1025 lines
24 KiB
C
1025 lines
24 KiB
C
/*#define UNDERSCORE_HACK 0*/
|
||
/*
|
||
|
||
bfd backend for oasys objects.
|
||
|
||
|
||
Object files contain records in order:
|
||
|
||
optional header
|
||
symbol records
|
||
section records
|
||
data records
|
||
debugging records
|
||
end record
|
||
|
||
|
||
|
||
Written by Steve Chamberlain
|
||
steve@cygnus.com
|
||
|
||
|
||
|
||
*/
|
||
|
||
|
||
#include <ansidecl.h>
|
||
#include "sysdep.h"
|
||
#include "bfd.h"
|
||
#include "libbfd.h"
|
||
#include "obstack.h"
|
||
#include "oasys.h"
|
||
#include "liboasys.h"
|
||
|
||
|
||
|
||
#define obstack_chunk_alloc malloc
|
||
#define obstack_chunk_free free
|
||
|
||
typedef void generic_symbol_type;
|
||
|
||
|
||
void DEFUN(oasys_read_record,(abfd, record),
|
||
bfd *abfd AND
|
||
oasys_record_union_type *record)
|
||
{
|
||
|
||
bfd_read(record, 1, sizeof(record->header), abfd);
|
||
|
||
bfd_read(((char *)record )+ sizeof(record->header),
|
||
1, record->header.length - sizeof(record->header),
|
||
abfd);
|
||
}
|
||
static size_t
|
||
oasys_string_length(record)
|
||
oasys_record_union_type *record;
|
||
{
|
||
return record->header.length
|
||
- ((char *)record->symbol.name - (char *)record);
|
||
}
|
||
|
||
/*****************************************************************************/
|
||
|
||
/*
|
||
|
||
Slurp the symbol table by reading in all the records at the start file
|
||
till we get to the first section record.
|
||
|
||
We'll sort the symbols into two lists, defined and undefined. The
|
||
undefined symbols will also be sorted by refno. We do this by placing
|
||
all undefined symbols at the front of the table moving in, and the
|
||
defined symbols at the end of the table moving back.
|
||
|
||
*/
|
||
|
||
static boolean
|
||
oasys_slurp_symbol_table(abfd)
|
||
bfd *abfd;
|
||
{
|
||
oasys_record_union_type record;
|
||
oasys_data_type *data = oasys_data(abfd);
|
||
boolean loop = true;
|
||
asymbol *dest_undefined;
|
||
asymbol *dest_defined;
|
||
asymbol *dest;
|
||
char *string_ptr;
|
||
|
||
|
||
if (data->symbols != (asymbol *)NULL) {
|
||
return true;
|
||
}
|
||
/* Buy enough memory for all the symbols and all the names */
|
||
data->symbols =
|
||
(asymbol *)malloc(sizeof(asymbol) * abfd->symcount);
|
||
#ifdef UNDERSCORE_HACK
|
||
/* buy 1 more char for each symbol to keep the underscore in*/
|
||
data->strings = malloc(data->symbol_string_length +
|
||
abfd->symcount);
|
||
#else
|
||
data->strings = malloc(data->symbol_string_length);
|
||
#endif
|
||
|
||
dest_undefined = data->symbols;
|
||
dest_defined = data->symbols + abfd->symcount -1;
|
||
|
||
string_ptr = data->strings;
|
||
bfd_seek(abfd, (file_ptr)0, SEEK_SET);
|
||
while (loop) {
|
||
|
||
oasys_read_record(abfd, &record);
|
||
switch (record.header.type) {
|
||
case oasys_record_is_header_enum:
|
||
break;
|
||
case oasys_record_is_local_enum:
|
||
case oasys_record_is_symbol_enum:
|
||
{
|
||
int flag = record.header.type == oasys_record_is_local_enum ?
|
||
(BSF_LOCAL) : (BSF_GLOBAL | BSF_EXPORT);
|
||
|
||
|
||
size_t length = oasys_string_length(&record);
|
||
switch (record.symbol.relb[0] & RELOCATION_TYPE_BITS) {
|
||
case RELOCATION_TYPE_ABS:
|
||
dest = dest_defined--;
|
||
dest->section = 0;
|
||
dest->flags = BSF_ABSOLUTE | flag;
|
||
break;
|
||
case RELOCATION_TYPE_REL:
|
||
dest = dest_defined--;
|
||
dest->section =
|
||
oasys_data(abfd)->sections[record.symbol.relb[0] &
|
||
RELOCATION_SECT_BITS];
|
||
if (record.header.type == oasys_record_is_local_enum)
|
||
{
|
||
dest->flags = BSF_LOCAL;
|
||
}
|
||
else {
|
||
|
||
dest->flags = flag;
|
||
}
|
||
break;
|
||
case RELOCATION_TYPE_UND:
|
||
dest = dest_undefined++;
|
||
dest->section = (asection *)NULL;
|
||
dest->flags = BSF_UNDEFINED;
|
||
break;
|
||
case RELOCATION_TYPE_COM:
|
||
dest = dest_defined--;
|
||
dest->name = string_ptr;
|
||
dest->the_bfd = abfd;
|
||
|
||
dest->section = (asection *)NULL;
|
||
dest->flags = BSF_FORT_COMM;
|
||
break;
|
||
}
|
||
dest->name = string_ptr;
|
||
dest->the_bfd = abfd;
|
||
dest->udata = (void *)NULL;
|
||
dest->value = bfd_h_getlong(abfd, &record.symbol.value);
|
||
#if UNDERSCORE_HACK
|
||
string_ptr[0] = '_';
|
||
string_ptr++;
|
||
#endif
|
||
memcpy(string_ptr, record.symbol.name, length);
|
||
|
||
|
||
string_ptr[length] =0;
|
||
string_ptr += length +1;
|
||
}
|
||
break;
|
||
default:
|
||
loop = false;
|
||
}
|
||
}
|
||
return true;
|
||
|
||
}
|
||
|
||
size_t
|
||
oasys_get_symtab_upper_bound (abfd)
|
||
bfd *abfd;
|
||
{
|
||
oasys_slurp_symbol_table (abfd);
|
||
|
||
return (abfd->symcount+1) * (sizeof (oasys_symbol_type *));
|
||
}
|
||
|
||
/*
|
||
*/
|
||
|
||
extern bfd_target oasys_vec;
|
||
|
||
unsigned int
|
||
oasys_get_symtab (abfd, location)
|
||
bfd *abfd;
|
||
asymbol **location;
|
||
{
|
||
asymbol *symbase ;
|
||
unsigned int counter ;
|
||
if (oasys_slurp_symbol_table(abfd) == false) {
|
||
return 0;
|
||
}
|
||
symbase = oasys_data(abfd)->symbols;
|
||
for (counter = 0; counter < abfd->symcount; counter++) {
|
||
*(location++) = symbase++;
|
||
}
|
||
*location = 0;
|
||
return abfd->symcount;
|
||
}
|
||
|
||
/***********************************************************************
|
||
* archive stuff
|
||
*/
|
||
#define swap(x) x = bfd_h_get_x(abfd, &x);
|
||
bfd_target *
|
||
oasys_archive_p(abfd)
|
||
bfd *abfd;
|
||
{
|
||
oasys_archive_header_type header;
|
||
unsigned int i;
|
||
|
||
bfd_seek(abfd, (file_ptr) 0, false);
|
||
|
||
|
||
bfd_read(&header, 1, sizeof(header), 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);
|
||
|
||
/*
|
||
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 ||
|
||
header.sym_count>100000 ||
|
||
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*) malloc(sizeof(oasys_ar_data_type));
|
||
|
||
|
||
oasys_module_info_type *module =
|
||
(oasys_module_info_type*)
|
||
malloc(sizeof(oasys_module_info_type) * header.mod_count);
|
||
|
||
oasys_module_table_type record;
|
||
|
||
oasys_ar_data(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(&record, 1, sizeof(record), abfd);
|
||
swap(record.mod_size);
|
||
swap(record.file_offset);
|
||
swap(record.mod_name_length);
|
||
module[i].name = malloc(record.mod_name_length+1);
|
||
|
||
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;
|
||
}
|
||
|
||
#define MAX_SECS 16
|
||
bfd_target *
|
||
oasys_object_p (abfd)
|
||
bfd *abfd;
|
||
{
|
||
oasys_data_type *oasys;
|
||
oasys_data_type static_data;
|
||
|
||
boolean loop = true;
|
||
|
||
|
||
boolean had_usefull = false;
|
||
|
||
memset((PTR)static_data.sections, 0xff, sizeof(static_data.sections));
|
||
|
||
/* Point to the start of the file */
|
||
bfd_seek(abfd, (file_ptr)0, SEEK_SET);
|
||
static_data.symbol_string_length = 0;
|
||
/* Inspect the records, but only keep the section info -
|
||
remember the size of the symbols
|
||
*/
|
||
static_data.first_data_record = 0;
|
||
while (loop) {
|
||
|
||
oasys_record_union_type record;
|
||
oasys_read_record(abfd, &record);
|
||
if (record.header.length < sizeof(record.header))
|
||
return (bfd_target *)NULL;
|
||
|
||
switch ((oasys_record_enum_type)(record.header.type)) {
|
||
case oasys_record_is_header_enum:
|
||
had_usefull = true;
|
||
break;
|
||
case oasys_record_is_symbol_enum:
|
||
case oasys_record_is_local_enum:
|
||
/* Count symbols and remember their size for a future malloc */
|
||
abfd->symcount++;
|
||
static_data.symbol_string_length += 1 + oasys_string_length(&record);
|
||
had_usefull = true;
|
||
break;
|
||
case oasys_record_is_section_enum:
|
||
{
|
||
asection *s;
|
||
char *buffer;
|
||
unsigned int section_number;
|
||
if (record.section.header.length != sizeof(record.section))
|
||
{
|
||
return (bfd_target *)NULL;
|
||
}
|
||
buffer = malloc(3);
|
||
section_number= record.section.relb & RELOCATION_SECT_BITS;
|
||
sprintf(buffer,"%u", section_number);
|
||
s = bfd_make_section(abfd,buffer);
|
||
static_data.sections[section_number] = s;
|
||
switch (record.section.relb & RELOCATION_TYPE_BITS) {
|
||
case RELOCATION_TYPE_ABS:
|
||
case RELOCATION_TYPE_REL:
|
||
break;
|
||
case RELOCATION_TYPE_UND:
|
||
case RELOCATION_TYPE_COM:
|
||
BFD_FAIL();
|
||
}
|
||
|
||
|
||
s->size = bfd_h_getlong(abfd, & record.section.value) ;
|
||
s->vma = bfd_h_getlong(abfd, &record.section.vma);
|
||
s->flags |= SEC_LOAD | SEC_HAS_CONTENTS;
|
||
had_usefull = true;
|
||
}
|
||
break;
|
||
case oasys_record_is_data_enum:
|
||
static_data.first_data_record = bfd_tell(abfd) - record.header.length;
|
||
case oasys_record_is_debug_enum:
|
||
case oasys_record_is_module_enum:
|
||
case oasys_record_is_named_section_enum:
|
||
case oasys_record_is_end_enum:
|
||
if (had_usefull == false) return (bfd_target *)NULL;
|
||
loop = false;
|
||
break;
|
||
default:
|
||
return (bfd_target *)NULL;
|
||
}
|
||
}
|
||
oasys_data(abfd) = (oasys_data_type
|
||
*)malloc(sizeof(oasys_data_type));
|
||
oasys = oasys_data(abfd);
|
||
* oasys = static_data;
|
||
|
||
oasys->symbols = (asymbol *)NULL;
|
||
/*
|
||
Oasys support several architectures, but I can't see a simple way
|
||
to discover which one is in a particular file - we'll guess
|
||
*/
|
||
abfd->obj_arch = bfd_arch_m68k;
|
||
abfd->obj_machine =0;
|
||
if (abfd->symcount != 0) {
|
||
abfd->flags |= HAS_SYMS;
|
||
}
|
||
return abfd->xvec;
|
||
}
|
||
|
||
|
||
void
|
||
oasys_print_symbol(ignore_abfd, file, symbol, how)
|
||
bfd *ignore_abfd;
|
||
FILE *file;
|
||
asymbol *symbol;
|
||
bfd_print_symbol_enum_type how;
|
||
{
|
||
switch (how) {
|
||
case bfd_print_symbol_name_enum:
|
||
case bfd_print_symbol_type_enum:
|
||
fprintf(file,"%s", symbol->name);
|
||
break;
|
||
case bfd_print_symbol_all_enum:
|
||
{
|
||
char *section_name = symbol->section == (asection *)NULL ?
|
||
"*abs" : symbol->section->name;
|
||
|
||
bfd_print_symbol_vandf((void *)file,symbol);
|
||
|
||
fprintf(file," %-5s %s",
|
||
section_name,
|
||
symbol->name);
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
/*
|
||
The howto table is build using the top two bits of a reloc byte to
|
||
index into it. The bits are PCREL,WORD/LONG
|
||
*/
|
||
static reloc_howto_type howto_table[]=
|
||
{
|
||
/* T rs size bsz pcrel bitpos abs ovr sf name partial inplace mask */
|
||
|
||
{ 0, 0, 1, 16, false,0, true,true,0,"abs16",true,0x0000ffff},
|
||
{ 0, 0, 2, 32, false,0, true,true,0,"abs32",true,0xffffffff},
|
||
{ 0, 0, 1, 16, true,0, true,true,0,"pcrel16",true,0x0000ffff},
|
||
{ 0, 0, 2, 32, true,0, true,true,0,"pcrel32",true,0xffffffff}
|
||
};
|
||
|
||
/* Read in all the section data and relocation stuff too */
|
||
static boolean oasys_slurp_section_data(abfd)
|
||
bfd *abfd;
|
||
{
|
||
oasys_record_union_type record;
|
||
oasys_data_type *data = oasys_data(abfd);
|
||
boolean loop = true;
|
||
|
||
oasys_per_section_type *per ;
|
||
|
||
asection *s;
|
||
|
||
/* Buy enough memory for all the section data and relocations */
|
||
for (s = abfd->sections; s != (asection *)NULL; s= s->next) {
|
||
per = oasys_per_section(s);
|
||
if (per->data != (bfd_byte*)NULL) return true;
|
||
per->data = (bfd_byte *) malloc(s->size);
|
||
obstack_init(&per->reloc_obstack);
|
||
per->reloc_tail_ptr = (oasys_reloc_type **)&(s->relocation);
|
||
}
|
||
|
||
if (data->first_data_record == 0) return true;
|
||
bfd_seek(abfd, data->first_data_record, SEEK_SET);
|
||
while (loop) {
|
||
oasys_read_record(abfd, &record);
|
||
switch (record.header.type) {
|
||
case oasys_record_is_header_enum:
|
||
break;
|
||
case oasys_record_is_data_enum:
|
||
{
|
||
|
||
uint8e_type *src = record.data.data;
|
||
uint8e_type *end_src = ((uint8e_type *)&record) +
|
||
record.header.length;
|
||
unsigned int relbit;
|
||
bfd_byte *dst_ptr ;
|
||
bfd_byte *dst_base_ptr ;
|
||
asection *section;
|
||
unsigned int count;
|
||
|
||
bfd_vma dst_offset = bfd_h_getlong(abfd, record.data.addr);
|
||
section = data->sections[record.data.relb & RELOCATION_SECT_BITS];
|
||
per = oasys_per_section(section);
|
||
dst_base_ptr = oasys_per_section(section)->data;
|
||
dst_ptr = oasys_per_section(section)->data +
|
||
dst_offset;
|
||
|
||
while (src < end_src) {
|
||
uint32_type gap = end_src - src -1;
|
||
uint8e_type mod_byte = *src++;
|
||
count = 8;
|
||
if (mod_byte == 0 && gap >= 8) {
|
||
dst_ptr[0] = src[0];
|
||
dst_ptr[1] = src[1];
|
||
dst_ptr[2] = src[2];
|
||
dst_ptr[3] = src[3];
|
||
dst_ptr[4] = src[4];
|
||
dst_ptr[5] = src[5];
|
||
dst_ptr[6] = src[6];
|
||
dst_ptr[7] = src[7];
|
||
dst_ptr+= 8;
|
||
src += 8;
|
||
}
|
||
else {
|
||
for (relbit = 1; count-- != 0 && gap != 0; gap --, relbit <<=1)
|
||
{
|
||
if (relbit & mod_byte)
|
||
{
|
||
uint8e_type reloc = *src;
|
||
/* This item needs to be relocated */
|
||
switch (reloc & RELOCATION_TYPE_BITS) {
|
||
case RELOCATION_TYPE_ABS:
|
||
|
||
break;
|
||
|
||
case RELOCATION_TYPE_REL:
|
||
{
|
||
/* Relocate the item relative to the section */
|
||
oasys_reloc_type *r =
|
||
(oasys_reloc_type *)
|
||
obstack_alloc(&per->reloc_obstack,
|
||
sizeof(oasys_reloc_type));
|
||
*(per->reloc_tail_ptr) = r;
|
||
per->reloc_tail_ptr = &r->next;
|
||
r->next= (oasys_reloc_type *)NULL;
|
||
/* Reference to undefined symbol */
|
||
src++;
|
||
/* There is no symbol */
|
||
r->symbol = 0;
|
||
/* Work out the howto */
|
||
r->relent.section =
|
||
data->sections[reloc & RELOCATION_SECT_BITS];
|
||
r->relent.addend = 0;
|
||
r->relent.address = dst_ptr - dst_base_ptr;
|
||
r->relent.howto = &howto_table[reloc>>6];
|
||
r->relent.sym_ptr_ptr = (asymbol **)NULL;
|
||
section->reloc_count++;
|
||
|
||
}
|
||
break;
|
||
|
||
|
||
case RELOCATION_TYPE_UND:
|
||
{
|
||
oasys_reloc_type *r =
|
||
(oasys_reloc_type *)
|
||
obstack_alloc(&per->reloc_obstack,
|
||
sizeof(oasys_reloc_type));
|
||
*(per->reloc_tail_ptr) = r;
|
||
per->reloc_tail_ptr = &r->next;
|
||
r->next= (oasys_reloc_type *)NULL;
|
||
/* Reference to undefined symbol */
|
||
src++;
|
||
/* Get symbol number */
|
||
r->symbol = (src[0]<<8) | src[1];
|
||
/* Work out the howto */
|
||
r->relent.section = (asection *)NULL;
|
||
r->relent.addend = 0;
|
||
r->relent.address = dst_ptr - dst_base_ptr;
|
||
r->relent.howto = &howto_table[reloc>>6];
|
||
r->relent.sym_ptr_ptr = (asymbol **)NULL;
|
||
|
||
section->reloc_count++;
|
||
src+=2;
|
||
}
|
||
break;
|
||
case RELOCATION_TYPE_COM:
|
||
BFD_FAIL();
|
||
}
|
||
}
|
||
*dst_ptr++ = *src++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
case oasys_record_is_local_enum:
|
||
case oasys_record_is_symbol_enum:
|
||
case oasys_record_is_section_enum:
|
||
break;
|
||
default:
|
||
loop = false;
|
||
}
|
||
}
|
||
return true;
|
||
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
boolean
|
||
oasys_new_section_hook (abfd, newsect)
|
||
bfd *abfd;
|
||
asection *newsect;
|
||
{
|
||
newsect->used_by_bfd = (oasys_per_section_type *)
|
||
malloc(sizeof(oasys_per_section_type));
|
||
oasys_per_section( newsect)->data = (bfd_byte *)NULL;
|
||
oasys_per_section(newsect)->section = newsect;
|
||
oasys_per_section(newsect)->offset = 0;
|
||
return true;
|
||
}
|
||
|
||
|
||
unsigned int
|
||
oasys_get_reloc_upper_bound (abfd, asect)
|
||
bfd *abfd;
|
||
sec_ptr asect;
|
||
{
|
||
oasys_slurp_section_data(abfd);
|
||
return (asect->reloc_count+1) * sizeof(arelent *);
|
||
}
|
||
|
||
static boolean
|
||
oasys_get_section_contents (abfd, section, location, offset, count)
|
||
bfd *abfd;
|
||
sec_ptr section;
|
||
void *location;
|
||
file_ptr offset;
|
||
unsigned int count;
|
||
{
|
||
oasys_per_section_type *p = section->used_by_bfd;
|
||
oasys_slurp_section_data(abfd);
|
||
(void) memcpy(location, p->data + offset, count);
|
||
return true;
|
||
}
|
||
|
||
|
||
unsigned int
|
||
oasys_canonicalize_reloc (abfd, section, relptr, symbols)
|
||
bfd *abfd;
|
||
sec_ptr section;
|
||
arelent **relptr;
|
||
asymbol **symbols;
|
||
{
|
||
oasys_reloc_type *src = (oasys_reloc_type *)(section->relocation);
|
||
while (src != (oasys_reloc_type *)NULL) {
|
||
if (src->relent.section == (asection *)NULL) {
|
||
src->relent.sym_ptr_ptr = symbols + src->symbol;
|
||
}
|
||
*relptr ++ = &src->relent;
|
||
src = src->next;
|
||
}
|
||
*relptr = (arelent *)NULL;
|
||
return section->reloc_count;
|
||
}
|
||
|
||
boolean
|
||
oasys_set_arch_mach (abfd, arch, machine)
|
||
bfd *abfd;
|
||
enum bfd_architecture arch;
|
||
unsigned long machine;
|
||
{
|
||
abfd->obj_arch = arch;
|
||
abfd->obj_machine = machine;
|
||
return true;
|
||
}
|
||
|
||
boolean
|
||
oasys_mkobject(abfd)
|
||
bfd *abfd;
|
||
{
|
||
oasys_data_type *oasys =
|
||
(oasys_data_type *) malloc(sizeof(oasys_data_type));
|
||
oasys_data(abfd) = oasys;
|
||
if (oasys == (oasys_data_type *)NULL) {
|
||
bfd_error = no_memory;
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
static void
|
||
init_for_output(abfd)
|
||
bfd *abfd;
|
||
{
|
||
asection *s;
|
||
for (s = abfd->sections; s != (asection *)NULL; s = s->next) {
|
||
if (s->size != 0) {
|
||
oasys_per_section(s)->data = (bfd_byte *)(malloc(s->size));
|
||
}
|
||
}
|
||
}
|
||
|
||
/** exec and core file sections */
|
||
|
||
/* set section contents is complicated with OASYS since the format is
|
||
* not a byte image, but a record stream.
|
||
*/
|
||
boolean
|
||
oasys_set_section_contents (abfd, section, location, offset, count)
|
||
bfd *abfd;
|
||
sec_ptr section;
|
||
unsigned char *location;
|
||
file_ptr offset;
|
||
int count;
|
||
{
|
||
if (oasys_per_section(section)->data == (bfd_byte *)NULL) {
|
||
init_for_output(abfd);
|
||
}
|
||
(void) memcpy(oasys_per_section(section)->data + offset, location, count);
|
||
return true;
|
||
}
|
||
|
||
|
||
|
||
|
||
/* Native-level interface to symbols. */
|
||
|
||
/* We read the symbols into a buffer, which is discarded when this
|
||
function exits. We read the strings into a buffer large enough to
|
||
hold them all plus all the cached symbol entries. */
|
||
|
||
asymbol *
|
||
oasys_make_empty_symbol (abfd)
|
||
bfd *abfd;
|
||
{
|
||
|
||
oasys_symbol_type *new =
|
||
(oasys_symbol_type *)zalloc (sizeof (oasys_symbol_type));
|
||
new->symbol.the_bfd = abfd;
|
||
return &new->symbol;
|
||
|
||
}
|
||
|
||
void
|
||
oasys_reclaim_symbol_table (abfd)
|
||
bfd *abfd;
|
||
{
|
||
#if 0
|
||
asection *section;
|
||
|
||
if (!bfd_get_symcount (abfd)) return;
|
||
|
||
for (section = abfd->sections; section != NULL; section = section->next)
|
||
if (section->relocation) {
|
||
free ((void *)section->relocation);
|
||
section->relocation = NULL;
|
||
section->reloc_count = 0;
|
||
}
|
||
|
||
bfd_get_symcount (abfd) = 0;
|
||
free ((void *)obj_aout_symbols (abfd));
|
||
obj_aout_symbols (abfd) = (aout_symbol_type *)NULL;
|
||
#endif
|
||
}
|
||
|
||
|
||
|
||
|
||
/* Obsbolete procedural interface; better to look at the cache directly */
|
||
|
||
/* User should have checked the file flags; perhaps we should return
|
||
BFD_NO_MORE_SYMBOLS if there are none? */
|
||
|
||
int
|
||
oasys_get_symcount_upper_bound (abfd)
|
||
bfd *abfd;
|
||
{
|
||
#if 0
|
||
/* In case we're doing an output file or something...? */
|
||
if (bfd_get_symcount (abfd)) return bfd_get_symcount (abfd);
|
||
|
||
return (exec_hdr (abfd)->a_syms) / (sizeof (struct nlist));
|
||
#endif
|
||
}
|
||
|
||
symindex
|
||
oasys_get_first_symbol (ignore_abfd)
|
||
bfd * ignore_abfd;
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
symindex
|
||
oasys_get_next_symbol (abfd, oidx)
|
||
bfd *abfd;
|
||
symindex oidx;
|
||
{
|
||
#if 0
|
||
if (oidx == BFD_NO_MORE_SYMBOLS) return BFD_NO_MORE_SYMBOLS;
|
||
return ++oidx >= bfd_get_symcount (abfd) ? BFD_NO_MORE_SYMBOLS :
|
||
oidx;
|
||
#endif
|
||
}
|
||
|
||
char *
|
||
oasys_symbol_name (abfd, idx)
|
||
bfd *abfd;
|
||
symindex idx;
|
||
{
|
||
#if 0
|
||
return (obj_aout_symbols (abfd) + idx)->symbol.name;
|
||
#endif
|
||
}
|
||
|
||
long
|
||
oasys_symbol_value (abfd, idx)
|
||
bfd *abfd;
|
||
symindex idx;
|
||
{
|
||
#if 0
|
||
return (obj_aout_symbols (abfd) + idx)->symbol.value;
|
||
#endif
|
||
}
|
||
|
||
symclass
|
||
oasys_classify_symbol (abfd, idx)
|
||
bfd *abfd;
|
||
symindex idx;
|
||
{
|
||
#if 0
|
||
aout_symbol_type *sym = obj_aout_symbols (abfd) + idx;
|
||
|
||
if ((sym->symbol.flags & BSF_FORT_COMM) != 0) return bfd_symclass_fcommon;
|
||
if ((sym->symbol.flags & BSF_GLOBAL) != 0) return bfd_symclass_global;
|
||
if ((sym->symbol.flags & BSF_DEBUGGING) != 0) return bfd_symclass_debugger;
|
||
if ((sym->symbol.flags & BSF_UNDEFINED) != 0) return bfd_symclass_undefined;
|
||
#endif
|
||
return bfd_symclass_unknown;
|
||
}
|
||
|
||
boolean
|
||
oasys_symbol_hasclass (abfd, idx, class)
|
||
bfd *abfd;
|
||
symindex idx;
|
||
symclass class;
|
||
{
|
||
#if 0
|
||
aout_symbol_type *sym = obj_aout_symbols (abfd) + idx;
|
||
switch (class) {
|
||
case bfd_symclass_fcommon:
|
||
return (sym->symbol.flags & BSF_FORT_COMM) ? true :false;
|
||
case bfd_symclass_global:
|
||
return (sym->symbol.flags & BSF_GLOBAL) ? true:false;
|
||
case bfd_symclass_debugger:
|
||
return (sym->symbol.flags & BSF_DEBUGGING) ? true:false;;
|
||
case bfd_symclass_undefined:
|
||
return (sym->symbol.flags & BSF_UNDEFINED) ? true:false;;
|
||
default: return false;
|
||
}
|
||
#endif
|
||
}
|
||
|
||
|
||
void
|
||
oasys_reclaim_reloc (ignore_abfd, section)
|
||
bfd *ignore_abfd;
|
||
sec_ptr section;
|
||
{
|
||
#if 0
|
||
if (section->relocation) {
|
||
free (section->relocation);
|
||
section->relocation = NULL;
|
||
section->reloc_count = 0;
|
||
}
|
||
#endif
|
||
}
|
||
|
||
boolean
|
||
oasys_close_and_cleanup (abfd)
|
||
bfd *abfd;
|
||
{
|
||
if (bfd_read_p (abfd) == false)
|
||
switch (abfd->format) {
|
||
case bfd_archive:
|
||
if (!_bfd_write_archive_contents (abfd)) {
|
||
return false;
|
||
}
|
||
break;
|
||
case bfd_object:
|
||
/* if (!oasys_write_object_contents (abfd)) */{
|
||
return false;
|
||
}
|
||
break;
|
||
default:
|
||
bfd_error = invalid_operation;
|
||
return false;
|
||
}
|
||
|
||
|
||
if (oasys_data(abfd) != (oasys_data_type *)NULL) {
|
||
/* FIXME MORE LEAKS */
|
||
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
static bfd *
|
||
oasys_openr_next_archived_file(arch, prev)
|
||
bfd *arch;
|
||
bfd *prev;
|
||
{
|
||
oasys_ar_data_type *ar = oasys_ar_data(arch);
|
||
oasys_module_info_type *p;
|
||
/* take the next one from the arch state, or reset */
|
||
if (prev == (bfd *)NULL) {
|
||
/* Reset the index - the first two entries are bogus*/
|
||
ar->module_index = 0;
|
||
}
|
||
|
||
p = ar->module + ar->module_index;
|
||
ar->module_index++;
|
||
|
||
if (ar->module_index <= ar->module_count) {
|
||
if (p->abfd == (bfd *)NULL) {
|
||
p->abfd = _bfd_create_empty_archive_element_shell(arch);
|
||
p->abfd->origin = p->pos;
|
||
p->abfd->filename = p->name;
|
||
|
||
/* Fixup a pointer to this element for the member */
|
||
p->abfd->arelt_data = (void *)p;
|
||
}
|
||
return p->abfd;
|
||
}
|
||
else {
|
||
bfd_error = no_more_archived_files;
|
||
return (bfd *)NULL;
|
||
}
|
||
}
|
||
|
||
static boolean
|
||
oasys_find_nearest_line(abfd,
|
||
section,
|
||
symbols,
|
||
offset,
|
||
filename_ptr,
|
||
functionname_ptr,
|
||
line_ptr)
|
||
bfd *abfd;
|
||
asection *section;
|
||
asymbol **symbols;
|
||
bfd_vma offset;
|
||
char **filename_ptr;
|
||
char **functionname_ptr;
|
||
unsigned int *line_ptr;
|
||
{
|
||
return false;
|
||
|
||
}
|
||
|
||
static int
|
||
oasys_stat_arch_elt(abfd, buf)
|
||
bfd *abfd;
|
||
struct stat *buf;
|
||
{
|
||
oasys_module_info_type *mod = abfd->arelt_data;
|
||
if (mod == (oasys_module_info_type *)NULL) {
|
||
bfd_error = invalid_operation;
|
||
return -1;
|
||
}
|
||
else {
|
||
buf->st_size = mod->size;
|
||
buf->st_mode = 0666;
|
||
return 0;
|
||
}
|
||
|
||
|
||
}
|
||
|
||
|
||
/*SUPPRESS 460 */
|
||
bfd_target oasys_vec =
|
||
{
|
||
"oasys", /* name */
|
||
bfd_target_oasys_flavour_enum,
|
||
true, /* target byte order */
|
||
true, /* target headers byte order */
|
||
(HAS_RELOC | EXEC_P | /* object flags */
|
||
HAS_LINENO | HAS_DEBUG |
|
||
HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
|
||
(SEC_CODE|SEC_DATA|SEC_ROM|SEC_HAS_CONTENTS
|
||
|SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
|
||
0, /* valid reloc types */
|
||
' ', /* ar_pad_char */
|
||
16, /* ar_max_namelen */
|
||
oasys_close_and_cleanup, /* _close_and_cleanup */
|
||
oasys_set_section_contents, /* bfd_set_section_contents */
|
||
oasys_get_section_contents,
|
||
oasys_new_section_hook, /* new_section_hook */
|
||
0, /* _core_file_failing_command */
|
||
0, /* _core_file_failing_signal */
|
||
0, /* _core_file_matches_ex...p */
|
||
|
||
0, /* bfd_slurp_bsd_armap, bfd_slurp_armap */
|
||
bfd_true, /* bfd_slurp_extended_name_table */
|
||
bfd_bsd_truncate_arname, /* bfd_truncate_arname */
|
||
|
||
oasys_get_symtab_upper_bound, /* get_symtab_upper_bound */
|
||
oasys_get_symtab, /* canonicalize_symtab */
|
||
0, /* oasys_reclaim_symbol_table, bfd_reclaim_symbol_table */
|
||
oasys_get_reloc_upper_bound, /* get_reloc_upper_bound */
|
||
oasys_canonicalize_reloc, /* bfd_canonicalize_reloc */
|
||
0, /* oasys_reclaim_reloc, bfd_reclaim_reloc */
|
||
0, /* oasys_get_symcount_upper_bound, bfd_get_symcount_upper_bound */
|
||
0, /* oasys_get_first_symbol, bfd_get_first_symbol */
|
||
0, /* oasys_get_next_symbol, bfd_get_next_symbol */
|
||
0, /* oasys_classify_symbol, bfd_classify_symbol */
|
||
0, /* oasys_symbol_hasclass, bfd_symbol_hasclass */
|
||
0, /* oasys_symbol_name, bfd_symbol_name */
|
||
0, /* oasys_symbol_value, bfd_symbol_value */
|
||
|
||
_do_getblong, _do_putblong, _do_getbshort, _do_putbshort, /* data */
|
||
_do_getblong, _do_putblong, _do_getbshort, _do_putbshort, /* hdrs */
|
||
|
||
{_bfd_dummy_target,
|
||
oasys_object_p, /* bfd_check_format */
|
||
oasys_archive_p,
|
||
bfd_false
|
||
},
|
||
{
|
||
bfd_false,
|
||
oasys_mkobject,
|
||
_bfd_generic_mkarchive,
|
||
bfd_false
|
||
},
|
||
oasys_make_empty_symbol,
|
||
oasys_print_symbol,
|
||
bfd_false, /* oasys_get_lineno,*/
|
||
oasys_set_arch_mach, /* bfd_set_arch_mach,*/
|
||
bfd_false,
|
||
oasys_openr_next_archived_file,
|
||
oasys_find_nearest_line, /* bfd_find_nearest_line */
|
||
oasys_stat_arch_elt, /* bfd_stat_arch_elt */
|
||
};
|