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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.18.50/] [bfd/] [coffswap.h] - Blame information for rev 38

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

Line No. Rev Author Line
1 38 julius 
/* Generic COFF swapping routines, for BFD.
2 
   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1999, 2000,
3 
   2001, 2002, 2005, 2007
4 
   Free Software Foundation, Inc.
5 
   Written by Cygnus Support.
6 
 
7 
   This file is part of BFD, the Binary File Descriptor library.
8 
 
9 
   This program is free software; you can redistribute it and/or modify
10 
   it under the terms of the GNU General Public License as published by
11 
   the Free Software Foundation; either version 3 of the License, or
12 
   (at your option) any later version.
13 
 
14 
   This program is distributed in the hope that it will be useful,
15 
   but WITHOUT ANY WARRANTY; without even the implied warranty of
16 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 
   GNU General Public License for more details.
18 
 
19 
   You should have received a copy of the GNU General Public License
20 
   along with this program; if not, write to the Free Software
21 
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 
   MA 02110-1301, USA.  */
23 
 
24 
/* This file contains routines used to swap COFF data.  It is a header
25 
   file because the details of swapping depend on the details of the
26 
   structures used by each COFF implementation.  This is included by
27 
   coffcode.h, as well as by the ECOFF backend.
28 
 
29 
   Any file which uses this must first include "coff/internal.h" and
30 
   "coff/CPU.h".  The functions will then be correct for that CPU.  */
31 
 
