1 /* Plugin control for the GNU linker.
2 Copyright (C) 2010-2014 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
,
121 LDPT_ADD_INPUT_LIBRARY
,
122 LDPT_SET_EXTRA_LIBRARY_PATH
125 /* How many entries in the constant leading part of the tv array. */
126 static const size_t tv_header_size
= ARRAY_SIZE (tv_header_tags
);
128 /* Forward references. */
129 static bfd_boolean
plugin_notice (struct bfd_link_info
*,
130 struct bfd_link_hash_entry
*, bfd
*,
131 asection
*, bfd_vma
, flagword
, const char *);
133 #if !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H)
135 #define RTLD_NOW 0 /* Dummy value. */
138 dlopen (const char *file
, int mode ATTRIBUTE_UNUSED
)
140 return LoadLibrary (file
);
144 dlsym (void *handle
, const char *name
)
146 return GetProcAddress (handle
, name
);
150 dlclose (void *handle
)
152 FreeLibrary (handle
);
156 #endif /* !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H) */
166 /* Helper function for exiting with error status. */
168 set_plugin_error (const char *plugin
)
170 error_plugin
= plugin
;
174 /* Test if an error occurred. */
176 plugin_error_p (void)
178 return error_plugin
!= NULL
;
181 /* Return name of plugin which caused an error if any. */
183 plugin_error_plugin (void)
185 return error_plugin
? error_plugin
: _("<no plugin>");
188 /* Handle -plugin arg: find and load plugin, or return error. */
190 plugin_opt_plugin (const char *plugin
)
194 newplug
= xmalloc (sizeof *newplug
);
195 memset (newplug
, 0, sizeof *newplug
);
196 newplug
->name
= plugin
;
197 newplug
->dlhandle
= dlopen (plugin
, RTLD_NOW
);
198 if (!newplug
->dlhandle
)
199 einfo (_("%P%F: %s: error loading plugin: %s\n"), plugin
, dlerror ());
201 /* Chain on end, so when we run list it is in command-line order. */
202 *plugins_tail_chain_ptr
= newplug
;
203 plugins_tail_chain_ptr
= &newplug
->next
;
205 /* Record it as current plugin for receiving args. */
206 last_plugin
= newplug
;
207 last_plugin_args_tail_chain_ptr
= &newplug
->args
;
210 /* Accumulate option arguments for last-loaded plugin, or return
213 plugin_opt_plugin_arg (const char *arg
)
215 plugin_arg_t
*newarg
;
218 return set_plugin_error (_("<no plugin>"));
220 /* Ignore -pass-through= from GCC driver. */
223 const char *p
= arg
+ 1;
227 if (strncmp (p
, "pass-through=", 13) == 0)
231 newarg
= xmalloc (sizeof *newarg
);
235 /* Chain on end to preserve command-line order. */
236 *last_plugin_args_tail_chain_ptr
= newarg
;
237 last_plugin_args_tail_chain_ptr
= &newarg
->next
;
238 last_plugin
->n_args
++;
242 /* Create a dummy BFD. */
244 plugin_get_ir_dummy_bfd (const char *name
, bfd
*srctemplate
)
248 bfd_use_reserved_id
= 1;
249 abfd
= bfd_create (concat (name
, IRONLY_SUFFIX
, (const char *) NULL
),
253 abfd
->flags
|= BFD_LINKER_CREATED
| BFD_PLUGIN
;
254 bfd_set_arch_info (abfd
, bfd_get_arch_info (srctemplate
));
255 bfd_set_gp_size (abfd
, bfd_get_gp_size (srctemplate
));
256 if (bfd_make_writable (abfd
)
257 && bfd_copy_private_bfd_data (srctemplate
, abfd
))
261 /* Create section to own the symbols. */
262 flags
= (SEC_CODE
| SEC_HAS_CONTENTS
| SEC_READONLY
263 | SEC_ALLOC
| SEC_LOAD
| SEC_KEEP
| SEC_EXCLUDE
);
264 if (bfd_make_section_anyway_with_flags (abfd
, ".text", flags
))
268 einfo (_("could not create dummy IR bfd: %F%E\n"));
272 /* Check if the BFD passed in is an IR dummy object file. */
274 is_ir_dummy_bfd (const bfd
*abfd
)
276 /* ABFD can sometimes legitimately be NULL, e.g. when called from one
277 of the linker callbacks for a symbol in the *ABS* or *UND* sections.
278 Likewise, the usrdata field may be NULL if ABFD was added by the
279 backend without a corresponding input statement, as happens e.g.
280 when processing DT_NEEDED dependencies. */
283 && ((lang_input_statement_type
*)(abfd
->usrdata
))->flags
.claimed
);
286 /* Helpers to convert between BFD and GOLD symbol formats. */
287 static enum ld_plugin_status
288 asymbol_from_plugin_symbol (bfd
*abfd
, asymbol
*asym
,
289 const struct ld_plugin_symbol
*ldsym
)
291 flagword flags
= BSF_NO_FLAGS
;
292 struct bfd_section
*section
;
294 asym
->the_bfd
= abfd
;
295 asym
->name
= (ldsym
->version
296 ? concat (ldsym
->name
, "@", ldsym
->version
, (const char *) NULL
)
306 if (ldsym
->comdat_key
)
308 char *name
= concat (".gnu.linkonce.t.", ldsym
->comdat_key
,
309 (const char *) NULL
);
310 section
= bfd_get_section_by_name (abfd
, name
);
317 sflags
= (SEC_CODE
| SEC_HAS_CONTENTS
| SEC_READONLY
318 | SEC_ALLOC
| SEC_LOAD
| SEC_KEEP
| SEC_EXCLUDE
319 | SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
);
320 section
= bfd_make_section_anyway_with_flags (abfd
, name
, sflags
);
326 section
= bfd_get_section_by_name (abfd
, ".text");
333 section
= bfd_und_section_ptr
;
338 section
= bfd_com_section_ptr
;
339 asym
->value
= ldsym
->size
;
340 /* For ELF targets, set alignment of common symbol to 1. */
341 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
343 ((elf_symbol_type
*) asym
)->internal_elf_sym
.st_shndx
= SHN_COMMON
;
344 ((elf_symbol_type
*) asym
)->internal_elf_sym
.st_value
= 1;
352 asym
->section
= section
;
354 /* Visibility only applies on ELF targets. */
355 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
357 elf_symbol_type
*elfsym
= elf_symbol_from (abfd
, asym
);
358 unsigned char visibility
;
361 einfo (_("%P%F: %s: non-ELF symbol in ELF BFD!\n"), asym
->name
);
362 switch (ldsym
->visibility
)
365 einfo (_("%P%F: unknown ELF symbol visibility: %d!\n"),
368 visibility
= STV_DEFAULT
;
371 visibility
= STV_PROTECTED
;
374 visibility
= STV_INTERNAL
;
377 visibility
= STV_HIDDEN
;
380 elfsym
->internal_elf_sym
.st_other
381 = (visibility
| (elfsym
->internal_elf_sym
.st_other
382 & ~ELF_ST_VISIBILITY (-1)));
388 /* Register a claim-file handler. */
389 static enum ld_plugin_status
390 register_claim_file (ld_plugin_claim_file_handler handler
)
392 ASSERT (called_plugin
);
393 called_plugin
->claim_file_handler
= handler
;
397 /* Register an all-symbols-read handler. */
398 static enum ld_plugin_status
399 register_all_symbols_read (ld_plugin_all_symbols_read_handler handler
)
401 ASSERT (called_plugin
);
402 called_plugin
->all_symbols_read_handler
= handler
;
406 /* Register a cleanup handler. */
407 static enum ld_plugin_status
408 register_cleanup (ld_plugin_cleanup_handler handler
)
410 ASSERT (called_plugin
);
411 called_plugin
->cleanup_handler
= handler
;
415 /* Add symbols from a plugin-claimed input file. */
416 static enum ld_plugin_status
417 add_symbols (void *handle
, int nsyms
, const struct ld_plugin_symbol
*syms
)
423 ASSERT (called_plugin
);
424 symptrs
= xmalloc (nsyms
* sizeof *symptrs
);
425 for (n
= 0; n
< nsyms
; n
++)
427 enum ld_plugin_status rv
;
430 bfdsym
= bfd_make_empty_symbol (abfd
);
432 rv
= asymbol_from_plugin_symbol (abfd
, bfdsym
, syms
+ n
);
436 bfd_set_symtab (abfd
, symptrs
, nsyms
);
440 /* Get the input file information with an open (possibly re-opened)
442 static enum ld_plugin_status
443 get_input_file (const void *handle ATTRIBUTE_UNUSED
,
444 struct ld_plugin_input_file
*file ATTRIBUTE_UNUSED
)
446 ASSERT (called_plugin
);
450 /* Release the input file. */
451 static enum ld_plugin_status
452 release_input_file (const void *handle ATTRIBUTE_UNUSED
)
454 ASSERT (called_plugin
);
458 /* Return TRUE if a defined symbol might be reachable from outside the
459 universe of claimed objects. */
460 static inline bfd_boolean
461 is_visible_from_outside (struct ld_plugin_symbol
*lsym
,
462 struct bfd_link_hash_entry
*blhe
)
464 struct bfd_sym_chain
*sym
;
466 if (link_info
.relocatable
)
468 if (link_info
.export_dynamic
|| !link_info
.executable
)
470 /* Check if symbol is hidden by version script. */
471 if (bfd_hide_sym_by_version (link_info
.version_info
,
474 /* Only ELF symbols really have visibility. */
475 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
477 struct elf_link_hash_entry
*el
= (struct elf_link_hash_entry
*)blhe
;
478 int vis
= ELF_ST_VISIBILITY (el
->other
);
479 return vis
== STV_DEFAULT
|| vis
== STV_PROTECTED
;
481 /* On non-ELF targets, we can safely make inferences by considering
482 what visibility the plugin would have liked to apply when it first
483 sent us the symbol. During ELF symbol processing, visibility only
484 ever becomes more restrictive, not less, when symbols are merged,
485 so this is a conservative estimate; it may give false positives,
486 declaring something visible from outside when it in fact would
487 not have been, but this will only lead to missed optimisation
488 opportunities during LTRANS at worst; it will not give false
489 negatives, which can lead to the disastrous conclusion that the
490 related symbol is IRONLY. (See GCC PR46319 for an example.) */
491 return (lsym
->visibility
== LDPV_DEFAULT
492 || lsym
->visibility
== LDPV_PROTECTED
);
495 for (sym
= &entry_symbol
; sym
!= NULL
; sym
= sym
->next
)
497 && strcmp (sym
->name
, blhe
->root
.string
) == 0)
503 /* Get the symbol resolution info for a plugin-claimed input file. */
504 static enum ld_plugin_status
505 get_symbols (const void *handle
, int nsyms
, struct ld_plugin_symbol
*syms
,
508 const bfd
*abfd
= handle
;
511 ASSERT (called_plugin
);
512 for (n
= 0; n
< nsyms
; n
++)
514 struct bfd_link_hash_entry
*blhe
;
518 if (syms
[n
].def
!= LDPK_UNDEF
)
519 blhe
= bfd_link_hash_lookup (link_info
.hash
, syms
[n
].name
,
522 blhe
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
, &link_info
,
523 syms
[n
].name
, FALSE
, FALSE
, TRUE
);
530 /* Determine resolution from blhe type and symbol's original type. */
531 if (blhe
->type
== bfd_link_hash_undefined
532 || blhe
->type
== bfd_link_hash_undefweak
)
537 if (blhe
->type
!= bfd_link_hash_defined
538 && blhe
->type
!= bfd_link_hash_defweak
539 && blhe
->type
!= bfd_link_hash_common
)
541 /* We should not have a new, indirect or warning symbol here. */
542 einfo ("%P%F: %s: plugin symbol table corrupt (sym type %d)\n",
543 called_plugin
->name
, blhe
->type
);
546 /* Find out which section owns the symbol. Since it's not undef,
547 it must have an owner; if it's not a common symbol, both defs
548 and weakdefs keep it in the same place. */
549 owner_sec
= (blhe
->type
== bfd_link_hash_common
550 ? blhe
->u
.c
.p
->section
551 : blhe
->u
.def
.section
);
554 /* If it was originally undefined or common, then it has been
555 resolved; determine how. */
556 if (syms
[n
].def
== LDPK_UNDEF
557 || syms
[n
].def
== LDPK_WEAKUNDEF
558 || syms
[n
].def
== LDPK_COMMON
)
560 if (owner_sec
->owner
== link_info
.output_bfd
)
561 res
= LDPR_RESOLVED_EXEC
;
562 else if (owner_sec
->owner
== abfd
)
563 res
= LDPR_PREVAILING_DEF_IRONLY
;
564 else if (is_ir_dummy_bfd (owner_sec
->owner
))
565 res
= LDPR_RESOLVED_IR
;
566 else if (owner_sec
->owner
!= NULL
567 && (owner_sec
->owner
->flags
& DYNAMIC
) != 0)
568 res
= LDPR_RESOLVED_DYN
;
570 res
= LDPR_RESOLVED_EXEC
;
573 /* Was originally def, or weakdef. Does it prevail? If the
574 owner is the original dummy bfd that supplied it, then this
575 is the definition that has prevailed. */
576 else if (owner_sec
->owner
== link_info
.output_bfd
)
577 res
= LDPR_PREEMPTED_REG
;
578 else if (owner_sec
->owner
== abfd
)
579 res
= LDPR_PREVAILING_DEF_IRONLY
;
581 /* Was originally def, weakdef, or common, but has been pre-empted. */
582 else if (is_ir_dummy_bfd (owner_sec
->owner
))
583 res
= LDPR_PREEMPTED_IR
;
585 res
= LDPR_PREEMPTED_REG
;
587 if (res
== LDPR_PREVAILING_DEF_IRONLY
)
589 /* We need to know if the sym is referenced from non-IR files. Or
590 even potentially-referenced, perhaps in a future final link if
591 this is a partial one, perhaps dynamically at load-time if the
592 symbol is externally visible. */
593 if (blhe
->non_ir_ref
)
594 res
= LDPR_PREVAILING_DEF
;
595 else if (is_visible_from_outside (&syms
[n
], blhe
))
596 res
= def_ironly_exp
;
600 syms
[n
].resolution
= res
;
601 if (report_plugin_symbols
)
602 einfo (_("%P: %B: symbol `%s' "
603 "definition: %d, visibility: %d, resolution: %d\n"),
605 syms
[n
].def
, syms
[n
].visibility
, res
);
610 static enum ld_plugin_status
611 get_symbols_v1 (const void *handle
, int nsyms
, struct ld_plugin_symbol
*syms
)
613 return get_symbols (handle
, nsyms
, syms
, LDPR_PREVAILING_DEF
);
616 static enum ld_plugin_status
617 get_symbols_v2 (const void *handle
, int nsyms
, struct ld_plugin_symbol
*syms
)
619 return get_symbols (handle
, nsyms
, syms
, LDPR_PREVAILING_DEF_IRONLY_EXP
);
622 /* Add a new (real) input file generated by a plugin. */
623 static enum ld_plugin_status
624 add_input_file (const char *pathname
)
626 ASSERT (called_plugin
);
627 if (!lang_add_input_file (xstrdup (pathname
), lang_input_file_is_file_enum
,
633 /* Add a new (real) library required by a plugin. */
634 static enum ld_plugin_status
635 add_input_library (const char *pathname
)
637 ASSERT (called_plugin
);
638 if (!lang_add_input_file (xstrdup (pathname
), lang_input_file_is_l_enum
,
644 /* Set the extra library path to be used by libraries added via
645 add_input_library. */
646 static enum ld_plugin_status
647 set_extra_library_path (const char *path
)
649 ASSERT (called_plugin
);
650 ldfile_add_library_path (xstrdup (path
), FALSE
);
654 /* Issue a diagnostic message from a plugin. */
655 static enum ld_plugin_status
656 message (int level
, const char *format
, ...)
659 va_start (args
, format
);
664 vfinfo (stdout
, format
, args
, FALSE
);
668 vfinfo (stdout
, format
, args
, TRUE
);
675 char *newfmt
= ACONCAT ((level
== LDPL_FATAL
? "%P%F: " : "%P%X: ",
676 format
, "\n", (const char *) NULL
));
678 vfinfo (stderr
, newfmt
, args
, TRUE
);
688 /* Helper to size leading part of tv array and set it up. */
690 set_tv_header (struct ld_plugin_tv
*tv
)
695 static const unsigned int major
= (unsigned)(BFD_VERSION
/ 100000000UL);
696 static const unsigned int minor
= (unsigned)(BFD_VERSION
/ 1000000UL) % 100;
698 for (i
= 0; i
< tv_header_size
; i
++)
700 tv
[i
].tv_tag
= tv_header_tags
[i
];
701 #define TVU(x) tv[i].tv_u.tv_ ## x
702 switch (tv
[i
].tv_tag
)
705 TVU(message
) = message
;
707 case LDPT_API_VERSION
:
708 TVU(val
) = LD_PLUGIN_API_VERSION
;
710 case LDPT_GNU_LD_VERSION
:
711 TVU(val
) = major
* 100 + minor
;
713 case LDPT_LINKER_OUTPUT
:
714 TVU(val
) = (link_info
.relocatable
716 : (link_info
.executable
717 ? (link_info
.pie
? LDPO_PIE
: LDPO_EXEC
)
720 case LDPT_OUTPUT_NAME
:
721 TVU(string
) = output_filename
;
723 case LDPT_REGISTER_CLAIM_FILE_HOOK
:
724 TVU(register_claim_file
) = register_claim_file
;
726 case LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK
:
727 TVU(register_all_symbols_read
) = register_all_symbols_read
;
729 case LDPT_REGISTER_CLEANUP_HOOK
:
730 TVU(register_cleanup
) = register_cleanup
;
732 case LDPT_ADD_SYMBOLS
:
733 TVU(add_symbols
) = add_symbols
;
735 case LDPT_GET_INPUT_FILE
:
736 TVU(get_input_file
) = get_input_file
;
738 case LDPT_RELEASE_INPUT_FILE
:
739 TVU(release_input_file
) = release_input_file
;
741 case LDPT_GET_SYMBOLS
:
742 TVU(get_symbols
) = get_symbols_v1
;
744 case LDPT_GET_SYMBOLS_V2
:
745 TVU(get_symbols
) = get_symbols_v2
;
747 case LDPT_ADD_INPUT_FILE
:
748 TVU(add_input_file
) = add_input_file
;
750 case LDPT_ADD_INPUT_LIBRARY
:
751 TVU(add_input_library
) = add_input_library
;
753 case LDPT_SET_EXTRA_LIBRARY_PATH
:
754 TVU(set_extra_library_path
) = set_extra_library_path
;
757 /* Added a new entry to the array without adding
758 a new case to set up its value is a bug. */
765 /* Append the per-plugin args list and trailing LDPT_NULL to tv. */
767 set_tv_plugin_args (plugin_t
*plugin
, struct ld_plugin_tv
*tv
)
769 plugin_arg_t
*arg
= plugin
->args
;
772 tv
->tv_tag
= LDPT_OPTION
;
773 tv
->tv_u
.tv_string
= arg
->arg
;
777 tv
->tv_tag
= LDPT_NULL
;
781 /* Return true if any plugins are active this run. Only valid
782 after options have been processed. */
784 plugin_active_plugins_p (void)
786 return plugins_list
!= NULL
;
789 /* Load up and initialise all plugins after argument parsing. */
791 plugin_load_plugins (void)
793 struct ld_plugin_tv
*my_tv
;
794 unsigned int max_args
= 0;
795 plugin_t
*curplug
= plugins_list
;
797 /* If there are no plugins, we need do nothing this run. */
801 /* First pass over plugins to find max # args needed so that we
802 can size and allocate the tv array. */
805 if (curplug
->n_args
> max_args
)
806 max_args
= curplug
->n_args
;
807 curplug
= curplug
->next
;
810 /* Allocate tv array and initialise constant part. */
811 my_tv
= xmalloc ((max_args
+ 1 + tv_header_size
) * sizeof *my_tv
);
812 set_tv_header (my_tv
);
814 /* Pass over plugins again, activating them. */
815 curplug
= plugins_list
;
818 enum ld_plugin_status rv
;
819 ld_plugin_onload onloadfn
;
821 onloadfn
= (ld_plugin_onload
) dlsym (curplug
->dlhandle
, "onload");
823 onloadfn
= (ld_plugin_onload
) dlsym (curplug
->dlhandle
, "_onload");
825 einfo (_("%P%F: %s: error loading plugin: %s\n"),
826 curplug
->name
, dlerror ());
827 set_tv_plugin_args (curplug
, &my_tv
[tv_header_size
]);
828 called_plugin
= curplug
;
829 rv
= (*onloadfn
) (my_tv
);
830 called_plugin
= NULL
;
832 einfo (_("%P%F: %s: plugin error: %d\n"), curplug
->name
, rv
);
833 curplug
= curplug
->next
;
836 /* Since plugin(s) inited ok, assume they're going to want symbol
837 resolutions, which needs us to track which symbols are referenced
838 by non-IR files using the linker's notice callback. */
839 orig_notice_all
= link_info
.notice_all
;
840 orig_callbacks
= link_info
.callbacks
;
841 plugin_callbacks
= *orig_callbacks
;
842 plugin_callbacks
.notice
= &plugin_notice
;
843 link_info
.notice_all
= TRUE
;
844 link_info
.lto_plugin_active
= TRUE
;
845 link_info
.callbacks
= &plugin_callbacks
;
848 /* Call 'claim file' hook for all plugins. */
850 plugin_call_claim_file (const struct ld_plugin_input_file
*file
, int *claimed
)
852 plugin_t
*curplug
= plugins_list
;
854 if (no_more_claiming
)
856 while (curplug
&& !*claimed
)
858 if (curplug
->claim_file_handler
)
860 enum ld_plugin_status rv
;
861 called_plugin
= curplug
;
862 rv
= (*curplug
->claim_file_handler
) (file
, claimed
);
863 called_plugin
= NULL
;
865 set_plugin_error (curplug
->name
);
867 curplug
= curplug
->next
;
869 return plugin_error_p () ? -1 : 0;
873 plugin_maybe_claim (struct ld_plugin_input_file
*file
,
874 lang_input_statement_type
*entry
)
878 /* We create a dummy BFD, initially empty, to house whatever symbols
879 the plugin may want to add. */
880 file
->handle
= plugin_get_ir_dummy_bfd (entry
->the_bfd
->filename
,
882 if (plugin_call_claim_file (file
, &claimed
))
883 einfo (_("%P%F: %s: plugin reported error claiming file\n"),
884 plugin_error_plugin ());
885 /* fd belongs to us, not the plugin; but we don't need it. */
889 /* Discard the real file's BFD and substitute the dummy one. */
891 /* BFD archive handling caches elements so we can't call
892 bfd_close for archives. */
893 if (entry
->the_bfd
->my_archive
== NULL
)
894 bfd_close (entry
->the_bfd
);
895 entry
->the_bfd
= file
->handle
;
896 entry
->flags
.claimed
= TRUE
;
897 bfd_make_readable (entry
->the_bfd
);
901 /* If plugin didn't claim the file, we don't need the dummy bfd.
902 Can't avoid speculatively creating it, alas. */
903 bfd_close_all_done (file
->handle
);
904 entry
->flags
.claimed
= FALSE
;
908 /* Call 'all symbols read' hook for all plugins. */
910 plugin_call_all_symbols_read (void)
912 plugin_t
*curplug
= plugins_list
;
914 /* Disable any further file-claiming. */
915 no_more_claiming
= TRUE
;
919 if (curplug
->all_symbols_read_handler
)
921 enum ld_plugin_status rv
;
922 called_plugin
= curplug
;
923 rv
= (*curplug
->all_symbols_read_handler
) ();
924 called_plugin
= NULL
;
926 set_plugin_error (curplug
->name
);
928 curplug
= curplug
->next
;
930 return plugin_error_p () ? -1 : 0;
933 /* Call 'cleanup' hook for all plugins at exit. */
935 plugin_call_cleanup (void)
937 plugin_t
*curplug
= plugins_list
;
940 if (curplug
->cleanup_handler
&& !curplug
->cleanup_done
)
942 enum ld_plugin_status rv
;
943 curplug
->cleanup_done
= TRUE
;
944 called_plugin
= curplug
;
945 rv
= (*curplug
->cleanup_handler
) ();
946 called_plugin
= NULL
;
948 info_msg (_("%P: %s: error in plugin cleanup: %d (ignored)\n"),
950 dlclose (curplug
->dlhandle
);
952 curplug
= curplug
->next
;
956 /* To determine which symbols should be resolved LDPR_PREVAILING_DEF
957 and which LDPR_PREVAILING_DEF_IRONLY, we notice all the symbols as
958 the linker adds them to the linker hash table. Mark those
959 referenced from a non-IR file with non_ir_ref. We have to
960 notice_all symbols, because we won't necessarily know until later
961 which ones will be contributed by IR files. */
963 plugin_notice (struct bfd_link_info
*info
,
964 struct bfd_link_hash_entry
*h
,
975 /* Nothing to do here if this def/ref is from an IR dummy BFD. */
976 if (is_ir_dummy_bfd (abfd
))
979 /* Making an indirect symbol counts as a reference unless this
980 is a brand new symbol. */
981 else if (bfd_is_ind_section (section
)
982 || (flags
& BSF_INDIRECT
) != 0)
984 if (h
->type
!= bfd_link_hash_new
)
986 struct bfd_link_hash_entry
*inh
;
988 h
->non_ir_ref
= TRUE
;
989 inh
= bfd_wrapped_link_hash_lookup (abfd
, info
, string
, FALSE
,
992 inh
->non_ir_ref
= TRUE
;
996 /* Nothing to do here for warning symbols. */
997 else if ((flags
& BSF_WARNING
) != 0)
1000 /* Nothing to do here for constructor symbols. */
1001 else if ((flags
& BSF_CONSTRUCTOR
) != 0)
1004 /* If this is a ref, set non_ir_ref. */
1005 else if (bfd_is_und_section (section
))
1007 /* Replace the undefined dummy bfd with the real one. */
1008 if ((h
->type
== bfd_link_hash_undefined
1009 || h
->type
== bfd_link_hash_undefweak
)
1010 && (h
->u
.undef
.abfd
== NULL
1011 || (h
->u
.undef
.abfd
->flags
& BFD_PLUGIN
) != 0))
1012 h
->u
.undef
.abfd
= abfd
;
1013 h
->non_ir_ref
= TRUE
;
1016 /* Otherwise, it must be a new def. Ensure any symbol defined
1017 in an IR dummy BFD takes on a new value from a real BFD.
1018 Weak symbols are not normally overridden by a new weak
1019 definition, and strong symbols will normally cause multiple
1020 definition errors. Avoid this by making the symbol appear
1022 else if (((h
->type
== bfd_link_hash_defweak
1023 || h
->type
== bfd_link_hash_defined
)
1024 && is_ir_dummy_bfd (sym_bfd
= h
->u
.def
.section
->owner
))
1025 || (h
->type
== bfd_link_hash_common
1026 && is_ir_dummy_bfd (sym_bfd
= h
->u
.c
.p
->section
->owner
)))
1028 h
->type
= bfd_link_hash_undefweak
;
1029 h
->u
.undef
.abfd
= sym_bfd
;
1033 /* Continue with cref/nocrossref/trace-sym processing. */
1036 || (info
->notice_hash
!= NULL
1037 && bfd_hash_lookup (info
->notice_hash
, h
->root
.string
,
1038 FALSE
, FALSE
) != NULL
))
1039 return (*orig_callbacks
->notice
) (info
, h
,
1040 abfd
, section
, value
, flags
, string
);
1044 /* Return true if ABFD, a dynamic library, should be reloaded. */
1047 plugin_should_reload (bfd
*abfd
)
1049 return (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1050 && (elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0);