2001-08-23 H.J. Lu <hjl@gnu.org>

[deliverable/binutils-gdb.git] / bfd / ieee.c
diff --git a/bfd/ieee.c b/bfd/ieee.c

index 8683d7fb1bca5c7e32baa6919d091dd8dc725b30..f49ee53bbd8c088382a165d102925d2c426f7bf6 100644 (file)
--- a/bfd/ieee.c
+++ b/bfd/ieee.c
@@ -1,5 +1,8 @@
  /* BFD back-end for ieee-695 objects.
  /* 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
+   Free Software Foundation, Inc.
+
     Written by Steve Chamberlain of Cygnus Support.
  
  This file is part of BFD, the Binary File Descriptor library.
     Written by Steve Chamberlain of Cygnus Support.
  
  This file is part of BFD, the Binary File Descriptor library.
@@ -16,7 +19,7 @@ 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
  
  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.  */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  
  #define KEEPMINUSPCININST 0
  
  
  #define KEEPMINUSPCININST 0
  
@@ -29,118 +32,218 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  #include "libbfd.h"
  #include "ieee.h"
  #include "libieee.h"
  #include "libbfd.h"
  #include "ieee.h"
  #include "libieee.h"
-#include "obstack.h"
-#define obstack_chunk_alloc malloc
-#define obstack_chunk_free free
+
+#include <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 *, char));
+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. */
  
  
  /* 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 *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_write ((PTR) &byte, 1, 1, abfd) != 1)
+    return false;
+  return true;
  }
  
  }
  
-static void
+static boolean
  ieee_write_2bytes (abfd, bytes)
       bfd *abfd;
       int bytes;
  {
    bfd_byte buffer[2];
  ieee_write_2bytes (abfd, bytes)
       bfd *abfd;
       int bytes;
  {
    bfd_byte buffer[2];
+
    buffer[0] = bytes >> 8;
    buffer[1] = bytes & 0xff;
    buffer[0] = bytes >> 8;
    buffer[1] = bytes & 0xff;
-
-  bfd_write ((PTR) buffer, 1, 2, abfd);
+  if (bfd_write ((PTR) buffer, 1, 2, abfd) != 2)
+    return false;
+  return true;
  }
  
  }
  
-static void
+static boolean
  ieee_write_int (abfd, value)
       bfd *abfd;
       bfd_vma value;
  {
  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;
      }
    else
      {
        unsigned int length;
+
        /* How many significant bytes ? */
        /* FIXME FOR LONGER INTS */
        if (value & 0xff000000)
        /* How many significant bytes ? */
        /* FIXME FOR LONGER INTS */
        if (value & 0xff000000)
-       {
-         length = 4;
-       }
+       length = 4;
        else if (value & 0x00ff0000)
        else if (value & 0x00ff0000)
-       {
-         length = 3;
-       }
+       length = 3;
        else if (value & 0x0000ff00)
        else if (value & 0x0000ff00)
-       {
-         length = 2;
-       }
+       length = 2;
        else
         length = 1;
  
        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:
        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:
         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:
         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:
         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;
  ieee_write_id (abfd, id)
       bfd *abfd;
-     CONST char *id;
+     const char *id;
  {
    size_t length = strlen (id);
  {
    size_t length = strlen (id);
+
    if (length <= 127)
      {
    if (length <= 127)
      {
-      ieee_write_byte (abfd, (bfd_byte) length);
+      if (! ieee_write_byte (abfd, (bfd_byte) length))
+       return false;
      }
    else if (length < 255)
      {
      }
    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)
      {
      }
    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
      {
      }
    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_write ((PTR) id, 1, length, abfd) != length)
+    return false;
+  return true;
  }
  \f
  }
  \f
-
  /***************************************************************************
  Functions for reading from ieee files in the strange way that the
  standard requires:
  /***************************************************************************
  Functions for reading from ieee files in the strange way that the
  standard requires:
@@ -197,16 +300,13 @@ read_id (ieee)
    /* Buy memory and read string */
    string = bfd_alloc (ieee->abfd, length + 1);
    if (!string)
    /* Buy memory and read string */
    string = bfd_alloc (ieee->abfd, 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;
  }
  
    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;
  ieee_write_expression (abfd, value, symbol, pcrel, index)
       bfd *abfd;
       bfd_vma value;
@@ -218,71 +318,86 @@ ieee_write_expression (abfd, value, symbol, pcrel, index)
  
    if (value != 0)
      {
  
    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)
        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 */
      {
        /* 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++;
      }
        term_count++;
      }
-  else if (symbol->section != &bfd_abs_section)
+  else if (! bfd_is_abs_section (symbol->section))
      {
        /* Ref to defined symbol - */
  
      {
        /* 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)
         {
        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))
         {
           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++;
           term_count++;
+         if (symbol->value != 0)
+           {
+             if (! ieee_write_int (abfd, symbol->value))
+               return false;
+             term_count++;
+           }
         }
        else
         {
         }
        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*/
         }
      }
  
    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, 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;
  }
  \f
  }
  \f
-
  /*****************************************************************************/
  
  /*
  /*****************************************************************************/
  
  /*
@@ -300,14 +415,17 @@ ieee_write_int5 (buffer, value)
    buffer[4] = (value >> 0) & 0xff;
  }
  
    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_out (abfd, value)
       bfd *abfd;
       bfd_vma value;
  {
    bfd_byte b[5];
+
    ieee_write_int5 (b, value);
    ieee_write_int5 (b, value);
-  bfd_write ((PTR) b, 1, 5, abfd);
+  if (bfd_write ((PTR) b, 1, 5, abfd) != 5)
+    return false;
+  return true;
  }
  
  static boolean
  }
  
  static boolean
@@ -366,34 +484,109 @@ typedef struct
  } ieee_value_type;
  
  
  } 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)
  
  static void
  parse_expression (ieee, value, symbol, pcrel, extra, section)
@@ -418,8 +611,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;
  #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)))
         {
      {
        switch (this_byte (&(ieee->h)))
         {
@@ -430,9 +624,7 @@ parse_expression (ieee, value, symbol, pcrel, extra, section)
             next_byte (&(ieee->h));
             *pcrel = true;
             section_n = must_parse_int (&(ieee->h));
             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:
             break;
           }
         case ieee_variable_L_enum:
@@ -454,6 +646,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:
                 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 */
           {
         case ieee_variable_X_enum:
           /* Push the address of external variable n */
           {
@@ -462,7 +664,7 @@ parse_expression (ieee, value, symbol, pcrel, extra, section)
             sy.index = (int) (must_parse_int (&(ieee->h)));
             sy.letter = 'X';
  
             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:
           }
           break;
         case ieee_function_minus_enum:
@@ -474,7 +676,7 @@ parse_expression (ieee, value, symbol, pcrel, extra, section)
  
             POP (sy, section1, value1);
             POP (sy, section_dummy, value2);
  
             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:
           }
           break;
         case ieee_function_plus_enum:
