Subversion Repositories open8_urisc

// plugin.cc -- plugin manager for gold      -*- C++ -*-

// Copyright 2008, 2009, 2010, 2011 Free Software Foundation, Inc.

// Written by Cary Coutant <ccoutant@google.com>.

// This file is part of gold.

// This program is free software; you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation; either version 3 of the License, or

// (at your option) any later version.

// This program is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License

// along with this program; if not, write to the Free Software

// 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 "parameters.h"

#include "errors.h"

#include "fileread.h"

#include "layout.h"

#include "options.h"

#include "plugin.h"

#include "target.h"

#include "readsyms.h"

#include "symtab.h"

#include "elfcpp.h"

namespace gold

{

#ifdef ENABLE_PLUGINS

// The linker's exported interfaces.

extern "C"

{

static enum ld_plugin_status

register_claim_file(ld_plugin_claim_file_handler handler);

static enum ld_plugin_status

register_all_symbols_read(ld_plugin_all_symbols_read_handler handler);

static enum ld_plugin_status

register_cleanup(ld_plugin_cleanup_handler handler);

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

get_view(const void *handle, const void **viewp);

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(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 filesize);

// Plugin methods.

// Load one plugin library.

void

Plugin::load()

{

#ifdef ENABLE_PLUGINS

  // Load the plugin library.

  // FIXME: Look for the library in standard locations.

  this->handle_ = dlopen(this->filename_.c_str(), RTLD_NOW);

  if (this->handle_ == NULL)

    {

      gold_error(_("%s: could not load plugin library: %s"),

                 this->filename_.c_str(), dlerror());

      return;

    }

  // Find the plugin's onload entry point.

  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();

  int major = 0;

  int minor = 0;

  sscanf(ver, "%d.%d", &major, &minor);

  // Allocate and populate a transfer vector.

  const int tv_fixed_size = 17;

  int tv_size = this->args_.size() + tv_fixed_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.

  int i = 0;

  tv[i].tv_tag = LDPT_MESSAGE;

  tv[i].tv_u.tv_message = message;

  ++i;

  tv[i].tv_tag = LDPT_API_VERSION;

  tv[i].tv_u.tv_val = LD_PLUGIN_API_VERSION;

  ++i;

  tv[i].tv_tag = LDPT_GOLD_VERSION;

  tv[i].tv_u.tv_val = major * 100 + minor;

  ++i;

  tv[i].tv_tag = LDPT_LINKER_OUTPUT;

  if (parameters->options().relocatable())

    tv[i].tv_u.tv_val = LDPO_REL;

  else if (parameters->options().shared())

    tv[i].tv_u.tv_val = LDPO_DYN;

  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_OPTION;

      tv[i].tv_u.tv_string = this->args_[j].c_str();

    }

  ++i;

  tv[i].tv_tag = LDPT_REGISTER_CLAIM_FILE_HOOK;

  tv[i].tv_u.tv_register_claim_file = register_claim_file;

  ++i;

  tv[i].tv_tag = LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK;

  tv[i].tv_u.tv_register_all_symbols_read = register_all_symbols_read;

  ++i;

  tv[i].tv_tag = LDPT_REGISTER_CLEANUP_HOOK;

  tv[i].tv_u.tv_register_cleanup = register_cleanup;

  ++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_GET_VIEW;

  tv[i].tv_u.tv_get_view = get_view;

  ++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;

  ++i;

  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;

  gold_assert(i == tv_size - 1);

  // Call the onload entry point.

  (*onload)(tv);

  delete[] tv;

#endif // ENABLE_PLUGINS

}

// Call the plugin claim-file handler.

inline bool

Plugin::claim_file(struct ld_plugin_input_file* plugin_input_file)

{

  int claimed = 0;

  if (this->claim_file_handler_ != NULL)

    {

      (*this->claim_file_handler_)(plugin_input_file, &claimed);

      if (claimed)

        return true;

    }

  return false;

}

// Call the all-symbols-read handler.

inline void

Plugin::all_symbols_read()

{

  if (this->all_symbols_read_handler_ != NULL)

    (*this->all_symbols_read_handler_)();

}

// Call the cleanup handler.

inline void

Plugin::cleanup()

{

  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_)();

    }

}

// This task is used to rescan archives as needed.

class Plugin_rescan : public Task

{

 public:

  Plugin_rescan(Task_token* this_blocker, Task_token* next_blocker)

    : this_blocker_(this_blocker), next_blocker_(next_blocker)

  { }

  ~Plugin_rescan()

