* tracepoint.c (trace_status_command): Add some status output.
[deliverable/binutils-gdb.git] / gold / script.h
CommitLineData
dbe717ef
ILT
1// script.h -- handle linker scripts for gold -*- C++ -*-
2
e5756efb 3// Copyright 2006, 2007, 2008 Free Software Foundation, Inc.
6cb15b7f
ILT
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
dbe717ef
ILT
23// We implement a subset of the original GNU ld linker script language
24// for compatibility. The goal is not to implement the entire
25// language. It is merely to implement enough to handle common uses.
26// In particular we need to handle /usr/lib/libc.so on a typical
27// GNU/Linux system, and we want to handle linker scripts used by the
28// Linux kernel build.
29
30#ifndef GOLD_SCRIPT_H
31#define GOLD_SCRIPT_H
32
494e05f4 33#include <cstdio>
04bf7072 34#include <string>
e5756efb
ILT
35#include <vector>
36
494e05f4 37#include "script-sections.h"
09124467 38
dbe717ef
ILT
39namespace gold
40{
41
42class General_options;
3c2fafa5 43class Command_line;
dbe717ef
ILT
44class Symbol_table;
45class Layout;
7d9e3d98 46class Mapfile;
3c2fafa5 47class Input_argument;
072fe7ce 48class Input_arguments;
dbe717ef
ILT
49class Input_objects;
50class Input_group;
51class Input_file;
a445fddf 52class Output_segment;
dbe717ef 53class Task_token;
3c2fafa5 54class Workqueue;
494e05f4
ILT
55struct Version_dependency_list;
56struct Version_expression_list;
57struct Version_tree;
dbe717ef 58
e5756efb
ILT
59// This class represents an expression in a linker script.
60
61class Expression
62{
63 protected:
64 // These should only be created by child classes.
65 Expression()
66 { }
67
68 public:
69 virtual ~Expression()
70 { }
71
a445fddf 72 // Return the value of the expression which is not permitted to
919ed24c
ILT
73 // refer to the dot symbol. CHECK_ASSERTIONS is true if we should
74 // check whether assertions are true.
e5756efb 75 uint64_t
919ed24c 76 eval(const Symbol_table*, const Layout*, bool check_assertions);
e5756efb 77
a445fddf 78 // Return the value of an expression which is permitted to refer to
77e65537
ILT
79 // the dot symbol. DOT_VALUE is the absolute value of the dot
80 // symbol. DOT_SECTION is the section in which dot is defined; it
81 // should be NULL if the dot symbol has an absolute value (e.g., is
82 // defined in a SECTIONS clause outside of any output section
83 // definition). This sets *RESULT_SECTION to indicate where the
84 // value is defined. If the value is absolute *RESULT_SECTION will
85 // be NULL. Note that the returned value is still an absolute
86 // value; to get a section relative value the caller must subtract
87 // the section address.
a445fddf 88 uint64_t
919ed24c
ILT
89 eval_with_dot(const Symbol_table*, const Layout*, bool check_assertions,
90 uint64_t dot_value, Output_section* dot_section,
91 Output_section** result_section);
a445fddf
ILT
92
93 // Return the value of an expression which may or may not be
94 // permitted to refer to the dot symbol, depending on
95 // is_dot_available.
96 uint64_t
919ed24c
ILT
97 eval_maybe_dot(const Symbol_table*, const Layout*, bool check_assertions,
98 bool is_dot_available, uint64_t dot_value,
99 Output_section* dot_section,
77e65537 100 Output_section** result_section);
a445fddf 101
494e05f4
ILT
102 // Print the expression to the FILE. This is for debugging.
103 virtual void
104 print(FILE*) const = 0;
105
e5756efb
ILT
106 protected:
107 struct Expression_eval_info;
108
109 public:
110 // Compute the value of the expression (implemented by child class).
111 // This is public rather than protected because it is called
112 // directly by children of Expression on other Expression objects.
113 virtual uint64_t
114 value(const Expression_eval_info*) = 0;
115
116 private:
117 // May not be copied.
118 Expression(const Expression&);
119 Expression& operator=(const Expression&);
120};
121
09124467
ILT
122
123// Version_script_info stores information parsed from the version
124// script, either provided by --version-script or as part of a linker
125// script. A single Version_script_info object per target is owned by
126// Script_options.
127
494e05f4
ILT
128class Version_script_info
129{
09124467
ILT
130 public:
131 ~Version_script_info();
132
1ef1f3d3
ILT
133 // Clear everything.
134 void
135 clear();
136
09124467
ILT
137 // Return whether any version were defined in the version script.
138 bool
139 empty() const
140 { return this->version_trees_.empty(); }
141
057ead22
ILT
142 // If there is a version associated with SYMBOL, return true, and
143 // set *VERSION to the version. Otherwise, return false.
144 bool
145 get_symbol_version(const char* symbol, std::string* version) const
146 { return this->get_symbol_version_helper(symbol, true, version); }
147
148 // Return whether this symbol matches the local: section of some
149 // version.
09124467
ILT
150 bool
151 symbol_is_local(const char* symbol) const
057ead22 152 { return this->get_symbol_version_helper(symbol, false, NULL); }
09124467
ILT
153
154 // Return the names of versions defined in the version script.
155 // Strings are allocated out of the stringpool given in the
156 // constructor.
157 std::vector<std::string>
158 get_versions() const;
159
160 // Return the list of dependencies for this version.
161 std::vector<std::string>
162 get_dependencies(const char* version) const;
163
164 // The following functions should only be used by the bison helper
165 // functions. They allocate new structs whose memory belongs to
166 // Version_script_info. The bison functions copy the information
167 // from the version script into these structs.
168 struct Version_dependency_list*
169 allocate_dependency_list();
170
171 struct Version_expression_list*
172 allocate_expression_list();
173
174 struct Version_tree*
175 allocate_version_tree();
176
494e05f4
ILT
177 // Print contents to the FILE. This is for debugging.
178 void
179 print(FILE*) const;
180
09124467 181 private:
494e05f4
ILT
182 void
183 print_expression_list(FILE* f, const Version_expression_list*) const;
184
057ead22
ILT
185 bool get_symbol_version_helper(const char* symbol,
186 bool check_global,
187 std::string* pversion) const;
09124467
ILT
188
189 std::vector<struct Version_dependency_list*> dependency_lists_;
190 std::vector<struct Version_expression_list*> expression_lists_;
191 std::vector<struct Version_tree*> version_trees_;
192};
193
494e05f4
ILT
194// This class manages assignments to symbols. These can appear in
195// three different locations in scripts: outside of a SECTIONS clause,
196// within a SECTIONS clause, and within an output section definition
197// within a SECTIONS clause. This can also appear on the command line
198// via the --defsym command line option.
199
200class Symbol_assignment
201{
202 public:
99fff23b
ILT
203 Symbol_assignment(const char* name, size_t namelen, bool is_defsym,
204 Expression* val, bool provide, bool hidden)
205 : name_(name, namelen), val_(val), is_defsym_(is_defsym),
206 provide_(provide), hidden_(hidden), sym_(NULL)
494e05f4
ILT
207 { }
208
209 // Add the symbol to the symbol table.
210 void
9b07f471 211 add_to_table(Symbol_table*);
494e05f4
ILT
212
213 // Finalize the symbol value.
a445fddf
ILT
214 void
215 finalize(Symbol_table*, const Layout*);
216
217 // Finalize the symbol value when it can refer to the dot symbol.
218 void
77e65537
ILT
219 finalize_with_dot(Symbol_table*, const Layout*, uint64_t dot_value,
220 Output_section* dot_section);
a445fddf
ILT
221
222 // Set the symbol value, but only if the value is absolute. This is
77e65537 223 // used while processing a SECTIONS clause. We assume that dot is
919ed24c 224 // an absolute value here. We do not check assertions.
a445fddf
ILT
225 void
226 set_if_absolute(Symbol_table*, const Layout*, bool is_dot_available,
77e65537 227 uint64_t dot_value);
494e05f4
ILT
228
229 // Print the assignment to the FILE. This is for debugging.
230 void
231 print(FILE*) const;
232
233 private:
a445fddf
ILT
234 // Shared by finalize and finalize_with_dot.
235 void
236 finalize_maybe_dot(Symbol_table*, const Layout*, bool is_dot_available,
77e65537 237 uint64_t dot_value, Output_section* dot_section);
a445fddf 238
494e05f4
ILT
239 // Sized version of finalize.
240 template<int size>
241 void
a445fddf 242 sized_finalize(Symbol_table*, const Layout*, bool is_dot_available,
77e65537 243 uint64_t dot_value, Output_section*);
494e05f4
ILT
244
245 // Symbol name.
246 std::string name_;
247 // Expression to assign to symbol.
248 Expression* val_;
99fff23b
ILT
249 // True if this symbol is defined by a --defsym, false if it is
250 // defined in a linker script.
251 bool is_defsym_;
494e05f4
ILT
252 // Whether the assignment should be provided (only set if there is
253 // an undefined reference to the symbol.
254 bool provide_;
255 // Whether the assignment should be hidden.
256 bool hidden_;
257 // The entry in the symbol table.
258 Symbol* sym_;
259};
260
261// This class manages assertions in linker scripts. These can appear
262// in all the places where a Symbol_assignment can appear.
263
264class Script_assertion
265{
266 public:
2ea97941 267 Script_assertion(Expression* check, const char* message,
494e05f4 268 size_t messagelen)
2ea97941 269 : check_(check), message_(message, messagelen)
494e05f4
ILT
270 { }
271
272 // Check the assertion.
273 void
274 check(const Symbol_table*, const Layout*);
275
276 // Print the assertion to the FILE. This is for debugging.
277 void
278 print(FILE*) const;
279
280 private:
281 // The expression to check.
282 Expression* check_;
283 // The message to issue if the expression fails.
284 std::string message_;
285};
286
e5756efb
ILT
287// We can read a linker script in two different contexts: when
288// initially parsing the command line, and when we find an input file
289// which is actually a linker script. Also some of the data which can
290// be set by a linker script can also be set via command line options
291// like -e and --defsym. This means that we have a type of data which
292// can be set both during command line option parsing and while
293// reading input files. We store that data in an instance of this
294// object. We will keep pointers to that instance in both the
295// Command_line and Layout objects.
296
297class Script_options
298{
299 public:
300 Script_options();
301
494e05f4 302 // Add a symbol to be defined.
e5756efb 303 void
99fff23b
ILT
304 add_symbol_assignment(const char* name, size_t length, bool is_defsym,
305 Expression* value, bool provide, bool hidden);
494e05f4
ILT
306
307 // Add an assertion.
308 void
309 add_assertion(Expression* check, const char* message, size_t messagelen);
e5756efb
ILT
310
311 // Define a symbol from the command line.
312 bool
313 define_symbol(const char* definition);
314
919ed24c
ILT
315 // Create sections required by any linker scripts.
316 void
317 create_script_sections(Layout*);
318
e5756efb
ILT
319 // Add all symbol definitions to the symbol table.
320 void
9b07f471 321 add_symbols_to_table(Symbol_table*);
e5756efb 322
a445fddf 323 // Finalize the symbol values. Also check assertions.
e5756efb
ILT
324 void
325 finalize_symbols(Symbol_table*, const Layout*);
326
09124467
ILT
327 // Version information parsed from a version script. Everything
328 // else has a pointer to this object.
329 Version_script_info*
330 version_script_info()
494e05f4 331 { return &this->version_script_info_; }
09124467 332
a5dc0706
ILT
333 const Version_script_info*
334 version_script_info() const
335 { return &this->version_script_info_; }
336
494e05f4
ILT
337 // A SECTIONS clause parsed from a linker script. Everything else
338 // has a pointer to this object.
339 Script_sections*
340 script_sections()
341 { return &this->script_sections_; }
e5756efb 342
8f2eb564
ILT
343 const Script_sections*
344 script_sections() const
345 { return &this->script_sections_; }
346
a445fddf
ILT
347 // Whether we saw a SECTIONS clause.
348 bool
349 saw_sections_clause() const
350 { return this->script_sections_.saw_sections_clause(); }
351
1c4f3631
ILT
352 // Whether we saw a PHDRS clause.
353 bool
354 saw_phdrs_clause() const
355 { return this->script_sections_.saw_phdrs_clause(); }
356
a445fddf
ILT
357 // Set section addresses using a SECTIONS clause. Return the
358 // segment which should hold the file header and segment headers;
359 // this may return NULL, in which case the headers are not in a
360 // loadable segment.
361 Output_segment*
362 set_section_addresses(Symbol_table*, Layout*);
363
494e05f4 364 // Print the script to the FILE. This is for debugging.
e5756efb 365 void
494e05f4
ILT
366 print(FILE*) const;
367
368 private:
369 // We keep a list of symbol assignments which occur outside of a
370 // SECTIONS clause.
371 typedef std::vector<Symbol_assignment*> Symbol_assignments;
372
373 // We keep a list of all assertions whcih occur outside of a
374 // SECTIONS clause.
375 typedef std::vector<Script_assertion*> Assertions;
e5756efb
ILT
376
377 // The entry address. This will be empty if not set.
378 std::string entry_;
379 // Symbols to set.
380 Symbol_assignments symbol_assignments_;
494e05f4
ILT
381 // Assertions to check.
382 Assertions assertions_;
09124467
ILT
383 // Version information parsed from a version script.
384 Version_script_info version_script_info_;
494e05f4
ILT
385 // Information from any SECTIONS clauses.
386 Script_sections script_sections_;
e5756efb
ILT
387};
388
072fe7ce
ILT
389// Information about a script input that will persist during the whole linker
390// run. Needed only during an incremental build to retrieve the input files
391// added by this script.
392
393class Script_info
394{
395 public:
2ea97941
ILT
396 Script_info(Input_arguments* inputs)
397 : inputs_(inputs)
072fe7ce
ILT
398 { }
399
400 // Returns the input files included because of this script.
401 Input_arguments*
402 inputs()
98fa85cb 403 { return this->inputs_; }
072fe7ce
ILT
404
405 private:
406 Input_arguments* inputs_;
407};
408
dbe717ef 409// FILE was found as an argument on the command line, but was not
da769d56
ILT
410// recognized as an ELF file. Try to read it as a script. Return
411// true if the file was handled. This has to handle /usr/lib/libc.so
412// on a GNU/Linux system. *USED_NEXT_BLOCKER is set to indicate
413// whether the function took over NEXT_BLOCKER.
dbe717ef
ILT
414
415bool
15f8229b 416read_input_script(Workqueue*, Symbol_table*, Layout*, Dirsearch*, int,
f1ed28fb 417 Input_objects*, Mapfile*, Input_group*,
da769d56
ILT
418 const Input_argument*, Input_file*,
419 Task_token* next_blocker, bool* used_next_blocker);
dbe717ef 420
3c2fafa5
ILT
421// FILE was found as an argument to --script (-T).
422// Read it as a script, and execute its contents immediately.
423
424bool
c82fbeee 425read_commandline_script(const char* filename, Command_line* cmdline);
3c2fafa5 426
09124467
ILT
427// FILE was found as an argument to --version-script. Read it as a
428// version script, and store its contents in
429// cmdline->script_options()->version_script_info().
430
431bool
432read_version_script(const char* filename, Command_line* cmdline);
433
c82fbeee
CS
434// FILENAME was found as an argument to --dynamic-list. Read it as a
435// version script (actually, a versym_node from a version script), and
436// store its contents in DYNAMIC_LIST.
437
438bool
439read_dynamic_list(const char* filename, Command_line* cmdline,
440 Script_options* dynamic_list);
441
dbe717ef
ILT
442} // End namespace gold.
443
444#endif // !defined(GOLD_SCRIPT_H)
This page took 0.186668 seconds and 4 git commands to generate.