@@ -488,7 +690,9 @@ parse_expression (ieee, value, symbol, pcrel, extra, section)
  
             POP (sy1, section1, value1);
             POP (sy2, section2, value2);
  
             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:
           }
           break;
         default:
@@ -498,66 +702,80 @@ parse_expression (ieee, value, symbol, pcrel, extra, section)
                     || this_byte (&(ieee->h)) > (int) ieee_variable_Z_enum);
             if (parse_int (&(ieee->h), &va))
               {
                     || 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
               {
               }
             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;
               }
           }
         }
      }
                 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)
+
+/* 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];
  
  
-#define ieee_pos(abfd)   IEEE_DATA(abfd)->h.input_p -IEEE_DATA(abfd)->h.first_byte
+  return after;
+}
  
  static unsigned int last_index;
  static char last_type;         /* is the index for an X or a D */
  
  static ieee_symbol_type *
  
  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;
       ieee_data_type *ieee;
       ieee_symbol_type *last_symbol;
       unsigned int *symbol_count;
       ieee_symbol_type ***pptr;
       unsigned int *max_index;
-     char this_type
-      ;
+     char this_type;
  {
    /* Need a new symbol */
    unsigned int new_index = must_parse_int (&(ieee->h));
  {
    /* Need a new symbol */
    unsigned int new_index = must_parse_int (&(ieee->h));
@@ -566,10 +784,7 @@ get_symbol (abfd,
        ieee_symbol_type *new_symbol = (ieee_symbol_type *) bfd_alloc (ieee->h.abfd,
                                                  sizeof (ieee_symbol_type));
        if (!new_symbol)
        ieee_symbol_type *new_symbol = (ieee_symbol_type *) bfd_alloc (ieee->h.abfd,
                                                  sizeof (ieee_symbol_type));
        if (!new_symbol)
-       {
-         bfd_set_error (bfd_error_no_memory);
-         return NULL;
-       }
+       return NULL;
  
        new_symbol->index = new_index;
        last_index = new_index;
  
        new_symbol->index = new_index;
        last_index = new_index;
@@ -581,12 +796,13 @@ get_symbol (abfd,
           *max_index = new_index;
         }
        last_type = this_type;
           *max_index = new_index;
         }
        last_type = this_type;
+      new_symbol->symbol.section = bfd_abs_section_ptr;
        return new_symbol;
      }
    return last_symbol;
  }
  
        return new_symbol;
      }
    return last_symbol;
  }
  
-static void
+static boolean
  ieee_slurp_external_symbols (abfd)
       bfd *abfd;
  {
  ieee_slurp_external_symbols (abfd)
       bfd *abfd;
  {
@@ -601,7 +817,7 @@ ieee_slurp_external_symbols (abfd)
    last_index = 0xffffff;
    ieee->symbol_table_full = true;
  
    last_index = 0xffffff;
    ieee->symbol_table_full = true;
  
-  ieee_seek (abfd, offset);
+  ieee_seek (ieee, offset);
  
    while (loop)
      {
  
    while (loop)
      {
@@ -612,12 +828,13 @@ ieee_slurp_external_symbols (abfd)
  
           symbol = get_symbol (abfd, ieee, symbol, &symbol_count,
                                &prev_symbols_ptr,
  
           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.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:
           symbol->symbol.flags = BSF_NO_FLAGS;
           break;
         case ieee_external_symbol_enum:
@@ -626,13 +843,14 @@ ieee_slurp_external_symbols (abfd)
           symbol = get_symbol (abfd, ieee, symbol, &symbol_count,
                                &prev_symbols_ptr,
                                &ieee->external_symbol_max_index, 'D');
           symbol = get_symbol (abfd, ieee, symbol, &symbol_count,
                                &prev_symbols_ptr,
                                &ieee->external_symbol_max_index, 'D');
-
+         if (symbol == NULL)
+           return false;
  
           BFD_ASSERT (symbol->index >= ieee->external_symbol_min_index);
  
           symbol->symbol.the_bfd = abfd;
           symbol->symbol.name = read_id (&(ieee->h));
  
           BFD_ASSERT (symbol->index >= ieee->external_symbol_min_index);
  
           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:
           symbol->symbol.flags = BSF_NO_FLAGS;
           break;
         case ieee_attribute_record_enum >> 8:
@@ -641,25 +859,73 @@ ieee_slurp_external_symbols (abfd)
             unsigned int symbol_type_index;
             unsigned int symbol_attribute_def;
             bfd_vma value;
             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_get_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);
                 parse_int (&(ieee->h), &value);
                 parse_int (&(ieee->h), &value);
-               break;
-
-             default:
                 parse_int (&(ieee->h), &value);
                 break;
                 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_get_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_get_filename (abfd));
+                       bfd_set_error (bfd_error_bad_value);
+                       return false;
+                     }
+                 }
               }
           }
           break;
               }
           }
           break;
@@ -680,6 +946,28 @@ ieee_slurp_external_symbols (abfd)
                               &extra,
                               &symbol->symbol.section);
  
                               &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;
  
           }
             symbol->symbol.flags = BSF_GLOBAL | BSF_EXPORT;
  
           }
@@ -699,7 +987,7 @@ ieee_slurp_external_symbols (abfd)
                 value = 0;
               }
             /* This turns into a common */
                 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;
             symbol->symbol.value = size;
           }
           break;
@@ -710,12 +998,13 @@ ieee_slurp_external_symbols (abfd)
           symbol = get_symbol (abfd, ieee, symbol, &symbol_count,
                                &prev_reference_ptr,
                                &ieee->external_reference_max_index, 'X');
           symbol = get_symbol (abfd, ieee, symbol, &symbol_count,
                                &prev_reference_ptr,
                                &ieee->external_reference_max_index, 'X');
-
+         if (symbol == NULL)
+           return false;
  
           symbol->symbol.the_bfd = abfd;
           symbol->symbol.name = read_id (&(ieee->h));
  
           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;
  
           symbol->symbol.value = (bfd_vma) 0;
           symbol->symbol.flags = 0;
  
