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