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

Subversion Repositories or1k

[/] [or1k/] [branches/] [oc/] [gdb-5.0/] [bfd/] [coff-i386.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 104 markom
/* BFD back-end for Intel 386 COFF files.
2
   Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000
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
#include "bfd.h"
23
#include "sysdep.h"
24
#include "libbfd.h"
25
 
26
#include "coff/i386.h"
27
 
28
#include "coff/internal.h"
29
 
30
#ifdef COFF_WITH_PE
31
#include "coff/pe.h"
32
#endif
33
 
34
#ifdef COFF_GO32_EXE
35
#include "coff/go32exe.h"
36
#endif
37
 
38
#include "libcoff.h"
39
 
40
static bfd_reloc_status_type coff_i386_reloc
41
  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
42
static reloc_howto_type *coff_i386_rtype_to_howto
43
  PARAMS ((bfd *, asection *, struct internal_reloc *,
44
           struct coff_link_hash_entry *, struct internal_syment *,
45
           bfd_vma *));
46
static reloc_howto_type *coff_i386_reloc_type_lookup
47
  PARAMS ((bfd *, bfd_reloc_code_real_type));
48
 
49
#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (2)
50
/* The page size is a guess based on ELF.  */
51
 
52
#define COFF_PAGE_SIZE 0x1000
53
 
54
/* For some reason when using i386 COFF the value stored in the .text
55
   section for a reference to a common symbol is the value itself plus
56
   any desired offset.  Ian Taylor, Cygnus Support.  */
57
 
58
/* If we are producing relocateable output, we need to do some
59
   adjustments to the object file that are not done by the
60
   bfd_perform_relocation function.  This function is called by every
61
   reloc type to make any required adjustments.  */
62
 
63
static bfd_reloc_status_type
64
coff_i386_reloc (abfd, reloc_entry, symbol, data, input_section, output_bfd,
65
                 error_message)
66
     bfd *abfd;
67
     arelent *reloc_entry;
68
     asymbol *symbol;
69
     PTR data;
70
     asection *input_section ATTRIBUTE_UNUSED;
71
     bfd *output_bfd;
72
     char **error_message ATTRIBUTE_UNUSED;
73
{
74
  symvalue diff;
75
 
76
  if (output_bfd == (bfd *) NULL)
77
    return bfd_reloc_continue;
78
 
79
  if (bfd_is_com_section (symbol->section))
80
    {
81
#ifndef COFF_WITH_PE
82
      /* We are relocating a common symbol.  The current value in the
83
         object file is ORIG + OFFSET, where ORIG is the value of the
84
         common symbol as seen by the object file when it was compiled
85
         (this may be zero if the symbol was undefined) and OFFSET is
86
         the offset into the common symbol (normally zero, but may be
87
         non-zero when referring to a field in a common structure).
88
         ORIG is the negative of reloc_entry->addend, which is set by
89
         the CALC_ADDEND macro below.  We want to replace the value in
90
         the object file with NEW + OFFSET, where NEW is the value of
91
         the common symbol which we are going to put in the final
92
         object file.  NEW is symbol->value.  */
93
      diff = symbol->value + reloc_entry->addend;
94
#else
95
      /* In PE mode, we do not offset the common symbol.  */
96
      diff = reloc_entry->addend;
97
#endif
98
    }
99
  else
100
    {
101
      /* For some reason bfd_perform_relocation always effectively
102
         ignores the addend for a COFF target when producing
103
         relocateable output.  This seems to be always wrong for 386
104
         COFF, so we handle the addend here instead.  */
105
      diff = reloc_entry->addend;
106
    }
107
 
108
#ifdef COFF_WITH_PE
109
  /* FIXME: How should this case be handled?  */
110
  if (reloc_entry->howto->type == R_IMAGEBASE)
111
    diff -= pe_data (output_bfd)->pe_opthdr.ImageBase;
112
#endif
113
 
114
#define DOIT(x) \
115
  x = ((x & ~howto->dst_mask) | (((x & howto->src_mask) + diff) & howto->dst_mask))
116
 
117
    if (diff != 0)
118
      {
119
        reloc_howto_type *howto = reloc_entry->howto;
120
        unsigned char *addr = (unsigned char *) data + reloc_entry->address;
121
 
122
        switch (howto->size)
123
          {
124
          case 0:
125
            {
126
              char x = bfd_get_8 (abfd, addr);
127
              DOIT (x);
128
              bfd_put_8 (abfd, x, addr);
129
            }
130
            break;
131
 
132
          case 1:
133
            {
134
              short x = bfd_get_16 (abfd, addr);
135
              DOIT (x);
136
              bfd_put_16 (abfd, x, addr);
137
            }
138
            break;
139
 
140
          case 2:
141
            {
142
              long x = bfd_get_32 (abfd, addr);
143
              DOIT (x);
144
              bfd_put_32 (abfd, x, addr);
145
            }
146
            break;
147
 
148
          default:
149
            abort ();
150
          }
151
      }
152
 
153
  /* Now let bfd_perform_relocation finish everything up.  */
154
  return bfd_reloc_continue;
155
}
156
 
157
#ifdef COFF_WITH_PE
158
 
159
/* Return true if this relocation should appear in the output .reloc
160
   section.  */
161
 
162
static boolean in_reloc_p PARAMS ((bfd *, reloc_howto_type *));
163
 
164
static boolean in_reloc_p (abfd, howto)
165
     bfd *abfd ATTRIBUTE_UNUSED;
166
     reloc_howto_type *howto;
167
{
168
  return ! howto->pc_relative && howto->type != R_IMAGEBASE;
169
}
170
 
171
#endif /* COFF_WITH_PE */
172
 
173
#ifndef PCRELOFFSET
174
#define PCRELOFFSET false
175
#endif
176
 
177
static reloc_howto_type howto_table[] =
178
{
179
  EMPTY_HOWTO (0),
180
  EMPTY_HOWTO (1),
181
  EMPTY_HOWTO (2),
182
  EMPTY_HOWTO (3),
183
  EMPTY_HOWTO (4),
184
  EMPTY_HOWTO (5),
185
  HOWTO (R_DIR32,               /* type */
186
         0,                      /* rightshift */
187
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
188
         32,                    /* bitsize */
189
         false,                 /* pc_relative */
190
         0,                      /* bitpos */
191
         complain_overflow_bitfield, /* complain_on_overflow */
192
         coff_i386_reloc,       /* special_function */
193
         "dir32",               /* name */
194
         true,                  /* partial_inplace */
195
         0xffffffff,            /* src_mask */
196
         0xffffffff,            /* dst_mask */
197
         true),                 /* pcrel_offset */
198
  /* PE IMAGE_REL_I386_DIR32NB relocation (7).  */
199
  HOWTO (R_IMAGEBASE,           /* type */
200
         0,                      /* rightshift */
201
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
202
         32,                    /* bitsize */
203
         false,                 /* pc_relative */
204
         0,                      /* bitpos */
205
         complain_overflow_bitfield, /* complain_on_overflow */
206
         coff_i386_reloc,       /* special_function */
207
         "rva32",               /* name */
208
         true,                  /* partial_inplace */
209
         0xffffffff,            /* src_mask */
210
         0xffffffff,            /* dst_mask */
211
         false),                /* pcrel_offset */
212
  EMPTY_HOWTO (010),
213
  EMPTY_HOWTO (011),
214
  EMPTY_HOWTO (012),
215
  EMPTY_HOWTO (013),
216
  EMPTY_HOWTO (014),
217
  EMPTY_HOWTO (015),
218
  EMPTY_HOWTO (016),
219
  /* Byte relocation (017).  */
220
  HOWTO (R_RELBYTE,             /* type */
221
         0,                      /* rightshift */
222
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
223
         8,                     /* bitsize */
224
         false,                 /* pc_relative */
225
         0,                      /* bitpos */
226
         complain_overflow_bitfield, /* complain_on_overflow */
227
         coff_i386_reloc,       /* special_function */
228
         "8",                   /* name */
229
         true,                  /* partial_inplace */
230
         0x000000ff,            /* src_mask */
231
         0x000000ff,            /* dst_mask */
232
         PCRELOFFSET),          /* pcrel_offset */
233
  /* 16-bit word relocation (020).  */
234
  HOWTO (R_RELWORD,             /* type */
235
         0,                      /* rightshift */
236
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
237
         16,                    /* bitsize */
238
         false,                 /* pc_relative */
239
         0,                      /* bitpos */
240
         complain_overflow_bitfield, /* complain_on_overflow */
241
         coff_i386_reloc,       /* special_function */
242
         "16",                  /* name */
243
         true,                  /* partial_inplace */
244
         0x0000ffff,            /* src_mask */
245
         0x0000ffff,            /* dst_mask */
246
         PCRELOFFSET),          /* pcrel_offset */
247
  /* 32-bit longword relocation (021).  */
248
  HOWTO (R_RELLONG,             /* type */
249
         0,                      /* rightshift */
250
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
251
         32,                    /* bitsize */
252
         false,                 /* pc_relative */
253
         0,                      /* bitpos */
254
         complain_overflow_bitfield, /* complain_on_overflow */
255
         coff_i386_reloc,       /* special_function */
256
         "32",                  /* name */
257
         true,                  /* partial_inplace */
258
         0xffffffff,            /* src_mask */
259
         0xffffffff,            /* dst_mask */
260
         PCRELOFFSET),          /* pcrel_offset */
261
  /* Byte PC relative relocation (022).  */
262
  HOWTO (R_PCRBYTE,             /* type */
263
         0,                      /* rightshift */
264
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
265
         8,                     /* bitsize */
266
         true,                  /* pc_relative */
267
         0,                      /* bitpos */
268
         complain_overflow_signed, /* complain_on_overflow */
269
         coff_i386_reloc,       /* special_function */
270
         "DISP8",               /* name */
271
         true,                  /* partial_inplace */
272
         0x000000ff,            /* src_mask */
273
         0x000000ff,            /* dst_mask */
274
         PCRELOFFSET),          /* pcrel_offset */
275
  /* 16-bit word PC relative relocation (023).  */
276
  HOWTO (R_PCRWORD,             /* type */
277
         0,                      /* rightshift */
278
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
279
         16,                    /* bitsize */
280
         true,                  /* pc_relative */
281
         0,                      /* bitpos */
282
         complain_overflow_signed, /* complain_on_overflow */
283
         coff_i386_reloc,       /* special_function */
284
         "DISP16",              /* name */
285
         true,                  /* partial_inplace */
286
         0x0000ffff,            /* src_mask */
287
         0x0000ffff,            /* dst_mask */
288
         PCRELOFFSET),          /* pcrel_offset */
289
  /* 32-bit longword PC relative relocation (024).  */
290
  HOWTO (R_PCRLONG,             /* type */
291
         0,                      /* rightshift */
292
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
293
         32,                    /* bitsize */
294
         true,                  /* pc_relative */
295
         0,                      /* bitpos */
296
         complain_overflow_signed, /* complain_on_overflow */
297
         coff_i386_reloc,       /* special_function */
298
         "DISP32",              /* name */
299
         true,                  /* partial_inplace */
300
         0xffffffff,            /* src_mask */
301
         0xffffffff,            /* dst_mask */
302
         PCRELOFFSET)           /* pcrel_offset */
303
};
304
 
305
/* Turn a howto into a reloc  nunmber */
306
 
307
#define SELECT_RELOC(x,howto) { x.r_type = howto->type; }
308
#define BADMAG(x) I386BADMAG(x)
309
#define I386 1                  /* Customize coffcode.h */
310
 
311
#define RTYPE2HOWTO(cache_ptr, dst)                                     \
312
  ((cache_ptr)->howto =                                                 \
313
   ((dst)->r_type < sizeof (howto_table) / sizeof (howto_table[0])       \
314
    ? howto_table + (dst)->r_type                                       \
315
    : NULL))
316
 
317
/* For 386 COFF a STYP_NOLOAD | STYP_BSS section is part of a shared
318
   library.  On some other COFF targets STYP_BSS is normally
319
   STYP_NOLOAD.  */
320
#define BSS_NOLOAD_IS_SHARED_LIBRARY
321
 
322
/* Compute the addend of a reloc.  If the reloc is to a common symbol,
323
   the object file contains the value of the common symbol.  By the
324
   time this is called, the linker may be using a different symbol
325
   from a different object file with a different value.  Therefore, we
326
   hack wildly to locate the original symbol from this file so that we
327
   can make the correct adjustment.  This macro sets coffsym to the
328
   symbol from the original file, and uses it to set the addend value
329
   correctly.  If this is not a common symbol, the usual addend
330
   calculation is done, except that an additional tweak is needed for
331
   PC relative relocs.
332
   FIXME: This macro refers to symbols and asect; these are from the
333
   calling function, not the macro arguments.  */
334
 
335
#define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)                \
336
  {                                                             \
337
    coff_symbol_type *coffsym = (coff_symbol_type *) NULL;      \
338
    if (ptr && bfd_asymbol_bfd (ptr) != abfd)                   \
339
      coffsym = (obj_symbols (abfd)                             \
340
                 + (cache_ptr->sym_ptr_ptr - symbols));         \
341
    else if (ptr)                                               \
342
      coffsym = coff_symbol_from (abfd, ptr);                   \
343
    if (coffsym != (coff_symbol_type *) NULL                    \
344
        && coffsym->native->u.syment.n_scnum == 0)               \
345
      cache_ptr->addend = - coffsym->native->u.syment.n_value;  \
346
    else if (ptr && bfd_asymbol_bfd (ptr) == abfd               \
347
             && ptr->section != (asection *) NULL)              \
348
      cache_ptr->addend = - (ptr->section->vma + ptr->value);   \
349
    else                                                        \
350
      cache_ptr->addend = 0;                                     \
351
    if (ptr && howto_table[reloc.r_type].pc_relative)           \
352
      cache_ptr->addend += asect->vma;                          \
353
  }
354
 
355
/* We use the special COFF backend linker.  For normal i386 COFF, we
356
   can use the generic relocate_section routine.  For PE, we need our
357
   own routine.  */
358
 
359
#ifndef COFF_WITH_PE
360
 
361
#define coff_relocate_section _bfd_coff_generic_relocate_section
362
 
363
#else /* COFF_WITH_PE */
364
 
365
/* The PE relocate section routine.  The only difference between this
366
   and the regular routine is that we don't want to do anything for a
367
   relocateable link.  */
368
 
369
static boolean coff_pe_i386_relocate_section
370
  PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
371
           struct internal_reloc *, struct internal_syment *, asection **));