@@ -760,24 +1049,29 @@ ieee_slurp_external_symbols (abfd)
  
    *prev_symbols_ptr = (ieee_symbol_type *) NULL;
    *prev_reference_ptr = (ieee_symbol_type *) NULL;
  
    *prev_symbols_ptr = (ieee_symbol_type *) NULL;
    *prev_reference_ptr = (ieee_symbol_type *) NULL;
+
+  return true;
  }
  
  }
  
-static void
+static boolean
  ieee_slurp_symbol_table (abfd)
       bfd *abfd;
  {
    if (IEEE_DATA (abfd)->read_symbols == false)
      {
  ieee_slurp_symbol_table (abfd)
       bfd *abfd;
  {
    if (IEEE_DATA (abfd)->read_symbols == false)
      {
-      ieee_slurp_external_symbols (abfd);
+      if (! ieee_slurp_external_symbols (abfd))
+       return false;
        IEEE_DATA (abfd)->read_symbols = true;
      }
        IEEE_DATA (abfd)->read_symbols = true;
      }
+  return true;
  }
  
  }
  
-unsigned int
+static long
  ieee_get_symtab_upper_bound (abfd)
       bfd *abfd;
  {
  ieee_get_symtab_upper_bound (abfd)
       bfd *abfd;
  {
-  ieee_slurp_symbol_table (abfd);
+  if (! ieee_slurp_symbol_table (abfd))
+    return -1;
  
    return (abfd->symcount != 0) ?
      (abfd->symcount + 1) * (sizeof (ieee_symbol_type *)) : 0;
  
    return (abfd->symcount != 0) ?
      (abfd->symcount + 1) * (sizeof (ieee_symbol_type *)) : 0;
@@ -788,9 +1082,9 @@ Move from our internal lists to the canon table, and insert in
  symbol index order
  */
  
  symbol index order
  */
  
-extern bfd_target ieee_vec;
+extern const bfd_target ieee_vec;
  
  
-unsigned int
+static long
  ieee_get_symtab (abfd, location)
       bfd *abfd;
       asymbol **location;
  ieee_get_symtab (abfd, location)
       bfd *abfd;
       asymbol **location;
@@ -798,14 +1092,24 @@ ieee_get_symtab (abfd, location)
    ieee_symbol_type *symp;
    static bfd dummy_bfd;
    static asymbol empty_symbol =
    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)
      {
        ieee_data_type *ieee = IEEE_DATA (abfd);
        dummy_bfd.xvec = &ieee_vec;
  
    if (abfd->symcount)
      {
        ieee_data_type *ieee = IEEE_DATA (abfd);
        dummy_bfd.xvec = &ieee_vec;
-      ieee_slurp_symbol_table (abfd);
+      if (! ieee_slurp_symbol_table (abfd))
+       return -1;
  
        if (ieee->symbol_table_full == false)
         {
  
        if (ieee->symbol_table_full == false)
         {
@@ -853,16 +1157,36 @@ get_section_entry (abfd, ieee, index)
       ieee_data_type *ieee;
       unsigned int index;
  {
       ieee_data_type *ieee;
       unsigned int index;
  {
+  if (index >= ieee->section_table_size)
+    {
+      unsigned int c, i;
+      asection **n;
+
+      c = ieee->section_table_size;
+      if (c == 0)
+       c = 20;
+      while (c <= index)
+       c *= 2;
+
+      n = ((asection **)
+          bfd_realloc (ieee->section_table, c * sizeof (asection *)));
+      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);
        asection *section;
  
        if (!tmp)
    if (ieee->section_table[index] == (asection *) NULL)
      {
        char *tmp = bfd_alloc (abfd, 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;
        sprintf (tmp, " fsec%4d", index);
        section = bfd_make_section (abfd, tmp);
        ieee->section_table[index] = section;
@@ -885,7 +1209,7 @@ ieee_slurp_sections (abfd)
    if (offset != 0)
      {
        bfd_byte section_type[3];
    if (offset != 0)
      {
        bfd_byte section_type[3];
-      ieee_seek (abfd, offset);
+      ieee_seek (ieee, offset);
        while (true)
         {
           switch (this_byte (&(ieee->h)))
        while (true)
         {
           switch (this_byte (&(ieee->h)))
@@ -895,18 +1219,20 @@ ieee_slurp_sections (abfd)
                 unsigned int section_index;
                 next_byte (&(ieee->h));
                 section_index = must_parse_int (&(ieee->h));
                 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));
  
                 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));
                 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 */
                     switch (section_type[1])
                       {
                       case 0xD3:        /* AS Absolute section attributes */
@@ -917,17 +1243,17 @@ ieee_slurp_sections (abfd)
                           case 0xD0:
                             /* Normal code */
                             next_byte (&(ieee->h));
                           case 0xD0:
                             /* Normal code */
                             next_byte (&(ieee->h));
-                           section->flags |= SEC_LOAD | SEC_CODE;
+                           section->flags |= SEC_CODE;
                             break;
                           case 0xC4:
                             break;
                           case 0xC4:
-                           next_byte (&(ieee->h));
-                           section->flags |= SEC_LOAD | SEC_DATA;
                             /* Normal data */
                             /* Normal data */
+                           next_byte (&(ieee->h));
+                           section->flags |= SEC_DATA;
                             break;
                           case 0xD2:
                             next_byte (&(ieee->h));
                             /* Normal rom 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;
                             break;
                           default:
                             break;
@@ -936,20 +1262,20 @@ ieee_slurp_sections (abfd)
                     break;
                   case 0xC3:    /* Named relocatable sections (type C) */
                     section_type[1] = this_byte (&(ieee->h));
                     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));
                     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));
                         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));
                         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;
                         break;
                       default:
                         break;
@@ -1004,6 +1330,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));
                   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));
                     break;
                   case ieee_mau_size_enum:
                     must_parse_int (&(ieee->h));
@@ -1016,6 +1343,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));
                   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));
                     break;
                   case ieee_section_offset_enum:
                     (void) must_parse_int (&(ieee->h));
@@ -1032,33 +1360,60 @@ ieee_slurp_sections (abfd)
         }
      }
  }
         }
      }
  }
-\f
  
  
+/* 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;
+}
+\f
  /***********************************************************************
  *  archive stuff
  */
  
  /***********************************************************************
  *  archive stuff
  */
  
-bfd_target *
+const bfd_target *
  ieee_archive_p (abfd)
       bfd *abfd;
  {
    char *library;
  ieee_archive_p (abfd)
       bfd *abfd;
  {
    char *library;
-  boolean loop;
-
    unsigned int i;
    unsigned char buffer[512];
    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;
    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));
