// plugin.cc -- plugin manager for gold -*- C++ -*-
-// Copyright (C) 2008-2017 Free Software Foundation, Inc.
+// Copyright (C) 2008-2020 Free Software Foundation, Inc.
// Written by Cary Coutant <ccoutant@google.com>.
// This file is part of gold.
#include "gold.h"
+#include <cerrno>
#include <cstdio>
#include <cstdarg>
#include <cstring>
#include <string>
#include <vector>
+#include <fcntl.h>
+#include <unistd.h>
+#include "libiberty.h"
#ifdef ENABLE_PLUGINS
#ifdef HAVE_DLFCN_H
#endif /* ENABLE_PLUGINS */
#include "parameters.h"
+#include "debug.h"
#include "errors.h"
#include "fileread.h"
#include "layout.h"
get_input_section_size(const struct ld_plugin_section section,
uint64_t* secsize);
+static enum ld_plugin_status
+register_new_input(ld_plugin_new_input_handler handler);
+
+static enum ld_plugin_status
+get_wrap_symbols(uint64_t *num_symbols, const char ***wrap_symbol_list);
+
};
#endif // ENABLE_PLUGINS
-static Pluginobj* make_sized_plugin_object(Input_file* input_file,
+static Pluginobj* make_sized_plugin_object(const std::string& filename,
+ Input_file* input_file,
off_t offset, off_t filesize);
// Plugin methods.
sscanf(ver, "%d.%d", &major, &minor);
// Allocate and populate a transfer vector.
- const int tv_fixed_size = 29;
+ const int tv_fixed_size = 31;
int tv_size = this->args_.size() + tv_fixed_size;
ld_plugin_tv* tv = new ld_plugin_tv[tv_size];
tv[i].tv_tag = LDPT_GET_INPUT_SECTION_SIZE;
tv[i].tv_u.tv_get_input_section_size = get_input_section_size;
+ ++i;
+ tv[i].tv_tag = LDPT_REGISTER_NEW_INPUT_HOOK;
+ tv[i].tv_u.tv_register_new_input = register_new_input;
+
+ ++i;
+ tv[i].tv_tag = LDPT_GET_WRAP_SYMBOLS;
+ tv[i].tv_u.tv_get_wrap_symbols = get_wrap_symbols;
+
++i;
tv[i].tv_tag = LDPT_NULL;
tv[i].tv_u.tv_val = 0;
(*this->all_symbols_read_handler_)();
}
+// Call the new_input handler.
+
+inline void
+Plugin::new_input(struct ld_plugin_input_file* plugin_input_file)
+{
+ if (this->new_input_handler_ != NULL)
+ (*this->new_input_handler_)(plugin_input_file);
+}
+
// Call the cleanup handler.
inline void
Task_token* next_blocker_;
};
+// Plugin_recorder logs plugin actions and saves intermediate files
+// for later replay.
+
+class Plugin_recorder
+{
+ public:
+ Plugin_recorder() : file_count_(0), tempdir_(NULL), logfile_(NULL)
+ { }
+
+ bool
+ init();
+
+ void
+ claimed_file(const std::string& obj_name, off_t offset, off_t filesize,
+ const std::string& plugin_name);
+
+ void
+ unclaimed_file(const std::string& obj_name, off_t offset, off_t filesize);
+
+ void
+ replacement_file(const char* name, bool is_lib);
+
+ void
+ record_symbols(const Object* obj, int nsyms,
+ const struct ld_plugin_symbol* syms);
+
+ void
+ finish()
+ { ::fclose(this->logfile_); }
+
+ private:
+ unsigned int file_count_;
+ const char* tempdir_;
+ FILE* logfile_;
+};
+
+bool
+Plugin_recorder::init()
+{
+ // Create a temporary directory where we can stash the log and
+ // copies of replacement files.
+ char dir_template[] = "gold-recording-XXXXXX";
+#ifdef HAVE_MKDTEMP
+ if (mkdtemp(dir_template) == NULL)
+ return false;
+#else
+ if (mktemp(dir_template) == NULL)
+ return false;
+#if defined (_WIN32) && !defined (__CYGWIN32__)
+ if (mkdir(dir_template) != 0)
+ return false;
+#else
+ if (mkdir(dir_template, 0700) != 0)
+ return false;
+#endif
+#endif
+
+ size_t len = strlen(dir_template) + 1;
+ char* tempdir = new char[len];
+ strncpy(tempdir, dir_template, len);
+
+ // Create the log file.
+ std::string logname(tempdir);
+ logname.append("/log");
+ FILE* logfile = ::fopen(logname.c_str(), "w");
+ if (logfile == NULL)
+ return false;
+
+ this->tempdir_ = tempdir;
+ this->logfile_ = logfile;
+
+ gold_info(_("%s: recording to %s"), program_name, this->tempdir_);
+
+ return true;
+}
+
+void
+Plugin_recorder::claimed_file(const std::string& obj_name,
+ off_t offset,
+ off_t filesize,
+ const std::string& plugin_name)
+{
+ fprintf(this->logfile_, "PLUGIN: %s\n", plugin_name.c_str());
+ fprintf(this->logfile_, "CLAIMED: %s", obj_name.c_str());
+ if (offset > 0)
+ fprintf(this->logfile_, " @%ld", static_cast<long>(offset));
+ fprintf(this->logfile_, " %ld\n", static_cast<long>(filesize));
+}
+
+void
+Plugin_recorder::unclaimed_file(const std::string& obj_name,
+ off_t offset,
+ off_t filesize)
+{
+ fprintf(this->logfile_, "UNCLAIMED: %s", obj_name.c_str());
+ if (offset > 0)
+ fprintf(this->logfile_, " @%ld", static_cast<long>(offset));
+ fprintf(this->logfile_, " %ld\n", static_cast<long>(filesize));
+}
+
+// Make a hard link to INNAME from OUTNAME, if possible.
+// If not, copy the file.
+
+static bool
+link_or_copy_file(const char* inname, const char* outname)
+{
+ static char buf[4096];
+
+#ifdef HAVE_LINK
+ if (::link(inname, outname) == 0)
+ return true;
+#endif
+
+ int in = ::open(inname, O_RDONLY);
+ if (in < 0)
+ {
+ gold_warning(_("%s: can't open (%s)"), inname, strerror(errno));
+ return false;
+ }
+ int out = ::open(outname, O_CREAT | O_TRUNC | O_WRONLY, 0600);
+ if (out < 0)
+ {
+ gold_warning(_("%s: can't create (%s)"), outname, strerror(errno));
+ ::close(in);
+ return false;
+ }
+ ssize_t len;
+ while ((len = ::read(in, buf, sizeof(buf))) > 0)
+ {
+ if (::write(out, buf, len) != len)
+ {
+ gold_warning(_("%s: write error while making copy of file (%s)"),
+ inname, strerror(errno));
+ break;
+ }
+ }
+ ::close(in);
+ ::close(out);
+ return true;
+}
+
+void
+Plugin_recorder::replacement_file(const char* name, bool is_lib)
+{
+ fprintf(this->logfile_, "REPLACEMENT: %s", name);
+ if (is_lib)
+ fprintf(this->logfile_, "(lib)");
+ else
+ {
+ char counter[10];
+ const char* basename = lbasename(name);
+ snprintf(counter, sizeof(counter), "%05d", this->file_count_);
+ ++this->file_count_;
+ std::string outname(this->tempdir_);
+ outname.append("/");
+ outname.append(counter);
+ outname.append("-");
+ outname.append(basename);
+ if (link_or_copy_file(name, outname.c_str()))
+ fprintf(this->logfile_, " -> %s", outname.c_str());
+ }
+ fprintf(this->logfile_, "\n");
+}
+
+void
+Plugin_recorder::record_symbols(const Object* obj, int nsyms,
+ const struct ld_plugin_symbol* syms)
+{
+ fprintf(this->logfile_, "SYMBOLS: %d %s\n", nsyms, obj->name().c_str());
+ for (int i = 0; i < nsyms; ++i)
+ {
+ const struct ld_plugin_symbol* isym = &syms[i];
+
+ const char* def;
+ switch (isym->def)
+ {
+ case LDPK_DEF:
+ def = "D";
+ break;
+ case LDPK_WEAKDEF:
+ def = "WD";
+ break;
+ case LDPK_UNDEF:
+ def = "U";
+ break;
+ case LDPK_WEAKUNDEF:
+ def = "WU";
+ break;
+ case LDPK_COMMON:
+ def = "C";
+ break;
+ default:
+ def = "?";
+ break;
+ }
+
+ char vis;
+ switch (isym->visibility)
+ {
+ case LDPV_PROTECTED:
+ vis = 'P';
+ break;
+ case LDPV_INTERNAL:
+ vis = 'I';
+ break;
+ case LDPV_HIDDEN:
+ vis = 'H';
+ break;
+ case LDPV_DEFAULT:
+ vis = 'D';
+ break;
+ default:
+ vis = '?';
+ break;
+ }
+
+ fprintf(this->logfile_, " %5d: %-2s %c %s", i, def, vis, isym->name);
+ if (isym->version != NULL && isym->version[0] != '\0')
+ fprintf(this->logfile_, "@%s", isym->version);
+ if (isym->comdat_key != NULL && isym->comdat_key[0] != '\0')
+ {
+ if (strcmp(isym->name, isym->comdat_key) == 0)
+ fprintf(this->logfile_, " [comdat]");
+ else
+ fprintf(this->logfile_, " [comdat: %s]", isym->comdat_key);
+ }
+ fprintf(this->logfile_, "\n");
+ }
+}
+
// Plugin_manager methods.
Plugin_manager::~Plugin_manager()
delete *obj;
this->objects_.clear();
delete this->lock_;
+ delete this->recorder_;
}
// Load all plugin libraries.
Plugin_manager::load_plugins(Layout* layout)
{
this->layout_ = layout;
+
+ if (is_debugging_enabled(DEBUG_PLUGIN))
+ {
+ this->recorder_ = new Plugin_recorder();
+ this->recorder_->init();
+ }
+
for (this->current_ = this->plugins_.begin();
this->current_ != this->plugins_.end();
++this->current_)
gold_assert(lock_initialized);
Hold_lock hl(*this->lock_);
- if (this->in_replacement_phase_)
- return NULL;
unsigned int handle = this->objects_.size();
this->input_file_ = input_file;
this->current_ != this->plugins_.end();
++this->current_)
{
- if ((*this->current_)->claim_file(&this->plugin_input_file_))
+ // If we aren't yet in replacement phase, allow plugins to claim input
+ // files, otherwise notify the plugin of the new input file, if needed.
+ if (!this->in_replacement_phase_)
{
- this->any_claimed_ = true;
- this->in_claim_file_handler_ = false;
+ if ((*this->current_)->claim_file(&this->plugin_input_file_))
+ {
+ this->any_claimed_ = true;
+ this->in_claim_file_handler_ = false;
- if (this->objects_.size() > handle
- && this->objects_[handle]->pluginobj() != NULL)
- return this->objects_[handle]->pluginobj();
+ if (this->recorder_ != NULL)
+ {
+ const std::string& objname = (elf_object == NULL
+ ? input_file->filename()
+ : elf_object->name());
+ this->recorder_->claimed_file(objname,
+ offset, filesize,
+ (*this->current_)->filename());
+ }
+
+ if (this->objects_.size() > handle
+ && this->objects_[handle]->pluginobj() != NULL)
+ return this->objects_[handle]->pluginobj();
- // If the plugin claimed the file but did not call the
- // add_symbols callback, we need to create the Pluginobj now.
- Pluginobj* obj = this->make_plugin_object(handle);
- return obj;
+ // If the plugin claimed the file but did not call the
+ // add_symbols callback, we need to create the Pluginobj now.
+ Pluginobj* obj = this->make_plugin_object(handle);
+ return obj;
+ }
+ }
+ else
+ {
+ (*this->current_)->new_input(&this->plugin_input_file_);
}
}
this->in_claim_file_handler_ = false;
+
+ if (this->recorder_ != NULL)
+ this->recorder_->unclaimed_file(input_file->filename(), offset, filesize);
+
return NULL;
}
this->mapfile_ = mapfile;
this->this_blocker_ = NULL;
+ // Set symbols used in defsym expressions as seen in real ELF.
+ Layout *layout = parameters->options().plugins()->layout();
+ layout->script_options()->set_defsym_uses_in_real_elf(symtab);
+ layout->script_options()->find_defsym_defs(this->defsym_defines_set_);
+
for (this->current_ = this->plugins_.begin();
this->current_ != this->plugins_.end();
++this->current_)
&& this->objects_[handle]->pluginobj() != NULL)
return NULL;
- Pluginobj* obj = make_sized_plugin_object(this->input_file_,
+ const std::string* filename = &this->input_file_->filename();
+
+ // If the elf object for this file was pushed into the objects_ vector,
+ // use its filename, then delete it to make room for the Pluginobj as
+ // this file is claimed.
+ if (this->objects_.size() != handle)
+ {
+ filename = &this->objects_.back()->name();
+ this->objects_.pop_back();
+ }
+
+ Pluginobj* obj = make_sized_plugin_object(*filename,
+ this->input_file_,
this->plugin_input_file_.offset,
this->plugin_input_file_.filesize);
- // If the elf object for this file was pushed into the objects_ vector, delete
- // it to make room for the Pluginobj as this file is claimed.
- if (this->objects_.size() != handle)
- this->objects_.pop_back();
this->objects_.push_back(obj);
return obj;
if (parameters->incremental())
gold_error(_("input files added by plug-ins in --incremental mode not "
"supported yet"));
+
+ if (this->recorder_ != NULL)
+ this->recorder_->replacement_file(pathname, is_lib);
+
this->workqueue_->queue_soon(new Read_symbols(this->input_objects_,
this->symtab_,
this->layout_,
return version > 2 ? LDPS_NO_SYMS : LDPS_OK;
}
+ Plugin_manager* plugins = parameters->options().plugins();
for (int i = 0; i < nsyms; i++)
{
ld_plugin_symbol* isym = &syms[i];
lsym = symtab->resolve_forwards(lsym);
ld_plugin_symbol_resolution res = LDPR_UNKNOWN;
- if (lsym->is_undefined())
- // The symbol remains undefined.
- res = LDPR_UNDEF;
+ if (plugins->is_defsym_def(lsym->name()))
+ {
+ // The symbol is redefined via defsym.
+ res = LDPR_PREEMPTED_REG;
+ }
+ else if (lsym->is_undefined())
+ {
+ // The symbol remains undefined.
+ res = LDPR_UNDEF;
+ }
else if (isym->def == LDPK_UNDEF
|| isym->def == LDPK_WEAKUNDEF
|| isym->def == LDPK_COMMON)
elfcpp::Sym<size, big_endian> sym(symbuf);
elfcpp::Sym_write<size, big_endian> osym(symbuf);
+ Plugin_recorder* recorder = parameters->options().plugins()->recorder();
+ if (recorder != NULL)
+ recorder->record_symbols(this, this->nsyms_, this->syms_);
+
this->symbols_.resize(this->nsyms_);
for (int i = 0; i < this->nsyms_; ++i)
{
case LDPK_DEF:
case LDPK_WEAKDEF:
- shndx = elfcpp::SHN_ABS;
+ // We use an arbitrary section number for a defined symbol.
+ shndx = 1;
break;
case LDPK_COMMON:
shndx = elfcpp::SHN_COMMON;
void
run(Workqueue*)
{
+ Plugin_manager* plugins = parameters->options().plugins();
+ gold_assert(plugins != NULL);
// We could call early cleanup handlers here.
+ if (plugins->recorder())
+ plugins->recorder()->finish();
}
std::string
return LDPS_OK;
}
+static enum ld_plugin_status
+get_wrap_symbols(uint64_t *count, const char ***wrap_symbols)
+{
+ gold_assert(parameters->options().has_plugins());
+ *count = parameters->options().wrap_size();
+
+ if (*count == 0)
+ return LDPS_OK;
+
+ *wrap_symbols = new const char *[*count];
+ int i = 0;
+ for (options::String_set::const_iterator
+ it = parameters->options().wrap_begin();
+ it != parameters->options().wrap_end(); ++it, ++i) {
+ (*wrap_symbols)[i] = it->c_str();
+ }
+ return LDPS_OK;
+}
+
// Specify the ordering of sections in the final layout. The sections are
// specified as (handle,shndx) pairs in the two arrays in the order in
return LDPS_OK;
}
+// Register a new_input handler.
+
+static enum ld_plugin_status
+register_new_input(ld_plugin_new_input_handler handler)
+{
+ gold_assert(parameters->options().has_plugins());
+ parameters->options().plugins()->set_new_input_handler(handler);
+ return LDPS_OK;
+}
+
#endif // ENABLE_PLUGINS
// Allocate a Pluginobj object of the appropriate size and endianness.
static Pluginobj*
-make_sized_plugin_object(Input_file* input_file, off_t offset, off_t filesize)
+make_sized_plugin_object(const std::string& filename,
+ Input_file* input_file, off_t offset, off_t filesize)
{
Pluginobj* obj = NULL;
{
if (target.is_big_endian())
#ifdef HAVE_TARGET_32_BIG
- obj = new Sized_pluginobj<32, true>(input_file->filename(),
- input_file, offset, filesize);
+ obj = new Sized_pluginobj<32, true>(filename, input_file,
+ offset, filesize);
#else
gold_error(_("%s: not configured to support "
"32-bit big-endian object"),
- input_file->filename().c_str());
+ filename.c_str());
#endif
else
#ifdef HAVE_TARGET_32_LITTLE
- obj = new Sized_pluginobj<32, false>(input_file->filename(),
- input_file, offset, filesize);
+ obj = new Sized_pluginobj<32, false>(filename, input_file,
+ offset, filesize);
#else
gold_error(_("%s: not configured to support "
"32-bit little-endian object"),
- input_file->filename().c_str());
+ filename.c_str());
#endif
}
else if (target.get_size() == 64)
{
if (target.is_big_endian())
#ifdef HAVE_TARGET_64_BIG
- obj = new Sized_pluginobj<64, true>(input_file->filename(),
- input_file, offset, filesize);
+ obj = new Sized_pluginobj<64, true>(filename, input_file,
+ offset, filesize);
#else
gold_error(_("%s: not configured to support "
"64-bit big-endian object"),
- input_file->filename().c_str());
+ filename.c_str());
#endif
else
#ifdef HAVE_TARGET_64_LITTLE
- obj = new Sized_pluginobj<64, false>(input_file->filename(),
- input_file, offset, filesize);
+ obj = new Sized_pluginobj<64, false>(filename, input_file,
+ offset, filesize);
#else
gold_error(_("%s: not configured to support "
"64-bit little-endian object"),
- input_file->filename().c_str());
+ filename.c_str());
#endif
}
projects / deliverable / binutils-gdb.git / blobdiff