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

Subversion Repositories openrisc

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

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.