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