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, 401 insertions, 407 deletions

diff --git a/bfd/coffswap.h b/bfd/coffswap.h
index 2ff0a3231e..454e686271 100644
--- a/bfd/coffswap.h
+++ b/bfd/coffswap.h
@@ -1,5 +1,6 @@
 /* Generic COFF swapping routines, for BFD.
-   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1999, 2000
+   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1999, 2000,
+   2001
    Free Software Foundation, Inc.
    Written by Cygnus Support.
 
@@ -27,174 +28,186 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
    Any file which uses this must first include "coff/internal.h" and
    "coff/CPU.h".  The functions will then be correct for that CPU.  */
 
-#define PUTWORD bfd_h_put_32
-#define PUTHALF bfd_h_put_16
-#define	PUTBYTE bfd_h_put_8
-
 #ifndef GET_FCN_LNNOPTR
-#define GET_FCN_LNNOPTR(abfd, ext)  bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
+#define GET_FCN_LNNOPTR(abfd, ext) \
+  H_GET_32 (abfd, ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
 #endif
 
 #ifndef GET_FCN_ENDNDX
-#define GET_FCN_ENDNDX(abfd, ext)  bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx)
+#define GET_FCN_ENDNDX(abfd, ext) \
+  H_GET_32 (abfd, ext->x_sym.x_fcnary.x_fcn.x_endndx)
 #endif
 
 #ifndef PUT_FCN_LNNOPTR
-#define PUT_FCN_LNNOPTR(abfd, in, ext)  PUTWORD(abfd,  in, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
+#define PUT_FCN_LNNOPTR(abfd, in, ext) \
+  H_PUT_32 (abfd,  in, ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
 #endif
 #ifndef PUT_FCN_ENDNDX
-#define PUT_FCN_ENDNDX(abfd, in, ext) PUTWORD(abfd, in, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx)
+#define PUT_FCN_ENDNDX(abfd, in, ext) \
+  H_PUT_32 (abfd, in, ext->x_sym.x_fcnary.x_fcn.x_endndx)
 #endif
 #ifndef GET_LNSZ_LNNO
-#define GET_LNSZ_LNNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_misc.x_lnsz.x_lnno)
+#define GET_LNSZ_LNNO(abfd, ext) \
+  H_GET_16 (abfd, ext->x_sym.x_misc.x_lnsz.x_lnno)
 #endif
 #ifndef GET_LNSZ_SIZE
-#define GET_LNSZ_SIZE(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_misc.x_lnsz.x_size)
+#define GET_LNSZ_SIZE(abfd, ext) \
+  H_GET_16 (abfd, ext->x_sym.x_misc.x_lnsz.x_size)
 #endif
 #ifndef PUT_LNSZ_LNNO
-#define PUT_LNSZ_LNNO(abfd, in, ext) bfd_h_put_16(abfd, in, (bfd_byte *)ext->x_sym.x_misc.x_lnsz.x_lnno)
+#define PUT_LNSZ_LNNO(abfd, in, ext) \
+  H_PUT_16 (abfd, in, ext->x_sym.x_misc.x_lnsz.x_lnno)
 #endif
 #ifndef PUT_LNSZ_SIZE
-#define PUT_LNSZ_SIZE(abfd, in, ext) bfd_h_put_16(abfd, in, (bfd_byte*) ext->x_sym.x_misc.x_lnsz.x_size)
+#define PUT_LNSZ_SIZE(abfd, in, ext) \
+  H_PUT_16 (abfd, in, ext->x_sym.x_misc.x_lnsz.x_size)
 #endif
 #ifndef GET_SCN_SCNLEN
-#define GET_SCN_SCNLEN(abfd,  ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_scn.x_scnlen)
+#define GET_SCN_SCNLEN(abfd, ext) \
+  H_GET_32 (abfd, ext->x_scn.x_scnlen)
 #endif
 #ifndef GET_SCN_NRELOC
-#define GET_SCN_NRELOC(abfd,  ext) bfd_h_get_16(abfd, (bfd_byte *)ext->x_scn.x_nreloc)
+#define GET_SCN_NRELOC(abfd, ext) \
+  H_GET_16 (abfd, ext->x_scn.x_nreloc)
 #endif
 #ifndef GET_SCN_NLINNO
-#define GET_SCN_NLINNO(abfd, ext)  bfd_h_get_16(abfd, (bfd_byte *)ext->x_scn.x_nlinno)
+#define GET_SCN_NLINNO(abfd, ext) \
+  H_GET_16 (abfd, ext->x_scn.x_nlinno)
 #endif
 #ifndef PUT_SCN_SCNLEN
-#define PUT_SCN_SCNLEN(abfd,in, ext) bfd_h_put_32(abfd, in, (bfd_byte *) ext->x_scn.x_scnlen)
+#define PUT_SCN_SCNLEN(abfd, in, ext) \
+  H_PUT_32 (abfd, in, ext->x_scn.x_scnlen)
 #endif
 #ifndef PUT_SCN_NRELOC
-#define PUT_SCN_NRELOC(abfd,in, ext) bfd_h_put_16(abfd, in, (bfd_byte *)ext->x_scn.x_nreloc)
+#define PUT_SCN_NRELOC(abfd, in, ext) \
+  H_PUT_16 (abfd, in, ext->x_scn.x_nreloc)
 #endif
 #ifndef PUT_SCN_NLINNO
-#define PUT_SCN_NLINNO(abfd,in, ext)  bfd_h_put_16(abfd,in, (bfd_byte  *) ext->x_scn.x_nlinno)
+#define PUT_SCN_NLINNO(abfd, in, ext) \
+  H_PUT_16 (abfd, in, ext->x_scn.x_nlinno)
 #endif
 #ifndef GET_LINENO_LNNO
-#define GET_LINENO_LNNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) (ext->l_lnno));
+#define GET_LINENO_LNNO(abfd, ext) \
+  H_GET_16 (abfd, ext->l_lnno);
 #endif
 #ifndef PUT_LINENO_LNNO
-#define PUT_LINENO_LNNO(abfd,val, ext) bfd_h_put_16(abfd,val,  (bfd_byte *) (ext->l_lnno));
+#define PUT_LINENO_LNNO(abfd, val, ext) \
+  H_PUT_16 (abfd, val, ext->l_lnno);
 #endif
 
 /* The f_symptr field in the filehdr is sometimes 64 bits.  */
 #ifndef GET_FILEHDR_SYMPTR
-#define GET_FILEHDR_SYMPTR bfd_h_get_32
+#define GET_FILEHDR_SYMPTR H_GET_32
 #endif
 #ifndef PUT_FILEHDR_SYMPTR
-#define PUT_FILEHDR_SYMPTR bfd_h_put_32
+#define PUT_FILEHDR_SYMPTR H_PUT_32
 #endif
 
 /* Some fields in the aouthdr are sometimes 64 bits.  */
 #ifndef GET_AOUTHDR_TSIZE
-#define GET_AOUTHDR_TSIZE bfd_h_get_32
+#define GET_AOUTHDR_TSIZE H_GET_32
 #endif
 #ifndef PUT_AOUTHDR_TSIZE
-#define PUT_AOUTHDR_TSIZE bfd_h_put_32
+#define PUT_AOUTHDR_TSIZE H_PUT_32
 #endif
 #ifndef GET_AOUTHDR_DSIZE
-#define GET_AOUTHDR_DSIZE bfd_h_get_32
+#define GET_AOUTHDR_DSIZE H_GET_32
 #endif
 #ifndef PUT_AOUTHDR_DSIZE
-#define PUT_AOUTHDR_DSIZE bfd_h_put_32
+#define PUT_AOUTHDR_DSIZE H_PUT_32
 #endif
 #ifndef GET_AOUTHDR_BSIZE
-#define GET_AOUTHDR_BSIZE bfd_h_get_32
+#define GET_AOUTHDR_BSIZE H_GET_32
 #endif
 #ifndef PUT_AOUTHDR_BSIZE
-#define PUT_AOUTHDR_BSIZE bfd_h_put_32
+#define PUT_AOUTHDR_BSIZE H_PUT_32
 #endif
 #ifndef GET_AOUTHDR_ENTRY
-#define GET_AOUTHDR_ENTRY bfd_h_get_32
+#define GET_AOUTHDR_ENTRY H_GET_32
 #endif
 #ifndef PUT_AOUTHDR_ENTRY
-#define PUT_AOUTHDR_ENTRY bfd_h_put_32
+#define PUT_AOUTHDR_ENTRY H_PUT_32
 #endif
 #ifndef GET_AOUTHDR_TEXT_START
-#define GET_AOUTHDR_TEXT_START bfd_h_get_32
+#define GET_AOUTHDR_TEXT_START H_GET_32
 #endif
 #ifndef PUT_AOUTHDR_TEXT_START
-#define PUT_AOUTHDR_TEXT_START bfd_h_put_32
+#define PUT_AOUTHDR_TEXT_START H_PUT_32
 #endif
 #ifndef GET_AOUTHDR_DATA_START
-#define GET_AOUTHDR_DATA_START bfd_h_get_32
+#define GET_AOUTHDR_DATA_START H_GET_32
 #endif
 #ifndef PUT_AOUTHDR_DATA_START
-#define PUT_AOUTHDR_DATA_START bfd_h_put_32
+#define PUT_AOUTHDR_DATA_START H_PUT_32
 #endif
 
 /* Some fields in the scnhdr are sometimes 64 bits.  */
 #ifndef GET_SCNHDR_PADDR
-#define GET_SCNHDR_PADDR bfd_h_get_32
+#define GET_SCNHDR_PADDR H_GET_32
 #endif
 #ifndef PUT_SCNHDR_PADDR
-#define PUT_SCNHDR_PADDR bfd_h_put_32
+#define PUT_SCNHDR_PADDR H_PUT_32
 #endif
 #ifndef GET_SCNHDR_VADDR
-#define GET_SCNHDR_VADDR bfd_h_get_32
+#define GET_SCNHDR_VADDR H_GET_32
 #endif
 #ifndef PUT_SCNHDR_VADDR
-#define PUT_SCNHDR_VADDR bfd_h_put_32
+#define PUT_SCNHDR_VADDR H_PUT_32
 #endif
 #ifndef GET_SCNHDR_SIZE
-#define GET_SCNHDR_SIZE bfd_h_get_32
+#define GET_SCNHDR_SIZE H_GET_32
 #endif
 #ifndef PUT_SCNHDR_SIZE
-#define PUT_SCNHDR_SIZE bfd_h_put_32
+#define PUT_SCNHDR_SIZE H_PUT_32
 #endif
 #ifndef GET_SCNHDR_SCNPTR
-#define GET_SCNHDR_SCNPTR bfd_h_get_32
+#define GET_SCNHDR_SCNPTR H_GET_32
 #endif
 #ifndef PUT_SCNHDR_SCNPTR
-#define PUT_SCNHDR_SCNPTR bfd_h_put_32
+#define PUT_SCNHDR_SCNPTR H_PUT_32
 #endif
 #ifndef GET_SCNHDR_RELPTR
-#define GET_SCNHDR_RELPTR bfd_h_get_32
+#define GET_SCNHDR_RELPTR H_GET_32
 #endif
 #ifndef PUT_SCNHDR_RELPTR
-#define PUT_SCNHDR_RELPTR bfd_h_put_32
+#define PUT_SCNHDR_RELPTR H_PUT_32
 #endif
 #ifndef GET_SCNHDR_LNNOPTR
-#define GET_SCNHDR_LNNOPTR bfd_h_get_32
+#define GET_SCNHDR_LNNOPTR H_GET_32
 #endif
 #ifndef PUT_SCNHDR_LNNOPTR
-#define PUT_SCNHDR_LNNOPTR bfd_h_put_32
+#define PUT_SCNHDR_LNNOPTR H_PUT_32
 #endif
 #ifndef GET_SCNHDR_NRELOC
-#define GET_SCNHDR_NRELOC bfd_h_get_16
+#define GET_SCNHDR_NRELOC H_GET_16
 #endif
 #ifndef MAX_SCNHDR_NRELOC
 #define MAX_SCNHDR_NRELOC 0xffff
 #endif
 #ifndef PUT_SCNHDR_NRELOC
-#define PUT_SCNHDR_NRELOC bfd_h_put_16
+#define PUT_SCNHDR_NRELOC H_PUT_16
 #endif
 #ifndef GET_SCNHDR_NLNNO
-#define GET_SCNHDR_NLNNO bfd_h_get_16
+#define GET_SCNHDR_NLNNO H_GET_16
 #endif
 #ifndef MAX_SCNHDR_NLNNO
 #define MAX_SCNHDR_NLNNO 0xffff
 #endif
 #ifndef PUT_SCNHDR_NLNNO
-#define PUT_SCNHDR_NLNNO bfd_h_put_16
+#define PUT_SCNHDR_NLNNO H_PUT_16
 #endif
 #ifndef GET_SCNHDR_FLAGS
-#define GET_SCNHDR_FLAGS bfd_h_get_32
+#define GET_SCNHDR_FLAGS H_GET_32
 #endif
 #ifndef PUT_SCNHDR_FLAGS
-#define PUT_SCNHDR_FLAGS bfd_h_put_32
+#define PUT_SCNHDR_FLAGS H_PUT_32
 #endif
 
 #ifndef GET_RELOC_VADDR
-#define GET_RELOC_VADDR bfd_h_get_32
+#define GET_RELOC_VADDR H_GET_32
 #endif
 #ifndef PUT_RELOC_VADDR
-#define PUT_RELOC_VADDR bfd_h_put_32
+#define PUT_RELOC_VADDR H_PUT_32
 #endif
 
 static void coff_swap_aouthdr_in PARAMS ((bfd *, PTR, PTR));
@@ -229,48 +242,44 @@ coff_swap_reloc_in (abfd, src, dst)
   RELOC *reloc_src = (RELOC *) src;
   struct internal_reloc *reloc_dst = (struct internal_reloc *) dst;
 
-  reloc_dst->r_vaddr = GET_RELOC_VADDR (abfd, (bfd_byte *)reloc_src->r_vaddr);
-  reloc_dst->r_symndx = bfd_h_get_signed_32(abfd, (bfd_byte *) reloc_src->r_symndx);
+  reloc_dst->r_vaddr = GET_RELOC_VADDR (abfd, reloc_src->r_vaddr);
+  reloc_dst->r_symndx = H_GET_S32 (abfd, reloc_src->r_symndx);
 
 #ifdef RS6000COFF_C
-  reloc_dst->r_type = bfd_h_get_8(abfd, reloc_src->r_type);
-  reloc_dst->r_size = bfd_h_get_8(abfd, reloc_src->r_size);
+  reloc_dst->r_type = H_GET_8 (abfd, reloc_src->r_type);
+  reloc_dst->r_size = H_GET_8 (abfd, reloc_src->r_size);
 #else
-  reloc_dst->r_type = bfd_h_get_16(abfd, (bfd_byte *) reloc_src->r_type);
+  reloc_dst->r_type = H_GET_16 (abfd, reloc_src->r_type);
 #endif
 
 #ifdef SWAP_IN_RELOC_OFFSET
-  reloc_dst->r_offset = SWAP_IN_RELOC_OFFSET(abfd,
-					     (bfd_byte *) reloc_src->r_offset);
+  reloc_dst->r_offset = SWAP_IN_RELOC_OFFSET (abfd, reloc_src->r_offset);
 #endif
 }
 
 static unsigned int
 coff_swap_reloc_out (abfd, src, dst)
-     bfd       *abfd;
-     PTR	src;
-     PTR	dst;
+     bfd *abfd;
+     PTR src;
+     PTR dst;
 {
-  struct internal_reloc *reloc_src = (struct internal_reloc *)src;
-  struct external_reloc *reloc_dst = (struct external_reloc *)dst;
-  PUT_RELOC_VADDR (abfd, reloc_src->r_vaddr, (bfd_byte *) reloc_dst->r_vaddr);
-  bfd_h_put_32(abfd, reloc_src->r_symndx, (bfd_byte *) reloc_dst->r_symndx);
+  struct internal_reloc *reloc_src = (struct internal_reloc *) src;
+  struct external_reloc *reloc_dst = (struct external_reloc *) dst;
+  PUT_RELOC_VADDR (abfd, reloc_src->r_vaddr, reloc_dst->r_vaddr);
+  H_PUT_32 (abfd, reloc_src->r_symndx, reloc_dst->r_symndx);
 
 #ifdef RS6000COFF_C
-  bfd_h_put_8 (abfd, reloc_src->r_type, (bfd_byte *) reloc_dst->r_type);
-  bfd_h_put_8 (abfd, reloc_src->r_size, (bfd_byte *) reloc_dst->r_size);
+  H_PUT_8 (abfd, reloc_src->r_type, reloc_dst->r_type);
+  H_PUT_8 (abfd, reloc_src->r_size, reloc_dst->r_size);
 #else
-  bfd_h_put_16(abfd, reloc_src->r_type, (bfd_byte *)
-	       reloc_dst->r_type);
+  H_PUT_16 (abfd, reloc_src->r_type, reloc_dst->r_type);
 #endif
 
 #ifdef SWAP_OUT_RELOC_OFFSET
-  SWAP_OUT_RELOC_OFFSET(abfd,
-			reloc_src->r_offset,
-			(bfd_byte *) reloc_dst->r_offset);
+  SWAP_OUT_RELOC_OFFSET (abfd, reloc_src->r_offset, reloc_dst->r_offset);
 #endif
 #ifdef SWAP_OUT_RELOC_EXTRA
-  SWAP_OUT_RELOC_EXTRA(abfd,reloc_src, reloc_dst);
+  SWAP_OUT_RELOC_EXTRA (abfd, reloc_src, reloc_dst);
 #endif
 
   return bfd_coff_relsz (abfd);
@@ -280,9 +289,9 @@ coff_swap_reloc_out (abfd, src, dst)
 
 static void
 coff_swap_filehdr_in (abfd, src, dst)
-     bfd            *abfd;
-     PTR	     src;
-     PTR	     dst;
+     bfd *abfd;
+     PTR src;
+     PTR dst;
 {
   FILHDR *filehdr_src = (FILHDR *) src;
   struct internal_filehdr *filehdr_dst = (struct internal_filehdr *) dst;
@@ -290,16 +299,15 @@ coff_swap_filehdr_in (abfd, src, dst)
 #ifdef COFF_ADJUST_FILEHDR_IN_PRE
   COFF_ADJUST_FILEHDR_IN_PRE (abfd, src, dst);
 #endif
-  filehdr_dst->f_magic = bfd_h_get_16(abfd, (bfd_byte *) filehdr_src->f_magic);
-  filehdr_dst->f_nscns = bfd_h_get_16(abfd, (bfd_byte *)filehdr_src-> f_nscns);
-  filehdr_dst->f_timdat = bfd_h_get_32(abfd, (bfd_byte *)filehdr_src-> f_timdat);
-  filehdr_dst->f_symptr =
-    GET_FILEHDR_SYMPTR (abfd, (bfd_byte *) filehdr_src->f_symptr);
-  filehdr_dst->f_nsyms = bfd_h_get_32(abfd, (bfd_byte *)filehdr_src-> f_nsyms);
-  filehdr_dst->f_opthdr = bfd_h_get_16(abfd, (bfd_byte *)filehdr_src-> f_opthdr);
-  filehdr_dst->f_flags = bfd_h_get_16(abfd, (bfd_byte *)filehdr_src-> f_flags);
+  filehdr_dst->f_magic = H_GET_16 (abfd, filehdr_src->f_magic);
+  filehdr_dst->f_nscns = H_GET_16 (abfd, filehdr_src->f_nscns);
+  filehdr_dst->f_timdat = H_GET_32 (abfd, filehdr_src->f_timdat);
+  filehdr_dst->f_symptr = GET_FILEHDR_SYMPTR (abfd, filehdr_src->f_symptr);
+  filehdr_dst->f_nsyms = H_GET_32 (abfd, filehdr_src->f_nsyms);
+  filehdr_dst->f_opthdr = H_GET_16 (abfd, filehdr_src->f_opthdr);
+  filehdr_dst->f_flags = H_GET_16 (abfd, filehdr_src->f_flags);
 #ifdef TIC80_TARGET_ID
-  filehdr_dst->f_target_id = bfd_h_get_16(abfd, (bfd_byte *)filehdr_src-> f_target_id);
+  filehdr_dst->f_target_id = H_GET_16 (abfd, filehdr_src->f_target_id);
 #endif
 
 #ifdef COFF_ADJUST_FILEHDR_IN_POST
@@ -309,26 +317,25 @@ coff_swap_filehdr_in (abfd, src, dst)
 
 static  unsigned int
 coff_swap_filehdr_out (abfd, in, out)
-     bfd       *abfd;
-     PTR	in;
-     PTR	out;
+     bfd *abfd;
+     PTR in;
+     PTR out;
 {
-  struct internal_filehdr *filehdr_in = (struct internal_filehdr *)in;
-  FILHDR *filehdr_out = (FILHDR *)out;
+  struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
+  FILHDR *filehdr_out = (FILHDR *) out;
 
 #ifdef COFF_ADJUST_FILEHDR_OUT_PRE
   COFF_ADJUST_FILEHDR_OUT_PRE (abfd, in, out);
 #endif
-  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);
 #ifdef TIC80_TARGET_ID
-  bfd_h_put_16(abfd, filehdr_in->f_target_id, (bfd_byte *) filehdr_out->f_target_id);
+  H_PUT_16 (abfd, filehdr_in->f_target_id, filehdr_out->f_target_id);
 #endif
 
 #ifdef COFF_ADJUST_FILEHDR_OUT_POST
@@ -341,34 +348,38 @@ coff_swap_filehdr_out (abfd, in, out)
 
 static void
 coff_swap_sym_in (abfd, ext1, in1)
-     bfd            *abfd;
+     bfd *abfd;
      PTR ext1;
      PTR in1;
 {
-  SYMENT *ext = (SYMENT *)ext1;
-  struct internal_syment      *in = (struct internal_syment *)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);
-  }
-  else {
+  SYMENT *ext = (SYMENT *) ext1;
+  struct internal_syment *in = (struct internal_syment *) in1;
+
+  if (ext->e.e_name[0] == 0)
+    {
+      in->_n._n_n._n_zeroes = 0;
+      in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e.e.e_offset);
+    }
+  else
+    {
 #if SYMNMLEN != E_SYMNMLEN
-   -> Error, we need to cope with truncating or extending SYMNMLEN!;
+      -> Error, we need to cope with truncating or extending SYMNMLEN!;
 #else
-    memcpy(in->_n._n_name, ext->e.e_name, SYMNMLEN);
-#endif
-  }
-  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);
-  if (sizeof (ext->e_type) == 2){
-    in->n_type = bfd_h_get_16(abfd, (bfd_byte *) ext->e_type);
-  }
-  else {
-    in->n_type = bfd_h_get_32(abfd, (bfd_byte *) 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);
+      memcpy (in->_n._n_name, ext->e.e_name, SYMNMLEN);
+#endif
+    }
+  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 = H_GET_16 (abfd, ext->e_type);
+    }
+  else
+    {
+      in->n_type = H_GET_32 (abfd, ext->e_type);
+    }
+  in->n_sclass = H_GET_8 (abfd, ext->e_sclass);
+  in->n_numaux = H_GET_8 (abfd, ext->e_numaux);
 #ifdef COFF_ADJUST_SYM_IN_POST
   COFF_ADJUST_SYM_IN_POST (abfd, ext1, in1);
 #endif
