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

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

@@ -1 +1 @@
 /* BFD backend for SunOS binaries.
-   Copyright 1990, 1991, 1992, 1994, 1995, 1996, 1997, 1998, 2000
-   Free Software Foundation, Inc.
+   Copyright 1990, 1991, 1992, 1994, 1995, 1996, 1997, 1998, 2000, 2001,
+   2002 Free Software Foundation, Inc.
    Written by Cygnus Support.
 
@@ -21 +21 @@
 
 #define TARGETNAME "a.out-sunos-big"
-#define MY(OP) CAT(sunos_big_,OP)
+
+/* Do not "beautify" the CONCAT* macro args.  Traditional C will not
+   remove whitespace added here, and thus will fail to concatenate
+   the tokens.  */
+#define MY(OP) CONCAT2 (sunos_big_,OP)
 
 #include "bfd.h"
@@ -29 +33 @@
 /* Static routines defined in this file.  */
 
-static boolean sunos_read_dynamic_info PARAMS ((bfd *));
+static bfd_boolean sunos_read_dynamic_info PARAMS ((bfd *));
 static long sunos_get_dynamic_symtab_upper_bound PARAMS ((bfd *));
-static boolean sunos_slurp_dynamic_symtab PARAMS ((bfd *));
+static bfd_boolean sunos_slurp_dynamic_symtab PARAMS ((bfd *));
 static long sunos_canonicalize_dynamic_symtab PARAMS ((bfd *, asymbol **));
 static long sunos_get_dynamic_reloc_upper_bound PARAMS ((bfd *));
@@ -40 +44 @@
 static struct bfd_link_hash_table *sunos_link_hash_table_create
   PARAMS ((bfd *));
-static boolean sunos_create_dynamic_sections
-  PARAMS ((bfd *, struct bfd_link_info *, boolean));
-static boolean sunos_add_dynamic_symbols
+static bfd_boolean sunos_create_dynamic_sections
+  PARAMS ((bfd *, struct bfd_link_info *, bfd_boolean));
+static bfd_boolean sunos_add_dynamic_symbols
   PARAMS ((bfd *, struct bfd_link_info *, struct external_nlist **,
            bfd_size_type *, char **));
-static boolean sunos_add_one_symbol
+static bfd_boolean sunos_add_one_symbol
   PARAMS ((struct bfd_link_info *, bfd *, const char *, flagword, asection *,
-           bfd_vma, const char *, boolean, boolean,
+           bfd_vma, const char *, bfd_boolean, bfd_boolean,
            struct bfd_link_hash_entry **));
-static boolean sunos_scan_relocs
+static bfd_boolean sunos_scan_relocs
   PARAMS ((struct bfd_link_info *, bfd *, asection *, bfd_size_type));
-static boolean sunos_scan_std_relocs
+static bfd_boolean sunos_scan_std_relocs
   PARAMS ((struct bfd_link_info *, bfd *, asection *,
            const struct reloc_std_external *, bfd_size_type));
-static boolean sunos_scan_ext_relocs
+static bfd_boolean sunos_scan_ext_relocs
   PARAMS ((struct bfd_link_info *, bfd *, asection *,
            const struct reloc_ext_external *, bfd_size_type));
-static boolean sunos_link_dynamic_object
+static bfd_boolean sunos_link_dynamic_object
   PARAMS ((struct bfd_link_info *, bfd *));
-static boolean sunos_write_dynamic_symbol
+static bfd_boolean sunos_write_dynamic_symbol
   PARAMS ((bfd *, struct bfd_link_info *, struct aout_link_hash_entry *));
-static boolean sunos_check_dynamic_reloc
+static bfd_boolean sunos_check_dynamic_reloc
   PARAMS ((struct bfd_link_info *, bfd *, asection *,
-           struct aout_link_hash_entry *, PTR, bfd_byte *, boolean *,
+           struct aout_link_hash_entry *, PTR, bfd_byte *, bfd_boolean *,
            bfd_vma *));
-static boolean sunos_finish_dynamic_link
+static bfd_boolean sunos_finish_dynamic_link
   PARAMS ((bfd *, struct bfd_link_info *));
 
@@ -102 +106 @@
 {
   /* Whether we found any dynamic information.  */
-  boolean valid;
+  bfd_boolean valid;
   /* Dynamic information.  */
   struct internal_sun4_dynamic_link dyninfo;
@@ -131 +135 @@
    creates and saves a sunos_dynamic_info structure.  If it can't find
    __DYNAMIC, it sets the valid field of the sunos_dynamic_info
-   structure to false to avoid doing this work again.  */
-
-static boolean
+   structure to FALSE to avoid doing this work again.  */
+
+static bfd_boolean
 sunos_read_dynamic_info (abfd)
      bfd *abfd;
@@ -143 +147 @@
   unsigned long dynver;
   struct external_sun4_dynamic_link linkinfo;
+  bfd_size_type amt;
 
   if (obj_aout_dynamic_info (abfd) != (PTR) NULL)
-    return true;
+    return TRUE;
 
   if ((abfd->flags & DYNAMIC) == 0)
     {
       bfd_set_error (bfd_error_invalid_operation);
-      return false;
-    }
-
-  info = ((struct sunos_dynamic_info *)
-          bfd_zalloc (abfd, sizeof (struct sunos_dynamic_info)));
+      return FALSE;
+    }
+
+  amt = sizeof (struct sunos_dynamic_info);
+  info = (struct sunos_dynamic_info *) bfd_zalloc (abfd, amt);
   if (!info)
-    return false;
-  info->valid = false;
+    return FALSE;
+  info->valid = FALSE;
   info->dynsym = NULL;
   info->dynstr = NULL;
@@ -173 +178 @@
      symbols for the __DYNAMIC symbol.  */
   if ((abfd->flags & DYNAMIC) == 0)
-    return true;
+    return TRUE;
   if (! bfd_get_section_contents (abfd, obj_datasec (abfd), (PTR) &dyninfo,
-                                  (file_ptr) 0, sizeof dyninfo))
-    return true;
+                                  (file_ptr) 0,
+                                  (bfd_size_type) sizeof dyninfo))
+    return TRUE;
 
   dynver = GET_WORD (abfd, dyninfo.ld_version);
   if (dynver != 2 && dynver != 3)
-    return true;
+    return TRUE;
 
   dynoff = GET_WORD (abfd, dyninfo.ld);
@@ -192 +198 @@
   dynoff -= bfd_get_section_vma (abfd, dynsec);
   if (dynoff > bfd_section_size (abfd, dynsec))
