diff options
author | Andrew Hsieh <andrewhsieh@google.com> | 2014-06-13 12:38:00 -0700 |
---|---|---|
committer | Andrew Hsieh <andrewhsieh@google.com> | 2014-06-13 12:38:00 -0700 |
commit | 54f1b3cf509cd889905287cb8ce6c5ae33911a21 (patch) | |
tree | e39b1a7fa04db86a8215b7f9d4656d74e394aec0 /binutils-2.25/gold/plugin.h | |
parent | 2a6558a8ecfb81d75215b4ec7dc61113e12cfd5f (diff) | |
download | toolchain_binutils-54f1b3cf509cd889905287cb8ce6c5ae33911a21.zip toolchain_binutils-54f1b3cf509cd889905287cb8ce6c5ae33911a21.tar.gz toolchain_binutils-54f1b3cf509cd889905287cb8ce6c5ae33911a21.tar.bz2 |
Add upstream binutils-2.25 snapshot 4/4 2014
For MIPS -mmsa support
Change-Id: I08c4f002fa7b33dec85ed75956e6ab551bb03c96
Diffstat (limited to 'binutils-2.25/gold/plugin.h')
-rw-r--r-- | binutils-2.25/gold/plugin.h | 594 |
1 files changed, 594 insertions, 0 deletions
diff --git a/binutils-2.25/gold/plugin.h b/binutils-2.25/gold/plugin.h new file mode 100644 index 0000000..e4289ff --- /dev/null +++ b/binutils-2.25/gold/plugin.h @@ -0,0 +1,594 @@ +// plugin.h -- plugin manager for gold -*- C++ -*- + +// Copyright 2008, 2009, 2010, 2011, 2013 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. + +#ifndef GOLD_PLUGIN_H +#define GOLD_PLUGIN_H + +#include <list> +#include <string> + +#include "object.h" +#include "plugin-api.h" +#include "workqueue.h" + +namespace gold +{ + +class General_options; +class Input_file; +class Input_objects; +class Archive; +class Input_group; +class Symbol; +class Symbol_table; +class Layout; +class Dirsearch; +class Mapfile; +class Task; +class Task_token; +class Pluginobj; +class Plugin_rescan; + +// This class represents a single plugin library. + +class Plugin +{ + public: + Plugin(const char* filename) + : handle_(NULL), + filename_(filename), + args_(), + claim_file_handler_(NULL), + all_symbols_read_handler_(NULL), + cleanup_handler_(NULL), + cleanup_done_(false) + { } + + ~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; } + + // Add an argument + void + add_option(const char* arg) + { + this->args_.push_back(arg); + } + + private: + Plugin(const Plugin&); + Plugin& operator=(const Plugin&); + + // The shared library handle returned by dlopen. + void* handle_; + // The argument string given to --plugin. + std::string filename_; + // The list of argument string given to --plugin-opt. + std::vector<std::string> 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_; + // TRUE if the cleanup handlers have been called. + bool cleanup_done_; +}; + +// A manager class for plugins. + +class Plugin_manager +{ + public: + Plugin_manager(const General_options& options) + : plugins_(), objects_(), deferred_layout_objects_(), input_file_(NULL), + plugin_input_file_(), rescannable_(), undefined_symbols_(), + any_claimed_(false), in_replacement_phase_(false), any_added_(false), + in_claim_file_handler_(false), + options_(options), workqueue_(NULL), task_(NULL), input_objects_(NULL), + symtab_(NULL), layout_(NULL), dirpath_(NULL), mapfile_(NULL), + this_blocker_(NULL), extra_search_path_() + { this->current_ = plugins_.end(); } + + ~Plugin_manager(); + + // Add a plugin library. + void + add_plugin(const char* filename) + { this->plugins_.push_back(new Plugin(filename)); } + + // Add an argument to the current plugin. + void + add_plugin_option(const char* opt) + { + Plugin* last = this->plugins_.back(); + last->add_option(opt); + } + + // Load all plugin libraries. + void + load_plugins(Layout* layout); + + // 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, + Object* elf_object); + + // Get the object associated with the handle and check if it is an elf object. + // If it is not a Pluginobj, it is an elf object. + Object* + get_elf_object(const void* handle); + + // True if the claim_file handler of the plugins is being called. + bool + in_claim_file_handler() + { return in_claim_file_handler_; } + + // Let the plugin manager save an archive for later rescanning. + // This takes ownership of the Archive pointer. + void + save_archive(Archive*); + + // Let the plugin manager save an input group for later rescanning. + // This takes ownership of the Input_group pointer. + void + save_input_group(Input_group*); + + // Call the all-symbols-read handlers. + void + all_symbols_read(Workqueue* workqueue, Task* task, + Input_objects* input_objects, Symbol_table* symtab, + Dirsearch* dirpath, Mapfile* mapfile, + Task_token** last_blocker); + + // Tell the plugin manager that we've a new undefined symbol which + // may require rescanning. + void + new_undefined_symbol(Symbol*); + + // Run deferred layout. + void + layout_deferred_objects(); + + // 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 object associated with the given HANDLE. + Object* + object(unsigned int handle) const + { + if (handle >= this->objects_.size()) + return NULL; + return this->objects_[handle]; + } + + // Return TRUE if any input files have been claimed by a plugin + // and we are still in the initial input phase. + bool + should_defer_layout() const + { return this->any_claimed_ && !this->in_replacement_phase_; } + + // Add a regular object to the deferred layout list. These are + // objects whose layout has been deferred until after the + // replacement files have arrived. + void + add_deferred_layout_object(Relobj* obj) + { this->deferred_layout_objects_.push_back(obj); } + + // Get input file information with an open (possibly re-opened) + // file descriptor. + ld_plugin_status + get_input_file(unsigned int handle, struct ld_plugin_input_file* file); + + ld_plugin_status + get_view(unsigned int handle, const void **viewp); + + // Release an input file. + ld_plugin_status + release_input_file(unsigned int handle); + + // Add a new input file. + ld_plugin_status + add_input_file(const char* pathname, bool is_lib); + + // Set the extra library path. + ld_plugin_status + set_extra_library_path(const char* path); + + // Return TRUE if we are in the replacement phase. + bool + in_replacement_phase() const + { return this->in_replacement_phase_; } + + Input_objects* + input_objects() const + { return this->input_objects_; } + + Layout* + layout() + { return this->layout_; } + + private: + Plugin_manager(const Plugin_manager&); + Plugin_manager& operator=(const Plugin_manager&); + + // Plugin_rescan is a Task which calls the private rescan method. + friend class Plugin_rescan; + + // An archive or input group which may have to be rescanned if a + // plugin adds a new file. + struct Rescannable + { + bool is_archive; + union + { + Archive* archive; + Input_group* input_group; + } u; + + Rescannable(Archive* archive) + : is_archive(true) + { this->u.archive = archive; } + + Rescannable(Input_group* input_group) + : is_archive(false) + { this->u.input_group = input_group; } + }; + + typedef std::list<Plugin*> Plugin_list; + typedef std::vector<Object*> Object_list; + typedef std::vector<Relobj*> Deferred_layout_list; + typedef std::vector<Rescannable> Rescannable_list; + typedef std::vector<Symbol*> Undefined_symbol_list; + + // Rescan archives for undefined symbols. + void + rescan(Task*); + + // See whether the rescannable at index I defines SYM. + bool + rescannable_defines(size_t i, Symbol* sym); + + // 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 list of regular objects whose layout has been deferred. + Deferred_layout_list deferred_layout_objects_; + + // The file currently up for claim by the plugins. + Input_file* input_file_; + struct ld_plugin_input_file plugin_input_file_; + + // A list of archives and input groups being saved for possible + // later rescanning. + Rescannable_list rescannable_; + + // A list of undefined symbols found in added files. + Undefined_symbol_list undefined_symbols_; + + // Whether any input files have been claimed by a plugin. + bool any_claimed_; + + // Set to 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_; + + // Whether any input files or libraries were added by a plugin. + bool any_added_; + + // Set to true when the claim_file handler of a plugin is called. + bool in_claim_file_handler_; + + const General_options& options_; + Workqueue* workqueue_; + Task* task_; + Input_objects* input_objects_; + Symbol_table* symtab_; + Layout* layout_; + Dirsearch* dirpath_; + Mapfile* mapfile_; + Task_token* this_blocker_; + + // An extra directory to seach for the libraries passed by + // add_input_library. + std::string extra_search_path_; +}; + + +// 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<Symbol*> Symbols; + + Pluginobj(const std::string& name, Input_file* input_file, off_t offset, + off_t filesize); + + // Fill in the symbol resolution status for the given plugin symbols. + ld_plugin_status + get_symbol_resolution_info(int nsyms, + ld_plugin_symbol* syms, + int version) const; + + // 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); + + // Return the filename. + const std::string& + filename() const + { return this->input_file()->filename(); } + + // Return the file descriptor. + int + descriptor() + { return this->input_file()->file().descriptor(); } + + // Return the size of the file or archive member. + off_t + filesize() + { return this->filesize_; } + + protected: + // Return TRUE if this is an object claimed by a plugin. + virtual Pluginobj* + do_pluginobj() + { return this; } + + // 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: + // Size of the file (or archive member). + off_t filesize_; + // 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<std::string, bool> Comdat_map; + Comdat_map comdat_map_; +}; + +// A plugin object, size-specific version. + +template<int size, bool big_endian> +class Sized_pluginobj : public Pluginobj +{ + public: + Sized_pluginobj(const std::string& name, Input_file* input_file, + off_t offset, off_t filesize); + + // 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*, Layout*); + + Archive::Should_include + do_should_include_member(Symbol_table* symtab, Layout*, Read_symbols_data*, + std::string* why); + + // Iterate over global symbols, calling a visitor class V for each. + void + do_for_all_global_symbols(Read_symbols_data* sd, + Library_base::Symbol_visitor_base* v); + + // Iterate over local symbols, calling a visitor class V for each GOT offset + // associated with a local symbol. + void + do_for_all_local_got_entries(Got_offset_list::Visitor* v) const; + + // 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. + const unsigned char* + do_section_contents(unsigned int shndx, section_size_type* plen, + bool cache); + + // Return section flags. + uint64_t + do_section_flags(unsigned int shndx); + + // Return section entsize. + uint64_t + do_section_entsize(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; + + // Get global symbols. + const Symbols* + do_get_global_symbols() 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 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), + 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: + const General_options& options_; + Input_objects* input_objects_; + Symbol_table* symtab_; + Dirsearch* dirpath_; + Mapfile* mapfile_; + Task_token* this_blocker_; + Task_token* next_blocker_; +}; + +} // End namespace gold. + +#endif // !defined(GOLD_PLUGIN_H) |