Changeset 609 for branches/GNU/src/binutils/bfd/oasys.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/oasys.c (modified) (64 diffs, 1 prop)

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

@@ -1 +1 @@
 /* BFD back-end for oasys objects.
-   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999
-   Free Software Foundation, Inc.
+   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2001,
+   2002, 2003 Free Software Foundation, Inc.
    Written by Steve Chamberlain of Cygnus Support, <sac@cygnus.com>.
 
-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 UNDERSCORE_HACK 1
 #include "bfd.h"
 #include "sysdep.h"
-#include <ctype.h>
+#include "safe-ctype.h"
 #include "libbfd.h"
 #include "oasys.h"
 #include "liboasys.h"
 
-/* XXX - FIXME.  offsetof belongs in the system-specific files in
-   ../include/sys. */
-/* Define offsetof for those systems which lack it */
-
-#ifndef offsetof
-#define offsetof(type, identifier) (size_t) &(((type *) 0)->identifier)
-#endif
-
-static boolean oasys_read_record PARAMS ((bfd *,
-                                          oasys_record_union_type *));
-static boolean oasys_write_sections PARAMS ((bfd *));
-static boolean oasys_write_record PARAMS ((bfd *,
-                                           oasys_record_enum_type,
-                                           oasys_record_union_type *,
-                                           size_t));
-static boolean oasys_write_syms PARAMS ((bfd *));
-static boolean oasys_write_header PARAMS ((bfd *));
-static boolean oasys_write_end PARAMS ((bfd *));
-static boolean oasys_write_data PARAMS ((bfd *));
-
-/* Read in all the section data and relocation stuff too */
-PROTO (static boolean, oasys_slurp_section_data, (bfd * CONST abfd));
-
-static boolean
+static bfd_boolean oasys_slurp_section_data
+  PARAMS ((bfd * const));
+static bfd_boolean oasys_read_record
+  PARAMS ((bfd *, oasys_record_union_type *));
+static bfd_boolean oasys_write_sections
+  PARAMS ((bfd *));
+static bfd_boolean oasys_write_record
+  PARAMS ((bfd *, oasys_record_enum_type, oasys_record_union_type *, size_t));
+static bfd_boolean oasys_write_syms
+  PARAMS ((bfd *));
+static bfd_boolean oasys_write_header
+  PARAMS ((bfd *));
+static bfd_boolean oasys_write_end
+  PARAMS ((bfd *));
+static bfd_boolean oasys_write_data
+  PARAMS ((bfd *));
+static size_t oasys_string_length
+  PARAMS ((oasys_record_union_type *));
+static bfd_boolean oasys_slurp_symbol_table
+  PARAMS ((bfd *const));
+static long int oasys_get_symtab_upper_bound
+  PARAMS ((bfd *const));
+static const bfd_target *oasys_archive_p
+  PARAMS ((bfd *));
+static bfd_boolean oasys_mkobject
+  PARAMS ((bfd *));
+static const bfd_target *oasys_object_p
+  PARAMS ((bfd *));
+static void oasys_get_symbol_info
+  PARAMS ((bfd *, asymbol *, symbol_info *));
+static void oasys_print_symbol
+  PARAMS ((bfd *, void *, asymbol *, bfd_print_symbol_type));
+static bfd_boolean oasys_new_section_hook
+  PARAMS ((bfd *, asection *));
+static long int oasys_get_reloc_upper_bound
+  PARAMS ((bfd *, sec_ptr));
+static bfd_boolean oasys_get_section_contents
+  PARAMS ((bfd *, sec_ptr, void *, file_ptr, bfd_size_type));
+static int comp
+  PARAMS ((const void *, const void *));
+static bfd_boolean oasys_write_object_contents
+  PARAMS ((bfd *));
+static bfd_boolean oasys_set_section_contents
+  PARAMS ((bfd *, sec_ptr, void *, file_ptr, bfd_size_type));
+static asymbol *oasys_make_empty_symbol
+  PARAMS ((bfd *));
+static bfd *oasys_openr_next_archived_file
+  PARAMS ((bfd *, bfd *));
+static bfd_boolean oasys_find_nearest_line
+  PARAMS ((bfd *, asection *, asymbol **, bfd_vma,
+           const char **, const char **, unsigned int *));
+static int oasys_generic_stat_arch_elt
+  PARAMS ((bfd *, struct stat *));
+static int oasys_sizeof_headers
+  PARAMS ((bfd *, bfd_boolean));
+
+long oasys_get_symtab
+  PARAMS ((bfd *, asymbol **));
+long oasys_canonicalize_reloc
+  PARAMS ((bfd *, sec_ptr, arelent **, asymbol **));
+
+/* Read in all the section data and relocation stuff too.  */
+
+static bfd_boolean
 oasys_read_record (abfd, record)
      bfd *abfd;
      oasys_record_union_type *record;
 {
-  if (bfd_read ((PTR) record, 1, sizeof (record->header), abfd)
-      != sizeof (record->header))
-    return false;
-
-  if ((size_t) record->header.length <= (size_t) sizeof (record->header))
-    return true;
-  if (bfd_read ((PTR) (((char *) record) + sizeof (record->header)),
-                1, record->header.length - sizeof (record->header),
-                abfd)
-      != record->header.length - sizeof (record->header))
-    return false;
-  return true;
-}
+  bfd_size_type amt = sizeof (record->header);
+  if (bfd_bread ((PTR) record, amt, abfd) != amt)
+    return FALSE;
+
+  amt = record->header.length - sizeof (record->header);
+  if ((long) amt <= 0)
+    return TRUE;
+  if (bfd_bread ((PTR) ((char *) record + sizeof (record->header)), amt, abfd)
+      != amt)
+    return FALSE;
+  return TRUE;
+}
+
 static size_t
 oasys_string_length (record)