32 
#ifndef GET_FCN_LNNOPTR
33 
#define GET_FCN_LNNOPTR(abfd, ext) \
34 
  H_GET_32 (abfd, ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
35 
#endif
36 
 
37 
#ifndef GET_FCN_ENDNDX
38 
#define GET_FCN_ENDNDX(abfd, ext) \
39 
  H_GET_32 (abfd, ext->x_sym.x_fcnary.x_fcn.x_endndx)
40 
#endif
41 
 
42 
#ifndef PUT_FCN_LNNOPTR
43 
#define PUT_FCN_LNNOPTR(abfd, in, ext) \
44 
  H_PUT_32 (abfd,  in, ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
45 
#endif
46 
#ifndef PUT_FCN_ENDNDX
47 
#define PUT_FCN_ENDNDX(abfd, in, ext) \
48 
  H_PUT_32 (abfd, in, ext->x_sym.x_fcnary.x_fcn.x_endndx)
49 
#endif
50 
#ifndef GET_LNSZ_LNNO
51 
#define GET_LNSZ_LNNO(abfd, ext) \
52 
  H_GET_16 (abfd, ext->x_sym.x_misc.x_lnsz.x_lnno)
53 
#endif
54 
#ifndef GET_LNSZ_SIZE
55 
#define GET_LNSZ_SIZE(abfd, ext) \
56 
  H_GET_16 (abfd, ext->x_sym.x_misc.x_lnsz.x_size)
57 
#endif
58 
#ifndef PUT_LNSZ_LNNO
59 
#define PUT_LNSZ_LNNO(abfd, in, ext) \
60 
  H_PUT_16 (abfd, in, ext->x_sym.x_misc.x_lnsz.x_lnno)
61 
#endif
62 
#ifndef PUT_LNSZ_SIZE
63 
#define PUT_LNSZ_SIZE(abfd, in, ext) \
64 
  H_PUT_16 (abfd, in, ext->x_sym.x_misc.x_lnsz.x_size)
65 
#endif
66 
#ifndef GET_SCN_SCNLEN
67 
#define GET_SCN_SCNLEN(abfd, ext) \
68 
  H_GET_32 (abfd, ext->x_scn.x_scnlen)
69 
#endif
70 
#ifndef GET_SCN_NRELOC
71 
#define GET_SCN_NRELOC(abfd, ext) \
72 
  H_GET_16 (abfd, ext->x_scn.x_nreloc)
73 
#endif
74 
#ifndef GET_SCN_NLINNO
75 
#define GET_SCN_NLINNO(abfd, ext) \
76 
  H_GET_16 (abfd, ext->x_scn.x_nlinno)
77 
#endif
78 
#ifndef PUT_SCN_SCNLEN
79 
#define PUT_SCN_SCNLEN(abfd, in, ext) \
80 
  H_PUT_32 (abfd, in, ext->x_scn.x_scnlen)
81 
#endif
82 
#ifndef PUT_SCN_NRELOC
83 
#define PUT_SCN_NRELOC(abfd, in, ext) \
84 
  H_PUT_16 (abfd, in, ext->x_scn.x_nreloc)
85 
#endif
86 
#ifndef PUT_SCN_NLINNO
87 
#define PUT_SCN_NLINNO(abfd, in, ext) \
88 
  H_PUT_16 (abfd, in, ext->x_scn.x_nlinno)
89 
#endif
90 
#ifndef GET_LINENO_LNNO
91 
#define GET_LINENO_LNNO(abfd, ext) \
92 
  H_GET_16 (abfd, ext->l_lnno);
93 
#endif
94 
#ifndef PUT_LINENO_LNNO
95 
#define PUT_LINENO_LNNO(abfd, val, ext) \
96 
  H_PUT_16 (abfd, val, ext->l_lnno);
97 
#endif
98 
 
99 
/* The f_symptr field in the filehdr is sometimes 64 bits.  */
100 
#ifndef GET_FILEHDR_SYMPTR
101 
#define GET_FILEHDR_SYMPTR H_GET_32
102 
#endif
103 
#ifndef PUT_FILEHDR_SYMPTR
104 
#define PUT_FILEHDR_SYMPTR H_PUT_32
105 
#endif
106 
 
107 
/* Some fields in the aouthdr are sometimes 64 bits.  */
108 
#ifndef GET_AOUTHDR_TSIZE
109 
#define GET_AOUTHDR_TSIZE H_GET_32
110 
#endif
111 
#ifndef PUT_AOUTHDR_TSIZE
112 
#define PUT_AOUTHDR_TSIZE H_PUT_32
113 
#endif
114 
#ifndef GET_AOUTHDR_DSIZE
115 
#define GET_AOUTHDR_DSIZE H_GET_32
116 
#endif
117 
#ifndef PUT_AOUTHDR_DSIZE
118 
#define PUT_AOUTHDR_DSIZE H_PUT_32
119 
#endif
120 
#ifndef GET_AOUTHDR_BSIZE
121 
#define GET_AOUTHDR_BSIZE H_GET_32
122 
#endif
123 
#ifndef PUT_AOUTHDR_BSIZE
124 
#define PUT_AOUTHDR_BSIZE H_PUT_32
125 
#endif
126 
#ifndef GET_AOUTHDR_ENTRY
127 
#define GET_AOUTHDR_ENTRY H_GET_32
128 
#endif
129 
#ifndef PUT_AOUTHDR_ENTRY
130 
#define PUT_AOUTHDR_ENTRY H_PUT_32
131 
#endif
132 
#ifndef GET_AOUTHDR_TEXT_START
133 
#define GET_AOUTHDR_TEXT_START H_GET_32
134 
#endif
135 
#ifndef PUT_AOUTHDR_TEXT_START
136 
#define PUT_AOUTHDR_TEXT_START H_PUT_32
137 
#endif
138 
#ifndef GET_AOUTHDR_DATA_START
139 
#define GET_AOUTHDR_DATA_START H_GET_32
140 
#endif
141 
#ifndef PUT_AOUTHDR_DATA_START
142 
#define PUT_AOUTHDR_DATA_START H_PUT_32
143 
#endif
144 
 
145 
/* Some fields in the scnhdr are sometimes 64 bits.  */
146 
#ifndef GET_SCNHDR_PADDR
147 
#define GET_SCNHDR_PADDR H_GET_32
148 
#endif
149 
#ifndef PUT_SCNHDR_PADDR
150 
#define PUT_SCNHDR_PADDR H_PUT_32
151 
#endif
152 
#ifndef GET_SCNHDR_VADDR
153 
#define GET_SCNHDR_VADDR H_GET_32
154 
#endif
155 
#ifndef PUT_SCNHDR_VADDR
156 
#define PUT_SCNHDR_VADDR H_PUT_32
157 
#endif
158 
#ifndef GET_SCNHDR_SIZE
159 
#define GET_SCNHDR_SIZE H_GET_32
160 
#endif
161 
#ifndef PUT_SCNHDR_SIZE
162 
#define PUT_SCNHDR_SIZE H_PUT_32
163 
#endif
164 
#ifndef GET_SCNHDR_SCNPTR
165 
#define GET_SCNHDR_SCNPTR H_GET_32
166 
#endif
167 
#ifndef PUT_SCNHDR_SCNPTR
168 
#define PUT_SCNHDR_SCNPTR H_PUT_32
169 
#endif
170 
#ifndef GET_SCNHDR_RELPTR
171 
#define GET_SCNHDR_RELPTR H_GET_32
172 
#endif
173 
#ifndef PUT_SCNHDR_RELPTR
174 
#define PUT_SCNHDR_RELPTR H_PUT_32
175 
#endif
176 
#ifndef GET_SCNHDR_LNNOPTR
177 
#define GET_SCNHDR_LNNOPTR H_GET_32
178 
#endif
179 
#ifndef PUT_SCNHDR_LNNOPTR
180 
#define PUT_SCNHDR_LNNOPTR H_PUT_32
181 
#endif
182 
#ifndef GET_SCNHDR_NRELOC
183 
#define GET_SCNHDR_NRELOC H_GET_16
184 
#endif
185 
#ifndef MAX_SCNHDR_NRELOC
186 
#define MAX_SCNHDR_NRELOC 0xffff
187 
#endif
188 
#ifndef PUT_SCNHDR_NRELOC
189 
#define PUT_SCNHDR_NRELOC H_PUT_16
190 
#endif
191 
#ifndef GET_SCNHDR_NLNNO
192 
#define GET_SCNHDR_NLNNO H_GET_16
193 
#endif
194 
#ifndef MAX_SCNHDR_NLNNO
195 
#define MAX_SCNHDR_NLNNO 0xffff
196 
#endif
197 
#ifndef PUT_SCNHDR_NLNNO
198 
#define PUT_SCNHDR_NLNNO H_PUT_16
199 
#endif
200 
#ifndef GET_SCNHDR_FLAGS
201 
#define GET_SCNHDR_FLAGS H_GET_32
202 
#endif
203 
#ifndef PUT_SCNHDR_FLAGS
204 
#define PUT_SCNHDR_FLAGS H_PUT_32
205 
#endif
206 
 
207 
#ifndef GET_RELOC_VADDR
208 
#define GET_RELOC_VADDR H_GET_32
209 
#endif
210 
#ifndef PUT_RELOC_VADDR
211 
#define PUT_RELOC_VADDR H_PUT_32
212 
#endif
213 
 
214 
#ifndef NO_COFF_RELOCS
215 
 
216 
static void
217 
coff_swap_reloc_in (bfd * abfd, void * src, void * dst)
218 
{
219 
  RELOC *reloc_src = (RELOC *) src;
220 
  struct internal_reloc *reloc_dst = (struct internal_reloc *) dst;
221 
 
222 
  reloc_dst->r_vaddr  = GET_RELOC_VADDR (abfd, reloc_src->r_vaddr);
223 
  reloc_dst->r_symndx = H_GET_S32 (abfd, reloc_src->r_symndx);
224 
  reloc_dst->r_type   = H_GET_16 (abfd, reloc_src->r_type);
225 
 
226 
#ifdef SWAP_IN_RELOC_OFFSET
227 
  reloc_dst->r_offset = SWAP_IN_RELOC_OFFSET (abfd, reloc_src->r_offset);
228 
#endif
229 
}
230 
 
231 
static unsigned int
232 
coff_swap_reloc_out (bfd * abfd, void * src, void * dst)
233 
{
234 
  struct internal_reloc *reloc_src = (struct internal_reloc *) src;
235 
  struct external_reloc *reloc_dst = (struct external_reloc *) dst;
236 
 
237 
  PUT_RELOC_VADDR (abfd, reloc_src->r_vaddr, reloc_dst->r_vaddr);
238 
  H_PUT_32 (abfd, reloc_src->r_symndx, reloc_dst->r_symndx);
239 
  H_PUT_16 (abfd, reloc_src->r_type, reloc_dst->r_type);
240 
 
241 
#ifdef SWAP_OUT_RELOC_OFFSET
242 
  SWAP_OUT_RELOC_OFFSET (abfd, reloc_src->r_offset, reloc_dst->r_offset);
243 
#endif
244 
#ifdef SWAP_OUT_RELOC_EXTRA
245 
  SWAP_OUT_RELOC_EXTRA (abfd, reloc_src, reloc_dst);
246 
#endif
247 
 
248 
  return bfd_coff_relsz (abfd);
249 
}
250 
 
251 
#endif /* NO_COFF_RELOCS */
252 
 
253 
static void
254 
coff_swap_filehdr_in (bfd * abfd, void * src, void * dst)
255 
{
256 
  FILHDR *filehdr_src = (FILHDR *) src;
257 
  struct internal_filehdr *filehdr_dst = (struct internal_filehdr *) dst;
258 
 
259 
#ifdef COFF_ADJUST_FILEHDR_IN_PRE
260 
  COFF_ADJUST_FILEHDR_IN_PRE (abfd, src, dst);
261 
#endif
262 
  filehdr_dst->f_magic  = H_GET_16 (abfd, filehdr_src->f_magic);
263 
  filehdr_dst->f_nscns  = H_GET_16 (abfd, filehdr_src->f_nscns);
264 
  filehdr_dst->f_timdat = H_GET_32 (abfd, filehdr_src->f_timdat);
265 
  filehdr_dst->f_symptr = GET_FILEHDR_SYMPTR (abfd, filehdr_src->f_symptr);
266 
  filehdr_dst->f_nsyms  = H_GET_32 (abfd, filehdr_src->f_nsyms);
267 
  filehdr_dst->f_opthdr = H_GET_16 (abfd, filehdr_src->f_opthdr);
268 
  filehdr_dst->f_flags  = H_GET_16 (abfd, filehdr_src->f_flags);
269 
#ifdef TIC80_TARGET_ID
270 
  filehdr_dst->f_target_id = H_GET_16 (abfd, filehdr_src->f_target_id);
271 
#endif
272 
 
273 
#ifdef COFF_ADJUST_FILEHDR_IN_POST
274 
  COFF_ADJUST_FILEHDR_IN_POST (abfd, src, dst);
275 
#endif
276 
}
277 
 
278 
static  unsigned int
279 
coff_swap_filehdr_out (bfd *abfd, void * in, void * out)
280 
{
281 
  struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
282 
  FILHDR *filehdr_out = (FILHDR *) out;
283 
 
284 
#ifdef COFF_ADJUST_FILEHDR_OUT_PRE
285 
  COFF_ADJUST_FILEHDR_OUT_PRE (abfd, in, out);
286 
#endif
287 
  H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
288 
  H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
289 
  H_PUT_32 (abfd, filehdr_in->f_timdat, filehdr_out->f_timdat);
290 
  PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr, filehdr_out->f_symptr);
291 
  H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
292 
  H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
293 
  H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
294 
#ifdef TIC80_TARGET_ID
295 
  H_PUT_16 (abfd, filehdr_in->f_target_id, filehdr_out->f_target_id);
296 
#endif
297 
 
298 
#ifdef COFF_ADJUST_FILEHDR_OUT_POST
299 
  COFF_ADJUST_FILEHDR_OUT_POST (abfd, in, out);
300 
#endif
301 
  return bfd_coff_filhsz (abfd);
302 
}
303 
 
304 
#ifndef NO_COFF_SYMBOLS
305 
 
306 
static void
307 
coff_swap_sym_in (bfd * abfd, void * ext1, void * in1)
308 
{
309 
  SYMENT *ext = (SYMENT *) ext1;
310 
  struct internal_syment *in = (struct internal_syment *) in1;
311 
 
312 
  if (ext->e.e_name[0] == 0)
313 
    {
314 
      in->_n._n_n._n_zeroes = 0;
315 
      in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e.e.e_offset);
316 
    }
317 
  else
318 
    {
319 
#if SYMNMLEN != E_SYMNMLEN
320 
#error we need to cope with truncating or extending SYMNMLEN
321 
#else
322 
      memcpy (in->_n._n_name, ext->e.e_name, SYMNMLEN);
323 
#endif
324 
    }
325 
 
326 
  in->n_value = H_GET_32 (abfd, ext->e_value);
327 
  in->n_scnum = H_GET_16 (abfd, ext->e_scnum);
328 
  if (sizeof (ext->e_type) == 2)
329 
    in->n_type = H_GET_16 (abfd, ext->e_type);
330 
  else
331 
    in->n_type = H_GET_32 (abfd, ext->e_type);
332 
  in->n_sclass = H_GET_8 (abfd, ext->e_sclass);
333 
  in->n_numaux = H_GET_8 (abfd, ext->e_numaux);
334 
#ifdef COFF_ADJUST_SYM_IN_POST
335 
  COFF_ADJUST_SYM_IN_POST (abfd, ext1, in1);
336 
#endif
337 
}
338 
 
