Changeset 609 for branches/GNU/src/binutils/bfd/ieee.c

Timestamp:

Aug 16, 2003, 6:59:22 PM (22 years ago)

Author:

bird

Message:

binutils v2.14 - offical sources.

File:

• branches/GNU/src/binutils/bfd/ieee.c (modified) (210 diffs, 1 prop)

branches/GNU/src/binutils/bfd/ieee.c

@@ -1 +1 @@
 /* BFD back-end for ieee-695 objects.
    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
-   2000, 2001
+   2000, 2001, 2002, 2003
    Free Software Foundation, Inc.
 
    Written by Steve Chamberlain of Cygnus Support.
 
-This file is part of BFD, the Binary File Descriptor library.
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   This file is part of BFD, the Binary File Descriptor library.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 #define KEEPMINUSPCININST 0
@@ -33 +33 @@
 #include "ieee.h"
 #include "libieee.h"
-
-#include <ctype.h>
-
-static boolean ieee_write_byte PARAMS ((bfd *, int));
-static boolean ieee_write_2bytes PARAMS ((bfd *, int));
-static boolean ieee_write_int PARAMS ((bfd *, bfd_vma));
-static boolean ieee_write_id PARAMS ((bfd *, const char *));
-static boolean ieee_write_expression
-  PARAMS ((bfd *, bfd_vma, asymbol *, boolean, unsigned int));
-static void ieee_write_int5 PARAMS ((bfd_byte *, bfd_vma));
-static boolean ieee_write_int5_out PARAMS ((bfd *, bfd_vma));
-static boolean ieee_write_section_part PARAMS ((bfd *));
-static boolean do_with_relocs PARAMS ((bfd *, asection *));
-static boolean do_as_repeat PARAMS ((bfd *, asection *));
-static boolean do_without_relocs PARAMS ((bfd *, asection *));
-static boolean ieee_write_external_part PARAMS ((bfd *));
-static boolean ieee_write_data_part PARAMS ((bfd *));
-static boolean ieee_write_debug_part PARAMS ((bfd *));
-static boolean ieee_write_me_part PARAMS ((bfd *));
-static boolean ieee_write_processor PARAMS ((bfd *));
-
-static boolean ieee_slurp_debug PARAMS ((bfd *));
-static boolean ieee_slurp_section_data PARAMS ((bfd *));
+#include "safe-ctype.h"
+
+struct output_buffer_struct
+{
+  unsigned char *ptrp;
+  int buffer;
+};
+
+static bfd_boolean ieee_write_byte
+  PARAMS ((bfd *, int));
+static bfd_boolean ieee_write_2bytes
+  PARAMS ((bfd *, int));
+static bfd_boolean ieee_write_int
+  PARAMS ((bfd *, bfd_vma));
+static bfd_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 bfd_boolean ieee_write_expression
+  PARAMS ((bfd *, bfd_vma, asymbol *, bfd_boolean, unsigned int));
+static void ieee_write_int5
+  PARAMS ((bfd_byte *, bfd_vma));
+static bfd_boolean ieee_write_int5_out
+  PARAMS ((bfd *, bfd_vma));
+static bfd_boolean parse_int
+  PARAMS ((common_header_type *, bfd_vma *));
+static int parse_i
+  PARAMS ((common_header_type *, bfd_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 *,
+           bfd_boolean *, unsigned int *, asection **));
+static file_ptr ieee_part_after
+  PARAMS ((ieee_data_type *, file_ptr));
+static ieee_symbol_type *get_symbol
+  PARAMS ((bfd *, ieee_data_type *, ieee_symbol_type *, unsigned int *,
+           ieee_symbol_type ***, unsigned int *, int));
+static bfd_boolean ieee_slurp_external_symbols
+  PARAMS ((bfd *));
+static bfd_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 bfd_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 bfd_boolean do_one
+  PARAMS ((ieee_data_type *, ieee_per_section_type *, unsigned char *,
+           asection *, int));
+static bfd_boolean ieee_slurp_section_data
+  PARAMS ((bfd *));
+static bfd_boolean ieee_new_section_hook
+  PARAMS ((bfd *, asection *));
+static long ieee_get_reloc_upper_bound
+  PARAMS ((bfd *, sec_ptr));
+static bfd_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 bfd_boolean ieee_write_section_part
+  PARAMS ((bfd *));
+static bfd_boolean do_with_relocs
+  PARAMS ((bfd *, asection *));
+static bfd_boolean do_as_repeat
+  PARAMS ((bfd *, asection *));
+static bfd_boolean do_without_relocs
+  PARAMS ((bfd *, asection *));
+static bfd_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 bfd_boolean ieee_write_debug_part
+  PARAMS ((bfd *));
+static bfd_boolean ieee_write_data_part
+  PARAMS ((bfd *));
+static bfd_boolean init_for_output
+  PARAMS ((bfd *));
+static bfd_boolean ieee_set_section_contents
+  PARAMS ((bfd *, sec_ptr, PTR, file_ptr, bfd_size_type));
+static bfd_boolean ieee_write_external_part
+  PARAMS ((bfd *));
+static bfd_boolean ieee_write_me_part
+  PARAMS ((bfd *));
+static bfd_boolean ieee_write_processor
+  PARAMS ((bfd *));
+static bfd_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 bfd_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 *, bfd_boolean));
 
 /* Functions for writing to ieee files in the strange way that the
    standard requires. */
 
-static boolean
+static bfd_boolean
 ieee_write_byte (abfd, barg)
      bfd *abfd;
@@ -68 +193 @@
 
   byte = barg;
-  if (bfd_write ((PTR) &byte, 1, 1, abfd) != 1)
-    return false;
-  return true;
-}
-
-static boolean
+  if (bfd_bwrite ((PTR) &byte, (bfd_size_type) 1, abfd) != 1)
+    return FALSE;
+  return TRUE;
+}
+
+static bfd_boolean
 ieee_write_2bytes (abfd, bytes)
      bfd *abfd;
@@ -82 +207 @@
   buffer[0] = bytes >> 8;
   buffer[1] = bytes & 0xff;
-  if (bfd_write ((PTR) buffer, 1, 2, abfd) != 2)
-    return false;
-  return true;
-}
-
-static boolean
+  if (bfd_bwrite ((PTR) buffer, (bfd_size_type) 2, abfd) != 2)
+    return FALSE;
+  return TRUE;
+}
+
+static bfd_boolean
 ieee_write_int (abfd, value)
      bfd *abfd;
@@ -95 +220 @@
     {
       if (! ieee_write_byte (abfd, (bfd_byte) value))
-        return false;
+        return FALSE;
     }
   else
@@ -101 +226 @@
       unsigned int length;
 
-      /* How many significant bytes ? */
-      /* FIXME FOR LONGER INTS */
+      /* How many significant bytes ?  */
+      /* FIXME FOR LONGER INTS.  */
       if (value & 0xff000000)
         length = 4;
@@ -115 +240 @@
                              (bfd_byte) ((int) ieee_number_repeat_start_enum
                                          + length)))
-        return false;
+        return FALSE;
       switch (length)
         {
         case 4:
           if (! ieee_write_byte (abfd, (bfd_byte) (value >> 24)))
-            return false;
+            return FALSE;
           /* Fall through.  */
         case 3:
           if (! ieee_write_byte (abfd, (bfd_byte) (value >> 16)))
-            return false;
+            return FALSE;
           /* Fall through.  */
         case 2:
           if (! ieee_write_byte (abfd, (bfd_byte) (value >> 8)))
-            return false;
+            return FALSE;
           /* Fall through.  */
         case 1:
           if (! ieee_write_byte (abfd, (bfd_byte) (value)))
-            return false;
+            return FALSE;
         }
     }
 
-  return true;
-}
-
-static boolean
+  return TRUE;
+}
+
+static bfd_boolean
 ieee_write_id (abfd, id)
      bfd *abfd;
@@ -149 +274 @@
     {
       if (! ieee_write_byte (abfd, (bfd_byte) length))
-        return false;
+        return FALSE;
     }
   else if (length < 255)
@@ -155 +280 @@
       if (! ieee_write_byte (abfd, ieee_extension_length_1_enum)
           || ! ieee_write_byte (abfd, (bfd_byte) length))
-        return false;
+        return FALSE;
     }
   else if (length < 65535)
@@ -161 +286 @@
       if (! ieee_write_byte (abfd, ieee_extension_length_2_enum)
           || ! ieee_write_2bytes (abfd, (int) length))
-        return false;
+        return FALSE;
     }
   else
@@ -169 +294 @@
          bfd_get_filename (abfd), length);
       bfd_set_error (bfd_error_invalid_operation);
-      return false;
-    }
-
-  if (bfd_write ((PTR) id, 1, length, abfd) != length)
-    return false;
-  return true;
-}
-
-
-/***************************************************************************
-Functions for reading from ieee files in the strange way that the
-standard requires:
-*/
+      return FALSE;
+    }
+
+  if (bfd_bwrite ((PTR) id, (bfd_size_type) length, abfd) != length)
+    return FALSE;
+  return TRUE;
+}
+
+
+/* Functions for reading from ieee files in the strange way that the
+   standard requires.  */
 
 #define this_byte(ieee) *((ieee)->input_p)
@@ -193 +316 @@
   unsigned char c1 = this_byte_and_next (ieee);
   unsigned char c2 = this_byte_and_next (ieee);
+
   return (c1 << 8) | c2;
 }
@@ -203 +327 @@
 {
   size_t i;
+
   for (i = 0; i < length; i++)
-    {
-      string[i] = this_byte_and_next (ieee);
-    }
+    string[i] = this_byte_and_next (ieee);
 }
 
@@ -215 +338 @@
   size_t length;
   char *string;
+
   length = this_byte_and_next (ieee);
   if (length <= 0x7f)
     {
-      /* Simple string of length 0 to 127 */
+      /* Simple string of length 0 to 127.  */
     }
   else if (length == 0xde)
     {
-      /* Length is next byte, allowing 0..255 */
+      /* Length is next byte, allowing 0..255.  */
       length = this_byte_and_next (ieee);
     }
   else if (length == 0xdf)
     {
-      /* Length is next two bytes, allowing 0..65535 */
+      /* Length is next two bytes, allowing 0..65535.  */
       length = this_byte_and_next (ieee);
       length = (length * 256) + this_byte_and_next (ieee);
     }
-  /* Buy memory and read string */
-  string = bfd_alloc (ieee->abfd, length + 1);
+
+  /* Buy memory and read string.  */
+  string = bfd_alloc (ieee->abfd, (bfd_size_type) length + 1);
   if (!string)
     return NULL;
@@ -240 +365 @@
 }
 
-static boolean
+static bfd_boolean
 ieee_write_expression (abfd, value, symbol, pcrel, index)
      bfd *abfd;
      bfd_vma value;
      asymbol *symbol;
