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             {
 216               bfd_set_error (bfd_error_no_memory);
 217               return bfd_reloc_overflow;
 218             }
 219         }
 220       coff_section_data (output_bfd, osec)->tdata = (PTR) syms;
 221     }
 222
 223   /* Let bfd_perform_relocation do its thing, which will include
 224      stuffing the symbol addend into the object file.  */
 225   return bfd_reloc_continue;
 226 }
 227
 228 static reloc_howto_type howto_rellong =
 229   HOWTO ((unsigned int) R_RELLONG, 0, 2, 32,false, 0,
 230          complain_overflow_bitfield, coff_i960_relocate,"rellong", true,
 231          0xffffffff, 0xffffffff, 0);
 232 static reloc_howto_type howto_iprmed =
 233   HOWTO (R_IPRMED, 0, 2, 24,true,0, complain_overflow_signed,
 234          coff_i960_relocate, "iprmed ", true, 0x00ffffff, 0x00ffffff, 0);
 235 static reloc_howto_type howto_optcall =
 236   HOWTO (R_OPTCALL, 0,2,24,true,0, complain_overflow_signed,
 237          optcall_callback, "optcall", true, 0x00ffffff, 0x00ffffff, 0);
 238
 239 static reloc_howto_type *
 240 coff_i960_reloc_type_lookup (abfd, code)
 241      bfd *abfd;
 242      bfd_reloc_code_real_type code;
 243 {
 244   switch (code)
 245     {
 246     default:
 247       return 0;
 248     case BFD_RELOC_I960_CALLJ:
 249       return &howto_optcall;
 250     case BFD_RELOC_32:
 251     case BFD_RELOC_CTOR:
 252       return &howto_rellong;
 253     case BFD_RELOC_24_PCREL:
 254       return &howto_iprmed;
 255     }
 256 }
 257
 258 /* The real code is in coffcode.h */
 259
 260 #define RTYPE2HOWTO(cache_ptr, dst) \
 261 {                                                       \
 262    reloc_howto_type *howto_ptr;                         \
 263    switch ((dst)->r_type) {                             \
 264      case 17: howto_ptr = &howto_rellong; break;        \
 265      case 25: howto_ptr = &howto_iprmed; break;         \
 266      case 27: howto_ptr = &howto_optcall; break;        \
 267      default: howto_ptr = 0; break;                     \
 268      }                                                  \
 269    (cache_ptr)->howto = howto_ptr;                      \
 270  }
 271
 272 /* i960 COFF is used by VxWorks 5.1.  However, VxWorks 5.1 does not
 273    appear to correctly handle a reloc against a symbol defined in the
 274    same object file.  It appears to simply discard such relocs, rather
 275    than adding their values into the object file.  We handle this by
 276    converting all relocs against global symbols into relocs against
 277    internal symbols at the start of the section.  This routine is
 278    called at the start of the linking process, and it creates the
 279    necessary symbols.  */
 280
 281 static boolean
 282 coff_i960_start_final_link (abfd, info)
 283      bfd *abfd;
 284      struct bfd_link_info *info;
 285 {
 286   bfd_size_type symesz = bfd_coff_symesz (abfd);
 287   asection *o;
 288   bfd_byte *esym;
 289
 290   if (! info->relocateable)
 291     return true;
 292
 293   esym = (bfd_byte *) malloc (symesz);
 294   if (esym == NULL)
 295     {
 296       bfd_set_error (bfd_error_no_memory);
 297       return false;
 298     }
 299
 300   if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0)
 301     return false;
 302
 303   for (o = abfd->sections; o != NULL; o = o->next)
 304     {
 305       struct internal_syment isym;
 306
 307       strncpy (isym._n._n_name, o->name, SYMNMLEN);
 308       isym.n_value = 0;
 309       isym.n_scnum = o->target_index;
 310       isym.n_type = T_NULL;
 311       isym.n_sclass = C_STAT;
 312       isym.n_numaux = 0;
 313
 314       bfd_coff_swap_sym_out (abfd, (PTR) &isym, (PTR) esym);
 315
 316       if (bfd_write (esym, symesz, 1, abfd) != symesz)
 317         {
 318           free (esym);
 319           return false;
 320         }
 321
 322       obj_raw_syment_count (abfd) += 1;
 323     }
 324
 325   free (esym);
 326
 327   return true;
 328 }
 329
 330 /* The reloc processing routine for the optimized COFF linker.  */
 331
 332 static boolean
 333 coff_i960_relocate_section (output_bfd, info, input_bfd, input_section,
 334                             contents, relocs, syms, sections)
 335      bfd *output_bfd;
 336      struct bfd_link_info *info;
 337      bfd *input_bfd;
 338      asection *input_section;
 339      bfd_byte *contents;
 340      struct internal_reloc *relocs;
 341      struct internal_syment *syms;
 342      asection **sections;
 343 {
 344   struct internal_reloc *rel;
 345   struct internal_reloc *relend;
 346
 347   rel = relocs;
 348   relend = rel + input_section->reloc_count;
 349   for (; rel < relend; rel++)
 350     {
 351       long symndx;
 352       struct coff_link_hash_entry *h;
 353       struct internal_syment *sym;
 354       bfd_vma addend;
 355       bfd_vma val;
 356       reloc_howto_type *howto;
 357       bfd_reloc_status_type rstat = bfd_reloc_ok;
 358       boolean done;
 359
 360       symndx = rel->r_symndx;
 361
 362       if (symndx == -1)
 363         {
 364           h = NULL;
 365           sym = NULL;
 366         }
 367       else
 368         {
 369           h = obj_coff_sym_hashes (input_bfd)[symndx];
 370           sym = syms + symndx;
 371         }
 372
 373       if (sym != NULL && sym->n_scnum != 0)
 374         addend = - sym->n_value;
 375       else
 376         addend = 0;
 377
 378       switch (rel->r_type)
 379         {
 380         case 17: howto = &howto_rellong; break;
 381         case 25: howto = &howto_iprmed; break;
 382         case 27: howto = &howto_optcall; break;
 383         default:
 384           bfd_set_error (bfd_error_bad_value);
 385           return false;
 386         }
 387
 388       val = 0;
 389
 390       if (h == NULL)
 391         {
 392           asection *sec;
 393
 394           if (symndx == -1)
 395             {
 396               sec = bfd_abs_section_ptr;
 397               val = 0;
 398             }
 399           else
 400             {
 401               sec = sections[symndx];
 402               val = (sec->output_section->vma
 403                      + sec->output_offset
 404                      + sym->n_value
 405                      - sec->vma);
 406             }
 407         }
 408       else
 409         {
 410           if (h->root.type == bfd_link_hash_defined
 411               || h->root.type == bfd_link_hash_defweak)
 412             {
 413               asection *sec;
 414
 415               sec = h->root.u.def.section;
 416               val = (h->root.u.def.value
 417                      + sec->output_section->vma
 418                      + sec->output_offset);
 419             }
 420           else if (! info->relocateable)
 421             {
 422               if (! ((*info->callbacks->undefined_symbol)
 423                      (info, h->root.root.string, input_bfd, input_section,
 424                       rel->r_vaddr - input_section->vma)))
 425                 return false;
 426             }
 427         }
 428
 429       done = false;
 430
 431       if (howto->type == R_OPTCALL && ! info->relocateable && symndx != -1)
 432         {
 433           int class;
 434
 435           if (h != NULL)
 436             class = h->class;
 437           else
 438             class = sym->n_sclass;
 439
 440           switch (class)
 441             {
 442             case C_NULL:
 443               /* This symbol is apparently not from a COFF input file.
 444                  We warn, and then assume that it is not a leaf
 445                  function.  */
 446               if (! ((*info->callbacks->reloc_dangerous)
 447                      (info,
 448                       "uncertain calling convention for non-COFF symbol",
 449                       input_bfd, input_section,
 450                       rel->r_vaddr - input_section->vma)))
 451                 return false;
 452               break;
 453             case C_LEAFSTAT:
 454             case C_LEAFEXT:
 455               /* This is a call to a leaf procedure; use the bal
 456                  instruction.  */
 457               {
 458                 long olf;
 459                 unsigned long word;
 460
 461                 if (h != NULL)
 462                   {
 463                     BFD_ASSERT (h->numaux == 2);
 464                     olf = h->aux[1].x_bal.x_balntry;
 465                   }
 466                 else
 467                   {
 468                     bfd_byte *esyms;
 469                     union internal_auxent aux;
 470
 471                     BFD_ASSERT (sym->n_numaux == 2);
 472                     esyms = (bfd_byte *) obj_coff_external_syms (input_bfd);
 473                     esyms += (symndx + 2) * bfd_coff_symesz (input_bfd);
 474                     bfd_coff_swap_aux_in (input_bfd, (PTR) esyms, sym->n_type,
 475                                           sym->n_sclass, 1, sym->n_numaux,
 476                                           (PTR) &aux);
 477                     olf = aux.x_bal.x_balntry;
 478                   }
 479
 480                 word = bfd_get_32 (input_bfd,
 481                                    (contents
 482                                     + (rel->r_vaddr - input_section->vma)));
 483                 word = ((word + olf - val) & BAL_MASK) | BAL;
 484                 bfd_put_32 (input_bfd,
 485                             word,
 486                             (contents
 487                              + (rel->r_vaddr - input_section->vma)));
 488                 done = true;
 489               }
 490               break;
 491             case C_SCALL:
 492               BFD_ASSERT (0);
 493               break;
 494             }
 495         }
 496
 497       if (! done)
 498         rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
 499                                           contents,
 500                                           rel->r_vaddr - input_section->vma,
 501                                           val, addend);
 502
 503       switch (rstat)
 504         {
 505         default:
 506           abort ();
 507         case bfd_reloc_ok:
 508           break;
 509         case bfd_reloc_overflow:
 510           {
 511             const char *name;
 512             char buf[SYMNMLEN + 1];
 513
 514             if (symndx == -1)
 515               name = "*ABS*";
 516             else if (h != NULL)
 517               name = h->root.root.string;
 518             else
 519               {
 520                 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
 521                 if (name == NULL)
 522                   return false;
 523               }
 524
 525             if (! ((*info->callbacks->reloc_overflow)
 526                    (info, name, howto->name, (bfd_vma) 0, input_bfd,
 527                     input_section, rel->r_vaddr - input_section->vma)))
 528               return false;
 529           }
 530         }
 531     }
 532
 533   return true;
 534 }
 535
 536 /* Adjust the symbol index of any reloc against a global symbol to
 537    instead be a reloc against the internal symbol we created specially
 538    for the section.  */
 539
 540 /*ARGSUSED*/
 541 static boolean
 542 coff_i960_adjust_symndx (obfd, info, ibfd, sec, irel, adjustedp)
 543      bfd *obfd;
 544      struct bfd_link_info *info;
 545      bfd *ibfd;
 546      asection *sec;
 547      struct internal_reloc *irel;
 548      boolean *adjustedp;
 549 {
 550   struct coff_link_hash_entry *h;
 551
 552   h = obj_coff_sym_hashes (ibfd)[irel->r_symndx];
 553   if (h == NULL
 554       || (h->root.type != bfd_link_hash_defined
 555           && h->root.type != bfd_link_hash_defweak))
 556     return true;
 557
 558   irel->r_symndx = h->root.u.def.section->output_section->target_index - 1;
 559   *adjustedp = true;
 560
 561   return true;
 562 }
 563
 564 #define coff_start_final_link coff_i960_start_final_link
 565
 566 #define coff_relocate_section coff_i960_relocate_section
 567
 568 #define coff_adjust_symndx coff_i960_adjust_symndx
 569
 570 #define coff_bfd_reloc_type_lookup coff_i960_reloc_type_lookup
 571
 572 #include "coffcode.h"
 573
 574 const bfd_target icoff_little_vec =
 575 {
 576   "coff-Intel-little",          /* name */
 577   bfd_target_coff_flavour,
 578   false,                        /* data byte order is little */
 579   false,                        /* header byte order is little */
 580
 581   (HAS_RELOC | EXEC_P |         /* object flags */
 582    HAS_LINENO | HAS_DEBUG |
 583    HAS_SYMS | HAS_LOCALS | WP_TEXT),
 584
 585   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
 586   '_',                          /* leading underscore */
 587   '/',                          /* ar_pad_char */
 588   15,                           /* ar_max_namelen */
 589
 590   3,                            /* minimum alignment power */
 591   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 592      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 593      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
 594   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 595      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 596      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
 597
 598  {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
 599    bfd_generic_archive_p, _bfd_dummy_target},
 600  {bfd_false, coff_mkobject,     /* bfd_set_format */
 601    _bfd_generic_mkarchive, bfd_false},
 602  {bfd_false, coff_write_object_contents, /* bfd_write_contents */
 603    _bfd_write_archive_contents, bfd_false},
 604
 605      BFD_JUMP_TABLE_GENERIC (coff),
 606      BFD_JUMP_TABLE_COPY (coff),
 607      BFD_JUMP_TABLE_CORE (_bfd_nocore),
 608      BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
 609      BFD_JUMP_TABLE_SYMBOLS (coff),
 610      BFD_JUMP_TABLE_RELOCS (coff),
 611      BFD_JUMP_TABLE_WRITE (coff),
 612      BFD_JUMP_TABLE_LINK (coff),
 613      BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 614
 615   COFF_SWAP_TABLE,
 616 };
 617
 618
 619 const bfd_target icoff_big_vec =
 620 {
 621   "coff-Intel-big",             /* name */
 622   bfd_target_coff_flavour,
 623   false,                        /* data byte order is little */
 624   true,                         /* header byte order is big */
 625
 626   (HAS_RELOC | EXEC_P |         /* object flags */
 627    HAS_LINENO | HAS_DEBUG |
 628    HAS_SYMS | HAS_LOCALS | WP_TEXT),
 629
 630   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
 631   '_',                          /* leading underscore */
 632   '/',                          /* ar_pad_char */
 633   15,                           /* ar_max_namelen */
 634
 635   3,                            /* minimum alignment power */
 636 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 637      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 638      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
 639 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
 640      bfd_getb32, bfd_getb_signed_32, bfd_putb32,
 641      bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
 642
 643   {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
 644      bfd_generic_archive_p, _bfd_dummy_target},
 645   {bfd_false, coff_mkobject,    /* bfd_set_format */
 646      _bfd_generic_mkarchive, bfd_false},
 647   {bfd_false, coff_write_object_contents,       /* bfd_write_contents */
 648      _bfd_write_archive_contents, bfd_false},
 649
 650      BFD_JUMP_TABLE_GENERIC (coff),
 651      BFD_JUMP_TABLE_COPY (coff),
 652      BFD_JUMP_TABLE_CORE (_bfd_nocore),
 653      BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
 654      BFD_JUMP_TABLE_SYMBOLS (coff),
 655      BFD_JUMP_TABLE_RELOCS (coff),
 656      BFD_JUMP_TABLE_WRITE (coff),
 657      BFD_JUMP_TABLE_LINK (coff),
 658      BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 659
 660   COFF_SWAP_TABLE,
 661 };