Add plugin functionality for link-time optimization (LTO).

include/:
	* plugin-api.h: New file.

gold/:
	* configure.ac (plugins): Add --enable-plugins option.
	* configure: Regenerate.
	* config.in: Regenerate.
	* Makefile.am (LIBDL): New variable.
	(CCFILES): Add plugin.cc.
	(HFILES): Add plugin.h.
	(ldadd_var): Add LIBDL.
	* Makefile.in: Regenerate.

	* archive.cc: Include "plugin.h".
	(Archive::setup): Don't preread archive symbols when using a plugin.
	(Archive::get_file_and_offset): Add memsize parameter.  Change callers.
	(Archive::get_elf_object_for_member): Call plugin hooks for claiming
	files.
	(Archive::include_member): Add symbols from plugin objects.
	* archive.h (Archive::get_file_and_offset): Add memsize parameter.
	* descriptors.cc (Descriptors::open): Check for file descriptors
	abandoned by plugins.
	(Descriptors::claim_for_plugin): New function.
	* descriptors.h (Descriptors::claim_for_plugin): New function.
	(Open_descriptor::is_claimed): New field.
	(claim_descriptor_for_plugin): New function.
	* fileread.cc (File_read::claim_for_plugin): New function.
	* fileread.h (File_read::claim_for_plugin): New function.
	(File_read::descriptor): New function.
	* gold.cc: Include "plugin.h".
	(queue_initial_tasks): Add task to call plugin hooks for generating
	new object files.
	* main.cc: Include "plugin.h".
	(main): Load plugin libraries.
	* object.h (Pluginobj): Declare.
	(Object::pluginobj): New function.
	(Object::do_pluginobj): New function.
	(Object::set_target): New function.
	* options.cc: Include "plugin.h".
	(General_options::parse_plugin): New function.
	(General_options::General_options): Initialize plugins_ field.
	(General_options::add_plugin): New function.
	* options.h (Plugin_manager): Declare.
	(General_options): Add --plugin option.
	(General_options::has_plugins): New function.
	(General_options::plugins): New function.
	(General_options::add_plugin): New function.
	(General_options::plugins_): New field.
	* plugin.cc: New file.
	* plugin.h: New file.
	* readsyms.cc: Include "plugin.h".
	(Read_symbols::do_read_symbols): Check for archive before checking
	for ELF file.  Call plugin hooks to claim files.
	* resolve.cc (Symbol_table::resolve): Record when symbol is referenced
	from a real object file; force override when processing replacement
	files.
	* symtab.cc (Symbol::init_fields): Initialize in_real_elf_ field.
	(Symbol::init_base_object): Likewise.
	(Symbol::init_base_output_data): Likewise.
	(Symbol::init_base_output_segment): Likewise.
	(Symbol::init_base_constant): Likewise.
	(Symbol::init_base_undefined): Likewise.
	(Symbol::output_section): Assert that object is not a plugin.
	(Symbol_table::add_from_pluginobj): New function.
	(Symbol_table::sized_finalize_symbol): Treat symbols from plugins as
	undefined.
	(Symbol_table::sized_write_globals): Likewise.
	(Symbol_table::add_from_pluginobj): Instantiate template.
	* symtab.h (Sized_pluginobj): Declare.
	(Symbol::in_real_elf): New function.
	(Symbol::set_in_real_elf): New function.
	(Symbol::in_real_elf_): New field.
	(Symbol_table::add_from_pluginobj): New function.

	* testsuite/Makefile.am (AM_CFLAGS): New variable.
	(LIBDL): New variable.
	(LDADD): Add LIBDL.
	(check_PROGRAMS): Add plugin_test_1 and plugin_test_2.
	(check_SCRIPTS): Add plugin_test_1.sh and plugin_test_2.sh.
	(check_DATA): Add plugin_test_1.err and plugin_test_2.err.
	(MOSTLYCLEANFILES): Likewise.
	* testsuite/Makefile.in: Regenerate.
	* testsuite/plugin_test.c: New file.
	* testsuite/plugin_test_1.sh: New file.
	* testsuite/plugin_test_2.sh: New file.