@@ -376,35 +387,37 @@ coff_swap_sym_in (abfd, ext1, in1)
 
 static unsigned int
 coff_swap_sym_out (abfd, inp, extp)
-     bfd       *abfd;
-     PTR	inp;
-     PTR	extp;
+     bfd *abfd;
+     PTR inp;
+     PTR extp;
 {
-  struct internal_syment *in = (struct internal_syment *)inp;
-  SYMENT *ext =(SYMENT *)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);
-  }
-  else {
+  struct internal_syment *in = (struct internal_syment *) inp;
+  SYMENT *ext =(SYMENT *) extp;
+  if(in->_n._n_name[0] == 0)
+    {
+      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
+    {
 #if SYMNMLEN != E_SYMNMLEN
-    -> Error, we need to cope with truncating or extending SYMNMLEN!;
+      -> Error, we need to cope with truncating or extending SYMNMLEN!;
 #else
-    memcpy(ext->e.e_name, in->_n._n_name, SYMNMLEN);
+      memcpy(ext->e.e_name, in->_n._n_name, SYMNMLEN);
 #endif
-  }
-  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);
-      }
-  bfd_h_put_8(abfd,  in->n_sclass , ext->e_sclass);
-  bfd_h_put_8(abfd,  in->n_numaux , ext->e_numaux);
+    {
+      H_PUT_32 (abfd, in->n_type, ext->e_type);
+    }
+  H_PUT_8 (abfd, in->n_sclass, ext->e_sclass);
+  H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);
 #ifdef COFF_ADJUST_SYM_OUT_POST
   COFF_ADJUST_SYM_OUT_POST (abfd, inp, extp);
 #endif
