#include "bfd.h"
#include "sysdep.h"
+#include "bfdlink.h"
#include "libbfd.h"
-#include "seclet.h"
#include "aout/ar.h"
#include "aout/ranlib.h"
/* Prototypes for static functions. */
static int ecoff_get_magic PARAMS ((bfd *abfd));
-static void ecoff_set_symbol_info PARAMS ((bfd *abfd, SYMR *ecoff_sym,
+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,
+static void ecoff_emit_aggregate PARAMS ((bfd *abfd, FDR *fdr,
+ char *string,
RNDXR *rndx, long isym,
- CONST char *which));
-static char *ecoff_type_to_string PARAMS ((bfd *abfd, union aux_ext *aux_ptr,
- unsigned int indx, int bigendian));
+ const char *which));
+static char *ecoff_type_to_string PARAMS ((bfd *abfd, FDR *fdr,
+ unsigned int indx));
static boolean ecoff_slurp_reloc_table PARAMS ((bfd *abfd, asection *section,
asymbol **symbols));
-static void ecoff_clear_output_flags PARAMS ((bfd *abfd));
-static boolean ecoff_rel PARAMS ((bfd *output_bfd, bfd_seclet_type *seclet,
- asection *output_section, PTR data,
- boolean relocateable));
-static boolean ecoff_dump_seclet PARAMS ((bfd *abfd, bfd_seclet_type *seclet,
- asection *section, PTR data,
- boolean relocateable));
-static long ecoff_add_string PARAMS ((bfd *output_bfd, FDR *fdr,
- CONST char *string, boolean external));
-static boolean ecoff_get_debug PARAMS ((bfd *output_bfd,
- bfd_seclet_type *seclet,
- asection *section,
- boolean relocateable));
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,
bfd_zalloc (abfd, sizeof (ecoff_data_type)));
if (abfd->tdata.ecoff_obj_data == NULL)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return false;
}
- /* Always create a .scommon section for every BFD. This is a hack so
- that the linker has something to attach scSCommon symbols to. */
- if (bfd_make_section (abfd, SCOMMON) == NULL)
- return false;
-
return true;
}
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)
return NULL;
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;
/* This is a hook needed by SCO COFF, but we have nothing to do. */
+/*ARGSUSED*/
asection *
ecoff_make_section_hook (abfd, name)
bfd *abfd;
bfd *abfd;
asection *section;
{
- section->alignment_power = abfd->xvec->align_power_min;
+ /* 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;
if (strcmp (section->name, _TEXT) == 0)
section->flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
else if (strcmp (section->name, _BSS) == 0
|| strcmp (section->name, _SBSS) == 0)
section->flags |= SEC_ALLOC;
- else if (strcmp (section->name, REGINFO) == 0)
+ else if (strcmp (section->name, _LIB) == 0)
{
- section->flags |= SEC_HAS_CONTENTS | SEC_NEVER_LOAD;
- section->_raw_size = sizeof (struct ecoff_reginfo);
+ /* An Irix 4 shared libary. */
+ section->flags |= SEC_COFF_SHARED_LIBRARY;
}
/* Probably any other section name is SEC_NEVER_LOAD, but I'm
styp = STYP_SDATA;
else if (strcmp (name, _RDATA) == 0)
styp = STYP_RDATA;
+ else if (strcmp (name, _LITA) == 0)
+ styp = STYP_LITA;
else if (strcmp (name, _LIT8) == 0)
styp = STYP_LIT8;
else if (strcmp (name, _LIT4) == 0)
styp = STYP_ECOFF_INIT;
else if (strcmp (name, _FINI) == 0)
styp = STYP_ECOFF_FINI;
+ else if (strcmp (name, _PDATA) == 0)
+ styp = STYP_PDATA;
+ else if (strcmp (name, _XDATA) == 0)
+ styp = STYP_XDATA;
+ else if (strcmp (name, _LIB) == 0)
+ styp = STYP_ECOFF_LIB;
else if (flags & SEC_CODE)
styp = STYP_TEXT;
else if (flags & SEC_DATA)
/* Get the BFD flags to use for a section. */
+/*ARGSUSED*/
flagword
ecoff_styp_to_sec_flags (abfd, hdr)
bfd *abfd;
|| (styp_flags & STYP_ECOFF_FINI))
{
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)
{
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)
sec_flags |= SEC_READONLY;
}
else if ((styp_flags & STYP_BSS)
{
sec_flags |= SEC_ALLOC;
}
- else if (styp_flags & STYP_INFO)
+ else if ((styp_flags & STYP_INFO) || styp_flags == STYP_COMMENT)
{
sec_flags |= SEC_NEVER_LOAD;
}
- else if ((styp_flags & STYP_LIT8)
+ else if ((styp_flags & STYP_LITA)
+ || (styp_flags & STYP_LIT8)
|| (styp_flags & STYP_LIT4))
{
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;
void
ecoff_swap_tir_in (bigend, ext_copy, intern)
int bigend;
- struct tir_ext *ext_copy;
+ const struct tir_ext *ext_copy;
TIR *intern;
{
struct tir_ext ext[1];
void
ecoff_swap_tir_out (bigend, intern_copy, ext)
int bigend;
- TIR *intern_copy;
+ const TIR *intern_copy;
struct tir_ext *ext;
{
TIR intern[1];
void
ecoff_swap_rndx_in (bigend, ext_copy, intern)
int bigend;
- struct rndx_ext *ext_copy;
+ const struct rndx_ext *ext_copy;
RNDXR *intern;
{
struct rndx_ext ext[1];
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);
+ | ((unsigned int) ext->r_bits[3]
+ << RNDX_BITS3_INDEX_SH_LEFT_LITTLE);
}
#ifdef TEST
void
ecoff_swap_rndx_out (bigend, intern_copy, ext)
int bigend;
- RNDXR *intern_copy;
+ const RNDXR *intern_copy;
struct rndx_ext *ext;
{
RNDXR intern[1];
#endif
}
\f
-/* Read in and swap the important symbolic information for an ECOFF
- object file. This is called by gdb. */
+/* Read in the symbolic header for an ECOFF object file. */
-boolean
-ecoff_slurp_symbolic_info (abfd)
+static 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 = NULL;
HDRR *internal_symhdr;
- bfd_size_type raw_base;
- bfd_size_type raw_size;
- PTR raw;
- bfd_size_type external_fdr_size;
- char *fraw_src;
- char *fraw_end;
- struct fdr *fdr_ptr;
- bfd_size_type raw_end;
- bfd_size_type cb_end;
- /* Check whether we've already gotten it, and whether there's any to
- get. */
- if (ecoff_data (abfd)->raw_syments != (PTR) NULL)
+ /* See if we've already read it in. */
+ if (ecoff_data (abfd)->debug_info.symbolic_header.magic ==
+ backend->debug_swap.sym_magic)
return true;
+
+ /* See whether there is a symbolic header. */
if (ecoff_data (abfd)->sym_filepos == 0)
{
bfd_get_symcount (abfd) = 0;
as read from the file header, but on ECOFF this is always the
size of the symbolic information header. It would be cleaner to
handle this when we first read the file in coffgen.c. */
- external_hdr_size = backend->external_hdr_size;
+ external_hdr_size = backend->debug_swap.external_hdr_size;
if (bfd_get_symcount (abfd) != external_hdr_size)
{
- bfd_error = bad_value;
+ bfd_set_error (bfd_error_bad_value);
return false;
}
/* Read the symbolic information header. */
- raw = (PTR) alloca (external_hdr_size);
+ raw = (PTR) malloc ((size_t) external_hdr_size);
+ if (raw == NULL)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ 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))
- {
- bfd_error = system_call_error;
- return false;
- }
- internal_symhdr = &ecoff_data (abfd)->symbolic_header;
- (*backend->swap_hdr_in) (abfd, raw, internal_symhdr);
+ 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->sym_magic)
+ if (internal_symhdr->magic != backend->debug_swap.sym_magic)
{
- bfd_error = bad_value;
- return false;
+ bfd_set_error (bfd_error_bad_value);
+ goto error_return;
}
/* Now we can get the correct number of symbols. */
bfd_get_symcount (abfd) = (internal_symhdr->isymMax
+ internal_symhdr->iextMax);
+ if (raw != NULL)
+ free (raw);
+ return true;
+ error_return:
+ if (raw != NULL)
+ free (raw);
+ return false;
+}
+
+/* Read in and swap the important symbolic information for an ECOFF
+ object file. This is called by gdb via the read_debug_info entry
+ point in the backend structure. */
+
+/*ARGSUSED*/
+boolean
+ecoff_slurp_symbolic_info (abfd, ignore, debug)
+ bfd *abfd;
+ asection *ignore;
+ struct ecoff_debug_info *debug;
+{
+ const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
+ HDRR *internal_symhdr;
+ bfd_size_type raw_base;
+ bfd_size_type raw_size;
+ PTR raw;
+ bfd_size_type external_fdr_size;
+ char *fraw_src;
+ char *fraw_end;
+ struct fdr *fdr_ptr;
+ bfd_size_type raw_end;
+ bfd_size_type cb_end;
+
+ BFD_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;
+ if (ecoff_data (abfd)->sym_filepos == 0)
+ {
+ bfd_get_symcount (abfd) = 0;
+ return true;
+ }
+
+ if (! ecoff_slurp_symbolic_header (abfd))
+ return false;
+
+ internal_symhdr = &debug->symbolic_header;
+
/* Read all the symbolic information at once. */
- raw_base = ecoff_data (abfd)->sym_filepos + external_hdr_size;
+ raw_base = (ecoff_data (abfd)->sym_filepos
+ + backend->debug_swap.external_hdr_size);
/* Alpha ecoff makes the determination of raw_size difficult. It has
an undocumented debug data section between the symhdr and the first
raw_end = cb_end
UPDATE_RAW_END (cbLineOffset, cbLine, sizeof (unsigned char));
- UPDATE_RAW_END (cbDnOffset, idnMax, backend->external_dnr_size);
- UPDATE_RAW_END (cbPdOffset, ipdMax, backend->external_pdr_size);
- UPDATE_RAW_END (cbSymOffset, isymMax, backend->external_sym_size);
- UPDATE_RAW_END (cbOptOffset, ioptMax, backend->external_opt_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);
UPDATE_RAW_END (cbAuxOffset, iauxMax, sizeof (union aux_ext));
UPDATE_RAW_END (cbSsOffset, issMax, sizeof (char));
UPDATE_RAW_END (cbSsExtOffset, issExtMax, sizeof (char));
- UPDATE_RAW_END (cbFdOffset, ifdMax, backend->external_fdr_size);
- UPDATE_RAW_END (cbRfdOffset, crfd, backend->external_rfd_size);
- UPDATE_RAW_END (cbExtOffset, iextMax, backend->external_ext_size);
+ UPDATE_RAW_END (cbFdOffset, ifdMax, backend->debug_swap.external_fdr_size);
+ UPDATE_RAW_END (cbRfdOffset, crfd, backend->debug_swap.external_rfd_size);
+ UPDATE_RAW_END (cbExtOffset, iextMax, backend->debug_swap.external_ext_size);
#undef UPDATE_RAW_END
raw = (PTR) bfd_alloc (abfd, raw_size);
if (raw == NULL)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return false;
}
- if (bfd_read (raw, raw_size, 1, abfd) != raw_size)
+ 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_error = system_call_error;
bfd_release (abfd, raw);
return false;
}
- ecoff_data (abfd)->raw_size = raw_size;
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)->off2 = (type) NULL; \
+ debug->off2 = (type) NULL; \
else \
- ecoff_data (abfd)->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)->fdr =
- (struct fdr *) bfd_alloc (abfd,
- (internal_symhdr->ifdMax *
- sizeof (struct fdr)));
- if (ecoff_data (abfd)->fdr == NULL)
+ debug->fdr = (struct fdr *) bfd_alloc (abfd,
+ (internal_symhdr->ifdMax *
+ sizeof (struct fdr)));
+ if (debug->fdr == NULL)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return false;
}
- external_fdr_size = backend->external_fdr_size;
- fdr_ptr = ecoff_data (abfd)->fdr;
- fraw_src = (char *) ecoff_data (abfd)->external_fdr;
+ external_fdr_size = backend->debug_swap.external_fdr_size;
+ 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->swap_fdr_in) (abfd, (PTR) fraw_src, fdr_ptr);
+ (*backend->debug_swap.swap_fdr_in) (abfd, (PTR) fraw_src, fdr_ptr);
return true;
}
new = (ecoff_symbol_type *) bfd_alloc (abfd, sizeof (ecoff_symbol_type));
if (new == (ecoff_symbol_type *) NULL)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return (asymbol *) NULL;
}
- memset (new, 0, sizeof *new);
+ memset ((PTR) new, 0, sizeof *new);
new->symbol.section = (asection *) NULL;
new->fdr = (FDR *) NULL;
new->local = false;
/* Set the BFD flags and section for an ECOFF symbol. */
-static void
+static boolean
ecoff_set_symbol_info (abfd, ecoff_sym, asym, ext, indirect_ptr_ptr)
bfd *abfd;
SYMR *ecoff_sym;
asym->flags = BSF_DEBUGGING;
asym->section = &bfd_und_section;
*indirect_ptr_ptr = NULL;
- return;
+ return true;
}
if (ECOFF_IS_STAB (ecoff_sym)
asym->section = &bfd_ind_section;
/* Pass this symbol on to the next call to this function. */
*indirect_ptr_ptr = asym;
- return;
+ return true;
}
/* Most symbol types are just for debugging. */
if (ECOFF_IS_STAB (ecoff_sym))
{
asym->flags = BSF_DEBUGGING;
- return;
+ return true;
}
break;
default:
asym->flags = BSF_DEBUGGING;
- return;
+ return true;
}
if (ext)
char *copy;
copy = (char *) bfd_alloc (abfd, strlen (name) + 1);
+ if (!copy)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ 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));
+ if (!reloc_chain)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ return false;
+ }
reloc_chain->relent.sym_ptr_ptr =
bfd_get_section (asym)->symbol_ptr_ptr;
reloc_chain->relent.address = section->_raw_size;
break;
}
}
+ return true;
}
/* Read an ECOFF symbol table. */
bfd *abfd;
{
const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
- const bfd_size_type external_ext_size = backend->external_ext_size;
- const bfd_size_type external_sym_size = backend->external_sym_size;
+ const bfd_size_type external_ext_size
+ = backend->debug_swap.external_ext_size;
+ const bfd_size_type external_sym_size
+ = backend->debug_swap.external_sym_size;
void (* const swap_ext_in) PARAMS ((bfd *, PTR, EXTR *))
- = backend->swap_ext_in;
+ = backend->debug_swap.swap_ext_in;
void (* const swap_sym_in) PARAMS ((bfd *, PTR, SYMR *))
- = backend->swap_sym_in;
+ = backend->debug_swap.swap_sym_in;
bfd_size_type internal_size;
ecoff_symbol_type *internal;
ecoff_symbol_type *internal_ptr;
return true;
/* Get the symbolic information. */
- if (ecoff_slurp_symbolic_info (abfd) == false)
+ if (! ecoff_slurp_symbolic_info (abfd, (asection *) NULL,
+ &ecoff_data (abfd)->debug_info))
return false;
if (bfd_get_symcount (abfd) == 0)
return true;
internal = (ecoff_symbol_type *) bfd_alloc (abfd, internal_size);
if (internal == NULL)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return false;
}
internal_ptr = internal;
indirect_ptr = NULL;
- eraw_src = (char *) ecoff_data (abfd)->external_ext;
+ eraw_src = (char *) ecoff_data (abfd)->debug_info.external_ext;
eraw_end = (eraw_src
- + (ecoff_data (abfd)->symbolic_header.iextMax
+ + (ecoff_data (abfd)->debug_info.symbolic_header.iextMax
* external_ext_size));
for (; eraw_src < eraw_end; eraw_src += external_ext_size, internal_ptr++)
{
EXTR internal_esym;
(*swap_ext_in) (abfd, (PTR) eraw_src, &internal_esym);
- internal_ptr->symbol.name = (ecoff_data (abfd)->ssext
+ internal_ptr->symbol.name = (ecoff_data (abfd)->debug_info.ssext
+ internal_esym.asym.iss);
- ecoff_set_symbol_info (abfd, &internal_esym.asym,
- &internal_ptr->symbol, 1, &indirect_ptr);
+ if (!ecoff_set_symbol_info (abfd, &internal_esym.asym,
+ &internal_ptr->symbol, 1, &indirect_ptr))
+ return false;
/* The alpha uses a negative ifd field for section symbols. */
if (internal_esym.ifd >= 0)
- internal_ptr->fdr = ecoff_data (abfd)->fdr + internal_esym.ifd;
+ internal_ptr->fdr = (ecoff_data (abfd)->debug_info.fdr
+ + internal_esym.ifd);
else
internal_ptr->fdr = NULL;
internal_ptr->local = false;
/* The local symbols must be accessed via the fdr's, because the
string and aux indices are relative to the fdr information. */
- fdr_ptr = ecoff_data (abfd)->fdr;
- fdr_end = fdr_ptr + ecoff_data (abfd)->symbolic_header.ifdMax;
+ fdr_ptr = ecoff_data (abfd)->debug_info.fdr;
+ fdr_end = fdr_ptr + ecoff_data (abfd)->debug_info.symbolic_header.ifdMax;
for (; fdr_ptr < fdr_end; fdr_ptr++)
{
char *lraw_src;
char *lraw_end;
- lraw_src = ((char *) ecoff_data (abfd)->external_sym
+ lraw_src = ((char *) ecoff_data (abfd)->debug_info.external_sym
+ fdr_ptr->isymBase * external_sym_size);
lraw_end = lraw_src + fdr_ptr->csym * external_sym_size;
for (;
SYMR internal_sym;
(*swap_sym_in) (abfd, (PTR) lraw_src, &internal_sym);
- internal_ptr->symbol.name = (ecoff_data (abfd)->ss
+ internal_ptr->symbol.name = (ecoff_data (abfd)->debug_info.ss
+ fdr_ptr->issBase
+ internal_sym.iss);
- ecoff_set_symbol_info (abfd, &internal_sym,
- &internal_ptr->symbol, 0, &indirect_ptr);
+ if (!ecoff_set_symbol_info (abfd, &internal_sym,
+ &internal_ptr->symbol, 0, &indirect_ptr))
+ return false;
internal_ptr->fdr = fdr_ptr;
internal_ptr->local = true;
internal_ptr->native = (PTR) lraw_src;
/* Return the amount of space needed for the canonical symbols. */
-unsigned int
+long
ecoff_get_symtab_upper_bound (abfd)
bfd *abfd;
{
- if (ecoff_slurp_symbolic_info (abfd) == false
- || bfd_get_symcount (abfd) == 0)
+ if (! 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 canonicals symbols. */
+/* Get the canonical symbols. */
-unsigned int
+long
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 (ecoff_slurp_symbol_table (abfd) == false)
+ 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)->fdr[ifd].isymBase;
- ss_base = ecoff_data (abfd)->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_backend_data * const backend = ecoff_backend (abfd);
SYMR sym;
- indx += sym_base;
- (*backend->swap_sym_in) (abfd,
- ((char *) ecoff_data (abfd)->external_sym
- + indx * backend->external_sym_size),
- &sym);
- name = ecoff_data (abfd)->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 = %d }",
+ "%s %s { ifd = %u, index = %lu }",
which, name, ifd,
- indx + ecoff_data (abfd)->symbolic_header.iextMax);
+ ((long) indx
+ + 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 *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;
case btStruct: /* Structure (Record) */
ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx);
- ecoff_emit_aggregate (abfd, p1, &rndx,
- AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]),
+ ecoff_emit_aggregate (abfd, fdr, p1, &rndx,
+ (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]),
"struct");
indx++; /* skip aux words */
break;
case btUnion: /* Union */
ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx);
- ecoff_emit_aggregate (abfd, p1, &rndx,
- AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]),
+ ecoff_emit_aggregate (abfd, fdr, p1, &rndx,
+ (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]),
"union");
indx++; /* skip aux words */
break;
case btEnum: /* Enumeration */
ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx);
- ecoff_emit_aggregate (abfd, p1, &rndx,
- AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]),
+ ecoff_emit_aggregate (abfd, fdr, p1, &rndx,
+ (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]),
"enum");
indx++; /* skip aux words */
break;
/* Return information about ECOFF symbol SYMBOL in RET. */
+/*ARGSUSED*/
void
ecoff_get_symbol_info (abfd, symbol, ret)
bfd *abfd; /* Ignored. */
asymbol *symbol;
bfd_print_symbol_type how;
{
- const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
+ const struct ecoff_debug_swap * const debug_swap
+ = &ecoff_backend (abfd)->debug_swap;
FILE *file = (FILE *)filep;
switch (how)
{
SYMR ecoff_sym;
- (*backend->swap_sym_in) (abfd, ecoffsymbol (symbol)->native,
- &ecoff_sym);
+ (*debug_swap->swap_sym_in) (abfd, ecoffsymbol (symbol)->native,
+ &ecoff_sym);
fprintf (file, "ecoff local ");
fprintf_vma (file, (bfd_vma) ecoff_sym.value);
fprintf (file, " %x %x", (unsigned) ecoff_sym.st,
{
EXTR ecoff_ext;
- (*backend->swap_ext_in) (abfd, ecoffsymbol (symbol)->native,
- &ecoff_ext);
+ (*debug_swap->swap_ext_in) (abfd, ecoffsymbol (symbol)->native,
+ &ecoff_ext);
fprintf (file, "ecoff extern ");
fprintf_vma (file, (bfd_vma) ecoff_ext.asym.value);
fprintf (file, " %x %x", (unsigned) ecoff_ext.asym.st,
if (ecoffsymbol (symbol)->local)
{
- (*backend->swap_sym_in) (abfd, ecoffsymbol (symbol)->native,
- &ecoff_ext.asym);
+ (*debug_swap->swap_sym_in) (abfd, ecoffsymbol (symbol)->native,
+ &ecoff_ext.asym);
type = 'l';
pos = ((((char *) ecoffsymbol (symbol)->native
- - (char *) ecoff_data (abfd)->external_sym)
- / backend->external_sym_size)
- + ecoff_data (abfd)->symbolic_header.iextMax);
+ - (char *) ecoff_data (abfd)->debug_info.external_sym)
+ / debug_swap->external_sym_size)
+ + ecoff_data (abfd)->debug_info.symbolic_header.iextMax);
jmptbl = ' ';
cobol_main = ' ';
weakext = ' ';
}
else
{
- (*backend->swap_ext_in) (abfd, ecoffsymbol (symbol)->native,
- &ecoff_ext);
+ (*debug_swap->swap_ext_in) (abfd, ecoffsymbol (symbol)->native,
+ &ecoff_ext);
type = 'e';
pos = (((char *) ecoffsymbol (symbol)->native
- - (char *) ecoff_data (abfd)->external_ext)
- / backend->external_ext_size);
+ - (char *) ecoff_data (abfd)->debug_info.external_ext)
+ / debug_swap->external_ext_size);
jmptbl = ecoff_ext.jmptbl ? 'j' : ' ';
cobol_main = ecoff_ext.cobol_main ? 'c' : ' ';
weakext = ecoff_ext.weakext ? 'w' : ' ';
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)->symbolic_header.iextMax;
+ 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)->external_aux
- + ecoffsymbol (symbol)->fdr->iauxBase);
+ aux_base = (ecoff_data (abfd)->debug_info.external_aux
+ + fdr->iauxBase);
/* The aux entries are stored in host byte order; the
order is indicated by a bit in the fdr. */
- bigendian = ecoffsymbol (symbol)->fdr->fBigendian;
+ bigendian = fdr->fBigendian;
/* This switch is basically from gcc/mips-tdump.c */
switch (ecoff_ext.asym.st)
(long) (indx + sym_base));
else
fprintf (file, "\n First symbol: %ld",
- (long) (AUX_GET_ISYM (bigendian,
- &aux_base[ecoff_ext.asym.index])
- + sym_base));
+ ((long)
+ (AUX_GET_ISYM (bigendian,
+ &aux_base[ecoff_ext.asym.index])
+ + sym_base)));
break;
case stProc:
;
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));
+ ((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: %d",
- (indx
- + sym_base
- + ecoff_data (abfd)->symbolic_header.iextMax));
+ 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));
+ ecoff_type_to_string (abfd, fdr, indx));
break;
}
}
if (internal_relocs == (arelent *) NULL
|| external_relocs == (char *) NULL)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
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_error = system_call_error;
- return false;
- }
+ return false;
for (i = 0, rptr = internal_relocs; i < section->reloc_count; i++, rptr++)
{
/* r_symndx is an index into the external symbols. */
BFD_ASSERT (intern.r_symndx >= 0
&& (intern.r_symndx
- < ecoff_data (abfd)->symbolic_header.iextMax));
+ < (ecoff_data (abfd)
+ ->debug_info.symbolic_header.iextMax)));
rptr->sym_ptr_ptr = symbols + intern.r_symndx;
rptr->addend = 0;
}
case RELOC_SECTION_LIT4: sec_name = ".lit4"; break;
case RELOC_SECTION_XDATA: sec_name = ".xdata"; break;
case RELOC_SECTION_PDATA: sec_name = ".pdata"; break;
+ case RELOC_SECTION_FINI: sec_name = ".fini"; break;
case RELOC_SECTION_LITA: sec_name = ".lita"; break;
default: abort ();
}
/* Let the backend select the howto field and do any other
required processing. */
- (*backend->finish_reloc) (abfd, &intern, rptr);
+ (*backend->adjust_reloc_in) (abfd, &intern, rptr);
}
bfd_release (abfd, external_relocs);
/* Get a canonical list of relocs. */
-unsigned int
+long
ecoff_canonicalize_reloc (abfd, section, relptr, symbols)
bfd *abfd;
asection *section;
arelent *tblptr;
if (ecoff_slurp_reloc_table (abfd, section, symbols) == false)
- return 0;
+ return -1;
tblptr = section->relocation;
- if (tblptr == (arelent *) NULL)
- return 0;
for (count = 0; count < section->reloc_count; count++)
*relptr++ = tblptr++;
and return the name of the source file and the line nearest to the
wanted location. */
+/*ARGSUSED*/
boolean
ecoff_find_nearest_line (abfd,
section,
CONST char **functionname_ptr;
unsigned int *retline_ptr;
{
- const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
+ const struct ecoff_debug_swap * const debug_swap
+ = &ecoff_backend (abfd)->debug_swap;
FDR *fdr_ptr;
FDR *fdr_start;
FDR *fdr_end;
char *pdr_ptr;
char *pdr_end;
PDR pdr;
+ bfd_vma first_off;
unsigned char *line_ptr;
unsigned char *line_end;
int lineno;
return false;
/* Make sure we have the FDR's. */
- if (ecoff_slurp_symbolic_info (abfd) == false
+ if (! ecoff_slurp_symbolic_info (abfd, (asection *) NULL,
+ &ecoff_data (abfd)->debug_info)
|| bfd_get_symcount (abfd) == 0)
return false;
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)->fdr;
- fdr_end = fdr_start + ecoff_data (abfd)->symbolic_header.ifdMax;
+ 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++)
{
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 = backend->external_pdr_size;
- pdr_ptr = ((char *) ecoff_data (abfd)->external_pdr
+ 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;
- (*backend->swap_pdr_in) (abfd, (PTR) pdr_ptr, &pdr);
+ (*debug_swap->swap_pdr_in) (abfd, (PTR) pdr_ptr, &pdr);
+ if (offset < pdr.adr)
+ return false;
/* The address of the first PDR is an offset which applies to the
addresses of all the PDR's. */
- offset += pdr.adr;
+ first_off = pdr.adr;
for (pdr_ptr += external_pdr_size;
pdr_ptr < pdr_end;
pdr_ptr += external_pdr_size)
{
- (*backend->swap_pdr_in) (abfd, (PTR) pdr_ptr, &pdr);
+ (*debug_swap->swap_pdr_in) (abfd, (PTR) pdr_ptr, &pdr);
if (offset < pdr.adr)
break;
}
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)->line;
+ line_end = ecoff_data (abfd)->debug_info.line;
if (pdr_ptr == pdr_end)
line_end += fdr_ptr->cbLineOffset + fdr_ptr->cbLine;
else
/* Now change pdr and pdr_ptr to the one we want. */
pdr_ptr -= external_pdr_size;
- (*backend->swap_pdr_in) (abfd, (PTR) pdr_ptr, &pdr);
+ (*debug_swap->swap_pdr_in) (abfd, (PTR) pdr_ptr, &pdr);
- offset -= pdr.adr;
+ offset -= pdr.adr - first_off;
lineno = pdr.lnLow;
- line_ptr = (ecoff_data (abfd)->line
+ line_ptr = (ecoff_data (abfd)->debug_info.line
+ fdr_ptr->cbLineOffset
+ pdr.cbLineOffset);
while (line_ptr < line_end)
{
EXTR proc_ext;
- (*backend->swap_ext_in) (abfd,
- ((char *) ecoff_data (abfd)->external_ext
- + pdr.isym * backend->external_ext_size),
- &proc_ext);
- *functionname_ptr = ecoff_data (abfd)->ssext + proc_ext.asym.iss;
+ (*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);
}
}
else
{
SYMR proc_sym;
- *filename_ptr = ecoff_data (abfd)->ss + fdr_ptr->issBase + fdr_ptr->rss;
- (*backend->swap_sym_in) (abfd,
- ((char *) ecoff_data (abfd)->external_sym
- + ((fdr_ptr->isymBase + pdr.isym)
- * backend->external_sym_size)),
- &proc_sym);
- *functionname_ptr = (ecoff_data (abfd)->ss
+ *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);
}
return true;
}
\f
-/* We can't use the generic linking routines for ECOFF, because we
- have to handle all the debugging information. The generic link
- routine just works out the section contents and attaches a list of
- symbols.
-
- We link by looping over all the seclets. We make two passes. On
- the first we set the actual section contents and determine the size
- of the debugging information. On the second we accumulate the
- debugging information and write it out.
-
- This currently always accumulates the debugging information, which
- is incorrect, because it ignores the -s and -S options of the
- linker. The linker needs to be modified to give us that
- information in a more useful format (currently it just provides a
- list of symbols which should appear in the output file). */
-
-/* Clear the output_has_begun flag for all the input BFD's. We use it
- to avoid linking in the debugging information for a BFD more than
- once. */
+/* 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. */
-static void
-ecoff_clear_output_flags (abfd)
- bfd *abfd;
+boolean
+ecoff_bfd_copy_private_bfd_data (ibfd, obfd)
+ bfd *ibfd;
+ bfd *obfd;
{
- register asection *o;
- register bfd_seclet_type *p;
-
- for (o = abfd->sections; o != (asection *) NULL; o = o->next)
- for (p = o->seclets_head;
- p != (bfd_seclet_type *) NULL;
- p = p->next)
- if (p->type == bfd_indirect_seclet)
- p->u.indirect.section->owner->output_has_begun = false;
-}
-
-/* Handle an indirect seclet on the first pass. Set the contents of
- the output section, and accumulate the debugging information if
- any. */
+ struct ecoff_debug_info *iinfo = &ecoff_data (ibfd)->debug_info;
+ struct ecoff_debug_info *oinfo = &ecoff_data (obfd)->debug_info;
+ register int i;
+ asymbol **sym_ptr_ptr;
+ size_t c;
+ boolean local;
-static boolean
-ecoff_rel (output_bfd, seclet, output_section, data, relocateable)
- bfd *output_bfd;
- bfd_seclet_type *seclet;
- asection *output_section;
- PTR data;
- boolean relocateable;
-{
- bfd *input_bfd;
- HDRR *output_symhdr;
- HDRR *input_symhdr;
-
- if ((output_section->flags & SEC_HAS_CONTENTS)
- && !(output_section->flags & SEC_NEVER_LOAD)
- && (output_section->flags & SEC_LOAD)
- && seclet->size)
- {
- data = (PTR) bfd_get_relocated_section_contents (output_bfd,
- seclet,
- data,
- relocateable);
- if (bfd_set_section_contents (output_bfd,
- output_section,
- data,
- seclet->offset,
- seclet->size)
- == false)
- {
- abort();
- }
- }
+ /* This function is selected based on the input vector. We only
+ want to copy information over if the output BFD also uses ECOFF
+ format. */
+ if (bfd_get_flavour (obfd) != bfd_target_ecoff_flavour)
+ return true;
- input_bfd = seclet->u.indirect.section->owner;
+ /* 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];
- /* We want to figure out how much space will be required to
- incorporate all the debugging information from input_bfd. We use
- the output_has_begun field to avoid adding it in more than once.
- The actual incorporation is done in the second pass, in
- ecoff_get_debug. The code has to parallel that code in its
- manipulations of output_symhdr. */
+ /* Copy the version stamp. */
+ oinfo->symbolic_header.vstamp = iinfo->symbolic_header.vstamp;
- if (input_bfd->output_has_begun)
+ /* 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;
- input_bfd->output_has_begun = true;
-
- output_symhdr = &ecoff_data (output_bfd)->symbolic_header;
- if (input_bfd->xvec->flavour != bfd_target_ecoff_flavour)
+ /* See if there are any local symbols. */
+ local = false;
+ for (; c > 0; c--, sym_ptr_ptr++)
{
- asymbol **symbols;
- asymbol **sym_ptr;
- asymbol **sym_end;
-
- /* We just accumulate local symbols from a non-ECOFF BFD. The
- external symbols are handled separately. */
-
- symbols = (asymbol **) bfd_alloc (output_bfd,
- get_symtab_upper_bound (input_bfd));
- if (symbols == (asymbol **) NULL)
+ if (ecoffsymbol (*sym_ptr_ptr)->local)
{
- bfd_error = no_memory;
- return false;
+ local = true;
+ break;
}
- sym_end = symbols + bfd_canonicalize_symtab (input_bfd, symbols);
-
- for (sym_ptr = symbols; sym_ptr < sym_end; sym_ptr++)
- {
- size_t len;
+ }
- len = strlen ((*sym_ptr)->name);
- if (((*sym_ptr)->flags & BSF_EXPORT) == 0)
- {
- ++output_symhdr->isymMax;
- output_symhdr->issMax += len + 1;
- }
- }
+ if (local)
+ {
+ /* 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;
- bfd_release (output_bfd, (PTR) symbols);
+ oinfo->symbolic_header.idnMax = iinfo->symbolic_header.idnMax;
+ oinfo->external_dnr = iinfo->external_dnr;
- ++output_symhdr->ifdMax;
+ oinfo->symbolic_header.ipdMax = iinfo->symbolic_header.ipdMax;
+ oinfo->external_pdr = iinfo->external_pdr;
- return true;
- }
+ oinfo->symbolic_header.isymMax = iinfo->symbolic_header.isymMax;
+ oinfo->external_sym = iinfo->external_sym;
- /* We simply add in the information from another ECOFF BFD. First
- we make sure we have the symbolic information. */
- if (ecoff_slurp_symbol_table (input_bfd) == false)
- return false;
- if (bfd_get_symcount (input_bfd) == 0)
- return true;
+ oinfo->symbolic_header.ioptMax = iinfo->symbolic_header.ioptMax;
+ oinfo->external_opt = iinfo->external_opt;
- input_symhdr = &ecoff_data (input_bfd)->symbolic_header;
-
- /* Figure out how much information we are going to be putting in.
- The external symbols are handled separately. */
- output_symhdr->ilineMax += input_symhdr->ilineMax;
- output_symhdr->cbLine += input_symhdr->cbLine;
- output_symhdr->idnMax += input_symhdr->idnMax;
- output_symhdr->ipdMax += input_symhdr->ipdMax;
- output_symhdr->isymMax += input_symhdr->isymMax;
- output_symhdr->ioptMax += input_symhdr->ioptMax;
- output_symhdr->iauxMax += input_symhdr->iauxMax;
- output_symhdr->issMax += input_symhdr->issMax;
- output_symhdr->ifdMax += input_symhdr->ifdMax;
-
- /* The RFD's are special, since we create them if needed. */
- if (input_symhdr->crfd > 0)
- output_symhdr->crfd += input_symhdr->crfd;
- else
- output_symhdr->crfd += input_symhdr->ifdMax;
+ oinfo->symbolic_header.iauxMax = iinfo->symbolic_header.iauxMax;
+ oinfo->external_aux = iinfo->external_aux;
- return true;
-}
+ oinfo->symbolic_header.issMax = iinfo->symbolic_header.issMax;
+ oinfo->ss = iinfo->ss;
-/* Handle an arbitrary seclet on the first pass. */
+ oinfo->symbolic_header.ifdMax = iinfo->symbolic_header.ifdMax;
+ oinfo->external_fdr = iinfo->external_fdr;
-static boolean
-ecoff_dump_seclet (abfd, seclet, section, data, relocateable)
- bfd *abfd;
- bfd_seclet_type *seclet;
- asection *section;
- PTR data;
- boolean relocateable;
-{
- switch (seclet->type)
+ oinfo->symbolic_header.crfd = iinfo->symbolic_header.crfd;
+ oinfo->external_rfd = iinfo->external_rfd;
+ }
+ else
{
- case bfd_indirect_seclet:
- /* The contents of this section come from another one somewhere
- else. */
- return ecoff_rel (abfd, seclet, section, data, relocateable);
-
- case bfd_fill_seclet:
- /* Fill in the section with fill.value. This is used to pad out
- sections, but we must avoid padding the .bss section. */
- if ((section->flags & SEC_HAS_CONTENTS) == 0)
- {
- if (seclet->u.fill.value != 0)
- abort ();
- }
- else
+ /* 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++)
{
- char *d = (char *) bfd_alloc (abfd, seclet->size);
- unsigned int i;
- boolean ret;
-
- for (i = 0; i < seclet->size; i+=2)
- d[i] = seclet->u.fill.value >> 8;
- for (i = 1; i < seclet->size; i+=2)
- d[i] = seclet->u.fill.value;
- ret = bfd_set_section_contents (abfd, section, d, seclet->offset,
- seclet->size);
- bfd_release (abfd, (PTR) d);
- return ret;
- }
- break;
+ EXTR esym;
- default:
- abort();
+ (*(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);
+ }
}
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 *abfd;
+ enum bfd_architecture arch;
+ unsigned long machine;
+{
+ bfd_default_set_arch_mach (abfd, arch, machine);
+ return arch == ecoff_backend (abfd)->arch;
+}
-/* Add a string to the debugging information we are accumulating for a
- file. Return the offset from the fdr string base or from the
- external string base. */
+/* Get the size of the section headers. */
-static long
-ecoff_add_string (output_bfd, fdr, string, external)
- bfd *output_bfd;
- FDR *fdr;
- CONST char *string;
- boolean external;
+/*ARGSUSED*/
+int
+ecoff_sizeof_headers (abfd, reloc)
+ bfd *abfd;
+ boolean reloc;
{
- HDRR *symhdr;
- size_t len;
- long ret;
+ asection *current;
+ int c;
+ int ret;
- symhdr = &ecoff_data (output_bfd)->symbolic_header;
- len = strlen (string);
- if (external)
- {
- strcpy (ecoff_data (output_bfd)->ssext + symhdr->issExtMax, string);
- ret = symhdr->issExtMax;
- symhdr->issExtMax += len + 1;
- }
- else
- {
- strcpy (ecoff_data (output_bfd)->ss + symhdr->issMax, string);
- ret = fdr->cbSs;
- symhdr->issMax += len + 1;
- fdr->cbSs += len + 1;
- }
- return ret;
+ c = 0;
+ for (current = abfd->sections;
+ current != (asection *)NULL;
+ current = current->next)
+ ++c;
+
+ ret = (bfd_coff_filhsz (abfd)
+ + bfd_coff_aoutsz (abfd)
+ + c * bfd_coff_scnhsz (abfd));
+ return BFD_ALIGN (ret, 16);
}
-/* Accumulate the debugging information from an input section. */
+/* Get the contents of a section. */
-static boolean
-ecoff_get_debug (output_bfd, seclet, section, relocateable)
- bfd *output_bfd;
- bfd_seclet_type *seclet;
+boolean
+ecoff_get_section_contents (abfd, section, location, offset, count)
+ bfd *abfd;
asection *section;
- boolean relocateable;
+ PTR location;
+ file_ptr offset;
+ bfd_size_type count;
{
- const struct ecoff_backend_data * const backend = ecoff_backend (output_bfd);
- const bfd_size_type external_sym_size = backend->external_sym_size;
- const bfd_size_type external_pdr_size = backend->external_pdr_size;
- const bfd_size_type external_fdr_size = backend->external_fdr_size;
- const bfd_size_type external_rfd_size = backend->external_rfd_size;
- void (* const swap_sym_in) PARAMS ((bfd *, PTR, SYMR *))
- = backend->swap_sym_in;
- void (* const swap_sym_out) PARAMS ((bfd *, const SYMR *, PTR))
- = backend->swap_sym_out;
- void (* const swap_pdr_in) PARAMS ((bfd *, PTR, PDR *))
- = backend->swap_pdr_in;
- void (* const swap_fdr_out) PARAMS ((bfd *, const FDR *, PTR))
- = backend->swap_fdr_out;
- void (* const swap_rfd_out) PARAMS ((bfd *, const RFDT *, PTR))
- = backend->swap_rfd_out;
- bfd *input_bfd;
- HDRR *output_symhdr;
- HDRR *input_symhdr;
- ecoff_data_type *output_ecoff;
- ecoff_data_type *input_ecoff;
- unsigned int count;
- char *sym_out;
- ecoff_symbol_type *esym_ptr;
- ecoff_symbol_type *esym_end;
- FDR *fdr_ptr;
- FDR *fdr_end;
- char *fdr_out;
+ return _bfd_generic_get_section_contents (abfd, section, location,
+ offset, count);
+}
- input_bfd = seclet->u.indirect.section->owner;
+/* Calculate the file position for each section, and set
+ reloc_filepos. */
- /* Don't get the information more than once. */
- if (input_bfd->output_has_begun)
- return true;
- input_bfd->output_has_begun = true;
+static void
+ecoff_compute_section_file_positions (abfd)
+ bfd *abfd;
+{
+ asection *current;
+ file_ptr sofar;
+ file_ptr old_sofar;
+ boolean first_data;
- output_ecoff = ecoff_data (output_bfd);
- output_symhdr = &output_ecoff->symbolic_header;
+ sofar = ecoff_sizeof_headers (abfd, false);
- if (input_bfd->xvec->flavour != bfd_target_ecoff_flavour)
+ first_data = true;
+ for (current = abfd->sections;
+ current != (asection *) NULL;
+ current = current->next)
{
- FDR fdr;
- asymbol **symbols;
- asymbol **sym_ptr;
- asymbol **sym_end;
-
- /* This is not an ECOFF BFD. Just gather the symbols. */
+ unsigned int alignment_power;
- memset (&fdr, 0, sizeof fdr);
-
- fdr.adr = bfd_get_section_vma (output_bfd, section) + seclet->offset;
- fdr.issBase = output_symhdr->issMax;
- fdr.cbSs = 0;
- fdr.rss = ecoff_add_string (output_bfd,
- &fdr,
- bfd_get_filename (input_bfd),
- false);
- fdr.isymBase = output_symhdr->isymMax;
+ /* Only deal with sections which have contents */
+ if ((current->flags & (SEC_HAS_CONTENTS | SEC_LOAD)) == 0)
+ continue;
- /* Get the local symbols from the input BFD. */
- symbols = (asymbol **) bfd_alloc (output_bfd,
- get_symtab_upper_bound (input_bfd));
- if (symbols == (asymbol **) NULL)
+ /* 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
{
- bfd_error = no_memory;
- return false;
+ current->line_filepos = current->_raw_size / 8;
+ alignment_power = 4;
}
- sym_end = symbols + bfd_canonicalize_symtab (input_bfd, symbols);
- /* Handle the local symbols. Any external symbols are handled
- separately. */
- fdr.csym = 0;
- for (sym_ptr = symbols; sym_ptr != sym_end; sym_ptr++)
+ /* On Ultrix, the data sections in an executable file must be
+ aligned to a page boundary within the file. This does not
+ affect the section size, though. FIXME: Does this work for
+ other platforms? It requires some modification for the
+ Alpha, because .rdata on the Alpha goes with the text, not
+ the data. */
+ if ((abfd->flags & EXEC_P) != 0
+ && (abfd->flags & D_PAGED) != 0
+ && first_data != false
+ && (current->flags & SEC_CODE) == 0
+ && (! ecoff_backend (abfd)->rdata_in_text
+ || strcmp (current->name, _RDATA) != 0)
+ && strcmp (current->name, _PDATA) != 0)
{
- SYMR internal_sym;
+ const bfd_vma round = ecoff_backend (abfd)->round;
- if (((*sym_ptr)->flags & BSF_EXPORT) != 0)
- continue;
- memset (&internal_sym, 0, sizeof internal_sym);
- internal_sym.iss = ecoff_add_string (output_bfd,
- &fdr,
- (*sym_ptr)->name,
- false);
-
- if (bfd_is_com_section ((*sym_ptr)->section)
- || (*sym_ptr)->section == &bfd_und_section)
- internal_sym.value = (*sym_ptr)->value;
- else
- internal_sym.value = ((*sym_ptr)->value
- + (*sym_ptr)->section->output_offset
- + (*sym_ptr)->section->output_section->vma);
- internal_sym.st = stNil;
- internal_sym.sc = scUndefined;
- internal_sym.index = indexNil;
- (*swap_sym_out) (output_bfd, &internal_sym,
- ((char *) output_ecoff->external_sym
- + output_symhdr->isymMax * external_sym_size));
- ++fdr.csym;
- ++output_symhdr->isymMax;
+ sofar = (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. */
- bfd_release (output_bfd, (PTR) symbols);
-
- /* Leave everything else in the FDR zeroed out. This will cause
- the lang field to be langC. The fBigendian field will
- indicate little endian format, but it doesn't matter because
- it only applies to aux fields and there are none. */
+ sofar = (sofar + round - 1) &~ (round - 1);
+ }
- (*swap_fdr_out) (output_bfd, &fdr,
- ((char *) output_ecoff->external_fdr
- + output_symhdr->ifdMax * external_fdr_size));
- ++output_symhdr->ifdMax;
- return true;
- }
+ /* 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);
- /* This is an ECOFF BFD. We want to grab the information from
- input_bfd and attach it to output_bfd. */
- count = bfd_get_symcount (input_bfd);
- if (count == 0)
- return true;
- input_ecoff = ecoff_data (input_bfd);
- input_symhdr = &input_ecoff->symbolic_header;
+ current->filepos = sofar;
- /* I think that it is more efficient to simply copy the debugging
- information from the input BFD to the output BFD. Because ECOFF
- uses relative pointers for most of the debugging information,
- only a little of it has to be changed at all. */
+ sofar += current->_raw_size;
- /* Swap in the local symbols, adjust their values, and swap them out
- again. The external symbols are handled separately. */
- sym_out = ((char *) output_ecoff->external_sym
- + output_symhdr->isymMax * external_sym_size);
+ /* make sure that this section is of the right size too */
+ old_sofar = sofar;
+ sofar = BFD_ALIGN (sofar, 1 << alignment_power);
+ current->_raw_size += sofar - old_sofar;
+ }
- esym_ptr = ecoff_data (input_bfd)->canonical_symbols;
- esym_end = esym_ptr + count;
- for (; esym_ptr < esym_end; esym_ptr++)
- {
- if (esym_ptr->local)
- {
- SYMR sym;
+ ecoff_data (abfd)->reloc_filepos = sofar;
+}
- (*swap_sym_in) (input_bfd, esym_ptr->native, &sym);
+/* Determine the location of the relocs for all the sections in the
+ output file, as well as the location of the symbolic debugging
+ information. */
- /* If we're producing an executable, move common symbols
- into bss. */
- if (relocateable == false)
- {
- if (sym.sc == scCommon)
- sym.sc = scBss;
- else if (sym.sc == scSCommon)
- sym.sc = scSBss;
- }
+static bfd_size_type
+ecoff_compute_reloc_file_positions (abfd)
+ bfd *abfd;
+{
+ const bfd_size_type external_reloc_size =
+ ecoff_backend (abfd)->external_reloc_size;
+ file_ptr reloc_base;
+ bfd_size_type reloc_size;
+ asection *current;
+ file_ptr sym_base;
- if (! bfd_is_com_section (esym_ptr->symbol.section)
- && (esym_ptr->symbol.flags & BSF_DEBUGGING) == 0
- && esym_ptr->symbol.section != &bfd_und_section)
- sym.value = (esym_ptr->symbol.value
- + esym_ptr->symbol.section->output_offset
- + esym_ptr->symbol.section->output_section->vma);
- (*swap_sym_out) (output_bfd, &sym, sym_out);
- sym_out += external_sym_size;
- }
+ if (! abfd->output_has_begun)
+ {
+ ecoff_compute_section_file_positions (abfd);
+ abfd->output_has_begun = true;
}
+
+ reloc_base = ecoff_data (abfd)->reloc_filepos;
- /* That should have accounted for all the local symbols in
- input_bfd. */
-
- /* Copy the information that does not need swapping. */
- memcpy (output_ecoff->line + output_symhdr->cbLine,
- input_ecoff->line,
- input_symhdr->cbLine * sizeof (unsigned char));
- memcpy (output_ecoff->external_aux + output_symhdr->iauxMax,
- input_ecoff->external_aux,
- input_symhdr->iauxMax * sizeof (union aux_ext));
- memcpy (output_ecoff->ss + output_symhdr->issMax,
- input_ecoff->ss,
- input_symhdr->issMax * sizeof (char));
-
- /* Some of the information may need to be swapped. */
- if (output_bfd->xvec->header_byteorder_big_p
- == input_bfd->xvec->header_byteorder_big_p)
- {
- /* The two BFD's have the same endianness, so memcpy will
- suffice. */
- if (input_symhdr->idnMax > 0)
- memcpy (((char *) output_ecoff->external_dnr
- + output_symhdr->idnMax * backend->external_dnr_size),
- input_ecoff->external_dnr,
- input_symhdr->idnMax * backend->external_dnr_size);
- if (input_symhdr->ipdMax > 0)
- memcpy (((char *) output_ecoff->external_pdr
- + output_symhdr->ipdMax * external_pdr_size),
- input_ecoff->external_pdr,
- input_symhdr->ipdMax * external_pdr_size);
- if (input_symhdr->ioptMax > 0)
- memcpy (((char *) output_ecoff->external_opt
- + output_symhdr->ioptMax * backend->external_opt_size),
- input_ecoff->external_opt,
- input_symhdr->ioptMax * backend->external_opt_size);
- }
- else
+ reloc_size = 0;
+ for (current = abfd->sections;
+ current != (asection *)NULL;
+ current = current->next)
{
- bfd_size_type sz;
- char *in;
- char *end;
- char *out;
-
- /* The two BFD's have different endianness, so we must swap
- everything in and out. This code would always work, but it
- would be slow in the normal case. */
- sz = backend->external_dnr_size;
- in = (char *) input_ecoff->external_dnr;
- end = in + input_symhdr->idnMax * sz;
- out = (char *) output_ecoff->external_dnr + output_symhdr->idnMax * sz;
- for (; in < end; in += sz, out += sz)
- {
- DNR dnr;
-
- (*backend->swap_dnr_in) (input_bfd, in, &dnr);
- (*backend->swap_dnr_out) (output_bfd, &dnr, out);
- }
-
- sz = external_pdr_size;
- in = (char *) input_ecoff->external_pdr;
- end = in + input_symhdr->ipdMax * sz;
- out = (char *) output_ecoff->external_pdr + output_symhdr->ipdMax * sz;
- for (; in < end; in += sz, out += sz)
- {
- PDR pdr;
-
- (*swap_pdr_in) (input_bfd, in, &pdr);
- (*backend->swap_pdr_out) (output_bfd, &pdr, out);
- }
-
- sz = backend->external_opt_size;
- in = (char *) input_ecoff->external_opt;
- end = in + input_symhdr->ioptMax * sz;
- out = (char *) output_ecoff->external_opt + output_symhdr->ioptMax * sz;
- for (; in < end; in += sz, out += sz)
+ if (current->reloc_count == 0)
+ current->rel_filepos = 0;
+ else
{
- OPTR opt;
+ bfd_size_type relsize;
- (*backend->swap_opt_in) (input_bfd, in, &opt);
- (*backend->swap_opt_out) (output_bfd, &opt, out);
+ current->rel_filepos = reloc_base;
+ relsize = current->reloc_count * external_reloc_size;
+ reloc_size += relsize;
+ reloc_base += relsize;
}
}
- /* Set ifdbase so that the external symbols know how to adjust their
- ifd values. */
- input_ecoff->ifdbase = output_symhdr->ifdMax;
+ sym_base = ecoff_data (abfd)->reloc_filepos + reloc_size;
- fdr_ptr = input_ecoff->fdr;
- fdr_end = fdr_ptr + input_symhdr->ifdMax;
- fdr_out = ((char *) output_ecoff->external_fdr
- + output_symhdr->ifdMax * external_fdr_size);
- for (; fdr_ptr < fdr_end; fdr_ptr++, fdr_out += external_fdr_size)
- {
- FDR fdr;
- unsigned long pdr_off;
+ /* At least on Ultrix, the symbol table of an executable file must
+ be aligned to a page boundary. FIXME: Is this true on other
+ platforms? */
+ if ((abfd->flags & EXEC_P) != 0
+ && (abfd->flags & D_PAGED) != 0)
+ sym_base = ((sym_base + ecoff_backend (abfd)->round - 1)
+ &~ (ecoff_backend (abfd)->round - 1));
- fdr = *fdr_ptr;
+ ecoff_data (abfd)->sym_filepos = sym_base;
- /* The memory address for this fdr is the address for the seclet
- plus the offset to this fdr within input_bfd. For some
- reason the offset of the first procedure pointer is also
- added in. */
- if (fdr.cpd == 0)
- pdr_off = 0;
- else
- {
- PDR pdr;
+ return reloc_size;
+}
- (*swap_pdr_in) (input_bfd,
- ((char *) input_ecoff->external_pdr
- + fdr.ipdFirst * external_pdr_size),
- &pdr);
- pdr_off = pdr.adr;
- }
- fdr.adr = (bfd_get_section_vma (output_bfd, section)
- + seclet->offset
- + (fdr_ptr->adr - input_ecoff->fdr->adr)
- + pdr_off);
-
- fdr.issBase += output_symhdr->issMax;
- fdr.isymBase += output_symhdr->isymMax;
- fdr.ilineBase += output_symhdr->ilineMax;
- fdr.ioptBase += output_symhdr->ioptMax;
- fdr.ipdFirst += output_symhdr->ipdMax;
- fdr.iauxBase += output_symhdr->iauxMax;
- fdr.rfdBase += output_symhdr->crfd;
-
- /* If there are no RFD's, we are going to add some. We don't
- want to adjust irfd for this, so that all the FDR's can share
- the RFD's. */
- if (input_symhdr->crfd == 0)
- fdr.crfd = input_symhdr->ifdMax;
-
- if (fdr.cbLine != 0)
- fdr.cbLineOffset += output_symhdr->cbLine;
-
- (*swap_fdr_out) (output_bfd, &fdr, fdr_out);
- }
-
- if (input_symhdr->crfd > 0)
- {
- void (* const swap_rfd_in) PARAMS ((bfd *, PTR, RFDT *))
- = backend->swap_rfd_in;
- char *rfd_in;
- char *rfd_end;
- char *rfd_out;
-
- /* Swap and adjust the RFD's. RFD's are only created by the
- linker, so this will only be necessary if one of the input
- files is the result of a partial link. Presumably all
- necessary RFD's are present. */
- rfd_in = (char *) input_ecoff->external_rfd;
- rfd_end = rfd_in + input_symhdr->crfd * external_rfd_size;
- rfd_out = ((char *) output_ecoff->external_rfd
- + output_symhdr->crfd * external_rfd_size);
- for (;
- rfd_in < rfd_end;
- rfd_in += external_rfd_size, rfd_out += external_rfd_size)
- {
- RFDT rfd;
+/* Set the contents of a section. */
- (*swap_rfd_in) (input_bfd, rfd_in, &rfd);
- rfd += output_symhdr->ifdMax;
- (*swap_rfd_out) (output_bfd, &rfd, rfd_out);
- }
- output_symhdr->crfd += input_symhdr->crfd;
- }
- else
- {
- char *rfd_out;
- char *rfd_end;
- RFDT rfd;
-
- /* Create RFD's. Some of the debugging information includes
- relative file indices. These indices are taken as indices to
- the RFD table if there is one, or to the global table if
- there is not. If we did not create RFD's, we would have to
- parse and adjust all the debugging information which contains
- file indices. */
- rfd = output_symhdr->ifdMax;
- rfd_out = ((char *) output_ecoff->external_rfd
- + output_symhdr->crfd * external_rfd_size);
- rfd_end = rfd_out + input_symhdr->ifdMax * external_rfd_size;
- for (; rfd_out < rfd_end; rfd_out += external_rfd_size, rfd++)
- (*swap_rfd_out) (output_bfd, &rfd, rfd_out);
- output_symhdr->crfd += input_symhdr->ifdMax;
- }
-
- /* Combine the register masks. Not all of these are used on all
- targets, but that's OK because only the relevant ones will be
- swapped in and out. */
- {
- int i;
+boolean
+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);
- output_ecoff->gprmask |= input_ecoff->gprmask;
- output_ecoff->fprmask |= input_ecoff->fprmask;
- for (i = 0; i < 4; i++)
- output_ecoff->cprmask[i] |= input_ecoff->cprmask[i];
- }
+ /* If this is a .lib section, bump the vma address so that it winds
+ up being the number of .lib sections output. This is right for
+ Irix 4. Ian Taylor <ian@cygnus.com>. */
+ if (strcmp (section->name, _LIB) == 0)
+ ++section->vma;
+
+ if (count == 0)
+ return true;
- /* Update the counts. */
- output_symhdr->ilineMax += input_symhdr->ilineMax;
- output_symhdr->cbLine += input_symhdr->cbLine;
- output_symhdr->idnMax += input_symhdr->idnMax;
- output_symhdr->ipdMax += input_symhdr->ipdMax;
- output_symhdr->isymMax += input_symhdr->isymMax;
- output_symhdr->ioptMax += input_symhdr->ioptMax;
- output_symhdr->iauxMax += input_symhdr->iauxMax;
- output_symhdr->issMax += input_symhdr->issMax;
- output_symhdr->ifdMax += input_symhdr->ifdMax;
+ if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) != 0
+ || bfd_write (location, 1, count, abfd) != count)
+ return false;
return true;
}
-/* This is the actual link routine. It makes two passes over all the
- seclets. */
+/* Get the GP value for an ECOFF file. This is a hook used by
+ nlmconv. */
-boolean
-ecoff_bfd_seclet_link (abfd, data, relocateable)
+bfd_vma
+bfd_ecoff_get_gp_value (abfd)
bfd *abfd;
- PTR data;
- boolean relocateable;
{
- const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
- HDRR *symhdr;
- int ipass;
- register asection *o;
- register bfd_seclet_type *p;
- asymbol **sym_ptr_ptr;
- bfd_size_type debug_align;
- bfd_size_type size;
- char *raw;
+ if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour
+ || bfd_get_format (abfd) != bfd_object)
+ {
+ bfd_set_error (bfd_error_invalid_operation);
+ return 0;
+ }
+
+ return ecoff_data (abfd)->gp;
+}
- /* We accumulate the debugging information counts in the symbolic
- header. */
- symhdr = &ecoff_data (abfd)->symbolic_header;
- symhdr->magic = backend->sym_magic;
- /* FIXME: What should the version stamp be? */
- symhdr->vstamp = 0;
- symhdr->ilineMax = 0;
- symhdr->cbLine = 0;
- symhdr->idnMax = 0;
- symhdr->ipdMax = 0;
- symhdr->isymMax = 0;
- symhdr->ioptMax = 0;
- symhdr->iauxMax = 0;
- symhdr->issMax = 0;
- symhdr->issExtMax = 0;
- symhdr->ifdMax = 0;
- symhdr->crfd = 0;
- symhdr->iextMax = 0;
+/* Set the GP value for an ECOFF file. This is a hook used by the
+ assembler. */
- /* We need to copy over the debugging symbols from each input BFD.
- When we do this copying, we have to adjust the text address in
- the FDR structures, so we have to know the text address used for
- the input BFD. Since we only want to copy the symbols once per
- input BFD, but we are going to look at each input BFD multiple
- times (once for each section it provides), we arrange to always
- look at the text section first. That means that when we copy the
- debugging information, we always know the text address. So we
- actually do each pass in two sub passes; first the text sections,
- then the non-text sections. We use the output_has_begun flag to
- determine whether we have copied over the debugging information
- yet. */
-
- /* Do the first pass: set the output section contents and count the
- debugging information. */
- ecoff_clear_output_flags (abfd);
- for (ipass = 0; ipass < 2; ipass++)
+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)
{
- for (o = abfd->sections; o != (asection *) NULL; o = o->next)
- {
- /* For SEC_CODE sections, (flags & SEC_CODE) == 0 is false,
- so they are done on pass 0. For other sections the
- expression is true, so they are done on pass 1. */
- if (((o->flags & SEC_CODE) == 0) != ipass)
- continue;
-
- for (p = o->seclets_head;
- p != (bfd_seclet_type *) NULL;
- p = p->next)
- {
- if (ecoff_dump_seclet (abfd, p, o, data, relocateable)
- == false)
- return false;
- }
- }
+ bfd_set_error (bfd_error_invalid_operation);
+ return false;
}
- /* We handle the external symbols differently. We use the ones
- attached to the output_bfd. The linker will have already
- determined which symbols are to be attached. Here we just
- determine how much space we will need for them. */
- sym_ptr_ptr = bfd_get_outsymbols (abfd);
- if (sym_ptr_ptr != NULL)
- {
- asymbol **sym_end;
+ ecoff_data (abfd)->gp = gp_value;
- sym_end = sym_ptr_ptr + bfd_get_symcount (abfd);
- for (; sym_ptr_ptr < sym_end; sym_ptr_ptr++)
- {
- if (((*sym_ptr_ptr)->flags & BSF_DEBUGGING) == 0
- && ((*sym_ptr_ptr)->flags & BSF_LOCAL) == 0)
- {
- ++symhdr->iextMax;
- symhdr->issExtMax += strlen ((*sym_ptr_ptr)->name) + 1;
- }
- }
- }
+ return true;
+}
- /* Adjust the counts so that structures are longword aligned. */
- debug_align = backend->debug_align;
- --debug_align;
- symhdr->cbLine = (symhdr->cbLine + debug_align) &~ debug_align;
- symhdr->issMax = (symhdr->issMax + debug_align) &~ debug_align;
- symhdr->issExtMax = (symhdr->issExtMax + debug_align) &~ debug_align;
-
- /* Now the counts in symhdr are the correct size for the debugging
- information. We allocate the right amount of space, and reset
- the counts so that the second pass can use them as indices. It
- would be possible to output the debugging information directly to
- the file in pass 2, rather than to build it in memory and then
- write it out. Outputting to the file would require a lot of
- seeks and small writes, though, and I think this approach is
- faster. */
- size = (symhdr->cbLine * sizeof (unsigned char)
- + symhdr->idnMax * backend->external_dnr_size
- + symhdr->ipdMax * backend->external_pdr_size
- + symhdr->isymMax * backend->external_sym_size
- + symhdr->ioptMax * backend->external_opt_size
- + symhdr->iauxMax * sizeof (union aux_ext)
- + symhdr->issMax * sizeof (char)
- + symhdr->issExtMax * sizeof (char)
- + symhdr->ifdMax * backend->external_fdr_size
- + symhdr->crfd * backend->external_rfd_size
- + symhdr->iextMax * backend->external_ext_size);
- raw = (char *) bfd_alloc (abfd, size);
- if (raw == (char *) NULL)
- {
- bfd_error = no_memory;
- return false;
- }
- ecoff_data (abfd)->raw_size = size;
- ecoff_data (abfd)->raw_syments = (PTR) raw;
-
- /* Initialize the raw pointers. */
-#define SET(field, count, type, size) \
- ecoff_data (abfd)->field = (type) raw; \
- raw += symhdr->count * size
-
- SET (line, cbLine, unsigned char *, sizeof (unsigned char));
- SET (external_dnr, idnMax, PTR, backend->external_dnr_size);
- SET (external_pdr, ipdMax, PTR, backend->external_pdr_size);
- SET (external_sym, isymMax, PTR, backend->external_sym_size);
- SET (external_opt, ioptMax, PTR, backend->external_opt_size);
- SET (external_aux, iauxMax, union aux_ext *, sizeof (union aux_ext));
- SET (ss, issMax, char *, sizeof (char));
- SET (ssext, issExtMax, char *, sizeof (char));
- SET (external_fdr, ifdMax, PTR, backend->external_fdr_size);
- SET (external_rfd, crfd, PTR, backend->external_rfd_size);
- SET (external_ext, iextMax, PTR, backend->external_ext_size);
-#undef SET
-
- /* Reset the counts so the second pass can use them to know how far
- it has gotten. */
- symhdr->ilineMax = 0;
- symhdr->cbLine = 0;
- symhdr->idnMax = 0;
- symhdr->ipdMax = 0;
- symhdr->isymMax = 0;
- symhdr->ioptMax = 0;
- symhdr->iauxMax = 0;
- symhdr->issMax = 0;
- symhdr->issExtMax = 0;
- symhdr->ifdMax = 0;
- symhdr->crfd = 0;
- symhdr->iextMax = 0;
+/* Set the register masks for an ECOFF file. This is a hook used by
+ the assembler. */
+
+boolean
+bfd_ecoff_set_regmasks (abfd, gprmask, fprmask, cprmask)
+ bfd *abfd;
+ unsigned long gprmask;
+ unsigned long fprmask;
+ unsigned long *cprmask;
+{
+ ecoff_data_type *tdata;
- /* Do the second pass: accumulate the debugging information. */
- ecoff_clear_output_flags (abfd);
- for (ipass = 0; ipass < 2; ipass++)
+ if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour
+ || bfd_get_format (abfd) != bfd_object)
{
- for (o = abfd->sections; o != (asection *) NULL; o = o->next)
- {
- if (((o->flags & SEC_CODE) == 0) != ipass)
- continue;
- for (p = o->seclets_head;
- p != (bfd_seclet_type *) NULL;
- p = p->next)
- {
- if (p->type == bfd_indirect_seclet)
- {
- if (ecoff_get_debug (abfd, p, o, relocateable) == false)
- return false;
- }
- }
- }
+ bfd_set_error (bfd_error_invalid_operation);
+ return false;
}
- /* Put in the external symbols. */
- sym_ptr_ptr = bfd_get_outsymbols (abfd);
- if (sym_ptr_ptr != NULL)
+ tdata = ecoff_data (abfd);
+ tdata->gprmask = gprmask;
+ tdata->fprmask = fprmask;
+ if (cprmask != (unsigned long *) NULL)
{
- const bfd_size_type external_ext_size = backend->external_ext_size;
- void (* const swap_ext_in) PARAMS ((bfd *, PTR, EXTR *))
- = backend->swap_ext_in;
- void (* const swap_ext_out) PARAMS ((bfd *, const EXTR *, PTR))
- = backend->swap_ext_out;
- char *ssext;
- char *external_ext;
-
- ssext = ecoff_data (abfd)->ssext;
- external_ext = (char *) ecoff_data (abfd)->external_ext;
- for (; *sym_ptr_ptr != NULL; sym_ptr_ptr++)
- {
- asymbol *sym_ptr;
- EXTR esym;
+ register int i;
- sym_ptr = *sym_ptr_ptr;
-
- if ((sym_ptr->flags & BSF_DEBUGGING) != 0
- || (sym_ptr->flags & BSF_LOCAL) != 0)
- continue;
-
- /* The native pointer can be NULL for a symbol created by
- the linker via ecoff_make_empty_symbol. */
- if (bfd_asymbol_flavour (sym_ptr) != bfd_target_ecoff_flavour
- || ecoffsymbol (sym_ptr)->native == NULL)
- {
- esym.jmptbl = 0;
- esym.cobol_main = 0;
- esym.weakext = 0;
- esym.reserved = 0;
- esym.ifd = ifdNil;
- /* FIXME: we can do better than this for st and sc. */
- esym.asym.st = stGlobal;
- esym.asym.sc = scAbs;
- esym.asym.reserved = 0;
- esym.asym.index = indexNil;
- }
- else
- {
- ecoff_symbol_type *ecoff_sym_ptr;
+ for (i = 0; i < 3; i++)
+ tdata->cprmask[i] = cprmask[i];
+ }
- ecoff_sym_ptr = ecoffsymbol (sym_ptr);
- if (ecoff_sym_ptr->local)
- abort ();
- (*swap_ext_in) (abfd, ecoff_sym_ptr->native, &esym);
+ return true;
+}
- /* If we're producing an executable, move common symbols
- into bss. */
- if (relocateable == false)
- {
- if (esym.asym.sc == scCommon)
- esym.asym.sc = scBss;
- else if (esym.asym.sc == scSCommon)
- esym.asym.sc = scSBss;
- }
+/* Get ECOFF EXTR information for an external symbol. This function
+ is passed to bfd_ecoff_debug_externals. */
- /* Adjust the FDR index for the symbol by that used for
- the input BFD. */
- esym.ifd += ecoff_data (bfd_asymbol_bfd (sym_ptr))->ifdbase;
- }
+static boolean
+ecoff_get_extr (sym, esym)
+ asymbol *sym;
+ EXTR *esym;
+{
+ ecoff_symbol_type *ecoff_sym_ptr;
+ bfd *input_bfd;
- esym.asym.iss = symhdr->issExtMax;
+ 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;
- if (bfd_is_com_section (sym_ptr->section)
- || sym_ptr->section == &bfd_und_section)
- esym.asym.value = sym_ptr->value;
- else
- esym.asym.value = (sym_ptr->value
- + sym_ptr->section->output_offset
- + sym_ptr->section->output_section->vma);
+ esym->jmptbl = 0;
+ esym->cobol_main = 0;
+ esym->weakext = 0;
+ esym->reserved = 0;
+ esym->ifd = ifdNil;
+ /* FIXME: we can do better than this for st and sc. */
+ esym->asym.st = stGlobal;
+ esym->asym.sc = scAbs;
+ esym->asym.reserved = 0;
+ esym->asym.index = indexNil;
+ return true;
+ }
- (*swap_ext_out) (abfd, &esym, external_ext);
+ ecoff_sym_ptr = ecoffsymbol (sym);
- ecoff_set_sym_index (sym_ptr, symhdr->iextMax);
+ if (ecoff_sym_ptr->local)
+ return false;
- external_ext += external_ext_size;
- ++symhdr->iextMax;
+ input_bfd = bfd_asymbol_bfd (sym);
+ (*(ecoff_backend (input_bfd)->debug_swap.swap_ext_in))
+ (input_bfd, ecoff_sym_ptr->native, esym);
+
+ /* If the symbol was defined by the linker, then esym will be
+ undefined but sym will not be. Get a better class for such a
+ symbol. */
+ if ((esym->asym.sc == scUndefined
+ || esym->asym.sc == scSUndefined)
+ && bfd_get_section (sym) != &bfd_und_section)
+ esym->asym.sc = scAbs;
+
+ /* Adjust the FDR index for the symbol by that used for the input
+ BFD. */
+ if (esym->ifd != -1)
+ {
+ struct ecoff_debug_info *input_debug;
- strcpy (ssext + symhdr->issExtMax, sym_ptr->name);
- symhdr->issExtMax += strlen (sym_ptr->name) + 1;
- }
+ input_debug = &ecoff_data (input_bfd)->debug_info;
+ BFD_ASSERT (esym->ifd < input_debug->symbolic_header.ifdMax);
+ if (input_debug->ifdmap != (RFDT *) NULL)
+ esym->ifd = input_debug->ifdmap[esym->ifd];
}
- /* Adjust the counts so that structures are longword aligned. */
- symhdr->cbLine = (symhdr->cbLine + debug_align) &~ debug_align;
- symhdr->issMax = (symhdr->issMax + debug_align) &~ debug_align;
- symhdr->issExtMax = (symhdr->issExtMax + debug_align) &~ debug_align;
-
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 *abfd;
- enum bfd_architecture arch;
- unsigned long machine;
+/* Set the external symbol index. This routine is passed to
+ bfd_ecoff_debug_externals. */
+
+static void
+ecoff_set_index (sym, indx)
+ asymbol *sym;
+ bfd_size_type indx;
{
- bfd_default_set_arch_mach (abfd, arch, machine);
- return arch == ecoff_backend (abfd)->arch;
+ ecoff_set_sym_index (sym, indx);
}
-/* Get the size of the section headers. We do not output the .scommon
- section which we created in ecoff_mkobject, nor do we output any
- .reginfo section. */
+/* Write out an ECOFF file. */
-int
-ecoff_sizeof_headers (abfd, reloc)
+boolean
+ecoff_write_object_contents (abfd)
bfd *abfd;
- boolean reloc;
{
+ const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
+ const bfd_vma round = backend->round;
+ const bfd_size_type filhsz = bfd_coff_filhsz (abfd);
+ const bfd_size_type aoutsz = bfd_coff_aoutsz (abfd);
+ const bfd_size_type scnhsz = bfd_coff_scnhsz (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 *))
+ = backend->adjust_reloc_out;
+ 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;
asection *current;
- int c;
+ unsigned int count;
+ bfd_size_type reloc_size;
+ bfd_size_type text_size;
+ bfd_vma text_start;
+ boolean set_text_start;
+ bfd_size_type data_size;
+ bfd_vma data_start;
+ boolean set_data_start;
+ bfd_size_type bss_size;
+ PTR buff = NULL;
+ PTR reloc_buff = NULL;
+ struct internal_filehdr internal_f;
+ struct internal_aouthdr internal_a;
+ int i;
- c = 0;
+ /* 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)
- if (strcmp (current->name, SCOMMON) != 0
- && strcmp (current->name, REGINFO) != 0)
- ++c;
-
- return (bfd_coff_filhsz (abfd)
- + bfd_coff_aoutsz (abfd)
- + c * bfd_coff_scnhsz (abfd));
-}
-
+ {
+ current->target_index = count;
+ ++count;
+ }
-/* 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. */
+ if ((abfd->flags & D_PAGED) != 0)
+ text_size = 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;
-boolean
-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;
+ /* Write section headers to the file. */
- if (strcmp (section->name, REGINFO) != 0)
- return bfd_generic_get_section_contents (abfd, section, location,
- offset, count);
+ /* 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) malloc (siz);
+ if (buff == NULL)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ goto error_return;
+ }
+ }
- 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, count);
- return true;
-}
-
-/* Calculate the file position for each section, and set
- reloc_filepos. */
-
-static void
-ecoff_compute_section_file_positions (abfd)
- bfd *abfd;
-{
- asection *current;
- file_ptr sofar;
- file_ptr old_sofar;
- boolean first_data;
-
- if (bfd_get_start_address (abfd))
- abfd->flags |= EXEC_P;
-
- sofar = ecoff_sizeof_headers (abfd, false);
-
- first_data = true;
- for (current = abfd->sections;
- current != (asection *) NULL;
- current = current->next)
- {
- /* Only deal with sections which have contents */
- if ((current->flags & (SEC_HAS_CONTENTS | SEC_LOAD)) == 0
- || strcmp (current->name, SCOMMON) == 0
- || strcmp (current->name, REGINFO) == 0)
- continue;
-
- /* On Ultrix, the data sections in an executable file must be
- aligned to a page boundary within the file. This does not
- affect the section size, though. FIXME: Does this work for
- other platforms? */
- if ((abfd->flags & EXEC_P) != 0
- && (abfd->flags & D_PAGED) != 0
- && first_data != false
- && (current->flags & SEC_CODE) == 0)
- {
- const bfd_vma round = ecoff_backend (abfd)->round;
-
- sofar = (sofar + round - 1) &~ (round - 1);
- first_data = false;
- }
-
- /* 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 << current->alignment_power);
-
- current->filepos = sofar;
-
- sofar += current->_raw_size;
-
- /* make sure that this section is of the right size too */
- old_sofar = sofar;
- sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
- current->_raw_size += sofar - old_sofar;
- }
-
- ecoff_data (abfd)->reloc_filepos = sofar;
-}
-
-/* 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. */
-
-boolean
-ecoff_set_section_contents (abfd, section, location, offset, count)
- bfd *abfd;
- asection *section;
- PTR location;
- file_ptr offset;
- bfd_size_type count;
-{
- if (abfd->output_has_begun == false)
- ecoff_compute_section_file_positions (abfd);
-
- if (strcmp (section->name, REGINFO) == 0)
- {
- ecoff_data_type *tdata = ecoff_data (abfd);
- struct ecoff_reginfo s;
- int i;
-
- /* If the caller is only changing part of the structure, we must
- retrieve the current information before the memcpy. */
- if (offset != 0 || count != sizeof (struct ecoff_reginfo))
- {
- s.gp_value = tdata->gp;
- s.gprmask = tdata->gprmask;
- for (i = 0; i < 4; i++)
- s.cprmask[i] = tdata->cprmask[i];
- s.fprmask = tdata->fprmask;
- }
-
- /* 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, count);
-
- 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;
-
- return true;
-
- }
-
- bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET);
-
- if (count != 0)
- return (bfd_write (location, 1, count, abfd) == count) ? true : false;
-
- return true;
-}
-
-/* Write out an ECOFF file. */
-
-boolean
-ecoff_write_object_contents (abfd)
- bfd *abfd;
-{
- const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
- const bfd_vma round = backend->round;
- const bfd_size_type filhsz = bfd_coff_filhsz (abfd);
- const bfd_size_type aoutsz = bfd_coff_aoutsz (abfd);
- const bfd_size_type scnhsz = bfd_coff_scnhsz (abfd);
- const bfd_size_type external_hdr_size = backend->external_hdr_size;
- const bfd_size_type external_reloc_size = backend->external_reloc_size;
- void (* const swap_reloc_out) PARAMS ((bfd *,
- const struct internal_reloc *,
- PTR))
- = backend->swap_reloc_out;
- asection *current;
- unsigned int count;
- file_ptr scn_base;
- file_ptr reloc_base;
- file_ptr sym_base;
- unsigned long reloc_size;
- unsigned long text_size;
- unsigned long text_start;
- unsigned long data_size;
- unsigned long data_start;
- unsigned long bss_size;
- PTR buff;
- struct internal_filehdr internal_f;
- struct internal_aouthdr internal_a;
- int i;
-
- bfd_error = system_call_error;
-
- if(abfd->output_has_begun == false)
- ecoff_compute_section_file_positions(abfd);
-
- if (abfd->sections != (asection *) NULL)
- scn_base = abfd->sections->filepos;
- else
- scn_base = 0;
- reloc_base = ecoff_data (abfd)->reloc_filepos;
-
- count = 1;
- reloc_size = 0;
- for (current = abfd->sections;
- current != (asection *)NULL;
- current = current->next)
- {
- if (strcmp (current->name, SCOMMON) == 0
- || strcmp (current->name, REGINFO) == 0)
- continue;
- current->target_index = count;
- ++count;
- if (current->reloc_count != 0)
- {
- bfd_size_type relsize;
-
- current->rel_filepos = reloc_base;
- relsize = current->reloc_count * external_reloc_size;
- reloc_size += relsize;
- reloc_base += relsize;
- }
- else
- current->rel_filepos = 0;
- }
-
- sym_base = reloc_base + reloc_size;
-
- /* At least on Ultrix, the symbol table of an executable file must
- be aligned to a page boundary. FIXME: Is this true on other
- platforms? */
- if ((abfd->flags & EXEC_P) != 0
- && (abfd->flags & D_PAGED) != 0)
- sym_base = (sym_base + round - 1) &~ (round - 1);
-
- ecoff_data (abfd)->sym_filepos = sym_base;
-
- if ((abfd->flags & D_PAGED) != 0)
- text_size = ecoff_sizeof_headers (abfd, false);
- else
- text_size = 0;
- text_start = 0;
- data_size = 0;
- data_start = 0;
- bss_size = 0;
-
- /* Write section headers to the file. */
-
- buff = (PTR) alloca (scnhsz);
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, SCOMMON) == 0)
- {
- BFD_ASSERT (bfd_get_section_size_before_reloc (current) == 0
- && current->reloc_count == 0);
- continue;
- }
- if (strcmp (current->name, REGINFO) == 0)
- {
- BFD_ASSERT ((bfd_get_section_size_before_reloc (current)
- == sizeof (struct ecoff_reginfo))
- && 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;
want the linker to compute the best size to use, or
something. I don't know what happens if the information is
not present. */
- section.s_lnnoptr = 0;
+ if (strcmp (current->name, _PDATA) != 0)
+ section.s_lnnoptr = 0;
+ else
+ {
+ /* The Alpha ECOFF .pdata section uses the lnnoptr field to
+ hold the number of entries in the section (each entry is
+ 8 bytes). We stored this in the line_filepos field in
+ ecoff_compute_section_file_positions. */
+ section.s_lnnoptr = current->line_filepos;
+ }
section.s_nreloc = current->reloc_count;
section.s_nlnno = 0;
bfd_coff_swap_scnhdr_out (abfd, (PTR) §ion, buff);
if (bfd_write (buff, 1, scnhsz, abfd) != scnhsz)
- return false;
+ goto error_return;
- if ((section.s_flags & STYP_TEXT) != 0)
+ if ((section.s_flags & STYP_TEXT) != 0
+ || ((section.s_flags & STYP_RDATA) != 0
+ && backend->rdata_in_text)
+ || strcmp (current->name, _PDATA) == 0)
{
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_LITA) != 0
|| (section.s_flags & STYP_LIT8) != 0
|| (section.s_flags & STYP_LIT4) != 0
- || (section.s_flags & STYP_SDATA) != 0)
+ || (section.s_flags & STYP_SDATA) != 0
+ || strcmp (current->name, _XDATA) == 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 & STYP_ECOFF_LIB) != 0)
+ /* Do nothing */ ;
+ else
+ abort ();
}
/* Set up the file header. */
/* The ECOFF f_nsyms field is not actually the number of
symbols, it's the size of symbolic information header. */
internal_f.f_nsyms = external_hdr_size;
- internal_f.f_symptr = sym_base;
+ internal_f.f_symptr = ecoff_data (abfd)->sym_filepos;
}
else
{
else
internal_a.magic = ECOFF_AOUT_OMAGIC;
- /* FIXME: This is what Ultrix puts in, and it makes the Ultrix
- linker happy. But, is it right? */
- internal_a.vstamp = 0x20a;
+ /* FIXME: Is this really correct? */
+ internal_a.vstamp = symhdr->vstamp;
/* At least on Ultrix, these have to be rounded to page boundaries.
FIXME: Is this true on other platforms? */
/* 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;
+ 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;
+ goto error_return;
- /* Write out the relocs. */
- for (current = abfd->sections;
- current != (asection *) NULL;
- current = current->next)
+ /* Build the external symbol information. This must be done before
+ 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)
{
- arelent **reloc_ptr_ptr;
- arelent **reloc_end;
- char *out_ptr;
-
- if (current->reloc_count == 0)
- continue;
-
- buff = bfd_alloc (abfd, current->reloc_count * external_reloc_size);
- if (buff == NULL)
- {
- bfd_error = no_memory;
- return false;
- }
+ 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)
+ goto error_return;
- reloc_ptr_ptr = current->orelocation;
- reloc_end = reloc_ptr_ptr + current->reloc_count;
- out_ptr = (char *) buff;
- for (;
- reloc_ptr_ptr < reloc_end;
- reloc_ptr_ptr++, out_ptr += external_reloc_size)
+ /* Write out the relocs. */
+ for (current = abfd->sections;
+ current != (asection *) NULL;
+ current = current->next)
{
- arelent *reloc;
- asymbol *sym;
- struct internal_reloc in;
-
- memset (&in, 0, sizeof in);
-
- reloc = *reloc_ptr_ptr;
- sym = *reloc->sym_ptr_ptr;
+ arelent **reloc_ptr_ptr;
+ arelent **reloc_end;
+ char *out_ptr;
- in.r_vaddr = reloc->address + bfd_get_section_vma (abfd, current);
- in.r_type = reloc->howto->type;
+ if (current->reloc_count == 0)
+ continue;
- if ((sym->flags & BSF_SECTION_SYM) == 0)
+ reloc_buff =
+ bfd_alloc (abfd, current->reloc_count * external_reloc_size);
+ if (reloc_buff == NULL)
{
- in.r_symndx = ecoff_get_sym_index (*reloc->sym_ptr_ptr);
- in.r_extern = 1;
+ bfd_set_error (bfd_error_no_memory);
+ goto error_return;
}
- else
+
+ reloc_ptr_ptr = current->orelocation;
+ reloc_end = reloc_ptr_ptr + current->reloc_count;
+ out_ptr = (char *) reloc_buff;
+ for (;
+ reloc_ptr_ptr < reloc_end;
+ reloc_ptr_ptr++, out_ptr += external_reloc_size)
{
- CONST char *name;
-
- name = bfd_get_section_name (abfd, bfd_get_section (sym));
- if (strcmp (name, ".text") == 0)
- in.r_symndx = RELOC_SECTION_TEXT;
- else if (strcmp (name, ".rdata") == 0)
- in.r_symndx = RELOC_SECTION_RDATA;
- else if (strcmp (name, ".data") == 0)
- in.r_symndx = RELOC_SECTION_DATA;
- else if (strcmp (name, ".sdata") == 0)
- in.r_symndx = RELOC_SECTION_SDATA;
- else if (strcmp (name, ".sbss") == 0)
- in.r_symndx = RELOC_SECTION_SBSS;
- else if (strcmp (name, ".bss") == 0)
- in.r_symndx = RELOC_SECTION_BSS;
- else if (strcmp (name, ".init") == 0)
- in.r_symndx = RELOC_SECTION_INIT;
- else if (strcmp (name, ".lit8") == 0)
- in.r_symndx = RELOC_SECTION_LIT8;
- else if (strcmp (name, ".lit4") == 0)
- in.r_symndx = RELOC_SECTION_LIT4;
+ arelent *reloc;
+ asymbol *sym;
+ struct internal_reloc in;
+
+ memset ((PTR) &in, 0, sizeof in);
+
+ reloc = *reloc_ptr_ptr;
+ sym = *reloc->sym_ptr_ptr;
+
+ in.r_vaddr = (reloc->address
+ + bfd_get_section_vma (abfd, current));
+ in.r_type = reloc->howto->type;
+
+ if ((sym->flags & BSF_SECTION_SYM) == 0)
+ {
+ in.r_symndx = ecoff_get_sym_index (*reloc->sym_ptr_ptr);
+ in.r_extern = 1;
+ }
else
- abort ();
- in.r_extern = 0;
+ {
+ CONST char *name;
+
+ name = bfd_get_section_name (abfd, bfd_get_section (sym));
+ if (strcmp (name, ".text") == 0)
+ in.r_symndx = RELOC_SECTION_TEXT;
+ else if (strcmp (name, ".rdata") == 0)
+ in.r_symndx = RELOC_SECTION_RDATA;
+ else if (strcmp (name, ".data") == 0)
+ in.r_symndx = RELOC_SECTION_DATA;
+ else if (strcmp (name, ".sdata") == 0)
+ in.r_symndx = RELOC_SECTION_SDATA;
+ else if (strcmp (name, ".sbss") == 0)
+ in.r_symndx = RELOC_SECTION_SBSS;
+ else if (strcmp (name, ".bss") == 0)
+ in.r_symndx = RELOC_SECTION_BSS;
+ else if (strcmp (name, ".init") == 0)
+ in.r_symndx = RELOC_SECTION_INIT;
+ else if (strcmp (name, ".lit8") == 0)
+ in.r_symndx = RELOC_SECTION_LIT8;
+ else if (strcmp (name, ".lit4") == 0)
+ in.r_symndx = RELOC_SECTION_LIT4;
+ else if (strcmp (name, ".xdata") == 0)
+ in.r_symndx = RELOC_SECTION_XDATA;
+ else if (strcmp (name, ".pdata") == 0)
+ in.r_symndx = RELOC_SECTION_PDATA;
+ else if (strcmp (name, ".fini") == 0)
+ in.r_symndx = RELOC_SECTION_FINI;
+ else if (strcmp (name, ".lita") == 0)
+ in.r_symndx = RELOC_SECTION_LITA;
+ else if (strcmp (name, "*ABS*") == 0)
+ in.r_symndx = RELOC_SECTION_ABS;
+ else
+ abort ();
+ in.r_extern = 0;
+ }
+
+ (*adjust_reloc_out) (abfd, reloc, &in);
+
+ (*swap_reloc_out) (abfd, &in, (PTR) out_ptr);
}
- (*swap_reloc_out) (abfd, &in, (PTR) out_ptr);
+ 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)
+ goto error_return;
+ bfd_release (abfd, reloc_buff);
+ reloc_buff = NULL;
}
- 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);
+ /* 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)
+ goto error_return;
+ }
}
- /* Write out the symbolic debugging information. */
- if (bfd_get_symcount (abfd) > 0)
- {
- HDRR *symhdr;
- unsigned long sym_offset;
-
- /* Set up the offsets in the symbolic header. */
- symhdr = &ecoff_data (abfd)->symbolic_header;
- sym_offset = ecoff_data (abfd)->sym_filepos + external_hdr_size;
-
-#define SET(offset, size, ptr) \
- if (symhdr->size == 0) \
- symhdr->offset = 0; \
- else \
- symhdr->offset = (((char *) ecoff_data (abfd)->ptr \
- - (char *) ecoff_data (abfd)->raw_syments) \
- + sym_offset);
-
- SET (cbLineOffset, cbLine, line);
- SET (cbDnOffset, idnMax, external_dnr);
- SET (cbPdOffset, ipdMax, external_pdr);
- SET (cbSymOffset, isymMax, external_sym);
- SET (cbOptOffset, ioptMax, external_opt);
- SET (cbAuxOffset, iauxMax, external_aux);
- SET (cbSsOffset, issMax, ss);
- SET (cbSsExtOffset, issExtMax, ssext);
- SET (cbFdOffset, ifdMax, external_fdr);
- SET (cbRfdOffset, crfd, external_rfd);
- SET (cbExtOffset, iextMax, external_ext);
-#undef SET
-
- if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos,
- SEEK_SET) != 0)
- return false;
- buff = (PTR) alloca (external_hdr_size);
- (*backend->swap_hdr_out) (abfd, &ecoff_data (abfd)->symbolic_header,
- buff);
- if (bfd_write (buff, 1, external_hdr_size, abfd) != external_hdr_size)
- return false;
- if (bfd_write ((PTR) ecoff_data (abfd)->raw_syments, 1,
- ecoff_data (abfd)->raw_size, abfd)
- != ecoff_data (abfd)->raw_size)
- return false;
- }
- else if ((abfd->flags & EXEC_P) != 0
- && (abfd->flags & D_PAGED) != 0)
+ /* The .bss section of a demand paged executable must receive an
+ entire page. If there are symbols, the symbols will start on the
+ next page. If there are no symbols, we must fill out the page by
+ hand. */
+ if (bfd_get_symcount (abfd) == 0
+ && (abfd->flags & EXEC_P) != 0
+ && (abfd->flags & D_PAGED) != 0)
{
char c;
- /* A demand paged executable must occupy an even number of
- pages. */
if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos - 1,
SEEK_SET) != 0)
- return false;
+ goto error_return;
if (bfd_read (&c, 1, 1, abfd) == 0)
c = 0;
if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos - 1,
SEEK_SET) != 0)
- return false;
+ goto error_return;
if (bfd_write (&c, 1, 1, abfd) != 1)
- return false;
+ goto error_return;
}
+ if (reloc_buff != NULL)
+ bfd_release (abfd, reloc_buff);
+ if (buff != NULL)
+ free (buff);
return true;
+ error_return:
+ if (reloc_buff != NULL)
+ bfd_release (abfd, reloc_buff);
+ if (buff != NULL)
+ free (buff);
+ return false;
}
\f
/* Archive handling. ECOFF uses what appears to be a unique type of
- archive header (which I call an armap). The byte ordering of the
- armap and the contents are encoded in the name of the armap itself.
- At least for now, we only support archives with the same byte
- ordering in the armap and the contents.
+ archive header (armap). The byte ordering of the armap and the
+ contents are encoded in the name of the armap itself. At least for
+ now, we only support archives with the same byte ordering in the
+ armap and the contents.
The first four bytes in the armap are the number of symbol
definitions. This is always a power of two.
The symbols are hashed into the armap with a closed hashing scheme.
See the functions below for the details of the algorithm.
- We could use the hash table when looking up symbols in a library.
- This would require a new BFD target entry point to replace the
- bfd_get_next_mapent function used by the linker.
-
After the symbol definitions comes four bytes holding the size of
the string table, followed by the string table itself. */
if (i != 16)
return false;
- bfd_seek (abfd, (file_ptr) -16, SEEK_CUR);
+ if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
+ return false;
/* Irix 4.0.5F apparently can use either an ECOFF armap or a
standard COFF armap. We could move the ECOFF armap stuff into
|| ((nextname[ARMAP_OBJECT_ENDIAN_INDEX] == ARMAP_BIG_ENDIAN)
^ (abfd->xvec->byteorder_big_p != false)))
{
- bfd_error = wrong_format;
+ bfd_set_error (bfd_error_wrong_format);
return false;
}
/* Read in the armap. */
ardata = bfd_ardata (abfd);
- mapdata = snarf_ar_hdr (abfd);
+ mapdata = _bfd_snarf_ar_hdr (abfd);
if (mapdata == (struct areltdata *) NULL)
return false;
parsed_size = mapdata->parsed_size;
raw_armap = (char *) bfd_alloc (abfd, parsed_size);
if (raw_armap == (char *) NULL)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return false;
}
if (bfd_read ((PTR) raw_armap, 1, parsed_size, abfd) != parsed_size)
{
- bfd_error = malformed_archive;
+ if (bfd_get_error () != bfd_error_system_call)
+ bfd_set_error (bfd_error_malformed_archive);
bfd_release (abfd, (PTR) raw_armap);
return false;
}
+ ardata->tdata = (PTR) raw_armap;
+
count = bfd_h_get_32 (abfd, (PTR) raw_armap);
ardata->symdef_count = 0;
symdef_ptr = ((struct symdef *)
bfd_alloc (abfd,
ardata->symdef_count * sizeof (struct symdef)));
+ if (!symdef_ptr)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ return false;
+ }
+
ardata->symdefs = (carsym *) symdef_ptr;
raw_ptr = raw_armap + 4;
sprintf (hdr.ar_size, "%-10d", (int) mapsize);
hdr.ar_fmag[0] = '`';
- hdr.ar_fmag[1] = '\n';
+ hdr.ar_fmag[1] = '\012';
/* Turn all null bytes in the header into spaces. */
for (i = 0; i < sizeof (struct ar_hdr); i++)
!= sizeof (struct ar_hdr))
return false;
- bfd_h_put_32 (abfd, hashsize, temp);
- if (bfd_write (temp, 1, 4, abfd) != 4)
+ 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;
+ }
current = abfd->archive_head;
last_elt = current;
hash = srch;
}
- bfd_h_put_32 (abfd, map[i].namidx, (PTR) (hashtable + hash * 8));
- bfd_h_put_32 (abfd, firstreal, (PTR) (hashtable + hash * 8 + 4));
+ 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));
}
- if (bfd_write (hashtable, 1, symdefsize, abfd) != symdefsize)
+ if (bfd_write ((PTR) hashtable, 1, symdefsize, abfd) != symdefsize)
return false;
bfd_release (abfd, hashtable);
/* Now write the strings. */
- bfd_h_put_32 (abfd, stringsize, temp);
- if (bfd_write (temp, 1, 4, abfd) != 4)
+ bfd_h_put_32 (abfd, (bfd_vma) stringsize, temp);
+ if (bfd_write ((PTR) temp, 1, 4, abfd) != 4)
return false;
for (i = 0; i < orl_count; i++)
{
bug-compatible for DECstation ar we use a null. */
if (padit)
{
- if (bfd_write ("\0", 1, 1, abfd) != 1)
+ if (bfd_write ("", 1, 1, abfd) != 1)
return false;
}
if (bfd_read ((PTR) armag, 1, SARMAG, abfd) != SARMAG
|| strncmp (armag, ARMAG, SARMAG) != 0)
{
- bfd_error = wrong_format;
+ if (bfd_get_error () != bfd_error_system_call)
+ bfd_set_error (bfd_error_wrong_format);
return (bfd_target *) NULL;
}
if (bfd_ardata (abfd) == (struct artdata *) NULL)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return (bfd_target *) NULL;
}
bfd_ardata (abfd)->first_file_filepos = SARMAG;
+ bfd_ardata (abfd)->cache = NULL;
+ bfd_ardata (abfd)->archive_head = NULL;
+ bfd_ardata (abfd)->symdefs = NULL;
+ bfd_ardata (abfd)->extended_names = NULL;
+ bfd_ardata (abfd)->tdata = NULL;
if (ecoff_slurp_armap (abfd) == false
|| ecoff_slurp_extended_name_table (abfd) == false)
return abfd->xvec;
}
+\f
+/* ECOFF linker code. */
+
+static struct bfd_hash_entry *ecoff_link_hash_newfunc
+ PARAMS ((struct bfd_hash_entry *entry,
+ struct bfd_hash_table *table,
+ const char *string));
+static 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
+ PARAMS ((bfd *, struct bfd_link_info *));
+static boolean ecoff_link_add_externals
+ PARAMS ((bfd *, struct bfd_link_info *, PTR, char *));
+
+/* Routine to create an entry in an ECOFF link hash table. */
+
+static struct bfd_hash_entry *
+ecoff_link_hash_newfunc (entry, table, string)
+ struct bfd_hash_entry *entry;
+ struct bfd_hash_table *table;
+ const char *string;
+{
+ struct ecoff_link_hash_entry *ret = (struct ecoff_link_hash_entry *) entry;
+
+ /* Allocate the structure if it has not already been allocated by a
+ subclass. */
+ if (ret == (struct ecoff_link_hash_entry *) NULL)
+ 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;
+ }
+
+ /* Call the allocation method of the superclass. */
+ ret = ((struct ecoff_link_hash_entry *)
+ _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
+ table, string));
+
+ if (ret)
+ {
+ /* Set local fields. */
+ ret->indx = -1;
+ ret->abfd = NULL;
+ ret->written = 0;
+ ret->small = 0;
+ }
+ 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 *abfd;
+{
+ struct ecoff_link_hash_table *ret;
+
+ ret = ((struct ecoff_link_hash_table *)
+ malloc (sizeof (struct ecoff_link_hash_table)));
+ if (!ret)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ return NULL;
+ }
+ if (! _bfd_link_hash_table_init (&ret->root, abfd,
+ ecoff_link_hash_newfunc))
+ {
+ free (ret);
+ return (struct bfd_link_hash_table *) NULL;
+ }
+ return &ret->root;
+}
+
+/* Look up an entry in an ECOFF link hash table. */
+
+#define ecoff_link_hash_lookup(table, string, create, copy, follow) \
+ ((struct ecoff_link_hash_entry *) \
+ bfd_link_hash_lookup (&(table)->root, (string), (create), (copy), (follow)))
+
+/* Traverse an ECOFF link hash table. */
+
+#define ecoff_link_hash_traverse(table, func, info) \
+ (bfd_link_hash_traverse \
+ (&(table)->root, \
+ (boolean (*) PARAMS ((struct bfd_link_hash_entry *, PTR))) (func), \
+ (info)))
+
+/* Get the ECOFF link hash table from the info structure. This is
+ just a cast. */
+
+#define ecoff_hash_table(p) ((struct ecoff_link_hash_table *) ((p)->hash))
+
+/* Given an ECOFF BFD, add symbols to the global hash table as
+ appropriate. */
+
+boolean
+ecoff_bfd_link_add_symbols (abfd, info)
+ bfd *abfd;
+ struct bfd_link_info *info;
+{
+ switch (bfd_get_format (abfd))
+ {
+ case bfd_object:
+ return ecoff_link_add_object_symbols (abfd, info);
+ case bfd_archive:
+ return ecoff_link_add_archive_symbols (abfd, info);
+ default:
+ bfd_set_error (bfd_error_wrong_format);
+ return false;
+ }
+}
+
+/* Add the symbols from an archive file to the global hash table.
+ This looks through the undefined symbols, looks each one up in the
+ archive hash table, and adds any associated object file. We do not
+ use _bfd_generic_link_add_archive_symbols because ECOFF archives
+ already have a hash table, so there is no reason to construct
+ another one. */
+
+static boolean
+ecoff_link_add_archive_symbols (abfd, info)
+ bfd *abfd;
+ struct bfd_link_info *info;
+{
+ const bfd_byte *raw_armap;
+ struct bfd_link_hash_entry **pundef;
+ unsigned int armap_count;
+ unsigned int armap_log;
+ unsigned int i;
+ const bfd_byte *hashtable;
+ const char *stringbase;
+
+ if (! bfd_has_map (abfd))
+ {
+ bfd_set_error (bfd_error_no_symbols);
+ return false;
+ }
+
+ /* If we don't have any raw data for this archive, as can happen on
+ Irix 4.0.5F, we call the generic routine.
+ FIXME: We should be more clever about this, since someday tdata
+ may get to something for a generic archive. */
+ raw_armap = (const bfd_byte *) bfd_ardata (abfd)->tdata;
+ if (raw_armap == (bfd_byte *) NULL)
+ return (_bfd_generic_link_add_archive_symbols
+ (abfd, info, ecoff_link_check_archive_element));
+
+ armap_count = bfd_h_get_32 (abfd, raw_armap);
+
+ armap_log = 0;
+ for (i = 1; i < armap_count; i <<= 1)
+ armap_log++;
+ BFD_ASSERT (i == armap_count);
+
+ hashtable = raw_armap + 4;
+ stringbase = (const char *) raw_armap + armap_count * 8 + 8;
+
+ /* Look through the list of undefined symbols. */
+ pundef = &info->hash->undefs;
+ while (*pundef != (struct bfd_link_hash_entry *) NULL)
+ {
+ struct bfd_link_hash_entry *h;
+ unsigned int hash, rehash;
+ unsigned int file_offset;
+ const char *name;
+ bfd *element;
+
+ h = *pundef;
+
+ /* When a symbol is defined, it is not necessarily removed from
+ the list. */
+ if (h->type != bfd_link_hash_undefined
+ && h->type != bfd_link_hash_common)
+ {
+ /* Remove this entry from the list, for general cleanliness
+ and because we are going to look through the list again
+ if we search any more libraries. We can't remove the
+ entry if it is the tail, because that would lose any
+ entries we add to the list later on. */
+ if (*pundef != info->hash->undefs_tail)
+ *pundef = (*pundef)->next;
+ else
+ pundef = &(*pundef)->next;
+ continue;
+ }
+
+ /* Native ECOFF linkers do not pull in archive elements merely
+ to satisfy common definitions, so neither do we. We leave
+ them on the list, though, in case we are linking against some
+ other object format. */
+ if (h->type != bfd_link_hash_undefined)
+ {
+ pundef = &(*pundef)->next;
+ continue;
+ }
+
+ /* Look for this symbol in the archive hash table. */
+ hash = ecoff_armap_hash (h->root.string, &rehash, armap_count,
+ armap_log);
+
+ file_offset = bfd_h_get_32 (abfd, hashtable + (hash * 8) + 4);
+ if (file_offset == 0)
+ {
+ /* Nothing in this slot. */
+ pundef = &(*pundef)->next;
+ continue;
+ }
+
+ name = stringbase + bfd_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;
+
+ /* That was the wrong symbol. Try rehashing. */
+ found = false;
+ for (srch = (hash + rehash) & (armap_count - 1);
+ srch != hash;
+ srch = (srch + rehash) & (armap_count - 1))
+ {
+ file_offset = bfd_h_get_32 (abfd, hashtable + (srch * 8) + 4);
+ if (file_offset == 0)
+ break;
+ name = stringbase + bfd_h_get_32 (abfd, hashtable + (srch * 8));
+ if (name[0] == h->root.string[0]
+ && strcmp (name, h->root.string) == 0)
+ {
+ found = true;
+ break;
+ }
+ }
+
+ if (! found)
+ {
+ pundef = &(*pundef)->next;
+ continue;
+ }
+
+ hash = srch;
+ }
+
+ element = _bfd_get_elt_at_filepos (abfd, file_offset);
+ if (element == (bfd *) NULL)
+ return false;
+
+ if (! bfd_check_format (element, bfd_object))
+ return false;
+
+ /* Unlike the generic linker, we know that this element provides
+ a definition for an undefined symbol and we know that we want
+ to include it. We don't need to check anything. */
+ if (! (*info->callbacks->add_archive_element) (info, element, name))
+ return false;
+ if (! ecoff_link_add_object_symbols (element, info))
+ return false;
+
+ pundef = &(*pundef)->next;
+ }
+
+ return true;
+}
+
+/* This is called if we used _bfd_generic_link_add_archive_symbols
+ because we were not dealing with an ECOFF archive. */
+
+static boolean
+ecoff_link_check_archive_element (abfd, info, pneeded)
+ bfd *abfd;
+ struct bfd_link_info *info;
+ boolean *pneeded;
+{
+ const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
+ void (* const swap_ext_in) PARAMS ((bfd *, PTR, EXTR *))
+ = backend->debug_swap.swap_ext_in;
+ HDRR *symhdr;
+ bfd_size_type external_ext_size;
+ PTR external_ext = NULL;
+ size_t esize;
+ char *ssext = NULL;
+ char *ext_ptr;
+ char *ext_end;
+
+ *pneeded = false;
+
+ if (! ecoff_slurp_symbolic_header (abfd))
+ goto error_return;
+
+ /* If there are no symbols, we don't want it. */
+ if (bfd_get_symcount (abfd) == 0)
+ goto successful_return;
+
+ symhdr = &ecoff_data (abfd)->debug_info.symbolic_header;
+
+ /* Read in the external symbols and external strings. */
+ external_ext_size = backend->debug_swap.external_ext_size;
+ esize = symhdr->iextMax * external_ext_size;
+ external_ext = (PTR) malloc (esize);
+ if (external_ext == NULL && esize != 0)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ goto error_return;
+ }
+
+ if (bfd_seek (abfd, symhdr->cbExtOffset, SEEK_SET) != 0
+ || bfd_read (external_ext, 1, esize, abfd) != esize)
+ goto error_return;
+
+ ssext = (char *) malloc (symhdr->issExtMax);
+ if (ssext == NULL && symhdr->issExtMax != 0)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ goto error_return;
+ }
+
+ if (bfd_seek (abfd, symhdr->cbSsExtOffset, SEEK_SET) != 0
+ || bfd_read (ssext, 1, symhdr->issExtMax, abfd) != symhdr->issExtMax)
+ goto error_return;
+
+ /* Look through the external symbols to see if they define some
+ symbol that is currently undefined. */
+ ext_ptr = (char *) external_ext;
+ ext_end = ext_ptr + esize;
+ for (; ext_ptr < ext_end; ext_ptr += external_ext_size)
+ {
+ EXTR esym;
+ boolean def;
+ const char *name;
+ struct bfd_link_hash_entry *h;
+
+ (*swap_ext_in) (abfd, (PTR) ext_ptr, &esym);
+
+ /* See if this symbol defines something. */
+ if (esym.asym.st != stGlobal
+ && esym.asym.st != stLabel
+ && esym.asym.st != stProc)
+ continue;
+
+ switch (esym.asym.sc)
+ {
+ case scText:
+ case scData:
+ case scBss:
+ case scAbs:
+ case scSData:
+ case scSBss:
+ case scRData:
+ case scCommon:
+ case scSCommon:
+ case scInit:
+ case scFini:
+ def = true;
+ break;
+ default:
+ def = false;
+ break;
+ }
+
+ if (! def)
+ continue;
+
+ name = ssext + esym.asym.iss;
+ h = bfd_link_hash_lookup (info->hash, name, false, false, true);
+
+ /* Unlike the generic linker, we do not pull in elements because
+ of common symbols. */
+ if (h == (struct bfd_link_hash_entry *) NULL
+ || h->type != bfd_link_hash_undefined)
+ continue;
+
+ /* Include this element. */
+ if (! (*info->callbacks->add_archive_element) (info, abfd, name))
+ goto error_return;
+ if (! ecoff_link_add_externals (abfd, info, external_ext, ssext))
+ goto error_return;
+
+ *pneeded = true;
+ goto successful_return;
+ }
+
+ successful_return:
+ if (external_ext != NULL)
+ free (external_ext);
+ if (ssext != NULL)
+ free (ssext);
+ return true;
+ error_return:
+ if (external_ext != NULL)
+ free (external_ext);
+ if (ssext != NULL)
+ free (ssext);
+ return false;
+}
+
+/* Add symbols from an ECOFF object file to the global linker hash
+ table. */
+
+static 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 = NULL;
+ size_t esize;
+ char *ssext = NULL;
+ boolean result;
+
+ if (! ecoff_slurp_symbolic_header (abfd))
+ return false;
+
+ /* If there are no symbols, we don't want it. */
+ if (bfd_get_symcount (abfd) == 0)
+ 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) malloc (esize);
+ if (external_ext == NULL && esize != 0)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ goto error_return;
+ }
+
+ if (bfd_seek (abfd, symhdr->cbExtOffset, SEEK_SET) != 0
+ || bfd_read (external_ext, 1, esize, abfd) != esize)
+ goto error_return;
+
+ ssext = (char *) malloc (symhdr->issExtMax);
+ if (ssext == NULL && symhdr->issExtMax != 0)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ goto error_return;
+ }
+
+ if (bfd_seek (abfd, symhdr->cbSsExtOffset, SEEK_SET) != 0
+ || bfd_read (ssext, 1, symhdr->issExtMax, abfd) != 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
+ hash table. The external symbols and strings we are passed are
+ just allocated on the stack, and will be discarded. We must
+ explicitly save any information we may need later on in the link.
+ We do not want to read the external symbol information again. */
+
+static boolean
+ecoff_link_add_externals (abfd, info, external_ext, ssext)
+ bfd *abfd;
+ struct bfd_link_info *info;
+ PTR external_ext;
+ char *ssext;
+{
+ const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
+ void (* const swap_ext_in) PARAMS ((bfd *, PTR, EXTR *))
+ = backend->debug_swap.swap_ext_in;
+ bfd_size_type external_ext_size = backend->debug_swap.external_ext_size;
+ unsigned long ext_count;
+ struct ecoff_link_hash_entry **sym_hash;
+ char *ext_ptr;
+ char *ext_end;
+
+ 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 *)));
+ if (!sym_hash)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ return false;
+ }
+ ecoff_data (abfd)->sym_hashes = 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_vma value;
+ asection *section;
+ const char *name;
+ struct ecoff_link_hash_entry *h;
+
+ *sym_hash = NULL;
+
+ (*swap_ext_in) (abfd, (PTR) ext_ptr, &esym);
+
+ /* Skip debugging symbols. */
+ skip = false;
+ switch (esym.asym.st)
+ {
+ case stGlobal:
+ case stStatic:
+ case stLabel:
+ case stProc:
+ case stStaticProc:
+ break;
+ default:
+ skip = true;
+ break;
+ }
+
+ if (skip)
+ continue;
+
+ /* Get the information for this symbol. */
+ value = esym.asym.value;
+ switch (esym.asym.sc)
+ {
+ default:
+ case scNil:
+ case scRegister:
+ case scCdbLocal:
+ case scBits:
+ case scCdbSystem:
+ case scRegImage:
+ case scInfo:
+ case scUserStruct:
+ case scVar:
+ case scVarRegister:
+ case scVariant:
+ case scBasedVar:
+ case scXData:
+ case scPData:
+ section = NULL;
+ break;
+ case scText:
+ section = bfd_make_section_old_way (abfd, ".text");
+ value -= section->vma;
+ break;
+ case scData:
+ section = bfd_make_section_old_way (abfd, ".data");
+ value -= section->vma;
+ break;
+ case scBss:
+ section = bfd_make_section_old_way (abfd, ".bss");
+ value -= section->vma;
+ break;
+ case scAbs:
+ section = &bfd_abs_section;
+ break;
+ case scUndefined:
+ section = &bfd_und_section;
+ break;
+ case scSData:
+ section = bfd_make_section_old_way (abfd, ".sdata");
+ value -= section->vma;
+ break;
+ case scSBss:
+ section = bfd_make_section_old_way (abfd, ".sbss");
+ value -= section->vma;
+ break;
+ case scRData:
+ section = bfd_make_section_old_way (abfd, ".rdata");
+ value -= section->vma;
+ break;
+ case scCommon:
+ if (value > ecoff_data (abfd)->gp_size)
+ {
+ section = &bfd_com_section;
+ break;
+ }
+ /* Fall through. */
+ case scSCommon:
+ if (ecoff_scom_section.name == NULL)
+ {
+ /* Initialize the small common section. */
+ ecoff_scom_section.name = SCOMMON;
+ ecoff_scom_section.flags = SEC_IS_COMMON;
+ ecoff_scom_section.output_section = &ecoff_scom_section;
+ ecoff_scom_section.symbol = &ecoff_scom_symbol;
+ ecoff_scom_section.symbol_ptr_ptr = &ecoff_scom_symbol_ptr;
+ ecoff_scom_symbol.name = SCOMMON;
+ ecoff_scom_symbol.flags = BSF_SECTION_SYM;
+ ecoff_scom_symbol.section = &ecoff_scom_section;
+ ecoff_scom_symbol_ptr = &ecoff_scom_symbol;
+ }
+ section = &ecoff_scom_section;
+ break;
+ case scSUndefined:
+ section = &bfd_und_section;
+ break;
+ case scInit:
+ section = bfd_make_section_old_way (abfd, ".init");
+ value -= section->vma;
+ break;
+ case scFini:
+ section = bfd_make_section_old_way (abfd, ".fini");
+ value -= section->vma;
+ break;
+ }
+
+ if (section == (asection *) NULL)
+ continue;
+
+ name = ssext + esym.asym.iss;
+
+ h = NULL;
+ if (! (_bfd_generic_link_add_one_symbol
+ (info, abfd, name, BSF_GLOBAL, section, value,
+ (const char *) NULL, true, true,
+ (struct bfd_link_hash_entry **) &h)))
+ return false;
+
+ *sym_hash = h;
+
+ /* 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_com_section (section)
+ || h->root.type != bfd_link_hash_defined)))
+ {
+ 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.section->name, SCOMMON) != 0)
+ {
+ h->root.u.c.section = bfd_make_section_old_way (abfd, SCOMMON);
+ h->root.u.c.section->flags = SEC_ALLOC;
+ if (h->esym.asym.sc == scCommon)
+ h->esym.asym.sc = scSCommon;
+ }
+ }
+ }
+
+ return true;
+}
+\f
+/* ECOFF final link routines. */
+
+static 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
+ PARAMS ((struct ecoff_link_hash_entry *, PTR));
+static boolean ecoff_indirect_link_order
+ PARAMS ((bfd *, struct bfd_link_info *, asection *,
+ struct bfd_link_order *));
+static boolean ecoff_reloc_link_order
+ PARAMS ((bfd *, struct bfd_link_info *, asection *,
+ struct bfd_link_order *));
+
+/* 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 *abfd;
+ struct bfd_link_info *info;
+{
+ const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
+ struct ecoff_debug_info * const debug = &ecoff_data (abfd)->debug_info;
+ HDRR *symhdr;
+ PTR handle;
+ register bfd *input_bfd;
+ asection *o;
+ struct bfd_link_order *p;
+
+ /* We accumulate the debugging information counts in the symbolic
+ header. */
+ symhdr = &debug->symbolic_header;
+ symhdr->vstamp = 0;
+ symhdr->ilineMax = 0;
+ symhdr->cbLine = 0;
+ symhdr->idnMax = 0;
+ symhdr->ipdMax = 0;
+ symhdr->isymMax = 0;
+ symhdr->ioptMax = 0;
+ symhdr->iauxMax = 0;
+ symhdr->issMax = 0;
+ symhdr->issExtMax = 0;
+ symhdr->ifdMax = 0;
+ symhdr->crfd = 0;
+ symhdr->iextMax = 0;
+
+ /* We accumulate the debugging information itself in the debug_info
+ structure. */
+ debug->line = NULL;
+ debug->external_dnr = NULL;
+ debug->external_pdr = NULL;
+ debug->external_sym = NULL;
+ debug->external_opt = NULL;
+ debug->external_aux = NULL;
+ debug->ss = NULL;
+ debug->ssext = debug->ssext_end = NULL;
+ debug->external_fdr = NULL;
+ debug->external_rfd = NULL;
+ debug->external_ext = debug->external_ext_end = NULL;
+
+ handle = bfd_ecoff_debug_init (abfd, debug, &backend->debug_swap, info);
+ if (handle == (PTR) NULL)
+ 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 (bfd_get_flavour (input_bfd) == bfd_target_ecoff_flavour)
+ {
+ /* Abitrarily set the symbolic header vstamp to the vstamp
+ of the first object file in the link. */
+ if (symhdr->vstamp == 0)
+ symhdr->vstamp
+ = ecoff_data (input_bfd)->debug_info.symbolic_header.vstamp;
+ ret = ecoff_final_link_debug_accumulate (abfd, input_bfd, info,
+ handle);
+ }
+ else
+ ret = bfd_ecoff_debug_accumulate_other (handle, abfd,
+ debug, &backend->debug_swap,
+ input_bfd, info);
+ if (! ret)
+ return false;
+
+ /* Combine the register masks. */
+ ecoff_data (abfd)->gprmask |= ecoff_data (input_bfd)->gprmask;
+ ecoff_data (abfd)->fprmask |= ecoff_data (input_bfd)->fprmask;
+ ecoff_data (abfd)->cprmask[0] |= ecoff_data (input_bfd)->cprmask[0];
+ ecoff_data (abfd)->cprmask[1] |= ecoff_data (input_bfd)->cprmask[1];
+ ecoff_data (abfd)->cprmask[2] |= ecoff_data (input_bfd)->cprmask[2];
+ ecoff_data (abfd)->cprmask[3] |= ecoff_data (input_bfd)->cprmask[3];
+ }
+
+ /* Write out the external symbols. */
+ ecoff_link_hash_traverse (ecoff_hash_table (info),
+ ecoff_link_write_external,
+ (PTR) abfd);
+
+ if (info->relocateable)
+ {
+ /* We need to make a pass over the link_orders to count up the
+ number of relocations we will need to output, so that we know
+ how much space they will take up. */
+ for (o = abfd->sections; o != (asection *) NULL; o = o->next)
+ {
+ o->reloc_count = 0;
+ for (p = o->link_order_head;
+ p != (struct bfd_link_order *) NULL;
+ p = p->next)
+ if (p->type == bfd_indirect_link_order)
+ o->reloc_count += p->u.indirect.section->reloc_count;
+ else if (p->type == bfd_section_reloc_link_order
+ || p->type == bfd_symbol_reloc_link_order)
+ ++o->reloc_count;
+ }
+ }
+
+ /* Compute the reloc and symbol file positions. */
+ ecoff_compute_reloc_file_positions (abfd);
+
+ /* Write out the debugging information. */
+ if (! bfd_ecoff_write_accumulated_debug (handle, abfd, debug,
+ &backend->debug_swap, info,
+ ecoff_data (abfd)->sym_filepos))
+ return false;
+
+ bfd_ecoff_debug_free (handle, abfd, debug, &backend->debug_swap, info);
+
+ if (info->relocateable)
+ {
+ /* Now reset the reloc_count field of the sections in the output
+ BFD to 0, so that we can use them to keep track of how many
+ relocs we have output thus far. */
+ for (o = abfd->sections; o != (asection *) NULL; o = o->next)
+ o->reloc_count = 0;
+ }
+
+ /* Get a value for the GP register. */
+ if (ecoff_data (abfd)->gp == 0)
+ {
+ struct bfd_link_hash_entry *h;
+
+ h = bfd_link_hash_lookup (info->hash, "_gp", false, false, true);
+ if (h != (struct bfd_link_hash_entry *) NULL
+ && h->type == bfd_link_hash_defined)
+ ecoff_data (abfd)->gp = (h->u.def.value
+ + h->u.def.section->output_section->vma
+ + h->u.def.section->output_offset);
+ else if (info->relocateable)
+ {
+ bfd_vma lo;
+
+ /* Make up a value. */
+ lo = (bfd_vma) -1;
+ for (o = abfd->sections; o != (asection *) NULL; o = o->next)
+ {
+ if (o->vma < lo
+ && (strcmp (o->name, _SBSS) == 0
+ || strcmp (o->name, _SDATA) == 0
+ || strcmp (o->name, _LIT4) == 0
+ || strcmp (o->name, _LIT8) == 0
+ || strcmp (o->name, _LITA) == 0))
+ lo = o->vma;
+ }
+ ecoff_data (abfd)->gp = lo + 0x8000;
+ }
+ else
+ {
+ /* If the relocate_section function needs to do a reloc
+ involving the GP value, it should make a reloc_dangerous
+ callback to warn that GP is not defined. */
+ }
+ }
+
+ for (o = abfd->sections; o != (asection *) NULL; o = o->next)
+ {
+ for (p = o->link_order_head;
+ p != (struct bfd_link_order *) NULL;
+ p = p->next)
+ {
+ if (p->type == bfd_indirect_link_order
+ && (bfd_get_flavour (p->u.indirect.section->owner)
+ == bfd_target_ecoff_flavour))
+ {
+ if (! ecoff_indirect_link_order (abfd, info, o, p))
+ return false;
+ }
+ else if (p->type == bfd_section_reloc_link_order
+ || p->type == bfd_symbol_reloc_link_order)
+ {
+ if (! ecoff_reloc_link_order (abfd, info, o, p))
+ return false;
+ }
+ else
+ {
+ if (! _bfd_default_link_order (abfd, info, o, p))
+ return false;
+ }
+ }
+ }
+
+ bfd_get_symcount (abfd) = symhdr->iextMax + symhdr->isymMax;
+
+ 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
+ecoff_final_link_debug_accumulate (output_bfd, input_bfd, info, handle)
+ bfd *output_bfd;
+ bfd *input_bfd;
+ struct bfd_link_info *info;
+ PTR handle;
+{
+ struct ecoff_debug_info * const debug = &ecoff_data (input_bfd)->debug_info;
+ const struct ecoff_debug_swap * const swap =
+ &ecoff_backend (input_bfd)->debug_swap;
+ HDRR *symhdr = &debug->symbolic_header;
+ boolean ret;
+
+#define READ(ptr, offset, count, size, type) \
+ if (symhdr->count == 0) \
+ debug->ptr = NULL; \
+ else \
+ { \
+ debug->ptr = (type) malloc (size * symhdr->count); \
+ if (debug->ptr == NULL) \
+ { \
+ bfd_set_error (bfd_error_no_memory); \
+ 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; \
+ } \
+ }
+
+ /* If raw_syments is not NULL, then the data was already by read by
+ 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. */
+
+ ret = (bfd_ecoff_debug_accumulate
+ (handle, output_bfd, &ecoff_data (output_bfd)->debug_info,
+ &ecoff_backend (output_bfd)->debug_swap,
+ input_bfd, debug, swap, info));
+
+ return_something:
+ if (ecoff_data (input_bfd)->raw_syments == NULL)
+ {
+ if (debug->line != NULL)
+ free (debug->line);
+ if (debug->external_dnr != NULL)
+ free (debug->external_dnr);
+ if (debug->external_pdr != NULL)
+ free (debug->external_pdr);
+ if (debug->external_sym != NULL)
+ free (debug->external_sym);
+ if (debug->external_opt != NULL)
+ free (debug->external_opt);
+ if (debug->external_aux != NULL)
+ free (debug->external_aux);
+ if (debug->ss != NULL)
+ free (debug->ss);
+ if (debug->external_fdr != NULL)
+ free (debug->external_fdr);
+ if (debug->external_rfd != NULL)
+ free (debug->external_rfd);
+
+ /* 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
+ecoff_link_write_external (h, data)
+ struct ecoff_link_hash_entry *h;
+ PTR data;
+{
+ bfd *output_bfd = (bfd *) data;
+
+ /* FIXME: We should check if this symbol is being stripped. */
+
+ if (h->written)
+ return true;
+
+ if (h->abfd == (bfd *) NULL)
+ {
+ h->esym.jmptbl = 0;
+ h->esym.cobol_main = 0;
+ h->esym.weakext = 0;
+ h->esym.reserved = 0;
+ h->esym.ifd = ifdNil;
+ h->esym.asym.value = 0;
+ h->esym.asym.st = stGlobal;
+
+ if (h->root.type != bfd_link_hash_defined)
+ 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
+ h->esym.asym.sc = scAbs;
+ }
+
+ h->esym.asym.reserved = 0;
+ h->esym.asym.index = indexNil;
+ }
+ else if (h->esym.ifd != -1)
+ {
+ struct ecoff_debug_info *debug;
+
+ /* Adjust the FDR index for the symbol by that used for the
+ input BFD. */
+ debug = &ecoff_data (h->abfd)->debug_info;
+ BFD_ASSERT (h->esym.ifd >= 0
+ && h->esym.ifd < debug->symbolic_header.ifdMax);
+ h->esym.ifd = debug->ifdmap[h->esym.ifd];
+ }
+
+ switch (h->root.type)
+ {
+ default:
+ case bfd_link_hash_new:
+ abort ();
+ case bfd_link_hash_undefined:
+ case bfd_link_hash_weak:
+ if (h->esym.asym.sc != scUndefined
+ && h->esym.asym.sc != scSUndefined)
+ h->esym.asym.sc = scUndefined;
+ break;
+ case bfd_link_hash_defined:
+ if (h->esym.asym.sc == scUndefined
+ || h->esym.asym.sc == scSUndefined)
+ h->esym.asym.sc = scAbs;
+ else if (h->esym.asym.sc == scCommon)
+ h->esym.asym.sc = scBss;
+ else if (h->esym.asym.sc == scSCommon)
+ h->esym.asym.sc = scSBss;
+ h->esym.asym.value = (h->root.u.def.value
+ + h->root.u.def.section->output_section->vma
+ + h->root.u.def.section->output_offset);
+ break;
+ case bfd_link_hash_common:
+ if (h->esym.asym.sc != scCommon
+ && h->esym.asym.sc != scSCommon)
+ h->esym.asym.sc = scCommon;
+ 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;
+ }
+
+ /* 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->written = 1;
+
+ return (bfd_ecoff_debug_one_external
+ (output_bfd, &ecoff_data (output_bfd)->debug_info,
+ &ecoff_backend (output_bfd)->debug_swap, h->root.root.string,
+ &h->esym));
+}
+
+/* Relocate and write an ECOFF section into an ECOFF output file. */
+
+static boolean
+ecoff_indirect_link_order (output_bfd, info, output_section, link_order)
+ bfd *output_bfd;
+ struct bfd_link_info *info;
+ asection *output_section;
+ struct bfd_link_order *link_order;
+{
+ asection *input_section;
+ bfd *input_bfd;
+ 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 = NULL;
+
+ BFD_ASSERT ((output_section->flags & SEC_HAS_CONTENTS) != 0);
+
+ if (link_order->size == 0)
+ return true;
+
+ input_section = link_order->u.indirect.section;
+ input_bfd = input_section->owner;
+ 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 (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. */
+ contents = (bfd_byte *) malloc (raw_size >= cooked_size
+ ? raw_size
+ : cooked_size);
+ if (contents == NULL && raw_size != 0)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ 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, 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. 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;
+
+ if (section_tdata != (struct ecoff_section_tdata *) NULL)
+ external_relocs = section_tdata->external_relocs;
+ else
+ {
+ external_relocs = (PTR) malloc (external_relocs_size);
+ if (external_relocs == NULL && external_relocs_size != 0)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ 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)
+ != 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)))
+ goto error_return;
+
+ /* Write out the relocated section. */
+ if (! bfd_set_section_contents (output_bfd,
+ output_section,
+ (PTR) contents,
+ 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
+ field of output_section to keep track of the number of relocs we
+ 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)
+ != external_relocs_size))
+ goto error_return;
+ output_section->reloc_count += input_section->reloc_count;
+ }
+
+ if (contents != NULL)
+ free (contents);
+ if (external_relocs != NULL && section_tdata == NULL)
+ free (external_relocs);
+ return true;
+
+ error_return:
+ if (contents != NULL)
+ free (contents);
+ if (external_relocs != NULL && section_tdata == NULL)
+ free (external_relocs);
+ return false;
+}
+
+/* Generate a reloc when linking an ECOFF file. This is a reloc
+ requested by the linker, and does come from any input file. This
+ is used to build constructor and destructor tables when linking
+ with -Ur. */
+
+static boolean
+ecoff_reloc_link_order (output_bfd, info, output_section, link_order)
+ bfd *output_bfd;
+ struct bfd_link_info *info;
+ asection *output_section;
+ struct bfd_link_order *link_order;
+{
+ arelent rel;
+ struct internal_reloc in;
+ bfd_size_type external_reloc_size;
+ bfd_byte *rbuf;
+ boolean ok;
+
+ /* 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 == (const reloc_howto_type *) NULL)
+ {
+ bfd_set_error (bfd_error_bad_value);
+ return false;
+ }
+
+ if (link_order->type == bfd_section_reloc_link_order)
+ rel.sym_ptr_ptr = link_order->u.reloc.p->u.section->symbol_ptr_ptr;
+ else
+ {
+ /* We can't set up a reloc against a symbol correctly, because
+ we have no asymbol structure. Currently no adjust_reloc_out
+ routine cases. */
+ 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 (link_order->u.reloc.p->addend != 0)
+ {
+ 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)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ return false;
+ }
+ rstat = _bfd_relocate_contents (rel.howto, output_bfd,
+ link_order->u.reloc.p->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,
+ link_order->u.reloc.p->u.section)
+ : link_order->u.reloc.p->u.name),
+ rel.howto->name, link_order->u.reloc.p->addend,
+ (bfd *) NULL, (asection *) NULL, (bfd_vma) 0)))
+ {
+ free (buf);
+ return false;
+ }
+ break;
+ }
+ ok = bfd_set_section_contents (output_bfd, output_section, (PTR) buf,
+ (file_ptr) link_order->offset, size);
+ free (buf);
+ if (! ok)
+ return false;
+ }
+
+ rel.addend = 0;
+
+ /* Move the information into a internal_reloc structure. */
+ in.r_vaddr = (rel.address
+ + bfd_get_section_vma (output_bfd, output_section));
+ in.r_type = rel.howto->type;
+
+ if (link_order->type == bfd_symbol_reloc_link_order)
+ {
+ struct ecoff_link_hash_entry *h;
+
+ h = ecoff_link_hash_lookup (ecoff_hash_table (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,
+ link_order->u.reloc.p->u.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
+ 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 *) malloc (external_reloc_size);
+ if (rbuf == (bfd_byte *) NULL)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ 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)
+ == external_reloc_size));
+
+ if (ok)
+ ++output_section->reloc_count;
+
+ free (rbuf);
+
+ return ok;
+}
projects / binutils-gdb.git / blobdiff