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