-    return true;
+    return TRUE;
 
   /* This executable appears to be dynamically linked in a way that we
      can understand.  */
-  if (! bfd_get_section_contents (abfd, dynsec, (PTR) &linkinfo, dynoff,
+  if (! bfd_get_section_contents (abfd, dynsec, (PTR) &linkinfo,
+                                  (file_ptr) dynoff,
                                   (bfd_size_type) sizeof linkinfo))
-    return true;
+    return TRUE;
 
   /* Swap in the dynamic link information.  */
@@ -245 +252 @@
                                   - info->dyninfo.ld_rel));
 
-  info->valid = true;
-
-  return true;
+  info->valid = TRUE;
+
+  return TRUE;
 }
 
@@ -273 +280 @@
 /* Read the external dynamic symbols.  */
 
-static boolean
+static bfd_boolean
 sunos_slurp_dynamic_symtab (abfd)
      bfd *abfd;
 {
   struct sunos_dynamic_info *info;
+  bfd_size_type amt;
 
   /* Get the general dynamic information.  */
@@ -283 +291 @@
     {
       if (! sunos_read_dynamic_info (abfd))
-          return false;
+          return FALSE;
     }
 
@@ -290 +298 @@
     {
       bfd_set_error (bfd_error_no_symbols);
-      return false;
+      return FALSE;
     }
 
@@ -296 +304 @@
   if (info->dynsym == (struct external_nlist *) NULL)
     {
-      info->dynsym = ((struct external_nlist *)
-                      bfd_alloc (abfd,
-                                 (info->dynsym_count
-                                  * EXTERNAL_NLIST_SIZE)));
+      amt = (bfd_size_type) info->dynsym_count * EXTERNAL_NLIST_SIZE;
+      info->dynsym = (struct external_nlist *) bfd_alloc (abfd, amt);
       if (info->dynsym == NULL && info->dynsym_count != 0)
-        return false;
-      if (bfd_seek (abfd, info->dyninfo.ld_stab, SEEK_SET) != 0
-          || (bfd_read ((PTR) info->dynsym, info->dynsym_count,
-                        EXTERNAL_NLIST_SIZE, abfd)
-              != info->dynsym_count * EXTERNAL_NLIST_SIZE))
+        return FALSE;
+      if (bfd_seek (abfd, (file_ptr) info->dyninfo.ld_stab, SEEK_SET) != 0
+          || bfd_bread ((PTR) info->dynsym, amt, abfd) != amt)
         {
           if (info->dynsym != NULL)
@@ -312 +316 @@
               info->dynsym = NULL;
             }
-          return false;
+          return FALSE;
         }
     }
@@ -319 +323 @@
   if (info->dynstr == (char *) NULL)
     {
-      info->dynstr = (char *) bfd_alloc (abfd, info->dyninfo.ld_symb_size);
+      amt = info->dyninfo.ld_symb_size;
+      info->dynstr = (char *) bfd_alloc (abfd, amt);
       if (info->dynstr == NULL && info->dyninfo.ld_symb_size != 0)
-        return false;
-      if (bfd_seek (abfd, info->dyninfo.ld_symbols, SEEK_SET) != 0
-          || (bfd_read ((PTR) info->dynstr, 1, info->dyninfo.ld_symb_size,
-                        abfd)
-              != info->dyninfo.ld_symb_size))
+        return FALSE;
+      if (bfd_seek (abfd, (file_ptr) info->dyninfo.ld_symbols, SEEK_SET) != 0
+          || bfd_bread ((PTR) info->dynstr, amt, abfd) != amt)
         {
           if (info->dynstr != NULL)
@@ -332 +335 @@
               info->dynstr = NULL;
             }
-          return false;
-        }
-    }
-
-  return true;
+          return FALSE;
+        }
+    }
+
+  return TRUE;
 }
 
@@ -368 +371 @@
     if (table == NULL && table_size != 0)
       abort ();
-    if (bfd_seek (abfd, info->dyninfo.ld_hash, SEEK_SET) != 0
-        || bfd_read ((PTR) table, 1, table_size, abfd) != table_size)
+    if (bfd_seek (abfd, (file_ptr) info->dyninfo.ld_hash, SEEK_SET) != 0
+        || bfd_bread ((PTR) table, table_size, abfd) != table_size)
       abort ();
     for (i = 0; i < info->dynsym_count; i++)
@@ -399 +402 @@
   if (info->canonical_dynsym == (aout_symbol_type *) NULL)
     {
-      info->canonical_dynsym = ((aout_symbol_type *)
-                                bfd_alloc (abfd,
-                                           (info->dynsym_count
-                                            * sizeof (aout_symbol_type))));
+      bfd_size_type size;
+      bfd_size_type strsize = info->dyninfo.ld_symb_size;
+
+      size = (bfd_size_type) info->dynsym_count * sizeof (aout_symbol_type);
+      info->canonical_dynsym = (aout_symbol_type *) bfd_alloc (abfd, size);
       if (info->canonical_dynsym == NULL && info->dynsym_count != 0)
         return -1;
 
       if (! aout_32_translate_symbol_table (abfd, info->canonical_dynsym,
-                                            info->dynsym, info->dynsym_count,
-                                            info->dynstr,
-                                            info->dyninfo.ld_symb_size,
-                                            true))
+                                            info->dynsym,
+                                            (bfd_size_type) info->dynsym_count,
+                                            info->dynstr, strsize, TRUE))
         {
           if (info->canonical_dynsym != NULL)
@@ -460 +463 @@
   struct sunos_dynamic_info *info;
   unsigned long i;
+  bfd_size_type size;
 
   /* Get the general dynamic information.  */
@@ -478 +482 @@
   if (info->dynrel == NULL)
     {
-      info->dynrel = (PTR) bfd_alloc (abfd,
-                                      (info->dynrel_count
-                                       * obj_reloc_entry_size (abfd)));
-      if (info->dynrel == NULL && info->dynrel_count != 0)
+      size = (bfd_size_type) info->dynrel_count * obj_reloc_entry_size (abfd);
+      info->dynrel = (PTR) bfd_alloc (abfd, size);
+      if (info->dynrel == NULL && size != 0)
         return -1;
-      if (bfd_seek (abfd, info->dyninfo.ld_rel, SEEK_SET) != 0
-          || (bfd_read ((PTR) info->dynrel, info->dynrel_count,
-                        obj_reloc_entry_size (abfd), abfd)
-              != info->dynrel_count * obj_reloc_entry_size (abfd)))
+      if (bfd_seek (abfd, (file_ptr) info->dyninfo.ld_rel, SEEK_SET) != 0
+          || bfd_bread ((PTR) info->dynrel, size, abfd) != size)
         {
           if (info->dynrel != NULL)
@@ -503 +504 @@
       arelent *to;
 
-      info->canonical_dynrel = ((arelent *)
-                                bfd_alloc (abfd,
-                                           (info->dynrel_count
-                                            * sizeof (arelent))));
+      size = (bfd_size_type) info->dynrel_count * sizeof (arelent);
+      info->canonical_dynrel = (arelent *) bfd_alloc (abfd, size);
       if (info->canonical_dynrel == NULL && info->dynrel_count != 0)
         return -1;
@@ -521 +520 @@
           for (; p < pend; p++, to++)
             NAME(aout,swap_ext_reloc_in) (abfd, p, to, syms,
-                                          info->dynsym_count);
+                                          (bfd_size_type) info->dynsym_count);
         }
       else
@@ -532 +531 @@
           for (; p < pend; p++, to++)
             NAME(aout,swap_std_reloc_in) (abfd, p, to, syms,
-                                          info->dynsym_count);
+                                          (bfd_size_type) info->dynsym_count);
         }
     }
