URL
https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk
Subversion Repositories open8_urisc
[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [gold/] [plugin.h] - Rev 203
Go to most recent revision | Compare with Previous | Blame | View Log
// plugin.h -- 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. #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. 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; // 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), 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