-     boolean pcrel;
+     bfd_boolean pcrel;
      unsigned int index;
 {
@@ -253 +378 @@
     {
       if (! ieee_write_int (abfd, value))
-        return false;
+        return FALSE;
       term_count++;
     }
 
-  if (bfd_is_com_section (symbol->section)
-      || bfd_is_und_section (symbol->section))
-    {
-      /* Def of a common symbol */
-      if (! ieee_write_byte (abfd, ieee_variable_X_enum)
-          || ! ieee_write_int (abfd, symbol->value))
-        return false;
-      term_count++;
-    }
-  else if (! bfd_is_abs_section (symbol->section))
-    {
-      /* Ref to defined symbol - */
-
-      if (symbol->flags & BSF_GLOBAL)
+  /* Badly formatted binaries can have a missing symbol,
+     so test here to prevent a seg fault.  */
+  if (symbol != NULL)
+    {
+      if (bfd_is_com_section (symbol->section)
+          || bfd_is_und_section (symbol->section))
         {
-          if (! ieee_write_byte (abfd, ieee_variable_I_enum)
+          /* Def of a common symbol.  */
+          if (! ieee_write_byte (abfd, ieee_variable_X_enum)
               || ! ieee_write_int (abfd, symbol->value))
-            return false;
-          term_count++;
+            return FALSE;
+          term_count ++;
         }
-      else if (symbol->flags & (BSF_LOCAL | BSF_SECTION_SYM))
+      else if (! bfd_is_abs_section (symbol->section))
         {
-          /* This is a reference to a defined local symbol.  We can
-             easily do a local as a section+offset.  */
-          if (! ieee_write_byte (abfd, ieee_variable_R_enum)
-              || ! ieee_write_byte (abfd,
-                                    (bfd_byte) (symbol->section->index
-                                                + IEEE_SECTION_NUMBER_BASE)))
-            return false;
-          term_count++;
-          if (symbol->value != 0)
+          /* Ref to defined symbol -  */
+
+          if (symbol->flags & BSF_GLOBAL)
             {
-              if (! ieee_write_int (abfd, symbol->value))
-                return false;
+              if (! ieee_write_byte (abfd, ieee_variable_I_enum)
+                  || ! ieee_write_int (abfd, symbol->value))
+                return FALSE;
               term_count++;
             }
+          else if (symbol->flags & (BSF_LOCAL | BSF_SECTION_SYM))
+            {
+              /* This is a reference to a defined local symbol.  We can
+                 easily do a local as a section+offset.  */
+              if (! ieee_write_byte (abfd, ieee_variable_R_enum)
+                  || ! ieee_write_byte (abfd,
+                                        (bfd_byte) (symbol->section->index
+                                                    + IEEE_SECTION_NUMBER_BASE)))
+                return FALSE;
+
+              term_count++;
+              if (symbol->value != 0)
+                {
+                  if (! ieee_write_int (abfd, symbol->value))
+                    return FALSE;
+                  term_count++;
+                }
+            }
+          else
+            {
+              (*_bfd_error_handler)
+                (_("%s: unrecognized symbol `%s' flags 0x%x"),
+                 bfd_get_filename (abfd), bfd_asymbol_name (symbol),
+                 symbol->flags);
+              bfd_set_error (bfd_error_invalid_operation);
+              return FALSE;
+            }
         }
-      else
-        {
-          (*_bfd_error_handler)
-            (_("%s: unrecognized symbol `%s' flags 0x%x"),
-             bfd_get_filename (abfd), bfd_asymbol_name (symbol),
-             symbol->flags);
-          bfd_set_error (bfd_error_invalid_operation);
-          return false;
-        }
     }
 
   if (pcrel)
     {
-      /* subtract the pc from here by asking for PC of this section*/
+      /* Subtract the pc from here by asking for PC of this section.  */
       if (! ieee_write_byte (abfd, ieee_variable_P_enum)
           || ! ieee_write_byte (abfd,
                                 (bfd_byte) (index + IEEE_SECTION_NUMBER_BASE))
           || ! ieee_write_byte (abfd, ieee_function_minus_enum))
-        return false;
+        return FALSE;
     }
 
   /* Handle the degenerate case of a 0 address.  */
   if (term_count == 0)
-    {
-      if (! ieee_write_int (abfd, 0))
-        return false;
-    }
+    if (! ieee_write_int (abfd, (bfd_vma) 0))
+      return FALSE;
 
   while (term_count > 1)
     {
       if (! ieee_write_byte (abfd, ieee_function_plus_enum))
-        return false;
+        return FALSE;
       term_count--;
     }
 
-  return true;
-}
-
-
-/*****************************************************************************/
-
-/*
-writes any integer into the buffer supplied and always takes 5 bytes
-*/
+  return TRUE;
+}
+
+
+/* Writes any integer into the buffer supplied and always takes 5 bytes.  */
+
 static void
 ieee_write_int5 (buffer, value)
@@ -350 +476 @@
 }
 
-static boolean
+static bfd_boolean
 ieee_write_int5_out (abfd, value)
      bfd *abfd;
@@ -358 +484 @@
 
   ieee_write_int5 (b, value);
-  if (bfd_write ((PTR) b, 1, 5, abfd) != 5)
-    return false;
-  return true;
-}
-
-static boolean
+  if (bfd_bwrite ((PTR) b, (bfd_size_type) 5, abfd) != 5)
+    return FALSE;
+  return TRUE;
+}
+
+static bfd_boolean
 parse_int (ieee, value_ptr)
      common_header_type *ieee;
@@ -370 +496 @@
   int value = this_byte (ieee);
   int result;
+
   if (value >= 0 && value <= 127)
     {
       *value_ptr = value;
       next_byte (ieee);
-      return true;
+      return TRUE;
     }
   else if (value >= 0x80 && value <= 0x88)
     {
       unsigned int count = value & 0xf;
+
       result = 0;
       next_byte (ieee);
@@ -387 +515 @@
         }
       *value_ptr = result;
-      return true;
-    }
-  return false;
+      return TRUE;
+    }
+  return FALSE;
 }
 
@@ -395 +523 @@
 parse_i (ieee, ok)
      common_header_type *ieee;
-     boolean *ok;
+     bfd_boolean *ok;
 {
   bfd_vma x;
@@ -407 +535 @@
 {
   bfd_vma result;
-  BFD_ASSERT (parse_int (ieee, &result) == true);
+  BFD_ASSERT (parse_int (ieee, &result));
   return result;
 }
@@ -422 +550 @@
 
 #define SRC_MASK(arg) arg
-#define PCREL_OFFSET false
+#define PCREL_OFFSET FALSE
 
 #else
 
 #define SRC_MASK(arg) 0
-#define PCREL_OFFSET true
+#define PCREL_OFFSET TRUE
 
 #endif
@@ -436 +564 @@
          2,
          32,
-         false,
+         FALSE,
          0,
          complain_overflow_bitfield,
          0,
          "abs32",
-         true,
+         TRUE,
          0xffffffff,
          0xffffffff,
-         false);
+         FALSE);
 
 static reloc_howto_type abs16_howto =
@@ -451 +579 @@
          1,
          16,
-         false,
+         FALSE,
          0,
          complain_overflow_bitfield,
          0,
          "abs16",
-         true,
+         TRUE,
          0x0000ffff,
          0x0000ffff,
-         false);
+         FALSE);
 
 static reloc_howto_type abs8_howto =
@@ -466 +594 @@
          0,
          8,
-         false,
+         FALSE,
          0,
          complain_overflow_bitfield,
          0,
          "abs8",
-         true,
+         TRUE,
          0x000000ff,
          0x000000ff,
-         false);
+         FALSE);
 
 static reloc_howto_type rel32_howto =
@@ -481 +609 @@
          2,
          32,
-         true,
+         TRUE,
          0,
          complain_overflow_signed,
          0,
          "rel32",
-         true,
+         TRUE,
          SRC_MASK (0xffffffff),
          0xffffffff,
@@ -496 +624 @@
          1,
          16,
-         true,
+         TRUE,
          0,
          complain_overflow_signed,
          0,
          "rel16",
-         true,
+         TRUE,
          SRC_MASK (0x0000ffff),
          0x0000ffff,
@@ -511 +639 @@
          0,
          8,
-         true,
+         TRUE,
          0,
          complain_overflow_signed,
          0,
          "rel8",
-         true,
+         TRUE,
          SRC_MASK (0x000000ff),
          0x000000ff,
@@ -528 +656 @@
      bfd_vma *value;
      ieee_symbol_index_type *symbol;
-     boolean *pcrel;
+     bfd_boolean *pcrel;
      unsigned int *extra;
      asection **section;
@@ -539 +667 @@
 #define DEC sp--;
 
-  boolean loop = true;
+  bfd_boolean loop = TRUE;
   ieee_value_type stack[10];
 
-  /* The stack pointer always points to the next unused location */
+  /* The stack pointer always points to the next unused location.  */
 #define PUSH(x,y,z) TOS.symbol=x;TOS.section=y;TOS.value=z;INC;
 #define POP(x,y,z) DEC;x=TOS.symbol;y=TOS.section;z=TOS.value;
   ieee_value_type *sp = stack;
-
-  while (loop)
+  asection *dummy;
+
+  while (loop && ieee->h.input_p < ieee->h.last_byte)
     {
       switch (this_byte (&(ieee->h)))
         {
         case ieee_variable_P_enum:
-          /* P variable, current program counter for section n */
+          /* P variable, current program counter for section n.  */
           {
             int section_n;
+
             next_byte (&(ieee->h));
-            *pcrel = true;
+            *pcrel = TRUE;
             section_n = must_parse_int (&(ieee->h));
             PUSH (NOSYMBOL, bfd_abs_section_ptr, 0);
@@ -562 +692 @@
           }
         case ieee_variable_L_enum:
-          /* L variable  address of section N */
+          /* L variable  address of section N.  */
           next_byte (&(ieee->h));
           PUSH (NOSYMBOL, ieee->section_table[must_parse_int (&(ieee->h))], 0);
           break;
         case ieee_variable_R_enum:
-          /* R variable, logical address of section module */
-          /* FIXME, this should be different to L */
+          /* R variable, logical address of section module.  */
+          /* FIXME, this should be different to L.  */
           next_byte (&(ieee->h));
           PUSH (NOSYMBOL, ieee->section_table[must_parse_int (&(ieee->h))], 0);
           break;
         case ieee_variable_S_enum:
-          /* S variable, size in MAUS of section module */
+          /* S variable, size in MAUS of section module.  */
           next_byte (&(ieee->h));
           PUSH (NOSYMBOL,
@@ -580 +710 @@
           break;
         case ieee_variable_I_enum:
-          /* Push the address of variable n */
+          /* Push the address of variable n.  */
           {
             ieee_symbol_index_type sy;
@@ -591 +721 @@
           break;
         case ieee_variable_X_enum:
-          /* Push the address of external variable n */
+          /* Push the address of external variable n.  */
           {
             ieee_symbol_index_type sy;
@@ -640 +770 @@
             else
               {
-                /*
-                  Thats all that we can understand. As far as I can see
-                  there is a bug in the Microtec IEEE output which I'm
-                  using to scan, whereby the comma operator is omitted
-                  sometimes in an expression, giving expressions with too
-                  many terms. We can tell if that's the case by ensuring
-                  that sp == stack here. If not, then we've pushed
-                  something too far, so we keep adding.  */
-
-                while (sp != stack + 1)
-                  {
-                    asection *section1;
-                    ieee_symbol_index_type sy1;
-                    POP (sy1, section1, *extra);
-                  }
-                {
-                  asection *dummy;
-
-                  POP (*symbol, dummy, *value);
-                  if (section)
-                    *section = dummy;
-                }
-
-                loop = false;
+                /* Thats all that we can understand.  */
+                loop = FALSE;
               }
           }
         }
     }
-}
-
-
-#define ieee_seek(abfd, offset) \
-  IEEE_DATA(abfd)->h.input_p = IEEE_DATA(abfd)->h.first_byte + offset
-
-#define ieee_pos(abfd) \
-  (IEEE_DATA(abfd)->h.input_p - IEEE_DATA(abfd)->h.first_byte)
+
+  /* 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(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];
+
+  return after;
+}
 
 static unsigned int last_index;
-static char last_type;          /* is the index for an X or a D */
+static char last_type;          /* Is the index for an X or a D.  */
 
 static ieee_symbol_type *
-get_symbol (abfd,
-            ieee,
-            last_symbol,
-            symbol_count,
-            pptr,
-            max_index,
-            this_type
-)
+get_symbol (abfd, ieee, last_symbol, symbol_count, pptr, max_index, this_type)
      bfd *abfd ATTRIBUTE_UNUSED;
      ieee_data_type *ieee;
@@ -695 +838 @@
      ieee_symbol_type ***pptr;
      unsigned int *max_index;
-     char this_type
-      ;
-{
-  /* Need a new symbol */
+     int this_type;
+{
+  /* Need a new symbol.  */
   unsigned int new_index = must_parse_int (&(ieee->h));
+
   if (new_index != last_index || this_type != last_type)
     {
-      ieee_symbol_type *new_symbol = (ieee_symbol_type *) bfd_alloc (ieee->h.abfd,
-                                                 sizeof (ieee_symbol_type));
+      ieee_symbol_type *new_symbol;
+      bfd_size_type amt = sizeof (ieee_symbol_type);
+
+      new_symbol = (ieee_symbol_type *) bfd_alloc (ieee->h.abfd, amt);
       if (!new_symbol)
         return NULL;
@@ -713 +858 @@
       *pptr = &new_symbol->next;
       if (new_index > *max_index)
-        {
-          *max_index = new_index;
-        }
+        *max_index = new_index;
+
       last_type = this_type;
       new_symbol->symbol.section = bfd_abs_section_ptr;
@@ -723 +867 @@
 }
 
-static boolean
+static bfd_boolean
 ieee_slurp_external_symbols (abfd)
      bfd *abfd;
@@ -734 +878 @@
   ieee_symbol_type *symbol = (ieee_symbol_type *) NULL;
   unsigned int symbol_count = 0;
-  boolean loop = true;
+  bfd_boolean loop = TRUE;
   last_index = 0xffffff;
-  ieee->symbol_table_full = true;
-
-  ieee_seek (abfd, offset);
+  ieee->symbol_table_full = TRUE;
+
+  ieee_seek (ieee, offset);
 
   while (loop)
@@ -751 +895 @@
                                &ieee->external_symbol_max_index, 'I');
           if (symbol == NULL)
-            return false;
+            return FALSE;
 
           symbol->symbol.the_bfd = abfd;
@@ -765 +909 @@
                                &ieee->external_symbol_max_index, 'D');
           if (symbol == NULL)
-            return false;
+            return FALSE;
 
           BFD_ASSERT (symbol->index >= ieee->external_symbol_min_index);
@@ -780 +924 @@
             unsigned int symbol_attribute_def;
             bfd_vma value;
-            switch (read_2bytes (ieee))
+            switch (read_2bytes (&ieee->h))
               {
               case ieee_attribute_record_enum:
@@ -794 +938 @@
                   default:
                     (*_bfd_error_handler)
-                      (_("%s: unimplemented ATI record  %u for symbol %u"),
-                       bfd_get_filename (abfd), symbol_attribute_def,
+                      (_("%s: unimplemented ATI record %u for symbol %u"),
+                       bfd_archive_filename (abfd), symbol_attribute_def,
                        symbol_name_index);
                     bfd_set_error (bfd_error_bad_value);
-                    return false;
+                    return FALSE;
                     break;
                   }
                 break;
               case ieee_external_reference_info_record_enum:
-                /* Skip over ATX record. */
+                /* Skip over ATX record.  */
                 parse_int (&(ieee->h), &value);
                 parse_int (&(ieee->h), &value);
@@ -812 +956 @@
                 /* We may get call optimization information here,
                    which we just ignore.  The format is
-                   {$F1}${CE}{index}{$00}{$3F}{$3F}{#_of_ASNs} */
+                   {$F1}${CE}{index}{$00}{$3F}{$3F}{#_of_ASNs}.  */
                 parse_int (&ieee->h, &value);
                 parse_int (&ieee->h, &value);
@@ -820 +964 @@
                     (*_bfd_error_handler)
                       (_("%s: unexpected ATN type %d in external part"),
-                         bfd_get_filename (abfd), (int) value);
+                         bfd_archive_filename (abfd), (int) value);
                     bfd_set_error (bfd_error_bad_value);
-                    return false;
+                    return FALSE;
                   }
                 parse_int (&ieee->h, &value);
@@ -832 +976 @@
                     --value;
 
-                    switch (read_2bytes (ieee))
+                    switch (read_2bytes (&ieee->h))
                       {
                       case ieee_asn_record_enum:
@@ -842 +986 @@
                         (*_bfd_error_handler)
                           (_("%s: unexpected type after ATN"),
-                             bfd_get_filename (abfd));
+                             bfd_archive_filename (abfd));
                         bfd_set_error (bfd_error_bad_value);
-                        return false;
+                        return FALSE;
                       }
                   }