@@ -566 +565 @@
 
 /* save %sp, -96, %sp */
-#define SPARC_PLT_ENTRY_WORD0 0x9de3bfa0
+#define SPARC_PLT_ENTRY_WORD0 ((bfd_vma) 0x9de3bfa0)
 /* call; address filled in later.  */
-#define SPARC_PLT_ENTRY_WORD1 0x40000000
+#define SPARC_PLT_ENTRY_WORD1 ((bfd_vma) 0x40000000)
 /* sethi; reloc index filled in later.  */
-#define SPARC_PLT_ENTRY_WORD2 0x01000000
+#define SPARC_PLT_ENTRY_WORD2 ((bfd_vma) 0x01000000)
 
 /* This sequence is used when for the jump table entry to a defined
@@ -576 +575 @@
    compiled code which is not being put into a shared library.  */
 /* sethi <address to be filled in later>, %g1 */
-#define SPARC_PLT_PIC_WORD0 0x03000000
+#define SPARC_PLT_PIC_WORD0 ((bfd_vma) 0x03000000)
 /* jmp %g1 + <address to be filled in later> */
-#define SPARC_PLT_PIC_WORD1 0x81c06000
+#define SPARC_PLT_PIC_WORD1 ((bfd_vma) 0x81c06000)
 /* nop */
-#define SPARC_PLT_PIC_WORD2 0x01000000
+#define SPARC_PLT_PIC_WORD2 ((bfd_vma) 0x01000000)
 
 /* An m68k procedure linkage table entry is 8 bytes.  The first entry
@@ -600 +599 @@
 
 /* bsrl */
-#define M68K_PLT_ENTRY_WORD0 (0x61ff)
+#define M68K_PLT_ENTRY_WORD0 ((bfd_vma) 0x61ff)
 /* Remaining words filled in later.  */
 
@@ -653 +652 @@
 
   /* Whether we have created the dynamic sections.  */
-  boolean dynamic_sections_created;
+  bfd_boolean dynamic_sections_created;
 
   /* Whether we need the dynamic sections.  */
-  boolean dynamic_sections_needed;
+  bfd_boolean dynamic_sections_needed;
 
   /* Whether we need the .got table.  */
-  boolean got_needed;
+  bfd_boolean got_needed;
 
   /* The number of dynamic symbols.  */
@@ -717 +716 @@
 {
   struct sunos_link_hash_table *ret;
-
-  ret = ((struct sunos_link_hash_table *)
-         bfd_alloc (abfd, sizeof (struct sunos_link_hash_table)));
+  bfd_size_type amt = sizeof (struct sunos_link_hash_table);
+
+  ret = (struct sunos_link_hash_table *) bfd_malloc (amt);
   if (ret == (struct sunos_link_hash_table *) NULL)
     return (struct bfd_link_hash_table *) NULL;
@@ -725 +724 @@
                                          sunos_link_hash_newfunc))
     {
-      bfd_release (abfd, ret);
+      free (ret);
       return (struct bfd_link_hash_table *) NULL;
     }
 
   ret->dynobj = NULL;
-  ret->dynamic_sections_created = false;
-  ret->dynamic_sections_needed = false;
-  ret->got_needed = false;
+  ret->dynamic_sections_created = FALSE;
+  ret->dynamic_sections_needed = FALSE;
+  ret->got_needed = FALSE;
   ret->dynsymcount = 0;
   ret->bucketcount = 0;
@@ -753 +752 @@
   (aout_link_hash_traverse                                              \
    (&(table)->root,                                                     \
-    (boolean (*) PARAMS ((struct aout_link_hash_entry *, PTR))) (func), \
+    (bfd_boolean (*) PARAMS ((struct aout_link_hash_entry *, PTR))) (func), \
     (info)))
 
@@ -761 +760 @@
 #define sunos_hash_table(p) ((struct sunos_link_hash_table *) ((p)->hash))
 
-static boolean sunos_scan_dynamic_symbol
+static bfd_boolean sunos_scan_dynamic_symbol
   PARAMS ((struct sunos_link_hash_entry *, PTR));
 
@@ -771 +770 @@
    of the dynamic linking information.  */
 
-static boolean
+static bfd_boolean
 sunos_create_dynamic_sections (abfd, info, needed)
      bfd *abfd;
      struct bfd_link_info *info;
-     boolean needed;
+     bfd_boolean needed;
 {
   asection *s;
@@ -795 +794 @@
           || ! bfd_set_section_flags (abfd, s, flags)
           || ! bfd_set_section_alignment (abfd, s, 2))
