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
,
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) */
158 /* Helper function for exiting with error status. */
160 set_plugin_error (const char *plugin
)
162 error_plugin
= plugin
;
166 /* Test if an error occurred. */
168 plugin_error_p (void)
170 return error_plugin
!= NULL
;
173 /* Return name of plugin which caused an error if any. */
175 plugin_error_plugin (void)
177 return error_plugin
? error_plugin
: _("<no plugin>");
180 /* Handle -plugin arg: find and load plugin, or return error. */
182 plugin_opt_plugin (const char *plugin
)
186 newplug
= xmalloc (sizeof *newplug
);
187 memset (newplug
, 0, sizeof *newplug
);
188 newplug
->name
= plugin
;
189 newplug
->dlhandle
= dlopen (plugin
, RTLD_NOW
);
190 if (!newplug
->dlhandle
)
191 return set_plugin_error (plugin
);
193 /* Chain on end, so when we run list it is in command-line order. */
194 *plugins_tail_chain_ptr
= newplug
;
195 plugins_tail_chain_ptr
= &newplug
->next
;
197 /* Record it as current plugin for receiving args. */
198 last_plugin
= newplug
;
199 last_plugin_args_tail_chain_ptr
= &newplug
->args
;
203 /* Accumulate option arguments for last-loaded plugin, or return
206 plugin_opt_plugin_arg (const char *arg
)
208 plugin_arg_t
*newarg
;
211 return set_plugin_error (_("<no plugin>"));
213 newarg
= xmalloc (sizeof *newarg
);
217 /* Chain on end to preserve command-line order. */
218 *last_plugin_args_tail_chain_ptr
= newarg
;
219 last_plugin_args_tail_chain_ptr
= &newarg
->next
;
220 last_plugin
->n_args
++;
224 /* Create a dummy BFD. */
226 plugin_get_ir_dummy_bfd (const char *name
, bfd
*srctemplate
)
230 bfd_use_reserved_id
= 1;
231 abfd
= bfd_create (concat (name
, IRONLY_SUFFIX
, (const char *) NULL
),
235 abfd
->flags
|= BFD_LINKER_CREATED
| BFD_PLUGIN
;
236 bfd_set_arch_info (abfd
, bfd_get_arch_info (srctemplate
));
237 bfd_set_gp_size (abfd
, bfd_get_gp_size (srctemplate
));
238 if (bfd_make_writable (abfd
)
239 && bfd_copy_private_bfd_data (srctemplate
, abfd
))
243 /* Create section to own the symbols. */
244 flags
= (SEC_CODE
| SEC_HAS_CONTENTS
| SEC_READONLY
245 | SEC_ALLOC
| SEC_LOAD
| SEC_KEEP
| SEC_EXCLUDE
);
246 if (bfd_make_section_anyway_with_flags (abfd
, ".text", flags
))
250 einfo (_("could not create dummy IR bfd: %F%E\n"));
254 /* Check if the BFD passed in is an IR dummy object file. */
256 is_ir_dummy_bfd (const bfd
*abfd
)
258 /* ABFD can sometimes legitimately be NULL, e.g. when called from one
259 of the linker callbacks for a symbol in the *ABS* or *UND* sections.
260 Likewise, the usrdata field may be NULL if ABFD was added by the
261 backend without a corresponding input statement, as happens e.g.
262 when processing DT_NEEDED dependencies. */
265 && ((lang_input_statement_type
*)(abfd
->usrdata
))->claimed
);
268 /* Helpers to convert between BFD and GOLD symbol formats. */
269 static enum ld_plugin_status
270 asymbol_from_plugin_symbol (bfd
*abfd
, asymbol
*asym
,
271 const struct ld_plugin_symbol
*ldsym
)
273 flagword flags
= BSF_NO_FLAGS
;
274 struct bfd_section
*section
;
276 asym
->the_bfd
= abfd
;
277 asym
->name
= (ldsym
->version
278 ? concat (ldsym
->name
, "@", ldsym
->version
, (const char *) NULL
)
288 if (ldsym
->comdat_key
)
290 char *name
= concat (".gnu.linkonce.t.", ldsym
->comdat_key
,
291 (const char *) NULL
);
292 section
= bfd_get_section_by_name (abfd
, name
);
299 sflags
= (SEC_CODE
| SEC_HAS_CONTENTS
| SEC_READONLY
300 | SEC_ALLOC
| SEC_LOAD
| SEC_KEEP
| SEC_EXCLUDE
301 | SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
);
302 section
= bfd_make_section_anyway_with_flags (abfd
, name
, sflags
);
308 section
= bfd_get_section_by_name (abfd
, ".text");
315 section
= bfd_und_section_ptr
;
320 section
= bfd_com_section_ptr
;
321 asym
->value
= ldsym
->size
;
322 /* For ELF targets, set alignment of common symbol to 1. */
323 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
325 ((elf_symbol_type
*) asym
)->internal_elf_sym
.st_shndx
= SHN_COMMON
;
326 ((elf_symbol_type
*) asym
)->internal_elf_sym
.st_value
= 1;
334 asym
->section
= section
;
336 /* Visibility only applies on ELF targets. */
337 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
339 elf_symbol_type
*elfsym
= elf_symbol_from (abfd
, asym
);
340 unsigned char visibility
;
343 einfo (_("%P%F: %s: non-ELF symbol in ELF BFD!\n"), asym
->name
);
344 switch (ldsym
->visibility
)
347 einfo (_("%P%F: unknown ELF symbol visibility: %d!\n"),
350 visibility
= STV_DEFAULT
;
353 visibility
= STV_PROTECTED
;
356 visibility
= STV_INTERNAL
;
359 visibility
= STV_HIDDEN
;
362 elfsym
->internal_elf_sym
.st_other
363 = (visibility
| (elfsym
->internal_elf_sym
.st_other
364 & ~ELF_ST_VISIBILITY (-1)));
370 /* Register a claim-file handler. */
371 static enum ld_plugin_status
372 register_claim_file (ld_plugin_claim_file_handler handler
)
374 ASSERT (called_plugin
);
375 called_plugin
->claim_file_handler
= handler
;
379 /* Register an all-symbols-read handler. */
380 static enum ld_plugin_status
381 register_all_symbols_read (ld_plugin_all_symbols_read_handler handler
)
383 ASSERT (called_plugin
);
384 called_plugin
->all_symbols_read_handler
= handler
;
388 /* Register a cleanup handler. */
389 static enum ld_plugin_status
390 register_cleanup (ld_plugin_cleanup_handler handler
)
392 ASSERT (called_plugin
);
393 called_plugin
->cleanup_handler
= handler
;
397 /* Add symbols from a plugin-claimed input file. */
398 static enum ld_plugin_status
399 add_symbols (void *handle
, int nsyms
, const struct ld_plugin_symbol
*syms
)
405 ASSERT (called_plugin
);
406 symptrs
= xmalloc (nsyms
* sizeof *symptrs
);
407 for (n
= 0; n
< nsyms
; n
++)
409 enum ld_plugin_status rv
;
412 bfdsym
= bfd_make_empty_symbol (abfd
);
414 rv
= asymbol_from_plugin_symbol (abfd
, bfdsym
, syms
+ n
);
418 bfd_set_symtab (abfd
, symptrs
, nsyms
);
422 /* Get the input file information with an open (possibly re-opened)
424 static enum ld_plugin_status
425 get_input_file (const void *handle
, struct ld_plugin_input_file
*file
)
427 ASSERT (called_plugin
);
433 /* Release the input file. */
434 static enum ld_plugin_status
435 release_input_file (const void *handle
)
437 ASSERT (called_plugin
);
442 /* Return TRUE if a defined symbol might be reachable from outside the
443 universe of claimed objects. */
444 static inline bfd_boolean
445 is_visible_from_outside (struct ld_plugin_symbol
*lsym
, asection
*section
,
446 struct bfd_link_hash_entry
*blhe
)
448 struct bfd_sym_chain
*sym
;
450 /* Section's owner may be NULL if it is the absolute
451 section, fortunately is_ir_dummy_bfd handles that. */
452 if (!is_ir_dummy_bfd (section
->owner
))
454 if (link_info
.relocatable
)
456 if (link_info
.export_dynamic
|| link_info
.shared
)
458 /* Check if symbol is hidden by version script. */
459 if (bfd_hide_sym_by_version (link_info
.version_info
,
462 /* Only ELF symbols really have visibility. */
463 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
465 struct elf_link_hash_entry
*el
= (struct elf_link_hash_entry
*)blhe
;
466 int vis
= ELF_ST_VISIBILITY (el
->other
);
467 return vis
== STV_DEFAULT
|| vis
== STV_PROTECTED
;
469 /* On non-ELF targets, we can safely make inferences by considering
470 what visibility the plugin would have liked to apply when it first
471 sent us the symbol. During ELF symbol processing, visibility only
472 ever becomes more restrictive, not less, when symbols are merged,
473 so this is a conservative estimate; it may give false positives,
474 declaring something visible from outside when it in fact would
475 not have been, but this will only lead to missed optimisation
476 opportunities during LTRANS at worst; it will not give false
477 negatives, which can lead to the disastrous conclusion that the
478 related symbol is IRONLY. (See GCC PR46319 for an example.) */
479 return (lsym
->visibility
== LDPV_DEFAULT
480 || lsym
->visibility
== LDPV_PROTECTED
);
483 for (sym
= &entry_symbol
; sym
!= NULL
; sym
= sym
->next
)
485 && strcmp (sym
->name
, blhe
->root
.string
) == 0)
491 /* Get the symbol resolution info for a plugin-claimed input file. */
492 static enum ld_plugin_status
493 get_symbols (const void *handle
, int nsyms
, struct ld_plugin_symbol
*syms
,
496 const bfd
*abfd
= handle
;
499 ASSERT (called_plugin
);
500 for (n
= 0; n
< nsyms
; n
++)
502 struct bfd_link_hash_entry
*blhe
;
506 if (syms
[n
].def
!= LDPK_UNDEF
)
507 blhe
= bfd_link_hash_lookup (link_info
.hash
, syms
[n
].name
,
510 blhe
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
, &link_info
,
511 syms
[n
].name
, FALSE
, FALSE
, TRUE
);
518 /* Determine resolution from blhe type and symbol's original type. */
519 if (blhe
->type
== bfd_link_hash_undefined
520 || blhe
->type
== bfd_link_hash_undefweak
)
525 if (blhe
->type
!= bfd_link_hash_defined
526 && blhe
->type
!= bfd_link_hash_defweak
527 && blhe
->type
!= bfd_link_hash_common
)
529 /* We should not have a new, indirect or warning symbol here. */
530 einfo ("%P%F: %s: plugin symbol table corrupt (sym type %d)\n",
531 called_plugin
->name
, blhe
->type
);
534 /* Find out which section owns the symbol. Since it's not undef,
535 it must have an owner; if it's not a common symbol, both defs
536 and weakdefs keep it in the same place. */
537 owner_sec
= (blhe
->type
== bfd_link_hash_common
538 ? blhe
->u
.c
.p
->section
539 : blhe
->u
.def
.section
);
542 /* If it was originally undefined or common, then it has been
543 resolved; determine how. */
544 if (syms
[n
].def
== LDPK_UNDEF
545 || syms
[n
].def
== LDPK_WEAKUNDEF
546 || syms
[n
].def
== LDPK_COMMON
)
548 if (owner_sec
->owner
== link_info
.output_bfd
)
549 res
= LDPR_RESOLVED_EXEC
;
550 else if (owner_sec
->owner
== abfd
)
551 res
= LDPR_PREVAILING_DEF_IRONLY
;
552 else if (is_ir_dummy_bfd (owner_sec
->owner
))
553 res
= LDPR_RESOLVED_IR
;
554 else if (owner_sec
->owner
!= NULL
555 && (owner_sec
->owner
->flags
& DYNAMIC
) != 0)
556 res
= LDPR_RESOLVED_DYN
;
558 res
= LDPR_RESOLVED_EXEC
;
561 /* Was originally def, or weakdef. Does it prevail? If the
562 owner is the original dummy bfd that supplied it, then this
563 is the definition that has prevailed. */
564 else if (owner_sec
->owner
== link_info
.output_bfd
)
565 res
= LDPR_PREEMPTED_REG
;
566 else if (owner_sec
->owner
== abfd
)
567 res
= LDPR_PREVAILING_DEF_IRONLY
;
569 /* Was originally def, weakdef, or common, but has been pre-empted. */
570 else if (is_ir_dummy_bfd (owner_sec
->owner
))
571 res
= LDPR_PREEMPTED_IR
;
573 res
= LDPR_PREEMPTED_REG
;
575 if (res
== LDPR_PREVAILING_DEF_IRONLY
)
577 /* We need to know if the sym is referenced from non-IR files. Or
578 even potentially-referenced, perhaps in a future final link if
579 this is a partial one, perhaps dynamically at load-time if the
580 symbol is externally visible. */
581 if (blhe
->non_ir_ref
)
582 res
= LDPR_PREVAILING_DEF
;
583 else if (is_visible_from_outside (&syms
[n
], owner_sec
, blhe
))
584 res
= def_ironly_exp
;
588 syms
[n
].resolution
= res
;
589 if (report_plugin_symbols
)
590 einfo (_("%P: %B: symbol `%s' "
591 "definition: %d, visibility: %d, resolution: %d\n"),
593 syms
[n
].def
, syms
[n
].visibility
, res
);
598 static enum ld_plugin_status
599 get_symbols_v1 (const void *handle
, int nsyms
, struct ld_plugin_symbol
*syms
)
601 return get_symbols (handle
, nsyms
, syms
, LDPR_PREVAILING_DEF
);
604 static enum ld_plugin_status
605 get_symbols_v2 (const void *handle
, int nsyms
, struct ld_plugin_symbol
*syms
)
607 return get_symbols (handle
, nsyms
, syms
, LDPR_PREVAILING_DEF_IRONLY_EXP
);
610 /* Add a new (real) input file generated by a plugin. */
611 static enum ld_plugin_status
612 add_input_file (const char *pathname
)
614 ASSERT (called_plugin
);
615 if (!lang_add_input_file (xstrdup (pathname
), lang_input_file_is_file_enum
,
621 /* Add a new (real) library required by a plugin. */
622 static enum ld_plugin_status
623 add_input_library (const char *pathname
)
625 ASSERT (called_plugin
);
626 if (!lang_add_input_file (xstrdup (pathname
), lang_input_file_is_l_enum
,
632 /* Set the extra library path to be used by libraries added via
633 add_input_library. */
634 static enum ld_plugin_status
635 set_extra_library_path (const char *path
)
637 ASSERT (called_plugin
);
638 ldfile_add_library_path (xstrdup (path
), FALSE
);
642 /* Issue a diagnostic message from a plugin. */
643 static enum ld_plugin_status
644 message (int level
, const char *format
, ...)
647 va_start (args
, format
);
652 vfinfo (stdout
, format
, args
, FALSE
);
656 vfinfo (stdout
, format
, args
, TRUE
);
663 char *newfmt
= ACONCAT ((level
== LDPL_FATAL
? "%P%F: " : "%P%X: ",
664 format
, "\n", (const char *) NULL
));
666 vfinfo (stderr
, newfmt
, args
, TRUE
);
676 /* Helper to size leading part of tv array and set it up. */
678 set_tv_header (struct ld_plugin_tv
*tv
)
683 static const unsigned int major
= (unsigned)(BFD_VERSION
/ 100000000UL);
684 static const unsigned int minor
= (unsigned)(BFD_VERSION
/ 1000000UL) % 100;
686 for (i
= 0; i
< tv_header_size
; i
++)
688 tv
[i
].tv_tag
= tv_header_tags
[i
];
689 #define TVU(x) tv[i].tv_u.tv_ ## x
690 switch (tv
[i
].tv_tag
)
693 TVU(message
) = message
;
695 case LDPT_API_VERSION
:
696 TVU(val
) = LD_PLUGIN_API_VERSION
;
698 case LDPT_GNU_LD_VERSION
:
699 TVU(val
) = major
* 100 + minor
;
701 case LDPT_LINKER_OUTPUT
:
702 TVU(val
) = (link_info
.relocatable
704 : (link_info
.shared
? LDPO_DYN
: LDPO_EXEC
));
706 case LDPT_OUTPUT_NAME
:
707 TVU(string
) = output_filename
;
709 case LDPT_REGISTER_CLAIM_FILE_HOOK
:
710 TVU(register_claim_file
) = register_claim_file
;
712 case LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK
:
713 TVU(register_all_symbols_read
) = register_all_symbols_read
;
715 case LDPT_REGISTER_CLEANUP_HOOK
:
716 TVU(register_cleanup
) = register_cleanup
;
718 case LDPT_ADD_SYMBOLS
:
719 TVU(add_symbols
) = add_symbols
;
721 case LDPT_GET_INPUT_FILE
:
722 TVU(get_input_file
) = get_input_file
;
724 case LDPT_RELEASE_INPUT_FILE
:
725 TVU(release_input_file
) = release_input_file
;
727 case LDPT_GET_SYMBOLS
:
728 TVU(get_symbols
) = get_symbols_v1
;
730 case LDPT_GET_SYMBOLS_V2
:
731 TVU(get_symbols
) = get_symbols_v2
;
733 case LDPT_ADD_INPUT_FILE
:
734 TVU(add_input_file
) = add_input_file
;
736 case LDPT_ADD_INPUT_LIBRARY
:
737 TVU(add_input_library
) = add_input_library
;
739 case LDPT_SET_EXTRA_LIBRARY_PATH
:
740 TVU(set_extra_library_path
) = set_extra_library_path
;
743 /* Added a new entry to the array without adding
744 a new case to set up its value is a bug. */
751 /* Append the per-plugin args list and trailing LDPT_NULL to tv. */
753 set_tv_plugin_args (plugin_t
*plugin
, struct ld_plugin_tv
*tv
)
755 plugin_arg_t
*arg
= plugin
->args
;
758 tv
->tv_tag
= LDPT_OPTION
;
759 tv
->tv_u
.tv_string
= arg
->arg
;
763 tv
->tv_tag
= LDPT_NULL
;
767 /* Return true if any plugins are active this run. Only valid
768 after options have been processed. */
770 plugin_active_plugins_p (void)
772 return plugins_list
!= NULL
;
775 /* Load up and initialise all plugins after argument parsing. */
777 plugin_load_plugins (void)
779 struct ld_plugin_tv
*my_tv
;
780 unsigned int max_args
= 0;
781 plugin_t
*curplug
= plugins_list
;
783 /* If there are no plugins, we need do nothing this run. */
787 /* First pass over plugins to find max # args needed so that we
788 can size and allocate the tv array. */
791 if (curplug
->n_args
> max_args
)
792 max_args
= curplug
->n_args
;
793 curplug
= curplug
->next
;
796 /* Allocate tv array and initialise constant part. */
797 my_tv
= xmalloc ((max_args
+ 1 + tv_header_size
) * sizeof *my_tv
);
798 set_tv_header (my_tv
);
800 /* Pass over plugins again, activating them. */
801 curplug
= plugins_list
;
804 enum ld_plugin_status rv
;
805 ld_plugin_onload onloadfn
= dlsym (curplug
->dlhandle
, "onload");
807 onloadfn
= dlsym (curplug
->dlhandle
, "_onload");
809 return set_plugin_error (curplug
->name
);
810 set_tv_plugin_args (curplug
, &my_tv
[tv_header_size
]);
811 called_plugin
= curplug
;
812 rv
= (*onloadfn
) (my_tv
);
813 called_plugin
= NULL
;
815 return set_plugin_error (curplug
->name
);
816 curplug
= curplug
->next
;
819 /* Since plugin(s) inited ok, assume they're going to want symbol
820 resolutions, which needs us to track which symbols are referenced
821 by non-IR files using the linker's notice callback. */
822 orig_notice_all
= link_info
.notice_all
;
823 orig_callbacks
= link_info
.callbacks
;
824 plugin_callbacks
= *orig_callbacks
;
825 plugin_callbacks
.notice
= &plugin_notice
;
826 link_info
.notice_all
= TRUE
;
827 link_info
.callbacks
= &plugin_callbacks
;
832 /* Call 'claim file' hook for all plugins. */
834 plugin_call_claim_file (const struct ld_plugin_input_file
*file
, int *claimed
)
836 plugin_t
*curplug
= plugins_list
;
838 if (no_more_claiming
)
840 while (curplug
&& !*claimed
)
842 if (curplug
->claim_file_handler
)
844 enum ld_plugin_status rv
;
845 called_plugin
= curplug
;
846 rv
= (*curplug
->claim_file_handler
) (file
, claimed
);
847 called_plugin
= NULL
;
849 set_plugin_error (curplug
->name
);
851 curplug
= curplug
->next
;
853 return plugin_error_p () ? -1 : 0;
857 plugin_maybe_claim (struct ld_plugin_input_file
*file
,
858 lang_input_statement_type
*entry
)
862 /* We create a dummy BFD, initially empty, to house whatever symbols
863 the plugin may want to add. */
864 file
->handle
= plugin_get_ir_dummy_bfd (entry
->the_bfd
->filename
,
866 if (plugin_call_claim_file (file
, &claimed
))
867 einfo (_("%P%F: %s: plugin reported error claiming file\n"),
868 plugin_error_plugin ());
869 /* fd belongs to us, not the plugin; but we don't need it. */
873 /* Discard the real file's BFD and substitute the dummy one. */
875 /* BFD archive handling caches elements so we can't call
876 bfd_close for archives. */
877 if (entry
->the_bfd
->my_archive
== NULL
)
878 bfd_close (entry
->the_bfd
);
879 entry
->the_bfd
= file
->handle
;
880 entry
->claimed
= TRUE
;
881 bfd_make_readable (entry
->the_bfd
);
885 /* If plugin didn't claim the file, we don't need the dummy bfd.
886 Can't avoid speculatively creating it, alas. */
887 bfd_close_all_done (file
->handle
);
888 entry
->claimed
= FALSE
;
892 /* Call 'all symbols read' hook for all plugins. */
894 plugin_call_all_symbols_read (void)
896 plugin_t
*curplug
= plugins_list
;
898 /* Disable any further file-claiming. */
899 no_more_claiming
= TRUE
;
903 if (curplug
->all_symbols_read_handler
)
905 enum ld_plugin_status rv
;
906 called_plugin
= curplug
;
907 rv
= (*curplug
->all_symbols_read_handler
) ();
908 called_plugin
= NULL
;
910 set_plugin_error (curplug
->name
);
912 curplug
= curplug
->next
;
914 return plugin_error_p () ? -1 : 0;
917 /* Call 'cleanup' hook for all plugins at exit. */
919 plugin_call_cleanup (void)
921 plugin_t
*curplug
= plugins_list
;
924 if (curplug
->cleanup_handler
&& !curplug
->cleanup_done
)
926 enum ld_plugin_status rv
;
927 curplug
->cleanup_done
= TRUE
;
928 called_plugin
= curplug
;
929 rv
= (*curplug
->cleanup_handler
) ();
930 called_plugin
= NULL
;
932 set_plugin_error (curplug
->name
);
933 dlclose (curplug
->dlhandle
);
935 curplug
= curplug
->next
;
937 if (plugin_error_p ())
938 info_msg (_("%P: %s: error in plugin cleanup (ignored)\n"),
939 plugin_error_plugin ());
942 /* To determine which symbols should be resolved LDPR_PREVAILING_DEF
943 and which LDPR_PREVAILING_DEF_IRONLY, we notice all the symbols as
944 the linker adds them to the linker hash table. Mark those
945 referenced from a non-IR file with non_ir_ref. We have to
946 notice_all symbols, because we won't necessarily know until later
947 which ones will be contributed by IR files. */
949 plugin_notice (struct bfd_link_info
*info
,
950 struct bfd_link_hash_entry
*h
,
961 /* No further processing if this def/ref is from an IR dummy BFD. */
962 if (is_ir_dummy_bfd (abfd
))
965 /* Making an indirect symbol counts as a reference unless this
966 is a brand new symbol. */
967 if (bfd_is_ind_section (section
)
968 || (flags
& BSF_INDIRECT
) != 0)
970 if (h
->type
!= bfd_link_hash_new
)
972 struct bfd_link_hash_entry
*inh
;
974 h
->non_ir_ref
= TRUE
;
975 inh
= bfd_wrapped_link_hash_lookup (abfd
, info
, string
, FALSE
,
978 inh
->non_ir_ref
= TRUE
;
982 /* Nothing to do here for warning symbols. */
983 else if ((flags
& BSF_WARNING
) != 0)
986 /* Nothing to do here for constructor symbols. */
987 else if ((flags
& BSF_CONSTRUCTOR
) != 0)
990 /* If this is a ref, set non_ir_ref. */
991 else if (bfd_is_und_section (section
))
992 h
->non_ir_ref
= TRUE
;
994 /* Otherwise, it must be a new def. Ensure any symbol defined
995 in an IR dummy BFD takes on a new value from a real BFD.
996 Weak symbols are not normally overridden by a new weak
997 definition, and strong symbols will normally cause multiple
998 definition errors. Avoid this by making the symbol appear
1000 else if (((h
->type
== bfd_link_hash_defweak
1001 || h
->type
== bfd_link_hash_defined
)
1002 && is_ir_dummy_bfd (sym_bfd
= h
->u
.def
.section
->owner
))
1003 || (h
->type
== bfd_link_hash_common
1004 && is_ir_dummy_bfd (sym_bfd
= h
->u
.c
.p
->section
->owner
)))
1006 h
->type
= bfd_link_hash_undefweak
;
1007 h
->u
.undef
.abfd
= sym_bfd
;
1011 /* Continue with cref/nocrossref/trace-sym processing. */
1014 || (info
->notice_hash
!= NULL
1015 && bfd_hash_lookup (info
->notice_hash
, h
->root
.string
,
1016 FALSE
, FALSE
) != NULL
))
1017 return (*orig_callbacks
->notice
) (info
, h
,
1018 abfd
, section
, value
, flags
, string
);