X-Git-Url: http://git.osdn.net/view?a=blobdiff_plain;f=bfd%2Fieee.c;h=de1e926721164cf32fdd7bddb1aae138b5e381e0;hb=78121365ccfbaad8a06076d0502f95d91d8d4f04;hp=97ad7cc844e0b2f0f757cf7300b79bafc2d56694;hpb=7cb0b8f63ada523fb2b1d684aff84f3fa755a0ad;p=pf3gnuchains%2Fpf3gnuchains4x.git diff --git a/bfd/ieee.c b/bfd/ieee.c index 97ad7cc844..de1e926721 100644 --- a/bfd/ieee.c +++ b/bfd/ieee.c @@ -1,24 +1,27 @@ /* BFD back-end for ieee-695 objects. - Copyright (C) 1990, 91, 92, 93, 94, 95, 96, 97, 98, 1999 + Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, + 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010, 2011 Free Software Foundation, Inc. Written by Steve Chamberlain of Cygnus Support. -This file is part of BFD, the Binary File Descriptor library. + This file is part of BFD, the Binary File Descriptor library. -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 2 of the License, or -(at your option) any later version. + 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 3 of the License, or + (at your option) any later version. -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. + 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, + MA 02110-1301, USA. */ -You should have received a copy of the GNU General Public License -along with this program; if not, write to the Free Software -Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #define KEEPMINUSPCININST 0 @@ -26,81 +29,72 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ token (which is one byte in this lexicon) lookahead recursive decent parser. */ -#include "bfd.h" #include "sysdep.h" +#include "bfd.h" #include "libbfd.h" #include "ieee.h" #include "libieee.h" +#include "safe-ctype.h" + +struct output_buffer_struct +{ + unsigned char *ptrp; + int buffer; +}; + +static unsigned char *output_ptr_start; +static unsigned char *output_ptr; +static unsigned char *output_ptr_end; +static unsigned char *input_ptr_start; +static unsigned char *input_ptr; +static unsigned char *input_ptr_end; +static bfd *input_bfd; +static bfd *output_bfd; +static int output_buffer; + -#include - -static boolean ieee_write_byte PARAMS ((bfd *, int)); -static boolean ieee_write_2bytes PARAMS ((bfd *, int)); -static boolean ieee_write_int PARAMS ((bfd *, bfd_vma)); -static boolean ieee_write_id PARAMS ((bfd *, const char *)); -static boolean ieee_write_expression - PARAMS ((bfd *, bfd_vma, asymbol *, boolean, unsigned int)); -static void ieee_write_int5 PARAMS ((bfd_byte *, bfd_vma)); -static boolean ieee_write_int5_out PARAMS ((bfd *, bfd_vma)); -static boolean ieee_write_section_part PARAMS ((bfd *)); -static boolean do_with_relocs PARAMS ((bfd *, asection *)); -static boolean do_as_repeat PARAMS ((bfd *, asection *)); -static boolean do_without_relocs PARAMS ((bfd *, asection *)); -static boolean ieee_write_external_part PARAMS ((bfd *)); -static boolean ieee_write_data_part PARAMS ((bfd *)); -static boolean ieee_write_debug_part PARAMS ((bfd *)); -static boolean ieee_write_me_part PARAMS ((bfd *)); -static boolean ieee_write_processor PARAMS ((bfd *)); - -static boolean ieee_slurp_debug PARAMS ((bfd *)); -static boolean ieee_slurp_section_data PARAMS ((bfd *)); +static void block (void); /* Functions for writing to ieee files in the strange way that the - standard requires. */ + standard requires. */ -static boolean -ieee_write_byte (abfd, barg) - bfd *abfd; - int barg; +static bfd_boolean +ieee_write_byte (bfd *abfd, int barg) { bfd_byte byte; byte = barg; - if (bfd_write ((PTR) &byte, 1, 1, abfd) != 1) - return false; - return true; + if (bfd_bwrite ((void *) &byte, (bfd_size_type) 1, abfd) != 1) + return FALSE; + return TRUE; } -static boolean -ieee_write_2bytes (abfd, bytes) - bfd *abfd; - int bytes; +static bfd_boolean +ieee_write_2bytes (bfd *abfd, int bytes) { bfd_byte buffer[2]; buffer[0] = bytes >> 8; buffer[1] = bytes & 0xff; - if (bfd_write ((PTR) buffer, 1, 2, abfd) != 2) - return false; - return true; + if (bfd_bwrite ((void *) buffer, (bfd_size_type) 2, abfd) != 2) + return FALSE; + return TRUE; } -static boolean -ieee_write_int (abfd, value) - bfd *abfd; - bfd_vma value; +static bfd_boolean +ieee_write_int (bfd *abfd, bfd_vma value) { if (value <= 127) { if (! ieee_write_byte (abfd, (bfd_byte) value)) - return false; + return FALSE; } else { unsigned int length; - /* How many significant bytes ? */ - /* FIXME FOR LONGER INTS */ + /* How many significant bytes ? */ + /* FIXME FOR LONGER INTS. */ if (value & 0xff000000) length = 4; else if (value & 0x00ff0000) @@ -113,53 +107,51 @@ ieee_write_int (abfd, value) if (! ieee_write_byte (abfd, (bfd_byte) ((int) ieee_number_repeat_start_enum + length))) - return false; + return FALSE; switch (length) { case 4: if (! ieee_write_byte (abfd, (bfd_byte) (value >> 24))) - return false; + return FALSE; /* Fall through. */ case 3: if (! ieee_write_byte (abfd, (bfd_byte) (value >> 16))) - return false; + return FALSE; /* Fall through. */ case 2: if (! ieee_write_byte (abfd, (bfd_byte) (value >> 8))) - return false; + return FALSE; /* Fall through. */ case 1: if (! ieee_write_byte (abfd, (bfd_byte) (value))) - return false; + return FALSE; } } - return true; + return TRUE; } -static boolean -ieee_write_id (abfd, id) - bfd *abfd; - const char *id; +static bfd_boolean +ieee_write_id (bfd *abfd, const char *id) { size_t length = strlen (id); if (length <= 127) { if (! ieee_write_byte (abfd, (bfd_byte) length)) - return false; + return FALSE; } else if (length < 255) { if (! ieee_write_byte (abfd, ieee_extension_length_1_enum) || ! ieee_write_byte (abfd, (bfd_byte) length)) - return false; + return FALSE; } else if (length < 65535) { if (! ieee_write_byte (abfd, ieee_extension_length_2_enum) || ! ieee_write_2bytes (abfd, (int) length)) - return false; + return FALSE; } else { @@ -167,69 +159,63 @@ ieee_write_id (abfd, id) (_("%s: string too long (%d chars, max 65535)"), bfd_get_filename (abfd), length); bfd_set_error (bfd_error_invalid_operation); - return false; + return FALSE; } - if (bfd_write ((PTR) id, 1, length, abfd) != length) - return false; - return true; + if (bfd_bwrite ((void *) id, (bfd_size_type) length, abfd) != length) + return FALSE; + return TRUE; } -/*************************************************************************** -Functions for reading from ieee files in the strange way that the -standard requires: -*/ +/* Functions for reading from ieee files in the strange way that the + standard requires. */ -#define this_byte(ieee) *((ieee)->input_p) -#define next_byte(ieee) ((ieee)->input_p++) +#define this_byte(ieee) *((ieee)->input_p) +#define next_byte(ieee) ((ieee)->input_p++) #define this_byte_and_next(ieee) (*((ieee)->input_p++)) static unsigned short -read_2bytes (ieee) - common_header_type *ieee; +read_2bytes (common_header_type *ieee) { unsigned char c1 = this_byte_and_next (ieee); unsigned char c2 = this_byte_and_next (ieee); + return (c1 << 8) | c2; } static void -bfd_get_string (ieee, string, length) - common_header_type *ieee; - char *string; - size_t length; +bfd_get_string (common_header_type *ieee, char *string, size_t length) { size_t i; + for (i = 0; i < length; i++) - { - string[i] = this_byte_and_next (ieee); - } + string[i] = this_byte_and_next (ieee); } static char * -read_id (ieee) - common_header_type *ieee; +read_id (common_header_type *ieee) { size_t length; char *string; + length = this_byte_and_next (ieee); if (length <= 0x7f) - { - /* Simple string of length 0 to 127 */ - } + /* Simple string of length 0 to 127. */ + ; + else if (length == 0xde) - { - /* Length is next byte, allowing 0..255 */ - length = this_byte_and_next (ieee); - } + /* Length is next byte, allowing 0..255. */ + length = this_byte_and_next (ieee); + else if (length == 0xdf) { - /* Length is next two bytes, allowing 0..65535 */ + /* Length is next two bytes, allowing 0..65535. */ length = this_byte_and_next (ieee); length = (length * 256) + this_byte_and_next (ieee); } - /* Buy memory and read string */ - string = bfd_alloc (ieee->abfd, length + 1); + + /* Buy memory and read string. */ + string = bfd_alloc (ieee->abfd, (bfd_size_type) length + 1); if (!string) return NULL; bfd_get_string (ieee, string, length); @@ -237,107 +223,104 @@ read_id (ieee) return string; } -static boolean -ieee_write_expression (abfd, value, symbol, pcrel, index) - bfd *abfd; - bfd_vma value; - asymbol *symbol; - boolean pcrel; - unsigned int index; +static bfd_boolean +ieee_write_expression (bfd *abfd, + bfd_vma value, + asymbol *symbol, + bfd_boolean pcrel, + unsigned int sindex) { unsigned int term_count = 0; if (value != 0) { if (! ieee_write_int (abfd, value)) - return false; + return FALSE; term_count++; } - if (bfd_is_com_section (symbol->section) - || bfd_is_und_section (symbol->section)) - { - /* Def of a common symbol */ - if (! ieee_write_byte (abfd, ieee_variable_X_enum) - || ! ieee_write_int (abfd, symbol->value)) - return false; - term_count++; - } - else if (! bfd_is_abs_section (symbol->section)) + /* Badly formatted binaries can have a missing symbol, + so test here to prevent a seg fault. */ + if (symbol != NULL) { - /* Ref to defined symbol - */ - - if (symbol->flags & BSF_GLOBAL) + if (bfd_is_com_section (symbol->section) + || bfd_is_und_section (symbol->section)) { - if (! ieee_write_byte (abfd, ieee_variable_I_enum) + /* Def of a common symbol. */ + if (! ieee_write_byte (abfd, ieee_variable_X_enum) || ! ieee_write_int (abfd, symbol->value)) - return false; - term_count++; + return FALSE; + term_count ++; } - else if (symbol->flags & (BSF_LOCAL | BSF_SECTION_SYM)) + else if (! bfd_is_abs_section (symbol->section)) { - /* This is a reference to a defined local symbol. We can - easily do a local as a section+offset. */ - if (! ieee_write_byte (abfd, ieee_variable_R_enum) - || ! ieee_write_byte (abfd, - (bfd_byte) (symbol->section->index - + IEEE_SECTION_NUMBER_BASE))) - return false; - term_count++; - if (symbol->value != 0) + /* Ref to defined symbol - */ + if (symbol->flags & BSF_GLOBAL) { - if (! ieee_write_int (abfd, symbol->value)) - return false; + if (! ieee_write_byte (abfd, ieee_variable_I_enum) + || ! ieee_write_int (abfd, symbol->value)) + return FALSE; term_count++; } - } - else - { - (*_bfd_error_handler) - (_("%s: unrecognized symbol `%s' flags 0x%x"), - bfd_get_filename (abfd), bfd_asymbol_name (symbol), - symbol->flags); - bfd_set_error (bfd_error_invalid_operation); - return false; + else if (symbol->flags & (BSF_LOCAL | BSF_SECTION_SYM)) + { + /* This is a reference to a defined local symbol. We can + easily do a local as a section+offset. */ + if (! ieee_write_byte (abfd, ieee_variable_R_enum) + || ! ieee_write_byte (abfd, + (bfd_byte) (symbol->section->index + + IEEE_SECTION_NUMBER_BASE))) + return FALSE; + + term_count++; + if (symbol->value != 0) + { + if (! ieee_write_int (abfd, symbol->value)) + return FALSE; + term_count++; + } + } + else + { + (*_bfd_error_handler) + (_("%s: unrecognized symbol `%s' flags 0x%x"), + bfd_get_filename (abfd), bfd_asymbol_name (symbol), + symbol->flags); + bfd_set_error (bfd_error_invalid_operation); + return FALSE; + } } } if (pcrel) { - /* subtract the pc from here by asking for PC of this section*/ + /* Subtract the pc from here by asking for PC of this section. */ if (! ieee_write_byte (abfd, ieee_variable_P_enum) || ! ieee_write_byte (abfd, - (bfd_byte) (index + IEEE_SECTION_NUMBER_BASE)) + (bfd_byte) (sindex + IEEE_SECTION_NUMBER_BASE)) || ! ieee_write_byte (abfd, ieee_function_minus_enum)) - return false; + return FALSE; } /* Handle the degenerate case of a 0 address. */ if (term_count == 0) - { - if (! ieee_write_int (abfd, 0)) - return false; - } + if (! ieee_write_int (abfd, (bfd_vma) 0)) + return FALSE; while (term_count > 1) { if (! ieee_write_byte (abfd, ieee_function_plus_enum)) - return false; + return FALSE; term_count--; } - return true; + return TRUE; } -/*****************************************************************************/ +/* Writes any integer into the buffer supplied and always takes 5 bytes. */ -/* -writes any integer into the buffer supplied and always takes 5 bytes -*/ static void -ieee_write_int5 (buffer, value) - bfd_byte *buffer; - bfd_vma value; +ieee_write_int5 (bfd_byte *buffer, bfd_vma value) { buffer[0] = (bfd_byte) ieee_number_repeat_4_enum; buffer[1] = (value >> 24) & 0xff; @@ -346,35 +329,33 @@ ieee_write_int5 (buffer, value) buffer[4] = (value >> 0) & 0xff; } -static boolean -ieee_write_int5_out (abfd, value) - bfd *abfd; - bfd_vma value; +static bfd_boolean +ieee_write_int5_out (bfd *abfd, bfd_vma value) { bfd_byte b[5]; ieee_write_int5 (b, value); - if (bfd_write ((PTR) b, 1, 5, abfd) != 5) - return false; - return true; + if (bfd_bwrite ((void *) b, (bfd_size_type) 5, abfd) != 5) + return FALSE; + return TRUE; } -static boolean -parse_int (ieee, value_ptr) - common_header_type *ieee; - bfd_vma *value_ptr; +static bfd_boolean +parse_int (common_header_type *ieee, bfd_vma *value_ptr) { int value = this_byte (ieee); int result; + if (value >= 0 && value <= 127) { *value_ptr = value; next_byte (ieee); - return true; + return TRUE; } else if (value >= 0x80 && value <= 0x88) { unsigned int count = value & 0xf; + result = 0; next_byte (ieee); while (count) @@ -383,27 +364,24 @@ parse_int (ieee, value_ptr) count--; } *value_ptr = result; - return true; + return TRUE; } - return false; + return FALSE; } static int -parse_i (ieee, ok) - common_header_type *ieee; - boolean *ok; +parse_i (common_header_type *ieee, bfd_boolean *ok) { - bfd_vma x; + bfd_vma x = 0; *ok = parse_int (ieee, &x); return x; } static bfd_vma -must_parse_int (ieee) - common_header_type *ieee; +must_parse_int (common_header_type *ieee) { - bfd_vma result; - BFD_ASSERT (parse_int (ieee, &result) == true); + bfd_vma result = 0; + BFD_ASSERT (parse_int (ieee, &result)); return result; } @@ -418,12 +396,12 @@ typedef struct #if KEEPMINUSPCININST #define SRC_MASK(arg) arg -#define PCREL_OFFSET false +#define PCREL_OFFSET FALSE #else #define SRC_MASK(arg) 0 -#define PCREL_OFFSET true +#define PCREL_OFFSET TRUE #endif @@ -432,57 +410,57 @@ static reloc_howto_type abs32_howto = 0, 2, 32, - false, + FALSE, 0, complain_overflow_bitfield, 0, "abs32", - true, + TRUE, 0xffffffff, 0xffffffff, - false); + FALSE); static reloc_howto_type abs16_howto = HOWTO (1, 0, 1, 16, - false, + FALSE, 0, complain_overflow_bitfield, 0, "abs16", - true, + TRUE, 0x0000ffff, 0x0000ffff, - false); + FALSE); static reloc_howto_type abs8_howto = HOWTO (1, 0, 0, 8, - false, + FALSE, 0, complain_overflow_bitfield, 0, "abs8", - true, + TRUE, 0x000000ff, 0x000000ff, - false); + FALSE); static reloc_howto_type rel32_howto = HOWTO (1, 0, 2, 32, - true, + TRUE, 0, complain_overflow_signed, 0, "rel32", - true, + TRUE, SRC_MASK (0xffffffff), 0xffffffff, PCREL_OFFSET); @@ -492,12 +470,12 @@ static reloc_howto_type rel16_howto = 0, 1, 16, - true, + TRUE, 0, complain_overflow_signed, 0, "rel16", - true, + TRUE, SRC_MASK (0x0000ffff), 0x0000ffff, PCREL_OFFSET); @@ -507,12 +485,12 @@ static reloc_howto_type rel8_howto = 0, 0, 8, - true, + TRUE, 0, complain_overflow_signed, 0, "rel8", - true, + TRUE, SRC_MASK (0x000000ff), 0x000000ff, PCREL_OFFSET); @@ -520,65 +498,68 @@ static reloc_howto_type rel8_howto = static ieee_symbol_index_type NOSYMBOL = {0, 0}; static void -parse_expression (ieee, value, symbol, pcrel, extra, section) - ieee_data_type *ieee; - bfd_vma *value; - ieee_symbol_index_type *symbol; - boolean *pcrel; - unsigned int *extra; - asection **section; +parse_expression (ieee_data_type *ieee, + bfd_vma *value, + ieee_symbol_index_type *symbol, + bfd_boolean *pcrel, + unsigned int *extra, + asection **section) { + bfd_boolean loop = TRUE; + ieee_value_type stack[10]; + ieee_value_type *sp = stack; + asection *dummy; + #define POS sp[1] #define TOS sp[0] #define NOS sp[-1] #define INC sp++; #define DEC sp--; - boolean loop = true; - ieee_value_type stack[10]; - - /* The stack pointer always points to the next unused location */ -#define PUSH(x,y,z) TOS.symbol=x;TOS.section=y;TOS.value=z;INC; -#define POP(x,y,z) DEC;x=TOS.symbol;y=TOS.section;z=TOS.value; - ieee_value_type *sp = stack; + /* The stack pointer always points to the next unused location. */ +#define PUSH(x,y,z) TOS.symbol = x; TOS.section = y; TOS.value = z; INC; +#define POP(x,y,z) DEC; x = TOS.symbol; y = TOS.section; z = TOS.value; - while (loop) + while (loop && ieee->h.input_p < ieee->h.last_byte) { switch (this_byte (&(ieee->h))) { case ieee_variable_P_enum: - /* P variable, current program counter for section n */ + /* P variable, current program counter for section n. */ { int section_n; + next_byte (&(ieee->h)); - *pcrel = true; + *pcrel = TRUE; section_n = must_parse_int (&(ieee->h)); + (void) section_n; PUSH (NOSYMBOL, bfd_abs_section_ptr, 0); break; } case ieee_variable_L_enum: - /* L variable address of section N */ + /* L variable address of section N. */ next_byte (&(ieee->h)); PUSH (NOSYMBOL, ieee->section_table[must_parse_int (&(ieee->h))], 0); break; case ieee_variable_R_enum: - /* R variable, logical address of section module */ - /* FIXME, this should be different to L */ + /* R variable, logical address of section module. */ + /* FIXME, this should be different to L. */ next_byte (&(ieee->h)); PUSH (NOSYMBOL, ieee->section_table[must_parse_int (&(ieee->h))], 0); break; case ieee_variable_S_enum: - /* S variable, size in MAUS of section module */ + /* S variable, size in MAUS of section module. */ next_byte (&(ieee->h)); PUSH (NOSYMBOL, 0, - ieee->section_table[must_parse_int (&(ieee->h))]->_raw_size); + ieee->section_table[must_parse_int (&(ieee->h))]->size); break; case ieee_variable_I_enum: - /* Push the address of variable n */ + /* Push the address of variable n. */ { ieee_symbol_index_type sy; + next_byte (&(ieee->h)); sy.index = (int) must_parse_int (&(ieee->h)); sy.letter = 'I'; @@ -587,9 +568,10 @@ parse_expression (ieee, value, symbol, pcrel, extra, section) } break; case ieee_variable_X_enum: - /* Push the address of external variable n */ + /* Push the address of external variable n. */ { ieee_symbol_index_type sy; + next_byte (&(ieee->h)); sy.index = (int) (must_parse_int (&(ieee->h))); sy.letter = 'X'; @@ -602,6 +584,7 @@ parse_expression (ieee, value, symbol, pcrel, extra, section) bfd_vma value1, value2; asection *section1, *section_dummy; ieee_symbol_index_type sy; + next_byte (&(ieee->h)); POP (sy, section1, value1); @@ -616,6 +599,7 @@ parse_expression (ieee, value, symbol, pcrel, extra, section) asection *section2; ieee_symbol_index_type sy1; ieee_symbol_index_type sy2; + next_byte (&(ieee->h)); POP (sy1, section1, value1); @@ -628,6 +612,7 @@ parse_expression (ieee, value, symbol, pcrel, extra, section) default: { bfd_vma va; + BFD_ASSERT (this_byte (&(ieee->h)) < (int) ieee_variable_A_enum || this_byte (&(ieee->h)) > (int) ieee_variable_Z_enum); if (parse_int (&(ieee->h), &va)) @@ -635,71 +620,84 @@ parse_expression (ieee, value, symbol, pcrel, extra, section) PUSH (NOSYMBOL, bfd_abs_section_ptr, 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 omitted - 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); - } - { - asection *dummy; - - POP (*symbol, dummy, *value); - if (section) - *section = dummy; - } - - loop = false; - } + /* Thats all that we can understand. */ + loop = FALSE; } } } + + /* 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 omitted + 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); + (void) section1; + (void) sy1; + } + + POP (*symbol, dummy, *value); + if (section) + *section = dummy; } -#define ieee_seek(abfd, offset) \ - IEEE_DATA(abfd)->h.input_p = IEEE_DATA(abfd)->h.first_byte + offset +#define ieee_seek(ieee, offset) \ + do \ + { \ + ieee->h.input_p = ieee->h.first_byte + offset; \ + ieee->h.last_byte = (ieee->h.first_byte \ + + ieee_part_after (ieee, offset)); \ + } \ + while (0) + +#define ieee_pos(ieee) \ + (ieee->h.input_p - ieee->h.first_byte) + +/* Find the first part of the ieee file after HERE. */ + +static file_ptr +ieee_part_after (ieee_data_type *ieee, file_ptr here) +{ + int part; + file_ptr after = ieee->w.r.me_record; + + /* File parts can come in any order, except that module end is + guaranteed to be last (and the header first). */ + for (part = 0; part < N_W_VARIABLES; part++) + if (ieee->w.offset[part] > here && after > ieee->w.offset[part]) + after = ieee->w.offset[part]; -#define ieee_pos(abfd) \ - (IEEE_DATA(abfd)->h.input_p - IEEE_DATA(abfd)->h.first_byte) + return after; +} static unsigned int last_index; -static char last_type; /* is the index for an X or a D */ +static char last_type; /* Is the index for an X or a D. */ static ieee_symbol_type * -get_symbol (abfd, - ieee, - last_symbol, - symbol_count, - pptr, - max_index, - this_type -) - bfd *abfd ATTRIBUTE_UNUSED; - ieee_data_type *ieee; - ieee_symbol_type *last_symbol; - unsigned int *symbol_count; - ieee_symbol_type ***pptr; - unsigned int *max_index; - char this_type - ; -{ - /* Need a new symbol */ +get_symbol (bfd *abfd ATTRIBUTE_UNUSED, + ieee_data_type *ieee, + ieee_symbol_type *last_symbol, + unsigned int *symbol_count, + ieee_symbol_type ***pptr, + unsigned int *max_index, + int this_type) +{ + /* Need a new symbol. */ unsigned int new_index = must_parse_int (&(ieee->h)); + if (new_index != last_index || this_type != last_type) { - ieee_symbol_type *new_symbol = (ieee_symbol_type *) bfd_alloc (ieee->h.abfd, - sizeof (ieee_symbol_type)); + ieee_symbol_type *new_symbol; + bfd_size_type amt = sizeof (ieee_symbol_type); + + new_symbol = bfd_alloc (ieee->h.abfd, amt); if (!new_symbol) return NULL; @@ -709,9 +707,8 @@ get_symbol (abfd, **pptr = new_symbol; *pptr = &new_symbol->next; if (new_index > *max_index) - { - *max_index = new_index; - } + *max_index = new_index; + last_type = this_type; new_symbol->symbol.section = bfd_abs_section_ptr; return new_symbol; @@ -719,22 +716,22 @@ get_symbol (abfd, return last_symbol; } -static boolean -ieee_slurp_external_symbols (abfd) - bfd *abfd; +static bfd_boolean +ieee_slurp_external_symbols (bfd *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 *) NULL; + ieee_symbol_type *symbol = NULL; unsigned int symbol_count = 0; - boolean loop = true; + bfd_boolean loop = TRUE; + last_index = 0xffffff; - ieee->symbol_table_full = true; + ieee->symbol_table_full = TRUE; - ieee_seek (abfd, offset); + ieee_seek (ieee, offset); while (loop) { @@ -744,14 +741,14 @@ ieee_slurp_external_symbols (abfd) next_byte (&(ieee->h)); symbol = get_symbol (abfd, ieee, symbol, &symbol_count, - &prev_symbols_ptr, - &ieee->external_symbol_max_index, 'I'); + & prev_symbols_ptr, + & ieee->external_symbol_max_index, 'I'); if (symbol == NULL) - return false; + return FALSE; symbol->symbol.the_bfd = abfd; symbol->symbol.name = read_id (&(ieee->h)); - symbol->symbol.udata.p = (PTR) NULL; + symbol->symbol.udata.p = NULL; symbol->symbol.flags = BSF_NO_FLAGS; break; case ieee_external_symbol_enum: @@ -761,13 +758,13 @@ ieee_slurp_external_symbols (abfd) &prev_symbols_ptr, &ieee->external_symbol_max_index, 'D'); if (symbol == NULL) - return false; + return FALSE; BFD_ASSERT (symbol->index >= ieee->external_symbol_min_index); symbol->symbol.the_bfd = abfd; symbol->symbol.name = read_id (&(ieee->h)); - symbol->symbol.udata.p = (PTR) NULL; + symbol->symbol.udata.p = NULL; symbol->symbol.flags = BSF_NO_FLAGS; break; case ieee_attribute_record_enum >> 8: @@ -775,12 +772,14 @@ ieee_slurp_external_symbols (abfd) unsigned int symbol_name_index; unsigned int symbol_type_index; unsigned int symbol_attribute_def; - bfd_vma value; - switch (read_2bytes (ieee)) + bfd_vma value = 0; + + switch (read_2bytes (&ieee->h)) { case ieee_attribute_record_enum: symbol_name_index = must_parse_int (&(ieee->h)); symbol_type_index = must_parse_int (&(ieee->h)); + (void) symbol_type_index; symbol_attribute_def = must_parse_int (&(ieee->h)); switch (symbol_attribute_def) { @@ -790,16 +789,15 @@ ieee_slurp_external_symbols (abfd) break; default: (*_bfd_error_handler) - (_("%s: unimplemented ATI record %u for symbol %u"), - bfd_get_filename (abfd), symbol_attribute_def, - symbol_name_index); + (_("%B: unimplemented ATI record %u for symbol %u"), + abfd, symbol_attribute_def, symbol_name_index); bfd_set_error (bfd_error_bad_value); - return false; + return FALSE; break; } break; case ieee_external_reference_info_record_enum: - /* Skip over ATX record. */ + /* Skip over ATX record. */ parse_int (&(ieee->h), &value); parse_int (&(ieee->h), &value); parse_int (&(ieee->h), &value); @@ -808,17 +806,17 @@ ieee_slurp_external_symbols (abfd) case ieee_atn_record_enum: /* We may get call optimization information here, which we just ignore. The format is - {$F1}${CE}{index}{$00}{$3F}{$3F}{#_of_ASNs} */ + {$F1}${CE}{index}{$00}{$3F}{$3F}{#_of_ASNs}. */ parse_int (&ieee->h, &value); parse_int (&ieee->h, &value); parse_int (&ieee->h, &value); if (value != 0x3f) { (*_bfd_error_handler) - (_("%s: unexpected ATN type %d in external part"), - bfd_get_filename (abfd), (int) value); + (_("%B: unexpected ATN type %d in external part"), + abfd, (int) value); bfd_set_error (bfd_error_bad_value); - return false; + return FALSE; } parse_int (&ieee->h, &value); parse_int (&ieee->h, &value); @@ -828,7 +826,7 @@ ieee_slurp_external_symbols (abfd) --value; - switch (read_2bytes (ieee)) + switch (read_2bytes (&ieee->h)) { case ieee_asn_record_enum: parse_int (&ieee->h, &val1); @@ -837,10 +835,9 @@ ieee_slurp_external_symbols (abfd) default: (*_bfd_error_handler) - (_("%s: unexpected type after ATN"), - bfd_get_filename (abfd)); + (_("%B: unexpected type after ATN"), abfd); bfd_set_error (bfd_error_bad_value); - return false; + return FALSE; } } } @@ -850,12 +847,14 @@ ieee_slurp_external_symbols (abfd) { unsigned int symbol_name_index; ieee_symbol_index_type symbol_ignore; - boolean pcrel_ignore; + bfd_boolean pcrel_ignore; unsigned int extra; + next_byte (&(ieee->h)); next_byte (&(ieee->h)); symbol_name_index = must_parse_int (&(ieee->h)); + (void) symbol_name_index; parse_expression (ieee, &symbol->symbol.value, &symbol_ignore, @@ -876,7 +875,7 @@ ieee_slurp_external_symbols (abfd) val = symbol->symbol.value; for (s = abfd->sections; s != NULL; s = s->next) { - if (val >= s->vma && val < s->vma + s->_raw_size) + if (val >= s->vma && val < s->vma + s->size) { symbol->symbol.section = s; symbol->symbol.value -= s->vma; @@ -893,17 +892,16 @@ ieee_slurp_external_symbols (abfd) { bfd_vma size; bfd_vma value; + next_byte (&(ieee->h)); - /* Throw away the external reference index */ + /* Throw away the external reference index. */ (void) must_parse_int (&(ieee->h)); - /* Fetch the default size if not resolved */ + /* 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 */ + /* Fetch the default value if available. */ + if (! parse_int (&(ieee->h), &value)) + value = 0; + /* This turns into a common. */ symbol->symbol.section = bfd_com_section_ptr; symbol->symbol.value = size; } @@ -916,11 +914,11 @@ ieee_slurp_external_symbols (abfd) &prev_reference_ptr, &ieee->external_reference_max_index, 'X'); if (symbol == NULL) - return false; + return FALSE; symbol->symbol.the_bfd = abfd; symbol->symbol.name = read_id (&(ieee->h)); - symbol->symbol.udata.p = (PTR) NULL; + symbol->symbol.udata.p = NULL; symbol->symbol.section = bfd_und_section_ptr; symbol->symbol.value = (bfd_vma) 0; symbol->symbol.flags = 0; @@ -929,7 +927,7 @@ ieee_slurp_external_symbols (abfd) break; default: - loop = false; + loop = FALSE; } } @@ -940,9 +938,7 @@ ieee_slurp_external_symbols (abfd) ieee->external_symbol_min_index + 1; } else - { - ieee->external_symbol_count = 0; - } + ieee->external_symbol_count = 0; if (ieee->external_reference_max_index != 0) { @@ -951,41 +947,35 @@ ieee_slurp_external_symbols (abfd) ieee->external_reference_min_index + 1; } else - { - ieee->external_reference_count = 0; - } + ieee->external_reference_count = 0; abfd->symcount = ieee->external_reference_count + ieee->external_symbol_count; if (symbol_count != abfd->symcount) - { - /* There are gaps in the table -- */ - ieee->symbol_table_full = false; - } + /* 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; + *prev_symbols_ptr = NULL; + *prev_reference_ptr = NULL; - return true; + return TRUE; } -static boolean -ieee_slurp_symbol_table (abfd) - bfd *abfd; +static bfd_boolean +ieee_slurp_symbol_table (bfd *abfd) { - if (IEEE_DATA (abfd)->read_symbols == false) + if (! IEEE_DATA (abfd)->read_symbols) { if (! ieee_slurp_external_symbols (abfd)) - return false; - IEEE_DATA (abfd)->read_symbols = true; + return FALSE; + IEEE_DATA (abfd)->read_symbols = TRUE; } - return true; + return TRUE; } -long -ieee_get_symtab_upper_bound (abfd) - bfd *abfd; +static long +ieee_get_symtab_upper_bound (bfd *abfd) { if (! ieee_slurp_symbol_table (abfd)) return -1; @@ -994,17 +984,13 @@ ieee_get_symtab_upper_bound (abfd) (abfd->symcount + 1) * (sizeof (ieee_symbol_type *)) : 0; } -/* -Move from our internal lists to the canon table, and insert in -symbol index order -*/ +/* Move from our internal lists to the canon table, and insert in + symbol index order. */ extern const bfd_target ieee_vec; -long -ieee_get_symtab (abfd, location) - bfd *abfd; - asymbol **location; +static long +ieee_canonicalize_symtab (bfd *abfd, asymbol **location) { ieee_symbol_type *symp; static bfd dummy_bfd; @@ -1024,69 +1010,63 @@ ieee_get_symtab (abfd, location) if (abfd->symcount) { ieee_data_type *ieee = IEEE_DATA (abfd); + dummy_bfd.xvec = &ieee_vec; if (! ieee_slurp_symbol_table (abfd)) return -1; - if (ieee->symbol_table_full == false) + if (! ieee->symbol_table_full) { - /* Arrgh - there are gaps in the table, run through and fill them */ - /* up with pointers to a null place */ + /* Arrgh - there are gaps in the table, run through and fill them + up with pointers to a null place. */ unsigned int i; + for (i = 0; i < abfd->symcount; i++) - { - location[i] = &empty_symbol; - } + location[i] = &empty_symbol; } ieee->external_symbol_base_offset = -ieee->external_symbol_min_index; for (symp = IEEE_DATA (abfd)->external_symbols; symp != (ieee_symbol_type *) NULL; symp = symp->next) - { - /* Place into table at correct index locations */ - location[symp->index + ieee->external_symbol_base_offset] = &symp->symbol; - } + /* Place into table at correct index locations. */ + location[symp->index + ieee->external_symbol_base_offset] = &symp->symbol; - /* The external refs are indexed in a bit */ + /* The external refs are indexed in a bit. */ ieee->external_reference_base_offset = -ieee->external_reference_min_index + ieee->external_symbol_count; for (symp = IEEE_DATA (abfd)->external_reference; symp != (ieee_symbol_type *) NULL; symp = symp->next) - { - location[symp->index + ieee->external_reference_base_offset] = - &symp->symbol; - - } + location[symp->index + ieee->external_reference_base_offset] = + &symp->symbol; } + if (abfd->symcount) - { - location[abfd->symcount] = (asymbol *) NULL; - } + location[abfd->symcount] = (asymbol *) NULL; + return abfd->symcount; } static asection * -get_section_entry (abfd, ieee, index) - bfd *abfd; - ieee_data_type *ieee; - unsigned int index; +get_section_entry (bfd *abfd, ieee_data_type *ieee, unsigned int sindex) { - if (index >= ieee->section_table_size) + if (sindex >= ieee->section_table_size) { unsigned int c, i; asection **n; + bfd_size_type amt; c = ieee->section_table_size; if (c == 0) c = 20; - while (c <= index) + while (c <= sindex) c *= 2; - n = ((asection **) - bfd_realloc (ieee->section_table, c * sizeof (asection *))); + amt = c; + amt *= sizeof (asection *); + n = bfd_realloc (ieee->section_table, amt); if (n == NULL) return NULL; @@ -1097,43 +1077,43 @@ get_section_entry (abfd, ieee, index) ieee->section_table_size = c; } - if (ieee->section_table[index] == (asection *) NULL) + if (ieee->section_table[sindex] == (asection *) NULL) { - char *tmp = bfd_alloc (abfd, 11); + char *tmp = bfd_alloc (abfd, (bfd_size_type) 11); asection *section; if (!tmp) return NULL; - sprintf (tmp, " fsec%4d", index); + sprintf (tmp, " fsec%4d", sindex); section = bfd_make_section (abfd, tmp); - ieee->section_table[index] = section; - section->flags = SEC_NO_FLAGS; - section->target_index = index; - ieee->section_table[index] = section; + ieee->section_table[sindex] = section; + section->target_index = sindex; + ieee->section_table[sindex] = section; } - return ieee->section_table[index]; + return ieee->section_table[sindex]; } static void -ieee_slurp_sections (abfd) - bfd *abfd; +ieee_slurp_sections (bfd *abfd) { ieee_data_type *ieee = IEEE_DATA (abfd); file_ptr offset = ieee->w.r.section_part; - asection *section = (asection *) NULL; char *name; if (offset != 0) { bfd_byte section_type[3]; - ieee_seek (abfd, offset); - while (true) + + ieee_seek (ieee, offset); + while (TRUE) { switch (this_byte (&(ieee->h))) { case ieee_section_type_enum: { + asection *section; unsigned int section_index; + next_byte (&(ieee->h)); section_index = must_parse_int (&(ieee->h)); @@ -1142,34 +1122,34 @@ ieee_slurp_sections (abfd) section_type[0] = this_byte_and_next (&(ieee->h)); /* Set minimal section attributes. Attributes are - extended later, based on section contents. */ - + extended later, based on section contents. */ switch (section_type[0]) { case 0xC1: - /* Normal attributes for absolute sections */ + /* Normal attributes for absolute sections. */ section_type[1] = this_byte (&(ieee->h)); section->flags = SEC_ALLOC; switch (section_type[1]) { - case 0xD3: /* AS Absolute section attributes */ + /* AS Absolute section attributes. */ + case 0xD3: next_byte (&(ieee->h)); section_type[2] = this_byte (&(ieee->h)); switch (section_type[2]) { case 0xD0: - /* Normal code */ + /* Normal code. */ next_byte (&(ieee->h)); section->flags |= SEC_CODE; break; case 0xC4: - /* Normal data */ + /* Normal data. */ next_byte (&(ieee->h)); section->flags |= SEC_DATA; break; case 0xD2: next_byte (&(ieee->h)); - /* Normal rom data */ + /* Normal rom data. */ section->flags |= SEC_ROM | SEC_DATA; break; default: @@ -1177,20 +1157,22 @@ ieee_slurp_sections (abfd) } } break; - case 0xC3: /* Named relocatable sections (type C) */ + + /* Named relocatable sections (type C). */ + case 0xC3: section_type[1] = this_byte (&(ieee->h)); section->flags = SEC_ALLOC; switch (section_type[1]) { - case 0xD0: /* Normal code (CP) */ + case 0xD0: /* Normal code (CP). */ next_byte (&(ieee->h)); section->flags |= SEC_CODE; break; - case 0xC4: /* Normal data (CD) */ + case 0xC4: /* Normal data (CD). */ next_byte (&(ieee->h)); section->flags |= SEC_DATA; break; - case 0xD2: /* Normal rom data (CR) */ + case 0xD2: /* Normal rom data (CR). */ next_byte (&(ieee->h)); section->flags |= SEC_ROM | SEC_DATA; break; @@ -1199,14 +1181,15 @@ ieee_slurp_sections (abfd) } } - /* Read section name, use it if non empty. */ + /* Read section name, use it if non empty. */ name = read_id (&ieee->h); if (name[0]) section->name = name; - /* Skip these fields, which we don't care about */ + /* Skip these fields, which we don't care about. */ { bfd_vma parent, brother, context; + parse_int (&(ieee->h), &parent); parse_int (&(ieee->h), &brother); parse_int (&(ieee->h), &context); @@ -1218,13 +1201,13 @@ ieee_slurp_sections (abfd) 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; - } + ieee->section_count = section_index; + section->alignment_power = bfd_log2 (must_parse_int (&ieee->h)); (void) parse_int (&(ieee->h), &value); @@ -1232,17 +1215,19 @@ ieee_slurp_sections (abfd) break; case ieee_e2_first_byte_enum: { - ieee_record_enum_type t = (ieee_record_enum_type) (read_2bytes (&(ieee->h))); + asection *section; + ieee_record_enum_type t; + 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->_raw_size = 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->_raw_size = 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))]; @@ -1283,40 +1268,33 @@ ieee_slurp_sections (abfd) at the area in the file so that program which understand can dig it out. */ -static boolean -ieee_slurp_debug (abfd) - bfd *abfd; +static bfd_boolean +ieee_slurp_debug (bfd *abfd) { ieee_data_type *ieee = IEEE_DATA (abfd); asection *sec; file_ptr debug_end; + flagword flags; if (ieee->w.r.debug_information_part == 0) - return true; + return TRUE; - sec = bfd_make_section (abfd, ".debug"); + flags = SEC_DEBUGGING | SEC_HAS_CONTENTS; + sec = bfd_make_section_with_flags (abfd, ".debug", flags); if (sec == NULL) - return false; - sec->flags |= SEC_DEBUGGING | SEC_HAS_CONTENTS; + return FALSE; sec->filepos = ieee->w.r.debug_information_part; - debug_end = ieee->w.r.data_part; - if (debug_end == 0) - debug_end = ieee->w.r.trailer_part; - if (debug_end == 0) - debug_end = ieee->w.r.me_record; - sec->_raw_size = debug_end - ieee->w.r.debug_information_part; + debug_end = ieee_part_after (ieee, ieee->w.r.debug_information_part); + sec->size = debug_end - ieee->w.r.debug_information_part; - return true; + return TRUE; } -/*********************************************************************** -* archive stuff -*/ +/* Archive stuff. */ -const bfd_target * -ieee_archive_p (abfd) - bfd *abfd; +static const bfd_target * +ieee_archive_p (bfd *abfd) { char *library; unsigned int i; @@ -1324,18 +1302,18 @@ ieee_archive_p (abfd) file_ptr buffer_offset = 0; ieee_ar_data_type *save = abfd->tdata.ieee_ar_data; ieee_ar_data_type *ieee; - unsigned int alc_elts; + bfd_size_type alc_elts; ieee_ar_obstack_type *elts = NULL; + bfd_size_type amt = sizeof (ieee_ar_data_type); - abfd->tdata.ieee_ar_data = - (ieee_ar_data_type *) bfd_alloc (abfd, sizeof (ieee_ar_data_type)); + abfd->tdata.ieee_ar_data = bfd_alloc (abfd, amt); if (!abfd->tdata.ieee_ar_data) - goto error_return; + goto error_ret_restore; ieee = IEEE_AR_DATA (abfd); - /* FIXME: Check return value. I'm not sure whether it needs to read - the entire buffer or not. */ - bfd_read ((PTR) buffer, 1, sizeof (buffer), abfd); + /* Ignore the return value here. It doesn't matter if we don't read + the entire buffer. We might have a very small ieee file. */ + bfd_bread ((void *) buffer, (bfd_size_type) sizeof (buffer), abfd); ieee->h.first_byte = buffer; ieee->h.input_p = buffer; @@ -1343,35 +1321,29 @@ ieee_archive_p (abfd) ieee->h.abfd = abfd; if (this_byte (&(ieee->h)) != Module_Beginning) - { - abfd->tdata.ieee_ar_data = save; - goto got_wrong_format_error; - } + goto got_wrong_format_error; next_byte (&(ieee->h)); library = read_id (&(ieee->h)); if (strcmp (library, "LIBRARY") != 0) - { - bfd_release (abfd, ieee); - abfd->tdata.ieee_ar_data = save; - goto got_wrong_format_error; - } - /* Throw away the filename */ + goto got_wrong_format_error; + + /* Throw away the filename. */ read_id (&(ieee->h)); ieee->element_count = 0; ieee->element_index = 0; - next_byte (&(ieee->h)); /* Drop the ad part */ - must_parse_int (&(ieee->h)); /* And the two dummy numbers */ + next_byte (&(ieee->h)); /* Drop the ad part. */ + must_parse_int (&(ieee->h)); /* And the two dummy numbers. */ must_parse_int (&(ieee->h)); alc_elts = 10; - elts = (ieee_ar_obstack_type *) bfd_malloc (alc_elts * sizeof *elts); + elts = bfd_malloc (alc_elts * sizeof *elts); if (elts == NULL) goto error_return; - /* Read the index of the BB table */ + /* Read the index of the BB table. */ while (1) { int rec; @@ -1386,8 +1358,7 @@ ieee_archive_p (abfd) ieee_ar_obstack_type *n; alc_elts *= 2; - n = ((ieee_ar_obstack_type *) - bfd_realloc (elts, alc_elts * sizeof *elts)); + n = bfd_realloc (elts, alc_elts * sizeof (* elts)); if (n == NULL) goto error_return; elts = n; @@ -1400,57 +1371,51 @@ ieee_archive_p (abfd) t->file_offset = must_parse_int (&(ieee->h)); t->abfd = (bfd *) NULL; - /* Make sure that we don't go over the end of the buffer */ - - if ((size_t) ieee_pos (abfd) > sizeof (buffer) / 2) + /* Make sure that we don't go over the end of the buffer. */ + if ((size_t) ieee_pos (IEEE_DATA (abfd)) > sizeof (buffer) / 2) { - /* Past half way, reseek and reprime */ - buffer_offset += ieee_pos (abfd); + /* Past half way, reseek and reprime. */ + buffer_offset += ieee_pos (IEEE_DATA (abfd)); if (bfd_seek (abfd, buffer_offset, SEEK_SET) != 0) goto error_return; - /* FIXME: Check return value. I'm not sure whether it needs - to read the entire buffer or not. */ - bfd_read ((PTR) buffer, 1, sizeof (buffer), abfd); + + /* Again ignore return value of bfd_bread. */ + bfd_bread ((void *) buffer, (bfd_size_type) sizeof (buffer), abfd); ieee->h.first_byte = buffer; ieee->h.input_p = buffer; } } - ieee->elements = ((ieee_ar_obstack_type *) - bfd_alloc (abfd, - ieee->element_count * sizeof *ieee->elements)); + amt = ieee->element_count; + amt *= sizeof *ieee->elements; + ieee->elements = bfd_alloc (abfd, amt); if (ieee->elements == NULL) goto error_return; - memcpy (ieee->elements, elts, - ieee->element_count * sizeof *ieee->elements); + + memcpy (ieee->elements, elts, (size_t) amt); free (elts); elts = NULL; - /* Now scan the area again, and replace BB offsets with file */ - /* offsets */ - + /* Now scan the area again, and replace BB offsets with file offsets. */ for (i = 2; i < ieee->element_count; i++) { if (bfd_seek (abfd, ieee->elements[i].file_offset, SEEK_SET) != 0) goto error_return; - /* FIXME: Check return value. I'm not sure whether it needs to - read the entire buffer or not. */ - bfd_read ((PTR) buffer, 1, sizeof (buffer), abfd); + + /* Again ignore return value of bfd_bread. */ + bfd_bread ((void *) buffer, (bfd_size_type) sizeof (buffer), abfd); ieee->h.first_byte = buffer; ieee->h.input_p = buffer; - next_byte (&(ieee->h)); /* Drop F8 */ - next_byte (&(ieee->h)); /* Drop 14 */ - must_parse_int (&(ieee->h)); /* Drop size of block */ + next_byte (&(ieee->h)); /* Drop F8. */ + next_byte (&(ieee->h)); /* Drop 14. */ + must_parse_int (&(ieee->h)); /* Drop size of block. */ + if (must_parse_int (&(ieee->h)) != 0) - { - /* This object has been deleted */ - ieee->elements[i].file_offset = 0; - } + /* This object has been deleted. */ + ieee->elements[i].file_offset = 0; else - { - ieee->elements[i].file_offset = must_parse_int (&(ieee->h)); - } + ieee->elements[i].file_offset = must_parse_int (&(ieee->h)); } /* abfd->has_armap = ;*/ @@ -1462,318 +1427,80 @@ ieee_archive_p (abfd) error_return: if (elts != NULL) free (elts); + bfd_release (abfd, ieee); + error_ret_restore: + abfd->tdata.ieee_ar_data = save; + return NULL; } -static boolean -ieee_mkobject (abfd) - bfd *abfd; +static bfd_boolean +ieee_mkobject (bfd *abfd) { - abfd->tdata.ieee_data = (ieee_data_type *) bfd_zalloc (abfd, sizeof (ieee_data_type)); - return abfd->tdata.ieee_data ? true : false; + bfd_size_type amt; + + output_ptr_start = NULL; + output_ptr = NULL; + output_ptr_end = NULL; + input_ptr_start = NULL; + input_ptr = NULL; + input_ptr_end = NULL; + input_bfd = NULL; + output_bfd = NULL; + output_buffer = 0; + amt = sizeof (ieee_data_type); + abfd->tdata.ieee_data = bfd_zalloc (abfd, amt); + return abfd->tdata.ieee_data != NULL; } -const bfd_target * -ieee_object_p (abfd) - bfd *abfd; +static bfd_boolean +do_one (ieee_data_type *ieee, + ieee_per_section_type *current_map, + unsigned char *location_ptr, + asection *s, + int iterations) { - char *processor; - unsigned int part; - ieee_data_type *ieee; - unsigned char buffer[300]; - ieee_data_type *save = IEEE_DATA (abfd); - - abfd->tdata.ieee_data = 0; - ieee_mkobject (abfd); - - ieee = IEEE_DATA (abfd); - if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) - goto fail; - /* Read the first few bytes in to see if it makes sense */ - /* FIXME: Check return value. I'm not sure whether it needs to read - the entire buffer or not. */ - bfd_read ((PTR) buffer, 1, sizeof (buffer), abfd); - - ieee->h.input_p = buffer; - if (this_byte_and_next (&(ieee->h)) != Module_Beginning) - goto got_wrong_format; - - ieee->read_symbols = false; - ieee->read_data = false; - ieee->section_count = 0; - ieee->external_symbol_max_index = 0; - ieee->external_symbol_min_index = IEEE_PUBLIC_BASE; - ieee->external_reference_min_index = IEEE_REFERENCE_BASE; - ieee->external_reference_max_index = 0; - ieee->h.abfd = abfd; - ieee->section_table = NULL; - ieee->section_table_size = 0; - - processor = ieee->mb.processor = read_id (&(ieee->h)); - if (strcmp (processor, "LIBRARY") == 0) - goto got_wrong_format; - ieee->mb.module_name = read_id (&(ieee->h)); - if (abfd->filename == (CONST char *) NULL) + switch (this_byte (&(ieee->h))) { - abfd->filename = ieee->mb.module_name; - } - /* Determine the architecture and machine type of the object file. - */ - { - const bfd_arch_info_type *arch; - char family[10]; - - /* IEEE does not specify the format of the processor identificaton - string, so the compiler is free to put in it whatever it wants. - We try here to recognize different processors belonging to the - m68k family. Code for other processors can be added here. */ - if ((processor[0] == '6') && (processor[1] == '8')) + case ieee_load_constant_bytes_enum: { - if (processor[2] == '3') /* 683xx integrated processors */ - { - switch (processor[3]) - { - case '0': /* 68302, 68306, 68307 */ - case '2': /* 68322, 68328 */ - case '5': /* 68356 */ - strcpy (family, "68000"); /* MC68000-based controllers */ - break; - - case '3': /* 68330, 68331, 68332, 68333, - 68334, 68335, 68336, 68338 */ - case '6': /* 68360 */ - case '7': /* 68376 */ - strcpy (family, "68332"); /* CPU32 and CPU32+ */ - break; + unsigned int number_of_maus; + unsigned int i; - case '4': - if (processor[4] == '9') /* 68349 */ - strcpy (family, "68030"); /* CPU030 */ - else /* 68340, 68341 */ - strcpy (family, "68332"); /* CPU32 and CPU32+ */ - break; + next_byte (&(ieee->h)); + number_of_maus = must_parse_int (&(ieee->h)); - default: /* Does not exist yet */ - strcpy (family, "68332"); /* Guess it will be CPU32 */ - } - } - else if (toupper (processor[3]) == 'F') /* 68F333 */ - strcpy (family, "68332"); /* CPU32 */ - else if ((toupper (processor[3]) == 'C') /* Embedded controllers */ - && ((toupper (processor[2]) == 'E') - || (toupper (processor[2]) == 'H') - || (toupper (processor[2]) == 'L'))) - { - strcpy (family, "68"); - strncat (family, processor + 4, 7); - family[9] = '\0'; - } - else /* "Regular" processors */ + for (i = 0; i < number_of_maus; i++) { - strncpy (family, processor, 9); - family[9] = '\0'; + location_ptr[current_map->pc++] = this_byte (&(ieee->h)); + next_byte (&(ieee->h)); } } - else if ((strncmp (processor, "cpu32", 5) == 0) /* CPU32 and CPU32+ */ - || (strncmp (processor, "CPU32", 5) == 0)) - strcpy (family, "68332"); - else + break; + + case ieee_load_with_relocation_enum: { - strncpy (family, processor, 9); - family[9] = '\0'; - } + bfd_boolean loop = TRUE; - arch = bfd_scan_arch (family); - if (arch == 0) - goto got_wrong_format; - abfd->arch_info = arch; - } - - if (this_byte (&(ieee->h)) != (int) ieee_address_descriptor_enum) - { - goto fail; - } - next_byte (&(ieee->h)); - - if (parse_int (&(ieee->h), &ieee->ad.number_of_bits_mau) == false) - { - goto fail; - } - if (parse_int (&(ieee->h), &ieee->ad.number_of_maus_in_address) == false) - { - goto fail; - } - - /* If there is a byte order info, take it */ - if (this_byte (&(ieee->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)) != (int) ieee_assign_value_to_variable_enum) - { - goto fail; - } - if (this_byte_and_next (&(ieee->h)) != part) - { - goto fail; - } - - ieee->w.offset[part] = parse_i (&(ieee->h), &ok); - if (ok == false) - { - goto fail; - } - - } - - if (ieee->w.r.external_part != 0) - abfd->flags = HAS_SYMS; - - /* By now we know that this is a real IEEE file, we're going to read - the whole thing into memory so that we can run up and down it - quickly. We can work out how big the file is from the trailer - record */ - - IEEE_DATA (abfd)->h.first_byte = - (unsigned char *) bfd_alloc (ieee->h.abfd, ieee->w.r.me_record + 1); - if (!IEEE_DATA (abfd)->h.first_byte) - goto fail; - if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) - goto fail; - /* FIXME: Check return value. I'm not sure whether it needs to read - the entire buffer or not. */ - bfd_read ((PTR) (IEEE_DATA (abfd)->h.first_byte), 1, - ieee->w.r.me_record + 1, abfd); - - ieee_slurp_sections (abfd); - - if (! ieee_slurp_debug (abfd)) - goto fail; - - /* Parse section data to activate file and section flags implied by - section contents. */ - - if (! ieee_slurp_section_data (abfd)) - goto fail; - - return abfd->xvec; -got_wrong_format: - bfd_set_error (bfd_error_wrong_format); -fail: - (void) bfd_release (abfd, ieee); - abfd->tdata.ieee_data = save; - return (const bfd_target *) NULL; -} - -void -ieee_get_symbol_info (ignore_abfd, symbol, ret) - bfd *ignore_abfd ATTRIBUTE_UNUSED; - asymbol *symbol; - symbol_info *ret; -{ - bfd_symbol_info (symbol, ret); - if (symbol->name[0] == ' ') - ret->name = "* empty table entry "; - if (!symbol->section) - ret->type = (symbol->flags & BSF_LOCAL) ? 'a' : 'A'; -} - -void -ieee_print_symbol (ignore_abfd, afile, symbol, how) - bfd *ignore_abfd ATTRIBUTE_UNUSED; - PTR afile; - asymbol *symbol; - bfd_print_symbol_type how; -{ - FILE *file = (FILE *) afile; - - switch (how) - { - case bfd_print_symbol_name: - fprintf (file, "%s", symbol->name); - break; - case bfd_print_symbol_more: -#if 0 - fprintf (file, "%4x %2x", aout_symbol (symbol)->desc & 0xffff, - aout_symbol (symbol)->other & 0xff); -#endif - BFD_FAIL (); - break; - case bfd_print_symbol_all: - { - 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); - - fprintf (file, " %-5s %04x %02x %s", - section_name, - (unsigned) ieee_symbol (symbol)->index, - (unsigned) 0, - symbol->name); - } - } - break; - } -} - -static boolean -do_one (ieee, current_map, location_ptr, s, iterations) - ieee_data_type *ieee; - ieee_per_section_type *current_map; - unsigned char *location_ptr; - asection *s; - int iterations; -{ - switch (this_byte (&(ieee->h))) - { - case ieee_load_constant_bytes_enum: - { - unsigned int number_of_maus; - unsigned int i; - next_byte (&(ieee->h)); - number_of_maus = must_parse_int (&(ieee->h)); - - for (i = 0; i < number_of_maus; i++) - { - location_ptr[current_map->pc++] = this_byte (&(ieee->h)); - next_byte (&(ieee->h)); - } - } - break; - - case ieee_load_with_relocation_enum: - { - boolean loop = true; - next_byte (&(ieee->h)); - while (loop) - { - switch (this_byte (&(ieee->h))) - { - case ieee_variable_R_enum: + next_byte (&(ieee->h)); + while (loop) + { + switch (this_byte (&(ieee->h))) + { + case ieee_variable_R_enum: case ieee_function_signed_open_b_enum: case ieee_function_unsigned_open_b_enum: case ieee_function_either_open_b_enum: { unsigned int extra = 4; - boolean pcrel = false; + bfd_boolean pcrel = FALSE; asection *section; - ieee_reloc_type *r = - (ieee_reloc_type *) bfd_alloc (ieee->h.abfd, - sizeof (ieee_reloc_type)); + ieee_reloc_type *r; + + r = bfd_alloc (ieee->h.abfd, sizeof (* r)); if (!r) - return false; + return FALSE; *(current_map->reloc_tail_ptr) = r; current_map->reloc_tail_ptr = &r->next; @@ -1795,7 +1522,7 @@ do_one (ieee, current_map, location_ptr, s, iterations) if (this_byte (&(ieee->h)) == (int) ieee_comma) { next_byte (&(ieee->h)); - /* Fetch number of bytes to pad */ + /* Fetch number of bytes to pad. */ extra = must_parse_int (&(ieee->h)); }; @@ -1813,7 +1540,7 @@ do_one (ieee, current_map, location_ptr, s, iterations) default: break; } - /* Build a relocation entry for this type */ + /* Build a relocation entry for this type. */ /* If pc rel then stick -ve pc into instruction and take out of reloc .. @@ -1825,51 +1552,53 @@ do_one (ieee, current_map, location_ptr, s, iterations) case 0: case 4: - if (pcrel == true) + if (pcrel) { #if KEEPMINUSPCININST - bfd_put_32 (ieee->h.abfd, -current_map->pc, location_ptr + - current_map->pc); + 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 + + bfd_put_32 (ieee->h.abfd, (bfd_vma) 0, location_ptr + current_map->pc); r->relent.howto = &rel32_howto; #endif } else { - bfd_put_32 (ieee->h.abfd, 0, location_ptr + - current_map->pc); + bfd_put_32 (ieee->h.abfd, (bfd_vma) 0, + location_ptr + current_map->pc); r->relent.howto = &abs32_howto; } current_map->pc += 4; break; case 2: - if (pcrel == true) + if (pcrel) { #if KEEPMINUSPCININST - bfd_put_16 (ieee->h.abfd, (int) (-current_map->pc), location_ptr + current_map->pc); + bfd_put_16 (ieee->h.abfd, (bfd_vma) -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); + bfd_put_16 (ieee->h.abfd, (bfd_vma) 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); + bfd_put_16 (ieee->h.abfd, (bfd_vma) 0, + location_ptr + current_map->pc); r->relent.howto = &abs16_howto; } current_map->pc += 2; break; case 1: - if (pcrel == true) + if (pcrel) { #if KEEPMINUSPCININST bfd_put_8 (ieee->h.abfd, (int) (-current_map->pc), location_ptr + current_map->pc); @@ -1890,16 +1619,18 @@ do_one (ieee, current_map, location_ptr, s, iterations) default: BFD_FAIL (); - return false; + return FALSE; } } break; default: { bfd_vma this_size; - if (parse_int (&(ieee->h), &this_size) == true) + + if (parse_int (&(ieee->h), &this_size)) { unsigned int i; + for (i = 0; i < this_size; i++) { location_ptr[current_map->pc++] = this_byte (&(ieee->h)); @@ -1907,72 +1638,70 @@ do_one (ieee, current_map, location_ptr, s, iterations) } } else - { - loop = false; - } + loop = FALSE; } } /* Prevent more than the first load-item of an LR record - from being repeated (MRI convention). */ + from being repeated (MRI convention). */ if (iterations != 1) - loop = false; + loop = FALSE; } } } - return true; + return TRUE; } -/* Read in all the section data and relocation stuff too */ -static boolean -ieee_slurp_section_data (abfd) - bfd *abfd; +/* Read in all the section data and relocation stuff too. */ + +static bfd_boolean +ieee_slurp_section_data (bfd *abfd) { 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 *) NULL; + ieee_per_section_type *current_map = NULL; asection *s; - /* Seek to the start of the data area */ - if (ieee->read_data == true) - return true; - ieee->read_data = true; - ieee_seek (abfd, ieee->w.r.data_part); - - /* Allocate enough space for all the section contents */ + + /* Seek to the start of the data area. */ + if (ieee->read_data) + return TRUE; + ieee->read_data = TRUE; + ieee_seek (ieee, ieee->w.r.data_part); + /* Allocate enough space for all the section contents. */ for (s = abfd->sections; s != (asection *) NULL; s = s->next) { - ieee_per_section_type *per = (ieee_per_section_type *) s->used_by_bfd; + ieee_per_section_type *per = ieee_per_section (s); + arelent **relpp; + if ((s->flags & SEC_DEBUGGING) != 0) continue; - per->data = (bfd_byte *) bfd_alloc (ieee->h.abfd, s->_raw_size); + per->data = bfd_alloc (ieee->h.abfd, s->size); if (!per->data) - return false; - /*SUPPRESS 68*/ - per->reloc_tail_ptr = - (ieee_reloc_type **) & (s->relocation); + return FALSE; + relpp = &s->relocation; + per->reloc_tail_ptr = (ieee_reloc_type **) relpp; } - while (true) + while (TRUE) { switch (this_byte (&(ieee->h))) { - /* IF we see anything strange then quit */ + /* IF we see anything strange then quit. */ default: - return true; + return TRUE; case ieee_set_current_section_enum: next_byte (&(ieee->h)); section_number = must_parse_int (&(ieee->h)); s = ieee->section_table[section_number]; s->flags |= SEC_LOAD | SEC_HAS_CONTENTS; - current_map = (ieee_per_section_type *) s->used_by_bfd; + current_map = ieee_per_section (s); location_ptr = current_map->data - s->vma; - /* The document I have says that Microtec's compilers reset */ - /* this after a sec section, even though the standard says not */ - /* to. SO .. */ + /* The document I have says that Microtec's compilers reset + this after a sec section, even though the standard says not + to, SO... */ current_map->pc = s->vma; break; @@ -1985,15 +1714,16 @@ ieee_slurp_section_data (abfd) bfd_vma value; ieee_symbol_index_type symbol; unsigned int extra; - boolean pcrel; + bfd_boolean pcrel; + next_byte (&(ieee->h)); - must_parse_int (&(ieee->h)); /* Thow away section #*/ + must_parse_int (&(ieee->h)); /* Throw away section #. */ parse_expression (ieee, &value, &symbol, &pcrel, &extra, 0); current_map->pc = value; - BFD_ASSERT ((unsigned) (value - s->vma) <= s->_raw_size); + BFD_ASSERT ((unsigned) (value - s->vma) <= s->size); } break; @@ -2002,28 +1732,27 @@ ieee_slurp_section_data (abfd) if (this_byte (&(ieee->h)) == ieee_function_either_open_b_enum) next_byte (&(ieee->h)); abfd->start_address = must_parse_int (&(ieee->h)); - /* We've got to the end of the data now - */ - return true; + /* We've got to the end of the data now - */ + return TRUE; default: BFD_FAIL (); - return false; + return FALSE; } break; case ieee_repeat_data_enum: { /* Repeat the following LD or LR n times - we do this by - remembering the stream pointer before running it and - resetting it and running it n times. We special case - the repetition of a repeat_data/load_constant - */ - + remembering the stream pointer before running it and + resetting it and running it n times. We special case + the repetition of a repeat_data/load_constant. */ unsigned int iterations; unsigned char *start; + next_byte (&(ieee->h)); iterations = must_parse_int (&(ieee->h)); start = ieee->h.input_p; - if (start[0] == (int) ieee_load_constant_bytes_enum && - start[1] == 1) + if (start[0] == (int) ieee_load_constant_bytes_enum + && start[1] == 1) { while (iterations != 0) { @@ -2040,8 +1769,8 @@ ieee_slurp_section_data (abfd) { ieee->h.input_p = start; if (!do_one (ieee, current_map, location_ptr, s, - iterations)) - return false; + (int) iterations)) + return FALSE; iterations--; } } @@ -2049,32 +1778,262 @@ ieee_slurp_section_data (abfd) break; case ieee_load_constant_bytes_enum: case ieee_load_with_relocation_enum: + if (!do_one (ieee, current_map, location_ptr, s, 1)) + return FALSE; + } + } +} + +static const bfd_target * +ieee_object_p (bfd *abfd) +{ + char *processor; + unsigned int part; + ieee_data_type *ieee; + unsigned char buffer[300]; + ieee_data_type *save = IEEE_DATA (abfd); + bfd_size_type amt; + + abfd->tdata.ieee_data = 0; + ieee_mkobject (abfd); + + ieee = IEEE_DATA (abfd); + if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) + goto fail; + /* Read the first few bytes in to see if it makes sense. Ignore + bfd_bread return value; The file might be very small. */ + bfd_bread ((void *) buffer, (bfd_size_type) sizeof (buffer), abfd); + + ieee->h.input_p = buffer; + if (this_byte_and_next (&(ieee->h)) != Module_Beginning) + goto got_wrong_format; + + ieee->read_symbols = FALSE; + ieee->read_data = FALSE; + ieee->section_count = 0; + ieee->external_symbol_max_index = 0; + ieee->external_symbol_min_index = IEEE_PUBLIC_BASE; + ieee->external_reference_min_index = IEEE_REFERENCE_BASE; + ieee->external_reference_max_index = 0; + ieee->h.abfd = abfd; + ieee->section_table = NULL; + ieee->section_table_size = 0; + + processor = ieee->mb.processor = read_id (&(ieee->h)); + if (strcmp (processor, "LIBRARY") == 0) + goto got_wrong_format; + ieee->mb.module_name = read_id (&(ieee->h)); + if (abfd->filename == (const char *) NULL) + abfd->filename = ieee->mb.module_name; + + /* Determine the architecture and machine type of the object file. */ + { + const bfd_arch_info_type *arch; + char family[10]; + + /* IEEE does not specify the format of the processor identification + string, so the compiler is free to put in it whatever it wants. + We try here to recognize different processors belonging to the + m68k family. Code for other processors can be added here. */ + if ((processor[0] == '6') && (processor[1] == '8')) + { + if (processor[2] == '3') /* 683xx integrated processors. */ + { + switch (processor[3]) + { + case '0': /* 68302, 68306, 68307 */ + case '2': /* 68322, 68328 */ + case '5': /* 68356 */ + strcpy (family, "68000"); /* MC68000-based controllers. */ + break; + + case '3': /* 68330, 68331, 68332, 68333, + 68334, 68335, 68336, 68338 */ + case '6': /* 68360 */ + case '7': /* 68376 */ + strcpy (family, "68332"); /* CPU32 and CPU32+ */ + break; + + case '4': + if (processor[4] == '9') /* 68349 */ + strcpy (family, "68030"); /* CPU030 */ + else /* 68340, 68341 */ + strcpy (family, "68332"); /* CPU32 and CPU32+ */ + break; + + default: /* Does not exist yet. */ + strcpy (family, "68332"); /* Guess it will be CPU32 */ + } + } + else if (TOUPPER (processor[3]) == 'F') /* 68F333 */ + strcpy (family, "68332"); /* CPU32 */ + else if ((TOUPPER (processor[3]) == 'C') /* Embedded controllers. */ + && ((TOUPPER (processor[2]) == 'E') + || (TOUPPER (processor[2]) == 'H') + || (TOUPPER (processor[2]) == 'L'))) + { + strcpy (family, "68"); + strncat (family, processor + 4, 7); + family[9] = '\0'; + } + else /* "Regular" processors. */ + { + strncpy (family, processor, 9); + family[9] = '\0'; + } + } + else if ((CONST_STRNEQ (processor, "cpu32")) /* CPU32 and CPU32+ */ + || (CONST_STRNEQ (processor, "CPU32"))) + strcpy (family, "68332"); + else + { + strncpy (family, processor, 9); + family[9] = '\0'; + } + + arch = bfd_scan_arch (family); + if (arch == 0) + goto got_wrong_format; + abfd->arch_info = arch; + } + + if (this_byte (&(ieee->h)) != (int) ieee_address_descriptor_enum) + goto fail; + + next_byte (&(ieee->h)); + + if (! parse_int (&(ieee->h), &ieee->ad.number_of_bits_mau)) + goto fail; + + if (! parse_int (&(ieee->h), &ieee->ad.number_of_maus_in_address)) + goto fail; + + /* If there is a byte order info, take it. */ + 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++) + { + bfd_boolean ok; + + if (read_2bytes (&(ieee->h)) != (int) ieee_assign_value_to_variable_enum) + goto fail; + + if (this_byte_and_next (&(ieee->h)) != part) + goto fail; + + ieee->w.offset[part] = parse_i (&(ieee->h), &ok); + if (! ok) + goto fail; + } + + if (ieee->w.r.external_part != 0) + abfd->flags = HAS_SYMS; + + /* By now we know that this is a real IEEE file, we're going to read + the whole thing into memory so that we can run up and down it + quickly. We can work out how big the file is from the trailer + record. */ + + amt = ieee->w.r.me_record + 1; + IEEE_DATA (abfd)->h.first_byte = bfd_alloc (ieee->h.abfd, amt); + if (!IEEE_DATA (abfd)->h.first_byte) + goto fail; + if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) + goto fail; + /* FIXME: Check return value. I'm not sure whether it needs to read + the entire buffer or not. */ + bfd_bread ((void *) (IEEE_DATA (abfd)->h.first_byte), + (bfd_size_type) ieee->w.r.me_record + 1, abfd); + + ieee_slurp_sections (abfd); + + if (! ieee_slurp_debug (abfd)) + goto fail; + + /* Parse section data to activate file and section flags implied by + section contents. */ + if (! ieee_slurp_section_data (abfd)) + goto fail; + + return abfd->xvec; +got_wrong_format: + bfd_set_error (bfd_error_wrong_format); +fail: + bfd_release (abfd, ieee); + abfd->tdata.ieee_data = save; + return (const bfd_target *) NULL; +} + +static void +ieee_get_symbol_info (bfd *ignore_abfd ATTRIBUTE_UNUSED, + asymbol *symbol, + symbol_info *ret) +{ + bfd_symbol_info (symbol, ret); + if (symbol->name[0] == ' ') + ret->name = "* empty table entry "; + if (!symbol->section) + ret->type = (symbol->flags & BSF_LOCAL) ? 'a' : 'A'; +} + +static void +ieee_print_symbol (bfd *abfd, + void * afile, + asymbol *symbol, + bfd_print_symbol_type how) +{ + FILE *file = (FILE *) afile; + + switch (how) + { + case bfd_print_symbol_name: + fprintf (file, "%s", symbol->name); + break; + case bfd_print_symbol_more: + BFD_FAIL (); + break; + case bfd_print_symbol_all: + { + const char *section_name = + (symbol->section == (asection *) NULL + ? "*abs" + : symbol->section->name); + + if (symbol->name[0] == ' ') + fprintf (file, "* empty table entry "); + else { - if (!do_one (ieee, current_map, location_ptr, s, 1)) - return false; + bfd_print_symbol_vandf (abfd, (void *) file, symbol); + + fprintf (file, " %-5s %04x %02x %s", + section_name, + (unsigned) ieee_symbol (symbol)->index, + (unsigned) 0, + symbol->name); } - } + } + break; } } -boolean -ieee_new_section_hook (abfd, newsect) - bfd *abfd; - asection *newsect; +static bfd_boolean +ieee_new_section_hook (bfd *abfd, asection *newsect) { - newsect->used_by_bfd = (PTR) - bfd_alloc (abfd, sizeof (ieee_per_section_type)); if (!newsect->used_by_bfd) - return false; - ieee_per_section (newsect)->data = (bfd_byte *) NULL; + { + newsect->used_by_bfd = bfd_alloc (abfd, sizeof (ieee_per_section_type)); + if (!newsect->used_by_bfd) + return FALSE; + } + ieee_per_section (newsect)->data = NULL; ieee_per_section (newsect)->section = newsect; - return true; + return _bfd_generic_new_section_hook (abfd, newsect); } -long -ieee_get_reloc_upper_bound (abfd, asect) - bfd *abfd; - sec_ptr asect; +static long +ieee_get_reloc_upper_bound (bfd *abfd, sec_ptr asect) { if ((asect->flags & SEC_DEBUGGING) != 0) return 0; @@ -2083,31 +2042,28 @@ ieee_get_reloc_upper_bound (abfd, asect) return (asect->reloc_count + 1) * sizeof (arelent *); } -static boolean -ieee_get_section_contents (abfd, section, location, offset, count) - bfd *abfd; - sec_ptr section; - PTR location; - file_ptr offset; - bfd_size_type count; +static bfd_boolean +ieee_get_section_contents (bfd *abfd, + sec_ptr section, + void * location, + file_ptr offset, + bfd_size_type count) { - ieee_per_section_type *p = (ieee_per_section_type *) section->used_by_bfd; + ieee_per_section_type *p = ieee_per_section (section); if ((section->flags & SEC_DEBUGGING) != 0) return _bfd_generic_get_section_contents (abfd, section, location, offset, count); ieee_slurp_section_data (abfd); - (void) memcpy ((PTR) location, (PTR) (p->data + offset), (unsigned) count); - return true; + (void) memcpy ((void *) location, (void *) (p->data + offset), (unsigned) count); + return TRUE; } -long -ieee_canonicalize_reloc (abfd, section, relptr, symbols) - bfd *abfd; - sec_ptr section; - arelent **relptr; - asymbol **symbols; +static long +ieee_canonicalize_reloc (bfd *abfd, + sec_ptr section, + arelent **relptr, + asymbol **symbols) { -/* 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); @@ -2116,7 +2072,7 @@ ieee_canonicalize_reloc (abfd, section, relptr, symbols) while (src != (ieee_reloc_type *) NULL) { - /* Work out which symbol to attach it this reloc to */ + /* Work out which symbol to attach it this reloc to. */ switch (src->symbol.letter) { case 'I': @@ -2139,14 +2095,12 @@ ieee_canonicalize_reloc (abfd, section, relptr, symbols) *relptr++ = &src->relent; src = src->next; } - *relptr = (arelent *) NULL; + *relptr = NULL; return section->reloc_count; } static int -comp (ap, bp) - CONST PTR ap; - CONST PTR bp; +comp (const void * ap, const void * bp) { arelent *a = *((arelent **) ap); arelent *b = *((arelent **) bp); @@ -2155,12 +2109,12 @@ comp (ap, bp) /* Write the section headers. */ -static boolean -ieee_write_section_part (abfd) - bfd *abfd; +static bfd_boolean +ieee_write_section_part (bfd *abfd) { ieee_data_type *ieee = IEEE_DATA (abfd); asection *s; + ieee->w.r.section_part = bfd_tell (abfd); for (s = abfd->sections; s != (asection *) NULL; s = s->next) { @@ -2171,19 +2125,19 @@ ieee_write_section_part (abfd) || ! ieee_write_byte (abfd, (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE))) - return false; + return FALSE; if (abfd->flags & EXEC_P) { - /* This image is executable, so output absolute sections */ + /* This image is executable, so output absolute sections. */ if (! ieee_write_byte (abfd, ieee_variable_A_enum) || ! ieee_write_byte (abfd, ieee_variable_S_enum)) - return false; + return FALSE; } else { if (! ieee_write_byte (abfd, ieee_variable_C_enum)) - return false; + return FALSE; } switch (s->flags & (SEC_CODE | SEC_DATA | SEC_ROM)) @@ -2191,67 +2145,59 @@ ieee_write_section_part (abfd) case SEC_CODE | SEC_LOAD: case SEC_CODE: if (! ieee_write_byte (abfd, ieee_variable_P_enum)) - return false; + return FALSE; break; case SEC_DATA: default: if (! ieee_write_byte (abfd, ieee_variable_D_enum)) - return false; + return FALSE; break; case SEC_ROM: case SEC_ROM | SEC_DATA: case SEC_ROM | SEC_LOAD: case SEC_ROM | SEC_DATA | SEC_LOAD: if (! ieee_write_byte (abfd, ieee_variable_R_enum)) - return false; + return FALSE; } if (! ieee_write_id (abfd, s->name)) - return false; -#if 0 - ieee_write_int (abfd, 0); /* Parent */ - ieee_write_int (abfd, 0); /* Brother */ - ieee_write_int (abfd, 0); /* Context */ -#endif - /* Alignment */ + return FALSE; + /* Alignment. */ if (! ieee_write_byte (abfd, ieee_section_alignment_enum) || ! ieee_write_byte (abfd, (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE)) - || ! ieee_write_int (abfd, 1 << s->alignment_power)) - return false; + || ! ieee_write_int (abfd, (bfd_vma) 1 << s->alignment_power)) + return FALSE; - /* Size */ + /* Size. */ if (! ieee_write_2bytes (abfd, ieee_section_size_enum) || ! ieee_write_byte (abfd, (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE)) - || ! ieee_write_int (abfd, s->_raw_size)) - return false; + || ! ieee_write_int (abfd, s->size)) + return FALSE; if (abfd->flags & EXEC_P) { - /* Relocateable sections don't have asl records */ - /* Vma */ + /* Relocateable sections don't have asl records. */ + /* Vma. */ if (! ieee_write_2bytes (abfd, ieee_section_base_address_enum) || ! ieee_write_byte (abfd, ((bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE))) || ! ieee_write_int (abfd, s->lma)) - return false; + return FALSE; } } } - return true; + return TRUE; } - -static boolean -do_with_relocs (abfd, s) - bfd *abfd; - asection *s; +static bfd_boolean +do_with_relocs (bfd *abfd, asection *s) { unsigned int number_of_maus_in_address = bfd_arch_bits_per_address (abfd) / bfd_arch_bits_per_byte (abfd); @@ -2265,53 +2211,49 @@ do_with_relocs (abfd, s) sizeof (arelent **), comp); - /* Output the section preheader */ + /* Output the section preheader. */ if (! ieee_write_byte (abfd, ieee_set_current_section_enum) || ! ieee_write_byte (abfd, (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE)) || ! ieee_write_2bytes (abfd, ieee_set_current_pc_enum) || ! ieee_write_byte (abfd, (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE))) - return false; + return FALSE; + if ((abfd->flags & EXEC_P) != 0 && relocs_to_go == 0) { if (! ieee_write_int (abfd, s->lma)) - return false; + return FALSE; } else { - if (! ieee_write_expression (abfd, 0, s->symbol, 0, 0)) - return false; + if (! ieee_write_expression (abfd, (bfd_vma) 0, s->symbol, 0, 0)) + return FALSE; } if (relocs_to_go == 0) { /* If there aren't any relocations then output the load constant - byte opcode rather than the load with relocation opcode */ - - while (current_byte_index < s->_raw_size) + byte opcode rather than the load with relocation opcode. */ + while (current_byte_index < s->size) { bfd_size_type run; unsigned int MAXRUN = 127; + run = MAXRUN; - if (run > s->_raw_size - current_byte_index) - { - run = s->_raw_size - current_byte_index; - } + if (run > s->size - current_byte_index) + run = s->size - current_byte_index; if (run != 0) { if (! ieee_write_byte (abfd, ieee_load_constant_bytes_enum)) - return false; - /* Output a stream of bytes */ + return FALSE; + /* Output a stream of bytes. */ if (! ieee_write_int (abfd, run)) - return false; - if (bfd_write ((PTR) (stream + current_byte_index), - 1, - run, - abfd) + return FALSE; + if (bfd_bwrite ((void *) (stream + current_byte_index), run, abfd) != run) - return false; + return FALSE; current_byte_index += run; } } @@ -2319,24 +2261,23 @@ do_with_relocs (abfd, s) else { if (! ieee_write_byte (abfd, ieee_load_with_relocation_enum)) - return false; + return FALSE; /* 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) + if (stream == NULL) { - /* Outputting a section without data, fill it up */ - stream = (unsigned char *) (bfd_alloc (abfd, s->_raw_size)); + /* Outputting a section without data, fill it up. */ + stream = bfd_zalloc (abfd, s->size); if (!stream) - return false; - memset ((PTR) stream, 0, (size_t) s->_raw_size); + return FALSE; } - while (current_byte_index < s->_raw_size) + while (current_byte_index < s->size) { bfd_size_type run; unsigned int MAXRUN = 127; + if (relocs_to_go) { run = (*p)->address - current_byte_index; @@ -2344,28 +2285,23 @@ do_with_relocs (abfd, s) run = MAXRUN; } else - { - run = MAXRUN; - } - if (run > s->_raw_size - current_byte_index) - { - run = s->_raw_size - current_byte_index; - } + run = MAXRUN; + + if (run > s->size - current_byte_index) + run = s->size - current_byte_index; if (run != 0) { - /* Output a stream of bytes */ + /* Output a stream of bytes. */ if (! ieee_write_int (abfd, run)) - return false; - if (bfd_write ((PTR) (stream + current_byte_index), - 1, - run, - abfd) + return FALSE; + if (bfd_bwrite ((void *) (stream + current_byte_index), run, abfd) != run) - return false; + return FALSE; current_byte_index += run; } - /* Output any relocations here */ + + /* Output any relocations here. */ if (relocs_to_go && (*p) && (*p)->address == current_byte_index) { while (relocs_to_go @@ -2373,18 +2309,9 @@ do_with_relocs (abfd, s) { arelent *r = *p; bfd_signed_vma ov; - -#if 0 - if (r->howto->pc_relative) - { - r->addend += current_byte_index; - } -#endif - switch (r->howto->size) { case 2: - ov = bfd_get_signed_32 (abfd, stream + current_byte_index); current_byte_index += 4; @@ -2402,7 +2329,7 @@ do_with_relocs (abfd, s) default: ov = 0; BFD_FAIL (); - return false; + return FALSE; } ov &= r->howto->src_mask; @@ -2413,37 +2340,35 @@ do_with_relocs (abfd, s) if (! ieee_write_byte (abfd, ieee_function_either_open_b_enum)) - return false; - -/* abort();*/ + return FALSE; if (r->sym_ptr_ptr != (asymbol **) NULL) { if (! ieee_write_expression (abfd, r->addend + ov, *(r->sym_ptr_ptr), r->howto->pc_relative, - s->index)) - return false; + (unsigned) s->index)) + return FALSE; } else { if (! ieee_write_expression (abfd, r->addend + ov, (asymbol *) NULL, r->howto->pc_relative, - s->index)) - return false; + (unsigned) s->index)) + return FALSE; } if (number_of_maus_in_address != bfd_get_reloc_size (r->howto)) { - if (! ieee_write_int (abfd, - bfd_get_reloc_size (r->howto))) - return false; + bfd_vma rsize = bfd_get_reloc_size (r->howto); + if (! ieee_write_int (abfd, rsize)) + return FALSE; } if (! ieee_write_byte (abfd, ieee_function_either_close_b_enum)) - return false; + return FALSE; relocs_to_go--; p++; @@ -2453,19 +2378,17 @@ do_with_relocs (abfd, s) } } - return true; + return TRUE; } /* If there are no relocations in the output section then we can be clever about how we write. We block items up into a max of 127 bytes. */ -static boolean -do_as_repeat (abfd, s) - bfd *abfd; - asection *s; +static bfd_boolean +do_as_repeat (bfd *abfd, asection *s) { - if (s->_raw_size) + if (s->size) { if (! ieee_write_byte (abfd, ieee_set_current_section_enum) || ! ieee_write_byte (abfd, @@ -2475,87 +2398,88 @@ do_as_repeat (abfd, s) || ! ieee_write_byte (abfd, ieee_set_current_pc_enum & 0xff) || ! ieee_write_byte (abfd, (bfd_byte) (s->index - + IEEE_SECTION_NUMBER_BASE)) - || ! ieee_write_int (abfd, s->lma) - || ! ieee_write_byte (abfd, ieee_repeat_data_enum) - || ! ieee_write_int (abfd, s->_raw_size) + + IEEE_SECTION_NUMBER_BASE))) + return FALSE; + + if ((abfd->flags & EXEC_P) != 0) + { + if (! ieee_write_int (abfd, s->lma)) + return FALSE; + } + else + { + if (! ieee_write_expression (abfd, (bfd_vma) 0, s->symbol, 0, 0)) + return FALSE; + } + + if (! ieee_write_byte (abfd, ieee_repeat_data_enum) + || ! ieee_write_int (abfd, s->size) || ! ieee_write_byte (abfd, ieee_load_constant_bytes_enum) || ! ieee_write_byte (abfd, 1) || ! ieee_write_byte (abfd, 0)) - return false; + return FALSE; } - return true; + return TRUE; } -static boolean -do_without_relocs (abfd, s) - bfd *abfd; - asection *s; +static bfd_boolean +do_without_relocs (bfd *abfd, asection *s) { bfd_byte *stream = ieee_per_section (s)->data; if (stream == 0 || ((s->flags & SEC_LOAD) == 0)) { if (! do_as_repeat (abfd, s)) - return false; + return FALSE; } else { unsigned int i; - for (i = 0; i < s->_raw_size; i++) + + for (i = 0; i < s->size; i++) { if (stream[i] != 0) { if (! do_with_relocs (abfd, s)) - return false; - return true; + return FALSE; + return TRUE; } } if (! do_as_repeat (abfd, s)) - return false; + return FALSE; } - return true; + return TRUE; } - -static unsigned char *output_ptr_start; -static unsigned char *output_ptr; -static unsigned char *output_ptr_end; -static unsigned char *input_ptr_start; -static unsigned char *input_ptr; -static unsigned char *input_ptr_end; -static bfd *input_bfd; -static bfd *output_bfd; -static int output_buffer; - static void -fill () +fill (void) { + bfd_size_type amt = input_ptr_end - input_ptr_start; /* FIXME: Check return value. I'm not sure whether it needs to read the entire buffer or not. */ - bfd_read ((PTR) input_ptr_start, 1, input_ptr_end - input_ptr_start, input_bfd); + bfd_bread ((void *) input_ptr_start, amt, input_bfd); input_ptr = input_ptr_start; } + static void -flush () +flush (void) { - if (bfd_write ((PTR) (output_ptr_start), 1, output_ptr - output_ptr_start, - output_bfd) - != (bfd_size_type) (output_ptr - output_ptr_start)) + bfd_size_type amt = output_ptr - output_ptr_start; + + if (bfd_bwrite ((void *) (output_ptr_start), amt, output_bfd) != amt) abort (); output_ptr = output_ptr_start; output_buffer++; } #define THIS() ( *input_ptr ) -#define NEXT() { input_ptr++; if (input_ptr == input_ptr_end) fill(); } -#define OUT(x) { *output_ptr++ = (x); if(output_ptr == output_ptr_end) flush(); } +#define NEXT() { input_ptr++; if (input_ptr == input_ptr_end) fill (); } +#define OUT(x) { *output_ptr++ = (x); if (output_ptr == output_ptr_end) flush (); } static void -write_int (value) - int value; +write_int (int value) { if (value >= 0 && value <= 127) { @@ -2564,20 +2488,15 @@ write_int (value) else { unsigned int length; - /* How many significant bytes ? */ - /* FIXME FOR LONGER INTS */ + + /* How many significant bytes ? */ + /* FIXME FOR LONGER INTS. */ if (value & 0xff000000) - { - length = 4; - } + length = 4; else if (value & 0x00ff0000) - { - length = 3; - } + length = 3; else if (value & 0x0000ff00) - { - length = 2; - } + length = 2; else length = 1; @@ -2593,15 +2512,15 @@ write_int (value) case 1: OUT (value); } - } } static void -copy_id () +copy_id (void) { int length = THIS (); char ch; + OUT (length); NEXT (); while (length--) @@ -2614,11 +2533,12 @@ copy_id () #define VAR(x) ((x | 0x80)) static void -copy_expression () +copy_expression (void) { int stack[10]; int *tos = stack; - int value = 0; + int value; + while (1) { switch (THIS ()) @@ -2666,45 +2586,37 @@ copy_expression () default: if (THIS () > 0x84) { - /* Not a number, just bug out with the answer */ + /* Not a number, just bug out with the answer. */ write_int (*(--tos)); return; } *tos++ = THIS (); NEXT (); - value = 0; break; case 0xa5: - /* PLUS anything */ - { - int value = *(--tos); - value += *(--tos); - *tos++ = value; - NEXT (); - } + /* PLUS anything. */ + value = *(--tos); + value += *(--tos); + *tos++ = value; + NEXT (); break; case VAR ('R'): { int section_number; ieee_data_type *ieee; asection *s; + NEXT (); section_number = THIS (); NEXT (); ieee = IEEE_DATA (input_bfd); s = ieee->section_table[section_number]; + value = 0; if (s->output_section) - { - value = s->output_section->lma; - } - else - { - value = 0; - } + value = s->output_section->lma; value += s->output_offset; *tos++ = value; - value = 0; } break; case 0x90: @@ -2713,29 +2625,20 @@ copy_expression () write_int (*(--tos)); OUT (0x90); return; - } } } - } /* Drop the int in the buffer, and copy a null into the gap, which we - will overwrite later */ - -struct output_buffer_struct -{ - unsigned char *ptrp; - int buffer; -}; + will overwrite later. */ static void -fill_int (buf) - struct output_buffer_struct *buf; +fill_int (struct output_buffer_struct *buf) { if (buf->buffer == output_buffer) { - /* Still a chance to output the size */ + /* Still a chance to output the size. */ int value = output_ptr - buf->ptrp + 3; buf->ptrp[0] = value >> 24; buf->ptrp[1] = value >> 16; @@ -2745,11 +2648,11 @@ fill_int (buf) } static void -drop_int (buf) - struct output_buffer_struct *buf; +drop_int (struct output_buffer_struct *buf) { int type = THIS (); int ch; + if (type <= 0x84) { NEXT (); @@ -2771,6 +2674,7 @@ drop_int (buf) break; } } + (void) ch; OUT (0x84); buf->ptrp = output_ptr; buf->buffer = output_buffer; @@ -2781,7 +2685,7 @@ drop_int (buf) } static void -copy_int () +copy_int (void) { int type = THIS (); int ch; @@ -2813,18 +2717,57 @@ copy_int () } } -#define ID copy_id() -#define INT copy_int() -#define EXP copy_expression() -static void copy_till_end (); -#define INTn(q) copy_int() -#define EXPn(q) copy_expression() +#define ID copy_id () +#define INT copy_int () +#define EXP copy_expression () +#define INTn(q) copy_int () +#define EXPn(q) copy_expression () + +static void +copy_till_end (void) +{ + int ch = THIS (); + + while (1) + { + while (ch <= 0x80) + { + OUT (ch); + NEXT (); + ch = THIS (); + } + switch (ch) + { + case 0x84: + OUT (THIS ()); + NEXT (); + case 0x83: + OUT (THIS ()); + NEXT (); + case 0x82: + OUT (THIS ()); + NEXT (); + case 0x81: + OUT (THIS ()); + NEXT (); + OUT (THIS ()); + NEXT (); + + ch = THIS (); + break; + default: + return; + } + } + +} static void -f1_record () +f1_record (void) { int ch; - /* ATN record */ + + /* ATN record. */ NEXT (); ch = THIS (); switch (ch) @@ -2864,7 +2807,7 @@ f1_record () } break; case 0xd8: - /* EXternal ref */ + /* EXternal ref. */ NEXT (); OUT (0xf1); OUT (0xd8); @@ -2918,13 +2861,12 @@ f1_record () break; } } - } static void -f0_record () +f0_record (void) { - /* Attribute record */ + /* Attribute record. */ NEXT (); OUT (0xf0); INTn (Symbol name); @@ -2932,45 +2874,7 @@ f0_record () } static void -copy_till_end () -{ - int ch = THIS (); - while (1) - { - while (ch <= 0x80) - { - OUT (ch); - NEXT (); - ch = THIS (); - } - switch (ch) - { - case 0x84: - OUT (THIS ()); - NEXT (); - case 0x83: - OUT (THIS ()); - NEXT (); - case 0x82: - OUT (THIS ()); - NEXT (); - case 0x81: - OUT (THIS ()); - NEXT (); - OUT (THIS ()); - NEXT (); - - ch = THIS (); - break; - default: - return; - } - } - -} - -static void -f2_record () +f2_record (void) { NEXT (); OUT (0xf2); @@ -2981,10 +2885,8 @@ f2_record () copy_till_end (); } - -static void block (); static void -f8_record () +f8_record (void) { int ch; NEXT (); @@ -2994,11 +2896,12 @@ f8_record () case 0x01: case 0x02: case 0x03: - /* Unique typedefs for module */ - /* GLobal typedefs */ - /* High level module scope beginning */ + /* Unique typedefs for module. */ + /* GLobal typedefs. */ + /* High level module scope beginning. */ { struct output_buffer_struct ob; + NEXT (); OUT (0xf8); OUT (ch); @@ -3013,9 +2916,10 @@ f8_record () } break; case 0x04: - /* Global function */ + /* Global function. */ { struct output_buffer_struct ob; + NEXT (); OUT (0xf8); OUT (0x04); @@ -3035,9 +2939,10 @@ f8_record () break; case 0x05: - /* File name for source line numbers */ + /* File name for source line numbers. */ { struct output_buffer_struct ob; + NEXT (); OUT (0xf8); OUT (0x05); @@ -3057,9 +2962,10 @@ f8_record () break; case 0x06: - /* Local function */ + /* Local function. */ { struct output_buffer_struct ob; + NEXT (); OUT (0xf8); OUT (0x06); @@ -3077,7 +2983,7 @@ f8_record () break; case 0x0a: - /* Assembler module scope beginning -*/ + /* Assembler module scope beginning - */ { struct output_buffer_struct ob; @@ -3106,6 +3012,7 @@ f8_record () case 0x0b: { struct output_buffer_struct ob; + NEXT (); OUT (0xf8); OUT (0x0b); @@ -3128,7 +3035,7 @@ f8_record () } static void -e2_record () +e2_record (void) { OUT (0xe2); NEXT (); @@ -3139,9 +3046,10 @@ e2_record () } static void -block () +block (void) { int ch; + while (1) { ch = THIS (); @@ -3172,17 +3080,12 @@ block () } } - - -/* relocate_debug, - moves all the debug information from the source bfd to the output - bfd, and relocates any expressions it finds -*/ +/* Moves all the debug information from the source bfd to the output + bfd, and relocates any expressions it finds. */ static void -relocate_debug (output, input) - bfd *output ATTRIBUTE_UNUSED; - bfd *input; +relocate_debug (bfd *output ATTRIBUTE_UNUSED, + bfd *input) { #define IBS 400 #define OBS 400 @@ -3193,26 +3096,25 @@ relocate_debug (output, input) input_bfd = input; /* FIXME: Check return value. I'm not sure whether it needs to read the entire buffer or not. */ - bfd_read ((PTR) input_ptr_start, 1, IBS, input); + bfd_bread ((void *) input_ptr_start, (bfd_size_type) IBS, input); block (); } /* Gather together all the debug information from each input BFD into one place, relocating it and emitting it as we go. */ -static boolean -ieee_write_debug_part (abfd) - bfd *abfd; +static bfd_boolean +ieee_write_debug_part (bfd *abfd) { ieee_data_type *ieee = IEEE_DATA (abfd); bfd_chain_type *chain = ieee->chain_root; - unsigned char output_buffer[OBS]; - boolean some_debug = false; + unsigned char obuff[OBS]; + bfd_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_ptr_start = output_ptr = obuff; + output_ptr_end = obuff + OBS; + output_ptr = obuff; output_bfd = abfd; if (chain == (bfd_chain_type *) NULL) @@ -3225,12 +3127,12 @@ ieee_write_debug_part (abfd) if (s == NULL) { ieee->w.r.debug_information_part = 0; - return true; + return TRUE; } ieee->w.r.debug_information_part = here; - if (bfd_write (s->contents, 1, s->_raw_size, abfd) != s->_raw_size) - return false; + if (bfd_bwrite (s->contents, s->size, abfd) != s->size) + return FALSE; } else { @@ -3238,41 +3140,39 @@ ieee_write_debug_part (abfd) { bfd *entry = chain->this; ieee_data_type *entry_ieee = IEEE_DATA (entry); + if (entry_ieee->w.r.debug_information_part) { if (bfd_seek (entry, entry_ieee->w.r.debug_information_part, - SEEK_SET) - != 0) - return false; + SEEK_SET) != 0) + return FALSE; relocate_debug (abfd, entry); } chain = chain->next; } + if (some_debug) - { - ieee->w.r.debug_information_part = here; - } + ieee->w.r.debug_information_part = here; else - { - ieee->w.r.debug_information_part = 0; - } + ieee->w.r.debug_information_part = 0; flush (); } - return true; + return TRUE; } /* Write the data in an ieee way. */ -static boolean -ieee_write_data_part (abfd) - bfd *abfd; +static bfd_boolean +ieee_write_data_part (bfd *abfd) { asection *s; + ieee_data_type *ieee = IEEE_DATA (abfd); ieee->w.r.data_part = bfd_tell (abfd); + for (s = abfd->sections; s != (asection *) NULL; s = s->next) { /* Skip sections that have no loadable contents (.bss, @@ -3281,79 +3181,78 @@ ieee_write_data_part (abfd) continue; /* Sort the reloc records so we can insert them in the correct - places */ + places. */ if (s->reloc_count != 0) { if (! do_with_relocs (abfd, s)) - return false; + return FALSE; } else { if (! do_without_relocs (abfd, s)) - return false; + return FALSE; } } - return true; + return TRUE; } - -static boolean -init_for_output (abfd) - bfd *abfd; +static bfd_boolean +init_for_output (bfd *abfd) { asection *s; + for (s = abfd->sections; s != (asection *) NULL; s = s->next) { if ((s->flags & SEC_DEBUGGING) != 0) continue; - if (s->_raw_size != 0) + if (s->size != 0) { - ieee_per_section (s)->data = (bfd_byte *) (bfd_alloc (abfd, s->_raw_size)); + bfd_size_type size = s->size; + ieee_per_section (s)->data = bfd_alloc (abfd, size); if (!ieee_per_section (s)->data) - return false; + return FALSE; } } - return true; + return TRUE; } -/** exec and core file sections */ +/* Exec and core file sections. */ -/* set section contents is complicated with IEEE since the format is -* not a byte image, but a record stream. -*/ -boolean -ieee_set_section_contents (abfd, section, location, offset, count) - bfd *abfd; - sec_ptr section; - PTR location; - file_ptr offset; - bfd_size_type count; +/* Set section contents is complicated with IEEE since the format is + not a byte image, but a record stream. */ + +static bfd_boolean +ieee_set_section_contents (bfd *abfd, + sec_ptr section, + const void * location, + file_ptr offset, + bfd_size_type count) { if ((section->flags & SEC_DEBUGGING) != 0) { if (section->contents == NULL) { - section->contents = ((unsigned char *) - bfd_alloc (abfd, section->_raw_size)); + bfd_size_type size = section->size; + section->contents = bfd_alloc (abfd, size); if (section->contents == NULL) - return false; + return FALSE; } /* bfd_set_section_contents has already checked that everything is within range. */ - memcpy (section->contents + offset, location, count); - return true; + memcpy (section->contents + offset, location, (size_t) count); + return TRUE; } if (ieee_per_section (section)->data == (bfd_byte *) NULL) { if (!init_for_output (abfd)) - return false; + return FALSE; } - memcpy ((PTR) (ieee_per_section (section)->data + offset), - (PTR) location, + memcpy ((void *) (ieee_per_section (section)->data + offset), + (void *) location, (unsigned int) count); - return true; + return TRUE; } /* Write the external symbols of a file. IEEE considers two sorts of @@ -3361,79 +3260,78 @@ ieee_set_section_contents (abfd, section, location, offset, count) forms to index them as well. When we write them out we turn their symbol values into indexes from the right base. */ -static boolean -ieee_write_external_part (abfd) - bfd *abfd; +static bfd_boolean +ieee_write_external_part (bfd *abfd) { asymbol **q; ieee_data_type *ieee = IEEE_DATA (abfd); - unsigned int reference_index = IEEE_REFERENCE_BASE; unsigned int public_index = IEEE_PUBLIC_BASE + 2; file_ptr here = bfd_tell (abfd); - boolean hadone = false; + bfd_boolean hadone = FALSE; + if (abfd->outsymbols != (asymbol **) NULL) { for (q = abfd->outsymbols; *q != (asymbol *) NULL; q++) { asymbol *p = *q; + if (bfd_is_und_section (p->section)) { - /* This must be a symbol reference .. */ + /* This must be a symbol reference. */ if (! ieee_write_byte (abfd, ieee_external_reference_enum) - || ! ieee_write_int (abfd, reference_index) + || ! ieee_write_int (abfd, (bfd_vma) reference_index) || ! ieee_write_id (abfd, p->name)) - return false; + return FALSE; p->value = reference_index; reference_index++; - hadone = true; + hadone = TRUE; } else if (bfd_is_com_section (p->section)) { - /* This is a weak reference */ + /* This is a weak reference. */ if (! ieee_write_byte (abfd, ieee_external_reference_enum) - || ! ieee_write_int (abfd, reference_index) + || ! ieee_write_int (abfd, (bfd_vma) reference_index) || ! ieee_write_id (abfd, p->name) || ! ieee_write_byte (abfd, ieee_weak_external_reference_enum) - || ! ieee_write_int (abfd, reference_index) + || ! ieee_write_int (abfd, (bfd_vma) reference_index) || ! ieee_write_int (abfd, p->value)) - return false; + return FALSE; p->value = reference_index; reference_index++; - hadone = true; + hadone = TRUE; } else if (p->flags & BSF_GLOBAL) { - /* This must be a symbol definition */ - + /* This must be a symbol definition. */ if (! ieee_write_byte (abfd, ieee_external_symbol_enum) - || ! ieee_write_int (abfd, public_index) + || ! ieee_write_int (abfd, (bfd_vma) public_index) || ! ieee_write_id (abfd, p->name) || ! ieee_write_2bytes (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 */ - return false; + || ! ieee_write_int (abfd, (bfd_vma) public_index) + || ! ieee_write_byte (abfd, 15) /* Instruction address. */ + || ! ieee_write_byte (abfd, 19) /* Static symbol. */ + || ! ieee_write_byte (abfd, 1)) /* One of them. */ + return FALSE; - /* Write out the value */ + /* Write out the value. */ if (! ieee_write_2bytes (abfd, ieee_value_record_enum) - || ! ieee_write_int (abfd, public_index)) - return false; + || ! ieee_write_int (abfd, (bfd_vma) public_index)) + return FALSE; if (! bfd_is_abs_section (p->section)) { if (abfd->flags & EXEC_P) { /* If fully linked, then output all symbols - relocated */ + relocated. */ if (! (ieee_write_int (abfd, (p->value + p->section->output_offset + p->section->output_section->vma)))) - return false; + return FALSE; } else { @@ -3441,8 +3339,8 @@ ieee_write_external_part (abfd) (abfd, p->value + p->section->output_offset, p->section->output_section->symbol, - false, 0))) - return false; + FALSE, 0))) + return FALSE; } } else @@ -3450,51 +3348,50 @@ ieee_write_external_part (abfd) if (! ieee_write_expression (abfd, p->value, bfd_abs_section_ptr->symbol, - false, 0)) - return false; + FALSE, 0)) + return FALSE; } p->value = public_index; public_index++; - hadone = true; + hadone = TRUE; } else { - /* This can happen - when there are gaps in the symbols read */ - /* from an input ieee file */ + /* This can happen - when there are gaps in the symbols read + from an input ieee file. */ } } } if (hadone) ieee->w.r.external_part = here; - return true; + return TRUE; } -static CONST unsigned char exten[] = +static const unsigned 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 */ + 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 relocatable to x. */ }; -static CONST unsigned char envi[] = +static const unsigned char envi[] = { 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, 00, 52, 0x00, /* exec ok. */ - 0xf1, 0xce, 0x21, 0, 53, 0x03,/* host unix */ + 0xf1, 0xce, 0x21, 0, 53, 0x03,/* host unix. */ /* 0xf1, 0xce, 0x21, 0, 54, 2,1,1 tool & version # */ }; -static boolean -ieee_write_me_part (abfd) - bfd *abfd; +static bfd_boolean +ieee_write_me_part (bfd *abfd) { ieee_data_type *ieee = IEEE_DATA (abfd); ieee->w.r.trailer_part = bfd_tell (abfd); @@ -3504,19 +3401,18 @@ ieee_write_me_part (abfd) || ! 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)) - return false; + return FALSE; } ieee->w.r.me_record = bfd_tell (abfd); if (! ieee_write_byte (abfd, ieee_module_end_enum)) - return false; - return true; + return FALSE; + return TRUE; } /* Write out the IEEE processor ID. */ -static boolean -ieee_write_processor (abfd) - bfd *abfd; +static bfd_boolean +ieee_write_processor (bfd *abfd) { const bfd_arch_info_type *arch; @@ -3525,22 +3421,17 @@ ieee_write_processor (abfd) { default: if (! ieee_write_id (abfd, bfd_printable_name (abfd))) - return false; - break; - - case bfd_arch_a29k: - if (! ieee_write_id (abfd, "29000")) - return false; + return FALSE; break; case bfd_arch_h8300: if (! ieee_write_id (abfd, "H8/300")) - return false; + return FALSE; break; case bfd_arch_h8500: if (! ieee_write_id (abfd, "H8/500")) - return false; + return FALSE; break; case bfd_arch_i960: @@ -3550,23 +3441,23 @@ ieee_write_processor (abfd) case bfd_mach_i960_core: case bfd_mach_i960_ka_sa: if (! ieee_write_id (abfd, "80960KA")) - return false; + return FALSE; break; case bfd_mach_i960_kb_sb: if (! ieee_write_id (abfd, "80960KB")) - return false; + return FALSE; break; case bfd_mach_i960_ca: if (! ieee_write_id (abfd, "80960CA")) - return false; + return FALSE; break; case bfd_mach_i960_mc: case bfd_mach_i960_xa: if (! ieee_write_id (abfd, "80960MC")) - return false; + return FALSE; break; } break; @@ -3586,68 +3477,91 @@ ieee_write_processor (abfd) case bfd_mach_m68040: id = "68040"; break; case bfd_mach_m68060: id = "68060"; break; case bfd_mach_cpu32: id = "cpu32"; break; + case bfd_mach_mcf_isa_a_nodiv: id = "isa-a:nodiv"; break; + case bfd_mach_mcf_isa_a: id = "isa-a"; break; + case bfd_mach_mcf_isa_a_mac: id = "isa-a:mac"; break; + case bfd_mach_mcf_isa_a_emac: id = "isa-a:emac"; break; + case bfd_mach_mcf_isa_aplus: id = "isa-aplus"; break; + case bfd_mach_mcf_isa_aplus_mac: id = "isa-aplus:mac"; break; + case bfd_mach_mcf_isa_aplus_emac: id = "isa-aplus:mac"; break; + case bfd_mach_mcf_isa_b_nousp: id = "isa-b:nousp"; break; + case bfd_mach_mcf_isa_b_nousp_mac: id = "isa-b:nousp:mac"; break; + case bfd_mach_mcf_isa_b_nousp_emac: id = "isa-b:nousp:emac"; break; + case bfd_mach_mcf_isa_b: id = "isa-b"; break; + case bfd_mach_mcf_isa_b_mac: id = "isa-b:mac"; break; + case bfd_mach_mcf_isa_b_emac: id = "isa-b:emac"; break; + case bfd_mach_mcf_isa_b_float: id = "isa-b:float"; break; + case bfd_mach_mcf_isa_b_float_mac: id = "isa-b:float:mac"; break; + case bfd_mach_mcf_isa_b_float_emac: id = "isa-b:float:emac"; break; + case bfd_mach_mcf_isa_c: id = "isa-c"; break; + case bfd_mach_mcf_isa_c_mac: id = "isa-c:mac"; break; + case bfd_mach_mcf_isa_c_emac: id = "isa-c:emac"; break; + case bfd_mach_mcf_isa_c_nodiv: id = "isa-c:nodiv"; break; + case bfd_mach_mcf_isa_c_nodiv_mac: id = "isa-c:nodiv:mac"; break; + case bfd_mach_mcf_isa_c_nodiv_emac: id = "isa-c:nodiv:emac"; break; } if (! ieee_write_id (abfd, id)) - return false; + return FALSE; } break; } - return true; + return TRUE; } -boolean -ieee_write_object_contents (abfd) - bfd *abfd; +static bfd_boolean +ieee_write_object_contents (bfd *abfd) { ieee_data_type *ieee = IEEE_DATA (abfd); unsigned int i; file_ptr old; - /* Fast forward over the header area */ + /* Fast forward over the header area. */ if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) - return false; + return FALSE; if (! ieee_write_byte (abfd, ieee_module_beginning_enum) || ! ieee_write_processor (abfd) || ! ieee_write_id (abfd, abfd->filename)) - return false; + return FALSE; - /* Fast forward over the variable bits */ + /* Fast forward over the variable bits. */ if (! ieee_write_byte (abfd, ieee_address_descriptor_enum)) - return false; + return FALSE; - /* Bits per MAU */ + /* Bits per MAU. */ if (! ieee_write_byte (abfd, (bfd_byte) (bfd_arch_bits_per_byte (abfd)))) - return false; - /* MAU's per address */ + return FALSE; + /* MAU's per address. */ if (! ieee_write_byte (abfd, (bfd_byte) (bfd_arch_bits_per_address (abfd) / bfd_arch_bits_per_byte (abfd)))) - return false; + return FALSE; old = bfd_tell (abfd); if (bfd_seek (abfd, (file_ptr) (8 * N_W_VARIABLES), SEEK_CUR) != 0) - return false; + return FALSE; ieee->w.r.extension_record = bfd_tell (abfd); - if (bfd_write ((char *) exten, 1, sizeof (exten), abfd) != sizeof (exten)) - return false; + if (bfd_bwrite ((char *) exten, (bfd_size_type) sizeof (exten), abfd) + != sizeof (exten)) + return FALSE; if (abfd->flags & EXEC_P) { - if (! ieee_write_byte (abfd, 0x1)) /* Absolute */ - return false; + if (! ieee_write_byte (abfd, 0x1)) /* Absolute. */ + return FALSE; } else { - if (! ieee_write_byte (abfd, 0x2)) /* Relocateable */ - return false; + if (! ieee_write_byte (abfd, 0x2)) /* Relocateable. */ + return FALSE; } ieee->w.r.environmental_record = bfd_tell (abfd); - if (bfd_write ((char *) envi, 1, sizeof (envi), abfd) != sizeof (envi)) - return false; + if (bfd_bwrite ((char *) envi, (bfd_size_type) sizeof (envi), abfd) + != sizeof (envi)) + return FALSE; /* The HP emulator database requires a timestamp in the file. */ { @@ -3660,13 +3574,13 @@ ieee_write_object_contents (abfd) || ! ieee_write_byte (abfd, 0x21) || ! ieee_write_byte (abfd, 0) || ! ieee_write_byte (abfd, 50) - || ! ieee_write_int (abfd, t->tm_year + 1900) - || ! ieee_write_int (abfd, t->tm_mon + 1) - || ! ieee_write_int (abfd, t->tm_mday) - || ! ieee_write_int (abfd, t->tm_hour) - || ! ieee_write_int (abfd, t->tm_min) - || ! ieee_write_int (abfd, t->tm_sec)) - return false; + || ! ieee_write_int (abfd, (bfd_vma) (t->tm_year + 1900)) + || ! ieee_write_int (abfd, (bfd_vma) (t->tm_mon + 1)) + || ! ieee_write_int (abfd, (bfd_vma) t->tm_mday) + || ! ieee_write_int (abfd, (bfd_vma) t->tm_hour) + || ! ieee_write_int (abfd, (bfd_vma) t->tm_min) + || ! ieee_write_int (abfd, (bfd_vma) t->tm_sec)) + return FALSE; } output_bfd = abfd; @@ -3674,79 +3588,73 @@ ieee_write_object_contents (abfd) flush (); if (! ieee_write_section_part (abfd)) - return false; + return FALSE; /* First write the symbols. This changes their values into table indeces so we cant use it after this point. */ if (! ieee_write_external_part (abfd)) - return false; - - /* ieee_write_byte(abfd, ieee_record_seperator_enum);*/ - - /* ieee_write_byte(abfd, ieee_record_seperator_enum);*/ - + return FALSE; /* Write any debugs we have been told about. */ if (! ieee_write_debug_part (abfd)) - return false; + return FALSE; /* Can only write the data once the symbols have been written, since the data contains relocation information which points to the symbols. */ if (! ieee_write_data_part (abfd)) - return false; + return FALSE; /* At the end we put the end! */ if (! ieee_write_me_part (abfd)) - return false; + return FALSE; - /* Generate the header */ + /* Generate the header. */ if (bfd_seek (abfd, old, SEEK_SET) != 0) - return false; + return FALSE; for (i = 0; i < N_W_VARIABLES; i++) { if (! ieee_write_2bytes (abfd, ieee_assign_value_to_variable_enum) || ! ieee_write_byte (abfd, (bfd_byte) i) - || ! ieee_write_int5_out (abfd, ieee->w.offset[i])) - return false; + || ! ieee_write_int5_out (abfd, (bfd_vma) ieee->w.offset[i])) + return FALSE; } - return true; + return TRUE; } -/* Native-level interface to symbols. */ +/* Native-level interface to symbols. */ /* We read the symbols into a buffer, which is discarded when this function exits. We read the strings into a buffer large enough to - hold them all plus all the cached symbol entries. */ + hold them all plus all the cached symbol entries. */ -asymbol * -ieee_make_empty_symbol (abfd) - bfd *abfd; +static asymbol * +ieee_make_empty_symbol (bfd *abfd) { - ieee_symbol_type *new = - (ieee_symbol_type *) bfd_zalloc (sizeof (ieee_symbol_type)); - if (!new) + bfd_size_type amt = sizeof (ieee_symbol_type); + ieee_symbol_type *new_symbol = (ieee_symbol_type *) bfd_zalloc (abfd, amt); + + if (!new_symbol) return NULL; - new->symbol.the_bfd = abfd; - return &new->symbol; + new_symbol->symbol.the_bfd = abfd; + return &new_symbol->symbol; } static bfd * -ieee_openr_next_archived_file (arch, prev) - bfd *arch; - bfd *prev; +ieee_openr_next_archived_file (bfd *arch, bfd *prev) { ieee_ar_data_type *ar = IEEE_AR_DATA (arch); - /* take the next one from the arch state, or reset */ + + /* Take the next one from the arch state, or reset. */ if (prev == (bfd *) NULL) - { - /* Reset the index - the first two entries are bogus*/ - ar->element_index = 2; - } - while (true) + /* Reset the index - the first two entries are bogus. */ + ar->element_index = 2; + + while (TRUE) { ieee_ar_obstack_type *p = ar->elements + ar->element_index; + ar->element_index++; if (ar->element_index <= ar->element_count) { @@ -3763,35 +3671,34 @@ ieee_openr_next_archived_file (arch, prev) else { bfd_set_error (bfd_error_no_more_archived_files); - return (bfd *) NULL; + return NULL; } - } } -static boolean -ieee_find_nearest_line (abfd, - section, - symbols, - offset, - filename_ptr, - functionname_ptr, - line_ptr) - bfd *abfd ATTRIBUTE_UNUSED; - asection *section ATTRIBUTE_UNUSED; - asymbol **symbols ATTRIBUTE_UNUSED; - bfd_vma offset ATTRIBUTE_UNUSED; - const char **filename_ptr ATTRIBUTE_UNUSED; - const char **functionname_ptr ATTRIBUTE_UNUSED; - unsigned int *line_ptr ATTRIBUTE_UNUSED; +static bfd_boolean +ieee_find_nearest_line (bfd *abfd ATTRIBUTE_UNUSED, + asection *section ATTRIBUTE_UNUSED, + asymbol **symbols ATTRIBUTE_UNUSED, + bfd_vma offset ATTRIBUTE_UNUSED, + const char **filename_ptr ATTRIBUTE_UNUSED, + const char **functionname_ptr ATTRIBUTE_UNUSED, + unsigned int *line_ptr ATTRIBUTE_UNUSED) +{ + return FALSE; +} + +static bfd_boolean +ieee_find_inliner_info (bfd *abfd ATTRIBUTE_UNUSED, + const char **filename_ptr ATTRIBUTE_UNUSED, + const char **functionname_ptr ATTRIBUTE_UNUSED, + unsigned int *line_ptr ATTRIBUTE_UNUSED) { - return false; + return FALSE; } static int -ieee_generic_stat_arch_elt (abfd, buf) - bfd *abfd; - struct stat *buf; +ieee_generic_stat_arch_elt (bfd *abfd, struct stat *buf) { ieee_ar_data_type *ar = (ieee_ar_data_type *) NULL; ieee_data_type *ieee; @@ -3821,95 +3728,33 @@ ieee_generic_stat_arch_elt (abfd, buf) } static int -ieee_sizeof_headers (abfd, x) - bfd *abfd ATTRIBUTE_UNUSED; - boolean x ATTRIBUTE_UNUSED; +ieee_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED, + struct bfd_link_info *info ATTRIBUTE_UNUSED) { return 0; } - -/* The debug info routines are never used. */ -#if 0 - -static void -ieee_bfd_debug_info_start (abfd) - bfd *abfd; -{ - -} - -static void -ieee_bfd_debug_info_end (abfd) - bfd *abfd; -{ - -} - - -/* Add this section to the list of sections we have debug info for, to - be ready to output it at close time - */ -static void -ieee_bfd_debug_info_accumulate (abfd, section) - bfd *abfd; - asection *section; -{ - ieee_data_type *ieee = IEEE_DATA (section->owner); - ieee_data_type *output_ieee = IEEE_DATA (abfd); - /* can only accumulate data from other ieee bfds */ - if (section->owner->xvec != abfd->xvec) - return; - /* Only bother once per bfd */ - if (ieee->done_debug == true) - return; - ieee->done_debug = true; - - /* Don't bother if there is no debug info */ - if (ieee->w.r.debug_information_part == 0) - return; - - - /* Add to chain */ - { - bfd_chain_type *n = (bfd_chain_type *) bfd_alloc (abfd, sizeof (bfd_chain_type)); - if (!n) - abort (); /* FIXME */ - n->this = section->owner; - n->next = (bfd_chain_type *) NULL; - - if (output_ieee->chain_head) - { - output_ieee->chain_head->next = n; - } - else - { - output_ieee->chain_root = n; - - } - output_ieee->chain_head = n; - } -} - -#endif - #define ieee_close_and_cleanup _bfd_generic_close_and_cleanup #define ieee_bfd_free_cached_info _bfd_generic_bfd_free_cached_info #define ieee_slurp_armap bfd_true #define ieee_slurp_extended_name_table bfd_true #define ieee_construct_extended_name_table \ - ((boolean (*) PARAMS ((bfd *, char **, bfd_size_type *, const char **))) \ + ((bfd_boolean (*) \ + (bfd *, char **, bfd_size_type *, const char **)) \ bfd_true) #define ieee_truncate_arname bfd_dont_truncate_arname #define ieee_write_armap \ - ((boolean (*) \ - PARAMS ((bfd *, unsigned int, struct orl *, unsigned int, int))) \ + ((bfd_boolean (*) \ + (bfd *, unsigned int, struct orl *, unsigned int, int)) \ bfd_true) #define ieee_read_ar_hdr bfd_nullvoidptr +#define ieee_write_ar_hdr ((bfd_boolean (*) (bfd *, bfd *)) bfd_false) #define ieee_update_armap_timestamp bfd_true #define ieee_get_elt_at_index _bfd_generic_get_elt_at_index +#define ieee_bfd_is_target_special_symbol \ + ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false) #define ieee_bfd_is_local_label_name bfd_generic_is_local_label_name #define ieee_get_lineno _bfd_nosymbols_get_lineno #define ieee_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol @@ -3917,6 +3762,7 @@ ieee_bfd_debug_info_accumulate (abfd, section) #define ieee_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol #define ieee_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup +#define ieee_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup #define ieee_set_arch_mach _bfd_generic_set_arch_mach @@ -3926,35 +3772,46 @@ ieee_bfd_debug_info_accumulate (abfd, section) bfd_generic_get_relocated_section_contents #define ieee_bfd_relax_section bfd_generic_relax_section #define ieee_bfd_gc_sections bfd_generic_gc_sections +#define ieee_bfd_lookup_section_flags bfd_generic_lookup_section_flags +#define ieee_bfd_merge_sections bfd_generic_merge_sections +#define ieee_bfd_is_group_section bfd_generic_is_group_section +#define ieee_bfd_discard_group bfd_generic_discard_group +#define ieee_section_already_linked \ + _bfd_generic_section_already_linked +#define ieee_bfd_define_common_symbol bfd_generic_define_common_symbol #define ieee_bfd_link_hash_table_create _bfd_generic_link_hash_table_create +#define ieee_bfd_link_hash_table_free _bfd_generic_link_hash_table_free #define ieee_bfd_link_add_symbols _bfd_generic_link_add_symbols +#define ieee_bfd_link_just_syms _bfd_generic_link_just_syms +#define ieee_bfd_copy_link_hash_symbol_type \ + _bfd_generic_copy_link_hash_symbol_type #define ieee_bfd_final_link _bfd_generic_final_link #define ieee_bfd_link_split_section _bfd_generic_link_split_section -/*SUPPRESS 460 */ const bfd_target ieee_vec = { - "ieee", /* name */ + "ieee", /* Name. */ bfd_target_ieee_flavour, - BFD_ENDIAN_UNKNOWN, /* target byte order */ - BFD_ENDIAN_UNKNOWN, /* target headers byte order */ - (HAS_RELOC | EXEC_P | /* object flags */ + BFD_ENDIAN_UNKNOWN, /* Target byte order. */ + BFD_ENDIAN_UNKNOWN, /* Target headers byte order. */ + (HAS_RELOC | EXEC_P | /* Object flags. */ HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED), (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS - | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */ - '_', /* leading underscore */ - ' ', /* ar_pad_char */ - 16, /* ar_max_namelen */ + | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags. */ + '_', /* Leading underscore. */ + ' ', /* AR_pad_char. */ + 16, /* AR_max_namelen. */ + 0, /* match priority. */ bfd_getb64, bfd_getb_signed_64, bfd_putb64, bfd_getb32, bfd_getb_signed_32, bfd_putb32, - bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */ + bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Data. */ bfd_getb64, bfd_getb_signed_64, bfd_putb64, bfd_getb32, bfd_getb_signed_32, bfd_putb32, - bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */ + bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Headers. */ {_bfd_dummy_target, - ieee_object_p, /* bfd_check_format */ + ieee_object_p, /* bfd_check_format. */ ieee_archive_p, _bfd_dummy_target, }, @@ -3971,17 +3828,45 @@ const bfd_target ieee_vec = bfd_false, }, + /* ieee_close_and_cleanup, ieee_bfd_free_cached_info, ieee_new_section_hook, + ieee_get_section_contents, ieee_get_section_contents_in_window. */ BFD_JUMP_TABLE_GENERIC (ieee), + BFD_JUMP_TABLE_COPY (_bfd_generic), BFD_JUMP_TABLE_CORE (_bfd_nocore), + + /* ieee_slurp_armap, ieee_slurp_extended_name_table, + ieee_construct_extended_name_table, ieee_truncate_arname, + ieee_write_armap, ieee_read_ar_hdr, ieee_openr_next_archived_file, + ieee_get_elt_at_index, ieee_generic_stat_arch_elt, + ieee_update_armap_timestamp. */ BFD_JUMP_TABLE_ARCHIVE (ieee), + + /* ieee_get_symtab_upper_bound, ieee_canonicalize_symtab, + ieee_make_empty_symbol, ieee_print_symbol, ieee_get_symbol_info, + ieee_bfd_is_local_label_name, ieee_get_lineno, + ieee_find_nearest_line, ieee_bfd_make_debug_symbol, + ieee_read_minisymbols, ieee_minisymbol_to_symbol. */ BFD_JUMP_TABLE_SYMBOLS (ieee), + + /* ieee_get_reloc_upper_bound, ieee_canonicalize_reloc, + ieee_bfd_reloc_type_lookup. */ BFD_JUMP_TABLE_RELOCS (ieee), + + /* ieee_set_arch_mach, ieee_set_section_contents. */ BFD_JUMP_TABLE_WRITE (ieee), + + /* ieee_sizeof_headers, ieee_bfd_get_relocated_section_contents, + ieee_bfd_relax_section, ieee_bfd_link_hash_table_create, + _bfd_generic_link_hash_table_free, + ieee_bfd_link_add_symbols, ieee_bfd_final_link, + ieee_bfd_link_split_section, ieee_bfd_gc_sections, + ieee_bfd_merge_sections. */ BFD_JUMP_TABLE_LINK (ieee), + BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), NULL, - - (PTR) 0 + + NULL };