-        return false;
+        return FALSE;
 
       /* The .got section holds the global offset table.  The address
@@ -803 +802 @@
           || ! bfd_set_section_flags (abfd, s, flags)
           || ! bfd_set_section_alignment (abfd, s, 2))
-        return false;
+        return FALSE;
 
       /* The .plt section holds the procedure linkage table.  The
@@ -811 +810 @@
           || ! bfd_set_section_flags (abfd, s, flags | SEC_CODE)
           || ! bfd_set_section_alignment (abfd, s, 2))
-        return false;
+        return FALSE;
 
       /* The .dynrel section holds the dynamic relocs.  The address is
@@ -819 +818 @@
           || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
           || ! bfd_set_section_alignment (abfd, s, 2))
-        return false;
+        return FALSE;
 
       /* The .hash section holds the dynamic hash table.  The address
@@ -827 +826 @@
           || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
           || ! bfd_set_section_alignment (abfd, s, 2))
-        return false;
+        return FALSE;
 
       /* The .dynsym section holds the dynamic symbols.  The address
@@ -835 +834 @@
           || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
           || ! bfd_set_section_alignment (abfd, s, 2))
-        return false;
+        return FALSE;
 
       /* The .dynstr section holds the dynamic symbol string table.
@@ -843 +842 @@
           || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
           || ! bfd_set_section_alignment (abfd, s, 2))
-        return false;
-
-      sunos_hash_table (info)->dynamic_sections_created = true;
+        return FALSE;
+
+      sunos_hash_table (info)->dynamic_sections_created = TRUE;
     }
 
@@ -859 +858 @@
         s->_raw_size = BYTES_IN_WORD;
 
-      sunos_hash_table (info)->dynamic_sections_needed = true;
-      sunos_hash_table (info)->got_needed = true;
-    }
-
-  return true;
+      sunos_hash_table (info)->dynamic_sections_needed = TRUE;
+      sunos_hash_table (info)->got_needed = TRUE;
+    }
+
+  return TRUE;
 }
 
@@ -869 +868 @@
    backend linker for each object it encounters.  */
 
-static boolean
+static bfd_boolean
 sunos_add_dynamic_symbols (abfd, info, symsp, sym_countp, stringsp)
      bfd *abfd;
@@ -877 +876 @@
      char **stringsp;
 {
-  asection *s;
   bfd *dynobj;
   struct sunos_dynamic_info *dinfo;
   unsigned long need;
+  asection **ps;
 
   /* Make sure we have all the required sections.  */
@@ -886 +885 @@
     {
       if (! sunos_create_dynamic_sections (abfd, info,
-                                           (((abfd->flags & DYNAMIC) != 0
-                                             && ! info->relocateable)
-                                            ? true
-                                            : false)))
-        return false;
+                                           ((abfd->flags & DYNAMIC) != 0
+                                            && !info->relocateable)))
+        return FALSE;
     }
 
   /* There is nothing else to do for a normal object.  */
   if ((abfd->flags & DYNAMIC) == 0)
-    return true;
+    return TRUE;
 
   dynobj = sunos_hash_table (info)->dynobj;
@@ -906 +903 @@
      space in the output file.  If this is the first object we have
      seen, we must preserve the dynamic sections we just created.  */
-  if (abfd != dynobj)
-    abfd->sections = NULL;
-  else
-    {
-      asection *s;
-
-      for (s = abfd->sections;
-           (s->flags & SEC_LINKER_CREATED) == 0;
-           s = s->next)
-        ;
-      abfd->sections = s;
+  for (ps = &abfd->sections; *ps != NULL; )
+    {
+      if (abfd != dynobj || ((*ps)->flags & SEC_LINKER_CREATED) == 0)
+        bfd_section_list_remove (abfd, ps);
+      else
+        ps = &(*ps)->next;
     }
 
@@ -922 +914 @@
      used.  */
   if (info->relocateable)
-    return true;
+    return TRUE;
 
   /* There's no hope of using a dynamic object which does not exactly
@@ -929 +921 @@
     {
       bfd_set_error (bfd_error_invalid_operation);
-      return false;
+      return FALSE;
     }
 
@@ -940 +932 @@
          which must be included at runtime.  The address of this
          section is put in the ld_need field.  */
-      s = bfd_make_section (dynobj, ".need");
+      asection *s = bfd_make_section (dynobj, ".need");
       if (s == NULL
           || ! bfd_set_section_flags (dynobj, s,
@@ -949 +941 @@
                                        | SEC_READONLY))
           || ! bfd_set_section_alignment (dynobj, s, 2))
-        return false;
+        return FALSE;
     }
 
@@ -957 +949 @@
          objects.  The address of this section is put in the ld_rules
          field.  */
-      s = bfd_make_section (dynobj, ".rules");
+      asection *s = bfd_make_section (dynobj, ".rules");
       if (s == NULL
           || ! bfd_set_section_flags (dynobj, s,
@@ -966 +958 @@
                                        | SEC_READONLY))
           || ! bfd_set_section_alignment (dynobj, s, 2))
-        return false;
+        return FALSE;
     }
 
   /* Pick up the dynamic symbols and return them to the caller.  */
   if (! sunos_slurp_dynamic_symtab (abfd))
-    return false;
+    return FALSE;
 
   dinfo = (struct sunos_dynamic_info *) obj_aout_dynamic_info (abfd);
@@ -987 +979 @@
       struct bfd_link_needed_list *needed, **pp;
       char *namebuf, *p;
-      size_t alc;
+      bfd_size_type alc;
       bfd_byte b;
       char *namecopy;
 
-      if (bfd_seek (abfd, need, SEEK_SET) != 0
-          || bfd_read (buf, 1, 16, abfd) != 16)
-        return false;
+      if (bfd_seek (abfd, (file_ptr) need, SEEK_SET) != 0
+          || bfd_bread (buf, (bfd_size_type) 16, abfd) != 16)
+        return FALSE;
 
       /* For the format of an ld_need entry, see aout/sun4.h.  We
-         should probably define structs for this manipulation.  */
+         should probably define structs for this manipulation.  */
 
       name = bfd_get_32 (abfd, buf);
       flags = bfd_get_32 (abfd, buf + 4);
-      major_vno = (unsigned short)bfd_get_16 (abfd, buf + 8);
-      minor_vno = (unsigned short)bfd_get_16 (abfd, buf + 10);
+      major_vno = (unsigned short) bfd_get_16 (abfd, buf + 8);
+      minor_vno = (unsigned short) bfd_get_16 (abfd, buf + 10);
       need = bfd_get_32 (abfd, buf + 12);
 
-      needed = ((struct bfd_link_needed_list *)
-                bfd_alloc (abfd, sizeof (struct bfd_link_needed_list)));
+      alc = sizeof (struct bfd_link_needed_list);
+      needed = (struct bfd_link_needed_list *) bfd_alloc (abfd, alc);
       if (needed == NULL)
-        return false;
+        return FALSE;
       needed->by = abfd;
 
@@ -1014 +1006 @@
       namebuf = (char *) bfd_malloc (alc + 1);
       if (namebuf == NULL)
-        return false;
+        return FALSE;
       p = namebuf;
 
