bfd/coff-i386.c

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