@@ -854 +998 @@
             unsigned int symbol_name_index;
             ieee_symbol_index_type symbol_ignore;
-            boolean pcrel_ignore;
+            bfd_boolean pcrel_ignore;
             unsigned int extra;
             next_byte (&(ieee->h));
@@ -898 +1042 @@
             bfd_vma value;
             next_byte (&(ieee->h));
-            /* Throw away the external reference index */
+            /* Throw away the external reference index.  */
             (void) must_parse_int (&(ieee->h));
-            /* Fetch the default size if not resolved */
+            /* Fetch the default size if not resolved.  */
             size = must_parse_int (&(ieee->h));
-            /* Fetch the defautlt value if available */
-            if (parse_int (&(ieee->h), &value) == false)
+            /* Fetch the defautlt value if available.  */
+            if (! parse_int (&(ieee->h), &value))
               {
                 value = 0;
               }
-            /* This turns into a common */
+            /* This turns into a common.  */
             symbol->symbol.section = bfd_com_section_ptr;
             symbol->symbol.value = size;
@@ -920 +1064 @@
                                &ieee->external_reference_max_index, 'X');
           if (symbol == NULL)
-            return false;
+            return FALSE;
 
           symbol->symbol.the_bfd = abfd;
@@ -933 +1077 @@
 
         default:
-          loop = false;
+          loop = FALSE;
         }
     }
@@ -965 +1109 @@
     {
       /* There are gaps in the table -- */
-      ieee->symbol_table_full = false;
+      ieee->symbol_table_full = FALSE;
     }
 
@@ -971 +1115 @@
   *prev_reference_ptr = (ieee_symbol_type *) NULL;
 
-  return true;
-}
-
-static boolean
+  return TRUE;
+}
+
+static bfd_boolean
 ieee_slurp_symbol_table (abfd)
      bfd *abfd;
 {
-  if (IEEE_DATA (abfd)->read_symbols == false)
+  if (! IEEE_DATA (abfd)->read_symbols)
     {
       if (! ieee_slurp_external_symbols (abfd))
-        return false;
-      IEEE_DATA (abfd)->read_symbols = true;
-    }
-  return true;
-}
-
-long
+        return FALSE;
+      IEEE_DATA (abfd)->read_symbols = TRUE;
+    }
+  return TRUE;
+}
+
+static long
 ieee_get_symtab_upper_bound (abfd)
      bfd *abfd;
@@ -998 +1142 @@
 }
 
-/*
-Move from our internal lists to the canon table, and insert in
-symbol index order
-*/
+/* Move from our internal lists to the canon table, and insert in
+   symbol index order.  */
 
 extern const bfd_target ieee_vec;
 
-long
+static long
 ieee_get_symtab (abfd, location)
      bfd *abfd;
@@ -1032 +1174 @@
         return -1;
 
-      if (ieee->symbol_table_full == false)
+      if (! ieee->symbol_table_full)
         {
-          /* Arrgh - there are gaps in the table, run through and fill them */
-          /* up with pointers to a null place */
+          /* Arrgh - there are gaps in the table, run through and fill them
+             up with pointers to a null place.  */
           unsigned int i;
+
           for (i = 0; i < abfd->symcount; i++)
-            {
-              location[i] = &empty_symbol;
-            }
+            location[i] = &empty_symbol;
         }
 
@@ -1047 +1188 @@
            symp != (ieee_symbol_type *) NULL;
            symp = symp->next)
-        {
-          /* Place into table at correct index locations */
-          location[symp->index + ieee->external_symbol_base_offset] = &symp->symbol;
-        }
-
-      /* The external refs are indexed in a bit */
+        /* Place into table at correct index locations.  */
+        location[symp->index + ieee->external_symbol_base_offset] = &symp->symbol;
+
+      /* The external refs are indexed in a bit.  */
       ieee->external_reference_base_offset =
         -ieee->external_reference_min_index + ieee->external_symbol_count;
@@ -1059 +1198 @@
            symp != (ieee_symbol_type *) NULL;
            symp = symp->next)
-        {
-          location[symp->index + ieee->external_reference_base_offset] =
-            &symp->symbol;
-
-        }
-    }
+        location[symp->index + ieee->external_reference_base_offset] =
+          &symp->symbol;
+    }
+
   if (abfd->symcount)
-    {
-      location[abfd->symcount] = (asymbol *) NULL;
-    }
+    location[abfd->symcount] = (asymbol *) NULL;
+
   return abfd->symcount;
 }
@@ -1082 +1218 @@
       unsigned int c, i;
       asection **n;
+      bfd_size_type amt;
 
       c = ieee->section_table_size;
@@ -1089 +1226 @@
         c *= 2;
 
-      n = ((asection **)
-           bfd_realloc (ieee->section_table, c * sizeof (asection *)));
+      amt = c;
+      amt *= sizeof (asection *);
+      n = (asection **) bfd_realloc (ieee->section_table, amt);
       if (n == NULL)
         return NULL;
