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, 196 insertions, 240 deletions

diff --git a/bfd/peXXigen.c b/bfd/peXXigen.c
index 957a934..cc2a5ef 100644
--- a/bfd/peXXigen.c
+++ b/bfd/peXXigen.c
@@ -111,22 +111,21 @@ _bfd_XXi_swap_sym_in (abfd, ext1, in1)
   if (ext->e.e_name[0] == 0)
     {
       in->_n._n_n._n_zeroes = 0;
-      in->_n._n_n._n_offset =
-	bfd_h_get_32 (abfd, (bfd_byte *) ext->e.e.e_offset);
+      in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e.e.e_offset);
     }
   else
     memcpy (in->_n._n_name, ext->e.e_name, SYMNMLEN);
 
-  in->n_value = bfd_h_get_32 (abfd, (bfd_byte *) ext->e_value);
-  in->n_scnum = bfd_h_get_16 (abfd, (bfd_byte *) ext->e_scnum);
+  in->n_value = H_GET_32 (abfd, ext->e_value);
+  in->n_scnum = H_GET_16 (abfd, ext->e_scnum);
 
   if (sizeof (ext->e_type) == 2)
-    in->n_type = bfd_h_get_16 (abfd, (bfd_byte *) ext->e_type);
+    in->n_type = H_GET_16 (abfd, ext->e_type);
   else
-    in->n_type = bfd_h_get_32 (abfd, (bfd_byte *) ext->e_type);
+    in->n_type = H_GET_32 (abfd, ext->e_type);
 
-  in->n_sclass = bfd_h_get_8 (abfd, ext->e_sclass);
-  in->n_numaux = bfd_h_get_8 (abfd, ext->e_numaux);
+  in->n_sclass = H_GET_8 (abfd, ext->e_sclass);
+  in->n_numaux = H_GET_8 (abfd, ext->e_numaux);
 
 #ifndef STRICT_PE_FORMAT
   /* This is for Gnu-created DLLs.  */
@@ -184,7 +183,7 @@ _bfd_XXi_swap_sym_in (abfd, ext1, in1)
 	    if (unused_section_number <= sec->target_index)
 	      unused_section_number = sec->target_index + 1;
 
-	  name = bfd_alloc (abfd, strlen (in->n_name) + 10);
+	  name = bfd_alloc (abfd, (bfd_size_type) strlen (in->n_name) + 10);
 	  if (name == NULL)
 	    return;
 	  strcpy (name, in->n_name);
@@ -232,22 +231,22 @@ _bfd_XXi_swap_sym_out (abfd, inp, extp)
 
   if (in->_n._n_name[0] == 0)
     {
-      bfd_h_put_32 (abfd, 0, (bfd_byte *) ext->e.e.e_zeroes);
-      bfd_h_put_32 (abfd, in->_n._n_n._n_offset, (bfd_byte *) ext->e.e.e_offset);
+      H_PUT_32 (abfd, 0, ext->e.e.e_zeroes);
+      H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e.e.e_offset);
     }
   else
     memcpy (ext->e.e_name, in->_n._n_name, SYMNMLEN);
 
-  bfd_h_put_32 (abfd, in->n_value, (bfd_byte *) ext->e_value);
-  bfd_h_put_16 (abfd, in->n_scnum, (bfd_byte *) ext->e_scnum);
+  H_PUT_32 (abfd, in->n_value, ext->e_value);
+  H_PUT_16 (abfd, in->n_scnum, ext->e_scnum);
 
   if (sizeof (ext->e_type) == 2)
-    bfd_h_put_16 (abfd, in->n_type, (bfd_byte *) ext->e_type);
+    H_PUT_16 (abfd, in->n_type, ext->e_type);
   else
-    bfd_h_put_32 (abfd, in->n_type, (bfd_byte *) ext->e_type);
+    H_PUT_32 (abfd, in->n_type, ext->e_type);
 
-  bfd_h_put_8 (abfd, in->n_sclass, ext->e_sclass);
-  bfd_h_put_8 (abfd, in->n_numaux, ext->e_numaux);
+  H_PUT_8 (abfd, in->n_sclass, ext->e_sclass);
+  H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);
 
   return SYMESZ;
 }
@@ -271,8 +270,7 @@ _bfd_XXi_swap_aux_in (abfd, ext1, type, class, indx, numaux, in1)
       if (ext->x_file.x_fname[0] == 0)
 	{
 	  in->x_file.x_n.x_zeroes = 0;
-	  in->x_file.x_n.x_offset =
-	    bfd_h_get_32 (abfd, (bfd_byte *) ext->x_file.x_n.x_offset);
+	  in->x_file.x_n.x_offset = H_GET_32 (abfd, ext->x_file.x_n.x_offset);
 	}
       else
 	memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
@@ -286,19 +284,16 @@ _bfd_XXi_swap_aux_in (abfd, ext1, type, class, indx, numaux, in1)
 	  in->x_scn.x_scnlen = GET_SCN_SCNLEN (abfd, ext);
 	  in->x_scn.x_nreloc = GET_SCN_NRELOC (abfd, ext);
 	  in->x_scn.x_nlinno = GET_SCN_NLINNO (abfd, ext);
-	  in->x_scn.x_checksum =
-	    bfd_h_get_32 (abfd, (bfd_byte *) ext->x_scn.x_checksum);
-	  in->x_scn.x_associated =
-	    bfd_h_get_16 (abfd, (bfd_byte *) ext->x_scn.x_associated);
-	  in->x_scn.x_comdat =
-	    bfd_h_get_8 (abfd, (bfd_byte *) ext->x_scn.x_comdat);
+	  in->x_scn.x_checksum = H_GET_32 (abfd, ext->x_scn.x_checksum);
+	  in->x_scn.x_associated = H_GET_16 (abfd, ext->x_scn.x_associated);
+	  in->x_scn.x_comdat = H_GET_8 (abfd, ext->x_scn.x_comdat);
 	  return;
 	}
       break;
     }
 