+  unsigned int alc_elts;
+  ieee_ar_obstack_type *elts = NULL;
+
+  abfd->tdata.ieee_ar_data =
+    (ieee_ar_data_type *) bfd_alloc (abfd, sizeof (ieee_ar_data_type));
    if (!abfd->tdata.ieee_ar_data)
    if (!abfd->tdata.ieee_ar_data)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      return NULL;
-    }
+    goto error_return;
    ieee = IEEE_AR_DATA (abfd);
  
    ieee = IEEE_AR_DATA (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_read ((PTR) buffer, 1, sizeof (buffer), abfd);
  
    ieee->h.first_byte = buffer;
    bfd_read ((PTR) buffer, 1, sizeof (buffer), abfd);
  
    ieee->h.first_byte = buffer;
@@ -1067,112 +1422,122 @@ ieee_archive_p (abfd)
    ieee->h.abfd = abfd;
  
    if (this_byte (&(ieee->h)) != Module_Beginning)
    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)
  
    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;
  
  
    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));
  
    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_read.  */
+         bfd_read ((PTR) buffer, 1, 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;
-    }
+  ieee->elements = ((ieee_ar_obstack_type *)
+                   bfd_alloc (abfd,
+                              ieee->element_count * sizeof *ieee->elements));
+  if (ieee->elements == NULL)
+    goto error_return;
  
  
-  /* Now scan the area again, and replace BB offsets with file */
-  /* offsets */
+  memcpy (ieee->elements, elts,
+         ieee->element_count * sizeof *ieee->elements);
+  free (elts);
+  elts = NULL;
  
  
+  /* Now scan the area again, and replace BB offsets with file offsets.  */
    for (i = 2; i < ieee->element_count; i++)
      {
    for (i = 2; i < ieee->element_count; i++)
      {
-      bfd_seek (abfd, ieee->elements[i].file_offset, SEEK_SET);
+      if (bfd_seek (abfd, ieee->elements[i].file_offset, SEEK_SET) != 0)
+       goto error_return;
+
+      /* Again ignore return value of bfd_read.  */
        bfd_read ((PTR) buffer, 1, sizeof (buffer), abfd);
        ieee->h.first_byte = buffer;
        ieee->h.input_p = buffer;
  
        bfd_read ((PTR) buffer, 1, sizeof (buffer), abfd);
        ieee->h.first_byte = buffer;
        ieee->h.input_p = buffer;
  
-      next_byte (&(ieee->h));  /* Drop F8 */
-      next_byte (&(ieee->h));  /* Drop 14 */
-      must_parse_int (&(ieee->h));     /* Drop size of block */
+      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)
        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
        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;
    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;
  {
  ieee_object_p (abfd)
       bfd *abfd;
  {
@@ -1186,13 +1551,15 @@ ieee_object_p (abfd)
    ieee_mkobject (abfd);
  
    ieee = IEEE_DATA (abfd);
    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 */
+  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_read return value;  The file might be very small.  */
    bfd_read ((PTR) buffer, 1, sizeof (buffer), abfd);
  
    ieee->h.input_p = buffer;
    if (this_byte_and_next (&(ieee->h)) != Module_Beginning)
    bfd_read ((PTR) buffer, 1, 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;
  
    ieee->read_symbols = false;
    ieee->read_data = false;
@@ -1202,22 +1569,86 @@ ieee_object_p (abfd)
    ieee->external_reference_min_index = IEEE_REFERENCE_BASE;
    ieee->external_reference_max_index = 0;
    ieee->h.abfd = 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)
  
    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));
    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.
       */
    {
      {
        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)
      if (arch == 0)
-      goto fail;
+      goto got_wrong_format;
      abfd->arch_info = arch;
    }
  
      abfd->arch_info = arch;
    }
  
@@ -1260,33 +1691,49 @@ 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 */
+
+  IEEE_DATA (abfd)->h.first_byte =
+    (unsigned char *) bfd_alloc (ieee->h.abfd, ieee->w.r.me_record + 1);
    if (!IEEE_DATA (abfd)->h.first_byte)
    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_read ((PTR) (IEEE_DATA (abfd)->h.first_byte), 1,
+           ieee->w.r.me_record + 1, abfd);
  
    ieee_slurp_sections (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;
    return abfd->xvec;
+got_wrong_format:
+  bfd_set_error (bfd_error_wrong_format);
  fail:
    (void) bfd_release (abfd, ieee);
    abfd->tdata.ieee_data = save;
  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)
  ieee_get_symbol_info (ignore_abfd, symbol, ret)
-     bfd *ignore_abfd;
+     bfd *ignore_abfd ATTRIBUTE_UNUSED;
       asymbol *symbol;
       symbol_info *ret;
  {
       asymbol *symbol;
       symbol_info *ret;
  {
@@ -1297,9 +1744,9 @@ ieee_get_symbol_info (ignore_abfd, symbol, ret)
      ret->type = (symbol->flags & BSF_LOCAL) ? 'a' : 'A';
  }
  
      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;
       PTR afile;
       asymbol *symbol;
       bfd_print_symbol_type how;
@@ -1320,22 +1767,22 @@ ieee_print_symbol (ignore_abfd, afile, symbol, how)
        break;
      case bfd_print_symbol_all:
        {
        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
           {
         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,
  
             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);
           }
        }
                      symbol->name);
           }
        }
@@ -1344,11 +1791,12 @@ ieee_print_symbol (ignore_abfd, afile, symbol, how)
  }
  
  static boolean
  }
  
  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;
       ieee_data_type *ieee;
       ieee_per_section_type *current_map;
       unsigned char *location_ptr;
       asection *s;
