bfd/ecoffswap.h

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