Eliminate ia64 compiler warnings. Fix ia64 gas testsuite again.

[deliverable/binutils-gdb.git] / bfd / coffswap.h

diff --git a/bfd/coffswap.h b/bfd/coffswap.h
index ed1137eb64d841c6e9de0dda6a88a2f58d1ce61d..2f89afbff2d08a2d6b331bcd676821b69de13a06 100644 (file)
--- a/bfd/coffswap.h
+++ b/bfd/coffswap.h
@@ -1,5 +1,6 @@
 /* Generic COFF swapping routines, for BFD.
 /* Generic COFF swapping routines, for BFD.

-   Copyright 1990, 1991, 1992 Free Software Foundation, Inc.
+   Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 98, 1999
+   Free Software Foundation, Inc.

    Written by Cygnus Support.
 
 This file is part of BFD, the Binary File Descriptor library.
    Written by Cygnus Support.
 
 This file is part of BFD, the Binary File Descriptor library.


@@ -16,7 +17,7 @@ GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software

-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

 
 /* This file contains routines used to swap COFF data.  It is a header
    file because the details of swapping depend on the details of the
 
 /* This file contains routines used to swap COFF data.  It is a header
    file because the details of swapping depend on the details of the


@@ -81,14 +82,155 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #define PUT_LINENO_LNNO(abfd,val, ext) bfd_h_put_16(abfd,val,  (bfd_byte *) (ext->l_lnno));
 #endif
 
 #define PUT_LINENO_LNNO(abfd,val, ext) bfd_h_put_16(abfd,val,  (bfd_byte *) (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
+#endif
+#ifndef PUT_FILEHDR_SYMPTR
+#define PUT_FILEHDR_SYMPTR bfd_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
+#endif
+#ifndef PUT_AOUTHDR_TSIZE
+#define PUT_AOUTHDR_TSIZE bfd_h_put_32
+#endif
+#ifndef GET_AOUTHDR_DSIZE
+#define GET_AOUTHDR_DSIZE bfd_h_get_32
+#endif
+#ifndef PUT_AOUTHDR_DSIZE
+#define PUT_AOUTHDR_DSIZE bfd_h_put_32
+#endif
+#ifndef GET_AOUTHDR_BSIZE
+#define GET_AOUTHDR_BSIZE bfd_h_get_32
+#endif
+#ifndef PUT_AOUTHDR_BSIZE
+#define PUT_AOUTHDR_BSIZE bfd_h_put_32
+#endif
+#ifndef GET_AOUTHDR_ENTRY
+#define GET_AOUTHDR_ENTRY bfd_h_get_32
+#endif
+#ifndef PUT_AOUTHDR_ENTRY
+#define PUT_AOUTHDR_ENTRY bfd_h_put_32
+#endif
+#ifndef GET_AOUTHDR_TEXT_START
+#define GET_AOUTHDR_TEXT_START bfd_h_get_32
+#endif
+#ifndef PUT_AOUTHDR_TEXT_START
+#define PUT_AOUTHDR_TEXT_START bfd_h_put_32
+#endif
+#ifndef GET_AOUTHDR_DATA_START
+#define GET_AOUTHDR_DATA_START bfd_h_get_32
+#endif
+#ifndef PUT_AOUTHDR_DATA_START
+#define PUT_AOUTHDR_DATA_START bfd_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
+#endif
+#ifndef PUT_SCNHDR_PADDR
+#define PUT_SCNHDR_PADDR bfd_h_put_32
+#endif
+#ifndef GET_SCNHDR_VADDR
+#define GET_SCNHDR_VADDR bfd_h_get_32
+#endif
+#ifndef PUT_SCNHDR_VADDR
+#define PUT_SCNHDR_VADDR bfd_h_put_32
+#endif
+#ifndef GET_SCNHDR_SIZE
+#define GET_SCNHDR_SIZE bfd_h_get_32
+#endif
+#ifndef PUT_SCNHDR_SIZE
+#define PUT_SCNHDR_SIZE bfd_h_put_32
+#endif
+#ifndef GET_SCNHDR_SCNPTR
+#define GET_SCNHDR_SCNPTR bfd_h_get_32
+#endif
+#ifndef PUT_SCNHDR_SCNPTR
+#define PUT_SCNHDR_SCNPTR bfd_h_put_32
+#endif
+#ifndef GET_SCNHDR_RELPTR
+#define GET_SCNHDR_RELPTR bfd_h_get_32
+#endif
+#ifndef PUT_SCNHDR_RELPTR
+#define PUT_SCNHDR_RELPTR bfd_h_put_32
+#endif
+#ifndef GET_SCNHDR_LNNOPTR
+#define GET_SCNHDR_LNNOPTR bfd_h_get_32
+#endif
+#ifndef PUT_SCNHDR_LNNOPTR
+#define PUT_SCNHDR_LNNOPTR bfd_h_put_32
+#endif
+#ifndef GET_SCNHDR_NRELOC
+#define GET_SCNHDR_NRELOC bfd_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
+#endif
+#ifndef GET_SCNHDR_NLNNO
+#define GET_SCNHDR_NLNNO bfd_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
+#endif
+#ifndef GET_SCNHDR_FLAGS
+#define GET_SCNHDR_FLAGS bfd_h_get_32
+#endif
+#ifndef PUT_SCNHDR_FLAGS
+#define PUT_SCNHDR_FLAGS bfd_h_put_32
+#endif
+
+#ifndef GET_RELOC_VADDR
+#define GET_RELOC_VADDR bfd_h_get_32
+#endif
+#ifndef PUT_RELOC_VADDR
+#define PUT_RELOC_VADDR bfd_h_put_32
+#endif
+
+static void coff_swap_aouthdr_in PARAMS ((bfd *, PTR, PTR));
+static unsigned int coff_swap_aouthdr_out PARAMS ((bfd *, PTR, PTR));
+static void coff_swap_scnhdr_in PARAMS ((bfd *, PTR, PTR));
+static unsigned int coff_swap_scnhdr_out PARAMS ((bfd *, PTR, PTR));
+static void coff_swap_filehdr_in PARAMS ((bfd *, PTR, PTR));
+static unsigned int coff_swap_filehdr_out PARAMS ((bfd *, PTR, PTR));
+#ifndef NO_COFF_RELOCS
+static void coff_swap_reloc_in PARAMS ((bfd *, PTR, PTR));
+static unsigned int coff_swap_reloc_out PARAMS ((bfd *, PTR, PTR));
+#endif /* NO_COFF_RELOCS */
+#ifndef NO_COFF_SYMBOLS
+static void coff_swap_sym_in PARAMS ((bfd *, PTR, PTR));
+static unsigned int coff_swap_sym_out PARAMS ((bfd *, PTR, PTR));
+static void coff_swap_aux_in PARAMS ((bfd *, PTR, int, int, int, int, PTR));
+static unsigned int coff_swap_aux_out PARAMS ((bfd *, PTR, int, int, int, int, PTR));
+#endif /* NO_COFF_SYMBOLS */
+#ifndef NO_COFF_LINENOS
+static void coff_swap_lineno_in PARAMS ((bfd *, PTR, PTR));
+static unsigned int coff_swap_lineno_out PARAMS ((bfd *, PTR, PTR));
+#endif /* NO_COFF_LINENOS */
+
+#ifndef NO_COFF_RELOCS
+

 static void
 static void

