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