1 /* Plugin control for the GNU linker.
2 Copyright (C) 2010-2020 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"
34 #include "../bfd/plugin.h"
38 # include <sys/mman.h>
40 # define MAP_FAILED ((void *) -1)
46 # define MAP_PRIVATE 0
50 #if !(defined(errno) || defined(_MSC_VER) && defined(_INC_ERRNO))
53 #if !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H)
57 /* Report plugin symbols. */
58 bfd_boolean report_plugin_symbols
;
60 /* The suffix to append to the name of the real (claimed) object file
61 when generating a dummy BFD to hold the IR symbols sent from the
62 plugin. For cosmetic use only; appears in maps, crefs etc. */
63 #define IRONLY_SUFFIX " (symbol from plugin)"
65 /* Stores a single argument passed to a plugin. */
66 typedef struct plugin_arg
68 struct plugin_arg
*next
;
72 /* Holds all details of a single plugin. */
75 /* Next on the list of plugins, or NULL at end of chain. */
77 /* The argument string given to --plugin. */
79 /* The shared library handle returned by dlopen. */
81 /* The list of argument string given to --plugin-opt. */
83 /* Number of args in the list, for convenience. */
85 /* The plugin's event handlers. */
86 ld_plugin_claim_file_handler claim_file_handler
;
87 ld_plugin_all_symbols_read_handler all_symbols_read_handler
;
88 ld_plugin_cleanup_handler cleanup_handler
;
89 /* TRUE if the cleanup handlers have been called. */
90 bfd_boolean cleanup_done
;
93 typedef struct view_buffer
100 /* The internal version of struct ld_plugin_input_file with a BFD
102 typedef struct plugin_input_file
105 view_buffer_t view_buffer
;
108 bfd_boolean use_mmap
;
111 } plugin_input_file_t
;
113 /* The master list of all plugins. */
114 static plugin_t
*plugins_list
= NULL
;
116 /* We keep a tail pointer for easy linking on the end. */
117 static plugin_t
**plugins_tail_chain_ptr
= &plugins_list
;
119 /* The last plugin added to the list, for receiving args. */
120 static plugin_t
*last_plugin
= NULL
;
122 /* The tail of the arg chain of the last plugin added to the list. */
123 static plugin_arg_t
**last_plugin_args_tail_chain_ptr
= NULL
;
125 /* The plugin which is currently having a callback executed. */
126 static plugin_t
*called_plugin
= NULL
;
128 /* Last plugin to cause an error, if any. */
129 static const char *error_plugin
= NULL
;
131 /* State of linker "notice" interface before we poked at it. */
132 static bfd_boolean orig_notice_all
;
134 /* Original linker callbacks, and the plugin version. */
135 static const struct bfd_link_callbacks
*orig_callbacks
;
136 static struct bfd_link_callbacks plugin_callbacks
;
138 /* Set at all symbols read time, to avoid recursively offering the plugin
139 its own newly-added input files and libs to claim. */
140 bfd_boolean no_more_claiming
= FALSE
;
142 #if HAVE_MMAP && HAVE_GETPAGESIZE
143 /* Page size used by mmap. */
144 static off_t plugin_pagesize
;
147 /* List of tags to set in the constant leading part of the tv array. */
148 static const enum ld_plugin_tag tv_header_tags
[] =
155 LDPT_REGISTER_CLAIM_FILE_HOOK
,
156 LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK
,
157 LDPT_REGISTER_CLEANUP_HOOK
,
161 LDPT_RELEASE_INPUT_FILE
,
165 LDPT_ADD_INPUT_LIBRARY
,
166 LDPT_SET_EXTRA_LIBRARY_PATH
169 /* How many entries in the constant leading part of the tv array. */
170 static const size_t tv_header_size
= ARRAY_SIZE (tv_header_tags
);
172 /* Forward references. */
173 static bfd_boolean
plugin_notice (struct bfd_link_info
*,
174 struct bfd_link_hash_entry
*,
175 struct bfd_link_hash_entry
*,
176 bfd
*, asection
*, bfd_vma
, flagword
);
178 static bfd_cleanup
plugin_object_p (bfd
*);
180 #if !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H)
182 #define RTLD_NOW 0 /* Dummy value. */
185 dlopen (const char *file
, int mode ATTRIBUTE_UNUSED
)
187 return LoadLibrary (file
);
191 dlsym (void *handle
, const char *name
)
193 return GetProcAddress (handle
, name
);
197 dlclose (void *handle
)
199 FreeLibrary (handle
);
203 #endif /* !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H) */
213 /* Helper function for exiting with error status. */
215 set_plugin_error (const char *plugin
)
217 error_plugin
= plugin
;
221 /* Test if an error occurred. */
223 plugin_error_p (void)
225 return error_plugin
!= NULL
;
228 /* Return name of plugin which caused an error if any. */
230 plugin_error_plugin (void)
232 return error_plugin
? error_plugin
: _("<no plugin>");
235 /* Handle -plugin arg: find and load plugin, or return error. */
237 plugin_opt_plugin (const char *plugin
)
240 plugin_t
*curplug
= plugins_list
;
242 newplug
= xmalloc (sizeof *newplug
);
243 memset (newplug
, 0, sizeof *newplug
);
244 newplug
->name
= plugin
;
245 newplug
->dlhandle
= dlopen (plugin
, RTLD_NOW
);
246 if (!newplug
->dlhandle
)
247 einfo (_("%F%P: %s: error loading plugin: %s\n"), plugin
, dlerror ());
249 /* Check if plugin has been loaded already. */
252 if (newplug
->dlhandle
== curplug
->dlhandle
)
254 einfo (_("%P: %s: duplicated plugin\n"), plugin
);
258 curplug
= curplug
->next
;
261 /* Chain on end, so when we run list it is in command-line order. */
262 *plugins_tail_chain_ptr
= newplug
;
263 plugins_tail_chain_ptr
= &newplug
->next
;
265 /* Record it as current plugin for receiving args. */
266 last_plugin
= newplug
;
267 last_plugin_args_tail_chain_ptr
= &newplug
->args
;
270 /* Accumulate option arguments for last-loaded plugin, or return
273 plugin_opt_plugin_arg (const char *arg
)
275 plugin_arg_t
*newarg
;
278 return set_plugin_error (_("<no plugin>"));
280 /* Ignore -pass-through= from GCC driver. */
283 const char *p
= arg
+ 1;
287 if (strncmp (p
, "pass-through=", 13) == 0)
291 newarg
= xmalloc (sizeof *newarg
);
295 /* Chain on end to preserve command-line order. */
296 *last_plugin_args_tail_chain_ptr
= newarg
;
297 last_plugin_args_tail_chain_ptr
= &newarg
->next
;
298 last_plugin
->n_args
++;
302 /* Generate a dummy BFD to represent an IR file, for any callers of
303 plugin_call_claim_file to use as the handle in the ld_plugin_input_file
304 struct that they build to pass in. The BFD is initially writable, so
305 that symbols can be added to it; it must be made readable after the
306 add_symbols hook has been called so that it can be read when linking. */
308 plugin_get_ir_dummy_bfd (const char *name
, bfd
*srctemplate
)
311 bfd_boolean bfd_plugin_target
;
313 bfd_use_reserved_id
= 1;
314 bfd_plugin_target
= bfd_plugin_target_p (srctemplate
->xvec
);
315 abfd
= bfd_create (concat (name
, IRONLY_SUFFIX
, (const char *) NULL
),
316 bfd_plugin_target
? link_info
.output_bfd
: srctemplate
);
319 abfd
->flags
|= BFD_LINKER_CREATED
| BFD_PLUGIN
;
320 if (!bfd_make_writable (abfd
))
322 if (!bfd_plugin_target
)
324 bfd_set_arch_info (abfd
, bfd_get_arch_info (srctemplate
));
325 bfd_set_gp_size (abfd
, bfd_get_gp_size (srctemplate
));
326 if (!bfd_copy_private_bfd_data (srctemplate
, abfd
))
332 /* Create section to own the symbols. */
333 flags
= (SEC_CODE
| SEC_HAS_CONTENTS
| SEC_READONLY
334 | SEC_ALLOC
| SEC_LOAD
| SEC_KEEP
| SEC_EXCLUDE
);
335 if (bfd_make_section_anyway_with_flags (abfd
, ".text", flags
))
340 einfo (_("%F%P: could not create dummy IR bfd: %E\n"));
344 /* Check if the BFD passed in is an IR dummy object file. */
345 static inline bfd_boolean
346 is_ir_dummy_bfd (const bfd
*abfd
)
348 /* ABFD can sometimes legitimately be NULL, e.g. when called from one
349 of the linker callbacks for a symbol in the *ABS* or *UND* sections. */
350 return abfd
!= NULL
&& (abfd
->flags
& BFD_PLUGIN
) != 0;
353 /* Helpers to convert between BFD and GOLD symbol formats. */
354 static enum ld_plugin_status
355 asymbol_from_plugin_symbol (bfd
*abfd
, asymbol
*asym
,
356 const struct ld_plugin_symbol
*ldsym
)
358 flagword flags
= BSF_NO_FLAGS
;
359 struct bfd_section
*section
;
361 asym
->the_bfd
= abfd
;
362 asym
->name
= (ldsym
->version
363 ? concat (ldsym
->name
, "@", ldsym
->version
, (const char *) NULL
)
373 if (ldsym
->comdat_key
)
375 char *name
= concat (".gnu.linkonce.t.", ldsym
->comdat_key
,
376 (const char *) NULL
);
377 section
= bfd_get_section_by_name (abfd
, name
);
384 sflags
= (SEC_CODE
| SEC_HAS_CONTENTS
| SEC_READONLY
385 | SEC_ALLOC
| SEC_LOAD
| SEC_KEEP
| SEC_EXCLUDE
386 | SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
);
387 section
= bfd_make_section_anyway_with_flags (abfd
, name
, sflags
);
393 section
= bfd_get_section_by_name (abfd
, ".text");
400 section
= bfd_und_section_ptr
;
405 section
= bfd_com_section_ptr
;
406 asym
->value
= ldsym
->size
;
413 asym
->section
= section
;
415 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
417 elf_symbol_type
*elfsym
= elf_symbol_from (abfd
, asym
);
418 unsigned char visibility
;
421 einfo (_("%F%P: %s: non-ELF symbol in ELF BFD!\n"), asym
->name
);
423 if (ldsym
->def
== LDPK_COMMON
)
425 elfsym
->internal_elf_sym
.st_shndx
= SHN_COMMON
;
426 elfsym
->internal_elf_sym
.st_value
= 1;
429 switch (ldsym
->visibility
)
432 einfo (_("%F%P: unknown ELF symbol visibility: %d!\n"),
437 visibility
= STV_DEFAULT
;
440 visibility
= STV_PROTECTED
;
443 visibility
= STV_INTERNAL
;
446 visibility
= STV_HIDDEN
;
449 elfsym
->internal_elf_sym
.st_other
|= visibility
;
455 /* Register a claim-file handler. */
456 static enum ld_plugin_status
457 register_claim_file (ld_plugin_claim_file_handler handler
)
459 ASSERT (called_plugin
);
460 called_plugin
->claim_file_handler
= handler
;
464 /* Register an all-symbols-read handler. */
465 static enum ld_plugin_status
466 register_all_symbols_read (ld_plugin_all_symbols_read_handler handler
)
468 ASSERT (called_plugin
);
469 called_plugin
->all_symbols_read_handler
= handler
;
473 /* Register a cleanup handler. */
474 static enum ld_plugin_status
475 register_cleanup (ld_plugin_cleanup_handler handler
)
477 ASSERT (called_plugin
);
478 called_plugin
->cleanup_handler
= handler
;
482 /* Add symbols from a plugin-claimed input file. */
483 static enum ld_plugin_status
484 add_symbols (void *handle
, int nsyms
, const struct ld_plugin_symbol
*syms
)
487 plugin_input_file_t
*input
= handle
;
488 bfd
*abfd
= input
->abfd
;
491 ASSERT (called_plugin
);
492 symptrs
= xmalloc (nsyms
* sizeof *symptrs
);
493 for (n
= 0; n
< nsyms
; n
++)
495 enum ld_plugin_status rv
;
498 bfdsym
= bfd_make_empty_symbol (abfd
);
500 rv
= asymbol_from_plugin_symbol (abfd
, bfdsym
, syms
+ n
);
504 bfd_set_symtab (abfd
, symptrs
, nsyms
);
508 /* Get the input file information with an open (possibly re-opened)
510 static enum ld_plugin_status
511 get_input_file (const void *handle
, struct ld_plugin_input_file
*file
)
513 const plugin_input_file_t
*input
= handle
;
515 ASSERT (called_plugin
);
517 file
->name
= input
->name
;
518 file
->offset
= input
->offset
;
519 file
->filesize
= input
->filesize
;
520 file
->handle
= (void *) handle
;
525 /* Get view of the input file. */
526 static enum ld_plugin_status
527 get_view (const void *handle
, const void **viewp
)
529 plugin_input_file_t
*input
= (plugin_input_file_t
*) handle
;
531 size_t size
= input
->filesize
;
532 off_t offset
= input
->offset
;
533 #if HAVE_MMAP && HAVE_GETPAGESIZE
537 ASSERT (called_plugin
);
539 /* FIXME: einfo should support %lld. */
540 if ((off_t
) size
!= input
->filesize
)
541 einfo (_("%F%P: unsupported input file size: %s (%ld bytes)\n"),
542 input
->name
, (long) input
->filesize
);
544 /* Check the cached view buffer. */
545 if (input
->view_buffer
.addr
!= NULL
546 && input
->view_buffer
.filesize
== size
547 && input
->view_buffer
.offset
== offset
)
549 *viewp
= input
->view_buffer
.addr
;
553 input
->view_buffer
.filesize
= size
;
554 input
->view_buffer
.offset
= offset
;
557 # if HAVE_GETPAGESIZE
558 bias
= offset
% plugin_pagesize
;
562 buffer
= mmap (NULL
, size
, PROT_READ
, MAP_PRIVATE
, input
->fd
, offset
);
563 if (buffer
!= MAP_FAILED
)
565 input
->use_mmap
= TRUE
;
566 # if HAVE_GETPAGESIZE
575 input
->use_mmap
= FALSE
;
577 if (lseek (input
->fd
, offset
, SEEK_SET
) < 0)
580 buffer
= bfd_alloc (input
->abfd
, size
);
587 ssize_t got
= read (input
->fd
, p
, size
);
595 else if (errno
!= EINTR
)
601 input
->view_buffer
.addr
= buffer
;
607 /* Release the input file. */
608 static enum ld_plugin_status
609 release_input_file (const void *handle
)
611 plugin_input_file_t
*input
= (plugin_input_file_t
*) handle
;
612 ASSERT (called_plugin
);
621 /* Return TRUE if a defined symbol might be reachable from outside the
622 universe of claimed objects. */
623 static inline bfd_boolean
624 is_visible_from_outside (struct ld_plugin_symbol
*lsym
,
625 struct bfd_link_hash_entry
*blhe
)
627 if (bfd_link_relocatable (&link_info
))
629 if (blhe
->non_ir_ref_dynamic
630 || link_info
.export_dynamic
631 || bfd_link_dll (&link_info
))
633 /* Check if symbol is hidden by version script. */
634 if (bfd_hide_sym_by_version (link_info
.version_info
,
637 /* Only ELF symbols really have visibility. */
638 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
640 struct elf_link_hash_entry
*el
= (struct elf_link_hash_entry
*)blhe
;
641 int vis
= ELF_ST_VISIBILITY (el
->other
);
642 return vis
== STV_DEFAULT
|| vis
== STV_PROTECTED
;
644 /* On non-ELF targets, we can safely make inferences by considering
645 what visibility the plugin would have liked to apply when it first
646 sent us the symbol. During ELF symbol processing, visibility only
647 ever becomes more restrictive, not less, when symbols are merged,
648 so this is a conservative estimate; it may give false positives,
649 declaring something visible from outside when it in fact would
650 not have been, but this will only lead to missed optimisation
651 opportunities during LTRANS at worst; it will not give false
652 negatives, which can lead to the disastrous conclusion that the
653 related symbol is IRONLY. (See GCC PR46319 for an example.) */
654 return (lsym
->visibility
== LDPV_DEFAULT
655 || lsym
->visibility
== LDPV_PROTECTED
);
661 /* Return LTO kind string name that corresponds to IDX enum value. */
663 get_lto_kind (unsigned int idx
)
665 static char buffer
[64];
666 const char *lto_kind_str
[5] =
675 if (idx
< ARRAY_SIZE (lto_kind_str
))
676 return lto_kind_str
[idx
];
678 sprintf (buffer
, _("unknown LTO kind value %x"), idx
);
682 /* Return LTO resolution string name that corresponds to IDX enum value. */
684 get_lto_resolution (unsigned int idx
)
686 static char buffer
[64];
687 static const char *lto_resolution_str
[10] =
692 "PREVAILING_DEF_IRONLY",
698 "PREVAILING_DEF_IRONLY_EXP",
701 if (idx
< ARRAY_SIZE (lto_resolution_str
))
702 return lto_resolution_str
[idx
];
704 sprintf (buffer
, _("unknown LTO resolution value %x"), idx
);
708 /* Return LTO visibility string name that corresponds to IDX enum value. */
710 get_lto_visibility (unsigned int idx
)
712 static char buffer
[64];
713 const char *lto_visibility_str
[4] =
721 if (idx
< ARRAY_SIZE (lto_visibility_str
))
722 return lto_visibility_str
[idx
];
724 sprintf (buffer
, _("unknown LTO visibility value %x"), idx
);
728 /* Get the symbol resolution info for a plugin-claimed input file. */
729 static enum ld_plugin_status
730 get_symbols (const void *handle
, int nsyms
, struct ld_plugin_symbol
*syms
,
733 const plugin_input_file_t
*input
= handle
;
734 const bfd
*abfd
= (const bfd
*) input
->abfd
;
737 ASSERT (called_plugin
);
738 for (n
= 0; n
< nsyms
; n
++)
740 struct bfd_link_hash_entry
*blhe
;
743 struct bfd_link_hash_entry
*h
744 = bfd_link_hash_lookup (link_info
.hash
, syms
[n
].name
,
746 enum { wrap_none
, wrapper
, wrapped
} wrap_status
= wrap_none
;
748 if (syms
[n
].def
!= LDPK_UNDEF
&& syms
[n
].def
!= LDPK_WEAKUNDEF
)
751 if (blhe
&& link_info
.wrap_hash
!= NULL
)
753 /* Check if a symbol is a wrapper symbol. */
754 struct bfd_link_hash_entry
*unwrap
755 = unwrap_hash_lookup (&link_info
, (bfd
*) abfd
, blhe
);
756 if (unwrap
&& unwrap
!= h
)
757 wrap_status
= wrapper
;
762 blhe
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
763 &link_info
, syms
[n
].name
,
765 /* Check if a symbol is a wrapped symbol. */
766 if (blhe
&& blhe
!= h
)
767 wrap_status
= wrapped
;
771 /* The plugin is called to claim symbols in an archive element
772 from plugin_object_p. But those symbols aren't needed to
773 create output. They are defined and referenced only within
786 res
= LDPR_PREVAILING_DEF_IRONLY
;
792 /* Determine resolution from blhe type and symbol's original type. */
793 if (blhe
->type
== bfd_link_hash_undefined
794 || blhe
->type
== bfd_link_hash_undefweak
)
799 if (blhe
->type
!= bfd_link_hash_defined
800 && blhe
->type
!= bfd_link_hash_defweak
801 && blhe
->type
!= bfd_link_hash_common
)
803 /* We should not have a new, indirect or warning symbol here. */
804 einfo (_("%F%P: %s: plugin symbol table corrupt (sym type %d)\n"),
805 called_plugin
->name
, blhe
->type
);
808 /* Find out which section owns the symbol. Since it's not undef,
809 it must have an owner; if it's not a common symbol, both defs
810 and weakdefs keep it in the same place. */
811 owner_sec
= (blhe
->type
== bfd_link_hash_common
812 ? blhe
->u
.c
.p
->section
813 : blhe
->u
.def
.section
);
816 /* If it was originally undefined or common, then it has been
817 resolved; determine how. */
818 if (syms
[n
].def
== LDPK_UNDEF
819 || syms
[n
].def
== LDPK_WEAKUNDEF
820 || syms
[n
].def
== LDPK_COMMON
)
822 if (owner_sec
->owner
== link_info
.output_bfd
)
823 res
= LDPR_RESOLVED_EXEC
;
824 else if (owner_sec
->owner
== abfd
)
825 res
= LDPR_PREVAILING_DEF_IRONLY
;
826 else if (is_ir_dummy_bfd (owner_sec
->owner
))
827 res
= LDPR_RESOLVED_IR
;
828 else if (owner_sec
->owner
!= NULL
829 && (owner_sec
->owner
->flags
& DYNAMIC
) != 0)
830 res
= LDPR_RESOLVED_DYN
;
832 res
= LDPR_RESOLVED_EXEC
;
835 /* Was originally def, or weakdef. Does it prevail? If the
836 owner is the original dummy bfd that supplied it, then this
837 is the definition that has prevailed. */
838 else if (owner_sec
->owner
== link_info
.output_bfd
)
839 res
= LDPR_PREEMPTED_REG
;
840 else if (owner_sec
->owner
== abfd
)
841 res
= LDPR_PREVAILING_DEF_IRONLY
;
843 /* Was originally def, weakdef, or common, but has been pre-empted. */
844 else if (is_ir_dummy_bfd (owner_sec
->owner
))
845 res
= LDPR_PREEMPTED_IR
;
847 res
= LDPR_PREEMPTED_REG
;
849 if (res
== LDPR_PREVAILING_DEF_IRONLY
)
851 /* We need to know if the sym is referenced from non-IR files. Or
852 even potentially-referenced, perhaps in a future final link if
853 this is a partial one, perhaps dynamically at load-time if the
854 symbol is externally visible. Also check for wrapper symbol. */
855 if (blhe
->non_ir_ref_regular
|| wrap_status
== wrapper
)
856 res
= LDPR_PREVAILING_DEF
;
857 else if (wrap_status
== wrapped
)
858 res
= LDPR_RESOLVED_IR
;
859 else if (is_visible_from_outside (&syms
[n
], blhe
))
860 res
= def_ironly_exp
;
864 syms
[n
].resolution
= res
;
865 if (report_plugin_symbols
)
866 einfo (_("%P: %pB: symbol `%s' "
867 "definition: %s, visibility: %s, resolution: %s\n"),
869 get_lto_kind (syms
[n
].def
),
870 get_lto_visibility (syms
[n
].visibility
),
871 get_lto_resolution (res
));
876 static enum ld_plugin_status
877 get_symbols_v1 (const void *handle
, int nsyms
, struct ld_plugin_symbol
*syms
)
879 return get_symbols (handle
, nsyms
, syms
, LDPR_PREVAILING_DEF
);
882 static enum ld_plugin_status
883 get_symbols_v2 (const void *handle
, int nsyms
, struct ld_plugin_symbol
*syms
)
885 return get_symbols (handle
, nsyms
, syms
, LDPR_PREVAILING_DEF_IRONLY_EXP
);
888 /* Add a new (real) input file generated by a plugin. */
889 static enum ld_plugin_status
890 add_input_file (const char *pathname
)
892 lang_input_statement_type
*is
;
894 ASSERT (called_plugin
);
895 is
= lang_add_input_file (xstrdup (pathname
), lang_input_file_is_file_enum
,
899 is
->flags
.lto_output
= 1;
903 /* Add a new (real) library required by a plugin. */
904 static enum ld_plugin_status
905 add_input_library (const char *pathname
)
907 lang_input_statement_type
*is
;
909 ASSERT (called_plugin
);
910 is
= lang_add_input_file (xstrdup (pathname
), lang_input_file_is_l_enum
,
914 is
->flags
.lto_output
= 1;
918 /* Set the extra library path to be used by libraries added via
919 add_input_library. */
920 static enum ld_plugin_status
921 set_extra_library_path (const char *path
)
923 ASSERT (called_plugin
);
924 ldfile_add_library_path (xstrdup (path
), FALSE
);
928 /* Issue a diagnostic message from a plugin. */
929 static enum ld_plugin_status
930 message (int level
, const char *format
, ...)
933 va_start (args
, format
);
938 vfinfo (stdout
, format
, args
, FALSE
);
943 char *newfmt
= concat (_("%P: warning: "), format
, "\n",
944 (const char *) NULL
);
945 vfinfo (stdout
, newfmt
, args
, TRUE
);
953 char *newfmt
= concat (level
== LDPL_FATAL
? "%F" : "%X",
954 _("%P: error: "), format
, "\n",
955 (const char *) NULL
);
957 vfinfo (stderr
, newfmt
, args
, TRUE
);
968 /* Helper to size leading part of tv array and set it up. */
970 set_tv_header (struct ld_plugin_tv
*tv
)
975 static const unsigned int major
= (unsigned)(BFD_VERSION
/ 100000000UL);
976 static const unsigned int minor
= (unsigned)(BFD_VERSION
/ 1000000UL) % 100;
978 for (i
= 0; i
< tv_header_size
; i
++)
980 tv
[i
].tv_tag
= tv_header_tags
[i
];
981 #define TVU(x) tv[i].tv_u.tv_ ## x
982 switch (tv
[i
].tv_tag
)
985 TVU(message
) = message
;
987 case LDPT_API_VERSION
:
988 TVU(val
) = LD_PLUGIN_API_VERSION
;
990 case LDPT_GNU_LD_VERSION
:
991 TVU(val
) = major
* 100 + minor
;
993 case LDPT_LINKER_OUTPUT
:
994 TVU(val
) = (bfd_link_relocatable (&link_info
) ? LDPO_REL
995 : bfd_link_pde (&link_info
) ? LDPO_EXEC
996 : bfd_link_pie (&link_info
) ? LDPO_PIE
999 case LDPT_OUTPUT_NAME
:
1000 TVU(string
) = output_filename
;
1002 case LDPT_REGISTER_CLAIM_FILE_HOOK
:
1003 TVU(register_claim_file
) = register_claim_file
;
1005 case LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK
:
1006 TVU(register_all_symbols_read
) = register_all_symbols_read
;
1008 case LDPT_REGISTER_CLEANUP_HOOK
:
1009 TVU(register_cleanup
) = register_cleanup
;
1011 case LDPT_ADD_SYMBOLS
:
1012 TVU(add_symbols
) = add_symbols
;
1014 case LDPT_GET_INPUT_FILE
:
1015 TVU(get_input_file
) = get_input_file
;
1018 TVU(get_view
) = get_view
;
1020 case LDPT_RELEASE_INPUT_FILE
:
1021 TVU(release_input_file
) = release_input_file
;
1023 case LDPT_GET_SYMBOLS
:
1024 TVU(get_symbols
) = get_symbols_v1
;
1026 case LDPT_GET_SYMBOLS_V2
:
1027 TVU(get_symbols
) = get_symbols_v2
;
1029 case LDPT_ADD_INPUT_FILE
:
1030 TVU(add_input_file
) = add_input_file
;
1032 case LDPT_ADD_INPUT_LIBRARY
:
1033 TVU(add_input_library
) = add_input_library
;
1035 case LDPT_SET_EXTRA_LIBRARY_PATH
:
1036 TVU(set_extra_library_path
) = set_extra_library_path
;
1039 /* Added a new entry to the array without adding
1040 a new case to set up its value is a bug. */
1047 /* Append the per-plugin args list and trailing LDPT_NULL to tv. */
1049 set_tv_plugin_args (plugin_t
*plugin
, struct ld_plugin_tv
*tv
)
1051 plugin_arg_t
*arg
= plugin
->args
;
1054 tv
->tv_tag
= LDPT_OPTION
;
1055 tv
->tv_u
.tv_string
= arg
->arg
;
1059 tv
->tv_tag
= LDPT_NULL
;
1060 tv
->tv_u
.tv_val
= 0;
1063 /* Load up and initialise all plugins after argument parsing. */
1065 plugin_load_plugins (void)
1067 struct ld_plugin_tv
*my_tv
;
1068 unsigned int max_args
= 0;
1069 plugin_t
*curplug
= plugins_list
;
1071 /* If there are no plugins, we need do nothing this run. */
1075 /* First pass over plugins to find max # args needed so that we
1076 can size and allocate the tv array. */
1079 if (curplug
->n_args
> max_args
)
1080 max_args
= curplug
->n_args
;
1081 curplug
= curplug
->next
;
1084 /* Allocate tv array and initialise constant part. */
1085 my_tv
= xmalloc ((max_args
+ 1 + tv_header_size
) * sizeof *my_tv
);
1086 set_tv_header (my_tv
);
1088 /* Pass over plugins again, activating them. */
1089 curplug
= plugins_list
;
1092 enum ld_plugin_status rv
;
1093 ld_plugin_onload onloadfn
;
1095 onloadfn
= (ld_plugin_onload
) dlsym (curplug
->dlhandle
, "onload");
1097 onloadfn
= (ld_plugin_onload
) dlsym (curplug
->dlhandle
, "_onload");
1099 einfo (_("%F%P: %s: error loading plugin: %s\n"),
1100 curplug
->name
, dlerror ());
1101 set_tv_plugin_args (curplug
, &my_tv
[tv_header_size
]);
1102 called_plugin
= curplug
;
1103 rv
= (*onloadfn
) (my_tv
);
1104 called_plugin
= NULL
;
1106 einfo (_("%F%P: %s: plugin error: %d\n"), curplug
->name
, rv
);
1107 curplug
= curplug
->next
;
1110 /* Since plugin(s) inited ok, assume they're going to want symbol
1111 resolutions, which needs us to track which symbols are referenced
1112 by non-IR files using the linker's notice callback. */
1113 orig_notice_all
= link_info
.notice_all
;
1114 orig_callbacks
= link_info
.callbacks
;
1115 plugin_callbacks
= *orig_callbacks
;
1116 plugin_callbacks
.notice
= &plugin_notice
;
1117 link_info
.notice_all
= TRUE
;
1118 link_info
.lto_plugin_active
= TRUE
;
1119 link_info
.callbacks
= &plugin_callbacks
;
1121 register_ld_plugin_object_p (plugin_object_p
);
1123 #if HAVE_MMAP && HAVE_GETPAGESIZE
1124 plugin_pagesize
= getpagesize ();
1128 /* Call 'claim file' hook for all plugins. */
1130 plugin_call_claim_file (const struct ld_plugin_input_file
*file
, int *claimed
)
1132 plugin_t
*curplug
= plugins_list
;
1134 while (curplug
&& !*claimed
)
1136 if (curplug
->claim_file_handler
)
1138 enum ld_plugin_status rv
;
1140 called_plugin
= curplug
;
1141 rv
= (*curplug
->claim_file_handler
) (file
, claimed
);
1142 called_plugin
= NULL
;
1144 set_plugin_error (curplug
->name
);
1146 curplug
= curplug
->next
;
1148 return plugin_error_p () ? -1 : 0;
1151 /* Duplicates a character string with memory attached to ABFD. */
1154 plugin_strdup (bfd
*abfd
, const char *str
)
1158 strlength
= strlen (str
) + 1;
1159 copy
= bfd_alloc (abfd
, strlength
);
1161 einfo (_("%F%P: plugin_strdup failed to allocate memory: %s\n"),
1163 memcpy (copy
, str
, strlength
);
1168 plugin_cleanup (bfd
*abfd ATTRIBUTE_UNUSED
)
1173 plugin_object_p (bfd
*ibfd
)
1176 plugin_input_file_t
*input
;
1177 struct ld_plugin_input_file file
;
1180 /* Don't try the dummy object file. */
1181 if ((ibfd
->flags
& BFD_PLUGIN
) != 0)
1184 if (ibfd
->plugin_format
!= bfd_plugin_unknown
)
1186 if (ibfd
->plugin_format
== bfd_plugin_yes
)
1187 return plugin_cleanup
;
1192 /* We create a dummy BFD, initially empty, to house whatever symbols
1193 the plugin may want to add. */
1194 abfd
= plugin_get_ir_dummy_bfd (bfd_get_filename (ibfd
), ibfd
);
1196 input
= bfd_alloc (abfd
, sizeof (*input
));
1198 einfo (_("%F%P: plugin failed to allocate memory for input: %s\n"),
1201 if (!bfd_plugin_open_input (ibfd
, &file
))
1204 if (file
.name
== bfd_get_filename (ibfd
))
1206 /* We must copy filename attached to ibfd if it is not an archive
1207 member since it may be freed by bfd_close below. */
1208 file
.name
= plugin_strdup (abfd
, file
.name
);
1211 file
.handle
= input
;
1213 input
->view_buffer
.addr
= NULL
;
1214 input
->view_buffer
.filesize
= 0;
1215 input
->view_buffer
.offset
= 0;
1216 input
->fd
= file
.fd
;
1217 input
->use_mmap
= FALSE
;
1218 input
->offset
= file
.offset
;
1219 input
->filesize
= file
.filesize
;
1220 input
->name
= plugin_strdup (abfd
, bfd_get_filename (ibfd
));
1224 if (plugin_call_claim_file (&file
, &claimed
))
1225 einfo (_("%F%P: %s: plugin reported error claiming file\n"),
1226 plugin_error_plugin ());
1228 if (input
->fd
!= -1 && !bfd_plugin_target_p (ibfd
->xvec
))
1230 /* FIXME: fd belongs to us, not the plugin. GCC plugin, which
1231 doesn't need fd after plugin_call_claim_file, doesn't use
1232 BFD plugin target vector. Since GCC plugin doesn't call
1233 release_input_file, we close it here. LLVM plugin, which
1234 needs fd after plugin_call_claim_file and calls
1235 release_input_file after it is done, uses BFD plugin target
1236 vector. This scheme doesn't work when a plugin needs fd and
1237 doesn't use BFD plugin target vector neither. */
1244 ibfd
->plugin_format
= bfd_plugin_yes
;
1245 ibfd
->plugin_dummy_bfd
= abfd
;
1246 bfd_make_readable (abfd
);
1247 abfd
->no_export
= ibfd
->no_export
;
1248 return plugin_cleanup
;
1253 if (input
->use_mmap
)
1255 /* If plugin didn't claim the file, unmap the buffer. */
1256 char *addr
= input
->view_buffer
.addr
;
1257 off_t size
= input
->view_buffer
.filesize
;
1258 # if HAVE_GETPAGESIZE
1259 off_t bias
= input
->view_buffer
.offset
% plugin_pagesize
;
1263 munmap (addr
, size
);
1267 /* If plugin didn't claim the file, we don't need the dummy bfd.
1268 Can't avoid speculatively creating it, alas. */
1269 ibfd
->plugin_format
= bfd_plugin_no
;
1270 bfd_close_all_done (abfd
);
1276 plugin_maybe_claim (lang_input_statement_type
*entry
)
1278 ASSERT (entry
->header
.type
== lang_input_statement_enum
);
1279 if (plugin_object_p (entry
->the_bfd
))
1281 bfd
*abfd
= entry
->the_bfd
->plugin_dummy_bfd
;
1283 /* Discard the real file's BFD and substitute the dummy one. */
1285 /* We can't call bfd_close on archives. BFD archive handling
1286 caches elements, and add_archive_element keeps pointers to
1287 the_bfd and the_bfd->filename in a lang_input_statement_type
1288 linker script statement. */
1289 if (entry
->the_bfd
->my_archive
== NULL
)
1290 bfd_close (entry
->the_bfd
);
1291 entry
->the_bfd
= abfd
;
1292 entry
->flags
.claimed
= 1;
1296 /* Call 'all symbols read' hook for all plugins. */
1298 plugin_call_all_symbols_read (void)
1300 plugin_t
*curplug
= plugins_list
;
1302 /* Disable any further file-claiming. */
1303 no_more_claiming
= TRUE
;
1307 if (curplug
->all_symbols_read_handler
)
1309 enum ld_plugin_status rv
;
1310 called_plugin
= curplug
;
1311 rv
= (*curplug
->all_symbols_read_handler
) ();
1312 called_plugin
= NULL
;
1314 set_plugin_error (curplug
->name
);
1316 curplug
= curplug
->next
;
1318 return plugin_error_p () ? -1 : 0;
1321 /* Call 'cleanup' hook for all plugins at exit. */
1323 plugin_call_cleanup (void)
1325 plugin_t
*curplug
= plugins_list
;
1328 if (curplug
->cleanup_handler
&& !curplug
->cleanup_done
)
1330 enum ld_plugin_status rv
;
1331 curplug
->cleanup_done
= TRUE
;
1332 called_plugin
= curplug
;
1333 rv
= (*curplug
->cleanup_handler
) ();
1334 called_plugin
= NULL
;
1336 info_msg (_("%P: %s: error in plugin cleanup: %d (ignored)\n"),
1338 dlclose (curplug
->dlhandle
);
1340 curplug
= curplug
->next
;
1344 /* To determine which symbols should be resolved LDPR_PREVAILING_DEF
1345 and which LDPR_PREVAILING_DEF_IRONLY, we notice all the symbols as
1346 the linker adds them to the linker hash table. Mark those
1347 referenced from a non-IR file with non_ir_ref_regular or
1348 non_ir_ref_dynamic as appropriate. We have to notice_all symbols,
1349 because we won't necessarily know until later which ones will be
1350 contributed by IR files. */
1352 plugin_notice (struct bfd_link_info
*info
,
1353 struct bfd_link_hash_entry
*h
,
1354 struct bfd_link_hash_entry
*inh
,
1360 struct bfd_link_hash_entry
*orig_h
= h
;
1365 bfd_boolean ref
= FALSE
;
1367 if (h
->type
== bfd_link_hash_warning
)
1370 /* Nothing to do here if this def/ref is from an IR dummy BFD. */
1371 if (is_ir_dummy_bfd (abfd
))
1374 /* Making an indirect symbol counts as a reference unless this
1375 is a brand new symbol. */
1376 else if (bfd_is_ind_section (section
)
1377 || (flags
& BSF_INDIRECT
) != 0)
1379 /* ??? Some of this is questionable. See comments in
1380 _bfd_generic_link_add_one_symbol for case IND. */
1381 if (h
->type
!= bfd_link_hash_new
1382 || inh
->type
== bfd_link_hash_new
)
1384 if ((abfd
->flags
& DYNAMIC
) == 0)
1385 inh
->non_ir_ref_regular
= TRUE
;
1387 inh
->non_ir_ref_dynamic
= TRUE
;
1390 if (h
->type
!= bfd_link_hash_new
)
1394 /* Nothing to do here for warning symbols. */
1395 else if ((flags
& BSF_WARNING
) != 0)
1398 /* Nothing to do here for constructor symbols. */
1399 else if ((flags
& BSF_CONSTRUCTOR
) != 0)
1402 /* If this is a ref, set non_ir_ref. */
1403 else if (bfd_is_und_section (section
))
1405 /* Replace the undefined dummy bfd with the real one. */
1406 if ((h
->type
== bfd_link_hash_undefined
1407 || h
->type
== bfd_link_hash_undefweak
)
1408 && (h
->u
.undef
.abfd
== NULL
1409 || (h
->u
.undef
.abfd
->flags
& BFD_PLUGIN
) != 0))
1410 h
->u
.undef
.abfd
= abfd
;
1415 /* A common symbol should be merged with other commons or
1416 defs with the same name. In particular, a common ought
1417 to be overridden by a def in a -flto object. In that
1418 sense a common is also a ref. */
1419 else if (bfd_is_com_section (section
))
1421 if (h
->type
== bfd_link_hash_common
1422 && is_ir_dummy_bfd (sym_bfd
= h
->u
.c
.p
->section
->owner
))
1424 h
->type
= bfd_link_hash_undefweak
;
1425 h
->u
.undef
.abfd
= sym_bfd
;
1430 /* Otherwise, it must be a new def.
1431 Ensure any symbol defined in an IR dummy BFD takes on a
1432 new value from a real BFD. Weak symbols are not normally
1433 overridden by a new weak definition, and strong symbols
1434 will normally cause multiple definition errors. Avoid
1435 this by making the symbol appear to be undefined. */
1436 else if (((h
->type
== bfd_link_hash_defweak
1437 || h
->type
== bfd_link_hash_defined
)
1438 && is_ir_dummy_bfd (sym_bfd
= h
->u
.def
.section
->owner
))
1439 || (h
->type
== bfd_link_hash_common
1440 && is_ir_dummy_bfd (sym_bfd
= h
->u
.c
.p
->section
->owner
)))
1442 h
->type
= bfd_link_hash_undefweak
;
1443 h
->u
.undef
.abfd
= sym_bfd
;
1448 if ((abfd
->flags
& DYNAMIC
) == 0)
1449 h
->non_ir_ref_regular
= TRUE
;
1451 h
->non_ir_ref_dynamic
= TRUE
;
1455 /* Continue with cref/nocrossref/trace-sym processing. */
1458 || (info
->notice_hash
!= NULL
1459 && bfd_hash_lookup (info
->notice_hash
, orig_h
->root
.string
,
1460 FALSE
, FALSE
) != NULL
))
1461 return (*orig_callbacks
->notice
) (info
, orig_h
, inh
,
1462 abfd
, section
, value
, flags
);