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