1 // plugin.h -- plugin manager for gold -*- C++ -*-
3 // Copyright (C) 2008-2018 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
;
51 // This class represents a single plugin library.
56 Plugin(const char* filename
)
60 claim_file_handler_(NULL
),
61 all_symbols_read_handler_(NULL
),
62 cleanup_handler_(NULL
),
63 new_input_handler_(NULL
),
70 // Load the library and call its entry point.
74 // Call the claim-file handler.
76 claim_file(struct ld_plugin_input_file
* plugin_input_file
);
78 // Call the all-symbols-read handler.
82 // Call the new_input handler.
84 new_input(struct ld_plugin_input_file
* plugin_input_file
);
86 // Call the cleanup handler.
90 // Register a claim-file handler.
92 set_claim_file_handler(ld_plugin_claim_file_handler handler
)
93 { this->claim_file_handler_
= handler
; }
95 // Register an all-symbols-read handler.
97 set_all_symbols_read_handler(ld_plugin_all_symbols_read_handler handler
)
98 { this->all_symbols_read_handler_
= handler
; }
100 // Register a claim-file handler.
102 set_cleanup_handler(ld_plugin_cleanup_handler handler
)
103 { this->cleanup_handler_
= handler
; }
105 // Register a new_input handler.
107 set_new_input_handler(ld_plugin_new_input_handler handler
)
108 { this->new_input_handler_
= handler
; }
112 add_option(const char* arg
)
114 this->args_
.push_back(arg
);
118 Plugin(const Plugin
&);
119 Plugin
& operator=(const Plugin
&);
121 // The shared library handle returned by dlopen.
123 // The argument string given to --plugin.
124 std::string filename_
;
125 // The list of argument string given to --plugin-opt.
126 std::vector
<std::string
> args_
;
127 // The plugin's event handlers.
128 ld_plugin_claim_file_handler claim_file_handler_
;
129 ld_plugin_all_symbols_read_handler all_symbols_read_handler_
;
130 ld_plugin_cleanup_handler cleanup_handler_
;
131 ld_plugin_new_input_handler new_input_handler_
;
132 // TRUE if the cleanup handlers have been called.
136 // A manager class for plugins.
141 Plugin_manager(const General_options
& options
)
142 : plugins_(), objects_(), deferred_layout_objects_(), input_file_(NULL
),
143 plugin_input_file_(), rescannable_(), undefined_symbols_(),
144 any_claimed_(false), in_replacement_phase_(false), any_added_(false),
145 in_claim_file_handler_(false),
146 options_(options
), workqueue_(NULL
), task_(NULL
), input_objects_(NULL
),
147 symtab_(NULL
), layout_(NULL
), dirpath_(NULL
), mapfile_(NULL
),
148 this_blocker_(NULL
), extra_search_path_(), lock_(NULL
),
149 initialize_lock_(&lock_
), defsym_defines_set_()
150 { this->current_
= plugins_
.end(); }
154 // Returns true if the symbol name is used in the LHS of a defsym.
156 is_defsym_def(const char* sym_name
) const
158 return defsym_defines_set_
.find(sym_name
) != defsym_defines_set_
.end();
161 // Add a plugin library.
163 add_plugin(const char* filename
)
164 { this->plugins_
.push_back(new Plugin(filename
)); }
166 // Add an argument to the current plugin.
168 add_plugin_option(const char* opt
)
170 Plugin
* last
= this->plugins_
.back();
171 last
->add_option(opt
);
174 // Load all plugin libraries.
176 load_plugins(Layout
* layout
);
178 // Call the plugin claim-file handlers in turn to see if any claim the file.
180 claim_file(Input_file
* input_file
, off_t offset
, off_t filesize
,
183 // Get the object associated with the handle and check if it is an elf object.
184 // If it is not a Pluginobj, it is an elf object.
186 get_elf_object(const void* handle
);
188 // True if the claim_file handler of the plugins is being called.
190 in_claim_file_handler()
191 { return in_claim_file_handler_
; }
193 // Let the plugin manager save an archive for later rescanning.
194 // This takes ownership of the Archive pointer.
196 save_archive(Archive
*);
198 // Let the plugin manager save an input group for later rescanning.
199 // This takes ownership of the Input_group pointer.
201 save_input_group(Input_group
*);
203 // Call the all-symbols-read handlers.
205 all_symbols_read(Workqueue
* workqueue
, Task
* task
,
206 Input_objects
* input_objects
, Symbol_table
* symtab
,
207 Dirsearch
* dirpath
, Mapfile
* mapfile
,
208 Task_token
** last_blocker
);
210 // Tell the plugin manager that we've a new undefined symbol which
211 // may require rescanning.
213 new_undefined_symbol(Symbol
*);
215 // Run deferred layout.
217 layout_deferred_objects();
219 // Call the cleanup handlers.
223 // Register a claim-file handler.
225 set_claim_file_handler(ld_plugin_claim_file_handler handler
)
227 gold_assert(this->current_
!= plugins_
.end());
228 (*this->current_
)->set_claim_file_handler(handler
);
231 // Register an all-symbols-read handler.
233 set_all_symbols_read_handler(ld_plugin_all_symbols_read_handler handler
)
235 gold_assert(this->current_
!= plugins_
.end());
236 (*this->current_
)->set_all_symbols_read_handler(handler
);
239 // Register a new_input handler.
241 set_new_input_handler(ld_plugin_new_input_handler handler
)
243 gold_assert(this->current_
!= plugins_
.end());
244 (*this->current_
)->set_new_input_handler(handler
);
247 // Register a claim-file handler.
249 set_cleanup_handler(ld_plugin_cleanup_handler handler
)
251 gold_assert(this->current_
!= plugins_
.end());
252 (*this->current_
)->set_cleanup_handler(handler
);
255 // Make a new Pluginobj object. This is called when the plugin calls
256 // the add_symbols API.
258 make_plugin_object(unsigned int handle
);
260 // Return the object associated with the given HANDLE.
262 object(unsigned int handle
) const
264 if (handle
>= this->objects_
.size())
266 return this->objects_
[handle
];
269 // Return TRUE if any input files have been claimed by a plugin
270 // and we are still in the initial input phase.
272 should_defer_layout() const
273 { return this->any_claimed_
&& !this->in_replacement_phase_
; }
275 // Add a regular object to the deferred layout list. These are
276 // objects whose layout has been deferred until after the
277 // replacement files have arrived.
279 add_deferred_layout_object(Relobj
* obj
)
280 { this->deferred_layout_objects_
.push_back(obj
); }
282 // Get input file information with an open (possibly re-opened)
285 get_input_file(unsigned int handle
, struct ld_plugin_input_file
* file
);
288 get_view(unsigned int handle
, const void **viewp
);
290 // Release an input file.
292 release_input_file(unsigned int handle
);
294 // Add a new input file.
296 add_input_file(const char* pathname
, bool is_lib
);
298 // Set the extra library path.
300 set_extra_library_path(const char* path
);
302 // Return TRUE if we are in the replacement phase.
304 in_replacement_phase() const
305 { return this->in_replacement_phase_
; }
308 input_objects() const
309 { return this->input_objects_
; }
313 { return this->symtab_
; }
317 { return this->layout_
; }
320 Plugin_manager(const Plugin_manager
&);
321 Plugin_manager
& operator=(const Plugin_manager
&);
323 // Plugin_rescan is a Task which calls the private rescan method.
324 friend class Plugin_rescan
;
326 // An archive or input group which may have to be rescanned if a
327 // plugin adds a new file.
334 Input_group
* input_group
;
337 Rescannable(Archive
* archive
)
339 { this->u
.archive
= archive
; }
341 Rescannable(Input_group
* input_group
)
343 { this->u
.input_group
= input_group
; }
346 typedef std::list
<Plugin
*> Plugin_list
;
347 typedef std::vector
<Object
*> Object_list
;
348 typedef std::vector
<Relobj
*> Deferred_layout_list
;
349 typedef std::vector
<Rescannable
> Rescannable_list
;
350 typedef std::vector
<Symbol
*> Undefined_symbol_list
;
352 // Rescan archives for undefined symbols.
356 // See whether the rescannable at index I defines SYM.
358 rescannable_defines(size_t i
, Symbol
* sym
);
360 // The list of plugin libraries.
361 Plugin_list plugins_
;
362 // A pointer to the current plugin. Used while loading plugins.
363 Plugin_list::iterator current_
;
365 // The list of plugin objects. The index of an item in this list
366 // serves as the "handle" that we pass to the plugins.
367 Object_list objects_
;
369 // The list of regular objects whose layout has been deferred.
370 Deferred_layout_list deferred_layout_objects_
;
372 // The file currently up for claim by the plugins.
373 Input_file
* input_file_
;
374 struct ld_plugin_input_file plugin_input_file_
;
376 // A list of archives and input groups being saved for possible
378 Rescannable_list rescannable_
;
380 // A list of undefined symbols found in added files.
381 Undefined_symbol_list undefined_symbols_
;
383 // Whether any input files have been claimed by a plugin.
386 // Set to true after the all symbols read event; indicates that we
387 // are processing replacement files whose symbols should replace the
388 // placeholder symbols from the Pluginobj objects.
389 bool in_replacement_phase_
;
391 // Whether any input files or libraries were added by a plugin.
394 // Set to true when the claim_file handler of a plugin is called.
395 bool in_claim_file_handler_
;
397 const General_options
& options_
;
398 Workqueue
* workqueue_
;
400 Input_objects
* input_objects_
;
401 Symbol_table
* symtab_
;
405 Task_token
* this_blocker_
;
407 // An extra directory to search for the libraries passed by
408 // add_input_library.
409 std::string extra_search_path_
;
411 Initialize_lock initialize_lock_
;
413 // Keep track of all symbols defined by defsym.
414 typedef Unordered_set
<std::string
> Defsym_defines_set
;
415 Defsym_defines_set defsym_defines_set_
;
419 // An object file claimed by a plugin. This is an abstract base class.
420 // The implementation is the template class Sized_pluginobj.
422 class Pluginobj
: public Object
426 typedef std::vector
<Symbol
*> Symbols
;
428 Pluginobj(const std::string
& name
, Input_file
* input_file
, off_t offset
,
431 // Fill in the symbol resolution status for the given plugin symbols.
433 get_symbol_resolution_info(Symbol_table
* symtab
,
435 ld_plugin_symbol
* syms
,
438 // Store the incoming symbols from the plugin for later processing.
440 store_incoming_symbols(int nsyms
, const struct ld_plugin_symbol
* syms
)
442 this->nsyms_
= nsyms
;
446 // Return TRUE if the comdat group with key COMDAT_KEY from this object
449 include_comdat_group(std::string comdat_key
, Layout
* layout
);
451 // Return the filename.
454 { return this->input_file()->filename(); }
456 // Return the file descriptor.
459 { return this->input_file()->file().descriptor(); }
461 // Return the size of the file or archive member.
464 { return this->filesize_
; }
466 // Return the word size of the object file.
469 { gold_unreachable(); }
471 // Return TRUE if this is a big-endian object file.
473 is_big_endian() const
474 { gold_unreachable(); }
477 // Return TRUE if this is an object claimed by a plugin.
482 // The number of symbols provided by the plugin.
485 // The symbols provided by the plugin.
486 const struct ld_plugin_symbol
* syms_
;
488 // The entries in the symbol table for the external symbols.
492 // Size of the file (or archive member).
494 // Map a comdat key symbol to a boolean indicating whether the comdat
495 // group in this object with that key should be kept.
496 typedef Unordered_map
<std::string
, bool> Comdat_map
;
497 Comdat_map comdat_map_
;
500 // A plugin object, size-specific version.
502 template<int size
, bool big_endian
>
503 class Sized_pluginobj
: public Pluginobj
506 Sized_pluginobj(const std::string
& name
, Input_file
* input_file
,
507 off_t offset
, off_t filesize
);
511 do_read_symbols(Read_symbols_data
*);
513 // Lay out the input sections.
515 do_layout(Symbol_table
*, Layout
*, Read_symbols_data
*);
517 // Add the symbols to the symbol table.
519 do_add_symbols(Symbol_table
*, Read_symbols_data
*, Layout
*);
521 Archive::Should_include
522 do_should_include_member(Symbol_table
* symtab
, Layout
*, Read_symbols_data
*,
525 // Iterate over global symbols, calling a visitor class V for each.
527 do_for_all_global_symbols(Read_symbols_data
* sd
,
528 Library_base::Symbol_visitor_base
* v
);
530 // Iterate over local symbols, calling a visitor class V for each GOT offset
531 // associated with a local symbol.
533 do_for_all_local_got_entries(Got_offset_list::Visitor
* v
) const;
535 // Get the size of a section.
537 do_section_size(unsigned int shndx
);
539 // Get the name of a section.
541 do_section_name(unsigned int shndx
) const;
543 // Return a view of the contents of a section.
545 do_section_contents(unsigned int shndx
, section_size_type
* plen
,
548 // Return section flags.
550 do_section_flags(unsigned int shndx
);
552 // Return section entsize.
554 do_section_entsize(unsigned int shndx
);
556 // Return section address.
558 do_section_address(unsigned int shndx
);
560 // Return section type.
562 do_section_type(unsigned int shndx
);
564 // Return the section link field.
566 do_section_link(unsigned int shndx
);
568 // Return the section link field.
570 do_section_info(unsigned int shndx
);
572 // Return the section alignment.
574 do_section_addralign(unsigned int shndx
);
576 // Return the Xindex structure to use.
578 do_initialize_xindex();
580 // Get symbol counts.
582 do_get_global_symbol_counts(const Symbol_table
*, size_t*, size_t*) const;
584 // Get global symbols.
586 do_get_global_symbols() const;
588 // Add placeholder symbols from a claimed file.
590 add_symbols_from_plugin(int nsyms
, const ld_plugin_symbol
* syms
);
597 // This Task handles handles the "all symbols read" event hook.
598 // The plugin may add additional input files at this time, which must
599 // be queued for reading.
601 class Plugin_hook
: public Task
604 Plugin_hook(const General_options
& options
, Input_objects
* input_objects
,
605 Symbol_table
* symtab
, Layout
* /*layout*/, Dirsearch
* dirpath
,
606 Mapfile
* mapfile
, Task_token
* this_blocker
,
607 Task_token
* next_blocker
)
608 : options_(options
), input_objects_(input_objects
), symtab_(symtab
),
609 dirpath_(dirpath
), mapfile_(mapfile
),
610 this_blocker_(this_blocker
), next_blocker_(next_blocker
)
615 // The standard Task methods.
628 { return "Plugin_hook"; }
631 const General_options
& options_
;
632 Input_objects
* input_objects_
;
633 Symbol_table
* symtab_
;
636 Task_token
* this_blocker_
;
637 Task_token
* next_blocker_
;
640 } // End namespace gold.
642 #endif // !defined(GOLD_PLUGIN_H)