gold/plugin.h

   1 // plugin.h -- plugin manager for gold      -*- C++ -*-
   2
   3 // Copyright (C) 2008-2023 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 Archive;
  40 class Input_group;
  41 class Symbol;
  42 class Symbol_table;
  43 class Layout;
  44 class Dirsearch;
  45 class Mapfile;
  46 class Task;
  47 class Task_token;
  48 class Pluginobj;
  49 class Plugin_rescan;
  50 class Plugin_recorder;
  51
  52 // This class represents a single plugin library.
  53
  54 class Plugin
  55 {
  56  public:
  57   Plugin(const char* filename)
  58     : handle_(NULL),
  59       filename_(filename),
  60       args_(),
  61       claim_file_handler_(NULL),
  62       all_symbols_read_handler_(NULL),
  63       cleanup_handler_(NULL),
  64       new_input_handler_(NULL),
  65       cleanup_done_(false)
  66   { }
  67
  68   ~Plugin()
  69   { }
  70
  71   // Load the library and call its entry point.
  72   void
  73   load();
  74
  75   // Call the claim-file handler.
  76   bool
  77   claim_file(struct ld_plugin_input_file* plugin_input_file);
  78
  79   // Call the all-symbols-read handler.
  80   void
  81   all_symbols_read();
  82
  83   // Call the new_input handler.
  84   void
  85   new_input(struct ld_plugin_input_file* plugin_input_file);
  86
  87   // Call the cleanup handler.
  88   void
  89   cleanup();
  90
  91   // Register a claim-file handler.
  92   void
  93   set_claim_file_handler(ld_plugin_claim_file_handler handler)
  94   { this->claim_file_handler_ = handler; }
  95
  96   // Register an all-symbols-read handler.
  97   void
  98   set_all_symbols_read_handler(ld_plugin_all_symbols_read_handler handler)
  99   { this->all_symbols_read_handler_ = handler; }
 100
 101   // Register a claim-file handler.
 102   void
 103   set_cleanup_handler(ld_plugin_cleanup_handler handler)
 104   { this->cleanup_handler_ = handler; }
 105
 106   // Register a new_input handler.
 107   void
 108   set_new_input_handler(ld_plugin_new_input_handler handler)
 109   { this->new_input_handler_ = handler; }
 110
 111   // Add an argument
 112   void
 113   add_option(const char* arg)
 114   {
 115     this->args_.push_back(arg);
 116   }
 117
 118   const std::string&
 119   filename() const
 120   { return this->filename_; }
 121
 122  private:
 123   Plugin(const Plugin&);
 124   Plugin& operator=(const Plugin&);
 125
 126   // The shared library handle returned by dlopen.
 127   void* handle_;
 128   // The argument string given to --plugin.
 129   std::string filename_;
 130   // The list of argument string given to --plugin-opt.
 131   std::vector<std::string> args_;
 132   // The plugin's event handlers.
 133   ld_plugin_claim_file_handler claim_file_handler_;
 134   ld_plugin_all_symbols_read_handler all_symbols_read_handler_;
 135   ld_plugin_cleanup_handler cleanup_handler_;
 136   ld_plugin_new_input_handler new_input_handler_;
 137   // TRUE if the cleanup handlers have been called.
 138   bool cleanup_done_;
 139 };
 140
 141 // A manager class for plugins.
 142
 143 class Plugin_manager
 144 {
 145  public:
 146   Plugin_manager(const General_options& options)
 147     : plugins_(), objects_(), deferred_layout_objects_(), input_file_(NULL),
 148       plugin_input_file_(), rescannable_(), undefined_symbols_(),
 149       any_claimed_(false), in_replacement_phase_(false), any_added_(false),
 150       in_claim_file_handler_(false),
 151       options_(options), workqueue_(NULL), task_(NULL), input_objects_(NULL),
 152       symtab_(NULL), layout_(NULL), dirpath_(NULL), mapfile_(NULL),
 153       this_blocker_(NULL), extra_search_path_(), lock_(NULL),
 154       initialize_lock_(&lock_), defsym_defines_set_(),
 155       recorder_(NULL)
 156   { this->current_ = plugins_.end(); }
 157
 158   ~Plugin_manager();
 159
 160   // Returns true if the symbol name is used in the LHS of a defsym.
 161   bool
 162   is_defsym_def(const char* sym_name) const
 163   {
 164     return defsym_defines_set_.find(sym_name) != defsym_defines_set_.end();
 165   }
 166
 167   // Add a plugin library.
 168   void
 169   add_plugin(const char* filename)
 170   { this->plugins_.push_back(new Plugin(filename)); }
 171
 172   // Add an argument to the current plugin.
 173   void
 174   add_plugin_option(const char* opt)
 175   {
 176     Plugin* last = this->plugins_.back();
 177     last->add_option(opt);
 178   }
 179
 180   // Load all plugin libraries.
 181   void
 182   load_plugins(Layout* layout);
 183
 184   // Call the plugin claim-file handlers in turn to see if any claim the file.
 185   Pluginobj*
 186   claim_file(Input_file* input_file, off_t offset, off_t filesize,
 187              Object* elf_object);
 188
 189   // Get the object associated with the handle and check if it is an elf object.
 190   // If it is not a Pluginobj, it is an elf object.
 191   Object*
 192   get_elf_object(const void* handle);
 193
 194   // True if the claim_file handler of the plugins is being called.
 195   bool
 196   in_claim_file_handler()
 197   { return in_claim_file_handler_; }
 198
 199   // Let the plugin manager save an archive for later rescanning.
 200   // This takes ownership of the Archive pointer.
 201   void
 202   save_archive(Archive*);
 203
 204   // Let the plugin manager save an input group for later rescanning.
 205   // This takes ownership of the Input_group pointer.
 206   void
 207   save_input_group(Input_group*);
 208
 209   // Call the all-symbols-read handlers.
 210   void
 211   all_symbols_read(Workqueue* workqueue, Task* task,
 212                    Input_objects* input_objects, Symbol_table* symtab,
 213                    Dirsearch* dirpath, Mapfile* mapfile,
 214                    Task_token** last_blocker);
 215
 216   // Tell the plugin manager that we've a new undefined symbol which
 217   // may require rescanning.
 218   void
 219   new_undefined_symbol(Symbol*);
 220
 221   // Run deferred layout.
 222   void
 223   layout_deferred_objects();
 224
 225   // Call the cleanup handlers.
 226   void
 227   cleanup();
 228
 229   // Register a claim-file handler.
 230   void
 231   set_claim_file_handler(ld_plugin_claim_file_handler handler)
 232   {
 233     gold_assert(this->current_ != plugins_.end());
 234     (*this->current_)->set_claim_file_handler(handler);
 235   }
 236
 237   // Register an all-symbols-read handler.
 238   void
 239   set_all_symbols_read_handler(ld_plugin_all_symbols_read_handler handler)
 240   {
 241     gold_assert(this->current_ != plugins_.end());
 242     (*this->current_)->set_all_symbols_read_handler(handler);
 243   }
 244
 245   // Register a new_input handler.
 246   void
 247   set_new_input_handler(ld_plugin_new_input_handler handler)
 248   {
 249     gold_assert(this->current_ != plugins_.end());
 250     (*this->current_)->set_new_input_handler(handler);
 251   }
 252
 253   // Register a claim-file handler.
 254   void
 255   set_cleanup_handler(ld_plugin_cleanup_handler handler)
 256   {
 257     gold_assert(this->current_ != plugins_.end());
 258     (*this->current_)->set_cleanup_handler(handler);
 259   }
 260
 261   // Make a new Pluginobj object.  This is called when the plugin calls
 262   // the add_symbols API.
 263   Pluginobj*
 264   make_plugin_object(unsigned int handle);
 265
 266   // Return the object associated with the given HANDLE.
 267   Object*
 268   object(unsigned int handle) const
 269   {
 270     if (handle >= this->objects_.size())
 271       return NULL;
 272     return this->objects_[handle];
 273   }
 274
 275   // Return TRUE if any input files have been claimed by a plugin
 276   // and we are still in the initial input phase.
 277   bool
 278   should_defer_layout() const
 279   { return this->any_claimed_ && !this->in_replacement_phase_; }
 280
 281   // Add a regular object to the deferred layout list.  These are
 282   // objects whose layout has been deferred until after the
 283   // replacement files have arrived.
 284   void
 285   add_deferred_layout_object(Relobj* obj)
 286   { this->deferred_layout_objects_.push_back(obj); }
 287
 288   // Get input file information with an open (possibly re-opened)
 289   // file descriptor.
 290   ld_plugin_status
 291   get_input_file(unsigned int handle, struct ld_plugin_input_file* file);
 292
 293   ld_plugin_status
 294   get_view(unsigned int handle, const void **viewp);
 295
 296   // Release an input file.
 297   ld_plugin_status
 298   release_input_file(unsigned int handle);
 299
 300   // Add a new input file.
 301   ld_plugin_status
 302   add_input_file(const char* pathname, bool is_lib);
 303
 304   // Set the extra library path.
 305   ld_plugin_status
 306   set_extra_library_path(const char* path);
 307
 308   // Return TRUE if we are in the replacement phase.
 309   bool
 310   in_replacement_phase() const
 311   { return this->in_replacement_phase_; }
 312
 313   Input_objects*
 314   input_objects() const
 315   { return this->input_objects_; }
 316
 317   Symbol_table*
 318   symtab()
 319   { return this->symtab_; }
 320
 321   Layout*
 322   layout()
 323   { return this->layout_; }
 324
 325   Plugin_recorder*
 326   recorder() const
 327   { return this->recorder_; }
 328
 329  private:
 330   Plugin_manager(const Plugin_manager&);
 331   Plugin_manager& operator=(const Plugin_manager&);
 332
 333   // Plugin_rescan is a Task which calls the private rescan method.
 334   friend class Plugin_rescan;
 335
 336   // An archive or input group which may have to be rescanned if a
 337   // plugin adds a new file.
 338   struct Rescannable
 339   {
 340     bool is_archive;
 341     union
 342     {
 343       Archive* archive;
 344       Input_group* input_group;
 345     } u;
 346
 347     Rescannable(Archive* archive)
 348       : is_archive(true)
 349     { this->u.archive = archive; }
 350
 351     Rescannable(Input_group* input_group)
 352       : is_archive(false)
 353     { this->u.input_group = input_group; }
 354   };
 355
 356   typedef std::list<Plugin*> Plugin_list;
 357   typedef std::vector<Object*> Object_list;
 358   typedef std::vector<Relobj*> Deferred_layout_list;
 359   typedef std::vector<Rescannable> Rescannable_list;
 360   typedef std::vector<Symbol*> Undefined_symbol_list;
 361
 362   // Rescan archives for undefined symbols.
 363   void
 364   rescan(Task*);
 365
 366   // See whether the rescannable at index I defines SYM.
 367   bool
 368   rescannable_defines(size_t i, Symbol* sym);
 369
 370   // The list of plugin libraries.
 371   Plugin_list plugins_;
 372   // A pointer to the current plugin.  Used while loading plugins.
 373   Plugin_list::iterator current_;
 374
 375   // The list of plugin objects.  The index of an item in this list
 376   // serves as the "handle" that we pass to the plugins.
 377   Object_list objects_;
 378
 379   // The list of regular objects whose layout has been deferred.
 380   Deferred_layout_list deferred_layout_objects_;
 381
 382   // The file currently up for claim by the plugins.
 383   Input_file* input_file_;
 384   struct ld_plugin_input_file plugin_input_file_;
 385
 386   // A list of archives and input groups being saved for possible
 387   // later rescanning.
 388   Rescannable_list rescannable_;
 389
 390   // A list of undefined symbols found in added files.
 391   Undefined_symbol_list undefined_symbols_;
 392
 393   // Whether any input files have been claimed by a plugin.
 394   bool any_claimed_;
 395
 396   // Set to true after the all symbols read event; indicates that we
 397   // are processing replacement files whose symbols should replace the
 398   // placeholder symbols from the Pluginobj objects.
 399   bool in_replacement_phase_;
 400
 401   // Whether any input files or libraries were added by a plugin.
 402   bool any_added_;
 403
 404   // Set to true when the claim_file handler of a plugin is called.
 405   bool in_claim_file_handler_;
 406
 407   const General_options& options_;
 408   Workqueue* workqueue_;
 409   Task* task_;
 410   Input_objects* input_objects_;
 411   Symbol_table* symtab_;
 412   Layout* layout_;
 413   Dirsearch* dirpath_;
 414   Mapfile* mapfile_;
 415   Task_token* this_blocker_;
 416
 417   // An extra directory to search for the libraries passed by
 418   // add_input_library.
 419   std::string extra_search_path_;
 420   Lock* lock_;
 421   Initialize_lock initialize_lock_;
 422
 423   // Keep track of all symbols defined by defsym.
 424   typedef Unordered_set<std::string> Defsym_defines_set;
 425   Defsym_defines_set defsym_defines_set_;
 426
 427   // Class to record plugin actions.
 428   Plugin_recorder* recorder_;
 429 };
 430
 431
 432 // An object file claimed by a plugin.  This is an abstract base class.
 433 // The implementation is the template class Sized_pluginobj.
 434
 435 class Pluginobj : public Object
 436 {
 437  public:
 438
 439   typedef std::vector<Symbol*> Symbols;
 440
 441   Pluginobj(const std::string& name, Input_file* input_file, off_t offset,
 442             off_t filesize);
 443
 444   // Fill in the symbol resolution status for the given plugin symbols.
 445   ld_plugin_status
 446   get_symbol_resolution_info(Symbol_table* symtab,
 447                              int nsyms,
 448                              ld_plugin_symbol* syms,
 449                              int version) const;
 450
 451   // Store the incoming symbols from the plugin for later processing.
 452   void
 453   store_incoming_symbols(int nsyms, const struct ld_plugin_symbol* syms)
 454   {
 455     this->nsyms_ = nsyms;
 456     this->syms_ = syms;
 457   }
 458
 459   // Return TRUE if the comdat group with key COMDAT_KEY from this object
 460   // should be kept.
 461   bool
 462   include_comdat_group(std::string comdat_key, Layout* layout);
 463
 464   // Return the filename.
 465   const std::string&
 466   filename() const
 467   { return this->input_file()->filename(); }
 468
 469   // Return the file descriptor.
 470   int
 471   descriptor()
 472   { return this->input_file()->file().descriptor(); }
 473
 474   // Return the size of the file or archive member.
 475   off_t
 476   filesize()
 477   { return this->filesize_; }
 478
 479   // Return the word size of the object file.
 480   int
 481   elfsize() const
 482   { gold_unreachable(); }
 483
 484   // Return TRUE if this is a big-endian object file.
 485   bool
 486   is_big_endian() const
 487   { gold_unreachable(); }
 488
 489  protected:
 490   // Return TRUE if this is an object claimed by a plugin.
 491   virtual Pluginobj*
 492   do_pluginobj()
 493   { return this; }
 494
 495   // The number of symbols provided by the plugin.
 496   int nsyms_;
 497
 498   // The symbols provided by the plugin.
 499   const struct ld_plugin_symbol* syms_;
 500
 501   // The entries in the symbol table for the external symbols.
 502   Symbols symbols_;
 503
 504  private:
 505   // Size of the file (or archive member).
 506   off_t filesize_;
 507   // Map a comdat key symbol to a boolean indicating whether the comdat
 508   // group in this object with that key should be kept.
 509   typedef Unordered_map<std::string, bool> Comdat_map;
 510   Comdat_map comdat_map_;
 511 };
 512
 513 // A plugin object, size-specific version.
 514
 515 template<int size, bool big_endian>
 516 class Sized_pluginobj : public Pluginobj
 517 {
 518  public:
 519   Sized_pluginobj(const std::string& name, Input_file* input_file,
 520                   off_t offset, off_t filesize);
 521
 522   // Read the symbols.
 523   void
 524   do_read_symbols(Read_symbols_data*);
 525
 526   // Lay out the input sections.
 527   void
 528   do_layout(Symbol_table*, Layout*, Read_symbols_data*);
 529
 530   // Add the symbols to the symbol table.
 531   void
 532   do_add_symbols(Symbol_table*, Read_symbols_data*, Layout*);
 533
 534   Archive::Should_include
 535   do_should_include_member(Symbol_table* symtab, Layout*, Read_symbols_data*,
 536                            std::string* why);
 537
 538   // Iterate over global symbols, calling a visitor class V for each.
 539   void
 540   do_for_all_global_symbols(Read_symbols_data* sd,
 541                             Library_base::Symbol_visitor_base* v);
 542
 543   // Iterate over local symbols, calling a visitor class V for each GOT offset
 544   // associated with a local symbol.
 545   void
 546   do_for_all_local_got_entries(Got_offset_list::Visitor* v) const;
 547
 548   // Get the size of a section.
 549   uint64_t
 550   do_section_size(unsigned int shndx);
 551
 552   // Get the name of a section.
 553   std::string
 554   do_section_name(unsigned int shndx) const;
 555
 556   // Return a view of the contents of a section.
 557   const unsigned char*
 558   do_section_contents(unsigned int shndx, section_size_type* plen,
 559                       bool cache);
 560
 561   // Return section flags.
 562   uint64_t
 563   do_section_flags(unsigned int shndx);
 564
 565   // Return section entsize.
 566   uint64_t
 567   do_section_entsize(unsigned int shndx);
 568
 569   // Return section address.
 570   uint64_t
 571   do_section_address(unsigned int shndx);
 572
 573   // Return section type.
 574   unsigned int
 575   do_section_type(unsigned int shndx);
 576
 577   // Return the section link field.
 578   unsigned int
 579   do_section_link(unsigned int shndx);
 580
 581   // Return the section link field.
 582   unsigned int
 583   do_section_info(unsigned int shndx);
 584
 585   // Return the section alignment.
 586   uint64_t
 587   do_section_addralign(unsigned int shndx);
 588
 589   // Return the Xindex structure to use.
 590   Xindex*
 591   do_initialize_xindex();
 592
 593   // Get symbol counts.
 594   void
 595   do_get_global_symbol_counts(const Symbol_table*, size_t*, size_t*) const;
 596
 597   // Get global symbols.
 598   const Symbols*
 599   do_get_global_symbols() const;
 600
 601   // Add placeholder symbols from a claimed file.
 602   ld_plugin_status
 603   add_symbols_from_plugin(int nsyms, const ld_plugin_symbol* syms);
 604
 605  protected:
 606
 607  private:
 608 };
 609
 610 // This Task handles handles the "all symbols read" event hook.
 611 // The plugin may add additional input files at this time, which must
 612 // be queued for reading.
 613
 614 class Plugin_hook : public Task
 615 {
 616  public:
 617   Plugin_hook(const General_options& options, Input_objects* input_objects,
 618               Symbol_table* symtab, Layout* /*layout*/, Dirsearch* dirpath,
 619               Mapfile* mapfile, Task_token* this_blocker,
 620               Task_token* next_blocker)
 621     : options_(options), input_objects_(input_objects), symtab_(symtab),
 622       dirpath_(dirpath), mapfile_(mapfile),
 623       this_blocker_(this_blocker), next_blocker_(next_blocker)
 624   { }
 625
 626   ~Plugin_hook();
 627
 628   // The standard Task methods.
 629
 630   Task_token*
 631   is_runnable();
 632
 633   void
 634   locks(Task_locker*);
 635
 636   void
 637   run(Workqueue*);
 638
 639   std::string
 640   get_name() const
 641   { return "Plugin_hook"; }
 642
 643  private:
 644   const General_options& options_;
 645   Input_objects* input_objects_;
 646   Symbol_table* symtab_;
 647   Dirsearch* dirpath_;
 648   Mapfile* mapfile_;
 649   Task_token* this_blocker_;
 650   Task_token* next_blocker_;
 651 };
 652
 653 } // End namespace gold.
 654
 655 #endif // !defined(GOLD_PLUGIN_H)