339 
static unsigned int
340 
coff_swap_sym_out (bfd * abfd, void * inp, void * extp)
341 
{
342 
  struct internal_syment *in = (struct internal_syment *) inp;
343 
  SYMENT *ext =(SYMENT *) extp;
344 
 
345 
#ifdef COFF_ADJUST_SYM_OUT_PRE
346 
  COFF_ADJUST_SYM_OUT_PRE (abfd, inp, extp);
347 
#endif
348 
 
349 
  if (in->_n._n_name[0] == 0)
350 
    {
351 
      H_PUT_32 (abfd, 0, ext->e.e.e_zeroes);
352 
      H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e.e.e_offset);
353 
    }
354 
  else
355 
    {
356 
#if SYMNMLEN != E_SYMNMLEN
357 
#error we need to cope with truncating or extending SYMNMLEN
358 
#else
359 
      memcpy (ext->e.e_name, in->_n._n_name, SYMNMLEN);
360 
#endif
361 
    }
362 
 
363 
  H_PUT_32 (abfd, in->n_value, ext->e_value);
364 
  H_PUT_16 (abfd, in->n_scnum, ext->e_scnum);
365 
 
366 
  if (sizeof (ext->e_type) == 2)
367 
    H_PUT_16 (abfd, in->n_type, ext->e_type);
