bfd/coff-i386.c

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