]>
Commit | Line | Data |
---|---|---|
1 | /* Generic ECOFF swapping routines, for BFD. | |
2 | Copyright (C) 1992-2020 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 | } |