372
 
373
static boolean
374
coff_pe_i386_relocate_section (output_bfd, info, input_bfd,
375
                               input_section, contents, relocs, syms,
376
                               sections)
377
     bfd *output_bfd;
378
     struct bfd_link_info *info;
379
     bfd *input_bfd;
380
     asection *input_section;
381
     bfd_byte *contents;
382
     struct internal_reloc *relocs;
383
     struct internal_syment *syms;
384
     asection **sections;
385
{
386
  if (info->relocateable)
387
    return true;
388
 
389
  return _bfd_coff_generic_relocate_section (output_bfd, info, input_bfd,
390
                                             input_section, contents,
391
                                             relocs, syms, sections);
392
}
393
 
394
#define coff_relocate_section coff_pe_i386_relocate_section
395
 
396
#endif /* COFF_WITH_PE */
397
 
398
/* Convert an rtype to howto for the COFF backend linker.  */
399
 
400
static reloc_howto_type *
401
coff_i386_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
402
     bfd *abfd ATTRIBUTE_UNUSED;
403
     asection *sec;
404
     struct internal_reloc *rel;
405
     struct coff_link_hash_entry *h;
406
     struct internal_syment *sym;
407
     bfd_vma *addendp;
408
{
409
  reloc_howto_type *howto;
410
 
411
  if (rel->r_type > sizeof (howto_table) / sizeof (howto_table[0]))
412
    {
413
      bfd_set_error (bfd_error_bad_value);
414
      return NULL;
415
    }
416
 
417
  howto = howto_table + rel->r_type;
418
 
419
#ifdef COFF_WITH_PE
420
  /* Cancel out code in _bfd_coff_generic_relocate_section.  */
421
  *addendp = 0;
422
#endif
423
 
424
  if (howto->pc_relative)
425
    *addendp += sec->vma;
426
 
427
  if (sym != NULL && sym->n_scnum == 0 && sym->n_value != 0)
428
    {
429
      /* This is a common symbol.  The section contents include the
430
         size (sym->n_value) as an addend.  The relocate_section
431
         function will be adding in the final value of the symbol.  We
432
         need to subtract out the current size in order to get the
433
         correct result.  */
434
 
435
      BFD_ASSERT (h != NULL);
436
 
437
#ifndef COFF_WITH_PE
438
      /* I think we *do* want to bypass this.  If we don't, I have
439
         seen some data parameters get the wrong relocation address.
440
         If I link two versions with and without this section bypassed
441
         and then do a binary comparison, the addresses which are
442
         different can be looked up in the map.  The case in which
443
         this section has been bypassed has addresses which correspond
444
         to values I can find in the map.  */
445
      *addendp -= sym->n_value;
446
#endif
447
    }
448
 
449
#ifndef COFF_WITH_PE
450
  /* If the output symbol is common (in which case this must be a
451
     relocateable link), we need to add in the final size of the
452
     common symbol.  */
453
  if (h != NULL && h->root.type == bfd_link_hash_common)
454
    *addendp += h->root.u.c.size;
455
#endif
456
 
457
#ifdef COFF_WITH_PE
458
  if (howto->pc_relative)
459
    {
460
      *addendp -= 4;
461
 
462
      /* If the symbol is defined, then the generic code is going to
463
         add back the symbol value in order to cancel out an
464
         adjustment it made to the addend.  However, we set the addend
465
         to 0 at the start of this function.  We need to adjust here,
466
         to avoid the adjustment the generic code will make.  FIXME:
467
         This is getting a bit hackish.  */
468
      if (sym != NULL && sym->n_scnum != 0)
469
        *addendp -= sym->n_value;
470
    }
471
 
472
  if (rel->r_type == R_IMAGEBASE)
473
    {
474
      *addendp -= pe_data(sec->output_section->owner)->pe_opthdr.ImageBase;
475
    }
476
#endif
477
 
478
  return howto;
479
}
480
 
