1/* Generic ECOFF (Extended-COFF) routines. 2 Copyright 1990, 1991, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 3 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. 4 Original version by Per Bothner. 5 Full support added by Ian Lance Taylor, ian@cygnus.com. 6 7 This file is part of BFD, the Binary File Descriptor library. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 2 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ 22 23#include "bfd.h" 24#include "sysdep.h" 25#include "bfdlink.h" 26#include "libbfd.h" 27#include "aout/ar.h" 28#include "aout/ranlib.h" 29#include "aout/stab_gnu.h" 30 31/* FIXME: We need the definitions of N_SET[ADTB], but aout64.h defines 32 some other stuff which we don't want and which conflicts with stuff 33 we do want. */ 34#include "libaout.h" 35#include "aout/aout64.h" 36#undef N_ABS 37#undef exec_hdr 38#undef obj_sym_filepos 39 40#include "coff/internal.h" 41#include "coff/sym.h" 42#include "coff/symconst.h" 43#include "coff/ecoff.h" 44#include "libcoff.h" 45#include "libecoff.h" 46#include "libiberty.h" 47 48#define streq(a, b) (strcmp ((a), (b)) == 0) 49#define strneq(a, b, n) (strncmp ((a), (b), (n)) == 0) 50 51 52/* This stuff is somewhat copied from coffcode.h. */ 53static asection bfd_debug_section = 54{ 55 /* name, id, index, next, prev, flags, user_set_vma, */ 56 "*DEBUG*", 0, 0, NULL, NULL, 0, 0, 57 /* linker_mark, linker_has_input, gc_mark, gc_mark_from_eh, */ 58 0, 0, 1, 0, 59 /* segment_mark, sec_info_type, use_rela_p, has_tls_reloc, */ 60 0, 0, 0, 0, 61 /* has_gp_reloc, need_finalize_relax, reloc_done, */ 62 0, 0, 0, 63 /* vma, lma, size, rawsize, */ 64 0, 0, 0, 0, 65 /* output_offset, output_section, alignment_power, */ 66 0, NULL, 0, 67 /* relocation, orelocation, reloc_count, filepos, rel_filepos, */ 68 NULL, NULL, 0, 0, 0, 69 /* line_filepos, userdata, contents, lineno, lineno_count, */ 70 0, NULL, NULL, NULL, 0, 71 /* entsize, kept_section, moving_line_filepos, */ 72 0, NULL, 0, 73 /* target_index, used_by_bfd, constructor_chain, owner, */ 74 0, NULL, NULL, NULL, 75 /* symbol, */ 76 NULL, 77 /* symbol_ptr_ptr, */ 78 NULL, 79 /* map_head, map_tail */ 80 { NULL }, { NULL } 81}; 82 83/* Create an ECOFF object. */ 84 85bfd_boolean 86_bfd_ecoff_mkobject (bfd *abfd) 87{ 88 bfd_size_type amt = sizeof (ecoff_data_type); 89 90 abfd->tdata.ecoff_obj_data = bfd_zalloc (abfd, amt); 91 if (abfd->tdata.ecoff_obj_data == NULL) 92 return FALSE; 93 94 return TRUE; 95} 96 97/* This is a hook called by coff_real_object_p to create any backend 98 specific information. */ 99 100void * 101_bfd_ecoff_mkobject_hook (bfd *abfd, void * filehdr, void * aouthdr) 102{ 103 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; 104 struct internal_aouthdr *internal_a = (struct internal_aouthdr *) aouthdr; 105 ecoff_data_type *ecoff; 106 107 if (! _bfd_ecoff_mkobject (abfd)) 108 return NULL; 109 110 ecoff = ecoff_data (abfd); 111 ecoff->gp_size = 8; 112 ecoff->sym_filepos = internal_f->f_symptr; 113 114 if (internal_a != NULL) 115 { 116 int i; 117 118 ecoff->text_start = internal_a->text_start; 119 ecoff->text_end = internal_a->text_start + internal_a->tsize; 120 ecoff->gp = internal_a->gp_value; 121 ecoff->gprmask = internal_a->gprmask; 122 for (i = 0; i < 4; i++) 123 ecoff->cprmask[i] = internal_a->cprmask[i]; 124 ecoff->fprmask = internal_a->fprmask; 125 if (internal_a->magic == ECOFF_AOUT_ZMAGIC) 126 abfd->flags |= D_PAGED; 127 else 128 abfd->flags &=~ D_PAGED; 129 } 130 131 /* It turns out that no special action is required by the MIPS or 132 Alpha ECOFF backends. They have different information in the 133 a.out header, but we just copy it all (e.g., gprmask, cprmask and 134 fprmask) and let the swapping routines ensure that only relevant 135 information is written out. */ 136 137 return (void *) ecoff; 138} 139 140/* Initialize a new section. */ 141 142bfd_boolean 143_bfd_ecoff_new_section_hook (bfd *abfd, asection *section) 144{ 145 unsigned int i; 146 static struct 147 { 148 const char * name; 149 flagword flags; 150 } 151 section_flags [] = 152 { 153 { _TEXT, SEC_ALLOC | SEC_CODE | SEC_LOAD }, 154 { _INIT, SEC_ALLOC | SEC_CODE | SEC_LOAD }, 155 { _FINI, SEC_ALLOC | SEC_CODE | SEC_LOAD }, 156 { _DATA, SEC_ALLOC | SEC_DATA | SEC_LOAD }, 157 { _SDATA, SEC_ALLOC | SEC_DATA | SEC_LOAD }, 158 { _RDATA, SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY}, 159 { _LIT8, SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY}, 160 { _LIT4, SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY}, 161 { _RCONST, SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY}, 162 { _PDATA, SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY}, 163 { _BSS, SEC_ALLOC}, 164 { _SBSS, SEC_ALLOC}, 165 /* An Irix 4 shared libary. */ 166 { _LIB, SEC_COFF_SHARED_LIBRARY} 167 }; 168 169 section->alignment_power = 4; 170 171 for (i = 0; i < ARRAY_SIZE (section_flags); i++) 172 if (streq (section->name, section_flags[i].name)) 173 { 174 section->flags |= section_flags[i].flags; 175 break; 176 } 177 178 179 /* Probably any other section name is SEC_NEVER_LOAD, but I'm 180 uncertain about .init on some systems and I don't know how shared 181 libraries work. */ 182 183 return _bfd_generic_new_section_hook (abfd, section); 184} 185 186/* Determine the machine architecture and type. This is called from 187 the generic COFF routines. It is the inverse of ecoff_get_magic, 188 below. This could be an ECOFF backend routine, with one version 189 for each target, but there aren't all that many ECOFF targets. */ 190 191bfd_boolean 192_bfd_ecoff_set_arch_mach_hook (bfd *abfd, void * filehdr) 193{ 194 struct internal_filehdr *internal_f = filehdr; 195 enum bfd_architecture arch; 196 unsigned long mach; 197 198 switch (internal_f->f_magic) 199 { 200 case MIPS_MAGIC_1: 201 case MIPS_MAGIC_LITTLE: 202 case MIPS_MAGIC_BIG: 203 arch = bfd_arch_mips; 204 mach = bfd_mach_mips3000; 205 break; 206 207 case MIPS_MAGIC_LITTLE2: 208 case MIPS_MAGIC_BIG2: 209 /* MIPS ISA level 2: the r6000. */ 210 arch = bfd_arch_mips; 211 mach = bfd_mach_mips6000; 212 break; 213 214 case MIPS_MAGIC_LITTLE3: 215 case MIPS_MAGIC_BIG3: 216 /* MIPS ISA level 3: the r4000. */ 217 arch = bfd_arch_mips; 218 mach = bfd_mach_mips4000; 219 break; 220 221 case ALPHA_MAGIC: 222 arch = bfd_arch_alpha; 223 mach = 0; 224 break; 225 226 default: 227 arch = bfd_arch_obscure; 228 mach = 0; 229 break; 230 } 231 232 return bfd_default_set_arch_mach (abfd, arch, mach); 233} 234 235/* Get the magic number to use based on the architecture and machine. 236 This is the inverse of _bfd_ecoff_set_arch_mach_hook, above. */ 237 238static int 239ecoff_get_magic (bfd *abfd) 240{ 241 int big, little; 242 243 switch (bfd_get_arch (abfd)) 244 { 245 case bfd_arch_mips: 246 switch (bfd_get_mach (abfd)) 247 { 248 default: 249 case 0: 250 case bfd_mach_mips3000: 251 big = MIPS_MAGIC_BIG; 252 little = MIPS_MAGIC_LITTLE; 253 break; 254 255 case bfd_mach_mips6000: 256 big = MIPS_MAGIC_BIG2; 257 little = MIPS_MAGIC_LITTLE2; 258 break; 259 260 case bfd_mach_mips4000: 261 big = MIPS_MAGIC_BIG3; 262 little = MIPS_MAGIC_LITTLE3; 263 break; 264 } 265 266 return bfd_big_endian (abfd) ? big : little; 267 268 case bfd_arch_alpha: 269 return ALPHA_MAGIC; 270 271 default: 272 abort (); 273 return 0; 274 } 275} 276 277/* Get the section s_flags to use for a section. */ 278 279static long 280ecoff_sec_to_styp_flags (const char *name, flagword flags) 281{ 282 unsigned int i; 283 static struct 284 { 285 const char * name; 286 long flags; 287 } 288 styp_flags [] = 289 { 290 { _TEXT, STYP_TEXT }, 291 { _DATA, STYP_DATA }, 292 { _SDATA, STYP_SDATA }, 293 { _RDATA, STYP_RDATA }, 294 { _LITA, STYP_LITA }, 295 { _LIT8, STYP_LIT8 }, 296 { _LIT4, STYP_LIT4 }, 297 { _BSS, STYP_BSS }, 298 { _SBSS, STYP_SBSS }, 299 { _INIT, STYP_ECOFF_INIT }, 300 { _FINI, STYP_ECOFF_FINI }, 301 { _PDATA, STYP_PDATA }, 302 { _XDATA, STYP_XDATA }, 303 { _LIB, STYP_ECOFF_LIB }, 304 { _GOT, STYP_GOT }, 305 { _HASH, STYP_HASH }, 306 { _DYNAMIC, STYP_DYNAMIC }, 307 { _LIBLIST, STYP_LIBLIST }, 308 { _RELDYN, STYP_RELDYN }, 309 { _CONFLIC, STYP_CONFLIC }, 310 { _DYNSTR, STYP_DYNSTR }, 311 { _DYNSYM, STYP_DYNSYM }, 312 { _RCONST, STYP_RCONST } 313 }; 314 long styp = 0; 315 316 for (i = 0; i < ARRAY_SIZE (styp_flags); i++) 317 if (streq (name, styp_flags[i].name)) 318 { 319 styp = styp_flags[i].flags; 320 break; 321 } 322 323 if (styp == 0) 324 { 325 if (streq (name, _COMMENT)) 326 { 327 styp = STYP_COMMENT; 328 flags &=~ SEC_NEVER_LOAD; 329 } 330 else if (flags & SEC_CODE) 331 styp = STYP_TEXT; 332 else if (flags & SEC_DATA) 333 styp = STYP_DATA; 334 else if (flags & SEC_READONLY) 335 styp = STYP_RDATA; 336 else if (flags & SEC_LOAD) 337 styp = STYP_REG; 338 else 339 styp = STYP_BSS; 340 } 341 342 if (flags & SEC_NEVER_LOAD) 343 styp |= STYP_NOLOAD; 344 345 return styp; 346} 347 348/* Get the BFD flags to use for a section. */ 349 350bfd_boolean 351_bfd_ecoff_styp_to_sec_flags (bfd *abfd ATTRIBUTE_UNUSED, 352 void * hdr, 353 const char *name ATTRIBUTE_UNUSED, 354 asection *section ATTRIBUTE_UNUSED, 355 flagword * flags_ptr) 356{ 357 struct internal_scnhdr *internal_s = hdr; 358 long styp_flags = internal_s->s_flags; 359 flagword sec_flags = 0; 360 361 if (styp_flags & STYP_NOLOAD) 362 sec_flags |= SEC_NEVER_LOAD; 363 364 /* For 386 COFF, at least, an unloadable text or data section is 365 actually a shared library section. */ 366 if ((styp_flags & STYP_TEXT) 367 || (styp_flags & STYP_ECOFF_INIT) 368 || (styp_flags & STYP_ECOFF_FINI) 369 || (styp_flags & STYP_DYNAMIC) 370 || (styp_flags & STYP_LIBLIST) 371 || (styp_flags & STYP_RELDYN) 372 || styp_flags == STYP_CONFLIC 373 || (styp_flags & STYP_DYNSTR) 374 || (styp_flags & STYP_DYNSYM) 375 || (styp_flags & STYP_HASH)) 376 { 377 if (sec_flags & SEC_NEVER_LOAD) 378 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY; 379 else 380 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC; 381 } 382 else if ((styp_flags & STYP_DATA) 383 || (styp_flags & STYP_RDATA) 384 || (styp_flags & STYP_SDATA) 385 || styp_flags == STYP_PDATA 386 || styp_flags == STYP_XDATA 387 || (styp_flags & STYP_GOT) 388 || styp_flags == STYP_RCONST) 389 { 390 if (sec_flags & SEC_NEVER_LOAD) 391 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY; 392 else 393 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC; 394 if ((styp_flags & STYP_RDATA) 395 || styp_flags == STYP_PDATA 396 || styp_flags == STYP_RCONST) 397 sec_flags |= SEC_READONLY; 398 } 399 else if ((styp_flags & STYP_BSS) 400 || (styp_flags & STYP_SBSS)) 401 sec_flags |= SEC_ALLOC; 402 else if ((styp_flags & STYP_INFO) || styp_flags == STYP_COMMENT) 403 sec_flags |= SEC_NEVER_LOAD; 404 else if ((styp_flags & STYP_LITA) 405 || (styp_flags & STYP_LIT8) 406 || (styp_flags & STYP_LIT4)) 407 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC | SEC_READONLY; 408 else if (styp_flags & STYP_ECOFF_LIB) 409 sec_flags |= SEC_COFF_SHARED_LIBRARY; 410 else 411 sec_flags |= SEC_ALLOC | SEC_LOAD; 412 413 * flags_ptr = sec_flags; 414 return TRUE; 415} 416 417/* Read in the symbolic header for an ECOFF object file. */ 418 419static bfd_boolean 420ecoff_slurp_symbolic_header (bfd *abfd) 421{ 422 const struct ecoff_backend_data * const backend = ecoff_backend (abfd); 423 bfd_size_type external_hdr_size; 424 void * raw = NULL; 425 HDRR *internal_symhdr; 426 427 /* See if we've already read it in. */ 428 if (ecoff_data (abfd)->debug_info.symbolic_header.magic == 429 backend->debug_swap.sym_magic) 430 return TRUE; 431 432 /* See whether there is a symbolic header. */ 433 if (ecoff_data (abfd)->sym_filepos == 0) 434 { 435 bfd_get_symcount (abfd) = 0; 436 return TRUE; 437 } 438 439 /* At this point bfd_get_symcount (abfd) holds the number of symbols 440 as read from the file header, but on ECOFF this is always the 441 size of the symbolic information header. It would be cleaner to 442 handle this when we first read the file in coffgen.c. */ 443 external_hdr_size = backend->debug_swap.external_hdr_size; 444 if (bfd_get_symcount (abfd) != external_hdr_size) 445 { 446 bfd_set_error (bfd_error_bad_value); 447 return FALSE; 448 } 449 450 /* Read the symbolic information header. */ 451 raw = bfd_malloc (external_hdr_size); 452 if (raw == NULL) 453 goto error_return; 454 455 if (bfd_seek (abfd, ecoff_data (abfd)->sym_filepos, SEEK_SET) != 0 456 || bfd_bread (raw, external_hdr_size, abfd) != external_hdr_size) 457 goto error_return; 458 internal_symhdr = &ecoff_data (abfd)->debug_info.symbolic_header; 459 (*backend->debug_swap.swap_hdr_in) (abfd, raw, internal_symhdr); 460 461 if (internal_symhdr->magic != backend->debug_swap.sym_magic) 462 { 463 bfd_set_error (bfd_error_bad_value); 464 goto error_return; 465 } 466 467 /* Now we can get the correct number of symbols. */ 468 bfd_get_symcount (abfd) = (internal_symhdr->isymMax 469 + internal_symhdr->iextMax); 470 471 if (raw != NULL) 472 free (raw); 473 return TRUE; 474 error_return: 475 if (raw != NULL) 476 free (raw); 477 return FALSE; 478} 479 480/* Read in and swap the important symbolic information for an ECOFF 481 object file. This is called by gdb via the read_debug_info entry 482 point in the backend structure. */ 483 484bfd_boolean 485_bfd_ecoff_slurp_symbolic_info (bfd *abfd, 486 asection *ignore ATTRIBUTE_UNUSED, 487 struct ecoff_debug_info *debug) 488{ 489 const struct ecoff_backend_data * const backend = ecoff_backend (abfd); 490 HDRR *internal_symhdr; 491 bfd_size_type raw_base; 492 bfd_size_type raw_size; 493 void * raw; 494 bfd_size_type external_fdr_size; 495 char *fraw_src; 496 char *fraw_end; 497 struct fdr *fdr_ptr; 498 bfd_size_type raw_end; 499 bfd_size_type cb_end; 500 bfd_size_type amt; 501 file_ptr pos; 502 503 BFD_ASSERT (debug == &ecoff_data (abfd)->debug_info); 504 505 /* Check whether we've already gotten it, and whether there's any to 506 get. */ 507 if (ecoff_data (abfd)->raw_syments != NULL) 508 return TRUE; 509 if (ecoff_data (abfd)->sym_filepos == 0) 510 { 511 bfd_get_symcount (abfd) = 0; 512 return TRUE; 513 } 514 515 if (! ecoff_slurp_symbolic_header (abfd)) 516 return FALSE; 517 518 internal_symhdr = &debug->symbolic_header; 519 520 /* Read all the symbolic information at once. */ 521 raw_base = (ecoff_data (abfd)->sym_filepos 522 + backend->debug_swap.external_hdr_size); 523 524 /* Alpha ecoff makes the determination of raw_size difficult. It has 525 an undocumented debug data section between the symhdr and the first 526 documented section. And the ordering of the sections varies between 527 statically and dynamically linked executables. 528 If bfd supports SEEK_END someday, this code could be simplified. */ 529 raw_end = 0; 530 531#define UPDATE_RAW_END(start, count, size) \ 532 cb_end = internal_symhdr->start + internal_symhdr->count * (size); \ 533 if (cb_end > raw_end) \ 534 raw_end = cb_end 535 536 UPDATE_RAW_END (cbLineOffset, cbLine, sizeof (unsigned char)); 537 UPDATE_RAW_END (cbDnOffset, idnMax, backend->debug_swap.external_dnr_size); 538 UPDATE_RAW_END (cbPdOffset, ipdMax, backend->debug_swap.external_pdr_size); 539 UPDATE_RAW_END (cbSymOffset, isymMax, backend->debug_swap.external_sym_size); 540 /* eraxxon@alumni.rice.edu: ioptMax refers to the size of the 541 optimization symtab, not the number of entries. */ 542 UPDATE_RAW_END (cbOptOffset, ioptMax, sizeof (char)); 543 UPDATE_RAW_END (cbAuxOffset, iauxMax, sizeof (union aux_ext)); 544 UPDATE_RAW_END (cbSsOffset, issMax, sizeof (char)); 545 UPDATE_RAW_END (cbSsExtOffset, issExtMax, sizeof (char)); 546 UPDATE_RAW_END (cbFdOffset, ifdMax, backend->debug_swap.external_fdr_size); 547 UPDATE_RAW_END (cbRfdOffset, crfd, backend->debug_swap.external_rfd_size); 548 UPDATE_RAW_END (cbExtOffset, iextMax, backend->debug_swap.external_ext_size); 549 550#undef UPDATE_RAW_END 551 552 raw_size = raw_end - raw_base; 553 if (raw_size == 0) 554 { 555 ecoff_data (abfd)->sym_filepos = 0; 556 return TRUE; 557 } 558 raw = bfd_alloc (abfd, raw_size); 559 if (raw == NULL) 560 return FALSE; 561 562 pos = ecoff_data (abfd)->sym_filepos; 563 pos += backend->debug_swap.external_hdr_size; 564 if (bfd_seek (abfd, pos, SEEK_SET) != 0 565 || bfd_bread (raw, raw_size, abfd) != raw_size) 566 { 567 bfd_release (abfd, raw); 568 return FALSE; 569 } 570 571 ecoff_data (abfd)->raw_syments = raw; 572 573 /* Get pointers for the numeric offsets in the HDRR structure. */ 574#define FIX(off1, off2, type) \ 575 if (internal_symhdr->off1 == 0) \ 576 debug->off2 = NULL; \ 577 else \ 578 debug->off2 = (type) ((char *) raw \ 579 + (internal_symhdr->off1 \ 580 - raw_base)) 581 582 FIX (cbLineOffset, line, unsigned char *); 583 FIX (cbDnOffset, external_dnr, void *); 584 FIX (cbPdOffset, external_pdr, void *); 585 FIX (cbSymOffset, external_sym, void *); 586 FIX (cbOptOffset, external_opt, void *); 587 FIX (cbAuxOffset, external_aux, union aux_ext *); 588 FIX (cbSsOffset, ss, char *); 589 FIX (cbSsExtOffset, ssext, char *); 590 FIX (cbFdOffset, external_fdr, void *); 591 FIX (cbRfdOffset, external_rfd, void *); 592 FIX (cbExtOffset, external_ext, void *); 593#undef FIX 594 595 /* I don't want to always swap all the data, because it will just 596 waste time and most programs will never look at it. The only 597 time the linker needs most of the debugging information swapped 598 is when linking big-endian and little-endian MIPS object files 599 together, which is not a common occurrence. 600 601 We need to look at the fdr to deal with a lot of information in 602 the symbols, so we swap them here. */ 603 amt = internal_symhdr->ifdMax; 604 amt *= sizeof (struct fdr); 605 debug->fdr = bfd_alloc (abfd, amt); 606 if (debug->fdr == NULL) 607 return FALSE; 608 external_fdr_size = backend->debug_swap.external_fdr_size; 609 fdr_ptr = debug->fdr; 610 fraw_src = (char *) debug->external_fdr; 611 fraw_end = fraw_src + internal_symhdr->ifdMax * external_fdr_size; 612 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++) 613 (*backend->debug_swap.swap_fdr_in) (abfd, (void *) fraw_src, fdr_ptr); 614 615 return TRUE; 616} 617 618/* ECOFF symbol table routines. The ECOFF symbol table is described 619 in gcc/mips-tfile.c. */ 620 621/* ECOFF uses two common sections. One is the usual one, and the 622 other is for small objects. All the small objects are kept 623 together, and then referenced via the gp pointer, which yields 624 faster assembler code. This is what we use for the small common 625 section. */ 626static asection ecoff_scom_section; 627static asymbol ecoff_scom_symbol; 628static asymbol *ecoff_scom_symbol_ptr; 629 630/* Create an empty symbol. */ 631 632asymbol * 633_bfd_ecoff_make_empty_symbol (bfd *abfd) 634{ 635 ecoff_symbol_type *new; 636 bfd_size_type amt = sizeof (ecoff_symbol_type); 637 638 new = bfd_zalloc (abfd, amt); 639 if (new == NULL) 640 return NULL; 641 new->symbol.section = NULL; 642 new->fdr = NULL; 643 new->local = FALSE; 644 new->native = NULL; 645 new->symbol.the_bfd = abfd; 646 return &new->symbol; 647} 648 649/* Set the BFD flags and section for an ECOFF symbol. */ 650 651static bfd_boolean 652ecoff_set_symbol_info (bfd *abfd, 653 SYMR *ecoff_sym, 654 asymbol *asym, 655 int ext, 656 int weak) 657{ 658 asym->the_bfd = abfd; 659 asym->value = ecoff_sym->value; 660 asym->section = &bfd_debug_section; 661 asym->udata.i = 0; 662 663 /* Most symbol types are just for debugging. */ 664 switch (ecoff_sym->st) 665 { 666 case stGlobal: 667 case stStatic: 668 case stLabel: 669 case stProc: 670 case stStaticProc: 671 break; 672 case stNil: 673 if (ECOFF_IS_STAB (ecoff_sym)) 674 { 675 asym->flags = BSF_DEBUGGING; 676 return TRUE; 677 } 678 break; 679 default: 680 asym->flags = BSF_DEBUGGING; 681 return TRUE; 682 } 683 684 if (weak) 685 asym->flags = BSF_EXPORT | BSF_WEAK; 686 else if (ext) 687 asym->flags = BSF_EXPORT | BSF_GLOBAL; 688 else 689 { 690 asym->flags = BSF_LOCAL; 691 /* Normally, a local stProc symbol will have a corresponding 692 external symbol. We mark the local symbol as a debugging 693 symbol, in order to prevent nm from printing both out. 694 Similarly, we mark stLabel and stabs symbols as debugging 695 symbols. In both cases, we do want to set the value 696 correctly based on the symbol class. */ 697 if (ecoff_sym->st == stProc 698 || ecoff_sym->st == stLabel 699 || ECOFF_IS_STAB (ecoff_sym)) 700 asym->flags |= BSF_DEBUGGING; 701 } 702 703 if (ecoff_sym->st == stProc || ecoff_sym->st == stStaticProc) 704 asym->flags |= BSF_FUNCTION; 705 706 switch (ecoff_sym->sc) 707 { 708 case scNil: 709 /* Used for compiler generated labels. Leave them in the 710 debugging section, and mark them as local. If BSF_DEBUGGING 711 is set, then nm does not display them for some reason. If no 712 flags are set then the linker whines about them. */ 713 asym->flags = BSF_LOCAL; 714 break; 715 case scText: 716 asym->section = bfd_make_section_old_way (abfd, _TEXT); 717 asym->value -= asym->section->vma; 718 break; 719 case scData: 720 asym->section = bfd_make_section_old_way (abfd, _DATA); 721 asym->value -= asym->section->vma; 722 break; 723 case scBss: 724 asym->section = bfd_make_section_old_way (abfd, _BSS); 725 asym->value -= asym->section->vma; 726 break; 727 case scRegister: 728 asym->flags = BSF_DEBUGGING; 729 break; 730 case scAbs: 731 asym->section = bfd_abs_section_ptr; 732 break; 733 case scUndefined: 734 asym->section = bfd_und_section_ptr; 735 asym->flags = 0; 736 asym->value = 0; 737 break; 738 case scCdbLocal: 739 case scBits: 740 case scCdbSystem: 741 case scRegImage: 742 case scInfo: 743 case scUserStruct: 744 asym->flags = BSF_DEBUGGING; 745 break; 746 case scSData: 747 asym->section = bfd_make_section_old_way (abfd, ".sdata"); 748 asym->value -= asym->section->vma; 749 break; 750 case scSBss: 751 asym->section = bfd_make_section_old_way (abfd, ".sbss"); 752 asym->value -= asym->section->vma; 753 break; 754 case scRData: 755 asym->section = bfd_make_section_old_way (abfd, ".rdata"); 756 asym->value -= asym->section->vma; 757 break; 758 case scVar: 759 asym->flags = BSF_DEBUGGING; 760 break; 761 case scCommon: 762 if (asym->value > ecoff_data (abfd)->gp_size) 763 { 764 asym->section = bfd_com_section_ptr; 765 asym->flags = 0; 766 break; 767 } 768 /* Fall through. */ 769 case scSCommon: 770 if (ecoff_scom_section.name == NULL) 771 { 772 /* Initialize the small common section. */ 773 ecoff_scom_section.name = SCOMMON; 774 ecoff_scom_section.flags = SEC_IS_COMMON; 775 ecoff_scom_section.output_section = &ecoff_scom_section; 776 ecoff_scom_section.symbol = &ecoff_scom_symbol; 777 ecoff_scom_section.symbol_ptr_ptr = &ecoff_scom_symbol_ptr; 778 ecoff_scom_symbol.name = SCOMMON; 779 ecoff_scom_symbol.flags = BSF_SECTION_SYM; 780 ecoff_scom_symbol.section = &ecoff_scom_section; 781 ecoff_scom_symbol_ptr = &ecoff_scom_symbol; 782 } 783 asym->section = &ecoff_scom_section; 784 asym->flags = 0; 785 break; 786 case scVarRegister: 787 case scVariant: 788 asym->flags = BSF_DEBUGGING; 789 break; 790 case scSUndefined: 791 asym->section = bfd_und_section_ptr; 792 asym->flags = 0; 793 asym->value = 0; 794 break; 795 case scInit: 796 asym->section = bfd_make_section_old_way (abfd, ".init"); 797 asym->value -= asym->section->vma; 798 break; 799 case scBasedVar: 800 case scXData: 801 case scPData: 802 asym->flags = BSF_DEBUGGING; 803 break; 804 case scFini: 805 asym->section = bfd_make_section_old_way (abfd, ".fini"); 806 asym->value -= asym->section->vma; 807 break; 808 case scRConst: 809 asym->section = bfd_make_section_old_way (abfd, ".rconst"); 810 asym->value -= asym->section->vma; 811 break; 812 default: 813 break; 814 } 815 816 /* Look for special constructors symbols and make relocation entries 817 in a special construction section. These are produced by the 818 -fgnu-linker argument to g++. */ 819 if (ECOFF_IS_STAB (ecoff_sym)) 820 { 821 switch (ECOFF_UNMARK_STAB (ecoff_sym->index)) 822 { 823 default: 824 break; 825 826 case N_SETA: 827 case N_SETT: 828 case N_SETD: 829 case N_SETB: 830 /* Mark the symbol as a constructor. */ 831 asym->flags |= BSF_CONSTRUCTOR; 832 break; 833 } 834 } 835 return TRUE; 836} 837 838/* Read an ECOFF symbol table. */ 839 840bfd_boolean 841_bfd_ecoff_slurp_symbol_table (bfd *abfd) 842{ 843 const struct ecoff_backend_data * const backend = ecoff_backend (abfd); 844 const bfd_size_type external_ext_size 845 = backend->debug_swap.external_ext_size; 846 const bfd_size_type external_sym_size 847 = backend->debug_swap.external_sym_size; 848 void (* const swap_ext_in) (bfd *, void *, EXTR *) 849 = backend->debug_swap.swap_ext_in; 850 void (* const swap_sym_in) (bfd *, void *, SYMR *) 851 = backend->debug_swap.swap_sym_in; 852 bfd_size_type internal_size; 853 ecoff_symbol_type *internal; 854 ecoff_symbol_type *internal_ptr; 855 char *eraw_src; 856 char *eraw_end; 857 FDR *fdr_ptr; 858 FDR *fdr_end; 859 860 /* If we've already read in the symbol table, do nothing. */ 861 if (ecoff_data (abfd)->canonical_symbols != NULL) 862 return TRUE; 863 864 /* Get the symbolic information. */ 865 if (! _bfd_ecoff_slurp_symbolic_info (abfd, NULL, 866 &ecoff_data (abfd)->debug_info)) 867 return FALSE; 868 if (bfd_get_symcount (abfd) == 0) 869 return TRUE; 870 871 internal_size = bfd_get_symcount (abfd); 872 internal_size *= sizeof (ecoff_symbol_type); 873 internal = bfd_alloc (abfd, internal_size); 874 if (internal == NULL) 875 return FALSE; 876 877 internal_ptr = internal; 878 eraw_src = (char *) ecoff_data (abfd)->debug_info.external_ext; 879 eraw_end = (eraw_src 880 + (ecoff_data (abfd)->debug_info.symbolic_header.iextMax 881 * external_ext_size)); 882 for (; eraw_src < eraw_end; eraw_src += external_ext_size, internal_ptr++) 883 { 884 EXTR internal_esym; 885 886 (*swap_ext_in) (abfd, (void *) eraw_src, &internal_esym); 887 internal_ptr->symbol.name = (ecoff_data (abfd)->debug_info.ssext 888 + internal_esym.asym.iss); 889 if (!ecoff_set_symbol_info (abfd, &internal_esym.asym, 890 &internal_ptr->symbol, 1, 891 internal_esym.weakext)) 892 return FALSE; 893 /* The alpha uses a negative ifd field for section symbols. */ 894 if (internal_esym.ifd >= 0) 895 internal_ptr->fdr = (ecoff_data (abfd)->debug_info.fdr 896 + internal_esym.ifd); 897 else 898 internal_ptr->fdr = NULL; 899 internal_ptr->local = FALSE; 900 internal_ptr->native = (void *) eraw_src; 901 } 902 903 /* The local symbols must be accessed via the fdr's, because the 904 string and aux indices are relative to the fdr information. */ 905 fdr_ptr = ecoff_data (abfd)->debug_info.fdr; 906 fdr_end = fdr_ptr + ecoff_data (abfd)->debug_info.symbolic_header.ifdMax; 907 for (; fdr_ptr < fdr_end; fdr_ptr++) 908 { 909 char *lraw_src; 910 char *lraw_end; 911 912 lraw_src = ((char *) ecoff_data (abfd)->debug_info.external_sym 913 + fdr_ptr->isymBase * external_sym_size); 914 lraw_end = lraw_src + fdr_ptr->csym * external_sym_size; 915 for (; 916 lraw_src < lraw_end; 917 lraw_src += external_sym_size, internal_ptr++) 918 { 919 SYMR internal_sym; 920 921 (*swap_sym_in) (abfd, (void *) lraw_src, &internal_sym); 922 internal_ptr->symbol.name = (ecoff_data (abfd)->debug_info.ss 923 + fdr_ptr->issBase 924 + internal_sym.iss); 925 if (!ecoff_set_symbol_info (abfd, &internal_sym, 926 &internal_ptr->symbol, 0, 0)) 927 return FALSE; 928 internal_ptr->fdr = fdr_ptr; 929 internal_ptr->local = TRUE; 930 internal_ptr->native = (void *) lraw_src; 931 } 932 } 933 934 ecoff_data (abfd)->canonical_symbols = internal; 935 936 return TRUE; 937} 938 939/* Return the amount of space needed for the canonical symbols. */ 940 941long 942_bfd_ecoff_get_symtab_upper_bound (bfd *abfd) 943{ 944 if (! _bfd_ecoff_slurp_symbolic_info (abfd, NULL, 945 &ecoff_data (abfd)->debug_info)) 946 return -1; 947 948 if (bfd_get_symcount (abfd) == 0) 949 return 0; 950 951 return (bfd_get_symcount (abfd) + 1) * (sizeof (ecoff_symbol_type *)); 952} 953 954/* Get the canonical symbols. */ 955 956long 957_bfd_ecoff_canonicalize_symtab (bfd *abfd, asymbol **alocation) 958{ 959 unsigned int counter = 0; 960 ecoff_symbol_type *symbase; 961 ecoff_symbol_type **location = (ecoff_symbol_type **) alocation; 962 963 if (! _bfd_ecoff_slurp_symbol_table (abfd)) 964 return -1; 965 if (bfd_get_symcount (abfd) == 0) 966 return 0; 967 968 symbase = ecoff_data (abfd)->canonical_symbols; 969 while (counter < bfd_get_symcount (abfd)) 970 { 971 *(location++) = symbase++; 972 counter++; 973 } 974 *location++ = NULL; 975 return bfd_get_symcount (abfd); 976} 977 978/* Turn ECOFF type information into a printable string. 979 ecoff_emit_aggregate and ecoff_type_to_string are from 980 gcc/mips-tdump.c, with swapping added and used_ptr removed. */ 981 982/* Write aggregate information to a string. */ 983 984static void 985ecoff_emit_aggregate (bfd *abfd, 986 FDR *fdr, 987 char *string, 988 RNDXR *rndx, 989 long isym, 990 const char *which) 991{ 992 const struct ecoff_debug_swap * const debug_swap = 993 &ecoff_backend (abfd)->debug_swap; 994 struct ecoff_debug_info * const debug_info = &ecoff_data (abfd)->debug_info; 995 unsigned int ifd = rndx->rfd; 996 unsigned int indx = rndx->index; 997 const char *name; 998 999 if (ifd == 0xfff) 1000 ifd = isym; 1001 1002 /* An ifd of -1 is an opaque type. An escaped index of 0 is a 1003 struct return type of a procedure compiled without -g. */ 1004 if (ifd == 0xffffffff 1005 || (rndx->rfd == 0xfff && indx == 0)) 1006 name = "<undefined>"; 1007 else if (indx == indexNil) 1008 name = "<no name>"; 1009 else 1010 { 1011 SYMR sym; 1012 1013 if (debug_info->external_rfd == NULL) 1014 fdr = debug_info->fdr + ifd; 1015 else 1016 { 1017 RFDT rfd; 1018 1019 (*debug_swap->swap_rfd_in) (abfd, 1020 ((char *) debug_info->external_rfd 1021 + ((fdr->rfdBase + ifd) 1022 * debug_swap->external_rfd_size)), 1023 &rfd); 1024 fdr = debug_info->fdr + rfd; 1025 } 1026 1027 indx += fdr->isymBase; 1028 1029 (*debug_swap->swap_sym_in) (abfd, 1030 ((char *) debug_info->external_sym 1031 + indx * debug_swap->external_sym_size), 1032 &sym); 1033 1034 name = debug_info->ss + fdr->issBase + sym.iss; 1035 } 1036 1037 sprintf (string, 1038 "%s %s { ifd = %u, index = %lu }", 1039 which, name, ifd, 1040 ((long) indx 1041 + debug_info->symbolic_header.iextMax)); 1042} 1043 1044/* Convert the type information to string format. */ 1045 1046static char * 1047ecoff_type_to_string (bfd *abfd, FDR *fdr, unsigned int indx) 1048{ 1049 union aux_ext *aux_ptr; 1050 int bigendian; 1051 AUXU u; 1052 struct qual 1053 { 1054 unsigned int type; 1055 int low_bound; 1056 int high_bound; 1057 int stride; 1058 } qualifiers[7]; 1059 unsigned int basic_type; 1060 int i; 1061 char buffer1[1024]; 1062 static char buffer2[1024]; 1063 char *p1 = buffer1; 1064 char *p2 = buffer2; 1065 RNDXR rndx; 1066 1067 aux_ptr = ecoff_data (abfd)->debug_info.external_aux + fdr->iauxBase; 1068 bigendian = fdr->fBigendian; 1069 1070 for (i = 0; i < 7; i++) 1071 { 1072 qualifiers[i].low_bound = 0; 1073 qualifiers[i].high_bound = 0; 1074 qualifiers[i].stride = 0; 1075 } 1076 1077 if (AUX_GET_ISYM (bigendian, &aux_ptr[indx]) == (bfd_vma) -1) 1078 return "-1 (no type)"; 1079 _bfd_ecoff_swap_tir_in (bigendian, &aux_ptr[indx++].a_ti, &u.ti); 1080 1081 basic_type = u.ti.bt; 1082 qualifiers[0].type = u.ti.tq0; 1083 qualifiers[1].type = u.ti.tq1; 1084 qualifiers[2].type = u.ti.tq2; 1085 qualifiers[3].type = u.ti.tq3; 1086 qualifiers[4].type = u.ti.tq4; 1087 qualifiers[5].type = u.ti.tq5; 1088 qualifiers[6].type = tqNil; 1089 1090 /* Go get the basic type. */ 1091 switch (basic_type) 1092 { 1093 case btNil: /* Undefined. */ 1094 strcpy (p1, "nil"); 1095 break; 1096 1097 case btAdr: /* Address - integer same size as pointer. */ 1098 strcpy (p1, "address"); 1099 break; 1100 1101 case btChar: /* Character. */ 1102 strcpy (p1, "char"); 1103 break; 1104 1105 case btUChar: /* Unsigned character. */ 1106 strcpy (p1, "unsigned char"); 1107 break; 1108 1109 case btShort: /* Short. */ 1110 strcpy (p1, "short"); 1111 break; 1112 1113 case btUShort: /* Unsigned short. */ 1114 strcpy (p1, "unsigned short"); 1115 break; 1116 1117 case btInt: /* Int. */ 1118 strcpy (p1, "int"); 1119 break; 1120 1121 case btUInt: /* Unsigned int. */ 1122 strcpy (p1, "unsigned int"); 1123 break; 1124 1125 case btLong: /* Long. */ 1126 strcpy (p1, "long"); 1127 break; 1128 1129 case btULong: /* Unsigned long. */ 1130 strcpy (p1, "unsigned long"); 1131 break; 1132 1133 case btFloat: /* Float (real). */ 1134 strcpy (p1, "float"); 1135 break; 1136 1137 case btDouble: /* Double (real). */ 1138 strcpy (p1, "double"); 1139 break; 1140 1141 /* Structures add 1-2 aux words: 1142 1st word is [ST_RFDESCAPE, offset] pointer to struct def; 1143 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */ 1144 1145 case btStruct: /* Structure (Record). */ 1146 _bfd_ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx); 1147 ecoff_emit_aggregate (abfd, fdr, p1, &rndx, 1148 (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]), 1149 "struct"); 1150 indx++; /* Skip aux words. */ 1151 break; 1152 1153 /* Unions add 1-2 aux words: 1154 1st word is [ST_RFDESCAPE, offset] pointer to union def; 1155 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */ 1156 1157 case btUnion: /* Union. */ 1158 _bfd_ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx); 1159 ecoff_emit_aggregate (abfd, fdr, p1, &rndx, 1160 (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]), 1161 "union"); 1162 indx++; /* Skip aux words. */ 1163 break; 1164 1165 /* Enumerations add 1-2 aux words: 1166 1st word is [ST_RFDESCAPE, offset] pointer to enum def; 1167 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */ 1168 1169 case btEnum: /* Enumeration. */ 1170 _bfd_ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx); 1171 ecoff_emit_aggregate (abfd, fdr, p1, &rndx, 1172 (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]), 1173 "enum"); 1174 indx++; /* Skip aux words. */ 1175 break; 1176 1177 case btTypedef: /* Defined via a typedef, isymRef points. */ 1178 strcpy (p1, "typedef"); 1179 break; 1180 1181 case btRange: /* Subrange of int. */ 1182 strcpy (p1, "subrange"); 1183 break; 1184 1185 case btSet: /* Pascal sets. */ 1186 strcpy (p1, "set"); 1187 break; 1188 1189 case btComplex: /* Fortran complex. */ 1190 strcpy (p1, "complex"); 1191 break; 1192 1193 case btDComplex: /* Fortran double complex. */ 1194 strcpy (p1, "double complex"); 1195 break; 1196 1197 case btIndirect: /* Forward or unnamed typedef. */ 1198 strcpy (p1, "forward/unamed typedef"); 1199 break; 1200 1201 case btFixedDec: /* Fixed Decimal. */ 1202 strcpy (p1, "fixed decimal"); 1203 break; 1204 1205 case btFloatDec: /* Float Decimal. */ 1206 strcpy (p1, "float decimal"); 1207 break; 1208 1209 case btString: /* Varying Length Character String. */ 1210 strcpy (p1, "string"); 1211 break; 1212 1213 case btBit: /* Aligned Bit String. */ 1214 strcpy (p1, "bit"); 1215 break; 1216 1217 case btPicture: /* Picture. */ 1218 strcpy (p1, "picture"); 1219 break; 1220 1221 case btVoid: /* Void. */ 1222 strcpy (p1, "void"); 1223 break; 1224 1225 default: 1226 sprintf (p1, _("Unknown basic type %d"), (int) basic_type); 1227 break; 1228 } 1229 1230 p1 += strlen (buffer1); 1231 1232 /* If this is a bitfield, get the bitsize. */ 1233 if (u.ti.fBitfield) 1234 { 1235 int bitsize; 1236 1237 bitsize = AUX_GET_WIDTH (bigendian, &aux_ptr[indx++]); 1238 sprintf (p1, " : %d", bitsize); 1239 p1 += strlen (buffer1); 1240 } 1241 1242 /* Deal with any qualifiers. */ 1243 if (qualifiers[0].type != tqNil) 1244 { 1245 /* Snarf up any array bounds in the correct order. Arrays 1246 store 5 successive words in the aux. table: 1247 word 0 RNDXR to type of the bounds (ie, int) 1248 word 1 Current file descriptor index 1249 word 2 low bound 1250 word 3 high bound (or -1 if []) 1251 word 4 stride size in bits. */ 1252 for (i = 0; i < 7; i++) 1253 { 1254 if (qualifiers[i].type == tqArray) 1255 { 1256 qualifiers[i].low_bound = 1257 AUX_GET_DNLOW (bigendian, &aux_ptr[indx+2]); 1258 qualifiers[i].high_bound = 1259 AUX_GET_DNHIGH (bigendian, &aux_ptr[indx+3]); 1260 qualifiers[i].stride = 1261 AUX_GET_WIDTH (bigendian, &aux_ptr[indx+4]); 1262 indx += 5; 1263 } 1264 } 1265 1266 /* Now print out the qualifiers. */ 1267 for (i = 0; i < 6; i++) 1268 { 1269 switch (qualifiers[i].type) 1270 { 1271 case tqNil: 1272 case tqMax: 1273 break; 1274 1275 case tqPtr: 1276 strcpy (p2, "ptr to "); 1277 p2 += sizeof ("ptr to ")-1; 1278 break; 1279 1280 case tqVol: 1281 strcpy (p2, "volatile "); 1282 p2 += sizeof ("volatile ")-1; 1283 break; 1284 1285 case tqFar: 1286 strcpy (p2, "far "); 1287 p2 += sizeof ("far ")-1; 1288 break; 1289 1290 case tqProc: 1291 strcpy (p2, "func. ret. "); 1292 p2 += sizeof ("func. ret. "); 1293 break; 1294 1295 case tqArray: 1296 { 1297 int first_array = i; 1298 int j; 1299 1300 /* Print array bounds reversed (ie, in the order the C 1301 programmer writes them). C is such a fun language.... */ 1302 while (i < 5 && qualifiers[i+1].type == tqArray) 1303 i++; 1304 1305 for (j = i; j >= first_array; j--) 1306 { 1307 strcpy (p2, "array ["); 1308 p2 += sizeof ("array [")-1; 1309 if (qualifiers[j].low_bound != 0) 1310 sprintf (p2, 1311 "%ld:%ld {%ld bits}", 1312 (long) qualifiers[j].low_bound, 1313 (long) qualifiers[j].high_bound, 1314 (long) qualifiers[j].stride); 1315 1316 else if (qualifiers[j].high_bound != -1) 1317 sprintf (p2, 1318 "%ld {%ld bits}", 1319 (long) (qualifiers[j].high_bound + 1), 1320 (long) (qualifiers[j].stride)); 1321 1322 else 1323 sprintf (p2, " {%ld bits}", (long) (qualifiers[j].stride)); 1324 1325 p2 += strlen (p2); 1326 strcpy (p2, "] of "); 1327 p2 += sizeof ("] of ")-1; 1328 } 1329 } 1330 break; 1331 } 1332 } 1333 } 1334 1335 strcpy (p2, buffer1); 1336 return buffer2; 1337} 1338 1339/* Return information about ECOFF symbol SYMBOL in RET. */ 1340 1341void 1342_bfd_ecoff_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED, 1343 asymbol *symbol, 1344 symbol_info *ret) 1345{ 1346 bfd_symbol_info (symbol, ret); 1347} 1348 1349/* Return whether this is a local label. */ 1350 1351bfd_boolean 1352_bfd_ecoff_bfd_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED, 1353 const char *name) 1354{ 1355 return name[0] == '$'; 1356} 1357 1358/* Print information about an ECOFF symbol. */ 1359 1360void 1361_bfd_ecoff_print_symbol (bfd *abfd, 1362 void * filep, 1363 asymbol *symbol, 1364 bfd_print_symbol_type how) 1365{ 1366 const struct ecoff_debug_swap * const debug_swap 1367 = &ecoff_backend (abfd)->debug_swap; 1368 FILE *file = (FILE *)filep; 1369 1370 switch (how) 1371 { 1372 case bfd_print_symbol_name: 1373 fprintf (file, "%s", symbol->name); 1374 break; 1375 case bfd_print_symbol_more: 1376 if (ecoffsymbol (symbol)->local) 1377 { 1378 SYMR ecoff_sym; 1379 1380 (*debug_swap->swap_sym_in) (abfd, ecoffsymbol (symbol)->native, 1381 &ecoff_sym); 1382 fprintf (file, "ecoff local "); 1383 fprintf_vma (file, (bfd_vma) ecoff_sym.value); 1384 fprintf (file, " %x %x", (unsigned) ecoff_sym.st, 1385 (unsigned) ecoff_sym.sc); 1386 } 1387 else 1388 { 1389 EXTR ecoff_ext; 1390 1391 (*debug_swap->swap_ext_in) (abfd, ecoffsymbol (symbol)->native, 1392 &ecoff_ext); 1393 fprintf (file, "ecoff extern "); 1394 fprintf_vma (file, (bfd_vma) ecoff_ext.asym.value); 1395 fprintf (file, " %x %x", (unsigned) ecoff_ext.asym.st, 1396 (unsigned) ecoff_ext.asym.sc); 1397 } 1398 break; 1399 case bfd_print_symbol_all: 1400 /* Print out the symbols in a reasonable way. */ 1401 { 1402 char type; 1403 int pos; 1404 EXTR ecoff_ext; 1405 char jmptbl; 1406 char cobol_main; 1407 char weakext; 1408 1409 if (ecoffsymbol (symbol)->local) 1410 { 1411 (*debug_swap->swap_sym_in) (abfd, ecoffsymbol (symbol)->native, 1412 &ecoff_ext.asym); 1413 type = 'l'; 1414 pos = ((((char *) ecoffsymbol (symbol)->native 1415 - (char *) ecoff_data (abfd)->debug_info.external_sym) 1416 / debug_swap->external_sym_size) 1417 + ecoff_data (abfd)->debug_info.symbolic_header.iextMax); 1418 jmptbl = ' '; 1419 cobol_main = ' '; 1420 weakext = ' '; 1421 } 1422 else 1423 { 1424 (*debug_swap->swap_ext_in) (abfd, ecoffsymbol (symbol)->native, 1425 &ecoff_ext); 1426 type = 'e'; 1427 pos = (((char *) ecoffsymbol (symbol)->native 1428 - (char *) ecoff_data (abfd)->debug_info.external_ext) 1429 / debug_swap->external_ext_size); 1430 jmptbl = ecoff_ext.jmptbl ? 'j' : ' '; 1431 cobol_main = ecoff_ext.cobol_main ? 'c' : ' '; 1432 weakext = ecoff_ext.weakext ? 'w' : ' '; 1433 } 1434 1435 fprintf (file, "[%3d] %c ", 1436 pos, type); 1437 fprintf_vma (file, (bfd_vma) ecoff_ext.asym.value); 1438 fprintf (file, " st %x sc %x indx %x %c%c%c %s", 1439 (unsigned) ecoff_ext.asym.st, 1440 (unsigned) ecoff_ext.asym.sc, 1441 (unsigned) ecoff_ext.asym.index, 1442 jmptbl, cobol_main, weakext, 1443 symbol->name); 1444 1445 if (ecoffsymbol (symbol)->fdr != NULL 1446 && ecoff_ext.asym.index != indexNil) 1447 { 1448 FDR *fdr; 1449 unsigned int indx; 1450 int bigendian; 1451 bfd_size_type sym_base; 1452 union aux_ext *aux_base; 1453 1454 fdr = ecoffsymbol (symbol)->fdr; 1455 indx = ecoff_ext.asym.index; 1456 1457 /* sym_base is used to map the fdr relative indices which 1458 appear in the file to the position number which we are 1459 using. */ 1460 sym_base = fdr->isymBase; 1461 if (ecoffsymbol (symbol)->local) 1462 sym_base += 1463 ecoff_data (abfd)->debug_info.symbolic_header.iextMax; 1464 1465 /* aux_base is the start of the aux entries for this file; 1466 asym.index is an offset from this. */ 1467 aux_base = (ecoff_data (abfd)->debug_info.external_aux 1468 + fdr->iauxBase); 1469 1470 /* The aux entries are stored in host byte order; the 1471 order is indicated by a bit in the fdr. */ 1472 bigendian = fdr->fBigendian; 1473 1474 /* This switch is basically from gcc/mips-tdump.c. */ 1475 switch (ecoff_ext.asym.st) 1476 { 1477 case stNil: 1478 case stLabel: 1479 break; 1480 1481 case stFile: 1482 case stBlock: 1483 fprintf (file, _("\n End+1 symbol: %ld"), 1484 (long) (indx + sym_base)); 1485 break; 1486 1487 case stEnd: 1488 if (ecoff_ext.asym.sc == scText 1489 || ecoff_ext.asym.sc == scInfo) 1490 fprintf (file, _("\n First symbol: %ld"), 1491 (long) (indx + sym_base)); 1492 else 1493 fprintf (file, _("\n First symbol: %ld"), 1494 ((long) 1495 (AUX_GET_ISYM (bigendian, 1496 &aux_base[ecoff_ext.asym.index]) 1497 + sym_base))); 1498 break; 1499 1500 case stProc: 1501 case stStaticProc: 1502 if (ECOFF_IS_STAB (&ecoff_ext.asym)) 1503 ; 1504 else if (ecoffsymbol (symbol)->local) 1505 fprintf (file, _("\n End+1 symbol: %-7ld Type: %s"), 1506 ((long) 1507 (AUX_GET_ISYM (bigendian, 1508 &aux_base[ecoff_ext.asym.index]) 1509 + sym_base)), 1510 ecoff_type_to_string (abfd, fdr, indx + 1)); 1511 else 1512 fprintf (file, _("\n Local symbol: %ld"), 1513 ((long) indx 1514 + (long) sym_base 1515 + (ecoff_data (abfd) 1516 ->debug_info.symbolic_header.iextMax))); 1517 break; 1518 1519 case stStruct: 1520 fprintf (file, _("\n struct; End+1 symbol: %ld"), 1521 (long) (indx + sym_base)); 1522 break; 1523 1524 case stUnion: 1525 fprintf (file, _("\n union; End+1 symbol: %ld"), 1526 (long) (indx + sym_base)); 1527 break; 1528 1529 case stEnum: 1530 fprintf (file, _("\n enum; End+1 symbol: %ld"), 1531 (long) (indx + sym_base)); 1532 break; 1533 1534 default: 1535 if (! ECOFF_IS_STAB (&ecoff_ext.asym)) 1536 fprintf (file, _("\n Type: %s"), 1537 ecoff_type_to_string (abfd, fdr, indx)); 1538 break; 1539 } 1540 } 1541 } 1542 break; 1543 } 1544} 1545 1546/* Read in the relocs for a section. */ 1547 1548static bfd_boolean 1549ecoff_slurp_reloc_table (bfd *abfd, 1550 asection *section, 1551 asymbol **symbols) 1552{ 1553 const struct ecoff_backend_data * const backend = ecoff_backend (abfd); 1554 arelent *internal_relocs; 1555 bfd_size_type external_reloc_size; 1556 bfd_size_type amt; 1557 char *external_relocs; 1558 arelent *rptr; 1559 unsigned int i; 1560 1561 if (section->relocation != NULL 1562 || section->reloc_count == 0 1563 || (section->flags & SEC_CONSTRUCTOR) != 0) 1564 return TRUE; 1565 1566 if (! _bfd_ecoff_slurp_symbol_table (abfd)) 1567 return FALSE; 1568 1569 amt = section->reloc_count; 1570 amt *= sizeof (arelent); 1571 internal_relocs = bfd_alloc (abfd, amt); 1572 1573 external_reloc_size = backend->external_reloc_size; 1574 amt = external_reloc_size * section->reloc_count; 1575 external_relocs = bfd_alloc (abfd, amt); 1576 if (internal_relocs == NULL || external_relocs == NULL) 1577 return FALSE; 1578 if (bfd_seek (abfd, section->rel_filepos, SEEK_SET) != 0) 1579 return FALSE; 1580 if (bfd_bread (external_relocs, amt, abfd) != amt) 1581 return FALSE; 1582 1583 for (i = 0, rptr = internal_relocs; i < section->reloc_count; i++, rptr++) 1584 { 1585 struct internal_reloc intern; 1586 1587 (*backend->swap_reloc_in) (abfd, 1588 external_relocs + i * external_reloc_size, 1589 &intern); 1590 1591 if (intern.r_extern) 1592 { 1593 /* r_symndx is an index into the external symbols. */ 1594 BFD_ASSERT (intern.r_symndx >= 0 1595 && (intern.r_symndx 1596 < (ecoff_data (abfd) 1597 ->debug_info.symbolic_header.iextMax))); 1598 rptr->sym_ptr_ptr = symbols + intern.r_symndx; 1599 rptr->addend = 0; 1600 } 1601 else if (intern.r_symndx == RELOC_SECTION_NONE 1602 || intern.r_symndx == RELOC_SECTION_ABS) 1603 { 1604 rptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; 1605 rptr->addend = 0; 1606 } 1607 else 1608 { 1609 const char *sec_name; 1610 asection *sec; 1611 1612 /* r_symndx is a section key. */ 1613 switch (intern.r_symndx) 1614 { 1615 case RELOC_SECTION_TEXT: sec_name = _TEXT; break; 1616 case RELOC_SECTION_RDATA: sec_name = _RDATA; break; 1617 case RELOC_SECTION_DATA: sec_name = _DATA; break; 1618 case RELOC_SECTION_SDATA: sec_name = _SDATA; break; 1619 case RELOC_SECTION_SBSS: sec_name = _SBSS; break; 1620 case RELOC_SECTION_BSS: sec_name = _BSS; break; 1621 case RELOC_SECTION_INIT: sec_name = _INIT; break; 1622 case RELOC_SECTION_LIT8: sec_name = _LIT8; break; 1623 case RELOC_SECTION_LIT4: sec_name = _LIT4; break; 1624 case RELOC_SECTION_XDATA: sec_name = _XDATA; break; 1625 case RELOC_SECTION_PDATA: sec_name = _PDATA; break; 1626 case RELOC_SECTION_FINI: sec_name = _FINI; break; 1627 case RELOC_SECTION_LITA: sec_name = _LITA; break; 1628 case RELOC_SECTION_RCONST: sec_name = _RCONST; break; 1629 default: abort (); 1630 } 1631 1632 sec = bfd_get_section_by_name (abfd, sec_name); 1633 if (sec == NULL) 1634 abort (); 1635 rptr->sym_ptr_ptr = sec->symbol_ptr_ptr; 1636 1637 rptr->addend = - bfd_get_section_vma (abfd, sec); 1638 } 1639 1640 rptr->address = intern.r_vaddr - bfd_get_section_vma (abfd, section); 1641 1642 /* Let the backend select the howto field and do any other 1643 required processing. */ 1644 (*backend->adjust_reloc_in) (abfd, &intern, rptr); 1645 } 1646 1647 bfd_release (abfd, external_relocs); 1648 1649 section->relocation = internal_relocs; 1650 1651 return TRUE; 1652} 1653 1654/* Get a canonical list of relocs. */ 1655 1656long 1657_bfd_ecoff_canonicalize_reloc (bfd *abfd, 1658 asection *section, 1659 arelent **relptr, 1660 asymbol **symbols) 1661{ 1662 unsigned int count; 1663 1664 if (section->flags & SEC_CONSTRUCTOR) 1665 { 1666 arelent_chain *chain; 1667 1668 /* This section has relocs made up by us, not the file, so take 1669 them out of their chain and place them into the data area 1670 provided. */ 1671 for (count = 0, chain = section->constructor_chain; 1672 count < section->reloc_count; 1673 count++, chain = chain->next) 1674 *relptr++ = &chain->relent; 1675 } 1676 else 1677 { 1678 arelent *tblptr; 1679 1680 if (! ecoff_slurp_reloc_table (abfd, section, symbols)) 1681 return -1; 1682 1683 tblptr = section->relocation; 1684 1685 for (count = 0; count < section->reloc_count; count++) 1686 *relptr++ = tblptr++; 1687 } 1688 1689 *relptr = NULL; 1690 1691 return section->reloc_count; 1692} 1693 1694/* Provided a BFD, a section and an offset into the section, calculate 1695 and return the name of the source file and the line nearest to the 1696 wanted location. */ 1697 1698bfd_boolean 1699_bfd_ecoff_find_nearest_line (bfd *abfd, 1700 asection *section, 1701 asymbol **ignore_symbols ATTRIBUTE_UNUSED, 1702 bfd_vma offset, 1703 const char **filename_ptr, 1704 const char **functionname_ptr, 1705 unsigned int *retline_ptr) 1706{ 1707 const struct ecoff_debug_swap * const debug_swap 1708 = &ecoff_backend (abfd)->debug_swap; 1709 struct ecoff_debug_info * const debug_info = &ecoff_data (abfd)->debug_info; 1710 struct ecoff_find_line *line_info; 1711 1712 /* Make sure we have the FDR's. */ 1713 if (! _bfd_ecoff_slurp_symbolic_info (abfd, NULL, debug_info) 1714 || bfd_get_symcount (abfd) == 0) 1715 return FALSE; 1716 1717 if (ecoff_data (abfd)->find_line_info == NULL) 1718 { 1719 bfd_size_type amt = sizeof (struct ecoff_find_line); 1720 1721 ecoff_data (abfd)->find_line_info = bfd_zalloc (abfd, amt); 1722 if (ecoff_data (abfd)->find_line_info == NULL) 1723 return FALSE; 1724 } 1725 line_info = ecoff_data (abfd)->find_line_info; 1726 1727 return _bfd_ecoff_locate_line (abfd, section, offset, debug_info, 1728 debug_swap, line_info, filename_ptr, 1729 functionname_ptr, retline_ptr); 1730} 1731 1732/* Copy private BFD data. This is called by objcopy and strip. We 1733 use it to copy the ECOFF debugging information from one BFD to the 1734 other. It would be theoretically possible to represent the ECOFF 1735 debugging information in the symbol table. However, it would be a 1736 lot of work, and there would be little gain (gas, gdb, and ld 1737 already access the ECOFF debugging information via the 1738 ecoff_debug_info structure, and that structure would have to be 1739 retained in order to support ECOFF debugging in MIPS ELF). 1740 1741 The debugging information for the ECOFF external symbols comes from 1742 the symbol table, so this function only handles the other debugging 1743 information. */ 1744 1745bfd_boolean 1746_bfd_ecoff_bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd) 1747{ 1748 struct ecoff_debug_info *iinfo = &ecoff_data (ibfd)->debug_info; 1749 struct ecoff_debug_info *oinfo = &ecoff_data (obfd)->debug_info; 1750 int i; 1751 asymbol **sym_ptr_ptr; 1752 size_t c; 1753 bfd_boolean local; 1754 1755 /* We only want to copy information over if both BFD's use ECOFF 1756 format. */ 1757 if (bfd_get_flavour (ibfd) != bfd_target_ecoff_flavour 1758 || bfd_get_flavour (obfd) != bfd_target_ecoff_flavour) 1759 return TRUE; 1760 1761 /* Copy the GP value and the register masks. */ 1762 ecoff_data (obfd)->gp = ecoff_data (ibfd)->gp; 1763 ecoff_data (obfd)->gprmask = ecoff_data (ibfd)->gprmask; 1764 ecoff_data (obfd)->fprmask = ecoff_data (ibfd)->fprmask; 1765 for (i = 0; i < 3; i++) 1766 ecoff_data (obfd)->cprmask[i] = ecoff_data (ibfd)->cprmask[i]; 1767 1768 /* Copy the version stamp. */ 1769 oinfo->symbolic_header.vstamp = iinfo->symbolic_header.vstamp; 1770 1771 /* If there are no symbols, don't copy any debugging information. */ 1772 c = bfd_get_symcount (obfd); 1773 sym_ptr_ptr = bfd_get_outsymbols (obfd); 1774 if (c == 0 || sym_ptr_ptr == NULL) 1775 return TRUE; 1776 1777 /* See if there are any local symbols. */ 1778 local = FALSE; 1779 for (; c > 0; c--, sym_ptr_ptr++) 1780 { 1781 if (ecoffsymbol (*sym_ptr_ptr)->local) 1782 { 1783 local = TRUE; 1784 break; 1785 } 1786 } 1787 1788 if (local) 1789 { 1790 /* There are some local symbols. We just bring over all the 1791 debugging information. FIXME: This is not quite the right 1792 thing to do. If the user has asked us to discard all 1793 debugging information, then we are probably going to wind up 1794 keeping it because there will probably be some local symbol 1795 which objcopy did not discard. We should actually break 1796 apart the debugging information and only keep that which 1797 applies to the symbols we want to keep. */ 1798 oinfo->symbolic_header.ilineMax = iinfo->symbolic_header.ilineMax; 1799 oinfo->symbolic_header.cbLine = iinfo->symbolic_header.cbLine; 1800 oinfo->line = iinfo->line; 1801 1802 oinfo->symbolic_header.idnMax = iinfo->symbolic_header.idnMax; 1803 oinfo->external_dnr = iinfo->external_dnr; 1804 1805 oinfo->symbolic_header.ipdMax = iinfo->symbolic_header.ipdMax; 1806 oinfo->external_pdr = iinfo->external_pdr; 1807 1808 oinfo->symbolic_header.isymMax = iinfo->symbolic_header.isymMax; 1809 oinfo->external_sym = iinfo->external_sym; 1810 1811 oinfo->symbolic_header.ioptMax = iinfo->symbolic_header.ioptMax; 1812 oinfo->external_opt = iinfo->external_opt; 1813 1814 oinfo->symbolic_header.iauxMax = iinfo->symbolic_header.iauxMax; 1815 oinfo->external_aux = iinfo->external_aux; 1816 1817 oinfo->symbolic_header.issMax = iinfo->symbolic_header.issMax; 1818 oinfo->ss = iinfo->ss; 1819 1820 oinfo->symbolic_header.ifdMax = iinfo->symbolic_header.ifdMax; 1821 oinfo->external_fdr = iinfo->external_fdr; 1822 1823 oinfo->symbolic_header.crfd = iinfo->symbolic_header.crfd; 1824 oinfo->external_rfd = iinfo->external_rfd; 1825 } 1826 else 1827 { 1828 /* We are discarding all the local symbol information. Look 1829 through the external symbols and remove all references to FDR 1830 or aux information. */ 1831 c = bfd_get_symcount (obfd); 1832 sym_ptr_ptr = bfd_get_outsymbols (obfd); 1833 for (; c > 0; c--, sym_ptr_ptr++) 1834 { 1835 EXTR esym; 1836 1837 (*(ecoff_backend (obfd)->debug_swap.swap_ext_in)) 1838 (obfd, ecoffsymbol (*sym_ptr_ptr)->native, &esym); 1839 esym.ifd = ifdNil; 1840 esym.asym.index = indexNil; 1841 (*(ecoff_backend (obfd)->debug_swap.swap_ext_out)) 1842 (obfd, &esym, ecoffsymbol (*sym_ptr_ptr)->native); 1843 } 1844 } 1845 1846 return TRUE; 1847} 1848 1849/* Set the architecture. The supported architecture is stored in the 1850 backend pointer. We always set the architecture anyhow, since many 1851 callers ignore the return value. */ 1852 1853bfd_boolean 1854_bfd_ecoff_set_arch_mach (bfd *abfd, 1855 enum bfd_architecture arch, 1856 unsigned long machine) 1857{ 1858 bfd_default_set_arch_mach (abfd, arch, machine); 1859 return arch == ecoff_backend (abfd)->arch; 1860} 1861 1862/* Get the size of the section headers. */ 1863 1864int 1865_bfd_ecoff_sizeof_headers (bfd *abfd, 1866 struct bfd_link_info *info ATTRIBUTE_UNUSED) 1867{ 1868 asection *current; 1869 int c; 1870 int ret; 1871 1872 c = 0; 1873 for (current = abfd->sections; 1874 current != NULL; 1875 current = current->next) 1876 ++c; 1877 1878 ret = (bfd_coff_filhsz (abfd) 1879 + bfd_coff_aoutsz (abfd) 1880 + c * bfd_coff_scnhsz (abfd)); 1881 return BFD_ALIGN (ret, 16); 1882} 1883 1884/* Get the contents of a section. */ 1885 1886bfd_boolean 1887_bfd_ecoff_get_section_contents (bfd *abfd, 1888 asection *section, 1889 void * location, 1890 file_ptr offset, 1891 bfd_size_type count) 1892{ 1893 return _bfd_generic_get_section_contents (abfd, section, location, 1894 offset, count); 1895} 1896 1897/* Sort sections by VMA, but put SEC_ALLOC sections first. This is 1898 called via qsort. */ 1899 1900static int 1901ecoff_sort_hdrs (const void * arg1, const void * arg2) 1902{ 1903 const asection *hdr1 = *(const asection **) arg1; 1904 const asection *hdr2 = *(const asection **) arg2; 1905 1906 if ((hdr1->flags & SEC_ALLOC) != 0) 1907 { 1908 if ((hdr2->flags & SEC_ALLOC) == 0) 1909 return -1; 1910 } 1911 else 1912 { 1913 if ((hdr2->flags & SEC_ALLOC) != 0) 1914 return 1; 1915 } 1916 if (hdr1->vma < hdr2->vma) 1917 return -1; 1918 else if (hdr1->vma > hdr2->vma) 1919 return 1; 1920 else 1921 return 0; 1922} 1923 1924/* Calculate the file position for each section, and set 1925 reloc_filepos. */ 1926 1927static bfd_boolean 1928ecoff_compute_section_file_positions (bfd *abfd) 1929{ 1930 file_ptr sofar, file_sofar; 1931 asection **sorted_hdrs; 1932 asection *current; 1933 unsigned int i; 1934 file_ptr old_sofar; 1935 bfd_boolean rdata_in_text; 1936 bfd_boolean first_data, first_nonalloc; 1937 const bfd_vma round = ecoff_backend (abfd)->round; 1938 bfd_size_type amt; 1939 1940 sofar = _bfd_ecoff_sizeof_headers (abfd, NULL); 1941 file_sofar = sofar; 1942 1943 /* Sort the sections by VMA. */ 1944 amt = abfd->section_count; 1945 amt *= sizeof (asection *); 1946 sorted_hdrs = bfd_malloc (amt); 1947 if (sorted_hdrs == NULL) 1948 return FALSE; 1949 for (current = abfd->sections, i = 0; 1950 current != NULL; 1951 current = current->next, i++) 1952 sorted_hdrs[i] = current; 1953 BFD_ASSERT (i == abfd->section_count); 1954 1955 qsort (sorted_hdrs, abfd->section_count, sizeof (asection *), 1956 ecoff_sort_hdrs); 1957 1958 /* Some versions of the OSF linker put the .rdata section in the 1959 text segment, and some do not. */ 1960 rdata_in_text = ecoff_backend (abfd)->rdata_in_text; 1961 if (rdata_in_text) 1962 { 1963 for (i = 0; i < abfd->section_count; i++) 1964 { 1965 current = sorted_hdrs[i]; 1966 if (streq (current->name, _RDATA)) 1967 break; 1968 if ((current->flags & SEC_CODE) == 0 1969 && ! streq (current->name, _PDATA) 1970 && ! streq (current->name, _RCONST)) 1971 { 1972 rdata_in_text = FALSE; 1973 break; 1974 } 1975 } 1976 } 1977 ecoff_data (abfd)->rdata_in_text = rdata_in_text; 1978 1979 first_data = TRUE; 1980 first_nonalloc = TRUE; 1981 for (i = 0; i < abfd->section_count; i++) 1982 { 1983 unsigned int alignment_power; 1984 1985 current = sorted_hdrs[i]; 1986 1987 /* For the Alpha ECOFF .pdata section the lnnoptr field is 1988 supposed to indicate the number of .pdata entries that are 1989 really in the section. Each entry is 8 bytes. We store this 1990 away in line_filepos before increasing the section size. */ 1991 if (streq (current->name, _PDATA)) 1992 current->line_filepos = current->size / 8; 1993 1994 alignment_power = current->alignment_power; 1995 1996 /* On Ultrix, the data sections in an executable file must be 1997 aligned to a page boundary within the file. This does not 1998 affect the section size, though. FIXME: Does this work for 1999 other platforms? It requires some modification for the 2000 Alpha, because .rdata on the Alpha goes with the text, not 2001 the data. */ 2002 if ((abfd->flags & EXEC_P) != 0 2003 && (abfd->flags & D_PAGED) != 0 2004 && ! first_data 2005 && (current->flags & SEC_CODE) == 0 2006 && (! rdata_in_text 2007 || ! streq (current->name, _RDATA)) 2008 && ! streq (current->name, _PDATA) 2009 && ! streq (current->name, _RCONST)) 2010 { 2011 sofar = (sofar + round - 1) &~ (round - 1); 2012 file_sofar = (file_sofar + round - 1) &~ (round - 1); 2013 first_data = FALSE; 2014 } 2015 else if (streq (current->name, _LIB)) 2016 { 2017 /* On Irix 4, the location of contents of the .lib section 2018 from a shared library section is also rounded up to a 2019 page boundary. */ 2020 2021 sofar = (sofar + round - 1) &~ (round - 1); 2022 file_sofar = (file_sofar + round - 1) &~ (round - 1); 2023 } 2024 else if (first_nonalloc 2025 && (current->flags & SEC_ALLOC) == 0 2026 && (abfd->flags & D_PAGED) != 0) 2027 { 2028 /* Skip up to the next page for an unallocated section, such 2029 as the .comment section on the Alpha. This leaves room 2030 for the .bss section. */ 2031 first_nonalloc = FALSE; 2032 sofar = (sofar + round - 1) &~ (round - 1); 2033 file_sofar = (file_sofar + round - 1) &~ (round - 1); 2034 } 2035 2036 /* Align the sections in the file to the same boundary on 2037 which they are aligned in virtual memory. */ 2038 sofar = BFD_ALIGN (sofar, 1 << alignment_power); 2039 if ((current->flags & SEC_HAS_CONTENTS) != 0) 2040 file_sofar = BFD_ALIGN (file_sofar, 1 << alignment_power); 2041 2042 if ((abfd->flags & D_PAGED) != 0 2043 && (current->flags & SEC_ALLOC) != 0) 2044 { 2045 sofar += (current->vma - sofar) % round; 2046 if ((current->flags & SEC_HAS_CONTENTS) != 0) 2047 file_sofar += (current->vma - file_sofar) % round; 2048 } 2049 2050 if ((current->flags & (SEC_HAS_CONTENTS | SEC_LOAD)) != 0) 2051 current->filepos = file_sofar; 2052 2053 sofar += current->size; 2054 if ((current->flags & SEC_HAS_CONTENTS) != 0) 2055 file_sofar += current->size; 2056 2057 /* Make sure that this section is of the right size too. */ 2058 old_sofar = sofar; 2059 sofar = BFD_ALIGN (sofar, 1 << alignment_power); 2060 if ((current->flags & SEC_HAS_CONTENTS) != 0) 2061 file_sofar = BFD_ALIGN (file_sofar, 1 << alignment_power); 2062 current->size += sofar - old_sofar; 2063 } 2064 2065 free (sorted_hdrs); 2066 sorted_hdrs = NULL; 2067 2068 ecoff_data (abfd)->reloc_filepos = file_sofar; 2069 2070 return TRUE; 2071} 2072 2073/* Determine the location of the relocs for all the sections in the 2074 output file, as well as the location of the symbolic debugging 2075 information. */ 2076 2077static bfd_size_type 2078ecoff_compute_reloc_file_positions (bfd *abfd) 2079{ 2080 const bfd_size_type external_reloc_size = 2081 ecoff_backend (abfd)->external_reloc_size; 2082 file_ptr reloc_base; 2083 bfd_size_type reloc_size; 2084 asection *current; 2085 file_ptr sym_base; 2086 2087 if (! abfd->output_has_begun) 2088 { 2089 if (! ecoff_compute_section_file_positions (abfd)) 2090 abort (); 2091 abfd->output_has_begun = TRUE; 2092 } 2093 2094 reloc_base = ecoff_data (abfd)->reloc_filepos; 2095 2096 reloc_size = 0; 2097 for (current = abfd->sections; 2098 current != NULL; 2099 current = current->next) 2100 { 2101 if (current->reloc_count == 0) 2102 current->rel_filepos = 0; 2103 else 2104 { 2105 bfd_size_type relsize; 2106 2107 current->rel_filepos = reloc_base; 2108 relsize = current->reloc_count * external_reloc_size; 2109 reloc_size += relsize; 2110 reloc_base += relsize; 2111 } 2112 } 2113 2114 sym_base = ecoff_data (abfd)->reloc_filepos + reloc_size; 2115 2116 /* At least on Ultrix, the symbol table of an executable file must 2117 be aligned to a page boundary. FIXME: Is this true on other 2118 platforms? */ 2119 if ((abfd->flags & EXEC_P) != 0 2120 && (abfd->flags & D_PAGED) != 0) 2121 sym_base = ((sym_base + ecoff_backend (abfd)->round - 1) 2122 &~ (ecoff_backend (abfd)->round - 1)); 2123 2124 ecoff_data (abfd)->sym_filepos = sym_base; 2125 2126 return reloc_size; 2127} 2128 2129/* Set the contents of a section. */ 2130 2131bfd_boolean 2132_bfd_ecoff_set_section_contents (bfd *abfd, 2133 asection *section, 2134 const void * location, 2135 file_ptr offset, 2136 bfd_size_type count) 2137{ 2138 file_ptr pos; 2139 2140 /* This must be done first, because bfd_set_section_contents is 2141 going to set output_has_begun to TRUE. */ 2142 if (! abfd->output_has_begun 2143 && ! ecoff_compute_section_file_positions (abfd)) 2144 return FALSE; 2145 2146 /* Handle the .lib section specially so that Irix 4 shared libraries 2147 work out. See coff_set_section_contents in coffcode.h. */ 2148 if (streq (section->name, _LIB)) 2149 { 2150 bfd_byte *rec, *recend; 2151 2152 rec = (bfd_byte *) location; 2153 recend = rec + count; 2154 while (rec < recend) 2155 { 2156 ++section->lma; 2157 rec += bfd_get_32 (abfd, rec) * 4; 2158 } 2159 2160 BFD_ASSERT (rec == recend); 2161 } 2162 2163 if (count == 0) 2164 return TRUE; 2165 2166 pos = section->filepos + offset; 2167 if (bfd_seek (abfd, pos, SEEK_SET) != 0 2168 || bfd_bwrite (location, count, abfd) != count) 2169 return FALSE; 2170 2171 return TRUE; 2172} 2173 2174/* Get the GP value for an ECOFF file. This is a hook used by 2175 nlmconv. */ 2176 2177bfd_vma 2178bfd_ecoff_get_gp_value (bfd *abfd) 2179{ 2180 if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour 2181 || bfd_get_format (abfd) != bfd_object) 2182 { 2183 bfd_set_error (bfd_error_invalid_operation); 2184 return 0; 2185 } 2186 2187 return ecoff_data (abfd)->gp; 2188} 2189 2190/* Set the GP value for an ECOFF file. This is a hook used by the 2191 assembler. */ 2192 2193bfd_boolean 2194bfd_ecoff_set_gp_value (bfd *abfd, bfd_vma gp_value) 2195{ 2196 if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour 2197 || bfd_get_format (abfd) != bfd_object) 2198 { 2199 bfd_set_error (bfd_error_invalid_operation); 2200 return FALSE; 2201 } 2202 2203 ecoff_data (abfd)->gp = gp_value; 2204 2205 return TRUE; 2206} 2207 2208/* Set the register masks for an ECOFF file. This is a hook used by 2209 the assembler. */ 2210 2211bfd_boolean 2212bfd_ecoff_set_regmasks (bfd *abfd, 2213 unsigned long gprmask, 2214 unsigned long fprmask, 2215 unsigned long *cprmask) 2216{ 2217 ecoff_data_type *tdata; 2218 2219 if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour 2220 || bfd_get_format (abfd) != bfd_object) 2221 { 2222 bfd_set_error (bfd_error_invalid_operation); 2223 return FALSE; 2224 } 2225 2226 tdata = ecoff_data (abfd); 2227 tdata->gprmask = gprmask; 2228 tdata->fprmask = fprmask; 2229 if (cprmask != NULL) 2230 { 2231 int i; 2232 2233 for (i = 0; i < 3; i++) 2234 tdata->cprmask[i] = cprmask[i]; 2235 } 2236 2237 return TRUE; 2238} 2239 2240/* Get ECOFF EXTR information for an external symbol. This function 2241 is passed to bfd_ecoff_debug_externals. */ 2242 2243static bfd_boolean 2244ecoff_get_extr (asymbol *sym, EXTR *esym) 2245{ 2246 ecoff_symbol_type *ecoff_sym_ptr; 2247 bfd *input_bfd; 2248 2249 if (bfd_asymbol_flavour (sym) != bfd_target_ecoff_flavour 2250 || ecoffsymbol (sym)->native == NULL) 2251 { 2252 /* Don't include debugging, local, or section symbols. */ 2253 if ((sym->flags & BSF_DEBUGGING) != 0 2254 || (sym->flags & BSF_LOCAL) != 0 2255 || (sym->flags & BSF_SECTION_SYM) != 0) 2256 return FALSE; 2257 2258 esym->jmptbl = 0; 2259 esym->cobol_main = 0; 2260 esym->weakext = (sym->flags & BSF_WEAK) != 0; 2261 esym->reserved = 0; 2262 esym->ifd = ifdNil; 2263 /* FIXME: we can do better than this for st and sc. */ 2264 esym->asym.st = stGlobal; 2265 esym->asym.sc = scAbs; 2266 esym->asym.reserved = 0; 2267 esym->asym.index = indexNil; 2268 return TRUE; 2269 } 2270 2271 ecoff_sym_ptr = ecoffsymbol (sym); 2272 2273 if (ecoff_sym_ptr->local) 2274 return FALSE; 2275 2276 input_bfd = bfd_asymbol_bfd (sym); 2277 (*(ecoff_backend (input_bfd)->debug_swap.swap_ext_in)) 2278 (input_bfd, ecoff_sym_ptr->native, esym); 2279 2280 /* If the symbol was defined by the linker, then esym will be 2281 undefined but sym will not be. Get a better class for such a 2282 symbol. */ 2283 if ((esym->asym.sc == scUndefined 2284 || esym->asym.sc == scSUndefined) 2285 && ! bfd_is_und_section (bfd_get_section (sym))) 2286 esym->asym.sc = scAbs; 2287 2288 /* Adjust the FDR index for the symbol by that used for the input 2289 BFD. */ 2290 if (esym->ifd != -1) 2291 { 2292 struct ecoff_debug_info *input_debug; 2293 2294 input_debug = &ecoff_data (input_bfd)->debug_info; 2295 BFD_ASSERT (esym->ifd < input_debug->symbolic_header.ifdMax); 2296 if (input_debug->ifdmap != NULL) 2297 esym->ifd = input_debug->ifdmap[esym->ifd]; 2298 } 2299 2300 return TRUE; 2301} 2302 2303/* Set the external symbol index. This routine is passed to 2304 bfd_ecoff_debug_externals. */ 2305 2306static void 2307ecoff_set_index (asymbol *sym, bfd_size_type indx) 2308{ 2309 ecoff_set_sym_index (sym, indx); 2310} 2311 2312/* Write out an ECOFF file. */ 2313 2314bfd_boolean 2315_bfd_ecoff_write_object_contents (bfd *abfd) 2316{ 2317 const struct ecoff_backend_data * const backend = ecoff_backend (abfd); 2318 const bfd_vma round = backend->round; 2319 const bfd_size_type filhsz = bfd_coff_filhsz (abfd); 2320 const bfd_size_type aoutsz = bfd_coff_aoutsz (abfd); 2321 const bfd_size_type scnhsz = bfd_coff_scnhsz (abfd); 2322 const bfd_size_type external_hdr_size 2323 = backend->debug_swap.external_hdr_size; 2324 const bfd_size_type external_reloc_size = backend->external_reloc_size; 2325 void (* const adjust_reloc_out) (bfd *, const arelent *, struct internal_reloc *) 2326 = backend->adjust_reloc_out; 2327 void (* const swap_reloc_out) (bfd *, const struct internal_reloc *, void *) 2328 = backend->swap_reloc_out; 2329 struct ecoff_debug_info * const debug = &ecoff_data (abfd)->debug_info; 2330 HDRR * const symhdr = &debug->symbolic_header; 2331 asection *current; 2332 unsigned int count; 2333 bfd_size_type reloc_size; 2334 bfd_size_type text_size; 2335 bfd_vma text_start; 2336 bfd_boolean set_text_start; 2337 bfd_size_type data_size; 2338 bfd_vma data_start; 2339 bfd_boolean set_data_start; 2340 bfd_size_type bss_size; 2341 void * buff = NULL; 2342 void * reloc_buff = NULL; 2343 struct internal_filehdr internal_f; 2344 struct internal_aouthdr internal_a; 2345 int i; 2346 2347 /* Determine where the sections and relocs will go in the output 2348 file. */ 2349 reloc_size = ecoff_compute_reloc_file_positions (abfd); 2350 2351 count = 1; 2352 for (current = abfd->sections; 2353 current != NULL; 2354 current = current->next) 2355 { 2356 current->target_index = count; 2357 ++count; 2358 } 2359 2360 if ((abfd->flags & D_PAGED) != 0) 2361 text_size = _bfd_ecoff_sizeof_headers (abfd, NULL); 2362 else 2363 text_size = 0; 2364 text_start = 0; 2365 set_text_start = FALSE; 2366 data_size = 0; 2367 data_start = 0; 2368 set_data_start = FALSE; 2369 bss_size = 0; 2370 2371 /* Write section headers to the file. */ 2372 2373 /* Allocate buff big enough to hold a section header, 2374 file header, or a.out header. */ 2375 { 2376 bfd_size_type siz; 2377 2378 siz = scnhsz; 2379 if (siz < filhsz) 2380 siz = filhsz; 2381 if (siz < aoutsz) 2382 siz = aoutsz; 2383 buff = bfd_malloc (siz); 2384 if (buff == NULL) 2385 goto error_return; 2386 } 2387 2388 internal_f.f_nscns = 0; 2389 if (bfd_seek (abfd, (file_ptr) (filhsz + aoutsz), SEEK_SET) != 0) 2390 goto error_return; 2391 2392 for (current = abfd->sections; 2393 current != NULL; 2394 current = current->next) 2395 { 2396 struct internal_scnhdr section; 2397 bfd_vma vma; 2398 2399 ++internal_f.f_nscns; 2400 2401 strncpy (section.s_name, current->name, sizeof section.s_name); 2402 2403 /* This seems to be correct for Irix 4 shared libraries. */ 2404 vma = bfd_get_section_vma (abfd, current); 2405 if (streq (current->name, _LIB)) 2406 section.s_vaddr = 0; 2407 else 2408 section.s_vaddr = vma; 2409 2410 section.s_paddr = current->lma; 2411 section.s_size = current->size; 2412 2413 /* If this section is unloadable then the scnptr will be 0. */ 2414 if ((current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0) 2415 section.s_scnptr = 0; 2416 else 2417 section.s_scnptr = current->filepos; 2418 section.s_relptr = current->rel_filepos; 2419 2420 /* FIXME: the lnnoptr of the .sbss or .sdata section of an 2421 object file produced by the assembler is supposed to point to 2422 information about how much room is required by objects of 2423 various different sizes. I think this only matters if we 2424 want the linker to compute the best size to use, or 2425 something. I don't know what happens if the information is 2426 not present. */ 2427 if (! streq (current->name, _PDATA)) 2428 section.s_lnnoptr = 0; 2429 else 2430 { 2431 /* The Alpha ECOFF .pdata section uses the lnnoptr field to 2432 hold the number of entries in the section (each entry is 2433 8 bytes). We stored this in the line_filepos field in 2434 ecoff_compute_section_file_positions. */ 2435 section.s_lnnoptr = current->line_filepos; 2436 } 2437 2438 section.s_nreloc = current->reloc_count; 2439 section.s_nlnno = 0; 2440 section.s_flags = ecoff_sec_to_styp_flags (current->name, 2441 current->flags); 2442 2443 if (bfd_coff_swap_scnhdr_out (abfd, (void *) §ion, buff) == 0 2444 || bfd_bwrite (buff, scnhsz, abfd) != scnhsz) 2445 goto error_return; 2446 2447 if ((section.s_flags & STYP_TEXT) != 0 2448 || ((section.s_flags & STYP_RDATA) != 0 2449 && ecoff_data (abfd)->rdata_in_text) 2450 || section.s_flags == STYP_PDATA 2451 || (section.s_flags & STYP_DYNAMIC) != 0 2452 || (section.s_flags & STYP_LIBLIST) != 0 2453 || (section.s_flags & STYP_RELDYN) != 0 2454 || section.s_flags == STYP_CONFLIC 2455 || (section.s_flags & STYP_DYNSTR) != 0 2456 || (section.s_flags & STYP_DYNSYM) != 0 2457 || (section.s_flags & STYP_HASH) != 0 2458 || (section.s_flags & STYP_ECOFF_INIT) != 0 2459 || (section.s_flags & STYP_ECOFF_FINI) != 0 2460 || section.s_flags == STYP_RCONST) 2461 { 2462 text_size += current->size; 2463 if (! set_text_start || text_start > vma) 2464 { 2465 text_start = vma; 2466 set_text_start = TRUE; 2467 } 2468 } 2469 else if ((section.s_flags & STYP_RDATA) != 0 2470 || (section.s_flags & STYP_DATA) != 0 2471 || (section.s_flags & STYP_LITA) != 0 2472 || (section.s_flags & STYP_LIT8) != 0 2473 || (section.s_flags & STYP_LIT4) != 0 2474 || (section.s_flags & STYP_SDATA) != 0 2475 || section.s_flags == STYP_XDATA 2476 || (section.s_flags & STYP_GOT) != 0) 2477 { 2478 data_size += current->size; 2479 if (! set_data_start || data_start > vma) 2480 { 2481 data_start = vma; 2482 set_data_start = TRUE; 2483 } 2484 } 2485 else if ((section.s_flags & STYP_BSS) != 0 2486 || (section.s_flags & STYP_SBSS) != 0) 2487 bss_size += current->size; 2488 else if (section.s_flags == 0 2489 || (section.s_flags & STYP_ECOFF_LIB) != 0 2490 || section.s_flags == STYP_COMMENT) 2491 /* Do nothing. */ ; 2492 else 2493 abort (); 2494 } 2495 2496 /* Set up the file header. */ 2497 internal_f.f_magic = ecoff_get_magic (abfd); 2498 2499 /* We will NOT put a fucking timestamp in the header here. Every 2500 time you put it back, I will come in and take it out again. I'm 2501 sorry. This field does not belong here. We fill it with a 0 so 2502 it compares the same but is not a reasonable time. -- 2503 gnu@cygnus.com. */ 2504 internal_f.f_timdat = 0; 2505 2506 if (bfd_get_symcount (abfd) != 0) 2507 { 2508 /* The ECOFF f_nsyms field is not actually the number of 2509 symbols, it's the size of symbolic information header. */ 2510 internal_f.f_nsyms = external_hdr_size; 2511 internal_f.f_symptr = ecoff_data (abfd)->sym_filepos; 2512 } 2513 else 2514 { 2515 internal_f.f_nsyms = 0; 2516 internal_f.f_symptr = 0; 2517 } 2518 2519 internal_f.f_opthdr = aoutsz; 2520 2521 internal_f.f_flags = F_LNNO; 2522 if (reloc_size == 0) 2523 internal_f.f_flags |= F_RELFLG; 2524 if (bfd_get_symcount (abfd) == 0) 2525 internal_f.f_flags |= F_LSYMS; 2526 if (abfd->flags & EXEC_P) 2527 internal_f.f_flags |= F_EXEC; 2528 2529 if (bfd_little_endian (abfd)) 2530 internal_f.f_flags |= F_AR32WR; 2531 else 2532 internal_f.f_flags |= F_AR32W; 2533 2534 /* Set up the ``optional'' header. */ 2535 if ((abfd->flags & D_PAGED) != 0) 2536 internal_a.magic = ECOFF_AOUT_ZMAGIC; 2537 else 2538 internal_a.magic = ECOFF_AOUT_OMAGIC; 2539 2540 /* FIXME: Is this really correct? */ 2541 internal_a.vstamp = symhdr->vstamp; 2542 2543 /* At least on Ultrix, these have to be rounded to page boundaries. 2544 FIXME: Is this true on other platforms? */ 2545 if ((abfd->flags & D_PAGED) != 0) 2546 { 2547 internal_a.tsize = (text_size + round - 1) &~ (round - 1); 2548 internal_a.text_start = text_start &~ (round - 1); 2549 internal_a.dsize = (data_size + round - 1) &~ (round - 1); 2550 internal_a.data_start = data_start &~ (round - 1); 2551 } 2552 else 2553 { 2554 internal_a.tsize = text_size; 2555 internal_a.text_start = text_start; 2556 internal_a.dsize = data_size; 2557 internal_a.data_start = data_start; 2558 } 2559 2560 /* On Ultrix, the initial portions of the .sbss and .bss segments 2561 are at the end of the data section. The bsize field in the 2562 optional header records how many bss bytes are required beyond 2563 those in the data section. The value is not rounded to a page 2564 boundary. */ 2565 if (bss_size < internal_a.dsize - data_size) 2566 bss_size = 0; 2567 else 2568 bss_size -= internal_a.dsize - data_size; 2569 internal_a.bsize = bss_size; 2570 internal_a.bss_start = internal_a.data_start + internal_a.dsize; 2571 2572 internal_a.entry = bfd_get_start_address (abfd); 2573 2574 internal_a.gp_value = ecoff_data (abfd)->gp; 2575 2576 internal_a.gprmask = ecoff_data (abfd)->gprmask; 2577 internal_a.fprmask = ecoff_data (abfd)->fprmask; 2578 for (i = 0; i < 4; i++) 2579 internal_a.cprmask[i] = ecoff_data (abfd)->cprmask[i]; 2580 2581 /* Let the backend adjust the headers if necessary. */ 2582 if (backend->adjust_headers) 2583 { 2584 if (! (*backend->adjust_headers) (abfd, &internal_f, &internal_a)) 2585 goto error_return; 2586 } 2587 2588 /* Write out the file header and the optional header. */ 2589 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) 2590 goto error_return; 2591 2592 bfd_coff_swap_filehdr_out (abfd, (void *) &internal_f, buff); 2593 if (bfd_bwrite (buff, filhsz, abfd) != filhsz) 2594 goto error_return; 2595 2596 bfd_coff_swap_aouthdr_out (abfd, (void *) &internal_a, buff); 2597 if (bfd_bwrite (buff, aoutsz, abfd) != aoutsz) 2598 goto error_return; 2599 2600 /* Build the external symbol information. This must be done before 2601 writing out the relocs so that we know the symbol indices. We 2602 don't do this if this BFD was created by the backend linker, 2603 since it will have already handled the symbols and relocs. */ 2604 if (! ecoff_data (abfd)->linker) 2605 { 2606 symhdr->iextMax = 0; 2607 symhdr->issExtMax = 0; 2608 debug->external_ext = debug->external_ext_end = NULL; 2609 debug->ssext = debug->ssext_end = NULL; 2610 if (! bfd_ecoff_debug_externals (abfd, debug, &backend->debug_swap, 2611 (abfd->flags & EXEC_P) == 0, 2612 ecoff_get_extr, ecoff_set_index)) 2613 goto error_return; 2614 2615 /* Write out the relocs. */ 2616 for (current = abfd->sections; 2617 current != NULL; 2618 current = current->next) 2619 { 2620 arelent **reloc_ptr_ptr; 2621 arelent **reloc_end; 2622 char *out_ptr; 2623 bfd_size_type amt; 2624 2625 if (current->reloc_count == 0) 2626 continue; 2627 2628 amt = current->reloc_count * external_reloc_size; 2629 reloc_buff = bfd_alloc (abfd, amt); 2630 if (reloc_buff == NULL) 2631 goto error_return; 2632 2633 reloc_ptr_ptr = current->orelocation; 2634 reloc_end = reloc_ptr_ptr + current->reloc_count; 2635 out_ptr = (char *) reloc_buff; 2636 2637 for (; 2638 reloc_ptr_ptr < reloc_end; 2639 reloc_ptr_ptr++, out_ptr += external_reloc_size) 2640 { 2641 arelent *reloc; 2642 asymbol *sym; 2643 struct internal_reloc in; 2644 2645 memset ((void *) &in, 0, sizeof in); 2646 2647 reloc = *reloc_ptr_ptr; 2648 sym = *reloc->sym_ptr_ptr; 2649 2650 /* If the howto field has not been initialised then skip this reloc. 2651 This assumes that an error message has been issued elsewhere. */ 2652 if (reloc->howto == NULL) 2653 continue; 2654 2655 in.r_vaddr = (reloc->address 2656 + bfd_get_section_vma (abfd, current)); 2657 in.r_type = reloc->howto->type; 2658 2659 if ((sym->flags & BSF_SECTION_SYM) == 0) 2660 { 2661 in.r_symndx = ecoff_get_sym_index (*reloc->sym_ptr_ptr); 2662 in.r_extern = 1; 2663 } 2664 else 2665 { 2666 const char *name; 2667 unsigned int i; 2668 static struct 2669 { 2670 const char * name; 2671 long r_symndx; 2672 } 2673 section_symndx [] = 2674 { 2675 { _TEXT, RELOC_SECTION_TEXT }, 2676 { _RDATA, RELOC_SECTION_RDATA }, 2677 { _DATA, RELOC_SECTION_DATA }, 2678 { _SDATA, RELOC_SECTION_SDATA }, 2679 { _SBSS, RELOC_SECTION_SBSS }, 2680 { _BSS, RELOC_SECTION_BSS }, 2681 { _INIT, RELOC_SECTION_INIT }, 2682 { _LIT8, RELOC_SECTION_LIT8 }, 2683 { _LIT4, RELOC_SECTION_LIT4 }, 2684 { _XDATA, RELOC_SECTION_XDATA }, 2685 { _PDATA, RELOC_SECTION_PDATA }, 2686 { _FINI, RELOC_SECTION_FINI }, 2687 { _LITA, RELOC_SECTION_LITA }, 2688 { "*ABS*", RELOC_SECTION_ABS }, 2689 { _RCONST, RELOC_SECTION_RCONST } 2690 }; 2691 2692 name = bfd_get_section_name (abfd, bfd_get_section (sym)); 2693 2694 for (i = 0; i < ARRAY_SIZE (section_symndx); i++) 2695 if (streq (name, section_symndx[i].name)) 2696 { 2697 in.r_symndx = section_symndx[i].r_symndx; 2698 break; 2699 } 2700 2701 if (i == ARRAY_SIZE (section_symndx)) 2702 abort (); 2703 in.r_extern = 0; 2704 } 2705 2706 (*adjust_reloc_out) (abfd, reloc, &in); 2707 2708 (*swap_reloc_out) (abfd, &in, (void *) out_ptr); 2709 } 2710 2711 if (bfd_seek (abfd, current->rel_filepos, SEEK_SET) != 0) 2712 goto error_return; 2713 amt = current->reloc_count * external_reloc_size; 2714 if (bfd_bwrite (reloc_buff, amt, abfd) != amt) 2715 goto error_return; 2716 bfd_release (abfd, reloc_buff); 2717 reloc_buff = NULL; 2718 } 2719 2720 /* Write out the symbolic debugging information. */ 2721 if (bfd_get_symcount (abfd) > 0) 2722 { 2723 /* Write out the debugging information. */ 2724 if (! bfd_ecoff_write_debug (abfd, debug, &backend->debug_swap, 2725 ecoff_data (abfd)->sym_filepos)) 2726 goto error_return; 2727 } 2728 } 2729 2730 /* The .bss section of a demand paged executable must receive an 2731 entire page. If there are symbols, the symbols will start on the 2732 next page. If there are no symbols, we must fill out the page by 2733 hand. */ 2734 if (bfd_get_symcount (abfd) == 0 2735 && (abfd->flags & EXEC_P) != 0 2736 && (abfd->flags & D_PAGED) != 0) 2737 { 2738 char c; 2739 2740 if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos - 1, 2741 SEEK_SET) != 0) 2742 goto error_return; 2743 if (bfd_bread (&c, (bfd_size_type) 1, abfd) == 0) 2744 c = 0; 2745 if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos - 1, 2746 SEEK_SET) != 0) 2747 goto error_return; 2748 if (bfd_bwrite (&c, (bfd_size_type) 1, abfd) != 1) 2749 goto error_return; 2750 } 2751 2752 if (reloc_buff != NULL) 2753 bfd_release (abfd, reloc_buff); 2754 if (buff != NULL) 2755 free (buff); 2756 return TRUE; 2757 error_return: 2758 if (reloc_buff != NULL) 2759 bfd_release (abfd, reloc_buff); 2760 if (buff != NULL) 2761 free (buff); 2762 return FALSE; 2763} 2764 2765/* Archive handling. ECOFF uses what appears to be a unique type of 2766 archive header (armap). The byte ordering of the armap and the 2767 contents are encoded in the name of the armap itself. At least for 2768 now, we only support archives with the same byte ordering in the 2769 armap and the contents. 2770 2771 The first four bytes in the armap are the number of symbol 2772 definitions. This is always a power of two. 2773 2774 This is followed by the symbol definitions. Each symbol definition 2775 occupies 8 bytes. The first four bytes are the offset from the 2776 start of the armap strings to the null-terminated string naming 2777 this symbol. The second four bytes are the file offset to the 2778 archive member which defines this symbol. If the second four bytes 2779 are 0, then this is not actually a symbol definition, and it should 2780 be ignored. 2781 2782 The symbols are hashed into the armap with a closed hashing scheme. 2783 See the functions below for the details of the algorithm. 2784 2785 After the symbol definitions comes four bytes holding the size of 2786 the string table, followed by the string table itself. */ 2787 2788/* The name of an archive headers looks like this: 2789 __________E[BL]E[BL]_ (with a trailing space). 2790 The trailing space is changed to an X if the archive is changed to 2791 indicate that the armap is out of date. 2792 2793 The Alpha seems to use ________64E[BL]E[BL]_. */ 2794 2795#define ARMAP_BIG_ENDIAN 'B' 2796#define ARMAP_LITTLE_ENDIAN 'L' 2797#define ARMAP_MARKER 'E' 2798#define ARMAP_START_LENGTH 10 2799#define ARMAP_HEADER_MARKER_INDEX 10 2800#define ARMAP_HEADER_ENDIAN_INDEX 11 2801#define ARMAP_OBJECT_MARKER_INDEX 12 2802#define ARMAP_OBJECT_ENDIAN_INDEX 13 2803#define ARMAP_END_INDEX 14 2804#define ARMAP_END "_ " 2805 2806/* This is a magic number used in the hashing algorithm. */ 2807#define ARMAP_HASH_MAGIC 0x9dd68ab5 2808 2809/* This returns the hash value to use for a string. It also sets 2810 *REHASH to the rehash adjustment if the first slot is taken. SIZE 2811 is the number of entries in the hash table, and HLOG is the log 2812 base 2 of SIZE. */ 2813 2814static unsigned int 2815ecoff_armap_hash (const char *s, 2816 unsigned int *rehash, 2817 unsigned int size, 2818 unsigned int hlog) 2819{ 2820 unsigned int hash; 2821 2822 if (hlog == 0) 2823 return 0; 2824 hash = *s++; 2825 while (*s != '\0') 2826 hash = ((hash >> 27) | (hash << 5)) + *s++; 2827 hash *= ARMAP_HASH_MAGIC; 2828 *rehash = (hash & (size - 1)) | 1; 2829 return hash >> (32 - hlog); 2830} 2831 2832/* Read in the armap. */ 2833 2834bfd_boolean 2835_bfd_ecoff_slurp_armap (bfd *abfd) 2836{ 2837 char nextname[17]; 2838 unsigned int i; 2839 struct areltdata *mapdata; 2840 bfd_size_type parsed_size; 2841 char *raw_armap; 2842 struct artdata *ardata; 2843 unsigned int count; 2844 char *raw_ptr; 2845 struct symdef *symdef_ptr; 2846 char *stringbase; 2847 bfd_size_type amt; 2848 2849 /* Get the name of the first element. */ 2850 i = bfd_bread ((void *) nextname, (bfd_size_type) 16, abfd); 2851 if (i == 0) 2852 return TRUE; 2853 if (i != 16) 2854 return FALSE; 2855 2856 if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0) 2857 return FALSE; 2858 2859 /* Irix 4.0.5F apparently can use either an ECOFF armap or a 2860 standard COFF armap. We could move the ECOFF armap stuff into 2861 bfd_slurp_armap, but that seems inappropriate since no other 2862 target uses this format. Instead, we check directly for a COFF 2863 armap. */ 2864 if (CONST_STRNEQ (nextname, "/ ")) 2865 return bfd_slurp_armap (abfd); 2866 2867 /* See if the first element is an armap. */ 2868 if (! strneq (nextname, ecoff_backend (abfd)->armap_start, ARMAP_START_LENGTH) 2869 || nextname[ARMAP_HEADER_MARKER_INDEX] != ARMAP_MARKER 2870 || (nextname[ARMAP_HEADER_ENDIAN_INDEX] != ARMAP_BIG_ENDIAN 2871 && nextname[ARMAP_HEADER_ENDIAN_INDEX] != ARMAP_LITTLE_ENDIAN) 2872 || nextname[ARMAP_OBJECT_MARKER_INDEX] != ARMAP_MARKER 2873 || (nextname[ARMAP_OBJECT_ENDIAN_INDEX] != ARMAP_BIG_ENDIAN 2874 && nextname[ARMAP_OBJECT_ENDIAN_INDEX] != ARMAP_LITTLE_ENDIAN) 2875 || ! strneq (nextname + ARMAP_END_INDEX, ARMAP_END, sizeof ARMAP_END - 1)) 2876 { 2877 bfd_has_map (abfd) = FALSE; 2878 return TRUE; 2879 } 2880 2881 /* Make sure we have the right byte ordering. */ 2882 if (((nextname[ARMAP_HEADER_ENDIAN_INDEX] == ARMAP_BIG_ENDIAN) 2883 ^ (bfd_header_big_endian (abfd))) 2884 || ((nextname[ARMAP_OBJECT_ENDIAN_INDEX] == ARMAP_BIG_ENDIAN) 2885 ^ (bfd_big_endian (abfd)))) 2886 { 2887 bfd_set_error (bfd_error_wrong_format); 2888 return FALSE; 2889 } 2890 2891 /* Read in the armap. */ 2892 ardata = bfd_ardata (abfd); 2893 mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd); 2894 if (mapdata == NULL) 2895 return FALSE; 2896 parsed_size = mapdata->parsed_size; 2897 bfd_release (abfd, (void *) mapdata); 2898 2899 raw_armap = bfd_alloc (abfd, parsed_size); 2900 if (raw_armap == NULL) 2901 return FALSE; 2902 2903 if (bfd_bread ((void *) raw_armap, parsed_size, abfd) != parsed_size) 2904 { 2905 if (bfd_get_error () != bfd_error_system_call) 2906 bfd_set_error (bfd_error_malformed_archive); 2907 bfd_release (abfd, (void *) raw_armap); 2908 return FALSE; 2909 } 2910 2911 ardata->tdata = (void *) raw_armap; 2912 2913 count = H_GET_32 (abfd, raw_armap); 2914 2915 ardata->symdef_count = 0; 2916 ardata->cache = NULL; 2917 2918 /* This code used to overlay the symdefs over the raw archive data, 2919 but that doesn't work on a 64 bit host. */ 2920 stringbase = raw_armap + count * 8 + 8; 2921 2922#ifdef CHECK_ARMAP_HASH 2923 { 2924 unsigned int hlog; 2925 2926 /* Double check that I have the hashing algorithm right by making 2927 sure that every symbol can be looked up successfully. */ 2928 hlog = 0; 2929 for (i = 1; i < count; i <<= 1) 2930 hlog++; 2931 BFD_ASSERT (i == count); 2932 2933 raw_ptr = raw_armap + 4; 2934 for (i = 0; i < count; i++, raw_ptr += 8) 2935 { 2936 unsigned int name_offset, file_offset; 2937 unsigned int hash, rehash, srch; 2938 2939 name_offset = H_GET_32 (abfd, raw_ptr); 2940 file_offset = H_GET_32 (abfd, (raw_ptr + 4)); 2941 if (file_offset == 0) 2942 continue; 2943 hash = ecoff_armap_hash (stringbase + name_offset, &rehash, count, 2944 hlog); 2945 if (hash == i) 2946 continue; 2947 2948 /* See if we can rehash to this location. */ 2949 for (srch = (hash + rehash) & (count - 1); 2950 srch != hash && srch != i; 2951 srch = (srch + rehash) & (count - 1)) 2952 BFD_ASSERT (H_GET_32 (abfd, (raw_armap + 8 + srch * 8)) != 0); 2953 BFD_ASSERT (srch == i); 2954 } 2955 } 2956 2957#endif /* CHECK_ARMAP_HASH */ 2958 2959 raw_ptr = raw_armap + 4; 2960 for (i = 0; i < count; i++, raw_ptr += 8) 2961 if (H_GET_32 (abfd, (raw_ptr + 4)) != 0) 2962 ++ardata->symdef_count; 2963 2964 amt = ardata->symdef_count; 2965 amt *= sizeof (struct symdef); 2966 symdef_ptr = bfd_alloc (abfd, amt); 2967 if (!symdef_ptr) 2968 return FALSE; 2969 2970 ardata->symdefs = (carsym *) symdef_ptr; 2971 2972 raw_ptr = raw_armap + 4; 2973 for (i = 0; i < count; i++, raw_ptr += 8) 2974 { 2975 unsigned int name_offset, file_offset; 2976 2977 file_offset = H_GET_32 (abfd, (raw_ptr + 4)); 2978 if (file_offset == 0) 2979 continue; 2980 name_offset = H_GET_32 (abfd, raw_ptr); 2981 symdef_ptr->s.name = stringbase + name_offset; 2982 symdef_ptr->file_offset = file_offset; 2983 ++symdef_ptr; 2984 } 2985 2986 ardata->first_file_filepos = bfd_tell (abfd); 2987 /* Pad to an even boundary. */ 2988 ardata->first_file_filepos += ardata->first_file_filepos % 2; 2989 2990 bfd_has_map (abfd) = TRUE; 2991 2992 return TRUE; 2993} 2994 2995/* Write out an armap. */ 2996 2997bfd_boolean 2998_bfd_ecoff_write_armap (bfd *abfd, 2999 unsigned int elength, 3000 struct orl *map, 3001 unsigned int orl_count, 3002 int stridx) 3003{ 3004 unsigned int hashsize, hashlog; 3005 bfd_size_type symdefsize; 3006 int padit; 3007 unsigned int stringsize; 3008 unsigned int mapsize; 3009 file_ptr firstreal; 3010 struct ar_hdr hdr; 3011 struct stat statbuf; 3012 unsigned int i; 3013 bfd_byte temp[4]; 3014 bfd_byte *hashtable; 3015 bfd *current; 3016 bfd *last_elt; 3017 3018 /* Ultrix appears to use as a hash table size the least power of two 3019 greater than twice the number of entries. */ 3020 for (hashlog = 0; ((unsigned int) 1 << hashlog) <= 2 * orl_count; hashlog++) 3021 ; 3022 hashsize = 1 << hashlog; 3023 3024 symdefsize = hashsize * 8; 3025 padit = stridx % 2; 3026 stringsize = stridx + padit; 3027 3028 /* Include 8 bytes to store symdefsize and stringsize in output. */ 3029 mapsize = symdefsize + stringsize + 8; 3030 3031 firstreal = SARMAG + sizeof (struct ar_hdr) + mapsize + elength; 3032 3033 memset ((void *) &hdr, 0, sizeof hdr); 3034 3035 /* Work out the ECOFF armap name. */ 3036 strcpy (hdr.ar_name, ecoff_backend (abfd)->armap_start); 3037 hdr.ar_name[ARMAP_HEADER_MARKER_INDEX] = ARMAP_MARKER; 3038 hdr.ar_name[ARMAP_HEADER_ENDIAN_INDEX] = 3039 (bfd_header_big_endian (abfd) 3040 ? ARMAP_BIG_ENDIAN 3041 : ARMAP_LITTLE_ENDIAN); 3042 hdr.ar_name[ARMAP_OBJECT_MARKER_INDEX] = ARMAP_MARKER; 3043 hdr.ar_name[ARMAP_OBJECT_ENDIAN_INDEX] = 3044 bfd_big_endian (abfd) ? ARMAP_BIG_ENDIAN : ARMAP_LITTLE_ENDIAN; 3045 memcpy (hdr.ar_name + ARMAP_END_INDEX, ARMAP_END, sizeof ARMAP_END - 1); 3046 3047 /* Write the timestamp of the archive header to be just a little bit 3048 later than the timestamp of the file, otherwise the linker will 3049 complain that the index is out of date. Actually, the Ultrix 3050 linker just checks the archive name; the GNU linker may check the 3051 date. */ 3052 stat (abfd->filename, &statbuf); 3053 sprintf (hdr.ar_date, "%ld", (long) (statbuf.st_mtime + 60)); 3054 3055 /* The DECstation uses zeroes for the uid, gid and mode of the 3056 armap. */ 3057 hdr.ar_uid[0] = '0'; 3058 hdr.ar_gid[0] = '0'; 3059 /* Building gcc ends up extracting the armap as a file - twice. */ 3060 hdr.ar_mode[0] = '6'; 3061 hdr.ar_mode[1] = '4'; 3062 hdr.ar_mode[2] = '4'; 3063 3064 sprintf (hdr.ar_size, "%-10d", (int) mapsize); 3065 3066 hdr.ar_fmag[0] = '`'; 3067 hdr.ar_fmag[1] = '\012'; 3068 3069 /* Turn all null bytes in the header into spaces. */ 3070 for (i = 0; i < sizeof (struct ar_hdr); i++) 3071 if (((char *) (&hdr))[i] == '\0') 3072 (((char *) (&hdr))[i]) = ' '; 3073 3074 if (bfd_bwrite ((void *) &hdr, (bfd_size_type) sizeof (struct ar_hdr), abfd) 3075 != sizeof (struct ar_hdr)) 3076 return FALSE; 3077 3078 H_PUT_32 (abfd, hashsize, temp); 3079 if (bfd_bwrite ((void *) temp, (bfd_size_type) 4, abfd) != 4) 3080 return FALSE; 3081 3082 hashtable = bfd_zalloc (abfd, symdefsize); 3083 if (!hashtable) 3084 return FALSE; 3085 3086 current = abfd->archive_head; 3087 last_elt = current; 3088 for (i = 0; i < orl_count; i++) 3089 { 3090 unsigned int hash, rehash; 3091 3092 /* Advance firstreal to the file position of this archive 3093 element. */ 3094 if (map[i].u.abfd != last_elt) 3095 { 3096 do 3097 { 3098 firstreal += arelt_size (current) + sizeof (struct ar_hdr); 3099 firstreal += firstreal % 2; 3100 current = current->next; 3101 } 3102 while (current != map[i].u.abfd); 3103 } 3104 3105 last_elt = current; 3106 3107 hash = ecoff_armap_hash (*map[i].name, &rehash, hashsize, hashlog); 3108 if (H_GET_32 (abfd, (hashtable + (hash * 8) + 4)) != 0) 3109 { 3110 unsigned int srch; 3111 3112 /* The desired slot is already taken. */ 3113 for (srch = (hash + rehash) & (hashsize - 1); 3114 srch != hash; 3115 srch = (srch + rehash) & (hashsize - 1)) 3116 if (H_GET_32 (abfd, (hashtable + (srch * 8) + 4)) == 0) 3117 break; 3118 3119 BFD_ASSERT (srch != hash); 3120 3121 hash = srch; 3122 } 3123 3124 H_PUT_32 (abfd, map[i].namidx, (hashtable + hash * 8)); 3125 H_PUT_32 (abfd, firstreal, (hashtable + hash * 8 + 4)); 3126 } 3127 3128 if (bfd_bwrite ((void *) hashtable, symdefsize, abfd) != symdefsize) 3129 return FALSE; 3130 3131 bfd_release (abfd, hashtable); 3132 3133 /* Now write the strings. */ 3134 H_PUT_32 (abfd, stringsize, temp); 3135 if (bfd_bwrite ((void *) temp, (bfd_size_type) 4, abfd) != 4) 3136 return FALSE; 3137 for (i = 0; i < orl_count; i++) 3138 { 3139 bfd_size_type len; 3140 3141 len = strlen (*map[i].name) + 1; 3142 if (bfd_bwrite ((void *) (*map[i].name), len, abfd) != len) 3143 return FALSE; 3144 } 3145 3146 /* The spec sez this should be a newline. But in order to be 3147 bug-compatible for DECstation ar we use a null. */ 3148 if (padit) 3149 { 3150 if (bfd_bwrite ("", (bfd_size_type) 1, abfd) != 1) 3151 return FALSE; 3152 } 3153 3154 return TRUE; 3155} 3156 3157/* See whether this BFD is an archive. If it is, read in the armap 3158 and the extended name table. */ 3159 3160const bfd_target * 3161_bfd_ecoff_archive_p (bfd *abfd) 3162{ 3163 struct artdata *tdata_hold; 3164 char armag[SARMAG + 1]; 3165 bfd_size_type amt; 3166 3167 if (bfd_bread ((void *) armag, (bfd_size_type) SARMAG, abfd) != SARMAG) 3168 { 3169 if (bfd_get_error () != bfd_error_system_call) 3170 bfd_set_error (bfd_error_wrong_format); 3171 return NULL; 3172 } 3173 3174 if (! strneq (armag, ARMAG, SARMAG)) 3175 { 3176 bfd_set_error (bfd_error_wrong_format); 3177 return NULL; 3178 } 3179 3180 tdata_hold = bfd_ardata (abfd); 3181 3182 amt = sizeof (struct artdata); 3183 bfd_ardata (abfd) = bfd_zalloc (abfd, amt); 3184 if (bfd_ardata (abfd) == NULL) 3185 { 3186 bfd_ardata (abfd) = tdata_hold; 3187 return NULL; 3188 } 3189 3190 bfd_ardata (abfd)->first_file_filepos = SARMAG; 3191 /* Already cleared by bfd_zalloc above. 3192 bfd_ardata (abfd)->cache = NULL; 3193 bfd_ardata (abfd)->archive_head = NULL; 3194 bfd_ardata (abfd)->symdefs = NULL; 3195 bfd_ardata (abfd)->extended_names = NULL; 3196 bfd_ardata (abfd)->extended_names_size = 0; 3197 bfd_ardata (abfd)->tdata = NULL; */ 3198 3199 if (! _bfd_ecoff_slurp_armap (abfd) 3200 || ! _bfd_ecoff_slurp_extended_name_table (abfd)) 3201 { 3202 bfd_release (abfd, bfd_ardata (abfd)); 3203 bfd_ardata (abfd) = tdata_hold; 3204 return NULL; 3205 } 3206 3207 if (bfd_has_map (abfd)) 3208 { 3209 bfd *first; 3210 3211 /* This archive has a map, so we may presume that the contents 3212 are object files. Make sure that if the first file in the 3213 archive can be recognized as an object file, it is for this 3214 target. If not, assume that this is the wrong format. If 3215 the first file is not an object file, somebody is doing 3216 something weird, and we permit it so that ar -t will work. */ 3217 3218 first = bfd_openr_next_archived_file (abfd, NULL); 3219 if (first != NULL) 3220 { 3221 first->target_defaulted = FALSE; 3222 if (bfd_check_format (first, bfd_object) 3223 && first->xvec != abfd->xvec) 3224 { 3225 /* We ought to close `first' here, but we can't, because 3226 we have no way to remove it from the archive cache. 3227 It's almost impossible to figure out when we can 3228 release bfd_ardata. FIXME. */ 3229 bfd_set_error (bfd_error_wrong_object_format); 3230 bfd_ardata (abfd) = tdata_hold; 3231 return NULL; 3232 } 3233 /* And we ought to close `first' here too. */ 3234 } 3235 } 3236 3237 return abfd->xvec; 3238} 3239 3240/* ECOFF linker code. */ 3241 3242/* Routine to create an entry in an ECOFF link hash table. */ 3243 3244static struct bfd_hash_entry * 3245ecoff_link_hash_newfunc (struct bfd_hash_entry *entry, 3246 struct bfd_hash_table *table, 3247 const char *string) 3248{ 3249 struct ecoff_link_hash_entry *ret = (struct ecoff_link_hash_entry *) entry; 3250 3251 /* Allocate the structure if it has not already been allocated by a 3252 subclass. */ 3253 if (ret == NULL) 3254 ret = ((struct ecoff_link_hash_entry *) 3255 bfd_hash_allocate (table, sizeof (struct ecoff_link_hash_entry))); 3256 if (ret == NULL) 3257 return NULL; 3258 3259 /* Call the allocation method of the superclass. */ 3260 ret = ((struct ecoff_link_hash_entry *) 3261 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret, 3262 table, string)); 3263 3264 if (ret) 3265 { 3266 /* Set local fields. */ 3267 ret->indx = -1; 3268 ret->abfd = NULL; 3269 ret->written = 0; 3270 ret->small = 0; 3271 } 3272 memset ((void *) &ret->esym, 0, sizeof ret->esym); 3273 3274 return (struct bfd_hash_entry *) ret; 3275} 3276 3277/* Create an ECOFF link hash table. */ 3278 3279struct bfd_link_hash_table * 3280_bfd_ecoff_bfd_link_hash_table_create (bfd *abfd) 3281{ 3282 struct ecoff_link_hash_table *ret; 3283 bfd_size_type amt = sizeof (struct ecoff_link_hash_table); 3284 3285 ret = bfd_malloc (amt); 3286 if (ret == NULL) 3287 return NULL; 3288 if (!_bfd_link_hash_table_init (&ret->root, abfd, 3289 ecoff_link_hash_newfunc, 3290 sizeof (struct ecoff_link_hash_entry))) 3291 { 3292 free (ret); 3293 return NULL; 3294 } 3295 return &ret->root; 3296} 3297 3298/* Look up an entry in an ECOFF link hash table. */ 3299 3300#define ecoff_link_hash_lookup(table, string, create, copy, follow) \ 3301 ((struct ecoff_link_hash_entry *) \ 3302 bfd_link_hash_lookup (&(table)->root, (string), (create), (copy), (follow))) 3303 3304/* Traverse an ECOFF link hash table. */ 3305 3306#define ecoff_link_hash_traverse(table, func, info) \ 3307 (bfd_link_hash_traverse \ 3308 (&(table)->root, \ 3309 (bfd_boolean (*) (struct bfd_link_hash_entry *, void *)) (func), \ 3310 (info))) 3311 3312/* Get the ECOFF link hash table from the info structure. This is 3313 just a cast. */ 3314 3315#define ecoff_hash_table(p) ((struct ecoff_link_hash_table *) ((p)->hash)) 3316 3317/* Add the external symbols of an object file to the global linker 3318 hash table. The external symbols and strings we are passed are 3319 just allocated on the stack, and will be discarded. We must 3320 explicitly save any information we may need later on in the link. 3321 We do not want to read the external symbol information again. */ 3322 3323static bfd_boolean 3324ecoff_link_add_externals (bfd *abfd, 3325 struct bfd_link_info *info, 3326 void * external_ext, 3327 char *ssext) 3328{ 3329 const struct ecoff_backend_data * const backend = ecoff_backend (abfd); 3330 void (* const swap_ext_in) (bfd *, void *, EXTR *) 3331 = backend->debug_swap.swap_ext_in; 3332 bfd_size_type external_ext_size = backend->debug_swap.external_ext_size; 3333 unsigned long ext_count; 3334 struct bfd_link_hash_entry **sym_hash; 3335 char *ext_ptr; 3336 char *ext_end; 3337 bfd_size_type amt; 3338 3339 ext_count = ecoff_data (abfd)->debug_info.symbolic_header.iextMax; 3340 3341 amt = ext_count; 3342 amt *= sizeof (struct bfd_link_hash_entry *); 3343 sym_hash = bfd_alloc (abfd, amt); 3344 if (!sym_hash) 3345 return FALSE; 3346 ecoff_data (abfd)->sym_hashes = (struct ecoff_link_hash_entry **) sym_hash; 3347 3348 ext_ptr = (char *) external_ext; 3349 ext_end = ext_ptr + ext_count * external_ext_size; 3350 for (; ext_ptr < ext_end; ext_ptr += external_ext_size, sym_hash++) 3351 { 3352 EXTR esym; 3353 bfd_boolean skip; 3354 bfd_vma value; 3355 asection *section; 3356 const char *name; 3357 struct ecoff_link_hash_entry *h; 3358 3359 *sym_hash = NULL; 3360 3361 (*swap_ext_in) (abfd, (void *) ext_ptr, &esym); 3362 3363 /* Skip debugging symbols. */ 3364 skip = FALSE; 3365 switch (esym.asym.st) 3366 { 3367 case stGlobal: 3368 case stStatic: 3369 case stLabel: 3370 case stProc: 3371 case stStaticProc: 3372 break; 3373 default: 3374 skip = TRUE; 3375 break; 3376 } 3377 3378 if (skip) 3379 continue; 3380 3381 /* Get the information for this symbol. */ 3382 value = esym.asym.value; 3383 switch (esym.asym.sc) 3384 { 3385 default: 3386 case scNil: 3387 case scRegister: 3388 case scCdbLocal: 3389 case scBits: 3390 case scCdbSystem: 3391 case scRegImage: 3392 case scInfo: 3393 case scUserStruct: 3394 case scVar: 3395 case scVarRegister: 3396 case scVariant: 3397 case scBasedVar: 3398 case scXData: 3399 case scPData: 3400 section = NULL; 3401 break; 3402 case scText: 3403 section = bfd_make_section_old_way (abfd, _TEXT); 3404 value -= section->vma; 3405 break; 3406 case scData: 3407 section = bfd_make_section_old_way (abfd, _DATA); 3408 value -= section->vma; 3409 break; 3410 case scBss: 3411 section = bfd_make_section_old_way (abfd, _BSS); 3412 value -= section->vma; 3413 break; 3414 case scAbs: 3415 section = bfd_abs_section_ptr; 3416 break; 3417 case scUndefined: 3418 section = bfd_und_section_ptr; 3419 break; 3420 case scSData: 3421 section = bfd_make_section_old_way (abfd, _SDATA); 3422 value -= section->vma; 3423 break; 3424 case scSBss: 3425 section = bfd_make_section_old_way (abfd, _SBSS); 3426 value -= section->vma; 3427 break; 3428 case scRData: 3429 section = bfd_make_section_old_way (abfd, _RDATA); 3430 value -= section->vma; 3431 break; 3432 case scCommon: 3433 if (value > ecoff_data (abfd)->gp_size) 3434 { 3435 section = bfd_com_section_ptr; 3436 break; 3437 } 3438 /* Fall through. */ 3439 case scSCommon: 3440 if (ecoff_scom_section.name == NULL) 3441 { 3442 /* Initialize the small common section. */ 3443 ecoff_scom_section.name = SCOMMON; 3444 ecoff_scom_section.flags = SEC_IS_COMMON; 3445 ecoff_scom_section.output_section = &ecoff_scom_section; 3446 ecoff_scom_section.symbol = &ecoff_scom_symbol; 3447 ecoff_scom_section.symbol_ptr_ptr = &ecoff_scom_symbol_ptr; 3448 ecoff_scom_symbol.name = SCOMMON; 3449 ecoff_scom_symbol.flags = BSF_SECTION_SYM; 3450 ecoff_scom_symbol.section = &ecoff_scom_section; 3451 ecoff_scom_symbol_ptr = &ecoff_scom_symbol; 3452 } 3453 section = &ecoff_scom_section; 3454 break; 3455 case scSUndefined: 3456 section = bfd_und_section_ptr; 3457 break; 3458 case scInit: 3459 section = bfd_make_section_old_way (abfd, _INIT); 3460 value -= section->vma; 3461 break; 3462 case scFini: 3463 section = bfd_make_section_old_way (abfd, _FINI); 3464 value -= section->vma; 3465 break; 3466 case scRConst: 3467 section = bfd_make_section_old_way (abfd, _RCONST); 3468 value -= section->vma; 3469 break; 3470 } 3471 3472 if (section == NULL) 3473 continue; 3474 3475 name = ssext + esym.asym.iss; 3476 3477 if (! (_bfd_generic_link_add_one_symbol 3478 (info, abfd, name, 3479 (flagword) (esym.weakext ? BSF_WEAK : BSF_GLOBAL), 3480 section, value, NULL, TRUE, TRUE, sym_hash))) 3481 return FALSE; 3482 3483 h = (struct ecoff_link_hash_entry *) *sym_hash; 3484 3485 /* If we are building an ECOFF hash table, save the external 3486 symbol information. */ 3487 if (info->hash->creator->flavour == bfd_get_flavour (abfd)) 3488 { 3489 if (h->abfd == NULL 3490 || (! bfd_is_und_section (section) 3491 && (! bfd_is_com_section (section) 3492 || (h->root.type != bfd_link_hash_defined 3493 && h->root.type != bfd_link_hash_defweak)))) 3494 { 3495 h->abfd = abfd; 3496 h->esym = esym; 3497 } 3498 3499 /* Remember whether this symbol was small undefined. */ 3500 if (esym.asym.sc == scSUndefined) 3501 h->small = 1; 3502 3503 /* If this symbol was ever small undefined, it needs to wind 3504 up in a GP relative section. We can't control the 3505 section of a defined symbol, but we can control the 3506 section of a common symbol. This case is actually needed 3507 on Ultrix 4.2 to handle the symbol cred in -lckrb. */ 3508 if (h->small 3509 && h->root.type == bfd_link_hash_common 3510 && streq (h->root.u.c.p->section->name, SCOMMON)) 3511 { 3512 h->root.u.c.p->section = bfd_make_section_old_way (abfd, 3513 SCOMMON); 3514 h->root.u.c.p->section->flags = SEC_ALLOC; 3515 if (h->esym.asym.sc == scCommon) 3516 h->esym.asym.sc = scSCommon; 3517 } 3518 } 3519 } 3520 3521 return TRUE; 3522} 3523 3524/* Add symbols from an ECOFF object file to the global linker hash 3525 table. */ 3526 3527static bfd_boolean 3528ecoff_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info) 3529{ 3530 HDRR *symhdr; 3531 bfd_size_type external_ext_size; 3532 void * external_ext = NULL; 3533 bfd_size_type esize; 3534 char *ssext = NULL; 3535 bfd_boolean result; 3536 3537 if (! ecoff_slurp_symbolic_header (abfd)) 3538 return FALSE; 3539 3540 /* If there are no symbols, we don't want it. */ 3541 if (bfd_get_symcount (abfd) == 0) 3542 return TRUE; 3543 3544 symhdr = &ecoff_data (abfd)->debug_info.symbolic_header; 3545 3546 /* Read in the external symbols and external strings. */ 3547 external_ext_size = ecoff_backend (abfd)->debug_swap.external_ext_size; 3548 esize = symhdr->iextMax * external_ext_size; 3549 external_ext = bfd_malloc (esize); 3550 if (external_ext == NULL && esize != 0) 3551 goto error_return; 3552 3553 if (bfd_seek (abfd, (file_ptr) symhdr->cbExtOffset, SEEK_SET) != 0 3554 || bfd_bread (external_ext, esize, abfd) != esize) 3555 goto error_return; 3556 3557 ssext = bfd_malloc ((bfd_size_type) symhdr->issExtMax); 3558 if (ssext == NULL && symhdr->issExtMax != 0) 3559 goto error_return; 3560 3561 if (bfd_seek (abfd, (file_ptr) symhdr->cbSsExtOffset, SEEK_SET) != 0 3562 || (bfd_bread (ssext, (bfd_size_type) symhdr->issExtMax, abfd) 3563 != (bfd_size_type) symhdr->issExtMax)) 3564 goto error_return; 3565 3566 result = ecoff_link_add_externals (abfd, info, external_ext, ssext); 3567 3568 if (ssext != NULL) 3569 free (ssext); 3570 if (external_ext != NULL) 3571 free (external_ext); 3572 return result; 3573 3574 error_return: 3575 if (ssext != NULL) 3576 free (ssext); 3577 if (external_ext != NULL) 3578 free (external_ext); 3579 return FALSE; 3580} 3581 3582/* This is called if we used _bfd_generic_link_add_archive_symbols 3583 because we were not dealing with an ECOFF archive. */ 3584 3585static bfd_boolean 3586ecoff_link_check_archive_element (bfd *abfd, 3587 struct bfd_link_info *info, 3588 bfd_boolean *pneeded) 3589{ 3590 const struct ecoff_backend_data * const backend = ecoff_backend (abfd); 3591 void (* const swap_ext_in) (bfd *, void *, EXTR *) 3592 = backend->debug_swap.swap_ext_in; 3593 HDRR *symhdr; 3594 bfd_size_type external_ext_size; 3595 void * external_ext = NULL; 3596 bfd_size_type esize; 3597 char *ssext = NULL; 3598 char *ext_ptr; 3599 char *ext_end; 3600 3601 *pneeded = FALSE; 3602 3603 if (! ecoff_slurp_symbolic_header (abfd)) 3604 goto error_return; 3605 3606 /* If there are no symbols, we don't want it. */ 3607 if (bfd_get_symcount (abfd) == 0) 3608 goto successful_return; 3609 3610 symhdr = &ecoff_data (abfd)->debug_info.symbolic_header; 3611 3612 /* Read in the external symbols and external strings. */ 3613 external_ext_size = backend->debug_swap.external_ext_size; 3614 esize = symhdr->iextMax * external_ext_size; 3615 external_ext = bfd_malloc (esize); 3616 if (external_ext == NULL && esize != 0) 3617 goto error_return; 3618 3619 if (bfd_seek (abfd, (file_ptr) symhdr->cbExtOffset, SEEK_SET) != 0 3620 || bfd_bread (external_ext, esize, abfd) != esize) 3621 goto error_return; 3622 3623 ssext = bfd_malloc ((bfd_size_type) symhdr->issExtMax); 3624 if (ssext == NULL && symhdr->issExtMax != 0) 3625 goto error_return; 3626 3627 if (bfd_seek (abfd, (file_ptr) symhdr->cbSsExtOffset, SEEK_SET) != 0 3628 || (bfd_bread (ssext, (bfd_size_type) symhdr->issExtMax, abfd) 3629 != (bfd_size_type) symhdr->issExtMax)) 3630 goto error_return; 3631 3632 /* Look through the external symbols to see if they define some 3633 symbol that is currently undefined. */ 3634 ext_ptr = (char *) external_ext; 3635 ext_end = ext_ptr + esize; 3636 for (; ext_ptr < ext_end; ext_ptr += external_ext_size) 3637 { 3638 EXTR esym; 3639 bfd_boolean def; 3640 const char *name; 3641 struct bfd_link_hash_entry *h; 3642 3643 (*swap_ext_in) (abfd, (void *) ext_ptr, &esym); 3644 3645 /* See if this symbol defines something. */ 3646 if (esym.asym.st != stGlobal 3647 && esym.asym.st != stLabel 3648 && esym.asym.st != stProc) 3649 continue; 3650 3651 switch (esym.asym.sc) 3652 { 3653 case scText: 3654 case scData: 3655 case scBss: 3656 case scAbs: 3657 case scSData: 3658 case scSBss: 3659 case scRData: 3660 case scCommon: 3661 case scSCommon: 3662 case scInit: 3663 case scFini: 3664 case scRConst: 3665 def = TRUE; 3666 break; 3667 default: 3668 def = FALSE; 3669 break; 3670 } 3671 3672 if (! def) 3673 continue; 3674 3675 name = ssext + esym.asym.iss; 3676 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE); 3677 3678 /* Unlike the generic linker, we do not pull in elements because 3679 of common symbols. */ 3680 if (h == NULL 3681 || h->type != bfd_link_hash_undefined) 3682 continue; 3683 3684 /* Include this element. */ 3685 if (! (*info->callbacks->add_archive_element) (info, abfd, name)) 3686 goto error_return; 3687 if (! ecoff_link_add_externals (abfd, info, external_ext, ssext)) 3688 goto error_return; 3689 3690 *pneeded = TRUE; 3691 goto successful_return; 3692 } 3693 3694 successful_return: 3695 if (external_ext != NULL) 3696 free (external_ext); 3697 if (ssext != NULL) 3698 free (ssext); 3699 return TRUE; 3700 error_return: 3701 if (external_ext != NULL) 3702 free (external_ext); 3703 if (ssext != NULL) 3704 free (ssext); 3705 return FALSE; 3706} 3707 3708/* Add the symbols from an archive file to the global hash table. 3709 This looks through the undefined symbols, looks each one up in the 3710 archive hash table, and adds any associated object file. We do not 3711 use _bfd_generic_link_add_archive_symbols because ECOFF archives 3712 already have a hash table, so there is no reason to construct 3713 another one. */ 3714 3715static bfd_boolean 3716ecoff_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info) 3717{ 3718 const struct ecoff_backend_data * const backend = ecoff_backend (abfd); 3719 const bfd_byte *raw_armap; 3720 struct bfd_link_hash_entry **pundef; 3721 unsigned int armap_count; 3722 unsigned int armap_log; 3723 unsigned int i; 3724 const bfd_byte *hashtable; 3725 const char *stringbase; 3726 3727 if (! bfd_has_map (abfd)) 3728 { 3729 /* An empty archive is a special case. */ 3730 if (bfd_openr_next_archived_file (abfd, NULL) == NULL) 3731 return TRUE; 3732 bfd_set_error (bfd_error_no_armap); 3733 return FALSE; 3734 } 3735 3736 /* If we don't have any raw data for this archive, as can happen on 3737 Irix 4.0.5F, we call the generic routine. 3738 FIXME: We should be more clever about this, since someday tdata 3739 may get to something for a generic archive. */ 3740 raw_armap = (const bfd_byte *) bfd_ardata (abfd)->tdata; 3741 if (raw_armap == NULL) 3742 return (_bfd_generic_link_add_archive_symbols 3743 (abfd, info, ecoff_link_check_archive_element)); 3744 3745 armap_count = H_GET_32 (abfd, raw_armap); 3746 3747 armap_log = 0; 3748 for (i = 1; i < armap_count; i <<= 1) 3749 armap_log++; 3750 BFD_ASSERT (i == armap_count); 3751 3752 hashtable = raw_armap + 4; 3753 stringbase = (const char *) raw_armap + armap_count * 8 + 8; 3754 3755 /* Look through the list of undefined symbols. */ 3756 pundef = &info->hash->undefs; 3757 while (*pundef != NULL) 3758 { 3759 struct bfd_link_hash_entry *h; 3760 unsigned int hash, rehash; 3761 unsigned int file_offset; 3762 const char *name; 3763 bfd *element; 3764 3765 h = *pundef; 3766 3767 /* When a symbol is defined, it is not necessarily removed from 3768 the list. */ 3769 if (h->type != bfd_link_hash_undefined 3770 && h->type != bfd_link_hash_common) 3771 { 3772 /* Remove this entry from the list, for general cleanliness 3773 and because we are going to look through the list again 3774 if we search any more libraries. We can't remove the 3775 entry if it is the tail, because that would lose any 3776 entries we add to the list later on. */ 3777 if (*pundef != info->hash->undefs_tail) 3778 *pundef = (*pundef)->u.undef.next; 3779 else 3780 pundef = &(*pundef)->u.undef.next; 3781 continue; 3782 } 3783 3784 /* Native ECOFF linkers do not pull in archive elements merely 3785 to satisfy common definitions, so neither do we. We leave 3786 them on the list, though, in case we are linking against some 3787 other object format. */ 3788 if (h->type != bfd_link_hash_undefined) 3789 { 3790 pundef = &(*pundef)->u.undef.next; 3791 continue; 3792 } 3793 3794 /* Look for this symbol in the archive hash table. */ 3795 hash = ecoff_armap_hash (h->root.string, &rehash, armap_count, 3796 armap_log); 3797 3798 file_offset = H_GET_32 (abfd, hashtable + (hash * 8) + 4); 3799 if (file_offset == 0) 3800 { 3801 /* Nothing in this slot. */ 3802 pundef = &(*pundef)->u.undef.next; 3803 continue; 3804 } 3805 3806 name = stringbase + H_GET_32 (abfd, hashtable + (hash * 8)); 3807 if (name[0] != h->root.string[0] 3808 || ! streq (name, h->root.string)) 3809 { 3810 unsigned int srch; 3811 bfd_boolean found; 3812 3813 /* That was the wrong symbol. Try rehashing. */ 3814 found = FALSE; 3815 for (srch = (hash + rehash) & (armap_count - 1); 3816 srch != hash; 3817 srch = (srch + rehash) & (armap_count - 1)) 3818 { 3819 file_offset = H_GET_32 (abfd, hashtable + (srch * 8) + 4); 3820 if (file_offset == 0) 3821 break; 3822 name = stringbase + H_GET_32 (abfd, hashtable + (srch * 8)); 3823 if (name[0] == h->root.string[0] 3824 && streq (name, h->root.string)) 3825 { 3826 found = TRUE; 3827 break; 3828 } 3829 } 3830 3831 if (! found) 3832 { 3833 pundef = &(*pundef)->u.undef.next; 3834 continue; 3835 } 3836 3837 hash = srch; 3838 } 3839 3840 element = (*backend->get_elt_at_filepos) (abfd, (file_ptr) file_offset); 3841 if (element == NULL) 3842 return FALSE; 3843 3844 if (! bfd_check_format (element, bfd_object)) 3845 return FALSE; 3846 3847 /* Unlike the generic linker, we know that this element provides 3848 a definition for an undefined symbol and we know that we want 3849 to include it. We don't need to check anything. */ 3850 if (! (*info->callbacks->add_archive_element) (info, element, name)) 3851 return FALSE; 3852 if (! ecoff_link_add_object_symbols (element, info)) 3853 return FALSE; 3854 3855 pundef = &(*pundef)->u.undef.next; 3856 } 3857 3858 return TRUE; 3859} 3860 3861/* Given an ECOFF BFD, add symbols to the global hash table as 3862 appropriate. */ 3863 3864bfd_boolean 3865_bfd_ecoff_bfd_link_add_symbols (bfd *abfd, struct bfd_link_info *info) 3866{ 3867 switch (bfd_get_format (abfd)) 3868 { 3869 case bfd_object: 3870 return ecoff_link_add_object_symbols (abfd, info); 3871 case bfd_archive: 3872 return ecoff_link_add_archive_symbols (abfd, info); 3873 default: 3874 bfd_set_error (bfd_error_wrong_format); 3875 return FALSE; 3876 } 3877} 3878 3879 3880/* ECOFF final link routines. */ 3881 3882/* Structure used to pass information to ecoff_link_write_external. */ 3883 3884struct extsym_info 3885{ 3886 bfd *abfd; 3887 struct bfd_link_info *info; 3888}; 3889 3890/* Accumulate the debugging information for an input BFD into the 3891 output BFD. This must read in the symbolic information of the 3892 input BFD. */ 3893 3894static bfd_boolean 3895ecoff_final_link_debug_accumulate (bfd *output_bfd, 3896 bfd *input_bfd, 3897 struct bfd_link_info *info, 3898 void * handle) 3899{ 3900 struct ecoff_debug_info * const debug = &ecoff_data (input_bfd)->debug_info; 3901 const struct ecoff_debug_swap * const swap = 3902 &ecoff_backend (input_bfd)->debug_swap; 3903 HDRR *symhdr = &debug->symbolic_header; 3904 bfd_boolean ret; 3905 3906#define READ(ptr, offset, count, size, type) \ 3907 if (symhdr->count == 0) \ 3908 debug->ptr = NULL; \ 3909 else \ 3910 { \ 3911 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \ 3912 debug->ptr = bfd_malloc (amt); \ 3913 if (debug->ptr == NULL) \ 3914 { \ 3915 ret = FALSE; \ 3916 goto return_something; \ 3917 } \ 3918 if (bfd_seek (input_bfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \ 3919 || bfd_bread (debug->ptr, amt, input_bfd) != amt) \ 3920 { \ 3921 ret = FALSE; \ 3922 goto return_something; \ 3923 } \ 3924 } 3925 3926 /* If raw_syments is not NULL, then the data was already by read by 3927 _bfd_ecoff_slurp_symbolic_info. */ 3928 if (ecoff_data (input_bfd)->raw_syments == NULL) 3929 { 3930 READ (line, cbLineOffset, cbLine, sizeof (unsigned char), 3931 unsigned char *); 3932 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, void *); 3933 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, void *); 3934 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, void *); 3935 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, void *); 3936 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext), 3937 union aux_ext *); 3938 READ (ss, cbSsOffset, issMax, sizeof (char), char *); 3939 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, void *); 3940 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, void *); 3941 } 3942#undef READ 3943 3944 /* We do not read the external strings or the external symbols. */ 3945 3946 ret = (bfd_ecoff_debug_accumulate 3947 (handle, output_bfd, &ecoff_data (output_bfd)->debug_info, 3948 &ecoff_backend (output_bfd)->debug_swap, 3949 input_bfd, debug, swap, info)); 3950 3951 return_something: 3952 if (ecoff_data (input_bfd)->raw_syments == NULL) 3953 { 3954 if (debug->line != NULL) 3955 free (debug->line); 3956 if (debug->external_dnr != NULL) 3957 free (debug->external_dnr); 3958 if (debug->external_pdr != NULL) 3959 free (debug->external_pdr); 3960 if (debug->external_sym != NULL) 3961 free (debug->external_sym); 3962 if (debug->external_opt != NULL) 3963 free (debug->external_opt); 3964 if (debug->external_aux != NULL) 3965 free (debug->external_aux); 3966 if (debug->ss != NULL) 3967 free (debug->ss); 3968 if (debug->external_fdr != NULL) 3969 free (debug->external_fdr); 3970 if (debug->external_rfd != NULL) 3971 free (debug->external_rfd); 3972 3973 /* Make sure we don't accidentally follow one of these pointers 3974 into freed memory. */ 3975 debug->line = NULL; 3976 debug->external_dnr = NULL; 3977 debug->external_pdr = NULL; 3978 debug->external_sym = NULL; 3979 debug->external_opt = NULL; 3980 debug->external_aux = NULL; 3981 debug->ss = NULL; 3982 debug->external_fdr = NULL; 3983 debug->external_rfd = NULL; 3984 } 3985 3986 return ret; 3987} 3988 3989/* Relocate and write an ECOFF section into an ECOFF output file. */ 3990 3991static bfd_boolean 3992ecoff_indirect_link_order (bfd *output_bfd, 3993 struct bfd_link_info *info, 3994 asection *output_section, 3995 struct bfd_link_order *link_order) 3996{ 3997 asection *input_section; 3998 bfd *input_bfd; 3999 bfd_byte *contents = NULL; 4000 bfd_size_type external_reloc_size; 4001 bfd_size_type external_relocs_size; 4002 void * external_relocs = NULL; 4003 4004 BFD_ASSERT ((output_section->flags & SEC_HAS_CONTENTS) != 0); 4005 4006 input_section = link_order->u.indirect.section; 4007 input_bfd = input_section->owner; 4008 if (input_section->size == 0) 4009 return TRUE; 4010 4011 BFD_ASSERT (input_section->output_section == output_section); 4012 BFD_ASSERT (input_section->output_offset == link_order->offset); 4013 BFD_ASSERT (input_section->size == link_order->size); 4014 4015 /* Get the section contents. */ 4016 if (!bfd_malloc_and_get_section (input_bfd, input_section, &contents)) 4017 goto error_return; 4018 4019 /* Get the relocs. If we are relaxing MIPS code, they will already 4020 have been read in. Otherwise, we read them in now. */ 4021 external_reloc_size = ecoff_backend (input_bfd)->external_reloc_size; 4022 external_relocs_size = external_reloc_size * input_section->reloc_count; 4023 4024 external_relocs = bfd_malloc (external_relocs_size); 4025 if (external_relocs == NULL && external_relocs_size != 0) 4026 goto error_return; 4027 4028 if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0 4029 || (bfd_bread (external_relocs, external_relocs_size, input_bfd) 4030 != external_relocs_size)) 4031 goto error_return; 4032 4033 /* Relocate the section contents. */ 4034 if (! ((*ecoff_backend (input_bfd)->relocate_section) 4035 (output_bfd, info, input_bfd, input_section, contents, 4036 external_relocs))) 4037 goto error_return; 4038 4039 /* Write out the relocated section. */ 4040 if (! bfd_set_section_contents (output_bfd, 4041 output_section, 4042 contents, 4043 input_section->output_offset, 4044 input_section->size)) 4045 goto error_return; 4046 4047 /* If we are producing relocatable output, the relocs were 4048 modified, and we write them out now. We use the reloc_count 4049 field of output_section to keep track of the number of relocs we 4050 have output so far. */ 4051 if (info->relocatable) 4052 { 4053 file_ptr pos = (output_section->rel_filepos 4054 + output_section->reloc_count * external_reloc_size); 4055 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0 4056 || (bfd_bwrite (external_relocs, external_relocs_size, output_bfd) 4057 != external_relocs_size)) 4058 goto error_return; 4059 output_section->reloc_count += input_section->reloc_count; 4060 } 4061 4062 if (contents != NULL) 4063 free (contents); 4064 if (external_relocs != NULL) 4065 free (external_relocs); 4066 return TRUE; 4067 4068 error_return: 4069 if (contents != NULL) 4070 free (contents); 4071 if (external_relocs != NULL) 4072 free (external_relocs); 4073 return FALSE; 4074} 4075 4076/* Generate a reloc when linking an ECOFF file. This is a reloc 4077 requested by the linker, and does come from any input file. This 4078 is used to build constructor and destructor tables when linking 4079 with -Ur. */ 4080 4081static bfd_boolean 4082ecoff_reloc_link_order (bfd *output_bfd, 4083 struct bfd_link_info *info, 4084 asection *output_section, 4085 struct bfd_link_order *link_order) 4086{ 4087 enum bfd_link_order_type type; 4088 asection *section; 4089 bfd_vma addend; 4090 arelent rel; 4091 struct internal_reloc in; 4092 bfd_size_type external_reloc_size; 4093 bfd_byte *rbuf; 4094 bfd_boolean ok; 4095 file_ptr pos; 4096 4097 type = link_order->type; 4098 section = NULL; 4099 addend = link_order->u.reloc.p->addend; 4100 4101 /* We set up an arelent to pass to the backend adjust_reloc_out 4102 routine. */ 4103 rel.address = link_order->offset; 4104 4105 rel.howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc); 4106 if (rel.howto == 0) 4107 { 4108 bfd_set_error (bfd_error_bad_value); 4109 return FALSE; 4110 } 4111 4112 if (type == bfd_section_reloc_link_order) 4113 { 4114 section = link_order->u.reloc.p->u.section; 4115 rel.sym_ptr_ptr = section->symbol_ptr_ptr; 4116 } 4117 else 4118 { 4119 struct bfd_link_hash_entry *h; 4120 4121 /* Treat a reloc against a defined symbol as though it were 4122 actually against the section. */ 4123 h = bfd_wrapped_link_hash_lookup (output_bfd, info, 4124 link_order->u.reloc.p->u.name, 4125 FALSE, FALSE, FALSE); 4126 if (h != NULL 4127 && (h->type == bfd_link_hash_defined 4128 || h->type == bfd_link_hash_defweak)) 4129 { 4130 type = bfd_section_reloc_link_order; 4131 section = h->u.def.section->output_section; 4132 /* It seems that we ought to add the symbol value to the 4133 addend here, but in practice it has already been added 4134 because it was passed to constructor_callback. */ 4135 addend += section->vma + h->u.def.section->output_offset; 4136 } 4137 else 4138 { 4139 /* We can't set up a reloc against a symbol correctly, 4140 because we have no asymbol structure. Currently no 4141 adjust_reloc_out routine cares. */ 4142 rel.sym_ptr_ptr = NULL; 4143 } 4144 } 4145 4146 /* All ECOFF relocs are in-place. Put the addend into the object 4147 file. */ 4148 4149 BFD_ASSERT (rel.howto->partial_inplace); 4150 if (addend != 0) 4151 { 4152 bfd_size_type size; 4153 bfd_reloc_status_type rstat; 4154 bfd_byte *buf; 4155 4156 size = bfd_get_reloc_size (rel.howto); 4157 buf = bfd_zmalloc (size); 4158 if (buf == NULL) 4159 return FALSE; 4160 rstat = _bfd_relocate_contents (rel.howto, output_bfd, 4161 (bfd_vma) addend, buf); 4162 switch (rstat) 4163 { 4164 case bfd_reloc_ok: 4165 break; 4166 default: 4167 case bfd_reloc_outofrange: 4168 abort (); 4169 case bfd_reloc_overflow: 4170 if (! ((*info->callbacks->reloc_overflow) 4171 (info, NULL, 4172 (link_order->type == bfd_section_reloc_link_order 4173 ? bfd_section_name (output_bfd, section) 4174 : link_order->u.reloc.p->u.name), 4175 rel.howto->name, addend, NULL, 4176 NULL, (bfd_vma) 0))) 4177 { 4178 free (buf); 4179 return FALSE; 4180 } 4181 break; 4182 } 4183 ok = bfd_set_section_contents (output_bfd, output_section, (void *) buf, 4184 (file_ptr) link_order->offset, size); 4185 free (buf); 4186 if (! ok) 4187 return FALSE; 4188 } 4189 4190 rel.addend = 0; 4191 4192 /* Move the information into an internal_reloc structure. */ 4193 in.r_vaddr = (rel.address 4194 + bfd_get_section_vma (output_bfd, output_section)); 4195 in.r_type = rel.howto->type; 4196 4197 if (type == bfd_symbol_reloc_link_order) 4198 { 4199 struct ecoff_link_hash_entry *h; 4200 4201 h = ((struct ecoff_link_hash_entry *) 4202 bfd_wrapped_link_hash_lookup (output_bfd, info, 4203 link_order->u.reloc.p->u.name, 4204 FALSE, FALSE, TRUE)); 4205 if (h != NULL 4206 && h->indx != -1) 4207 in.r_symndx = h->indx; 4208 else 4209 { 4210 if (! ((*info->callbacks->unattached_reloc) 4211 (info, link_order->u.reloc.p->u.name, NULL, 4212 NULL, (bfd_vma) 0))) 4213 return FALSE; 4214 in.r_symndx = 0; 4215 } 4216 in.r_extern = 1; 4217 } 4218 else 4219 { 4220 const char *name; 4221 unsigned int i; 4222 static struct 4223 { 4224 const char * name; 4225 long r_symndx; 4226 } 4227 section_symndx [] = 4228 { 4229 { _TEXT, RELOC_SECTION_TEXT }, 4230 { _RDATA, RELOC_SECTION_RDATA }, 4231 { _DATA, RELOC_SECTION_DATA }, 4232 { _SDATA, RELOC_SECTION_SDATA }, 4233 { _SBSS, RELOC_SECTION_SBSS }, 4234 { _BSS, RELOC_SECTION_BSS }, 4235 { _INIT, RELOC_SECTION_INIT }, 4236 { _LIT8, RELOC_SECTION_LIT8 }, 4237 { _LIT4, RELOC_SECTION_LIT4 }, 4238 { _XDATA, RELOC_SECTION_XDATA }, 4239 { _PDATA, RELOC_SECTION_PDATA }, 4240 { _FINI, RELOC_SECTION_FINI }, 4241 { _LITA, RELOC_SECTION_LITA }, 4242 { "*ABS*", RELOC_SECTION_ABS }, 4243 { _RCONST, RELOC_SECTION_RCONST } 4244 }; 4245 4246 name = bfd_get_section_name (output_bfd, section); 4247 4248 for (i = 0; i < ARRAY_SIZE (section_symndx); i++) 4249 if (streq (name, section_symndx[i].name)) 4250 { 4251 in.r_symndx = section_symndx[i].r_symndx; 4252 break; 4253 } 4254 4255 if (i == ARRAY_SIZE (section_symndx)) 4256 abort (); 4257 4258 in.r_extern = 0; 4259 } 4260 4261 /* Let the BFD backend adjust the reloc. */ 4262 (*ecoff_backend (output_bfd)->adjust_reloc_out) (output_bfd, &rel, &in); 4263 4264 /* Get some memory and swap out the reloc. */ 4265 external_reloc_size = ecoff_backend (output_bfd)->external_reloc_size; 4266 rbuf = bfd_malloc (external_reloc_size); 4267 if (rbuf == NULL) 4268 return FALSE; 4269 4270 (*ecoff_backend (output_bfd)->swap_reloc_out) (output_bfd, &in, (void *) rbuf); 4271 4272 pos = (output_section->rel_filepos 4273 + output_section->reloc_count * external_reloc_size); 4274 ok = (bfd_seek (output_bfd, pos, SEEK_SET) == 0 4275 && (bfd_bwrite ((void *) rbuf, external_reloc_size, output_bfd) 4276 == external_reloc_size)); 4277 4278 if (ok) 4279 ++output_section->reloc_count; 4280 4281 free (rbuf); 4282 4283 return ok; 4284} 4285 4286/* Put out information for an external symbol. These come only from 4287 the hash table. */ 4288 4289static bfd_boolean 4290ecoff_link_write_external (struct ecoff_link_hash_entry *h, void * data) 4291{ 4292 struct extsym_info *einfo = (struct extsym_info *) data; 4293 bfd *output_bfd = einfo->abfd; 4294 bfd_boolean strip; 4295 4296 if (h->root.type == bfd_link_hash_warning) 4297 { 4298 h = (struct ecoff_link_hash_entry *) h->root.u.i.link; 4299 if (h->root.type == bfd_link_hash_new) 4300 return TRUE; 4301 } 4302 4303 /* We need to check if this symbol is being stripped. */ 4304 if (h->root.type == bfd_link_hash_undefined 4305 || h->root.type == bfd_link_hash_undefweak) 4306 strip = FALSE; 4307 else if (einfo->info->strip == strip_all 4308 || (einfo->info->strip == strip_some 4309 && bfd_hash_lookup (einfo->info->keep_hash, 4310 h->root.root.string, 4311 FALSE, FALSE) == NULL)) 4312 strip = TRUE; 4313 else 4314 strip = FALSE; 4315 4316 if (strip || h->written) 4317 return TRUE; 4318 4319 if (h->abfd == NULL) 4320 { 4321 h->esym.jmptbl = 0; 4322 h->esym.cobol_main = 0; 4323 h->esym.weakext = 0; 4324 h->esym.reserved = 0; 4325 h->esym.ifd = ifdNil; 4326 h->esym.asym.value = 0; 4327 h->esym.asym.st = stGlobal; 4328 4329 if (h->root.type != bfd_link_hash_defined 4330 && h->root.type != bfd_link_hash_defweak) 4331 h->esym.asym.sc = scAbs; 4332 else 4333 { 4334 asection *output_section; 4335 const char *name; 4336 unsigned int i; 4337 static struct 4338 { 4339 const char * name; 4340 int sc; 4341 } 4342 section_storage_classes [] = 4343 { 4344 { _TEXT, scText }, 4345 { _DATA, scData }, 4346 { _SDATA, scSData }, 4347 { _RDATA, scRData }, 4348 { _BSS, scBss }, 4349 { _SBSS, scSBss }, 4350 { _INIT, scInit }, 4351 { _FINI, scFini }, 4352 { _PDATA, scPData }, 4353 { _XDATA, scXData }, 4354 { _RCONST, scRConst } 4355 }; 4356 4357 output_section = h->root.u.def.section->output_section; 4358 name = bfd_section_name (output_section->owner, output_section); 4359 4360 for (i = 0; i < ARRAY_SIZE (section_storage_classes); i++) 4361 if (streq (name, section_storage_classes[i].name)) 4362 { 4363 h->esym.asym.sc = section_storage_classes[i].sc; 4364 break; 4365 } 4366 4367 if (i == ARRAY_SIZE (section_storage_classes)) 4368 h->esym.asym.sc = scAbs; 4369 } 4370 4371 h->esym.asym.reserved = 0; 4372 h->esym.asym.index = indexNil; 4373 } 4374 else if (h->esym.ifd != -1) 4375 { 4376 struct ecoff_debug_info *debug; 4377 4378 /* Adjust the FDR index for the symbol by that used for the 4379 input BFD. */ 4380 debug = &ecoff_data (h->abfd)->debug_info; 4381 BFD_ASSERT (h->esym.ifd >= 0 4382 && h->esym.ifd < debug->symbolic_header.ifdMax); 4383 h->esym.ifd = debug->ifdmap[h->esym.ifd]; 4384 } 4385 4386 switch (h->root.type) 4387 { 4388 default: 4389 case bfd_link_hash_warning: 4390 case bfd_link_hash_new: 4391 abort (); 4392 case bfd_link_hash_undefined: 4393 case bfd_link_hash_undefweak: 4394 if (h->esym.asym.sc != scUndefined 4395 && h->esym.asym.sc != scSUndefined) 4396 h->esym.asym.sc = scUndefined; 4397 break; 4398 case bfd_link_hash_defined: 4399 case bfd_link_hash_defweak: 4400 if (h->esym.asym.sc == scUndefined 4401 || h->esym.asym.sc == scSUndefined) 4402 h->esym.asym.sc = scAbs; 4403 else if (h->esym.asym.sc == scCommon) 4404 h->esym.asym.sc = scBss; 4405 else if (h->esym.asym.sc == scSCommon) 4406 h->esym.asym.sc = scSBss; 4407 h->esym.asym.value = (h->root.u.def.value 4408 + h->root.u.def.section->output_section->vma 4409 + h->root.u.def.section->output_offset); 4410 break; 4411 case bfd_link_hash_common: 4412 if (h->esym.asym.sc != scCommon 4413 && h->esym.asym.sc != scSCommon) 4414 h->esym.asym.sc = scCommon; 4415 h->esym.asym.value = h->root.u.c.size; 4416 break; 4417 case bfd_link_hash_indirect: 4418 /* We ignore these symbols, since the indirected symbol is 4419 already in the hash table. */ 4420 return TRUE; 4421 } 4422 4423 /* bfd_ecoff_debug_one_external uses iextMax to keep track of the 4424 symbol number. */ 4425 h->indx = ecoff_data (output_bfd)->debug_info.symbolic_header.iextMax; 4426 h->written = 1; 4427 4428 return (bfd_ecoff_debug_one_external 4429 (output_bfd, &ecoff_data (output_bfd)->debug_info, 4430 &ecoff_backend (output_bfd)->debug_swap, h->root.root.string, 4431 &h->esym)); 4432} 4433 4434/* ECOFF final link routine. This looks through all the input BFDs 4435 and gathers together all the debugging information, and then 4436 processes all the link order information. This may cause it to 4437 close and reopen some input BFDs; I'll see how bad this is. */ 4438 4439bfd_boolean 4440_bfd_ecoff_bfd_final_link (bfd *abfd, struct bfd_link_info *info) 4441{ 4442 const struct ecoff_backend_data * const backend = ecoff_backend (abfd); 4443 struct ecoff_debug_info * const debug = &ecoff_data (abfd)->debug_info; 4444 HDRR *symhdr; 4445 void * handle; 4446 bfd *input_bfd; 4447 asection *o; 4448 struct bfd_link_order *p; 4449 struct extsym_info einfo; 4450 4451 /* We accumulate the debugging information counts in the symbolic 4452 header. */ 4453 symhdr = &debug->symbolic_header; 4454 symhdr->vstamp = 0; 4455 symhdr->ilineMax = 0; 4456 symhdr->cbLine = 0; 4457 symhdr->idnMax = 0; 4458 symhdr->ipdMax = 0; 4459 symhdr->isymMax = 0; 4460 symhdr->ioptMax = 0; 4461 symhdr->iauxMax = 0; 4462 symhdr->issMax = 0; 4463 symhdr->issExtMax = 0; 4464 symhdr->ifdMax = 0; 4465 symhdr->crfd = 0; 4466 symhdr->iextMax = 0; 4467 4468 /* We accumulate the debugging information itself in the debug_info 4469 structure. */ 4470 debug->line = NULL; 4471 debug->external_dnr = NULL; 4472 debug->external_pdr = NULL; 4473 debug->external_sym = NULL; 4474 debug->external_opt = NULL; 4475 debug->external_aux = NULL; 4476 debug->ss = NULL; 4477 debug->ssext = debug->ssext_end = NULL; 4478 debug->external_fdr = NULL; 4479 debug->external_rfd = NULL; 4480 debug->external_ext = debug->external_ext_end = NULL; 4481 4482 handle = bfd_ecoff_debug_init (abfd, debug, &backend->debug_swap, info); 4483 if (handle == NULL) 4484 return FALSE; 4485 4486 /* Accumulate the debugging symbols from each input BFD. */ 4487 for (input_bfd = info->input_bfds; 4488 input_bfd != NULL; 4489 input_bfd = input_bfd->link_next) 4490 { 4491 bfd_boolean ret; 4492 4493 if (bfd_get_flavour (input_bfd) == bfd_target_ecoff_flavour) 4494 { 4495 /* Arbitrarily set the symbolic header vstamp to the vstamp 4496 of the first object file in the link. */ 4497 if (symhdr->vstamp == 0) 4498 symhdr->vstamp 4499 = ecoff_data (input_bfd)->debug_info.symbolic_header.vstamp; 4500 ret = ecoff_final_link_debug_accumulate (abfd, input_bfd, info, 4501 handle); 4502 } 4503 else 4504 ret = bfd_ecoff_debug_accumulate_other (handle, abfd, 4505 debug, &backend->debug_swap, 4506 input_bfd, info); 4507 if (! ret) 4508 return FALSE; 4509 4510 /* Combine the register masks. */ 4511 ecoff_data (abfd)->gprmask |= ecoff_data (input_bfd)->gprmask; 4512 ecoff_data (abfd)->fprmask |= ecoff_data (input_bfd)->fprmask; 4513 ecoff_data (abfd)->cprmask[0] |= ecoff_data (input_bfd)->cprmask[0]; 4514 ecoff_data (abfd)->cprmask[1] |= ecoff_data (input_bfd)->cprmask[1]; 4515 ecoff_data (abfd)->cprmask[2] |= ecoff_data (input_bfd)->cprmask[2]; 4516 ecoff_data (abfd)->cprmask[3] |= ecoff_data (input_bfd)->cprmask[3]; 4517 } 4518 4519 /* Write out the external symbols. */ 4520 einfo.abfd = abfd; 4521 einfo.info = info; 4522 ecoff_link_hash_traverse (ecoff_hash_table (info), 4523 ecoff_link_write_external, 4524 (void *) &einfo); 4525 4526 if (info->relocatable) 4527 { 4528 /* We need to make a pass over the link_orders to count up the 4529 number of relocations we will need to output, so that we know 4530 how much space they will take up. */ 4531 for (o = abfd->sections; o != NULL; o = o->next) 4532 { 4533 o->reloc_count = 0; 4534 for (p = o->map_head.link_order; 4535 p != NULL; 4536 p = p->next) 4537 if (p->type == bfd_indirect_link_order) 4538 o->reloc_count += p->u.indirect.section->reloc_count; 4539 else if (p->type == bfd_section_reloc_link_order 4540 || p->type == bfd_symbol_reloc_link_order) 4541 ++o->reloc_count; 4542 } 4543 } 4544 4545 /* Compute the reloc and symbol file positions. */ 4546 ecoff_compute_reloc_file_positions (abfd); 4547 4548 /* Write out the debugging information. */ 4549 if (! bfd_ecoff_write_accumulated_debug (handle, abfd, debug, 4550 &backend->debug_swap, info, 4551 ecoff_data (abfd)->sym_filepos)) 4552 return FALSE; 4553 4554 bfd_ecoff_debug_free (handle, abfd, debug, &backend->debug_swap, info); 4555 4556 if (info->relocatable) 4557 { 4558 /* Now reset the reloc_count field of the sections in the output 4559 BFD to 0, so that we can use them to keep track of how many 4560 relocs we have output thus far. */ 4561 for (o = abfd->sections; o != NULL; o = o->next) 4562 o->reloc_count = 0; 4563 } 4564 4565 /* Get a value for the GP register. */ 4566 if (ecoff_data (abfd)->gp == 0) 4567 { 4568 struct bfd_link_hash_entry *h; 4569 4570 h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE); 4571 if (h != NULL 4572 && h->type == bfd_link_hash_defined) 4573 ecoff_data (abfd)->gp = (h->u.def.value 4574 + h->u.def.section->output_section->vma 4575 + h->u.def.section->output_offset); 4576 else if (info->relocatable) 4577 { 4578 bfd_vma lo; 4579 4580 /* Make up a value. */ 4581 lo = (bfd_vma) -1; 4582 for (o = abfd->sections; o != NULL; o = o->next) 4583 { 4584 if (o->vma < lo 4585 && (streq (o->name, _SBSS) 4586 || streq (o->name, _SDATA) 4587 || streq (o->name, _LIT4) 4588 || streq (o->name, _LIT8) 4589 || streq (o->name, _LITA))) 4590 lo = o->vma; 4591 } 4592 ecoff_data (abfd)->gp = lo + 0x8000; 4593 } 4594 else 4595 { 4596 /* If the relocate_section function needs to do a reloc 4597 involving the GP value, it should make a reloc_dangerous 4598 callback to warn that GP is not defined. */ 4599 } 4600 } 4601 4602 for (o = abfd->sections; o != NULL; o = o->next) 4603 { 4604 for (p = o->map_head.link_order; 4605 p != NULL; 4606 p = p->next) 4607 { 4608 if (p->type == bfd_indirect_link_order 4609 && (bfd_get_flavour (p->u.indirect.section->owner) 4610 == bfd_target_ecoff_flavour)) 4611 { 4612 if (! ecoff_indirect_link_order (abfd, info, o, p)) 4613 return FALSE; 4614 } 4615 else if (p->type == bfd_section_reloc_link_order 4616 || p->type == bfd_symbol_reloc_link_order) 4617 { 4618 if (! ecoff_reloc_link_order (abfd, info, o, p)) 4619 return FALSE; 4620 } 4621 else 4622 { 4623 if (! _bfd_default_link_order (abfd, info, o, p)) 4624 return FALSE; 4625 } 4626 } 4627 } 4628 4629 bfd_get_symcount (abfd) = symhdr->iextMax + symhdr->isymMax; 4630 4631 ecoff_data (abfd)->linker = TRUE; 4632 4633 return TRUE; 4634} 4635