Import binutils-2.20
[dragonfly.git] / contrib / binutils-2.20 / gold / gold.cc
1 // gold.cc -- main linker functions
2
3 // Copyright 2006, 2007, 2008, 2009 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 "debug.h"
34 #include "workqueue.h"
35 #include "dirsearch.h"
36 #include "readsyms.h"
37 #include "symtab.h"
38 #include "common.h"
39 #include "object.h"
40 #include "layout.h"
41 #include "reloc.h"
42 #include "defstd.h"
43 #include "plugin.h"
44 #include "gc.h"
45 #include "icf.h"
46 #include "incremental.h"
47
48 namespace gold
49 {
50
51 const char* program_name;
52
53 void
54 gold_exit(bool status)
55 {
56   if (parameters != NULL
57       && parameters->options_valid()
58       && parameters->options().has_plugins())
59     parameters->options().plugins()->cleanup();
60   if (!status && parameters != NULL && parameters->options_valid())
61     unlink_if_ordinary(parameters->options().output_file_name());
62   exit(status ? EXIT_SUCCESS : EXIT_FAILURE);
63 }
64
65 void
66 gold_nomem()
67 {
68   // We are out of memory, so try hard to print a reasonable message.
69   // Note that we don't try to translate this message, since the
70   // translation process itself will require memory.
71
72   // LEN only exists to avoid a pointless warning when write is
73   // declared with warn_use_result, as when compiling with
74   // -D_USE_FORTIFY on GNU/Linux.  Casting to void does not appear to
75   // work, at least not with gcc 4.3.0.
76
77   ssize_t len = write(2, program_name, strlen(program_name));
78   if (len >= 0)
79     {
80       const char* const s = ": out of memory\n";
81       len = write(2, s, strlen(s));
82     }
83   gold_exit(false);
84 }
85
86 // Handle an unreachable case.
87
88 void
89 do_gold_unreachable(const char* filename, int lineno, const char* function)
90 {
91   fprintf(stderr, _("%s: internal error in %s, at %s:%d\n"),
92           program_name, function, filename, lineno);
93   gold_exit(false);
94 }
95
96 // This class arranges to run the functions done in the middle of the
97 // link.  It is just a closure.
98
99 class Middle_runner : public Task_function_runner
100 {
101  public:
102   Middle_runner(const General_options& options,
103                 const Input_objects* input_objects,
104                 Symbol_table* symtab,
105                 Layout* layout, Mapfile* mapfile)
106     : options_(options), input_objects_(input_objects), symtab_(symtab),
107       layout_(layout), mapfile_(mapfile)
108   { }
109
110   void
111   run(Workqueue*, const Task*);
112
113  private:
114   const General_options& options_;
115   const Input_objects* input_objects_;
116   Symbol_table* symtab_;
117   Layout* layout_;
118   Mapfile* mapfile_;
119 };
120
121 void
122 Middle_runner::run(Workqueue* workqueue, const Task* task)
123 {
124   queue_middle_tasks(this->options_, task, this->input_objects_, this->symtab_,
125                      this->layout_, workqueue, this->mapfile_);
126 }
127
128 // This class arranges the tasks to process the relocs for garbage collection.
129
130 class Gc_runner : public Task_function_runner 
131 {
132   public:
133    Gc_runner(const General_options& options,
134              const Input_objects* input_objects,
135              Symbol_table* symtab,
136              Layout* layout, Mapfile* mapfile)
137     : options_(options), input_objects_(input_objects), symtab_(symtab),
138       layout_(layout), mapfile_(mapfile)
139    { }
140
141   void
142   run(Workqueue*, const Task*);
143
144  private:
145   const General_options& options_;
146   const Input_objects* input_objects_;
147   Symbol_table* symtab_;
148   Layout* layout_;
149   Mapfile* mapfile_;
150 };
151
152 void
153 Gc_runner::run(Workqueue* workqueue, const Task* task)
154 {
155   queue_middle_gc_tasks(this->options_, task, this->input_objects_, 
156                         this->symtab_, this->layout_, workqueue, 
157                         this->mapfile_);
158 }
159
160 // Queue up the initial set of tasks for this link job.
161
162 void
163 queue_initial_tasks(const General_options& options,
164                     Dirsearch& search_path,
165                     const Command_line& cmdline,
166                     Workqueue* workqueue, Input_objects* input_objects,
167                     Symbol_table* symtab, Layout* layout, Mapfile* mapfile)
168 {
169   if (cmdline.begin() == cmdline.end())
170     {
171       if (options.printed_version())
172         gold_exit(true);
173       gold_fatal(_("no input files"));
174     }
175
176   int thread_count = options.thread_count_initial();
177   if (thread_count == 0)
178     thread_count = cmdline.number_of_input_files();
179   workqueue->set_thread_count(thread_count);
180
181   if (cmdline.options().incremental())
182     {
183       Incremental_checker incremental_checker(
184           parameters->options().output_file_name(),
185           layout->incremental_inputs());
186       if (incremental_checker.can_incrementally_link_output_file())
187         {
188           // TODO: remove when incremental linking implemented.
189           printf("Incremental linking might be possible "
190               "(not implemented yet)\n");
191         }
192       // TODO: If we decide on an incremental build, fewer tasks
193       // should be scheduled.
194     }
195
196   // Read the input files.  We have to add the symbols to the symbol
197   // table in order.  We do this by creating a separate blocker for
198   // each input file.  We associate the blocker with the following
199   // input file, to give us a convenient place to delete it.
200   Task_token* this_blocker = NULL;
201   for (Command_line::const_iterator p = cmdline.begin();
202        p != cmdline.end();
203        ++p)
204     {
205       Task_token* next_blocker = new Task_token(true);
206       next_blocker->add_blocker();
207       workqueue->queue(new Read_symbols(input_objects, symtab, layout,
208                                         &search_path, 0, mapfile, &*p, NULL,
209                                         this_blocker, next_blocker));
210       this_blocker = next_blocker;
211     }
212
213   if (options.has_plugins())
214     {
215       Task_token* next_blocker = new Task_token(true);
216       next_blocker->add_blocker();
217       workqueue->queue(new Plugin_hook(options, input_objects, symtab, layout,
218                                        &search_path, mapfile, this_blocker,
219                                        next_blocker));
220       this_blocker = next_blocker;
221     }
222
223   if (parameters->options().relocatable()
224       && (parameters->options().gc_sections()
225           || parameters->options().icf_enabled()))
226     gold_error(_("cannot mix -r with --gc-sections or --icf"));
227
228   if (parameters->options().gc_sections()
229       || parameters->options().icf_enabled())
230     {
231       workqueue->queue(new Task_function(new Gc_runner(options,
232                                                        input_objects,
233                                                        symtab,
234                                                        layout,
235                                                        mapfile),
236                                          this_blocker,
237                                          "Task_function Gc_runner"));
238     }
239   else
240     {
241       workqueue->queue(new Task_function(new Middle_runner(options,
242                                                            input_objects,
243                                                            symtab,
244                                                            layout,
245                                                            mapfile),
246                                          this_blocker,
247                                          "Task_function Middle_runner"));
248     }
249 }
250
251 // Queue up a set of tasks to be done before queueing the middle set
252 // of tasks.  This is only necessary when garbage collection
253 // (--gc-sections) of unused sections is desired.  The relocs are read
254 // and processed here early to determine the garbage sections before the
255 // relocs can be scanned in later tasks.
256
257 void
258 queue_middle_gc_tasks(const General_options& options,
259                       const Task* ,
260                       const Input_objects* input_objects,
261                       Symbol_table* symtab,
262                       Layout* layout,
263                       Workqueue* workqueue,
264                       Mapfile* mapfile)
265 {
266   // Read_relocs for all the objects must be done and processed to find
267   // unused sections before any scanning of the relocs can take place.
268   Task_token* blocker = new Task_token(true);
269   Task_token* symtab_lock = new Task_token(false);
270   for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
271        p != input_objects->relobj_end();
272        ++p)
273     {
274       // We can read and process the relocations in any order.  
275       blocker->add_blocker();
276       workqueue->queue(new Read_relocs(options, symtab, layout, *p,
277                                        symtab_lock, blocker));
278     }
279
280   Task_token* this_blocker = new Task_token(true);
281   workqueue->queue(new Task_function(new Middle_runner(options,
282                                                        input_objects,
283                                                        symtab,
284                                                        layout,
285                                                        mapfile),
286                                      this_blocker,
287                                      "Task_function Middle_runner"));
288 }
289
290 // Queue up the middle set of tasks.  These are the tasks which run
291 // after all the input objects have been found and all the symbols
292 // have been read, but before we lay out the output file.
293
294 void
295 queue_middle_tasks(const General_options& options,
296                    const Task* task,
297                    const Input_objects* input_objects,
298                    Symbol_table* symtab,
299                    Layout* layout,
300                    Workqueue* workqueue,
301                    Mapfile* mapfile)
302 {
303   // Add any symbols named with -u options to the symbol table.
304   symtab->add_undefined_symbols_from_command_line();
305
306   // If garbage collection was chosen, relocs have been read and processed
307   // at this point by pre_middle_tasks.  Layout can then be done for all 
308   // objects.
309   if (parameters->options().gc_sections())
310     {
311       // Find the start symbol if any.
312       Symbol* start_sym;
313       if (parameters->options().entry())
314         start_sym = symtab->lookup(parameters->options().entry());
315       else
316         start_sym = symtab->lookup("_start");
317       if (start_sym !=NULL)
318         {
319           bool is_ordinary;
320           unsigned int shndx = start_sym->shndx(&is_ordinary);
321           if (is_ordinary) 
322             {
323               symtab->gc()->worklist().push(
324                 Section_id(start_sym->object(), shndx));
325             }
326         }
327       // Symbols named with -u should not be considered garbage.
328       symtab->gc_mark_undef_symbols();
329       gold_assert(symtab->gc() != NULL);
330       // Do a transitive closure on all references to determine the worklist.
331       symtab->gc()->do_transitive_closure();
332     }
333
334   // If identical code folding (--icf) is chosen it makes sense to do it 
335   // only after garbage collection (--gc-sections) as we do not want to 
336   // be folding sections that will be garbage.
337   if (parameters->options().icf_enabled())
338     {
339       symtab->icf()->find_identical_sections(input_objects, symtab);
340     }
341
342   // Call Object::layout for the second time to determine the 
343   // output_sections for all referenced input sections.  When 
344   // --gc-sections or --icf is turned on, Object::layout is 
345   // called twice.  It is called the first time when the 
346   // symbols are added.
347   if (parameters->options().gc_sections()
348       || parameters->options().icf_enabled())
349     {
350       for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
351            p != input_objects->relobj_end();
352            ++p)
353         {
354           (*p)->layout(symtab, layout, NULL);
355         }
356     }
357
358   // Layout deferred objects due to plugins.
359   if (parameters->options().has_plugins())
360     {
361       Plugin_manager* plugins = parameters->options().plugins();
362       gold_assert(plugins != NULL);
363       plugins->layout_deferred_objects();
364     }     
365
366   if (parameters->options().gc_sections()
367       || parameters->options().icf_enabled())
368     {
369       for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
370            p != input_objects->relobj_end();
371            ++p)
372         {
373           // Update the value of output_section stored in rd.
374           Read_relocs_data *rd = (*p)->get_relocs_data();
375           for (Read_relocs_data::Relocs_list::iterator q = rd->relocs.begin();
376                q != rd->relocs.end();
377                ++q)
378             {
379               q->output_section = (*p)->output_section(q->data_shndx);
380               q->needs_special_offset_handling = 
381                       (*p)->is_output_section_offset_invalid(q->data_shndx);
382             }
383         }
384     }
385
386   // We have to support the case of not seeing any input objects, and
387   // generate an empty file.  Existing builds depend on being able to
388   // pass an empty archive to the linker and get an empty object file
389   // out.  In order to do this we need to use a default target.
390   if (input_objects->number_of_input_objects() == 0)
391     parameters_force_valid_target();
392
393   int thread_count = options.thread_count_middle();
394   if (thread_count == 0)
395     thread_count = std::max(2, input_objects->number_of_input_objects());
396   workqueue->set_thread_count(thread_count);
397
398   // Now we have seen all the input files.
399   const bool doing_static_link =
400     (!input_objects->any_dynamic()
401      && !parameters->options().output_is_position_independent());
402   set_parameters_doing_static_link(doing_static_link);
403   if (!doing_static_link && options.is_static())
404     {
405       // We print out just the first .so we see; there may be others.
406       gold_assert(input_objects->dynobj_begin() != input_objects->dynobj_end());
407       gold_error(_("cannot mix -static with dynamic object %s"),
408                  (*input_objects->dynobj_begin())->name().c_str());
409     }
410   if (!doing_static_link && parameters->options().relocatable())
411     gold_fatal(_("cannot mix -r with dynamic object %s"),
412                (*input_objects->dynobj_begin())->name().c_str());
413   if (!doing_static_link
414       && options.oformat_enum() != General_options::OBJECT_FORMAT_ELF)
415     gold_fatal(_("cannot use non-ELF output format with dynamic object %s"),
416                (*input_objects->dynobj_begin())->name().c_str());
417
418   if (parameters->options().relocatable())
419     {
420       Input_objects::Relobj_iterator p = input_objects->relobj_begin();
421       if (p != input_objects->relobj_end())
422         {
423           bool uses_split_stack = (*p)->uses_split_stack();
424           for (++p; p != input_objects->relobj_end(); ++p)
425             {
426               if ((*p)->uses_split_stack() != uses_split_stack)
427                 gold_fatal(_("cannot mix split-stack '%s' and "
428                              "non-split-stack '%s' when using -r"),
429                            (*input_objects->relobj_begin())->name().c_str(),
430                            (*p)->name().c_str());
431             }
432         }
433     }
434
435   if (is_debugging_enabled(DEBUG_SCRIPT))
436     layout->script_options()->print(stderr);
437
438   // For each dynamic object, record whether we've seen all the
439   // dynamic objects that it depends upon.
440   input_objects->check_dynamic_dependencies();
441
442   // See if any of the input definitions violate the One Definition Rule.
443   // TODO: if this is too slow, do this as a task, rather than inline.
444   symtab->detect_odr_violations(task, options.output_file_name());
445
446   // Create any automatic note sections.
447   layout->create_notes();
448
449   // Create any output sections required by any linker script.
450   layout->create_script_sections();
451
452   // Define some sections and symbols needed for a dynamic link.  This
453   // handles some cases we want to see before we read the relocs.
454   layout->create_initial_dynamic_sections(symtab);
455
456   // Define symbols from any linker scripts.
457   layout->define_script_symbols(symtab);
458
459   // Attach sections to segments.
460   layout->attach_sections_to_segments();
461
462   if (!parameters->options().relocatable())
463     {
464       // Predefine standard symbols.
465       define_standard_symbols(symtab, layout);
466
467       // Define __start and __stop symbols for output sections where
468       // appropriate.
469       layout->define_section_symbols(symtab);
470     }
471
472   // Make sure we have symbols for any required group signatures.
473   layout->define_group_signatures(symtab);
474
475   Task_token* blocker = new Task_token(true);
476   Task_token* symtab_lock = new Task_token(false);
477
478   // If doing garbage collection, the relocations have already been read.
479   // Otherwise, read and scan the relocations.
480   if (parameters->options().gc_sections()
481       || parameters->options().icf_enabled())
482     {
483       for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
484            p != input_objects->relobj_end();
485            ++p)
486         {
487           blocker->add_blocker();
488           workqueue->queue(new Scan_relocs(options, symtab, layout, *p, 
489                            (*p)->get_relocs_data(),symtab_lock, blocker));
490         }
491     }
492   else
493     {
494       // Read the relocations of the input files.  We do this to find
495       // which symbols are used by relocations which require a GOT and/or
496       // a PLT entry, or a COPY reloc.  When we implement garbage
497       // collection we will do it here by reading the relocations in a
498       // breadth first search by references.
499       //
500       // We could also read the relocations during the first pass, and
501       // mark symbols at that time.  That is how the old GNU linker works.
502       // Doing that is more complex, since we may later decide to discard
503       // some of the sections, and thus change our minds about the types
504       // of references made to the symbols.
505       for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
506            p != input_objects->relobj_end();
507            ++p)
508         {
509           // We can read and process the relocations in any order.  But we
510           // only want one task to write to the symbol table at a time.
511           // So we queue up a task for each object to read the
512           // relocations.  That task will in turn queue a task to wait
513           // until it can write to the symbol table.
514           blocker->add_blocker();
515           workqueue->queue(new Read_relocs(options, symtab, layout, *p,
516                    symtab_lock, blocker));
517         }
518     }
519
520   // Allocate common symbols.  This requires write access to the
521   // symbol table, but is independent of the relocation processing.
522   if (parameters->options().define_common())
523     {
524       blocker->add_blocker();
525       workqueue->queue(new Allocate_commons_task(symtab, layout, mapfile,
526                                                  symtab_lock, blocker));
527     }
528
529   // When all those tasks are complete, we can start laying out the
530   // output file.
531   // TODO(csilvers): figure out a more principled way to get the target
532   Target* target = const_cast<Target*>(&parameters->target());
533   workqueue->queue(new Task_function(new Layout_task_runner(options,
534                                                             input_objects,
535                                                             symtab,
536                                                             target,
537                                                             layout,
538                                                             mapfile),
539                                      blocker,
540                                      "Task_function Layout_task_runner"));
541 }
542
543 // Queue up the final set of tasks.  This is called at the end of
544 // Layout_task.
545
546 void
547 queue_final_tasks(const General_options& options,
548                   const Input_objects* input_objects,
549                   const Symbol_table* symtab,
550                   Layout* layout,
551                   Workqueue* workqueue,
552                   Output_file* of)
553 {
554   int thread_count = options.thread_count_final();
555   if (thread_count == 0)
556     thread_count = std::max(2, input_objects->number_of_input_objects());
557   workqueue->set_thread_count(thread_count);
558
559   bool any_postprocessing_sections = layout->any_postprocessing_sections();
560
561   // Use a blocker to wait until all the input sections have been
562   // written out.
563   Task_token* input_sections_blocker = NULL;
564   if (!any_postprocessing_sections)
565     input_sections_blocker = new Task_token(true);
566
567   // Use a blocker to block any objects which have to wait for the
568   // output sections to complete before they can apply relocations.
569   Task_token* output_sections_blocker = new Task_token(true);
570
571   // Use a blocker to block the final cleanup task.
572   Task_token* final_blocker = new Task_token(true);
573
574   // Queue a task to write out the symbol table.
575   final_blocker->add_blocker();
576   workqueue->queue(new Write_symbols_task(layout,
577                                           symtab,
578                                           input_objects,
579                                           layout->sympool(),
580                                           layout->dynpool(),
581                                           of,
582                                           final_blocker));
583
584   // Queue a task to write out the output sections.
585   output_sections_blocker->add_blocker();
586   final_blocker->add_blocker();
587   workqueue->queue(new Write_sections_task(layout, of, output_sections_blocker,
588                                            final_blocker));
589
590   // Queue a task to write out everything else.
591   final_blocker->add_blocker();
592   workqueue->queue(new Write_data_task(layout, symtab, of, final_blocker));
593
594   // Queue a task for each input object to relocate the sections and
595   // write out the local symbols.
596   for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
597        p != input_objects->relobj_end();
598        ++p)
599     {
600       if (input_sections_blocker != NULL)
601         input_sections_blocker->add_blocker();
602       final_blocker->add_blocker();
603       workqueue->queue(new Relocate_task(options, symtab, layout, *p, of,
604                                          input_sections_blocker,
605                                          output_sections_blocker,
606                                          final_blocker));
607     }
608
609   // Queue a task to write out the output sections which depend on
610   // input sections.  If there are any sections which require
611   // postprocessing, then we need to do this last, since it may resize
612   // the output file.
613   if (!any_postprocessing_sections)
614     {
615       final_blocker->add_blocker();
616       Task* t = new Write_after_input_sections_task(layout, of,
617                                                     input_sections_blocker,
618                                                     final_blocker);
619       workqueue->queue(t);
620     }
621   else
622     {
623       Task_token *new_final_blocker = new Task_token(true);
624       new_final_blocker->add_blocker();
625       Task* t = new Write_after_input_sections_task(layout, of,
626                                                     final_blocker,
627                                                     new_final_blocker);
628       workqueue->queue(t);
629       final_blocker = new_final_blocker;
630     }
631
632   // Queue a task to close the output file.  This will be blocked by
633   // FINAL_BLOCKER.
634   workqueue->queue(new Task_function(new Close_task_runner(&options, layout,
635                                                            of),
636                                      final_blocker,
637                                      "Task_function Close_task_runner"));
638 }
639
640 } // End namespace gold.