481
#define coff_bfd_reloc_type_lookup coff_i386_reloc_type_lookup
482
 
483
static reloc_howto_type *
484
coff_i386_reloc_type_lookup (abfd, code)
485
     bfd *abfd ATTRIBUTE_UNUSED;
486
     bfd_reloc_code_real_type code;
487
{
488
  switch (code)
489
    {
490
    case BFD_RELOC_RVA:
491
      return howto_table + R_IMAGEBASE;
492
    case BFD_RELOC_32:
493
      return howto_table + R_DIR32;
494
    case BFD_RELOC_32_PCREL:
495
      return howto_table + R_PCRLONG;
496
    case BFD_RELOC_16:
497
      return howto_table + R_RELWORD;
498
    case BFD_RELOC_16_PCREL:
499
      return howto_table + R_PCRWORD;
500
    case BFD_RELOC_8:
501
      return howto_table + R_RELBYTE;
502
    case BFD_RELOC_8_PCREL:
503
      return howto_table + R_PCRBYTE;
504
    default:
505
      BFD_FAIL ();
506
      return 0;
507
    }
508
}
509
 
510
#define coff_rtype_to_howto coff_i386_rtype_to_howto
511
 
512
#ifdef TARGET_UNDERSCORE
513
 
514
/* If i386 gcc uses underscores for symbol names, then it does not use
515
   a leading dot for local labels, so if TARGET_UNDERSCORE is defined
516
   we treat all symbols starting with L as local.  */
