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