Merge branch 'vendor/BZIP'
[dragonfly.git] / contrib / binutils-2.20 / gold / plugin.h
CommitLineData
8e158dd0
SS
1// plugin.h -- plugin manager for gold -*- C++ -*-
2
3// Copyright 2008, 2009 Free Software Foundation, Inc.
4// Written by Cary Coutant <ccoutant@google.com>.
5
6// This file is part of gold.
7
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.
12
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.
17
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.
22
23#ifndef GOLD_PLUGIN_H
24#define GOLD_PLUGIN_H
25
26#include <list>
27#include <string>
28
29#include "object.h"
30#include "plugin-api.h"
31#include "workqueue.h"
32
33namespace gold
34{
35
36class General_options;
37class Input_file;
38class Input_objects;
39class Symbol_table;
40class Layout;
41class Dirsearch;
42class Mapfile;
43class Task_token;
44class Pluginobj;
45
46// This class represents a single plugin library.
47
48class Plugin
49{
50 public:
51 Plugin(const char* filename)
52 : handle_(NULL),
53 filename_(filename),
54 args_(),
55 claim_file_handler_(NULL),
56 all_symbols_read_handler_(NULL),
57 cleanup_handler_(NULL)
58 { }
59
60 ~Plugin()
61 { }
62
63 // Load the library and call its entry point.
64 void
65 load();
66
67 // Call the claim-file handler.
68 bool
69 claim_file(struct ld_plugin_input_file *plugin_input_file);
70
71 // Call the all-symbols-read handler.
72 void
73 all_symbols_read();
74
75 // Call the cleanup handler.
76 void
77 cleanup();
78
79 // Register a claim-file handler.
80 void
81 set_claim_file_handler(ld_plugin_claim_file_handler handler)
82 { this->claim_file_handler_ = handler; }
83
84 // Register an all-symbols-read handler.
85 void
86 set_all_symbols_read_handler(ld_plugin_all_symbols_read_handler handler)
87 { this->all_symbols_read_handler_ = handler; }
88
89 // Register a claim-file handler.
90 void
91 set_cleanup_handler(ld_plugin_cleanup_handler handler)
92 { this->cleanup_handler_ = handler; }
93
94 // Add an argument
95 void
96 add_option(const char *arg)
97 {
98 this->args_.push_back(arg);
99 }
100
101 private:
102 Plugin(const Plugin&);
103 Plugin& operator=(const Plugin&);
104
105 // The shared library handle returned by dlopen.
106 void* handle_;
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_;
115};
116
117// A manager class for plugins.
118
119class Plugin_manager
120{
121 public:
122 Plugin_manager(const General_options& options)
123 : plugins_(), objects_(), deferred_layout_objects_(), input_file_(NULL),
124 plugin_input_file_(), in_replacement_phase_(false), cleanup_done_(false),
125 options_(options), workqueue_(NULL), task_(NULL), input_objects_(NULL),
126 symtab_(NULL), layout_(NULL), dirpath_(NULL), mapfile_(NULL),
127 this_blocker_(NULL)
128 { this->current_ = plugins_.end(); }
129
130 ~Plugin_manager();
131
132 // Add a plugin library.
133 void
134 add_plugin(const char* filename)
135 { this->plugins_.push_back(new Plugin(filename)); }
136
137 // Add an argument to the current plugin.
138 void
139 add_plugin_option(const char* opt)
140 {
141 Plugin* last = this->plugins_.back();
142 last->add_option(opt);
143 }
144
145 // Load all plugin libraries.
146 void
147 load_plugins();
148
149 // Call the plugin claim-file handlers in turn to see if any claim the file.
150 Pluginobj*
151 claim_file(Input_file *input_file, off_t offset, off_t filesize);
152
153 // Call the all-symbols-read handlers.
154 void
155 all_symbols_read(Workqueue* workqueue, Task* task,
156 Input_objects* input_objects, Symbol_table* symtab,
157 Layout* layout, Dirsearch* dirpath, Mapfile* mapfile,
158 Task_token** last_blocker);
159
160 // Run deferred layout.
161 void
162 layout_deferred_objects();
163
164 // Call the cleanup handlers.
165 void
166 cleanup();
167
168 // Register a claim-file handler.
169 void
170 set_claim_file_handler(ld_plugin_claim_file_handler handler)
171 {
172 gold_assert(this->current_ != plugins_.end());
173 (*this->current_)->set_claim_file_handler(handler);
174 }
175
176 // Register an all-symbols-read handler.
177 void
178 set_all_symbols_read_handler(ld_plugin_all_symbols_read_handler handler)
179 {
180 gold_assert(this->current_ != plugins_.end());
181 (*this->current_)->set_all_symbols_read_handler(handler);
182 }
183
184 // Register a claim-file handler.
185 void
186 set_cleanup_handler(ld_plugin_cleanup_handler handler)
187 {
188 gold_assert(this->current_ != plugins_.end());
189 (*this->current_)->set_cleanup_handler(handler);
190 }
191
192 // Make a new Pluginobj object. This is called when the plugin calls
193 // the add_symbols API.
194 Pluginobj*
195 make_plugin_object(unsigned int handle);
196
197 // Return the Pluginobj associated with the given HANDLE.
198 Pluginobj*
199 object(unsigned int handle) const
200 {
201 if (handle >= this->objects_.size())
202 return NULL;
203 return this->objects_[handle];
204 }
205
206 // Return TRUE if any input files have been claimed by a plugin
207 // and we are still in the initial input phase.
208 bool
209 should_defer_layout() const
210 { return !this->objects_.empty() && !this->in_replacement_phase_; }
211
212 // Add a regular object to the deferred layout list. These are
213 // objects whose layout has been deferred until after the
214 // replacement files have arrived.
215 void
216 add_deferred_layout_object(Relobj* obj)
217 { this->deferred_layout_objects_.push_back(obj); }
218
219 // Get input file information with an open (possibly re-opened)
220 // file descriptor.
221 ld_plugin_status
222 get_input_file(unsigned int handle, struct ld_plugin_input_file *file);
223
224 // Release an input file.
225 ld_plugin_status
226 release_input_file(unsigned int handle);
227
228 // Add a new input file.
229 ld_plugin_status
230 add_input_file(char *pathname, bool is_lib);
231
232 // Return TRUE if we are in the replacement phase.
233 bool
234 in_replacement_phase() const
235 { return this->in_replacement_phase_; }
236
237 private:
238 Plugin_manager(const Plugin_manager&);
239 Plugin_manager& operator=(const Plugin_manager&);
240
241 typedef std::list<Plugin*> Plugin_list;
242 typedef std::vector<Pluginobj*> Object_list;
243 typedef std::vector<Relobj*> Deferred_layout_list;
244
245 // The list of plugin libraries.
246 Plugin_list plugins_;
247 // A pointer to the current plugin. Used while loading plugins.
248 Plugin_list::iterator current_;
249
250 // The list of plugin objects. The index of an item in this list
251 // serves as the "handle" that we pass to the plugins.
252 Object_list objects_;
253
254 // The list of regular objects whose layout has been deferred.
255 Deferred_layout_list deferred_layout_objects_;
256
257 // The file currently up for claim by the plugins.
258 Input_file* input_file_;
259 struct ld_plugin_input_file plugin_input_file_;
260
261 // TRUE after the all symbols read event; indicates that we are
262 // processing replacement files whose symbols should replace the
263 // placeholder symbols from the Pluginobj objects.
264 bool in_replacement_phase_;
265
266 // TRUE if the cleanup handlers have been called.
267 bool cleanup_done_;
268
269 const General_options& options_;
270 Workqueue* workqueue_;
271 Task* task_;
272 Input_objects* input_objects_;
273 Symbol_table* symtab_;
274 Layout* layout_;
275 Dirsearch* dirpath_;
276 Mapfile* mapfile_;
277 Task_token* this_blocker_;
278};
279
280
281// An object file claimed by a plugin. This is an abstract base class.
282// The implementation is the template class Sized_pluginobj.
283
284class Pluginobj : public Object
285{
286 public:
287
288 typedef std::vector<Symbol*> Symbols;
289
290 Pluginobj(const std::string& name, Input_file* input_file, off_t offset,
291 off_t filesize);
292
293 // Fill in the symbol resolution status for the given plugin symbols.
294 ld_plugin_status
295 get_symbol_resolution_info(int nsyms, ld_plugin_symbol* syms) const;
296
297 // Store the incoming symbols from the plugin for later processing.
298 void
299 store_incoming_symbols(int nsyms, const struct ld_plugin_symbol* syms)
300 {
301 this->nsyms_ = nsyms;
302 this->syms_ = syms;
303 }
304
305 // Return TRUE if the comdat group with key COMDAT_KEY from this object
306 // should be kept.
307 bool
308 include_comdat_group(std::string comdat_key, Layout* layout);
309
310 // Return the filename.
311 const std::string&
312 filename() const
313 { return this->input_file()->filename(); }
314
315 // Return the file descriptor.
316 int
317 descriptor()
318 { return this->input_file()->file().descriptor(); }
319
320 // Return the size of the file or archive member.
321 off_t
322 filesize()
323 { return this->filesize_; }
324
325 protected:
326 // Return TRUE if this is an object claimed by a plugin.
327 virtual Pluginobj*
328 do_pluginobj()
329 { return this; }
330
331 // The number of symbols provided by the plugin.
332 int nsyms_;
333
334 // The symbols provided by the plugin.
335 const struct ld_plugin_symbol* syms_;
336
337 // The entries in the symbol table for the external symbols.
338 Symbols symbols_;
339
340 private:
341 // Size of the file (or archive member).
342 off_t filesize_;
343 // Map a comdat key symbol to a boolean indicating whether the comdat
344 // group in this object with that key should be kept.
345 typedef Unordered_map<std::string, bool> Comdat_map;
346 Comdat_map comdat_map_;
347};
348
349// A plugin object, size-specific version.
350
351template<int size, bool big_endian>
352class Sized_pluginobj : public Pluginobj
353{
354 public:
355 Sized_pluginobj(const std::string& name, Input_file* input_file,
356 off_t offset, off_t filesize);
357
358 // Read the symbols.
359 void
360 do_read_symbols(Read_symbols_data*);
361
362 // Lay out the input sections.
363 void
364 do_layout(Symbol_table*, Layout*, Read_symbols_data*);
365
366 // Add the symbols to the symbol table.
367 void
368 do_add_symbols(Symbol_table*, Read_symbols_data*, Layout*);
369
370 // Get the size of a section.
371 uint64_t
372 do_section_size(unsigned int shndx);
373
374 // Get the name of a section.
375 std::string
376 do_section_name(unsigned int shndx);
377
378 // Return a view of the contents of a section.
379 Object::Location
380 do_section_contents(unsigned int shndx);
381
382 // Return section flags.
383 uint64_t
384 do_section_flags(unsigned int shndx);
385
386 // Return section entsize.
387 uint64_t
388 do_section_entsize(unsigned int shndx);
389
390 // Return section address.
391 uint64_t
392 do_section_address(unsigned int shndx);
393
394 // Return section type.
395 unsigned int
396 do_section_type(unsigned int shndx);
397
398 // Return the section link field.
399 unsigned int
400 do_section_link(unsigned int shndx);
401
402 // Return the section link field.
403 unsigned int
404 do_section_info(unsigned int shndx);
405
406 // Return the section alignment.
407 uint64_t
408 do_section_addralign(unsigned int shndx);
409
410 // Return the Xindex structure to use.
411 Xindex*
412 do_initialize_xindex();
413
414 // Get symbol counts.
415 void
416 do_get_global_symbol_counts(const Symbol_table*, size_t*, size_t*) const;
417
418 // Add placeholder symbols from a claimed file.
419 ld_plugin_status
420 add_symbols_from_plugin(int nsyms, const ld_plugin_symbol* syms);
421
422 protected:
423
424 private:
425};
426
427// This Task handles handles the "all symbols read" event hook.
428// The plugin may add additional input files at this time, which must
429// be queued for reading.
430
431class Plugin_hook : public Task
432{
433 public:
434 Plugin_hook(const General_options& options, Input_objects* input_objects,
435 Symbol_table* symtab, Layout* layout, Dirsearch* dirpath,
436 Mapfile* mapfile, Task_token* this_blocker,
437 Task_token* next_blocker)
438 : options_(options), input_objects_(input_objects), symtab_(symtab),
439 layout_(layout), dirpath_(dirpath), mapfile_(mapfile),
440 this_blocker_(this_blocker), next_blocker_(next_blocker)
441 { }
442
443 ~Plugin_hook();
444
445 // The standard Task methods.
446
447 Task_token*
448 is_runnable();
449
450 void
451 locks(Task_locker*);
452
453 void
454 run(Workqueue*);
455
456 std::string
457 get_name() const
458 { return "Plugin_hook"; }
459
460 private:
461 const General_options& options_;
462 Input_objects* input_objects_;
463 Symbol_table* symtab_;
464 Layout* layout_;
465 Dirsearch* dirpath_;
466 Mapfile* mapfile_;
467 Task_token* this_blocker_;
468 Task_token* next_blocker_;
469};
470
471} // End namespace gold.
472
473#endif // !defined(GOLD_PLUGIN_H)