aboutsummaryrefslogtreecommitdiff
path: root/bfd/ieee.c
diff options
context:
space:
mode:
Diffstat (limited to 'bfd/ieee.c')
-rw-r--r--bfd/ieee.c1374
1 files changed, 1069 insertions, 305 deletions
diff --git a/bfd/ieee.c b/bfd/ieee.c
index 5a532ea..801f6ee 100644
--- a/bfd/ieee.c
+++ b/bfd/ieee.c
@@ -119,14 +119,14 @@ standard requires:
*/
-#define this_byte(ieee) *(ieee->input_p)
-#define next_byte(ieee) (ieee->input_p++)
-#define this_byte_and_next(ieee) (*(ieee->input_p++))
+#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,(ieee),
- ieee_data_type *ieee)
+ common_header_type *ieee)
{
unsigned char c1 = this_byte_and_next(ieee);
unsigned char c2 = this_byte_and_next(ieee);
@@ -136,7 +136,7 @@ DEFUN(read_2bytes,(ieee),
static void
DEFUN(bfd_get_string,(ieee, string, length),
- ieee_data_type *ieee AND
+ common_header_type *ieee AND
char *string AND
size_t length)
{
@@ -148,7 +148,7 @@ DEFUN(bfd_get_string,(ieee, string, length),
static char *
DEFUN(read_id,(ieee),
- ieee_data_type *ieee)
+ common_header_type *ieee)
{
size_t length;
char *string;
@@ -272,7 +272,7 @@ DEFUN(ieee_write_int5_out, (abfd, value),
static boolean
DEFUN(parse_int,(ieee, value_ptr),
- ieee_data_type *ieee AND
+ common_header_type *ieee AND
bfd_vma *value_ptr)
{
int value = this_byte(ieee);
@@ -297,7 +297,7 @@ DEFUN(parse_int,(ieee, value_ptr),
}
static int
DEFUN(parse_i,(ieee, ok),
- ieee_data_type *ieee AND
+ common_header_type *ieee AND
boolean *ok)
{
bfd_vma x;
@@ -307,7 +307,7 @@ DEFUN(parse_i,(ieee, ok),
static bfd_vma
DEFUN(must_parse_int,(ieee),
- ieee_data_type *ieee)
+ common_header_type *ieee)
{
bfd_vma result;
BFD_ASSERT(parse_int(ieee, &result) == true);
@@ -364,15 +364,15 @@ DEFUN(parse_expression,(ieee, value, section, symbol, pcrel, extra),
ieee_value_type *sp = stack;
while (loop) {
- switch (this_byte(ieee))
+ switch (this_byte(&(ieee->h)))
{
case ieee_variable_P_enum:
/* P variable, current program counter for section n */
{
int section_n ;
- next_byte(ieee);
+ next_byte(&(ieee->h));
*pcrel = true;
- section_n = must_parse_int(ieee);
+ section_n = must_parse_int(&(ieee->h));
PUSH(NOSYMBOL, 0,
TOS.value = ieee->section_table[section_n]->vma +
ieee_per_section(ieee->section_table[section_n])->pc);
@@ -380,29 +380,29 @@ DEFUN(parse_expression,(ieee, value, section, symbol, pcrel, extra),
}
case ieee_variable_L_enum:
/* L variable address of section N */
- next_byte(ieee);
- PUSH(NOSYMBOL,ieee->section_table[must_parse_int(ieee)],0);
+ next_byte(&(ieee->h));
+ PUSH(NOSYMBOL,ieee->section_table[must_parse_int(&(ieee->h))],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);
+ next_byte(&(ieee->h));
+ PUSH(NOSYMBOL,ieee->section_table[must_parse_int(&(ieee->h))],0);
break;
case ieee_variable_S_enum:
/* S variable, size in MAUS of section module */
- next_byte(ieee);
+ next_byte(&(ieee->h));
PUSH(NOSYMBOL,
0,
- ieee->section_table[must_parse_int(ieee)]->size);
+ ieee->section_table[must_parse_int(&(ieee->h))]->size);
break;
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)) ;
+ next_byte(&(ieee->h));
+ sy.index = (int)(must_parse_int(&(ieee->h))) ;
sy.letter = 'X';
PUSH(sy, 0, 0);
@@ -413,7 +413,7 @@ DEFUN(parse_expression,(ieee, value, section, symbol, pcrel, extra),
bfd_vma value1, value2;
asection *section1, *section_dummy;
ieee_symbol_index_type sy;
- next_byte(ieee);
+ next_byte(&(ieee->h));
POP(sy, section1, value1);
POP(sy, section_dummy, value2);
@@ -427,7 +427,7 @@ DEFUN(parse_expression,(ieee, value, section, symbol, pcrel, extra),
asection *section2;
ieee_symbol_index_type sy1;
ieee_symbol_index_type sy2;
- next_byte(ieee);
+ next_byte(&(ieee->h));
POP(sy1, section1, value1);
POP(sy2, section2, value2);
@@ -437,9 +437,9 @@ DEFUN(parse_expression,(ieee, value, section, symbol, pcrel, extra),
default:
{
bfd_vma va;
- BFD_ASSERT(this_byte(ieee) < (int)ieee_variable_A_enum
- || this_byte(ieee) > (int)ieee_variable_Z_enum);
- if (parse_int(ieee, &va))
+ BFD_ASSERT(this_byte(&(ieee->h)) < (int)ieee_variable_A_enum
+ || this_byte(&(ieee->h)) > (int)ieee_variable_Z_enum);
+ if (parse_int(&(ieee->h), &va))
{
PUSH(NOSYMBOL,0, va);
}
@@ -472,7 +472,9 @@ DEFUN(parse_expression,(ieee, value, section, symbol, pcrel, extra),
#define ieee_seek(abfd, offset) \
- ieee_data(abfd)->input_p = ieee_data(abfd)->first_byte + offset
+ ieee_data(abfd)->h.input_p = ieee_data(abfd)->h.first_byte + offset
+
+#define ieee_pos(abfd) ieee_data(abfd)->h.input_p -ieee_data(abfd)->h.first_byte
static void
DEFUN(ieee_slurp_external_symbols,(abfd),
@@ -492,21 +494,21 @@ DEFUN(ieee_slurp_external_symbols,(abfd),
ieee_seek(abfd, offset );
while (loop) {
- switch (this_byte(ieee)) {
+ switch (this_byte(&(ieee->h))) {
case ieee_external_symbol_enum:
- next_byte(ieee);
- symbol = (ieee_symbol_type *)bfd_alloc(ieee->abfd, sizeof(ieee_symbol_type));
+ next_byte(&(ieee->h));
+ symbol = (ieee_symbol_type *)bfd_alloc(ieee->h.abfd, sizeof(ieee_symbol_type));
*prev_symbols_ptr = symbol;
prev_symbols_ptr= &symbol->next;
- symbol->index = must_parse_int(ieee);
+ symbol->index = must_parse_int(&(ieee->h));
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(ieee);
+ symbol->symbol.name = read_id(&(ieee->h));
symbol->symbol.udata = (PTR)NULL;
symbol->symbol.flags = BSF_NO_FLAGS;
break;
@@ -516,13 +518,13 @@ DEFUN(ieee_slurp_external_symbols,(abfd),
unsigned int symbol_type_index;
unsigned int symbol_attribute_def;
bfd_vma value;
- 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);
+ next_byte(&(ieee->h)); /* Skip prefix */
+ next_byte(&(ieee->h));
+ symbol_name_index = must_parse_int(&(ieee->h));
+ symbol_type_index = must_parse_int(&(ieee->h));
+ symbol_attribute_def = must_parse_int(&(ieee->h));
- parse_int(ieee,&value);
+ parse_int(&(ieee->h),&value);
}
break;
@@ -532,10 +534,10 @@ DEFUN(ieee_slurp_external_symbols,(abfd),
ieee_symbol_index_type symbol_ignore;
boolean pcrel_ignore;
unsigned int extra;
- next_byte(ieee);
- next_byte(ieee);
+ next_byte(&(ieee->h));
+ next_byte(&(ieee->h));
- symbol_name_index = must_parse_int(ieee);
+ symbol_name_index = must_parse_int(&(ieee->h));
parse_expression(ieee,
&symbol->symbol.value,
&symbol->symbol.section,
@@ -553,13 +555,13 @@ DEFUN(ieee_slurp_external_symbols,(abfd),
case ieee_weak_external_reference_enum:
{ bfd_vma size;
bfd_vma value ;
- next_byte(ieee);
+ next_byte(&(ieee->h));
/* Throw away the external reference index */
- (void)must_parse_int(ieee);
+ (void)must_parse_int(&(ieee->h));
/* Fetch the default size if not resolved */
- size = must_parse_int(ieee);
+ size = must_parse_int(&(ieee->h));
/* Fetch the defautlt value if available */
- if ( parse_int(ieee, &value) == false) {
+ if ( parse_int(&(ieee->h), &value) == false) {
value = 0;
}
/* This turns into a common */
@@ -569,14 +571,14 @@ DEFUN(ieee_slurp_external_symbols,(abfd),
break;
case ieee_external_reference_enum:
- next_byte(ieee);
- symbol = (ieee_symbol_type *)bfd_alloc(ieee->abfd, sizeof(ieee_symbol_type));
+ next_byte(&(ieee->h));
+ symbol = (ieee_symbol_type *)bfd_alloc(ieee->h.abfd, sizeof(ieee_symbol_type));
symbol_count++;
*prev_reference_ptr = symbol;
prev_reference_ptr = &symbol->next;
- symbol->index = must_parse_int(ieee);
+ symbol->index = must_parse_int(&(ieee->h));
symbol->symbol.the_bfd = abfd;
- symbol->symbol.name = read_id(ieee);
+ symbol->symbol.name = read_id(&(ieee->h));
symbol->symbol.udata = (PTR)NULL;
symbol->symbol.section = (asection *)NULL;
symbol->symbol.value = (bfd_vma)0;
@@ -715,12 +717,12 @@ DEFUN(ieee_slurp_sections,(abfd),
bfd_byte section_type[3];
ieee_seek(abfd, offset);
while (true) {
- switch (this_byte(ieee)) {
+ switch (this_byte(&(ieee->h))) {
case ieee_section_type_enum:
{
unsigned int section_index ;
- next_byte(ieee);
- section_index = must_parse_int(ieee);
+ next_byte(&(ieee->h));
+ section_index = must_parse_int(&(ieee->h));
/* Fixme to be nice about a silly number of sections */
BFD_ASSERT(section_index < NSECTIONS);
@@ -728,24 +730,24 @@ DEFUN(ieee_slurp_sections,(abfd),
ieee->section_table[section_index] = section;
section->flags = SEC_NO_FLAGS;
section->target_index = section_index;
- section_type[0] = this_byte_and_next(ieee);
+ section_type[0] = this_byte_and_next(&(ieee->h));
switch (section_type[0]) {
case 0xC3:
- section_type[1] = this_byte(ieee);
- section->flags = SEC_LOAD;
+ section_type[1] = this_byte(&(ieee->h));
+ section->flags = SEC_LOAD | SEC_ALLOC | SEC_HAS_CONTENTS;
switch (section_type[1]) {
case 0xD0:
/* Normal code */
- next_byte(ieee);
+ next_byte(&(ieee->h));
section->flags |= SEC_LOAD | SEC_CODE;
break;
case 0xC4:
- next_byte(ieee);
+ next_byte(&(ieee->h));
section->flags |= SEC_LOAD | SEC_DATA;
/* Normal data */
break;
case 0xD2:
- next_byte(ieee);
+ next_byte(&(ieee->h));
/* Normal rom data */
section->flags |= SEC_LOAD | SEC_ROM | SEC_DATA;
break;
@@ -753,11 +755,11 @@ DEFUN(ieee_slurp_sections,(abfd),
break;
}
}
- section->name = read_id(ieee);
+ section->name = read_id(&(ieee->h));
{ bfd_vma parent, brother, context;
- parse_int(ieee, &parent);
- parse_int(ieee, &brother);
- parse_int(ieee, &context);
+ parse_int(&(ieee->h), &parent);
+ parse_int(&(ieee->h), &brother);
+ parse_int(&(ieee->h), &context);
}
@@ -767,47 +769,47 @@ DEFUN(ieee_slurp_sections,(abfd),
{
unsigned int section_index;
bfd_vma value;
- next_byte(ieee);
- section_index = must_parse_int(ieee);
+ next_byte(&(ieee->h));
+ section_index = must_parse_int(&ieee->h);
if (section_index > ieee->section_count) {
ieee->section_count = section_index;
}
ieee->section_table[section_index]->alignment_power =
- bfd_log2(must_parse_int(ieee));
- (void)parse_int(ieee, & value);
+ bfd_log2(must_parse_int(&ieee->h));
+ (void)parse_int(&(ieee->h), & value);
}
break;
case ieee_e2_first_byte_enum:
{
- ieee_record_enum_type t = read_2bytes(ieee);
+ ieee_record_enum_type t = read_2bytes(&(ieee->h));
switch (t) {
case ieee_section_size_enum:
- section = ieee->section_table[must_parse_int(ieee)];
- section->size = must_parse_int(ieee);
+ section = ieee->section_table[must_parse_int(&(ieee->h))];
+ section->size = must_parse_int(&(ieee->h));
break;
case ieee_physical_region_size_enum:
- section = ieee->section_table[must_parse_int(ieee)];
- section->size = must_parse_int(ieee);
+ section = ieee->section_table[must_parse_int(&(ieee->h))];
+ section->size = must_parse_int(&(ieee->h));
break;
case ieee_region_base_address_enum:
- section = ieee->section_table[must_parse_int(ieee)];
- section->vma = must_parse_int(ieee);
+ section = ieee->section_table[must_parse_int(&(ieee->h))];
+ section->vma = must_parse_int(&(ieee->h));
break;
case ieee_mau_size_enum:
- must_parse_int(ieee);
- must_parse_int(ieee);
+ must_parse_int(&(ieee->h));
+ must_parse_int(&(ieee->h));
break;
case ieee_m_value_enum:
- must_parse_int(ieee);
- must_parse_int(ieee);
+ must_parse_int(&(ieee->h));
+ must_parse_int(&(ieee->h));
break;
case ieee_section_base_address_enum:
- section = ieee->section_table[must_parse_int(ieee)];
- section->vma = must_parse_int(ieee);
+ section = ieee->section_table[must_parse_int(&(ieee->h))];
+ section->vma = must_parse_int(&(ieee->h));
break;
case ieee_section_offset_enum:
- (void) must_parse_int(ieee);
- (void) must_parse_int(ieee);
+ (void) must_parse_int(&(ieee->h));
+ (void) must_parse_int(&(ieee->h));
break;
default:
return;
@@ -828,81 +830,107 @@ bfd_target *
DEFUN(ieee_archive_p,(abfd),
bfd *abfd)
{
- return 0;
-#if 0
char *library;
boolean loop;
- ieee_ar_data_type *ar;
+
unsigned int i;
+uint8e_type buffer[512];
+ int buffer_i = 0;
+ int buffer_offset = 0;
+ ieee_ar_data_type *save = ieee_ar_data(abfd);
+ ieee_ar_data_type *ieee ;
+ set_tdata(abfd, bfd_alloc(abfd, sizeof(ieee_ar_data_type)));
+ ieee= ieee_ar_data(abfd);
+
+
+ bfd_read((PTR)buffer, 1, sizeof(buffer), abfd);
+ ieee->h.first_byte = buffer;
+ ieee->h.input_p = buffer;
-/* FIXME */
- ieee_seek(abfd, (file_ptr) 0);
- if (this_byte(abfd) != Module_Beginning) return (bfd_target*)NULL;
- next_byte(ieee);
- library= read_id(ieee);
+ ieee->h.abfd = abfd;
+
+ if (this_byte(&(ieee->h)) != Module_Beginning) return (bfd_target*)NULL;
+
+ next_byte(&(ieee->h));
+ library= read_id(&(ieee->h));
if (strcmp(library , "LIBRARY") != 0) {
- free(library);
+ bfd_release(abfd, ieee);
+ ieee_ar_data(abfd)= save;
return (bfd_target *)NULL;
}
/* Throw away the filename */
- free( read_id(ieee));
+ free( read_id(&(ieee->h)));
/* 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));
- set_tdata (abfd, ar);
- ar->element_count = 0;
- ar->element_index = 0;
- obstack_init(&ar->element_obstack);
+ ieee->element_count = 0;
+ ieee->element_index = 0;
- next_byte(ieee); /* Drop the ad part */
- must_parse_int(ieee); /* And the two dummy numbers */
- must_parse_int(ieee);
+ next_byte(&(ieee->h)); /* Drop the ad part */
+ must_parse_int(&(ieee->h)); /* And the two dummy numbers */
+ must_parse_int(&(ieee->h));
loop = true;
/* Read the index of the BB table */
while (loop) {
ieee_ar_obstack_type t;
- int rec =read_2bytes(abfd);
+ int rec =read_2bytes(&(ieee->h));
if (rec ==ieee_assign_value_to_variable_enum) {
- int record_number = must_parse_int(ieee);
- t.file_offset = must_parse_int(ieee);
+ int record_number = must_parse_int(&(ieee->h));
+ t.file_offset = must_parse_int(&(ieee->h));
t.abfd = (bfd *)NULL;
- ar->element_count++;
- obstack_grow(&ar->element_obstack, (PTR)&t, sizeof(t));
+ ieee->element_count++;
+ bfd_alloc_grow(abfd, (PTR)&t, sizeof(t));
+
+ /* Make sure that we don't go over the end of the buffer */
+
+ if (ieee_pos(abfd) > sizeof(buffer)/2) {
+ /* Past half way, reseek and reprime */
+ buffer_offset += ieee_pos(abfd);
+ bfd_seek(abfd, buffer_offset, SEEK_SET);
+ bfd_read(buffer, 1, sizeof(buffer), abfd);
+ ieee->h.first_byte = buffer;
+ ieee->h.input_p = buffer;
+ }
}
else loop = false;
}
- ar->elements = (ieee_ar_obstack_type *)obstack_base(&ar->element_obstack);
+
+ ieee->elements = (ieee_ar_obstack_type *)bfd_alloc_finish(abfd);
/* Now scan the area again, and replace BB offsets with file */
/* offsets */
- for (i = 2; i < ar->element_count; i++) {
- ieee_seek(abfd, ar->elements[i].file_offset);
- next_byte(ieee); /* Drop F8 */
- next_byte(ieee); /* Drop 14 */
- must_parse_int(ieee); /* Drop size of block */
- if (must_parse_int(ieee) != 0) {
+ for (i = 2; i < ieee->element_count; i++) {
+ bfd_seek(abfd, ieee->elements[i].file_offset, SEEK_SET);
+ bfd_read(buffer, 1, sizeof(buffer), abfd);
+ ieee->h.first_byte = buffer;
+ ieee->h.input_p = buffer;
+
+ next_byte(&(ieee->h)); /* Drop F8 */
+ next_byte(&(ieee->h)); /* Drop 14 */
+ must_parse_int(&(ieee->h)); /* Drop size of block */
+ if (must_parse_int(&(ieee->h)) != 0) {
/* This object has been deleted */
- ar->elements[i].file_offset = 0;
+ ieee->elements[i].file_offset = 0;
}
else {
- ar->elements[i].file_offset = must_parse_int(ieee);
+ ieee->elements[i].file_offset = must_parse_int(&(ieee->h));
}
}
- obstack_finish(&ar->element_obstack);
return abfd->xvec;
-#endif
+
}
static boolean
DEFUN(ieee_mkobject,(abfd),
bfd *abfd)
-{
- set_tdata (abfd, bfd_alloc(abfd,sizeof(ieee_data_type)));
+{
+ set_tdata (abfd, bfd_zalloc(abfd,sizeof(ieee_data_type)));
+
+
return true;
}
@@ -922,8 +950,8 @@ DEFUN(ieee_object_p,(abfd),
/* Read the first few bytes in to see if it makes sense */
bfd_read((PTR)buffer, 1, sizeof(buffer), abfd);
- ieee->input_p = buffer;
- if (this_byte_and_next(ieee) != Module_Beginning) goto fail;
+ ieee->h.input_p = buffer;
+ if (this_byte_and_next(&(ieee->h)) != Module_Beginning) goto fail;
ieee->read_symbols= false;
ieee->read_data= false;
@@ -932,46 +960,46 @@ DEFUN(ieee_object_p,(abfd),
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;
+ ieee->h.abfd = abfd;
memset((PTR)ieee->section_table, 0, sizeof(ieee->section_table));
- processor = ieee->mb.processor = read_id(ieee);
+ processor = ieee->mb.processor = read_id(&(ieee->h));
if (strcmp(processor,"LIBRARY") == 0) goto fail;
- ieee->mb.module_name = read_id(ieee);
+ ieee->mb.module_name = read_id(&(ieee->h));
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(ieee) != ieee_address_descriptor_enum) {
+ if (this_byte(&(ieee->h)) != ieee_address_descriptor_enum) {
goto fail;
}
- next_byte(ieee);
+ next_byte(&(ieee->h));
- if (parse_int(ieee, &ieee->ad.number_of_bits_mau) == false) {
+ if (parse_int(&(ieee->h), &ieee->ad.number_of_bits_mau) == false) {
goto fail;
}
- if(parse_int(ieee, &ieee->ad.number_of_maus_in_address) == false) {
+ if(parse_int(&(ieee->h), &ieee->ad.number_of_maus_in_address) == false) {
goto fail;
}
/* If there is a byte order info, take it */
- if (this_byte(ieee) == ieee_variable_L_enum ||
- this_byte(ieee) == ieee_variable_M_enum)
- next_byte(ieee);
+ if (this_byte(&(ieee->h)) == ieee_variable_L_enum ||
+ this_byte(&(ieee->h)) == ieee_variable_M_enum)
+ next_byte(&(ieee->h));
for (part = 0; part < N_W_VARIABLES; part++) {
boolean ok;
- if (read_2bytes(ieee) != ieee_assign_value_to_variable_enum) {
+ if (read_2bytes(&(ieee->h)) != ieee_assign_value_to_variable_enum) {
goto fail;
}
- if (this_byte_and_next(ieee) != part) {
+ if (this_byte_and_next(&(ieee->h)) != part) {
goto fail;
}
- ieee->w.offset[part] = parse_i(ieee, &ok);
+ ieee->w.offset[part] = parse_i(&(ieee->h), &ok);
if (ok==false) {
goto fail;
}
@@ -984,10 +1012,10 @@ DEFUN(ieee_object_p,(abfd),
quickly. We can work out how big the file is from the trailer
record */
- ieee_data(abfd)->first_byte = (uint8e_type *) bfd_alloc(ieee->abfd, ieee->w.r.me_record
+ ieee_data(abfd)->h.first_byte = (uint8e_type *) bfd_alloc(ieee->h.abfd, ieee->w.r.me_record
+ 50);
bfd_seek(abfd, 0, 0);
- bfd_read((PTR)(ieee_data(abfd)->first_byte), 1, ieee->w.r.me_record+50, abfd);
+ bfd_read((PTR)(ieee_data(abfd)->h.first_byte), 1, ieee->w.r.me_record+50, abfd);
ieee_slurp_sections(abfd);
return abfd->xvec;
@@ -1049,18 +1077,18 @@ DEFUN(do_one,(ieee, current_map, location_ptr,s),
uint8e_type *location_ptr AND
asection *s)
{
- switch (this_byte(ieee))
+ switch (this_byte(&(ieee->h)))
{
case ieee_load_constant_bytes_enum:
{
unsigned int number_of_maus;
unsigned int i;
- next_byte(ieee);
- number_of_maus = must_parse_int(ieee);
+ next_byte(&(ieee->h));
+ number_of_maus = must_parse_int(&(ieee->h));
for (i = 0; i < number_of_maus; i++) {
- location_ptr[current_map->pc++]= this_byte(ieee);
- next_byte(ieee);
+ location_ptr[current_map->pc++]= this_byte(&(ieee->h));
+ next_byte(&(ieee->h));
}
}
break;
@@ -1068,10 +1096,10 @@ DEFUN(do_one,(ieee, current_map, location_ptr,s),
case ieee_load_with_relocation_enum:
{
boolean loop = true;
- next_byte(ieee);
+ next_byte(&(ieee->h));
while (loop)
{
- switch (this_byte(ieee))
+ switch (this_byte(&(ieee->h)))
{
case ieee_variable_R_enum:
@@ -1083,13 +1111,13 @@ DEFUN(do_one,(ieee, current_map, location_ptr,s),
boolean pcrel = false;
ieee_reloc_type *r =
- (ieee_reloc_type *) bfd_alloc(ieee->abfd,
+ (ieee_reloc_type *) bfd_alloc(ieee->h.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(ieee);
+ next_byte(&(ieee->h));
parse_expression(ieee,
&r->relent.addend,
&r->relent.section,
@@ -1097,24 +1125,24 @@ DEFUN(do_one,(ieee, current_map, location_ptr,s),
&pcrel, &extra);
r->relent.address = current_map->pc;
s->reloc_count++;
- switch (this_byte(ieee)) {
+ switch (this_byte(&(ieee->h))) {
case ieee_function_signed_close_b_enum:
- next_byte(ieee);
+ next_byte(&(ieee->h));
break;
case ieee_function_unsigned_close_b_enum:
- next_byte(ieee);
+ next_byte(&(ieee->h));
break;
case ieee_function_either_close_b_enum:
- next_byte(ieee);
+ next_byte(&(ieee->h));
break;
default:
break;
}
/* Build a relocation entry for this type */
- if (this_byte(ieee) == ieee_comma) {
- next_byte(ieee);
+ if (this_byte(&(ieee->h)) == ieee_comma) {
+ next_byte(&(ieee->h));
/* Fetch number of bytes to pad */
- extra = must_parse_int(ieee);
+ extra = must_parse_int(&(ieee->h));
};
/* If pc rel then stick -ve pc into instruction
@@ -1126,14 +1154,14 @@ DEFUN(do_one,(ieee, current_map, location_ptr,s),
case 4:
if (pcrel == true)
{
- bfd_put_32(ieee->abfd, -current_map->pc, location_ptr +
+ bfd_put_32(ieee->h.abfd, -current_map->pc, location_ptr +
current_map->pc);
r->relent.howto = &rel32_howto;
r->relent.addend -= current_map->pc;
}
else
{
- bfd_put_32(ieee->abfd, 0, location_ptr +
+ bfd_put_32(ieee->h.abfd, 0, location_ptr +
current_map->pc);
r->relent.howto = &abs32_howto;
}
@@ -1141,12 +1169,12 @@ DEFUN(do_one,(ieee, current_map, location_ptr,s),
break;
case 2:
if (pcrel == true) {
- bfd_put_16(ieee->abfd, (int)(-current_map->pc), location_ptr +current_map->pc);
+ bfd_put_16(ieee->h.abfd, (int)(-current_map->pc), location_ptr +current_map->pc);
r->relent.addend -= current_map->pc;
r->relent.howto = &rel16_howto;
}
else {
- bfd_put_16(ieee->abfd, 0, location_ptr +current_map->pc);
+ bfd_put_16(ieee->h.abfd, 0, location_ptr +current_map->pc);
r->relent.howto = &abs16_howto;
}
current_map->pc +=2;
@@ -1161,11 +1189,11 @@ DEFUN(do_one,(ieee, current_map, location_ptr,s),
default:
{
bfd_vma this_size ;
- if (parse_int(ieee, &this_size) == true) {
+ if (parse_int(&(ieee->h), &this_size) == true) {
unsigned int i;
for (i = 0; i < this_size; i++) {
- location_ptr[current_map->pc ++] = this_byte(ieee);
- next_byte(ieee);
+ location_ptr[current_map->pc ++] = this_byte(&(ieee->h));
+ next_byte(&(ieee->h));
}
}
else {
@@ -1178,7 +1206,7 @@ DEFUN(do_one,(ieee, current_map, location_ptr,s),
}
}
- /* Read in all the section data and relocation stuff too */
+/* Read in all the section data and relocation stuff too */
static boolean
DEFUN(ieee_slurp_section_data,(abfd),
bfd *abfd)
@@ -1199,7 +1227,7 @@ DEFUN(ieee_slurp_section_data,(abfd),
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 *) bfd_alloc(ieee->abfd, s->size);
+ per->data = (bfd_byte *) bfd_alloc(ieee->h.abfd, s->size);
/*SUPPRESS 68*/
per->reloc_tail_ptr =
(ieee_reloc_type **)&(s->relocation);
@@ -1208,15 +1236,15 @@ DEFUN(ieee_slurp_section_data,(abfd),
while (true) {
- switch (this_byte(ieee))
+ switch (this_byte(&(ieee->h)))
{
/* IF we see anything strange then quit */
default:
return true;
case ieee_set_current_section_enum:
- next_byte(ieee);
- section_number = must_parse_int(ieee);
+ next_byte(&(ieee->h));
+ section_number = must_parse_int(&(ieee->h));
s = ieee->section_table[section_number];
current_map = (ieee_per_section_type *) s->used_by_bfd;
location_ptr = current_map->data - s->vma;
@@ -1228,8 +1256,8 @@ DEFUN(ieee_slurp_section_data,(abfd),
case ieee_e2_first_byte_enum:
- next_byte(ieee);
- switch (this_byte(ieee))
+ next_byte(&(ieee->h));
+ switch (this_byte(&(ieee->h)))
{
case ieee_set_current_pc_enum & 0xff:
{
@@ -1238,8 +1266,8 @@ DEFUN(ieee_slurp_section_data,(abfd),
ieee_symbol_index_type symbol;
unsigned int extra;
boolean pcrel;
- next_byte(ieee);
- must_parse_int(ieee); /* Thow away section #*/
+ next_byte(&(ieee->h));
+ must_parse_int(&(ieee->h)); /* Thow away section #*/
parse_expression(ieee, &value, &dsection, &symbol,
&pcrel, &extra);
current_map->pc = value;
@@ -1259,18 +1287,31 @@ DEFUN(ieee_slurp_section_data,(abfd),
{
/* Repeat the following LD or LR n times - we do this by
remembering the stream pointer before running it and
- resetting it and running it n times
+ resetting it and running it n times. We special case
+ the repetition of a repeat_data/load_constant
*/
unsigned int iterations ;
uint8e_type *start ;
- next_byte(ieee);
- iterations = must_parse_int(ieee);
- start = ieee->input_p;
- while (iterations != 0) {
- ieee->input_p = start;
- do_one(ieee, current_map, location_ptr,s);
- iterations --;
+ next_byte(&(ieee->h));
+ iterations = must_parse_int(&(ieee->h));
+ start = ieee->h.input_p;
+ if (start[0] == ieee_load_constant_bytes_enum &&
+ start[1] == 1) {
+ while (iterations != 0) {
+ location_ptr[current_map->pc++] = start[2];
+ iterations--;
+ }
+ next_byte(&(ieee->h));
+ next_byte(&(ieee->h));
+ next_byte(&(ieee->h));
+ }
+ else {
+ while (iterations != 0) {
+ ieee->h.input_p = start;
+ do_one(ieee, current_map, location_ptr,s);
+ iterations --;
+ }
}
}
break;
@@ -1393,32 +1434,42 @@ DEFUN(ieee_write_section_part,(abfd),
ieee_write_byte(abfd, ieee_section_type_enum);
ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE);
- switch (s->flags & (SEC_LOAD | SEC_CODE | SEC_DATA | SEC_ROM)) {
- case SEC_LOAD | SEC_CODE:
- /* Normal named section, code */
- ieee_write_byte(abfd, ieee_variable_C_enum);
- ieee_write_byte(abfd, ieee_variable_P_enum);
- break;
- case SEC_LOAD | SEC_DATA:
- /* Normal named section, data */
- ieee_write_byte(abfd, ieee_variable_C_enum);
- ieee_write_byte(abfd, ieee_variable_D_enum);
- break;
- case SEC_LOAD | SEC_DATA | SEC_ROM:
- /* Normal named section, data rom */
- ieee_write_byte(abfd, ieee_variable_C_enum);
- ieee_write_byte(abfd, ieee_variable_R_enum);
- break;
- default:
- ieee_write_byte(abfd, ieee_variable_C_enum);
- break;
- }
+ if (abfd->flags & EXEC_P)
+ {
+ /* This image is executable, so output absolute sections */
+ ieee_write_byte(abfd, ieee_variable_A_enum);
+ ieee_write_byte(abfd, ieee_variable_S_enum);
+ }
+ else
+ {
+ ieee_write_byte(abfd, ieee_variable_C_enum);
+ }
+
+ switch (s->flags &(SEC_CODE | SEC_DATA | SEC_ROM))
+ {
+ case SEC_CODE | SEC_LOAD:
+ case SEC_CODE:
+ ieee_write_byte(abfd, ieee_variable_P_enum);
+ break;
+ case SEC_DATA:
+ default:
+ ieee_write_byte(abfd, ieee_variable_D_enum);
+ break;
+ case SEC_ROM:
+ case SEC_ROM | SEC_DATA:
+ case SEC_ROM | SEC_LOAD:
+ case SEC_ROM | SEC_DATA | SEC_LOAD:
+
+ ieee_write_byte(abfd, ieee_variable_R_enum);
+ }
+
ieee_write_id(abfd, s->name);
+#if 0
ieee_write_int(abfd, 0); /* Parent */
ieee_write_int(abfd, 0); /* Brother */
ieee_write_int(abfd, 0); /* Context */
-
+#endif
/* Alignment */
ieee_write_byte(abfd, ieee_section_alignment_enum);
ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE);
@@ -1430,7 +1481,7 @@ DEFUN(ieee_write_section_part,(abfd),
ieee_write_int(abfd, s->size);
/* Vma */
- ieee_write_2bytes(abfd, ieee_region_base_address_enum);
+ ieee_write_2bytes(abfd, ieee_section_base_address_enum);
ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE);
ieee_write_int(abfd, s->vma);
@@ -1439,128 +1490,737 @@ DEFUN(ieee_write_section_part,(abfd),
-/* write the data in an ieee way */
-static void
-DEFUN(ieee_write_data_part,(abfd),
- bfd *abfd)
+static void
+DEFUN(do_with_relocs,(abfd, s),
+ bfd *abfd AND
+ asection *s)
{
- asection *s;
- ieee_data_type *ieee = ieee_data(abfd);
- ieee->w.r.data_part = bfd_tell(abfd);
- for (s = abfd->sections; s != (asection *)NULL; s = s->next)
+ unsigned int relocs_to_go = s->reloc_count;
+ bfd_byte header[11];
+
+ bfd_byte *stream = ieee_per_section(s)->data;
+ arelent **p = s->orelocation;
+
+ bfd_size_type current_byte_index = 0;
+
+ qsort(s->orelocation,
+ relocs_to_go,
+ sizeof(arelent **),
+ comp);
+
+
+
+ /* Output the section preheader */
+ header[0] =ieee_set_current_section_enum;
+ header[1] = s->index + IEEE_SECTION_NUMBER_BASE;
+
+ header[2] = ieee_set_current_pc_enum >> 8;
+ header[3]= ieee_set_current_pc_enum & 0xff;
+ header[4] = s->index + IEEE_SECTION_NUMBER_BASE;
+ ieee_write_int5(header+5, s->vma );
+ header[10] = ieee_load_with_relocation_enum;
+ 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 ((PTR)stream == (PTR)NULL) {
+ /* Outputting a section without data, fill it up */
+ stream = (uint8e_type *)(bfd_alloc(abfd, s->size));
+ memset((PTR)stream, 0, s->size);
+ }
+ while (current_byte_index < s->size) {
+ bfd_size_type run;
+ unsigned int MAXRUN = 32;
+ if (relocs_to_go) {
+ run = (*p)->address - current_byte_index;
+ }
+ else {
+ run = MAXRUN;
+ }
+ if (run > s->size - current_byte_index) {
+ run = s->size - current_byte_index;
+ }
+
+ if (run != 0) {
+ /* Output a stream of bytes */
+ ieee_write_int(abfd, run);
+ bfd_write((PTR)(stream + current_byte_index),
+ 1,
+ run,
+ abfd);
+ current_byte_index += run;
+ }
+ /* Output any relocations here */
+ if (relocs_to_go && (*p) && (*p)->address == current_byte_index) {
+ 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_get_32(abfd,
+ stream+current_byte_index);
+ current_byte_index +=4;
+ break;
+ case 1:
+ ov = bfd_get_16(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 + ov,
+ r->section,
+ *(r->sym_ptr_ptr),
+ r->howto->pc_relative, s->target_index);
+ }
+ else {
+ ieee_write_expression(abfd, r->addend + ov,
+ r->section,
+ (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++;
+ }
+
+ }
+ }
+}
+
+/* If there are no relocations in the output section then we can
+be clever about how we write. We block items up into a max of 127
+bytes */
+
+static void
+DEFUN(do_as_repeat, (abfd, s),
+ bfd *abfd AND
+ asection *s)
+{
+ ieee_write_byte(abfd, ieee_set_current_section_enum);
+ ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE);
+ ieee_write_byte(abfd, ieee_set_current_pc_enum >> 8);
+ ieee_write_byte(abfd, ieee_set_current_pc_enum & 0xff);
+ ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE);
+ ieee_write_int(abfd, s->vma );
+
+ ieee_write_byte(abfd,ieee_repeat_data_enum);
+ ieee_write_int(abfd, s->size);
+ ieee_write_byte(abfd, ieee_load_constant_bytes_enum);
+ ieee_write_byte(abfd, 1);
+ ieee_write_byte(abfd, 0);
+}
+
+static void
+DEFUN(do_without_relocs, (abfd, s),
+ bfd *abfd AND
+ asection *s)
+{
+ bfd_byte *stream = ieee_per_section(s)->data;
+
+ if (stream == 0 || ((s->flags & SEC_LOAD) == 0))
{
- bfd_byte header[11];
- bfd_byte *stream = ieee_per_section(s)->data;
- arelent **p = s->orelocation;
- unsigned int relocs_to_go = s->reloc_count;
- bfd_size_type current_byte_index = 0;
+ do_as_repeat(abfd, s);
+ }
+ else
+ {
+ unsigned int i;
+ for (i = 0; i < s->size; i++) {
+ if (stream[i] != 0) {
+ do_with_relocs(abfd, s);
+ return;
+ }
+ }
+ do_as_repeat(abfd, s);
+ }
+
+}
- /* Sort the reloc records so we can insert them in the correct
- places */
- if (s->reloc_count != 0) {
- qsort(s->orelocation,
- relocs_to_go,
- sizeof(arelent **),
- comp);
+
+static unsigned char *output_ptr_start;
+static unsigned char *output_ptr;
+static unsigned char *output_ptr_end;
+static unsigned char *input_ptr_start;
+static unsigned char *input_ptr;
+static unsigned char *input_ptr_end;
+static bfd *input_bfd;
+static bfd *output_bfd;
+static int output_buffer;
+
+static void fill()
+{
+ bfd_read(input_ptr_start, 1, input_ptr_end - input_ptr_start, input_bfd);
+ input_ptr = input_ptr_start;
+}
+static void flush()
+{
+ bfd_write(output_ptr_start,1,output_ptr - output_ptr_start, output_bfd);
+ output_ptr = output_ptr_start;
+ output_buffer++;
+}
+
+#define THIS() ( *input_ptr )
+#define NEXT() { input_ptr++; if (input_ptr == input_ptr_end) fill(); }
+#define OUT(x) { *output_ptr++ = (x); if(output_ptr == output_ptr_end) flush(); }
+
+static void write_int(value)
+int value;
+{
+ if (value >= 0 && value <= 127) {
+ OUT(value);
+ }
+ else {
+ unsigned int length;
+ /* How many significant bytes ? */
+ /* FIXME FOR LONGER INTS */
+ if (value & 0xff000000) {
+ length = 4;
+ }
+ else if (value & 0x00ff0000) {
+ length = 3;
+ }
+ else if (value & 0x0000ff00) {
+ length = 2;
+ }
+ else length = 1;
+
+ OUT((int)ieee_number_repeat_start_enum + length);
+ switch (length) {
+ case 4:
+ OUT( value >> 24);
+ case 3:
+ OUT( value >> 16);
+ case 2:
+ OUT( value >> 8);
+ case 1:
+ OUT( value);
+ }
+
+ }
+}
+static void copy_id()
+{
+ int length = THIS();
+ char ch;
+ OUT(length);
+ NEXT();
+ while (length--) {
+ ch = THIS();
+ OUT(ch);
+ NEXT();
+ }
+}
+#define VAR(x) ((x | 0x80))
+static void copy_expression()
+{
+ int stack[10];
+ int *tos = stack;
+ int value = 0;
+ while (1) {
+ switch (THIS()) {
+ case 0x84:
+ NEXT();
+ value = THIS(); NEXT();
+ value = (value << 8) | THIS(); NEXT();
+ value = (value << 8) | THIS(); NEXT();
+ value = (value << 8) | THIS(); NEXT();
+ *tos ++ = value;
+ break;
+ case 0x83:
+ NEXT();
+ value = THIS(); NEXT();
+ value = (value << 8) | THIS(); NEXT();
+ value = (value << 8) | THIS(); NEXT();
+ *tos ++ = value;
+ break;
+ case 0x82:
+ NEXT();
+ value = THIS(); NEXT();
+ value = (value << 8) | THIS(); NEXT();
+ *tos ++ = value;
+ break;
+ case 0x81:
+ NEXT();
+ value = THIS(); NEXT();
+ *tos ++ = value;
+ break;
+ case 0x80:
+ NEXT();
+ *tos ++ = 0;
+ break;
+ default:
+ if (THIS() >0x84) {
+ /* Not a number, just bug out with the answer */
+ write_int(*(--tos));
+ return;
+ }
+ *tos++ = THIS();
+NEXT();
+ value = 0;
+ break;
+ case 0xa5:
+ /* PLUS anything */
+ {
+ int value = *(--tos);
+ value += *(--tos);
+ *tos++ = value;
+ NEXT();
}
+ break;
+ case VAR('R') :
+ {
+ int section_number ;
+ ieee_data_type *ieee;
+ asection *s;
+ NEXT();
+ section_number = THIS();
+
+ NEXT();
+ ieee= ieee_data(input_bfd);
+ s = ieee->section_table[section_number];
+ if (s->output_section) {
+ value = s->output_section->vma ;
+ } else { value = 0; }
+ value += s->output_offset;
+ *tos++ = value;
+ value = 0;
+ }
+ break;
+ case 0x90:
+ {
+ NEXT();
+ write_int(*(--tos));
+ OUT(0x90);
+ return;
+ }
+ }
+ }
+
+}
- /* Output the section preheader */
- header[0] =ieee_set_current_section_enum;
- header[1] = s->index + IEEE_SECTION_NUMBER_BASE;
+/* Drop the int in the buffer, and copy a null into the gap, which we
+ will overwrite later */
- header[2] = ieee_set_current_pc_enum >> 8;
- header[3]= ieee_set_current_pc_enum & 0xff;
- header[4] = s->index + IEEE_SECTION_NUMBER_BASE;
- ieee_write_int5(header+5, s->vma );
- header[10] = ieee_load_with_relocation_enum;
- bfd_write((PTR)header, 1, sizeof(header), abfd);
+struct output_buffer_struct {
+unsigned char *ptrp;
+ int buffer;
+} ;
- /* Output the data stream as the longest sequence of bytes
- possible, allowing for the a reasonable packet size and
- relocation stuffs */
+static void
+DEFUN(fill_int,(buf),
+ struct output_buffer_struct *buf)
+{
+ if (buf->buffer == output_buffer) {
+ /* Still a chance to output the size */
+ int value = output_ptr - buf->ptrp + 3;
+ buf->ptrp[0] = value >> 24;
+ buf->ptrp[1] = value >> 16;
+ buf->ptrp[2] = value >> 8;
+ buf->ptrp[3] = value >> 0;
+ }
- if ((PTR)stream == (PTR)NULL) {
- /* Outputting a section without data, fill it up */
- stream = (uint8e_type *)(bfd_alloc(abfd, s->size));
- memset((PTR)stream, 0, s->size);
+}
+static void
+DEFUN(drop_int,(buf),
+ struct output_buffer_struct *buf)
+{
+ int type = THIS();
+ int ch;
+ if (type <= 0x84) {
+ NEXT();
+ switch(type) {
+ case 0x84: ch = THIS(); NEXT();
+ case 0x83: ch = THIS(); NEXT();
+ case 0x82: ch = THIS(); NEXT();
+ case 0x81: ch = THIS(); NEXT();
+ case 0x80: break;
+ }
+ }
+ OUT(0x84);
+ buf->ptrp = output_ptr;
+ buf->buffer = output_buffer;
+ OUT(0);OUT(0);OUT(0);OUT(0);
+}
+
+static void copy_int()
+{
+ int type = THIS();
+ int ch;
+ if (type <= 0x84) {
+ OUT(type);
+ NEXT();
+ switch(type) {
+ case 0x84: ch = THIS(); NEXT(); OUT(ch);
+ case 0x83: ch = THIS(); NEXT(); OUT(ch);
+ case 0x82: ch = THIS(); NEXT(); OUT(ch);
+ case 0x81: ch = THIS(); NEXT(); OUT(ch);
+ case 0x80: break;
+ }
+ }
+}
+
+#define ID copy_id()
+#define INT copy_int()
+#define EXP copy_expression()
+static void copy_till_end();
+#define INTn(q) copy_int()
+#define EXPn(q) copy_expression()
+static void f1_record()
+{
+ int ch;
+ /* ATN record */
+ NEXT();
+ ch = THIS();
+ switch (ch)
+ {
+ default:
+ OUT(0xf1); OUT(ch);
+ break;
+ case 0xc9:
+ NEXT();
+ OUT(0xf1); OUT(0xc9);
+ INT; INT; ch = THIS();
+ switch (ch)
+ {
+ case 0x16: NEXT();break;
+ case 0x01: NEXT();break;
+ case 0x00: NEXT(); INT; break;
+ case 0x03: NEXT(); INT; break;
+ case 0x13: EXPn(instruction address); break;
+ default:
+ break;
+ }
+ break;
+ case 0xd8:
+ /* EXternal ref */
+ NEXT();
+ OUT(0xf1); OUT(0xd8);
+ EXP ; EXP; EXP; EXP;
+ break;
+ case 0xce:
+ NEXT();
+ OUT(0xf1);OUT(0xce); INT; INT; ch = THIS(); INT;
+ switch (ch) {
+ case 0x01:
+ INT; INT; break;
+ case 0x02:
+ INT; break;
+ case 0x04:
+ EXPn(external function); break;
+ case 0x05:
+ break;
+ case 0x07: INTn(line number); INT;
+ case 0x08: break;
+ case 0x0a: INTn(locked register); INT; break;
+ case 0x3f: copy_till_end(); break;
+ case 0x3e: copy_till_end(); break;
+ case 0x40: copy_till_end(); break;
+ case 0x41: ID; break;
}
- while (current_byte_index < s->size) {
- bfd_size_type run;
- unsigned int MAXRUN = 32;
- if (relocs_to_go) {
- run = (*p)->address - current_byte_index;
- }
- else {
- run = MAXRUN;
+ }
+
+}
+static void f0_record()
+{
+ /* Attribute record */
+ NEXT();
+ OUT(0xf0);
+ INTn(Symbol name );
+ ID;
+}
+static void copy_till_end()
+{
+ int ch = THIS();
+ while (1) {
+ while (ch <= 0x80)
+ {
+ OUT(ch);
+ NEXT();
+ ch = THIS();
+ }
+ switch (ch) {
+ case 0x84:
+ OUT(THIS());
+ NEXT();
+ case 0x83:
+ OUT(THIS());
+ NEXT();
+ case 0x82:
+ OUT(THIS());
+ NEXT();
+ case 0x81:
+ OUT(THIS());
+ NEXT();
+ OUT(THIS());
+ NEXT();
+
+ ch = THIS();
+ break;
+ default:
+ return;
+ }
+ }
+
+}
+
+static void f2_record()
+{
+ int ch;
+ NEXT();
+ OUT(0xf2);
+ INT ;
+ NEXT();
+ OUT(0xce);
+ INT ;
+copy_till_end();
+}
+
+
+static void block();
+static void f8_record()
+{
+ int ch;
+ NEXT();
+ ch = THIS();
+ switch (ch)
+ {
+ case 0x01:
+ case 0x02:
+ case 0x03:
+ /* Unique typedefs for module */
+ /* GLobal typedefs */
+ /* High level module scope beginning */
+ {
+ struct output_buffer_struct ob;
+ NEXT();
+ OUT(0xf8); OUT(ch);
+ drop_int(&ob); ID ;
+
+ block();
+
+ NEXT();
+ fill_int(&ob);
+ OUT(0xf9);
}
- if (run > s->size - current_byte_index) {
- run = s->size - current_byte_index;
+ break;
+ case 0x04:
+ /* Global function */
+ {
+ struct output_buffer_struct ob;
+ NEXT();
+ OUT(0xf8); OUT(0x04);
+ drop_int(&ob); ID ; INTn(stack size); INTn(ret val);
+ EXPn(offset);
+
+ block();
+
+ NEXT();
+ OUT(0xf9);
+ EXPn(size of block);
+ fill_int(&ob);
}
+ break;
- if (run != 0) {
- /* Output a stream of bytes */
- ieee_write_int(abfd, run);
- bfd_write((PTR)(stream + current_byte_index),
- 1,
- run,
- abfd);
- current_byte_index += run;
+ case 0x05:
+ /* File name for source line numbers */
+ {
+ struct output_buffer_struct ob;
+ NEXT();
+ OUT(0xf8); OUT(0x05);
+ drop_int(&ob);
+ ID; INTn(year); INTn(month); INTn(day);
+ INTn(hour); INTn(monute); INTn(second);
+ block();
+ NEXT();
+ OUT(0xf9);
+ fill_int(&ob);
}
- /* Output any relocations here */
- if (relocs_to_go && (*p) && (*p)->address == current_byte_index) {
- 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;
- }
+ break;
+
+ case 0x06:
+ /* Local function */
+ { struct output_buffer_struct ob;
+ NEXT(); OUT(0xf8); OUT(0x06);
+ drop_int(&ob);
+ ID; INTn(stack size); INTn(type return);
+ EXPn(offset);
+ block();
+ NEXT();
+ OUT(0xf9);
+ EXPn(size);
+ fill_int(&ob);
+ }
+ break;
+
+ case 0x0a:
+ /* Assembler module scope beginning -*/
+ { struct output_buffer_struct ob;
- switch (r->howto->size) {
- case 2:
+ NEXT();
+ OUT(0xf8); OUT(0x0a);
+ drop_int(&ob);
+ ID; ID; INT; ID; INT; INT; INT; INT; INT; INT;
- ov = bfd_get_32(abfd,
- stream+current_byte_index);
- current_byte_index +=4;
- break;
- case 1:
- ov = bfd_get_16(abfd,
- stream+current_byte_index);
- current_byte_index +=2;
- break;
- default:
- BFD_FAIL();
- }
- ieee_write_byte(abfd, ieee_function_either_open_b_enum);
+ block();
- if (r->sym_ptr_ptr != (asymbol **)NULL) {
- ieee_write_expression(abfd, r->addend + ov,
- r->section,
- *(r->sym_ptr_ptr),
- r->howto->pc_relative, s->target_index);
- }
- else {
- ieee_write_expression(abfd, r->addend + ov,
- r->section,
- (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);
- }
+ NEXT();
+ OUT(0xf9);
+ fill_int(&ob);
+ }
+ break;
+ case 0x0b:
+ {
+ struct output_buffer_struct ob;
+ NEXT();
+ OUT(0xf8); OUT(0x0b);
+ drop_int(&ob); ID ; INT; INTn(section index); EXPn(offset); INTn(stuff);
- relocs_to_go --;
- p++;
- }
+ block();
+ OUT(0xf9);
+ NEXT();
+ EXPn(Size in Maus);
+ fill_int(&ob);
}
- }
+ break;
}
+}
+static void e2_record()
+{
+ OUT(0xe2);
+ NEXT();
+ OUT(0xce);
+ NEXT();
+ INT;
+ EXP;
+}
+
+static void DEFUN_VOID(block)
+{
+ int ch ;
+ while (1) {
+ ch = THIS();
+ switch (ch) {
+ case 0xe1:
+ case 0xe5:
+ return;
+ case 0xf9:
+ return;
+ case 0xf0:
+ f0_record();
+ break;
+ case 0xf1:
+ f1_record();
+ break;
+ case 0xf2:
+ f2_record();
+ break;
+ case 0xf8:
+ f8_record();
+ break;
+ case 0xe2:
+ e2_record();
+ break;
+
+ }
+ }
+}
+
+
+
+/* relocate_debug,
+ moves all the debug information from the source bfd to the output
+ bfd, and relocates any expressions it finds
+*/
+
+static void
+DEFUN(relocate_debug,(output, input),
+ bfd *output AND
+ bfd *input)
+{
+#define IBS 400
+#define OBS 400
+ unsigned char input_buffer[IBS];
+
+ input_ptr_start = input_ptr = input_buffer;
+ input_ptr_end = input_buffer + IBS;
+ input_bfd = input;
+ bfd_read(input_ptr_start, 1, IBS, input);
+ block();
+}
+/*
+ During linking, we we told about the bfds which made up our
+ contents, we have a list of them. They will still be open, so go to
+ the debug info in each, and copy it out, relocating it as we go.
+*/
+
+static void
+DEFUN(ieee_write_debug_part, (abfd),
+ bfd *abfd)
+{
+ ieee_data_type *ieee = ieee_data(abfd);
+ bfd_chain_type *chain = ieee->chain_root;
+ unsigned char output_buffer[OBS];
+ output_ptr_start = output_ptr = output_buffer ;
+ output_ptr_end = output_buffer + OBS;
+ output_ptr = output_buffer;
+ output_bfd = abfd;
+ ieee->w.r.debug_information_part = bfd_tell(abfd);
+ while (chain != (bfd_chain_type *)NULL) {
+ bfd *entry = chain->this;
+ ieee_data_type *entry_ieee = ieee_data(entry);
+ if (entry_ieee->w.r.debug_information_part) {
+ bfd_seek(entry, entry_ieee->w.r.debug_information_part, SEEK_SET);
+ relocate_debug(abfd, entry);
+ }
+
+ chain = chain->next;
+ }
+
+ flush();
+
+}
+/* write the data in an ieee way */
+static void
+DEFUN(ieee_write_data_part,(abfd),
+ bfd *abfd)
+{
+ asection *s;
+ ieee_data_type *ieee = ieee_data(abfd);
+ ieee->w.r.data_part = bfd_tell(abfd);
+ for (s = abfd->sections; s != (asection *)NULL; s = s->next)
+ {
+ /* Sort the reloc records so we can insert them in the correct
+ places */
+ if (s->reloc_count != 0)
+ {
+ do_with_relocs(abfd, s);
+ }
+ else
+ {
+ do_without_relocs(abfd, s);
+ }
+ }
}
@@ -1650,10 +2310,20 @@ DEFUN(ieee_write_external_part,(abfd),
ieee_write_int(abfd, public_index);
if (p->section != (asection *)NULL)
{
- ieee_write_expression(abfd,
- p->value + p->section->output_offset,
- p->section->output_section,
- (asymbol *)NULL, false, 0);
+ if (abfd->flags & EXEC_P)
+ {
+ /* If fully linked, then output all symbols
+ relocated */
+ ieee_write_int(abfd,
+ p->value + p->section->output_offset+ p->section->output_section->vma);
+
+ }
+ else {
+ ieee_write_expression(abfd,
+ p->value + p->section->output_offset,
+ p->section->output_section,
+ (asymbol *)NULL, false, 0);
+ }
}
else
{
@@ -1701,14 +2371,36 @@ DEFUN(ieee_write_object_contents,(abfd),
ieee_write_id(abfd, bfd_printable_arch_mach(abfd->obj_arch,
abfd->obj_machine));
ieee_write_id(abfd, abfd->filename);
+
+
+
+
+ /* Fast forward over the variable bits */
+
+
+
ieee_write_byte(abfd, ieee_address_descriptor_enum);
ieee_write_byte(abfd, 8); /* Bits per MAU */
ieee_write_byte(abfd, 4); /* MAU's per address */
- /* Fast forward over the variable bits */
old = bfd_tell(abfd);
bfd_seek(abfd, 8 * N_W_VARIABLES, 1);
+
+ ieee->w.r.extension_record = bfd_tell(abfd);
+ ieee->w.r.environmental_record = bfd_tell(abfd);
+ ieee_write_byte(abfd, 0xf0);
+ ieee_write_byte(abfd, 0x20);
+ ieee_write_byte(abfd, 0x00);
+ ieee_write_byte(abfd, 0xf1);
+ ieee_write_byte(abfd, 0xce);
+ ieee_write_byte(abfd, 0x20);
+ ieee_write_byte(abfd, 0x00);
+ ieee_write_byte(abfd, 0x55);
+ ieee_write_id(abfd,"built using BFD");
+
+
+
/*
First write the symbols, this changes their values into table
indeces so we cant use it after this point
@@ -1718,6 +2410,13 @@ DEFUN(ieee_write_object_contents,(abfd),
ieee_write_section_part(abfd);
ieee_write_byte(abfd, ieee_record_seperator_enum);
+
+
+ /*
+ Write any debugs we have been told about
+ */
+ieee_write_debug_part(abfd);
+
/*
Can only write the data once the symbols have been written since
the data contains relocation information which points to the
@@ -1765,9 +2464,9 @@ DEFUN(ieee_make_empty_symbol,(abfd),
}
static bfd *
-ieee_openr_next_archived_file(arch, prev)
-bfd *arch;
-bfd *prev;
+DEFUN(ieee_openr_next_archived_file,(arch, prev),
+ bfd *arch AND
+ bfd *prev)
{
ieee_ar_data_type *ar = ieee_ar_data(arch);
/* take the next one from the arch state, or reset */
@@ -1788,6 +2487,7 @@ bfd *prev;
}
}
else {
+ bfd_error = no_more_archived_files;
return (bfd *)NULL;
}
@@ -1838,13 +2538,76 @@ DEFUN(ieee_sizeof_headers,(abfd, x),
return 0;
}
+
+
+static void
+DEFUN(ieee_bfd_debug_info_start,(abfd),
+ bfd *abfd)
+ {
+
+ }
+
+static void
+DEFUN(ieee_bfd_debug_info_end,(abfd),
+ bfd *abfd)
+ {
+
+ }
+
+
+/* Add this section to the list of sections we have debug info for, to
+ be ready to output it at close time
+ */
+static void
+DEFUN(ieee_bfd_debug_info_accumulate,(abfd, section),
+ bfd *abfd AND
+ asection *section)
+{
+ ieee_data_type *ieee = ieee_data(section->owner);
+ ieee_data_type *output_ieee = ieee_data(abfd);
+ /* can only accumulate data from other ieee bfds */
+ if (section->owner->xvec != abfd->xvec)
+ return;
+ /* Only bother once per bfd */
+ if (ieee->done_debug == true)
+ return;
+ ieee->done_debug = true;
+
+ /* Don't bother if there is no debug info */
+ if (ieee->w.r.debug_information_part == 0)
+ return;
+
+
+ /* Add to chain */
+ {
+ bfd_chain_type *n = (bfd_chain_type *) bfd_alloc(abfd, sizeof(bfd_chain_type));
+ n->this = section->owner;
+ n->next = (bfd_chain_type *)NULL;
+
+ if (output_ieee->chain_head) {
+ output_ieee->chain_head->next = n;
+ }
+ else {
+ output_ieee->chain_root = n;
+
+ }
+ output_ieee->chain_head = n;
+ }
+}
+
+
+
+
+
+
+#define FOO PROTO
#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_core_file_matches_executable_p ( FOO(boolean, (*),(bfd *, bfd *)))bfd_false
#define ieee_slurp_armap bfd_true
#define ieee_slurp_extended_name_table bfd_true
#define ieee_truncate_arname (void (*)())bfd_nullvoidptr
-#define ieee_write_armap (PROTO( boolean, (*),(bfd *, unsigned int, struct orl *, int, int))) bfd_nullvoidptr
+#define ieee_write_armap (FOO( boolean, (*),(bfd *, unsigned int, struct orl *, int, int))) bfd_nullvoidptr
#define ieee_get_lineno (struct lineno_cache_entry *(*)())bfd_nullvoidptr
#define ieee_close_and_cleanup bfd_generic_close_and_cleanup
@@ -1863,6 +2626,7 @@ bfd_target ieee_vec =
|SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
' ', /* ar_pad_char */
16, /* ar_max_namelen */
+ 1, /* minimum alignment */
_do_getb64, _do_putb64, _do_getb32, _do_putb32, _do_getb16, _do_putb16, /* data */
_do_getb64, _do_putb64, _do_getb32, _do_putb32, _do_getb16, _do_putb16, /* hdrs */
generated by cgit v1.1 at 2024-12-20 14:09:13 +0000