1 // plugin.h -- plugin manager for gold -*- C++ -*-
3 // Copyright 2008 Free Software Foundation, Inc.
4 // Written by Cary Coutant <ccoutant@google.com>.
6 // This file is part of gold.
8 // This program is free software; you can redistribute it and/or modify
9 // it under the terms of the GNU General Public License as published by
10 // the Free Software Foundation; either version 3 of the License, or
11 // (at your option) any later version.
13 // This program is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 // GNU General Public License for more details.
18 // You should have received a copy of the GNU General Public License
19 // along with this program; if not, write to the Free Software
20 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 // MA 02110-1301, USA.
30 #include "plugin-api.h"
31 #include "workqueue.h"
36 class General_options;
46 // This class represents a single plugin library.
51 Plugin(const char* filename)
55 claim_file_handler_(NULL),
56 all_symbols_read_handler_(NULL),
57 cleanup_handler_(NULL)
63 // Load the library and call its entry point.
67 // Call the claim-file handler.
69 claim_file(struct ld_plugin_input_file *plugin_input_file);
71 // Call the all-symbols-read handler.
75 // Call the cleanup handler.
79 // Register a claim-file handler.
81 set_claim_file_handler(ld_plugin_claim_file_handler handler)
82 { this->claim_file_handler_ = handler; }
84 // Register an all-symbols-read handler.
86 set_all_symbols_read_handler(ld_plugin_all_symbols_read_handler handler)
87 { this->all_symbols_read_handler_ = handler; }
89 // Register a claim-file handler.
91 set_cleanup_handler(ld_plugin_cleanup_handler handler)
92 { this->cleanup_handler_ = handler; }
96 add_option(const char *arg)
98 this->args_.push_back(arg);
102 Plugin(const Plugin&);
103 Plugin& operator=(const Plugin&);
105 // The shared library handle returned by dlopen.
107 // The argument string given to --plugin.
108 std::string filename_;
109 // The list of argument string given to --plugin-opt.
110 std::vector<std::string> args_;
111 // The plugin's event handlers.
112 ld_plugin_claim_file_handler claim_file_handler_;
113 ld_plugin_all_symbols_read_handler all_symbols_read_handler_;
114 ld_plugin_cleanup_handler cleanup_handler_;
117 // A manager class for plugins.
122 Plugin_manager(const General_options& options)
123 : plugins_(), in_replacement_phase_(false), options_(options),
124 workqueue_(NULL), input_objects_(NULL), symtab_(NULL), layout_(NULL),
125 dirpath_(NULL), mapfile_(NULL), this_blocker_(NULL)
126 { this->current_ = plugins_.end(); }
130 // Add a plugin library.
132 add_plugin(const char* filename)
133 { this->plugins_.push_back(new Plugin(filename)); }
135 // Add an argument to the current plugin.
137 add_plugin_option(const char* opt)
139 Plugin* last = this->plugins_.back();
140 last->add_option(opt);
143 // Load all plugin libraries.
147 // Call the plugin claim-file handlers in turn to see if any claim the file.
149 claim_file(Input_file *input_file, off_t offset, off_t filesize);
151 // Call the all-symbols-read handlers.
153 all_symbols_read(Workqueue* workqueue, Input_objects* input_objects,
154 Symbol_table* symtab, Layout* layout, Dirsearch* dirpath,
155 Mapfile* mapfile, Task_token** last_blocker);
157 // Call the cleanup handlers.
161 // Register a claim-file handler.
163 set_claim_file_handler(ld_plugin_claim_file_handler handler)
165 gold_assert(this->current_ != plugins_.end());
166 (*this->current_)->set_claim_file_handler(handler);
169 // Register an all-symbols-read handler.
171 set_all_symbols_read_handler(ld_plugin_all_symbols_read_handler handler)
173 gold_assert(this->current_ != plugins_.end());
174 (*this->current_)->set_all_symbols_read_handler(handler);
177 // Register a claim-file handler.
179 set_cleanup_handler(ld_plugin_cleanup_handler handler)
181 gold_assert(this->current_ != plugins_.end());
182 (*this->current_)->set_cleanup_handler(handler);
185 // Make a new Pluginobj object. This is called when the plugin calls
186 // the add_symbols API.
188 make_plugin_object(unsigned int handle);
190 // Return the Pluginobj associated with the given HANDLE.
192 object(unsigned int handle) const
194 if (handle >= this->objects_.size())
196 return this->objects_[handle];
199 // Add a new input file.
201 add_input_file(char *pathname);
203 // Return TRUE if we are in the replacement phase.
205 in_replacement_phase() const
206 { return this->in_replacement_phase_; }
209 Plugin_manager(const Plugin_manager&);
210 Plugin_manager& operator=(const Plugin_manager&);
212 typedef std::list<Plugin*> Plugin_list;
213 typedef std::vector<Pluginobj*> Object_list;
215 // The list of plugin libraries.
216 Plugin_list plugins_;
217 // A pointer to the current plugin. Used while loading plugins.
218 Plugin_list::iterator current_;
220 // The list of plugin objects. The index of an item in this list
221 // serves as the "handle" that we pass to the plugins.
222 Object_list objects_;
224 // The file currently up for claim by the plugins.
225 Input_file* input_file_;
226 struct ld_plugin_input_file plugin_input_file_;
228 // TRUE after the all symbols read event; indicates that we are
229 // processing replacement files whose symbols should replace the
230 // placeholder symbols from the Pluginobj objects.
231 bool in_replacement_phase_;
233 const General_options& options_;
234 Workqueue* workqueue_;
235 Input_objects* input_objects_;
236 Symbol_table* symtab_;
240 Task_token* this_blocker_;
244 // An object file claimed by a plugin. This is an abstract base class.
245 // The implementation is the template class Sized_pluginobj.
247 class Pluginobj : public Object
251 typedef std::vector<Symbol*> Symbols;
253 Pluginobj(const std::string& name, Input_file* input_file, off_t offset);
255 // Fill in the symbol resolution status for the given plugin symbols.
257 get_symbol_resolution_info(int nsyms, ld_plugin_symbol* syms) const;
259 // Add symbol information to the global symbol table.
261 add_symbols(Symbol_table* symtab, Layout* layout)
262 { this->do_add_symbols(symtab, layout); }
264 // Store the incoming symbols from the plugin for later processing.
266 store_incoming_symbols(int nsyms, const struct ld_plugin_symbol* syms)
268 this->nsyms_ = nsyms;
272 // Return TRUE if the comdat group with key COMDAT_KEY from this object
275 include_comdat_group(std::string comdat_key, Layout* layout);
278 // Return TRUE if this is an object claimed by a plugin.
283 // Add symbol information to the global symbol table--implemented by
286 do_add_symbols(Symbol_table*, Layout*) = 0;
288 // The number of symbols provided by the plugin.
291 // The symbols provided by the plugin.
292 const struct ld_plugin_symbol* syms_;
294 // The entries in the symbol table for the external symbols.
298 // Map a comdat key symbol to a boolean indicating whether the comdat
299 // group in this object with that key should be kept.
300 typedef Unordered_map<std::string, bool> Comdat_map;
301 Comdat_map comdat_map_;
304 // A plugin object, size-specific version.
306 template<int size, bool big_endian>
307 class Sized_pluginobj : public Pluginobj
310 Sized_pluginobj(const std::string& name, Input_file* input_file,
315 do_read_symbols(Read_symbols_data*);
317 // Lay out the input sections.
319 do_layout(Symbol_table*, Layout*, Read_symbols_data*);
321 // Add the symbols to the symbol table.
323 do_add_symbols(Symbol_table*, Read_symbols_data*);
326 do_add_symbols(Symbol_table*, Layout*);
328 // Get the size of a section.
330 do_section_size(unsigned int shndx);
332 // Get the name of a section.
334 do_section_name(unsigned int shndx);
336 // Return a view of the contents of a section.
338 do_section_contents(unsigned int shndx);
340 // Return section flags.
342 do_section_flags(unsigned int shndx);
344 // Return section address.
346 do_section_address(unsigned int shndx);
348 // Return section type.
350 do_section_type(unsigned int shndx);
352 // Return the section link field.
354 do_section_link(unsigned int shndx);
356 // Return the section link field.
358 do_section_info(unsigned int shndx);
360 // Return the section alignment.
362 do_section_addralign(unsigned int shndx);
364 // Return the Xindex structure to use.
366 do_initialize_xindex();
368 // Get symbol counts.
370 do_get_global_symbol_counts(const Symbol_table*, size_t*, size_t*) const;
372 // Add placeholder symbols from a claimed file.
374 add_symbols_from_plugin(int nsyms, const ld_plugin_symbol* syms);
381 // This Task handles adding the symbols to the symbol table. These
382 // tasks must be run in the same order as the arguments appear on the
385 class Add_plugin_symbols : public Task
388 // THIS_BLOCKER is used to prevent this task from running before the
389 // one for the previous input file. NEXT_BLOCKER is used to prevent
390 // the next task from running.
391 Add_plugin_symbols(Symbol_table* symtab,
394 Task_token* this_blocker,
395 Task_token* next_blocker)
396 : symtab_(symtab), layout_(layout), obj_(obj),
397 this_blocker_(this_blocker), next_blocker_(next_blocker)
400 ~Add_plugin_symbols();
402 // The standard Task methods.
415 { return "Add_plugin_symbols " + this->obj_->name(); }
418 Symbol_table* symtab_;
421 Task_token* this_blocker_;
422 Task_token* next_blocker_;
425 // This Task handles handles the "all symbols read" event hook.
426 // The plugin may add additional input files at this time, which must
427 // be queued for reading.
429 class Plugin_hook : public Task
432 Plugin_hook(const General_options& options, Input_objects* input_objects,
433 Symbol_table* symtab, Layout* layout, Dirsearch* dirpath,
434 Mapfile* mapfile, Task_token* this_blocker,
435 Task_token* next_blocker)
436 : options_(options), input_objects_(input_objects), symtab_(symtab),
437 layout_(layout), dirpath_(dirpath), mapfile_(mapfile),
438 this_blocker_(this_blocker), next_blocker_(next_blocker)
443 // The standard Task methods.
456 { return "Plugin_hook"; }
459 // Call the plugin hook.
461 do_plugin_hook(Workqueue*);
463 const General_options& options_;
464 Input_objects* input_objects_;
465 Symbol_table* symtab_;
469 Task_token* this_blocker_;
470 Task_token* next_blocker_;
473 } // End namespace gold.
475 #endif // !defined(GOLD_PLUGIN_H)