-DEFUN(bfd_swap_reloc_in,(abfd, reloc_src, reloc_dst),
-      bfd            *abfd AND
-      RELOC *reloc_src AND
-      struct internal_reloc *reloc_dst)
+coff_swap_reloc_in (abfd, src, dst)
+     bfd *abfd;
+     PTR src;
+     PTR dst;

 {
 {

-  reloc_dst->r_vaddr = bfd_h_get_32(abfd, (bfd_byte *)reloc_src->r_vaddr);
-  reloc_dst->r_symndx = bfd_h_get_32(abfd, (bfd_byte *) reloc_src->r_symndx);
+  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);

 
 #ifdef RS6000COFF_C
   reloc_dst->r_type = bfd_h_get_8(abfd, reloc_src->r_type);
 
 #ifdef RS6000COFF_C
   reloc_dst->r_type = bfd_h_get_8(abfd, reloc_src->r_type);


@@ -103,19 +245,24 @@ DEFUN(bfd_swap_reloc_in,(abfd, reloc_src, reloc_dst),
 #endif
 }
 
 #endif
 }
 

-

 static unsigned int
 static unsigned int

-DEFUN(coff_swap_reloc_out,(abfd, src, dst),
-      bfd       *abfd AND
-      PTR      src AND
-      PTR      dst)
+coff_swap_reloc_out (abfd, src, 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;
 {
   struct internal_reloc *reloc_src = (struct internal_reloc *)src;
   struct external_reloc *reloc_dst = (struct external_reloc *)dst;

-  bfd_h_put_32(abfd, reloc_src->r_vaddr, (bfd_byte *) reloc_dst->r_vaddr);
+  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);
   bfd_h_put_32(abfd, reloc_src->r_symndx, (bfd_byte *) 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);
+#else

   bfd_h_put_16(abfd, reloc_src->r_type, (bfd_byte *)
               reloc_dst->r_type);
   bfd_h_put_16(abfd, reloc_src->r_type, (bfd_byte *)
               reloc_dst->r_type);

+#endif

 
 #ifdef SWAP_OUT_RELOC_OFFSET
   SWAP_OUT_RELOC_OFFSET(abfd,
 
 #ifdef SWAP_OUT_RELOC_OFFSET
   SWAP_OUT_RELOC_OFFSET(abfd,


@@ -126,52 +273,76 @@ DEFUN(coff_swap_reloc_out,(abfd, src, dst),
   SWAP_OUT_RELOC_EXTRA(abfd,reloc_src, reloc_dst);
 #endif
 
   SWAP_OUT_RELOC_EXTRA(abfd,reloc_src, reloc_dst);
 #endif
 

-  return sizeof(struct external_reloc);
+  return bfd_coff_relsz (abfd);

 }
 
 }
 

+#endif /* NO_COFF_RELOCS */
+

 static void
 static void

-DEFUN(coff_swap_filehdr_in,(abfd, src, dst),
-      bfd            *abfd AND
-      PTR           src AND
-      PTR           dst)
+coff_swap_filehdr_in (abfd, src, dst)
+     bfd            *abfd;
+     PTR            src;
+     PTR            dst;

 {
   FILHDR *filehdr_src = (FILHDR *) src;
   struct internal_filehdr *filehdr_dst = (struct internal_filehdr *) dst;
 {
   FILHDR *filehdr_src = (FILHDR *) src;
   struct internal_filehdr *filehdr_dst = (struct internal_filehdr *) 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_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 = bfd_h_get_32(abfd, (bfd_byte *)filehdr_src-> f_symptr);
+  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_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);

+#ifdef TIC80_TARGET_ID
+  filehdr_dst->f_target_id = bfd_h_get_16(abfd, (bfd_byte *)filehdr_src-> f_target_id);
+#endif
+
+#ifdef COFF_ADJUST_FILEHDR_IN_POST
+  COFF_ADJUST_FILEHDR_IN_POST (abfd, src, dst);
+#endif

 }
 
 static  unsigned int
 }
 
 static  unsigned int

-DEFUN(coff_swap_filehdr_out,(abfd, in, out),
-      bfd       *abfd AND
-      PTR      in AND
-      PTR      out)
+coff_swap_filehdr_out (abfd, in, 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);
   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);

