From d0ec7a8ee45ad23107d26161b3499d33b99922a6 Mon Sep 17 00:00:00 2001 From: Steve Chamberlain Date: Wed, 8 May 1991 19:21:48 +0000 Subject: Various portability lints. Fixed reloc bug in ieee and oasys. --- bfd/aout.c | 4 +- bfd/archive.c | 10 +- bfd/coff-mips.c | 6 +- bfd/ieee.c | 903 ++++++++++++++++++++++++++------------------------------ bfd/libbfd.c | 4 +- bfd/oasys.c | 51 ++-- bfd/srec.c | 31 +- bfd/sunos.c | 4 +- 8 files changed, 474 insertions(+), 539 deletions(-) (limited to 'bfd') diff --git a/bfd/aout.c b/bfd/aout.c index b714bf9..35f2d4f 100755 --- a/bfd/aout.c +++ b/bfd/aout.c @@ -1273,7 +1273,9 @@ swap_std_reloc_out (abfd, g, natptr) else { r_extern = 0; if (g->section == NULL) { - BFD_ASSERT(0); + /* It is possible to have a reloc with nothing, we generate an + abs + 0 */ + r_addend = 0; r_index = N_ABS | N_EXT; } else if(g->section->output_section == obj_textsec(abfd)) { diff --git a/bfd/archive.c b/bfd/archive.c index 4df6318..f1d8a6a 100644 --- a/bfd/archive.c +++ b/bfd/archive.c @@ -1144,7 +1144,7 @@ bsd_write_armap (arch, elength, map, orl_count, stridx) /* now write the strings themselves */ /* FIXME, this needs to be byte-swapped! */ temp = stridx + 4; - bfd_write (&temp, 1, sizeof (temp), arch); + bfd_write ((PTR)&temp, 1, sizeof (temp), arch); for (count = 0; count < orl_count; count++) bfd_write (*((map[count]).name), 1, strlen (*((map[count]).name))+1, arch); @@ -1211,9 +1211,9 @@ coff_write_armap (arch, elength, map, orl_count, stridx) /* Write the ar header for this item and the number of symbols */ - bfd_write ((char *)&hdr, 1, sizeof (struct ar_hdr), arch); + bfd_write ((PTR)&hdr, 1, sizeof (struct ar_hdr), arch); /* FIXME, this needs to be byte-swapped */ - bfd_write (&orl_count, 1, sizeof (orl_count), arch); + bfd_write ((PTR)&orl_count, 1, sizeof (orl_count), arch); /* Two passes, first write the file offsets for each symbol - remembering that each offset is on a two byte boundary @@ -1230,7 +1230,7 @@ coff_write_armap (arch, elength, map, orl_count, stridx) last_eltno++; } /* FIXME, this needs to be byte-swapped */ - bfd_write (&archive_member_file_ptr, + bfd_write ((PTR)&archive_member_file_ptr, 1, sizeof (archive_member_file_ptr), arch); @@ -1238,7 +1238,7 @@ coff_write_armap (arch, elength, map, orl_count, stridx) /* now write the strings themselves */ for (count = 0; count < orl_count; count++) { - bfd_write (*((map[count]).name), + bfd_write ((PTR)*((map[count]).name), 1, strlen (*((map[count]).name))+1, arch); diff --git a/bfd/coff-mips.c b/bfd/coff-mips.c index ebdf221..d424932 100644 --- a/bfd/coff-mips.c +++ b/bfd/coff-mips.c @@ -168,7 +168,7 @@ ecoff_object_p (abfd) bfd_error = no_error; /* figure out how much to read */ - if (bfd_read (short_bytes, 1, SHORT_SIZE, abfd) != SHORT_SIZE) + if (bfd_read ((PTR)short_bytes, 1, SHORT_SIZE, abfd) != SHORT_SIZE) return 0; magic = bfd_h_getshort (abfd, short_bytes); @@ -176,13 +176,13 @@ ecoff_object_p (abfd) bfd_error = wrong_format; return 0; } - if (bfd_read (short_bytes, 1, SHORT_SIZE, abfd) != SHORT_SIZE) + if (bfd_read ((PTR)short_bytes, 1, SHORT_SIZE, abfd) != SHORT_SIZE) return 0; nscns = bfd_h_getshort (abfd, short_bytes); if (bfd_seek (abfd,(file_ptr) ((sizeof (long)) * 3), true) < 0) return 0; - if (bfd_read (short_bytes, 1, SHORT_SIZE, abfd) != SHORT_SIZE) + if (bfd_read ((PTR)short_bytes, 1, SHORT_SIZE, abfd) != SHORT_SIZE) return 0; opthdr = bfd_h_getshort (abfd, short_bytes); diff --git a/bfd/ieee.c b/bfd/ieee.c index 84f64ac..6bc3730 100644 --- a/bfd/ieee.c +++ b/bfd/ieee.c @@ -1,4 +1,5 @@ -/* bfd backend for ieee-695 objects. + + /* bfd backend for ieee-695 objects. IEEE 695 format is a stream of records, which we parse using a simple one token (which is one byte in this lexicon) lookahead recursive decent @@ -23,17 +24,13 @@ along with BFD; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "sysdep.h" + #include "bfd.h" #include "libbfd.h" -#include "obstack.h" #include "ieee.h" #include "libieee.h" -#define obstack_chunk_alloc malloc -#define obstack_chunk_free free -#define ieee_malloc(abfd,size) \ - obstack_alloc(&( ieee_data(abfd)->ieee_obstack), (size)) typedef void generic_symbol_type; @@ -49,7 +46,7 @@ DEFUN(ieee_write_byte,(abfd, byte), bfd *abfd AND bfd_byte byte) { - bfd_write(&byte, 1, 1, abfd); + bfd_write((PTR)&byte, 1, 1, abfd); } @@ -62,7 +59,7 @@ DEFUN(ieee_write_2bytes,(abfd, bytes), buffer[0] = bytes >> 8; buffer[1] = bytes & 0xff; - bfd_write(buffer, 1, 2, abfd); + bfd_write((PTR)buffer, 1, 2, abfd); } static void @@ -123,72 +120,75 @@ DEFUN(ieee_write_id,(abfd, id), else { BFD_FAIL(); } - bfd_write((bfd_byte *)id, 1, length, abfd); + bfd_write((PTR)id, 1, length, abfd); } /*************************************************************************** Functions for reading from ieee files in the strange way that the standard requires: */ -#define this_byte(abfd) *(ptr(abfd)) -#define next_byte(abfd) (ptr(abfd)++) -#define this_byte_and_next(abfd) *(ptr(abfd)++) + +#define this_byte(ieee) *(ieee->input_p) +#define next_byte(ieee) (ieee->input_p++) +#define this_byte_and_next(ieee) (*(ieee->input_p++)) static unsigned short -DEFUN(read_2bytes,(abfd), - bfd *abfd) +DEFUN(read_2bytes,(ieee), + ieee_data_type *ieee) { - unsigned char c1 = this_byte_and_next(abfd); - unsigned char c2 = this_byte_and_next(abfd); + unsigned char c1 = this_byte_and_next(ieee); + unsigned char c2 = this_byte_and_next(ieee); return (c1<<8 ) | c2; } static void -DEFUN(bfd_get_string,(abfd, string, length), - bfd *abfd AND +DEFUN(bfd_get_string,(ieee, string, length), + ieee_data_type *ieee AND char *string AND size_t length) { size_t i; for (i= 0; i < length; i++) { - string[i] = this_byte_and_next(abfd); + string[i] = this_byte_and_next(ieee); } } static char * -DEFUN(read_id,(abfd), - bfd *abfd) +DEFUN(read_id,(ieee), + ieee_data_type *ieee) { size_t length; char *string; - length = this_byte_and_next(abfd); + length = this_byte_and_next(ieee); if (length >= 0x00 && length <= 0x7f) { /* Simple string of length 0 to 127 */ } else if (length == 0xde) { /* Length is next byte, allowing 0..255 */ - length = this_byte_and_next(abfd); + length = this_byte_and_next(ieee); } else if (length == 0xdf) { /* Length is next two bytes, allowing 0..65535 */ - length = this_byte_and_next(abfd) ; - length = (length * 256) + this_byte_and_next(abfd); + length = this_byte_and_next(ieee) ; + length = (length * 256) + this_byte_and_next(ieee); } /* Buy memory and read string */ - string = ieee_malloc(abfd, length+1); - bfd_get_string(abfd, string, length); + string = bfd_alloc(ieee->abfd, length+1); + bfd_get_string(ieee, string, length); string[length] = 0; return string; } static void -DEFUN(ieee_write_expression,(abfd, value, section, symbol), +DEFUN(ieee_write_expression,(abfd, value, section, symbol, pcrel, index), bfd*abfd AND bfd_vma value AND asection *section AND - asymbol *symbol) + asymbol *symbol AND + boolean pcrel AND + unsigned int index) { unsigned int plus_count = 0; ieee_write_int(abfd, value); @@ -198,6 +198,8 @@ DEFUN(ieee_write_expression,(abfd, value, section, symbol), ieee_write_byte(abfd, section->index +IEEE_SECTION_NUMBER_BASE); } + + if (symbol != (asymbol *)NULL) { plus_count++; if ((symbol->flags & BSF_UNDEFINED ) || @@ -228,7 +230,14 @@ DEFUN(ieee_write_expression,(abfd, value, section, symbol), } } - while (plus_count != 0) { + if(pcrel) { + /* subtract the pc from here by asking for PC of this section*/ + ieee_write_byte(abfd, ieee_variable_P_enum); + ieee_write_byte(abfd, index +IEEE_SECTION_NUMBER_BASE); + ieee_write_byte(abfd, ieee_function_minus_enum); + } + + while (plus_count > 0) { ieee_write_byte(abfd, ieee_function_plus_enum); plus_count--; } @@ -264,30 +273,30 @@ DEFUN(ieee_write_int5_out, (abfd, value), bfd *abfd AND bfd_vma value) { - char b[5]; + bfd_byte b[5]; ieee_write_int5(b, value); - bfd_write(b,1,5,abfd); + bfd_write((PTR)b,1,5,abfd); } static boolean -DEFUN(parse_int,(abfd, value_ptr), - bfd *abfd AND +DEFUN(parse_int,(ieee, value_ptr), + ieee_data_type *ieee AND bfd_vma *value_ptr) { - int value = this_byte(abfd); + int value = this_byte(ieee); int result; if (value >= 0 && value <= 127) { *value_ptr = value; - next_byte(abfd); + next_byte(ieee); return true; } else if (value >= 0x80 && value <= 0x88) { unsigned int count = value & 0xf; result = 0; - next_byte(abfd); + next_byte(ieee); while (count) { - result =(result << 8) | this_byte_and_next(abfd); + result =(result << 8) | this_byte_and_next(ieee); count--; } *value_ptr = result; @@ -296,21 +305,21 @@ DEFUN(parse_int,(abfd, value_ptr), return false; } static int -DEFUN(parse_i,(abfd, ok), - bfd *abfd AND +DEFUN(parse_i,(ieee, ok), + ieee_data_type *ieee AND boolean *ok) { bfd_vma x; - *ok = parse_int(abfd, &x); + *ok = parse_int(ieee, &x); return x; } static bfd_vma -DEFUN(must_parse_int,(abfd), - bfd *abfd) +DEFUN(must_parse_int,(ieee), + ieee_data_type *ieee) { bfd_vma result; - BFD_ASSERT(parse_int(abfd, &result) == true); + BFD_ASSERT(parse_int(ieee, &result) == true); return result; } @@ -324,22 +333,30 @@ typedef struct static reloc_howto_type abs32_howto - = HOWTO(1,0,2,32,0,0,0,true,0,"abs32",false,0xffffffff, 0xffffffff,false); + = HOWTO(1,0,2,32,0,0,0,true,0,"abs32",true,0xffffffff, 0xffffffff,false); static reloc_howto_type abs16_howto - = HOWTO(1,0,1,16,0,0,0,true,0,"abs16",false,0x0000ffff, 0x0000ffff,false); + = HOWTO(1,0,1,16,0,0,0,true,0,"abs16",true,0x0000ffff, 0x0000ffff,false); + +static +reloc_howto_type rel32_howto + = HOWTO(1,0,2,32,1,0,0,true,0,"rel32",true,0xffffffff, 0xffffffff,false); +static +reloc_howto_type rel16_howto + = HOWTO(1,0,1,16,1,0,0,true,0,"rel16",true,0x0000ffff, 0x0000ffff,false); static ieee_symbol_index_type NOSYMBOL = { 0, 0}; static void -DEFUN(parse_expression,(abfd, value, section, symbol, pcrel, extra), - bfd *abfd AND +DEFUN(parse_expression,(ieee, value, section, symbol, pcrel, extra), + ieee_data_type *ieee AND bfd_vma *value AND asection **section AND ieee_symbol_index_type *symbol AND boolean *pcrel AND unsigned int *extra) + { #define POS sp[1] #define TOS sp[0] @@ -356,110 +373,108 @@ DEFUN(parse_expression,(abfd, value, section, symbol, pcrel, extra), ieee_value_type *sp = stack; while (loop) { - switch (this_byte(abfd)) - { - case ieee_variable_P_enum: - /* P variable, current program counter for section n */ + switch (this_byte(ieee)) { - int section_n ; - next_byte(abfd); - section_n = must_parse_int(abfd); - PUSH(NOSYMBOL, 0, - TOS.value = ieee_data(abfd)->section_table[section_n]->vma + - ieee_per_section(ieee_data(abfd)->section_table[section_n])->pc); + case ieee_variable_P_enum: + /* P variable, current program counter for section n */ + { + int section_n ; + next_byte(ieee); + *pcrel = true; + section_n = must_parse_int(ieee); + PUSH(NOSYMBOL, 0, + TOS.value = ieee->section_table[section_n]->vma + + ieee_per_section(ieee->section_table[section_n])->pc); + break; + } + case ieee_variable_L_enum: + /* L variable address of section N */ + next_byte(ieee); + PUSH(NOSYMBOL,ieee->section_table[must_parse_int(ieee)],0); + break; + case ieee_variable_R_enum: + /* R variable, logical address of section module */ + /* FIXME, this should be different to L */ + next_byte(ieee); + PUSH(NOSYMBOL,ieee->section_table[must_parse_int(ieee)],0); + break; + case ieee_variable_S_enum: + /* S variable, size in MAUS of section module */ + next_byte(ieee); + PUSH(NOSYMBOL, + 0, + ieee->section_table[must_parse_int(ieee)]->size); break; - } - case ieee_variable_L_enum: - /* L variable address of section N */ - next_byte(abfd); - PUSH(NOSYMBOL,ieee_data(abfd)->section_table[must_parse_int(abfd)],0); - break; - case ieee_variable_R_enum: - /* R variable, logical address of section module */ - /* FIXME, this should be different to L */ - next_byte(abfd); - PUSH(NOSYMBOL,ieee_data(abfd)->section_table[must_parse_int(abfd)],0); - break; - case ieee_variable_S_enum: - /* S variable, size in MAUS of section module */ - next_byte(abfd); - PUSH(NOSYMBOL, - 0, - ieee_data(abfd)->section_table[must_parse_int(abfd)]->size); - break; - case ieee_variable_X_enum: - /* Push the address of external variable n */ - { - ieee_symbol_index_type sy; - next_byte(abfd); - sy.index = (int)(must_parse_int(abfd)) ; - sy.letter = 'X'; + case ieee_variable_X_enum: + /* Push the address of external variable n */ + { + ieee_symbol_index_type sy; + next_byte(ieee); + sy.index = (int)(must_parse_int(ieee)) ; + sy.letter = 'X'; - PUSH(sy, 0, 0); - } - break; - case ieee_function_minus_enum: - { - bfd_vma value1, value2; - asection *section; - ieee_symbol_index_type sy; - next_byte(abfd); - - POP(sy, section, value1); - POP(sy, section, value2); - PUSH(NOSYMBOL, 0, value1-value2); - } - break; - case ieee_function_plus_enum: - { - bfd_vma value1, value2; - asection *section1; - asection *section2; - ieee_symbol_index_type sy1; - ieee_symbol_index_type sy2; - next_byte(abfd); - - POP(sy1, section1, value1); - POP(sy2, section2, value2); - PUSH(sy1.letter ? sy1 : sy2, section1 ? section1: section2, value1+value2); - } - break; - default: - { - bfd_vma va; - BFD_ASSERT(this_byte(abfd) < ieee_variable_A_enum - || this_byte(abfd) > ieee_variable_Z_enum); - if (parse_int(abfd, &va)) + PUSH(sy, 0, 0); + } + break; + case ieee_function_minus_enum: { - PUSH(NOSYMBOL,0, va); + bfd_vma value1, value2; + asection *section1, *section_dummy; + ieee_symbol_index_type sy; + next_byte(ieee); + + POP(sy, section1, value1); + POP(sy, section_dummy, value2); + PUSH(sy, section1, value1-value2); } - else { - /* - Thats all that we can understand. As far as I can see - there is a bug in the Microtec IEEE output which I'm - using to scan, whereby the comma operator is ommited - sometimes in an expression, giving expressions with too - many terms. We can tell if that's the case by ensuring - that sp == stack here. If not, then we've pushed - something too far. - - */ - - POP(*symbol, *section, *value); - if (sp != stack) { - BFD_ASSERT(*section == 0); - *extra = *value; - /* Get what should be returned */ - POP(*symbol, *section, *value); + break; + case ieee_function_plus_enum: + { + bfd_vma value1, value2; + asection *section1; + asection *section2; + ieee_symbol_index_type sy1; + ieee_symbol_index_type sy2; + next_byte(ieee); + + POP(sy1, section1, value1); + POP(sy2, section2, value2); + PUSH(sy1.letter ? sy1 : sy2, section1 ? section1: section2, value1+value2); } - else { - *extra = 0; + break; + default: + { + bfd_vma va; + BFD_ASSERT(this_byte(ieee) < ieee_variable_A_enum + || this_byte(ieee) > ieee_variable_Z_enum); + if (parse_int(ieee, &va)) + { + PUSH(NOSYMBOL,0, va); + } + else { + /* + Thats all that we can understand. As far as I can see + there is a bug in the Microtec IEEE output which I'm + using to scan, whereby the comma operator is ommited + sometimes in an expression, giving expressions with too + many terms. We can tell if that's the case by ensuring + that sp == stack here. If not, then we've pushed + something too far, so we keep adding + */ + + while (sp != stack+1) { + asection *section1; + ieee_symbol_index_type sy1; + POP(sy1, section1, *extra); + } + + POP(*symbol, *section, *value); + loop = false; + } } - loop = false; - } - } - } + } } } @@ -486,22 +501,22 @@ DEFUN(ieee_slurp_external_symbols,(abfd), ieee_seek(abfd, offset ); while (loop) { - switch (this_byte(abfd)) { + switch (this_byte(ieee)) { case ieee_external_symbol_enum: - next_byte(abfd); - symbol = (ieee_symbol_type *)ieee_malloc(abfd, sizeof(ieee_symbol_type)); + next_byte(ieee); + symbol = (ieee_symbol_type *)bfd_alloc(ieee->abfd, sizeof(ieee_symbol_type)); *prev_symbols_ptr = symbol; prev_symbols_ptr= &symbol->next; - symbol->index = must_parse_int(abfd); + symbol->index = must_parse_int(ieee); if (symbol->index > ieee->external_symbol_max_index) { ieee->external_symbol_max_index = symbol->index; } BFD_ASSERT (symbol->index >= ieee->external_symbol_min_index); symbol_count++; symbol->symbol.the_bfd = abfd; - symbol->symbol.name = read_id(abfd); - symbol->symbol.udata = (void *)NULL; + symbol->symbol.name = read_id(ieee); + symbol->symbol.udata = (PTR)NULL; symbol->symbol.flags = BSF_NO_FLAGS; break; case ieee_attribute_record_enum >> 8: @@ -510,13 +525,13 @@ DEFUN(ieee_slurp_external_symbols,(abfd), unsigned int symbol_type_index; unsigned int symbol_attribute_def; bfd_vma value; - next_byte(abfd); /* Skip prefix */ - next_byte(abfd); - symbol_name_index = must_parse_int(abfd); - symbol_type_index = must_parse_int(abfd); - symbol_attribute_def = must_parse_int(abfd); + next_byte(ieee); /* Skip prefix */ + next_byte(ieee); + symbol_name_index = must_parse_int(ieee); + symbol_type_index = must_parse_int(ieee); + symbol_attribute_def = must_parse_int(ieee); - parse_int(abfd,&value); + parse_int(ieee,&value); } break; @@ -525,17 +540,17 @@ DEFUN(ieee_slurp_external_symbols,(abfd), unsigned int symbol_name_index; ieee_symbol_index_type symbol_ignore; boolean pcrel_ignore; - unsigned int extra_ignore; - next_byte(abfd); - next_byte(abfd); + unsigned int extra; + next_byte(ieee); + next_byte(ieee); - symbol_name_index = must_parse_int(abfd); - parse_expression(abfd, + symbol_name_index = must_parse_int(ieee); + parse_expression(ieee, &symbol->symbol.value, &symbol->symbol.section, &symbol_ignore, - &pcrel_ignore, - &extra_ignore); + &pcrel_ignore, + &extra); if (symbol->symbol.section != (asection *)NULL) { symbol->symbol.flags = BSF_GLOBAL | BSF_EXPORT; } @@ -547,13 +562,13 @@ DEFUN(ieee_slurp_external_symbols,(abfd), case ieee_weak_external_reference_enum: { bfd_vma size; bfd_vma value ; - next_byte(abfd); + next_byte(ieee); /* Throw away the external reference index */ - (void)must_parse_int(abfd); + (void)must_parse_int(ieee); /* Fetch the default size if not resolved */ - size = must_parse_int(abfd); + size = must_parse_int(ieee); /* Fetch the defautlt value if available */ - if ( parse_int(abfd, &value) == false) { + if ( parse_int(ieee, &value) == false) { value = 0; } /* This turns into a common */ @@ -563,15 +578,15 @@ DEFUN(ieee_slurp_external_symbols,(abfd), break; case ieee_external_reference_enum: - next_byte(abfd); - symbol = (ieee_symbol_type *)ieee_malloc(abfd, sizeof(ieee_symbol_type)); + next_byte(ieee); + symbol = (ieee_symbol_type *)bfd_alloc(ieee->abfd, sizeof(ieee_symbol_type)); symbol_count++; *prev_reference_ptr = symbol; prev_reference_ptr = &symbol->next; - symbol->index = must_parse_int(abfd); + symbol->index = must_parse_int(ieee); symbol->symbol.the_bfd = abfd; - symbol->symbol.name = read_id(abfd); - symbol->symbol.udata = (void *)NULL; + symbol->symbol.name = read_id(ieee); + symbol->symbol.udata = (PTR)NULL; symbol->symbol.section = (asection *)NULL; symbol->symbol.value = (bfd_vma)0; symbol->symbol.flags = BSF_UNDEFINED; @@ -626,7 +641,7 @@ DEFUN(ieee_slurp_symbol_table,(abfd), } } -size_t +unsigned int DEFUN(ieee_get_symtab_upper_bound,(abfd), bfd *abfd) { @@ -642,7 +657,6 @@ symbol index order */ extern bfd_target ieee_vec; - unsigned int DEFUN(ieee_get_symtab,(abfd, location), bfd *abfd AND @@ -651,7 +665,8 @@ DEFUN(ieee_get_symtab,(abfd, location), ieee_symbol_type *symp; static bfd dummy_bfd; static asymbol empty_symbol = - { &dummy_bfd," ieee empty",(symvalue)0,BSF_DEBUGGING | BSF_FAKE}; + { &dummy_bfd," ieee empty",(symvalue)0,BSF_DEBUGGING | BSF_ABSOLUTE}; + ieee_data_type *ieee = ieee_data(abfd); dummy_bfd.xvec= &ieee_vec; @@ -709,12 +724,12 @@ DEFUN(ieee_slurp_sections,(abfd), bfd_byte section_type[3]; ieee_seek(abfd, offset); while (true) { - switch (this_byte(abfd)) { + switch (this_byte(ieee)) { case ieee_section_type_enum: { unsigned int section_index ; - next_byte(abfd); - section_index = must_parse_int(abfd); + next_byte(ieee); + section_index = must_parse_int(ieee); /* Fixme to be nice about a silly number of sections */ BFD_ASSERT(section_index < NSECTIONS); @@ -722,24 +737,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(abfd); + section_type[0] = this_byte_and_next(ieee); switch (section_type[0]) { case 0xC3: - section_type[1] = this_byte(abfd); + section_type[1] = this_byte(ieee); section->flags = SEC_LOAD; switch (section_type[1]) { case 0xD0: /* Normal code */ - next_byte(abfd); + next_byte(ieee); section->flags |= SEC_LOAD | SEC_CODE; break; case 0xC4: - next_byte(abfd); + next_byte(ieee); section->flags |= SEC_LOAD | SEC_DATA; /* Normal data */ break; case 0xD2: - next_byte(abfd); + next_byte(ieee); /* Normal rom data */ section->flags |= SEC_LOAD | SEC_ROM | SEC_DATA; break; @@ -747,11 +762,11 @@ DEFUN(ieee_slurp_sections,(abfd), break; } } - section->name = read_id(abfd); + section->name = read_id(ieee); { bfd_vma parent, brother, context; - parse_int(abfd, &parent); - parse_int(abfd, &brother); - parse_int(abfd, &context); + parse_int(ieee, &parent); + parse_int(ieee, &brother); + parse_int(ieee, &context); } @@ -761,47 +776,47 @@ DEFUN(ieee_slurp_sections,(abfd), { unsigned int section_index; bfd_vma value; - next_byte(abfd); - section_index = must_parse_int(abfd); + next_byte(ieee); + section_index = must_parse_int(ieee); if (section_index > ieee->section_count) { ieee->section_count = section_index; } ieee->section_table[section_index]->alignment_power = - bfd_log2(must_parse_int(abfd)); - (void)parse_int(abfd, & value); + bfd_log2(must_parse_int(ieee)); + (void)parse_int(ieee, & value); } break; case ieee_e2_first_byte_enum: { - ieee_record_enum_type t = read_2bytes(abfd); + ieee_record_enum_type t = read_2bytes(ieee); switch (t) { case ieee_section_size_enum: - section = ieee->section_table[must_parse_int(abfd)]; - section->size = must_parse_int(abfd); + section = ieee->section_table[must_parse_int(ieee)]; + section->size = must_parse_int(ieee); break; case ieee_physical_region_size_enum: - section = ieee->section_table[must_parse_int(abfd)]; - section->size = must_parse_int(abfd); + section = ieee->section_table[must_parse_int(ieee)]; + section->size = must_parse_int(ieee); break; case ieee_region_base_address_enum: - section = ieee->section_table[must_parse_int(abfd)]; - section->vma = must_parse_int(abfd); + section = ieee->section_table[must_parse_int(ieee)]; + section->vma = must_parse_int(ieee); break; case ieee_mau_size_enum: - must_parse_int(abfd); - must_parse_int(abfd); + must_parse_int(ieee); + must_parse_int(ieee); break; case ieee_m_value_enum: - must_parse_int(abfd); - must_parse_int(abfd); + must_parse_int(ieee); + must_parse_int(ieee); break; case ieee_section_base_address_enum: - section = ieee->section_table[must_parse_int(abfd)]; - section->vma = must_parse_int(abfd); + section = ieee->section_table[must_parse_int(ieee)]; + section->vma = must_parse_int(ieee); break; case ieee_section_offset_enum: - (void) must_parse_int(abfd); - (void) must_parse_int(abfd); + (void) must_parse_int(ieee); + (void) must_parse_int(ieee); break; default: return; @@ -822,21 +837,25 @@ 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; - return 0; /* FIXME */ + + +/* FIXME */ ieee_seek(abfd, (file_ptr) 0); if (this_byte(abfd) != Module_Beginning) return (bfd_target*)NULL; - next_byte(abfd); - library= read_id(abfd); + next_byte(ieee); + library= read_id(ieee); if (strcmp(library , "LIBRARY") != 0) { free(library); return (bfd_target *)NULL; } /* Throw away the filename */ - free( read_id(abfd)); + free( read_id(ieee)); /* This must be an IEEE archive, so we'll buy some space to do things */ ar = (ieee_ar_data_type *) malloc(sizeof(ieee_ar_data_type)); @@ -845,9 +864,9 @@ DEFUN(ieee_archive_p,(abfd), ar->element_index = 0; obstack_init(&ar->element_obstack); - next_byte(abfd); /* Drop the ad part */ - must_parse_int(abfd); /* And the two dummy numbers */ - must_parse_int(abfd); + next_byte(ieee); /* Drop the ad part */ + must_parse_int(ieee); /* And the two dummy numbers */ + must_parse_int(ieee); loop = true; /* Read the index of the BB table */ @@ -855,8 +874,8 @@ DEFUN(ieee_archive_p,(abfd), ieee_ar_obstack_type t; int rec =read_2bytes(abfd); if (rec ==ieee_assign_value_to_variable_enum) { - int record_number = must_parse_int(abfd); - t.file_offset = must_parse_int(abfd); + int record_number = must_parse_int(ieee); + t.file_offset = must_parse_int(ieee); t.abfd = (bfd *)NULL; ar->element_count++; obstack_grow(&ar->element_obstack, (PTR)&t, sizeof(t)); @@ -871,34 +890,28 @@ DEFUN(ieee_archive_p,(abfd), for (i = 2; i < ar->element_count; i++) { ieee_seek(abfd, ar->elements[i].file_offset); - next_byte(abfd); /* Drop F8 */ - next_byte(abfd); /* Drop 14 */ - must_parse_int(abfd); /* Drop size of block */ - if (must_parse_int(abfd) != 0) { + next_byte(ieee); /* Drop F8 */ + next_byte(ieee); /* Drop 14 */ + must_parse_int(ieee); /* Drop size of block */ + if (must_parse_int(ieee) != 0) { /* This object has been deleted */ ar->elements[i].file_offset = 0; } else { - ar->elements[i].file_offset = must_parse_int(abfd); + ar->elements[i].file_offset = must_parse_int(ieee); } } obstack_finish(&ar->element_obstack); return abfd->xvec; +#endif } static boolean DEFUN(ieee_mkobject,(abfd), bfd *abfd) { - struct obstack tmp_obstack; - ieee_data_type *ieee; - - obstack_init(&tmp_obstack); - BFD_ASSERT(ieee_data(abfd) == 0); - set_tdata (abfd, obstack_alloc(&tmp_obstack,sizeof(ieee_data_type))); - ieee = ieee_data(abfd); - ieee->ieee_obstack = tmp_obstack; + ieee_data(abfd) = (ieee_data_type *)bfd_alloc(abfd,sizeof(ieee_data_type)); return true; } @@ -909,17 +922,17 @@ DEFUN(ieee_object_p,(abfd), char *processor; unsigned int part; ieee_data_type *ieee; - char buffer[300]; - + uint8e_type buffer[300]; + ieee_data_type *save = ieee_data(abfd); set_tdata (abfd, 0); ieee_mkobject(abfd); ieee = ieee_data(abfd); /* Read the first few bytes in to see if it makes sense */ - bfd_read(buffer, 1, sizeof(buffer), abfd); + bfd_read((PTR)buffer, 1, sizeof(buffer), abfd); - ptr(abfd)= buffer; - if (*(ptr(abfd)++) != Module_Beginning) goto fail; + ieee->input_p = buffer; + if (this_byte_and_next(ieee) != Module_Beginning) goto fail; ieee->read_symbols= false; ieee->read_data= false; @@ -928,45 +941,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; memset((PTR)ieee->section_table, 0, sizeof(ieee->section_table)); - processor = ieee->mb.processor = read_id(abfd); + processor = ieee->mb.processor = read_id(ieee); if (strcmp(processor,"LIBRARY") == 0) goto fail; - ieee->mb.module_name = read_id(abfd); + ieee->mb.module_name = read_id(ieee); if (abfd->filename == (char *)NULL) { abfd->filename = ieee->mb.module_name; } /* Determine the architecture and machine type of the object file. */ bfd_scan_arch_mach(processor, &abfd->obj_arch, &abfd->obj_machine); - if (this_byte(abfd) != ieee_address_descriptor_enum) { + if (this_byte(ieee) != ieee_address_descriptor_enum) { goto fail; } - next_byte(abfd); + next_byte(ieee); - if (parse_int(abfd, &ieee->ad.number_of_bits_mau) == false) { + if (parse_int(ieee, &ieee->ad.number_of_bits_mau) == false) { goto fail; } - if(parse_int(abfd, &ieee->ad.number_of_maus_in_address) == false) { + if(parse_int(ieee, &ieee->ad.number_of_maus_in_address) == false) { goto fail; } /* If there is a byte order info, take it */ - if (this_byte(abfd) == ieee_variable_L_enum || - this_byte(abfd) == ieee_variable_M_enum) - next_byte(abfd); + if (this_byte(ieee) == ieee_variable_L_enum || + this_byte(ieee) == ieee_variable_M_enum) + next_byte(ieee); for (part = 0; part < N_W_VARIABLES; part++) { boolean ok; - if (read_2bytes(abfd) != ieee_assign_value_to_variable_enum) { + if (read_2bytes(ieee) != ieee_assign_value_to_variable_enum) { goto fail; } - if (this_byte_and_next(abfd) != part) { + if (this_byte_and_next(ieee) != part) { goto fail; } - ieee->w.offset[part] = parse_i(abfd, &ok); + ieee->w.offset[part] = parse_i(ieee, &ok); if (ok==false) { goto fail; } @@ -979,15 +993,16 @@ DEFUN(ieee_object_p,(abfd), quickly. We can work out how big the file is from the trailer record */ - ieee_data(abfd)->first_byte = ieee_malloc(abfd, ieee->w.r.me_record + ieee_data(abfd)->first_byte = (uint8e_type *) bfd_alloc(ieee->abfd, ieee->w.r.me_record + 50); bfd_seek(abfd, 0, 0); - bfd_read(ieee_data(abfd)->first_byte, 1, ieee->w.r.me_record+50, abfd); + bfd_read((PTR)(ieee_data(abfd)->first_byte), 1, ieee->w.r.me_record+50, abfd); ieee_slurp_sections(abfd); return abfd->xvec; fail: - obstack_finish(&ieee->ieee_obstack); + (void) bfd_release(abfd, ieee); + ieee_data(abfd) = save; return (bfd_target *)NULL; } @@ -1014,16 +1029,20 @@ DEFUN(ieee_print_symbol,(ignore_abfd, file, symbol, how), { CONST char *section_name = symbol->section == (asection *)NULL ? "*abs" : symbol->section->name; + if (symbol->name[0] == ' ') { + fprintf(file,"* empty table entry "); + } + else { + bfd_print_symbol_vandf((PTR)file,symbol); - bfd_print_symbol_vandf((void *)file,symbol); - - fprintf(file," %-5s %04x %02x %s", - section_name, - (unsigned) ieee_symbol(symbol)->index, - (unsigned) 0, /* + fprintf(file," %-5s %04x %02x %s", + section_name, + (unsigned) ieee_symbol(symbol)->index, + (unsigned) 0, /* aout_symbol(symbol)->desc & 0xffff, aout_symbol(symbol)->other & 0xff,*/ - symbol->name); + symbol->name); + } } break; } @@ -1052,7 +1071,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 *) ieee_malloc(abfd, s->size); + per->data = (bfd_byte *) bfd_alloc(ieee->abfd, s->size); /*SUPPRESS 68*/ per->reloc_tail_ptr = (ieee_reloc_type **)&(s->relocation); @@ -1061,15 +1080,15 @@ DEFUN(ieee_slurp_section_data,(abfd), while (true) { - switch (this_byte(abfd)) + switch (this_byte(ieee)) { /* IF we see anything strange then quit */ default: return true; case ieee_set_current_section_enum: - next_byte(abfd); - section_number = must_parse_int(abfd); + next_byte(ieee); + section_number = must_parse_int(ieee); s = ieee->section_table[section_number]; current_map = (ieee_per_section_type *) s->used_by_bfd; location_ptr = current_map->data - s->vma; @@ -1083,19 +1102,19 @@ DEFUN(ieee_slurp_section_data,(abfd), { unsigned int number_of_maus; unsigned int i; - next_byte(abfd); - number_of_maus = must_parse_int(abfd); + next_byte(ieee); + number_of_maus = must_parse_int(ieee); for (i = 0; i < number_of_maus; i++) { - location_ptr[current_map->pc++]= this_byte(abfd); - next_byte(abfd); + location_ptr[current_map->pc++]= this_byte(ieee); + next_byte(ieee); } } break; case ieee_e2_first_byte_enum: - next_byte(abfd); - switch (this_byte(abfd)) + next_byte(ieee); + switch (this_byte(ieee)) { case ieee_set_current_pc_enum & 0xff: { @@ -1104,9 +1123,10 @@ DEFUN(ieee_slurp_section_data,(abfd), ieee_symbol_index_type symbol; unsigned int extra; boolean pcrel; - next_byte(abfd); - must_parse_int(abfd); /* Thow away section #*/ - parse_expression(abfd, &value, &dsection, &symbol, &pcrel, &extra); + next_byte(ieee); + must_parse_int(ieee); /* Thow away section #*/ + parse_expression(ieee, &value, &dsection, &symbol, + &pcrel, &extra); current_map->pc = value; BFD_ASSERT((unsigned)(value - s->vma) <= s->size); } @@ -1115,7 +1135,6 @@ DEFUN(ieee_slurp_section_data,(abfd), case ieee_value_starting_address_enum & 0xff: /* We've got to the end of the data now - */ return true; - break; default: BFD_FAIL(); return true; @@ -1124,10 +1143,10 @@ DEFUN(ieee_slurp_section_data,(abfd), case ieee_load_with_relocation_enum: { boolean loop = true; - next_byte(abfd); + next_byte(ieee); while (loop) { - switch (this_byte(abfd)) + switch (this_byte(ieee)) { case ieee_variable_R_enum: @@ -1135,75 +1154,93 @@ DEFUN(ieee_slurp_section_data,(abfd), case ieee_function_unsigned_open_b_enum: case ieee_function_either_open_b_enum: { - unsigned int extra; - boolean pcrel; + unsigned int extra = 4; + boolean pcrel = false; - ieee_reloc_type *r = - (ieee_reloc_type *) ieee_malloc(abfd, - sizeof(ieee_reloc_type)); + ieee_reloc_type *r = + (ieee_reloc_type *) bfd_alloc(ieee->abfd, + sizeof(ieee_reloc_type)); *(current_map->reloc_tail_ptr) = r; current_map->reloc_tail_ptr= &r->next; r->next = (ieee_reloc_type *)NULL; - next_byte(abfd); - parse_expression(abfd, - &r->relent.addend, - &r->relent.section, - &r->symbol, - &pcrel, - &extra); + next_byte(ieee); + parse_expression(ieee, + &r->relent.addend, + &r->relent.section, + &r->symbol, + &pcrel, &extra); r->relent.address = current_map->pc; s->reloc_count++; - switch (this_byte(abfd)) { + switch (this_byte(ieee)) { case ieee_function_signed_close_b_enum: - next_byte(abfd); + next_byte(ieee); break; case ieee_function_unsigned_close_b_enum: - next_byte(abfd); + next_byte(ieee); break; case ieee_function_either_close_b_enum: - next_byte(abfd); + next_byte(ieee); break; default: break; } /* Build a relocation entry for this type */ - if (this_byte(abfd) == ieee_comma) { - - next_byte(abfd); + if (this_byte(ieee) == ieee_comma) { + next_byte(ieee); /* Fetch number of bytes to pad */ - extra = must_parse_int(abfd); - BFD_FAIL(); - } - switch (extra) { - case 0: - case 4: - location_ptr[current_map->pc++] = 0; - location_ptr[current_map->pc++] = 0; - location_ptr[current_map->pc++] = 0; - location_ptr[current_map->pc++] = 0; - r->relent.howto = &abs32_howto; - break; - case 2: - location_ptr[current_map->pc++] = 0; - location_ptr[current_map->pc++] = 0; - r->relent.howto = &abs16_howto; - break; - - default: - BFD_FAIL(); - break; - } + extra = must_parse_int(ieee); + }; + + /* If pc rel then stick -ve pc into instruction + and take out of reloc*/ + + switch (extra) + { + case 0: + case 4: + if (pcrel == true) + { + bfd_putlong(abfd, -current_map->pc, location_ptr + + current_map->pc); + r->relent.howto = &rel32_howto; + r->relent.addend -= current_map->pc; + } + else + { + bfd_putlong(abfd, 0, location_ptr + + current_map->pc); + r->relent.howto = &abs32_howto; + } + current_map->pc +=4; + break; + case 2: + if (pcrel == true) { + bfd_putshort(abfd, (int)(-current_map->pc), location_ptr +current_map->pc); + r->relent.addend -= current_map->pc; + r->relent.howto = &rel16_howto; + } + else { + bfd_putshort(abfd, 0, location_ptr +current_map->pc); + r->relent.howto = &abs16_howto; + } + current_map->pc +=2; + break; + + default: + BFD_FAIL(); + break; + } } break; default: { bfd_vma this_size ; - if (parse_int(abfd, &this_size) == true) { + if (parse_int(ieee, &this_size) == true) { unsigned int i; for (i = 0; i < this_size; i++) { - location_ptr[current_map->pc ++] = this_byte(abfd); - next_byte(abfd); + location_ptr[current_map->pc ++] = this_byte(ieee); + next_byte(ieee); } } else { @@ -1225,7 +1262,7 @@ DEFUN(ieee_new_section_hook,(abfd, newsect), asection *newsect) { newsect->used_by_bfd = (PTR) - ieee_malloc(abfd, sizeof(ieee_per_section_type)); + bfd_alloc(abfd, sizeof(ieee_per_section_type)); ieee_per_section( newsect)->data = (bfd_byte *)NULL; ieee_per_section(newsect)->section = newsect; return true; @@ -1245,9 +1282,9 @@ static boolean DEFUN(ieee_get_section_contents,(abfd, section, location, offset, count), bfd *abfd AND sec_ptr section AND - void *location AND + PTR location AND file_ptr offset AND - unsigned int count) + int count) { ieee_per_section_type *p = (ieee_per_section_type *) section->used_by_bfd; ieee_slurp_section_data(abfd); @@ -1263,7 +1300,7 @@ DEFUN(ieee_canonicalize_reloc,(abfd, section, relptr, symbols), arelent **relptr AND asymbol **symbols) { - ieee_per_section_type *p = (ieee_per_section_type *) section->used_by_bfd; +/* ieee_per_section_type *p = (ieee_per_section_type *) section->used_by_bfd;*/ ieee_reloc_type *src = (ieee_reloc_type *)(section->relocation); ieee_data_type *ieee = ieee_data(abfd); @@ -1387,12 +1424,11 @@ DEFUN(ieee_write_data_part,(abfd), unsigned int relocs_to_go = s->reloc_count; size_t current_byte_index = 0; - /* Sort the reloc records so we can insert them in the correct places */ if (s->reloc_count != 0) { qsort(s->orelocation, - s->reloc_count, + relocs_to_go, sizeof(arelent **), comp); } @@ -1407,21 +1443,21 @@ DEFUN(ieee_write_data_part,(abfd), header[4] = s->index + IEEE_SECTION_NUMBER_BASE; ieee_write_int5(header+5, s->vma ); header[10] = ieee_load_with_relocation_enum; - bfd_write(header, 1, sizeof(header), abfd); + bfd_write((PTR)header, 1, sizeof(header), abfd); /* Output the data stream as the longest sequence of bytes possible, allowing for the a reasonable packet size and relocation stuffs */ - if (stream == (void *)NULL) { + if ((PTR)stream == (PTR)NULL) { /* Outputting a section without data, fill it up */ - stream = ieee_malloc(abfd, s->size); - memset(stream, 0, s->size); + stream = (uint8e_type *)(bfd_alloc(abfd, s->size)); + memset((PTR)stream, 0, s->size); } while (current_byte_index < s->size) { size_t run; unsigned int MAXRUN = 32; - if (p && *p) { + if (relocs_to_go) { run = (*p)->address - current_byte_index; } else { @@ -1434,7 +1470,7 @@ DEFUN(ieee_write_data_part,(abfd), if (run != 0) { /* Output a stream of bytes */ ieee_write_int(abfd, run); - bfd_write(stream + current_byte_index, + bfd_write((PTR)(stream + current_byte_index), 1, run, abfd); @@ -1445,24 +1481,51 @@ DEFUN(ieee_write_data_part,(abfd), while (relocs_to_go && (*p) && (*p)->address == current_byte_index) { arelent *r = *p; + bfd_vma ov; + if (r->howto->pc_relative) { + r->addend += current_byte_index; + } + + switch (r->howto->size) { + case 2: + + ov = bfd_getlong(abfd, + stream+current_byte_index); + current_byte_index +=4; + break; + case 1: + ov = bfd_getshort(abfd, + stream+current_byte_index); + current_byte_index +=2; + break; + default: + BFD_FAIL(); + } ieee_write_byte(abfd, ieee_function_either_open_b_enum); + if (r->sym_ptr_ptr != (asymbol **)NULL) { - ieee_write_expression(abfd, r->addend, + ieee_write_expression(abfd, r->addend + ov, r->section, - *(r->sym_ptr_ptr)); + *(r->sym_ptr_ptr), + r->howto->pc_relative, s->target_index); } else { - ieee_write_expression(abfd, r->addend, + ieee_write_expression(abfd, r->addend + ov, r->section, - (asymbol *)NULL); + (asymbol *)NULL, + r->howto->pc_relative, s->target_index); } ieee_write_byte(abfd, ieee_function_either_close_b_enum); + if (r->howto->size != 2) { + ieee_write_byte(abfd, ieee_comma); + ieee_write_int(abfd, 1<< r->howto->size); + } + relocs_to_go --; p++; } - /* FIXME !! Are all relocations 4 bytes ? */ - current_byte_index += 4; + } } } @@ -1478,7 +1541,7 @@ DEFUN(init_for_output,(abfd), asection *s; for (s = abfd->sections; s != (asection *)NULL; s = s->next) { if (s->size != 0) { - ieee_per_section(s)->data = (bfd_byte *)(ieee_malloc(abfd, s->size)); + ieee_per_section(s)->data = (bfd_byte *)(bfd_alloc(abfd, s->size)); } } } @@ -1492,7 +1555,7 @@ boolean DEFUN(ieee_set_section_contents,(abfd, section, location, offset, count), bfd *abfd AND sec_ptr section AND - unsigned char *location AND + PTR location AND file_ptr offset AND int count) { @@ -1557,14 +1620,14 @@ DEFUN(ieee_write_external_part,(abfd), ieee_write_expression(abfd, p->value + p->section->output_offset, p->section->output_section, - (asymbol *)NULL); + (asymbol *)NULL, false, 0); } else { ieee_write_expression(abfd, p->value, (asection *)NULL, - (asymbol *)NULL); + (asymbol *)NULL, false, 0); } p->value = public_index; public_index++; @@ -1668,144 +1731,7 @@ DEFUN(ieee_make_empty_symbol,(abfd), } -void -DEFUN(ieee_reclaim_symbol_table, (abfd), - bfd *abfd) -{ -#if 0 - asection *section; - - if (!bfd_get_symcount (abfd)) return; - - for (section = abfd->sections; section != NULL; section = section->next) - if (section->relocation) { - free ((void *)section->relocation); - section->relocation = NULL; - section->reloc_count = 0; - } - bfd_get_symcount (abfd) = 0; - free ((void *)obj_aout_symbols (abfd)); - obj_aout_symbols (abfd) = (aout_symbol_type *)NULL; -#endif -} - - - - -/* Obsolete procedural interface; better to look at the cache directly */ - -/* User should have checked the file flags; perhaps we should return -BFD_NO_MORE_SYMBOLS if there are none? */ - -int -DEFUN(ieee_get_symcount_upper_bound,(abfd), - bfd *abfd) -{ -#if 0 - /* In case we're doing an output file or something...? */ - if (bfd_get_symcount (abfd)) return bfd_get_symcount (abfd); - - return (exec_hdr (abfd)->a_syms) / (sizeof (struct nlist)); -#endif -return 0; -} - -symindex -DEFUN(ieee_get_first_symbol,(ignore_abfd), - bfd * ignore_abfd) -{ - return 0; -} - -symindex -DEFUN(ieee_get_next_symbol,(abfd, oidx), - bfd *abfd AND - symindex oidx) -{ -#if 0 - if (oidx == BFD_NO_MORE_SYMBOLS) return BFD_NO_MORE_SYMBOLS; - return ++oidx >= bfd_get_symcount (abfd) ? BFD_NO_MORE_SYMBOLS : - oidx; -#endif -return 0; -} - -char * -ieee_symbol_name (abfd, idx) -bfd *abfd; -symindex idx; -{ -#if 0 - return (obj_aout_symbols (abfd) + idx)->symbol.name; -#endif -return 0; -} - -long -ieee_symbol_value (abfd, idx) -bfd *abfd; -symindex idx; -{ -#if 0 - return (obj_aout_symbols (abfd) + idx)->symbol.value; -#endif -return 0; -} - -symclass -ieee_classify_symbol (abfd, idx) -bfd *abfd; -symindex idx; -{ -#if 0 - aout_symbol_type *sym = obj_aout_symbols (abfd) + idx; - - if ((sym->symbol.flags & BSF_FORT_COMM) != 0) return bfd_symclass_fcommon; - if ((sym->symbol.flags & BSF_GLOBAL) != 0) return bfd_symclass_global; - if ((sym->symbol.flags & BSF_DEBUGGING) != 0) return bfd_symclass_debugger; - if ((sym->symbol.flags & BSF_UNDEFINED) != 0) return bfd_symclass_undefined; -#endif - return bfd_symclass_unknown; -} - -boolean -ieee_symbol_hasclass (abfd, idx, class) -bfd *abfd; -symindex idx; -symclass class; -{ -#if 0 - aout_symbol_type *sym = obj_aout_symbols (abfd) + idx; - switch (class) { - case bfd_symclass_fcommon: - return (sym->symbol.flags & BSF_FORT_COMM) ? true :false; - case bfd_symclass_global: - return (sym->symbol.flags & BSF_GLOBAL) ? true:false; - case bfd_symclass_debugger: - return (sym->symbol.flags & BSF_DEBUGGING) ? true:false;; - case bfd_symclass_undefined: - return (sym->symbol.flags & BSF_UNDEFINED) ? true:false;; - default: return false; - } -#endif -return 0; -} - - -void -ieee_reclaim_reloc (ignore_abfd, section) -bfd *ignore_abfd; -sec_ptr section; -{ -#if 0 - if (section->relocation) { - free (section->relocation); - section->relocation = NULL; - section->reloc_count = 0; - } -#endif -} boolean ieee_close_and_cleanup (abfd) @@ -1829,11 +1755,6 @@ bfd *abfd; } - if (ieee_data(abfd) != (ieee_data_type *)NULL) { - /* FIXME MORE LEAKS */ - - } - return true; } @@ -1881,10 +1802,9 @@ asymbol **symbols; bfd_vma offset; char **filename_ptr; char **functionname_ptr; -unsigned int *line_ptr; +int *line_ptr; { return false; - } @@ -1905,20 +1825,21 @@ struct stat *buf; } } static int -DEFUN(ieee_sizeof_headers,(abfd), - bfd *abfd) +DEFUN(ieee_sizeof_headers,(abfd, x), + bfd *abfd AND + boolean x) { -return 0; + return 0; } -#define ieee_core_file_failing_command bfd_false -#define ieee_core_file_failing_signal bfd_false -#define ieee_core_file_matches_executable_p bfd_false +#define ieee_core_file_failing_command (char *(*)())(bfd_nullvoidptr) +#define ieee_core_file_failing_signal (int (*)())bfd_0 +#define ieee_core_file_matches_executable_p ( PROTO(boolean, (*),(bfd *, bfd *)))bfd_false #define ieee_slurp_armap bfd_true #define ieee_slurp_extended_name_table bfd_true -#define ieee_truncate_arname bfd_false -#define ieee_write_armap bfd_false -#define ieee_get_lineno bfd_false +#define ieee_truncate_arname (void (*)())bfd_nullvoidptr +#define ieee_write_armap (PROTO( boolean, (*),(bfd *, unsigned int, struct orl *, int, int))) bfd_nullvoidptr +#define ieee_get_lineno (struct lineno_cache_entry *(*)())bfd_nullvoidptr /*SUPPRESS 460 */ @@ -1939,10 +1860,10 @@ bfd_target ieee_vec = _do_getblong, _do_putblong, _do_getbshort, _do_putbshort, /* data */ _do_getblong, _do_putblong, _do_getbshort, _do_putbshort, /* hdrs */ - {_bfd_dummy_target, + { _bfd_dummy_target, ieee_object_p, /* bfd_check_format */ ieee_archive_p, - bfd_false + _bfd_dummy_target, }, { bfd_false, diff --git a/bfd/libbfd.c b/bfd/libbfd.c index f339092..f278a9c 100644 --- a/bfd/libbfd.c +++ b/bfd/libbfd.c @@ -50,11 +50,11 @@ bfd_true (ignore) return true; } -void * +PTR bfd_nullvoidptr(ignore) bfd *ignore; { - return (void *)NULL; + return (PTR)NULL; } int diff --git a/bfd/oasys.c b/bfd/oasys.c index 757a7b2..431f510 100644 --- a/bfd/oasys.c +++ b/bfd/oasys.c @@ -23,26 +23,24 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #define UNDERSCORE_HACK 1 #define offsetof(type, identifier) (size_t) &(((type *) 0)->identifier) - #include + #include "sysdep.h" #include "bfd.h" #include "libbfd.h" -#include "obstack.h" #include "oasys.h" #include "liboasys.h" - static void DEFUN(oasys_read_record,(abfd, record), bfd *CONST abfd AND oasys_record_union_type *record) { - bfd_read(record, 1, sizeof(record->header), abfd); + bfd_read((PTR)record, 1, sizeof(record->header), abfd); if ((size_t) record->header.length <= (size_t) sizeof (record->header)) return; - bfd_read(((char *)record )+ sizeof(record->header), + bfd_read((PTR)(((char *)record )+ sizeof(record->header)), 1, record->header.length - sizeof(record->header), abfd); } @@ -77,7 +75,6 @@ DEFUN(oasys_slurp_symbol_table,(abfd), oasys_record_union_type record; oasys_data_type *data = oasys_data(abfd); boolean loop = true; - asymbol *dest_undefined; asymbol *dest_defined; asymbol *dest; char *string_ptr; @@ -92,12 +89,12 @@ DEFUN(oasys_slurp_symbol_table,(abfd), #ifdef UNDERSCORE_HACK /* buy 1 more char for each symbol to keep the underscore in*/ data->strings = bfd_alloc(abfd, data->symbol_string_length + - abfd->symcount); + abfd->symcount); #else data->strings = bfd_alloc(abfd, data->symbol_string_length); #endif - dest_undefined = data->symbols; + dest_defined = data->symbols + abfd->symcount -1; string_ptr = data->strings; @@ -137,7 +134,7 @@ DEFUN(oasys_slurp_symbol_table,(abfd), } break; case RELOCATION_TYPE_UND: - dest = data->symbols + bfd_h_getshort(abfd, &record.symbol.refno[0]); + dest = data->symbols + bfd_h_getshort(abfd, (bfd_byte *)&record.symbol.refno[0]); dest->section = (asection *)NULL; dest->flags = BSF_UNDEFINED; break; @@ -176,7 +173,7 @@ DEFUN(oasys_slurp_symbol_table,(abfd), } -static size_t +static unsigned int DEFUN(oasys_get_symtab_upper_bound,(abfd), bfd *CONST abfd) { @@ -222,7 +219,7 @@ DEFUN(oasys_archive_p,(abfd), bfd_seek(abfd, (file_ptr) 0, false); - bfd_read(&header, 1, sizeof(header), abfd); + bfd_read((PTR)&header, 1, sizeof(header), abfd); swap(header.version); @@ -266,8 +263,7 @@ DEFUN(oasys_archive_p,(abfd), bfd_seek(abfd , header.mod_tbl_offset, SEEK_SET); for (i = 0; i < header.mod_count; i++) { - - bfd_read(&record, 1, sizeof(record), abfd); + bfd_read((PTR)&record, 1, sizeof(record), abfd); swap(record.mod_size); swap(record.file_offset); swap(record.mod_name_length); @@ -304,6 +300,7 @@ DEFUN(oasys_object_p,(abfd), bfd *abfd) { oasys_data_type *oasys; + oasys_data_type *save = oasys_data(abfd); boolean loop = true; boolean had_usefull = false; @@ -393,6 +390,7 @@ DEFUN(oasys_object_p,(abfd), fail: (void) bfd_release(abfd, oasys); + oasys_data(abfd) = save; return (bfd_target *)NULL; } @@ -852,6 +850,7 @@ DEFUN(oasys_write_end,(abfd), bfd *CONST abfd) { oasys_end_record_type end; + uint8e_type null = 0; end.relb = RELOCATION_TYPE_ABS; bfd_h_putlong(abfd, abfd->start_address, end.entry); bfd_h_putshort(abfd, 0, end.fill); @@ -860,6 +859,7 @@ DEFUN(oasys_write_end,(abfd), oasys_record_is_end_enum, (oasys_record_union_type *)&end, sizeof(end)); + bfd_write((PTR)&null, 1, 1, abfd); } static int @@ -1081,7 +1081,6 @@ DEFUN(oasys_make_empty_symbol,(abfd), -/* Obsbolete procedural interface; better to look at the cache directly */ /* User should have checked the file flags; perhaps we should return BFD_NO_MORE_SYMBOLS if there are none? */ @@ -1185,20 +1184,22 @@ DEFUN(oasys_generic_stat_arch_elt,(abfd, buf), } static int -DEFUN(oasys_sizeof_headers,(abfd), - bfd *abfd) +DEFUN(oasys_sizeof_headers,(abfd, exec), + bfd *abfd AND + boolean exec) { return 0; } -#define oasys_core_file_failing_command bfd_false -#define oasys_core_file_failing_signal bfd_false -#define oasys_core_file_matches_executable_p bfd_false -#define oasys_slurp_armap bfd_false -#define oasys_slurp_extended_name_table bfd_false -#define oasys_truncate_arname bfd_false -#define oasys_write_armap bfd_false -#define oasys_get_lineno bfd_false +#define oasys_core_file_failing_command (char *(*)())(bfd_nullvoidptr) +#define oasys_core_file_failing_signal (int (*)())bfd_0 +#define oasys_core_file_matches_executable_p 0 /*(PROTO(boolean, (*),(bfd*, bfd*)))bfd_false*/ +#define oasys_slurp_armap bfd_true +#define oasys_slurp_extended_name_table bfd_true +#define oasys_truncate_arname (void (*)())bfd_nullvoidptr +#define oasys_write_armap 0 /* (PROTO( boolean, (*),(bfd *, unsigned int, struct orl *, int, int))) bfd_nullvoidptr*/ +#define oasys_get_lineno (struct lineno_cache_entry *(*)())bfd_nullvoidptr + @@ -1223,7 +1224,7 @@ bfd_target oasys_vec = {_bfd_dummy_target, oasys_object_p, /* bfd_check_format */ oasys_archive_p, - bfd_false + _bfd_dummy_target, }, { bfd_false, diff --git a/bfd/srec.c b/bfd/srec.c index fe4fa7c..b5123ea 100644 --- a/bfd/srec.c +++ b/bfd/srec.c @@ -42,7 +42,11 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ /* $Id$ * $Log$ - * Revision 1.6 1991/04/25 04:06:21 gnu + * Revision 1.7 1991/05/08 19:21:47 steve + * Various portability lints. + * Fixed reloc bug in ieee and oasys. + * + * Revision 1.6 1991/04/25 04:06:21 gnu * Fix minor pointer type problems that "cc" complains about. * * Revision 1.5 1991/04/23 22:44:14 steve @@ -213,7 +217,7 @@ asection *section; bytes_on_line = HEX(&buffer.size); - bfd_read(buffer.u.data, 1 , bytes_on_line * 2, abfd); + bfd_read((PTR)buffer.u.data, 1 , bytes_on_line * 2, abfd); switch (buffer.type) { case '6': @@ -380,7 +384,7 @@ int bytes_to_do; data++; * ( (char *)(data)) = '\n'; - bfd_write(&buffer, 1, (char *)data - (char *)&buffer + 1 , abfd); + bfd_write((PTR)&buffer, 1, (char *)data - (char *)&buffer + 1 , abfd); bytes_written += bytes_this_chunk; location += bytes_this_chunk; @@ -427,13 +431,7 @@ return 0; } /*SUPPRESS 460 */ -#define srec_core_file_failing_command bfd_false -#define srec_core_file_failing_signal bfd_false -#define srec_core_file_matches_executable_p bfd_false -#define srec_slurp_armap bfd_false -#define srec_slurp_extended_name_table bfd_false -#define srec_truncate_arname bfd_false -#define srec_write_armap bfd_false + #define srec_new_section_hook bfd_false #define srec_get_symtab_upper_bound bfd_false #define srec_get_symtab bfd_false @@ -441,11 +439,22 @@ return 0; #define srec_canonicalize_reloc bfd_false #define srec_make_empty_symbol bfd_false #define srec_print_symbol bfd_false -#define srec_get_lineno bfd_false + #define srec_openr_next_archived_file bfd_false #define srec_find_nearest_line bfd_false #define srec_generic_stat_arch_elt bfd_false + +#define srec_core_file_failing_command (char *(*)())(bfd_nullvoidptr) +#define srec_core_file_failing_signal (int (*)())bfd_0 +#define srec_core_file_matches_executable_p (PROTO(boolean, (*),(bfd*, bfd*)))bfd_false +#define srec_slurp_armap bfd_true +#define srec_slurp_extended_name_table bfd_true +#define srec_truncate_arname (void (*)())bfd_nullvoidptr +#define srec_write_armap (PROTO( boolean, (*),(bfd *, unsigned int, struct orl *, int, int))) bfd_nullvoidptr +#define srec_get_lineno (struct lineno_cache_entry *(*)())bfd_nullvoidptr + + bfd_target srec_vec = { "srec", /* name */ diff --git a/bfd/sunos.c b/bfd/sunos.c index b714bf9..35f2d4f 100644 --- a/bfd/sunos.c +++ b/bfd/sunos.c @@ -1273,7 +1273,9 @@ swap_std_reloc_out (abfd, g, natptr) else { r_extern = 0; if (g->section == NULL) { - BFD_ASSERT(0); + /* It is possible to have a reloc with nothing, we generate an + abs + 0 */ + r_addend = 0; r_index = N_ABS | N_EXT; } else if(g->section->output_section == obj_textsec(abfd)) { -- cgit v1.1