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