-  in->x_sym.x_tagndx.l = bfd_h_get_32 (abfd, (bfd_byte *) ext->x_sym.x_tagndx);
-  in->x_sym.x_tvndx = bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_tvndx);
+  in->x_sym.x_tagndx.l = H_GET_32 (abfd, ext->x_sym.x_tagndx);
+  in->x_sym.x_tvndx = H_GET_16 (abfd, ext->x_sym.x_tvndx);
 
   if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
     {
@@ -308,19 +303,18 @@ _bfd_XXi_swap_aux_in (abfd, ext1, type, class, indx, numaux, in1)
   else
     {
       in->x_sym.x_fcnary.x_ary.x_dimen[0] =
-	bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
+	H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
       in->x_sym.x_fcnary.x_ary.x_dimen[1] =
-	bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
+	H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
       in->x_sym.x_fcnary.x_ary.x_dimen[2] =
-	bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
+	H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
       in->x_sym.x_fcnary.x_ary.x_dimen[3] =
-	bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
+	H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
     }
 
   if (ISFCN (type))
     {
-      in->x_sym.x_misc.x_fsize =
-	bfd_h_get_32 (abfd, (bfd_byte *) ext->x_sym.x_misc.x_fsize);
+      in->x_sym.x_misc.x_fsize = H_GET_32 (abfd, ext->x_sym.x_misc.x_fsize);
     }
   else
     {
@@ -348,10 +342,8 @@ _bfd_XXi_swap_aux_out (abfd, inp, type, class, indx, numaux, extp)
     case C_FILE:
       if (in->x_file.x_fname[0] == 0)
 	{
-	  bfd_h_put_32 (abfd, 0, (bfd_byte *) ext->x_file.x_n.x_zeroes);
-	  bfd_h_put_32 (abfd,
-			in->x_file.x_n.x_offset,
-			(bfd_byte *) ext->x_file.x_n.x_offset);
+	  H_PUT_32 (abfd, 0, ext->x_file.x_n.x_zeroes);
+	  H_PUT_32 (abfd, in->x_file.x_n.x_offset, ext->x_file.x_n.x_offset);
 	}
       else
 	memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
@@ -366,19 +358,16 @@ _bfd_XXi_swap_aux_out (abfd, inp, type, class, indx, numaux, extp)
 	  PUT_SCN_SCNLEN (abfd, in->x_scn.x_scnlen, ext);
 	  PUT_SCN_NRELOC (abfd, in->x_scn.x_nreloc, ext);
 	  PUT_SCN_NLINNO (abfd, in->x_scn.x_nlinno, ext);
-	  bfd_h_put_32 (abfd, in->x_scn.x_checksum,
-			(bfd_byte *) ext->x_scn.x_checksum);
-	  bfd_h_put_16 (abfd, in->x_scn.x_associated,
-			(bfd_byte *) ext->x_scn.x_associated);
-	  bfd_h_put_8 (abfd, in->x_scn.x_comdat,
-		       (bfd_byte *) ext->x_scn.x_comdat);
+	  H_PUT_32 (abfd, in->x_scn.x_checksum, ext->x_scn.x_checksum);
+	  H_PUT_16 (abfd, in->x_scn.x_associated, ext->x_scn.x_associated);
+	  H_PUT_8 (abfd, in->x_scn.x_comdat, ext->x_scn.x_comdat);
 	  return AUXESZ;
 	}
       break;
     }
 
-  bfd_h_put_32 (abfd, in->x_sym.x_tagndx.l, (bfd_byte *) ext->x_sym.x_tagndx);
-  bfd_h_put_16 (abfd, in->x_sym.x_tvndx, (bfd_byte *) ext->x_sym.x_tvndx);
+  H_PUT_32 (abfd, in->x_sym.x_tagndx.l, ext->x_sym.x_tagndx);
+  H_PUT_16 (abfd, in->x_sym.x_tvndx, ext->x_sym.x_tvndx);
 
   if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
     {
@@ -387,19 +376,18 @@ _bfd_XXi_swap_aux_out (abfd, inp, type, class, indx, numaux, extp)
     }
   else
     {
-      bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],
-		    (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
-      bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],
-		    (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
-      bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],
-		    (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
-      bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],
-		    (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
+      H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],
+		ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
+      H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],
+		ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
+      H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],
+		ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
+      H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],
+		ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
     }
 
   if (ISFCN (type))
-    bfd_h_put_32 (abfd, in->x_sym.x_misc.x_fsize,
-		  (bfd_byte *) ext->x_sym.x_misc.x_fsize);
+    H_PUT_32 (abfd, in->x_sym.x_misc.x_fsize, ext->x_sym.x_misc.x_fsize);
   else
     {
       PUT_LNSZ_LNNO (abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext);
@@ -418,7 +406,7 @@ _bfd_XXi_swap_lineno_in (abfd, ext1, in1)
   LINENO *ext = (LINENO *) ext1;
   struct internal_lineno *in = (struct internal_lineno *) in1;
 
-  in->l_addr.l_symndx = bfd_h_get_32 (abfd, (bfd_byte *) ext->l_addr.l_symndx);
+  in->l_addr.l_symndx = H_GET_32 (abfd, ext->l_addr.l_symndx);
   in->l_lnno = GET_LINENO_LNNO (abfd, ext);
 }
 
@@ -430,8 +418,7 @@ _bfd_XXi_swap_lineno_out (abfd, inp, outp)
 {
   struct internal_lineno *in = (struct internal_lineno *) inp;
   struct external_lineno *ext = (struct external_lineno *) outp;
-  bfd_h_put_32 (abfd, in->l_addr.l_symndx, (bfd_byte *)
-	  ext->l_addr.l_symndx);
+  H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx);
 
   PUT_LINENO_LNNO (abfd, in->l_lnno, ext);
   return LINESZ;
