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, 119 insertions, 117 deletions

diff --git a/bfd/cofflink.c b/bfd/cofflink.c
index 7e40bd9..e99c470 100644
--- a/bfd/cofflink.c
+++ b/bfd/cofflink.c
@@ -117,9 +117,9 @@ _bfd_coff_link_hash_table_create (abfd)
      bfd *abfd;
 {
   struct coff_link_hash_table *ret;
+  bfd_size_type amt = sizeof (struct coff_link_hash_table);
 
-  ret = ((struct coff_link_hash_table *)
-	 bfd_alloc (abfd, sizeof (struct coff_link_hash_table)));
+  ret = (struct coff_link_hash_table *) bfd_alloc (abfd, amt);
   if (ret == NULL)
     return NULL;
   if (! _bfd_coff_link_hash_table_init (ret, abfd,
@@ -325,6 +325,7 @@ coff_link_add_symbols (abfd, info)
   bfd_size_type symesz;
   bfd_byte *esym;
   bfd_byte *esym_end;
+  bfd_size_type amt;
 
   /* Keep the symbols during this function, in case the linker needs
      to read the generic symbols in order to report an error message.  */
@@ -340,10 +341,8 @@ coff_link_add_symbols (abfd, info)
 
   /* We keep a list of the linker hash table entries that correspond
      to particular symbols.  */
-  sym_hash = ((struct coff_link_hash_entry **)
-	      bfd_alloc (abfd,
-			 ((size_t) symcount
-			  * sizeof (struct coff_link_hash_entry *))));
+  amt = symcount * sizeof (struct coff_link_hash_entry *);
+  sym_hash = (struct coff_link_hash_entry **) bfd_alloc (abfd, amt);
   if (sym_hash == NULL && symcount != 0)
     goto error_return;
   obj_coff_sym_hashes (abfd) = sym_hash;
@@ -564,8 +563,8 @@ coff_link_add_symbols (abfd, info)
 			   i < sym.n_numaux;
 			   i++, eaux += symesz, iaux++)
 			bfd_coff_swap_aux_in (abfd, (PTR) eaux, sym.n_type,
-					      sym.n_sclass, i, sym.n_numaux,
-					      (PTR) iaux);
+					      sym.n_sclass, (int) i,
+					      sym.n_numaux, (PTR) iaux);
 		      (*sym_hash)->aux = alloc;
 		    }
 		}
