1 /* Plugin support for BFD. 2 Copyright (C) 2009-2020 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 /* The intent was to search ${libdir}/bfd-plugins for plugins, but 371 unfortunately the original implementation wasn't precisely that 372 when configuring binutils using --libdir. Search in the proper 373 path first, then the old one for backwards compatibility. */ 374 static const char *path[] 375 = { PLUGINLIBDIR "/bfd-plugins", BINDIR RELPLUGINDIR}; 376 struct stat last_st; 377 int found = 0; 378 unsigned int i; 379 380 if (!has_plugin) 381 return found; 382 383 if (plugin_name) 384 return try_load_plugin (plugin_name, abfd, &has_plugin); 385 386 if (plugin_program_name == NULL) 387 return found; 388 389 /* Try not to search the same dir twice, by looking at st_dev and 390 st_ino for the dir. If we are on a file system that always sets 391 st_ino to zero or the actual st_ino is zero we might waste some 392 time, but that doesn't matter too much. */ 393 last_st.st_dev = 0; 394 last_st.st_ino = 0; 395 for (i = 0; i < sizeof (path) / sizeof (path[0]); i++) 396 { 397 char *plugin_dir = make_relative_prefix (plugin_program_name, 398 BINDIR, 399 path[i]); 400 if (plugin_dir) 401 { 402 struct stat st; 403 DIR *d; 404 405 if (stat (plugin_dir, &st) == 0 406 && S_ISDIR (st.st_mode) 407 && !(last_st.st_dev == st.st_dev 408 && last_st.st_ino == st.st_ino 409 && st.st_ino != 0) 410 && (d = opendir (plugin_dir)) != NULL) 411 { 412 struct dirent *ent; 413 414 last_st.st_dev = st.st_dev; 415 last_st.st_ino = st.st_ino; 416 while ((ent = readdir (d)) != NULL) 417 { 418 char *full_name; 419 420 full_name = concat (plugin_dir, "/", ent->d_name, NULL); 421 if (stat (full_name, &st) == 0 && S_ISREG (st.st_mode)) 422 { 423 int valid_plugin; 424 425 found = try_load_plugin (full_name, abfd, &valid_plugin); 426 if (has_plugin <= 0) 427 has_plugin = valid_plugin; 428 } 429 free (full_name); 430 if (found) 431 break; 432 } 433 closedir (d); 434 } 435 free (plugin_dir); 436 } 437 if (found) 438 break; 439 } 440 441 return found; 442 } 443 444 445 static const bfd_target * 446 bfd_plugin_object_p (bfd *abfd) 447 { 448 if (ld_plugin_object_p) 449 return ld_plugin_object_p (abfd); 450 451 if (abfd->plugin_format == bfd_plugin_unknown && !load_plugin (abfd)) 452 return NULL; 453 454 return abfd->plugin_format == bfd_plugin_yes ? abfd->xvec : NULL; 455 } 456 457 /* Copy any private info we understand from the input bfd 458 to the output bfd. */ 459 460 static bfd_boolean 461 bfd_plugin_bfd_copy_private_bfd_data (bfd *ibfd ATTRIBUTE_UNUSED, 462 bfd *obfd ATTRIBUTE_UNUSED) 463 { 464 BFD_ASSERT (0); 465 return TRUE; 466 } 467 468 /* Copy any private info we understand from the input section 469 to the output section. */ 470 471 static bfd_boolean 472 bfd_plugin_bfd_copy_private_section_data (bfd *ibfd ATTRIBUTE_UNUSED, 473 asection *isection ATTRIBUTE_UNUSED, 474 bfd *obfd ATTRIBUTE_UNUSED, 475 asection *osection ATTRIBUTE_UNUSED) 476 { 477 BFD_ASSERT (0); 478 return TRUE; 479 } 480 481 /* Copy any private info we understand from the input symbol 482 to the output symbol. */ 483 484 static bfd_boolean 485 bfd_plugin_bfd_copy_private_symbol_data (bfd *ibfd ATTRIBUTE_UNUSED, 486 asymbol *isymbol ATTRIBUTE_UNUSED, 487 bfd *obfd ATTRIBUTE_UNUSED, 488 asymbol *osymbol ATTRIBUTE_UNUSED) 489 { 490 BFD_ASSERT (0); 491 return TRUE; 492 } 493 494 static bfd_boolean 495 bfd_plugin_bfd_print_private_bfd_data (bfd *abfd ATTRIBUTE_UNUSED, PTR ptr ATTRIBUTE_UNUSED) 496 { 497 BFD_ASSERT (0); 498 return TRUE; 499 } 500 501 static char * 502 bfd_plugin_core_file_failing_command (bfd *abfd ATTRIBUTE_UNUSED) 503 { 504 BFD_ASSERT (0); 505 return NULL; 506 } 507 508 static int 509 bfd_plugin_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED) 510 { 511 BFD_ASSERT (0); 512 return 0; 513 } 514 515 static int 516 bfd_plugin_core_file_pid (bfd *abfd ATTRIBUTE_UNUSED) 517 { 518 BFD_ASSERT (0); 519 return 0; 520 } 521 522 static long 523 bfd_plugin_get_symtab_upper_bound (bfd *abfd) 524 { 525 struct plugin_data_struct *plugin_data = abfd->tdata.plugin_data; 526 long nsyms = plugin_data->nsyms; 527 528 BFD_ASSERT (nsyms >= 0); 529 530 return ((nsyms + 1) * sizeof (asymbol *)); 531 } 532 533 static flagword 534 convert_flags (const struct ld_plugin_symbol *sym) 535 { 536 switch (sym->def) 537 { 538 case LDPK_DEF: 539 case LDPK_COMMON: 540 case LDPK_UNDEF: 541 return BSF_GLOBAL; 542 543 case LDPK_WEAKUNDEF: 544 case LDPK_WEAKDEF: 545 return BSF_GLOBAL | BSF_WEAK; 546 547 default: 548 BFD_ASSERT (0); 549 return 0; 550 } 551 } 552 553 static long 554 bfd_plugin_canonicalize_symtab (bfd *abfd, 555 asymbol **alocation) 556 { 557 struct plugin_data_struct *plugin_data = abfd->tdata.plugin_data; 558 long nsyms = plugin_data->nsyms; 559 const struct ld_plugin_symbol *syms = plugin_data->syms; 560 static asection fake_section 561 = BFD_FAKE_SECTION (fake_section, NULL, "plug", 0, 562 SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS); 563 static asection fake_common_section 564 = BFD_FAKE_SECTION (fake_common_section, NULL, "plug", 0, SEC_IS_COMMON); 565 int i; 566 567 for (i = 0; i < nsyms; i++) 568 { 569 asymbol *s = bfd_alloc (abfd, sizeof (asymbol)); 570 571 BFD_ASSERT (s); 572 alocation[i] = s; 573 574 s->the_bfd = abfd; 575 s->name = syms[i].name; 576 s->value = 0; 577 s->flags = convert_flags (&syms[i]); 578 switch (syms[i].def) 579 { 580 case LDPK_COMMON: 581 s->section = &fake_common_section; 582 break; 583 case LDPK_UNDEF: 584 case LDPK_WEAKUNDEF: 585 s->section = bfd_und_section_ptr; 586 break; 587 case LDPK_DEF: 588 case LDPK_WEAKDEF: 589 s->section = &fake_section; 590 break; 591 default: 592 BFD_ASSERT (0); 593 } 594 595 s->udata.p = (void *) &syms[i]; 596 } 597 598 return nsyms; 599 } 600 601 static void 602 bfd_plugin_print_symbol (bfd *abfd ATTRIBUTE_UNUSED, 603 PTR afile ATTRIBUTE_UNUSED, 604 asymbol *symbol ATTRIBUTE_UNUSED, 605 bfd_print_symbol_type how ATTRIBUTE_UNUSED) 606 { 607 BFD_ASSERT (0); 608 } 609 610 static void 611 bfd_plugin_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED, 612 asymbol *symbol, 613 symbol_info *ret) 614 { 615 bfd_symbol_info (symbol, ret); 616 } 617 618 /* Make an empty symbol. */ 619 620 static asymbol * 621 bfd_plugin_make_empty_symbol (bfd *abfd) 622 { 623 asymbol *new_symbol = bfd_zalloc (abfd, sizeof (asymbol)); 624 if (new_symbol == NULL) 625 return new_symbol; 626 new_symbol->the_bfd = abfd; 627 return new_symbol; 628 } 629 630 static int 631 bfd_plugin_sizeof_headers (bfd *a ATTRIBUTE_UNUSED, 632 struct bfd_link_info *info ATTRIBUTE_UNUSED) 633 { 634 BFD_ASSERT (0); 635 return 0; 636 } 637 638 const bfd_target plugin_vec = 639 { 640 "plugin", /* Name. */ 641 bfd_target_unknown_flavour, 642 BFD_ENDIAN_LITTLE, /* Target byte order. */ 643 BFD_ENDIAN_LITTLE, /* Target headers byte order. */ 644 (HAS_RELOC | EXEC_P | /* Object flags. */ 645 HAS_LINENO | HAS_DEBUG | 646 HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED), 647 (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS 648 | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags. */ 649 0, /* symbol_leading_char. */ 650 '/', /* ar_pad_char. */ 651 15, /* ar_max_namelen. */ 652 255, /* match priority. */ 653 654 bfd_getl64, bfd_getl_signed_64, bfd_putl64, 655 bfd_getl32, bfd_getl_signed_32, bfd_putl32, 656 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */ 657 bfd_getl64, bfd_getl_signed_64, bfd_putl64, 658 bfd_getl32, bfd_getl_signed_32, bfd_putl32, 659 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */ 660 661 { /* bfd_check_format. */ 662 _bfd_dummy_target, 663 bfd_plugin_object_p, 664 bfd_generic_archive_p, 665 _bfd_dummy_target 666 }, 667 { /* bfd_set_format. */ 668 _bfd_bool_bfd_false_error, 669 _bfd_bool_bfd_false_error, 670 _bfd_generic_mkarchive, 671 _bfd_bool_bfd_false_error, 672 }, 673 { /* bfd_write_contents. */ 674 _bfd_bool_bfd_false_error, 675 _bfd_bool_bfd_false_error, 676 _bfd_write_archive_contents, 677 _bfd_bool_bfd_false_error, 678 }, 679 680 BFD_JUMP_TABLE_GENERIC (bfd_plugin), 681 BFD_JUMP_TABLE_COPY (bfd_plugin), 682 BFD_JUMP_TABLE_CORE (bfd_plugin), 683 #ifdef USE_64_BIT_ARCHIVE 684 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_64_bit), 685 #else 686 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), 687 #endif 688 BFD_JUMP_TABLE_SYMBOLS (bfd_plugin), 689 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs), 690 BFD_JUMP_TABLE_WRITE (bfd_plugin), 691 BFD_JUMP_TABLE_LINK (bfd_plugin), 692 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), 693 694 NULL, 695 696 NULL /* backend_data. */ 697 }; 698 #endif /* BFD_SUPPORTS_PLUGIN */ 699