@@ -448,48 +435,48 @@ _bfd_XXi_swap_aouthdr_in (abfd, aouthdr_ext1, aouthdr_int1)
   AOUTHDR        *aouthdr_ext = (AOUTHDR *) aouthdr_ext1;
   struct internal_aouthdr *aouthdr_int = (struct internal_aouthdr *)aouthdr_int1;
 
-  aouthdr_int->magic = bfd_h_get_16 (abfd, (bfd_byte *) aouthdr_ext->magic);
-  aouthdr_int->vstamp = bfd_h_get_16 (abfd, (bfd_byte *) aouthdr_ext->vstamp);
-  aouthdr_int->tsize =
-    GET_AOUTHDR_TSIZE (abfd, (bfd_byte *) aouthdr_ext->tsize);
-  aouthdr_int->dsize =
-    GET_AOUTHDR_DSIZE (abfd, (bfd_byte *) aouthdr_ext->dsize);
-  aouthdr_int->bsize =
-    GET_AOUTHDR_BSIZE (abfd, (bfd_byte *) aouthdr_ext->bsize);
-  aouthdr_int->entry =
-    GET_AOUTHDR_ENTRY (abfd, (bfd_byte *) aouthdr_ext->entry);
+  aouthdr_int->magic = H_GET_16 (abfd, aouthdr_ext->magic);
+  aouthdr_int->vstamp = H_GET_16 (abfd, aouthdr_ext->vstamp);
+  aouthdr_int->tsize = GET_AOUTHDR_TSIZE (abfd, aouthdr_ext->tsize);
+  aouthdr_int->dsize = GET_AOUTHDR_DSIZE (abfd, aouthdr_ext->dsize);
+  aouthdr_int->bsize = GET_AOUTHDR_BSIZE (abfd, aouthdr_ext->bsize);
+  aouthdr_int->entry = GET_AOUTHDR_ENTRY (abfd, aouthdr_ext->entry);
   aouthdr_int->text_start =
-    GET_AOUTHDR_TEXT_START (abfd, (bfd_byte *) aouthdr_ext->text_start);
+    GET_AOUTHDR_TEXT_START (abfd, aouthdr_ext->text_start);
 #ifndef COFF_WITH_pep
   /* PE32+ does not have data_start member! */
   aouthdr_int->data_start =
-    GET_AOUTHDR_DATA_START (abfd, (bfd_byte *) aouthdr_ext->data_start);
+    GET_AOUTHDR_DATA_START (abfd, aouthdr_ext->data_start);
 #endif
 
   a = &aouthdr_int->pe;
-  a->ImageBase = GET_OPTHDR_IMAGE_BASE (abfd, (bfd_byte *) src->ImageBase);
-  a->SectionAlignment = bfd_h_get_32 (abfd, (bfd_byte *) src->SectionAlignment);
-  a->FileAlignment = bfd_h_get_32 (abfd, (bfd_byte *) src->FileAlignment);
+  a->ImageBase = GET_OPTHDR_IMAGE_BASE (abfd, src->ImageBase);
+  a->SectionAlignment = H_GET_32 (abfd, src->SectionAlignment);
+  a->FileAlignment = H_GET_32 (abfd, src->FileAlignment);
   a->MajorOperatingSystemVersion =
-    bfd_h_get_16 (abfd, (bfd_byte *) src->MajorOperatingSystemVersion);
+    H_GET_16 (abfd, src->MajorOperatingSystemVersion);
   a->MinorOperatingSystemVersion =
