From 89fc34211be8b1d74b83e4e2b18cfa4b4cf65ba9 Mon Sep 17 00:00:00 2001 From: Cary Coutant Date: Fri, 19 Sep 2008 22:54:57 +0000 Subject: 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. --- gold/plugin.h | 457 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 457 insertions(+) create mode 100644 gold/plugin.h (limited to 'gold/plugin.h') diff --git a/gold/plugin.h b/gold/plugin.h new file mode 100644 index 00000000000..3f573ced27b --- /dev/null +++ b/gold/plugin.h @@ -0,0 +1,457 @@ +// plugin.h -- plugin manager for gold -*- C++ -*- + +// Copyright 2008 Free Software Foundation, Inc. +// Written by Cary Coutant . + +// 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. + +#ifndef GOLD_PLUGIN_H +#define GOLD_PLUGIN_H + +#include +#include + +#include "object.h" +#include "plugin-api.h" +#include "workqueue.h" + +namespace gold +{ + +class General_options; +class Input_file; +class Input_objects; +class Symbol_table; +class Layout; +class Dirsearch; +class Mapfile; +class Task_token; +class Pluginobj; + +// This class represents a single plugin library. + +class Plugin +{ + public: + Plugin(const char* args) + : handle_(NULL), + args_(args), + claim_file_handler_(NULL), + all_symbols_read_handler_(NULL), + cleanup_handler_(NULL) + { } + + ~Plugin() + { } + + // Load the library and call its entry point. + void + load(); + + // Call the claim-file handler. + bool + claim_file(struct ld_plugin_input_file *plugin_input_file); + + // Call the all-symbols-read handler. + void + all_symbols_read(); + + // Call the cleanup handler. + void + cleanup(); + + // Register a claim-file handler. + void + set_claim_file_handler(ld_plugin_claim_file_handler handler) + { this->claim_file_handler_ = handler; } + + // Register an all-symbols-read handler. + void + set_all_symbols_read_handler(ld_plugin_all_symbols_read_handler handler) + { this->all_symbols_read_handler_ = handler; } + + // Register a claim-file handler. + void + set_cleanup_handler(ld_plugin_cleanup_handler handler) + { this->cleanup_handler_ = handler; } + + private: + Plugin(const Plugin&); + Plugin& operator=(const Plugin&); + + // The shared library handle returned by dlopen. + void* handle_; + // The argument string given to --plugin. + const char* args_; + // The plugin's event handlers. + ld_plugin_claim_file_handler claim_file_handler_; + ld_plugin_all_symbols_read_handler all_symbols_read_handler_; + ld_plugin_cleanup_handler cleanup_handler_; +}; + +// A manager class for plugins. + +class Plugin_manager +{ + public: + Plugin_manager(const General_options& options) + : plugins_(), in_replacement_phase_(false), options_(options), + workqueue_(NULL), input_objects_(NULL), symtab_(NULL), layout_(NULL), + dirpath_(NULL), mapfile_(NULL), this_blocker_(NULL) + { this->current_ = plugins_.end(); } + + ~Plugin_manager(); + + // Add a plugin library. + void + add_plugin(const char* args) + { this->plugins_.push_back(new Plugin(args)); } + + // Load all plugin libraries. + void + load_plugins(); + + // Call the plugin claim-file handlers in turn to see if any claim the file. + Pluginobj* + claim_file(Input_file *input_file, off_t offset, off_t filesize); + + // Call the all-symbols-read handlers. + void + all_symbols_read(Workqueue* workqueue, Input_objects* input_objects, + Symbol_table* symtab, Layout* layout, Dirsearch* dirpath, + Mapfile* mapfile, Task_token** last_blocker); + + // Call the cleanup handlers. + void + cleanup(); + + // Register a claim-file handler. + void + set_claim_file_handler(ld_plugin_claim_file_handler handler) + { + gold_assert(this->current_ != plugins_.end()); + (*this->current_)->set_claim_file_handler(handler); + } + + // Register an all-symbols-read handler. + void + set_all_symbols_read_handler(ld_plugin_all_symbols_read_handler handler) + { + gold_assert(this->current_ != plugins_.end()); + (*this->current_)->set_all_symbols_read_handler(handler); + } + + // Register a claim-file handler. + void + set_cleanup_handler(ld_plugin_cleanup_handler handler) + { + gold_assert(this->current_ != plugins_.end()); + (*this->current_)->set_cleanup_handler(handler); + } + + // Make a new Pluginobj object. This is called when the plugin calls + // the add_symbols API. + Pluginobj* + make_plugin_object(unsigned int handle); + + // Return the Pluginobj associated with the given HANDLE. + Pluginobj* + object(unsigned int handle) const + { + if (handle >= this->objects_.size()) + return NULL; + return this->objects_[handle]; + } + + // Add a new input file. + ld_plugin_status + add_input_file(char *pathname); + + // Return TRUE if we are in the replacement phase. + bool + in_replacement_phase() const + { return this->in_replacement_phase_; } + + private: + Plugin_manager(const Plugin_manager&); + Plugin_manager& operator=(const Plugin_manager&); + + typedef std::list Plugin_list; + typedef std::vector Object_list; + + // The list of plugin libraries. + Plugin_list plugins_; + // A pointer to the current plugin. Used while loading plugins. + Plugin_list::iterator current_; + + // The list of plugin objects. The index of an item in this list + // serves as the "handle" that we pass to the plugins. + Object_list objects_; + + // The file currently up for claim by the plugins. + Input_file* input_file_; + struct ld_plugin_input_file plugin_input_file_; + + // TRUE after the all symbols read event; indicates that we are + // processing replacement files whose symbols should replace the + // placeholder symbols from the Pluginobj objects. + bool in_replacement_phase_; + + const General_options& options_; + Workqueue* workqueue_; + Input_objects* input_objects_; + Symbol_table* symtab_; + Layout* layout_; + Dirsearch* dirpath_; + Mapfile* mapfile_; + Task_token* this_blocker_; +}; + + +// An object file claimed by a plugin. This is an abstract base class. +// The implementation is the template class Sized_pluginobj. + +class Pluginobj : public Object +{ + public: + + typedef std::vector Symbols; + + Pluginobj(const std::string& name, Input_file* input_file, off_t offset); + + // Fill in the symbol resolution status for the given plugin symbols. + ld_plugin_status + get_symbol_resolution_info(int nsyms, ld_plugin_symbol* syms) const; + + // Add symbol information to the global symbol table. + void + add_symbols(Symbol_table* symtab, Layout* layout) + { this->do_add_symbols(symtab, layout); } + + // Store the incoming symbols from the plugin for later processing. + void + store_incoming_symbols(int nsyms, const struct ld_plugin_symbol* syms) + { + this->nsyms_ = nsyms; + this->syms_ = syms; + } + + // Return TRUE if the comdat group with key COMDAT_KEY from this object + // should be kept. + bool + include_comdat_group(std::string comdat_key, Layout* layout); + + protected: + // Return TRUE if this is an object claimed by a plugin. + virtual Pluginobj* + do_pluginobj() + { return this; } + + // Add symbol information to the global symbol table--implemented by + // child class. + virtual void + do_add_symbols(Symbol_table*, Layout*) = 0; + + // The number of symbols provided by the plugin. + int nsyms_; + + // The symbols provided by the plugin. + const struct ld_plugin_symbol* syms_; + + // The entries in the symbol table for the external symbols. + Symbols symbols_; + + private: + // Map a comdat key symbol to a boolean indicating whether the comdat + // group in this object with that key should be kept. + typedef Unordered_map Comdat_map; + Comdat_map comdat_map_; +}; + +// A plugin object, size-specific version. + +template +class Sized_pluginobj : public Pluginobj +{ + public: + Sized_pluginobj(const std::string& name, Input_file* input_file, + off_t offset); + + // Read the symbols. + void + do_read_symbols(Read_symbols_data*); + + // Lay out the input sections. + void + do_layout(Symbol_table*, Layout*, Read_symbols_data*); + + // Add the symbols to the symbol table. + void + do_add_symbols(Symbol_table*, Read_symbols_data*); + + void + do_add_symbols(Symbol_table*, Layout*); + + // Get the size of a section. + uint64_t + do_section_size(unsigned int shndx); + + // Get the name of a section. + std::string + do_section_name(unsigned int shndx); + + // Return a view of the contents of a section. + Object::Location + do_section_contents(unsigned int shndx); + + // Return section flags. + uint64_t + do_section_flags(unsigned int shndx); + + // Return section address. + uint64_t + do_section_address(unsigned int shndx); + + // Return section type. + unsigned int + do_section_type(unsigned int shndx); + + // Return the section link field. + unsigned int + do_section_link(unsigned int shndx); + + // Return the section link field. + unsigned int + do_section_info(unsigned int shndx); + + // Return the section alignment. + uint64_t + do_section_addralign(unsigned int shndx); + + // Return the Xindex structure to use. + Xindex* + do_initialize_xindex(); + + // Get symbol counts. + void + do_get_global_symbol_counts(const Symbol_table*, size_t*, size_t*) const; + + // Add placeholder symbols from a claimed file. + ld_plugin_status + add_symbols_from_plugin(int nsyms, const ld_plugin_symbol* syms); + + protected: + + private: +}; + +// This Task handles adding the symbols to the symbol table. These +// tasks must be run in the same order as the arguments appear on the +// command line. + +class Add_plugin_symbols : public Task +{ + public: + // THIS_BLOCKER is used to prevent this task from running before the + // one for the previous input file. NEXT_BLOCKER is used to prevent + // the next task from running. + Add_plugin_symbols(Symbol_table* symtab, + Layout* layout, + Pluginobj* obj, + Task_token* this_blocker, + Task_token* next_blocker) + : symtab_(symtab), layout_(layout), obj_(obj), + this_blocker_(this_blocker), next_blocker_(next_blocker) + { } + + ~Add_plugin_symbols(); + + // The standard Task methods. + + Task_token* + is_runnable(); + + void + locks(Task_locker*); + + void + run(Workqueue*); + + std::string + get_name() const + { return "Add_plugin_symbols " + this->obj_->name(); } + +private: + Symbol_table* symtab_; + Layout* layout_; + Pluginobj* obj_; + Task_token* this_blocker_; + Task_token* next_blocker_; +}; + +// This Task handles handles the "all symbols read" event hook. +// The plugin may add additional input files at this time, which must +// be queued for reading. + +class Plugin_hook : public Task +{ + public: + Plugin_hook(const General_options& options, Input_objects* input_objects, + Symbol_table* symtab, Layout* layout, Dirsearch* dirpath, + Mapfile* mapfile, Task_token* this_blocker, + Task_token* next_blocker) + : options_(options), input_objects_(input_objects), symtab_(symtab), + layout_(layout), dirpath_(dirpath), mapfile_(mapfile), + this_blocker_(this_blocker), next_blocker_(next_blocker) + { } + + ~Plugin_hook(); + + // The standard Task methods. + + Task_token* + is_runnable(); + + void + locks(Task_locker*); + + void + run(Workqueue*); + + std::string + get_name() const + { return "Plugin_hook"; } + + private: + // Call the plugin hook. + void + do_plugin_hook(Workqueue*); + + const General_options& options_; + Input_objects* input_objects_; + Symbol_table* symtab_; + Layout* layout_; + Dirsearch* dirpath_; + Mapfile* mapfile_; + Task_token* this_blocker_; + Task_token* next_blocker_; +}; + +} // End namespace gold. + +#endif // !defined(GOLD_PLUGIN_H) -- cgit v1.2.1