1 /* Plugin control for the GNU linker. 2 Copyright (C) 2010-2016 Free Software Foundation, Inc. 3 4 This file is part of the GNU Binutils. 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 "libiberty.h" 23 #include "bfd.h" 24 #include "libbfd.h" 25 #include "bfdlink.h" 26 #include "bfdver.h" 27 #include "ld.h" 28 #include "ldmain.h" 29 #include "ldmisc.h" 30 #include "ldexp.h" 31 #include "ldlang.h" 32 #include "ldfile.h" 33 #include "../bfd/plugin.h" 34 #include "plugin.h" 35 #include "plugin-api.h" 36 #include "elf-bfd.h" 37 #if HAVE_MMAP 38 # include <sys/mman.h> 39 # ifndef MAP_FAILED 40 # define MAP_FAILED ((void *) -1) 41 # endif 42 # ifndef PROT_READ 43 # define PROT_READ 0 44 # endif 45 # ifndef MAP_PRIVATE 46 # define MAP_PRIVATE 0 47 # endif 48 #endif 49 #include <errno.h> 50 #if !(defined(errno) || defined(_MSC_VER) && defined(_INC_ERRNO)) 51 extern int errno; 52 #endif 53 #if !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H) 54 #include <windows.h> 55 #endif 56 57 /* Report plugin symbols. */ 58 bfd_boolean report_plugin_symbols; 59 60 /* The suffix to append to the name of the real (claimed) object file 61 when generating a dummy BFD to hold the IR symbols sent from the 62 plugin. For cosmetic use only; appears in maps, crefs etc. */ 63 #define IRONLY_SUFFIX " (symbol from plugin)" 64 65 /* Stores a single argument passed to a plugin. */ 66 typedef struct plugin_arg 67 { 68 struct plugin_arg *next; 69 const char *arg; 70 } plugin_arg_t; 71 72 /* Holds all details of a single plugin. */ 73 typedef struct plugin 74 { 75 /* Next on the list of plugins, or NULL at end of chain. */ 76 struct plugin *next; 77 /* The argument string given to --plugin. */ 78 const char *name; 79 /* The shared library handle returned by dlopen. */ 80 void *dlhandle; 81 /* The list of argument string given to --plugin-opt. */ 82 plugin_arg_t *args; 83 /* Number of args in the list, for convenience. */ 84 size_t n_args; 85 /* The plugin's event handlers. */ 86 ld_plugin_claim_file_handler claim_file_handler; 87 ld_plugin_all_symbols_read_handler all_symbols_read_handler; 88 ld_plugin_cleanup_handler cleanup_handler; 89 /* TRUE if the cleanup handlers have been called. */ 90 bfd_boolean cleanup_done; 91 } plugin_t; 92 93 typedef struct view_buffer 94 { 95 char *addr; 96 size_t filesize; 97 off_t offset; 98 } view_buffer_t; 99 100 /* The internal version of struct ld_plugin_input_file with a BFD 101 pointer. */ 102 typedef struct plugin_input_file 103 { 104 bfd *abfd; 105 view_buffer_t view_buffer; 106 char *name; 107 int fd; 108 bfd_boolean use_mmap; 109 off_t offset; 110 off_t filesize; 111 } plugin_input_file_t; 112 113 /* The master list of all plugins. */ 114 static plugin_t *plugins_list = NULL; 115 116 /* We keep a tail pointer for easy linking on the end. */ 117 static plugin_t **plugins_tail_chain_ptr = &plugins_list; 118 119 /* The last plugin added to the list, for receiving args. */ 120 static plugin_t *last_plugin = NULL; 121 122 /* The tail of the arg chain of the last plugin added to the list. */ 123 static plugin_arg_t **last_plugin_args_tail_chain_ptr = NULL; 124 125 /* The plugin which is currently having a callback executed. */ 126 static plugin_t *called_plugin = NULL; 127 128 /* Last plugin to cause an error, if any. */ 129 static const char *error_plugin = NULL; 130 131 /* State of linker "notice" interface before we poked at it. */ 132 static bfd_boolean orig_notice_all; 133 134 /* Original linker callbacks, and the plugin version. */ 135 static const struct bfd_link_callbacks *orig_callbacks; 136 static struct bfd_link_callbacks plugin_callbacks; 137 138 /* Set at all symbols read time, to avoid recursively offering the plugin 139 its own newly-added input files and libs to claim. */ 140 bfd_boolean no_more_claiming = FALSE; 141 142 #if HAVE_MMAP && HAVE_GETPAGESIZE 143 /* Page size used by mmap. */ 144 static off_t plugin_pagesize; 145 #endif 146 147 /* List of tags to set in the constant leading part of the tv array. */ 148 static const enum ld_plugin_tag tv_header_tags[] = 149 { 150 LDPT_MESSAGE, 151 LDPT_API_VERSION, 152 LDPT_GNU_LD_VERSION, 153 LDPT_LINKER_OUTPUT, 154 LDPT_OUTPUT_NAME, 155 LDPT_REGISTER_CLAIM_FILE_HOOK, 156 LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK, 157 LDPT_REGISTER_CLEANUP_HOOK, 158 LDPT_ADD_SYMBOLS, 159 LDPT_GET_INPUT_FILE, 160 LDPT_GET_VIEW, 161 LDPT_RELEASE_INPUT_FILE, 162 LDPT_GET_SYMBOLS, 163 LDPT_GET_SYMBOLS_V2, 164 LDPT_ADD_INPUT_FILE, 165 LDPT_ADD_INPUT_LIBRARY, 166 LDPT_SET_EXTRA_LIBRARY_PATH 167 }; 168 169 /* How many entries in the constant leading part of the tv array. */ 170 static const size_t tv_header_size = ARRAY_SIZE (tv_header_tags); 171 172 /* Forward references. */ 173 static bfd_boolean plugin_notice (struct bfd_link_info *, 174 struct bfd_link_hash_entry *, 175 struct bfd_link_hash_entry *, 176 bfd *, asection *, bfd_vma, flagword); 177 178 static const bfd_target * plugin_object_p (bfd *); 179 180 #if !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H) 181 182 #define RTLD_NOW 0 /* Dummy value. */ 183 184 static void * 185 dlopen (const char *file, int mode ATTRIBUTE_UNUSED) 186 { 187 return LoadLibrary (file); 188 } 189 190 static void * 191 dlsym (void *handle, const char *name) 192 { 193 return GetProcAddress (handle, name); 194 } 195 196 static int 197 dlclose (void *handle) 198 { 199 FreeLibrary (handle); 200 return 0; 201 } 202 203 #endif /* !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H) */ 204 205 #ifndef HAVE_DLFCN_H 206 static const char * 207 dlerror (void) 208 { 209 return ""; 210 } 211 #endif 212 213 /* Helper function for exiting with error status. */ 214 static int 215 set_plugin_error (const char *plugin) 216 { 217 error_plugin = plugin; 218 return -1; 219 } 220 221 /* Test if an error occurred. */ 222 static bfd_boolean 223 plugin_error_p (void) 224 { 225 return error_plugin != NULL; 226 } 227 228 /* Return name of plugin which caused an error if any. */ 229 const char * 230 plugin_error_plugin (void) 231 { 232 return error_plugin ? error_plugin : _("<no plugin>"); 233 } 234 235 /* Handle -plugin arg: find and load plugin, or return error. */ 236 void 237 plugin_opt_plugin (const char *plugin) 238 { 239 plugin_t *newplug; 240 241 newplug = xmalloc (sizeof *newplug); 242 memset (newplug, 0, sizeof *newplug); 243 newplug->name = plugin; 244 newplug->dlhandle = dlopen (plugin, RTLD_NOW); 245 if (!newplug->dlhandle) 246 einfo (_("%P%F: %s: error loading plugin: %s\n"), plugin, dlerror ()); 247 248 /* Chain on end, so when we run list it is in command-line order. */ 249 *plugins_tail_chain_ptr = newplug; 250 plugins_tail_chain_ptr = &newplug->next; 251 252 /* Record it as current plugin for receiving args. */ 253 last_plugin = newplug; 254 last_plugin_args_tail_chain_ptr = &newplug->args; 255 } 256 257 /* Accumulate option arguments for last-loaded plugin, or return 258 error if none. */ 259 int 260 plugin_opt_plugin_arg (const char *arg) 261 { 262 plugin_arg_t *newarg; 263 264 if (!last_plugin) 265 return set_plugin_error (_("<no plugin>")); 266 267 /* Ignore -pass-through= from GCC driver. */ 268 if (*arg == '-') 269 { 270 const char *p = arg + 1; 271 272 if (*p == '-') 273 ++p; 274 if (strncmp (p, "pass-through=", 13) == 0) 275 return 0; 276 } 277 278 newarg = xmalloc (sizeof *newarg); 279 newarg->arg = arg; 280 newarg->next = NULL; 281 282 /* Chain on end to preserve command-line order. */ 283 *last_plugin_args_tail_chain_ptr = newarg; 284 last_plugin_args_tail_chain_ptr = &newarg->next; 285 last_plugin->n_args++; 286 return 0; 287 } 288 289 /* Generate a dummy BFD to represent an IR file, for any callers of 290 plugin_call_claim_file to use as the handle in the ld_plugin_input_file 291 struct that they build to pass in. The BFD is initially writable, so 292 that symbols can be added to it; it must be made readable after the 293 add_symbols hook has been called so that it can be read when linking. */ 294 static bfd * 295 plugin_get_ir_dummy_bfd (const char *name, bfd *srctemplate) 296 { 297 bfd *abfd; 298 bfd_boolean bfd_plugin_target; 299 300 bfd_use_reserved_id = 1; 301 bfd_plugin_target = bfd_plugin_target_p (srctemplate->xvec); 302 abfd = bfd_create (concat (name, IRONLY_SUFFIX, (const char *) NULL), 303 bfd_plugin_target ? link_info.output_bfd : srctemplate); 304 if (abfd != NULL) 305 { 306 abfd->flags |= BFD_LINKER_CREATED | BFD_PLUGIN; 307 if (!bfd_make_writable (abfd)) 308 goto report_error; 309 if (!bfd_plugin_target) 310 { 311 bfd_set_arch_info (abfd, bfd_get_arch_info (srctemplate)); 312 bfd_set_gp_size (abfd, bfd_get_gp_size (srctemplate)); 313 if (!bfd_copy_private_bfd_data (srctemplate, abfd)) 314 goto report_error; 315 } 316 { 317 flagword flags; 318 319 /* Create section to own the symbols. */ 320 flags = (SEC_CODE | SEC_HAS_CONTENTS | SEC_READONLY 321 | SEC_ALLOC | SEC_LOAD | SEC_KEEP | SEC_EXCLUDE); 322 if (bfd_make_section_anyway_with_flags (abfd, ".text", flags)) 323 return abfd; 324 } 325 } 326 report_error: 327 einfo (_("could not create dummy IR bfd: %F%E\n")); 328 return NULL; 329 } 330 331 /* Check if the BFD passed in is an IR dummy object file. */ 332 static inline bfd_boolean 333 is_ir_dummy_bfd (const bfd *abfd) 334 { 335 /* ABFD can sometimes legitimately be NULL, e.g. when called from one 336 of the linker callbacks for a symbol in the *ABS* or *UND* sections. */ 337 return abfd != NULL && (abfd->flags & BFD_PLUGIN) != 0; 338 } 339 340 /* Helpers to convert between BFD and GOLD symbol formats. */ 341 static enum ld_plugin_status 342 asymbol_from_plugin_symbol (bfd *abfd, asymbol *asym, 343 const struct ld_plugin_symbol *ldsym) 344 { 345 flagword flags = BSF_NO_FLAGS; 346 struct bfd_section *section; 347 348 asym->the_bfd = abfd; 349 asym->name = (ldsym->version 350 ? concat (ldsym->name, "@", ldsym->version, (const char *) NULL) 351 : ldsym->name); 352 asym->value = 0; 353 switch (ldsym->def) 354 { 355 case LDPK_WEAKDEF: 356 flags = BSF_WEAK; 357 /* FALLTHRU */ 358 case LDPK_DEF: 359 flags |= BSF_GLOBAL; 360 if (ldsym->comdat_key) 361 { 362 char *name = concat (".gnu.linkonce.t.", ldsym->comdat_key, 363 (const char *) NULL); 364 section = bfd_get_section_by_name (abfd, name); 365 if (section != NULL) 366 free (name); 367 else 368 { 369 flagword sflags; 370 371 sflags = (SEC_CODE | SEC_HAS_CONTENTS | SEC_READONLY 372 | SEC_ALLOC | SEC_LOAD | SEC_KEEP | SEC_EXCLUDE 373 | SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD); 374 section = bfd_make_section_anyway_with_flags (abfd, name, sflags); 375 if (section == NULL) 376 return LDPS_ERR; 377 } 378 } 379 else 380 section = bfd_get_section_by_name (abfd, ".text"); 381 break; 382 383 case LDPK_WEAKUNDEF: 384 flags = BSF_WEAK; 385 /* FALLTHRU */ 386 case LDPK_UNDEF: 387 section = bfd_und_section_ptr; 388 break; 389 390 case LDPK_COMMON: 391 flags = BSF_GLOBAL; 392 section = bfd_com_section_ptr; 393 asym->value = ldsym->size; 394 /* For ELF targets, set alignment of common symbol to 1. */ 395 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour) 396 { 397 ((elf_symbol_type *) asym)->internal_elf_sym.st_shndx = SHN_COMMON; 398 ((elf_symbol_type *) asym)->internal_elf_sym.st_value = 1; 399 } 400 break; 401 402 default: 403 return LDPS_ERR; 404 } 405 asym->flags = flags; 406 asym->section = section; 407 408 /* Visibility only applies on ELF targets. */ 409 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour) 410 { 411 elf_symbol_type *elfsym = elf_symbol_from (abfd, asym); 412 unsigned char visibility; 413 414 if (!elfsym) 415 einfo (_("%P%F: %s: non-ELF symbol in ELF BFD!\n"), asym->name); 416 switch (ldsym->visibility) 417 { 418 default: 419 einfo (_("%P%F: unknown ELF symbol visibility: %d!\n"), 420 ldsym->visibility); 421 case LDPV_DEFAULT: 422 visibility = STV_DEFAULT; 423 break; 424 case LDPV_PROTECTED: 425 visibility = STV_PROTECTED; 426 break; 427 case LDPV_INTERNAL: 428 visibility = STV_INTERNAL; 429 break; 430 case LDPV_HIDDEN: 431 visibility = STV_HIDDEN; 432 break; 433 } 434 elfsym->internal_elf_sym.st_other 435 = (visibility | (elfsym->internal_elf_sym.st_other 436 & ~ELF_ST_VISIBILITY (-1))); 437 } 438 439 return LDPS_OK; 440 } 441 442 /* Register a claim-file handler. */ 443 static enum ld_plugin_status 444 register_claim_file (ld_plugin_claim_file_handler handler) 445 { 446 ASSERT (called_plugin); 447 called_plugin->claim_file_handler = handler; 448 return LDPS_OK; 449 } 450 451 /* Register an all-symbols-read handler. */ 452 static enum ld_plugin_status 453 register_all_symbols_read (ld_plugin_all_symbols_read_handler handler) 454 { 455 ASSERT (called_plugin); 456 called_plugin->all_symbols_read_handler = handler; 457 return LDPS_OK; 458 } 459 460 /* Register a cleanup handler. */ 461 static enum ld_plugin_status 462 register_cleanup (ld_plugin_cleanup_handler handler) 463 { 464 ASSERT (called_plugin); 465 called_plugin->cleanup_handler = handler; 466 return LDPS_OK; 467 } 468 469 /* Add symbols from a plugin-claimed input file. */ 470 static enum ld_plugin_status 471 add_symbols (void *handle, int nsyms, const struct ld_plugin_symbol *syms) 472 { 473 asymbol **symptrs; 474 plugin_input_file_t *input = handle; 475 bfd *abfd = input->abfd; 476 int n; 477 478 ASSERT (called_plugin); 479 symptrs = xmalloc (nsyms * sizeof *symptrs); 480 for (n = 0; n < nsyms; n++) 481 { 482 enum ld_plugin_status rv; 483 asymbol *bfdsym; 484 485 bfdsym = bfd_make_empty_symbol (abfd); 486 symptrs[n] = bfdsym; 487 rv = asymbol_from_plugin_symbol (abfd, bfdsym, syms + n); 488 if (rv != LDPS_OK) 489 return rv; 490 } 491 bfd_set_symtab (abfd, symptrs, nsyms); 492 return LDPS_OK; 493 } 494 495 /* Get the input file information with an open (possibly re-opened) 496 file descriptor. */ 497 static enum ld_plugin_status 498 get_input_file (const void *handle, struct ld_plugin_input_file *file) 499 { 500 const plugin_input_file_t *input = handle; 501 502 ASSERT (called_plugin); 503 504 file->name = input->name; 505 file->offset = input->offset; 506 file->filesize = input->filesize; 507 file->handle = (void *) handle; 508 509 return LDPS_OK; 510 } 511 512 /* Get view of the input file. */ 513 static enum ld_plugin_status 514 get_view (const void *handle, const void **viewp) 515 { 516 plugin_input_file_t *input = (plugin_input_file_t *) handle; 517 char *buffer; 518 size_t size = input->filesize; 519 off_t offset = input->offset; 520 #if HAVE_MMAP && HAVE_GETPAGESIZE 521 off_t bias; 522 #endif 523 524 ASSERT (called_plugin); 525 526 /* FIXME: einfo should support %lld. */ 527 if ((off_t) size != input->filesize) 528 einfo (_("%P%F: unsupported input file size: %s (%ld bytes)\n"), 529 input->name, (long) input->filesize); 530 531 /* Check the cached view buffer. */ 532 if (input->view_buffer.addr != NULL 533 && input->view_buffer.filesize == size 534 && input->view_buffer.offset == offset) 535 { 536 *viewp = input->view_buffer.addr; 537 return LDPS_OK; 538 } 539 540 input->view_buffer.filesize = size; 541 input->view_buffer.offset = offset; 542 543 #if HAVE_MMAP 544 # if HAVE_GETPAGESIZE 545 bias = offset % plugin_pagesize; 546 offset -= bias; 547 size += bias; 548 # endif 549 buffer = mmap (NULL, size, PROT_READ, MAP_PRIVATE, input->fd, offset); 550 if (buffer != MAP_FAILED) 551 { 552 input->use_mmap = TRUE; 553 # if HAVE_GETPAGESIZE 554 buffer += bias; 555 # endif 556 } 557 else 558 #endif 559 { 560 char *p; 561 562 input->use_mmap = FALSE; 563 564 if (lseek (input->fd, offset, SEEK_SET) < 0) 565 return LDPS_ERR; 566 567 buffer = bfd_alloc (input->abfd, size); 568 if (buffer == NULL) 569 return LDPS_ERR; 570 571 p = buffer; 572 do 573 { 574 ssize_t got = read (input->fd, p, size); 575 if (got == 0) 576 break; 577 else if (got > 0) 578 { 579 p += got; 580 size -= got; 581 } 582 else if (errno != EINTR) 583 return LDPS_ERR; 584 } 585 while (size > 0); 586 } 587 588 input->view_buffer.addr = buffer; 589 *viewp = buffer; 590 591 return LDPS_OK; 592 } 593 594 /* Release the input file. */ 595 static enum ld_plugin_status 596 release_input_file (const void *handle) 597 { 598 plugin_input_file_t *input = (plugin_input_file_t *) handle; 599 ASSERT (called_plugin); 600 if (input->fd != -1) 601 { 602 close (input->fd); 603 input->fd = -1; 604 } 605 return LDPS_OK; 606 } 607 608 /* Return TRUE if a defined symbol might be reachable from outside the 609 universe of claimed objects. */ 610 static inline bfd_boolean 611 is_visible_from_outside (struct ld_plugin_symbol *lsym, 612 struct bfd_link_hash_entry *blhe) 613 { 614 struct bfd_sym_chain *sym; 615 616 if (bfd_link_relocatable (&link_info)) 617 return TRUE; 618 if (link_info.export_dynamic || bfd_link_dll (&link_info)) 619 { 620 /* Check if symbol is hidden by version script. */ 621 if (bfd_hide_sym_by_version (link_info.version_info, 622 blhe->root.string)) 623 return FALSE; 624 /* Only ELF symbols really have visibility. */ 625 if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour) 626 { 627 struct elf_link_hash_entry *el = (struct elf_link_hash_entry *)blhe; 628 int vis = ELF_ST_VISIBILITY (el->other); 629 return vis == STV_DEFAULT || vis == STV_PROTECTED; 630 } 631 /* On non-ELF targets, we can safely make inferences by considering 632 what visibility the plugin would have liked to apply when it first 633 sent us the symbol. During ELF symbol processing, visibility only 634 ever becomes more restrictive, not less, when symbols are merged, 635 so this is a conservative estimate; it may give false positives, 636 declaring something visible from outside when it in fact would 637 not have been, but this will only lead to missed optimisation 638 opportunities during LTRANS at worst; it will not give false 639 negatives, which can lead to the disastrous conclusion that the 640 related symbol is IRONLY. (See GCC PR46319 for an example.) */ 641 return (lsym->visibility == LDPV_DEFAULT 642 || lsym->visibility == LDPV_PROTECTED); 643 } 644 645 for (sym = &entry_symbol; sym != NULL; sym = sym->next) 646 if (sym->name 647 && strcmp (sym->name, blhe->root.string) == 0) 648 return TRUE; 649 650 return FALSE; 651 } 652 653 /* Get the symbol resolution info for a plugin-claimed input file. */ 654 static enum ld_plugin_status 655 get_symbols (const void *handle, int nsyms, struct ld_plugin_symbol *syms, 656 int def_ironly_exp) 657 { 658 const plugin_input_file_t *input = handle; 659 const bfd *abfd = (const bfd *) input->abfd; 660 int n; 661 662 ASSERT (called_plugin); 663 for (n = 0; n < nsyms; n++) 664 { 665 struct bfd_link_hash_entry *blhe; 666 asection *owner_sec; 667 int res; 668 669 if (syms[n].def != LDPK_UNDEF) 670 blhe = bfd_link_hash_lookup (link_info.hash, syms[n].name, 671 FALSE, FALSE, TRUE); 672 else 673 blhe = bfd_wrapped_link_hash_lookup (link_info.output_bfd, &link_info, 674 syms[n].name, FALSE, FALSE, TRUE); 675 if (!blhe) 676 { 677 /* The plugin is called to claim symbols in an archive element 678 from plugin_object_p. But those symbols aren't needed to 679 create output. They are defined and referenced only within 680 IR. */ 681 switch (syms[n].def) 682 { 683 default: 684 abort (); 685 case LDPK_UNDEF: 686 case LDPK_WEAKUNDEF: 687 res = LDPR_UNDEF; 688 break; 689 case LDPK_DEF: 690 case LDPK_WEAKDEF: 691 case LDPK_COMMON: 692 res = LDPR_PREVAILING_DEF_IRONLY; 693 break; 694 } 695 goto report_symbol; 696 } 697 698 /* Determine resolution from blhe type and symbol's original type. */ 699 if (blhe->type == bfd_link_hash_undefined 700 || blhe->type == bfd_link_hash_undefweak) 701 { 702 res = LDPR_UNDEF; 703 goto report_symbol; 704 } 705 if (blhe->type != bfd_link_hash_defined 706 && blhe->type != bfd_link_hash_defweak 707 && blhe->type != bfd_link_hash_common) 708 { 709 /* We should not have a new, indirect or warning symbol here. */ 710 einfo ("%P%F: %s: plugin symbol table corrupt (sym type %d)\n", 711 called_plugin->name, blhe->type); 712 } 713 714 /* Find out which section owns the symbol. Since it's not undef, 715 it must have an owner; if it's not a common symbol, both defs 716 and weakdefs keep it in the same place. */ 717 owner_sec = (blhe->type == bfd_link_hash_common 718 ? blhe->u.c.p->section 719 : blhe->u.def.section); 720 721 722 /* If it was originally undefined or common, then it has been 723 resolved; determine how. */ 724 if (syms[n].def == LDPK_UNDEF 725 || syms[n].def == LDPK_WEAKUNDEF 726 || syms[n].def == LDPK_COMMON) 727 { 728 if (owner_sec->owner == link_info.output_bfd) 729 res = LDPR_RESOLVED_EXEC; 730 else if (owner_sec->owner == abfd) 731 res = LDPR_PREVAILING_DEF_IRONLY; 732 else if (is_ir_dummy_bfd (owner_sec->owner)) 733 res = LDPR_RESOLVED_IR; 734 else if (owner_sec->owner != NULL 735 && (owner_sec->owner->flags & DYNAMIC) != 0) 736 res = LDPR_RESOLVED_DYN; 737 else 738 res = LDPR_RESOLVED_EXEC; 739 } 740 741 /* Was originally def, or weakdef. Does it prevail? If the 742 owner is the original dummy bfd that supplied it, then this 743 is the definition that has prevailed. */ 744 else if (owner_sec->owner == link_info.output_bfd) 745 res = LDPR_PREEMPTED_REG; 746 else if (owner_sec->owner == abfd) 747 res = LDPR_PREVAILING_DEF_IRONLY; 748 749 /* Was originally def, weakdef, or common, but has been pre-empted. */ 750 else if (is_ir_dummy_bfd (owner_sec->owner)) 751 res = LDPR_PREEMPTED_IR; 752 else 753 res = LDPR_PREEMPTED_REG; 754 755 if (res == LDPR_PREVAILING_DEF_IRONLY) 756 { 757 /* We need to know if the sym is referenced from non-IR files. Or 758 even potentially-referenced, perhaps in a future final link if 759 this is a partial one, perhaps dynamically at load-time if the 760 symbol is externally visible. */ 761 if (blhe->non_ir_ref) 762 res = LDPR_PREVAILING_DEF; 763 else if (is_visible_from_outside (&syms[n], blhe)) 764 res = def_ironly_exp; 765 } 766 767 report_symbol: 768 syms[n].resolution = res; 769 if (report_plugin_symbols) 770 einfo (_("%P: %B: symbol `%s' " 771 "definition: %d, visibility: %d, resolution: %d\n"), 772 abfd, syms[n].name, 773 syms[n].def, syms[n].visibility, res); 774 } 775 return LDPS_OK; 776 } 777 778 static enum ld_plugin_status 779 get_symbols_v1 (const void *handle, int nsyms, struct ld_plugin_symbol *syms) 780 { 781 return get_symbols (handle, nsyms, syms, LDPR_PREVAILING_DEF); 782 } 783 784 static enum ld_plugin_status 785 get_symbols_v2 (const void *handle, int nsyms, struct ld_plugin_symbol *syms) 786 { 787 return get_symbols (handle, nsyms, syms, LDPR_PREVAILING_DEF_IRONLY_EXP); 788 } 789 790 /* Add a new (real) input file generated by a plugin. */ 791 static enum ld_plugin_status 792 add_input_file (const char *pathname) 793 { 794 lang_input_statement_type *is; 795 796 ASSERT (called_plugin); 797 is = lang_add_input_file (xstrdup (pathname), lang_input_file_is_file_enum, 798 NULL); 799 if (!is) 800 return LDPS_ERR; 801 is->flags.lto_output = 1; 802 return LDPS_OK; 803 } 804 805 /* Add a new (real) library required by a plugin. */ 806 static enum ld_plugin_status 807 add_input_library (const char *pathname) 808 { 809 lang_input_statement_type *is; 810 811 ASSERT (called_plugin); 812 is = lang_add_input_file (xstrdup (pathname), lang_input_file_is_l_enum, 813 NULL); 814 if (!is) 815 return LDPS_ERR; 816 is->flags.lto_output = 1; 817 return LDPS_OK; 818 } 819 820 /* Set the extra library path to be used by libraries added via 821 add_input_library. */ 822 static enum ld_plugin_status 823 set_extra_library_path (const char *path) 824 { 825 ASSERT (called_plugin); 826 ldfile_add_library_path (xstrdup (path), FALSE); 827 return LDPS_OK; 828 } 829 830 /* Issue a diagnostic message from a plugin. */ 831 static enum ld_plugin_status 832 message (int level, const char *format, ...) 833 { 834 va_list args; 835 va_start (args, format); 836 837 switch (level) 838 { 839 case LDPL_INFO: 840 vfinfo (stdout, format, args, FALSE); 841 putchar ('\n'); 842 break; 843 case LDPL_WARNING: 844 { 845 char *newfmt = concat ("%P: warning: ", format, "\n", 846 (const char *) NULL); 847 vfinfo (stdout, newfmt, args, TRUE); 848 free (newfmt); 849 } 850 break; 851 case LDPL_FATAL: 852 case LDPL_ERROR: 853 default: 854 { 855 char *newfmt = concat (level == LDPL_FATAL ? "%P%F" : "%P%X", 856 ": error: ", format, "\n", 857 (const char *) NULL); 858 fflush (stdout); 859 vfinfo (stderr, newfmt, args, TRUE); 860 fflush (stderr); 861 free (newfmt); 862 } 863 break; 864 } 865 866 va_end (args); 867 return LDPS_OK; 868 } 869 870 /* Helper to size leading part of tv array and set it up. */ 871 static void 872 set_tv_header (struct ld_plugin_tv *tv) 873 { 874 size_t i; 875 876 /* Version info. */ 877 static const unsigned int major = (unsigned)(BFD_VERSION / 100000000UL); 878 static const unsigned int minor = (unsigned)(BFD_VERSION / 1000000UL) % 100; 879 880 for (i = 0; i < tv_header_size; i++) 881 { 882 tv[i].tv_tag = tv_header_tags[i]; 883 #define TVU(x) tv[i].tv_u.tv_ ## x 884 switch (tv[i].tv_tag) 885 { 886 case LDPT_MESSAGE: 887 TVU(message) = message; 888 break; 889 case LDPT_API_VERSION: 890 TVU(val) = LD_PLUGIN_API_VERSION; 891 break; 892 case LDPT_GNU_LD_VERSION: 893 TVU(val) = major * 100 + minor; 894 break; 895 case LDPT_LINKER_OUTPUT: 896 TVU(val) = (bfd_link_relocatable (&link_info) ? LDPO_REL 897 : bfd_link_pde (&link_info) ? LDPO_EXEC 898 : bfd_link_pie (&link_info) ? LDPO_PIE 899 : LDPO_DYN); 900 break; 901 case LDPT_OUTPUT_NAME: 902 TVU(string) = output_filename; 903 break; 904 case LDPT_REGISTER_CLAIM_FILE_HOOK: 905 TVU(register_claim_file) = register_claim_file; 906 break; 907 case LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK: 908 TVU(register_all_symbols_read) = register_all_symbols_read; 909 break; 910 case LDPT_REGISTER_CLEANUP_HOOK: 911 TVU(register_cleanup) = register_cleanup; 912 break; 913 case LDPT_ADD_SYMBOLS: 914 TVU(add_symbols) = add_symbols; 915 break; 916 case LDPT_GET_INPUT_FILE: 917 TVU(get_input_file) = get_input_file; 918 break; 919 case LDPT_GET_VIEW: 920 TVU(get_view) = get_view; 921 break; 922 case LDPT_RELEASE_INPUT_FILE: 923 TVU(release_input_file) = release_input_file; 924 break; 925 case LDPT_GET_SYMBOLS: 926 TVU(get_symbols) = get_symbols_v1; 927 break; 928 case LDPT_GET_SYMBOLS_V2: 929 TVU(get_symbols) = get_symbols_v2; 930 break; 931 case LDPT_ADD_INPUT_FILE: 932 TVU(add_input_file) = add_input_file; 933 break; 934 case LDPT_ADD_INPUT_LIBRARY: 935 TVU(add_input_library) = add_input_library; 936 break; 937 case LDPT_SET_EXTRA_LIBRARY_PATH: 938 TVU(set_extra_library_path) = set_extra_library_path; 939 break; 940 default: 941 /* Added a new entry to the array without adding 942 a new case to set up its value is a bug. */ 943 FAIL (); 944 } 945 #undef TVU 946 } 947 } 948 949 /* Append the per-plugin args list and trailing LDPT_NULL to tv. */ 950 static void 951 set_tv_plugin_args (plugin_t *plugin, struct ld_plugin_tv *tv) 952 { 953 plugin_arg_t *arg = plugin->args; 954 while (arg) 955 { 956 tv->tv_tag = LDPT_OPTION; 957 tv->tv_u.tv_string = arg->arg; 958 arg = arg->next; 959 tv++; 960 } 961 tv->tv_tag = LDPT_NULL; 962 tv->tv_u.tv_val = 0; 963 } 964 965 /* Load up and initialise all plugins after argument parsing. */ 966 void 967 plugin_load_plugins (void) 968 { 969 struct ld_plugin_tv *my_tv; 970 unsigned int max_args = 0; 971 plugin_t *curplug = plugins_list; 972 973 /* If there are no plugins, we need do nothing this run. */ 974 if (!curplug) 975 return; 976 977 /* First pass over plugins to find max # args needed so that we 978 can size and allocate the tv array. */ 979 while (curplug) 980 { 981 if (curplug->n_args > max_args) 982 max_args = curplug->n_args; 983 curplug = curplug->next; 984 } 985 986 /* Allocate tv array and initialise constant part. */ 987 my_tv = xmalloc ((max_args + 1 + tv_header_size) * sizeof *my_tv); 988 set_tv_header (my_tv); 989 990 /* Pass over plugins again, activating them. */ 991 curplug = plugins_list; 992 while (curplug) 993 { 994 enum ld_plugin_status rv; 995 ld_plugin_onload onloadfn; 996 997 onloadfn = (ld_plugin_onload) dlsym (curplug->dlhandle, "onload"); 998 if (!onloadfn) 999 onloadfn = (ld_plugin_onload) dlsym (curplug->dlhandle, "_onload"); 1000 if (!onloadfn) 1001 einfo (_("%P%F: %s: error loading plugin: %s\n"), 1002 curplug->name, dlerror ()); 1003 set_tv_plugin_args (curplug, &my_tv[tv_header_size]); 1004 called_plugin = curplug; 1005 rv = (*onloadfn) (my_tv); 1006 called_plugin = NULL; 1007 if (rv != LDPS_OK) 1008 einfo (_("%P%F: %s: plugin error: %d\n"), curplug->name, rv); 1009 curplug = curplug->next; 1010 } 1011 1012 /* Since plugin(s) inited ok, assume they're going to want symbol 1013 resolutions, which needs us to track which symbols are referenced 1014 by non-IR files using the linker's notice callback. */ 1015 orig_notice_all = link_info.notice_all; 1016 orig_callbacks = link_info.callbacks; 1017 plugin_callbacks = *orig_callbacks; 1018 plugin_callbacks.notice = &plugin_notice; 1019 link_info.notice_all = TRUE; 1020 link_info.lto_plugin_active = TRUE; 1021 link_info.callbacks = &plugin_callbacks; 1022 1023 register_ld_plugin_object_p (plugin_object_p); 1024 1025 #if HAVE_MMAP && HAVE_GETPAGESIZE 1026 plugin_pagesize = getpagesize (); 1027 #endif 1028 } 1029 1030 /* Call 'claim file' hook for all plugins. */ 1031 static int 1032 plugin_call_claim_file (const struct ld_plugin_input_file *file, int *claimed) 1033 { 1034 plugin_t *curplug = plugins_list; 1035 *claimed = FALSE; 1036 while (curplug && !*claimed) 1037 { 1038 if (curplug->claim_file_handler) 1039 { 1040 enum ld_plugin_status rv; 1041 called_plugin = curplug; 1042 rv = (*curplug->claim_file_handler) (file, claimed); 1043 called_plugin = NULL; 1044 if (rv != LDPS_OK) 1045 set_plugin_error (curplug->name); 1046 } 1047 curplug = curplug->next; 1048 } 1049 return plugin_error_p () ? -1 : 0; 1050 } 1051 1052 /* Duplicates a character string with memory attached to ABFD. */ 1053 1054 static char * 1055 plugin_strdup (bfd *abfd, const char *str) 1056 { 1057 size_t strlength; 1058 char *copy; 1059 strlength = strlen (str) + 1; 1060 copy = bfd_alloc (abfd, strlength); 1061 if (copy == NULL) 1062 einfo (_("%P%F: plugin_strdup failed to allocate memory: %s\n"), 1063 bfd_get_error ()); 1064 memcpy (copy, str, strlength); 1065 return copy; 1066 } 1067 1068 static const bfd_target * 1069 plugin_object_p (bfd *ibfd) 1070 { 1071 int claimed; 1072 plugin_input_file_t *input; 1073 off_t offset, filesize; 1074 struct ld_plugin_input_file file; 1075 bfd *abfd; 1076 bfd_boolean inarchive; 1077 const char *name; 1078 int fd; 1079 1080 /* Don't try the dummy object file. */ 1081 if ((ibfd->flags & BFD_PLUGIN) != 0) 1082 return NULL; 1083 1084 if (ibfd->plugin_format != bfd_plugin_unknown) 1085 { 1086 if (ibfd->plugin_format == bfd_plugin_yes) 1087 return ibfd->plugin_dummy_bfd->xvec; 1088 else 1089 return NULL; 1090 } 1091 1092 inarchive = (ibfd->my_archive != NULL 1093 && !bfd_is_thin_archive (ibfd->my_archive)); 1094 name = inarchive ? ibfd->my_archive->filename : ibfd->filename; 1095 fd = open (name, O_RDONLY | O_BINARY); 1096 1097 if (fd < 0) 1098 return NULL; 1099 1100 /* We create a dummy BFD, initially empty, to house whatever symbols 1101 the plugin may want to add. */ 1102 abfd = plugin_get_ir_dummy_bfd (ibfd->filename, ibfd); 1103 1104 input = bfd_alloc (abfd, sizeof (*input)); 1105 if (input == NULL) 1106 einfo (_("%P%F: plugin failed to allocate memory for input: %s\n"), 1107 bfd_get_error ()); 1108 1109 if (inarchive) 1110 { 1111 /* Offset and filesize must refer to the individual archive 1112 member, not the whole file, and must exclude the header. 1113 Fortunately for us, that is how the data is stored in the 1114 origin field of the bfd and in the arelt_data. */ 1115 offset = ibfd->origin; 1116 filesize = arelt_size (ibfd); 1117 } 1118 else 1119 { 1120 offset = 0; 1121 filesize = lseek (fd, 0, SEEK_END); 1122 1123 /* We must copy filename attached to ibfd if it is not an archive 1124 member since it may be freed by bfd_close below. */ 1125 name = plugin_strdup (abfd, name); 1126 } 1127 1128 file.name = name; 1129 file.offset = offset; 1130 file.filesize = filesize; 1131 file.fd = fd; 1132 file.handle = input; 1133 1134 input->abfd = abfd; 1135 input->view_buffer.addr = NULL; 1136 input->view_buffer.filesize = 0; 1137 input->view_buffer.offset = 0; 1138 input->fd = fd; 1139 input->use_mmap = FALSE; 1140 input->offset = offset; 1141 input->filesize = filesize; 1142 input->name = plugin_strdup (abfd, ibfd->filename); 1143 1144 claimed = 0; 1145 1146 if (plugin_call_claim_file (&file, &claimed)) 1147 einfo (_("%P%F: %s: plugin reported error claiming file\n"), 1148 plugin_error_plugin ()); 1149 1150 if (input->fd != -1 && ! bfd_plugin_target_p (ibfd->xvec)) 1151 { 1152 /* FIXME: fd belongs to us, not the plugin. GCC plugin, which 1153 doesn't need fd after plugin_call_claim_file, doesn't use 1154 BFD plugin target vector. Since GCC plugin doesn't call 1155 release_input_file, we close it here. LLVM plugin, which 1156 needs fd after plugin_call_claim_file and calls 1157 release_input_file after it is done, uses BFD plugin target 1158 vector. This scheme doesn't work when a plugin needs fd and 1159 doesn't use BFD plugin target vector neither. */ 1160 close (fd); 1161 input->fd = -1; 1162 } 1163 1164 if (claimed) 1165 { 1166 ibfd->plugin_format = bfd_plugin_yes; 1167 ibfd->plugin_dummy_bfd = abfd; 1168 bfd_make_readable (abfd); 1169 return abfd->xvec; 1170 } 1171 else 1172 { 1173 #if HAVE_MMAP 1174 if (input->use_mmap) 1175 { 1176 /* If plugin didn't claim the file, unmap the buffer. */ 1177 char *addr = input->view_buffer.addr; 1178 off_t size = input->view_buffer.filesize; 1179 # if HAVE_GETPAGESIZE 1180 off_t bias = input->view_buffer.offset % plugin_pagesize; 1181 size += bias; 1182 addr -= bias; 1183 # endif 1184 munmap (addr, size); 1185 } 1186 #endif 1187 1188 /* If plugin didn't claim the file, we don't need the dummy bfd. 1189 Can't avoid speculatively creating it, alas. */ 1190 ibfd->plugin_format = bfd_plugin_no; 1191 bfd_close_all_done (abfd); 1192 return NULL; 1193 } 1194 } 1195 1196 void 1197 plugin_maybe_claim (lang_input_statement_type *entry) 1198 { 1199 if (plugin_object_p (entry->the_bfd)) 1200 { 1201 bfd *abfd = entry->the_bfd->plugin_dummy_bfd; 1202 1203 /* Discard the real file's BFD and substitute the dummy one. */ 1204 1205 /* We can't call bfd_close on archives. BFD archive handling 1206 caches elements, and add_archive_element keeps pointers to 1207 the_bfd and the_bfd->filename in a lang_input_statement_type 1208 linker script statement. */ 1209 if (entry->the_bfd->my_archive == NULL) 1210 bfd_close (entry->the_bfd); 1211 entry->the_bfd = abfd; 1212 entry->flags.claimed = 1; 1213 } 1214 } 1215 1216 /* Call 'all symbols read' hook for all plugins. */ 1217 int 1218 plugin_call_all_symbols_read (void) 1219 { 1220 plugin_t *curplug = plugins_list; 1221 1222 /* Disable any further file-claiming. */ 1223 no_more_claiming = TRUE; 1224 1225 while (curplug) 1226 { 1227 if (curplug->all_symbols_read_handler) 1228 { 1229 enum ld_plugin_status rv; 1230 called_plugin = curplug; 1231 rv = (*curplug->all_symbols_read_handler) (); 1232 called_plugin = NULL; 1233 if (rv != LDPS_OK) 1234 set_plugin_error (curplug->name); 1235 } 1236 curplug = curplug->next; 1237 } 1238 return plugin_error_p () ? -1 : 0; 1239 } 1240 1241 /* Call 'cleanup' hook for all plugins at exit. */ 1242 void 1243 plugin_call_cleanup (void) 1244 { 1245 plugin_t *curplug = plugins_list; 1246 while (curplug) 1247 { 1248 if (curplug->cleanup_handler && !curplug->cleanup_done) 1249 { 1250 enum ld_plugin_status rv; 1251 curplug->cleanup_done = TRUE; 1252 called_plugin = curplug; 1253 rv = (*curplug->cleanup_handler) (); 1254 called_plugin = NULL; 1255 if (rv != LDPS_OK) 1256 info_msg (_("%P: %s: error in plugin cleanup: %d (ignored)\n"), 1257 curplug->name, rv); 1258 dlclose (curplug->dlhandle); 1259 } 1260 curplug = curplug->next; 1261 } 1262 } 1263 1264 /* To determine which symbols should be resolved LDPR_PREVAILING_DEF 1265 and which LDPR_PREVAILING_DEF_IRONLY, we notice all the symbols as 1266 the linker adds them to the linker hash table. Mark those 1267 referenced from a non-IR file with non_ir_ref. We have to 1268 notice_all symbols, because we won't necessarily know until later 1269 which ones will be contributed by IR files. */ 1270 static bfd_boolean 1271 plugin_notice (struct bfd_link_info *info, 1272 struct bfd_link_hash_entry *h, 1273 struct bfd_link_hash_entry *inh, 1274 bfd *abfd, 1275 asection *section, 1276 bfd_vma value, 1277 flagword flags) 1278 { 1279 struct bfd_link_hash_entry *orig_h = h; 1280 1281 if (h != NULL) 1282 { 1283 bfd *sym_bfd; 1284 1285 if (h->type == bfd_link_hash_warning) 1286 h = h->u.i.link; 1287 1288 /* Nothing to do here if this def/ref is from an IR dummy BFD. */ 1289 if (is_ir_dummy_bfd (abfd)) 1290 ; 1291 1292 /* Making an indirect symbol counts as a reference unless this 1293 is a brand new symbol. */ 1294 else if (bfd_is_ind_section (section) 1295 || (flags & BSF_INDIRECT) != 0) 1296 { 1297 /* ??? Some of this is questionable. See comments in 1298 _bfd_generic_link_add_one_symbol for case IND. */ 1299 if (h->type != bfd_link_hash_new) 1300 { 1301 h->non_ir_ref = TRUE; 1302 inh->non_ir_ref = TRUE; 1303 } 1304 else if (inh->type == bfd_link_hash_new) 1305 inh->non_ir_ref = TRUE; 1306 } 1307 1308 /* Nothing to do here for warning symbols. */ 1309 else if ((flags & BSF_WARNING) != 0) 1310 ; 1311 1312 /* Nothing to do here for constructor symbols. */ 1313 else if ((flags & BSF_CONSTRUCTOR) != 0) 1314 ; 1315 1316 /* If this is a ref, set non_ir_ref. */ 1317 else if (bfd_is_und_section (section)) 1318 { 1319 /* Replace the undefined dummy bfd with the real one. */ 1320 if ((h->type == bfd_link_hash_undefined 1321 || h->type == bfd_link_hash_undefweak) 1322 && (h->u.undef.abfd == NULL 1323 || (h->u.undef.abfd->flags & BFD_PLUGIN) != 0)) 1324 h->u.undef.abfd = abfd; 1325 h->non_ir_ref = TRUE; 1326 } 1327 1328 /* Otherwise, it must be a new def. */ 1329 else 1330 { 1331 /* A common symbol should be merged with other commons or 1332 defs with the same name. In particular, a common ought 1333 to be overridden by a def in a -flto object. In that 1334 sense a common is also a ref. */ 1335 if (bfd_is_com_section (section)) 1336 h->non_ir_ref = TRUE; 1337 1338 /* Ensure any symbol defined in an IR dummy BFD takes on a 1339 new value from a real BFD. Weak symbols are not normally 1340 overridden by a new weak definition, and strong symbols 1341 will normally cause multiple definition errors. Avoid 1342 this by making the symbol appear to be undefined. */ 1343 if (((h->type == bfd_link_hash_defweak 1344 || h->type == bfd_link_hash_defined) 1345 && is_ir_dummy_bfd (sym_bfd = h->u.def.section->owner)) 1346 || (h->type == bfd_link_hash_common 1347 && is_ir_dummy_bfd (sym_bfd = h->u.c.p->section->owner))) 1348 { 1349 h->type = bfd_link_hash_undefweak; 1350 h->u.undef.abfd = sym_bfd; 1351 } 1352 } 1353 } 1354 1355 /* Continue with cref/nocrossref/trace-sym processing. */ 1356 if (orig_h == NULL 1357 || orig_notice_all 1358 || (info->notice_hash != NULL 1359 && bfd_hash_lookup (info->notice_hash, orig_h->root.string, 1360 FALSE, FALSE) != NULL)) 1361 return (*orig_callbacks->notice) (info, orig_h, inh, 1362 abfd, section, value, flags); 1363 return TRUE; 1364 } 1365