// plugin.h -- plugin manager for gold -*- C++ -*-
-// Copyright 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
+// Copyright (C) 2008-2020 Free Software Foundation, Inc.
// Written by Cary Coutant <ccoutant@google.com>.
// This file is part of gold.
class Task_token;
class Pluginobj;
class Plugin_rescan;
+class Plugin_recorder;
// This class represents a single plugin library.
claim_file_handler_(NULL),
all_symbols_read_handler_(NULL),
cleanup_handler_(NULL),
+ new_input_handler_(NULL),
cleanup_done_(false)
{ }
void
all_symbols_read();
+ // Call the new_input handler.
+ void
+ new_input(struct ld_plugin_input_file* plugin_input_file);
+
// Call the cleanup handler.
void
cleanup();
set_cleanup_handler(ld_plugin_cleanup_handler handler)
{ this->cleanup_handler_ = handler; }
+ // Register a new_input handler.
+ void
+ set_new_input_handler(ld_plugin_new_input_handler handler)
+ { this->new_input_handler_ = handler; }
+
// Add an argument
void
add_option(const char* arg)
this->args_.push_back(arg);
}
+ const std::string&
+ filename() const
+ { return this->filename_; }
+
private:
Plugin(const Plugin&);
Plugin& operator=(const Plugin&);
ld_plugin_claim_file_handler claim_file_handler_;
ld_plugin_all_symbols_read_handler all_symbols_read_handler_;
ld_plugin_cleanup_handler cleanup_handler_;
+ ld_plugin_new_input_handler new_input_handler_;
// TRUE if the cleanup handlers have been called.
bool cleanup_done_;
};
: 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_blocker_(NULL), extra_search_path_(), lock_(NULL),
+ initialize_lock_(&lock_), defsym_defines_set_(),
+ recorder_(NULL)
{ this->current_ = plugins_.end(); }
~Plugin_manager();
+ // Returns true if the symbol name is used in the LHS of a defsym.
+ bool
+ is_defsym_def(const char* sym_name) const
+ {
+ return defsym_defines_set_.find(sym_name) != defsym_defines_set_.end();
+ }
+
// Add a plugin library.
void
add_plugin(const char* filename)
// Load all plugin libraries.
void
- load_plugins();
+ 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);
+ 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
all_symbols_read(Workqueue* workqueue, Task* task,
Input_objects* input_objects, Symbol_table* symtab,
- Layout* layout, Dirsearch* dirpath, Mapfile* mapfile,
+ Dirsearch* dirpath, Mapfile* mapfile,
Task_token** last_blocker);
// Tell the plugin manager that we've a new undefined symbol which
(*this->current_)->set_all_symbols_read_handler(handler);
}
+ // Register a new_input handler.
+ void
+ set_new_input_handler(ld_plugin_new_input_handler handler)
+ {
+ gold_assert(this->current_ != plugins_.end());
+ (*this->current_)->set_new_input_handler(handler);
+ }
+
// Register a claim-file handler.
void
set_cleanup_handler(ld_plugin_cleanup_handler handler)
Pluginobj*
make_plugin_object(unsigned int handle);
- // Return the Pluginobj associated with the given HANDLE.
- Pluginobj*
+ // Return the object associated with the given HANDLE.
+ Object*
object(unsigned int handle) const
{
if (handle >= this->objects_.size())
// and we are still in the initial input phase.
bool
should_defer_layout() const
- { return !this->objects_.empty() && !this->in_replacement_phase_; }
+ { 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
in_replacement_phase() const
{ return this->in_replacement_phase_; }
+ Input_objects*
+ input_objects() const
+ { return this->input_objects_; }
+
+ Symbol_table*
+ symtab()
+ { return this->symtab_; }
+
+ Layout*
+ layout()
+ { return this->layout_; }
+
+ Plugin_recorder*
+ recorder() const
+ { return this->recorder_; }
+
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<Object*> Object_list;
typedef std::vector<Relobj*> Deferred_layout_list;
typedef std::vector<Rescannable> Rescannable_list;
typedef std::vector<Symbol*> Undefined_symbol_list;
// 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_;
Mapfile* mapfile_;
Task_token* this_blocker_;
- // An extra directory to seach for the libraries passed by
+ // An extra directory to search for the libraries passed by
// add_input_library.
std::string extra_search_path_;
+ Lock* lock_;
+ Initialize_lock initialize_lock_;
+
+ // Keep track of all symbols defined by defsym.
+ typedef Unordered_set<std::string> Defsym_defines_set;
+ Defsym_defines_set defsym_defines_set_;
+
+ // Class to record plugin actions.
+ Plugin_recorder* recorder_;
};
// 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;
+ get_symbol_resolution_info(Symbol_table* symtab,
+ int nsyms,
+ ld_plugin_symbol* syms,
+ int version) const;
// Store the incoming symbols from the plugin for later processing.
void
filesize()
{ return this->filesize_; }
+ // Return the word size of the object file.
+ int
+ elfsize() const
+ { gold_unreachable(); }
+
+ // Return TRUE if this is a big-endian object file.
+ bool
+ is_big_endian() const
+ { gold_unreachable(); }
+
protected:
// Return TRUE if this is an object claimed by a plugin.
virtual Pluginobj*
// The number of symbols provided by the plugin.
int nsyms_;
-
+
// The symbols provided by the plugin.
const struct ld_plugin_symbol* syms_;
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);
+ do_section_name(unsigned int shndx) const;
// Return a view of the contents of a section.
- Object::Location
- do_section_contents(unsigned int shndx);
+ const unsigned char*
+ do_section_contents(unsigned int shndx, section_size_type* plen,
+ bool cache);
// Return section flags.
uint64_t
{
public:
Plugin_hook(const General_options& options, Input_objects* input_objects,
- Symbol_table* symtab, Layout* layout, Dirsearch* dirpath,
+ 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),
+ dirpath_(dirpath), mapfile_(mapfile),
this_blocker_(this_blocker), next_blocker_(next_blocker)
{ }
const General_options& options_;
Input_objects* input_objects_;
Symbol_table* symtab_;
- Layout* layout_;
Dirsearch* dirpath_;
Mapfile* mapfile_;
Task_token* this_blocker_;