*** empty log message ***
This commit is contained in:
parent
22ddf9bcc5
commit
8e3c8f4755
10
bfd/aout.c
10
bfd/aout.c
|
@ -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
1322
bfd/coff-code.h
File diff suppressed because it is too large
Load Diff
|
@ -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;
|
||||
|
|
|
@ -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
365
bfd/coff-mips.c
|
@ -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)
|
||||
};
|
||||
|
|
|
@ -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
88
bfd/oasys.c
|
@ -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;
|
||||
}
|
||||
|
||||
|
|
Loading…
Reference in New Issue