1 // script-sections.h -- linker script SECTIONS for gold -*- C++ -*- 2 3 // Copyright (C) 2008-2016 Free Software Foundation, Inc. 4 // Written by Ian Lance Taylor <iant (at) 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 const char* 168 output_section_name(const char* file_name, const char* section_name, 169 Output_section*** output_section_slot, 170 Section_type* pscript_section_type, 171 bool* keep); 172 173 // Place a marker for an orphan output section into the SECTIONS 174 // clause. 175 void 176 place_orphan(Output_section* os); 177 178 // Set the addresses of all the output sections. Return the segment 179 // which holds the file header and segment headers, if any. 180 Output_segment* 181 set_section_addresses(Symbol_table*, Layout*); 182 183 // Add a program header definition. 184 void 185 add_phdr(const char* name, size_t namelen, unsigned int type, 186 bool filehdr, bool phdrs, bool is_flags_valid, unsigned int flags, 187 Expression* load_address); 188 189 // Return the number of segments we expect to create based on the 190 // SECTIONS clause. 191 size_t 192 expected_segment_count(const Layout*) const; 193 194 // Add the file header and segment header to non-load segments as 195 // specified by the PHDRS clause. 196 void 197 put_headers_in_phdrs(Output_data* file_header, Output_data* segment_headers); 198 199 // Look for an output section by name and return the address, the 200 // load address, the alignment, and the size. This is used when an 201 // expression refers to an output section which was not actually 202 // created. This returns true if the section was found, false 203 // otherwise. 204 bool 205 get_output_section_info(const char* name, uint64_t* address, 206 uint64_t* load_address, uint64_t* addralign, 207 uint64_t* size) const; 208 209 // Release all Output_segments. This is used in relaxation. 210 void 211 release_segments(); 212 213 // Whether we ever saw a SEGMENT_START expression, the presence of which 214 // changes the behaviour of -Ttext, -Tdata and -Tbss options. 215 bool 216 saw_segment_start_expression() const 217 { return this->saw_segment_start_expression_; } 218 219 // Set the flag which indicates whether we saw a SEGMENT_START expression. 220 void 221 set_saw_segment_start_expression(bool value) 222 { this->saw_segment_start_expression_ = value; } 223 224 // Add a memory region. 225 void 226 add_memory_region(const char*, size_t, unsigned int, 227 Expression*, Expression*); 228 229 // Find a memory region's origin. 230 Expression* 231 find_memory_region_origin(const char*, size_t); 232 233 // Find a memory region's length. 234 Expression* 235 find_memory_region_length(const char*, size_t); 236 237 // Find a memory region by name. 238 Memory_region* 239 find_memory_region(const char*, size_t); 240 241 // Find a memory region that should be used by a given output section. 242 Memory_region* 243 find_memory_region(Output_section_definition*, bool, bool, 244 Output_section_definition**); 245 246 // Returns true if the provide block of memory is contained 247 // within a memory region. 248 bool 249 block_in_region(Symbol_table*, Layout*, uint64_t, uint64_t) const; 250 251 // Set the memory region of the section. 252 void 253 set_memory_region(Memory_region*, bool); 254 255 // Print the contents to the FILE. This is for debugging. 256 void 257 print(FILE*) const; 258 259 // Used for orphan sections. 260 typedef Sections_elements::iterator Elements_iterator; 261 262 private: 263 typedef std::vector<Memory_region*> Memory_regions; 264 typedef std::vector<Phdrs_element*> Phdrs_elements; 265 266 // Create segments. 267 Output_segment* 268 create_segments(Layout*, uint64_t); 269 270 // Create PT_NOTE and PT_TLS segments. 271 void 272 create_note_and_tls_segments(Layout*, const std::vector<Output_section*>*); 273 274 // Return whether the section is a BSS section. 275 static bool 276 is_bss_section(const Output_section*); 277 278 // Return the total size of the headers. 279 size_t 280 total_header_size(Layout* layout) const; 281 282 // Return the amount we have to subtract from the LMA to accomodate 283 // headers of the given size. 284 uint64_t 285 header_size_adjustment(uint64_t lma, size_t sizeof_headers) const; 286 287 // Create the segments from a PHDRS clause. 288 Output_segment* 289 create_segments_from_phdrs_clause(Layout* layout, uint64_t); 290 291 // Attach sections to segments from a PHDRS clause. 292 void 293 attach_sections_using_phdrs_clause(Layout*); 294 295 // Set addresses of segments from a PHDRS clause. 296 Output_segment* 297 set_phdrs_clause_addresses(Layout*, uint64_t); 298 299 // True if we ever saw a SECTIONS clause. 300 bool saw_sections_clause_; 301 // True if we are currently processing a SECTIONS clause. 302 bool in_sections_clause_; 303 // The list of elements in the SECTIONS clause. 304 Sections_elements* sections_elements_; 305 // The current output section, if there is one. 306 Output_section_definition* output_section_; 307 // The list of memory regions in the MEMORY clause. 308 Memory_regions* memory_regions_; 309 // The list of program headers in the PHDRS clause. 310 Phdrs_elements* phdrs_elements_; 311 // Where to put orphan sections. 312 Orphan_section_placement* orphan_section_placement_; 313 // A pointer to the last Sections_element when we see 314 // DATA_SEGMENT_ALIGN. 315 Sections_elements::iterator data_segment_align_start_; 316 // Whether we have seen DATA_SEGMENT_ALIGN. 317 bool saw_data_segment_align_; 318 // Whether we have seen DATA_SEGMENT_RELRO_END. 319 bool saw_relro_end_; 320 // Whether we have seen SEGMENT_START. 321 bool saw_segment_start_expression_; 322 // Whether we have created all necessary segments. 323 bool segments_created_; 324 }; 325 326 // Attributes for memory regions. 327 enum 328 { 329 MEM_EXECUTABLE = (1 << 0), 330 MEM_WRITEABLE = (1 << 1), 331 MEM_READABLE = (1 << 2), 332 MEM_ALLOCATABLE = (1 << 3), 333 MEM_INITIALIZED = (1 << 4), 334 MEM_ATTR_MASK = (1 << 5) - 1 335 }; 336 337 } // End namespace gold. 338 339 #endif // !defined(GOLD_SCRIPT_SECTIONS_H 340