@@ -618,9 +617,8 @@ coff_link_add_symbols (abfd, info)
 	      secdata = coff_section_data (abfd, stab);
 	      if (secdata == NULL)
 		{
-		  stab->used_by_bfd =
-		    (PTR) bfd_zalloc (abfd,
-				      sizeof (struct coff_section_tdata));
+		  amt = sizeof (struct coff_section_tdata);
+		  stab->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
 		  if (stab->used_by_bfd == NULL)
 		    goto error_return;
 		  secdata = coff_section_data (abfd, stab);
@@ -658,11 +656,11 @@ _bfd_coff_final_link (abfd, info)
   boolean long_section_names;
   asection *o;
   struct bfd_link_order *p;
-  size_t max_sym_count;
-  size_t max_lineno_count;
-  size_t max_reloc_count;
-  size_t max_output_reloc_count;
-  size_t max_contents_size;
+  bfd_size_type max_sym_count;
+  bfd_size_type max_lineno_count;
+  bfd_size_type max_reloc_count;
+  bfd_size_type max_output_reloc_count;
+  bfd_size_type max_contents_size;
   file_ptr rel_filepos;
   unsigned int relsz;
   file_ptr line_filepos;
@@ -670,6 +668,7 @@ _bfd_coff_final_link (abfd, info)
   bfd *sub;
   bfd_byte *external_relocs = NULL;
   char strbuf[STRING_SIZE_SIZE];
+  bfd_size_type amt;
 
   symesz = bfd_coff_symesz (abfd);
 
@@ -785,10 +784,9 @@ _bfd_coff_final_link (abfd, info)
 
       /* We use section_count + 1, rather than section_count, because
          the target_index fields are 1 based.  */
-      finfo.section_info =
-	((struct coff_link_section_info *)
-	 bfd_malloc ((abfd->section_count + 1)
-		     * sizeof (struct coff_link_section_info)));
+      amt = abfd->section_count + 1;
+      amt *= sizeof (struct coff_link_section_info);
+      finfo.section_info = (struct coff_link_section_info *) bfd_malloc (amt);
       if (finfo.section_info == NULL)
 	goto error_return;
       for (i = 0; i <= abfd->section_count; i++)
@@ -829,13 +827,14 @@ _bfd_coff_final_link (abfd, info)
 	     but only when doing a relocateable link, which is not the
 	     common case.  */
 	  BFD_ASSERT (info->relocateable);
+	  amt = o->reloc_count;
+	  amt *= sizeof (struct internal_reloc);
 	  finfo.section_info[o->target_index].relocs =
-	    ((struct internal_reloc *)
-	     bfd_malloc (o->reloc_count * sizeof (struct internal_reloc)));
+	    (struct internal_reloc *) bfd_malloc (amt);
+	  amt = o->reloc_count;
+	  amt *= sizeof (struct coff_link_hash_entry *);
 	  finfo.section_info[o->target_index].rel_hashes =
-	    ((struct coff_link_hash_entry **)
-	     bfd_malloc (o->reloc_count
-		     * sizeof (struct coff_link_hash_entry *)));
+	    (struct coff_link_hash_entry **) bfd_malloc (amt);
 	  if (finfo.section_info[o->target_index].relocs == NULL
 	      || finfo.section_info[o->target_index].rel_hashes == NULL)
 	    goto error_return;
@@ -867,22 +866,23 @@ _bfd_coff_final_link (abfd, info)
     }
 
   /* Allocate some buffers used while linking.  */
-  finfo.internal_syms = ((struct internal_syment *)
-			 bfd_malloc (max_sym_count
-				     * sizeof (struct internal_syment)));
-  finfo.sec_ptrs = (asection **) bfd_malloc (max_sym_count
-					     * sizeof (asection *));
-  finfo.sym_indices = (long *) bfd_malloc (max_sym_count * sizeof (long));
-  finfo.outsyms = ((bfd_byte *)
-		   bfd_malloc ((size_t) ((max_sym_count + 1) * symesz)));
-  finfo.linenos = (bfd_byte *) bfd_malloc (max_lineno_count
-				       * bfd_coff_linesz (abfd));
+  amt = max_sym_count * sizeof (struct internal_syment);
+  finfo.internal_syms = (struct internal_syment *) bfd_malloc (amt);
+  amt = max_sym_count * sizeof (asection *);
+  finfo.sec_ptrs = (asection **) bfd_malloc (amt);
+  amt = max_sym_count * sizeof (long);
+  finfo.sym_indices = (long *) bfd_malloc (amt);
+  finfo.outsyms = (bfd_byte *) bfd_malloc ((max_sym_count + 1) * symesz);
+  amt = max_lineno_count * bfd_coff_linesz (abfd);
+  finfo.linenos = (bfd_byte *) bfd_malloc (amt);
   finfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
-  finfo.external_relocs = (bfd_byte *) bfd_malloc (max_reloc_count * relsz);
+  amt = max_reloc_count * relsz;
+  finfo.external_relocs = (bfd_byte *) bfd_malloc (amt);
   if (! info->relocateable)
