/* 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, 2002
+ Free Software Foundation, Inc.
Original version by Per Bothner.
Full support added by Ian Lance Taylor, ian@cygnus.com.
-This file is part of BFD, the Binary File Descriptor library.
+ This file is part of BFD, the Binary File Descriptor library.
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ 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. */
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
#include "bfd.h"
#include "sysdep.h"
#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
\f
/* Prototypes for static functions. */
-static int ecoff_get_magic PARAMS ((bfd *abfd));
-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,
- 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));
-static boolean ecoff_slurp_reloc_table PARAMS ((bfd *abfd, asection *section,
- asymbol **symbols));
-static void 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,
- unsigned int *rehash,
- unsigned int size,
- unsigned int hlog));
+static int ecoff_get_magic
+ PARAMS ((bfd *));
+static long ecoff_sec_to_styp_flags
+ PARAMS ((const char *, flagword));
+static bfd_boolean ecoff_slurp_symbolic_header
+ PARAMS ((bfd *));
+static bfd_boolean ecoff_set_symbol_info
+ PARAMS ((bfd *, SYMR *, asymbol *, int, int));
+static void ecoff_emit_aggregate
+ PARAMS ((bfd *, FDR *, char *, RNDXR *, long, const char *));
+static char *ecoff_type_to_string
+ PARAMS ((bfd *, FDR *, unsigned int));
+static bfd_boolean ecoff_slurp_reloc_table
+ PARAMS ((bfd *, asection *, asymbol **));
+static int ecoff_sort_hdrs
+ PARAMS ((const PTR, const PTR));
+static bfd_boolean ecoff_compute_section_file_positions
+ PARAMS ((bfd *));
+static bfd_size_type ecoff_compute_reloc_file_positions
+ PARAMS ((bfd *));
+static bfd_boolean ecoff_get_extr
+ PARAMS ((asymbol *, EXTR *));
+static void ecoff_set_index
+ PARAMS ((asymbol *, bfd_size_type));
+static unsigned int ecoff_armap_hash
+ PARAMS ((const char *, unsigned int *, unsigned int, unsigned int));
\f
/* 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_boolean
+_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;
+ return TRUE;
}
/* This is a hook called by coff_real_object_p to create any backend
specific information. */
PTR
-ecoff_mkobject_hook (abfd, filehdr, aouthdr)
+_bfd_ecoff_mkobject_hook (abfd, filehdr, aouthdr)
bfd *abfd;
PTR filehdr;
PTR 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))
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;
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
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_boolean
+_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)
- {
- /* 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);
- }
+ else if (strcmp (section->name, _LIB) == 0)
+ /* An Irix 4 shared libary. */
+ section->flags |= SEC_COFF_SHARED_LIBRARY;
/* Probably any other section name is SEC_NEVER_LOAD, but I'm
uncertain about .init on some systems and I don't know how shared
libraries work. */
- return true;
+ return TRUE;
}
/* Determine the machine architecture and type. This is called from
below. This could be an ECOFF backend routine, with one version
for each target, but there aren't all that many ECOFF targets. */
-boolean
-ecoff_set_arch_mach_hook (abfd, filehdr)
+bfd_boolean
+_bfd_ecoff_set_arch_mach_hook (abfd, filehdr)
bfd *abfd;
PTR filehdr;
{
case MIPS_MAGIC_LITTLE:
case MIPS_MAGIC_BIG:
arch = bfd_arch_mips;
- mach = 3000;
+ mach = bfd_mach_mips3000;
break;
case MIPS_MAGIC_LITTLE2:
case MIPS_MAGIC_BIG2:
- /* MIPS ISA level 2: the r6000 */
+ /* MIPS ISA level 2: the r6000. */
arch = bfd_arch_mips;
- mach = 6000;
+ mach = bfd_mach_mips6000;
break;
case MIPS_MAGIC_LITTLE3:
case MIPS_MAGIC_BIG3:
- /* MIPS ISA level 3: the r4000 */
+ /* MIPS ISA level 3: the r4000. */
arch = bfd_arch_mips;
- mach = 4000;
+ mach = bfd_mach_mips4000;
break;
case ALPHA_MAGIC:
}
/* 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)
{
default:
case 0:
- case 3000:
+ case bfd_mach_mips3000:
big = MIPS_MAGIC_BIG;
little = MIPS_MAGIC_LITTLE;
break;
- case 6000:
+ case bfd_mach_mips6000:
big = MIPS_MAGIC_BIG2;
little = MIPS_MAGIC_LITTLE2;
break;
- case 4000:
+ case bfd_mach_mips4000:
big = MIPS_MAGIC_BIG3;
little = MIPS_MAGIC_LITTLE3;
break;
}
- return abfd->xvec->byteorder_big_p ? big : little;
+ return bfd_big_endian (abfd) ? big : little;
case bfd_arch_alpha:
return ALPHA_MAGIC;
/* 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;
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;
/* Get the BFD flags to use for a section. */
-/*ARGSUSED*/
-flagword
-ecoff_styp_to_sec_flags (abfd, hdr)
- bfd *abfd;
+bfd_boolean
+_bfd_ecoff_styp_to_sec_flags (abfd, hdr, name, section, flags_ptr)
+ bfd *abfd ATTRIBUTE_UNUSED;
PTR hdr;
+ const char *name ATTRIBUTE_UNUSED;
+ asection *section ATTRIBUTE_UNUSED;
+ flagword * flags_ptr;
{
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;
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;
-}
-\f
-/* 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)
- | (ext->r_bits[3] << RNDX_BITS3_INDEX_SH_LEFT_LITTLE);
- }
-
-#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.*/
+ sec_flags |= SEC_ALLOC | SEC_LOAD;
-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;
}
\f
/* Read in the symbolic header for an ECOFF object file. */
-static boolean
+static bfd_boolean
ecoff_slurp_symbolic_header (abfd)
bfd *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;
+ return TRUE;
/* See whether there is a symbolic header. */
if (ecoff_data (abfd)->sym_filepos == 0)
{
bfd_get_symcount (abfd) = 0;
- return true;
+ return TRUE;
}
/* At this point bfd_get_symcount (abfd) holds the number of symbols
if (bfd_get_symcount (abfd) != external_hdr_size)
{
bfd_set_error (bfd_error_bad_value);
- return false;
+ return FALSE;
}
/* 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);
- return true;
+ 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_boolean
+_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;
struct fdr *fdr_ptr;
bfd_size_type raw_end;
bfd_size_type cb_end;
+ bfd_size_type amt;
+ file_ptr pos;
+
+ BFD_ASSERT (debug == &ecoff_data (abfd)->debug_info);
/* Check whether we've already gotten it, and whether there's any to
get. */
if (ecoff_data (abfd)->raw_syments != (PTR) NULL)
- return true;
+ return TRUE;
if (ecoff_data (abfd)->sym_filepos == 0)
{
bfd_get_symcount (abfd) = 0;
- return true;
+ return TRUE;
}
if (! ecoff_slurp_symbolic_header (abfd))
- return false;
+ 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
documented section. And the ordering of the sections varies between
statically and dynamically linked executables.
If bfd supports SEEK_END someday, this code could be simplified. */
-
raw_end = 0;
#define UPDATE_RAW_END(start, count, size) \
UPDATE_RAW_END (cbDnOffset, idnMax, backend->debug_swap.external_dnr_size);
UPDATE_RAW_END (cbPdOffset, ipdMax, backend->debug_swap.external_pdr_size);
UPDATE_RAW_END (cbSymOffset, isymMax, backend->debug_swap.external_sym_size);
- UPDATE_RAW_END (cbOptOffset, ioptMax, backend->debug_swap.external_opt_size);
+ /* eraxxon@alumni.rice.edu: ioptMax refers to the size of the
+ optimization symtab, not the number of entries */
+ UPDATE_RAW_END (cbOptOffset, ioptMax, sizeof (char));
UPDATE_RAW_END (cbAuxOffset, iauxMax, sizeof (union aux_ext));
UPDATE_RAW_END (cbSsOffset, issMax, sizeof (char));
UPDATE_RAW_END (cbSsExtOffset, issExtMax, sizeof (char));
if (raw_size == 0)
{
ecoff_data (abfd)->sym_filepos = 0;
- return true;
+ return TRUE;
}
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;
+ return FALSE;
}
ecoff_data (abfd)->raw_syments = raw;
/* Get pointers for the numeric offsets in the HDRR structure. */
#define FIX(off1, off2, type) \
if (internal_symhdr->off1 == 0) \
- 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);
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);
- return true;
+ return TRUE;
}
\f
/* ECOFF symbol table routines. The ECOFF symbol table is described
/* 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_zalloc (abfd, amt);
if (new == (ecoff_symbol_type *) NULL)
- {
- bfd_set_error (bfd_error_no_memory);
- return (asymbol *) NULL;
- }
- memset (new, 0, sizeof *new);
+ return (asymbol *) NULL;
new->symbol.section = (asection *) NULL;
new->fdr = (FDR *) NULL;
- new->local = false;
+ new->local = FALSE;
new->native = NULL;
new->symbol.the_bfd = abfd;
return &new->symbol;
/* Set the BFD flags and section for an ECOFF symbol. */
-static boolean
-ecoff_set_symbol_info (abfd, ecoff_sym, asym, ext, indirect_ptr_ptr)
+static bfd_boolean
+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)
if (ECOFF_IS_STAB (ecoff_sym))
{
asym->flags = BSF_DEBUGGING;
- return true;
+ return TRUE;
}
break;
default:
asym->flags = BSF_DEBUGGING;
- return true;
+ 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;
+ }
+
+ if (ecoff_sym->st == stProc || ecoff_sym->st == stStaticProc)
+ asym->flags |= BSF_FUNCTION;
+
switch (ecoff_sym->sc)
{
case scNil:
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;
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;
}
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;
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;
}
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
{
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;
section->constructor_chain = reloc_chain;
section->_raw_size += bitsize / 8;
+#endif /* 0 */
+
/* Mark the symbol as a constructor. */
asym->flags |= BSF_CONSTRUCTOR;
}
break;
}
}
- return true;
+ return TRUE;
}
/* Read an ECOFF symbol table. */
-boolean
-ecoff_slurp_symbol_table (abfd)
+bfd_boolean
+_bfd_ecoff_slurp_symbol_table (abfd)
bfd *abfd;
{
const struct ecoff_backend_data * const backend = ecoff_backend (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;
/* If we've already read in the symbol table, do nothing. */
if (ecoff_data (abfd)->canonical_symbols != NULL)
- return true;
+ return TRUE;
/* Get the symbolic information. */
- if (ecoff_slurp_symbolic_info (abfd) == false)
- return 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;
+ 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
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))
- return false;
+ &internal_ptr->symbol, 1,
+ internal_esym.weakext))
+ return FALSE;
/* The alpha uses a negative ifd field for section symbols. */
if (internal_esym.ifd >= 0)
internal_ptr->fdr = (ecoff_data (abfd)->debug_info.fdr
+ internal_esym.ifd);
else
internal_ptr->fdr = NULL;
- internal_ptr->local = false;
+ 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. */
+ fdr_ptr->issBase
+ internal_sym.iss);
if (!ecoff_set_symbol_info (abfd, &internal_sym,
- &internal_ptr->symbol, 0, &indirect_ptr))
- return false;
+ &internal_ptr->symbol, 0, 0))
+ return FALSE;
internal_ptr->fdr = fdr_ptr;
- internal_ptr->local = true;
+ internal_ptr->local = TRUE;
internal_ptr->native = (PTR) lraw_src;
}
}
- BFD_ASSERT (indirect_ptr == (asymbol *) NULL);
ecoff_data (abfd)->canonical_symbols = internal;
- return true;
+ return TRUE;
}
/* 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 *));
/* Get the canonical symbols. */
-unsigned int
-ecoff_get_symtab (abfd, alocation)
+long
+_bfd_ecoff_get_symtab (abfd, alocation)
bfd *abfd;
asymbol **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))
+ return -1;
+ if (bfd_get_symcount (abfd) == 0)
return 0;
symbase = ecoff_data (abfd)->canonical_symbols;
/* 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 = "<undefined>";
+ else if (indx == indexNil)
+ name = "<no 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;
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;
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;
qualifiers[5].type = u.ti.tq5;
qualifiers[6].type = tqNil;
- /*
- * Go get the basic type.
- */
+ /* Go get the basic type. */
switch (basic_type)
{
- case btNil: /* undefined */
+ case btNil: /* Undefined. */
strcpy (p1, "nil");
break;
- case btAdr: /* address - integer same size as pointer */
+ case btAdr: /* Address - integer same size as pointer. */
strcpy (p1, "address");
break;
- case btChar: /* character */
+ case btChar: /* Character. */
strcpy (p1, "char");
break;
- case btUChar: /* unsigned character */
+ case btUChar: /* Unsigned character. */
strcpy (p1, "unsigned char");
break;
- case btShort: /* short */
+ case btShort: /* Short. */
strcpy (p1, "short");
break;
- case btUShort: /* unsigned short */
+ case btUShort: /* Unsigned short. */
strcpy (p1, "unsigned short");
break;
- case btInt: /* int */
+ case btInt: /* Int. */
strcpy (p1, "int");
break;
- case btUInt: /* unsigned int */
+ case btUInt: /* Unsigned int. */
strcpy (p1, "unsigned int");
break;
- case btLong: /* long */
+ case btLong: /* Long. */
strcpy (p1, "long");
break;
- case btULong: /* unsigned long */
+ case btULong: /* Unsigned long. */
strcpy (p1, "unsigned long");
break;
- case btFloat: /* float (real) */
+ case btFloat: /* Float (real). */
strcpy (p1, "float");
break;
- case btDouble: /* Double (real) */
+ case btDouble: /* Double (real). */
strcpy (p1, "double");
break;
1st word is [ST_RFDESCAPE, offset] pointer to struct def;
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,
+ case btStruct: /* Structure (Record). */
+ _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 */
+ indx++; /* Skip aux words. */
break;
/* Unions add 1-2 aux words:
1st word is [ST_RFDESCAPE, offset] pointer to union def;
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,
+ case btUnion: /* Union. */
+ _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 */
+ indx++; /* Skip aux words. */
break;
/* Enumerations add 1-2 aux words:
1st word is [ST_RFDESCAPE, offset] pointer to enum def;
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,
+ case btEnum: /* Enumeration. */
+ _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 */
+ indx++; /* Skip aux words. */
break;
- case btTypedef: /* defined via a typedef, isymRef points */
+ case btTypedef: /* Defined via a typedef, isymRef points. */
strcpy (p1, "typedef");
break;
- case btRange: /* subrange of int */
+ case btRange: /* Subrange of int. */
strcpy (p1, "subrange");
break;
- case btSet: /* pascal sets */
+ case btSet: /* Pascal sets. */
strcpy (p1, "set");
break;
- case btComplex: /* fortran complex */
+ case btComplex: /* Fortran complex. */
strcpy (p1, "complex");
break;
- case btDComplex: /* fortran double complex */
+ case btDComplex: /* Fortran double complex. */
strcpy (p1, "double complex");
break;
- case btIndirect: /* forward or unnamed typedef */
+ case btIndirect: /* Forward or unnamed typedef. */
strcpy (p1, "forward/unamed typedef");
break;
- case btFixedDec: /* Fixed Decimal */
+ case btFixedDec: /* Fixed Decimal. */
strcpy (p1, "fixed decimal");
break;
- case btFloatDec: /* Float Decimal */
+ case btFloatDec: /* Float Decimal. */
strcpy (p1, "float decimal");
break;
- case btString: /* Varying Length Character String */
+ case btString: /* Varying Length Character String. */
strcpy (p1, "string");
break;
- case btBit: /* Aligned Bit String */
+ case btBit: /* Aligned Bit String. */
strcpy (p1, "bit");
break;
- case btPicture: /* Picture */
+ case btPicture: /* Picture. */
strcpy (p1, "picture");
break;
- case btVoid: /* Void */
+ case btVoid: /* Void. */
strcpy (p1, "void");
break;
default:
- sprintf (p1, "Unknown basic type %d", (int) basic_type);
+ sprintf (p1, _("Unknown basic type %d"), (int) basic_type);
break;
}
p1 += strlen (buffer1);
- /*
- * If this is a bitfield, get the bitsize.
- */
+ /* If this is a bitfield, get the bitsize. */
if (u.ti.fBitfield)
{
int bitsize;
p1 += strlen (buffer1);
}
-
- /*
- * Deal with any qualifiers.
- */
+ /* Deal with any qualifiers. */
if (qualifiers[0].type != tqNil)
{
- /*
- * Snarf up any array bounds in the correct order. Arrays
- * store 5 successive words in the aux. table:
- * word 0 RNDXR to type of the bounds (ie, int)
- * word 1 Current file descriptor index
- * word 2 low bound
- * word 3 high bound (or -1 if [])
- * word 4 stride size in bits
- */
+ /* Snarf up any array bounds in the correct order. Arrays
+ store 5 successive words in the aux. table:
+ word 0 RNDXR to type of the bounds (ie, int)
+ word 1 Current file descriptor index
+ word 2 low bound
+ word 3 high bound (or -1 if [])
+ word 4 stride size in bits. */
for (i = 0; i < 7; i++)
{
if (qualifiers[i].type == tqArray)
}
}
- /*
- * Now print out the qualifiers.
- */
+ /* Now print out the qualifiers. */
for (i = 0; i < 6; i++)
{
switch (qualifiers[i].type)
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++;
/* 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. */
+
+bfd_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;
if (ecoffsymbol (symbol)->local)
{
SYMR ecoff_sym;
-
+
(*debug_swap->swap_sym_in) (abfd, ecoffsymbol (symbol)->native,
&ecoff_sym);
fprintf (file, "ecoff local ");
}
break;
case bfd_print_symbol_all:
- /* Print out the symbols in a reasonable way */
+ /* Print out the symbols in a reasonable way. */
{
char type;
int pos;
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;
/* 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 */
+ /* This switch is basically from gcc/mips-tdump.c. */
switch (ecoff_ext.asym.st)
{
case stNil:
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:
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;
}
}
\f
/* Read in the relocs for a section. */
-static boolean
+static bfd_boolean
ecoff_slurp_reloc_table (abfd, section, symbols)
bfd *abfd;
asection *section;
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;
if (section->relocation != (arelent *) NULL
|| section->reloc_count == 0
|| (section->flags & SEC_CONSTRUCTOR) != 0)
- return true;
-
- if (ecoff_slurp_symbol_table (abfd) == false)
- return false;
-
- internal_relocs = (arelent *) bfd_alloc (abfd,
- (sizeof (arelent)
- * section->reloc_count));
+ return TRUE;
+
+ if (! _bfd_ecoff_slurp_symbol_table (abfd))
+ return FALSE;
+
+ 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;
- }
+ return FALSE;
+ if (bfd_bread (external_relocs, amt, abfd) != amt)
+ return FALSE;
for (i = 0, rptr = internal_relocs; i < section->reloc_count; i++, rptr++)
{
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. */
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 ();
}
section->relocation = internal_relocs;
- return true;
+ return TRUE;
}
/* 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;
{
unsigned int count;
- if (section->flags & SEC_CONSTRUCTOR)
+ if (section->flags & SEC_CONSTRUCTOR)
{
arelent_chain *chain;
*relptr++ = &chain->relent;
}
else
- {
+ {
arelent *tblptr;
- if (ecoff_slurp_reloc_table (abfd, section, symbols) == false)
- return 0;
+ if (! ecoff_slurp_reloc_table (abfd, section, symbols))
+ return -1;
tblptr = section->relocation;
- if (tblptr == (arelent *) NULL)
- return 0;
for (count = 0; count < section->reloc_count; count++)
*relptr++ = tblptr++;
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_boolean
+_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 (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)
+ return FALSE;
+
+ if (ecoff_data (abfd)->find_line_info == NULL)
{
- (*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);
+}
+\f
+/* 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. */
+
+bfd_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;
+ bfd_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;
+
+ return TRUE;
}
\f
/* Set the architecture. The supported architecture is stored in the
backend pointer. We always set the architecture anyhow, since many
callers ignore the return value. */
-boolean
-ecoff_set_arch_mach (abfd, arch, machine)
+bfd_boolean
+_bfd_ecoff_set_arch_mach (abfd, arch, machine)
bfd *abfd;
enum bfd_architecture arch;
unsigned long 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;
+ bfd_boolean reloc ATTRIBUTE_UNUSED;
{
asection *current;
int c;
+ int ret;
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)
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_boolean
+_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 bfd_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);
+ bfd_boolean rdata_in_text;
+ bfd_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_data = TRUE;
+ 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
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)
+ {
+ sofar = (sofar + round - 1) &~ (round - 1);
+ file_sofar = (file_sofar + round - 1) &~ (round - 1);
+ first_data = FALSE;
+ }
+ else if (strcmp (current->name, _LIB) == 0)
{
- const bfd_vma round = ecoff_backend (abfd)->round;
+ /* 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);
- first_data = false;
+ 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);
+
+ 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;
+ }
- current->filepos = sofar;
+ 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 */
+ /* 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
if (! abfd->output_has_begun)
{
- ecoff_compute_section_file_positions (abfd);
- abfd->output_has_begun = true;
+ 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
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_boolean
+_bfd_ecoff_set_section_contents (abfd, section, location, offset, count)
bfd *abfd;
asection *section;
PTR location;
file_ptr offset;
bfd_size_type count;
{
- /* 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);
+ file_ptr pos;
- if (count == 0)
- return true;
+ /* This must be done first, because bfd_set_section_contents is
+ going to set output_has_begun to TRUE. */
+ if (! abfd->output_has_begun)
+ {
+ if (! ecoff_compute_section_file_positions (abfd))
+ return FALSE;
+ }
- if (strcmp (section->name, REGINFO) == 0)
+ /* 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)
{
- ecoff_data_type *tdata = ecoff_data (abfd);
- struct ecoff_reginfo s;
- int i;
+ bfd_byte *rec, *recend;
- /* 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))
+ rec = (bfd_byte *) location;
+ recend = rec + count;
+ while (rec < recend)
{
- 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;
+ ++section->lma;
+ rec += bfd_get_32 (abfd, rec) * 4;
}
- /* 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);
+ BFD_ASSERT (rec == recend);
+ }
- 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;
+ if (count == 0)
+ return TRUE;
+
+ 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. */
- return true;
+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;
}
- if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) != 0
- || bfd_write (location, 1, count, abfd) != count)
- return false;
+ return ecoff_data (abfd)->gp;
+}
+
+/* Set the GP value for an ECOFF file. This is a hook used by the
+ assembler. */
- return true;
+bfd_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)
+ {
+ bfd_set_error (bfd_error_invalid_operation);
+ return FALSE;
+ }
+
+ ecoff_data (abfd)->gp = gp_value;
+
+ return TRUE;
+}
+
+/* Set the register masks for an ECOFF file. This is a hook used by
+ the assembler. */
+
+bfd_boolean
+bfd_ecoff_set_regmasks (abfd, gprmask, fprmask, cprmask)
+ bfd *abfd;
+ unsigned long gprmask;
+ unsigned long fprmask;
+ unsigned long *cprmask;
+{
+ ecoff_data_type *tdata;
+
+ if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour
+ || bfd_get_format (abfd) != bfd_object)
+ {
+ bfd_set_error (bfd_error_invalid_operation);
+ return FALSE;
+ }
+
+ tdata = ecoff_data (abfd);
+ tdata->gprmask = gprmask;
+ tdata->fprmask = fprmask;
+ if (cprmask != (unsigned long *) NULL)
+ {
+ int i;
+
+ for (i = 0; i < 3; i++)
+ tdata->cprmask[i] = cprmask[i];
+ }
+
+ return TRUE;
}
/* Get ECOFF EXTR information for an external symbol. This function
is passed to bfd_ecoff_debug_externals. */
-static boolean
+static bfd_boolean
ecoff_get_extr (sym, esym)
asymbol *sym;
EXTR *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. */
esym->asym.sc = scAbs;
esym->asym.reserved = 0;
esym->asym.index = indexNil;
- return true;
+ return TRUE;
}
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))
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
esym->ifd = input_debug->ifdmap[esym->ifd];
}
- return true;
+ return TRUE;
}
/* Set the external symbol index. This routine is passed to
/* Write out an ECOFF file. */
-boolean
-ecoff_write_object_contents (abfd)
+bfd_boolean
+_bfd_ecoff_write_object_contents (abfd)
bfd *abfd;
{
const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
const bfd_size_type external_hdr_size
= backend->debug_swap.external_hdr_size;
const bfd_size_type external_reloc_size = backend->external_reloc_size;
- void (* const adjust_reloc_out) PARAMS ((bfd *,
- const arelent *,
- struct internal_reloc *))
+ void (* const adjust_reloc_out)
+ PARAMS ((bfd *, const arelent *, struct internal_reloc *))
= backend->adjust_reloc_out;
- void (* const swap_reloc_out) PARAMS ((bfd *,
- const struct internal_reloc *,
- PTR))
+ void (* const swap_reloc_out)
+ PARAMS ((bfd *, const struct internal_reloc *, PTR))
= backend->swap_reloc_out;
struct ecoff_debug_info * const debug = &ecoff_data (abfd)->debug_info;
HDRR * const symhdr = &debug->symbolic_header;
bfd_size_type reloc_size;
bfd_size_type text_size;
bfd_vma text_start;
+ bfd_boolean set_text_start;
bfd_size_type data_size;
bfd_vma data_start;
+ bfd_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)
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. */
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
|| (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. */
-
internal_f.f_magic = ecoff_get_magic (abfd);
/* We will NOT put a fucking timestamp in the header here. Every
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;
for (i = 0; i < 4; i++)
internal_a.cprmask[i] = ecoff_data (abfd)->cprmask[i];
- /* Write out the file header and the optional header. */
+ /* 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;
debug->external_ext = debug->external_ext_end = NULL;
debug->ssext = debug->ssext_end = NULL;
- if (bfd_ecoff_debug_externals (abfd, debug, &backend->debug_swap,
- (((abfd->flags & EXEC_P) == 0)
- ? true : false),
- ecoff_get_extr, ecoff_set_index)
- == false)
- return false;
+ if (! bfd_ecoff_debug_externals (abfd, debug, &backend->debug_swap,
+ (abfd->flags & EXEC_P) == 0,
+ ecoff_get_extr, ecoff_set_index))
+ goto error_return;
/* Write out the relocs. */
for (current = abfd->sections;
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)
arelent *reloc;
asymbol *sym;
struct internal_reloc in;
-
- memset (&in, 0, sizeof in);
+
+ memset ((PTR) &in, 0, sizeof in);
reloc = *reloc_ptr_ptr;
sym = *reloc->sym_ptr_ptr;
}
else
{
- CONST char *name;
+ const char *name;
name = bfd_get_section_name (abfd, bfd_get_section (sym));
if (strcmp (name, ".text") == 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;
}
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. */
if (bfd_get_symcount (abfd) > 0)
{
/* Write out the debugging information. */
- if (bfd_ecoff_write_debug (abfd, debug, &backend->debug_swap,
- ecoff_data (abfd)->sym_filepos)
- == false)
- return false;
+ if (! bfd_ecoff_write_debug (abfd, debug, &backend->debug_swap,
+ ecoff_data (abfd)->sym_filepos))
+ goto error_return;
}
}
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;
}
- return true;
+ 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;
}
\f
/* Archive handling. ECOFF uses what appears to be a unique type of
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++;
/* Read in the armap. */
-boolean
-ecoff_slurp_armap (abfd)
+bfd_boolean
+_bfd_ecoff_slurp_armap (abfd)
bfd *abfd;
{
char nextname[17];
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;
+ return TRUE;
if (i != 16)
- return false;
+ 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
|| strncmp (nextname + ARMAP_END_INDEX,
ARMAP_END, sizeof ARMAP_END - 1) != 0)
{
- bfd_has_map (abfd) = false;
- return true;
+ bfd_has_map (abfd) = FALSE;
+ return TRUE;
}
/* 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;
+ return FALSE;
}
/* 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;
+ 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;
+ 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;
/* This code used to overlay the symdefs over the raw archive data,
but that doesn't work on a 64 bit host. */
-
stringbase = raw_armap + count * 8 + 8;
#ifdef CHECK_ARMAP_HASH
{
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,
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);
}
}
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;
{
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;
/* Pad to an even boundary. */
ardata->first_file_filepos += ardata->first_file_filepos % 2;
- bfd_has_map (abfd) = true;
+ bfd_has_map (abfd) = TRUE;
- return true;
+ return TRUE;
}
/* Write out an armap. */
-boolean
-ecoff_write_armap (abfd, elength, map, orl_count, stridx)
+bfd_boolean
+_bfd_ecoff_write_armap (abfd, elength, map, orl_count, stridx)
bfd *abfd;
unsigned int elength;
struct orl *map;
int stridx;
{
unsigned int hashsize, hashlog;
- unsigned int symdefsize;
+ bfd_size_type symdefsize;
int padit;
unsigned int stringsize;
unsigned int mapsize;
/* 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;
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;
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
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);
/* 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;
+ return FALSE;
+
+ H_PUT_32 (abfd, hashsize, temp);
+ if (bfd_bwrite ((PTR) temp, (bfd_size_type) 4, abfd) != 4)
+ return FALSE;
- bfd_h_put_32 (abfd, (bfd_vma) hashsize, temp);
- if (bfd_write ((PTR) temp, 1, 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;
/* 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
{
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;
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)
- return false;
+ 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)
- return false;
+ 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)
- return false;
+ if (bfd_bwrite ((PTR) (*map[i].name), len, abfd) != len)
+ return FALSE;
}
/* The spec sez this should be a newline. But in order to be
bug-compatible for DECstation ar we use a null. */
if (padit)
{
- if (bfd_write ("", 1, 1, abfd) != 1)
- return false;
+ if (bfd_bwrite ("", (bfd_size_type) 1, abfd) != 1)
+ return FALSE;
}
- return true;
+ return TRUE;
}
/* 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)
+ 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));
+ tdata_hold = bfd_ardata (abfd);
+ amt = sizeof (struct artdata);
+ bfd_ardata (abfd) = (struct artdata *) bfd_zalloc (abfd, amt);
if (bfd_ardata (abfd) == (struct artdata *) NULL)
{
- bfd_set_error (bfd_error_no_memory);
- return (bfd_target *) NULL;
+ bfd_ardata (abfd) = tdata_hold;
+ return (const bfd_target *) NULL;
}
bfd_ardata (abfd)->first_file_filepos = SARMAG;
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)
+ || ! _bfd_ecoff_slurp_extended_name_table (abfd))
{
bfd_release (abfd, bfd_ardata (abfd));
- abfd->tdata.aout_ar_data = (struct artdata *) NULL;
- return (bfd_target *) NULL;
+ bfd_ardata (abfd) = tdata_hold;
+ return (const bfd_target *) NULL;
}
-
+
+ if (bfd_has_map (abfd))
+ {
+ bfd *first;
+
+ /* This archive has a map, so we may presume that the contents
+ are object files. Make sure that if the first file in the
+ archive can be recognized as an object file, it is for this
+ target. If not, assume that this is the wrong format. If
+ the first file is not an object file, somebody is doing
+ something weird, and we permit it so that ar -t will work. */
+
+ first = bfd_openr_next_archived_file (abfd, (bfd *) NULL);
+ if (first != NULL)
+ {
+ first->target_defaulted = FALSE;
+ if (bfd_check_format (first, bfd_object)
+ && first->xvec != abfd->xvec)
+ {
+#if 0
+ /* We ought to close `first' here, but we can't, because
+ we have no way to remove it from the archive cache.
+ It's close to impossible to figure out when we can
+ release bfd_ardata. FIXME. */
+ (void) bfd_close (first);
+ bfd_release (abfd, bfd_ardata (abfd));
+#endif
+ bfd_set_error (bfd_error_wrong_object_format);
+ bfd_ardata (abfd) = tdata_hold;
+ return NULL;
+ }
+ /* And we ought to close `first' here too. */
+ }
+ }
+
return abfd->xvec;
}
\f
PARAMS ((struct bfd_hash_entry *entry,
struct bfd_hash_table *table,
const char *string));
-static boolean ecoff_link_add_archive_symbols
+static bfd_boolean ecoff_link_add_archive_symbols
PARAMS ((bfd *, struct bfd_link_info *));
-static boolean ecoff_link_check_archive_element
- PARAMS ((bfd *, struct bfd_link_info *, boolean *pneeded));
-static boolean ecoff_link_add_object_symbols
+static bfd_boolean ecoff_link_check_archive_element
+ PARAMS ((bfd *, struct bfd_link_info *, bfd_boolean *pneeded));
+static bfd_boolean ecoff_link_add_object_symbols
PARAMS ((bfd *, struct bfd_link_info *));
-static boolean ecoff_link_add_externals
+static bfd_boolean ecoff_link_add_externals
PARAMS ((bfd *, struct bfd_link_info *, PTR, char *));
/* Routine to create an entry in an ECOFF link hash table. */
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 *)
/* Set local fields. */
ret->indx = -1;
ret->abfd = NULL;
+ ret->written = 0;
+ ret->small = 0;
}
- memset (&ret->esym, 0, sizeof ret->esym);
+ memset ((PTR) &ret->esym, 0, sizeof ret->esym);
return (struct bfd_hash_entry *) ret;
}
/* 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_malloc (amt);
+ if (ret == NULL)
+ return NULL;
if (! _bfd_link_hash_table_init (&ret->root, abfd,
ecoff_link_hash_newfunc))
{
#define ecoff_link_hash_traverse(table, func, info) \
(bfd_link_hash_traverse \
(&(table)->root, \
- (boolean (*) PARAMS ((struct bfd_link_hash_entry *, PTR))) (func), \
+ (bfd_boolean (*) PARAMS ((struct bfd_link_hash_entry *, PTR))) (func), \
(info)))
/* Get the ECOFF link hash table from the info structure. This is
/* Given an ECOFF BFD, add symbols to the global hash table as
appropriate. */
-boolean
-ecoff_bfd_link_add_symbols (abfd, info)
+bfd_boolean
+_bfd_ecoff_bfd_link_add_symbols (abfd, info)
bfd *abfd;
struct bfd_link_info *info;
{
return ecoff_link_add_archive_symbols (abfd, info);
default:
bfd_set_error (bfd_error_wrong_format);
- return false;
+ return FALSE;
}
}
already have a hash table, so there is no reason to construct
another one. */
-static boolean
+static bfd_boolean
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;
if (! bfd_has_map (abfd))
{
- bfd_set_error (bfd_error_no_symbols);
- return false;
+ /* An empty archive is a special case. */
+ if (bfd_openr_next_archived_file (abfd, (bfd *) NULL) == NULL)
+ return TRUE;
+ bfd_set_error (bfd_error_no_armap);
+ return FALSE;
}
/* If we don't have any raw data for this archive, as can happen on
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)
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. */
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)
{
unsigned int srch;
- boolean found;
+ bfd_boolean found;
/* That was the wrong symbol. Try rehashing. */
- found = false;
+ found = FALSE;
for (srch = (hash + rehash) & (armap_count - 1);
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)
{
- found = true;
+ found = TRUE;
break;
}
}
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;
+ return FALSE;
if (! bfd_check_format (element, bfd_object))
- return false;
+ return FALSE;
/* Unlike the generic linker, we know that this element provides
a definition for an undefined symbol and we know that we want
to include it. We don't need to check anything. */
if (! (*info->callbacks->add_archive_element) (info, element, name))
- return false;
+ return FALSE;
if (! ecoff_link_add_object_symbols (element, info))
- return false;
+ return FALSE;
pundef = &(*pundef)->next;
}
- return true;
+ return TRUE;
}
/* This is called if we used _bfd_generic_link_add_archive_symbols
because we were not dealing with an ECOFF archive. */
-static boolean
+static bfd_boolean
ecoff_link_check_archive_element (abfd, info, pneeded)
bfd *abfd;
struct bfd_link_info *info;
- boolean *pneeded;
+ bfd_boolean *pneeded;
{
const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
void (* const swap_ext_in) PARAMS ((bfd *, PTR, EXTR *))
= backend->debug_swap.swap_ext_in;
HDRR *symhdr;
bfd_size_type external_ext_size;
- PTR external_ext;
- size_t esize;
- char *ssext;
+ PTR external_ext = NULL;
+ bfd_size_type esize;
+ char *ssext = NULL;
char *ext_ptr;
char *ext_end;
- *pneeded = false;
+ *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;
+
+ if (bfd_seek (abfd, (file_ptr) symhdr->cbExtOffset, SEEK_SET) != 0
+ || bfd_bread (external_ext, esize, abfd) != esize)
+ 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;
+ 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. */
for (; ext_ptr < ext_end; ext_ptr += external_ext_size)
{
EXTR esym;
- boolean def;
+ bfd_boolean def;
const char *name;
struct bfd_link_hash_entry *h;
case scSCommon:
case scInit:
case scFini:
- def = true;
+ case scRConst:
+ def = TRUE;
break;
default:
- def = false;
+ def = FALSE;
break;
}
continue;
name = ssext + esym.asym.iss;
- h = bfd_link_hash_lookup (info->hash, name, false, false, true);
+ h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
/* Unlike the generic linker, we do not pull in elements because
of common symbols. */
/* 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;
+ *pneeded = TRUE;
+ goto successful_return;
}
- return true;
+ successful_return:
+ if (external_ext != NULL)
+ free (external_ext);
+ if (ssext != NULL)
+ free (ssext);
+ return TRUE;
+ error_return:
+ if (external_ext != NULL)
+ free (external_ext);
+ if (ssext != NULL)
+ free (ssext);
+ return FALSE;
}
/* Add symbols from an ECOFF object file to the global linker hash
table. */
-static boolean
+static bfd_boolean
ecoff_link_add_object_symbols (abfd, info)
bfd *abfd;
struct bfd_link_info *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;
+ bfd_boolean result;
if (! ecoff_slurp_symbolic_header (abfd))
- return false;
+ return FALSE;
/* If there are no symbols, we don't want it. */
if (bfd_get_symcount (abfd) == 0)
- return true;
+ return TRUE;
symhdr = &ecoff_data (abfd)->debug_info.symbolic_header;
/* 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
explicitly save any information we may need later on in the link.
We do not want to read the external symbol information again. */
-static boolean
+static bfd_boolean
ecoff_link_add_externals (abfd, info, external_ext, ssext)
bfd *abfd;
struct bfd_link_info *info;
= backend->debug_swap.swap_ext_in;
bfd_size_type external_ext_size = backend->debug_swap.external_ext_size;
unsigned long ext_count;
- struct ecoff_link_hash_entry **sym_hash;
+ struct bfd_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 bfd_link_hash_entry **) bfd_alloc (abfd, amt);
if (!sym_hash)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
- ecoff_data (abfd)->sym_hashes = sym_hash;
+ return FALSE;
+ ecoff_data (abfd)->sym_hashes = (struct ecoff_link_hash_entry **) sym_hash;
ext_ptr = (char *) external_ext;
ext_end = ext_ptr + ext_count * external_ext_size;
for (; ext_ptr < ext_end; ext_ptr += external_ext_size, sym_hash++)
{
EXTR esym;
- boolean skip;
+ bfd_boolean skip;
bfd_vma value;
asection *section;
const char *name;
(*swap_ext_in) (abfd, (PTR) ext_ptr, &esym);
/* Skip debugging symbols. */
- skip = false;
+ skip = FALSE;
switch (esym.asym.st)
{
case stGlobal:
case stStaticProc:
break;
default:
- skip = true;
+ skip = TRUE;
break;
}
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");
case scCommon:
if (value > ecoff_data (abfd)->gp_size)
{
- section = &bfd_com_section;
+ section = bfd_com_section_ptr;
break;
}
/* Fall through. */
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");
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)
name = ssext + esym.asym.iss;
if (! (_bfd_generic_link_add_one_symbol
- (info, abfd, name, BSF_GLOBAL, section, value,
- (const char *) NULL, true, true, backend->constructor_bitsize,
- (struct bfd_link_hash_entry **) &h)))
- return false;
+ (info, abfd, name,
+ (flagword) (esym.weakext ? BSF_WEAK : BSF_GLOBAL),
+ section, value, (const char *) NULL, TRUE, TRUE, sym_hash)))
+ return FALSE;
- *sym_hash = h;
+ h = (struct ecoff_link_hash_entry *) *sym_hash;
/* If we are building an ECOFF hash table, save the external
symbol information. */
if (info->hash->creator->flavour == bfd_get_flavour (abfd))
{
if (h->abfd == (bfd *) NULL
- || (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;
+ }
}
}
- return true;
+ return TRUE;
}
\f
/* ECOFF final link routines. */
-static boolean ecoff_final_link_debug_accumulate
+static bfd_boolean ecoff_final_link_debug_accumulate
PARAMS ((bfd *output_bfd, bfd *input_bfd, struct bfd_link_info *,
PTR handle));
-static boolean ecoff_link_write_external
+static bfd_boolean ecoff_link_write_external
PARAMS ((struct ecoff_link_hash_entry *, PTR));
-static boolean ecoff_indirect_link_order
+static bfd_boolean ecoff_indirect_link_order
PARAMS ((bfd *, struct bfd_link_info *, asection *,
struct bfd_link_order *));
+static bfd_boolean ecoff_reloc_link_order
+ PARAMS ((bfd *, struct bfd_link_info *, asection *,
+ struct bfd_link_order *));
+
+/* Structure used to pass information to ecoff_link_write_external. */
+
+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
processes all the link order information. This may cause it to
close and reopen some input BFDs; I'll see how bad this is. */
-boolean
-ecoff_bfd_final_link (abfd, info)
+bfd_boolean
+_bfd_ecoff_bfd_final_link (abfd, info)
bfd *abfd;
struct bfd_link_info *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. */
handle = bfd_ecoff_debug_init (abfd, debug, &backend->debug_swap, info);
if (handle == (PTR) NULL)
- return false;
+ return FALSE;
/* Accumulate the debugging symbols from each input BFD. */
for (input_bfd = info->input_bfds;
input_bfd != (bfd *) NULL;
input_bfd = input_bfd->link_next)
{
- 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
+ bfd_boolean ret;
if (bfd_get_flavour (input_bfd) == bfd_target_ecoff_flavour)
{
debug, &backend->debug_swap,
input_bfd, info);
if (! ret)
- return false;
+ return FALSE;
/* Combine the register masks. */
ecoff_data (abfd)->gprmask |= ecoff_data (input_bfd)->gprmask;
}
/* 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)
{
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;
}
}
if (! bfd_ecoff_write_accumulated_debug (handle, abfd, debug,
&backend->debug_swap, info,
ecoff_data (abfd)->sym_filepos))
- return false;
+ return FALSE;
bfd_ecoff_debug_free (handle, abfd, debug, &backend->debug_swap, info);
{
struct bfd_link_hash_entry *h;
- h = bfd_link_hash_lookup (info->hash, "_gp", false, false, true);
+ h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
if (h != (struct bfd_link_hash_entry *) NULL
&& h->type == bfd_link_hash_defined)
ecoff_data (abfd)->gp = (h->u.def.value
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))
{
if (! ecoff_indirect_link_order (abfd, info, o, p))
- return false;
+ return FALSE;
+ }
+ else if (p->type == bfd_section_reloc_link_order
+ || p->type == bfd_symbol_reloc_link_order)
+ {
+ if (! ecoff_reloc_link_order (abfd, info, o, p))
+ return FALSE;
}
else
{
if (! _bfd_default_link_order (abfd, info, o, p))
- return false;
+ return FALSE;
}
}
}
bfd_get_symcount (abfd) = symhdr->iextMax + symhdr->isymMax;
- return true;
+ ecoff_data (abfd)->linker = TRUE;
+
+ return TRUE;
}
/* Accumulate the debugging information for an input BFD into the
output BFD. This must read in the symbolic information of the
input BFD. */
-static boolean
+static bfd_boolean
ecoff_final_link_debug_accumulate (output_bfd, input_bfd, info, handle)
bfd *output_bfd;
bfd *input_bfd;
const struct ecoff_debug_swap * const swap =
&ecoff_backend (input_bfd)->debug_swap;
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; \
+ bfd_boolean ret;
+
+#define READ(ptr, offset, count, size, type) \
+ if (symhdr->count == 0) \
+ debug->ptr = NULL; \
+ else \
+ { \
+ bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
+ debug->ptr = (type) bfd_malloc (amt); \
+ if (debug->ptr == NULL) \
+ { \
+ ret = FALSE; \
+ goto return_something; \
+ } \
+ if (bfd_seek (input_bfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
+ || bfd_bread (debug->ptr, amt, input_bfd) != amt) \
+ { \
+ ret = FALSE; \
+ goto return_something; \
+ } \
}
- 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. */
&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;
}
/* Put out information for an external symbol. These come only from
the hash table. */
-static boolean
+static bfd_boolean
ecoff_link_write_external (h, data)
struct ecoff_link_hash_entry *h;
PTR data;
{
- bfd *output_bfd = (bfd *) data;
+ struct extsym_info *einfo = (struct extsym_info *) data;
+ bfd *output_bfd = einfo->abfd;
+ bfd_boolean strip;
- /* FIXME: We should check if this symbol is being stripped. */
+ if (h->root.type == bfd_link_hash_warning)
+ {
+ h = (struct ecoff_link_hash_entry *) h->root.u.i.link;
+ if (h->root.type == bfd_link_hash_new)
+ return TRUE;
+ }
- if (h->root.written)
- return true;
+ /* 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 (strip || h->written)
+ return TRUE;
if (h->abfd == (bfd *) NULL)
{
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;
}
switch (h->root.type)
{
default:
+ case bfd_link_hash_warning:
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;
h->esym.asym.value = h->root.u.c.size;
break;
case bfd_link_hash_indirect:
- case bfd_link_hash_warning:
- /* FIXME: Ignore these for now. The circumstances under which
- they should be written out are not clear to me. */
- return true;
+ /* We ignore these symbols, since the indirected symbol is
+ already in the hash table. */
+ return TRUE;
}
/* 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,
/* Relocate and write an ECOFF section into an ECOFF output file. */
-static boolean
+static bfd_boolean
ecoff_indirect_link_order (output_bfd, info, output_section, link_order)
bfd *output_bfd;
struct bfd_link_info *info;
{
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);
if (link_order->size == 0)
- return true;
+ return TRUE;
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
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;
}
- return true;
+ 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 bfd_boolean
+ecoff_reloc_link_order (output_bfd, info, output_section, link_order)
+ bfd *output_bfd;
+ struct bfd_link_info *info;
+ asection *output_section;
+ struct bfd_link_order *link_order;
+{
+ enum bfd_link_order_type type;
+ asection *section;
+ bfd_vma addend;
+ arelent rel;
+ struct internal_reloc in;
+ bfd_size_type external_reloc_size;
+ bfd_byte *rbuf;
+ bfd_boolean ok;
+ file_ptr pos;
+
+ 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 an internal_reloc structure. */
+ in.r_vaddr = (rel.address
+ + bfd_get_section_vma (output_bfd, output_section));
+ in.r_type = rel.howto->type;
+
+ if (type == bfd_symbol_reloc_link_order)
+ {
+ struct ecoff_link_hash_entry *h;
+
+ h = ((struct ecoff_link_hash_entry *)
+ bfd_wrapped_link_hash_lookup (output_bfd, info,
+ link_order->u.reloc.p->u.name,
+ FALSE, FALSE, TRUE));
+ if (h != (struct ecoff_link_hash_entry *) NULL
+ && h->indx != -1)
+ in.r_symndx = h->indx;
+ else
+ {
+ if (! ((*info->callbacks->unattached_reloc)
+ (info, link_order->u.reloc.p->u.name, (bfd *) NULL,
+ (asection *) NULL, (bfd_vma) 0)))
+ return FALSE;
+ in.r_symndx = 0;
+ }
+ in.r_extern = 1;
+ }
+ else
+ {
+ const char *name;
+
+ name = bfd_get_section_name (output_bfd, section);
+ if (strcmp (name, ".text") == 0)
+ in.r_symndx = RELOC_SECTION_TEXT;
+ else if (strcmp (name, ".rdata") == 0)
+ in.r_symndx = RELOC_SECTION_RDATA;
+ else if (strcmp (name, ".data") == 0)
+ in.r_symndx = RELOC_SECTION_DATA;
+ else if (strcmp (name, ".sdata") == 0)
+ in.r_symndx = RELOC_SECTION_SDATA;
+ else if (strcmp (name, ".sbss") == 0)
+ in.r_symndx = RELOC_SECTION_SBSS;
+ else if (strcmp (name, ".bss") == 0)
+ in.r_symndx = RELOC_SECTION_BSS;
+ else if (strcmp (name, ".init") == 0)
+ in.r_symndx = RELOC_SECTION_INIT;
+ else if (strcmp (name, ".lit8") == 0)
+ in.r_symndx = RELOC_SECTION_LIT8;
+ else if (strcmp (name, ".lit4") == 0)
+ in.r_symndx = RELOC_SECTION_LIT4;
+ else if (strcmp (name, ".xdata") == 0)
+ in.r_symndx = RELOC_SECTION_XDATA;
+ else if (strcmp (name, ".pdata") == 0)
+ in.r_symndx = RELOC_SECTION_PDATA;
+ else if (strcmp (name, ".fini") == 0)
+ in.r_symndx = RELOC_SECTION_FINI;
+ else if (strcmp (name, ".lita") == 0)
+ in.r_symndx = RELOC_SECTION_LITA;
+ else if (strcmp (name, "*ABS*") == 0)
+ in.r_symndx = RELOC_SECTION_ABS;
+ else if (strcmp (name, ".rconst") == 0)
+ in.r_symndx = RELOC_SECTION_RCONST;
+ else
+ abort ();
+ in.r_extern = 0;
+ }
+
+ /* Let the BFD backend adjust the reloc. */
+ (*ecoff_backend (output_bfd)->adjust_reloc_out) (output_bfd, &rel, &in);
+
+ /* Get some memory and swap out the reloc. */
+ external_reloc_size = ecoff_backend (output_bfd)->external_reloc_size;
+ rbuf = (bfd_byte *) bfd_malloc (external_reloc_size);
+ if (rbuf == (bfd_byte *) NULL)
+ return FALSE;
+
+ (*ecoff_backend (output_bfd)->swap_reloc_out) (output_bfd, &in, (PTR) rbuf);
+
+ pos = (output_section->rel_filepos
+ + output_section->reloc_count * external_reloc_size);
+ ok = (bfd_seek (output_bfd, pos, SEEK_SET) == 0
+ && (bfd_bwrite ((PTR) rbuf, external_reloc_size, output_bfd)
+ == external_reloc_size));
+
+ if (ok)
+ ++output_section->reloc_count;
+
+ free (rbuf);
+
+ return ok;
}