-  bfd_h_put_32(abfd, filehdr_in->f_symptr, (bfd_byte *) filehdr_out->f_symptr);
+  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);
   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);

-  return sizeof(FILHDR);
-}
+#ifdef TIC80_TARGET_ID
+  bfd_h_put_16(abfd, filehdr_in->f_target_id, (bfd_byte *) filehdr_out->f_target_id);
+#endif

 
 

+#ifdef COFF_ADJUST_FILEHDR_OUT_POST
+  COFF_ADJUST_FILEHDR_OUT_POST (abfd, in, out);
+#endif
+  return bfd_coff_filhsz (abfd);
+}

 
 #ifndef NO_COFF_SYMBOLS
 
 static void
 
 #ifndef NO_COFF_SYMBOLS
 
 static void

-DEFUN(coff_swap_sym_in,(abfd, ext1, in1),
-      bfd            *abfd AND
-      PTR ext1 AND
-      PTR in1)
+coff_swap_sym_in (abfd, ext1, in1)
+     bfd            *abfd;
+     PTR ext1;
+     PTR in1;

 {
   SYMENT *ext = (SYMENT *)ext1;
   struct internal_syment      *in = (struct internal_syment *)in1;
 {
   SYMENT *ext = (SYMENT *)ext1;
   struct internal_syment      *in = (struct internal_syment *)in1;


@@ -189,7 +360,7 @@ DEFUN(coff_swap_sym_in,(abfd, ext1, in1),
   }
   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 = 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){
+  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_16(abfd, (bfd_byte *) ext->e_type);
   }
   else {


@@ -197,13 +368,16 @@ DEFUN(coff_swap_sym_in,(abfd, ext1, in1),
   }
   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 = bfd_h_get_8(abfd, ext->e_sclass);
   in->n_numaux = bfd_h_get_8(abfd, ext->e_numaux);

+#ifdef COFF_ADJUST_SYM_IN_POST
+  COFF_ADJUST_SYM_IN_POST (abfd, ext1, in1);
+#endif

 }
 
 static unsigned int
 }
 
 static unsigned int