@@ -93 +133 @@
 */
 
-static boolean
+static bfd_boolean
 oasys_slurp_symbol_table (abfd)
-     bfd *CONST abfd;
+     bfd *const abfd;
 {
   oasys_record_union_type record;
   oasys_data_type *data = OASYS_DATA (abfd);
-  boolean loop = true;
+  bfd_boolean loop = TRUE;
   asymbol *dest_defined;
   asymbol *dest;
   char *string_ptr;
-
+  bfd_size_type amt;
 
   if (data->symbols != (asymbol *) NULL)
     {
-      return true;
+      return TRUE;
     }
   /* Buy enough memory for all the symbols and all the names */
-  data->symbols =
-    (asymbol *) bfd_alloc (abfd, sizeof (asymbol) * abfd->symcount);
+  amt = abfd->symcount;
+  amt *= sizeof (asymbol);
+  data->symbols = (asymbol *) bfd_alloc (abfd, amt);
+
+  amt = data->symbol_string_length;
 #ifdef UNDERSCORE_HACK
   /* buy 1 more char for each symbol to keep the underscore in*/
-  data->strings = bfd_alloc (abfd, data->symbol_string_length +
-                             abfd->symcount);
-#else
-  data->strings = bfd_alloc (abfd, data->symbol_string_length);
+  amt += abfd->symcount;
 #endif
+  data->strings = bfd_alloc (abfd, amt);
+
   if (!data->symbols || !data->strings)
-    return false;
+    return FALSE;
 
   dest_defined = data->symbols + abfd->symcount - 1;
@@ -126 +168 @@
   string_ptr = data->strings;
   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
-    return false;
+    return FALSE;
   while (loop)
     {
 
       if (! oasys_read_record (abfd, &record))
-        return false;
+        return FALSE;
       switch (record.header.type)
         {
@@ -175 +217 @@
                 break;
               case RELOCATION_TYPE_UND:
-                dest = data->symbols + bfd_h_get_16 (abfd, record.symbol.refno);
+                dest = data->symbols + H_GET_16 (abfd, record.symbol.refno);
                 dest->section = bfd_und_section_ptr;
                 break;
@@ -194 +236 @@
             dest->the_bfd = abfd;
             dest->udata.p = (PTR) NULL;
-            dest->value = bfd_h_get_32 (abfd, record.symbol.value);
+            dest->value = H_GET_32 (abfd, record.symbol.value);
 
 #ifdef UNDERSCORE_HACK
@@ -211 +253 @@
           break;
         default:
-          loop = false;
+          loop = FALSE;
         }
     }
-  return true;
+  return TRUE;
 }
 
 static long
 oasys_get_symtab_upper_bound (abfd)
-     bfd *CONST abfd;
+     bfd *const abfd;
 {
   if (! oasys_slurp_symbol_table (abfd))
@@ -227 +269 @@
 }
 
-/*
-*/
-
 extern const bfd_target oasys_vec;
 
@@ -239 +278 @@
   asymbol *symbase;
   unsigned int counter;
