1 // script.h -- handle linker scripts for gold -*- C++ -*-
3 // Copyright 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
4 // Written by Ian Lance Taylor <iant@google.com>.
6 // This file is part of gold.
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.
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.
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.
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.
37 #include "script-sections.h"
42 class General_options
;
48 class Input_arguments
;
55 struct Version_dependency_list
;
56 struct Version_expression_list
;
59 // This class represents an expression in a linker script.
64 // These should only be created by child classes.
72 // Return the value of the expression which is not permitted to
73 // refer to the dot symbol. CHECK_ASSERTIONS is true if we should
74 // check whether assertions are true.
76 eval(const Symbol_table
*, const Layout
*, bool check_assertions
);
78 // Return the value of an expression which is permitted to refer to
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.
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
);
93 // Return the value of an expression which may or may not be
94 // permitted to refer to the dot symbol, depending on
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
,
100 Output_section
** result_section
);
102 // Print the expression to the FILE. This is for debugging.
104 print(FILE*) const = 0;
107 struct Expression_eval_info
;
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.
114 value(const Expression_eval_info
*) = 0;
117 // May not be copied.
118 Expression(const Expression
&);
119 Expression
& operator=(const Expression
&);
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
128 class Version_script_info
131 // The languages which can be specified in a versionn script.
134 LANGUAGE_C
, // No demangling.
135 LANGUAGE_CXX
, // C++ demangling.
136 LANGUAGE_JAVA
, // Java demangling.
140 Version_script_info();
142 ~Version_script_info();
148 // Finalize the version control information.
152 // Return whether the information is finalized.
155 { return this->is_finalized_
; }
157 // Return whether any version were defined in the version script.
160 { return this->version_trees_
.empty(); }
162 // If there is a version associated with SYMBOL, return true, and
163 // set *VERSION to the version. Otherwise, return false.
165 get_symbol_version(const char* symbol
, std::string
* version
) const
166 { return this->get_symbol_version_helper(symbol
, true, version
); }
168 // Return whether this symbol matches the local: section of some
171 symbol_is_local(const char* symbol
) const
172 { return this->get_symbol_version_helper(symbol
, false, NULL
); }
174 // Return the names of versions defined in the version script.
175 std::vector
<std::string
>
176 get_versions() const;
178 // Return the list of dependencies for this version.
179 std::vector
<std::string
>
180 get_dependencies(const char* version
) const;
182 // The following functions should only be used by the bison helper
183 // functions. They allocate new structs whose memory belongs to
184 // Version_script_info. The bison functions copy the information
185 // from the version script into these structs.
186 struct Version_dependency_list
*
187 allocate_dependency_list();
189 struct Version_expression_list
*
190 allocate_expression_list();
193 allocate_version_tree();
195 // Build the lookup tables after all data have been read.
197 build_lookup_tables();
199 // Give an error if there are any unmatched names in the version
202 check_unmatched_names(const Symbol_table
*) const;
204 // Print contents to the FILE. This is for debugging.
210 print_expression_list(FILE* f
, const Version_expression_list
*) const;
213 get_symbol_version_helper(const char* symbol
,
215 std::string
* pversion
) const;
218 matched_symbol(const Version_tree
*, const char*) const;
220 // Fast lookup information for a glob pattern.
224 : pattern(NULL
), version(NULL
)
227 Glob(const char* p
, const Version_tree
* v
)
228 : pattern(p
), version(v
)
231 // A pointer to the glob pattern. The pattern itself lives in a
232 // Version_expression structure.
234 // The Version_tree we use if this pattern matches.
235 const Version_tree
* version
;
238 // Fast lookup information for a given language.
240 typedef Unordered_map
<std::string
, const Version_tree
*> Exact
;
244 // A hash table of all exact match strings mapping to a
247 // A vector of glob patterns mapping to Version_trees.
248 std::vector
<Glob
> globs
;
252 build_expression_list_lookup(const Version_expression_list
*,
253 const Version_tree
*, Lookup
**);
255 // All the version dependencies we allocate.
256 std::vector
<Version_dependency_list
*> dependency_lists_
;
257 // All the version expressions we allocate.
258 std::vector
<Version_expression_list
*> expression_lists_
;
259 // The list of versions.
260 std::vector
<Version_tree
*> version_trees_
;
261 // Lookup information for global symbols, by language.
262 Lookup
* globals_
[LANGUAGE_COUNT
];
263 // Lookup information for local symbols, by language.
264 Lookup
* locals_
[LANGUAGE_COUNT
];
265 // Whether this has been finalized.
269 // This class manages assignments to symbols. These can appear in
270 // three different locations in scripts: outside of a SECTIONS clause,
271 // within a SECTIONS clause, and within an output section definition
272 // within a SECTIONS clause. This can also appear on the command line
273 // via the --defsym command line option.
275 class Symbol_assignment
278 Symbol_assignment(const char* name
, size_t namelen
, bool is_defsym
,
279 Expression
* val
, bool provide
, bool hidden
)
280 : name_(name
, namelen
), val_(val
), is_defsym_(is_defsym
),
281 provide_(provide
), hidden_(hidden
), sym_(NULL
)
284 // Add the symbol to the symbol table.
286 add_to_table(Symbol_table
*);
288 // Finalize the symbol value.
290 finalize(Symbol_table
*, const Layout
*);
292 // Finalize the symbol value when it can refer to the dot symbol.
294 finalize_with_dot(Symbol_table
*, const Layout
*, uint64_t dot_value
,
295 Output_section
* dot_section
);
297 // Set the symbol value, but only if the value is absolute. This is
298 // used while processing a SECTIONS clause. We assume that dot is
299 // an absolute value here. We do not check assertions.
301 set_if_absolute(Symbol_table
*, const Layout
*, bool is_dot_available
,
304 // Print the assignment to the FILE. This is for debugging.
309 // Shared by finalize and finalize_with_dot.
311 finalize_maybe_dot(Symbol_table
*, const Layout
*, bool is_dot_available
,
312 uint64_t dot_value
, Output_section
* dot_section
);
314 // Sized version of finalize.
317 sized_finalize(Symbol_table
*, const Layout
*, bool is_dot_available
,
318 uint64_t dot_value
, Output_section
*);
322 // Expression to assign to symbol.
324 // True if this symbol is defined by a --defsym, false if it is
325 // defined in a linker script.
327 // Whether the assignment should be provided (only set if there is
328 // an undefined reference to the symbol.
330 // Whether the assignment should be hidden.
332 // The entry in the symbol table.
336 // This class manages assertions in linker scripts. These can appear
337 // in all the places where a Symbol_assignment can appear.
339 class Script_assertion
342 Script_assertion(Expression
* check
, const char* message
,
344 : check_(check
), message_(message
, messagelen
)
347 // Check the assertion.
349 check(const Symbol_table
*, const Layout
*);
351 // Print the assertion to the FILE. This is for debugging.
356 // The expression to check.
358 // The message to issue if the expression fails.
359 std::string message_
;
362 // We can read a linker script in two different contexts: when
363 // initially parsing the command line, and when we find an input file
364 // which is actually a linker script. Also some of the data which can
365 // be set by a linker script can also be set via command line options
366 // like -e and --defsym. This means that we have a type of data which
367 // can be set both during command line option parsing and while
368 // reading input files. We store that data in an instance of this
369 // object. We will keep pointers to that instance in both the
370 // Command_line and Layout objects.
377 // Add a symbol to be defined.
379 add_symbol_assignment(const char* name
, size_t length
, bool is_defsym
,
380 Expression
* value
, bool provide
, bool hidden
);
384 add_assertion(Expression
* check
, const char* message
, size_t messagelen
);
386 // Define a symbol from the command line.
388 define_symbol(const char* definition
);
390 // Create sections required by any linker scripts.
392 create_script_sections(Layout
*);
394 // Add all symbol definitions to the symbol table.
396 add_symbols_to_table(Symbol_table
*);
398 // Finalize the symbol values. Also check assertions.
400 finalize_symbols(Symbol_table
*, const Layout
*);
402 // Version information parsed from a version script. Everything
403 // else has a pointer to this object.
405 version_script_info()
406 { return &this->version_script_info_
; }
408 const Version_script_info
*
409 version_script_info() const
410 { return &this->version_script_info_
; }
412 // A SECTIONS clause parsed from a linker script. Everything else
413 // has a pointer to this object.
416 { return &this->script_sections_
; }
418 const Script_sections
*
419 script_sections() const
420 { return &this->script_sections_
; }
422 // Whether we saw a SECTIONS clause.
424 saw_sections_clause() const
425 { return this->script_sections_
.saw_sections_clause(); }
427 // Whether we saw a PHDRS clause.
429 saw_phdrs_clause() const
430 { return this->script_sections_
.saw_phdrs_clause(); }
432 // Set section addresses using a SECTIONS clause. Return the
433 // segment which should hold the file header and segment headers;
434 // this may return NULL, in which case the headers are not in a
437 set_section_addresses(Symbol_table
*, Layout
*);
439 // Print the script to the FILE. This is for debugging.
444 // We keep a list of symbol assignments which occur outside of a
446 typedef std::vector
<Symbol_assignment
*> Symbol_assignments
;
448 // We keep a list of all assertions whcih occur outside of a
450 typedef std::vector
<Script_assertion
*> Assertions
;
452 // The entry address. This will be empty if not set.
455 Symbol_assignments symbol_assignments_
;
456 // Assertions to check.
457 Assertions assertions_
;
458 // Version information parsed from a version script.
459 Version_script_info version_script_info_
;
460 // Information from any SECTIONS clauses.
461 Script_sections script_sections_
;
464 // Information about a script input that will persist during the whole linker
465 // run. Needed only during an incremental build to retrieve the input files
466 // added by this script.
471 Script_info(Input_arguments
* inputs
)
475 // Returns the input files included because of this script.
478 { return this->inputs_
; }
481 Input_arguments
* inputs_
;
484 // FILE was found as an argument on the command line, but was not
485 // recognized as an ELF file. Try to read it as a script. Return
486 // true if the file was handled. This has to handle /usr/lib/libc.so
487 // on a GNU/Linux system. *USED_NEXT_BLOCKER is set to indicate
488 // whether the function took over NEXT_BLOCKER.
491 read_input_script(Workqueue
*, Symbol_table
*, Layout
*, Dirsearch
*, int,
492 Input_objects
*, Mapfile
*, Input_group
*,
493 const Input_argument
*, Input_file
*,
494 Task_token
* next_blocker
, bool* used_next_blocker
);
496 // FILE was found as an argument to --script (-T).
497 // Read it as a script, and execute its contents immediately.
500 read_commandline_script(const char* filename
, Command_line
* cmdline
);
502 // FILE was found as an argument to --version-script. Read it as a
503 // version script, and store its contents in
504 // cmdline->script_options()->version_script_info().
507 read_version_script(const char* filename
, Command_line
* cmdline
);
509 // FILENAME was found as an argument to --dynamic-list. Read it as a
510 // version script (actually, a versym_node from a version script), and
511 // store its contents in DYNAMIC_LIST.
514 read_dynamic_list(const char* filename
, Command_line
* cmdline
,
515 Script_options
* dynamic_list
);
517 } // End namespace gold.
519 #endif // !defined(GOLD_SCRIPT_H)