368 
  else
369 
    H_PUT_32 (abfd, in->n_type, ext->e_type);
370 
 
371 
  H_PUT_8 (abfd, in->n_sclass, ext->e_sclass);
372 
  H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);
373 
 
374 
#ifdef COFF_ADJUST_SYM_OUT_POST
375 
  COFF_ADJUST_SYM_OUT_POST (abfd, inp, extp);
376 
#endif
377 
 
378 
  return SYMESZ;
379 
}
380 
 
381 
static void
382 
coff_swap_aux_in (bfd *abfd,
383 
                  void * ext1,
384 
                  int type,
385 
                  int class,
386 
                  int indx,
387 
                  int numaux,
388 
                  void * in1)
389 
{
390 
  AUXENT *ext = (AUXENT *) ext1;
391 
  union internal_auxent *in = (union internal_auxent *) in1;
392 
 
393 
#ifdef COFF_ADJUST_AUX_IN_PRE
394 
  COFF_ADJUST_AUX_IN_PRE (abfd, ext1, type, class, indx, numaux, in1);
395 
#endif
396 
 
397 
  switch (class)
398 
    {
399 
    case C_FILE:
400 
      if (ext->x_file.x_fname[0] == 0)
401 
        {
402 
          in->x_file.x_n.x_zeroes = 0;
403 
          in->x_file.x_n.x_offset = H_GET_32 (abfd, ext->x_file.x_n.x_offset);
404 
        }
405 
      else
406 
        {
407 
#if FILNMLEN != E_FILNMLEN
408 
#error we need to cope with truncating or extending FILNMLEN
409 
#else
410 
          if (numaux > 1)
411 
            {
412 
              if (indx == 0)
413 
                memcpy (in->x_file.x_fname, ext->x_file.x_fname,
414 
                        numaux * sizeof (AUXENT));
415 
            }
416 
          else
417 
            memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
418 
#endif
419 
        }
420 
      goto end;
421 
 
422 
    case C_STAT:
423 
#ifdef C_LEAFSTAT
424 
    case C_LEAFSTAT:
425 
#endif
426 
    case C_HIDDEN:
427 
      if (type == T_NULL)
428 
        {
429 
          in->x_scn.x_scnlen = GET_SCN_SCNLEN (abfd, ext);
430 
          in->x_scn.x_nreloc = GET_SCN_NRELOC (abfd, ext);
431 
          in->x_scn.x_nlinno = GET_SCN_NLINNO (abfd, ext);
432 
 
433 
          /* PE defines some extra fields; we zero them out for
434 
             safety.  */
435 
          in->x_scn.x_checksum = 0;
436 
          in->x_scn.x_associated = 0;
437 
          in->x_scn.x_comdat = 0;
438 
 
439 
          goto end;
440 
        }
441 
      break;
442 
    }
443 
 
444 
  in->x_sym.x_tagndx.l = H_GET_32 (abfd, ext->x_sym.x_tagndx);
445 
#ifndef NO_TVNDX
446 
  in->x_sym.x_tvndx = H_GET_16 (abfd, ext->x_sym.x_tvndx);
447 
#endif
448 
 
449 
  if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
450 
    {
451 
      in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR (abfd, ext);
452 
      in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX (abfd, ext);
453 
    }
454 
  else
455 
    {
456 
#if DIMNUM != E_DIMNUM
457 
#error we need to cope with truncating or extending DIMNUM
458 
#endif
459 
      in->x_sym.x_fcnary.x_ary.x_dimen[0] =
460 
        H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
461 
      in->x_sym.x_fcnary.x_ary.x_dimen[1] =
462 
        H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
463 
      in->x_sym.x_fcnary.x_ary.x_dimen[2] =
464 
        H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
465 
      in->x_sym.x_fcnary.x_ary.x_dimen[3] =
466 
        H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
467 
    }
468 
 
469 
  if (ISFCN (type))
470 
    in->x_sym.x_misc.x_fsize = H_GET_32 (abfd, ext->x_sym.x_misc.x_fsize);
471 
  else
472 
    {
473 
      in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO (abfd, ext);
474 
      in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE (abfd, ext);
475 
    }
476 
 
477 
 end: ;
478 
 
479 
#ifdef COFF_ADJUST_AUX_IN_POST
480 
  COFF_ADJUST_AUX_IN_POST (abfd, ext1, type, class, indx, numaux, in1);
481 
#endif
482 
}
483 
 