@@ -1022 +1014 @@
           *p++ = 'l';
         }
-      if (bfd_seek (abfd, name, SEEK_SET) != 0)
+      if (bfd_seek (abfd, (file_ptr) name, SEEK_SET) != 0)
         {
           free (namebuf);
-          return false;
+          return FALSE;
         }
 
       do
         {
-          if (bfd_read (&b, 1, 1, abfd) != 1)
+          if (bfd_bread (&b, (bfd_size_type) 1, abfd) != 1)
             {
               free (namebuf);
-              return false;
+              return FALSE;
             }
 
-          if ((size_t) (p - namebuf) >= alc)
+          if ((bfd_size_type) (p - namebuf) >= alc)
             {
               char *n;
@@ -1045 +1037 @@
                 {
                   free (namebuf);
-                  return false;
+                  return FALSE;
                 }
               p = n + (p - namebuf);
@@ -1077 +1069 @@
                 {
                   free (namebuf);
-                  return false;
+                  return FALSE;
                 }
               p = n + (p - namebuf);
@@ -1087 +1079 @@
         }
 
-      namecopy = bfd_alloc (abfd, strlen (namebuf) + 1);
+      namecopy = bfd_alloc (abfd, (bfd_size_type) strlen (namebuf) + 1);
       if (namecopy == NULL)
         {
           free (namebuf);
-          return false;
+          return FALSE;
         }
       strcpy (namecopy, namebuf);
@@ -1106 +1098 @@
     }
 
-  return true;
+  return TRUE;
 }
 
@@ -1113 +1105 @@
    tweaking needed for dynamic linking support.  */
 
-static boolean
+static bfd_boolean
 sunos_add_one_symbol (info, abfd, name, flags, section, value, string,
                       copy, collect, hashp)
@@ -1123 +1115 @@
      bfd_vma value;
      const char *string;
-     boolean copy;
-     boolean collect;
+     bfd_boolean copy;
+     bfd_boolean collect;
      struct bfd_link_hash_entry **hashp;
 {
@@ -1132 +1124 @@
   if ((flags & (BSF_INDIRECT | BSF_WARNING | BSF_CONSTRUCTOR)) != 0
       || ! bfd_is_und_section (section))
-    h = sunos_link_hash_lookup (sunos_hash_table (info), name, true, copy,
-                                false);
+    h = sunos_link_hash_lookup (sunos_hash_table (info), name, TRUE, copy,
+                                FALSE);
   else
     h = ((struct sunos_link_hash_entry *)
-         bfd_wrapped_link_hash_lookup (abfd, info, name, true, copy, false));
+         bfd_wrapped_link_hash_lookup (abfd, info, name, TRUE, copy, FALSE));
   if (h == NULL)
-    return false;
+    return FALSE;
 
   if (hashp != NULL)
@@ -1192 +1184 @@
     {
       /* The existing symbol is a constructor symbol, and this symbol
-         is from a dynamic object.  A constructor symbol is actually a
-         definition, although the type will be bfd_link_hash_undefined
-         at this point.  We want to ignore the definition from the
-         dynamic object.  */
+         is from a dynamic object.  A constructor symbol is actually a
+         definition, although the type will be bfd_link_hash_undefined
+         at this point.  We want to ignore the definition from the
+         dynamic object.  */
       section = bfd_und_section_ptr;
     }
@@ -1205 +1197 @@
     {
       /* The existing symbol is defined by a dynamic object, and this
-         is a constructor symbol.  As above, we want to force the use
-         of the constructor symbol from the regular object.  */
+         is a constructor symbol.  As above, we want to force the use
+         of the constructor symbol from the regular object.  */
       h->root.root.type = bfd_link_hash_new;
     }
@@ -1214 +1206 @@
                                           value, string, copy, collect,
                                           hashp))
-    return false;
+    return FALSE;
 
   if (abfd->xvec == info->hash->creator)
@@ -1251 +1243 @@
     }
 
-  return true;
+  return TRUE;
 }
 
@@ -1270 +1262 @@
    this in case some dynamic object refers to this symbol.  */
 
-boolean
+bfd_boolean
 bfd_sunos_record_link_assignment (output_bfd, info, name)
      bfd *output_bfd;
@@ -1279 +1271 @@
 
   if (output_bfd->xvec != &MY(vec))
-    return true;
+    return TRUE;
 
   /* This is called after we have examined all the input objects.  If
@@ -1285 +1277 @@
      to it, and we can just ignore it at this point.  */
   h = sunos_link_hash_lookup (sunos_hash_table (info), name,
-                              false, false, false);
+                              FALSE, FALSE, FALSE);
   if (h == NULL)
-    return true;
+    return TRUE;
 
   /* In a shared library, the __DYNAMIC symbol does not appear in the
@@ -1302 +1294 @@
     }
 
-  return true;
+  return TRUE;
 }
 
@@ -1311 +1303 @@
    sections.  This unfortunately requires reading all the relocs so
    that we can work out which ones need to become dynamic relocs.  If
-   info->keep_memory is true, we keep the relocs in memory; otherwise,
+   info->keep_memory is TRUE, we keep the relocs in memory; otherwise,
    we discard them, and will read them again later.  */
 
-boolean
+bfd_boolean
 bfd_sunos_size_dynamic_sections (output_bfd, info, sdynptr, sneedptr,
                                  srulesptr)
