gold/readsyms.h

   1 // readsyms.h -- read input file symbols for gold   -*- C++ -*-
   2
   3 #ifndef GOLD_READSYMS_H
   4 #define GOLD_READSYMS_H
   5
   6 #include "workqueue.h"
   7 #include "object.h"
   8
   9 namespace gold
  10 {
  11
  12 class Input_objects;
  13 class Symbol_table;
  14
  15 // This Task is responsible for reading the symbols from an input
  16 // file.  This also includes reading the relocations so that we can
  17 // check for any that require a PLT and/or a GOT.  After the data has
  18 // been read, this queues up another task to actually add the symbols
  19 // to the symbol table.  The tasks are separated because the file
  20 // reading can occur in parallel but adding the symbols must be done
  21 // in the order of the input files.
  22
  23 class Read_symbols : public Task
  24 {
  25  public:
  26   // DIRPATH is the list of directories to search for libraries.
  27   // INPUT is the file to read.  THIS_BLOCKER is used to prevent the
  28   // associated Add_symbols task from running before the previous one
  29   // has completed; it will be NULL for the first task.  NEXT_BLOCKER
  30   // is used to block the next input file from adding symbols.
  31   Read_symbols(const General_options& options, Input_objects* input_objects,
  32                Symbol_table* symtab, const Dirsearch& dirpath,
  33                const Input_argument& input,
  34                Task_token* this_blocker, Task_token* next_blocker)
  35     : options_(options), input_objects_(input_objects), symtab_(symtab),
  36       dirpath_(dirpath), input_(input), this_blocker_(this_blocker),
  37       next_blocker_(next_blocker)
  38   { }
  39
  40   ~Read_symbols();
  41
  42   // The standard Task methods.
  43
  44   Is_runnable_type
  45   is_runnable(Workqueue*);
  46
  47   Task_locker*
  48   locks(Workqueue*);
  49
  50   void
  51   run(Workqueue*);
  52
  53  private:
  54   const General_options& options_;
  55   Input_objects* input_objects_;
  56   Symbol_table* symtab_;
  57   const Dirsearch& dirpath_;
  58   const Input_argument& input_;
  59   Task_token* this_blocker_;
  60   Task_token* next_blocker_;
  61 };
  62
  63 // This Task handles adding the symbols to the symbol table.  These
  64 // tasks must be run in the same order as the arguments appear on the
  65 // command line.
  66
  67 class Add_symbols : public Task
  68 {
  69  public:
  70   // THIS_BLOCKER is used to prevent this task from running before the
  71   // one for the previous input file.  NEXT_BLOCKER is used to prevent
  72   // the next task from running.
  73   Add_symbols(Symbol_table* symtab, Object* object, Read_symbols_data sd,
  74               Task_token* this_blocker, Task_token* next_blocker)
  75     : symtab_(symtab), object_(object), sd_(sd), this_blocker_(this_blocker),
  76       next_blocker_(next_blocker)
  77   { }
  78
  79   ~Add_symbols();
  80
  81   // The standard Task methods.
  82
  83   Is_runnable_type
  84   is_runnable(Workqueue*);
  85
  86   Task_locker*
  87   locks(Workqueue*);
  88
  89   void
  90   run(Workqueue*);
  91
  92 private:
  93   class Add_symbols_locker;
  94
  95   Symbol_table* symtab_;
  96   Object* object_;
  97   Read_symbols_data sd_;
  98   Task_token* this_blocker_;
  99   Task_token* next_blocker_;
 100 };
 101
 102 } // end namespace gold
 103
 104 #endif // !defined(GOLD_READSYMS_H)