-    finfo.internal_relocs = ((struct internal_reloc *)
-			     bfd_malloc (max_reloc_count
-					 * sizeof (struct internal_reloc)));
+    {
+      amt = max_reloc_count * sizeof (struct internal_reloc);
+      finfo.internal_relocs = (struct internal_reloc *) bfd_malloc (amt);
+    }
   if ((finfo.internal_syms == NULL && max_sym_count > 0)
       || (finfo.sec_ptrs == NULL && max_sym_count > 0)
       || (finfo.sym_indices == NULL && max_sym_count > 0)
@@ -987,14 +987,15 @@ _bfd_coff_final_link (abfd, info)
   if (finfo.last_file_index != -1
       && (unsigned int) finfo.last_file.n_value != obj_raw_syment_count (abfd))
     {
+      file_ptr pos;
+
       finfo.last_file.n_value = obj_raw_syment_count (abfd);
       bfd_coff_swap_sym_out (abfd, (PTR) &finfo.last_file,
 			     (PTR) finfo.outsyms);
-      if (bfd_seek (abfd,
-		    (obj_sym_filepos (abfd)
-		     + finfo.last_file_index * symesz),
-		    SEEK_SET) != 0
-	  || bfd_write (finfo.outsyms, symesz, 1, abfd) != symesz)
+
+      pos = obj_sym_filepos (abfd) + finfo.last_file_index * symesz;
+      if (bfd_seek (abfd, pos, SEEK_SET) != 0
+	  || bfd_bwrite (finfo.outsyms, symesz, abfd) != symesz)
 	return false;
     }
 
@@ -1029,8 +1030,8 @@ _bfd_coff_final_link (abfd, info)
       /* Now that we have written out all the global symbols, we know
 	 the symbol indices to use for relocs against them, and we can
 	 finally write out the relocs.  */
-      external_relocs = ((bfd_byte *)
-			 bfd_malloc (max_output_reloc_count * relsz));
+      amt = max_output_reloc_count * relsz;
+      external_relocs = (bfd_byte *) bfd_malloc (amt);
       if (external_relocs == NULL)
 	goto error_return;
 
@@ -1059,8 +1060,9 @@ _bfd_coff_final_link (abfd, info)
 	    }
 
 	  if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0
-	      || bfd_write ((PTR) external_relocs, relsz, o->reloc_count,
-			    abfd) != relsz * o->reloc_count)
+	      || (bfd_bwrite ((PTR) external_relocs,
+			     (bfd_size_type) relsz * o->reloc_count, abfd)
+		  != (bfd_size_type) relsz * o->reloc_count))
 	    goto error_return;
 	}
 