-DEFUN(coff_swap_sym_out,(abfd, inp, extp),
-      bfd       *abfd AND
-      PTR      inp AND
-      PTR      extp)
+coff_swap_sym_out (abfd, inp, extp)
+     bfd       *abfd;
+     PTR       inp;
+     PTR       extp;

 {
   struct internal_syment *in = (struct internal_syment *)inp;
   SYMENT *ext =(SYMENT *)extp;
 {
   struct internal_syment *in = (struct internal_syment *)inp;
   SYMENT *ext =(SYMENT *)extp;


@@ -220,7 +394,7 @@ DEFUN(coff_swap_sym_out,(abfd, inp, extp),
   }
   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);
   }
   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);

-  if (sizeof(ext->e_type) == 2)
+  if (sizeof (ext->e_type) == 2)

       {
        bfd_h_put_16(abfd,  in->n_type , (bfd_byte *) ext->e_type);
       }
       {
        bfd_h_put_16(abfd,  in->n_type , (bfd_byte *) ext->e_type);
       }


@@ -230,50 +404,51 @@ DEFUN(coff_swap_sym_out,(abfd, inp, extp),
       }
   bfd_h_put_8(abfd,  in->n_sclass , ext->e_sclass);
   bfd_h_put_8(abfd,  in->n_numaux , ext->e_numaux);
       }
   bfd_h_put_8(abfd,  in->n_sclass , ext->e_sclass);
   bfd_h_put_8(abfd,  in->n_numaux , ext->e_numaux);

-  return sizeof(SYMENT);
+#ifdef COFF_ADJUST_SYM_OUT_POST
+  COFF_ADJUST_SYM_OUT_POST (abfd, inp, extp);
+#endif
+  return SYMESZ;

 }
 
 static void
 }
 
 static void

-DEFUN(coff_swap_aux_in,(abfd, ext1, type, class, in1),
-      bfd            *abfd AND
-      PTR            ext1 AND
-      int             type AND
-      int             class AND
-      PTR            in1)
+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;

 {
   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) {
     case C_FILE:
       if (ext->x_file.x_fname[0] == 0) {
          in->x_file.x_n.x_zeroes = 0;
   switch (class) {
     case C_FILE:
       if (ext->x_file.x_fname[0] == 0) {
          in->x_file.x_n.x_zeroes = 0;

-         in->x_file.x_n.x_offset = 
+         in->x_file.x_n.x_offset =

           bfd_h_get_32(abfd, (bfd_byte *) ext->x_file.x_n.x_offset);
        } else {
 #if FILNMLEN != E_FILNMLEN
            -> Error, we need to cope with truncating or extending FILNMLEN!;
 #else
           bfd_h_get_32(abfd, (bfd_byte *) ext->x_file.x_n.x_offset);
        } else {
 #if FILNMLEN != E_FILNMLEN
            -> Error, we need to cope with truncating or extending FILNMLEN!;
 #else

-           memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
+           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
          }
 #endif
          }

-      break;
-
-      /* RS/6000 "csect" auxents */
-#ifdef RS6000COFF_C
-    case C_EXT:
-    case C_HIDEXT:
-      in->x_csect.x_scnlen   = bfd_h_get_32 (abfd, (bfd_byte *) ext->x_csect.x_scnlen);
-      in->x_csect.x_parmhash = bfd_h_get_32 (abfd, (bfd_byte *) ext->x_csect.x_parmhash);
-      in->x_csect.x_snhash   = bfd_h_get_16 (abfd, (bfd_byte *) ext->x_csect.x_snhash);
-      /* We don't have to hack bitfields in x_smtyp because it's defined by
-        shifts-and-ands, which are equivalent on all byte orders.  */
-      in->x_csect.x_smtyp    = bfd_h_get_8  (abfd, (bfd_byte *) ext->x_csect.x_smtyp);
-      in->x_csect.x_smclas   = bfd_h_get_8  (abfd, (bfd_byte *) ext->x_csect.x_smclas);
-      in->x_csect.x_stab     = bfd_h_get_32 (abfd, (bfd_byte *) ext->x_csect.x_stab);
-      in->x_csect.x_snstab   = bfd_h_get_16 (abfd, (bfd_byte *) ext->x_csect.x_snstab);
-      break;
-#endif
+      goto end;

 
     case C_STAT:
 #ifdef C_LEAFSTAT
 
     case C_STAT:
 #ifdef C_LEAFSTAT


@@ -284,50 +459,76 @@ DEFUN(coff_swap_aux_in,(abfd, ext1, type, class, 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_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);

-         break;
+
+         /* PE defines some extra fields; we zero them out for
+             safety.  */
+         in->x_scn.x_checksum = 0;
+         in->x_scn.x_associated = 0;
+         in->x_scn.x_comdat = 0;
+
+         goto end;

        }
        }

-    default:
-      in->x_sym.x_tagndx.l = bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_tagndx);
+      break;
+    }
+
+  in->x_sym.x_tagndx.l = bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_tagndx);

 #ifndef NO_TVNDX
 #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 = bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_tvndx);

 #endif
 
 #endif
 