@@ -1103 +1241 @@
   if (ieee->section_table[index] == (asection *) NULL)
     {
-      char *tmp = bfd_alloc (abfd, 11);
+      char *tmp = bfd_alloc (abfd, (bfd_size_type) 11);
       asection *section;
 
@@ -1124 +1262 @@
   ieee_data_type *ieee = IEEE_DATA (abfd);
   file_ptr offset = ieee->w.r.section_part;
-  asection *section = (asection *) NULL;
   char *name;
 
@@ -1130 +1267 @@
     {
       bfd_byte section_type[3];
-      ieee_seek (abfd, offset);
-      while (true)
+      ieee_seek (ieee, offset);
+      while (TRUE)
         {
           switch (this_byte (&(ieee->h)))
@@ -1137 +1274 @@
             case ieee_section_type_enum:
               {
+                asection *section;
                 unsigned int section_index;
                 next_byte (&(ieee->h));
@@ -1146 +1284 @@
 
                 /* Set minimal section attributes. Attributes are
-                   extended later, based on section contents. */
-
+                   extended later, based on section contents.  */
                 switch (section_type[0])
                   {
                   case 0xC1:
-                    /* Normal attributes for absolute sections  */
+                    /* Normal attributes for absolute sections.  */
                     section_type[1] = this_byte (&(ieee->h));
                     section->flags = SEC_ALLOC;
                     switch (section_type[1])
                       {
-                      case 0xD3:        /* AS Absolute section attributes */
+                      case 0xD3:        /* AS Absolute section attributes.  */
                         next_byte (&(ieee->h));
                         section_type[2] = this_byte (&(ieee->h));
@@ -1162 +1299 @@
                           {
                           case 0xD0:
-                            /* Normal code */
+                            /* Normal code.  */
                             next_byte (&(ieee->h));
                             section->flags |= SEC_CODE;
                             break;
                           case 0xC4:
-                            /* Normal data */
+                            /* Normal data.  */
                             next_byte (&(ieee->h));
                             section->flags |= SEC_DATA;
@@ -1173 +1310 @@
                           case 0xD2:
                             next_byte (&(ieee->h));
-                            /* Normal rom data */
+                            /* Normal rom data.  */
                             section->flags |= SEC_ROM | SEC_DATA;
                             break;
@@ -1181 +1318 @@
                       }
                     break;
-                  case 0xC3:    /* Named relocatable sections (type C) */
+                  case 0xC3:    /* Named relocatable sections (type C).  */
                     section_type[1] = this_byte (&(ieee->h));
                     section->flags = SEC_ALLOC;
                     switch (section_type[1])
                       {
-                      case 0xD0:        /* Normal code (CP) */
+                      case 0xD0:        /* Normal code (CP).  */
                         next_byte (&(ieee->h));
                         section->flags |= SEC_CODE;
                         break;
-                      case 0xC4:        /* Normal data (CD) */
+                      case 0xC4:        /* Normal data (CD).  */
                         next_byte (&(ieee->h));
                         section->flags |= SEC_DATA;
                         break;
-                      case 0xD2:        /* Normal rom data (CR) */
+                      case 0xD2:        /* Normal rom data (CR).  */
                         next_byte (&(ieee->h));
                         section->flags |= SEC_ROM | SEC_DATA;
@@ -1203 +1340 @@
                   }
 
-                /* Read section name, use it if non empty. */
+                /* Read section name, use it if non empty.  */
                 name = read_id (&ieee->h);
                 if (name[0])
                   section->name = name;
 
-                /* Skip these fields, which we don't care about */
+                /* Skip these fields, which we don't care about.  */
                 {
                   bfd_vma parent, brother, context;
@@ -1236 +1373 @@
             case ieee_e2_first_byte_enum:
               {
-                ieee_record_enum_type t = (ieee_record_enum_type) (read_2bytes (&(ieee->h)));
-
+                asection *section;
+                ieee_record_enum_type t;
+
+                t = (ieee_record_enum_type) (read_2bytes (&(ieee->h)));
                 switch (t)
                   {
@@ -1287 +1426 @@
    out.  */
 
-static boolean
+static bfd_boolean
 ieee_slurp_debug (abfd)
      bfd *abfd;
@@ -1296 +1435 @@
 
   if (ieee->w.r.debug_information_part == 0)
-    return true;
+    return TRUE;
 
   sec = bfd_make_section (abfd, ".debug");
   if (sec == NULL)
-    return false;
+    return FALSE;
   sec->flags |= SEC_DEBUGGING | SEC_HAS_CONTENTS;
   sec->filepos = ieee->w.r.debug_information_part;
 
-  debug_end = ieee->w.r.data_part;
-  if (debug_end == 0)
-    debug_end = ieee->w.r.trailer_part;
-  if (debug_end == 0)
-    debug_end = ieee->w.r.me_record;
+  debug_end = ieee_part_after (ieee, ieee->w.r.debug_information_part);
   sec->_raw_size = debug_end - ieee->w.r.debug_information_part;
 
-  return true;
-}
-
-
-/***********************************************************************
-*  archive stuff
-*/
+  return TRUE;
+}
+
+
+/* Archive stuff.  */
 
 const bfd_target *
@@ -1329 +1462 @@
   ieee_ar_data_type *save = abfd->tdata.ieee_ar_data;
   ieee_ar_data_type *ieee;
-  unsigned int alc_elts;
+  bfd_size_type alc_elts;
   ieee_ar_obstack_type *elts = NULL;
-
-  abfd->tdata.ieee_ar_data =
-    (ieee_ar_data_type *) bfd_alloc (abfd, sizeof (ieee_ar_data_type));
+  bfd_size_type amt = sizeof (ieee_ar_data_type);
+
+  abfd->tdata.ieee_ar_data = (ieee_ar_data_type *) bfd_alloc (abfd, amt);
   if (!abfd->tdata.ieee_ar_data)
-    goto error_return;
+    goto error_ret_restore;
   ieee = IEEE_AR_DATA (abfd);
 
-  /* FIXME: Check return value.  I'm not sure whether it needs to read
-     the entire buffer or not.  */
-  bfd_read ((PTR) buffer, 1, sizeof (buffer), abfd);
+  /* Ignore the return value here.  It doesn't matter if we don't read
+     the entire buffer.  We might have a very small ieee file.  */
+  bfd_bread ((PTR) buffer, (bfd_size_type) sizeof (buffer), abfd);
 
   ieee->h.first_byte = buffer;
@@ -1400 +1533 @@
 
       /* Make sure that we don't go over the end of the buffer.  */
-      if ((size_t) ieee_pos (abfd) > sizeof (buffer) / 2)
+      if ((size_t) ieee_pos (IEEE_DATA (abfd)) > sizeof (buffer) / 2)
         {
           /* Past half way, reseek and reprime.  */
-          buffer_offset += ieee_pos (abfd);
+          buffer_offset += ieee_pos (IEEE_DATA (abfd));
           if (bfd_seek (abfd, buffer_offset, SEEK_SET) != 0)
             goto error_return;
 
-          /* FIXME: Check return value.  I'm not sure whether it needs
-             to read the entire buffer or not.  */
-          bfd_read ((PTR) buffer, 1, sizeof (buffer), abfd);
+          /* Again ignore return value of bfd_bread.  */
+          bfd_bread ((PTR) buffer, (bfd_size_type) sizeof (buffer), abfd);
           ieee->h.first_byte = buffer;
           ieee->h.input_p = buffer;
@@ -1415 +1547 @@
     }
 
-  ieee->elements = ((ieee_ar_obstack_type *)
-                    bfd_alloc (abfd,
-                               ieee->element_count * sizeof *ieee->elements));
+  amt = ieee->element_count;
+  amt *= sizeof *ieee->elements;
+  ieee->elements = (ieee_ar_obstack_type *) bfd_alloc (abfd, amt);
   if (ieee->elements == NULL)
     goto error_return;
 
-  memcpy (ieee->elements, elts,
-          ieee->element_count * sizeof *ieee->elements);
+  memcpy (ieee->elements, elts, (size_t) amt);
   free (elts);
   elts = NULL;
@@ -1432 +1563 @@
         goto error_return;
 
-      /* FIXME: Check return value.  I'm not sure whether it needs to
-         read the entire buffer or not.  */
-      bfd_read ((PTR) buffer, 1, sizeof (buffer), abfd);
+      /* Again ignore return value of bfd_bread.  */
+      bfd_bread ((PTR) buffer, (bfd_size_type) sizeof (buffer), abfd);
       ieee->h.first_byte = buffer;
       ieee->h.input_p = buffer;
@@ -1441 +1571 @@
       next_byte (&(ieee->h));           /* Drop 14.  */
       must_parse_int (&(ieee->h));      /* Drop size of block.  */
-      
+
       if (must_parse_int (&(ieee->h)) != 0)
         /* This object has been deleted.  */
@@ -1454 +1584 @@
 
  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);
+  bfd_release (abfd, ieee);
+ error_ret_restore:
+  abfd->tdata.ieee_ar_data = save;
 
   return NULL;
-}
-
-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;
 }
 
@@ -1482 +1604 @@
   unsigned char buffer[300];
   ieee_data_type *save = IEEE_DATA (abfd);
+  bfd_size_type amt;
 
   abfd->tdata.ieee_data = 0;
@@ -1489 +1612 @@
   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
     goto fail;
-  /* Read the first few bytes in to see if it makes sense */
-  /* FIXME: Check return value.  I'm not sure whether it needs to read
-     the entire buffer or not.  */
-  bfd_read ((PTR) buffer, 1, sizeof (buffer), abfd);
+  /* Read the first few bytes in to see if it makes sense.  Ignore
+     bfd_bread return value;  The file might be very small.  */
+  bfd_bread ((PTR) buffer, (bfd_size_type) sizeof (buffer), abfd);
 
   ieee->h.input_p = buffer;
@@ -1498 +1620 @@
     goto got_wrong_format;
 
-  ieee->read_symbols = false;
-  ieee->read_data = false;
+  ieee->read_symbols = FALSE;
+  ieee->read_data = FALSE;
   ieee->section_count = 0;
   ieee->external_symbol_max_index = 0;
@@ -1513 +1635 @@
     goto got_wrong_format;
   ieee->mb.module_name = read_id (&(ieee->h));
-  if (abfd->filename == (CONST char *) NULL)
-    {
-      abfd->filename = ieee->mb.module_name;
-    }
-  /* Determine the architecture and machine type of the object file.
-     */
+  if (abfd->filename == (const char *) NULL)
+    abfd->filename = ieee->mb.module_name;
+
+  /* Determine the architecture and machine type of the object file.  */
   {
     const bfd_arch_info_type *arch;
@@ -1557 +1677 @@
               }
           }
-        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')))
+        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");
@@ -1568 +1688 @@
             family[9] = '\0';
           }
-        else                             /* "Regular" processors */
+        else                             /* "Regular" processors.  */
           {
             strncpy (family, processor, 9);
@@ -1590 +1710 @@
 
   if (this_byte (&(ieee->h)) != (int) ieee_address_descriptor_enum)
-    {
-      goto fail;
-    }
+    goto fail;
+
   next_byte (&(ieee->h));
 
-  if (parse_int (&(ieee->h), &ieee->ad.number_of_bits_mau) == false)
-    {
-      goto fail;
-    }
-  if (parse_int (&(ieee->h), &ieee->ad.number_of_maus_in_address) == false)
-    {
-      goto fail;
-    }
-
-  /* If there is a byte order info, take it */
-  if (this_byte (&(ieee->h)) == (int) ieee_variable_L_enum ||
-      this_byte (&(ieee->h)) == (int) ieee_variable_M_enum)
+  if (! parse_int (&(ieee->h), &ieee->ad.number_of_bits_mau))
+    goto fail;
+
+  if (! parse_int (&(ieee->h), &ieee->ad.number_of_maus_in_address))
+    goto fail;
+
+  /* If there is a byte order info, take it.  */
+  if (this_byte (&(ieee->h)) == (int) ieee_variable_L_enum
+      || this_byte (&(ieee->h)) == (int) ieee_variable_M_enum)
     next_byte (&(ieee->h));
 
   for (part = 0; part < N_W_VARIABLES; part++)
     {
-      boolean ok;
+      bfd_boolean ok;
+
       if (read_2bytes (&(ieee->h)) != (int) ieee_assign_value_to_variable_enum)
-        {
-          goto fail;
-        }
+        goto fail;
+
       if (this_byte_and_next (&(ieee->h)) != part)
-        {
-          goto fail;
-        }
+        goto fail;
 
       ieee->w.offset[part] = parse_i (&(ieee->h), &ok);
-      if (ok == false)
-        {
-          goto fail;
-        }
-
+      if (! ok)
+        goto fail;
     }
 
@@ -1635 +1746 @@
      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 */
-
+     record.  */
+
+  amt = ieee->w.r.me_record + 1;
   IEEE_DATA (abfd)->h.first_byte =
-    (unsigned char *) bfd_alloc (ieee->h.abfd, ieee->w.r.me_record + 1);
+    (unsigned char *) bfd_alloc (ieee->h.abfd, amt);
   if (!IEEE_DATA (abfd)->h.first_byte)
     goto fail;
@@ -1645 +1757 @@
   /* 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);
+  bfd_bread ((PTR) (IEEE_DATA (abfd)->h.first_byte),
+            (bfd_size_type) ieee->w.r.me_record + 1, abfd);
 
   ieee_slurp_sections (abfd);
@@ -1655 +1767 @@
   /* Parse section data to activate file and section flags implied by
      section contents. */
-
   if (! ieee_slurp_section_data (abfd))
     goto fail;
-    
+
   return abfd->xvec;
 got_wrong_format:
   bfd_set_error (bfd_error_wrong_format);
 fail:
-  (void) bfd_release (abfd, ieee);
+  bfd_release (abfd, ieee);
   abfd->tdata.ieee_data = save;
   return (const bfd_target *) NULL;
 }
 
-void
+static void
 ieee_get_symbol_info (ignore_abfd, symbol, ret)
      bfd *ignore_abfd ATTRIBUTE_UNUSED;
@@ -1681 +1792 @@
 }
 
-void
-ieee_print_symbol (ignore_abfd, afile, symbol, how)
-     bfd *ignore_abfd ATTRIBUTE_UNUSED;
+static void
+ieee_print_symbol (abfd, afile, symbol, how)
+     bfd *abfd;
      PTR afile;
      asymbol *symbol;
@@ -1708 +1819 @@
            ? "*abs"
            : symbol->section->name);
+
         if (symbol->name[0] == ' ')
           {
@@ -1714 +1826 @@
         else
           {
-            bfd_print_symbol_vandf ((PTR) file, symbol);
+            bfd_print_symbol_vandf (abfd, (PTR) file, symbol);
 
             fprintf (file, " %-5s %04x %02x %s",
@@ -1727 +1839 @@
 }
 
-static boolean
+static bfd_boolean
 do_one (ieee, current_map, location_ptr, s, iterations)
      ieee_data_type *ieee;
@@ -1741 +1853 @@
         unsigned int number_of_maus;
         unsigned int i;
+
         next_byte (&(ieee->h));
         number_of_maus = must_parse_int (&(ieee->h));
@@ -1754 +1867 @@
     case ieee_load_with_relocation_enum:
       {
-        boolean loop = true;
+        bfd_boolean loop = TRUE;
+
         next_byte (&(ieee->h));
         while (loop)
@@ -1767 +1881 @@
                 {
                   unsigned int extra = 4;
-                  boolean pcrel = false;
+                  bfd_boolean pcrel = FALSE;
                   asection *section;
-                  ieee_reloc_type *r =
-                  (ieee_reloc_type *) bfd_alloc (ieee->h.abfd,
-                                                 sizeof (ieee_reloc_type));
+                  ieee_reloc_type *r;
+                  bfd_size_type amt = sizeof (ieee_reloc_type);
+
+                  r = (ieee_reloc_type *) bfd_alloc (ieee->h.abfd, amt);
                   if (!r)
-                    return false;
+                    return FALSE;
 
                   *(current_map->reloc_tail_ptr) = r;
@@ -1795 +1910 @@
                     {
                       next_byte (&(ieee->h));
-                      /* Fetch number of bytes to pad */
+                      /* Fetch number of bytes to pad.  */
                       extra = must_parse_int (&(ieee->h));
                     };
@@ -1813 +1928 @@
                       break;
                     }
-                  /* Build a relocation entry for this type */
+                  /* Build a relocation entry for this type.  */
                   /* If pc rel then stick -ve pc into instruction
                      and take out of reloc ..
@@ -1825 +1940 @@
                     case 4:
 
-                      if (pcrel == true)
+                      if (pcrel)
                         {
 #if KEEPMINUSPCININST
-                          bfd_put_32 (ieee->h.abfd, -current_map->pc, location_ptr +
-                                      current_map->pc);
+                          bfd_put_32 (ieee->h.abfd, -current_map->pc,
+                                      location_ptr + current_map->pc);
                           r->relent.howto = &rel32_howto;
-                          r->relent.addend -=
-                            current_map->pc;
+                          r->relent.addend -= current_map->pc;
 #else
-                          bfd_put_32 (ieee->h.abfd, 0, location_ptr +
+                          bfd_put_32 (ieee->h.abfd, (bfd_vma) 0, location_ptr +
                                       current_map->pc);
                           r->relent.howto = &rel32_howto;
@@ -1841 +1955 @@
                       else
                         {
-                          bfd_put_32 (ieee->h.abfd, 0, location_ptr +
-                                      current_map->pc);
+                          bfd_put_32 (ieee->h.abfd, (bfd_vma) 0,
+                                      location_ptr + current_map->pc);
                           r->relent.howto = &abs32_howto;
                         }
@@ -1848 +1962 @@
                       break;
                     case 2:
-                      if (pcrel == true)
+                      if (pcrel)
                         {
 #if KEEPMINUSPCININST
-                          bfd_put_16 (ieee->h.abfd, (int) (-current_map->pc), location_ptr + current_map->pc);
+                          bfd_put_16 (ieee->h.abfd, (bfd_vma) -current_map->pc,
+                                      location_ptr + current_map->pc);
                           r->relent.addend -= current_map->pc;
                           r->relent.howto = &rel16_howto;
 #else
 
-                          bfd_put_16 (ieee->h.abfd, 0, location_ptr + current_map->pc);
+                          bfd_put_16 (ieee->h.abfd, (bfd_vma) 0,
+                                      location_ptr + current_map->pc);
                           r->relent.howto = &rel16_howto;
 #endif
@@ -1863 +1979 @@
                       else
                         {
-                          bfd_put_16 (ieee->h.abfd, 0, location_ptr + current_map->pc);
+                          bfd_put_16 (ieee->h.abfd, (bfd_vma) 0,
+                                      location_ptr + current_map->pc);
                           r->relent.howto = &abs16_howto;
                         }
@@ -1869 +1986 @@
                       break;
                     case 1:
-                      if (pcrel == true)
+                      if (pcrel)
                         {
 #if KEEPMINUSPCININST
@@ -1890 +2007 @@
                     default:
                       BFD_FAIL ();
-                      return false;
+                      return FALSE;
                     }
                 }
@@ -1897 +2014 @@
                 {
                   bfd_vma this_size;
-                  if (parse_int (&(ieee->h), &this_size) == true)
+                  if (parse_int (&(ieee->h), &this_size))
                     {
                       unsigned int i;
@@ -1908 +2025 @@
                   else
                     {
-                      loop = false;
+                      loop = FALSE;
                     }
                 }
@@ -1916 +2033 @@
                from being repeated (MRI convention). */
             if (iterations != 1)
-              loop = false;
+              loop = FALSE;
           }
       }
     }
