1 /* Plugin control for the GNU linker.
2 Copyright 2010, 2011 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 "plugin-api.h"
35 #if !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H)
39 /* Report plugin symbols. */
40 bfd_boolean report_plugin_symbols;
42 /* The suffix to append to the name of the real (claimed) object file
43 when generating a dummy BFD to hold the IR symbols sent from the
44 plugin. For cosmetic use only; appears in maps, crefs etc. */
45 #define IRONLY_SUFFIX " (symbol from plugin)"
47 /* Stores a single argument passed to a plugin. */
48 typedef struct plugin_arg
50 struct plugin_arg *next;
54 /* Holds all details of a single plugin. */
57 /* Next on the list of plugins, or NULL at end of chain. */
59 /* The argument string given to --plugin. */
61 /* The shared library handle returned by dlopen. */
63 /* The list of argument string given to --plugin-opt. */
65 /* Number of args in the list, for convenience. */
67 /* The plugin's event handlers. */
68 ld_plugin_claim_file_handler claim_file_handler;
69 ld_plugin_all_symbols_read_handler all_symbols_read_handler;
70 ld_plugin_cleanup_handler cleanup_handler;
71 /* TRUE if the cleanup handlers have been called. */
72 bfd_boolean cleanup_done;
75 /* The master list of all plugins. */
76 static plugin_t *plugins_list = NULL;
78 /* We keep a tail pointer for easy linking on the end. */
79 static plugin_t **plugins_tail_chain_ptr = &plugins_list;
81 /* The last plugin added to the list, for receiving args. */
82 static plugin_t *last_plugin = NULL;
84 /* The tail of the arg chain of the last plugin added to the list. */
85 static plugin_arg_t **last_plugin_args_tail_chain_ptr = NULL;
87 /* The plugin which is currently having a callback executed. */
88 static plugin_t *called_plugin = NULL;
90 /* Last plugin to cause an error, if any. */
91 static const char *error_plugin = NULL;
93 /* State of linker "notice" interface before we poked at it. */
94 static bfd_boolean orig_notice_all;
96 /* Original linker callbacks, and the plugin version. */
97 static const struct bfd_link_callbacks *orig_callbacks;
98 static struct bfd_link_callbacks plugin_callbacks;
100 /* Set at all symbols read time, to avoid recursively offering the plugin
101 its own newly-added input files and libs to claim. */
102 bfd_boolean no_more_claiming = FALSE;
104 /* List of tags to set in the constant leading part of the tv array. */
105 static const enum ld_plugin_tag tv_header_tags[] =
112 LDPT_REGISTER_CLAIM_FILE_HOOK,
113 LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK,
114 LDPT_REGISTER_CLEANUP_HOOK,
117 LDPT_RELEASE_INPUT_FILE,
120 LDPT_ADD_INPUT_LIBRARY,
121 LDPT_SET_EXTRA_LIBRARY_PATH
124 /* How many entries in the constant leading part of the tv array. */
125 static const size_t tv_header_size = ARRAY_SIZE (tv_header_tags);
127 /* Forward references. */
128 static bfd_boolean plugin_notice (struct bfd_link_info *,
129 struct bfd_link_hash_entry *, bfd *,
130 asection *, bfd_vma, flagword, const char *);
132 #if !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H)
134 #define RTLD_NOW 0 /* Dummy value. */
137 dlopen (const char *file, int mode ATTRIBUTE_UNUSED)
139 return LoadLibrary (file);
143 dlsym (void *handle, const char *name)
145 return GetProcAddress (handle, name);
149 dlclose (void *handle)
151 FreeLibrary (handle);
155 #endif /* !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H) */
157 /* Helper function for exiting with error status. */
159 set_plugin_error (const char *plugin)
161 error_plugin = plugin;
165 /* Test if an error occurred. */
167 plugin_error_p (void)
169 return error_plugin != NULL;
172 /* Return name of plugin which caused an error if any. */
174 plugin_error_plugin (void)
176 return error_plugin ? error_plugin : _("<no plugin>");
179 /* Handle -plugin arg: find and load plugin, or return error. */
181 plugin_opt_plugin (const char *plugin)
185 newplug = xmalloc (sizeof *newplug);
186 memset (newplug, 0, sizeof *newplug);
187 newplug->name = plugin;
188 newplug->dlhandle = dlopen (plugin, RTLD_NOW);
189 if (!newplug->dlhandle)
190 return set_plugin_error (plugin);
192 /* Chain on end, so when we run list it is in command-line order. */
193 *plugins_tail_chain_ptr = newplug;
194 plugins_tail_chain_ptr = &newplug->next;
196 /* Record it as current plugin for receiving args. */
197 last_plugin = newplug;
198 last_plugin_args_tail_chain_ptr = &newplug->args;
202 /* Accumulate option arguments for last-loaded plugin, or return
205 plugin_opt_plugin_arg (const char *arg)
207 plugin_arg_t *newarg;
210 return set_plugin_error (_("<no plugin>"));
212 newarg = xmalloc (sizeof *newarg);
216 /* Chain on end to preserve command-line order. */
217 *last_plugin_args_tail_chain_ptr = newarg;
218 last_plugin_args_tail_chain_ptr = &newarg->next;
219 last_plugin->n_args++;
223 /* Create a dummy BFD. */
225 plugin_get_ir_dummy_bfd (const char *name, bfd *srctemplate)
229 bfd_use_reserved_id = 1;
230 abfd = bfd_create (concat (name, IRONLY_SUFFIX, (const char *) NULL),
234 abfd->flags |= BFD_LINKER_CREATED | BFD_PLUGIN;
235 bfd_set_arch_info (abfd, bfd_get_arch_info (srctemplate));
236 bfd_set_gp_size (abfd, bfd_get_gp_size (srctemplate));
237 if (bfd_make_writable (abfd)
238 && bfd_copy_private_bfd_data (srctemplate, abfd))
242 /* Create section to own the symbols. */
243 flags = (SEC_CODE | SEC_HAS_CONTENTS | SEC_READONLY
244 | SEC_ALLOC | SEC_LOAD | SEC_KEEP | SEC_EXCLUDE);
245 if (bfd_make_section_anyway_with_flags (abfd, ".text", flags))
249 einfo (_("could not create dummy IR bfd: %F%E\n"));
253 /* Check if the BFD passed in is an IR dummy object file. */
255 is_ir_dummy_bfd (const bfd *abfd)
257 /* ABFD can sometimes legitimately be NULL, e.g. when called from one
258 of the linker callbacks for a symbol in the *ABS* or *UND* sections.
259 Likewise, the usrdata field may be NULL if ABFD was added by the
260 backend without a corresponding input statement, as happens e.g.
261 when processing DT_NEEDED dependencies. */
264 && ((lang_input_statement_type *)(abfd->usrdata))->claimed);
267 /* Helpers to convert between BFD and GOLD symbol formats. */
268 static enum ld_plugin_status
269 asymbol_from_plugin_symbol (bfd *abfd, asymbol *asym,
270 const struct ld_plugin_symbol *ldsym)
272 flagword flags = BSF_NO_FLAGS;
273 struct bfd_section *section;
275 asym->the_bfd = abfd;
276 asym->name = (ldsym->version
277 ? concat (ldsym->name, "@", ldsym->version, (const char *) NULL)
287 if (ldsym->comdat_key)
289 char *name = concat (".gnu.linkonce.t.", ldsym->comdat_key,
290 (const char *) NULL);
291 section = bfd_get_section_by_name (abfd, name);
298 sflags = (SEC_CODE | SEC_HAS_CONTENTS | SEC_READONLY
299 | SEC_ALLOC | SEC_LOAD | SEC_KEEP | SEC_EXCLUDE
300 | SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD);
301 section = bfd_make_section_anyway_with_flags (abfd, name, sflags);
307 section = bfd_get_section_by_name (abfd, ".text");
314 section = bfd_und_section_ptr;
319 section = bfd_com_section_ptr;
320 asym->value = ldsym->size;
321 /* For ELF targets, set alignment of common symbol to 1. */
322 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
324 ((elf_symbol_type *) asym)->internal_elf_sym.st_shndx = SHN_COMMON;
325 ((elf_symbol_type *) asym)->internal_elf_sym.st_value = 1;
333 asym->section = section;
335 /* Visibility only applies on ELF targets. */
336 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
338 elf_symbol_type *elfsym = elf_symbol_from (abfd, asym);
339 unsigned char visibility;
342 einfo (_("%P%F: %s: non-ELF symbol in ELF BFD!\n"), asym->name);
343 switch (ldsym->visibility)
346 einfo (_("%P%F: unknown ELF symbol visibility: %d!\n"),
349 visibility = STV_DEFAULT;
352 visibility = STV_PROTECTED;
355 visibility = STV_INTERNAL;
358 visibility = STV_HIDDEN;
361 elfsym->internal_elf_sym.st_other
362 = (visibility | (elfsym->internal_elf_sym.st_other
363 & ~ELF_ST_VISIBILITY (-1)));
369 /* Register a claim-file handler. */
370 static enum ld_plugin_status
371 register_claim_file (ld_plugin_claim_file_handler handler)
373 ASSERT (called_plugin);
374 called_plugin->claim_file_handler = handler;
378 /* Register an all-symbols-read handler. */
379 static enum ld_plugin_status
380 register_all_symbols_read (ld_plugin_all_symbols_read_handler handler)
382 ASSERT (called_plugin);
383 called_plugin->all_symbols_read_handler = handler;
387 /* Register a cleanup handler. */
388 static enum ld_plugin_status
389 register_cleanup (ld_plugin_cleanup_handler handler)
391 ASSERT (called_plugin);
392 called_plugin->cleanup_handler = handler;
396 /* Add symbols from a plugin-claimed input file. */
397 static enum ld_plugin_status
398 add_symbols (void *handle, int nsyms, const struct ld_plugin_symbol *syms)
404 ASSERT (called_plugin);
405 symptrs = xmalloc (nsyms * sizeof *symptrs);
406 for (n = 0; n < nsyms; n++)
408 enum ld_plugin_status rv;
411 bfdsym = bfd_make_empty_symbol (abfd);
413 rv = asymbol_from_plugin_symbol (abfd, bfdsym, syms + n);
417 bfd_set_symtab (abfd, symptrs, nsyms);
421 /* Get the input file information with an open (possibly re-opened)
423 static enum ld_plugin_status
424 get_input_file (const void *handle, struct ld_plugin_input_file *file)
426 ASSERT (called_plugin);
432 /* Release the input file. */
433 static enum ld_plugin_status
434 release_input_file (const void *handle)
436 ASSERT (called_plugin);
441 /* Return TRUE if a defined symbol might be reachable from outside the
442 universe of claimed objects. */
443 static inline bfd_boolean
444 is_visible_from_outside (struct ld_plugin_symbol *lsym, asection *section,
445 struct bfd_link_hash_entry *blhe)
447 struct bfd_sym_chain *sym;
449 /* Section's owner may be NULL if it is the absolute
450 section, fortunately is_ir_dummy_bfd handles that. */
451 if (!is_ir_dummy_bfd (section->owner))
453 if (link_info.relocatable)
455 if (link_info.export_dynamic || link_info.shared)
457 /* Check if symbol is hidden by version script. */
458 if (bfd_hide_sym_by_version (link_info.version_info,
461 /* Only ELF symbols really have visibility. */
462 if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour)
464 struct elf_link_hash_entry *el = (struct elf_link_hash_entry *)blhe;
465 int vis = ELF_ST_VISIBILITY (el->other);
466 return vis == STV_DEFAULT || vis == STV_PROTECTED;
468 /* On non-ELF targets, we can safely make inferences by considering
469 what visibility the plugin would have liked to apply when it first
470 sent us the symbol. During ELF symbol processing, visibility only
471 ever becomes more restrictive, not less, when symbols are merged,
472 so this is a conservative estimate; it may give false positives,
473 declaring something visible from outside when it in fact would
474 not have been, but this will only lead to missed optimisation
475 opportunities during LTRANS at worst; it will not give false
476 negatives, which can lead to the disastrous conclusion that the
477 related symbol is IRONLY. (See GCC PR46319 for an example.) */
478 return (lsym->visibility == LDPV_DEFAULT
479 || lsym->visibility == LDPV_PROTECTED);
482 for (sym = &entry_symbol; sym != NULL; sym = sym->next)
484 && strcmp (sym->name, blhe->root.string) == 0)
490 /* Get the symbol resolution info for a plugin-claimed input file. */
491 static enum ld_plugin_status
492 get_symbols (const void *handle, int nsyms, struct ld_plugin_symbol *syms)
494 const bfd *abfd = handle;
496 ASSERT (called_plugin);
497 for (n = 0; n < nsyms; n++)
499 struct bfd_link_hash_entry *blhe;
502 if (syms[n].def != LDPK_UNDEF)
503 blhe = bfd_link_hash_lookup (link_info.hash, syms[n].name,
506 blhe = bfd_wrapped_link_hash_lookup (link_info.output_bfd, &link_info,
507 syms[n].name, FALSE, FALSE, TRUE);
510 syms[n].resolution = LDPR_UNKNOWN;
514 /* Determine resolution from blhe type and symbol's original type. */
515 if (blhe->type == bfd_link_hash_undefined
516 || blhe->type == bfd_link_hash_undefweak)
518 syms[n].resolution = LDPR_UNDEF;
521 if (blhe->type != bfd_link_hash_defined
522 && blhe->type != bfd_link_hash_defweak
523 && blhe->type != bfd_link_hash_common)
525 /* We should not have a new, indirect or warning symbol here. */
526 einfo ("%P%F: %s: plugin symbol table corrupt (sym type %d)\n",
527 called_plugin->name, blhe->type);
530 /* Find out which section owns the symbol. Since it's not undef,
531 it must have an owner; if it's not a common symbol, both defs
532 and weakdefs keep it in the same place. */
533 owner_sec = (blhe->type == bfd_link_hash_common
534 ? blhe->u.c.p->section
535 : blhe->u.def.section);
537 /* We need to know if the sym is referenced from non-IR files. Or
538 even potentially-referenced, perhaps in a future final link if
539 this is a partial one, perhaps dynamically at load-time if the
540 symbol is externally visible. */
541 ironly = !(blhe->non_ir_ref
542 || is_visible_from_outside (&syms[n], owner_sec, blhe));
544 /* If it was originally undefined or common, then it has been
545 resolved; determine how. */
546 if (syms[n].def == LDPK_UNDEF
547 || syms[n].def == LDPK_WEAKUNDEF
548 || syms[n].def == LDPK_COMMON)
550 if (owner_sec->owner == link_info.output_bfd)
551 syms[n].resolution = LDPR_RESOLVED_EXEC;
552 else if (owner_sec->owner == abfd)
553 syms[n].resolution = (ironly
554 ? LDPR_PREVAILING_DEF_IRONLY
555 : LDPR_PREVAILING_DEF);
556 else if (is_ir_dummy_bfd (owner_sec->owner))
557 syms[n].resolution = LDPR_RESOLVED_IR;
558 else if (owner_sec->owner != NULL
559 && (owner_sec->owner->flags & DYNAMIC) != 0)
560 syms[n].resolution = LDPR_RESOLVED_DYN;
562 syms[n].resolution = LDPR_RESOLVED_EXEC;
566 /* Was originally def, or weakdef. Does it prevail? If the
567 owner is the original dummy bfd that supplied it, then this
568 is the definition that has prevailed. */
569 if (owner_sec->owner == link_info.output_bfd)
570 syms[n].resolution = LDPR_PREEMPTED_REG;
571 else if (owner_sec->owner == abfd)
573 syms[n].resolution = (ironly
574 ? LDPR_PREVAILING_DEF_IRONLY
575 : LDPR_PREVAILING_DEF);
579 /* Was originally def, weakdef, or common, but has been pre-empted. */
580 syms[n].resolution = (is_ir_dummy_bfd (owner_sec->owner)
582 : LDPR_PREEMPTED_REG);
585 if (report_plugin_symbols)
586 einfo (_("%P: %B: symbol `%s' "
587 "definition: %d, visibility: %d, resolution: %d\n"),
589 syms[n].def, syms[n].visibility, syms[n].resolution);
594 /* Add a new (real) input file generated by a plugin. */
595 static enum ld_plugin_status
596 add_input_file (const char *pathname)
598 ASSERT (called_plugin);
599 if (!lang_add_input_file (xstrdup (pathname), lang_input_file_is_file_enum,
605 /* Add a new (real) library required by a plugin. */
606 static enum ld_plugin_status
607 add_input_library (const char *pathname)
609 ASSERT (called_plugin);
610 if (!lang_add_input_file (xstrdup (pathname), lang_input_file_is_l_enum,
616 /* Set the extra library path to be used by libraries added via
617 add_input_library. */
618 static enum ld_plugin_status
619 set_extra_library_path (const char *path)
621 ASSERT (called_plugin);
622 ldfile_add_library_path (xstrdup (path), FALSE);
626 /* Issue a diagnostic message from a plugin. */
627 static enum ld_plugin_status
628 message (int level, const char *format, ...)
631 va_start (args, format);
636 vfinfo (stdout, format, args, FALSE);
640 vfinfo (stdout, format, args, TRUE);
647 char *newfmt = ACONCAT ((level == LDPL_FATAL ? "%P%F: " : "%P%X: ",
648 format, "\n", (const char *) NULL));
650 vfinfo (stderr, newfmt, args, TRUE);
660 /* Helper to size leading part of tv array and set it up. */
662 set_tv_header (struct ld_plugin_tv *tv)
667 static const unsigned int major = (unsigned)(BFD_VERSION / 100000000UL);
668 static const unsigned int minor = (unsigned)(BFD_VERSION / 1000000UL) % 100;
671 return tv_header_size;
673 for (i = 0; i < tv_header_size; i++)
675 tv[i].tv_tag = tv_header_tags[i];
676 #define TVU(x) tv[i].tv_u.tv_ ## x
677 switch (tv[i].tv_tag)
680 TVU(message) = message;
682 case LDPT_API_VERSION:
683 TVU(val) = LD_PLUGIN_API_VERSION;
685 case LDPT_GNU_LD_VERSION:
686 TVU(val) = major * 100 + minor;
688 case LDPT_LINKER_OUTPUT:
689 TVU(val) = (link_info.relocatable
691 : (link_info.shared ? LDPO_DYN : LDPO_EXEC));
693 case LDPT_OUTPUT_NAME:
694 TVU(string) = output_filename;
696 case LDPT_REGISTER_CLAIM_FILE_HOOK:
697 TVU(register_claim_file) = register_claim_file;
699 case LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK:
700 TVU(register_all_symbols_read) = register_all_symbols_read;
702 case LDPT_REGISTER_CLEANUP_HOOK:
703 TVU(register_cleanup) = register_cleanup;
705 case LDPT_ADD_SYMBOLS:
706 TVU(add_symbols) = add_symbols;
708 case LDPT_GET_INPUT_FILE:
709 TVU(get_input_file) = get_input_file;
711 case LDPT_RELEASE_INPUT_FILE:
712 TVU(release_input_file) = release_input_file;
714 case LDPT_GET_SYMBOLS:
715 TVU(get_symbols) = get_symbols;
717 case LDPT_ADD_INPUT_FILE:
718 TVU(add_input_file) = add_input_file;
720 case LDPT_ADD_INPUT_LIBRARY:
721 TVU(add_input_library) = add_input_library;
723 case LDPT_SET_EXTRA_LIBRARY_PATH:
724 TVU(set_extra_library_path) = set_extra_library_path;
727 /* Added a new entry to the array without adding
728 a new case to set up its value is a bug. */
733 return tv_header_size;
736 /* Append the per-plugin args list and trailing LDPT_NULL to tv. */
738 set_tv_plugin_args (plugin_t *plugin, struct ld_plugin_tv *tv)
740 plugin_arg_t *arg = plugin->args;
743 tv->tv_tag = LDPT_OPTION;
744 tv->tv_u.tv_string = arg->arg;
748 tv->tv_tag = LDPT_NULL;
752 /* Return true if any plugins are active this run. Only valid
753 after options have been processed. */
755 plugin_active_plugins_p (void)
757 return plugins_list != NULL;
760 /* Load up and initialise all plugins after argument parsing. */
762 plugin_load_plugins (void)
764 struct ld_plugin_tv *my_tv;
765 unsigned int max_args = 0;
766 plugin_t *curplug = plugins_list;
768 /* If there are no plugins, we need do nothing this run. */
772 /* First pass over plugins to find max # args needed so that we
773 can size and allocate the tv array. */
776 if (curplug->n_args > max_args)
777 max_args = curplug->n_args;
778 curplug = curplug->next;
781 /* Allocate tv array and initialise constant part. */
782 my_tv = xmalloc ((max_args + 1 + tv_header_size) * sizeof *my_tv);
783 set_tv_header (my_tv);
785 /* Pass over plugins again, activating them. */
786 curplug = plugins_list;
789 enum ld_plugin_status rv;
790 ld_plugin_onload onloadfn = dlsym (curplug->dlhandle, "onload");
792 onloadfn = dlsym (curplug->dlhandle, "_onload");
794 return set_plugin_error (curplug->name);
795 set_tv_plugin_args (curplug, &my_tv[tv_header_size]);
796 called_plugin = curplug;
797 rv = (*onloadfn) (my_tv);
798 called_plugin = NULL;
800 return set_plugin_error (curplug->name);
801 curplug = curplug->next;
804 /* Since plugin(s) inited ok, assume they're going to want symbol
805 resolutions, which needs us to track which symbols are referenced
806 by non-IR files using the linker's notice callback. */
807 orig_notice_all = link_info.notice_all;
808 orig_callbacks = link_info.callbacks;
809 plugin_callbacks = *orig_callbacks;
810 plugin_callbacks.notice = &plugin_notice;
811 link_info.notice_all = TRUE;
812 link_info.callbacks = &plugin_callbacks;
817 /* Call 'claim file' hook for all plugins. */
819 plugin_call_claim_file (const struct ld_plugin_input_file *file, int *claimed)
821 plugin_t *curplug = plugins_list;
823 if (no_more_claiming)
825 while (curplug && !*claimed)
827 if (curplug->claim_file_handler)
829 enum ld_plugin_status rv;
830 called_plugin = curplug;
831 rv = (*curplug->claim_file_handler) (file, claimed);
832 called_plugin = NULL;
834 set_plugin_error (curplug->name);
836 curplug = curplug->next;
838 return plugin_error_p () ? -1 : 0;
842 plugin_maybe_claim (struct ld_plugin_input_file *file,
843 lang_input_statement_type *entry)
847 /* We create a dummy BFD, initially empty, to house whatever symbols
848 the plugin may want to add. */
849 file->handle = plugin_get_ir_dummy_bfd (entry->the_bfd->filename,
851 if (plugin_call_claim_file (file, &claimed))
852 einfo (_("%P%F: %s: plugin reported error claiming file\n"),
853 plugin_error_plugin ());
854 /* fd belongs to us, not the plugin; but we don't need it. */
858 /* Discard the real file's BFD and substitute the dummy one. */
860 /* BFD archive handling caches elements so we can't call
861 bfd_close for archives. */
862 if (entry->the_bfd->my_archive == NULL)
863 bfd_close (entry->the_bfd);
864 entry->the_bfd = file->handle;
865 entry->claimed = TRUE;
866 bfd_make_readable (entry->the_bfd);
870 /* If plugin didn't claim the file, we don't need the dummy bfd.
871 Can't avoid speculatively creating it, alas. */
872 bfd_close_all_done (file->handle);
873 entry->claimed = FALSE;
877 /* Call 'all symbols read' hook for all plugins. */
879 plugin_call_all_symbols_read (void)
881 plugin_t *curplug = plugins_list;
883 /* Disable any further file-claiming. */
884 no_more_claiming = TRUE;
888 if (curplug->all_symbols_read_handler)
890 enum ld_plugin_status rv;
891 called_plugin = curplug;
892 rv = (*curplug->all_symbols_read_handler) ();
893 called_plugin = NULL;
895 set_plugin_error (curplug->name);
897 curplug = curplug->next;
899 return plugin_error_p () ? -1 : 0;
902 /* Call 'cleanup' hook for all plugins at exit. */
904 plugin_call_cleanup (void)
906 plugin_t *curplug = plugins_list;
909 if (curplug->cleanup_handler && !curplug->cleanup_done)
911 enum ld_plugin_status rv;
912 curplug->cleanup_done = TRUE;
913 called_plugin = curplug;
914 rv = (*curplug->cleanup_handler) ();
915 called_plugin = NULL;
917 set_plugin_error (curplug->name);
918 dlclose (curplug->dlhandle);
920 curplug = curplug->next;
922 if (plugin_error_p ())
923 info_msg (_("%P: %s: error in plugin cleanup (ignored)\n"),
924 plugin_error_plugin ());
927 /* To determine which symbols should be resolved LDPR_PREVAILING_DEF
928 and which LDPR_PREVAILING_DEF_IRONLY, we notice all the symbols as
929 the linker adds them to the linker hash table. Mark those
930 referenced from a non-IR file with non_ir_ref. We have to
931 notice_all symbols, because we won't necessarily know until later
932 which ones will be contributed by IR files. */
934 plugin_notice (struct bfd_link_info *info,
935 struct bfd_link_hash_entry *h,
946 /* No further processing if this def/ref is from an IR dummy BFD. */
947 if (is_ir_dummy_bfd (abfd))
950 /* Making an indirect symbol counts as a reference unless this
951 is a brand new symbol. */
952 if (bfd_is_ind_section (section)
953 || (flags & BSF_INDIRECT) != 0)
955 if (h->type != bfd_link_hash_new)
957 struct bfd_link_hash_entry *inh;
959 h->non_ir_ref = TRUE;
960 inh = bfd_wrapped_link_hash_lookup (abfd, info, string, FALSE,
963 inh->non_ir_ref = TRUE;
967 /* Nothing to do here for warning symbols. */
968 else if ((flags & BSF_WARNING) != 0)
971 /* Nothing to do here for constructor symbols. */
972 else if ((flags & BSF_CONSTRUCTOR) != 0)
975 /* If this is a ref, set non_ir_ref. */
976 else if (bfd_is_und_section (section))
977 h->non_ir_ref = TRUE;
979 /* Otherwise, it must be a new def. Ensure any symbol defined
980 in an IR dummy BFD takes on a new value from a real BFD.
981 Weak symbols are not normally overridden by a new weak
982 definition, and strong symbols will normally cause multiple
983 definition errors. Avoid this by making the symbol appear
985 else if (((h->type == bfd_link_hash_defweak
986 || h->type == bfd_link_hash_defined)
987 && is_ir_dummy_bfd (sym_bfd = h->u.def.section->owner))
988 || (h->type == bfd_link_hash_common
989 && is_ir_dummy_bfd (sym_bfd = h->u.c.p->section->owner)))
991 h->type = bfd_link_hash_undefweak;
992 h->u.undef.abfd = sym_bfd;
996 /* Continue with cref/nocrossref/trace-sym processing. */
999 || (info->notice_hash != NULL
1000 && bfd_hash_lookup (info->notice_hash, h->root.string,
1001 FALSE, FALSE) != NULL))
1002 return (*orig_callbacks->notice) (info, h,
1003 abfd, section, value, flags, string);