update copyright dates
[external/binutils.git] / bfd / ecoffswap.h
1 /* Generic ECOFF swapping routines, for BFD.
2    Copyright 1992, 1993, 1994, 1995, 1996, 2000, 2001, 2002, 2004
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 }