source: trunk/src/binutils/bfd/ecoffswap.h@ 294

Last change on this file since 294 was 10, checked in by bird, 23 years ago

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