1 /* Plugin control for the GNU linker.
2 Copyright (C) 2010-2015 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"
34 #include "plugin-api.h"
37 # include <sys/mman.h>
39 # define MAP_FAILED ((void *) -1)
45 # define MAP_PRIVATE 0
49 #if !(defined(errno) || defined(_MSC_VER) && defined(_INC_ERRNO))
52 #if !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H)
56 /* Report plugin symbols. */
57 bfd_boolean report_plugin_symbols
;
59 /* The suffix to append to the name of the real (claimed) object file
60 when generating a dummy BFD to hold the IR symbols sent from the
61 plugin. For cosmetic use only; appears in maps, crefs etc. */
62 #define IRONLY_SUFFIX " (symbol from plugin)"
64 /* Stores a single argument passed to a plugin. */
65 typedef struct plugin_arg
67 struct plugin_arg
*next
;
71 /* Holds all details of a single plugin. */
74 /* Next on the list of plugins, or NULL at end of chain. */
76 /* The argument string given to --plugin. */
78 /* The shared library handle returned by dlopen. */
80 /* The list of argument string given to --plugin-opt. */
82 /* Number of args in the list, for convenience. */
84 /* The plugin's event handlers. */
85 ld_plugin_claim_file_handler claim_file_handler
;
86 ld_plugin_all_symbols_read_handler all_symbols_read_handler
;
87 ld_plugin_cleanup_handler cleanup_handler
;
88 /* TRUE if the cleanup handlers have been called. */
89 bfd_boolean cleanup_done
;
92 typedef struct view_buffer
99 /* The internal version of struct ld_plugin_input_file with a BFD
101 typedef struct plugin_input_file
104 view_buffer_t view_buffer
;
107 bfd_boolean use_mmap
;
110 } plugin_input_file_t
;
112 /* The master list of all plugins. */
113 static plugin_t
*plugins_list
= NULL
;
115 /* We keep a tail pointer for easy linking on the end. */
116 static plugin_t
**plugins_tail_chain_ptr
= &plugins_list
;
118 /* The last plugin added to the list, for receiving args. */
119 static plugin_t
*last_plugin
= NULL
;
121 /* The tail of the arg chain of the last plugin added to the list. */
122 static plugin_arg_t
**last_plugin_args_tail_chain_ptr
= NULL
;
124 /* The plugin which is currently having a callback executed. */
125 static plugin_t
*called_plugin
= NULL
;
127 /* Last plugin to cause an error, if any. */
128 static const char *error_plugin
= NULL
;
130 /* State of linker "notice" interface before we poked at it. */
131 static bfd_boolean orig_notice_all
;
133 /* Original linker callbacks, and the plugin version. */
134 static const struct bfd_link_callbacks
*orig_callbacks
;
135 static struct bfd_link_callbacks plugin_callbacks
;
137 /* Set at all symbols read time, to avoid recursively offering the plugin
138 its own newly-added input files and libs to claim. */
139 bfd_boolean no_more_claiming
= FALSE
;
141 #if HAVE_MMAP && HAVE_GETPAGESIZE
142 /* Page size used by mmap. */
143 static off_t plugin_pagesize
;
146 /* List of tags to set in the constant leading part of the tv array. */
147 static const enum ld_plugin_tag tv_header_tags
[] =
154 LDPT_REGISTER_CLAIM_FILE_HOOK
,
155 LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK
,
156 LDPT_REGISTER_CLEANUP_HOOK
,
160 LDPT_RELEASE_INPUT_FILE
,
164 LDPT_ADD_INPUT_LIBRARY
,
165 LDPT_SET_EXTRA_LIBRARY_PATH
168 /* How many entries in the constant leading part of the tv array. */
169 static const size_t tv_header_size
= ARRAY_SIZE (tv_header_tags
);
171 /* Forward references. */
172 static bfd_boolean
plugin_notice (struct bfd_link_info
*,
173 struct bfd_link_hash_entry
*,
174 struct bfd_link_hash_entry
*,
175 bfd
*, asection
*, bfd_vma
, flagword
);
177 #if !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H)
179 #define RTLD_NOW 0 /* Dummy value. */
182 dlopen (const char *file
, int mode ATTRIBUTE_UNUSED
)
184 return LoadLibrary (file
);
188 dlsym (void *handle
, const char *name
)
190 return GetProcAddress (handle
, name
);
194 dlclose (void *handle
)
196 FreeLibrary (handle
);
200 #endif /* !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H) */
210 /* Helper function for exiting with error status. */
212 set_plugin_error (const char *plugin
)
214 error_plugin
= plugin
;
218 /* Test if an error occurred. */
220 plugin_error_p (void)
222 return error_plugin
!= NULL
;
225 /* Return name of plugin which caused an error if any. */
227 plugin_error_plugin (void)
229 return error_plugin
? error_plugin
: _("<no plugin>");
232 /* Handle -plugin arg: find and load plugin, or return error. */
234 plugin_opt_plugin (const char *plugin
)
238 newplug
= xmalloc (sizeof *newplug
);
239 memset (newplug
, 0, sizeof *newplug
);
240 newplug
->name
= plugin
;
241 newplug
->dlhandle
= dlopen (plugin
, RTLD_NOW
);
242 if (!newplug
->dlhandle
)
243 einfo (_("%P%F: %s: error loading plugin: %s\n"), plugin
, dlerror ());
245 /* Chain on end, so when we run list it is in command-line order. */
246 *plugins_tail_chain_ptr
= newplug
;
247 plugins_tail_chain_ptr
= &newplug
->next
;
249 /* Record it as current plugin for receiving args. */
250 last_plugin
= newplug
;
251 last_plugin_args_tail_chain_ptr
= &newplug
->args
;
254 /* Accumulate option arguments for last-loaded plugin, or return
257 plugin_opt_plugin_arg (const char *arg
)
259 plugin_arg_t
*newarg
;
262 return set_plugin_error (_("<no plugin>"));
264 /* Ignore -pass-through= from GCC driver. */
267 const char *p
= arg
+ 1;
271 if (strncmp (p
, "pass-through=", 13) == 0)
275 newarg
= xmalloc (sizeof *newarg
);
279 /* Chain on end to preserve command-line order. */
280 *last_plugin_args_tail_chain_ptr
= newarg
;
281 last_plugin_args_tail_chain_ptr
= &newarg
->next
;
282 last_plugin
->n_args
++;
286 /* Generate a dummy BFD to represent an IR file, for any callers of
287 plugin_call_claim_file to use as the handle in the ld_plugin_input_file
288 struct that they build to pass in. The BFD is initially writable, so
289 that symbols can be added to it; it must be made readable after the
290 add_symbols hook has been called so that it can be read when linking. */
292 plugin_get_ir_dummy_bfd (const char *name
, bfd
*srctemplate
)
296 bfd_use_reserved_id
= 1;
297 abfd
= bfd_create (concat (name
, IRONLY_SUFFIX
, (const char *) NULL
),
301 abfd
->flags
|= BFD_LINKER_CREATED
| BFD_PLUGIN
;
302 bfd_set_arch_info (abfd
, bfd_get_arch_info (srctemplate
));
303 bfd_set_gp_size (abfd
, bfd_get_gp_size (srctemplate
));
304 if (bfd_make_writable (abfd
)
305 && bfd_copy_private_bfd_data (srctemplate
, abfd
))
309 /* Create section to own the symbols. */
310 flags
= (SEC_CODE
| SEC_HAS_CONTENTS
| SEC_READONLY
311 | SEC_ALLOC
| SEC_LOAD
| SEC_KEEP
| SEC_EXCLUDE
);
312 if (bfd_make_section_anyway_with_flags (abfd
, ".text", flags
))
316 einfo (_("could not create dummy IR bfd: %F%E\n"));
320 /* Check if the BFD passed in is an IR dummy object file. */
321 static inline bfd_boolean
322 is_ir_dummy_bfd (const bfd
*abfd
)
324 /* ABFD can sometimes legitimately be NULL, e.g. when called from one
325 of the linker callbacks for a symbol in the *ABS* or *UND* sections. */
326 return abfd
!= NULL
&& (abfd
->flags
& BFD_PLUGIN
) != 0;
329 /* Helpers to convert between BFD and GOLD symbol formats. */
330 static enum ld_plugin_status
331 asymbol_from_plugin_symbol (bfd
*abfd
, asymbol
*asym
,
332 const struct ld_plugin_symbol
*ldsym
)
334 flagword flags
= BSF_NO_FLAGS
;
335 struct bfd_section
*section
;
337 asym
->the_bfd
= abfd
;
338 asym
->name
= (ldsym
->version
339 ? concat (ldsym
->name
, "@", ldsym
->version
, (const char *) NULL
)
349 if (ldsym
->comdat_key
)
351 char *name
= concat (".gnu.linkonce.t.", ldsym
->comdat_key
,
352 (const char *) NULL
);
353 section
= bfd_get_section_by_name (abfd
, name
);
360 sflags
= (SEC_CODE
| SEC_HAS_CONTENTS
| SEC_READONLY
361 | SEC_ALLOC
| SEC_LOAD
| SEC_KEEP
| SEC_EXCLUDE
362 | SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
);
363 section
= bfd_make_section_anyway_with_flags (abfd
, name
, sflags
);
369 section
= bfd_get_section_by_name (abfd
, ".text");
376 section
= bfd_und_section_ptr
;
381 section
= bfd_com_section_ptr
;
382 asym
->value
= ldsym
->size
;
383 /* For ELF targets, set alignment of common symbol to 1. */
384 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
386 ((elf_symbol_type
*) asym
)->internal_elf_sym
.st_shndx
= SHN_COMMON
;
387 ((elf_symbol_type
*) asym
)->internal_elf_sym
.st_value
= 1;
395 asym
->section
= section
;
397 /* Visibility only applies on ELF targets. */
398 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
400 elf_symbol_type
*elfsym
= elf_symbol_from (abfd
, asym
);
401 unsigned char visibility
;
404 einfo (_("%P%F: %s: non-ELF symbol in ELF BFD!\n"), asym
->name
);
405 switch (ldsym
->visibility
)
408 einfo (_("%P%F: unknown ELF symbol visibility: %d!\n"),
411 visibility
= STV_DEFAULT
;
414 visibility
= STV_PROTECTED
;
417 visibility
= STV_INTERNAL
;
420 visibility
= STV_HIDDEN
;
423 elfsym
->internal_elf_sym
.st_other
424 = (visibility
| (elfsym
->internal_elf_sym
.st_other
425 & ~ELF_ST_VISIBILITY (-1)));
431 /* Register a claim-file handler. */
432 static enum ld_plugin_status
433 register_claim_file (ld_plugin_claim_file_handler handler
)
435 ASSERT (called_plugin
);
436 called_plugin
->claim_file_handler
= handler
;
440 /* Register an all-symbols-read handler. */
441 static enum ld_plugin_status
442 register_all_symbols_read (ld_plugin_all_symbols_read_handler handler
)
444 ASSERT (called_plugin
);
445 called_plugin
->all_symbols_read_handler
= handler
;
449 /* Register a cleanup handler. */
450 static enum ld_plugin_status
451 register_cleanup (ld_plugin_cleanup_handler handler
)
453 ASSERT (called_plugin
);
454 called_plugin
->cleanup_handler
= handler
;
458 /* Add symbols from a plugin-claimed input file. */
459 static enum ld_plugin_status
460 add_symbols (void *handle
, int nsyms
, const struct ld_plugin_symbol
*syms
)
463 plugin_input_file_t
*input
= handle
;
464 bfd
*abfd
= input
->abfd
;
467 ASSERT (called_plugin
);
468 symptrs
= xmalloc (nsyms
* sizeof *symptrs
);
469 for (n
= 0; n
< nsyms
; n
++)
471 enum ld_plugin_status rv
;
474 bfdsym
= bfd_make_empty_symbol (abfd
);
476 rv
= asymbol_from_plugin_symbol (abfd
, bfdsym
, syms
+ n
);
480 bfd_set_symtab (abfd
, symptrs
, nsyms
);
484 /* Get the input file information with an open (possibly re-opened)
486 static enum ld_plugin_status
487 get_input_file (const void *handle
, struct ld_plugin_input_file
*file
)
489 const plugin_input_file_t
*input
= handle
;
491 ASSERT (called_plugin
);
493 file
->name
= input
->name
;
494 file
->offset
= input
->offset
;
495 file
->filesize
= input
->filesize
;
496 file
->handle
= (void *) handle
;
501 /* Get view of the input file. */
502 static enum ld_plugin_status
503 get_view (const void *handle
, const void **viewp
)
505 plugin_input_file_t
*input
= (plugin_input_file_t
*) handle
;
507 size_t size
= input
->filesize
;
508 off_t offset
= input
->offset
;
509 #if HAVE_MMAP && HAVE_GETPAGESIZE
513 ASSERT (called_plugin
);
515 /* FIXME: einfo should support %lld. */
516 if ((off_t
) size
!= input
->filesize
)
517 einfo (_("%P%F: unsupported input file size: %s (%ld bytes)\n"),
518 input
->name
, (long) input
->filesize
);
520 /* Check the cached view buffer. */
521 if (input
->view_buffer
.addr
!= NULL
522 && input
->view_buffer
.filesize
== size
523 && input
->view_buffer
.offset
== offset
)
525 *viewp
= input
->view_buffer
.addr
;
529 input
->view_buffer
.filesize
= size
;
530 input
->view_buffer
.offset
= offset
;
533 # if HAVE_GETPAGESIZE
534 bias
= offset
% plugin_pagesize
;
538 buffer
= mmap (NULL
, size
, PROT_READ
, MAP_PRIVATE
, input
->fd
, offset
);
539 if (buffer
!= MAP_FAILED
)
541 input
->use_mmap
= TRUE
;
542 # if HAVE_GETPAGESIZE
551 input
->use_mmap
= FALSE
;
553 if (lseek (input
->fd
, offset
, SEEK_SET
) < 0)
556 buffer
= bfd_alloc (input
->abfd
, size
);
563 ssize_t got
= read (input
->fd
, p
, size
);
571 else if (errno
!= EINTR
)
577 input
->view_buffer
.addr
= buffer
;
583 /* Release the input file. */
584 static enum ld_plugin_status
585 release_input_file (const void *handle
)
587 plugin_input_file_t
*input
= (plugin_input_file_t
*) handle
;
588 ASSERT (called_plugin
);
597 /* Return TRUE if a defined symbol might be reachable from outside the
598 universe of claimed objects. */
599 static inline bfd_boolean
600 is_visible_from_outside (struct ld_plugin_symbol
*lsym
,
601 struct bfd_link_hash_entry
*blhe
)
603 struct bfd_sym_chain
*sym
;
605 if (link_info
.relocatable
)
607 if (link_info
.export_dynamic
|| !link_info
.executable
)
609 /* Check if symbol is hidden by version script. */
610 if (bfd_hide_sym_by_version (link_info
.version_info
,
613 /* Only ELF symbols really have visibility. */
614 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
616 struct elf_link_hash_entry
*el
= (struct elf_link_hash_entry
*)blhe
;
617 int vis
= ELF_ST_VISIBILITY (el
->other
);
618 return vis
== STV_DEFAULT
|| vis
== STV_PROTECTED
;
620 /* On non-ELF targets, we can safely make inferences by considering
621 what visibility the plugin would have liked to apply when it first
622 sent us the symbol. During ELF symbol processing, visibility only
623 ever becomes more restrictive, not less, when symbols are merged,
624 so this is a conservative estimate; it may give false positives,
625 declaring something visible from outside when it in fact would
626 not have been, but this will only lead to missed optimisation
627 opportunities during LTRANS at worst; it will not give false
628 negatives, which can lead to the disastrous conclusion that the
629 related symbol is IRONLY. (See GCC PR46319 for an example.) */
630 return (lsym
->visibility
== LDPV_DEFAULT
631 || lsym
->visibility
== LDPV_PROTECTED
);
634 for (sym
= &entry_symbol
; sym
!= NULL
; sym
= sym
->next
)
636 && strcmp (sym
->name
, blhe
->root
.string
) == 0)
642 /* Get the symbol resolution info for a plugin-claimed input file. */
643 static enum ld_plugin_status
644 get_symbols (const void *handle
, int nsyms
, struct ld_plugin_symbol
*syms
,
647 const plugin_input_file_t
*input
= handle
;
648 const bfd
*abfd
= (const bfd
*) input
->abfd
;
651 ASSERT (called_plugin
);
652 for (n
= 0; n
< nsyms
; n
++)
654 struct bfd_link_hash_entry
*blhe
;
658 if (syms
[n
].def
!= LDPK_UNDEF
)
659 blhe
= bfd_link_hash_lookup (link_info
.hash
, syms
[n
].name
,
662 blhe
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
, &link_info
,
663 syms
[n
].name
, FALSE
, FALSE
, TRUE
);
670 /* Determine resolution from blhe type and symbol's original type. */
671 if (blhe
->type
== bfd_link_hash_undefined
672 || blhe
->type
== bfd_link_hash_undefweak
)
677 if (blhe
->type
!= bfd_link_hash_defined
678 && blhe
->type
!= bfd_link_hash_defweak
679 && blhe
->type
!= bfd_link_hash_common
)
681 /* We should not have a new, indirect or warning symbol here. */
682 einfo ("%P%F: %s: plugin symbol table corrupt (sym type %d)\n",
683 called_plugin
->name
, blhe
->type
);
686 /* Find out which section owns the symbol. Since it's not undef,
687 it must have an owner; if it's not a common symbol, both defs
688 and weakdefs keep it in the same place. */
689 owner_sec
= (blhe
->type
== bfd_link_hash_common
690 ? blhe
->u
.c
.p
->section
691 : blhe
->u
.def
.section
);
694 /* If it was originally undefined or common, then it has been
695 resolved; determine how. */
696 if (syms
[n
].def
== LDPK_UNDEF
697 || syms
[n
].def
== LDPK_WEAKUNDEF
698 || syms
[n
].def
== LDPK_COMMON
)
700 if (owner_sec
->owner
== link_info
.output_bfd
)
701 res
= LDPR_RESOLVED_EXEC
;
702 else if (owner_sec
->owner
== abfd
)
703 res
= LDPR_PREVAILING_DEF_IRONLY
;
704 else if (is_ir_dummy_bfd (owner_sec
->owner
))
705 res
= LDPR_RESOLVED_IR
;
706 else if (owner_sec
->owner
!= NULL
707 && (owner_sec
->owner
->flags
& DYNAMIC
) != 0)
708 res
= LDPR_RESOLVED_DYN
;
710 res
= LDPR_RESOLVED_EXEC
;
713 /* Was originally def, or weakdef. Does it prevail? If the
714 owner is the original dummy bfd that supplied it, then this
715 is the definition that has prevailed. */
716 else if (owner_sec
->owner
== link_info
.output_bfd
)
717 res
= LDPR_PREEMPTED_REG
;
718 else if (owner_sec
->owner
== abfd
)
719 res
= LDPR_PREVAILING_DEF_IRONLY
;
721 /* Was originally def, weakdef, or common, but has been pre-empted. */
722 else if (is_ir_dummy_bfd (owner_sec
->owner
))
723 res
= LDPR_PREEMPTED_IR
;
725 res
= LDPR_PREEMPTED_REG
;
727 if (res
== LDPR_PREVAILING_DEF_IRONLY
)
729 /* We need to know if the sym is referenced from non-IR files. Or
730 even potentially-referenced, perhaps in a future final link if
731 this is a partial one, perhaps dynamically at load-time if the
732 symbol is externally visible. */
733 if (blhe
->non_ir_ref
)
734 res
= LDPR_PREVAILING_DEF
;
735 else if (is_visible_from_outside (&syms
[n
], blhe
))
736 res
= def_ironly_exp
;
740 syms
[n
].resolution
= res
;
741 if (report_plugin_symbols
)
742 einfo (_("%P: %B: symbol `%s' "
743 "definition: %d, visibility: %d, resolution: %d\n"),
745 syms
[n
].def
, syms
[n
].visibility
, res
);
750 static enum ld_plugin_status
751 get_symbols_v1 (const void *handle
, int nsyms
, struct ld_plugin_symbol
*syms
)
753 return get_symbols (handle
, nsyms
, syms
, LDPR_PREVAILING_DEF
);
756 static enum ld_plugin_status
757 get_symbols_v2 (const void *handle
, int nsyms
, struct ld_plugin_symbol
*syms
)
759 return get_symbols (handle
, nsyms
, syms
, LDPR_PREVAILING_DEF_IRONLY_EXP
);
762 /* Add a new (real) input file generated by a plugin. */
763 static enum ld_plugin_status
764 add_input_file (const char *pathname
)
766 ASSERT (called_plugin
);
767 if (!lang_add_input_file (xstrdup (pathname
), lang_input_file_is_file_enum
,
773 /* Add a new (real) library required by a plugin. */
774 static enum ld_plugin_status
775 add_input_library (const char *pathname
)
777 ASSERT (called_plugin
);
778 if (!lang_add_input_file (xstrdup (pathname
), lang_input_file_is_l_enum
,
784 /* Set the extra library path to be used by libraries added via
785 add_input_library. */
786 static enum ld_plugin_status
787 set_extra_library_path (const char *path
)
789 ASSERT (called_plugin
);
790 ldfile_add_library_path (xstrdup (path
), FALSE
);
794 /* Issue a diagnostic message from a plugin. */
795 static enum ld_plugin_status
796 message (int level
, const char *format
, ...)
799 va_start (args
, format
);
804 vfinfo (stdout
, format
, args
, FALSE
);
808 vfinfo (stdout
, format
, args
, TRUE
);
815 char *newfmt
= ACONCAT ((level
== LDPL_FATAL
? "%P%F: " : "%P%X: ",
816 format
, "\n", (const char *) NULL
));
818 vfinfo (stderr
, newfmt
, args
, TRUE
);
828 /* Helper to size leading part of tv array and set it up. */
830 set_tv_header (struct ld_plugin_tv
*tv
)
835 static const unsigned int major
= (unsigned)(BFD_VERSION
/ 100000000UL);
836 static const unsigned int minor
= (unsigned)(BFD_VERSION
/ 1000000UL) % 100;
838 for (i
= 0; i
< tv_header_size
; i
++)
840 tv
[i
].tv_tag
= tv_header_tags
[i
];
841 #define TVU(x) tv[i].tv_u.tv_ ## x
842 switch (tv
[i
].tv_tag
)
845 TVU(message
) = message
;
847 case LDPT_API_VERSION
:
848 TVU(val
) = LD_PLUGIN_API_VERSION
;
850 case LDPT_GNU_LD_VERSION
:
851 TVU(val
) = major
* 100 + minor
;
853 case LDPT_LINKER_OUTPUT
:
854 TVU(val
) = (link_info
.relocatable
856 : (link_info
.executable
857 ? (link_info
.pie
? LDPO_PIE
: LDPO_EXEC
)
860 case LDPT_OUTPUT_NAME
:
861 TVU(string
) = output_filename
;
863 case LDPT_REGISTER_CLAIM_FILE_HOOK
:
864 TVU(register_claim_file
) = register_claim_file
;
866 case LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK
:
867 TVU(register_all_symbols_read
) = register_all_symbols_read
;
869 case LDPT_REGISTER_CLEANUP_HOOK
:
870 TVU(register_cleanup
) = register_cleanup
;
872 case LDPT_ADD_SYMBOLS
:
873 TVU(add_symbols
) = add_symbols
;
875 case LDPT_GET_INPUT_FILE
:
876 TVU(get_input_file
) = get_input_file
;
879 TVU(get_view
) = get_view
;
881 case LDPT_RELEASE_INPUT_FILE
:
882 TVU(release_input_file
) = release_input_file
;
884 case LDPT_GET_SYMBOLS
:
885 TVU(get_symbols
) = get_symbols_v1
;
887 case LDPT_GET_SYMBOLS_V2
:
888 TVU(get_symbols
) = get_symbols_v2
;
890 case LDPT_ADD_INPUT_FILE
:
891 TVU(add_input_file
) = add_input_file
;
893 case LDPT_ADD_INPUT_LIBRARY
:
894 TVU(add_input_library
) = add_input_library
;
896 case LDPT_SET_EXTRA_LIBRARY_PATH
:
897 TVU(set_extra_library_path
) = set_extra_library_path
;
900 /* Added a new entry to the array without adding
901 a new case to set up its value is a bug. */
908 /* Append the per-plugin args list and trailing LDPT_NULL to tv. */
910 set_tv_plugin_args (plugin_t
*plugin
, struct ld_plugin_tv
*tv
)
912 plugin_arg_t
*arg
= plugin
->args
;
915 tv
->tv_tag
= LDPT_OPTION
;
916 tv
->tv_u
.tv_string
= arg
->arg
;
920 tv
->tv_tag
= LDPT_NULL
;
924 /* Load up and initialise all plugins after argument parsing. */
926 plugin_load_plugins (void)
928 struct ld_plugin_tv
*my_tv
;
929 unsigned int max_args
= 0;
930 plugin_t
*curplug
= plugins_list
;
932 /* If there are no plugins, we need do nothing this run. */
936 /* First pass over plugins to find max # args needed so that we
937 can size and allocate the tv array. */
940 if (curplug
->n_args
> max_args
)
941 max_args
= curplug
->n_args
;
942 curplug
= curplug
->next
;
945 /* Allocate tv array and initialise constant part. */
946 my_tv
= xmalloc ((max_args
+ 1 + tv_header_size
) * sizeof *my_tv
);
947 set_tv_header (my_tv
);
949 /* Pass over plugins again, activating them. */
950 curplug
= plugins_list
;
953 enum ld_plugin_status rv
;
954 ld_plugin_onload onloadfn
;
956 onloadfn
= (ld_plugin_onload
) dlsym (curplug
->dlhandle
, "onload");
958 onloadfn
= (ld_plugin_onload
) dlsym (curplug
->dlhandle
, "_onload");
960 einfo (_("%P%F: %s: error loading plugin: %s\n"),
961 curplug
->name
, dlerror ());
962 set_tv_plugin_args (curplug
, &my_tv
[tv_header_size
]);
963 called_plugin
= curplug
;
964 rv
= (*onloadfn
) (my_tv
);
965 called_plugin
= NULL
;
967 einfo (_("%P%F: %s: plugin error: %d\n"), curplug
->name
, rv
);
968 curplug
= curplug
->next
;
971 /* Since plugin(s) inited ok, assume they're going to want symbol
972 resolutions, which needs us to track which symbols are referenced
973 by non-IR files using the linker's notice callback. */
974 orig_notice_all
= link_info
.notice_all
;
975 orig_callbacks
= link_info
.callbacks
;
976 plugin_callbacks
= *orig_callbacks
;
977 plugin_callbacks
.notice
= &plugin_notice
;
978 link_info
.notice_all
= TRUE
;
979 link_info
.lto_plugin_active
= TRUE
;
980 link_info
.callbacks
= &plugin_callbacks
;
982 #if HAVE_MMAP && HAVE_GETPAGESIZE
983 plugin_pagesize
= getpagesize ();;
987 /* Call 'claim file' hook for all plugins. */
989 plugin_call_claim_file (const struct ld_plugin_input_file
*file
, int *claimed
)
991 plugin_t
*curplug
= plugins_list
;
993 if (no_more_claiming
)
995 while (curplug
&& !*claimed
)
997 if (curplug
->claim_file_handler
)
999 enum ld_plugin_status rv
;
1000 called_plugin
= curplug
;
1001 rv
= (*curplug
->claim_file_handler
) (file
, claimed
);
1002 called_plugin
= NULL
;
1004 set_plugin_error (curplug
->name
);
1006 curplug
= curplug
->next
;
1008 return plugin_error_p () ? -1 : 0;
1011 /* Duplicates a character string with memory attached to ABFD. */
1014 plugin_strdup (bfd
*abfd
, const char *str
)
1018 strlength
= strlen (str
) + 1;
1019 copy
= bfd_alloc (abfd
, strlength
);
1021 einfo (_("%P%F: plugin_strdup failed to allocate memory: %s\n"),
1023 memcpy (copy
, str
, strlength
);
1028 plugin_maybe_claim (lang_input_statement_type
*entry
)
1031 plugin_input_file_t
*input
;
1032 off_t offset
, filesize
;
1033 struct ld_plugin_input_file file
;
1035 bfd
*ibfd
= entry
->the_bfd
;
1036 bfd_boolean inarchive
= bfd_my_archive (ibfd
) != NULL
;
1038 = inarchive
? bfd_my_archive (ibfd
)->filename
: ibfd
->filename
;
1039 int fd
= open (name
, O_RDONLY
| O_BINARY
);
1044 /* We create a dummy BFD, initially empty, to house whatever symbols
1045 the plugin may want to add. */
1046 abfd
= plugin_get_ir_dummy_bfd (ibfd
->filename
, ibfd
);
1048 input
= bfd_alloc (abfd
, sizeof (*input
));
1050 einfo (_("%P%F: plugin failed to allocate memory for input: %s\n"),
1055 /* Offset and filesize must refer to the individual archive
1056 member, not the whole file, and must exclude the header.
1057 Fortunately for us, that is how the data is stored in the
1058 origin field of the bfd and in the arelt_data. */
1059 offset
= ibfd
->origin
;
1060 filesize
= arelt_size (ibfd
);
1065 filesize
= lseek (fd
, 0, SEEK_END
);
1067 /* We must copy filename attached to ibfd if it is not an archive
1068 member since it may be freed by bfd_close below. */
1069 name
= plugin_strdup (abfd
, name
);
1073 file
.offset
= offset
;
1074 file
.filesize
= filesize
;
1076 file
.handle
= input
;
1079 input
->view_buffer
.addr
= NULL
;
1080 input
->view_buffer
.filesize
= 0;
1081 input
->view_buffer
.offset
= 0;
1083 input
->offset
= offset
;
1084 input
->filesize
= filesize
;
1085 input
->name
= plugin_strdup (abfd
, ibfd
->filename
);
1087 if (plugin_call_claim_file (&file
, &claimed
))
1088 einfo (_("%P%F: %s: plugin reported error claiming file\n"),
1089 plugin_error_plugin ());
1091 if (input
->fd
!= -1 && ibfd
->format
== bfd_object
)
1093 /* FIXME: fd belongs to us, not the plugin. IR for GCC plugin,
1094 which doesn't need fd after plugin_call_claim_file, is
1095 stored in bfd_object file. Since GCC plugin before GCC 5
1096 doesn't call release_input_file, we close it here. IR for
1097 LLVM plugin, which needs fd after plugin_call_claim_file and
1098 calls release_input_file after it is done, is stored in
1099 non-bfd_object file. This scheme doesn't work when a plugin
1100 needs fd and its IR is stored in bfd_object file. */
1107 /* Discard the real file's BFD and substitute the dummy one. */
1109 /* BFD archive handling caches elements so we can't call
1110 bfd_close for archives. */
1113 bfd_make_readable (abfd
);
1114 entry
->the_bfd
= abfd
;
1115 entry
->flags
.claimed
= TRUE
;
1120 if (input
->use_mmap
)
1122 /* If plugin didn't claim the file, unmap the buffer. */
1123 char *addr
= input
->view_buffer
.addr
;
1124 off_t size
= input
->view_buffer
.filesize
;
1125 # if HAVE_GETPAGESIZE
1126 off_t bias
= input
->view_buffer
.offset
% plugin_pagesize
;
1130 munmap (addr
, size
);
1134 /* If plugin didn't claim the file, we don't need the dummy bfd.
1135 Can't avoid speculatively creating it, alas. */
1136 bfd_close_all_done (abfd
);
1137 entry
->flags
.claimed
= FALSE
;
1141 /* Call 'all symbols read' hook for all plugins. */
1143 plugin_call_all_symbols_read (void)
1145 plugin_t
*curplug
= plugins_list
;
1147 /* Disable any further file-claiming. */
1148 no_more_claiming
= TRUE
;
1152 if (curplug
->all_symbols_read_handler
)
1154 enum ld_plugin_status rv
;
1155 called_plugin
= curplug
;
1156 rv
= (*curplug
->all_symbols_read_handler
) ();
1157 called_plugin
= NULL
;
1159 set_plugin_error (curplug
->name
);
1161 curplug
= curplug
->next
;
1163 return plugin_error_p () ? -1 : 0;
1166 /* Call 'cleanup' hook for all plugins at exit. */
1168 plugin_call_cleanup (void)
1170 plugin_t
*curplug
= plugins_list
;
1173 if (curplug
->cleanup_handler
&& !curplug
->cleanup_done
)
1175 enum ld_plugin_status rv
;
1176 curplug
->cleanup_done
= TRUE
;
1177 called_plugin
= curplug
;
1178 rv
= (*curplug
->cleanup_handler
) ();
1179 called_plugin
= NULL
;
1181 info_msg (_("%P: %s: error in plugin cleanup: %d (ignored)\n"),
1183 dlclose (curplug
->dlhandle
);
1185 curplug
= curplug
->next
;
1189 /* To determine which symbols should be resolved LDPR_PREVAILING_DEF
1190 and which LDPR_PREVAILING_DEF_IRONLY, we notice all the symbols as
1191 the linker adds them to the linker hash table. Mark those
1192 referenced from a non-IR file with non_ir_ref. We have to
1193 notice_all symbols, because we won't necessarily know until later
1194 which ones will be contributed by IR files. */
1196 plugin_notice (struct bfd_link_info
*info
,
1197 struct bfd_link_hash_entry
*h
,
1198 struct bfd_link_hash_entry
*inh
,
1204 struct bfd_link_hash_entry
*orig_h
= h
;
1210 if (h
->type
== bfd_link_hash_warning
)
1213 /* Nothing to do here if this def/ref is from an IR dummy BFD. */
1214 if (is_ir_dummy_bfd (abfd
))
1217 /* Making an indirect symbol counts as a reference unless this
1218 is a brand new symbol. */
1219 else if (bfd_is_ind_section (section
)
1220 || (flags
& BSF_INDIRECT
) != 0)
1222 /* ??? Some of this is questionable. See comments in
1223 _bfd_generic_link_add_one_symbol for case IND. */
1224 if (h
->type
!= bfd_link_hash_new
)
1226 h
->non_ir_ref
= TRUE
;
1227 inh
->non_ir_ref
= TRUE
;
1229 else if (inh
->type
== bfd_link_hash_new
)
1230 inh
->non_ir_ref
= TRUE
;
1233 /* Nothing to do here for warning symbols. */
1234 else if ((flags
& BSF_WARNING
) != 0)
1237 /* Nothing to do here for constructor symbols. */
1238 else if ((flags
& BSF_CONSTRUCTOR
) != 0)
1241 /* If this is a ref, set non_ir_ref. */
1242 else if (bfd_is_und_section (section
))
1244 /* Replace the undefined dummy bfd with the real one. */
1245 if ((h
->type
== bfd_link_hash_undefined
1246 || h
->type
== bfd_link_hash_undefweak
)
1247 && (h
->u
.undef
.abfd
== NULL
1248 || (h
->u
.undef
.abfd
->flags
& BFD_PLUGIN
) != 0))
1249 h
->u
.undef
.abfd
= abfd
;
1250 h
->non_ir_ref
= TRUE
;
1253 /* Otherwise, it must be a new def. Ensure any symbol defined
1254 in an IR dummy BFD takes on a new value from a real BFD.
1255 Weak symbols are not normally overridden by a new weak
1256 definition, and strong symbols will normally cause multiple
1257 definition errors. Avoid this by making the symbol appear
1259 else if (((h
->type
== bfd_link_hash_defweak
1260 || h
->type
== bfd_link_hash_defined
)
1261 && is_ir_dummy_bfd (sym_bfd
= h
->u
.def
.section
->owner
))
1262 || (h
->type
== bfd_link_hash_common
1263 && is_ir_dummy_bfd (sym_bfd
= h
->u
.c
.p
->section
->owner
)))
1265 h
->type
= bfd_link_hash_undefweak
;
1266 h
->u
.undef
.abfd
= sym_bfd
;
1270 /* Continue with cref/nocrossref/trace-sym processing. */
1273 || (info
->notice_hash
!= NULL
1274 && bfd_hash_lookup (info
->notice_hash
, orig_h
->root
.string
,
1275 FALSE
, FALSE
) != NULL
))
1276 return (*orig_callbacks
->notice
) (info
, orig_h
, inh
,
1277 abfd
, section
, value
, flags
);