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