-      if (ISARY(type)) {
+  if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
+    {
+      in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR (abfd, ext);
+      in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX (abfd, ext);
+    }
+  else
+    {

 #if DIMNUM != E_DIMNUM
 #if DIMNUM != E_DIMNUM

-         -> Error, we need to cope with truncating or extending DIMNUM!;
-#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]);
-         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]);
-         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]);
-         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]);
-#endif
-       }
-      if (class == C_BLOCK || ISFCN(type) || ISTAG(class)) {
-       in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR(abfd, ext);
-       in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX(abfd, ext);
-      }
-
-      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);
-       }
+ #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]);
+      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]);
+      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]);
+      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]);

     }
     }

+
+  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);
+  }
+
+end: ;
+  /* the semicolon is because MSVC doesn't like labels at
+     end of block.  */
+
+#ifdef COFF_ADJUST_AUX_IN_POST
+  COFF_ADJUST_AUX_IN_POST (abfd, ext1, type, class, indx, numaux, in1);
+#endif

 }
 
 static unsigned int
 }
 
 static unsigned int

-DEFUN(coff_swap_aux_out,(abfd, inp, type, class, extp),
-  bfd   *abfd AND
-  PTR  inp AND
-  int   type AND
-  int   class AND
-  PTR  extp)
+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;

 {
   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:
   memset((PTR)ext, 0, AUXESZ);
   switch (class) {
   case C_FILE:


@@ -344,23 +545,7 @@ DEFUN(coff_swap_aux_out,(abfd, inp, type, class, extp),
       memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
 #endif
     }
       memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
 #endif
     }

-    break;
-
-#ifdef RS6000COFF_C
-  /* RS/6000 "csect" auxents */
-  case C_EXT:
-  case C_HIDEXT:
-    PUTWORD (abfd, in->x_csect.x_scnlen,       ext->x_csect.x_scnlen);
-    PUTWORD (abfd, in->x_csect.x_parmhash,     ext->x_csect.x_parmhash);
-    PUTHALF (abfd, in->x_csect.x_snhash,       ext->x_csect.x_snhash);
-    /* We don't have to hack bitfields in x_smtyp because it's defined by
-       shifts-and-ands, which are equivalent on all byte orders.  */
-    PUTBYTE (abfd, in->x_csect.x_smtyp,                ext->x_csect.x_smtyp);
-    PUTBYTE (abfd, in->x_csect.x_smclas,       ext->x_csect.x_smclas);
-    PUTWORD (abfd, in->x_csect.x_stab,         ext->x_csect.x_stab);
-    PUTHALF (abfd, in->x_csect.x_snstab,       ext->x_csect.x_snstab);
-    break;
-#endif
+    goto end;

 
   case C_STAT:
 #ifdef C_LEAFSTAT
 
   case C_STAT:
 #ifdef C_LEAFSTAT


@@ -371,38 +556,50 @@ DEFUN(coff_swap_aux_out,(abfd, inp, type, class, 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);
       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);

-      break;
+      goto end;

     }
     }

-  default:
-    PUTWORD(abfd, in->x_sym.x_tagndx.l, (bfd_byte *) ext->x_sym.x_tagndx);
+    break;
+  }
+
+  PUTWORD(abfd, in->x_sym.x_tagndx.l, (bfd_byte *) ext->x_sym.x_tagndx);

 #ifndef NO_TVNDX
 #ifndef NO_TVNDX

-    bfd_h_put_16(abfd, in->x_sym.x_tvndx , (bfd_byte *) ext->x_sym.x_tvndx);
+  bfd_h_put_16(abfd, in->x_sym.x_tvndx , (bfd_byte *) ext->x_sym.x_tvndx);

 #endif
 
 #endif
 