-  if (oasys_slurp_symbol_table (abfd) == false)
+  if (! oasys_slurp_symbol_table (abfd))
     {
       return -1;
@@ -264 +303 @@
   unsigned int i;
   file_ptr filepos;
-
-  if (bfd_seek (abfd, (file_ptr) 0, false) != 0
-      || (bfd_read ((PTR) & header_ext, 1, sizeof (header_ext), abfd)
-          != sizeof (header_ext)))
+  bfd_size_type amt;
+
+  amt = sizeof (header_ext);
+  if (bfd_seek (abfd, (file_ptr) 0, 0) != 0
+      || bfd_bread ((PTR) &header_ext, amt, abfd) != amt)
     {
       if (bfd_get_error () != bfd_error_system_call)
@@ -274 +314 @@
     }
 
-  header.version = bfd_h_get_32 (abfd, header_ext.version);
-  header.mod_count = bfd_h_get_32 (abfd, header_ext.mod_count);
-  header.mod_tbl_offset = bfd_h_get_32 (abfd, header_ext.mod_tbl_offset);
-  header.sym_tbl_size = bfd_h_get_32 (abfd, header_ext.sym_tbl_size);
-  header.sym_count = bfd_h_get_32 (abfd, header_ext.sym_count);
-  header.sym_tbl_offset = bfd_h_get_32 (abfd, header_ext.sym_tbl_offset);
-  header.xref_count = bfd_h_get_32 (abfd, header_ext.xref_count);
-  header.xref_lst_offset = bfd_h_get_32 (abfd, header_ext.xref_lst_offset);
+  header.version = H_GET_32 (abfd, header_ext.version);
+  header.mod_count = H_GET_32 (abfd, header_ext.mod_count);
+  header.mod_tbl_offset = H_GET_32 (abfd, header_ext.mod_tbl_offset);
+  header.sym_tbl_size = H_GET_32 (abfd, header_ext.sym_tbl_size);
+  header.sym_count = H_GET_32 (abfd, header_ext.sym_count);
+  header.sym_tbl_offset = H_GET_32 (abfd, header_ext.sym_tbl_offset);
+  header.xref_count = H_GET_32 (abfd, header_ext.xref_count);
+  header.xref_lst_offset = H_GET_32 (abfd, header_ext.xref_lst_offset);
 
   /*
@@ -300 +340 @@
     */
   {
-    oasys_ar_data_type *ar =
-    (oasys_ar_data_type *) bfd_alloc (abfd, sizeof (oasys_ar_data_type));
-
-    oasys_module_info_type *module =
-    (oasys_module_info_type *)
-    bfd_alloc (abfd, sizeof (oasys_module_info_type) * header.mod_count);
+    oasys_ar_data_type *ar;
+    oasys_module_info_type *module;
     oasys_module_table_type record;
+
+    amt = sizeof (oasys_ar_data_type);
+    ar = (oasys_ar_data_type *) bfd_alloc (abfd, amt);
+
+    amt = header.mod_count;
+    amt *= sizeof (oasys_module_info_type);
+    module = (oasys_module_info_type *) bfd_alloc (abfd, amt);
 
     if (!ar || !module)
@@ -326 +369 @@
           {
             oasys_extmodule_table_type_a_type record_ext;
-            if (bfd_read ((PTR) & record_ext, 1, sizeof (record_ext), abfd)
-                != sizeof (record_ext))
+
+            amt = sizeof (record_ext);
+            if (bfd_bread ((PTR) &record_ext, amt, abfd) != amt)
               return NULL;
 
-            record.mod_size = bfd_h_get_32 (abfd, record_ext.mod_size);
-            record.file_offset = bfd_h_get_32 (abfd, record_ext.file_offset);
-
-            record.dep_count = bfd_h_get_32 (abfd, record_ext.dep_count);
-            record.depee_count = bfd_h_get_32 (abfd, record_ext.depee_count);
-            record.sect_count = bfd_h_get_32 (abfd, record_ext.sect_count);
-
-            module[i].name = bfd_alloc (abfd, 33);
+            record.mod_size = H_GET_32 (abfd, record_ext.mod_size);
+            record.file_offset = H_GET_32 (abfd, record_ext.file_offset);
+
+            record.dep_count = H_GET_32 (abfd, record_ext.dep_count);
+            record.depee_count = H_GET_32 (abfd, record_ext.depee_count);
+            record.sect_count = H_GET_32 (abfd, record_ext.sect_count);
+
+            module[i].name = bfd_alloc (abfd, (bfd_size_type) 33);
             if (!module[i].name)
               return NULL;
@@ -351 +395 @@
           {
             oasys_extmodule_table_type_b_type record_ext;
-            if (bfd_read ((PTR) & record_ext, 1, sizeof (record_ext), abfd)
-                != sizeof (record_ext))
+
+            amt = sizeof (record_ext);
+            if (bfd_bread ((PTR) &record_ext, amt, abfd) != amt)
               return NULL;
 
-            record.mod_size = bfd_h_get_32 (abfd, record_ext.mod_size);
-            record.file_offset = bfd_h_get_32 (abfd, record_ext.file_offset);
-
-            record.dep_count = bfd_h_get_32 (abfd, record_ext.dep_count);
-            record.depee_count = bfd_h_get_32 (abfd, record_ext.depee_count);
-            record.sect_count = bfd_h_get_32 (abfd, record_ext.sect_count);
-            record.module_name_size = bfd_h_get_32 (abfd, record_ext.mod_name_length);
-
-            module[i].name = bfd_alloc (abfd, record.module_name_size + 1);
+            record.mod_size = H_GET_32 (abfd, record_ext.mod_size);
+            record.file_offset = H_GET_32 (abfd, record_ext.file_offset);
+
+            record.dep_count = H_GET_32 (abfd, record_ext.dep_count);
+            record.depee_count = H_GET_32 (abfd, record_ext.depee_count);
+            record.sect_count = H_GET_32 (abfd, record_ext.sect_count);
+            record.module_name_size = H_GET_32 (abfd,
+                                                record_ext.mod_name_length);
+
+            amt = record.module_name_size;
+            module[i].name = bfd_alloc (abfd, amt + 1);
             if (!module[i].name)
               return NULL;
-            if (bfd_read ((PTR) module[i].name, 1, record.module_name_size,
-                          abfd)
-                != record.module_name_size)
+            if (bfd_bread ((PTR) module[i].name, amt, abfd) != amt)
               return NULL;
             module[i].name[record.module_name_size] = 0;
-            filepos +=
-              sizeof (record_ext) +
-              record.dep_count * 4 +
-              record.module_name_size + 1;
-
+            filepos += (sizeof (record_ext)
+                        + record.dep_count * 4
+                        + record.module_name_size + 1);
           }
-
 
         module[i].size = record.mod_size;
@@ -383 +425 @@
         module[i].abfd = 0;
       }
-
   }
   return abfd->xvec;
 }
 
