-// plugin.c -- plugin manager for gold -*- C++ -*-
+// plugin.cc -- plugin manager for gold -*- C++ -*-
-// Copyright 2008 Free Software Foundation, Inc.
+// Copyright 2008, 2009, 2010 Free Software Foundation, Inc.
// Written by Cary Coutant <ccoutant@google.com>.
// This file is part of gold.
// Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
// MA 02110-1301, USA.
+#include "gold.h"
+
#include <cstdio>
#include <cstdarg>
#include <cstring>
#include <string>
#include <vector>
+
+#ifdef ENABLE_PLUGINS
#include <dlfcn.h>
+#endif
-#include "gold.h"
#include "parameters.h"
#include "errors.h"
#include "fileread.h"
static enum ld_plugin_status
add_symbols(void *handle, int nsyms, const struct ld_plugin_symbol *syms);
+static enum ld_plugin_status
+get_input_file(const void *handle, struct ld_plugin_input_file *file);
+
+static enum ld_plugin_status
+release_input_file(const void *handle);
+
static enum ld_plugin_status
get_symbols(const void *handle, int nsyms, struct ld_plugin_symbol *syms);
static enum ld_plugin_status
-add_input_file(char *pathname);
+add_input_file(const char *pathname);
+
+static enum ld_plugin_status
+add_input_library(const char *pathname);
+
+static enum ld_plugin_status
+set_extra_library_path(const char *path);
static enum ld_plugin_status
message(int level, const char *format, ...);
#endif // ENABLE_PLUGINS
static Pluginobj* make_sized_plugin_object(Input_file* input_file,
- off_t offset);
+ off_t offset, off_t filesize);
// Plugin methods.
this->handle_ = dlopen(this->filename_.c_str(), RTLD_NOW);
if (this->handle_ == NULL)
{
- gold_error(_("%s: could not load plugin library"),
- this->filename_.c_str());
+ gold_error(_("%s: could not load plugin library: %s"),
+ this->filename_.c_str(), dlerror());
return;
}
// Find the plugin's onload entry point.
- ld_plugin_onload onload = reinterpret_cast<ld_plugin_onload>
- (dlsym(this->handle_, "onload"));
- if (onload == NULL)
+ void* ptr = dlsym(this->handle_, "onload");
+ if (ptr == NULL)
{
gold_error(_("%s: could not find onload entry point"),
this->filename_.c_str());
return;
}
+ ld_plugin_onload onload;
+ gold_assert(sizeof(onload) == sizeof(ptr));
+ memcpy(&onload, &ptr, sizeof(ptr));
// Get the linker's version number.
const char* ver = get_version_string();
sscanf(ver, "%d.%d", &major, &minor);
// Allocate and populate a transfer vector.
- const int tv_fixed_size = 11;
+ const int tv_fixed_size = 16;
int tv_size = this->args_.size() + tv_fixed_size;
- ld_plugin_tv *tv = new ld_plugin_tv[tv_size];
+ ld_plugin_tv* tv = new ld_plugin_tv[tv_size];
// Put LDPT_MESSAGE at the front of the list so the plugin can use it
// while processing subsequent entries.
else
tv[i].tv_u.tv_val = LDPO_EXEC;
+ ++i;
+ tv[i].tv_tag = LDPT_OUTPUT_NAME;
+ tv[i].tv_u.tv_string = parameters->options().output();
+
for (unsigned int j = 0; j < this->args_.size(); ++j)
{
++i;
tv[i].tv_tag = LDPT_ADD_SYMBOLS;
tv[i].tv_u.tv_add_symbols = add_symbols;
+ ++i;
+ tv[i].tv_tag = LDPT_GET_INPUT_FILE;
+ tv[i].tv_u.tv_get_input_file = get_input_file;
+
+ ++i;
+ tv[i].tv_tag = LDPT_RELEASE_INPUT_FILE;
+ tv[i].tv_u.tv_release_input_file = release_input_file;
+
++i;
tv[i].tv_tag = LDPT_GET_SYMBOLS;
tv[i].tv_u.tv_get_symbols = get_symbols;
tv[i].tv_tag = LDPT_ADD_INPUT_FILE;
tv[i].tv_u.tv_add_input_file = add_input_file;
+ ++i;
+ tv[i].tv_tag = LDPT_ADD_INPUT_LIBRARY;
+ tv[i].tv_u.tv_add_input_library = add_input_library;
+
+ ++i;
+ tv[i].tv_tag = LDPT_SET_EXTRA_LIBRARY_PATH;
+ tv[i].tv_u.tv_set_extra_library_path = set_extra_library_path;
+
++i;
tv[i].tv_tag = LDPT_NULL;
tv[i].tv_u.tv_val = 0;
// Call the plugin claim-file handler.
inline bool
-Plugin::claim_file(struct ld_plugin_input_file *plugin_input_file)
+Plugin::claim_file(struct ld_plugin_input_file* plugin_input_file)
{
int claimed = 0;
inline void
Plugin::cleanup()
{
- if (this->cleanup_handler_ != NULL)
- (*this->cleanup_handler_)();
+ if (this->cleanup_handler_ != NULL && !this->cleanup_done_)
+ {
+ // Set this flag before calling to prevent a recursive plunge
+ // in the event that a plugin's cleanup handler issues a
+ // fatal error.
+ this->cleanup_done_ = true;
+ (*this->cleanup_handler_)();
+ }
}
// Plugin_manager methods.
// Call the all-symbols-read handlers.
void
-Plugin_manager::all_symbols_read(Workqueue* workqueue,
+Plugin_manager::all_symbols_read(Workqueue* workqueue, Task* task,
Input_objects* input_objects,
Symbol_table* symtab, Layout* layout,
Dirsearch* dirpath, Mapfile* mapfile,
{
this->in_replacement_phase_ = true;
this->workqueue_ = workqueue;
+ this->task_ = task;
this->input_objects_ = input_objects;
this->symtab_ = symtab;
this->layout_ = layout;
*last_blocker = this->this_blocker_;
}
-// Layout deferred sections and call the cleanup handlers.
+// Layout deferred objects.
void
-Plugin_manager::finish()
+Plugin_manager::layout_deferred_objects()
{
Deferred_layout_list::iterator obj;
obj != this->deferred_layout_objects_.end();
++obj)
(*obj)->layout_deferred_sections(this->layout_);
+}
+
+// Call the cleanup handlers.
+void
+Plugin_manager::cleanup()
+{
for (this->current_ = this->plugins_.begin();
this->current_ != this->plugins_.end();
++this->current_)
return NULL;
Pluginobj* obj = make_sized_plugin_object(this->input_file_,
- this->plugin_input_file_.offset);
+ this->plugin_input_file_.offset,
+ this->plugin_input_file_.filesize);
this->objects_.push_back(obj);
return obj;
}
+// Get the input file information with an open (possibly re-opened)
+// file descriptor.
+
+ld_plugin_status
+Plugin_manager::get_input_file(unsigned int handle,
+ struct ld_plugin_input_file* file)
+{
+ Pluginobj* obj = this->object(handle);
+ if (obj == NULL)
+ return LDPS_BAD_HANDLE;
+
+ obj->lock(this->task_);
+ file->name = obj->filename().c_str();
+ file->fd = obj->descriptor();
+ file->offset = obj->offset();
+ file->filesize = obj->filesize();
+ file->handle = reinterpret_cast<void*>(handle);
+ return LDPS_OK;
+}
+
+// Release the input file.
+
+ld_plugin_status
+Plugin_manager::release_input_file(unsigned int handle)
+{
+ Pluginobj* obj = this->object(handle);
+ if (obj == NULL)
+ return LDPS_BAD_HANDLE;
+
+ obj->unlock(this->task_);
+ return LDPS_OK;
+}
+
+// Add a new library path.
+
+ld_plugin_status
+Plugin_manager::set_extra_library_path(const char* path)
+{
+ this->extra_search_path_ = std::string(path);
+ return LDPS_OK;
+}
+
// Add a new input file.
ld_plugin_status
-Plugin_manager::add_input_file(char *pathname)
+Plugin_manager::add_input_file(const char* pathname, bool is_lib)
{
- Input_file_argument file(pathname, false, "", false, this->options_);
+ Input_file_argument file(pathname,
+ (is_lib
+ ? Input_file_argument::INPUT_FILE_TYPE_LIBRARY
+ : Input_file_argument::INPUT_FILE_TYPE_FILE),
+ (is_lib
+ ? this->extra_search_path_.c_str()
+ : ""),
+ false,
+ this->options_);
Input_argument* input_argument = new Input_argument(file);
Task_token* next_blocker = new Task_token(true);
next_blocker->add_blocker();
- this->workqueue_->queue_soon(new Read_symbols(this->options_,
- this->input_objects_,
+ if (parameters->options().incremental())
+ gold_error(_("input files added by plug-ins in --incremental mode not "
+ "supported yet"));
+ this->workqueue_->queue_soon(new Read_symbols(this->input_objects_,
this->symtab_,
this->layout_,
this->dirpath_,
+ 0,
this->mapfile_,
input_argument,
NULL,
+ NULL,
this->this_blocker_,
next_blocker));
this->this_blocker_ = next_blocker;
// Class Pluginobj.
Pluginobj::Pluginobj(const std::string& name, Input_file* input_file,
- off_t offset)
+ off_t offset, off_t filesize)
: Object(name, input_file, false, offset),
- nsyms_(0), syms_(NULL), symbols_(), comdat_map_()
+ nsyms_(0), syms_(NULL), symbols_(), filesize_(filesize), comdat_map_()
{
}
+// Return TRUE if a defined symbol might be reachable from outside the
+// universe of claimed objects.
+
+static inline bool
+is_visible_from_outside(Symbol* lsym)
+{
+ if (lsym->in_real_elf())
+ return true;
+ if (parameters->options().relocatable())
+ return true;
+ if (parameters->options().export_dynamic() || parameters->options().shared())
+ return lsym->is_externally_visible();
+ return false;
+}
+
// Get symbol resolution info.
ld_plugin_status
{
if (nsyms > this->nsyms_)
return LDPS_NO_SYMS;
+
+ if (static_cast<size_t>(nsyms) > this->symbols_.size())
+ {
+ // We never decided to include this object. We mark all symbols as
+ // preempted.
+ gold_assert(this->symbols_.size() == 0);
+ for (int i = 0; i < nsyms; i++)
+ syms[i].resolution = LDPR_PREEMPTED_REG;
+ return LDPS_OK;
+ }
+
for (int i = 0; i < nsyms; i++)
{
ld_plugin_symbol* isym = &syms[i];
// The original symbol was undefined or common.
if (lsym->source() != Symbol::FROM_OBJECT)
res = LDPR_RESOLVED_EXEC;
+ else if (lsym->object()->pluginobj() == this)
+ res = (is_visible_from_outside(lsym)
+ ? LDPR_PREVAILING_DEF
+ : LDPR_PREVAILING_DEF_IRONLY);
else if (lsym->object()->pluginobj() != NULL)
res = LDPR_RESOLVED_IR;
else if (lsym->object()->is_dynamic())
if (lsym->source() != Symbol::FROM_OBJECT)
res = LDPR_PREEMPTED_REG;
else if (lsym->object() == static_cast<const Object*>(this))
- res = (lsym->in_real_elf()
+ res = (is_visible_from_outside(lsym)
? LDPR_PREVAILING_DEF
: LDPR_PREVAILING_DEF_IRONLY);
else
// If this is the first time we've seen this comdat key, ask the
// layout object whether it should be included.
if (ins.second)
- ins.first->second = layout->add_comdat(NULL, 1, comdat_key, true);
+ ins.first->second = layout->find_or_add_kept_section(comdat_key,
+ NULL, 0, true,
+ true, NULL);
return ins.first->second;
}
Sized_pluginobj<size, big_endian>::Sized_pluginobj(
const std::string& name,
Input_file* input_file,
- off_t offset)
- : Pluginobj(name, input_file, offset)
+ off_t offset,
+ off_t filesize)
+ : Pluginobj(name, input_file, offset, filesize)
{
}
// Add the symbols to the symbol table.
-template<int size, bool big_endian>
-void
-Sized_pluginobj<size, big_endian>::do_add_symbols(Symbol_table*,
- Read_symbols_data*)
-{
- gold_unreachable();
-}
-
template<int size, bool big_endian>
void
Sized_pluginobj<size, big_endian>::do_add_symbols(Symbol_table* symtab,
+ Read_symbols_data*,
Layout* layout)
{
const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
for (int i = 0; i < this->nsyms_; ++i)
{
- const struct ld_plugin_symbol *isym = &this->syms_[i];
+ const struct ld_plugin_symbol* isym = &this->syms_[i];
const char* name = isym->name;
const char* ver = isym->version;
elfcpp::Elf_Half shndx;
switch (isym->visibility)
{
case LDPV_PROTECTED:
- vis = elfcpp::STV_DEFAULT;
+ vis = elfcpp::STV_PROTECTED;
break;
case LDPV_INTERNAL:
- vis = elfcpp::STV_DEFAULT;
+ vis = elfcpp::STV_INTERNAL;
break;
case LDPV_HIDDEN:
- vis = elfcpp::STV_DEFAULT;
+ vis = elfcpp::STV_HIDDEN;
break;
case LDPV_DEFAULT:
default:
}
}
+template<int size, bool big_endian>
+Archive::Should_include
+Sized_pluginobj<size, big_endian>::do_should_include_member(
+ Symbol_table* symtab,
+ Layout* layout,
+ Read_symbols_data*,
+ std::string* why)
+{
+ char* tmpbuf = NULL;
+ size_t tmpbuflen = 0;
+
+ for (int i = 0; i < this->nsyms_; ++i)
+ {
+ const struct ld_plugin_symbol& sym = this->syms_[i];
+ const char* name = sym.name;
+ Symbol* symbol;
+ Archive::Should_include t = Archive::should_include_member(symtab,
+ layout,
+ name,
+ &symbol, why,
+ &tmpbuf,
+ &tmpbuflen);
+ if (t == Archive::SHOULD_INCLUDE_YES)
+ {
+ if (tmpbuf != NULL)
+ free(tmpbuf);
+ return t;
+ }
+ }
+ if (tmpbuf != NULL)
+ free(tmpbuf);
+ return Archive::SHOULD_INCLUDE_UNKNOWN;
+}
+
// Get the size of a section. Not used for plugin objects.
template<int size, bool big_endian>
return 0;
}
+// Return section entsize. Not used for plugin objects.
+
+template<int size, bool big_endian>
+uint64_t
+Sized_pluginobj<size, big_endian>::do_section_entsize(unsigned int)
+{
+ gold_unreachable();
+ return 0;
+}
+
// Return section address. Not used for plugin objects.
template<int size, bool big_endian>
gold_unreachable();
}
-// Class Add_plugin_symbols.
+// Get symbols. Not used for plugin objects.
-Add_plugin_symbols::~Add_plugin_symbols()
-{
- if (this->this_blocker_ != NULL)
- delete this->this_blocker_;
- // next_blocker_ is deleted by the task associated with the next
- // input file.
-}
-
-// We are blocked by this_blocker_. We block next_blocker_. We also
-// lock the file.
-
-Task_token*
-Add_plugin_symbols::is_runnable()
-{
- if (this->this_blocker_ != NULL && this->this_blocker_->is_blocked())
- return this->this_blocker_;
- if (this->obj_->is_locked())
- return this->obj_->token();
- return NULL;
-}
-
-void
-Add_plugin_symbols::locks(Task_locker* tl)
-{
- tl->add(this, this->next_blocker_);
- tl->add(this, this->obj_->token());
-}
-
-// Add the symbols in the object to the symbol table.
-
-void
-Add_plugin_symbols::run(Workqueue*)
+template<int size, bool big_endian>
+const Object::Symbols*
+Sized_pluginobj<size, big_endian>::do_get_global_symbols() const
{
- this->obj_->add_symbols(this->symtab_, this->layout_);
+ gold_unreachable();
}
// Class Plugin_finish. This task runs after all replacement files have
-// been added. It calls Layout::layout for any deferred sections and
-// calls each plugin's cleanup handler.
+// been added. For now, it's a placeholder for a possible plugin API
+// to allow the plugin to release most of its resources. The cleanup
+// handlers must be called later, because they can remove the temporary
+// object files that are needed until the end of the link.
class Plugin_finish : public Task
{
void
run(Workqueue*)
- { parameters->options().plugins()->finish(); }
+ {
+ // We could call early cleanup handlers here.
+ }
std::string
get_name() const
Plugin_hook::run(Workqueue* workqueue)
{
gold_assert(this->options_.has_plugins());
+ Symbol* start_sym;
+ if (parameters->options().entry())
+ start_sym = this->symtab_->lookup(parameters->options().entry());
+ else
+ start_sym = this->symtab_->lookup("_start");
+ if (start_sym != NULL)
+ start_sym->set_in_real_elf();
+
this->options_.plugins()->all_symbols_read(workqueue,
+ this,
this->input_objects_,
this->symtab_,
this->layout_,
// Add symbols from a plugin-claimed input file.
static enum ld_plugin_status
-add_symbols(void* handle, int nsyms, const ld_plugin_symbol *syms)
+add_symbols(void* handle, int nsyms, const ld_plugin_symbol* syms)
{
gold_assert(parameters->options().has_plugins());
Pluginobj* obj = parameters->options().plugins()->make_plugin_object(
return LDPS_OK;
}
+// 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)
+{
+ gold_assert(parameters->options().has_plugins());
+ unsigned int obj_index =
+ static_cast<unsigned int>(reinterpret_cast<intptr_t>(handle));
+ return parameters->options().plugins()->get_input_file(obj_index, file);
+}
+
+// Release the input file.
+
+static enum ld_plugin_status
+release_input_file(const void* handle)
+{
+ gold_assert(parameters->options().has_plugins());
+ unsigned int obj_index =
+ static_cast<unsigned int>(reinterpret_cast<intptr_t>(handle));
+ return parameters->options().plugins()->release_input_file(obj_index);
+}
+
// Get the symbol resolution info for a plugin-claimed input file.
static enum ld_plugin_status
-get_symbols(const void * handle, int nsyms, ld_plugin_symbol* syms)
+get_symbols(const void* handle, int nsyms, ld_plugin_symbol* syms)
{
gold_assert(parameters->options().has_plugins());
Pluginobj* obj = parameters->options().plugins()->object(
// Add a new (real) input file generated by a plugin.
static enum ld_plugin_status
-add_input_file(char *pathname)
+add_input_file(const char* pathname)
{
gold_assert(parameters->options().has_plugins());
- return parameters->options().plugins()->add_input_file(pathname);
+ return parameters->options().plugins()->add_input_file(pathname, false);
+}
+
+// Add a new (real) library required by a plugin.
+
+static enum ld_plugin_status
+add_input_library(const char* pathname)
+{
+ gold_assert(parameters->options().has_plugins());
+ return parameters->options().plugins()->add_input_file(pathname, true);
+}
+
+// Set the extra library path to be used by libraries added via
+// add_input_library
+
+static enum ld_plugin_status
+set_extra_library_path(const char* path)
+{
+ gold_assert(parameters->options().has_plugins());
+ return parameters->options().plugins()->set_extra_library_path(path);
}
// Issue a diagnostic message from a plugin.
static enum ld_plugin_status
-message(int level, const char * format, ...)
+message(int level, const char* format, ...)
{
va_list args;
va_start(args, format);
// Allocate a Pluginobj object of the appropriate size and endianness.
static Pluginobj*
-make_sized_plugin_object(Input_file* input_file, off_t offset)
+make_sized_plugin_object(Input_file* input_file, off_t offset, off_t filesize)
{
- Target* target;
Pluginobj* obj = NULL;
- if (parameters->target_valid())
- target = const_cast<Target*>(¶meters->target());
- else
- target = const_cast<Target*>(¶meters->default_target());
+ parameters_force_valid_target();
+ const Target& target(parameters->target());
- if (target->get_size() == 32)
+ if (target.get_size() == 32)
{
- if (target->is_big_endian())
+ if (target.is_big_endian())
#ifdef HAVE_TARGET_32_BIG
obj = new Sized_pluginobj<32, true>(input_file->filename(),
- input_file, offset);
+ input_file, offset, filesize);
#else
gold_error(_("%s: not configured to support "
"32-bit big-endian object"),
else
#ifdef HAVE_TARGET_32_LITTLE
obj = new Sized_pluginobj<32, false>(input_file->filename(),
- input_file, offset);
+ input_file, offset, filesize);
#else
gold_error(_("%s: not configured to support "
"32-bit little-endian object"),
input_file->filename().c_str());
#endif
}
- else if (target->get_size() == 64)
+ else if (target.get_size() == 64)
{
- if (target->is_big_endian())
+ if (target.is_big_endian())
#ifdef HAVE_TARGET_64_BIG
obj = new Sized_pluginobj<64, true>(input_file->filename(),
- input_file, offset);
+ input_file, offset, filesize);
#else
gold_error(_("%s: not configured to support "
"64-bit big-endian object"),
else
#ifdef HAVE_TARGET_64_LITTLE
obj = new Sized_pluginobj<64, false>(input_file->filename(),
- input_file, offset);
+ input_file, offset, filesize);
#else
gold_error(_("%s: not configured to support "
"64-bit little-endian object"),
}
gold_assert(obj != NULL);
- obj->set_target(target);
return obj;
}