@@ -1094,21 +1096,22 @@ _bfd_coff_final_link (abfd, info)
   /* Write out the string table.  */
   if (obj_raw_syment_count (abfd) != 0 || long_section_names)
     {
-      if (bfd_seek (abfd,
-		    (obj_sym_filepos (abfd)
-		     + obj_raw_syment_count (abfd) * symesz),
-		    SEEK_SET) != 0)
+      file_ptr pos;
+
+      pos = obj_sym_filepos (abfd) + obj_raw_syment_count (abfd) * symesz;
+      if (bfd_seek (abfd, pos, SEEK_SET) != 0)
 	return false;
 
 #if STRING_SIZE_SIZE == 4
-      bfd_h_put_32 (abfd,
-		    _bfd_stringtab_size (finfo.strtab) + STRING_SIZE_SIZE,
-		    (bfd_byte *) strbuf);
+      H_PUT_32 (abfd,
+		_bfd_stringtab_size (finfo.strtab) + STRING_SIZE_SIZE,
+		strbuf);
 #else
- #error Change bfd_h_put_32
+ #error Change H_PUT_32 above
 #endif
 
-      if (bfd_write (strbuf, 1, STRING_SIZE_SIZE, abfd) != STRING_SIZE_SIZE)
+      if (bfd_bwrite (strbuf, (bfd_size_type) STRING_SIZE_SIZE, abfd)
+	  != STRING_SIZE_SIZE)
 	return false;
 
       if (! _bfd_stringtab_emit (abfd, finfo.strtab))
@@ -1176,17 +1179,17 @@ dores_com (ptr, output_bfd, heap)
     {
       int val = strtoul (ptr, &ptr, 0);
       if (heap)
-	pe_data(output_bfd)->pe_opthdr.SizeOfHeapReserve =val;
+	pe_data(output_bfd)->pe_opthdr.SizeOfHeapReserve = val;
       else
-	pe_data(output_bfd)->pe_opthdr.SizeOfStackReserve =val;
+	pe_data(output_bfd)->pe_opthdr.SizeOfStackReserve = val;
 
       if (ptr[0] == ',')
 	{
-	  int val = strtoul (ptr+1, &ptr, 0);
+	  val = strtoul (ptr+1, &ptr, 0);
 	  if (heap)
-	    pe_data(output_bfd)->pe_opthdr.SizeOfHeapCommit =val;
+	    pe_data(output_bfd)->pe_opthdr.SizeOfHeapCommit = val;
 	  else
-	    pe_data(output_bfd)->pe_opthdr.SizeOfStackCommit =val;
+	    pe_data(output_bfd)->pe_opthdr.SizeOfStackCommit = val;
 	}
     }
   return ptr;
@@ -1220,10 +1223,10 @@ process_embedded_commands (output_bfd, info,  abfd)
   if (!sec)
     return 1;
 
-  copy = bfd_malloc ((size_t) sec->_raw_size);
+  copy = bfd_malloc (sec->_raw_size);
   if (!copy)
     return 0;
-  if (! bfd_get_section_contents(abfd, sec, copy, 0, sec->_raw_size))
+  if (! bfd_get_section_contents(abfd, sec, copy, (bfd_vma) 0, sec->_raw_size))
     {
       free (copy);
       return 0;
@@ -1586,6 +1589,7 @@ _bfd_coff_link_input_bfd (finfo, input_bfd)
 	  struct coff_debug_merge_element **epp;
 	  bfd_byte *esl, *eslend;
 	  struct internal_syment *islp;
+	  bfd_size_type amt;
 
 	  name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
 	  if (name == NULL)
@@ -1606,9 +1610,8 @@ _bfd_coff_link_input_bfd (finfo, input_bfd)
 	  /* Allocate memory to hold type information.  If this turns
              out to be a duplicate, we pass this address to
              bfd_release.  */
-	  mt = ((struct coff_debug_merge_type *)
-		bfd_alloc (input_bfd,
-			   sizeof (struct coff_debug_merge_type)));
+	  amt = sizeof (struct coff_debug_merge_type);
+	  mt = (struct coff_debug_merge_type *) bfd_alloc (input_bfd, amt);
 	  if (mt == NULL)
 	    return false;
 	  mt->class = isym.n_sclass;
@@ -1634,9 +1637,9 @@ _bfd_coff_link_input_bfd (finfo, input_bfd)
 
 	      bfd_coff_swap_sym_in (input_bfd, (PTR) esl, (PTR) islp);
 
+	      amt = sizeof (struct coff_debug_merge_element);
 	      *epp = ((struct coff_debug_merge_element *)
-		      bfd_alloc (input_bfd,
-				 sizeof (struct coff_debug_merge_element)));
+		      bfd_alloc (input_bfd, amt));
 	      if (*epp == NULL)
 		return false;
 
@@ -1645,8 +1648,8 @@ _bfd_coff_link_input_bfd (finfo, input_bfd)
 	      if (elename == NULL)
 		return false;
 
-	      name_copy = (char *) bfd_alloc (input_bfd,
-					      strlen (elename) + 1);
+	      amt = strlen (elename) + 1;
+	      name_copy = (char *) bfd_alloc (input_bfd, amt);
 	      if (name_copy == NULL)
 		return false;
 	      strcpy (name_copy, elename);
@@ -1846,18 +1849,18 @@ _bfd_coff_link_input_bfd (finfo, input_bfd)
 		    }
 		  else
 		    {
+		      file_ptr pos;
+
 		      /* We have already written out the last C_FILE
 			 symbol.  We need to write it out again.  We
 			 borrow *outsym temporarily.  */
 		      bfd_coff_swap_sym_out (output_bfd,
 					     (PTR) &finfo->last_file,
 					     (PTR) outsym);
-		      if (bfd_seek (output_bfd,
-				    (obj_sym_filepos (output_bfd)
-				     + finfo->last_file_index * osymesz),
-				    SEEK_SET) != 0
-			  || (bfd_write (outsym, osymesz, 1, output_bfd)
-			      != osymesz))
+		      pos = obj_sym_filepos (output_bfd);
+		      pos += finfo->last_file_index * osymesz;
+		      if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
+			  || bfd_bwrite (outsym, osymesz, output_bfd) != osymesz)
 			return false;
 		    }
 		}
