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. */ 53 static 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 85 bfd_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 100 void * 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 142 bfd_boolean 143 _bfd_ecoff_new_section_hook (bfd *abfd ATTRIBUTE_UNUSED, 144 asection *section) 145 { 146 unsigned int i; 147 static struct 148 { 149 const char * name; 150 flagword flags; 151 } 152 section_flags [] = 153 { 154 { _TEXT, SEC_ALLOC | SEC_CODE | SEC_LOAD }, 155 { _INIT, SEC_ALLOC | SEC_CODE | SEC_LOAD }, 156 { _FINI, SEC_ALLOC | SEC_CODE | SEC_LOAD }, 157 { _DATA, SEC_ALLOC | SEC_DATA | SEC_LOAD }, 158 { _SDATA, SEC_ALLOC | SEC_DATA | SEC_LOAD }, 159 { _RDATA, SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY}, 160 { _LIT8, SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY}, 161 { _LIT4, SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY}, 162 { _RCONST, SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY}, 163 { _PDATA, SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY}, 164 { _BSS, SEC_ALLOC}, 165 { _SBSS, SEC_ALLOC}, 166 /* An Irix 4 shared libary. */ 167 { _LIB, SEC_COFF_SHARED_LIBRARY} 168 }; 169 170 section->alignment_power = 4; 171 172 for (i = 0; i < ARRAY_SIZE (section_flags); i++) 173 if (streq (section->name, section_flags[i].name)) 174 { 175 section->flags |= section_flags[i].flags; 176 break; 177 } 178 179 180 /* Probably any other section name is SEC_NEVER_LOAD, but I'm 181 uncertain about .init on some systems and I don't know how shared 182 libraries work. */ 183 184 return TRUE; 185 } 186 187 /* Determine the machine architecture and type. This is called from 188 the generic COFF routines. It is the inverse of ecoff_get_magic, 189 below. This could be an ECOFF backend routine, with one version 190 for each target, but there aren't all that many ECOFF targets. */ 191 192 bfd_boolean 193 _bfd_ecoff_set_arch_mach_hook (bfd *abfd, void * filehdr) 194 { 195 struct internal_filehdr *internal_f = filehdr; 196 enum bfd_architecture arch; 197 unsigned long mach; 198 199 switch (internal_f->f_magic) 200 { 201 case MIPS_MAGIC_1: 202 case MIPS_MAGIC_LITTLE: 203 case MIPS_MAGIC_BIG: 204 arch = bfd_arch_mips; 205 mach = bfd_mach_mips3000; 206 break; 207 208 case MIPS_MAGIC_LITTLE2: 209 case MIPS_MAGIC_BIG2: 210 /* MIPS ISA level 2: the r6000. */ 211 arch = bfd_arch_mips; 212 mach = bfd_mach_mips6000; 213 break; 214 215 case MIPS_MAGIC_LITTLE3: 216 case MIPS_MAGIC_BIG3: 217 /* MIPS ISA level 3: the r4000. */ 218 arch = bfd_arch_mips; 219 mach = bfd_mach_mips4000; 220 break; 221 222 case ALPHA_MAGIC: 223 arch = bfd_arch_alpha; 224 mach = 0; 225 break; 226 227 default: 228 arch = bfd_arch_obscure; 229 mach = 0; 230 break; 231 } 232 233 return bfd_default_set_arch_mach (abfd, arch, mach); 234 } 235 236 /* Get the magic number to use based on the architecture and machine. 237 This is the inverse of _bfd_ecoff_set_arch_mach_hook, above. */ 238 239 static int 240 ecoff_get_magic (bfd *abfd) 241 { 242 int big, little; 243 244 switch (bfd_get_arch (abfd)) 245 { 246 case bfd_arch_mips: 247 switch (bfd_get_mach (abfd)) 248 { 249 default: 250 case 0: 251 case bfd_mach_mips3000: 252 big = MIPS_MAGIC_BIG; 253 little = MIPS_MAGIC_LITTLE; 254 break; 255 256 case bfd_mach_mips6000: 257 big = MIPS_MAGIC_BIG2; 258 little = MIPS_MAGIC_LITTLE2; 259 break; 260 261 case bfd_mach_mips4000: 262 big = MIPS_MAGIC_BIG3; 263 little = MIPS_MAGIC_LITTLE3; 264 break; 265 } 266 267 return bfd_big_endian (abfd) ? big : little; 268 269 case bfd_arch_alpha: 270 return ALPHA_MAGIC; 271 272 default: 273 abort (); 274 return 0; 275 } 276 } 277 278 /* Get the section s_flags to use for a section. */ 279 280 static long 281 ecoff_sec_to_styp_flags (const char *name, flagword flags) 282 { 283 unsigned int i; 284 static struct 285 { 286 const char * name; 287 long flags; 288 } 289 styp_flags [] = 290 { 291 { _TEXT, STYP_TEXT }, 292 { _DATA, STYP_DATA }, 293 { _SDATA, STYP_SDATA }, 294 { _RDATA, STYP_RDATA }, 295 { _LITA, STYP_LITA }, 296 { _LIT8, STYP_LIT8 }, 297 { _LIT4, STYP_LIT4 }, 298 { _BSS, STYP_BSS }, 299 { _SBSS, STYP_SBSS }, 300 { _INIT, STYP_ECOFF_INIT }, 301 { _FINI, STYP_ECOFF_FINI }, 302 { _PDATA, STYP_PDATA }, 303 { _XDATA, STYP_XDATA }, 304 { _LIB, STYP_ECOFF_LIB }, 305 { _GOT, STYP_GOT }, 306 { _HASH, STYP_HASH }, 307 { _DYNAMIC, STYP_DYNAMIC }, 308 { _LIBLIST, STYP_LIBLIST }, 309 { _RELDYN, STYP_RELDYN }, 310 { _CONFLIC, STYP_CONFLIC }, 311 { _DYNSTR, STYP_DYNSTR }, 312 { _DYNSYM, STYP_DYNSYM }, 313 { _RCONST, STYP_RCONST } 314 }; 315 long styp = 0; 316 317 for (i = 0; i < ARRAY_SIZE (styp_flags); i++) 318 if (streq (name, styp_flags[i].name)) 319 { 320 styp = styp_flags[i].flags; 321 break; 322 } 323 324 if (styp == 0) 325 { 326 if (streq (name, _COMMENT)) 327 { 328 styp = STYP_COMMENT; 329 flags &=~ SEC_NEVER_LOAD; 330 } 331 else if (flags & SEC_CODE) 332 styp = STYP_TEXT; 333 else if (flags & SEC_DATA) 334 styp = STYP_DATA; 335 else if (flags & SEC_READONLY) 336 styp = STYP_RDATA; 337 else if (flags & SEC_LOAD) 338 styp = STYP_REG; 339 else 340 styp = STYP_BSS; 341 } 342 343 if (flags & SEC_NEVER_LOAD) 344 styp |= STYP_NOLOAD; 345 346 return styp; 347 } 348 349 /* Get the BFD flags to use for a section. */ 350 351 bfd_boolean 352 _bfd_ecoff_styp_to_sec_flags (bfd *abfd ATTRIBUTE_UNUSED, 353 void * hdr, 354 const char *name ATTRIBUTE_UNUSED, 355 asection *section ATTRIBUTE_UNUSED, 356 flagword * flags_ptr) 357 { 358 struct internal_scnhdr *internal_s = hdr; 359 long styp_flags = internal_s->s_flags; 360 flagword sec_flags = 0; 361 362 if (styp_flags & STYP_NOLOAD) 363 sec_flags |= SEC_NEVER_LOAD; 364 365 /* For 386 COFF, at least, an unloadable text or data section is 366 actually a shared library section. */ 367 if ((styp_flags & STYP_TEXT) 368 || (styp_flags & STYP_ECOFF_INIT) 369 || (styp_flags & STYP_ECOFF_FINI) 370 || (styp_flags & STYP_DYNAMIC) 371 || (styp_flags & STYP_LIBLIST) 372 || (styp_flags & STYP_RELDYN) 373 || styp_flags == STYP_CONFLIC 374 || (styp_flags & STYP_DYNSTR) 375 || (styp_flags & STYP_DYNSYM) 376 || (styp_flags & STYP_HASH)) 377 { 378 if (sec_flags & SEC_NEVER_LOAD) 379 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY; 380 else 381 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC; 382 } 383 else if ((styp_flags & STYP_DATA) 384 || (styp_flags & STYP_RDATA) 385 || (styp_flags & STYP_SDATA) 386 || styp_flags == STYP_PDATA 387 || styp_flags == STYP_XDATA 388 || (styp_flags & STYP_GOT) 389 || styp_flags == STYP_RCONST) 390 { 391 if (sec_flags & SEC_NEVER_LOAD) 392 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY; 393 else 394 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC; 395 if ((styp_flags & STYP_RDATA) 396 || styp_flags == STYP_PDATA 397 || styp_flags == STYP_RCONST) 398 sec_flags |= SEC_READONLY; 399 } 400 else if ((styp_flags & STYP_BSS) 401 || (styp_flags & STYP_SBSS)) 402 sec_flags |= SEC_ALLOC; 403 else if ((styp_flags & STYP_INFO) || styp_flags == STYP_COMMENT) 404 sec_flags |= SEC_NEVER_LOAD; 405 else if ((styp_flags & STYP_LITA) 406 || (styp_flags & STYP_LIT8) 407 || (styp_flags & STYP_LIT4)) 408 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC | SEC_READONLY; 409 else if (styp_flags & STYP_ECOFF_LIB) 410 sec_flags |= SEC_COFF_SHARED_LIBRARY; 411 else 412 sec_flags |= SEC_ALLOC | SEC_LOAD; 413 414 * flags_ptr = sec_flags; 415 return TRUE; 416 } 417 418 /* Read in the symbolic header for an ECOFF object file. */ 419 420 static bfd_boolean 421 ecoff_slurp_symbolic_header (bfd *abfd) 422 { 423 const struct ecoff_backend_data * const backend = ecoff_backend (abfd); 424 bfd_size_type external_hdr_size; 425 void * raw = NULL; 426 HDRR *internal_symhdr; 427 428 /* See if we've already read it in. */ 429 if (ecoff_data (abfd)->debug_info.symbolic_header.magic == 430 backend->debug_swap.sym_magic) 431 return TRUE; 432 433 /* See whether there is a symbolic header. */ 434 if (ecoff_data (abfd)->sym_filepos == 0) 435 { 436 bfd_get_symcount (abfd) = 0; 437 return TRUE; 438 } 439 440 /* At this point bfd_get_symcount (abfd) holds the number of symbols 441 as read from the file header, but on ECOFF this is always the 442 size of the symbolic information header. It would be cleaner to 443 handle this when we first read the file in coffgen.c. */ 444 external_hdr_size = backend->debug_swap.external_hdr_size; 445 if (bfd_get_symcount (abfd) != external_hdr_size) 446 { 447 bfd_set_error (bfd_error_bad_value); 448 return FALSE; 449 } 450 451 /* Read the symbolic information header. */ 452 raw = bfd_malloc (external_hdr_size); 453 if (raw == NULL) 454 goto error_return; 455 456 if (bfd_seek (abfd, ecoff_data (abfd)->sym_filepos, SEEK_SET) != 0 457 || bfd_bread (raw, external_hdr_size, abfd) != external_hdr_size) 458 goto error_return; 459 internal_symhdr = &ecoff_data (abfd)->debug_info.symbolic_header; 460 (*backend->debug_swap.swap_hdr_in) (abfd, raw, internal_symhdr); 461 462 if (internal_symhdr->magic != backend->debug_swap.sym_magic) 463 { 464 bfd_set_error (bfd_error_bad_value); 465 goto error_return; 466 } 467 468 /* Now we can get the correct number of symbols. */ 469 bfd_get_symcount (abfd) = (internal_symhdr->isymMax 470 + internal_symhdr->iextMax); 471 472 if (raw != NULL) 473 free (raw); 474 return TRUE; 475 error_return: 476 if (raw != NULL) 477 free (raw); 478 return FALSE; 479 } 480 481 /* Read in and swap the important symbolic information for an ECOFF 482 object file. This is called by gdb via the read_debug_info entry 483 point in the backend structure. */ 484 485 bfd_boolean 486 _bfd_ecoff_slurp_symbolic_info (bfd *abfd, 487 asection *ignore ATTRIBUTE_UNUSED, 488 struct ecoff_debug_info *debug) 489 { 490 const struct ecoff_backend_data * const backend = ecoff_backend (abfd); 491 HDRR *internal_symhdr; 492 bfd_size_type raw_base; 493 bfd_size_type raw_size; 494 void * raw; 495 bfd_size_type external_fdr_size; 496 char *fraw_src; 497 char *fraw_end; 498 struct fdr *fdr_ptr; 499 bfd_size_type raw_end; 500 bfd_size_type cb_end; 501 bfd_size_type amt; 502 file_ptr pos; 503 504 BFD_ASSERT (debug == &ecoff_data (abfd)->debug_info); 505 506 /* Check whether we've already gotten it, and whether there's any to 507 get. */ 508 if (ecoff_data (abfd)->raw_syments != NULL) 509 return TRUE; 510 if (ecoff_data (abfd)->sym_filepos == 0) 511 { 512 bfd_get_symcount (abfd) = 0; 513 return TRUE; 514 } 515 516 if (! ecoff_slurp_symbolic_header (abfd)) 517 return FALSE; 518 519 internal_symhdr = &debug->symbolic_header; 520 521 /* Read all the symbolic information at once. */ 522 raw_base = (ecoff_data (abfd)->sym_filepos 523 + backend->debug_swap.external_hdr_size); 524 525 /* Alpha ecoff makes the determination of raw_size difficult. It has 526 an undocumented debug data section between the symhdr and the first 527 documented section. And the ordering of the sections varies between 528 statically and dynamically linked executables. 529 If bfd supports SEEK_END someday, this code could be simplified. */ 530 raw_end = 0; 531 532 #define UPDATE_RAW_END(start, count, size) \ 533 cb_end = internal_symhdr->start + internal_symhdr->count * (size); \ 534 if (cb_end > raw_end) \ 535 raw_end = cb_end 536 537 UPDATE_RAW_END (cbLineOffset, cbLine, sizeof (unsigned char)); 538 UPDATE_RAW_END (cbDnOffset, idnMax, backend->debug_swap.external_dnr_size); 539 UPDATE_RAW_END (cbPdOffset, ipdMax, backend->debug_swap.external_pdr_size); 540 UPDATE_RAW_END (cbSymOffset, isymMax, backend->debug_swap.external_sym_size); 541 /* eraxxon@alumni.rice.edu: ioptMax refers to the size of the 542 optimization symtab, not the number of entries. */ 543 UPDATE_RAW_END (cbOptOffset, ioptMax, sizeof (char)); 544 UPDATE_RAW_END (cbAuxOffset, iauxMax, sizeof (union aux_ext)); 545 UPDATE_RAW_END (cbSsOffset, issMax, sizeof (char)); 546 UPDATE_RAW_END (cbSsExtOffset, issExtMax, sizeof (char)); 547 UPDATE_RAW_END (cbFdOffset, ifdMax, backend->debug_swap.external_fdr_size); 548 UPDATE_RAW_END (cbRfdOffset, crfd, backend->debug_swap.external_rfd_size); 549 UPDATE_RAW_END (cbExtOffset, iextMax, backend->debug_swap.external_ext_size); 550 551 #undef UPDATE_RAW_END 552 553 raw_size = raw_end - raw_base; 554 if (raw_size == 0) 555 { 556 ecoff_data (abfd)->sym_filepos = 0; 557 return TRUE; 558 } 559 raw = bfd_alloc (abfd, raw_size); 560 if (raw == NULL) 561 return FALSE; 562 563 pos = ecoff_data (abfd)->sym_filepos; 564 pos += backend->debug_swap.external_hdr_size; 565 if (bfd_seek (abfd, pos, SEEK_SET) != 0 566 || bfd_bread (raw, raw_size, abfd) != raw_size) 567 { 568 bfd_release (abfd, raw); 569 return FALSE; 570 } 571 572 ecoff_data (abfd)->raw_syments = raw; 573 574 /* Get pointers for the numeric offsets in the HDRR structure. */ 575 #define FIX(off1, off2, type) \ 576 if (internal_symhdr->off1 == 0) \ 577 debug->off2 = NULL; \ 578 else \ 579 debug->off2 = (type) ((char *) raw \ 580 + (internal_symhdr->off1 \ 581 - raw_base)) 582 583 FIX (cbLineOffset, line, unsigned char *); 584 FIX (cbDnOffset, external_dnr, void *); 585 FIX (cbPdOffset, external_pdr, void *); 586 FIX (cbSymOffset, external_sym, void *); 587 FIX (cbOptOffset, external_opt, void *); 588 FIX (cbAuxOffset, external_aux, union aux_ext *); 589 FIX (cbSsOffset, ss, char *); 590 FIX (cbSsExtOffset, ssext, char *); 591 FIX (cbFdOffset, external_fdr, void *); 592 FIX (cbRfdOffset, external_rfd, void *); 593 FIX (cbExtOffset, external_ext, void *); 594 #undef FIX 595 596 /* I don't want to always swap all the data, because it will just 597 waste time and most programs will never look at it. The only 598 time the linker needs most of the debugging information swapped 599 is when linking big-endian and little-endian MIPS object files 600 together, which is not a common occurrence. 601 602 We need to look at the fdr to deal with a lot of information in 603 the symbols, so we swap them here. */ 604 amt = internal_symhdr->ifdMax; 605 amt *= sizeof (struct fdr); 606 debug->fdr = bfd_alloc (abfd, amt); 607 if (debug->fdr == NULL) 608 return FALSE; 609 external_fdr_size = backend->debug_swap.external_fdr_size; 610 fdr_ptr = debug->fdr; 611 fraw_src = (char *) debug->external_fdr; 612 fraw_end = fraw_src + internal_symhdr->ifdMax * external_fdr_size; 613 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++) 614 (*backend->debug_swap.swap_fdr_in) (abfd, (void *) fraw_src, fdr_ptr); 615 616 return TRUE; 617 } 618 619 /* ECOFF symbol table routines. The ECOFF symbol table is described 620 in gcc/mips-tfile.c. */ 621 622 /* ECOFF uses two common sections. One is the usual one, and the 623 other is for small objects. All the small objects are kept 624 together, and then referenced via the gp pointer, which yields 625 faster assembler code. This is what we use for the small common 626 section. */ 627 static asection ecoff_scom_section; 628 static asymbol ecoff_scom_symbol; 629 static asymbol *ecoff_scom_symbol_ptr; 630 631 /* Create an empty symbol. */ 632 633 asymbol * 634 _bfd_ecoff_make_empty_symbol (bfd *abfd) 635 { 636 ecoff_symbol_type *new; 637 bfd_size_type amt = sizeof (ecoff_symbol_type); 638 639 new = bfd_zalloc (abfd, amt); 640 if (new == NULL) 641 return NULL; 642 new->symbol.section = NULL; 643 new->fdr = NULL; 644 new->local = FALSE; 645 new->native = NULL; 646 new->symbol.the_bfd = abfd; 647 return &new->symbol; 648 } 649 650 /* Set the BFD flags and section for an ECOFF symbol. */ 651 652 static bfd_boolean 653 ecoff_set_symbol_info (bfd *abfd, 654 SYMR *ecoff_sym, 655 asymbol *asym, 656 int ext, 657 int weak) 658 { 659 asym->the_bfd = abfd; 660 asym->value = ecoff_sym->value; 661 asym->section = &bfd_debug_section; 662 asym->udata.i = 0; 663 664 /* Most symbol types are just for debugging. */ 665 switch (ecoff_sym->st) 666 { 667 case stGlobal: 668 case stStatic: 669 case stLabel: 670 case stProc: 671 case stStaticProc: 672 break; 673 case stNil: 674 if (ECOFF_IS_STAB (ecoff_sym)) 675 { 676 asym->flags = BSF_DEBUGGING; 677 return TRUE; 678 } 679 break; 680 default: 681 asym->flags = BSF_DEBUGGING; 682 return TRUE; 683 } 684 685 if (weak) 686 asym->flags = BSF_EXPORT | BSF_WEAK; 687 else if (ext) 688 asym->flags = BSF_EXPORT | BSF_GLOBAL; 689 else 690 { 691 asym->flags = BSF_LOCAL; 692 /* Normally, a local stProc symbol will have a corresponding 693 external symbol. We mark the local symbol as a debugging 694 symbol, in order to prevent nm from printing both out. 695 Similarly, we mark stLabel and stabs symbols as debugging 696 symbols. In both cases, we do want to set the value 697 correctly based on the symbol class. */ 698 if (ecoff_sym->st == stProc 699 || ecoff_sym->st == stLabel 700 || ECOFF_IS_STAB (ecoff_sym)) 701 asym->flags |= BSF_DEBUGGING; 702 } 703 704 if (ecoff_sym->st == stProc || ecoff_sym->st == stStaticProc) 705 asym->flags |= BSF_FUNCTION; 706 707 switch (ecoff_sym->sc) 708 { 709 case scNil: 710 /* Used for compiler generated labels. Leave them in the 711 debugging section, and mark them as local. If BSF_DEBUGGING 712 is set, then nm does not display them for some reason. If no 713 flags are set then the linker whines about them. */ 714 asym->flags = BSF_LOCAL; 715 break; 716 case scText: 717 asym->section = bfd_make_section_old_way (abfd, _TEXT); 718 asym->value -= asym->section->vma; 719 break; 720 case scData: 721 asym->section = bfd_make_section_old_way (abfd, _DATA); 722 asym->value -= asym->section->vma; 723 break; 724 case scBss: 725 asym->section = bfd_make_section_old_way (abfd, _BSS); 726 asym->value -= asym->section->vma; 727 break; 728 case scRegister: 729 asym->flags = BSF_DEBUGGING; 730 break; 731 case scAbs: 732 asym->section = bfd_abs_section_ptr; 733 break; 734 case scUndefined: 735 asym->section = bfd_und_section_ptr; 736 asym->flags = 0; 737 asym->value = 0; 738 break; 739 case scCdbLocal: 740 case scBits: 741 case scCdbSystem: 742 case scRegImage: 743 case scInfo: 744 case scUserStruct: 745 asym->flags = BSF_DEBUGGING; 746 break; 747 case scSData: 748 asym->section = bfd_make_section_old_way (abfd, ".sdata"); 749 asym->value -= asym->section->vma; 750 break; 751 case scSBss: 752 asym->section = bfd_make_section_old_way (abfd, ".sbss"); 753 asym->value -= asym->section->vma; 754 break; 755 case scRData: 756 asym->section = bfd_make_section_old_way (abfd, ".rdata"); 757 asym->value -= asym->section->vma; 758 break; 759 case scVar: 760 asym->flags = BSF_DEBUGGING; 761 break; 762 case scCommon: 763 if (asym->value > ecoff_data (abfd)->gp_size) 764 { 765 asym->section = bfd_com_section_ptr; 766 asym->flags = 0; 767 break; 768 } 769 /* Fall through. */ 770 case scSCommon: 771 if (ecoff_scom_section.name == NULL) 772 { 773 /* Initialize the small common section. */ 774 ecoff_scom_section.name = SCOMMON; 775 ecoff_scom_section.flags = SEC_IS_COMMON; 776 ecoff_scom_section.output_section = &ecoff_scom_section; 777 ecoff_scom_section.symbol = &ecoff_scom_symbol; 778 ecoff_scom_section.symbol_ptr_ptr = &ecoff_scom_symbol_ptr; 779 ecoff_scom_symbol.name = SCOMMON; 780 ecoff_scom_symbol.flags = BSF_SECTION_SYM; 781 ecoff_scom_symbol.section = &ecoff_scom_section; 782 ecoff_scom_symbol_ptr = &ecoff_scom_symbol; 783 } 784 asym->section = &ecoff_scom_section; 785 asym->flags = 0; 786 break; 787 case scVarRegister: 788 case scVariant: 789 asym->flags = BSF_DEBUGGING; 790 break; 791 case scSUndefined: 792 asym->section = bfd_und_section_ptr; 793 asym->flags = 0; 794 asym->value = 0; 795 break; 796 case scInit: 797 asym->section = bfd_make_section_old_way (abfd, ".init"); 798 asym->value -= asym->section->vma; 799 break; 800 case scBasedVar: 801 case scXData: 802 case scPData: 803 asym->flags = BSF_DEBUGGING; 804 break; 805 case scFini: 806 asym->section = bfd_make_section_old_way (abfd, ".fini"); 807 asym->value -= asym->section->vma; 808 break; 809 case scRConst: 810 asym->section = bfd_make_section_old_way (abfd, ".rconst"); 811 asym->value -= asym->section->vma; 812 break; 813 default: 814 break; 815 } 816 817 /* Look for special constructors symbols and make relocation entries 818 in a special construction section. These are produced by the 819 -fgnu-linker argument to g++. */ 820 if (ECOFF_IS_STAB (ecoff_sym)) 821 { 822 switch (ECOFF_UNMARK_STAB (ecoff_sym->index)) 823 { 824 default: 825 break; 826 827 case N_SETA: 828 case N_SETT: 829 case N_SETD: 830 case N_SETB: 831 /* Mark the symbol as a constructor. */ 832 asym->flags |= BSF_CONSTRUCTOR; 833 break; 834 } 835 } 836 return TRUE; 837 } 838 839 /* Read an ECOFF symbol table. */ 840 841 bfd_boolean 842 _bfd_ecoff_slurp_symbol_table (bfd *abfd) 843 { 844 const struct ecoff_backend_data * const backend = ecoff_backend (abfd); 845 const bfd_size_type external_ext_size 846 = backend->debug_swap.external_ext_size; 847 const bfd_size_type external_sym_size 848 = backend->debug_swap.external_sym_size; 849 void (* const swap_ext_in) (bfd *, void *, EXTR *) 850 = backend->debug_swap.swap_ext_in; 851 void (* const swap_sym_in) (bfd *, void *, SYMR *) 852 = backend->debug_swap.swap_sym_in; 853 bfd_size_type internal_size; 854 ecoff_symbol_type *internal; 855 ecoff_symbol_type *internal_ptr; 856 char *eraw_src; 857 char *eraw_end; 858 FDR *fdr_ptr; 859 FDR *fdr_end; 860 861 /* If we've already read in the symbol table, do nothing. */ 862 if (ecoff_data (abfd)->canonical_symbols != NULL) 863 return TRUE; 864 865 /* Get the symbolic information. */ 866 if (! _bfd_ecoff_slurp_symbolic_info (abfd, NULL, 867 &ecoff_data (abfd)->debug_info)) 868 return FALSE; 869 if (bfd_get_symcount (abfd) == 0) 870 return TRUE; 871 872 internal_size = bfd_get_symcount (abfd); 873 internal_size *= sizeof (ecoff_symbol_type); 874 internal = bfd_alloc (abfd, internal_size); 875 if (internal == NULL) 876 return FALSE; 877 878 internal_ptr = internal; 879 eraw_src = (char *) ecoff_data (abfd)->debug_info.external_ext; 880 eraw_end = (eraw_src 881 + (ecoff_data (abfd)->debug_info.symbolic_header.iextMax 882 * external_ext_size)); 883 for (; eraw_src < eraw_end; eraw_src += external_ext_size, internal_ptr++) 884 { 885 EXTR internal_esym; 886 887 (*swap_ext_in) (abfd, (void *) eraw_src, &internal_esym); 888 internal_ptr->symbol.name = (ecoff_data (abfd)->debug_info.ssext 889 + internal_esym.asym.iss); 890 if (!ecoff_set_symbol_info (abfd, &internal_esym.asym, 891 &internal_ptr->symbol, 1, 892 internal_esym.weakext)) 893 return FALSE; 894 /* The alpha uses a negative ifd field for section symbols. */ 895 if (internal_esym.ifd >= 0) 896 internal_ptr->fdr = (ecoff_data (abfd)->debug_info.fdr 897 + internal_esym.ifd); 898 else 899 internal_ptr->fdr = NULL; 900 internal_ptr->local = FALSE; 901 internal_ptr->native = (void *) eraw_src; 902 } 903 904 /* The local symbols must be accessed via the fdr's, because the 905 string and aux indices are relative to the fdr information. */ 906 fdr_ptr = ecoff_data (abfd)->debug_info.fdr; 907 fdr_end = fdr_ptr + ecoff_data (abfd)->debug_info.symbolic_header.ifdMax; 908 for (; fdr_ptr < fdr_end; fdr_ptr++) 909 { 910 char *lraw_src; 911 char *lraw_end; 912 913 lraw_src = ((char *) ecoff_data (abfd)->debug_info.external_sym 914 + fdr_ptr->isymBase * external_sym_size); 915 lraw_end = lraw_src + fdr_ptr->csym * external_sym_size; 916 for (; 917 lraw_src < lraw_end; 918 lraw_src += external_sym_size, internal_ptr++) 919 { 920 SYMR internal_sym; 921 922 (*swap_sym_in) (abfd, (void *) lraw_src, &internal_sym); 923 internal_ptr->symbol.name = (ecoff_data (abfd)->debug_info.ss 924 + fdr_ptr->issBase 925 + internal_sym.iss); 926 if (!ecoff_set_symbol_info (abfd, &internal_sym, 927 &internal_ptr->symbol, 0, 0)) 928 return FALSE; 929 internal_ptr->fdr = fdr_ptr; 930 internal_ptr->local = TRUE; 931 internal_ptr->native = (void *) lraw_src; 932 } 933 } 934 935 ecoff_data (abfd)->canonical_symbols = internal; 936 937 return TRUE; 938 } 939 940 /* Return the amount of space needed for the canonical symbols. */ 941 942 long 943 _bfd_ecoff_get_symtab_upper_bound (bfd *abfd) 944 { 945 if (! _bfd_ecoff_slurp_symbolic_info (abfd, NULL, 946 &ecoff_data (abfd)->debug_info)) 947 return -1; 948 949 if (bfd_get_symcount (abfd) == 0) 950 return 0; 951 952 return (bfd_get_symcount (abfd) + 1) * (sizeof (ecoff_symbol_type *)); 953 } 954 955 /* Get the canonical symbols. */ 956 957 long 958 _bfd_ecoff_canonicalize_symtab (bfd *abfd, asymbol **alocation) 959 { 960 unsigned int counter = 0; 961 ecoff_symbol_type *symbase; 962 ecoff_symbol_type **location = (ecoff_symbol_type **) alocation; 963 964 if (! _bfd_ecoff_slurp_symbol_table (abfd)) 965 return -1; 966 if (bfd_get_symcount (abfd) == 0) 967 return 0; 968 969 symbase = ecoff_data (abfd)->canonical_symbols; 970 while (counter < bfd_get_symcount (abfd)) 971 { 972 *(location++) = symbase++; 973 counter++; 974 } 975 *location++ = NULL; 976 return bfd_get_symcount (abfd); 977 } 978 979 /* Turn ECOFF type information into a printable string. 980 ecoff_emit_aggregate and ecoff_type_to_string are from 981 gcc/mips-tdump.c, with swapping added and used_ptr removed. */ 982 983 /* Write aggregate information to a string. */ 984 985 static void 986 ecoff_emit_aggregate (bfd *abfd, 987 FDR *fdr, 988 char *string, 989 RNDXR *rndx, 990 long isym, 991 const char *which) 992 { 993 const struct ecoff_debug_swap * const debug_swap = 994 &ecoff_backend (abfd)->debug_swap; 995 struct ecoff_debug_info * const debug_info = &ecoff_data (abfd)->debug_info; 996 unsigned int ifd = rndx->rfd; 997 unsigned int indx = rndx->index; 998 const char *name; 999 1000 if (ifd == 0xfff) 1001 ifd = isym; 1002 1003 /* An ifd of -1 is an opaque type. An escaped index of 0 is a 1004 struct return type of a procedure compiled without -g. */ 1005 if (ifd == 0xffffffff 1006 || (rndx->rfd == 0xfff && indx == 0)) 1007 name = "<undefined>"; 1008 else if (indx == indexNil) 1009 name = "<no name>"; 1010 else 1011 { 1012 SYMR sym; 1013 1014 if (debug_info->external_rfd == NULL) 1015 fdr = debug_info->fdr + ifd; 1016 else 1017 { 1018 RFDT rfd; 1019 1020 (*debug_swap->swap_rfd_in) (abfd, 1021 ((char *) debug_info->external_rfd 1022 + ((fdr->rfdBase + ifd) 1023 * debug_swap->external_rfd_size)), 1024 &rfd); 1025 fdr = debug_info->fdr + rfd; 1026 } 1027 1028 indx += fdr->isymBase; 1029 1030 (*debug_swap->swap_sym_in) (abfd, 1031 ((char *) debug_info->external_sym 1032 + indx * debug_swap->external_sym_size), 1033 &sym); 1034 1035 name = debug_info->ss + fdr->issBase + sym.iss; 1036 } 1037 1038 sprintf (string, 1039 "%s %s { ifd = %u, index = %lu }", 1040 which, name, ifd, 1041 ((long) indx 1042 + debug_info->symbolic_header.iextMax)); 1043 } 1044 1045 /* Convert the type information to string format. */ 1046 1047 static char * 1048 ecoff_type_to_string (bfd *abfd, FDR *fdr, unsigned int indx) 1049 { 1050 union aux_ext *aux_ptr; 1051 int bigendian; 1052 AUXU u; 1053 struct qual 1054 { 1055 unsigned int type; 1056 int low_bound; 1057 int high_bound; 1058 int stride; 1059 } qualifiers[7]; 1060 unsigned int basic_type; 1061 int i; 1062 char buffer1[1024]; 1063 static char buffer2[1024]; 1064 char *p1 = buffer1; 1065 char *p2 = buffer2; 1066 RNDXR rndx; 1067 1068 aux_ptr = ecoff_data (abfd)->debug_info.external_aux + fdr->iauxBase; 1069 bigendian = fdr->fBigendian; 1070 1071 for (i = 0; i < 7; i++) 1072 { 1073 qualifiers[i].low_bound = 0; 1074 qualifiers[i].high_bound = 0; 1075 qualifiers[i].stride = 0; 1076 } 1077 1078 if (AUX_GET_ISYM (bigendian, &aux_ptr[indx]) == (bfd_vma) -1) 1079 return "-1 (no type)"; 1080 _bfd_ecoff_swap_tir_in (bigendian, &aux_ptr[indx++].a_ti, &u.ti); 1081 1082 basic_type = u.ti.bt; 1083 qualifiers[0].type = u.ti.tq0; 1084 qualifiers[1].type = u.ti.tq1; 1085 qualifiers[2].type = u.ti.tq2; 1086 qualifiers[3].type = u.ti.tq3; 1087 qualifiers[4].type = u.ti.tq4; 1088 qualifiers[5].type = u.ti.tq5; 1089 qualifiers[6].type = tqNil; 1090 1091 /* Go get the basic type. */ 1092 switch (basic_type) 1093 { 1094 case btNil: /* Undefined. */ 1095 strcpy (p1, "nil"); 1096 break; 1097 1098 case btAdr: /* Address - integer same size as pointer. */ 1099 strcpy (p1, "address"); 1100 break; 1101 1102 case btChar: /* Character. */ 1103 strcpy (p1, "char"); 1104 break; 1105 1106 case btUChar: /* Unsigned character. */ 1107 strcpy (p1, "unsigned char"); 1108 break; 1109 1110 case btShort: /* Short. */ 1111 strcpy (p1, "short"); 1112 break; 1113 1114 case btUShort: /* Unsigned short. */ 1115 strcpy (p1, "unsigned short"); 1116 break; 1117 1118 case btInt: /* Int. */ 1119 strcpy (p1, "int"); 1120 break; 1121 1122 case btUInt: /* Unsigned int. */ 1123 strcpy (p1, "unsigned int"); 1124 break; 1125 1126 case btLong: /* Long. */ 1127 strcpy (p1, "long"); 1128 break; 1129 1130 case btULong: /* Unsigned long. */ 1131 strcpy (p1, "unsigned long"); 1132 break; 1133 1134 case btFloat: /* Float (real). */ 1135 strcpy (p1, "float"); 1136 break; 1137 1138 case btDouble: /* Double (real). */ 1139 strcpy (p1, "double"); 1140 break; 1141 1142 /* Structures add 1-2 aux words: 1143 1st word is [ST_RFDESCAPE, offset] pointer to struct def; 1144 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */ 1145 1146 case btStruct: /* Structure (Record). */ 1147 _bfd_ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx); 1148 ecoff_emit_aggregate (abfd, fdr, p1, &rndx, 1149 (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]), 1150 "struct"); 1151 indx++; /* Skip aux words. */ 1152 break; 1153 1154 /* Unions add 1-2 aux words: 1155 1st word is [ST_RFDESCAPE, offset] pointer to union def; 1156 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */ 1157 1158 case btUnion: /* Union. */ 1159 _bfd_ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx); 1160 ecoff_emit_aggregate (abfd, fdr, p1, &rndx, 1161 (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]), 1162 "union"); 1163 indx++; /* Skip aux words. */ 1164 break; 1165 1166 /* Enumerations add 1-2 aux words: 1167 1st word is [ST_RFDESCAPE, offset] pointer to enum def; 1168 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */ 1169 1170 case btEnum: /* Enumeration. */ 1171 _bfd_ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx); 1172 ecoff_emit_aggregate (abfd, fdr, p1, &rndx, 1173 (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]), 1174 "enum"); 1175 indx++; /* Skip aux words. */ 1176 break; 1177 1178 case btTypedef: /* Defined via a typedef, isymRef points. */ 1179 strcpy (p1, "typedef"); 1180 break; 1181 1182 case btRange: /* Subrange of int. */ 1183 strcpy (p1, "subrange"); 1184 break; 1185 1186 case btSet: /* Pascal sets. */ 1187 strcpy (p1, "set"); 1188 break; 1189 1190 case btComplex: /* Fortran complex. */ 1191 strcpy (p1, "complex"); 1192 break; 1193 1194 case btDComplex: /* Fortran double complex. */ 1195 strcpy (p1, "double complex"); 1196 break; 1197 1198 case btIndirect: /* Forward or unnamed typedef. */ 1199 strcpy (p1, "forward/unamed typedef"); 1200 break; 1201 1202 case btFixedDec: /* Fixed Decimal. */ 1203 strcpy (p1, "fixed decimal"); 1204 break; 1205 1206 case btFloatDec: /* Float Decimal. */ 1207 strcpy (p1, "float decimal"); 1208 break; 1209 1210 case btString: /* Varying Length Character String. */ 1211 strcpy (p1, "string"); 1212 break; 1213 1214 case btBit: /* Aligned Bit String. */ 1215 strcpy (p1, "bit"); 1216 break; 1217 1218 case btPicture: /* Picture. */ 1219 strcpy (p1, "picture"); 1220 break; 1221 1222 case btVoid: /* Void. */ 1223 strcpy (p1, "void"); 1224 break; 1225 1226 default: 1227 sprintf (p1, _("Unknown basic type %d"), (int) basic_type); 1228 break; 1229 } 1230 1231 p1 += strlen (buffer1); 1232 1233 /* If this is a bitfield, get the bitsize. */ 1234 if (u.ti.fBitfield) 1235 { 1236 int bitsize; 1237 1238 bitsize = AUX_GET_WIDTH (bigendian, &aux_ptr[indx++]); 1239 sprintf (p1, " : %d", bitsize); 1240 p1 += strlen (buffer1); 1241 } 1242 1243 /* Deal with any qualifiers. */ 1244 if (qualifiers[0].type != tqNil) 1245 { 1246 /* Snarf up any array bounds in the correct order. Arrays 1247 store 5 successive words in the aux. table: 1248 word 0 RNDXR to type of the bounds (ie, int) 1249 word 1 Current file descriptor index 1250 word 2 low bound 1251 word 3 high bound (or -1 if []) 1252 word 4 stride size in bits. */ 1253 for (i = 0; i < 7; i++) 1254 { 1255 if (qualifiers[i].type == tqArray) 1256 { 1257 qualifiers[i].low_bound = 1258 AUX_GET_DNLOW (bigendian, &aux_ptr[indx+2]); 1259 qualifiers[i].high_bound = 1260 AUX_GET_DNHIGH (bigendian, &aux_ptr[indx+3]); 1261 qualifiers[i].stride = 1262 AUX_GET_WIDTH (bigendian, &aux_ptr[indx+4]); 1263 indx += 5; 1264 } 1265 } 1266 1267 /* Now print out the qualifiers. */ 1268 for (i = 0; i < 6; i++) 1269 { 1270 switch (qualifiers[i].type) 1271 { 1272 case tqNil: 1273 case tqMax: 1274 break; 1275 1276 case tqPtr: 1277 strcpy (p2, "ptr to "); 1278 p2 += sizeof ("ptr to ")-1; 1279 break; 1280 1281 case tqVol: 1282 strcpy (p2, "volatile "); 1283 p2 += sizeof ("volatile ")-1; 1284 break; 1285 1286 case tqFar: 1287 strcpy (p2, "far "); 1288 p2 += sizeof ("far ")-1; 1289 break; 1290 1291 case tqProc: 1292 strcpy (p2, "func. ret. "); 1293 p2 += sizeof ("func. ret. "); 1294 break; 1295 1296 case tqArray: 1297 { 1298 int first_array = i; 1299 int j; 1300 1301 /* Print array bounds reversed (ie, in the order the C 1302 programmer writes them). C is such a fun language.... */ 1303 while (i < 5 && qualifiers[i+1].type == tqArray) 1304 i++; 1305 1306 for (j = i; j >= first_array; j--) 1307 { 1308 strcpy (p2, "array ["); 1309 p2 += sizeof ("array [")-1; 1310 if (qualifiers[j].low_bound != 0) 1311 sprintf (p2, 1312 "%ld:%ld {%ld bits}", 1313 (long) qualifiers[j].low_bound, 1314 (long) qualifiers[j].high_bound, 1315 (long) qualifiers[j].stride); 1316 1317 else if (qualifiers[j].high_bound != -1) 1318 sprintf (p2, 1319 "%ld {%ld bits}", 1320 (long) (qualifiers[j].high_bound + 1), 1321 (long) (qualifiers[j].stride)); 1322 1323 else 1324 sprintf (p2, " {%ld bits}", (long) (qualifiers[j].stride)); 1325 1326 p2 += strlen (p2); 1327 strcpy (p2, "] of "); 1328 p2 += sizeof ("] of ")-1; 1329 } 1330 } 1331 break; 1332 } 1333 } 1334 } 1335 1336 strcpy (p2, buffer1); 1337 return buffer2; 1338 } 1339 1340 /* Return information about ECOFF symbol SYMBOL in RET. */ 1341 1342 void 1343 _bfd_ecoff_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED, 1344 asymbol *symbol, 1345 symbol_info *ret) 1346 { 1347 bfd_symbol_info (symbol, ret); 1348 } 1349 1350 /* Return whether this is a local label. */ 1351 1352 bfd_boolean 1353 _bfd_ecoff_bfd_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED, 1354 const char *name) 1355 { 1356 return name[0] == '$'; 1357 } 1358 1359 /* Print information about an ECOFF symbol. */ 1360 1361 void 1362 _bfd_ecoff_print_symbol (bfd *abfd, 1363 void * filep, 1364 asymbol *symbol, 1365 bfd_print_symbol_type how) 1366 { 1367 const struct ecoff_debug_swap * const debug_swap 1368 = &ecoff_backend (abfd)->debug_swap; 1369 FILE *file = (FILE *)filep; 1370 1371 switch (how) 1372 { 1373 case bfd_print_symbol_name: 1374 fprintf (file, "%s", symbol->name); 1375 break; 1376 case bfd_print_symbol_more: 1377 if (ecoffsymbol (symbol)->local) 1378 { 1379 SYMR ecoff_sym; 1380 1381 (*debug_swap->swap_sym_in) (abfd, ecoffsymbol (symbol)->native, 1382 &ecoff_sym); 1383 fprintf (file, "ecoff local "); 1384 fprintf_vma (file, (bfd_vma) ecoff_sym.value); 1385 fprintf (file, " %x %x", (unsigned) ecoff_sym.st, 1386 (unsigned) ecoff_sym.sc); 1387 } 1388 else 1389 { 1390 EXTR ecoff_ext; 1391 1392 (*debug_swap->swap_ext_in) (abfd, ecoffsymbol (symbol)->native, 1393 &ecoff_ext); 1394 fprintf (file, "ecoff extern "); 1395 fprintf_vma (file, (bfd_vma) ecoff_ext.asym.value); 1396 fprintf (file, " %x %x", (unsigned) ecoff_ext.asym.st, 1397 (unsigned) ecoff_ext.asym.sc); 1398 } 1399 break; 1400 case bfd_print_symbol_all: 1401 /* Print out the symbols in a reasonable way. */ 1402 { 1403 char type; 1404 int pos; 1405 EXTR ecoff_ext; 1406 char jmptbl; 1407 char cobol_main; 1408 char weakext; 1409 1410 if (ecoffsymbol (symbol)->local) 1411 { 1412 (*debug_swap->swap_sym_in) (abfd, ecoffsymbol (symbol)->native, 1413 &ecoff_ext.asym); 1414 type = 'l'; 1415 pos = ((((char *) ecoffsymbol (symbol)->native 1416 - (char *) ecoff_data (abfd)->debug_info.external_sym) 1417 / debug_swap->external_sym_size) 1418 + ecoff_data (abfd)->debug_info.symbolic_header.iextMax); 1419 jmptbl = ' '; 1420 cobol_main = ' '; 1421 weakext = ' '; 1422 } 1423 else 1424 { 1425 (*debug_swap->swap_ext_in) (abfd, ecoffsymbol (symbol)->native, 1426 &ecoff_ext); 1427 type = 'e'; 1428 pos = (((char *) ecoffsymbol (symbol)->native 1429 - (char *) ecoff_data (abfd)->debug_info.external_ext) 1430 / debug_swap->external_ext_size); 1431 jmptbl = ecoff_ext.jmptbl ? 'j' : ' '; 1432 cobol_main = ecoff_ext.cobol_main ? 'c' : ' '; 1433 weakext = ecoff_ext.weakext ? 'w' : ' '; 1434 } 1435 1436 fprintf (file, "[%3d] %c ", 1437 pos, type); 1438 fprintf_vma (file, (bfd_vma) ecoff_ext.asym.value); 1439 fprintf (file, " st %x sc %x indx %x %c%c%c %s", 1440 (unsigned) ecoff_ext.asym.st, 1441 (unsigned) ecoff_ext.asym.sc, 1442 (unsigned) ecoff_ext.asym.index, 1443 jmptbl, cobol_main, weakext, 1444 symbol->name); 1445 1446 if (ecoffsymbol (symbol)->fdr != NULL 1447 && ecoff_ext.asym.index != indexNil) 1448 { 1449 FDR *fdr; 1450 unsigned int indx; 1451 int bigendian; 1452 bfd_size_type sym_base; 1453 union aux_ext *aux_base; 1454 1455 fdr = ecoffsymbol (symbol)->fdr; 1456 indx = ecoff_ext.asym.index; 1457 1458 /* sym_base is used to map the fdr relative indices which 1459 appear in the file to the position number which we are 1460 using. */ 1461 sym_base = fdr->isymBase; 1462 if (ecoffsymbol (symbol)->local) 1463 sym_base += 1464 ecoff_data (abfd)->debug_info.symbolic_header.iextMax; 1465 1466 /* aux_base is the start of the aux entries for this file; 1467 asym.index is an offset from this. */ 1468 aux_base = (ecoff_data (abfd)->debug_info.external_aux 1469 + fdr->iauxBase); 1470 1471 /* The aux entries are stored in host byte order; the 1472 order is indicated by a bit in the fdr. */ 1473 bigendian = fdr->fBigendian; 1474 1475 /* This switch is basically from gcc/mips-tdump.c. */ 1476 switch (ecoff_ext.asym.st) 1477 { 1478 case stNil: 1479 case stLabel: 1480 break; 1481 1482 case stFile: 1483 case stBlock: 1484 fprintf (file, _("\n End+1 symbol: %ld"), 1485 (long) (indx + sym_base)); 1486 break; 1487 1488 case stEnd: 1489 if (ecoff_ext.asym.sc == scText 1490 || ecoff_ext.asym.sc == scInfo) 1491 fprintf (file, _("\n First symbol: %ld"), 1492 (long) (indx + sym_base)); 1493 else 1494 fprintf (file, _("\n First symbol: %ld"), 1495 ((long) 1496 (AUX_GET_ISYM (bigendian, 1497 &aux_base[ecoff_ext.asym.index]) 1498 + sym_base))); 1499 break; 1500 1501 case stProc: 1502 case stStaticProc: 1503 if (ECOFF_IS_STAB (&ecoff_ext.asym)) 1504 ; 1505 else if (ecoffsymbol (symbol)->local) 1506 fprintf (file, _("\n End+1 symbol: %-7ld Type: %s"), 1507 ((long) 1508 (AUX_GET_ISYM (bigendian, 1509 &aux_base[ecoff_ext.asym.index]) 1510 + sym_base)), 1511 ecoff_type_to_string (abfd, fdr, indx + 1)); 1512 else 1513 fprintf (file, _("\n Local symbol: %ld"), 1514 ((long) indx 1515 + (long) sym_base 1516 + (ecoff_data (abfd) 1517 ->debug_info.symbolic_header.iextMax))); 1518 break; 1519 1520 case stStruct: 1521 fprintf (file, _("\n struct; End+1 symbol: %ld"), 1522 (long) (indx + sym_base)); 1523 break; 1524 1525 case stUnion: 1526 fprintf (file, _("\n union; End+1 symbol: %ld"), 1527 (long) (indx + sym_base)); 1528 break; 1529 1530 case stEnum: 1531 fprintf (file, _("\n enum; End+1 symbol: %ld"), 1532 (long) (indx + sym_base)); 1533 break; 1534 1535 default: 1536 if (! ECOFF_IS_STAB (&ecoff_ext.asym)) 1537 fprintf (file, _("\n Type: %s"), 1538 ecoff_type_to_string (abfd, fdr, indx)); 1539 break; 1540 } 1541 } 1542 } 1543 break; 1544 } 1545 } 1546 1547 /* Read in the relocs for a section. */ 1548 1549 static bfd_boolean 1550 ecoff_slurp_reloc_table (bfd *abfd, 1551 asection *section, 1552 asymbol **symbols) 1553 { 1554 const struct ecoff_backend_data * const backend = ecoff_backend (abfd); 1555 arelent *internal_relocs; 1556 bfd_size_type external_reloc_size; 1557 bfd_size_type amt; 1558 char *external_relocs; 1559 arelent *rptr; 1560 unsigned int i; 1561 1562 if (section->relocation != NULL 1563 || section->reloc_count == 0 1564 || (section->flags & SEC_CONSTRUCTOR) != 0) 1565 return TRUE; 1566 1567 if (! _bfd_ecoff_slurp_symbol_table (abfd)) 1568 return FALSE; 1569 1570 amt = section->reloc_count; 1571 amt *= sizeof (arelent); 1572 internal_relocs = bfd_alloc (abfd, amt); 1573 1574 external_reloc_size = backend->external_reloc_size; 1575 amt = external_reloc_size * section->reloc_count; 1576 external_relocs = bfd_alloc (abfd, amt); 1577 if (internal_relocs == NULL || external_relocs == NULL) 1578 return FALSE; 1579 if (bfd_seek (abfd, section->rel_filepos, SEEK_SET) != 0) 1580 return FALSE; 1581 if (bfd_bread (external_relocs, amt, abfd) != amt) 1582 return FALSE; 1583 1584 for (i = 0, rptr = internal_relocs; i < section->reloc_count; i++, rptr++) 1585 { 1586 struct internal_reloc intern; 1587 1588 (*backend->swap_reloc_in) (abfd, 1589 external_relocs + i * external_reloc_size, 1590 &intern); 1591 1592 if (intern.r_extern) 1593 { 1594 /* r_symndx is an index into the external symbols. */ 1595 BFD_ASSERT (intern.r_symndx >= 0 1596 && (intern.r_symndx 1597 < (ecoff_data (abfd) 1598 ->debug_info.symbolic_header.iextMax))); 1599 rptr->sym_ptr_ptr = symbols + intern.r_symndx; 1600 rptr->addend = 0; 1601 } 1602 else if (intern.r_symndx == RELOC_SECTION_NONE 1603 || intern.r_symndx == RELOC_SECTION_ABS) 1604 { 1605 rptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; 1606 rptr->addend = 0; 1607 } 1608 else 1609 { 1610 const char *sec_name; 1611 asection *sec; 1612 1613 /* r_symndx is a section key. */ 1614 switch (intern.r_symndx) 1615 { 1616 case RELOC_SECTION_TEXT: sec_name = _TEXT; break; 1617 case RELOC_SECTION_RDATA: sec_name = _RDATA; break; 1618 case RELOC_SECTION_DATA: sec_name = _DATA; break; 1619 case RELOC_SECTION_SDATA: sec_name = _SDATA; break; 1620 case RELOC_SECTION_SBSS: sec_name = _SBSS; break; 1621 case RELOC_SECTION_BSS: sec_name = _BSS; break; 1622 case RELOC_SECTION_INIT: sec_name = _INIT; break; 1623 case RELOC_SECTION_LIT8: sec_name = _LIT8; break; 1624 case RELOC_SECTION_LIT4: sec_name = _LIT4; break; 1625 case RELOC_SECTION_XDATA: sec_name = _XDATA; break; 1626 case RELOC_SECTION_PDATA: sec_name = _PDATA; break; 1627 case RELOC_SECTION_FINI: sec_name = _FINI; break; 1628 case RELOC_SECTION_LITA: sec_name = _LITA; break; 1629 case RELOC_SECTION_RCONST: sec_name = _RCONST; break; 1630 default: abort (); 1631 } 1632 1633 sec = bfd_get_section_by_name (abfd, sec_name); 1634 if (sec == NULL) 1635 abort (); 1636 rptr->sym_ptr_ptr = sec->symbol_ptr_ptr; 1637 1638 rptr->addend = - bfd_get_section_vma (abfd, sec); 1639 } 1640 1641 rptr->address = intern.r_vaddr - bfd_get_section_vma (abfd, section); 1642 1643 /* Let the backend select the howto field and do any other 1644 required processing. */ 1645 (*backend->adjust_reloc_in) (abfd, &intern, rptr); 1646 } 1647 1648 bfd_release (abfd, external_relocs); 1649 1650 section->relocation = internal_relocs; 1651 1652 return TRUE; 1653 } 1654 1655 /* Get a canonical list of relocs. */ 1656 1657 long 1658 _bfd_ecoff_canonicalize_reloc (bfd *abfd, 1659 asection *section, 1660 arelent **relptr, 1661 asymbol **symbols) 1662 { 1663 unsigned int count; 1664 1665 if (section->flags & SEC_CONSTRUCTOR) 1666 { 1667 arelent_chain *chain; 1668 1669 /* This section has relocs made up by us, not the file, so take 1670 them out of their chain and place them into the data area 1671 provided. */ 1672 for (count = 0, chain = section->constructor_chain; 1673 count < section->reloc_count; 1674 count++, chain = chain->next) 1675 *relptr++ = &chain->relent; 1676 } 1677 else 1678 { 1679 arelent *tblptr; 1680 1681 if (! ecoff_slurp_reloc_table (abfd, section, symbols)) 1682 return -1; 1683 1684 tblptr = section->relocation; 1685 1686 for (count = 0; count < section->reloc_count; count++) 1687 *relptr++ = tblptr++; 1688 } 1689 1690 *relptr = NULL; 1691 1692 return section->reloc_count; 1693 } 1694 1695 /* Provided a BFD, a section and an offset into the section, calculate 1696 and return the name of the source file and the line nearest to the 1697 wanted location. */ 1698 1699 bfd_boolean 1700 _bfd_ecoff_find_nearest_line (bfd *abfd, 1701 asection *section, 1702 asymbol **ignore_symbols ATTRIBUTE_UNUSED, 1703 bfd_vma offset, 1704 const char **filename_ptr, 1705 const char **functionname_ptr, 1706 unsigned int *retline_ptr) 1707 { 1708 const struct ecoff_debug_swap * const debug_swap 1709 = &ecoff_backend (abfd)->debug_swap; 1710 struct ecoff_debug_info * const debug_info = &ecoff_data (abfd)->debug_info; 1711 struct ecoff_find_line *line_info; 1712 1713 /* Make sure we have the FDR's. */ 1714 if (! _bfd_ecoff_slurp_symbolic_info (abfd, NULL, debug_info) 1715 || bfd_get_symcount (abfd) == 0) 1716 return FALSE; 1717 1718 if (ecoff_data (abfd)->find_line_info == NULL) 1719 { 1720 bfd_size_type amt = sizeof (struct ecoff_find_line); 1721 1722 ecoff_data (abfd)->find_line_info = bfd_zalloc (abfd, amt); 1723 if (ecoff_data (abfd)->find_line_info == NULL) 1724 return FALSE; 1725 } 1726 line_info = ecoff_data (abfd)->find_line_info; 1727 1728 return _bfd_ecoff_locate_line (abfd, section, offset, debug_info, 1729 debug_swap, line_info, filename_ptr, 1730 functionname_ptr, retline_ptr); 1731 } 1732 1733 /* Copy private BFD data. This is called by objcopy and strip. We 1734 use it to copy the ECOFF debugging information from one BFD to the 1735 other. It would be theoretically possible to represent the ECOFF 1736 debugging information in the symbol table. However, it would be a 1737 lot of work, and there would be little gain (gas, gdb, and ld 1738 already access the ECOFF debugging information via the 1739 ecoff_debug_info structure, and that structure would have to be 1740 retained in order to support ECOFF debugging in MIPS ELF). 1741 1742 The debugging information for the ECOFF external symbols comes from 1743 the symbol table, so this function only handles the other debugging 1744 information. */ 1745 1746 bfd_boolean 1747 _bfd_ecoff_bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd) 1748 { 1749 struct ecoff_debug_info *iinfo = &ecoff_data (ibfd)->debug_info; 1750 struct ecoff_debug_info *oinfo = &ecoff_data (obfd)->debug_info; 1751 int i; 1752 asymbol **sym_ptr_ptr; 1753 size_t c; 1754 bfd_boolean local; 1755 1756 /* We only want to copy information over if both BFD's use ECOFF 1757 format. */ 1758 if (bfd_get_flavour (ibfd) != bfd_target_ecoff_flavour 1759 || bfd_get_flavour (obfd) != bfd_target_ecoff_flavour) 1760 return TRUE; 1761 1762 /* Copy the GP value and the register masks. */ 1763 ecoff_data (obfd)->gp = ecoff_data (ibfd)->gp; 1764 ecoff_data (obfd)->gprmask = ecoff_data (ibfd)->gprmask; 1765 ecoff_data (obfd)->fprmask = ecoff_data (ibfd)->fprmask; 1766 for (i = 0; i < 3; i++) 1767 ecoff_data (obfd)->cprmask[i] = ecoff_data (ibfd)->cprmask[i]; 1768 1769 /* Copy the version stamp. */ 1770 oinfo->symbolic_header.vstamp = iinfo->symbolic_header.vstamp; 1771 1772 /* If there are no symbols, don't copy any debugging information. */ 1773 c = bfd_get_symcount (obfd); 1774 sym_ptr_ptr = bfd_get_outsymbols (obfd); 1775 if (c == 0 || sym_ptr_ptr == NULL) 1776 return TRUE; 1777 1778 /* See if there are any local symbols. */ 1779 local = FALSE; 1780 for (; c > 0; c--, sym_ptr_ptr++) 1781 { 1782 if (ecoffsymbol (*sym_ptr_ptr)->local) 1783 { 1784 local = TRUE; 1785 break; 1786 } 1787 } 1788 1789 if (local) 1790 { 1791 /* There are some local symbols. We just bring over all the 1792 debugging information. FIXME: This is not quite the right 1793 thing to do. If the user has asked us to discard all 1794 debugging information, then we are probably going to wind up 1795 keeping it because there will probably be some local symbol 1796 which objcopy did not discard. We should actually break 1797 apart the debugging information and only keep that which 1798 applies to the symbols we want to keep. */ 1799 oinfo->symbolic_header.ilineMax = iinfo->symbolic_header.ilineMax; 1800 oinfo->symbolic_header.cbLine = iinfo->symbolic_header.cbLine; 1801 oinfo->line = iinfo->line; 1802 1803 oinfo->symbolic_header.idnMax = iinfo->symbolic_header.idnMax; 1804 oinfo->external_dnr = iinfo->external_dnr; 1805 1806 oinfo->symbolic_header.ipdMax = iinfo->symbolic_header.ipdMax; 1807 oinfo->external_pdr = iinfo->external_pdr; 1808 1809 oinfo->symbolic_header.isymMax = iinfo->symbolic_header.isymMax; 1810 oinfo->external_sym = iinfo->external_sym; 1811 1812 oinfo->symbolic_header.ioptMax = iinfo->symbolic_header.ioptMax; 1813 oinfo->external_opt = iinfo->external_opt; 1814 1815 oinfo->symbolic_header.iauxMax = iinfo->symbolic_header.iauxMax; 1816 oinfo->external_aux = iinfo->external_aux; 1817 1818 oinfo->symbolic_header.issMax = iinfo->symbolic_header.issMax; 1819 oinfo->ss = iinfo->ss; 1820 1821 oinfo->symbolic_header.ifdMax = iinfo->symbolic_header.ifdMax; 1822 oinfo->external_fdr = iinfo->external_fdr; 1823 1824 oinfo->symbolic_header.crfd = iinfo->symbolic_header.crfd; 1825 oinfo->external_rfd = iinfo->external_rfd; 1826 } 1827 else 1828 { 1829 /* We are discarding all the local symbol information. Look 1830 through the external symbols and remove all references to FDR 1831 or aux information. */ 1832 c = bfd_get_symcount (obfd); 1833 sym_ptr_ptr = bfd_get_outsymbols (obfd); 1834 for (; c > 0; c--, sym_ptr_ptr++) 1835 { 1836 EXTR esym; 1837 1838 (*(ecoff_backend (obfd)->debug_swap.swap_ext_in)) 1839 (obfd, ecoffsymbol (*sym_ptr_ptr)->native, &esym); 1840 esym.ifd = ifdNil; 1841 esym.asym.index = indexNil; 1842 (*(ecoff_backend (obfd)->debug_swap.swap_ext_out)) 1843 (obfd, &esym, ecoffsymbol (*sym_ptr_ptr)->native); 1844 } 1845 } 1846 1847 return TRUE; 1848 } 1849 1850 /* Set the architecture. The supported architecture is stored in the 1851 backend pointer. We always set the architecture anyhow, since many 1852 callers ignore the return value. */ 1853 1854 bfd_boolean 1855 _bfd_ecoff_set_arch_mach (bfd *abfd, 1856 enum bfd_architecture arch, 1857 unsigned long machine) 1858 { 1859 bfd_default_set_arch_mach (abfd, arch, machine); 1860 return arch == ecoff_backend (abfd)->arch; 1861 } 1862 1863 /* Get the size of the section headers. */ 1864 1865 int 1866 _bfd_ecoff_sizeof_headers (bfd *abfd, bfd_boolean reloc 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 1886 bfd_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 1900 static int 1901 ecoff_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 1927 static bfd_boolean 1928 ecoff_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, FALSE); 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 2077 static bfd_size_type 2078 ecoff_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 2131 bfd_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 2177 bfd_vma 2178 bfd_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 2193 bfd_boolean 2194 bfd_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 2211 bfd_boolean 2212 bfd_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 2243 static bfd_boolean 2244 ecoff_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 2306 static void 2307 ecoff_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 2314 bfd_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, FALSE); 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 2814 static unsigned int 2815 ecoff_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 2834 bfd_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 (strneq (nextname, "/ ", 16)) 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 2997 bfd_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 3160 const 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 3244 static struct bfd_hash_entry * 3245 ecoff_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 3279 struct 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 3323 static bfd_boolean 3324 ecoff_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 3527 static bfd_boolean 3528 ecoff_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 3585 static bfd_boolean 3586 ecoff_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 3715 static bfd_boolean 3716 ecoff_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 3864 bfd_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 3884 struct 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 3894 static bfd_boolean 3895 ecoff_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 3991 static bfd_boolean 3992 ecoff_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 4081 static bfd_boolean 4082 ecoff_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 4289 static bfd_boolean 4290 ecoff_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 4439 bfd_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