bfd/coff-i960.c

   1 /* BFD back-end for Intel 960 COFF files.
   2    Copyright (C) 1990, 91, 92, 93, 94, 1995 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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #define I960 1
  22 #define BADMAG(x) I960BADMAG(x)
  23
  24 #include "bfd.h"
  25 #include "sysdep.h"
  26 #include "libbfd.h"
  27 #include "obstack.h"
  28 #include "coff/i960.h"
  29 #include "coff/internal.h"
  30 #include "libcoff.h"            /* to allow easier abstraction-breaking */
  31
  32 static bfd_reloc_status_type optcall_callback
  33   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  34 static bfd_reloc_status_type coff_i960_relocate
  35   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  36 static reloc_howto_type *coff_i960_reloc_type_lookup
  37   PARAMS ((bfd *, bfd_reloc_code_real_type));
  38 static boolean coff_i960_start_final_link
  39   PARAMS ((bfd *, struct bfd_link_info *));
  40 static boolean coff_i960_relocate_section
  41   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
  42            struct internal_reloc *, struct internal_syment *, asection **));
  43 static boolean coff_i960_adjust_symndx
  44   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *,
  45            struct internal_reloc *, boolean *));
  46
  47 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (3)
  48
  49 /* The i960 does not support an MMU, so COFF_PAGE_SIZE can be
  50    arbitrarily small.  */
  51 #define COFF_PAGE_SIZE 1
  52
  53 #define COFF_LONG_FILENAMES
  54
  55 #define CALLS    0x66003800     /* Template for 'calls' instruction     */
  56 #define BAL      0x0b000000     /* Template for 'bal' instruction       */
  57 #define BAL_MASK 0x00ffffff
  58
  59 static bfd_reloc_status_type
  60 optcall_callback (abfd, reloc_entry, symbol_in, data,
  61                   input_section, ignore_bfd, error_message)
  62      bfd *abfd;
  63      arelent *reloc_entry;
  64      asymbol *symbol_in;
  65      PTR data;
  66      asection *input_section;
  67      bfd *ignore_bfd;
  68      char **error_message;
  69 {
  70   /* This item has already been relocated correctly, but we may be
  71    * able to patch in yet better code - done by digging out the
  72    * correct info on this symbol */
  73   bfd_reloc_status_type result;
  74   coff_symbol_type *cs = coffsymbol(symbol_in);
  75
  76   /* Don't do anything with symbols which aren't tied up yet,
  77      except move the reloc. */
  78   if (bfd_is_und_section (cs->symbol.section)) {
  79     reloc_entry->address += input_section->output_offset;
  80     return bfd_reloc_ok;
  81   }
  82
  83   /* So the target symbol has to be of coff type, and the symbol
  84      has to have the correct native information within it */
  85   if ((bfd_asymbol_flavour(&cs->symbol) != bfd_target_coff_flavour)
  86       || (cs->native == (combined_entry_type *)NULL))
  87     {
  88       /* This is interesting, consider the case where we're outputting coff
  89          from a mix n match input, linking from coff to a symbol defined in a
  90          bout file will cause this match to be true. Should I complain?  This
  91          will only work if the bout symbol is non leaf.  */
  92       *error_message =
  93         (char *) "uncertain calling convention for non-COFF symbol";
  94       result = bfd_reloc_dangerous;
  95     }
  96   else
  97     {
  98     switch (cs->native->u.syment.n_sclass)
  99       {
 100       case C_LEAFSTAT:
 101       case C_LEAFEXT:
 102         /* This is a call to a leaf procedure, replace instruction with a bal
 103            to the correct location.  */
 104         {
 105           union internal_auxent *aux = &((cs->native+2)->u.auxent);
 106           int word = bfd_get_32(abfd, (bfd_byte *)data + reloc_entry->address);
 107           int olf = (aux->x_bal.x_balntry - cs->native->u.syment.n_value);
 108           BFD_ASSERT(cs->native->u.syment.n_numaux==2);
 109
 110           /* We replace the original call instruction with a bal to
 111              the bal entry point - the offset of which is described in
 112              the 2nd auxent of the original symbol. We keep the native
 113              sym and auxents untouched, so the delta between the two
 114              is the offset of the bal entry point.  */
 115           word = ((word +  olf)  & BAL_MASK) | BAL;
 116           bfd_put_32(abfd, word, (bfd_byte *) data + reloc_entry->address);
 117         }
 118         result = bfd_reloc_ok;
 119         break;
 120       case C_SCALL:
 121         /* This is a call to a system call, replace with a calls to # */
 122         BFD_ASSERT(0);
 123         result = bfd_reloc_ok;
 124         break;
 125       default:
 126         result = bfd_reloc_ok;
 127         break;
 128       }
 129   }
 130   return result;
 131 }
 132
 133 /* i960 COFF is used by VxWorks 5.1.  However, VxWorks 5.1 does not
 134    appear to correctly handle a reloc against a symbol defined in the
 135    same object file.  It appears to simply discard such relocs, rather
 136    than adding their values into the object file.  We handle this here
 137    by converting all relocs against defined symbols into relocs
 138    against the section symbol, when generating a relocateable output
 139    file.
 140
 141    Note that this function is only called if we are not using the COFF
 142    specific backend linker.  It only does something when doing a
 143    relocateable link, which will almost certainly fail when not
 144    generating COFF i960 output, so this function is actually no longer
 145    useful.  It was used before this target was converted to use the
 146    COFF specific backend linker.  */
 147
 148 static bfd_reloc_status_type
 149 coff_i960_relocate (abfd, reloc_entry, symbol, data, input_section,
 150                     output_bfd, error_message)
 151      bfd *abfd;
 152      arelent *reloc_entry;
 153      asymbol *symbol;
 154      PTR data;
 155      asection *input_section;
 156      bfd *output_bfd;
 157      char **error_message;
 158 {
 159   asection *osec;
 160
 161   if (output_bfd == NULL)
 162     {
 163       /* Not generating relocateable output file.  */
 164       return bfd_reloc_continue;
 165     }
 166
 167   if (bfd_is_und_section (bfd_get_section (symbol)))
 168     {
 169       /* Symbol is not defined, so no need to worry about it.  */
 170       return bfd_reloc_continue;
 171     }
 172
 173   if (bfd_is_com_section (bfd_get_section (symbol)))
 174     {
 175       /* I don't really know what the right action is for a common
 176          symbol.  */
 177       return bfd_reloc_continue;
 178     }
 179
 180   /* Convert the reloc to use the section symbol.  FIXME: This method
 181      is ridiculous.  */
 182   osec = bfd_get_section (symbol)->output_section;
 183   if (coff_section_data (output_bfd, osec) != NULL
 184       && coff_section_data (output_bfd, osec)->tdata != NULL)
 185     reloc_entry->sym_ptr_ptr =
 186       (asymbol **) coff_section_data (output_bfd, osec)->tdata;
 187   else
 188     {
 189       const char *sec_name;
 190       asymbol **syms, **sym_end;
 191
 192       sec_name = bfd_get_section_name (output_bfd, osec);
 193       syms = bfd_get_outsymbols (output_bfd);
 194       sym_end = syms + bfd_get_symcount (output_bfd);
 195       for (; syms < sym_end; syms++)
 196         {
 197           if (bfd_asymbol_name (*syms) != NULL
 198               && (*syms)->value == 0
 199               && strcmp ((*syms)->section->output_section->name,
 200                          sec_name) == 0)
 201             break;
 202         }
 203
 204       if (syms >= sym_end)
 205         abort ();
 206
 207       reloc_entry->sym_ptr_ptr = syms;
 208
 209       if (coff_section_data (output_bfd, osec) == NULL)
 210         {
 211           osec->used_by_bfd =
 212             ((PTR) bfd_zalloc (abfd,
 213                                sizeof (struct coff_section_tdata)));
 214           if (osec->used_by_bfd == NULL)
 215             return bfd_reloc_overflow;
 216         }
 217       coff_section_data (output_bfd, osec)->tdata = (PTR) syms;
 218     }
 219
 220   /* Let bfd_perform_relocation do its thing, which will include
 221      stuffing the symbol addend into the object file.  */
 222   return bfd_reloc_continue;
 223 }
 224
 225 static reloc_howto_type howto_rellong =
 226   HOWTO ((unsigned int) R_RELLONG, 0, 2, 32,false, 0,
 227          complain_overflow_bitfield, coff_i960_relocate,"rellong", true,
 228          0xffffffff, 0xffffffff, 0);
 229 static reloc_howto_type howto_iprmed =
 230   HOWTO (R_IPRMED, 0, 2, 24,true,0, complain_overflow_signed,
 231          coff_i960_relocate, "iprmed ", true, 0x00ffffff, 0x00ffffff, 0);
 232 static reloc_howto_type howto_optcall =
 233   HOWTO (R_OPTCALL, 0,2,24,true,0, complain_overflow_signed,
 234          optcall_callback, "optcall", true, 0x00ffffff, 0x00ffffff, 0);
 235
 236 static reloc_howto_type *
 237 coff_i960_reloc_type_lookup (abfd, code)
 238      bfd *abfd;
 239      bfd_reloc_code_real_type code;
 240 {
 241   switch (code)
 242     {
 243     default:
 244       return 0;
 245     case BFD_RELOC_I960_CALLJ:
 246       return &howto_optcall;
 247     case BFD_RELOC_32:
 248     case BFD_RELOC_CTOR:
 249       return &howto_rellong;
 250     case BFD_RELOC_24_PCREL:
 251       return &howto_iprmed;
 252     }
 253 }
 254
 255 /* The real code is in coffcode.h */
 256
 257 #define RTYPE2HOWTO(cache_ptr, dst) \
 258 {                                                       \
 259    reloc_howto_type *howto_ptr;                         \
 260    switch ((dst)->r_type) {                             \
 261      case 17: howto_ptr = &howto_rellong; break;        \
 262      case 25: howto_ptr = &howto_iprmed; break;         \
 263      case 27: howto_ptr = &howto_optcall; break;        \
 264      default: howto_ptr = 0; break;                     \
 265      }                                                  \
 266    (cache_ptr)->howto = howto_ptr;                      \
 267  }
 268
 269 /* i960 COFF is used by VxWorks 5.1.  However, VxWorks 5.1 does not
 270    appear to correctly handle a reloc against a symbol defined in the
 271    same object file.  It appears to simply discard such relocs, rather
 272    than adding their values into the object file.  We handle this by
 273    converting all relocs against global symbols into relocs against
 274    internal symbols at the start of the section.  This routine is
 275    called at the start of the linking process, and it creates the
 276    necessary symbols.  */
 277
 278 static boolean
 279 coff_i960_start_final_link (abfd, info)
 280      bfd *abfd;
 281      struct bfd_link_info *info;
 282 {
 283   bfd_size_type symesz = bfd_coff_symesz (abfd);
 284   asection *o;
 285   bfd_byte *esym;
 286
 287   if (! info->relocateable)
 288     return true;
 289
 290   esym = (bfd_byte *) malloc (symesz);
 291   if (esym == NULL)
 292     {
 293       bfd_set_error (bfd_error_no_memory);
 294       return false;
 295     }
 296
 297   if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0)
 298     return false;
 299
 300   for (o = abfd->sections; o != NULL; o = o->next)
 301     {
 302       struct internal_syment isym;
 303
 304       strncpy (isym._n._n_name, o->name, SYMNMLEN);
 305       isym.n_value = 0;
 306       isym.n_scnum = o->target_index;
 307       isym.n_type = T_NULL;
 308       isym.n_sclass = C_STAT;
 309       isym.n_numaux = 0;
 310
 311       bfd_coff_swap_sym_out (abfd, (PTR) &isym, (PTR) esym);
 312
 313       if (bfd_write (esym, symesz, 1, abfd) != symesz)
 314         {
 315           free (esym);
 316           return false;
 317         }
 318
 319       obj_raw_syment_count (abfd) += 1;
 320     }
 321
 322   free (esym);
 323
 324   return true;
 325 }
 326
 327 /* The reloc processing routine for the optimized COFF linker.  */
 328
 329 static boolean
 330 coff_i960_relocate_section (output_bfd, info, input_bfd, input_section,
 331                             contents, relocs, syms, sections)
 332      bfd *output_bfd;
 333      struct bfd_link_info *info;
 334      bfd *input_bfd;
 335      asection *input_section;
 336      bfd_byte *contents;
 337      struct internal_reloc *relocs;
 338      struct internal_syment *syms;
 339      asection **sections;
 340 {
 341   struct internal_reloc *rel;
 342   struct internal_reloc *relend;
 343
 344   rel = relocs;
 345   relend = rel + input_section->reloc_count;
 346   for (; rel < relend; rel++)
 347     {
 348       long symndx;
 349       struct coff_link_hash_entry *h;
 350       struct internal_syment *sym;
 351       bfd_vma addend;
 352       bfd_vma val;
 353       reloc_howto_type *howto;
 354       bfd_reloc_status_type rstat = bfd_reloc_ok;
 355       boolean done;
 356
 357       symndx = rel->r_symndx;
 358
 359       if (symndx == -1)
 360         {
 361           h = NULL;
 362           sym = NULL;
 363         }
 364       else
 365         {
 366           h = obj_coff_sym_hashes (input_bfd)[symndx];
 367           sym = syms + symndx;
 368         }
 369
 370       if (sym != NULL && sym->n_scnum != 0)
 371         addend = - sym->n_value;
 372       else
 373         addend = 0;
 374
 375       switch (rel->r_type)
 376         {
 377         case 17: howto = &howto_rellong; break;
 378         case 25: howto = &howto_iprmed; break;
 379         case 27: howto = &howto_optcall; break;
 380         default:
 381           bfd_set_error (bfd_error_bad_value);
 382           return false;
 383         }
 384
 385       val = 0;
 386
 387       if (h == NULL)
 388         {
 389           asection *sec;
 390
 391           if (symndx == -1)
 392             {
 393               sec = bfd_abs_section_ptr;
 394               val = 0;
 395             }
 396           else
 397             {
 398               sec = sections[symndx];
 399               val = (sec->output_section->vma
 400                      + sec->output_offset
 401                      + sym->n_value
 402                      - sec->vma);
 403             }
 404         }
 405       else
 406         {
 407           if (h->root.type == bfd_link_hash_defined
 408               || h->root.type == bfd_link_hash_defweak)
 409             {
 410               asection *sec;
 411
 412               sec = h->root.u.def.section;
 413               val = (h->root.u.def.value
 414                      + sec->output_section->vma
 415                      + sec->output_offset);
 416             }
 417           else if (! info->relocateable)
 418             {
 419               if (! ((*info->callbacks->undefined_symbol)
 420                      (info, h->root.root.string, input_bfd, input_section,
 421                       rel->r_vaddr - input_section->vma)))
 422                 return false;
 423             }
 424         }
 425
 426       done = false;
 427
 428       if (howto->type == R_OPTCALL && ! info->relocateable && symndx != -1)
 429         {
 430           int class;
 431
 432           if (h != NULL)
 433             class = h->class;
 434           else
 435             class = sym->n_sclass;
 436
 437           switch (class)
 438             {
 439             case C_NULL:
 440               /* This symbol is apparently not from a COFF input file.
 441                  We warn, and then assume that it is not a leaf
 442                  function.  */
 443               if (! ((*info->callbacks->reloc_dangerous)
 444                      (info,
 445                       "uncertain calling convention for non-COFF symbol",
 446                       input_bfd, input_section,
 447                       rel->r_vaddr - input_section->vma)))
 448                 return false;
 449               break;
 450             case C_LEAFSTAT:
 451             case C_LEAFEXT:
 452               /* This is a call to a leaf procedure; use the bal
 453                  instruction.  */
 454               {
 455                 long olf;
 456                 unsigned long word;
 457
 458                 if (h != NULL)
 459                   {
 460                     BFD_ASSERT (h->numaux == 2);
 461                     olf = h->aux[1].x_bal.x_balntry;
 462                   }
 463                 else
 464                   {
 465                     bfd_byte *esyms;
 466                     union internal_auxent aux;
 467
 468                     BFD_ASSERT (sym->n_numaux == 2);
 469                     esyms = (bfd_byte *) obj_coff_external_syms (input_bfd);
 470                     esyms += (symndx + 2) * bfd_coff_symesz (input_bfd);
 471                     bfd_coff_swap_aux_in (input_bfd, (PTR) esyms, sym->n_type,
 472                                           sym->n_sclass, 1, sym->n_numaux,
 473                                           (PTR) &aux);
 474                     olf = aux.x_bal.x_balntry;
 475                   }
 476
 477                 word = bfd_get_32 (input_bfd,
 478                                    (contents
 479                                     + (rel->r_vaddr - input_section->vma)));
 480                 word = ((word + olf - val) & BAL_MASK) | BAL;
 481                 bfd_put_32 (input_bfd,
 482                             word,
 483                             (contents
 484                              + (rel->r_vaddr - input_section->vma)));
 485                 done = true;
 486               }
 487               break;
 488             case C_SCALL:
 489               BFD_ASSERT (0);
 490               break;
 491             }
 492         }
 493
 494       if (! done)
 495         rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
 496                                           contents,
 497                                           rel->r_vaddr - input_section->vma,
 498                                           val, addend);
 499
 500       switch (rstat)
 501         {
 502         default:
 503           abort ();
 504         case bfd_reloc_ok:
 505           break;
 506         case bfd_reloc_overflow:
 507           {
 508             const char *name;
 509             char buf[SYMNMLEN + 1];
 510
 511             if (symndx == -1)
 512               name = "*ABS*";
 513             else if (h != NULL)
 514               name = h->root.root.string;
 515             else
 516               {
 517                 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
 518                 if (name == NULL)
 519                   return false;
 520               }
 521
 522             if (! ((*info->callbacks->reloc_overflow)
 523                    (info, name, howto->name, (bfd_vma) 0, input_bfd,
 524                     input_section, rel->r_vaddr - input_section->vma)))
 525               return false;
 526           }
 527         }
 528     }
 529
 530   return true;
 531 }
 532
 533 /* Adjust the symbol index of any reloc against a global symbol to
 534    instead be a reloc against the internal symbol we created specially
 535    for the section.  */
 536
 537 /*ARGSUSED*/
 538 static boolean
 539 coff_i960_adjust_symndx (obfd, info, ibfd, sec, irel, adjustedp)
 540      bfd *obfd;
 541      struct bfd_link_info *info;
 542      bfd *ibfd;
 543      asection *sec;
 544      struct internal_reloc *irel;
 545      boolean *adjustedp;
 546 {
 547   struct coff_link_hash_entry *h;
 548
 549   *adjustedp = false;
 550
 551   h = obj_coff_sym_hashes (ibfd)[irel->r_symndx];
 552   if (h == NULL
 553       || (h->root.type != bfd_link_hash_defined
 554           && h->root.type != bfd_link_hash_defweak))
 555     return true;
 556
 557   irel->r_symndx = h->root.u.def.section->output_section->target_index - 1;
 558   *adjustedp = true;
 559
 560   return true;
 561 }
 562
 563 #define coff_start_final_link coff_i960_start_final_link
 564
 565 #define coff_relocate_section coff_i960_relocate_section
 566
 567 #define coff_adjust_symndx coff_i960_adjust_symndx
 568
 569 #define coff_bfd_reloc_type_lookup coff_i960_reloc_type_lookup
 570
 571 #include "coffcode.h"
 572
 573 const bfd_target icoff_little_vec =
 574 {
 575   "coff-Intel-little",          /* name */
 576   bfd_target_coff_flavour,
 577   false,                        /* data byte order is little */
 578   false,                        /* header byte order is little */
 579
 580   (HAS_RELOC | EXEC_P |         /* object flags */
 581    HAS_LINENO | HAS_DEBUG |
 582    HAS_SYMS | HAS_LOCALS | WP_TEXT),
 583
 584   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
 585   '_',                          /* leading underscore */
 586   '/',                          /* ar_pad_char */
 587   15,                           /* ar_max_namelen */
 588
 589   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 590      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 591      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
 592   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 593      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 594      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
 595
 596  {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
 597    bfd_generic_archive_p, _bfd_dummy_target},
 598  {bfd_false, coff_mkobject,     /* bfd_set_format */
 599    _bfd_generic_mkarchive, bfd_false},
 600  {bfd_false, coff_write_object_contents, /* bfd_write_contents */
 601    _bfd_write_archive_contents, bfd_false},
 602
 603      BFD_JUMP_TABLE_GENERIC (coff),
 604      BFD_JUMP_TABLE_COPY (coff),
 605      BFD_JUMP_TABLE_CORE (_bfd_nocore),
 606      BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
 607      BFD_JUMP_TABLE_SYMBOLS (coff),
 608      BFD_JUMP_TABLE_RELOCS (coff),
 609      BFD_JUMP_TABLE_WRITE (coff),
 610      BFD_JUMP_TABLE_LINK (coff),
 611      BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 612
 613   COFF_SWAP_TABLE,
 614 };
 615
 616
 617 const bfd_target icoff_big_vec =
 618 {
 619   "coff-Intel-big",             /* name */
 620   bfd_target_coff_flavour,
 621   false,                        /* data byte order is little */
 622   true,                         /* header byte order is big */
 623
 624   (HAS_RELOC | EXEC_P |         /* object flags */
 625    HAS_LINENO | HAS_DEBUG |
 626    HAS_SYMS | HAS_LOCALS | WP_TEXT),
 627
 628   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
 629   '_',                          /* leading underscore */
 630   '/',                          /* ar_pad_char */
 631   15,                           /* ar_max_namelen */
 632
 633 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 634      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 635      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
 636 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
 637      bfd_getb32, bfd_getb_signed_32, bfd_putb32,
 638      bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
 639
 640   {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
 641      bfd_generic_archive_p, _bfd_dummy_target},
 642   {bfd_false, coff_mkobject,    /* bfd_set_format */
 643      _bfd_generic_mkarchive, bfd_false},
 644   {bfd_false, coff_write_object_contents,       /* bfd_write_contents */
 645      _bfd_write_archive_contents, bfd_false},
 646
 647      BFD_JUMP_TABLE_GENERIC (coff),
 648      BFD_JUMP_TABLE_COPY (coff),
 649      BFD_JUMP_TABLE_CORE (_bfd_nocore),
 650      BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
 651      BFD_JUMP_TABLE_SYMBOLS (coff),
 652      BFD_JUMP_TABLE_RELOCS (coff),
 653      BFD_JUMP_TABLE_WRITE (coff),
 654      BFD_JUMP_TABLE_LINK (coff),
 655      BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 656
 657   COFF_SWAP_TABLE,
 658 };