@@ -1324 +1316 @@
 {
   bfd *dynobj;
-  size_t dynsymcount;
+  bfd_size_type dynsymcount;
   struct sunos_link_hash_entry *h;
   asection *s;
   size_t bucketcount;
-  size_t hashalloc;
+  bfd_size_type hashalloc;
   size_t i;
   bfd *sub;
@@ -1337 +1329 @@
 
   if (info->relocateable)
-    return true;
+    return TRUE;
 
   if (output_bfd->xvec != &MY(vec))
-    return true;
+    return TRUE;
 
   /* Look through all the input BFD's and read their relocs.  It would
@@ -1356 +1348 @@
               || ! sunos_scan_relocs (info, sub, obj_datasec (sub),
                                       exec_hdr (sub)->a_drsize))
-            return false;
+            return FALSE;
         }
     }
@@ -1367 +1359 @@
   if (! sunos_hash_table (info)->dynamic_sections_needed
       && ! sunos_hash_table (info)->got_needed)
-    return true;
+    return TRUE;
 
   /* If __GLOBAL_OFFSET_TABLE_ was mentioned, define it.  */
   h = sunos_link_hash_lookup (sunos_hash_table (info),
-                              "__GLOBAL_OFFSET_TABLE_", false, false, false);
+                              "__GLOBAL_OFFSET_TABLE_", FALSE, FALSE, FALSE);
   if (h != NULL && (h->flags & SUNOS_REF_REGULAR) != 0)
     {
@@ -1384 +1376 @@
 
       /* If the .got section is more than 0x1000 bytes, we set
-         __GLOBAL_OFFSET_TABLE_ to be 0x1000 bytes into the section,
-         so that 13 bit relocations have a greater chance of working.  */
+         __GLOBAL_OFFSET_TABLE_ to be 0x1000 bytes into the section,
+         so that 13 bit relocations have a greater chance of working.  */
       s = bfd_get_section_by_name (dynobj, ".got");
       BFD_ASSERT (s != NULL);
@@ -1422 +1414 @@
       s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
       if (s->contents == NULL && s->_raw_size != 0)
-        return false;
+        return FALSE;
 
       /* The number of buckets is just the number of symbols divided
@@ -1441 +1433 @@
       BFD_ASSERT (s != NULL);
       hashalloc = (dynsymcount + bucketcount - 1) * HASH_ENTRY_SIZE;
-      s->contents = (bfd_byte *) bfd_alloc (dynobj, hashalloc);
+      s->contents = (bfd_byte *) bfd_zalloc (dynobj, hashalloc);
       if (s->contents == NULL && dynsymcount > 0)
-        return false;
-      memset (s->contents, 0, hashalloc);
+        return FALSE;
       for (i = 0; i < bucketcount; i++)
         PUT_WORD (output_bfd, (bfd_vma) -1, s->contents + i * HASH_ENTRY_SIZE);
@@ -1472 +1463 @@
           add = 8 - (s->_raw_size & 7);
           contents = (bfd_byte *) bfd_realloc (s->contents,
-                                               (size_t) (s->_raw_size + add));
+                                               s->_raw_size + add);
           if (contents == NULL)
-            return false;
+            return FALSE;
           memset (contents + s->_raw_size, 0, (size_t) add);
           s->contents = contents;
@@ -1489 +1480 @@
       s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
       if (s->contents == NULL)
-        return false;
+        return FALSE;
 
       /* Fill in the first entry in the table.  */
@@ -1512 +1503 @@
       s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
       if (s->contents == NULL)
-        return false;
+        return FALSE;
     }
   /* We use the reloc_count field to keep track of how many of the
@@ -1522 +1513 @@
   s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
   if (s->contents == NULL)
-    return false;
+    return FALSE;
 
   *sneedptr = bfd_get_section_by_name (dynobj, ".need");
   *srulesptr = bfd_get_section_by_name (dynobj, ".rules");
 
-  return true;
+  return TRUE;
 }
 
 /* Scan the relocs for an input section.  */
 
-static boolean
+static bfd_boolean
 sunos_scan_relocs (info, abfd, sec, rel_size)
      struct bfd_link_info *info;
@@ -1543 +1534 @@
 
   if (rel_size == 0)
-    return true;
+    return TRUE;
 
   if (! info->keep_memory)
-    relocs = free_relocs = bfd_malloc ((size_t) rel_size);
+    relocs = free_relocs = bfd_malloc (rel_size);
   else
     {
       struct aout_section_data_struct *n;
-
-      n = ((struct aout_section_data_struct *)
-           bfd_alloc (abfd, sizeof (struct aout_section_data_struct)));
+      bfd_size_type amt = sizeof (struct aout_section_data_struct);
+
+      n = (struct aout_section_data_struct *) bfd_alloc (abfd, amt);
       if (n == NULL)
         relocs = NULL;
@@ -1558 +1549 @@
         {
           set_aout_section_data (sec, n);
-          relocs = bfd_malloc ((size_t) rel_size);
+          relocs = bfd_malloc (rel_size);
           aout_section_data (sec)->relocs = relocs;
         }
     }
   if (relocs == NULL)
-    return false;
+    return FALSE;
 
   if (bfd_seek (abfd, sec->rel_filepos, SEEK_SET) != 0
-      || bfd_read (relocs, 1, rel_size, abfd) != rel_size)
+      || bfd_bread (relocs, rel_size, abfd) != rel_size)
     goto error_return;
 
@@ -1587 +1578 @@
     free (free_relocs);
 
-  return true;
+  return TRUE;
 
  error_return:
   if (free_relocs != NULL)
     free (free_relocs);
-  return false;
+  return FALSE;
 }
 
@@ -1605 +1596 @@
    building global offset table entries.  */
 
-static boolean
+static bfd_boolean
 sunos_scan_std_relocs (info, abfd, sec, relocs, rel_size)
      struct bfd_link_info *info;
@@ -1623 +1614 @@
     {
       bfd_set_error (bfd_error_invalid_target);
-      return false;
+      return FALSE;
     }
 
@@ -1685 +1676 @@
           asection *sgot;
 
-          if (! sunos_create_dynamic_sections (abfd, info, false))
-            return false;
+          if (! sunos_create_dynamic_sections (abfd, info, FALSE))
+            return FALSE;
           dynobj = sunos_hash_table (info)->dynobj;
           splt = bfd_get_section_by_name (dynobj, ".plt");
@@ -1696 +1687 @@
           if (sgot->_raw_size == 0)
             sgot->_raw_size = BYTES_IN_WORD;
-          sunos_hash_table (info)->got_needed = true;
+          sunos_hash_table (info)->got_needed = TRUE;
         }
 
@@ -1756 +1747 @@
     }
 
-  return true;
+  return TRUE;
 }
 
@@ -1765 +1756 @@
    Otherwise, we must preserve the reloc as a dynamic reloc.  */
 
-static boolean
+static bfd_boolean
 sunos_scan_ext_relocs (info, abfd, sec, relocs, rel_size)
      struct bfd_link_info *info;
@@ -1779 +1770 @@
   asection *sgot = NULL;
   asection *srel = NULL;
+  bfd_size_type amt;
 
   /* We only know how to handle SPARC plt entries.  */
@@ -1784 +1776 @@
     {
       bfd_set_error (bfd_error_invalid_target);
-      return false;
+      return FALSE;
     }
 
