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

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [bfd/] [coff-i960.c] - Blame information for rev 148

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 14 khays
/* BFD back-end for Intel 960 COFF files.
2
   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1997, 1999, 2000, 2001,
3 148 khays
   2002, 2003, 2004, 2005, 2007, 2008, 2009, 2011
4
   Free Software Foundation, Inc.
5 14 khays
   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
#define I960 1
25
#define BADMAG(x) I960BADMAG(x)
26
 
27
#include "sysdep.h"
28
#include "bfd.h"
29
#include "libbfd.h"
30
#include "coff/i960.h"
31
#include "coff/internal.h"
32
 
33
#ifndef bfd_pe_print_pdata
34
#define bfd_pe_print_pdata      NULL
35
#endif
36
 
37
#include "libcoff.h"            /* To allow easier abstraction-breaking.  */
38
 
39
static bfd_boolean coff_i960_is_local_label_name
40
  PARAMS ((bfd *, const char *));
41
static bfd_reloc_status_type optcall_callback
42
  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
43
static bfd_reloc_status_type coff_i960_relocate
44
  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
45
static reloc_howto_type *coff_i960_reloc_type_lookup
46
  PARAMS ((bfd *, bfd_reloc_code_real_type));
47
static bfd_boolean coff_i960_start_final_link
48
  PARAMS ((bfd *, struct bfd_link_info *));
49
static bfd_boolean coff_i960_relocate_section
50
  PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
51
           struct internal_reloc *, struct internal_syment *, asection **));
52
static bfd_boolean coff_i960_adjust_symndx
53
  PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *,
54
           struct internal_reloc *, bfd_boolean *));
55
 
56
#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (3)
57
#define COFF_ALIGN_IN_SECTION_HEADER 1
58
 
59
#define GET_SCNHDR_ALIGN H_GET_32
60
#define PUT_SCNHDR_ALIGN H_PUT_32
61
 
62
/* The i960 does not support an MMU, so COFF_PAGE_SIZE can be
63
   arbitrarily small.  */
64
#define COFF_PAGE_SIZE 1
65
 
66
#define COFF_LONG_FILENAMES
67
 
68
/* This set of local label names is taken from gas.  */
69
 
70
static bfd_boolean
71
coff_i960_is_local_label_name (abfd, name)
72
     bfd *abfd ATTRIBUTE_UNUSED;
73
     const char *name;
74
{
75
  return (name[0] == 'L'
76
          || (name[0] == '.'
77
              && (name[1] == 'C'
78
                  || name[1] == 'I'
79
                  || name[1] == '.')));
80
}
81
 
82
/* This is just like the usual CALC_ADDEND, but it includes the
83
   section VMA for PC relative relocs.  */
84
#ifndef CALC_ADDEND
85
#define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)                \
86
  {                                                             \
87
    coff_symbol_type *coffsym = (coff_symbol_type *) NULL;      \
88
    if (ptr && bfd_asymbol_bfd (ptr) != abfd)                   \
89
      coffsym = (obj_symbols (abfd)                             \
90
                 + (cache_ptr->sym_ptr_ptr - symbols));         \
91
    else if (ptr)                                               \
92
      coffsym = coff_symbol_from (abfd, ptr);                   \
93
    if (coffsym != (coff_symbol_type *) NULL                    \
94
        && coffsym->native->u.syment.n_scnum == 0)              \
95
      cache_ptr->addend = 0;                                    \
96
    else if (ptr && bfd_asymbol_bfd (ptr) == abfd               \
97
             && ptr->section != (asection *) NULL)              \
98
      cache_ptr->addend = - (ptr->section->vma + ptr->value);   \
99
    else                                                        \
100
      cache_ptr->addend = 0;                                    \
101
    if (ptr && (reloc.r_type == 25 || reloc.r_type == 27))      \
102
      cache_ptr->addend += asect->vma;                          \
103
  }
104
#endif
105
 
106
#define CALLS    0x66003800     /* Template for 'calls' instruction     */
107
#define BAL      0x0b000000     /* Template for 'bal' instruction       */
108
#define BAL_MASK 0x00ffffff
109
 
110
static bfd_reloc_status_type
111
optcall_callback (abfd, reloc_entry, symbol_in, data,
112
                  input_section, ignore_bfd, error_message)
113
     bfd *abfd;
114
     arelent *reloc_entry;
