bfd/coffswap.h

   1 /* Generic COFF swapping routines, for BFD.
   2    Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 98, 1999
   3    Free Software Foundation, Inc.
   4    Written by Cygnus Support.
   5
   6 This file is part of BFD, the Binary File Descriptor library.
   7
   8 This program is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2 of the License, or
  11 (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  21
  22 /* This file contains routines used to swap COFF data.  It is a header
  23    file because the details of swapping depend on the details of the
  24    structures used by each COFF implementation.  This is included by
  25    coffcode.h, as well as by the ECOFF backend.
  26
  27    Any file which uses this must first include "coff/internal.h" and
  28    "coff/CPU.h".  The functions will then be correct for that CPU.  */
  29
  30 #define PUTWORD bfd_h_put_32
  31 #define PUTHALF bfd_h_put_16
  32 #define PUTBYTE bfd_h_put_8
  33
  34 #ifndef GET_FCN_LNNOPTR
  35 #define GET_FCN_LNNOPTR(abfd, ext)  bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
  36 #endif
  37
  38 #ifndef GET_FCN_ENDNDX
  39 #define GET_FCN_ENDNDX(abfd, ext)  bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx)
  40 #endif
  41
  42 #ifndef PUT_FCN_LNNOPTR
  43 #define PUT_FCN_LNNOPTR(abfd, in, ext)  PUTWORD(abfd,  in, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
  44 #endif
  45 #ifndef PUT_FCN_ENDNDX
  46 #define PUT_FCN_ENDNDX(abfd, in, ext) PUTWORD(abfd, in, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx)
  47 #endif
  48 #ifndef GET_LNSZ_LNNO
  49 #define GET_LNSZ_LNNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_misc.x_lnsz.x_lnno)
  50 #endif
  51 #ifndef GET_LNSZ_SIZE
  52 #define GET_LNSZ_SIZE(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_misc.x_lnsz.x_size)
  53 #endif
  54 #ifndef PUT_LNSZ_LNNO
  55 #define PUT_LNSZ_LNNO(abfd, in, ext) bfd_h_put_16(abfd, in, (bfd_byte *)ext->x_sym.x_misc.x_lnsz.x_lnno)
  56 #endif
  57 #ifndef PUT_LNSZ_SIZE
  58 #define PUT_LNSZ_SIZE(abfd, in, ext) bfd_h_put_16(abfd, in, (bfd_byte*) ext->x_sym.x_misc.x_lnsz.x_size)
  59 #endif
  60 #ifndef GET_SCN_SCNLEN
  61 #define GET_SCN_SCNLEN(abfd,  ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_scn.x_scnlen)
  62 #endif
  63 #ifndef GET_SCN_NRELOC
  64 #define GET_SCN_NRELOC(abfd,  ext) bfd_h_get_16(abfd, (bfd_byte *)ext->x_scn.x_nreloc)
  65 #endif
  66 #ifndef GET_SCN_NLINNO
  67 #define GET_SCN_NLINNO(abfd, ext)  bfd_h_get_16(abfd, (bfd_byte *)ext->x_scn.x_nlinno)
  68 #endif
  69 #ifndef PUT_SCN_SCNLEN
  70 #define PUT_SCN_SCNLEN(abfd,in, ext) bfd_h_put_32(abfd, in, (bfd_byte *) ext->x_scn.x_scnlen)
  71 #endif
  72 #ifndef PUT_SCN_NRELOC
  73 #define PUT_SCN_NRELOC(abfd,in, ext) bfd_h_put_16(abfd, in, (bfd_byte *)ext->x_scn.x_nreloc)
  74 #endif
  75 #ifndef PUT_SCN_NLINNO
  76 #define PUT_SCN_NLINNO(abfd,in, ext)  bfd_h_put_16(abfd,in, (bfd_byte  *) ext->x_scn.x_nlinno)
  77 #endif
  78 #ifndef GET_LINENO_LNNO
  79 #define GET_LINENO_LNNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) (ext->l_lnno));
  80 #endif
  81 #ifndef PUT_LINENO_LNNO
  82 #define PUT_LINENO_LNNO(abfd,val, ext) bfd_h_put_16(abfd,val,  (bfd_byte *) (ext->l_lnno));
  83 #endif
  84
  85 /* The f_symptr field in the filehdr is sometimes 64 bits.  */
  86 #ifndef GET_FILEHDR_SYMPTR
  87 #define GET_FILEHDR_SYMPTR bfd_h_get_32
  88 #endif
  89 #ifndef PUT_FILEHDR_SYMPTR
  90 #define PUT_FILEHDR_SYMPTR bfd_h_put_32
  91 #endif
  92
  93 /* Some fields in the aouthdr are sometimes 64 bits.  */
  94 #ifndef GET_AOUTHDR_TSIZE
  95 #define GET_AOUTHDR_TSIZE bfd_h_get_32
  96 #endif
  97 #ifndef PUT_AOUTHDR_TSIZE
  98 #define PUT_AOUTHDR_TSIZE bfd_h_put_32
  99 #endif
 100 #ifndef GET_AOUTHDR_DSIZE
 101 #define GET_AOUTHDR_DSIZE bfd_h_get_32
 102 #endif
 103 #ifndef PUT_AOUTHDR_DSIZE
 104 #define PUT_AOUTHDR_DSIZE bfd_h_put_32
 105 #endif
 106 #ifndef GET_AOUTHDR_BSIZE
 107 #define GET_AOUTHDR_BSIZE bfd_h_get_32
 108 #endif
 109 #ifndef PUT_AOUTHDR_BSIZE
 110 #define PUT_AOUTHDR_BSIZE bfd_h_put_32
 111 #endif
 112 #ifndef GET_AOUTHDR_ENTRY
 113 #define GET_AOUTHDR_ENTRY bfd_h_get_32
 114 #endif
 115 #ifndef PUT_AOUTHDR_ENTRY
 116 #define PUT_AOUTHDR_ENTRY bfd_h_put_32
 117 #endif
 118 #ifndef GET_AOUTHDR_TEXT_START
 119 #define GET_AOUTHDR_TEXT_START bfd_h_get_32
 120 #endif
 121 #ifndef PUT_AOUTHDR_TEXT_START
 122 #define PUT_AOUTHDR_TEXT_START bfd_h_put_32
 123 #endif
 124 #ifndef GET_AOUTHDR_DATA_START
 125 #define GET_AOUTHDR_DATA_START bfd_h_get_32
 126 #endif
 127 #ifndef PUT_AOUTHDR_DATA_START
 128 #define PUT_AOUTHDR_DATA_START bfd_h_put_32
 129 #endif
 130
 131 /* Some fields in the scnhdr are sometimes 64 bits.  */
 132 #ifndef GET_SCNHDR_PADDR
 133 #define GET_SCNHDR_PADDR bfd_h_get_32
 134 #endif
 135 #ifndef PUT_SCNHDR_PADDR
 136 #define PUT_SCNHDR_PADDR bfd_h_put_32
 137 #endif
 138 #ifndef GET_SCNHDR_VADDR
 139 #define GET_SCNHDR_VADDR bfd_h_get_32
 140 #endif
 141 #ifndef PUT_SCNHDR_VADDR
 142 #define PUT_SCNHDR_VADDR bfd_h_put_32
 143 #endif
 144 #ifndef GET_SCNHDR_SIZE
 145 #define GET_SCNHDR_SIZE bfd_h_get_32
 146 #endif
 147 #ifndef PUT_SCNHDR_SIZE
 148 #define PUT_SCNHDR_SIZE bfd_h_put_32
 149 #endif
 150 #ifndef GET_SCNHDR_SCNPTR
 151 #define GET_SCNHDR_SCNPTR bfd_h_get_32
 152 #endif
 153 #ifndef PUT_SCNHDR_SCNPTR
 154 #define PUT_SCNHDR_SCNPTR bfd_h_put_32
 155 #endif
 156 #ifndef GET_SCNHDR_RELPTR
 157 #define GET_SCNHDR_RELPTR bfd_h_get_32
 158 #endif
 159 #ifndef PUT_SCNHDR_RELPTR
 160 #define PUT_SCNHDR_RELPTR bfd_h_put_32
 161 #endif
 162 #ifndef GET_SCNHDR_LNNOPTR
 163 #define GET_SCNHDR_LNNOPTR bfd_h_get_32
 164 #endif
 165 #ifndef PUT_SCNHDR_LNNOPTR
 166 #define PUT_SCNHDR_LNNOPTR bfd_h_put_32
 167 #endif
 168 #ifndef GET_SCNHDR_NRELOC
 169 #define GET_SCNHDR_NRELOC bfd_h_get_16
 170 #endif
 171 #ifndef PUT_SCNHDR_NRELOC
 172 #define PUT_SCNHDR_NRELOC bfd_h_put_16
 173 #endif
 174 #ifndef GET_SCNHDR_NLNNO
 175 #define GET_SCNHDR_NLNNO bfd_h_get_16
 176 #endif
 177 #ifndef PUT_SCNHDR_NLNNO
 178 #define PUT_SCNHDR_NLNNO bfd_h_put_16
 179 #endif
 180 #ifndef GET_SCNHDR_FLAGS
 181 #define GET_SCNHDR_FLAGS bfd_h_get_32
 182 #endif
 183 #ifndef PUT_SCNHDR_FLAGS
 184 #define PUT_SCNHDR_FLAGS bfd_h_put_32
 185 #endif
 186
 187
 188 static void coff_swap_aouthdr_in PARAMS ((bfd *, PTR, PTR));
 189 static unsigned int coff_swap_aouthdr_out PARAMS ((bfd *, PTR, PTR));
 190 static void coff_swap_scnhdr_in PARAMS ((bfd *, PTR, PTR));
 191 static unsigned int coff_swap_scnhdr_out PARAMS ((bfd *, PTR, PTR));
 192 static void coff_swap_filehdr_in PARAMS ((bfd *, PTR, PTR));
 193 static unsigned int coff_swap_filehdr_out PARAMS ((bfd *, PTR, PTR));
 194 #ifndef NO_COFF_RELOCS
 195 static void coff_swap_reloc_in PARAMS ((bfd *, PTR, PTR));
 196 static unsigned int coff_swap_reloc_out PARAMS ((bfd *, PTR, PTR));
 197 #endif /* NO_COFF_RELOCS */
 198 #ifndef NO_COFF_SYMBOLS
 199 static void coff_swap_sym_in PARAMS ((bfd *, PTR, PTR));
 200 static unsigned int coff_swap_sym_out PARAMS ((bfd *, PTR, PTR));
 201 static void coff_swap_aux_in PARAMS ((bfd *, PTR, int, int, int, int, PTR));
 202 static unsigned int coff_swap_aux_out PARAMS ((bfd *, PTR, int, int, int, int, PTR));
 203 #endif /* NO_COFF_SYMBOLS */
 204 #ifndef NO_COFF_LINENOS
 205 static void coff_swap_lineno_in PARAMS ((bfd *, PTR, PTR));
 206 static unsigned int coff_swap_lineno_out PARAMS ((bfd *, PTR, PTR));
 207 #endif /* NO_COFF_LINENOS */
 208
 209 #ifndef NO_COFF_RELOCS
 210
 211 static void
 212 coff_swap_reloc_in (abfd, src, dst)
 213      bfd *abfd;
 214      PTR src;
 215      PTR dst;
 216 {
 217   RELOC *reloc_src = (RELOC *) src;
 218   struct internal_reloc *reloc_dst = (struct internal_reloc *) dst;
 219
 220   reloc_dst->r_vaddr = bfd_h_get_32(abfd, (bfd_byte *)reloc_src->r_vaddr);
 221   reloc_dst->r_symndx = bfd_h_get_signed_32(abfd, (bfd_byte *) reloc_src->r_symndx);
 222
 223 #ifdef RS6000COFF_C
 224   reloc_dst->r_type = bfd_h_get_8(abfd, reloc_src->r_type);
 225   reloc_dst->r_size = bfd_h_get_8(abfd, reloc_src->r_size);
 226 #else
 227   reloc_dst->r_type = bfd_h_get_16(abfd, (bfd_byte *) reloc_src->r_type);
 228 #endif
 229
 230 #ifdef SWAP_IN_RELOC_OFFSET
 231   reloc_dst->r_offset = SWAP_IN_RELOC_OFFSET(abfd,
 232                                              (bfd_byte *) reloc_src->r_offset);
 233 #endif
 234 }
 235
 236 static unsigned int
 237 coff_swap_reloc_out (abfd, src, dst)
 238      bfd       *abfd;
 239      PTR        src;
 240      PTR        dst;
 241 {
 242   struct internal_reloc *reloc_src = (struct internal_reloc *)src;
 243   struct external_reloc *reloc_dst = (struct external_reloc *)dst;
 244   bfd_h_put_32(abfd, reloc_src->r_vaddr, (bfd_byte *) reloc_dst->r_vaddr);
 245   bfd_h_put_32(abfd, reloc_src->r_symndx, (bfd_byte *) reloc_dst->r_symndx);
 246
 247 #ifdef RS6000COFF_C
 248   bfd_h_put_8 (abfd, reloc_src->r_type, (bfd_byte *) reloc_dst->r_type);
 249   bfd_h_put_8 (abfd, reloc_src->r_size, (bfd_byte *) reloc_dst->r_size);
 250 #else
 251   bfd_h_put_16(abfd, reloc_src->r_type, (bfd_byte *)
 252                reloc_dst->r_type);
 253 #endif
 254
 255 #ifdef SWAP_OUT_RELOC_OFFSET
 256   SWAP_OUT_RELOC_OFFSET(abfd,
 257                         reloc_src->r_offset,
 258                         (bfd_byte *) reloc_dst->r_offset);
 259 #endif
 260 #ifdef SWAP_OUT_RELOC_EXTRA
 261   SWAP_OUT_RELOC_EXTRA(abfd,reloc_src, reloc_dst);
 262 #endif
 263
 264   return bfd_coff_relsz (abfd);
 265 }
 266
 267 #endif /* NO_COFF_RELOCS */
 268
 269 static void
 270 coff_swap_filehdr_in (abfd, src, dst)
 271      bfd            *abfd;
 272      PTR             src;
 273      PTR             dst;
 274 {
 275   FILHDR *filehdr_src = (FILHDR *) src;
 276   struct internal_filehdr *filehdr_dst = (struct internal_filehdr *) dst;
 277 #ifdef COFF_ADJUST_FILEHDR_IN_PRE
 278   COFF_ADJUST_FILEHDR_IN_PRE (abfd, src, dst);
 279 #endif
 280   filehdr_dst->f_magic = bfd_h_get_16(abfd, (bfd_byte *) filehdr_src->f_magic);
 281   filehdr_dst->f_nscns = bfd_h_get_16(abfd, (bfd_byte *)filehdr_src-> f_nscns);
 282   filehdr_dst->f_timdat = bfd_h_get_32(abfd, (bfd_byte *)filehdr_src-> f_timdat);
 283   filehdr_dst->f_symptr =
 284     GET_FILEHDR_SYMPTR (abfd, (bfd_byte *) filehdr_src->f_symptr);
 285   filehdr_dst->f_nsyms = bfd_h_get_32(abfd, (bfd_byte *)filehdr_src-> f_nsyms);
 286   filehdr_dst->f_opthdr = bfd_h_get_16(abfd, (bfd_byte *)filehdr_src-> f_opthdr);
 287   filehdr_dst->f_flags = bfd_h_get_16(abfd, (bfd_byte *)filehdr_src-> f_flags);
 288 #ifdef TIC80_TARGET_ID
 289   filehdr_dst->f_target_id = bfd_h_get_16(abfd, (bfd_byte *)filehdr_src-> f_target_id);
 290 #endif
 291
 292 #ifdef COFF_ADJUST_FILEHDR_IN_POST
 293   COFF_ADJUST_FILEHDR_IN_POST (abfd, src, dst);
 294 #endif
 295 }
 296
 297 static  unsigned int
 298 coff_swap_filehdr_out (abfd, in, out)
 299      bfd       *abfd;
 300      PTR        in;
 301      PTR        out;
 302 {
 303   struct internal_filehdr *filehdr_in = (struct internal_filehdr *)in;
 304   FILHDR *filehdr_out = (FILHDR *)out;
 305
 306 #ifdef COFF_ADJUST_FILEHDR_OUT_PRE
 307   COFF_ADJUST_FILEHDR_OUT_PRE (abfd, in, out);
 308 #endif
 309   bfd_h_put_16(abfd, filehdr_in->f_magic, (bfd_byte *) filehdr_out->f_magic);
 310   bfd_h_put_16(abfd, filehdr_in->f_nscns, (bfd_byte *) filehdr_out->f_nscns);
 311   bfd_h_put_32(abfd, filehdr_in->f_timdat, (bfd_byte *) filehdr_out->f_timdat);
 312   PUT_FILEHDR_SYMPTR (abfd, (bfd_vma) filehdr_in->f_symptr,
 313                       (bfd_byte *) filehdr_out->f_symptr);
 314   bfd_h_put_32(abfd, filehdr_in->f_nsyms, (bfd_byte *) filehdr_out->f_nsyms);
 315   bfd_h_put_16(abfd, filehdr_in->f_opthdr, (bfd_byte *) filehdr_out->f_opthdr);
 316   bfd_h_put_16(abfd, filehdr_in->f_flags, (bfd_byte *) filehdr_out->f_flags);
 317 #ifdef TIC80_TARGET_ID
 318   bfd_h_put_16(abfd, filehdr_in->f_target_id, (bfd_byte *) filehdr_out->f_target_id);
 319 #endif
 320
 321 #ifdef COFF_ADJUST_FILEHDR_OUT_POST
 322   COFF_ADJUST_FILEHDR_OUT_POST (abfd, in, out);
 323 #endif
 324   return bfd_coff_filhsz (abfd);
 325 }
 326
 327
 328 #ifndef NO_COFF_SYMBOLS
 329
 330 static void
 331 coff_swap_sym_in (abfd, ext1, in1)
 332      bfd            *abfd;
 333      PTR ext1;
 334      PTR in1;
 335 {
 336   SYMENT *ext = (SYMENT *)ext1;
 337   struct internal_syment      *in = (struct internal_syment *)in1;
 338
 339   if( ext->e.e_name[0] == 0) {
 340     in->_n._n_n._n_zeroes = 0;
 341     in->_n._n_n._n_offset = bfd_h_get_32(abfd, (bfd_byte *) ext->e.e.e_offset);
 342   }
 343   else {
 344 #if SYMNMLEN != E_SYMNMLEN
 345    -> Error, we need to cope with truncating or extending SYMNMLEN!;
 346 #else
 347     memcpy(in->_n._n_name, ext->e.e_name, SYMNMLEN);
 348 #endif
 349   }
 350   in->n_value = bfd_h_get_32(abfd, (bfd_byte *) ext->e_value);
 351   in->n_scnum = bfd_h_get_16(abfd, (bfd_byte *) ext->e_scnum);
 352   if (sizeof(ext->e_type) == 2){
 353     in->n_type = bfd_h_get_16(abfd, (bfd_byte *) ext->e_type);
 354   }
 355   else {
 356     in->n_type = bfd_h_get_32(abfd, (bfd_byte *) ext->e_type);
 357   }
 358   in->n_sclass = bfd_h_get_8(abfd, ext->e_sclass);
 359   in->n_numaux = bfd_h_get_8(abfd, ext->e_numaux);
 360 #ifdef COFF_ADJUST_SYM_IN_POST
 361   COFF_ADJUST_SYM_IN_POST (abfd, ext1, in1);
 362 #endif
 363 }
 364
 365 static unsigned int
 366 coff_swap_sym_out (abfd, inp, extp)
 367      bfd       *abfd;
 368      PTR        inp;
 369      PTR        extp;
 370 {
 371   struct internal_syment *in = (struct internal_syment *)inp;
 372   SYMENT *ext =(SYMENT *)extp;
 373   if(in->_n._n_name[0] == 0) {
 374     bfd_h_put_32(abfd, 0, (bfd_byte *) ext->e.e.e_zeroes);
 375     bfd_h_put_32(abfd, in->_n._n_n._n_offset, (bfd_byte *)  ext->e.e.e_offset);
 376   }
 377   else {
 378 #if SYMNMLEN != E_SYMNMLEN
 379     -> Error, we need to cope with truncating or extending SYMNMLEN!;
 380 #else
 381     memcpy(ext->e.e_name, in->_n._n_name, SYMNMLEN);
 382 #endif
 383   }
 384   bfd_h_put_32(abfd,  in->n_value , (bfd_byte *) ext->e_value);
 385   bfd_h_put_16(abfd,  in->n_scnum , (bfd_byte *) ext->e_scnum);
 386   if (sizeof(ext->e_type) == 2)
 387       {
 388         bfd_h_put_16(abfd,  in->n_type , (bfd_byte *) ext->e_type);
 389       }
 390   else
 391       {
 392         bfd_h_put_32(abfd,  in->n_type , (bfd_byte *) ext->e_type);
 393       }
 394   bfd_h_put_8(abfd,  in->n_sclass , ext->e_sclass);
 395   bfd_h_put_8(abfd,  in->n_numaux , ext->e_numaux);
 396 #ifdef COFF_ADJUST_SYM_OUT_POST
 397   COFF_ADJUST_SYM_OUT_POST (abfd, inp, extp);
 398 #endif
 399   return SYMESZ;
 400 }
 401
 402 static void
 403 coff_swap_aux_in (abfd, ext1, type, class, indx, numaux, in1)
 404      bfd            *abfd;
 405      PTR              ext1;
 406      int             type;
 407      int             class;
 408      int              indx;
 409      int              numaux;
 410      PTR              in1;
 411 {
 412   AUXENT    *ext = (AUXENT *)ext1;
 413   union internal_auxent *in = (union internal_auxent *)in1;
 414
 415 #ifdef COFF_ADJUST_AUX_IN_PRE
 416   COFF_ADJUST_AUX_IN_PRE (abfd, ext1, type, class, indx, numaux, in1);
 417 #endif
 418   switch (class) {
 419     case C_FILE:
 420       if (ext->x_file.x_fname[0] == 0) {
 421           in->x_file.x_n.x_zeroes = 0;
 422           in->x_file.x_n.x_offset =
 423            bfd_h_get_32(abfd, (bfd_byte *) ext->x_file.x_n.x_offset);
 424         } else {
 425 #if FILNMLEN != E_FILNMLEN
 426             -> Error, we need to cope with truncating or extending FILNMLEN!;
 427 #else
 428             if (numaux > 1)
 429               {
 430                 if (indx == 0)
 431                   memcpy (in->x_file.x_fname, ext->x_file.x_fname,
 432                           numaux * sizeof (AUXENT));
 433               }
 434             else
 435               {
 436                 memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
 437               }
 438 #endif
 439           }
 440       goto end;
 441
 442       /* RS/6000 "csect" auxents */
 443 #ifdef RS6000COFF_C
 444     case C_EXT:
 445     case C_HIDEXT:
 446       if (indx + 1 == numaux)
 447         {
 448           in->x_csect.x_scnlen.l = bfd_h_get_32 (abfd, ext->x_csect.x_scnlen);
 449           in->x_csect.x_parmhash = bfd_h_get_32 (abfd,
 450                                                  ext->x_csect.x_parmhash);
 451           in->x_csect.x_snhash   = bfd_h_get_16 (abfd, ext->x_csect.x_snhash);
 452           /* We don't have to hack bitfields in x_smtyp because it's
 453              defined by shifts-and-ands, which are equivalent on all
 454              byte orders.  */
 455           in->x_csect.x_smtyp    = bfd_h_get_8  (abfd, ext->x_csect.x_smtyp);
 456           in->x_csect.x_smclas   = bfd_h_get_8  (abfd, ext->x_csect.x_smclas);
 457           in->x_csect.x_stab     = bfd_h_get_32 (abfd, ext->x_csect.x_stab);
 458           in->x_csect.x_snstab   = bfd_h_get_16 (abfd, ext->x_csect.x_snstab);
 459           goto end;
 460         }
 461       break;
 462 #endif
 463
 464     case C_STAT:
 465 #ifdef C_LEAFSTAT
 466     case C_LEAFSTAT:
 467 #endif
 468     case C_HIDDEN:
 469       if (type == T_NULL) {
 470           in->x_scn.x_scnlen = GET_SCN_SCNLEN(abfd, ext);
 471           in->x_scn.x_nreloc = GET_SCN_NRELOC(abfd, ext);
 472           in->x_scn.x_nlinno = GET_SCN_NLINNO(abfd, ext);
 473
 474           /* PE defines some extra fields; we zero them out for
 475              safety.  */
 476           in->x_scn.x_checksum = 0;
 477           in->x_scn.x_associated = 0;
 478           in->x_scn.x_comdat = 0;
 479
 480           goto end;
 481         }
 482       break;
 483     }
 484
 485   in->x_sym.x_tagndx.l = bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_tagndx);
 486 #ifndef NO_TVNDX
 487   in->x_sym.x_tvndx = bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_tvndx);
 488 #endif
 489
 490   if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
 491     {
 492       in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR (abfd, ext);
 493       in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX (abfd, ext);
 494     }
 495   else
 496     {
 497 #if DIMNUM != E_DIMNUM
 498  #error we need to cope with truncating or extending DIMNUM
 499 #endif
 500       in->x_sym.x_fcnary.x_ary.x_dimen[0] =
 501         bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
 502       in->x_sym.x_fcnary.x_ary.x_dimen[1] =
 503         bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
 504       in->x_sym.x_fcnary.x_ary.x_dimen[2] =
 505         bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
 506       in->x_sym.x_fcnary.x_ary.x_dimen[3] =
 507         bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
 508     }
 509
 510   if (ISFCN(type)) {
 511     in->x_sym.x_misc.x_fsize = bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_misc.x_fsize);
 512   }
 513   else {
 514     in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO(abfd, ext);
 515     in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE(abfd, ext);
 516   }
 517
 518 end: ;
 519   /* the semicolon is because MSVC doesn't like labels at
 520      end of block. */
 521
 522 #ifdef COFF_ADJUST_AUX_IN_POST
 523   COFF_ADJUST_AUX_IN_POST (abfd, ext1, type, class, indx, numaux, in1);
 524 #endif
 525 }
 526
 527 static unsigned int
 528 coff_swap_aux_out (abfd, inp, type, class, indx, numaux, extp)
 529      bfd   *abfd;
 530      PTR        inp;
 531      int   type;
 532      int   class;
 533      int   indx ATTRIBUTE_UNUSED;
 534      int   numaux ATTRIBUTE_UNUSED;
 535      PTR        extp;
 536 {
 537   union internal_auxent *in = (union internal_auxent *)inp;
 538   AUXENT *ext = (AUXENT *)extp;
 539
 540 #ifdef COFF_ADJUST_AUX_OUT_PRE
 541   COFF_ADJUST_AUX_OUT_PRE (abfd, inp, type, class, indx, numaux, extp);
 542 #endif
 543   memset((PTR)ext, 0, AUXESZ);
 544   switch (class) {
 545   case C_FILE:
 546     if (in->x_file.x_fname[0] == 0) {
 547       PUTWORD(abfd, 0, (bfd_byte *) ext->x_file.x_n.x_zeroes);
 548       PUTWORD(abfd,
 549               in->x_file.x_n.x_offset,
 550               (bfd_byte *) ext->x_file.x_n.x_offset);
 551     }
 552     else {
 553 #if FILNMLEN != E_FILNMLEN
 554       -> Error, we need to cope with truncating or extending FILNMLEN!;
 555 #else
 556       memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
 557 #endif
 558     }
 559     goto end;
 560
 561 #ifdef RS6000COFF_C
 562   /* RS/6000 "csect" auxents */
 563   case C_EXT:
 564   case C_HIDEXT:
 565     if (indx + 1 == numaux)
 566       {
 567         PUTWORD (abfd, in->x_csect.x_scnlen.l,  ext->x_csect.x_scnlen);
 568         PUTWORD (abfd, in->x_csect.x_parmhash,  ext->x_csect.x_parmhash);
 569         PUTHALF (abfd, in->x_csect.x_snhash,    ext->x_csect.x_snhash);
 570         /* We don't have to hack bitfields in x_smtyp because it's
 571            defined by shifts-and-ands, which are equivalent on all
 572            byte orders.  */
 573         PUTBYTE (abfd, in->x_csect.x_smtyp,     ext->x_csect.x_smtyp);
 574         PUTBYTE (abfd, in->x_csect.x_smclas,    ext->x_csect.x_smclas);
 575         PUTWORD (abfd, in->x_csect.x_stab,      ext->x_csect.x_stab);
 576         PUTHALF (abfd, in->x_csect.x_snstab,    ext->x_csect.x_snstab);
 577         goto end;
 578       }
 579     break;
 580 #endif
 581
 582   case C_STAT:
 583 #ifdef C_LEAFSTAT
 584   case C_LEAFSTAT:
 585 #endif
 586   case C_HIDDEN:
 587     if (type == T_NULL) {
 588       PUT_SCN_SCNLEN(abfd, in->x_scn.x_scnlen, ext);
 589       PUT_SCN_NRELOC(abfd, in->x_scn.x_nreloc, ext);
 590       PUT_SCN_NLINNO(abfd, in->x_scn.x_nlinno, ext);
 591       goto end;
 592     }
 593     break;
 594   }
 595
 596   PUTWORD(abfd, in->x_sym.x_tagndx.l, (bfd_byte *) ext->x_sym.x_tagndx);
 597 #ifndef NO_TVNDX
 598   bfd_h_put_16(abfd, in->x_sym.x_tvndx , (bfd_byte *) ext->x_sym.x_tvndx);
 599 #endif
 600
 601   if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
 602     {
 603       PUT_FCN_LNNOPTR(abfd,  in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext);
 604       PUT_FCN_ENDNDX(abfd,  in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext);
 605     }
 606   else
 607     {
 608 #if DIMNUM != E_DIMNUM
 609  #error we need to cope with truncating or extending DIMNUM
 610 #endif
 611       bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],
 612                     (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
 613       bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],
 614                     (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
 615       bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],
 616                     (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
 617       bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],
 618                     (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
 619     }
 620
 621   if (ISFCN (type))
 622     PUTWORD (abfd, in->x_sym.x_misc.x_fsize,
 623              (bfd_byte *)  ext->x_sym.x_misc.x_fsize);
 624   else
 625     {
 626       PUT_LNSZ_LNNO (abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext);
 627       PUT_LNSZ_SIZE (abfd, in->x_sym.x_misc.x_lnsz.x_size, ext);
 628     }
 629
 630 end:
 631 #ifdef COFF_ADJUST_AUX_OUT_POST
 632   COFF_ADJUST_AUX_OUT_POST (abfd, inp, type, class, indx, numaux, extp);
 633 #endif
 634   return AUXESZ;
 635 }
 636
 637 #endif /* NO_COFF_SYMBOLS */
 638
 639 #ifndef NO_COFF_LINENOS
 640
 641 static void
 642 coff_swap_lineno_in (abfd, ext1, in1)
 643      bfd            *abfd;
 644      PTR ext1;
 645      PTR in1;
 646 {
 647   LINENO *ext = (LINENO *)ext1;
 648   struct internal_lineno      *in = (struct internal_lineno *)in1;
 649
 650   in->l_addr.l_symndx = bfd_h_get_32(abfd, (bfd_byte *) ext->l_addr.l_symndx);
 651   in->l_lnno = GET_LINENO_LNNO(abfd, ext);
 652 }
 653
 654 static unsigned int
 655 coff_swap_lineno_out (abfd, inp, outp)
 656      bfd       *abfd;
 657      PTR        inp;
 658      PTR        outp;
 659 {
 660   struct internal_lineno *in = (struct internal_lineno *)inp;
 661   struct external_lineno *ext = (struct external_lineno *)outp;
 662   PUTWORD(abfd, in->l_addr.l_symndx, (bfd_byte *)
 663           ext->l_addr.l_symndx);
 664
 665   PUT_LINENO_LNNO (abfd, in->l_lnno, ext);
 666   return LINESZ;
 667 }
 668
 669 #endif /* NO_COFF_LINENOS */
 670
 671 static void
 672 coff_swap_aouthdr_in (abfd, aouthdr_ext1, aouthdr_int1)
 673      bfd            *abfd;
 674      PTR aouthdr_ext1;
 675      PTR aouthdr_int1;
 676 {
 677   AOUTHDR        *aouthdr_ext = (AOUTHDR *) aouthdr_ext1;
 678   struct internal_aouthdr *aouthdr_int = (struct internal_aouthdr *)aouthdr_int1;
 679
 680   aouthdr_int->magic = bfd_h_get_16(abfd, (bfd_byte *) aouthdr_ext->magic);
 681   aouthdr_int->vstamp = bfd_h_get_16(abfd, (bfd_byte *) aouthdr_ext->vstamp);
 682   aouthdr_int->tsize =
 683     GET_AOUTHDR_TSIZE (abfd, (bfd_byte *) aouthdr_ext->tsize);
 684   aouthdr_int->dsize =
 685     GET_AOUTHDR_DSIZE (abfd, (bfd_byte *) aouthdr_ext->dsize);
 686   aouthdr_int->bsize =
 687     GET_AOUTHDR_BSIZE (abfd, (bfd_byte *) aouthdr_ext->bsize);
 688   aouthdr_int->entry =
 689     GET_AOUTHDR_ENTRY (abfd, (bfd_byte *) aouthdr_ext->entry);
 690   aouthdr_int->text_start =
 691     GET_AOUTHDR_TEXT_START (abfd, (bfd_byte *) aouthdr_ext->text_start);
 692   aouthdr_int->data_start =
 693     GET_AOUTHDR_DATA_START (abfd, (bfd_byte *) aouthdr_ext->data_start);
 694
 695 #ifdef I960
 696   aouthdr_int->tagentries = bfd_h_get_32(abfd, (bfd_byte *) aouthdr_ext->tagentries);
 697 #endif
 698
 699 #ifdef APOLLO_M68
 700   bfd_h_put_32(abfd, aouthdr_int->o_inlib, (bfd_byte *) aouthdr_ext->o_inlib);
 701   bfd_h_put_32(abfd, aouthdr_int->o_sri, (bfd_byte *) aouthdr_ext->o_sri);
 702   bfd_h_put_32(abfd, aouthdr_int->vid[0], (bfd_byte *) aouthdr_ext->vid);
 703   bfd_h_put_32(abfd, aouthdr_int->vid[1], (bfd_byte *) aouthdr_ext->vid + 4);
 704 #endif
 705
 706
 707 #ifdef RS6000COFF_C
 708   aouthdr_int->o_toc = bfd_h_get_32(abfd, aouthdr_ext->o_toc);
 709   aouthdr_int->o_snentry = bfd_h_get_16(abfd, aouthdr_ext->o_snentry);
 710   aouthdr_int->o_sntext = bfd_h_get_16(abfd, aouthdr_ext->o_sntext);
 711   aouthdr_int->o_sndata = bfd_h_get_16(abfd, aouthdr_ext->o_sndata);
 712   aouthdr_int->o_sntoc = bfd_h_get_16(abfd, aouthdr_ext->o_sntoc);
 713   aouthdr_int->o_snloader = bfd_h_get_16(abfd, aouthdr_ext->o_snloader);
 714   aouthdr_int->o_snbss = bfd_h_get_16(abfd, aouthdr_ext->o_snbss);
 715   aouthdr_int->o_algntext = bfd_h_get_16(abfd, aouthdr_ext->o_algntext);
 716   aouthdr_int->o_algndata = bfd_h_get_16(abfd, aouthdr_ext->o_algndata);
 717   aouthdr_int->o_modtype = bfd_h_get_16(abfd, aouthdr_ext->o_modtype);
 718   aouthdr_int->o_cputype = bfd_h_get_16(abfd, aouthdr_ext->o_cputype);
 719   aouthdr_int->o_maxstack = bfd_h_get_32(abfd, aouthdr_ext->o_maxstack);
 720   aouthdr_int->o_maxdata = bfd_h_get_32(abfd, aouthdr_ext->o_maxdata);
 721 #endif
 722
 723 #ifdef MIPSECOFF
 724   aouthdr_int->bss_start = bfd_h_get_32(abfd, aouthdr_ext->bss_start);
 725   aouthdr_int->gp_value = bfd_h_get_32(abfd, aouthdr_ext->gp_value);
 726   aouthdr_int->gprmask = bfd_h_get_32(abfd, aouthdr_ext->gprmask);
 727   aouthdr_int->cprmask[0] = bfd_h_get_32(abfd, aouthdr_ext->cprmask[0]);
 728   aouthdr_int->cprmask[1] = bfd_h_get_32(abfd, aouthdr_ext->cprmask[1]);
 729   aouthdr_int->cprmask[2] = bfd_h_get_32(abfd, aouthdr_ext->cprmask[2]);
 730   aouthdr_int->cprmask[3] = bfd_h_get_32(abfd, aouthdr_ext->cprmask[3]);
 731 #endif
 732
 733 #ifdef ALPHAECOFF
 734   aouthdr_int->bss_start = bfd_h_get_64(abfd, aouthdr_ext->bss_start);
 735   aouthdr_int->gp_value = bfd_h_get_64(abfd, aouthdr_ext->gp_value);
 736   aouthdr_int->gprmask = bfd_h_get_32(abfd, aouthdr_ext->gprmask);
 737   aouthdr_int->fprmask = bfd_h_get_32(abfd, aouthdr_ext->fprmask);
 738 #endif
 739 }
 740
 741 static unsigned int
 742 coff_swap_aouthdr_out (abfd, in, out)
 743      bfd       *abfd;
 744      PTR        in;
 745      PTR        out;
 746 {
 747   struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *)in;
 748   AOUTHDR *aouthdr_out = (AOUTHDR *)out;
 749
 750   bfd_h_put_16(abfd, aouthdr_in->magic, (bfd_byte *) aouthdr_out->magic);
 751   bfd_h_put_16(abfd, aouthdr_in->vstamp, (bfd_byte *) aouthdr_out->vstamp);
 752   PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, (bfd_byte *) aouthdr_out->tsize);
 753   PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, (bfd_byte *) aouthdr_out->dsize);
 754   PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, (bfd_byte *) aouthdr_out->bsize);
 755   PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, (bfd_byte *) aouthdr_out->entry);
 756   PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
 757                           (bfd_byte *) aouthdr_out->text_start);
 758   PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
 759                           (bfd_byte *) aouthdr_out->data_start);
 760
 761 #ifdef I960
 762   bfd_h_put_32(abfd, aouthdr_in->tagentries, (bfd_byte *) aouthdr_out->tagentries);
 763 #endif
 764
 765 #ifdef RS6000COFF_C
 766   bfd_h_put_32 (abfd, aouthdr_in->o_toc, aouthdr_out->o_toc);
 767   bfd_h_put_16 (abfd, aouthdr_in->o_snentry, aouthdr_out->o_snentry);
 768   bfd_h_put_16 (abfd, aouthdr_in->o_sntext, aouthdr_out->o_sntext);
 769   bfd_h_put_16 (abfd, aouthdr_in->o_sndata, aouthdr_out->o_sndata);
 770   bfd_h_put_16 (abfd, aouthdr_in->o_sntoc, aouthdr_out->o_sntoc);
 771   bfd_h_put_16 (abfd, aouthdr_in->o_snloader, aouthdr_out->o_snloader);
 772   bfd_h_put_16 (abfd, aouthdr_in->o_snbss, aouthdr_out->o_snbss);
 773   bfd_h_put_16 (abfd, aouthdr_in->o_algntext, aouthdr_out->o_algntext);
 774   bfd_h_put_16 (abfd, aouthdr_in->o_algndata, aouthdr_out->o_algndata);
 775   bfd_h_put_16 (abfd, aouthdr_in->o_modtype, aouthdr_out->o_modtype);
 776   bfd_h_put_16 (abfd, aouthdr_in->o_cputype, aouthdr_out->o_cputype);
 777   bfd_h_put_32 (abfd, aouthdr_in->o_maxstack, aouthdr_out->o_maxstack);
 778   bfd_h_put_32 (abfd, aouthdr_in->o_maxdata, aouthdr_out->o_maxdata);
 779   memset (aouthdr_out->o_resv2, 0, sizeof aouthdr_out->o_resv2);
 780 #endif
 781
 782 #ifdef MIPSECOFF
 783   bfd_h_put_32(abfd, aouthdr_in->bss_start, (bfd_byte *) aouthdr_out->bss_start);
 784   bfd_h_put_32(abfd, aouthdr_in->gp_value, (bfd_byte *) aouthdr_out->gp_value);
 785   bfd_h_put_32(abfd, aouthdr_in->gprmask, (bfd_byte *) aouthdr_out->gprmask);
 786   bfd_h_put_32(abfd, aouthdr_in->cprmask[0], (bfd_byte *) aouthdr_out->cprmask[0]);
 787   bfd_h_put_32(abfd, aouthdr_in->cprmask[1], (bfd_byte *) aouthdr_out->cprmask[1]);
 788   bfd_h_put_32(abfd, aouthdr_in->cprmask[2], (bfd_byte *) aouthdr_out->cprmask[2]);
 789   bfd_h_put_32(abfd, aouthdr_in->cprmask[3], (bfd_byte *) aouthdr_out->cprmask[3]);
 790 #endif
 791
 792 #ifdef ALPHAECOFF
 793   /* FIXME: What does bldrev mean?  */
 794   bfd_h_put_16(abfd, (bfd_vma) 2, (bfd_byte *) aouthdr_out->bldrev);
 795   bfd_h_put_16(abfd, (bfd_vma) 0, (bfd_byte *) aouthdr_out->padding);
 796   bfd_h_put_64(abfd, aouthdr_in->bss_start, (bfd_byte *) aouthdr_out->bss_start);
 797   bfd_h_put_64(abfd, aouthdr_in->gp_value, (bfd_byte *) aouthdr_out->gp_value);
 798   bfd_h_put_32(abfd, aouthdr_in->gprmask, (bfd_byte *) aouthdr_out->gprmask);
 799   bfd_h_put_32(abfd, aouthdr_in->fprmask, (bfd_byte *) aouthdr_out->fprmask);
 800 #endif
 801
 802   return AOUTSZ;
 803 }
 804
 805 static void
 806 coff_swap_scnhdr_in (abfd, ext, in)
 807      bfd            *abfd;
 808      PTR             ext;
 809      PTR             in;
 810 {
 811   SCNHDR *scnhdr_ext = (SCNHDR *) ext;
 812   struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
 813
 814 #ifdef COFF_ADJUST_SCNHDR_IN_PRE
 815   COFF_ADJUST_SCNHDR_IN_PRE (abfd, ext, in);
 816 #endif
 817   memcpy(scnhdr_int->s_name, scnhdr_ext->s_name, sizeof(scnhdr_int->s_name));
 818   scnhdr_int->s_vaddr =
 819     GET_SCNHDR_VADDR (abfd, (bfd_byte *) scnhdr_ext->s_vaddr);
 820   scnhdr_int->s_paddr =
 821     GET_SCNHDR_PADDR (abfd, (bfd_byte *) scnhdr_ext->s_paddr);
 822   scnhdr_int->s_size =
 823     GET_SCNHDR_SIZE (abfd, (bfd_byte *) scnhdr_ext->s_size);
 824
 825   scnhdr_int->s_scnptr =
 826     GET_SCNHDR_SCNPTR (abfd, (bfd_byte *) scnhdr_ext->s_scnptr);
 827   scnhdr_int->s_relptr =
 828     GET_SCNHDR_RELPTR (abfd, (bfd_byte *) scnhdr_ext->s_relptr);
 829   scnhdr_int->s_lnnoptr =
 830     GET_SCNHDR_LNNOPTR (abfd, (bfd_byte *) scnhdr_ext->s_lnnoptr);
 831   scnhdr_int->s_flags =
 832     GET_SCNHDR_FLAGS (abfd, (bfd_byte *) scnhdr_ext->s_flags);
 833   scnhdr_int->s_nreloc =
 834     GET_SCNHDR_NRELOC (abfd, (bfd_byte *) scnhdr_ext->s_nreloc);
 835   scnhdr_int->s_nlnno =
 836     GET_SCNHDR_NLNNO (abfd, (bfd_byte *) scnhdr_ext->s_nlnno);
 837 #ifdef I960
 838   scnhdr_int->s_align =
 839     GET_SCNHDR_ALIGN (abfd, (bfd_byte *) scnhdr_ext->s_align);
 840 #endif
 841 #ifdef COFF_ADJUST_SCNHDR_IN_POST
 842   COFF_ADJUST_SCNHDR_IN_POST (abfd, ext, in);
 843 #endif
 844 }
 845
 846 static unsigned int
 847 coff_swap_scnhdr_out (abfd, in, out)
 848      bfd       *abfd;
 849      PTR        in;
 850      PTR        out;
 851 {
 852   struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *)in;
 853   SCNHDR *scnhdr_ext = (SCNHDR *)out;
 854   unsigned int ret = bfd_coff_scnhsz (abfd);
 855
 856 #ifdef COFF_ADJUST_SCNHDR_OUT_PRE
 857   COFF_ADJUST_SCNHDR_OUT_PRE (abfd, in, out);
 858 #endif
 859   memcpy(scnhdr_ext->s_name, scnhdr_int->s_name, sizeof(scnhdr_int->s_name));
 860
 861   PUT_SCNHDR_VADDR (abfd, scnhdr_int->s_vaddr,
 862                     (bfd_byte *) scnhdr_ext->s_vaddr);
 863
 864
 865   PUT_SCNHDR_PADDR (abfd, scnhdr_int->s_paddr,
 866                     (bfd_byte *) scnhdr_ext->s_paddr);
 867   PUT_SCNHDR_SIZE (abfd, scnhdr_int->s_size,
 868                    (bfd_byte *) scnhdr_ext->s_size);
 869
 870   PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,
 871                      (bfd_byte *) scnhdr_ext->s_scnptr);
 872   PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,
 873                      (bfd_byte *) scnhdr_ext->s_relptr);
 874   PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,
 875                       (bfd_byte *) scnhdr_ext->s_lnnoptr);
 876   PUT_SCNHDR_FLAGS (abfd, scnhdr_int->s_flags,
 877                     (bfd_byte *) scnhdr_ext->s_flags);
 878 #if defined(M88)
 879   PUTWORD(abfd, scnhdr_int->s_nlnno, (bfd_byte *) scnhdr_ext->s_nlnno);
 880   PUTWORD(abfd, scnhdr_int->s_nreloc, (bfd_byte *) scnhdr_ext->s_nreloc);
 881 #else
 882   if (scnhdr_int->s_nlnno <= 0xffff)
 883     PUTHALF(abfd, scnhdr_int->s_nlnno, (bfd_byte *) scnhdr_ext->s_nlnno);
 884   else
 885     {
 886       char buf[sizeof (scnhdr_int->s_name) + 1];
 887
 888       memcpy (buf, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
 889       buf[sizeof (scnhdr_int->s_name)] = '\0';
 890       (*_bfd_error_handler)
 891         (_("%s: warning: %s: line number overflow: 0x%lx > 0xffff"),
 892          bfd_get_filename (abfd),
 893          buf, scnhdr_int->s_nlnno);
 894       PUTHALF (abfd, 0xffff, (bfd_byte *) scnhdr_ext->s_nlnno);
 895     }
 896   if (scnhdr_int->s_nreloc <= 0xffff)
 897     PUTHALF(abfd, scnhdr_int->s_nreloc, (bfd_byte *) scnhdr_ext->s_nreloc);
 898   else
 899     {
 900       char buf[sizeof (scnhdr_int->s_name) + 1];
 901
 902       memcpy (buf, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
 903       buf[sizeof (scnhdr_int->s_name)] = '\0';
 904       (*_bfd_error_handler) (_("%s: %s: reloc overflow: 0x%lx > 0xffff"),
 905                              bfd_get_filename (abfd),
 906                              buf, scnhdr_int->s_nreloc);
 907       bfd_set_error (bfd_error_file_truncated);
 908       PUTHALF (abfd, 0xffff, (bfd_byte *) scnhdr_ext->s_nreloc);
 909       ret = 0;
 910     }
 911 #endif
 912
 913 #ifdef I960
 914   PUT_SCNHDR_ALIGN (abfd, scnhdr_int->s_align, (bfd_byte *) scnhdr_ext->s_align);
 915 #endif
 916 #ifdef COFF_ADJUST_SCNHDR_OUT_POST
 917   COFF_ADJUST_SCNHDR_OUT_POST (abfd, in, out);
 918 #endif
 919   return ret;
 920 }