-  return true;
-}
-
-/* Read in all the section data and relocation stuff too */
-static boolean
+  return TRUE;
+}
+
+/* Read in all the section data and relocation stuff too.  */
+
+static bfd_boolean
 ieee_slurp_section_data (abfd)
      bfd *abfd;
@@ -1934 +2052 @@
   ieee_per_section_type *current_map = (ieee_per_section_type *) NULL;
   asection *s;
-  /* Seek to the start of the data area */
-  if (ieee->read_data == true)
-    return true;
-  ieee->read_data = true;
-  ieee_seek (abfd, ieee->w.r.data_part);
-
-  /* Allocate enough space for all the section contents */
-
+  /* Seek to the start of the data area.  */
+  if (ieee->read_data)
+    return TRUE;
+  ieee->read_data = TRUE;
+  ieee_seek (ieee, ieee->w.r.data_part);
+
+  /* Allocate enough space for all the section contents.  */
   for (s = abfd->sections; s != (asection *) NULL; s = s->next)
     {
-      ieee_per_section_type *per = (ieee_per_section_type *) s->used_by_bfd;
+      ieee_per_section_type *per = ieee_per_section (s);
       if ((s->flags & SEC_DEBUGGING) != 0)
         continue;
       per->data = (bfd_byte *) bfd_alloc (ieee->h.abfd, s->_raw_size);
       if (!per->data)
-        return false;
-      /*SUPPRESS 68*/
+        return FALSE;
       per->reloc_tail_ptr =
         (ieee_reloc_type **) & (s->relocation);
     }
 
-  while (true)
+  while (TRUE)
     {
       switch (this_byte (&(ieee->h)))
         {
-          /* IF we see anything strange then quit */
+          /* IF we see anything strange then quit.  */
         default:
-          return true;
+          return TRUE;
 
         case ieee_set_current_section_enum:
@@ -1968 +2084 @@
           s = ieee->section_table[section_number];
           s->flags |= SEC_LOAD | SEC_HAS_CONTENTS;
-          current_map = (ieee_per_section_type *) s->used_by_bfd;
+          current_map = ieee_per_section (s);
           location_ptr = current_map->data - s->vma;
-          /* The document I have says that Microtec's compilers reset */
-          /* this after a sec section, even though the standard says not */
-          /* to. SO .. */
+          /* The document I have says that Microtec's compilers reset
+             this after a sec section, even though the standard says not
+             to, SO...  */
           current_map->pc = s->vma;
           break;
@@ -1985 +2101 @@
                 ieee_symbol_index_type symbol;
                 unsigned int extra;
-                boolean pcrel;
+                bfd_boolean pcrel;
+
                 next_byte (&(ieee->h));
-                must_parse_int (&(ieee->h));    /* Thow away section #*/
+                must_parse_int (&(ieee->h));    /* Throw away section #.  */
                 parse_expression (ieee, &value,
                                   &symbol,
@@ -2002 +2119 @@
                 next_byte (&(ieee->h));
               abfd->start_address = must_parse_int (&(ieee->h));
-              /* We've got to the end of the data now - */
-              return true;
+              /* We've got to the end of the data now -  */
+              return TRUE;
             default:
               BFD_FAIL ();
-              return false;
+              return FALSE;
             }
           break;
@@ -2012 +2129 @@
           {
             /* Repeat the following LD or LR n times - we do this by
-                 remembering the stream pointer before running it and
-                 resetting it and running it n times. We special case
-                 the repetition of a repeat_data/load_constant
-                 */
-
+               remembering the stream pointer before running it and
+               resetting it and running it n times. We special case
+               the repetition of a repeat_data/load_constant.  */
             unsigned int iterations;
             unsigned char *start;
+
             next_byte (&(ieee->h));
             iterations = must_parse_int (&(ieee->h));
             start = ieee->h.input_p;
-            if (start[0] == (int) ieee_load_constant_bytes_enum &&
-                start[1] == 1)
+            if (start[0] == (int) ieee_load_constant_bytes_enum
+                && start[1] == 1)
               {
                 while (iterations != 0)
@@ -2040 +2156 @@
                     ieee->h.input_p = start;
                     if (!do_one (ieee, current_map, location_ptr, s,
-                                 iterations))
-                      return false;
+                                 (int) iterations))
+                      return FALSE;
                     iterations--;
                   }
@@ -2049 +2165 @@
         case ieee_load_constant_bytes_enum:
         case ieee_load_with_relocation_enum:
-          {
-            if (!do_one (ieee, current_map, location_ptr, s, 1))
-              return false;
-          }
+          if (!do_one (ieee, current_map, location_ptr, s, 1))
+            return FALSE;
         }
     }
 }
 
-boolean
+static bfd_boolean
 ieee_new_section_hook (abfd, newsect)
      bfd *abfd;
      asection *newsect;
 {
-  newsect->used_by_bfd = (PTR)
-    bfd_alloc (abfd, sizeof (ieee_per_section_type));
+  newsect->used_by_bfd
+    = (PTR) bfd_alloc (abfd, (bfd_size_type) sizeof (ieee_per_section_type));
   if (!newsect->used_by_bfd)
-    return false;
+    return FALSE;
   ieee_per_section (newsect)->data = (bfd_byte *) NULL;
   ieee_per_section (newsect)->section = newsect;
-  return true;
-}
-
-long
+  return TRUE;
+}
+
+static long
 ieee_get_reloc_upper_bound (abfd, asect)
      bfd *abfd;
@@ -2083 +2197 @@
 }
 
-static boolean
+static bfd_boolean
 ieee_get_section_contents (abfd, section, location, offset, count)
      bfd *abfd;
@@ -2091 +2205 @@
      bfd_size_type count;
 {
-  ieee_per_section_type *p = (ieee_per_section_type *) section->used_by_bfd;
+  ieee_per_section_type *p = ieee_per_section (section);
   if ((section->flags & SEC_DEBUGGING) != 0)
     return _bfd_generic_get_section_contents (abfd, section, location,
@@ -2097 +2211 @@
   ieee_slurp_section_data (abfd);
   (void) memcpy ((PTR) location, (PTR) (p->data + offset), (unsigned) count);
-  return true;
-}
-
-long
+  return TRUE;
+}
+
+static long
 ieee_canonicalize_reloc (abfd, section, relptr, symbols)
      bfd *abfd;
@@ -2107 +2221 @@
      asymbol **symbols;
 {
-/*  ieee_per_section_type *p = (ieee_per_section_type *) section->used_by_bfd;*/
   ieee_reloc_type *src = (ieee_reloc_type *) (section->relocation);
   ieee_data_type *ieee = IEEE_DATA (abfd);
@@ -2116 +2229 @@
   while (src != (ieee_reloc_type *) NULL)
     {
-      /* Work out which symbol to attach it this reloc to */
+      /* Work out which symbol to attach it this reloc to.  */
       switch (src->symbol.letter)
         {
@@ -2145 +2258 @@
 static int
 comp (ap, bp)
-     CONST PTR ap;
-     CONST PTR bp;
+     const PTR ap;
+     const PTR bp;
 {
   arelent *a = *((arelent **) ap);
@@ -2155 +2268 @@
 /* Write the section headers.  */
 
-static boolean
+static bfd_boolean
 ieee_write_section_part (abfd)
      bfd *abfd;
@@ -2171 +2284 @@
                                     (bfd_byte) (s->index
                                                 + IEEE_SECTION_NUMBER_BASE)))
-            return false;
+            return FALSE;
 
           if (abfd->flags & EXEC_P)
             {
-              /* This image is executable, so output absolute sections */
+              /* This image is executable, so output absolute sections.  */
               if (! ieee_write_byte (abfd, ieee_variable_A_enum)
                   || ! ieee_write_byte (abfd, ieee_variable_S_enum))
-                return false;
+                return FALSE;
             }
           else
             {
               if (! ieee_write_byte (abfd, ieee_variable_C_enum))
-                return false;
+                return FALSE;
             }
 
@@ -2191 +2304 @@
             case SEC_CODE:
               if (! ieee_write_byte (abfd, ieee_variable_P_enum))
-                return false;
+                return FALSE;
               break;
             case SEC_DATA:
             default:
               if (! ieee_write_byte (abfd, ieee_variable_D_enum))
-                return false;
+                return FALSE;
               break;
             case SEC_ROM:
@@ -2203 +2316 @@
             case SEC_ROM | SEC_DATA | SEC_LOAD:
               if (! ieee_write_byte (abfd, ieee_variable_R_enum))
-                return false;
+                return FALSE;
             }
 
 
           if (! ieee_write_id (abfd, s->name))
-            return false;
+            return FALSE;
 #if 0
           ieee_write_int (abfd, 0);     /* Parent */
@@ -2214 +2327 @@
           ieee_write_int (abfd, 0);     /* Context */
 #endif
-          /* Alignment */
+          /* Alignment.  */
           if (! ieee_write_byte (abfd, ieee_section_alignment_enum)
               || ! ieee_write_byte (abfd,
                                     (bfd_byte) (s->index
                                                 + IEEE_SECTION_NUMBER_BASE))
-              || ! ieee_write_int (abfd, 1 << s->alignment_power))
-            return false;
-
-          /* Size */
+              || ! ieee_write_int (abfd, (bfd_vma) 1 << s->alignment_power))
+            return FALSE;
+
+          /* Size.  */
           if (! ieee_write_2bytes (abfd, ieee_section_size_enum)
               || ! ieee_write_byte (abfd,
@@ -2228 +2341 @@
                                                 + IEEE_SECTION_NUMBER_BASE))
               || ! ieee_write_int (abfd, s->_raw_size))
-            return false;
+            return FALSE;
           if (abfd->flags & EXEC_P)
             {
-              /* Relocateable sections don't have asl records */
-              /* Vma */
+              /* Relocateable sections don't have asl records.  */
+              /* Vma.  */
               if (! ieee_write_2bytes (abfd, ieee_section_base_address_enum)
                   || ! ieee_write_byte (abfd,
@@ -2239 +2352 @@
                                           + IEEE_SECTION_NUMBER_BASE)))
                   || ! ieee_write_int (abfd, s->lma))
-                return false;
+                return FALSE;
             }
         }
     }
 
-  return true;
-}
-
-
-static boolean
+  return TRUE;
+}
+
+
+static bfd_boolean
 do_with_relocs (abfd, s)
      bfd *abfd;
@@ -2265 +2378 @@
          comp);
 