  {

    delete this->this_blocker_;

  }

  Task_token*

  is_runnable()

  {

    if (this->this_blocker_->is_blocked())

      return this->this_blocker_;

    return NULL;

  }

  void

  locks(Task_locker* tl)

  { tl->add(this, this->next_blocker_); }

  void

  run(Workqueue*)

  { parameters->options().plugins()->rescan(this); }

  std::string

  get_name() const

  { return "Plugin_rescan"; }

 private:

  Task_token* this_blocker_;

  Task_token* next_blocker_;

};

// Plugin_manager methods.

Plugin_manager::~Plugin_manager()

{

  for (Plugin_list::iterator p = this->plugins_.begin();

       p != this->plugins_.end();

       ++p)

    delete *p;

  this->plugins_.clear();

  for (Object_list::iterator obj = this->objects_.begin();

       obj != this->objects_.end();

       ++obj)

    delete *obj;

  this->objects_.clear();

}

// Load all plugin libraries.

void

Plugin_manager::load_plugins()

{

  for (this->current_ = this->plugins_.begin();

       this->current_ != this->plugins_.end();

       ++this->current_)

    (*this->current_)->load();

}

// Call the plugin claim-file handlers in turn to see if any claim the file.

Pluginobj*

Plugin_manager::claim_file(Input_file* input_file, off_t offset,

                           off_t filesize)

{

  if (this->in_replacement_phase_)

    return NULL;

  unsigned int handle = this->objects_.size();

  this->input_file_ = input_file;

  this->plugin_input_file_.name = input_file->filename().c_str();

  this->plugin_input_file_.fd = input_file->file().descriptor();

  this->plugin_input_file_.offset = offset;

  this->plugin_input_file_.filesize = filesize;

  this->plugin_input_file_.handle = reinterpret_cast<void*>(handle);

  for (this->current_ = this->plugins_.begin();

       this->current_ != this->plugins_.end();

       ++this->current_)

    {

      if ((*this->current_)->claim_file(&this->plugin_input_file_))

        {

          this->any_claimed_ = true;

          if (this->objects_.size() > handle)

            return this->objects_[handle];

          // 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;

        }

    }

  return NULL;

}

// Save an archive.  This is used so that a plugin can add a file

// which refers to a symbol which was not previously referenced.  In

// that case we want to pretend that the symbol was referenced before,

// and pull in the archive object.

void

Plugin_manager::save_archive(Archive* archive)

{

  if (this->in_replacement_phase_ || !this->any_claimed_)

    delete archive;

  else

    this->rescannable_.push_back(Rescannable(archive));

}

// Save an Input_group.  This is like save_archive.

void

Plugin_manager::save_input_group(Input_group* input_group)

{

  if (this->in_replacement_phase_ || !this->any_claimed_)

    delete input_group;

  else

    this->rescannable_.push_back(Rescannable(input_group));

}

// Call the all-symbols-read handlers.

void

Plugin_manager::all_symbols_read(Workqueue* workqueue, Task* task,

                                 Input_objects* input_objects,

                                 Symbol_table* symtab, Layout* layout,

                                 Dirsearch* dirpath, Mapfile* mapfile,

                                 Task_token** last_blocker)

{

  this->in_replacement_phase_ = true;

  this->workqueue_ = workqueue;

  this->task_ = task;

  this->input_objects_ = input_objects;

  this->symtab_ = symtab;

  this->layout_ = layout;

  this->dirpath_ = dirpath;

  this->mapfile_ = mapfile;

  this->this_blocker_ = NULL;

  for (this->current_ = this->plugins_.begin();

       this->current_ != this->plugins_.end();

       ++this->current_)

    (*this->current_)->all_symbols_read();

  if (this->any_added_)

    {

      Task_token* next_blocker = new Task_token(true);

      next_blocker->add_blocker();

      workqueue->queue(new Plugin_rescan(this->this_blocker_, next_blocker));

      this->this_blocker_ = next_blocker;

    }

  *last_blocker = this->this_blocker_;

}

// This is called when we see a new undefined symbol.  If we are in

// the replacement phase, this means that we may need to rescan some

// archives we have previously seen.

void

Plugin_manager::new_undefined_symbol(Symbol* sym)

{

  if (this->in_replacement_phase_)

    this->undefined_symbols_.push_back(sym);

}

// Rescan archives as needed.  This handles the case where a new

// object file added by a plugin has an undefined reference to some

// symbol defined in an archive.

void

Plugin_manager::rescan(Task* task)

