source: vendor/binutils/current/bfd/ecoffswap.h

Last change on this file was 609, checked in by bird, 22 years ago

binutils v2.14 - offical sources.
  • Property cvs2svn:cvs-rev set to 1.1.1.2
  • Property svn:eol-style set to native
  • Property svn:executable set to *
File size: 30.1 KB
Line 
1/* Generic ECOFF swapping routines, for BFD.
2 Copyright 1992, 1993, 1994, 1995, 1996, 2000, 2001, 2002
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
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 = 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
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 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
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, 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
257static void
258ecoff_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#ifndef MPW_C
328
329/* Swap in the procedure descriptor record. */
330
331static void
332ecoff_swap_pdr_in (abfd, ext_copy, intern)
333 bfd *abfd;
334 PTR ext_copy;
335 PDR *intern;
336{
337 struct pdr_ext ext[1];
338
339 *ext = *(struct pdr_ext *) ext_copy;
340
341 memset ((PTR) intern, 0, sizeof (*intern));
342
343 intern->adr = ECOFF_GET_OFF (abfd, ext->p_adr);
344 intern->isym = H_GET_32 (abfd, ext->p_isym);
345 intern->iline = H_GET_32 (abfd, ext->p_iline);
346 intern->regmask = H_GET_32 (abfd, ext->p_regmask);
347 intern->regoffset = H_GET_S32 (abfd, ext->p_regoffset);
348 intern->iopt = H_GET_S32 (abfd, ext->p_iopt);
349 intern->fregmask = H_GET_32 (abfd, ext->p_fregmask);
350 intern->fregoffset = H_GET_S32 (abfd, ext->p_fregoffset);
351 intern->frameoffset = H_GET_S32 (abfd, ext->p_frameoffset);
352 intern->framereg = H_GET_16 (abfd, ext->p_framereg);
353 intern->pcreg = H_GET_16 (abfd, ext->p_pcreg);
354 intern->lnLow = H_GET_32 (abfd, ext->p_lnLow);
355 intern->lnHigh = H_GET_32 (abfd, ext->p_lnHigh);
356 intern->cbLineOffset = ECOFF_GET_OFF (abfd, ext->p_cbLineOffset);
357
358#if defined (ECOFF_64) || defined (ECOFF_SIGNED_64)
359 if (intern->isym == (signed long) 0xffffffff)
360 intern->isym = -1;
361 if (intern->iline == (signed long) 0xffffffff)
362 intern->iline = -1;
363
364 intern->gp_prologue = H_GET_8 (abfd, ext->p_gp_prologue);
365 if (bfd_header_big_endian (abfd))
366 {
367 intern->gp_used = 0 != (ext->p_bits1[0] & PDR_BITS1_GP_USED_BIG);
368 intern->reg_frame = 0 != (ext->p_bits1[0] & PDR_BITS1_REG_FRAME_BIG);
369 intern->prof = 0 != (ext->p_bits1[0] & PDR_BITS1_PROF_BIG);
370 intern->reserved = (((ext->p_bits1[0] & PDR_BITS1_RESERVED_BIG)
371 << PDR_BITS1_RESERVED_SH_LEFT_BIG)
372 | ((ext->p_bits2[0] & PDR_BITS2_RESERVED_BIG)
373 >> PDR_BITS2_RESERVED_SH_BIG));
374 }
375 else
376 {
377 intern->gp_used = 0 != (ext->p_bits1[0] & PDR_BITS1_GP_USED_LITTLE);
378 intern->reg_frame = 0 != (ext->p_bits1[0] & PDR_BITS1_REG_FRAME_LITTLE);
379 intern->prof = 0 != (ext->p_bits1[0] & PDR_BITS1_PROF_LITTLE);
380 intern->reserved = (((ext->p_bits1[0] & PDR_BITS1_RESERVED_LITTLE)
381 >> PDR_BITS1_RESERVED_SH_LITTLE)
382 | ((ext->p_bits2[0] & PDR_BITS2_RESERVED_LITTLE)
383 << PDR_BITS2_RESERVED_SH_LEFT_LITTLE));
384 }
385 intern->localoff = H_GET_8 (abfd, ext->p_localoff);
386#endif
387
388#ifdef TEST
389 if (memcmp ((char *)ext, (char *)intern, sizeof (*intern)) != 0)
390 abort ();
391#endif
392}
393
394/* Swap out the procedure descriptor record. */
395
396static void
397ecoff_swap_pdr_out (abfd, intern_copy, ext_ptr)
398 bfd *abfd;
399 const PDR *intern_copy;
400 PTR ext_ptr;
401{
402 struct pdr_ext *ext = (struct pdr_ext *) ext_ptr;
403 PDR intern[1];
404
405 /* Make it reasonable to do in-place. */
406 *intern = *intern_copy;
407
408 ECOFF_PUT_OFF (abfd, intern->adr, ext->p_adr);
409 H_PUT_32 (abfd, intern->isym, ext->p_isym);
410 H_PUT_32 (abfd, intern->iline, ext->p_iline);
411 H_PUT_32 (abfd, intern->regmask, ext->p_regmask);
412 H_PUT_32 (abfd, intern->regoffset, ext->p_regoffset);
413 H_PUT_32 (abfd, intern->iopt, ext->p_iopt);
414 H_PUT_32 (abfd, intern->fregmask, ext->p_fregmask);
415 H_PUT_32 (abfd, intern->fregoffset, ext->p_fregoffset);
416 H_PUT_32 (abfd, intern->frameoffset, ext->p_frameoffset);
417 H_PUT_16 (abfd, intern->framereg, ext->p_framereg);
418 H_PUT_16 (abfd, intern->pcreg, ext->p_pcreg);
419 H_PUT_32 (abfd, intern->lnLow, ext->p_lnLow);
420 H_PUT_32 (abfd, intern->lnHigh, ext->p_lnHigh);
421 ECOFF_PUT_OFF (abfd, intern->cbLineOffset, ext->p_cbLineOffset);
422
423#if defined (ECOFF_64) || defined (ECOFF_SIGNED_64)
424 H_PUT_8 (abfd, intern->gp_prologue, ext->p_gp_prologue);
425
426 if (bfd_header_big_endian (abfd))
427 {
428 ext->p_bits1[0] = ((intern->gp_used ? PDR_BITS1_GP_USED_BIG : 0)
429 | (intern->reg_frame ? PDR_BITS1_REG_FRAME_BIG : 0)
430 | (intern->prof ? PDR_BITS1_PROF_BIG : 0)
431 | ((intern->reserved
432 >> PDR_BITS1_RESERVED_SH_LEFT_BIG)
433 & PDR_BITS1_RESERVED_BIG));
434 ext->p_bits2[0] = ((intern->reserved << PDR_BITS2_RESERVED_SH_BIG)
435 & PDR_BITS2_RESERVED_BIG);
436 }
437 else
438 {
439 ext->p_bits1[0] = ((intern->gp_used ? PDR_BITS1_GP_USED_LITTLE : 0)
440 | (intern->reg_frame ? PDR_BITS1_REG_FRAME_LITTLE : 0)
441 | (intern->prof ? PDR_BITS1_PROF_LITTLE : 0)
442 | ((intern->reserved << PDR_BITS1_RESERVED_SH_LITTLE)
443 & PDR_BITS1_RESERVED_LITTLE));
444 ext->p_bits2[0] = ((intern->reserved >>
445 PDR_BITS2_RESERVED_SH_LEFT_LITTLE)
446 & PDR_BITS2_RESERVED_LITTLE);
447 }
448 H_PUT_8 (abfd, intern->localoff, ext->p_localoff);
449#endif
450
451#ifdef TEST
452 if (memcmp ((char *)ext, (char *)intern, sizeof (*intern)) != 0)
453 abort ();
454#endif
455}
456
457#else /* MPW_C */
458/* Same routines, but with ECOFF_64 code removed, so ^&%$#&! MPW C doesn't
459 corrupt itself and then freak out. */
460/* Swap in the procedure descriptor record. */
461
462static void
463ecoff_swap_pdr_in (abfd, ext_copy, intern)
464 bfd *abfd;
465 PTR ext_copy;
466 PDR *intern;
467{
468 struct pdr_ext ext[1];
469
470 *ext = *(struct pdr_ext *) ext_copy;
471
472 intern->adr = ECOFF_GET_OFF (abfd, ext->p_adr);
473 intern->isym = H_GET_32 (abfd, ext->p_isym);
474 intern->iline = H_GET_32 (abfd, ext->p_iline);
475 intern->regmask = H_GET_32 (abfd, ext->p_regmask);
476 intern->regoffset = H_GET_S32 (abfd, ext->p_regoffset);
477 intern->iopt = H_GET_S32 (abfd, ext->p_iopt);
478 intern->fregmask = H_GET_32 (abfd, ext->p_fregmask);
479 intern->fregoffset = H_GET_S32 (abfd, ext->p_fregoffset);
480 intern->frameoffset = H_GET_S32 (abfd, ext->p_frameoffset);
481 intern->framereg = H_GET_16 (abfd, ext->p_framereg);
482 intern->pcreg = H_GET_16 (abfd, ext->p_pcreg);
483 intern->lnLow = H_GET_32 (abfd, ext->p_lnLow);
484 intern->lnHigh = H_GET_32 (abfd, ext->p_lnHigh);
485 intern->cbLineOffset = ECOFF_GET_OFF (abfd, ext->p_cbLineOffset);
486
487#ifdef TEST
488 if (memcmp ((char *)ext, (char *)intern, sizeof (*intern)) != 0)
489 abort ();
490#endif
491}
492
493/* Swap out the procedure descriptor record. */
494
495static void
496ecoff_swap_pdr_out (abfd, intern_copy, ext_ptr)
497 bfd *abfd;
498 const PDR *intern_copy;
499 PTR ext_ptr;
500{
501 struct pdr_ext *ext = (struct pdr_ext *) ext_ptr;
502 PDR intern[1];
503
504 /* Make it reasonable to do in-place. */
505 *intern = *intern_copy;
506
507 ECOFF_PUT_OFF (abfd, intern->adr, ext->p_adr);
508 H_PUT_32 (abfd, intern->isym, ext->p_isym);
509 H_PUT_32 (abfd, intern->iline, ext->p_iline);
510 H_PUT_32 (abfd, intern->regmask, ext->p_regmask);
511 H_PUT_32 (abfd, intern->regoffset, ext->p_regoffset);
512 H_PUT_32 (abfd, intern->iopt, ext->p_iopt);
513 H_PUT_32 (abfd, intern->fregmask, ext->p_fregmask);
514 H_PUT_32 (abfd, intern->fregoffset, ext->p_fregoffset);
515 H_PUT_32 (abfd, intern->frameoffset, ext->p_frameoffset);
516 H_PUT_16 (abfd, intern->framereg, ext->p_framereg);
517 H_PUT_16 (abfd, intern->pcreg, ext->p_pcreg);
518 H_PUT_32 (abfd, intern->lnLow, ext->p_lnLow);
519 H_PUT_32 (abfd, intern->lnHigh, ext->p_lnHigh);
520 ECOFF_PUT_OFF (abfd, intern->cbLineOffset, ext->p_cbLineOffset);
521
522#ifdef TEST
523 if (memcmp ((char *)ext, (char *)intern, sizeof (*intern)) != 0)
524 abort ();
525#endif
526}
527#endif /* MPW_C */
528
529/* Swap in a symbol record. */
530
531static void
532ecoff_swap_sym_in (abfd, ext_copy, intern)
533 bfd *abfd;
534 PTR ext_copy;
535 SYMR *intern;
536{
537 struct sym_ext ext[1];
538
539 *ext = *(struct sym_ext *) ext_copy;
540
541 intern->iss = H_GET_32 (abfd, ext->s_iss);
542 intern->value = ECOFF_GET_OFF (abfd, ext->s_value);
543
544#if defined (ECOFF_64) || defined (ECOFF_SIGNED_64)
545 if (intern->iss == (signed long) 0xffffffff)
546 intern->iss = -1;
547#endif
548
549 /* Now the fun stuff... */
550 if (bfd_header_big_endian (abfd))
551 {
552 intern->st = (ext->s_bits1[0] & SYM_BITS1_ST_BIG)
553 >> SYM_BITS1_ST_SH_BIG;
554 intern->sc = ((ext->s_bits1[0] & SYM_BITS1_SC_BIG)
555 << SYM_BITS1_SC_SH_LEFT_BIG)
556 | ((ext->s_bits2[0] & SYM_BITS2_SC_BIG)
557 >> SYM_BITS2_SC_SH_BIG);
558 intern->reserved = 0 != (ext->s_bits2[0] & SYM_BITS2_RESERVED_BIG);
559 intern->index = ((ext->s_bits2[0] & SYM_BITS2_INDEX_BIG)
560 << SYM_BITS2_INDEX_SH_LEFT_BIG)
561 | (ext->s_bits3[0] << SYM_BITS3_INDEX_SH_LEFT_BIG)
562 | (ext->s_bits4[0] << SYM_BITS4_INDEX_SH_LEFT_BIG);
563 }
564 else
565 {
566 intern->st = (ext->s_bits1[0] & SYM_BITS1_ST_LITTLE)
567 >> SYM_BITS1_ST_SH_LITTLE;
568 intern->sc = ((ext->s_bits1[0] & SYM_BITS1_SC_LITTLE)
569 >> SYM_BITS1_SC_SH_LITTLE)
570 | ((ext->s_bits2[0] & SYM_BITS2_SC_LITTLE)
571 << SYM_BITS2_SC_SH_LEFT_LITTLE);
572 intern->reserved = 0 != (ext->s_bits2[0] & SYM_BITS2_RESERVED_LITTLE);
573 intern->index = ((ext->s_bits2[0] & SYM_BITS2_INDEX_LITTLE)
574 >> SYM_BITS2_INDEX_SH_LITTLE)
575 | (ext->s_bits3[0] << SYM_BITS3_INDEX_SH_LEFT_LITTLE)
576 | ((unsigned int) ext->s_bits4[0]
577 << SYM_BITS4_INDEX_SH_LEFT_LITTLE);
578 }
579
580#ifdef TEST
581 if (memcmp ((char *)ext, (char *)intern, sizeof (*intern)) != 0)
582 abort ();
583#endif
584}
585
586/* Swap out a symbol record. */
587
588static void
589ecoff_swap_sym_out (abfd, intern_copy, ext_ptr)
590 bfd *abfd;
591 const SYMR *intern_copy;
592 PTR ext_ptr;
593{
594 struct sym_ext *ext = (struct sym_ext *) ext_ptr;
595 SYMR intern[1];
596
597 /* Make it reasonable to do in-place. */
598 *intern = *intern_copy;
599
600 H_PUT_32 (abfd, intern->iss, ext->s_iss);
601 ECOFF_PUT_OFF (abfd, intern->value, ext->s_value);
602
603 /* Now the fun stuff... */
604 if (bfd_header_big_endian (abfd))
605 {
606 ext->s_bits1[0] = (((intern->st << SYM_BITS1_ST_SH_BIG)
607 & SYM_BITS1_ST_BIG)
608 | ((intern->sc >> SYM_BITS1_SC_SH_LEFT_BIG)
609 & SYM_BITS1_SC_BIG));
610 ext->s_bits2[0] = (((intern->sc << SYM_BITS2_SC_SH_BIG)
611 & SYM_BITS2_SC_BIG)
612 | (intern->reserved ? SYM_BITS2_RESERVED_BIG : 0)
613 | ((intern->index >> SYM_BITS2_INDEX_SH_LEFT_BIG)
614 & SYM_BITS2_INDEX_BIG));
615 ext->s_bits3[0] = (intern->index >> SYM_BITS3_INDEX_SH_LEFT_BIG) & 0xff;
616 ext->s_bits4[0] = (intern->index >> SYM_BITS4_INDEX_SH_LEFT_BIG) & 0xff;
617 }
618 else
619 {
620 ext->s_bits1[0] = (((intern->st << SYM_BITS1_ST_SH_LITTLE)
621 & SYM_BITS1_ST_LITTLE)
622 | ((intern->sc << SYM_BITS1_SC_SH_LITTLE)
623 & SYM_BITS1_SC_LITTLE));
624 ext->s_bits2[0] = (((intern->sc >> SYM_BITS2_SC_SH_LEFT_LITTLE)
625 & SYM_BITS2_SC_LITTLE)
626 | (intern->reserved ? SYM_BITS2_RESERVED_LITTLE : 0)
627 | ((intern->index << SYM_BITS2_INDEX_SH_LITTLE)
628 & SYM_BITS2_INDEX_LITTLE));
629 ext->s_bits3[0] = (intern->index >> SYM_BITS3_INDEX_SH_LEFT_LITTLE) & 0xff;
630 ext->s_bits4[0] = (intern->index >> SYM_BITS4_INDEX_SH_LEFT_LITTLE) & 0xff;
631 }
632
633#ifdef TEST
634 if (memcmp ((char *)ext, (char *)intern, sizeof (*intern)) != 0)
635 abort ();
636#endif
637}
638
639/* Swap in an external symbol record. */
640
641static void
642ecoff_swap_ext_in (abfd, ext_copy, intern)
643 bfd *abfd;
644 PTR ext_copy;
645 EXTR *intern;
646{
647 struct ext_ext ext[1];
648
649 *ext = *(struct ext_ext *) ext_copy;
650
651 /* Now the fun stuff... */
652 if (bfd_header_big_endian (abfd))
653 {
654 intern->jmptbl = 0 != (ext->es_bits1[0] & EXT_BITS1_JMPTBL_BIG);
655 intern->cobol_main = 0 != (ext->es_bits1[0] & EXT_BITS1_COBOL_MAIN_BIG);
656 intern->weakext = 0 != (ext->es_bits1[0] & EXT_BITS1_WEAKEXT_BIG);
657 }
658 else
659 {
660 intern->jmptbl = 0 != (ext->es_bits1[0] & EXT_BITS1_JMPTBL_LITTLE);
661 intern->cobol_main = 0 != (ext->es_bits1[0] & EXT_BITS1_COBOL_MAIN_LITTLE);
662 intern->weakext = 0 != (ext->es_bits1[0] & EXT_BITS1_WEAKEXT_LITTLE);
663 }
664 intern->reserved = 0;
665
666#if defined (ECOFF_32) || defined (ECOFF_SIGNED_32)
667 intern->ifd = H_GET_S16 (abfd, ext->es_ifd);
668#endif
669#if defined (ECOFF_64) || defined (ECOFF_SIGNED_64)
670 intern->ifd = H_GET_S32 (abfd, ext->es_ifd);
671#endif
672
673 ecoff_swap_sym_in (abfd, &ext->es_asym, &intern->asym);
674
675#ifdef TEST
676 if (memcmp ((char *)ext, (char *)intern, sizeof (*intern)) != 0)
677 abort ();
678#endif
679}
680
681/* Swap out an external symbol record. */
682
683static void
684ecoff_swap_ext_out (abfd, intern_copy, ext_ptr)
685 bfd *abfd;
686 const EXTR *intern_copy;
687 PTR ext_ptr;
688{
689 struct ext_ext *ext = (struct ext_ext *) ext_ptr;
690 EXTR intern[1];
691
692 /* Make it reasonable to do in-place. */
693 *intern = *intern_copy;
694
695 /* Now the fun stuff... */
696 if (bfd_header_big_endian (abfd))
697 {
698 ext->es_bits1[0] = ((intern->jmptbl ? EXT_BITS1_JMPTBL_BIG : 0)
699 | (intern->cobol_main ? EXT_BITS1_COBOL_MAIN_BIG : 0)
700 | (intern->weakext ? EXT_BITS1_WEAKEXT_BIG : 0));
701 ext->es_bits2[0] = 0;
702#if defined (ECOFF_64) || defined (ECOFF_SIGNED_64)
703 ext->es_bits2[1] = 0;
704 ext->es_bits2[2] = 0;
705#endif
706 }
707 else
708 {
709 ext->es_bits1[0] = ((intern->jmptbl ? EXT_BITS1_JMPTBL_LITTLE : 0)
710 | (intern->cobol_main ? EXT_BITS1_COBOL_MAIN_LITTLE : 0)
711 | (intern->weakext ? EXT_BITS1_WEAKEXT_LITTLE : 0));
712 ext->es_bits2[0] = 0;
713#if defined (ECOFF_64) || defined (ECOFF_SIGNED_64)
714 ext->es_bits2[1] = 0;
715 ext->es_bits2[2] = 0;
716#endif
717 }
718
719#if defined (ECOFF_32) || defined (ECOFF_SIGNED_32)
720 H_PUT_S16 (abfd, intern->ifd, ext->es_ifd);
721#endif
722#if defined (ECOFF_64) || defined (ECOFF_SIGNED_64)
723 H_PUT_S32 (abfd, intern->ifd, ext->es_ifd);
724#endif
725
726 ecoff_swap_sym_out (abfd, &intern->asym, &ext->es_asym);
727
728#ifdef TEST
729 if (memcmp ((char *)ext, (char *)intern, sizeof (*intern)) != 0)
730 abort ();
731#endif
732}
733
734/* Swap in a relative file descriptor. */
735
736static void
737ecoff_swap_rfd_in (abfd, ext_ptr, intern)
738 bfd *abfd;
739 PTR ext_ptr;
740 RFDT *intern;
741{
742 struct rfd_ext *ext = (struct rfd_ext *) ext_ptr;
743
744 *intern = H_GET_32 (abfd, ext->rfd);
745
746#ifdef TEST
747 if (memcmp ((char *)ext, (char *)intern, sizeof (*intern)) != 0)
748 abort ();
749#endif
750}
751
752/* Swap out a relative file descriptor. */
753
754static void
755ecoff_swap_rfd_out (abfd, intern, ext_ptr)
756 bfd *abfd;
757 const RFDT *intern;
758 PTR ext_ptr;
759{
760 struct rfd_ext *ext = (struct rfd_ext *) ext_ptr;
761
762 H_PUT_32 (abfd, *intern, ext->rfd);
763
764#ifdef TEST
765 if (memcmp ((char *)ext, (char *)intern, sizeof (*intern)) != 0)
766 abort ();
767#endif
768}
769
770/* Swap in an optimization symbol. */
771
772static void
773ecoff_swap_opt_in (abfd, ext_copy, intern)
774 bfd *abfd;
775 PTR ext_copy;
776 OPTR *intern;
777{
778 struct opt_ext ext[1];
779
780 *ext = *(struct opt_ext *) ext_copy;
781
782 if (bfd_header_big_endian (abfd))
783 {
784 intern->ot = ext->o_bits1[0];
785 intern->value = (((unsigned int) ext->o_bits2[0]
786 << OPT_BITS2_VALUE_SH_LEFT_BIG)
787 | ((unsigned int) ext->o_bits3[0]
788 << OPT_BITS2_VALUE_SH_LEFT_BIG)
789 | ((unsigned int) ext->o_bits4[0]
790 << OPT_BITS2_VALUE_SH_LEFT_BIG));
791 }
792 else
793 {
794 intern->ot = ext->o_bits1[0];
795 intern->value = ((ext->o_bits2[0] << OPT_BITS2_VALUE_SH_LEFT_LITTLE)
796 | (ext->o_bits3[0] << OPT_BITS2_VALUE_SH_LEFT_LITTLE)
797 | (ext->o_bits4[0] << OPT_BITS2_VALUE_SH_LEFT_LITTLE));
798 }
799
800 _bfd_ecoff_swap_rndx_in (bfd_header_big_endian (abfd),
801 &ext->o_rndx, &intern->rndx);
802
803 intern->offset = H_GET_32 (abfd, ext->o_offset);
804
805#ifdef TEST
806 if (memcmp ((char *)ext, (char *)intern, sizeof (*intern)) != 0)
807 abort ();
808#endif
809}
810
811/* Swap out an optimization symbol. */
812
813static void
814ecoff_swap_opt_out (abfd, intern_copy, ext_ptr)
815 bfd *abfd;
816 const OPTR *intern_copy;
817 PTR ext_ptr;
818{
819 struct opt_ext *ext = (struct opt_ext *) ext_ptr;
820 OPTR intern[1];
821
822 /* Make it reasonable to do in-place. */
823 *intern = *intern_copy;
824
825 if (bfd_header_big_endian (abfd))
826 {
827 ext->o_bits1[0] = intern->ot;
828 ext->o_bits2[0] = intern->value >> OPT_BITS2_VALUE_SH_LEFT_BIG;
829 ext->o_bits3[0] = intern->value >> OPT_BITS3_VALUE_SH_LEFT_BIG;
830 ext->o_bits4[0] = intern->value >> OPT_BITS4_VALUE_SH_LEFT_BIG;
831 }
832 else
833 {
834 ext->o_bits1[0] = intern->ot;
835 ext->o_bits2[0] = intern->value >> OPT_BITS2_VALUE_SH_LEFT_LITTLE;
836 ext->o_bits3[0] = intern->value >> OPT_BITS3_VALUE_SH_LEFT_LITTLE;
837 ext->o_bits4[0] = intern->value >> OPT_BITS4_VALUE_SH_LEFT_LITTLE;
838 }
839
840 _bfd_ecoff_swap_rndx_out (bfd_header_big_endian (abfd),
841 &intern->rndx, &ext->o_rndx);
842
843 H_PUT_32 (abfd, intern->value, ext->o_offset);
844
845#ifdef TEST
846 if (memcmp ((char *)ext, (char *)intern, sizeof (*intern)) != 0)
847 abort ();
848#endif
849}
850
851/* Swap in a dense number. */
852
853static void
854ecoff_swap_dnr_in (abfd, ext_copy, intern)
855 bfd *abfd;
856 PTR ext_copy;
857 DNR *intern;
858{
859 struct dnr_ext ext[1];
860
861 *ext = *(struct dnr_ext *) ext_copy;
862
863 intern->rfd = H_GET_32 (abfd, ext->d_rfd);
864 intern->index = H_GET_32 (abfd, ext->d_index);
865
866#ifdef TEST
867 if (memcmp ((char *)ext, (char *)intern, sizeof (*intern)) != 0)
868 abort ();
869#endif
870}
871
872/* Swap out a dense number. */
873
874static void
875ecoff_swap_dnr_out (abfd, intern_copy, ext_ptr)
876 bfd *abfd;
877 const DNR *intern_copy;
878 PTR ext_ptr;
879{
880 struct dnr_ext *ext = (struct dnr_ext *) ext_ptr;
881 DNR intern[1];
882
883 /* Make it reasonable to do in-place. */
884 *intern = *intern_copy;
885
886 H_PUT_32 (abfd, intern->rfd, ext->d_rfd);
887 H_PUT_32 (abfd, intern->index, ext->d_index);
888
889#ifdef TEST
890 if (memcmp ((char *)ext, (char *)intern, sizeof (*intern)) != 0)
891 abort ();
892#endif
893}
Note: See TracBrowser for help on using the repository browser.