bfd/ecoffswap.h

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