Commit | Line | Data |
---|---|---|
5a6f7e2d | 1 | // gold.cc -- main linker functions |
bae7f79e | 2 | |
6d03d481 | 3 | // Copyright 2006, 2007, 2008, 2009 Free Software Foundation, Inc. |
6cb15b7f ILT |
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 | ||
bae7f79e ILT |
23 | #include "gold.h" |
24 | ||
25 | #include <cstdlib> | |
26 | #include <cstdio> | |
27 | #include <cstring> | |
28 | #include <unistd.h> | |
fbfba508 | 29 | #include <algorithm> |
75f2446e | 30 | #include "libiberty.h" |
bae7f79e ILT |
31 | |
32 | #include "options.h" | |
494e05f4 | 33 | #include "debug.h" |
bae7f79e ILT |
34 | #include "workqueue.h" |
35 | #include "dirsearch.h" | |
36 | #include "readsyms.h" | |
14bfc3f5 | 37 | #include "symtab.h" |
ead1e424 | 38 | #include "common.h" |
54dc6425 | 39 | #include "object.h" |
a2fb1b05 | 40 | #include "layout.h" |
61ba1cf9 | 41 | #include "reloc.h" |
ead1e424 | 42 | #include "defstd.h" |
89fc3421 | 43 | #include "plugin.h" |
f345227a | 44 | #include "gc.h" |
ef15dade | 45 | #include "icf.h" |
44453f85 | 46 | #include "incremental.h" |
bae7f79e ILT |
47 | |
48 | namespace gold | |
49 | { | |
50 | ||
51 | const char* program_name; | |
52 | ||
53 | void | |
54 | gold_exit(bool status) | |
55 | { | |
483620e8 CC |
56 | if (parameters != NULL |
57 | && parameters->options_valid() | |
58 | && parameters->options().has_plugins()) | |
59 | parameters->options().plugins()->cleanup(); | |
2d684091 | 60 | if (!status && parameters != NULL && parameters->options_valid()) |
8851ecca | 61 | unlink_if_ordinary(parameters->options().output_file_name()); |
bae7f79e ILT |
62 | exit(status ? EXIT_SUCCESS : EXIT_FAILURE); |
63 | } | |
64 | ||
bae7f79e ILT |
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. | |
55ba0940 ILT |
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 | } | |
bae7f79e ILT |
83 | gold_exit(false); |
84 | } | |
85 | ||
a3ad94ed ILT |
86 | // Handle an unreachable case. |
87 | ||
bae7f79e | 88 | void |
a3ad94ed | 89 | do_gold_unreachable(const char* filename, int lineno, const char* function) |
bae7f79e | 90 | { |
27b7985a | 91 | fprintf(stderr, _("%s: internal error in %s, at %s:%d\n"), |
a3ad94ed ILT |
92 | program_name, function, filename, lineno); |
93 | gold_exit(false); | |
bae7f79e ILT |
94 | } |
95 | ||
92e059d8 ILT |
96 | // This class arranges to run the functions done in the middle of the |
97 | // link. It is just a closure. | |
bae7f79e | 98 | |
92e059d8 | 99 | class Middle_runner : public Task_function_runner |
bae7f79e | 100 | { |
92e059d8 ILT |
101 | public: |
102 | Middle_runner(const General_options& options, | |
103 | const Input_objects* input_objects, | |
104 | Symbol_table* symtab, | |
7d9e3d98 | 105 | Layout* layout, Mapfile* mapfile) |
92e059d8 | 106 | : options_(options), input_objects_(input_objects), symtab_(symtab), |
7d9e3d98 | 107 | layout_(layout), mapfile_(mapfile) |
92e059d8 ILT |
108 | { } |
109 | ||
110 | void | |
17a1d0a9 | 111 | run(Workqueue*, const Task*); |
92e059d8 ILT |
112 | |
113 | private: | |
114 | const General_options& options_; | |
115 | const Input_objects* input_objects_; | |
116 | Symbol_table* symtab_; | |
117 | Layout* layout_; | |
7d9e3d98 | 118 | Mapfile* mapfile_; |
92e059d8 | 119 | }; |
bae7f79e | 120 | |
92e059d8 | 121 | void |
17a1d0a9 | 122 | Middle_runner::run(Workqueue* workqueue, const Task* task) |
92e059d8 | 123 | { |
17a1d0a9 | 124 | queue_middle_tasks(this->options_, task, this->input_objects_, this->symtab_, |
7d9e3d98 | 125 | this->layout_, workqueue, this->mapfile_); |
92e059d8 | 126 | } |
bae7f79e | 127 | |
6d03d481 ST |
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 | ||
bae7f79e ILT |
160 | // Queue up the initial set of tasks for this link job. |
161 | ||
162 | void | |
163 | queue_initial_tasks(const General_options& options, | |
17a1d0a9 | 164 | Dirsearch& search_path, |
ead1e424 | 165 | const Command_line& cmdline, |
54dc6425 | 166 | Workqueue* workqueue, Input_objects* input_objects, |
7d9e3d98 | 167 | Symbol_table* symtab, Layout* layout, Mapfile* mapfile) |
bae7f79e | 168 | { |
e5366891 | 169 | if (cmdline.begin() == cmdline.end()) |
459c9f1c ILT |
170 | { |
171 | if (options.printed_version()) | |
172 | gold_exit(true); | |
173 | gold_fatal(_("no input files")); | |
174 | } | |
e5366891 | 175 | |
fe9a4c12 ILT |
176 | int thread_count = options.thread_count_initial(); |
177 | if (thread_count == 0) | |
e5366891 | 178 | thread_count = cmdline.number_of_input_files(); |
fe9a4c12 ILT |
179 | workqueue->set_thread_count(thread_count); |
180 | ||
44453f85 ILT |
181 | if (cmdline.options().incremental()) |
182 | { | |
183 | Incremental_checker incremental_checker( | |
c4aa1e2d ILT |
184 | parameters->options().output_file_name(), |
185 | layout->incremental_inputs()); | |
44453f85 ILT |
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 | ||
bae7f79e ILT |
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; | |
ead1e424 ILT |
201 | for (Command_line::const_iterator p = cmdline.begin(); |
202 | p != cmdline.end(); | |
bae7f79e ILT |
203 | ++p) |
204 | { | |
17a1d0a9 | 205 | Task_token* next_blocker = new Task_token(true); |
bae7f79e | 206 | next_blocker->add_blocker(); |
f1ed28fb | 207 | workqueue->queue(new Read_symbols(input_objects, symtab, layout, |
15f8229b | 208 | &search_path, 0, mapfile, &*p, NULL, |
7d9e3d98 | 209 | this_blocker, next_blocker)); |
bae7f79e ILT |
210 | this_blocker = next_blocker; |
211 | } | |
212 | ||
89fc3421 CC |
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 | ||
6d03d481 | 223 | if (parameters->options().relocatable() |
032ce4e9 ST |
224 | && (parameters->options().gc_sections() |
225 | || parameters->options().icf_enabled())) | |
ef15dade | 226 | gold_error(_("cannot mix -r with --gc-sections or --icf")); |
6d03d481 | 227 | |
032ce4e9 ST |
228 | if (parameters->options().gc_sections() |
229 | || parameters->options().icf_enabled()) | |
6d03d481 ST |
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 | ||
44453f85 ILT |
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 | |
6d03d481 ST |
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); | |
92e059d8 | 281 | workqueue->queue(new Task_function(new Middle_runner(options, |
6d03d481 ST |
282 | input_objects, |
283 | symtab, | |
284 | layout, | |
285 | mapfile), | |
286 | this_blocker, | |
287 | "Task_function Middle_runner")); | |
bae7f79e ILT |
288 | } |
289 | ||
92e059d8 ILT |
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. | |
bae7f79e | 293 | |
92e059d8 ILT |
294 | void |
295 | queue_middle_tasks(const General_options& options, | |
17a1d0a9 | 296 | const Task* task, |
92e059d8 ILT |
297 | const Input_objects* input_objects, |
298 | Symbol_table* symtab, | |
299 | Layout* layout, | |
7d9e3d98 ILT |
300 | Workqueue* workqueue, |
301 | Mapfile* mapfile) | |
61ba1cf9 | 302 | { |
6d03d481 ST |
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(); | |
ef15dade ST |
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. | |
032ce4e9 | 337 | if (parameters->options().icf_enabled()) |
ef15dade ST |
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. | |
032ce4e9 ST |
347 | if (parameters->options().gc_sections() |
348 | || parameters->options().icf_enabled()) | |
ef15dade | 349 | { |
6d03d481 ST |
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 | } | |
ef15dade | 357 | |
6d03d481 ST |
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 | } | |
ef15dade | 365 | |
032ce4e9 ST |
366 | if (parameters->options().gc_sections() |
367 | || parameters->options().icf_enabled()) | |
6d03d481 ST |
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 | ||
fbfba508 ILT |
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. | |
2c0aeda4 | 390 | if (input_objects->number_of_input_objects() == 0) |
029ba973 | 391 | parameters_force_valid_target(); |
2c0aeda4 | 392 | |
fe9a4c12 ILT |
393 | int thread_count = options.thread_count_middle(); |
394 | if (thread_count == 0) | |
fbfba508 | 395 | thread_count = std::max(2, input_objects->number_of_input_objects()); |
fe9a4c12 ILT |
396 | workqueue->set_thread_count(thread_count); |
397 | ||
b3b74ddc | 398 | // Now we have seen all the input files. |
374ad285 ILT |
399 | const bool doing_static_link = |
400 | (!input_objects->any_dynamic() | |
401 | && !parameters->options().output_is_position_independent()); | |
4eff2974 ILT |
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. | |
4e1e25e0 | 406 | gold_assert(input_objects->dynobj_begin() != input_objects->dynobj_end()); |
75f2446e ILT |
407 | gold_error(_("cannot mix -static with dynamic object %s"), |
408 | (*input_objects->dynobj_begin())->name().c_str()); | |
4eff2974 | 409 | } |
8851ecca | 410 | if (!doing_static_link && parameters->options().relocatable()) |
459c9f1c | 411 | gold_fatal(_("cannot mix -r with dynamic object %s"), |
6a74a719 | 412 | (*input_objects->dynobj_begin())->name().c_str()); |
516cb3d0 | 413 | if (!doing_static_link |
7cc619c3 | 414 | && options.oformat_enum() != General_options::OBJECT_FORMAT_ELF) |
516cb3d0 ILT |
415 | gold_fatal(_("cannot use non-ELF output format with dynamic object %s"), |
416 | (*input_objects->dynobj_begin())->name().c_str()); | |
b3b74ddc | 417 | |
364c7fa5 ILT |
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 | ||
494e05f4 ILT |
435 | if (is_debugging_enabled(DEBUG_SCRIPT)) |
436 | layout->script_options()->print(stderr); | |
437 | ||
e2827e5f ILT |
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 | ||
70e654ba ILT |
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. | |
17a1d0a9 | 444 | symtab->detect_odr_violations(task, options.output_file_name()); |
70e654ba | 445 | |
9c547ec3 ILT |
446 | // Create any automatic note sections. |
447 | layout->create_notes(); | |
448 | ||
919ed24c ILT |
449 | // Create any output sections required by any linker script. |
450 | layout->create_script_sections(); | |
451 | ||
a3ad94ed ILT |
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. | |
9b07f471 | 454 | layout->create_initial_dynamic_sections(symtab); |
a3ad94ed | 455 | |
a445fddf ILT |
456 | // Define symbols from any linker scripts. |
457 | layout->define_script_symbols(symtab); | |
458 | ||
154e0e9a ILT |
459 | // Attach sections to segments. |
460 | layout->attach_sections_to_segments(); | |
461 | ||
8851ecca | 462 | if (!parameters->options().relocatable()) |
6a74a719 ILT |
463 | { |
464 | // Predefine standard symbols. | |
465 | define_standard_symbols(symtab, layout); | |
ead1e424 | 466 | |
6a74a719 ILT |
467 | // Define __start and __stop symbols for output sections where |
468 | // appropriate. | |
469 | layout->define_section_symbols(symtab); | |
470 | } | |
bfd58944 | 471 | |
755ab8af ILT |
472 | // Make sure we have symbols for any required group signatures. |
473 | layout->define_group_signatures(symtab); | |
474 | ||
17a1d0a9 ILT |
475 | Task_token* blocker = new Task_token(true); |
476 | Task_token* symtab_lock = new Task_token(false); | |
6d03d481 ST |
477 | |
478 | // If doing garbage collection, the relocations have already been read. | |
479 | // Otherwise, read and scan the relocations. | |
032ce4e9 ST |
480 | if (parameters->options().gc_sections() |
481 | || parameters->options().icf_enabled()) | |
92e059d8 | 482 | { |
6d03d481 ST |
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 | } | |
92e059d8 ILT |
518 | } |
519 | ||
520 | // Allocate common symbols. This requires write access to the | |
521 | // symbol table, but is independent of the relocation processing. | |
0dfbdef4 | 522 | if (parameters->options().define_common()) |
6a74a719 ILT |
523 | { |
524 | blocker->add_blocker(); | |
7d9e3d98 ILT |
525 | workqueue->queue(new Allocate_commons_task(symtab, layout, mapfile, |
526 | symtab_lock, blocker)); | |
6a74a719 | 527 | } |
92e059d8 ILT |
528 | |
529 | // When all those tasks are complete, we can start laying out the | |
530 | // output file. | |
8851ecca ILT |
531 | // TODO(csilvers): figure out a more principled way to get the target |
532 | Target* target = const_cast<Target*>(¶meters->target()); | |
92e059d8 ILT |
533 | workqueue->queue(new Task_function(new Layout_task_runner(options, |
534 | input_objects, | |
535 | symtab, | |
8851ecca | 536 | target, |
7d9e3d98 ILT |
537 | layout, |
538 | mapfile), | |
c7912668 ILT |
539 | blocker, |
540 | "Task_function Layout_task_runner")); | |
92e059d8 | 541 | } |
61ba1cf9 ILT |
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, | |
27bc2bce | 550 | Layout* layout, |
61ba1cf9 ILT |
551 | Workqueue* workqueue, |
552 | Output_file* of) | |
553 | { | |
fe9a4c12 ILT |
554 | int thread_count = options.thread_count_final(); |
555 | if (thread_count == 0) | |
fbfba508 | 556 | thread_count = std::max(2, input_objects->number_of_input_objects()); |
fe9a4c12 ILT |
557 | workqueue->set_thread_count(thread_count); |
558 | ||
17a1d0a9 ILT |
559 | bool any_postprocessing_sections = layout->any_postprocessing_sections(); |
560 | ||
730cdc88 ILT |
561 | // Use a blocker to wait until all the input sections have been |
562 | // written out. | |
17a1d0a9 ILT |
563 | Task_token* input_sections_blocker = NULL; |
564 | if (!any_postprocessing_sections) | |
565 | input_sections_blocker = new Task_token(true); | |
730cdc88 ILT |
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. | |
17a1d0a9 | 569 | Task_token* output_sections_blocker = new Task_token(true); |
730cdc88 | 570 | |
61ba1cf9 | 571 | // Use a blocker to block the final cleanup task. |
17a1d0a9 | 572 | Task_token* final_blocker = new Task_token(true); |
61ba1cf9 ILT |
573 | |
574 | // Queue a task to write out the symbol table. | |
5fe2a0f5 | 575 | final_blocker->add_blocker(); |
d491d34e ILT |
576 | workqueue->queue(new Write_symbols_task(layout, |
577 | symtab, | |
5fe2a0f5 ILT |
578 | input_objects, |
579 | layout->sympool(), | |
580 | layout->dynpool(), | |
581 | of, | |
582 | final_blocker)); | |
61ba1cf9 | 583 | |
730cdc88 ILT |
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 | ||
61ba1cf9 ILT |
590 | // Queue a task to write out everything else. |
591 | final_blocker->add_blocker(); | |
9025d29d | 592 | workqueue->queue(new Write_data_task(layout, symtab, of, final_blocker)); |
61ba1cf9 | 593 | |
17a1d0a9 ILT |
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 | ||
730cdc88 | 609 | // Queue a task to write out the output sections which depend on |
17a1d0a9 ILT |
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 | } | |
730cdc88 | 631 | |
61ba1cf9 ILT |
632 | // Queue a task to close the output file. This will be blocked by |
633 | // FINAL_BLOCKER. | |
516cb3d0 ILT |
634 | workqueue->queue(new Task_function(new Close_task_runner(&options, layout, |
635 | of), | |
c7912668 ILT |
636 | final_blocker, |
637 | "Task_function Close_task_runner")); | |
61ba1cf9 ILT |
638 | } |
639 | ||
640 | } // End namespace gold. |