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