gold/gold.cc

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