@@ -1831 +1823 @@
 
       /* If this is a base relative reloc, we need to make an entry in
-         the .got section.  */
+         the .got section.  */
       if (r_type == RELOC_BASE10
           || r_type == RELOC_BASE13
@@ -1838 +1830 @@
           if (dynobj == NULL)
             {
-              if (! sunos_create_dynamic_sections (abfd, info, false))
-                return false;
+              if (! sunos_create_dynamic_sections (abfd, info, FALSE))
+                return FALSE;
               dynobj = sunos_hash_table (info)->dynobj;
               splt = bfd_get_section_by_name (dynobj, ".plt");
@@ -1849 +1841 @@
               if (sgot->_raw_size == 0)
                 sgot->_raw_size = BYTES_IN_WORD;
-              sunos_hash_table (info)->got_needed = true;
+              sunos_hash_table (info)->got_needed = TRUE;
             }
 
@@ -1870 +1862 @@
               if (adata (abfd).local_got_offsets == NULL)
                 {
+                  amt = bfd_get_symcount (abfd);
+                  amt *= sizeof (bfd_vma);
                   adata (abfd).local_got_offsets =
-                    (bfd_vma *) bfd_zalloc (abfd,
-                                            (bfd_get_symcount (abfd)
-                                             * sizeof (bfd_vma)));
+                    (bfd_vma *) bfd_zalloc (abfd, amt);
                   if (adata (abfd).local_got_offsets == NULL)
-                    return false;
+                    return FALSE;
                 }
 
@@ -1899 +1891 @@
 
       /* Otherwise, we are only interested in relocs against symbols
-         defined in dynamic objects but not in regular objects.  We
-         only need to consider relocs against external symbols.  */
+         defined in dynamic objects but not in regular objects.  We
+         only need to consider relocs against external symbols.  */
       if (! r_extern)
         {
           /* But, if we are creating a shared library, we need to
-             generate an absolute reloc.  */
+             generate an absolute reloc.  */
           if (info->shared)
             {
               if (dynobj == NULL)
                 {
-                  if (! sunos_create_dynamic_sections (abfd, info, true))
-                    return false;
+                  if (! sunos_create_dynamic_sections (abfd, info, TRUE))
+                    return FALSE;
                   dynobj = sunos_hash_table (info)->dynobj;
                   splt = bfd_get_section_by_name (dynobj, ".plt");
@@ -1946 +1938 @@
         {
           /* This symbol is apparently undefined.  Don't do anything
-             here; just let the relocation routine report an undefined
-             symbol.  */
+             here; just let the relocation routine report an undefined
+             symbol.  */
           continue;
         }
@@ -1956 +1948 @@
       if (dynobj == NULL)
         {
-          if (! sunos_create_dynamic_sections (abfd, info, false))
-            return false;
+          if (! sunos_create_dynamic_sections (abfd, info, FALSE))
+            return FALSE;
           dynobj = sunos_hash_table (info)->dynobj;
           splt = bfd_get_section_by_name (dynobj, ".plt");
@@ -1967 +1959 @@
           if (sgot->_raw_size == 0)
             sgot->_raw_size = BYTES_IN_WORD;
-          sunos_hash_table (info)->got_needed = true;
+          sunos_hash_table (info)->got_needed = TRUE;
         }
 
@@ -2032 +2024 @@
 
               /* We will also need a dynamic reloc entry, unless this
-                 is a JMP_TBL reloc produced by linking PIC compiled
-                 code, and we are not making a shared library.  */
+                 is a JMP_TBL reloc produced by linking PIC compiled
+                 code, and we are not making a shared library.  */
               if (info->shared || (h->flags & SUNOS_DEF_REGULAR) == 0)
                 srel->_raw_size += RELOC_EXT_SIZE;
@@ -2039 +2031 @@
 
           /* If we are creating a shared library, we need to copy over
-             any reloc other than a jump table reloc.  */
+             any reloc other than a jump table reloc.  */
           if (info->shared && r_type != RELOC_JMP_TBL)
             srel->_raw_size += RELOC_EXT_SIZE;
@@ -2045 +2037 @@
     }
 
-  return true;
+  return TRUE;
 }
 
@@ -2051 +2043 @@
    symbols from dynamic objects which we do not plan to write out.  */
 
-static boolean
+static bfd_boolean
 sunos_scan_dynamic_symbol (h, data)
      struct sunos_link_hash_entry *h;
@@ -2057 +2049 @@
 {
   struct bfd_link_info *info = (struct bfd_link_info *) data;
+
+  if (h->root.root.type == bfd_link_hash_warning)
+    h = (struct sunos_link_hash_entry *) h->root.root.u.i.link;
 
   /* Set the written flag for symbols we do not want to write out as
@@ -2070 +2065 @@
       && (h->flags & SUNOS_DEF_DYNAMIC) != 0
       && strcmp (h->root.root.root.string, "__DYNAMIC") != 0)
-    h->root.written = true;
+    h->root.written = TRUE;
 
   /* If this symbol is defined by a dynamic object and referenced by a
@@ -2129 +2124 @@
                                            s->_raw_size + len + 1);
       if (contents == NULL)
-        return false;
+        return FALSE;
       s->contents = contents;
 
@@ -2165 +2160 @@
     }
 
-  return true;
+  return TRUE;
 }
 
@@ -2173 +2168 @@
 
 /*ARGSUSED*/
-static boolean
+static bfd_boolean
 sunos_link_dynamic_object (info, abfd)
      struct bfd_link_info *info ATTRIBUTE_UNUSED;
      bfd *abfd ATTRIBUTE_UNUSED;
 {
-  return true;
+  return TRUE;
 }
 
@@ -2184 +2179 @@
    over the symbol table.  */
 
-static boolean
+static bfd_boolean
 sunos_write_dynamic_symbol (output_bfd, info, harg)
      bfd *output_bfd;
@@ -2203 +2198 @@
       asection *splt;
       bfd_byte *p;
-      asection *s;
       bfd_vma r_address;
 
@@ -2232 +2226 @@
           else
             {
-              bfd_vma val;
-
               val = (h->root.root.u.def.section->output_section->vma
                      + h->root.root.u.def.section->output_offset
@@ -2252 +2244 @@
           bfd_put_16 (output_bfd, M68K_PLT_ENTRY_WORD0, p);
           bfd_put_32 (output_bfd, (- (h->plt_offset + 2)), p + 2);
-          bfd_put_16 (output_bfd, s->reloc_count, p + 6);
+          bfd_put_16 (output_bfd, (bfd_vma) s->reloc_count, p + 6);
           r_address += 2;
           break;
@@ -2261 +2253 @@
 
       /* We also need to add a jump table reloc, unless this is the
-         result of a JMP_TBL reloc from PIC compiled code.  */
+         result of a JMP_TBL reloc from PIC compiled code.  */
       if (info->shared || (h->flags & SUNOS_DEF_REGULAR) == 0)
         {
@@ -2327 +2319 @@
      compiled code from a regular object.  */
   if (h->dynindx < 0)
-    return true;
+    return TRUE;
 
   switch (h->root.root.type)
@@ -2335 +2327 @@
       abort ();
       /* Avoid variable not initialized warnings.  */
-      return true;
+      return TRUE;
     case bfd_link_hash_undefined:
       type = N_UNDF | N_EXT;
@@ -2393 +2385 @@
       /* FIXME: Ignore these for now.  The circumstances under which
          they should be written out are not clear to me.  */
-      return true;
+      return TRUE;
     }
 
@@ -2401 +2393 @@
             (s->contents + h->dynindx * EXTERNAL_NLIST_SIZE));
 
-  bfd_h_put_8 (output_bfd, type, outsym->e_type);
-  bfd_h_put_8 (output_bfd, 0, outsym->e_other);
+  H_PUT_8 (output_bfd, type, outsym->e_type);
+  H_PUT_8 (output_bfd, 0, outsym->e_other);
 
   /* FIXME: The native linker doesn't use 0 for desc.  It seems to use
      one less than the desc value in the shared library, although that
      seems unlikely.  */
-  bfd_h_put_16 (output_bfd, 0, outsym->e_desc);
+  H_PUT_16 (output_bfd, 0, outsym->e_desc);
 
   PUT_WORD (output_bfd, h->dynstr_index, outsym->e_strx);
   PUT_WORD (output_bfd, val, outsym->e_value);
 
-  return true;
+  return TRUE;
 }
 
@@ -2421 +2413 @@
 
 /*ARGSUSED*/
-static boolean
+static bfd_boolean
 sunos_check_dynamic_reloc (info, input_bfd, input_section, harg, reloc,
                            contents, skip, relocationp)
@@ -2430 +2422 @@
      PTR reloc;
      bfd_byte *contents ATTRIBUTE_UNUSED;
-     boolean *skip;
+     bfd_boolean *skip;
      bfd_vma *relocationp;
 {
   struct sunos_link_hash_entry *h = (struct sunos_link_hash_entry *) harg;
   bfd *dynobj;
-  boolean baserel;
-  boolean jmptbl;
-  boolean pcrel;
+  bfd_boolean baserel;
+  bfd_boolean jmptbl;
+  bfd_boolean pcrel;
   asection *s;
   bfd_byte *p;
   long indx;
 
-  *skip = false;
+  *skip = FALSE;
 
   dynobj = sunos_hash_table (info)->dynobj;
@@ -2500 +2492 @@
                || r_type == RELOC_WDISP22);
       /* We don't consider the PC10 and PC22 types to be PC relative,
-         because they are pcrel_offset.  */
+         because they are pcrel_offset.  */
     }
 
@@ -2569 +2561 @@
             {
               /* We need to create a GLOB_DAT or 32 reloc to tell the
-                 dynamic linker to fill in this entry in the table.  */
+                 dynamic linker to fill in this entry in the table.  */
 
               s = bfd_get_section_by_name (dynobj, ".dynrel");
@@ -2670 +2662 @@
 
       *relocationp = (sgot->vma
-                      + (*got_offsetp &~ 1)
+                      + (*got_offsetp &~ (bfd_vma) 1)
                       - sunos_hash_table (info)->got_base);
 
       /* There is nothing else to do for a base relative reloc.  */
-      return true;
+      return TRUE;
     }
 
   if (! sunos_hash_table (info)->dynamic_sections_needed)
-    return true;
+    return TRUE;
   if (! info->shared)
     {
@@ -2687 +2679 @@
           || (h->flags & SUNOS_DEF_DYNAMIC) == 0
           || (h->root.root.u.undef.abfd->flags & DYNAMIC) == 0)
-        return true;
+        return TRUE;
     }
   else
@@ -2696 +2688 @@
               || strcmp (h->root.root.root.string,
                          "__GLOBAL_OFFSET_TABLE_") == 0))
