URL
https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk
Subversion Repositories openrisc_2011-10-31
[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.20.1/] [gold/] [plugin.h] - Rev 207
Go to most recent revision | Compare with Previous | Blame | View Log
// plugin.h -- plugin manager for gold -*- C++ -*- // Copyright 2008, 2009 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 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* filename) : handle_(NULL), filename_(filename), 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; } // 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_; }; // 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_(), in_replacement_phase_(false), cleanup_done_(false), options_(options), workqueue_(NULL), task_(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* 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(); // 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, Task* task, Input_objects* input_objects, Symbol_table* symtab, Layout* layout, Dirsearch* dirpath, Mapfile* mapfile, Task_token** last_blocker); // 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 Pluginobj associated with the given HANDLE. Pluginobj* 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->objects_.empty() && !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); // Release an input file. ld_plugin_status release_input_file(unsigned int handle); // Add a new input file. ld_plugin_status add_input_file(char *pathname, bool is_lib); // 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*> Plugin_list; typedef std::vector<Pluginobj*> Object_list; typedef std::vector<Relobj*> Deferred_layout_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 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_; // 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_; // TRUE if the cleanup handlers have been called. bool cleanup_done_; 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 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) 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*); // 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 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; // 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), 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: 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)
Go to most recent revision | Compare with Previous | Blame | View Log