@@ -2079,6 +2082,8 @@ _bfd_coff_link_input_bfd (finfo, input_bfd)
 			    }
 			  else
 			    {
+			      file_ptr pos;
+
 			      /* We have already written out the last
                                  .bf aux entry.  We need to write it
                                  out again.  We borrow *outsym
@@ -2090,12 +2095,11 @@ _bfd_coff_link_input_bfd (finfo, input_bfd)
 						     isymp->n_sclass,
 						     0, isymp->n_numaux,
 						     (PTR) outsym);
-			      if (bfd_seek (output_bfd,
-					    (obj_sym_filepos (output_bfd)
-					     + finfo->last_bf_index * osymesz),
-					    SEEK_SET) != 0
-				  || bfd_write (outsym, osymesz, 1,
-						output_bfd) != osymesz)
+			      pos = obj_sym_filepos (output_bfd);
+			      pos += finfo->last_bf_index * osymesz;
+			      if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
+				  || (bfd_bwrite (outsym, osymesz, output_bfd)
+				      != osymesz))
 				return false;
 			    }
 			}
@@ -2143,6 +2147,8 @@ _bfd_coff_link_input_bfd (finfo, input_bfd)
 	  bfd_byte *elineend;
 	  bfd_byte *oeline;
 	  boolean skipping;
+	  file_ptr pos;
+	  bfd_size_type amt;
 
 	  /* FIXME: If SEC_HAS_CONTENTS is not for the section, then
 	     build_link_order in ldwrite.c will not have created a
@@ -2158,7 +2164,7 @@ _bfd_coff_link_input_bfd (finfo, input_bfd)
 	    continue;
 
 	  if (bfd_seek (input_bfd, o->line_filepos, SEEK_SET) != 0
-	      || bfd_read (finfo->linenos, linesz, o->lineno_count,
+	      || bfd_bread (finfo->linenos, linesz * o->lineno_count,
 			   input_bfd) != linesz * o->lineno_count)
 	    return false;
 
@@ -2246,17 +2252,14 @@ _bfd_coff_link_input_bfd (finfo, input_bfd)
 		}
 	    }
 
-	  if (bfd_seek (output_bfd,
-			(o->output_section->line_filepos
-			 + o->output_section->lineno_count * linesz),
-			SEEK_SET) != 0
-	      || (bfd_write (finfo->linenos, 1, oeline - finfo->linenos,
-			     output_bfd)
-		  != (bfd_size_type) (oeline - finfo->linenos)))
+	  pos = o->output_section->line_filepos;
+	  pos += o->output_section->lineno_count * linesz;
+	  amt = oeline - finfo->linenos;
+	  if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
+	      || bfd_bwrite (finfo->linenos, amt, output_bfd) != amt)
 	    return false;
 
-	  o->output_section->lineno_count +=
-	    (oeline - finfo->linenos) / linesz;
+	  o->output_section->lineno_count += amt / linesz;
 	}
     }
 
@@ -2277,12 +2280,13 @@ _bfd_coff_link_input_bfd (finfo, input_bfd)
   /* Write the modified symbols to the output file.  */
   if (outsym > finfo->outsyms)
     {
-      if (bfd_seek (output_bfd,
-		    obj_sym_filepos (output_bfd) + syment_base * osymesz,
-		    SEEK_SET) != 0
-	  || (bfd_write (finfo->outsyms, outsym - finfo->outsyms, 1,
-			output_bfd)
-	      != (bfd_size_type) (outsym - finfo->outsyms)))
+      file_ptr pos;
+      bfd_size_type amt;
+
+      pos = obj_sym_filepos (output_bfd) + syment_base * osymesz;
+      amt = outsym - finfo->outsyms;
+      if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
+	  || bfd_bwrite (finfo->outsyms, amt, output_bfd) != amt)
 	return false;
 
       BFD_ASSERT ((obj_raw_syment_count (output_bfd)
@@ -2454,14 +2458,11 @@ _bfd_coff_link_input_bfd (finfo, input_bfd)
       /* Write out the modified section contents.  */
       if (secdata == NULL || secdata->stab_info == NULL)
 	{
+	  file_ptr loc = o->output_offset * bfd_octets_per_byte (output_bfd);
+	  bfd_size_type amt = (o->_cooked_size != 0
+			       ? o->_cooked_size : o->_raw_size);
 	  if (! bfd_set_section_contents (output_bfd, o->output_section,
-					  contents,
-                                          (file_ptr)
-                                          (o->output_offset *
-                                           bfd_octets_per_byte (output_bfd)),
-					  (o->_cooked_size != 0
-					   ? o->_cooked_size
-					   : o->_raw_size)))
+					  contents, loc, amt))
 	    return false;
 	}
       else
@@ -2494,6 +2495,7 @@ _bfd_coff_write_global_sym (h, data)
   struct internal_syment isym;
   bfd_size_type symesz;
   unsigned int i;
+  file_ptr pos;
 
   output_bfd = finfo->output_bfd;
 
@@ -2602,11 +2604,10 @@ _bfd_coff_write_global_sym (h, data)
 
   symesz = bfd_coff_symesz (output_bfd);
 
-  if (bfd_seek (output_bfd,
-		(obj_sym_filepos (output_bfd)
-		 + obj_raw_syment_count (output_bfd) * symesz),
-		SEEK_SET) != 0
-      || bfd_write (finfo->outsyms, symesz, 1, output_bfd) != symesz)
+  pos = obj_sym_filepos (output_bfd);
+  pos += obj_raw_syment_count (output_bfd) * symesz;
+  if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
+      || bfd_bwrite (finfo->outsyms, symesz, output_bfd) != symesz)
     {
       finfo->failed = true;
       return false;
@@ -2674,9 +2675,9 @@ _bfd_coff_write_global_sym (h, data)
 	}
 
       bfd_coff_swap_aux_out (output_bfd, (PTR) auxp, isym.n_type,
-			     isym.n_sclass, i, isym.n_numaux,
+			     isym.n_sclass, (int) i, isym.n_numaux,
 			     (PTR) finfo->outsyms);
