darkkirb/old-cross-binutils
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages 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
Show stats 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 */

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;
}
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;

88
bfd/oasys.c
View file

@ -214,28 +214,29 @@ 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
can do to verify reasnableness is to make sure that the values in
the header are too weird
*/
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
the header are too weird
*/
if (header.version>10000 ||
header.mod_count>10000 ||
@ -243,42 +244,45 @@ DEFUN(oasys_archive_p,(abfd),
header.xref_count > 100000) return (bfd_target *)NULL;
/*
That all worked, lets buy the space for the header and read in
the headers.
*/
{
oasys_ar_data_type *ar =
(oasys_ar_data_type*) bfd_alloc(abfd, sizeof(oasys_ar_data_type));
That all worked, lets buy the space for the header and read in
the headers.
*/
{
oasys_ar_data_type *ar =
(oasys_ar_data_type*) bfd_alloc(abfd, sizeof(oasys_ar_data_type));
oasys_module_info_type *module =
(oasys_module_info_type*)
bfd_alloc(abfd, sizeof(oasys_module_info_type) * header.mod_count);
oasys_module_info_type *module =
(oasys_module_info_type*)
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);
ar->module = module;
ar->module_count = header.mod_count;
set_tdata(abfd, ar);
ar->module = module;
ar->module_count = header.mod_count;
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);
module[i].name = bfd_alloc(abfd,record.mod_name_length+1);
bfd_seek(abfd , header.mod_tbl_offset, SEEK_SET);
for (i = 0; i < header.mod_count; i++) {
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);
bfd_read(module[i].name, 1, record.mod_name_length +1, abfd);
/* SKip some stuff */
bfd_seek(abfd, record.dep_count * sizeof(int32_type),
SEEK_CUR);
module[i].name = bfd_alloc(abfd,record.mod_name_length+1);
module[i].size = record.mod_size;
module[i].pos = record.file_offset;
}
bfd_read(module[i].name, 1, record.mod_name_length +1, abfd);
/* 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;
}