-static boolean
+static bfd_boolean
 oasys_mkobject (abfd)
      bfd *abfd;
 {
-
-  abfd->tdata.oasys_obj_data = (oasys_data_type *) bfd_alloc (abfd, sizeof (oasys_data_type));
-  return abfd->tdata.oasys_obj_data ? true : false;
+  bfd_size_type amt = sizeof (oasys_data_type);
+  abfd->tdata.oasys_obj_data = (oasys_data_type *) bfd_alloc (abfd, amt);
+  return abfd->tdata.oasys_obj_data != NULL;
 }
 
@@ -404 +445 @@
   oasys_data_type *oasys;
   oasys_data_type *save = OASYS_DATA (abfd);
-  boolean loop = true;
-  boolean had_usefull = false;
+  bfd_boolean loop = TRUE;
+  bfd_boolean had_usefull = FALSE;
 
   abfd->tdata.oasys_obj_data = 0;
@@ -432 +473 @@
         {
         case oasys_record_is_header_enum:
-          had_usefull = true;
+          had_usefull = TRUE;
           break;
         case oasys_record_is_symbol_enum:
@@ -439 +480 @@
           abfd->symcount++;
           oasys->symbol_string_length += 1 + oasys_string_length (&record);
-          had_usefull = true;
+          had_usefull = TRUE;
           break;
         case oasys_record_is_section_enum:
@@ -450 +491 @@
                 goto fail;
               }
-            buffer = bfd_alloc (abfd, 3);
+            buffer = bfd_alloc (abfd, (bfd_size_type) 3);
             if (!buffer)
               goto fail;
@@ -467 +508 @@
               }
 
-            s->_raw_size = bfd_h_get_32 (abfd, record.section.value);
-            s->vma = bfd_h_get_32 (abfd, record.section.vma);
+            s->_raw_size = H_GET_32 (abfd, record.section.value);
+            s->vma = H_GET_32 (abfd, record.section.vma);
             s->flags = 0;
-            had_usefull = true;
+            had_usefull = TRUE;
           }
           break;
@@ -479 +520 @@
         case oasys_record_is_named_section_enum:
         case oasys_record_is_end_enum:
-          if (had_usefull == false)
+          if (! had_usefull)
             goto fail;
-          loop = false;
+          loop = FALSE;
           break;
         default:
@@ -526 +567 @@
 
 static void
-oasys_print_symbol (ignore_abfd, afile, symbol, how)
-     bfd *ignore_abfd ATTRIBUTE_UNUSED;
+oasys_print_symbol (abfd, afile, symbol, how)
+     bfd *abfd;
      PTR afile;
      asymbol *symbol;
