gold/plugin.h

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