Changeset 609 for branches/GNU/src/binutils/bfd/nlmcode.h

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/nlmcode.h (modified) (72 diffs, 1 prop)

branches/GNU/src/binutils/bfd/nlmcode.h

@@ -1 +1 @@
 /* NLM (NetWare Loadable Module) executable support for BFD.
-   Copyright 1993, 1994, 1995, 1998, 2000 Free Software Foundation, Inc.
+   Copyright 1993, 1994, 1995, 1998, 2000, 2001, 2002
+   Free Software Foundation, Inc.
 
    Written by Fred Fish @ Cygnus Support, using ELF support as the
    template.
 
-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.  */
 
 #include "bfd.h"
@@ -57 +58 @@
   (nlm_swap_fixed_header_out_func(abfd)) (abfd,src,dst)
 
-/* Forward declarations of static functions */
-
-static boolean add_bfd_section
+/* Forward declarations of static functions.  */
+
+static bfd_boolean add_bfd_section
   PARAMS ((bfd *, char *, file_ptr, bfd_size_type, flagword));
-static boolean nlm_swap_variable_header_in
+static bfd_boolean nlm_swap_variable_header_in
   PARAMS ((bfd *));
-static boolean nlm_swap_variable_header_out
+static bfd_boolean nlm_swap_variable_header_out
   PARAMS ((bfd *));
-static boolean find_nonzero
+static bfd_boolean find_nonzero
   PARAMS ((PTR, size_t));
-static boolean nlm_swap_auxiliary_headers_in
+static bfd_boolean nlm_swap_auxiliary_headers_in
   PARAMS ((bfd *));
-static boolean nlm_swap_auxiliary_headers_out
+static bfd_boolean nlm_swap_auxiliary_headers_out
   PARAMS ((bfd *));
-static boolean nlm_slurp_symbol_table
+static bfd_boolean nlm_slurp_symbol_table
   PARAMS ((bfd *));
-static boolean nlm_slurp_reloc_fixups
+static bfd_boolean nlm_slurp_reloc_fixups
   PARAMS ((bfd *));
-static boolean nlm_compute_section_file_positions
+static bfd_boolean nlm_compute_section_file_positions
   PARAMS ((bfd *));
 static int nlm_external_reloc_compare
@@ -83 +84 @@
    can be handled by explicitly specifying 32 bits or "the long type".  */
 #if ARCH_SIZE == 64
-#define put_word        bfd_h_put_64
-#define get_word        bfd_h_get_64
+#define put_word        H_PUT_64
+#define get_word        H_GET_64
 #endif
 #if ARCH_SIZE == 32
-#define put_word        bfd_h_put_32
-#define get_word        bfd_h_get_32
+#define put_word        H_PUT_32
+#define get_word        H_GET_32
 #endif
 