@@ -542 +583 @@
     case bfd_print_symbol_all:
       {
-        CONST char *section_name = symbol->section == (asection *) NULL ?
-        (CONST char *) "*abs" : symbol->section->name;
-
-        bfd_print_symbol_vandf ((PTR) file, symbol);
+        const char *section_name = symbol->section == (asection *) NULL ?
+        (const char *) "*abs" : symbol->section->name;
+
+        bfd_print_symbol_vandf (abfd, (PTR) file, symbol);
 
         fprintf (file, " %-5s %s",
@@ -561 +602 @@
 {
 
-  HOWTO (0, 0, 1, 16, false, 0, complain_overflow_bitfield, 0, "abs16", true, 0x0000ffff, 0x0000ffff, false),
-  HOWTO (0, 0, 2, 32, false, 0, complain_overflow_bitfield, 0, "abs32", true, 0xffffffff, 0xffffffff, false),
-  HOWTO (0, 0, 1, 16, true, 0, complain_overflow_signed, 0, "pcrel16", true, 0x0000ffff, 0x0000ffff, false),
-  HOWTO (0, 0, 2, 32, true, 0, complain_overflow_signed, 0, "pcrel32", true, 0xffffffff, 0xffffffff, false)
+  HOWTO (0, 0, 1, 16, FALSE, 0, complain_overflow_bitfield, 0, "abs16", TRUE, 0x0000ffff, 0x0000ffff, FALSE),
+  HOWTO (0, 0, 2, 32, FALSE, 0, complain_overflow_bitfield, 0, "abs32", TRUE, 0xffffffff, 0xffffffff, FALSE),
+  HOWTO (0, 0, 1, 16, TRUE, 0, complain_overflow_signed, 0, "pcrel16", TRUE, 0x0000ffff, 0x0000ffff, FALSE),
+  HOWTO (0, 0, 2, 32, TRUE, 0, complain_overflow_signed, 0, "pcrel32", TRUE, 0xffffffff, 0xffffffff, FALSE)
 };
 
 /* Read in all the section data and relocation stuff too */
-static boolean
+static bfd_boolean
 oasys_slurp_section_data (abfd)
-     bfd *CONST abfd;
+     bfd *const abfd;
 {
   oasys_record_union_type record;
   oasys_data_type *data = OASYS_DATA (abfd);
-  boolean loop = true;
-
+  bfd_boolean loop = TRUE;
   oasys_per_section_type *per;
-
   asection *s;
+  bfd_size_type amt;
 
   /* See if the data has been slurped already .. */
@@ -584 +624 @@
     {
       per = oasys_per_section (s);
-      if (per->initialized == true)
-        return true;
+      if (per->initialized)
+        return TRUE;
     }
 
   if (data->first_data_record == 0)
-    return true;
+    return TRUE;
 
   if (bfd_seek (abfd, data->first_data_record, SEEK_SET) != 0)
-    return false;
+    return FALSE;
   while (loop)
     {
       if (! oasys_read_record (abfd, &record))
-        return false;
+        return FALSE;
       switch (record.header.type)
         {
@@ -616 +656 @@
             per = oasys_per_section (section);
 
-            if (per->initialized == false)
+            if (! per->initialized)
               {
                 per->data = (bfd_byte *) bfd_zalloc (abfd, section->_raw_size);
                 if (!per->data)
-                  return false;
-                per->reloc_tail_ptr = (oasys_reloc_type **) & (section->relocation);
-                per->had_vma = false;
-                per->initialized = true;
+                  return FALSE;
+                per->reloc_tail_ptr
+                  = (oasys_reloc_type **) &section->relocation;
+                per->had_vma = FALSE;
+                per->initialized = TRUE;
                 section->reloc_count = 0;
                 section->flags = SEC_ALLOC;
               }
 
-            dst_offset = bfd_h_get_32 (abfd, record.data.addr);
-            if (per->had_vma == false)
+            dst_offset = H_GET_32 (abfd, record.data.addr);
+            if (! per->had_vma)
               {
                 /* Take the first vma we see as the base */
                 section->vma = dst_offset;
-                per->had_vma = true;
+                per->had_vma = TRUE;
               }
 
@@ -682 +723 @@
                                 {
                                   /* Relocate the item relative to the section */
-                                  oasys_reloc_type *r =
-                                  (oasys_reloc_type *)
-                                  bfd_alloc (abfd,
-                                             sizeof (oasys_reloc_type));
+                                  oasys_reloc_type *r;
+
+                                  amt = sizeof (oasys_reloc_type);
+                                  r = (oasys_reloc_type *) bfd_alloc (abfd,
+                                                                      amt);
                                   if (!r)
-                                    return false;
+                                    return FALSE;
                                   *(per->reloc_tail_ptr) = r;
                                   per->reloc_tail_ptr = &r->next;
@@ -710 +752 @@
                                   section->reloc_count++;
 
-                                  /* Fake up the data to look like it's got the -ve pc in it, this makes
-                                       it much easier to convert into other formats. This is done by
-                                       hitting the addend.
-                                       */
-                                  if (r->relent.howto->pc_relative == true)
-                                    {
-                                      r->relent.addend -= dst_ptr - dst_base_ptr;
-                                    }
-
-
+                                  /* Fake up the data to look like
+                                     it's got the -ve pc in it, this
+                                     makes it much easier to convert
+                                     into other formats.  This is done
+                                     by hitting the addend.  */
+                                  if (r->relent.howto->pc_relative)
+                                    r->relent.addend -= dst_ptr - dst_base_ptr;
                                 }
                                 break;
@@ -726 +765 @@
                               case RELOCATION_TYPE_UND:
                                 {
-                                  oasys_reloc_type *r =
-                                  (oasys_reloc_type *)
-                                  bfd_alloc (abfd,
-                                             sizeof (oasys_reloc_type));
+                                  oasys_reloc_type *r;
+
+                                  amt = sizeof (oasys_reloc_type);
+                                  r = (oasys_reloc_type *) bfd_alloc (abfd,
+                                                                      amt);
                                   if (!r)
-                                    return false;
+                                    return FALSE;
                                   *(per->reloc_tail_ptr) = r;
                                   per->reloc_tail_ptr = &r->next;
@@ -753 +793 @@
 
                                   src += 2;
-                                  /* Fake up the data to look like it's got the -ve pc in it, this makes
-                                       it much easier to convert into other formats. This is done by
-                                       hitting the addend.
-                                       */
-                                  if (r->relent.howto->pc_relative == true)
-                                    {
-                                      r->relent.addend -= dst_ptr - dst_base_ptr;
-                                    }
-
-
-
+                                  /* Fake up the data to look like
+                                     it's got the -ve pc in it, this
+                                     makes it much easier to convert
+                                     into other formats.  This is done
+                                     by hitting the addend.  */
+                                  if (r->relent.howto->pc_relative)
+                                    r->relent.addend -= dst_ptr - dst_base_ptr;
                                 }
                                 break;
@@ -781 +817 @@
           break;
         default:
-          loop = false;
+          loop = FALSE;
         }
     }
 
-  return true;
-
-}
-
-static boolean
+  return TRUE;
+
+}
+
+static bfd_boolean
 oasys_new_section_hook (abfd, newsect)
      bfd *abfd;
@@ -795 +831 @@
 {
   newsect->used_by_bfd = (PTR)
-    bfd_alloc (abfd, sizeof (oasys_per_section_type));
+    bfd_alloc (abfd, (bfd_size_type) sizeof (oasys_per_section_type));
   if (!newsect->used_by_bfd)
-    return false;
+    return FALSE;
   oasys_per_section (newsect)->data = (bfd_byte *) NULL;
   oasys_per_section (newsect)->section = newsect;
   oasys_per_section (newsect)->offset = 0;
-  oasys_per_section (newsect)->initialized = false;
+  oasys_per_section (newsect)->initialized = FALSE;
   newsect->alignment_power = 1;
   /* Turn the section string into an index */
@@ -807 +843 @@
   sscanf (newsect->name, "%u", &newsect->target_index);
 
-  return true;
+  return TRUE;
 }
 
@@ -821 +857 @@
 }
 
