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);
677 /* The plugin is called to claim symbols in an archive element
678 from plugin_object_p. But those symbols aren't needed to
679 create output. They are defined and referenced only within
692 res = LDPR_PREVAILING_DEF_IRONLY;
698 /* Determine resolution from blhe type and symbol's original type. */
699 if (blhe->type == bfd_link_hash_undefined
700 || blhe->type == bfd_link_hash_undefweak)
705 if (blhe->type != bfd_link_hash_defined
706 && blhe->type != bfd_link_hash_defweak
707 && blhe->type != bfd_link_hash_common)
709 /* We should not have a new, indirect or warning symbol here. */
710 einfo ("%P%F: %s: plugin symbol table corrupt (sym type %d)\n",
711 called_plugin->name, blhe->type);
714 /* Find out which section owns the symbol. Since it's not undef,
715 it must have an owner; if it's not a common symbol, both defs
716 and weakdefs keep it in the same place. */
717 owner_sec = (blhe->type == bfd_link_hash_common
718 ? blhe->u.c.p->section
719 : blhe->u.def.section);
722 /* If it was originally undefined or common, then it has been
723 resolved; determine how. */
724 if (syms[n].def == LDPK_UNDEF
725 || syms[n].def == LDPK_WEAKUNDEF
726 || syms[n].def == LDPK_COMMON)
728 if (owner_sec->owner == link_info.output_bfd)
729 res = LDPR_RESOLVED_EXEC;
730 else if (owner_sec->owner == abfd)
731 res = LDPR_PREVAILING_DEF_IRONLY;
732 else if (is_ir_dummy_bfd (owner_sec->owner))
733 res = LDPR_RESOLVED_IR;
734 else if (owner_sec->owner != NULL
735 && (owner_sec->owner->flags & DYNAMIC) != 0)
736 res = LDPR_RESOLVED_DYN;
738 res = LDPR_RESOLVED_EXEC;
741 /* Was originally def, or weakdef. Does it prevail? If the
742 owner is the original dummy bfd that supplied it, then this
743 is the definition that has prevailed. */
744 else if (owner_sec->owner == link_info.output_bfd)
745 res = LDPR_PREEMPTED_REG;
746 else if (owner_sec->owner == abfd)
747 res = LDPR_PREVAILING_DEF_IRONLY;
749 /* Was originally def, weakdef, or common, but has been pre-empted. */
750 else if (is_ir_dummy_bfd (owner_sec->owner))
751 res = LDPR_PREEMPTED_IR;
753 res = LDPR_PREEMPTED_REG;
755 if (res == LDPR_PREVAILING_DEF_IRONLY)
757 /* We need to know if the sym is referenced from non-IR files. Or
758 even potentially-referenced, perhaps in a future final link if
759 this is a partial one, perhaps dynamically at load-time if the
760 symbol is externally visible. */
761 if (blhe->non_ir_ref)
762 res = LDPR_PREVAILING_DEF;
763 else if (is_visible_from_outside (&syms[n], blhe))
764 res = def_ironly_exp;
768 syms[n].resolution = res;
769 if (report_plugin_symbols)
770 einfo (_("%P: %B: symbol `%s' "
771 "definition: %d, visibility: %d, resolution: %d\n"),
773 syms[n].def, syms[n].visibility, res);
778 static enum ld_plugin_status
779 get_symbols_v1 (const void *handle, int nsyms, struct ld_plugin_symbol *syms)
781 return get_symbols (handle, nsyms, syms, LDPR_PREVAILING_DEF);
784 static enum ld_plugin_status
785 get_symbols_v2 (const void *handle, int nsyms, struct ld_plugin_symbol *syms)
787 return get_symbols (handle, nsyms, syms, LDPR_PREVAILING_DEF_IRONLY_EXP);
790 /* Add a new (real) input file generated by a plugin. */
791 static enum ld_plugin_status
792 add_input_file (const char *pathname)
794 lang_input_statement_type *is;
796 ASSERT (called_plugin);
797 is = lang_add_input_file (xstrdup (pathname), lang_input_file_is_file_enum,
801 is->flags.lto_output = 1;
805 /* Add a new (real) library required by a plugin. */
806 static enum ld_plugin_status
807 add_input_library (const char *pathname)
809 lang_input_statement_type *is;
811 ASSERT (called_plugin);
812 is = lang_add_input_file (xstrdup (pathname), lang_input_file_is_l_enum,
816 is->flags.lto_output = 1;
820 /* Set the extra library path to be used by libraries added via
821 add_input_library. */
822 static enum ld_plugin_status
823 set_extra_library_path (const char *path)
825 ASSERT (called_plugin);
826 ldfile_add_library_path (xstrdup (path), FALSE);
830 /* Issue a diagnostic message from a plugin. */
831 static enum ld_plugin_status
832 message (int level, const char *format, ...)
835 va_start (args, format);
840 vfinfo (stdout, format, args, FALSE);
845 char *newfmt = concat ("%P: warning: ", format, "\n",
846 (const char *) NULL);
847 vfinfo (stdout, newfmt, args, TRUE);
855 char *newfmt = concat (level == LDPL_FATAL ? "%P%F" : "%P%X",
856 ": error: ", format, "\n",
857 (const char *) NULL);
859 vfinfo (stderr, newfmt, args, TRUE);
870 /* Helper to size leading part of tv array and set it up. */
872 set_tv_header (struct ld_plugin_tv *tv)
877 static const unsigned int major = (unsigned)(BFD_VERSION / 100000000UL);
878 static const unsigned int minor = (unsigned)(BFD_VERSION / 1000000UL) % 100;
880 for (i = 0; i < tv_header_size; i++)
882 tv[i].tv_tag = tv_header_tags[i];
883 #define TVU(x) tv[i].tv_u.tv_ ## x
884 switch (tv[i].tv_tag)
887 TVU(message) = message;
889 case LDPT_API_VERSION:
890 TVU(val) = LD_PLUGIN_API_VERSION;
892 case LDPT_GNU_LD_VERSION:
893 TVU(val) = major * 100 + minor;
895 case LDPT_LINKER_OUTPUT:
896 TVU(val) = (bfd_link_relocatable (&link_info) ? LDPO_REL
897 : bfd_link_pde (&link_info) ? LDPO_EXEC
898 : bfd_link_pie (&link_info) ? LDPO_PIE
901 case LDPT_OUTPUT_NAME:
902 TVU(string) = output_filename;
904 case LDPT_REGISTER_CLAIM_FILE_HOOK:
905 TVU(register_claim_file) = register_claim_file;
907 case LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK:
908 TVU(register_all_symbols_read) = register_all_symbols_read;
910 case LDPT_REGISTER_CLEANUP_HOOK:
911 TVU(register_cleanup) = register_cleanup;
913 case LDPT_ADD_SYMBOLS:
914 TVU(add_symbols) = add_symbols;
916 case LDPT_GET_INPUT_FILE:
917 TVU(get_input_file) = get_input_file;
920 TVU(get_view) = get_view;
922 case LDPT_RELEASE_INPUT_FILE:
923 TVU(release_input_file) = release_input_file;
925 case LDPT_GET_SYMBOLS:
926 TVU(get_symbols) = get_symbols_v1;
928 case LDPT_GET_SYMBOLS_V2:
929 TVU(get_symbols) = get_symbols_v2;
931 case LDPT_ADD_INPUT_FILE:
932 TVU(add_input_file) = add_input_file;
934 case LDPT_ADD_INPUT_LIBRARY:
935 TVU(add_input_library) = add_input_library;
937 case LDPT_SET_EXTRA_LIBRARY_PATH:
938 TVU(set_extra_library_path) = set_extra_library_path;
941 /* Added a new entry to the array without adding
942 a new case to set up its value is a bug. */
949 /* Append the per-plugin args list and trailing LDPT_NULL to tv. */
951 set_tv_plugin_args (plugin_t *plugin, struct ld_plugin_tv *tv)
953 plugin_arg_t *arg = plugin->args;
956 tv->tv_tag = LDPT_OPTION;
957 tv->tv_u.tv_string = arg->arg;
961 tv->tv_tag = LDPT_NULL;
965 /* Load up and initialise all plugins after argument parsing. */
967 plugin_load_plugins (void)
969 struct ld_plugin_tv *my_tv;
970 unsigned int max_args = 0;
971 plugin_t *curplug = plugins_list;
973 /* If there are no plugins, we need do nothing this run. */
977 /* First pass over plugins to find max # args needed so that we
978 can size and allocate the tv array. */
981 if (curplug->n_args > max_args)
982 max_args = curplug->n_args;
983 curplug = curplug->next;
986 /* Allocate tv array and initialise constant part. */
987 my_tv = xmalloc ((max_args + 1 + tv_header_size) * sizeof *my_tv);
988 set_tv_header (my_tv);
990 /* Pass over plugins again, activating them. */
991 curplug = plugins_list;
994 enum ld_plugin_status rv;
995 ld_plugin_onload onloadfn;
997 onloadfn = (ld_plugin_onload) dlsym (curplug->dlhandle, "onload");
999 onloadfn = (ld_plugin_onload) dlsym (curplug->dlhandle, "_onload");
1001 einfo (_("%P%F: %s: error loading plugin: %s\n"),
1002 curplug->name, dlerror ());
1003 set_tv_plugin_args (curplug, &my_tv[tv_header_size]);
1004 called_plugin = curplug;
1005 rv = (*onloadfn) (my_tv);
1006 called_plugin = NULL;
1008 einfo (_("%P%F: %s: plugin error: %d\n"), curplug->name, rv);
1009 curplug = curplug->next;
1012 /* Since plugin(s) inited ok, assume they're going to want symbol
1013 resolutions, which needs us to track which symbols are referenced
1014 by non-IR files using the linker's notice callback. */
1015 orig_notice_all = link_info.notice_all;
1016 orig_callbacks = link_info.callbacks;
1017 plugin_callbacks = *orig_callbacks;
1018 plugin_callbacks.notice = &plugin_notice;
1019 link_info.notice_all = TRUE;
1020 link_info.lto_plugin_active = TRUE;
1021 link_info.callbacks = &plugin_callbacks;
1023 register_ld_plugin_object_p (plugin_object_p);
1025 #if HAVE_MMAP && HAVE_GETPAGESIZE
1026 plugin_pagesize = getpagesize ();
1030 /* Call 'claim file' hook for all plugins. */
1032 plugin_call_claim_file (const struct ld_plugin_input_file *file, int *claimed)
1034 plugin_t *curplug = plugins_list;
1036 while (curplug && !*claimed)
1038 if (curplug->claim_file_handler)
1040 enum ld_plugin_status rv;
1041 called_plugin = curplug;
1042 rv = (*curplug->claim_file_handler) (file, claimed);
1043 called_plugin = NULL;
1045 set_plugin_error (curplug->name);
1047 curplug = curplug->next;
1049 return plugin_error_p () ? -1 : 0;
1052 /* Duplicates a character string with memory attached to ABFD. */
1055 plugin_strdup (bfd *abfd, const char *str)
1059 strlength = strlen (str) + 1;
1060 copy = bfd_alloc (abfd, strlength);
1062 einfo (_("%P%F: plugin_strdup failed to allocate memory: %s\n"),
1064 memcpy (copy, str, strlength);
1068 static const bfd_target *
1069 plugin_object_p (bfd *ibfd)
1072 plugin_input_file_t *input;
1073 off_t offset, filesize;
1074 struct ld_plugin_input_file file;
1076 bfd_boolean inarchive;
1080 /* Don't try the dummy object file. */
1081 if ((ibfd->flags & BFD_PLUGIN) != 0)
1084 if (ibfd->plugin_format != bfd_plugin_uknown)
1086 if (ibfd->plugin_format == bfd_plugin_yes)
1087 return ibfd->plugin_dummy_bfd->xvec;
1092 inarchive = bfd_my_archive (ibfd) != NULL;
1093 name = inarchive ? bfd_my_archive (ibfd)->filename : ibfd->filename;
1094 fd = open (name, O_RDONLY | O_BINARY);
1099 /* We create a dummy BFD, initially empty, to house whatever symbols
1100 the plugin may want to add. */
1101 abfd = plugin_get_ir_dummy_bfd (ibfd->filename, ibfd);
1103 input = bfd_alloc (abfd, sizeof (*input));
1105 einfo (_("%P%F: plugin failed to allocate memory for input: %s\n"),
1110 /* Offset and filesize must refer to the individual archive
1111 member, not the whole file, and must exclude the header.
1112 Fortunately for us, that is how the data is stored in the
1113 origin field of the bfd and in the arelt_data. */
1114 offset = ibfd->origin;
1115 filesize = arelt_size (ibfd);
1120 filesize = lseek (fd, 0, SEEK_END);
1122 /* We must copy filename attached to ibfd if it is not an archive
1123 member since it may be freed by bfd_close below. */
1124 name = plugin_strdup (abfd, name);
1128 file.offset = offset;
1129 file.filesize = filesize;
1131 file.handle = input;
1134 input->view_buffer.addr = NULL;
1135 input->view_buffer.filesize = 0;
1136 input->view_buffer.offset = 0;
1138 input->use_mmap = FALSE;
1139 input->offset = offset;
1140 input->filesize = filesize;
1141 input->name = plugin_strdup (abfd, ibfd->filename);
1145 if (plugin_call_claim_file (&file, &claimed))
1146 einfo (_("%P%F: %s: plugin reported error claiming file\n"),
1147 plugin_error_plugin ());
1149 if (input->fd != -1 && ! bfd_plugin_target_p (ibfd->xvec))
1151 /* FIXME: fd belongs to us, not the plugin. GCC plugin, which
1152 doesn't need fd after plugin_call_claim_file, doesn't use
1153 BFD plugin target vector. Since GCC plugin doesn't call
1154 release_input_file, we close it here. LLVM plugin, which
1155 needs fd after plugin_call_claim_file and calls
1156 release_input_file after it is done, uses BFD plugin target
1157 vector. This scheme doesn't work when a plugin needs fd and
1158 doesn't use BFD plugin target vector neither. */
1165 ibfd->plugin_format = bfd_plugin_yes;
1166 ibfd->plugin_dummy_bfd = abfd;
1167 bfd_make_readable (abfd);
1173 if (input->use_mmap)
1175 /* If plugin didn't claim the file, unmap the buffer. */
1176 char *addr = input->view_buffer.addr;
1177 off_t size = input->view_buffer.filesize;
1178 # if HAVE_GETPAGESIZE
1179 off_t bias = input->view_buffer.offset % plugin_pagesize;
1183 munmap (addr, size);
1187 /* If plugin didn't claim the file, we don't need the dummy bfd.
1188 Can't avoid speculatively creating it, alas. */
1189 ibfd->plugin_format = bfd_plugin_no;
1190 bfd_close_all_done (abfd);
1196 plugin_maybe_claim (lang_input_statement_type *entry)
1198 if (plugin_object_p (entry->the_bfd))
1200 bfd *abfd = entry->the_bfd->plugin_dummy_bfd;
1202 /* Discard the real file's BFD and substitute the dummy one. */
1204 /* BFD archive handling caches elements so we can't call
1205 bfd_close for archives. */
1206 if (entry->the_bfd->my_archive == NULL)
1207 bfd_close (entry->the_bfd);
1208 entry->the_bfd = abfd;
1209 entry->flags.claimed = 1;
1213 /* Call 'all symbols read' hook for all plugins. */
1215 plugin_call_all_symbols_read (void)
1217 plugin_t *curplug = plugins_list;
1219 /* Disable any further file-claiming. */
1220 no_more_claiming = TRUE;
1224 if (curplug->all_symbols_read_handler)
1226 enum ld_plugin_status rv;
1227 called_plugin = curplug;
1228 rv = (*curplug->all_symbols_read_handler) ();
1229 called_plugin = NULL;
1231 set_plugin_error (curplug->name);
1233 curplug = curplug->next;
1235 return plugin_error_p () ? -1 : 0;
1238 /* Call 'cleanup' hook for all plugins at exit. */
1240 plugin_call_cleanup (void)
1242 plugin_t *curplug = plugins_list;
1245 if (curplug->cleanup_handler && !curplug->cleanup_done)
1247 enum ld_plugin_status rv;
1248 curplug->cleanup_done = TRUE;
1249 called_plugin = curplug;
1250 rv = (*curplug->cleanup_handler) ();
1251 called_plugin = NULL;
1253 info_msg (_("%P: %s: error in plugin cleanup: %d (ignored)\n"),
1255 dlclose (curplug->dlhandle);
1257 curplug = curplug->next;
1261 /* To determine which symbols should be resolved LDPR_PREVAILING_DEF
1262 and which LDPR_PREVAILING_DEF_IRONLY, we notice all the symbols as
1263 the linker adds them to the linker hash table. Mark those
1264 referenced from a non-IR file with non_ir_ref. We have to
1265 notice_all symbols, because we won't necessarily know until later
1266 which ones will be contributed by IR files. */
1268 plugin_notice (struct bfd_link_info *info,
1269 struct bfd_link_hash_entry *h,
1270 struct bfd_link_hash_entry *inh,
1276 struct bfd_link_hash_entry *orig_h = h;
1282 if (h->type == bfd_link_hash_warning)
1285 /* Nothing to do here if this def/ref is from an IR dummy BFD. */
1286 if (is_ir_dummy_bfd (abfd))
1289 /* Making an indirect symbol counts as a reference unless this
1290 is a brand new symbol. */
1291 else if (bfd_is_ind_section (section)
1292 || (flags & BSF_INDIRECT) != 0)
1294 /* ??? Some of this is questionable. See comments in
1295 _bfd_generic_link_add_one_symbol for case IND. */
1296 if (h->type != bfd_link_hash_new)
1298 h->non_ir_ref = TRUE;
1299 inh->non_ir_ref = TRUE;
1301 else if (inh->type == bfd_link_hash_new)
1302 inh->non_ir_ref = TRUE;
1305 /* Nothing to do here for warning symbols. */
1306 else if ((flags & BSF_WARNING) != 0)
1309 /* Nothing to do here for constructor symbols. */
1310 else if ((flags & BSF_CONSTRUCTOR) != 0)
1313 /* If this is a ref, set non_ir_ref. */
1314 else if (bfd_is_und_section (section))
1316 /* Replace the undefined dummy bfd with the real one. */
1317 if ((h->type == bfd_link_hash_undefined
1318 || h->type == bfd_link_hash_undefweak)
1319 && (h->u.undef.abfd == NULL
1320 || (h->u.undef.abfd->flags & BFD_PLUGIN) != 0))
1321 h->u.undef.abfd = abfd;
1322 h->non_ir_ref = TRUE;
1325 /* Otherwise, it must be a new def. Ensure any symbol defined
1326 in an IR dummy BFD takes on a new value from a real BFD.
1327 Weak symbols are not normally overridden by a new weak
1328 definition, and strong symbols will normally cause multiple
1329 definition errors. Avoid this by making the symbol appear
1331 else if (((h->type == bfd_link_hash_defweak
1332 || h->type == bfd_link_hash_defined)
1333 && is_ir_dummy_bfd (sym_bfd = h->u.def.section->owner))
1334 || (h->type == bfd_link_hash_common
1335 && is_ir_dummy_bfd (sym_bfd = h->u.c.p->section->owner)))
1337 h->type = bfd_link_hash_undefweak;
1338 h->u.undef.abfd = sym_bfd;
1342 /* Continue with cref/nocrossref/trace-sym processing. */
1345 || (info->notice_hash != NULL
1346 && bfd_hash_lookup (info->notice_hash, orig_h->root.string,
1347 FALSE, FALSE) != NULL))
1348 return (*orig_callbacks->notice) (info, orig_h, inh,
1349 abfd, section, value, flags);