484 
static unsigned int
485 
coff_swap_aux_out (bfd * abfd,
486 
                   void * inp,
487 
                   int type,
488 
                   int class,
489 
                   int indx ATTRIBUTE_UNUSED,
490 
                   int numaux ATTRIBUTE_UNUSED,
491 
                   void * extp)
492 
{
493 
  union internal_auxent * in = (union internal_auxent *) inp;
494 
  AUXENT *ext = (AUXENT *) extp;
495 
 
496 
#ifdef COFF_ADJUST_AUX_OUT_PRE
497 
  COFF_ADJUST_AUX_OUT_PRE (abfd, inp, type, class, indx, numaux, extp);
498 
#endif
499 
 
500 
  memset (ext, 0, AUXESZ);
501 
 
502 
  switch (class)
503 
    {
504 
    case C_FILE:
505 
      if (in->x_file.x_fname[0] == 0)
506 
        {
507 
          H_PUT_32 (abfd, 0, ext->x_file.x_n.x_zeroes);
508 
          H_PUT_32 (abfd, in->x_file.x_n.x_offset, ext->x_file.x_n.x_offset);
509 
        }
510 
      else
511 
        {
512 
#if FILNMLEN != E_FILNMLEN
513 
#error we need to cope with truncating or extending FILNMLEN
514 
#else
515 
          memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
516 
#endif
517 
        }
518 
      goto end;
519 
 
520 
    case C_STAT:
521 
#ifdef C_LEAFSTAT
522 
    case C_LEAFSTAT:
523 
#endif
524 
    case C_HIDDEN:
525 
      if (type == T_NULL)
526 
        {
527 
          PUT_SCN_SCNLEN (abfd, in->x_scn.x_scnlen, ext);
528 
          PUT_SCN_NRELOC (abfd, in->x_scn.x_nreloc, ext);
529 
          PUT_SCN_NLINNO (abfd, in->x_scn.x_nlinno, ext);
530 
          goto end;
531 
        }
532 
      break;
533 
    }
534 
 
535 
  H_PUT_32 (abfd, in->x_sym.x_tagndx.l, ext->x_sym.x_tagndx);
536 
#ifndef NO_TVNDX
537 
  H_PUT_16 (abfd, in->x_sym.x_tvndx, ext->x_sym.x_tvndx);
538 
#endif
539 
 
540 
  if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
541 
    {
542 
      PUT_FCN_LNNOPTR (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext);
543 
      PUT_FCN_ENDNDX (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext);
544 
    }
545 
  else
546 
    {
547 
#if DIMNUM != E_DIMNUM
548 
#error we need to cope with truncating or extending DIMNUM
549 
#endif
550 
      H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],
551 
               ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
552 
      H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],
553 
               ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
554 
      H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],
555 
               ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
556 
      H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],
557 
               ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
558 
    }
559 
 
560 
  if (ISFCN (type))
561 
    H_PUT_32 (abfd, in->x_sym.x_misc.x_fsize, ext->x_sym.x_misc.x_fsize);
562 
  else
563 
    {
564 
      PUT_LNSZ_LNNO (abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext);
565 
      PUT_LNSZ_SIZE (abfd, in->x_sym.x_misc.x_lnsz.x_size, ext);
566 
    }
567 
 
568 
 end:
569 
#ifdef COFF_ADJUST_AUX_OUT_POST
570 
  COFF_ADJUST_AUX_OUT_POST (abfd, inp, type, class, indx, numaux, extp);
571 
#endif
572 
  return AUXESZ;
573 
}
574 
 
575 
#endif /* NO_COFF_SYMBOLS */
576 
 
577 
#ifndef NO_COFF_LINENOS
578 
 
579 
static void
580 
coff_swap_lineno_in (bfd * abfd, void * ext1, void * in1)
581 
{
582 
  LINENO *ext = (LINENO *) ext1;
583 
  struct internal_lineno *in = (struct internal_lineno *) in1;
584 
 
585 
  in->l_addr.l_symndx = H_GET_32 (abfd, ext->l_addr.l_symndx);
586 
  in->l_lnno = GET_LINENO_LNNO (abfd, ext);
587 
}
588 
 
589 
static unsigned int
590 
coff_swap_lineno_out (bfd * abfd, void * inp, void * outp)
591 
{
592 
  struct internal_lineno *in = (struct internal_lineno *) inp;
593 
  struct external_lineno *ext = (struct external_lineno *) outp;
594 
  H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx);
595 
 
596 
  PUT_LINENO_LNNO (abfd, in->l_lnno, ext);