517
 
518
static boolean coff_i386_is_local_label_name PARAMS ((bfd *, const char *));
519
 
520
static boolean
521
coff_i386_is_local_label_name (abfd, name)
522
     bfd *abfd;
523
     const char *name;
524
{
525
  if (name[0] == 'L')
526
    return true;
527
 
528
  return _bfd_coff_is_local_label_name (abfd, name);
529
}
530
 
531
#define coff_bfd_is_local_label_name coff_i386_is_local_label_name
532
 
533
#endif /* TARGET_UNDERSCORE */
534
 
535
#include "coffcode.h"
536
 
537
const bfd_target
538
#ifdef TARGET_SYM
539
  TARGET_SYM =
540
#else
541
  i386coff_vec =
542
#endif
543
{
544
#ifdef TARGET_NAME
545
  TARGET_NAME,
546
#else
547
  "coff-i386",                  /* name */
548
#endif
549
  bfd_target_coff_flavour,
550
  BFD_ENDIAN_LITTLE,            /* data byte order is little */
551
  BFD_ENDIAN_LITTLE,            /* header byte order is little */
552
 
553
  (HAS_RELOC | EXEC_P |         /* object flags */
554
   HAS_LINENO | HAS_DEBUG |
555
   HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
556
 
557
  (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC /* section flags */
558
#ifdef COFF_WITH_PE
559
   | SEC_LINK_ONCE | SEC_LINK_DUPLICATES
560
#endif
561
   | SEC_CODE | SEC_DATA),
562
 
563
#ifdef TARGET_UNDERSCORE
564
  TARGET_UNDERSCORE,            /* leading underscore */
565
#else
566
  0,                             /* leading underscore */
567
#endif
568
  '/',                          /* ar_pad_char */
569
  15,                           /* ar_max_namelen */
570
 
571
  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
572
     bfd_getl32, bfd_getl_signed_32, bfd_putl32,
573
     bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
574
  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
575
     bfd_getl32, bfd_getl_signed_32, bfd_putl32,
576
     bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
577
 
578
/* Note that we allow an object file to be treated as a core file as well. */
579
    {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
580
       bfd_generic_archive_p, coff_object_p},
581
    {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
582
       bfd_false},
583
    {bfd_false, coff_write_object_contents, /* bfd_write_contents */
584
       _bfd_write_archive_contents, bfd_false},
585
 
586
     BFD_JUMP_TABLE_GENERIC (coff),
587
     BFD_JUMP_TABLE_COPY (coff),
588
     BFD_JUMP_TABLE_CORE (_bfd_nocore),
589
     BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
590
     BFD_JUMP_TABLE_SYMBOLS (coff),
591
     BFD_JUMP_TABLE_RELOCS (coff),
592
     BFD_JUMP_TABLE_WRITE (coff),
593
     BFD_JUMP_TABLE_LINK (coff),
594
     BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
595
 
596
  NULL,
597
 
598
  COFF_SWAP_TABLE
599
};

powered by: WebSVN 2.1.0

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