115
     asymbol *symbol_in;
116
     PTR data;
117
     asection *input_section;
118
     bfd *ignore_bfd ATTRIBUTE_UNUSED;
119
     char **error_message;
120
{
121
  /* This item has already been relocated correctly, but we may be
122
   * able to patch in yet better code - done by digging out the
123
   * correct info on this symbol */
124
  bfd_reloc_status_type result;
125
  coff_symbol_type *cs = coffsymbol(symbol_in);
126
 
127
  /* Don't do anything with symbols which aren't tied up yet,
128
     except move the reloc.  */
129
  if (bfd_is_und_section (cs->symbol.section)) {
130
    reloc_entry->address += input_section->output_offset;
131
    return bfd_reloc_ok;
132
  }
133
 
134
  /* So the target symbol has to be of coff type, and the symbol
135
     has to have the correct native information within it */
136
  if ((bfd_asymbol_flavour(&cs->symbol) != bfd_target_coff_flavour)
137
      || (cs->native == (combined_entry_type *)NULL))
138
    {
139
      /* This is interesting, consider the case where we're outputting coff
140
         from a mix n match input, linking from coff to a symbol defined in a
141
         bout file will cause this match to be true. Should I complain?  This
142
         will only work if the bout symbol is non leaf.  */
143
      *error_message =
144
        (char *) _("uncertain calling convention for non-COFF symbol");
145
      result = bfd_reloc_dangerous;
146
    }
147
  else
148
    {
149
    switch (cs->native->u.syment.n_sclass)
150
      {
151
      case C_LEAFSTAT:
152
      case C_LEAFEXT:
153
        /* This is a call to a leaf procedure, replace instruction with a bal
154
           to the correct location.  */
155
        {
156
          union internal_auxent *aux = &((cs->native+2)->u.auxent);
157
          int word = bfd_get_32 (abfd, (bfd_byte *)data + reloc_entry->address);
158
          int olf = (aux->x_bal.x_balntry - cs->native->u.syment.n_value);
159
          BFD_ASSERT(cs->native->u.syment.n_numaux==2);
160
 
161
          /* We replace the original call instruction with a bal to
162
             the bal entry point - the offset of which is described in
163
             the 2nd auxent of the original symbol. We keep the native
164
             sym and auxents untouched, so the delta between the two
165
             is the offset of the bal entry point.  */
166
          word = ((word +  olf)  & BAL_MASK) | BAL;
167
          bfd_put_32 (abfd, (bfd_vma) word,
168
                      (bfd_byte *) data + reloc_entry->address);
169
        }
170
        result = bfd_reloc_ok;
171
        break;
172
      case C_SCALL:
173
        /* This is a call to a system call, replace with a calls to # */
174
        BFD_ASSERT(0);
175
        result = bfd_reloc_ok;
176
        break;
177
      default:
178
        result = bfd_reloc_ok;
179
        break;
180
      }
181
  }
182
  return result;
183
}
184
 
185
/* i960 COFF is used by VxWorks 5.1.  However, VxWorks 5.1 does not
186
   appear to correctly handle a reloc against a symbol defined in the
187
   same object file.  It appears to simply discard such relocs, rather
188
   than adding their values into the object file.  We handle this here
189
   by converting all relocs against defined symbols into relocs
190
   against the section symbol, when generating a relocatable output
191
   file.
192
 
193
   Note that this function is only called if we are not using the COFF
194
   specific backend linker.  It only does something when doing a
195
   relocatable link, which will almost certainly fail when not
196
   generating COFF i960 output, so this function is actually no longer
197
   useful.  It was used before this target was converted to use the
198
   COFF specific backend linker.  */
199
 
200
static bfd_reloc_status_type
201
coff_i960_relocate (abfd, reloc_entry, symbol, data, input_section,
202
                    output_bfd, error_message)
203
     bfd *abfd;
204
     arelent *reloc_entry;
205
     asymbol *symbol;
206
     PTR data ATTRIBUTE_UNUSED;
207
     asection *input_section ATTRIBUTE_UNUSED;
208
     bfd *output_bfd;
209
     char **error_message ATTRIBUTE_UNUSED;
