1 /* Plugin control for the GNU linker.
2 Copyright (C) 2010-2021 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"
24 #if BFD_SUPPORTS_PLUGINS
34 #include "plugin-api.h"
35 #include "../bfd/plugin.h"
39 # include <sys/mman.h>
41 # define MAP_FAILED ((void *) -1)
47 # define MAP_PRIVATE 0
51 #if !(defined(errno) || defined(_MSC_VER) && defined(_INC_ERRNO))
54 #if !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H)
58 /* Report plugin symbols. */
59 bool report_plugin_symbols
;
61 /* The suffix to append to the name of the real (claimed) object file
62 when generating a dummy BFD to hold the IR symbols sent from the
63 plugin. For cosmetic use only; appears in maps, crefs etc. */
64 #define IRONLY_SUFFIX " (symbol from plugin)"
66 /* Stores a single argument passed to a plugin. */
67 typedef struct plugin_arg
69 struct plugin_arg
*next
;
73 /* Holds all details of a single plugin. */
76 /* Next on the list of plugins, or NULL at end of chain. */
78 /* The argument string given to --plugin. */
80 /* The shared library handle returned by dlopen. */
82 /* The list of argument string given to --plugin-opt. */
84 /* Number of args in the list, for convenience. */
86 /* The plugin's event handlers. */
87 ld_plugin_claim_file_handler claim_file_handler
;
88 ld_plugin_all_symbols_read_handler all_symbols_read_handler
;
89 ld_plugin_cleanup_handler cleanup_handler
;
90 /* TRUE if the cleanup handlers have been called. */
94 typedef struct view_buffer
101 /* The internal version of struct ld_plugin_input_file with a BFD
103 typedef struct plugin_input_file
107 /* The original input BFD. Non-NULL if it is an archive member. */
109 view_buffer_t view_buffer
;
115 } plugin_input_file_t
;
117 /* The master list of all plugins. */
118 static plugin_t
*plugins_list
= NULL
;
120 /* We keep a tail pointer for easy linking on the end. */
121 static plugin_t
**plugins_tail_chain_ptr
= &plugins_list
;
123 /* The last plugin added to the list, for receiving args. */
124 static plugin_t
*last_plugin
= NULL
;
126 /* The tail of the arg chain of the last plugin added to the list. */
127 static plugin_arg_t
**last_plugin_args_tail_chain_ptr
= NULL
;
129 /* The plugin which is currently having a callback executed. */
130 static plugin_t
*called_plugin
= NULL
;
132 /* Last plugin to cause an error, if any. */
133 static const char *error_plugin
= NULL
;
135 /* State of linker "notice" interface before we poked at it. */
136 static bool orig_notice_all
;
138 /* Original linker callbacks, and the plugin version. */
139 static const struct bfd_link_callbacks
*orig_callbacks
;
140 static struct bfd_link_callbacks plugin_callbacks
;
142 /* Set at all symbols read time, to avoid recursively offering the plugin
143 its own newly-added input files and libs to claim. */
144 bool no_more_claiming
= false;
146 #if HAVE_MMAP && HAVE_GETPAGESIZE
147 /* Page size used by mmap. */
148 static off_t plugin_pagesize
;
151 /* List of tags to set in the constant leading part of the tv array. */
152 static const enum ld_plugin_tag tv_header_tags
[] =
159 LDPT_REGISTER_CLAIM_FILE_HOOK
,
160 LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK
,
161 LDPT_REGISTER_CLEANUP_HOOK
,
165 LDPT_RELEASE_INPUT_FILE
,
169 LDPT_ADD_INPUT_LIBRARY
,
170 LDPT_SET_EXTRA_LIBRARY_PATH
173 /* How many entries in the constant leading part of the tv array. */
174 static const size_t tv_header_size
= ARRAY_SIZE (tv_header_tags
);
176 /* Forward references. */
177 static bool plugin_notice (struct bfd_link_info
*,
178 struct bfd_link_hash_entry
*,
179 struct bfd_link_hash_entry
*,
180 bfd
*, asection
*, bfd_vma
, flagword
);
182 static bfd_cleanup
plugin_object_p (bfd
*);
184 #if !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H)
186 #define RTLD_NOW 0 /* Dummy value. */
189 dlopen (const char *file
, int mode ATTRIBUTE_UNUSED
)
191 return LoadLibrary (file
);
195 dlsym (void *handle
, const char *name
)
197 return GetProcAddress (handle
, name
);
201 dlclose (void *handle
)
203 FreeLibrary (handle
);
207 #endif /* !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H) */
217 /* Helper function for exiting with error status. */
219 set_plugin_error (const char *plugin
)
221 error_plugin
= plugin
;
225 /* Test if an error occurred. */
227 plugin_error_p (void)
229 return error_plugin
!= NULL
;
232 /* Return name of plugin which caused an error if any. */
234 plugin_error_plugin (void)
236 return error_plugin
? error_plugin
: _("<no plugin>");
239 /* Handle -plugin arg: find and load plugin, or return error. */
241 plugin_opt_plugin (const char *plugin
)
244 plugin_t
*curplug
= plugins_list
;
246 newplug
= xmalloc (sizeof *newplug
);
247 memset (newplug
, 0, sizeof *newplug
);
248 newplug
->name
= plugin
;
249 newplug
->dlhandle
= dlopen (plugin
, RTLD_NOW
);
250 if (!newplug
->dlhandle
)
251 einfo (_("%F%P: %s: error loading plugin: %s\n"), plugin
, dlerror ());
253 /* Check if plugin has been loaded already. */
256 if (newplug
->dlhandle
== curplug
->dlhandle
)
258 einfo (_("%P: %s: duplicated plugin\n"), plugin
);
262 curplug
= curplug
->next
;
265 /* Chain on end, so when we run list it is in command-line order. */
266 *plugins_tail_chain_ptr
= newplug
;
267 plugins_tail_chain_ptr
= &newplug
->next
;
269 /* Record it as current plugin for receiving args. */
270 last_plugin
= newplug
;
271 last_plugin_args_tail_chain_ptr
= &newplug
->args
;
274 /* Accumulate option arguments for last-loaded plugin, or return
277 plugin_opt_plugin_arg (const char *arg
)
279 plugin_arg_t
*newarg
;
282 return set_plugin_error (_("<no plugin>"));
284 /* Ignore -pass-through= from GCC driver. */
287 const char *p
= arg
+ 1;
291 if (strncmp (p
, "pass-through=", 13) == 0)
295 newarg
= xmalloc (sizeof *newarg
);
299 /* Chain on end to preserve command-line order. */
300 *last_plugin_args_tail_chain_ptr
= newarg
;
301 last_plugin_args_tail_chain_ptr
= &newarg
->next
;
302 last_plugin
->n_args
++;
306 /* Generate a dummy BFD to represent an IR file, for any callers of
307 plugin_call_claim_file to use as the handle in the ld_plugin_input_file
308 struct that they build to pass in. The BFD is initially writable, so
309 that symbols can be added to it; it must be made readable after the
310 add_symbols hook has been called so that it can be read when linking. */
312 plugin_get_ir_dummy_bfd (const char *name
, bfd
*srctemplate
)
315 bool bfd_plugin_target
;
317 bfd_use_reserved_id
= 1;
318 bfd_plugin_target
= bfd_plugin_target_p (srctemplate
->xvec
);
319 abfd
= bfd_create (concat (name
, IRONLY_SUFFIX
, (const char *) NULL
),
320 bfd_plugin_target
? link_info
.output_bfd
: srctemplate
);
323 abfd
->flags
|= BFD_LINKER_CREATED
| BFD_PLUGIN
;
324 if (!bfd_make_writable (abfd
))
326 if (!bfd_plugin_target
)
328 bfd_set_arch_info (abfd
, bfd_get_arch_info (srctemplate
));
329 bfd_set_gp_size (abfd
, bfd_get_gp_size (srctemplate
));
330 if (!bfd_copy_private_bfd_data (srctemplate
, abfd
))
336 /* Create section to own the symbols. */
337 flags
= (SEC_CODE
| SEC_HAS_CONTENTS
| SEC_READONLY
338 | SEC_ALLOC
| SEC_LOAD
| SEC_KEEP
| SEC_EXCLUDE
);
339 if (bfd_make_section_anyway_with_flags (abfd
, ".text", flags
))
344 einfo (_("%F%P: could not create dummy IR bfd: %E\n"));
348 /* Check if the BFD passed in is an IR dummy object file. */
350 is_ir_dummy_bfd (const bfd
*abfd
)
352 /* ABFD can sometimes legitimately be NULL, e.g. when called from one
353 of the linker callbacks for a symbol in the *ABS* or *UND* sections. */
354 return abfd
!= NULL
&& (abfd
->flags
& BFD_PLUGIN
) != 0;
357 /* Helpers to convert between BFD and GOLD symbol formats. */
358 static enum ld_plugin_status
359 asymbol_from_plugin_symbol (bfd
*abfd
, asymbol
*asym
,
360 const struct ld_plugin_symbol
*ldsym
)
362 flagword flags
= BSF_NO_FLAGS
;
363 struct bfd_section
*section
;
365 asym
->the_bfd
= abfd
;
366 asym
->name
= (ldsym
->version
367 ? concat (ldsym
->name
, "@", ldsym
->version
, (const char *) NULL
)
377 if (ldsym
->comdat_key
)
379 char *name
= concat (".gnu.linkonce.t.", ldsym
->comdat_key
,
380 (const char *) NULL
);
381 section
= bfd_get_section_by_name (abfd
, name
);
388 sflags
= (SEC_CODE
| SEC_HAS_CONTENTS
| SEC_READONLY
389 | SEC_ALLOC
| SEC_LOAD
| SEC_KEEP
| SEC_EXCLUDE
390 | SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
);
391 section
= bfd_make_section_anyway_with_flags (abfd
, name
, sflags
);
397 section
= bfd_get_section_by_name (abfd
, ".text");
404 section
= bfd_und_section_ptr
;
409 section
= bfd_com_section_ptr
;
410 asym
->value
= ldsym
->size
;
417 asym
->section
= section
;
419 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
421 elf_symbol_type
*elfsym
= elf_symbol_from (asym
);
422 unsigned char visibility
;
425 einfo (_("%F%P: %s: non-ELF symbol in ELF BFD!\n"), asym
->name
);
427 if (ldsym
->def
== LDPK_COMMON
)
429 elfsym
->internal_elf_sym
.st_shndx
= SHN_COMMON
;
430 elfsym
->internal_elf_sym
.st_value
= 1;
433 switch (ldsym
->visibility
)
436 einfo (_("%F%P: unknown ELF symbol visibility: %d!\n"),
441 visibility
= STV_DEFAULT
;
444 visibility
= STV_PROTECTED
;
447 visibility
= STV_INTERNAL
;
450 visibility
= STV_HIDDEN
;
453 elfsym
->internal_elf_sym
.st_other
|= visibility
;
459 /* Register a claim-file handler. */
460 static enum ld_plugin_status
461 register_claim_file (ld_plugin_claim_file_handler handler
)
463 ASSERT (called_plugin
);
464 called_plugin
->claim_file_handler
= handler
;
468 /* Register an all-symbols-read handler. */
469 static enum ld_plugin_status
470 register_all_symbols_read (ld_plugin_all_symbols_read_handler handler
)
472 ASSERT (called_plugin
);
473 called_plugin
->all_symbols_read_handler
= handler
;
477 /* Register a cleanup handler. */
478 static enum ld_plugin_status
479 register_cleanup (ld_plugin_cleanup_handler handler
)
481 ASSERT (called_plugin
);
482 called_plugin
->cleanup_handler
= handler
;
486 /* Add symbols from a plugin-claimed input file. */
487 static enum ld_plugin_status
488 add_symbols (void *handle
, int nsyms
, const struct ld_plugin_symbol
*syms
)
491 plugin_input_file_t
*input
= handle
;
492 bfd
*abfd
= input
->abfd
;
495 ASSERT (called_plugin
);
496 symptrs
= xmalloc (nsyms
* sizeof *symptrs
);
497 for (n
= 0; n
< nsyms
; n
++)
499 enum ld_plugin_status rv
;
502 bfdsym
= bfd_make_empty_symbol (abfd
);
504 rv
= asymbol_from_plugin_symbol (abfd
, bfdsym
, syms
+ n
);
508 bfd_set_symtab (abfd
, symptrs
, nsyms
);
512 /* Get the input file information with an open (possibly re-opened)
514 static enum ld_plugin_status
515 get_input_file (const void *handle
, struct ld_plugin_input_file
*file
)
517 const plugin_input_file_t
*input
= handle
;
519 ASSERT (called_plugin
);
521 file
->name
= input
->name
;
522 file
->offset
= input
->offset
;
523 file
->filesize
= input
->filesize
;
524 file
->handle
= (void *) handle
;
529 /* Get view of the input file. */
530 static enum ld_plugin_status
531 get_view (const void *handle
, const void **viewp
)
533 plugin_input_file_t
*input
= (plugin_input_file_t
*) handle
;
535 size_t size
= input
->filesize
;
536 off_t offset
= input
->offset
;
537 #if HAVE_MMAP && HAVE_GETPAGESIZE
541 ASSERT (called_plugin
);
543 /* FIXME: einfo should support %lld. */
544 if ((off_t
) size
!= input
->filesize
)
545 einfo (_("%F%P: unsupported input file size: %s (%ld bytes)\n"),
546 input
->name
, (long) input
->filesize
);
548 /* Check the cached view buffer. */
549 if (input
->view_buffer
.addr
!= NULL
550 && input
->view_buffer
.filesize
== size
551 && input
->view_buffer
.offset
== offset
)
553 *viewp
= input
->view_buffer
.addr
;
557 input
->view_buffer
.filesize
= size
;
558 input
->view_buffer
.offset
= offset
;
561 # if HAVE_GETPAGESIZE
562 bias
= offset
% plugin_pagesize
;
566 buffer
= mmap (NULL
, size
, PROT_READ
, MAP_PRIVATE
, input
->fd
, offset
);
567 if (buffer
!= MAP_FAILED
)
569 input
->use_mmap
= true;
570 # if HAVE_GETPAGESIZE
579 input
->use_mmap
= false;
581 if (lseek (input
->fd
, offset
, SEEK_SET
) < 0)
584 buffer
= bfd_alloc (input
->abfd
, size
);
591 ssize_t got
= read (input
->fd
, p
, size
);
599 else if (errno
!= EINTR
)
605 input
->view_buffer
.addr
= buffer
;
611 /* Release plugin file descriptor. */
614 release_plugin_file_descriptor (plugin_input_file_t
*input
)
618 bfd_plugin_close_file_descriptor (input
->ibfd
, input
->fd
);
623 /* Release the input file. */
624 static enum ld_plugin_status
625 release_input_file (const void *handle
)
627 plugin_input_file_t
*input
= (plugin_input_file_t
*) handle
;
628 ASSERT (called_plugin
);
629 release_plugin_file_descriptor (input
);
633 /* Return TRUE if a defined symbol might be reachable from outside the
634 universe of claimed objects. */
636 is_visible_from_outside (struct ld_plugin_symbol
*lsym
,
637 struct bfd_link_hash_entry
*blhe
)
639 if (bfd_link_relocatable (&link_info
))
641 if (blhe
->non_ir_ref_dynamic
642 || link_info
.export_dynamic
643 || bfd_link_dll (&link_info
))
645 /* Check if symbol is hidden by version script. */
646 if (bfd_hide_sym_by_version (link_info
.version_info
,
649 /* Only ELF symbols really have visibility. */
650 if (is_elf_hash_table (link_info
.hash
))
652 struct elf_link_hash_entry
*el
= (struct elf_link_hash_entry
*)blhe
;
653 int vis
= ELF_ST_VISIBILITY (el
->other
);
654 return vis
== STV_DEFAULT
|| vis
== STV_PROTECTED
;
656 /* On non-ELF targets, we can safely make inferences by considering
657 what visibility the plugin would have liked to apply when it first
658 sent us the symbol. During ELF symbol processing, visibility only
659 ever becomes more restrictive, not less, when symbols are merged,
660 so this is a conservative estimate; it may give false positives,
661 declaring something visible from outside when it in fact would
662 not have been, but this will only lead to missed optimisation
663 opportunities during LTRANS at worst; it will not give false
664 negatives, which can lead to the disastrous conclusion that the
665 related symbol is IRONLY. (See GCC PR46319 for an example.) */
666 return (lsym
->visibility
== LDPV_DEFAULT
667 || lsym
->visibility
== LDPV_PROTECTED
);
673 /* Return LTO kind string name that corresponds to IDX enum value. */
675 get_lto_kind (unsigned int idx
)
677 static char buffer
[64];
678 const char *lto_kind_str
[5] =
687 if (idx
< ARRAY_SIZE (lto_kind_str
))
688 return lto_kind_str
[idx
];
690 sprintf (buffer
, _("unknown LTO kind value %x"), idx
);
694 /* Return LTO resolution string name that corresponds to IDX enum value. */
696 get_lto_resolution (unsigned int idx
)
698 static char buffer
[64];
699 static const char *lto_resolution_str
[10] =
704 "PREVAILING_DEF_IRONLY",
710 "PREVAILING_DEF_IRONLY_EXP",
713 if (idx
< ARRAY_SIZE (lto_resolution_str
))
714 return lto_resolution_str
[idx
];
716 sprintf (buffer
, _("unknown LTO resolution value %x"), idx
);
720 /* Return LTO visibility string name that corresponds to IDX enum value. */
722 get_lto_visibility (unsigned int idx
)
724 static char buffer
[64];
725 const char *lto_visibility_str
[4] =
733 if (idx
< ARRAY_SIZE (lto_visibility_str
))
734 return lto_visibility_str
[idx
];
736 sprintf (buffer
, _("unknown LTO visibility value %x"), idx
);
740 /* Get the symbol resolution info for a plugin-claimed input file. */
741 static enum ld_plugin_status
742 get_symbols (const void *handle
, int nsyms
, struct ld_plugin_symbol
*syms
,
745 const plugin_input_file_t
*input
= handle
;
746 const bfd
*abfd
= (const bfd
*) input
->abfd
;
749 ASSERT (called_plugin
);
750 for (n
= 0; n
< nsyms
; n
++)
752 struct bfd_link_hash_entry
*blhe
;
755 struct bfd_link_hash_entry
*h
756 = bfd_link_hash_lookup (link_info
.hash
, syms
[n
].name
,
758 enum { wrap_none
, wrapper
, wrapped
} wrap_status
= wrap_none
;
760 if (syms
[n
].def
!= LDPK_UNDEF
&& syms
[n
].def
!= LDPK_WEAKUNDEF
)
763 if (blhe
&& link_info
.wrap_hash
!= NULL
)
765 /* Check if a symbol is a wrapper symbol. */
766 struct bfd_link_hash_entry
*unwrap
767 = unwrap_hash_lookup (&link_info
, (bfd
*) abfd
, blhe
);
768 if (unwrap
&& unwrap
!= h
)
769 wrap_status
= wrapper
;
774 blhe
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
775 &link_info
, syms
[n
].name
,
777 /* Check if a symbol is a wrapped symbol. */
778 if (blhe
&& blhe
!= h
)
779 wrap_status
= wrapped
;
783 /* The plugin is called to claim symbols in an archive element
784 from plugin_object_p. But those symbols aren't needed to
785 create output. They are defined and referenced only within
798 res
= LDPR_PREVAILING_DEF_IRONLY
;
804 /* Determine resolution from blhe type and symbol's original type. */
805 if (blhe
->type
== bfd_link_hash_undefined
806 || blhe
->type
== bfd_link_hash_undefweak
)
811 if (blhe
->type
!= bfd_link_hash_defined
812 && blhe
->type
!= bfd_link_hash_defweak
813 && blhe
->type
!= bfd_link_hash_common
)
815 /* We should not have a new, indirect or warning symbol here. */
816 einfo (_("%F%P: %s: plugin symbol table corrupt (sym type %d)\n"),
817 called_plugin
->name
, blhe
->type
);
820 /* Find out which section owns the symbol. Since it's not undef,
821 it must have an owner; if it's not a common symbol, both defs
822 and weakdefs keep it in the same place. */
823 owner_sec
= (blhe
->type
== bfd_link_hash_common
824 ? blhe
->u
.c
.p
->section
825 : blhe
->u
.def
.section
);
828 /* If it was originally undefined or common, then it has been
829 resolved; determine how. */
830 if (syms
[n
].def
== LDPK_UNDEF
831 || syms
[n
].def
== LDPK_WEAKUNDEF
832 || syms
[n
].def
== LDPK_COMMON
)
834 if (owner_sec
->owner
== link_info
.output_bfd
)
835 res
= LDPR_RESOLVED_EXEC
;
836 else if (owner_sec
->owner
== abfd
)
837 res
= LDPR_PREVAILING_DEF_IRONLY
;
838 else if (is_ir_dummy_bfd (owner_sec
->owner
))
839 res
= LDPR_RESOLVED_IR
;
840 else if (owner_sec
->owner
!= NULL
841 && (owner_sec
->owner
->flags
& DYNAMIC
) != 0)
842 res
= LDPR_RESOLVED_DYN
;
844 res
= LDPR_RESOLVED_EXEC
;
847 /* Was originally def, or weakdef. Does it prevail? If the
848 owner is the original dummy bfd that supplied it, then this
849 is the definition that has prevailed. */
850 else if (owner_sec
->owner
== link_info
.output_bfd
)
851 res
= LDPR_PREEMPTED_REG
;
852 else if (owner_sec
->owner
== abfd
)
853 res
= LDPR_PREVAILING_DEF_IRONLY
;
855 /* Was originally def, weakdef, or common, but has been pre-empted. */
856 else if (is_ir_dummy_bfd (owner_sec
->owner
))
857 res
= LDPR_PREEMPTED_IR
;
859 res
= LDPR_PREEMPTED_REG
;
861 if (res
== LDPR_PREVAILING_DEF_IRONLY
)
863 /* We need to know if the sym is referenced from non-IR files. Or
864 even potentially-referenced, perhaps in a future final link if
865 this is a partial one, perhaps dynamically at load-time if the
866 symbol is externally visible. Also check for wrapper symbol. */
867 if (blhe
->non_ir_ref_regular
|| wrap_status
== wrapper
)
868 res
= LDPR_PREVAILING_DEF
;
869 else if (wrap_status
== wrapped
)
870 res
= LDPR_RESOLVED_IR
;
871 else if (is_visible_from_outside (&syms
[n
], blhe
))
872 res
= def_ironly_exp
;
876 syms
[n
].resolution
= res
;
877 if (report_plugin_symbols
)
878 einfo (_("%P: %pB: symbol `%s' "
879 "definition: %s, visibility: %s, resolution: %s\n"),
881 get_lto_kind (syms
[n
].def
),
882 get_lto_visibility (syms
[n
].visibility
),
883 get_lto_resolution (res
));
888 static enum ld_plugin_status
889 get_symbols_v1 (const void *handle
, int nsyms
, struct ld_plugin_symbol
*syms
)
891 return get_symbols (handle
, nsyms
, syms
, LDPR_PREVAILING_DEF
);
894 static enum ld_plugin_status
895 get_symbols_v2 (const void *handle
, int nsyms
, struct ld_plugin_symbol
*syms
)
897 return get_symbols (handle
, nsyms
, syms
, LDPR_PREVAILING_DEF_IRONLY_EXP
);
900 /* Add a new (real) input file generated by a plugin. */
901 static enum ld_plugin_status
902 add_input_file (const char *pathname
)
904 lang_input_statement_type
*is
;
906 ASSERT (called_plugin
);
907 is
= lang_add_input_file (xstrdup (pathname
), lang_input_file_is_file_enum
,
911 is
->flags
.lto_output
= 1;
915 /* Add a new (real) library required by a plugin. */
916 static enum ld_plugin_status
917 add_input_library (const char *pathname
)
919 lang_input_statement_type
*is
;
921 ASSERT (called_plugin
);
922 is
= lang_add_input_file (xstrdup (pathname
), lang_input_file_is_l_enum
,
926 is
->flags
.lto_output
= 1;
930 /* Set the extra library path to be used by libraries added via
931 add_input_library. */
932 static enum ld_plugin_status
933 set_extra_library_path (const char *path
)
935 ASSERT (called_plugin
);
936 ldfile_add_library_path (xstrdup (path
), false);
940 /* Issue a diagnostic message from a plugin. */
941 static enum ld_plugin_status
942 message (int level
, const char *format
, ...)
945 va_start (args
, format
);
950 vfinfo (stdout
, format
, args
, false);
955 char *newfmt
= concat (_("%P: warning: "), format
, "\n",
956 (const char *) NULL
);
957 vfinfo (stdout
, newfmt
, args
, true);
965 char *newfmt
= concat (level
== LDPL_FATAL
? "%F" : "%X",
966 _("%P: error: "), format
, "\n",
967 (const char *) NULL
);
969 vfinfo (stderr
, newfmt
, args
, true);
980 /* Helper to size leading part of tv array and set it up. */
982 set_tv_header (struct ld_plugin_tv
*tv
)
987 static const unsigned int major
= (unsigned)(BFD_VERSION
/ 100000000UL);
988 static const unsigned int minor
= (unsigned)(BFD_VERSION
/ 1000000UL) % 100;
990 for (i
= 0; i
< tv_header_size
; i
++)
992 tv
[i
].tv_tag
= tv_header_tags
[i
];
993 #define TVU(x) tv[i].tv_u.tv_ ## x
994 switch (tv
[i
].tv_tag
)
997 TVU(message
) = message
;
999 case LDPT_API_VERSION
:
1000 TVU(val
) = LD_PLUGIN_API_VERSION
;
1002 case LDPT_GNU_LD_VERSION
:
1003 TVU(val
) = major
* 100 + minor
;
1005 case LDPT_LINKER_OUTPUT
:
1006 TVU(val
) = (bfd_link_relocatable (&link_info
) ? LDPO_REL
1007 : bfd_link_pde (&link_info
) ? LDPO_EXEC
1008 : bfd_link_pie (&link_info
) ? LDPO_PIE
1011 case LDPT_OUTPUT_NAME
:
1012 TVU(string
) = output_filename
;
1014 case LDPT_REGISTER_CLAIM_FILE_HOOK
:
1015 TVU(register_claim_file
) = register_claim_file
;
1017 case LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK
:
1018 TVU(register_all_symbols_read
) = register_all_symbols_read
;
1020 case LDPT_REGISTER_CLEANUP_HOOK
:
1021 TVU(register_cleanup
) = register_cleanup
;
1023 case LDPT_ADD_SYMBOLS
:
1024 TVU(add_symbols
) = add_symbols
;
1026 case LDPT_GET_INPUT_FILE
:
1027 TVU(get_input_file
) = get_input_file
;
1030 TVU(get_view
) = get_view
;
1032 case LDPT_RELEASE_INPUT_FILE
:
1033 TVU(release_input_file
) = release_input_file
;
1035 case LDPT_GET_SYMBOLS
:
1036 TVU(get_symbols
) = get_symbols_v1
;
1038 case LDPT_GET_SYMBOLS_V2
:
1039 TVU(get_symbols
) = get_symbols_v2
;
1041 case LDPT_ADD_INPUT_FILE
:
1042 TVU(add_input_file
) = add_input_file
;
1044 case LDPT_ADD_INPUT_LIBRARY
:
1045 TVU(add_input_library
) = add_input_library
;
1047 case LDPT_SET_EXTRA_LIBRARY_PATH
:
1048 TVU(set_extra_library_path
) = set_extra_library_path
;
1051 /* Added a new entry to the array without adding
1052 a new case to set up its value is a bug. */
1059 /* Append the per-plugin args list and trailing LDPT_NULL to tv. */
1061 set_tv_plugin_args (plugin_t
*plugin
, struct ld_plugin_tv
*tv
)
1063 plugin_arg_t
*arg
= plugin
->args
;
1066 tv
->tv_tag
= LDPT_OPTION
;
1067 tv
->tv_u
.tv_string
= arg
->arg
;
1071 tv
->tv_tag
= LDPT_NULL
;
1072 tv
->tv_u
.tv_val
= 0;
1075 /* Load up and initialise all plugins after argument parsing. */
1077 plugin_load_plugins (void)
1079 struct ld_plugin_tv
*my_tv
;
1080 unsigned int max_args
= 0;
1081 plugin_t
*curplug
= plugins_list
;
1083 /* If there are no plugins, we need do nothing this run. */
1087 /* First pass over plugins to find max # args needed so that we
1088 can size and allocate the tv array. */
1091 if (curplug
->n_args
> max_args
)
1092 max_args
= curplug
->n_args
;
1093 curplug
= curplug
->next
;
1096 /* Allocate tv array and initialise constant part. */
1097 my_tv
= xmalloc ((max_args
+ 1 + tv_header_size
) * sizeof *my_tv
);
1098 set_tv_header (my_tv
);
1100 /* Pass over plugins again, activating them. */
1101 curplug
= plugins_list
;
1104 enum ld_plugin_status rv
;
1105 ld_plugin_onload onloadfn
;
1107 onloadfn
= (ld_plugin_onload
) dlsym (curplug
->dlhandle
, "onload");
1109 onloadfn
= (ld_plugin_onload
) dlsym (curplug
->dlhandle
, "_onload");
1111 einfo (_("%F%P: %s: error loading plugin: %s\n"),
1112 curplug
->name
, dlerror ());
1113 set_tv_plugin_args (curplug
, &my_tv
[tv_header_size
]);
1114 called_plugin
= curplug
;
1115 rv
= (*onloadfn
) (my_tv
);
1116 called_plugin
= NULL
;
1118 einfo (_("%F%P: %s: plugin error: %d\n"), curplug
->name
, rv
);
1119 curplug
= curplug
->next
;
1122 /* Since plugin(s) inited ok, assume they're going to want symbol
1123 resolutions, which needs us to track which symbols are referenced
1124 by non-IR files using the linker's notice callback. */
1125 orig_notice_all
= link_info
.notice_all
;
1126 orig_callbacks
= link_info
.callbacks
;
1127 plugin_callbacks
= *orig_callbacks
;
1128 plugin_callbacks
.notice
= &plugin_notice
;
1129 link_info
.notice_all
= true;
1130 link_info
.lto_plugin_active
= true;
1131 link_info
.callbacks
= &plugin_callbacks
;
1133 register_ld_plugin_object_p (plugin_object_p
);
1135 #if HAVE_MMAP && HAVE_GETPAGESIZE
1136 plugin_pagesize
= getpagesize ();
1140 /* Call 'claim file' hook for all plugins. */
1142 plugin_call_claim_file (const struct ld_plugin_input_file
*file
, int *claimed
)
1144 plugin_t
*curplug
= plugins_list
;
1146 while (curplug
&& !*claimed
)
1148 if (curplug
->claim_file_handler
)
1150 enum ld_plugin_status rv
;
1152 called_plugin
= curplug
;
1153 rv
= (*curplug
->claim_file_handler
) (file
, claimed
);
1154 called_plugin
= NULL
;
1156 set_plugin_error (curplug
->name
);
1158 curplug
= curplug
->next
;
1160 return plugin_error_p () ? -1 : 0;
1163 /* Duplicates a character string with memory attached to ABFD. */
1166 plugin_strdup (bfd
*abfd
, const char *str
)
1170 strlength
= strlen (str
) + 1;
1171 copy
= bfd_alloc (abfd
, strlength
);
1173 einfo (_("%F%P: plugin_strdup failed to allocate memory: %s\n"),
1175 memcpy (copy
, str
, strlength
);
1180 plugin_cleanup (bfd
*abfd ATTRIBUTE_UNUSED
)
1185 plugin_object_p (bfd
*ibfd
)
1188 plugin_input_file_t
*input
;
1189 struct ld_plugin_input_file file
;
1192 /* Don't try the dummy object file. */
1193 if ((ibfd
->flags
& BFD_PLUGIN
) != 0)
1196 if (ibfd
->plugin_format
!= bfd_plugin_unknown
)
1198 if (ibfd
->plugin_format
== bfd_plugin_yes
)
1199 return plugin_cleanup
;
1204 /* We create a dummy BFD, initially empty, to house whatever symbols
1205 the plugin may want to add. */
1206 abfd
= plugin_get_ir_dummy_bfd (bfd_get_filename (ibfd
), ibfd
);
1208 input
= bfd_alloc (abfd
, sizeof (*input
));
1210 einfo (_("%F%P: plugin failed to allocate memory for input: %s\n"),
1213 if (!bfd_plugin_open_input (ibfd
, &file
))
1216 if (file
.name
== bfd_get_filename (ibfd
))
1218 /* We must copy filename attached to ibfd if it is not an archive
1219 member since it may be freed by bfd_close below. */
1220 file
.name
= plugin_strdup (abfd
, file
.name
);
1223 file
.handle
= input
;
1225 input
->ibfd
= ibfd
->my_archive
!= NULL
? ibfd
: NULL
;
1226 input
->view_buffer
.addr
= NULL
;
1227 input
->view_buffer
.filesize
= 0;
1228 input
->view_buffer
.offset
= 0;
1229 input
->fd
= file
.fd
;
1230 input
->use_mmap
= false;
1231 input
->offset
= file
.offset
;
1232 input
->filesize
= file
.filesize
;
1233 input
->name
= plugin_strdup (abfd
, bfd_get_filename (ibfd
));
1237 if (plugin_call_claim_file (&file
, &claimed
))
1238 einfo (_("%F%P: %s: plugin reported error claiming file\n"),
1239 plugin_error_plugin ());
1242 && (!claimed
|| !bfd_plugin_target_p (ibfd
->xvec
)))
1244 /* FIXME: fd belongs to us, not the plugin. GCC plugin, which
1245 doesn't need fd after plugin_call_claim_file, doesn't use
1246 BFD plugin target vector. Since GCC plugin doesn't call
1247 release_input_file, we close it here. LLVM plugin, which
1248 needs fd after plugin_call_claim_file and calls
1249 release_input_file after it is done, uses BFD plugin target
1250 vector. This scheme doesn't work when a plugin needs fd and
1251 doesn't use BFD plugin target vector neither. */
1252 release_plugin_file_descriptor (input
);
1257 ibfd
->plugin_format
= bfd_plugin_yes
;
1258 ibfd
->plugin_dummy_bfd
= abfd
;
1259 bfd_make_readable (abfd
);
1260 abfd
->no_export
= ibfd
->no_export
;
1261 return plugin_cleanup
;
1266 if (input
->use_mmap
)
1268 /* If plugin didn't claim the file, unmap the buffer. */
1269 char *addr
= input
->view_buffer
.addr
;
1270 off_t size
= input
->view_buffer
.filesize
;
1271 # if HAVE_GETPAGESIZE
1272 off_t bias
= input
->view_buffer
.offset
% plugin_pagesize
;
1276 munmap (addr
, size
);
1280 /* If plugin didn't claim the file, we don't need the dummy bfd.
1281 Can't avoid speculatively creating it, alas. */
1282 ibfd
->plugin_format
= bfd_plugin_no
;
1283 bfd_close_all_done (abfd
);
1289 plugin_maybe_claim (lang_input_statement_type
*entry
)
1291 ASSERT (entry
->header
.type
== lang_input_statement_enum
);
1292 if (plugin_object_p (entry
->the_bfd
))
1294 bfd
*abfd
= entry
->the_bfd
->plugin_dummy_bfd
;
1296 /* Discard the real file's BFD and substitute the dummy one. */
1298 /* We can't call bfd_close on archives. BFD archive handling
1299 caches elements, and add_archive_element keeps pointers to
1300 the_bfd and the_bfd->filename in a lang_input_statement_type
1301 linker script statement. */
1302 if (entry
->the_bfd
->my_archive
== NULL
)
1303 bfd_close (entry
->the_bfd
);
1304 entry
->the_bfd
= abfd
;
1305 entry
->flags
.claimed
= 1;
1309 /* Call 'all symbols read' hook for all plugins. */
1311 plugin_call_all_symbols_read (void)
1313 plugin_t
*curplug
= plugins_list
;
1315 /* Disable any further file-claiming. */
1316 no_more_claiming
= true;
1320 if (curplug
->all_symbols_read_handler
)
1322 enum ld_plugin_status rv
;
1323 called_plugin
= curplug
;
1324 rv
= (*curplug
->all_symbols_read_handler
) ();
1325 called_plugin
= NULL
;
1327 set_plugin_error (curplug
->name
);
1329 curplug
= curplug
->next
;
1331 return plugin_error_p () ? -1 : 0;
1334 /* Call 'cleanup' hook for all plugins at exit. */
1336 plugin_call_cleanup (void)
1338 plugin_t
*curplug
= plugins_list
;
1341 if (curplug
->cleanup_handler
&& !curplug
->cleanup_done
)
1343 enum ld_plugin_status rv
;
1344 curplug
->cleanup_done
= true;
1345 called_plugin
= curplug
;
1346 rv
= (*curplug
->cleanup_handler
) ();
1347 called_plugin
= NULL
;
1349 info_msg (_("%P: %s: error in plugin cleanup: %d (ignored)\n"),
1351 dlclose (curplug
->dlhandle
);
1353 curplug
= curplug
->next
;
1357 /* To determine which symbols should be resolved LDPR_PREVAILING_DEF
1358 and which LDPR_PREVAILING_DEF_IRONLY, we notice all the symbols as
1359 the linker adds them to the linker hash table. Mark those
1360 referenced from a non-IR file with non_ir_ref_regular or
1361 non_ir_ref_dynamic as appropriate. We have to notice_all symbols,
1362 because we won't necessarily know until later which ones will be
1363 contributed by IR files. */
1365 plugin_notice (struct bfd_link_info
*info
,
1366 struct bfd_link_hash_entry
*h
,
1367 struct bfd_link_hash_entry
*inh
,
1373 struct bfd_link_hash_entry
*orig_h
= h
;
1380 if (h
->type
== bfd_link_hash_warning
)
1383 /* Nothing to do here if this def/ref is from an IR dummy BFD. */
1384 if (is_ir_dummy_bfd (abfd
))
1387 /* Making an indirect symbol counts as a reference unless this
1388 is a brand new symbol. */
1389 else if (bfd_is_ind_section (section
)
1390 || (flags
& BSF_INDIRECT
) != 0)
1392 /* ??? Some of this is questionable. See comments in
1393 _bfd_generic_link_add_one_symbol for case IND. */
1394 if (h
->type
!= bfd_link_hash_new
1395 || inh
->type
== bfd_link_hash_new
)
1397 if ((abfd
->flags
& DYNAMIC
) == 0)
1398 inh
->non_ir_ref_regular
= true;
1400 inh
->non_ir_ref_dynamic
= true;
1403 if (h
->type
!= bfd_link_hash_new
)
1407 /* Nothing to do here for warning symbols. */
1408 else if ((flags
& BSF_WARNING
) != 0)
1411 /* Nothing to do here for constructor symbols. */
1412 else if ((flags
& BSF_CONSTRUCTOR
) != 0)
1415 /* If this is a ref, set non_ir_ref. */
1416 else if (bfd_is_und_section (section
))
1418 /* Replace the undefined dummy bfd with the real one. */
1419 if ((h
->type
== bfd_link_hash_undefined
1420 || h
->type
== bfd_link_hash_undefweak
)
1421 && (h
->u
.undef
.abfd
== NULL
1422 || (h
->u
.undef
.abfd
->flags
& BFD_PLUGIN
) != 0))
1423 h
->u
.undef
.abfd
= abfd
;
1428 /* A common symbol should be merged with other commons or
1429 defs with the same name. In particular, a common ought
1430 to be overridden by a def in a -flto object. In that
1431 sense a common is also a ref. */
1432 else if (bfd_is_com_section (section
))
1434 if (h
->type
== bfd_link_hash_common
1435 && is_ir_dummy_bfd (sym_bfd
= h
->u
.c
.p
->section
->owner
))
1437 h
->type
= bfd_link_hash_undefweak
;
1438 h
->u
.undef
.abfd
= sym_bfd
;
1443 /* Otherwise, it must be a new def.
1444 Ensure any symbol defined in an IR dummy BFD takes on a
1445 new value from a real BFD. Weak symbols are not normally
1446 overridden by a new weak definition, and strong symbols
1447 will normally cause multiple definition errors. Avoid
1448 this by making the symbol appear to be undefined.
1450 NB: We change the previous definition in the IR object to
1451 undefweak only after all LTO symbols have been read or for
1453 else if ((info
->lto_all_symbols_read
1454 || bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
1455 && (((h
->type
== bfd_link_hash_defweak
1456 || h
->type
== bfd_link_hash_defined
)
1457 && is_ir_dummy_bfd (sym_bfd
= h
->u
.def
.section
->owner
))
1458 || (h
->type
== bfd_link_hash_common
1459 && is_ir_dummy_bfd (sym_bfd
= h
->u
.c
.p
->section
->owner
))))
1461 h
->type
= bfd_link_hash_undefweak
;
1462 h
->u
.undef
.abfd
= sym_bfd
;
1467 if ((abfd
->flags
& DYNAMIC
) == 0)
1468 h
->non_ir_ref_regular
= true;
1470 h
->non_ir_ref_dynamic
= true;
1474 /* Continue with cref/nocrossref/trace-sym processing. */
1477 || (info
->notice_hash
!= NULL
1478 && bfd_hash_lookup (info
->notice_hash
, orig_h
->root
.string
,
1479 false, false) != NULL
))
1480 return (*orig_callbacks
->notice
) (info
, orig_h
, inh
,
1481 abfd
, section
, value
, flags
);
1484 #endif /* BFD_SUPPORTS_PLUGINS */