Touches most files in bfd/, so likely will be blamed for everything..

o  bfd_read and bfd_write lose an unnecessary param and become
   bfd_bread and bfd_bwrite.

o  bfd_*alloc now all take a bfd_size_type arg, and will error if
   size_t is too small.  eg. 32 bit host, 64 bit bfd, verrry big files
   or bugs in linker scripts etc.

o  file_ptr becomes a bfd_signed_vma.  Besides matching sizes with
   various other types involved in handling sections, this should make
   it easier for bfd to support a 64 bit off_t on 32 bit hosts that
   provide it.

o  I've made the H_GET_* and H_PUT_* macros (which invoke bfd_h_{get,put}_*)
   generally available.  They now cast their args to bfd_vma and
   bfd_byte * as appropriate, which removes a swag of casts from the
   source.

o  Bug fixes to bfd_get8, aix386_core_vec, elf32_h8_relax_section, and
   aout-encap.c.

o  Zillions of formatting and -Wconversion fixes.

1 files changed, 213 insertions, 209 deletions

diff --git a/bfd/nlmcode.h b/bfd/nlmcode.h
index 0dce943..d4501d0 100644
--- a/bfd/nlmcode.h
+++ b/bfd/nlmcode.h
@@ -1,5 +1,6 @@
 /* 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
+   Free Software Foundation, Inc.
 
    Written by Fred Fish @ Cygnus Support, using ELF support as the
    template.
@@ -82,12 +83,12 @@ static int nlm_external_reloc_compare
 /* Should perhaps use put_offset, put_word, etc.  For now, the two versions
    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
 
 const bfd_target *
@@ -101,6 +102,7 @@ nlm_object_p (abfd)
   struct nlm_obj_tdata *new_tdata = NULL;
   const char *signature;
   enum bfd_architecture arch;
+  bfd_size_type amt;
 
   /* Some NLM formats have a prefix before the standard NLM fixed
      header.  */
@@ -113,12 +115,12 @@ nlm_object_p (abfd)
 
   /* 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)
 	goto got_wrong_format_error;
@@ -129,8 +131,8 @@ nlm_object_p (abfd)
   /* 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;
 
@@ -238,14 +240,14 @@ add_bfd_section (abfd, name, offset, size, flags)
   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;
 }
 
 /* Read and swap in the variable length header.  All the fields must
@@ -256,66 +258,62 @@ 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;
 }
 
 /* Swap and write out the variable length header.  All the fields must
@@ -326,68 +324,64 @@ 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;
 }
 
 /* Read and swap in the contents of all the auxiliary headers.  Because of
@@ -404,21 +398,24 @@ 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));
 	  nlm_version_header (abfd)->majorVersion =
@@ -437,8 +434,10 @@ nlm_swap_auxiliary_headers_in (abfd)
       else if (strncmp (tempstr, "MeSsAgEs", 8) == 0)
 	{
 	  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));
 	  nlm_extended_header (abfd)->languageID =
@@ -502,22 +501,19 @@ nlm_swap_auxiliary_headers_in (abfd)
 	}
       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)
 	{
@@ -529,12 +525,12 @@ nlm_swap_auxiliary_headers_in (abfd)
 	  PTR hdr;
 
 	  /* Read the stamp ("CuStHeAd").  */
-	  if (bfd_read ((PTR) thdr.stamp, 1, sizeof (thdr.stamp), abfd)
-	      != sizeof (thdr.stamp))
+	  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))
+	  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.  */
@@ -542,9 +538,8 @@ nlm_swap_auxiliary_headers_in (abfd)
 	    dataOffset = 0;
 	  else
 	    {
-	      if (bfd_read ((PTR) thdr.dataOffset, 1,
-			    sizeof (thdr.dataOffset), abfd)
-		  != sizeof (thdr.dataOffset))
+	      amt = sizeof (thdr.dataOffset);
+	      if (bfd_bread ((PTR) thdr.dataOffset, amt, abfd) != amt)
 		return false;
 	      dataOffset = get_word (abfd, (bfd_byte *) thdr.dataOffset);
 	    }
@@ -552,9 +547,8 @@ nlm_swap_auxiliary_headers_in (abfd)
 	    dataLength = 0;
 	  else
 	    {
-	      if (bfd_read ((PTR) thdr.dataLength, 1,
-			    sizeof (thdr.dataLength), abfd)
-		  != sizeof (thdr.dataLength))
+	      amt = sizeof (thdr.dataLength);
+	      if (bfd_bread ((PTR) thdr.dataLength, amt, abfd) != amt)
 		return false;
 	      dataLength = get_word (abfd, (bfd_byte *) thdr.dataLength);
 	    }
@@ -562,8 +556,8 @@ nlm_swap_auxiliary_headers_in (abfd)
 	    memset (dataStamp, 0, sizeof (dataStamp));
 	  else
 	    {
-	      if (bfd_read ((PTR) dataStamp, 1, sizeof (dataStamp), abfd)
-		  != sizeof (dataStamp))
+	      amt = sizeof (dataStamp);
+	      if (bfd_bread ((PTR) dataStamp, amt, abfd) != amt)
 		return false;
 	    }
 