-    if (class == C_BLOCK || ISFCN(type) || ISTAG(class)) {
+  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]);
+    }

 
 

-    if (ISFCN(type)) {
-      PUTWORD(abfd, in->x_sym.x_misc.x_fsize, (bfd_byte *)  ext->x_sym.x_misc.x_fsize);
+  if (ISFCN (type))
+    PUTWORD (abfd, in->x_sym.x_misc.x_fsize,
+            (bfd_byte *)  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);

     }
     }

-    else {
-      if (ISARY(type)) {
-#if DIMNUM != E_DIMNUM
-       -> Error, we need to cope with truncating or extending DIMNUM!;
-#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]);
+
+end:
+#ifdef COFF_ADJUST_AUX_OUT_POST
+  COFF_ADJUST_AUX_OUT_POST (abfd, inp, type, class, indx, numaux, extp);

 #endif
 #endif

-      }
-      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);
-    }
-  }
-return sizeof(AUXENT);
+  return AUXESZ;

 }
 
 #endif /* NO_COFF_SYMBOLS */
 }
 
 #endif /* NO_COFF_SYMBOLS */


@@ -410,10 +607,10 @@ return sizeof(AUXENT);
 #ifndef NO_COFF_LINENOS
 
 static void
 #ifndef NO_COFF_LINENOS
 
 static void

-DEFUN(coff_swap_lineno_in,(abfd, ext1, in1),
-      bfd            *abfd AND
-      PTR ext1 AND
-      PTR in1)
+coff_swap_lineno_in (abfd, ext1, in1)
+     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;


@@ -423,10 +620,10 @@ DEFUN(coff_swap_lineno_in,(abfd, ext1, in1),
 }
 
 static unsigned int
 }
 
 static unsigned int

-DEFUN(coff_swap_lineno_out,(abfd, inp, outp),
-      bfd       *abfd AND
-      PTR      inp AND
-      PTR      outp)
+coff_swap_lineno_out (abfd, inp, outp)
+     bfd       *abfd;
+     PTR       inp;
+     PTR       outp;

 {
   struct internal_lineno *in = (struct internal_lineno *)inp;
   struct external_lineno *ext = (struct external_lineno *)outp;
 {
   struct internal_lineno *in = (struct internal_lineno *)inp;
   struct external_lineno *ext = (struct external_lineno *)outp;


@@ -434,35 +631,52 @@ DEFUN(coff_swap_lineno_out,(abfd, inp, outp),
          ext->l_addr.l_symndx);
 
   PUT_LINENO_LNNO (abfd, in->l_lnno, ext);
          ext->l_addr.l_symndx);
 
   PUT_LINENO_LNNO (abfd, in->l_lnno, ext);

-  return sizeof(struct external_lineno);
+  return LINESZ;

 }
 
 #endif /* NO_COFF_LINENOS */
 
 }
 
 #endif /* NO_COFF_LINENOS */
 

-

 static void
 static void

-DEFUN(coff_swap_aouthdr_in,(abfd, aouthdr_ext1, aouthdr_int1),
-      bfd            *abfd AND
-      PTR aouthdr_ext1 AND
-      PTR aouthdr_int1)
+coff_swap_aouthdr_in (abfd, aouthdr_ext1, aouthdr_int1)
+     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        *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 = bfd_h_get_32(abfd, (bfd_byte *) aouthdr_ext->tsize);
-  aouthdr_int->dsize = bfd_h_get_32(abfd, (bfd_byte *) aouthdr_ext->dsize);
-  aouthdr_int->bsize = bfd_h_get_32(abfd, (bfd_byte *) aouthdr_ext->bsize);
-  aouthdr_int->entry = bfd_h_get_32(abfd, (bfd_byte *) aouthdr_ext->entry);
-  aouthdr_int->text_start = bfd_h_get_32(abfd, (bfd_byte *) aouthdr_ext->text_start);
-  aouthdr_int->data_start = bfd_h_get_32(abfd, (bfd_byte *) aouthdr_ext->data_start);
+  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->text_start =
+    GET_AOUTHDR_TEXT_START (abfd, (bfd_byte *) aouthdr_ext->text_start);
+  aouthdr_int->data_start =
+    GET_AOUTHDR_DATA_START (abfd, (bfd_byte *) aouthdr_ext->data_start);
+

 #ifdef I960
   aouthdr_int->tagentries = bfd_h_get_32(abfd, (bfd_byte *) aouthdr_ext->tagentries);
 #endif
 
 #ifdef I960
   aouthdr_int->tagentries = bfd_h_get_32(abfd, (bfd_byte *) 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);
