1 // layout.h -- lay out output file sections for gold -*- C++ -*-
3 // Copyright 2006, 2007 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.
31 #include "workqueue.h"
34 #include "stringpool.h"
39 class General_options
;
42 class Output_section_data
;
44 class Output_section_headers
;
47 class Output_data_dynamic
;
51 // This task function handles mapping the input sections to output
52 // sections and laying them out in memory.
54 class Layout_task_runner
: public Task_function_runner
57 // OPTIONS is the command line options, INPUT_OBJECTS is the list of
58 // input objects, SYMTAB is the symbol table, LAYOUT is the layout
60 Layout_task_runner(const General_options
& options
,
61 const Input_objects
* input_objects
,
64 : options_(options
), input_objects_(input_objects
), symtab_(symtab
),
70 run(Workqueue
*, const Task
*);
73 Layout_task_runner(const Layout_task_runner
&);
74 Layout_task_runner
& operator=(const Layout_task_runner
&);
76 const General_options
& options_
;
77 const Input_objects
* input_objects_
;
78 Symbol_table
* symtab_
;
82 // This class handles the details of laying out input sections.
87 Layout(const General_options
& options
);
89 // Given an input section SHNDX, named NAME, with data in SHDR, from
90 // the object file OBJECT, return the output section where this
91 // input section should go. RELOC_SHNDX is the index of a
92 // relocation section which applies to this section, or 0 if none,
93 // or -1U if more than one. RELOC_TYPE is the type of the
94 // relocation section if there is one. Set *OFFSET to the offset
95 // within the output section.
96 template<int size
, bool big_endian
>
98 layout(Sized_relobj
<size
, big_endian
> *object
, unsigned int shndx
,
99 const char* name
, const elfcpp::Shdr
<size
, big_endian
>& shdr
,
100 unsigned int reloc_shndx
, unsigned int reloc_type
, off_t
* offset
);
102 // Like layout, only for exception frame sections. OBJECT is an
103 // object file. SYMBOLS is the contents of the symbol table
104 // section, with size SYMBOLS_SIZE. SYMBOL_NAMES is the contents of
105 // the symbol name section, with size SYMBOL_NAMES_SIZE. SHNDX is a
106 // .eh_frame section in OBJECT. SHDR is the section header.
107 // RELOC_SHNDX is the index of a relocation section which applies to
108 // this section, or 0 if none, or -1U if more than one. RELOC_TYPE
109 // is the type of the relocation section if there is one. This
110 // returns the output section, and sets *OFFSET to the offset.
111 template<int size
, bool big_endian
>
113 layout_eh_frame(Sized_relobj
<size
, big_endian
>* object
,
114 const unsigned char* symbols
,
116 const unsigned char* symbol_names
,
117 off_t symbol_names_size
,
119 const elfcpp::Shdr
<size
, big_endian
>& shdr
,
120 unsigned int reloc_shndx
, unsigned int reloc_type
,
123 // Handle a GNU stack note. This is called once per input object
124 // file. SEEN_GNU_STACK is true if the object file has a
125 // .note.GNU-stack section. GNU_STACK_FLAGS is the section flags
126 // from that section if there was one.
128 layout_gnu_stack(bool seen_gnu_stack
, uint64_t gnu_stack_flags
);
130 // Add an Output_section_data to the layout. This is used for
131 // special sections like the GOT section.
133 add_output_section_data(const char* name
, elfcpp::Elf_Word type
,
134 elfcpp::Elf_Xword flags
,
135 Output_section_data
*);
137 // Create dynamic sections if necessary.
139 create_initial_dynamic_sections(const Input_objects
*, Symbol_table
*);
141 // Define __start and __stop symbols for output sections.
143 define_section_symbols(Symbol_table
*, const Target
*);
145 // Return the Stringpool used for symbol names.
148 { return &this->sympool_
; }
150 // Return the Stringpool used for dynamic symbol names and dynamic
154 { return &this->dynpool_
; }
156 // Return whether a section is a .gnu.linkonce section, given the
159 is_linkonce(const char* name
)
160 { return strncmp(name
, ".gnu.linkonce", sizeof(".gnu.linkonce") - 1) == 0; }
162 // Record the signature of a comdat section, and return whether to
163 // include it in the link. The GROUP parameter is true for a
164 // section group signature, false for a signature derived from a
165 // .gnu.linkonce section.
167 add_comdat(const char*, bool group
);
169 // Finalize the layout after all the input sections have been added.
171 finalize(const Input_objects
*, Symbol_table
*, const Task
*);
173 // Return whether any sections require postprocessing.
175 any_postprocessing_sections() const
176 { return this->any_postprocessing_sections_
; }
178 // Return the size of the output file.
180 output_file_size() const
181 { return this->output_file_size_
; }
183 // Return the TLS segment. This will return NULL if there isn't
187 { return this->tls_segment_
; }
189 // Return the normal symbol table.
191 symtab_section() const
193 gold_assert(this->symtab_section_
!= NULL
);
194 return this->symtab_section_
;
197 // Return the dynamic symbol table.
199 dynsym_section() const
201 gold_assert(this->dynsym_section_
!= NULL
);
202 return this->dynsym_section_
;
205 // Return the dynamic tags.
208 { return this->dynamic_data_
; }
210 // Write out the output sections.
212 write_output_sections(Output_file
* of
) const;
214 // Write out data not associated with an input file or the symbol
217 write_data(const Symbol_table
*, Output_file
*) const;
219 // Write out output sections which can not be written until all the
220 // input sections are complete.
222 write_sections_after_input_sections(Output_file
* of
);
224 // Return an output section named NAME, or NULL if there is none.
226 find_output_section(const char* name
) const;
228 // Return an output segment of type TYPE, with segment flags SET set
229 // and segment flags CLEAR clear. Return NULL if there is none.
231 find_output_segment(elfcpp::PT type
, elfcpp::Elf_Word set
,
232 elfcpp::Elf_Word clear
) const;
234 // Set a flag to indicate that an object file uses the static TLS model.
237 { this->has_static_tls_
= true; }
239 // Return true if any object file uses the static TLS model.
241 has_static_tls() const
242 { return this->has_static_tls_
; }
244 // Dump statistical information to stderr.
248 // The list of segments.
250 typedef std::vector
<Output_segment
*> Segment_list
;
252 // The list of sections not attached to a segment.
254 typedef std::vector
<Output_section
*> Section_list
;
256 // The list of information to write out which is not attached to
257 // either a section or a segment.
258 typedef std::vector
<Output_data
*> Data_list
;
261 Layout(const Layout
&);
262 Layout
& operator=(const Layout
&);
264 // Mapping from .gnu.linkonce section names to output section names.
265 struct Linkonce_mapping
272 static const Linkonce_mapping linkonce_mapping
[];
273 static const int linkonce_mapping_count
;
275 // Create a .note section for gold.
279 // Record whether the stack must be executable.
281 create_executable_stack_info(const Target
*);
283 // Find the first read-only PT_LOAD segment, creating one if
286 find_first_load_seg();
288 // Count the local symbols in the regular symbol table and the dynamic
289 // symbol table, and build the respective string pools.
291 count_local_symbols(const Task
*, const Input_objects
*);
293 // Create the output sections for the symbol table.
295 create_symtab_sections(const Input_objects
*, Symbol_table
*, const Task
*,
298 // Create the .shstrtab section.
302 // Create the section header table.
304 create_shdrs(off_t
*);
306 // Create the dynamic symbol table.
308 create_dynamic_symtab(const Input_objects
*, const Target
*,
309 Symbol_table
*, Output_section
** pdynstr
,
310 unsigned int* plocal_dynamic_count
,
311 std::vector
<Symbol
*>* pdynamic_symbols
,
314 // Assign offsets to each local portion of the dynamic symbol table.
316 assign_local_dynsym_offsets(const Input_objects
*);
318 // Finish the .dynamic section and PT_DYNAMIC segment.
320 finish_dynamic_section(const Input_objects
*, const Symbol_table
*);
322 // Create the .interp section and PT_INTERP segment.
324 create_interp(const Target
* target
);
326 // Create the version sections.
328 create_version_sections(const Versions
*,
330 unsigned int local_symcount
,
331 const std::vector
<Symbol
*>& dynamic_symbols
,
332 const Output_section
* dynstr
);
334 template<int size
, bool big_endian
>
336 sized_create_version_sections(const Versions
* versions
,
338 unsigned int local_symcount
,
339 const std::vector
<Symbol
*>& dynamic_symbols
,
340 const Output_section
* dynstr
343 // Return whether to include this section in the link.
344 template<int size
, bool big_endian
>
346 include_section(Sized_relobj
<size
, big_endian
>* object
, const char* name
,
347 const elfcpp::Shdr
<size
, big_endian
>&);
349 // Return the output section name to use given an input section
350 // name. Set *PLEN to the length of the name. *PLEN must be
351 // initialized to the length of NAME.
353 output_section_name(const char* name
, size_t* plen
);
355 // Return the output section name to use for a linkonce section
356 // name. PLEN is as for output_section_name.
358 linkonce_output_name(const char* name
, size_t* plen
);
360 // Return the output section for NAME, TYPE and FLAGS.
362 get_output_section(const char* name
, Stringpool::Key name_key
,
363 elfcpp::Elf_Word type
, elfcpp::Elf_Xword flags
);
365 // Create a new Output_section.
367 make_output_section(const char* name
, elfcpp::Elf_Word type
,
368 elfcpp::Elf_Xword flags
);
370 // Set the final file offsets of all the segments.
372 set_segment_offsets(const Target
*, Output_segment
*, unsigned int* pshndx
);
374 // Set the final file offsets of all the sections not associated
375 // with a segment. We set section offsets in three passes: the
376 // first handles all allocated sections, the second sections that
377 // require postprocessing, and the last the late-bound STRTAB
378 // sections (probably only shstrtab, which is the one we care about
379 // because it holds section names).
380 enum Section_offset_pass
382 BEFORE_INPUT_SECTIONS_PASS
,
383 POSTPROCESSING_SECTIONS_PASS
,
384 STRTAB_AFTER_POSTPROCESSING_SECTIONS_PASS
387 set_section_offsets(off_t
, Section_offset_pass pass
);
389 // Set the final section indexes of all the sections not associated
390 // with a segment. Returns the next unused index.
392 set_section_indexes(unsigned int pshndx
);
394 // Return whether SEG1 comes before SEG2 in the output file.
396 segment_precedes(const Output_segment
* seg1
, const Output_segment
* seg2
);
398 // Map from section flags to segment flags.
399 static elfcpp::Elf_Word
400 section_flags_to_segment(elfcpp::Elf_Xword flags
);
402 // A mapping used for group signatures.
403 typedef Unordered_map
<std::string
, bool> Signatures
;
405 // Mapping from input section name/type/flags to output section. We
406 // use canonicalized strings here.
408 typedef std::pair
<Stringpool::Key
,
409 std::pair
<elfcpp::Elf_Word
, elfcpp::Elf_Xword
> > Key
;
414 operator()(const Key
& k
) const;
417 typedef Unordered_map
<Key
, Output_section
*, Hash_key
> Section_name_map
;
419 // A comparison class for segments.
421 struct Compare_segments
424 operator()(const Output_segment
* seg1
, const Output_segment
* seg2
)
425 { return Layout::segment_precedes(seg1
, seg2
); }
428 // A reference to the options on the command line.
429 const General_options
& options_
;
430 // The output section names.
431 Stringpool namepool_
;
432 // The output symbol names.
434 // The dynamic strings, if needed.
436 // The list of group sections and linkonce sections which we have seen.
437 Signatures signatures_
;
438 // The mapping from input section name/type/flags to output sections.
439 Section_name_map section_name_map_
;
440 // The list of output segments.
441 Segment_list segment_list_
;
442 // The list of output sections.
443 Section_list section_list_
;
444 // The list of output sections which are not attached to any output
446 Section_list unattached_section_list_
;
447 // The list of unattached Output_data objects which require special
448 // handling because they are not Output_sections.
449 Data_list special_output_list_
;
450 // The section headers.
451 Output_section_headers
* section_headers_
;
452 // A pointer to the PT_TLS segment if there is one.
453 Output_segment
* tls_segment_
;
454 // The SHT_SYMTAB output section.
455 Output_section
* symtab_section_
;
456 // The SHT_DYNSYM output section if there is one.
457 Output_section
* dynsym_section_
;
458 // The SHT_DYNAMIC output section if there is one.
459 Output_section
* dynamic_section_
;
460 // The dynamic data which goes into dynamic_section_.
461 Output_data_dynamic
* dynamic_data_
;
462 // The exception frame output section if there is one.
463 Output_section
* eh_frame_section_
;
464 // The exception frame data for eh_frame_section_.
465 Eh_frame
* eh_frame_data_
;
466 // The exception frame header output section if there is one.
467 Output_section
* eh_frame_hdr_section_
;
468 // The size of the output file.
469 off_t output_file_size_
;
470 // Whether we have seen an object file marked to require an
472 bool input_requires_executable_stack_
;
473 // Whether we have seen at least one object file with an executable
475 bool input_with_gnu_stack_note_
;
476 // Whether we have seen at least one object file without an
477 // executable stack marker.
478 bool input_without_gnu_stack_note_
;
479 // Whether we have seen an object file that uses the static TLS model.
480 bool has_static_tls_
;
481 // Whether any sections require postprocessing.
482 bool any_postprocessing_sections_
;
485 // This task handles writing out data in output sections which is not
486 // part of an input section, or which requires special handling. When
487 // this is done, it unblocks both output_sections_blocker and
490 class Write_sections_task
: public Task
493 Write_sections_task(const Layout
* layout
, Output_file
* of
,
494 Task_token
* output_sections_blocker
,
495 Task_token
* final_blocker
)
496 : layout_(layout
), of_(of
),
497 output_sections_blocker_(output_sections_blocker
),
498 final_blocker_(final_blocker
)
501 // The standard Task methods.
514 { return "Write_sections_task"; }
517 class Write_sections_locker
;
519 const Layout
* layout_
;
521 Task_token
* output_sections_blocker_
;
522 Task_token
* final_blocker_
;
525 // This task handles writing out data which is not part of a section
528 class Write_data_task
: public Task
531 Write_data_task(const Layout
* layout
, const Symbol_table
* symtab
,
532 Output_file
* of
, Task_token
* final_blocker
)
533 : layout_(layout
), symtab_(symtab
), of_(of
), final_blocker_(final_blocker
)
536 // The standard Task methods.
549 { return "Write_data_task"; }
552 const Layout
* layout_
;
553 const Symbol_table
* symtab_
;
555 Task_token
* final_blocker_
;
558 // This task handles writing out the global symbols.
560 class Write_symbols_task
: public Task
563 Write_symbols_task(const Symbol_table
* symtab
,
564 const Input_objects
* input_objects
,
565 const Stringpool
* sympool
, const Stringpool
* dynpool
,
566 Output_file
* of
, Task_token
* final_blocker
)
567 : symtab_(symtab
), input_objects_(input_objects
), sympool_(sympool
),
568 dynpool_(dynpool
), of_(of
), final_blocker_(final_blocker
)
571 // The standard Task methods.
584 { return "Write_symbols_task"; }
587 const Symbol_table
* symtab_
;
588 const Input_objects
* input_objects_
;
589 const Stringpool
* sympool_
;
590 const Stringpool
* dynpool_
;
592 Task_token
* final_blocker_
;
595 // This task handles writing out data in output sections which can't
596 // be written out until all the input sections have been handled.
597 // This is for sections whose contents is based on the contents of
598 // other output sections.
600 class Write_after_input_sections_task
: public Task
603 Write_after_input_sections_task(Layout
* layout
, Output_file
* of
,
604 Task_token
* input_sections_blocker
,
605 Task_token
* final_blocker
)
606 : layout_(layout
), of_(of
),
607 input_sections_blocker_(input_sections_blocker
),
608 final_blocker_(final_blocker
)
611 // The standard Task methods.
624 { return "Write_after_input_sections_task"; }
629 Task_token
* input_sections_blocker_
;
630 Task_token
* final_blocker_
;
633 // This task function handles closing the file.
635 class Close_task_runner
: public Task_function_runner
638 Close_task_runner(Output_file
* of
)
642 // Run the operation.
644 run(Workqueue
*, const Task
*);
650 // A small helper function to align an address.
653 align_address(uint64_t address
, uint64_t addralign
)
656 address
= (address
+ addralign
- 1) &~ (addralign
- 1);
660 } // End namespace gold.
662 #endif // !defined(GOLD_LAYOUT_H)