gold/readsyms.cc

   1 // readsyms.cc -- read input file symbols for gold
   2
   3 #include "gold.h"
   4
   5 #include <cstring>
   6
   7 #include "elfcpp.h"
   8 #include "options.h"
   9 #include "dirsearch.h"
  10 #include "object.h"
  11 #include "archive.h"
  12 #include "readsyms.h"
  13
  14 namespace gold
  15 {
  16
  17 // Class read_symbols.
  18
  19 Read_symbols::~Read_symbols()
  20 {
  21   // The this_blocker_ and next_blocker_ pointers are passed on to the
  22   // Add_symbols task.
  23 }
  24
  25 // Return whether a Read_symbols task is runnable.  We need write
  26 // access to the symbol table.  We can read an ordinary input file
  27 // immediately.  For an archive specified using -l, we have to wait
  28 // until the search path is complete.
  29
  30 Task::Is_runnable_type
  31 Read_symbols::is_runnable(Workqueue*)
  32 {
  33   if (this->input_.is_lib() && this->dirpath_.token().is_blocked())
  34     return IS_BLOCKED;
  35
  36   return IS_RUNNABLE;
  37 }
  38
  39 // Return a Task_locker for a Read_symbols task.  We don't need any
  40 // locks here.
  41
  42 Task_locker*
  43 Read_symbols::locks(Workqueue*)
  44 {
  45   return NULL;
  46 }
  47
  48 // Run a Read_symbols task.  This is where we actually read the
  49 // symbols and relocations.
  50
  51 void
  52 Read_symbols::run(Workqueue* workqueue)
  53 {
  54   Input_file* input_file = new Input_file(this->input_);
  55   input_file->open(this->options_, this->dirpath_);
  56
  57   // Read enough of the file to pick up the entire ELF header.
  58
  59   int ehdr_size = elfcpp::Elf_sizes<64>::ehdr_size;
  60   off_t bytes;
  61   const unsigned char* p = input_file->file().get_view(0, ehdr_size, &bytes);
  62   if (bytes >= 4)
  63     {
  64       static unsigned char elfmagic[4] =
  65         {
  66           elfcpp::ELFMAG0, elfcpp::ELFMAG1,
  67           elfcpp::ELFMAG2, elfcpp::ELFMAG3
  68         };
  69       if (memcmp(p, elfmagic, 4) == 0)
  70         {
  71           // This is an ELF object.
  72           Object* obj = make_elf_object(this->input_.name(), input_file, 0,
  73                                         p, bytes);
  74
  75           this->input_objects_->add_object(obj);
  76
  77           Read_symbols_data* sd = new Read_symbols_data;
  78           obj->read_symbols(sd);
  79           workqueue->queue(new Add_symbols(this->symtab_, this->layout_,
  80                                            obj, sd,
  81                                            this->this_blocker_,
  82                                            this->next_blocker_));
  83
  84           // Opening the file locked it, so now we need to unlock it.
  85           input_file->file().unlock();
  86
  87           return;
  88         }
  89     }
  90
  91   if (bytes >= Archive::sarmag)
  92     {
  93       if (memcmp(p, Archive::armag, Archive::sarmag) == 0)
  94         {
  95           // This is an archive.
  96           Archive* arch = new Archive(this->input_.name(), input_file);
  97           arch->setup();
  98           workqueue->queue(new Add_archive_symbols(this->symtab_,
  99                                                    this->layout_,
 100                                                    this->input_objects_,
 101                                                    arch,
 102                                                    this->this_blocker_,
 103                                                    this->next_blocker_));
 104           return;
 105         }
 106     }
 107
 108   // Here we have to handle archives and any other input file
 109   // types we need.
 110   fprintf(stderr, _("%s: %s: not an object or archive\n"),
 111           program_name, input_file->file().filename().c_str());
 112   gold_exit(false);
 113 }
 114
 115 // Class Add_symbols.
 116
 117 Add_symbols::~Add_symbols()
 118 {
 119   if (this->this_blocker_ != NULL)
 120     delete this->this_blocker_;
 121   // next_blocker_ is deleted by the task associated with the next
 122   // input file.
 123 }
 124
 125 // We are blocked by this_blocker_.  We block next_blocker_.  We also
 126 // lock the file.
 127
 128 Task::Is_runnable_type
 129 Add_symbols::is_runnable(Workqueue*)
 130 {
 131   if (this->this_blocker_ != NULL && this->this_blocker_->is_blocked())
 132     return IS_BLOCKED;
 133   if (this->object_->is_locked())
 134     return IS_LOCKED;
 135   return IS_RUNNABLE;
 136 }
 137
 138 class Add_symbols::Add_symbols_locker : public Task_locker
 139 {
 140  public:
 141   Add_symbols_locker(Task_token& token, Workqueue* workqueue,
 142                      Object* object)
 143     : blocker_(token, workqueue), objlock_(*object)
 144   { }
 145
 146  private:
 147   Task_locker_block blocker_;
 148   Task_locker_obj<Object> objlock_;
 149 };
 150
 151 Task_locker*
 152 Add_symbols::locks(Workqueue* workqueue)
 153 {
 154   return new Add_symbols_locker(*this->next_blocker_, workqueue,
 155                                 this->object_);
 156 }
 157
 158 void
 159 Add_symbols::run(Workqueue*)
 160 {
 161   this->object_->layout(this->layout_, this->sd_);
 162   this->object_->add_symbols(this->symtab_, this->sd_);
 163   delete this->sd_;
 164   this->sd_ = NULL;
 165 }
 166
 167 } // End namespace gold.