-  /* Output the section preheader */
+  /* Output the section preheader.  */
   if (! ieee_write_byte (abfd, ieee_set_current_section_enum)
       || ! ieee_write_byte (abfd,
@@ -2272 +2385 @@
       || ! ieee_write_byte (abfd,
                             (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE)))
-    return false;
+    return FALSE;
+
   if ((abfd->flags & EXEC_P) != 0 && relocs_to_go == 0)
     {
       if (! ieee_write_int (abfd, s->lma))
-        return false;
+        return FALSE;
     }
   else
     {
-      if (! ieee_write_expression (abfd, 0, s->symbol, 0, 0))
-        return false;
+      if (! ieee_write_expression (abfd, (bfd_vma) 0, s->symbol, 0, 0))
+        return FALSE;
     }
 
@@ -2287 +2401 @@
     {
       /* If there aren't any relocations then output the load constant
-         byte opcode rather than the load with relocation opcode */
-
+         byte opcode rather than the load with relocation opcode.  */
       while (current_byte_index < s->_raw_size)
         {
           bfd_size_type run;
           unsigned int MAXRUN = 127;
+
           run = MAXRUN;
           if (run > s->_raw_size - current_byte_index)
-            {
-              run = s->_raw_size - current_byte_index;
-            }
+            run = s->_raw_size - current_byte_index;
 
           if (run != 0)
             {
               if (! ieee_write_byte (abfd, ieee_load_constant_bytes_enum))
-                return false;
-              /* Output a stream of bytes */
+                return FALSE;
+              /* Output a stream of bytes.  */
               if (! ieee_write_int (abfd, run))
-                return false;
-              if (bfd_write ((PTR) (stream + current_byte_index),
-                             1,
-                             run,
-                             abfd)
+                return FALSE;
+              if (bfd_bwrite ((PTR) (stream + current_byte_index), run, abfd)
                   != run)
-                return false;
+                return FALSE;
               current_byte_index += run;
             }
@@ -2319 +2428 @@
     {
       if (! ieee_write_byte (abfd, ieee_load_with_relocation_enum))
-        return false;
+        return FALSE;
 
       /* Output the data stream as the longest sequence of bytes
@@ -2327 +2436 @@
       if ((PTR) stream == (PTR) NULL)
         {
-          /* Outputting a section without data, fill it up */
-          stream = (unsigned char *) (bfd_alloc (abfd, s->_raw_size));
+          /* Outputting a section without data, fill it up.  */
+          stream = (unsigned char *) bfd_zalloc (abfd, s->_raw_size);
           if (!stream)
-            return false;
-          memset ((PTR) stream, 0, (size_t) s->_raw_size);
+            return FALSE;
         }
       while (current_byte_index < s->_raw_size)
@@ -2337 +2445 @@
           bfd_size_type run;
           unsigned int MAXRUN = 127;
+
           if (relocs_to_go)
             {
@@ -2344 +2453 @@
             }
           else
-            {
-              run = MAXRUN;
-            }
+            run = MAXRUN;
+
           if (run > s->_raw_size - current_byte_index)
-            {
-              run = s->_raw_size - current_byte_index;
-            }
+            run = s->_raw_size - current_byte_index;
 
           if (run != 0)
             {
-              /* Output a stream of bytes */
+              /* Output a stream of bytes.  */
               if (! ieee_write_int (abfd, run))
-                return false;
-              if (bfd_write ((PTR) (stream + current_byte_index),
-                             1,
-                             run,
-                             abfd)
+                return FALSE;
+              if (bfd_bwrite ((PTR) (stream + current_byte_index), run, abfd)
                   != run)
-                return false;
+                return FALSE;
               current_byte_index += run;
             }
-          /* Output any relocations here */
+
+          /* Output any relocations here.  */
           if (relocs_to_go && (*p) && (*p)->address == current_byte_index)
             {
@@ -2373 +2477 @@
                   arelent *r = *p;
                   bfd_signed_vma ov;
-
 #if 0
                   if (r->howto->pc_relative)
-                    {
-                      r->addend += current_byte_index;
-                    }
+                    r->addend += current_byte_index;
 #endif
-
                   switch (r->howto->size)
                     {
@@ -2402 +2502 @@
                       ov = 0;
                       BFD_FAIL ();
-                      return false;
+                      return FALSE;
                     }
 
@@ -2413 +2513 @@
                   if (! ieee_write_byte (abfd,
                                          ieee_function_either_open_b_enum))
-                    return false;
+                    return FALSE;
 
 /*                abort();*/
@@ -2422 +2522 @@
                                                    *(r->sym_ptr_ptr),
                                                    r->howto->pc_relative,
-                                                   s->index))
-                        return false;
+                                                   (unsigned) s->index))
+                        return FALSE;
                     }
                   else
@@ -2430 +2530 @@
                                                    (asymbol *) NULL,
                                                    r->howto->pc_relative,
-                                                   s->index))
-                        return false;
+                                                   (unsigned) s->index))
+                        return FALSE;
                     }
 
@@ -2437 +2537 @@
                       != bfd_get_reloc_size (r->howto))
                     {
-                      if (! ieee_write_int (abfd,
-                                            bfd_get_reloc_size (r->howto)))
-                        return false;
+                      bfd_vma rsize = bfd_get_reloc_size (r->howto);
+                      if (! ieee_write_int (abfd, rsize))
+                        return FALSE;
                     }
                   if (! ieee_write_byte (abfd,
                                          ieee_function_either_close_b_enum))
-                    return false;
+                    return FALSE;
 
                   relocs_to_go--;
@@ -2453 +2553 @@
     }
 
-  return true;
+  return TRUE;
 }
 
@@ -2460 +2560 @@
    bytes.  */
 
-static boolean
+static bfd_boolean
 do_as_repeat (abfd, s)
      bfd *abfd;
@@ -2475 +2575 @@
           || ! ieee_write_byte (abfd,
                                 (bfd_byte) (s->index
-                                            + IEEE_SECTION_NUMBER_BASE))
-          || ! ieee_write_int (abfd, s->lma)
-          || ! ieee_write_byte (abfd, ieee_repeat_data_enum)
+                                            + IEEE_SECTION_NUMBER_BASE)))
+        return FALSE;
+
+      if ((abfd->flags & EXEC_P) != 0)
+        {
+          if (! ieee_write_int (abfd, s->lma))
+            return FALSE;
+        }
+      else
+        {
+          if (! ieee_write_expression (abfd, (bfd_vma) 0, s->symbol, 0, 0))
+            return FALSE;
+        }
+
+      if (! ieee_write_byte (abfd, ieee_repeat_data_enum)
           || ! ieee_write_int (abfd, s->_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 boolean
+        return FALSE;
+    }
+
+  return TRUE;
+}
+
+static bfd_boolean
 do_without_relocs (abfd, s)
      bfd *abfd;
@@ -2498 +2610 @@
     {
       if (! do_as_repeat (abfd, s))
-        return false;
+        return FALSE;
     }
   else
     {
       unsigned int i;
+
       for (i = 0; i < s->_raw_size; i++)
         {
@@ -2508 +2621 @@
             {
               if (! do_with_relocs (abfd, s))
-                return false;
-              return true;
+                return FALSE;
+              return TRUE;
             }
         }
       if (! do_as_repeat (abfd, s))
-        return false;
-    }
-
-  return true;
+        return FALSE;
+    }
+
+  return TRUE;
 }
 
@@ -2530 +2643 @@
 static int output_buffer;
 
+static bfd_boolean
+ieee_mkobject (abfd)
+     bfd *abfd;
+{
+  bfd_size_type amt;
+
+  output_ptr_start = NULL;
+  output_ptr = NULL;
+  output_ptr_end = NULL;
+  input_ptr_start = NULL;
+  input_ptr = NULL;
+  input_ptr_end = NULL;
+  input_bfd = NULL;
+  output_bfd = NULL;
+  output_buffer = 0;
+  amt = sizeof (ieee_data_type);
+  abfd->tdata.ieee_data = (ieee_data_type *) bfd_zalloc (abfd, amt);
+  return abfd->tdata.ieee_data != NULL;
+}
+
 static void
 fill ()
 {
+  bfd_size_type amt = input_ptr_end - input_ptr_start;
   /* FIXME: Check return value.  I'm not sure whether it needs to read
      the entire buffer or not.  */
-  bfd_read ((PTR) input_ptr_start, 1, input_ptr_end - input_ptr_start, input_bfd);
+  bfd_bread ((PTR) input_ptr_start, amt, input_bfd);
   input_ptr = input_ptr_start;
 }
+
 static void
 flush ()
 {
-  if (bfd_write ((PTR) (output_ptr_start), 1, output_ptr - output_ptr_start,
-                 output_bfd)
-      != (bfd_size_type) (output_ptr - output_ptr_start))
+  bfd_size_type amt = output_ptr - output_ptr_start;
+
+  if (bfd_bwrite ((PTR) (output_ptr_start), amt, output_bfd) != amt)
     abort ();
   output_ptr = output_ptr_start;
@@ -2564 +2699 @@
     {
       unsigned int length;
-      /* How many significant bytes ? */
-      /* FIXME FOR LONGER INTS */
+      /* How many significant bytes ?  */
+      /* FIXME FOR LONGER INTS.  */
       if (value & 0xff000000)
-        {
-          length = 4;
-        }
+        length = 4;
       else if (value & 0x00ff0000)
-        {
-          length = 3;
-        }
+        length = 3;
       else if (value & 0x0000ff00)
-        {
-          length = 2;
-        }
+        length = 2;
       else
         length = 1;
@@ -2593 +2722 @@
           OUT (value);
         }
-
     }
 }
@@ -2602 +2730 @@
   int length = THIS ();
   char ch;
+
   OUT (length);
   NEXT ();
@@ -2618 +2747 @@
   int stack[10];
   int *tos = stack;
-  int value = 0;
+  int value;
+
   while (1)
     {
@@ -2666 +2796 @@
           if (THIS () > 0x84)
             {
-              /* Not a number, just bug out with the answer */
+              /* Not a number, just bug out with the answer.  */
               write_int (*(--tos));
               return;
@@ -2672 +2802 @@
           *tos++ = THIS ();
           NEXT ();
-          value = 0;
           break;
         case 0xa5:
-          /* PLUS anything */
-          {
-            int value = *(--tos);
-            value += *(--tos);
-            *tos++ = value;
-            NEXT ();
-          }
+          /* PLUS anything.  */
+          value = *(--tos);
+          value += *(--tos);
+          *tos++ = value;
+          NEXT ();
           break;
         case VAR ('R'):
@@ -2688 +2815 @@
             ieee_data_type *ieee;
             asection *s;
+
             NEXT ();
             section_number = THIS ();
@@ -2694 +2822 @@
             ieee = IEEE_DATA (input_bfd);
             s = ieee->section_table[section_number];
+            value = 0;
             if (s->output_section)
-              {
-                value = s->output_section->lma;
-              }
-            else
-              {
-                value = 0;
-              }
+              value = s->output_section->lma;
             value += s->output_offset;
             *tos++ = value;
-            value = 0;
           }
           break;
@@ -2713 +2835 @@
             OUT (0x90);
             return;
-
           }
         }
     }
-
 }
 
 /* Drop the int in the buffer, and copy a null into the gap, which we
    will overwrite later */
-
-struct output_buffer_struct
-{
-  unsigned char *ptrp;
-  int buffer;
-};
 
 static void
@@ -2735 +2849 @@
   if (buf->buffer == output_buffer)
     {
-      /* Still a chance to output the size */
+      /* Still a chance to output the size.  */
       int value = output_ptr - buf->ptrp + 3;
       buf->ptrp[0] = value >> 24;
@@ -2750 +2864 @@
   int type = THIS ();
   int ch;
+
   if (type <= 0x84)
     {
@@ -2816 +2931 @@
 #define INT copy_int()
 #define EXP copy_expression()
-static void copy_till_end ();
 #define INTn(q) copy_int()
 #define EXPn(q) copy_expression()
@@ -2824 +2938 @@
 {
   int ch;
-  /* ATN record */
+
+  /* ATN record.  */
   NEXT ();
   ch = THIS ();
@@ -2864 +2979 @@
       break;
     case 0xd8:
-      /* EXternal ref */
+      /* EXternal ref.  */
       NEXT ();
       OUT (0xf1);
@@ -2918 +3033 @@
         }
     }
-
 }
 
