1 /* Plugin control for the GNU linker.
2 Copyright (C) 2010-2016 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"
33 #include "../bfd/plugin.h"
35 #include "plugin-api.h"
38 # include <sys/mman.h>
40 # define MAP_FAILED ((void *) -1)
46 # define MAP_PRIVATE 0
50 #if !(defined(errno) || defined(_MSC_VER) && defined(_INC_ERRNO))
53 #if !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H)
57 /* Report plugin symbols. */
58 bfd_boolean report_plugin_symbols;
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)"
65 /* Stores a single argument passed to a plugin. */
66 typedef struct plugin_arg
68 struct plugin_arg *next;
72 /* Holds all details of a single plugin. */
75 /* Next on the list of plugins, or NULL at end of chain. */
77 /* The argument string given to --plugin. */
79 /* The shared library handle returned by dlopen. */
81 /* The list of argument string given to --plugin-opt. */
83 /* Number of args in the list, for convenience. */
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;
93 typedef struct view_buffer
100 /* The internal version of struct ld_plugin_input_file with a BFD
102 typedef struct plugin_input_file
105 view_buffer_t view_buffer;
108 bfd_boolean use_mmap;
111 } plugin_input_file_t;
113 /* The master list of all plugins. */
114 static plugin_t *plugins_list = NULL;
116 /* We keep a tail pointer for easy linking on the end. */
117 static plugin_t **plugins_tail_chain_ptr = &plugins_list;
119 /* The last plugin added to the list, for receiving args. */
120 static plugin_t *last_plugin = NULL;
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;
125 /* The plugin which is currently having a callback executed. */
126 static plugin_t *called_plugin = NULL;
128 /* Last plugin to cause an error, if any. */
129 static const char *error_plugin = NULL;
131 /* State of linker "notice" interface before we poked at it. */
132 static bfd_boolean orig_notice_all;
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;
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;
142 #if HAVE_MMAP && HAVE_GETPAGESIZE
143 /* Page size used by mmap. */
144 static off_t plugin_pagesize;
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[] =
155 LDPT_REGISTER_CLAIM_FILE_HOOK,
156 LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK,
157 LDPT_REGISTER_CLEANUP_HOOK,
161 LDPT_RELEASE_INPUT_FILE,
165 LDPT_ADD_INPUT_LIBRARY,
166 LDPT_SET_EXTRA_LIBRARY_PATH
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);
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);
178 static const bfd_target * plugin_object_p (bfd *);
180 #if !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H)
182 #define RTLD_NOW 0 /* Dummy value. */
185 dlopen (const char *file, int mode ATTRIBUTE_UNUSED)
187 return LoadLibrary (file);
191 dlsym (void *handle, const char *name)
193 return GetProcAddress (handle, name);
197 dlclose (void *handle)
199 FreeLibrary (handle);
203 #endif /* !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H) */
213 /* Helper function for exiting with error status. */
215 set_plugin_error (const char *plugin)
217 error_plugin = plugin;
221 /* Test if an error occurred. */
223 plugin_error_p (void)
225 return error_plugin != NULL;
228 /* Return name of plugin which caused an error if any. */
230 plugin_error_plugin (void)
232 return error_plugin ? error_plugin : _("<no plugin>");
235 /* Handle -plugin arg: find and load plugin, or return error. */
237 plugin_opt_plugin (const char *plugin)
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 ());
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;
252 /* Record it as current plugin for receiving args. */
253 last_plugin = newplug;
254 last_plugin_args_tail_chain_ptr = &newplug->args;
257 /* Accumulate option arguments for last-loaded plugin, or return
260 plugin_opt_plugin_arg (const char *arg)
262 plugin_arg_t *newarg;
265 return set_plugin_error (_("<no plugin>"));
267 /* Ignore -pass-through= from GCC driver. */
270 const char *p = arg + 1;
274 if (strncmp (p, "pass-through=", 13) == 0)
278 newarg = xmalloc (sizeof *newarg);
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++;
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. */
295 plugin_get_ir_dummy_bfd (const char *name, bfd *srctemplate)
298 bfd_boolean bfd_plugin_target;
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);
306 abfd->flags |= BFD_LINKER_CREATED | BFD_PLUGIN;
307 if (!bfd_make_writable (abfd))
309 if (!bfd_plugin_target)
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))
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))
327 einfo (_("could not create dummy IR bfd: %F%E\n"));
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)
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;
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)
345 flagword flags = BSF_NO_FLAGS;
346 struct bfd_section *section;
348 asym->the_bfd = abfd;
349 asym->name = (ldsym->version
350 ? concat (ldsym->name, "@", ldsym->version, (const char *) NULL)
360 if (ldsym->comdat_key)
362 char *name = concat (".gnu.linkonce.t.", ldsym->comdat_key,
363 (const char *) NULL);
364 section = bfd_get_section_by_name (abfd, name);
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);
380 section = bfd_get_section_by_name (abfd, ".text");
387 section = bfd_und_section_ptr;
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)
397 ((elf_symbol_type *) asym)->internal_elf_sym.st_shndx = SHN_COMMON;
398 ((elf_symbol_type *) asym)->internal_elf_sym.st_value = 1;
406 asym->section = section;
408 /* Visibility only applies on ELF targets. */
409 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
411 elf_symbol_type *elfsym = elf_symbol_from (abfd, asym);
412 unsigned char visibility;
415 einfo (_("%P%F: %s: non-ELF symbol in ELF BFD!\n"), asym->name);
416 switch (ldsym->visibility)
419 einfo (_("%P%F: unknown ELF symbol visibility: %d!\n"),
422 visibility = STV_DEFAULT;
425 visibility = STV_PROTECTED;
428 visibility = STV_INTERNAL;
431 visibility = STV_HIDDEN;
434 elfsym->internal_elf_sym.st_other
435 = (visibility | (elfsym->internal_elf_sym.st_other
436 & ~ELF_ST_VISIBILITY (-1)));
442 /* Register a claim-file handler. */
443 static enum ld_plugin_status
444 register_claim_file (ld_plugin_claim_file_handler handler)
446 ASSERT (called_plugin);
447 called_plugin->claim_file_handler = handler;
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)
455 ASSERT (called_plugin);
456 called_plugin->all_symbols_read_handler = handler;
460 /* Register a cleanup handler. */
461 static enum ld_plugin_status
462 register_cleanup (ld_plugin_cleanup_handler handler)
464 ASSERT (called_plugin);
465 called_plugin->cleanup_handler = handler;
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)
474 plugin_input_file_t *input = handle;
475 bfd *abfd = input->abfd;
478 ASSERT (called_plugin);
479 symptrs = xmalloc (nsyms * sizeof *symptrs);
480 for (n = 0; n < nsyms; n++)
482 enum ld_plugin_status rv;
485 bfdsym = bfd_make_empty_symbol (abfd);
487 rv = asymbol_from_plugin_symbol (abfd, bfdsym, syms + n);
491 bfd_set_symtab (abfd, symptrs, nsyms);
495 /* Get the input file information with an open (possibly re-opened)
497 static enum ld_plugin_status
498 get_input_file (const void *handle, struct ld_plugin_input_file *file)
500 const plugin_input_file_t *input = handle;
502 ASSERT (called_plugin);
504 file->name = input->name;
505 file->offset = input->offset;
506 file->filesize = input->filesize;
507 file->handle = (void *) handle;
512 /* Get view of the input file. */
513 static enum ld_plugin_status
514 get_view (const void *handle, const void **viewp)
516 plugin_input_file_t *input = (plugin_input_file_t *) handle;
518 size_t size = input->filesize;
519 off_t offset = input->offset;
520 #if HAVE_MMAP && HAVE_GETPAGESIZE
524 ASSERT (called_plugin);
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);
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)
536 *viewp = input->view_buffer.addr;
540 input->view_buffer.filesize = size;
541 input->view_buffer.offset = offset;
544 # if HAVE_GETPAGESIZE
545 bias = offset % plugin_pagesize;
549 buffer = mmap (NULL, size, PROT_READ, MAP_PRIVATE, input->fd, offset);
550 if (buffer != MAP_FAILED)
552 input->use_mmap = TRUE;
553 # if HAVE_GETPAGESIZE
562 input->use_mmap = FALSE;
564 if (lseek (input->fd, offset, SEEK_SET) < 0)
567 buffer = bfd_alloc (input->abfd, size);
574 ssize_t got = read (input->fd, p, size);
582 else if (errno != EINTR)
588 input->view_buffer.addr = buffer;
594 /* Release the input file. */
595 static enum ld_plugin_status
596 release_input_file (const void *handle)
598 plugin_input_file_t *input = (plugin_input_file_t *) handle;
599 ASSERT (called_plugin);
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)
614 struct bfd_sym_chain *sym;
616 if (bfd_link_relocatable (&link_info))
618 if (link_info.export_dynamic || bfd_link_dll (&link_info))
620 /* Check if symbol is hidden by version script. */
621 if (bfd_hide_sym_by_version (link_info.version_info,
624 /* Only ELF symbols really have visibility. */
625 if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour)
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;
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);
645 for (sym = &entry_symbol; sym != NULL; sym = sym->next)
647 && strcmp (sym->name, blhe->root.string) == 0)
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,
658 const plugin_input_file_t *input = handle;
659 const bfd *abfd = (const bfd *) input->abfd;
662 ASSERT (called_plugin);
663 for (n = 0; n < nsyms; n++)
665 struct bfd_link_hash_entry *blhe;
669 if (syms[n].def != LDPK_UNDEF)
670 blhe = bfd_link_hash_lookup (link_info.hash, syms[n].name,
673 blhe = bfd_wrapped_link_hash_lookup (link_info.output_bfd, &link_info,
674 syms[n].name, FALSE, FALSE, TRUE);
681 /* Determine resolution from blhe type and symbol's original type. */
682 if (blhe->type == bfd_link_hash_undefined
683 || blhe->type == bfd_link_hash_undefweak)
688 if (blhe->type != bfd_link_hash_defined
689 && blhe->type != bfd_link_hash_defweak
690 && blhe->type != bfd_link_hash_common)
692 /* We should not have a new, indirect or warning symbol here. */
693 einfo ("%P%F: %s: plugin symbol table corrupt (sym type %d)\n",
694 called_plugin->name, blhe->type);
697 /* Find out which section owns the symbol. Since it's not undef,
698 it must have an owner; if it's not a common symbol, both defs
699 and weakdefs keep it in the same place. */
700 owner_sec = (blhe->type == bfd_link_hash_common
701 ? blhe->u.c.p->section
702 : blhe->u.def.section);
705 /* If it was originally undefined or common, then it has been
706 resolved; determine how. */
707 if (syms[n].def == LDPK_UNDEF
708 || syms[n].def == LDPK_WEAKUNDEF
709 || syms[n].def == LDPK_COMMON)
711 if (owner_sec->owner == link_info.output_bfd)
712 res = LDPR_RESOLVED_EXEC;
713 else if (owner_sec->owner == abfd)
714 res = LDPR_PREVAILING_DEF_IRONLY;
715 else if (is_ir_dummy_bfd (owner_sec->owner))
716 res = LDPR_RESOLVED_IR;
717 else if (owner_sec->owner != NULL
718 && (owner_sec->owner->flags & DYNAMIC) != 0)
719 res = LDPR_RESOLVED_DYN;
721 res = LDPR_RESOLVED_EXEC;
724 /* Was originally def, or weakdef. Does it prevail? If the
725 owner is the original dummy bfd that supplied it, then this
726 is the definition that has prevailed. */
727 else if (owner_sec->owner == link_info.output_bfd)
728 res = LDPR_PREEMPTED_REG;
729 else if (owner_sec->owner == abfd)
730 res = LDPR_PREVAILING_DEF_IRONLY;
732 /* Was originally def, weakdef, or common, but has been pre-empted. */
733 else if (is_ir_dummy_bfd (owner_sec->owner))
734 res = LDPR_PREEMPTED_IR;
736 res = LDPR_PREEMPTED_REG;
738 if (res == LDPR_PREVAILING_DEF_IRONLY)
740 /* We need to know if the sym is referenced from non-IR files. Or
741 even potentially-referenced, perhaps in a future final link if
742 this is a partial one, perhaps dynamically at load-time if the
743 symbol is externally visible. */
744 if (blhe->non_ir_ref)
745 res = LDPR_PREVAILING_DEF;
746 else if (is_visible_from_outside (&syms[n], blhe))
747 res = def_ironly_exp;
751 syms[n].resolution = res;
752 if (report_plugin_symbols)
753 einfo (_("%P: %B: symbol `%s' "
754 "definition: %d, visibility: %d, resolution: %d\n"),
756 syms[n].def, syms[n].visibility, res);
761 static enum ld_plugin_status
762 get_symbols_v1 (const void *handle, int nsyms, struct ld_plugin_symbol *syms)
764 return get_symbols (handle, nsyms, syms, LDPR_PREVAILING_DEF);
767 static enum ld_plugin_status
768 get_symbols_v2 (const void *handle, int nsyms, struct ld_plugin_symbol *syms)
770 return get_symbols (handle, nsyms, syms, LDPR_PREVAILING_DEF_IRONLY_EXP);
773 /* Add a new (real) input file generated by a plugin. */
774 static enum ld_plugin_status
775 add_input_file (const char *pathname)
777 lang_input_statement_type *is;
779 ASSERT (called_plugin);
780 is = lang_add_input_file (xstrdup (pathname), lang_input_file_is_file_enum,
784 is->flags.lto_output = 1;
788 /* Add a new (real) library required by a plugin. */
789 static enum ld_plugin_status
790 add_input_library (const char *pathname)
792 lang_input_statement_type *is;
794 ASSERT (called_plugin);
795 is = lang_add_input_file (xstrdup (pathname), lang_input_file_is_l_enum,
799 is->flags.lto_output = 1;
803 /* Set the extra library path to be used by libraries added via
804 add_input_library. */
805 static enum ld_plugin_status
806 set_extra_library_path (const char *path)
808 ASSERT (called_plugin);
809 ldfile_add_library_path (xstrdup (path), FALSE);
813 /* Issue a diagnostic message from a plugin. */
814 static enum ld_plugin_status
815 message (int level, const char *format, ...)
818 va_start (args, format);
823 vfinfo (stdout, format, args, FALSE);
828 char *newfmt = concat ("%P: warning: ", format, "\n",
829 (const char *) NULL);
830 vfinfo (stdout, newfmt, args, TRUE);
838 char *newfmt = concat (level == LDPL_FATAL ? "%P%F" : "%P%X",
839 ": error: ", format, "\n",
840 (const char *) NULL);
842 vfinfo (stderr, newfmt, args, TRUE);
853 /* Helper to size leading part of tv array and set it up. */
855 set_tv_header (struct ld_plugin_tv *tv)
860 static const unsigned int major = (unsigned)(BFD_VERSION / 100000000UL);
861 static const unsigned int minor = (unsigned)(BFD_VERSION / 1000000UL) % 100;
863 for (i = 0; i < tv_header_size; i++)
865 tv[i].tv_tag = tv_header_tags[i];
866 #define TVU(x) tv[i].tv_u.tv_ ## x
867 switch (tv[i].tv_tag)
870 TVU(message) = message;
872 case LDPT_API_VERSION:
873 TVU(val) = LD_PLUGIN_API_VERSION;
875 case LDPT_GNU_LD_VERSION:
876 TVU(val) = major * 100 + minor;
878 case LDPT_LINKER_OUTPUT:
879 TVU(val) = (bfd_link_relocatable (&link_info) ? LDPO_REL
880 : bfd_link_pde (&link_info) ? LDPO_EXEC
881 : bfd_link_pie (&link_info) ? LDPO_PIE
884 case LDPT_OUTPUT_NAME:
885 TVU(string) = output_filename;
887 case LDPT_REGISTER_CLAIM_FILE_HOOK:
888 TVU(register_claim_file) = register_claim_file;
890 case LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK:
891 TVU(register_all_symbols_read) = register_all_symbols_read;
893 case LDPT_REGISTER_CLEANUP_HOOK:
894 TVU(register_cleanup) = register_cleanup;
896 case LDPT_ADD_SYMBOLS:
897 TVU(add_symbols) = add_symbols;
899 case LDPT_GET_INPUT_FILE:
900 TVU(get_input_file) = get_input_file;
903 TVU(get_view) = get_view;
905 case LDPT_RELEASE_INPUT_FILE:
906 TVU(release_input_file) = release_input_file;
908 case LDPT_GET_SYMBOLS:
909 TVU(get_symbols) = get_symbols_v1;
911 case LDPT_GET_SYMBOLS_V2:
912 TVU(get_symbols) = get_symbols_v2;
914 case LDPT_ADD_INPUT_FILE:
915 TVU(add_input_file) = add_input_file;
917 case LDPT_ADD_INPUT_LIBRARY:
918 TVU(add_input_library) = add_input_library;
920 case LDPT_SET_EXTRA_LIBRARY_PATH:
921 TVU(set_extra_library_path) = set_extra_library_path;
924 /* Added a new entry to the array without adding
925 a new case to set up its value is a bug. */
932 /* Append the per-plugin args list and trailing LDPT_NULL to tv. */
934 set_tv_plugin_args (plugin_t *plugin, struct ld_plugin_tv *tv)
936 plugin_arg_t *arg = plugin->args;
939 tv->tv_tag = LDPT_OPTION;
940 tv->tv_u.tv_string = arg->arg;
944 tv->tv_tag = LDPT_NULL;
948 /* Load up and initialise all plugins after argument parsing. */
950 plugin_load_plugins (void)
952 struct ld_plugin_tv *my_tv;
953 unsigned int max_args = 0;
954 plugin_t *curplug = plugins_list;
956 /* If there are no plugins, we need do nothing this run. */
960 /* First pass over plugins to find max # args needed so that we
961 can size and allocate the tv array. */
964 if (curplug->n_args > max_args)
965 max_args = curplug->n_args;
966 curplug = curplug->next;
969 /* Allocate tv array and initialise constant part. */
970 my_tv = xmalloc ((max_args + 1 + tv_header_size) * sizeof *my_tv);
971 set_tv_header (my_tv);
973 /* Pass over plugins again, activating them. */
974 curplug = plugins_list;
977 enum ld_plugin_status rv;
978 ld_plugin_onload onloadfn;
980 onloadfn = (ld_plugin_onload) dlsym (curplug->dlhandle, "onload");
982 onloadfn = (ld_plugin_onload) dlsym (curplug->dlhandle, "_onload");
984 einfo (_("%P%F: %s: error loading plugin: %s\n"),
985 curplug->name, dlerror ());
986 set_tv_plugin_args (curplug, &my_tv[tv_header_size]);
987 called_plugin = curplug;
988 rv = (*onloadfn) (my_tv);
989 called_plugin = NULL;
991 einfo (_("%P%F: %s: plugin error: %d\n"), curplug->name, rv);
992 curplug = curplug->next;
995 /* Since plugin(s) inited ok, assume they're going to want symbol
996 resolutions, which needs us to track which symbols are referenced
997 by non-IR files using the linker's notice callback. */
998 orig_notice_all = link_info.notice_all;
999 orig_callbacks = link_info.callbacks;
1000 plugin_callbacks = *orig_callbacks;
1001 plugin_callbacks.notice = &plugin_notice;
1002 link_info.notice_all = TRUE;
1003 link_info.lto_plugin_active = TRUE;
1004 link_info.callbacks = &plugin_callbacks;
1006 register_ld_plugin_object_p (plugin_object_p);
1008 #if HAVE_MMAP && HAVE_GETPAGESIZE
1009 plugin_pagesize = getpagesize ();
1013 /* Call 'claim file' hook for all plugins. */
1015 plugin_call_claim_file (const struct ld_plugin_input_file *file, int *claimed)
1017 plugin_t *curplug = plugins_list;
1019 if (no_more_claiming)
1021 while (curplug && !*claimed)
1023 if (curplug->claim_file_handler)
1025 enum ld_plugin_status rv;
1026 called_plugin = curplug;
1027 rv = (*curplug->claim_file_handler) (file, claimed);
1028 called_plugin = NULL;
1030 set_plugin_error (curplug->name);
1032 curplug = curplug->next;
1034 return plugin_error_p () ? -1 : 0;
1037 /* Duplicates a character string with memory attached to ABFD. */
1040 plugin_strdup (bfd *abfd, const char *str)
1044 strlength = strlen (str) + 1;
1045 copy = bfd_alloc (abfd, strlength);
1047 einfo (_("%P%F: plugin_strdup failed to allocate memory: %s\n"),
1049 memcpy (copy, str, strlength);
1053 static const bfd_target *
1054 plugin_object_p (bfd *ibfd)
1057 plugin_input_file_t *input;
1058 off_t offset, filesize;
1059 struct ld_plugin_input_file file;
1061 bfd_boolean inarchive;
1065 /* Don't try the dummy object file. */
1066 if ((ibfd->flags & BFD_PLUGIN) != 0)
1069 if (ibfd->plugin_format != bfd_plugin_uknown)
1071 if (ibfd->plugin_format == bfd_plugin_yes)
1072 return ibfd->plugin_dummy_bfd->xvec;
1077 inarchive = bfd_my_archive (ibfd) != NULL;
1078 name = inarchive ? bfd_my_archive (ibfd)->filename : ibfd->filename;
1079 fd = open (name, O_RDONLY | O_BINARY);
1084 /* We create a dummy BFD, initially empty, to house whatever symbols
1085 the plugin may want to add. */
1086 abfd = plugin_get_ir_dummy_bfd (ibfd->filename, ibfd);
1088 input = bfd_alloc (abfd, sizeof (*input));
1090 einfo (_("%P%F: plugin failed to allocate memory for input: %s\n"),
1095 /* Offset and filesize must refer to the individual archive
1096 member, not the whole file, and must exclude the header.
1097 Fortunately for us, that is how the data is stored in the
1098 origin field of the bfd and in the arelt_data. */
1099 offset = ibfd->origin;
1100 filesize = arelt_size (ibfd);
1105 filesize = lseek (fd, 0, SEEK_END);
1107 /* We must copy filename attached to ibfd if it is not an archive
1108 member since it may be freed by bfd_close below. */
1109 name = plugin_strdup (abfd, name);
1113 file.offset = offset;
1114 file.filesize = filesize;
1116 file.handle = input;
1119 input->view_buffer.addr = NULL;
1120 input->view_buffer.filesize = 0;
1121 input->view_buffer.offset = 0;
1123 input->use_mmap = FALSE;
1124 input->offset = offset;
1125 input->filesize = filesize;
1126 input->name = plugin_strdup (abfd, ibfd->filename);
1130 if (plugin_call_claim_file (&file, &claimed))
1131 einfo (_("%P%F: %s: plugin reported error claiming file\n"),
1132 plugin_error_plugin ());
1134 if (input->fd != -1 && ! bfd_plugin_target_p (ibfd->xvec))
1136 /* FIXME: fd belongs to us, not the plugin. GCC plugin, which
1137 doesn't need fd after plugin_call_claim_file, doesn't use
1138 BFD plugin target vector. Since GCC plugin doesn't call
1139 release_input_file, we close it here. LLVM plugin, which
1140 needs fd after plugin_call_claim_file and calls
1141 release_input_file after it is done, uses BFD plugin target
1142 vector. This scheme doesn't work when a plugin needs fd and
1143 doesn't use BFD plugin target vector neither. */
1150 ibfd->plugin_format = bfd_plugin_yes;
1151 ibfd->plugin_dummy_bfd = abfd;
1152 bfd_make_readable (abfd);
1158 if (input->use_mmap)
1160 /* If plugin didn't claim the file, unmap the buffer. */
1161 char *addr = input->view_buffer.addr;
1162 off_t size = input->view_buffer.filesize;
1163 # if HAVE_GETPAGESIZE
1164 off_t bias = input->view_buffer.offset % plugin_pagesize;
1168 munmap (addr, size);
1172 /* If plugin didn't claim the file, we don't need the dummy bfd.
1173 Can't avoid speculatively creating it, alas. */
1174 ibfd->plugin_format = bfd_plugin_no;
1175 bfd_close_all_done (abfd);
1181 plugin_maybe_claim (lang_input_statement_type *entry)
1183 if (plugin_object_p (entry->the_bfd))
1185 bfd *abfd = entry->the_bfd->plugin_dummy_bfd;
1187 /* Discard the real file's BFD and substitute the dummy one. */
1189 /* BFD archive handling caches elements so we can't call
1190 bfd_close for archives. */
1191 if (entry->the_bfd->my_archive == NULL)
1192 bfd_close (entry->the_bfd);
1193 entry->the_bfd = abfd;
1194 entry->flags.claimed = 1;
1198 /* Call 'all symbols read' hook for all plugins. */
1200 plugin_call_all_symbols_read (void)
1202 plugin_t *curplug = plugins_list;
1204 /* Disable any further file-claiming. */
1205 no_more_claiming = TRUE;
1209 if (curplug->all_symbols_read_handler)
1211 enum ld_plugin_status rv;
1212 called_plugin = curplug;
1213 rv = (*curplug->all_symbols_read_handler) ();
1214 called_plugin = NULL;
1216 set_plugin_error (curplug->name);
1218 curplug = curplug->next;
1220 return plugin_error_p () ? -1 : 0;
1223 /* Call 'cleanup' hook for all plugins at exit. */
1225 plugin_call_cleanup (void)
1227 plugin_t *curplug = plugins_list;
1230 if (curplug->cleanup_handler && !curplug->cleanup_done)
1232 enum ld_plugin_status rv;
1233 curplug->cleanup_done = TRUE;
1234 called_plugin = curplug;
1235 rv = (*curplug->cleanup_handler) ();
1236 called_plugin = NULL;
1238 info_msg (_("%P: %s: error in plugin cleanup: %d (ignored)\n"),
1240 dlclose (curplug->dlhandle);
1242 curplug = curplug->next;
1246 /* To determine which symbols should be resolved LDPR_PREVAILING_DEF
1247 and which LDPR_PREVAILING_DEF_IRONLY, we notice all the symbols as
1248 the linker adds them to the linker hash table. Mark those
1249 referenced from a non-IR file with non_ir_ref. We have to
1250 notice_all symbols, because we won't necessarily know until later
1251 which ones will be contributed by IR files. */
1253 plugin_notice (struct bfd_link_info *info,
1254 struct bfd_link_hash_entry *h,
1255 struct bfd_link_hash_entry *inh,
1261 struct bfd_link_hash_entry *orig_h = h;
1267 if (h->type == bfd_link_hash_warning)
1270 /* Nothing to do here if this def/ref is from an IR dummy BFD. */
1271 if (is_ir_dummy_bfd (abfd))
1274 /* Making an indirect symbol counts as a reference unless this
1275 is a brand new symbol. */
1276 else if (bfd_is_ind_section (section)
1277 || (flags & BSF_INDIRECT) != 0)
1279 /* ??? Some of this is questionable. See comments in
1280 _bfd_generic_link_add_one_symbol for case IND. */
1281 if (h->type != bfd_link_hash_new)
1283 h->non_ir_ref = TRUE;
1284 inh->non_ir_ref = TRUE;
1286 else if (inh->type == bfd_link_hash_new)
1287 inh->non_ir_ref = TRUE;
1290 /* Nothing to do here for warning symbols. */
1291 else if ((flags & BSF_WARNING) != 0)
1294 /* Nothing to do here for constructor symbols. */
1295 else if ((flags & BSF_CONSTRUCTOR) != 0)
1298 /* If this is a ref, set non_ir_ref. */
1299 else if (bfd_is_und_section (section))
1301 /* Replace the undefined dummy bfd with the real one. */
1302 if ((h->type == bfd_link_hash_undefined
1303 || h->type == bfd_link_hash_undefweak)
1304 && (h->u.undef.abfd == NULL
1305 || (h->u.undef.abfd->flags & BFD_PLUGIN) != 0))
1306 h->u.undef.abfd = abfd;
1307 h->non_ir_ref = TRUE;
1310 /* Otherwise, it must be a new def. Ensure any symbol defined
1311 in an IR dummy BFD takes on a new value from a real BFD.
1312 Weak symbols are not normally overridden by a new weak
1313 definition, and strong symbols will normally cause multiple
1314 definition errors. Avoid this by making the symbol appear
1316 else if (((h->type == bfd_link_hash_defweak
1317 || h->type == bfd_link_hash_defined)
1318 && is_ir_dummy_bfd (sym_bfd = h->u.def.section->owner))
1319 || (h->type == bfd_link_hash_common
1320 && is_ir_dummy_bfd (sym_bfd = h->u.c.p->section->owner)))
1322 h->type = bfd_link_hash_undefweak;
1323 h->u.undef.abfd = sym_bfd;
1327 /* Continue with cref/nocrossref/trace-sym processing. */
1330 || (info->notice_hash != NULL
1331 && bfd_hash_lookup (info->notice_hash, orig_h->root.string,
1332 FALSE, FALSE) != NULL))
1333 return (*orig_callbacks->notice) (info, orig_h, inh,
1334 abfd, section, value, flags);