Home | History | Annotate | Download | only in bfd
      1 /* Generic ECOFF swapping routines, for BFD.
      2    Copyright (C) 1992-2014 Free Software Foundation, Inc.
      3    Written by Cygnus Support.
      4 
      5    This file is part of BFD, the Binary File Descriptor library.
      6 
      7    This program is free software; you can redistribute it and/or modify
      8    it under the terms of the GNU General Public License as published by
      9    the Free Software Foundation; either version 3 of the License, or
     10    (at your option) any later version.
     11 
     12    This program is distributed in the hope that it will be useful,
     13    but WITHOUT ANY WARRANTY; without even the implied warranty of
     14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     15    GNU General Public License for more details.
     16 
     17    You should have received a copy of the GNU General Public License
     18    along with this program; if not, write to the Free Software
     19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
     20    MA 02110-1301, USA.  */
     21 
     22 
     23 /* NOTE: This is a header file, but it contains executable routines.
     24    This is done this way because these routines are substantially
     25    similar, but are not identical, for all ECOFF targets.
     26 
     27    These are routines to swap the ECOFF symbolic information in and
     28    out.  The routines are defined statically.  You can set breakpoints
     29    on them in gdb by naming the including source file; e.g.,
     30    'coff-mips.c':ecoff_swap_hdr_in.
     31 
     32    Before including this header file, one of ECOFF_32, ECOFF_64,
     33    ECOFF_SIGNED_32 or ECOFF_SIGNED_64 must be defined.  These are
     34    checked when swapping information that depends upon the target
     35    size.  This code works for 32 bit and 64 bit ECOFF, but may need to
     36    be generalized in the future.
     37 
     38    Some header file which defines the external forms of these
     39    structures must also be included before including this header file.
     40    Currently this is either coff/mips.h or coff/alpha.h.
     41 
     42    If the symbol TEST is defined when this file is compiled, a
     43    comparison is made to ensure that, in fact, the output is
     44    bit-for-bit the same as the input.  Of course, this symbol should
     45    only be defined when deliberately testing the code on a machine
     46    with the proper byte sex and such.  */
     47 
     48 #ifdef ECOFF_32
     49 #define ECOFF_GET_OFF H_GET_32
     50 #define ECOFF_PUT_OFF H_PUT_32
     51 #endif
     52 #ifdef ECOFF_64
     53 #define ECOFF_GET_OFF H_GET_64
     54 #define ECOFF_PUT_OFF H_PUT_64
     55 #endif
     56 #ifdef ECOFF_SIGNED_32
     57 #define ECOFF_GET_OFF H_GET_S32
     58 #define ECOFF_PUT_OFF H_PUT_S32
     59 #endif
     60 #ifdef ECOFF_SIGNED_64
     61 #define ECOFF_GET_OFF H_GET_S64
     62 #define ECOFF_PUT_OFF H_PUT_S64
     63 #endif
     64 
     65 /* ECOFF auxiliary information swapping routines.  These are the same
     66    for all ECOFF targets, so they are defined in ecofflink.c.  */
     67 
     68 extern void _bfd_ecoff_swap_tir_in
     69   (int, const struct tir_ext *, TIR *);
     70 extern void _bfd_ecoff_swap_tir_out
     71   (int, const TIR *, struct tir_ext *);
     72 extern void _bfd_ecoff_swap_rndx_in
     73   (int, const struct rndx_ext *, RNDXR *);
     74 extern void _bfd_ecoff_swap_rndx_out
     75   (int, const RNDXR *, struct rndx_ext *);
     76 
     77 /* Prototypes for functions defined in this file.  */
     78 
     79 static void ecoff_swap_hdr_in (bfd *, void *, HDRR *);
     80 static void ecoff_swap_hdr_out (bfd *, const HDRR *, void *);
     81 static void ecoff_swap_fdr_in (bfd *, void *, FDR *);
     82 static void ecoff_swap_fdr_out (bfd *, const FDR *, void *);
     83 static void ecoff_swap_pdr_in (bfd *, void *, PDR *);
     84 static void ecoff_swap_pdr_out (bfd *, const PDR *, void *);
     85 static void ecoff_swap_sym_in (bfd *, void *, SYMR *);
     86 static void ecoff_swap_sym_out (bfd *, const SYMR *, void *);
     87 static void ecoff_swap_ext_in (bfd *, void *, EXTR *);
     88 static void ecoff_swap_ext_out (bfd *, const EXTR *, void *);
     89 static void ecoff_swap_rfd_in (bfd *, void *, RFDT *);
     90 static void ecoff_swap_rfd_out (bfd *, const RFDT *, void *);
     91 static void ecoff_swap_opt_in (bfd *, void *, OPTR *);
     92 static void ecoff_swap_opt_out (bfd *, const OPTR *, void *);
     93 static void ecoff_swap_dnr_in (bfd *, void *, DNR *);
     94 static void ecoff_swap_dnr_out (bfd *, const DNR *, void *);
     95 
     96 /* Swap in the symbolic header.  */
     97 
     98 static void
     99 ecoff_swap_hdr_in (bfd *abfd, void * ext_copy, HDRR *intern)
    100 {
    101   struct hdr_ext ext[1];
    102 
    103   *ext = *(struct hdr_ext *) ext_copy;
    104 
    105   intern->magic         = H_GET_S16     (abfd, ext->h_magic);
    106   intern->vstamp        = H_GET_S16     (abfd, ext->h_vstamp);
    107   intern->ilineMax      = H_GET_32      (abfd, ext->h_ilineMax);
    108   intern->cbLine        = ECOFF_GET_OFF (abfd, ext->h_cbLine);
    109   intern->cbLineOffset  = ECOFF_GET_OFF (abfd, ext->h_cbLineOffset);
    110   intern->idnMax        = H_GET_32      (abfd, ext->h_idnMax);
    111   intern->cbDnOffset    = ECOFF_GET_OFF (abfd, ext->h_cbDnOffset);
    112   intern->ipdMax        = H_GET_32      (abfd, ext->h_ipdMax);
    113   intern->cbPdOffset    = ECOFF_GET_OFF (abfd, ext->h_cbPdOffset);
    114   intern->isymMax       = H_GET_32      (abfd, ext->h_isymMax);
    115   intern->cbSymOffset   = ECOFF_GET_OFF (abfd, ext->h_cbSymOffset);
    116   intern->ioptMax       = H_GET_32      (abfd, ext->h_ioptMax);
    117   intern->cbOptOffset   = ECOFF_GET_OFF (abfd, ext->h_cbOptOffset);
    118   intern->iauxMax       = H_GET_32      (abfd, ext->h_iauxMax);
    119   intern->cbAuxOffset   = ECOFF_GET_OFF (abfd, ext->h_cbAuxOffset);
    120   intern->issMax        = H_GET_32      (abfd, ext->h_issMax);
    121   intern->cbSsOffset    = ECOFF_GET_OFF (abfd, ext->h_cbSsOffset);
    122   intern->issExtMax     = H_GET_32      (abfd, ext->h_issExtMax);
    123   intern->cbSsExtOffset = ECOFF_GET_OFF (abfd, ext->h_cbSsExtOffset);
    124   intern->ifdMax        = H_GET_32      (abfd, ext->h_ifdMax);
    125   intern->cbFdOffset    = ECOFF_GET_OFF (abfd, ext->h_cbFdOffset);
    126   intern->crfd          = H_GET_32      (abfd, ext->h_crfd);
    127   intern->cbRfdOffset   = ECOFF_GET_OFF (abfd, ext->h_cbRfdOffset);
    128   intern->iextMax       = H_GET_32      (abfd, ext->h_iextMax);
    129   intern->cbExtOffset   = ECOFF_GET_OFF (abfd, ext->h_cbExtOffset);
    130 
    131 #ifdef TEST
    132   if (memcmp ((char *) ext, (char *) intern, sizeof (*intern)) != 0)
    133     abort ();
    134 #endif
    135 }
    136 
    137 /* Swap out the symbolic header.  */
    138 
    139 static void
    140 ecoff_swap_hdr_out (bfd *abfd, const HDRR *intern_copy, void * ext_ptr)
    141 {
    142   struct hdr_ext *ext = (struct hdr_ext *) ext_ptr;
    143   HDRR intern[1];
    144 
    145   *intern = *intern_copy;
    146 
    147   H_PUT_S16     (abfd, intern->magic,         ext->h_magic);
    148   H_PUT_S16     (abfd, intern->vstamp,        ext->h_vstamp);
    149   H_PUT_32      (abfd, intern->ilineMax,      ext->h_ilineMax);
    150   ECOFF_PUT_OFF (abfd, intern->cbLine,        ext->h_cbLine);
    151   ECOFF_PUT_OFF (abfd, intern->cbLineOffset,  ext->h_cbLineOffset);
    152   H_PUT_32      (abfd, intern->idnMax,        ext->h_idnMax);
    153   ECOFF_PUT_OFF (abfd, intern->cbDnOffset,    ext->h_cbDnOffset);
    154   H_PUT_32      (abfd, intern->ipdMax,        ext->h_ipdMax);
    155   ECOFF_PUT_OFF (abfd, intern->cbPdOffset,    ext->h_cbPdOffset);
    156   H_PUT_32      (abfd, intern->isymMax,       ext->h_isymMax);
    157   ECOFF_PUT_OFF (abfd, intern->cbSymOffset,   ext->h_cbSymOffset);
    158   H_PUT_32      (abfd, intern->ioptMax,       ext->h_ioptMax);
    159   ECOFF_PUT_OFF (abfd, intern->cbOptOffset,   ext->h_cbOptOffset);
    160   H_PUT_32      (abfd, intern->iauxMax,       ext->h_iauxMax);
    161   ECOFF_PUT_OFF (abfd, intern->cbAuxOffset,   ext->h_cbAuxOffset);
    162   H_PUT_32      (abfd, intern->issMax,        ext->h_issMax);
    163   ECOFF_PUT_OFF (abfd, intern->cbSsOffset,    ext->h_cbSsOffset);
    164   H_PUT_32      (abfd, intern->issExtMax,     ext->h_issExtMax);
    165   ECOFF_PUT_OFF (abfd, intern->cbSsExtOffset, ext->h_cbSsExtOffset);
    166   H_PUT_32      (abfd, intern->ifdMax,        ext->h_ifdMax);
    167   ECOFF_PUT_OFF (abfd, intern->cbFdOffset,    ext->h_cbFdOffset);
    168   H_PUT_32      (abfd, intern->crfd,          ext->h_crfd);
    169   ECOFF_PUT_OFF (abfd, intern->cbRfdOffset,   ext->h_cbRfdOffset);
    170   H_PUT_32      (abfd, intern->iextMax,       ext->h_iextMax);
    171   ECOFF_PUT_OFF (abfd, intern->cbExtOffset,   ext->h_cbExtOffset);
    172 
    173 #ifdef TEST
    174   if (memcmp ((char *) ext, (char *) intern, sizeof (*intern)) != 0)
    175     abort ();
    176 #endif
    177 }
    178 
    179 /* Swap in the file descriptor record.  */
    180 
    181 static void
    182 ecoff_swap_fdr_in (bfd *abfd, void * ext_copy, FDR *intern)
    183 {
    184   struct fdr_ext ext[1];
    185 
    186   *ext = *(struct fdr_ext *) ext_copy;
    187 
    188   intern->adr           = ECOFF_GET_OFF (abfd, ext->f_adr);
    189   intern->rss           = H_GET_32 (abfd, ext->f_rss);
    190 #if defined (ECOFF_64) || defined (ECOFF_SIGNED_64)
    191   if (intern->rss == (signed long) 0xffffffff)
    192     intern->rss = -1;
    193 #endif
    194   intern->issBase       = H_GET_32 (abfd, ext->f_issBase);
    195   intern->cbSs          = ECOFF_GET_OFF (abfd, ext->f_cbSs);
    196   intern->isymBase      = H_GET_32 (abfd, ext->f_isymBase);
    197   intern->csym          = H_GET_32 (abfd, ext->f_csym);
    198   intern->ilineBase     = H_GET_32 (abfd, ext->f_ilineBase);
    199   intern->cline         = H_GET_32 (abfd, ext->f_cline);
    200   intern->ioptBase      = H_GET_32 (abfd, ext->f_ioptBase);
    201   intern->copt          = H_GET_32 (abfd, ext->f_copt);
    202 #if defined (ECOFF_32) || defined (ECOFF_SIGNED_32)
    203   intern->ipdFirst      = H_GET_16 (abfd, ext->f_ipdFirst);
    204   intern->cpd           = H_GET_16 (abfd, ext->f_cpd);
    205 #endif
    206 #if defined (ECOFF_64) || defined (ECOFF_SIGNED_64)
    207   intern->ipdFirst      = H_GET_32 (abfd, ext->f_ipdFirst);
    208   intern->cpd           = H_GET_32 (abfd, ext->f_cpd);
    209 #endif
    210   intern->iauxBase      = H_GET_32 (abfd, ext->f_iauxBase);
    211   intern->caux          = H_GET_32 (abfd, ext->f_caux);
    212   intern->rfdBase       = H_GET_32 (abfd, ext->f_rfdBase);
    213   intern->crfd          = H_GET_32 (abfd, ext->f_crfd);
    214 
    215   /* Now the fun stuff...  */
    216   if (bfd_header_big_endian (abfd))
    217     {
    218       intern->lang       = ((ext->f_bits1[0] & FDR_BITS1_LANG_BIG)
    219 			    >> FDR_BITS1_LANG_SH_BIG);
    220       intern->fMerge     = 0 != (ext->f_bits1[0] & FDR_BITS1_FMERGE_BIG);
    221       intern->fReadin    = 0 != (ext->f_bits1[0] & FDR_BITS1_FREADIN_BIG);
    222       intern->fBigendian = 0 != (ext->f_bits1[0] & FDR_BITS1_FBIGENDIAN_BIG);
    223       intern->glevel     = ((ext->f_bits2[0] & FDR_BITS2_GLEVEL_BIG)
    224 			    >> FDR_BITS2_GLEVEL_SH_BIG);
    225     }
    226   else
    227     {
    228       intern->lang       = ((ext->f_bits1[0] & FDR_BITS1_LANG_LITTLE)
    229 			    >> FDR_BITS1_LANG_SH_LITTLE);
    230       intern->fMerge     = 0 != (ext->f_bits1[0] & FDR_BITS1_FMERGE_LITTLE);
    231       intern->fReadin    = 0 != (ext->f_bits1[0] & FDR_BITS1_FREADIN_LITTLE);
    232       intern->fBigendian = 0 != (ext->f_bits1[0] & FDR_BITS1_FBIGENDIAN_LITTLE);
    233       intern->glevel     = ((ext->f_bits2[0] & FDR_BITS2_GLEVEL_LITTLE)
    234 			    >> FDR_BITS2_GLEVEL_SH_LITTLE);
    235     }
    236   intern->reserved = 0;
    237 
    238   intern->cbLineOffset  = ECOFF_GET_OFF (abfd, ext->f_cbLineOffset);
    239   intern->cbLine        = ECOFF_GET_OFF (abfd, ext->f_cbLine);
    240 
    241 #ifdef TEST
    242   if (memcmp ((char *) ext, (char *) intern, sizeof (*intern)) != 0)
    243     abort ();
    244 #endif
    245 }
    246 
    247 /* Swap out the file descriptor record.  */
    248 
    249 static void
    250 ecoff_swap_fdr_out (bfd *abfd, const FDR *intern_copy, void * ext_ptr)
    251 {
    252   struct fdr_ext *ext = (struct fdr_ext *) ext_ptr;
    253   FDR intern[1];
    254 
    255   /* Make it reasonable to do in-place.  */
    256   *intern = *intern_copy;
    257 
    258   ECOFF_PUT_OFF (abfd, intern->adr,       ext->f_adr);
    259   H_PUT_32      (abfd, intern->rss,       ext->f_rss);
    260   H_PUT_32      (abfd, intern->issBase,   ext->f_issBase);
    261   ECOFF_PUT_OFF (abfd, intern->cbSs,      ext->f_cbSs);
    262   H_PUT_32      (abfd, intern->isymBase,  ext->f_isymBase);
    263   H_PUT_32      (abfd, intern->csym,      ext->f_csym);
    264   H_PUT_32      (abfd, intern->ilineBase, ext->f_ilineBase);
    265   H_PUT_32      (abfd, intern->cline,     ext->f_cline);
    266   H_PUT_32      (abfd, intern->ioptBase,  ext->f_ioptBase);
    267   H_PUT_32      (abfd, intern->copt,      ext->f_copt);
    268 #if defined (ECOFF_32) || defined (ECOFF_SIGNED_32)
    269   H_PUT_16      (abfd, intern->ipdFirst,  ext->f_ipdFirst);
    270   H_PUT_16      (abfd, intern->cpd,       ext->f_cpd);
    271 #endif
    272 #if defined (ECOFF_64) || defined (ECOFF_SIGNED_64)
    273   H_PUT_32      (abfd, intern->ipdFirst,  ext->f_ipdFirst);
    274   H_PUT_32      (abfd, intern->cpd,       ext->f_cpd);
    275 #endif
    276   H_PUT_32      (abfd, intern->iauxBase,  ext->f_iauxBase);
    277   H_PUT_32      (abfd, intern->caux,      ext->f_caux);
    278   H_PUT_32      (abfd, intern->rfdBase,   ext->f_rfdBase);
    279   H_PUT_32      (abfd, intern->crfd,      ext->f_crfd);
    280 
    281   /* Now the fun stuff...  */
    282   if (bfd_header_big_endian (abfd))
    283     {
    284       ext->f_bits1[0] = (((intern->lang << FDR_BITS1_LANG_SH_BIG)
    285 			  & FDR_BITS1_LANG_BIG)
    286 			 | (intern->fMerge ? FDR_BITS1_FMERGE_BIG : 0)
    287 			 | (intern->fReadin ? FDR_BITS1_FREADIN_BIG : 0)
    288 			 | (intern->fBigendian ? FDR_BITS1_FBIGENDIAN_BIG : 0));
    289       ext->f_bits2[0] = ((intern->glevel << FDR_BITS2_GLEVEL_SH_BIG)
    290 			 & FDR_BITS2_GLEVEL_BIG);
    291       ext->f_bits2[1] = 0;
    292       ext->f_bits2[2] = 0;
    293     }
    294   else
    295     {
    296       ext->f_bits1[0] = (((intern->lang << FDR_BITS1_LANG_SH_LITTLE)
    297 			  & FDR_BITS1_LANG_LITTLE)
    298 			 | (intern->fMerge ? FDR_BITS1_FMERGE_LITTLE : 0)
    299 			 | (intern->fReadin ? FDR_BITS1_FREADIN_LITTLE : 0)
    300 			 | (intern->fBigendian ? FDR_BITS1_FBIGENDIAN_LITTLE : 0));
    301       ext->f_bits2[0] = ((intern->glevel << FDR_BITS2_GLEVEL_SH_LITTLE)
    302 			 & FDR_BITS2_GLEVEL_LITTLE);
    303       ext->f_bits2[1] = 0;
    304       ext->f_bits2[2] = 0;
    305     }
    306 
    307   ECOFF_PUT_OFF (abfd, intern->cbLineOffset, ext->f_cbLineOffset);
    308   ECOFF_PUT_OFF (abfd, intern->cbLine, ext->f_cbLine);
    309 
    310 #ifdef TEST
    311   if (memcmp ((char *) ext, (char *) intern, sizeof (*intern)) != 0)
    312     abort ();
    313 #endif
    314 }
    315 
    316 /* Swap in the procedure descriptor record.  */
    317 
    318 static void
    319 ecoff_swap_pdr_in (bfd *abfd, void * ext_copy, PDR *intern)
    320 {
    321   struct pdr_ext ext[1];
    322 
    323   *ext = *(struct pdr_ext *) ext_copy;
    324 
    325   memset ((void *) intern, 0, sizeof (*intern));
    326 
    327   intern->adr           = ECOFF_GET_OFF (abfd, ext->p_adr);
    328   intern->isym          = H_GET_32 (abfd, ext->p_isym);
    329   intern->iline         = H_GET_32 (abfd, ext->p_iline);
    330   intern->regmask       = H_GET_32 (abfd, ext->p_regmask);
    331   intern->regoffset     = H_GET_S32 (abfd, ext->p_regoffset);
    332   intern->iopt          = H_GET_S32 (abfd, ext->p_iopt);
    333   intern->fregmask      = H_GET_32 (abfd, ext->p_fregmask);
    334   intern->fregoffset    = H_GET_S32 (abfd, ext->p_fregoffset);
    335   intern->frameoffset   = H_GET_S32 (abfd, ext->p_frameoffset);
    336   intern->framereg      = H_GET_16 (abfd, ext->p_framereg);
    337   intern->pcreg         = H_GET_16 (abfd, ext->p_pcreg);
    338   intern->lnLow         = H_GET_32 (abfd, ext->p_lnLow);
    339   intern->lnHigh        = H_GET_32 (abfd, ext->p_lnHigh);
    340   intern->cbLineOffset  = ECOFF_GET_OFF (abfd, ext->p_cbLineOffset);
    341 
    342 #if defined (ECOFF_64) || defined (ECOFF_SIGNED_64)
    343   if (intern->isym == (signed long) 0xffffffff)
    344     intern->isym = -1;
    345   if (intern->iline == (signed long) 0xffffffff)
    346     intern->iline = -1;
    347 
    348   intern->gp_prologue = H_GET_8 (abfd, ext->p_gp_prologue);
    349   if (bfd_header_big_endian (abfd))
    350     {
    351       intern->gp_used = 0 != (ext->p_bits1[0] & PDR_BITS1_GP_USED_BIG);
    352       intern->reg_frame = 0 != (ext->p_bits1[0] & PDR_BITS1_REG_FRAME_BIG);
    353       intern->prof = 0 != (ext->p_bits1[0] & PDR_BITS1_PROF_BIG);
    354       intern->reserved = (((ext->p_bits1[0] & PDR_BITS1_RESERVED_BIG)
    355 			   << PDR_BITS1_RESERVED_SH_LEFT_BIG)
    356 			  | ((ext->p_bits2[0] & PDR_BITS2_RESERVED_BIG)
    357 			     >> PDR_BITS2_RESERVED_SH_BIG));
    358     }
    359   else
    360     {
    361       intern->gp_used = 0 != (ext->p_bits1[0] & PDR_BITS1_GP_USED_LITTLE);
    362       intern->reg_frame = 0 != (ext->p_bits1[0] & PDR_BITS1_REG_FRAME_LITTLE);
    363       intern->prof = 0 != (ext->p_bits1[0] & PDR_BITS1_PROF_LITTLE);
    364       intern->reserved = (((ext->p_bits1[0] & PDR_BITS1_RESERVED_LITTLE)
    365 			   >> PDR_BITS1_RESERVED_SH_LITTLE)
    366 			  | ((ext->p_bits2[0] & PDR_BITS2_RESERVED_LITTLE)
    367 			     << PDR_BITS2_RESERVED_SH_LEFT_LITTLE));
    368     }
    369   intern->localoff = H_GET_8 (abfd, ext->p_localoff);
    370 #endif
    371 
    372 #ifdef TEST
    373   if (memcmp ((char *) ext, (char *) intern, sizeof (*intern)) != 0)
    374     abort ();
    375 #endif
    376 }
    377 
    378 /* Swap out the procedure descriptor record.  */
    379 
    380 static void
    381 ecoff_swap_pdr_out (bfd *abfd, const PDR *intern_copy, void * ext_ptr)
    382 {
    383   struct pdr_ext *ext = (struct pdr_ext *) ext_ptr;
    384   PDR intern[1];
    385 
    386   /* Make it reasonable to do in-place.  */
    387   *intern = *intern_copy;
    388 
    389   ECOFF_PUT_OFF (abfd, intern->adr,          ext->p_adr);
    390   H_PUT_32      (abfd, intern->isym,         ext->p_isym);
    391   H_PUT_32      (abfd, intern->iline,        ext->p_iline);
    392   H_PUT_32      (abfd, intern->regmask,      ext->p_regmask);
    393   H_PUT_32      (abfd, intern->regoffset,    ext->p_regoffset);
    394   H_PUT_32      (abfd, intern->iopt,         ext->p_iopt);
    395   H_PUT_32      (abfd, intern->fregmask,     ext->p_fregmask);
    396   H_PUT_32      (abfd, intern->fregoffset,   ext->p_fregoffset);
    397   H_PUT_32      (abfd, intern->frameoffset,  ext->p_frameoffset);
    398   H_PUT_16      (abfd, intern->framereg,     ext->p_framereg);
    399   H_PUT_16      (abfd, intern->pcreg,        ext->p_pcreg);
    400   H_PUT_32      (abfd, intern->lnLow,        ext->p_lnLow);
    401   H_PUT_32      (abfd, intern->lnHigh,       ext->p_lnHigh);
    402   ECOFF_PUT_OFF (abfd, intern->cbLineOffset, ext->p_cbLineOffset);
    403 
    404 #if defined (ECOFF_64) || defined (ECOFF_SIGNED_64)
    405   H_PUT_8       (abfd, intern->gp_prologue,  ext->p_gp_prologue);
    406 
    407   if (bfd_header_big_endian (abfd))
    408     {
    409       ext->p_bits1[0] = ((intern->gp_used ? PDR_BITS1_GP_USED_BIG : 0)
    410 			 | (intern->reg_frame ? PDR_BITS1_REG_FRAME_BIG : 0)
    411 			 | (intern->prof ? PDR_BITS1_PROF_BIG : 0)
    412 			 | ((intern->reserved
    413 			     >> PDR_BITS1_RESERVED_SH_LEFT_BIG)
    414 			    & PDR_BITS1_RESERVED_BIG));
    415       ext->p_bits2[0] = ((intern->reserved << PDR_BITS2_RESERVED_SH_BIG)
    416 			 & PDR_BITS2_RESERVED_BIG);
    417     }
    418   else
    419     {
    420       ext->p_bits1[0] = ((intern->gp_used ? PDR_BITS1_GP_USED_LITTLE : 0)
    421 			 | (intern->reg_frame ? PDR_BITS1_REG_FRAME_LITTLE : 0)
    422 			 | (intern->prof ? PDR_BITS1_PROF_LITTLE : 0)
    423 			 | ((intern->reserved << PDR_BITS1_RESERVED_SH_LITTLE)
    424 			    & PDR_BITS1_RESERVED_LITTLE));
    425       ext->p_bits2[0] = ((intern->reserved >>
    426 			  PDR_BITS2_RESERVED_SH_LEFT_LITTLE)
    427 			 & PDR_BITS2_RESERVED_LITTLE);
    428     }
    429   H_PUT_8 (abfd, intern->localoff, ext->p_localoff);
    430 #endif
    431 
    432 #ifdef TEST
    433   if (memcmp ((char *) ext, (char *) intern, sizeof (*intern)) != 0)
    434     abort ();
    435 #endif
    436 }
    437 
    438 /* Swap in a symbol record.  */
    439 
    440 static void
    441 ecoff_swap_sym_in (bfd *abfd, void * ext_copy, SYMR *intern)
    442 {
    443   struct sym_ext ext[1];
    444 
    445   *ext = *(struct sym_ext *) ext_copy;
    446 
    447   intern->iss           = H_GET_32 (abfd, ext->s_iss);
    448   intern->value         = ECOFF_GET_OFF (abfd, ext->s_value);
    449 
    450 #if defined (ECOFF_64) || defined (ECOFF_SIGNED_64)
    451   if (intern->iss == (signed long) 0xffffffff)
    452     intern->iss = -1;
    453 #endif
    454 
    455   /* Now the fun stuff...  */
    456   if (bfd_header_big_endian (abfd))
    457     {
    458       intern->st          =  (ext->s_bits1[0] & SYM_BITS1_ST_BIG)
    459 					     >> SYM_BITS1_ST_SH_BIG;
    460       intern->sc          = ((ext->s_bits1[0] & SYM_BITS1_SC_BIG)
    461 					     << SYM_BITS1_SC_SH_LEFT_BIG)
    462 			  | ((ext->s_bits2[0] & SYM_BITS2_SC_BIG)
    463 					     >> SYM_BITS2_SC_SH_BIG);
    464       intern->reserved    = 0 != (ext->s_bits2[0] & SYM_BITS2_RESERVED_BIG);
    465       intern->index       = ((ext->s_bits2[0] & SYM_BITS2_INDEX_BIG)
    466 					     << SYM_BITS2_INDEX_SH_LEFT_BIG)
    467 			  | (ext->s_bits3[0] << SYM_BITS3_INDEX_SH_LEFT_BIG)
    468 			  | (ext->s_bits4[0] << SYM_BITS4_INDEX_SH_LEFT_BIG);
    469     }
    470   else
    471     {
    472       intern->st          =  (ext->s_bits1[0] & SYM_BITS1_ST_LITTLE)
    473 					     >> SYM_BITS1_ST_SH_LITTLE;
    474       intern->sc          = ((ext->s_bits1[0] & SYM_BITS1_SC_LITTLE)
    475 					     >> SYM_BITS1_SC_SH_LITTLE)
    476 			  | ((ext->s_bits2[0] & SYM_BITS2_SC_LITTLE)
    477 					     << SYM_BITS2_SC_SH_LEFT_LITTLE);
    478       intern->reserved    = 0 != (ext->s_bits2[0] & SYM_BITS2_RESERVED_LITTLE);
    479       intern->index       = ((ext->s_bits2[0] & SYM_BITS2_INDEX_LITTLE)
    480 					     >> SYM_BITS2_INDEX_SH_LITTLE)
    481 			  | (ext->s_bits3[0] << SYM_BITS3_INDEX_SH_LEFT_LITTLE)
    482 			  | ((unsigned int) ext->s_bits4[0]
    483 			     << SYM_BITS4_INDEX_SH_LEFT_LITTLE);
    484     }
    485 
    486 #ifdef TEST
    487   if (memcmp ((char *) ext, (char *) intern, sizeof (*intern)) != 0)
    488     abort ();
    489 #endif
    490 }
    491 
    492 /* Swap out a symbol record.  */
    493 
    494 static void
    495 ecoff_swap_sym_out (bfd *abfd, const SYMR *intern_copy, void * ext_ptr)
    496 {
    497   struct sym_ext *ext = (struct sym_ext *) ext_ptr;
    498   SYMR intern[1];
    499 
    500   /* Make it reasonable to do in-place.  */
    501   *intern = *intern_copy;
    502 
    503   H_PUT_32 (abfd, intern->iss, ext->s_iss);
    504   ECOFF_PUT_OFF (abfd, intern->value, ext->s_value);
    505 
    506   /* Now the fun stuff...  */
    507   if (bfd_header_big_endian (abfd))
    508     {
    509       ext->s_bits1[0] = (((intern->st << SYM_BITS1_ST_SH_BIG)
    510 			  & SYM_BITS1_ST_BIG)
    511 			 | ((intern->sc >> SYM_BITS1_SC_SH_LEFT_BIG)
    512 			    & SYM_BITS1_SC_BIG));
    513       ext->s_bits2[0] = (((intern->sc << SYM_BITS2_SC_SH_BIG)
    514 			  & SYM_BITS2_SC_BIG)
    515 			 | (intern->reserved ? SYM_BITS2_RESERVED_BIG : 0)
    516 			 | ((intern->index >> SYM_BITS2_INDEX_SH_LEFT_BIG)
    517 			    & SYM_BITS2_INDEX_BIG));
    518       ext->s_bits3[0] = (intern->index >> SYM_BITS3_INDEX_SH_LEFT_BIG) & 0xff;
    519       ext->s_bits4[0] = (intern->index >> SYM_BITS4_INDEX_SH_LEFT_BIG) & 0xff;
    520     }
    521   else
    522     {
    523       ext->s_bits1[0] = (((intern->st << SYM_BITS1_ST_SH_LITTLE)
    524 			  & SYM_BITS1_ST_LITTLE)
    525 			 | ((intern->sc << SYM_BITS1_SC_SH_LITTLE)
    526 			    & SYM_BITS1_SC_LITTLE));
    527       ext->s_bits2[0] = (((intern->sc >> SYM_BITS2_SC_SH_LEFT_LITTLE)
    528 			  & SYM_BITS2_SC_LITTLE)
    529 			 | (intern->reserved ? SYM_BITS2_RESERVED_LITTLE : 0)
    530 			 | ((intern->index << SYM_BITS2_INDEX_SH_LITTLE)
    531 			    & SYM_BITS2_INDEX_LITTLE));
    532       ext->s_bits3[0] = (intern->index >> SYM_BITS3_INDEX_SH_LEFT_LITTLE) & 0xff;
    533       ext->s_bits4[0] = (intern->index >> SYM_BITS4_INDEX_SH_LEFT_LITTLE) & 0xff;
    534     }
    535 
    536 #ifdef TEST
    537   if (memcmp ((char *) ext, (char *) intern, sizeof (*intern)) != 0)
    538     abort ();
    539 #endif
    540 }
    541 
    542 /* Swap in an external symbol record.  */
    543 
    544 static void
    545 ecoff_swap_ext_in (bfd *abfd, void * ext_copy, EXTR *intern)
    546 {
    547   struct ext_ext ext[1];
    548 
    549   *ext = *(struct ext_ext *) ext_copy;
    550 
    551   /* Now the fun stuff...  */
    552   if (bfd_header_big_endian (abfd))
    553     {
    554       intern->jmptbl      = 0 != (ext->es_bits1[0] & EXT_BITS1_JMPTBL_BIG);
    555       intern->cobol_main  = 0 != (ext->es_bits1[0] & EXT_BITS1_COBOL_MAIN_BIG);
    556       intern->weakext     = 0 != (ext->es_bits1[0] & EXT_BITS1_WEAKEXT_BIG);
    557     }
    558   else
    559     {
    560       intern->jmptbl      = 0 != (ext->es_bits1[0] & EXT_BITS1_JMPTBL_LITTLE);
    561       intern->cobol_main  = 0 != (ext->es_bits1[0] & EXT_BITS1_COBOL_MAIN_LITTLE);
    562       intern->weakext     = 0 != (ext->es_bits1[0] & EXT_BITS1_WEAKEXT_LITTLE);
    563     }
    564   intern->reserved = 0;
    565 
    566 #if defined (ECOFF_32) || defined (ECOFF_SIGNED_32)
    567   intern->ifd = H_GET_S16 (abfd, ext->es_ifd);
    568 #endif
    569 #if defined (ECOFF_64) || defined (ECOFF_SIGNED_64)
    570   intern->ifd = H_GET_S32 (abfd, ext->es_ifd);
    571 #endif
    572 
    573   ecoff_swap_sym_in (abfd, &ext->es_asym, &intern->asym);
    574 
    575 #ifdef TEST
    576   if (memcmp ((char *) ext, (char *) intern, sizeof (*intern)) != 0)
    577     abort ();
    578 #endif
    579 }
    580 
    581 /* Swap out an external symbol record.  */
    582 
    583 static void
    584 ecoff_swap_ext_out (bfd *abfd, const EXTR *intern_copy, void * ext_ptr)
    585 {
    586   struct ext_ext *ext = (struct ext_ext *) ext_ptr;
    587   EXTR intern[1];
    588 
    589   /* Make it reasonable to do in-place.  */
    590   *intern = *intern_copy;
    591 
    592   /* Now the fun stuff...  */
    593   if (bfd_header_big_endian (abfd))
    594     {
    595       ext->es_bits1[0] = ((intern->jmptbl ? EXT_BITS1_JMPTBL_BIG : 0)
    596 			  | (intern->cobol_main ? EXT_BITS1_COBOL_MAIN_BIG : 0)
    597 			  | (intern->weakext ? EXT_BITS1_WEAKEXT_BIG : 0));
    598       ext->es_bits2[0] = 0;
    599 #if defined (ECOFF_64) || defined (ECOFF_SIGNED_64)
    600       ext->es_bits2[1] = 0;
    601       ext->es_bits2[2] = 0;
    602 #endif
    603     }
    604   else
    605     {
    606       ext->es_bits1[0] = ((intern->jmptbl ? EXT_BITS1_JMPTBL_LITTLE : 0)
    607 			  | (intern->cobol_main ? EXT_BITS1_COBOL_MAIN_LITTLE : 0)
    608 			  | (intern->weakext ? EXT_BITS1_WEAKEXT_LITTLE : 0));
    609       ext->es_bits2[0] = 0;
    610 #if defined (ECOFF_64) || defined (ECOFF_SIGNED_64)
    611       ext->es_bits2[1] = 0;
    612       ext->es_bits2[2] = 0;
    613 #endif
    614     }
    615 
    616 #if defined (ECOFF_32) || defined (ECOFF_SIGNED_32)
    617   H_PUT_S16 (abfd, intern->ifd, ext->es_ifd);
    618 #endif
    619 #if defined (ECOFF_64) || defined (ECOFF_SIGNED_64)
    620   H_PUT_S32 (abfd, intern->ifd, ext->es_ifd);
    621 #endif
    622 
    623   ecoff_swap_sym_out (abfd, &intern->asym, &ext->es_asym);
    624 
    625 #ifdef TEST
    626   if (memcmp ((char *) ext, (char *) intern, sizeof (*intern)) != 0)
    627     abort ();
    628 #endif
    629 }
    630 
    631 /* Swap in a relative file descriptor.  */
    632 
    633 static void
    634 ecoff_swap_rfd_in (bfd *abfd, void * ext_ptr, RFDT *intern)
    635 {
    636   struct rfd_ext *ext = (struct rfd_ext *) ext_ptr;
    637 
    638   *intern = H_GET_32 (abfd, ext->rfd);
    639 
    640 #ifdef TEST
    641   if (memcmp ((char *) ext, (char *) intern, sizeof (*intern)) != 0)
    642     abort ();
    643 #endif
    644 }
    645 
    646 /* Swap out a relative file descriptor.  */
    647 
    648 static void
    649 ecoff_swap_rfd_out (bfd *abfd, const RFDT *intern, void * ext_ptr)
    650 {
    651   struct rfd_ext *ext = (struct rfd_ext *) ext_ptr;
    652 
    653   H_PUT_32 (abfd, *intern, ext->rfd);
    654 
    655 #ifdef TEST
    656   if (memcmp ((char *) ext, (char *) intern, sizeof (*intern)) != 0)
    657     abort ();
    658 #endif
    659 }
    660 
    661 /* Swap in an optimization symbol.  */
    662 
    663 static void
    664 ecoff_swap_opt_in (bfd *abfd, void * ext_copy, OPTR * intern)
    665 {
    666   struct opt_ext ext[1];
    667 
    668   *ext = *(struct opt_ext *) ext_copy;
    669 
    670   if (bfd_header_big_endian (abfd))
    671     {
    672       intern->ot = ext->o_bits1[0];
    673       intern->value = (((unsigned int) ext->o_bits2[0]
    674 			<< OPT_BITS2_VALUE_SH_LEFT_BIG)
    675 		       | ((unsigned int) ext->o_bits3[0]
    676 			  << OPT_BITS2_VALUE_SH_LEFT_BIG)
    677 		       | ((unsigned int) ext->o_bits4[0]
    678 			  << OPT_BITS2_VALUE_SH_LEFT_BIG));
    679     }
    680   else
    681     {
    682       intern->ot = ext->o_bits1[0];
    683       intern->value = ((ext->o_bits2[0] << OPT_BITS2_VALUE_SH_LEFT_LITTLE)
    684 		       | (ext->o_bits3[0] << OPT_BITS2_VALUE_SH_LEFT_LITTLE)
    685 		       | (ext->o_bits4[0] << OPT_BITS2_VALUE_SH_LEFT_LITTLE));
    686     }
    687 
    688   _bfd_ecoff_swap_rndx_in (bfd_header_big_endian (abfd),
    689 			   &ext->o_rndx, &intern->rndx);
    690 
    691   intern->offset = H_GET_32 (abfd, ext->o_offset);
    692 
    693 #ifdef TEST
    694   if (memcmp ((char *) ext, (char *) intern, sizeof (*intern)) != 0)
    695     abort ();
    696 #endif
    697 }
    698 
    699 /* Swap out an optimization symbol.  */
    700 
    701 static void
    702 ecoff_swap_opt_out (bfd *abfd, const OPTR *intern_copy, void * ext_ptr)
    703 {
    704   struct opt_ext *ext = (struct opt_ext *) ext_ptr;
    705   OPTR intern[1];
    706 
    707   /* Make it reasonable to do in-place.  */
    708   *intern = *intern_copy;
    709 
    710   if (bfd_header_big_endian (abfd))
    711     {
    712       ext->o_bits1[0] = intern->ot;
    713       ext->o_bits2[0] = intern->value >> OPT_BITS2_VALUE_SH_LEFT_BIG;
    714       ext->o_bits3[0] = intern->value >> OPT_BITS3_VALUE_SH_LEFT_BIG;
    715       ext->o_bits4[0] = intern->value >> OPT_BITS4_VALUE_SH_LEFT_BIG;
    716     }
    717   else
    718     {
    719       ext->o_bits1[0] = intern->ot;
    720       ext->o_bits2[0] = intern->value >> OPT_BITS2_VALUE_SH_LEFT_LITTLE;
    721       ext->o_bits3[0] = intern->value >> OPT_BITS3_VALUE_SH_LEFT_LITTLE;
    722       ext->o_bits4[0] = intern->value >> OPT_BITS4_VALUE_SH_LEFT_LITTLE;
    723     }
    724 
    725   _bfd_ecoff_swap_rndx_out (bfd_header_big_endian (abfd),
    726 			    &intern->rndx, &ext->o_rndx);
    727 
    728   H_PUT_32 (abfd, intern->value, ext->o_offset);
    729 
    730 #ifdef TEST
    731   if (memcmp ((char *) ext, (char *) intern, sizeof (*intern)) != 0)
    732     abort ();
    733 #endif
    734 }
    735 
    736 /* Swap in a dense number.  */
    737 
    738 static void
    739 ecoff_swap_dnr_in (bfd *abfd, void * ext_copy, DNR *intern)
    740 {
    741   struct dnr_ext ext[1];
    742 
    743   *ext = *(struct dnr_ext *) ext_copy;
    744 
    745   intern->rfd = H_GET_32 (abfd, ext->d_rfd);
    746   intern->index = H_GET_32 (abfd, ext->d_index);
    747 
    748 #ifdef TEST
    749   if (memcmp ((char *) ext, (char *) intern, sizeof (*intern)) != 0)
    750     abort ();
    751 #endif
    752 }
    753 
    754 /* Swap out a dense number.  */
    755 
    756 static void
    757 ecoff_swap_dnr_out (bfd *abfd, const DNR *intern_copy, void * ext_ptr)
    758 {
    759   struct dnr_ext *ext = (struct dnr_ext *) ext_ptr;
    760   DNR intern[1];
    761 
    762   /* Make it reasonable to do in-place.  */
    763   *intern = *intern_copy;
    764 
    765   H_PUT_32 (abfd, intern->rfd, ext->d_rfd);
    766   H_PUT_32 (abfd, intern->index, ext->d_index);
    767 
    768 #ifdef TEST
    769   if (memcmp ((char *) ext, (char *) intern, sizeof (*intern)) != 0)
    770     abort ();
    771 #endif
    772 }
    773