210
{
211
  asection *osec;
212
 
213
  if (output_bfd == NULL)
214
    {
215
      /* Not generating relocatable output file.  */
216
      return bfd_reloc_continue;
217
    }
218
 
219
  if (bfd_is_und_section (bfd_get_section (symbol)))
220
    {
221
      /* Symbol is not defined, so no need to worry about it.  */
222
      return bfd_reloc_continue;
223
    }
224
 
225
  if (bfd_is_com_section (bfd_get_section (symbol)))
226
    {
227
      /* I don't really know what the right action is for a common
228
         symbol.  */
229
      return bfd_reloc_continue;
230
    }
231
 
232
  /* Convert the reloc to use the section symbol.  FIXME: This method
233
     is ridiculous.  */
234
  osec = bfd_get_section (symbol)->output_section;
235
  if (coff_section_data (output_bfd, osec) != NULL
236
      && coff_section_data (output_bfd, osec)->tdata != NULL)
237
    reloc_entry->sym_ptr_ptr =
238
      (asymbol **) coff_section_data (output_bfd, osec)->tdata;
239
  else
240
    {
241
      const char *sec_name;
242
      asymbol **syms, **sym_end;
243
 
244
      sec_name = bfd_get_section_name (output_bfd, osec);
245
      syms = bfd_get_outsymbols (output_bfd);
246
      sym_end = syms + bfd_get_symcount (output_bfd);
247
      for (; syms < sym_end; syms++)
248
        {
249
          if (bfd_asymbol_name (*syms) != NULL
250
              && (*syms)->value == 0
251
              && strcmp ((*syms)->section->output_section->name,
252
                         sec_name) == 0)
253
            break;
254
        }
255
 
256
      if (syms >= sym_end)
257
        abort ();
258
 
259
      reloc_entry->sym_ptr_ptr = syms;
260
 
261
      if (coff_section_data (output_bfd, osec) == NULL)
262
        {
263
          bfd_size_type amt = sizeof (struct coff_section_tdata);
264
          osec->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
265
          if (osec->used_by_bfd == NULL)
266
            return bfd_reloc_overflow;
267
        }
268
      coff_section_data (output_bfd, osec)->tdata = (PTR) syms;
269
    }
270
 
271
  /* Let bfd_perform_relocation do its thing, which will include
272
     stuffing the symbol addend into the object file.  */
273
  return bfd_reloc_continue;
274
}
275
 
276
static reloc_howto_type howto_rellong =
277
  HOWTO ((unsigned int) R_RELLONG, 0, 2, 32,FALSE, 0,
278
         complain_overflow_bitfield, coff_i960_relocate,"rellong", TRUE,
279
         0xffffffff, 0xffffffff, 0);
280
static reloc_howto_type howto_iprmed =
281
  HOWTO (R_IPRMED, 0, 2, 24,TRUE,0, complain_overflow_signed,
282
         coff_i960_relocate, "iprmed ", TRUE, 0x00ffffff, 0x00ffffff, 0);
283
static reloc_howto_type howto_optcall =
284
  HOWTO (R_OPTCALL, 0,2,24,TRUE,0, complain_overflow_signed,
285
         optcall_callback, "optcall", TRUE, 0x00ffffff, 0x00ffffff, 0);
286
 
287
static reloc_howto_type *
288
coff_i960_reloc_type_lookup (abfd, code)
289
     bfd *abfd ATTRIBUTE_UNUSED;
290
     bfd_reloc_code_real_type code;
291
{
292
  switch (code)
293
    {
294
    default:
295
      return 0;
296
    case BFD_RELOC_I960_CALLJ:
297
      return &howto_optcall;
298
    case BFD_RELOC_32:
299
    case BFD_RELOC_CTOR:
300
      return &howto_rellong;
301
    case BFD_RELOC_24_PCREL:
302
      return &howto_iprmed;
303
    }
304
}
305
 
306
static reloc_howto_type *
307
coff_i960_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
308
                             const char *r_name)
309
{
310
  if (strcasecmp (howto_optcall.name, r_name) == 0)
311
    return &howto_optcall;
312
  if (strcasecmp (howto_rellong.name, r_name) == 0)
313
    return &howto_rellong;
314
  if (strcasecmp (howto_iprmed.name, r_name) == 0)
315
    return &howto_iprmed;
316
 
317
  return NULL;
318
}
319
 
320
/* The real code is in coffcode.h */
321
 