-static boolean
+static bfd_boolean
 oasys_get_section_contents (abfd, section, location, offset, count)
      bfd *abfd;
@@ -829 +865 @@
      bfd_size_type count;
 {
-  oasys_per_section_type *p = (oasys_per_section_type *) section->used_by_bfd;
+  oasys_per_section_type *p = oasys_per_section (section);
   oasys_slurp_section_data (abfd);
-  if (p->initialized == false)
-    {
-      (void) memset (location, 0, (int) count);
+  if (! p->initialized)
+    {
+      (void) memset (location, 0, (size_t) count);
     }
   else
     {
-      (void) memcpy (location, (PTR) (p->data + offset), (int) count);
-    }
-  return true;
+      (void) memcpy (location, (PTR) (p->data + offset), (size_t) count);
+    }
+  return TRUE;
 }
 
@@ -878 +914 @@
 
 /* Calculate the checksum and write one record */
-static boolean
+static bfd_boolean
 oasys_write_record (abfd, type, record, size)
      bfd *abfd;
@@ -900 +936 @@
     }
   record->header.check_sum = 0xff & (-checksum);
-  if (bfd_write ((PTR) record, 1, size, abfd) != size)
-    return false;
-  return true;
+  if (bfd_bwrite ((PTR) record, (bfd_size_type) size, abfd) != size)
+    return FALSE;
+  return TRUE;
 }
 
 
 /* Write out all the symbols */
-static boolean
+static bfd_boolean
 oasys_write_syms (abfd)
      bfd *abfd;
@@ -918 +954 @@
 
       oasys_symbol_record_type symbol;
-      asymbol *CONST g = generic[count];
-
-      CONST char *src = g->name;
+      asymbol *const g = generic[count];
+
+      const char *src = g->name;
       char *dst = symbol.name;
       unsigned int l = 0;
@@ -927 +963 @@
         {
           symbol.relb = RELOCATION_TYPE_COM;
-          bfd_h_put_16 (abfd, index, symbol.refno);
+          H_PUT_16 (abfd, index, symbol.refno);
           index++;
         }
@@ -933 +969 @@
         {
           symbol.relb = RELOCATION_TYPE_ABS;
-          bfd_h_put_16 (abfd, 0, symbol.refno);
+          H_PUT_16 (abfd, 0, symbol.refno);
 
         }
@@ -939 +975 @@
         {
           symbol.relb = RELOCATION_TYPE_UND;
-          bfd_h_put_16 (abfd, index, symbol.refno);
+          H_PUT_16 (abfd, index, symbol.refno);
           /* Overload the value field with the output index number */
           index++;
@@ -961 +997 @@
               symbol.relb = RELOCATION_TYPE_REL | g->section->output_section->target_index;
             }