@@ -2924 +3038 @@
 f0_record ()
 {
-  /* Attribute record */
+  /* Attribute record.  */
   NEXT ();
   OUT (0xf0);
@@ -2935 +3049 @@
 {
   int ch = THIS ();
+
   while (1)
     {
@@ -2982 +3097 @@
 
 
-static void block ();
 static void
 f8_record ()
@@ -2994 +3108 @@
     case 0x02:
     case 0x03:
-      /* Unique typedefs for module */
-      /* GLobal typedefs  */
-      /* High level module scope beginning */
+      /* Unique typedefs for module.  */
+      /* GLobal typedefs.   */
+      /* High level module scope beginning.  */
       {
         struct output_buffer_struct ob;
+
         NEXT ();
         OUT (0xf8);
@@ -3013 +3128 @@
       break;
     case 0x04:
-      /* Global function */
+      /* Global function.  */
       {
         struct output_buffer_struct ob;
+
         NEXT ();
         OUT (0xf8);
@@ -3035 +3151 @@
 
     case 0x05:
-      /* File name for source line numbers */
+      /* File name for source line numbers.  */
       {
         struct output_buffer_struct ob;
+
         NEXT ();
         OUT (0xf8);
@@ -3057 +3174 @@
 
     case 0x06:
-      /* Local function */
+      /* Local function.  */
       {
         struct output_buffer_struct ob;
+
         NEXT ();
         OUT (0xf8);
@@ -3077 +3195 @@
 
     case 0x0a:
-      /* Assembler module scope beginning -*/
+      /* Assembler module scope beginning -  */
       {
         struct output_buffer_struct ob;
@@ -3106 +3224 @@
       {
         struct output_buffer_struct ob;
+
         NEXT ();
         OUT (0xf8);
@@ -3142 +3261 @@
 {
   int ch;
+
   while (1)
     {
@@ -3173 +3293 @@
 
 
-
-/* relocate_debug,
-   moves all the debug information from the source bfd to the output
-   bfd, and relocates any expressions it finds
-*/
+/* Moves all the debug information from the source bfd to the output
+   bfd, and relocates any expressions it finds.  */
 
 static void
@@ -3193 +3310 @@
   /* FIXME: Check return value.  I'm not sure whether it needs to read
      the entire buffer or not.  */
-  bfd_read ((PTR) input_ptr_start, 1, IBS, input);
+  bfd_bread ((PTR) input_ptr_start, (bfd_size_type) IBS, input);
   block ();
 }
@@ -3200 +3317 @@
    one place, relocating it and emitting it as we go.  */
 
-static boolean
+static bfd_boolean
 ieee_write_debug_part (abfd)
      bfd *abfd;
@@ -3206 +3323 @@
   ieee_data_type *ieee = IEEE_DATA (abfd);
   bfd_chain_type *chain = ieee->chain_root;
-  unsigned char output_buffer[OBS];
-  boolean some_debug = false;
+  unsigned char obuff[OBS];
+  bfd_boolean some_debug = FALSE;
   file_ptr here = bfd_tell (abfd);
 
-  output_ptr_start = output_ptr = output_buffer;
-  output_ptr_end = output_buffer + OBS;
-  output_ptr = output_buffer;
+  output_ptr_start = output_ptr = obuff;
+  output_ptr_end = obuff + OBS;
+  output_ptr = obuff;
   output_bfd = abfd;
 
@@ -3225 +3342 @@
         {
           ieee->w.r.debug_information_part = 0;
-          return true;
+          return TRUE;
         }
 
       ieee->w.r.debug_information_part = here;
-      if (bfd_write (s->contents, 1, s->_raw_size, abfd) != s->_raw_size)
-        return false;
+      if (bfd_bwrite (s->contents, s->_raw_size, abfd) != s->_raw_size)
+        return FALSE;
     }
   else
@@ -3238 +3355 @@
           bfd *entry = chain->this;
           ieee_data_type *entry_ieee = IEEE_DATA (entry);
+
           if (entry_ieee->w.r.debug_information_part)
             {
               if (bfd_seek (entry, entry_ieee->w.r.debug_information_part,
-                            SEEK_SET)
-                  != 0)
-                return false;
+                            SEEK_SET) != 0)
+                return FALSE;
               relocate_debug (abfd, entry);
             }
@@ -3249 +3366 @@
           chain = chain->next;
         }
+
       if (some_debug)
-        {
-          ieee->w.r.debug_information_part = here;
-        }
+        ieee->w.r.debug_information_part = here;
       else
-        {
-          ieee->w.r.debug_information_part = 0;
-        }
+        ieee->w.r.debug_information_part = 0;
 
       flush ();
     }
 
-  return true;
+  return TRUE;
 }
 
 /* Write the data in an ieee way.  */
 
-static boolean
+static bfd_boolean
 ieee_write_data_part (abfd)
      bfd *abfd;
 {
   asection *s;
+
   ieee_data_type *ieee = IEEE_DATA (abfd);
   ieee->w.r.data_part = bfd_tell (abfd);
+
   for (s = abfd->sections; s != (asection *) NULL; s = s->next)
     {
@@ -3285 +3401 @@
         {
           if (! do_with_relocs (abfd, s))
-            return false;
+            return FALSE;
         }
       else
         {
           if (! do_without_relocs (abfd, s))
-            return false;
+            return FALSE;
         }
     }
 
-  return true;
-}
-
-
-static boolean
+  return TRUE;
+}
+
+
+static bfd_boolean
 init_for_output (abfd)
      bfd *abfd;
 {
   asection *s;
+
   for (s = abfd->sections; s != (asection *) NULL; s = s->next)
     {
@@ -3309 +3426 @@
       if (s->_raw_size != 0)
         {
-          ieee_per_section (s)->data = (bfd_byte *) (bfd_alloc (abfd, s->_raw_size));
+          bfd_size_type size = s->_raw_size;
+          ieee_per_section (s)->data = (bfd_byte *) (bfd_alloc (abfd, size));
           if (!ieee_per_section (s)->data)
-            return false;
+            return FALSE;
         }
     }
-  return true;
-}
-
-
-/** exec and core file sections */
-
-/* set section contents is complicated with IEEE since the format is
-* not a byte image, but a record stream.
-*/
-boolean
+  return TRUE;
+}
+
+
+/* Exec and core file sections.  */
+
+/* Set section contents is complicated with IEEE since the format is
+   not a byte image, but a record stream.  */
+
+static bfd_boolean
 ieee_set_section_contents (abfd, section, location, offset, count)
      bfd *abfd;
@@ -3335 +3453 @@
       if (section->contents == NULL)
         {
-          section->contents = ((unsigned char *)
-                               bfd_alloc (abfd, section->_raw_size));
+          bfd_size_type size = section->_raw_size;
+          section->contents = (unsigned char *) bfd_alloc (abfd, size);
           if (section->contents == NULL)
-            return false;
+            return FALSE;
         }
       /* bfd_set_section_contents has already checked that everything
          is within range.  */
-      memcpy (section->contents + offset, location, count);
-      return true;
+      memcpy (section->contents + offset, location, (size_t) count);
+      return TRUE;
     }
 
@@ -3349 +3467 @@
     {
       if (!init_for_output (abfd))
-        return false;
+        return FALSE;
     }
   memcpy ((PTR) (ieee_per_section (section)->data + offset),
           (PTR) location,
           (unsigned int) count);
-  return true;
+  return TRUE;
 }
 
@@ -3362 +3480 @@
    symbol values into indexes from the right base.  */
 
-static boolean
+static bfd_boolean
 ieee_write_external_part (abfd)
      bfd *abfd;
@@ -3368 +3486 @@
   asymbol **q;
   ieee_data_type *ieee = IEEE_DATA (abfd);
-
   unsigned int reference_index = IEEE_REFERENCE_BASE;
   unsigned int public_index = IEEE_PUBLIC_BASE + 2;
   file_ptr here = bfd_tell (abfd);
-  boolean hadone = false;
+  bfd_boolean hadone = FALSE;
+
   if (abfd->outsymbols != (asymbol **) NULL)
     {
@@ -3379 +3497 @@
         {
           asymbol *p = *q;
+
           if (bfd_is_und_section (p->section))
             {
-              /* This must be a symbol reference .. */
+              /* This must be a symbol reference.  */
               if (! ieee_write_byte (abfd, ieee_external_reference_enum)
-                  || ! ieee_write_int (abfd, reference_index)
+                  || ! ieee_write_int (abfd, (bfd_vma) reference_index)
                   || ! ieee_write_id (abfd, p->name))
-                return false;
+                return FALSE;
               p->value = reference_index;
               reference_index++;
-              hadone = true;
+              hadone = TRUE;
             }
           else if (bfd_is_com_section (p->section))
             {
-              /* This is a weak reference */
+              /* This is a weak reference.  */
               if (! ieee_write_byte (abfd, ieee_external_reference_enum)
-                  || ! ieee_write_int (abfd, reference_index)
+                  || ! ieee_write_int (abfd, (bfd_vma) reference_index)
                   || ! ieee_write_id (abfd, p->name)
                   || ! ieee_write_byte (abfd,
                                         ieee_weak_external_reference_enum)
-                  || ! ieee_write_int (abfd, reference_index)
+                  || ! ieee_write_int (abfd, (bfd_vma) reference_index)
                   || ! ieee_write_int (abfd, p->value))
-                return false;
+                return FALSE;
               p->value = reference_index;
               reference_index++;
-              hadone = true;
+              hadone = TRUE;
             }
           else if (p->flags & BSF_GLOBAL)
             {
-              /* This must be a symbol definition */
-
+              /* This must be a symbol definition.  */
               if (! ieee_write_byte (abfd, ieee_external_symbol_enum)
-                  || ! ieee_write_int (abfd, public_index)
+                  || ! ieee_write_int (abfd, (bfd_vma) public_index)
                   || ! ieee_write_id (abfd, p->name)
                   || ! ieee_write_2bytes (abfd, ieee_attribute_record_enum)
-                  || ! ieee_write_int (abfd, public_index)
+                  || ! ieee_write_int (abfd, (bfd_vma) public_index)
                   || ! ieee_write_byte (abfd, 15) /* instruction address */
                   || ! ieee_write_byte (abfd, 19) /* static symbol */
                   || ! ieee_write_byte (abfd, 1)) /* one of them */
-                return false;
-
-              /* Write out the value */
+                return FALSE;
+
+              /* Write out the value.  */
               if (! ieee_write_2bytes (abfd, ieee_value_record_enum)
-                  || ! ieee_write_int (abfd, public_index))
-                return false;
+                  || ! ieee_write_int (abfd, (bfd_vma) public_index))
+                return FALSE;
               if (! bfd_is_abs_section (p->section))
                 {
@@ -3428 +3546 @@
                     {
                       /* If fully linked, then output all symbols
-                         relocated */
+                         relocated.  */
                       if (! (ieee_write_int
                              (abfd,
@@ -3434 +3552 @@
                                + p->section->output_offset
                                + p->section->output_section->vma))))
-                        return false;
+                        return FALSE;
                     }
                   else
@@ -3442 +3560 @@
                               p->value + p->section->output_offset,
                               p->section->output_section->symbol,
-                              false, 0)))
-                        return false;
+                              FALSE, 0)))
+                        return FALSE;
                     }
                 }
@@ -3451 +3569 @@
                                                p->value,
                                                bfd_abs_section_ptr->symbol,
-                                               false, 0))
-                    return false;
+                                               FALSE, 0))
+                    return FALSE;
                 }
               p->value = public_index;
               public_index++;
-              hadone = true;
+              hadone = TRUE;
             }
           else
             {
-              /* This can happen - when there are gaps in the symbols read */
-              /* from an input ieee file */
+              /* This can happen - when there are gaps in the symbols read
+                 from an input ieee file.  */
             }
         }
@@ -3468 +3586 @@
     ieee->w.r.external_part = here;
 
-  return true;
-}
-
-
-static CONST unsigned char exten[] =
+  return TRUE;
+}
+
+
+static const unsigned char exten[] =
 {
   0xf0, 0x20, 0x00,
-  0xf1, 0xce, 0x20, 0x00, 37, 3, 3,     /* Set version 3 rev 3          */
-  0xf1, 0xce, 0x20, 0x00, 39, 2,/* keep symbol in  original case */
-  0xf1, 0xce, 0x20, 0x00, 38    /* set object type relocateable to x */
+  0xf1, 0xce, 0x20, 0x00, 37, 3, 3,     /* Set version 3 rev 3.  */
+  0xf1, 0xce, 0x20, 0x00, 39, 2,        /* Keep symbol in  original case.  */
+  0xf1, 0xce, 0x20, 0x00, 38            /* Set object type relocateable to x.  */
 };
 
-static CONST unsigned char envi[] =
+static const unsigned char envi[] =
 {
   0xf0, 0x21, 0x00,
@@ -3493 +3611 @@
 };
 
-static boolean
+static bfd_boolean
 ieee_write_me_part (abfd)
      bfd *abfd;
@@ -3505 +3623 @@
           || ! ieee_write_int (abfd, abfd->start_address)
           || ! ieee_write_byte (abfd, ieee_function_either_close_b_enum))
-        return false;
+        return FALSE;
     }
   ieee->w.r.me_record = bfd_tell (abfd);
   if (! ieee_write_byte (abfd, ieee_module_end_enum))
-    return false;
-  return true;
+    return FALSE;
+  return TRUE;
 }
 
 /* Write out the IEEE processor ID.  */
 
-static boolean
+static bfd_boolean
 ieee_write_processor (abfd)
      bfd *abfd;
@@ -3526 +3644 @@
     default:
       if (! ieee_write_id (abfd, bfd_printable_name (abfd)))
-        return false;
+        return FALSE;
       break;
 
     case bfd_arch_a29k:
       if (! ieee_write_id (abfd, "29000"))
-        return false;
+        return FALSE;
       break;
 
     case bfd_arch_h8300:
       if (! ieee_write_id (abfd, "H8/300"))
-        return false;
+        return FALSE;
       break;
 
     case bfd_arch_h8500:
       if (! ieee_write_id (abfd, "H8/500"))
-        return false;
+        return FALSE;
       break;
 
@@ -3551 +3669 @@
         case bfd_mach_i960_ka_sa:
           if (! ieee_write_id (abfd, "80960KA"))
-            return false;
+            return FALSE;
           break;
 
         case bfd_mach_i960_kb_sb:
           if (! ieee_write_id (abfd, "80960KB"))
-            return false;
+            return FALSE;
           break;
 
         case bfd_mach_i960_ca:
           if (! ieee_write_id (abfd, "80960CA"))
-            return false;
+            return FALSE;
           break;
 
@@ -3567 +3685 @@
         case bfd_mach_i960_xa:
           if (! ieee_write_id (abfd, "80960MC"))
