1 /* Plugin support for BFD. 2 Copyright (C) 2009-2018 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; 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 if (fstat (file->fd, &stat_buf)) 190 return 0; 191 file->offset = 0; 192 file->filesize = stat_buf.st_size; 193 } 194 else 195 { 196 file->offset = ibfd->origin; 197 file->filesize = arelt_size (ibfd); 198 } 199 return 1; 200 } 201 202 static int 203 try_claim (bfd *abfd) 204 { 205 int claimed = 0; 206 struct ld_plugin_input_file file; 207 208 file.handle = abfd; 209 if (!bfd_plugin_open_input (abfd, &file)) 210 return 0; 211 claim_file (&file, &claimed); 212 if (!claimed) 213 close (file.fd); 214 return claimed; 215 } 216 217 static int 218 try_load_plugin (const char *pname, bfd *abfd, int *has_plugin_p) 219 { 220 void *plugin_handle; 221 struct ld_plugin_tv tv[4]; 222 int i; 223 ld_plugin_onload onload; 224 enum ld_plugin_status status; 225 226 *has_plugin_p = 0; 227 228 plugin_handle = dlopen (pname, RTLD_NOW); 229 if (!plugin_handle) 230 { 231 _bfd_error_handler ("%s\n", dlerror ()); 232 return 0; 233 } 234 235 onload = dlsym (plugin_handle, "onload"); 236 if (!onload) 237 goto err; 238 239 i = 0; 240 tv[i].tv_tag = LDPT_MESSAGE; 241 tv[i].tv_u.tv_message = message; 242 243 ++i; 244 tv[i].tv_tag = LDPT_REGISTER_CLAIM_FILE_HOOK; 245 tv[i].tv_u.tv_register_claim_file = register_claim_file; 246 247 ++i; 248 tv[i].tv_tag = LDPT_ADD_SYMBOLS; 249 tv[i].tv_u.tv_add_symbols = add_symbols; 250 251 ++i; 252 tv[i].tv_tag = LDPT_NULL; 253 tv[i].tv_u.tv_val = 0; 254 255 status = (*onload)(tv); 256 257 if (status != LDPS_OK) 258 goto err; 259 260 *has_plugin_p = 1; 261 262 abfd->plugin_format = bfd_plugin_no; 263 264 if (!claim_file) 265 goto err; 266 267 if (!try_claim (abfd)) 268 goto err; 269 270 abfd->plugin_format = bfd_plugin_yes; 271 272 return 1; 273 274 err: 275 return 0; 276 } 277 278 /* There may be plugin libraries in lib/bfd-plugins. */ 279 280 static int has_plugin = -1; 281 282 static const bfd_target *(*ld_plugin_object_p) (bfd *); 283 284 static const char *plugin_name; 285 286 void 287 bfd_plugin_set_plugin (const char *p) 288 { 289 plugin_name = p; 290 has_plugin = p != NULL; 291 } 292 293 /* Return TRUE if a plugin library is used. */ 294 295 bfd_boolean 296 bfd_plugin_specified_p (void) 297 { 298 return has_plugin > 0; 299 } 300 301 /* Return TRUE if ABFD can be claimed by linker LTO plugin. */ 302 303 bfd_boolean 304 bfd_link_plugin_object_p (bfd *abfd) 305 { 306 if (ld_plugin_object_p) 307 return ld_plugin_object_p (abfd) != NULL; 308 return FALSE; 309 } 310 311 extern const bfd_target plugin_vec; 312 313 /* Return TRUE if TARGET is a pointer to plugin_vec. */ 314 315 bfd_boolean 316 bfd_plugin_target_p (const bfd_target *target) 317 { 318 return target == &plugin_vec; 319 } 320 321 /* Register OBJECT_P to be used by bfd_plugin_object_p. */ 322 323 void 324 register_ld_plugin_object_p (const bfd_target *(*object_p) (bfd *)) 325 { 326 ld_plugin_object_p = object_p; 327 } 328 329 static int 330 load_plugin (bfd *abfd) 331 { 332 char *plugin_dir; 333 char *p; 334 DIR *d; 335 struct dirent *ent; 336 int found = 0; 337 338 if (!has_plugin) 339 return found; 340 341 if (plugin_name) 342 return try_load_plugin (plugin_name, abfd, &has_plugin); 343 344 if (plugin_program_name == NULL) 345 return found; 346 347 plugin_dir = concat (BINDIR, "/../lib/bfd-plugins", NULL); 348 p = make_relative_prefix (plugin_program_name, 349 BINDIR, 350 plugin_dir); 351 free (plugin_dir); 352 plugin_dir = NULL; 353 354 d = opendir (p); 355 if (!d) 356 goto out; 357 358 while ((ent = readdir (d))) 359 { 360 char *full_name; 361 struct stat s; 362 int valid_plugin; 363 364 full_name = concat (p, "/", ent->d_name, NULL); 365 if (stat(full_name, &s) == 0 && S_ISREG (s.st_mode)) 366 found = try_load_plugin (full_name, abfd, &valid_plugin); 367 if (has_plugin <= 0) 368 has_plugin = valid_plugin; 369 free (full_name); 370 if (found) 371 break; 372 } 373 374 out: 375 free (p); 376 if (d) 377 closedir (d); 378 379 return found; 380 } 381 382 383 static const bfd_target * 384 bfd_plugin_object_p (bfd *abfd) 385 { 386 if (ld_plugin_object_p) 387 return ld_plugin_object_p (abfd); 388 389 if (abfd->plugin_format == bfd_plugin_unknown && !load_plugin (abfd)) 390 return NULL; 391 392 return abfd->plugin_format == bfd_plugin_yes ? abfd->xvec : NULL; 393 } 394 395 /* Copy any private info we understand from the input bfd 396 to the output bfd. */ 397 398 static bfd_boolean 399 bfd_plugin_bfd_copy_private_bfd_data (bfd *ibfd ATTRIBUTE_UNUSED, 400 bfd *obfd ATTRIBUTE_UNUSED) 401 { 402 BFD_ASSERT (0); 403 return TRUE; 404 } 405 406 /* Copy any private info we understand from the input section 407 to the output section. */ 408 409 static bfd_boolean 410 bfd_plugin_bfd_copy_private_section_data (bfd *ibfd ATTRIBUTE_UNUSED, 411 asection *isection ATTRIBUTE_UNUSED, 412 bfd *obfd ATTRIBUTE_UNUSED, 413 asection *osection ATTRIBUTE_UNUSED) 414 { 415 BFD_ASSERT (0); 416 return TRUE; 417 } 418 419 /* Copy any private info we understand from the input symbol 420 to the output symbol. */ 421 422 static bfd_boolean 423 bfd_plugin_bfd_copy_private_symbol_data (bfd *ibfd ATTRIBUTE_UNUSED, 424 asymbol *isymbol ATTRIBUTE_UNUSED, 425 bfd *obfd ATTRIBUTE_UNUSED, 426 asymbol *osymbol ATTRIBUTE_UNUSED) 427 { 428 BFD_ASSERT (0); 429 return TRUE; 430 } 431 432 static bfd_boolean 433 bfd_plugin_bfd_print_private_bfd_data (bfd *abfd ATTRIBUTE_UNUSED, PTR ptr ATTRIBUTE_UNUSED) 434 { 435 BFD_ASSERT (0); 436 return TRUE; 437 } 438 439 static char * 440 bfd_plugin_core_file_failing_command (bfd *abfd ATTRIBUTE_UNUSED) 441 { 442 BFD_ASSERT (0); 443 return NULL; 444 } 445 446 static int 447 bfd_plugin_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED) 448 { 449 BFD_ASSERT (0); 450 return 0; 451 } 452 453 static int 454 bfd_plugin_core_file_pid (bfd *abfd ATTRIBUTE_UNUSED) 455 { 456 BFD_ASSERT (0); 457 return 0; 458 } 459 460 static long 461 bfd_plugin_get_symtab_upper_bound (bfd *abfd) 462 { 463 struct plugin_data_struct *plugin_data = abfd->tdata.plugin_data; 464 long nsyms = plugin_data->nsyms; 465 466 BFD_ASSERT (nsyms >= 0); 467 468 return ((nsyms + 1) * sizeof (asymbol *)); 469 } 470 471 static flagword 472 convert_flags (const struct ld_plugin_symbol *sym) 473 { 474 switch (sym->def) 475 { 476 case LDPK_DEF: 477 case LDPK_COMMON: 478 case LDPK_UNDEF: 479 return BSF_GLOBAL; 480 481 case LDPK_WEAKUNDEF: 482 case LDPK_WEAKDEF: 483 return BSF_GLOBAL | BSF_WEAK; 484 485 default: 486 BFD_ASSERT (0); 487 return 0; 488 } 489 } 490 491 static long 492 bfd_plugin_canonicalize_symtab (bfd *abfd, 493 asymbol **alocation) 494 { 495 struct plugin_data_struct *plugin_data = abfd->tdata.plugin_data; 496 long nsyms = plugin_data->nsyms; 497 const struct ld_plugin_symbol *syms = plugin_data->syms; 498 static asection fake_section; 499 static asection fake_common_section; 500 int i; 501 502 fake_section.name = ".text"; 503 fake_common_section.flags = SEC_IS_COMMON; 504 505 for (i = 0; i < nsyms; i++) 506 { 507 asymbol *s = bfd_alloc (abfd, sizeof (asymbol)); 508 509 BFD_ASSERT (s); 510 alocation[i] = s; 511 512 s->the_bfd = abfd; 513 s->name = syms[i].name; 514 s->value = 0; 515 s->flags = convert_flags (&syms[i]); 516 switch (syms[i].def) 517 { 518 case LDPK_COMMON: 519 s->section = &fake_common_section; 520 break; 521 case LDPK_UNDEF: 522 case LDPK_WEAKUNDEF: 523 s->section = bfd_und_section_ptr; 524 break; 525 case LDPK_DEF: 526 case LDPK_WEAKDEF: 527 s->section = &fake_section; 528 break; 529 default: 530 BFD_ASSERT (0); 531 } 532 533 s->udata.p = (void *) &syms[i]; 534 } 535 536 return nsyms; 537 } 538 539 static void 540 bfd_plugin_print_symbol (bfd *abfd ATTRIBUTE_UNUSED, 541 PTR afile ATTRIBUTE_UNUSED, 542 asymbol *symbol ATTRIBUTE_UNUSED, 543 bfd_print_symbol_type how ATTRIBUTE_UNUSED) 544 { 545 BFD_ASSERT (0); 546 } 547 548 static void 549 bfd_plugin_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED, 550 asymbol *symbol, 551 symbol_info *ret) 552 { 553 bfd_symbol_info (symbol, ret); 554 } 555 556 /* Make an empty symbol. */ 557 558 static asymbol * 559 bfd_plugin_make_empty_symbol (bfd *abfd) 560 { 561 asymbol *new_symbol = bfd_zalloc (abfd, sizeof (asymbol)); 562 if (new_symbol == NULL) 563 return new_symbol; 564 new_symbol->the_bfd = abfd; 565 return new_symbol; 566 } 567 568 static int 569 bfd_plugin_sizeof_headers (bfd *a ATTRIBUTE_UNUSED, 570 struct bfd_link_info *info ATTRIBUTE_UNUSED) 571 { 572 BFD_ASSERT (0); 573 return 0; 574 } 575 576 const bfd_target plugin_vec = 577 { 578 "plugin", /* Name. */ 579 bfd_target_unknown_flavour, 580 BFD_ENDIAN_LITTLE, /* Target byte order. */ 581 BFD_ENDIAN_LITTLE, /* Target headers byte order. */ 582 (HAS_RELOC | EXEC_P | /* Object flags. */ 583 HAS_LINENO | HAS_DEBUG | 584 HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED), 585 (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS 586 | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags. */ 587 0, /* symbol_leading_char. */ 588 '/', /* ar_pad_char. */ 589 15, /* ar_max_namelen. */ 590 255, /* match priority. */ 591 592 bfd_getl64, bfd_getl_signed_64, bfd_putl64, 593 bfd_getl32, bfd_getl_signed_32, bfd_putl32, 594 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */ 595 bfd_getl64, bfd_getl_signed_64, bfd_putl64, 596 bfd_getl32, bfd_getl_signed_32, bfd_putl32, 597 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */ 598 599 { /* bfd_check_format. */ 600 _bfd_dummy_target, 601 bfd_plugin_object_p, 602 bfd_generic_archive_p, 603 _bfd_dummy_target 604 }, 605 { /* bfd_set_format. */ 606 _bfd_bool_bfd_false_error, 607 _bfd_bool_bfd_false_error, 608 _bfd_generic_mkarchive, 609 _bfd_bool_bfd_false_error, 610 }, 611 { /* bfd_write_contents. */ 612 _bfd_bool_bfd_false_error, 613 _bfd_bool_bfd_false_error, 614 _bfd_write_archive_contents, 615 _bfd_bool_bfd_false_error, 616 }, 617 618 BFD_JUMP_TABLE_GENERIC (bfd_plugin), 619 BFD_JUMP_TABLE_COPY (bfd_plugin), 620 BFD_JUMP_TABLE_CORE (bfd_plugin), 621 #ifdef USE_64_BIT_ARCHIVE 622 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_64_bit), 623 #else 624 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), 625 #endif 626 BFD_JUMP_TABLE_SYMBOLS (bfd_plugin), 627 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs), 628 BFD_JUMP_TABLE_WRITE (bfd_plugin), 629 BFD_JUMP_TABLE_LINK (bfd_plugin), 630 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), 631 632 NULL, 633 634 NULL /* backend_data. */ 635 }; 636 #endif /* BFD_SUPPORTS_PLUGIN */ 637