-        return true;
+        return TRUE;
     }
 
@@ -2739 +2731 @@
         }
       /* FIXME: We may have to change the addend for a PC relative
-         reloc.  */
+         reloc.  */
     }
   else
@@ -2778 +2770 @@
 
   if (h != NULL)
-    *skip = true;
-
-  return true;
+    *skip = TRUE;
+
+  return TRUE;
 }
 
 /* Finish up the dynamic linking information.  */
 
-static boolean
+static bfd_boolean
 sunos_finish_dynamic_link (abfd, info)
      bfd *abfd;
@@ -2797 +2789 @@
   if (! sunos_hash_table (info)->dynamic_sections_needed
       && ! sunos_hash_table (info)->got_needed)
-    return true;
+    return TRUE;
 
   dynobj = sunos_hash_table (info)->dynobj;
@@ -2847 +2839 @@
                       && o->output_section->owner == abfd);
           if (! bfd_set_section_contents (abfd, o->output_section,
-                                          o->contents, o->output_offset,
+                                          o->contents,
+                                          (file_ptr) o->output_offset,
                                           o->_raw_size))
-            return false;
+            return FALSE;
         }
     }
@@ -2857 +2850 @@
       struct external_sun4_dynamic esd;
       struct external_sun4_dynamic_link esdl;
+      file_ptr pos;
 
       /* Finish up the dynamic link information.  */
@@ -2871 +2865 @@
 
       if (! bfd_set_section_contents (abfd, sdyn->output_section, &esd,
-                                      sdyn->output_offset, sizeof esd))
-        return false;
+                                      (file_ptr) sdyn->output_offset,
+                                      (bfd_size_type) sizeof esd))
+        return FALSE;
 
       PUT_WORD (dynobj, (bfd_vma) 0, esdl.ld_loaded);
@@ -2936 +2931 @@
                 esdl.ld_text);
 
+      pos = sdyn->output_offset;
+      pos += sizeof esd + EXTERNAL_SUN4_DYNAMIC_DEBUGGER_SIZE;
       if (! bfd_set_section_contents (abfd, sdyn->output_section, &esdl,
-                                      (sdyn->output_offset
-                                       + sizeof esd
-                                       + EXTERNAL_SUN4_DYNAMIC_DEBUGGER_SIZE),
-                                      sizeof esdl))
-        return false;
+                                      pos, (bfd_size_type) sizeof esdl))
+        return FALSE;
 
       abfd->flags |= DYNAMIC;
     }
 
-  return true;
+  return TRUE;
 }