-    bfd_h_get_16 (abfd, (bfd_byte *) src->MinorOperatingSystemVersion);
-  a->MajorImageVersion = bfd_h_get_16 (abfd, (bfd_byte *) src->MajorImageVersion);
-  a->MinorImageVersion = bfd_h_get_16 (abfd, (bfd_byte *) src->MinorImageVersion);
-  a->MajorSubsystemVersion = bfd_h_get_16 (abfd, (bfd_byte *) src->MajorSubsystemVersion);
-  a->MinorSubsystemVersion = bfd_h_get_16 (abfd, (bfd_byte *) src->MinorSubsystemVersion);
-  a->Reserved1 = bfd_h_get_32 (abfd, (bfd_byte *) src->Reserved1);
-  a->SizeOfImage = bfd_h_get_32 (abfd, (bfd_byte *) src->SizeOfImage);
-  a->SizeOfHeaders = bfd_h_get_32 (abfd, (bfd_byte *) src->SizeOfHeaders);
-  a->CheckSum = bfd_h_get_32 (abfd, (bfd_byte *) src->CheckSum);
-  a->Subsystem = bfd_h_get_16 (abfd, (bfd_byte *) src->Subsystem);
-  a->DllCharacteristics = bfd_h_get_16 (abfd, (bfd_byte *) src->DllCharacteristics);
-  a->SizeOfStackReserve = GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, (bfd_byte *) src->SizeOfStackReserve);
-  a->SizeOfStackCommit = GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, (bfd_byte *) src->SizeOfStackCommit);
-  a->SizeOfHeapReserve = GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, (bfd_byte *) src->SizeOfHeapReserve);
-  a->SizeOfHeapCommit = GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, (bfd_byte *) src->SizeOfHeapCommit);
-  a->LoaderFlags = bfd_h_get_32 (abfd, (bfd_byte *) src->LoaderFlags);
-  a->NumberOfRvaAndSizes = bfd_h_get_32 (abfd, (bfd_byte *) src->NumberOfRvaAndSizes);
+    H_GET_16 (abfd, src->MinorOperatingSystemVersion);
+  a->MajorImageVersion = H_GET_16 (abfd, src->MajorImageVersion);
+  a->MinorImageVersion = H_GET_16 (abfd, src->MinorImageVersion);
+  a->MajorSubsystemVersion = H_GET_16 (abfd, src->MajorSubsystemVersion);
+  a->MinorSubsystemVersion = H_GET_16 (abfd, src->MinorSubsystemVersion);
+  a->Reserved1 = H_GET_32 (abfd, src->Reserved1);
+  a->SizeOfImage = H_GET_32 (abfd, src->SizeOfImage);
+  a->SizeOfHeaders = H_GET_32 (abfd, src->SizeOfHeaders);
+  a->CheckSum = H_GET_32 (abfd, src->CheckSum);
+  a->Subsystem = H_GET_16 (abfd, src->Subsystem);
+  a->DllCharacteristics = H_GET_16 (abfd, src->DllCharacteristics);
+  a->SizeOfStackReserve =
+    GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, src->SizeOfStackReserve);
+  a->SizeOfStackCommit =
+    GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, src->SizeOfStackCommit);
+  a->SizeOfHeapReserve =
+    GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, src->SizeOfHeapReserve);
+  a->SizeOfHeapCommit =
+    GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, src->SizeOfHeapCommit);
+  a->LoaderFlags = H_GET_32 (abfd, src->LoaderFlags);
+  a->NumberOfRvaAndSizes = H_GET_32 (abfd, src->NumberOfRvaAndSizes);
 
   {
     int idx;
@@ -498,12 +485,12 @@ _bfd_XXi_swap_aouthdr_in (abfd, aouthdr_ext1, aouthdr_int1)
       {
         /* If data directory is empty, rva also should be 0.  */
 	int size =
-	  bfd_h_get_32 (abfd, (bfd_byte *) src->DataDirectory[idx][1]);
+	  H_GET_32 (abfd, src->DataDirectory[idx][1]);
 	a->DataDirectory[idx].Size = size;
 
 	if (size)
 	  a->DataDirectory[idx].VirtualAddress =
-	    bfd_h_get_32 (abfd, (bfd_byte *) src->DataDirectory[idx][0]);
+	    H_GET_32 (abfd, src->DataDirectory[idx][0]);
 	else
 	  a->DataDirectory[idx].VirtualAddress = 0;
       }
@@ -687,80 +674,67 @@ _bfd_XXi_swap_aouthdr_out (abfd, in, out)
   }
 
   extra->SizeOfHeaders = abfd->sections->filepos;
-  bfd_h_put_16 (abfd, aouthdr_in->magic, (bfd_byte *) aouthdr_out->standard.magic);
+  H_PUT_16 (abfd, aouthdr_in->magic, aouthdr_out->standard.magic);
 
 #define LINKER_VERSION 256 /* That is, 2.56 */
 
   /* This piece of magic sets the "linker version" field to
      LINKER_VERSION.  */
-  bfd_h_put_16 (abfd,
-		LINKER_VERSION / 100 + (LINKER_VERSION % 100) * 256,
-		(bfd_byte *) aouthdr_out->standard.vstamp);
-
-  PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, (bfd_byte *) aouthdr_out->standard.tsize);
-  PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, (bfd_byte *) aouthdr_out->standard.dsize);
-  PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, (bfd_byte *) aouthdr_out->standard.bsize);
-  PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, (bfd_byte *) aouthdr_out->standard.entry);
+  H_PUT_16 (abfd, (LINKER_VERSION / 100 + (LINKER_VERSION % 100) * 256),
+	    aouthdr_out->standard.vstamp);
+
+  PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, aouthdr_out->standard.tsize);
+  PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, aouthdr_out->standard.dsize);
+  PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, aouthdr_out->standard.bsize);
+  PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, aouthdr_out->standard.entry);
   PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
-			  (bfd_byte *) aouthdr_out->standard.text_start);
+			  aouthdr_out->standard.text_start);
 
 #ifndef COFF_WITH_pep
   /* PE32+ does not have data_start member! */
   PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
-			  (bfd_byte *) aouthdr_out->standard.data_start);
+			  aouthdr_out->standard.data_start);
 #endif
 