-            return false;
+            return FALSE;
           break;
         }
@@ -3594 +3712 @@
 
         if (! ieee_write_id (abfd, id))
-          return false;
+          return FALSE;
       }
       break;
     }
 
-  return true;
-}
-
-boolean
+  return TRUE;
+}
+
+static bfd_boolean
 ieee_write_object_contents (abfd)
      bfd *abfd;
@@ -3610 +3728 @@
   file_ptr old;
 
-  /* Fast forward over the header area */
+  /* Fast forward over the header area.  */
   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
-    return false;
+    return FALSE;
 
   if (! ieee_write_byte (abfd, ieee_module_beginning_enum)
       || ! ieee_write_processor (abfd)
       || ! ieee_write_id (abfd, abfd->filename))
-    return false;
-
-  /* Fast forward over the variable bits */
+    return FALSE;
+
+  /* Fast forward over the variable bits.  */
   if (! ieee_write_byte (abfd, ieee_address_descriptor_enum))
-    return false;
-
-  /* Bits per MAU */
+    return FALSE;
+
+  /* Bits per MAU.  */
   if (! ieee_write_byte (abfd, (bfd_byte) (bfd_arch_bits_per_byte (abfd))))
-    return false;
-  /* MAU's per address */
+    return FALSE;
+  /* MAU's per address.  */
   if (! ieee_write_byte (abfd,
                          (bfd_byte) (bfd_arch_bits_per_address (abfd)
                                      / bfd_arch_bits_per_byte (abfd))))
-    return false;
+    return FALSE;
 
   old = bfd_tell (abfd);
   if (bfd_seek (abfd, (file_ptr) (8 * N_W_VARIABLES), SEEK_CUR) != 0)
-    return false;
+    return FALSE;
 
   ieee->w.r.extension_record = bfd_tell (abfd);
-  if (bfd_write ((char *) exten, 1, sizeof (exten), abfd) != sizeof (exten))
-    return false;
+  if (bfd_bwrite ((char *) exten, (bfd_size_type) sizeof (exten), abfd)
+      != sizeof (exten))
+    return FALSE;
   if (abfd->flags & EXEC_P)
     {
       if (! ieee_write_byte (abfd, 0x1)) /* Absolute */
-        return false;
+        return FALSE;
     }
   else
     {
       if (! ieee_write_byte (abfd, 0x2)) /* Relocateable */
-        return false;
+        return FALSE;
     }
 
   ieee->w.r.environmental_record = bfd_tell (abfd);
-  if (bfd_write ((char *) envi, 1, sizeof (envi), abfd) != sizeof (envi))
-    return false;
+  if (bfd_bwrite ((char *) envi, (bfd_size_type) sizeof (envi), abfd)
+      != sizeof (envi))
+    return FALSE;
 
   /* The HP emulator database requires a timestamp in the file.  */
@@ -3665 +3785 @@
         || ! ieee_write_byte (abfd, 0)
         || ! ieee_write_byte (abfd, 50)
-        || ! ieee_write_int (abfd, t->tm_year + 1900)
-        || ! ieee_write_int (abfd, t->tm_mon + 1)
-        || ! ieee_write_int (abfd, t->tm_mday)
-        || ! ieee_write_int (abfd, t->tm_hour)
-        || ! ieee_write_int (abfd, t->tm_min)
-        || ! ieee_write_int (abfd, t->tm_sec))
-      return false;
+        || ! ieee_write_int (abfd, (bfd_vma) (t->tm_year + 1900))
+        || ! ieee_write_int (abfd, (bfd_vma) (t->tm_mon + 1))
+        || ! ieee_write_int (abfd, (bfd_vma) t->tm_mday)
+        || ! ieee_write_int (abfd, (bfd_vma) t->tm_hour)
+        || ! ieee_write_int (abfd, (bfd_vma) t->tm_min)
+        || ! ieee_write_int (abfd, (bfd_vma) t->tm_sec))
+      return FALSE;
   }
 
@@ -3679 +3799 @@
 
   if (! ieee_write_section_part (abfd))
-    return false;
+    return FALSE;
   /* First write the symbols.  This changes their values into table
     indeces so we cant use it after this point.  */
   if (! ieee_write_external_part (abfd))
-    return false;
-
-  /*  ieee_write_byte(abfd, ieee_record_seperator_enum);*/
-
-  /*  ieee_write_byte(abfd, ieee_record_seperator_enum);*/
-
+    return FALSE;
 
   /* Write any debugs we have been told about.  */
   if (! ieee_write_debug_part (abfd))
-    return false;
+    return FALSE;
 
   /* Can only write the data once the symbols have been written, since
@@ -3698 +3813 @@
      symbols.  */
   if (! ieee_write_data_part (abfd))
-    return false;
+    return FALSE;
 
   /* At the end we put the end!  */
   if (! ieee_write_me_part (abfd))
-    return false;
-
-  /* Generate the header */
+    return FALSE;
+
+  /* Generate the header.  */
   if (bfd_seek (abfd, old, SEEK_SET) != 0)
-    return false;
+    return FALSE;
 
   for (i = 0; i < N_W_VARIABLES; i++)
@@ -3712 +3827 @@
       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;
+          || ! ieee_write_int5_out (abfd, (bfd_vma) ieee->w.offset[i]))
+        return FALSE;
+    }
+
+  return TRUE;
 }
 
@@ -3724 +3839 @@
 /* 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. */
-
-asymbol *
+   hold them all plus all the cached symbol entries.  */
+
+static asymbol *
 ieee_make_empty_symbol (abfd)
      bfd *abfd;
 {
-  ieee_symbol_type *new =
-    (ieee_symbol_type *) bfd_zalloc (abfd, sizeof (ieee_symbol_type));
+  bfd_size_type amt = sizeof (ieee_symbol_type);
+  ieee_symbol_type *new = (ieee_symbol_type *) bfd_zalloc (abfd, amt);
+
   if (!new)
     return NULL;
@@ -3744 +3860 @@
 {
   ieee_ar_data_type *ar = IEEE_AR_DATA (arch);
-  /* take the next one from the arch state, or reset */
+
+  /* Take the next one from the arch state, or reset.  */
   if (prev == (bfd *) NULL)
-    {
-      /* Reset the index - the first two entries are bogus*/
-      ar->element_index = 2;
-    }
-  while (true)
+    /* Reset the index - the first two entries are bogus.  */
+    ar->element_index = 2;
+
+  while (TRUE)
     {
       ieee_ar_obstack_type *p = ar->elements + ar->element_index;
+
       ar->element_index++;
       if (ar->element_index <= ar->element_count)
@@ -3771 +3888 @@
           return (bfd *) NULL;
         }
-
-    }
-}
-
-static boolean
-ieee_find_nearest_line (abfd,
-                        section,
-                        symbols,
-                        offset,
-                        filename_ptr,
-                        functionname_ptr,
-                        line_ptr)
+    }
+}
+
+static bfd_boolean
+ieee_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
+                        functionname_ptr, line_ptr)
      bfd *abfd ATTRIBUTE_UNUSED;
      asection *section ATTRIBUTE_UNUSED;
@@ -3791 +3902 @@
      unsigned int *line_ptr ATTRIBUTE_UNUSED;
 {
-  return false;
+  return FALSE;
 }
 
@@ -3829 +3940 @@
 ieee_sizeof_headers (abfd, x)
      bfd *abfd ATTRIBUTE_UNUSED;
-     boolean x ATTRIBUTE_UNUSED;
+     bfd_boolean x ATTRIBUTE_UNUSED;
 {
   return 0;
@@ -3854 +3965 @@
 
 /* Add this section to the list of sections we have debug info for, to
-   be ready to output it at close time
-   */
+   be ready to output it at close time.  */
 static void
 ieee_bfd_debug_info_accumulate (abfd, section)
@@ -3863 +3973 @@
   ieee_data_type *ieee = IEEE_DATA (section->owner);
   ieee_data_type *output_ieee = IEEE_DATA (abfd);
-  /* can only accumulate data from other ieee bfds */
+
+  /* Can only accumulate data from other ieee bfds.  */
   if (section->owner->xvec != abfd->xvec)
     return;
-  /* Only bother once per bfd */
-  if (ieee->done_debug == true)
+  /* Only bother once per bfd.  */
+  if (ieee->done_debug)
     return;
-  ieee->done_debug = true;
-
-  /* Don't bother if there is no debug info */
+  ieee->done_debug = TRUE;
+
+  /* Don't bother if there is no debug info.  */
   if (ieee->w.r.debug_information_part == 0)
     return;
 
-
-  /* Add to chain */
+  /* Add to chain.  */
   {
-    bfd_chain_type *n = (bfd_chain_type *) bfd_alloc (abfd, sizeof (bfd_chain_type));
+    bfd_size_type amt = sizeof (bfd_chain_type);
+    bfd_chain_type *n = (bfd_chain_type *) bfd_alloc (abfd, amt);
+
     if (!n)
       abort ();         /* FIXME */
@@ -3885 +3997 @@
 
     if (output_ieee->chain_head)
-      {
-        output_ieee->chain_head->next = n;
-      }
+      output_ieee->chain_head->next = n;
     else
-      {
-        output_ieee->chain_root = n;
-
-      }
+      output_ieee->chain_root = n;
+
     output_ieee->chain_head = n;
   }
@@ -3905 +4013 @@
 #define ieee_slurp_extended_name_table bfd_true
 #define ieee_construct_extended_name_table \
-  ((boolean (*) PARAMS ((bfd *, char **, bfd_size_type *, const char **))) \
+  ((bfd_boolean (*) \
+    PARAMS ((bfd *, char **, bfd_size_type *, const char **))) \
    bfd_true)
 #define ieee_truncate_arname bfd_dont_truncate_arname
 #define ieee_write_armap \
-  ((boolean (*) \
+  ((bfd_boolean (*) \
     PARAMS ((bfd *, unsigned int, struct orl *, unsigned int, int))) \
    bfd_true)
@@ -3932 +4041 @@
 #define ieee_bfd_relax_section bfd_generic_relax_section
 #define ieee_bfd_gc_sections bfd_generic_gc_sections
+#define ieee_bfd_merge_sections bfd_generic_merge_sections
+#define ieee_bfd_discard_group bfd_generic_discard_group
 #define ieee_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
+#define ieee_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
 #define ieee_bfd_link_add_symbols _bfd_generic_link_add_symbols
+#define ieee_bfd_link_just_syms _bfd_generic_link_just_syms
 #define ieee_bfd_final_link _bfd_generic_final_link
 #define ieee_bfd_link_split_section  _bfd_generic_link_split_section
 
-/*SUPPRESS 460 */
 const bfd_target ieee_vec =
 {
@@ -3977 +4089 @@
   },
 
+  /* ieee_close_and_cleanup, ieee_bfd_free_cached_info, ieee_new_section_hook,
+     ieee_get_section_contents, ieee_get_section_contents_in_window  */
   BFD_JUMP_TABLE_GENERIC (ieee),
+
   BFD_JUMP_TABLE_COPY (_bfd_generic),
   BFD_JUMP_TABLE_CORE (_bfd_nocore),
+
+  /* ieee_slurp_armap, ieee_slurp_extended_name_table,
+     ieee_construct_extended_name_table, ieee_truncate_arname,
+     ieee_write_armap, ieee_read_ar_hdr, ieee_openr_next_archived_file,
+     ieee_get_elt_at_index, ieee_generic_stat_arch_elt,
+     ieee_update_armap_timestamp  */
   BFD_JUMP_TABLE_ARCHIVE (ieee),
+
+  /* ieee_get_symtab_upper_bound, ieee_get_symtab, ieee_make_empty_symbol,
+     ieee_print_symbol, ieee_get_symbol_info, ieee_bfd_is_local_label_name,
+     ieee_get_lineno, ieee_find_nearest_line, ieee_bfd_make_debug_symbol,
+     ieee_read_minisymbols, ieee_minisymbol_to_symbol  */
   BFD_JUMP_TABLE_SYMBOLS (ieee),
+
+  /* ieee_get_reloc_upper_bound, ieee_canonicalize_reloc,
+     ieee_bfd_reloc_type_lookup  */
   BFD_JUMP_TABLE_RELOCS (ieee),
+
+  /* ieee_set_arch_mach, ieee_set_section_contents  */
   BFD_JUMP_TABLE_WRITE (ieee),
+
+  /* ieee_sizeof_headers, ieee_bfd_get_relocated_section_contents,
+     ieee_bfd_relax_section, ieee_bfd_link_hash_table_create,
+     _bfd_generic_link_hash_table_free,
+     ieee_bfd_link_add_symbols, ieee_bfd_final_link,
+     ieee_bfd_link_split_section, ieee_bfd_gc_sections,
+     ieee_bfd_merge_sections  */
   BFD_JUMP_TABLE_LINK (ieee),
+
   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 
   NULL,
-  
+
   (PTR) 0
 };