Merge branch 'vendor/GCC44'
[dragonfly.git] / contrib / binutils-2.22 / gold / gold.cc
1 // gold.cc -- main linker functions
2
3 // Copyright 2006, 2007, 2008, 2009, 2010, 2011 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 #include <algorithm>
30 #include "libiberty.h"
31
32 #include "options.h"
33 #include "target-select.h"
34 #include "debug.h"
35 #include "workqueue.h"
36 #include "dirsearch.h"
37 #include "readsyms.h"
38 #include "symtab.h"
39 #include "common.h"
40 #include "object.h"
41 #include "layout.h"
42 #include "reloc.h"
43 #include "defstd.h"
44 #include "plugin.h"
45 #include "gc.h"
46 #include "icf.h"
47 #include "incremental.h"
48
49 namespace gold
50 {
51
52 class Object;
53
54 const char* program_name;
55
56 static Task*
57 process_incremental_input(Incremental_binary*, unsigned int, Input_objects*,
58                           Symbol_table*, Layout*, Dirsearch*, Mapfile*,
59                           Task_token*, Task_token*);
60
61 void
62 gold_exit(Exit_status status)
63 {
64   if (parameters != NULL
65       && parameters->options_valid()
66       && parameters->options().has_plugins())
67     parameters->options().plugins()->cleanup();
68   if (status != GOLD_OK && parameters != NULL && parameters->options_valid())
69     unlink_if_ordinary(parameters->options().output_file_name());
70   exit(status);
71 }
72
73 void
74 gold_nomem()
75 {
76   // We are out of memory, so try hard to print a reasonable message.
77   // Note that we don't try to translate this message, since the
78   // translation process itself will require memory.
79
80   // LEN only exists to avoid a pointless warning when write is
81   // declared with warn_use_result, as when compiling with
82   // -D_USE_FORTIFY on GNU/Linux.  Casting to void does not appear to
83   // work, at least not with gcc 4.3.0.
84
85   ssize_t len = write(2, program_name, strlen(program_name));
86   if (len >= 0)
87     {
88       const char* const s = ": out of memory\n";
89       len = write(2, s, strlen(s));
90     }
91   gold_exit(GOLD_ERR);
92 }
93
94 // Handle an unreachable case.
95
96 void
97 do_gold_unreachable(const char* filename, int lineno, const char* function)
98 {
99   fprintf(stderr, _("%s: internal error in %s, at %s:%d\n"),
100           program_name, function, filename, lineno);
101   gold_exit(GOLD_ERR);
102 }
103
104 // This class arranges to run the functions done in the middle of the
105 // link.  It is just a closure.
106
107 class Middle_runner : public Task_function_runner
108 {
109  public:
110   Middle_runner(const General_options& options,
111                 const Input_objects* input_objects,
112                 Symbol_table* symtab,
113                 Layout* layout, Mapfile* mapfile)
114     : options_(options), input_objects_(input_objects), symtab_(symtab),
115       layout_(layout), mapfile_(mapfile)
116   { }
117
118   void
119   run(Workqueue*, const Task*);
120
121  private:
122   const General_options& options_;
123   const Input_objects* input_objects_;
124   Symbol_table* symtab_;
125   Layout* layout_;
126   Mapfile* mapfile_;
127 };
128
129 void
130 Middle_runner::run(Workqueue* workqueue, const Task* task)
131 {
132   queue_middle_tasks(this->options_, task, this->input_objects_, this->symtab_,
133                      this->layout_, workqueue, this->mapfile_);
134 }
135
136 // This class arranges the tasks to process the relocs for garbage collection.
137
138 class Gc_runner : public Task_function_runner 
139 {
140   public:
141    Gc_runner(const General_options& options,
142              const Input_objects* input_objects,
143              Symbol_table* symtab,
144              Layout* layout, Mapfile* mapfile)
145     : options_(options), input_objects_(input_objects), symtab_(symtab),
146       layout_(layout), mapfile_(mapfile)
147    { }
148
149   void
150   run(Workqueue*, const Task*);
151
152  private:
153   const General_options& options_;
154   const Input_objects* input_objects_;
155   Symbol_table* symtab_;
156   Layout* layout_;
157   Mapfile* mapfile_;
158 };
159
160 void
161 Gc_runner::run(Workqueue* workqueue, const Task* task)
162 {
163   queue_middle_gc_tasks(this->options_, task, this->input_objects_, 
164                         this->symtab_, this->layout_, workqueue, 
165                         this->mapfile_);
166 }
167
168 // Queue up the initial set of tasks for this link job.
169
170 void
171 queue_initial_tasks(const General_options& options,
172                     Dirsearch& search_path,
173                     const Command_line& cmdline,
174                     Workqueue* workqueue, Input_objects* input_objects,
175                     Symbol_table* symtab, Layout* layout, Mapfile* mapfile)
176 {
177   if (cmdline.begin() == cmdline.end())
178     {
179       bool is_ok = false;
180       if (options.printed_version())
181         is_ok = true;
182       if (options.print_output_format())
183         {
184           print_output_format();
185           is_ok = true;
186         }
187       if (is_ok)
188         gold_exit(GOLD_OK);
189       gold_fatal(_("no input files"));
190     }
191
192   int thread_count = options.thread_count_initial();
193   if (thread_count == 0)
194     thread_count = cmdline.number_of_input_files();
195   workqueue->set_thread_count(thread_count);
196
197   // For incremental links, the base output file.
198   Incremental_binary* ibase = NULL;
199
200   if (parameters->incremental())
201     {
202       if (options.relocatable())
203         gold_error(_("incremental linking is incompatible with -r"));
204       if (options.emit_relocs())
205         gold_error(_("incremental linking is incompatible with --emit-relocs"));
206       if (options.gc_sections())
207         gold_error(_("incremental linking is incompatible with --gc-sections"));
208       if (options.icf_enabled())
209         gold_error(_("incremental linking is incompatible with --icf"));
210       if (options.has_plugins())
211         gold_error(_("incremental linking is incompatible with --plugin"));
212       if (strcmp(options.compress_debug_sections(), "none") != 0)
213         gold_error(_("incremental linking is incompatible with "
214                      "--compress-debug-sections"));
215
216       if (parameters->incremental_update())
217         {
218           Output_file* of = new Output_file(options.output_file_name());
219           if (of->open_base_file(options.incremental_base(), true))
220             {
221               ibase = open_incremental_binary(of);
222               if (ibase != NULL
223                   && ibase->check_inputs(cmdline, layout->incremental_inputs()))
224                 ibase->init_layout(layout);
225               else
226                 {
227                   delete ibase;
228                   ibase = NULL;
229                   of->close();
230                 }
231             }
232           if (ibase == NULL)
233             {
234               if (set_parameters_incremental_full())
235                 gold_info(_("linking with --incremental-full"));
236               else
237                 gold_fallback(_("restart link with --incremental-full"));
238             }
239         }
240     }
241
242   // Read the input files.  We have to add the symbols to the symbol
243   // table in order.  We do this by creating a separate blocker for
244   // each input file.  We associate the blocker with the following
245   // input file, to give us a convenient place to delete it.
246   Task_token* this_blocker = NULL;
247   if (ibase == NULL)
248     {
249       // Normal link.  Queue a Read_symbols task for each input file
250       // on the command line.
251       for (Command_line::const_iterator p = cmdline.begin();
252            p != cmdline.end();
253            ++p)
254         {
255           Task_token* next_blocker = new Task_token(true);
256           next_blocker->add_blocker();
257           workqueue->queue(new Read_symbols(input_objects, symtab, layout,
258                                             &search_path, 0, mapfile, &*p, NULL,
259                                             NULL, this_blocker, next_blocker));
260           this_blocker = next_blocker;
261         }
262     }
263   else
264     {
265       // Incremental update link.  Process the list of input files
266       // stored in the base file, and queue a task for each file:
267       // a Read_symbols task for a changed file, and an Add_symbols task
268       // for an unchanged file.  We need to mark all the space used by
269       // unchanged files before we can start any tasks running.
270       unsigned int input_file_count = ibase->input_file_count();
271       std::vector<Task*> tasks;
272       tasks.reserve(input_file_count);
273       for (unsigned int i = 0; i < input_file_count; ++i)
274         {
275           Task_token* next_blocker = new Task_token(true);
276           next_blocker->add_blocker();
277           Task* t = process_incremental_input(ibase, i, input_objects, symtab,
278                                               layout, &search_path, mapfile,
279                                               this_blocker, next_blocker);
280           tasks.push_back(t);
281           this_blocker = next_blocker;
282         }
283       // Now we can queue the tasks.
284       for (unsigned int i = 0; i < tasks.size(); i++)
285         workqueue->queue(tasks[i]);
286     }
287
288   if (options.has_plugins())
289     {
290       Task_token* next_blocker = new Task_token(true);
291       next_blocker->add_blocker();
292       workqueue->queue(new Plugin_hook(options, input_objects, symtab, layout,
293                                        &search_path, mapfile, this_blocker,
294                                        next_blocker));
295       this_blocker = next_blocker;
296     }
297
298   if (options.relocatable()
299       && (options.gc_sections() || options.icf_enabled()))
300     gold_error(_("cannot mix -r with --gc-sections or --icf"));
301
302   if (options.gc_sections() || options.icf_enabled())
303     {
304       workqueue->queue(new Task_function(new Gc_runner(options,
305                                                        input_objects,
306                                                        symtab,
307                                                        layout,
308                                                        mapfile),
309                                          this_blocker,
310                                          "Task_function Gc_runner"));
311     }
312   else
313     {
314       workqueue->queue(new Task_function(new Middle_runner(options,
315                                                            input_objects,
316                                                            symtab,
317                                                            layout,
318                                                            mapfile),
319                                          this_blocker,
320                                          "Task_function Middle_runner"));
321     }
322 }
323
324 // Process an incremental input file: if it is unchanged from the previous
325 // link, return a task to add its symbols from the base file's incremental
326 // info; if it has changed, return a normal Read_symbols task.  We create a
327 // task for every input file, if only to report the file for rebuilding the
328 // incremental info.
329
330 static Task*
331 process_incremental_input(Incremental_binary* ibase,
332                           unsigned int input_file_index,
333                           Input_objects* input_objects,
334                           Symbol_table* symtab,
335                           Layout* layout,
336                           Dirsearch* search_path,
337                           Mapfile* mapfile,
338                           Task_token* this_blocker,
339                           Task_token* next_blocker)
340 {
341   const Incremental_binary::Input_reader* input_reader =
342       ibase->get_input_reader(input_file_index);
343   Incremental_input_type input_type = input_reader->type();
344
345   // Get the input argument corresponding to this input file, matching on
346   // the argument serial number.  If the input file cannot be matched
347   // to an existing input argument, synthesize a new one.
348   const Input_argument* input_argument =
349       ibase->get_input_argument(input_file_index);
350   if (input_argument == NULL)
351     {
352       Input_file_argument file(input_reader->filename(),
353                                Input_file_argument::INPUT_FILE_TYPE_FILE,
354                                "", false, parameters->options());
355       Input_argument* arg = new Input_argument(file);
356       arg->set_script_info(ibase->get_script_info(input_file_index));
357       input_argument = arg;
358     }
359
360   gold_debug(DEBUG_INCREMENTAL, "Incremental object: %s, type %d",
361              input_reader->filename(), input_type);
362
363   if (input_type == INCREMENTAL_INPUT_SCRIPT)
364     {
365       // Incremental_binary::check_inputs should have cancelled the
366       // incremental update if the script has changed.
367       gold_assert(!ibase->file_has_changed(input_file_index));
368       return new Check_script(layout, ibase, input_file_index, input_reader,
369                               this_blocker, next_blocker);
370     }
371
372   if (input_type == INCREMENTAL_INPUT_ARCHIVE)
373     {
374       Incremental_library* lib = ibase->get_library(input_file_index);
375       gold_assert(lib != NULL);
376       if (lib->filename() == "/group/"
377           || !ibase->file_has_changed(input_file_index))
378         {
379           // Queue a task to check that no references have been added to any
380           // of the library's unused symbols.
381           return new Check_library(symtab, layout, ibase, input_file_index,
382                                    input_reader, this_blocker, next_blocker);
383         }
384       else
385         {
386           // Queue a Read_symbols task to process the archive normally.
387           return new Read_symbols(input_objects, symtab, layout, search_path,
388                                   0, mapfile, input_argument, NULL, NULL,
389                                   this_blocker, next_blocker);
390         }
391     }
392
393   if (input_type == INCREMENTAL_INPUT_ARCHIVE_MEMBER)
394     {
395       // For archive members, check the timestamp of the containing archive.
396       Incremental_library* lib = ibase->get_library(input_file_index);
397       gold_assert(lib != NULL);
398       // Process members of a --start-lib/--end-lib group as normal objects.
399       if (lib->filename() != "/group/")
400         {
401           if (ibase->file_has_changed(lib->input_file_index()))
402             {
403               return new Read_member(input_objects, symtab, layout, mapfile,
404                                      input_reader, this_blocker, next_blocker);
405             }
406           else
407             {
408               // The previous contributions from this file will be kept.
409               // Mark the pieces of output sections contributed by this
410               // object.
411               ibase->reserve_layout(input_file_index);
412               Object* obj = make_sized_incremental_object(ibase,
413                                                           input_file_index,
414                                                           input_type,
415                                                           input_reader);
416               return new Add_symbols(input_objects, symtab, layout,
417                                      search_path, 0, mapfile, input_argument,
418                                      obj, lib, NULL, this_blocker,
419                                      next_blocker);
420             }
421         }
422     }
423
424   // Normal object file or shared library.  Check if the file has changed
425   // since the last incremental link.
426   if (ibase->file_has_changed(input_file_index))
427     {
428       return new Read_symbols(input_objects, symtab, layout, search_path, 0,
429                               mapfile, input_argument, NULL, NULL,
430                               this_blocker, next_blocker);
431     }
432   else
433     {
434       // The previous contributions from this file will be kept.
435       // Mark the pieces of output sections contributed by this object.
436       ibase->reserve_layout(input_file_index);
437       Object* obj = make_sized_incremental_object(ibase,
438                                                   input_file_index,
439                                                   input_type,
440                                                   input_reader);
441       return new Add_symbols(input_objects, symtab, layout, search_path, 0,
442                              mapfile, input_argument, obj, NULL, NULL,
443                              this_blocker, next_blocker);
444     }
445 }
446
447 // Queue up a set of tasks to be done before queueing the middle set
448 // of tasks.  This is only necessary when garbage collection
449 // (--gc-sections) of unused sections is desired.  The relocs are read
450 // and processed here early to determine the garbage sections before the
451 // relocs can be scanned in later tasks.
452
453 void
454 queue_middle_gc_tasks(const General_options& options,
455                       const Task* ,
456                       const Input_objects* input_objects,
457                       Symbol_table* symtab,
458                       Layout* layout,
459                       Workqueue* workqueue,
460                       Mapfile* mapfile)
461 {
462   // Read_relocs for all the objects must be done and processed to find
463   // unused sections before any scanning of the relocs can take place.
464   Task_token* this_blocker = NULL;
465   for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
466        p != input_objects->relobj_end();
467        ++p)
468     {
469       Task_token* next_blocker = new Task_token(true);
470       next_blocker->add_blocker();
471       workqueue->queue(new Read_relocs(symtab, layout, *p, this_blocker,
472                                        next_blocker));
473       this_blocker = next_blocker;
474     }
475
476   // If we are given only archives in input, we have no regular
477   // objects and THIS_BLOCKER is NULL here.  Create a dummy
478   // blocker here so that we can run the middle tasks immediately.
479   if (this_blocker == NULL)
480     {
481       gold_assert(input_objects->number_of_relobjs() == 0);
482       this_blocker = new Task_token(true);
483     }
484
485   workqueue->queue(new Task_function(new Middle_runner(options,
486                                                        input_objects,
487                                                        symtab,
488                                                        layout,
489                                                        mapfile),
490                                      this_blocker,
491                                      "Task_function Middle_runner"));
492 }
493
494 // Queue up the middle set of tasks.  These are the tasks which run
495 // after all the input objects have been found and all the symbols
496 // have been read, but before we lay out the output file.
497
498 void
499 queue_middle_tasks(const General_options& options,
500                    const Task* task,
501                    const Input_objects* input_objects,
502                    Symbol_table* symtab,
503                    Layout* layout,
504                    Workqueue* workqueue,
505                    Mapfile* mapfile)
506 {
507   // Add any symbols named with -u options to the symbol table.
508   symtab->add_undefined_symbols_from_command_line(layout);
509
510   // If garbage collection was chosen, relocs have been read and processed
511   // at this point by pre_middle_tasks.  Layout can then be done for all 
512   // objects.
513   if (parameters->options().gc_sections())
514     {
515       // Find the start symbol if any.
516       Symbol* start_sym = symtab->lookup(parameters->entry());
517       if (start_sym != NULL)
518         {
519           bool is_ordinary;
520           unsigned int shndx = start_sym->shndx(&is_ordinary);
521           if (is_ordinary) 
522             {
523               symtab->gc()->worklist().push(
524                 Section_id(start_sym->object(), shndx));
525             }
526         }
527       // Symbols named with -u should not be considered garbage.
528       symtab->gc_mark_undef_symbols(layout);
529       gold_assert(symtab->gc() != NULL);
530       // Do a transitive closure on all references to determine the worklist.
531       symtab->gc()->do_transitive_closure();
532     }
533
534   // If identical code folding (--icf) is chosen it makes sense to do it 
535   // only after garbage collection (--gc-sections) as we do not want to 
536   // be folding sections that will be garbage.
537   if (parameters->options().icf_enabled())
538     {
539       symtab->icf()->find_identical_sections(input_objects, symtab);
540     }
541
542   // Call Object::layout for the second time to determine the 
543   // output_sections for all referenced input sections.  When 
544   // --gc-sections or --icf is turned on, Object::layout is 
545   // called twice.  It is called the first time when the 
546   // symbols are added.
547   if (parameters->options().gc_sections()
548       || parameters->options().icf_enabled())
549     {
550       for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
551            p != input_objects->relobj_end();
552            ++p)
553         {
554           Task_lock_obj<Object> tlo(task, *p);
555           (*p)->layout(symtab, layout, NULL);
556         }
557     }
558
559   // Layout deferred objects due to plugins.
560   if (parameters->options().has_plugins())
561     {
562       Plugin_manager* plugins = parameters->options().plugins();
563       gold_assert(plugins != NULL);
564       plugins->layout_deferred_objects();
565     }     
566
567   if (parameters->options().gc_sections()
568       || parameters->options().icf_enabled())
569     {
570       for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
571            p != input_objects->relobj_end();
572            ++p)
573         {
574           // Update the value of output_section stored in rd.
575           Read_relocs_data* rd = (*p)->get_relocs_data();
576           for (Read_relocs_data::Relocs_list::iterator q = rd->relocs.begin();
577                q != rd->relocs.end();
578                ++q)
579             {
580               q->output_section = (*p)->output_section(q->data_shndx);
581               q->needs_special_offset_handling = 
582                       (*p)->is_output_section_offset_invalid(q->data_shndx);
583             }
584         }
585     }
586
587   // We have to support the case of not seeing any input objects, and
588   // generate an empty file.  Existing builds depend on being able to
589   // pass an empty archive to the linker and get an empty object file
590   // out.  In order to do this we need to use a default target.
591   if (input_objects->number_of_input_objects() == 0
592       && layout->incremental_base() == NULL)
593     parameters_force_valid_target();
594
595   int thread_count = options.thread_count_middle();
596   if (thread_count == 0)
597     thread_count = std::max(2, input_objects->number_of_input_objects());
598   workqueue->set_thread_count(thread_count);
599
600   // Now we have seen all the input files.
601   const bool doing_static_link =
602     (!input_objects->any_dynamic()
603      && !parameters->options().output_is_position_independent());
604   set_parameters_doing_static_link(doing_static_link);
605   if (!doing_static_link && options.is_static())
606     {
607       // We print out just the first .so we see; there may be others.
608       gold_assert(input_objects->dynobj_begin() != input_objects->dynobj_end());
609       gold_error(_("cannot mix -static with dynamic object %s"),
610                  (*input_objects->dynobj_begin())->name().c_str());
611     }
612   if (!doing_static_link && parameters->options().relocatable())
613     gold_fatal(_("cannot mix -r with dynamic object %s"),
614                (*input_objects->dynobj_begin())->name().c_str());
615   if (!doing_static_link
616       && options.oformat_enum() != General_options::OBJECT_FORMAT_ELF)
617     gold_fatal(_("cannot use non-ELF output format with dynamic object %s"),
618                (*input_objects->dynobj_begin())->name().c_str());
619
620   if (parameters->options().relocatable())
621     {
622       Input_objects::Relobj_iterator p = input_objects->relobj_begin();
623       if (p != input_objects->relobj_end())
624         {
625           bool uses_split_stack = (*p)->uses_split_stack();
626           for (++p; p != input_objects->relobj_end(); ++p)
627             {
628               if ((*p)->uses_split_stack() != uses_split_stack)
629                 gold_fatal(_("cannot mix split-stack '%s' and "
630                              "non-split-stack '%s' when using -r"),
631                            (*input_objects->relobj_begin())->name().c_str(),
632                            (*p)->name().c_str());
633             }
634         }
635     }
636
637   // For incremental updates, record the existing GOT and PLT entries,
638   // and the COPY relocations.
639   if (parameters->incremental_update())
640     {
641       Incremental_binary* ibase = layout->incremental_base();
642       ibase->process_got_plt(symtab, layout);
643       ibase->emit_copy_relocs(symtab);
644     }
645
646   if (is_debugging_enabled(DEBUG_SCRIPT))
647     layout->script_options()->print(stderr);
648
649   // For each dynamic object, record whether we've seen all the
650   // dynamic objects that it depends upon.
651   input_objects->check_dynamic_dependencies();
652
653   // See if any of the input definitions violate the One Definition Rule.
654   // TODO: if this is too slow, do this as a task, rather than inline.
655   symtab->detect_odr_violations(task, options.output_file_name());
656
657   // Do the --no-undefined-version check.
658   if (!parameters->options().undefined_version())
659     {
660       Script_options* so = layout->script_options();
661       so->version_script_info()->check_unmatched_names(symtab);
662     }
663
664   // Create any automatic note sections.
665   layout->create_notes();
666
667   // Create any output sections required by any linker script.
668   layout->create_script_sections();
669
670   // Define some sections and symbols needed for a dynamic link.  This
671   // handles some cases we want to see before we read the relocs.
672   layout->create_initial_dynamic_sections(symtab);
673
674   // Define symbols from any linker scripts.
675   layout->define_script_symbols(symtab);
676
677   // Attach sections to segments.
678   layout->attach_sections_to_segments();
679
680   if (!parameters->options().relocatable())
681     {
682       // Predefine standard symbols.
683       define_standard_symbols(symtab, layout);
684
685       // Define __start and __stop symbols for output sections where
686       // appropriate.
687       layout->define_section_symbols(symtab);
688     }
689
690   // Make sure we have symbols for any required group signatures.
691   layout->define_group_signatures(symtab);
692
693   Task_token* this_blocker = NULL;
694
695   // Allocate common symbols.  We use a blocker to run this before the
696   // Scan_relocs tasks, because it writes to the symbol table just as
697   // they do.
698   if (parameters->options().define_common())
699     {
700       this_blocker = new Task_token(true);
701       this_blocker->add_blocker();
702       workqueue->queue(new Allocate_commons_task(symtab, layout, mapfile,
703                                                  this_blocker));
704     }
705
706   // If doing garbage collection, the relocations have already been read.
707   // Otherwise, read and scan the relocations.
708   if (parameters->options().gc_sections()
709       || parameters->options().icf_enabled())
710     {
711       for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
712            p != input_objects->relobj_end();
713            ++p)
714         {
715           Task_token* next_blocker = new Task_token(true);
716           next_blocker->add_blocker();
717           workqueue->queue(new Scan_relocs(symtab, layout, *p, 
718                                            (*p)->get_relocs_data(),
719                                            this_blocker, next_blocker));
720           this_blocker = next_blocker;
721         }
722     }
723   else
724     {
725       // Read the relocations of the input files.  We do this to find
726       // which symbols are used by relocations which require a GOT and/or
727       // a PLT entry, or a COPY reloc.  When we implement garbage
728       // collection we will do it here by reading the relocations in a
729       // breadth first search by references.
730       //
731       // We could also read the relocations during the first pass, and
732       // mark symbols at that time.  That is how the old GNU linker works.
733       // Doing that is more complex, since we may later decide to discard
734       // some of the sections, and thus change our minds about the types
735       // of references made to the symbols.
736       for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
737            p != input_objects->relobj_end();
738            ++p)
739         {
740           Task_token* next_blocker = new Task_token(true);
741           next_blocker->add_blocker();
742           workqueue->queue(new Read_relocs(symtab, layout, *p, this_blocker,
743                                            next_blocker));
744           this_blocker = next_blocker;
745         }
746     }
747
748   if (this_blocker == NULL)
749     {
750       if (input_objects->number_of_relobjs() == 0)
751         {
752           // If we are given only archives in input, we have no regular
753           // objects and THIS_BLOCKER is NULL here.  Create a dummy
754           // blocker here so that we can run the layout task immediately.
755           this_blocker = new Task_token(true);
756         }
757       else 
758         {
759           // If we failed to open any input files, it's possible for
760           // THIS_BLOCKER to be NULL here.  There's no real point in
761           // continuing if that happens.
762           gold_assert(parameters->errors()->error_count() > 0);
763           gold_exit(GOLD_ERR);
764         }
765     }
766
767   // When all those tasks are complete, we can start laying out the
768   // output file.
769   // TODO(csilvers): figure out a more principled way to get the target
770   Target* target = const_cast<Target*>(&parameters->target());
771   workqueue->queue(new Task_function(new Layout_task_runner(options,
772                                                             input_objects,
773                                                             symtab,
774                                                             target,
775                                                             layout,
776                                                             mapfile),
777                                      this_blocker,
778                                      "Task_function Layout_task_runner"));
779 }
780
781 // Queue up the final set of tasks.  This is called at the end of
782 // Layout_task.
783
784 void
785 queue_final_tasks(const General_options& options,
786                   const Input_objects* input_objects,
787                   const Symbol_table* symtab,
788                   Layout* layout,
789                   Workqueue* workqueue,
790                   Output_file* of)
791 {
792   int thread_count = options.thread_count_final();
793   if (thread_count == 0)
794     thread_count = std::max(2, input_objects->number_of_input_objects());
795   workqueue->set_thread_count(thread_count);
796
797   bool any_postprocessing_sections = layout->any_postprocessing_sections();
798
799   // Use a blocker to wait until all the input sections have been
800   // written out.
801   Task_token* input_sections_blocker = NULL;
802   if (!any_postprocessing_sections)
803     {
804       input_sections_blocker = new Task_token(true);
805       input_sections_blocker->add_blockers(input_objects->number_of_relobjs());
806     }
807
808   // Use a blocker to block any objects which have to wait for the
809   // output sections to complete before they can apply relocations.
810   Task_token* output_sections_blocker = new Task_token(true);
811   output_sections_blocker->add_blocker();
812
813   // Use a blocker to block the final cleanup task.
814   Task_token* final_blocker = new Task_token(true);
815   // Write_symbols_task, Write_sections_task, Write_data_task,
816   // Relocate_tasks.
817   final_blocker->add_blockers(3);
818   final_blocker->add_blockers(input_objects->number_of_relobjs());
819   if (!any_postprocessing_sections)
820     final_blocker->add_blocker();
821
822   // Queue a task to write out the symbol table.
823   workqueue->queue(new Write_symbols_task(layout,
824                                           symtab,
825                                           input_objects,
826                                           layout->sympool(),
827                                           layout->dynpool(),
828                                           of,
829                                           final_blocker));
830
831   // Queue a task to write out the output sections.
832   workqueue->queue(new Write_sections_task(layout, of, output_sections_blocker,
833                                            final_blocker));
834
835   // Queue a task to write out everything else.
836   workqueue->queue(new Write_data_task(layout, symtab, of, final_blocker));
837
838   // Queue a task for each input object to relocate the sections and
839   // write out the local symbols.
840   for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
841        p != input_objects->relobj_end();
842        ++p)
843     workqueue->queue(new Relocate_task(symtab, layout, *p, of,
844                                        input_sections_blocker,
845                                        output_sections_blocker,
846                                        final_blocker));
847
848   // Queue a task to write out the output sections which depend on
849   // input sections.  If there are any sections which require
850   // postprocessing, then we need to do this last, since it may resize
851   // the output file.
852   if (!any_postprocessing_sections)
853     {
854       Task* t = new Write_after_input_sections_task(layout, of,
855                                                     input_sections_blocker,
856                                                     final_blocker);
857       workqueue->queue(t);
858     }
859   else
860     {
861       Task_token* new_final_blocker = new Task_token(true);
862       new_final_blocker->add_blocker();
863       Task* t = new Write_after_input_sections_task(layout, of,
864                                                     final_blocker,
865                                                     new_final_blocker);
866       workqueue->queue(t);
867       final_blocker = new_final_blocker;
868     }
869
870   // Queue a task to close the output file.  This will be blocked by
871   // FINAL_BLOCKER.
872   workqueue->queue(new Task_function(new Close_task_runner(&options, layout,
873                                                            of),
874                                      final_blocker,
875                                      "Task_function Close_task_runner"));
876 }
877
878 } // End namespace gold.