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