OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [bfd/] [ecoffswap.h] - Blame information for rev 1776

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 578 markom
/* 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
 
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 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
 
67
extern void _bfd_ecoff_swap_tir_in
68
  PARAMS ((int, const struct tir_ext *, TIR *));
69
extern void _bfd_ecoff_swap_tir_out
70
  PARAMS ((int, const TIR *, struct tir_ext *));
71
extern void _bfd_ecoff_swap_rndx_in
72
  PARAMS ((int, const struct rndx_ext *, RNDXR *));
73
extern void _bfd_ecoff_swap_rndx_out
74
  PARAMS ((int, const RNDXR *, struct rndx_ext *));
75
 
76
/* Prototypes for functions defined in this file.  */
77
 
78
static void ecoff_swap_hdr_in PARAMS ((bfd *, PTR, HDRR *));
79
static void ecoff_swap_hdr_out PARAMS ((bfd *, const HDRR *, PTR));
80
static void ecoff_swap_fdr_in PARAMS ((bfd *, PTR, FDR *));
81
static void ecoff_swap_fdr_out PARAMS ((bfd *, const FDR *, PTR));
82
static void ecoff_swap_pdr_in PARAMS ((bfd *, PTR, PDR *));
83
static void ecoff_swap_pdr_out PARAMS ((bfd *, const PDR *, PTR));
84
static void ecoff_swap_sym_in PARAMS ((bfd *, PTR, SYMR *));
85
static void ecoff_swap_sym_out PARAMS ((bfd *, const SYMR *, PTR));
86
static void ecoff_swap_ext_in PARAMS ((bfd *, PTR, EXTR *));
87
static void ecoff_swap_ext_out PARAMS ((bfd *, const EXTR *, PTR));
88
static void ecoff_swap_rfd_in PARAMS ((bfd *, PTR, RFDT *));
89
static void ecoff_swap_rfd_out PARAMS ((bfd *, const RFDT *, PTR));
90
static void ecoff_swap_opt_in PARAMS ((bfd *, PTR, OPTR *));
91
static void ecoff_swap_opt_out PARAMS ((bfd *, const OPTR *, PTR));
92
static void ecoff_swap_dnr_in PARAMS ((bfd *, PTR, DNR *));
93
static void ecoff_swap_dnr_out PARAMS ((bfd *, const DNR *, PTR));
94
 
95
/* Swap in the symbolic header.  */
96
 
97
static void
98
ecoff_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
 
141
static void
142
ecoff_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
 
186
static void
187
ecoff_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
 
254
static void
255
ecoff_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
 
324
static void
325
ecoff_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
 
387
static void
388
ecoff_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
 
451
static void
452
ecoff_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
 
487
static void
488
ecoff_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
 
522
static void
523
ecoff_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
 
571
static void
572
ecoff_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
 
620
static void
621
ecoff_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
 
659
static void
660
ecoff_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
 
708
static void
709
ecoff_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
 
726
static void
727
ecoff_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
 
744
static void
745
ecoff_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
 
785
static void
786
ecoff_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
 
824
static void
825
ecoff_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
 
845
static void
846
ecoff_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
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.