gold/readsyms.h

   1 // readsyms.h -- read input file symbols for gold   -*- C++ -*-
   2
   3 // Copyright (C) 2006-2023 Free Software Foundation, Inc.
   4 // Written by Ian Lance Taylor <iant@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_READSYMS_H
  24 #define GOLD_READSYMS_H
  25
  26 #include <vector>
  27
  28 #include "workqueue.h"
  29 #include "object.h"
  30 #include "incremental.h"
  31
  32 namespace gold
  33 {
  34
  35 class Input_objects;
  36 class Symbol_table;
  37 class Input_group;
  38 class Archive;
  39 class Finish_group;
  40
  41 // This Task is responsible for reading the symbols from an input
  42 // file.  This also includes reading the relocations so that we can
  43 // check for any that require a PLT and/or a GOT.  After the data has
  44 // been read, this queues up another task to actually add the symbols
  45 // to the symbol table.  The tasks are separated because the file
  46 // reading can occur in parallel but adding the symbols must be done
  47 // in the order of the input files.
  48
  49 class Read_symbols : public Task
  50 {
  51  public:
  52   // DIRPATH is the list of directories to search for libraries.
  53   // INPUT is the file to read.  INPUT_GROUP is not NULL if we are in
  54   // the middle of an input group.  THIS_BLOCKER is used to prevent
  55   // the associated Add_symbols task from running before the previous
  56   // one has completed; it will be NULL for the first task.
  57   // NEXT_BLOCKER is used to block the next input file from adding
  58   // symbols.
  59   Read_symbols(Input_objects* input_objects, Symbol_table* symtab,
  60                Layout* layout, Dirsearch* dirpath, int dirindex,
  61                Mapfile* mapfile, const Input_argument* input_argument,
  62                Input_group* input_group, Archive_member* member,
  63                Task_token* this_blocker, Task_token* next_blocker)
  64     : input_objects_(input_objects), symtab_(symtab), layout_(layout),
  65       dirpath_(dirpath), dirindex_(dirindex), mapfile_(mapfile),
  66       input_argument_(input_argument), input_group_(input_group),
  67       member_(member), this_blocker_(this_blocker),
  68       next_blocker_(next_blocker)
  69   { }
  70
  71   ~Read_symbols();
  72
  73   // If appropriate, issue a warning about skipping an incompatible
  74   // object.
  75   static void
  76   incompatible_warning(const Input_argument*, const Input_file*);
  77
  78   // Requeue a Read_symbols task to search for the next object with
  79   // the same name.
  80   static void
  81   requeue(Workqueue*, Input_objects*, Symbol_table*, Layout*, Dirsearch*,
  82           int dirindex, Mapfile*, const Input_argument*, Input_group*,
  83           Task_token* next_blocker);
  84
  85   // The standard Task methods.
  86
  87   Task_token*
  88   is_runnable();
  89
  90   void
  91   locks(Task_locker*);
  92
  93   void
  94   run(Workqueue*);
  95
  96   std::string
  97   get_name() const;
  98
  99  private:
 100   // Handle an archive group.
 101   void
 102   do_group(Workqueue*);
 103
 104   // Handle --start-lib ... --end-lib
 105   bool
 106   do_lib_group(Workqueue*);
 107
 108   // Handle --whole-archive --start-lib ... --end-lib --no-whole-archive
 109   bool
 110   do_whole_lib_group(Workqueue*);
 111
 112   // Open and identify the file.
 113   bool
 114   do_read_symbols(Workqueue*);
 115
 116   Input_objects* input_objects_;
 117   Symbol_table* symtab_;
 118   Layout* layout_;
 119   Dirsearch* dirpath_;
 120   int dirindex_;
 121   Mapfile* mapfile_;
 122   const Input_argument* input_argument_;
 123   Input_group* input_group_;
 124   Archive_member* member_;
 125   Task_token* this_blocker_;
 126   Task_token* next_blocker_;
 127 };
 128
 129 // This Task handles adding the symbols to the symbol table.  These
 130 // tasks must be run in the same order as the arguments appear on the
 131 // command line.
 132
 133 class Add_symbols : public Task
 134 {
 135  public:
 136   // THIS_BLOCKER is used to prevent this task from running before the
 137   // one for the previous input file.  NEXT_BLOCKER is used to prevent
 138   // the next task from running.
 139   Add_symbols(Input_objects* input_objects, Symbol_table* symtab,
 140               Layout* layout, Dirsearch* /*dirpath*/, int /*dirindex*/,
 141               Mapfile* /*mapfile*/, const Input_argument* input_argument,
 142               Object* object, Incremental_library* library,
 143               Read_symbols_data* sd, Task_token* this_blocker,
 144               Task_token* next_blocker)
 145     : input_objects_(input_objects), symtab_(symtab), layout_(layout),
 146       input_argument_(input_argument), object_(object), library_(library),
 147       sd_(sd), this_blocker_(this_blocker), next_blocker_(next_blocker)
 148   { }
 149
 150   ~Add_symbols();
 151
 152   // The standard Task methods.
 153
 154   Task_token*
 155   is_runnable();
 156
 157   void
 158   locks(Task_locker*);
 159
 160   void
 161   run(Workqueue*);
 162
 163   std::string
 164   get_name() const
 165   { return "Add_symbols " + this->object_->name(); }
 166
 167 private:
 168   Input_objects* input_objects_;
 169   Symbol_table* symtab_;
 170   Layout* layout_;
 171   const Input_argument* input_argument_;
 172   Object* object_;
 173   Incremental_library* library_;
 174   Read_symbols_data* sd_;
 175   Task_token* this_blocker_;
 176   Task_token* next_blocker_;
 177 };
 178
 179 // This Task is responsible for reading the symbols from an archive
 180 // member that has changed since the last incremental link.
 181
 182 class Read_member : public Task
 183 {
 184  public:
 185   // INPUT is the file to read.  INPUT_GROUP is not NULL if we are in
 186   // the middle of an input group.  THIS_BLOCKER is used to prevent
 187   // the associated Add_symbols task from running before the previous
 188   // one has completed; it will be NULL for the first task.
 189   // NEXT_BLOCKER is used to block the next input file from adding
 190   // symbols.
 191   Read_member(Input_objects* /*input_objects*/, Symbol_table* /*symtab*/,
 192               Layout* /*layout*/, Mapfile* /*mapfile*/,
 193               const Incremental_binary::Input_reader* input_reader,
 194               Task_token* this_blocker, Task_token* next_blocker)
 195     : input_reader_(input_reader),
 196       this_blocker_(this_blocker), next_blocker_(next_blocker)
 197   { }
 198
 199   ~Read_member();
 200
 201   // The standard Task methods.
 202
 203   Task_token*
 204   is_runnable();
 205
 206   void
 207   locks(Task_locker*);
 208
 209   void
 210   run(Workqueue*);
 211
 212   std::string
 213   get_name() const
 214   {
 215     return (std::string("Read_member ") + this->input_reader_->filename());
 216   }
 217
 218  private:
 219   const Incremental_binary::Input_reader* input_reader_;
 220   Task_token* this_blocker_;
 221   Task_token* next_blocker_;
 222 };
 223
 224 // This Task is responsible for processing an input script file that has
 225 // not changed since the last incremental link.
 226
 227 class Check_script : public Task
 228 {
 229  public:
 230   Check_script(Layout* layout, Incremental_binary* ibase,
 231                unsigned int input_file_index,
 232                const Incremental_binary::Input_reader* input_reader,
 233                Task_token* this_blocker, Task_token* next_blocker)
 234     : layout_(layout), ibase_(ibase), input_file_index_(input_file_index),
 235       input_reader_(input_reader), this_blocker_(this_blocker),
 236       next_blocker_(next_blocker)
 237   {
 238     this->filename_ = std::string(this->input_reader_->filename());
 239   }
 240
 241   ~Check_script();
 242
 243   // The standard Task methods.
 244
 245   Task_token*
 246   is_runnable();
 247
 248   void
 249   locks(Task_locker*);
 250
 251   void
 252   run(Workqueue*);
 253
 254   std::string
 255   get_name() const
 256   {
 257     return (std::string("Check_script ") + this->input_reader_->filename());
 258   }
 259
 260  private:
 261   std::string filename_;
 262   Layout* layout_;
 263   Incremental_binary* ibase_;
 264   unsigned int input_file_index_;
 265   const Incremental_binary::Input_reader* input_reader_;
 266   Task_token* this_blocker_;
 267   Task_token* next_blocker_;
 268 };
 269
 270 // This Task is responsible for processing an archive library that has
 271 // not changed since the last incremental link.
 272
 273 class Check_library : public Task
 274 {
 275  public:
 276   Check_library(Symbol_table* /*symtab*/, Layout* layout,
 277                 Incremental_binary* ibase,
 278                 unsigned int input_file_index,
 279                 const Incremental_binary::Input_reader* input_reader,
 280                 Task_token* this_blocker, Task_token* next_blocker)
 281     : layout_(layout), ibase_(ibase),
 282       input_file_index_(input_file_index), input_reader_(input_reader),
 283       this_blocker_(this_blocker), next_blocker_(next_blocker)
 284   { }
 285
 286   ~Check_library();
 287
 288   // The standard Task methods.
 289
 290   Task_token*
 291   is_runnable();
 292
 293   void
 294   locks(Task_locker*);
 295
 296   void
 297   run(Workqueue*);
 298
 299   std::string
 300   get_name() const
 301   {
 302     return (std::string("Check_library ") + this->input_reader_->filename());
 303   }
 304
 305  private:
 306   Layout* layout_;
 307   Incremental_binary* ibase_;
 308   unsigned int input_file_index_;
 309   const Incremental_binary::Input_reader* input_reader_;
 310   Task_token* this_blocker_;
 311   Task_token* next_blocker_;
 312 };
 313
 314 // This class is used to track the archives in a group.
 315
 316 class Input_group
 317 {
 318  public:
 319   typedef std::vector<Archive*> Archives;
 320   typedef Archives::const_iterator const_iterator;
 321
 322   Input_group()
 323     : archives_()
 324   { }
 325
 326   ~Input_group();
 327
 328   // Add an archive to the group.
 329   void
 330   add_archive(Archive* arch)
 331   { this->archives_.push_back(arch); }
 332
 333   // Loop over the archives in the group.
 334
 335   const_iterator
 336   begin() const
 337   { return this->archives_.begin(); }
 338
 339   const_iterator
 340   end() const
 341   { return this->archives_.end(); }
 342
 343  private:
 344   Archives archives_;
 345 };
 346
 347 // This class starts the handling of a group.  It exists only to pick
 348 // up the number of undefined symbols at that point, so that we only
 349 // run back through the group if we saw a new undefined symbol.
 350
 351 class Start_group : public Task
 352 {
 353  public:
 354   Start_group(Symbol_table* symtab, Finish_group* finish_group,
 355               Task_token* this_blocker, Task_token* next_blocker)
 356     : symtab_(symtab), finish_group_(finish_group),
 357       this_blocker_(this_blocker), next_blocker_(next_blocker)
 358   { }
 359
 360   ~Start_group();
 361
 362   // The standard Task methods.
 363
 364   Task_token*
 365   is_runnable();
 366
 367   void
 368   locks(Task_locker*);
 369
 370   void
 371   run(Workqueue*);
 372
 373   std::string
 374   get_name() const
 375   { return "Start_group"; }
 376
 377  private:
 378   Symbol_table* symtab_;
 379   Finish_group* finish_group_;
 380   Task_token* this_blocker_;
 381   Task_token* next_blocker_;
 382 };
 383
 384 // This class is used to finish up handling a group.  It is just a
 385 // closure.
 386
 387 class Finish_group : public Task
 388 {
 389  public:
 390   Finish_group(Input_objects* input_objects, Symbol_table* symtab,
 391                Layout* layout, Mapfile* mapfile, Input_group* input_group,
 392                Task_token* next_blocker)
 393     : input_objects_(input_objects), symtab_(symtab),
 394       layout_(layout), mapfile_(mapfile), input_group_(input_group),
 395       saw_undefined_(0), this_blocker_(NULL), next_blocker_(next_blocker)
 396   { }
 397
 398   ~Finish_group();
 399
 400   // Set the number of undefined symbols when we start processing the
 401   // group.  This is called by the Start_group task.
 402   void
 403   set_saw_undefined(size_t saw_undefined)
 404   { this->saw_undefined_ = saw_undefined; }
 405
 406   // Set the blocker to use for this task.
 407   void
 408   set_blocker(Task_token* this_blocker)
 409   {
 410     gold_assert(this->this_blocker_ == NULL);
 411     this->this_blocker_ = this_blocker;
 412   }
 413
 414   // The standard Task methods.
 415
 416   Task_token*
 417   is_runnable();
 418
 419   void
 420   locks(Task_locker*);
 421
 422   void
 423   run(Workqueue*);
 424
 425   std::string
 426   get_name() const
 427   { return "Finish_group"; }
 428
 429  private:
 430   Input_objects* input_objects_;
 431   Symbol_table* symtab_;
 432   Layout* layout_;
 433   Mapfile* mapfile_;
 434   Input_group* input_group_;
 435   size_t saw_undefined_;
 436   Task_token* this_blocker_;
 437   Task_token* next_blocker_;
 438 };
 439
 440 // This class is used to read a file which was not recognized as an
 441 // object or archive.  It tries to read it as a linker script, using
 442 // the tokens to serialize with the calls to Add_symbols.
 443
 444 class Read_script : public Task
 445 {
 446  public:
 447   Read_script(Symbol_table* symtab, Layout* layout, Dirsearch* dirpath,
 448               int dirindex, Input_objects* input_objects, Mapfile* mapfile,
 449               Input_group* input_group, const Input_argument* input_argument,
 450               Input_file* input_file, Task_token* this_blocker,
 451               Task_token* next_blocker)
 452     : symtab_(symtab), layout_(layout), dirpath_(dirpath), dirindex_(dirindex),
 453       input_objects_(input_objects), mapfile_(mapfile),
 454       input_group_(input_group), input_argument_(input_argument),
 455       input_file_(input_file), this_blocker_(this_blocker),
 456       next_blocker_(next_blocker)
 457   { }
 458
 459   ~Read_script();
 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
 475  private:
 476   Symbol_table* symtab_;
 477   Layout* layout_;
 478   Dirsearch* dirpath_;
 479   int dirindex_;
 480   Input_objects* input_objects_;
 481   Mapfile* mapfile_;
 482   Input_group* input_group_;
 483   const Input_argument* input_argument_;
 484   Input_file* input_file_;
 485   Task_token* this_blocker_;
 486   Task_token* next_blocker_;
 487 };
 488
 489 } // end namespace gold
 490
 491 #endif // !defined(GOLD_READSYMS_H)