-  PUT_OPTHDR_IMAGE_BASE (abfd, extra->ImageBase,
-			 (bfd_byte *) aouthdr_out->ImageBase);
-  bfd_h_put_32 (abfd, extra->SectionAlignment,
-		(bfd_byte *) aouthdr_out->SectionAlignment);
-  bfd_h_put_32 (abfd, extra->FileAlignment,
-		(bfd_byte *) aouthdr_out->FileAlignment);
-  bfd_h_put_16 (abfd, extra->MajorOperatingSystemVersion,
-		(bfd_byte *) aouthdr_out->MajorOperatingSystemVersion);
-  bfd_h_put_16 (abfd, extra->MinorOperatingSystemVersion,
-		(bfd_byte *) aouthdr_out->MinorOperatingSystemVersion);
-  bfd_h_put_16 (abfd, extra->MajorImageVersion,
-		(bfd_byte *) aouthdr_out->MajorImageVersion);
-  bfd_h_put_16 (abfd, extra->MinorImageVersion,
-		(bfd_byte *) aouthdr_out->MinorImageVersion);
-  bfd_h_put_16 (abfd, extra->MajorSubsystemVersion,
-		(bfd_byte *) aouthdr_out->MajorSubsystemVersion);
-  bfd_h_put_16 (abfd, extra->MinorSubsystemVersion,
-		(bfd_byte *) aouthdr_out->MinorSubsystemVersion);
-  bfd_h_put_32 (abfd, extra->Reserved1,
-		(bfd_byte *) aouthdr_out->Reserved1);
-  bfd_h_put_32 (abfd, extra->SizeOfImage,
-		(bfd_byte *) aouthdr_out->SizeOfImage);
-  bfd_h_put_32 (abfd, extra->SizeOfHeaders,
-		(bfd_byte *) aouthdr_out->SizeOfHeaders);
-  bfd_h_put_32 (abfd, extra->CheckSum,
-		(bfd_byte *) aouthdr_out->CheckSum);
-  bfd_h_put_16 (abfd, extra->Subsystem,
-		(bfd_byte *) aouthdr_out->Subsystem);
-  bfd_h_put_16 (abfd, extra->DllCharacteristics,
-		(bfd_byte *) aouthdr_out->DllCharacteristics);
+  PUT_OPTHDR_IMAGE_BASE (abfd, extra->ImageBase, aouthdr_out->ImageBase);
+  H_PUT_32 (abfd, extra->SectionAlignment, aouthdr_out->SectionAlignment);
+  H_PUT_32 (abfd, extra->FileAlignment, aouthdr_out->FileAlignment);
+  H_PUT_16 (abfd, extra->MajorOperatingSystemVersion,
+	    aouthdr_out->MajorOperatingSystemVersion);
+  H_PUT_16 (abfd, extra->MinorOperatingSystemVersion,
+	    aouthdr_out->MinorOperatingSystemVersion);
+  H_PUT_16 (abfd, extra->MajorImageVersion, aouthdr_out->MajorImageVersion);
+  H_PUT_16 (abfd, extra->MinorImageVersion, aouthdr_out->MinorImageVersion);
+  H_PUT_16 (abfd, extra->MajorSubsystemVersion,
+	    aouthdr_out->MajorSubsystemVersion);
+  H_PUT_16 (abfd, extra->MinorSubsystemVersion,
+	    aouthdr_out->MinorSubsystemVersion);
+  H_PUT_32 (abfd, extra->Reserved1, aouthdr_out->Reserved1);
+  H_PUT_32 (abfd, extra->SizeOfImage, aouthdr_out->SizeOfImage);
+  H_PUT_32 (abfd, extra->SizeOfHeaders, aouthdr_out->SizeOfHeaders);
+  H_PUT_32 (abfd, extra->CheckSum, aouthdr_out->CheckSum);
+  H_PUT_16 (abfd, extra->Subsystem, aouthdr_out->Subsystem);
+  H_PUT_16 (abfd, extra->DllCharacteristics, aouthdr_out->DllCharacteristics);
   PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, extra->SizeOfStackReserve,
-				    (bfd_byte *) aouthdr_out->SizeOfStackReserve);
+				    aouthdr_out->SizeOfStackReserve);
   PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, extra->SizeOfStackCommit,
-				   (bfd_byte *) aouthdr_out->SizeOfStackCommit);
+				   aouthdr_out->SizeOfStackCommit);
   PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, extra->SizeOfHeapReserve,
-				   (bfd_byte *) aouthdr_out->SizeOfHeapReserve);
+				   aouthdr_out->SizeOfHeapReserve);
   PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, extra->SizeOfHeapCommit,
-				  (bfd_byte *) aouthdr_out->SizeOfHeapCommit);
-  bfd_h_put_32 (abfd, extra->LoaderFlags,
-		(bfd_byte *) aouthdr_out->LoaderFlags);
-  bfd_h_put_32 (abfd, extra->NumberOfRvaAndSizes,
-		(bfd_byte *) aouthdr_out->NumberOfRvaAndSizes);
+				  aouthdr_out->SizeOfHeapCommit);
+  H_PUT_32 (abfd, extra->LoaderFlags, aouthdr_out->LoaderFlags);
+  H_PUT_32 (abfd, extra->NumberOfRvaAndSizes,
+	    aouthdr_out->NumberOfRvaAndSizes);
   {
     int idx;
 
     for (idx = 0; idx < 16; idx++)
       {
-	bfd_h_put_32 (abfd, extra->DataDirectory[idx].VirtualAddress,
-		      (bfd_byte *) aouthdr_out->DataDirectory[idx][0]);
-	bfd_h_put_32 (abfd, extra->DataDirectory[idx].Size,
-		      (bfd_byte *) aouthdr_out->DataDirectory[idx][1]);
+	H_PUT_32 (abfd, extra->DataDirectory[idx].VirtualAddress,
+		  aouthdr_out->DataDirectory[idx][0]);
+	H_PUT_32 (abfd, extra->DataDirectory[idx].Size,
+		  aouthdr_out->DataDirectory[idx][1]);
       }
   }
 
@@ -829,58 +803,51 @@ _bfd_XXi_only_swap_filehdr_out (abfd, in, out)
   filehdr_in->pe.dos_message[15] = 0x0;
   filehdr_in->pe.nt_signature = NT_SIGNATURE;
 
-  bfd_h_put_16 (abfd, filehdr_in->f_magic, (bfd_byte *) filehdr_out->f_magic);
-  bfd_h_put_16 (abfd, filehdr_in->f_nscns, (bfd_byte *) filehdr_out->f_nscns);
+  H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
+  H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
 
-  bfd_h_put_32 (abfd, time (0), (bfd_byte *) filehdr_out->f_timdat);
-  PUT_FILEHDR_SYMPTR (abfd, (bfd_vma) filehdr_in->f_symptr,
-		      (bfd_byte *) filehdr_out->f_symptr);
-  bfd_h_put_32 (abfd, filehdr_in->f_nsyms, (bfd_byte *) filehdr_out->f_nsyms);
-  bfd_h_put_16 (abfd, filehdr_in->f_opthdr, (bfd_byte *) filehdr_out->f_opthdr);
-  bfd_h_put_16 (abfd, filehdr_in->f_flags, (bfd_byte *) filehdr_out->f_flags);
+  H_PUT_32 (abfd, time (0), filehdr_out->f_timdat);
+  PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr,
+		      filehdr_out->f_symptr);
+  H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
+  H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
+  H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
 
   /* Put in extra dos header stuff.  This data remains essentially
      constant, it just has to be tacked on to the beginning of all exes
      for NT.  */