@@ -413,42 +426,45 @@ coff_swap_sym_out (abfd, inp, extp)
 
 static void
 coff_swap_aux_in (abfd, ext1, type, class, indx, numaux, in1)
-     bfd            *abfd;
-     PTR 	      ext1;
-     int             type;
-     int             class;
-     int	      indx;
-     int	      numaux;
-     PTR 	      in1;
+     bfd *abfd;
+     PTR ext1;
+     int type;
+     int class;
+     int indx;
+     int numaux;
+     PTR in1;
 {
-  AUXENT    *ext = (AUXENT *)ext1;
-  union internal_auxent *in = (union internal_auxent *)in1;
+  AUXENT *ext = (AUXENT *) ext1;
+  union internal_auxent *in = (union internal_auxent *) in1;
 
 #ifdef COFF_ADJUST_AUX_IN_PRE
   COFF_ADJUST_AUX_IN_PRE (abfd, ext1, type, class, indx, numaux, in1);
 #endif
-  switch (class) {
+  switch (class)
+    {
     case C_FILE:
-      if (ext->x_file.x_fname[0] == 0) {
+      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);
-	} else {
+	  in->x_file.x_n.x_offset = H_GET_32 (abfd, ext->x_file.x_n.x_offset);
+	}
+      else
+	{
 #if FILNMLEN != E_FILNMLEN
-	    -> Error, we need to cope with truncating or extending FILNMLEN!;
+	  -> Error, we need to cope with truncating or extending FILNMLEN!;
 #else
-	    if (numaux > 1)
-	      {
-		if (indx == 0)
-		  memcpy (in->x_file.x_fname, ext->x_file.x_fname,
-			  numaux * sizeof (AUXENT));
-	      }
-	    else
-	      {
-		memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
-	      }
-#endif
-	  }
+	  if (numaux > 1)
+	    {
+	      if (indx == 0)
+		memcpy (in->x_file.x_fname, ext->x_file.x_fname,
+			numaux * sizeof (AUXENT));
+	    }
+	  else
+	    {
+	      memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
+	    }
+#endif
+	}
       goto end;
 
     case C_STAT:
@@ -456,10 +472,11 @@ coff_swap_aux_in (abfd, ext1, type, class, indx, numaux, in1)
     case C_LEAFSTAT:
 #endif
     case C_HIDDEN:
-      if (type == T_NULL) {
-	  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);
+      if (type == T_NULL)
+	{
+	  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);
 
 	  /* PE defines some extra fields; we zero them out for
              safety.  */
@@ -472,9 +489,9 @@ coff_swap_aux_in (abfd, ext1, type, class, indx, numaux, in1)
       break;
     }
 
