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_discard_group                  bfd_generic_discard_group
 106 #define bfd_plugin_section_already_linked             _bfd_generic_section_already_linked
 107 #define bfd_plugin_bfd_define_common_symbol           bfd_generic_define_common_symbol
 108 #define bfd_plugin_bfd_link_hide_symbol               _bfd_generic_link_hide_symbol
 109 #define bfd_plugin_bfd_define_start_stop              bfd_generic_define_start_stop
 110 #define bfd_plugin_bfd_copy_link_hash_symbol_type     _bfd_generic_copy_link_hash_symbol_type
 111 #define bfd_plugin_bfd_link_check_relocs              _bfd_generic_link_check_relocs
 112
 113 static enum ld_plugin_status
 114 message (int level ATTRIBUTE_UNUSED,
 115          const char * format, ...)
 116 {
 117   va_list args;
 118   va_start (args, format);
 119   printf ("bfd plugin: ");
 120   vprintf (format, args);
 121   putchar ('\n');
 122   va_end (args);
 123   return LDPS_OK;
 124 }
 125
 126 /* Register a claim-file handler. */
 127 static ld_plugin_claim_file_handler claim_file = NULL;
 128
 129 static enum ld_plugin_status
 130 register_claim_file (ld_plugin_claim_file_handler handler)
 131 {
 132   claim_file = handler;
 133   return LDPS_OK;
 134 }
 135
 136 static enum ld_plugin_status
 137 add_symbols (void * handle,
 138              int nsyms,
 139              const struct ld_plugin_symbol * syms)
 140 {
 141   bfd *abfd = handle;
 142   struct plugin_data_struct *plugin_data =
 143     bfd_alloc (abfd, sizeof (plugin_data_struct));
 144
 145   plugin_data->nsyms = nsyms;
 146   plugin_data->syms = syms;
 147
 148   if (nsyms != 0)
 149     abfd->flags |= HAS_SYMS;
 150
 151   abfd->tdata.plugin_data = plugin_data;
 152   return LDPS_OK;
 153 }
 154
 155 static const char *plugin_program_name;
 156
 157 void
 158 bfd_plugin_set_program_name (const char *program_name)
 159 {
 160   plugin_program_name = program_name;
 161 }
 162
 163 int
 164 bfd_plugin_open_input (bfd *ibfd, struct ld_plugin_input_file *file)
 165 {
 166   bfd *iobfd;
 167
 168   iobfd = ibfd;
 169   while (iobfd->my_archive
 170          && !bfd_is_thin_archive (iobfd->my_archive))
 171     iobfd = iobfd->my_archive;
 172   file->name = iobfd->filename;
 173
 174   if (!iobfd->iostream && !bfd_open_file (iobfd))
 175     return 0;
 176
 177   /* The plugin API expects that the file descriptor won't be closed
 178      and reused as done by the bfd file cache.  So open it again.
 179      dup isn't good enough.  plugin IO uses lseek/read while BFD uses
 180      fseek/fread.  It isn't wise to mix the unistd and stdio calls on
 181      the same underlying file descriptor.  */
 182   file->fd = open (file->name, O_RDONLY | O_BINARY);
 183   if (file->fd < 0)
 184     return 0;
 185
 186   if (iobfd == ibfd)
 187     {
 188       struct stat stat_buf;
 189
 190       if (fstat (file->fd, &stat_buf))
 191         {
 192           close(file->fd);
 193           return 0;
 194         }
 195
 196       file->offset = 0;
 197       file->filesize = stat_buf.st_size;
 198     }
 199   else
 200     {
 201       file->offset = ibfd->origin;
 202       file->filesize = arelt_size (ibfd);
 203     }
 204   return 1;
 205 }
 206
 207 static int
 208 try_claim (bfd *abfd)
 209 {
 210   int claimed = 0;
 211   struct ld_plugin_input_file file;
 212
 213   file.handle = abfd;
 214   if (!bfd_plugin_open_input (abfd, &file))
 215     return 0;
 216   if (claim_file)
 217     claim_file (&file, &claimed);
 218   close (file.fd);
 219   return claimed;
 220 }
 221
 222 struct plugin_list_entry
 223 {
 224   void *                        handle;
 225   ld_plugin_claim_file_handler  claim_file;
 226   struct plugin_list_entry *    next;
 227 };
 228
 229 static struct plugin_list_entry * plugin_list = NULL;
 230
 231 static int
 232 try_load_plugin (const char *pname, bfd *abfd, int *has_plugin_p)
 233 {
 234   void *plugin_handle = NULL;
 235   struct ld_plugin_tv tv[4];
 236   int i;
 237   ld_plugin_onload onload;
 238   enum ld_plugin_status status;
 239   struct plugin_list_entry *plugin_list_iter;
 240
 241   *has_plugin_p = 0;
 242
 243   plugin_handle = dlopen (pname, RTLD_NOW);
 244   if (!plugin_handle)
 245     {
 246       _bfd_error_handler ("%s\n", dlerror ());
 247       return 0;
 248     }
 249
 250   for (plugin_list_iter = plugin_list;
 251        plugin_list_iter;
 252        plugin_list_iter = plugin_list_iter->next)
 253     {
 254       if (plugin_handle == plugin_list_iter->handle)
 255         {
 256           dlclose (plugin_handle);
 257           if (!plugin_list_iter->claim_file)
 258             return 0;
 259
 260           register_claim_file (plugin_list_iter->claim_file);
 261           goto have_claim_file;
 262         }
 263     }
 264
 265   plugin_list_iter = bfd_malloc (sizeof *plugin_list_iter);
 266   if (plugin_list_iter == NULL)
 267     return 0;
 268   plugin_list_iter->handle = plugin_handle;
 269   plugin_list_iter->claim_file = NULL;
 270   plugin_list_iter->next = plugin_list;
 271   plugin_list = plugin_list_iter;
 272
 273   onload = dlsym (plugin_handle, "onload");
 274   if (!onload)
 275     return 0;
 276
 277   i = 0;
 278   tv[i].tv_tag = LDPT_MESSAGE;
 279   tv[i].tv_u.tv_message = message;
 280
 281   ++i;
 282   tv[i].tv_tag = LDPT_REGISTER_CLAIM_FILE_HOOK;
 283   tv[i].tv_u.tv_register_claim_file = register_claim_file;
 284
 285   ++i;
 286   tv[i].tv_tag = LDPT_ADD_SYMBOLS;
 287   tv[i].tv_u.tv_add_symbols = add_symbols;
 288
 289   ++i;
 290   tv[i].tv_tag = LDPT_NULL;
 291   tv[i].tv_u.tv_val = 0;
 292
 293   status = (*onload)(tv);
 294
 295   if (status != LDPS_OK)
 296     return 0;
 297
 298   plugin_list_iter->claim_file = claim_file;
 299
 300 have_claim_file:
 301   *has_plugin_p = 1;
 302
 303   abfd->plugin_format = bfd_plugin_no;
 304
 305   if (!claim_file)
 306     return 0;
 307
 308   if (!try_claim (abfd))
 309     return 0;
 310
 311   abfd->plugin_format = bfd_plugin_yes;
 312   return 1;
 313 }
 314
 315 /* There may be plugin libraries in lib/bfd-plugins.  */
 316
 317 static int has_plugin = -1;
 318
 319 static const bfd_target *(*ld_plugin_object_p) (bfd *);
 320
 321 static const char *plugin_name;
 322
 323 void
 324 bfd_plugin_set_plugin (const char *p)
 325 {
 326   plugin_name = p;
 327   has_plugin = p != NULL;
 328 }
 329
 330 /* Return TRUE if a plugin library is used.  */
 331
 332 bfd_boolean
 333 bfd_plugin_specified_p (void)
 334 {
 335   return has_plugin > 0;
 336 }
 337
 338 /* Return TRUE if ABFD can be claimed by linker LTO plugin.  */
 339
 340 bfd_boolean
 341 bfd_link_plugin_object_p (bfd *abfd)
 342 {
 343   if (ld_plugin_object_p)
 344     return ld_plugin_object_p (abfd) != NULL;
 345   return FALSE;
 346 }
 347
 348 extern const bfd_target plugin_vec;
 349
 350 /* Return TRUE if TARGET is a pointer to plugin_vec.  */
 351
 352 bfd_boolean
 353 bfd_plugin_target_p (const bfd_target *target)
 354 {
 355   return target == &plugin_vec;
 356 }
 357
 358 /* Register OBJECT_P to be used by bfd_plugin_object_p.  */
 359
 360 void
 361 register_ld_plugin_object_p (const bfd_target *(*object_p) (bfd *))
 362 {
 363   ld_plugin_object_p = object_p;
 364 }
 365
 366 static int
 367 load_plugin (bfd *abfd)
 368 {
 369   /* The intent was to search ${libdir}/bfd-plugins for plugins, but
 370      unfortunately the original implementation wasn't precisely that
 371      when configuring binutils using --libdir.  Search in the proper
 372      path first, then the old one for backwards compatibility.  */
 373   static const char *path[]
 374     = { LIBDIR "/bfd-plugins", BINDIR "/../lib/bfd-plugins" };
 375   struct stat last_st;
 376   int found = 0;
 377   unsigned int i;
 378
 379   if (!has_plugin)
 380     return found;
 381
 382   if (plugin_name)
 383     return try_load_plugin (plugin_name, abfd, &has_plugin);
 384
 385   if (plugin_program_name == NULL)
 386     return found;
 387
 388   /* Try not to search the same dir twice, by looking at st_dev and
 389      st_ino for the dir.  If we are on a file system that always sets
 390      st_ino to zero or the actual st_ino is zero we might waste some
 391      time, but that doesn't matter too much.  */
 392   last_st.st_dev = 0;
 393   last_st.st_ino = 0;
 394   for (i = 0; i < sizeof (path) / sizeof (path[0]); i++)
 395     {
 396       char *plugin_dir = make_relative_prefix (plugin_program_name,
 397                                                BINDIR,
 398                                                path[i]);
 399       if (plugin_dir)
 400         {
 401           struct stat st;
 402           DIR *d;
 403
 404           if (stat (plugin_dir, &st) == 0
 405               && S_ISDIR (st.st_mode)
 406               && !(last_st.st_dev == st.st_dev
 407                    && last_st.st_ino == st.st_ino
 408                    && st.st_ino != 0)
 409               && (d = opendir (plugin_dir)) != NULL)
 410             {
 411               struct dirent *ent;
 412
 413               last_st.st_dev = st.st_dev;
 414               last_st.st_ino = st.st_ino;
 415               while ((ent = readdir (d)) != NULL)
 416                 {
 417                   char *full_name;
 418
 419                   full_name = concat (plugin_dir, "/", ent->d_name, NULL);
 420                   if (stat (full_name, &st) == 0 && S_ISREG (st.st_mode))
 421                     {
 422                       int valid_plugin;
 423
 424                       found = try_load_plugin (full_name, abfd, &valid_plugin);
 425                       if (has_plugin <= 0)
 426                         has_plugin = valid_plugin;
 427                     }
 428                   free (full_name);
 429                   if (found)
 430                     break;
 431                 }
 432               closedir (d);
 433             }
 434           free (plugin_dir);
 435         }
 436       if (found)
 437         break;
 438     }
 439
 440   return found;
 441 }
 442
 443
 444 static const bfd_target *
 445 bfd_plugin_object_p (bfd *abfd)
 446 {
 447   if (ld_plugin_object_p)
 448     return ld_plugin_object_p (abfd);
 449
 450   if (abfd->plugin_format == bfd_plugin_unknown && !load_plugin (abfd))
 451     return NULL;
 452
 453   return abfd->plugin_format == bfd_plugin_yes ? abfd->xvec : NULL;
 454 }
 455
 456 /* Copy any private info we understand from the input bfd
 457    to the output bfd.  */
 458
 459 static bfd_boolean
 460 bfd_plugin_bfd_copy_private_bfd_data (bfd *ibfd ATTRIBUTE_UNUSED,
 461                                       bfd *obfd ATTRIBUTE_UNUSED)
 462 {
 463   BFD_ASSERT (0);
 464   return TRUE;
 465 }
 466
 467 /* Copy any private info we understand from the input section
 468    to the output section.  */
 469
 470 static bfd_boolean
 471 bfd_plugin_bfd_copy_private_section_data (bfd *ibfd ATTRIBUTE_UNUSED,
 472                                           asection *isection ATTRIBUTE_UNUSED,
 473                                           bfd *obfd ATTRIBUTE_UNUSED,
 474                                           asection *osection ATTRIBUTE_UNUSED)
 475 {
 476   BFD_ASSERT (0);
 477   return TRUE;
 478 }
 479
 480 /* Copy any private info we understand from the input symbol
 481    to the output symbol.  */
 482
 483 static bfd_boolean
 484 bfd_plugin_bfd_copy_private_symbol_data (bfd *ibfd ATTRIBUTE_UNUSED,
 485                                          asymbol *isymbol ATTRIBUTE_UNUSED,
 486                                          bfd *obfd ATTRIBUTE_UNUSED,
 487                                          asymbol *osymbol ATTRIBUTE_UNUSED)
 488 {
 489   BFD_ASSERT (0);
 490   return TRUE;
 491 }
 492
 493 static bfd_boolean
 494 bfd_plugin_bfd_print_private_bfd_data (bfd *abfd ATTRIBUTE_UNUSED, PTR ptr ATTRIBUTE_UNUSED)
 495 {
 496   BFD_ASSERT (0);
 497   return TRUE;
 498 }
 499
 500 static char *
 501 bfd_plugin_core_file_failing_command (bfd *abfd ATTRIBUTE_UNUSED)
 502 {
 503   BFD_ASSERT (0);
 504   return NULL;
 505 }
 506
 507 static int
 508 bfd_plugin_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED)
 509 {
 510   BFD_ASSERT (0);
 511   return 0;
 512 }
 513
 514 static int
 515 bfd_plugin_core_file_pid (bfd *abfd ATTRIBUTE_UNUSED)
 516 {
 517   BFD_ASSERT (0);
 518   return 0;
 519 }
 520
 521 static long
 522 bfd_plugin_get_symtab_upper_bound (bfd *abfd)
 523 {
 524   struct plugin_data_struct *plugin_data = abfd->tdata.plugin_data;
 525   long nsyms = plugin_data->nsyms;
 526
 527   BFD_ASSERT (nsyms >= 0);
 528
 529   return ((nsyms + 1) * sizeof (asymbol *));
 530 }
 531
 532 static flagword
 533 convert_flags (const struct ld_plugin_symbol *sym)
 534 {
 535  switch (sym->def)
 536    {
 537    case LDPK_DEF:
 538    case LDPK_COMMON:
 539    case LDPK_UNDEF:
 540      return BSF_GLOBAL;
 541
 542    case LDPK_WEAKUNDEF:
 543    case LDPK_WEAKDEF:
 544      return BSF_GLOBAL | BSF_WEAK;
 545
 546    default:
 547      BFD_ASSERT (0);
 548      return 0;
 549    }
 550 }
 551
 552 static long
 553 bfd_plugin_canonicalize_symtab (bfd *abfd,
 554                                 asymbol **alocation)
 555 {
 556   struct plugin_data_struct *plugin_data = abfd->tdata.plugin_data;
 557   long nsyms = plugin_data->nsyms;
 558   const struct ld_plugin_symbol *syms = plugin_data->syms;
 559   static asection fake_section
 560     = BFD_FAKE_SECTION (fake_section, NULL, "plug", 0,
 561                         SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS);
 562   static asection fake_common_section
 563     = BFD_FAKE_SECTION (fake_common_section, NULL, "plug", 0, SEC_IS_COMMON);
 564   int i;
 565
 566   for (i = 0; i < nsyms; i++)
 567     {
 568       asymbol *s = bfd_alloc (abfd, sizeof (asymbol));
 569
 570       BFD_ASSERT (s);
 571       alocation[i] = s;
 572
 573       s->the_bfd = abfd;
 574       s->name = syms[i].name;
 575       s->value = 0;
 576       s->flags = convert_flags (&syms[i]);
 577       switch (syms[i].def)
 578         {
 579         case LDPK_COMMON:
 580           s->section = &fake_common_section;
 581           break;
 582         case LDPK_UNDEF:
 583         case LDPK_WEAKUNDEF:
 584           s->section = bfd_und_section_ptr;
 585           break;
 586         case LDPK_DEF:
 587         case LDPK_WEAKDEF:
 588           s->section = &fake_section;
 589           break;
 590         default:
 591           BFD_ASSERT (0);
 592         }
 593
 594       s->udata.p = (void *) &syms[i];
 595     }
 596
 597   return nsyms;
 598 }
 599
 600 static void
 601 bfd_plugin_print_symbol (bfd *abfd ATTRIBUTE_UNUSED,
 602                          PTR afile ATTRIBUTE_UNUSED,
 603                          asymbol *symbol ATTRIBUTE_UNUSED,
 604                          bfd_print_symbol_type how ATTRIBUTE_UNUSED)
 605 {
 606   BFD_ASSERT (0);
 607 }
 608
 609 static void
 610 bfd_plugin_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
 611                             asymbol *symbol,
 612                             symbol_info *ret)
 613 {
 614   bfd_symbol_info (symbol, ret);
 615 }
 616
 617 /* Make an empty symbol. */
 618
 619 static asymbol *
 620 bfd_plugin_make_empty_symbol (bfd *abfd)
 621 {
 622   asymbol *new_symbol = bfd_zalloc (abfd, sizeof (asymbol));
 623   if (new_symbol == NULL)
 624     return new_symbol;
 625   new_symbol->the_bfd = abfd;
 626   return new_symbol;
 627 }
 628
 629 static int
 630 bfd_plugin_sizeof_headers (bfd *a ATTRIBUTE_UNUSED,
 631                            struct bfd_link_info *info ATTRIBUTE_UNUSED)
 632 {
 633   BFD_ASSERT (0);
 634   return 0;
 635 }
 636
 637 const bfd_target plugin_vec =
 638 {
 639   "plugin",                     /* Name.  */
 640   bfd_target_unknown_flavour,
 641   BFD_ENDIAN_LITTLE,            /* Target byte order.  */
 642   BFD_ENDIAN_LITTLE,            /* Target headers byte order.  */
 643   (HAS_RELOC | EXEC_P |         /* Object flags.  */
 644    HAS_LINENO | HAS_DEBUG |
 645    HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
 646   (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
 647    | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags.  */
 648   0,                            /* symbol_leading_char.  */
 649   '/',                          /* ar_pad_char.  */
 650   15,                           /* ar_max_namelen.  */
 651   255,                          /* match priority.  */
 652
 653   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 654   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 655   bfd_getl16, bfd_getl_signed_16, bfd_putl16,   /* data */
 656   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 657   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 658   bfd_getl16, bfd_getl_signed_16, bfd_putl16,   /* hdrs */
 659
 660   {                             /* bfd_check_format.  */
 661     _bfd_dummy_target,
 662     bfd_plugin_object_p,
 663     bfd_generic_archive_p,
 664     _bfd_dummy_target
 665   },
 666   {                             /* bfd_set_format.  */
 667     _bfd_bool_bfd_false_error,
 668     _bfd_bool_bfd_false_error,
 669     _bfd_generic_mkarchive,
 670     _bfd_bool_bfd_false_error,
 671   },
 672   {                             /* bfd_write_contents.  */
 673     _bfd_bool_bfd_false_error,
 674     _bfd_bool_bfd_false_error,
 675     _bfd_write_archive_contents,
 676     _bfd_bool_bfd_false_error,
 677   },
 678
 679   BFD_JUMP_TABLE_GENERIC (bfd_plugin),
 680   BFD_JUMP_TABLE_COPY (bfd_plugin),
 681   BFD_JUMP_TABLE_CORE (bfd_plugin),
 682 #ifdef USE_64_BIT_ARCHIVE
 683   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_64_bit),
 684 #else
 685   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
 686 #endif
 687   BFD_JUMP_TABLE_SYMBOLS (bfd_plugin),
 688   BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
 689   BFD_JUMP_TABLE_WRITE (bfd_plugin),
 690   BFD_JUMP_TABLE_LINK (bfd_plugin),
 691   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 692
 693   NULL,
 694
 695   NULL                          /* backend_data.  */
 696 };
 697 #endif /* BFD_SUPPORTS_PLUGIN */