1 // parameters.cc -- general parameters for a link using gold
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 "debug.h"
26 #include "options.h"
27 #include "target.h"
28 #include "target-select.h"
29 
30 namespace gold
31 {
32 
33 // Our local version of the variable, which is not const.
34 
35 static Parameters static_parameters;
36 
37 // The global variable.
38 
39 const Parameters* parameters = &static_parameters;
40 
41 // A helper class to set the target once.
42 
43 class Set_parameters_target_once : public Once
44 {
45  public:
46   Set_parameters_target_once(Parameters* parameters)
47     : parameters_(parameters)
48   { }
49 
50  protected:
51   void
52   do_run_once(void* arg)
53   { this->parameters_->set_target_once(static_cast<Target*>(arg)); }
54 
55  private:
56   Parameters* parameters_;
57 };
58 
59 // We only need one Set_parameters_target_once.
60 
61 static
62 Set_parameters_target_once set_parameters_target_once(&static_parameters);
63 
64 // Class Parameters.
65 
66 Parameters::Parameters()
67    : errors_(NULL), timer_(NULL), options_(NULL), target_(NULL),
68      doing_static_link_valid_(false), doing_static_link_(false),
69      debug_(0), incremental_mode_(General_options::INCREMENTAL_OFF),
70      set_parameters_target_once_(&set_parameters_target_once)
71  {
72  }
73 
74 void
75 Parameters::set_errors(Errors* errors)
76 {
77   gold_assert(this->errors_ == NULL);
78   this->errors_ = errors;
79 }
80 
81 void
82 Parameters::set_timer(Timer* timer)
83 {
84   gold_assert(this->timer_ == NULL);
85   this->timer_ = timer;
86 }
87 
88 void
89 Parameters::set_options(const General_options* options)
90 {
91   gold_assert(!this->options_valid());
92   this->options_ = options;
93   // For speed, we convert the options() debug var from a string to an
94   // enum (from debug.h).
95   this->debug_ = debug_string_to_enum(this->options().debug());
96   // Set incremental_mode_ based on the value of the --incremental option.
97   // We copy the mode into parameters because it can change based on inputs.
98   this->incremental_mode_ = this->options().incremental_mode();
99   // If --verbose is set, it acts as "--debug=files".
100   if (options->verbose())
101     this->debug_ |= DEBUG_FILES;
102   if (this->target_valid())
103     this->check_target_endianness();
104 }
105 
106 void
107 Parameters::set_doing_static_link(bool doing_static_link)
108 {
109   gold_assert(!this->doing_static_link_valid_);
110   this->doing_static_link_ = doing_static_link;
111   this->doing_static_link_valid_ = true;
112 }
113 
114 void
115 Parameters::set_target(Target* target)
116 {
117   this->set_parameters_target_once_->run_once(static_cast<void*>(target));
118   gold_assert(target == this->target_);
119 }
120 
121 // This is called at most once.
122 
123 void
124 Parameters::set_target_once(Target* target)
125 {
126   gold_assert(this->target_ == NULL);
127   this->target_ = target;
128   target->select_as_default_target();
129   if (this->options_valid())
130     {
131       this->check_target_endianness();
132       this->check_rodata_segment();
133     }
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);
145 }
146 
147 // Return whether TARGET is compatible with the target we are using.
148 
149 bool
150 Parameters::is_compatible_target(const Target* target) const
151 {
152   if (this->target_ == NULL)
153     return true;
154   return target == this->target_;
155 }
156 
157 Parameters::Target_size_endianness
158 Parameters::size_and_endianness() const
159 {
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();
200 }
201 
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 	}
219 
220       if (this->target().is_big_endian() != big_endian)
221 	gold_error(_("input file does not match -EB/EL option"));
222     }
223 }
224 
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 
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 && parameters->target_valid())
241     ret = parameters->target().entry_symbol_name();
242   return ret;
243 }
244 
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 
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 
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 
285 void
286 set_parameters_errors(Errors* errors)
287 { static_parameters.set_errors(errors); }
288 
289 void
290 set_parameters_timer(Timer* timer)
291 { static_parameters.set_timer(timer); }
292 
293 void
294 set_parameters_options(const General_options* options)
295 { static_parameters.set_options(options); }
296 
297 void
298 set_parameters_target(Target* target)
299 {
300   static_parameters.set_target(target);
301 }
302 
303 void
304 set_parameters_doing_static_link(bool doing_static_link)
305 { static_parameters.set_doing_static_link(doing_static_link); }
306 
307 // Set the incremental linking mode to INCREMENTAL_FULL.  Used when
308 // the linker determines that an incremental update is not possible.
309 // Returns false if the incremental mode was INCREMENTAL_UPDATE,
310 // indicating that the linker should exit if an update is not possible.
311 bool
312 set_parameters_incremental_full()
313 { return static_parameters.set_incremental_full(); }
314 
315 // Force the target to be valid by using the default.  Use the
316 // --oformat option is set; this supports the x86_64 kernel build,
317 // which converts a binary file to an object file using -r --format
318 // binary --oformat elf32-i386 foo.o.  Otherwise use the configured
319 // default.
320 
321 void
322 parameters_force_valid_target()
323 {
324   if (parameters->target_valid())
325     return;
326 
327   gold_assert(parameters->options_valid());
328   if (parameters->options().user_set_oformat())
329     {
330       const char* bfd_name = parameters->options().oformat();
331       Target* target = select_target_by_bfd_name(bfd_name);
332       if (target != NULL)
333 	{
334 	  set_parameters_target(target);
335 	  return;
336 	}
337 
338       gold_error(_("unrecognized output format %s"), bfd_name);
339     }
340 
341   if (parameters->options().user_set_m())
342     {
343       const char* emulation = parameters->options().m();
344       Target* target = select_target_by_emulation(emulation);
345       if (target != NULL)
346 	{
347 	  set_parameters_target(target);
348 	  return;
349 	}
350 
351       gold_error(_("unrecognized emulation %s"), emulation);
352     }
353 
354   // The GOLD_DEFAULT_xx macros are defined by the configure script.
355   bool is_big_endian;
356   General_options::Endianness endianness = parameters->options().endianness();
357   if (endianness == General_options::ENDIANNESS_BIG)
358     is_big_endian = true;
359   else if (endianness == General_options::ENDIANNESS_LITTLE)
360     is_big_endian = false;
361   else
362     is_big_endian = GOLD_DEFAULT_BIG_ENDIAN;
363 
364   Target* target = select_target(NULL, 0,
365 				 elfcpp::GOLD_DEFAULT_MACHINE,
366 				 GOLD_DEFAULT_SIZE,
367 				 is_big_endian,
368 				 elfcpp::GOLD_DEFAULT_OSABI,
369 				 0);
370 
371   if (target == NULL)
372     {
373       gold_assert(is_big_endian != GOLD_DEFAULT_BIG_ENDIAN);
374       gold_fatal(_("no supported target for -EB/-EL option"));
375     }
376 
377   set_parameters_target(target);
378 }
379 
380 // Clear the current target, for testing.
381 
382 void
383 parameters_clear_target()
384 {
385   static_parameters.clear_target();
386 }
387 
388 } // End namespace gold.
389