-          bfd_h_put_16 (abfd, 0, symbol.refno);
+          H_PUT_16 (abfd, 0, symbol.refno);
         }
 #ifdef UNDERSCORE_HACK
@@ -973 +1009 @@
         }
 
-      bfd_h_put_32 (abfd, g->value, symbol.value);
+      H_PUT_32 (abfd, g->value, symbol.value);
 
 
@@ -983 +1019 @@
                                     offsetof (oasys_symbol_record_type,
                                               name[0]) + l))
-            return false;
+            return FALSE;
         }
       else
@@ -992 +1028 @@
                                     offsetof (oasys_symbol_record_type,
                                               name[0]) + l))
-            return false;
+            return FALSE;
         }
       g->value = index - 1;
     }
 
-  return true;
+  return TRUE;
 }
 
 
  /* Write a section header for each section */
-static boolean
+static bfd_boolean
 oasys_write_sections (abfd)
      bfd *abfd;
@@ -1011 +1047 @@
   for (s = abfd->sections; s != (asection *) NULL; s = s->next)
     {
-      if (!isdigit ((unsigned char) s->name[0]))
+      if (!ISDIGIT (s->name[0]))
         {
           (*_bfd_error_handler)
@@ -1017 +1053 @@
              bfd_get_filename (abfd), s->name);
           bfd_set_error (bfd_error_nonrepresentable_section);
-          return false;
+          return FALSE;
         }
       out.relb = RELOCATION_TYPE_REL | s->target_index;
-      bfd_h_put_32 (abfd, s->_cooked_size, out.value);
-      bfd_h_put_32 (abfd, s->vma, out.vma);
+      H_PUT_32 (abfd, s->_cooked_size, out.value);
+      H_PUT_32 (abfd, s->vma, out.vma);
 
       if (! oasys_write_record (abfd,
@@ -1027 +1063 @@
                                 (oasys_record_union_type *) & out,
                                 sizeof (out)))
-        return false;
-    }
-  return true;
-}
-
-static boolean
+        return FALSE;
+    }
+  return TRUE;
+}
+
+static bfd_boolean
 oasys_write_header (abfd)
      bfd *abfd;
@@ -1058 +1094 @@
                             offsetof (oasys_header_record_type,
                                       description[0])))
-    return false;
-
-  return true;
-}
-
-static boolean
+    return FALSE;
+
+  return TRUE;
+}
+
+static bfd_boolean
 oasys_write_end (abfd)
      bfd *abfd;
@@ -1070 +1106 @@
   unsigned char null = 0;
   end.relb = RELOCATION_TYPE_ABS;
-  bfd_h_put_32 (abfd, abfd->start_address, end.entry);
-  bfd_h_put_16 (abfd, 0, end.fill);
+  H_PUT_32 (abfd, abfd->start_address, end.entry);
+  H_PUT_16 (abfd, 0, end.fill);
   end.zero = 0;
   if (! oasys_write_record (abfd,
@@ -1077 +1113 @@
                             (oasys_record_union_type *) & end,
                             sizeof (end)))
-    return false;
-  if (bfd_write ((PTR) & null, 1, 1, abfd) != 1)
-    return false;
-  return true;
+    return FALSE;
+  if (bfd_bwrite ((PTR) &null, (bfd_size_type) 1, abfd) != 1)
+    return FALSE;
+  return TRUE;
 }
 
 static int
 comp (ap, bp)
-     CONST PTR ap;
-     CONST PTR bp;
+     const PTR ap;
+     const PTR bp;
 {
   arelent *a = *((arelent **) ap);
@@ -1097 +1133 @@
 
 */
-static boolean
+static bfd_boolean
 oasys_write_data (abfd)
      bfd *abfd;
@@ -1135 +1171 @@
 
 
-              bfd_h_put_32 (abfd, s->vma + current_byte_index,
-                            processed_data.addr);
+              H_PUT_32 (abfd, s->vma + current_byte_index,
+                        processed_data.addr);
 
               /* Don't start a relocation unless you're sure you can finish it
@@ -1208 +1244 @@
 #endif
                             {
-                              asymbol *p = *(r->sym_ptr_ptr);
+                              asymbol *sym = *(r->sym_ptr_ptr);
 
                               /* If this symbol has a section attached, then it
                              has already been resolved.  Change from a symbol
                              ref to a section ref */
-                              if (p->section != (asection *) NULL)
+                              if (sym->section != (asection *) NULL)
                                 {
                                   rel_byte |= RELOCATION_TYPE_REL;
                                   rel_byte |=
-                                    p->section->output_section->target_index;
+                                    sym->section->output_section->target_index;
                                   *dst++ = rel_byte;
                                 }
@@ -1229 +1265 @@
                                symbol table was written
                                */
-                                  *dst++ = p->value >> 8;
-                                  *dst++ = p->value;
+                                  *dst++ = sym->value >> 8;
+                                  *dst++ = sym->value;
                                 }
                             }
