bfd/plugin.c

   1 /* Plugin support for BFD.
   2    Copyright (C) 2009-2019 Free Software Foundation, Inc.
   3
   4    This file is part of BFD, the Binary File Descriptor library.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  19    MA 02110-1301, USA.  */
  20
  21 #include "sysdep.h"
  22 #include "bfd.h"
  23
  24 #if BFD_SUPPORTS_PLUGINS
  25
  26 #include <assert.h>
  27 #ifdef HAVE_DLFCN_H
  28 #include <dlfcn.h>
  29 #elif defined (HAVE_WINDOWS_H)
  30 #include <windows.h>
  31 #else
  32 #error Unknown how to handle dynamic-load-libraries.
  33 #endif
  34 #include <stdarg.h>
  35 #include "plugin-api.h"
  36 #include "plugin.h"
  37 #include "libbfd.h"
  38 #include "libiberty.h"
  39 #include <dirent.h>
  40
  41 #if !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H)
  42
  43 #define RTLD_NOW 0      /* Dummy value.  */
  44
  45 static void *
  46 dlopen (const char *file, int mode ATTRIBUTE_UNUSED)
  47 {
  48   return LoadLibrary (file);
  49 }
  50
  51 static void *
  52 dlsym (void *handle, const char *name)
  53 {
  54   return GetProcAddress (handle, name);
  55 }
  56
  57 static int ATTRIBUTE_UNUSED
  58 dlclose (void *handle)
  59 {
  60   FreeLibrary (handle);
  61   return 0;
  62 }
  63
  64 static const char *
  65 dlerror (void)
  66 {
  67   return "Unable to load DLL.";
  68 }
  69
  70 #endif /* !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H)  */
  71
  72 #define bfd_plugin_close_and_cleanup                  _bfd_generic_close_and_cleanup
  73 #define bfd_plugin_bfd_free_cached_info               _bfd_generic_bfd_free_cached_info
  74 #define bfd_plugin_new_section_hook                   _bfd_generic_new_section_hook
  75 #define bfd_plugin_get_section_contents               _bfd_generic_get_section_contents
  76 #define bfd_plugin_get_section_contents_in_window     _bfd_generic_get_section_contents_in_window
  77 #define bfd_plugin_bfd_copy_private_header_data       _bfd_generic_bfd_copy_private_header_data
  78 #define bfd_plugin_bfd_merge_private_bfd_data         _bfd_generic_bfd_merge_private_bfd_data
  79 #define bfd_plugin_bfd_copy_private_header_data       _bfd_generic_bfd_copy_private_header_data
  80 #define bfd_plugin_bfd_set_private_flags              _bfd_generic_bfd_set_private_flags
  81 #define bfd_plugin_core_file_matches_executable_p     generic_core_file_matches_executable_p
  82 #define bfd_plugin_bfd_is_local_label_name            _bfd_nosymbols_bfd_is_local_label_name
  83 #define bfd_plugin_bfd_is_target_special_symbol       _bfd_bool_bfd_asymbol_false
  84 #define bfd_plugin_get_lineno                         _bfd_nosymbols_get_lineno
  85 #define bfd_plugin_find_nearest_line                  _bfd_nosymbols_find_nearest_line
  86 #define bfd_plugin_find_line                          _bfd_nosymbols_find_line
  87 #define bfd_plugin_find_inliner_info                  _bfd_nosymbols_find_inliner_info
  88 #define bfd_plugin_get_symbol_version_string          _bfd_nosymbols_get_symbol_version_string
  89 #define bfd_plugin_bfd_make_debug_symbol              _bfd_nosymbols_bfd_make_debug_symbol
  90 #define bfd_plugin_read_minisymbols                   _bfd_generic_read_minisymbols
  91 #define bfd_plugin_minisymbol_to_symbol               _bfd_generic_minisymbol_to_symbol
  92 #define bfd_plugin_set_arch_mach                      bfd_default_set_arch_mach
  93 #define bfd_plugin_set_section_contents               _bfd_generic_set_section_contents
  94 #define bfd_plugin_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
  95 #define bfd_plugin_bfd_relax_section                  bfd_generic_relax_section
  96 #define bfd_plugin_bfd_link_hash_table_create         _bfd_generic_link_hash_table_create
  97 #define bfd_plugin_bfd_link_add_symbols               _bfd_generic_link_add_symbols
  98 #define bfd_plugin_bfd_link_just_syms                 _bfd_generic_link_just_syms
  99 #define bfd_plugin_bfd_final_link                     _bfd_generic_final_link
 100 #define bfd_plugin_bfd_link_split_section             _bfd_generic_link_split_section
 101 #define bfd_plugin_bfd_gc_sections                    bfd_generic_gc_sections
 102 #define bfd_plugin_bfd_lookup_section_flags           bfd_generic_lookup_section_flags
 103 #define bfd_plugin_bfd_merge_sections                 bfd_generic_merge_sections
 104 #define bfd_plugin_bfd_is_group_section               bfd_generic_is_group_section
 105 #define bfd_plugin_bfd_group_name                     bfd_generic_group_name
 106 #define bfd_plugin_bfd_discard_group                  bfd_generic_discard_group
 107 #define bfd_plugin_section_already_linked             _bfd_generic_section_already_linked
 108 #define bfd_plugin_bfd_define_common_symbol           bfd_generic_define_common_symbol
 109 #define bfd_plugin_bfd_link_hide_symbol               _bfd_generic_link_hide_symbol
 110 #define bfd_plugin_bfd_define_start_stop              bfd_generic_define_start_stop
 111 #define bfd_plugin_bfd_copy_link_hash_symbol_type     _bfd_generic_copy_link_hash_symbol_type
 112 #define bfd_plugin_bfd_link_check_relocs              _bfd_generic_link_check_relocs
 113
 114 static enum ld_plugin_status
 115 message (int level ATTRIBUTE_UNUSED,
 116          const char * format, ...)
 117 {
 118   va_list args;
 119   va_start (args, format);
 120   printf ("bfd plugin: ");
 121   vprintf (format, args);
 122   putchar ('\n');
 123   va_end (args);
 124   return LDPS_OK;
 125 }
 126
 127 /* Register a claim-file handler. */
 128 static ld_plugin_claim_file_handler claim_file = NULL;
 129
 130 static enum ld_plugin_status
 131 register_claim_file (ld_plugin_claim_file_handler handler)
 132 {
 133   claim_file = handler;
 134   return LDPS_OK;
 135 }
 136
 137 static enum ld_plugin_status
 138 add_symbols (void * handle,
 139              int nsyms,
 140              const struct ld_plugin_symbol * syms)
 141 {
 142   bfd *abfd = handle;
 143   struct plugin_data_struct *plugin_data =
 144     bfd_alloc (abfd, sizeof (plugin_data_struct));
 145
 146   plugin_data->nsyms = nsyms;
 147   plugin_data->syms = syms;
 148
 149   if (nsyms != 0)
 150     abfd->flags |= HAS_SYMS;
 151
 152   abfd->tdata.plugin_data = plugin_data;
 153   return LDPS_OK;
 154 }
 155
 156 static const char *plugin_program_name;
 157
 158 void
 159 bfd_plugin_set_program_name (const char *program_name)
 160 {
 161   plugin_program_name = program_name;
 162 }
 163
 164 int
 165 bfd_plugin_open_input (bfd *ibfd, struct ld_plugin_input_file *file)
 166 {
 167   bfd *iobfd;
 168
 169   iobfd = ibfd;
 170   while (iobfd->my_archive
 171          && !bfd_is_thin_archive (iobfd->my_archive))
 172     iobfd = iobfd->my_archive;
 173   file->name = iobfd->filename;
 174
 175   if (!iobfd->iostream && !bfd_open_file (iobfd))
 176     return 0;
 177
 178   /* The plugin API expects that the file descriptor won't be closed
 179      and reused as done by the bfd file cache.  So open it again.
 180      dup isn't good enough.  plugin IO uses lseek/read while BFD uses
 181      fseek/fread.  It isn't wise to mix the unistd and stdio calls on
 182      the same underlying file descriptor.  */
 183   file->fd = open (file->name, O_RDONLY | O_BINARY);
 184   if (file->fd < 0)
 185     return 0;
 186
 187   if (iobfd == ibfd)
 188     {
 189       struct stat stat_buf;
 190
 191       if (fstat (file->fd, &stat_buf))
 192         {
 193           close(file->fd);
 194           return 0;
 195         }
 196
 197       file->offset = 0;
 198       file->filesize = stat_buf.st_size;
 199     }
 200   else
 201     {
 202       file->offset = ibfd->origin;
 203       file->filesize = arelt_size (ibfd);
 204     }
 205   return 1;
 206 }
 207
 208 static int
 209 try_claim (bfd *abfd)
 210 {
 211   int claimed = 0;
 212   struct ld_plugin_input_file file;
 213
 214   file.handle = abfd;
 215   if (!bfd_plugin_open_input (abfd, &file))
 216     return 0;
 217   if (claim_file)
 218     claim_file (&file, &claimed);
 219   close (file.fd);
 220   return claimed;
 221 }
 222
 223 struct plugin_list_entry
 224 {
 225   void *                        handle;
 226   ld_plugin_claim_file_handler  claim_file;
 227   struct plugin_list_entry *    next;
 228 };
 229
 230 static struct plugin_list_entry * plugin_list = NULL;
 231
 232 static int
 233 try_load_plugin (const char *pname, bfd *abfd, int *has_plugin_p)
 234 {
 235   void *plugin_handle = NULL;
 236   struct ld_plugin_tv tv[4];
 237   int i;
 238   ld_plugin_onload onload;
 239   enum ld_plugin_status status;
 240   struct plugin_list_entry *plugin_list_iter;
 241
 242   *has_plugin_p = 0;
 243
 244   plugin_handle = dlopen (pname, RTLD_NOW);
 245   if (!plugin_handle)
 246     {
 247       _bfd_error_handler ("%s\n", dlerror ());
 248       return 0;
 249     }
 250
 251   for (plugin_list_iter = plugin_list;
 252        plugin_list_iter;
 253        plugin_list_iter = plugin_list_iter->next)
 254     {
 255       if (plugin_handle == plugin_list_iter->handle)
 256         {
 257           dlclose (plugin_handle);
 258           if (!plugin_list_iter->claim_file)
 259             return 0;
 260
 261           register_claim_file (plugin_list_iter->claim_file);
 262           goto have_claim_file;
 263         }
 264     }
 265
 266   plugin_list_iter = bfd_malloc (sizeof *plugin_list_iter);
 267   if (plugin_list_iter == NULL)
 268     return 0;
 269   plugin_list_iter->handle = plugin_handle;
 270   plugin_list_iter->claim_file = NULL;
 271   plugin_list_iter->next = plugin_list;
 272   plugin_list = plugin_list_iter;
 273
 274   onload = dlsym (plugin_handle, "onload");
 275   if (!onload)
 276     return 0;
 277
 278   i = 0;
 279   tv[i].tv_tag = LDPT_MESSAGE;
 280   tv[i].tv_u.tv_message = message;
 281
 282   ++i;
 283   tv[i].tv_tag = LDPT_REGISTER_CLAIM_FILE_HOOK;
 284   tv[i].tv_u.tv_register_claim_file = register_claim_file;
 285
 286   ++i;
 287   tv[i].tv_tag = LDPT_ADD_SYMBOLS;
 288   tv[i].tv_u.tv_add_symbols = add_symbols;
 289
 290   ++i;
 291   tv[i].tv_tag = LDPT_NULL;
 292   tv[i].tv_u.tv_val = 0;
 293
 294   status = (*onload)(tv);
 295
 296   if (status != LDPS_OK)
 297     return 0;
 298
 299   plugin_list_iter->claim_file = claim_file;
 300
 301 have_claim_file:
 302   *has_plugin_p = 1;
 303
 304   abfd->plugin_format = bfd_plugin_no;
 305
 306   if (!claim_file)
 307     return 0;
 308
 309   if (!try_claim (abfd))
 310     return 0;
 311
 312   abfd->plugin_format = bfd_plugin_yes;
 313   return 1;
 314 }
 315
 316 /* There may be plugin libraries in lib/bfd-plugins.  */
 317
 318 static int has_plugin = -1;
 319
 320 static const bfd_target *(*ld_plugin_object_p) (bfd *);
 321
 322 static const char *plugin_name;
 323
 324 void
 325 bfd_plugin_set_plugin (const char *p)
 326 {
 327   plugin_name = p;
 328   has_plugin = p != NULL;
 329 }
 330
 331 /* Return TRUE if a plugin library is used.  */
 332
 333 bfd_boolean
 334 bfd_plugin_specified_p (void)
 335 {
 336   return has_plugin > 0;
 337 }
 338
 339 /* Return TRUE if ABFD can be claimed by linker LTO plugin.  */
 340
 341 bfd_boolean
 342 bfd_link_plugin_object_p (bfd *abfd)
 343 {
 344   if (ld_plugin_object_p)
 345     return ld_plugin_object_p (abfd) != NULL;
 346   return FALSE;
 347 }
 348
 349 extern const bfd_target plugin_vec;
 350
 351 /* Return TRUE if TARGET is a pointer to plugin_vec.  */
 352
 353 bfd_boolean
 354 bfd_plugin_target_p (const bfd_target *target)
 355 {
 356   return target == &plugin_vec;
 357 }
 358
 359 /* Register OBJECT_P to be used by bfd_plugin_object_p.  */
 360
 361 void
 362 register_ld_plugin_object_p (const bfd_target *(*object_p) (bfd *))
 363 {
 364   ld_plugin_object_p = object_p;
 365 }
 366
 367 static int
 368 load_plugin (bfd *abfd)
 369 {
 370   char *plugin_dir;
 371   char *p;
 372   DIR *d;
 373   struct dirent *ent;
 374   int found = 0;
 375
 376   if (!has_plugin)
 377     return found;
 378
 379   if (plugin_name)
 380     return try_load_plugin (plugin_name, abfd, &has_plugin);
 381
 382   if (plugin_program_name == NULL)
 383     return found;
 384
 385   plugin_dir = concat (BINDIR, "/../lib/bfd-plugins", NULL);
 386   p = make_relative_prefix (plugin_program_name,
 387                             BINDIR,
 388                             plugin_dir);
 389   free (plugin_dir);
 390   plugin_dir = NULL;
 391
 392   d = opendir (p);
 393   if (!d)
 394     goto out;
 395
 396   while ((ent = readdir (d)))
 397     {
 398       char *full_name;
 399       struct stat s;
 400       int valid_plugin;
 401
 402       full_name = concat (p, "/", ent->d_name, NULL);
 403       if (stat (full_name, &s) == 0 && S_ISREG (s.st_mode))
 404         found = try_load_plugin (full_name, abfd, &valid_plugin);
 405       if (has_plugin <= 0)
 406         has_plugin = valid_plugin;
 407       free (full_name);
 408       if (found)
 409         break;
 410     }
 411
 412  out:
 413   free (p);
 414   if (d)
 415     closedir (d);
 416
 417   return found;
 418 }
 419
 420
 421 static const bfd_target *
 422 bfd_plugin_object_p (bfd *abfd)
 423 {
 424   if (ld_plugin_object_p)
 425     return ld_plugin_object_p (abfd);
 426
 427   if (abfd->plugin_format == bfd_plugin_unknown && !load_plugin (abfd))
 428     return NULL;
 429
 430   return abfd->plugin_format == bfd_plugin_yes ? abfd->xvec : NULL;
 431 }
 432
 433 /* Copy any private info we understand from the input bfd
 434    to the output bfd.  */
 435
 436 static bfd_boolean
 437 bfd_plugin_bfd_copy_private_bfd_data (bfd *ibfd ATTRIBUTE_UNUSED,
 438                                       bfd *obfd ATTRIBUTE_UNUSED)
 439 {
 440   BFD_ASSERT (0);
 441   return TRUE;
 442 }
 443
 444 /* Copy any private info we understand from the input section
 445    to the output section.  */
 446
 447 static bfd_boolean
 448 bfd_plugin_bfd_copy_private_section_data (bfd *ibfd ATTRIBUTE_UNUSED,
 449                                           asection *isection ATTRIBUTE_UNUSED,
 450                                           bfd *obfd ATTRIBUTE_UNUSED,
 451                                           asection *osection ATTRIBUTE_UNUSED)
 452 {
 453   BFD_ASSERT (0);
 454   return TRUE;
 455 }
 456
 457 /* Copy any private info we understand from the input symbol
 458    to the output symbol.  */
 459
 460 static bfd_boolean
 461 bfd_plugin_bfd_copy_private_symbol_data (bfd *ibfd ATTRIBUTE_UNUSED,
 462                                          asymbol *isymbol ATTRIBUTE_UNUSED,
 463                                          bfd *obfd ATTRIBUTE_UNUSED,
 464                                          asymbol *osymbol ATTRIBUTE_UNUSED)
 465 {
 466   BFD_ASSERT (0);
 467   return TRUE;
 468 }
 469
 470 static bfd_boolean
 471 bfd_plugin_bfd_print_private_bfd_data (bfd *abfd ATTRIBUTE_UNUSED, PTR ptr ATTRIBUTE_UNUSED)
 472 {
 473   BFD_ASSERT (0);
 474   return TRUE;
 475 }
 476
 477 static char *
 478 bfd_plugin_core_file_failing_command (bfd *abfd ATTRIBUTE_UNUSED)
 479 {
 480   BFD_ASSERT (0);
 481   return NULL;
 482 }
 483
 484 static int
 485 bfd_plugin_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED)
 486 {
 487   BFD_ASSERT (0);
 488   return 0;
 489 }
 490
 491 static int
 492 bfd_plugin_core_file_pid (bfd *abfd ATTRIBUTE_UNUSED)
 493 {
 494   BFD_ASSERT (0);
 495   return 0;
 496 }
 497
 498 static long
 499 bfd_plugin_get_symtab_upper_bound (bfd *abfd)
 500 {
 501   struct plugin_data_struct *plugin_data = abfd->tdata.plugin_data;
 502   long nsyms = plugin_data->nsyms;
 503
 504   BFD_ASSERT (nsyms >= 0);
 505
 506   return ((nsyms + 1) * sizeof (asymbol *));
 507 }
 508
 509 static flagword
 510 convert_flags (const struct ld_plugin_symbol *sym)
 511 {
 512  switch (sym->def)
 513    {
 514    case LDPK_DEF:
 515    case LDPK_COMMON:
 516    case LDPK_UNDEF:
 517      return BSF_GLOBAL;
 518
 519    case LDPK_WEAKUNDEF:
 520    case LDPK_WEAKDEF:
 521      return BSF_GLOBAL | BSF_WEAK;
 522
 523    default:
 524      BFD_ASSERT (0);
 525      return 0;
 526    }
 527 }
 528
 529 static long
 530 bfd_plugin_canonicalize_symtab (bfd *abfd,
 531                                 asymbol **alocation)
 532 {
 533   struct plugin_data_struct *plugin_data = abfd->tdata.plugin_data;
 534   long nsyms = plugin_data->nsyms;
 535   const struct ld_plugin_symbol *syms = plugin_data->syms;
 536   static asection fake_section
 537     = BFD_FAKE_SECTION (fake_section, NULL, "plug", 0,
 538                         SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS);
 539   static asection fake_common_section
 540     = BFD_FAKE_SECTION (fake_common_section, NULL, "plug", 0, SEC_IS_COMMON);
 541   int i;
 542
 543   for (i = 0; i < nsyms; i++)
 544     {
 545       asymbol *s = bfd_alloc (abfd, sizeof (asymbol));
 546
 547       BFD_ASSERT (s);
 548       alocation[i] = s;
 549
 550       s->the_bfd = abfd;
 551       s->name = syms[i].name;
 552       s->value = 0;
 553       s->flags = convert_flags (&syms[i]);
 554       switch (syms[i].def)
 555         {
 556         case LDPK_COMMON:
 557           s->section = &fake_common_section;
 558           break;
 559         case LDPK_UNDEF:
 560         case LDPK_WEAKUNDEF:
 561           s->section = bfd_und_section_ptr;
 562           break;
 563         case LDPK_DEF:
 564         case LDPK_WEAKDEF:
 565           s->section = &fake_section;
 566           break;
 567         default:
 568           BFD_ASSERT (0);
 569         }
 570
 571       s->udata.p = (void *) &syms[i];
 572     }
 573
 574   return nsyms;
 575 }
 576
 577 static void
 578 bfd_plugin_print_symbol (bfd *abfd ATTRIBUTE_UNUSED,
 579                          PTR afile ATTRIBUTE_UNUSED,
 580                          asymbol *symbol ATTRIBUTE_UNUSED,
 581                          bfd_print_symbol_type how ATTRIBUTE_UNUSED)
 582 {
 583   BFD_ASSERT (0);
 584 }
 585
 586 static void
 587 bfd_plugin_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
 588                             asymbol *symbol,
 589                             symbol_info *ret)
 590 {
 591   bfd_symbol_info (symbol, ret);
 592 }
 593
 594 /* Make an empty symbol. */
 595
 596 static asymbol *
 597 bfd_plugin_make_empty_symbol (bfd *abfd)
 598 {
 599   asymbol *new_symbol = bfd_zalloc (abfd, sizeof (asymbol));
 600   if (new_symbol == NULL)
 601     return new_symbol;
 602   new_symbol->the_bfd = abfd;
 603   return new_symbol;
 604 }
 605
 606 static int
 607 bfd_plugin_sizeof_headers (bfd *a ATTRIBUTE_UNUSED,
 608                            struct bfd_link_info *info ATTRIBUTE_UNUSED)
 609 {
 610   BFD_ASSERT (0);
 611   return 0;
 612 }
 613
 614 const bfd_target plugin_vec =
 615 {
 616   "plugin",                     /* Name.  */
 617   bfd_target_unknown_flavour,
 618   BFD_ENDIAN_LITTLE,            /* Target byte order.  */
 619   BFD_ENDIAN_LITTLE,            /* Target headers byte order.  */
 620   (HAS_RELOC | EXEC_P |         /* Object flags.  */
 621    HAS_LINENO | HAS_DEBUG |
 622    HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
 623   (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
 624    | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags.  */
 625   0,                            /* symbol_leading_char.  */
 626   '/',                          /* ar_pad_char.  */
 627   15,                           /* ar_max_namelen.  */
 628   255,                          /* match priority.  */
 629
 630   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 631   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 632   bfd_getl16, bfd_getl_signed_16, bfd_putl16,   /* data */
 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,   /* hdrs */
 636
 637   {                             /* bfd_check_format.  */
 638     _bfd_dummy_target,
 639     bfd_plugin_object_p,
 640     bfd_generic_archive_p,
 641     _bfd_dummy_target
 642   },
 643   {                             /* bfd_set_format.  */
 644     _bfd_bool_bfd_false_error,
 645     _bfd_bool_bfd_false_error,
 646     _bfd_generic_mkarchive,
 647     _bfd_bool_bfd_false_error,
 648   },
 649   {                             /* bfd_write_contents.  */
 650     _bfd_bool_bfd_false_error,
 651     _bfd_bool_bfd_false_error,
 652     _bfd_write_archive_contents,
 653     _bfd_bool_bfd_false_error,
 654   },
 655
 656   BFD_JUMP_TABLE_GENERIC (bfd_plugin),
 657   BFD_JUMP_TABLE_COPY (bfd_plugin),
 658   BFD_JUMP_TABLE_CORE (bfd_plugin),
 659 #ifdef USE_64_BIT_ARCHIVE
 660   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_64_bit),
 661 #else
 662   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
 663 #endif
 664   BFD_JUMP_TABLE_SYMBOLS (bfd_plugin),
 665   BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
 666   BFD_JUMP_TABLE_WRITE (bfd_plugin),
 667   BFD_JUMP_TABLE_LINK (bfd_plugin),
 668   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 669
 670   NULL,
 671
 672   NULL                          /* backend_data.  */
 673 };
 674 #endif /* BFD_SUPPORTS_PLUGIN */