1 // parameters.h -- general parameters for a link using gold -*- C++ -*-
2
3 // Copyright (C) 2006-2023 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
26 namespace gold
27 {
28
29 class General_options;
30 class Errors;
31 class Timer;
32 class Target;
33 template<int size, bool big_endian>
34 class Sized_target;
35 class 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
51 class 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.
203 extern 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
208 extern void
209 set_parameters_errors(Errors* errors);
210
211 extern void
212 set_parameters_timer(Timer* timer);
213
214 extern void
215 set_parameters_options(const General_options* options);
216
217 extern void
218 set_parameters_target(Target* target);
219
220 extern void
221 set_parameters_doing_static_link(bool doing_static_link);
222
223 extern bool
224 set_parameters_incremental_full();
225
226 // Ensure that the target to be valid by using the default target if
227 // necessary.
228
229 extern void
230 parameters_force_valid_target();
231
232 // Clear the current target, for testing.
233
234 extern void
235 parameters_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
240 inline bool
241 is_debugging_enabled(unsigned int type)
242 { return (parameters->debug() & type) != 0; }
243
244 } // End namespace gold.
245
246 #endif // !defined(GOLD_PARAMETERS_H)