+#endif
+

 #ifdef RS6000COFF_C
 #ifdef RS6000COFF_C

+#ifdef XCOFF64
+  aouthdr_int->o_toc = bfd_h_get_64(abfd, aouthdr_ext->o_toc);
+#else

   aouthdr_int->o_toc = bfd_h_get_32(abfd, aouthdr_ext->o_toc);
   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_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);


@@ -472,88 +686,225 @@ DEFUN(coff_swap_aouthdr_in,(abfd, aouthdr_ext1, aouthdr_int1),
   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_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);
+#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);
+#else

   aouthdr_int->o_maxstack = bfd_h_get_32(abfd, aouthdr_ext->o_maxstack);
   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);
+#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]);
+#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);

 #endif
 }
 
 static unsigned int
 #endif
 }
 
 static unsigned int

-DEFUN(coff_swap_aouthdr_out,(abfd, in, out),
-      bfd       *abfd AND
-      PTR      in AND
-      PTR      out)
+coff_swap_aouthdr_out (abfd, in, out)
+     bfd       *abfd;
+     PTR       in;
+     PTR       out;

 {
   struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *)in;
   AOUTHDR *aouthdr_out = (AOUTHDR *)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);
   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);

-  bfd_h_put_32(abfd, aouthdr_in->tsize, (bfd_byte *) aouthdr_out->tsize);
-  bfd_h_put_32(abfd, aouthdr_in->dsize, (bfd_byte *) aouthdr_out->dsize);
-  bfd_h_put_32(abfd, aouthdr_in->bsize, (bfd_byte *) aouthdr_out->bsize);
-  bfd_h_put_32(abfd, aouthdr_in->entry, (bfd_byte *) aouthdr_out->entry);
-  bfd_h_put_32(abfd, aouthdr_in->text_start,
-              (bfd_byte *) aouthdr_out->text_start);
-  bfd_h_put_32(abfd, aouthdr_in->data_start, (bfd_byte *) aouthdr_out->data_start);
+  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);
+  PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
+                         (bfd_byte *) aouthdr_out->text_start);
+  PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
+                         (bfd_byte *) aouthdr_out->data_start);
+

 #ifdef I960
   bfd_h_put_32(abfd, aouthdr_in->tagentries, (bfd_byte *) aouthdr_out->tagentries);
 #endif
 #ifdef I960
   bfd_h_put_32(abfd, aouthdr_in->tagentries, (bfd_byte *) aouthdr_out->tagentries);
 #endif

-  return sizeof(AOUTHDR);
+
+#ifdef RS6000COFF_C
+#ifdef XCOFF64
+  bfd_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);
+#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);
+#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);
+#endif
+  memset (aouthdr_out->o_resv2, 0, sizeof aouthdr_out->o_resv2);
+#ifdef XCOFF64
+  memset (aouthdr_out->o_debugger, 0, sizeof aouthdr_out->o_debugger);
+  memset (aouthdr_out->o_resv3, 0, sizeof aouthdr_out->o_resv3);
+#endif
+#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]);
+#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);
+#endif
+
+  return AOUTSZ;

 }
 
 static void
 }
 
 static void

-DEFUN(coff_swap_scnhdr_in,(abfd, ext, in),
-      bfd            *abfd AND
-      PTR           ext AND
-      PTR           in)
+coff_swap_scnhdr_in (abfd, ext, in)
+     bfd            *abfd;
+     PTR            ext;
+     PTR            in;

 {
   SCNHDR *scnhdr_ext = (SCNHDR *) ext;
   struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
 {
   SCNHDR *scnhdr_ext = (SCNHDR *) ext;
   struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;

-  memcpy(scnhdr_int->s_name, scnhdr_ext->s_name, sizeof(scnhdr_int->s_name));
-  scnhdr_int->s_vaddr = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_vaddr);
-  scnhdr_int->s_paddr = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_paddr);
-  scnhdr_int->s_size = bfd_h_get_32(abfd, (bfd_byte *)  scnhdr_ext->s_size);
-
-  scnhdr_int->s_scnptr = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_scnptr);
-  scnhdr_int->s_relptr = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_relptr);
-  scnhdr_int->s_lnnoptr = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_lnnoptr);
-  scnhdr_int->s_flags = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_flags);
-#if defined(M88)
-  scnhdr_int->s_nreloc = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_nreloc);
-  scnhdr_int->s_nlnno = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_nlnno);
-#else
-  scnhdr_int->s_nreloc = bfd_h_get_16(abfd, (bfd_byte *) scnhdr_ext->s_nreloc);
-  scnhdr_int->s_nlnno = bfd_h_get_16(abfd, (bfd_byte *) scnhdr_ext->s_nlnno);
-#endif
+
+#ifdef COFF_ADJUST_SCNHDR_IN_PRE
+  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);

 #ifdef I960
 #ifdef I960