+     int iterations;
  {
    switch (this_byte (&(ieee->h)))
      {
  {
    switch (this_byte (&(ieee->h)))
      {
@@ -1388,10 +1836,7 @@ do_one (ieee, current_map, location_ptr, s)
                   (ieee_reloc_type *) bfd_alloc (ieee->h.abfd,
                                                  sizeof (ieee_reloc_type));
                   if (!r)
                   (ieee_reloc_type *) bfd_alloc (ieee->h.abfd,
                                                  sizeof (ieee_reloc_type));
                   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;
  
                   *(current_map->reloc_tail_ptr) = r;
                   current_map->reloc_tail_ptr = &r->next;
@@ -1404,11 +1849,11 @@ do_one (ieee, current_map, location_ptr, s)
                                     &r->symbol,
                                     &pcrel, &extra, &section);
                   r->relent.address = current_map->pc;
                                     &r->symbol,
                                     &pcrel, &extra, &section);
                   r->relent.address = current_map->pc;
+                 s->flags |= SEC_RELOC;
+                 s->owner->flags |= HAS_RELOC;
                   s->reloc_count++;
                   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)
                     {
  
                   if (this_byte (&(ieee->h)) == (int) ieee_comma)
                     {
@@ -1433,12 +1878,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
                     }
                   /* 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)
                     {
  
                   switch (extra)
                     {
@@ -1510,7 +1953,7 @@ do_one (ieee, current_map, location_ptr, s)
  
                     default:
                       BFD_FAIL ();
  
                     default:
                       BFD_FAIL ();
-                     break;
+                     return false;
                     }
                 }
                 break;
                     }
                 }
                 break;
@@ -1532,6 +1975,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;
           }
        }
      }
           }
        }
      }
@@ -1553,19 +2001,18 @@ ieee_slurp_section_data (abfd)
    if (ieee->read_data == true)
      return true;
    ieee->read_data = true;
    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;
  
    /* 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)
        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);
        /*SUPPRESS 68*/
        per->reloc_tail_ptr =
         (ieee_reloc_type **) & (s->relocation);
@@ -1583,6 +2030,7 @@ ieee_slurp_section_data (abfd)
           next_byte (&(ieee->h));
           section_number = must_parse_int (&(ieee->h));
           s = ieee->section_table[section_number];
           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 */
           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 */
@@ -1602,7 +2050,7 @@ ieee_slurp_section_data (abfd)
                 unsigned int extra;
                 boolean pcrel;
                 next_byte (&(ieee->h));
                 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,
                 parse_expression (ieee, &value,
                                   &symbol,
                                   &pcrel, &extra,
@@ -1613,11 +2061,15 @@ ieee_slurp_section_data (abfd)
               break;
  
             case ieee_value_starting_address_enum & 0xff:
               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 ();
               /* 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:
             }
           break;
         case ieee_repeat_data_enum:
@@ -1650,7 +2102,8 @@ ieee_slurp_section_data (abfd)
                 while (iterations != 0)
                   {
                     ieee->h.input_p = start;
                 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,
+                                iterations))
                       return false;
                     iterations--;
                   }
                       return false;
                     iterations--;
                   }
@@ -1660,14 +2113,14 @@ ieee_slurp_section_data (abfd)
         case ieee_load_constant_bytes_enum:
         case ieee_load_with_relocation_enum:
           {
         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;
           }
         }
      }
  }
  
               return false;
           }
         }
      }
  }
  
-boolean
+static boolean
  ieee_new_section_hook (abfd, newsect)
       bfd *abfd;
       asection *newsect;
  ieee_new_section_hook (abfd, newsect)
       bfd *abfd;
       asection *newsect;
@@ -1675,21 +2128,21 @@ ieee_new_section_hook (abfd, newsect)
    newsect->used_by_bfd = (PTR)
      bfd_alloc (abfd, sizeof (ieee_per_section_type));
    if (!newsect->used_by_bfd)
    newsect->used_by_bfd = (PTR)
      bfd_alloc (abfd, 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;
  }
  
    ieee_per_section (newsect)->data = (bfd_byte *) NULL;
    ieee_per_section (newsect)->section = newsect;
    return true;
  }
  
-unsigned int
+static long
  ieee_get_reloc_upper_bound (abfd, asect)
       bfd *abfd;
       sec_ptr asect;
  {
  ieee_get_reloc_upper_bound (abfd, asect)
       bfd *abfd;
       sec_ptr asect;
  {
-  ieee_slurp_section_data (abfd);
+  if ((asect->flags & SEC_DEBUGGING) != 0)
+    return 0;
+  if (! ieee_slurp_section_data (abfd))
+    return -1;
    return (asect->reloc_count + 1) * sizeof (arelent *);
  }
  
    return (asect->reloc_count + 1) * sizeof (arelent *);
  }
  
@@ -1702,12 +2155,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;
       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;
  }
  
    ieee_slurp_section_data (abfd);
    (void) memcpy ((PTR) location, (PTR) (p->data + offset), (unsigned) count);
    return true;
  }
  
-unsigned int
+static long
  ieee_canonicalize_reloc (abfd, section, relptr, symbols)
       bfd *abfd;
       sec_ptr section;
  ieee_canonicalize_reloc (abfd, section, relptr, symbols)
       bfd *abfd;
       sec_ptr section;
@@ -1718,18 +2174,26 @@ ieee_canonicalize_reloc (abfd, section, relptr, symbols)
    ieee_reloc_type *src = (ieee_reloc_type *) (section->relocation);
    ieee_data_type *ieee = IEEE_DATA (abfd);
  
    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)
         {
    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:
         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:
  
           break;
         default:
  
@@ -1744,19 +2208,17 @@ ieee_canonicalize_reloc (abfd, section, relptr, symbols)
  
  static int
  comp (ap, bp)
  
  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;
  }
  
  {
    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;
  {
  ieee_write_section_part (abfd)
       bfd *abfd;
  {
@@ -1765,68 +2227,87 @@ ieee_write_section_part (abfd)
    ieee->w.r.section_part = bfd_tell (abfd);
    for (s = abfd->sections; s != (asection *) NULL; s = s->next)
      {
    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 */
  
           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
             {
             }
           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:
             }
  
           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:
               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:
               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 */
  #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, 1 << s->alignment_power))
+           return false;
  
           /* Size */
  
           /* 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 */
           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;
  }
  
  
  }
  
  
@@ -1835,11 +2316,11 @@ do_with_relocs (abfd, s)
       bfd *abfd;
       asection *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;
    unsigned int relocs_to_go = s->reloc_count;
-
    bfd_byte *stream = ieee_per_section (s)->data;
    arelent **p = s->orelocation;
    bfd_byte *stream = ieee_per_section (s)->data;
    arelent **p = s->orelocation;
-
    bfd_size_type current_byte_index = 0;
  
    qsort (s->orelocation,
    bfd_size_type current_byte_index = 0;
  
    qsort (s->orelocation,
@@ -1848,22 +2329,34 @@ do_with_relocs (abfd, s)
          comp);
  
    /* Output the section preheader */
          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, 0, s->symbol, 0, 0))