-  bfd_h_put_16 (abfd, filehdr_in->pe.e_magic, (bfd_byte *) filehdr_out->e_magic);
-  bfd_h_put_16 (abfd, filehdr_in->pe.e_cblp, (bfd_byte *) filehdr_out->e_cblp);
-  bfd_h_put_16 (abfd, filehdr_in->pe.e_cp, (bfd_byte *) filehdr_out->e_cp);
-  bfd_h_put_16 (abfd, filehdr_in->pe.e_crlc, (bfd_byte *) filehdr_out->e_crlc);
-  bfd_h_put_16 (abfd, filehdr_in->pe.e_cparhdr,
-	       (bfd_byte *) filehdr_out->e_cparhdr);
-  bfd_h_put_16 (abfd, filehdr_in->pe.e_minalloc,
-	       (bfd_byte *) filehdr_out->e_minalloc);
-  bfd_h_put_16 (abfd, filehdr_in->pe.e_maxalloc,
-	       (bfd_byte *) filehdr_out->e_maxalloc);
-  bfd_h_put_16 (abfd, filehdr_in->pe.e_ss, (bfd_byte *) filehdr_out->e_ss);
-  bfd_h_put_16 (abfd, filehdr_in->pe.e_sp, (bfd_byte *) filehdr_out->e_sp);
-  bfd_h_put_16 (abfd, filehdr_in->pe.e_csum, (bfd_byte *) filehdr_out->e_csum);
-  bfd_h_put_16 (abfd, filehdr_in->pe.e_ip, (bfd_byte *) filehdr_out->e_ip);
-  bfd_h_put_16 (abfd, filehdr_in->pe.e_cs, (bfd_byte *) filehdr_out->e_cs);
-  bfd_h_put_16 (abfd, filehdr_in->pe.e_lfarlc, (bfd_byte *) filehdr_out->e_lfarlc);
-  bfd_h_put_16 (abfd, filehdr_in->pe.e_ovno, (bfd_byte *) filehdr_out->e_ovno);
+  H_PUT_16 (abfd, filehdr_in->pe.e_magic, filehdr_out->e_magic);
+  H_PUT_16 (abfd, filehdr_in->pe.e_cblp, filehdr_out->e_cblp);
+  H_PUT_16 (abfd, filehdr_in->pe.e_cp, filehdr_out->e_cp);
+  H_PUT_16 (abfd, filehdr_in->pe.e_crlc, filehdr_out->e_crlc);
+  H_PUT_16 (abfd, filehdr_in->pe.e_cparhdr, filehdr_out->e_cparhdr);
+  H_PUT_16 (abfd, filehdr_in->pe.e_minalloc, filehdr_out->e_minalloc);
+  H_PUT_16 (abfd, filehdr_in->pe.e_maxalloc, filehdr_out->e_maxalloc);
+  H_PUT_16 (abfd, filehdr_in->pe.e_ss, filehdr_out->e_ss);
+  H_PUT_16 (abfd, filehdr_in->pe.e_sp, filehdr_out->e_sp);
+  H_PUT_16 (abfd, filehdr_in->pe.e_csum, filehdr_out->e_csum);
+  H_PUT_16 (abfd, filehdr_in->pe.e_ip, filehdr_out->e_ip);
+  H_PUT_16 (abfd, filehdr_in->pe.e_cs, filehdr_out->e_cs);
+  H_PUT_16 (abfd, filehdr_in->pe.e_lfarlc, filehdr_out->e_lfarlc);
+  H_PUT_16 (abfd, filehdr_in->pe.e_ovno, filehdr_out->e_ovno);
 
   for (idx = 0; idx < 4; idx++)
-    bfd_h_put_16 (abfd, filehdr_in->pe.e_res[idx],
-		  (bfd_byte *) filehdr_out->e_res[idx]);
+    H_PUT_16 (abfd, filehdr_in->pe.e_res[idx], filehdr_out->e_res[idx]);
 
-  bfd_h_put_16 (abfd, filehdr_in->pe.e_oemid, (bfd_byte *) filehdr_out->e_oemid);
-  bfd_h_put_16 (abfd, filehdr_in->pe.e_oeminfo,
-		(bfd_byte *) filehdr_out->e_oeminfo);
+  H_PUT_16 (abfd, filehdr_in->pe.e_oemid, filehdr_out->e_oemid);
+  H_PUT_16 (abfd, filehdr_in->pe.e_oeminfo, filehdr_out->e_oeminfo);
 
   for (idx = 0; idx < 10; idx++)
-    bfd_h_put_16 (abfd, filehdr_in->pe.e_res2[idx],
-		  (bfd_byte *) filehdr_out->e_res2[idx]);
+    H_PUT_16 (abfd, filehdr_in->pe.e_res2[idx], filehdr_out->e_res2[idx]);
 
-  bfd_h_put_32 (abfd, filehdr_in->pe.e_lfanew, (bfd_byte *) filehdr_out->e_lfanew);
+  H_PUT_32 (abfd, filehdr_in->pe.e_lfanew, filehdr_out->e_lfanew);
 
   for (idx = 0; idx < 16; idx++)
-    bfd_h_put_32 (abfd, filehdr_in->pe.dos_message[idx],
-		  (bfd_byte *) filehdr_out->dos_message[idx]);
+    H_PUT_32 (abfd, filehdr_in->pe.dos_message[idx],
+	      filehdr_out->dos_message[idx]);
 
   /* Also put in the NT signature.  */
-  bfd_h_put_32 (abfd, filehdr_in->pe.nt_signature,
-		(bfd_byte *) filehdr_out->nt_signature);
+  H_PUT_32 (abfd, filehdr_in->pe.nt_signature, filehdr_out->nt_signature);
 
   return FILHSZ;
 }
@@ -894,14 +861,13 @@ _bfd_XX_only_swap_filehdr_out (abfd, in, out)
   struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
   FILHDR *filehdr_out = (FILHDR *) out;
 
