/* Plugin control for the GNU linker.
- Copyright 2010, 2011 Free Software Foundation, Inc.
+ Copyright 2010, 2011, 2012, 2013 Free Software Foundation, Inc.
This file is part of the GNU Binutils.
#include "plugin.h"
#include "plugin-api.h"
#include "elf-bfd.h"
-#include "libbfd.h"
#if !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H)
#include <windows.h>
#endif
LDPT_GET_INPUT_FILE,
LDPT_RELEASE_INPUT_FILE,
LDPT_GET_SYMBOLS,
+ LDPT_GET_SYMBOLS_V2,
LDPT_ADD_INPUT_FILE,
LDPT_ADD_INPUT_LIBRARY,
LDPT_SET_EXTRA_LIBRARY_PATH
#endif /* !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H) */
+#ifndef HAVE_DLFCN_H
+static const char *
+dlerror (void)
+{
+ return "";
+}
+#endif
+
/* Helper function for exiting with error status. */
static int
set_plugin_error (const char *plugin)
}
/* Handle -plugin arg: find and load plugin, or return error. */
-int
+void
plugin_opt_plugin (const char *plugin)
{
plugin_t *newplug;
newplug->name = plugin;
newplug->dlhandle = dlopen (plugin, RTLD_NOW);
if (!newplug->dlhandle)
- return set_plugin_error (plugin);
+ einfo (_("%P%F: %s: error loading plugin: %s\n"), plugin, dlerror ());
/* Chain on end, so when we run list it is in command-line order. */
*plugins_tail_chain_ptr = newplug;
/* Record it as current plugin for receiving args. */
last_plugin = newplug;
last_plugin_args_tail_chain_ptr = &newplug->args;
- return 0;
}
/* Accumulate option arguments for last-loaded plugin, or return
{
flagword flags;
- /* Create sections to own the symbols. */
+ /* Create section to own the symbols. */
flags = (SEC_CODE | SEC_HAS_CONTENTS | SEC_READONLY
| SEC_ALLOC | SEC_LOAD | SEC_KEEP | SEC_EXCLUDE);
if (bfd_make_section_anyway_with_flags (abfd, ".text", flags))
when processing DT_NEEDED dependencies. */
return (abfd
&& abfd->usrdata
- && ((lang_input_statement_type *)(abfd->usrdata))->claimed);
+ && ((lang_input_statement_type *)(abfd->usrdata))->flags.claimed);
}
/* Helpers to convert between BFD and GOLD symbol formats. */
/* FALLTHRU */
case LDPK_DEF:
flags |= BSF_GLOBAL;
- section = bfd_get_section_by_name (abfd, ".text");
+ if (ldsym->comdat_key)
+ {
+ char *name = concat (".gnu.linkonce.t.", ldsym->comdat_key,
+ (const char *) NULL);
+ section = bfd_get_section_by_name (abfd, name);
+ if (section != NULL)
+ free (name);
+ else
+ {
+ flagword sflags;
+
+ sflags = (SEC_CODE | SEC_HAS_CONTENTS | SEC_READONLY
+ | SEC_ALLOC | SEC_LOAD | SEC_KEEP | SEC_EXCLUDE
+ | SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD);
+ section = bfd_make_section_anyway_with_flags (abfd, name, sflags);
+ if (section == NULL)
+ return LDPS_ERR;
+ }
+ }
+ else
+ section = bfd_get_section_by_name (abfd, ".text");
break;
case LDPK_WEAKUNDEF:
asymbol **symptrs;
bfd *abfd = handle;
int n;
+
ASSERT (called_plugin);
symptrs = xmalloc (nsyms * sizeof *symptrs);
for (n = 0; n < nsyms; n++)
enum ld_plugin_status rv;
asymbol *bfdsym;
- if (syms[n].comdat_key)
- {
- struct already_linked linked;
- linked.comdat_key = xstrdup (syms[n].comdat_key);
- linked.u.abfd = abfd;
- bfd_section_already_linked (abfd, &linked, &link_info);
- }
bfdsym = bfd_make_empty_symbol (abfd);
symptrs[n] = bfdsym;
rv = asymbol_from_plugin_symbol (abfd, bfdsym, syms + n);
/* Get the input file information with an open (possibly re-opened)
file descriptor. */
static enum ld_plugin_status
-get_input_file (const void *handle, struct ld_plugin_input_file *file)
+get_input_file (const void *handle ATTRIBUTE_UNUSED,
+ struct ld_plugin_input_file *file ATTRIBUTE_UNUSED)
{
ASSERT (called_plugin);
- handle = handle;
- file = file;
return LDPS_ERR;
}
/* Release the input file. */
static enum ld_plugin_status
-release_input_file (const void *handle)
+release_input_file (const void *handle ATTRIBUTE_UNUSED)
{
ASSERT (called_plugin);
- handle = handle;
return LDPS_ERR;
}
/* Return TRUE if a defined symbol might be reachable from outside the
universe of claimed objects. */
static inline bfd_boolean
-is_visible_from_outside (struct ld_plugin_symbol *lsym, asection *section,
+is_visible_from_outside (struct ld_plugin_symbol *lsym,
struct bfd_link_hash_entry *blhe)
{
struct bfd_sym_chain *sym;
- /* Section's owner may be NULL if it is the absolute
- section, fortunately is_ir_dummy_bfd handles that. */
- if (!is_ir_dummy_bfd (section->owner))
- return TRUE;
if (link_info.relocatable)
return TRUE;
- if (link_info.export_dynamic || link_info.shared)
+ if (link_info.export_dynamic || !link_info.executable)
{
+ /* Check if symbol is hidden by version script. */
+ if (bfd_hide_sym_by_version (link_info.version_info,
+ blhe->root.string))
+ return FALSE;
/* Only ELF symbols really have visibility. */
if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour)
{
/* Get the symbol resolution info for a plugin-claimed input file. */
static enum ld_plugin_status
-get_symbols (const void *handle, int nsyms, struct ld_plugin_symbol *syms)
+get_symbols (const void *handle, int nsyms, struct ld_plugin_symbol *syms,
+ int def_ironly_exp)
{
const bfd *abfd = handle;
int n;
+
ASSERT (called_plugin);
for (n = 0; n < nsyms; n++)
{
struct bfd_link_hash_entry *blhe;
- bfd_boolean ironly;
asection *owner_sec;
+ int res;
+
if (syms[n].def != LDPK_UNDEF)
blhe = bfd_link_hash_lookup (link_info.hash, syms[n].name,
FALSE, FALSE, TRUE);
syms[n].name, FALSE, FALSE, TRUE);
if (!blhe)
{
- syms[n].resolution = LDPR_UNKNOWN;
+ res = LDPR_UNKNOWN;
goto report_symbol;
}
if (blhe->type == bfd_link_hash_undefined
|| blhe->type == bfd_link_hash_undefweak)
{
- syms[n].resolution = LDPR_UNDEF;
+ res = LDPR_UNDEF;
goto report_symbol;
}
if (blhe->type != bfd_link_hash_defined
? blhe->u.c.p->section
: blhe->u.def.section);
- /* We need to know if the sym is referenced from non-IR files. Or
- even potentially-referenced, perhaps in a future final link if
- this is a partial one, perhaps dynamically at load-time if the
- symbol is externally visible. */
- ironly = !(blhe->non_ir_ref
- || is_visible_from_outside (&syms[n], owner_sec, blhe));
/* If it was originally undefined or common, then it has been
resolved; determine how. */
|| syms[n].def == LDPK_COMMON)
{
if (owner_sec->owner == link_info.output_bfd)
- syms[n].resolution = LDPR_RESOLVED_EXEC;
+ res = LDPR_RESOLVED_EXEC;
else if (owner_sec->owner == abfd)
- syms[n].resolution = (ironly
- ? LDPR_PREVAILING_DEF_IRONLY
- : LDPR_PREVAILING_DEF);
+ res = LDPR_PREVAILING_DEF_IRONLY;
else if (is_ir_dummy_bfd (owner_sec->owner))
- syms[n].resolution = LDPR_RESOLVED_IR;
+ res = LDPR_RESOLVED_IR;
else if (owner_sec->owner != NULL
&& (owner_sec->owner->flags & DYNAMIC) != 0)
- syms[n].resolution = LDPR_RESOLVED_DYN;
+ res = LDPR_RESOLVED_DYN;
else
- syms[n].resolution = LDPR_RESOLVED_EXEC;
- goto report_symbol;
+ res = LDPR_RESOLVED_EXEC;
}
/* Was originally def, or weakdef. Does it prevail? If the
owner is the original dummy bfd that supplied it, then this
is the definition that has prevailed. */
- if (owner_sec->owner == link_info.output_bfd)
- syms[n].resolution = LDPR_PREEMPTED_REG;
+ else if (owner_sec->owner == link_info.output_bfd)
+ res = LDPR_PREEMPTED_REG;
else if (owner_sec->owner == abfd)
- {
- syms[n].resolution = (ironly
- ? LDPR_PREVAILING_DEF_IRONLY
- : LDPR_PREVAILING_DEF);
- goto report_symbol;
- }
+ res = LDPR_PREVAILING_DEF_IRONLY;
/* Was originally def, weakdef, or common, but has been pre-empted. */
- syms[n].resolution = (is_ir_dummy_bfd (owner_sec->owner)
- ? LDPR_PREEMPTED_IR
- : LDPR_PREEMPTED_REG);
+ else if (is_ir_dummy_bfd (owner_sec->owner))
+ res = LDPR_PREEMPTED_IR;
+ else
+ res = LDPR_PREEMPTED_REG;
+
+ if (res == LDPR_PREVAILING_DEF_IRONLY)
+ {
+ /* We need to know if the sym is referenced from non-IR files. Or
+ even potentially-referenced, perhaps in a future final link if
+ this is a partial one, perhaps dynamically at load-time if the
+ symbol is externally visible. */
+ if (blhe->non_ir_ref)
+ res = LDPR_PREVAILING_DEF;
+ else if (is_visible_from_outside (&syms[n], blhe))
+ res = def_ironly_exp;
+ }
report_symbol:
+ syms[n].resolution = res;
if (report_plugin_symbols)
einfo (_("%P: %B: symbol `%s' "
"definition: %d, visibility: %d, resolution: %d\n"),
abfd, syms[n].name,
- syms[n].def, syms[n].visibility, syms[n].resolution);
+ syms[n].def, syms[n].visibility, res);
}
return LDPS_OK;
}
+static enum ld_plugin_status
+get_symbols_v1 (const void *handle, int nsyms, struct ld_plugin_symbol *syms)
+{
+ return get_symbols (handle, nsyms, syms, LDPR_PREVAILING_DEF);
+}
+
+static enum ld_plugin_status
+get_symbols_v2 (const void *handle, int nsyms, struct ld_plugin_symbol *syms)
+{
+ return get_symbols (handle, nsyms, syms, LDPR_PREVAILING_DEF_IRONLY_EXP);
+}
+
/* Add a new (real) input file generated by a plugin. */
static enum ld_plugin_status
add_input_file (const char *pathname)
}
/* Helper to size leading part of tv array and set it up. */
-static size_t
+static void
set_tv_header (struct ld_plugin_tv *tv)
{
size_t i;
static const unsigned int major = (unsigned)(BFD_VERSION / 100000000UL);
static const unsigned int minor = (unsigned)(BFD_VERSION / 1000000UL) % 100;
- if (!tv)
- return tv_header_size;
-
for (i = 0; i < tv_header_size; i++)
{
tv[i].tv_tag = tv_header_tags[i];
case LDPT_LINKER_OUTPUT:
TVU(val) = (link_info.relocatable
? LDPO_REL
- : (link_info.shared ? LDPO_DYN : LDPO_EXEC));
+ : (link_info.executable
+ ? (link_info.pie ? LDPO_PIE : LDPO_EXEC)
+ : LDPO_DYN));
break;
case LDPT_OUTPUT_NAME:
TVU(string) = output_filename;
TVU(release_input_file) = release_input_file;
break;
case LDPT_GET_SYMBOLS:
- TVU(get_symbols) = get_symbols;
+ TVU(get_symbols) = get_symbols_v1;
+ break;
+ case LDPT_GET_SYMBOLS_V2:
+ TVU(get_symbols) = get_symbols_v2;
break;
case LDPT_ADD_INPUT_FILE:
TVU(add_input_file) = add_input_file;
}
#undef TVU
}
- return tv_header_size;
}
/* Append the per-plugin args list and trailing LDPT_NULL to tv. */
}
/* Load up and initialise all plugins after argument parsing. */
-int
+void
plugin_load_plugins (void)
{
struct ld_plugin_tv *my_tv;
/* If there are no plugins, we need do nothing this run. */
if (!curplug)
- return 0;
+ return;
/* First pass over plugins to find max # args needed so that we
can size and allocate the tv array. */
while (curplug)
{
enum ld_plugin_status rv;
- ld_plugin_onload onloadfn = dlsym (curplug->dlhandle, "onload");
+ ld_plugin_onload onloadfn;
+
+ onloadfn = (ld_plugin_onload) dlsym (curplug->dlhandle, "onload");
if (!onloadfn)
- onloadfn = dlsym (curplug->dlhandle, "_onload");
+ onloadfn = (ld_plugin_onload) dlsym (curplug->dlhandle, "_onload");
if (!onloadfn)
- return set_plugin_error (curplug->name);
+ einfo (_("%P%F: %s: error loading plugin: %s\n"),
+ curplug->name, dlerror ());
set_tv_plugin_args (curplug, &my_tv[tv_header_size]);
called_plugin = curplug;
rv = (*onloadfn) (my_tv);
called_plugin = NULL;
if (rv != LDPS_OK)
- return set_plugin_error (curplug->name);
+ einfo (_("%P%F: %s: plugin error: %d\n"), curplug->name, rv);
curplug = curplug->next;
}
plugin_callbacks.notice = &plugin_notice;
link_info.notice_all = TRUE;
link_info.callbacks = &plugin_callbacks;
-
- return 0;
}
/* Call 'claim file' hook for all plugins. */
if (entry->the_bfd->my_archive == NULL)
bfd_close (entry->the_bfd);
entry->the_bfd = file->handle;
- entry->claimed = TRUE;
+ entry->flags.claimed = TRUE;
bfd_make_readable (entry->the_bfd);
}
else
/* If plugin didn't claim the file, we don't need the dummy bfd.
Can't avoid speculatively creating it, alas. */
bfd_close_all_done (file->handle);
- entry->claimed = FALSE;
+ entry->flags.claimed = FALSE;
}
}
rv = (*curplug->cleanup_handler) ();
called_plugin = NULL;
if (rv != LDPS_OK)
- set_plugin_error (curplug->name);
+ info_msg (_("%P: %s: error in plugin cleanup: %d (ignored)\n"),
+ curplug->name, rv);
dlclose (curplug->dlhandle);
}
curplug = curplug->next;
}
- if (plugin_error_p ())
- info_msg (_("%P: %s: error in plugin cleanup (ignored)\n"),
- plugin_error_plugin ());
}
/* To determine which symbols should be resolved LDPR_PREVAILING_DEF
{
bfd *sym_bfd;
- /* No further processing if this def/ref is from an IR dummy BFD. */
+ /* Nothing to do here if this def/ref is from an IR dummy BFD. */
if (is_ir_dummy_bfd (abfd))
- return TRUE;
+ ;
/* Making an indirect symbol counts as a reference unless this
is a brand new symbol. */
- if (bfd_is_ind_section (section)
- || (flags & BSF_INDIRECT) != 0)
+ else if (bfd_is_ind_section (section)
+ || (flags & BSF_INDIRECT) != 0)
{
if (h->type != bfd_link_hash_new)
{
/* If this is a ref, set non_ir_ref. */
else if (bfd_is_und_section (section))
- h->non_ir_ref = TRUE;
+ {
+ /* Replace the undefined dummy bfd with the real one. */
+ if ((h->type == bfd_link_hash_undefined
+ || h->type == bfd_link_hash_undefweak)
+ && (h->u.undef.abfd == NULL
+ || (h->u.undef.abfd->flags & BFD_PLUGIN) != 0))
+ h->u.undef.abfd = abfd;
+ h->non_ir_ref = TRUE;
+ }
/* Otherwise, it must be a new def. Ensure any symbol defined
in an IR dummy BFD takes on a new value from a real BFD.
abfd, section, value, flags, string);
return TRUE;
}
+
+/* Return true if bfd is a dynamic library that should be reloaded. */
+
+bfd_boolean
+plugin_should_reload (bfd *abfd)
+{
+ return ((abfd->flags & DYNAMIC) != 0
+ && bfd_get_flavour (abfd) == bfd_target_elf_flavour
+ && bfd_get_format (abfd) == bfd_object
+ && (elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0);
+}