597 
  return LINESZ;
598 
}
599 
 
600 
#endif /* NO_COFF_LINENOS */
601 
 
602 
static void
603 
coff_swap_aouthdr_in (bfd * abfd, void * aouthdr_ext1, void * aouthdr_int1)
604 
{
605 
  AOUTHDR *aouthdr_ext;
606 
  struct internal_aouthdr *aouthdr_int;
607 
 
608 
  aouthdr_ext = (AOUTHDR *) aouthdr_ext1;
609 
  aouthdr_int = (struct internal_aouthdr *) aouthdr_int1;
610 
  aouthdr_int->magic = H_GET_16 (abfd, aouthdr_ext->magic);
611 
  aouthdr_int->vstamp = H_GET_16 (abfd, aouthdr_ext->vstamp);
612 
  aouthdr_int->tsize = GET_AOUTHDR_TSIZE (abfd, aouthdr_ext->tsize);
613 
  aouthdr_int->dsize = GET_AOUTHDR_DSIZE (abfd, aouthdr_ext->dsize);
614 
  aouthdr_int->bsize = GET_AOUTHDR_BSIZE (abfd, aouthdr_ext->bsize);
615 
  aouthdr_int->entry = GET_AOUTHDR_ENTRY (abfd, aouthdr_ext->entry);
616 
  aouthdr_int->text_start =
617 
    GET_AOUTHDR_TEXT_START (abfd, aouthdr_ext->text_start);
618 
  aouthdr_int->data_start =
619 
    GET_AOUTHDR_DATA_START (abfd, aouthdr_ext->data_start);
620 
 
621 
#ifdef I960
622 
  aouthdr_int->tagentries = H_GET_32 (abfd, aouthdr_ext->tagentries);
623 
#endif
624 
 
625 
#ifdef APOLLO_M68
626 
  H_PUT_32 (abfd, aouthdr_int->o_inlib, aouthdr_ext->o_inlib);
627 
  H_PUT_32 (abfd, aouthdr_int->o_sri, aouthdr_ext->o_sri);
628 
  H_PUT_32 (abfd, aouthdr_int->vid[0], aouthdr_ext->vid);
629 
  H_PUT_32 (abfd, aouthdr_int->vid[1], aouthdr_ext->vid + 4);
630 
#endif
631 
 
632 
#ifdef RS6000COFF_C
633 
#ifdef XCOFF64
634 
  aouthdr_int->o_toc = H_GET_64 (abfd, aouthdr_ext->o_toc);
635 
#else
636 
  aouthdr_int->o_toc = H_GET_32 (abfd, aouthdr_ext->o_toc);
637 
#endif
638 
  aouthdr_int->o_snentry  = H_GET_16 (abfd, aouthdr_ext->o_snentry);
639 
  aouthdr_int->o_sntext   = H_GET_16 (abfd, aouthdr_ext->o_sntext);
640 
  aouthdr_int->o_sndata   = H_GET_16 (abfd, aouthdr_ext->o_sndata);
641 
  aouthdr_int->o_sntoc    = H_GET_16 (abfd, aouthdr_ext->o_sntoc);
642 
  aouthdr_int->o_snloader = H_GET_16 (abfd, aouthdr_ext->o_snloader);
643 
  aouthdr_int->o_snbss    = H_GET_16 (abfd, aouthdr_ext->o_snbss);
644 
  aouthdr_int->o_algntext = H_GET_16 (abfd, aouthdr_ext->o_algntext);
645 
  aouthdr_int->o_algndata = H_GET_16 (abfd, aouthdr_ext->o_algndata);
646 
  aouthdr_int->o_modtype  = H_GET_16 (abfd, aouthdr_ext->o_modtype);
647 
  aouthdr_int->o_cputype  = H_GET_16 (abfd, aouthdr_ext->o_cputype);
648 
#ifdef XCOFF64
649 
  aouthdr_int->o_maxstack = H_GET_64 (abfd, aouthdr_ext->o_maxstack);
650 
  aouthdr_int->o_maxdata  = H_GET_64 (abfd, aouthdr_ext->o_maxdata);
651 
#else
652 
  aouthdr_int->o_maxstack = H_GET_32 (abfd, aouthdr_ext->o_maxstack);
653 
  aouthdr_int->o_maxdata  = H_GET_32 (abfd, aouthdr_ext->o_maxdata);
654 
#endif
655 
#endif
656 
 
657 
#ifdef MIPSECOFF
658 
  aouthdr_int->bss_start  = H_GET_32 (abfd, aouthdr_ext->bss_start);
659 
  aouthdr_int->gp_value   = H_GET_32 (abfd, aouthdr_ext->gp_value);
660 
  aouthdr_int->gprmask    = H_GET_32 (abfd, aouthdr_ext->gprmask);
661 
  aouthdr_int->cprmask[0] = H_GET_32 (abfd, aouthdr_ext->cprmask[0]);
662 
  aouthdr_int->cprmask[1] = H_GET_32 (abfd, aouthdr_ext->cprmask[1]);
663 
  aouthdr_int->cprmask[2] = H_GET_32 (abfd, aouthdr_ext->cprmask[2]);
664 
  aouthdr_int->cprmask[3] = H_GET_32 (abfd, aouthdr_ext->cprmask[3]);
665 
#endif
666 
 
667 
#ifdef ALPHAECOFF
668 
  aouthdr_int->bss_start = H_GET_64 (abfd, aouthdr_ext->bss_start);
669 
  aouthdr_int->gp_value  = H_GET_64 (abfd, aouthdr_ext->gp_value);
670 
  aouthdr_int->gprmask   = H_GET_32 (abfd, aouthdr_ext->gprmask);
671 
  aouthdr_int->fprmask   = H_GET_32 (abfd, aouthdr_ext->fprmask);
672 
#endif
673 
}
674 
 