-  bfd_h_put_16 (abfd, filehdr_in->f_magic, (bfd_byte *) filehdr_out->f_magic);
-  bfd_h_put_16 (abfd, filehdr_in->f_nscns, (bfd_byte *) filehdr_out->f_nscns);
-  bfd_h_put_32 (abfd, filehdr_in->f_timdat, (bfd_byte *) filehdr_out->f_timdat);
-  PUT_FILEHDR_SYMPTR (abfd, (bfd_vma) filehdr_in->f_symptr,
-		      (bfd_byte *) filehdr_out->f_symptr);
-  bfd_h_put_32 (abfd, filehdr_in->f_nsyms, (bfd_byte *) filehdr_out->f_nsyms);
-  bfd_h_put_16 (abfd, filehdr_in->f_opthdr, (bfd_byte *) filehdr_out->f_opthdr);
-  bfd_h_put_16 (abfd, filehdr_in->f_flags, (bfd_byte *) filehdr_out->f_flags);
+  H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
+  H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
+  H_PUT_32 (abfd, filehdr_in->f_timdat, filehdr_out->f_timdat);
+  PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr, filehdr_out->f_symptr);
+  H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
+  H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
+  H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
 
   return FILHSZ;
 }
@@ -924,7 +890,7 @@ _bfd_XXi_swap_scnhdr_out (abfd, in, out)
 		    ((scnhdr_int->s_vaddr
 		      - pe_data (abfd)->pe_opthdr.ImageBase)
 		     & 0xffffffff),
-		    (bfd_byte *) scnhdr_ext->s_vaddr);
+		    scnhdr_ext->s_vaddr);
 
   /* NT wants the size data to be rounded up to the next
      NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
@@ -941,17 +907,17 @@ _bfd_XXi_swap_scnhdr_out (abfd, in, out)
     }
 
   PUT_SCNHDR_SIZE (abfd, ss,
-		   (bfd_byte *) scnhdr_ext->s_size);
+		   scnhdr_ext->s_size);
 
   /* s_paddr in PE is really the virtual size.  */
-  PUT_SCNHDR_PADDR (abfd, ps, (bfd_byte *) scnhdr_ext->s_paddr);
+  PUT_SCNHDR_PADDR (abfd, ps, scnhdr_ext->s_paddr);
 
   PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,
-		     (bfd_byte *) scnhdr_ext->s_scnptr);
+		     scnhdr_ext->s_scnptr);
   PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,
-		     (bfd_byte *) scnhdr_ext->s_relptr);
+		     scnhdr_ext->s_relptr);
   PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,
-		      (bfd_byte *) scnhdr_ext->s_lnnoptr);
+		      scnhdr_ext->s_lnnoptr);
 
   /* Extra flags must be set when dealing with NT.  All sections should also
      have the IMAGE_SCN_MEM_READ (0x40000000) flag set.  In addition, the
@@ -970,7 +936,7 @@ _bfd_XXi_swap_scnhdr_out (abfd, in, out)
   {
     int flags = scnhdr_int->s_flags;
 
-    bfd_h_put_32 (abfd, flags, (bfd_byte *) scnhdr_ext->s_flags);
+    H_PUT_32 (abfd, flags, scnhdr_ext->s_flags);
   }
 
   if (coff_data (abfd)->link_info
@@ -986,42 +952,37 @@ _bfd_XXi_swap_scnhdr_out (abfd, in, out)
 	 executables, but the 17-th bit has been observed to be there.
 	 Overflow is not an issue: a 4G-line program will overflow a
 	 bunch of other fields long before this!  */
-      bfd_h_put_16 (abfd, scnhdr_int->s_nlnno & 0xffff,
-		    (bfd_byte *) scnhdr_ext->s_nlnno);
-      bfd_h_put_16 (abfd, scnhdr_int->s_nlnno >> 16,
-		    (bfd_byte *) scnhdr_ext->s_nreloc);
+      H_PUT_16 (abfd, (scnhdr_int->s_nlnno & 0xffff), scnhdr_ext->s_nlnno);
+      H_PUT_16 (abfd, (scnhdr_int->s_nlnno >> 16), scnhdr_ext->s_nreloc);
     }
   else
     {
       if (scnhdr_int->s_nlnno <= 0xffff)
-	bfd_h_put_16 (abfd, scnhdr_int->s_nlnno,
-		      (bfd_byte *) scnhdr_ext->s_nlnno);
+	H_PUT_16 (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno);
       else
 	{
 	  (*_bfd_error_handler) (_("%s: line number overflow: 0x%lx > 0xffff"),
 				 bfd_get_filename (abfd),
 				 scnhdr_int->s_nlnno);
 	  bfd_set_error (bfd_error_file_truncated);
-	  bfd_h_put_16 (abfd, 0xffff, (bfd_byte *) scnhdr_ext->s_nlnno);
+	  H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nlnno);
 	  ret = 0;
 	}
 
       if (scnhdr_int->s_nreloc <= 0xffff)
-	bfd_h_put_16 (abfd, scnhdr_int->s_nreloc,
-		      (bfd_byte *) scnhdr_ext->s_nreloc);
+	H_PUT_16 (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc);
       else
 	{
 	  /* PE can deal with large #s of relocs, but not here.  */
-	  bfd_h_put_16 (abfd, 0xffff, (bfd_byte *) scnhdr_ext->s_nreloc);
+	  H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nreloc);
 	  scnhdr_int->s_flags |= IMAGE_SCN_LNK_NRELOC_OVFL;
-	  bfd_h_put_32 (abfd, scnhdr_int->s_flags,
-			(bfd_byte *) scnhdr_ext->s_flags);
+	  H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
 #if 0
 	  (*_bfd_error_handler) (_("%s: reloc overflow 1: 0x%lx > 0xffff"),
 				 bfd_get_filename (abfd),
 				 scnhdr_int->s_nreloc);
 	  bfd_set_error (bfd_error_file_truncated);
