espressif/binutils-gdb
1
0
Fork 0
mirror of https://github.com/espressif/binutils-gdb.git synced 2025-06-24 04:00:07 +08:00
Code Issues Packages Projects Releases Wiki Activity

*** empty log message ***

Browse Source
This commit is contained in:
Steve Chamberlain
1991-05-11 02:22:21 +00:00
parent 22ddf9bcc5
commit 8e3c8f4755
7 changed files with 472 additions and 1329 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
bfd/aout.c
View File

@ -722,15 +722,15 @@ DEFUN(aout_slurp_symbol_table, (abfd),
/* run through the table and byte swap if needed */
for (sym_pointer = syms; sym_pointer < sym_end; sym_pointer++) {
sym_pointer->n_un.n_strx =
bfd_h_get_x (abfd, &sym_pointer->n_un.n_strx);
bfd_h_getlong (abfd, &sym_pointer->n_un.n_strx);
sym_pointer->n_desc =
bfd_h_get_x (abfd, &sym_pointer->n_desc);
bfd_h_getshort (abfd, &sym_pointer->n_desc);
sym_pointer->n_value =
bfd_h_get_x (abfd, &sym_pointer->n_value);
bfd_h_getlong (abfd, &sym_pointer->n_value);
sym_pointer->n_other = (char)
bfd_h_get_x(abfd, &sym_pointer->n_other);
bfd_h_getchar(abfd, &sym_pointer->n_other);
sym_pointer->n_type = (char)
bfd_h_get_x(abfd, &sym_pointer->n_type);
bfd_h_getchar(abfd, &sym_pointer->n_type);
}
/* Run through table and copy values */

720
bfd/coff-code.h
View File

@ -43,273 +43,6 @@ You should have received a copy of the GNU General Public License along with
PROTO(static void,force_indices_file_symbol_relative,(bfd *abfd,
struct internal_syment *symtab));
/* All the swapping routines:
*/
static void
DEFUN(swap_reloc_in,(abfd, reloc_src, reloc_dst),
bfd *abfd AND
RELOC *reloc_src AND
struct internal_reloc *reloc_dst)
{
reloc_dst->r_vaddr = bfd_h_getlong(abfd, reloc_src->r_vaddr);
reloc_dst->r_symndx = bfd_h_getlong(abfd, reloc_src->r_symndx);
reloc_dst->r_type = bfd_h_getshort(abfd, reloc_src->r_type);
#if M88
reloc_dst->r_offset = bfd_h_getshort(abfd, reloc_src->r_offset);
#endif
}
static void
DEFUN(swap_reloc_out,(abfd, reloc_src, reloc_dst),
bfd *abfd AND
struct internal_reloc *reloc_src AND
struct external_reloc *reloc_dst)
{
bfd_h_putlong(abfd, reloc_src->r_vaddr, reloc_dst->r_vaddr);
bfd_h_putlong(abfd, reloc_src->r_symndx, reloc_dst->r_symndx);
bfd_h_putshort(abfd, reloc_src->r_type, reloc_dst->r_type);
#if M88
bfd_h_putshort(abfd, reloc_src->r_offset, reloc_dst->r_offset);
#endif
}
static void
DEFUN(swap_filehdr,(abfd, filehdr),
bfd *abfd AND
FILHDR *filehdr)
{
sp(filehdr->f_magic);
sp(filehdr->f_nscns);
sp(filehdr->f_timdat);
sp(filehdr->f_symptr);
sp(filehdr->f_nsyms);
sp(filehdr->f_opthdr);
sp(filehdr->f_flags);
}
static void
DEFUN(bfd_coff_swap_name_in,(abfd, ptr),
bfd *abfd AND
long *ptr)
{
if (ptr[0] == 0) {
/* There is an index which needs to be swapped */
bfd_h_put_x(abfd, ptr[1], (ptr + 1));
}
else {
/* This is a string .. leave it alone */
}
}
static void
DEFUN(bfd_coff_swap_sym_in,(abfd, ext, in),
bfd *abfd AND
SYMENT *ext AND
struct internal_syment *in)
{
if( ext->e.e_name[0] == 0) {
in->_n._n_n._n_zeroes = 0;
in->_n._n_n._n_offset = bfd_h_getlong(abfd, &ext->e.e.e_offset);
}
else {
memcpy(in->_n._n_name, ext->e.e_name, SYMNMLEN);
}
in->n_value = bfd_h_get_x(abfd, &ext->e_value);
in->n_scnum = bfd_h_get_x(abfd, &ext->e_scnum);
in->n_type = bfd_h_get_x(abfd, &ext->e_type);
in->n_sclass = bfd_h_get_x(abfd, &ext->e_sclass);
in->n_numaux = bfd_h_get_x(abfd, &ext->e_numaux);
}
static void
DEFUN(bfd_coff_swap_sym_out,(abfd,in, ext),
bfd *abfd AND
struct internal_syment *in AND
SYMENT *ext)
{
if(in->_n._n_name[0] == 0) {
bfd_h_putlong(abfd, 0, ext->e.e.e_zeroes);
bfd_h_putlong(abfd, in->_n._n_n._n_offset, ext->e.e.e_offset);
}
else {
memcpy(ext->e.e_name, in->_n._n_name, SYMNMLEN);
}
bfd_h_put_x(abfd, in->n_value , &ext->e_value);
bfd_h_put_x(abfd, in->n_scnum , &ext->e_scnum);
bfd_h_put_x(abfd, in->n_type , &ext->e_type);
bfd_h_put_x(abfd, in->n_sclass , &ext->e_sclass);
bfd_h_put_x(abfd, in->n_numaux , &ext->e_numaux);
}
static void
DEFUN(bfd_coff_swap_aux_in,(abfd, ext, type, class, in),
bfd *abfd AND
AUXENT *ext AND
int type AND
int class AND
union internal_auxent *in)
{
switch (class) {
case C_FILE:
if (ext->x_file.x_fname[0] == 0) {
in->x_file.x_n.x_zeroes = 0;
in->x_file.x_n.x_offset = bfd_h_getlong(abfd, &ext->x_file.x_n.x_offset);
}
break;
case C_STAT:
#ifdef C_LEAFSTAT
case C_LEAFSTAT:
#endif
case C_HIDDEN:
if (type == T_NULL) {
in->x_scn.x_scnlen = bfd_h_get_x(abfd, & ext->x_scn.x_scnlen);
in->x_scn.x_nreloc = bfd_h_get_x(abfd, &ext->x_scn.x_nreloc);
in->x_scn.x_nlinno = bfd_h_get_x(abfd, &ext->x_scn.x_nlinno);
break;
}
default:
in->x_sym.x_tagndx = bfd_h_get_x(abfd, &ext->x_sym.x_tagndx);
in->x_sym.x_tvndx = bfd_h_get_x(abfd, &ext->x_sym.x_tvndx);
if (ISARY(type) || class == C_BLOCK) {
in->x_sym.x_fcnary.x_ary.x_dimen[0] = bfd_h_get_x(abfd, & ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
in->x_sym.x_fcnary.x_ary.x_dimen[1] = bfd_h_get_x(abfd, & ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
in->x_sym.x_fcnary.x_ary.x_dimen[2] = bfd_h_get_x(abfd, & ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
in->x_sym.x_fcnary.x_ary.x_dimen[3] = bfd_h_get_x(abfd, &ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
}
else {
in->x_sym.x_fcnary.x_fcn.x_lnnoptr = bfd_h_get_x(abfd, & ext->x_sym.x_fcnary.x_fcn.x_lnnoptr);
in->x_sym.x_fcnary.x_fcn.x_endndx = bfd_h_get_x(abfd, & ext->x_sym.x_fcnary.x_fcn.x_endndx);
}
if (ISFCN(type)) {
in->x_sym.x_misc.x_fsize = bfd_h_get_x(abfd, &ext->x_sym.x_misc.x_fsize);
}
else {
in->x_sym.x_misc.x_lnsz.x_lnno = bfd_h_get_x(abfd, & ext->x_sym.x_misc.x_lnsz.x_lnno);
in->x_sym.x_misc.x_lnsz.x_size = bfd_h_get_x(abfd, & ext->x_sym.x_misc.x_lnsz.x_size);
}
}
}
static void
DEFUN(bfd_coff_swap_aux_out,(abfd, in, type, class, ext),
bfd *abfd AND
union internal_auxent *in AND
int type AND
int class AND
AUXENT *ext)
{
switch (class) {
case C_FILE:
if (in->x_file.x_fname[0] == 0) {
bfd_h_put_x(abfd, 0,&ext->x_file.x_n.x_zeroes );
bfd_h_put_x(abfd, in->x_file.x_n.x_offset, &ext->x_file.x_n.x_offset);
}
break;
case C_STAT:
#ifdef C_LEAFSTAT
case C_LEAFSTAT:
#endif
case C_HIDDEN:
if (type == T_NULL) {
bfd_h_put_x(abfd, in->x_scn.x_scnlen, & ext->x_scn.x_scnlen);
bfd_h_put_x(abfd, in->x_scn.x_nreloc, & ext->x_scn.x_nreloc);
bfd_h_put_x(abfd, in->x_scn.x_nlinno, & ext->x_scn.x_nlinno);
break;
}
default:
bfd_h_put_x(abfd, in->x_sym.x_tagndx, &ext->x_sym.x_tagndx);
bfd_h_put_x(abfd, in->x_sym.x_tvndx , &ext->x_sym.x_tvndx);
if (ISARY(type) || class == C_BLOCK) {
bfd_h_put_x(abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0], & ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
bfd_h_put_x(abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1], & ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
bfd_h_put_x(abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2], & ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
bfd_h_put_x(abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3], & ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
}
else {
bfd_h_put_x(abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, & ext->x_sym.x_fcnary.x_fcn.x_lnnoptr);
bfd_h_put_x(abfd, in->x_sym.x_fcnary.x_fcn.x_endndx, & ext->x_sym.x_fcnary.x_fcn.x_endndx);
}
if (ISFCN(type)) {
bfd_h_put_x(abfd, in->x_sym.x_misc.x_fsize, &ext->x_sym.x_misc.x_fsize);
}
else {
bfd_h_put_x(abfd, in->x_sym.x_misc.x_lnsz.x_lnno, & ext->x_sym.x_misc.x_lnsz.x_lnno);
bfd_h_put_x(abfd, in->x_sym.x_misc.x_lnsz.x_size, & ext->x_sym.x_misc.x_lnsz.x_size);
}
}
}
static void
DEFUN(bfd_coff_swap_lineno_in,(abfd, ext, in),
bfd *abfd AND
LINENO *ext AND
struct internal_lineno *in)
{
in->l_addr.l_symndx = bfd_h_get_x(abfd, &ext->l_addr.l_symndx);
in->l_lnno = bfd_h_get_x(abfd, & ext->l_lnno);
}
static void
DEFUN(bfd_coff_swap_lineno_out,(abfd, in, ext),
bfd *abfd AND
struct internal_lineno *in AND
struct external_lineno *ext)
{
bfd_h_put_x(abfd, in->l_addr.l_symndx, &ext->l_addr.l_symndx);
bfd_h_put_x(abfd, in->l_lnno, &ext->l_lnno);
}
static void
DEFUN(swap_aouthdr,(abfd, aouthdr),
bfd *abfd AND
AOUTHDR *aouthdr)
{
sp(aouthdr->magic);
sp(aouthdr->vstamp);
sp(aouthdr->tsize);
sp(aouthdr->dsize);
sp(aouthdr->bsize);
sp(aouthdr->entry);
sp(aouthdr->text_start);
sp(aouthdr->data_start);
#ifdef I960
sp(aouthdr->tagentries);
#endif
}
static void
DEFUN(swap_scnhdr,(abfd, scnhdr),
bfd *abfd AND
SCNHDR *scnhdr)
{
sp(scnhdr->s_vaddr);
sp(scnhdr->s_paddr);
sp(scnhdr->s_size);
sp(scnhdr->s_scnptr);
sp(scnhdr->s_relptr);
sp(scnhdr->s_lnnoptr);
sp(scnhdr->s_nreloc);
sp(scnhdr->s_nlnno);
sp(scnhdr->s_flags);
#ifdef I960
sp(scnhdr->s_align);
#endif
}
/* void warning(); */
extern asection abs_section;
@ -329,246 +62,10 @@ DEFUN(set_index,(symbol, idx),
symbol->value = idx;
}
/*
initialize a section structure with information peculiar to this
particular implementation of coff
*/
static boolean
DEFUN(coff_new_section_hook,(abfd_ignore, section_ignore),
bfd *abfd_ignore AND
asection *section_ignore)
{
#ifdef MC88MAGIC
/* FIXME, shouldn't this ifdef be on something that says we are
actually COMPILING FOR an 88K coff file, rather than simply
knowing its magic number? */
/* Align to at least 16 bytes */
section_ignore->alignment_power = 4;
#endif
#if M68
section_ignore->alignment_power = 3;
#endif
return true;
}
/* Take a section header read from a coff file (in HOST byte order),
and make a BFD "section" out of it. */
static boolean
DEFUN(make_a_section_from_file,(abfd, hdr),
bfd *abfd AND
struct scnhdr *hdr)
{
asection *return_section;
{
/* Assorted wastage to null-terminate the name, thanks AT&T! */
char *name = bfd_alloc(abfd, sizeof (hdr->s_name)+1);
if (name == NULL) {
bfd_error = no_memory;
return false;
}
strncpy(name, (char *) &hdr->s_name[0], sizeof (hdr->s_name));
name[sizeof (hdr->s_name)] = 0;
return_section = bfd_make_section(abfd, name);
}
/* s_paddr is presumed to be = to s_vaddr */
#define assign(to, from) return_section->to = hdr->from
assign(vma, s_vaddr);
/* assign (vma, s_vaddr); */
assign(size, s_size);
assign(filepos, s_scnptr);
assign(rel_filepos, s_relptr);
assign(reloc_count, s_nreloc);
#ifdef I960
{
/* FIXME, use a temp var rather than alignment_power */
assign(alignment_power, s_align);
{
unsigned int i;
for (i = 0; i < 32; i++) {
if ((1 << i) >= (int) (return_section->alignment_power)) {
return_section->alignment_power = i;
break;
}
}
}
}
#endif
assign(line_filepos, s_lnnoptr);
/*
return_section->linesize = hdr->s_nlnno * sizeof (struct lineno);
*/
#undef assign
return_section->lineno_count = hdr->s_nlnno;
return_section->userdata = NULL;
return_section->next = (asection *) NULL;
if ((hdr->s_flags & STYP_TEXT) || (hdr->s_flags & STYP_DATA))
return_section->flags = (SEC_LOAD | SEC_ALLOC);
else if (hdr->s_flags & STYP_BSS)
return_section->flags = SEC_ALLOC;
if (hdr->s_nreloc != 0)
return_section->flags |= SEC_RELOC;
if (hdr->s_scnptr != 0)
return_section->flags |= SEC_HAS_CONTENTS;
return true;
}
static boolean
DEFUN(coff_mkobject,(abfd),
bfd *abfd)
{
set_tdata (abfd, bfd_zalloc (abfd,sizeof(coff_data_type)));
if (coff_data(abfd) == 0) {
bfd_error = no_memory;
return false;
}
coff_data(abfd)->relocbase = 0;
return true;
}
static
bfd_target *
DEFUN(coff_real_object_p,(abfd, nscns, opthdr),
bfd *abfd AND
unsigned nscns AND
unsigned opthdr)
{
coff_data_type *coff;
char *file_info; /* buffer for all the headers */
size_t readsize; /* length of file_info */
struct filehdr *filehdr; /* points into file_info */
struct scnhdr *sections; /* points into file_info */
/* Build a play area */
if (coff_mkobject(abfd) != true)
return 0;
coff = coff_data(abfd);
/* OK, now we know the format, read in the filehdr, soi-disant "optional
header", and all the sections. */
readsize = sizeof(struct filehdr)
+ opthdr
+ (nscns * sizeof(struct scnhdr));
file_info = (PTR) bfd_alloc(abfd, readsize);
if (file_info == NULL) {
bfd_error = no_memory;
goto fail;
}
if (bfd_seek(abfd, 0L, SEEK_SET) < 0) {
bfd_release (abfd, (PTR)file_info);
goto fail;
}
if (bfd_read((PTR) file_info, 1, readsize, abfd) != readsize) {
bfd_release (abfd, (PTR)file_info);
goto fail;
}
filehdr = (struct filehdr *) file_info;
sections = (struct scnhdr *) (file_info + sizeof(struct filehdr) + opthdr);
swap_filehdr(abfd, filehdr);
/* Now copy data as required; construct all asections etc */
coff->symbol_index_slew = 0;
coff->relocbase =0;
coff->raw_syment_count = 0;
coff->raw_linenos = 0;
coff->raw_syments = 0;
coff->sym_filepos =0;
coff->flags = filehdr->f_flags;
if (nscns != 0) {
unsigned int i;
for (i = 0; i < nscns; i++) {
swap_scnhdr(abfd, sections + i);
make_a_section_from_file(abfd, sections + i);
}
}
/* Determine the machine architecture and type. */
abfd->obj_machine = 0;
switch (filehdr->f_magic) {
#ifdef MC68MAGIC
case MC68MAGIC:
case M68MAGIC:
abfd->obj_arch = bfd_arch_m68k;
abfd->obj_machine = 68020;
break;
#endif
#ifdef MC88MAGIC
case MC88MAGIC:
case MC88DMAGIC:
case MC88OMAGIC:
abfd->obj_arch = bfd_arch_m88k;
abfd->obj_machine = 88100;
break;
#endif
#ifdef I960ROMAGIC
case I960ROMAGIC:
case I960RWMAGIC:
abfd->obj_arch = bfd_arch_i960;
switch (F_I960TYPE & filehdr->f_flags)
{
default:
case F_I960CORE:
abfd->obj_machine = bfd_mach_i960_core;
break;
case F_I960KB:
abfd->obj_machine = bfd_mach_i960_kb_sb;
break;
case F_I960MC:
abfd->obj_machine = bfd_mach_i960_mc;
break;
case F_I960XA:
abfd->obj_machine = bfd_mach_i960_xa;
break;
case F_I960CA:
abfd->obj_machine = bfd_mach_i960_ca;
break;
case F_I960KA:
abfd->obj_machine = bfd_mach_i960_ka_sa;
break;
}
break;
#endif
default: /* Unreadable input file type */
abfd->obj_arch = bfd_arch_obscure;
break;
}
if (!(filehdr->f_flags & F_RELFLG))
abfd->flags |= HAS_RELOC;
if ((filehdr->f_flags & F_EXEC))
abfd->flags |= EXEC_P;
if (!(filehdr->f_flags & F_LNNO))
abfd->flags |= HAS_LINENO;
if (!(filehdr->f_flags & F_LSYMS))
abfd->flags |= HAS_LOCALS;
bfd_get_symcount(abfd) = filehdr->f_nsyms;
if (filehdr->f_nsyms)
abfd->flags |= HAS_SYMS;
coff->sym_filepos = filehdr->f_symptr;
swap_aouthdr(abfd, &coff->hdr);
coff->symbols = (coff_symbol_type *) NULL;
bfd_get_start_address(abfd) = opthdr ? exec_hdr(abfd).entry : 0;
return abfd->xvec;
fail:
bfd_release(abfd, coff);
return (bfd_target *)NULL;
}
#include "coffish.h"
/*
Takes a bfd and a symbol, returns a pointer to the coff specific area
@ -590,47 +87,6 @@ DEFUN(coff_symbol_from,(abfd, symbol),
static bfd_target *
DEFUN(coff_object_p,(abfd),
bfd *abfd)
{
unsigned short magic,
nscns,
opthdr;
bfd_error = system_call_error;
/* figure out how much to read */
if (bfd_read((PTR) &magic, 1, sizeof(magic), abfd) != sizeof(magic))
return 0;
magic = bfd_h_getshort(abfd, (bfd_byte *) (&magic));
if (BADMAG(*((struct filehdr *) & magic))) {
bfd_error = wrong_format;
return 0;
}
if (bfd_read((PTR) &nscns, 1, sizeof(nscns), abfd) != sizeof(nscns))
return 0;
nscns = bfd_h_getshort(abfd, (unsigned char *) &nscns);
if (bfd_seek(abfd, (file_ptr) & (((struct filehdr *) NULL)->f_opthdr), SEEK_SET)
< 0)
return 0;
if (bfd_read((PTR) &opthdr, 1, sizeof(opthdr), abfd) != sizeof(opthdr))
return 0;
opthdr = bfd_h_getshort(abfd, (unsigned char *) &opthdr);
/* if the optional header is NULL or not the correct size then
quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
and Intel 960 readwrite headers (I960WRMAGIC) is that the
optional header is of a different size
*/
if (opthdr != 0 &&
opthdr != AOUTSZ)
return (bfd_target *)NULL;
return coff_real_object_p(abfd, nscns, opthdr);
}
@ -730,8 +186,8 @@ We store in the name field of each syment the actual native index
applied so we can dig it out through a pointer. */
static void
coff_mangle_symbols(bfd_ptr)
bfd *bfd_ptr;
DEFUN(coff_mangle_symbols,(bfd_ptr),
bfd *bfd_ptr)
{
unsigned int symbol_count = bfd_get_symcount(bfd_ptr);
asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
@ -837,7 +293,7 @@ bfd *bfd_ptr;
}
#ifdef C_LEAFPROC
if (syment->n_sclass == C_LEAFPROC &&
bfd_h_get_x(bfd_ptr, &syment->n_numaux) == 2) {
syment->n_numaux == 2) {
union internal_auxent *auxent = (union internal_auxent *)(syment+2);
/* This is the definition of a leaf proc, we'll relocate the
address */
@ -885,7 +341,7 @@ bfd *bfd_ptr;
if (ISFCN(syment->n_type)) {
last_fcn = syment;
}
if (bfd_h_get_x(bfd_ptr, & syment->n_sclass) == C_BLOCK
if (syment->n_sclass == C_BLOCK
&& coff_symbol_ptr->symbol.name[1] == 'b')
{
*last_block++ = syment;
@ -900,9 +356,9 @@ bfd *bfd_ptr;
static void
coff_write_symbols(abfd)
bfd *abfd;
{
DEFUN(coff_write_symbols,(abfd),
bfd *abfd)
{
unsigned int i;
unsigned int limit = bfd_get_symcount(abfd);
unsigned int written = 0;
@ -1040,7 +496,7 @@ bfd *abfd;
SYMENT buf;
bfd_coff_swap_sym_out(abfd, native, &buf);
bfd_write((PTR)& buf, 1, SYMESZ, abfd);
for (j = 0; j != bfd_h_get_x(abfd, &native->n_numaux);
for (j = 0; j != native->n_numaux;
j++) {
AUXENT buf1;
bfd_coff_swap_aux_out(abfd,
@ -1083,7 +539,7 @@ bfd *abfd;
}
}
}
static void
coff_write_relocs(abfd)
@ -1117,8 +573,8 @@ bfd *abfd;
}
static void
coff_write_linenumbers(abfd)
bfd *abfd;
DEFUN(coff_write_linenumbers,(abfd),
bfd *abfd)
{
asection *s;
for (s = abfd->sections; s != (asection *) NULL; s = s->next) {
@ -1351,10 +807,9 @@ bfd *abfd;
/* SUPPRESS 558 */
/* SUPPRESS 529 */
static boolean
coff_write_object_contents(abfd)
bfd *abfd;
{
struct filehdr file_header;
DEFUN(coff_write_object_contents,(abfd),
bfd *abfd)
{
asection *current;
boolean hasrelocs = false;
boolean haslinno = false;
@ -1368,9 +823,9 @@ bfd *abfd;
asection *text_sec = NULL;
asection *data_sec = NULL;
asection *bss_sec = NULL;
unsigned magic,
flags;
struct internal_filehdr internal_f;
struct internal_aouthdr internal_a;
struct icofdata *coff = obj_icof(abfd);
@ -1442,7 +897,7 @@ bfd *abfd;
unsigned int pad = 0;
for (current = abfd->sections; current != NULL; current = current->next) {
SCNHDR section;
struct internal_scnhdr section;
strncpy(&(section.s_name[0]), current->name, 8);
section.s_vaddr = current->vma + pad;
section.s_paddr = current->vma + pad;
@ -1488,15 +943,19 @@ bfd *abfd;
: 0);
#endif
swap_scnhdr(abfd, &section);
bfd_write((PTR) (&section), 1, SCNHSZ, abfd);
{
SCNHDR buff;
swap_scnhdr_out(abfd, &section, &buff);
bfd_write((PTR) (&buff), 1, SCNHSZ, abfd);
}
pad = 0;
}
}
/* OK, now set up the filehdr... */
bfd_h_put_x(abfd, abfd->section_count, &file_header.f_nscns);
internal_f.f_nscns = abfd->section_count;
/*
We will NOT put a fucking timestamp in the header here. Every time you
put it back, I will come in and take it out again. I'm sorry. This
@ -1508,36 +967,36 @@ bfd *abfd;
steve@cygnus.com
*/
#ifdef COFF_TIMESTAMP
bfd_h_put_x(abfd, time(0), &file_header.f_timdat);
internal_f.f_timdat = time(0);
#else
bfd_h_put_x(abfd, 0, &file_header.f_timdat);
internal_f.f_timdat = 0;
#endif
if (bfd_get_symcount(abfd) != 0)
bfd_h_put_x(abfd, sym_base, &file_header.f_symptr);
internal_f.f_symptr = sym_base;
else
bfd_h_put_x(abfd, 0, &file_header.f_symptr);
internal_f.f_symptr = 0;
file_header.f_flags = 0;
internal_f.f_flags = 0;
if (abfd->flags & EXEC_P)
bfd_h_put_x(abfd, sizeof(AOUTHDR), &file_header.f_opthdr);
internal_f.f_opthdr = AOUTSZ;
else
bfd_h_put_x(abfd, 0, &file_header.f_opthdr);
internal_f.f_opthdr = 0;
if (!hasrelocs)
file_header.f_flags |= F_RELFLG;
internal_f.f_flags |= F_RELFLG;
if (!haslinno)
file_header.f_flags |= F_LNNO;
internal_f.f_flags |= F_LNNO;
if (0 == bfd_get_symcount(abfd))
file_header.f_flags |= F_LSYMS;
internal_f.f_flags |= F_LSYMS;
if (abfd->flags & EXEC_P)
file_header.f_flags |= F_EXEC;
internal_f.f_flags |= F_EXEC;
#if M88
file_header.f_flags |= F_AR32W;
internal_f.f_flags |= F_AR32W;
#else
if (!abfd->xvec->byteorder_big_p)
file_header.f_flags |= F_AR32WR;
internal_f.f_flags |= F_AR32WR;
#endif
/*
FIXME, should do something about the other byte orders and
@ -1546,23 +1005,23 @@ bfd *abfd;
/* Set up architecture-dependent stuff */
magic = 0;
flags = 0;
{ int magic = 0;
int flags = 0;
coff_set_flags(abfd, &magic, &flags);
file_header.f_flags |= flags;
internal_f.f_flags |= flags;
internal_f.f_magic = magic;
internal_f.f_flags = flags;
bfd_h_put_x(abfd, magic, &file_header.f_magic);
bfd_h_put_x(abfd, file_header.f_flags, &file_header.f_flags);
/* ...and the "opt"hdr... */
#ifdef I960
bfd_h_put_x(abfd, (magic == I960ROMAGIC ? NMAGIC : OMAGIC),
&(exec_hdr(abfd).magic));
internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
#endif
#if M88
exec_hdr(abfd).magic = PAGEMAGICBCS;
internal_a.magic = PAGEMAGICBCS;
#endif
}
/* Now should write relocs, strings, syms */
obj_sym_filepos(abfd) = sym_base;
@ -1573,32 +1032,32 @@ bfd *abfd;
coff_write_relocs(abfd);
}
if (text_sec) {
bfd_h_put_x(abfd, text_sec->size, &coff->hdr.tsize);
bfd_h_put_x(abfd,
text_sec->size ? text_sec->vma : 0,
&exec_hdr(abfd).text_start);
internal_a.tsize = text_sec->size;
internal_a.text_start =text_sec->size ? text_sec->vma : 0;
}
if (data_sec) {
bfd_h_put_x(abfd, data_sec->size, &coff->hdr.dsize);
bfd_h_put_x(abfd,
data_sec->size ? data_sec->vma : 0,
&exec_hdr(abfd).data_start);
internal_a.dsize = data_sec->size;
internal_a.data_start = data_sec->size ? data_sec->vma : 0;
}
if (bss_sec) {
bfd_h_put_x(abfd, bss_sec->size, &coff->hdr.bsize);
internal_a.bsize = bss_sec->size;
}
bfd_h_put_x(abfd, bfd_get_start_address(abfd), &coff->hdr.entry);
bfd_h_put_x(abfd, bfd_get_symcount(abfd), &file_header.f_nsyms);
internal_a.entry = bfd_get_start_address(abfd);
internal_f.f_nsyms = bfd_get_symcount(abfd);
/* now write them */
if (bfd_seek(abfd, 0L, SEEK_SET) != 0)
return false;
bfd_write((PTR) &file_header, 1, FILHSZ, abfd);
{
FILHDR buff;
swap_filehdr_out(abfd, &internal_f, &buff);
bfd_write((PTR) &internal_f, 1, FILHSZ, abfd);
}
if (abfd->flags & EXEC_P) {
bfd_write((PTR) &coff->hdr, 1, AOUTSZ, abfd);
AOUTHDR buff;
swap_aouthdr_out(abfd, &internal_a, &buff);
bfd_write((PTR) &buff, 1, AOUTSZ, abfd);
}
return true;
}
@ -1622,6 +1081,30 @@ coff_set_section_contents(abfd, section, location, offset, count)
return true;
}
static boolean
coff_close_and_cleanup(abfd)
bfd *abfd;
{
if (!bfd_read_p(abfd))
switch (abfd->format) {
case bfd_archive:
if (!_bfd_write_archive_contents(abfd))
return false;
break;
case bfd_object:
if (!coff_write_object_contents(abfd))
return false;
break;
default:
bfd_error = invalid_operation;
return false;
}
/* We depend on bfd_close to free all the memory on the obstack. */
/* FIXME if bfd_release is not using obstacks! */
return true;
}
static PTR
buy_and_read(abfd, where, seek_direction, size)
@ -1652,15 +1135,14 @@ DEFUN(offset_symbol_indices,(abfd, symtab, count, offset),
{
struct internal_syment *end = symtab + count;
for (; symtab < end; ++symtab) {
if (bfd_h_get_x(abfd, &symtab->n_sclass) == C_FILE) {
bfd_h_put_x(abfd, 0, & symtab->n_value);
if (symtab->n_sclass == C_FILE) {
symtab->n_value = 0;
}
else if (bfd_h_get_x(abfd, &symtab->n_sclass) == C_ALIAS) {
else if (symtab->n_sclass == C_ALIAS) {
/*
These guys have indices in their values.
*/
bfd_h_put_x(abfd, bfd_h_get_x(abfd, & symtab->n_value) + offset, & symtab->n_value);
symtab->n_value = symtab->n_value + offset;
}
else if (symtab->n_numaux) {
/*
@ -1685,7 +1167,7 @@ DEFUN(offset_symbol_indices,(abfd, symtab, count, offset),
|| symtab->n_sclass == C_ENTAG
|| symtab->n_sclass == C_BLOCK
|| symtab->n_sclass == C_FCN
|| ISFCN(bfd_h_get_x(abfd, &symtab->n_type))) {
|| ISFCN(symtab->n_type)) {
((union internal_auxent *) (symtab +
1))->x_sym.x_fcnary.x_fcn.x_endndx
@ -1693,14 +1175,14 @@ DEFUN(offset_symbol_indices,(abfd, symtab, count, offset),
} /* These guys have an endndx */
#ifndef I960
if (ISFCN(bfd_h_get_x(abfd,& symtab->n_type))) {
if (ISFCN(symtab->n_type)) {
((union internal_auxent *) (symtab + 1))->x_sym.x_tvndx += offset;
} /* These guys have a tvndx. I think...
(FIXME) */
#endif /* Not I960 */
} /* if value, else if aux */
symtab += bfd_h_get_x(abfd, &symtab->n_numaux);
symtab += symtab->n_numaux;
} /* walk the symtab */
return;
@ -1833,14 +1315,14 @@ bfd *abfd)
symbols === the symbol table size.
*/
if (bfd_read((char *) &string_table_size_buffer,
if (bfd_read((char *) string_table_size_buffer,
sizeof(string_table_size_buffer),
1, abfd) != sizeof(string_table_size)) {
bfd_error = system_call_error;
return (NULL);
} /* on error */
string_table_size = bfd_h_getlong(abfd, &string_table_size_buffer);
string_table_size = bfd_h_getlong(abfd, string_table_size_buffer);
if ((string_table = (PTR) bfd_alloc(abfd, string_table_size -= 4)) == NULL) {
bfd_error = no_memory;
@ -2409,7 +1891,7 @@ DEFUN(coff_find_nearest_line,(abfd,
#endif
for (i = 0; i < cof->raw_syment_count; i++) {
if (bfd_h_get_x(abfd, &p->n_sclass) == C_FILE) {
if (p->n_sclass == C_FILE) {
/* File name is embeded in auxent */
/*
This isn't right. The fname should probably be normalized
@ -2421,7 +1903,7 @@ DEFUN(coff_find_nearest_line,(abfd,
*filename_ptr = ((AUXENT *) (p + 1))->x_file.x_fname;
break;
}
p += 1 + bfd_h_get_x(abfd, & p->n_numaux);
p += 1 + p->n_numaux;
}
/* Now wander though the raw linenumbers of the section */
/*
@ -2456,7 +1938,7 @@ DEFUN(coff_find_nearest_line,(abfd,
The linenumber is stored in the auxent
*/
union internal_auxent *a = (union internal_auxent *) (s + 1);
line_base = bfd_h_get_x(abfd, &a->x_sym.x_misc.x_lnsz.x_lnno);
line_base = a->x_sym.x_misc.x_lnsz.x_lnno;
}
}
}
@ -2494,10 +1976,10 @@ DEFUN(coff_sizeof_headers,(abfd, reloc),
size_t size;
if (reloc == false) {
size = sizeof(struct filehdr) + sizeof(AOUTHDR);
size = FILHSZ + AOUTSZ;
}
else {
size = sizeof(struct filehdr);
size = FILHSZ;
}
size += abfd->section_count * SCNHSZ;

12
bfd/coff-i960.c
View File

@ -62,24 +62,24 @@ asection *ignore_input_section;
result = bfd_reloc_dangerous;
}
else {
switch (bfd_h_get_x(abfd, & cs->native->n_sclass))
switch (cs->native->n_sclass)
{
case C_LEAFSTAT:
case C_LEAFEXT:
/* This is a call to a leaf procedure, replace instruction with a bal
to the correct location */
{
AUXENT *aux = (AUXENT *)(cs->native+2);
union internal_auxent *aux = (union internal_auxent *)(cs->native+2);
int word = bfd_getlong(abfd, data + reloc_entry->address);
BFD_ASSERT(bfd_h_get_x(abfd, &cs->native->n_numaux)==2);
int olf = (aux->x_bal.x_balntry - cs->native->n_value);
BFD_ASSERT(cs->native->n_numaux==2);
/* We replace the original call instruction with a bal to */
/* the bal entry point - the offset of which is described in the */
/* 2nd auxent of the original symbol. We keep the native sym and */
/* auxents untouched, so the delta between the two is the */
/* offset of the bal entry point */
word = ((word + (bfd_h_get_x(abfd, &aux->x_bal.x_balntry) -
bfd_h_get_x(abfd, &cs->native->n_value)))
& BAL_MASK) | BAL;
word = ((word + olf) & BAL_MASK) | BAL;
bfd_putlong(abfd, word, data+reloc_entry->address);
}
result = bfd_reloc_ok;

2
bfd/coff-m68k.c
View File

@ -72,6 +72,8 @@ bfd_target m68kcoff_vec =
bfd_generic_archive_p, _bfd_dummy_target},
{bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
bfd_false},
{bfd_false, coff_write_object_contents, /* bfd_write_contents */
_bfd_write_archive_contents, bfd_false},
JUMP_TABLE(coff)

365
bfd/coff-mips.c
View File

@ -34,354 +34,9 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "intel-coff.h"
#include "libcoff.h" /* to allow easier abstraction-breaking */
/* initialize a section structure with information
* peculiar to this particular implementation of coff
*/
static boolean
ecoff_new_section_hook(ignore_abfd, ignore)
bfd *ignore_abfd;
asection *ignore;
{
return true;
}
/* Take a section header read from a coff file (in HOST byte order),
and make a BFD "section" out of it. */
static boolean
DEFUN(make_a_section_from_file,(abfd, hdr),
bfd *abfd AND
struct scnhdr *hdr)
{
asection *return_section;
{
/* Assorted wastage to null-terminate the name, thanks AT&T! */
char *name = bfd_alloc(abfd, sizeof (hdr->s_name)+1);
if (name == NULL) {
bfd_error = no_memory;
return false;
}
strncpy(name, (char *) &hdr->s_name[0], sizeof (hdr->s_name));
name[sizeof (hdr->s_name)] = 0;
return_section = bfd_make_section(abfd, name);
}
/* s_paddr is presumed to be = to s_vaddr */
#define assign(to, from) return_section->to = hdr->from
assign(vma, s_vaddr);
/* assign (vma, s_vaddr); */
assign(size, s_size);
assign(filepos, s_scnptr);
assign(rel_filepos, s_relptr);
assign(reloc_count, s_nreloc);
assign(line_filepos, s_lnnoptr);
/*
return_section->linesize = hdr->s_nlnno * sizeof (struct lineno);
*/
#undef assign
return_section->lineno_count = hdr->s_nlnno;
return_section->userdata = NULL;
return_section->next = (asection *) NULL;
if ((hdr->s_flags & STYP_TEXT) || (hdr->s_flags & STYP_DATA))
return_section->flags = (SEC_LOAD | SEC_ALLOC);
else if (hdr->s_flags & STYP_BSS)
return_section->flags = SEC_ALLOC;
if (hdr->s_nreloc != 0)
return_section->flags |= SEC_RELOC;
if (hdr->s_scnptr != 0)
return_section->flags |= SEC_HAS_CONTENTS;
return true;
}
bfd_target *
ecoff_real_object_p (abfd, nscns, opthdr)
bfd *abfd;
unsigned short nscns, opthdr;
{
struct icofdata *tdata;
char *file_info; /* buffer for all the headers */
long readsize; /* length of file_info */
struct filehdr* filehdr; /* points into file_info */
struct scnhdr *sections; /* points into file_info */
/* OK, now we know the format, read in the filehdr, soi-disant
"optional header", and all the sections.*/
readsize = sizeof(struct filehdr) + opthdr + (nscns * sizeof (struct scnhdr));
file_info = (char*)bfd_alloc (abfd, readsize);
if (file_info == NULL) {
bfd_error = no_memory;
return 0;
}
if (bfd_seek (abfd, 0, false) < 0) return 0;
if (bfd_read (file_info, 1, readsize, abfd) != readsize) return 0;
filehdr = (struct filehdr *) file_info;
sections = (struct scnhdr *) (file_info + sizeof (struct filehdr) + opthdr);
/* Now copy data as required; construct all asections etc */
tdata = (struct icofdata *) bfd_zalloc (abfd, sizeof (struct icofdata) +
sizeof (AOUTHDR));
if (tdata == NULL) {
bfd_release (abfd, file_info);
bfd_error = no_memory;
return 0;
}
if (nscns != 0)
{
unsigned int i;
for (i = 0; i < nscns; i++)
{
make_a_section_from_file (abfd, sections + i);
}
}
abfd->flags |= HAS_RELOC | HAS_LINENO | HAS_LOCALS;
/* FIXME, the guess should be set by OR-ing info from the sections */
if ((filehdr->f_flags & F_RELFLG) != F_RELFLG) abfd->flags &= ~HAS_RELOC;
if ((filehdr->f_flags & F_EXEC) == F_EXEC) abfd->flags |= EXEC_P;
if ((filehdr->f_flags & F_LNNO) != F_LNNO) abfd->flags &= ~HAS_LINENO;
if ((filehdr->f_flags & F_LSYMS) != F_LSYMS) abfd->flags &= ~HAS_LOCALS;
set_tdata (abfd, tdata);
bfd_get_symcount (abfd) = filehdr->f_nsyms;
if (filehdr->f_nsyms) abfd->flags |= HAS_SYMS;
tdata->sym_filepos = filehdr->f_symptr;
/* FIXME, needs byte swapping */
tdata->hdr = *(struct aouthdr *)(file_info + sizeof (struct filehdr));
tdata->symbols = (coff_symbol_type *)NULL;
bfd_get_start_address (abfd) = exec_hdr (abfd).entry;
return abfd->xvec;
}
bfd_target *
ecoff_object_p (abfd)
bfd *abfd;
{
unsigned char short_bytes[SHORT_SIZE];
unsigned short magic, nscns, opthdr;
bfd_error = no_error;
/* figure out how much to read */
if (bfd_read ((PTR)short_bytes, 1, SHORT_SIZE, abfd) != SHORT_SIZE)
return 0;
magic = bfd_h_getshort (abfd, short_bytes);
if (magic != (abfd->xvec->byteorder_big_p ? 0x160 : 0x162)) {
bfd_error = wrong_format;
return 0;
}
if (bfd_read ((PTR)short_bytes, 1, SHORT_SIZE, abfd) != SHORT_SIZE)
return 0;
nscns = bfd_h_getshort (abfd, short_bytes);
if (bfd_seek (abfd,(file_ptr) ((sizeof (long)) * 3), true) < 0)
return 0;
if (bfd_read ((PTR)short_bytes, 1, SHORT_SIZE, abfd) != SHORT_SIZE)
return 0;
opthdr = bfd_h_getshort (abfd, short_bytes);
return ecoff_real_object_p (abfd, nscns, opthdr);
}
static boolean
ecoff_mkobject (abfd)
bfd *abfd;
{
char *rawptr;
bfd_error = no_error;
/* Use an intermediate variable for clarity */
rawptr = (char*)bfd_zalloc (abfd, sizeof (struct icofdata));
if (rawptr == NULL) {
bfd_error = no_memory;
return false;
}
set_tdata (abfd, rawptr);
return true;
}
void
ecoff_write_linenumbers(ignore_abfd)
bfd *ignore_abfd;
{
}
static asymbol *
ecoff_make_empty_symbol(abfd)
bfd *abfd;
{
coff_symbol_type *new = (coff_symbol_type *) bfd_alloc(abfd, sizeof(coff_symbol_type));
if (new == NULL) {
bfd_error = no_memory;
return (NULL);
} /* on error */
new->native = 0;
new->lineno = (alent *) NULL;
new->symbol.the_bfd = abfd;
return &new->symbol;
}
/*SUPPRESS 558*/
/*SUPPRESS 529*/
boolean
ecoff_write_object_contents (ignore_abfd)
bfd *ignore_abfd;
{
return false;
}
/* Calculate the file position for each section. */
/* ARGSUSED */
boolean
ecoff_set_section_contents (abfd, section, location, offset, count)
bfd *abfd;
sec_ptr section;
unsigned char *location;
file_ptr offset;
int count;
{
return false;
}
/* ARGSUSED */
boolean
ecoff_set_section_linenos (abfd, section, location, offset, count)
bfd *abfd;
sec_ptr section;
unsigned char *location;
file_ptr offset;
int count;
{
return 0;
}
/* ARGSUSED */
static boolean
ecoff_slurp_symbol_table(abfd)
bfd *abfd;
{
abort();
}
unsigned int
ecoff_get_symtab_upper_bound (abfd)
bfd *abfd;
{
if (!ecoff_slurp_symbol_table (abfd)) return 0;
return (bfd_get_symcount (abfd)+1) * (sizeof (coff_symbol_type *));
}
unsigned int
ecoff_get_symtab(abfd, alocation)
bfd *abfd;
asymbol **alocation;
{
unsigned int counter = 0;
coff_symbol_type *symbase;
coff_symbol_type **location = (coff_symbol_type **)(alocation);
if (!ecoff_slurp_symbol_table (abfd)) return 0;
for (symbase = obj_symbols (abfd); counter++ < bfd_get_symcount (abfd);)
*(location++) = symbase++;
*location++ =0;
return counter;
}
unsigned int
ecoff_get_reloc_upper_bound (abfd, asect)
bfd *abfd;
sec_ptr asect;
{
if (bfd_get_format (abfd) != bfd_object) {
bfd_error = invalid_operation;
return 0;
}
return (asect->reloc_count + 1) * sizeof(arelent *);
}
/* ARGSUSED */
boolean
ecoff_slurp_reloc_table (abfd, asect)
bfd *abfd;
sec_ptr asect;
{
abort();
}
/* This is stupid. This function should be a boolean predicate */
unsigned int
ecoff_canonicalize_reloc (abfd, section, relptr)
bfd *abfd;
sec_ptr section;
arelent **relptr;
{
return 0;
}
boolean
ecoff_get_section_contents (abfd, section, location, offset, count)
bfd *abfd;
sec_ptr section;
PTR location;
file_ptr offset;
int count;
{
if (count) {
if (offset >= section->size) return false;
bfd_seek (abfd, section->filepos + offset, SEEK_SET);
return (bfd_read (location, 1, count, abfd) == count) ? true:false;
}
else return true;
}
/* ARGSUSED */
alent *
ecoff_get_lineno(ignore_abfd, ignore_symbol)
bfd *ignore_abfd;
PTR ignore_symbol;
{
return (alent *)NULL;
}
#define ecoff_core_file_failing_command _bfd_dummy_core_file_failing_command
#define ecoff_core_file_failing_signal _bfd_dummy_core_file_failing_signal
#define ecoff_core_file_matches_executable_p _bfd_dummy_core_file_matches_executable_p
/* Archives not supported yet. FIXME. */
#define ecoff_slurp_armap bfd_false
#define ecoff_slurp_extended_name_table bfd_false
#define ecoff_truncate_arname bfd_dont_truncate_arname
#define ecoff_write_armap bfd_false
#define ecoff_openr_next_archived_file bfd_generic_openr_next_archived_file
#define ecoff_generic_stat_arch_elt bfd_generic_stat_arch_elt
/* Unimplemented routines. FIXME. */
#define ecoff_print_symbol bfd_void
#define ecoff_set_arch_mach bfd_false
#define ecoff_find_nearest_line bfd_false
#define ecoff_sizeof_headers bfd_0
/* We use the generic BFD version of these. */
#define ecoff_close_and_cleanup bfd_generic_close_and_cleanup
#define BADMAG(x) ECOFFBADMAG(x)
#include "coff-code.h"
bfd_target ecoff_little_vec =
{"ecoff-littlemips", /* name */
bfd_target_coff_flavour_enum,
@ -398,12 +53,12 @@ bfd_target ecoff_little_vec =
_do_getllong, _do_putllong, _do_getlshort, _do_putlshort, /* data */
_do_getllong, _do_putllong, _do_getlshort, _do_putlshort, /* hdrs */
{_bfd_dummy_target, ecoff_object_p, /* bfd_check_format */
{_bfd_dummy_target, coff_object_p, /* bfd_check_format */
bfd_generic_archive_p, _bfd_dummy_target},
{bfd_false, ecoff_mkobject, bfd_false, /* bfd_set_format */
{bfd_false, coff_mkobject, bfd_false, /* bfd_set_format */
bfd_false},
{bfd_false, ecoff_write_object_contents, bfd_false, bfd_false},
JUMP_TABLE (ecoff)
{bfd_false, coff_write_object_contents, bfd_false, bfd_false},
JUMP_TABLE (coff)
};
bfd_target ecoff_big_vec =
@ -422,11 +77,11 @@ bfd_target ecoff_big_vec =
_do_getblong, _do_putblong, _do_getbshort, _do_putbshort, /* data */
_do_getblong, _do_putblong, _do_getbshort, _do_putbshort, /* hdrs */
{_bfd_dummy_target, ecoff_object_p, /* bfd_check_format */
{_bfd_dummy_target, coff_object_p, /* bfd_check_format */
bfd_generic_archive_p, _bfd_dummy_target},
{bfd_false, ecoff_mkobject, bfd_false, /* bfd_set_format */
{bfd_false, coff_mkobject, bfd_false, /* bfd_set_format */
bfd_false},
{bfd_false, ecoff_write_object_contents, /* bfd_write_contents */
{bfd_false, coff_write_object_contents, /* bfd_write_contents */
bfd_false, bfd_false},
JUMP_TABLE(ecoff)
JUMP_TABLE(coff)
};

2
bfd/libcoff.h
View File

@ -46,7 +46,7 @@ typedef struct {
typedef struct icofdata
{
struct aouthdr hdr; /* exec file header */
/* struct internal_aouthdr hdr; /* exec file header */
coff_symbol_type *symbols; /* symtab for input bfd */
unsigned int *conversion_table;
file_ptr sym_filepos;

30
bfd/oasys.c
View File

@ -214,22 +214,23 @@ DEFUN(oasys_archive_p,(abfd),
bfd *abfd)
{
oasys_archive_header_type header;
oasys_external_archive_header_type header_ext;
unsigned int i;
bfd_seek(abfd, (file_ptr) 0, false);
bfd_read((PTR)&header, 1, sizeof(header), abfd);
bfd_read((PTR)&header_ext, 1, sizeof(header_ext), abfd);
swap(header.version);
swap(header.mod_count);
swap(header.mod_tbl_offset);
swap(header.sym_tbl_size);
swap(header.sym_count);
swap(header.sym_tbl_offset);
swap(header.xref_count);
swap(header.xref_lst_offset);
header.version = bfd_h_get_x(abfd, header_ext.version);
header.mod_count = bfd_h_get_x(abfd, header_ext.mod_count);
header.mod_tbl_offset = bfd_h_get_x(abfd, header_ext.mod_tbl_offset);
header.sym_tbl_size = bfd_h_get_x(abfd, header_ext.sym_tbl_size);
header.sym_count = bfd_h_get_x(abfd, header_ext.sym_count);
header.sym_tbl_offset = bfd_h_get_x(abfd, header_ext.sym_tbl_offset);
header.xref_count = bfd_h_get_x(abfd, header_ext.xref_count);
header.xref_lst_offset = bfd_h_get_x(abfd, header_ext.xref_lst_offset);
/*
There isn't a magic number in an Oasys archive, so the best we
@ -256,6 +257,7 @@ DEFUN(oasys_archive_p,(abfd),
bfd_alloc(abfd, sizeof(oasys_module_info_type) * header.mod_count);
oasys_module_table_type record;
oasys_external_module_table_type record_ext;
set_tdata(abfd, ar);
ar->module = module;
@ -263,10 +265,12 @@ DEFUN(oasys_archive_p,(abfd),
bfd_seek(abfd , header.mod_tbl_offset, SEEK_SET);
for (i = 0; i < header.mod_count; i++) {
bfd_read((PTR)&record, 1, sizeof(record), abfd);
swap(record.mod_size);
swap(record.file_offset);
swap(record.mod_name_length);
bfd_read((PTR)&record_ext, 1, sizeof(record_ext), abfd);
record.mod_size = bfd_h_get_x(abfd, record_ext.mod_size);
record.file_offset = bfd_h_get_x(abfd, record_ext.file_offset);
record.mod_name_length = bfd_h_get_x(abfd, record_ext.mod_name_length);
module[i].name = bfd_alloc(abfd,record.mod_name_length+1);
bfd_read(module[i].name, 1, record.mod_name_length +1, abfd);