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