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