@@ -96 +97 @@
 {
   struct nlm_obj_tdata *preserved_tdata = nlm_tdata (abfd);
-  boolean (*backend_object_p) PARAMS ((bfd *));
+  bfd_boolean (*backend_object_p) PARAMS ((bfd *));
   PTR x_fxdhdr = NULL;
   Nlm_Internal_Fixed_Header *i_fxdhdrp;
@@ -102 +103 @@
   const char *signature;
   enum bfd_architecture arch;
+  bfd_size_type amt;
 
   /* Some NLM formats have a prefix before the standard NLM fixed
@@ -113 +115 @@
 
   /* Read in the fixed length portion of the NLM header in external format.  */
-
-  x_fxdhdr = (PTR) bfd_malloc ((size_t) nlm_fixed_header_size (abfd));
+  amt = nlm_fixed_header_size (abfd);
+  x_fxdhdr = (PTR) bfd_malloc (amt);
   if (x_fxdhdr == NULL)
     goto got_no_match;
 
-  if (bfd_read ((PTR) x_fxdhdr, nlm_fixed_header_size (abfd), 1, abfd) !=
-      nlm_fixed_header_size (abfd))
+  if (bfd_bread ((PTR) x_fxdhdr, amt, abfd) != amt)
     {
       if (bfd_get_error () != bfd_error_system_call)
@@ -129 +130 @@
   /* Allocate an instance of the nlm_obj_tdata structure and hook it up to
      the tdata pointer in the bfd.  */
-
-  new_tdata = ((struct nlm_obj_tdata *)
-               bfd_zalloc (abfd, sizeof (struct nlm_obj_tdata)));
+  amt = sizeof (struct nlm_obj_tdata);
+  new_tdata = (struct nlm_obj_tdata *) bfd_zalloc (abfd, amt);
   if (new_tdata == NULL)
     goto got_no_match;
@@ -144 +144 @@
   /* Check to see if we have an NLM file for this backend by matching
      the NLM signature.  */
-
   signature = nlm_signature (abfd);
   if (signature != NULL
@@ -154 +153 @@
   /* There's no supported way to discover the endianess of an NLM, so test for
      a sane version number after doing byte swapping appropriate for this
-     XVEC.  (Hack alert!) */
-
+     XVEC.  (Hack alert!)  */
   if (i_fxdhdrp->version > 0xFFFF)
     goto got_wrong_format_error;
@@ -161 +159 @@
   /* There's no supported way to check for 32 bit versus 64 bit addresses,
      so ignore this distinction for now.  (FIXME) */
-
   /* Swap in the rest of the required header.  */
   if (!nlm_swap_variable_header_in (abfd))
@@ -176 +173 @@
      From this point on we assume that we have an NLM, and do not
      treat errors as indicating the wrong format.  */
-
   if (!add_bfd_section (abfd, NLM_CODE_NAME,
                         i_fxdhdrp->codeImageOffset,
@@ -226 +222 @@
 /* Add a section to the bfd.  */
 
-static boolean
+static bfd_boolean
 add_bfd_section (abfd, name, offset, size, flags)
      bfd *abfd;
@@ -238 +234 @@
   newsect = bfd_make_section (abfd, name);
   if (newsect == NULL)
-    {
-      return (false);
-    }
+    return FALSE;
+
   newsect->vma = 0;             /* NLM's are relocatable.  */
   newsect->_raw_size = size;
   newsect->filepos = offset;
   newsect->flags = flags;
-  newsect->alignment_power = bfd_log2 (0);      /* FIXME */
-  return (true);
+  newsect->alignment_power = bfd_log2 ((bfd_vma) 0);    /* FIXME */
+
+  return TRUE;
 }
 
@@ -252 +248 @@
    exist in the NLM, and must exist in the order they are read here.  */
 
-static boolean
+static bfd_boolean
 nlm_swap_variable_header_in (abfd)
      bfd *abfd;
 {
   unsigned char temp[NLM_TARGET_LONG_SIZE];
+  bfd_size_type amt;
 
   /* Read the description length and text members.  */
 
-  if (bfd_read ((PTR) & nlm_variable_header (abfd)->descriptionLength,
-                sizeof (nlm_variable_header (abfd)->descriptionLength),
-                1, abfd) !=
-      sizeof (nlm_variable_header (abfd)->descriptionLength))
-    return (false);
-  if (bfd_read ((PTR) nlm_variable_header (abfd)->descriptionText,
-                nlm_variable_header (abfd)->descriptionLength + 1,
-                1, abfd) !=
-      (bfd_size_type) nlm_variable_header (abfd)->descriptionLength + 1)
-    return (false);
+  amt = sizeof (nlm_variable_header (abfd)->descriptionLength);
+  if (bfd_bread ((PTR) &nlm_variable_header (abfd)->descriptionLength,
+                amt, abfd) != amt)
+    return FALSE;
+  amt = nlm_variable_header (abfd)->descriptionLength + 1;
+  if (bfd_bread ((PTR) nlm_variable_header (abfd)->descriptionText,
+                amt, abfd) != amt)
+    return FALSE;
 
   /* Read and convert the stackSize field.  */
 
-  if (bfd_read ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp))
-    return (false);
+  amt = sizeof (temp);
+  if (bfd_bread ((PTR) temp, amt, abfd) != amt)
+    return FALSE;
   nlm_variable_header (abfd)->stackSize = get_word (abfd, (bfd_byte *) temp);
 
   /* Read and convert the reserved field.  */
 
-  if (bfd_read ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp))
-    return (false);
+  amt = sizeof (temp);
+  if (bfd_bread ((PTR) temp, amt, abfd) != amt)
+    return FALSE;
   nlm_variable_header (abfd)->reserved = get_word (abfd, (bfd_byte *) temp);
 
   /* Read the oldThreadName field.  This field is a fixed length string.  */
 
-  if (bfd_read ((PTR) nlm_variable_header (abfd)->oldThreadName,
-                sizeof (nlm_variable_header (abfd)->oldThreadName),
-                1, abfd) !=
-      sizeof (nlm_variable_header (abfd)->oldThreadName))
-    return (false);
+  amt = sizeof (nlm_variable_header (abfd)->oldThreadName);
+  if (bfd_bread ((PTR) nlm_variable_header (abfd)->oldThreadName,
+                amt, abfd) != amt)
+    return FALSE;
 
   /* Read the screen name length and text members.  */
 
-  if (bfd_read ((PTR) & nlm_variable_header (abfd)->screenNameLength,
-                sizeof (nlm_variable_header (abfd)->screenNameLength),
-                1, abfd) !=
-      sizeof (nlm_variable_header (abfd)->screenNameLength))
-    return (false);
-  if (bfd_read ((PTR) nlm_variable_header (abfd)->screenName,
-                nlm_variable_header (abfd)->screenNameLength + 1,
-                1, abfd) !=
-      (bfd_size_type) nlm_variable_header (abfd)->screenNameLength + 1)
-    return (false);
+  amt = sizeof (nlm_variable_header (abfd)->screenNameLength);
+  if (bfd_bread ((PTR) & nlm_variable_header (abfd)->screenNameLength,
+                amt, abfd) != amt)
+    return FALSE;
+  amt = nlm_variable_header (abfd)->screenNameLength + 1;
+  if (bfd_bread ((PTR) nlm_variable_header (abfd)->screenName,
+                amt, abfd) != amt)
+    return FALSE;
 
   /* Read the thread name length and text members.  */
 
-  if (bfd_read ((PTR) & nlm_variable_header (abfd)->threadNameLength,
-                sizeof (nlm_variable_header (abfd)->threadNameLength),
-                1, abfd) !=
-      sizeof (nlm_variable_header (abfd)->threadNameLength))
-    return (false);
-  if (bfd_read ((PTR) nlm_variable_header (abfd)->threadName,
-                nlm_variable_header (abfd)->threadNameLength + 1,
-                1, abfd) !=
-      (bfd_size_type) nlm_variable_header (abfd)->threadNameLength + 1)
-    return (false);
-  return (true);
+  amt = sizeof (nlm_variable_header (abfd)->threadNameLength);
+  if (bfd_bread ((PTR) & nlm_variable_header (abfd)->threadNameLength,
+                amt, abfd) != amt)
+    return FALSE;
+  amt = nlm_variable_header (abfd)->threadNameLength + 1;
+  if (bfd_bread ((PTR) nlm_variable_header (abfd)->threadName,
+                amt, abfd) != amt)
+    return FALSE;
+  return TRUE;
 }
 
@@ -322 +314 @@
    exist in the NLM, and must exist in this order.  */
 
-static boolean
+static bfd_boolean
 nlm_swap_variable_header_out (abfd)
      bfd *abfd;
 {
   unsigned char temp[NLM_TARGET_LONG_SIZE];
+  bfd_size_type amt;
 
   /* Write the description length and text members.  */
-
-  if (bfd_write ((PTR) & nlm_variable_header (abfd)->descriptionLength,
-                 sizeof (nlm_variable_header (abfd)->descriptionLength),
-                 1, abfd) !=
-      sizeof (nlm_variable_header (abfd)->descriptionLength))
-    return (false);
-  if (bfd_write ((PTR) nlm_variable_header (abfd)->descriptionText,
-                 nlm_variable_header (abfd)->descriptionLength + 1,
-                 1, abfd) !=
-      (bfd_size_type) nlm_variable_header (abfd)->descriptionLength + 1)
-    return (false);
+  amt = sizeof (nlm_variable_header (abfd)->descriptionLength);
+  if (bfd_bwrite ((PTR) & nlm_variable_header (abfd)->descriptionLength, amt,
+                 abfd) != amt)
+    return FALSE;
+  amt = nlm_variable_header (abfd)->descriptionLength + 1;
+  if (bfd_bwrite ((PTR) nlm_variable_header (abfd)->descriptionText, amt,
+                 abfd) != amt)
+    return FALSE;
 
   /* Convert and write the stackSize field.  */
-
   put_word (abfd, (bfd_vma) nlm_variable_header (abfd)->stackSize,
             (bfd_byte *) temp);
-  if (bfd_write ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp))
-    return (false);
+  amt = sizeof (temp);
+  if (bfd_bwrite ((PTR) temp, amt, abfd) != amt)
+    return FALSE;
 
   /* Convert and write the reserved field.  */
-
   put_word (abfd, (bfd_vma) nlm_variable_header (abfd)->reserved,
             (bfd_byte *) temp);
-  if (bfd_write ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp))
-    return (false);
+  amt = sizeof (temp);
+  if (bfd_bwrite ((PTR) temp, amt, abfd) != amt)
+    return FALSE;
 
   /* Write the oldThreadName field.  This field is a fixed length string.  */
-
-  if (bfd_write ((PTR) nlm_variable_header (abfd)->oldThreadName,
-                 sizeof (nlm_variable_header (abfd)->oldThreadName),
-                 1, abfd) !=
-      sizeof (nlm_variable_header (abfd)->oldThreadName))
-    return (false);
+  amt = sizeof (nlm_variable_header (abfd)->oldThreadName);
+  if (bfd_bwrite ((PTR) nlm_variable_header (abfd)->oldThreadName, amt,
+                 abfd) != amt)
+    return FALSE;
 
   /* Write the screen name length and text members.  */
-
-  if (bfd_write ((PTR) & nlm_variable_header (abfd)->screenNameLength,
-                 sizeof (nlm_variable_header (abfd)->screenNameLength),
-                 1, abfd) !=
-      sizeof (nlm_variable_header (abfd)->screenNameLength))
-    return (false);
-  if (bfd_write ((PTR) nlm_variable_header (abfd)->screenName,
-                 nlm_variable_header (abfd)->screenNameLength + 1,
-                 1, abfd) !=
-      (bfd_size_type) nlm_variable_header (abfd)->screenNameLength + 1)
-    return (false);
+  amt = sizeof (nlm_variable_header (abfd)->screenNameLength);
+  if (bfd_bwrite ((PTR) & nlm_variable_header (abfd)->screenNameLength, amt,
+                 abfd) != amt)
+    return FALSE;
+  amt = nlm_variable_header (abfd)->screenNameLength + 1;
+  if (bfd_bwrite ((PTR) nlm_variable_header (abfd)->screenName, amt,
+                 abfd) != amt)
+    return FALSE;
 
   /* Write the thread name length and text members.  */
-
-  if (bfd_write ((PTR) & nlm_variable_header (abfd)->threadNameLength,
-                 sizeof (nlm_variable_header (abfd)->threadNameLength),
-                 1, abfd) !=
-      sizeof (nlm_variable_header (abfd)->threadNameLength))
-    return (false);
-  if (bfd_write ((PTR) nlm_variable_header (abfd)->threadName,
-                 nlm_variable_header (abfd)->threadNameLength + 1,
-                 1, abfd) !=
-      (bfd_size_type) nlm_variable_header (abfd)->threadNameLength + 1)
-    return (false);
-  return (true);
+  amt = sizeof (nlm_variable_header (abfd)->threadNameLength);
+  if (bfd_bwrite ((PTR) & nlm_variable_header (abfd)->threadNameLength, amt,
+                 abfd) != amt)
+    return FALSE;
+  amt = nlm_variable_header (abfd)->threadNameLength + 1;
+  if (bfd_bwrite ((PTR) nlm_variable_header (abfd)->threadName, amt,
+                 abfd) != amt)
+    return FALSE;
+  return TRUE;
 }
 
