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 bfd_fprintf_vma (abfd, file, 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 bfd_fprintf_vma (abfd, file, 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 bfd_fprintf_vma (abfd, file, 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 (symbols != NULL 1616 && intern.r_symndx >= 0 1617 && (intern.r_symndx 1618 < (ecoff_data (abfd)->debug_info.symbolic_header.iextMax))) 1619 rptr->sym_ptr_ptr = symbols + intern.r_symndx; 1620 } 1621 else 1622 { 1623 const char *sec_name; 1624 asection *sec; 1625 1626 /* r_symndx is a section key. */ 1627 switch (intern.r_symndx) 1628 { 1629 case RELOC_SECTION_TEXT: sec_name = _TEXT; break; 1630 case RELOC_SECTION_RDATA: sec_name = _RDATA; break; 1631 case RELOC_SECTION_DATA: sec_name = _DATA; break; 1632 case RELOC_SECTION_SDATA: sec_name = _SDATA; break; 1633 case RELOC_SECTION_SBSS: sec_name = _SBSS; break; 1634 case RELOC_SECTION_BSS: sec_name = _BSS; break; 1635 case RELOC_SECTION_INIT: sec_name = _INIT; break; 1636 case RELOC_SECTION_LIT8: sec_name = _LIT8; break; 1637 case RELOC_SECTION_LIT4: sec_name = _LIT4; break; 1638 case RELOC_SECTION_XDATA: sec_name = _XDATA; break; 1639 case RELOC_SECTION_PDATA: sec_name = _PDATA; break; 1640 case RELOC_SECTION_FINI: sec_name = _FINI; break; 1641 case RELOC_SECTION_LITA: sec_name = _LITA; break; 1642 case RELOC_SECTION_RCONST: sec_name = _RCONST; break; 1643 default: 1644 sec_name = NULL; 1645 break; 1646 } 1647 1648 if (sec_name != NULL) 1649 { 1650 sec = bfd_get_section_by_name (abfd, sec_name); 1651 if (sec != NULL) 1652 { 1653 rptr->sym_ptr_ptr = sec->symbol_ptr_ptr; 1654 rptr->addend = - bfd_section_vma (sec); 1655 } 1656 } 1657 } 1658 1659 rptr->address = intern.r_vaddr - bfd_section_vma (section); 1660 1661 /* Let the backend select the howto field and do any other 1662 required processing. */ 1663 (*backend->adjust_reloc_in) (abfd, &intern, rptr); 1664 } 1665 1666 free (external_relocs); 1667 1668 section->relocation = internal_relocs; 1669 1670 return true; 1671} 1672 1673/* Get a canonical list of relocs. */ 1674 1675long 1676_bfd_ecoff_canonicalize_reloc (bfd *abfd, 1677 asection *section, 1678 arelent **relptr, 1679 asymbol **symbols) 1680{ 1681 unsigned int count; 1682 1683 if (section->flags & SEC_CONSTRUCTOR) 1684 { 1685 arelent_chain *chain; 1686 1687 /* This section has relocs made up by us, not the file, so take 1688 them out of their chain and place them into the data area 1689 provided. */ 1690 for (count = 0, chain = section->constructor_chain; 1691 count < section->reloc_count; 1692 count++, chain = chain->next) 1693 *relptr++ = &chain->relent; 1694 } 1695 else 1696 { 1697 arelent *tblptr; 1698 1699 if (! ecoff_slurp_reloc_table (abfd, section, symbols)) 1700 return -1; 1701 1702 tblptr = section->relocation; 1703 1704 for (count = 0; count < section->reloc_count; count++) 1705 *relptr++ = tblptr++; 1706 } 1707 1708 *relptr = NULL; 1709 1710 return section->reloc_count; 1711} 1712 1713/* Provided a BFD, a section and an offset into the section, calculate 1714 and return the name of the source file and the line nearest to the 1715 wanted location. */ 1716 1717bool 1718_bfd_ecoff_find_nearest_line (bfd *abfd, 1719 asymbol **symbols ATTRIBUTE_UNUSED, 1720 asection *section, 1721 bfd_vma offset, 1722 const char **filename_ptr, 1723 const char **functionname_ptr, 1724 unsigned int *retline_ptr, 1725 unsigned int *discriminator_ptr) 1726{ 1727 const struct ecoff_debug_swap * const debug_swap 1728 = &ecoff_backend (abfd)->debug_swap; 1729 struct ecoff_debug_info * const debug_info = &ecoff_data (abfd)->debug_info; 1730 struct ecoff_find_line *line_info; 1731 1732 /* Make sure we have the FDR's. */ 1733 if (! _bfd_ecoff_slurp_symbolic_info (abfd, NULL, debug_info) 1734 || bfd_get_symcount (abfd) == 0) 1735 return false; 1736 1737 if (ecoff_data (abfd)->find_line_info == NULL) 1738 { 1739 size_t amt = sizeof (struct ecoff_find_line); 1740 1741 ecoff_data (abfd)->find_line_info = 1742 (struct ecoff_find_line *) bfd_zalloc (abfd, amt); 1743 if (ecoff_data (abfd)->find_line_info == NULL) 1744 return false; 1745 } 1746 1747 if (discriminator_ptr) 1748 *discriminator_ptr = 0; 1749 line_info = ecoff_data (abfd)->find_line_info; 1750 return _bfd_ecoff_locate_line (abfd, section, offset, debug_info, 1751 debug_swap, line_info, filename_ptr, 1752 functionname_ptr, retline_ptr); 1753} 1754 1755/* Copy private BFD data. This is called by objcopy and strip. We 1756 use it to copy the ECOFF debugging information from one BFD to the 1757 other. It would be theoretically possible to represent the ECOFF 1758 debugging information in the symbol table. However, it would be a 1759 lot of work, and there would be little gain (gas, gdb, and ld 1760 already access the ECOFF debugging information via the 1761 ecoff_debug_info structure, and that structure would have to be 1762 retained in order to support ECOFF debugging in MIPS ELF). 1763 1764 The debugging information for the ECOFF external symbols comes from 1765 the symbol table, so this function only handles the other debugging 1766 information. */ 1767 1768bool 1769_bfd_ecoff_bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd) 1770{ 1771 struct ecoff_debug_info *iinfo = &ecoff_data (ibfd)->debug_info; 1772 struct ecoff_debug_info *oinfo = &ecoff_data (obfd)->debug_info; 1773 int i; 1774 asymbol **sym_ptr_ptr; 1775 size_t c; 1776 bool local; 1777 1778 /* We only want to copy information over if both BFD's use ECOFF 1779 format. */ 1780 if (bfd_get_flavour (ibfd) != bfd_target_ecoff_flavour 1781 || bfd_get_flavour (obfd) != bfd_target_ecoff_flavour) 1782 return true; 1783 1784 /* Copy the GP value and the register masks. */ 1785 ecoff_data (obfd)->gp = ecoff_data (ibfd)->gp; 1786 ecoff_data (obfd)->gprmask = ecoff_data (ibfd)->gprmask; 1787 ecoff_data (obfd)->fprmask = ecoff_data (ibfd)->fprmask; 1788 for (i = 0; i < 3; i++) 1789 ecoff_data (obfd)->cprmask[i] = ecoff_data (ibfd)->cprmask[i]; 1790 1791 /* Copy the version stamp. */ 1792 oinfo->symbolic_header.vstamp = iinfo->symbolic_header.vstamp; 1793 1794 /* If there are no symbols, don't copy any debugging information. */ 1795 c = bfd_get_symcount (obfd); 1796 sym_ptr_ptr = bfd_get_outsymbols (obfd); 1797 if (c == 0 || sym_ptr_ptr == NULL) 1798 return true; 1799 1800 /* See if there are any local symbols. */ 1801 local = false; 1802 for (; c > 0; c--, sym_ptr_ptr++) 1803 { 1804 if (ecoffsymbol (*sym_ptr_ptr)->local) 1805 { 1806 local = true; 1807 break; 1808 } 1809 } 1810 1811 if (local) 1812 { 1813 /* There are some local symbols. We just bring over all the 1814 debugging information. FIXME: This is not quite the right 1815 thing to do. If the user has asked us to discard all 1816 debugging information, then we are probably going to wind up 1817 keeping it because there will probably be some local symbol 1818 which objcopy did not discard. We should actually break 1819 apart the debugging information and only keep that which 1820 applies to the symbols we want to keep. */ 1821 oinfo->symbolic_header.ilineMax = iinfo->symbolic_header.ilineMax; 1822 oinfo->symbolic_header.cbLine = iinfo->symbolic_header.cbLine; 1823 oinfo->line = iinfo->line; 1824 1825 oinfo->symbolic_header.idnMax = iinfo->symbolic_header.idnMax; 1826 oinfo->external_dnr = iinfo->external_dnr; 1827 1828 oinfo->symbolic_header.ipdMax = iinfo->symbolic_header.ipdMax; 1829 oinfo->external_pdr = iinfo->external_pdr; 1830 1831 oinfo->symbolic_header.isymMax = iinfo->symbolic_header.isymMax; 1832 oinfo->external_sym = iinfo->external_sym; 1833 1834 oinfo->symbolic_header.ioptMax = iinfo->symbolic_header.ioptMax; 1835 oinfo->external_opt = iinfo->external_opt; 1836 1837 oinfo->symbolic_header.iauxMax = iinfo->symbolic_header.iauxMax; 1838 oinfo->external_aux = iinfo->external_aux; 1839 1840 oinfo->symbolic_header.issMax = iinfo->symbolic_header.issMax; 1841 oinfo->ss = iinfo->ss; 1842 1843 oinfo->symbolic_header.ifdMax = iinfo->symbolic_header.ifdMax; 1844 oinfo->external_fdr = iinfo->external_fdr; 1845 1846 oinfo->symbolic_header.crfd = iinfo->symbolic_header.crfd; 1847 oinfo->external_rfd = iinfo->external_rfd; 1848 } 1849 else 1850 { 1851 /* We are discarding all the local symbol information. Look 1852 through the external symbols and remove all references to FDR 1853 or aux information. */ 1854 c = bfd_get_symcount (obfd); 1855 sym_ptr_ptr = bfd_get_outsymbols (obfd); 1856 for (; c > 0; c--, sym_ptr_ptr++) 1857 { 1858 EXTR esym; 1859 1860 (*(ecoff_backend (obfd)->debug_swap.swap_ext_in)) 1861 (obfd, ecoffsymbol (*sym_ptr_ptr)->native, &esym); 1862 esym.ifd = ifdNil; 1863 esym.asym.index = indexNil; 1864 (*(ecoff_backend (obfd)->debug_swap.swap_ext_out)) 1865 (obfd, &esym, ecoffsymbol (*sym_ptr_ptr)->native); 1866 } 1867 } 1868 1869 return true; 1870} 1871 1872/* Set the architecture. The supported architecture is stored in the 1873 backend pointer. We always set the architecture anyhow, since many 1874 callers ignore the return value. */ 1875 1876bool 1877_bfd_ecoff_set_arch_mach (bfd *abfd, 1878 enum bfd_architecture arch, 1879 unsigned long machine) 1880{ 1881 bfd_default_set_arch_mach (abfd, arch, machine); 1882 return arch == ecoff_backend (abfd)->arch; 1883} 1884 1885/* Get the size of the section headers. */ 1886 1887int 1888_bfd_ecoff_sizeof_headers (bfd *abfd, 1889 struct bfd_link_info *info ATTRIBUTE_UNUSED) 1890{ 1891 asection *current; 1892 int c; 1893 int ret; 1894 1895 c = 0; 1896 for (current = abfd->sections; 1897 current != NULL; 1898 current = current->next) 1899 ++c; 1900 1901 ret = (bfd_coff_filhsz (abfd) 1902 + bfd_coff_aoutsz (abfd) 1903 + c * bfd_coff_scnhsz (abfd)); 1904 return (int) BFD_ALIGN (ret, 16); 1905} 1906 1907/* Get the contents of a section. */ 1908 1909bool 1910_bfd_ecoff_get_section_contents (bfd *abfd, 1911 asection *section, 1912 void * location, 1913 file_ptr offset, 1914 bfd_size_type count) 1915{ 1916 return _bfd_generic_get_section_contents (abfd, section, location, 1917 offset, count); 1918} 1919 1920/* Sort sections by VMA, but put SEC_ALLOC sections first. This is 1921 called via qsort. */ 1922 1923static int 1924ecoff_sort_hdrs (const void * arg1, const void * arg2) 1925{ 1926 const asection *hdr1 = *(const asection **) arg1; 1927 const asection *hdr2 = *(const asection **) arg2; 1928 1929 if ((hdr1->flags & SEC_ALLOC) != 0) 1930 { 1931 if ((hdr2->flags & SEC_ALLOC) == 0) 1932 return -1; 1933 } 1934 else 1935 { 1936 if ((hdr2->flags & SEC_ALLOC) != 0) 1937 return 1; 1938 } 1939 if (hdr1->vma < hdr2->vma) 1940 return -1; 1941 else if (hdr1->vma > hdr2->vma) 1942 return 1; 1943 else 1944 return 0; 1945} 1946 1947/* Calculate the file position for each section, and set 1948 reloc_filepos. */ 1949 1950static bool 1951ecoff_compute_section_file_positions (bfd *abfd) 1952{ 1953 file_ptr sofar, file_sofar; 1954 asection **sorted_hdrs; 1955 asection *current; 1956 unsigned int i; 1957 file_ptr old_sofar; 1958 bool rdata_in_text; 1959 bool first_data, first_nonalloc; 1960 const bfd_vma round = ecoff_backend (abfd)->round; 1961 bfd_size_type amt; 1962 1963 sofar = _bfd_ecoff_sizeof_headers (abfd, NULL); 1964 file_sofar = sofar; 1965 1966 /* Sort the sections by VMA. */ 1967 amt = abfd->section_count; 1968 amt *= sizeof (asection *); 1969 sorted_hdrs = (asection **) bfd_malloc (amt); 1970 if (sorted_hdrs == NULL) 1971 return false; 1972 for (current = abfd->sections, i = 0; 1973 current != NULL; 1974 current = current->next, i++) 1975 sorted_hdrs[i] = current; 1976 BFD_ASSERT (i == abfd->section_count); 1977 1978 qsort (sorted_hdrs, abfd->section_count, sizeof (asection *), 1979 ecoff_sort_hdrs); 1980 1981 /* Some versions of the OSF linker put the .rdata section in the 1982 text segment, and some do not. */ 1983 rdata_in_text = ecoff_backend (abfd)->rdata_in_text; 1984 if (rdata_in_text) 1985 { 1986 for (i = 0; i < abfd->section_count; i++) 1987 { 1988 current = sorted_hdrs[i]; 1989 if (streq (current->name, _RDATA)) 1990 break; 1991 if ((current->flags & SEC_CODE) == 0 1992 && ! streq (current->name, _PDATA) 1993 && ! streq (current->name, _RCONST)) 1994 { 1995 rdata_in_text = false; 1996 break; 1997 } 1998 } 1999 } 2000 ecoff_data (abfd)->rdata_in_text = rdata_in_text; 2001 2002 first_data = true; 2003 first_nonalloc = true; 2004 for (i = 0; i < abfd->section_count; i++) 2005 { 2006 unsigned int alignment_power; 2007 2008 current = sorted_hdrs[i]; 2009 2010 /* For the Alpha ECOFF .pdata section the lnnoptr field is 2011 supposed to indicate the number of .pdata entries that are 2012 really in the section. Each entry is 8 bytes. We store this 2013 away in line_filepos before increasing the section size. */ 2014 if (streq (current->name, _PDATA)) 2015 current->line_filepos = current->size / 8; 2016 2017 alignment_power = current->alignment_power; 2018 2019 /* On Ultrix, the data sections in an executable file must be 2020 aligned to a page boundary within the file. This does not 2021 affect the section size, though. FIXME: Does this work for 2022 other platforms? It requires some modification for the 2023 Alpha, because .rdata on the Alpha goes with the text, not 2024 the data. */ 2025 if ((abfd->flags & EXEC_P) != 0 2026 && (abfd->flags & D_PAGED) != 0 2027 && ! first_data 2028 && (current->flags & SEC_CODE) == 0 2029 && (! rdata_in_text 2030 || ! streq (current->name, _RDATA)) 2031 && ! streq (current->name, _PDATA) 2032 && ! streq (current->name, _RCONST)) 2033 { 2034 sofar = (sofar + round - 1) &~ (round - 1); 2035 file_sofar = (file_sofar + round - 1) &~ (round - 1); 2036 first_data = false; 2037 } 2038 else if (streq (current->name, _LIB)) 2039 { 2040 /* On Irix 4, the location of contents of the .lib section 2041 from a shared library section is also rounded up to a 2042 page boundary. */ 2043 2044 sofar = (sofar + round - 1) &~ (round - 1); 2045 file_sofar = (file_sofar + round - 1) &~ (round - 1); 2046 } 2047 else if (first_nonalloc 2048 && (current->flags & SEC_ALLOC) == 0 2049 && (abfd->flags & D_PAGED) != 0) 2050 { 2051 /* Skip up to the next page for an unallocated section, such 2052 as the .comment section on the Alpha. This leaves room 2053 for the .bss section. */ 2054 first_nonalloc = false; 2055 sofar = (sofar + round - 1) &~ (round - 1); 2056 file_sofar = (file_sofar + round - 1) &~ (round - 1); 2057 } 2058 2059 /* Align the sections in the file to the same boundary on 2060 which they are aligned in virtual memory. */ 2061 sofar = BFD_ALIGN (sofar, 1 << alignment_power); 2062 if ((current->flags & SEC_HAS_CONTENTS) != 0) 2063 file_sofar = BFD_ALIGN (file_sofar, 1 << alignment_power); 2064 2065 if ((abfd->flags & D_PAGED) != 0 2066 && (current->flags & SEC_ALLOC) != 0) 2067 { 2068 sofar += (current->vma - sofar) % round; 2069 if ((current->flags & SEC_HAS_CONTENTS) != 0) 2070 file_sofar += (current->vma - file_sofar) % round; 2071 } 2072 2073 if ((current->flags & (SEC_HAS_CONTENTS | SEC_LOAD)) != 0) 2074 current->filepos = file_sofar; 2075 2076 sofar += current->size; 2077 if ((current->flags & SEC_HAS_CONTENTS) != 0) 2078 file_sofar += current->size; 2079 2080 /* Make sure that this section is of the right size too. */ 2081 old_sofar = sofar; 2082 sofar = BFD_ALIGN (sofar, 1 << alignment_power); 2083 if ((current->flags & SEC_HAS_CONTENTS) != 0) 2084 file_sofar = BFD_ALIGN (file_sofar, 1 << alignment_power); 2085 current->size += sofar - old_sofar; 2086 } 2087 2088 free (sorted_hdrs); 2089 sorted_hdrs = NULL; 2090 2091 ecoff_data (abfd)->reloc_filepos = file_sofar; 2092 2093 return true; 2094} 2095 2096/* Determine the location of the relocs for all the sections in the 2097 output file, as well as the location of the symbolic debugging 2098 information. */ 2099 2100static bfd_size_type 2101ecoff_compute_reloc_file_positions (bfd *abfd) 2102{ 2103 const bfd_size_type external_reloc_size = 2104 ecoff_backend (abfd)->external_reloc_size; 2105 file_ptr reloc_base; 2106 bfd_size_type reloc_size; 2107 asection *current; 2108 file_ptr sym_base; 2109 2110 if (! abfd->output_has_begun) 2111 { 2112 if (! ecoff_compute_section_file_positions (abfd)) 2113 abort (); 2114 abfd->output_has_begun = true; 2115 } 2116 2117 reloc_base = ecoff_data (abfd)->reloc_filepos; 2118 2119 reloc_size = 0; 2120 for (current = abfd->sections; 2121 current != NULL; 2122 current = current->next) 2123 { 2124 if (current->reloc_count == 0) 2125 current->rel_filepos = 0; 2126 else 2127 { 2128 bfd_size_type relsize; 2129 2130 current->rel_filepos = reloc_base; 2131 relsize = current->reloc_count * external_reloc_size; 2132 reloc_size += relsize; 2133 reloc_base += relsize; 2134 } 2135 } 2136 2137 sym_base = ecoff_data (abfd)->reloc_filepos + reloc_size; 2138 2139 /* At least on Ultrix, the symbol table of an executable file must 2140 be aligned to a page boundary. FIXME: Is this true on other 2141 platforms? */ 2142 if ((abfd->flags & EXEC_P) != 0 2143 && (abfd->flags & D_PAGED) != 0) 2144 sym_base = ((sym_base + ecoff_backend (abfd)->round - 1) 2145 &~ (ecoff_backend (abfd)->round - 1)); 2146 2147 ecoff_data (abfd)->sym_filepos = sym_base; 2148 2149 return reloc_size; 2150} 2151 2152/* Set the contents of a section. */ 2153 2154bool 2155_bfd_ecoff_set_section_contents (bfd *abfd, 2156 asection *section, 2157 const void * location, 2158 file_ptr offset, 2159 bfd_size_type count) 2160{ 2161 file_ptr pos; 2162 2163 /* This must be done first, because bfd_set_section_contents is 2164 going to set output_has_begun to TRUE. */ 2165 if (! abfd->output_has_begun 2166 && ! ecoff_compute_section_file_positions (abfd)) 2167 return false; 2168 2169 /* Handle the .lib section specially so that Irix 4 shared libraries 2170 work out. See coff_set_section_contents in coffcode.h. */ 2171 if (streq (section->name, _LIB)) 2172 { 2173 bfd_byte *rec, *recend; 2174 2175 rec = (bfd_byte *) location; 2176 recend = rec + count; 2177 while (rec < recend) 2178 { 2179 ++section->lma; 2180 rec += bfd_get_32 (abfd, rec) * 4; 2181 } 2182 2183 BFD_ASSERT (rec == recend); 2184 } 2185 2186 if (count == 0) 2187 return true; 2188 2189 pos = section->filepos + offset; 2190 if (bfd_seek (abfd, pos, SEEK_SET) != 0 2191 || bfd_bwrite (location, count, abfd) != count) 2192 return false; 2193 2194 return true; 2195} 2196 2197/* Set the GP value for an ECOFF file. This is a hook used by the 2198 assembler. */ 2199 2200bool 2201bfd_ecoff_set_gp_value (bfd *abfd, bfd_vma gp_value) 2202{ 2203 if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour 2204 || bfd_get_format (abfd) != bfd_object) 2205 { 2206 bfd_set_error (bfd_error_invalid_operation); 2207 return false; 2208 } 2209 2210 ecoff_data (abfd)->gp = gp_value; 2211 2212 return true; 2213} 2214 2215/* Set the register masks for an ECOFF file. This is a hook used by 2216 the assembler. */ 2217 2218bool 2219bfd_ecoff_set_regmasks (bfd *abfd, 2220 unsigned long gprmask, 2221 unsigned long fprmask, 2222 unsigned long *cprmask) 2223{ 2224 ecoff_data_type *tdata; 2225 2226 if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour 2227 || bfd_get_format (abfd) != bfd_object) 2228 { 2229 bfd_set_error (bfd_error_invalid_operation); 2230 return false; 2231 } 2232 2233 tdata = ecoff_data (abfd); 2234 tdata->gprmask = gprmask; 2235 tdata->fprmask = fprmask; 2236 if (cprmask != NULL) 2237 { 2238 int i; 2239 2240 for (i = 0; i < 3; i++) 2241 tdata->cprmask[i] = cprmask[i]; 2242 } 2243 2244 return true; 2245} 2246 2247/* Get ECOFF EXTR information for an external symbol. This function 2248 is passed to bfd_ecoff_debug_externals. */ 2249 2250static bool 2251ecoff_get_extr (asymbol *sym, EXTR *esym) 2252{ 2253 ecoff_symbol_type *ecoff_sym_ptr; 2254 bfd *input_bfd; 2255 2256 if (bfd_asymbol_flavour (sym) != bfd_target_ecoff_flavour 2257 || ecoffsymbol (sym)->native == NULL) 2258 { 2259 /* Don't include debugging, local, or section symbols. */ 2260 if ((sym->flags & BSF_DEBUGGING) != 0 2261 || (sym->flags & BSF_LOCAL) != 0 2262 || (sym->flags & BSF_SECTION_SYM) != 0) 2263 return false; 2264 2265 esym->jmptbl = 0; 2266 esym->cobol_main = 0; 2267 esym->weakext = (sym->flags & BSF_WEAK) != 0; 2268 esym->reserved = 0; 2269 esym->ifd = ifdNil; 2270 /* FIXME: we can do better than this for st and sc. */ 2271 esym->asym.st = stGlobal; 2272 esym->asym.sc = scAbs; 2273 esym->asym.reserved = 0; 2274 esym->asym.index = indexNil; 2275 return true; 2276 } 2277 2278 ecoff_sym_ptr = ecoffsymbol (sym); 2279 2280 if (ecoff_sym_ptr->local) 2281 return false; 2282 2283 input_bfd = bfd_asymbol_bfd (sym); 2284 (*(ecoff_backend (input_bfd)->debug_swap.swap_ext_in)) 2285 (input_bfd, ecoff_sym_ptr->native, esym); 2286 2287 /* If the symbol was defined by the linker, then esym will be 2288 undefined but sym will not be. Get a better class for such a 2289 symbol. */ 2290 if ((esym->asym.sc == scUndefined 2291 || esym->asym.sc == scSUndefined) 2292 && ! bfd_is_und_section (bfd_asymbol_section (sym))) 2293 esym->asym.sc = scAbs; 2294 2295 /* Adjust the FDR index for the symbol by that used for the input 2296 BFD. */ 2297 if (esym->ifd != -1) 2298 { 2299 struct ecoff_debug_info *input_debug; 2300 2301 input_debug = &ecoff_data (input_bfd)->debug_info; 2302 BFD_ASSERT (esym->ifd < input_debug->symbolic_header.ifdMax); 2303 if (input_debug->ifdmap != NULL) 2304 esym->ifd = input_debug->ifdmap[esym->ifd]; 2305 } 2306 2307 return true; 2308} 2309 2310/* Set the external symbol index. This routine is passed to 2311 bfd_ecoff_debug_externals. */ 2312 2313static void 2314ecoff_set_index (asymbol *sym, bfd_size_type indx) 2315{ 2316 ecoff_set_sym_index (sym, indx); 2317} 2318 2319/* Write out an ECOFF file. */ 2320 2321bool 2322_bfd_ecoff_write_object_contents (bfd *abfd) 2323{ 2324 const struct ecoff_backend_data * const backend = ecoff_backend (abfd); 2325 const bfd_vma round = backend->round; 2326 const bfd_size_type filhsz = bfd_coff_filhsz (abfd); 2327 const bfd_size_type aoutsz = bfd_coff_aoutsz (abfd); 2328 const bfd_size_type scnhsz = bfd_coff_scnhsz (abfd); 2329 const bfd_size_type external_hdr_size 2330 = backend->debug_swap.external_hdr_size; 2331 const bfd_size_type external_reloc_size = backend->external_reloc_size; 2332 void (* const adjust_reloc_out) (bfd *, const arelent *, struct internal_reloc *) 2333 = backend->adjust_reloc_out; 2334 void (* const swap_reloc_out) (bfd *, const struct internal_reloc *, void *) 2335 = backend->swap_reloc_out; 2336 struct ecoff_debug_info * const debug = &ecoff_data (abfd)->debug_info; 2337 HDRR * const symhdr = &debug->symbolic_header; 2338 asection *current; 2339 unsigned int count; 2340 bfd_size_type reloc_size; 2341 bfd_size_type text_size; 2342 bfd_vma text_start; 2343 bool set_text_start; 2344 bfd_size_type data_size; 2345 bfd_vma data_start; 2346 bool set_data_start; 2347 bfd_size_type bss_size; 2348 void * buff = NULL; 2349 void * reloc_buff = NULL; 2350 struct internal_filehdr internal_f; 2351 struct internal_aouthdr internal_a; 2352 int i; 2353 2354 /* Determine where the sections and relocs will go in the output 2355 file. */ 2356 reloc_size = ecoff_compute_reloc_file_positions (abfd); 2357 2358 count = 1; 2359 for (current = abfd->sections; 2360 current != NULL; 2361 current = current->next) 2362 { 2363 current->target_index = count; 2364 ++count; 2365 } 2366 2367 if ((abfd->flags & D_PAGED) != 0) 2368 text_size = _bfd_ecoff_sizeof_headers (abfd, NULL); 2369 else 2370 text_size = 0; 2371 text_start = 0; 2372 set_text_start = false; 2373 data_size = 0; 2374 data_start = 0; 2375 set_data_start = false; 2376 bss_size = 0; 2377 2378 /* Write section headers to the file. */ 2379 2380 /* Allocate buff big enough to hold a section header, 2381 file header, or a.out header. */ 2382 { 2383 bfd_size_type siz; 2384 2385 siz = scnhsz; 2386 if (siz < filhsz) 2387 siz = filhsz; 2388 if (siz < aoutsz) 2389 siz = aoutsz; 2390 buff = bfd_malloc (siz); 2391 if (buff == NULL) 2392 goto error_return; 2393 } 2394 2395 internal_f.f_nscns = 0; 2396 if (bfd_seek (abfd, (file_ptr) (filhsz + aoutsz), SEEK_SET) != 0) 2397 goto error_return; 2398 2399 for (current = abfd->sections; 2400 current != NULL; 2401 current = current->next) 2402 { 2403 struct internal_scnhdr section; 2404 bfd_vma vma; 2405 2406 ++internal_f.f_nscns; 2407 2408 strncpy (section.s_name, current->name, sizeof section.s_name); 2409 2410 /* This seems to be correct for Irix 4 shared libraries. */ 2411 vma = bfd_section_vma (current); 2412 if (streq (current->name, _LIB)) 2413 section.s_vaddr = 0; 2414 else 2415 section.s_vaddr = vma; 2416 2417 section.s_paddr = current->lma; 2418 section.s_size = current->size; 2419 2420 /* If this section is unloadable then the scnptr will be 0. */ 2421 if ((current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0) 2422 section.s_scnptr = 0; 2423 else 2424 section.s_scnptr = current->filepos; 2425 section.s_relptr = current->rel_filepos; 2426 2427 /* FIXME: the lnnoptr of the .sbss or .sdata section of an 2428 object file produced by the assembler is supposed to point to 2429 information about how much room is required by objects of 2430 various different sizes. I think this only matters if we 2431 want the linker to compute the best size to use, or 2432 something. I don't know what happens if the information is 2433 not present. */ 2434 if (! streq (current->name, _PDATA)) 2435 section.s_lnnoptr = 0; 2436 else 2437 { 2438 /* The Alpha ECOFF .pdata section uses the lnnoptr field to 2439 hold the number of entries in the section (each entry is 2440 8 bytes). We stored this in the line_filepos field in 2441 ecoff_compute_section_file_positions. */ 2442 section.s_lnnoptr = current->line_filepos; 2443 } 2444 2445 section.s_nreloc = current->reloc_count; 2446 section.s_nlnno = 0; 2447 section.s_flags = ecoff_sec_to_styp_flags (current->name, 2448 current->flags); 2449 2450 if (bfd_coff_swap_scnhdr_out (abfd, (void *) §ion, buff) == 0 2451 || bfd_bwrite (buff, scnhsz, abfd) != scnhsz) 2452 goto error_return; 2453 2454 if ((section.s_flags & STYP_TEXT) != 0 2455 || ((section.s_flags & STYP_RDATA) != 0 2456 && ecoff_data (abfd)->rdata_in_text) 2457 || section.s_flags == STYP_PDATA 2458 || (section.s_flags & STYP_DYNAMIC) != 0 2459 || (section.s_flags & STYP_LIBLIST) != 0 2460 || (section.s_flags & STYP_RELDYN) != 0 2461 || section.s_flags == STYP_CONFLIC 2462 || (section.s_flags & STYP_DYNSTR) != 0 2463 || (section.s_flags & STYP_DYNSYM) != 0 2464 || (section.s_flags & STYP_HASH) != 0 2465 || (section.s_flags & STYP_ECOFF_INIT) != 0 2466 || (section.s_flags & STYP_ECOFF_FINI) != 0 2467 || section.s_flags == STYP_RCONST) 2468 { 2469 text_size += current->size; 2470 if (! set_text_start || text_start > vma) 2471 { 2472 text_start = vma; 2473 set_text_start = true; 2474 } 2475 } 2476 else if ((section.s_flags & STYP_RDATA) != 0 2477 || (section.s_flags & STYP_DATA) != 0 2478 || (section.s_flags & STYP_LITA) != 0 2479 || (section.s_flags & STYP_LIT8) != 0 2480 || (section.s_flags & STYP_LIT4) != 0 2481 || (section.s_flags & STYP_SDATA) != 0 2482 || section.s_flags == STYP_XDATA 2483 || (section.s_flags & STYP_GOT) != 0) 2484 { 2485 data_size += current->size; 2486 if (! set_data_start || data_start > vma) 2487 { 2488 data_start = vma; 2489 set_data_start = true; 2490 } 2491 } 2492 else if ((section.s_flags & STYP_BSS) != 0 2493 || (section.s_flags & STYP_SBSS) != 0) 2494 bss_size += current->size; 2495 else if (section.s_flags == 0 2496 || (section.s_flags & STYP_ECOFF_LIB) != 0 2497 || section.s_flags == STYP_COMMENT) 2498 /* Do nothing. */ ; 2499 else 2500 abort (); 2501 } 2502 2503 /* Set up the file header. */ 2504 internal_f.f_magic = ecoff_get_magic (abfd); 2505 2506 /* We will NOT put a fucking timestamp in the header here. Every 2507 time you put it back, I will come in and take it out again. I'm 2508 sorry. This field does not belong here. We fill it with a 0 so 2509 it compares the same but is not a reasonable time. -- 2510 gnu@cygnus.com. */ 2511 internal_f.f_timdat = 0; 2512 2513 if (bfd_get_symcount (abfd) != 0) 2514 { 2515 /* The ECOFF f_nsyms field is not actually the number of 2516 symbols, it's the size of symbolic information header. */ 2517 internal_f.f_nsyms = external_hdr_size; 2518 internal_f.f_symptr = ecoff_data (abfd)->sym_filepos; 2519 } 2520 else 2521 { 2522 internal_f.f_nsyms = 0; 2523 internal_f.f_symptr = 0; 2524 } 2525 2526 internal_f.f_opthdr = aoutsz; 2527 2528 internal_f.f_flags = F_LNNO; 2529 if (reloc_size == 0) 2530 internal_f.f_flags |= F_RELFLG; 2531 if (bfd_get_symcount (abfd) == 0) 2532 internal_f.f_flags |= F_LSYMS; 2533 if (abfd->flags & EXEC_P) 2534 internal_f.f_flags |= F_EXEC; 2535 2536 if (bfd_little_endian (abfd)) 2537 internal_f.f_flags |= F_AR32WR; 2538 else 2539 internal_f.f_flags |= F_AR32W; 2540 2541 /* Set up the ``optional'' header. */ 2542 if ((abfd->flags & D_PAGED) != 0) 2543 internal_a.magic = ECOFF_AOUT_ZMAGIC; 2544 else 2545 internal_a.magic = ECOFF_AOUT_OMAGIC; 2546 2547 /* FIXME: Is this really correct? */ 2548 internal_a.vstamp = symhdr->vstamp; 2549 2550 /* At least on Ultrix, these have to be rounded to page boundaries. 2551 FIXME: Is this true on other platforms? */ 2552 if ((abfd->flags & D_PAGED) != 0) 2553 { 2554 internal_a.tsize = (text_size + round - 1) &~ (round - 1); 2555 internal_a.text_start = text_start &~ (round - 1); 2556 internal_a.dsize = (data_size + round - 1) &~ (round - 1); 2557 internal_a.data_start = data_start &~ (round - 1); 2558 } 2559 else 2560 { 2561 internal_a.tsize = text_size; 2562 internal_a.text_start = text_start; 2563 internal_a.dsize = data_size; 2564 internal_a.data_start = data_start; 2565 } 2566 2567 /* On Ultrix, the initial portions of the .sbss and .bss segments 2568 are at the end of the data section. The bsize field in the 2569 optional header records how many bss bytes are required beyond 2570 those in the data section. The value is not rounded to a page 2571 boundary. */ 2572 if (bss_size < internal_a.dsize - data_size) 2573 bss_size = 0; 2574 else 2575 bss_size -= internal_a.dsize - data_size; 2576 internal_a.bsize = bss_size; 2577 internal_a.bss_start = internal_a.data_start + internal_a.dsize; 2578 2579 internal_a.entry = bfd_get_start_address (abfd); 2580 2581 internal_a.gp_value = ecoff_data (abfd)->gp; 2582 2583 internal_a.gprmask = ecoff_data (abfd)->gprmask; 2584 internal_a.fprmask = ecoff_data (abfd)->fprmask; 2585 for (i = 0; i < 4; i++) 2586 internal_a.cprmask[i] = ecoff_data (abfd)->cprmask[i]; 2587 2588 /* Let the backend adjust the headers if necessary. */ 2589 if (backend->adjust_headers) 2590 { 2591 if (! (*backend->adjust_headers) (abfd, &internal_f, &internal_a)) 2592 goto error_return; 2593 } 2594 2595 /* Write out the file header and the optional header. */ 2596 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) 2597 goto error_return; 2598 2599 bfd_coff_swap_filehdr_out (abfd, (void *) &internal_f, buff); 2600 if (bfd_bwrite (buff, filhsz, abfd) != filhsz) 2601 goto error_return; 2602 2603 bfd_coff_swap_aouthdr_out (abfd, (void *) &internal_a, buff); 2604 if (bfd_bwrite (buff, aoutsz, abfd) != aoutsz) 2605 goto error_return; 2606 2607 /* Build the external symbol information. This must be done before 2608 writing out the relocs so that we know the symbol indices. We 2609 don't do this if this BFD was created by the backend linker, 2610 since it will have already handled the symbols and relocs. */ 2611 if (! ecoff_data (abfd)->linker) 2612 { 2613 symhdr->iextMax = 0; 2614 symhdr->issExtMax = 0; 2615 debug->external_ext = debug->external_ext_end = NULL; 2616 debug->ssext = debug->ssext_end = NULL; 2617 if (! bfd_ecoff_debug_externals (abfd, debug, &backend->debug_swap, 2618 (abfd->flags & EXEC_P) == 0, 2619 ecoff_get_extr, ecoff_set_index)) 2620 goto error_return; 2621 2622 /* Write out the relocs. */ 2623 for (current = abfd->sections; 2624 current != NULL; 2625 current = current->next) 2626 { 2627 arelent **reloc_ptr_ptr; 2628 arelent **reloc_end; 2629 char *out_ptr; 2630 bfd_size_type amt; 2631 2632 if (current->reloc_count == 0) 2633 continue; 2634 2635 amt = current->reloc_count * external_reloc_size; 2636 reloc_buff = bfd_zalloc (abfd, amt); 2637 if (reloc_buff == NULL) 2638 goto error_return; 2639 2640 reloc_ptr_ptr = current->orelocation; 2641 reloc_end = reloc_ptr_ptr + current->reloc_count; 2642 out_ptr = (char *) reloc_buff; 2643 2644 for (; 2645 reloc_ptr_ptr < reloc_end; 2646 reloc_ptr_ptr++, out_ptr += external_reloc_size) 2647 { 2648 arelent *reloc; 2649 asymbol *sym; 2650 struct internal_reloc in; 2651 2652 memset ((void *) &in, 0, sizeof in); 2653 2654 reloc = *reloc_ptr_ptr; 2655 sym = *reloc->sym_ptr_ptr; 2656 2657 /* If the howto field has not been initialised then skip this reloc. 2658 This assumes that an error message has been issued elsewhere. */ 2659 if (reloc->howto == NULL) 2660 continue; 2661 2662 in.r_vaddr = reloc->address + bfd_section_vma (current); 2663 in.r_type = reloc->howto->type; 2664 2665 if ((sym->flags & BSF_SECTION_SYM) == 0) 2666 { 2667 in.r_symndx = ecoff_get_sym_index (*reloc->sym_ptr_ptr); 2668 in.r_extern = 1; 2669 } 2670 else 2671 { 2672 const char *name; 2673 unsigned int j; 2674 static struct 2675 { 2676 const char * name; 2677 long r_symndx; 2678 } 2679 section_symndx [] = 2680 { 2681 { _TEXT, RELOC_SECTION_TEXT }, 2682 { _RDATA, RELOC_SECTION_RDATA }, 2683 { _DATA, RELOC_SECTION_DATA }, 2684 { _SDATA, RELOC_SECTION_SDATA }, 2685 { _SBSS, RELOC_SECTION_SBSS }, 2686 { _BSS, RELOC_SECTION_BSS }, 2687 { _INIT, RELOC_SECTION_INIT }, 2688 { _LIT8, RELOC_SECTION_LIT8 }, 2689 { _LIT4, RELOC_SECTION_LIT4 }, 2690 { _XDATA, RELOC_SECTION_XDATA }, 2691 { _PDATA, RELOC_SECTION_PDATA }, 2692 { _FINI, RELOC_SECTION_FINI }, 2693 { _LITA, RELOC_SECTION_LITA }, 2694 { "*ABS*", RELOC_SECTION_ABS }, 2695 { _RCONST, RELOC_SECTION_RCONST } 2696 }; 2697 2698 name = bfd_section_name (bfd_asymbol_section (sym)); 2699 2700 for (j = 0; j < ARRAY_SIZE (section_symndx); j++) 2701 if (streq (name, section_symndx[j].name)) 2702 { 2703 in.r_symndx = section_symndx[j].r_symndx; 2704 break; 2705 } 2706 2707 if (j == ARRAY_SIZE (section_symndx)) 2708 abort (); 2709 in.r_extern = 0; 2710 } 2711 2712 (*adjust_reloc_out) (abfd, reloc, &in); 2713 2714 (*swap_reloc_out) (abfd, &in, (void *) out_ptr); 2715 } 2716 2717 if (bfd_seek (abfd, current->rel_filepos, SEEK_SET) != 0) 2718 goto error_return; 2719 amt = current->reloc_count * external_reloc_size; 2720 if (bfd_bwrite (reloc_buff, amt, abfd) != amt) 2721 goto error_return; 2722 bfd_release (abfd, reloc_buff); 2723 reloc_buff = NULL; 2724 } 2725 2726 /* Write out the symbolic debugging information. */ 2727 if (bfd_get_symcount (abfd) > 0) 2728 { 2729 /* Write out the debugging information. */ 2730 if (! bfd_ecoff_write_debug (abfd, debug, &backend->debug_swap, 2731 ecoff_data (abfd)->sym_filepos)) 2732 goto error_return; 2733 } 2734 } 2735 2736 /* The .bss section of a demand paged executable must receive an 2737 entire page. If there are symbols, the symbols will start on the 2738 next page. If there are no symbols, we must fill out the page by 2739 hand. */ 2740 if (bfd_get_symcount (abfd) == 0 2741 && (abfd->flags & EXEC_P) != 0 2742 && (abfd->flags & D_PAGED) != 0) 2743 { 2744 char c; 2745 2746 if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos - 1, 2747 SEEK_SET) != 0) 2748 goto error_return; 2749 if (bfd_bread (&c, (bfd_size_type) 1, abfd) == 0) 2750 c = 0; 2751 if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos - 1, 2752 SEEK_SET) != 0) 2753 goto error_return; 2754 if (bfd_bwrite (&c, (bfd_size_type) 1, abfd) != 1) 2755 goto error_return; 2756 } 2757 2758 if (reloc_buff != NULL) 2759 bfd_release (abfd, reloc_buff); 2760 free (buff); 2761 return true; 2762 error_return: 2763 if (reloc_buff != NULL) 2764 bfd_release (abfd, reloc_buff); 2765 free (buff); 2766 return false; 2767} 2768 2769/* Archive handling. ECOFF uses what appears to be a unique type of 2770 archive header (armap). The byte ordering of the armap and the 2771 contents are encoded in the name of the armap itself. At least for 2772 now, we only support archives with the same byte ordering in the 2773 armap and the contents. 2774 2775 The first four bytes in the armap are the number of symbol 2776 definitions. This is always a power of two. 2777 2778 This is followed by the symbol definitions. Each symbol definition 2779 occupies 8 bytes. The first four bytes are the offset from the 2780 start of the armap strings to the null-terminated string naming 2781 this symbol. The second four bytes are the file offset to the 2782 archive member which defines this symbol. If the second four bytes 2783 are 0, then this is not actually a symbol definition, and it should 2784 be ignored. 2785 2786 The symbols are hashed into the armap with a closed hashing scheme. 2787 See the functions below for the details of the algorithm. 2788 2789 After the symbol definitions comes four bytes holding the size of 2790 the string table, followed by the string table itself. */ 2791 2792/* The name of an archive headers looks like this: 2793 __________E[BL]E[BL]_ (with a trailing space). 2794 The trailing space is changed to an X if the archive is changed to 2795 indicate that the armap is out of date. 2796 2797 The Alpha seems to use ________64E[BL]E[BL]_. */ 2798 2799#define ARMAP_BIG_ENDIAN 'B' 2800#define ARMAP_LITTLE_ENDIAN 'L' 2801#define ARMAP_MARKER 'E' 2802#define ARMAP_START_LENGTH 10 2803#define ARMAP_HEADER_MARKER_INDEX 10 2804#define ARMAP_HEADER_ENDIAN_INDEX 11 2805#define ARMAP_OBJECT_MARKER_INDEX 12 2806#define ARMAP_OBJECT_ENDIAN_INDEX 13 2807#define ARMAP_END_INDEX 14 2808#define ARMAP_END "_ " 2809 2810/* This is a magic number used in the hashing algorithm. */ 2811#define ARMAP_HASH_MAGIC 0x9dd68ab5 2812 2813/* This returns the hash value to use for a string. It also sets 2814 *REHASH to the rehash adjustment if the first slot is taken. SIZE 2815 is the number of entries in the hash table, and HLOG is the log 2816 base 2 of SIZE. */ 2817 2818static unsigned int 2819ecoff_armap_hash (const char *s, 2820 unsigned int *rehash, 2821 unsigned int size, 2822 unsigned int hlog) 2823{ 2824 unsigned int hash; 2825 2826 if (hlog == 0) 2827 return 0; 2828 hash = *s++; 2829 while (*s != '\0') 2830 hash = ((hash >> 27) | (hash << 5)) + *s++; 2831 hash *= ARMAP_HASH_MAGIC; 2832 *rehash = (hash & (size - 1)) | 1; 2833 return hash >> (32 - hlog); 2834} 2835 2836/* Read in the armap. */ 2837 2838bool 2839_bfd_ecoff_slurp_armap (bfd *abfd) 2840{ 2841 char nextname[17]; 2842 unsigned int i; 2843 struct areltdata *mapdata; 2844 bfd_size_type parsed_size, stringsize; 2845 char *raw_armap; 2846 struct artdata *ardata; 2847 unsigned int count; 2848 char *raw_ptr; 2849 carsym *symdef_ptr; 2850 char *stringbase; 2851 bfd_size_type amt; 2852 2853 /* Get the name of the first element. */ 2854 i = bfd_bread ((void *) nextname, (bfd_size_type) 16, abfd); 2855 if (i == 0) 2856 return true; 2857 if (i != 16) 2858 return false; 2859 2860 if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0) 2861 return false; 2862 2863 /* Irix 4.0.5F apparently can use either an ECOFF armap or a 2864 standard COFF armap. We could move the ECOFF armap stuff into 2865 bfd_slurp_armap, but that seems inappropriate since no other 2866 target uses this format. Instead, we check directly for a COFF 2867 armap. */ 2868 if (startswith (nextname, "/ ")) 2869 return bfd_slurp_armap (abfd); 2870 2871 /* See if the first element is an armap. */ 2872 if (strncmp (nextname, ecoff_backend (abfd)->armap_start, ARMAP_START_LENGTH) != 0 2873 || nextname[ARMAP_HEADER_MARKER_INDEX] != ARMAP_MARKER 2874 || (nextname[ARMAP_HEADER_ENDIAN_INDEX] != ARMAP_BIG_ENDIAN 2875 && nextname[ARMAP_HEADER_ENDIAN_INDEX] != ARMAP_LITTLE_ENDIAN) 2876 || nextname[ARMAP_OBJECT_MARKER_INDEX] != ARMAP_MARKER 2877 || (nextname[ARMAP_OBJECT_ENDIAN_INDEX] != ARMAP_BIG_ENDIAN 2878 && nextname[ARMAP_OBJECT_ENDIAN_INDEX] != ARMAP_LITTLE_ENDIAN) 2879 || strncmp (nextname + ARMAP_END_INDEX, ARMAP_END, sizeof ARMAP_END - 1) != 0) 2880 { 2881 abfd->has_armap = false; 2882 return true; 2883 } 2884 2885 /* Make sure we have the right byte ordering. */ 2886 if (((nextname[ARMAP_HEADER_ENDIAN_INDEX] == ARMAP_BIG_ENDIAN) 2887 ^ (bfd_header_big_endian (abfd))) 2888 || ((nextname[ARMAP_OBJECT_ENDIAN_INDEX] == ARMAP_BIG_ENDIAN) 2889 ^ (bfd_big_endian (abfd)))) 2890 { 2891 bfd_set_error (bfd_error_wrong_format); 2892 return false; 2893 } 2894 2895 /* Read in the armap. */ 2896 ardata = bfd_ardata (abfd); 2897 mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd); 2898 if (mapdata == NULL) 2899 return false; 2900 parsed_size = mapdata->parsed_size; 2901 free (mapdata); 2902 2903 if (parsed_size + 1 < 9) 2904 { 2905 bfd_set_error (bfd_error_malformed_archive); 2906 return false; 2907 } 2908 2909 raw_armap = (char *) _bfd_alloc_and_read (abfd, parsed_size + 1, parsed_size); 2910 if (raw_armap == NULL) 2911 return false; 2912 raw_armap[parsed_size] = 0; 2913 2914 ardata->tdata = (void *) raw_armap; 2915 2916 count = H_GET_32 (abfd, raw_armap); 2917 if ((parsed_size - 8) / 8 < count) 2918 goto error_malformed; 2919 2920 ardata->symdef_count = 0; 2921 ardata->cache = NULL; 2922 2923 /* This code used to overlay the symdefs over the raw archive data, 2924 but that doesn't work on a 64 bit host. */ 2925 stringbase = raw_armap + count * 8 + 8; 2926 stringsize = parsed_size - (count * 8 + 8); 2927 2928#ifdef CHECK_ARMAP_HASH 2929 { 2930 unsigned int hlog; 2931 2932 /* Double check that I have the hashing algorithm right by making 2933 sure that every symbol can be looked up successfully. */ 2934 hlog = 0; 2935 for (i = 1; i < count; i <<= 1) 2936 hlog++; 2937 BFD_ASSERT (i == count); 2938 2939 raw_ptr = raw_armap + 4; 2940 for (i = 0; i < count; i++, raw_ptr += 8) 2941 { 2942 unsigned int name_offset, file_offset; 2943 unsigned int hash, rehash, srch; 2944 2945 name_offset = H_GET_32 (abfd, raw_ptr); 2946 file_offset = H_GET_32 (abfd, (raw_ptr + 4)); 2947 if (file_offset == 0) 2948 continue; 2949 hash = ecoff_armap_hash (stringbase + name_offset, &rehash, count, 2950 hlog); 2951 if (hash == i) 2952 continue; 2953 2954 /* See if we can rehash to this location. */ 2955 for (srch = (hash + rehash) & (count - 1); 2956 srch != hash && srch != i; 2957 srch = (srch + rehash) & (count - 1)) 2958 BFD_ASSERT (H_GET_32 (abfd, (raw_armap + 8 + srch * 8)) != 0); 2959 BFD_ASSERT (srch == i); 2960 } 2961 } 2962 2963#endif /* CHECK_ARMAP_HASH */ 2964 2965 raw_ptr = raw_armap + 4; 2966 for (i = 0; i < count; i++, raw_ptr += 8) 2967 if (H_GET_32 (abfd, (raw_ptr + 4)) != 0) 2968 ++ardata->symdef_count; 2969 2970 amt = ardata->symdef_count; 2971 amt *= sizeof (carsym); 2972 symdef_ptr = (carsym *) bfd_alloc (abfd, amt); 2973 if (!symdef_ptr) 2974 goto error_exit; 2975 2976 ardata->symdefs = symdef_ptr; 2977 2978 raw_ptr = raw_armap + 4; 2979 for (i = 0; i < count; i++, raw_ptr += 8) 2980 { 2981 unsigned int name_offset, file_offset; 2982 2983 file_offset = H_GET_32 (abfd, (raw_ptr + 4)); 2984 if (file_offset == 0) 2985 continue; 2986 name_offset = H_GET_32 (abfd, raw_ptr); 2987 if (name_offset > stringsize) 2988 goto error_malformed; 2989 symdef_ptr->name = stringbase + name_offset; 2990 symdef_ptr->file_offset = file_offset; 2991 ++symdef_ptr; 2992 } 2993 2994 ardata->first_file_filepos = bfd_tell (abfd); 2995 /* Pad to an even boundary. */ 2996 ardata->first_file_filepos += ardata->first_file_filepos % 2; 2997 abfd->has_armap = true; 2998 return true; 2999 3000 error_malformed: 3001 bfd_set_error (bfd_error_malformed_archive); 3002 error_exit: 3003 ardata->symdef_count = 0; 3004 ardata->symdefs = NULL; 3005 ardata->tdata = NULL; 3006 bfd_release (abfd, raw_armap); 3007 return false; 3008} 3009 3010/* Write out an armap. */ 3011 3012bool 3013_bfd_ecoff_write_armap (bfd *abfd, 3014 unsigned int elength, 3015 struct orl *map, 3016 unsigned int orl_count, 3017 int stridx) 3018{ 3019 unsigned int hashsize, hashlog; 3020 bfd_size_type symdefsize; 3021 int padit; 3022 unsigned int stringsize; 3023 unsigned int mapsize; 3024 file_ptr firstreal; 3025 struct ar_hdr hdr; 3026 struct stat statbuf; 3027 unsigned int i; 3028 bfd_byte temp[4]; 3029 bfd_byte *hashtable; 3030 bfd *current; 3031 bfd *last_elt; 3032 3033 /* Ultrix appears to use as a hash table size the least power of two 3034 greater than twice the number of entries. */ 3035 for (hashlog = 0; ((unsigned int) 1 << hashlog) <= 2 * orl_count; hashlog++) 3036 ; 3037 hashsize = 1 << hashlog; 3038 3039 symdefsize = hashsize * 8; 3040 padit = stridx % 2; 3041 stringsize = stridx + padit; 3042 3043 /* Include 8 bytes to store symdefsize and stringsize in output. */ 3044 mapsize = symdefsize + stringsize + 8; 3045 3046 firstreal = SARMAG + sizeof (struct ar_hdr) + mapsize + elength; 3047 3048 memset ((void *) &hdr, 0, sizeof hdr); 3049 3050 /* Work out the ECOFF armap name. */ 3051 strcpy (hdr.ar_name, ecoff_backend (abfd)->armap_start); 3052 hdr.ar_name[ARMAP_HEADER_MARKER_INDEX] = ARMAP_MARKER; 3053 hdr.ar_name[ARMAP_HEADER_ENDIAN_INDEX] = 3054 (bfd_header_big_endian (abfd) 3055 ? ARMAP_BIG_ENDIAN 3056 : ARMAP_LITTLE_ENDIAN); 3057 hdr.ar_name[ARMAP_OBJECT_MARKER_INDEX] = ARMAP_MARKER; 3058 hdr.ar_name[ARMAP_OBJECT_ENDIAN_INDEX] = 3059 bfd_big_endian (abfd) ? ARMAP_BIG_ENDIAN : ARMAP_LITTLE_ENDIAN; 3060 memcpy (hdr.ar_name + ARMAP_END_INDEX, ARMAP_END, sizeof ARMAP_END - 1); 3061 3062 /* Write the timestamp of the archive header to be just a little bit 3063 later than the timestamp of the file, otherwise the linker will 3064 complain that the index is out of date. Actually, the Ultrix 3065 linker just checks the archive name; the GNU linker may check the 3066 date. */ 3067 stat (bfd_get_filename (abfd), &statbuf); 3068 _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld", 3069 (long) (statbuf.st_mtime + 60)); 3070 3071 /* The DECstation uses zeroes for the uid, gid and mode of the 3072 armap. */ 3073 hdr.ar_uid[0] = '0'; 3074 hdr.ar_gid[0] = '0'; 3075 /* Building gcc ends up extracting the armap as a file - twice. */ 3076 hdr.ar_mode[0] = '6'; 3077 hdr.ar_mode[1] = '4'; 3078 hdr.ar_mode[2] = '4'; 3079 3080 _bfd_ar_spacepad (hdr.ar_size, sizeof (hdr.ar_size), "%-10ld", mapsize); 3081 3082 hdr.ar_fmag[0] = '`'; 3083 hdr.ar_fmag[1] = '\012'; 3084 3085 /* Turn all null bytes in the header into spaces. */ 3086 for (i = 0; i < sizeof (struct ar_hdr); i++) 3087 if (((char *) (&hdr))[i] == '\0') 3088 (((char *) (&hdr))[i]) = ' '; 3089 3090 if (bfd_bwrite ((void *) &hdr, (bfd_size_type) sizeof (struct ar_hdr), abfd) 3091 != sizeof (struct ar_hdr)) 3092 return false; 3093 3094 H_PUT_32 (abfd, hashsize, temp); 3095 if (bfd_bwrite ((void *) temp, (bfd_size_type) 4, abfd) != 4) 3096 return false; 3097 3098 hashtable = (bfd_byte *) bfd_zalloc (abfd, symdefsize); 3099 if (!hashtable) 3100 return false; 3101 3102 current = abfd->archive_head; 3103 last_elt = current; 3104 for (i = 0; i < orl_count; i++) 3105 { 3106 unsigned int hash, rehash = 0; 3107 3108 /* Advance firstreal to the file position of this archive 3109 element. */ 3110 if (map[i].u.abfd != last_elt) 3111 { 3112 do 3113 { 3114 firstreal += arelt_size (current) + sizeof (struct ar_hdr); 3115 firstreal += firstreal % 2; 3116 current = current->archive_next; 3117 } 3118 while (current != map[i].u.abfd); 3119 } 3120 3121 last_elt = current; 3122 3123 hash = ecoff_armap_hash (*map[i].name, &rehash, hashsize, hashlog); 3124 if (H_GET_32 (abfd, (hashtable + (hash * 8) + 4)) != 0) 3125 { 3126 unsigned int srch; 3127 3128 /* The desired slot is already taken. */ 3129 for (srch = (hash + rehash) & (hashsize - 1); 3130 srch != hash; 3131 srch = (srch + rehash) & (hashsize - 1)) 3132 if (H_GET_32 (abfd, (hashtable + (srch * 8) + 4)) == 0) 3133 break; 3134 3135 BFD_ASSERT (srch != hash); 3136 3137 hash = srch; 3138 } 3139 3140 H_PUT_32 (abfd, map[i].namidx, (hashtable + hash * 8)); 3141 H_PUT_32 (abfd, firstreal, (hashtable + hash * 8 + 4)); 3142 } 3143 3144 if (bfd_bwrite ((void *) hashtable, symdefsize, abfd) != symdefsize) 3145 return false; 3146 3147 bfd_release (abfd, hashtable); 3148 3149 /* Now write the strings. */ 3150 H_PUT_32 (abfd, stringsize, temp); 3151 if (bfd_bwrite ((void *) temp, (bfd_size_type) 4, abfd) != 4) 3152 return false; 3153 for (i = 0; i < orl_count; i++) 3154 { 3155 bfd_size_type len; 3156 3157 len = strlen (*map[i].name) + 1; 3158 if (bfd_bwrite ((void *) (*map[i].name), len, abfd) != len) 3159 return false; 3160 } 3161 3162 /* The spec sez this should be a newline. But in order to be 3163 bug-compatible for DECstation ar we use a null. */ 3164 if (padit) 3165 { 3166 if (bfd_bwrite ("", (bfd_size_type) 1, abfd) != 1) 3167 return false; 3168 } 3169 3170 return true; 3171} 3172 3173/* ECOFF linker code. */ 3174 3175/* Routine to create an entry in an ECOFF link hash table. */ 3176 3177static struct bfd_hash_entry * 3178ecoff_link_hash_newfunc (struct bfd_hash_entry *entry, 3179 struct bfd_hash_table *table, 3180 const char *string) 3181{ 3182 struct ecoff_link_hash_entry *ret = (struct ecoff_link_hash_entry *) entry; 3183 3184 /* Allocate the structure if it has not already been allocated by a 3185 subclass. */ 3186 if (ret == NULL) 3187 ret = ((struct ecoff_link_hash_entry *) 3188 bfd_hash_allocate (table, sizeof (struct ecoff_link_hash_entry))); 3189 if (ret == NULL) 3190 return NULL; 3191 3192 /* Call the allocation method of the superclass. */ 3193 ret = ((struct ecoff_link_hash_entry *) 3194 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret, 3195 table, string)); 3196 3197 if (ret) 3198 { 3199 /* Set local fields. */ 3200 ret->indx = -1; 3201 ret->abfd = NULL; 3202 ret->written = 0; 3203 ret->small = 0; 3204 } 3205 memset ((void *) &ret->esym, 0, sizeof ret->esym); 3206 3207 return (struct bfd_hash_entry *) ret; 3208} 3209 3210/* Create an ECOFF link hash table. */ 3211 3212struct bfd_link_hash_table * 3213_bfd_ecoff_bfd_link_hash_table_create (bfd *abfd) 3214{ 3215 struct ecoff_link_hash_table *ret; 3216 size_t amt = sizeof (struct ecoff_link_hash_table); 3217 3218 ret = (struct ecoff_link_hash_table *) bfd_malloc (amt); 3219 if (ret == NULL) 3220 return NULL; 3221 if (!_bfd_link_hash_table_init (&ret->root, abfd, 3222 ecoff_link_hash_newfunc, 3223 sizeof (struct ecoff_link_hash_entry))) 3224 { 3225 free (ret); 3226 return NULL; 3227 } 3228 return &ret->root; 3229} 3230 3231/* Look up an entry in an ECOFF link hash table. */ 3232 3233#define ecoff_link_hash_lookup(table, string, create, copy, follow) \ 3234 ((struct ecoff_link_hash_entry *) \ 3235 bfd_link_hash_lookup (&(table)->root, (string), (create), (copy), (follow))) 3236 3237/* Get the ECOFF link hash table from the info structure. This is 3238 just a cast. */ 3239 3240#define ecoff_hash_table(p) ((struct ecoff_link_hash_table *) ((p)->hash)) 3241 3242/* Add the external symbols of an object file to the global linker 3243 hash table. The external symbols and strings we are passed are 3244 just allocated on the stack, and will be discarded. We must 3245 explicitly save any information we may need later on in the link. 3246 We do not want to read the external symbol information again. */ 3247 3248static bool 3249ecoff_link_add_externals (bfd *abfd, 3250 struct bfd_link_info *info, 3251 void * external_ext, 3252 char *ssext) 3253{ 3254 const struct ecoff_backend_data * const backend = ecoff_backend (abfd); 3255 void (* const swap_ext_in) (bfd *, void *, EXTR *) 3256 = backend->debug_swap.swap_ext_in; 3257 bfd_size_type external_ext_size = backend->debug_swap.external_ext_size; 3258 unsigned long ext_count; 3259 struct bfd_link_hash_entry **sym_hash; 3260 char *ext_ptr; 3261 char *ext_end; 3262 bfd_size_type amt; 3263 3264 ext_count = ecoff_data (abfd)->debug_info.symbolic_header.iextMax; 3265 3266 amt = ext_count; 3267 amt *= sizeof (struct bfd_link_hash_entry *); 3268 sym_hash = (struct bfd_link_hash_entry **) bfd_alloc (abfd, amt); 3269 if (!sym_hash) 3270 return false; 3271 ecoff_data (abfd)->sym_hashes = (struct ecoff_link_hash_entry **) sym_hash; 3272 3273 ext_ptr = (char *) external_ext; 3274 ext_end = ext_ptr + ext_count * external_ext_size; 3275 for (; ext_ptr < ext_end; ext_ptr += external_ext_size, sym_hash++) 3276 { 3277 EXTR esym; 3278 bool skip; 3279 bfd_vma value; 3280 asection *section; 3281 const char *name; 3282 struct ecoff_link_hash_entry *h; 3283 3284 *sym_hash = NULL; 3285 3286 (*swap_ext_in) (abfd, (void *) ext_ptr, &esym); 3287 3288 /* Skip debugging symbols. */ 3289 skip = false; 3290 switch (esym.asym.st) 3291 { 3292 case stGlobal: 3293 case stStatic: 3294 case stLabel: 3295 case stProc: 3296 case stStaticProc: 3297 break; 3298 default: 3299 skip = true; 3300 break; 3301 } 3302 3303 if (skip) 3304 continue; 3305 3306 /* Get the information for this symbol. */ 3307 value = esym.asym.value; 3308 switch (esym.asym.sc) 3309 { 3310 default: 3311 case scNil: 3312 case scRegister: 3313 case scCdbLocal: 3314 case scBits: 3315 case scCdbSystem: 3316 case scRegImage: 3317 case scInfo: 3318 case scUserStruct: 3319 case scVar: 3320 case scVarRegister: 3321 case scVariant: 3322 case scBasedVar: 3323 case scXData: 3324 case scPData: 3325 section = NULL; 3326 break; 3327 case scText: 3328 section = bfd_make_section_old_way (abfd, _TEXT); 3329 value -= section->vma; 3330 break; 3331 case scData: 3332 section = bfd_make_section_old_way (abfd, _DATA); 3333 value -= section->vma; 3334 break; 3335 case scBss: 3336 section = bfd_make_section_old_way (abfd, _BSS); 3337 value -= section->vma; 3338 break; 3339 case scAbs: 3340 section = bfd_abs_section_ptr; 3341 break; 3342 case scUndefined: 3343 section = bfd_und_section_ptr; 3344 break; 3345 case scSData: 3346 section = bfd_make_section_old_way (abfd, _SDATA); 3347 value -= section->vma; 3348 break; 3349 case scSBss: 3350 section = bfd_make_section_old_way (abfd, _SBSS); 3351 value -= section->vma; 3352 break; 3353 case scRData: 3354 section = bfd_make_section_old_way (abfd, _RDATA); 3355 value -= section->vma; 3356 break; 3357 case scCommon: 3358 if (value > ecoff_data (abfd)->gp_size) 3359 { 3360 section = bfd_com_section_ptr; 3361 break; 3362 } 3363 /* Fall through. */ 3364 case scSCommon: 3365 section = &ecoff_scom_section; 3366 break; 3367 case scSUndefined: 3368 section = bfd_und_section_ptr; 3369 break; 3370 case scInit: 3371 section = bfd_make_section_old_way (abfd, _INIT); 3372 value -= section->vma; 3373 break; 3374 case scFini: 3375 section = bfd_make_section_old_way (abfd, _FINI); 3376 value -= section->vma; 3377 break; 3378 case scRConst: 3379 section = bfd_make_section_old_way (abfd, _RCONST); 3380 value -= section->vma; 3381 break; 3382 } 3383 3384 if (section == NULL) 3385 continue; 3386 3387 name = ssext + esym.asym.iss; 3388 3389 if (! (_bfd_generic_link_add_one_symbol 3390 (info, abfd, name, 3391 (flagword) (esym.weakext ? BSF_WEAK : BSF_GLOBAL), 3392 section, value, NULL, true, true, sym_hash))) 3393 return false; 3394 3395 h = (struct ecoff_link_hash_entry *) *sym_hash; 3396 3397 /* If we are building an ECOFF hash table, save the external 3398 symbol information. */ 3399 if (bfd_get_flavour (info->output_bfd) == bfd_get_flavour (abfd)) 3400 { 3401 if (h->abfd == NULL 3402 || (! bfd_is_und_section (section) 3403 && (! bfd_is_com_section (section) 3404 || (h->root.type != bfd_link_hash_defined 3405 && h->root.type != bfd_link_hash_defweak)))) 3406 { 3407 h->abfd = abfd; 3408 h->esym = esym; 3409 } 3410 3411 /* Remember whether this symbol was small undefined. */ 3412 if (esym.asym.sc == scSUndefined) 3413 h->small = 1; 3414 3415 /* If this symbol was ever small undefined, it needs to wind 3416 up in a GP relative section. We can't control the 3417 section of a defined symbol, but we can control the 3418 section of a common symbol. This case is actually needed 3419 on Ultrix 4.2 to handle the symbol cred in -lckrb. */ 3420 if (h->small 3421 && h->root.type == bfd_link_hash_common 3422 && streq (h->root.u.c.p->section->name, SCOMMON)) 3423 { 3424 h->root.u.c.p->section = bfd_make_section_old_way (abfd, 3425 SCOMMON); 3426 h->root.u.c.p->section->flags = SEC_ALLOC; 3427 if (h->esym.asym.sc == scCommon) 3428 h->esym.asym.sc = scSCommon; 3429 } 3430 } 3431 } 3432 3433 return true; 3434} 3435 3436/* Add symbols from an ECOFF object file to the global linker hash 3437 table. */ 3438 3439static bool 3440ecoff_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info) 3441{ 3442 HDRR *symhdr; 3443 bfd_size_type external_ext_size; 3444 void * external_ext = NULL; 3445 bfd_size_type esize; 3446 char *ssext = NULL; 3447 bool result; 3448 3449 if (! ecoff_slurp_symbolic_header (abfd)) 3450 return false; 3451 3452 /* If there are no symbols, we don't want it. */ 3453 if (bfd_get_symcount (abfd) == 0) 3454 return true; 3455 3456 symhdr = &ecoff_data (abfd)->debug_info.symbolic_header; 3457 3458 /* Read in the external symbols and external strings. */ 3459 if (bfd_seek (abfd, symhdr->cbExtOffset, SEEK_SET) != 0) 3460 return false; 3461 external_ext_size = ecoff_backend (abfd)->debug_swap.external_ext_size; 3462 esize = symhdr->iextMax * external_ext_size; 3463 external_ext = _bfd_malloc_and_read (abfd, esize, esize); 3464 if (external_ext == NULL && esize != 0) 3465 goto error_return; 3466 3467 if (bfd_seek (abfd, symhdr->cbSsExtOffset, SEEK_SET) != 0) 3468 goto error_return; 3469 ssext = (char *) _bfd_malloc_and_read (abfd, symhdr->issExtMax, 3470 symhdr->issExtMax); 3471 if (ssext == NULL && symhdr->issExtMax != 0) 3472 goto error_return; 3473 3474 result = ecoff_link_add_externals (abfd, info, external_ext, ssext); 3475 3476 free (ssext); 3477 free (external_ext); 3478 return result; 3479 3480 error_return: 3481 free (ssext); 3482 free (external_ext); 3483 return false; 3484} 3485 3486/* This is called if we used _bfd_generic_link_add_archive_symbols 3487 because we were not dealing with an ECOFF archive. */ 3488 3489static bool 3490ecoff_link_check_archive_element (bfd *abfd, 3491 struct bfd_link_info *info, 3492 struct bfd_link_hash_entry *h, 3493 const char *name, 3494 bool *pneeded) 3495{ 3496 *pneeded = false; 3497 3498 /* Unlike the generic linker, we do not pull in elements because 3499 of common symbols. */ 3500 if (h->type != bfd_link_hash_undefined) 3501 return true; 3502 3503 /* Include this element? */ 3504 if (!(*info->callbacks->add_archive_element) (info, abfd, name, &abfd)) 3505 return true; 3506 *pneeded = true; 3507 3508 return ecoff_link_add_object_symbols (abfd, info); 3509} 3510 3511/* Add the symbols from an archive file to the global hash table. 3512 This looks through the undefined symbols, looks each one up in the 3513 archive hash table, and adds any associated object file. We do not 3514 use _bfd_generic_link_add_archive_symbols because ECOFF archives 3515 already have a hash table, so there is no reason to construct 3516 another one. */ 3517 3518static bool 3519ecoff_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info) 3520{ 3521 const struct ecoff_backend_data * const backend = ecoff_backend (abfd); 3522 const bfd_byte *raw_armap; 3523 struct bfd_link_hash_entry **pundef; 3524 unsigned int armap_count; 3525 unsigned int armap_log; 3526 unsigned int i; 3527 const bfd_byte *hashtable; 3528 const char *stringbase; 3529 3530 if (! bfd_has_map (abfd)) 3531 { 3532 /* An empty archive is a special case. */ 3533 if (bfd_openr_next_archived_file (abfd, NULL) == NULL) 3534 return true; 3535 bfd_set_error (bfd_error_no_armap); 3536 return false; 3537 } 3538 3539 /* If we don't have any raw data for this archive, as can happen on 3540 Irix 4.0.5F, we call the generic routine. 3541 FIXME: We should be more clever about this, since someday tdata 3542 may get to something for a generic archive. */ 3543 raw_armap = (const bfd_byte *) bfd_ardata (abfd)->tdata; 3544 if (raw_armap == NULL) 3545 return (_bfd_generic_link_add_archive_symbols 3546 (abfd, info, ecoff_link_check_archive_element)); 3547 3548 armap_count = H_GET_32 (abfd, raw_armap); 3549 3550 armap_log = 0; 3551 for (i = 1; i < armap_count; i <<= 1) 3552 armap_log++; 3553 BFD_ASSERT (i == armap_count); 3554 3555 hashtable = raw_armap + 4; 3556 stringbase = (const char *) raw_armap + armap_count * 8 + 8; 3557 3558 /* Look through the list of undefined symbols. */ 3559 pundef = &info->hash->undefs; 3560 while (*pundef != NULL) 3561 { 3562 struct bfd_link_hash_entry *h; 3563 unsigned int hash, rehash = 0; 3564 unsigned int file_offset; 3565 const char *name; 3566 bfd *element; 3567 3568 h = *pundef; 3569 3570 /* When a symbol is defined, it is not necessarily removed from 3571 the list. */ 3572 if (h->type != bfd_link_hash_undefined 3573 && h->type != bfd_link_hash_common) 3574 { 3575 /* Remove this entry from the list, for general cleanliness 3576 and because we are going to look through the list again 3577 if we search any more libraries. We can't remove the 3578 entry if it is the tail, because that would lose any 3579 entries we add to the list later on. */ 3580 if (*pundef != info->hash->undefs_tail) 3581 *pundef = (*pundef)->u.undef.next; 3582 else 3583 pundef = &(*pundef)->u.undef.next; 3584 continue; 3585 } 3586 3587 /* Native ECOFF linkers do not pull in archive elements merely 3588 to satisfy common definitions, so neither do we. We leave 3589 them on the list, though, in case we are linking against some 3590 other object format. */ 3591 if (h->type != bfd_link_hash_undefined) 3592 { 3593 pundef = &(*pundef)->u.undef.next; 3594 continue; 3595 } 3596 3597 /* Look for this symbol in the archive hash table. */ 3598 hash = ecoff_armap_hash (h->root.string, &rehash, armap_count, 3599 armap_log); 3600 3601 file_offset = H_GET_32 (abfd, hashtable + (hash * 8) + 4); 3602 if (file_offset == 0) 3603 { 3604 /* Nothing in this slot. */ 3605 pundef = &(*pundef)->u.undef.next; 3606 continue; 3607 } 3608 3609 name = stringbase + H_GET_32 (abfd, hashtable + (hash * 8)); 3610 if (name[0] != h->root.string[0] 3611 || ! streq (name, h->root.string)) 3612 { 3613 unsigned int srch; 3614 bool found; 3615 3616 /* That was the wrong symbol. Try rehashing. */ 3617 found = false; 3618 for (srch = (hash + rehash) & (armap_count - 1); 3619 srch != hash; 3620 srch = (srch + rehash) & (armap_count - 1)) 3621 { 3622 file_offset = H_GET_32 (abfd, hashtable + (srch * 8) + 4); 3623 if (file_offset == 0) 3624 break; 3625 name = stringbase + H_GET_32 (abfd, hashtable + (srch * 8)); 3626 if (name[0] == h->root.string[0] 3627 && streq (name, h->root.string)) 3628 { 3629 found = true; 3630 break; 3631 } 3632 } 3633 3634 if (! found) 3635 { 3636 pundef = &(*pundef)->u.undef.next; 3637 continue; 3638 } 3639 3640 hash = srch; 3641 } 3642 3643 element = (*backend->get_elt_at_filepos) (abfd, 3644 (file_ptr) file_offset, 3645 info); 3646 if (element == NULL) 3647 return false; 3648 3649 if (! bfd_check_format (element, bfd_object)) 3650 return false; 3651 3652 /* Unlike the generic linker, we know that this element provides 3653 a definition for an undefined symbol and we know that we want 3654 to include it. We don't need to check anything. */ 3655 if (!(*info->callbacks 3656 ->add_archive_element) (info, element, name, &element)) 3657 return false; 3658 if (! ecoff_link_add_object_symbols (element, info)) 3659 return false; 3660 3661 pundef = &(*pundef)->u.undef.next; 3662 } 3663 3664 return true; 3665} 3666 3667/* Given an ECOFF BFD, add symbols to the global hash table as 3668 appropriate. */ 3669 3670bool 3671_bfd_ecoff_bfd_link_add_symbols (bfd *abfd, struct bfd_link_info *info) 3672{ 3673 switch (bfd_get_format (abfd)) 3674 { 3675 case bfd_object: 3676 return ecoff_link_add_object_symbols (abfd, info); 3677 case bfd_archive: 3678 return ecoff_link_add_archive_symbols (abfd, info); 3679 default: 3680 bfd_set_error (bfd_error_wrong_format); 3681 return false; 3682 } 3683} 3684 3685 3686/* ECOFF final link routines. */ 3687 3688/* Structure used to pass information to ecoff_link_write_external. */ 3689 3690struct extsym_info 3691{ 3692 bfd *abfd; 3693 struct bfd_link_info *info; 3694}; 3695 3696/* Accumulate the debugging information for an input BFD into the 3697 output BFD. This must read in the symbolic information of the 3698 input BFD. */ 3699 3700static bool 3701ecoff_final_link_debug_accumulate (bfd *output_bfd, 3702 bfd *input_bfd, 3703 struct bfd_link_info *info, 3704 void * handle) 3705{ 3706 struct ecoff_debug_info * const debug = &ecoff_data (input_bfd)->debug_info; 3707 const struct ecoff_debug_swap * const swap = 3708 &ecoff_backend (input_bfd)->debug_swap; 3709 HDRR *symhdr = &debug->symbolic_header; 3710 bool ret; 3711 3712#define READ(ptr, offset, count, size, type) \ 3713 do \ 3714 { \ 3715 size_t amt; \ 3716 debug->ptr = NULL; \ 3717 if (symhdr->count == 0) \ 3718 break; \ 3719 if (_bfd_mul_overflow (size, symhdr->count, &amt)) \ 3720 { \ 3721 bfd_set_error (bfd_error_file_too_big); \ 3722 ret = false; \ 3723 goto return_something; \ 3724 } \ 3725 if (bfd_seek (input_bfd, symhdr->offset, SEEK_SET) != 0) \ 3726 { \ 3727 ret = false; \ 3728 goto return_something; \ 3729 } \ 3730 debug->ptr = (type) _bfd_malloc_and_read (input_bfd, amt, amt); \ 3731 if (debug->ptr == NULL) \ 3732 { \ 3733 ret = false; \ 3734 goto return_something; \ 3735 } \ 3736 } while (0) 3737 3738 /* If raw_syments is not NULL, then the data was already by read by 3739 _bfd_ecoff_slurp_symbolic_info. */ 3740 if (ecoff_data (input_bfd)->raw_syments == NULL) 3741 { 3742 READ (line, cbLineOffset, cbLine, sizeof (unsigned char), 3743 unsigned char *); 3744 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, void *); 3745 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, void *); 3746 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, void *); 3747 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, void *); 3748 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext), 3749 union aux_ext *); 3750 READ (ss, cbSsOffset, issMax, sizeof (char), char *); 3751 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, void *); 3752 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, void *); 3753 } 3754#undef READ 3755 3756 /* We do not read the external strings or the external symbols. */ 3757 3758 ret = (bfd_ecoff_debug_accumulate 3759 (handle, output_bfd, &ecoff_data (output_bfd)->debug_info, 3760 &ecoff_backend (output_bfd)->debug_swap, 3761 input_bfd, debug, swap, info)); 3762 3763 return_something: 3764 if (ecoff_data (input_bfd)->raw_syments == NULL) 3765 { 3766 free (debug->line); 3767 free (debug->external_dnr); 3768 free (debug->external_pdr); 3769 free (debug->external_sym); 3770 free (debug->external_opt); 3771 free (debug->external_aux); 3772 free (debug->ss); 3773 free (debug->external_fdr); 3774 free (debug->external_rfd); 3775 3776 /* Make sure we don't accidentally follow one of these pointers 3777 into freed memory. */ 3778 debug->line = NULL; 3779 debug->external_dnr = NULL; 3780 debug->external_pdr = NULL; 3781 debug->external_sym = NULL; 3782 debug->external_opt = NULL; 3783 debug->external_aux = NULL; 3784 debug->ss = NULL; 3785 debug->external_fdr = NULL; 3786 debug->external_rfd = NULL; 3787 } 3788 3789 return ret; 3790} 3791 3792/* Relocate and write an ECOFF section into an ECOFF output file. */ 3793 3794static bool 3795ecoff_indirect_link_order (bfd *output_bfd, 3796 struct bfd_link_info *info, 3797 asection *output_section, 3798 struct bfd_link_order *link_order) 3799{ 3800 asection *input_section; 3801 bfd *input_bfd; 3802 bfd_byte *contents = NULL; 3803 bfd_size_type external_reloc_size; 3804 bfd_size_type external_relocs_size; 3805 void * external_relocs = NULL; 3806 3807 BFD_ASSERT ((output_section->flags & SEC_HAS_CONTENTS) != 0); 3808 3809 input_section = link_order->u.indirect.section; 3810 input_bfd = input_section->owner; 3811 if (input_section->size == 0) 3812 return true; 3813 3814 BFD_ASSERT (input_section->output_section == output_section); 3815 BFD_ASSERT (input_section->output_offset == link_order->offset); 3816 BFD_ASSERT (input_section->size == link_order->size); 3817 3818 /* Get the section contents. */ 3819 if (!bfd_malloc_and_get_section (input_bfd, input_section, &contents)) 3820 goto error_return; 3821 3822 /* Get the relocs. If we are relaxing MIPS code, they will already 3823 have been read in. Otherwise, we read them in now. */ 3824 external_reloc_size = ecoff_backend (input_bfd)->external_reloc_size; 3825 external_relocs_size = external_reloc_size * input_section->reloc_count; 3826 3827 if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0) 3828 goto error_return; 3829 external_relocs = _bfd_malloc_and_read (input_bfd, external_relocs_size, 3830 external_relocs_size); 3831 if (external_relocs == NULL && external_relocs_size != 0) 3832 goto error_return; 3833 3834 /* Relocate the section contents. */ 3835 if (! ((*ecoff_backend (input_bfd)->relocate_section) 3836 (output_bfd, info, input_bfd, input_section, contents, 3837 external_relocs))) 3838 goto error_return; 3839 3840 /* Write out the relocated section. */ 3841 if (! bfd_set_section_contents (output_bfd, 3842 output_section, 3843 contents, 3844 input_section->output_offset, 3845 input_section->size)) 3846 goto error_return; 3847 3848 /* If we are producing relocatable output, the relocs were 3849 modified, and we write them out now. We use the reloc_count 3850 field of output_section to keep track of the number of relocs we 3851 have output so far. */ 3852 if (bfd_link_relocatable (info)) 3853 { 3854 file_ptr pos = (output_section->rel_filepos 3855 + output_section->reloc_count * external_reloc_size); 3856 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0 3857 || (bfd_bwrite (external_relocs, external_relocs_size, output_bfd) 3858 != external_relocs_size)) 3859 goto error_return; 3860 output_section->reloc_count += input_section->reloc_count; 3861 } 3862 3863 free (contents); 3864 free (external_relocs); 3865 return true; 3866 3867 error_return: 3868 free (contents); 3869 free (external_relocs); 3870 return false; 3871} 3872 3873/* Generate a reloc when linking an ECOFF file. This is a reloc 3874 requested by the linker, and does come from any input file. This 3875 is used to build constructor and destructor tables when linking 3876 with -Ur. */ 3877 3878static bool 3879ecoff_reloc_link_order (bfd *output_bfd, 3880 struct bfd_link_info *info, 3881 asection *output_section, 3882 struct bfd_link_order *link_order) 3883{ 3884 enum bfd_link_order_type type; 3885 asection *section; 3886 bfd_vma addend; 3887 arelent rel; 3888 struct internal_reloc in; 3889 bfd_size_type external_reloc_size; 3890 bfd_byte *rbuf; 3891 bool ok; 3892 file_ptr pos; 3893 3894 type = link_order->type; 3895 section = NULL; 3896 addend = link_order->u.reloc.p->addend; 3897 3898 /* We set up an arelent to pass to the backend adjust_reloc_out 3899 routine. */ 3900 rel.address = link_order->offset; 3901 3902 rel.howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc); 3903 if (rel.howto == 0) 3904 { 3905 bfd_set_error (bfd_error_bad_value); 3906 return false; 3907 } 3908 3909 if (type == bfd_section_reloc_link_order) 3910 { 3911 section = link_order->u.reloc.p->u.section; 3912 rel.sym_ptr_ptr = section->symbol_ptr_ptr; 3913 } 3914 else 3915 { 3916 struct bfd_link_hash_entry *h; 3917 3918 /* Treat a reloc against a defined symbol as though it were 3919 actually against the section. */ 3920 h = bfd_wrapped_link_hash_lookup (output_bfd, info, 3921 link_order->u.reloc.p->u.name, 3922 false, false, false); 3923 if (h != NULL 3924 && (h->type == bfd_link_hash_defined 3925 || h->type == bfd_link_hash_defweak)) 3926 { 3927 type = bfd_section_reloc_link_order; 3928 section = h->u.def.section->output_section; 3929 /* It seems that we ought to add the symbol value to the 3930 addend here, but in practice it has already been added 3931 because it was passed to constructor_callback. */ 3932 addend += section->vma + h->u.def.section->output_offset; 3933 } 3934 else 3935 { 3936 /* We can't set up a reloc against a symbol correctly, 3937 because we have no asymbol structure. Currently no 3938 adjust_reloc_out routine cares. */ 3939 rel.sym_ptr_ptr = NULL; 3940 } 3941 } 3942 3943 /* All ECOFF relocs are in-place. Put the addend into the object 3944 file. */ 3945 3946 BFD_ASSERT (rel.howto->partial_inplace); 3947 if (addend != 0) 3948 { 3949 bfd_size_type size; 3950 bfd_reloc_status_type rstat; 3951 bfd_byte *buf; 3952 3953 size = bfd_get_reloc_size (rel.howto); 3954 buf = (bfd_byte *) bfd_zmalloc (size); 3955 if (buf == NULL && size != 0) 3956 return false; 3957 rstat = _bfd_relocate_contents (rel.howto, output_bfd, 3958 (bfd_vma) addend, buf); 3959 switch (rstat) 3960 { 3961 case bfd_reloc_ok: 3962 break; 3963 default: 3964 case bfd_reloc_outofrange: 3965 abort (); 3966 case bfd_reloc_overflow: 3967 (*info->callbacks->reloc_overflow) 3968 (info, NULL, 3969 (link_order->type == bfd_section_reloc_link_order 3970 ? bfd_section_name (section) 3971 : link_order->u.reloc.p->u.name), 3972 rel.howto->name, addend, NULL, NULL, (bfd_vma) 0); 3973 break; 3974 } 3975 ok = bfd_set_section_contents (output_bfd, output_section, (void *) buf, 3976 (file_ptr) link_order->offset, size); 3977 free (buf); 3978 if (! ok) 3979 return false; 3980 } 3981 3982 rel.addend = 0; 3983 3984 /* Move the information into an internal_reloc structure. */ 3985 in.r_vaddr = rel.address + bfd_section_vma (output_section); 3986 in.r_type = rel.howto->type; 3987 3988 if (type == bfd_symbol_reloc_link_order) 3989 { 3990 struct ecoff_link_hash_entry *h; 3991 3992 h = ((struct ecoff_link_hash_entry *) 3993 bfd_wrapped_link_hash_lookup (output_bfd, info, 3994 link_order->u.reloc.p->u.name, 3995 false, false, true)); 3996 if (h != NULL 3997 && h->indx != -1) 3998 in.r_symndx = h->indx; 3999 else 4000 { 4001 (*info->callbacks->unattached_reloc) 4002 (info, link_order->u.reloc.p->u.name, NULL, NULL, (bfd_vma) 0); 4003 in.r_symndx = 0; 4004 } 4005 in.r_extern = 1; 4006 } 4007 else 4008 { 4009 const char *name; 4010 unsigned int i; 4011 static struct 4012 { 4013 const char * name; 4014 long r_symndx; 4015 } 4016 section_symndx [] = 4017 { 4018 { _TEXT, RELOC_SECTION_TEXT }, 4019 { _RDATA, RELOC_SECTION_RDATA }, 4020 { _DATA, RELOC_SECTION_DATA }, 4021 { _SDATA, RELOC_SECTION_SDATA }, 4022 { _SBSS, RELOC_SECTION_SBSS }, 4023 { _BSS, RELOC_SECTION_BSS }, 4024 { _INIT, RELOC_SECTION_INIT }, 4025 { _LIT8, RELOC_SECTION_LIT8 }, 4026 { _LIT4, RELOC_SECTION_LIT4 }, 4027 { _XDATA, RELOC_SECTION_XDATA }, 4028 { _PDATA, RELOC_SECTION_PDATA }, 4029 { _FINI, RELOC_SECTION_FINI }, 4030 { _LITA, RELOC_SECTION_LITA }, 4031 { "*ABS*", RELOC_SECTION_ABS }, 4032 { _RCONST, RELOC_SECTION_RCONST } 4033 }; 4034 4035 name = bfd_section_name (section); 4036 4037 for (i = 0; i < ARRAY_SIZE (section_symndx); i++) 4038 if (streq (name, section_symndx[i].name)) 4039 { 4040 in.r_symndx = section_symndx[i].r_symndx; 4041 break; 4042 } 4043 4044 if (i == ARRAY_SIZE (section_symndx)) 4045 abort (); 4046 4047 in.r_extern = 0; 4048 } 4049 4050 /* Let the BFD backend adjust the reloc. */ 4051 (*ecoff_backend (output_bfd)->adjust_reloc_out) (output_bfd, &rel, &in); 4052 4053 /* Get some memory and swap out the reloc. */ 4054 external_reloc_size = ecoff_backend (output_bfd)->external_reloc_size; 4055 rbuf = (bfd_byte *) bfd_malloc (external_reloc_size); 4056 if (rbuf == NULL) 4057 return false; 4058 4059 (*ecoff_backend (output_bfd)->swap_reloc_out) (output_bfd, &in, (void *) rbuf); 4060 4061 pos = (output_section->rel_filepos 4062 + output_section->reloc_count * external_reloc_size); 4063 ok = (bfd_seek (output_bfd, pos, SEEK_SET) == 0 4064 && (bfd_bwrite ((void *) rbuf, external_reloc_size, output_bfd) 4065 == external_reloc_size)); 4066 4067 if (ok) 4068 ++output_section->reloc_count; 4069 4070 free (rbuf); 4071 4072 return ok; 4073} 4074 4075/* Put out information for an external symbol. These come only from 4076 the hash table. */ 4077 4078static bool 4079ecoff_link_write_external (struct bfd_hash_entry *bh, void * data) 4080{ 4081 struct ecoff_link_hash_entry *h = (struct ecoff_link_hash_entry *) bh; 4082 struct extsym_info *einfo = (struct extsym_info *) data; 4083 bfd *output_bfd = einfo->abfd; 4084 bool strip; 4085 4086 if (h->root.type == bfd_link_hash_warning) 4087 { 4088 h = (struct ecoff_link_hash_entry *) h->root.u.i.link; 4089 if (h->root.type == bfd_link_hash_new) 4090 return true; 4091 } 4092 4093 /* We need to check if this symbol is being stripped. */ 4094 if (h->root.type == bfd_link_hash_undefined 4095 || h->root.type == bfd_link_hash_undefweak) 4096 strip = false; 4097 else if (einfo->info->strip == strip_all 4098 || (einfo->info->strip == strip_some 4099 && bfd_hash_lookup (einfo->info->keep_hash, 4100 h->root.root.string, 4101 false, false) == NULL)) 4102 strip = true; 4103 else 4104 strip = false; 4105 4106 if (strip || h->written) 4107 return true; 4108 4109 if (h->abfd == NULL) 4110 { 4111 h->esym.jmptbl = 0; 4112 h->esym.cobol_main = 0; 4113 h->esym.weakext = 0; 4114 h->esym.reserved = 0; 4115 h->esym.ifd = ifdNil; 4116 h->esym.asym.value = 0; 4117 h->esym.asym.st = stGlobal; 4118 4119 if (h->root.type != bfd_link_hash_defined 4120 && h->root.type != bfd_link_hash_defweak) 4121 h->esym.asym.sc = scAbs; 4122 else 4123 { 4124 asection *output_section; 4125 const char *name; 4126 unsigned int i; 4127 static struct 4128 { 4129 const char * name; 4130 int sc; 4131 } 4132 section_storage_classes [] = 4133 { 4134 { _TEXT, scText }, 4135 { _DATA, scData }, 4136 { _SDATA, scSData }, 4137 { _RDATA, scRData }, 4138 { _BSS, scBss }, 4139 { _SBSS, scSBss }, 4140 { _INIT, scInit }, 4141 { _FINI, scFini }, 4142 { _PDATA, scPData }, 4143 { _XDATA, scXData }, 4144 { _RCONST, scRConst } 4145 }; 4146 4147 output_section = h->root.u.def.section->output_section; 4148 name = bfd_section_name (output_section); 4149 4150 for (i = 0; i < ARRAY_SIZE (section_storage_classes); i++) 4151 if (streq (name, section_storage_classes[i].name)) 4152 { 4153 h->esym.asym.sc = section_storage_classes[i].sc; 4154 break; 4155 } 4156 4157 if (i == ARRAY_SIZE (section_storage_classes)) 4158 h->esym.asym.sc = scAbs; 4159 } 4160 4161 h->esym.asym.reserved = 0; 4162 h->esym.asym.index = indexNil; 4163 } 4164 else if (h->esym.ifd != -1) 4165 { 4166 struct ecoff_debug_info *debug; 4167 4168 /* Adjust the FDR index for the symbol by that used for the 4169 input BFD. */ 4170 debug = &ecoff_data (h->abfd)->debug_info; 4171 BFD_ASSERT (h->esym.ifd >= 0 4172 && h->esym.ifd < debug->symbolic_header.ifdMax); 4173 h->esym.ifd = debug->ifdmap[h->esym.ifd]; 4174 } 4175 4176 switch (h->root.type) 4177 { 4178 default: 4179 case bfd_link_hash_warning: 4180 case bfd_link_hash_new: 4181 abort (); 4182 case bfd_link_hash_undefined: 4183 case bfd_link_hash_undefweak: 4184 if (h->esym.asym.sc != scUndefined 4185 && h->esym.asym.sc != scSUndefined) 4186 h->esym.asym.sc = scUndefined; 4187 break; 4188 case bfd_link_hash_defined: 4189 case bfd_link_hash_defweak: 4190 if (h->esym.asym.sc == scUndefined 4191 || h->esym.asym.sc == scSUndefined) 4192 h->esym.asym.sc = scAbs; 4193 else if (h->esym.asym.sc == scCommon) 4194 h->esym.asym.sc = scBss; 4195 else if (h->esym.asym.sc == scSCommon) 4196 h->esym.asym.sc = scSBss; 4197 h->esym.asym.value = (h->root.u.def.value 4198 + h->root.u.def.section->output_section->vma 4199 + h->root.u.def.section->output_offset); 4200 break; 4201 case bfd_link_hash_common: 4202 if (h->esym.asym.sc != scCommon 4203 && h->esym.asym.sc != scSCommon) 4204 h->esym.asym.sc = scCommon; 4205 h->esym.asym.value = h->root.u.c.size; 4206 break; 4207 case bfd_link_hash_indirect: 4208 /* We ignore these symbols, since the indirected symbol is 4209 already in the hash table. */ 4210 return true; 4211 } 4212 4213 /* bfd_ecoff_debug_one_external uses iextMax to keep track of the 4214 symbol number. */ 4215 h->indx = ecoff_data (output_bfd)->debug_info.symbolic_header.iextMax; 4216 h->written = 1; 4217 4218 return (bfd_ecoff_debug_one_external 4219 (output_bfd, &ecoff_data (output_bfd)->debug_info, 4220 &ecoff_backend (output_bfd)->debug_swap, h->root.root.string, 4221 &h->esym)); 4222} 4223 4224/* ECOFF final link routine. This looks through all the input BFDs 4225 and gathers together all the debugging information, and then 4226 processes all the link order information. This may cause it to 4227 close and reopen some input BFDs; I'll see how bad this is. */ 4228 4229bool 4230_bfd_ecoff_bfd_final_link (bfd *abfd, struct bfd_link_info *info) 4231{ 4232 const struct ecoff_backend_data * const backend = ecoff_backend (abfd); 4233 struct ecoff_debug_info * const debug = &ecoff_data (abfd)->debug_info; 4234 HDRR *symhdr; 4235 void * handle; 4236 bfd *input_bfd; 4237 asection *o; 4238 struct bfd_link_order *p; 4239 struct extsym_info einfo; 4240 4241 /* We accumulate the debugging information counts in the symbolic 4242 header. */ 4243 symhdr = &debug->symbolic_header; 4244 symhdr->vstamp = 0; 4245 symhdr->ilineMax = 0; 4246 symhdr->cbLine = 0; 4247 symhdr->idnMax = 0; 4248 symhdr->ipdMax = 0; 4249 symhdr->isymMax = 0; 4250 symhdr->ioptMax = 0; 4251 symhdr->iauxMax = 0; 4252 symhdr->issMax = 0; 4253 symhdr->issExtMax = 0; 4254 symhdr->ifdMax = 0; 4255 symhdr->crfd = 0; 4256 symhdr->iextMax = 0; 4257 4258 /* We accumulate the debugging information itself in the debug_info 4259 structure. */ 4260 debug->line = NULL; 4261 debug->external_dnr = NULL; 4262 debug->external_pdr = NULL; 4263 debug->external_sym = NULL; 4264 debug->external_opt = NULL; 4265 debug->external_aux = NULL; 4266 debug->ss = NULL; 4267 debug->ssext = debug->ssext_end = NULL; 4268 debug->external_fdr = NULL; 4269 debug->external_rfd = NULL; 4270 debug->external_ext = debug->external_ext_end = NULL; 4271 4272 handle = bfd_ecoff_debug_init (abfd, debug, &backend->debug_swap, info); 4273 if (handle == NULL) 4274 return false; 4275 4276 /* Accumulate the debugging symbols from each input BFD. */ 4277 for (input_bfd = info->input_bfds; 4278 input_bfd != NULL; 4279 input_bfd = input_bfd->link.next) 4280 { 4281 bool ret; 4282 4283 if (bfd_get_flavour (input_bfd) == bfd_target_ecoff_flavour) 4284 { 4285 /* Arbitrarily set the symbolic header vstamp to the vstamp 4286 of the first object file in the link. */ 4287 if (symhdr->vstamp == 0) 4288 symhdr->vstamp 4289 = ecoff_data (input_bfd)->debug_info.symbolic_header.vstamp; 4290 ret = ecoff_final_link_debug_accumulate (abfd, input_bfd, info, 4291 handle); 4292 } 4293 else 4294 ret = bfd_ecoff_debug_accumulate_other (handle, abfd, 4295 debug, &backend->debug_swap, 4296 input_bfd, info); 4297 if (! ret) 4298 return false; 4299 4300 /* Combine the register masks. */ 4301 ecoff_data (abfd)->gprmask |= ecoff_data (input_bfd)->gprmask; 4302 ecoff_data (abfd)->fprmask |= ecoff_data (input_bfd)->fprmask; 4303 ecoff_data (abfd)->cprmask[0] |= ecoff_data (input_bfd)->cprmask[0]; 4304 ecoff_data (abfd)->cprmask[1] |= ecoff_data (input_bfd)->cprmask[1]; 4305 ecoff_data (abfd)->cprmask[2] |= ecoff_data (input_bfd)->cprmask[2]; 4306 ecoff_data (abfd)->cprmask[3] |= ecoff_data (input_bfd)->cprmask[3]; 4307 } 4308 4309 /* Write out the external symbols. */ 4310 einfo.abfd = abfd; 4311 einfo.info = info; 4312 bfd_hash_traverse (&info->hash->table, ecoff_link_write_external, &einfo); 4313 4314 if (bfd_link_relocatable (info)) 4315 { 4316 /* We need to make a pass over the link_orders to count up the 4317 number of relocations we will need to output, so that we know 4318 how much space they will take up. */ 4319 for (o = abfd->sections; o != NULL; o = o->next) 4320 { 4321 o->reloc_count = 0; 4322 for (p = o->map_head.link_order; 4323 p != NULL; 4324 p = p->next) 4325 if (p->type == bfd_indirect_link_order) 4326 o->reloc_count += p->u.indirect.section->reloc_count; 4327 else if (p->type == bfd_section_reloc_link_order 4328 || p->type == bfd_symbol_reloc_link_order) 4329 ++o->reloc_count; 4330 } 4331 } 4332 4333 /* Compute the reloc and symbol file positions. */ 4334 ecoff_compute_reloc_file_positions (abfd); 4335 4336 /* Write out the debugging information. */ 4337 if (! bfd_ecoff_write_accumulated_debug (handle, abfd, debug, 4338 &backend->debug_swap, info, 4339 ecoff_data (abfd)->sym_filepos)) 4340 return false; 4341 4342 bfd_ecoff_debug_free (handle, abfd, debug, &backend->debug_swap, info); 4343 4344 if (bfd_link_relocatable (info)) 4345 { 4346 /* Now reset the reloc_count field of the sections in the output 4347 BFD to 0, so that we can use them to keep track of how many 4348 relocs we have output thus far. */ 4349 for (o = abfd->sections; o != NULL; o = o->next) 4350 o->reloc_count = 0; 4351 } 4352 4353 /* Get a value for the GP register. */ 4354 if (ecoff_data (abfd)->gp == 0) 4355 { 4356 struct bfd_link_hash_entry *h; 4357 4358 h = bfd_link_hash_lookup (info->hash, "_gp", false, false, true); 4359 if (h != NULL 4360 && h->type == bfd_link_hash_defined) 4361 ecoff_data (abfd)->gp = (h->u.def.value 4362 + h->u.def.section->output_section->vma 4363 + h->u.def.section->output_offset); 4364 else if (bfd_link_relocatable (info)) 4365 { 4366 bfd_vma lo; 4367 4368 /* Make up a value. */ 4369 lo = (bfd_vma) -1; 4370 for (o = abfd->sections; o != NULL; o = o->next) 4371 { 4372 if (o->vma < lo 4373 && (streq (o->name, _SBSS) 4374 || streq (o->name, _SDATA) 4375 || streq (o->name, _LIT4) 4376 || streq (o->name, _LIT8) 4377 || streq (o->name, _LITA))) 4378 lo = o->vma; 4379 } 4380 ecoff_data (abfd)->gp = lo + 0x8000; 4381 } 4382 else 4383 { 4384 /* If the relocate_section function needs to do a reloc 4385 involving the GP value, it should make a reloc_dangerous 4386 callback to warn that GP is not defined. */ 4387 } 4388 } 4389 4390 for (o = abfd->sections; o != NULL; o = o->next) 4391 { 4392 for (p = o->map_head.link_order; 4393 p != NULL; 4394 p = p->next) 4395 { 4396 if (p->type == bfd_indirect_link_order 4397 && (bfd_get_flavour (p->u.indirect.section->owner) 4398 == bfd_target_ecoff_flavour)) 4399 { 4400 if (! ecoff_indirect_link_order (abfd, info, o, p)) 4401 return false; 4402 } 4403 else if (p->type == bfd_section_reloc_link_order 4404 || p->type == bfd_symbol_reloc_link_order) 4405 { 4406 if (! ecoff_reloc_link_order (abfd, info, o, p)) 4407 return false; 4408 } 4409 else 4410 { 4411 if (! _bfd_default_link_order (abfd, info, o, p)) 4412 return false; 4413 } 4414 } 4415 } 4416 4417 abfd->symcount = symhdr->iextMax + symhdr->isymMax; 4418 4419 ecoff_data (abfd)->linker = true; 4420 4421 return true; 4422} 4423