322
#define RTYPE2HOWTO(cache_ptr, dst) \
323
{                                                       \
324
   reloc_howto_type *howto_ptr;                         \
325
   switch ((dst)->r_type) {                             \
326
     case 17: howto_ptr = &howto_rellong; break;        \
327
     case 25: howto_ptr = &howto_iprmed; break;         \
328
     case 27: howto_ptr = &howto_optcall; break;        \
329
     default: howto_ptr = 0; break;                      \
330
     }                                                  \
331
   (cache_ptr)->howto = howto_ptr;                      \
332
 }
333
 
334
/* i960 COFF is used by VxWorks 5.1.  However, VxWorks 5.1 does not
335
   appear to correctly handle a reloc against a symbol defined in the
336
   same object file.  It appears to simply discard such relocs, rather
337
   than adding their values into the object file.  We handle this by
338
   converting all relocs against global symbols into relocs against
339
   internal symbols at the start of the section.  This routine is
340
   called at the start of the linking process, and it creates the
341
   necessary symbols.  */
342
 
343
static bfd_boolean
344
coff_i960_start_final_link (abfd, info)
345
     bfd *abfd;
346
     struct bfd_link_info *info;
347
{
348
  bfd_size_type symesz = bfd_coff_symesz (abfd);
349
  asection *o;
350
  bfd_byte *esym;
351
 
352
  if (! info->relocatable)
353
    return TRUE;
354
 
355
  esym = (bfd_byte *) bfd_malloc (symesz);
356
  if (esym == NULL)
357
    return FALSE;
358
 
359
  if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0)
360
    return FALSE;
361
 
362
  for (o = abfd->sections; o != NULL; o = o->next)
363
    {
364
      struct internal_syment isym;
365
 
366
      strncpy (isym._n._n_name, o->name, SYMNMLEN);
367
      isym.n_value = 0;
368
      isym.n_scnum = o->target_index;
369
      isym.n_type = T_NULL;
370
      isym.n_sclass = C_STAT;
371
      isym.n_numaux = 0;
372
 
373
      bfd_coff_swap_sym_out (abfd, (PTR) &isym, (PTR) esym);
374
 
375
      if (bfd_bwrite (esym, symesz, abfd) != symesz)
376
        {
377
          free (esym);
378
          return FALSE;
379
        }
380
 
381
      obj_raw_syment_count (abfd) += 1;
382
    }
383
 
384
  free (esym);
385
 
386
  return TRUE;
387
}
388
 
389
/* The reloc processing routine for the optimized COFF linker.  */
390
 
391
static bfd_boolean
392
coff_i960_relocate_section (output_bfd, info, input_bfd, input_section,
393
                            contents, relocs, syms, sections)
394
     bfd *output_bfd ATTRIBUTE_UNUSED;
395
     struct bfd_link_info *info;
396
     bfd *input_bfd;
397
     asection *input_section;
398
     bfd_byte *contents;
399
     struct internal_reloc *relocs;
400
     struct internal_syment *syms;
401
     asection **sections;