@@ -400 +382 @@
    recognize it.  */
 
-static boolean
+static bfd_boolean
 nlm_swap_auxiliary_headers_in (abfd)
      bfd *abfd;
 {
   char tempstr[16];
-  long position;
+  file_ptr position;
+  bfd_size_type amt;
 
   for (;;)
     {
       position = bfd_tell (abfd);
-      if (bfd_read ((PTR) tempstr, sizeof (tempstr), 1, abfd) !=
-          sizeof (tempstr))
-        return (false);
-      if (bfd_seek (abfd, position, SEEK_SET) == -1)
-        return (false);
+      amt = sizeof (tempstr);
+      if (bfd_bread ((PTR) tempstr, amt, abfd) != amt)
+        return FALSE;
+      if (bfd_seek (abfd, position, SEEK_SET) != 0)
+        return FALSE;
       if (strncmp (tempstr, "VeRsIoN#", 8) == 0)
         {
           Nlm_External_Version_Header thdr;
-          if (bfd_read ((PTR) & thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
-            return (false);
+
+          amt = sizeof (thdr);
+          if (bfd_bread ((PTR) &thdr, amt, abfd) != amt)
+            return FALSE;
           memcpy (nlm_version_header (abfd)->stamp, thdr.stamp,
                   sizeof (thdr.stamp));
@@ -438 +423 @@
         {
           Nlm_External_Extended_Header thdr;
-          if (bfd_read ((PTR) & thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
-            return (false);
+
+          amt = sizeof (thdr);
+          if (bfd_bread ((PTR) &thdr, amt, abfd) != amt)
+            return FALSE;
           memcpy (nlm_extended_header (abfd)->stamp, thdr.stamp,
                   sizeof (thdr.stamp));
@@ -503 +490 @@
       else if (strncmp (tempstr, "CoPyRiGhT=", 10) == 0)
         {
-          if (bfd_read ((PTR) nlm_copyright_header (abfd)->stamp,
-                        sizeof (nlm_copyright_header (abfd)->stamp),
-                        1, abfd)
-              != sizeof (nlm_copyright_header (abfd)->stamp))
-            return (false);
-          if (bfd_read ((PTR) & (nlm_copyright_header (abfd)
-                                 ->copyrightMessageLength),
-                        1, 1, abfd) != 1)
-            return (false);
+          amt = sizeof (nlm_copyright_header (abfd)->stamp);
+          if (bfd_bread ((PTR) nlm_copyright_header (abfd)->stamp,
+                        amt, abfd) != amt)
+            return FALSE;
+          if (bfd_bread ((PTR) &(nlm_copyright_header (abfd)
+                                ->copyrightMessageLength),
+                        (bfd_size_type) 1, abfd) != 1)
+            return FALSE;
           /* The copyright message is a variable length string.  */
-          if (bfd_read ((PTR) nlm_copyright_header (abfd)->copyrightMessage,
-                    nlm_copyright_header (abfd)->copyrightMessageLength + 1,
-                        1, abfd) !=
-              ((bfd_size_type)
-               nlm_copyright_header (abfd)->copyrightMessageLength + 1))
-            return (false);
+          amt = nlm_copyright_header (abfd)->copyrightMessageLength + 1;
+          if (bfd_bread ((PTR) nlm_copyright_header (abfd)->copyrightMessage,
+                        amt, abfd) != amt)
+            return FALSE;
         }
       else if (strncmp (tempstr, "CuStHeAd", 8) == 0)
@@ -530 +514 @@
 
           /* Read the stamp ("CuStHeAd").  */
-          if (bfd_read ((PTR) thdr.stamp, 1, sizeof (thdr.stamp), abfd)
-              != sizeof (thdr.stamp))
-            return false;
+          amt = sizeof (thdr.stamp);
+          if (bfd_bread ((PTR) thdr.stamp, amt, abfd) != amt)
+            return FALSE;
           /* Read the length of this custom header.  */
-          if (bfd_read ((PTR) thdr.length, 1, sizeof (thdr.length), abfd)
-              != sizeof (thdr.length))
-            return false;
+          amt = sizeof (thdr.length);
+          if (bfd_bread ((PTR) thdr.length, amt, abfd) != amt)
+            return FALSE;
           hdrLength = get_word (abfd, (bfd_byte *) thdr.length);
           /* Read further fields if we have them.  */
@@ -543 +527 @@
           else
             {
-              if (bfd_read ((PTR) thdr.dataOffset, 1,
-                            sizeof (thdr.dataOffset), abfd)
-                  != sizeof (thdr.dataOffset))
-                return false;
+              amt = sizeof (thdr.dataOffset);
+              if (bfd_bread ((PTR) thdr.dataOffset, amt, abfd) != amt)
+                return FALSE;
               dataOffset = get_word (abfd, (bfd_byte *) thdr.dataOffset);
             }
@@ -553 +536 @@
           else
             {
-              if (bfd_read ((PTR) thdr.dataLength, 1,
-                            sizeof (thdr.dataLength), abfd)
-                  != sizeof (thdr.dataLength))
-                return false;
+              amt = sizeof (thdr.dataLength);
+              if (bfd_bread ((PTR) thdr.dataLength, amt, abfd) != amt)
+                return FALSE;
               dataLength = get_word (abfd, (bfd_byte *) thdr.dataLength);
             }
@@ -563 +545 @@
           else
             {
-              if (bfd_read ((PTR) dataStamp, 1, sizeof (dataStamp), abfd)
-                  != sizeof (dataStamp))
-                return false;
+              amt = sizeof (dataStamp);
+              if (bfd_bread ((PTR) dataStamp, amt, abfd) != amt)
+                return FALSE;
             }
 
@@ -579 +561 @@
               hdr = bfd_alloc (abfd, hdrLength);
               if (hdr == NULL)
-                return false;
-              if (bfd_read (hdr, 1, hdrLength, abfd) != hdrLength)
-                return false;
+                return FALSE;
+              if (bfd_bread (hdr, hdrLength, abfd) != hdrLength)
+                return FALSE;
             }
 
@@ -597 +579 @@
               pos = bfd_tell (abfd);
               if (bfd_seek (abfd, dataOffset, SEEK_SET) != 0)
-                return false;
+                return FALSE;
               contents = (bfd_byte *) bfd_alloc (abfd, dataLength);
               if (contents == NULL)
-                return false;
-              if (bfd_read (contents, 1, dataLength, abfd) != dataLength)
-                return false;
+                return FALSE;
+              if (bfd_bread (contents, dataLength, abfd) != dataLength)
+                return FALSE;
               if (bfd_seek (abfd, pos, SEEK_SET) != 0)
-                return false;
+                return FALSE;
 
               memcpy (nlm_cygnus_ext_header (abfd), "CyGnUsEx", 8);
@@ -639 +621 @@
                   name = (char *) p;
                   l = strlen (name) + 1;
-                  l = (l + 3) &~ 3;
+                  l = (l + 3) &~ (size_t) 3;
                   p += l;
-                  filepos = bfd_h_get_32 (abfd, p);
+                  filepos = H_GET_32 (abfd, p);
                   p += 4;
-                  size = bfd_h_get_32 (abfd, p);
+                  size = H_GET_32 (abfd, p);
                   p += 4;
 
                   newsec = bfd_make_section_anyway (abfd, name);
                   if (newsec == (asection *) NULL)
-                    return false;
+                    return FALSE;
                   newsec->_raw_size = size;
                   if (filepos != 0)
@@ -670 +652 @@
         }
       else
-        {
-          break;
-        }
-    }
-  return (true);
+        break;
+    }
+  return TRUE;
 }
 
 /* Return whether there is a non-zero byte in a memory block.  */
 
-static boolean
+static bfd_boolean
 find_nonzero (buf, size)
      PTR buf;
@@ -688 +668 @@
   while (size-- != 0)
     if (*p++ != 0)
-      return true;
-  return false;
+      return TRUE;
+  return FALSE;
 }
 
@@ -696 +676 @@
    the caller to set up the stamp fields.  */
 
-static boolean
+static bfd_boolean
 nlm_swap_auxiliary_headers_out (abfd)
      bfd *abfd;
 {
+  bfd_size_type amt;
+
   /* Write out the version header if there is one.  */
   if (find_nonzero ((PTR) nlm_version_header (abfd),
@@ -719 +701 @@
       put_word (abfd, (bfd_vma) nlm_version_header (abfd)->day,
                 (bfd_byte *) thdr.day);
-      if (bfd_write ((PTR) & thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
-        return false;
+      if (bfd_bwrite ((PTR) &thdr, (bfd_size_type) sizeof (thdr), abfd)
+          != sizeof (thdr))
+        return FALSE;
+    }
+
+  /* Note - the CoPyRiGhT tag is emitted before the MeSsAgEs
+     tag in order to make the NW4.x and NW5.x loaders happy.  */
+
+  /* Write out the copyright header if there is one.  */
+  if (find_nonzero ((PTR) nlm_copyright_header (abfd),
+                    sizeof (Nlm_Internal_Copyright_Header)))
+    {
+      Nlm_External_Copyright_Header thdr;
+
+      memcpy (thdr.stamp, "CoPyRiGhT=", 10);
+      amt = sizeof (thdr.stamp);
+      if (bfd_bwrite ((PTR) thdr.stamp, amt, abfd) != amt)
+        return FALSE;
+      thdr.copyrightMessageLength[0] =
+        nlm_copyright_header (abfd)->copyrightMessageLength;
+      amt = 1;
+      if (bfd_bwrite ((PTR) thdr.copyrightMessageLength, amt, abfd) != amt)
+        return FALSE;
+      /* The copyright message is a variable length string.  */
+      amt = nlm_copyright_header (abfd)->copyrightMessageLength + 1;
+      if (bfd_bwrite ((PTR) nlm_copyright_header (abfd)->copyrightMessage,
+                     amt, abfd) != amt)
+        return FALSE;
     }
 
@@ -817 +825 @@
                 (bfd_vma) nlm_extended_header (abfd)->reserved5,
                 (bfd_byte *) thdr.reserved5);
-      if (bfd_write ((PTR) & thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
-        return false;
-    }
-
-  /* Write out the copyright header if there is one.  */
-  if (find_nonzero ((PTR) nlm_copyright_header (abfd),
-                    sizeof (Nlm_Internal_Copyright_Header)))
-    {
-      Nlm_External_Copyright_Header thdr;
-
-      memcpy (thdr.stamp, "CoPyRiGhT=", 10);
-      if (bfd_write ((PTR) thdr.stamp, sizeof (thdr.stamp), 1, abfd)
-          != sizeof (thdr.stamp))
-        return false;
-      thdr.copyrightMessageLength[0] =
-        nlm_copyright_header (abfd)->copyrightMessageLength;
-      if (bfd_write ((PTR) thdr.copyrightMessageLength, 1, 1, abfd) != 1)
-        return false;
-      /* The copyright message is a variable length string.  */
-      if (bfd_write ((PTR) nlm_copyright_header (abfd)->copyrightMessage,
-                     nlm_copyright_header (abfd)->copyrightMessageLength + 1,
-                     1, abfd) !=
-          ((bfd_size_type)
-           nlm_copyright_header (abfd)->copyrightMessageLength + 1))
-        return false;
+      if (bfd_bwrite ((PTR) &thdr, (bfd_size_type) sizeof (thdr), abfd)
+          != sizeof (thdr))
+        return FALSE;
     }
 
@@ -849 +835 @@
     {
       Nlm_External_Custom_Header thdr;
-      boolean ds;
+      bfd_boolean ds;
       bfd_size_type hdrLength;
 
@@ -865 +851 @@
         {
           BFD_ASSERT (nlm_custom_header (abfd)->hdrLength == 0);
-          if (bfd_write ((PTR) &thdr, 1,
-                         sizeof (thdr) - sizeof (thdr.dataStamp), abfd)
-              != sizeof (thdr) - sizeof (thdr.dataStamp))
-            return false;
+          amt = sizeof (thdr) - sizeof (thdr.dataStamp);
+          if (bfd_bwrite ((PTR) &thdr, amt, abfd) != amt)
+            return FALSE;
         }
       else
@@ -874 +859 @@
           memcpy (thdr.dataStamp, nlm_custom_header (abfd)->dataStamp,
                   sizeof (thdr.dataStamp));
-          if (bfd_write ((PTR) &thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
-            return false;
-          if (bfd_write (nlm_custom_header (abfd)->hdr, 1,
-                         nlm_custom_header (abfd)->hdrLength, abfd)
-              != nlm_custom_header (abfd)->hdrLength)
-            return false;
+          amt = sizeof (thdr);
+          if (bfd_bwrite ((PTR) &thdr, amt, abfd) != amt)
+            return FALSE;
+          amt = nlm_custom_header (abfd)->hdrLength;
+          if (bfd_bwrite (nlm_custom_header (abfd)->hdr, amt, abfd) != amt)
+            return FALSE;
         }
     }
@@ -897 +882 @@
                 (bfd_byte *) thdr.dataLength);
       memcpy (thdr.dataStamp, "CyGnUsEx", 8);
-      if (bfd_write ((PTR) &thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
-        return false;
-    }
-
-  return true;
+      amt = sizeof (thdr);
+      if (bfd_bwrite ((PTR) &thdr, amt, abfd) != amt)
+        return FALSE;
+    }
+
+  return TRUE;
 }
 
@@ -917 +903 @@
      bfd *abfd;
 {
-  Nlm_Internal_Fixed_Header *i_fxdhdrp; /* Nlm file header, internal form */
+  Nlm_Internal_Fixed_Header *i_fxdhdrp; /* Nlm file header, internal form.  */
   long symcount;
   long symtab_size = 0;
@@ -940 +926 @@
   bfd_size_type counter = 0;
 
-  if (nlm_slurp_symbol_table (abfd) == false)
+  if (! nlm_slurp_symbol_table (abfd))
     return -1;
   symbase = nlm_get_symbols (abfd);
@@ -959 +945 @@
      bfd *abfd;
 {
-  nlm_symbol_type *new;
-
-  new = (nlm_symbol_type *) bfd_zalloc (abfd, sizeof (nlm_symbol_type));
+  bfd_size_type amt = sizeof (nlm_symbol_type);
+  nlm_symbol_type *new = (nlm_symbol_type *) bfd_zalloc (abfd, amt);
+
   if (new)
     new->symbol.the_bfd = abfd;
@@ -982 +968 @@
 void
 nlm_print_symbol (abfd, afile, symbol, how)
-     bfd *abfd ATTRIBUTE_UNUSED;
+     bfd *abfd;
      PTR afile;
      asymbol *symbol;
@@ -997 +983 @@
       break;
     case bfd_print_symbol_all:
-      bfd_print_symbol_vandf ((PTR) file, symbol);
+      bfd_print_symbol_vandf (abfd, (PTR) file, symbol);
       fprintf (file, " %-5s", symbol->section->name);
       if (symbol->name)
@@ -1022 +1008 @@
 
    When we return, the bfd symcount is either zero or contains the correct
-   number of symbols.
-*/
-
-static boolean
+   number of symbols.  */
+
+static bfd_boolean
 nlm_slurp_symbol_table (abfd)
      bfd *abfd;
 {
-  Nlm_Internal_Fixed_Header *i_fxdhdrp; /* Nlm file header, internal form */
-  bfd_size_type totsymcount;    /* Number of NLM symbols */
-  bfd_size_type symcount;       /* Counter of NLM symbols */
-  nlm_symbol_type *sym;         /* Pointer to current bfd symbol */
-  unsigned char symlength;      /* Symbol length read into here */
-  unsigned char symtype;        /* Type of debugging symbol */
-  bfd_byte temp[NLM_TARGET_LONG_SIZE];  /* Symbol offsets read into here */
-  boolean (*read_import_func) PARAMS ((bfd *, nlm_symbol_type *));
-  boolean (*set_public_section_func) PARAMS ((bfd *, nlm_symbol_type *));
+  Nlm_Internal_Fixed_Header *i_fxdhdrp; /* Nlm file header, internal form.  */
+  bfd_size_type totsymcount;    /* Number of NLM symbols.  */
+  bfd_size_type symcount;       /* Counter of NLM symbols.  */
+  nlm_symbol_type *sym;         /* Pointer to current bfd symbol.  */
+  unsigned char symlength;      /* Symbol length read into here.  */
+  unsigned char symtype;        /* Type of debugging symbol.  */
+  bfd_byte temp[NLM_TARGET_LONG_SIZE];  /* Symbol offsets read into here.  */
+  bfd_boolean (*read_import_func) PARAMS ((bfd *, nlm_symbol_type *));
+  bfd_boolean (*set_public_section_func) PARAMS ((bfd *, nlm_symbol_type *));
+  bfd_size_type amt;
 
   if (nlm_get_symbols (abfd) != NULL)
-    return (true);
+    return TRUE;
 
   /* Read each raw NLM symbol, using the information to create a canonical bfd
@@ -1056 +1042 @@
                  + i_fxdhdrp->numberOfExternalReferences);
   if (totsymcount == 0)
-    {
-      return (true);
-    }
-
-  if (bfd_seek (abfd, i_fxdhdrp->publicsOffset, SEEK_SET) == -1)
-    return (false);
-
-  sym = ((nlm_symbol_type *)
-         bfd_zalloc (abfd, totsymcount * sizeof (nlm_symbol_type)));
+    return TRUE;
+
+  if (bfd_seek (abfd, i_fxdhdrp->publicsOffset, SEEK_SET) != 0)
+    return FALSE;
+
+  amt = totsymcount * sizeof (nlm_symbol_type);
+  sym = ((nlm_symbol_type *) bfd_zalloc (abfd, amt));
   if (!sym)
-    return false;
+    return FALSE;
   nlm_set_symbols (abfd, sym);
 
@@ -1077 +1061 @@
   while (abfd->symcount < symcount)
     {
-      if (bfd_read ((PTR) & symlength, sizeof (symlength), 1, abfd)
-          != sizeof (symlength))
-        return (false);
+      amt = sizeof (symlength);
+      if (bfd_bread ((PTR) &symlength, amt, abfd) != amt)
+        return FALSE;
+      amt = symlength;
       sym->symbol.the_bfd = abfd;
-      sym->symbol.name = bfd_alloc (abfd, symlength + 1);
+      sym->symbol.name = bfd_alloc (abfd, amt + 1);
       if (!sym->symbol.name)
-        return false;
-      if (bfd_read ((PTR) sym->symbol.name, symlength, 1, abfd)
-          != symlength)
-        return (false);
+        return FALSE;
+      if (bfd_bread ((PTR) sym->symbol.name, amt, abfd) != amt)
+        return FALSE;
       /* Cast away const.  */
       ((char *) (sym->symbol.name))[symlength] = '\0';
-      if (bfd_read ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp))
-        return (false);
+      amt = sizeof (temp);
+      if (bfd_bread ((PTR) temp, amt, abfd) != amt)
+        return FALSE;
       sym->symbol.flags = BSF_GLOBAL | BSF_EXPORT;
       sym->symbol.value = get_word (abfd, temp);
@@ -1097 +1082 @@
           /* Most backends can use the code below, but unfortunately
              some use a different scheme.  */
-          if ((*set_public_section_func) (abfd, sym) == false)
-            return false;
+          if (! (*set_public_section_func) (abfd, sym))
+            return FALSE;
         }
       else
@@ -1124 +1109 @@
   if (i_fxdhdrp->numberOfDebugRecords > 0)
     {
-      if (bfd_seek (abfd, i_fxdhdrp->debugInfoOffset, SEEK_SET) == -1)
-        return (false);
+      if (bfd_seek (abfd, i_fxdhdrp->debugInfoOffset, SEEK_SET) != 0)
+        return FALSE;
 
       symcount += i_fxdhdrp->numberOfDebugRecords;
       while (abfd->symcount < symcount)
         {
-          if ((bfd_read ((PTR) & symtype, sizeof (symtype), 1, abfd)
-               != sizeof (symtype))
-           || bfd_read ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp)
-              || (bfd_read ((PTR) & symlength, sizeof (symlength), 1, abfd)
-                  != sizeof (symlength)))
-            return false;
+          amt = sizeof (symtype);
+          if (bfd_bread ((PTR) &symtype, amt, abfd) != amt)
+            return FALSE;
+          amt = sizeof (temp);
+          if (bfd_bread ((PTR) temp, amt, abfd) != amt)
+            return FALSE;
+          amt = sizeof (symlength);
+          if (bfd_bread ((PTR) &symlength, amt, abfd) != amt)
+            return FALSE;
+          amt = symlength;
           sym->symbol.the_bfd = abfd;
-          sym->symbol.name = bfd_alloc (abfd, symlength + 1);
+          sym->symbol.name = bfd_alloc (abfd, amt + 1);
           if (!sym->symbol.name)
-            return false;
-          if (bfd_read ((PTR) sym->symbol.name, symlength, 1, abfd)
-              != symlength)
-            return (false);
+            return FALSE;
+          if (bfd_bread ((PTR) sym->symbol.name, amt, abfd) != amt)
+            return FALSE;
           /* Cast away const.  */
           ((char *) (sym->symbol.name))[symlength] = '\0';
@@ -1170 +1158 @@
   /* Read in the import records.  We can only do this if we know how
      to read relocs for this target.  */
-
   read_import_func = nlm_read_import_func (abfd);
   if (read_import_func != NULL)
     {
-      if (bfd_seek (abfd, i_fxdhdrp->externalReferencesOffset, SEEK_SET)
-          == -1)
-        return (false);
+      if (bfd_seek (abfd, i_fxdhdrp->externalReferencesOffset, SEEK_SET) != 0)
+        return FALSE;
 
       symcount += i_fxdhdrp->numberOfExternalReferences;
       while (abfd->symcount < symcount)
         {
-          if ((*read_import_func) (abfd, sym) == false)
-            return false;
+          if (! (*read_import_func) (abfd, sym))
+            return FALSE;
           sym++;
           abfd->symcount++;
@@ -1188 +1174 @@
     }
 
-  return (true);
+  return TRUE;
 }
 
@@ -1205 +1191 @@
    section.  */
 
-static boolean
+static bfd_boolean
 nlm_slurp_reloc_fixups (abfd)
      bfd *abfd;
 {
-  boolean (*read_func) PARAMS ((bfd *, nlm_symbol_type *, asection **,
-                                arelent *));
-  bfd_size_type count;
+  bfd_boolean (*read_func)
+    PARAMS ((bfd *, nlm_symbol_type *, asection **, arelent *));
+  bfd_size_type count, amt;
   arelent *rels;
   asection **secs;
 
   if (nlm_relocation_fixups (abfd) != NULL)
-    return true;
+    return TRUE;
   read_func = nlm_read_reloc_func (abfd);
   if (read_func == NULL)
-    return true;
+    return TRUE;
 
   if (bfd_seek (abfd, nlm_fixed_header (abfd)->relocationFixupOffset,
                 SEEK_SET) != 0)
-    return false;
+    return FALSE;
 
   count = nlm_fixed_header (abfd)->numberOfRelocationFixups;
-  rels = (arelent *) bfd_alloc (abfd, count * sizeof (arelent));
-  secs = (asection **) bfd_alloc (abfd, count * sizeof (asection *));
+  amt = count * sizeof (arelent);
+  rels = (arelent *) bfd_alloc (abfd, amt);
+  amt = count * sizeof (asection *);
+  secs = (asection **) bfd_alloc (abfd, amt);
   if ((rels == NULL || secs == NULL) && count != 0)
-    return false;
+    return FALSE;
   nlm_relocation_fixups (abfd) = rels;
   nlm_relocation_fixup_secs (abfd) = secs;
@@ -1237 +1225 @@
   while (count-- != 0)
     {
-      if ((*read_func) (abfd, (nlm_symbol_type *) NULL, secs, rels) == false)
+      if (! (*read_func) (abfd, (nlm_symbol_type *) NULL, secs, rels))
         {
           nlm_relocation_fixups (abfd) = NULL;
           nlm_relocation_fixup_secs (abfd) = NULL;
-          return false;
+          return FALSE;
         }
       ++secs;
@@ -1247 +1235 @@
     }
 
-  return true;
+  return TRUE;
 }
 
@@ -1273 +1261 @@
   if (syms == NULL)
     {
-      if (nlm_slurp_symbol_table (abfd) == false)
+      if (! nlm_slurp_symbol_table (abfd))
         return -1;
       syms = nlm_get_symbols (abfd);
@@ -1308 +1296 @@
   if (rels == NULL)
     {
-      if (nlm_slurp_reloc_fixups (abfd) == false)
+      if (! nlm_slurp_reloc_fixups (abfd))
         return -1;
       rels = nlm_relocation_fixups (abfd);
@@ -1373 +1361 @@
    final values.  */
 
-static boolean
+static bfd_boolean
 nlm_compute_section_file_positions (abfd)
      bfd *abfd;
@@ -1386 +1374 @@
   asymbol **sym_ptr_ptr;
 
-  if (abfd->output_has_begun == true)
-    return true;
+  if (abfd->output_has_begun)
+    return TRUE;
 
   /* Make sure we have a section to hold uninitialized data.  */
@@ -1396 +1384 @@
                             (file_ptr) 0, (bfd_size_type) 0,
                             SEC_ALLOC))
-        return false;
+        return FALSE;
       bss_sec = bfd_get_section_by_name (abfd, NLM_UNINITIALIZED_DATA_NAME);
     }
 
-  abfd->output_has_begun = true;
+  abfd->output_has_begun = TRUE;
 
   /* The fixed header.  */
@@ -1571 +1559 @@
     }
 
-  return true;
+  return TRUE;
 }
 
@@ -1579 +1567 @@
    variable size header information must be known.  */
 
-boolean
+bfd_boolean
 nlm_set_section_contents (abfd, section, location, offset, count)
      bfd *abfd;
@@ -1587 +1575 @@
      bfd_size_type count;
 {
-  if (abfd->output_has_begun == false
-      && nlm_compute_section_file_positions (abfd) == false)
-    return false;
+  if (! abfd->output_has_begun
+      && ! nlm_compute_section_file_positions (abfd))
+    return FALSE;
 
   if (count == 0)
-    return true;
+    return TRUE;
 
   /* i386 NetWare has a very restricted set of relocs.  In order for
@@ -1600 +1588 @@
   if (section->reloc_count != 0)
     {
-      boolean (*mangle_relocs_func) PARAMS ((bfd *, asection *, PTR,
-                                             bfd_vma, bfd_size_type));
+      bfd_boolean (*mangle_relocs_func)
+        PARAMS ((bfd *, asection *, PTR, bfd_vma, bfd_size_type));
 
       mangle_relocs_func = nlm_mangle_relocs_func (abfd);
@@ -1608 +1596 @@
           if (!(*mangle_relocs_func) (abfd, section, location,
                                       (bfd_vma) offset, count))
-            return false;
-        }
-    }
-
-  if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) != 0
-      || bfd_write (location, 1, count, abfd) != count)
-    return false;
-
-  return true;
+            return FALSE;
+        }
+    }
+
+  if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
+      || bfd_bwrite (location, count, abfd) != count)
+    return FALSE;
+
+  return TRUE;
 }
 
@@ -1670 +1658 @@
    list of outsymbols.  */
 
-boolean
+bfd_boolean
 nlm_write_object_contents (abfd)
      bfd *abfd;
 {
   asection *sec;
-  boolean (*write_import_func) PARAMS ((bfd *, asection *, arelent *));
+  bfd_boolean (*write_import_func) PARAMS ((bfd *, asection *, arelent *));
   bfd_size_type external_reloc_count, internal_reloc_count, i, c;
   struct reloc_and_sec *external_relocs;
   asymbol **sym_ptr_ptr;
   file_ptr last;
-  boolean (*write_prefix_func) PARAMS ((bfd *));
+  bfd_boolean (*write_prefix_func) PARAMS ((bfd *));
   unsigned char *fixed_header = NULL;
+  file_ptr pos;
+  bfd_size_type amt;
 
   fixed_header = ((unsigned char *)
-                  bfd_malloc ((size_t) nlm_fixed_header_size (abfd)));
+                  bfd_malloc (nlm_fixed_header_size (abfd)));
   if (fixed_header == NULL)
     goto error_return;
 
-  if (abfd->output_has_begun == false
-      && nlm_compute_section_file_positions (abfd) == false)
+  if (! abfd->output_has_begun
+      && ! nlm_compute_section_file_positions (abfd))
     goto error_return;
 
   /* Write out the variable length headers.  */
-  if (bfd_seek (abfd,
-             nlm_optional_prefix_size (abfd) + nlm_fixed_header_size (abfd),
-                SEEK_SET) != 0)
+  pos = nlm_optional_prefix_size (abfd) + nlm_fixed_header_size (abfd);
+  if (bfd_seek (abfd, pos, SEEK_SET) != 0)
     goto error_return;
-  if (nlm_swap_variable_header_out (abfd) == false
-      || nlm_swap_auxiliary_headers_out (abfd) == false)
+  if (! nlm_swap_variable_header_out (abfd)
+      || ! nlm_swap_auxiliary_headers_out (abfd))
     {
       bfd_set_error (bfd_error_system_call);
@@ -1706 +1695 @@
   /* A weak check on whether the section file positions were
      reasonable.  */
-  if (bfd_tell (abfd) > nlm_fixed_header (abfd)->codeImageOffset)
+  if (bfd_tell (abfd) > (ufile_ptr) nlm_fixed_header (abfd)->codeImageOffset)
     {
       bfd_set_error (bfd_error_invalid_operation);
@@ -1759 +1748 @@
             {
               ++internal_reloc_count;
-              if ((*write_import_func) (abfd, sec, rel) == false)
+              if (! (*write_import_func) (abfd, sec, rel))
                 goto error_return;
             }
@@ -1772 +1761 @@
      symbol, so we must first gather together all the relocs against
      external symbols and sort them.  */
-  external_relocs =
-    (struct reloc_and_sec *) bfd_alloc (abfd,
-                                        (external_reloc_count
-                                         * sizeof (struct reloc_and_sec)));
+  amt = external_reloc_count * sizeof (struct reloc_and_sec);
+  external_relocs = (struct reloc_and_sec *) bfd_alloc (abfd, amt);
   if (external_relocs == (struct reloc_and_sec *) NULL)
     goto error_return;
@@ -1833 +1820 @@
         ++cnt;
 
-      if ((*nlm_write_external_func (abfd)) (abfd, cnt, sym,
-                                             &external_relocs[i])
-          == false)
+      if (! (*nlm_write_external_func (abfd)) (abfd, cnt, sym,
+                                               &external_relocs[i]))
         goto error_return;
 
@@ -1848 +1834 @@
     {
       bfd_vma (*get_public_offset_func) PARAMS ((bfd *, asymbol *));
-      boolean (*write_export_func) PARAMS ((bfd *, asymbol *, bfd_vma));
+      bfd_boolean (*write_export_func) PARAMS ((bfd *, asymbol *, bfd_vma));
 
       asymbol **sym_end;
@@ -1903 +1889 @@
           if (write_export_func)
             {
-              if ((*write_export_func) (abfd, sym, offset) == false)
+              if (! (*write_export_func) (abfd, sym, offset))
                 goto error_return;
             }
@@ -1909 +1895 @@
             {
               len = strlen (sym->name);
-              if ((bfd_write (&len, sizeof (bfd_byte), 1, abfd)
+              if ((bfd_bwrite (&len, (bfd_size_type) sizeof (bfd_byte), abfd)
                    != sizeof (bfd_byte))
-                  || bfd_write (sym->name, len, 1, abfd) != len)
+                  || bfd_bwrite (sym->name, (bfd_size_type) len, abfd) != len)
                 goto error_return;
 
               put_word (abfd, offset, temp);
-              if (bfd_write (temp, sizeof (temp), 1, abfd) != sizeof (temp))
+              if (bfd_bwrite (temp, (bfd_size_type) sizeof (temp), abfd)
+                  != sizeof (temp))
                 goto error_return;
             }
@@ -1974 +1961 @@
 
               /* The type is 0 for data, 1 for code, 2 for absolute.  */
-              if (bfd_write (&type, sizeof (bfd_byte), 1, abfd)
+              if (bfd_bwrite (&type, (bfd_size_type) sizeof (bfd_byte), abfd)
                   != sizeof (bfd_byte))
                 goto error_return;
 
               put_word (abfd, offset, temp);
-              if (bfd_write (temp, sizeof (temp), 1, abfd) != sizeof (temp))
+              if (bfd_bwrite (temp, (bfd_size_type) sizeof (temp), abfd)
+                  != sizeof (temp))
                 goto error_return;
 
               len = strlen (sym->name);
-              if ((bfd_write (&len, sizeof (bfd_byte), 1, abfd)
+              if ((bfd_bwrite (&len, (bfd_size_type) sizeof (bfd_byte), abfd)
                    != sizeof (bfd_byte))
-                  || bfd_write (sym->name, len, 1, abfd) != len)
+                  || bfd_bwrite (sym->name, (bfd_size_type) len, abfd) != len)
                 goto error_return;
             }
@@ -2029 +2017 @@
       nlm_get_text_low (abfd);
 
-  if (bfd_seek (abfd, 0, SEEK_SET) != 0)
+  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
     goto error_return;
 
@@ -2035 +2023 @@
   if (write_prefix_func)
     {
-      if ((*write_prefix_func) (abfd) == false)
+      if (! (*write_prefix_func) (abfd))
         goto error_return;
     }
@@ -2043 +2031 @@
 
   nlm_swap_fixed_header_out (abfd, nlm_fixed_header (abfd), fixed_header);
-  if (bfd_write (fixed_header, nlm_fixed_header_size (abfd), 1, abfd)
+  if (bfd_bwrite (fixed_header, nlm_fixed_header_size (abfd), abfd)
       != nlm_fixed_header_size (abfd))
     goto error_return;
@@ -2049 +2037 @@
   if (fixed_header != NULL)
     free (fixed_header);
-  return true;
+  return TRUE;
 
 error_return:
   if (fixed_header != NULL)
     free (fixed_header);
-  return false;
+  return FALSE;
 }