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