-  in->x_sym.x_tagndx.l = bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_tagndx);
+  in->x_sym.x_tagndx.l = H_GET_32 (abfd, ext->x_sym.x_tagndx);
 #ifndef NO_TVNDX
-  in->x_sym.x_tvndx = bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_tvndx);
+  in->x_sym.x_tvndx = H_GET_16 (abfd, ext->x_sym.x_tvndx);
 #endif
 
   if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
@@ -485,29 +502,29 @@ coff_swap_aux_in (abfd, ext1, type, class, indx, numaux, in1)
   else
     {
 #if DIMNUM != E_DIMNUM
- #error we need to cope with truncating or extending DIMNUM
+#error we need to cope with truncating or extending DIMNUM
 #endif
       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);
-  }
-  else {
-    in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO(abfd, ext);
-    in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE(abfd, ext);
-  }
+  if (ISFCN(type))
+    {
+      in->x_sym.x_misc.x_fsize = H_GET_32 (abfd, ext->x_sym.x_misc.x_fsize);
+    }
+  else
+    {
+      in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO (abfd, ext);
+      in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE (abfd, ext);
+    }
 
-end: ;
-  /* the semicolon is because MSVC doesn't like labels at
-     end of block.  */
+ end: ;
 
 #ifdef COFF_ADJUST_AUX_IN_POST
   COFF_ADJUST_AUX_IN_POST (abfd, ext1, type, class, indx, numaux, in1);
@@ -516,87 +533,88 @@ end: ;
 
 static unsigned int
 coff_swap_aux_out (abfd, inp, type, class, indx, numaux, extp)