1 files changed, 968 insertions, 0 deletions

diff --git a/gold/plugin.cc b/gold/plugin.cc
new file mode 100644
index 00000000000..19f7619979b
--- /dev/null
+++ b/gold/plugin.cc
@@ -0,0 +1,968 @@
+// plugin.c -- plugin manager for gold      -*- C++ -*-
+
+// Copyright 2008 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 <cstdio>
+#include <cstdarg>
+#include <cstring>
+#include <string>
+#include <vector>
+#include <dlfcn.h>
+
+#include "gold.h"
+#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_symbols(const void *handle, int nsyms, struct ld_plugin_symbol *syms);
+
+static enum ld_plugin_status
+add_input_file(char *pathname);
+
+static enum ld_plugin_status
+message(int level, char *format, ...);
+
+};
+
+#endif // ENABLE_PLUGINS
+
+static Pluginobj* make_sized_plugin_object(Input_file* input_file,
+                                           off_t offset);
+
+// Plugin methods.
+
+// Load one plugin library.
+
+void
+Plugin::load()
+{
+#ifdef ENABLE_PLUGINS
+  std::string filename;
+  std::vector<std::string> args;
+
+  // Parse the filename and arguments, each separated by commas.
+  // FIXME:  Temporarily allowing semicolon as an argument separator
+  // so args can be passed through gcc's -Wl,... option, which
+  // breaks arguments at the commas.
+  const char* p = this->args_;
+  int n = strcspn(p, ",;");
+  filename.assign(p, n);
+  p += n;
+  while (*p == ',' || *p == ';')
+    {
+      ++p;
+      n = strcspn(p, ",;");
+      args.push_back(std::string(p, n));
+      p += n;
+    }
+
+  // Load the plugin library.
+  // FIXME: Look for the library in standard locations.
+  this->handle_ = dlopen(filename.c_str(), RTLD_NOW);
+  if (this->handle_ == NULL)
+    {
+      gold_error(_("%s: could not load plugin library"), filename.c_str());
+      return;
+    }
+
+  // Find the plugin's onload entry point.
+  ld_plugin_onload onload = reinterpret_cast<ld_plugin_onload>
+    (dlsym(this->handle_, "onload"));
+  if (onload == NULL)
+    {
+      gold_error(_("%s: could not find onload entry point"), filename.c_str());
+      return;
+    }
+
+  // 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 = 11;
+  int tv_size = args.size() + tv_fixed_size;
+  ld_plugin_tv *tv = new ld_plugin_tv[tv_size];
+
+  int i = 0;
+  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;
+
+  for (unsigned int j = 0; j < args.size(); ++j)
+    {
+      ++i;
+      tv[i].tv_tag = LDPT_OPTION;
+      tv[i].tv_u.tv_string = 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_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_MESSAGE;
+  tv[i].tv_u.tv_message = message;
+
+  ++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_handler_)();
+}
+
+// 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_))
+        {
+          if (this->objects_.size() <= handle)
+            {
+              gold_error(_("%s: plugin claimed the file "
+                           "but did not provide any symbols"),
+                         this->plugin_input_file_.name);
+              return NULL;
+            }
+          return this->objects_[handle];
+        }
+    }
+
+  return NULL;
+}
+
+// Call the all-symbols-read handlers.
+
+void
+Plugin_manager::all_symbols_read(Workqueue* workqueue,
+                                 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->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();
+
+  *last_blocker = this->this_blocker_;
+}
+
+// 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->objects_.push_back(obj);
+  return obj;
+}
+
+// Add a new input file.
+
+ld_plugin_status
+Plugin_manager::add_input_file(char *pathname)
+{
+  Input_file_argument file(pathname, false, "", 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_,
+                                                this->symtab_,
+                                                this->layout_,
+                                                this->dirpath_,
+                                                this->mapfile_,
+                                                input_argument,
+                                                NULL,
+                                                this->this_blocker_,
+                                                next_blocker));
+  this->this_blocker_ = next_blocker;
+  return LDPS_OK;
+}
+
+// Class Pluginobj.
+
+Pluginobj::Pluginobj(const std::string& name, Input_file* input_file,
+                     off_t offset)
+  : Object(name, input_file, false, offset),
+    nsyms_(0), syms_(NULL), symbols_(), comdat_map_()
+{
+}
+
+// Get symbol resolution info.
+
+ld_plugin_status
+Pluginobj::get_symbol_resolution_info(int nsyms, ld_plugin_symbol* syms) const
+{
+  if (this->nsyms_ == 0)
+    return LDPS_NO_SYMS;
+  for (int i = 0; i < nsyms; i++)
+    {
+      ld_plugin_symbol* isym = &syms[i];
+      Symbol* lsym = this->symbols_[i];
+      ld_plugin_symbol_resolution res = LDPR_UNKNOWN;
+
+      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)
+        {
+          // The original symbol was undefined or common.
+          if (lsym->source() != Symbol::FROM_OBJECT)
+            res = LDPR_RESOLVED_EXEC;
+          else if (lsym->object()->pluginobj() != NULL)
+            res = LDPR_RESOLVED_IR;
+          else if (lsym->object()->is_dynamic())
+            res = LDPR_RESOLVED_DYN;
+          else
+            res = LDPR_RESOLVED_EXEC;
+        }
+      else
+        {
+          // The original symbol was a definition.
+          if (lsym->source() != Symbol::FROM_OBJECT)
+            res = LDPR_PREEMPTED_REG;
+          else if (lsym->object() == static_cast<const Object*>(this))
+            res = (lsym->in_real_elf()
+                   ? LDPR_PREVAILING_DEF
+                   : LDPR_PREVAILING_DEF_IRONLY);
+          else
+            res = (lsym->object()->pluginobj() != NULL
+                   ? LDPR_PREEMPTED_IR
+                   : LDPR_PREEMPTED_REG);
+        }
+      isym->resolution = res;
+    }
+  return LDPS_OK;
+}
+
+// Return TRUE if the comdat group with key COMDAT_KEY from this object
+// should be kept.
+
+bool
+Pluginobj::include_comdat_group(std::string comdat_key, Layout* layout)
+{
+  std::pair<Comdat_map::iterator, bool> ins =
+    this->comdat_map_.insert(std::make_pair(comdat_key, false));
+
+  // 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);
+
+  return ins.first->second;
+}
+
+// Class Sized_pluginobj.
+
+template<int size, bool big_endian>
+Sized_pluginobj<size, big_endian>::Sized_pluginobj(
+    const std::string& name,
+    Input_file* input_file,
+    off_t offset)
+  : Pluginobj(name, input_file, offset)
+{
+}
+
+// Read the symbols.  Not used for plugin objects.
+
+template<int size, bool big_endian>
+void
+Sized_pluginobj<size, big_endian>::do_read_symbols(Read_symbols_data*)
+{
+  gold_unreachable();
+}
+
+// Lay out the input sections.  Not used for plugin objects.
+
+template<int size, bool big_endian>
+void
+Sized_pluginobj<size, big_endian>::do_layout(Symbol_table*, Layout*,
+                                             Read_symbols_data*)
+{
+  gold_unreachable();
+}
+
+// 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,
+                                                  Layout* layout)
+{
+  const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
+  unsigned char symbuf[sym_size];
+  elfcpp::Sym<size, big_endian> sym(symbuf);
+  elfcpp::Sym_write<size, big_endian> osym(symbuf);
+
+  typedef typename elfcpp::Elf_types<size>::Elf_WXword Elf_size_type;
+
+  this->symbols_.resize(this->nsyms_);
+
+  for (int i = 0; i < this->nsyms_; ++i)
+    {
+      const struct ld_plugin_symbol *isym = &this->syms_[i];
+      const char* name = isym->name;
+      const char* ver = isym->version;
+      elfcpp::Elf_Half shndx;
+      elfcpp::STB bind;
+      elfcpp::STV vis;
+
+      if (name != NULL && name[0] == '\0')
+        name = NULL;
+      if (ver != NULL && ver[0] == '\0')
+        ver = NULL;
+
+      switch (isym->def)
+        {
+        case LDPK_WEAKDEF:
+        case LDPK_WEAKUNDEF:
+          bind = elfcpp::STB_WEAK;
+          break;
+        case LDPK_DEF:
+        case LDPK_UNDEF:
+        case LDPK_COMMON:
+        default:
+          bind = elfcpp::STB_GLOBAL;
+          break;
+        }
+
+      switch (isym->def)
+        {
+        case LDPK_DEF:
+        case LDPK_WEAKDEF:
+          shndx = elfcpp::SHN_ABS;
+          break;
+        case LDPK_COMMON:
+          shndx = elfcpp::SHN_COMMON;
+          break;
+        case LDPK_UNDEF:
+        case LDPK_WEAKUNDEF:
+        default:
+          shndx = elfcpp::SHN_UNDEF;
+          break;
+        }
+
+      switch (isym->visibility)
+        {
+        case LDPV_PROTECTED:
+          vis = elfcpp::STV_DEFAULT;
+          break;
+        case LDPV_INTERNAL:
+          vis = elfcpp::STV_DEFAULT;
+          break;
+        case LDPV_HIDDEN:
+          vis = elfcpp::STV_DEFAULT;
+          break;
+        case LDPV_DEFAULT:
+        default:
+          vis = elfcpp::STV_DEFAULT;
+          break;
+        }
+
+      if (isym->comdat_key != NULL
+          && isym->comdat_key[0] != '\0'
+          && !this->include_comdat_group(isym->comdat_key, layout))
+        shndx = elfcpp::SHN_UNDEF;
+
+      osym.put_st_name(0);
+      osym.put_st_value(0);
+      osym.put_st_size(static_cast<Elf_size_type>(isym->size));
+      osym.put_st_info(bind, elfcpp::STT_NOTYPE);
+      osym.put_st_other(vis, 0);
+      osym.put_st_shndx(shndx);
+
+      this->symbols_[i] =
+        symtab->add_from_pluginobj<size, big_endian>(this, name, ver, &sym);
+    }
+}
+
+// Get the size of a section.  Not used for plugin objects.
+
+template<int size, bool big_endian>
+uint64_t
+Sized_pluginobj<size, big_endian>::do_section_size(unsigned int)
+{
+  gold_unreachable();
+  return 0;
+}
+
+// Get the name of a section.  Not used for plugin objects.
+
+template<int size, bool big_endian>
+std::string
+Sized_pluginobj<size, big_endian>::do_section_name(unsigned int)
+{
+  gold_unreachable();
+  return std::string();
+}
+
+// Return a view of the contents of a section.  Not used for plugin objects.
+
+template<int size, bool big_endian>
+Object::Location
+Sized_pluginobj<size, big_endian>::do_section_contents(unsigned int)
+{
+  Location loc(0, 0);
+
+  gold_unreachable();
+  return loc;
+}
+
+// Return section flags.  Not used for plugin objects.
+
+template<int size, bool big_endian>
+uint64_t
+Sized_pluginobj<size, big_endian>::do_section_flags(unsigned int)
+{
+  gold_unreachable();
+  return 0;
+}
+
+// Return section address.  Not used for plugin objects.
+
+template<int size, bool big_endian>
+uint64_t
+Sized_pluginobj<size, big_endian>::do_section_address(unsigned int)
+{
+  gold_unreachable();
+  return 0;
+}
+
+// Return section type.  Not used for plugin objects.
+
+template<int size, bool big_endian>
+unsigned int
+Sized_pluginobj<size, big_endian>::do_section_type(unsigned int)
+{
+  gold_unreachable();
+  return 0;
+}
+
+// Return the section link field.  Not used for plugin objects.
+
+template<int size, bool big_endian>
+unsigned int
+Sized_pluginobj<size, big_endian>::do_section_link(unsigned int)
+{
+  gold_unreachable();
+  return 0;
+}
+
+// Return the section link field.  Not used for plugin objects.
+
+template<int size, bool big_endian>
+unsigned int
+Sized_pluginobj<size, big_endian>::do_section_info(unsigned int)
+{
+  gold_unreachable();
+  return 0;
+}
+
+// Return the section alignment.  Not used for plugin objects.
+
+template<int size, bool big_endian>
+uint64_t
+Sized_pluginobj<size, big_endian>::do_section_addralign(unsigned int)
+{
+  gold_unreachable();
+  return 0;
+}
+
+// Return the Xindex structure to use.  Not used for plugin objects.
+
+template<int size, bool big_endian>
+Xindex*
+Sized_pluginobj<size, big_endian>::do_initialize_xindex()
+{
+  gold_unreachable();
+  return NULL;
+}
+
+// Get symbol counts.  Not used for plugin objects.
+
+template<int size, bool big_endian>
+void
+Sized_pluginobj<size, big_endian>::do_get_global_symbol_counts(const Symbol_table*,
+                                                   size_t*, size_t*) const
+{
+  gold_unreachable();
+}
+
+// Class Add_plugin_symbols.
+
+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*)
+{
+  this->obj_->add_symbols(this->symtab_, this->layout_);
+}
+
+// Class Plugin_cleanup.  This task calls the plugin cleanup hooks once all
+// replacement files have been added.
+
+class Plugin_cleanup : public Task
+{
+ public:
+  Plugin_cleanup(Task_token* this_blocker, Task_token* next_blocker)
+    : this_blocker_(this_blocker), next_blocker_(next_blocker)
+  { }
+
+  ~Plugin_cleanup()
+  {
+    if (this->this_blocker_ != NULL)
+      delete this->this_blocker_;
+  }
+
+  Task_token*
+  is_runnable()
+  {
+    if (this->this_blocker_ != NULL && 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()->cleanup(); }
+
+  std::string
+  get_name() const
+  { return "Plugin_cleanup"; }
+
+ private:
+  Task_token* this_blocker_;
+  Task_token* next_blocker_;
+};
+
+// Class Plugin_hook.
+
+Plugin_hook::~Plugin_hook()
+{
+}
+
+// Return whether a Plugin_hook task is runnable.
+
+Task_token*
+Plugin_hook::is_runnable()
+{
+  if (this->this_blocker_ != NULL && this->this_blocker_->is_blocked())
+    return this->this_blocker_;
+  return NULL;
+}
+
+// Return a Task_locker for a Plugin_hook task.  We don't need any
+// locks here.
+
+void
+Plugin_hook::locks(Task_locker*)
+{
+}
+
+// Run a Plugin_hook task.
+
+void
+Plugin_hook::run(Workqueue* workqueue)
+{
+  this->do_plugin_hook(workqueue);
+}
+
+// Run the "all symbols read" plugin hook.
+
+void
+Plugin_hook::do_plugin_hook(Workqueue* workqueue)
+{
+  gold_assert(this->options_.has_plugins());
+  this->options_.plugins()->all_symbols_read(workqueue,
+                                             this->input_objects_,
+                                             this->symtab_,
+                                             this->layout_,
+                                             this->dirpath_,
+                                             this->mapfile_,
+                                             &this->this_blocker_);
+  workqueue->queue_soon(new Plugin_cleanup(this->this_blocker_,
+					   this->next_blocker_));
+}
+
+// The C interface routines called by the plugins.
+
+#ifdef ENABLE_PLUGINS
+
+// Register a claim-file handler.
+
+static enum ld_plugin_status
+register_claim_file(ld_plugin_claim_file_handler handler)
+{
+  gold_assert(parameters->options().has_plugins());
+  parameters->options().plugins()->set_claim_file_handler(handler);
+  return LDPS_OK;
+}
+
+// Register an all-symbols-read handler.
+
+static enum ld_plugin_status
+register_all_symbols_read(ld_plugin_all_symbols_read_handler handler)
+{
+  gold_assert(parameters->options().has_plugins());
+  parameters->options().plugins()->set_all_symbols_read_handler(handler);
+  return LDPS_OK;
+}
+
+// Register a cleanup handler.
+
+static enum ld_plugin_status
+register_cleanup(ld_plugin_cleanup_handler handler)
+{
+  gold_assert(parameters->options().has_plugins());
+  parameters->options().plugins()->set_cleanup_handler(handler);
+  return LDPS_OK;
+}
+
+// Add symbols from a plugin-claimed input file.
+
+static enum ld_plugin_status
+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(
+      static_cast<unsigned int>(reinterpret_cast<intptr_t>(handle)));
+  if (obj == NULL)
+    return LDPS_ERR;
+  obj->store_incoming_symbols(nsyms, syms);
+  return LDPS_OK;
+}
+
+// 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)
+{
+  gold_assert(parameters->options().has_plugins());
+  Pluginobj* obj = parameters->options().plugins()->object(
+      static_cast<unsigned int>(reinterpret_cast<intptr_t>(handle)));
+  if (obj == NULL)
+    return LDPS_ERR;
+  return obj->get_symbol_resolution_info(nsyms, syms);
+}
+
+// Add a new (real) input file generated by a plugin.
+
+static enum ld_plugin_status
+add_input_file(char *pathname)
+{
+  gold_assert(parameters->options().has_plugins());
+  return parameters->options().plugins()->add_input_file(pathname);
+}
+
+// Issue a diagnostic message from a plugin.
+
+static enum ld_plugin_status
+message(int level, char * format, ...)
+{
+  va_list args;
+  va_start(args, format);
+
+  switch (level)
+    {
+    case LDPL_INFO:
+      parameters->errors()->info(format, args);
+      break;
+    case LDPL_WARNING:
+      parameters->errors()->warning(format, args);
+      break;
+    case LDPL_ERROR:
+    default:
+      parameters->errors()->error(format, args);
+      break;
+    case LDPL_FATAL:
+      parameters->errors()->fatal(format, args);
+      break;
+    }
+
+  va_end(args);
+  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)
+{
+  Target* target;
+  Pluginobj* obj = NULL;
+
+  if (parameters->target_valid())
+    target = const_cast<Target*>(&parameters->target());
+  else
+    target = const_cast<Target*>(&parameters->default_target());
+
+  if (target->get_size() == 32)
+    {
+#ifdef HAVE_TARGET_32_BIG
+      if (target->is_big_endian())
+        obj = new Sized_pluginobj<32, true>(input_file->filename(),
+                                            input_file, offset);
+#endif
+#ifdef HAVE_TARGET_32_LITTLE
+      else
+        obj = new Sized_pluginobj<32, false>(input_file->filename(),
+                                             input_file, offset);
+#endif
+    }
+  else if (target->get_size() == 64)
+    {
+#ifdef HAVE_TARGET_64_BIG
+      if (target->is_big_endian())
+        obj = new Sized_pluginobj<64, true>(input_file->filename(),
+                                            input_file, offset);
+#endif
+#ifdef HAVE_TARGET_64_LITTLE
+      else
+        obj = new Sized_pluginobj<64, false>(input_file->filename(),
+                                             input_file, offset);
+#endif
+    }
+
+  gold_assert(obj != NULL);
+  obj->set_target(target);
+  return obj;
+}
+
+} // End namespace gold.