-      if (bfd_write (finfo->outsyms, symesz, 1, output_bfd) != symesz)
+      if (bfd_bwrite (finfo->outsyms, symesz, output_bfd) != symesz)
 	{
 	  finfo->failed = true;
 	  return false;
@@ -2744,6 +2745,7 @@ _bfd_coff_reloc_link_order (output_bfd, finfo, output_section, link_order)
       bfd_byte *buf;
       bfd_reloc_status_type rstat;
       boolean ok;
+      file_ptr loc;
 
       size = bfd_get_reloc_size (howto);
       buf = (bfd_byte *) bfd_zmalloc (size);
@@ -2751,7 +2753,8 @@ _bfd_coff_reloc_link_order (output_bfd, finfo, output_section, link_order)
 	return false;
 
       rstat = _bfd_relocate_contents (howto, output_bfd,
-				      link_order->u.reloc.p->addend, buf);
+				      (bfd_vma) link_order->u.reloc.p->addend,\
+				      buf);
       switch (rstat)
 	{
 	case bfd_reloc_ok:
@@ -2774,10 +2777,9 @@ _bfd_coff_reloc_link_order (output_bfd, finfo, output_section, link_order)
 	    }
 	  break;
 	}
+      loc = link_order->offset * bfd_octets_per_byte (output_bfd);
       ok = bfd_set_section_contents (output_bfd, output_section, (PTR) buf,
-				     (file_ptr)
-                                     (link_order->offset *
-                                      bfd_octets_per_byte (output_bfd)), size);
+                                     loc, size);
       free (buf);
       if (! ok)
 	return false;