X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=bfd%2Fecoff.c;h=4e0e9533b90f8de027fbffa031bca556d2d5565e;hb=862517b6506a76ce9dc0e06b8f1d98577371e3b4;hp=552be6942064168df1efdcdaea4fc86a3caf046c;hpb=68241b2b3f91c517b33a1d234ade7ed834f31f54;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/ecoff.c b/bfd/ecoff.c index 552be69420..4e0e9533b9 100644 --- a/bfd/ecoff.c +++ b/bfd/ecoff.c @@ -1,5 +1,6 @@ /* Generic ECOFF (Extended-COFF) routines. - Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc. + Copyright 1990, 1991, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001 + Free Software Foundation, Inc. Original version by Per Bothner. Full support added by Ian Lance Taylor, ian@cygnus.com. @@ -17,7 +18,7 @@ GNU General Public License for more details. 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., 675 Mass Ave, Cambridge, MA 02139, USA. */ +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "bfd.h" #include "sysdep.h" @@ -25,6 +26,7 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "libbfd.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 some other stuff which we don't want and which conflicts with stuff @@ -45,43 +47,67 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Prototypes for static functions. */ static int ecoff_get_magic PARAMS ((bfd *abfd)); +static long ecoff_sec_to_styp_flags PARAMS ((const char *name, + flagword flags)); static boolean ecoff_slurp_symbolic_header PARAMS ((bfd *abfd)); static boolean ecoff_set_symbol_info PARAMS ((bfd *abfd, SYMR *ecoff_sym, - asymbol *asym, int ext, - asymbol **indirect_ptr_ptr)); -static void ecoff_emit_aggregate PARAMS ((bfd *abfd, char *string, + asymbol *asym, int ext, int weak)); +static void ecoff_emit_aggregate PARAMS ((bfd *abfd, FDR *fdr, + char *string, RNDXR *rndx, long isym, - CONST char *which)); -static char *ecoff_type_to_string PARAMS ((bfd *abfd, union aux_ext *aux_ptr, - unsigned int indx, int bigendian)); + const char *which)); +static char *ecoff_type_to_string PARAMS ((bfd *abfd, FDR *fdr, + unsigned int indx)); static boolean ecoff_slurp_reloc_table PARAMS ((bfd *abfd, asection *section, asymbol **symbols)); -static void ecoff_compute_section_file_positions PARAMS ((bfd *abfd)); +static int ecoff_sort_hdrs PARAMS ((const PTR, const PTR)); +static boolean ecoff_compute_section_file_positions PARAMS ((bfd *abfd)); static bfd_size_type ecoff_compute_reloc_file_positions PARAMS ((bfd *abfd)); static 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 *s, +static unsigned int ecoff_armap_hash PARAMS ((const char *s, unsigned int *rehash, unsigned int size, unsigned int hlog)); /* This stuff is somewhat copied from coffcode.h. */ -static asection bfd_debug_section = { "*DEBUG*" }; +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, + /* vma, lma, _cooked_size, _raw_size, */ + 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, moving_line_filepos, */ + 0, NULL, 0, + /* target_index, used_by_bfd, constructor_chain, owner, */ + 0, NULL, NULL, NULL, + /* symbol, */ + (struct symbol_cache_entry *) NULL, + /* symbol_ptr_ptr, */ + (struct symbol_cache_entry **) NULL, + /* link_order_head, link_order_tail */ + NULL, NULL +}; /* Create an ECOFF object. */ boolean -ecoff_mkobject (abfd) +_bfd_ecoff_mkobject (abfd) bfd *abfd; { - abfd->tdata.ecoff_obj_data = ((struct ecoff_tdata *) - bfd_zalloc (abfd, sizeof (ecoff_data_type))); + bfd_size_type amt = sizeof (ecoff_data_type); + abfd->tdata.ecoff_obj_data = (struct ecoff_tdata *) bfd_zalloc (abfd, amt); if (abfd->tdata.ecoff_obj_data == NULL) - { - bfd_set_error (bfd_error_no_memory); - return false; - } + return false; return true; } @@ -90,7 +116,7 @@ ecoff_mkobject (abfd) specific information. */ PTR -ecoff_mkobject_hook (abfd, filehdr, aouthdr) +_bfd_ecoff_mkobject_hook (abfd, filehdr, aouthdr) bfd *abfd; PTR filehdr; PTR aouthdr; @@ -98,22 +124,14 @@ ecoff_mkobject_hook (abfd, filehdr, aouthdr) struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; struct internal_aouthdr *internal_a = (struct internal_aouthdr *) aouthdr; ecoff_data_type *ecoff; - asection *regsec; - if (ecoff_mkobject (abfd) == false) + if (_bfd_ecoff_mkobject (abfd) == false) return NULL; ecoff = ecoff_data (abfd); ecoff->gp_size = 8; ecoff->sym_filepos = internal_f->f_symptr; - /* Create the .reginfo section to give programs outside BFD a way to - see the information stored in the a.out header. See the comment - in coff/ecoff.h. */ - regsec = bfd_make_section (abfd, REGINFO); - if (regsec == NULL) - return NULL; - if (internal_a != (struct internal_aouthdr *) NULL) { int i; @@ -127,6 +145,8 @@ ecoff_mkobject_hook (abfd, filehdr, aouthdr) ecoff->fprmask = internal_a->fprmask; if (internal_a->magic == ECOFF_AOUT_ZMAGIC) abfd->flags |= D_PAGED; + else + abfd->flags &=~ D_PAGED; } /* It turns out that no special action is required by the MIPS or @@ -138,54 +158,35 @@ ecoff_mkobject_hook (abfd, filehdr, aouthdr) return (PTR) ecoff; } -/* This is a hook needed by SCO COFF, but we have nothing to do. */ - -/*ARGSUSED*/ -asection * -ecoff_make_section_hook (abfd, name) - bfd *abfd; - char *name; -{ - return (asection *) NULL; -} - /* Initialize a new section. */ boolean -ecoff_new_section_hook (abfd, section) - bfd *abfd; +_bfd_ecoff_new_section_hook (abfd, section) + bfd *abfd ATTRIBUTE_UNUSED; asection *section; { - /* For the .pdata section, which has a special meaning on the Alpha, - we set the alignment to 8. We correct this later in - ecoff_compute_section_file_positions. We do this hackery because - we need to know the exact unaligned size of the .pdata section in - order to set the lnnoptr field correctly. */ - if (strcmp (section->name, _PDATA) == 0) - section->alignment_power = 3; - else - section->alignment_power = abfd->xvec->align_power_min; + section->alignment_power = 4; - if (strcmp (section->name, _TEXT) == 0) + 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, _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, REGINFO) == 0) + else if (strcmp (section->name, _LIB) == 0) { - /* Setting SEC_SHARED_LIBRARY should make the linker leave the - section completely alone. */ - section->flags |= (SEC_SHARED_LIBRARY - | SEC_HAS_CONTENTS - | SEC_NEVER_LOAD); - section->_raw_size = sizeof (struct ecoff_reginfo); + /* An Irix 4 shared libary. */ + section->flags |= SEC_COFF_SHARED_LIBRARY; } /* Probably any other section name is SEC_NEVER_LOAD, but I'm @@ -201,7 +202,7 @@ ecoff_new_section_hook (abfd, section) for each target, but there aren't all that many ECOFF targets. */ boolean -ecoff_set_arch_mach_hook (abfd, filehdr) +_bfd_ecoff_set_arch_mach_hook (abfd, filehdr) bfd *abfd; PTR filehdr; { @@ -247,7 +248,7 @@ ecoff_set_arch_mach_hook (abfd, filehdr) } /* Get the magic number to use based on the architecture and machine. - This is the inverse of ecoff_set_arch_mach_hook, above. */ + This is the inverse of _bfd_ecoff_set_arch_mach_hook, above. */ static int ecoff_get_magic (abfd) @@ -278,7 +279,7 @@ ecoff_get_magic (abfd) break; } - return abfd->xvec->byteorder_big_p ? big : little; + return bfd_big_endian (abfd) ? big : little; case bfd_arch_alpha: return ALPHA_MAGIC; @@ -291,9 +292,9 @@ ecoff_get_magic (abfd) /* Get the section s_flags to use for a section. */ -long +static long ecoff_sec_to_styp_flags (name, flags) - CONST char *name; + const char *name; flagword flags; { long styp; @@ -326,9 +327,34 @@ ecoff_sec_to_styp_flags (name, flags) styp = STYP_PDATA; else if (strcmp (name, _XDATA) == 0) styp = STYP_XDATA; - else if (flags & SEC_CODE) + 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) + { + styp = STYP_COMMENT; + flags &=~ SEC_NEVER_LOAD; + } + else if (strcmp (name, _RCONST) == 0) + styp = STYP_RCONST; + else if (flags & SEC_CODE) styp = STYP_TEXT; - else if (flags & SEC_DATA) + else if (flags & SEC_DATA) styp = STYP_DATA; else if (flags & SEC_READONLY) styp = STYP_RDATA; @@ -345,15 +371,17 @@ ecoff_sec_to_styp_flags (name, flags) /* Get the BFD flags to use for a section. */ -/*ARGSUSED*/ -flagword -ecoff_styp_to_sec_flags (abfd, hdr) - bfd *abfd; +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; { struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr; long styp_flags = internal_s->s_flags; - flagword sec_flags=0; + flagword sec_flags = 0; if (styp_flags & STYP_NOLOAD) sec_flags |= SEC_NEVER_LOAD; @@ -362,240 +390,53 @@ ecoff_styp_to_sec_flags (abfd, hdr) actually a shared library section. */ if ((styp_flags & STYP_TEXT) || (styp_flags & STYP_ECOFF_INIT) - || (styp_flags & STYP_ECOFF_FINI)) + || (styp_flags & STYP_ECOFF_FINI) + || (styp_flags & STYP_DYNAMIC) + || (styp_flags & STYP_LIBLIST) + || (styp_flags & STYP_RELDYN) + || styp_flags == STYP_CONFLIC + || (styp_flags & STYP_DYNSTR) + || (styp_flags & STYP_DYNSYM) + || (styp_flags & STYP_HASH)) { if (sec_flags & SEC_NEVER_LOAD) - sec_flags |= SEC_CODE | SEC_SHARED_LIBRARY; + sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY; else sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC; } else if ((styp_flags & STYP_DATA) || (styp_flags & STYP_RDATA) - || (styp_flags & STYP_SDATA)) + || (styp_flags & STYP_SDATA) + || styp_flags == STYP_PDATA + || styp_flags == STYP_XDATA + || (styp_flags & STYP_GOT) + || styp_flags == STYP_RCONST) { if (sec_flags & SEC_NEVER_LOAD) - sec_flags |= SEC_DATA | SEC_SHARED_LIBRARY; + sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY; else sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC; - if (styp_flags & STYP_RDATA) + if ((styp_flags & STYP_RDATA) + || styp_flags == STYP_PDATA + || styp_flags == STYP_RCONST) sec_flags |= SEC_READONLY; } else if ((styp_flags & STYP_BSS) || (styp_flags & STYP_SBSS)) - { - sec_flags |= SEC_ALLOC; - } - else if (styp_flags & STYP_INFO) - { - sec_flags |= SEC_NEVER_LOAD; - } + sec_flags |= SEC_ALLOC; + else if ((styp_flags & STYP_INFO) || styp_flags == STYP_COMMENT) + sec_flags |= SEC_NEVER_LOAD; else if ((styp_flags & STYP_LITA) || (styp_flags & STYP_LIT8) || (styp_flags & STYP_LIT4)) - { - sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC | SEC_READONLY; - } + sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC | SEC_READONLY; + else if (styp_flags & STYP_ECOFF_LIB) + sec_flags |= SEC_COFF_SHARED_LIBRARY; else - { - sec_flags |= SEC_ALLOC | SEC_LOAD; - } - - return sec_flags; -} - -/* Routines to swap auxiliary information in and out. I am assuming - that the auxiliary information format is always going to be target - independent. */ - -/* Swap in a type information record. - BIGEND says whether AUX symbols are big-endian or little-endian; this - info comes from the file header record (fh-fBigendian). */ - -void -ecoff_swap_tir_in (bigend, ext_copy, intern) - int bigend; - struct tir_ext *ext_copy; - TIR *intern; -{ - struct tir_ext ext[1]; - - *ext = *ext_copy; /* Make it reasonable to do in-place. */ - - /* now the fun stuff... */ - if (bigend) { - intern->fBitfield = 0 != (ext->t_bits1[0] & TIR_BITS1_FBITFIELD_BIG); - intern->continued = 0 != (ext->t_bits1[0] & TIR_BITS1_CONTINUED_BIG); - intern->bt = (ext->t_bits1[0] & TIR_BITS1_BT_BIG) - >> TIR_BITS1_BT_SH_BIG; - intern->tq4 = (ext->t_tq45[0] & TIR_BITS_TQ4_BIG) - >> TIR_BITS_TQ4_SH_BIG; - intern->tq5 = (ext->t_tq45[0] & TIR_BITS_TQ5_BIG) - >> TIR_BITS_TQ5_SH_BIG; - intern->tq0 = (ext->t_tq01[0] & TIR_BITS_TQ0_BIG) - >> TIR_BITS_TQ0_SH_BIG; - intern->tq1 = (ext->t_tq01[0] & TIR_BITS_TQ1_BIG) - >> TIR_BITS_TQ1_SH_BIG; - intern->tq2 = (ext->t_tq23[0] & TIR_BITS_TQ2_BIG) - >> TIR_BITS_TQ2_SH_BIG; - intern->tq3 = (ext->t_tq23[0] & TIR_BITS_TQ3_BIG) - >> TIR_BITS_TQ3_SH_BIG; - } else { - intern->fBitfield = 0 != (ext->t_bits1[0] & TIR_BITS1_FBITFIELD_LITTLE); - intern->continued = 0 != (ext->t_bits1[0] & TIR_BITS1_CONTINUED_LITTLE); - intern->bt = (ext->t_bits1[0] & TIR_BITS1_BT_LITTLE) - >> TIR_BITS1_BT_SH_LITTLE; - intern->tq4 = (ext->t_tq45[0] & TIR_BITS_TQ4_LITTLE) - >> TIR_BITS_TQ4_SH_LITTLE; - intern->tq5 = (ext->t_tq45[0] & TIR_BITS_TQ5_LITTLE) - >> TIR_BITS_TQ5_SH_LITTLE; - intern->tq0 = (ext->t_tq01[0] & TIR_BITS_TQ0_LITTLE) - >> TIR_BITS_TQ0_SH_LITTLE; - intern->tq1 = (ext->t_tq01[0] & TIR_BITS_TQ1_LITTLE) - >> TIR_BITS_TQ1_SH_LITTLE; - intern->tq2 = (ext->t_tq23[0] & TIR_BITS_TQ2_LITTLE) - >> TIR_BITS_TQ2_SH_LITTLE; - intern->tq3 = (ext->t_tq23[0] & TIR_BITS_TQ3_LITTLE) - >> TIR_BITS_TQ3_SH_LITTLE; - } - -#ifdef TEST - if (memcmp ((char *)ext, (char *)intern, sizeof (*intern)) != 0) - abort(); -#endif -} - -/* Swap out a type information record. - BIGEND says whether AUX symbols are big-endian or little-endian; this - info comes from the file header record (fh-fBigendian). */ - -void -ecoff_swap_tir_out (bigend, intern_copy, ext) - int bigend; - TIR *intern_copy; - struct tir_ext *ext; -{ - TIR intern[1]; - - *intern = *intern_copy; /* Make it reasonable to do in-place. */ - - /* now the fun stuff... */ - if (bigend) { - ext->t_bits1[0] = ((intern->fBitfield ? TIR_BITS1_FBITFIELD_BIG : 0) - | (intern->continued ? TIR_BITS1_CONTINUED_BIG : 0) - | ((intern->bt << TIR_BITS1_BT_SH_BIG) - & TIR_BITS1_BT_BIG)); - ext->t_tq45[0] = (((intern->tq4 << TIR_BITS_TQ4_SH_BIG) - & TIR_BITS_TQ4_BIG) - | ((intern->tq5 << TIR_BITS_TQ5_SH_BIG) - & TIR_BITS_TQ5_BIG)); - ext->t_tq01[0] = (((intern->tq0 << TIR_BITS_TQ0_SH_BIG) - & TIR_BITS_TQ0_BIG) - | ((intern->tq1 << TIR_BITS_TQ1_SH_BIG) - & TIR_BITS_TQ1_BIG)); - ext->t_tq23[0] = (((intern->tq2 << TIR_BITS_TQ2_SH_BIG) - & TIR_BITS_TQ2_BIG) - | ((intern->tq3 << TIR_BITS_TQ3_SH_BIG) - & TIR_BITS_TQ3_BIG)); - } else { - ext->t_bits1[0] = ((intern->fBitfield ? TIR_BITS1_FBITFIELD_LITTLE : 0) - | (intern->continued ? TIR_BITS1_CONTINUED_LITTLE : 0) - | ((intern->bt << TIR_BITS1_BT_SH_LITTLE) - & TIR_BITS1_BT_LITTLE)); - ext->t_tq45[0] = (((intern->tq4 << TIR_BITS_TQ4_SH_LITTLE) - & TIR_BITS_TQ4_LITTLE) - | ((intern->tq5 << TIR_BITS_TQ5_SH_LITTLE) - & TIR_BITS_TQ5_LITTLE)); - ext->t_tq01[0] = (((intern->tq0 << TIR_BITS_TQ0_SH_LITTLE) - & TIR_BITS_TQ0_LITTLE) - | ((intern->tq1 << TIR_BITS_TQ1_SH_LITTLE) - & TIR_BITS_TQ1_LITTLE)); - ext->t_tq23[0] = (((intern->tq2 << TIR_BITS_TQ2_SH_LITTLE) - & TIR_BITS_TQ2_LITTLE) - | ((intern->tq3 << TIR_BITS_TQ3_SH_LITTLE) - & TIR_BITS_TQ3_LITTLE)); - } - -#ifdef TEST - if (memcmp ((char *)ext, (char *)intern, sizeof (*intern)) != 0) - abort(); -#endif -} - -/* Swap in a relative symbol record. BIGEND says whether it is in - big-endian or little-endian format.*/ - -void -ecoff_swap_rndx_in (bigend, ext_copy, intern) - int bigend; - struct rndx_ext *ext_copy; - RNDXR *intern; -{ - struct rndx_ext ext[1]; - - *ext = *ext_copy; /* Make it reasonable to do in-place. */ - - /* now the fun stuff... */ - if (bigend) { - intern->rfd = (ext->r_bits[0] << RNDX_BITS0_RFD_SH_LEFT_BIG) - | ((ext->r_bits[1] & RNDX_BITS1_RFD_BIG) - >> RNDX_BITS1_RFD_SH_BIG); - intern->index = ((ext->r_bits[1] & RNDX_BITS1_INDEX_BIG) - << RNDX_BITS1_INDEX_SH_LEFT_BIG) - | (ext->r_bits[2] << RNDX_BITS2_INDEX_SH_LEFT_BIG) - | (ext->r_bits[3] << RNDX_BITS3_INDEX_SH_LEFT_BIG); - } else { - intern->rfd = (ext->r_bits[0] << RNDX_BITS0_RFD_SH_LEFT_LITTLE) - | ((ext->r_bits[1] & RNDX_BITS1_RFD_LITTLE) - << RNDX_BITS1_RFD_SH_LEFT_LITTLE); - intern->index = ((ext->r_bits[1] & RNDX_BITS1_INDEX_LITTLE) - >> RNDX_BITS1_INDEX_SH_LITTLE) - | (ext->r_bits[2] << RNDX_BITS2_INDEX_SH_LEFT_LITTLE) - | ((unsigned int) ext->r_bits[3] - << RNDX_BITS3_INDEX_SH_LEFT_LITTLE); - } + sec_flags |= SEC_ALLOC | SEC_LOAD; -#ifdef TEST - if (memcmp ((char *)ext, (char *)intern, sizeof (*intern)) != 0) - abort(); -#endif -} - -/* Swap out a relative symbol record. BIGEND says whether it is in - big-endian or little-endian format.*/ - -void -ecoff_swap_rndx_out (bigend, intern_copy, ext) - int bigend; - RNDXR *intern_copy; - struct rndx_ext *ext; -{ - RNDXR intern[1]; - - *intern = *intern_copy; /* Make it reasonable to do in-place. */ - - /* now the fun stuff... */ - if (bigend) { - ext->r_bits[0] = intern->rfd >> RNDX_BITS0_RFD_SH_LEFT_BIG; - ext->r_bits[1] = (((intern->rfd << RNDX_BITS1_RFD_SH_BIG) - & RNDX_BITS1_RFD_BIG) - | ((intern->index >> RNDX_BITS1_INDEX_SH_LEFT_BIG) - & RNDX_BITS1_INDEX_BIG)); - ext->r_bits[2] = intern->index >> RNDX_BITS2_INDEX_SH_LEFT_BIG; - ext->r_bits[3] = intern->index >> RNDX_BITS3_INDEX_SH_LEFT_BIG; - } else { - ext->r_bits[0] = intern->rfd >> RNDX_BITS0_RFD_SH_LEFT_LITTLE; - ext->r_bits[1] = (((intern->rfd >> RNDX_BITS1_RFD_SH_LEFT_LITTLE) - & RNDX_BITS1_RFD_LITTLE) - | ((intern->index << RNDX_BITS1_INDEX_SH_LITTLE) - & RNDX_BITS1_INDEX_LITTLE)); - ext->r_bits[2] = intern->index >> RNDX_BITS2_INDEX_SH_LEFT_LITTLE; - ext->r_bits[3] = intern->index >> RNDX_BITS3_INDEX_SH_LEFT_LITTLE; - } - -#ifdef TEST - if (memcmp ((char *)ext, (char *)intern, sizeof (*intern)) != 0) - abort(); -#endif + * flags_ptr = sec_flags; + return true; } /* Read in the symbolic header for an ECOFF object file. */ @@ -606,11 +447,11 @@ ecoff_slurp_symbolic_header (abfd) { const struct ecoff_backend_data * const backend = ecoff_backend (abfd); bfd_size_type external_hdr_size; - PTR raw; + PTR raw = NULL; HDRR *internal_symhdr; /* See if we've already read it in. */ - if (ecoff_data (abfd)->debug_info.symbolic_header.magic == + if (ecoff_data (abfd)->debug_info.symbolic_header.magic == backend->debug_swap.sym_magic) return true; @@ -633,36 +474,44 @@ ecoff_slurp_symbolic_header (abfd) } /* Read the symbolic information header. */ - raw = (PTR) alloca ((size_t) external_hdr_size); - if (bfd_seek (abfd, ecoff_data (abfd)->sym_filepos, SEEK_SET) == -1 - || (bfd_read (raw, external_hdr_size, 1, abfd) - != external_hdr_size)) - { - bfd_set_error (bfd_error_system_call); - return false; - } + raw = (PTR) bfd_malloc (external_hdr_size); + if (raw == NULL) + goto error_return; + + if (bfd_seek (abfd, ecoff_data (abfd)->sym_filepos, SEEK_SET) != 0 + || bfd_bread (raw, external_hdr_size, abfd) != external_hdr_size) + goto error_return; internal_symhdr = &ecoff_data (abfd)->debug_info.symbolic_header; (*backend->debug_swap.swap_hdr_in) (abfd, raw, internal_symhdr); if (internal_symhdr->magic != backend->debug_swap.sym_magic) { bfd_set_error (bfd_error_bad_value); - return false; + goto error_return; } /* Now we can get the correct number of symbols. */ bfd_get_symcount (abfd) = (internal_symhdr->isymMax + internal_symhdr->iextMax); + if (raw != NULL) + free (raw); return true; + error_return: + if (raw != NULL) + free (raw); + return false; } /* Read in and swap the important symbolic information for an ECOFF - object file. This is called by gdb. */ + object file. This is called by gdb via the read_debug_info entry + point in the backend structure. */ boolean -ecoff_slurp_symbolic_info (abfd) +_bfd_ecoff_slurp_symbolic_info (abfd, ignore, debug) bfd *abfd; + asection *ignore ATTRIBUTE_UNUSED; + struct ecoff_debug_info *debug; { const struct ecoff_backend_data * const backend = ecoff_backend (abfd); HDRR *internal_symhdr; @@ -675,6 +524,10 @@ ecoff_slurp_symbolic_info (abfd) 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. */ @@ -689,7 +542,7 @@ ecoff_slurp_symbolic_info (abfd) if (! ecoff_slurp_symbolic_header (abfd)) return false; - internal_symhdr = &ecoff_data (abfd)->debug_info.symbolic_header; + internal_symhdr = &debug->symbolic_header; /* Read all the symbolic information at once. */ raw_base = (ecoff_data (abfd)->sym_filepos @@ -730,17 +583,13 @@ ecoff_slurp_symbolic_info (abfd) } raw = (PTR) bfd_alloc (abfd, raw_size); if (raw == NULL) + return false; + + pos = ecoff_data (abfd)->sym_filepos; + pos += backend->debug_swap.external_hdr_size; + if (bfd_seek (abfd, pos, SEEK_SET) != 0 + || bfd_bread (raw, raw_size, abfd) != raw_size) { - bfd_set_error (bfd_error_no_memory); - return false; - } - if (bfd_seek (abfd, - (ecoff_data (abfd)->sym_filepos - + backend->debug_swap.external_hdr_size), - SEEK_SET) != 0 - || bfd_read (raw, raw_size, 1, abfd) != raw_size) - { - bfd_set_error (bfd_error_system_call); bfd_release (abfd, raw); return false; } @@ -750,11 +599,11 @@ ecoff_slurp_symbolic_info (abfd) /* Get pointers for the numeric offsets in the HDRR structure. */ #define FIX(off1, off2, type) \ if (internal_symhdr->off1 == 0) \ - ecoff_data (abfd)->debug_info.off2 = (type) NULL; \ + debug->off2 = (type) NULL; \ else \ - ecoff_data (abfd)->debug_info.off2 = (type) ((char *) raw \ - + internal_symhdr->off1 \ - - raw_base) + 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); @@ -776,18 +625,14 @@ ecoff_slurp_symbolic_info (abfd) We need to look at the fdr to deal with a lot of information in the symbols, so we swap them here. */ - ecoff_data (abfd)->debug_info.fdr = - (struct fdr *) bfd_alloc (abfd, - (internal_symhdr->ifdMax * - sizeof (struct fdr))); - if (ecoff_data (abfd)->debug_info.fdr == NULL) - { - bfd_set_error (bfd_error_no_memory); - return false; - } + amt = internal_symhdr->ifdMax; + amt *= sizeof (struct fdr); + debug->fdr = (struct fdr *) bfd_alloc (abfd, amt); + if (debug->fdr == NULL) + return false; external_fdr_size = backend->debug_swap.external_fdr_size; - fdr_ptr = ecoff_data (abfd)->debug_info.fdr; - fraw_src = (char *) ecoff_data (abfd)->debug_info.external_fdr; + fdr_ptr = debug->fdr; + fraw_src = (char *) debug->external_fdr; 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); @@ -810,17 +655,15 @@ static asymbol *ecoff_scom_symbol_ptr; /* Create an empty symbol. */ asymbol * -ecoff_make_empty_symbol (abfd) +_bfd_ecoff_make_empty_symbol (abfd) bfd *abfd; { ecoff_symbol_type *new; + bfd_size_type amt = sizeof (ecoff_symbol_type); - new = (ecoff_symbol_type *) bfd_alloc (abfd, sizeof (ecoff_symbol_type)); + new = (ecoff_symbol_type *) bfd_alloc (abfd, amt); if (new == (ecoff_symbol_type *) NULL) - { - bfd_set_error (bfd_error_no_memory); - return (asymbol *) NULL; - } + return (asymbol *) NULL; memset ((PTR) new, 0, sizeof *new); new->symbol.section = (asection *) NULL; new->fdr = (FDR *) NULL; @@ -833,45 +676,17 @@ ecoff_make_empty_symbol (abfd) /* Set the BFD flags and section for an ECOFF symbol. */ static boolean -ecoff_set_symbol_info (abfd, ecoff_sym, asym, ext, indirect_ptr_ptr) +ecoff_set_symbol_info (abfd, ecoff_sym, asym, ext, weak) bfd *abfd; SYMR *ecoff_sym; asymbol *asym; int ext; - asymbol **indirect_ptr_ptr; + int weak; { asym->the_bfd = abfd; asym->value = ecoff_sym->value; asym->section = &bfd_debug_section; - asym->udata = NULL; - - /* An indirect symbol requires two consecutive stabs symbols. */ - if (*indirect_ptr_ptr != (asymbol *) NULL) - { - BFD_ASSERT (ECOFF_IS_STAB (ecoff_sym)); - - /* @@ Stuffing pointers into integers is a no-no. - We can usually get away with it if the integer is - large enough though. */ - if (sizeof (asym) > sizeof (bfd_vma)) - abort (); - (*indirect_ptr_ptr)->value = (bfd_vma) asym; - - asym->flags = BSF_DEBUGGING; - asym->section = &bfd_und_section; - *indirect_ptr_ptr = NULL; - return true; - } - - if (ECOFF_IS_STAB (ecoff_sym) - && (ECOFF_UNMARK_STAB (ecoff_sym->index) | N_EXT) == (N_INDR | N_EXT)) - { - asym->flags = BSF_DEBUGGING | BSF_INDIRECT; - asym->section = &bfd_ind_section; - /* Pass this symbol on to the next call to this function. */ - *indirect_ptr_ptr = asym; - return true; - } + asym->udata.i = 0; /* Most symbol types are just for debugging. */ switch (ecoff_sym->st) @@ -894,10 +709,24 @@ ecoff_set_symbol_info (abfd, ecoff_sym, asym, ext, indirect_ptr_ptr) return true; } - if (ext) + if (weak) + asym->flags = BSF_EXPORT | BSF_WEAK; + else if (ext) asym->flags = BSF_EXPORT | BSF_GLOBAL; else - asym->flags = BSF_LOCAL; + { + 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. */ + if (ecoff_sym->st == stProc + || ecoff_sym->st == stLabel + || ECOFF_IS_STAB (ecoff_sym)) + asym->flags |= BSF_DEBUGGING; + } switch (ecoff_sym->sc) { case scNil: @@ -923,10 +752,10 @@ ecoff_set_symbol_info (abfd, ecoff_sym, asym, ext, indirect_ptr_ptr) asym->flags = BSF_DEBUGGING; break; case scAbs: - asym->section = &bfd_abs_section; + asym->section = bfd_abs_section_ptr; break; case scUndefined: - asym->section = &bfd_und_section; + asym->section = bfd_und_section_ptr; asym->flags = 0; asym->value = 0; break; @@ -956,7 +785,7 @@ ecoff_set_symbol_info (abfd, ecoff_sym, asym, ext, indirect_ptr_ptr) case scCommon: if (asym->value > ecoff_data (abfd)->gp_size) { - asym->section = &bfd_com_section; + asym->section = bfd_com_section_ptr; asym->flags = 0; break; } @@ -983,7 +812,7 @@ ecoff_set_symbol_info (abfd, ecoff_sym, asym, ext, indirect_ptr_ptr) asym->flags = BSF_DEBUGGING; break; case scSUndefined: - asym->section = &bfd_und_section; + asym->section = bfd_und_section_ptr; asym->flags = 0; asym->value = 0; break; @@ -1000,6 +829,10 @@ ecoff_set_symbol_info (abfd, ecoff_sym, asym, ext, indirect_ptr_ptr) asym->section = bfd_make_section_old_way (abfd, ".fini"); asym->value -= asym->section->vma; break; + case scRConst: + asym->section = bfd_make_section_old_way (abfd, ".rconst"); + asym->value -= asym->section->vma; + break; default: break; } @@ -1019,10 +852,15 @@ ecoff_set_symbol_info (abfd, ecoff_sym, asym, ext, indirect_ptr_ptr) 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 @@ -1042,24 +880,19 @@ ecoff_set_symbol_info (abfd, ecoff_sym, asym, ext, indirect_ptr_ptr) { char *copy; - copy = (char *) bfd_alloc (abfd, strlen (name) + 1); + amt = strlen (name) + 1; + copy = (char *) bfd_alloc (abfd, amt); if (!copy) - { - bfd_set_error (bfd_error_no_memory); - return false; - } + return false; strcpy (copy, name); section = bfd_make_section (abfd, copy); } /* Build a reloc pointing to this constructor. */ - reloc_chain = - (arelent_chain *) bfd_alloc (abfd, sizeof (arelent_chain)); + amt = sizeof (arelent_chain); + reloc_chain = (arelent_chain *) bfd_alloc (abfd, amt); if (!reloc_chain) - { - bfd_set_error (bfd_error_no_memory); - return false; - } + return false; reloc_chain->relent.sym_ptr_ptr = bfd_get_section (asym)->symbol_ptr_ptr; reloc_chain->relent.address = section->_raw_size; @@ -1084,6 +917,8 @@ ecoff_set_symbol_info (abfd, ecoff_sym, asym, ext, indirect_ptr_ptr) section->constructor_chain = reloc_chain; section->_raw_size += bitsize / 8; +#endif /* 0 */ + /* Mark the symbol as a constructor. */ asym->flags |= BSF_CONSTRUCTOR; } @@ -1096,7 +931,7 @@ ecoff_set_symbol_info (abfd, ecoff_sym, asym, ext, indirect_ptr_ptr) /* Read an ECOFF symbol table. */ boolean -ecoff_slurp_symbol_table (abfd) +_bfd_ecoff_slurp_symbol_table (abfd) bfd *abfd; { const struct ecoff_backend_data * const backend = ecoff_backend (abfd); @@ -1111,7 +946,6 @@ ecoff_slurp_symbol_table (abfd) bfd_size_type internal_size; ecoff_symbol_type *internal; ecoff_symbol_type *internal_ptr; - asymbol *indirect_ptr; char *eraw_src; char *eraw_end; FDR *fdr_ptr; @@ -1122,21 +956,19 @@ ecoff_slurp_symbol_table (abfd) return true; /* Get the symbolic information. */ - if (ecoff_slurp_symbolic_info (abfd) == false) + if (! _bfd_ecoff_slurp_symbolic_info (abfd, (asection *) NULL, + &ecoff_data (abfd)->debug_info)) return false; if (bfd_get_symcount (abfd) == 0) return true; - internal_size = bfd_get_symcount (abfd) * sizeof (ecoff_symbol_type); + internal_size = bfd_get_symcount (abfd); + internal_size *= sizeof (ecoff_symbol_type); internal = (ecoff_symbol_type *) bfd_alloc (abfd, internal_size); if (internal == NULL) - { - bfd_set_error (bfd_error_no_memory); - return false; - } + return false; internal_ptr = internal; - indirect_ptr = NULL; eraw_src = (char *) ecoff_data (abfd)->debug_info.external_ext; eraw_end = (eraw_src + (ecoff_data (abfd)->debug_info.symbolic_header.iextMax @@ -1149,7 +981,8 @@ ecoff_slurp_symbol_table (abfd) 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, &indirect_ptr)) + &internal_ptr->symbol, 1, + internal_esym.weakext)) return false; /* The alpha uses a negative ifd field for section symbols. */ if (internal_esym.ifd >= 0) @@ -1160,7 +993,6 @@ ecoff_slurp_symbol_table (abfd) internal_ptr->local = false; internal_ptr->native = (PTR) eraw_src; } - BFD_ASSERT (indirect_ptr == (asymbol *) NULL); /* The local symbols must be accessed via the fdr's, because the string and aux indices are relative to the fdr information. */ @@ -1185,14 +1017,13 @@ ecoff_slurp_symbol_table (abfd) + fdr_ptr->issBase + internal_sym.iss); if (!ecoff_set_symbol_info (abfd, &internal_sym, - &internal_ptr->symbol, 0, &indirect_ptr)) + &internal_ptr->symbol, 0, 0)) return false; internal_ptr->fdr = fdr_ptr; internal_ptr->local = true; internal_ptr->native = (PTR) lraw_src; } } - BFD_ASSERT (indirect_ptr == (asymbol *) NULL); ecoff_data (abfd)->canonical_symbols = internal; @@ -1201,12 +1032,15 @@ ecoff_slurp_symbol_table (abfd) /* Return the amount of space needed for the canonical symbols. */ -unsigned int -ecoff_get_symtab_upper_bound (abfd) +long +_bfd_ecoff_get_symtab_upper_bound (abfd) bfd *abfd; { - if (ecoff_slurp_symbolic_info (abfd) == false - || bfd_get_symcount (abfd) == 0) + if (! _bfd_ecoff_slurp_symbolic_info (abfd, (asection *) NULL, + &ecoff_data (abfd)->debug_info)) + return -1; + + if (bfd_get_symcount (abfd) == 0) return 0; return (bfd_get_symcount (abfd) + 1) * (sizeof (ecoff_symbol_type *)); @@ -1214,8 +1048,8 @@ ecoff_get_symtab_upper_bound (abfd) /* Get the canonical symbols. */ -unsigned int -ecoff_get_symtab (abfd, alocation) +long +_bfd_ecoff_get_symtab (abfd, alocation) bfd *abfd; asymbol **alocation; { @@ -1223,8 +1057,9 @@ ecoff_get_symtab (abfd, alocation) ecoff_symbol_type *symbase; ecoff_symbol_type **location = (ecoff_symbol_type **) alocation; - if (ecoff_slurp_symbol_table (abfd) == false - || bfd_get_symcount (abfd) == 0) + if (_bfd_ecoff_slurp_symbol_table (abfd) == false) + return -1; + if (bfd_get_symcount (abfd) == 0) return 0; symbase = ecoff_data (abfd)->canonical_symbols; @@ -1244,57 +1079,76 @@ ecoff_get_symtab (abfd, alocation) /* Write aggregate information to a string. */ static void -ecoff_emit_aggregate (abfd, string, rndx, isym, which) +ecoff_emit_aggregate (abfd, fdr, string, rndx, isym, which) bfd *abfd; + FDR *fdr; char *string; RNDXR *rndx; long isym; - CONST char *which; + const char *which; { - int ifd = rndx->rfd; - int indx = rndx->index; - int sym_base, ss_base; - CONST char *name; - + const struct ecoff_debug_swap * const debug_swap = + &ecoff_backend (abfd)->debug_swap; + struct ecoff_debug_info * const debug_info = &ecoff_data (abfd)->debug_info; + unsigned int ifd = rndx->rfd; + unsigned int indx = rndx->index; + const char *name; + if (ifd == 0xfff) ifd = isym; - sym_base = ecoff_data (abfd)->debug_info.fdr[ifd].isymBase; - ss_base = ecoff_data (abfd)->debug_info.fdr[ifd].issBase; - - if (indx == indexNil) - name = "/* no name */"; + /* An ifd of -1 is an opaque type. An escaped index of 0 is a + struct return type of a procedure compiled without -g. */ + if (ifd == 0xffffffff + || (rndx->rfd == 0xfff && indx == 0)) + name = ""; + else if (indx == indexNil) + name = ""; else { - const struct ecoff_debug_swap * const debug_swap - = &ecoff_backend (abfd)->debug_swap; SYMR sym; - indx += sym_base; - (*debug_swap->swap_sym_in) - (abfd, - ((char *) ecoff_data (abfd)->debug_info.external_sym - + indx * debug_swap->external_sym_size), - &sym); - name = ecoff_data (abfd)->debug_info.ss + ss_base + sym.iss; + if (debug_info->external_rfd == NULL) + fdr = debug_info->fdr + ifd; + else + { + RFDT rfd; + + (*debug_swap->swap_rfd_in) (abfd, + ((char *) debug_info->external_rfd + + ((fdr->rfdBase + ifd) + * debug_swap->external_rfd_size)), + &rfd); + fdr = debug_info->fdr + rfd; + } + + indx += fdr->isymBase; + + (*debug_swap->swap_sym_in) (abfd, + ((char *) debug_info->external_sym + + indx * debug_swap->external_sym_size), + &sym); + + name = debug_info->ss + fdr->issBase + sym.iss; } sprintf (string, - "%s %s { ifd = %d, index = %ld }", + "%s %s { ifd = %u, index = %lu }", which, name, ifd, ((long) indx - + ecoff_data (abfd)->debug_info.symbolic_header.iextMax)); + + debug_info->symbolic_header.iextMax)); } /* Convert the type information to string format. */ static char * -ecoff_type_to_string (abfd, aux_ptr, indx, bigendian) +ecoff_type_to_string (abfd, fdr, indx) bfd *abfd; - union aux_ext *aux_ptr; + FDR *fdr; unsigned int indx; - int bigendian; { + union aux_ext *aux_ptr; + int bigendian; AUXU u; struct qual { unsigned int type; @@ -1302,15 +1156,17 @@ ecoff_type_to_string (abfd, aux_ptr, indx, bigendian) int high_bound; int stride; } qualifiers[7]; - unsigned int basic_type; int i; - static char buffer1[1024]; + char buffer1[1024]; static char buffer2[1024]; char *p1 = buffer1; char *p2 = buffer2; RNDXR rndx; + aux_ptr = ecoff_data (abfd)->debug_info.external_aux + fdr->iauxBase; + bigendian = fdr->fBigendian; + for (i = 0; i < 7; i++) { qualifiers[i].low_bound = 0; @@ -1318,9 +1174,9 @@ ecoff_type_to_string (abfd, aux_ptr, indx, bigendian) qualifiers[i].stride = 0; } - if (AUX_GET_ISYM (bigendian, &aux_ptr[indx]) == -1) + if (AUX_GET_ISYM (bigendian, &aux_ptr[indx]) == (bfd_vma) -1) return "-1 (no type)"; - ecoff_swap_tir_in (bigendian, &aux_ptr[indx++].a_ti, &u.ti); + _bfd_ecoff_swap_tir_in (bigendian, &aux_ptr[indx++].a_ti, &u.ti); basic_type = u.ti.bt; qualifiers[0].type = u.ti.tq0; @@ -1389,8 +1245,8 @@ ecoff_type_to_string (abfd, aux_ptr, indx, bigendian) 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */ case btStruct: /* Structure (Record) */ - ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx); - ecoff_emit_aggregate (abfd, p1, &rndx, + _bfd_ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx); + ecoff_emit_aggregate (abfd, fdr, p1, &rndx, (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]), "struct"); indx++; /* skip aux words */ @@ -1401,8 +1257,8 @@ ecoff_type_to_string (abfd, aux_ptr, indx, bigendian) 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */ case btUnion: /* Union */ - ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx); - ecoff_emit_aggregate (abfd, p1, &rndx, + _bfd_ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx); + ecoff_emit_aggregate (abfd, fdr, p1, &rndx, (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]), "union"); indx++; /* skip aux words */ @@ -1413,8 +1269,8 @@ ecoff_type_to_string (abfd, aux_ptr, indx, bigendian) 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */ case btEnum: /* Enumeration */ - ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx); - ecoff_emit_aggregate (abfd, p1, &rndx, + _bfd_ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx); + ecoff_emit_aggregate (abfd, fdr, p1, &rndx, (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]), "enum"); indx++; /* skip aux words */ @@ -1469,7 +1325,7 @@ ecoff_type_to_string (abfd, aux_ptr, indx, bigendian) break; default: - sprintf (p1, "Unknown basic type %d", (int) basic_type); + sprintf (p1, _("Unknown basic type %d"), (int) basic_type); break; } @@ -1487,7 +1343,6 @@ ecoff_type_to_string (abfd, aux_ptr, indx, bigendian) p1 += strlen (buffer1); } - /* * Deal with any qualifiers. */ @@ -1553,7 +1408,7 @@ ecoff_type_to_string (abfd, aux_ptr, indx, bigendian) int j; /* Print array bounds reversed (ie, in the order the C - programmer writes them). C is such a fun language.... */ + programmer writes them). C is such a fun language.... */ while (i < 5 && qualifiers[i+1].type == tqArray) i++; @@ -1594,20 +1449,29 @@ ecoff_type_to_string (abfd, aux_ptr, indx, bigendian) /* Return information about ECOFF symbol SYMBOL in RET. */ -/*ARGSUSED*/ void -ecoff_get_symbol_info (abfd, symbol, ret) - bfd *abfd; /* Ignored. */ +_bfd_ecoff_get_symbol_info (abfd, symbol, ret) + bfd *abfd ATTRIBUTE_UNUSED; asymbol *symbol; symbol_info *ret; { bfd_symbol_info (symbol, ret); } +/* Return whether this is a local label. */ + +boolean +_bfd_ecoff_bfd_is_local_label_name (abfd, name) + bfd *abfd ATTRIBUTE_UNUSED; + const char *name; +{ + return name[0] == '$'; +} + /* Print information about an ECOFF symbol. */ void -ecoff_print_symbol (abfd, filep, symbol, how) +_bfd_ecoff_print_symbol (abfd, filep, symbol, how) bfd *abfd; PTR filep; asymbol *symbol; @@ -1626,7 +1490,7 @@ ecoff_print_symbol (abfd, filep, symbol, how) if (ecoffsymbol (symbol)->local) { SYMR ecoff_sym; - + (*debug_swap->swap_sym_in) (abfd, ecoffsymbol (symbol)->native, &ecoff_sym); fprintf (file, "ecoff local "); @@ -1695,17 +1559,19 @@ ecoff_print_symbol (abfd, filep, symbol, how) if (ecoffsymbol (symbol)->fdr != NULL && ecoff_ext.asym.index != indexNil) { + FDR *fdr; unsigned int indx; int bigendian; bfd_size_type sym_base; union aux_ext *aux_base; + fdr = ecoffsymbol (symbol)->fdr; indx = ecoff_ext.asym.index; /* sym_base is used to map the fdr relative indices which appear in the file to the position number which we are using. */ - sym_base = ecoffsymbol (symbol)->fdr->isymBase; + sym_base = fdr->isymBase; if (ecoffsymbol (symbol)->local) sym_base += ecoff_data (abfd)->debug_info.symbolic_header.iextMax; @@ -1713,11 +1579,11 @@ ecoff_print_symbol (abfd, filep, symbol, how) /* aux_base is the start of the aux entries for this file; asym.index is an offset from this. */ aux_base = (ecoff_data (abfd)->debug_info.external_aux - + ecoffsymbol (symbol)->fdr->iauxBase); + + fdr->iauxBase); /* The aux entries are stored in host byte order; the order is indicated by a bit in the fdr. */ - bigendian = ecoffsymbol (symbol)->fdr->fBigendian; + bigendian = fdr->fBigendian; /* This switch is basically from gcc/mips-tdump.c */ switch (ecoff_ext.asym.st) @@ -1728,20 +1594,21 @@ ecoff_print_symbol (abfd, filep, symbol, how) case stFile: case stBlock: - fprintf (file, "\n End+1 symbol: %ld", + fprintf (file, _("\n End+1 symbol: %ld"), (long) (indx + sym_base)); break; case stEnd: if (ecoff_ext.asym.sc == scText || ecoff_ext.asym.sc == scInfo) - fprintf (file, "\n First symbol: %ld", + fprintf (file, _("\n First symbol: %ld"), (long) (indx + sym_base)); else - fprintf (file, "\n First symbol: %ld", - (long) (AUX_GET_ISYM (bigendian, - &aux_base[ecoff_ext.asym.index]) - + sym_base)); + fprintf (file, _("\n First symbol: %ld"), + ((long) + (AUX_GET_ISYM (bigendian, + &aux_base[ecoff_ext.asym.index]) + + sym_base))); break; case stProc: @@ -1749,25 +1616,39 @@ ecoff_print_symbol (abfd, filep, symbol, how) if (ECOFF_IS_STAB (&ecoff_ext.asym)) ; else if (ecoffsymbol (symbol)->local) - fprintf (file, "\n End+1 symbol: %-7ld Type: %s", - (long) (AUX_GET_ISYM (bigendian, - &aux_base[ecoff_ext.asym.index]) - + sym_base), - ecoff_type_to_string (abfd, aux_base, indx + 1, - bigendian)); + fprintf (file, _("\n End+1 symbol: %-7ld Type: %s"), + ((long) + (AUX_GET_ISYM (bigendian, + &aux_base[ecoff_ext.asym.index]) + + sym_base)), + ecoff_type_to_string (abfd, fdr, indx + 1)); else - fprintf (file, "\n Local symbol: %ld", + fprintf (file, _("\n Local symbol: %ld"), ((long) indx + (long) sym_base + (ecoff_data (abfd) ->debug_info.symbolic_header.iextMax))); break; + case stStruct: + fprintf (file, _("\n struct; End+1 symbol: %ld"), + (long) (indx + sym_base)); + break; + + case stUnion: + fprintf (file, _("\n union; End+1 symbol: %ld"), + (long) (indx + sym_base)); + break; + + case stEnum: + fprintf (file, _("\n enum; End+1 symbol: %ld"), + (long) (indx + sym_base)); + break; + default: if (! ECOFF_IS_STAB (&ecoff_ext.asym)) - fprintf (file, "\n Type: %s", - ecoff_type_to_string (abfd, aux_base, indx, - bigendian)); + fprintf (file, _("\n Type: %s"), + ecoff_type_to_string (abfd, fdr, indx)); break; } } @@ -1787,7 +1668,7 @@ ecoff_slurp_reloc_table (abfd, section, symbols) const struct ecoff_backend_data * const backend = ecoff_backend (abfd); arelent *internal_relocs; bfd_size_type external_reloc_size; - bfd_size_type external_relocs_size; + bfd_size_type amt; char *external_relocs; arelent *rptr; unsigned int i; @@ -1797,29 +1678,23 @@ ecoff_slurp_reloc_table (abfd, section, symbols) || (section->flags & SEC_CONSTRUCTOR) != 0) return true; - if (ecoff_slurp_symbol_table (abfd) == false) + if (_bfd_ecoff_slurp_symbol_table (abfd) == false) return false; - - internal_relocs = (arelent *) bfd_alloc (abfd, - (sizeof (arelent) - * section->reloc_count)); + + amt = section->reloc_count; + amt *= sizeof (arelent); + internal_relocs = (arelent *) bfd_alloc (abfd, amt); + external_reloc_size = backend->external_reloc_size; - external_relocs_size = external_reloc_size * section->reloc_count; - external_relocs = (char *) bfd_alloc (abfd, external_relocs_size); + amt = external_reloc_size * section->reloc_count; + external_relocs = (char *) bfd_alloc (abfd, amt); if (internal_relocs == (arelent *) NULL || external_relocs == (char *) NULL) - { - bfd_set_error (bfd_error_no_memory); - return false; - } + return false; if (bfd_seek (abfd, section->rel_filepos, SEEK_SET) != 0) return false; - if (bfd_read (external_relocs, 1, external_relocs_size, abfd) - != external_relocs_size) - { - bfd_set_error (bfd_error_system_call); - return false; - } + if (bfd_bread (external_relocs, amt, abfd) != amt) + return false; for (i = 0, rptr = internal_relocs; i < section->reloc_count; i++, rptr++) { @@ -1842,12 +1717,12 @@ ecoff_slurp_reloc_table (abfd, section, symbols) else if (intern.r_symndx == RELOC_SECTION_NONE || intern.r_symndx == RELOC_SECTION_ABS) { - rptr->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr; + rptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; rptr->addend = 0; } else { - CONST char *sec_name; + const char *sec_name; asection *sec; /* r_symndx is a section key. */ @@ -1866,6 +1741,7 @@ ecoff_slurp_reloc_table (abfd, section, symbols) 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 (); } @@ -1893,8 +1769,8 @@ ecoff_slurp_reloc_table (abfd, section, symbols) /* Get a canonical list of relocs. */ -unsigned int -ecoff_canonicalize_reloc (abfd, section, relptr, symbols) +long +_bfd_ecoff_canonicalize_reloc (abfd, section, relptr, symbols) bfd *abfd; asection *section; arelent **relptr; @@ -1902,7 +1778,7 @@ ecoff_canonicalize_reloc (abfd, section, relptr, symbols) { unsigned int count; - if (section->flags & SEC_CONSTRUCTOR) + if (section->flags & SEC_CONSTRUCTOR) { arelent_chain *chain; @@ -1915,15 +1791,13 @@ ecoff_canonicalize_reloc (abfd, section, relptr, symbols) *relptr++ = &chain->relent; } else - { + { arelent *tblptr; if (ecoff_slurp_reloc_table (abfd, section, symbols) == false) - return 0; + return -1; tblptr = section->relocation; - if (tblptr == (arelent *) NULL) - return 0; for (count = 0; count < section->reloc_count; count++) *relptr++ = tblptr++; @@ -1938,173 +1812,158 @@ ecoff_canonicalize_reloc (abfd, section, relptr, symbols) and return the name of the source file and the line nearest to the wanted location. */ -/*ARGSUSED*/ boolean -ecoff_find_nearest_line (abfd, - section, - ignore_symbols, - offset, - filename_ptr, - functionname_ptr, - retline_ptr) +_bfd_ecoff_find_nearest_line (abfd, section, ignore_symbols, offset, + filename_ptr, functionname_ptr, retline_ptr) bfd *abfd; asection *section; - asymbol **ignore_symbols; + asymbol **ignore_symbols ATTRIBUTE_UNUSED; bfd_vma offset; - CONST char **filename_ptr; - CONST char **functionname_ptr; + const char **filename_ptr; + const char **functionname_ptr; unsigned int *retline_ptr; { const struct ecoff_debug_swap * const debug_swap = &ecoff_backend (abfd)->debug_swap; - FDR *fdr_ptr; - FDR *fdr_start; - FDR *fdr_end; - FDR *fdr_hold; - bfd_size_type external_pdr_size; - char *pdr_ptr; - char *pdr_end; - PDR pdr; - unsigned char *line_ptr; - unsigned char *line_end; - int lineno; - - /* If we're not in the .text section, we don't have any line - numbers. */ - if (strcmp (section->name, _TEXT) != 0 - || offset < ecoff_data (abfd)->text_start - || offset >= ecoff_data (abfd)->text_end) - return false; + struct ecoff_debug_info * const debug_info = &ecoff_data (abfd)->debug_info; + struct ecoff_find_line *line_info; /* Make sure we have the FDR's. */ - if (ecoff_slurp_symbolic_info (abfd) == false + if (! _bfd_ecoff_slurp_symbolic_info (abfd, (asection *) NULL, debug_info) || bfd_get_symcount (abfd) == 0) return false; - /* Each file descriptor (FDR) has a memory address. Here we track - down which FDR we want. The FDR's are stored in increasing - memory order. If speed is ever important, this can become a - binary search. We must ignore FDR's with no PDR entries; they - will have the adr of the FDR before or after them. */ - fdr_start = ecoff_data (abfd)->debug_info.fdr; - fdr_end = fdr_start + ecoff_data (abfd)->debug_info.symbolic_header.ifdMax; - fdr_hold = (FDR *) NULL; - for (fdr_ptr = fdr_start; fdr_ptr < fdr_end; fdr_ptr++) + if (ecoff_data (abfd)->find_line_info == NULL) { - if (fdr_ptr->cpd == 0) - continue; - if (offset < fdr_ptr->adr) - break; - fdr_hold = fdr_ptr; - } - if (fdr_hold == (FDR *) NULL) - return false; - fdr_ptr = fdr_hold; - - /* Each FDR has a list of procedure descriptors (PDR). PDR's also - have an address, which is relative to the FDR address, and are - also stored in increasing memory order. */ - offset -= fdr_ptr->adr; - external_pdr_size = debug_swap->external_pdr_size; - pdr_ptr = ((char *) ecoff_data (abfd)->debug_info.external_pdr - + fdr_ptr->ipdFirst * external_pdr_size); - pdr_end = pdr_ptr + fdr_ptr->cpd * external_pdr_size; - (*debug_swap->swap_pdr_in) (abfd, (PTR) pdr_ptr, &pdr); - - /* The address of the first PDR is an offset which applies to the - addresses of all the PDR's. */ - offset += pdr.adr; - - for (pdr_ptr += external_pdr_size; - pdr_ptr < pdr_end; - pdr_ptr += external_pdr_size) - { - (*debug_swap->swap_pdr_in) (abfd, (PTR) pdr_ptr, &pdr); - if (offset < pdr.adr) - break; + bfd_size_type amt = sizeof (struct ecoff_find_line); + 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; - /* Now we can look for the actual line number. The line numbers are - stored in a very funky format, which I won't try to describe. - Note that right here pdr_ptr and pdr hold the PDR *after* the one - we want; we need this to compute line_end. */ - line_end = ecoff_data (abfd)->debug_info.line; - if (pdr_ptr == pdr_end) - line_end += fdr_ptr->cbLineOffset + fdr_ptr->cbLine; - else - line_end += fdr_ptr->cbLineOffset + pdr.cbLineOffset; - - /* Now change pdr and pdr_ptr to the one we want. */ - pdr_ptr -= external_pdr_size; - (*debug_swap->swap_pdr_in) (abfd, (PTR) pdr_ptr, &pdr); - - offset -= pdr.adr; - lineno = pdr.lnLow; - line_ptr = (ecoff_data (abfd)->debug_info.line - + fdr_ptr->cbLineOffset - + pdr.cbLineOffset); - while (line_ptr < line_end) + return _bfd_ecoff_locate_line (abfd, section, offset, debug_info, + debug_swap, line_info, filename_ptr, + functionname_ptr, retline_ptr); +} + +/* Copy private BFD data. This is called by objcopy and strip. We + use it to copy the ECOFF debugging information from one BFD to the + other. It would be theoretically possible to represent the ECOFF + debugging information in the symbol table. However, it would be a + lot of work, and there would be little gain (gas, gdb, and ld + already access the ECOFF debugging information via the + ecoff_debug_info structure, and that structure would have to be + retained in order to support ECOFF debugging in MIPS ELF). + + The debugging information for the ECOFF external symbols comes from + the symbol table, so this function only handles the other debugging + information. */ + +boolean +_bfd_ecoff_bfd_copy_private_bfd_data (ibfd, obfd) + 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; + asymbol **sym_ptr_ptr; + size_t c; + boolean local; + + /* We only want to copy information over if both BFD's use ECOFF + format. */ + if (bfd_get_flavour (ibfd) != bfd_target_ecoff_flavour + || bfd_get_flavour (obfd) != bfd_target_ecoff_flavour) + return true; + + /* Copy the GP value and the register masks. */ + ecoff_data (obfd)->gp = ecoff_data (ibfd)->gp; + ecoff_data (obfd)->gprmask = ecoff_data (ibfd)->gprmask; + ecoff_data (obfd)->fprmask = ecoff_data (ibfd)->fprmask; + for (i = 0; i < 3; i++) + ecoff_data (obfd)->cprmask[i] = ecoff_data (ibfd)->cprmask[i]; + + /* Copy the version stamp. */ + oinfo->symbolic_header.vstamp = iinfo->symbolic_header.vstamp; + + /* 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) + return true; + + /* See if there are any local symbols. */ + local = false; + for (; c > 0; c--, sym_ptr_ptr++) { - int delta; - int count; - - delta = *line_ptr >> 4; - if (delta >= 0x8) - delta -= 0x10; - count = (*line_ptr & 0xf) + 1; - ++line_ptr; - if (delta == -8) + if (ecoffsymbol (*sym_ptr_ptr)->local) { - delta = (((line_ptr[0]) & 0xff) << 8) + ((line_ptr[1]) & 0xff); - if (delta >= 0x8000) - delta -= 0x10000; - line_ptr += 2; + local = true; + break; } - lineno += delta; - if (offset < count * 4) - break; - offset -= count * 4; } - /* If fdr_ptr->rss is -1, then this file does not have full symbols, - at least according to gdb/mipsread.c. */ - if (fdr_ptr->rss == -1) + if (local) { - *filename_ptr = NULL; - if (pdr.isym == -1) - *functionname_ptr = NULL; - else - { - EXTR proc_ext; - - (*debug_swap->swap_ext_in) - (abfd, - ((char *) ecoff_data (abfd)->debug_info.external_ext - + pdr.isym * debug_swap->external_ext_size), - &proc_ext); - *functionname_ptr = (ecoff_data (abfd)->debug_info.ssext - + proc_ext.asym.iss); - } + /* There are some local symbols. We just bring over all the + debugging information. FIXME: This is not quite the right + thing to do. If the user has asked us to discard all + debugging information, then we are probably going to wind up + keeping it because there will probably be some local symbol + which objcopy did not discard. We should actually break + apart the debugging information and only keep that which + applies to the symbols we want to keep. */ + oinfo->symbolic_header.ilineMax = iinfo->symbolic_header.ilineMax; + oinfo->symbolic_header.cbLine = iinfo->symbolic_header.cbLine; + oinfo->line = iinfo->line; + + oinfo->symbolic_header.idnMax = iinfo->symbolic_header.idnMax; + oinfo->external_dnr = iinfo->external_dnr; + + oinfo->symbolic_header.ipdMax = iinfo->symbolic_header.ipdMax; + oinfo->external_pdr = iinfo->external_pdr; + + oinfo->symbolic_header.isymMax = iinfo->symbolic_header.isymMax; + oinfo->external_sym = iinfo->external_sym; + + oinfo->symbolic_header.ioptMax = iinfo->symbolic_header.ioptMax; + oinfo->external_opt = iinfo->external_opt; + + oinfo->symbolic_header.iauxMax = iinfo->symbolic_header.iauxMax; + oinfo->external_aux = iinfo->external_aux; + + oinfo->symbolic_header.issMax = iinfo->symbolic_header.issMax; + oinfo->ss = iinfo->ss; + + oinfo->symbolic_header.ifdMax = iinfo->symbolic_header.ifdMax; + oinfo->external_fdr = iinfo->external_fdr; + + oinfo->symbolic_header.crfd = iinfo->symbolic_header.crfd; + oinfo->external_rfd = iinfo->external_rfd; } else { - SYMR proc_sym; - - *filename_ptr = (ecoff_data (abfd)->debug_info.ss - + fdr_ptr->issBase - + fdr_ptr->rss); - (*debug_swap->swap_sym_in) - (abfd, - ((char *) ecoff_data (abfd)->debug_info.external_sym - + (fdr_ptr->isymBase + pdr.isym) * debug_swap->external_sym_size), - &proc_sym); - *functionname_ptr = (ecoff_data (abfd)->debug_info.ss - + fdr_ptr->issBase - + proc_sym.iss); + /* We are discarding all the local symbol information. Look + through the external symbols and remove all references to FDR + or aux information. */ + c = bfd_get_symcount (obfd); + sym_ptr_ptr = bfd_get_outsymbols (obfd); + for (; c > 0; c--, sym_ptr_ptr++) + { + EXTR esym; + + (*(ecoff_backend (obfd)->debug_swap.swap_ext_in)) + (obfd, ecoffsymbol (*sym_ptr_ptr)->native, &esym); + esym.ifd = ifdNil; + esym.asym.index = indexNil; + (*(ecoff_backend (obfd)->debug_swap.swap_ext_out)) + (obfd, &esym, ecoffsymbol (*sym_ptr_ptr)->native); + } } - if (lineno == ilineNil) - lineno = 0; - *retline_ptr = lineno; + return true; } @@ -2113,7 +1972,7 @@ ecoff_find_nearest_line (abfd, callers ignore the return value. */ boolean -ecoff_set_arch_mach (abfd, arch, machine) +_bfd_ecoff_set_arch_mach (abfd, arch, machine) bfd *abfd; enum bfd_architecture arch; unsigned long machine; @@ -2122,14 +1981,12 @@ ecoff_set_arch_mach (abfd, arch, machine) return arch == ecoff_backend (abfd)->arch; } -/* Get the size of the section headers. We do not output the .reginfo - section. */ +/* Get the size of the section headers. */ -/*ARGSUSED*/ int -ecoff_sizeof_headers (abfd, reloc) +_bfd_ecoff_sizeof_headers (abfd, reloc) bfd *abfd; - boolean reloc; + boolean reloc ATTRIBUTE_UNUSED; { asection *current; int c; @@ -2137,10 +1994,9 @@ ecoff_sizeof_headers (abfd, reloc) c = 0; for (current = abfd->sections; - current != (asection *)NULL; - current = current->next) - if (strcmp (current->name, REGINFO) != 0) - ++c; + current != (asection *)NULL; + current = current->next) + ++c; ret = (bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd) @@ -2148,77 +2004,121 @@ ecoff_sizeof_headers (abfd, reloc) return BFD_ALIGN (ret, 16); } -/* Get the contents of a section. This is where we handle reading the - .reginfo section, which implicitly holds the contents of an - ecoff_reginfo structure. */ +/* Get the contents of a section. */ boolean -ecoff_get_section_contents (abfd, section, location, offset, count) +_bfd_ecoff_get_section_contents (abfd, section, location, offset, count) bfd *abfd; asection *section; PTR location; file_ptr offset; bfd_size_type count; { - ecoff_data_type *tdata = ecoff_data (abfd); - struct ecoff_reginfo s; - int i; + return _bfd_generic_get_section_contents (abfd, section, location, + offset, count); +} - if (strcmp (section->name, REGINFO) != 0) - return bfd_generic_get_section_contents (abfd, section, location, - offset, count); +/* Sort sections by VMA, but put SEC_ALLOC sections first. This is + called via qsort. */ - s.gp_value = tdata->gp; - s.gprmask = tdata->gprmask; - for (i = 0; i < 4; i++) - s.cprmask[i] = tdata->cprmask[i]; - s.fprmask = tdata->fprmask; - - /* bfd_get_section_contents has already checked that the offset and - size is reasonable. We don't have to worry about swapping or any - such thing; the .reginfo section is defined such that the - contents are an ecoff_reginfo structure as seen on the host. */ - memcpy (location, ((char *) &s) + offset, (size_t) count); - return true; +static int +ecoff_sort_hdrs (arg1, arg2) + const PTR arg1; + const PTR arg2; +{ + const asection *hdr1 = *(const asection **) arg1; + const asection *hdr2 = *(const asection **) arg2; + + if ((hdr1->flags & SEC_ALLOC) != 0) + { + if ((hdr2->flags & SEC_ALLOC) == 0) + return -1; + } + else + { + if ((hdr2->flags & SEC_ALLOC) != 0) + return 1; + } + if (hdr1->vma < hdr2->vma) + return -1; + else if (hdr1->vma > hdr2->vma) + return 1; + else + return 0; } /* Calculate the file position for each section, and set reloc_filepos. */ -static void +static boolean ecoff_compute_section_file_positions (abfd) bfd *abfd; { + file_ptr sofar, file_sofar; + asection **sorted_hdrs; asection *current; - file_ptr sofar; + unsigned int i; file_ptr old_sofar; - boolean first_data; - - sofar = ecoff_sizeof_headers (abfd, false); + boolean rdata_in_text; + boolean first_data, first_nonalloc; + const bfd_vma round = ecoff_backend (abfd)->round; + bfd_size_type amt; + + sofar = _bfd_ecoff_sizeof_headers (abfd, false); + file_sofar = sofar; + + /* Sort the sections by VMA. */ + amt = abfd->section_count; + amt *= sizeof (asection *); + sorted_hdrs = (asection **) bfd_malloc (amt); + if (sorted_hdrs == NULL) + return false; + for (current = abfd->sections, i = 0; + current != NULL; + current = current->next, i++) + sorted_hdrs[i] = current; + BFD_ASSERT (i == abfd->section_count); + + qsort (sorted_hdrs, abfd->section_count, sizeof (asection *), + ecoff_sort_hdrs); + + /* Some versions of the OSF linker put the .rdata section in the + text segment, and some do not. */ + rdata_in_text = ecoff_backend (abfd)->rdata_in_text; + if (rdata_in_text) + { + for (i = 0; i < abfd->section_count; i++) + { + current = sorted_hdrs[i]; + if (strcmp (current->name, _RDATA) == 0) + break; + if ((current->flags & SEC_CODE) == 0 + && strcmp (current->name, _PDATA) != 0 + && strcmp (current->name, _RCONST) != 0) + { + rdata_in_text = false; + break; + } + } + } + ecoff_data (abfd)->rdata_in_text = rdata_in_text; first_data = true; - for (current = abfd->sections; - current != (asection *) NULL; - current = current->next) + first_nonalloc = true; + for (i = 0; i < abfd->section_count; i++) { unsigned int alignment_power; - /* Only deal with sections which have contents */ - if ((current->flags & (SEC_HAS_CONTENTS | SEC_LOAD)) == 0 - || strcmp (current->name, REGINFO) == 0) - continue; + current = sorted_hdrs[i]; /* For the Alpha ECOFF .pdata section the lnnoptr field is 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) - alignment_power = current->alignment_power; - else - { - current->line_filepos = current->_raw_size / 8; - alignment_power = 4; - } + if (strcmp (current->name, _PDATA) == 0) + current->line_filepos = current->_raw_size / 8; + + alignment_power = current->alignment_power; /* On Ultrix, the data sections in an executable file must be aligned to a page boundary within the file. This does not @@ -2228,34 +2128,73 @@ ecoff_compute_section_file_positions (abfd) the data. */ if ((abfd->flags & EXEC_P) != 0 && (abfd->flags & D_PAGED) != 0 - && first_data != false + && ! first_data && (current->flags & SEC_CODE) == 0 - && (! ecoff_backend (abfd)->rdata_in_text + && (! rdata_in_text || strcmp (current->name, _RDATA) != 0) - && strcmp (current->name, _PDATA) != 0) + && strcmp (current->name, _PDATA) != 0 + && strcmp (current->name, _RCONST) != 0) { - const bfd_vma round = ecoff_backend (abfd)->round; - sofar = (sofar + round - 1) &~ (round - 1); + file_sofar = (file_sofar + round - 1) &~ (round - 1); first_data = false; } + else if (strcmp (current->name, _LIB) == 0) + { + /* On Irix 4, the location of contents of the .lib section + from a shared library section is also rounded up to a + page boundary. */ + + sofar = (sofar + round - 1) &~ (round - 1); + file_sofar = (file_sofar + round - 1) &~ (round - 1); + } + else if (first_nonalloc + && (current->flags & SEC_ALLOC) == 0 + && (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. */ + first_nonalloc = false; + sofar = (sofar + round - 1) &~ (round - 1); + file_sofar = (file_sofar + round - 1) &~ (round - 1); + } /* Align the sections in the file to the same boundary on which they are aligned in virtual memory. */ - 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->filepos = sofar; + if ((abfd->flags & D_PAGED) != 0 + && (current->flags & SEC_ALLOC) != 0) + { + sofar += (current->vma - sofar) % round; + if ((current->flags & SEC_HAS_CONTENTS) != 0) + file_sofar += (current->vma - file_sofar) % round; + } + + if ((current->flags & (SEC_HAS_CONTENTS | SEC_LOAD)) != 0) + current->filepos = file_sofar; sofar += current->_raw_size; + if ((current->flags & SEC_HAS_CONTENTS) != 0) + file_sofar += current->_raw_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; } - ecoff_data (abfd)->reloc_filepos = sofar; + free (sorted_hdrs); + sorted_hdrs = NULL; + + ecoff_data (abfd)->reloc_filepos = file_sofar; + + return true; } /* Determine the location of the relocs for all the sections in the @@ -2275,19 +2214,18 @@ ecoff_compute_reloc_file_positions (abfd) if (! abfd->output_has_begun) { - ecoff_compute_section_file_positions (abfd); + if (! ecoff_compute_section_file_positions (abfd)) + abort (); abfd->output_has_begun = true; } - + reloc_base = ecoff_data (abfd)->reloc_filepos; reloc_size = 0; for (current = abfd->sections; - current != (asection *)NULL; - current = current->next) + current != (asection *)NULL; + current = current->next) { - if (strcmp (current->name, REGINFO) == 0) - continue; if (current->reloc_count == 0) current->rel_filepos = 0; else @@ -2316,62 +2254,120 @@ ecoff_compute_reloc_file_positions (abfd) return reloc_size; } -/* Set the contents of a section. This is where we handle setting the - contents of the .reginfo section, which implicitly holds a - ecoff_reginfo structure. */ +/* Set the contents of a section. */ boolean -ecoff_set_section_contents (abfd, section, location, offset, count) +_bfd_ecoff_set_section_contents (abfd, section, location, offset, count) bfd *abfd; asection *section; PTR 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 == false) - ecoff_compute_section_file_positions (abfd); + { + if (! 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) + { + bfd_byte *rec, *recend; + + rec = (bfd_byte *) location; + recend = rec + count; + while (rec < recend) + { + ++section->lma; + rec += bfd_get_32 (abfd, rec) * 4; + } + + BFD_ASSERT (rec == recend); + } if (count == 0) return true; - if (strcmp (section->name, REGINFO) == 0) + pos = section->filepos + offset; + if (bfd_seek (abfd, pos, SEEK_SET) != 0 + || bfd_bwrite (location, count, abfd) != count) + return false; + + 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. */ + +boolean +bfd_ecoff_set_gp_value (abfd, gp_value) + bfd *abfd; + bfd_vma gp_value; +{ + if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour + || bfd_get_format (abfd) != bfd_object) { - ecoff_data_type *tdata = ecoff_data (abfd); - struct ecoff_reginfo s; - int i; + bfd_set_error (bfd_error_invalid_operation); + return false; + } - /* If the caller is only changing part of the structure, we must - retrieve the current information before the memcpy. */ - if (offset != 0 || count != sizeof (struct ecoff_reginfo)) - { - s.gp_value = tdata->gp; - s.gprmask = tdata->gprmask; - for (i = 0; i < 4; i++) - s.cprmask[i] = tdata->cprmask[i]; - s.fprmask = tdata->fprmask; - } + ecoff_data (abfd)->gp = gp_value; + + return true; +} - /* bfd_set_section_contents has already checked that the offset - and size is reasonable. We don't have to worry about - swapping or any such thing; the .reginfo section is defined - such that the contents are an ecoff_reginfo structure as seen - on the host. */ - memcpy (((char *) &s) + offset, location, (size_t) count); +/* Set the register masks for an ECOFF file. This is a hook used by + the assembler. */ - tdata->gp = s.gp_value; - tdata->gprmask = s.gprmask; - for (i = 0; i < 4; i++) - tdata->cprmask[i] = s.cprmask[i]; - tdata->fprmask = s.fprmask; +boolean +bfd_ecoff_set_regmasks (abfd, gprmask, fprmask, cprmask) + bfd *abfd; + unsigned long gprmask; + unsigned long fprmask; + unsigned long *cprmask; +{ + ecoff_data_type *tdata; - return true; + if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour + || bfd_get_format (abfd) != bfd_object) + { + bfd_set_error (bfd_error_invalid_operation); + return false; } - if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) != 0 - || bfd_write (location, 1, count, abfd) != count) - return false; + tdata = ecoff_data (abfd); + tdata->gprmask = gprmask; + tdata->fprmask = fprmask; + if (cprmask != (unsigned long *) NULL) + { + register int i; + + for (i = 0; i < 3; i++) + tdata->cprmask[i] = cprmask[i]; + } return true; } @@ -2387,18 +2383,18 @@ ecoff_get_extr (sym, esym) ecoff_symbol_type *ecoff_sym_ptr; bfd *input_bfd; - /* Don't include debugging, local or section symbols. */ - if ((sym->flags & BSF_DEBUGGING) != 0 - || (sym->flags & BSF_LOCAL) != 0 - || (sym->flags & BSF_SECTION_SYM) != 0) - return false; - if (bfd_asymbol_flavour (sym) != bfd_target_ecoff_flavour || ecoffsymbol (sym)->native == NULL) { + /* Don't include debugging, local, or section symbols. */ + if ((sym->flags & BSF_DEBUGGING) != 0 + || (sym->flags & BSF_LOCAL) != 0 + || (sym->flags & BSF_SECTION_SYM) != 0) + return false; + esym->jmptbl = 0; esym->cobol_main = 0; - esym->weakext = 0; + esym->weakext = (sym->flags & BSF_WEAK) != 0; esym->reserved = 0; esym->ifd = ifdNil; /* FIXME: we can do better than this for st and sc. */ @@ -2412,7 +2408,7 @@ ecoff_get_extr (sym, esym) ecoff_sym_ptr = ecoffsymbol (sym); if (ecoff_sym_ptr->local) - abort (); + return false; input_bfd = bfd_asymbol_bfd (sym); (*(ecoff_backend (input_bfd)->debug_swap.swap_ext_in)) @@ -2423,7 +2419,7 @@ ecoff_get_extr (sym, esym) symbol. */ if ((esym->asym.sc == scUndefined || esym->asym.sc == scSUndefined) - && bfd_get_section (sym) != &bfd_und_section) + && ! bfd_is_und_section (bfd_get_section (sym))) esym->asym.sc = scAbs; /* Adjust the FDR index for the symbol by that used for the input @@ -2455,7 +2451,7 @@ ecoff_set_index (sym, indx) /* Write out an ECOFF file. */ boolean -ecoff_write_object_contents (abfd) +_bfd_ecoff_write_object_contents (abfd) bfd *abfd; { const struct ecoff_backend_data * const backend = ecoff_backend (abfd); @@ -2481,46 +2477,60 @@ ecoff_write_object_contents (abfd) bfd_size_type reloc_size; bfd_size_type text_size; bfd_vma text_start; + boolean set_text_start; bfd_size_type data_size; bfd_vma data_start; + boolean set_data_start; bfd_size_type bss_size; - PTR buff; + PTR buff = NULL; + PTR reloc_buff = NULL; struct internal_filehdr internal_f; struct internal_aouthdr internal_a; int i; - bfd_set_error (bfd_error_system_call); - /* Determine where the sections and relocs will go in the output file. */ reloc_size = ecoff_compute_reloc_file_positions (abfd); count = 1; for (current = abfd->sections; - current != (asection *)NULL; - current = current->next) + current != (asection *)NULL; + current = current->next) { - if (strcmp (current->name, REGINFO) == 0) - continue; current->target_index = count; ++count; } if ((abfd->flags & D_PAGED) != 0) - text_size = ecoff_sizeof_headers (abfd, false); + text_size = _bfd_ecoff_sizeof_headers (abfd, false); else text_size = 0; text_start = 0; + set_text_start = false; data_size = 0; data_start = 0; + set_data_start = false; bss_size = 0; /* Write section headers to the file. */ - buff = (PTR) alloca (scnhsz); + /* Allocate buff big enough to hold a section header, + 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); + if (buff == NULL) + goto error_return; + } + internal_f.f_nscns = 0; if (bfd_seek (abfd, (file_ptr) (filhsz + aoutsz), SEEK_SET) != 0) - return false; + goto error_return; for (current = abfd->sections; current != (asection *) NULL; current = current->next) @@ -2528,25 +2538,18 @@ ecoff_write_object_contents (abfd) struct internal_scnhdr section; bfd_vma vma; - if (strcmp (current->name, REGINFO) == 0) - { - BFD_ASSERT (current->reloc_count == 0); - continue; - } - ++internal_f.f_nscns; strncpy (section.s_name, current->name, sizeof section.s_name); - /* FIXME: is this correct for shared libraries? I think it is - but I have no platform to check. Ian Lance Taylor. */ + /* This seems to be correct for Irix 4 shared libraries. */ vma = bfd_get_section_vma (abfd, current); if (strcmp (current->name, _LIB) == 0) section.s_vaddr = 0; else section.s_vaddr = vma; - section.s_paddr = vma; + section.s_paddr = current->lma; section.s_size = bfd_get_section_size_before_reloc (current); /* If this section is unloadable then the scnptr will be 0. */ @@ -2579,18 +2582,31 @@ ecoff_write_object_contents (abfd) section.s_flags = ecoff_sec_to_styp_flags (current->name, current->flags); - bfd_coff_swap_scnhdr_out (abfd, (PTR) §ion, buff); - if (bfd_write (buff, 1, scnhsz, abfd) != scnhsz) - return false; + if (bfd_coff_swap_scnhdr_out (abfd, (PTR) §ion, buff) == 0 + || bfd_bwrite (buff, scnhsz, abfd) != scnhsz) + goto error_return; if ((section.s_flags & STYP_TEXT) != 0 || ((section.s_flags & STYP_RDATA) != 0 - && backend->rdata_in_text) - || strcmp (current->name, _PDATA) == 0) + && ecoff_data (abfd)->rdata_in_text) + || section.s_flags == STYP_PDATA + || (section.s_flags & STYP_DYNAMIC) != 0 + || (section.s_flags & STYP_LIBLIST) != 0 + || (section.s_flags & STYP_RELDYN) != 0 + || section.s_flags == STYP_CONFLIC + || (section.s_flags & STYP_DYNSTR) != 0 + || (section.s_flags & STYP_DYNSYM) != 0 + || (section.s_flags & STYP_HASH) != 0 + || (section.s_flags & STYP_ECOFF_INIT) != 0 + || (section.s_flags & STYP_ECOFF_FINI) != 0 + || section.s_flags == STYP_RCONST) { text_size += bfd_get_section_size_before_reloc (current); - if (text_start == 0 || text_start > vma) - text_start = vma; + if (! set_text_start || text_start > vma) + { + text_start = vma; + set_text_start = true; + } } else if ((section.s_flags & STYP_RDATA) != 0 || (section.s_flags & STYP_DATA) != 0 @@ -2598,18 +2614,26 @@ ecoff_write_object_contents (abfd) || (section.s_flags & STYP_LIT8) != 0 || (section.s_flags & STYP_LIT4) != 0 || (section.s_flags & STYP_SDATA) != 0 - || strcmp (current->name, _XDATA) == 0) + || section.s_flags == STYP_XDATA + || (section.s_flags & STYP_GOT) != 0) { data_size += bfd_get_section_size_before_reloc (current); - if (data_start == 0 || data_start > vma) - data_start = vma; + if (! set_data_start || data_start > vma) + { + data_start = vma; + set_data_start = true; + } } else if ((section.s_flags & STYP_BSS) != 0 || (section.s_flags & STYP_SBSS) != 0) bss_size += bfd_get_section_size_before_reloc (current); + else if (section.s_flags == 0 + || (section.s_flags & STYP_ECOFF_LIB) != 0 + || section.s_flags == STYP_COMMENT) + /* Do nothing */ ; else abort (); - } + } /* Set up the file header. */ @@ -2645,7 +2669,7 @@ ecoff_write_object_contents (abfd) if (abfd->flags & EXEC_P) internal_f.f_flags |= F_EXEC; - if (! abfd->xvec->byteorder_big_p) + if (bfd_little_endian (abfd)) internal_f.f_flags |= F_AR32WR; else internal_f.f_flags |= F_AR32W; @@ -2697,27 +2721,31 @@ ecoff_write_object_contents (abfd) for (i = 0; i < 4; i++) internal_a.cprmask[i] = ecoff_data (abfd)->cprmask[i]; + /* Let the backend adjust the headers if necessary. */ + if (backend->adjust_headers) + { + if (! (*backend->adjust_headers) (abfd, &internal_f, &internal_a)) + goto error_return; + } + /* Write out the file header and the optional header. */ if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) - return false; + goto error_return; - buff = (PTR) alloca (filhsz); bfd_coff_swap_filehdr_out (abfd, (PTR) &internal_f, buff); - if (bfd_write (buff, 1, filhsz, abfd) != filhsz) - return false; + if (bfd_bwrite (buff, filhsz, abfd) != filhsz) + goto error_return; - buff = (PTR) alloca (aoutsz); bfd_coff_swap_aouthdr_out (abfd, (PTR) &internal_a, buff); - if (bfd_write (buff, 1, aoutsz, abfd) != aoutsz) - return false; + if (bfd_bwrite (buff, aoutsz, abfd) != aoutsz) + goto error_return; /* Build the external symbol information. This must be done before - writing out the relocs so that we know the symbol indices. The - condition checks makes sure this object was not created by - ecoff_bfd_final_link, since if it was we do not want to tamper - with the external symbols. */ - if (bfd_get_outsymbols (abfd) != (asymbol **) NULL) + writing out the relocs so that we know the symbol indices. We + don't do this if this BFD was created by the backend linker, + since it will have already handled the symbols and relocs. */ + if (! ecoff_data (abfd)->linker) { symhdr->iextMax = 0; symhdr->issExtMax = 0; @@ -2728,7 +2756,7 @@ ecoff_write_object_contents (abfd) ? true : false), ecoff_get_extr, ecoff_set_index) == false) - return false; + goto error_return; /* Write out the relocs. */ for (current = abfd->sections; @@ -2738,20 +2766,19 @@ ecoff_write_object_contents (abfd) arelent **reloc_ptr_ptr; arelent **reloc_end; char *out_ptr; + bfd_size_type amt; if (current->reloc_count == 0) continue; - buff = bfd_alloc (abfd, current->reloc_count * external_reloc_size); - if (buff == NULL) - { - bfd_set_error (bfd_error_no_memory); - return false; - } + amt = current->reloc_count * external_reloc_size; + reloc_buff = bfd_alloc (abfd, amt); + if (reloc_buff == NULL) + goto error_return; reloc_ptr_ptr = current->orelocation; reloc_end = reloc_ptr_ptr + current->reloc_count; - out_ptr = (char *) buff; + out_ptr = (char *) reloc_buff; for (; reloc_ptr_ptr < reloc_end; reloc_ptr_ptr++, out_ptr += external_reloc_size) @@ -2759,7 +2786,7 @@ ecoff_write_object_contents (abfd) arelent *reloc; asymbol *sym; struct internal_reloc in; - + memset ((PTR) &in, 0, sizeof in); reloc = *reloc_ptr_ptr; @@ -2776,7 +2803,7 @@ ecoff_write_object_contents (abfd) } else { - CONST char *name; + const char *name; name = bfd_get_section_name (abfd, bfd_get_section (sym)); if (strcmp (name, ".text") == 0) @@ -2807,6 +2834,8 @@ ecoff_write_object_contents (abfd) 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; @@ -2818,11 +2847,12 @@ ecoff_write_object_contents (abfd) } if (bfd_seek (abfd, current->rel_filepos, SEEK_SET) != 0) - return false; - if (bfd_write (buff, external_reloc_size, current->reloc_count, abfd) - != external_reloc_size * current->reloc_count) - return false; - bfd_release (abfd, buff); + goto error_return; + amt = current->reloc_count * external_reloc_size; + if (bfd_bwrite (reloc_buff, amt, abfd) != amt) + goto error_return; + bfd_release (abfd, reloc_buff); + reloc_buff = NULL; } /* Write out the symbolic debugging information. */ @@ -2832,7 +2862,7 @@ ecoff_write_object_contents (abfd) if (bfd_ecoff_write_debug (abfd, debug, &backend->debug_swap, ecoff_data (abfd)->sym_filepos) == false) - return false; + goto error_return; } } @@ -2848,17 +2878,27 @@ ecoff_write_object_contents (abfd) if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos - 1, SEEK_SET) != 0) - return false; - if (bfd_read (&c, 1, 1, abfd) == 0) + goto error_return; + if (bfd_bread (&c, (bfd_size_type) 1, abfd) == 0) c = 0; if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos - 1, SEEK_SET) != 0) - return false; - if (bfd_write (&c, 1, 1, abfd) != 1) - return false; + goto error_return; + if (bfd_bwrite (&c, (bfd_size_type) 1, abfd) != 1) + goto error_return; } + if (reloc_buff != NULL) + bfd_release (abfd, reloc_buff); + if (buff != NULL) + free (buff); return true; + error_return: + if (reloc_buff != NULL) + bfd_release (abfd, reloc_buff); + if (buff != NULL) + free (buff); + return false; } /* Archive handling. ECOFF uses what appears to be a unique type of @@ -2912,13 +2952,15 @@ ecoff_write_object_contents (abfd) static unsigned int ecoff_armap_hash (s, rehash, size, hlog) - CONST char *s; + const char *s; unsigned int *rehash; unsigned int size; unsigned int hlog; { unsigned int hash; + if (hlog == 0) + return 0; hash = *s++; while (*s != '\0') hash = ((hash >> 27) | (hash << 5)) + *s++; @@ -2930,7 +2972,7 @@ ecoff_armap_hash (s, rehash, size, hlog) /* Read in the armap. */ boolean -ecoff_slurp_armap (abfd) +_bfd_ecoff_slurp_armap (abfd) bfd *abfd; { char nextname[17]; @@ -2943,15 +2985,17 @@ ecoff_slurp_armap (abfd) char *raw_ptr; struct symdef *symdef_ptr; char *stringbase; - + bfd_size_type amt; + /* Get the name of the first element. */ - i = bfd_read ((PTR) nextname, 1, 16, abfd); + i = bfd_bread ((PTR) nextname, (bfd_size_type) 16, abfd); if (i == 0) return true; if (i != 16) return false; - bfd_seek (abfd, (file_ptr) -16, SEEK_CUR); + if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0) + return false; /* Irix 4.0.5F apparently can use either an ECOFF armap or a standard COFF armap. We could move the ECOFF armap stuff into @@ -2979,9 +3023,9 @@ ecoff_slurp_armap (abfd) /* Make sure we have the right byte ordering. */ if (((nextname[ARMAP_HEADER_ENDIAN_INDEX] == ARMAP_BIG_ENDIAN) - ^ (abfd->xvec->header_byteorder_big_p != false)) + ^ (bfd_header_big_endian (abfd))) || ((nextname[ARMAP_OBJECT_ENDIAN_INDEX] == ARMAP_BIG_ENDIAN) - ^ (abfd->xvec->byteorder_big_p != false))) + ^ (bfd_big_endian (abfd)))) { bfd_set_error (bfd_error_wrong_format); return false; @@ -2989,29 +3033,27 @@ ecoff_slurp_armap (abfd) /* Read in the armap. */ ardata = bfd_ardata (abfd); - mapdata = _bfd_snarf_ar_hdr (abfd); + mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd); if (mapdata == (struct areltdata *) NULL) return false; parsed_size = mapdata->parsed_size; bfd_release (abfd, (PTR) mapdata); - + raw_armap = (char *) bfd_alloc (abfd, parsed_size); if (raw_armap == (char *) NULL) + return false; + + if (bfd_bread ((PTR) raw_armap, parsed_size, abfd) != parsed_size) { - bfd_set_error (bfd_error_no_memory); - return false; - } - - if (bfd_read ((PTR) raw_armap, 1, parsed_size, abfd) != parsed_size) - { - bfd_set_error (bfd_error_malformed_archive); + if (bfd_get_error () != bfd_error_system_call) + bfd_set_error (bfd_error_malformed_archive); bfd_release (abfd, (PTR) raw_armap); return false; } - + ardata->tdata = (PTR) raw_armap; - count = bfd_h_get_32 (abfd, (PTR) raw_armap); + count = H_GET_32 (abfd, raw_armap); ardata->symdef_count = 0; ardata->cache = (struct ar_cache *) NULL; @@ -3037,9 +3079,9 @@ ecoff_slurp_armap (abfd) { unsigned int name_offset, file_offset; unsigned int hash, rehash, srch; - - name_offset = bfd_h_get_32 (abfd, (PTR) raw_ptr); - file_offset = bfd_h_get_32 (abfd, (PTR) (raw_ptr + 4)); + + name_offset = H_GET_32 (abfd, raw_ptr); + file_offset = H_GET_32 (abfd, (raw_ptr + 4)); if (file_offset == 0) continue; hash = ecoff_armap_hash (stringbase + name_offset, &rehash, count, @@ -3051,8 +3093,7 @@ ecoff_slurp_armap (abfd) for (srch = (hash + rehash) & (count - 1); srch != hash && srch != i; srch = (srch + rehash) & (count - 1)) - BFD_ASSERT (bfd_h_get_32 (abfd, (PTR) (raw_armap + 8 + srch * 8)) - != 0); + BFD_ASSERT (H_GET_32 (abfd, (raw_armap + 8 + srch * 8)) != 0); BFD_ASSERT (srch == i); } } @@ -3061,17 +3102,14 @@ ecoff_slurp_armap (abfd) raw_ptr = raw_armap + 4; for (i = 0; i < count; i++, raw_ptr += 8) - if (bfd_h_get_32 (abfd, (PTR) (raw_ptr + 4)) != 0) + if (H_GET_32 (abfd, (raw_ptr + 4)) != 0) ++ardata->symdef_count; - symdef_ptr = ((struct symdef *) - bfd_alloc (abfd, - ardata->symdef_count * sizeof (struct symdef))); + amt = ardata->symdef_count; + amt *= sizeof (struct symdef); + symdef_ptr = (struct symdef *) bfd_alloc (abfd, amt); if (!symdef_ptr) - { - bfd_set_error (bfd_error_no_memory); - return false; - } + return false; ardata->symdefs = (carsym *) symdef_ptr; @@ -3080,10 +3118,10 @@ ecoff_slurp_armap (abfd) { unsigned int name_offset, file_offset; - file_offset = bfd_h_get_32 (abfd, (PTR) (raw_ptr + 4)); + file_offset = H_GET_32 (abfd, (raw_ptr + 4)); if (file_offset == 0) continue; - name_offset = bfd_h_get_32 (abfd, (PTR) raw_ptr); + name_offset = H_GET_32 (abfd, raw_ptr); symdef_ptr->s.name = stringbase + name_offset; symdef_ptr->file_offset = file_offset; ++symdef_ptr; @@ -3101,7 +3139,7 @@ ecoff_slurp_armap (abfd) /* Write out an armap. */ boolean -ecoff_write_armap (abfd, elength, map, orl_count, stridx) +_bfd_ecoff_write_armap (abfd, elength, map, orl_count, stridx) bfd *abfd; unsigned int elength; struct orl *map; @@ -3109,7 +3147,7 @@ ecoff_write_armap (abfd, elength, map, orl_count, stridx) int stridx; { unsigned int hashsize, hashlog; - unsigned int symdefsize; + bfd_size_type symdefsize; int padit; unsigned int stringsize; unsigned int mapsize; @@ -3124,7 +3162,7 @@ ecoff_write_armap (abfd, elength, map, orl_count, stridx) /* Ultrix appears to use as a hash table size the least power of two greater than twice the number of entries. */ - for (hashlog = 0; (1 << hashlog) <= 2 * orl_count; hashlog++) + for (hashlog = 0; ((unsigned int) 1 << hashlog) <= 2 * orl_count; hashlog++) ; hashsize = 1 << hashlog; @@ -3132,7 +3170,7 @@ ecoff_write_armap (abfd, elength, map, orl_count, stridx) padit = stridx % 2; stringsize = stridx + padit; - /* Include 8 bytes to store symdefsize and stringsize in output. */ + /* Include 8 bytes to store symdefsize and stringsize in output. */ mapsize = symdefsize + stringsize + 8; firstreal = SARMAG + sizeof (struct ar_hdr) + mapsize + elength; @@ -3143,12 +3181,12 @@ ecoff_write_armap (abfd, elength, map, orl_count, stridx) strcpy (hdr.ar_name, ecoff_backend (abfd)->armap_start); hdr.ar_name[ARMAP_HEADER_MARKER_INDEX] = ARMAP_MARKER; hdr.ar_name[ARMAP_HEADER_ENDIAN_INDEX] = - (abfd->xvec->header_byteorder_big_p + (bfd_header_big_endian (abfd) ? ARMAP_BIG_ENDIAN : ARMAP_LITTLE_ENDIAN); hdr.ar_name[ARMAP_OBJECT_MARKER_INDEX] = ARMAP_MARKER; hdr.ar_name[ARMAP_OBJECT_ENDIAN_INDEX] = - abfd->xvec->byteorder_big_p ? ARMAP_BIG_ENDIAN : ARMAP_LITTLE_ENDIAN; + bfd_big_endian (abfd) ? ARMAP_BIG_ENDIAN : ARMAP_LITTLE_ENDIAN; memcpy (hdr.ar_name + ARMAP_END_INDEX, ARMAP_END, sizeof ARMAP_END - 1); /* Write the timestamp of the archive header to be just a little bit @@ -3163,7 +3201,14 @@ ecoff_write_armap (abfd, elength, map, orl_count, stridx) 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); @@ -3172,23 +3217,20 @@ ecoff_write_armap (abfd, elength, map, orl_count, stridx) /* Turn all null bytes in the header into spaces. */ for (i = 0; i < sizeof (struct ar_hdr); i++) - if (((char *)(&hdr))[i] == '\0') - (((char *)(&hdr))[i]) = ' '; + if (((char *) (&hdr))[i] == '\0') + (((char *) (&hdr))[i]) = ' '; - if (bfd_write ((PTR) &hdr, 1, sizeof (struct ar_hdr), abfd) + if (bfd_bwrite ((PTR) &hdr, (bfd_size_type) sizeof (struct ar_hdr), abfd) != sizeof (struct ar_hdr)) return false; - bfd_h_put_32 (abfd, (bfd_vma) hashsize, temp); - if (bfd_write ((PTR) temp, 1, 4, abfd) != 4) + H_PUT_32 (abfd, hashsize, temp); + if (bfd_bwrite ((PTR) temp, (bfd_size_type) 4, abfd) != 4) return false; - + hashtable = (bfd_byte *) bfd_zalloc (abfd, symdefsize); if (!hashtable) - { - bfd_set_error (bfd_error_no_memory); - return false; - } + return false; current = abfd->archive_head; last_elt = current; @@ -3198,7 +3240,7 @@ ecoff_write_armap (abfd, elength, map, orl_count, stridx) /* Advance firstreal to the file position of this archive element. */ - if (((bfd *) map[i].pos) != last_elt) + if (map[i].u.abfd != last_elt) { do { @@ -3206,13 +3248,13 @@ ecoff_write_armap (abfd, elength, map, orl_count, stridx) firstreal += firstreal % 2; current = current->next; } - while (current != (bfd *) map[i].pos); + while (current != map[i].u.abfd); } last_elt = current; hash = ecoff_armap_hash (*map[i].name, &rehash, hashsize, hashlog); - if (bfd_h_get_32 (abfd, (PTR) (hashtable + (hash * 8) + 4)) != 0) + if (H_GET_32 (abfd, (hashtable + (hash * 8) + 4)) != 0) { unsigned int srch; @@ -3220,35 +3262,33 @@ ecoff_write_armap (abfd, elength, map, orl_count, stridx) for (srch = (hash + rehash) & (hashsize - 1); srch != hash; srch = (srch + rehash) & (hashsize - 1)) - if (bfd_h_get_32 (abfd, (PTR) (hashtable + (srch * 8) + 4)) == 0) + if (H_GET_32 (abfd, (hashtable + (srch * 8) + 4)) == 0) break; BFD_ASSERT (srch != hash); hash = srch; } - - bfd_h_put_32 (abfd, (bfd_vma) map[i].namidx, - (PTR) (hashtable + hash * 8)); - bfd_h_put_32 (abfd, (bfd_vma) firstreal, - (PTR) (hashtable + hash * 8 + 4)); + + H_PUT_32 (abfd, map[i].namidx, (hashtable + hash * 8)); + H_PUT_32 (abfd, firstreal, (hashtable + hash * 8 + 4)); } - if (bfd_write ((PTR) hashtable, 1, symdefsize, abfd) != symdefsize) + if (bfd_bwrite ((PTR) hashtable, symdefsize, abfd) != symdefsize) return false; bfd_release (abfd, hashtable); /* Now write the strings. */ - bfd_h_put_32 (abfd, (bfd_vma) stringsize, temp); - if (bfd_write ((PTR) temp, 1, 4, abfd) != 4) + H_PUT_32 (abfd, stringsize, temp); + if (bfd_bwrite ((PTR) 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_write ((PTR) (*map[i].name), 1, len, abfd) != len) + if (bfd_bwrite ((PTR) (*map[i].name), len, abfd) != len) return false; } @@ -3256,7 +3296,7 @@ ecoff_write_armap (abfd, elength, map, orl_count, stridx) bug-compatible for DECstation ar we use a null. */ if (padit) { - if (bfd_write ("", 1, 1, abfd) != 1) + if (bfd_bwrite ("", (bfd_size_type) 1, abfd) != 1) return false; } @@ -3266,29 +3306,39 @@ ecoff_write_armap (abfd, elength, map, orl_count, stridx) /* See whether this BFD is an archive. If it is, read in the armap and the extended name table. */ -bfd_target * -ecoff_archive_p (abfd) +const bfd_target * +_bfd_ecoff_archive_p (abfd) bfd *abfd; { + struct artdata *tdata_hold; char armag[SARMAG + 1]; + bfd_size_type amt; - if (bfd_read ((PTR) armag, 1, SARMAG, abfd) != SARMAG - || strncmp (armag, ARMAG, SARMAG) != 0) + tdata_hold = abfd->tdata.aout_ar_data; + + 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 (bfd_target *) NULL; + return NULL; } /* We are setting bfd_ardata(abfd) here, but since bfd_ardata involves a cast, we can't do it as the left operand of assignment. */ - abfd->tdata.aout_ar_data = - (struct artdata *) bfd_zalloc (abfd, sizeof (struct artdata)); + amt = sizeof (struct artdata); + abfd->tdata.aout_ar_data = (struct artdata *) bfd_zalloc (abfd, amt); if (bfd_ardata (abfd) == (struct artdata *) NULL) { - bfd_set_error (bfd_error_no_memory); - return (bfd_target *) NULL; + abfd->tdata.aout_ar_data = tdata_hold; + return (const bfd_target *) NULL; } bfd_ardata (abfd)->first_file_filepos = SARMAG; @@ -3297,15 +3347,48 @@ ecoff_archive_p (abfd) bfd_ardata (abfd)->symdefs = NULL; bfd_ardata (abfd)->extended_names = NULL; bfd_ardata (abfd)->tdata = NULL; - - if (ecoff_slurp_armap (abfd) == false - || ecoff_slurp_extended_name_table (abfd) == false) + + if (_bfd_ecoff_slurp_armap (abfd) == false + || _bfd_ecoff_slurp_extended_name_table (abfd) == false) { bfd_release (abfd, bfd_ardata (abfd)); - abfd->tdata.aout_ar_data = (struct artdata *) NULL; - return (bfd_target *) NULL; + abfd->tdata.aout_ar_data = 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) + { + boolean fail; + + first->target_defaulted = false; + fail = false; + if (bfd_check_format (first, bfd_object) + && first->xvec != abfd->xvec) + { + (void) bfd_close (first); + bfd_release (abfd, bfd_ardata (abfd)); + abfd->tdata.aout_ar_data = tdata_hold; + bfd_set_error (bfd_error_wrong_format); + return NULL; + } + + /* We ought to close first here, but we can't, because we + have no way to remove it from the archive cache. FIXME. */ + } } - + return abfd->xvec; } @@ -3340,10 +3423,7 @@ ecoff_link_hash_newfunc (entry, table, string) ret = ((struct ecoff_link_hash_entry *) bfd_hash_allocate (table, sizeof (struct ecoff_link_hash_entry))); if (ret == (struct ecoff_link_hash_entry *) NULL) - { - bfd_set_error (bfd_error_no_memory); - return NULL; - } + return NULL; /* Call the allocation method of the superclass. */ ret = ((struct ecoff_link_hash_entry *) @@ -3355,6 +3435,8 @@ ecoff_link_hash_newfunc (entry, table, string) /* Set local fields. */ ret->indx = -1; ret->abfd = NULL; + ret->written = 0; + ret->small = 0; } memset ((PTR) &ret->esym, 0, sizeof ret->esym); @@ -3364,18 +3446,15 @@ ecoff_link_hash_newfunc (entry, table, string) /* Create an ECOFF link hash table. */ struct bfd_link_hash_table * -ecoff_bfd_link_hash_table_create (abfd) +_bfd_ecoff_bfd_link_hash_table_create (abfd) bfd *abfd; { struct ecoff_link_hash_table *ret; + bfd_size_type amt = sizeof (struct ecoff_link_hash_table); - ret = ((struct ecoff_link_hash_table *) - malloc (sizeof (struct ecoff_link_hash_table))); - if (!ret) - { - bfd_set_error (bfd_error_no_memory); - return NULL; - } + ret = (struct ecoff_link_hash_table *) bfd_alloc (abfd, amt); + if (ret == NULL) + return NULL; if (! _bfd_link_hash_table_init (&ret->root, abfd, ecoff_link_hash_newfunc)) { @@ -3408,7 +3487,7 @@ ecoff_bfd_link_hash_table_create (abfd) appropriate. */ boolean -ecoff_bfd_link_add_symbols (abfd, info) +_bfd_ecoff_bfd_link_add_symbols (abfd, info) bfd *abfd; struct bfd_link_info *info; { @@ -3436,6 +3515,7 @@ ecoff_link_add_archive_symbols (abfd, info) 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; @@ -3446,7 +3526,10 @@ ecoff_link_add_archive_symbols (abfd, info) if (! bfd_has_map (abfd)) { - bfd_set_error (bfd_error_no_symbols); + /* 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; } @@ -3459,7 +3542,7 @@ ecoff_link_add_archive_symbols (abfd, info) return (_bfd_generic_link_add_archive_symbols (abfd, info, ecoff_link_check_archive_element)); - armap_count = bfd_h_get_32 (abfd, raw_armap); + armap_count = H_GET_32 (abfd, raw_armap); armap_log = 0; for (i = 1; i < armap_count; i <<= 1) @@ -3512,7 +3595,7 @@ ecoff_link_add_archive_symbols (abfd, info) hash = ecoff_armap_hash (h->root.string, &rehash, armap_count, armap_log); - file_offset = bfd_h_get_32 (abfd, hashtable + (hash * 8) + 4); + file_offset = H_GET_32 (abfd, hashtable + (hash * 8) + 4); if (file_offset == 0) { /* Nothing in this slot. */ @@ -3520,7 +3603,7 @@ ecoff_link_add_archive_symbols (abfd, info) continue; } - name = stringbase + bfd_h_get_32 (abfd, hashtable + (hash * 8)); + name = stringbase + H_GET_32 (abfd, hashtable + (hash * 8)); if (name[0] != h->root.string[0] || strcmp (name, h->root.string) != 0) { @@ -3533,10 +3616,10 @@ ecoff_link_add_archive_symbols (abfd, info) srch != hash; srch = (srch + rehash) & (armap_count - 1)) { - file_offset = bfd_h_get_32 (abfd, hashtable + (srch * 8) + 4); + file_offset = H_GET_32 (abfd, hashtable + (srch * 8) + 4); if (file_offset == 0) break; - name = stringbase + bfd_h_get_32 (abfd, hashtable + (srch * 8)); + name = stringbase + H_GET_32 (abfd, hashtable + (srch * 8)); if (name[0] == h->root.string[0] && strcmp (name, h->root.string) == 0) { @@ -3554,7 +3637,7 @@ ecoff_link_add_archive_symbols (abfd, info) hash = srch; } - element = _bfd_get_elt_at_filepos (abfd, file_offset); + element = (*backend->get_elt_at_filepos) (abfd, (file_ptr) file_offset); if (element == (bfd *) NULL) return false; @@ -3589,35 +3672,42 @@ ecoff_link_check_archive_element (abfd, info, pneeded) = backend->debug_swap.swap_ext_in; HDRR *symhdr; bfd_size_type external_ext_size; - PTR external_ext; - size_t esize; - char *ssext; + 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)) - return false; + goto error_return; /* If there are no symbols, we don't want it. */ if (bfd_get_symcount (abfd) == 0) - return true; + 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) alloca (esize); - if (bfd_seek (abfd, symhdr->cbExtOffset, SEEK_SET) != 0 - || bfd_read (external_ext, 1, esize, abfd) != esize) - return false; + external_ext = (PTR) bfd_malloc (esize); + if (external_ext == NULL && esize != 0) + goto error_return; - ssext = (char *) alloca (symhdr->issExtMax); - if (bfd_seek (abfd, symhdr->cbSsExtOffset, SEEK_SET) != 0 - || bfd_read (ssext, 1, symhdr->issExtMax, abfd) != symhdr->issExtMax) - return false; + 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. */ @@ -3651,6 +3741,7 @@ ecoff_link_check_archive_element (abfd, info, pneeded) case scSCommon: case scInit: case scFini: + case scRConst: def = true; break; default: @@ -3672,15 +3763,26 @@ ecoff_link_check_archive_element (abfd, info, pneeded) /* Include this element. */ if (! (*info->callbacks->add_archive_element) (info, abfd, name)) - return false; + goto error_return; if (! ecoff_link_add_externals (abfd, info, external_ext, ssext)) - return false; + goto error_return; *pneeded = true; - return true; + goto successful_return; } + 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 @@ -3693,9 +3795,10 @@ ecoff_link_add_object_symbols (abfd, info) { HDRR *symhdr; bfd_size_type external_ext_size; - PTR external_ext; - size_t esize; - char *ssext; + PTR external_ext = NULL; + bfd_size_type esize; + char *ssext = NULL; + boolean result; if (! ecoff_slurp_symbolic_header (abfd)) return false; @@ -3709,17 +3812,37 @@ 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) alloca (esize); - if (bfd_seek (abfd, symhdr->cbExtOffset, SEEK_SET) != 0 - || bfd_read (external_ext, 1, esize, abfd) != esize) - return false; - - ssext = (char *) alloca (symhdr->issExtMax); - if (bfd_seek (abfd, symhdr->cbSsExtOffset, SEEK_SET) != 0 - || bfd_read (ssext, 1, symhdr->issExtMax, abfd) != symhdr->issExtMax) - return false; - - return ecoff_link_add_externals (abfd, info, external_ext, ssext); + 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; + + result = ecoff_link_add_externals (abfd, info, external_ext, ssext); + + if (ssext != NULL) + free (ssext); + if (external_ext != NULL) + free (external_ext); + return result; + + error_return: + if (ssext != NULL) + free (ssext); + if (external_ext != NULL) + free (external_ext); + return false; } /* Add the external symbols of an object file to the global linker @@ -3743,17 +3866,15 @@ ecoff_link_add_externals (abfd, info, external_ext, ssext) struct ecoff_link_hash_entry **sym_hash; char *ext_ptr; char *ext_end; + bfd_size_type amt; ext_count = ecoff_data (abfd)->debug_info.symbolic_header.iextMax; - sym_hash = ((struct ecoff_link_hash_entry **) - bfd_alloc (abfd, - ext_count * sizeof (struct bfd_link_hash_entry *))); + amt = ext_count; + amt *= sizeof (struct bfd_link_hash_entry *); + sym_hash = (struct ecoff_link_hash_entry **) bfd_alloc (abfd, amt); if (!sym_hash) - { - bfd_set_error (bfd_error_no_memory); - return false; - } + return false; ecoff_data (abfd)->sym_hashes = sym_hash; ext_ptr = (char *) external_ext; @@ -3823,10 +3944,10 @@ ecoff_link_add_externals (abfd, info, external_ext, ssext) value -= section->vma; break; case scAbs: - section = &bfd_abs_section; + section = bfd_abs_section_ptr; break; case scUndefined: - section = &bfd_und_section; + section = bfd_und_section_ptr; break; case scSData: section = bfd_make_section_old_way (abfd, ".sdata"); @@ -3843,7 +3964,7 @@ ecoff_link_add_externals (abfd, info, external_ext, ssext) case scCommon: if (value > ecoff_data (abfd)->gp_size) { - section = &bfd_com_section; + section = bfd_com_section_ptr; break; } /* Fall through. */ @@ -3864,7 +3985,7 @@ ecoff_link_add_externals (abfd, info, external_ext, ssext) section = &ecoff_scom_section; break; case scSUndefined: - section = &bfd_und_section; + section = bfd_und_section_ptr; break; case scInit: section = bfd_make_section_old_way (abfd, ".init"); @@ -3874,6 +3995,10 @@ ecoff_link_add_externals (abfd, info, external_ext, ssext) 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; } if (section == (asection *) NULL) @@ -3881,9 +4006,11 @@ ecoff_link_add_externals (abfd, info, external_ext, ssext) name = ssext + esym.asym.iss; + h = NULL; if (! (_bfd_generic_link_add_one_symbol - (info, abfd, name, BSF_GLOBAL, section, value, - (const char *) NULL, true, true, backend->constructor_bitsize, + (info, abfd, name, + (flagword) (esym.weakext ? BSF_WEAK : BSF_GLOBAL), + section, value, (const char *) NULL, true, true, (struct bfd_link_hash_entry **) &h))) return false; @@ -3894,13 +4021,34 @@ ecoff_link_add_externals (abfd, info, external_ext, ssext) if (info->hash->creator->flavour == bfd_get_flavour (abfd)) { if (h->abfd == (bfd *) NULL - || (section != &bfd_und_section + || (! bfd_is_und_section (section) && (! bfd_is_com_section (section) - || h->root.type != bfd_link_hash_defined))) + || (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; + + /* 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; + } } } @@ -3917,6 +4065,17 @@ static boolean ecoff_link_write_external static boolean ecoff_indirect_link_order PARAMS ((bfd *, struct bfd_link_info *, asection *, struct bfd_link_order *)); +static 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. */ + +struct extsym_info +{ + bfd *abfd; + struct bfd_link_info *info; +}; /* ECOFF final link routine. This looks through all the input BFDs and gathers together all the debugging information, and then @@ -3924,7 +4083,7 @@ static boolean ecoff_indirect_link_order close and reopen some input BFDs; I'll see how bad this is. */ boolean -ecoff_bfd_final_link (abfd, info) +_bfd_ecoff_bfd_final_link (abfd, info) bfd *abfd; struct bfd_link_info *info; { @@ -3935,6 +4094,7 @@ ecoff_bfd_final_link (abfd, info) register bfd *input_bfd; asection *o; struct bfd_link_order *p; + struct extsym_info einfo; /* We accumulate the debugging information counts in the symbolic header. */ @@ -3978,14 +4138,6 @@ ecoff_bfd_final_link (abfd, info) { boolean ret; - /* If we might be using the C based alloca function, dump memory - allocated by ecoff_final_link_debug_accumulate. */ -#ifndef __GNUC__ -#ifndef alloca - (void) alloca (0); -#endif -#endif - if (bfd_get_flavour (input_bfd) == bfd_target_ecoff_flavour) { /* Abitrarily set the symbolic header vstamp to the vstamp @@ -4013,9 +4165,11 @@ ecoff_bfd_final_link (abfd, info) } /* Write out the external symbols. */ + einfo.abfd = abfd; + einfo.info = info; ecoff_link_hash_traverse (ecoff_hash_table (info), ecoff_link_write_external, - (PTR) abfd); + (PTR) &einfo); if (info->relocateable) { @@ -4030,6 +4184,9 @@ ecoff_bfd_final_link (abfd, info) 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; } } @@ -4092,23 +4249,10 @@ ecoff_bfd_final_link (abfd, info) for (o = abfd->sections; o != (asection *) NULL; o = o->next) { - /* Ignore any link_orders for the .reginfo section, which does - not really exist. */ - if (strcmp (o->name, REGINFO) == 0) - continue; - for (p = o->link_order_head; p != (struct bfd_link_order *) NULL; p = p->next) { - /* If we might be using the C based alloca function, we need - to dump the memory allocated by the function - ecoff_indirect_link_order. */ -#ifndef __GNUC__ -#ifndef alloca - (void) alloca (0); -#endif -#endif if (p->type == bfd_indirect_link_order && (bfd_get_flavour (p->u.indirect.section->owner) == bfd_target_ecoff_flavour)) @@ -4116,6 +4260,12 @@ ecoff_bfd_final_link (abfd, info) 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)) @@ -4126,6 +4276,8 @@ ecoff_bfd_final_link (abfd, info) bfd_get_symcount (abfd) = symhdr->iextMax + symhdr->isymMax; + ecoff_data (abfd)->linker = true; + return true; } @@ -4146,29 +4298,42 @@ ecoff_final_link_debug_accumulate (output_bfd, input_bfd, info, handle) HDRR *symhdr = &debug->symbolic_header; boolean ret; -#define READ(ptr, offset, count, size, type) \ - if (symhdr->count == 0) \ - debug->ptr = NULL; \ - else \ - { \ - debug->ptr = (type) alloca (size * symhdr->count); \ - if ((bfd_seek (input_bfd, (file_ptr) symhdr->offset, SEEK_SET) \ - != 0) \ - || (bfd_read (debug->ptr, size, symhdr->count, \ - input_bfd) != size * symhdr->count)) \ - return false; \ +#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; \ + } \ } - 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); + /* 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 /* We do not read the external strings or the external symbols. */ @@ -4178,17 +4343,40 @@ ecoff_final_link_debug_accumulate (output_bfd, input_bfd, info, handle) &ecoff_backend (output_bfd)->debug_swap, input_bfd, debug, swap, info)); - /* Make sure we don't accidentally follow one of these pointers on - to the stack. */ - 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_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); + + /* 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 ret; } @@ -4201,11 +4389,24 @@ ecoff_link_write_external (h, data) struct ecoff_link_hash_entry *h; PTR data; { - bfd *output_bfd = (bfd *) data; - - /* FIXME: We should check if this symbol is being stripped. */ + struct extsym_info *einfo = (struct extsym_info *) data; + bfd *output_bfd = einfo->abfd; + boolean strip; + + /* We need to check if this symbol is being stripped. */ + if (h->root.type == bfd_link_hash_undefined + || h->root.type == bfd_link_hash_undefweak) + strip = false; + else if (einfo->info->strip == strip_all + || (einfo->info->strip == strip_some + && bfd_hash_lookup (einfo->info->keep_hash, + h->root.root.string, + false, false) == NULL)) + strip = true; + else + strip = false; - if (h->root.written) + if (strip || h->written) return true; if (h->abfd == (bfd *) NULL) @@ -4216,9 +4417,45 @@ ecoff_link_write_external (h, data) h->esym.reserved = 0; h->esym.ifd = ifdNil; h->esym.asym.value = 0; - /* FIXME: we can do better than this for st and sc. */ h->esym.asym.st = stGlobal; - h->esym.asym.sc = scAbs; + + if (h->root.type != bfd_link_hash_defined + && h->root.type != bfd_link_hash_defweak) + h->esym.asym.sc = scAbs; + else + { + asection *output_section; + const char *name; + + 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 + h->esym.asym.sc = scAbs; + } + h->esym.asym.reserved = 0; h->esym.asym.index = indexNil; } @@ -4240,12 +4477,13 @@ ecoff_link_write_external (h, data) case bfd_link_hash_new: abort (); case bfd_link_hash_undefined: - case bfd_link_hash_weak: - if (h->esym.asym.st != scUndefined - && h->esym.asym.st != scSUndefined) - h->esym.asym.st = scUndefined; + case bfd_link_hash_undefweak: + if (h->esym.asym.sc != scUndefined + && h->esym.asym.sc != scSUndefined) + h->esym.asym.sc = scUndefined; break; case bfd_link_hash_defined: + case bfd_link_hash_defweak: if (h->esym.asym.sc == scUndefined || h->esym.asym.sc == scSUndefined) h->esym.asym.sc = scAbs; @@ -4273,7 +4511,7 @@ ecoff_link_write_external (h, data) /* bfd_ecoff_debug_one_external uses iextMax to keep track of the symbol number. */ h->indx = ecoff_data (output_bfd)->debug_info.symbolic_header.iextMax; - h->root.written = true; + h->written = 1; return (bfd_ecoff_debug_one_external (output_bfd, &ecoff_data (output_bfd)->debug_info, @@ -4292,11 +4530,14 @@ ecoff_indirect_link_order (output_bfd, info, output_section, link_order) { asection *input_section; bfd *input_bfd; - bfd_size_type input_size; - bfd_byte *contents; + struct ecoff_section_tdata *section_tdata; + 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; + PTR external_relocs = NULL; + bfd_size_type amt; BFD_ASSERT ((output_section->flags & SEC_HAS_CONTENTS) != 0); @@ -4305,40 +4546,71 @@ ecoff_indirect_link_order (output_bfd, info, output_section, link_order) input_section = link_order->u.indirect.section; input_bfd = input_section->owner; + section_tdata = ecoff_section_data (input_bfd, input_section); + + 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 (bfd_section_size (input_bfd, input_section) == link_order->size); - - /* Get the section contents. */ - input_size = bfd_section_size (input_bfd, input_section); - contents = (bfd_byte *) alloca (input_size); - if (! bfd_get_section_contents (input_bfd, input_section, (PTR) contents, - (file_ptr) 0, input_size)) - return false; + 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 we are relaxing, the contents may have already been read into + memory, in which case we copy them into our new buffer. We don't + simply reuse the old buffer in case cooked_size > raw_size. */ + if (section_tdata != (struct ecoff_section_tdata *) NULL + && section_tdata->contents != (bfd_byte *) NULL) + memcpy (contents, section_tdata->contents, (size_t) raw_size); + else + { + if (! bfd_get_section_contents (input_bfd, input_section, + (PTR) contents, + (file_ptr) 0, raw_size)) + goto error_return; + } - /* Get the relocs. */ + /* 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; - external_relocs = (PTR) alloca (external_relocs_size); - if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0 - || (bfd_read (external_relocs, 1, external_relocs_size, input_bfd) - != external_relocs_size)) - return false; + + if (section_tdata != (struct ecoff_section_tdata *) NULL + && section_tdata->external_relocs != NULL) + external_relocs = section_tdata->external_relocs; + else + { + external_relocs = (PTR) bfd_malloc (external_relocs_size); + if (external_relocs == NULL && external_relocs_size != 0) + goto error_return; + + 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; + } /* Relocate the section contents. */ if (! ((*ecoff_backend (input_bfd)->relocate_section) (output_bfd, info, input_bfd, input_section, contents, external_relocs))) - return false; + goto error_return; /* Write out the relocated section. */ if (! bfd_set_section_contents (output_bfd, output_section, (PTR) contents, - input_section->output_offset, - input_size)) - return false; + (file_ptr) input_section->output_offset, + cooked_size)) + goto error_return; /* If we are producing relocateable output, the relocs were modified, and we write them out now. We use the reloc_count @@ -4346,15 +4618,233 @@ ecoff_indirect_link_order (output_bfd, info, output_section, link_order) have output so far. */ if (info->relocateable) { - if (bfd_seek (output_bfd, - (output_section->rel_filepos + - output_section->reloc_count * external_reloc_size), - SEEK_SET) != 0 - || (bfd_write (external_relocs, 1, external_relocs_size, output_bfd) + 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)) - return false; + goto error_return; output_section->reloc_count += input_section->reloc_count; } + if (contents != NULL) + free (contents); + if (external_relocs != NULL && section_tdata == NULL) + free (external_relocs); return true; + + error_return: + if (contents != NULL) + free (contents); + if (external_relocs != NULL && section_tdata == NULL) + free (external_relocs); + return false; +} + +/* 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 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; + 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; + + rel.howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc); + if (rel.howto == 0) + { + bfd_set_error (bfd_error_bad_value); + return false; + } + + 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; + + /* 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 + { + /* 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; + } + } + + /* All ECOFF relocs are in-place. Put the addend into the object + file. */ + + BFD_ASSERT (rel.howto->partial_inplace); + if (addend != 0) + { + 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) + { + 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))) + { + free (buf); + 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 a 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; + + free (rbuf); + + return ok; }