@@ -1270 +1306 @@
                 }
 
-              if (! oasys_write_record (abfd,
-                                        oasys_record_is_data_enum,
-                                        ((oasys_record_union_type *)
-                                         & processed_data),
-                                        dst - (bfd_byte *) & processed_data))
-                return false;
+              if (! (oasys_write_record
+                     (abfd, oasys_record_is_data_enum,
+                      ((oasys_record_union_type *) &processed_data),
+                      (size_t) (dst - (bfd_byte *) &processed_data))))
+                return FALSE;
             }
         }
     }
 
-  return true;
-}
-
-static boolean
+  return TRUE;
+}
+
+static bfd_boolean
 oasys_write_object_contents (abfd)
      bfd *abfd;
 {
   if (! oasys_write_header (abfd))
-    return false;
+    return FALSE;
   if (! oasys_write_syms (abfd))
-    return false;
+    return FALSE;
   if (! oasys_write_sections (abfd))
-    return false;
+    return FALSE;
   if (! oasys_write_data (abfd))
-    return false;
+    return FALSE;
   if (! oasys_write_end (abfd))
-    return false;
-  return true;
+    return FALSE;
+  return TRUE;
 }
 
@@ -1308 +1343 @@
 * not a byte image, but a record stream.
 */
-static boolean
+static bfd_boolean
 oasys_set_section_contents (abfd, section, location, offset, count)
      bfd *abfd;
@@ -1323 +1358 @@
             (bfd_byte *) (bfd_alloc (abfd, section->_cooked_size));
           if (!oasys_per_section (section)->data)
-            return false;
+            return FALSE;
         }
       (void) memcpy ((PTR) (oasys_per_section (section)->data + offset),
@@ -1329 +1364 @@
                      (size_t) count);
     }
-  return true;
+  return TRUE;
 }
 
@@ -1344 +1379 @@
      bfd *abfd;
 {
-
-  oasys_symbol_type *new =
-  (oasys_symbol_type *) bfd_zalloc (abfd, sizeof (oasys_symbol_type));
+  bfd_size_type amt = sizeof (oasys_symbol_type);
+  oasys_symbol_type *new = (oasys_symbol_type *) bfd_zalloc (abfd, amt);
   if (!new)
     return NULL;
@@ -1397 +1431 @@
 }
 
-static boolean
-oasys_find_nearest_line (abfd,
-                         section,
-                         symbols,
-                         offset,
-                         filename_ptr,
-                         functionname_ptr,
-                         line_ptr)
+static bfd_boolean
+oasys_find_nearest_line (abfd, section, symbols, offset,
+                         filename_ptr, functionname_ptr, line_ptr)
      bfd *abfd ATTRIBUTE_UNUSED;
      asection *section ATTRIBUTE_UNUSED;
      asymbol **symbols ATTRIBUTE_UNUSED;
      bfd_vma offset ATTRIBUTE_UNUSED;
-     char **filename_ptr ATTRIBUTE_UNUSED;
-     char **functionname_ptr ATTRIBUTE_UNUSED;
+     const char **filename_ptr ATTRIBUTE_UNUSED;
+     const char **functionname_ptr ATTRIBUTE_UNUSED;
      unsigned int *line_ptr ATTRIBUTE_UNUSED;
 {
-  return false;
+  return FALSE;
 
 }
@@ -1439 +1468 @@
 oasys_sizeof_headers (abfd, exec)
      bfd *abfd ATTRIBUTE_UNUSED;
-     boolean exec ATTRIBUTE_UNUSED;
+     bfd_boolean exec ATTRIBUTE_UNUSED;
 {
   return 0;
@@ -1450 +1479 @@
 #define oasys_slurp_extended_name_table bfd_true
 #define oasys_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 oasys_truncate_arname bfd_dont_truncate_arname
 #define oasys_write_armap \
-  ((boolean (*) \
+  ((bfd_boolean (*) \
     PARAMS ((bfd *, unsigned int, struct orl *, unsigned int, int))) \
    bfd_true)
@@ -1478 +1507 @@
 #define oasys_bfd_relax_section bfd_generic_relax_section
 #define oasys_bfd_gc_sections bfd_generic_gc_sections
+#define oasys_bfd_merge_sections bfd_generic_merge_sections
+#define oasys_bfd_discard_group bfd_generic_discard_group
 #define oasys_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
+#define oasys_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
 #define oasys_bfd_link_add_symbols _bfd_generic_link_add_symbols
+#define oasys_bfd_link_just_syms _bfd_generic_link_just_syms
 #define oasys_bfd_final_link _bfd_generic_final_link
 #define oasys_bfd_link_split_section _bfd_generic_link_split_section
@@ -1534 +1567 @@
 
   NULL,
-  
+
   (PTR) 0
 };