gold/gold.cc

   1 // gold.cc -- main linker functions
   2
   3 #include "gold.h"
   4
   5 #include <cstdlib>
   6 #include <cstdio>
   7 #include <cstring>
   8 #include <unistd.h>
   9
  10 #include "options.h"
  11 #include "workqueue.h"
  12 #include "dirsearch.h"
  13 #include "readsyms.h"
  14 #include "symtab.h"
  15 #include "common.h"
  16 #include "object.h"
  17 #include "layout.h"
  18 #include "reloc.h"
  19 #include "defstd.h"
  20
  21 namespace gold
  22 {
  23
  24 const char* program_name;
  25
  26 void
  27 gold_exit(bool status)
  28 {
  29   exit(status ? EXIT_SUCCESS : EXIT_FAILURE);
  30 }
  31
  32 void
  33 gold_fatal(const char* msg, bool perrno)
  34 {
  35   fprintf(stderr, "%s: ", program_name);
  36   if (perrno)
  37     perror(msg);
  38   else
  39     fprintf(stderr, "%s\n", msg);
  40   gold_exit(false);
  41 }
  42
  43 void
  44 gold_nomem()
  45 {
  46   // We are out of memory, so try hard to print a reasonable message.
  47   // Note that we don't try to translate this message, since the
  48   // translation process itself will require memory.
  49   write(2, program_name, strlen(program_name));
  50   const char* const s = ": out of memory\n";
  51   write(2, s, strlen(s));
  52   gold_exit(false);
  53 }
  54
  55 // Handle an unreachable case.
  56
  57 void
  58 do_gold_unreachable(const char* filename, int lineno, const char* function)
  59 {
  60   fprintf(stderr, "%s: internal error in %s, at %s:%d\n",
  61           program_name, function, filename, lineno);
  62   gold_exit(false);
  63 }
  64
  65 // This class arranges to run the functions done in the middle of the
  66 // link.  It is just a closure.
  67
  68 class Middle_runner : public Task_function_runner
  69 {
  70  public:
  71   Middle_runner(const General_options& options,
  72                 const Input_objects* input_objects,
  73                 Symbol_table* symtab,
  74                 Layout* layout)
  75     : options_(options), input_objects_(input_objects), symtab_(symtab),
  76       layout_(layout)
  77   { }
  78
  79   void
  80   run(Workqueue*);
  81
  82  private:
  83   const General_options& options_;
  84   const Input_objects* input_objects_;
  85   Symbol_table* symtab_;
  86   Layout* layout_;
  87 };
  88
  89 void
  90 Middle_runner::run(Workqueue* workqueue)
  91 {
  92   queue_middle_tasks(this->options_, this->input_objects_, this->symtab_,
  93                      this->layout_, workqueue);
  94 }
  95
  96 // Queue up the initial set of tasks for this link job.
  97
  98 void
  99 queue_initial_tasks(const General_options& options,
 100                     const Dirsearch& search_path,
 101                     const Command_line& cmdline,
 102                     Workqueue* workqueue, Input_objects* input_objects,
 103                     Symbol_table* symtab, Layout* layout)
 104 {
 105   if (cmdline.begin() == cmdline.end())
 106     gold_fatal(_("no input files"), false);
 107
 108   // Read the input files.  We have to add the symbols to the symbol
 109   // table in order.  We do this by creating a separate blocker for
 110   // each input file.  We associate the blocker with the following
 111   // input file, to give us a convenient place to delete it.
 112   Task_token* this_blocker = NULL;
 113   for (Command_line::const_iterator p = cmdline.begin();
 114        p != cmdline.end();
 115        ++p)
 116     {
 117       Task_token* next_blocker = new Task_token();
 118       next_blocker->add_blocker();
 119       workqueue->queue(new Read_symbols(options, input_objects, symtab, layout,
 120                                         search_path, &*p, NULL, this_blocker,
 121                                         next_blocker));
 122       this_blocker = next_blocker;
 123     }
 124
 125   workqueue->queue(new Task_function(new Middle_runner(options,
 126                                                        input_objects,
 127                                                        symtab,
 128                                                        layout),
 129                                      this_blocker));
 130 }
 131
 132 // Queue up the middle set of tasks.  These are the tasks which run
 133 // after all the input objects have been found and all the symbols
 134 // have been read, but before we lay out the output file.
 135
 136 void
 137 queue_middle_tasks(const General_options& options,
 138                    const Input_objects* input_objects,
 139                    Symbol_table* symtab,
 140                    Layout* layout,
 141                    Workqueue* workqueue)
 142 {
 143   // Define some sections and symbols needed for a dynamic link.  This
 144   // handles some cases we want to see before we read the relocs.
 145   layout->create_initial_dynamic_sections(input_objects, symtab);
 146
 147   // Predefine standard symbols.  This should be fast, so we don't
 148   // bother to create a task for it.
 149   define_standard_symbols(symtab, layout, input_objects->target());
 150
 151   // Read the relocations of the input files.  We do this to find
 152   // which symbols are used by relocations which require a GOT and/or
 153   // a PLT entry, or a COPY reloc.  When we implement garbage
 154   // collection we will do it here by reading the relocations in a
 155   // breadth first search by references.
 156   //
 157   // We could also read the relocations during the first pass, and
 158   // mark symbols at that time.  That is how the old GNU linker works.
 159   // Doing that is more complex, since we may later decide to discard
 160   // some of the sections, and thus change our minds about the types
 161   // of references made to the symbols.
 162   Task_token* blocker = new Task_token();
 163   Task_token* symtab_lock = new Task_token();
 164   for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
 165        p != input_objects->relobj_end();
 166        ++p)
 167     {
 168       // We can read and process the relocations in any order.  But we
 169       // only want one task to write to the symbol table at a time.
 170       // So we queue up a task for each object to read the
 171       // relocations.  That task will in turn queue a task to wait
 172       // until it can write to the symbol table.
 173       blocker->add_blocker();
 174       workqueue->queue(new Read_relocs(options, symtab, layout, *p,
 175                                        symtab_lock, blocker));
 176     }
 177
 178   // Allocate common symbols.  This requires write access to the
 179   // symbol table, but is independent of the relocation processing.
 180   blocker->add_blocker();
 181   workqueue->queue(new Allocate_commons_task(options, symtab, layout,
 182                                              symtab_lock, blocker));
 183
 184   // When all those tasks are complete, we can start laying out the
 185   // output file.
 186   workqueue->queue(new Task_function(new Layout_task_runner(options,
 187                                                             input_objects,
 188                                                             symtab,
 189                                                             layout),
 190                                      blocker));
 191 }
 192
 193 // Queue up the final set of tasks.  This is called at the end of
 194 // Layout_task.
 195
 196 void
 197 queue_final_tasks(const General_options& options,
 198                   const Input_objects* input_objects,
 199                   const Symbol_table* symtab,
 200                   const Layout* layout,
 201                   Workqueue* workqueue,
 202                   Output_file* of)
 203 {
 204   // Use a blocker to block the final cleanup task.
 205   Task_token* final_blocker = new Task_token();
 206
 207   // Queue a task for each input object to relocate the sections and
 208   // write out the local symbols.
 209   for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
 210        p != input_objects->relobj_end();
 211        ++p)
 212     {
 213       final_blocker->add_blocker();
 214       workqueue->queue(new Relocate_task(options, symtab, layout, *p, of,
 215                                          final_blocker));
 216     }
 217
 218   // Queue a task to write out the symbol table.
 219   final_blocker->add_blocker();
 220   workqueue->queue(new Write_symbols_task(symtab,
 221                                           input_objects->target(),
 222                                           layout->sympool(),
 223                                           layout->dynpool(),
 224                                           of,
 225                                           final_blocker));
 226
 227   // Queue a task to write out everything else.
 228   final_blocker->add_blocker();
 229   workqueue->queue(new Write_data_task(layout, symtab,
 230                                        input_objects->target(),
 231                                        of, final_blocker));
 232
 233   // Queue a task to close the output file.  This will be blocked by
 234   // FINAL_BLOCKER.
 235   workqueue->queue(new Task_function(new Close_task_runner(of),
 236                                      final_blocker));
 237 }
 238
 239 } // End namespace gold.