-     bfd   *abfd;
-     PTR 	inp;
-     int   type;
-     int   class;
-     int   indx ATTRIBUTE_UNUSED;
-     int   numaux ATTRIBUTE_UNUSED;
-     PTR	extp;
+     bfd *abfd;
+     PTR inp;
+     int type;
+     int class;
+     int indx ATTRIBUTE_UNUSED;
+     int numaux ATTRIBUTE_UNUSED;
+     PTR extp;
 {
-  union internal_auxent *in = (union internal_auxent *)inp;
-  AUXENT *ext = (AUXENT *)extp;
+  union internal_auxent *in = (union internal_auxent *) inp;
+  AUXENT *ext = (AUXENT *) extp;
 
 #ifdef COFF_ADJUST_AUX_OUT_PRE
   COFF_ADJUST_AUX_OUT_PRE (abfd, inp, type, class, indx, numaux, extp);
 #endif
   memset((PTR)ext, 0, AUXESZ);
-  switch (class) {
-  case C_FILE:
-    if (in->x_file.x_fname[0] == 0) {
-      PUTWORD(abfd, 0, (bfd_byte *) ext->x_file.x_n.x_zeroes);
-      PUTWORD(abfd,
-	      in->x_file.x_n.x_offset,
-	      (bfd_byte *) ext->x_file.x_n.x_offset);
-    }
-    else {
+  switch (class)
+    {
+    case C_FILE:
+      if (in->x_file.x_fname[0] == 0)
+	{
+	  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
+	{
 #if FILNMLEN != E_FILNMLEN
-      -> Error, we need to cope with truncating or extending FILNMLEN!;
+	  -> Error, we need to cope with truncating or extending FILNMLEN!;
 #else
-      memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
+	  memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
 #endif
-    }
-    goto end;
+	}
+      goto end;
 
-  case C_STAT:
+    case C_STAT:
 #ifdef C_LEAFSTAT
-  case C_LEAFSTAT:
+    case C_LEAFSTAT:
 #endif
-  case C_HIDDEN:
-    if (type == T_NULL) {
-      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);
-      goto end;
+    case C_HIDDEN:
+      if (type == T_NULL)
+	{
+	  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);
+	  goto end;
+	}
+      break;
     }
-    break;
-  }
 
-  PUTWORD(abfd, in->x_sym.x_tagndx.l, (bfd_byte *) ext->x_sym.x_tagndx);
+  H_PUT_32 (abfd, in->x_sym.x_tagndx.l, ext->x_sym.x_tagndx);
 #ifndef NO_TVNDX
-  bfd_h_put_16(abfd, in->x_sym.x_tvndx , (bfd_byte *) ext->x_sym.x_tvndx);
+  H_PUT_16 (abfd, in->x_sym.x_tvndx, ext->x_sym.x_tvndx);
 #endif
 
   if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
     {
-      PUT_FCN_LNNOPTR(abfd,  in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext);
-      PUT_FCN_ENDNDX(abfd,  in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext);
+      PUT_FCN_LNNOPTR (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext);
+      PUT_FCN_ENDNDX (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext);
     }
   else
     {
 #if DIMNUM != E_DIMNUM
- #error we need to cope with truncating or extending DIMNUM
-#endif
-      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]);
+#error we need to cope with truncating or extending DIMNUM
+#endif
+      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))
-    PUTWORD (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);
       PUT_LNSZ_SIZE (abfd, in->x_sym.x_misc.x_lnsz.x_size, ext);
     }
 
-end:
+ end:
 #ifdef COFF_ADJUST_AUX_OUT_POST
   COFF_ADJUST_AUX_OUT_POST (abfd, inp, type, class, indx, numaux, extp);
 #endif
@@ -609,27 +627,26 @@ end:
 
 static void
 coff_swap_lineno_in (abfd, ext1, in1)
-     bfd            *abfd;
+     bfd *abfd;
      PTR ext1;
      PTR in1;
 {
-  LINENO *ext = (LINENO *)ext1;
-  struct internal_lineno      *in = (struct internal_lineno *)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_lnno = GET_LINENO_LNNO(abfd, ext);
+  in->l_addr.l_symndx = H_GET_32 (abfd, ext->l_addr.l_symndx);
+  in->l_lnno = GET_LINENO_LNNO (abfd, ext);
 }
 
 static unsigned int
 coff_swap_lineno_out (abfd, inp, outp)
-     bfd       *abfd;
-     PTR	inp;
-     PTR	outp;
+     bfd *abfd;
+     PTR inp;
+     PTR outp;
 {
-  struct internal_lineno *in = (struct internal_lineno *)inp;
-  struct external_lineno *ext = (struct external_lineno *)outp;
-  PUTWORD(abfd, in->l_addr.l_symndx, (bfd_byte *)
-	  ext->l_addr.l_symndx);
+  struct internal_lineno *in = (struct internal_lineno *) inp;
+  struct external_lineno *ext = (struct external_lineno *) outp;
+  H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx);
 
   PUT_LINENO_LNNO (abfd, in->l_lnno, ext);
   return LINESZ;
@@ -639,128 +656,126 @@ coff_swap_lineno_out (abfd, inp, outp)
 
 static void
 coff_swap_aouthdr_in (abfd, aouthdr_ext1, aouthdr_int1)
-     bfd            *abfd;
+     bfd *abfd;
      PTR aouthdr_ext1;
      PTR 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 *aouthdr_ext;
+  struct internal_aouthdr *aouthdr_int;
+
+  aouthdr_ext = (AOUTHDR *) aouthdr_ext1;
+  aouthdr_int = (struct internal_aouthdr *) aouthdr_int1;
+  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);
   aouthdr_int->data_start =
-    GET_AOUTHDR_DATA_START (abfd, (bfd_byte *) aouthdr_ext->data_start);
+    GET_AOUTHDR_DATA_START (abfd, aouthdr_ext->data_start);
 
 #ifdef I960
-  aouthdr_int->tagentries = bfd_h_get_32(abfd, (bfd_byte *) aouthdr_ext->tagentries);
+  aouthdr_int->tagentries = H_GET_32 (abfd, aouthdr_ext->tagentries);
 #endif
 
 #ifdef APOLLO_M68
-  bfd_h_put_32(abfd, aouthdr_int->o_inlib, (bfd_byte *) aouthdr_ext->o_inlib);
-  bfd_h_put_32(abfd, aouthdr_int->o_sri, (bfd_byte *) aouthdr_ext->o_sri);
-  bfd_h_put_32(abfd, aouthdr_int->vid[0], (bfd_byte *) aouthdr_ext->vid);
-  bfd_h_put_32(abfd, aouthdr_int->vid[1], (bfd_byte *) aouthdr_ext->vid + 4);
+  H_PUT_32 (abfd, aouthdr_int->o_inlib, aouthdr_ext->o_inlib);
+  H_PUT_32 (abfd, aouthdr_int->o_sri, aouthdr_ext->o_sri);
+  H_PUT_32 (abfd, aouthdr_int->vid[0], aouthdr_ext->vid);
+  H_PUT_32 (abfd, aouthdr_int->vid[1], aouthdr_ext->vid + 4);
 #endif
 
 #ifdef RS6000COFF_C
 #ifdef XCOFF64
-  aouthdr_int->o_toc = bfd_h_get_64(abfd, aouthdr_ext->o_toc);
+  aouthdr_int->o_toc = H_GET_64 (abfd, aouthdr_ext->o_toc);
 #else
