bfd/ecoffswap.h

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