X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=bfd%2Fieee.c;h=cd56101aa13f2cc0be021f717a48c9a7ce72b82d;hb=e2d34d7de2eb0bf5be827ffcf976ae5f9524e901;hp=45c76e193c7930e12098c4dc6300c5183765a8d8;hpb=9deaaaf1b35a54f776957492c4300ea993a3961c;p=binutils-gdb.git diff --git a/bfd/ieee.c b/bfd/ieee.c index 45c76e193c7..cd56101aa13 100644 --- a/bfd/ieee.c +++ b/bfd/ieee.c @@ -1,22 +1,25 @@ /* BFD back-end for ieee-695 objects. - Copyright (C) 1990, 91, 92, 93, 94 Free Software Foundation, Inc. + Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, + 2000, 2001, 2002 + 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 2 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., 675 Mass Ave, Cambridge, MA 02139, 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 @@ -29,118 +32,217 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "libbfd.h" #include "ieee.h" #include "libieee.h" -#include "obstack.h" -#define obstack_chunk_alloc malloc -#define obstack_chunk_free free +#include "safe-ctype.h" + +struct output_buffer_struct +{ + unsigned char *ptrp; + int buffer; +}; + +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 unsigned short read_2bytes PARAMS ((common_header_type *)); +static void bfd_get_string PARAMS ((common_header_type *, char *, size_t)); +static char *read_id PARAMS ((common_header_type *)); +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 parse_int PARAMS ((common_header_type *, bfd_vma *)); +static int parse_i PARAMS ((common_header_type *, boolean *)); +static bfd_vma must_parse_int PARAMS ((common_header_type *)); +static void parse_expression + PARAMS ((ieee_data_type *, bfd_vma *, ieee_symbol_index_type *, + boolean *, unsigned int *, asection **)); +static file_ptr ieee_part_after PARAMS ((ieee_data_type *, file_ptr)); +static ieee_symbol_type *get_symbol + PARAMS ((bfd *, ieee_data_type *, ieee_symbol_type *, unsigned int *, + ieee_symbol_type ***, unsigned int *, int)); +static boolean ieee_slurp_external_symbols PARAMS ((bfd *)); +static boolean ieee_slurp_symbol_table PARAMS ((bfd *)); +static long ieee_get_symtab_upper_bound PARAMS ((bfd *)); +static long ieee_get_symtab PARAMS ((bfd *, asymbol **)); +static asection *get_section_entry + PARAMS ((bfd *, ieee_data_type *i, unsigned int)); +static void ieee_slurp_sections PARAMS ((bfd *)); +static boolean ieee_slurp_debug PARAMS ((bfd *)); +const bfd_target *ieee_archive_p PARAMS ((bfd *)); +const bfd_target *ieee_object_p PARAMS ((bfd *)); +static void ieee_get_symbol_info PARAMS ((bfd *, asymbol *, symbol_info *)); +static void ieee_print_symbol + PARAMS ((bfd *, PTR, asymbol *, bfd_print_symbol_type)); +static boolean do_one + PARAMS ((ieee_data_type *, ieee_per_section_type *, unsigned char *, + asection *, int)); +static boolean ieee_slurp_section_data PARAMS ((bfd *)); +static boolean ieee_new_section_hook PARAMS ((bfd *, asection *)); +static long ieee_get_reloc_upper_bound PARAMS ((bfd *, sec_ptr)); +static boolean ieee_get_section_contents + PARAMS ((bfd *, sec_ptr, PTR, file_ptr, bfd_size_type)); +static long ieee_canonicalize_reloc + PARAMS ((bfd *, sec_ptr, arelent **, asymbol **)); +static int comp PARAMS ((const PTR, const PTR)); +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_mkobject PARAMS ((bfd *)); +static void fill PARAMS ((void)); +static void flush PARAMS ((void)); +static void write_int PARAMS ((int)); +static void copy_id PARAMS ((void)); +static void copy_expression PARAMS ((void)); +static void fill_int PARAMS ((struct output_buffer_struct *)); +static void drop_int PARAMS ((struct output_buffer_struct *)); +static void copy_int PARAMS ((void)); +static void f1_record PARAMS ((void)); +static void f0_record PARAMS ((void)); +static void copy_till_end PARAMS ((void)); +static void f2_record PARAMS ((void)); +static void f8_record PARAMS ((void)); +static void e2_record PARAMS ((void)); +static void block PARAMS ((void)); +static void relocate_debug PARAMS ((bfd *, bfd *)); +static boolean ieee_write_debug_part PARAMS ((bfd *)); +static boolean ieee_write_data_part PARAMS ((bfd *)); +static boolean init_for_output PARAMS ((bfd *)); +static boolean ieee_set_section_contents + PARAMS ((bfd *, sec_ptr, PTR, file_ptr, bfd_size_type)); +static boolean ieee_write_external_part PARAMS ((bfd *)); +static boolean ieee_write_me_part PARAMS ((bfd *)); +static boolean ieee_write_processor PARAMS ((bfd *)); +static boolean ieee_write_object_contents PARAMS ((bfd *)); +static asymbol *ieee_make_empty_symbol PARAMS ((bfd *)); +static bfd *ieee_openr_next_archived_file PARAMS ((bfd *, bfd *)); +static boolean ieee_find_nearest_line + PARAMS ((bfd *, asection *, asymbol **, bfd_vma, const char **, + const char **, unsigned int *)); +static int ieee_generic_stat_arch_elt PARAMS ((bfd *, struct stat *)); +static int ieee_sizeof_headers PARAMS ((bfd *, boolean)); /* Functions for writing to ieee files in the strange way that the standard requires. */ -static void -ieee_write_byte (abfd, byte) +static boolean +ieee_write_byte (abfd, barg) bfd *abfd; - bfd_byte byte; + int barg; { - bfd_write ((PTR) & byte, 1, 1, abfd); -} + bfd_byte byte; -static void -ieee_write_twobyte (abfd, twobyte) - bfd *abfd; - int twobyte; -{ - bfd_byte b[2]; - b[1] = twobyte & 0xff; - b[0] = twobyte >> 8; - bfd_write ((PTR) & b[0], 1, 2, abfd); + byte = barg; + if (bfd_bwrite ((PTR) &byte, (bfd_size_type) 1, abfd) != 1) + return false; + return true; } -static void +static boolean ieee_write_2bytes (abfd, bytes) bfd *abfd; int bytes; { bfd_byte buffer[2]; + buffer[0] = bytes >> 8; buffer[1] = bytes & 0xff; - - bfd_write ((PTR) buffer, 1, 2, abfd); + if (bfd_bwrite ((PTR) buffer, (bfd_size_type) 2, abfd) != 2) + return false; + return true; } -static void +static boolean ieee_write_int (abfd, value) bfd *abfd; bfd_vma value; { - if (((unsigned) value) <= 127) + if (value <= 127) { - ieee_write_byte (abfd, (bfd_byte) value); + if (! ieee_write_byte (abfd, (bfd_byte) value)) + return false; } else { unsigned int length; + /* 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; - ieee_write_byte (abfd, - (bfd_byte) ((int) ieee_number_repeat_start_enum + length)); + if (! ieee_write_byte (abfd, + (bfd_byte) ((int) ieee_number_repeat_start_enum + + length))) + return false; switch (length) { case 4: - ieee_write_byte (abfd, (bfd_byte) (value >> 24)); + if (! ieee_write_byte (abfd, (bfd_byte) (value >> 24))) + return false; + /* Fall through. */ case 3: - ieee_write_byte (abfd, (bfd_byte) (value >> 16)); + if (! ieee_write_byte (abfd, (bfd_byte) (value >> 16))) + return false; + /* Fall through. */ case 2: - ieee_write_byte (abfd, (bfd_byte) (value >> 8)); + if (! ieee_write_byte (abfd, (bfd_byte) (value >> 8))) + return false; + /* Fall through. */ case 1: - ieee_write_byte (abfd, (bfd_byte) (value)); + if (! ieee_write_byte (abfd, (bfd_byte) (value))) + return false; } } + + return true; } -static void +static boolean ieee_write_id (abfd, id) bfd *abfd; - CONST char *id; + const char *id; { size_t length = strlen (id); + if (length <= 127) { - ieee_write_byte (abfd, (bfd_byte) length); + if (! ieee_write_byte (abfd, (bfd_byte) length)) + return false; } else if (length < 255) { - ieee_write_byte (abfd, ieee_extension_length_1_enum); - ieee_write_byte (abfd, (bfd_byte) length); + if (! ieee_write_byte (abfd, ieee_extension_length_1_enum) + || ! ieee_write_byte (abfd, (bfd_byte) length)) + return false; } else if (length < 65535) { - ieee_write_byte (abfd, ieee_extension_length_2_enum); - ieee_write_byte (abfd, (bfd_byte) (length >> 8)); - ieee_write_byte (abfd, (bfd_byte) (length & 0xff)); + if (! ieee_write_byte (abfd, ieee_extension_length_2_enum) + || ! ieee_write_2bytes (abfd, (int) length)) + return false; } else { - BFD_FAIL (); + (*_bfd_error_handler) + (_("%s: string too long (%d chars, max 65535)"), + bfd_get_filename (abfd), length); + bfd_set_error (bfd_error_invalid_operation); + return false; } - bfd_write ((PTR) id, 1, length, abfd); + + if (bfd_bwrite ((PTR) 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: @@ -195,18 +297,15 @@ read_id (ieee) length = (length * 256) + this_byte_and_next (ieee); } /* Buy memory and read string */ - string = bfd_alloc (ieee->abfd, length + 1); + string = bfd_alloc (ieee->abfd, (bfd_size_type) length + 1); if (!string) - { - bfd_set_error (bfd_error_no_memory); - return NULL; - } + return NULL; bfd_get_string (ieee, string, length); string[length] = 0; return string; } -static void +static boolean ieee_write_expression (abfd, value, symbol, pcrel, index) bfd *abfd; bfd_vma value; @@ -218,71 +317,86 @@ ieee_write_expression (abfd, value, symbol, pcrel, index) if (value != 0) { - ieee_write_int (abfd, value); + if (! ieee_write_int (abfd, value)) + return false; term_count++; } if (bfd_is_com_section (symbol->section) - || symbol->section == &bfd_und_section) + || bfd_is_und_section (symbol->section)) { /* Def of a common symbol */ - ieee_write_byte (abfd, ieee_variable_X_enum); - ieee_write_int (abfd, symbol->value); + if (! ieee_write_byte (abfd, ieee_variable_X_enum) + || ! ieee_write_int (abfd, symbol->value)) + return false; term_count++; } - else if (symbol->section != &bfd_abs_section) + else if (! bfd_is_abs_section (symbol->section)) { /* Ref to defined symbol - */ - ieee_write_byte (abfd, ieee_variable_R_enum); - ieee_write_byte (abfd, - (bfd_byte) (symbol->section->index + IEEE_SECTION_NUMBER_BASE)); - term_count++; if (symbol->flags & BSF_GLOBAL) { - ieee_write_byte (abfd, ieee_variable_I_enum); - ieee_write_int (abfd, symbol->value); + if (! ieee_write_byte (abfd, ieee_variable_I_enum) + || ! ieee_write_int (abfd, symbol->value)) + return false; term_count++; } 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 */ - ieee_write_byte (abfd, ieee_variable_R_enum); /* or L */ - ieee_write_byte (abfd, - (bfd_byte) (symbol->section->index + IEEE_SECTION_NUMBER_BASE)); - ieee_write_int (abfd, symbol->value); + /* 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_FAIL (); + (*_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*/ - ieee_write_byte (abfd, ieee_variable_P_enum); - ieee_write_byte (abfd, (bfd_byte) (index + IEEE_SECTION_NUMBER_BASE)); - ieee_write_byte (abfd, ieee_function_minus_enum); + if (! ieee_write_byte (abfd, ieee_variable_P_enum) + || ! ieee_write_byte (abfd, + (bfd_byte) (index + IEEE_SECTION_NUMBER_BASE)) + || ! ieee_write_byte (abfd, ieee_function_minus_enum)) + return false; } - if (term_count == 1) + /* Handle the degenerate case of a 0 address. */ + if (term_count == 0) { - ieee_write_byte (abfd, 0); + if (! ieee_write_int (abfd, (bfd_vma) 0)) + return false; } - else + + while (term_count > 1) { - while (term_count > 1) - { - ieee_write_byte (abfd, ieee_function_plus_enum); - term_count--; - } + if (! ieee_write_byte (abfd, ieee_function_plus_enum)) + return false; + term_count--; } + + return true; } - /*****************************************************************************/ /* @@ -300,14 +414,17 @@ ieee_write_int5 (buffer, value) buffer[4] = (value >> 0) & 0xff; } -static void +static boolean ieee_write_int5_out (abfd, value) bfd *abfd; bfd_vma value; { bfd_byte b[5]; + ieee_write_int5 (b, value); - bfd_write ((PTR) b, 1, 5, abfd); + if (bfd_bwrite ((PTR) b, (bfd_size_type) 5, abfd) != 5) + return false; + return true; } static boolean @@ -366,34 +483,109 @@ typedef struct } ieee_value_type; -static -reloc_howto_type abs32_howto -= HOWTO (1, 0, 2, 32, false, 0, complain_overflow_bitfield, 0, "abs32", true, 0xffffffff, 0xffffffff, false); -static -reloc_howto_type abs16_howto -= HOWTO (1, 0, 1, 16, false, 0, complain_overflow_bitfield, 0, "abs16", true, 0x0000ffff, 0x0000ffff, false); - -static -reloc_howto_type abs8_howto -= HOWTO (1, 0, 0, 8, false, 0, complain_overflow_bitfield, 0, "abs8", true, 0x000000ff, 0x000000ff, false); - -static -reloc_howto_type rel32_howto -= HOWTO (1, 0, 2, 32, true, 0, complain_overflow_signed, 0, "rel32", true, 0xffffffff, - 0xffffffff, false); +#if KEEPMINUSPCININST -static -reloc_howto_type rel16_howto -= HOWTO (1, 0, 1, 16, true, 0, complain_overflow_signed, 0, "rel16", true, 0x0000ffff, 0x0000ffff, false); +#define SRC_MASK(arg) arg +#define PCREL_OFFSET false -static -reloc_howto_type rel8_howto -= HOWTO (1, 0, 0, 8, true, 0, complain_overflow_signed, 0, "rel8", true, 0x000000ff, 0x000000ff, false); +#else +#define SRC_MASK(arg) 0 +#define PCREL_OFFSET true -static ieee_symbol_index_type NOSYMBOL = -{0, 0}; +#endif +static reloc_howto_type abs32_howto = + HOWTO (1, + 0, + 2, + 32, + false, + 0, + complain_overflow_bitfield, + 0, + "abs32", + true, + 0xffffffff, + 0xffffffff, + false); + +static reloc_howto_type abs16_howto = + HOWTO (1, + 0, + 1, + 16, + false, + 0, + complain_overflow_bitfield, + 0, + "abs16", + true, + 0x0000ffff, + 0x0000ffff, + false); + +static reloc_howto_type abs8_howto = + HOWTO (1, + 0, + 0, + 8, + false, + 0, + complain_overflow_bitfield, + 0, + "abs8", + true, + 0x000000ff, + 0x000000ff, + false); + +static reloc_howto_type rel32_howto = + HOWTO (1, + 0, + 2, + 32, + true, + 0, + complain_overflow_signed, + 0, + "rel32", + true, + SRC_MASK (0xffffffff), + 0xffffffff, + PCREL_OFFSET); + +static reloc_howto_type rel16_howto = + HOWTO (1, + 0, + 1, + 16, + true, + 0, + complain_overflow_signed, + 0, + "rel16", + true, + SRC_MASK (0x0000ffff), + 0x0000ffff, + PCREL_OFFSET); + +static reloc_howto_type rel8_howto = + HOWTO (1, + 0, + 0, + 8, + true, + 0, + complain_overflow_signed, + 0, + "rel8", + true, + SRC_MASK (0x000000ff), + 0x000000ff, + PCREL_OFFSET); + +static ieee_symbol_index_type NOSYMBOL = {0, 0}; static void parse_expression (ieee, value, symbol, pcrel, extra, section) @@ -418,8 +610,9 @@ parse_expression (ieee, value, symbol, pcrel, extra, section) #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; + asection *dummy; - while (loop) + while (loop && ieee->h.input_p < ieee->h.last_byte) { switch (this_byte (&(ieee->h))) { @@ -430,9 +623,7 @@ parse_expression (ieee, value, symbol, pcrel, extra, section) next_byte (&(ieee->h)); *pcrel = true; section_n = must_parse_int (&(ieee->h)); - PUSH (NOSYMBOL, &bfd_abs_section, - TOS.value = ieee->section_table[section_n]->vma + - ieee_per_section (ieee->section_table[section_n])->pc); + PUSH (NOSYMBOL, bfd_abs_section_ptr, 0); break; } case ieee_variable_L_enum: @@ -454,6 +645,16 @@ parse_expression (ieee, value, symbol, pcrel, extra, section) ieee->section_table[must_parse_int (&(ieee->h))]->_raw_size); break; case ieee_variable_I_enum: + /* 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'; + + PUSH (sy, bfd_abs_section_ptr, 0); + } + break; case ieee_variable_X_enum: /* Push the address of external variable n */ { @@ -462,7 +663,7 @@ parse_expression (ieee, value, symbol, pcrel, extra, section) sy.index = (int) (must_parse_int (&(ieee->h))); sy.letter = 'X'; - PUSH (sy, &bfd_und_section, 0); + PUSH (sy, bfd_und_section_ptr, 0); } break; case ieee_function_minus_enum: @@ -474,7 +675,7 @@ parse_expression (ieee, value, symbol, pcrel, extra, section) POP (sy, section1, value1); POP (sy, section_dummy, value2); - PUSH (sy, section1 ? section1 : section_dummy, value1 - value2); + PUSH (sy, section1 ? section1 : section_dummy, value2 - value1); } break; case ieee_function_plus_enum: @@ -488,7 +689,9 @@ parse_expression (ieee, value, symbol, pcrel, extra, section) POP (sy1, section1, value1); POP (sy2, section2, value2); - PUSH (sy1.letter ? sy1 : sy2, section1 != &bfd_abs_section ? section1 : section2, value1 + value2); + PUSH (sy1.letter ? sy1 : sy2, + bfd_is_abs_section (section1) ? section2 : section1, + value1 + value2); } break; default: @@ -498,78 +701,91 @@ parse_expression (ieee, value, symbol, pcrel, extra, section) || this_byte (&(ieee->h)) > (int) ieee_variable_Z_enum); if (parse_int (&(ieee->h), &va)) { - PUSH (NOSYMBOL, &bfd_abs_section, va); + 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; - } - + /* 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); + } + + 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) -#define ieee_pos(abfd) IEEE_DATA(abfd)->h.input_p -IEEE_DATA(abfd)->h.first_byte +/* Find the first part of the ieee file after HERE. */ + +static file_ptr +ieee_part_after (ieee, here) + 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]; + + return after; +} static unsigned int last_index; 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; +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 - ; + 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 = (ieee_symbol_type *) bfd_alloc (ieee->h.abfd, amt); if (!new_symbol) - { - bfd_set_error (bfd_error_no_memory); - return NULL; - } + return NULL; new_symbol->index = new_index; last_index = new_index; @@ -581,6 +797,7 @@ get_symbol (abfd, *max_index = new_index; } last_type = this_type; + new_symbol->symbol.section = bfd_abs_section_ptr; return new_symbol; } return last_symbol; @@ -601,7 +818,7 @@ ieee_slurp_external_symbols (abfd) last_index = 0xffffff; ieee->symbol_table_full = true; - ieee_seek (abfd, offset); + ieee_seek (ieee, offset); while (loop) { @@ -612,13 +829,13 @@ ieee_slurp_external_symbols (abfd) symbol = get_symbol (abfd, ieee, symbol, &symbol_count, &prev_symbols_ptr, - &ieee->external_symbol_max_index, 'D'); + &ieee->external_symbol_max_index, 'I'); if (symbol == NULL) return false; symbol->symbol.the_bfd = abfd; symbol->symbol.name = read_id (&(ieee->h)); - symbol->symbol.udata = (PTR) NULL; + symbol->symbol.udata.p = (PTR) NULL; symbol->symbol.flags = BSF_NO_FLAGS; break; case ieee_external_symbol_enum: @@ -634,7 +851,7 @@ ieee_slurp_external_symbols (abfd) symbol->symbol.the_bfd = abfd; symbol->symbol.name = read_id (&(ieee->h)); - symbol->symbol.udata = (PTR) NULL; + symbol->symbol.udata.p = (PTR) NULL; symbol->symbol.flags = BSF_NO_FLAGS; break; case ieee_attribute_record_enum >> 8: @@ -643,25 +860,73 @@ ieee_slurp_external_symbols (abfd) unsigned int symbol_type_index; unsigned int symbol_attribute_def; bfd_vma value; - next_byte (&(ieee->h)); /* Skip prefix */ - next_byte (&(ieee->h)); - symbol_name_index = must_parse_int (&(ieee->h)); - symbol_type_index = must_parse_int (&(ieee->h)); - symbol_attribute_def = must_parse_int (&(ieee->h)); - switch (symbol_attribute_def) + switch (read_2bytes (&ieee->h)) { - case 63: - /* Module misc; followed by two fields which describe the - current module block. The first fired is the type id - number, the second is the number of asn records - associated with the directive */ + case ieee_attribute_record_enum: + symbol_name_index = must_parse_int (&(ieee->h)); + symbol_type_index = must_parse_int (&(ieee->h)); + symbol_attribute_def = must_parse_int (&(ieee->h)); + switch (symbol_attribute_def) + { + case 8: + case 19: + parse_int (&ieee->h, &value); + break; + default: + (*_bfd_error_handler) + (_("%s: unimplemented ATI record %u for symbol %u"), + bfd_archive_filename (abfd), symbol_attribute_def, + symbol_name_index); + bfd_set_error (bfd_error_bad_value); + return false; + break; + } + break; + case ieee_external_reference_info_record_enum: + /* Skip over ATX record. */ + parse_int (&(ieee->h), &value); parse_int (&(ieee->h), &value); parse_int (&(ieee->h), &value); - break; - - default: parse_int (&(ieee->h), &value); break; + 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} */ + 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_archive_filename (abfd), (int) value); + bfd_set_error (bfd_error_bad_value); + return false; + } + parse_int (&ieee->h, &value); + parse_int (&ieee->h, &value); + while (value > 0) + { + bfd_vma val1; + + --value; + + switch (read_2bytes (&ieee->h)) + { + case ieee_asn_record_enum: + parse_int (&ieee->h, &val1); + parse_int (&ieee->h, &val1); + break; + + default: + (*_bfd_error_handler) + (_("%s: unexpected type after ATN"), + bfd_archive_filename (abfd)); + bfd_set_error (bfd_error_bad_value); + return false; + } + } } } break; @@ -682,6 +947,28 @@ ieee_slurp_external_symbols (abfd) &extra, &symbol->symbol.section); + /* Fully linked IEEE-695 files tend to give every symbol + an absolute value. Try to convert that back into a + section relative value. FIXME: This won't always to + the right thing. */ + if (bfd_is_abs_section (symbol->symbol.section) + && (abfd->flags & HAS_RELOC) == 0) + { + bfd_vma val; + asection *s; + + val = symbol->symbol.value; + for (s = abfd->sections; s != NULL; s = s->next) + { + if (val >= s->vma && val < s->vma + s->_raw_size) + { + symbol->symbol.section = s; + symbol->symbol.value -= s->vma; + break; + } + } + } + symbol->symbol.flags = BSF_GLOBAL | BSF_EXPORT; } @@ -701,7 +988,7 @@ ieee_slurp_external_symbols (abfd) value = 0; } /* This turns into a common */ - symbol->symbol.section = &bfd_com_section; + symbol->symbol.section = bfd_com_section_ptr; symbol->symbol.value = size; } break; @@ -717,8 +1004,8 @@ ieee_slurp_external_symbols (abfd) symbol->symbol.the_bfd = abfd; symbol->symbol.name = read_id (&(ieee->h)); - symbol->symbol.udata = (PTR) NULL; - symbol->symbol.section = &bfd_und_section; + symbol->symbol.udata.p = (PTR) NULL; + symbol->symbol.section = bfd_und_section_ptr; symbol->symbol.value = (bfd_vma) 0; symbol->symbol.flags = 0; @@ -780,7 +1067,7 @@ ieee_slurp_symbol_table (abfd) return true; } -long +static long ieee_get_symtab_upper_bound (abfd) bfd *abfd; { @@ -796,9 +1083,9 @@ Move from our internal lists to the canon table, and insert in symbol index order */ -extern bfd_target ieee_vec; +extern const bfd_target ieee_vec; -long +static long ieee_get_symtab (abfd, location) bfd *abfd; asymbol **location; @@ -806,8 +1093,17 @@ ieee_get_symtab (abfd, location) ieee_symbol_type *symp; static bfd dummy_bfd; static asymbol empty_symbol = - /* the_bfd, name, value, attr, section */ - {&dummy_bfd, " ieee empty", (symvalue) 0, BSF_DEBUGGING, &bfd_abs_section}; + { + &dummy_bfd, + " ieee empty", + (symvalue) 0, + BSF_DEBUGGING, + bfd_abs_section_ptr +#ifdef __STDC__ + /* K&R compilers can't initialise unions. */ + , { 0 } +#endif + }; if (abfd->symcount) { @@ -862,16 +1158,38 @@ get_section_entry (abfd, ieee, index) ieee_data_type *ieee; unsigned int index; { + if (index >= 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) + c *= 2; + + amt = c; + amt *= sizeof (asection *); + n = (asection **) bfd_realloc (ieee->section_table, amt); + if (n == NULL) + return NULL; + + for (i = ieee->section_table_size; i < c; i++) + n[i] = NULL; + + ieee->section_table = n; + ieee->section_table_size = c; + } + if (ieee->section_table[index] == (asection *) NULL) { - char *tmp = bfd_alloc (abfd, 11); + char *tmp = bfd_alloc (abfd, (bfd_size_type) 11); asection *section; if (!tmp) - { - bfd_set_error (bfd_error_no_memory); - return NULL; - } + return NULL; sprintf (tmp, " fsec%4d", index); section = bfd_make_section (abfd, tmp); ieee->section_table[index] = section; @@ -888,34 +1206,36 @@ ieee_slurp_sections (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); + 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)); - /* Fixme to be nice about a silly number of sections */ - BFD_ASSERT (section_index < NSECTIONS); section = get_section_entry (abfd, ieee, section_index); section_type[0] = this_byte_and_next (&(ieee->h)); + + /* Set minimal section attributes. Attributes are + extended later, based on section contents. */ + switch (section_type[0]) { case 0xC1: /* Normal attributes for absolute sections */ section_type[1] = this_byte (&(ieee->h)); - section->flags = SEC_LOAD | SEC_ALLOC | SEC_HAS_CONTENTS; + section->flags = SEC_ALLOC; switch (section_type[1]) { case 0xD3: /* AS Absolute section attributes */ @@ -926,17 +1246,17 @@ ieee_slurp_sections (abfd) case 0xD0: /* Normal code */ next_byte (&(ieee->h)); - section->flags |= SEC_LOAD | SEC_CODE; + section->flags |= SEC_CODE; break; case 0xC4: - next_byte (&(ieee->h)); - section->flags |= SEC_LOAD | SEC_DATA; /* Normal data */ + next_byte (&(ieee->h)); + section->flags |= SEC_DATA; break; case 0xD2: next_byte (&(ieee->h)); /* Normal rom data */ - section->flags |= SEC_LOAD | SEC_ROM | SEC_DATA; + section->flags |= SEC_ROM | SEC_DATA; break; default: break; @@ -945,20 +1265,20 @@ ieee_slurp_sections (abfd) break; case 0xC3: /* Named relocatable sections (type C) */ section_type[1] = this_byte (&(ieee->h)); - section->flags = SEC_LOAD | SEC_ALLOC | SEC_HAS_CONTENTS; + section->flags = SEC_ALLOC; switch (section_type[1]) { case 0xD0: /* Normal code (CP) */ next_byte (&(ieee->h)); - section->flags |= SEC_LOAD | SEC_CODE; + section->flags |= SEC_CODE; break; case 0xC4: /* Normal data (CD) */ next_byte (&(ieee->h)); - section->flags |= SEC_LOAD | SEC_DATA; + section->flags |= SEC_DATA; break; case 0xD2: /* Normal rom data (CR) */ next_byte (&(ieee->h)); - section->flags |= SEC_LOAD | SEC_ROM | SEC_DATA; + section->flags |= SEC_ROM | SEC_DATA; break; default: break; @@ -998,8 +1318,10 @@ 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: @@ -1013,6 +1335,7 @@ ieee_slurp_sections (abfd) case ieee_region_base_address_enum: section = ieee->section_table[must_parse_int (&(ieee->h))]; section->vma = must_parse_int (&(ieee->h)); + section->lma = section->vma; break; case ieee_mau_size_enum: must_parse_int (&(ieee->h)); @@ -1025,6 +1348,7 @@ ieee_slurp_sections (abfd) case ieee_section_base_address_enum: section = ieee->section_table[must_parse_int (&(ieee->h))]; section->vma = must_parse_int (&(ieee->h)); + section->lma = section->vma; break; case ieee_section_offset_enum: (void) must_parse_int (&(ieee->h)); @@ -1041,34 +1365,61 @@ ieee_slurp_sections (abfd) } } } - +/* Make a section for the debugging information, if any. We don't try + to interpret the debugging information; we just point the section + at the area in the file so that program which understand can dig it + out. */ + +static boolean +ieee_slurp_debug (abfd) + bfd *abfd; +{ + ieee_data_type *ieee = IEEE_DATA (abfd); + asection *sec; + file_ptr debug_end; + + if (ieee->w.r.debug_information_part == 0) + return true; + + sec = bfd_make_section (abfd, ".debug"); + if (sec == NULL) + return false; + sec->flags |= SEC_DEBUGGING | SEC_HAS_CONTENTS; + sec->filepos = ieee->w.r.debug_information_part; + + debug_end = ieee_part_after (ieee, ieee->w.r.debug_information_part); + sec->_raw_size = debug_end - ieee->w.r.debug_information_part; + + return true; +} + /*********************************************************************** * archive stuff */ -bfd_target * +const bfd_target * ieee_archive_p (abfd) bfd *abfd; { char *library; - boolean loop; - unsigned int i; unsigned char buffer[512]; - struct obstack ob; file_ptr buffer_offset = 0; ieee_ar_data_type *save = abfd->tdata.ieee_ar_data; ieee_ar_data_type *ieee; - abfd->tdata.ieee_ar_data = (ieee_ar_data_type *) bfd_alloc (abfd, sizeof (ieee_ar_data_type)); + 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, amt); if (!abfd->tdata.ieee_ar_data) - { - bfd_set_error (bfd_error_no_memory); - return NULL; - } + goto error_return; ieee = IEEE_AR_DATA (abfd); - 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 ((PTR) buffer, (bfd_size_type) sizeof (buffer), abfd); ieee->h.first_byte = buffer; ieee->h.input_p = buffer; @@ -1076,112 +1427,121 @@ ieee_archive_p (abfd) ieee->h.abfd = abfd; if (this_byte (&(ieee->h)) != Module_Beginning) - { - abfd->tdata.ieee_ar_data = save; - return (bfd_target *) NULL; - } + 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; - return (bfd_target *) NULL; - } - /* Throw away the filename */ - read_id (&(ieee->h)); - /* This must be an IEEE archive, so we'll buy some space to do - things */ + goto got_wrong_format_error; - if (!obstack_begin (&ob, 128)) - { - bfd_set_error (bfd_error_no_memory); - return (bfd_target *) NULL; - } + /* 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)); - loop = true; - /* Read the index of the BB table */ - while (loop) + alc_elts = 10; + elts = (ieee_ar_obstack_type *) bfd_malloc (alc_elts * sizeof *elts); + if (elts == NULL) + goto error_return; + + /* Read the index of the BB table. */ + while (1) { - ieee_ar_obstack_type t; - int rec = read_2bytes (&(ieee->h)); - if (rec == (int) ieee_assign_value_to_variable_enum) + int rec; + ieee_ar_obstack_type *t; + + rec = read_2bytes (&(ieee->h)); + if (rec != (int) ieee_assign_value_to_variable_enum) + break; + + if (ieee->element_count >= alc_elts) { - must_parse_int (&(ieee->h)); - t.file_offset = must_parse_int (&(ieee->h)); - t.abfd = (bfd *) NULL; - ieee->element_count++; + ieee_ar_obstack_type *n; + + alc_elts *= 2; + n = ((ieee_ar_obstack_type *) + bfd_realloc (elts, alc_elts * sizeof *elts)); + if (n == NULL) + goto error_return; + elts = n; + } - obstack_grow (&ob, (PTR) & t, sizeof (t)); + t = &elts[ieee->element_count]; + ieee->element_count++; - /* Make sure that we don't go over the end of the buffer */ + must_parse_int (&(ieee->h)); + t->file_offset = must_parse_int (&(ieee->h)); + t->abfd = (bfd *) NULL; - if (ieee_pos (abfd) > sizeof (buffer) / 2) - { - /* Past half way, reseek and reprime */ - buffer_offset += ieee_pos (abfd); - bfd_seek (abfd, buffer_offset, SEEK_SET); - bfd_read ((PTR) buffer, 1, sizeof (buffer), abfd); - ieee->h.first_byte = buffer; - ieee->h.input_p = buffer; - } + /* 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 (IEEE_DATA (abfd)); + if (bfd_seek (abfd, buffer_offset, SEEK_SET) != 0) + goto error_return; + + /* Again ignore return value of bfd_bread. */ + bfd_bread ((PTR) buffer, (bfd_size_type) sizeof (buffer), abfd); + ieee->h.first_byte = buffer; + ieee->h.input_p = buffer; } - else - loop = false; } - ieee->elements = (ieee_ar_obstack_type *) obstack_finish (&ob); - if (!ieee->elements) - { - bfd_set_error (bfd_error_no_memory); - return (bfd_target *) NULL; - } + amt = ieee->element_count; + amt *= sizeof *ieee->elements; + ieee->elements = (ieee_ar_obstack_type *) bfd_alloc (abfd, amt); + if (ieee->elements == NULL) + goto error_return; - /* Now scan the area again, and replace BB offsets with file */ - /* offsets */ + memcpy (ieee->elements, elts, (size_t) amt); + free (elts); + elts = NULL; + /* Now scan the area again, and replace BB offsets with file offsets. */ for (i = 2; i < ieee->element_count; i++) { - bfd_seek (abfd, ieee->elements[i].file_offset, SEEK_SET); - bfd_read ((PTR) buffer, 1, sizeof (buffer), abfd); + if (bfd_seek (abfd, ieee->elements[i].file_offset, SEEK_SET) != 0) + goto error_return; + + /* Again ignore return value of bfd_bread. */ + bfd_bread ((PTR) 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 = ;*/ + /* abfd->has_armap = ;*/ + return abfd->xvec; -} -static boolean -ieee_mkobject (abfd) - bfd *abfd; -{ - abfd->tdata.ieee_data = (ieee_data_type *) bfd_zalloc (abfd, sizeof (ieee_data_type)); - return abfd->tdata.ieee_data ? true : false; + got_wrong_format_error: + bfd_release (abfd, ieee); + abfd->tdata.ieee_ar_data = save; + bfd_set_error (bfd_error_wrong_format); + + error_return: + if (elts != NULL) + free (elts); + + return NULL; } -bfd_target * +const bfd_target * ieee_object_p (abfd) bfd *abfd; { @@ -1190,18 +1550,21 @@ ieee_object_p (abfd) 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); - bfd_seek (abfd, (file_ptr) 0, SEEK_SET); - /* Read the first few bytes in to see if it makes sense */ - bfd_read ((PTR) buffer, 1, sizeof (buffer), 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 ((PTR) buffer, (bfd_size_type) sizeof (buffer), abfd); ieee->h.input_p = buffer; if (this_byte_and_next (&(ieee->h)) != Module_Beginning) - goto fail; + goto got_wrong_format; ieee->read_symbols = false; ieee->read_data = false; @@ -1211,22 +1574,86 @@ ieee_object_p (abfd) ieee->external_reference_min_index = IEEE_REFERENCE_BASE; ieee->external_reference_max_index = 0; ieee->h.abfd = abfd; - memset ((PTR) ieee->section_table, 0, sizeof (ieee->section_table)); + ieee->section_table = NULL; + ieee->section_table_size = 0; processor = ieee->mb.processor = read_id (&(ieee->h)); if (strcmp (processor, "LIBRARY") == 0) - goto fail; + goto got_wrong_format; ieee->mb.module_name = read_id (&(ieee->h)); - if (abfd->filename == (CONST char *) NULL) + if (abfd->filename == (const char *) NULL) { abfd->filename = ieee->mb.module_name; } /* Determine the architecture and machine type of the object file. */ { - bfd_arch_info_type *arch = bfd_scan_arch (processor); + 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')) + { + 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 ((strncmp (processor, "cpu32", 5) == 0) /* CPU32 and CPU32+ */ + || (strncmp (processor, "CPU32", 5) == 0)) + strcpy (family, "68332"); + else + { + strncpy (family, processor, 9); + family[9] = '\0'; + } + + arch = bfd_scan_arch (family); if (arch == 0) - goto fail; + goto got_wrong_format; abfd->arch_info = arch; } @@ -1269,33 +1696,50 @@ ieee_object_p (abfd) } } - 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 - + 50); + 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 = + (unsigned char *) bfd_alloc (ieee->h.abfd, amt); if (!IEEE_DATA (abfd)->h.first_byte) - { - bfd_set_error (bfd_error_no_memory); - goto fail; - } - bfd_seek (abfd, (file_ptr) 0, SEEK_SET); - bfd_read ((PTR) (IEEE_DATA (abfd)->h.first_byte), 1, ieee->w.r.me_record + 50, abfd); + 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 ((PTR) (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: (void) bfd_release (abfd, ieee); abfd->tdata.ieee_data = save; - return (bfd_target *) NULL; + return (const bfd_target *) NULL; } -void +static void ieee_get_symbol_info (ignore_abfd, symbol, ret) - bfd *ignore_abfd; + bfd *ignore_abfd ATTRIBUTE_UNUSED; asymbol *symbol; symbol_info *ret; { @@ -1306,9 +1750,9 @@ ieee_get_symbol_info (ignore_abfd, symbol, ret) ret->type = (symbol->flags & BSF_LOCAL) ? 'a' : 'A'; } -void -ieee_print_symbol (ignore_abfd, afile, symbol, how) - bfd *ignore_abfd; +static void +ieee_print_symbol (abfd, afile, symbol, how) + bfd *abfd; PTR afile; asymbol *symbol; bfd_print_symbol_type how; @@ -1329,22 +1773,22 @@ ieee_print_symbol (ignore_abfd, afile, symbol, how) break; case bfd_print_symbol_all: { - CONST char *section_name = symbol->section == (asection *) NULL ? - (CONST char *) "*abs" : symbol->section->name; + const char *section_name = + (symbol->section == (asection *) NULL + ? "*abs" + : symbol->section->name); if (symbol->name[0] == ' ') { fprintf (file, "* empty table entry "); } else { - bfd_print_symbol_vandf ((PTR) file, symbol); + bfd_print_symbol_vandf (abfd, (PTR) file, symbol); fprintf (file, " %-5s %04x %02x %s", section_name, (unsigned) ieee_symbol (symbol)->index, - (unsigned) 0, /* - aout_symbol(symbol)->desc & 0xffff, - aout_symbol(symbol)->other & 0xff,*/ + (unsigned) 0, symbol->name); } } @@ -1353,11 +1797,12 @@ ieee_print_symbol (ignore_abfd, afile, symbol, how) } static boolean -do_one (ieee, current_map, location_ptr, s) +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))) { @@ -1393,14 +1838,12 @@ do_one (ieee, current_map, location_ptr, s) unsigned int extra = 4; 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; + bfd_size_type amt = sizeof (ieee_reloc_type); + + r = (ieee_reloc_type *) bfd_alloc (ieee->h.abfd, amt); if (!r) - { - bfd_set_error (bfd_error_no_memory); - return false; - } + return false; *(current_map->reloc_tail_ptr) = r; current_map->reloc_tail_ptr = &r->next; @@ -1413,11 +1856,11 @@ do_one (ieee, current_map, location_ptr, s) &r->symbol, &pcrel, &extra, §ion); r->relent.address = current_map->pc; + s->flags |= SEC_RELOC; + s->owner->flags |= HAS_RELOC; s->reloc_count++; - if (r->relent.sym_ptr_ptr == 0) - { - r->relent.sym_ptr_ptr = section->symbol_ptr_ptr; - } + if (r->relent.sym_ptr_ptr == NULL && section != NULL) + r->relent.sym_ptr_ptr = section->symbol_ptr_ptr; if (this_byte (&(ieee->h)) == (int) ieee_comma) { @@ -1442,12 +1885,10 @@ do_one (ieee, current_map, location_ptr, s) } /* Build a relocation entry for this type */ /* If pc rel then stick -ve pc into instruction - and take out of reloc .. + and take out of reloc .. - I've changed this. It's all too - complicated. I keep 0 in the - instruction now. - */ + I've changed this. It's all too complicated. I + keep 0 in the instruction now. */ switch (extra) { @@ -1457,21 +1898,20 @@ do_one (ieee, current_map, location_ptr, s) if (pcrel == true) { #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; @@ -1480,19 +1920,22 @@ do_one (ieee, current_map, location_ptr, s) if (pcrel == true) { #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; @@ -1519,7 +1962,7 @@ do_one (ieee, current_map, location_ptr, s) default: BFD_FAIL (); - break; + return false; } } break; @@ -1541,6 +1984,11 @@ do_one (ieee, current_map, location_ptr, s) } } } + + /* Prevent more than the first load-item of an LR record + from being repeated (MRI convention). */ + if (iterations != 1) + loop = false; } } } @@ -1562,19 +2010,18 @@ ieee_slurp_section_data (abfd) if (ieee->read_data == true) return true; ieee->read_data = true; - ieee_seek (abfd, ieee->w.r.data_part); + 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; + if ((s->flags & SEC_DEBUGGING) != 0) + continue; per->data = (bfd_byte *) bfd_alloc (ieee->h.abfd, s->_raw_size); if (!per->data) - { - bfd_set_error (bfd_error_no_memory); - return false; - } + return false; /*SUPPRESS 68*/ per->reloc_tail_ptr = (ieee_reloc_type **) & (s->relocation); @@ -1592,6 +2039,7 @@ ieee_slurp_section_data (abfd) 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; location_ptr = current_map->data - s->vma; /* The document I have says that Microtec's compilers reset */ @@ -1611,7 +2059,7 @@ ieee_slurp_section_data (abfd) unsigned int extra; 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, @@ -1622,11 +2070,15 @@ ieee_slurp_section_data (abfd) break; case ieee_value_starting_address_enum & 0xff: + next_byte (&(ieee->h)); + 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; default: BFD_FAIL (); - return true; + return false; } break; case ieee_repeat_data_enum: @@ -1659,7 +2111,8 @@ ieee_slurp_section_data (abfd) while (iterations != 0) { ieee->h.input_p = start; - if (!do_one (ieee, current_map, location_ptr, s)) + if (!do_one (ieee, current_map, location_ptr, s, + (int) iterations)) return false; iterations--; } @@ -1669,35 +2122,34 @@ ieee_slurp_section_data (abfd) case ieee_load_constant_bytes_enum: case ieee_load_with_relocation_enum: { - if (!do_one (ieee, current_map, location_ptr, s)) + if (!do_one (ieee, current_map, location_ptr, s, 1)) return false; } } } } -boolean +static boolean ieee_new_section_hook (abfd, newsect) bfd *abfd; asection *newsect; { newsect->used_by_bfd = (PTR) - bfd_alloc (abfd, sizeof (ieee_per_section_type)); + bfd_alloc (abfd, (bfd_size_type) sizeof (ieee_per_section_type)); if (!newsect->used_by_bfd) - { - bfd_set_error (bfd_error_no_memory); - return false; - } + return false; ieee_per_section (newsect)->data = (bfd_byte *) NULL; ieee_per_section (newsect)->section = newsect; return true; } -long +static long ieee_get_reloc_upper_bound (abfd, asect) bfd *abfd; sec_ptr asect; { + if ((asect->flags & SEC_DEBUGGING) != 0) + return 0; if (! ieee_slurp_section_data (abfd)) return -1; return (asect->reloc_count + 1) * sizeof (arelent *); @@ -1712,12 +2164,15 @@ ieee_get_section_contents (abfd, section, location, offset, count) bfd_size_type count; { ieee_per_section_type *p = (ieee_per_section_type *) section->used_by_bfd; + 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; } -long +static long ieee_canonicalize_reloc (abfd, section, relptr, symbols) bfd *abfd; sec_ptr section; @@ -1728,18 +2183,26 @@ ieee_canonicalize_reloc (abfd, section, relptr, symbols) ieee_reloc_type *src = (ieee_reloc_type *) (section->relocation); ieee_data_type *ieee = IEEE_DATA (abfd); + if ((section->flags & SEC_DEBUGGING) != 0) + return 0; + while (src != (ieee_reloc_type *) NULL) { /* Work out which symbol to attach it this reloc to */ switch (src->symbol.letter) { + case 'I': + src->relent.sym_ptr_ptr = + symbols + src->symbol.index + ieee->external_symbol_base_offset; + break; case 'X': src->relent.sym_ptr_ptr = symbols + src->symbol.index + ieee->external_reference_base_offset; break; case 0: - src->relent.sym_ptr_ptr = - src->relent.sym_ptr_ptr[0]->section->symbol_ptr_ptr; + if (src->relent.sym_ptr_ptr != NULL) + src->relent.sym_ptr_ptr = + src->relent.sym_ptr_ptr[0]->section->symbol_ptr_ptr; break; default: @@ -1754,19 +2217,17 @@ ieee_canonicalize_reloc (abfd, section, relptr, symbols) static int comp (ap, bp) - CONST PTR ap; - CONST PTR bp; + const PTR ap; + const PTR bp; { arelent *a = *((arelent **) ap); arelent *b = *((arelent **) bp); return a->address - b->address; } -/* -Write the section headers -*/ +/* Write the section headers. */ -static void +static boolean ieee_write_section_part (abfd) bfd *abfd; { @@ -1775,68 +2236,87 @@ ieee_write_section_part (abfd) ieee->w.r.section_part = bfd_tell (abfd); for (s = abfd->sections; s != (asection *) NULL; s = s->next) { - if (s != &bfd_abs_section) + if (! bfd_is_abs_section (s) + && (s->flags & SEC_DEBUGGING) == 0) { - ieee_write_byte (abfd, ieee_section_type_enum); - ieee_write_byte (abfd, (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE)); + if (! ieee_write_byte (abfd, ieee_section_type_enum) + || ! ieee_write_byte (abfd, + (bfd_byte) (s->index + + IEEE_SECTION_NUMBER_BASE))) + return false; if (abfd->flags & EXEC_P) { /* This image is executable, so output absolute sections */ - ieee_write_byte (abfd, ieee_variable_A_enum); - ieee_write_byte (abfd, ieee_variable_S_enum); + if (! ieee_write_byte (abfd, ieee_variable_A_enum) + || ! ieee_write_byte (abfd, ieee_variable_S_enum)) + return false; } else { - ieee_write_byte (abfd, ieee_variable_C_enum); + if (! ieee_write_byte (abfd, ieee_variable_C_enum)) + return false; } switch (s->flags & (SEC_CODE | SEC_DATA | SEC_ROM)) { case SEC_CODE | SEC_LOAD: case SEC_CODE: - ieee_write_byte (abfd, ieee_variable_P_enum); + if (! ieee_write_byte (abfd, ieee_variable_P_enum)) + return false; break; case SEC_DATA: default: - ieee_write_byte (abfd, ieee_variable_D_enum); + if (! ieee_write_byte (abfd, ieee_variable_D_enum)) + return false; break; case SEC_ROM: case SEC_ROM | SEC_DATA: case SEC_ROM | SEC_LOAD: case SEC_ROM | SEC_DATA | SEC_LOAD: - - ieee_write_byte (abfd, ieee_variable_R_enum); + if (! ieee_write_byte (abfd, ieee_variable_R_enum)) + return false; } - ieee_write_id (abfd, s->name); + 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 */ - 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); + 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, (bfd_vma) 1 << s->alignment_power)) + return false; /* Size */ - 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); + 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; if (abfd->flags & EXEC_P) { /* Relocateable sections don't have asl records */ /* Vma */ - ieee_write_2bytes (abfd, ieee_section_base_address_enum); - ieee_write_byte (abfd, - (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE)); - ieee_write_int (abfd, s->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 true; } @@ -1845,11 +2325,11 @@ do_with_relocs (abfd, s) bfd *abfd; asection *s; { + unsigned int number_of_maus_in_address = + bfd_arch_bits_per_address (abfd) / bfd_arch_bits_per_byte (abfd); unsigned int relocs_to_go = s->reloc_count; - bfd_byte *stream = ieee_per_section (s)->data; arelent **p = s->orelocation; - bfd_size_type current_byte_index = 0; qsort (s->orelocation, @@ -1858,22 +2338,34 @@ do_with_relocs (abfd, s) comp); /* Output the section preheader */ - ieee_write_byte (abfd, ieee_set_current_section_enum); - ieee_write_byte (abfd, (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE)); - - ieee_write_twobyte (abfd, ieee_set_current_pc_enum); - ieee_write_byte (abfd, (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE)); - ieee_write_expression (abfd, 0, s->symbol, 0, 0); + 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; + + if ((abfd->flags & EXEC_P) != 0 && relocs_to_go == 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 (relocs_to_go == 0) { - /* If there arn't any relocations then output the load constant byte - opcode rather than the load with relocation opcode */ + /* 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) { bfd_size_type run; - unsigned int MAXRUN = 32; + unsigned int MAXRUN = 127; run = MAXRUN; if (run > s->_raw_size - current_byte_index) { @@ -1882,44 +2374,44 @@ do_with_relocs (abfd, s) if (run != 0) { - ieee_write_byte (abfd, ieee_load_constant_bytes_enum); + if (! ieee_write_byte (abfd, ieee_load_constant_bytes_enum)) + return false; /* Output a stream of bytes */ - ieee_write_int (abfd, run); - bfd_write ((PTR) (stream + current_byte_index), - 1, - run, - abfd); + if (! ieee_write_int (abfd, run)) + return false; + if (bfd_bwrite ((PTR) (stream + current_byte_index), run, abfd) + != run) + return false; current_byte_index += run; } } } else { - ieee_write_byte (abfd, ieee_load_with_relocation_enum); - + if (! ieee_write_byte (abfd, ieee_load_with_relocation_enum)) + return false; /* Output the data stream as the longest sequence of bytes - possible, allowing for the a reasonable packet size and - relocation stuffs */ + possible, allowing for the a reasonable packet size and + relocation stuffs. */ if ((PTR) stream == (PTR) NULL) { /* Outputting a section without data, fill it up */ stream = (unsigned char *) (bfd_alloc (abfd, s->_raw_size)); if (!stream) - { - bfd_set_error (bfd_error_no_memory); - return false; - } - memset ((PTR) stream, 0, s->_raw_size); + return false; + memset ((PTR) stream, 0, (size_t) s->_raw_size); } while (current_byte_index < s->_raw_size) { bfd_size_type run; - unsigned int MAXRUN = 32; + unsigned int MAXRUN = 127; if (relocs_to_go) { run = (*p)->address - current_byte_index; + if (run > MAXRUN) + run = MAXRUN; } else { @@ -1933,21 +2425,21 @@ do_with_relocs (abfd, s) if (run != 0) { /* Output a stream of bytes */ - ieee_write_int (abfd, run); - bfd_write ((PTR) (stream + current_byte_index), - 1, - run, - abfd); + if (! ieee_write_int (abfd, run)) + return false; + if (bfd_bwrite ((PTR) (stream + current_byte_index), run, abfd) + != run) + return false; current_byte_index += run; } /* Output any relocations here */ if (relocs_to_go && (*p) && (*p)->address == current_byte_index) { - while (relocs_to_go && (*p) && (*p)->address == current_byte_index) + while (relocs_to_go + && (*p) && (*p)->address == current_byte_index) { - arelent *r = *p; - bfd_vma ov; + bfd_signed_vma ov; #if 0 if (r->howto->pc_relative) @@ -1960,47 +2452,65 @@ do_with_relocs (abfd, s) { case 2: - ov = bfd_get_32 (abfd, - stream + current_byte_index); + ov = bfd_get_signed_32 (abfd, + stream + current_byte_index); current_byte_index += 4; break; case 1: - ov = bfd_get_16 (abfd, - stream + current_byte_index); + ov = bfd_get_signed_16 (abfd, + stream + current_byte_index); current_byte_index += 2; break; case 0: - ov = bfd_get_8 (abfd, - stream + current_byte_index); + ov = bfd_get_signed_8 (abfd, + stream + current_byte_index); current_byte_index++; break; default: ov = 0; BFD_FAIL (); + return false; } - ieee_write_byte (abfd, ieee_function_either_open_b_enum); -/* abort();*/ + + ov &= r->howto->src_mask; + + if (r->howto->pc_relative + && ! r->howto->pcrel_offset) + ov += r->address; + + if (! ieee_write_byte (abfd, + ieee_function_either_open_b_enum)) + return false; + +/* abort();*/ if (r->sym_ptr_ptr != (asymbol **) NULL) { - ieee_write_expression (abfd, r->addend + ov, - *(r->sym_ptr_ptr), - r->howto->pc_relative, s->index); + if (! ieee_write_expression (abfd, r->addend + ov, + *(r->sym_ptr_ptr), + r->howto->pc_relative, + (unsigned) s->index)) + return false; } else { - ieee_write_expression (abfd, r->addend + ov, - (asymbol *) NULL, - r->howto->pc_relative, s->index); + if (! ieee_write_expression (abfd, r->addend + ov, + (asymbol *) NULL, + r->howto->pc_relative, + (unsigned) s->index)) + return false; } - if (1 || r->howto->size != 2) + if (number_of_maus_in_address + != bfd_get_reloc_size (r->howto)) { - ieee_write_byte (abfd, ieee_comma); - ieee_write_int (abfd, 1 << r->howto->size); + bfd_vma rsize = bfd_get_reloc_size (r->howto); + if (! ieee_write_int (abfd, rsize)) + return false; } - ieee_write_byte (abfd, - ieee_function_either_close_b_enum); + if (! ieee_write_byte (abfd, + ieee_function_either_close_b_enum)) + return false; relocs_to_go--; p++; @@ -2009,36 +2519,55 @@ do_with_relocs (abfd, s) } } } + 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 */ +/* If there are no relocations in the output section then we can be + clever about how we write. We block items up into a max of 127 + bytes. */ -static void +static boolean do_as_repeat (abfd, s) bfd *abfd; asection *s; { if (s->_raw_size) { - ieee_write_byte (abfd, ieee_set_current_section_enum); - ieee_write_byte (abfd, (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE)); - ieee_write_byte (abfd, ieee_set_current_pc_enum >> 8); - ieee_write_byte (abfd, ieee_set_current_pc_enum & 0xff); - ieee_write_byte (abfd, (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE)); - ieee_write_int (abfd, s->vma); + if (! ieee_write_byte (abfd, ieee_set_current_section_enum) + || ! ieee_write_byte (abfd, + (bfd_byte) (s->index + + IEEE_SECTION_NUMBER_BASE)) + || ! ieee_write_byte (abfd, ieee_set_current_pc_enum >> 8) + || ! ieee_write_byte (abfd, ieee_set_current_pc_enum & 0xff) + || ! ieee_write_byte (abfd, + (bfd_byte) (s->index + + 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; + } - ieee_write_byte (abfd, ieee_repeat_data_enum); - ieee_write_int (abfd, s->_raw_size); - ieee_write_byte (abfd, ieee_load_constant_bytes_enum); - ieee_write_byte (abfd, 1); - ieee_write_byte (abfd, 0); + if (! ieee_write_byte (abfd, ieee_repeat_data_enum) + || ! ieee_write_int (abfd, s->_raw_size) + || ! ieee_write_byte (abfd, ieee_load_constant_bytes_enum) + || ! ieee_write_byte (abfd, 1) + || ! ieee_write_byte (abfd, 0)) + return false; } + + return true; } -static void +static boolean do_without_relocs (abfd, s) bfd *abfd; asection *s; @@ -2047,7 +2576,8 @@ do_without_relocs (abfd, s) if (stream == 0 || ((s->flags & SEC_LOAD) == 0)) { - do_as_repeat (abfd, s); + if (! do_as_repeat (abfd, s)) + return false; } else { @@ -2056,13 +2586,16 @@ do_without_relocs (abfd, s) { if (stream[i] != 0) { - do_with_relocs (abfd, s); - return; + if (! do_with_relocs (abfd, s)) + return false; + return true; } } - do_as_repeat (abfd, s); + if (! do_as_repeat (abfd, s)) + return false; } + return true; } @@ -2076,16 +2609,42 @@ static bfd *input_bfd; static bfd *output_bfd; static int output_buffer; +static boolean +ieee_mkobject (abfd) + bfd *abfd; +{ + 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 = (ieee_data_type *) bfd_zalloc (abfd, amt); + return abfd->tdata.ieee_data ? true : false; +} + static void fill () { - bfd_read ((PTR) input_ptr_start, 1, input_ptr_end - input_ptr_start, input_bfd); + 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_bread ((PTR) input_ptr_start, amt, input_bfd); input_ptr = input_ptr_start; } + static void flush () { - bfd_write ((PTR) (output_ptr_start), 1, output_ptr - output_ptr_start, output_bfd); + bfd_size_type amt = output_ptr - output_ptr_start; + if (bfd_bwrite ((PTR) (output_ptr_start), amt, output_bfd) != amt) + abort (); output_ptr = output_ptr_start; output_buffer++; } @@ -2159,7 +2718,7 @@ copy_expression () { int stack[10]; int *tos = stack; - int value = 0; + int value; while (1) { switch (THIS ()) @@ -2213,16 +2772,13 @@ copy_expression () } *tos++ = THIS (); NEXT (); - value = 0; break; case 0xa5: /* PLUS anything */ - { - int value = *(--tos); - value += *(--tos); - *tos++ = value; - NEXT (); - } + value = *(--tos); + value += *(--tos); + *tos++ = value; + NEXT (); break; case VAR ('R'): { @@ -2235,17 +2791,11 @@ copy_expression () NEXT (); ieee = IEEE_DATA (input_bfd); s = ieee->section_table[section_number]; + value = 0; if (s->output_section) - { - value = s->output_section->vma; - } - else - { - value = 0; - } + value = s->output_section->lma; value += s->output_offset; *tos++ = value; - value = 0; } break; case 0x90: @@ -2254,22 +2804,14 @@ 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; -}; - static void fill_int (buf) struct output_buffer_struct *buf; @@ -2357,7 +2899,6 @@ 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() @@ -2523,7 +3064,6 @@ f2_record () } -static void block (); static void f8_record () { @@ -2722,7 +3262,7 @@ block () static void relocate_debug (output, input) - bfd *output; + bfd *output ATTRIBUTE_UNUSED; bfd *input; { #define IBS 400 @@ -2732,76 +3272,46 @@ relocate_debug (output, input) input_ptr_start = input_ptr = input_buffer; input_ptr_end = input_buffer + IBS; input_bfd = input; - bfd_read ((PTR) input_ptr_start, 1, IBS, input); + /* FIXME: Check return value. I'm not sure whether it needs to read + the entire buffer or not. */ + bfd_bread ((PTR) input_ptr_start, (bfd_size_type) IBS, input); block (); } -/* - During linking, we we told about the bfds which made up our - contents, we have a list of them. They will still be open, so go to - the debug info in each, and copy it out, relocating it as we go. -*/ +/* Gather together all the debug information from each input BFD into + one place, relocating it and emitting it as we go. */ -static void +static boolean ieee_write_debug_part (abfd) bfd *abfd; { ieee_data_type *ieee = IEEE_DATA (abfd); bfd_chain_type *chain = ieee->chain_root; - unsigned char output_buffer[OBS]; + unsigned char obuff[OBS]; boolean some_debug = false; file_ptr here = bfd_tell (abfd); - output_ptr_start = output_ptr = output_buffer; - output_ptr_end = output_buffer + OBS; - output_ptr = output_buffer; + output_ptr_start = output_ptr = obuff; + output_ptr_end = obuff + OBS; + output_ptr = obuff; output_bfd = abfd; if (chain == (bfd_chain_type *) NULL) { -#if 0 - /* There is no debug info, so we'll fake some up */ - CONST static char fake[] = - { - 0xf8, 0xa, 0, 5, 't', 't', 't', 't', 't', 0, 2, 3, - '1', '.', '1', 0x82, 1991 >> 8, 1991 & 0xff, 9, 20, 11, 07, 50}; - ieee->w.r.debug_information_part = 0; - - - here; - + asection *s; - /* bfd_write(fake, 1, sizeof(fake), abfd);*/ - /* Now write a header for each section */ - { - int i = 0; - asection *s = abfd->sections; - while (s) - { - if (s != abfd->abs_section) - { - - ieee_write_byte (abfd, 0xf8); - ieee_write_byte (abfd, 0x0b); - ieee_write_byte (abfd, 0); - ieee_write_byte (abfd, 0); - ieee_write_byte (abfd, 1); - ieee_write_byte (abfd, i + IEEE_SECTION_NUMBER_BASE); - ieee_write_expression (abfd, 0, s->symbol, 0, 0, 0); - ieee_write_byte (abfd, 0); - ieee_write_byte (abfd, 0xf9); - ieee_write_expression (abfd, s->size, - bfd_abs_section.symbol, 0, 0, 0); - i++; - } - - s = s->next; + for (s = abfd->sections; s != NULL; s = s->next) + if ((s->flags & SEC_DEBUGGING) != 0) + break; + if (s == NULL) + { + ieee->w.r.debug_information_part = 0; + return true; + } - } - /* Close the scope */ - ieee_write_byte (abfd, 0xf9); - } -#endif + ieee->w.r.debug_information_part = here; + if (bfd_bwrite (s->contents, s->_raw_size, abfd) != s->_raw_size) + return false; } else { @@ -2811,7 +3321,9 @@ ieee_write_debug_part (abfd) ieee_data_type *entry_ieee = IEEE_DATA (entry); if (entry_ieee->w.r.debug_information_part) { - bfd_seek (entry, entry_ieee->w.r.debug_information_part, SEEK_SET); + if (bfd_seek (entry, entry_ieee->w.r.debug_information_part, + SEEK_SET) != 0) + return false; relocate_debug (abfd, entry); } @@ -2825,13 +3337,16 @@ ieee_write_debug_part (abfd) { ieee->w.r.debug_information_part = 0; } + + flush (); } - flush (); + return true; } -/* write the data in an ieee way */ -static void +/* Write the data in an ieee way. */ + +static boolean ieee_write_data_part (abfd) bfd *abfd; { @@ -2840,17 +3355,26 @@ ieee_write_data_part (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, + debugging, etc.) */ + if ((s->flags & SEC_LOAD) == 0) + continue; + /* Sort the reloc records so we can insert them in the correct - places */ + places */ if (s->reloc_count != 0) { - do_with_relocs (abfd, s); + if (! do_with_relocs (abfd, s)) + return false; } else { - do_without_relocs (abfd, s); + if (! do_without_relocs (abfd, s)) + return false; } } + + return true; } @@ -2861,14 +3385,14 @@ init_for_output (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) { - ieee_per_section (s)->data = (bfd_byte *) (bfd_alloc (abfd, s->_raw_size)); + bfd_size_type size = s->_raw_size; + ieee_per_section (s)->data = (bfd_byte *) (bfd_alloc (abfd, size)); if (!ieee_per_section (s)->data) - { - bfd_set_error (bfd_error_no_memory); - return false; - } + return false; } } return true; @@ -2879,7 +3403,7 @@ init_for_output (abfd) /* set section contents is complicated with IEEE since the format is * not a byte image, but a record stream. */ -boolean +static boolean ieee_set_section_contents (abfd, section, location, offset, count) bfd *abfd; sec_ptr section; @@ -2887,6 +3411,21 @@ ieee_set_section_contents (abfd, section, location, offset, count) file_ptr offset; bfd_size_type count; { + if ((section->flags & SEC_DEBUGGING) != 0) + { + if (section->contents == NULL) + { + bfd_size_type size = section->_raw_size; + section->contents = (unsigned char *) bfd_alloc (abfd, size); + if (section->contents == NULL) + return false; + } + /* bfd_set_section_contents has already checked that everything + is within range. */ + memcpy (section->contents + offset, location, (size_t) count); + return true; + } + if (ieee_per_section (section)->data == (bfd_byte *) NULL) { if (!init_for_output (abfd)) @@ -2898,13 +3437,12 @@ ieee_set_section_contents (abfd, section, location, offset, count) return true; } -/* -write the external symbols of a file, IEEE considers two sorts of -external symbols, public, and referenced. It uses to internal forms -to index them as well. When we write them out we turn their symbol -values into indexes from the right base. -*/ -static void +/* Write the external symbols of a file. IEEE considers two sorts of + external symbols, public, and referenced. It uses to internal + 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; { @@ -2921,75 +3459,84 @@ ieee_write_external_part (abfd) for (q = abfd->outsymbols; *q != (asymbol *) NULL; q++) { asymbol *p = *q; - hadone = true; - if (p->section == &bfd_und_section) + if (bfd_is_und_section (p->section)) { /* This must be a symbol reference .. */ - ieee_write_byte (abfd, ieee_external_reference_enum); - ieee_write_int (abfd, reference_index); - ieee_write_id (abfd, p->name); + if (! ieee_write_byte (abfd, ieee_external_reference_enum) + || ! ieee_write_int (abfd, (bfd_vma) reference_index) + || ! ieee_write_id (abfd, p->name)) + return false; p->value = reference_index; reference_index++; + hadone = true; } else if (bfd_is_com_section (p->section)) { /* This is a weak reference */ - ieee_write_byte (abfd, ieee_external_reference_enum); - ieee_write_int (abfd, 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, p->value); - ieee_write_int (abfd, BFD_FORT_COMM_DEFAULT_VALUE); + if (! ieee_write_byte (abfd, ieee_external_reference_enum) + || ! 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, (bfd_vma) reference_index) + || ! ieee_write_int (abfd, p->value)) + return false; p->value = reference_index; reference_index++; + hadone = true; } else if (p->flags & BSF_GLOBAL) { /* This must be a symbol definition */ - - ieee_write_byte (abfd, ieee_external_symbol_enum); - ieee_write_int (abfd, public_index); - ieee_write_id (abfd, p->name); - - ieee_write_twobyte (abfd, ieee_attribute_record_enum); - ieee_write_int (abfd, public_index); - ieee_write_byte (abfd, 15); /* instruction address */ - ieee_write_byte (abfd, 19); /* static symbol */ - ieee_write_byte (abfd, 1); /* one of them */ - + if (! ieee_write_byte (abfd, ieee_external_symbol_enum) + || ! 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, (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 */ - ieee_write_2bytes (abfd, ieee_value_record_enum); - ieee_write_int (abfd, public_index); - if (p->section != &bfd_abs_section) + if (! ieee_write_2bytes (abfd, ieee_value_record_enum) + || ! 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 */ - ieee_write_int (abfd, - p->value + p->section->output_offset + p->section->output_section->vma); - + relocated */ + if (! (ieee_write_int + (abfd, + (p->value + + p->section->output_offset + + p->section->output_section->vma)))) + return false; } else { - ieee_write_expression (abfd, - p->value + p->section->output_offset, - p->section->output_section->symbol - ,false, 0); + if (! (ieee_write_expression + (abfd, + p->value + p->section->output_offset, + p->section->output_section->symbol, + false, 0))) + return false; } } else { - ieee_write_expression (abfd, - p->value, - bfd_abs_section.symbol, - false, 0); + if (! ieee_write_expression (abfd, + p->value, + bfd_abs_section_ptr->symbol, + false, 0)) + return false; } p->value = public_index; public_index++; + hadone = true; } else { @@ -3001,10 +3548,11 @@ ieee_write_external_part (abfd) if (hadone) ieee->w.r.external_part = here; + 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 */ @@ -3012,7 +3560,7 @@ static CONST unsigned char exten[] = 0xf1, 0xce, 0x20, 0x00, 38 /* set object type relocateable to x */ }; -static CONST unsigned char envi[] = +static const unsigned char envi[] = { 0xf0, 0x21, 0x00, @@ -3025,8 +3573,7 @@ static CONST unsigned char envi[] = /* 0xf1, 0xce, 0x21, 0, 54, 2,1,1 tool & version # */ }; -static -void +static boolean ieee_write_me_part (abfd) bfd *abfd; { @@ -3034,121 +3581,240 @@ ieee_write_me_part (abfd) ieee->w.r.trailer_part = bfd_tell (abfd); if (abfd->start_address) { - ieee->w.r.me_record = bfd_tell (abfd); - ieee_write_2bytes (abfd, ieee_value_starting_address_enum); - ieee_write_byte (abfd, ieee_function_either_open_b_enum); - ieee_write_int (abfd, abfd->start_address); - ieee_write_byte (abfd, ieee_function_either_close_b_enum); + if (! ieee_write_2bytes (abfd, ieee_value_starting_address_enum) + || ! ieee_write_byte (abfd, ieee_function_either_open_b_enum) + || ! ieee_write_int (abfd, abfd->start_address) + || ! ieee_write_byte (abfd, ieee_function_either_close_b_enum)) + return false; } - else + ieee->w.r.me_record = bfd_tell (abfd); + if (! ieee_write_byte (abfd, ieee_module_end_enum)) + return false; + return true; +} + +/* Write out the IEEE processor ID. */ + +static boolean +ieee_write_processor (abfd) + bfd *abfd; +{ + const bfd_arch_info_type *arch; + + arch = bfd_get_arch_info (abfd); + switch (arch->arch) { - ieee->w.r.me_record = bfd_tell (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; + break; + + case bfd_arch_h8300: + if (! ieee_write_id (abfd, "H8/300")) + return false; + break; + + case bfd_arch_h8500: + if (! ieee_write_id (abfd, "H8/500")) + return false; + break; + + case bfd_arch_i960: + switch (arch->mach) + { + default: + case bfd_mach_i960_core: + case bfd_mach_i960_ka_sa: + if (! ieee_write_id (abfd, "80960KA")) + return false; + break; + + case bfd_mach_i960_kb_sb: + if (! ieee_write_id (abfd, "80960KB")) + return false; + break; + + case bfd_mach_i960_ca: + if (! ieee_write_id (abfd, "80960CA")) + return false; + break; + + case bfd_mach_i960_mc: + case bfd_mach_i960_xa: + if (! ieee_write_id (abfd, "80960MC")) + return false; + break; + } + break; + + case bfd_arch_m68k: + { + const char *id; + + switch (arch->mach) + { + default: id = "68020"; break; + case bfd_mach_m68000: id = "68000"; break; + case bfd_mach_m68008: id = "68008"; break; + case bfd_mach_m68010: id = "68010"; break; + case bfd_mach_m68020: id = "68020"; break; + case bfd_mach_m68030: id = "68030"; break; + case bfd_mach_m68040: id = "68040"; break; + case bfd_mach_m68060: id = "68060"; break; + case bfd_mach_cpu32: id = "cpu32"; break; + case bfd_mach_mcf5200:id = "5200"; break; + case bfd_mach_mcf5206e:id = "5206e"; break; + case bfd_mach_mcf5307:id = "5307"; break; + case bfd_mach_mcf5407:id = "5407"; break; + } + + if (! ieee_write_id (abfd, id)) + return false; + } + break; } - ieee_write_byte (abfd, ieee_module_end_enum); + return true; } -boolean +static boolean ieee_write_object_contents (abfd) bfd *abfd; { ieee_data_type *ieee = IEEE_DATA (abfd); unsigned int i; file_ptr old; + /* Fast forward over the header area */ - bfd_seek (abfd, (file_ptr) 0, SEEK_SET); - ieee_write_byte (abfd, ieee_module_beginning_enum); + if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) + return false; - ieee_write_id (abfd, bfd_printable_name (abfd)); - ieee_write_id (abfd, abfd->filename); + if (! ieee_write_byte (abfd, ieee_module_beginning_enum) + || ! ieee_write_processor (abfd) + || ! ieee_write_id (abfd, abfd->filename)) + return false; /* Fast forward over the variable bits */ - ieee_write_byte (abfd, ieee_address_descriptor_enum); + if (! ieee_write_byte (abfd, ieee_address_descriptor_enum)) + return false; /* Bits per MAU */ - ieee_write_byte (abfd, (bfd_byte) (bfd_arch_bits_per_byte (abfd))); + if (! ieee_write_byte (abfd, (bfd_byte) (bfd_arch_bits_per_byte (abfd)))) + return false; /* MAU's per address */ - ieee_write_byte (abfd, - (bfd_byte) (bfd_arch_bits_per_address (abfd) / bfd_arch_bits_per_byte (abfd))); + if (! ieee_write_byte (abfd, + (bfd_byte) (bfd_arch_bits_per_address (abfd) + / bfd_arch_bits_per_byte (abfd)))) + return false; old = bfd_tell (abfd); - bfd_seek (abfd, (file_ptr) (8 * N_W_VARIABLES), SEEK_CUR); + if (bfd_seek (abfd, (file_ptr) (8 * N_W_VARIABLES), SEEK_CUR) != 0) + return false; ieee->w.r.extension_record = bfd_tell (abfd); - bfd_write ((char *) exten, 1, sizeof (exten), abfd); + if (bfd_bwrite ((char *) exten, (bfd_size_type) sizeof (exten), abfd) + != sizeof (exten)) + return false; if (abfd->flags & EXEC_P) - ieee_write_byte (abfd, 0x1);/* Absolute */ + { + if (! ieee_write_byte (abfd, 0x1)) /* Absolute */ + return false; + } else - ieee_write_byte (abfd, 0x2);/* Relocateable */ + { + if (! ieee_write_byte (abfd, 0x2)) /* Relocateable */ + return false; + } ieee->w.r.environmental_record = bfd_tell (abfd); - bfd_write ((char *) envi, 1, sizeof (envi), abfd); + 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. */ + { + time_t now; + const struct tm *t; + + time (&now); + t = (struct tm *) localtime (&now); + if (! ieee_write_2bytes (abfd, (int) ieee_atn_record_enum) + || ! ieee_write_byte (abfd, 0x21) + || ! ieee_write_byte (abfd, 0) + || ! ieee_write_byte (abfd, 50) + || ! 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; - flush (); - ieee_write_section_part (abfd); - /* - First write the symbols, this changes their values into table - indeces so we cant use it after this point - */ - ieee_write_external_part (abfd); - /* ieee_write_byte(abfd, ieee_record_seperator_enum);*/ + flush (); + if (! ieee_write_section_part (abfd)) + 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);*/ - /* - Write any debugs we have been told about - */ - ieee_write_debug_part (abfd); - - /* - Can only write the data once the symbols have been written since - the data contains relocation information which points to the - symbols - */ - ieee_write_data_part (abfd); + /* Write any debugs we have been told about. */ + if (! ieee_write_debug_part (abfd)) + return false; - /* - At the end we put the end ! - */ - ieee_write_me_part (abfd); + /* 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; + /* At the end we put the end! */ + if (! ieee_write_me_part (abfd)) + return false; /* Generate the header */ - bfd_seek (abfd, old, SEEK_SET); + if (bfd_seek (abfd, old, SEEK_SET) != 0) + return false; for (i = 0; i < N_W_VARIABLES; i++) { - 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]); + if (! ieee_write_2bytes (abfd, ieee_assign_value_to_variable_enum) + || ! ieee_write_byte (abfd, (bfd_byte) i) + || ! ieee_write_int5_out (abfd, (bfd_vma) ieee->w.offset[i])) + return false; } + return true; } - - /* 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. */ + function exits. We read the strings into a buffer large enough to + hold them all plus all the cached symbol entries. */ -asymbol * +static asymbol * ieee_make_empty_symbol (abfd) bfd *abfd; { - - ieee_symbol_type *new = - (ieee_symbol_type *) bfd_zmalloc (sizeof (ieee_symbol_type)); + bfd_size_type amt = sizeof (ieee_symbol_type); + ieee_symbol_type *new = (ieee_symbol_type *) bfd_zalloc (abfd, amt); if (!new) - { - bfd_set_error (bfd_error_no_error); - return NULL; - } + return NULL; new->symbol.the_bfd = abfd; return &new->symbol; } @@ -3191,20 +3857,15 @@ ieee_openr_next_archived_file (arch, prev) } static boolean -ieee_find_nearest_line (abfd, - section, - symbols, - offset, - filename_ptr, - functionname_ptr, - line_ptr) - bfd *abfd; - asection *section; - asymbol **symbols; - bfd_vma offset; - char **filename_ptr; - char **functionname_ptr; - int *line_ptr; +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; { return false; } @@ -3214,29 +3875,45 @@ ieee_generic_stat_arch_elt (abfd, buf) bfd *abfd; struct stat *buf; { - ieee_ar_data_type *ar = abfd->my_archive->tdata.ieee_ar_data; + ieee_ar_data_type *ar = (ieee_ar_data_type *) NULL; + ieee_data_type *ieee; + + if (abfd->my_archive != NULL) + ar = abfd->my_archive->tdata.ieee_ar_data; if (ar == (ieee_ar_data_type *) NULL) { bfd_set_error (bfd_error_invalid_operation); return -1; } - else + + if (IEEE_DATA (abfd) == NULL) { - buf->st_size = 0x1; - buf->st_mode = 0666; - return !ieee_object_p (abfd); + if (ieee_object_p (abfd) == NULL) + { + bfd_set_error (bfd_error_wrong_format); + return -1; + } } + + ieee = IEEE_DATA (abfd); + + buf->st_size = ieee->w.r.me_record + 1; + buf->st_mode = 0644; + return 0; } static int ieee_sizeof_headers (abfd, x) - bfd *abfd; - boolean x; + bfd *abfd ATTRIBUTE_UNUSED; + boolean x ATTRIBUTE_UNUSED; { return 0; } +/* The debug info routines are never used. */ +#if 0 + static void ieee_bfd_debug_info_start (abfd) bfd *abfd; @@ -3277,12 +3954,10 @@ ieee_bfd_debug_info_accumulate (abfd, section) /* Add to chain */ { - bfd_chain_type *n = (bfd_chain_type *) bfd_alloc (abfd, sizeof (bfd_chain_type)); + bfd_size_type amt = sizeof (bfd_chain_type); + bfd_chain_type *n = (bfd_chain_type *) bfd_alloc (abfd, amt); if (!n) - { - bfd_set_error (bfd_error_no_memory); - abort (); /* FIXME */ - } + abort (); /* FIXME */ n->this = section->owner; n->next = (bfd_chain_type *) NULL; @@ -3299,50 +3974,63 @@ ieee_bfd_debug_info_accumulate (abfd, section) } } +#endif + +#define ieee_close_and_cleanup _bfd_generic_close_and_cleanup +#define ieee_bfd_free_cached_info _bfd_generic_bfd_free_cached_info -#define FOO PROTO -#define ieee_core_file_failing_command (char *(*)())(bfd_nullvoidptr) -#define ieee_core_file_failing_signal (int (*)())bfd_0 -#define ieee_core_file_matches_executable_p ( FOO(boolean, (*),(bfd *, bfd *)))bfd_false #define ieee_slurp_armap bfd_true #define ieee_slurp_extended_name_table bfd_true -#define ieee_truncate_arname (void (*)())bfd_nullvoidptr -#define ieee_write_armap (FOO( boolean, (*),(bfd *, unsigned int, struct orl *, unsigned int, int))) bfd_nullvoidptr -#define ieee_get_lineno (struct lineno_cache_entry *(*)())bfd_nullvoidptr -#define ieee_close_and_cleanup bfd_generic_close_and_cleanup -#define ieee_set_arch_mach bfd_default_set_arch_mach -#define ieee_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents +#define ieee_construct_extended_name_table \ + ((boolean (*) PARAMS ((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_true) +#define ieee_read_ar_hdr bfd_nullvoidptr +#define ieee_update_armap_timestamp bfd_true +#define ieee_get_elt_at_index _bfd_generic_get_elt_at_index + +#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 +#define ieee_read_minisymbols _bfd_generic_read_minisymbols +#define ieee_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol + +#define ieee_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup + +#define ieee_set_arch_mach _bfd_generic_set_arch_mach + +#define ieee_get_section_contents_in_window \ + _bfd_generic_get_section_contents_in_window +#define ieee_bfd_get_relocated_section_contents \ + bfd_generic_get_relocated_section_contents #define ieee_bfd_relax_section bfd_generic_relax_section -#define ieee_bfd_reloc_type_lookup \ - ((CONST struct reloc_howto_struct *(*) PARAMS ((bfd *, bfd_reloc_code_real_type))) bfd_nullvoidptr) -#define ieee_bfd_make_debug_symbol \ - ((asymbol *(*) PARAMS ((bfd *, void *, unsigned long))) bfd_nullvoidptr) +#define ieee_bfd_gc_sections bfd_generic_gc_sections +#define ieee_bfd_merge_sections bfd_generic_merge_sections #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_final_link _bfd_generic_final_link -#define ieee_bfd_copy_private_section_data \ - ((boolean (*) PARAMS ((bfd *, asection *, bfd *, asection *))) bfd_true) -#define ieee_bfd_copy_private_bfd_data \ - ((boolean (*) PARAMS ((bfd *, bfd *))) bfd_true) -#define ieee_bfd_is_local_label bfd_generic_is_local_label -#define ieee_bfd_free_cached_info bfd_true +#define ieee_bfd_link_split_section _bfd_generic_link_split_section /*SUPPRESS 460 */ -bfd_target ieee_vec = +const bfd_target ieee_vec = { "ieee", /* name */ bfd_target_ieee_flavour, - true, /* target byte order */ - true, /* target headers byte order */ + 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 */ - 0, /* leading underscore */ + '_', /* leading underscore */ ' ', /* ar_pad_char */ 16, /* ar_max_namelen */ - 1, /* minimum alignment */ 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 */ @@ -3367,6 +4055,45 @@ bfd_target ieee_vec = _bfd_write_archive_contents, bfd_false, }, - JUMP_TABLE (ieee), + + /* 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_get_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 };