{

  size_t rescan_pos = 0;

  size_t rescan_size = this->rescannable_.size();

  while (!this->undefined_symbols_.empty())

    {

      if (rescan_pos >= rescan_size)

        {

          this->undefined_symbols_.clear();

          return;

        }

      Undefined_symbol_list undefs;

      undefs.reserve(this->undefined_symbols_.size());

      this->undefined_symbols_.swap(undefs);

      size_t min_rescan_pos = rescan_size;

      for (Undefined_symbol_list::const_iterator p = undefs.begin();

           p != undefs.end();

           ++p)

        {

          if (!(*p)->is_undefined())

            continue;

          this->undefined_symbols_.push_back(*p);

          // Find the first rescan archive which defines this symbol,

          // starting at the current rescan position.  The rescan position

          // exists so that given -la -lb -lc we don't look for undefined

          // symbols in -lb back in -la, but instead get the definition

          // from -lc.  Don't bother to look past the current minimum

          // rescan position.

          for (size_t i = rescan_pos; i < min_rescan_pos; ++i)

            {

              if (this->rescannable_defines(i, *p))

                {

                  min_rescan_pos = i;

                  break;

                }

            }

        }

      if (min_rescan_pos >= rescan_size)

        {

          // We didn't find any rescannable archives which define any

          // undefined symbols.

          return;

        }

      const Rescannable& r(this->rescannable_[min_rescan_pos]);

      if (r.is_archive)

        {

          Task_lock_obj<Archive> tl(task, r.u.archive);

          r.u.archive->add_symbols(this->symtab_, this->layout_,

                                   this->input_objects_, this->mapfile_);

        }

      else

        {

          size_t next_saw_undefined = this->symtab_->saw_undefined();

          size_t saw_undefined;

          do

            {

              saw_undefined = next_saw_undefined;

              for (Input_group::const_iterator p = r.u.input_group->begin();

                   p != r.u.input_group->end();

                   ++p)

                {

                  Task_lock_obj<Archive> tl(task, *p);

                  (*p)->add_symbols(this->symtab_, this->layout_,

                                    this->input_objects_, this->mapfile_);

                }

              next_saw_undefined = this->symtab_->saw_undefined();

            }

          while (saw_undefined != next_saw_undefined);

        }

      for (size_t i = rescan_pos; i < min_rescan_pos + 1; ++i)

        {

          if (this->rescannable_[i].is_archive)

            delete this->rescannable_[i].u.archive;

          else

            delete this->rescannable_[i].u.input_group;

        }

      rescan_pos = min_rescan_pos + 1;

    }

}

// Return whether the rescannable at index I defines SYM.

bool

Plugin_manager::rescannable_defines(size_t i, Symbol* sym)

{

  const Rescannable& r(this->rescannable_[i]);

  if (r.is_archive)

    return r.u.archive->defines_symbol(sym);

  else

    {

      for (Input_group::const_iterator p = r.u.input_group->begin();

           p != r.u.input_group->end();

           ++p)

        {

          if ((*p)->defines_symbol(sym))

            return true;

        }

      return false;

    }

}

// Layout deferred objects.

void

Plugin_manager::layout_deferred_objects()

{

  Deferred_layout_list::iterator obj;

  for (obj = this->deferred_layout_objects_.begin();

       obj != this->deferred_layout_objects_.end();

       ++obj)

    {

      // Lock the object so we can read from it.  This is only called

      // single-threaded from queue_middle_tasks, so it is OK to lock.

      // Unfortunately we have no way to pass in a Task token.

      const Task* dummy_task = reinterpret_cast<const Task*>(-1);

      Task_lock_obj<Object> tl(dummy_task, *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_)

    (*this->current_)->cleanup();

}

// Make a new Pluginobj object.  This is called when the plugin calls

// the add_symbols API.

Pluginobj*

Plugin_manager::make_plugin_object(unsigned int handle)

{

  // Make sure we aren't asked to make an object for the same handle twice.

  if (this->objects_.size() != handle)

    return NULL;

  Pluginobj* obj = make_sized_plugin_object(this->input_file_,

                                            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;

}

ld_plugin_status

Plugin_manager::get_view(unsigned int handle, const void **viewp)

{

  off_t offset;

  size_t filesize;

  Input_file *input_file;

  if (this->objects_.size() == handle)

    {

      // We are being called from the claim_file hook.

      const struct ld_plugin_input_file &f = this->plugin_input_file_;

      offset = f.offset;

      filesize = f.filesize;