From b2c91bd95e7be9e695f155d375c38fd929ce50e9 Mon Sep 17 00:00:00 2001 From: Steve Chamberlain Date: Sat, 5 Oct 1991 00:39:21 +0000 Subject: [PATCH] Fri Oct 4 17:38:03 1991 Steve Chamberlain (steve at cygnus.com) * reloc.c: Extended NEWHOWTO macro * ieee.c: Changed the way 8bit pcrel is done * cpu-h8300.c: got the registers in the right order --- bfd/cpu-h8300.c | 46 ++- bfd/ieee.c | 1040 ++++++++++++++++++++++++++++++----------------- bfd/reloc.c | 2 +- 3 files changed, 703 insertions(+), 385 deletions(-) diff --git a/bfd/cpu-h8300.c b/bfd/cpu-h8300.c index 146285ec71..b4197cbdb7 100644 --- a/bfd/cpu-h8300.c +++ b/bfd/cpu-h8300.c @@ -75,6 +75,7 @@ DEFUN_VOID(bfd_h8_disassemble_init) } } + unsigned int DEFUN(bfd_h8_disassemble,(addr, data, stream), bfd_vma addr AND @@ -82,6 +83,10 @@ CONST bfd_byte *data AND FILE *stream) { /* Find the first entry in the table for this opcode */ + CONST static char *regnames[] = { + "r0h","r1h","r2h","r3h","r4h","r5h","r6h","r7h", + "r0l","r1l","r2l","r3l","r4l","r5l","r6l","r7l" }; + int rs = 0; int rd = 0; int rdisp = 0; @@ -163,8 +168,8 @@ FILE *stream) } fprintf(stream, "%02x %02x .word\tH'%x,H'%x\n", - data[0], data[1], - data[0], data[1]); + data[0], data[1], + data[0], data[1]); return 2; found:; { int i; @@ -190,9 +195,9 @@ FILE *stream) case IMM3: fprintf(stream, "#H'%x", (unsigned)abs); break; case RD8: - fprintf(stream, "r%d%c", rd/2, rd & 1 ? 'l' : 'h'); break; + fprintf(stream, "%s", regnames[rd]); break; case RS8: - fprintf(stream, "r%d%c", rs/2, rs & 1 ? 'l' : 'h'); break; + fprintf(stream, "%s",regnames[rs]); break; case RD16: fprintf(stream, "r%d", rd& 0x7); break; case RS16: @@ -211,7 +216,9 @@ FILE *stream) case ABS8DST: fprintf(stream, "@H'%x", (unsigned)abs); break; case DISP8: - fprintf(stream, "%d", (char)abs);break; + fprintf(stream, ".%s%d (%x)",(char)abs>0 ? "+" :"", (char)abs, + addr + (char)abs); + break; case DISPSRC: case DISPDST: fprintf(stream, "@(%d,r%d)", abs, rdisp & 0x7); break; @@ -334,20 +341,22 @@ asection *ignore_input_section) static reloc_howto_type howto_16 - = NEWHOWTO(howto16_callback,"abs16",1,0); + = NEWHOWTO(howto16_callback,"abs16",1,0,0); static reloc_howto_type howto_8 - = NEWHOWTO(howto8_callback,"abs8",0,0); + = NEWHOWTO(howto8_callback,"abs8",0,0,0); static reloc_howto_type howto_8_FFnn - = NEWHOWTO(howto8_FFnn_callback,"ff00+abs8",0,0); + = NEWHOWTO(howto8_FFnn_callback,"ff00+abs8",0,0,0); static reloc_howto_type howto_8_pcrel - = NEWHOWTO(howto8_pcrel_callback,"pcrel8",0,1); + = NEWHOWTO(howto8_pcrel_callback,"pcrel8",0,1,1); -static CONST struct reloc_howto_struct *DEFUN(local_bfd_reloc_type_lookup,( code), - bfd_reloc_code_enum_type code) +static CONST struct reloc_howto_struct * +DEFUN(local_bfd_reloc_type_lookup,(arch, code), + bfd_arch_info_struct_type *arch AND + bfd_reloc_code_enum_type code) { switch (code) { case BFD_RELOC_16: @@ -364,6 +373,17 @@ static CONST struct reloc_howto_struct *DEFUN(local_bfd_reloc_type_lookup,( cod int bfd_default_scan_num_mach(); +static boolean +DEFUN(h8300_scan,(info, string), +CONST struct bfd_arch_info_struct *info AND +CONST char *string) +{ + if (strcmp(string,"h8300") == 0) return true; + if (strcmp(string,"H8300") == 0) return true; + if (strcmp(string,"h8/300") == 0) return true; + if (strcmp(string,"H8/300") == 0) return true; + return false; +} static bfd_arch_info_struct_type arch_info_struct = { 16, /* 16 bits in a word */ @@ -371,11 +391,11 @@ static bfd_arch_info_struct_type arch_info_struct = 8, /* 8 bits in a byte */ bfd_arch_h8300, 0, /* only 1 machine */ - "H8/300", /* arch_name */ + "H8/300", /* arch_name */ "H8/300", /* printable name */ true, /* the default machine */ bfd_default_compatible, - bfd_default_scan, + h8300_scan, print_insn_h8300, local_bfd_reloc_type_lookup, 0, diff --git a/bfd/ieee.c b/bfd/ieee.c index 060eeea200..d6ed3ad76c 100644 --- a/bfd/ieee.c +++ b/bfd/ieee.c @@ -1,27 +1,26 @@ /* bfd back-end for ieee-695 objects. + Copyright (C) 1990-1991 Free Software Foundation, Inc. + Written by Steve Chamberlain of Cygnus Support. - 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 - parser. */ - -/* Copyright (C) 1990, 1991 Free Software Foundation, Inc. +This file is part of BFD, the Binary File Descriptor library. -This file is part of BFD, the Binary File Diddler. - -BFD is free software; you can redistribute it and/or modify +This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 1, or (at your option) -any later version. +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. -BFD is distributed in the hope that it will be useful, +This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License -along with BFD; see the file COPYING. If not, write to -the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ +along with this program; if not, write to the Free Software +Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ +/* 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 + parser. */ #include #include "bfd.h" @@ -41,6 +40,19 @@ DEFUN(ieee_write_byte,(abfd, byte), } +static void +DEFUN(ieee_write_twobyte,(abfd, twobyte), + bfd *abfd AND + int twobyte) +{ + bfd_byte b[2]; + b[1] = twobyte & 0xff; + b[0] = twobyte >> 8; + bfd_write((PTR)&b[0], 1, 2, abfd); +} + + + static void DEFUN(ieee_write_2bytes,(abfd, bytes), bfd *abfd AND @@ -58,7 +70,7 @@ DEFUN(ieee_write_int,(abfd, value), bfd *abfd AND bfd_vma value) { - if (value >= 0 && value <= 127) { + if (((unsigned)value) <= 127) { ieee_write_byte(abfd, value); } else { @@ -179,13 +191,15 @@ DEFUN(ieee_write_expression,(abfd, value, section, symbol, pcrel, index), asection *section AND asymbol *symbol AND boolean pcrel AND - unsigned int index) + unsigned int index) { unsigned int plus_count = 0; - ieee_write_int(abfd, value); + if (value != 0) + ieee_write_int(abfd, value); + if (section != (asection *)NULL) { plus_count++; - ieee_write_byte(abfd, ieee_variable_L_enum); + ieee_write_byte(abfd, ieee_variable_R_enum); ieee_write_byte(abfd, section->index +IEEE_SECTION_NUMBER_BASE); } @@ -207,7 +221,7 @@ DEFUN(ieee_write_expression,(abfd, value, section, symbol, pcrel, index), We can easily do a local as a section+offset */ if (symbol->section != (asection *)NULL) { /* If this symbol is not absolute, add the base of it */ - ieee_write_byte(abfd, ieee_variable_L_enum); + ieee_write_byte(abfd, ieee_variable_R_enum); /* or L */ ieee_write_byte(abfd, symbol->section->index + IEEE_SECTION_NUMBER_BASE); plus_count++; @@ -228,9 +242,15 @@ DEFUN(ieee_write_expression,(abfd, value, section, symbol, pcrel, index), ieee_write_byte(abfd, ieee_function_minus_enum); } - while (plus_count > 0) { - ieee_write_byte(abfd, ieee_function_plus_enum); - plus_count--; + if (value != 0){ + while (plus_count > 0) { + ieee_write_byte(abfd, ieee_function_plus_enum); + plus_count--; + } + } + else { + if (!plus_count) + ieee_write_byte(abfd,0); } } @@ -253,7 +273,7 @@ DEFUN(ieee_write_int5,(buffer, value), bfd_byte*buffer AND bfd_vma value ) { - buffer[0] = ieee_number_repeat_4_enum; + buffer[0] = (bfd_byte)ieee_number_repeat_4_enum; buffer[1] = (value >> 24 ) & 0xff; buffer[2] = (value >> 16 ) & 0xff; buffer[3] = (value >> 8 ) & 0xff; @@ -324,17 +344,26 @@ typedef struct static reloc_howto_type abs32_howto - = HOWTO(1,0,2,32,0,0,0,true,0,"abs32",true,0xffffffff, 0xffffffff,false); + = HOWTO(1,0,2,32,false,0,false,true,0,"abs32",true,0xffffffff, 0xffffffff,false); static reloc_howto_type abs16_howto - = HOWTO(1,0,1,16,0,0,0,true,0,"abs16",true,0x0000ffff, 0x0000ffff,false); + = HOWTO(1,0,1,16,false,0,false,true,0,"abs16",true,0x0000ffff, 0x0000ffff,false); + +static +reloc_howto_type abs8_howto + = HOWTO(1,0,0,8,false,0,false,true,0,"abs8",true,0x000000ff, 0x000000ff,false); static reloc_howto_type rel32_howto - = HOWTO(1,0,2,32,1,0,0,true,0,"rel32",true,0xffffffff, 0xffffffff,false); + = HOWTO(1,0,2,32,true,0,false,true,0,"rel32",true,0xffffffff, 0xffffffff,true); static reloc_howto_type rel16_howto - = HOWTO(1,0,1,16,1,0,0,true,0,"rel16",true,0x0000ffff, 0x0000ffff,false); + = HOWTO(1,0,1,16,true,0,false,true,0,"rel16",true,0x0000ffff, 0x0000ffff,true); + +static +reloc_howto_type rel8_howto + = HOWTO(1,0,0,8,true,0,false,true,0,"rel8",true,0x000000ff, 0x000000ff,true); + static ieee_symbol_index_type NOSYMBOL = { 0, 0}; @@ -396,7 +425,7 @@ DEFUN(parse_expression,(ieee, value, section, symbol, pcrel, extra), 0, ieee->section_table[must_parse_int(&(ieee->h))]->size); break; - + case ieee_variable_I_enum: case ieee_variable_X_enum: /* Push the address of external variable n */ { @@ -417,7 +446,7 @@ DEFUN(parse_expression,(ieee, value, section, symbol, pcrel, extra), POP(sy, section1, value1); POP(sy, section_dummy, value2); - PUSH(sy, section1, value1-value2); + PUSH(sy, section1 ? section1 : section_dummy, value1-value2); } break; case ieee_function_plus_enum: @@ -476,6 +505,42 @@ DEFUN(parse_expression,(ieee, value, section, symbol, pcrel, extra), #define ieee_pos(abfd) ieee_data(abfd)->h.input_p -ieee_data(abfd)->h.first_byte +static unsigned int last_index; + +static ieee_symbol_type * +DEFUN(get_symbol,(abfd, + ieee, + last_symbol, + symbol_count, +pptr, +max_index + ), + bfd *abfd AND + ieee_data_type *ieee AND + ieee_symbol_type *last_symbol AND + unsigned int *symbol_count AND + ieee_symbol_type *** pptr AND + unsigned int *max_index + ) +{ + /* Need a new symbol */ + unsigned int new_index = must_parse_int(&(ieee->h)); + if (new_index != last_index) { + ieee_symbol_type * new_symbol = (ieee_symbol_type *)bfd_alloc(ieee->h.abfd, + sizeof(ieee_symbol_type)); + + new_symbol->index = new_index; + last_index = new_index; + ( *symbol_count)++; + ** pptr= new_symbol; + *pptr = &new_symbol->next; + if (new_index > *max_index) { + *max_index = new_index; + } + return new_symbol; + } + return last_symbol; +} static void DEFUN(ieee_slurp_external_symbols,(abfd), bfd *abfd) @@ -483,109 +548,131 @@ DEFUN(ieee_slurp_external_symbols,(abfd), ieee_data_type *ieee = ieee_data(abfd); file_ptr offset = ieee->w.r.external_part; + ieee_symbol_type **prev_symbols_ptr = &ieee->external_symbols; ieee_symbol_type **prev_reference_ptr = &ieee->external_reference; - ieee_symbol_type *symbol; + ieee_symbol_type *symbol = (ieee_symbol_type *)NULL; unsigned int symbol_count = 0; boolean loop = true; - + last_index = 0xffffff; ieee->symbol_table_full = true; ieee_seek(abfd, offset ); while (loop) { switch (this_byte(&(ieee->h))) { + case ieee_nn_record: + next_byte(&(ieee->h)); + symbol = get_symbol(abfd, ieee, symbol, &symbol_count, + &prev_symbols_ptr, + &ieee->external_symbol_max_index); + + symbol->symbol.the_bfd = abfd; + symbol->symbol.name = read_id(&(ieee->h)); + symbol->symbol.udata = (PTR)NULL; + symbol->symbol.flags = BSF_NO_FLAGS; + + + break; case ieee_external_symbol_enum: next_byte(&(ieee->h)); - symbol = (ieee_symbol_type *)bfd_alloc(ieee->h.abfd, sizeof(ieee_symbol_type)); + + symbol = get_symbol(abfd, ieee, symbol, &symbol_count, + &prev_symbols_ptr, + &ieee->external_symbol_max_index); + - *prev_symbols_ptr = symbol; - prev_symbols_ptr= &symbol->next; - 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->h)); symbol->symbol.udata = (PTR)NULL; symbol->symbol.flags = BSF_NO_FLAGS; break; case ieee_attribute_record_enum >> 8: - { - unsigned int symbol_name_index; - unsigned int symbol_type_index; - unsigned int symbol_attribute_def; - bfd_vma value; - 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->h),&value); + { + unsigned int symbol_name_index; + unsigned int symbol_type_index; + unsigned int symbol_attribute_def; + bfd_vma value; + 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)); + switch (symbol_attribute_def) { + case 63: + /* Module misc; followed by two fields which describe the + current module block. The first fired is the type id + number, the second is the number of asn records + associated with the directive */ + parse_int(&(ieee->h),&value); + parse_int(&(ieee->h),&value); + break; - } + default: + parse_int(&(ieee->h),&value); + break; + } + } break; case ieee_value_record_enum >> 8: - { - unsigned int symbol_name_index; - ieee_symbol_index_type symbol_ignore; - boolean pcrel_ignore; - unsigned int extra; - next_byte(&(ieee->h)); - next_byte(&(ieee->h)); - - symbol_name_index = must_parse_int(&(ieee->h)); - parse_expression(ieee, - &symbol->symbol.value, - &symbol->symbol.section, - &symbol_ignore, - &pcrel_ignore, - &extra); - if (symbol->symbol.section != (asection *)NULL) { - symbol->symbol.flags = BSF_GLOBAL | BSF_EXPORT; - } - else { - symbol->symbol.flags = BSF_GLOBAL | BSF_EXPORT | BSF_ABSOLUTE; + { + unsigned int symbol_name_index; + ieee_symbol_index_type symbol_ignore; + boolean pcrel_ignore; + unsigned int extra; + next_byte(&(ieee->h)); + next_byte(&(ieee->h)); + + symbol_name_index = must_parse_int(&(ieee->h)); + parse_expression(ieee, + &symbol->symbol.value, + &symbol->symbol.section, + &symbol_ignore, + &pcrel_ignore, + &extra); + if (symbol->symbol.section != (asection *)NULL) { + symbol->symbol.flags = BSF_GLOBAL | BSF_EXPORT; + } + else { + symbol->symbol.flags = BSF_GLOBAL | BSF_EXPORT | BSF_ABSOLUTE; + } } - } break; case ieee_weak_external_reference_enum: - { bfd_vma size; - bfd_vma value ; - next_byte(&(ieee->h)); - /* Throw away the external reference index */ - (void)must_parse_int(&(ieee->h)); - /* Fetch the default size if not resolved */ - size = must_parse_int(&(ieee->h)); - /* Fetch the defautlt value if available */ - if ( parse_int(&(ieee->h), &value) == false) { - value = 0; + { bfd_vma size; + bfd_vma value ; + next_byte(&(ieee->h)); + /* Throw away the external reference index */ + (void)must_parse_int(&(ieee->h)); + /* Fetch the default size if not resolved */ + size = must_parse_int(&(ieee->h)); + /* Fetch the defautlt value if available */ + if ( parse_int(&(ieee->h), &value) == false) { + value = 0; + } + /* This turns into a common */ + symbol->symbol.flags = BSF_FORT_COMM; + symbol->symbol.value = size; } - /* This turns into a common */ - symbol->symbol.flags = BSF_FORT_COMM; - symbol->symbol.value = size; - } break; case ieee_external_reference_enum: 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->h)); + + symbol = get_symbol(abfd, ieee, symbol, &symbol_count, + &prev_reference_ptr, + &ieee->external_reference_max_index); + + symbol->symbol.the_bfd = abfd; symbol->symbol.name = read_id(&(ieee->h)); symbol->symbol.udata = (PTR)NULL; symbol->symbol.section = (asection *)NULL; symbol->symbol.value = (bfd_vma)0; symbol->symbol.flags = BSF_UNDEFINED; - if (symbol->index > ieee->external_reference_max_index) { - ieee->external_reference_max_index = symbol->index; - } + BFD_ASSERT (symbol->index >= ieee->external_reference_min_index); break; @@ -620,6 +707,8 @@ DEFUN(ieee_slurp_external_symbols,(abfd), /* There are gaps in the table -- */ ieee->symbol_table_full = false; } + + *prev_symbols_ptr = (ieee_symbol_type *)NULL; *prev_reference_ptr = (ieee_symbol_type *)NULL; } @@ -660,6 +749,10 @@ DEFUN(ieee_get_symtab,(abfd, location), static asymbol empty_symbol = { &dummy_bfd," ieee empty",(symvalue)0,BSF_DEBUGGING | BSF_ABSOLUTE}; +if (abfd->symcount) { + + + ieee_data_type *ieee = ieee_data(abfd); dummy_bfd.xvec= &ieee_vec; @@ -699,10 +792,24 @@ DEFUN(ieee_get_symtab,(abfd, location), location[abfd->symcount] = (asymbol *)NULL; - +} return abfd->symcount; } - +static asection * +DEFUN(get_section_entry,(abfd, ieee,index), + bfd *abfd AND + ieee_data_type *ieee AND + unsigned int index) +{ + if (ieee->section_table[index] == (asection *)NULL) { + asection *section = bfd_make_section(abfd, " tempname"); + ieee->section_table[index] = section; + section->flags = SEC_NO_FLAGS; + section->target_index = index; + ieee->section_table[index] = section; + } + return ieee->section_table[index]; +} static void DEFUN(ieee_slurp_sections,(abfd), @@ -719,102 +826,133 @@ DEFUN(ieee_slurp_sections,(abfd), while (true) { switch (this_byte(&(ieee->h))) { case ieee_section_type_enum: - { - unsigned int section_index ; - 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); - - section = bfd_make_section(abfd, " tempname"); - ieee->section_table[section_index] = section; - section->flags = SEC_NO_FLAGS; - section->target_index = section_index; - section_type[0] = this_byte_and_next(&(ieee->h)); - switch (section_type[0]) { - case 0xC3: - 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->h)); - section->flags |= SEC_LOAD | SEC_CODE; - break; - case 0xC4: - next_byte(&(ieee->h)); - section->flags |= SEC_LOAD | SEC_DATA; - /* Normal data */ - break; - case 0xD2: - next_byte(&(ieee->h)); - /* Normal rom data */ - section->flags |= SEC_LOAD | SEC_ROM | SEC_DATA; - break; - default: + { + unsigned int section_index ; + 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); + + section =get_section_entry(abfd, ieee, section_index); + + section_type[0] = this_byte_and_next(&(ieee->h)); + switch (section_type[0]) { + case 0xC1: + /* Normal attributes for absolute sections */ + section_type[1] = this_byte(&(ieee->h)); + section->flags = SEC_LOAD | SEC_ALLOC | SEC_HAS_CONTENTS; + switch(section_type[1]) { + case 0xD3: + next_byte(&(ieee->h)); + section_type[2] = this_byte(&(ieee->h)); + switch (section_type[2]) + { + case 0xD0: + /* Normal code */ + next_byte(&(ieee->h)); + section->flags |= SEC_LOAD | SEC_CODE; + break; + case 0xC4: + next_byte(&(ieee->h)); + section->flags |= SEC_LOAD | SEC_DATA; + /* Normal data */ + break; + case 0xD2: + next_byte(&(ieee->h)); + /* Normal rom data */ + section->flags |= SEC_LOAD | SEC_ROM | SEC_DATA; + break; + default: + break; + } + } break; + case 0xC3: + 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->h)); + section->flags |= SEC_LOAD | SEC_CODE; + break; + case 0xC4: + next_byte(&(ieee->h)); + section->flags |= SEC_LOAD | SEC_DATA; + /* Normal data */ + break; + case 0xD2: + next_byte(&(ieee->h)); + /* Normal rom data */ + section->flags |= SEC_LOAD | SEC_ROM | SEC_DATA; + break; + default: + break; + } } - } - section->name = read_id(&(ieee->h)); - { bfd_vma parent, brother, context; - parse_int(&(ieee->h), &parent); - parse_int(&(ieee->h), &brother); - parse_int(&(ieee->h), &context); - } + section->name = read_id(&(ieee->h)); + { bfd_vma parent, brother, context; + parse_int(&(ieee->h), &parent); + parse_int(&(ieee->h), &brother); + parse_int(&(ieee->h), &context); + } - } + } break; case ieee_section_alignment_enum: - { - unsigned int section_index; - bfd_vma value; - next_byte(&(ieee->h)); - section_index = must_parse_int(&ieee->h); - if (section_index > ieee->section_count) { - ieee->section_count = section_index; + { + unsigned int section_index; + bfd_vma value; + asection *section; + next_byte(&(ieee->h)); + section_index = must_parse_int(&ieee->h); + section = get_section_entry(abfd, ieee, section_index); + if (section_index > ieee->section_count) { + ieee->section_count = section_index; + } + section->alignment_power = + bfd_log2(must_parse_int(&ieee->h)); + (void)parse_int(&(ieee->h), & value); } - ieee->section_table[section_index]->alignment_power = - 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->h)); - switch (t) { - case ieee_section_size_enum: - 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->h))]; - section->size = must_parse_int(&(ieee->h)); - break; - case ieee_region_base_address_enum: - 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->h)); - must_parse_int(&(ieee->h)); - break; - case ieee_m_value_enum: - 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->h))]; - section->vma = must_parse_int(&(ieee->h)); - break; - case ieee_section_offset_enum: - (void) must_parse_int(&(ieee->h)); - (void) must_parse_int(&(ieee->h)); - break; - default: - return; + { + ieee_record_enum_type t = (ieee_record_enum_type)(read_2bytes(&(ieee->h))); + + switch (t) { + case ieee_section_size_enum: + 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->h))]; + section->size = must_parse_int(&(ieee->h)); + break; + case ieee_region_base_address_enum: + 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->h)); + must_parse_int(&(ieee->h)); + break; + case ieee_m_value_enum: + 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->h))]; + section->vma = must_parse_int(&(ieee->h)); + break; + case ieee_section_offset_enum: + (void) must_parse_int(&(ieee->h)); + (void) must_parse_int(&(ieee->h)); + break; + default: + return; + } } - } break; default: return; @@ -835,7 +973,7 @@ DEFUN(ieee_archive_p,(abfd), 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 ; @@ -875,7 +1013,7 @@ uint8e_type buffer[512]; while (loop) { ieee_ar_obstack_type t; int rec =read_2bytes(&(ieee->h)); - if (rec ==ieee_assign_value_to_variable_enum) { + if (rec ==(int)ieee_assign_value_to_variable_enum) { int record_number = must_parse_int(&(ieee->h)); t.file_offset = must_parse_int(&(ieee->h)); t.abfd = (bfd *)NULL; @@ -888,7 +1026,7 @@ uint8e_type buffer[512]; /* 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); + bfd_read((PTR)buffer, 1, sizeof(buffer), abfd); ieee->h.first_byte = buffer; ieee->h.input_p = buffer; } @@ -904,7 +1042,7 @@ uint8e_type buffer[512]; 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); + bfd_read((PTR)buffer, 1, sizeof(buffer), abfd); ieee->h.first_byte = buffer; ieee->h.input_p = buffer; @@ -969,10 +1107,15 @@ DEFUN(ieee_object_p,(abfd), 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); + /* Determine the architecture and machine type of the object file. + */ + { + bfd_arch_info_struct_type *arch = bfd_scan_arch(processor); + if (arch == 0) goto fail; + abfd->arch_info = arch; + } - if (this_byte(&(ieee->h)) != ieee_address_descriptor_enum) { + if (this_byte(&(ieee->h)) != (int)ieee_address_descriptor_enum) { goto fail; } next_byte(&(ieee->h)); @@ -985,14 +1128,14 @@ DEFUN(ieee_object_p,(abfd), } /* If there is a byte order info, take it */ - if (this_byte(&(ieee->h)) == ieee_variable_L_enum || - this_byte(&(ieee->h)) == ieee_variable_M_enum) + if (this_byte(&(ieee->h)) == (int)ieee_variable_L_enum || + this_byte(&(ieee->h)) == (int)ieee_variable_M_enum) next_byte(&(ieee->h)); for (part = 0; part < N_W_VARIABLES; part++) { boolean ok; - if (read_2bytes(&(ieee->h)) != ieee_assign_value_to_variable_enum) { + if (read_2bytes(&(ieee->h)) != (int) ieee_assign_value_to_variable_enum) { goto fail; } if (this_byte_and_next(&(ieee->h)) != part) { @@ -1125,6 +1268,13 @@ DEFUN(do_one,(ieee, current_map, location_ptr,s), &pcrel, &extra); r->relent.address = current_map->pc; s->reloc_count++; + + if (this_byte(&(ieee->h)) == (int)ieee_comma) { + next_byte(&(ieee->h)); + /* Fetch number of bytes to pad */ + extra = must_parse_int(&(ieee->h)); + }; + switch (this_byte(&(ieee->h))) { case ieee_function_signed_close_b_enum: next_byte(&(ieee->h)); @@ -1139,25 +1289,32 @@ DEFUN(do_one,(ieee, current_map, location_ptr,s), break; } /* Build a relocation entry for this type */ - if (this_byte(&(ieee->h)) == ieee_comma) { - next_byte(&(ieee->h)); - /* Fetch number of bytes to pad */ - extra = must_parse_int(&(ieee->h)); - }; - /* If pc rel then stick -ve pc into instruction - and take out of reloc*/ + and take out of reloc .. + + I've changed this. It's all too + complicated. I keep 0 in the + instruction now. + */ switch (extra) { case 0: case 4: + if (pcrel == true) { +#if KEEPMINUSPCININST 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; + r->relent.addend -= + current_map->pc; +#else + bfd_put_32(ieee->h.abfd,0, location_ptr + + current_map->pc); + r->relent.howto = &rel32_howto; +#endif } else { @@ -1169,16 +1326,40 @@ DEFUN(do_one,(ieee, current_map, location_ptr,s), break; case 2: if (pcrel == true) { +#if KEEPMINUSPCININST 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->h.abfd, 0, location_ptr +current_map->pc); + r->relent.howto = &rel16_howto; +#endif } + else { bfd_put_16(ieee->h.abfd, 0, location_ptr +current_map->pc); r->relent.howto = &abs16_howto; } current_map->pc +=2; break; + case 1: + if (pcrel == true) { +#if KEEPMINUSPCININST + bfd_put_8(ieee->h.abfd, (int)(-current_map->pc), location_ptr +current_map->pc); + r->relent.addend -= current_map->pc; + r->relent.howto = &rel8_howto; +#else + bfd_put_8(ieee->h.abfd,0, location_ptr +current_map->pc); + r->relent.howto = &rel8_howto; +#endif + } + else { + bfd_put_8(ieee->h.abfd, 0, location_ptr +current_map->pc); + r->relent.howto = &abs8_howto; + } + current_map->pc +=1; + break; default: BFD_FAIL(); @@ -1211,11 +1392,11 @@ static boolean DEFUN(ieee_slurp_section_data,(abfd), bfd *abfd) { - bfd_byte *location_ptr ; + bfd_byte *location_ptr = (bfd_byte *)NULL; ieee_data_type *ieee = ieee_data(abfd); unsigned int section_number ; - ieee_per_section_type *current_map; + ieee_per_section_type *current_map = (ieee_per_section_type *)NULL; asection *s; /* Seek to the start of the data area */ if (ieee->read_data== true) return true; @@ -1296,7 +1477,7 @@ DEFUN(ieee_slurp_section_data,(abfd), next_byte(&(ieee->h)); iterations = must_parse_int(&(ieee->h)); start = ieee->h.input_p; - if (start[0] == ieee_load_constant_bytes_enum && + if (start[0] == (int)ieee_load_constant_bytes_enum && start[1] == 1) { while (iterations != 0) { location_ptr[current_map->pc++] = start[2]; @@ -1360,7 +1541,7 @@ DEFUN(ieee_get_section_contents,(abfd, section, location, offset, count), { ieee_per_section_type *p = (ieee_per_section_type *) section->used_by_bfd; ieee_slurp_section_data(abfd); - (void) memcpy(location, p->data + offset, (unsigned)count); + (void) memcpy((PTR)location, (PTR)(p->data + offset), (unsigned)count); return true; } @@ -1377,7 +1558,7 @@ DEFUN(ieee_canonicalize_reloc,(abfd, section, relptr, symbols), ieee_data_type *ieee = ieee_data(abfd); while (src != (ieee_reloc_type *)NULL) { - /* Work out which symbol to attatch it this reloc to */ + /* Work out which symbol to attach it this reloc to */ switch (src->symbol.letter) { case 'X': src->relent.sym_ptr_ptr = @@ -1397,16 +1578,6 @@ DEFUN(ieee_canonicalize_reloc,(abfd, section, relptr, symbols), return section->reloc_count; } -boolean -DEFUN(ieee_set_arch_mach,(abfd, arch, machine), - bfd *abfd AND - enum bfd_architecture arch AND - unsigned long machine) -{ - abfd->obj_arch = arch; - abfd->obj_machine = machine; - return true; -} static int @@ -1479,11 +1650,13 @@ DEFUN(ieee_write_section_part,(abfd), ieee_write_2bytes(abfd, ieee_section_size_enum); ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE); ieee_write_int(abfd, s->size); - - /* Vma */ - 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); + if (abfd->flags & EXEC_P) { + /* Relocateable sections don't have asl records */ + /* Vma */ + 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); + } } } @@ -1496,7 +1669,7 @@ DEFUN(do_with_relocs,(abfd, s), asection *s) { unsigned int relocs_to_go = s->reloc_count; - bfd_byte header[11]; + bfd_byte *stream = ieee_per_section(s)->data; arelent **p = s->orelocation; @@ -1508,102 +1681,138 @@ DEFUN(do_with_relocs,(abfd, s), sizeof(arelent **), comp); + /* Output the section preheader */ + ieee_write_byte(abfd, ieee_set_current_section_enum); + ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE); + ieee_write_twobyte(abfd, ieee_set_current_pc_enum); + ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE); + ieee_write_expression(abfd, 0, s, 0, 0, 0); - /* 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 (relocs_to_go == 0) + { + /* If there arn't any relocations then output the load constant byte + opcode rather than the load with relocation opcode */ + + while (current_byte_index < s->size) { + bfd_size_type run; + unsigned int MAXRUN = 32; + 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; + if (run != 0) { + ieee_write_byte(abfd, ieee_load_constant_bytes_enum); + /* Output a stream of bytes */ + ieee_write_int(abfd, run); + bfd_write((PTR)(stream + current_byte_index), + 1, + run, + abfd); + current_byte_index += run; + } } + } + else + { + ieee_write_byte(abfd, ieee_load_with_relocation_enum); - 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); + /* Output the data stream as the longest sequence of bytes + possible, allowing for the a reasonable packet size and + relocation stuffs */ - 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); + 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; + } - relocs_to_go --; - p++; - } + 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 0 + if (r->howto->pc_relative) { + r->addend += current_byte_index ; + } +#endif + + 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; + case 0: + ov = bfd_get_8(abfd, + stream+current_byte_index); + current_byte_index ++; + break; + default: + ov = 0; + 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->index); + } + else { + ieee_write_expression(abfd, r->addend + ov, + r->section, + (asymbol *)NULL, + r->howto->pc_relative, s->index); + } + + if (1 || r->howto->size != 2) { + ieee_write_byte(abfd, ieee_comma); + ieee_write_int(abfd, 1<< r->howto->size); + } + ieee_write_byte(abfd, + ieee_function_either_close_b_enum); + + relocs_to_go --; + p++; + } + + } + } + } } /* If there are no relocations in the output section then we can @@ -1618,7 +1827,7 @@ DEFUN(do_as_repeat, (abfd, 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, ieee_set_current_pc_enum & 0xff); ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE); ieee_write_int(abfd, s->vma ); @@ -1667,12 +1876,12 @@ static int output_buffer; static void fill() { - bfd_read(input_ptr_start, 1, input_ptr_end - input_ptr_start, input_bfd); + bfd_read((PTR)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); + bfd_write((PTR)(output_ptr_start),1,output_ptr - output_ptr_start, output_bfd); output_ptr = output_ptr_start; output_buffer++; } @@ -1984,14 +2193,13 @@ static void copy_till_end() static void f2_record() { - int ch; NEXT(); OUT(0xf2); INT ; NEXT(); OUT(0xce); INT ; -copy_till_end(); + copy_till_end(); } @@ -2165,7 +2373,7 @@ DEFUN(relocate_debug,(output, input), input_ptr_start = input_ptr = input_buffer; input_ptr_end = input_buffer + IBS; input_bfd = input; - bfd_read(input_ptr_start, 1, IBS, input); + bfd_read((PTR)input_ptr_start, 1, IBS, input); block(); } /* @@ -2181,22 +2389,67 @@ DEFUN(ieee_write_debug_part, (abfd), ieee_data_type *ieee = ieee_data(abfd); bfd_chain_type *chain = ieee->chain_root; unsigned char output_buffer[OBS]; + boolean some_debug = false; + file_ptr here = bfd_tell(abfd); + 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; + if (chain == (bfd_chain_type *)NULL) { + /* There is no debug info, so we'll fake some up */ + CONST static char fake[] = { + 0xf8, 0xa, 0, 5, 't', 't', 't', 't', 't', 0, 2, 3, + '1','.','1',0x82, 1991>>8, 1991 & 0xff, 9, 20, 11, 07,50 }; + ieee->w.r.debug_information_part = 0; + +#if 0 +here; + + +/* bfd_write(fake, 1, sizeof(fake), abfd);*/ + /* Now write a header for each section */ + { + int i = 0; + asection *s = abfd->sections; + while (s) { + ieee_write_byte(abfd, 0xf8); + ieee_write_byte(abfd, 0x0b); + ieee_write_byte(abfd, 0); + ieee_write_byte(abfd, 0); + ieee_write_byte(abfd, 1); + ieee_write_byte(abfd, i + IEEE_SECTION_NUMBER_BASE); + ieee_write_expression(abfd, 0, s, 0, 0, 0); + ieee_write_byte(abfd,0); + ieee_write_byte(abfd, 0xf9); + ieee_write_expression(abfd, s->size, 0, 0, 0, 0); + s = s->next; + i++; + } + /* Close the scope */ + ieee_write_byte(abfd, 0xf9); + } +#endif } + else{ + 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; + } + if (some_debug) { + ieee->w.r.debug_information_part = here; + } + else { + ieee->w.r.debug_information_part = 0; + } + } flush(); } @@ -2214,7 +2467,7 @@ DEFUN(ieee_write_data_part,(abfd), places */ if (s->reloc_count != 0) { - do_with_relocs(abfd, s); + do_with_relocs(abfd, s); } else { @@ -2253,8 +2506,8 @@ DEFUN(ieee_set_section_contents,(abfd, section, location, offset, count), if (ieee_per_section(section)->data == (bfd_byte *)NULL) { init_for_output(abfd); } - (void) memcpy(ieee_per_section(section)->data + offset, - location, + (void) memcpy((PTR)(ieee_per_section(section)->data + offset), + (PTR)location, (unsigned int)count); return true; } @@ -2273,11 +2526,14 @@ DEFUN(ieee_write_external_part,(abfd), ieee_data_type *ieee = ieee_data(abfd); unsigned int reference_index = IEEE_REFERENCE_BASE; - unsigned int public_index = IEEE_PUBLIC_BASE; - ieee->w.r.external_part = bfd_tell(abfd); + unsigned int public_index = IEEE_PUBLIC_BASE+2; + file_ptr here = bfd_tell(abfd); + boolean hadone = false; if (abfd->outsymbols != (asymbol **)NULL) { + for (q = abfd->outsymbols; *q != (asymbol *)NULL; q++) { asymbol *p = *q; + hadone = true; if (p->flags & BSF_UNDEFINED) { /* This must be a symbol reference .. */ ieee_write_byte(abfd, ieee_external_reference_enum); @@ -2301,37 +2557,45 @@ DEFUN(ieee_write_external_part,(abfd), else if(p->flags & BSF_GLOBAL) { /* This must be a symbol definition */ + ieee_write_byte(abfd, ieee_external_symbol_enum); ieee_write_int(abfd, public_index ); ieee_write_id(abfd, p->name); + ieee_write_twobyte(abfd, ieee_attribute_record_enum); + ieee_write_int(abfd, public_index ); + ieee_write_byte(abfd, 15); /* instruction address */ + ieee_write_byte(abfd, 19); /* static symbol */ + ieee_write_byte(abfd, 1); /* one of them */ + + /* Write out the value */ ieee_write_2bytes(abfd, ieee_value_record_enum); ieee_write_int(abfd, public_index); if (p->section != (asection *)NULL) - { - 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); + { + 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 { + } + else { + ieee_write_expression(abfd, + p->value + p->section->output_offset, + p->section->output_section, + (asymbol *)NULL, false, 0); + } + } + else + { ieee_write_expression(abfd, - p->value + p->section->output_offset, - p->section->output_section, + p->value, + (asection *)NULL, (asymbol *)NULL, false, 0); } - } - else - { - ieee_write_expression(abfd, - p->value, - (asection *)NULL, - (asymbol *)NULL, false, 0); - } p->value = public_index; public_index++; } @@ -2341,19 +2605,50 @@ DEFUN(ieee_write_external_part,(abfd), } } } + if (hadone) + ieee->w.r.external_part = here; } + +CONST static char exten[] = + { + 0xf0, 0x20, 0x00, + 0xf1, 0xce, 0x20, 0x00, 37, 3, 3, /* Set version 3 rev 3 */ + 0xf1, 0xce, 0x20, 0x00, 39, 2, /* keep symbol in original case */ + 0xf1, 0xce, 0x20, 0x00, 38 /* set object type relocateable to x */ + }; + +CONST static char environ[] = + { + 0xf0, 0x21, 0x00, + +/* 0xf1, 0xce, 0x21, 00, 50, 0x82, 0x07, 0xc7, 0x09, 0x11, 0x11, + 0x19, 0x2c, +*/ + 0xf1, 0xce, 0x21, 00, 52, 0x00, /* exec ok */ + + 0xf1, 0xce, 0x21, 0, 53, 0x03, /* host unix */ +/* 0xf1, 0xce, 0x21, 0, 54, 2,1,1 tool & version # */ + }; + static void DEFUN(ieee_write_me_part,(abfd), bfd *abfd) { ieee_data_type *ieee= ieee_data(abfd); - ieee->w.r.me_record = bfd_tell(abfd); - - ieee_write_2bytes(abfd, ieee_value_starting_address_enum); - ieee_write_int(abfd, abfd->start_address); + ieee->w.r.trailer_part = bfd_tell(abfd); + if (abfd->start_address) { + ieee->w.r.me_record = bfd_tell(abfd); + ieee_write_2bytes(abfd, ieee_value_starting_address_enum); + ieee_write_byte(abfd, ieee_function_either_open_b_enum); + ieee_write_int(abfd, abfd->start_address); + ieee_write_byte(abfd, ieee_function_either_close_b_enum); + } + else { + ieee->w.r.me_record = bfd_tell(abfd); + } ieee_write_byte(abfd, ieee_module_end_enum); } @@ -2368,8 +2663,7 @@ DEFUN(ieee_write_object_contents,(abfd), bfd_seek(abfd, 0, 0); ieee_write_byte(abfd, ieee_module_beginning_enum); - ieee_write_id(abfd, bfd_printable_arch_mach(abfd->obj_arch, - abfd->obj_machine)); + ieee_write_id(abfd, bfd_printable_name(abfd)); ieee_write_id(abfd, abfd->filename); @@ -2380,42 +2674,46 @@ DEFUN(ieee_write_object_contents,(abfd), 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 */ + + /* Bits per MAU */ + ieee_write_byte(abfd, bfd_arch_bits_per_byte(abfd)); + /* MAU's per address */ + ieee_write_byte(abfd, bfd_arch_bits_per_address(abfd) / + bfd_arch_bits_per_byte(abfd)); + old = bfd_tell(abfd); bfd_seek(abfd, 8 * N_W_VARIABLES, 1); ieee->w.r.extension_record = bfd_tell(abfd); + bfd_write(exten, 1, sizeof(exten), abfd); + if (abfd->flags & EXEC_P) + ieee_write_byte(abfd, 0x1); /* Absolute */ + else + ieee_write_byte(abfd, 0x2); /* Relocateable */ + 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"); - - + bfd_write(environ, 1, sizeof(environ), abfd); + output_bfd = abfd; + flush(); + ieee_write_section_part(abfd); /* First write the symbols, this changes their values into table indeces so we cant use it after this point */ ieee_write_external_part(abfd); - ieee_write_byte(abfd, ieee_record_seperator_enum); + /* ieee_write_byte(abfd, ieee_record_seperator_enum);*/ - ieee_write_section_part(abfd); - ieee_write_byte(abfd, ieee_record_seperator_enum); + + /* ieee_write_byte(abfd, ieee_record_seperator_enum);*/ /* Write any debugs we have been told about */ -ieee_write_debug_part(abfd); + ieee_write_debug_part(abfd); /* Can only write the data once the symbols have been written since @@ -2423,7 +2721,7 @@ ieee_write_debug_part(abfd); symbols */ ieee_write_data_part(abfd); - ieee_write_byte(abfd, ieee_record_seperator_enum); + /* At the end we put the end ! @@ -2610,7 +2908,7 @@ DEFUN(ieee_bfd_debug_info_accumulate,(abfd, section), #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 - +#define ieee_set_arch_mach bfd_default_set_arch_mach /*SUPPRESS 460 */ bfd_target ieee_vec = diff --git a/bfd/reloc.c b/bfd/reloc.c index 993ff94552..4804e84e5f 100644 --- a/bfd/reloc.c +++ b/bfd/reloc.c @@ -365,7 +365,7 @@ And will be replaced with the totally magic way. But for the moment, we are compatible, so do it this way.. *+ -#define NEWHOWTO( FUNCTION, NAME,SIZE,REL) HOWTO(0,0,SIZE,0,REL,0,false,false,FUNCTION, NAME,false,0,0,false) +#define NEWHOWTO( FUNCTION, NAME,SIZE,REL,IN) HOWTO(0,0,SIZE,0,REL,0,false,false,FUNCTION, NAME,false,0,0,IN) *- Helper routine to turn a symbol into a relocation value. -- 2.34.1