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 */ /* run through the table and byte swap if needed */
for (sym_pointer = syms; sym_pointer < sym_end; sym_pointer++) { for (sym_pointer = syms; sym_pointer < sym_end; sym_pointer++) {
sym_pointer->n_un.n_strx = 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 = 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 = 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) 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) 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 */ /* Run through table and copy values */

1322
bfd/coff-code.h
View File

File diff suppressed because it is too large Load Diff

12
bfd/coff-i960.c
View File

@ -62,24 +62,24 @@ asection *ignore_input_section;
result = bfd_reloc_dangerous; result = bfd_reloc_dangerous;
} }
else { else {
switch (bfd_h_get_x(abfd, & cs->native->n_sclass)) switch (cs->native->n_sclass)
{ {
case C_LEAFSTAT: case C_LEAFSTAT:
case C_LEAFEXT: case C_LEAFEXT:
/* This is a call to a leaf procedure, replace instruction with a bal /* This is a call to a leaf procedure, replace instruction with a bal
to the correct location */ 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); 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 */ /* We replace the original call instruction with a bal to */
/* the bal entry point - the offset of which is described in the */ /* the bal entry point - the offset of which is described in the */
/* 2nd auxent of the original symbol. We keep the native sym and */ /* 2nd auxent of the original symbol. We keep the native sym and */
/* auxents untouched, so the delta between the two is the */ /* auxents untouched, so the delta between the two is the */
/* offset of the bal entry point */ /* 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))) word = ((word + olf) & BAL_MASK) | BAL;
& BAL_MASK) | BAL;
bfd_putlong(abfd, word, data+reloc_entry->address); bfd_putlong(abfd, word, data+reloc_entry->address);
} }
result = bfd_reloc_ok; 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_generic_archive_p, _bfd_dummy_target},
{bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */ {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
bfd_false}, bfd_false},
{bfd_false, coff_write_object_contents, /* bfd_write_contents */
_bfd_write_archive_contents, bfd_false},
JUMP_TABLE(coff) 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 "intel-coff.h"
#include "libcoff.h" /* to allow easier abstraction-breaking */ #include "libcoff.h" /* to allow easier abstraction-breaking */
/* initialize a section structure with information #define BADMAG(x) ECOFFBADMAG(x)
* 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
#include "coff-code.h"
bfd_target ecoff_little_vec = bfd_target ecoff_little_vec =
{"ecoff-littlemips", /* name */ {"ecoff-littlemips", /* name */
bfd_target_coff_flavour_enum, 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, /* data */
_do_getllong, _do_putllong, _do_getlshort, _do_putlshort, /* hdrs */ _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_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},
{bfd_false, ecoff_write_object_contents, bfd_false, bfd_false}, {bfd_false, coff_write_object_contents, bfd_false, bfd_false},
JUMP_TABLE (ecoff) JUMP_TABLE (coff)
}; };
bfd_target ecoff_big_vec = 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, /* data */
_do_getblong, _do_putblong, _do_getbshort, _do_putbshort, /* hdrs */ _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_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},
{bfd_false, ecoff_write_object_contents, /* bfd_write_contents */ {bfd_false, coff_write_object_contents, /* bfd_write_contents */
bfd_false, bfd_false}, 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 typedef struct icofdata
{ {
struct aouthdr hdr; /* exec file header */ /* struct internal_aouthdr hdr; /* exec file header */
coff_symbol_type *symbols; /* symtab for input bfd */ coff_symbol_type *symbols; /* symtab for input bfd */
unsigned int *conversion_table; unsigned int *conversion_table;
file_ptr sym_filepos; file_ptr sym_filepos;

88
bfd/oasys.c
View File

@ -214,28 +214,29 @@ DEFUN(oasys_archive_p,(abfd),
bfd *abfd) bfd *abfd)
{ {
oasys_archive_header_type header; oasys_archive_header_type header;
oasys_external_archive_header_type header_ext;
unsigned int i; unsigned int i;
bfd_seek(abfd, (file_ptr) 0, false); 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); header.version = bfd_h_get_x(abfd, header_ext.version);
swap(header.mod_count); header.mod_count = bfd_h_get_x(abfd, header_ext.mod_count);
swap(header.mod_tbl_offset); header.mod_tbl_offset = bfd_h_get_x(abfd, header_ext.mod_tbl_offset);
swap(header.sym_tbl_size); header.sym_tbl_size = bfd_h_get_x(abfd, header_ext.sym_tbl_size);
swap(header.sym_count); header.sym_count = bfd_h_get_x(abfd, header_ext.sym_count);
swap(header.sym_tbl_offset); header.sym_tbl_offset = bfd_h_get_x(abfd, header_ext.sym_tbl_offset);
swap(header.xref_count); header.xref_count = bfd_h_get_x(abfd, header_ext.xref_count);
swap(header.xref_lst_offset); 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 There isn't a magic number in an Oasys archive, so the best we
can do to verify reasnableness is to make sure that the values in can do to verify reasnableness is to make sure that the values in
the header are too weird the header are too weird
*/ */
if (header.version>10000 || if (header.version>10000 ||
header.mod_count>10000 || header.mod_count>10000 ||
@ -243,42 +244,45 @@ DEFUN(oasys_archive_p,(abfd),
header.xref_count > 100000) return (bfd_target *)NULL; header.xref_count > 100000) return (bfd_target *)NULL;
/* /*
That all worked, lets buy the space for the header and read in That all worked, lets buy the space for the header and read in
the headers. the headers.
*/ */
{ {
oasys_ar_data_type *ar = oasys_ar_data_type *ar =
(oasys_ar_data_type*) bfd_alloc(abfd, sizeof(oasys_ar_data_type)); (oasys_ar_data_type*) bfd_alloc(abfd, sizeof(oasys_ar_data_type));
oasys_module_info_type *module = oasys_module_info_type *module =
(oasys_module_info_type*) (oasys_module_info_type*)
bfd_alloc(abfd, sizeof(oasys_module_info_type) * header.mod_count); bfd_alloc(abfd, sizeof(oasys_module_info_type) * header.mod_count);
oasys_module_table_type record; oasys_module_table_type record;
oasys_external_module_table_type record_ext;
set_tdata(abfd, ar); set_tdata(abfd, ar);
ar->module = module; ar->module = module;
ar->module_count = header.mod_count; ar->module_count = header.mod_count;
bfd_seek(abfd , header.mod_tbl_offset, SEEK_SET); bfd_seek(abfd , header.mod_tbl_offset, SEEK_SET);
for (i = 0; i < header.mod_count; i++) { for (i = 0; i < header.mod_count; i++) {
bfd_read((PTR)&record, 1, sizeof(record), abfd); bfd_read((PTR)&record_ext, 1, sizeof(record_ext), abfd);
swap(record.mod_size);
swap(record.file_offset); record.mod_size = bfd_h_get_x(abfd, record_ext.mod_size);
swap(record.mod_name_length); record.file_offset = bfd_h_get_x(abfd, record_ext.file_offset);
module[i].name = bfd_alloc(abfd,record.mod_name_length+1); record.mod_name_length = bfd_h_get_x(abfd, record_ext.mod_name_length);
bfd_read(module[i].name, 1, record.mod_name_length +1, abfd); module[i].name = bfd_alloc(abfd,record.mod_name_length+1);
/* SKip some stuff */
bfd_seek(abfd, record.dep_count * sizeof(int32_type),
SEEK_CUR);
module[i].size = record.mod_size; bfd_read(module[i].name, 1, record.mod_name_length +1, abfd);
module[i].pos = record.file_offset; /* SKip some stuff */
} bfd_seek(abfd, record.dep_count * sizeof(int32_type),
SEEK_CUR);
module[i].size = record.mod_size;
module[i].pos = record.file_offset;
}
} }
return abfd->xvec; return abfd->xvec;
} }