1// parameters.h -- general parameters for a link using gold  -*- C++ -*-
2
3// Copyright (C) 2006-2017 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#ifndef GOLD_PARAMETERS_H
24#define GOLD_PARAMETERS_H
25
26namespace gold
27{
28
29class General_options;
30class Errors;
31class Timer;
32class Target;
33template<int size, bool big_endian>
34class Sized_target;
35class Set_parameters_target_once;
36
37// Here we define the Parameters class which simply holds simple
38// general parameters which apply to the entire link.  We use a global
39// variable for this.  The parameters class holds three types of data:
40//    1) An Errors struct.  Any part of the code that wants to log an
41//       error can use parameters->errors().
42//    2) A const General_options.  These are the options as read on
43//       the commandline.
44//    3) Target information, such as size and endian-ness.  This is
45//       available as soon as we've decided on the Target (after
46//       parsing the first .o file).
47//    4) Whether we're doing a static link or not.  This is set
48//       after all inputs have been read and we know if any is a
49//       dynamic library.
50
51class Parameters
52{
53 public:
54  Parameters();
55
56  // These should be called as soon as they are known.
57  void
58  set_errors(Errors* errors);
59
60  void
61  set_timer(Timer* timer);
62
63  void
64  set_options(const General_options* options);
65
66  void
67  set_target(Target* target);
68
69  void
70  set_doing_static_link(bool doing_static_link);
71
72  // Return the error object.
73  Errors*
74  errors() const
75  { return this->errors_; }
76
77  // Return the timer object.
78  Timer*
79  timer() const
80  { return this->timer_; }
81
82  // Whether the options are valid.  This should not normally be
83  // called, but it is needed by gold_exit.
84  bool
85  options_valid() const
86  { return this->options_ != NULL; }
87
88  // Return the options object.
89  const General_options&
90  options() const
91  {
92    gold_assert(this->options_valid());
93    return *this->options_;
94  }
95
96  // Return whether the target field has been set.
97  bool
98  target_valid() const
99  { return this->target_ != NULL; }
100
101  // The target of the output file we are generating.
102  const Target&
103  target() const
104  {
105    gold_assert(this->target_valid());
106    return *this->target_;
107  }
108
109  // The Sized_target of the output file.  The caller must request the
110  // right size and endianness.
111  template<int size, bool big_endian>
112  Sized_target<size, big_endian>*
113  sized_target() const
114  {
115    gold_assert(this->target_valid());
116    return static_cast<Sized_target<size, big_endian>*>(this->target_);
117  }
118
119  // Clear the target, for testing.
120  void
121  clear_target();
122
123  // Return true if TARGET is compatible with the current target.
124  bool
125  is_compatible_target(const Target*) const;
126
127  bool
128  doing_static_link() const
129  {
130    gold_assert(this->doing_static_link_valid_);
131    return this->doing_static_link_;
132  }
133
134  // This is just a copy of options().debug().  We make a copy so we
135  // don't have to #include options.h in order to inline
136  // is_debugging_enabled, below.
137  int
138  debug() const
139  {
140    // This can be called before the options are set up.
141    if (!this->options_valid())
142      return 0;
143    return debug_;
144  }
145
146  // Return the name of the entry symbol.
147  const char*
148  entry() const;
149
150  // A convenience routine for combining size and endianness.  It also
151  // checks the HAVE_TARGET_FOO configure options and dies if the
152  // current target's size/endianness is not supported according to
153  // HAVE_TARGET_FOO.  Otherwise it returns this enum
154  enum Target_size_endianness
155  { TARGET_32_LITTLE, TARGET_32_BIG, TARGET_64_LITTLE, TARGET_64_BIG };
156
157  Target_size_endianness
158  size_and_endianness() const;
159
160  // Set the incremental linking mode to INCREMENTAL_FULL.  Used when
161  // the linker determines that an incremental update is not possible.
162  // Returns false if the incremental mode was INCREMENTAL_UPDATE,
163  // indicating that the linker should exit if an update is not possible.
164  bool
165  set_incremental_full();
166
167  // Return true if we need to prepare incremental linking information.
168  bool
169  incremental() const;
170
171  // Return true if we are doing a full incremental link.
172  bool
173  incremental_full() const;
174
175  // Return true if we are doing an incremental update.
176  bool
177  incremental_update() const;
178
179 private:
180  void
181  set_target_once(Target*);
182
183  void
184  check_target_endianness();
185
186  void
187  check_rodata_segment();
188
189  friend class Set_parameters_target_once;
190
191  Errors* errors_;
192  Timer* timer_;
193  const General_options* options_;
194  Target* target_;
195  bool doing_static_link_valid_;
196  bool doing_static_link_;
197  int debug_;
198  int incremental_mode_;
199  Set_parameters_target_once* set_parameters_target_once_;
200};
201
202// This is a global variable.
203extern const Parameters* parameters;
204
205// We use free functions for these since they affect a global variable
206// that is internal to parameters.cc.
207
208extern void
209set_parameters_errors(Errors* errors);
210
211extern void
212set_parameters_timer(Timer* timer);
213
214extern void
215set_parameters_options(const General_options* options);
216
217extern void
218set_parameters_target(Target* target);
219
220extern void
221set_parameters_doing_static_link(bool doing_static_link);
222
223extern bool
224set_parameters_incremental_full();
225
226// Ensure that the target to be valid by using the default target if
227// necessary.
228
229extern void
230parameters_force_valid_target();
231
232// Clear the current target, for testing.
233
234extern void
235parameters_clear_target();
236
237// Return whether we are doing a particular debugging type.  The
238// argument is one of the flags from debug.h.
239
240inline bool
241is_debugging_enabled(unsigned int type)
242{ return (parameters->debug() & type) != 0; }
243
244} // End namespace gold.
245
246#endif // !defined(GOLD_PARAMETERS_H)
247