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