1 // script-sections.h -- linker script SECTIONS for gold -*- C++ -*-
2
3 // Copyright (C) 2008-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 // This is for the support of the SECTIONS clause in linker scripts.
24
25 #ifndef GOLD_SCRIPT_SECTIONS_H
26 #define GOLD_SCRIPT_SECTIONS_H
27
28 #include <cstdio>
29 #include <list>
30 #include <vector>
31
32 namespace gold
33 {
34
35 struct Parser_output_section_header;
36 struct Parser_output_section_trailer;
37 struct Input_section_spec;
38 class Expression;
39 class Sections_element;
40 class Memory_region;
41 class Phdrs_element;
42 class Output_data;
43 class Output_section_definition;
44 class Output_section;
45 class Output_segment;
46 class Orphan_section_placement;
47
48 class Script_sections
49 {
50 public:
51 // This is a list, not a vector, because we insert orphan sections
52 // in the middle.
53 typedef std::list<Sections_element*> Sections_elements;
54
55 // Logical script section types. We map section types returned by the
56 // parser into these since some section types have the same semantics.
57 enum Section_type
58 {
59 // No section type specified.
60 ST_NONE,
61 // Section is NOLOAD. We allocate space in the output but section
62 // is not loaded in runtime.
63 ST_NOLOAD,
64 // No space is allocated to section.
65 ST_NOALLOC
66 };
67
68 Script_sections();
69
70 // Start a SECTIONS clause.
71 void
72 start_sections();
73
74 // Finish a SECTIONS clause.
75 void
76 finish_sections();
77
78 // Return whether we ever saw a SECTIONS clause. If we did, then
79 // all section layout needs to go through this class.
80 bool
81 saw_sections_clause() const
82 { return this->saw_sections_clause_; }
83
84 // Return whether we are currently processing a SECTIONS clause.
85 bool
86 in_sections_clause() const
87 { return this->in_sections_clause_; }
88
89 // Return whether we ever saw a PHDRS clause. We ignore the PHDRS
90 // clause unless we also saw a SECTIONS clause.
91 bool
92 saw_phdrs_clause() const
93 { return this->saw_sections_clause_ && this->phdrs_elements_ != NULL; }
94
95 // Start processing entries for an output section.
96 void
97 start_output_section(const char* name, size_t namelen,
98 const Parser_output_section_header*);
99
100 // Finish processing entries for an output section.
101 void
102 finish_output_section(const Parser_output_section_trailer*);
103
104 // Add a data item to the current output section.
105 void
106 add_data(int size, bool is_signed, Expression* val);
107
108 // Add a symbol to be defined.
109 void
110 add_symbol_assignment(const char* name, size_t length, Expression* value,
111 bool provide, bool hidden);
112
113 // Add an assignment to the special dot symbol.
114 void
115 add_dot_assignment(Expression* value);
116
117 // Add an assertion.
118 void
119 add_assertion(Expression* check, const char* message, size_t messagelen);
120
121 // Add a setting for the fill value.
122 void
123 add_fill(Expression* val);
124
125 // Add an input section specification.
126 void
127 add_input_section(const Input_section_spec* spec, bool keep);
128
129 // Saw DATA_SEGMENT_ALIGN.
130 void
131 data_segment_align();
132
133 // Saw DATA_SEGMENT_RELRO_END.
134 void
135 data_segment_relro_end();
136
137 // Create any required sections.
138 void
139 create_sections(Layout*);
140
141 // Add any symbols we are defining to the symbol table.
142 void
143 add_symbols_to_table(Symbol_table*);
144
145 // Finalize symbol values and check assertions.
146 void
147 finalize_symbols(Symbol_table* symtab, const Layout* layout);
148
149 // Find the name of the output section to use for an input file name
150 // and section name. This returns a name, and sets
151 // *OUTPUT_SECTION_SLOT to point to the address where the actual
152 // output section may be stored.
153 // 1) If the input section should be discarded, this returns NULL
154 // and sets *OUTPUT_SECTION_SLOT to NULL.
155 // 2) If the input section is mapped by the SECTIONS clause, this
156 // returns the name to use for the output section (in permanent
157 // storage), and sets *OUTPUT_SECTION_SLOT to point to where the
158 // output section should be stored. **OUTPUT_SECTION_SLOT will be
159 // non-NULL if we have seen this output section already.
160 // 3) If the input section is not mapped by the SECTIONS clause,
161 // this returns SECTION_NAME, and sets *OUTPUT_SECTION_SLOT to
162 // NULL.
163 // PSCRIPT_SECTION_TYPE points to a location for returning the section
164 // type specified in script. This can be SCRIPT_SECTION_TYPE_NONE if
165 // no type is specified.
166 // *KEEP indicates whether the section should survive garbage collection.
167 // MATCH_INPUT_SPEC indicates whether the section should be matched
168 // with input section specs or simply against the output section name
169 // (i.e., for linker-created sections like .dynamic).
170 const char*
171 output_section_name(const char* file_name, const char* section_name,
172 Output_section*** output_section_slot,
173 Section_type* pscript_section_type,
174 bool* keep, bool match_input_spec);
175
176 // Place a marker for an orphan output section into the SECTIONS
177 // clause.
178 void
179 place_orphan(Output_section* os);
180
181 // Set the addresses of all the output sections. Return the segment
182 // which holds the file header and segment headers, if any.
183 Output_segment*
184 set_section_addresses(Symbol_table*, Layout*);
185
186 // Add a program header definition.
187 void
188 add_phdr(const char* name, size_t namelen, unsigned int type,
189 bool filehdr, bool phdrs, bool is_flags_valid, unsigned int flags,
190 Expression* load_address);
191
192 // Return the number of segments we expect to create based on the
193 // SECTIONS clause.
194 size_t
195 expected_segment_count(const Layout*) const;
196
197 // Add the file header and segment header to non-load segments as
198 // specified by the PHDRS clause.
199 void
200 put_headers_in_phdrs(Output_data* file_header, Output_data* segment_headers);
201
202 // Look for an output section by name and return the address, the
203 // load address, the alignment, and the size. This is used when an
204 // expression refers to an output section which was not actually
205 // created. This returns true if the section was found, false
206 // otherwise.
207 bool
208 get_output_section_info(const char* name, uint64_t* address,
209 uint64_t* load_address, uint64_t* addralign,
210 uint64_t* size) const;
211
212 // Release all Output_segments. This is used in relaxation.
213 void
214 release_segments();
215
216 // Whether we ever saw a SEGMENT_START expression, the presence of which
217 // changes the behaviour of -Ttext, -Tdata and -Tbss options.
218 bool
219 saw_segment_start_expression() const
220 { return this->saw_segment_start_expression_; }
221
222 // Set the flag which indicates whether we saw a SEGMENT_START expression.
223 void
224 set_saw_segment_start_expression(bool value)
225 { this->saw_segment_start_expression_ = value; }
226
227 // Add a memory region.
228 void
229 add_memory_region(const char*, size_t, unsigned int,
230 Expression*, Expression*);
231
232 // Find a memory region's origin.
233 Expression*
234 find_memory_region_origin(const char*, size_t);
235
236 // Find a memory region's length.
237 Expression*
238 find_memory_region_length(const char*, size_t);
239
240 // Find a memory region by name.
241 Memory_region*
242 find_memory_region(const char*, size_t);
243
244 // Find a memory region that should be used by a given output section.
245 Memory_region*
246 find_memory_region(Output_section_definition*, bool, bool,
247 Output_section_definition**);
248
249 // Returns true if the provide block of memory is contained
250 // within a memory region.
251 bool
252 block_in_region(Symbol_table*, Layout*, uint64_t, uint64_t) const;
253
254 // Set the memory region of the section.
255 void
256 set_memory_region(Memory_region*, bool);
257
258 // Print the contents to the FILE. This is for debugging.
259 void
260 print(FILE*) const;
261
262 // Used for orphan sections.
263 typedef Sections_elements::iterator Elements_iterator;
264
265 private:
266 typedef std::vector<Memory_region*> Memory_regions;
267 typedef std::vector<Phdrs_element*> Phdrs_elements;
268
269 // Create segments.
270 Output_segment*
271 create_segments(Layout*, uint64_t);
272
273 // Create PT_NOTE and PT_TLS segments.
274 void
275 create_note_and_tls_segments(Layout*, const std::vector<Output_section*>*);
276
277 // Return whether the section is a BSS section.
278 static bool
279 is_bss_section(const Output_section*);
280
281 // Return the total size of the headers.
282 size_t
283 total_header_size(Layout* layout) const;
284
285 // Return the amount we have to subtract from the LMA to accommodate
286 // headers of the given size.
287 uint64_t
288 header_size_adjustment(uint64_t lma, size_t sizeof_headers) const;
289
290 // Create the segments from a PHDRS clause.
291 Output_segment*
292 create_segments_from_phdrs_clause(Layout* layout, uint64_t);
293
294 // Attach sections to segments from a PHDRS clause.
295 void
296 attach_sections_using_phdrs_clause(Layout*);
297
298 // Set addresses of segments from a PHDRS clause.
299 Output_segment*
300 set_phdrs_clause_addresses(Layout*, uint64_t);
301
302 // True if we ever saw a SECTIONS clause.
303 bool saw_sections_clause_;
304 // True if we are currently processing a SECTIONS clause.
305 bool in_sections_clause_;
306 // The list of elements in the SECTIONS clause.
307 Sections_elements* sections_elements_;
308 // The current output section, if there is one.
309 Output_section_definition* output_section_;
310 // The list of memory regions in the MEMORY clause.
311 Memory_regions* memory_regions_;
312 // The list of program headers in the PHDRS clause.
313 Phdrs_elements* phdrs_elements_;
314 // Where to put orphan sections.
315 Orphan_section_placement* orphan_section_placement_;
316 // A pointer to the last Sections_element when we see
317 // DATA_SEGMENT_ALIGN.
318 Sections_elements::iterator data_segment_align_start_;
319 // Whether we have seen DATA_SEGMENT_ALIGN.
320 bool saw_data_segment_align_;
321 // Whether we have seen DATA_SEGMENT_RELRO_END.
322 bool saw_relro_end_;
323 // Whether we have seen SEGMENT_START.
324 bool saw_segment_start_expression_;
325 // Whether we have created all necessary segments.
326 bool segments_created_;
327 };
328
329 // Attributes for memory regions.
330 enum
331 {
332 MEM_EXECUTABLE = (1 << 0),
333 MEM_WRITEABLE = (1 << 1),
334 MEM_READABLE = (1 << 2),
335 MEM_ALLOCATABLE = (1 << 3),
336 MEM_INITIALIZED = (1 << 4),
337 MEM_ATTR_MASK = (1 << 5) - 1
338 };
339
340 } // End namespace gold.
341
342 #endif // !defined(GOLD_SCRIPT_SECTIONS_H