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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.3/] [bfd/] [ecoffswap.h] - Blame information for rev 1765

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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