402
{
403
  struct internal_reloc *rel;
404
  struct internal_reloc *relend;
405
 
406
  rel = relocs;
407
  relend = rel + input_section->reloc_count;
408
  for (; rel < relend; rel++)
409
    {
410
      long symndx;
411
      struct coff_link_hash_entry *h;
412
      struct internal_syment *sym;
413
      bfd_vma addend;
414
      bfd_vma val;
415
      reloc_howto_type *howto;
416
      bfd_reloc_status_type rstat = bfd_reloc_ok;
417
      bfd_boolean done;
418
 
419
      symndx = rel->r_symndx;
420
 
421
      if (symndx == -1)
422
        {
423
          h = NULL;
424
          sym = NULL;
425
        }
426
      else
427
        {
428
          h = obj_coff_sym_hashes (input_bfd)[symndx];
429
          sym = syms + symndx;
430
        }
431
 
432
      if (sym != NULL && sym->n_scnum != 0)
433
        addend = - sym->n_value;
434
      else
435
        addend = 0;
436
 
437
      switch (rel->r_type)
438
        {
439
        case 17: howto = &howto_rellong; break;
440
        case 25: howto = &howto_iprmed; break;
441
        case 27: howto = &howto_optcall; break;
442
        default:
443
          bfd_set_error (bfd_error_bad_value);
444
          return FALSE;
445
        }
446
 
447
      val = 0;
448
 
449
      if (h == NULL)
450
        {
451
          asection *sec;
452
 
453
          if (symndx == -1)
454
            {
455
              sec = bfd_abs_section_ptr;
456
              val = 0;
457
            }
458
          else
459
            {
460
              sec = sections[symndx];
461
              val = (sec->output_section->vma
462
                     + sec->output_offset
463
                     + sym->n_value
464
                     - sec->vma);
465
            }
466
        }
467
      else
468
        {
469
          if (h->root.type == bfd_link_hash_defined
470
              || h->root.type == bfd_link_hash_defweak)
471
            {
472
              asection *sec;
473
 
474
              sec = h->root.u.def.section;
475
              val = (h->root.u.def.value
476
                     + sec->output_section->vma
477
                     + sec->output_offset);
478
            }
479
          else if (! info->relocatable)
480
            {
481
              if (! ((*info->callbacks->undefined_symbol)
482
                     (info, h->root.root.string, input_bfd, input_section,
483
                      rel->r_vaddr - input_section->vma, TRUE)))
484
                return FALSE;
485
            }
486
        }
487
 
488
      done = FALSE;
489
 
490
      if (howto->type == R_OPTCALL && ! info->relocatable && symndx != -1)
491
        {
492
          int class_val;
493
 
494
          if (h != NULL)
495
            class_val = h->symbol_class;
496
          else
497
            class_val = sym->n_sclass;
498
 
499
          switch (class_val)
500
            {
501
            case C_NULL:
502
              /* This symbol is apparently not from a COFF input file.
503
                 We warn, and then assume that it is not a leaf
504
                 function.  */
505
              if (! ((*info->callbacks->reloc_dangerous)
506
                     (info,
507
                      _("uncertain calling convention for non-COFF symbol"),
508
                      input_bfd, input_section,
509
                      rel->r_vaddr - input_section->vma)))
510
                return FALSE;
511
              break;
512
            case C_LEAFSTAT:
513
            case C_LEAFEXT:
514
              /* This is a call to a leaf procedure; use the bal
515
                 instruction.  */
516
              {
517
                long olf;
518
                unsigned long word;
519
 
520
                if (h != NULL)
521
                  {
522
                    BFD_ASSERT (h->numaux == 2);
523
                    olf = h->aux[1].x_bal.x_balntry;
524
                  }
525
                else
526
                  {
527
                    bfd_byte *esyms;
528
                    union internal_auxent aux;
529
 
530
                    BFD_ASSERT (sym->n_numaux == 2);
531
                    esyms = (bfd_byte *) obj_coff_external_syms (input_bfd);
532
                    esyms += (symndx + 2) * bfd_coff_symesz (input_bfd);
533
                    bfd_coff_swap_aux_in (input_bfd, (PTR) esyms, sym->n_type,
534
                                          sym->n_sclass, 1, sym->n_numaux,
535
                                          (PTR) &aux);
536
                    olf = aux.x_bal.x_balntry;
537
                  }
538
 
539
                word = bfd_get_32 (input_bfd,
540
                                   (contents
541
                                    + (rel->r_vaddr - input_section->vma)));
542
                word = ((word + olf - val) & BAL_MASK) | BAL;
543
                bfd_put_32 (input_bfd,
544
                            (bfd_vma) word,
545
                            contents + (rel->r_vaddr - input_section->vma));
546
                done = TRUE;
547
              }
548
              break;
549
            case C_SCALL:
550
              BFD_ASSERT (0);
551
              break;
552
            }
553
        }
554
 
555
      if (! done)
556
        {
557
          if (howto->pc_relative)
558
            addend += input_section->vma;
559
          rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
560
                                            contents,
561
                                            rel->r_vaddr - input_section->vma,
562
                                            val, addend);
563
        }
564
 
565
      switch (rstat)
566
        {
567
        default:
568
          abort ();
569
        case bfd_reloc_ok:
570
          break;
571
        case bfd_reloc_overflow:
572
          {
573
            const char *name;
574
            char buf[SYMNMLEN + 1];
575
 
576
            if (symndx == -1)
577
              name = "*ABS*";
578
            else if (h != NULL)
579
              name = NULL;
580
            else
581
              {
582
                name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
583
                if (name == NULL)
584
                  return FALSE;
585
              }
586
 
587
            if (! ((*info->callbacks->reloc_overflow)
588
                   (info, (h ? &h->root : NULL), name, howto->name,
589
                    (bfd_vma) 0, input_bfd, input_section,
590
                    rel->r_vaddr - input_section->vma)))
591
              return FALSE;
592
          }
593
        }
594
    }