+       return false;
+    }
  
    if (relocs_to_go == 0)
      {
  
    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;
  
        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)
             {
           run = MAXRUN;
           if (run > s->_raw_size - current_byte_index)
             {
@@ -1872,44 +2365,47 @@ do_with_relocs (abfd, s)
  
           if (run != 0)
             {
  
           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 */
               /* 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_write ((PTR) (stream + current_byte_index),
+                            1,
+                            run,
+                            abfd)
+                 != run)
+               return false;
               current_byte_index += run;
             }
         }
      }
    else
      {
               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
  
        /* 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)
  
        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;
         }
        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 (relocs_to_go)
             {
               run = (*p)->address - current_byte_index;
+             if (run > MAXRUN)
+               run = MAXRUN;
             }
           else
             {
             }
           else
             {
@@ -1923,21 +2419,24 @@ do_with_relocs (abfd, s)
           if (run != 0)
             {
               /* Output a stream of bytes */
           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_write ((PTR) (stream + current_byte_index),
+                            1,
+                            run,
+                            abfd)
+                 != run)
+               return false;
               current_byte_index += run;
             }
           /* Output any relocations here */
           if (relocs_to_go && (*p) && (*p)->address == current_byte_index)
             {
               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;
                   arelent *r = *p;
-                 bfd_vma ov;
+                 bfd_signed_vma ov;
  
  #if 0
                   if (r->howto->pc_relative)
  
  #if 0
                   if (r->howto->pc_relative)
@@ -1950,47 +2449,65 @@ do_with_relocs (abfd, s)
                     {
                     case 2:
  
                     {
                     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:
                       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:
                       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 ();
                       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)
                     {
  
                   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,
+                                                  s->index))
+                       return false;
                     }
                   else
                     {
                     }
                   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,
+                                                  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);
+                     if (! ieee_write_int (abfd,
+                                           bfd_get_reloc_size (r->howto)))
+                       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++;
  
                   relocs_to_go--;
                   p++;
@@ -1999,36 +2516,55 @@ do_with_relocs (abfd, s)
             }
         }
      }
             }
         }
      }
+
    return true;
  }
  
    return true;
  }
  
-/* If there are no relocations in the output section then we can
-be clever about how we write. We block items up into a max of 127
-bytes */
+/* 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)
      {
  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, 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;
  do_without_relocs (abfd, s)
       bfd *abfd;
       asection *s;
@@ -2037,7 +2573,8 @@ do_without_relocs (abfd, s)
  
    if (stream == 0 || ((s->flags & SEC_LOAD) == 0))
      {
  
    if (stream == 0 || ((s->flags & SEC_LOAD) == 0))
      {
-      do_as_repeat (abfd, s);
+      if (! do_as_repeat (abfd, s))
+       return false;
      }
    else
      {
      }
    else
      {
@@ -2046,13 +2583,16 @@ do_without_relocs (abfd, s)
         {
           if (stream[i] != 0)
             {
         {
           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;
  }
  
  
  }
  
  
@@ -2066,16 +2606,39 @@ static bfd *input_bfd;
  static bfd *output_bfd;
  static int output_buffer;
  
  static bfd *output_bfd;
  static int output_buffer;
  
+static boolean
+ieee_mkobject (abfd)
+     bfd *abfd;
+{
+  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;
+  abfd->tdata.ieee_data = (ieee_data_type *) bfd_zalloc (abfd, sizeof (ieee_data_type));
+  return abfd->tdata.ieee_data ? true : false;
+}
+
  static void
  fill ()
  {
  static void
  fill ()
  {
+  /* FIXME: Check return value.  I'm not sure whether it needs to read
+     the entire buffer or not.  */
    bfd_read ((PTR) input_ptr_start, 1, input_ptr_end - input_ptr_start, input_bfd);
    input_ptr = input_ptr_start;
  }
    bfd_read ((PTR) input_ptr_start, 1, input_ptr_end - input_ptr_start, input_bfd);
    input_ptr = input_ptr_start;
  }
+
  static void
  flush ()
  {
  static void
  flush ()
  {
-  bfd_write ((PTR) (output_ptr_start), 1, output_ptr - output_ptr_start, output_bfd);
+  if (bfd_write ((PTR) (output_ptr_start), 1, output_ptr - output_ptr_start,
+                output_bfd)
+      != (bfd_size_type) (output_ptr - output_ptr_start))
+    abort ();
    output_ptr = output_ptr_start;
    output_buffer++;
  }
    output_ptr = output_ptr_start;
    output_buffer++;
  }
@@ -2227,7 +2790,7 @@ copy_expression ()
             s = ieee->section_table[section_number];
             if (s->output_section)
               {
             s = ieee->section_table[section_number];
             if (s->output_section)
               {
-               value = s->output_section->vma;
+               value = s->output_section->lma;
               }
             else
               {
               }
             else
               {
@@ -2254,12 +2817,6 @@ copy_expression ()
  /* Drop the int in the buffer, and copy a null into the gap, which we
     will overwrite later */
  
  /* 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;
  static void
  fill_int (buf)
       struct output_buffer_struct *buf;
@@ -2347,7 +2904,6 @@ copy_int ()
  #define ID copy_id()
  #define INT copy_int()
  #define EXP copy_expression()
  #define ID copy_id()
  #define INT copy_int()
  #define EXP copy_expression()
-static void copy_till_end ();
  #define INTn(q) copy_int()
  #define EXPn(q) copy_expression()
  
  #define INTn(q) copy_int()
  #define EXPn(q) copy_expression()
  
@@ -2513,7 +3069,6 @@ f2_record ()
  }
  
  
  }
  
  
-static void block ();
  static void
  f8_record ()
  {
  static void
  f8_record ()
  {
@@ -2712,7 +3267,7 @@ block ()
  
  static void
  relocate_debug (output, input)
  
  static void
  relocate_debug (output, input)
-     bfd *output;
+     bfd *output ATTRIBUTE_UNUSED;
       bfd *input;
  {
  #define IBS 400
       bfd *input;
  {
  #define IBS 400
@@ -2722,17 +3277,16 @@ relocate_debug (output, input)
    input_ptr_start = input_ptr = input_buffer;
    input_ptr_end = input_buffer + IBS;
    input_bfd = input;
    input_ptr_start = input_ptr = input_buffer;
    input_ptr_end = input_buffer + IBS;
    input_bfd = input;
+  /* FIXME: Check return value.  I'm not sure whether it needs to read
+     the entire buffer or not.  */
    bfd_read ((PTR) input_ptr_start, 1, IBS, input);
    block ();
  }
  
    bfd_read ((PTR) input_ptr_start, 1, IBS, input);
    block ();
  }
  