675 
static unsigned int
676 
coff_swap_aouthdr_out (bfd * abfd, void * in, void * out)
677 
{
678 
  struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *) in;
679 
  AOUTHDR *aouthdr_out = (AOUTHDR *) out;
680 
 
681 
  H_PUT_16 (abfd, aouthdr_in->magic, aouthdr_out->magic);
682 
  H_PUT_16 (abfd, aouthdr_in->vstamp, aouthdr_out->vstamp);
683 
  PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, aouthdr_out->tsize);
684 
  PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, aouthdr_out->dsize);
685 
  PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, aouthdr_out->bsize);
686 
  PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, aouthdr_out->entry);
687 
  PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
688 
                          aouthdr_out->text_start);
689 
  PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
690 
                          aouthdr_out->data_start);
691 
 
692 
#ifdef I960
693 
  H_PUT_32 (abfd, aouthdr_in->tagentries, aouthdr_out->tagentries);
694 
#endif
695 
 
696 
#ifdef RS6000COFF_C
697 
#ifdef XCOFF64
698 
  H_PUT_64 (abfd, aouthdr_in->o_toc, aouthdr_out->o_toc);
699 
#else
700 
  H_PUT_32 (abfd, aouthdr_in->o_toc, aouthdr_out->o_toc);
701 
#endif
702 
  H_PUT_16 (abfd, aouthdr_in->o_snentry, aouthdr_out->o_snentry);
703 
  H_PUT_16 (abfd, aouthdr_in->o_sntext, aouthdr_out->o_sntext);
704 
  H_PUT_16 (abfd, aouthdr_in->o_sndata, aouthdr_out->o_sndata);
705 
  H_PUT_16 (abfd, aouthdr_in->o_sntoc, aouthdr_out->o_sntoc);
706 
  H_PUT_16 (abfd, aouthdr_in->o_snloader, aouthdr_out->o_snloader);
707 
  H_PUT_16 (abfd, aouthdr_in->o_snbss, aouthdr_out->o_snbss);
708 
  H_PUT_16 (abfd, aouthdr_in->o_algntext, aouthdr_out->o_algntext);
709 
  H_PUT_16 (abfd, aouthdr_in->o_algndata, aouthdr_out->o_algndata);
710 
  H_PUT_16 (abfd, aouthdr_in->o_modtype, aouthdr_out->o_modtype);
711 
  H_PUT_16 (abfd, aouthdr_in->o_cputype, aouthdr_out->o_cputype);
712 
#ifdef XCOFF64
713 
  H_PUT_64 (abfd, aouthdr_in->o_maxstack, aouthdr_out->o_maxstack);
714 
  H_PUT_64 (abfd, aouthdr_in->o_maxdata, aouthdr_out->o_maxdata);
715 
#else
716 
  H_PUT_32 (abfd, aouthdr_in->o_maxstack, aouthdr_out->o_maxstack);
717 
  H_PUT_32 (abfd, aouthdr_in->o_maxdata, aouthdr_out->o_maxdata);
718 
#endif
719 
  memset (aouthdr_out->o_resv2, 0, sizeof aouthdr_out->o_resv2);
720 
#ifdef XCOFF64
721 
  memset (aouthdr_out->o_debugger, 0, sizeof aouthdr_out->o_debugger);
722 
  memset (aouthdr_out->o_resv3, 0, sizeof aouthdr_out->o_resv3);
723 
#endif
724 
#endif
725 
 
726 
#ifdef MIPSECOFF
727 
  H_PUT_32 (abfd, aouthdr_in->bss_start, aouthdr_out->bss_start);
728 
  H_PUT_32 (abfd, aouthdr_in->gp_value, aouthdr_out->gp_value);
729 
  H_PUT_32 (abfd, aouthdr_in->gprmask, aouthdr_out->gprmask);
730 
  H_PUT_32 (abfd, aouthdr_in->cprmask[0], aouthdr_out->cprmask[0]);
731 
  H_PUT_32 (abfd, aouthdr_in->cprmask[1], aouthdr_out->cprmask[1]);
732 
  H_PUT_32 (abfd, aouthdr_in->cprmask[2], aouthdr_out->cprmask[2]);
733 
  H_PUT_32 (abfd, aouthdr_in->cprmask[3], aouthdr_out->cprmask[3]);
734 
#endif
735 
 
736 
#ifdef ALPHAECOFF
737 
  /* FIXME: What does bldrev mean?  */
738 
  H_PUT_16 (abfd, 2, aouthdr_out->bldrev);
739 
  H_PUT_16 (abfd, 0, aouthdr_out->padding);
740 
  H_PUT_64 (abfd, aouthdr_in->bss_start, aouthdr_out->bss_start);
741 
  H_PUT_64 (abfd, aouthdr_in->gp_value, aouthdr_out->gp_value);
742 
  H_PUT_32 (abfd, aouthdr_in->gprmask, aouthdr_out->gprmask);
743 
  H_PUT_32 (abfd, aouthdr_in->fprmask, aouthdr_out->fprmask);
744 
#endif
745 
 
746 
  return AOUTSZ;
747 
}
748 
 
