New file to hold ECOFF linking routines used by both ECOFF and MIPS ELF.
This commit is contained in:
Ian Lance Taylor
parent
5b0ba16d41
commit
71efdf833f
|
|
@ -100,6 +100,7 @@ demo64.c
|
|||
dep-in.sed
|
||||
doc
|
||||
ecoff.c
|
||||
ecofflink.c
|
||||
ecoffswap.h
|
||||
elf.c
|
||||
elf32-gen.c
|
||||
|
|
|
|||
|
|
@ -0,0 +1,829 @@
|
|||
/* Routines to link ECOFF debugging information.
|
||||
Copyright 1993 Free Software Foundation, Inc.
|
||||
Written by Ian Lance Taylor, Cygnus Support, <ian@cygnus.com>.
|
||||
|
||||
This file is part of BFD, the Binary File Descriptor library.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
||||
|
||||
#include "bfd.h"
|
||||
#include "sysdep.h"
|
||||
#include "libbfd.h"
|
||||
#include "coff/internal.h"
|
||||
#include "coff/sym.h"
|
||||
#include "coff/symconst.h"
|
||||
#include "coff/ecoff.h"
|
||||
|
||||
static boolean ecoff_add_bytes PARAMS ((char **buf, char **bufend,
|
||||
bfd_size_type need));
|
||||
static bfd_size_type ecoff_add_string PARAMS ((struct ecoff_debug_info *,
|
||||
FDR *fdr, const char *string));
|
||||
static void ecoff_align_debug PARAMS ((bfd *abfd,
|
||||
struct ecoff_debug_info *debug,
|
||||
const struct ecoff_debug_swap *swap));
|
||||
|
||||
/* The minimum amount of data to allocate. */
|
||||
#define ALLOC_SIZE (4064)
|
||||
|
||||
/* Add bytes to a buffer. Return success. */
|
||||
|
||||
static boolean
|
||||
ecoff_add_bytes (buf, bufend, need)
|
||||
char **buf;
|
||||
char **bufend;
|
||||
bfd_size_type need;
|
||||
{
|
||||
bfd_size_type have;
|
||||
bfd_size_type want;
|
||||
char *newbuf;
|
||||
|
||||
have = *bufend - *buf;
|
||||
if (have > need)
|
||||
want = ALLOC_SIZE;
|
||||
else
|
||||
{
|
||||
want = need - have;
|
||||
if (want < ALLOC_SIZE)
|
||||
want = ALLOC_SIZE;
|
||||
}
|
||||
if (*buf == NULL)
|
||||
newbuf = (char *) malloc (have + want);
|
||||
else
|
||||
newbuf = (char *) realloc (*buf, have + want);
|
||||
if (newbuf == NULL)
|
||||
{
|
||||
bfd_error = no_memory;
|
||||
return false;
|
||||
}
|
||||
*buf = newbuf;
|
||||
*bufend = *buf + have + want;
|
||||
return true;
|
||||
}
|
||||
|
||||
/* Accumulate the debugging information from INPUT_BFD into
|
||||
OUTPUT_BFD. The INPUT_DEBUG argument points to some ECOFF
|
||||
debugging information which we want to link into the information
|
||||
pointed to by the OUTPUT_DEBUG argument. OUTPUT_SWAP and
|
||||
INPUT_SWAP point to the swapping information needed. */
|
||||
|
||||
boolean
|
||||
bfd_ecoff_debug_accumulate (output_bfd, output_debug, output_swap,
|
||||
input_bfd, input_debug, input_swap,
|
||||
relocateable)
|
||||
bfd *output_bfd;
|
||||
struct ecoff_debug_info *output_debug;
|
||||
const struct ecoff_debug_swap *output_swap;
|
||||
bfd *input_bfd;
|
||||
struct ecoff_debug_info *input_debug;
|
||||
const struct ecoff_debug_swap *input_swap;
|
||||
boolean relocateable;
|
||||
{
|
||||
void (* const swap_sym_in) PARAMS ((bfd *, PTR, SYMR *))
|
||||
= input_swap->swap_sym_in;
|
||||
void (* const swap_sym_out) PARAMS ((bfd *, const SYMR *, PTR))
|
||||
= output_swap->swap_sym_out;
|
||||
void (* const swap_fdr_out) PARAMS ((bfd *, const FDR *, PTR))
|
||||
= output_swap->swap_fdr_out;
|
||||
void (* const swap_rfd_out) PARAMS ((bfd *, const RFDT *, PTR))
|
||||
= output_swap->swap_rfd_out;
|
||||
HDRR *output_symhdr;
|
||||
HDRR *input_symhdr;
|
||||
bfd_vma section_adjust[scMax];
|
||||
asection *sec;
|
||||
char *sym_out;
|
||||
char *lraw_src;
|
||||
char *lraw_end;
|
||||
char *fdr_ptr;
|
||||
char *fdr_end;
|
||||
bfd_size_type fdr_add;
|
||||
char *fdr_out;
|
||||
|
||||
output_symhdr = &output_debug->symbolic_header;
|
||||
input_symhdr = &input_debug->symbolic_header;
|
||||
|
||||
/* Make sure the buffers are large enough. */
|
||||
#define CHECK(start, end, count, size) \
|
||||
if ((char *) output_debug->end - (char *) output_debug->start \
|
||||
< (output_symhdr->count + input_symhdr->count) * size) \
|
||||
{ \
|
||||
if (! ecoff_add_bytes ((char **) &output_debug->start, \
|
||||
(char **) &output_debug->end, \
|
||||
((output_symhdr->count \
|
||||
+ input_symhdr->count) \
|
||||
* size))) \
|
||||
return false; \
|
||||
}
|
||||
|
||||
CHECK (line, line_end, cbLine, sizeof (unsigned char));
|
||||
#if 0
|
||||
/* I don't think dense number information is needed. */
|
||||
CHECK (external_dnr, external_dnr_end, idnMax,
|
||||
output_swap->external_dnr_size);
|
||||
#endif
|
||||
CHECK (external_pdr, external_pdr_end, ipdMax,
|
||||
output_swap->external_pdr_size);
|
||||
CHECK (external_sym, external_sym_end, isymMax,
|
||||
output_swap->external_sym_size);
|
||||
CHECK (external_opt, external_opt_end, ioptMax,
|
||||
output_swap->external_opt_size);
|
||||
CHECK (external_aux, external_aux_end, iauxMax,
|
||||
sizeof (union aux_ext));
|
||||
CHECK (ss, ss_end, issMax, sizeof (char));
|
||||
CHECK (external_fdr, external_fdr_end, ifdMax,
|
||||
output_swap->external_fdr_size);
|
||||
|
||||
/* The RFD's are special, since we create them if needed. */
|
||||
{
|
||||
bfd_size_type crfd;
|
||||
|
||||
crfd = input_symhdr->crfd;
|
||||
if (input_symhdr->crfd == 0)
|
||||
input_symhdr->crfd = input_symhdr->ifdMax;
|
||||
CHECK (external_rfd, external_rfd_end, crfd,
|
||||
output_swap->external_rfd_size);
|
||||
input_symhdr->crfd = crfd;
|
||||
}
|
||||
|
||||
#undef CHECK
|
||||
|
||||
/* Use section_adjust to hold the value to add to a symbol in a
|
||||
particular section. */
|
||||
memset ((PTR) section_adjust, 0, sizeof section_adjust);
|
||||
|
||||
#define SET(name, indx) \
|
||||
sec = bfd_get_section_by_name (input_bfd, name); \
|
||||
if (sec != NULL) \
|
||||
section_adjust[indx] = (sec->output_section->vma \
|
||||
+ sec->output_offset \
|
||||
- sec->vma);
|
||||
|
||||
SET (".text", scText);
|
||||
SET (".data", scData);
|
||||
SET (".bss", scBss);
|
||||
SET (".sdata", scSData);
|
||||
SET (".sbss", scSBss);
|
||||
/* scRdata section may be either .rdata or .rodata. */
|
||||
SET (".rdata", scRData);
|
||||
SET (".rodata", scRData);
|
||||
SET (".init", scInit);
|
||||
SET (".fini", scFini);
|
||||
|
||||
#undef SET
|
||||
|
||||
/* Swap in the local symbols, adjust their values, and swap them out
|
||||
again. The external symbols are handled separately. */
|
||||
sym_out = ((char *) output_debug->external_sym
|
||||
+ output_symhdr->isymMax * output_swap->external_sym_size);
|
||||
lraw_src = (char *) input_debug->external_sym;
|
||||
lraw_end = lraw_src + input_symhdr->isymMax * input_swap->external_sym_size;
|
||||
for (; lraw_src < lraw_end; lraw_src += input_swap->external_sym_size)
|
||||
{
|
||||
SYMR internal_sym;
|
||||
|
||||
(*swap_sym_in) (input_bfd, (PTR) lraw_src, &internal_sym);
|
||||
|
||||
BFD_ASSERT (internal_sym.sc != scCommon
|
||||
&& internal_sym.sc != scSCommon);
|
||||
|
||||
/* Adjust the symbol value if appropriate. */
|
||||
switch (internal_sym.st)
|
||||
{
|
||||
case stNil:
|
||||
if (ECOFF_IS_STAB (&internal_sym))
|
||||
break;
|
||||
/* Fall through. */
|
||||
case stGlobal:
|
||||
case stStatic:
|
||||
case stLabel:
|
||||
case stProc:
|
||||
case stStaticProc:
|
||||
internal_sym.value += section_adjust[internal_sym.sc];
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
(*swap_sym_out) (output_bfd, &internal_sym, sym_out);
|
||||
sym_out += output_swap->external_sym_size;
|
||||
}
|
||||
|
||||
/* Copy the information that does not need swapping. */
|
||||
memcpy (output_debug->line + output_symhdr->cbLine,
|
||||
input_debug->line,
|
||||
input_symhdr->cbLine * sizeof (unsigned char));
|
||||
memcpy (output_debug->external_aux + output_symhdr->iauxMax,
|
||||
input_debug->external_aux,
|
||||
input_symhdr->iauxMax * sizeof (union aux_ext));
|
||||
memcpy (output_debug->ss + output_symhdr->issMax,
|
||||
input_debug->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 0
|
||||
/* I don't think dense number information is needed. */
|
||||
BFD_ASSERT (output_swap->external_dnr_size
|
||||
== input_swap->external_dnr_size);
|
||||
if (input_symhdr->idnMax > 0)
|
||||
memcpy (((char *) output_debug->external_dnr
|
||||
+ output_symhdr->idnMax * output_swap->external_dnr_size),
|
||||
input_debug->external_dnr,
|
||||
input_symhdr->idnMax * output_swap->external_dnr_size);
|
||||
#endif
|
||||
BFD_ASSERT (output_swap->external_pdr_size
|
||||
== input_swap->external_pdr_size);
|
||||
if (input_symhdr->ipdMax > 0)
|
||||
memcpy (((char *) output_debug->external_pdr
|
||||
+ output_symhdr->ipdMax * output_swap->external_pdr_size),
|
||||
input_debug->external_pdr,
|
||||
input_symhdr->ipdMax * output_swap->external_pdr_size);
|
||||
BFD_ASSERT (output_swap->external_opt_size
|
||||
== input_swap->external_opt_size);
|
||||
if (input_symhdr->ioptMax > 0)
|
||||
memcpy (((char *) output_debug->external_opt
|
||||
+ output_symhdr->ioptMax * output_swap->external_opt_size),
|
||||
input_debug->external_opt,
|
||||
input_symhdr->ioptMax * output_swap->external_opt_size);
|
||||
}
|
||||
else
|
||||
{
|
||||
bfd_size_type outsz, insz;
|
||||
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. */
|
||||
#if 0
|
||||
/* I don't think dense number information is needed. */
|
||||
outsz = output_swap->external_dnr_size;
|
||||
insz = input_swap->external_dnr_size;
|
||||
in = (char *) input_debug->external_dnr;
|
||||
end = in + input_symhdr->idnMax * insz;
|
||||
out = ((char *) output_debug->external_dnr
|
||||
+ output_symhdr->idnMax * outsz);
|
||||
for (; in < end; in += insz, out += outsz)
|
||||
{
|
||||
DNR dnr;
|
||||
|
||||
(*input_swap->swap_dnr_in) (input_bfd, in, &dnr);
|
||||
(*output_swap->swap_dnr_out) (output_bfd, &dnr, out);
|
||||
}
|
||||
#endif
|
||||
|
||||
outsz = output_swap->external_pdr_size;
|
||||
insz = input_swap->external_pdr_size;
|
||||
in = (char *) input_debug->external_pdr;
|
||||
end = in + input_symhdr->ipdMax * insz;
|
||||
out = ((char *) output_debug->external_pdr
|
||||
+ output_symhdr->ipdMax * outsz);
|
||||
for (; in < end; in += insz, out += outsz)
|
||||
{
|
||||
PDR pdr;
|
||||
|
||||
(*input_swap->swap_pdr_in) (input_bfd, in, &pdr);
|
||||
(*output_swap->swap_pdr_out) (output_bfd, &pdr, out);
|
||||
}
|
||||
|
||||
outsz = output_swap->external_opt_size;
|
||||
insz = input_swap->external_opt_size;
|
||||
in = (char *) input_debug->external_opt;
|
||||
end = in + input_symhdr->ioptMax * insz;
|
||||
out = ((char *) output_debug->external_opt
|
||||
+ output_symhdr->ioptMax * outsz);
|
||||
for (; in < end; in += insz, out += outsz)
|
||||
{
|
||||
OPTR opt;
|
||||
|
||||
(*input_swap->swap_opt_in) (input_bfd, in, &opt);
|
||||
(*output_swap->swap_opt_out) (output_bfd, &opt, out);
|
||||
}
|
||||
}
|
||||
|
||||
/* Set ifdbase so that the external symbols know how to adjust their
|
||||
ifd values. */
|
||||
input_debug->ifdbase = output_symhdr->ifdMax;
|
||||
|
||||
/* We need to handle the FDR's whether they are swapped or not. */
|
||||
if (input_debug->fdr != (FDR *) NULL)
|
||||
{
|
||||
fdr_ptr = (char *) input_debug->fdr;
|
||||
fdr_add = sizeof (FDR);
|
||||
}
|
||||
else
|
||||
{
|
||||
fdr_ptr = (char *) input_debug->external_fdr;
|
||||
fdr_add = input_swap->external_fdr_size;
|
||||
}
|
||||
fdr_end = fdr_ptr + input_symhdr->ifdMax * fdr_add;
|
||||
fdr_out = ((char *) output_debug->external_fdr
|
||||
+ output_symhdr->ifdMax * output_swap->external_fdr_size);
|
||||
for (;
|
||||
fdr_ptr < fdr_end;
|
||||
fdr_ptr += fdr_add, fdr_out += output_swap->external_fdr_size)
|
||||
{
|
||||
FDR fdr;
|
||||
|
||||
if (input_debug->fdr != (FDR *) NULL)
|
||||
fdr = *(FDR *) fdr_ptr;
|
||||
else
|
||||
(*input_swap->swap_fdr_in) (input_bfd, (PTR) fdr_ptr, &fdr);
|
||||
|
||||
/* FIXME: It is conceivable that this FDR points to the .init or
|
||||
.fini section, in which case this will not do the right
|
||||
thing. */
|
||||
fdr.adr += section_adjust[scText];
|
||||
|
||||
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 crfd 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 *))
|
||||
= input_swap->swap_rfd_in;
|
||||
bfd_size_type outsz, insz;
|
||||
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. */
|
||||
outsz = output_swap->external_rfd_size;
|
||||
insz = input_swap->external_rfd_size;
|
||||
rfd_in = (char *) input_debug->external_rfd;
|
||||
rfd_end = rfd_in + input_symhdr->crfd * insz;
|
||||
rfd_out = ((char *) output_debug->external_rfd
|
||||
+ output_symhdr->crfd * outsz);
|
||||
for (;
|
||||
rfd_in < rfd_end;
|
||||
rfd_in += insz, rfd_out += outsz)
|
||||
{
|
||||
RFDT rfd;
|
||||
|
||||
(*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
|
||||
{
|
||||
bfd_size_type outsz;
|
||||
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. */
|
||||
outsz = output_swap->external_rfd_size;
|
||||
rfd = output_symhdr->ifdMax;
|
||||
rfd_out = ((char *) output_debug->external_rfd
|
||||
+ output_symhdr->crfd * outsz);
|
||||
rfd_end = (rfd_out + input_symhdr->ifdMax * outsz);
|
||||
for (; rfd_out < rfd_end; rfd_out += outsz, rfd++)
|
||||
(*swap_rfd_out) (output_bfd, &rfd, rfd_out);
|
||||
output_symhdr->crfd += input_symhdr->ifdMax;
|
||||
}
|
||||
|
||||
/* Update the counts. */
|
||||
output_symhdr->ilineMax += input_symhdr->ilineMax;
|
||||
output_symhdr->cbLine += input_symhdr->cbLine;
|
||||
#if 0
|
||||
/* I don't think dense number information is needed. */
|
||||
output_symhdr->idnMax += input_symhdr->idnMax;
|
||||
#endif
|
||||
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;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/* Add a string to the debugging information we are accumulating.
|
||||
Return the offset from the fdr string base. */
|
||||
|
||||
static bfd_size_type
|
||||
ecoff_add_string (output, fdr, string)
|
||||
struct ecoff_debug_info *output;
|
||||
FDR *fdr;
|
||||
const char *string;
|
||||
{
|
||||
HDRR *symhdr;
|
||||
size_t len;
|
||||
bfd_size_type ret;
|
||||
|
||||
symhdr = &output->symbolic_header;
|
||||
len = strlen (string);
|
||||
if (output->ss_end - output->ss < symhdr->issMax + len + 1)
|
||||
{
|
||||
if (ecoff_add_bytes (&output->ss, &output->ss_end,
|
||||
symhdr->issMax + len + 1) == false)
|
||||
return -1;
|
||||
}
|
||||
memcpy (output->ss + symhdr->issMax, string, len + 1);
|
||||
ret = fdr->cbSs;
|
||||
symhdr->issMax += len + 1;
|
||||
fdr->cbSs += len + 1;
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* Add debugging information from a non-ECOFF file. */
|
||||
|
||||
boolean
|
||||
bfd_ecoff_debug_link_other (output_bfd, output_debug, output_swap, input_bfd)
|
||||
bfd *output_bfd;
|
||||
struct ecoff_debug_info *output_debug;
|
||||
const struct ecoff_debug_swap *output_swap;
|
||||
bfd *input_bfd;
|
||||
{
|
||||
void (* const swap_sym_out) PARAMS ((bfd *, const SYMR *, PTR))
|
||||
= output_swap->swap_sym_out;
|
||||
HDRR *output_symhdr = &output_debug->symbolic_header;
|
||||
FDR fdr;
|
||||
asection *sec;
|
||||
asymbol **symbols;
|
||||
asymbol **sym_ptr;
|
||||
asymbol **sym_end;
|
||||
|
||||
memset (&fdr, 0, sizeof fdr);
|
||||
|
||||
sec = bfd_get_section_by_name (input_bfd, ".text");
|
||||
if (sec != NULL)
|
||||
fdr.adr = sec->output_section->vma + sec->output_offset;
|
||||
else
|
||||
{
|
||||
/* FIXME: What about .init or .fini? */
|
||||
fdr.adr = 0;
|
||||
}
|
||||
|
||||
fdr.issBase = output_symhdr->issMax;
|
||||
fdr.cbSs = 0;
|
||||
fdr.rss = ecoff_add_string (output_debug, &fdr,
|
||||
bfd_get_filename (input_bfd));
|
||||
fdr.isymBase = output_symhdr->isymMax;
|
||||
|
||||
/* Get the local symbols from the input BFD. */
|
||||
symbols = (asymbol **) bfd_alloc (output_bfd,
|
||||
get_symtab_upper_bound (input_bfd));
|
||||
if (symbols == (asymbol **) NULL)
|
||||
{
|
||||
bfd_error = no_memory;
|
||||
return false;
|
||||
}
|
||||
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++)
|
||||
{
|
||||
SYMR internal_sym;
|
||||
|
||||
if (((*sym_ptr)->flags & BSF_EXPORT) != 0)
|
||||
continue;
|
||||
memset (&internal_sym, 0, sizeof internal_sym);
|
||||
internal_sym.iss = ecoff_add_string (output_debug, &fdr,
|
||||
(*sym_ptr)->name);
|
||||
|
||||
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;
|
||||
|
||||
if (((char *) output_debug->external_sym_end
|
||||
- (char *) output_debug->external_sym)
|
||||
< (output_symhdr->isymMax + 1) * output_swap->external_sym_size)
|
||||
{
|
||||
if (! ecoff_add_bytes ((char **) &output_debug->external_sym,
|
||||
(char **) &output_debug->external_sym_end,
|
||||
((output_symhdr->isymMax + 1)
|
||||
* output_swap->external_sym_size)))
|
||||
return false;
|
||||
}
|
||||
|
||||
(*swap_sym_out) (output_bfd, &internal_sym,
|
||||
((char *) output_debug->external_sym
|
||||
+ (output_symhdr->isymMax
|
||||
* output_swap->external_sym_size)));
|
||||
++fdr.csym;
|
||||
++output_symhdr->isymMax;
|
||||
}
|
||||
|
||||
bfd_release (output_bfd, (PTR) symbols);
|
||||
|
||||
if (((char *) output_debug->external_fdr_end
|
||||
- (char *) output_debug->external_fdr)
|
||||
< (output_symhdr->ifdMax + 1) * output_swap->external_fdr_size)
|
||||
{
|
||||
if (! ecoff_add_bytes ((char **) &output_debug->external_fdr,
|
||||
(char **) &output_debug->external_fdr_end,
|
||||
((output_symhdr->ifdMax + 1)
|
||||
* output_swap->external_fdr_size)))
|
||||
return false;
|
||||
}
|
||||
|
||||
/* 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. */
|
||||
(*output_swap->swap_fdr_out)
|
||||
(output_bfd, &fdr,
|
||||
((char *) output_debug->external_fdr
|
||||
+ output_symhdr->ifdMax * output_swap->external_fdr_size));
|
||||
++output_symhdr->ifdMax;
|
||||
return true;
|
||||
}
|
||||
|
||||
/* Set up ECOFF debugging information for the external symbols. */
|
||||
|
||||
boolean
|
||||
bfd_ecoff_debug_externals (abfd, debug, swap, relocateable, get_extr,
|
||||
set_index)
|
||||
bfd *abfd;
|
||||
struct ecoff_debug_info *debug;
|
||||
const struct ecoff_debug_swap *swap;
|
||||
boolean relocateable;
|
||||
boolean (*get_extr) PARAMS ((asymbol *, EXTR *));
|
||||
void (*set_index) PARAMS ((asymbol *, bfd_size_type));
|
||||
{
|
||||
const bfd_size_type external_ext_size = swap->external_ext_size;
|
||||
void (* const swap_ext_out) PARAMS ((bfd *, const EXTR *, PTR))
|
||||
= swap->swap_ext_out;
|
||||
HDRR * const symhdr = &debug->symbolic_header;
|
||||
asymbol **sym_ptr_ptr;
|
||||
size_t c;
|
||||
|
||||
sym_ptr_ptr = bfd_get_outsymbols (abfd);
|
||||
if (sym_ptr_ptr == NULL)
|
||||
return true;
|
||||
|
||||
for (c = bfd_get_symcount (abfd); c > 0; c--, sym_ptr_ptr++)
|
||||
{
|
||||
asymbol *sym_ptr;
|
||||
EXTR esym;
|
||||
|
||||
sym_ptr = *sym_ptr_ptr;
|
||||
|
||||
/* Get the external symbol information. */
|
||||
if ((*get_extr) (sym_ptr, &esym) == false)
|
||||
continue;
|
||||
|
||||
/* 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;
|
||||
}
|
||||
|
||||
if (debug->ssext_end - debug->ssext
|
||||
< symhdr->issExtMax + strlen (sym_ptr->name) + 1)
|
||||
{
|
||||
if (ecoff_add_bytes ((char **) &debug->ssext,
|
||||
(char **) &debug->ssext_end,
|
||||
symhdr->issExtMax + strlen (sym_ptr->name) + 1)
|
||||
== false)
|
||||
return false;
|
||||
}
|
||||
if ((char *) debug->external_ext_end - (char *) debug->external_ext
|
||||
< (symhdr->iextMax + 1) * external_ext_size)
|
||||
{
|
||||
if (ecoff_add_bytes ((char **) &debug->external_ext,
|
||||
(char **) &debug->external_ext_end,
|
||||
(symhdr->iextMax + 1) * external_ext_size)
|
||||
== false)
|
||||
return false;
|
||||
}
|
||||
|
||||
esym.asym.iss = symhdr->issExtMax;
|
||||
|
||||
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);
|
||||
|
||||
(*swap_ext_out) (abfd, &esym,
|
||||
((char *) debug->external_ext
|
||||
+ symhdr->iextMax * swap->external_ext_size));
|
||||
|
||||
if (set_index)
|
||||
(*set_index) (sym_ptr, symhdr->iextMax);
|
||||
|
||||
++symhdr->iextMax;
|
||||
|
||||
strcpy (debug->ssext + symhdr->issExtMax, sym_ptr->name);
|
||||
symhdr->issExtMax += strlen (sym_ptr->name) + 1;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/* Align the ECOFF debugging information. */
|
||||
|
||||
static void
|
||||
ecoff_align_debug (abfd, debug, swap)
|
||||
bfd *abfd;
|
||||
struct ecoff_debug_info *debug;
|
||||
const struct ecoff_debug_swap *swap;
|
||||
{
|
||||
HDRR * const symhdr = &debug->symbolic_header;
|
||||
bfd_size_type debug_align, aux_align, add;
|
||||
|
||||
/* Adjust the counts so that structures are aligned. The alignment
|
||||
of ALLOC_SIZE ensures that we do not have to worry about running
|
||||
off the end of the memory block when doing the memset. */
|
||||
debug_align = swap->debug_align;
|
||||
aux_align = debug_align / sizeof (union aux_ext);
|
||||
|
||||
add = debug_align - (symhdr->cbLine & (debug_align - 1));
|
||||
if (add != debug_align)
|
||||
{
|
||||
memset (debug->line + symhdr->cbLine, 0, add);
|
||||
symhdr->cbLine += add;
|
||||
}
|
||||
|
||||
add = debug_align - (symhdr->issMax & (debug_align - 1));
|
||||
if (add != debug_align)
|
||||
{
|
||||
memset (debug->ss + symhdr->issMax, 0, add);
|
||||
symhdr->issMax += add;
|
||||
}
|
||||
|
||||
add = debug_align - (symhdr->issExtMax & (debug_align - 1));
|
||||
if (add != debug_align)
|
||||
{
|
||||
memset (debug->ssext + symhdr->issExtMax, 0, add);
|
||||
symhdr->issExtMax += add;
|
||||
}
|
||||
|
||||
add = aux_align - (symhdr->iauxMax & (aux_align - 1));
|
||||
if (add != aux_align)
|
||||
{
|
||||
memset (debug->external_aux + symhdr->iauxMax, 0,
|
||||
add * sizeof (union aux_ext));
|
||||
symhdr->iauxMax += add;
|
||||
}
|
||||
}
|
||||
|
||||
/* Return the size required by the ECOFF debugging information. */
|
||||
|
||||
bfd_size_type
|
||||
bfd_ecoff_debug_size (abfd, debug, swap)
|
||||
bfd *abfd;
|
||||
struct ecoff_debug_info *debug;
|
||||
const struct ecoff_debug_swap *swap;
|
||||
{
|
||||
bfd_size_type tot;
|
||||
|
||||
ecoff_align_debug (abfd, debug, swap);
|
||||
tot = swap->external_hdr_size;
|
||||
|
||||
#define ADD(count, size) \
|
||||
tot += debug->symbolic_header.count * size
|
||||
|
||||
ADD (cbLine, sizeof (unsigned char));
|
||||
ADD (idnMax, swap->external_dnr_size);
|
||||
ADD (ipdMax, swap->external_pdr_size);
|
||||
ADD (isymMax, swap->external_sym_size);
|
||||
ADD (ioptMax, swap->external_opt_size);
|
||||
ADD (iauxMax, sizeof (union aux_ext));
|
||||
ADD (issMax, sizeof (char));
|
||||
ADD (issExtMax, sizeof (char));
|
||||
ADD (ifdMax, swap->external_fdr_size);
|
||||
ADD (crfd, swap->external_rfd_size);
|
||||
ADD (iextMax, swap->external_ext_size);
|
||||
|
||||
#undef ADD
|
||||
|
||||
return tot;
|
||||
}
|
||||
|
||||
/* Write out the ECOFF debugging information. This function assumes
|
||||
that the information (the pointers and counts) in *DEBUG have been
|
||||
set correctly. WHERE is the position in the file to write the
|
||||
information to. This function fills in the file offsets in the
|
||||
symbolic header. */
|
||||
|
||||
boolean
|
||||
bfd_ecoff_write_debug (abfd, debug, swap, where)
|
||||
bfd *abfd;
|
||||
struct ecoff_debug_info *debug;
|
||||
const struct ecoff_debug_swap *swap;
|
||||
file_ptr where;
|
||||
{
|
||||
HDRR * const symhdr = &debug->symbolic_header;
|
||||
char *buff;
|
||||
|
||||
ecoff_align_debug (abfd, debug, swap);
|
||||
|
||||
/* Go to the right location in the file. */
|
||||
if (bfd_seek (abfd, where, SEEK_SET) != 0)
|
||||
return false;
|
||||
|
||||
where += swap->external_hdr_size;
|
||||
|
||||
/* Fill in the file offsets. */
|
||||
#define SET(offset, count, size) \
|
||||
if (symhdr->count == 0) \
|
||||
symhdr->offset = 0; \
|
||||
else \
|
||||
{ \
|
||||
symhdr->offset = where; \
|
||||
where += symhdr->count * size; \
|
||||
}
|
||||
|
||||
SET (cbLineOffset, cbLine, sizeof (unsigned char));
|
||||
SET (cbDnOffset, idnMax, swap->external_dnr_size);
|
||||
SET (cbPdOffset, ipdMax, swap->external_pdr_size);
|
||||
SET (cbSymOffset, isymMax, swap->external_sym_size);
|
||||
SET (cbOptOffset, ioptMax, swap->external_opt_size);
|
||||
SET (cbAuxOffset, iauxMax, sizeof (union aux_ext));
|
||||
SET (cbSsOffset, issMax, sizeof (char));
|
||||
SET (cbSsExtOffset, issExtMax, sizeof (char));
|
||||
SET (cbFdOffset, ifdMax, swap->external_fdr_size);
|
||||
SET (cbRfdOffset, crfd, swap->external_rfd_size);
|
||||
SET (cbExtOffset, iextMax, swap->external_ext_size);
|
||||
#undef SET
|
||||
|
||||
buff = (PTR) alloca (swap->external_hdr_size);
|
||||
(*swap->swap_hdr_out) (abfd, symhdr, buff);
|
||||
if (bfd_write (buff, 1, swap->external_hdr_size, abfd)
|
||||
!= swap->external_hdr_size)
|
||||
return false;
|
||||
|
||||
#define WRITE(ptr, count, size, offset) \
|
||||
BFD_ASSERT (symhdr->offset == 0 || bfd_tell (abfd) == symhdr->offset); \
|
||||
if (bfd_write (debug->ptr, size, symhdr->count, abfd) \
|
||||
!= size * symhdr->count) \
|
||||
return false;
|
||||
|
||||
WRITE (line, cbLine, sizeof (unsigned char), cbLineOffset);
|
||||
WRITE (external_dnr, idnMax, swap->external_dnr_size, cbDnOffset);
|
||||
WRITE (external_pdr, ipdMax, swap->external_pdr_size, cbPdOffset);
|
||||
WRITE (external_sym, isymMax, swap->external_sym_size, cbSymOffset);
|
||||
WRITE (external_opt, ioptMax, swap->external_opt_size, cbOptOffset);
|
||||
WRITE (external_aux, iauxMax, sizeof (union aux_ext), cbAuxOffset);
|
||||
WRITE (ss, issMax, sizeof (char), cbSsOffset);
|
||||
WRITE (ssext, issExtMax, sizeof (char), cbSsExtOffset);
|
||||
WRITE (external_fdr, ifdMax, swap->external_fdr_size, cbFdOffset);
|
||||
WRITE (external_rfd, crfd, swap->external_rfd_size, cbRfdOffset);
|
||||
WRITE (external_ext, iextMax, swap->external_ext_size, cbExtOffset);
|
||||
#undef WRITE
|
||||
|
||||
return true;
|
||||
}
|
||||
Loading…
Reference in New Issue