bfd/ecoffswap.h

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