@@ -579,7 +573,7 @@ nlm_swap_auxiliary_headers_in (abfd)
 	      hdr = bfd_alloc (abfd, hdrLength);
 	      if (hdr == NULL)
 		return false;
-	      if (bfd_read (hdr, 1, hdrLength, abfd) != hdrLength)
+	      if (bfd_bread (hdr, hdrLength, abfd) != hdrLength)
 		return false;
 	    }
 
@@ -600,7 +594,7 @@ nlm_swap_auxiliary_headers_in (abfd)
 	      contents = (bfd_byte *) bfd_alloc (abfd, dataLength);
 	      if (contents == NULL)
 		return false;
-	      if (bfd_read (contents, 1, dataLength, abfd) != dataLength)
+	      if (bfd_bread (contents, dataLength, abfd) != dataLength)
 		return false;
 	      if (bfd_seek (abfd, pos, SEEK_SET) != 0)
 		return false;
@@ -638,11 +632,11 @@ nlm_swap_auxiliary_headers_in (abfd)
 
 		  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);
@@ -673,7 +667,7 @@ nlm_swap_auxiliary_headers_in (abfd)
 	  break;
 	}
     }
-  return (true);
+  return true;
 }
 
 /* Return whether there is a non-zero byte in a memory block.  */
@@ -699,6 +693,8 @@ static 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),
 		    sizeof (Nlm_Internal_Version_Header)))
@@ -718,7 +714,8 @@ nlm_swap_auxiliary_headers_out (abfd)
 		(bfd_byte *) thdr.month);
       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))
+      if (bfd_bwrite ((PTR) &thdr, (bfd_size_type) sizeof (thdr), abfd)
+	  != sizeof (thdr))
 	return false;
     }
 
@@ -816,7 +813,8 @@ nlm_swap_auxiliary_headers_out (abfd)
       put_word (abfd,
 		(bfd_vma) nlm_extended_header (abfd)->reserved5,
 		(bfd_byte *) thdr.reserved5);
-      if (bfd_write ((PTR) & thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
+      if (bfd_bwrite ((PTR) &thdr, (bfd_size_type) sizeof (thdr), abfd)
+	  != sizeof (thdr))
 	return false;
     }
 
@@ -827,19 +825,18 @@ nlm_swap_auxiliary_headers_out (abfd)
       Nlm_External_Copyright_Header thdr;
 
       memcpy (thdr.stamp, "CoPyRiGhT=", 10);
-      if (bfd_write ((PTR) thdr.stamp, sizeof (thdr.stamp), 1, abfd)
-	  != sizeof (thdr.stamp))
+      amt = sizeof (thdr.stamp);
+      if (bfd_bwrite ((PTR) thdr.stamp, amt, abfd) != amt)
 	return false;
       thdr.copyrightMessageLength[0] =
 	nlm_copyright_header (abfd)->copyrightMessageLength;
-      if (bfd_write ((PTR) thdr.copyrightMessageLength, 1, 1, abfd) != 1)
+      amt = 1;
+      if (bfd_bwrite ((PTR) thdr.copyrightMessageLength, amt, abfd) != amt)
 	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))
+      amt = nlm_copyright_header (abfd)->copyrightMessageLength + 1;
+      if (bfd_bwrite ((PTR) nlm_copyright_header (abfd)->copyrightMessage,
+		     amt, abfd) != amt)
 	return false;
     }
 
@@ -864,20 +861,19 @@ nlm_swap_auxiliary_headers_out (abfd)
       if (! ds)
 	{
 	  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))