-  scnhdr_int->s_align = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_align);
+  scnhdr_int->s_align =
+    GET_SCNHDR_ALIGN (abfd, (bfd_byte *) scnhdr_ext->s_align);
+#endif
+#ifdef COFF_ADJUST_SCNHDR_IN_POST
+  COFF_ADJUST_SCNHDR_IN_POST (abfd, ext, in);

 #endif
 }
 
 static unsigned int
 #endif
 }
 
 static unsigned int

-DEFUN(coff_swap_scnhdr_out,(abfd, in, out),
-      bfd       *abfd AND
-      PTR      in AND
-      PTR      out)
+coff_swap_scnhdr_out (abfd, in, 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;

-  memcpy(scnhdr_ext->s_name, scnhdr_int->s_name, sizeof(scnhdr_int->s_name));
-  PUTWORD(abfd, scnhdr_int->s_vaddr, (bfd_byte *) scnhdr_ext->s_vaddr);
-  PUTWORD(abfd, scnhdr_int->s_paddr, (bfd_byte *) scnhdr_ext->s_paddr);
-  PUTWORD(abfd, scnhdr_int->s_size, (bfd_byte *) scnhdr_ext->s_size);
-  PUTWORD(abfd, scnhdr_int->s_scnptr, (bfd_byte *) scnhdr_ext->s_scnptr);
-  PUTWORD(abfd, scnhdr_int->s_relptr, (bfd_byte *) scnhdr_ext->s_relptr);
-  PUTWORD(abfd, scnhdr_int->s_lnnoptr, (bfd_byte *) scnhdr_ext->s_lnnoptr);
-  PUTWORD(abfd, scnhdr_int->s_flags, (bfd_byte *) scnhdr_ext->s_flags);
+  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);
+
+  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);

 #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);
 #else
 #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);
 #else

-  PUTHALF(abfd, scnhdr_int->s_nlnno, (bfd_byte *) scnhdr_ext->s_nlnno);
-  PUTHALF(abfd, scnhdr_int->s_nreloc, (bfd_byte *) scnhdr_ext->s_nreloc);
+  if (scnhdr_int->s_nlnno <= MAX_SCNHDR_NLNNO)
+    PUT_SCNHDR_NLNNO(abfd, scnhdr_int->s_nlnno,
+           (bfd_byte *) scnhdr_ext->s_nlnno);
+  else
+    {
+      char buf[sizeof (scnhdr_int->s_name) + 1];
+
+      memcpy (buf, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
+      buf[sizeof (scnhdr_int->s_name)] = '\0';
+      (*_bfd_error_handler)
+       (_("%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);
+    }
+  if (scnhdr_int->s_nreloc <= MAX_SCNHDR_NRELOC)
+    PUT_SCNHDR_NRELOC(abfd, scnhdr_int->s_nreloc,
+           (bfd_byte *) scnhdr_ext->s_nreloc);
+  else
+    {
+      char buf[sizeof (scnhdr_int->s_name) + 1];
+
+      memcpy (buf, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
+      buf[sizeof (scnhdr_int->s_name)] = '\0';
+      (*_bfd_error_handler) (_("%s: %s: reloc overflow: 0x%lx > 0xffff"),
+                            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);
+      ret = 0;
+    }

 #endif
 
 #endif
 

-#if defined(I960)
-  PUTWORD(abfd, scnhdr_int->s_align, (bfd_byte *) scnhdr_ext->s_align);
+#ifdef I960
+  PUT_SCNHDR_ALIGN (abfd, scnhdr_int->s_align, (bfd_byte *) scnhdr_ext->s_align);
+#endif
+#ifdef COFF_ADJUST_SCNHDR_OUT_POST
+  COFF_ADJUST_SCNHDR_OUT_POST (abfd, in, out);

 #endif
 #endif

-  return sizeof(SCNHDR);
+  return ret;

 }
 }