/* Generic ECOFF (Extended-COFF) routines.
- Copyright 1990, 91, 92, 93, 94, 95, 1996 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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"
\f
/* Prototypes for static functions. */
-static int ecoff_get_magic PARAMS ((bfd *abfd));
-static long ecoff_sec_to_styp_flags PARAMS ((const char *name,
- flagword flags));
-static boolean ecoff_slurp_symbolic_header PARAMS ((bfd *abfd));
-static boolean ecoff_set_symbol_info PARAMS ((bfd *abfd, SYMR *ecoff_sym,
- asymbol *asym, int ext, int weak));
-static void ecoff_emit_aggregate PARAMS ((bfd *abfd, FDR *fdr,
- char *string,
- RNDXR *rndx, long isym,
- const char *which));
-static char *ecoff_type_to_string PARAMS ((bfd *abfd, FDR *fdr,
- unsigned int indx));
-static boolean ecoff_slurp_reloc_table PARAMS ((bfd *abfd, asection *section,
- asymbol **symbols));
+static int ecoff_get_magic PARAMS ((bfd *));
+static long ecoff_sec_to_styp_flags PARAMS ((const char *, flagword));
+static boolean ecoff_slurp_symbolic_header PARAMS ((bfd *));
+static 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 boolean ecoff_slurp_reloc_table PARAMS ((bfd *, asection *, asymbol **));
static int ecoff_sort_hdrs PARAMS ((const PTR, const PTR));
-static boolean ecoff_compute_section_file_positions PARAMS ((bfd *abfd));
-static bfd_size_type ecoff_compute_reloc_file_positions PARAMS ((bfd *abfd));
+static boolean ecoff_compute_section_file_positions PARAMS ((bfd *));
+static bfd_size_type ecoff_compute_reloc_file_positions PARAMS ((bfd *));
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 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. */
_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)
return false;
struct internal_aouthdr *internal_a = (struct internal_aouthdr *) aouthdr;
ecoff_data_type *ecoff;
- if (_bfd_ecoff_mkobject (abfd) == false)
+ if (! _bfd_ecoff_mkobject (abfd))
return NULL;
ecoff = ecoff_data (abfd);
boolean
_bfd_ecoff_new_section_hook (abfd, section)
- bfd *abfd;
+ bfd *abfd ATTRIBUTE_UNUSED;
asection *section;
{
- /* For the .pdata section, which has a special meaning on the Alpha,
- we set the alignment power to 3. 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. For every other
- section we use an alignment power of 4; this could be made target
- dependent by adding a field to ecoff_backend_data, but 4 appears
- to be correct for both the MIPS and the Alpha. */
- if (strcmp (section->name, _PDATA) == 0)
- section->alignment_power = 3;
- else
- section->alignment_power = 4;
+ 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)
else if (strcmp (section->name, _RDATA) == 0
|| strcmp (section->name, _LIT8) == 0
|| strcmp (section->name, _LIT4) == 0
- || strcmp (section->name, _RCONST) == 0)
+ || strcmp (section->name, _RCONST) == 0
+ || strcmp (section->name, _PDATA) == 0)
section->flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC | SEC_READONLY;
else if (strcmp (section->name, _BSS) == 0
|| strcmp (section->name, _SBSS) == 0)
section->flags |= SEC_ALLOC;
else if (strcmp (section->name, _LIB) == 0)
- {
- /* An Irix 4 shared libary. */
- section->flags |= SEC_COFF_SHARED_LIBRARY;
- }
+ /* 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
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:
{
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;
}
else if (strcmp (name, _RCONST) == 0)
styp = STYP_RCONST;
- else if (flags & SEC_CODE)
+ 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
-_bfd_ecoff_styp_to_sec_flags (abfd, hdr, name)
- bfd *abfd;
+boolean
+_bfd_ecoff_styp_to_sec_flags (abfd, hdr, name, section, flags_ptr)
+ bfd *abfd ATTRIBUTE_UNUSED;
PTR hdr;
- const char *name;
+ 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;
}
else if ((styp_flags & STYP_BSS)
|| (styp_flags & STYP_SBSS))
- {
- sec_flags |= SEC_ALLOC;
- }
+ sec_flags |= SEC_ALLOC;
else if ((styp_flags & STYP_INFO) || styp_flags == STYP_COMMENT)
- {
- sec_flags |= SEC_NEVER_LOAD;
- }
+ 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;
- }
+ sec_flags |= SEC_COFF_SHARED_LIBRARY;
else
- {
- sec_flags |= SEC_ALLOC | SEC_LOAD;
- }
+ sec_flags |= SEC_ALLOC | SEC_LOAD;
- return sec_flags;
+ * flags_ptr = sec_flags;
+ return true;
}
\f
/* Read in the symbolic header for an ECOFF object file. */
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;
}
/* Read the symbolic information header. */
- raw = (PTR) bfd_malloc ((size_t) external_hdr_size);
+ raw = (PTR) bfd_malloc (external_hdr_size);
if (raw == NULL)
goto error_return;
- if (bfd_seek (abfd, ecoff_data (abfd)->sym_filepos, SEEK_SET) == -1
- || (bfd_read (raw, external_hdr_size, 1, abfd)
- != external_hdr_size))
+ 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);
object file. This is called by gdb via the read_debug_info entry
point in the backend structure. */
-/*ARGSUSED*/
boolean
_bfd_ecoff_slurp_symbolic_info (abfd, ignore, debug)
bfd *abfd;
- asection *ignore;
+ asection *ignore ATTRIBUTE_UNUSED;
struct ecoff_debug_info *debug;
{
const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
struct fdr *fdr_ptr;
bfd_size_type raw_end;
bfd_size_type cb_end;
+ bfd_size_type amt;
+ file_ptr pos;
BFD_ASSERT (debug == &ecoff_data (abfd)->debug_info);
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));
raw = (PTR) bfd_alloc (abfd, raw_size);
if (raw == NULL)
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)
+
+ 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_release (abfd, raw);
return false;
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. */
- debug->fdr = (struct fdr *) bfd_alloc (abfd,
- (internal_symhdr->ifdMax *
- sizeof (struct fdr)));
+ 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;
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)
return (asymbol *) NULL;
- memset ((PTR) new, 0, sizeof *new);
new->symbol.section = (asection *) NULL;
new->fdr = (FDR *) NULL;
new->local = false;
|| 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:
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)
return false;
strcpy (copy, name);
}
/* 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)
return false;
reloc_chain->relent.sym_ptr_ptr =
section->constructor_chain = reloc_chain;
section->_raw_size += bitsize / 8;
+#endif /* 0 */
+
/* Mark the symbol as a constructor. */
asym->flags |= BSF_CONSTRUCTOR;
}
if (bfd_get_symcount (abfd) == 0)
return true;
- internal_size = bfd_get_symcount (abfd) * sizeof (ecoff_symbol_type);
+ internal_size = bfd_get_symcount (abfd);
+ internal_size *= sizeof (ecoff_symbol_type);
internal = (ecoff_symbol_type *) bfd_alloc (abfd, internal_size);
if (internal == NULL)
return false;
ecoff_symbol_type *symbase;
ecoff_symbol_type **location = (ecoff_symbol_type **) alocation;
- if (_bfd_ecoff_slurp_symbol_table (abfd) == false)
+ if (! _bfd_ecoff_slurp_symbol_table (abfd))
return -1;
if (bfd_get_symcount (abfd) == 0)
return 0;
unsigned int ifd = rndx->rfd;
unsigned int indx = rndx->index;
const char *name;
-
+
if (ifd == 0xfff)
ifd = isym;
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) */
+ 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 */
+ 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 */
+ 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
_bfd_ecoff_get_symbol_info (abfd, symbol, ret)
- bfd *abfd; /* Ignored. */
+ bfd *abfd ATTRIBUTE_UNUSED;
asymbol *symbol;
symbol_info *ret;
{
/* Return whether this is a local label. */
-/*ARGSUSED*/
boolean
-_bfd_ecoff_bfd_is_local_label (abfd, symbol)
- bfd *abfd;
- asymbol *symbol;
+_bfd_ecoff_bfd_is_local_label_name (abfd, name)
+ bfd *abfd ATTRIBUTE_UNUSED;
+ const char *name;
{
- return symbol->name[0] == '$';
+ return name[0] == '$';
}
/* Print information about an ECOFF 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;
order is indicated by a bit in the fdr. */
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",
+ fprintf (file, _("\n First symbol: %ld"),
((long)
(AUX_GET_ISYM (bigendian,
&aux_base[ecoff_ext.asym.index])
if (ECOFF_IS_STAB (&ecoff_ext.asym))
;
else if (ecoffsymbol (symbol)->local)
- fprintf (file, "\n End+1 symbol: %-7ld Type: %s",
+ 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)
break;
case stStruct:
- fprintf (file, "\n struct; End+1 symbol: %ld",
+ fprintf (file, _("\n struct; End+1 symbol: %ld"),
(long) (indx + sym_base));
break;
case stUnion:
- fprintf (file, "\n union; End+1 symbol: %ld",
+ fprintf (file, _("\n union; End+1 symbol: %ld"),
(long) (indx + sym_base));
break;
case stEnum:
- fprintf (file, "\n enum; End+1 symbol: %ld",
+ 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",
+ fprintf (file, _("\n Type: %s"),
ecoff_type_to_string (abfd, fdr, indx));
break;
}
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;
|| (section->flags & SEC_CONSTRUCTOR) != 0)
return true;
- if (_bfd_ecoff_slurp_symbol_table (abfd) == false)
+ if (! _bfd_ecoff_slurp_symbol_table (abfd))
return false;
-
- internal_relocs = (arelent *) bfd_alloc (abfd,
- (sizeof (arelent)
- * section->reloc_count));
+
+ amt = section->reloc_count;
+ amt *= sizeof (arelent);
+ internal_relocs = (arelent *) bfd_alloc (abfd, amt);
+
external_reloc_size = backend->external_reloc_size;
- external_relocs_size = external_reloc_size * section->reloc_count;
- external_relocs = (char *) bfd_alloc (abfd, external_relocs_size);
+ amt = external_reloc_size * section->reloc_count;
+ external_relocs = (char *) bfd_alloc (abfd, amt);
if (internal_relocs == (arelent *) NULL
|| external_relocs == (char *) NULL)
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)
+ if (bfd_bread (external_relocs, amt, abfd) != amt)
return false;
for (i = 0, rptr = internal_relocs; i < section->reloc_count; i++, rptr++)
}
else
{
- CONST char *sec_name;
+ const char *sec_name;
asection *sec;
/* r_symndx is a section key. */
{
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)
+ if (! ecoff_slurp_reloc_table (abfd, section, symbols))
return -1;
tblptr = section->relocation;
and return the name of the source file and the line nearest to the
wanted location. */
-/*ARGSUSED*/
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
if (ecoff_data (abfd)->find_line_info == NULL)
{
- ecoff_data (abfd)->find_line_info =
- ((struct ecoff_find_line *)
- bfd_zalloc (abfd, sizeof (struct ecoff_find_line)));
+ 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;
}
size_t c;
boolean local;
- /* This function is selected based on the input vector. We only
- want to copy information over if the output BFD also uses ECOFF
+ /* We only want to copy information over if both BFD's use ECOFF
format. */
- if (bfd_get_flavour (obfd) != bfd_target_ecoff_flavour)
+ 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. */
/* Get the size of the section headers. */
-/*ARGSUSED*/
int
_bfd_ecoff_sizeof_headers (abfd, reloc)
bfd *abfd;
- boolean reloc;
+ boolean reloc ATTRIBUTE_UNUSED;
{
asection *current;
int c;
c = 0;
for (current = abfd->sections;
- current != (asection *)NULL;
- current = current->next)
+ current != (asection *)NULL;
+ current = current->next)
++c;
ret = (bfd_coff_filhsz (abfd)
asection *current;
unsigned int i;
file_ptr old_sofar;
+ boolean rdata_in_text;
boolean first_data, first_nonalloc;
const bfd_vma round = ecoff_backend (abfd)->round;
+ bfd_size_type amt;
sofar = _bfd_ecoff_sizeof_headers (abfd, false);
file_sofar = sofar;
/* Sort the sections by VMA. */
- sorted_hdrs = (asection **) bfd_malloc (abfd->section_count
- * sizeof (asection *));
+ 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;
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;
first_nonalloc = true;
for (i = 0; i < abfd->section_count; i++)
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
&& (abfd->flags & D_PAGED) != 0
&& ! 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, _RCONST) != 0)
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)
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 (current->reloc_count == 0)
current->rel_filepos = 0;
file_ptr offset;
bfd_size_type count;
{
+ file_ptr pos;
+
/* This must be done first, because bfd_set_section_contents is
going to set output_has_begun to true. */
- if (abfd->output_has_begun == false)
+ if (! abfd->output_has_begun)
{
if (! ecoff_compute_section_file_positions (abfd))
return false;
if (count == 0)
return true;
- if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) != 0
- || bfd_write (location, 1, count, abfd) != count)
+ pos = section->filepos + offset;
+ if (bfd_seek (abfd, pos, SEEK_SET) != 0
+ || bfd_bwrite (location, count, abfd) != count)
return false;
return true;
bfd_set_error (bfd_error_invalid_operation);
return 0;
}
-
+
return ecoff_data (abfd)->gp;
}
tdata->fprmask = fprmask;
if (cprmask != (unsigned long *) NULL)
{
- register int i;
+ int i;
for (i = 0; i < 3; i++)
tdata->cprmask[i] = cprmask[i];
count = 1;
for (current = abfd->sections;
- current != (asection *)NULL;
- current = current->next)
+ current != (asection *)NULL;
+ current = current->next)
{
current->target_index = count;
++count;
siz = filhsz;
if (siz < aoutsz)
siz = aoutsz;
- buff = (PTR) bfd_malloc ((size_t) siz);
+ buff = (PTR) bfd_malloc (siz);
if (buff == NULL)
goto error_return;
}
current->flags);
if (bfd_coff_swap_scnhdr_out (abfd, (PTR) §ion, buff) == 0
- || bfd_write (buff, 1, scnhsz, abfd) != scnhsz)
+ || 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)
+ && ecoff_data (abfd)->rdata_in_text)
|| section.s_flags == STYP_PDATA
|| (section.s_flags & STYP_DYNAMIC) != 0
|| (section.s_flags & STYP_LIBLIST) != 0
else if (section.s_flags == 0
|| (section.s_flags & STYP_ECOFF_LIB) != 0
|| section.s_flags == STYP_COMMENT)
- /* Do nothing */ ;
+ /* 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
}
/* Write out the file header and the optional header. */
-
if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
goto error_return;
bfd_coff_swap_filehdr_out (abfd, (PTR) &internal_f, buff);
- if (bfd_write (buff, 1, filhsz, abfd) != filhsz)
+ if (bfd_bwrite (buff, filhsz, abfd) != filhsz)
goto error_return;
bfd_coff_swap_aouthdr_out (abfd, (PTR) &internal_a, buff);
- if (bfd_write (buff, 1, aoutsz, abfd) != aoutsz)
+ if (bfd_bwrite (buff, aoutsz, abfd) != aoutsz)
goto error_return;
/* Build the external symbol information. This must be done before
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)
+ 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. */
arelent **reloc_ptr_ptr;
arelent **reloc_end;
char *out_ptr;
+ bfd_size_type amt;
if (current->reloc_count == 0)
continue;
- reloc_buff =
- bfd_alloc (abfd, current->reloc_count * external_reloc_size);
+ amt = current->reloc_count * external_reloc_size;
+ reloc_buff = bfd_alloc (abfd, amt);
if (reloc_buff == NULL)
goto error_return;
arelent *reloc;
asymbol *sym;
struct internal_reloc in;
-
+
memset ((PTR) &in, 0, sizeof in);
reloc = *reloc_ptr_ptr;
}
else
{
- CONST char *name;
+ const char *name;
name = bfd_get_section_name (abfd, bfd_get_section (sym));
if (strcmp (name, ".text") == 0)
if (bfd_seek (abfd, current->rel_filepos, SEEK_SET) != 0)
goto error_return;
- if (bfd_write (reloc_buff,
- external_reloc_size, current->reloc_count, abfd)
- != external_reloc_size * current->reloc_count)
+ 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;
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)
+ 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)
goto error_return;
- if (bfd_read (&c, 1, 1, abfd) == 0)
+ 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)
goto error_return;
- if (bfd_write (&c, 1, 1, abfd) != 1)
+ if (bfd_bwrite (&c, (bfd_size_type) 1, abfd) != 1)
goto error_return;
}
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++;
char *raw_ptr;
struct symdef *symdef_ptr;
char *stringbase;
-
+ bfd_size_type amt;
+
/* Get the name of the first element. */
- i = bfd_read ((PTR) nextname, 1, 16, abfd);
+ i = bfd_bread ((PTR) nextname, (bfd_size_type) 16, abfd);
if (i == 0)
return true;
if (i != 16)
return false;
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_read ((PTR) raw_armap, 1, parsed_size, abfd) != parsed_size)
+
+ if (bfd_bread ((PTR) raw_armap, parsed_size, abfd) != parsed_size)
{
if (bfd_get_error () != bfd_error_system_call)
bfd_set_error (bfd_error_malformed_archive);
bfd_release (abfd, (PTR) raw_armap);
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)
return false;
{
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;
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;
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;
- bfd_h_put_32 (abfd, (bfd_vma) hashsize, temp);
- if (bfd_write ((PTR) temp, 1, 4, abfd) != 4)
+ H_PUT_32 (abfd, hashsize, temp);
+ if (bfd_bwrite ((PTR) temp, (bfd_size_type) 4, abfd) != 4)
return false;
-
+
hashtable = (bfd_byte *) bfd_zalloc (abfd, symdefsize);
if (!hashtable)
return false;
/* 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)
+ if (bfd_bwrite ((PTR) hashtable, symdefsize, abfd) != symdefsize)
return false;
bfd_release (abfd, hashtable);
/* Now write the strings. */
- bfd_h_put_32 (abfd, (bfd_vma) stringsize, temp);
- if (bfd_write ((PTR) temp, 1, 4, abfd) != 4)
+ H_PUT_32 (abfd, stringsize, temp);
+ if (bfd_bwrite ((PTR) temp, (bfd_size_type) 4, abfd) != 4)
return false;
for (i = 0; i < orl_count; i++)
{
bfd_size_type len;
len = strlen (*map[i].name) + 1;
- if (bfd_write ((PTR) (*map[i].name), 1, len, abfd) != len)
+ if (bfd_bwrite ((PTR) (*map[i].name), len, abfd) != len)
return false;
}
bug-compatible for DECstation ar we use a null. */
if (padit)
{
- if (bfd_write ("", 1, 1, abfd) != 1)
+ if (bfd_bwrite ("", (bfd_size_type) 1, abfd) != 1)
return false;
}
_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;
}
- /* 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));
+ if (strncmp (armag, ARMAG, SARMAG) != 0)
+ {
+ bfd_set_error (bfd_error_wrong_format);
+ return NULL;
+ }
+
+ tdata_hold = bfd_ardata (abfd);
+ amt = sizeof (struct artdata);
+ bfd_ardata (abfd) = (struct artdata *) bfd_zalloc (abfd, amt);
if (bfd_ardata (abfd) == (struct artdata *) NULL)
- return (const bfd_target *) NULL;
+ {
+ bfd_ardata (abfd) = tdata_hold;
+ return (const bfd_target *) NULL;
+ }
bfd_ardata (abfd)->first_file_filepos = SARMAG;
bfd_ardata (abfd)->cache = NULL;
bfd_ardata (abfd)->symdefs = NULL;
bfd_ardata (abfd)->extended_names = NULL;
bfd_ardata (abfd)->tdata = NULL;
-
- if (_bfd_ecoff_slurp_armap (abfd) == false
- || _bfd_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;
+ 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
bfd *abfd;
{
struct ecoff_link_hash_table *ret;
+ bfd_size_type amt = sizeof (struct ecoff_link_hash_table);
- ret = ((struct ecoff_link_hash_table *)
- bfd_alloc (abfd, sizeof (struct ecoff_link_hash_table)));
+ ret = (struct ecoff_link_hash_table *) bfd_malloc (amt);
if (ret == NULL)
return NULL;
if (! _bfd_link_hash_table_init (&ret->root, abfd,
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)
{
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)
{
hash = srch;
}
- element = (*backend->get_elt_at_filepos) (abfd, file_offset);
+ element = (*backend->get_elt_at_filepos) (abfd, (file_ptr) file_offset);
if (element == (bfd *) NULL)
return false;
HDRR *symhdr;
bfd_size_type external_ext_size;
PTR external_ext = NULL;
- size_t esize;
+ bfd_size_type esize;
char *ssext = NULL;
char *ext_ptr;
char *ext_end;
if (external_ext == NULL && esize != 0)
goto error_return;
- if (bfd_seek (abfd, symhdr->cbExtOffset, SEEK_SET) != 0
- || bfd_read (external_ext, 1, esize, abfd) != esize)
+ 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 (symhdr->issExtMax);
+ ssext = (char *) bfd_malloc ((bfd_size_type) symhdr->issExtMax);
if (ssext == NULL && symhdr->issExtMax != 0)
goto error_return;
- if (bfd_seek (abfd, symhdr->cbSsExtOffset, SEEK_SET) != 0
- || (bfd_read (ssext, 1, symhdr->issExtMax, abfd) !=
- (bfd_size_type) symhdr->issExtMax))
+ 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
HDRR *symhdr;
bfd_size_type external_ext_size;
PTR external_ext = NULL;
- size_t esize;
+ bfd_size_type esize;
char *ssext = NULL;
boolean result;
if (external_ext == NULL && esize != 0)
goto error_return;
- if (bfd_seek (abfd, symhdr->cbExtOffset, SEEK_SET) != 0
- || bfd_read (external_ext, 1, esize, abfd) != esize)
+ 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 (symhdr->issExtMax);
+ ssext = (char *) bfd_malloc ((bfd_size_type) symhdr->issExtMax);
if (ssext == NULL && symhdr->issExtMax != 0)
goto error_return;
- if (bfd_seek (abfd, symhdr->cbSsExtOffset, SEEK_SET) != 0
- || (bfd_read (ssext, 1, symhdr->issExtMax, abfd)
+ 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;
= 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)
return false;
- ecoff_data (abfd)->sym_hashes = sym_hash;
+ 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;
name = ssext + esym.asym.iss;
- h = NULL;
if (! (_bfd_generic_link_add_one_symbol
(info, abfd, name,
- esym.weakext ? BSF_WEAK : BSF_GLOBAL,
- section, value, (const char *) NULL, true, true,
- (struct bfd_link_hash_entry **) &h)))
+ (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. */
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) bfd_malloc ((size_t) (size * symhdr->count)); \
- if (debug->ptr == NULL) \
- { \
- ret = false; \
- goto return_something; \
- } \
- if ((bfd_seek (input_bfd, (file_ptr) symhdr->offset, SEEK_SET) \
- != 0) \
- || (bfd_read (debug->ptr, size, symhdr->count, \
- input_bfd) != size * symhdr->count)) \
- { \
- ret = false; \
- goto return_something; \
- } \
+#define READ(ptr, offset, count, size, type) \
+ if (symhdr->count == 0) \
+ debug->ptr = NULL; \
+ else \
+ { \
+ bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
+ debug->ptr = (type) bfd_malloc (amt); \
+ if (debug->ptr == NULL) \
+ { \
+ ret = false; \
+ goto return_something; \
+ } \
+ if (bfd_seek (input_bfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
+ || bfd_bread (debug->ptr, amt, input_bfd) != amt) \
+ { \
+ ret = false; \
+ goto return_something; \
+ } \
}
/* If raw_syments is not NULL, then the data was already by read by
bfd *output_bfd = einfo->abfd;
boolean strip;
- /* We need to 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;
+ }
+
+ /* 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;
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)
switch (h->root.type)
{
default:
+ case bfd_link_hash_warning:
case bfd_link_hash_new:
abort ();
case bfd_link_hash_undefined:
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. */
+ /* We ignore these symbols, since the indirected symbol is
+ already in the hash table. */
return true;
}
bfd_size_type external_reloc_size;
bfd_size_type external_relocs_size;
PTR external_relocs = NULL;
+ bfd_size_type amt;
BFD_ASSERT ((output_section->flags & SEC_HAS_CONTENTS) != 0);
/* Get the section contents. We allocate memory for the larger of
the size before relocating and the size after relocating. */
- contents = (bfd_byte *) bfd_malloc (raw_size >= cooked_size
- ? (size_t) raw_size
- : (size_t) cooked_size);
- if (contents == NULL && raw_size != 0)
+ 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
external_relocs = section_tdata->external_relocs;
else
{
- external_relocs = (PTR) bfd_malloc ((size_t) external_relocs_size);
+ 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_read (external_relocs, 1, external_relocs_size, input_bfd)
+ || (bfd_bread (external_relocs, external_relocs_size, input_bfd)
!= external_relocs_size))
goto error_return;
}
if (! bfd_set_section_contents (output_bfd,
output_section,
(PTR) contents,
- input_section->output_offset,
+ (file_ptr) input_section->output_offset,
cooked_size))
goto error_return;
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))
goto error_return;
output_section->reloc_count += input_section->reloc_count;
bfd_size_type external_reloc_size;
bfd_byte *rbuf;
boolean ok;
+ file_ptr pos;
type = link_order->type;
section = NULL;
bfd_size_type size;
bfd_reloc_status_type rstat;
bfd_byte *buf;
- boolean ok;
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, addend, buf);
+ rstat = _bfd_relocate_contents (rel.howto, output_bfd,
+ (bfd_vma) addend, buf);
switch (rstat)
{
case bfd_reloc_ok:
rel.addend = 0;
- /* Move the information into a internal_reloc structure. */
+ /* 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;
}
else
{
- CONST char *name;
+ const char *name;
name = bfd_get_section_name (output_bfd, section);
if (strcmp (name, ".text") == 0)
/* Get some memory and swap out the reloc. */
external_reloc_size = ecoff_backend (output_bfd)->external_reloc_size;
- rbuf = (bfd_byte *) bfd_malloc ((size_t) 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);
- ok = (bfd_seek (output_bfd,
- (output_section->rel_filepos +
- output_section->reloc_count * external_reloc_size),
- SEEK_SET) == 0
- && (bfd_write ((PTR) rbuf, 1, external_reloc_size, output_bfd)
+ 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)
projects / deliverable / binutils-gdb.git / blobdiff