Commit | Line | Data |
---|---|---|
7e1edb90 ILT |
1 | // parameters.cc -- general parameters for a link using gold |
2 | ||
a3ed37d8 | 3 | // Copyright 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 |
2e702c99 | 4 | // Free Software Foundation, Inc. |
6cb15b7f ILT |
5 | // Written by Ian Lance Taylor <iant@google.com>. |
6 | ||
7 | // This file is part of gold. | |
8 | ||
9 | // This program is free software; you can redistribute it and/or modify | |
10 | // it under the terms of the GNU General Public License as published by | |
11 | // the Free Software Foundation; either version 3 of the License, or | |
12 | // (at your option) any later version. | |
13 | ||
14 | // This program is distributed in the hope that it will be useful, | |
15 | // but WITHOUT ANY WARRANTY; without even the implied warranty of | |
16 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
17 | // GNU General Public License for more details. | |
18 | ||
19 | // You should have received a copy of the GNU General Public License | |
20 | // along with this program; if not, write to the Free Software | |
21 | // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, | |
22 | // MA 02110-1301, USA. | |
23 | ||
7e1edb90 ILT |
24 | #include "gold.h" |
25 | ||
ee1fe73e | 26 | #include "debug.h" |
7e1edb90 | 27 | #include "options.h" |
96803768 | 28 | #include "target.h" |
8851ecca | 29 | #include "target-select.h" |
7e1edb90 ILT |
30 | |
31 | namespace gold | |
32 | { | |
33 | ||
114dfbe1 ILT |
34 | // Our local version of the variable, which is not const. |
35 | ||
36 | static Parameters static_parameters; | |
37 | ||
38 | // The global variable. | |
39 | ||
40 | const Parameters* parameters = &static_parameters; | |
41 | ||
42 | // A helper class to set the target once. | |
43 | ||
44 | class Set_parameters_target_once : public Once | |
45 | { | |
46 | public: | |
47 | Set_parameters_target_once(Parameters* parameters) | |
48 | : parameters_(parameters) | |
49 | { } | |
50 | ||
51 | protected: | |
52 | void | |
53 | do_run_once(void* arg) | |
54 | { this->parameters_->set_target_once(static_cast<Target*>(arg)); } | |
55 | ||
56 | private: | |
57 | Parameters* parameters_; | |
58 | }; | |
59 | ||
60 | // We only need one Set_parameters_target_once. | |
61 | ||
62 | static | |
63 | Set_parameters_target_once set_parameters_target_once(&static_parameters); | |
64 | ||
65 | // Class Parameters. | |
66 | ||
67 | Parameters::Parameters() | |
b490c0bb | 68 | : errors_(NULL), timer_(NULL), options_(NULL), target_(NULL), |
114dfbe1 | 69 | doing_static_link_valid_(false), doing_static_link_(false), |
8c21d9d3 | 70 | debug_(0), incremental_mode_(General_options::INCREMENTAL_OFF), |
114dfbe1 ILT |
71 | set_parameters_target_once_(&set_parameters_target_once) |
72 | { | |
73 | } | |
74 | ||
8851ecca | 75 | void |
2ea97941 | 76 | Parameters::set_errors(Errors* errors) |
7e1edb90 | 77 | { |
8851ecca | 78 | gold_assert(this->errors_ == NULL); |
2ea97941 | 79 | this->errors_ = errors; |
3c2fafa5 ILT |
80 | } |
81 | ||
b490c0bb CC |
82 | void |
83 | Parameters::set_timer(Timer* timer) | |
84 | { | |
85 | gold_assert(this->timer_ == NULL); | |
86 | this->timer_ = timer; | |
87 | } | |
88 | ||
3c2fafa5 | 89 | void |
2ea97941 | 90 | Parameters::set_options(const General_options* options) |
3c2fafa5 | 91 | { |
8851ecca | 92 | gold_assert(!this->options_valid()); |
2ea97941 | 93 | this->options_ = options; |
ee1fe73e ILT |
94 | // For speed, we convert the options() debug var from a string to an |
95 | // enum (from debug.h). | |
96 | this->debug_ = debug_string_to_enum(this->options().debug()); | |
8c21d9d3 CC |
97 | // Set incremental_mode_ based on the value of the --incremental option. |
98 | // We copy the mode into parameters because it can change based on inputs. | |
99 | this->incremental_mode_ = this->options().incremental_mode(); | |
2285a610 | 100 | // If --verbose is set, it acts as "--debug=files". |
2ea97941 | 101 | if (options->verbose()) |
2285a610 | 102 | this->debug_ |= DEBUG_FILES; |
7296d933 DK |
103 | if (this->target_valid()) |
104 | this->check_target_endianness(); | |
7e1edb90 ILT |
105 | } |
106 | ||
b3b74ddc | 107 | void |
2ea97941 | 108 | Parameters::set_doing_static_link(bool doing_static_link) |
b3b74ddc | 109 | { |
8851ecca | 110 | gold_assert(!this->doing_static_link_valid_); |
2ea97941 | 111 | this->doing_static_link_ = doing_static_link; |
8851ecca | 112 | this->doing_static_link_valid_ = true; |
b3b74ddc ILT |
113 | } |
114 | ||
9025d29d | 115 | void |
2ea97941 | 116 | Parameters::set_target(Target* target) |
9025d29d | 117 | { |
114dfbe1 ILT |
118 | this->set_parameters_target_once_->run_once(static_cast<void*>(target)); |
119 | gold_assert(target == this->target_); | |
120 | } | |
121 | ||
122 | // This is called at most once. | |
123 | ||
124 | void | |
125 | Parameters::set_target_once(Target* target) | |
126 | { | |
127 | gold_assert(this->target_ == NULL); | |
128 | this->target_ = target; | |
7296d933 | 129 | if (this->options_valid()) |
a3ed37d8 RM |
130 | { |
131 | this->check_target_endianness(); | |
132 | this->check_rodata_segment(); | |
133 | } | |
114dfbe1 ILT |
134 | } |
135 | ||
136 | // Clear the target, for testing. | |
137 | ||
138 | void | |
139 | Parameters::clear_target() | |
140 | { | |
141 | this->target_ = NULL; | |
142 | // We need a new Set_parameters_target_once so that we can set the | |
143 | // target again. | |
144 | this->set_parameters_target_once_ = new Set_parameters_target_once(this); | |
9025d29d ILT |
145 | } |
146 | ||
15f8229b ILT |
147 | // Return whether TARGET is compatible with the target we are using. |
148 | ||
149 | bool | |
2ea97941 | 150 | Parameters::is_compatible_target(const Target* target) const |
15f8229b ILT |
151 | { |
152 | if (this->target_ == NULL) | |
153 | return true; | |
2ea97941 | 154 | return target == this->target_; |
15f8229b ILT |
155 | } |
156 | ||
8851ecca ILT |
157 | Parameters::Target_size_endianness |
158 | Parameters::size_and_endianness() const | |
3c2fafa5 | 159 | { |
8851ecca ILT |
160 | if (this->target().get_size() == 32) |
161 | { | |
162 | if (!this->target().is_big_endian()) | |
163 | { | |
164 | #ifdef HAVE_TARGET_32_LITTLE | |
165 | return TARGET_32_LITTLE; | |
166 | #else | |
167 | gold_unreachable(); | |
168 | #endif | |
169 | } | |
170 | else | |
171 | { | |
172 | #ifdef HAVE_TARGET_32_BIG | |
173 | return TARGET_32_BIG; | |
174 | #else | |
175 | gold_unreachable(); | |
176 | #endif | |
177 | } | |
178 | } | |
179 | else if (parameters->target().get_size() == 64) | |
180 | { | |
181 | if (!parameters->target().is_big_endian()) | |
182 | { | |
183 | #ifdef HAVE_TARGET_64_LITTLE | |
184 | return TARGET_64_LITTLE; | |
185 | #else | |
186 | gold_unreachable(); | |
187 | #endif | |
188 | } | |
189 | else | |
190 | { | |
191 | #ifdef HAVE_TARGET_64_BIG | |
192 | return TARGET_64_BIG; | |
193 | #else | |
194 | gold_unreachable(); | |
195 | #endif | |
196 | } | |
197 | } | |
198 | else | |
199 | gold_unreachable(); | |
3c2fafa5 ILT |
200 | } |
201 | ||
7296d933 DK |
202 | // If output endianness is specified in command line, check that it does |
203 | // not conflict with the target. | |
204 | ||
205 | void | |
206 | Parameters::check_target_endianness() | |
207 | { | |
208 | General_options::Endianness endianness = this->options().endianness(); | |
209 | if (endianness != General_options::ENDIANNESS_NOT_SET) | |
210 | { | |
211 | bool big_endian; | |
212 | if (endianness == General_options::ENDIANNESS_BIG) | |
213 | big_endian = true; | |
214 | else | |
215 | { | |
216 | gold_assert(endianness == General_options::ENDIANNESS_LITTLE); | |
217 | big_endian = false;; | |
218 | } | |
2e702c99 | 219 | |
7296d933 DK |
220 | if (this->target().is_big_endian() != big_endian) |
221 | gold_error(_("input file does not match -EB/EL option")); | |
222 | } | |
223 | } | |
224 | ||
a3ed37d8 RM |
225 | void |
226 | Parameters::check_rodata_segment() | |
227 | { | |
228 | if (this->options().user_set_Trodata_segment() | |
229 | && !this->options().rosegment() | |
230 | && !this->target().isolate_execinstr()) | |
231 | gold_error(_("-Trodata-segment is meaningless without --rosegment")); | |
232 | } | |
233 | ||
a10ae760 ILT |
234 | // Return the name of the entry symbol. |
235 | ||
236 | const char* | |
237 | Parameters::entry() const | |
238 | { | |
239 | const char* ret = this->options().entry(); | |
240 | if (ret == NULL) | |
a67858e0 | 241 | ret = parameters->target().entry_symbol_name(); |
a10ae760 ILT |
242 | return ret; |
243 | } | |
244 | ||
8c21d9d3 CC |
245 | // Set the incremental linking mode to INCREMENTAL_FULL. Used when |
246 | // the linker determines that an incremental update is not possible. | |
247 | // Returns false if the incremental mode was INCREMENTAL_UPDATE, | |
248 | // indicating that the linker should exit if an update is not possible. | |
249 | ||
250 | bool | |
251 | Parameters::set_incremental_full() | |
252 | { | |
253 | gold_assert(this->incremental_mode_ != General_options::INCREMENTAL_OFF); | |
254 | if (this->incremental_mode_ == General_options::INCREMENTAL_UPDATE) | |
255 | return false; | |
256 | this->incremental_mode_ = General_options::INCREMENTAL_FULL; | |
257 | return true; | |
258 | } | |
259 | ||
260 | // Return true if we need to prepare incremental linking information. | |
261 | ||
262 | bool | |
263 | Parameters::incremental() const | |
264 | { | |
265 | return this->incremental_mode_ != General_options::INCREMENTAL_OFF; | |
266 | } | |
267 | ||
9fbd3822 CC |
268 | // Return true if we are doing a full incremental link. |
269 | ||
270 | bool | |
271 | Parameters::incremental_full() const | |
272 | { | |
273 | return this->incremental_mode_ == General_options::INCREMENTAL_FULL; | |
274 | } | |
275 | ||
8c21d9d3 CC |
276 | // Return true if we are doing an incremental update. |
277 | ||
278 | bool | |
279 | Parameters::incremental_update() const | |
280 | { | |
281 | return (this->incremental_mode_ == General_options::INCREMENTAL_UPDATE | |
282 | || this->incremental_mode_ == General_options::INCREMENTAL_AUTO); | |
283 | } | |
284 | ||
b3b74ddc | 285 | void |
8851ecca ILT |
286 | set_parameters_errors(Errors* errors) |
287 | { static_parameters.set_errors(errors); } | |
b3b74ddc | 288 | |
b490c0bb CC |
289 | void |
290 | set_parameters_timer(Timer* timer) | |
291 | { static_parameters.set_timer(timer); } | |
292 | ||
8851ecca ILT |
293 | void |
294 | set_parameters_options(const General_options* options) | |
295 | { static_parameters.set_options(options); } | |
b3b74ddc | 296 | |
9025d29d | 297 | void |
029ba973 | 298 | set_parameters_target(Target* target) |
0d31c79d DK |
299 | { |
300 | static_parameters.set_target(target); | |
301 | target->select_as_default_target(); | |
302 | } | |
8851ecca ILT |
303 | |
304 | void | |
305 | set_parameters_doing_static_link(bool doing_static_link) | |
306 | { static_parameters.set_doing_static_link(doing_static_link); } | |
7e1edb90 | 307 | |
8c21d9d3 CC |
308 | // Set the incremental linking mode to INCREMENTAL_FULL. Used when |
309 | // the linker determines that an incremental update is not possible. | |
310 | // Returns false if the incremental mode was INCREMENTAL_UPDATE, | |
311 | // indicating that the linker should exit if an update is not possible. | |
312 | bool | |
313 | set_parameters_incremental_full() | |
314 | { return static_parameters.set_incremental_full(); } | |
315 | ||
029ba973 ILT |
316 | // Force the target to be valid by using the default. Use the |
317 | // --oformat option is set; this supports the x86_64 kernel build, | |
318 | // which converts a binary file to an object file using -r --format | |
319 | // binary --oformat elf32-i386 foo.o. Otherwise use the configured | |
320 | // default. | |
321 | ||
322 | void | |
323 | parameters_force_valid_target() | |
324 | { | |
325 | if (parameters->target_valid()) | |
326 | return; | |
327 | ||
328 | gold_assert(parameters->options_valid()); | |
329 | if (parameters->options().user_set_oformat()) | |
330 | { | |
03ef7571 ILT |
331 | const char* bfd_name = parameters->options().oformat(); |
332 | Target* target = select_target_by_bfd_name(bfd_name); | |
029ba973 ILT |
333 | if (target != NULL) |
334 | { | |
335 | set_parameters_target(target); | |
336 | return; | |
337 | } | |
338 | ||
03ef7571 ILT |
339 | gold_error(_("unrecognized output format %s"), bfd_name); |
340 | } | |
341 | ||
342 | if (parameters->options().user_set_m()) | |
343 | { | |
344 | const char* emulation = parameters->options().m(); | |
345 | Target* target = select_target_by_emulation(emulation); | |
346 | if (target != NULL) | |
347 | { | |
348 | set_parameters_target(target); | |
349 | return; | |
350 | } | |
351 | ||
352 | gold_error(_("unrecognized emulation %s"), emulation); | |
029ba973 ILT |
353 | } |
354 | ||
355 | // The GOLD_DEFAULT_xx macros are defined by the configure script. | |
7296d933 DK |
356 | bool is_big_endian; |
357 | General_options::Endianness endianness = parameters->options().endianness(); | |
358 | if (endianness == General_options::ENDIANNESS_BIG) | |
359 | is_big_endian = true; | |
360 | else if (endianness == General_options::ENDIANNESS_LITTLE) | |
361 | is_big_endian = false; | |
362 | else | |
363 | is_big_endian = GOLD_DEFAULT_BIG_ENDIAN; | |
364 | ||
2e702c99 RM |
365 | Target* target = select_target(NULL, 0, |
366 | elfcpp::GOLD_DEFAULT_MACHINE, | |
029ba973 | 367 | GOLD_DEFAULT_SIZE, |
7296d933 | 368 | is_big_endian, |
029ba973 ILT |
369 | elfcpp::GOLD_DEFAULT_OSABI, |
370 | 0); | |
f1ddb600 ILT |
371 | |
372 | if (target == NULL) | |
373 | { | |
374 | gold_assert(is_big_endian != GOLD_DEFAULT_BIG_ENDIAN); | |
375 | gold_fatal(_("no supported target for -EB/-EL option")); | |
376 | } | |
377 | ||
029ba973 ILT |
378 | set_parameters_target(target); |
379 | } | |
380 | ||
381 | // Clear the current target, for testing. | |
382 | ||
383 | void | |
384 | parameters_clear_target() | |
385 | { | |
386 | static_parameters.clear_target(); | |
387 | } | |
388 | ||
7e1edb90 | 389 | } // End namespace gold. |