+	  amt = sizeof (thdr) - sizeof (thdr.dataStamp);
+	  if (bfd_bwrite ((PTR) &thdr, amt, abfd) != amt)
 	    return false;
 	}
       else
 	{
 	  memcpy (thdr.dataStamp, nlm_custom_header (abfd)->dataStamp,
 		  sizeof (thdr.dataStamp));
-	  if (bfd_write ((PTR) &thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
+	  amt = sizeof (thdr);
+	  if (bfd_bwrite ((PTR) &thdr, amt, abfd) != amt)
 	    return false;
-	  if (bfd_write (nlm_custom_header (abfd)->hdr, 1,
-			 nlm_custom_header (abfd)->hdrLength, abfd)
-	      != nlm_custom_header (abfd)->hdrLength)
+	  amt = nlm_custom_header (abfd)->hdrLength;
+	  if (bfd_bwrite (nlm_custom_header (abfd)->hdr, amt, abfd) != amt)
 	    return false;
 	}
     }
@@ -896,7 +892,8 @@ nlm_swap_auxiliary_headers_out (abfd)
       put_word (abfd, (bfd_vma) nlm_cygnus_ext_header (abfd)->length,
 		(bfd_byte *) thdr.dataLength);
       memcpy (thdr.dataStamp, "CyGnUsEx", 8);
-      if (bfd_write ((PTR) &thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
+      amt = sizeof (thdr);
+      if (bfd_bwrite ((PTR) &thdr, amt, abfd) != amt)
 	return false;
     }
 
@@ -958,9 +955,9 @@ asymbol *
 nlm_make_empty_symbol (abfd)
      bfd *abfd;
 {
-  nlm_symbol_type *new;
+  bfd_size_type amt = sizeof (nlm_symbol_type);
+  nlm_symbol_type *new = (nlm_symbol_type *) bfd_zalloc (abfd, amt);
 
-  new = (nlm_symbol_type *) bfd_zalloc (abfd, sizeof (nlm_symbol_type));
   if (new)
     new->symbol.the_bfd = abfd;
   return &new->symbol;
@@ -1037,9 +1034,10 @@ nlm_slurp_symbol_table (abfd)
   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 *));
+  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
      symbol table entry.
@@ -1056,14 +1054,14 @@ nlm_slurp_symbol_table (abfd)
 		 + i_fxdhdrp->numberOfExternalReferences);
   if (totsymcount == 0)
     {
-      return (true);
+      return true;
     }
 
-  if (bfd_seek (abfd, i_fxdhdrp->publicsOffset, SEEK_SET) == -1)
-    return (false);
+  if (bfd_seek (abfd, i_fxdhdrp->publicsOffset, SEEK_SET) != 0)
+    return false;
 
-  sym = ((nlm_symbol_type *)
-	 bfd_zalloc (abfd, totsymcount * sizeof (nlm_symbol_type)));
+  amt = totsymcount * sizeof (nlm_symbol_type);
+  sym = ((nlm_symbol_type *) bfd_zalloc (abfd, amt));
   if (!sym)
     return false;
   nlm_set_symbols (abfd, sym);
@@ -1076,20 +1074,21 @@ nlm_slurp_symbol_table (abfd)
   symcount = i_fxdhdrp->numberOfPublics;
   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);
+      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);
       if (set_public_section_func)
@@ -1123,25 +1122,28 @@ nlm_slurp_symbol_table (abfd)
 
   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)))
+	  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);
+	  if (bfd_bread ((PTR) sym->symbol.name, amt, abfd) != amt)
+	    return false;
 	  /* Cast away const.  */
 	  ((char *) (sym->symbol.name))[symlength] = '\0';
 	  sym->symbol.flags = BSF_LOCAL;
@@ -1173,9 +1175,8 @@ nlm_slurp_symbol_table (abfd)
   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)
@@ -1187,7 +1188,7 @@ nlm_slurp_symbol_table (abfd)
 	}
     }
 
-  return (true);
+  return true;
 }
 
 /* Get the relocs for an NLM file.  There are two types of relocs.
@@ -1209,7 +1210,7 @@ nlm_slurp_reloc_fixups (abfd)
 {
   boolean (*read_func) PARAMS ((bfd *, nlm_symbol_type *, asection **,
 				arelent *));
-  bfd_size_type count;
+  bfd_size_type count, amt;
   arelent *rels;
   asection **secs;
 
@@ -1224,8 +1225,10 @@ nlm_slurp_reloc_fixups (abfd)
     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;
   nlm_relocation_fixups (abfd) = rels;
@@ -1609,8 +1612,8 @@ nlm_set_section_contents (abfd, section, location, offset, count)
 	}
     }
 
-  if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) != 0
-      || bfd_write (location, 1, count, abfd) != count)
+  if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
+      || bfd_bwrite (location, count, abfd) != count)
     return false;
 
   return true;
@@ -1679,9 +1682,11 @@ nlm_write_object_contents (abfd)
   file_ptr last;
   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;
 
@@ -1690,9 +1695,8 @@ nlm_write_object_contents (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)
@@ -1703,7 +1707,7 @@ nlm_write_object_contents (abfd)
 
   /* 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);
       goto error_return;
@@ -1769,10 +1773,8 @@ nlm_write_object_contents (abfd)
      are output as a symbol name followed by all the relocs for that
      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;
   i = 0;
@@ -1906,13 +1908,14 @@ nlm_write_object_contents (abfd)
 	  else
 	    {
 	      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;
 	    }
 	}
@@ -1971,18 +1974,19 @@ nlm_write_object_contents (abfd)
 		type = 2;
 
 	      /* 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;
 	    }
 	  nlm_fixed_header (abfd)->numberOfDebugRecords = c;
@@ -2026,7 +2030,7 @@ nlm_write_object_contents (abfd)
     nlm_fixed_header (abfd)->checkUnloadProcedureOffset -=
       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;
 
   write_prefix_func = nlm_write_prefix_func (abfd);
@@ -2040,7 +2044,7 @@ nlm_write_object_contents (abfd)
 	      == nlm_optional_prefix_size (abfd));
 
   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;