-/*
-  During linking, we we told about the bfds which made up our
-  contents, we have a list of them. They will still be open, so go to
-  the debug info in each, and copy it out, relocating it as we go.
-*/
+/* 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_write_debug_part (abfd)
       bfd *abfd;
  {
@@ -2749,49 +3303,20 @@ ieee_write_debug_part (abfd)
  
    if (chain == (bfd_chain_type *) NULL)
      {
  
    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;
  
  
+      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;
+       }
  
  
-      /*    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;
-
-         }
-       /* Close the scope */
-       ieee_write_byte (abfd, 0xf9);
-      }
-#endif
+      ieee->w.r.debug_information_part = here;
+      if (bfd_write (s->contents, 1, s->_raw_size, abfd) != s->_raw_size)
+       return false;
      }
    else
      {
      }
    else
      {
@@ -2801,7 +3326,10 @@ ieee_write_debug_part (abfd)
           ieee_data_type *entry_ieee = IEEE_DATA (entry);
           if (entry_ieee->w.r.debug_information_part)
             {
           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);
             }
  
               relocate_debug (abfd, entry);
             }
  
@@ -2815,13 +3343,16 @@ ieee_write_debug_part (abfd)
         {
           ieee->w.r.debug_information_part = 0;
         }
         {
           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;
  {
  ieee_write_data_part (abfd)
       bfd *abfd;
  {
@@ -2830,17 +3361,26 @@ ieee_write_data_part (abfd)
    ieee->w.r.data_part = bfd_tell (abfd);
    for (s = abfd->sections; s != (asection *) NULL; s = s->next)
      {
    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
        /* Sort the reloc records so we can insert them in the correct
-          places */
+        places */
        if (s->reloc_count != 0)
         {
        if (s->reloc_count != 0)
         {
-         do_with_relocs (abfd, s);
+         if (! do_with_relocs (abfd, s))
+           return false;
         }
        else
         {
         }
        else
         {
-         do_without_relocs (abfd, s);
+         if (! do_without_relocs (abfd, s))
+           return false;
         }
      }
         }
      }
+
+  return true;
  }
  
  
  }
  
  
@@ -2851,14 +3391,13 @@ init_for_output (abfd)
    asection *s;
    for (s = abfd->sections; s != (asection *) NULL; s = s->next)
      {
    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));
           if (!ieee_per_section (s)->data)
        if (s->_raw_size != 0)
         {
           ieee_per_section (s)->data = (bfd_byte *) (bfd_alloc (abfd, s->_raw_size));
           if (!ieee_per_section (s)->data)
-           {
-             bfd_set_error (bfd_error_no_memory);
-             return false;
-           }
+           return false;
         }
      }
    return true;
         }
      }
    return true;
@@ -2869,7 +3408,7 @@ init_for_output (abfd)
  /* set section contents is complicated with IEEE since the format is
  * not a byte image, but a record stream.
  */
  /* 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;
  ieee_set_section_contents (abfd, section, location, offset, count)
       bfd *abfd;
       sec_ptr section;
@@ -2877,6 +3416,21 @@ ieee_set_section_contents (abfd, section, location, offset, count)
       file_ptr offset;
       bfd_size_type count;
  {
       file_ptr offset;
       bfd_size_type count;
  {
+  if ((section->flags & SEC_DEBUGGING) != 0)
+    {
+      if (section->contents == NULL)
+       {
+         section->contents = ((unsigned char *)
+                              bfd_alloc (abfd, section->_raw_size));
+         if (section->contents == NULL)
+           return false;
+       }
+      /* bfd_set_section_contents has already checked that everything
+         is within range.  */
+      memcpy (section->contents + offset, location, count);
+      return true;
+    }
+
    if (ieee_per_section (section)->data == (bfd_byte *) NULL)
      {
        if (!init_for_output (abfd))
    if (ieee_per_section (section)->data == (bfd_byte *) NULL)
      {
        if (!init_for_output (abfd))
@@ -2888,13 +3442,12 @@ ieee_set_section_contents (abfd, section, location, offset, count)
    return true;
  }
  
    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;
  {
  ieee_write_external_part (abfd)
       bfd *abfd;
  {
@@ -2911,75 +3464,84 @@ ieee_write_external_part (abfd)
        for (q = abfd->outsymbols; *q != (asymbol *) NULL; q++)
         {
           asymbol *p = *q;
        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 .. */
             {
               /* 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, reference_index)
+                 || ! ieee_write_id (abfd, p->name))
+               return false;
               p->value = reference_index;
               reference_index++;
               p->value = reference_index;
               reference_index++;
+             hadone = true;
             }
           else if (bfd_is_com_section (p->section))
             {
               /* This is a weak reference */
             }
           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, 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))
+               return false;
               p->value = reference_index;
               reference_index++;
               p->value = reference_index;
               reference_index++;
+             hadone = true;
             }
           else if (p->flags & BSF_GLOBAL)
             {
               /* This must be a symbol definition */
  
             }
           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, public_index)
+                 || ! ieee_write_id (abfd, p->name)
+                 || ! ieee_write_2bytes (abfd, ieee_attribute_record_enum)
+                 || ! ieee_write_int (abfd, public_index)
+                 || ! ieee_write_byte (abfd, 15) /* instruction address */
+                 || ! ieee_write_byte (abfd, 19) /* static symbol */
+                 || ! ieee_write_byte (abfd, 1)) /* one of them */
+               return false;
  
               /* Write out the value */
  
               /* 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, public_index))
+               return false;
+             if (! bfd_is_abs_section (p->section))
                 {
                   if (abfd->flags & EXEC_P)
                     {
                       /* If fully linked, then output all symbols
                 {
                   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
                     {
                     }
                   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
                 {
                     }
                 }
               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++;
                 }
               p->value = public_index;
               public_index++;
+             hadone = true;
             }
           else
             {
             }
           else
             {
@@ -2991,10 +3553,11 @@ ieee_write_external_part (abfd)
    if (hadone)
      ieee->w.r.external_part = here;
  
    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          */
  {
    0xf0, 0x20, 0x00,
    0xf1, 0xce, 0x20, 0x00, 37, 3, 3,    /* Set version 3 rev 3          */
@@ -3002,7 +3565,7 @@ static CONST unsigned char exten[] =
    0xf1, 0xce, 0x20, 0x00, 38   /* set object type relocateable to x */
  };
  
    0xf1, 0xce, 0x20, 0x00, 38   /* set object type relocateable to x */
  };
  
-static CONST unsigned char envi[] =
+static const unsigned char envi[] =
  {
    0xf0, 0x21, 0x00,
  
  {
    0xf0, 0x21, 0x00,
  
@@ -3015,8 +3578,7 @@ static CONST unsigned char envi[] =
  /*    0xf1, 0xce, 0x21, 0, 54, 2,1,1   tool & version # */
  };
  
  /*    0xf1, 0xce, 0x21, 0, 54, 2,1,1   tool & version # */
  };
  