-  aouthdr_int->o_toc = bfd_h_get_32(abfd, aouthdr_ext->o_toc);
-#endif
-  aouthdr_int->o_snentry = bfd_h_get_16(abfd, aouthdr_ext->o_snentry);
-  aouthdr_int->o_sntext = bfd_h_get_16(abfd, aouthdr_ext->o_sntext);
-  aouthdr_int->o_sndata = bfd_h_get_16(abfd, aouthdr_ext->o_sndata);
-  aouthdr_int->o_sntoc = bfd_h_get_16(abfd, aouthdr_ext->o_sntoc);
-  aouthdr_int->o_snloader = bfd_h_get_16(abfd, aouthdr_ext->o_snloader);
-  aouthdr_int->o_snbss = bfd_h_get_16(abfd, aouthdr_ext->o_snbss);
-  aouthdr_int->o_algntext = bfd_h_get_16(abfd, aouthdr_ext->o_algntext);
-  aouthdr_int->o_algndata = bfd_h_get_16(abfd, aouthdr_ext->o_algndata);
-  aouthdr_int->o_modtype = bfd_h_get_16(abfd, aouthdr_ext->o_modtype);
-  aouthdr_int->o_cputype = bfd_h_get_16(abfd, aouthdr_ext->o_cputype);
+  aouthdr_int->o_toc = H_GET_32 (abfd, aouthdr_ext->o_toc);
+#endif
+  aouthdr_int->o_snentry = H_GET_16 (abfd, aouthdr_ext->o_snentry);
+  aouthdr_int->o_sntext = H_GET_16 (abfd, aouthdr_ext->o_sntext);
+  aouthdr_int->o_sndata = H_GET_16 (abfd, aouthdr_ext->o_sndata);
+  aouthdr_int->o_sntoc = H_GET_16 (abfd, aouthdr_ext->o_sntoc);
+  aouthdr_int->o_snloader = H_GET_16 (abfd, aouthdr_ext->o_snloader);
+  aouthdr_int->o_snbss = H_GET_16 (abfd, aouthdr_ext->o_snbss);
+  aouthdr_int->o_algntext = H_GET_16 (abfd, aouthdr_ext->o_algntext);
+  aouthdr_int->o_algndata = H_GET_16 (abfd, aouthdr_ext->o_algndata);
+  aouthdr_int->o_modtype = H_GET_16 (abfd, aouthdr_ext->o_modtype);
+  aouthdr_int->o_cputype = H_GET_16 (abfd, aouthdr_ext->o_cputype);
 #ifdef XCOFF64
-  aouthdr_int->o_maxstack = bfd_h_get_64(abfd, aouthdr_ext->o_maxstack);
-  aouthdr_int->o_maxdata = bfd_h_get_64(abfd, aouthdr_ext->o_maxdata);
+  aouthdr_int->o_maxstack = H_GET_64 (abfd, aouthdr_ext->o_maxstack);
+  aouthdr_int->o_maxdata = H_GET_64 (abfd, aouthdr_ext->o_maxdata);
 #else
-  aouthdr_int->o_maxstack = bfd_h_get_32(abfd, aouthdr_ext->o_maxstack);
-  aouthdr_int->o_maxdata = bfd_h_get_32(abfd, aouthdr_ext->o_maxdata);
+  aouthdr_int->o_maxstack = H_GET_32 (abfd, aouthdr_ext->o_maxstack);
+  aouthdr_int->o_maxdata = H_GET_32 (abfd, aouthdr_ext->o_maxdata);
 #endif
 #endif
 
 #ifdef MIPSECOFF
-  aouthdr_int->bss_start = bfd_h_get_32(abfd, aouthdr_ext->bss_start);
-  aouthdr_int->gp_value = bfd_h_get_32(abfd, aouthdr_ext->gp_value);
-  aouthdr_int->gprmask = bfd_h_get_32(abfd, aouthdr_ext->gprmask);
-  aouthdr_int->cprmask[0] = bfd_h_get_32(abfd, aouthdr_ext->cprmask[0]);
-  aouthdr_int->cprmask[1] = bfd_h_get_32(abfd, aouthdr_ext->cprmask[1]);
-  aouthdr_int->cprmask[2] = bfd_h_get_32(abfd, aouthdr_ext->cprmask[2]);
-  aouthdr_int->cprmask[3] = bfd_h_get_32(abfd, aouthdr_ext->cprmask[3]);
+  aouthdr_int->bss_start = H_GET_32 (abfd, aouthdr_ext->bss_start);
+  aouthdr_int->gp_value = H_GET_32 (abfd, aouthdr_ext->gp_value);
+  aouthdr_int->gprmask = H_GET_32 (abfd, aouthdr_ext->gprmask);
+  aouthdr_int->cprmask[0] = H_GET_32 (abfd, aouthdr_ext->cprmask[0]);
+  aouthdr_int->cprmask[1] = H_GET_32 (abfd, aouthdr_ext->cprmask[1]);
+  aouthdr_int->cprmask[2] = H_GET_32 (abfd, aouthdr_ext->cprmask[2]);
+  aouthdr_int->cprmask[3] = H_GET_32 (abfd, aouthdr_ext->cprmask[3]);
 #endif
 
 #ifdef ALPHAECOFF
-  aouthdr_int->bss_start = bfd_h_get_64(abfd, aouthdr_ext->bss_start);
-  aouthdr_int->gp_value = bfd_h_get_64(abfd, aouthdr_ext->gp_value);
-  aouthdr_int->gprmask = bfd_h_get_32(abfd, aouthdr_ext->gprmask);
-  aouthdr_int->fprmask = bfd_h_get_32(abfd, aouthdr_ext->fprmask);
+  aouthdr_int->bss_start = H_GET_64 (abfd, aouthdr_ext->bss_start);
+  aouthdr_int->gp_value = H_GET_64 (abfd, aouthdr_ext->gp_value);
+  aouthdr_int->gprmask = H_GET_32 (abfd, aouthdr_ext->gprmask);
+  aouthdr_int->fprmask = H_GET_32 (abfd, aouthdr_ext->fprmask);
 #endif
 }
 
 static unsigned int
 coff_swap_aouthdr_out (abfd, in, out)
-     bfd       *abfd;
-     PTR	in;
-     PTR	out;
+     bfd *abfd;
+     PTR in;
+     PTR out;
 {
-  struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *)in;
-  AOUTHDR *aouthdr_out = (AOUTHDR *)out;
-
-  bfd_h_put_16(abfd, aouthdr_in->magic, (bfd_byte *) aouthdr_out->magic);
-  bfd_h_put_16(abfd, aouthdr_in->vstamp, (bfd_byte *) aouthdr_out->vstamp);
-  PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, (bfd_byte *) aouthdr_out->tsize);
-  PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, (bfd_byte *) aouthdr_out->dsize);
-  PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, (bfd_byte *) aouthdr_out->bsize);
-  PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, (bfd_byte *) aouthdr_out->entry);
+  struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *) in;
+  AOUTHDR *aouthdr_out = (AOUTHDR *) out;
+
+  H_PUT_16 (abfd, aouthdr_in->magic, aouthdr_out->magic);
+  H_PUT_16 (abfd, aouthdr_in->vstamp, aouthdr_out->vstamp);
+  PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, aouthdr_out->tsize);
+  PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, aouthdr_out->dsize);
+  PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, aouthdr_out->bsize);
+  PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, aouthdr_out->entry);
   PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
-			  (bfd_byte *) aouthdr_out->text_start);
+			  aouthdr_out->text_start);
   PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
-			  (bfd_byte *) aouthdr_out->data_start);
+			  aouthdr_out->data_start);
 
 #ifdef I960
-  bfd_h_put_32(abfd, aouthdr_in->tagentries, (bfd_byte *) aouthdr_out->tagentries);
+  H_PUT_32 (abfd, aouthdr_in->tagentries, aouthdr_out->tagentries);
 #endif
 
 #ifdef RS6000COFF_C
 #ifdef XCOFF64
-  bfd_h_put_64 (abfd, aouthdr_in->o_toc, aouthdr_out->o_toc);
+  H_PUT_64 (abfd, aouthdr_in->o_toc, aouthdr_out->o_toc);
 #else
