-/* bfd backend for ieee-695 objects.
+
+ /* bfd backend for ieee-695 objects.
IEEE 695 format is a stream of records, which we parse using a simple one
token (which is one byte in this lexicon) lookahead recursive decent
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "sysdep.h"
+
#include "bfd.h"
#include "libbfd.h"
-#include "obstack.h"
#include "ieee.h"
#include "libieee.h"
-#define obstack_chunk_alloc malloc
-#define obstack_chunk_free free
-#define ieee_malloc(abfd,size) \
- obstack_alloc(&( ieee_data(abfd)->ieee_obstack), (size))
typedef void generic_symbol_type;
bfd *abfd AND
bfd_byte byte)
{
- bfd_write(&byte, 1, 1, abfd);
+ bfd_write((PTR)&byte, 1, 1, abfd);
}
buffer[0] = bytes >> 8;
buffer[1] = bytes & 0xff;
- bfd_write(buffer, 1, 2, abfd);
+ bfd_write((PTR)buffer, 1, 2, abfd);
}
static void
else {
BFD_FAIL();
}
- bfd_write((bfd_byte *)id, 1, length, abfd);
+ bfd_write((PTR)id, 1, length, abfd);
}
/***************************************************************************
Functions for reading from ieee files in the strange way that the
standard requires:
*/
-#define this_byte(abfd) *(ptr(abfd))
-#define next_byte(abfd) (ptr(abfd)++)
-#define this_byte_and_next(abfd) *(ptr(abfd)++)
+
+#define this_byte(ieee) *(ieee->input_p)
+#define next_byte(ieee) (ieee->input_p++)
+#define this_byte_and_next(ieee) (*(ieee->input_p++))
static unsigned short
-DEFUN(read_2bytes,(abfd),
- bfd *abfd)
+DEFUN(read_2bytes,(ieee),
+ ieee_data_type *ieee)
{
- unsigned char c1 = this_byte_and_next(abfd);
- unsigned char c2 = this_byte_and_next(abfd);
+ unsigned char c1 = this_byte_and_next(ieee);
+ unsigned char c2 = this_byte_and_next(ieee);
return (c1<<8 ) | c2;
}
static void
-DEFUN(bfd_get_string,(abfd, string, length),
- bfd *abfd AND
+DEFUN(bfd_get_string,(ieee, string, length),
+ ieee_data_type *ieee AND
char *string AND
size_t length)
{
size_t i;
for (i= 0; i < length; i++) {
- string[i] = this_byte_and_next(abfd);
+ string[i] = this_byte_and_next(ieee);
}
}
static char *
-DEFUN(read_id,(abfd),
- bfd *abfd)
+DEFUN(read_id,(ieee),
+ ieee_data_type *ieee)
{
size_t length;
char *string;
- length = this_byte_and_next(abfd);
+ length = this_byte_and_next(ieee);
if (length >= 0x00 && length <= 0x7f) {
/* Simple string of length 0 to 127 */
}
else if (length == 0xde) {
/* Length is next byte, allowing 0..255 */
- length = this_byte_and_next(abfd);
+ length = this_byte_and_next(ieee);
}
else if (length == 0xdf) {
/* Length is next two bytes, allowing 0..65535 */
- length = this_byte_and_next(abfd) ;
- length = (length * 256) + this_byte_and_next(abfd);
+ length = this_byte_and_next(ieee) ;
+ length = (length * 256) + this_byte_and_next(ieee);
}
/* Buy memory and read string */
- string = ieee_malloc(abfd, length+1);
- bfd_get_string(abfd, string, length);
+ string = bfd_alloc(ieee->abfd, length+1);
+ bfd_get_string(ieee, string, length);
string[length] = 0;
return string;
}
static void
-DEFUN(ieee_write_expression,(abfd, value, section, symbol),
+DEFUN(ieee_write_expression,(abfd, value, section, symbol, pcrel, index),
bfd*abfd AND
bfd_vma value AND
asection *section AND
- asymbol *symbol)
+ asymbol *symbol AND
+ boolean pcrel AND
+ unsigned int index)
{
unsigned int plus_count = 0;
ieee_write_int(abfd, value);
ieee_write_byte(abfd, section->index +IEEE_SECTION_NUMBER_BASE);
}
+
+
if (symbol != (asymbol *)NULL) {
plus_count++;
if ((symbol->flags & BSF_UNDEFINED ) ||
}
}
- while (plus_count != 0) {
+ if(pcrel) {
+ /* subtract the pc from here by asking for PC of this section*/
+ ieee_write_byte(abfd, ieee_variable_P_enum);
+ ieee_write_byte(abfd, index +IEEE_SECTION_NUMBER_BASE);
+ ieee_write_byte(abfd, ieee_function_minus_enum);
+ }
+
+ while (plus_count > 0) {
ieee_write_byte(abfd, ieee_function_plus_enum);
plus_count--;
}
bfd *abfd AND
bfd_vma value)
{
- char b[5];
+ bfd_byte b[5];
ieee_write_int5(b, value);
- bfd_write(b,1,5,abfd);
+ bfd_write((PTR)b,1,5,abfd);
}
static boolean
-DEFUN(parse_int,(abfd, value_ptr),
- bfd *abfd AND
+DEFUN(parse_int,(ieee, value_ptr),
+ ieee_data_type *ieee AND
bfd_vma *value_ptr)
{
- int value = this_byte(abfd);
+ int value = this_byte(ieee);
int result;
if (value >= 0 && value <= 127) {
*value_ptr = value;
- next_byte(abfd);
+ next_byte(ieee);
return true;
}
else if (value >= 0x80 && value <= 0x88) {
unsigned int count = value & 0xf;
result = 0;
- next_byte(abfd);
+ next_byte(ieee);
while (count) {
- result =(result << 8) | this_byte_and_next(abfd);
+ result =(result << 8) | this_byte_and_next(ieee);
count--;
}
*value_ptr = result;
return false;
}
static int
-DEFUN(parse_i,(abfd, ok),
- bfd *abfd AND
+DEFUN(parse_i,(ieee, ok),
+ ieee_data_type *ieee AND
boolean *ok)
{
bfd_vma x;
- *ok = parse_int(abfd, &x);
+ *ok = parse_int(ieee, &x);
return x;
}
static bfd_vma
-DEFUN(must_parse_int,(abfd),
- bfd *abfd)
+DEFUN(must_parse_int,(ieee),
+ ieee_data_type *ieee)
{
bfd_vma result;
- BFD_ASSERT(parse_int(abfd, &result) == true);
+ BFD_ASSERT(parse_int(ieee, &result) == true);
return result;
}
static
reloc_howto_type abs32_howto
- = HOWTO(1,0,2,32,0,0,0,true,0,"abs32",false,0xffffffff, 0xffffffff,false);
+ = HOWTO(1,0,2,32,0,0,0,true,0,"abs32",true,0xffffffff, 0xffffffff,false);
static
reloc_howto_type abs16_howto
- = HOWTO(1,0,1,16,0,0,0,true,0,"abs16",false,0x0000ffff, 0x0000ffff,false);
+ = HOWTO(1,0,1,16,0,0,0,true,0,"abs16",true,0x0000ffff, 0x0000ffff,false);
+
+static
+reloc_howto_type rel32_howto
+ = HOWTO(1,0,2,32,1,0,0,true,0,"rel32",true,0xffffffff, 0xffffffff,false);
+static
+reloc_howto_type rel16_howto
+ = HOWTO(1,0,1,16,1,0,0,true,0,"rel16",true,0x0000ffff, 0x0000ffff,false);
static ieee_symbol_index_type NOSYMBOL = { 0, 0};
static void
-DEFUN(parse_expression,(abfd, value, section, symbol, pcrel, extra),
- bfd *abfd AND
+DEFUN(parse_expression,(ieee, value, section, symbol, pcrel, extra),
+ ieee_data_type *ieee AND
bfd_vma *value AND
asection **section AND
ieee_symbol_index_type *symbol AND
boolean *pcrel AND
unsigned int *extra)
+
{
#define POS sp[1]
#define TOS sp[0]
ieee_value_type *sp = stack;
while (loop) {
- switch (this_byte(abfd))
- {
- case ieee_variable_P_enum:
- /* P variable, current program counter for section n */
+ switch (this_byte(ieee))
{
- int section_n ;
- next_byte(abfd);
- section_n = must_parse_int(abfd);
- PUSH(NOSYMBOL, 0,
- TOS.value = ieee_data(abfd)->section_table[section_n]->vma +
- ieee_per_section(ieee_data(abfd)->section_table[section_n])->pc);
+ case ieee_variable_P_enum:
+ /* P variable, current program counter for section n */
+ {
+ int section_n ;
+ next_byte(ieee);
+ *pcrel = true;
+ section_n = must_parse_int(ieee);
+ PUSH(NOSYMBOL, 0,
+ TOS.value = ieee->section_table[section_n]->vma +
+ ieee_per_section(ieee->section_table[section_n])->pc);
+ break;
+ }
+ case ieee_variable_L_enum:
+ /* L variable address of section N */
+ next_byte(ieee);
+ PUSH(NOSYMBOL,ieee->section_table[must_parse_int(ieee)],0);
+ break;
+ case ieee_variable_R_enum:
+ /* R variable, logical address of section module */
+ /* FIXME, this should be different to L */
+ next_byte(ieee);
+ PUSH(NOSYMBOL,ieee->section_table[must_parse_int(ieee)],0);
+ break;
+ case ieee_variable_S_enum:
+ /* S variable, size in MAUS of section module */
+ next_byte(ieee);
+ PUSH(NOSYMBOL,
+ 0,
+ ieee->section_table[must_parse_int(ieee)]->size);
break;
- }
- case ieee_variable_L_enum:
- /* L variable address of section N */
- next_byte(abfd);
- PUSH(NOSYMBOL,ieee_data(abfd)->section_table[must_parse_int(abfd)],0);
- break;
- case ieee_variable_R_enum:
- /* R variable, logical address of section module */
- /* FIXME, this should be different to L */
- next_byte(abfd);
- PUSH(NOSYMBOL,ieee_data(abfd)->section_table[must_parse_int(abfd)],0);
- break;
- case ieee_variable_S_enum:
- /* S variable, size in MAUS of section module */
- next_byte(abfd);
- PUSH(NOSYMBOL,
- 0,
- ieee_data(abfd)->section_table[must_parse_int(abfd)]->size);
- break;
- case ieee_variable_X_enum:
- /* Push the address of external variable n */
- {
- ieee_symbol_index_type sy;
- next_byte(abfd);
- sy.index = (int)(must_parse_int(abfd)) ;
- sy.letter = 'X';
+ case ieee_variable_X_enum:
+ /* Push the address of external variable n */
+ {
+ ieee_symbol_index_type sy;
+ next_byte(ieee);
+ sy.index = (int)(must_parse_int(ieee)) ;
+ sy.letter = 'X';
- PUSH(sy, 0, 0);
- }
- break;
- case ieee_function_minus_enum:
- {
- bfd_vma value1, value2;
- asection *section;
- ieee_symbol_index_type sy;
- next_byte(abfd);
-
- POP(sy, section, value1);
- POP(sy, section, value2);
- PUSH(NOSYMBOL, 0, value1-value2);
- }
- break;
- case ieee_function_plus_enum:
- {
- bfd_vma value1, value2;
- asection *section1;
- asection *section2;
- ieee_symbol_index_type sy1;
- ieee_symbol_index_type sy2;
- next_byte(abfd);
-
- POP(sy1, section1, value1);
- POP(sy2, section2, value2);
- PUSH(sy1.letter ? sy1 : sy2, section1 ? section1: section2, value1+value2);
- }
- break;
- default:
- {
- bfd_vma va;
- BFD_ASSERT(this_byte(abfd) < ieee_variable_A_enum
- || this_byte(abfd) > ieee_variable_Z_enum);
- if (parse_int(abfd, &va))
+ PUSH(sy, 0, 0);
+ }
+ break;
+ case ieee_function_minus_enum:
{
- PUSH(NOSYMBOL,0, va);
+ bfd_vma value1, value2;
+ asection *section1, *section_dummy;
+ ieee_symbol_index_type sy;
+ next_byte(ieee);
+
+ POP(sy, section1, value1);
+ POP(sy, section_dummy, value2);
+ PUSH(sy, section1, value1-value2);
}
- else {
- /*
- Thats all that we can understand. As far as I can see
- there is a bug in the Microtec IEEE output which I'm
- using to scan, whereby the comma operator is ommited
- sometimes in an expression, giving expressions with too
- many terms. We can tell if that's the case by ensuring
- that sp == stack here. If not, then we've pushed
- something too far. -
- */
-
- POP(*symbol, *section, *value);
- if (sp != stack) {
- BFD_ASSERT(*section == 0);
- *extra = *value;
- /* Get what should be returned */
- POP(*symbol, *section, *value);
+ break;
+ case ieee_function_plus_enum:
+ {
+ bfd_vma value1, value2;
+ asection *section1;
+ asection *section2;
+ ieee_symbol_index_type sy1;
+ ieee_symbol_index_type sy2;
+ next_byte(ieee);
+
+ POP(sy1, section1, value1);
+ POP(sy2, section2, value2);
+ PUSH(sy1.letter ? sy1 : sy2, section1 ? section1: section2, value1+value2);
}
- else {
- *extra = 0;
+ break;
+ default:
+ {
+ bfd_vma va;
+ BFD_ASSERT(this_byte(ieee) < ieee_variable_A_enum
+ || this_byte(ieee) > ieee_variable_Z_enum);
+ if (parse_int(ieee, &va))
+ {
+ PUSH(NOSYMBOL,0, va);
+ }
+ else {
+ /*
+ Thats all that we can understand. As far as I can see
+ there is a bug in the Microtec IEEE output which I'm
+ using to scan, whereby the comma operator is ommited
+ sometimes in an expression, giving expressions with too
+ many terms. We can tell if that's the case by ensuring
+ that sp == stack here. If not, then we've pushed
+ something too far, so we keep adding
+ */
+
+ while (sp != stack+1) {
+ asection *section1;
+ ieee_symbol_index_type sy1;
+ POP(sy1, section1, *extra);
+ }
+
+ POP(*symbol, *section, *value);
+ loop = false;
+ }
}
- loop = false;
- }
- }
- }
+ }
}
}
ieee_seek(abfd, offset );
while (loop) {
- switch (this_byte(abfd)) {
+ switch (this_byte(ieee)) {
case ieee_external_symbol_enum:
- next_byte(abfd);
- symbol = (ieee_symbol_type *)ieee_malloc(abfd, sizeof(ieee_symbol_type));
+ next_byte(ieee);
+ symbol = (ieee_symbol_type *)bfd_alloc(ieee->abfd, sizeof(ieee_symbol_type));
*prev_symbols_ptr = symbol;
prev_symbols_ptr= &symbol->next;
- symbol->index = must_parse_int(abfd);
+ symbol->index = must_parse_int(ieee);
if (symbol->index > ieee->external_symbol_max_index) {
ieee->external_symbol_max_index = symbol->index;
}
BFD_ASSERT (symbol->index >= ieee->external_symbol_min_index);
symbol_count++;
symbol->symbol.the_bfd = abfd;
- symbol->symbol.name = read_id(abfd);
- symbol->symbol.udata = (void *)NULL;
+ symbol->symbol.name = read_id(ieee);
+ symbol->symbol.udata = (PTR)NULL;
symbol->symbol.flags = BSF_NO_FLAGS;
break;
case ieee_attribute_record_enum >> 8:
unsigned int symbol_type_index;
unsigned int symbol_attribute_def;
bfd_vma value;
- next_byte(abfd); /* Skip prefix */
- next_byte(abfd);
- symbol_name_index = must_parse_int(abfd);
- symbol_type_index = must_parse_int(abfd);
- symbol_attribute_def = must_parse_int(abfd);
+ next_byte(ieee); /* Skip prefix */
+ next_byte(ieee);
+ symbol_name_index = must_parse_int(ieee);
+ symbol_type_index = must_parse_int(ieee);
+ symbol_attribute_def = must_parse_int(ieee);
- parse_int(abfd,&value);
+ parse_int(ieee,&value);
}
break;
unsigned int symbol_name_index;
ieee_symbol_index_type symbol_ignore;
boolean pcrel_ignore;
- unsigned int extra_ignore;
- next_byte(abfd);
- next_byte(abfd);
+ unsigned int extra;
+ next_byte(ieee);
+ next_byte(ieee);
- symbol_name_index = must_parse_int(abfd);
- parse_expression(abfd,
+ symbol_name_index = must_parse_int(ieee);
+ parse_expression(ieee,
&symbol->symbol.value,
&symbol->symbol.section,
&symbol_ignore,
- &pcrel_ignore,
- &extra_ignore);
+ &pcrel_ignore,
+ &extra);
if (symbol->symbol.section != (asection *)NULL) {
symbol->symbol.flags = BSF_GLOBAL | BSF_EXPORT;
}
case ieee_weak_external_reference_enum:
{ bfd_vma size;
bfd_vma value ;
- next_byte(abfd);
+ next_byte(ieee);
/* Throw away the external reference index */
- (void)must_parse_int(abfd);
+ (void)must_parse_int(ieee);
/* Fetch the default size if not resolved */
- size = must_parse_int(abfd);
+ size = must_parse_int(ieee);
/* Fetch the defautlt value if available */
- if ( parse_int(abfd, &value) == false) {
+ if ( parse_int(ieee, &value) == false) {
value = 0;
}
/* This turns into a common */
break;
case ieee_external_reference_enum:
- next_byte(abfd);
- symbol = (ieee_symbol_type *)ieee_malloc(abfd, sizeof(ieee_symbol_type));
+ next_byte(ieee);
+ symbol = (ieee_symbol_type *)bfd_alloc(ieee->abfd, sizeof(ieee_symbol_type));
symbol_count++;
*prev_reference_ptr = symbol;
prev_reference_ptr = &symbol->next;
- symbol->index = must_parse_int(abfd);
+ symbol->index = must_parse_int(ieee);
symbol->symbol.the_bfd = abfd;
- symbol->symbol.name = read_id(abfd);
- symbol->symbol.udata = (void *)NULL;
+ symbol->symbol.name = read_id(ieee);
+ symbol->symbol.udata = (PTR)NULL;
symbol->symbol.section = (asection *)NULL;
symbol->symbol.value = (bfd_vma)0;
symbol->symbol.flags = BSF_UNDEFINED;
}
}
-size_t
+unsigned int
DEFUN(ieee_get_symtab_upper_bound,(abfd),
bfd *abfd)
{
*/
extern bfd_target ieee_vec;
-
unsigned int
DEFUN(ieee_get_symtab,(abfd, location),
bfd *abfd AND
ieee_symbol_type *symp;
static bfd dummy_bfd;
static asymbol empty_symbol =
- { &dummy_bfd," ieee empty",(symvalue)0,BSF_DEBUGGING | BSF_FAKE};
+ { &dummy_bfd," ieee empty",(symvalue)0,BSF_DEBUGGING | BSF_ABSOLUTE};
+
ieee_data_type *ieee = ieee_data(abfd);
dummy_bfd.xvec= &ieee_vec;
bfd_byte section_type[3];
ieee_seek(abfd, offset);
while (true) {
- switch (this_byte(abfd)) {
+ switch (this_byte(ieee)) {
case ieee_section_type_enum:
{
unsigned int section_index ;
- next_byte(abfd);
- section_index = must_parse_int(abfd);
+ next_byte(ieee);
+ section_index = must_parse_int(ieee);
/* Fixme to be nice about a silly number of sections */
BFD_ASSERT(section_index < NSECTIONS);
ieee->section_table[section_index] = section;
section->flags = SEC_NO_FLAGS;
section->target_index = section_index;
- section_type[0] = this_byte_and_next(abfd);
+ section_type[0] = this_byte_and_next(ieee);
switch (section_type[0]) {
case 0xC3:
- section_type[1] = this_byte(abfd);
+ section_type[1] = this_byte(ieee);
section->flags = SEC_LOAD;
switch (section_type[1]) {
case 0xD0:
/* Normal code */
- next_byte(abfd);
+ next_byte(ieee);
section->flags |= SEC_LOAD | SEC_CODE;
break;
case 0xC4:
- next_byte(abfd);
+ next_byte(ieee);
section->flags |= SEC_LOAD | SEC_DATA;
/* Normal data */
break;
case 0xD2:
- next_byte(abfd);
+ next_byte(ieee);
/* Normal rom data */
section->flags |= SEC_LOAD | SEC_ROM | SEC_DATA;
break;
break;
}
}
- section->name = read_id(abfd);
+ section->name = read_id(ieee);
{ bfd_vma parent, brother, context;
- parse_int(abfd, &parent);
- parse_int(abfd, &brother);
- parse_int(abfd, &context);
+ parse_int(ieee, &parent);
+ parse_int(ieee, &brother);
+ parse_int(ieee, &context);
}
{
unsigned int section_index;
bfd_vma value;
- next_byte(abfd);
- section_index = must_parse_int(abfd);
+ next_byte(ieee);
+ section_index = must_parse_int(ieee);
if (section_index > ieee->section_count) {
ieee->section_count = section_index;
}
ieee->section_table[section_index]->alignment_power =
- bfd_log2(must_parse_int(abfd));
- (void)parse_int(abfd, & value);
+ bfd_log2(must_parse_int(ieee));
+ (void)parse_int(ieee, & value);
}
break;
case ieee_e2_first_byte_enum:
{
- ieee_record_enum_type t = read_2bytes(abfd);
+ ieee_record_enum_type t = read_2bytes(ieee);
switch (t) {
case ieee_section_size_enum:
- section = ieee->section_table[must_parse_int(abfd)];
- section->size = must_parse_int(abfd);
+ section = ieee->section_table[must_parse_int(ieee)];
+ section->size = must_parse_int(ieee);
break;
case ieee_physical_region_size_enum:
- section = ieee->section_table[must_parse_int(abfd)];
- section->size = must_parse_int(abfd);
+ section = ieee->section_table[must_parse_int(ieee)];
+ section->size = must_parse_int(ieee);
break;
case ieee_region_base_address_enum:
- section = ieee->section_table[must_parse_int(abfd)];
- section->vma = must_parse_int(abfd);
+ section = ieee->section_table[must_parse_int(ieee)];
+ section->vma = must_parse_int(ieee);
break;
case ieee_mau_size_enum:
- must_parse_int(abfd);
- must_parse_int(abfd);
+ must_parse_int(ieee);
+ must_parse_int(ieee);
break;
case ieee_m_value_enum:
- must_parse_int(abfd);
- must_parse_int(abfd);
+ must_parse_int(ieee);
+ must_parse_int(ieee);
break;
case ieee_section_base_address_enum:
- section = ieee->section_table[must_parse_int(abfd)];
- section->vma = must_parse_int(abfd);
+ section = ieee->section_table[must_parse_int(ieee)];
+ section->vma = must_parse_int(ieee);
break;
case ieee_section_offset_enum:
- (void) must_parse_int(abfd);
- (void) must_parse_int(abfd);
+ (void) must_parse_int(ieee);
+ (void) must_parse_int(ieee);
break;
default:
return;
DEFUN(ieee_archive_p,(abfd),
bfd *abfd)
{
+ return 0;
+#if 0
char *library;
boolean loop;
ieee_ar_data_type *ar;
unsigned int i;
- return 0; /* FIXME */
+
+
+/* FIXME */
ieee_seek(abfd, (file_ptr) 0);
if (this_byte(abfd) != Module_Beginning) return (bfd_target*)NULL;
- next_byte(abfd);
- library= read_id(abfd);
+ next_byte(ieee);
+ library= read_id(ieee);
if (strcmp(library , "LIBRARY") != 0) {
free(library);
return (bfd_target *)NULL;
}
/* Throw away the filename */
- free( read_id(abfd));
+ free( read_id(ieee));
/* This must be an IEEE archive, so we'll buy some space to do
things */
ar = (ieee_ar_data_type *) malloc(sizeof(ieee_ar_data_type));
ar->element_index = 0;
obstack_init(&ar->element_obstack);
- next_byte(abfd); /* Drop the ad part */
- must_parse_int(abfd); /* And the two dummy numbers */
- must_parse_int(abfd);
+ next_byte(ieee); /* Drop the ad part */
+ must_parse_int(ieee); /* And the two dummy numbers */
+ must_parse_int(ieee);
loop = true;
/* Read the index of the BB table */
ieee_ar_obstack_type t;
int rec =read_2bytes(abfd);
if (rec ==ieee_assign_value_to_variable_enum) {
- int record_number = must_parse_int(abfd);
- t.file_offset = must_parse_int(abfd);
+ int record_number = must_parse_int(ieee);
+ t.file_offset = must_parse_int(ieee);
t.abfd = (bfd *)NULL;
ar->element_count++;
obstack_grow(&ar->element_obstack, (PTR)&t, sizeof(t));
for (i = 2; i < ar->element_count; i++) {
ieee_seek(abfd, ar->elements[i].file_offset);
- next_byte(abfd); /* Drop F8 */
- next_byte(abfd); /* Drop 14 */
- must_parse_int(abfd); /* Drop size of block */
- if (must_parse_int(abfd) != 0) {
+ next_byte(ieee); /* Drop F8 */
+ next_byte(ieee); /* Drop 14 */
+ must_parse_int(ieee); /* Drop size of block */
+ if (must_parse_int(ieee) != 0) {
/* This object has been deleted */
ar->elements[i].file_offset = 0;
}
else {
- ar->elements[i].file_offset = must_parse_int(abfd);
+ ar->elements[i].file_offset = must_parse_int(ieee);
}
}
obstack_finish(&ar->element_obstack);
return abfd->xvec;
+#endif
}
static boolean
DEFUN(ieee_mkobject,(abfd),
bfd *abfd)
{
- struct obstack tmp_obstack;
- ieee_data_type *ieee;
-
- obstack_init(&tmp_obstack);
- BFD_ASSERT(ieee_data(abfd) == 0);
- set_tdata (abfd, obstack_alloc(&tmp_obstack,sizeof(ieee_data_type)));
- ieee = ieee_data(abfd);
- ieee->ieee_obstack = tmp_obstack;
+ ieee_data(abfd) = (ieee_data_type *)bfd_alloc(abfd,sizeof(ieee_data_type));
return true;
}
char *processor;
unsigned int part;
ieee_data_type *ieee;
- char buffer[300];
-
+ uint8e_type buffer[300];
+ ieee_data_type *save = ieee_data(abfd);
set_tdata (abfd, 0);
ieee_mkobject(abfd);
ieee = ieee_data(abfd);
/* Read the first few bytes in to see if it makes sense */
- bfd_read(buffer, 1, sizeof(buffer), abfd);
+ bfd_read((PTR)buffer, 1, sizeof(buffer), abfd);
- ptr(abfd)= buffer;
- if (*(ptr(abfd)++) != Module_Beginning) goto fail;
+ ieee->input_p = buffer;
+ if (this_byte_and_next(ieee) != Module_Beginning) goto fail;
ieee->read_symbols= false;
ieee->read_data= false;
ieee->external_symbol_min_index = IEEE_PUBLIC_BASE;
ieee->external_reference_min_index =IEEE_REFERENCE_BASE;
ieee->external_reference_max_index = 0;
+ ieee->abfd = abfd;
memset((PTR)ieee->section_table, 0, sizeof(ieee->section_table));
- processor = ieee->mb.processor = read_id(abfd);
+ processor = ieee->mb.processor = read_id(ieee);
if (strcmp(processor,"LIBRARY") == 0) goto fail;
- ieee->mb.module_name = read_id(abfd);
+ ieee->mb.module_name = read_id(ieee);
if (abfd->filename == (char *)NULL) {
abfd->filename = ieee->mb.module_name;
}
/* Determine the architecture and machine type of the object file. */
bfd_scan_arch_mach(processor, &abfd->obj_arch, &abfd->obj_machine);
- if (this_byte(abfd) != ieee_address_descriptor_enum) {
+ if (this_byte(ieee) != ieee_address_descriptor_enum) {
goto fail;
}
- next_byte(abfd);
+ next_byte(ieee);
- if (parse_int(abfd, &ieee->ad.number_of_bits_mau) == false) {
+ if (parse_int(ieee, &ieee->ad.number_of_bits_mau) == false) {
goto fail;
}
- if(parse_int(abfd, &ieee->ad.number_of_maus_in_address) == false) {
+ if(parse_int(ieee, &ieee->ad.number_of_maus_in_address) == false) {
goto fail;
}
/* If there is a byte order info, take it */
- if (this_byte(abfd) == ieee_variable_L_enum ||
- this_byte(abfd) == ieee_variable_M_enum)
- next_byte(abfd);
+ if (this_byte(ieee) == ieee_variable_L_enum ||
+ this_byte(ieee) == ieee_variable_M_enum)
+ next_byte(ieee);
for (part = 0; part < N_W_VARIABLES; part++) {
boolean ok;
- if (read_2bytes(abfd) != ieee_assign_value_to_variable_enum) {
+ if (read_2bytes(ieee) != ieee_assign_value_to_variable_enum) {
goto fail;
}
- if (this_byte_and_next(abfd) != part) {
+ if (this_byte_and_next(ieee) != part) {
goto fail;
}
- ieee->w.offset[part] = parse_i(abfd, &ok);
+ ieee->w.offset[part] = parse_i(ieee, &ok);
if (ok==false) {
goto fail;
}
quickly. We can work out how big the file is from the trailer
record */
- ieee_data(abfd)->first_byte = ieee_malloc(abfd, ieee->w.r.me_record
+ ieee_data(abfd)->first_byte = (uint8e_type *) bfd_alloc(ieee->abfd, ieee->w.r.me_record
+ 50);
bfd_seek(abfd, 0, 0);
- bfd_read(ieee_data(abfd)->first_byte, 1, ieee->w.r.me_record+50, abfd);
+ bfd_read((PTR)(ieee_data(abfd)->first_byte), 1, ieee->w.r.me_record+50, abfd);
ieee_slurp_sections(abfd);
return abfd->xvec;
fail:
- obstack_finish(&ieee->ieee_obstack);
+ (void) bfd_release(abfd, ieee);
+ ieee_data(abfd) = save;
return (bfd_target *)NULL;
}
{
CONST char *section_name = symbol->section == (asection *)NULL ?
"*abs" : symbol->section->name;
+ if (symbol->name[0] == ' ') {
+ fprintf(file,"* empty table entry ");
+ }
+ else {
+ bfd_print_symbol_vandf((PTR)file,symbol);
- bfd_print_symbol_vandf((void *)file,symbol);
-
- fprintf(file," %-5s %04x %02x %s",
- section_name,
- (unsigned) ieee_symbol(symbol)->index,
- (unsigned) 0, /*
+ fprintf(file," %-5s %04x %02x %s",
+ section_name,
+ (unsigned) ieee_symbol(symbol)->index,
+ (unsigned) 0, /*
aout_symbol(symbol)->desc & 0xffff,
aout_symbol(symbol)->other & 0xff,*/
- symbol->name);
+ symbol->name);
+ }
}
break;
}
for (s = abfd->sections; s != (asection *)NULL; s = s->next) {
ieee_per_section_type *per = (ieee_per_section_type *) s->used_by_bfd;
- per->data = (bfd_byte *) ieee_malloc(abfd, s->size);
+ per->data = (bfd_byte *) bfd_alloc(ieee->abfd, s->size);
/*SUPPRESS 68*/
per->reloc_tail_ptr =
(ieee_reloc_type **)&(s->relocation);
while (true) {
- switch (this_byte(abfd))
+ switch (this_byte(ieee))
{
/* IF we see anything strange then quit */
default:
return true;
case ieee_set_current_section_enum:
- next_byte(abfd);
- section_number = must_parse_int(abfd);
+ next_byte(ieee);
+ section_number = must_parse_int(ieee);
s = ieee->section_table[section_number];
current_map = (ieee_per_section_type *) s->used_by_bfd;
location_ptr = current_map->data - s->vma;
{
unsigned int number_of_maus;
unsigned int i;
- next_byte(abfd);
- number_of_maus = must_parse_int(abfd);
+ next_byte(ieee);
+ number_of_maus = must_parse_int(ieee);
for (i = 0; i < number_of_maus; i++) {
- location_ptr[current_map->pc++]= this_byte(abfd);
- next_byte(abfd);
+ location_ptr[current_map->pc++]= this_byte(ieee);
+ next_byte(ieee);
}
}
break;
case ieee_e2_first_byte_enum:
- next_byte(abfd);
- switch (this_byte(abfd))
+ next_byte(ieee);
+ switch (this_byte(ieee))
{
case ieee_set_current_pc_enum & 0xff:
{
ieee_symbol_index_type symbol;
unsigned int extra;
boolean pcrel;
- next_byte(abfd);
- must_parse_int(abfd); /* Thow away section #*/
- parse_expression(abfd, &value, &dsection, &symbol, &pcrel, &extra);
+ next_byte(ieee);
+ must_parse_int(ieee); /* Thow away section #*/
+ parse_expression(ieee, &value, &dsection, &symbol,
+ &pcrel, &extra);
current_map->pc = value;
BFD_ASSERT((unsigned)(value - s->vma) <= s->size);
}
case ieee_value_starting_address_enum & 0xff:
/* We've got to the end of the data now - */
return true;
- break;
default:
BFD_FAIL();
return true;
case ieee_load_with_relocation_enum:
{
boolean loop = true;
- next_byte(abfd);
+ next_byte(ieee);
while (loop)
{
- switch (this_byte(abfd))
+ switch (this_byte(ieee))
{
case ieee_variable_R_enum:
case ieee_function_unsigned_open_b_enum:
case ieee_function_either_open_b_enum:
{
- unsigned int extra;
- boolean pcrel;
+ unsigned int extra = 4;
+ boolean pcrel = false;
- ieee_reloc_type *r =
- (ieee_reloc_type *) ieee_malloc(abfd,
- sizeof(ieee_reloc_type));
+ ieee_reloc_type *r =
+ (ieee_reloc_type *) bfd_alloc(ieee->abfd,
+ sizeof(ieee_reloc_type));
*(current_map->reloc_tail_ptr) = r;
current_map->reloc_tail_ptr= &r->next;
r->next = (ieee_reloc_type *)NULL;
- next_byte(abfd);
- parse_expression(abfd,
- &r->relent.addend,
- &r->relent.section,
- &r->symbol,
- &pcrel,
- &extra);
+ next_byte(ieee);
+ parse_expression(ieee,
+ &r->relent.addend,
+ &r->relent.section,
+ &r->symbol,
+ &pcrel, &extra);
r->relent.address = current_map->pc;
s->reloc_count++;
- switch (this_byte(abfd)) {
+ switch (this_byte(ieee)) {
case ieee_function_signed_close_b_enum:
- next_byte(abfd);
+ next_byte(ieee);
break;
case ieee_function_unsigned_close_b_enum:
- next_byte(abfd);
+ next_byte(ieee);
break;
case ieee_function_either_close_b_enum:
- next_byte(abfd);
+ next_byte(ieee);
break;
default:
break;
}
/* Build a relocation entry for this type */
- if (this_byte(abfd) == ieee_comma) {
-
- next_byte(abfd);
+ if (this_byte(ieee) == ieee_comma) {
+ next_byte(ieee);
/* Fetch number of bytes to pad */
- extra = must_parse_int(abfd);
- BFD_FAIL();
- }
- switch (extra) {
- case 0:
- case 4:
- location_ptr[current_map->pc++] = 0;
- location_ptr[current_map->pc++] = 0;
- location_ptr[current_map->pc++] = 0;
- location_ptr[current_map->pc++] = 0;
- r->relent.howto = &abs32_howto;
- break;
- case 2:
- location_ptr[current_map->pc++] = 0;
- location_ptr[current_map->pc++] = 0;
- r->relent.howto = &abs16_howto;
- break;
-
- default:
- BFD_FAIL();
- break;
- }
+ extra = must_parse_int(ieee);
+ };
+
+ /* If pc rel then stick -ve pc into instruction
+ and take out of reloc*/
+
+ switch (extra)
+ {
+ case 0:
+ case 4:
+ if (pcrel == true)
+ {
+ bfd_putlong(abfd, -current_map->pc, location_ptr +
+ current_map->pc);
+ r->relent.howto = &rel32_howto;
+ r->relent.addend -= current_map->pc;
+ }
+ else
+ {
+ bfd_putlong(abfd, 0, location_ptr +
+ current_map->pc);
+ r->relent.howto = &abs32_howto;
+ }
+ current_map->pc +=4;
+ break;
+ case 2:
+ if (pcrel == true) {
+ bfd_putshort(abfd, (int)(-current_map->pc), location_ptr +current_map->pc);
+ r->relent.addend -= current_map->pc;
+ r->relent.howto = &rel16_howto;
+ }
+ else {
+ bfd_putshort(abfd, 0, location_ptr +current_map->pc);
+ r->relent.howto = &abs16_howto;
+ }
+ current_map->pc +=2;
+ break;
+
+ default:
+ BFD_FAIL();
+ break;
+ }
}
break;
default:
{
bfd_vma this_size ;
- if (parse_int(abfd, &this_size) == true) {
+ if (parse_int(ieee, &this_size) == true) {
unsigned int i;
for (i = 0; i < this_size; i++) {
- location_ptr[current_map->pc ++] = this_byte(abfd);
- next_byte(abfd);
+ location_ptr[current_map->pc ++] = this_byte(ieee);
+ next_byte(ieee);
}
}
else {
asection *newsect)
{
newsect->used_by_bfd = (PTR)
- ieee_malloc(abfd, sizeof(ieee_per_section_type));
+ bfd_alloc(abfd, sizeof(ieee_per_section_type));
ieee_per_section( newsect)->data = (bfd_byte *)NULL;
ieee_per_section(newsect)->section = newsect;
return true;
DEFUN(ieee_get_section_contents,(abfd, section, location, offset, count),
bfd *abfd AND
sec_ptr section AND
- void *location AND
+ PTR location AND
file_ptr offset AND
- unsigned int count)
+ int count)
{
ieee_per_section_type *p = (ieee_per_section_type *) section->used_by_bfd;
ieee_slurp_section_data(abfd);
arelent **relptr AND
asymbol **symbols)
{
- ieee_per_section_type *p = (ieee_per_section_type *) section->used_by_bfd;
+/* ieee_per_section_type *p = (ieee_per_section_type *) section->used_by_bfd;*/
ieee_reloc_type *src = (ieee_reloc_type *)(section->relocation);
ieee_data_type *ieee = ieee_data(abfd);
unsigned int relocs_to_go = s->reloc_count;
size_t current_byte_index = 0;
-
/* Sort the reloc records so we can insert them in the correct
places */
if (s->reloc_count != 0) {
qsort(s->orelocation,
- s->reloc_count,
+ relocs_to_go,
sizeof(arelent **),
comp);
}
header[4] = s->index + IEEE_SECTION_NUMBER_BASE;
ieee_write_int5(header+5, s->vma );
header[10] = ieee_load_with_relocation_enum;
- bfd_write(header, 1, sizeof(header), abfd);
+ bfd_write((PTR)header, 1, sizeof(header), abfd);
/* Output the data stream as the longest sequence of bytes
possible, allowing for the a reasonable packet size and
relocation stuffs */
- if (stream == (void *)NULL) {
+ if ((PTR)stream == (PTR)NULL) {
/* Outputting a section without data, fill it up */
- stream = ieee_malloc(abfd, s->size);
- memset(stream, 0, s->size);
+ stream = (uint8e_type *)(bfd_alloc(abfd, s->size));
+ memset((PTR)stream, 0, s->size);
}
while (current_byte_index < s->size) {
size_t run;
unsigned int MAXRUN = 32;
- if (p && *p) {
+ if (relocs_to_go) {
run = (*p)->address - current_byte_index;
}
else {
if (run != 0) {
/* Output a stream of bytes */
ieee_write_int(abfd, run);
- bfd_write(stream + current_byte_index,
+ bfd_write((PTR)(stream + current_byte_index),
1,
run,
abfd);
while (relocs_to_go && (*p) && (*p)->address == current_byte_index) {
arelent *r = *p;
+ bfd_vma ov;
+ if (r->howto->pc_relative) {
+ r->addend += current_byte_index;
+ }
+
+ switch (r->howto->size) {
+ case 2:
+
+ ov = bfd_getlong(abfd,
+ stream+current_byte_index);
+ current_byte_index +=4;
+ break;
+ case 1:
+ ov = bfd_getshort(abfd,
+ stream+current_byte_index);
+ current_byte_index +=2;
+ break;
+ default:
+ BFD_FAIL();
+ }
ieee_write_byte(abfd, ieee_function_either_open_b_enum);
+
if (r->sym_ptr_ptr != (asymbol **)NULL) {
- ieee_write_expression(abfd, r->addend,
+ ieee_write_expression(abfd, r->addend + ov,
r->section,
- *(r->sym_ptr_ptr));
+ *(r->sym_ptr_ptr),
+ r->howto->pc_relative, s->target_index);
}
else {
- ieee_write_expression(abfd, r->addend,
+ ieee_write_expression(abfd, r->addend + ov,
r->section,
- (asymbol *)NULL);
+ (asymbol *)NULL,
+ r->howto->pc_relative, s->target_index);
}
ieee_write_byte(abfd,
ieee_function_either_close_b_enum);
+ if (r->howto->size != 2) {
+ ieee_write_byte(abfd, ieee_comma);
+ ieee_write_int(abfd, 1<< r->howto->size);
+ }
+
relocs_to_go --;
p++;
}
- /* FIXME !! Are all relocations 4 bytes ? */
- current_byte_index += 4;
+
}
}
}
asection *s;
for (s = abfd->sections; s != (asection *)NULL; s = s->next) {
if (s->size != 0) {
- ieee_per_section(s)->data = (bfd_byte *)(ieee_malloc(abfd, s->size));
+ ieee_per_section(s)->data = (bfd_byte *)(bfd_alloc(abfd, s->size));
}
}
}
DEFUN(ieee_set_section_contents,(abfd, section, location, offset, count),
bfd *abfd AND
sec_ptr section AND
- unsigned char *location AND
+ PTR location AND
file_ptr offset AND
int count)
{
ieee_write_expression(abfd,
p->value + p->section->output_offset,
p->section->output_section,
- (asymbol *)NULL);
+ (asymbol *)NULL, false, 0);
}
else
{
ieee_write_expression(abfd,
p->value,
(asection *)NULL,
- (asymbol *)NULL);
+ (asymbol *)NULL, false, 0);
}
p->value = public_index;
public_index++;
}
-void
-DEFUN(ieee_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
-}
-\f
-
-
-\f
-/* Obsolete 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
-DEFUN(ieee_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
-return 0;
-}
-
-symindex
-DEFUN(ieee_get_first_symbol,(ignore_abfd),
- bfd * ignore_abfd)
-{
- return 0;
-}
-
-symindex
-DEFUN(ieee_get_next_symbol,(abfd, oidx),
- bfd *abfd AND
- 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
-return 0;
-}
-
-char *
-ieee_symbol_name (abfd, idx)
-bfd *abfd;
-symindex idx;
-{
-#if 0
- return (obj_aout_symbols (abfd) + idx)->symbol.name;
-#endif
-return 0;
-}
-
-long
-ieee_symbol_value (abfd, idx)
-bfd *abfd;
-symindex idx;
-{
-#if 0
- return (obj_aout_symbols (abfd) + idx)->symbol.value;
-#endif
-return 0;
-}
-
-symclass
-ieee_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
-ieee_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
-return 0;
-}
-
-
-void
-ieee_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
ieee_close_and_cleanup (abfd)
}
- if (ieee_data(abfd) != (ieee_data_type *)NULL) {
- /* FIXME MORE LEAKS */
-
- }
-
return true;
}
bfd_vma offset;
char **filename_ptr;
char **functionname_ptr;
-unsigned int *line_ptr;
+int *line_ptr;
{
return false;
-
}
}
}
static int
-DEFUN(ieee_sizeof_headers,(abfd),
- bfd *abfd)
+DEFUN(ieee_sizeof_headers,(abfd, x),
+ bfd *abfd AND
+ boolean x)
{
-return 0;
+ return 0;
}
-#define ieee_core_file_failing_command bfd_false
-#define ieee_core_file_failing_signal bfd_false
-#define ieee_core_file_matches_executable_p bfd_false
+#define ieee_core_file_failing_command (char *(*)())(bfd_nullvoidptr)
+#define ieee_core_file_failing_signal (int (*)())bfd_0
+#define ieee_core_file_matches_executable_p ( PROTO(boolean, (*),(bfd *, bfd *)))bfd_false
#define ieee_slurp_armap bfd_true
#define ieee_slurp_extended_name_table bfd_true
-#define ieee_truncate_arname bfd_false
-#define ieee_write_armap bfd_false
-#define ieee_get_lineno bfd_false
+#define ieee_truncate_arname (void (*)())bfd_nullvoidptr
+#define ieee_write_armap (PROTO( boolean, (*),(bfd *, unsigned int, struct orl *, int, int))) bfd_nullvoidptr
+#define ieee_get_lineno (struct lineno_cache_entry *(*)())bfd_nullvoidptr
/*SUPPRESS 460 */
_do_getblong, _do_putblong, _do_getbshort, _do_putbshort, /* data */
_do_getblong, _do_putblong, _do_getbshort, _do_putbshort, /* hdrs */
- {_bfd_dummy_target,
+ { _bfd_dummy_target,
ieee_object_p, /* bfd_check_format */
ieee_archive_p,
- bfd_false
+ _bfd_dummy_target,
},
{
bfd_false,
projects / binutils-gdb.git / commitdiff