Commit | Line | Data |
---|---|---|
5a6f7e2d | 1 | // gold.cc -- main linker functions |
bae7f79e | 2 | |
e5756efb | 3 | // Copyright 2006, 2007, 2008 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" |
fbfba508 | 34 | #include "target-select.h" |
bae7f79e ILT |
35 | #include "workqueue.h" |
36 | #include "dirsearch.h" | |
37 | #include "readsyms.h" | |
14bfc3f5 | 38 | #include "symtab.h" |
ead1e424 | 39 | #include "common.h" |
54dc6425 | 40 | #include "object.h" |
a2fb1b05 | 41 | #include "layout.h" |
61ba1cf9 | 42 | #include "reloc.h" |
ead1e424 | 43 | #include "defstd.h" |
bae7f79e ILT |
44 | |
45 | namespace gold | |
46 | { | |
47 | ||
48 | const char* program_name; | |
49 | ||
50 | void | |
51 | gold_exit(bool status) | |
52 | { | |
2d684091 | 53 | if (!status && parameters != NULL && parameters->options_valid()) |
75f2446e | 54 | unlink_if_ordinary(parameters->output_file_name()); |
bae7f79e ILT |
55 | exit(status ? EXIT_SUCCESS : EXIT_FAILURE); |
56 | } | |
57 | ||
bae7f79e ILT |
58 | void |
59 | gold_nomem() | |
60 | { | |
61 | // We are out of memory, so try hard to print a reasonable message. | |
62 | // Note that we don't try to translate this message, since the | |
63 | // translation process itself will require memory. | |
64 | write(2, program_name, strlen(program_name)); | |
65 | const char* const s = ": out of memory\n"; | |
66 | write(2, s, strlen(s)); | |
67 | gold_exit(false); | |
68 | } | |
69 | ||
a3ad94ed ILT |
70 | // Handle an unreachable case. |
71 | ||
bae7f79e | 72 | void |
a3ad94ed | 73 | do_gold_unreachable(const char* filename, int lineno, const char* function) |
bae7f79e | 74 | { |
27b7985a | 75 | fprintf(stderr, _("%s: internal error in %s, at %s:%d\n"), |
a3ad94ed ILT |
76 | program_name, function, filename, lineno); |
77 | gold_exit(false); | |
bae7f79e ILT |
78 | } |
79 | ||
92e059d8 ILT |
80 | // This class arranges to run the functions done in the middle of the |
81 | // link. It is just a closure. | |
bae7f79e | 82 | |
92e059d8 | 83 | class Middle_runner : public Task_function_runner |
bae7f79e | 84 | { |
92e059d8 ILT |
85 | public: |
86 | Middle_runner(const General_options& options, | |
87 | const Input_objects* input_objects, | |
88 | Symbol_table* symtab, | |
89 | Layout* layout) | |
90 | : options_(options), input_objects_(input_objects), symtab_(symtab), | |
91 | layout_(layout) | |
92 | { } | |
93 | ||
94 | void | |
17a1d0a9 | 95 | run(Workqueue*, const Task*); |
92e059d8 ILT |
96 | |
97 | private: | |
98 | const General_options& options_; | |
99 | const Input_objects* input_objects_; | |
100 | Symbol_table* symtab_; | |
101 | Layout* layout_; | |
102 | }; | |
bae7f79e | 103 | |
92e059d8 | 104 | void |
17a1d0a9 | 105 | Middle_runner::run(Workqueue* workqueue, const Task* task) |
92e059d8 | 106 | { |
17a1d0a9 | 107 | queue_middle_tasks(this->options_, task, this->input_objects_, this->symtab_, |
92e059d8 ILT |
108 | this->layout_, workqueue); |
109 | } | |
bae7f79e ILT |
110 | |
111 | // Queue up the initial set of tasks for this link job. | |
112 | ||
113 | void | |
114 | queue_initial_tasks(const General_options& options, | |
17a1d0a9 | 115 | Dirsearch& search_path, |
ead1e424 | 116 | const Command_line& cmdline, |
54dc6425 | 117 | Workqueue* workqueue, Input_objects* input_objects, |
12e14209 | 118 | Symbol_table* symtab, Layout* layout) |
bae7f79e | 119 | { |
e5366891 ILT |
120 | if (cmdline.begin() == cmdline.end()) |
121 | gold_fatal(_("no input files")); | |
122 | ||
fe9a4c12 ILT |
123 | int thread_count = options.thread_count_initial(); |
124 | if (thread_count == 0) | |
e5366891 | 125 | thread_count = cmdline.number_of_input_files(); |
fe9a4c12 ILT |
126 | workqueue->set_thread_count(thread_count); |
127 | ||
bae7f79e ILT |
128 | // Read the input files. We have to add the symbols to the symbol |
129 | // table in order. We do this by creating a separate blocker for | |
130 | // each input file. We associate the blocker with the following | |
131 | // input file, to give us a convenient place to delete it. | |
132 | Task_token* this_blocker = NULL; | |
ead1e424 ILT |
133 | for (Command_line::const_iterator p = cmdline.begin(); |
134 | p != cmdline.end(); | |
bae7f79e ILT |
135 | ++p) |
136 | { | |
17a1d0a9 | 137 | Task_token* next_blocker = new Task_token(true); |
bae7f79e | 138 | next_blocker->add_blocker(); |
12e14209 | 139 | workqueue->queue(new Read_symbols(options, input_objects, symtab, layout, |
17a1d0a9 | 140 | &search_path, &*p, NULL, this_blocker, |
a2fb1b05 | 141 | next_blocker)); |
bae7f79e ILT |
142 | this_blocker = next_blocker; |
143 | } | |
144 | ||
92e059d8 ILT |
145 | workqueue->queue(new Task_function(new Middle_runner(options, |
146 | input_objects, | |
147 | symtab, | |
148 | layout), | |
c7912668 ILT |
149 | this_blocker, |
150 | "Task_function Middle_runner")); | |
bae7f79e ILT |
151 | } |
152 | ||
92e059d8 ILT |
153 | // Queue up the middle set of tasks. These are the tasks which run |
154 | // after all the input objects have been found and all the symbols | |
155 | // have been read, but before we lay out the output file. | |
bae7f79e | 156 | |
92e059d8 ILT |
157 | void |
158 | queue_middle_tasks(const General_options& options, | |
17a1d0a9 | 159 | const Task* task, |
92e059d8 ILT |
160 | const Input_objects* input_objects, |
161 | Symbol_table* symtab, | |
162 | Layout* layout, | |
163 | Workqueue* workqueue) | |
61ba1cf9 | 164 | { |
fbfba508 ILT |
165 | // We have to support the case of not seeing any input objects, and |
166 | // generate an empty file. Existing builds depend on being able to | |
167 | // pass an empty archive to the linker and get an empty object file | |
168 | // out. In order to do this we need to use a default target. | |
2c0aeda4 ILT |
169 | if (input_objects->number_of_input_objects() == 0) |
170 | { | |
fbfba508 ILT |
171 | // The GOLD_xx macros are defined by the configure script. |
172 | Target* target = select_target(elfcpp::GOLD_DEFAULT_MACHINE, | |
173 | GOLD_DEFAULT_SIZE, | |
174 | GOLD_DEFAULT_BIG_ENDIAN, | |
175 | 0, 0); | |
176 | gold_assert(target != NULL); | |
177 | set_parameters_target(target); | |
2c0aeda4 ILT |
178 | } |
179 | ||
fe9a4c12 ILT |
180 | int thread_count = options.thread_count_middle(); |
181 | if (thread_count == 0) | |
fbfba508 | 182 | thread_count = std::max(2, input_objects->number_of_input_objects()); |
fe9a4c12 ILT |
183 | workqueue->set_thread_count(thread_count); |
184 | ||
b3b74ddc | 185 | // Now we have seen all the input files. |
436ca963 ILT |
186 | const bool doing_static_link = (!input_objects->any_dynamic() |
187 | && !parameters->output_is_shared()); | |
4eff2974 ILT |
188 | set_parameters_doing_static_link(doing_static_link); |
189 | if (!doing_static_link && options.is_static()) | |
190 | { | |
191 | // We print out just the first .so we see; there may be others. | |
75f2446e ILT |
192 | gold_error(_("cannot mix -static with dynamic object %s"), |
193 | (*input_objects->dynobj_begin())->name().c_str()); | |
4eff2974 | 194 | } |
6a74a719 ILT |
195 | if (!doing_static_link && parameters->output_is_object()) |
196 | gold_error(_("cannot mix -r with dynamic object %s"), | |
197 | (*input_objects->dynobj_begin())->name().c_str()); | |
b3b74ddc | 198 | |
494e05f4 ILT |
199 | if (is_debugging_enabled(DEBUG_SCRIPT)) |
200 | layout->script_options()->print(stderr); | |
201 | ||
e2827e5f ILT |
202 | // For each dynamic object, record whether we've seen all the |
203 | // dynamic objects that it depends upon. | |
204 | input_objects->check_dynamic_dependencies(); | |
205 | ||
70e654ba ILT |
206 | // See if any of the input definitions violate the One Definition Rule. |
207 | // TODO: if this is too slow, do this as a task, rather than inline. | |
17a1d0a9 | 208 | symtab->detect_odr_violations(task, options.output_file_name()); |
70e654ba | 209 | |
a3ad94ed ILT |
210 | // Define some sections and symbols needed for a dynamic link. This |
211 | // handles some cases we want to see before we read the relocs. | |
9b07f471 | 212 | layout->create_initial_dynamic_sections(symtab); |
a3ad94ed | 213 | |
a445fddf ILT |
214 | // Define symbols from any linker scripts. |
215 | layout->define_script_symbols(symtab); | |
216 | ||
6a74a719 ILT |
217 | if (!parameters->output_is_object()) |
218 | { | |
219 | // Predefine standard symbols. | |
220 | define_standard_symbols(symtab, layout); | |
ead1e424 | 221 | |
6a74a719 ILT |
222 | // Define __start and __stop symbols for output sections where |
223 | // appropriate. | |
224 | layout->define_section_symbols(symtab); | |
225 | } | |
bfd58944 | 226 | |
755ab8af ILT |
227 | // Make sure we have symbols for any required group signatures. |
228 | layout->define_group_signatures(symtab); | |
229 | ||
92e059d8 ILT |
230 | // Read the relocations of the input files. We do this to find |
231 | // which symbols are used by relocations which require a GOT and/or | |
232 | // a PLT entry, or a COPY reloc. When we implement garbage | |
233 | // collection we will do it here by reading the relocations in a | |
234 | // breadth first search by references. | |
235 | // | |
236 | // We could also read the relocations during the first pass, and | |
237 | // mark symbols at that time. That is how the old GNU linker works. | |
238 | // Doing that is more complex, since we may later decide to discard | |
239 | // some of the sections, and thus change our minds about the types | |
240 | // of references made to the symbols. | |
17a1d0a9 ILT |
241 | Task_token* blocker = new Task_token(true); |
242 | Task_token* symtab_lock = new Task_token(false); | |
f6ce93d6 ILT |
243 | for (Input_objects::Relobj_iterator p = input_objects->relobj_begin(); |
244 | p != input_objects->relobj_end(); | |
92e059d8 ILT |
245 | ++p) |
246 | { | |
247 | // We can read and process the relocations in any order. But we | |
248 | // only want one task to write to the symbol table at a time. | |
249 | // So we queue up a task for each object to read the | |
250 | // relocations. That task will in turn queue a task to wait | |
251 | // until it can write to the symbol table. | |
252 | blocker->add_blocker(); | |
ead1e424 ILT |
253 | workqueue->queue(new Read_relocs(options, symtab, layout, *p, |
254 | symtab_lock, blocker)); | |
92e059d8 ILT |
255 | } |
256 | ||
257 | // Allocate common symbols. This requires write access to the | |
258 | // symbol table, but is independent of the relocation processing. | |
6a74a719 ILT |
259 | // FIXME: We should have an option to do this even for a relocatable |
260 | // link. | |
261 | if (!parameters->output_is_object()) | |
262 | { | |
263 | blocker->add_blocker(); | |
264 | workqueue->queue(new Allocate_commons_task(options, symtab, layout, | |
265 | symtab_lock, blocker)); | |
266 | } | |
92e059d8 ILT |
267 | |
268 | // When all those tasks are complete, we can start laying out the | |
269 | // output file. | |
270 | workqueue->queue(new Task_function(new Layout_task_runner(options, | |
271 | input_objects, | |
272 | symtab, | |
273 | layout), | |
c7912668 ILT |
274 | blocker, |
275 | "Task_function Layout_task_runner")); | |
92e059d8 | 276 | } |
61ba1cf9 ILT |
277 | |
278 | // Queue up the final set of tasks. This is called at the end of | |
279 | // Layout_task. | |
280 | ||
281 | void | |
282 | queue_final_tasks(const General_options& options, | |
283 | const Input_objects* input_objects, | |
284 | const Symbol_table* symtab, | |
27bc2bce | 285 | Layout* layout, |
61ba1cf9 ILT |
286 | Workqueue* workqueue, |
287 | Output_file* of) | |
288 | { | |
fe9a4c12 ILT |
289 | int thread_count = options.thread_count_final(); |
290 | if (thread_count == 0) | |
fbfba508 | 291 | thread_count = std::max(2, input_objects->number_of_input_objects()); |
fe9a4c12 ILT |
292 | workqueue->set_thread_count(thread_count); |
293 | ||
17a1d0a9 ILT |
294 | bool any_postprocessing_sections = layout->any_postprocessing_sections(); |
295 | ||
730cdc88 ILT |
296 | // Use a blocker to wait until all the input sections have been |
297 | // written out. | |
17a1d0a9 ILT |
298 | Task_token* input_sections_blocker = NULL; |
299 | if (!any_postprocessing_sections) | |
300 | input_sections_blocker = new Task_token(true); | |
730cdc88 ILT |
301 | |
302 | // Use a blocker to block any objects which have to wait for the | |
303 | // output sections to complete before they can apply relocations. | |
17a1d0a9 | 304 | Task_token* output_sections_blocker = new Task_token(true); |
730cdc88 | 305 | |
61ba1cf9 | 306 | // Use a blocker to block the final cleanup task. |
17a1d0a9 | 307 | Task_token* final_blocker = new Task_token(true); |
61ba1cf9 ILT |
308 | |
309 | // Queue a task to write out the symbol table. | |
116724f3 ILT |
310 | if (!options.strip_all()) |
311 | { | |
312 | final_blocker->add_blocker(); | |
313 | workqueue->queue(new Write_symbols_task(symtab, | |
314 | input_objects, | |
315 | layout->sympool(), | |
316 | layout->dynpool(), | |
317 | of, | |
318 | final_blocker)); | |
319 | } | |
61ba1cf9 | 320 | |
730cdc88 ILT |
321 | // Queue a task to write out the output sections. |
322 | output_sections_blocker->add_blocker(); | |
323 | final_blocker->add_blocker(); | |
324 | workqueue->queue(new Write_sections_task(layout, of, output_sections_blocker, | |
325 | final_blocker)); | |
326 | ||
61ba1cf9 ILT |
327 | // Queue a task to write out everything else. |
328 | final_blocker->add_blocker(); | |
9025d29d | 329 | workqueue->queue(new Write_data_task(layout, symtab, of, final_blocker)); |
61ba1cf9 | 330 | |
17a1d0a9 ILT |
331 | // Queue a task for each input object to relocate the sections and |
332 | // write out the local symbols. | |
333 | for (Input_objects::Relobj_iterator p = input_objects->relobj_begin(); | |
334 | p != input_objects->relobj_end(); | |
335 | ++p) | |
336 | { | |
337 | if (input_sections_blocker != NULL) | |
338 | input_sections_blocker->add_blocker(); | |
339 | final_blocker->add_blocker(); | |
340 | workqueue->queue(new Relocate_task(options, symtab, layout, *p, of, | |
341 | input_sections_blocker, | |
342 | output_sections_blocker, | |
343 | final_blocker)); | |
344 | } | |
345 | ||
730cdc88 | 346 | // Queue a task to write out the output sections which depend on |
17a1d0a9 ILT |
347 | // input sections. If there are any sections which require |
348 | // postprocessing, then we need to do this last, since it may resize | |
349 | // the output file. | |
350 | if (!any_postprocessing_sections) | |
351 | { | |
352 | final_blocker->add_blocker(); | |
353 | Task* t = new Write_after_input_sections_task(layout, of, | |
354 | input_sections_blocker, | |
355 | final_blocker); | |
356 | workqueue->queue(t); | |
357 | } | |
358 | else | |
359 | { | |
360 | Task_token *new_final_blocker = new Task_token(true); | |
361 | new_final_blocker->add_blocker(); | |
362 | Task* t = new Write_after_input_sections_task(layout, of, | |
363 | final_blocker, | |
364 | new_final_blocker); | |
365 | workqueue->queue(t); | |
366 | final_blocker = new_final_blocker; | |
367 | } | |
730cdc88 | 368 | |
61ba1cf9 ILT |
369 | // Queue a task to close the output file. This will be blocked by |
370 | // FINAL_BLOCKER. | |
92e059d8 | 371 | workqueue->queue(new Task_function(new Close_task_runner(of), |
c7912668 ILT |
372 | final_blocker, |
373 | "Task_function Close_task_runner")); | |
61ba1cf9 ILT |
374 | } |
375 | ||
376 | } // End namespace gold. |