-  bfd_h_put_32 (abfd, aouthdr_in->o_toc, aouthdr_out->o_toc);
-#endif
-  bfd_h_put_16 (abfd, aouthdr_in->o_snentry, aouthdr_out->o_snentry);
-  bfd_h_put_16 (abfd, aouthdr_in->o_sntext, aouthdr_out->o_sntext);
-  bfd_h_put_16 (abfd, aouthdr_in->o_sndata, aouthdr_out->o_sndata);
-  bfd_h_put_16 (abfd, aouthdr_in->o_sntoc, aouthdr_out->o_sntoc);
-  bfd_h_put_16 (abfd, aouthdr_in->o_snloader, aouthdr_out->o_snloader);
-  bfd_h_put_16 (abfd, aouthdr_in->o_snbss, aouthdr_out->o_snbss);
-  bfd_h_put_16 (abfd, aouthdr_in->o_algntext, aouthdr_out->o_algntext);
-  bfd_h_put_16 (abfd, aouthdr_in->o_algndata, aouthdr_out->o_algndata);
-  bfd_h_put_16 (abfd, aouthdr_in->o_modtype, aouthdr_out->o_modtype);
-  bfd_h_put_16 (abfd, aouthdr_in->o_cputype, aouthdr_out->o_cputype);
+  H_PUT_32 (abfd, aouthdr_in->o_toc, aouthdr_out->o_toc);
+#endif
+  H_PUT_16 (abfd, aouthdr_in->o_snentry, aouthdr_out->o_snentry);
+  H_PUT_16 (abfd, aouthdr_in->o_sntext, aouthdr_out->o_sntext);
+  H_PUT_16 (abfd, aouthdr_in->o_sndata, aouthdr_out->o_sndata);
+  H_PUT_16 (abfd, aouthdr_in->o_sntoc, aouthdr_out->o_sntoc);
+  H_PUT_16 (abfd, aouthdr_in->o_snloader, aouthdr_out->o_snloader);
+  H_PUT_16 (abfd, aouthdr_in->o_snbss, aouthdr_out->o_snbss);
+  H_PUT_16 (abfd, aouthdr_in->o_algntext, aouthdr_out->o_algntext);
+  H_PUT_16 (abfd, aouthdr_in->o_algndata, aouthdr_out->o_algndata);
+  H_PUT_16 (abfd, aouthdr_in->o_modtype, aouthdr_out->o_modtype);
+  H_PUT_16 (abfd, aouthdr_in->o_cputype, aouthdr_out->o_cputype);
 #ifdef XCOFF64
-  bfd_h_put_64 (abfd, aouthdr_in->o_maxstack, aouthdr_out->o_maxstack);
-  bfd_h_put_64 (abfd, aouthdr_in->o_maxdata, aouthdr_out->o_maxdata);
+  H_PUT_64 (abfd, aouthdr_in->o_maxstack, aouthdr_out->o_maxstack);
+  H_PUT_64 (abfd, aouthdr_in->o_maxdata, aouthdr_out->o_maxdata);
 #else
-  bfd_h_put_32 (abfd, aouthdr_in->o_maxstack, aouthdr_out->o_maxstack);
-  bfd_h_put_32 (abfd, aouthdr_in->o_maxdata, aouthdr_out->o_maxdata);
+  H_PUT_32 (abfd, aouthdr_in->o_maxstack, aouthdr_out->o_maxstack);
+  H_PUT_32 (abfd, aouthdr_in->o_maxdata, aouthdr_out->o_maxdata);
 #endif
   memset (aouthdr_out->o_resv2, 0, sizeof aouthdr_out->o_resv2);
 #ifdef XCOFF64
@@ -770,23 +785,23 @@ coff_swap_aouthdr_out (abfd, in, out)
 #endif
 
 #ifdef MIPSECOFF
-  bfd_h_put_32(abfd, aouthdr_in->bss_start, (bfd_byte *) aouthdr_out->bss_start);
-  bfd_h_put_32(abfd, aouthdr_in->gp_value, (bfd_byte *) aouthdr_out->gp_value);
-  bfd_h_put_32(abfd, aouthdr_in->gprmask, (bfd_byte *) aouthdr_out->gprmask);
-  bfd_h_put_32(abfd, aouthdr_in->cprmask[0], (bfd_byte *) aouthdr_out->cprmask[0]);
-  bfd_h_put_32(abfd, aouthdr_in->cprmask[1], (bfd_byte *) aouthdr_out->cprmask[1]);
-  bfd_h_put_32(abfd, aouthdr_in->cprmask[2], (bfd_byte *) aouthdr_out->cprmask[2]);
-  bfd_h_put_32(abfd, aouthdr_in->cprmask[3], (bfd_byte *) aouthdr_out->cprmask[3]);
+  H_PUT_32 (abfd, aouthdr_in->bss_start, aouthdr_out->bss_start);
+  H_PUT_32 (abfd, aouthdr_in->gp_value, aouthdr_out->gp_value);
+  H_PUT_32 (abfd, aouthdr_in->gprmask, aouthdr_out->gprmask);
+  H_PUT_32 (abfd, aouthdr_in->cprmask[0], aouthdr_out->cprmask[0]);
+  H_PUT_32 (abfd, aouthdr_in->cprmask[1], aouthdr_out->cprmask[1]);
+  H_PUT_32 (abfd, aouthdr_in->cprmask[2], aouthdr_out->cprmask[2]);
+  H_PUT_32 (abfd, aouthdr_in->cprmask[3], aouthdr_out->cprmask[3]);
 #endif
 
 #ifdef ALPHAECOFF
   /* FIXME: What does bldrev mean?  */
-  bfd_h_put_16(abfd, (bfd_vma) 2, (bfd_byte *) aouthdr_out->bldrev);
-  bfd_h_put_16(abfd, (bfd_vma) 0, (bfd_byte *) aouthdr_out->padding);
-  bfd_h_put_64(abfd, aouthdr_in->bss_start, (bfd_byte *) aouthdr_out->bss_start);
-  bfd_h_put_64(abfd, aouthdr_in->gp_value, (bfd_byte *) aouthdr_out->gp_value);
-  bfd_h_put_32(abfd, aouthdr_in->gprmask, (bfd_byte *) aouthdr_out->gprmask);
-  bfd_h_put_32(abfd, aouthdr_in->fprmask, (bfd_byte *) aouthdr_out->fprmask);
+  H_PUT_16 (abfd, 2, aouthdr_out->bldrev);
+  H_PUT_16 (abfd, 0, aouthdr_out->padding);
+  H_PUT_64 (abfd, aouthdr_in->bss_start, aouthdr_out->bss_start);
+  H_PUT_64 (abfd, aouthdr_in->gp_value, aouthdr_out->gp_value);
+  H_PUT_32 (abfd, aouthdr_in->gprmask, aouthdr_out->gprmask);
+  H_PUT_32 (abfd, aouthdr_in->fprmask, aouthdr_out->fprmask);
 #endif
 
   return AOUTSZ;
@@ -794,9 +809,9 @@ coff_swap_aouthdr_out (abfd, in, out)
 
 static void
 coff_swap_scnhdr_in (abfd, ext, in)
