1 /* Plugin control for the GNU linker.
2 Copyright (C) 2010-2018 Free Software Foundation, Inc.
4 This file is part of the GNU Binutils.
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.
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.
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. */
22 #include "libiberty.h"
32 #include "plugin-api.h"
33 #include "../bfd/plugin.h"
37 # include <sys/mman.h>
39 # define MAP_FAILED ((void *) -1)
45 # define MAP_PRIVATE 0
49 #if !(defined(errno) || defined(_MSC_VER) && defined(_INC_ERRNO))
52 #if !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H)
56 /* Report plugin symbols. */
57 bfd_boolean report_plugin_symbols;
59 /* The suffix to append to the name of the real (claimed) object file
60 when generating a dummy BFD to hold the IR symbols sent from the
61 plugin. For cosmetic use only; appears in maps, crefs etc. */
62 #define IRONLY_SUFFIX " (symbol from plugin)"
64 /* Stores a single argument passed to a plugin. */
65 typedef struct plugin_arg
67 struct plugin_arg *next;
71 /* Holds all details of a single plugin. */
74 /* Next on the list of plugins, or NULL at end of chain. */
76 /* The argument string given to --plugin. */
78 /* The shared library handle returned by dlopen. */
80 /* The list of argument string given to --plugin-opt. */
82 /* Number of args in the list, for convenience. */
84 /* The plugin's event handlers. */
85 ld_plugin_claim_file_handler claim_file_handler;
86 ld_plugin_all_symbols_read_handler all_symbols_read_handler;
87 ld_plugin_cleanup_handler cleanup_handler;
88 /* TRUE if the cleanup handlers have been called. */
89 bfd_boolean cleanup_done;
92 typedef struct view_buffer
99 /* The internal version of struct ld_plugin_input_file with a BFD
101 typedef struct plugin_input_file
104 view_buffer_t view_buffer;
107 bfd_boolean use_mmap;
110 } plugin_input_file_t;
112 /* The master list of all plugins. */
113 static plugin_t *plugins_list = NULL;
115 /* We keep a tail pointer for easy linking on the end. */
116 static plugin_t **plugins_tail_chain_ptr = &plugins_list;
118 /* The last plugin added to the list, for receiving args. */
119 static plugin_t *last_plugin = NULL;
121 /* The tail of the arg chain of the last plugin added to the list. */
122 static plugin_arg_t **last_plugin_args_tail_chain_ptr = NULL;
124 /* The plugin which is currently having a callback executed. */
125 static plugin_t *called_plugin = NULL;
127 /* Last plugin to cause an error, if any. */
128 static const char *error_plugin = NULL;
130 /* State of linker "notice" interface before we poked at it. */
131 static bfd_boolean orig_notice_all;
133 /* Original linker callbacks, and the plugin version. */
134 static const struct bfd_link_callbacks *orig_callbacks;
135 static struct bfd_link_callbacks plugin_callbacks;
137 /* Set at all symbols read time, to avoid recursively offering the plugin
138 its own newly-added input files and libs to claim. */
139 bfd_boolean no_more_claiming = FALSE;
141 #if HAVE_MMAP && HAVE_GETPAGESIZE
142 /* Page size used by mmap. */
143 static off_t plugin_pagesize;
146 /* List of tags to set in the constant leading part of the tv array. */
147 static const enum ld_plugin_tag tv_header_tags[] =
154 LDPT_REGISTER_CLAIM_FILE_HOOK,
155 LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK,
156 LDPT_REGISTER_CLEANUP_HOOK,
160 LDPT_RELEASE_INPUT_FILE,
164 LDPT_ADD_INPUT_LIBRARY,
165 LDPT_SET_EXTRA_LIBRARY_PATH
168 /* How many entries in the constant leading part of the tv array. */
169 static const size_t tv_header_size = ARRAY_SIZE (tv_header_tags);
171 /* Forward references. */
172 static bfd_boolean plugin_notice (struct bfd_link_info *,
173 struct bfd_link_hash_entry *,
174 struct bfd_link_hash_entry *,
175 bfd *, asection *, bfd_vma, flagword);
177 static const bfd_target * plugin_object_p (bfd *);
179 #if !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H)
181 #define RTLD_NOW 0 /* Dummy value. */
184 dlopen (const char *file, int mode ATTRIBUTE_UNUSED)
186 return LoadLibrary (file);
190 dlsym (void *handle, const char *name)
192 return GetProcAddress (handle, name);
196 dlclose (void *handle)
198 FreeLibrary (handle);
202 #endif /* !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H) */
212 /* Helper function for exiting with error status. */
214 set_plugin_error (const char *plugin)
216 error_plugin = plugin;
220 /* Test if an error occurred. */
222 plugin_error_p (void)
224 return error_plugin != NULL;
227 /* Return name of plugin which caused an error if any. */
229 plugin_error_plugin (void)
231 return error_plugin ? error_plugin : _("<no plugin>");
234 /* Handle -plugin arg: find and load plugin, or return error. */
236 plugin_opt_plugin (const char *plugin)
239 plugin_t *curplug = plugins_list;
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 (_("%F%P: %s: error loading plugin: %s\n"), plugin, dlerror ());
248 /* Check if plugin has been loaded already. */
251 if (newplug->dlhandle == curplug->dlhandle)
253 einfo (_("%P: %s: duplicated plugin\n"), plugin);
257 curplug = curplug->next;
260 /* Chain on end, so when we run list it is in command-line order. */
261 *plugins_tail_chain_ptr = newplug;
262 plugins_tail_chain_ptr = &newplug->next;
264 /* Record it as current plugin for receiving args. */
265 last_plugin = newplug;
266 last_plugin_args_tail_chain_ptr = &newplug->args;
269 /* Accumulate option arguments for last-loaded plugin, or return
272 plugin_opt_plugin_arg (const char *arg)
274 plugin_arg_t *newarg;
277 return set_plugin_error (_("<no plugin>"));
279 /* Ignore -pass-through= from GCC driver. */
282 const char *p = arg + 1;
286 if (strncmp (p, "pass-through=", 13) == 0)
290 newarg = xmalloc (sizeof *newarg);
294 /* Chain on end to preserve command-line order. */
295 *last_plugin_args_tail_chain_ptr = newarg;
296 last_plugin_args_tail_chain_ptr = &newarg->next;
297 last_plugin->n_args++;
301 /* Generate a dummy BFD to represent an IR file, for any callers of
302 plugin_call_claim_file to use as the handle in the ld_plugin_input_file
303 struct that they build to pass in. The BFD is initially writable, so
304 that symbols can be added to it; it must be made readable after the
305 add_symbols hook has been called so that it can be read when linking. */
307 plugin_get_ir_dummy_bfd (const char *name, bfd *srctemplate)
310 bfd_boolean bfd_plugin_target;
312 bfd_use_reserved_id = 1;
313 bfd_plugin_target = bfd_plugin_target_p (srctemplate->xvec);
314 abfd = bfd_create (concat (name, IRONLY_SUFFIX, (const char *) NULL),
315 bfd_plugin_target ? link_info.output_bfd : srctemplate);
318 abfd->flags |= BFD_LINKER_CREATED | BFD_PLUGIN;
319 if (!bfd_make_writable (abfd))
321 if (!bfd_plugin_target)
323 bfd_set_arch_info (abfd, bfd_get_arch_info (srctemplate));
324 bfd_set_gp_size (abfd, bfd_get_gp_size (srctemplate));
325 if (!bfd_copy_private_bfd_data (srctemplate, abfd))
331 /* Create section to own the symbols. */
332 flags = (SEC_CODE | SEC_HAS_CONTENTS | SEC_READONLY
333 | SEC_ALLOC | SEC_LOAD | SEC_KEEP | SEC_EXCLUDE);
334 if (bfd_make_section_anyway_with_flags (abfd, ".text", flags))
339 einfo (_("%F%P: could not create dummy IR bfd: %E\n"));
343 /* Check if the BFD passed in is an IR dummy object file. */
344 static inline bfd_boolean
345 is_ir_dummy_bfd (const bfd *abfd)
347 /* ABFD can sometimes legitimately be NULL, e.g. when called from one
348 of the linker callbacks for a symbol in the *ABS* or *UND* sections. */
349 return abfd != NULL && (abfd->flags & BFD_PLUGIN) != 0;
352 /* Helpers to convert between BFD and GOLD symbol formats. */
353 static enum ld_plugin_status
354 asymbol_from_plugin_symbol (bfd *abfd, asymbol *asym,
355 const struct ld_plugin_symbol *ldsym)
357 flagword flags = BSF_NO_FLAGS;
358 struct bfd_section *section;
360 asym->the_bfd = abfd;
361 asym->name = (ldsym->version
362 ? concat (ldsym->name, "@", ldsym->version, (const char *) NULL)
372 if (ldsym->comdat_key)
374 char *name = concat (".gnu.linkonce.t.", ldsym->comdat_key,
375 (const char *) NULL);
376 section = bfd_get_section_by_name (abfd, name);
383 sflags = (SEC_CODE | SEC_HAS_CONTENTS | SEC_READONLY
384 | SEC_ALLOC | SEC_LOAD | SEC_KEEP | SEC_EXCLUDE
385 | SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD);
386 section = bfd_make_section_anyway_with_flags (abfd, name, sflags);
392 section = bfd_get_section_by_name (abfd, ".text");
399 section = bfd_und_section_ptr;
404 section = bfd_com_section_ptr;
405 asym->value = ldsym->size;
406 /* For ELF targets, set alignment of common symbol to 1. */
407 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
409 ((elf_symbol_type *) asym)->internal_elf_sym.st_shndx = SHN_COMMON;
410 ((elf_symbol_type *) asym)->internal_elf_sym.st_value = 1;
418 asym->section = section;
420 /* Visibility only applies on ELF targets. */
421 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
423 elf_symbol_type *elfsym = elf_symbol_from (abfd, asym);
424 unsigned char visibility;
427 einfo (_("%F%P: %s: non-ELF symbol in ELF BFD!\n"), asym->name);
428 switch (ldsym->visibility)
431 einfo (_("%F%P: unknown ELF symbol visibility: %d!\n"),
436 visibility = STV_DEFAULT;
439 visibility = STV_PROTECTED;
442 visibility = STV_INTERNAL;
445 visibility = STV_HIDDEN;
448 elfsym->internal_elf_sym.st_other
449 = (visibility | (elfsym->internal_elf_sym.st_other
450 & ~ELF_ST_VISIBILITY (-1)));
456 /* Register a claim-file handler. */
457 static enum ld_plugin_status
458 register_claim_file (ld_plugin_claim_file_handler handler)
460 ASSERT (called_plugin);
461 called_plugin->claim_file_handler = handler;
465 /* Register an all-symbols-read handler. */
466 static enum ld_plugin_status
467 register_all_symbols_read (ld_plugin_all_symbols_read_handler handler)
469 ASSERT (called_plugin);
470 called_plugin->all_symbols_read_handler = handler;
474 /* Register a cleanup handler. */
475 static enum ld_plugin_status
476 register_cleanup (ld_plugin_cleanup_handler handler)
478 ASSERT (called_plugin);
479 called_plugin->cleanup_handler = handler;
483 /* Add symbols from a plugin-claimed input file. */
484 static enum ld_plugin_status
485 add_symbols (void *handle, int nsyms, const struct ld_plugin_symbol *syms)
488 plugin_input_file_t *input = handle;
489 bfd *abfd = input->abfd;
492 ASSERT (called_plugin);
493 symptrs = xmalloc (nsyms * sizeof *symptrs);
494 for (n = 0; n < nsyms; n++)
496 enum ld_plugin_status rv;
499 bfdsym = bfd_make_empty_symbol (abfd);
501 rv = asymbol_from_plugin_symbol (abfd, bfdsym, syms + n);
505 bfd_set_symtab (abfd, symptrs, nsyms);
509 /* Get the input file information with an open (possibly re-opened)
511 static enum ld_plugin_status
512 get_input_file (const void *handle, struct ld_plugin_input_file *file)
514 const plugin_input_file_t *input = handle;
516 ASSERT (called_plugin);
518 file->name = input->name;
519 file->offset = input->offset;
520 file->filesize = input->filesize;
521 file->handle = (void *) handle;
526 /* Get view of the input file. */
527 static enum ld_plugin_status
528 get_view (const void *handle, const void **viewp)
530 plugin_input_file_t *input = (plugin_input_file_t *) handle;
532 size_t size = input->filesize;
533 off_t offset = input->offset;
534 #if HAVE_MMAP && HAVE_GETPAGESIZE
538 ASSERT (called_plugin);
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);
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)
550 *viewp = input->view_buffer.addr;
554 input->view_buffer.filesize = size;
555 input->view_buffer.offset = offset;
558 # if HAVE_GETPAGESIZE
559 bias = offset % plugin_pagesize;
563 buffer = mmap (NULL, size, PROT_READ, MAP_PRIVATE, input->fd, offset);
564 if (buffer != MAP_FAILED)
566 input->use_mmap = TRUE;
567 # if HAVE_GETPAGESIZE
576 input->use_mmap = FALSE;
578 if (lseek (input->fd, offset, SEEK_SET) < 0)
581 buffer = bfd_alloc (input->abfd, size);
588 ssize_t got = read (input->fd, p, size);
596 else if (errno != EINTR)
602 input->view_buffer.addr = buffer;
608 /* Release the input file. */
609 static enum ld_plugin_status
610 release_input_file (const void *handle)
612 plugin_input_file_t *input = (plugin_input_file_t *) handle;
613 ASSERT (called_plugin);
622 /* Return TRUE if a defined symbol might be reachable from outside the
623 universe of claimed objects. */
624 static inline bfd_boolean
625 is_visible_from_outside (struct ld_plugin_symbol *lsym,
626 struct bfd_link_hash_entry *blhe)
628 struct bfd_sym_chain *sym;
630 if (bfd_link_relocatable (&link_info))
632 if (blhe->non_ir_ref_dynamic
633 || link_info.export_dynamic
634 || bfd_link_dll (&link_info))
636 /* Check if symbol is hidden by version script. */
637 if (bfd_hide_sym_by_version (link_info.version_info,
640 /* Only ELF symbols really have visibility. */
641 if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour)
643 struct elf_link_hash_entry *el = (struct elf_link_hash_entry *)blhe;
644 int vis = ELF_ST_VISIBILITY (el->other);
645 return vis == STV_DEFAULT || vis == STV_PROTECTED;
647 /* On non-ELF targets, we can safely make inferences by considering
648 what visibility the plugin would have liked to apply when it first
649 sent us the symbol. During ELF symbol processing, visibility only
650 ever becomes more restrictive, not less, when symbols are merged,
651 so this is a conservative estimate; it may give false positives,
652 declaring something visible from outside when it in fact would
653 not have been, but this will only lead to missed optimisation
654 opportunities during LTRANS at worst; it will not give false
655 negatives, which can lead to the disastrous conclusion that the
656 related symbol is IRONLY. (See GCC PR46319 for an example.) */
657 return (lsym->visibility == LDPV_DEFAULT
658 || lsym->visibility == LDPV_PROTECTED);
661 for (sym = &entry_symbol; sym != NULL; sym = sym->next)
663 && strcmp (sym->name, blhe->root.string) == 0)
669 /* Get the symbol resolution info for a plugin-claimed input file. */
670 static enum ld_plugin_status
671 get_symbols (const void *handle, int nsyms, struct ld_plugin_symbol *syms,
674 const plugin_input_file_t *input = handle;
675 const bfd *abfd = (const bfd *) input->abfd;
678 ASSERT (called_plugin);
679 for (n = 0; n < nsyms; n++)
681 struct bfd_link_hash_entry *blhe;
685 if (syms[n].def != LDPK_UNDEF)
686 blhe = bfd_link_hash_lookup (link_info.hash, syms[n].name,
689 blhe = bfd_wrapped_link_hash_lookup (link_info.output_bfd, &link_info,
690 syms[n].name, FALSE, FALSE, TRUE);
693 /* The plugin is called to claim symbols in an archive element
694 from plugin_object_p. But those symbols aren't needed to
695 create output. They are defined and referenced only within
708 res = LDPR_PREVAILING_DEF_IRONLY;
714 /* Determine resolution from blhe type and symbol's original type. */
715 if (blhe->type == bfd_link_hash_undefined
716 || blhe->type == bfd_link_hash_undefweak)
721 if (blhe->type != bfd_link_hash_defined
722 && blhe->type != bfd_link_hash_defweak
723 && blhe->type != bfd_link_hash_common)
725 /* We should not have a new, indirect or warning symbol here. */
726 einfo (_("%F%P: %s: plugin symbol table corrupt (sym type %d)\n"),
727 called_plugin->name, blhe->type);
730 /* Find out which section owns the symbol. Since it's not undef,
731 it must have an owner; if it's not a common symbol, both defs
732 and weakdefs keep it in the same place. */
733 owner_sec = (blhe->type == bfd_link_hash_common
734 ? blhe->u.c.p->section
735 : blhe->u.def.section);
738 /* If it was originally undefined or common, then it has been
739 resolved; determine how. */
740 if (syms[n].def == LDPK_UNDEF
741 || syms[n].def == LDPK_WEAKUNDEF
742 || syms[n].def == LDPK_COMMON)
744 if (owner_sec->owner == link_info.output_bfd)
745 res = LDPR_RESOLVED_EXEC;
746 else if (owner_sec->owner == abfd)
747 res = LDPR_PREVAILING_DEF_IRONLY;
748 else if (is_ir_dummy_bfd (owner_sec->owner))
749 res = LDPR_RESOLVED_IR;
750 else if (owner_sec->owner != NULL
751 && (owner_sec->owner->flags & DYNAMIC) != 0)
752 res = LDPR_RESOLVED_DYN;
754 res = LDPR_RESOLVED_EXEC;
757 /* Was originally def, or weakdef. Does it prevail? If the
758 owner is the original dummy bfd that supplied it, then this
759 is the definition that has prevailed. */
760 else if (owner_sec->owner == link_info.output_bfd)
761 res = LDPR_PREEMPTED_REG;
762 else if (owner_sec->owner == abfd)
763 res = LDPR_PREVAILING_DEF_IRONLY;
765 /* Was originally def, weakdef, or common, but has been pre-empted. */
766 else if (is_ir_dummy_bfd (owner_sec->owner))
767 res = LDPR_PREEMPTED_IR;
769 res = LDPR_PREEMPTED_REG;
771 if (res == LDPR_PREVAILING_DEF_IRONLY)
773 /* We need to know if the sym is referenced from non-IR files. Or
774 even potentially-referenced, perhaps in a future final link if
775 this is a partial one, perhaps dynamically at load-time if the
776 symbol is externally visible. */
777 if (blhe->non_ir_ref_regular)
778 res = LDPR_PREVAILING_DEF;
779 else if (is_visible_from_outside (&syms[n], blhe))
780 res = def_ironly_exp;
784 syms[n].resolution = res;
785 if (report_plugin_symbols)
786 einfo (_("%P: %pB: symbol `%s' "
787 "definition: %d, visibility: %d, resolution: %d\n"),
789 syms[n].def, syms[n].visibility, res);
794 static enum ld_plugin_status
795 get_symbols_v1 (const void *handle, int nsyms, struct ld_plugin_symbol *syms)
797 return get_symbols (handle, nsyms, syms, LDPR_PREVAILING_DEF);
800 static enum ld_plugin_status
801 get_symbols_v2 (const void *handle, int nsyms, struct ld_plugin_symbol *syms)
803 return get_symbols (handle, nsyms, syms, LDPR_PREVAILING_DEF_IRONLY_EXP);
806 /* Add a new (real) input file generated by a plugin. */
807 static enum ld_plugin_status
808 add_input_file (const char *pathname)
810 lang_input_statement_type *is;
812 ASSERT (called_plugin);
813 is = lang_add_input_file (xstrdup (pathname), lang_input_file_is_file_enum,
817 is->flags.lto_output = 1;
821 /* Add a new (real) library required by a plugin. */
822 static enum ld_plugin_status
823 add_input_library (const char *pathname)
825 lang_input_statement_type *is;
827 ASSERT (called_plugin);
828 is = lang_add_input_file (xstrdup (pathname), lang_input_file_is_l_enum,
832 is->flags.lto_output = 1;
836 /* Set the extra library path to be used by libraries added via
837 add_input_library. */
838 static enum ld_plugin_status
839 set_extra_library_path (const char *path)
841 ASSERT (called_plugin);
842 ldfile_add_library_path (xstrdup (path), FALSE);
846 /* Issue a diagnostic message from a plugin. */
847 static enum ld_plugin_status
848 message (int level, const char *format, ...)
851 va_start (args, format);
856 vfinfo (stdout, format, args, FALSE);
861 char *newfmt = concat (_("%P: warning: "), format, "\n",
862 (const char *) NULL);
863 vfinfo (stdout, newfmt, args, TRUE);
871 char *newfmt = concat (level == LDPL_FATAL ? "%F" : "%X",
872 _("%P: error: "), format, "\n",
873 (const char *) NULL);
875 vfinfo (stderr, newfmt, args, TRUE);
886 /* Helper to size leading part of tv array and set it up. */
888 set_tv_header (struct ld_plugin_tv *tv)
893 static const unsigned int major = (unsigned)(BFD_VERSION / 100000000UL);
894 static const unsigned int minor = (unsigned)(BFD_VERSION / 1000000UL) % 100;
896 for (i = 0; i < tv_header_size; i++)
898 tv[i].tv_tag = tv_header_tags[i];
899 #define TVU(x) tv[i].tv_u.tv_ ## x
900 switch (tv[i].tv_tag)
903 TVU(message) = message;
905 case LDPT_API_VERSION:
906 TVU(val) = LD_PLUGIN_API_VERSION;
908 case LDPT_GNU_LD_VERSION:
909 TVU(val) = major * 100 + minor;
911 case LDPT_LINKER_OUTPUT:
912 TVU(val) = (bfd_link_relocatable (&link_info) ? LDPO_REL
913 : bfd_link_pde (&link_info) ? LDPO_EXEC
914 : bfd_link_pie (&link_info) ? LDPO_PIE
917 case LDPT_OUTPUT_NAME:
918 TVU(string) = output_filename;
920 case LDPT_REGISTER_CLAIM_FILE_HOOK:
921 TVU(register_claim_file) = register_claim_file;
923 case LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK:
924 TVU(register_all_symbols_read) = register_all_symbols_read;
926 case LDPT_REGISTER_CLEANUP_HOOK:
927 TVU(register_cleanup) = register_cleanup;
929 case LDPT_ADD_SYMBOLS:
930 TVU(add_symbols) = add_symbols;
932 case LDPT_GET_INPUT_FILE:
933 TVU(get_input_file) = get_input_file;
936 TVU(get_view) = get_view;
938 case LDPT_RELEASE_INPUT_FILE:
939 TVU(release_input_file) = release_input_file;
941 case LDPT_GET_SYMBOLS:
942 TVU(get_symbols) = get_symbols_v1;
944 case LDPT_GET_SYMBOLS_V2:
945 TVU(get_symbols) = get_symbols_v2;
947 case LDPT_ADD_INPUT_FILE:
948 TVU(add_input_file) = add_input_file;
950 case LDPT_ADD_INPUT_LIBRARY:
951 TVU(add_input_library) = add_input_library;
953 case LDPT_SET_EXTRA_LIBRARY_PATH:
954 TVU(set_extra_library_path) = set_extra_library_path;
957 /* Added a new entry to the array without adding
958 a new case to set up its value is a bug. */
965 /* Append the per-plugin args list and trailing LDPT_NULL to tv. */
967 set_tv_plugin_args (plugin_t *plugin, struct ld_plugin_tv *tv)
969 plugin_arg_t *arg = plugin->args;
972 tv->tv_tag = LDPT_OPTION;
973 tv->tv_u.tv_string = arg->arg;
977 tv->tv_tag = LDPT_NULL;
981 /* Load up and initialise all plugins after argument parsing. */
983 plugin_load_plugins (void)
985 struct ld_plugin_tv *my_tv;
986 unsigned int max_args = 0;
987 plugin_t *curplug = plugins_list;
989 /* If there are no plugins, we need do nothing this run. */
993 /* First pass over plugins to find max # args needed so that we
994 can size and allocate the tv array. */
997 if (curplug->n_args > max_args)
998 max_args = curplug->n_args;
999 curplug = curplug->next;
1002 /* Allocate tv array and initialise constant part. */
1003 my_tv = xmalloc ((max_args + 1 + tv_header_size) * sizeof *my_tv);
1004 set_tv_header (my_tv);
1006 /* Pass over plugins again, activating them. */
1007 curplug = plugins_list;
1010 enum ld_plugin_status rv;
1011 ld_plugin_onload onloadfn;
1013 onloadfn = (ld_plugin_onload) dlsym (curplug->dlhandle, "onload");
1015 onloadfn = (ld_plugin_onload) dlsym (curplug->dlhandle, "_onload");
1017 einfo (_("%F%P: %s: error loading plugin: %s\n"),
1018 curplug->name, dlerror ());
1019 set_tv_plugin_args (curplug, &my_tv[tv_header_size]);
1020 called_plugin = curplug;
1021 rv = (*onloadfn) (my_tv);
1022 called_plugin = NULL;
1024 einfo (_("%F%P: %s: plugin error: %d\n"), curplug->name, rv);
1025 curplug = curplug->next;
1028 /* Since plugin(s) inited ok, assume they're going to want symbol
1029 resolutions, which needs us to track which symbols are referenced
1030 by non-IR files using the linker's notice callback. */
1031 orig_notice_all = link_info.notice_all;
1032 orig_callbacks = link_info.callbacks;
1033 plugin_callbacks = *orig_callbacks;
1034 plugin_callbacks.notice = &plugin_notice;
1035 link_info.notice_all = TRUE;
1036 link_info.lto_plugin_active = TRUE;
1037 link_info.callbacks = &plugin_callbacks;
1039 register_ld_plugin_object_p (plugin_object_p);
1041 #if HAVE_MMAP && HAVE_GETPAGESIZE
1042 plugin_pagesize = getpagesize ();
1046 /* Call 'claim file' hook for all plugins. */
1048 plugin_call_claim_file (const struct ld_plugin_input_file *file, int *claimed)
1050 plugin_t *curplug = plugins_list;
1052 while (curplug && !*claimed)
1054 if (curplug->claim_file_handler)
1056 enum ld_plugin_status rv;
1058 called_plugin = curplug;
1059 rv = (*curplug->claim_file_handler) (file, claimed);
1060 called_plugin = NULL;
1062 set_plugin_error (curplug->name);
1064 curplug = curplug->next;
1066 return plugin_error_p () ? -1 : 0;
1069 /* Duplicates a character string with memory attached to ABFD. */
1072 plugin_strdup (bfd *abfd, const char *str)
1076 strlength = strlen (str) + 1;
1077 copy = bfd_alloc (abfd, strlength);
1079 einfo (_("%F%P: plugin_strdup failed to allocate memory: %s\n"),
1081 memcpy (copy, str, strlength);
1085 static const bfd_target *
1086 plugin_object_p (bfd *ibfd)
1089 plugin_input_file_t *input;
1090 struct ld_plugin_input_file file;
1093 /* Don't try the dummy object file. */
1094 if ((ibfd->flags & BFD_PLUGIN) != 0)
1097 if (ibfd->plugin_format != bfd_plugin_unknown)
1099 if (ibfd->plugin_format == bfd_plugin_yes)
1100 return ibfd->plugin_dummy_bfd->xvec;
1105 /* We create a dummy BFD, initially empty, to house whatever symbols
1106 the plugin may want to add. */
1107 abfd = plugin_get_ir_dummy_bfd (ibfd->filename, ibfd);
1109 input = bfd_alloc (abfd, sizeof (*input));
1111 einfo (_("%F%P: plugin failed to allocate memory for input: %s\n"),
1114 if (!bfd_plugin_open_input (ibfd, &file))
1117 if (file.name == ibfd->filename)
1119 /* We must copy filename attached to ibfd if it is not an archive
1120 member since it may be freed by bfd_close below. */
1121 file.name = plugin_strdup (abfd, file.name);
1124 file.handle = input;
1126 input->view_buffer.addr = NULL;
1127 input->view_buffer.filesize = 0;
1128 input->view_buffer.offset = 0;
1129 input->fd = file.fd;
1130 input->use_mmap = FALSE;
1131 input->offset = file.offset;
1132 input->filesize = file.filesize;
1133 input->name = plugin_strdup (abfd, ibfd->filename);
1137 if (plugin_call_claim_file (&file, &claimed))
1138 einfo (_("%F%P: %s: plugin reported error claiming file\n"),
1139 plugin_error_plugin ());
1141 if (input->fd != -1 && !bfd_plugin_target_p (ibfd->xvec))
1143 /* FIXME: fd belongs to us, not the plugin. GCC plugin, which
1144 doesn't need fd after plugin_call_claim_file, doesn't use
1145 BFD plugin target vector. Since GCC plugin doesn't call
1146 release_input_file, we close it here. LLVM plugin, which
1147 needs fd after plugin_call_claim_file and calls
1148 release_input_file after it is done, uses BFD plugin target
1149 vector. This scheme doesn't work when a plugin needs fd and
1150 doesn't use BFD plugin target vector neither. */
1157 ibfd->plugin_format = bfd_plugin_yes;
1158 ibfd->plugin_dummy_bfd = abfd;
1159 bfd_make_readable (abfd);
1165 if (input->use_mmap)
1167 /* If plugin didn't claim the file, unmap the buffer. */
1168 char *addr = input->view_buffer.addr;
1169 off_t size = input->view_buffer.filesize;
1170 # if HAVE_GETPAGESIZE
1171 off_t bias = input->view_buffer.offset % plugin_pagesize;
1175 munmap (addr, size);
1179 /* If plugin didn't claim the file, we don't need the dummy bfd.
1180 Can't avoid speculatively creating it, alas. */
1181 ibfd->plugin_format = bfd_plugin_no;
1182 bfd_close_all_done (abfd);
1188 plugin_maybe_claim (lang_input_statement_type *entry)
1190 ASSERT (entry->header.type == lang_input_statement_enum);
1191 if (plugin_object_p (entry->the_bfd))
1193 bfd *abfd = entry->the_bfd->plugin_dummy_bfd;
1195 /* Discard the real file's BFD and substitute the dummy one. */
1197 /* We can't call bfd_close on archives. BFD archive handling
1198 caches elements, and add_archive_element keeps pointers to
1199 the_bfd and the_bfd->filename in a lang_input_statement_type
1200 linker script statement. */
1201 if (entry->the_bfd->my_archive == NULL)
1202 bfd_close (entry->the_bfd);
1203 entry->the_bfd = abfd;
1204 entry->flags.claimed = 1;
1208 /* Call 'all symbols read' hook for all plugins. */
1210 plugin_call_all_symbols_read (void)
1212 plugin_t *curplug = plugins_list;
1214 /* Disable any further file-claiming. */
1215 no_more_claiming = TRUE;
1219 if (curplug->all_symbols_read_handler)
1221 enum ld_plugin_status rv;
1222 called_plugin = curplug;
1223 rv = (*curplug->all_symbols_read_handler) ();
1224 called_plugin = NULL;
1226 set_plugin_error (curplug->name);
1228 curplug = curplug->next;
1230 return plugin_error_p () ? -1 : 0;
1233 /* Call 'cleanup' hook for all plugins at exit. */
1235 plugin_call_cleanup (void)
1237 plugin_t *curplug = plugins_list;
1240 if (curplug->cleanup_handler && !curplug->cleanup_done)
1242 enum ld_plugin_status rv;
1243 curplug->cleanup_done = TRUE;
1244 called_plugin = curplug;
1245 rv = (*curplug->cleanup_handler) ();
1246 called_plugin = NULL;
1248 info_msg (_("%P: %s: error in plugin cleanup: %d (ignored)\n"),
1250 dlclose (curplug->dlhandle);
1252 curplug = curplug->next;
1256 /* To determine which symbols should be resolved LDPR_PREVAILING_DEF
1257 and which LDPR_PREVAILING_DEF_IRONLY, we notice all the symbols as
1258 the linker adds them to the linker hash table. Mark those
1259 referenced from a non-IR file with non_ir_ref_regular or
1260 non_ir_ref_dynamic as appropriate. We have to notice_all symbols,
1261 because we won't necessarily know until later which ones will be
1262 contributed by IR files. */
1264 plugin_notice (struct bfd_link_info *info,
1265 struct bfd_link_hash_entry *h,
1266 struct bfd_link_hash_entry *inh,
1272 struct bfd_link_hash_entry *orig_h = h;
1277 bfd_boolean ref = FALSE;
1279 if (h->type == bfd_link_hash_warning)
1282 /* Nothing to do here if this def/ref is from an IR dummy BFD. */
1283 if (is_ir_dummy_bfd (abfd))
1286 /* Making an indirect symbol counts as a reference unless this
1287 is a brand new symbol. */
1288 else if (bfd_is_ind_section (section)
1289 || (flags & BSF_INDIRECT) != 0)
1291 /* ??? Some of this is questionable. See comments in
1292 _bfd_generic_link_add_one_symbol for case IND. */
1293 if (h->type != bfd_link_hash_new
1294 || inh->type == bfd_link_hash_new)
1296 if ((abfd->flags & DYNAMIC) == 0)
1297 inh->non_ir_ref_regular = TRUE;
1299 inh->non_ir_ref_dynamic = TRUE;
1302 if (h->type != bfd_link_hash_new)
1306 /* Nothing to do here for warning symbols. */
1307 else if ((flags & BSF_WARNING) != 0)
1310 /* Nothing to do here for constructor symbols. */
1311 else if ((flags & BSF_CONSTRUCTOR) != 0)
1314 /* If this is a ref, set non_ir_ref. */
1315 else if (bfd_is_und_section (section))
1317 /* Replace the undefined dummy bfd with the real one. */
1318 if ((h->type == bfd_link_hash_undefined
1319 || h->type == bfd_link_hash_undefweak)
1320 && (h->u.undef.abfd == NULL
1321 || (h->u.undef.abfd->flags & BFD_PLUGIN) != 0))
1322 h->u.undef.abfd = abfd;
1326 /* Otherwise, it must be a new def. */
1329 /* Ensure any symbol defined in an IR dummy BFD takes on a
1330 new value from a real BFD. Weak symbols are not normally
1331 overridden by a new weak definition, and strong symbols
1332 will normally cause multiple definition errors. Avoid
1333 this by making the symbol appear to be undefined. */
1334 if (((h->type == bfd_link_hash_defweak
1335 || h->type == bfd_link_hash_defined)
1336 && is_ir_dummy_bfd (sym_bfd = h->u.def.section->owner))
1337 || (h->type == bfd_link_hash_common
1338 && is_ir_dummy_bfd (sym_bfd = h->u.c.p->section->owner)))
1340 h->type = bfd_link_hash_undefweak;
1341 h->u.undef.abfd = sym_bfd;
1344 /* A common symbol should be merged with other commons or
1345 defs with the same name. In particular, a common ought
1346 to be overridden by a def in a -flto object. In that
1347 sense a common is also a ref. */
1348 if (bfd_is_com_section (section))
1354 if ((abfd->flags & DYNAMIC) == 0)
1355 h->non_ir_ref_regular = TRUE;
1357 h->non_ir_ref_dynamic = TRUE;
1361 /* Continue with cref/nocrossref/trace-sym processing. */
1364 || (info->notice_hash != NULL
1365 && bfd_hash_lookup (info->notice_hash, orig_h->root.string,
1366 FALSE, FALSE) != NULL))
1367 return (*orig_callbacks->notice) (info, orig_h, inh,
1368 abfd, section, value, flags);