-	  bfd_h_put_16 (abfd, 0xffff, (bfd_byte *) scnhdr_ext->s_nreloc);
+	  H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nreloc);
 	  ret = 0;
 #endif
 	}
@@ -1074,6 +1035,7 @@ pe_print_idata (abfd, vfile)
   bfd_size_type datasize = 0;
   bfd_size_type dataoff;
   bfd_size_type i;
+  bfd_size_type amt;
   int onaline = 20;
 
   pe_data_type *pe = pe_data (abfd);
@@ -1135,15 +1097,13 @@ pe_print_idata (abfd, vfile)
       bfd_byte *data = 0;
       int offset;
 
-      data = (bfd_byte *) bfd_malloc ((size_t) bfd_section_size (abfd,
-								 rel_section));
-      if (data == NULL && bfd_section_size (abfd, rel_section) != 0)
+      amt = bfd_section_size (abfd, rel_section);
+      data = (bfd_byte *) bfd_malloc (amt);
+      if (data == NULL && amt != 0)
 	return false;
 
-      bfd_get_section_contents (abfd,
-				rel_section,
-				(PTR) data, 0,
-				bfd_section_size (abfd, rel_section));
+      bfd_get_section_contents (abfd, rel_section, (PTR) data, (bfd_vma) 0,
+				amt);
 
       offset = abfd->start_address - rel_section->vma;
 
@@ -1173,13 +1133,13 @@ pe_print_idata (abfd, vfile)
   fprintf (file,
 	   _("                 Table   Stamp     Chain    Name      Thunk\n"));
 
-  data = (bfd_byte *) bfd_malloc (dataoff + datasize);
+  amt = dataoff + datasize;
+  data = (bfd_byte *) bfd_malloc (amt);
   if (data == NULL)
     return false;
 
   /* Read the whole section.  Some of the fields might be before dataoff.  */
-  if (! bfd_get_section_contents (abfd, section, (PTR) data,
-				  0, dataoff + datasize))
+  if (! bfd_get_section_contents (abfd, section, (PTR) data, (bfd_vma) 0, amt))
     return false;
 
   adj = section->vma - extra->ImageBase;
@@ -1397,8 +1357,8 @@ pe_print_edata (abfd, vfile)
   if (data == NULL)
     return false;
 
-  if (! bfd_get_section_contents (abfd, section, (PTR) data, dataoff,
-				  datasize))
+  if (! bfd_get_section_contents (abfd, section, (PTR) data,
+				  (file_ptr) dataoff, datasize))
     return false;
 
   /* Go get Export Directory Table.  */
@@ -1585,18 +1545,16 @@ pe_print_pdata (abfd, vfile)
 	   _("     \t\tAddress  Address  Handler  Data     Address    Mask\n"));
 #endif
 
-  if (bfd_section_size (abfd, section) == 0)
+  datasize = bfd_section_size (abfd, section);
+  if (datasize == 0)
     return true;
 
-  data = (bfd_byte *) bfd_malloc ((size_t) bfd_section_size (abfd, section));
-  datasize = bfd_section_size (abfd, section);
+  data = (bfd_byte *) bfd_malloc (datasize);
   if (data == NULL && datasize != 0)
     return false;
 
-  bfd_get_section_contents (abfd,
-			    section,
-			    (PTR) data, 0,
-			    bfd_section_size (abfd, section));
+  bfd_get_section_contents (abfd, section, (PTR) data, (bfd_vma) 0,
+			    datasize);
 
   start = 0;
 
@@ -1699,7 +1657,7 @@ pe_print_reloc (abfd, vfile)
   FILE *file = (FILE *) vfile;
   bfd_byte *data = 0;
   asection *section = bfd_get_section_by_name (abfd, ".reloc");
-  bfd_size_type datasize = 0;
+  bfd_size_type datasize;
   bfd_size_type i;
   bfd_size_type start, stop;
 
@@ -1712,15 +1670,13 @@ pe_print_reloc (abfd, vfile)
   fprintf (file,
 	   _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
 
-  data = (bfd_byte *) bfd_malloc ((size_t) bfd_section_size (abfd, section));
   datasize = bfd_section_size (abfd, section);
+  data = (bfd_byte *) bfd_malloc (datasize);
   if (data == NULL && datasize != 0)
     return false;
 
-  bfd_get_section_contents (abfd,
-			    section,
-			    (PTR) data, 0,
-			    bfd_section_size (abfd, section));
+  bfd_get_section_contents (abfd, section, (PTR) data, (bfd_vma) 0,
+			    datasize);
 
   start = 0;
 
@@ -1935,16 +1891,16 @@ _bfd_XX_bfd_copy_private_section_data (ibfd, isec, obfd, osec)
     {
       if (coff_section_data (obfd, osec) == NULL)
 	{
-	  osec->used_by_bfd =
-	    (PTR) bfd_zalloc (obfd, sizeof (struct coff_section_tdata));
+	  bfd_size_type amt = sizeof (struct coff_section_tdata);
+	  osec->used_by_bfd = (PTR) bfd_zalloc (obfd, amt);
 	  if (osec->used_by_bfd == NULL)
 	    return false;
 	}
 
       if (pei_section_data (obfd, osec) == NULL)
 	{
-	  coff_section_data (obfd, osec)->tdata =
-	    (PTR) bfd_zalloc (obfd, sizeof (struct pei_section_tdata));
+	  bfd_size_type amt = sizeof (struct pei_section_tdata);
+	  coff_section_data (obfd, osec)->tdata = (PTR) bfd_zalloc (obfd, amt);
 	  if (coff_section_data (obfd, osec)->tdata == NULL)
 	    return false;
 	}