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, 100 insertions, 92 deletions

diff --git a/bfd/coffgen.c b/bfd/coffgen.c
index 45eda87..08c39f6 100644
--- a/bfd/coffgen.c
+++ b/bfd/coffgen.c
@@ -68,7 +68,7 @@ static void fixup_symbol_value
 static char *build_debug_section
   PARAMS ((bfd *));
 static char *copy_name
-  PARAMS ((bfd *, char *, int));
+  PARAMS ((bfd *, char *, size_t));
 
 #define STRING_SIZE_SIZE (4)
 
@@ -108,7 +108,7 @@ make_a_section_from_file (abfd, hdr, target_index)
              strindex does not run us past the end, but right now we
              don't know the length of the string table.  */
 	  strings += strindex;
-	  name = bfd_alloc (abfd, strlen (strings) + 1);
+	  name = bfd_alloc (abfd, (bfd_size_type) strlen (strings) + 1);
 	  if (name == NULL)
 	    return false;
 	  strcpy (name, strings);
@@ -118,7 +118,7 @@ make_a_section_from_file (abfd, hdr, target_index)
   if (name == NULL)
     {
       /* Assorted wastage to null-terminate the name, thanks AT&T! */
-      name = bfd_alloc (abfd, sizeof (hdr->s_name) + 1);
+      name = bfd_alloc (abfd, (bfd_size_type) sizeof (hdr->s_name) + 1);
       if (name == NULL)
 	return false;
       strncpy (name, (char *) &hdr->s_name[0], sizeof (hdr->s_name));
@@ -148,7 +148,7 @@ make_a_section_from_file (abfd, hdr, target_index)
   if (! bfd_coff_styp_to_sec_flags_hook (abfd, hdr, name, return_section,
 					 & flags))
     result = false;
-  
+
   return_section->flags = flags;
 
   /* At least on i386-coff, the line number count for a shared library
@@ -178,7 +178,7 @@ coff_real_object_p (abfd, nscns, internal_f, internal_a)
   flagword oflags = abfd->flags;
   bfd_vma ostart = bfd_get_start_address (abfd);
   PTR tdata;
-  size_t readsize;		/* length of file_info */
+  bfd_size_type readsize;	/* length of file_info */
   unsigned int scnhsz;
   char *external_sections;
 
@@ -211,12 +211,12 @@ coff_real_object_p (abfd, nscns, internal_f, internal_a)
     return 0;
 
   scnhsz = bfd_coff_scnhsz (abfd);
-  readsize = nscns * scnhsz;
+  readsize = (bfd_size_type) nscns * scnhsz;
   external_sections = (char *) bfd_alloc (abfd, readsize);
   if (!external_sections)
     goto fail;
 
-  if (bfd_read ((PTR) external_sections, 1, readsize, abfd) != readsize)
+  if (bfd_bread ((PTR) external_sections, readsize, abfd) != readsize)
     goto fail;
 
   /* Set the arch/mach *before* swapping in sections; section header swapping
@@ -257,9 +257,9 @@ const bfd_target *
 coff_object_p (abfd)
      bfd *abfd;
 {
-  unsigned int filhsz;
-  unsigned int aoutsz;
-  int nscns;
+  bfd_size_type filhsz;
+  bfd_size_type aoutsz;
+  unsigned int nscns;
   PTR filehdr;
   struct internal_filehdr internal_f;
   struct internal_aouthdr internal_a;
@@ -271,7 +271,7 @@ coff_object_p (abfd)
   filehdr = bfd_alloc (abfd, filhsz);
   if (filehdr == NULL)
     return 0;
-  if (bfd_read (filehdr, 1, filhsz, abfd) != filhsz)
+  if (bfd_bread (filehdr, filhsz, abfd) != filhsz)
     {
       if (bfd_get_error () != bfd_error_system_call)
 	bfd_set_error (bfd_error_wrong_format);
@@ -294,7 +294,7 @@ coff_object_p (abfd)
       opthdr = bfd_alloc (abfd, aoutsz);
       if (opthdr == NULL)
 	return 0;;
-      if (bfd_read (opthdr, 1, internal_f.f_opthdr, abfd)
+      if (bfd_bread (opthdr, (bfd_size_type) internal_f.f_opthdr, abfd)
 	  != internal_f.f_opthdr)
 	{
 	  return 0;
@@ -431,6 +431,7 @@ _bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs,
   bfd_byte *erel;
   bfd_byte *erel_end;
   struct internal_reloc *irel;
+  bfd_size_type amt;
 
   if (coff_section_data (abfd, sec) != NULL
       && coff_section_data (abfd, sec)->relocs != NULL)
@@ -444,24 +445,24 @@ _bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs,
 
   relsz = bfd_coff_relsz (abfd);
 
+  amt = sec->reloc_count * relsz;
   if (external_relocs == NULL)
     {
-      free_external = (bfd_byte *) bfd_malloc (sec->reloc_count * relsz);
+      free_external = (bfd_byte *) bfd_malloc (amt);
       if (free_external == NULL && sec->reloc_count > 0)
 	goto error_return;
       external_relocs = free_external;
     }
 
   if (bfd_seek (abfd, sec->rel_filepos, SEEK_SET) != 0
-      || (bfd_read (external_relocs, relsz, sec->reloc_count, abfd)
-	  != relsz * sec->reloc_count))
+      || bfd_bread (external_relocs, amt, abfd) != amt)
     goto error_return;
 
   if (internal_relocs == NULL)
     {
-      free_internal = ((struct internal_reloc *)
-		       bfd_malloc (sec->reloc_count
-				   * sizeof (struct internal_reloc)));
+      amt = sec->reloc_count;
+      amt *= sizeof (struct internal_reloc);
+      free_internal = (struct internal_reloc *) bfd_malloc (amt);
       if (free_internal == NULL && sec->reloc_count > 0)
 	goto error_return;
       internal_relocs = free_internal;
@@ -484,9 +485,8 @@ _bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs,
     {
       if (coff_section_data (abfd, sec) == NULL)
 	{
-	  sec->used_by_bfd =
-	    (PTR) bfd_zalloc (abfd,
-			      sizeof (struct coff_section_tdata));
+	  amt = sizeof (struct coff_section_tdata);
+	  sec->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
 	  if (sec->used_by_bfd == NULL)
 	    goto error_return;
 	  coff_section_data (abfd, sec)->contents = NULL;
@@ -661,9 +661,10 @@ coff_renumber_symbols (bfd_ptr, first_undef)
   {
     asymbol **newsyms;
     unsigned int i;
+    bfd_size_type amt;
 
-    newsyms = (asymbol **) bfd_alloc (bfd_ptr,
-				      sizeof (asymbol *) * (symbol_count + 1));
+    amt = sizeof (asymbol *) * ((bfd_size_type) symbol_count + 1);
+    newsyms = (asymbol **) bfd_alloc (bfd_ptr, amt);
     if (!newsyms)
       return false;
     bfd_ptr->outsymbols = newsyms;
@@ -756,8 +757,8 @@ coff_mangle_symbols (bfd_ptr)
 	  if (s->fix_value)
 	    {
 	      /* FIXME: We should use a union here.  */
-	      s->u.syment.n_value = 
-		(bfd_vma)((combined_entry_type *) 
+	      s->u.syment.n_value =
+		(bfd_vma)((combined_entry_type *)
 			  ((unsigned long) s->u.syment.n_value))->offset;
 	      s->fix_value = 0;
 	    }
@@ -876,7 +877,7 @@ coff_fix_symbol_name (abfd, symbol, native, string_size_p,
 	}
       else
 	{
-	  long filepos;
+	  file_ptr filepos;
 	  bfd_byte buf[4];
 	  int prefix_len = bfd_coff_debug_string_prefix_length (abfd);
 
@@ -889,9 +890,9 @@ coff_fix_symbol_name (abfd, symbol, native, string_size_p,
 	    *debug_string_section_p = bfd_get_section_by_name (abfd, ".debug");
 	  filepos = bfd_tell (abfd);
 	  if (prefix_len == 4)
-	    bfd_put_32 (abfd, name_length + 1, buf);
+	    bfd_put_32 (abfd, (bfd_vma) (name_length + 1), buf);
 	  else
-	    bfd_put_16 (abfd, name_length + 1, buf);
+	    bfd_put_16 (abfd, (bfd_vma) (name_length + 1), buf);
 
 	  if (!bfd_set_section_contents (abfd,
 					 *debug_string_section_p,
@@ -901,8 +902,8 @@ coff_fix_symbol_name (abfd, symbol, native, string_size_p,
 	      || !bfd_set_section_contents (abfd,
 					    *debug_string_section_p,
 					    (PTR) symbol->name,
-					    ((file_ptr) *debug_string_size_p
-					     + prefix_len),
+					    (file_ptr) (*debug_string_size_p
+							+ prefix_len),
 					    (bfd_size_type) name_length + 1))
 	    abort ();
 	  if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
@@ -970,7 +971,7 @@ coff_write_symbol (abfd, symbol, native, written, string_size_p,
   if (!buf)
     return false;
   bfd_coff_swap_sym_out (abfd, &native->u.syment, buf);
-  if (bfd_write (buf, 1, symesz, abfd) != symesz)
+  if (bfd_bwrite (buf, symesz, abfd) != symesz)
     return false;
   bfd_release (abfd, buf);
 
@@ -989,10 +990,10 @@ coff_write_symbol (abfd, symbol, native, written, string_size_p,
 				 &((native + j + 1)->u.auxent),
 				 type,
 				 class,
-				 j,
+				 (int) j,
 				 native->u.syment.n_numaux,
 				 buf);
-	  if (bfd_write (buf, 1, auxesz, abfd) != auxesz)
+	  if (bfd_bwrite (buf, auxesz, abfd) != auxesz)
 	    return false;
 	}
       bfd_release (abfd, buf);
@@ -1219,11 +1220,12 @@ coff_write_symbols (abfd)
       bfd_byte buffer[STRING_SIZE_SIZE];
 
 #if STRING_SIZE_SIZE == 4
-      bfd_h_put_32 (abfd, size, buffer);
+      H_PUT_32 (abfd, size, buffer);
 #else
- #error Change bfd_h_put_32
+ #error Change H_PUT_32
 #endif
-      if (bfd_write ((PTR) buffer, 1, sizeof (buffer), abfd) != sizeof (buffer))
+      if (bfd_bwrite ((PTR) buffer, (bfd_size_type) sizeof (buffer), abfd)
+	  != sizeof (buffer))
 	return false;
 
       /* Handle long section names.  This code must handle section
@@ -1239,7 +1241,8 @@ coff_write_symbols (abfd)
 	      len = strlen (o->name);
 	      if (len > SCNNMLEN)
 		{
-		  if (bfd_write (o->name, 1, len + 1, abfd) != len + 1)
+		  if (bfd_bwrite (o->name, (bfd_size_type) (len + 1), abfd)
+		      != len + 1)
 		    return false;
 		}
 	    }
@@ -1279,7 +1282,10 @@ coff_write_symbols (abfd)
 		   && c_symbol->native->u.syment.n_numaux > 0)
 	    {
 	      if (bfd_coff_force_symnames_in_strings (abfd))
-      		bfd_write (".file", 1, 6, abfd);
+		{
+		  if (bfd_bwrite (".file", (bfd_size_type) 6, abfd) != 6)
+		    return false;
+		}
 	      maxlen = bfd_coff_filnmlen (abfd);
 	    }
 	  else
@@ -1287,8 +1293,8 @@ coff_write_symbols (abfd)
 
 	  if (name_length > maxlen)
 	    {
-	      if (bfd_write ((PTR) (q->name), 1, name_length + 1, abfd)
-		  != name_length + 1)
+	      if (bfd_bwrite ((PTR) (q->name), (bfd_size_type) name_length + 1,
+			     abfd) != name_length + 1)
 		return false;
 	    }
 	}
@@ -1302,11 +1308,11 @@ coff_write_symbols (abfd)
       bfd_byte buffer[STRING_SIZE_SIZE];
 
 #if STRING_SIZE_SIZE == 4
-      bfd_h_put_32 (abfd, size, buffer);
+      H_PUT_32 (abfd, size, buffer);
 #else
- #error Change bfd_h_put_32
+ #error Change H_PUT_32
 #endif
-      if (bfd_write ((PTR) buffer, 1, STRING_SIZE_SIZE, abfd)
+      if (bfd_bwrite ((PTR) buffer, (bfd_size_type) STRING_SIZE_SIZE, abfd)
 	  != STRING_SIZE_SIZE)
 	return false;
     }
@@ -1361,7 +1367,8 @@ coff_write_linenumbers (abfd)
 		      out.l_lnno = 0;
 		      out.l_addr.l_symndx = l->u.offset;
 		      bfd_coff_swap_lineno_out (abfd, &out, buff);
-		      if (bfd_write (buff, 1, linesz, abfd) != linesz)
+		      if (bfd_bwrite (buff, (bfd_size_type) linesz, abfd)
+			  != linesz)
 			return false;
 		      l++;
 		      while (l->line_number)
@@ -1369,7 +1376,8 @@ coff_write_linenumbers (abfd)
 			  out.l_lnno = l->line_number;
 			  out.l_addr.l_symndx = l->u.offset;
 			  bfd_coff_swap_lineno_out (abfd, &out, buff);
-			  if (bfd_write (buff, 1, linesz, abfd) != linesz)
+			  if (bfd_bwrite (buff, (bfd_size_type) linesz, abfd)
+			      != linesz)
 			    return false;
 			  l++;
 			}
@@ -1417,7 +1425,7 @@ coff_section_symbol (abfd, name)
 	  combined_entry_type e[10];
 	};
       struct foo *f;
-      f = (struct foo *) bfd_alloc (abfd, sizeof (*f));
+      f = (struct foo *) bfd_alloc (abfd, (bfd_size_type) sizeof (*f));
       if (!f)
 	{
 	  bfd_set_error (bfd_error_no_error);
@@ -1500,7 +1508,8 @@ build_debug_section (abfd)
      bfd *abfd;
 {
   char *debug_section;
-  long position;
+  file_ptr position;
+  bfd_size_type sec_size;
 
   asection *sect = bfd_get_section_by_name (abfd, ".debug");
 
@@ -1510,8 +1519,8 @@ build_debug_section (abfd)
       return NULL;
     }
 
-  debug_section = (PTR) bfd_alloc (abfd,
-				   bfd_get_section_size_before_reloc (sect));
+  sec_size = bfd_get_section_size_before_reloc (sect);
+  debug_section = (PTR) bfd_alloc (abfd, sec_size);
   if (debug_section == NULL)
     return NULL;
 
@@ -1521,9 +1530,7 @@ build_debug_section (abfd)
 
   position = bfd_tell (abfd);
   if (bfd_seek (abfd, sect->filepos, SEEK_SET) != 0
-      || (bfd_read (debug_section,
-		    bfd_get_section_size_before_reloc (sect), 1, abfd)
-	  != bfd_get_section_size_before_reloc (sect))
+      || bfd_bread (debug_section, sec_size, abfd) != sec_size
       || bfd_seek (abfd, position, SEEK_SET) != 0)
     return NULL;
   return debug_section;
@@ -1536,9 +1543,9 @@ static char *
 copy_name (abfd, name, maxlen)
      bfd *abfd;
      char *name;
-     int maxlen;
+     size_t maxlen;
 {
-  int len;
+  size_t len;
   char *newname;
 
   for (len = 0; len < maxlen; ++len)
@@ -1549,7 +1556,7 @@ copy_name (abfd, name, maxlen)
 	}
     }
 
-  if ((newname = (PTR) bfd_alloc (abfd, len + 1)) == NULL)
+  if ((newname = (PTR) bfd_alloc (abfd, (bfd_size_type) len + 1)) == NULL)
     return (NULL);
   strncpy (newname, name, len);
   newname[len] = '\0';
@@ -1563,7 +1570,7 @@ _bfd_coff_get_external_symbols (abfd)
      bfd *abfd;
 {
   bfd_size_type symesz;
-  size_t size;
+  bfd_size_type size;
   PTR syms;
 
   if (obj_coff_external_syms (abfd) != NULL)
@@ -1578,7 +1585,7 @@ _bfd_coff_get_external_symbols (abfd)
     return false;
 
   if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
-      || bfd_read (syms, size, 1, abfd) != size)
+      || bfd_bread (syms, size, abfd) != size)
     {
       if (syms != NULL)
 	free (syms);
@@ -1599,8 +1606,9 @@ _bfd_coff_read_string_table (abfd)
      bfd *abfd;
 {
   char extstrsize[STRING_SIZE_SIZE];
-  size_t strsize;
+  bfd_size_type strsize;
   char *strings;
+  file_ptr pos;
 
   if (obj_coff_strings (abfd) != NULL)
     return obj_coff_strings (abfd);
@@ -1611,13 +1619,13 @@ _bfd_coff_read_string_table (abfd)
       return NULL;
     }
 
-  if (bfd_seek (abfd,
-		(obj_sym_filepos (abfd)
-		 + obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd)),
-		SEEK_SET) != 0)
+  pos = obj_sym_filepos (abfd);
+  pos += obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd);
+  if (bfd_seek (abfd, pos, SEEK_SET) != 0)
     return NULL;
 
-  if (bfd_read (extstrsize, sizeof extstrsize, 1, abfd) != sizeof extstrsize)
+  if (bfd_bread (extstrsize, (bfd_size_type) sizeof extstrsize, abfd)
+      != sizeof extstrsize)
     {
       if (bfd_get_error () != bfd_error_file_truncated)
 	return NULL;
@@ -1628,9 +1636,9 @@ _bfd_coff_read_string_table (abfd)
   else
     {
 #if STRING_SIZE_SIZE == 4
-      strsize = bfd_h_get_32 (abfd, (bfd_byte *) extstrsize);
+      strsize = H_GET_32 (abfd, extstrsize);
 #else
- #error Change bfd_h_get_32
+ #error Change H_GET_32
 #endif
     }
 
@@ -1647,8 +1655,7 @@ _bfd_coff_read_string_table (abfd)
   if (strings == NULL)
     return NULL;
 
-  if (bfd_read (strings + STRING_SIZE_SIZE,
-		strsize - STRING_SIZE_SIZE, 1, abfd)
+  if (bfd_bread (strings + STRING_SIZE_SIZE, strsize - STRING_SIZE_SIZE, abfd)
       != strsize - STRING_SIZE_SIZE)
     {
       free (strings);
@@ -1694,12 +1701,12 @@ coff_get_normalized_symtab (abfd)
   combined_entry_type *internal_ptr;
   combined_entry_type *symbol_ptr;
   combined_entry_type *internal_end;
-  bfd_size_type symesz;
+  size_t symesz;
   char *raw_src;
   char *raw_end;
   const char *string_table = NULL;
   char *debug_section = NULL;
-  unsigned long size;
+  bfd_size_type size;
 
   if (obj_raw_syments (abfd) != NULL)
     return obj_raw_syments (abfd);
@@ -1742,7 +1749,7 @@ coff_get_normalized_symtab (abfd)
 	  bfd_coff_swap_aux_in (abfd, (PTR) raw_src,
 				symbol_ptr->u.syment.n_type,
 				symbol_ptr->u.syment.n_sclass,
-				i, symbol_ptr->u.syment.n_numaux,
+				(int) i, symbol_ptr->u.syment.n_numaux,
 				&(internal_ptr->u.auxent));
 	  coff_pointerize_aux (abfd, internal, symbol_ptr, i,
 			       internal_ptr);
@@ -1797,7 +1804,7 @@ coff_get_normalized_symtab (abfd)
 		    ((long)
 		     copy_name (abfd,
 				(internal_ptr + 1)->u.auxent.x_file.x_fname,
-				bfd_coff_filnmlen (abfd)));
+				(size_t) bfd_coff_filnmlen (abfd)));
 		}
 	    }
 	}
@@ -1806,23 +1813,20 @@ coff_get_normalized_symtab (abfd)
 	  if (internal_ptr->u.syment._n._n_n._n_zeroes != 0)
 	    {
 	      /* This is a "short" name.  Make it long.  */
-	      unsigned long i = 0;
-	      char *newstring = NULL;
+	      size_t i;
+	      char *newstring;
 
 	      /* find the length of this string without walking into memory
 	         that isn't ours.  */
 	      for (i = 0; i < 8; ++i)
-		{
-		  if (internal_ptr->u.syment._n._n_name[i] == '\0')
-		    {
-		      break;
-		    }		/* if end of string */
-		}		/* possible lengths of this string.  */
+		if (internal_ptr->u.syment._n._n_name[i] == '\0')
+		  break;
 
-	      if ((newstring = (PTR) bfd_alloc (abfd, ++i)) == NULL)
+	      newstring = (PTR) bfd_alloc (abfd, (bfd_size_type) (i + 1));
+	      if (newstring == NULL)
 		return (NULL);
-	      memset (newstring, 0, i);
-	      strncpy (newstring, internal_ptr->u.syment._n._n_name, i - 1);
+	      memset (newstring, 0, i + 1);
+	      strncpy (newstring, internal_ptr->u.syment._n._n_name, i);
 	      internal_ptr->u.syment._n._n_n._n_offset = (long int) newstring;
 	      internal_ptr->u.syment._n._n_n._n_zeroes = 0;
 	    }
@@ -1879,7 +1883,8 @@ asymbol *
 coff_make_empty_symbol (abfd)
      bfd *abfd;
 {
-  coff_symbol_type *new = (coff_symbol_type *) bfd_alloc (abfd, sizeof (coff_symbol_type));
+  bfd_size_type amt = sizeof (coff_symbol_type);
+  coff_symbol_type *new = (coff_symbol_type *) bfd_alloc (abfd, amt);
   if (new == NULL)
     return (NULL);
   memset (new, 0, sizeof *new);
@@ -1899,12 +1904,14 @@ coff_bfd_make_debug_symbol (abfd, ptr, sz)
      PTR ptr ATTRIBUTE_UNUSED;
      unsigned long sz ATTRIBUTE_UNUSED;
 {
-  coff_symbol_type *new = (coff_symbol_type *) bfd_alloc (abfd, sizeof (coff_symbol_type));
+  bfd_size_type amt = sizeof (coff_symbol_type);
+  coff_symbol_type *new = (coff_symbol_type *) bfd_alloc (abfd, amt);
   if (new == NULL)
     return (NULL);
   /* @@ The 10 is a guess at a plausible maximum number of aux entries
      (but shouldn't be a constant).  */
-  new->native = (combined_entry_type *) bfd_zalloc (abfd, sizeof (combined_entry_type) * 10);
+  amt = sizeof (combined_entry_type) * 10;
+  new->native = (combined_entry_type *) bfd_zalloc (abfd, amt);
   if (!new->native)
     return (NULL);
   new->symbol.section = bfd_abs_section_ptr;
@@ -1950,7 +1957,7 @@ bfd_coff_get_syment (abfd, symbol, psyment)
   *psyment = csym->native->u.syment;
 
   if (csym->native->fix_value)
-    psyment->n_value = psyment->n_value - 
+    psyment->n_value = psyment->n_value -
       (unsigned long) obj_raw_syments (abfd);
 
   /* FIXME: We should handle fix_line here.  */
@@ -2185,8 +2192,8 @@ coff_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
      asection *section;
      asymbol **symbols;
      bfd_vma offset;
-     CONST char **filename_ptr;
-     CONST char **functionname_ptr;
+     const char **filename_ptr;
+     const char **functionname_ptr;
      unsigned int *line_ptr;
 {
   boolean found;
@@ -2198,6 +2205,7 @@ coff_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
   combined_entry_type *pend;
   alent *l;
   struct coff_section_tdata *sec_data;
+  bfd_size_type amt;
 
   /* Before looking through the symbol table, try to use a .stab
      section to find the information.  */
@@ -2372,9 +2380,8 @@ coff_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
   /* Cache the results for the next call.  */
   if (sec_data == NULL && section->owner == abfd)
     {
-      section->used_by_bfd =
-	((PTR) bfd_zalloc (abfd,
-			   sizeof (struct coff_section_tdata)));
+      amt = sizeof (struct coff_section_tdata);
+      section->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
       sec_data = (struct coff_section_tdata *) section->used_by_bfd;
     }
   if (sec_data != NULL)
@@ -2431,8 +2438,9 @@ bfd_coff_set_symbol_class (abfd, symbol, class)
 	 coff_write_alien_symbol().  */
 
       combined_entry_type * native;
+      bfd_size_type amt = sizeof (* native);
 
-      native = (combined_entry_type *) bfd_alloc (abfd, sizeof (* native));
+      native = (combined_entry_type *) bfd_alloc (abfd, amt);
       if (native == NULL)
 	return false;