-     bfd            *abfd;
-     PTR	     ext;
-     PTR	     in;
+     bfd *abfd;
+     PTR ext;
+     PTR in;
 {
   SCNHDR *scnhdr_ext = (SCNHDR *) ext;
   struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
@@ -805,28 +820,18 @@ coff_swap_scnhdr_in (abfd, ext, in)
   COFF_ADJUST_SCNHDR_IN_PRE (abfd, ext, in);
 #endif
   memcpy(scnhdr_int->s_name, scnhdr_ext->s_name, sizeof (scnhdr_int->s_name));
-  scnhdr_int->s_vaddr =
-    GET_SCNHDR_VADDR (abfd, (bfd_byte *) scnhdr_ext->s_vaddr);
-  scnhdr_int->s_paddr =
-    GET_SCNHDR_PADDR (abfd, (bfd_byte *) scnhdr_ext->s_paddr);
-  scnhdr_int->s_size =
-    GET_SCNHDR_SIZE (abfd, (bfd_byte *) scnhdr_ext->s_size);
-
-  scnhdr_int->s_scnptr =
-    GET_SCNHDR_SCNPTR (abfd, (bfd_byte *) scnhdr_ext->s_scnptr);
-  scnhdr_int->s_relptr =
-    GET_SCNHDR_RELPTR (abfd, (bfd_byte *) scnhdr_ext->s_relptr);
-  scnhdr_int->s_lnnoptr =
-    GET_SCNHDR_LNNOPTR (abfd, (bfd_byte *) scnhdr_ext->s_lnnoptr);
-  scnhdr_int->s_flags =
-    GET_SCNHDR_FLAGS (abfd, (bfd_byte *) scnhdr_ext->s_flags);
-  scnhdr_int->s_nreloc =
-    GET_SCNHDR_NRELOC (abfd, (bfd_byte *) scnhdr_ext->s_nreloc);
-  scnhdr_int->s_nlnno =
-    GET_SCNHDR_NLNNO (abfd, (bfd_byte *) scnhdr_ext->s_nlnno);
+  scnhdr_int->s_vaddr = GET_SCNHDR_VADDR (abfd, scnhdr_ext->s_vaddr);
+  scnhdr_int->s_paddr = GET_SCNHDR_PADDR (abfd, scnhdr_ext->s_paddr);
+  scnhdr_int->s_size = GET_SCNHDR_SIZE (abfd, scnhdr_ext->s_size);
+
+  scnhdr_int->s_scnptr = GET_SCNHDR_SCNPTR (abfd, scnhdr_ext->s_scnptr);
+  scnhdr_int->s_relptr = GET_SCNHDR_RELPTR (abfd, scnhdr_ext->s_relptr);
+  scnhdr_int->s_lnnoptr = GET_SCNHDR_LNNOPTR (abfd, scnhdr_ext->s_lnnoptr);
+  scnhdr_int->s_flags = GET_SCNHDR_FLAGS (abfd, scnhdr_ext->s_flags);
+  scnhdr_int->s_nreloc = GET_SCNHDR_NRELOC (abfd, scnhdr_ext->s_nreloc);
+  scnhdr_int->s_nlnno = GET_SCNHDR_NLNNO (abfd, scnhdr_ext->s_nlnno);
 #ifdef I960
-  scnhdr_int->s_align =
-    GET_SCNHDR_ALIGN (abfd, (bfd_byte *) scnhdr_ext->s_align);
+  scnhdr_int->s_align = GET_SCNHDR_ALIGN (abfd, scnhdr_ext->s_align);
 #endif
 #ifdef COFF_ADJUST_SCNHDR_IN_POST
   COFF_ADJUST_SCNHDR_IN_POST (abfd, ext, in);
@@ -835,42 +840,32 @@ coff_swap_scnhdr_in (abfd, ext, in)
 
 static unsigned int
 coff_swap_scnhdr_out (abfd, in, out)
-     bfd       *abfd;
-     PTR	in;
-     PTR	out;
+     bfd *abfd;
+     PTR in;
+     PTR out;
 {
-  struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *)in;
-  SCNHDR *scnhdr_ext = (SCNHDR *)out;
+  struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
+  SCNHDR *scnhdr_ext = (SCNHDR *) out;
   unsigned int ret = bfd_coff_scnhsz (abfd);
 
 #ifdef COFF_ADJUST_SCNHDR_OUT_PRE
   COFF_ADJUST_SCNHDR_OUT_PRE (abfd, in, out);
 #endif
-  memcpy(scnhdr_ext->s_name, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
-
-  PUT_SCNHDR_VADDR (abfd, scnhdr_int->s_vaddr,
-		    (bfd_byte *) scnhdr_ext->s_vaddr);
-
-  PUT_SCNHDR_PADDR (abfd, scnhdr_int->s_paddr,
-		    (bfd_byte *) scnhdr_ext->s_paddr);
-  PUT_SCNHDR_SIZE (abfd, scnhdr_int->s_size,
-		   (bfd_byte *) scnhdr_ext->s_size);
+  memcpy (scnhdr_ext->s_name, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
 
-  PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,
-		     (bfd_byte *) scnhdr_ext->s_scnptr);
-  PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,
-		     (bfd_byte *) scnhdr_ext->s_relptr);
-  PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,
-		      (bfd_byte *) scnhdr_ext->s_lnnoptr);
-  PUT_SCNHDR_FLAGS (abfd, scnhdr_int->s_flags,
-		    (bfd_byte *) scnhdr_ext->s_flags);
+  PUT_SCNHDR_VADDR (abfd, scnhdr_int->s_vaddr, scnhdr_ext->s_vaddr);
+  PUT_SCNHDR_PADDR (abfd, scnhdr_int->s_paddr, scnhdr_ext->s_paddr);
+  PUT_SCNHDR_SIZE (abfd, scnhdr_int->s_size, scnhdr_ext->s_size);
+  PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr, scnhdr_ext->s_scnptr);
+  PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr, scnhdr_ext->s_relptr);
+  PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr, scnhdr_ext->s_lnnoptr);
+  PUT_SCNHDR_FLAGS (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
 #if defined(M88)
-  PUTWORD(abfd, scnhdr_int->s_nlnno, (bfd_byte *) scnhdr_ext->s_nlnno);
-  PUTWORD(abfd, scnhdr_int->s_nreloc, (bfd_byte *) scnhdr_ext->s_nreloc);
+  H_PUT_32 (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno);
+  H_PUT_32 (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc);
 #else
   if (scnhdr_int->s_nlnno <= MAX_SCNHDR_NLNNO)
-    PUT_SCNHDR_NLNNO(abfd, scnhdr_int->s_nlnno,
-	    (bfd_byte *) scnhdr_ext->s_nlnno);
+    PUT_SCNHDR_NLNNO (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno);
   else
     {
       char buf[sizeof (scnhdr_int->s_name) + 1];
@@ -881,11 +876,10 @@ coff_swap_scnhdr_out (abfd, in, out)
 	(_("%s: warning: %s: line number overflow: 0x%lx > 0xffff"),
 	 bfd_get_filename (abfd),
 	 buf, scnhdr_int->s_nlnno);
-      PUT_SCNHDR_NLNNO(abfd, 0xffff, (bfd_byte *) scnhdr_ext->s_nlnno);
+      PUT_SCNHDR_NLNNO (abfd, 0xffff, scnhdr_ext->s_nlnno);
     }
   if (scnhdr_int->s_nreloc <= MAX_SCNHDR_NRELOC)
-    PUT_SCNHDR_NRELOC(abfd, scnhdr_int->s_nreloc,
-	    (bfd_byte *) scnhdr_ext->s_nreloc);
+    PUT_SCNHDR_NRELOC (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc);
   else
     {
       char buf[sizeof (scnhdr_int->s_name) + 1];
@@ -896,13 +890,13 @@ coff_swap_scnhdr_out (abfd, in, out)
 			     bfd_get_filename (abfd),
 			     buf, scnhdr_int->s_nreloc);
       bfd_set_error (bfd_error_file_truncated);
-      PUT_SCNHDR_NRELOC(abfd, 0xffff, (bfd_byte *) scnhdr_ext->s_nreloc);
+      PUT_SCNHDR_NRELOC (abfd, 0xffff, scnhdr_ext->s_nreloc);
       ret = 0;
     }
 #endif
 
 #ifdef I960
-  PUT_SCNHDR_ALIGN (abfd, scnhdr_int->s_align, (bfd_byte *) scnhdr_ext->s_align);
+  PUT_SCNHDR_ALIGN (abfd, scnhdr_int->s_align, scnhdr_ext->s_align);
 #endif
 #ifdef COFF_ADJUST_SCNHDR_OUT_POST
   COFF_ADJUST_SCNHDR_OUT_POST (abfd, in, out);