749 
static void
750 
coff_swap_scnhdr_in (bfd * abfd, void * ext, void * in)
751 
{
752 
  SCNHDR *scnhdr_ext = (SCNHDR *) ext;
753 
  struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
754 
 
755 
#ifdef COFF_ADJUST_SCNHDR_IN_PRE
756 
  COFF_ADJUST_SCNHDR_IN_PRE (abfd, ext, in);
757 
#endif
758 
  memcpy (scnhdr_int->s_name, scnhdr_ext->s_name, sizeof (scnhdr_int->s_name));
759 
 
760 
  scnhdr_int->s_vaddr = GET_SCNHDR_VADDR (abfd, scnhdr_ext->s_vaddr);
761 
  scnhdr_int->s_paddr = GET_SCNHDR_PADDR (abfd, scnhdr_ext->s_paddr);
762 
  scnhdr_int->s_size = GET_SCNHDR_SIZE (abfd, scnhdr_ext->s_size);
763 
 
764 
  scnhdr_int->s_scnptr = GET_SCNHDR_SCNPTR (abfd, scnhdr_ext->s_scnptr);
765 
  scnhdr_int->s_relptr = GET_SCNHDR_RELPTR (abfd, scnhdr_ext->s_relptr);
766 
  scnhdr_int->s_lnnoptr = GET_SCNHDR_LNNOPTR (abfd, scnhdr_ext->s_lnnoptr);
767 
  scnhdr_int->s_flags = GET_SCNHDR_FLAGS (abfd, scnhdr_ext->s_flags);
768 
  scnhdr_int->s_nreloc = GET_SCNHDR_NRELOC (abfd, scnhdr_ext->s_nreloc);
769 
  scnhdr_int->s_nlnno = GET_SCNHDR_NLNNO (abfd, scnhdr_ext->s_nlnno);
770 
#ifdef I960
771 
  scnhdr_int->s_align = GET_SCNHDR_ALIGN (abfd, scnhdr_ext->s_align);
772 
#endif
773 
#ifdef COFF_ADJUST_SCNHDR_IN_POST
774 
  COFF_ADJUST_SCNHDR_IN_POST (abfd, ext, in);
775 
#endif
776 
}
777 
 
778 
static unsigned int
779 
coff_swap_scnhdr_out (bfd * abfd, void * in, void * out)
780 
{
781 
  struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
782 
  SCNHDR *scnhdr_ext = (SCNHDR *) out;
783 
  unsigned int ret = bfd_coff_scnhsz (abfd);
784 
 
785 
#ifdef COFF_ADJUST_SCNHDR_OUT_PRE
786 
  COFF_ADJUST_SCNHDR_OUT_PRE (abfd, in, out);
787 
#endif
788 
  memcpy (scnhdr_ext->s_name, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
789 
 
790 
  PUT_SCNHDR_VADDR (abfd, scnhdr_int->s_vaddr, scnhdr_ext->s_vaddr);
791 
  PUT_SCNHDR_PADDR (abfd, scnhdr_int->s_paddr, scnhdr_ext->s_paddr);
792 
  PUT_SCNHDR_SIZE (abfd, scnhdr_int->s_size, scnhdr_ext->s_size);
793 
  PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr, scnhdr_ext->s_scnptr);
794 
  PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr, scnhdr_ext->s_relptr);
795 
  PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr, scnhdr_ext->s_lnnoptr);
796 
  PUT_SCNHDR_FLAGS (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
797 
#if defined(M88)
798 
  H_PUT_32 (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno);
799 
  H_PUT_32 (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc);
800 
#else
801 
  if (scnhdr_int->s_nlnno <= MAX_SCNHDR_NLNNO)
802 
    PUT_SCNHDR_NLNNO (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno);
803 
  else
804 
    {
805 
      char buf[sizeof (scnhdr_int->s_name) + 1];
806 
 
807 
      memcpy (buf, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
808 
      buf[sizeof (scnhdr_int->s_name)] = '\0';
809 
      (*_bfd_error_handler)
810 
        (_("%s: warning: %s: line number overflow: 0x%lx > 0xffff"),
811 
         bfd_get_filename (abfd),
812 
         buf, scnhdr_int->s_nlnno);
813 
      PUT_SCNHDR_NLNNO (abfd, 0xffff, scnhdr_ext->s_nlnno);
814 
    }
815 
 
816 
  if (scnhdr_int->s_nreloc <= MAX_SCNHDR_NRELOC)
817 
    PUT_SCNHDR_NRELOC (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc);
818 
  else
819 
    {
820 
      char buf[sizeof (scnhdr_int->s_name) + 1];
821 
 
822 
      memcpy (buf, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
823 
      buf[sizeof (scnhdr_int->s_name)] = '\0';
824 
      (*_bfd_error_handler) (_("%s: %s: reloc overflow: 0x%lx > 0xffff"),
825 
                             bfd_get_filename (abfd),
826 
                             buf, scnhdr_int->s_nreloc);
827 
      bfd_set_error (bfd_error_file_truncated);
828 
      PUT_SCNHDR_NRELOC (abfd, 0xffff, scnhdr_ext->s_nreloc);
829 
      ret = 0;
830 
    }
831 
#endif
832 
 
833 
#ifdef I960
834 
  PUT_SCNHDR_ALIGN (abfd, scnhdr_int->s_align, scnhdr_ext->s_align);
835 
#endif
836 
#ifdef COFF_ADJUST_SCNHDR_OUT_POST
837 
  COFF_ADJUST_SCNHDR_OUT_POST (abfd, in, out);
838 
#endif
839 
  return ret;
840 
}

powered by: WebSVN 2.1.0

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