595
 
596
  return TRUE;
597
}
598
 
599
/* Adjust the symbol index of any reloc against a global symbol to
600
   instead be a reloc against the internal symbol we created specially
601
   for the section.  */
602
 
603
static bfd_boolean
604
coff_i960_adjust_symndx (obfd, info, ibfd, sec, irel, adjustedp)
605
     bfd *obfd ATTRIBUTE_UNUSED;
606
     struct bfd_link_info *info ATTRIBUTE_UNUSED;
607
     bfd *ibfd;
608
     asection *sec ATTRIBUTE_UNUSED;
609
     struct internal_reloc *irel;
610
     bfd_boolean *adjustedp;
611
{
612
  struct coff_link_hash_entry *h;
613
 
614
  *adjustedp = FALSE;
615
 
616
  h = obj_coff_sym_hashes (ibfd)[irel->r_symndx];
617
  if (h == NULL
618
      || (h->root.type != bfd_link_hash_defined
619
          && h->root.type != bfd_link_hash_defweak))
620
    return TRUE;
621
 
622
  irel->r_symndx = h->root.u.def.section->output_section->target_index - 1;
623
  *adjustedp = TRUE;
624
 
625
  return TRUE;
626
}
627
 
628
#define coff_bfd_is_local_label_name coff_i960_is_local_label_name
629
 
630
#define coff_start_final_link coff_i960_start_final_link
631
 
632
#define coff_relocate_section coff_i960_relocate_section
633
 
634
#define coff_adjust_symndx coff_i960_adjust_symndx
635
 
636
#define coff_bfd_reloc_type_lookup coff_i960_reloc_type_lookup
637
#define coff_bfd_reloc_name_lookup coff_i960_reloc_name_lookup
638
 
639
#include "coffcode.h"
640
 
641
extern const bfd_target icoff_big_vec;
642
 
643
CREATE_LITTLE_COFF_TARGET_VEC (icoff_little_vec, "coff-Intel-little", 0, 0, '_', & icoff_big_vec, COFF_SWAP_TABLE)
644
 
645
const bfd_target icoff_big_vec =
646
{
647
  "coff-Intel-big",             /* name */
648
  bfd_target_coff_flavour,
649
  BFD_ENDIAN_LITTLE,            /* data byte order is little */
650
  BFD_ENDIAN_BIG,               /* header byte order is big */
651
 
652
  (HAS_RELOC | EXEC_P |         /* object flags */
653
   HAS_LINENO | HAS_DEBUG |
654
   HAS_SYMS | HAS_LOCALS | WP_TEXT),
655
 
656
  (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
657
  '_',                          /* leading underscore */
658
  '/',                          /* ar_pad_char */
659
  15,                           /* ar_max_namelen */
660 148 khays
  0,                             /* match priority.  */
661 14 khays
 
662
bfd_getl64, bfd_getl_signed_64, bfd_putl64,
663
     bfd_getl32, bfd_getl_signed_32, bfd_putl32,
664
     bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
665
bfd_getb64, bfd_getb_signed_64, bfd_putb64,
666
     bfd_getb32, bfd_getb_signed_32, bfd_putb32,
667
     bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
668
 
669
  {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
670
     bfd_generic_archive_p, _bfd_dummy_target},
671
  {bfd_false, coff_mkobject,    /* bfd_set_format */
672
     _bfd_generic_mkarchive, bfd_false},
673
  {bfd_false, coff_write_object_contents,       /* bfd_write_contents */
674
     _bfd_write_archive_contents, bfd_false},
675
 
676
     BFD_JUMP_TABLE_GENERIC (coff),
677
     BFD_JUMP_TABLE_COPY (coff),
678
     BFD_JUMP_TABLE_CORE (_bfd_nocore),
679
     BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
680
     BFD_JUMP_TABLE_SYMBOLS (coff),
681
     BFD_JUMP_TABLE_RELOCS (coff),
682
     BFD_JUMP_TABLE_WRITE (coff),
683
     BFD_JUMP_TABLE_LINK (coff),
684
     BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
685
 
686
  & icoff_little_vec,
687
 
688
  COFF_SWAP_TABLE
689
};

powered by: WebSVN 2.1.0

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