Commit | Line | Data |
---|---|---|
5a6f7e2d | 1 | // gold.cc -- main linker functions |
bae7f79e | 2 | |
6cb15b7f ILT |
3 | // Copyright 2006, 2007 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 | ||
bae7f79e ILT |
23 | #include "gold.h" |
24 | ||
25 | #include <cstdlib> | |
26 | #include <cstdio> | |
27 | #include <cstring> | |
28 | #include <unistd.h> | |
75f2446e | 29 | #include "libiberty.h" |
bae7f79e ILT |
30 | |
31 | #include "options.h" | |
32 | #include "workqueue.h" | |
33 | #include "dirsearch.h" | |
34 | #include "readsyms.h" | |
14bfc3f5 | 35 | #include "symtab.h" |
ead1e424 | 36 | #include "common.h" |
54dc6425 | 37 | #include "object.h" |
a2fb1b05 | 38 | #include "layout.h" |
61ba1cf9 | 39 | #include "reloc.h" |
ead1e424 | 40 | #include "defstd.h" |
bae7f79e ILT |
41 | |
42 | namespace gold | |
43 | { | |
44 | ||
45 | const char* program_name; | |
46 | ||
47 | void | |
48 | gold_exit(bool status) | |
49 | { | |
75f2446e ILT |
50 | if (!status && parameters != NULL) |
51 | unlink_if_ordinary(parameters->output_file_name()); | |
bae7f79e ILT |
52 | exit(status ? EXIT_SUCCESS : EXIT_FAILURE); |
53 | } | |
54 | ||
bae7f79e ILT |
55 | void |
56 | gold_nomem() | |
57 | { | |
58 | // We are out of memory, so try hard to print a reasonable message. | |
59 | // Note that we don't try to translate this message, since the | |
60 | // translation process itself will require memory. | |
61 | write(2, program_name, strlen(program_name)); | |
62 | const char* const s = ": out of memory\n"; | |
63 | write(2, s, strlen(s)); | |
64 | gold_exit(false); | |
65 | } | |
66 | ||
a3ad94ed ILT |
67 | // Handle an unreachable case. |
68 | ||
bae7f79e | 69 | void |
a3ad94ed | 70 | do_gold_unreachable(const char* filename, int lineno, const char* function) |
bae7f79e | 71 | { |
27b7985a | 72 | fprintf(stderr, _("%s: internal error in %s, at %s:%d\n"), |
a3ad94ed ILT |
73 | program_name, function, filename, lineno); |
74 | gold_exit(false); | |
bae7f79e ILT |
75 | } |
76 | ||
92e059d8 ILT |
77 | // This class arranges to run the functions done in the middle of the |
78 | // link. It is just a closure. | |
bae7f79e | 79 | |
92e059d8 | 80 | class Middle_runner : public Task_function_runner |
bae7f79e | 81 | { |
92e059d8 ILT |
82 | public: |
83 | Middle_runner(const General_options& options, | |
84 | const Input_objects* input_objects, | |
85 | Symbol_table* symtab, | |
86 | Layout* layout) | |
87 | : options_(options), input_objects_(input_objects), symtab_(symtab), | |
88 | layout_(layout) | |
89 | { } | |
90 | ||
91 | void | |
92 | run(Workqueue*); | |
93 | ||
94 | private: | |
95 | const General_options& options_; | |
96 | const Input_objects* input_objects_; | |
97 | Symbol_table* symtab_; | |
98 | Layout* layout_; | |
99 | }; | |
bae7f79e | 100 | |
92e059d8 ILT |
101 | void |
102 | Middle_runner::run(Workqueue* workqueue) | |
103 | { | |
104 | queue_middle_tasks(this->options_, this->input_objects_, this->symtab_, | |
105 | this->layout_, workqueue); | |
106 | } | |
bae7f79e ILT |
107 | |
108 | // Queue up the initial set of tasks for this link job. | |
109 | ||
110 | void | |
111 | queue_initial_tasks(const General_options& options, | |
112 | const Dirsearch& search_path, | |
ead1e424 | 113 | const Command_line& cmdline, |
54dc6425 | 114 | Workqueue* workqueue, Input_objects* input_objects, |
12e14209 | 115 | Symbol_table* symtab, Layout* layout) |
bae7f79e | 116 | { |
ead1e424 | 117 | if (cmdline.begin() == cmdline.end()) |
75f2446e | 118 | gold_fatal(_("no input files")); |
bae7f79e ILT |
119 | |
120 | // Read the input files. We have to add the symbols to the symbol | |
121 | // table in order. We do this by creating a separate blocker for | |
122 | // each input file. We associate the blocker with the following | |
123 | // input file, to give us a convenient place to delete it. | |
124 | Task_token* this_blocker = NULL; | |
ead1e424 ILT |
125 | for (Command_line::const_iterator p = cmdline.begin(); |
126 | p != cmdline.end(); | |
bae7f79e ILT |
127 | ++p) |
128 | { | |
129 | Task_token* next_blocker = new Task_token(); | |
130 | next_blocker->add_blocker(); | |
12e14209 | 131 | workqueue->queue(new Read_symbols(options, input_objects, symtab, layout, |
dbe717ef | 132 | search_path, &*p, NULL, this_blocker, |
a2fb1b05 | 133 | next_blocker)); |
bae7f79e ILT |
134 | this_blocker = next_blocker; |
135 | } | |
136 | ||
92e059d8 ILT |
137 | workqueue->queue(new Task_function(new Middle_runner(options, |
138 | input_objects, | |
139 | symtab, | |
140 | layout), | |
141 | this_blocker)); | |
bae7f79e ILT |
142 | } |
143 | ||
92e059d8 ILT |
144 | // Queue up the middle set of tasks. These are the tasks which run |
145 | // after all the input objects have been found and all the symbols | |
146 | // have been read, but before we lay out the output file. | |
bae7f79e | 147 | |
92e059d8 ILT |
148 | void |
149 | queue_middle_tasks(const General_options& options, | |
150 | const Input_objects* input_objects, | |
151 | Symbol_table* symtab, | |
152 | Layout* layout, | |
153 | Workqueue* workqueue) | |
61ba1cf9 | 154 | { |
b3b74ddc | 155 | // Now we have seen all the input files. |
436ca963 ILT |
156 | const bool doing_static_link = (!input_objects->any_dynamic() |
157 | && !parameters->output_is_shared()); | |
4eff2974 ILT |
158 | set_parameters_doing_static_link(doing_static_link); |
159 | if (!doing_static_link && options.is_static()) | |
160 | { | |
161 | // We print out just the first .so we see; there may be others. | |
75f2446e ILT |
162 | gold_error(_("cannot mix -static with dynamic object %s"), |
163 | (*input_objects->dynobj_begin())->name().c_str()); | |
4eff2974 | 164 | } |
b3b74ddc | 165 | |
a3ad94ed ILT |
166 | // Define some sections and symbols needed for a dynamic link. This |
167 | // handles some cases we want to see before we read the relocs. | |
168 | layout->create_initial_dynamic_sections(input_objects, symtab); | |
169 | ||
ead1e424 ILT |
170 | // Predefine standard symbols. This should be fast, so we don't |
171 | // bother to create a task for it. | |
172 | define_standard_symbols(symtab, layout, input_objects->target()); | |
173 | ||
bfd58944 ILT |
174 | // Define __start and __stop symbols for output sections where |
175 | // appropriate. | |
176 | layout->define_section_symbols(symtab, input_objects->target()); | |
177 | ||
92e059d8 ILT |
178 | // Read the relocations of the input files. We do this to find |
179 | // which symbols are used by relocations which require a GOT and/or | |
180 | // a PLT entry, or a COPY reloc. When we implement garbage | |
181 | // collection we will do it here by reading the relocations in a | |
182 | // breadth first search by references. | |
183 | // | |
184 | // We could also read the relocations during the first pass, and | |
185 | // mark symbols at that time. That is how the old GNU linker works. | |
186 | // Doing that is more complex, since we may later decide to discard | |
187 | // some of the sections, and thus change our minds about the types | |
188 | // of references made to the symbols. | |
189 | Task_token* blocker = new Task_token(); | |
190 | Task_token* symtab_lock = new Task_token(); | |
f6ce93d6 ILT |
191 | for (Input_objects::Relobj_iterator p = input_objects->relobj_begin(); |
192 | p != input_objects->relobj_end(); | |
92e059d8 ILT |
193 | ++p) |
194 | { | |
195 | // We can read and process the relocations in any order. But we | |
196 | // only want one task to write to the symbol table at a time. | |
197 | // So we queue up a task for each object to read the | |
198 | // relocations. That task will in turn queue a task to wait | |
199 | // until it can write to the symbol table. | |
200 | blocker->add_blocker(); | |
ead1e424 ILT |
201 | workqueue->queue(new Read_relocs(options, symtab, layout, *p, |
202 | symtab_lock, blocker)); | |
92e059d8 ILT |
203 | } |
204 | ||
205 | // Allocate common symbols. This requires write access to the | |
206 | // symbol table, but is independent of the relocation processing. | |
ead1e424 ILT |
207 | blocker->add_blocker(); |
208 | workqueue->queue(new Allocate_commons_task(options, symtab, layout, | |
209 | symtab_lock, blocker)); | |
92e059d8 ILT |
210 | |
211 | // When all those tasks are complete, we can start laying out the | |
212 | // output file. | |
213 | workqueue->queue(new Task_function(new Layout_task_runner(options, | |
214 | input_objects, | |
215 | symtab, | |
216 | layout), | |
217 | blocker)); | |
218 | } | |
61ba1cf9 ILT |
219 | |
220 | // Queue up the final set of tasks. This is called at the end of | |
221 | // Layout_task. | |
222 | ||
223 | void | |
224 | queue_final_tasks(const General_options& options, | |
225 | const Input_objects* input_objects, | |
226 | const Symbol_table* symtab, | |
227 | const Layout* layout, | |
228 | Workqueue* workqueue, | |
229 | Output_file* of) | |
230 | { | |
231 | // Use a blocker to block the final cleanup task. | |
232 | Task_token* final_blocker = new Task_token(); | |
233 | ||
234 | // Queue a task for each input object to relocate the sections and | |
235 | // write out the local symbols. | |
f6ce93d6 ILT |
236 | for (Input_objects::Relobj_iterator p = input_objects->relobj_begin(); |
237 | p != input_objects->relobj_end(); | |
61ba1cf9 ILT |
238 | ++p) |
239 | { | |
240 | final_blocker->add_blocker(); | |
92e059d8 ILT |
241 | workqueue->queue(new Relocate_task(options, symtab, layout, *p, of, |
242 | final_blocker)); | |
61ba1cf9 ILT |
243 | } |
244 | ||
245 | // Queue a task to write out the symbol table. | |
246 | final_blocker->add_blocker(); | |
16649710 ILT |
247 | workqueue->queue(new Write_symbols_task(symtab, |
248 | input_objects->target(), | |
249 | layout->sympool(), | |
250 | layout->dynpool(), | |
251 | of, | |
61ba1cf9 ILT |
252 | final_blocker)); |
253 | ||
254 | // Queue a task to write out everything else. | |
255 | final_blocker->add_blocker(); | |
9025d29d | 256 | workqueue->queue(new Write_data_task(layout, symtab, of, final_blocker)); |
61ba1cf9 ILT |
257 | |
258 | // Queue a task to close the output file. This will be blocked by | |
259 | // FINAL_BLOCKER. | |
92e059d8 ILT |
260 | workqueue->queue(new Task_function(new Close_task_runner(of), |
261 | final_blocker)); | |
61ba1cf9 ILT |
262 | } |
263 | ||
264 | } // End namespace gold. |