X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=bfd%2Fecoff.c;h=f2713626d6088d265815f113fa412b4901d87b7f;hb=acdf84a65400f416c60a0c9c14953ba5a73fb0cd;hp=5991fddb7871ea07ada2e92d82d0f26caf0ac804;hpb=3e27568fe9469749a169fb226ca0de9e43737a1f;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/ecoff.c b/bfd/ecoff.c index 5991fddb78..f2713626d6 100644 --- a/bfd/ecoff.c +++ b/bfd/ecoff.c @@ -1,6 +1,5 @@ /* Generic ECOFF (Extended-COFF) routines. - Copyright 1990, 1991, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, - 2002, 2003 Free Software Foundation, Inc. + Copyright (C) 1990-2020 Free Software Foundation, Inc. Original version by Per Bothner. Full support added by Ian Lance Taylor, ian@cygnus.com. @@ -8,7 +7,7 @@ This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or + the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, @@ -18,14 +17,15 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, + MA 02110-1301, USA. */ -#include "bfd.h" #include "sysdep.h" +#include "bfd.h" #include "bfdlink.h" #include "libbfd.h" +#include "ecoff-bfd.h" #include "aout/ar.h" -#include "aout/ranlib.h" #include "aout/stab_gnu.h" /* FIXME: We need the definitions of N_SET[ADTB], but aout64.h defines @@ -43,75 +43,47 @@ #include "coff/ecoff.h" #include "libcoff.h" #include "libecoff.h" - -/* Prototypes for static functions. */ - -static int ecoff_get_magic - PARAMS ((bfd *)); -static long ecoff_sec_to_styp_flags - PARAMS ((const char *, flagword)); -static bfd_boolean ecoff_slurp_symbolic_header - PARAMS ((bfd *)); -static bfd_boolean ecoff_set_symbol_info - PARAMS ((bfd *, SYMR *, asymbol *, int, int)); -static void ecoff_emit_aggregate - PARAMS ((bfd *, FDR *, char *, RNDXR *, long, const char *)); -static char *ecoff_type_to_string - PARAMS ((bfd *, FDR *, unsigned int)); -static bfd_boolean ecoff_slurp_reloc_table - PARAMS ((bfd *, asection *, asymbol **)); -static int ecoff_sort_hdrs - PARAMS ((const PTR, const PTR)); -static bfd_boolean ecoff_compute_section_file_positions - PARAMS ((bfd *)); -static bfd_size_type ecoff_compute_reloc_file_positions - PARAMS ((bfd *)); -static bfd_boolean ecoff_get_extr - PARAMS ((asymbol *, EXTR *)); -static void ecoff_set_index - PARAMS ((asymbol *, bfd_size_type)); -static unsigned int ecoff_armap_hash - PARAMS ((const char *, unsigned int *, unsigned int, unsigned int)); +#include "libiberty.h" + +#define streq(a, b) (strcmp ((a), (b)) == 0) +#define strneq(a, b, n) (strncmp ((a), (b), (n)) == 0) + /* This stuff is somewhat copied from coffcode.h. */ - static asection bfd_debug_section = { - /* name, id, index, next, flags, user_set_vma, reloc_done, */ - "*DEBUG*", 0, 0, NULL, 0, 0, 0, - /* linker_mark, linker_has_input, gc_mark, segment_mark, */ - 0, 0, 0, 0, - /* sec_info_type, use_rela_p, has_tls_reloc, */ - 0, 0, 0, - /* need_finalize_relax, has_gp_reloc, */ - 0, 0, - /* flag13, flag14, flag15, flag16, flag20, flag24, */ - 0, 0, 0, 0, 0, 0, - /* vma, lma, _cooked_size, _raw_size, */ - 0, 0, 0, 0, - /* output_offset, output_section, alignment_power, */ - 0, NULL, 0, + /* name, id, index, next, prev, flags, user_set_vma, */ + "*DEBUG*", 0, 0, NULL, NULL, 0, 0, + /* linker_mark, linker_has_input, gc_mark, compress_status, */ + 0, 0, 1, 0, + /* segment_mark, sec_info_type, use_rela_p, */ + 0, 0, 0, + /* sec_flg0, sec_flg1, sec_flg2, sec_flg3, sec_flg4, sec_flg5, */ + 0, 0, 0, 0, 0, 0, + /* vma, lma, size, rawsize, compressed_size, relax, relax_count, */ + 0, 0, 0, 0, 0, 0, 0, + /* output_offset, output_section, alignment_power, */ + 0, NULL, 0, /* relocation, orelocation, reloc_count, filepos, rel_filepos, */ - NULL, NULL, 0, 0, 0, - /* line_filepos, userdata, contents, lineno, lineno_count, */ - 0, NULL, NULL, NULL, 0, - /* entsize, comdat, kept_section, moving_line_filepos, */ - 0, NULL, NULL, 0, - /* target_index, used_by_bfd, constructor_chain, owner, */ - 0, NULL, NULL, NULL, - /* symbol, */ - (struct bfd_symbol *) NULL, - /* symbol_ptr_ptr, */ - (struct bfd_symbol **) NULL, - /* link_order_head, link_order_tail */ - NULL, NULL + NULL, NULL, 0, 0, 0, + /* line_filepos, userdata, contents, lineno, lineno_count, */ + 0, NULL, NULL, NULL, 0, + /* entsize, kept_section, moving_line_filepos, */ + 0, NULL, 0, + /* target_index, used_by_bfd, constructor_chain, owner, */ + 0, NULL, NULL, NULL, + /* symbol, */ + NULL, + /* symbol_ptr_ptr, */ + NULL, + /* map_head, map_tail */ + { NULL }, { NULL } }; /* Create an ECOFF object. */ bfd_boolean -_bfd_ecoff_mkobject (abfd) - bfd *abfd; +_bfd_ecoff_mkobject (bfd *abfd) { bfd_size_type amt = sizeof (ecoff_data_type); @@ -125,11 +97,8 @@ _bfd_ecoff_mkobject (abfd) /* This is a hook called by coff_real_object_p to create any backend specific information. */ -PTR -_bfd_ecoff_mkobject_hook (abfd, filehdr, aouthdr) - bfd *abfd; - PTR filehdr; - PTR aouthdr; +void * +_bfd_ecoff_mkobject_hook (bfd *abfd, void * filehdr, void * aouthdr) { struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; struct internal_aouthdr *internal_a = (struct internal_aouthdr *) aouthdr; @@ -142,7 +111,7 @@ _bfd_ecoff_mkobject_hook (abfd, filehdr, aouthdr) ecoff->gp_size = 8; ecoff->sym_filepos = internal_f->f_symptr; - if (internal_a != (struct internal_aouthdr *) NULL) + if (internal_a != NULL) { int i; @@ -165,43 +134,60 @@ _bfd_ecoff_mkobject_hook (abfd, filehdr, aouthdr) fprmask) and let the swapping routines ensure that only relevant information is written out. */ - return (PTR) ecoff; + return (void *) ecoff; } /* Initialize a new section. */ bfd_boolean -_bfd_ecoff_new_section_hook (abfd, section) - bfd *abfd ATTRIBUTE_UNUSED; - asection *section; +_bfd_ecoff_new_section_hook (bfd *abfd, asection *section) { + unsigned int i; + static struct + { + const char * name; + flagword flags; + } + section_flags [] = + { + { _TEXT, SEC_ALLOC | SEC_CODE | SEC_LOAD }, + { _INIT, SEC_ALLOC | SEC_CODE | SEC_LOAD }, + { _FINI, SEC_ALLOC | SEC_CODE | SEC_LOAD }, + { _DATA, SEC_ALLOC | SEC_DATA | SEC_LOAD }, + { _SDATA, SEC_ALLOC | SEC_DATA | SEC_LOAD }, + { _RDATA, SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY}, + { _LIT8, SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY}, + { _LIT4, SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY}, + { _RCONST, SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY}, + { _PDATA, SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY}, + { _BSS, SEC_ALLOC}, + { _SBSS, SEC_ALLOC}, + /* An Irix 4 shared libary. */ + { _LIB, SEC_COFF_SHARED_LIBRARY} + }; + section->alignment_power = 4; - if (strcmp (section->name, _TEXT) == 0 - || strcmp (section->name, _INIT) == 0 - || strcmp (section->name, _FINI) == 0) - section->flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC; - else if (strcmp (section->name, _DATA) == 0 - || strcmp (section->name, _SDATA) == 0) - section->flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC; - else if (strcmp (section->name, _RDATA) == 0 - || strcmp (section->name, _LIT8) == 0 - || strcmp (section->name, _LIT4) == 0 - || strcmp (section->name, _RCONST) == 0 - || strcmp (section->name, _PDATA) == 0) - section->flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC | SEC_READONLY; - else if (strcmp (section->name, _BSS) == 0 - || strcmp (section->name, _SBSS) == 0) - section->flags |= SEC_ALLOC; - else if (strcmp (section->name, _LIB) == 0) - /* An Irix 4 shared libary. */ - section->flags |= SEC_COFF_SHARED_LIBRARY; + for (i = 0; i < ARRAY_SIZE (section_flags); i++) + if (streq (section->name, section_flags[i].name)) + { + section->flags |= section_flags[i].flags; + break; + } + /* Probably any other section name is SEC_NEVER_LOAD, but I'm uncertain about .init on some systems and I don't know how shared libraries work. */ - return TRUE; + return _bfd_generic_new_section_hook (abfd, section); +} + +void +_bfd_ecoff_set_alignment_hook (bfd *abfd ATTRIBUTE_UNUSED, + asection *section ATTRIBUTE_UNUSED, + void *scnhdr ATTRIBUTE_UNUSED) +{ } /* Determine the machine architecture and type. This is called from @@ -210,9 +196,7 @@ _bfd_ecoff_new_section_hook (abfd, section) for each target, but there aren't all that many ECOFF targets. */ bfd_boolean -_bfd_ecoff_set_arch_mach_hook (abfd, filehdr) - bfd *abfd; - PTR filehdr; +_bfd_ecoff_set_arch_mach_hook (bfd *abfd, void * filehdr) { struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; enum bfd_architecture arch; @@ -255,12 +239,19 @@ _bfd_ecoff_set_arch_mach_hook (abfd, filehdr) return bfd_default_set_arch_mach (abfd, arch, mach); } +bfd_boolean +_bfd_ecoff_no_long_sections (bfd *abfd, int enable) +{ + (void) abfd; + (void) enable; + return FALSE; +} + /* Get the magic number to use based on the architecture and machine. This is the inverse of _bfd_ecoff_set_arch_mach_hook, above. */ static int -ecoff_get_magic (abfd) - bfd *abfd; +ecoff_get_magic (bfd *abfd) { int big, little; @@ -301,75 +292,67 @@ ecoff_get_magic (abfd) /* Get the section s_flags to use for a section. */ static long -ecoff_sec_to_styp_flags (name, flags) - const char *name; - flagword flags; +ecoff_sec_to_styp_flags (const char *name, flagword flags) { - long styp; - - styp = 0; - - if (strcmp (name, _TEXT) == 0) - styp = STYP_TEXT; - else if (strcmp (name, _DATA) == 0) - styp = STYP_DATA; - else if (strcmp (name, _SDATA) == 0) - styp = STYP_SDATA; - else if (strcmp (name, _RDATA) == 0) - styp = STYP_RDATA; - else if (strcmp (name, _LITA) == 0) - styp = STYP_LITA; - else if (strcmp (name, _LIT8) == 0) - styp = STYP_LIT8; - else if (strcmp (name, _LIT4) == 0) - styp = STYP_LIT4; - else if (strcmp (name, _BSS) == 0) - styp = STYP_BSS; - else if (strcmp (name, _SBSS) == 0) - styp = STYP_SBSS; - else if (strcmp (name, _INIT) == 0) - styp = STYP_ECOFF_INIT; - else if (strcmp (name, _FINI) == 0) - styp = STYP_ECOFF_FINI; - else if (strcmp (name, _PDATA) == 0) - styp = STYP_PDATA; - else if (strcmp (name, _XDATA) == 0) - styp = STYP_XDATA; - else if (strcmp (name, _LIB) == 0) - styp = STYP_ECOFF_LIB; - else if (strcmp (name, _GOT) == 0) - styp = STYP_GOT; - else if (strcmp (name, _HASH) == 0) - styp = STYP_HASH; - else if (strcmp (name, _DYNAMIC) == 0) - styp = STYP_DYNAMIC; - else if (strcmp (name, _LIBLIST) == 0) - styp = STYP_LIBLIST; - else if (strcmp (name, _RELDYN) == 0) - styp = STYP_RELDYN; - else if (strcmp (name, _CONFLIC) == 0) - styp = STYP_CONFLIC; - else if (strcmp (name, _DYNSTR) == 0) - styp = STYP_DYNSTR; - else if (strcmp (name, _DYNSYM) == 0) - styp = STYP_DYNSYM; - else if (strcmp (name, _COMMENT) == 0) + unsigned int i; + static struct + { + const char * name; + long flags; + } + styp_flags [] = + { + { _TEXT, STYP_TEXT }, + { _DATA, STYP_DATA }, + { _SDATA, STYP_SDATA }, + { _RDATA, STYP_RDATA }, + { _LITA, STYP_LITA }, + { _LIT8, STYP_LIT8 }, + { _LIT4, STYP_LIT4 }, + { _BSS, STYP_BSS }, + { _SBSS, STYP_SBSS }, + { _INIT, STYP_ECOFF_INIT }, + { _FINI, STYP_ECOFF_FINI }, + { _PDATA, STYP_PDATA }, + { _XDATA, STYP_XDATA }, + { _LIB, STYP_ECOFF_LIB }, + { _GOT, STYP_GOT }, + { _HASH, STYP_HASH }, + { _DYNAMIC, STYP_DYNAMIC }, + { _LIBLIST, STYP_LIBLIST }, + { _RELDYN, STYP_RELDYN }, + { _CONFLIC, STYP_CONFLIC }, + { _DYNSTR, STYP_DYNSTR }, + { _DYNSYM, STYP_DYNSYM }, + { _RCONST, STYP_RCONST } + }; + long styp = 0; + + for (i = 0; i < ARRAY_SIZE (styp_flags); i++) + if (streq (name, styp_flags[i].name)) + { + styp = styp_flags[i].flags; + break; + } + + if (styp == 0) { - styp = STYP_COMMENT; - flags &=~ SEC_NEVER_LOAD; + if (streq (name, _COMMENT)) + { + styp = STYP_COMMENT; + flags &=~ SEC_NEVER_LOAD; + } + else if (flags & SEC_CODE) + styp = STYP_TEXT; + else if (flags & SEC_DATA) + styp = STYP_DATA; + else if (flags & SEC_READONLY) + styp = STYP_RDATA; + else if (flags & SEC_LOAD) + styp = STYP_REG; + else + styp = STYP_BSS; } - else if (strcmp (name, _RCONST) == 0) - styp = STYP_RCONST; - else if (flags & SEC_CODE) - styp = STYP_TEXT; - else if (flags & SEC_DATA) - styp = STYP_DATA; - else if (flags & SEC_READONLY) - styp = STYP_RDATA; - else if (flags & SEC_LOAD) - styp = STYP_REG; - else - styp = STYP_BSS; if (flags & SEC_NEVER_LOAD) styp |= STYP_NOLOAD; @@ -380,12 +363,11 @@ ecoff_sec_to_styp_flags (name, flags) /* Get the BFD flags to use for a section. */ bfd_boolean -_bfd_ecoff_styp_to_sec_flags (abfd, hdr, name, section, flags_ptr) - bfd *abfd ATTRIBUTE_UNUSED; - PTR hdr; - const char *name ATTRIBUTE_UNUSED; - asection *section ATTRIBUTE_UNUSED; - flagword * flags_ptr; +_bfd_ecoff_styp_to_sec_flags (bfd *abfd ATTRIBUTE_UNUSED, + void * hdr, + const char *name ATTRIBUTE_UNUSED, + asection *section ATTRIBUTE_UNUSED, + flagword * flags_ptr) { struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr; long styp_flags = internal_s->s_flags; @@ -450,12 +432,11 @@ _bfd_ecoff_styp_to_sec_flags (abfd, hdr, name, section, flags_ptr) /* Read in the symbolic header for an ECOFF object file. */ static bfd_boolean -ecoff_slurp_symbolic_header (abfd) - bfd *abfd; +ecoff_slurp_symbolic_header (bfd *abfd) { const struct ecoff_backend_data * const backend = ecoff_backend (abfd); bfd_size_type external_hdr_size; - PTR raw = NULL; + void * raw = NULL; HDRR *internal_symhdr; /* See if we've already read it in. */ @@ -466,7 +447,7 @@ ecoff_slurp_symbolic_header (abfd) /* See whether there is a symbolic header. */ if (ecoff_data (abfd)->sym_filepos == 0) { - bfd_get_symcount (abfd) = 0; + abfd->symcount = 0; return TRUE; } @@ -482,7 +463,7 @@ ecoff_slurp_symbolic_header (abfd) } /* Read the symbolic information header. */ - raw = (PTR) bfd_malloc (external_hdr_size); + raw = bfd_malloc (external_hdr_size); if (raw == NULL) goto error_return; @@ -499,8 +480,7 @@ ecoff_slurp_symbolic_header (abfd) } /* Now we can get the correct number of symbols. */ - bfd_get_symcount (abfd) = (internal_symhdr->isymMax - + internal_symhdr->iextMax); + abfd->symcount = internal_symhdr->isymMax + internal_symhdr->iextMax; if (raw != NULL) free (raw); @@ -516,34 +496,32 @@ ecoff_slurp_symbolic_header (abfd) point in the backend structure. */ bfd_boolean -_bfd_ecoff_slurp_symbolic_info (abfd, ignore, debug) - bfd *abfd; - asection *ignore ATTRIBUTE_UNUSED; - struct ecoff_debug_info *debug; +_bfd_ecoff_slurp_symbolic_info (bfd *abfd, + asection *ignore ATTRIBUTE_UNUSED, + struct ecoff_debug_info *debug) { const struct ecoff_backend_data * const backend = ecoff_backend (abfd); HDRR *internal_symhdr; bfd_size_type raw_base; bfd_size_type raw_size; - PTR raw; + void * raw; bfd_size_type external_fdr_size; char *fraw_src; char *fraw_end; struct fdr *fdr_ptr; bfd_size_type raw_end; bfd_size_type cb_end; - bfd_size_type amt; file_ptr pos; BFD_ASSERT (debug == &ecoff_data (abfd)->debug_info); /* Check whether we've already gotten it, and whether there's any to get. */ - if (ecoff_data (abfd)->raw_syments != (PTR) NULL) + if (ecoff_data (abfd)->raw_syments != NULL) return TRUE; if (ecoff_data (abfd)->sym_filepos == 0) { - bfd_get_symcount (abfd) = 0; + abfd->symcount = 0; return TRUE; } @@ -573,7 +551,7 @@ _bfd_ecoff_slurp_symbolic_info (abfd, ignore, debug) UPDATE_RAW_END (cbPdOffset, ipdMax, backend->debug_swap.external_pdr_size); UPDATE_RAW_END (cbSymOffset, isymMax, backend->debug_swap.external_sym_size); /* eraxxon@alumni.rice.edu: ioptMax refers to the size of the - optimization symtab, not the number of entries */ + optimization symtab, not the number of entries. */ UPDATE_RAW_END (cbOptOffset, ioptMax, sizeof (char)); UPDATE_RAW_END (cbAuxOffset, iauxMax, sizeof (union aux_ext)); UPDATE_RAW_END (cbSsOffset, issMax, sizeof (char)); @@ -590,7 +568,7 @@ _bfd_ecoff_slurp_symbolic_info (abfd, ignore, debug) ecoff_data (abfd)->sym_filepos = 0; return TRUE; } - raw = (PTR) bfd_alloc (abfd, raw_size); + raw = bfd_alloc (abfd, raw_size); if (raw == NULL) return FALSE; @@ -606,25 +584,25 @@ _bfd_ecoff_slurp_symbolic_info (abfd, ignore, debug) ecoff_data (abfd)->raw_syments = raw; /* Get pointers for the numeric offsets in the HDRR structure. */ -#define FIX(off1, off2, type) \ - if (internal_symhdr->off1 == 0) \ - debug->off2 = (type) NULL; \ - else \ - debug->off2 = (type) ((char *) raw \ - + (internal_symhdr->off1 \ +#define FIX(off1, off2, type) \ + if (internal_symhdr->off1 == 0) \ + debug->off2 = NULL; \ + else \ + debug->off2 = (type) ((char *) raw \ + + (internal_symhdr->off1 \ - raw_base)) FIX (cbLineOffset, line, unsigned char *); - FIX (cbDnOffset, external_dnr, PTR); - FIX (cbPdOffset, external_pdr, PTR); - FIX (cbSymOffset, external_sym, PTR); - FIX (cbOptOffset, external_opt, PTR); + FIX (cbDnOffset, external_dnr, void *); + FIX (cbPdOffset, external_pdr, void *); + FIX (cbSymOffset, external_sym, void *); + FIX (cbOptOffset, external_opt, void *); FIX (cbAuxOffset, external_aux, union aux_ext *); FIX (cbSsOffset, ss, char *); FIX (cbSsExtOffset, ssext, char *); - FIX (cbFdOffset, external_fdr, PTR); - FIX (cbRfdOffset, external_rfd, PTR); - FIX (cbExtOffset, external_ext, PTR); + FIX (cbFdOffset, external_fdr, void *); + FIX (cbRfdOffset, external_rfd, void *); + FIX (cbExtOffset, external_ext, void *); #undef FIX /* I don't want to always swap all the data, because it will just @@ -635,17 +613,19 @@ _bfd_ecoff_slurp_symbolic_info (abfd, ignore, debug) We need to look at the fdr to deal with a lot of information in the symbols, so we swap them here. */ - amt = internal_symhdr->ifdMax; - amt *= sizeof (struct fdr); - debug->fdr = (struct fdr *) bfd_alloc (abfd, amt); + debug->fdr = (FDR *) bfd_alloc2 (abfd, internal_symhdr->ifdMax, + sizeof (struct fdr)); if (debug->fdr == NULL) return FALSE; external_fdr_size = backend->debug_swap.external_fdr_size; fdr_ptr = debug->fdr; fraw_src = (char *) debug->external_fdr; + /* PR 17512: file: 3372-1243-0.004. */ + if (fraw_src == NULL && internal_symhdr->ifdMax > 0) + return FALSE; fraw_end = fraw_src + internal_symhdr->ifdMax * external_fdr_size; for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++) - (*backend->debug_swap.swap_fdr_in) (abfd, (PTR) fraw_src, fdr_ptr); + (*backend->debug_swap.swap_fdr_in) (abfd, (void *) fraw_src, fdr_ptr); return TRUE; } @@ -665,32 +645,30 @@ static asymbol *ecoff_scom_symbol_ptr; /* Create an empty symbol. */ asymbol * -_bfd_ecoff_make_empty_symbol (abfd) - bfd *abfd; +_bfd_ecoff_make_empty_symbol (bfd *abfd) { - ecoff_symbol_type *new; + ecoff_symbol_type *new_symbol; bfd_size_type amt = sizeof (ecoff_symbol_type); - new = (ecoff_symbol_type *) bfd_zalloc (abfd, amt); - if (new == (ecoff_symbol_type *) NULL) - return (asymbol *) NULL; - new->symbol.section = (asection *) NULL; - new->fdr = (FDR *) NULL; - new->local = FALSE; - new->native = NULL; - new->symbol.the_bfd = abfd; - return &new->symbol; + new_symbol = (ecoff_symbol_type *) bfd_zalloc (abfd, amt); + if (new_symbol == NULL) + return NULL; + new_symbol->symbol.section = NULL; + new_symbol->fdr = NULL; + new_symbol->local = FALSE; + new_symbol->native = NULL; + new_symbol->symbol.the_bfd = abfd; + return &new_symbol->symbol; } /* Set the BFD flags and section for an ECOFF symbol. */ static bfd_boolean -ecoff_set_symbol_info (abfd, ecoff_sym, asym, ext, weak) - bfd *abfd; - SYMR *ecoff_sym; - asymbol *asym; - int ext; - int weak; +ecoff_set_symbol_info (bfd *abfd, + SYMR *ecoff_sym, + asymbol *asym, + int ext, + int weak) { asym->the_bfd = abfd; asym->value = ecoff_sym->value; @@ -726,11 +704,11 @@ ecoff_set_symbol_info (abfd, ecoff_sym, asym, ext, weak) { asym->flags = BSF_LOCAL; /* Normally, a local stProc symbol will have a corresponding - external symbol. We mark the local symbol as a debugging - symbol, in order to prevent nm from printing both out. - Similarly, we mark stLabel and stabs symbols as debugging - symbols. In both cases, we do want to set the value - correctly based on the symbol class. */ + external symbol. We mark the local symbol as a debugging + symbol, in order to prevent nm from printing both out. + Similarly, we mark stLabel and stabs symbols as debugging + symbols. In both cases, we do want to set the value + correctly based on the symbol class. */ if (ecoff_sym->st == stProc || ecoff_sym->st == stLabel || ECOFF_IS_STAB (ecoff_sym)) @@ -750,15 +728,15 @@ ecoff_set_symbol_info (abfd, ecoff_sym, asym, ext, weak) asym->flags = BSF_LOCAL; break; case scText: - asym->section = bfd_make_section_old_way (abfd, ".text"); + asym->section = bfd_make_section_old_way (abfd, _TEXT); asym->value -= asym->section->vma; break; case scData: - asym->section = bfd_make_section_old_way (abfd, ".data"); + asym->section = bfd_make_section_old_way (abfd, _DATA); asym->value -= asym->section->vma; break; case scBss: - asym->section = bfd_make_section_old_way (abfd, ".bss"); + asym->section = bfd_make_section_old_way (abfd, _BSS); asym->value -= asym->section->vma; break; case scRegister: @@ -864,77 +842,8 @@ ecoff_set_symbol_info (abfd, ecoff_sym, asym, ext, weak) case N_SETT: case N_SETD: case N_SETB: - { - /* This code is no longer needed. It used to be used to - make the linker handle set symbols, but they are now - handled in the add_symbols routine instead. */ -#if 0 - const char *name; - asection *section; - arelent_chain *reloc_chain; - unsigned int bitsize; - bfd_size_type amt; - - /* Get a section with the same name as the symbol (usually - __CTOR_LIST__ or __DTOR_LIST__). FIXME: gcc uses the - name ___CTOR_LIST (three underscores). We need - __CTOR_LIST (two underscores), since ECOFF doesn't use - a leading underscore. This should be handled by gcc, - but instead we do it here. Actually, this should all - be done differently anyhow. */ - name = bfd_asymbol_name (asym); - if (name[0] == '_' && name[1] == '_' && name[2] == '_') - { - ++name; - asym->name = name; - } - section = bfd_get_section_by_name (abfd, name); - if (section == (asection *) NULL) - { - char *copy; - - amt = strlen (name) + 1; - copy = (char *) bfd_alloc (abfd, amt); - if (!copy) - return FALSE; - strcpy (copy, name); - section = bfd_make_section (abfd, copy); - } - - /* Build a reloc pointing to this constructor. */ - amt = sizeof (arelent_chain); - reloc_chain = (arelent_chain *) bfd_alloc (abfd, amt); - if (!reloc_chain) - return FALSE; - reloc_chain->relent.sym_ptr_ptr = - bfd_get_section (asym)->symbol_ptr_ptr; - reloc_chain->relent.address = section->_raw_size; - reloc_chain->relent.addend = asym->value; - reloc_chain->relent.howto = - ecoff_backend (abfd)->constructor_reloc; - - /* Set up the constructor section to hold the reloc. */ - section->flags = SEC_CONSTRUCTOR; - ++section->reloc_count; - - /* Constructor sections must be rounded to a boundary - based on the bitsize. These are not real sections-- - they are handled specially by the linker--so the ECOFF - 16 byte alignment restriction does not apply. */ - bitsize = ecoff_backend (abfd)->constructor_bitsize; - section->alignment_power = 1; - while ((1 << section->alignment_power) < bitsize / 8) - ++section->alignment_power; - - reloc_chain->next = section->constructor_chain; - section->constructor_chain = reloc_chain; - section->_raw_size += bitsize / 8; - -#endif /* 0 */ - - /* Mark the symbol as a constructor. */ - asym->flags |= BSF_CONSTRUCTOR; - } + /* Mark the symbol as a constructor. */ + asym->flags |= BSF_CONSTRUCTOR; break; } } @@ -944,19 +853,17 @@ ecoff_set_symbol_info (abfd, ecoff_sym, asym, ext, weak) /* Read an ECOFF symbol table. */ bfd_boolean -_bfd_ecoff_slurp_symbol_table (abfd) - bfd *abfd; +_bfd_ecoff_slurp_symbol_table (bfd *abfd) { const struct ecoff_backend_data * const backend = ecoff_backend (abfd); const bfd_size_type external_ext_size = backend->debug_swap.external_ext_size; const bfd_size_type external_sym_size = backend->debug_swap.external_sym_size; - void (* const swap_ext_in) PARAMS ((bfd *, PTR, EXTR *)) + void (* const swap_ext_in) (bfd *, void *, EXTR *) = backend->debug_swap.swap_ext_in; - void (* const swap_sym_in) PARAMS ((bfd *, PTR, SYMR *)) + void (* const swap_sym_in) (bfd *, void *, SYMR *) = backend->debug_swap.swap_sym_in; - bfd_size_type internal_size; ecoff_symbol_type *internal; ecoff_symbol_type *internal_ptr; char *eraw_src; @@ -969,15 +876,14 @@ _bfd_ecoff_slurp_symbol_table (abfd) return TRUE; /* Get the symbolic information. */ - if (! _bfd_ecoff_slurp_symbolic_info (abfd, (asection *) NULL, + if (! _bfd_ecoff_slurp_symbolic_info (abfd, NULL, &ecoff_data (abfd)->debug_info)) return FALSE; if (bfd_get_symcount (abfd) == 0) return TRUE; - internal_size = bfd_get_symcount (abfd); - internal_size *= sizeof (ecoff_symbol_type); - internal = (ecoff_symbol_type *) bfd_alloc (abfd, internal_size); + internal = (ecoff_symbol_type *) bfd_alloc2 (abfd, bfd_get_symcount (abfd), + sizeof (ecoff_symbol_type)); if (internal == NULL) return FALSE; @@ -990,21 +896,35 @@ _bfd_ecoff_slurp_symbol_table (abfd) { EXTR internal_esym; - (*swap_ext_in) (abfd, (PTR) eraw_src, &internal_esym); + (*swap_ext_in) (abfd, (void *) eraw_src, &internal_esym); + + /* PR 17512: file: 3372-1000-0.004. */ + if (internal_esym.asym.iss >= ecoff_data (abfd)->debug_info.symbolic_header.issExtMax + || internal_esym.asym.iss < 0) + return FALSE; + internal_ptr->symbol.name = (ecoff_data (abfd)->debug_info.ssext + internal_esym.asym.iss); + if (!ecoff_set_symbol_info (abfd, &internal_esym.asym, &internal_ptr->symbol, 1, internal_esym.weakext)) return FALSE; + /* The alpha uses a negative ifd field for section symbols. */ if (internal_esym.ifd >= 0) - internal_ptr->fdr = (ecoff_data (abfd)->debug_info.fdr - + internal_esym.ifd); + { + /* PR 17512: file: 3372-1983-0.004. */ + if (internal_esym.ifd >= ecoff_data (abfd)->debug_info.symbolic_header.ifdMax) + internal_ptr->fdr = NULL; + else + internal_ptr->fdr = (ecoff_data (abfd)->debug_info.fdr + + internal_esym.ifd); + } else internal_ptr->fdr = NULL; internal_ptr->local = FALSE; - internal_ptr->native = (PTR) eraw_src; + internal_ptr->native = (void *) eraw_src; } /* The local symbols must be accessed via the fdr's, because the @@ -1025,7 +945,7 @@ _bfd_ecoff_slurp_symbol_table (abfd) { SYMR internal_sym; - (*swap_sym_in) (abfd, (PTR) lraw_src, &internal_sym); + (*swap_sym_in) (abfd, (void *) lraw_src, &internal_sym); internal_ptr->symbol.name = (ecoff_data (abfd)->debug_info.ss + fdr_ptr->issBase + internal_sym.iss); @@ -1034,10 +954,25 @@ _bfd_ecoff_slurp_symbol_table (abfd) return FALSE; internal_ptr->fdr = fdr_ptr; internal_ptr->local = TRUE; - internal_ptr->native = (PTR) lraw_src; + internal_ptr->native = (void *) lraw_src; } } + /* PR 17512: file: 3372-3080-0.004. + A discrepancy between ecoff_data (abfd)->debug_info.symbolic_header.isymMax + and ecoff_data (abfd)->debug_info.symbolic_header.ifdMax can mean that + we have fewer symbols than we were expecting. Allow for this by updating + the symbol count and warning the user. */ + if (internal_ptr - internal < (ptrdiff_t) bfd_get_symcount (abfd)) + { + abfd->symcount = internal_ptr - internal; + _bfd_error_handler + /* xgettext:c-format */ + (_("%pB: warning: isymMax (%ld) is greater than ifdMax (%ld)"), + abfd, ecoff_data (abfd)->debug_info.symbolic_header.isymMax, + ecoff_data (abfd)->debug_info.symbolic_header.ifdMax); + } + ecoff_data (abfd)->canonical_symbols = internal; return TRUE; @@ -1046,10 +981,9 @@ _bfd_ecoff_slurp_symbol_table (abfd) /* Return the amount of space needed for the canonical symbols. */ long -_bfd_ecoff_get_symtab_upper_bound (abfd) - bfd *abfd; +_bfd_ecoff_get_symtab_upper_bound (bfd *abfd) { - if (! _bfd_ecoff_slurp_symbolic_info (abfd, (asection *) NULL, + if (! _bfd_ecoff_slurp_symbolic_info (abfd, NULL, &ecoff_data (abfd)->debug_info)) return -1; @@ -1062,9 +996,7 @@ _bfd_ecoff_get_symtab_upper_bound (abfd) /* Get the canonical symbols. */ long -_bfd_ecoff_canonicalize_symtab (abfd, alocation) - bfd *abfd; - asymbol **alocation; +_bfd_ecoff_canonicalize_symtab (bfd *abfd, asymbol **alocation) { unsigned int counter = 0; ecoff_symbol_type *symbase; @@ -1081,7 +1013,7 @@ _bfd_ecoff_canonicalize_symtab (abfd, alocation) *(location++) = symbase++; counter++; } - *location++ = (ecoff_symbol_type *) NULL; + *location++ = NULL; return bfd_get_symcount (abfd); } @@ -1092,13 +1024,12 @@ _bfd_ecoff_canonicalize_symtab (abfd, alocation) /* Write aggregate information to a string. */ static void -ecoff_emit_aggregate (abfd, fdr, string, rndx, isym, which) - bfd *abfd; - FDR *fdr; - char *string; - RNDXR *rndx; - long isym; - const char *which; +ecoff_emit_aggregate (bfd *abfd, + FDR *fdr, + char *string, + RNDXR *rndx, + long isym, + const char *which) { const struct ecoff_debug_swap * const debug_swap = &ecoff_backend (abfd)->debug_swap; @@ -1148,22 +1079,20 @@ ecoff_emit_aggregate (abfd, fdr, string, rndx, isym, which) sprintf (string, "%s %s { ifd = %u, index = %lu }", which, name, ifd, - ((long) indx + ((unsigned long) indx + debug_info->symbolic_header.iextMax)); } /* Convert the type information to string format. */ static char * -ecoff_type_to_string (abfd, fdr, indx) - bfd *abfd; - FDR *fdr; - unsigned int indx; +ecoff_type_to_string (bfd *abfd, FDR *fdr, unsigned int indx) { union aux_ext *aux_ptr; int bigendian; AUXU u; - struct qual { + struct qual + { unsigned int type; int low_bound; int high_bound; @@ -1336,7 +1265,7 @@ ecoff_type_to_string (abfd, fdr, indx) break; default: - sprintf (p1, _("Unknown basic type %d"), (int) basic_type); + sprintf (p1, _("unknown basic type %d"), (int) basic_type); break; } @@ -1356,12 +1285,12 @@ ecoff_type_to_string (abfd, fdr, indx) if (qualifiers[0].type != tqNil) { /* Snarf up any array bounds in the correct order. Arrays - store 5 successive words in the aux. table: - word 0 RNDXR to type of the bounds (ie, int) - word 1 Current file descriptor index - word 2 low bound - word 3 high bound (or -1 if []) - word 4 stride size in bits. */ + store 5 successive words in the aux. table: + word 0 RNDXR to type of the bounds (ie, int) + word 1 Current file descriptor index + word 2 low bound + word 3 high bound (or -1 if []) + word 4 stride size in bits. */ for (i = 0; i < 7; i++) { if (qualifiers[i].type == tqArray) @@ -1452,10 +1381,9 @@ ecoff_type_to_string (abfd, fdr, indx) /* Return information about ECOFF symbol SYMBOL in RET. */ void -_bfd_ecoff_get_symbol_info (abfd, symbol, ret) - bfd *abfd ATTRIBUTE_UNUSED; - asymbol *symbol; - symbol_info *ret; +_bfd_ecoff_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED, + asymbol *symbol, + symbol_info *ret) { bfd_symbol_info (symbol, ret); } @@ -1463,9 +1391,8 @@ _bfd_ecoff_get_symbol_info (abfd, symbol, ret) /* Return whether this is a local label. */ bfd_boolean -_bfd_ecoff_bfd_is_local_label_name (abfd, name) - bfd *abfd ATTRIBUTE_UNUSED; - const char *name; +_bfd_ecoff_bfd_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED, + const char *name) { return name[0] == '$'; } @@ -1473,11 +1400,10 @@ _bfd_ecoff_bfd_is_local_label_name (abfd, name) /* Print information about an ECOFF symbol. */ void -_bfd_ecoff_print_symbol (abfd, filep, symbol, how) - bfd *abfd; - PTR filep; - asymbol *symbol; - bfd_print_symbol_type how; +_bfd_ecoff_print_symbol (bfd *abfd, + void * filep, + asymbol *symbol, + bfd_print_symbol_type how) { const struct ecoff_debug_swap * const debug_swap = &ecoff_backend (abfd)->debug_swap; @@ -1618,6 +1544,7 @@ _bfd_ecoff_print_symbol (abfd, filep, symbol, how) if (ECOFF_IS_STAB (&ecoff_ext.asym)) ; else if (ecoffsymbol (symbol)->local) + /* xgettext:c-format */ fprintf (file, _("\n End+1 symbol: %-7ld Type: %s"), ((long) (AUX_GET_ISYM (bigendian, @@ -1662,10 +1589,9 @@ _bfd_ecoff_print_symbol (abfd, filep, symbol, how) /* Read in the relocs for a section. */ static bfd_boolean -ecoff_slurp_reloc_table (abfd, section, symbols) - bfd *abfd; - asection *section; - asymbol **symbols; +ecoff_slurp_reloc_table (bfd *abfd, + asection *section, + asymbol **symbols) { const struct ecoff_backend_data * const backend = ecoff_backend (abfd); arelent *internal_relocs; @@ -1675,7 +1601,7 @@ ecoff_slurp_reloc_table (abfd, section, symbols) arelent *rptr; unsigned int i; - if (section->relocation != (arelent *) NULL + if (section->relocation != NULL || section->reloc_count == 0 || (section->flags & SEC_CONSTRUCTOR) != 0) return TRUE; @@ -1690,8 +1616,7 @@ ecoff_slurp_reloc_table (abfd, section, symbols) external_reloc_size = backend->external_reloc_size; amt = external_reloc_size * section->reloc_count; external_relocs = (char *) bfd_alloc (abfd, amt); - if (internal_relocs == (arelent *) NULL - || external_relocs == (char *) NULL) + if (internal_relocs == NULL || external_relocs == NULL) return FALSE; if (bfd_seek (abfd, section->rel_filepos, SEEK_SET) != 0) return FALSE; @@ -1730,32 +1655,32 @@ ecoff_slurp_reloc_table (abfd, section, symbols) /* r_symndx is a section key. */ switch (intern.r_symndx) { - case RELOC_SECTION_TEXT: sec_name = ".text"; break; - case RELOC_SECTION_RDATA: sec_name = ".rdata"; break; - case RELOC_SECTION_DATA: sec_name = ".data"; break; - case RELOC_SECTION_SDATA: sec_name = ".sdata"; break; - case RELOC_SECTION_SBSS: sec_name = ".sbss"; break; - case RELOC_SECTION_BSS: sec_name = ".bss"; break; - case RELOC_SECTION_INIT: sec_name = ".init"; break; - case RELOC_SECTION_LIT8: sec_name = ".lit8"; break; - case RELOC_SECTION_LIT4: sec_name = ".lit4"; break; - case RELOC_SECTION_XDATA: sec_name = ".xdata"; break; - case RELOC_SECTION_PDATA: sec_name = ".pdata"; break; - case RELOC_SECTION_FINI: sec_name = ".fini"; break; - case RELOC_SECTION_LITA: sec_name = ".lita"; break; - case RELOC_SECTION_RCONST: sec_name = ".rconst"; break; + case RELOC_SECTION_TEXT: sec_name = _TEXT; break; + case RELOC_SECTION_RDATA: sec_name = _RDATA; break; + case RELOC_SECTION_DATA: sec_name = _DATA; break; + case RELOC_SECTION_SDATA: sec_name = _SDATA; break; + case RELOC_SECTION_SBSS: sec_name = _SBSS; break; + case RELOC_SECTION_BSS: sec_name = _BSS; break; + case RELOC_SECTION_INIT: sec_name = _INIT; break; + case RELOC_SECTION_LIT8: sec_name = _LIT8; break; + case RELOC_SECTION_LIT4: sec_name = _LIT4; break; + case RELOC_SECTION_XDATA: sec_name = _XDATA; break; + case RELOC_SECTION_PDATA: sec_name = _PDATA; break; + case RELOC_SECTION_FINI: sec_name = _FINI; break; + case RELOC_SECTION_LITA: sec_name = _LITA; break; + case RELOC_SECTION_RCONST: sec_name = _RCONST; break; default: abort (); } sec = bfd_get_section_by_name (abfd, sec_name); - if (sec == (asection *) NULL) + if (sec == NULL) abort (); rptr->sym_ptr_ptr = sec->symbol_ptr_ptr; - rptr->addend = - bfd_get_section_vma (abfd, sec); + rptr->addend = - bfd_section_vma (sec); } - rptr->address = intern.r_vaddr - bfd_get_section_vma (abfd, section); + rptr->address = intern.r_vaddr - bfd_section_vma (section); /* Let the backend select the howto field and do any other required processing. */ @@ -1772,11 +1697,10 @@ ecoff_slurp_reloc_table (abfd, section, symbols) /* Get a canonical list of relocs. */ long -_bfd_ecoff_canonicalize_reloc (abfd, section, relptr, symbols) - bfd *abfd; - asection *section; - arelent **relptr; - asymbol **symbols; +_bfd_ecoff_canonicalize_reloc (bfd *abfd, + asection *section, + arelent **relptr, + asymbol **symbols) { unsigned int count; @@ -1805,7 +1729,7 @@ _bfd_ecoff_canonicalize_reloc (abfd, section, relptr, symbols) *relptr++ = tblptr++; } - *relptr = (arelent *) NULL; + *relptr = NULL; return section->reloc_count; } @@ -1815,15 +1739,14 @@ _bfd_ecoff_canonicalize_reloc (abfd, section, relptr, symbols) wanted location. */ bfd_boolean -_bfd_ecoff_find_nearest_line (abfd, section, ignore_symbols, offset, - filename_ptr, functionname_ptr, retline_ptr) - bfd *abfd; - asection *section; - asymbol **ignore_symbols ATTRIBUTE_UNUSED; - bfd_vma offset; - const char **filename_ptr; - const char **functionname_ptr; - unsigned int *retline_ptr; +_bfd_ecoff_find_nearest_line (bfd *abfd, + asymbol **symbols ATTRIBUTE_UNUSED, + asection *section, + bfd_vma offset, + const char **filename_ptr, + const char **functionname_ptr, + unsigned int *retline_ptr, + unsigned int *discriminator_ptr) { const struct ecoff_debug_swap * const debug_swap = &ecoff_backend (abfd)->debug_swap; @@ -1831,20 +1754,23 @@ _bfd_ecoff_find_nearest_line (abfd, section, ignore_symbols, offset, struct ecoff_find_line *line_info; /* Make sure we have the FDR's. */ - if (! _bfd_ecoff_slurp_symbolic_info (abfd, (asection *) NULL, debug_info) + if (! _bfd_ecoff_slurp_symbolic_info (abfd, NULL, debug_info) || bfd_get_symcount (abfd) == 0) return FALSE; if (ecoff_data (abfd)->find_line_info == NULL) { bfd_size_type amt = sizeof (struct ecoff_find_line); - ecoff_data (abfd)->find_line_info - = (struct ecoff_find_line *) bfd_zalloc (abfd, amt); + + ecoff_data (abfd)->find_line_info = + (struct ecoff_find_line *) bfd_zalloc (abfd, amt); if (ecoff_data (abfd)->find_line_info == NULL) return FALSE; } - line_info = ecoff_data (abfd)->find_line_info; + if (discriminator_ptr) + *discriminator_ptr = 0; + line_info = ecoff_data (abfd)->find_line_info; return _bfd_ecoff_locate_line (abfd, section, offset, debug_info, debug_swap, line_info, filename_ptr, functionname_ptr, retline_ptr); @@ -1864,13 +1790,11 @@ _bfd_ecoff_find_nearest_line (abfd, section, ignore_symbols, offset, information. */ bfd_boolean -_bfd_ecoff_bfd_copy_private_bfd_data (ibfd, obfd) - bfd *ibfd; - bfd *obfd; +_bfd_ecoff_bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd) { struct ecoff_debug_info *iinfo = &ecoff_data (ibfd)->debug_info; struct ecoff_debug_info *oinfo = &ecoff_data (obfd)->debug_info; - register int i; + int i; asymbol **sym_ptr_ptr; size_t c; bfd_boolean local; @@ -1894,7 +1818,7 @@ _bfd_ecoff_bfd_copy_private_bfd_data (ibfd, obfd) /* If there are no symbols, don't copy any debugging information. */ c = bfd_get_symcount (obfd); sym_ptr_ptr = bfd_get_outsymbols (obfd); - if (c == 0 || sym_ptr_ptr == (asymbol **) NULL) + if (c == 0 || sym_ptr_ptr == NULL) return TRUE; /* See if there are any local symbols. */ @@ -1974,10 +1898,9 @@ _bfd_ecoff_bfd_copy_private_bfd_data (ibfd, obfd) callers ignore the return value. */ bfd_boolean -_bfd_ecoff_set_arch_mach (abfd, arch, machine) - bfd *abfd; - enum bfd_architecture arch; - unsigned long machine; +_bfd_ecoff_set_arch_mach (bfd *abfd, + enum bfd_architecture arch, + unsigned long machine) { bfd_default_set_arch_mach (abfd, arch, machine); return arch == ecoff_backend (abfd)->arch; @@ -1986,9 +1909,8 @@ _bfd_ecoff_set_arch_mach (abfd, arch, machine) /* Get the size of the section headers. */ int -_bfd_ecoff_sizeof_headers (abfd, reloc) - bfd *abfd; - bfd_boolean reloc ATTRIBUTE_UNUSED; +_bfd_ecoff_sizeof_headers (bfd *abfd, + struct bfd_link_info *info ATTRIBUTE_UNUSED) { asection *current; int c; @@ -1996,25 +1918,24 @@ _bfd_ecoff_sizeof_headers (abfd, reloc) c = 0; for (current = abfd->sections; - current != (asection *)NULL; + current != NULL; current = current->next) ++c; ret = (bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd) + c * bfd_coff_scnhsz (abfd)); - return BFD_ALIGN (ret, 16); + return (int) BFD_ALIGN (ret, 16); } /* Get the contents of a section. */ bfd_boolean -_bfd_ecoff_get_section_contents (abfd, section, location, offset, count) - bfd *abfd; - asection *section; - PTR location; - file_ptr offset; - bfd_size_type count; +_bfd_ecoff_get_section_contents (bfd *abfd, + asection *section, + void * location, + file_ptr offset, + bfd_size_type count) { return _bfd_generic_get_section_contents (abfd, section, location, offset, count); @@ -2024,9 +1945,7 @@ _bfd_ecoff_get_section_contents (abfd, section, location, offset, count) called via qsort. */ static int -ecoff_sort_hdrs (arg1, arg2) - const PTR arg1; - const PTR arg2; +ecoff_sort_hdrs (const void * arg1, const void * arg2) { const asection *hdr1 = *(const asection **) arg1; const asection *hdr2 = *(const asection **) arg2; @@ -2053,8 +1972,7 @@ ecoff_sort_hdrs (arg1, arg2) reloc_filepos. */ static bfd_boolean -ecoff_compute_section_file_positions (abfd) - bfd *abfd; +ecoff_compute_section_file_positions (bfd *abfd) { file_ptr sofar, file_sofar; asection **sorted_hdrs; @@ -2066,7 +1984,7 @@ ecoff_compute_section_file_positions (abfd) const bfd_vma round = ecoff_backend (abfd)->round; bfd_size_type amt; - sofar = _bfd_ecoff_sizeof_headers (abfd, FALSE); + sofar = _bfd_ecoff_sizeof_headers (abfd, NULL); file_sofar = sofar; /* Sort the sections by VMA. */ @@ -2092,11 +2010,11 @@ ecoff_compute_section_file_positions (abfd) for (i = 0; i < abfd->section_count; i++) { current = sorted_hdrs[i]; - if (strcmp (current->name, _RDATA) == 0) + if (streq (current->name, _RDATA)) break; if ((current->flags & SEC_CODE) == 0 - && strcmp (current->name, _PDATA) != 0 - && strcmp (current->name, _RCONST) != 0) + && ! streq (current->name, _PDATA) + && ! streq (current->name, _RCONST)) { rdata_in_text = FALSE; break; @@ -2117,8 +2035,8 @@ ecoff_compute_section_file_positions (abfd) supposed to indicate the number of .pdata entries that are really in the section. Each entry is 8 bytes. We store this away in line_filepos before increasing the section size. */ - if (strcmp (current->name, _PDATA) == 0) - current->line_filepos = current->_raw_size / 8; + if (streq (current->name, _PDATA)) + current->line_filepos = current->size / 8; alignment_power = current->alignment_power; @@ -2133,15 +2051,15 @@ ecoff_compute_section_file_positions (abfd) && ! first_data && (current->flags & SEC_CODE) == 0 && (! rdata_in_text - || strcmp (current->name, _RDATA) != 0) - && strcmp (current->name, _PDATA) != 0 - && strcmp (current->name, _RCONST) != 0) + || ! streq (current->name, _RDATA)) + && ! streq (current->name, _PDATA) + && ! streq (current->name, _RCONST)) { sofar = (sofar + round - 1) &~ (round - 1); file_sofar = (file_sofar + round - 1) &~ (round - 1); first_data = FALSE; } - else if (strcmp (current->name, _LIB) == 0) + else if (streq (current->name, _LIB)) { /* On Irix 4, the location of contents of the .lib section from a shared library section is also rounded up to a @@ -2155,8 +2073,8 @@ ecoff_compute_section_file_positions (abfd) && (abfd->flags & D_PAGED) != 0) { /* Skip up to the next page for an unallocated section, such - as the .comment section on the Alpha. This leaves room - for the .bss section. */ + as the .comment section on the Alpha. This leaves room + for the .bss section. */ first_nonalloc = FALSE; sofar = (sofar + round - 1) &~ (round - 1); file_sofar = (file_sofar + round - 1) &~ (round - 1); @@ -2179,16 +2097,16 @@ ecoff_compute_section_file_positions (abfd) if ((current->flags & (SEC_HAS_CONTENTS | SEC_LOAD)) != 0) current->filepos = file_sofar; - sofar += current->_raw_size; + sofar += current->size; if ((current->flags & SEC_HAS_CONTENTS) != 0) - file_sofar += current->_raw_size; + file_sofar += current->size; /* Make sure that this section is of the right size too. */ old_sofar = sofar; sofar = BFD_ALIGN (sofar, 1 << alignment_power); if ((current->flags & SEC_HAS_CONTENTS) != 0) file_sofar = BFD_ALIGN (file_sofar, 1 << alignment_power); - current->_raw_size += sofar - old_sofar; + current->size += sofar - old_sofar; } free (sorted_hdrs); @@ -2204,8 +2122,7 @@ ecoff_compute_section_file_positions (abfd) information. */ static bfd_size_type -ecoff_compute_reloc_file_positions (abfd) - bfd *abfd; +ecoff_compute_reloc_file_positions (bfd *abfd) { const bfd_size_type external_reloc_size = ecoff_backend (abfd)->external_reloc_size; @@ -2225,7 +2142,7 @@ ecoff_compute_reloc_file_positions (abfd) reloc_size = 0; for (current = abfd->sections; - current != (asection *)NULL; + current != NULL; current = current->next) { if (current->reloc_count == 0) @@ -2259,26 +2176,23 @@ ecoff_compute_reloc_file_positions (abfd) /* Set the contents of a section. */ bfd_boolean -_bfd_ecoff_set_section_contents (abfd, section, location, offset, count) - bfd *abfd; - asection *section; - const PTR location; - file_ptr offset; - bfd_size_type count; +_bfd_ecoff_set_section_contents (bfd *abfd, + asection *section, + const void * location, + file_ptr offset, + bfd_size_type count) { file_ptr pos; /* This must be done first, because bfd_set_section_contents is going to set output_has_begun to TRUE. */ - if (! abfd->output_has_begun) - { - if (! ecoff_compute_section_file_positions (abfd)) - return FALSE; - } + if (! abfd->output_has_begun + && ! ecoff_compute_section_file_positions (abfd)) + return FALSE; /* Handle the .lib section specially so that Irix 4 shared libraries work out. See coff_set_section_contents in coffcode.h. */ - if (strcmp (section->name, _LIB) == 0) + if (streq (section->name, _LIB)) { bfd_byte *rec, *recend; @@ -2304,30 +2218,11 @@ _bfd_ecoff_set_section_contents (abfd, section, location, offset, count) return TRUE; } -/* Get the GP value for an ECOFF file. This is a hook used by - nlmconv. */ - -bfd_vma -bfd_ecoff_get_gp_value (abfd) - bfd *abfd; -{ - if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour - || bfd_get_format (abfd) != bfd_object) - { - bfd_set_error (bfd_error_invalid_operation); - return 0; - } - - return ecoff_data (abfd)->gp; -} - /* Set the GP value for an ECOFF file. This is a hook used by the assembler. */ bfd_boolean -bfd_ecoff_set_gp_value (abfd, gp_value) - bfd *abfd; - bfd_vma gp_value; +bfd_ecoff_set_gp_value (bfd *abfd, bfd_vma gp_value) { if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour || bfd_get_format (abfd) != bfd_object) @@ -2345,11 +2240,10 @@ bfd_ecoff_set_gp_value (abfd, gp_value) the assembler. */ bfd_boolean -bfd_ecoff_set_regmasks (abfd, gprmask, fprmask, cprmask) - bfd *abfd; - unsigned long gprmask; - unsigned long fprmask; - unsigned long *cprmask; +bfd_ecoff_set_regmasks (bfd *abfd, + unsigned long gprmask, + unsigned long fprmask, + unsigned long *cprmask) { ecoff_data_type *tdata; @@ -2363,7 +2257,7 @@ bfd_ecoff_set_regmasks (abfd, gprmask, fprmask, cprmask) tdata = ecoff_data (abfd); tdata->gprmask = gprmask; tdata->fprmask = fprmask; - if (cprmask != (unsigned long *) NULL) + if (cprmask != NULL) { int i; @@ -2378,9 +2272,7 @@ bfd_ecoff_set_regmasks (abfd, gprmask, fprmask, cprmask) is passed to bfd_ecoff_debug_externals. */ static bfd_boolean -ecoff_get_extr (sym, esym) - asymbol *sym; - EXTR *esym; +ecoff_get_extr (asymbol *sym, EXTR *esym) { ecoff_symbol_type *ecoff_sym_ptr; bfd *input_bfd; @@ -2421,7 +2313,7 @@ ecoff_get_extr (sym, esym) symbol. */ if ((esym->asym.sc == scUndefined || esym->asym.sc == scSUndefined) - && ! bfd_is_und_section (bfd_get_section (sym))) + && ! bfd_is_und_section (bfd_asymbol_section (sym))) esym->asym.sc = scAbs; /* Adjust the FDR index for the symbol by that used for the input @@ -2432,7 +2324,7 @@ ecoff_get_extr (sym, esym) input_debug = &ecoff_data (input_bfd)->debug_info; BFD_ASSERT (esym->ifd < input_debug->symbolic_header.ifdMax); - if (input_debug->ifdmap != (RFDT *) NULL) + if (input_debug->ifdmap != NULL) esym->ifd = input_debug->ifdmap[esym->ifd]; } @@ -2443,9 +2335,7 @@ ecoff_get_extr (sym, esym) bfd_ecoff_debug_externals. */ static void -ecoff_set_index (sym, indx) - asymbol *sym; - bfd_size_type indx; +ecoff_set_index (asymbol *sym, bfd_size_type indx) { ecoff_set_sym_index (sym, indx); } @@ -2453,8 +2343,7 @@ ecoff_set_index (sym, indx) /* Write out an ECOFF file. */ bfd_boolean -_bfd_ecoff_write_object_contents (abfd) - bfd *abfd; +_bfd_ecoff_write_object_contents (bfd *abfd) { const struct ecoff_backend_data * const backend = ecoff_backend (abfd); const bfd_vma round = backend->round; @@ -2464,11 +2353,9 @@ _bfd_ecoff_write_object_contents (abfd) const bfd_size_type external_hdr_size = backend->debug_swap.external_hdr_size; const bfd_size_type external_reloc_size = backend->external_reloc_size; - void (* const adjust_reloc_out) - PARAMS ((bfd *, const arelent *, struct internal_reloc *)) + void (* const adjust_reloc_out) (bfd *, const arelent *, struct internal_reloc *) = backend->adjust_reloc_out; - void (* const swap_reloc_out) - PARAMS ((bfd *, const struct internal_reloc *, PTR)) + void (* const swap_reloc_out) (bfd *, const struct internal_reloc *, void *) = backend->swap_reloc_out; struct ecoff_debug_info * const debug = &ecoff_data (abfd)->debug_info; HDRR * const symhdr = &debug->symbolic_header; @@ -2482,8 +2369,8 @@ _bfd_ecoff_write_object_contents (abfd) bfd_vma data_start; bfd_boolean set_data_start; bfd_size_type bss_size; - PTR buff = NULL; - PTR reloc_buff = NULL; + void * buff = NULL; + void * reloc_buff = NULL; struct internal_filehdr internal_f; struct internal_aouthdr internal_a; int i; @@ -2494,7 +2381,7 @@ _bfd_ecoff_write_object_contents (abfd) count = 1; for (current = abfd->sections; - current != (asection *)NULL; + current != NULL; current = current->next) { current->target_index = count; @@ -2502,7 +2389,7 @@ _bfd_ecoff_write_object_contents (abfd) } if ((abfd->flags & D_PAGED) != 0) - text_size = _bfd_ecoff_sizeof_headers (abfd, FALSE); + text_size = _bfd_ecoff_sizeof_headers (abfd, NULL); else text_size = 0; text_start = 0; @@ -2518,12 +2405,13 @@ _bfd_ecoff_write_object_contents (abfd) file header, or a.out header. */ { bfd_size_type siz; + siz = scnhsz; if (siz < filhsz) siz = filhsz; if (siz < aoutsz) siz = aoutsz; - buff = (PTR) bfd_malloc (siz); + buff = bfd_malloc (siz); if (buff == NULL) goto error_return; } @@ -2531,8 +2419,9 @@ _bfd_ecoff_write_object_contents (abfd) internal_f.f_nscns = 0; if (bfd_seek (abfd, (file_ptr) (filhsz + aoutsz), SEEK_SET) != 0) goto error_return; + for (current = abfd->sections; - current != (asection *) NULL; + current != NULL; current = current->next) { struct internal_scnhdr section; @@ -2543,14 +2432,14 @@ _bfd_ecoff_write_object_contents (abfd) strncpy (section.s_name, current->name, sizeof section.s_name); /* This seems to be correct for Irix 4 shared libraries. */ - vma = bfd_get_section_vma (abfd, current); - if (strcmp (current->name, _LIB) == 0) + vma = bfd_section_vma (current); + if (streq (current->name, _LIB)) section.s_vaddr = 0; else section.s_vaddr = vma; section.s_paddr = current->lma; - section.s_size = bfd_get_section_size_before_reloc (current); + section.s_size = current->size; /* If this section is unloadable then the scnptr will be 0. */ if ((current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0) @@ -2566,7 +2455,7 @@ _bfd_ecoff_write_object_contents (abfd) want the linker to compute the best size to use, or something. I don't know what happens if the information is not present. */ - if (strcmp (current->name, _PDATA) != 0) + if (! streq (current->name, _PDATA)) section.s_lnnoptr = 0; else { @@ -2582,7 +2471,7 @@ _bfd_ecoff_write_object_contents (abfd) section.s_flags = ecoff_sec_to_styp_flags (current->name, current->flags); - if (bfd_coff_swap_scnhdr_out (abfd, (PTR) §ion, buff) == 0 + if (bfd_coff_swap_scnhdr_out (abfd, (void *) §ion, buff) == 0 || bfd_bwrite (buff, scnhsz, abfd) != scnhsz) goto error_return; @@ -2601,7 +2490,7 @@ _bfd_ecoff_write_object_contents (abfd) || (section.s_flags & STYP_ECOFF_FINI) != 0 || section.s_flags == STYP_RCONST) { - text_size += bfd_get_section_size_before_reloc (current); + text_size += current->size; if (! set_text_start || text_start > vma) { text_start = vma; @@ -2617,7 +2506,7 @@ _bfd_ecoff_write_object_contents (abfd) || section.s_flags == STYP_XDATA || (section.s_flags & STYP_GOT) != 0) { - data_size += bfd_get_section_size_before_reloc (current); + data_size += current->size; if (! set_data_start || data_start > vma) { data_start = vma; @@ -2626,7 +2515,7 @@ _bfd_ecoff_write_object_contents (abfd) } else if ((section.s_flags & STYP_BSS) != 0 || (section.s_flags & STYP_SBSS) != 0) - bss_size += bfd_get_section_size_before_reloc (current); + bss_size += current->size; else if (section.s_flags == 0 || (section.s_flags & STYP_ECOFF_LIB) != 0 || section.s_flags == STYP_COMMENT) @@ -2731,11 +2620,11 @@ _bfd_ecoff_write_object_contents (abfd) if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) goto error_return; - bfd_coff_swap_filehdr_out (abfd, (PTR) &internal_f, buff); + bfd_coff_swap_filehdr_out (abfd, (void *) &internal_f, buff); if (bfd_bwrite (buff, filhsz, abfd) != filhsz) goto error_return; - bfd_coff_swap_aouthdr_out (abfd, (PTR) &internal_a, buff); + bfd_coff_swap_aouthdr_out (abfd, (void *) &internal_a, buff); if (bfd_bwrite (buff, aoutsz, abfd) != aoutsz) goto error_return; @@ -2756,7 +2645,7 @@ _bfd_ecoff_write_object_contents (abfd) /* Write out the relocs. */ for (current = abfd->sections; - current != (asection *) NULL; + current != NULL; current = current->next) { arelent **reloc_ptr_ptr; @@ -2775,6 +2664,7 @@ _bfd_ecoff_write_object_contents (abfd) reloc_ptr_ptr = current->orelocation; reloc_end = reloc_ptr_ptr + current->reloc_count; out_ptr = (char *) reloc_buff; + for (; reloc_ptr_ptr < reloc_end; reloc_ptr_ptr++, out_ptr += external_reloc_size) @@ -2783,13 +2673,17 @@ _bfd_ecoff_write_object_contents (abfd) asymbol *sym; struct internal_reloc in; - memset ((PTR) &in, 0, sizeof in); + memset ((void *) &in, 0, sizeof in); reloc = *reloc_ptr_ptr; sym = *reloc->sym_ptr_ptr; - in.r_vaddr = (reloc->address - + bfd_get_section_vma (abfd, current)); + /* If the howto field has not been initialised then skip this reloc. + This assumes that an error message has been issued elsewhere. */ + if (reloc->howto == NULL) + continue; + + in.r_vaddr = reloc->address + bfd_section_vma (current); in.r_type = reloc->howto->type; if ((sym->flags & BSF_SECTION_SYM) == 0) @@ -2800,46 +2694,48 @@ _bfd_ecoff_write_object_contents (abfd) else { const char *name; - - name = bfd_get_section_name (abfd, bfd_get_section (sym)); - if (strcmp (name, ".text") == 0) - in.r_symndx = RELOC_SECTION_TEXT; - else if (strcmp (name, ".rdata") == 0) - in.r_symndx = RELOC_SECTION_RDATA; - else if (strcmp (name, ".data") == 0) - in.r_symndx = RELOC_SECTION_DATA; - else if (strcmp (name, ".sdata") == 0) - in.r_symndx = RELOC_SECTION_SDATA; - else if (strcmp (name, ".sbss") == 0) - in.r_symndx = RELOC_SECTION_SBSS; - else if (strcmp (name, ".bss") == 0) - in.r_symndx = RELOC_SECTION_BSS; - else if (strcmp (name, ".init") == 0) - in.r_symndx = RELOC_SECTION_INIT; - else if (strcmp (name, ".lit8") == 0) - in.r_symndx = RELOC_SECTION_LIT8; - else if (strcmp (name, ".lit4") == 0) - in.r_symndx = RELOC_SECTION_LIT4; - else if (strcmp (name, ".xdata") == 0) - in.r_symndx = RELOC_SECTION_XDATA; - else if (strcmp (name, ".pdata") == 0) - in.r_symndx = RELOC_SECTION_PDATA; - else if (strcmp (name, ".fini") == 0) - in.r_symndx = RELOC_SECTION_FINI; - else if (strcmp (name, ".lita") == 0) - in.r_symndx = RELOC_SECTION_LITA; - else if (strcmp (name, "*ABS*") == 0) - in.r_symndx = RELOC_SECTION_ABS; - else if (strcmp (name, ".rconst") == 0) - in.r_symndx = RELOC_SECTION_RCONST; - else + unsigned int j; + static struct + { + const char * name; + long r_symndx; + } + section_symndx [] = + { + { _TEXT, RELOC_SECTION_TEXT }, + { _RDATA, RELOC_SECTION_RDATA }, + { _DATA, RELOC_SECTION_DATA }, + { _SDATA, RELOC_SECTION_SDATA }, + { _SBSS, RELOC_SECTION_SBSS }, + { _BSS, RELOC_SECTION_BSS }, + { _INIT, RELOC_SECTION_INIT }, + { _LIT8, RELOC_SECTION_LIT8 }, + { _LIT4, RELOC_SECTION_LIT4 }, + { _XDATA, RELOC_SECTION_XDATA }, + { _PDATA, RELOC_SECTION_PDATA }, + { _FINI, RELOC_SECTION_FINI }, + { _LITA, RELOC_SECTION_LITA }, + { "*ABS*", RELOC_SECTION_ABS }, + { _RCONST, RELOC_SECTION_RCONST } + }; + + name = bfd_section_name (bfd_asymbol_section (sym)); + + for (j = 0; j < ARRAY_SIZE (section_symndx); j++) + if (streq (name, section_symndx[j].name)) + { + in.r_symndx = section_symndx[j].r_symndx; + break; + } + + if (j == ARRAY_SIZE (section_symndx)) abort (); in.r_extern = 0; } (*adjust_reloc_out) (abfd, reloc, &in); - (*swap_reloc_out) (abfd, &in, (PTR) out_ptr); + (*swap_reloc_out) (abfd, &in, (void *) out_ptr); } if (bfd_seek (abfd, current->rel_filepos, SEEK_SET) != 0) @@ -2926,19 +2822,19 @@ _bfd_ecoff_write_object_contents (abfd) The Alpha seems to use ________64E[BL]E[BL]_. */ -#define ARMAP_BIG_ENDIAN 'B' -#define ARMAP_LITTLE_ENDIAN 'L' -#define ARMAP_MARKER 'E' -#define ARMAP_START_LENGTH 10 -#define ARMAP_HEADER_MARKER_INDEX 10 -#define ARMAP_HEADER_ENDIAN_INDEX 11 -#define ARMAP_OBJECT_MARKER_INDEX 12 -#define ARMAP_OBJECT_ENDIAN_INDEX 13 -#define ARMAP_END_INDEX 14 -#define ARMAP_END "_ " +#define ARMAP_BIG_ENDIAN 'B' +#define ARMAP_LITTLE_ENDIAN 'L' +#define ARMAP_MARKER 'E' +#define ARMAP_START_LENGTH 10 +#define ARMAP_HEADER_MARKER_INDEX 10 +#define ARMAP_HEADER_ENDIAN_INDEX 11 +#define ARMAP_OBJECT_MARKER_INDEX 12 +#define ARMAP_OBJECT_ENDIAN_INDEX 13 +#define ARMAP_END_INDEX 14 +#define ARMAP_END "_ " /* This is a magic number used in the hashing algorithm. */ -#define ARMAP_HASH_MAGIC 0x9dd68ab5 +#define ARMAP_HASH_MAGIC 0x9dd68ab5 /* This returns the hash value to use for a string. It also sets *REHASH to the rehash adjustment if the first slot is taken. SIZE @@ -2946,11 +2842,10 @@ _bfd_ecoff_write_object_contents (abfd) base 2 of SIZE. */ static unsigned int -ecoff_armap_hash (s, rehash, size, hlog) - const char *s; - unsigned int *rehash; - unsigned int size; - unsigned int hlog; +ecoff_armap_hash (const char *s, + unsigned int *rehash, + unsigned int size, + unsigned int hlog) { unsigned int hash; @@ -2967,8 +2862,7 @@ ecoff_armap_hash (s, rehash, size, hlog) /* Read in the armap. */ bfd_boolean -_bfd_ecoff_slurp_armap (abfd) - bfd *abfd; +_bfd_ecoff_slurp_armap (bfd *abfd) { char nextname[17]; unsigned int i; @@ -2978,12 +2872,12 @@ _bfd_ecoff_slurp_armap (abfd) struct artdata *ardata; unsigned int count; char *raw_ptr; - struct symdef *symdef_ptr; + carsym *symdef_ptr; char *stringbase; bfd_size_type amt; /* Get the name of the first element. */ - i = bfd_bread ((PTR) nextname, (bfd_size_type) 16, abfd); + i = bfd_bread ((void *) nextname, (bfd_size_type) 16, abfd); if (i == 0) return TRUE; if (i != 16) @@ -2997,22 +2891,20 @@ _bfd_ecoff_slurp_armap (abfd) bfd_slurp_armap, but that seems inappropriate since no other target uses this format. Instead, we check directly for a COFF armap. */ - if (strncmp (nextname, "/ ", 16) == 0) + if (CONST_STRNEQ (nextname, "/ ")) return bfd_slurp_armap (abfd); /* See if the first element is an armap. */ - if (strncmp (nextname, ecoff_backend (abfd)->armap_start, - ARMAP_START_LENGTH) != 0 + if (! strneq (nextname, ecoff_backend (abfd)->armap_start, ARMAP_START_LENGTH) || nextname[ARMAP_HEADER_MARKER_INDEX] != ARMAP_MARKER || (nextname[ARMAP_HEADER_ENDIAN_INDEX] != ARMAP_BIG_ENDIAN && nextname[ARMAP_HEADER_ENDIAN_INDEX] != ARMAP_LITTLE_ENDIAN) || nextname[ARMAP_OBJECT_MARKER_INDEX] != ARMAP_MARKER || (nextname[ARMAP_OBJECT_ENDIAN_INDEX] != ARMAP_BIG_ENDIAN && nextname[ARMAP_OBJECT_ENDIAN_INDEX] != ARMAP_LITTLE_ENDIAN) - || strncmp (nextname + ARMAP_END_INDEX, - ARMAP_END, sizeof ARMAP_END - 1) != 0) + || ! strneq (nextname + ARMAP_END_INDEX, ARMAP_END, sizeof ARMAP_END - 1)) { - bfd_has_map (abfd) = FALSE; + abfd->has_armap = FALSE; return TRUE; } @@ -3029,29 +2921,29 @@ _bfd_ecoff_slurp_armap (abfd) /* Read in the armap. */ ardata = bfd_ardata (abfd); mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd); - if (mapdata == (struct areltdata *) NULL) + if (mapdata == NULL) return FALSE; parsed_size = mapdata->parsed_size; - bfd_release (abfd, (PTR) mapdata); + free (mapdata); raw_armap = (char *) bfd_alloc (abfd, parsed_size); - if (raw_armap == (char *) NULL) + if (raw_armap == NULL) return FALSE; - if (bfd_bread ((PTR) raw_armap, parsed_size, abfd) != parsed_size) + if (bfd_bread ((void *) raw_armap, parsed_size, abfd) != parsed_size) { if (bfd_get_error () != bfd_error_system_call) bfd_set_error (bfd_error_malformed_archive); - bfd_release (abfd, (PTR) raw_armap); + bfd_release (abfd, (void *) raw_armap); return FALSE; } - ardata->tdata = (PTR) raw_armap; + ardata->tdata = (void *) raw_armap; count = H_GET_32 (abfd, raw_armap); ardata->symdef_count = 0; - ardata->cache = (struct ar_cache *) NULL; + ardata->cache = NULL; /* This code used to overlay the symdefs over the raw archive data, but that doesn't work on a 64 bit host. */ @@ -3100,12 +2992,12 @@ _bfd_ecoff_slurp_armap (abfd) ++ardata->symdef_count; amt = ardata->symdef_count; - amt *= sizeof (struct symdef); - symdef_ptr = (struct symdef *) bfd_alloc (abfd, amt); + amt *= sizeof (carsym); + symdef_ptr = (carsym *) bfd_alloc (abfd, amt); if (!symdef_ptr) return FALSE; - ardata->symdefs = (carsym *) symdef_ptr; + ardata->symdefs = symdef_ptr; raw_ptr = raw_armap + 4; for (i = 0; i < count; i++, raw_ptr += 8) @@ -3116,7 +3008,7 @@ _bfd_ecoff_slurp_armap (abfd) if (file_offset == 0) continue; name_offset = H_GET_32 (abfd, raw_ptr); - symdef_ptr->s.name = stringbase + name_offset; + symdef_ptr->name = stringbase + name_offset; symdef_ptr->file_offset = file_offset; ++symdef_ptr; } @@ -3125,7 +3017,7 @@ _bfd_ecoff_slurp_armap (abfd) /* Pad to an even boundary. */ ardata->first_file_filepos += ardata->first_file_filepos % 2; - bfd_has_map (abfd) = TRUE; + abfd->has_armap = TRUE; return TRUE; } @@ -3133,12 +3025,11 @@ _bfd_ecoff_slurp_armap (abfd) /* Write out an armap. */ bfd_boolean -_bfd_ecoff_write_armap (abfd, elength, map, orl_count, stridx) - bfd *abfd; - unsigned int elength; - struct orl *map; - unsigned int orl_count; - int stridx; +_bfd_ecoff_write_armap (bfd *abfd, + unsigned int elength, + struct orl *map, + unsigned int orl_count, + int stridx) { unsigned int hashsize, hashlog; bfd_size_type symdefsize; @@ -3169,7 +3060,7 @@ _bfd_ecoff_write_armap (abfd, elength, map, orl_count, stridx) firstreal = SARMAG + sizeof (struct ar_hdr) + mapsize + elength; - memset ((PTR) &hdr, 0, sizeof hdr); + memset ((void *) &hdr, 0, sizeof hdr); /* Work out the ECOFF armap name. */ strcpy (hdr.ar_name, ecoff_backend (abfd)->armap_start); @@ -3189,22 +3080,19 @@ _bfd_ecoff_write_armap (abfd, elength, map, orl_count, stridx) linker just checks the archive name; the GNU linker may check the date. */ stat (abfd->filename, &statbuf); - sprintf (hdr.ar_date, "%ld", (long) (statbuf.st_mtime + 60)); + _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld", + (long) (statbuf.st_mtime + 60)); /* The DECstation uses zeroes for the uid, gid and mode of the armap. */ hdr.ar_uid[0] = '0'; hdr.ar_gid[0] = '0'; -#if 0 - hdr.ar_mode[0] = '0'; -#else /* Building gcc ends up extracting the armap as a file - twice. */ hdr.ar_mode[0] = '6'; hdr.ar_mode[1] = '4'; hdr.ar_mode[2] = '4'; -#endif - sprintf (hdr.ar_size, "%-10d", (int) mapsize); + _bfd_ar_spacepad (hdr.ar_size, sizeof (hdr.ar_size), "%-10ld", mapsize); hdr.ar_fmag[0] = '`'; hdr.ar_fmag[1] = '\012'; @@ -3214,12 +3102,12 @@ _bfd_ecoff_write_armap (abfd, elength, map, orl_count, stridx) if (((char *) (&hdr))[i] == '\0') (((char *) (&hdr))[i]) = ' '; - if (bfd_bwrite ((PTR) &hdr, (bfd_size_type) sizeof (struct ar_hdr), abfd) + if (bfd_bwrite ((void *) &hdr, (bfd_size_type) sizeof (struct ar_hdr), abfd) != sizeof (struct ar_hdr)) return FALSE; H_PUT_32 (abfd, hashsize, temp); - if (bfd_bwrite ((PTR) temp, (bfd_size_type) 4, abfd) != 4) + if (bfd_bwrite ((void *) temp, (bfd_size_type) 4, abfd) != 4) return FALSE; hashtable = (bfd_byte *) bfd_zalloc (abfd, symdefsize); @@ -3230,7 +3118,7 @@ _bfd_ecoff_write_armap (abfd, elength, map, orl_count, stridx) last_elt = current; for (i = 0; i < orl_count; i++) { - unsigned int hash, rehash; + unsigned int hash, rehash = 0; /* Advance firstreal to the file position of this archive element. */ @@ -3240,7 +3128,7 @@ _bfd_ecoff_write_armap (abfd, elength, map, orl_count, stridx) { firstreal += arelt_size (current) + sizeof (struct ar_hdr); firstreal += firstreal % 2; - current = current->next; + current = current->archive_next; } while (current != map[i].u.abfd); } @@ -3268,21 +3156,21 @@ _bfd_ecoff_write_armap (abfd, elength, map, orl_count, stridx) H_PUT_32 (abfd, firstreal, (hashtable + hash * 8 + 4)); } - if (bfd_bwrite ((PTR) hashtable, symdefsize, abfd) != symdefsize) + if (bfd_bwrite ((void *) hashtable, symdefsize, abfd) != symdefsize) return FALSE; bfd_release (abfd, hashtable); /* Now write the strings. */ H_PUT_32 (abfd, stringsize, temp); - if (bfd_bwrite ((PTR) temp, (bfd_size_type) 4, abfd) != 4) + if (bfd_bwrite ((void *) temp, (bfd_size_type) 4, abfd) != 4) return FALSE; for (i = 0; i < orl_count; i++) { bfd_size_type len; len = strlen (*map[i].name) + 1; - if (bfd_bwrite ((PTR) (*map[i].name), len, abfd) != len) + if (bfd_bwrite ((void *) (*map[i].name), len, abfd) != len) return FALSE; } @@ -3296,124 +3184,24 @@ _bfd_ecoff_write_armap (abfd, elength, map, orl_count, stridx) return TRUE; } - -/* See whether this BFD is an archive. If it is, read in the armap - and the extended name table. */ - -const bfd_target * -_bfd_ecoff_archive_p (abfd) - bfd *abfd; -{ - struct artdata *tdata_hold; - char armag[SARMAG + 1]; - bfd_size_type amt; - - if (bfd_bread ((PTR) armag, (bfd_size_type) SARMAG, abfd) != SARMAG) - { - if (bfd_get_error () != bfd_error_system_call) - bfd_set_error (bfd_error_wrong_format); - return (const bfd_target *) NULL; - } - - if (strncmp (armag, ARMAG, SARMAG) != 0) - { - bfd_set_error (bfd_error_wrong_format); - return NULL; - } - - tdata_hold = bfd_ardata (abfd); - - amt = sizeof (struct artdata); - bfd_ardata (abfd) = (struct artdata *) bfd_zalloc (abfd, amt); - if (bfd_ardata (abfd) == (struct artdata *) NULL) - { - bfd_ardata (abfd) = tdata_hold; - return (const bfd_target *) NULL; - } - - bfd_ardata (abfd)->first_file_filepos = SARMAG; - bfd_ardata (abfd)->cache = NULL; - bfd_ardata (abfd)->archive_head = NULL; - bfd_ardata (abfd)->symdefs = NULL; - bfd_ardata (abfd)->extended_names = NULL; - bfd_ardata (abfd)->tdata = NULL; - - if (! _bfd_ecoff_slurp_armap (abfd) - || ! _bfd_ecoff_slurp_extended_name_table (abfd)) - { - bfd_release (abfd, bfd_ardata (abfd)); - bfd_ardata (abfd) = tdata_hold; - return (const bfd_target *) NULL; - } - - if (bfd_has_map (abfd)) - { - bfd *first; - - /* This archive has a map, so we may presume that the contents - are object files. Make sure that if the first file in the - archive can be recognized as an object file, it is for this - target. If not, assume that this is the wrong format. If - the first file is not an object file, somebody is doing - something weird, and we permit it so that ar -t will work. */ - - first = bfd_openr_next_archived_file (abfd, (bfd *) NULL); - if (first != NULL) - { - first->target_defaulted = FALSE; - if (bfd_check_format (first, bfd_object) - && first->xvec != abfd->xvec) - { -#if 0 - /* We ought to close `first' here, but we can't, because - we have no way to remove it from the archive cache. - It's close to impossible to figure out when we can - release bfd_ardata. FIXME. */ - (void) bfd_close (first); - bfd_release (abfd, bfd_ardata (abfd)); -#endif - bfd_set_error (bfd_error_wrong_object_format); - bfd_ardata (abfd) = tdata_hold; - return NULL; - } - /* And we ought to close `first' here too. */ - } - } - - return abfd->xvec; -} /* ECOFF linker code. */ -static struct bfd_hash_entry *ecoff_link_hash_newfunc - PARAMS ((struct bfd_hash_entry *entry, - struct bfd_hash_table *table, - const char *string)); -static bfd_boolean ecoff_link_add_archive_symbols - PARAMS ((bfd *, struct bfd_link_info *)); -static bfd_boolean ecoff_link_check_archive_element - PARAMS ((bfd *, struct bfd_link_info *, bfd_boolean *pneeded)); -static bfd_boolean ecoff_link_add_object_symbols - PARAMS ((bfd *, struct bfd_link_info *)); -static bfd_boolean ecoff_link_add_externals - PARAMS ((bfd *, struct bfd_link_info *, PTR, char *)); - /* Routine to create an entry in an ECOFF link hash table. */ static struct bfd_hash_entry * -ecoff_link_hash_newfunc (entry, table, string) - struct bfd_hash_entry *entry; - struct bfd_hash_table *table; - const char *string; +ecoff_link_hash_newfunc (struct bfd_hash_entry *entry, + struct bfd_hash_table *table, + const char *string) { struct ecoff_link_hash_entry *ret = (struct ecoff_link_hash_entry *) entry; /* Allocate the structure if it has not already been allocated by a subclass. */ - if (ret == (struct ecoff_link_hash_entry *) NULL) + if (ret == NULL) ret = ((struct ecoff_link_hash_entry *) bfd_hash_allocate (table, sizeof (struct ecoff_link_hash_entry))); - if (ret == (struct ecoff_link_hash_entry *) NULL) + if (ret == NULL) return NULL; /* Call the allocation method of the superclass. */ @@ -3429,7 +3217,7 @@ ecoff_link_hash_newfunc (entry, table, string) ret->written = 0; ret->small = 0; } - memset ((PTR) &ret->esym, 0, sizeof ret->esym); + memset ((void *) &ret->esym, 0, sizeof ret->esym); return (struct bfd_hash_entry *) ret; } @@ -3437,8 +3225,7 @@ ecoff_link_hash_newfunc (entry, table, string) /* Create an ECOFF link hash table. */ struct bfd_link_hash_table * -_bfd_ecoff_bfd_link_hash_table_create (abfd) - bfd *abfd; +_bfd_ecoff_bfd_link_hash_table_create (bfd *abfd) { struct ecoff_link_hash_table *ret; bfd_size_type amt = sizeof (struct ecoff_link_hash_table); @@ -3446,11 +3233,12 @@ _bfd_ecoff_bfd_link_hash_table_create (abfd) ret = (struct ecoff_link_hash_table *) bfd_malloc (amt); if (ret == NULL) return NULL; - if (! _bfd_link_hash_table_init (&ret->root, abfd, - ecoff_link_hash_newfunc)) + if (!_bfd_link_hash_table_init (&ret->root, abfd, + ecoff_link_hash_newfunc, + sizeof (struct ecoff_link_hash_entry))) { free (ret); - return (struct bfd_link_hash_table *) NULL; + return NULL; } return &ret->root; } @@ -3461,332 +3249,227 @@ _bfd_ecoff_bfd_link_hash_table_create (abfd) ((struct ecoff_link_hash_entry *) \ bfd_link_hash_lookup (&(table)->root, (string), (create), (copy), (follow))) -/* Traverse an ECOFF link hash table. */ - -#define ecoff_link_hash_traverse(table, func, info) \ - (bfd_link_hash_traverse \ - (&(table)->root, \ - (bfd_boolean (*) PARAMS ((struct bfd_link_hash_entry *, PTR))) (func), \ - (info))) - /* Get the ECOFF link hash table from the info structure. This is just a cast. */ #define ecoff_hash_table(p) ((struct ecoff_link_hash_table *) ((p)->hash)) -/* Given an ECOFF BFD, add symbols to the global hash table as - appropriate. */ - -bfd_boolean -_bfd_ecoff_bfd_link_add_symbols (abfd, info) - bfd *abfd; - struct bfd_link_info *info; -{ - switch (bfd_get_format (abfd)) - { - case bfd_object: - return ecoff_link_add_object_symbols (abfd, info); - case bfd_archive: - return ecoff_link_add_archive_symbols (abfd, info); - default: - bfd_set_error (bfd_error_wrong_format); - return FALSE; - } -} - -/* Add the symbols from an archive file to the global hash table. - This looks through the undefined symbols, looks each one up in the - archive hash table, and adds any associated object file. We do not - use _bfd_generic_link_add_archive_symbols because ECOFF archives - already have a hash table, so there is no reason to construct - another one. */ +/* Add the external symbols of an object file to the global linker + hash table. The external symbols and strings we are passed are + just allocated on the stack, and will be discarded. We must + explicitly save any information we may need later on in the link. + We do not want to read the external symbol information again. */ static bfd_boolean -ecoff_link_add_archive_symbols (abfd, info) - bfd *abfd; - struct bfd_link_info *info; +ecoff_link_add_externals (bfd *abfd, + struct bfd_link_info *info, + void * external_ext, + char *ssext) { const struct ecoff_backend_data * const backend = ecoff_backend (abfd); - const bfd_byte *raw_armap; - struct bfd_link_hash_entry **pundef; - unsigned int armap_count; - unsigned int armap_log; - unsigned int i; - const bfd_byte *hashtable; - const char *stringbase; - - if (! bfd_has_map (abfd)) - { - /* An empty archive is a special case. */ - if (bfd_openr_next_archived_file (abfd, (bfd *) NULL) == NULL) - return TRUE; - bfd_set_error (bfd_error_no_armap); - return FALSE; - } - - /* If we don't have any raw data for this archive, as can happen on - Irix 4.0.5F, we call the generic routine. - FIXME: We should be more clever about this, since someday tdata - may get to something for a generic archive. */ - raw_armap = (const bfd_byte *) bfd_ardata (abfd)->tdata; - if (raw_armap == (bfd_byte *) NULL) - return (_bfd_generic_link_add_archive_symbols - (abfd, info, ecoff_link_check_archive_element)); - - armap_count = H_GET_32 (abfd, raw_armap); + void (* const swap_ext_in) (bfd *, void *, EXTR *) + = backend->debug_swap.swap_ext_in; + bfd_size_type external_ext_size = backend->debug_swap.external_ext_size; + unsigned long ext_count; + struct bfd_link_hash_entry **sym_hash; + char *ext_ptr; + char *ext_end; + bfd_size_type amt; - armap_log = 0; - for (i = 1; i < armap_count; i <<= 1) - armap_log++; - BFD_ASSERT (i == armap_count); + ext_count = ecoff_data (abfd)->debug_info.symbolic_header.iextMax; - hashtable = raw_armap + 4; - stringbase = (const char *) raw_armap + armap_count * 8 + 8; + amt = ext_count; + amt *= sizeof (struct bfd_link_hash_entry *); + sym_hash = (struct bfd_link_hash_entry **) bfd_alloc (abfd, amt); + if (!sym_hash) + return FALSE; + ecoff_data (abfd)->sym_hashes = (struct ecoff_link_hash_entry **) sym_hash; - /* Look through the list of undefined symbols. */ - pundef = &info->hash->undefs; - while (*pundef != (struct bfd_link_hash_entry *) NULL) + ext_ptr = (char *) external_ext; + ext_end = ext_ptr + ext_count * external_ext_size; + for (; ext_ptr < ext_end; ext_ptr += external_ext_size, sym_hash++) { - struct bfd_link_hash_entry *h; - unsigned int hash, rehash; - unsigned int file_offset; + EXTR esym; + bfd_boolean skip; + bfd_vma value; + asection *section; const char *name; - bfd *element; + struct ecoff_link_hash_entry *h; - h = *pundef; + *sym_hash = NULL; - /* When a symbol is defined, it is not necessarily removed from - the list. */ - if (h->type != bfd_link_hash_undefined - && h->type != bfd_link_hash_common) - { - /* Remove this entry from the list, for general cleanliness - and because we are going to look through the list again - if we search any more libraries. We can't remove the - entry if it is the tail, because that would lose any - entries we add to the list later on. */ - if (*pundef != info->hash->undefs_tail) - *pundef = (*pundef)->und_next; - else - pundef = &(*pundef)->und_next; - continue; - } + (*swap_ext_in) (abfd, (void *) ext_ptr, &esym); - /* Native ECOFF linkers do not pull in archive elements merely - to satisfy common definitions, so neither do we. We leave - them on the list, though, in case we are linking against some - other object format. */ - if (h->type != bfd_link_hash_undefined) + /* Skip debugging symbols. */ + skip = FALSE; + switch (esym.asym.st) { - pundef = &(*pundef)->und_next; - continue; + case stGlobal: + case stStatic: + case stLabel: + case stProc: + case stStaticProc: + break; + default: + skip = TRUE; + break; } - /* Look for this symbol in the archive hash table. */ - hash = ecoff_armap_hash (h->root.string, &rehash, armap_count, - armap_log); - - file_offset = H_GET_32 (abfd, hashtable + (hash * 8) + 4); - if (file_offset == 0) - { - /* Nothing in this slot. */ - pundef = &(*pundef)->und_next; - continue; - } - - name = stringbase + H_GET_32 (abfd, hashtable + (hash * 8)); - if (name[0] != h->root.string[0] - || strcmp (name, h->root.string) != 0) - { - unsigned int srch; - bfd_boolean found; - - /* That was the wrong symbol. Try rehashing. */ - found = FALSE; - for (srch = (hash + rehash) & (armap_count - 1); - srch != hash; - srch = (srch + rehash) & (armap_count - 1)) - { - file_offset = H_GET_32 (abfd, hashtable + (srch * 8) + 4); - if (file_offset == 0) - break; - name = stringbase + H_GET_32 (abfd, hashtable + (srch * 8)); - if (name[0] == h->root.string[0] - && strcmp (name, h->root.string) == 0) - { - found = TRUE; - break; - } - } - - if (! found) - { - pundef = &(*pundef)->und_next; - continue; - } - - hash = srch; - } - - element = (*backend->get_elt_at_filepos) (abfd, (file_ptr) file_offset); - if (element == (bfd *) NULL) - return FALSE; - - if (! bfd_check_format (element, bfd_object)) - return FALSE; - - /* Unlike the generic linker, we know that this element provides - a definition for an undefined symbol and we know that we want - to include it. We don't need to check anything. */ - if (! (*info->callbacks->add_archive_element) (info, element, name)) - return FALSE; - if (! ecoff_link_add_object_symbols (element, info)) - return FALSE; - - pundef = &(*pundef)->und_next; - } - - return TRUE; -} - -/* This is called if we used _bfd_generic_link_add_archive_symbols - because we were not dealing with an ECOFF archive. */ - -static bfd_boolean -ecoff_link_check_archive_element (abfd, info, pneeded) - bfd *abfd; - struct bfd_link_info *info; - bfd_boolean *pneeded; -{ - const struct ecoff_backend_data * const backend = ecoff_backend (abfd); - void (* const swap_ext_in) PARAMS ((bfd *, PTR, EXTR *)) - = backend->debug_swap.swap_ext_in; - HDRR *symhdr; - bfd_size_type external_ext_size; - PTR external_ext = NULL; - bfd_size_type esize; - char *ssext = NULL; - char *ext_ptr; - char *ext_end; - - *pneeded = FALSE; - - if (! ecoff_slurp_symbolic_header (abfd)) - goto error_return; - - /* If there are no symbols, we don't want it. */ - if (bfd_get_symcount (abfd) == 0) - goto successful_return; - - symhdr = &ecoff_data (abfd)->debug_info.symbolic_header; - - /* Read in the external symbols and external strings. */ - external_ext_size = backend->debug_swap.external_ext_size; - esize = symhdr->iextMax * external_ext_size; - external_ext = (PTR) bfd_malloc (esize); - if (external_ext == NULL && esize != 0) - goto error_return; - - if (bfd_seek (abfd, (file_ptr) symhdr->cbExtOffset, SEEK_SET) != 0 - || bfd_bread (external_ext, esize, abfd) != esize) - goto error_return; - - ssext = (char *) bfd_malloc ((bfd_size_type) symhdr->issExtMax); - if (ssext == NULL && symhdr->issExtMax != 0) - goto error_return; - - if (bfd_seek (abfd, (file_ptr) symhdr->cbSsExtOffset, SEEK_SET) != 0 - || (bfd_bread (ssext, (bfd_size_type) symhdr->issExtMax, abfd) - != (bfd_size_type) symhdr->issExtMax)) - goto error_return; - - /* Look through the external symbols to see if they define some - symbol that is currently undefined. */ - ext_ptr = (char *) external_ext; - ext_end = ext_ptr + esize; - for (; ext_ptr < ext_end; ext_ptr += external_ext_size) - { - EXTR esym; - bfd_boolean def; - const char *name; - struct bfd_link_hash_entry *h; - - (*swap_ext_in) (abfd, (PTR) ext_ptr, &esym); - - /* See if this symbol defines something. */ - if (esym.asym.st != stGlobal - && esym.asym.st != stLabel - && esym.asym.st != stProc) - continue; + if (skip) + continue; + /* Get the information for this symbol. */ + value = esym.asym.value; switch (esym.asym.sc) { + default: + case scNil: + case scRegister: + case scCdbLocal: + case scBits: + case scCdbSystem: + case scRegImage: + case scInfo: + case scUserStruct: + case scVar: + case scVarRegister: + case scVariant: + case scBasedVar: + case scXData: + case scPData: + section = NULL; + break; case scText: + section = bfd_make_section_old_way (abfd, _TEXT); + value -= section->vma; + break; case scData: + section = bfd_make_section_old_way (abfd, _DATA); + value -= section->vma; + break; case scBss: + section = bfd_make_section_old_way (abfd, _BSS); + value -= section->vma; + break; case scAbs: + section = bfd_abs_section_ptr; + break; + case scUndefined: + section = bfd_und_section_ptr; + break; case scSData: + section = bfd_make_section_old_way (abfd, _SDATA); + value -= section->vma; + break; case scSBss: + section = bfd_make_section_old_way (abfd, _SBSS); + value -= section->vma; + break; case scRData: + section = bfd_make_section_old_way (abfd, _RDATA); + value -= section->vma; + break; case scCommon: + if (value > ecoff_data (abfd)->gp_size) + { + section = bfd_com_section_ptr; + break; + } + /* Fall through. */ case scSCommon: + if (ecoff_scom_section.name == NULL) + { + /* Initialize the small common section. */ + ecoff_scom_section.name = SCOMMON; + ecoff_scom_section.flags = SEC_IS_COMMON; + ecoff_scom_section.output_section = &ecoff_scom_section; + ecoff_scom_section.symbol = &ecoff_scom_symbol; + ecoff_scom_section.symbol_ptr_ptr = &ecoff_scom_symbol_ptr; + ecoff_scom_symbol.name = SCOMMON; + ecoff_scom_symbol.flags = BSF_SECTION_SYM; + ecoff_scom_symbol.section = &ecoff_scom_section; + ecoff_scom_symbol_ptr = &ecoff_scom_symbol; + } + section = &ecoff_scom_section; + break; + case scSUndefined: + section = bfd_und_section_ptr; + break; case scInit: + section = bfd_make_section_old_way (abfd, _INIT); + value -= section->vma; + break; case scFini: - case scRConst: - def = TRUE; + section = bfd_make_section_old_way (abfd, _FINI); + value -= section->vma; break; - default: - def = FALSE; + case scRConst: + section = bfd_make_section_old_way (abfd, _RCONST); + value -= section->vma; break; } - if (! def) + if (section == NULL) continue; name = ssext + esym.asym.iss; - h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE); - /* Unlike the generic linker, we do not pull in elements because - of common symbols. */ - if (h == (struct bfd_link_hash_entry *) NULL - || h->type != bfd_link_hash_undefined) - continue; + if (! (_bfd_generic_link_add_one_symbol + (info, abfd, name, + (flagword) (esym.weakext ? BSF_WEAK : BSF_GLOBAL), + section, value, NULL, TRUE, TRUE, sym_hash))) + return FALSE; - /* Include this element. */ - if (! (*info->callbacks->add_archive_element) (info, abfd, name)) - goto error_return; - if (! ecoff_link_add_externals (abfd, info, external_ext, ssext)) - goto error_return; + h = (struct ecoff_link_hash_entry *) *sym_hash; + + /* If we are building an ECOFF hash table, save the external + symbol information. */ + if (bfd_get_flavour (info->output_bfd) == bfd_get_flavour (abfd)) + { + if (h->abfd == NULL + || (! bfd_is_und_section (section) + && (! bfd_is_com_section (section) + || (h->root.type != bfd_link_hash_defined + && h->root.type != bfd_link_hash_defweak)))) + { + h->abfd = abfd; + h->esym = esym; + } + + /* Remember whether this symbol was small undefined. */ + if (esym.asym.sc == scSUndefined) + h->small = 1; - *pneeded = TRUE; - goto successful_return; + /* If this symbol was ever small undefined, it needs to wind + up in a GP relative section. We can't control the + section of a defined symbol, but we can control the + section of a common symbol. This case is actually needed + on Ultrix 4.2 to handle the symbol cred in -lckrb. */ + if (h->small + && h->root.type == bfd_link_hash_common + && streq (h->root.u.c.p->section->name, SCOMMON)) + { + h->root.u.c.p->section = bfd_make_section_old_way (abfd, + SCOMMON); + h->root.u.c.p->section->flags = SEC_ALLOC; + if (h->esym.asym.sc == scCommon) + h->esym.asym.sc = scSCommon; + } + } } - successful_return: - if (external_ext != NULL) - free (external_ext); - if (ssext != NULL) - free (ssext); return TRUE; - error_return: - if (external_ext != NULL) - free (external_ext); - if (ssext != NULL) - free (ssext); - return FALSE; } /* Add symbols from an ECOFF object file to the global linker hash table. */ static bfd_boolean -ecoff_link_add_object_symbols (abfd, info) - bfd *abfd; - struct bfd_link_info *info; +ecoff_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info) { HDRR *symhdr; bfd_size_type external_ext_size; - PTR external_ext = NULL; + void * external_ext = NULL; bfd_size_type esize; char *ssext = NULL; bfd_boolean result; @@ -3803,7 +3486,7 @@ ecoff_link_add_object_symbols (abfd, info) /* Read in the external symbols and external strings. */ external_ext_size = ecoff_backend (abfd)->debug_swap.external_ext_size; esize = symhdr->iextMax * external_ext_size; - external_ext = (PTR) bfd_malloc (esize); + external_ext = bfd_malloc (esize); if (external_ext == NULL && esize != 0) goto error_return; @@ -3836,548 +3519,609 @@ ecoff_link_add_object_symbols (abfd, info) return FALSE; } -/* Add the external symbols of an object file to the global linker - hash table. The external symbols and strings we are passed are - just allocated on the stack, and will be discarded. We must - explicitly save any information we may need later on in the link. - We do not want to read the external symbol information again. */ +/* This is called if we used _bfd_generic_link_add_archive_symbols + because we were not dealing with an ECOFF archive. */ static bfd_boolean -ecoff_link_add_externals (abfd, info, external_ext, ssext) - bfd *abfd; - struct bfd_link_info *info; - PTR external_ext; - char *ssext; +ecoff_link_check_archive_element (bfd *abfd, + struct bfd_link_info *info, + struct bfd_link_hash_entry *h, + const char *name, + bfd_boolean *pneeded) { - const struct ecoff_backend_data * const backend = ecoff_backend (abfd); - void (* const swap_ext_in) PARAMS ((bfd *, PTR, EXTR *)) - = backend->debug_swap.swap_ext_in; - bfd_size_type external_ext_size = backend->debug_swap.external_ext_size; - unsigned long ext_count; - struct bfd_link_hash_entry **sym_hash; - char *ext_ptr; - char *ext_end; - bfd_size_type amt; + *pneeded = FALSE; - ext_count = ecoff_data (abfd)->debug_info.symbolic_header.iextMax; + /* Unlike the generic linker, we do not pull in elements because + of common symbols. */ + if (h->type != bfd_link_hash_undefined) + return TRUE; - amt = ext_count; - amt *= sizeof (struct bfd_link_hash_entry *); - sym_hash = (struct bfd_link_hash_entry **) bfd_alloc (abfd, amt); - if (!sym_hash) - return FALSE; - ecoff_data (abfd)->sym_hashes = (struct ecoff_link_hash_entry **) sym_hash; + /* Include this element? */ + if (!(*info->callbacks->add_archive_element) (info, abfd, name, &abfd)) + return TRUE; + *pneeded = TRUE; - ext_ptr = (char *) external_ext; - ext_end = ext_ptr + ext_count * external_ext_size; - for (; ext_ptr < ext_end; ext_ptr += external_ext_size, sym_hash++) - { - EXTR esym; - bfd_boolean skip; - bfd_vma value; - asection *section; - const char *name; - struct ecoff_link_hash_entry *h; + return ecoff_link_add_object_symbols (abfd, info); +} - *sym_hash = NULL; +/* Add the symbols from an archive file to the global hash table. + This looks through the undefined symbols, looks each one up in the + archive hash table, and adds any associated object file. We do not + use _bfd_generic_link_add_archive_symbols because ECOFF archives + already have a hash table, so there is no reason to construct + another one. */ - (*swap_ext_in) (abfd, (PTR) ext_ptr, &esym); +static bfd_boolean +ecoff_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info) +{ + const struct ecoff_backend_data * const backend = ecoff_backend (abfd); + const bfd_byte *raw_armap; + struct bfd_link_hash_entry **pundef; + unsigned int armap_count; + unsigned int armap_log; + unsigned int i; + const bfd_byte *hashtable; + const char *stringbase; - /* Skip debugging symbols. */ - skip = FALSE; - switch (esym.asym.st) + if (! bfd_has_map (abfd)) + { + /* An empty archive is a special case. */ + if (bfd_openr_next_archived_file (abfd, NULL) == NULL) + return TRUE; + bfd_set_error (bfd_error_no_armap); + return FALSE; + } + + /* If we don't have any raw data for this archive, as can happen on + Irix 4.0.5F, we call the generic routine. + FIXME: We should be more clever about this, since someday tdata + may get to something for a generic archive. */ + raw_armap = (const bfd_byte *) bfd_ardata (abfd)->tdata; + if (raw_armap == NULL) + return (_bfd_generic_link_add_archive_symbols + (abfd, info, ecoff_link_check_archive_element)); + + armap_count = H_GET_32 (abfd, raw_armap); + + armap_log = 0; + for (i = 1; i < armap_count; i <<= 1) + armap_log++; + BFD_ASSERT (i == armap_count); + + hashtable = raw_armap + 4; + stringbase = (const char *) raw_armap + armap_count * 8 + 8; + + /* Look through the list of undefined symbols. */ + pundef = &info->hash->undefs; + while (*pundef != NULL) + { + struct bfd_link_hash_entry *h; + unsigned int hash, rehash = 0; + unsigned int file_offset; + const char *name; + bfd *element; + + h = *pundef; + + /* When a symbol is defined, it is not necessarily removed from + the list. */ + if (h->type != bfd_link_hash_undefined + && h->type != bfd_link_hash_common) { - case stGlobal: - case stStatic: - case stLabel: - case stProc: - case stStaticProc: - break; - default: - skip = TRUE; - break; + /* Remove this entry from the list, for general cleanliness + and because we are going to look through the list again + if we search any more libraries. We can't remove the + entry if it is the tail, because that would lose any + entries we add to the list later on. */ + if (*pundef != info->hash->undefs_tail) + *pundef = (*pundef)->u.undef.next; + else + pundef = &(*pundef)->u.undef.next; + continue; } - if (skip) - continue; + /* Native ECOFF linkers do not pull in archive elements merely + to satisfy common definitions, so neither do we. We leave + them on the list, though, in case we are linking against some + other object format. */ + if (h->type != bfd_link_hash_undefined) + { + pundef = &(*pundef)->u.undef.next; + continue; + } - /* Get the information for this symbol. */ - value = esym.asym.value; - switch (esym.asym.sc) + /* Look for this symbol in the archive hash table. */ + hash = ecoff_armap_hash (h->root.string, &rehash, armap_count, + armap_log); + + file_offset = H_GET_32 (abfd, hashtable + (hash * 8) + 4); + if (file_offset == 0) { - default: - case scNil: - case scRegister: - case scCdbLocal: - case scBits: - case scCdbSystem: - case scRegImage: - case scInfo: - case scUserStruct: - case scVar: - case scVarRegister: - case scVariant: - case scBasedVar: - case scXData: - case scPData: - section = NULL; - break; - case scText: - section = bfd_make_section_old_way (abfd, ".text"); - value -= section->vma; - break; - case scData: - section = bfd_make_section_old_way (abfd, ".data"); - value -= section->vma; - break; - case scBss: - section = bfd_make_section_old_way (abfd, ".bss"); - value -= section->vma; - break; - case scAbs: - section = bfd_abs_section_ptr; - break; - case scUndefined: - section = bfd_und_section_ptr; - break; - case scSData: - section = bfd_make_section_old_way (abfd, ".sdata"); - value -= section->vma; - break; - case scSBss: - section = bfd_make_section_old_way (abfd, ".sbss"); - value -= section->vma; - break; - case scRData: - section = bfd_make_section_old_way (abfd, ".rdata"); - value -= section->vma; - break; - case scCommon: - if (value > ecoff_data (abfd)->gp_size) + /* Nothing in this slot. */ + pundef = &(*pundef)->u.undef.next; + continue; + } + + name = stringbase + H_GET_32 (abfd, hashtable + (hash * 8)); + if (name[0] != h->root.string[0] + || ! streq (name, h->root.string)) + { + unsigned int srch; + bfd_boolean found; + + /* That was the wrong symbol. Try rehashing. */ + found = FALSE; + for (srch = (hash + rehash) & (armap_count - 1); + srch != hash; + srch = (srch + rehash) & (armap_count - 1)) { - section = bfd_com_section_ptr; - break; + file_offset = H_GET_32 (abfd, hashtable + (srch * 8) + 4); + if (file_offset == 0) + break; + name = stringbase + H_GET_32 (abfd, hashtable + (srch * 8)); + if (name[0] == h->root.string[0] + && streq (name, h->root.string)) + { + found = TRUE; + break; + } } - /* Fall through. */ - case scSCommon: - if (ecoff_scom_section.name == NULL) + + if (! found) { - /* Initialize the small common section. */ - ecoff_scom_section.name = SCOMMON; - ecoff_scom_section.flags = SEC_IS_COMMON; - ecoff_scom_section.output_section = &ecoff_scom_section; - ecoff_scom_section.symbol = &ecoff_scom_symbol; - ecoff_scom_section.symbol_ptr_ptr = &ecoff_scom_symbol_ptr; - ecoff_scom_symbol.name = SCOMMON; - ecoff_scom_symbol.flags = BSF_SECTION_SYM; - ecoff_scom_symbol.section = &ecoff_scom_section; - ecoff_scom_symbol_ptr = &ecoff_scom_symbol; + pundef = &(*pundef)->u.undef.next; + continue; } - section = &ecoff_scom_section; - break; - case scSUndefined: - section = bfd_und_section_ptr; - break; - case scInit: - section = bfd_make_section_old_way (abfd, ".init"); - value -= section->vma; - break; - case scFini: - section = bfd_make_section_old_way (abfd, ".fini"); - value -= section->vma; - break; - case scRConst: - section = bfd_make_section_old_way (abfd, ".rconst"); - value -= section->vma; - break; + + hash = srch; } - if (section == (asection *) NULL) - continue; + element = (*backend->get_elt_at_filepos) (abfd, (file_ptr) file_offset); + if (element == NULL) + return FALSE; - name = ssext + esym.asym.iss; + if (! bfd_check_format (element, bfd_object)) + return FALSE; - if (! (_bfd_generic_link_add_one_symbol - (info, abfd, name, - (flagword) (esym.weakext ? BSF_WEAK : BSF_GLOBAL), - section, value, (const char *) NULL, TRUE, TRUE, sym_hash))) + /* Unlike the generic linker, we know that this element provides + a definition for an undefined symbol and we know that we want + to include it. We don't need to check anything. */ + if (!(*info->callbacks + ->add_archive_element) (info, element, name, &element)) + return FALSE; + if (! ecoff_link_add_object_symbols (element, info)) return FALSE; - h = (struct ecoff_link_hash_entry *) *sym_hash; + pundef = &(*pundef)->u.undef.next; + } - /* If we are building an ECOFF hash table, save the external - symbol information. */ - if (info->hash->creator->flavour == bfd_get_flavour (abfd)) - { - if (h->abfd == (bfd *) NULL - || (! bfd_is_und_section (section) - && (! bfd_is_com_section (section) - || (h->root.type != bfd_link_hash_defined - && h->root.type != bfd_link_hash_defweak)))) - { - h->abfd = abfd; - h->esym = esym; - } + return TRUE; +} - /* Remember whether this symbol was small undefined. */ - if (esym.asym.sc == scSUndefined) - h->small = 1; +/* Given an ECOFF BFD, add symbols to the global hash table as + appropriate. */ + +bfd_boolean +_bfd_ecoff_bfd_link_add_symbols (bfd *abfd, struct bfd_link_info *info) +{ + switch (bfd_get_format (abfd)) + { + case bfd_object: + return ecoff_link_add_object_symbols (abfd, info); + case bfd_archive: + return ecoff_link_add_archive_symbols (abfd, info); + default: + bfd_set_error (bfd_error_wrong_format); + return FALSE; + } +} + + +/* ECOFF final link routines. */ + +/* Structure used to pass information to ecoff_link_write_external. */ + +struct extsym_info +{ + bfd *abfd; + struct bfd_link_info *info; +}; + +/* Accumulate the debugging information for an input BFD into the + output BFD. This must read in the symbolic information of the + input BFD. */ + +static bfd_boolean +ecoff_final_link_debug_accumulate (bfd *output_bfd, + bfd *input_bfd, + struct bfd_link_info *info, + void * handle) +{ + struct ecoff_debug_info * const debug = &ecoff_data (input_bfd)->debug_info; + const struct ecoff_debug_swap * const swap = + &ecoff_backend (input_bfd)->debug_swap; + HDRR *symhdr = &debug->symbolic_header; + bfd_boolean ret; + +#define READ(ptr, offset, count, size, type) \ + if (symhdr->count == 0) \ + debug->ptr = NULL; \ + else \ + { \ + bfd_size_type amt = (bfd_size_type) size * symhdr->count; \ + debug->ptr = (type) bfd_malloc (amt); \ + if (debug->ptr == NULL) \ + { \ + ret = FALSE; \ + goto return_something; \ + } \ + if (bfd_seek (input_bfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \ + || bfd_bread (debug->ptr, amt, input_bfd) != amt) \ + { \ + ret = FALSE; \ + goto return_something; \ + } \ + } + + /* If raw_syments is not NULL, then the data was already by read by + _bfd_ecoff_slurp_symbolic_info. */ + if (ecoff_data (input_bfd)->raw_syments == NULL) + { + READ (line, cbLineOffset, cbLine, sizeof (unsigned char), + unsigned char *); + READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, void *); + READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, void *); + READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, void *); + READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, void *); + READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext), + union aux_ext *); + READ (ss, cbSsOffset, issMax, sizeof (char), char *); + READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, void *); + READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, void *); + } +#undef READ + + /* We do not read the external strings or the external symbols. */ + + ret = (bfd_ecoff_debug_accumulate + (handle, output_bfd, &ecoff_data (output_bfd)->debug_info, + &ecoff_backend (output_bfd)->debug_swap, + input_bfd, debug, swap, info)); + + return_something: + if (ecoff_data (input_bfd)->raw_syments == NULL) + { + if (debug->line != NULL) + free (debug->line); + if (debug->external_dnr != NULL) + free (debug->external_dnr); + if (debug->external_pdr != NULL) + free (debug->external_pdr); + if (debug->external_sym != NULL) + free (debug->external_sym); + if (debug->external_opt != NULL) + free (debug->external_opt); + if (debug->external_aux != NULL) + free (debug->external_aux); + if (debug->ss != NULL) + free (debug->ss); + if (debug->external_fdr != NULL) + free (debug->external_fdr); + if (debug->external_rfd != NULL) + free (debug->external_rfd); - /* If this symbol was ever small undefined, it needs to wind - up in a GP relative section. We can't control the - section of a defined symbol, but we can control the - section of a common symbol. This case is actually needed - on Ultrix 4.2 to handle the symbol cred in -lckrb. */ - if (h->small - && h->root.type == bfd_link_hash_common - && strcmp (h->root.u.c.p->section->name, SCOMMON) != 0) - { - h->root.u.c.p->section = bfd_make_section_old_way (abfd, - SCOMMON); - h->root.u.c.p->section->flags = SEC_ALLOC; - if (h->esym.asym.sc == scCommon) - h->esym.asym.sc = scSCommon; - } - } + /* Make sure we don't accidentally follow one of these pointers + into freed memory. */ + debug->line = NULL; + debug->external_dnr = NULL; + debug->external_pdr = NULL; + debug->external_sym = NULL; + debug->external_opt = NULL; + debug->external_aux = NULL; + debug->ss = NULL; + debug->external_fdr = NULL; + debug->external_rfd = NULL; } - return TRUE; + return ret; } - -/* ECOFF final link routines. */ - -static bfd_boolean ecoff_final_link_debug_accumulate - PARAMS ((bfd *output_bfd, bfd *input_bfd, struct bfd_link_info *, - PTR handle)); -static bfd_boolean ecoff_link_write_external - PARAMS ((struct ecoff_link_hash_entry *, PTR)); -static bfd_boolean ecoff_indirect_link_order - PARAMS ((bfd *, struct bfd_link_info *, asection *, - struct bfd_link_order *)); -static bfd_boolean ecoff_reloc_link_order - PARAMS ((bfd *, struct bfd_link_info *, asection *, - struct bfd_link_order *)); -/* Structure used to pass information to ecoff_link_write_external. */ +/* Relocate and write an ECOFF section into an ECOFF output file. */ -struct extsym_info +static bfd_boolean +ecoff_indirect_link_order (bfd *output_bfd, + struct bfd_link_info *info, + asection *output_section, + struct bfd_link_order *link_order) { - bfd *abfd; - struct bfd_link_info *info; -}; + asection *input_section; + bfd *input_bfd; + bfd_byte *contents = NULL; + bfd_size_type external_reloc_size; + bfd_size_type external_relocs_size; + void * external_relocs = NULL; -/* ECOFF final link routine. This looks through all the input BFDs - and gathers together all the debugging information, and then - processes all the link order information. This may cause it to - close and reopen some input BFDs; I'll see how bad this is. */ + BFD_ASSERT ((output_section->flags & SEC_HAS_CONTENTS) != 0); -bfd_boolean -_bfd_ecoff_bfd_final_link (abfd, info) - bfd *abfd; - struct bfd_link_info *info; -{ - const struct ecoff_backend_data * const backend = ecoff_backend (abfd); - struct ecoff_debug_info * const debug = &ecoff_data (abfd)->debug_info; - HDRR *symhdr; - PTR handle; - register bfd *input_bfd; - asection *o; - struct bfd_link_order *p; - struct extsym_info einfo; + input_section = link_order->u.indirect.section; + input_bfd = input_section->owner; + if (input_section->size == 0) + return TRUE; - /* We accumulate the debugging information counts in the symbolic - header. */ - symhdr = &debug->symbolic_header; - symhdr->vstamp = 0; - symhdr->ilineMax = 0; - symhdr->cbLine = 0; - symhdr->idnMax = 0; - symhdr->ipdMax = 0; - symhdr->isymMax = 0; - symhdr->ioptMax = 0; - symhdr->iauxMax = 0; - symhdr->issMax = 0; - symhdr->issExtMax = 0; - symhdr->ifdMax = 0; - symhdr->crfd = 0; - symhdr->iextMax = 0; + BFD_ASSERT (input_section->output_section == output_section); + BFD_ASSERT (input_section->output_offset == link_order->offset); + BFD_ASSERT (input_section->size == link_order->size); - /* We accumulate the debugging information itself in the debug_info - structure. */ - debug->line = NULL; - debug->external_dnr = NULL; - debug->external_pdr = NULL; - debug->external_sym = NULL; - debug->external_opt = NULL; - debug->external_aux = NULL; - debug->ss = NULL; - debug->ssext = debug->ssext_end = NULL; - debug->external_fdr = NULL; - debug->external_rfd = NULL; - debug->external_ext = debug->external_ext_end = NULL; + /* Get the section contents. */ + if (!bfd_malloc_and_get_section (input_bfd, input_section, &contents)) + goto error_return; - handle = bfd_ecoff_debug_init (abfd, debug, &backend->debug_swap, info); - if (handle == (PTR) NULL) - return FALSE; + /* Get the relocs. If we are relaxing MIPS code, they will already + have been read in. Otherwise, we read them in now. */ + external_reloc_size = ecoff_backend (input_bfd)->external_reloc_size; + external_relocs_size = external_reloc_size * input_section->reloc_count; - /* Accumulate the debugging symbols from each input BFD. */ - for (input_bfd = info->input_bfds; - input_bfd != (bfd *) NULL; - input_bfd = input_bfd->link_next) - { - bfd_boolean ret; + external_relocs = bfd_malloc (external_relocs_size); + if (external_relocs == NULL && external_relocs_size != 0) + goto error_return; - if (bfd_get_flavour (input_bfd) == bfd_target_ecoff_flavour) - { - /* Arbitrarily set the symbolic header vstamp to the vstamp - of the first object file in the link. */ - if (symhdr->vstamp == 0) - symhdr->vstamp - = ecoff_data (input_bfd)->debug_info.symbolic_header.vstamp; - ret = ecoff_final_link_debug_accumulate (abfd, input_bfd, info, - handle); - } - else - ret = bfd_ecoff_debug_accumulate_other (handle, abfd, - debug, &backend->debug_swap, - input_bfd, info); - if (! ret) - return FALSE; + if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0 + || (bfd_bread (external_relocs, external_relocs_size, input_bfd) + != external_relocs_size)) + goto error_return; - /* Combine the register masks. */ - ecoff_data (abfd)->gprmask |= ecoff_data (input_bfd)->gprmask; - ecoff_data (abfd)->fprmask |= ecoff_data (input_bfd)->fprmask; - ecoff_data (abfd)->cprmask[0] |= ecoff_data (input_bfd)->cprmask[0]; - ecoff_data (abfd)->cprmask[1] |= ecoff_data (input_bfd)->cprmask[1]; - ecoff_data (abfd)->cprmask[2] |= ecoff_data (input_bfd)->cprmask[2]; - ecoff_data (abfd)->cprmask[3] |= ecoff_data (input_bfd)->cprmask[3]; - } + /* Relocate the section contents. */ + if (! ((*ecoff_backend (input_bfd)->relocate_section) + (output_bfd, info, input_bfd, input_section, contents, + external_relocs))) + goto error_return; - /* Write out the external symbols. */ - einfo.abfd = abfd; - einfo.info = info; - ecoff_link_hash_traverse (ecoff_hash_table (info), - ecoff_link_write_external, - (PTR) &einfo); + /* Write out the relocated section. */ + if (! bfd_set_section_contents (output_bfd, + output_section, + contents, + input_section->output_offset, + input_section->size)) + goto error_return; - if (info->relocatable) + /* If we are producing relocatable output, the relocs were + modified, and we write them out now. We use the reloc_count + field of output_section to keep track of the number of relocs we + have output so far. */ + if (bfd_link_relocatable (info)) { - /* We need to make a pass over the link_orders to count up the - number of relocations we will need to output, so that we know - how much space they will take up. */ - for (o = abfd->sections; o != (asection *) NULL; o = o->next) - { - o->reloc_count = 0; - for (p = o->link_order_head; - p != (struct bfd_link_order *) NULL; - p = p->next) - if (p->type == bfd_indirect_link_order) - o->reloc_count += p->u.indirect.section->reloc_count; - else if (p->type == bfd_section_reloc_link_order - || p->type == bfd_symbol_reloc_link_order) - ++o->reloc_count; - } + file_ptr pos = (output_section->rel_filepos + + output_section->reloc_count * external_reloc_size); + if (bfd_seek (output_bfd, pos, SEEK_SET) != 0 + || (bfd_bwrite (external_relocs, external_relocs_size, output_bfd) + != external_relocs_size)) + goto error_return; + output_section->reloc_count += input_section->reloc_count; } - /* Compute the reloc and symbol file positions. */ - ecoff_compute_reloc_file_positions (abfd); + if (contents != NULL) + free (contents); + if (external_relocs != NULL) + free (external_relocs); + return TRUE; - /* Write out the debugging information. */ - if (! bfd_ecoff_write_accumulated_debug (handle, abfd, debug, - &backend->debug_swap, info, - ecoff_data (abfd)->sym_filepos)) - return FALSE; + error_return: + if (contents != NULL) + free (contents); + if (external_relocs != NULL) + free (external_relocs); + return FALSE; +} - bfd_ecoff_debug_free (handle, abfd, debug, &backend->debug_swap, info); +/* Generate a reloc when linking an ECOFF file. This is a reloc + requested by the linker, and does come from any input file. This + is used to build constructor and destructor tables when linking + with -Ur. */ + +static bfd_boolean +ecoff_reloc_link_order (bfd *output_bfd, + struct bfd_link_info *info, + asection *output_section, + struct bfd_link_order *link_order) +{ + enum bfd_link_order_type type; + asection *section; + bfd_vma addend; + arelent rel; + struct internal_reloc in; + bfd_size_type external_reloc_size; + bfd_byte *rbuf; + bfd_boolean ok; + file_ptr pos; + + type = link_order->type; + section = NULL; + addend = link_order->u.reloc.p->addend; + + /* We set up an arelent to pass to the backend adjust_reloc_out + routine. */ + rel.address = link_order->offset; - if (info->relocatable) + rel.howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc); + if (rel.howto == 0) { - /* Now reset the reloc_count field of the sections in the output - BFD to 0, so that we can use them to keep track of how many - relocs we have output thus far. */ - for (o = abfd->sections; o != (asection *) NULL; o = o->next) - o->reloc_count = 0; + bfd_set_error (bfd_error_bad_value); + return FALSE; } - /* Get a value for the GP register. */ - if (ecoff_data (abfd)->gp == 0) + if (type == bfd_section_reloc_link_order) + { + section = link_order->u.reloc.p->u.section; + rel.sym_ptr_ptr = section->symbol_ptr_ptr; + } + else { struct bfd_link_hash_entry *h; - h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE); - if (h != (struct bfd_link_hash_entry *) NULL - && h->type == bfd_link_hash_defined) - ecoff_data (abfd)->gp = (h->u.def.value - + h->u.def.section->output_section->vma - + h->u.def.section->output_offset); - else if (info->relocatable) - { - bfd_vma lo; - - /* Make up a value. */ - lo = (bfd_vma) -1; - for (o = abfd->sections; o != (asection *) NULL; o = o->next) - { - if (o->vma < lo - && (strcmp (o->name, _SBSS) == 0 - || strcmp (o->name, _SDATA) == 0 - || strcmp (o->name, _LIT4) == 0 - || strcmp (o->name, _LIT8) == 0 - || strcmp (o->name, _LITA) == 0)) - lo = o->vma; - } - ecoff_data (abfd)->gp = lo + 0x8000; + /* Treat a reloc against a defined symbol as though it were + actually against the section. */ + h = bfd_wrapped_link_hash_lookup (output_bfd, info, + link_order->u.reloc.p->u.name, + FALSE, FALSE, FALSE); + if (h != NULL + && (h->type == bfd_link_hash_defined + || h->type == bfd_link_hash_defweak)) + { + type = bfd_section_reloc_link_order; + section = h->u.def.section->output_section; + /* It seems that we ought to add the symbol value to the + addend here, but in practice it has already been added + because it was passed to constructor_callback. */ + addend += section->vma + h->u.def.section->output_offset; } else { - /* If the relocate_section function needs to do a reloc - involving the GP value, it should make a reloc_dangerous - callback to warn that GP is not defined. */ + /* We can't set up a reloc against a symbol correctly, + because we have no asymbol structure. Currently no + adjust_reloc_out routine cares. */ + rel.sym_ptr_ptr = NULL; } } - for (o = abfd->sections; o != (asection *) NULL; o = o->next) + /* All ECOFF relocs are in-place. Put the addend into the object + file. */ + + BFD_ASSERT (rel.howto->partial_inplace); + if (addend != 0) { - for (p = o->link_order_head; - p != (struct bfd_link_order *) NULL; - p = p->next) + bfd_size_type size; + bfd_reloc_status_type rstat; + bfd_byte *buf; + + size = bfd_get_reloc_size (rel.howto); + buf = (bfd_byte *) bfd_zmalloc (size); + if (buf == NULL && size != 0) + return FALSE; + rstat = _bfd_relocate_contents (rel.howto, output_bfd, + (bfd_vma) addend, buf); + switch (rstat) { - if (p->type == bfd_indirect_link_order - && (bfd_get_flavour (p->u.indirect.section->owner) - == bfd_target_ecoff_flavour)) - { - if (! ecoff_indirect_link_order (abfd, info, o, p)) - return FALSE; - } - else if (p->type == bfd_section_reloc_link_order - || p->type == bfd_symbol_reloc_link_order) - { - if (! ecoff_reloc_link_order (abfd, info, o, p)) - return FALSE; - } - else - { - if (! _bfd_default_link_order (abfd, info, o, p)) - return FALSE; - } + case bfd_reloc_ok: + break; + default: + case bfd_reloc_outofrange: + abort (); + case bfd_reloc_overflow: + (*info->callbacks->reloc_overflow) + (info, NULL, + (link_order->type == bfd_section_reloc_link_order + ? bfd_section_name (section) + : link_order->u.reloc.p->u.name), + rel.howto->name, addend, NULL, NULL, (bfd_vma) 0); + break; } + ok = bfd_set_section_contents (output_bfd, output_section, (void *) buf, + (file_ptr) link_order->offset, size); + free (buf); + if (! ok) + return FALSE; } - bfd_get_symcount (abfd) = symhdr->iextMax + symhdr->isymMax; + rel.addend = 0; - ecoff_data (abfd)->linker = TRUE; + /* Move the information into an internal_reloc structure. */ + in.r_vaddr = rel.address + bfd_section_vma (output_section); + in.r_type = rel.howto->type; - return TRUE; -} + if (type == bfd_symbol_reloc_link_order) + { + struct ecoff_link_hash_entry *h; -/* Accumulate the debugging information for an input BFD into the - output BFD. This must read in the symbolic information of the - input BFD. */ + h = ((struct ecoff_link_hash_entry *) + bfd_wrapped_link_hash_lookup (output_bfd, info, + link_order->u.reloc.p->u.name, + FALSE, FALSE, TRUE)); + if (h != NULL + && h->indx != -1) + in.r_symndx = h->indx; + else + { + (*info->callbacks->unattached_reloc) + (info, link_order->u.reloc.p->u.name, NULL, NULL, (bfd_vma) 0); + in.r_symndx = 0; + } + in.r_extern = 1; + } + else + { + const char *name; + unsigned int i; + static struct + { + const char * name; + long r_symndx; + } + section_symndx [] = + { + { _TEXT, RELOC_SECTION_TEXT }, + { _RDATA, RELOC_SECTION_RDATA }, + { _DATA, RELOC_SECTION_DATA }, + { _SDATA, RELOC_SECTION_SDATA }, + { _SBSS, RELOC_SECTION_SBSS }, + { _BSS, RELOC_SECTION_BSS }, + { _INIT, RELOC_SECTION_INIT }, + { _LIT8, RELOC_SECTION_LIT8 }, + { _LIT4, RELOC_SECTION_LIT4 }, + { _XDATA, RELOC_SECTION_XDATA }, + { _PDATA, RELOC_SECTION_PDATA }, + { _FINI, RELOC_SECTION_FINI }, + { _LITA, RELOC_SECTION_LITA }, + { "*ABS*", RELOC_SECTION_ABS }, + { _RCONST, RELOC_SECTION_RCONST } + }; + + name = bfd_section_name (section); + + for (i = 0; i < ARRAY_SIZE (section_symndx); i++) + if (streq (name, section_symndx[i].name)) + { + in.r_symndx = section_symndx[i].r_symndx; + break; + } -static bfd_boolean -ecoff_final_link_debug_accumulate (output_bfd, input_bfd, info, handle) - bfd *output_bfd; - bfd *input_bfd; - struct bfd_link_info *info; - PTR handle; -{ - struct ecoff_debug_info * const debug = &ecoff_data (input_bfd)->debug_info; - const struct ecoff_debug_swap * const swap = - &ecoff_backend (input_bfd)->debug_swap; - HDRR *symhdr = &debug->symbolic_header; - bfd_boolean ret; + if (i == ARRAY_SIZE (section_symndx)) + abort (); -#define READ(ptr, offset, count, size, type) \ - if (symhdr->count == 0) \ - debug->ptr = NULL; \ - else \ - { \ - bfd_size_type amt = (bfd_size_type) size * symhdr->count; \ - debug->ptr = (type) bfd_malloc (amt); \ - if (debug->ptr == NULL) \ - { \ - ret = FALSE; \ - goto return_something; \ - } \ - if (bfd_seek (input_bfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \ - || bfd_bread (debug->ptr, amt, input_bfd) != amt) \ - { \ - ret = FALSE; \ - goto return_something; \ - } \ + in.r_extern = 0; } - /* If raw_syments is not NULL, then the data was already by read by - _bfd_ecoff_slurp_symbolic_info. */ - if (ecoff_data (input_bfd)->raw_syments == NULL) - { - READ (line, cbLineOffset, cbLine, sizeof (unsigned char), - unsigned char *); - READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, PTR); - READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, PTR); - READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, PTR); - READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, PTR); - READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext), - union aux_ext *); - READ (ss, cbSsOffset, issMax, sizeof (char), char *); - READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, PTR); - READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, PTR); - } -#undef READ + /* Let the BFD backend adjust the reloc. */ + (*ecoff_backend (output_bfd)->adjust_reloc_out) (output_bfd, &rel, &in); - /* We do not read the external strings or the external symbols. */ + /* Get some memory and swap out the reloc. */ + external_reloc_size = ecoff_backend (output_bfd)->external_reloc_size; + rbuf = (bfd_byte *) bfd_malloc (external_reloc_size); + if (rbuf == NULL) + return FALSE; - ret = (bfd_ecoff_debug_accumulate - (handle, output_bfd, &ecoff_data (output_bfd)->debug_info, - &ecoff_backend (output_bfd)->debug_swap, - input_bfd, debug, swap, info)); + (*ecoff_backend (output_bfd)->swap_reloc_out) (output_bfd, &in, (void *) rbuf); - return_something: - if (ecoff_data (input_bfd)->raw_syments == NULL) - { - if (debug->line != NULL) - free (debug->line); - if (debug->external_dnr != NULL) - free (debug->external_dnr); - if (debug->external_pdr != NULL) - free (debug->external_pdr); - if (debug->external_sym != NULL) - free (debug->external_sym); - if (debug->external_opt != NULL) - free (debug->external_opt); - if (debug->external_aux != NULL) - free (debug->external_aux); - if (debug->ss != NULL) - free (debug->ss); - if (debug->external_fdr != NULL) - free (debug->external_fdr); - if (debug->external_rfd != NULL) - free (debug->external_rfd); + pos = (output_section->rel_filepos + + output_section->reloc_count * external_reloc_size); + ok = (bfd_seek (output_bfd, pos, SEEK_SET) == 0 + && (bfd_bwrite ((void *) rbuf, external_reloc_size, output_bfd) + == external_reloc_size)); - /* Make sure we don't accidentally follow one of these pointers - into freed memory. */ - debug->line = NULL; - debug->external_dnr = NULL; - debug->external_pdr = NULL; - debug->external_sym = NULL; - debug->external_opt = NULL; - debug->external_aux = NULL; - debug->ss = NULL; - debug->external_fdr = NULL; - debug->external_rfd = NULL; - } + if (ok) + ++output_section->reloc_count; - return ret; + free (rbuf); + + return ok; } /* Put out information for an external symbol. These come only from the hash table. */ static bfd_boolean -ecoff_link_write_external (h, data) - struct ecoff_link_hash_entry *h; - PTR data; +ecoff_link_write_external (struct bfd_hash_entry *bh, void * data) { + struct ecoff_link_hash_entry *h = (struct ecoff_link_hash_entry *) bh; struct extsym_info *einfo = (struct extsym_info *) data; bfd *output_bfd = einfo->abfd; bfd_boolean strip; @@ -4405,7 +4149,7 @@ ecoff_link_write_external (h, data) if (strip || h->written) return TRUE; - if (h->abfd == (bfd *) NULL) + if (h->abfd == NULL) { h->esym.jmptbl = 0; h->esym.cobol_main = 0; @@ -4422,33 +4166,38 @@ ecoff_link_write_external (h, data) { asection *output_section; const char *name; + unsigned int i; + static struct + { + const char * name; + int sc; + } + section_storage_classes [] = + { + { _TEXT, scText }, + { _DATA, scData }, + { _SDATA, scSData }, + { _RDATA, scRData }, + { _BSS, scBss }, + { _SBSS, scSBss }, + { _INIT, scInit }, + { _FINI, scFini }, + { _PDATA, scPData }, + { _XDATA, scXData }, + { _RCONST, scRConst } + }; output_section = h->root.u.def.section->output_section; - name = bfd_section_name (output_section->owner, output_section); - - if (strcmp (name, _TEXT) == 0) - h->esym.asym.sc = scText; - else if (strcmp (name, _DATA) == 0) - h->esym.asym.sc = scData; - else if (strcmp (name, _SDATA) == 0) - h->esym.asym.sc = scSData; - else if (strcmp (name, _RDATA) == 0) - h->esym.asym.sc = scRData; - else if (strcmp (name, _BSS) == 0) - h->esym.asym.sc = scBss; - else if (strcmp (name, _SBSS) == 0) - h->esym.asym.sc = scSBss; - else if (strcmp (name, _INIT) == 0) - h->esym.asym.sc = scInit; - else if (strcmp (name, _FINI) == 0) - h->esym.asym.sc = scFini; - else if (strcmp (name, _PDATA) == 0) - h->esym.asym.sc = scPData; - else if (strcmp (name, _XDATA) == 0) - h->esym.asym.sc = scXData; - else if (strcmp (name, _RCONST) == 0) - h->esym.asym.sc = scRConst; - else + name = bfd_section_name (output_section); + + for (i = 0; i < ARRAY_SIZE (section_storage_classes); i++) + if (streq (name, section_storage_classes[i].name)) + { + h->esym.asym.sc = section_storage_classes[i].sc; + break; + } + + if (i == ARRAY_SIZE (section_storage_classes)) h->esym.asym.sc = scAbs; } @@ -4515,315 +4264,202 @@ ecoff_link_write_external (h, data) &h->esym)); } -/* Relocate and write an ECOFF section into an ECOFF output file. */ +/* ECOFF final link routine. This looks through all the input BFDs + and gathers together all the debugging information, and then + processes all the link order information. This may cause it to + close and reopen some input BFDs; I'll see how bad this is. */ -static bfd_boolean -ecoff_indirect_link_order (output_bfd, info, output_section, link_order) - bfd *output_bfd; - struct bfd_link_info *info; - asection *output_section; - struct bfd_link_order *link_order; +bfd_boolean +_bfd_ecoff_bfd_final_link (bfd *abfd, struct bfd_link_info *info) { - asection *input_section; + const struct ecoff_backend_data * const backend = ecoff_backend (abfd); + struct ecoff_debug_info * const debug = &ecoff_data (abfd)->debug_info; + HDRR *symhdr; + void * handle; bfd *input_bfd; - bfd_size_type raw_size; - bfd_size_type cooked_size; - bfd_byte *contents = NULL; - bfd_size_type external_reloc_size; - bfd_size_type external_relocs_size; - PTR external_relocs = NULL; - bfd_size_type amt; - - BFD_ASSERT ((output_section->flags & SEC_HAS_CONTENTS) != 0); - - if (link_order->size == 0) - return TRUE; - - input_section = link_order->u.indirect.section; - input_bfd = input_section->owner; - - raw_size = input_section->_raw_size; - cooked_size = input_section->_cooked_size; - if (cooked_size == 0) - cooked_size = raw_size; - - BFD_ASSERT (input_section->output_section == output_section); - BFD_ASSERT (input_section->output_offset == link_order->offset); - BFD_ASSERT (cooked_size == link_order->size); - - /* Get the section contents. We allocate memory for the larger of - the size before relocating and the size after relocating. */ - amt = raw_size >= cooked_size ? raw_size : cooked_size; - contents = (bfd_byte *) bfd_malloc (amt); - if (contents == NULL && amt != 0) - goto error_return; - - if (! bfd_get_section_contents (input_bfd, input_section, - (PTR) contents, - (file_ptr) 0, raw_size)) - goto error_return; + asection *o; + struct bfd_link_order *p; + struct extsym_info einfo; - /* Get the relocs. If we are relaxing MIPS code, they will already - have been read in. Otherwise, we read them in now. */ - external_reloc_size = ecoff_backend (input_bfd)->external_reloc_size; - external_relocs_size = external_reloc_size * input_section->reloc_count; + /* We accumulate the debugging information counts in the symbolic + header. */ + symhdr = &debug->symbolic_header; + symhdr->vstamp = 0; + symhdr->ilineMax = 0; + symhdr->cbLine = 0; + symhdr->idnMax = 0; + symhdr->ipdMax = 0; + symhdr->isymMax = 0; + symhdr->ioptMax = 0; + symhdr->iauxMax = 0; + symhdr->issMax = 0; + symhdr->issExtMax = 0; + symhdr->ifdMax = 0; + symhdr->crfd = 0; + symhdr->iextMax = 0; - external_relocs = (PTR) bfd_malloc (external_relocs_size); - if (external_relocs == NULL && external_relocs_size != 0) - goto error_return; + /* We accumulate the debugging information itself in the debug_info + structure. */ + debug->line = NULL; + debug->external_dnr = NULL; + debug->external_pdr = NULL; + debug->external_sym = NULL; + debug->external_opt = NULL; + debug->external_aux = NULL; + debug->ss = NULL; + debug->ssext = debug->ssext_end = NULL; + debug->external_fdr = NULL; + debug->external_rfd = NULL; + debug->external_ext = debug->external_ext_end = NULL; - if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0 - || (bfd_bread (external_relocs, external_relocs_size, input_bfd) - != external_relocs_size)) - goto error_return; + handle = bfd_ecoff_debug_init (abfd, debug, &backend->debug_swap, info); + if (handle == NULL) + return FALSE; - /* Relocate the section contents. */ - if (! ((*ecoff_backend (input_bfd)->relocate_section) - (output_bfd, info, input_bfd, input_section, contents, - external_relocs))) - goto error_return; + /* Accumulate the debugging symbols from each input BFD. */ + for (input_bfd = info->input_bfds; + input_bfd != NULL; + input_bfd = input_bfd->link.next) + { + bfd_boolean ret; - /* Write out the relocated section. */ - if (! bfd_set_section_contents (output_bfd, - output_section, - (PTR) contents, - (file_ptr) input_section->output_offset, - cooked_size)) - goto error_return; + if (bfd_get_flavour (input_bfd) == bfd_target_ecoff_flavour) + { + /* Arbitrarily set the symbolic header vstamp to the vstamp + of the first object file in the link. */ + if (symhdr->vstamp == 0) + symhdr->vstamp + = ecoff_data (input_bfd)->debug_info.symbolic_header.vstamp; + ret = ecoff_final_link_debug_accumulate (abfd, input_bfd, info, + handle); + } + else + ret = bfd_ecoff_debug_accumulate_other (handle, abfd, + debug, &backend->debug_swap, + input_bfd, info); + if (! ret) + return FALSE; - /* If we are producing relocatable output, the relocs were - modified, and we write them out now. We use the reloc_count - field of output_section to keep track of the number of relocs we - have output so far. */ - if (info->relocatable) - { - file_ptr pos = (output_section->rel_filepos - + output_section->reloc_count * external_reloc_size); - if (bfd_seek (output_bfd, pos, SEEK_SET) != 0 - || (bfd_bwrite (external_relocs, external_relocs_size, output_bfd) - != external_relocs_size)) - goto error_return; - output_section->reloc_count += input_section->reloc_count; + /* Combine the register masks. */ + ecoff_data (abfd)->gprmask |= ecoff_data (input_bfd)->gprmask; + ecoff_data (abfd)->fprmask |= ecoff_data (input_bfd)->fprmask; + ecoff_data (abfd)->cprmask[0] |= ecoff_data (input_bfd)->cprmask[0]; + ecoff_data (abfd)->cprmask[1] |= ecoff_data (input_bfd)->cprmask[1]; + ecoff_data (abfd)->cprmask[2] |= ecoff_data (input_bfd)->cprmask[2]; + ecoff_data (abfd)->cprmask[3] |= ecoff_data (input_bfd)->cprmask[3]; } - if (contents != NULL) - free (contents); - if (external_relocs != NULL) - free (external_relocs); - return TRUE; - - error_return: - if (contents != NULL) - free (contents); - if (external_relocs != NULL) - free (external_relocs); - return FALSE; -} + /* Write out the external symbols. */ + einfo.abfd = abfd; + einfo.info = info; + bfd_hash_traverse (&info->hash->table, ecoff_link_write_external, &einfo); -/* Generate a reloc when linking an ECOFF file. This is a reloc - requested by the linker, and does come from any input file. This - is used to build constructor and destructor tables when linking - with -Ur. */ + if (bfd_link_relocatable (info)) + { + /* We need to make a pass over the link_orders to count up the + number of relocations we will need to output, so that we know + how much space they will take up. */ + for (o = abfd->sections; o != NULL; o = o->next) + { + o->reloc_count = 0; + for (p = o->map_head.link_order; + p != NULL; + p = p->next) + if (p->type == bfd_indirect_link_order) + o->reloc_count += p->u.indirect.section->reloc_count; + else if (p->type == bfd_section_reloc_link_order + || p->type == bfd_symbol_reloc_link_order) + ++o->reloc_count; + } + } -static bfd_boolean -ecoff_reloc_link_order (output_bfd, info, output_section, link_order) - bfd *output_bfd; - struct bfd_link_info *info; - asection *output_section; - struct bfd_link_order *link_order; -{ - enum bfd_link_order_type type; - asection *section; - bfd_vma addend; - arelent rel; - struct internal_reloc in; - bfd_size_type external_reloc_size; - bfd_byte *rbuf; - bfd_boolean ok; - file_ptr pos; + /* Compute the reloc and symbol file positions. */ + ecoff_compute_reloc_file_positions (abfd); - type = link_order->type; - section = NULL; - addend = link_order->u.reloc.p->addend; + /* Write out the debugging information. */ + if (! bfd_ecoff_write_accumulated_debug (handle, abfd, debug, + &backend->debug_swap, info, + ecoff_data (abfd)->sym_filepos)) + return FALSE; - /* We set up an arelent to pass to the backend adjust_reloc_out - routine. */ - rel.address = link_order->offset; + bfd_ecoff_debug_free (handle, abfd, debug, &backend->debug_swap, info); - rel.howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc); - if (rel.howto == 0) + if (bfd_link_relocatable (info)) { - bfd_set_error (bfd_error_bad_value); - return FALSE; + /* Now reset the reloc_count field of the sections in the output + BFD to 0, so that we can use them to keep track of how many + relocs we have output thus far. */ + for (o = abfd->sections; o != NULL; o = o->next) + o->reloc_count = 0; } - if (type == bfd_section_reloc_link_order) - { - section = link_order->u.reloc.p->u.section; - rel.sym_ptr_ptr = section->symbol_ptr_ptr; - } - else + /* Get a value for the GP register. */ + if (ecoff_data (abfd)->gp == 0) { struct bfd_link_hash_entry *h; - /* Treat a reloc against a defined symbol as though it were - actually against the section. */ - h = bfd_wrapped_link_hash_lookup (output_bfd, info, - link_order->u.reloc.p->u.name, - FALSE, FALSE, FALSE); + h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE); if (h != NULL - && (h->type == bfd_link_hash_defined - || h->type == bfd_link_hash_defweak)) + && h->type == bfd_link_hash_defined) + ecoff_data (abfd)->gp = (h->u.def.value + + h->u.def.section->output_section->vma + + h->u.def.section->output_offset); + else if (bfd_link_relocatable (info)) { - type = bfd_section_reloc_link_order; - section = h->u.def.section->output_section; - /* It seems that we ought to add the symbol value to the - addend here, but in practice it has already been added - because it was passed to constructor_callback. */ - addend += section->vma + h->u.def.section->output_offset; + bfd_vma lo; + + /* Make up a value. */ + lo = (bfd_vma) -1; + for (o = abfd->sections; o != NULL; o = o->next) + { + if (o->vma < lo + && (streq (o->name, _SBSS) + || streq (o->name, _SDATA) + || streq (o->name, _LIT4) + || streq (o->name, _LIT8) + || streq (o->name, _LITA))) + lo = o->vma; + } + ecoff_data (abfd)->gp = lo + 0x8000; } else { - /* We can't set up a reloc against a symbol correctly, - because we have no asymbol structure. Currently no - adjust_reloc_out routine cares. */ - rel.sym_ptr_ptr = (asymbol **) NULL; + /* If the relocate_section function needs to do a reloc + involving the GP value, it should make a reloc_dangerous + callback to warn that GP is not defined. */ } } - /* All ECOFF relocs are in-place. Put the addend into the object - file. */ - - BFD_ASSERT (rel.howto->partial_inplace); - if (addend != 0) + for (o = abfd->sections; o != NULL; o = o->next) { - bfd_size_type size; - bfd_reloc_status_type rstat; - bfd_byte *buf; - - size = bfd_get_reloc_size (rel.howto); - buf = (bfd_byte *) bfd_zmalloc (size); - if (buf == (bfd_byte *) NULL) - return FALSE; - rstat = _bfd_relocate_contents (rel.howto, output_bfd, - (bfd_vma) addend, buf); - switch (rstat) + for (p = o->map_head.link_order; + p != NULL; + p = p->next) { - case bfd_reloc_ok: - break; - default: - case bfd_reloc_outofrange: - abort (); - case bfd_reloc_overflow: - if (! ((*info->callbacks->reloc_overflow) - (info, - (link_order->type == bfd_section_reloc_link_order - ? bfd_section_name (output_bfd, section) - : link_order->u.reloc.p->u.name), - rel.howto->name, addend, (bfd *) NULL, - (asection *) NULL, (bfd_vma) 0))) + if (p->type == bfd_indirect_link_order + && (bfd_get_flavour (p->u.indirect.section->owner) + == bfd_target_ecoff_flavour)) { - free (buf); - return FALSE; + if (! ecoff_indirect_link_order (abfd, info, o, p)) + return FALSE; + } + else if (p->type == bfd_section_reloc_link_order + || p->type == bfd_symbol_reloc_link_order) + { + if (! ecoff_reloc_link_order (abfd, info, o, p)) + return FALSE; + } + else + { + if (! _bfd_default_link_order (abfd, info, o, p)) + return FALSE; } - break; - } - ok = bfd_set_section_contents (output_bfd, output_section, (PTR) buf, - (file_ptr) link_order->offset, size); - free (buf); - if (! ok) - return FALSE; - } - - rel.addend = 0; - - /* Move the information into an internal_reloc structure. */ - in.r_vaddr = (rel.address - + bfd_get_section_vma (output_bfd, output_section)); - in.r_type = rel.howto->type; - - if (type == bfd_symbol_reloc_link_order) - { - struct ecoff_link_hash_entry *h; - - h = ((struct ecoff_link_hash_entry *) - bfd_wrapped_link_hash_lookup (output_bfd, info, - link_order->u.reloc.p->u.name, - FALSE, FALSE, TRUE)); - if (h != (struct ecoff_link_hash_entry *) NULL - && h->indx != -1) - in.r_symndx = h->indx; - else - { - if (! ((*info->callbacks->unattached_reloc) - (info, link_order->u.reloc.p->u.name, (bfd *) NULL, - (asection *) NULL, (bfd_vma) 0))) - return FALSE; - in.r_symndx = 0; } - in.r_extern = 1; - } - else - { - const char *name; - - name = bfd_get_section_name (output_bfd, section); - if (strcmp (name, ".text") == 0) - in.r_symndx = RELOC_SECTION_TEXT; - else if (strcmp (name, ".rdata") == 0) - in.r_symndx = RELOC_SECTION_RDATA; - else if (strcmp (name, ".data") == 0) - in.r_symndx = RELOC_SECTION_DATA; - else if (strcmp (name, ".sdata") == 0) - in.r_symndx = RELOC_SECTION_SDATA; - else if (strcmp (name, ".sbss") == 0) - in.r_symndx = RELOC_SECTION_SBSS; - else if (strcmp (name, ".bss") == 0) - in.r_symndx = RELOC_SECTION_BSS; - else if (strcmp (name, ".init") == 0) - in.r_symndx = RELOC_SECTION_INIT; - else if (strcmp (name, ".lit8") == 0) - in.r_symndx = RELOC_SECTION_LIT8; - else if (strcmp (name, ".lit4") == 0) - in.r_symndx = RELOC_SECTION_LIT4; - else if (strcmp (name, ".xdata") == 0) - in.r_symndx = RELOC_SECTION_XDATA; - else if (strcmp (name, ".pdata") == 0) - in.r_symndx = RELOC_SECTION_PDATA; - else if (strcmp (name, ".fini") == 0) - in.r_symndx = RELOC_SECTION_FINI; - else if (strcmp (name, ".lita") == 0) - in.r_symndx = RELOC_SECTION_LITA; - else if (strcmp (name, "*ABS*") == 0) - in.r_symndx = RELOC_SECTION_ABS; - else if (strcmp (name, ".rconst") == 0) - in.r_symndx = RELOC_SECTION_RCONST; - else - abort (); - in.r_extern = 0; } - /* Let the BFD backend adjust the reloc. */ - (*ecoff_backend (output_bfd)->adjust_reloc_out) (output_bfd, &rel, &in); - - /* Get some memory and swap out the reloc. */ - external_reloc_size = ecoff_backend (output_bfd)->external_reloc_size; - rbuf = (bfd_byte *) bfd_malloc (external_reloc_size); - if (rbuf == (bfd_byte *) NULL) - return FALSE; - - (*ecoff_backend (output_bfd)->swap_reloc_out) (output_bfd, &in, (PTR) rbuf); - - pos = (output_section->rel_filepos - + output_section->reloc_count * external_reloc_size); - ok = (bfd_seek (output_bfd, pos, SEEK_SET) == 0 - && (bfd_bwrite ((PTR) rbuf, external_reloc_size, output_bfd) - == external_reloc_size)); - - if (ok) - ++output_section->reloc_count; + abfd->symcount = symhdr->iextMax + symhdr->isymMax; - free (rbuf); + ecoff_data (abfd)->linker = TRUE; - return ok; + return TRUE; }