bfd/coff-i386.c

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