-static
-void
+static boolean
  ieee_write_me_part (abfd)
       bfd *abfd;
  {
  ieee_write_me_part (abfd)
       bfd *abfd;
  {
@@ -3024,121 +3586,238 @@ ieee_write_me_part (abfd)
    ieee->w.r.trailer_part = bfd_tell (abfd);
    if (abfd->start_address)
      {
    ieee->w.r.trailer_part = bfd_tell (abfd);
    if (abfd->start_address)
      {
-      ieee->w.r.me_record = bfd_tell (abfd);
-      ieee_write_2bytes (abfd, ieee_value_starting_address_enum);
-      ieee_write_byte (abfd, ieee_function_either_open_b_enum);
-      ieee_write_int (abfd, abfd->start_address);
-      ieee_write_byte (abfd, ieee_function_either_close_b_enum);
+      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;
  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 */
    /* 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 */
  
    /* 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 */
  
    /* 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 */
    /* 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);
  
    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);
  
    ieee->w.r.extension_record = bfd_tell (abfd);
-  bfd_write ((char *) exten, 1, sizeof (exten), abfd);
+  if (bfd_write ((char *) exten, 1, sizeof (exten), abfd) != sizeof (exten))
+    return false;
    if (abfd->flags & EXEC_P)
    if (abfd->flags & EXEC_P)
-    ieee_write_byte (abfd, 0x1);/* Absolute */
+    {
+      if (! ieee_write_byte (abfd, 0x1)) /* Absolute */
+       return false;
+    }
    else
    else
-    ieee_write_byte (abfd, 0x2);/* Relocateable */
+    {
+      if (! ieee_write_byte (abfd, 0x2)) /* Relocateable */
+       return false;
+    }
  
    ieee->w.r.environmental_record = bfd_tell (abfd);
  
    ieee->w.r.environmental_record = bfd_tell (abfd);
-  bfd_write ((char *) envi, 1, sizeof (envi), abfd);
+  if (bfd_write ((char *) envi, 1, 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, t->tm_year + 1900)
+       || ! ieee_write_int (abfd, t->tm_mon + 1)
+       || ! ieee_write_int (abfd, t->tm_mday)
+       || ! ieee_write_int (abfd, t->tm_hour)
+       || ! ieee_write_int (abfd, t->tm_min)
+       || ! ieee_write_int (abfd, t->tm_sec))
+      return false;
+  }
+
    output_bfd = abfd;
    output_bfd = abfd;
-  flush ();
  
  
-  ieee_write_section_part (abfd);
-  /*
-    First write the symbols, this changes their values into table
-    indeces so we cant use it after this point
-    */
-  ieee_write_external_part (abfd);
-  /*  ieee_write_byte(abfd, ieee_record_seperator_enum);*/
+  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);*/
  
+  /*  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 */
  
    /* 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++)
      {
  
    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, ieee->w.offset[i]))
+       return false;
      }
      }
+
    return true;
  }
  \f
    return true;
  }
  \f
-
-
  /* Native-level interface to symbols. */
  
  /* We read the symbols into a buffer, which is discarded when this
  /* 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_make_empty_symbol (abfd)
       bfd *abfd;
  {
-
    ieee_symbol_type *new =
    ieee_symbol_type *new =
-  (ieee_symbol_type *) bfd_zmalloc (sizeof (ieee_symbol_type));
+    (ieee_symbol_type *) bfd_zalloc (abfd, sizeof (ieee_symbol_type));
    if (!new)
    if (!new)
-    {
-      bfd_set_error (bfd_error_no_error);
-      return NULL;
-    }
+    return NULL;
    new->symbol.the_bfd = abfd;
    return &new->symbol;
  }
    new->symbol.the_bfd = abfd;
    return &new->symbol;
  }
@@ -3181,20 +3860,15 @@ ieee_openr_next_archived_file (arch, prev)
  }
  
  static boolean
  }
  
  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;
  }
  {
    return false;
  }
@@ -3204,29 +3878,45 @@ ieee_generic_stat_arch_elt (abfd, buf)
       bfd *abfd;
       struct stat *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;
      }
    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)
  }
  
  static int
  ieee_sizeof_headers (abfd, x)
-     bfd *abfd;
-     boolean x;
+     bfd *abfd ATTRIBUTE_UNUSED;
+     boolean x ATTRIBUTE_UNUSED;
  {
    return 0;
  }
  
  
  {
    return 0;
  }
  
  
+/* The debug info routines are never used.  */
+#if 0
+
  static void
  ieee_bfd_debug_info_start (abfd)
       bfd *abfd;
  static void
  ieee_bfd_debug_info_start (abfd)
       bfd *abfd;
@@ -3269,10 +3959,7 @@ ieee_bfd_debug_info_accumulate (abfd, section)
    {
      bfd_chain_type *n = (bfd_chain_type *) bfd_alloc (abfd, sizeof (bfd_chain_type));
      if (!n)
    {
      bfd_chain_type *n = (bfd_chain_type *) bfd_alloc (abfd, sizeof (bfd_chain_type));
      if (!n)
-      {
-       bfd_set_error (bfd_error_no_memory);
-       abort ();               /* FIXME */
-      }
+      abort ();                /* FIXME */
      n->this = section->owner;
      n->next = (bfd_chain_type *) NULL;
  
      n->this = section->owner;
      n->next = (bfd_chain_type *) NULL;
  
@@ -3289,44 +3976,62 @@ 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_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_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_add_symbols _bfd_generic_link_add_symbols
  #define ieee_bfd_final_link _bfd_generic_final_link
  #define ieee_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
  #define ieee_bfd_link_add_symbols _bfd_generic_link_add_symbols
  #define ieee_bfd_final_link _bfd_generic_final_link
+#define ieee_bfd_link_split_section  _bfd_generic_link_split_section
  
  /*SUPPRESS 460 */
  
  /*SUPPRESS 460 */
-bfd_target ieee_vec =
+const bfd_target ieee_vec =
  {
    "ieee",                      /* name */
    bfd_target_ieee_flavour,
  {
    "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 */
    (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 */
    ' ',                         /* 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 */
    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 */
@@ -3351,6 +4056,44 @@ bfd_target ieee_vec =
      _bfd_write_archive_contents,
      bfd_false,
    },
      _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,
+     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
  };
    (PTR) 0
  };