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

Subversion Repositories open8_urisc

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

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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