1 // script-sections.cc -- linker script SECTIONS for gold
3 // Copyright 2008, 2009 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.
33 #include "parameters.h"
39 #include "script-sections.h"
41 // Support for the SECTIONS clause in linker scripts.
46 // Manage orphan sections. This is intended to be largely compatible
47 // with the GNU linker. The Linux kernel implicitly relies on
48 // something similar to the GNU linker's orphan placement. We
49 // originally used a simpler scheme here, but it caused the kernel
50 // build to fail, and was also rather inefficient.
52 class Orphan_section_placement
55 typedef Script_sections::Elements_iterator Elements_iterator
;
58 Orphan_section_placement();
60 // Handle an output section during initialization of this mapping.
62 output_section_init(const std::string
& name
, Output_section
*,
63 Elements_iterator location
);
65 // Initialize the last location.
67 last_init(Elements_iterator location
);
69 // Set *PWHERE to the address of an iterator pointing to the
70 // location to use for an orphan section. Return true if the
71 // iterator has a value, false otherwise.
73 find_place(Output_section
*, Elements_iterator
** pwhere
);
75 // Return the iterator being used for sections at the very end of
81 // The places that we specifically recognize. This list is copied
82 // from the GNU linker.
98 // The information we keep for a specific place.
101 // The name of sections for this place.
103 // Whether we have a location for this place.
105 // The iterator for this place.
106 Elements_iterator location
;
109 // Initialize one place element.
111 initialize_place(Place_index
, const char*);
114 Place places_
[PLACE_MAX
];
115 // True if this is the first call to output_section_init.
119 // Initialize Orphan_section_placement.
121 Orphan_section_placement::Orphan_section_placement()
124 this->initialize_place(PLACE_TEXT
, ".text");
125 this->initialize_place(PLACE_RODATA
, ".rodata");
126 this->initialize_place(PLACE_DATA
, ".data");
127 this->initialize_place(PLACE_TLS
, NULL
);
128 this->initialize_place(PLACE_TLS_BSS
, NULL
);
129 this->initialize_place(PLACE_BSS
, ".bss");
130 this->initialize_place(PLACE_REL
, NULL
);
131 this->initialize_place(PLACE_INTERP
, ".interp");
132 this->initialize_place(PLACE_NONALLOC
, NULL
);
133 this->initialize_place(PLACE_LAST
, NULL
);
136 // Initialize one place element.
139 Orphan_section_placement::initialize_place(Place_index index
, const char* name
)
141 this->places_
[index
].name
= name
;
142 this->places_
[index
].have_location
= false;
145 // While initializing the Orphan_section_placement information, this
146 // is called once for each output section named in the linker script.
147 // If we found an output section during the link, it will be passed in
151 Orphan_section_placement::output_section_init(const std::string
& name
,
153 Elements_iterator location
)
155 bool first_init
= this->first_init_
;
156 this->first_init_
= false;
158 for (int i
= 0; i
< PLACE_MAX
; ++i
)
160 if (this->places_
[i
].name
!= NULL
&& this->places_
[i
].name
== name
)
162 if (this->places_
[i
].have_location
)
164 // We have already seen a section with this name.
168 this->places_
[i
].location
= location
;
169 this->places_
[i
].have_location
= true;
171 // If we just found the .bss section, restart the search for
172 // an unallocated section. This follows the GNU linker's
175 this->places_
[PLACE_NONALLOC
].have_location
= false;
181 // Relocation sections.
182 if (!this->places_
[PLACE_REL
].have_location
184 && (os
->type() == elfcpp::SHT_REL
|| os
->type() == elfcpp::SHT_RELA
)
185 && (os
->flags() & elfcpp::SHF_ALLOC
) != 0)
187 this->places_
[PLACE_REL
].location
= location
;
188 this->places_
[PLACE_REL
].have_location
= true;
191 // We find the location for unallocated sections by finding the
192 // first debugging or comment section after the BSS section (if
194 if (!this->places_
[PLACE_NONALLOC
].have_location
195 && (name
== ".comment" || Layout::is_debug_info_section(name
.c_str())))
197 // We add orphan sections after the location in PLACES_. We
198 // want to store unallocated sections before LOCATION. If this
199 // is the very first section, we can't use it.
203 this->places_
[PLACE_NONALLOC
].location
= location
;
204 this->places_
[PLACE_NONALLOC
].have_location
= true;
209 // Initialize the last location.
212 Orphan_section_placement::last_init(Elements_iterator location
)
214 this->places_
[PLACE_LAST
].location
= location
;
215 this->places_
[PLACE_LAST
].have_location
= true;
218 // Set *PWHERE to the address of an iterator pointing to the location
219 // to use for an orphan section. Return true if the iterator has a
220 // value, false otherwise.
223 Orphan_section_placement::find_place(Output_section
* os
,
224 Elements_iterator
** pwhere
)
226 // Figure out where OS should go. This is based on the GNU linker
227 // code. FIXME: The GNU linker handles small data sections
228 // specially, but we don't.
229 elfcpp::Elf_Word type
= os
->type();
230 elfcpp::Elf_Xword flags
= os
->flags();
232 if ((flags
& elfcpp::SHF_ALLOC
) == 0
233 && !Layout::is_debug_info_section(os
->name()))
234 index
= PLACE_NONALLOC
;
235 else if ((flags
& elfcpp::SHF_ALLOC
) == 0)
237 else if (type
== elfcpp::SHT_NOTE
)
238 index
= PLACE_INTERP
;
239 else if ((flags
& elfcpp::SHF_TLS
) != 0)
241 if (type
== elfcpp::SHT_NOBITS
)
242 index
= PLACE_TLS_BSS
;
246 else if (type
== elfcpp::SHT_NOBITS
)
248 else if ((flags
& elfcpp::SHF_WRITE
) != 0)
250 else if (type
== elfcpp::SHT_REL
|| type
== elfcpp::SHT_RELA
)
252 else if ((flags
& elfcpp::SHF_EXECINSTR
) == 0)
253 index
= PLACE_RODATA
;
257 // If we don't have a location yet, try to find one based on a
258 // plausible ordering of sections.
259 if (!this->places_
[index
].have_location
)
284 if (!this->places_
[PLACE_TLS
].have_location
)
288 if (follow
!= PLACE_MAX
&& this->places_
[follow
].have_location
)
290 // Set the location of INDEX to the location of FOLLOW. The
291 // location of INDEX will then be incremented by the caller,
292 // so anything in INDEX will continue to be after anything
294 this->places_
[index
].location
= this->places_
[follow
].location
;
295 this->places_
[index
].have_location
= true;
299 *pwhere
= &this->places_
[index
].location
;
300 bool ret
= this->places_
[index
].have_location
;
302 // The caller will set the location.
303 this->places_
[index
].have_location
= true;
308 // Return the iterator being used for sections at the very end of the
311 Orphan_section_placement::Elements_iterator
312 Orphan_section_placement::last_place() const
314 gold_assert(this->places_
[PLACE_LAST
].have_location
);
315 return this->places_
[PLACE_LAST
].location
;
318 // An element in a SECTIONS clause.
320 class Sections_element
326 virtual ~Sections_element()
329 // Return whether an output section is relro.
334 // Record that an output section is relro.
339 // Create any required output sections. The only real
340 // implementation is in Output_section_definition.
342 create_sections(Layout
*)
345 // Add any symbol being defined to the symbol table.
347 add_symbols_to_table(Symbol_table
*)
350 // Finalize symbols and check assertions.
352 finalize_symbols(Symbol_table
*, const Layout
*, uint64_t*)
355 // Return the output section name to use for an input file name and
356 // section name. This only real implementation is in
357 // Output_section_definition.
359 output_section_name(const char*, const char*, Output_section
***,
360 Script_sections::Section_type
*)
363 // Initialize OSP with an output section.
365 orphan_section_init(Orphan_section_placement
*,
366 Script_sections::Elements_iterator
)
369 // Set section addresses. This includes applying assignments if the
370 // the expression is an absolute value.
372 set_section_addresses(Symbol_table
*, Layout
*, uint64_t*, uint64_t*,
376 // Check a constraint (ONLY_IF_RO, etc.) on an output section. If
377 // this section is constrained, and the input sections do not match,
378 // return the constraint, and set *POSD.
379 virtual Section_constraint
380 check_constraint(Output_section_definition
**)
381 { return CONSTRAINT_NONE
; }
383 // See if this is the alternate output section for a constrained
384 // output section. If it is, transfer the Output_section and return
385 // true. Otherwise return false.
387 alternate_constraint(Output_section_definition
*, Section_constraint
)
390 // Get the list of segments to use for an allocated section when
391 // using a PHDRS clause. If this is an allocated section, return
392 // the Output_section, and set *PHDRS_LIST (the first parameter) to
393 // the list of PHDRS to which it should be attached. If the PHDRS
394 // were not specified, don't change *PHDRS_LIST. When not returning
395 // NULL, set *ORPHAN (the second parameter) according to whether
396 // this is an orphan section--one that is not mentioned in the
398 virtual Output_section
*
399 allocate_to_segment(String_list
**, bool*)
402 // Look for an output section by name and return the address, the
403 // load address, the alignment, and the size. This is used when an
404 // expression refers to an output section which was not actually
405 // created. This returns true if the section was found, false
406 // otherwise. The only real definition is for
407 // Output_section_definition.
409 get_output_section_info(const char*, uint64_t*, uint64_t*, uint64_t*,
413 // Return the associated Output_section if there is one.
414 virtual Output_section
*
415 get_output_section() const
418 // Print the element for debugging purposes.
420 print(FILE* f
) const = 0;
423 // An assignment in a SECTIONS clause outside of an output section.
425 class Sections_element_assignment
: public Sections_element
428 Sections_element_assignment(const char* name
, size_t namelen
,
429 Expression
* val
, bool provide
, bool hidden
)
430 : assignment_(name
, namelen
, false, val
, provide
, hidden
)
433 // Add the symbol to the symbol table.
435 add_symbols_to_table(Symbol_table
* symtab
)
436 { this->assignment_
.add_to_table(symtab
); }
438 // Finalize the symbol.
440 finalize_symbols(Symbol_table
* symtab
, const Layout
* layout
,
443 this->assignment_
.finalize_with_dot(symtab
, layout
, *dot_value
, NULL
);
446 // Set the section address. There is no section here, but if the
447 // value is absolute, we set the symbol. This permits us to use
448 // absolute symbols when setting dot.
450 set_section_addresses(Symbol_table
* symtab
, Layout
* layout
,
451 uint64_t* dot_value
, uint64_t*, uint64_t*)
453 this->assignment_
.set_if_absolute(symtab
, layout
, true, *dot_value
);
456 // Print for debugging.
461 this->assignment_
.print(f
);
465 Symbol_assignment assignment_
;
468 // An assignment to the dot symbol in a SECTIONS clause outside of an
471 class Sections_element_dot_assignment
: public Sections_element
474 Sections_element_dot_assignment(Expression
* val
)
478 // Finalize the symbol.
480 finalize_symbols(Symbol_table
* symtab
, const Layout
* layout
,
483 // We ignore the section of the result because outside of an
484 // output section definition the dot symbol is always considered
486 Output_section
* dummy
;
487 *dot_value
= this->val_
->eval_with_dot(symtab
, layout
, true, *dot_value
,
491 // Update the dot symbol while setting section addresses.
493 set_section_addresses(Symbol_table
* symtab
, Layout
* layout
,
494 uint64_t* dot_value
, uint64_t* dot_alignment
,
495 uint64_t* load_address
)
497 Output_section
* dummy
;
498 *dot_value
= this->val_
->eval_with_dot(symtab
, layout
, false, *dot_value
,
499 NULL
, &dummy
, dot_alignment
);
500 *load_address
= *dot_value
;
503 // Print for debugging.
508 this->val_
->print(f
);
516 // An assertion in a SECTIONS clause outside of an output section.
518 class Sections_element_assertion
: public Sections_element
521 Sections_element_assertion(Expression
* check
, const char* message
,
523 : assertion_(check
, message
, messagelen
)
526 // Check the assertion.
528 finalize_symbols(Symbol_table
* symtab
, const Layout
* layout
, uint64_t*)
529 { this->assertion_
.check(symtab
, layout
); }
531 // Print for debugging.
536 this->assertion_
.print(f
);
540 Script_assertion assertion_
;
543 // An element in an output section in a SECTIONS clause.
545 class Output_section_element
548 // A list of input sections.
549 typedef std::list
<Output_section::Input_section
> Input_section_list
;
551 Output_section_element()
554 virtual ~Output_section_element()
557 // Return whether this element requires an output section to exist.
559 needs_output_section() const
562 // Add any symbol being defined to the symbol table.
564 add_symbols_to_table(Symbol_table
*)
567 // Finalize symbols and check assertions.
569 finalize_symbols(Symbol_table
*, const Layout
*, uint64_t*, Output_section
**)
572 // Return whether this element matches FILE_NAME and SECTION_NAME.
573 // The only real implementation is in Output_section_element_input.
575 match_name(const char*, const char*) const
578 // Set section addresses. This includes applying assignments if the
579 // the expression is an absolute value.
581 set_section_addresses(Symbol_table
*, Layout
*, Output_section
*, uint64_t,
582 uint64_t*, uint64_t*, Output_section
**, std::string
*,
586 // Print the element for debugging purposes.
588 print(FILE* f
) const = 0;
591 // Return a fill string that is LENGTH bytes long, filling it with
594 get_fill_string(const std::string
* fill
, section_size_type length
) const;
598 Output_section_element::get_fill_string(const std::string
* fill
,
599 section_size_type length
) const
601 std::string this_fill
;
602 this_fill
.reserve(length
);
603 while (this_fill
.length() + fill
->length() <= length
)
605 if (this_fill
.length() < length
)
606 this_fill
.append(*fill
, 0, length
- this_fill
.length());
610 // A symbol assignment in an output section.
612 class Output_section_element_assignment
: public Output_section_element
615 Output_section_element_assignment(const char* name
, size_t namelen
,
616 Expression
* val
, bool provide
,
618 : assignment_(name
, namelen
, false, val
, provide
, hidden
)
621 // Add the symbol to the symbol table.
623 add_symbols_to_table(Symbol_table
* symtab
)
624 { this->assignment_
.add_to_table(symtab
); }
626 // Finalize the symbol.
628 finalize_symbols(Symbol_table
* symtab
, const Layout
* layout
,
629 uint64_t* dot_value
, Output_section
** dot_section
)
631 this->assignment_
.finalize_with_dot(symtab
, layout
, *dot_value
,
635 // Set the section address. There is no section here, but if the
636 // value is absolute, we set the symbol. This permits us to use
637 // absolute symbols when setting dot.
639 set_section_addresses(Symbol_table
* symtab
, Layout
* layout
, Output_section
*,
640 uint64_t, uint64_t* dot_value
, uint64_t*,
641 Output_section
**, std::string
*, Input_section_list
*)
643 this->assignment_
.set_if_absolute(symtab
, layout
, true, *dot_value
);
646 // Print for debugging.
651 this->assignment_
.print(f
);
655 Symbol_assignment assignment_
;
658 // An assignment to the dot symbol in an output section.
660 class Output_section_element_dot_assignment
: public Output_section_element
663 Output_section_element_dot_assignment(Expression
* val
)
667 // Finalize the symbol.
669 finalize_symbols(Symbol_table
* symtab
, const Layout
* layout
,
670 uint64_t* dot_value
, Output_section
** dot_section
)
672 *dot_value
= this->val_
->eval_with_dot(symtab
, layout
, true, *dot_value
,
673 *dot_section
, dot_section
, NULL
);
676 // Update the dot symbol while setting section addresses.
678 set_section_addresses(Symbol_table
* symtab
, Layout
* layout
, Output_section
*,
679 uint64_t, uint64_t* dot_value
, uint64_t*,
680 Output_section
**, std::string
*, Input_section_list
*);
682 // Print for debugging.
687 this->val_
->print(f
);
695 // Update the dot symbol while setting section addresses.
698 Output_section_element_dot_assignment::set_section_addresses(
699 Symbol_table
* symtab
,
701 Output_section
* output_section
,
704 uint64_t* dot_alignment
,
705 Output_section
** dot_section
,
709 uint64_t next_dot
= this->val_
->eval_with_dot(symtab
, layout
, false,
710 *dot_value
, *dot_section
,
711 dot_section
, dot_alignment
);
712 if (next_dot
< *dot_value
)
713 gold_error(_("dot may not move backward"));
714 if (next_dot
> *dot_value
&& output_section
!= NULL
)
716 section_size_type length
= convert_to_section_size_type(next_dot
718 Output_section_data
* posd
;
720 posd
= new Output_data_zero_fill(length
, 0);
723 std::string this_fill
= this->get_fill_string(fill
, length
);
724 posd
= new Output_data_const(this_fill
, 0);
726 output_section
->add_output_section_data(posd
);
727 layout
->new_output_section_data_from_script(posd
);
729 *dot_value
= next_dot
;
732 // An assertion in an output section.
734 class Output_section_element_assertion
: public Output_section_element
737 Output_section_element_assertion(Expression
* check
, const char* message
,
739 : assertion_(check
, message
, messagelen
)
746 this->assertion_
.print(f
);
750 Script_assertion assertion_
;
753 // We use a special instance of Output_section_data to handle BYTE,
754 // SHORT, etc. This permits forward references to symbols in the
757 class Output_data_expression
: public Output_section_data
760 Output_data_expression(int size
, bool is_signed
, Expression
* val
,
761 const Symbol_table
* symtab
, const Layout
* layout
,
762 uint64_t dot_value
, Output_section
* dot_section
)
763 : Output_section_data(size
, 0, true),
764 is_signed_(is_signed
), val_(val
), symtab_(symtab
),
765 layout_(layout
), dot_value_(dot_value
), dot_section_(dot_section
)
769 // Write the data to the output file.
771 do_write(Output_file
*);
773 // Write the data to a buffer.
775 do_write_to_buffer(unsigned char*);
777 // Write to a map file.
779 do_print_to_mapfile(Mapfile
* mapfile
) const
780 { mapfile
->print_output_data(this, _("** expression")); }
783 template<bool big_endian
>
785 endian_write_to_buffer(uint64_t, unsigned char*);
789 const Symbol_table
* symtab_
;
790 const Layout
* layout_
;
792 Output_section
* dot_section_
;
795 // Write the data element to the output file.
798 Output_data_expression::do_write(Output_file
* of
)
800 unsigned char* view
= of
->get_output_view(this->offset(), this->data_size());
801 this->write_to_buffer(view
);
802 of
->write_output_view(this->offset(), this->data_size(), view
);
805 // Write the data element to a buffer.
808 Output_data_expression::do_write_to_buffer(unsigned char* buf
)
810 Output_section
* dummy
;
811 uint64_t val
= this->val_
->eval_with_dot(this->symtab_
, this->layout_
,
812 true, this->dot_value_
,
813 this->dot_section_
, &dummy
, NULL
);
815 if (parameters
->target().is_big_endian())
816 this->endian_write_to_buffer
<true>(val
, buf
);
818 this->endian_write_to_buffer
<false>(val
, buf
);
821 template<bool big_endian
>
823 Output_data_expression::endian_write_to_buffer(uint64_t val
,
826 switch (this->data_size())
829 elfcpp::Swap_unaligned
<8, big_endian
>::writeval(buf
, val
);
832 elfcpp::Swap_unaligned
<16, big_endian
>::writeval(buf
, val
);
835 elfcpp::Swap_unaligned
<32, big_endian
>::writeval(buf
, val
);
838 if (parameters
->target().get_size() == 32)
841 if (this->is_signed_
&& (val
& 0x80000000) != 0)
842 val
|= 0xffffffff00000000LL
;
844 elfcpp::Swap_unaligned
<64, big_endian
>::writeval(buf
, val
);
851 // A data item in an output section.
853 class Output_section_element_data
: public Output_section_element
856 Output_section_element_data(int size
, bool is_signed
, Expression
* val
)
857 : size_(size
), is_signed_(is_signed
), val_(val
)
860 // If there is a data item, then we must create an output section.
862 needs_output_section() const
865 // Finalize symbols--we just need to update dot.
867 finalize_symbols(Symbol_table
*, const Layout
*, uint64_t* dot_value
,
869 { *dot_value
+= this->size_
; }
871 // Store the value in the section.
873 set_section_addresses(Symbol_table
*, Layout
*, Output_section
*, uint64_t,
874 uint64_t* dot_value
, uint64_t*, Output_section
**,
875 std::string
*, Input_section_list
*);
877 // Print for debugging.
882 // The size in bytes.
884 // Whether the value is signed.
890 // Store the value in the section.
893 Output_section_element_data::set_section_addresses(
894 Symbol_table
* symtab
,
900 Output_section
** dot_section
,
904 gold_assert(os
!= NULL
);
905 Output_data_expression
* expression
=
906 new Output_data_expression(this->size_
, this->is_signed_
, this->val_
,
907 symtab
, layout
, *dot_value
, *dot_section
);
908 os
->add_output_section_data(expression
);
909 layout
->new_output_section_data_from_script(expression
);
910 *dot_value
+= this->size_
;
913 // Print for debugging.
916 Output_section_element_data::print(FILE* f
) const
931 if (this->is_signed_
)
939 fprintf(f
, " %s(", s
);
940 this->val_
->print(f
);
944 // A fill value setting in an output section.
946 class Output_section_element_fill
: public Output_section_element
949 Output_section_element_fill(Expression
* val
)
953 // Update the fill value while setting section addresses.
955 set_section_addresses(Symbol_table
* symtab
, Layout
* layout
, Output_section
*,
956 uint64_t, uint64_t* dot_value
, uint64_t*,
957 Output_section
** dot_section
,
958 std::string
* fill
, Input_section_list
*)
960 Output_section
* fill_section
;
961 uint64_t fill_val
= this->val_
->eval_with_dot(symtab
, layout
, false,
962 *dot_value
, *dot_section
,
963 &fill_section
, NULL
);
964 if (fill_section
!= NULL
)
965 gold_warning(_("fill value is not absolute"));
966 // FIXME: The GNU linker supports fill values of arbitrary length.
967 unsigned char fill_buff
[4];
968 elfcpp::Swap_unaligned
<32, true>::writeval(fill_buff
, fill_val
);
969 fill
->assign(reinterpret_cast<char*>(fill_buff
), 4);
972 // Print for debugging.
976 fprintf(f
, " FILL(");
977 this->val_
->print(f
);
982 // The new fill value.
986 // Return whether STRING contains a wildcard character. This is used
987 // to speed up matching.
990 is_wildcard_string(const std::string
& s
)
992 return strpbrk(s
.c_str(), "?*[") != NULL
;
995 // An input section specification in an output section
997 class Output_section_element_input
: public Output_section_element
1000 Output_section_element_input(const Input_section_spec
* spec
, bool keep
);
1002 // Finalize symbols--just update the value of the dot symbol.
1004 finalize_symbols(Symbol_table
*, const Layout
*, uint64_t* dot_value
,
1005 Output_section
** dot_section
)
1007 *dot_value
= this->final_dot_value_
;
1008 *dot_section
= this->final_dot_section_
;
1011 // See whether we match FILE_NAME and SECTION_NAME as an input
1014 match_name(const char* file_name
, const char* section_name
) const;
1016 // Set the section address.
1018 set_section_addresses(Symbol_table
* symtab
, Layout
* layout
, Output_section
*,
1019 uint64_t subalign
, uint64_t* dot_value
, uint64_t*,
1020 Output_section
**, std::string
* fill
,
1021 Input_section_list
*);
1023 // Print for debugging.
1025 print(FILE* f
) const;
1028 // An input section pattern.
1029 struct Input_section_pattern
1031 std::string pattern
;
1032 bool pattern_is_wildcard
;
1035 Input_section_pattern(const char* patterna
, size_t patternlena
,
1036 Sort_wildcard sorta
)
1037 : pattern(patterna
, patternlena
),
1038 pattern_is_wildcard(is_wildcard_string(this->pattern
)),
1043 typedef std::vector
<Input_section_pattern
> Input_section_patterns
;
1045 // Filename_exclusions is a pair of filename pattern and a bool
1046 // indicating whether the filename is a wildcard.
1047 typedef std::vector
<std::pair
<std::string
, bool> > Filename_exclusions
;
1049 // Return whether STRING matches PATTERN, where IS_WILDCARD_PATTERN
1050 // indicates whether this is a wildcard pattern.
1052 match(const char* string
, const char* pattern
, bool is_wildcard_pattern
)
1054 return (is_wildcard_pattern
1055 ? fnmatch(pattern
, string
, 0) == 0
1056 : strcmp(string
, pattern
) == 0);
1059 // See if we match a file name.
1061 match_file_name(const char* file_name
) const;
1063 // The file name pattern. If this is the empty string, we match all
1065 std::string filename_pattern_
;
1066 // Whether the file name pattern is a wildcard.
1067 bool filename_is_wildcard_
;
1068 // How the file names should be sorted. This may only be
1069 // SORT_WILDCARD_NONE or SORT_WILDCARD_BY_NAME.
1070 Sort_wildcard filename_sort_
;
1071 // The list of file names to exclude.
1072 Filename_exclusions filename_exclusions_
;
1073 // The list of input section patterns.
1074 Input_section_patterns input_section_patterns_
;
1075 // Whether to keep this section when garbage collecting.
1077 // The value of dot after including all matching sections.
1078 uint64_t final_dot_value_
;
1079 // The section where dot is defined after including all matching
1081 Output_section
* final_dot_section_
;
1084 // Construct Output_section_element_input. The parser records strings
1085 // as pointers into a copy of the script file, which will go away when
1086 // parsing is complete. We make sure they are in std::string objects.
1088 Output_section_element_input::Output_section_element_input(
1089 const Input_section_spec
* spec
,
1091 : filename_pattern_(),
1092 filename_is_wildcard_(false),
1093 filename_sort_(spec
->file
.sort
),
1094 filename_exclusions_(),
1095 input_section_patterns_(),
1097 final_dot_value_(0),
1098 final_dot_section_(NULL
)
1100 // The filename pattern "*" is common, and matches all files. Turn
1101 // it into the empty string.
1102 if (spec
->file
.name
.length
!= 1 || spec
->file
.name
.value
[0] != '*')
1103 this->filename_pattern_
.assign(spec
->file
.name
.value
,
1104 spec
->file
.name
.length
);
1105 this->filename_is_wildcard_
= is_wildcard_string(this->filename_pattern_
);
1107 if (spec
->input_sections
.exclude
!= NULL
)
1109 for (String_list::const_iterator p
=
1110 spec
->input_sections
.exclude
->begin();
1111 p
!= spec
->input_sections
.exclude
->end();
1114 bool is_wildcard
= is_wildcard_string(*p
);
1115 this->filename_exclusions_
.push_back(std::make_pair(*p
,
1120 if (spec
->input_sections
.sections
!= NULL
)
1122 Input_section_patterns
& isp(this->input_section_patterns_
);
1123 for (String_sort_list::const_iterator p
=
1124 spec
->input_sections
.sections
->begin();
1125 p
!= spec
->input_sections
.sections
->end();
1127 isp
.push_back(Input_section_pattern(p
->name
.value
, p
->name
.length
,
1132 // See whether we match FILE_NAME.
1135 Output_section_element_input::match_file_name(const char* file_name
) const
1137 if (!this->filename_pattern_
.empty())
1139 // If we were called with no filename, we refuse to match a
1140 // pattern which requires a file name.
1141 if (file_name
== NULL
)
1144 if (!match(file_name
, this->filename_pattern_
.c_str(),
1145 this->filename_is_wildcard_
))
1149 if (file_name
!= NULL
)
1151 // Now we have to see whether FILE_NAME matches one of the
1152 // exclusion patterns, if any.
1153 for (Filename_exclusions::const_iterator p
=
1154 this->filename_exclusions_
.begin();
1155 p
!= this->filename_exclusions_
.end();
1158 if (match(file_name
, p
->first
.c_str(), p
->second
))
1166 // See whether we match FILE_NAME and SECTION_NAME.
1169 Output_section_element_input::match_name(const char* file_name
,
1170 const char* section_name
) const
1172 if (!this->match_file_name(file_name
))
1175 // If there are no section name patterns, then we match.
1176 if (this->input_section_patterns_
.empty())
1179 // See whether we match the section name patterns.
1180 for (Input_section_patterns::const_iterator p
=
1181 this->input_section_patterns_
.begin();
1182 p
!= this->input_section_patterns_
.end();
1185 if (match(section_name
, p
->pattern
.c_str(), p
->pattern_is_wildcard
))
1189 // We didn't match any section names, so we didn't match.
1193 // Information we use to sort the input sections.
1195 class Input_section_info
1198 Input_section_info(const Output_section::Input_section
& input_section
)
1199 : input_section_(input_section
), section_name_(),
1200 size_(0), addralign_(1)
1203 // Return the simple input section.
1204 const Output_section::Input_section
&
1205 input_section() const
1206 { return this->input_section_
; }
1208 // Return the object.
1211 { return this->input_section_
.relobj(); }
1213 // Return the section index.
1216 { return this->input_section_
.shndx(); }
1218 // Return the section name.
1220 section_name() const
1221 { return this->section_name_
; }
1223 // Set the section name.
1225 set_section_name(const std::string name
)
1226 { this->section_name_
= name
; }
1228 // Return the section size.
1231 { return this->size_
; }
1233 // Set the section size.
1235 set_size(uint64_t size
)
1236 { this->size_
= size
; }
1238 // Return the address alignment.
1241 { return this->addralign_
; }
1243 // Set the address alignment.
1245 set_addralign(uint64_t addralign
)
1246 { this->addralign_
= addralign
; }
1249 // Input section, can be a relaxed section.
1250 Output_section::Input_section input_section_
;
1251 // Name of the section.
1252 std::string section_name_
;
1255 // Address alignment.
1256 uint64_t addralign_
;
1259 // A class to sort the input sections.
1261 class Input_section_sorter
1264 Input_section_sorter(Sort_wildcard filename_sort
, Sort_wildcard section_sort
)
1265 : filename_sort_(filename_sort
), section_sort_(section_sort
)
1269 operator()(const Input_section_info
&, const Input_section_info
&) const;
1272 Sort_wildcard filename_sort_
;
1273 Sort_wildcard section_sort_
;
1277 Input_section_sorter::operator()(const Input_section_info
& isi1
,
1278 const Input_section_info
& isi2
) const
1280 if (this->section_sort_
== SORT_WILDCARD_BY_NAME
1281 || this->section_sort_
== SORT_WILDCARD_BY_NAME_BY_ALIGNMENT
1282 || (this->section_sort_
== SORT_WILDCARD_BY_ALIGNMENT_BY_NAME
1283 && isi1
.addralign() == isi2
.addralign()))
1285 if (isi1
.section_name() != isi2
.section_name())
1286 return isi1
.section_name() < isi2
.section_name();
1288 if (this->section_sort_
== SORT_WILDCARD_BY_ALIGNMENT
1289 || this->section_sort_
== SORT_WILDCARD_BY_NAME_BY_ALIGNMENT
1290 || this->section_sort_
== SORT_WILDCARD_BY_ALIGNMENT_BY_NAME
)
1292 if (isi1
.addralign() != isi2
.addralign())
1293 return isi1
.addralign() < isi2
.addralign();
1295 if (this->filename_sort_
== SORT_WILDCARD_BY_NAME
)
1297 if (isi1
.relobj()->name() != isi2
.relobj()->name())
1298 return (isi1
.relobj()->name() < isi2
.relobj()->name());
1301 // Otherwise we leave them in the same order.
1305 // Set the section address. Look in INPUT_SECTIONS for sections which
1306 // match this spec, sort them as specified, and add them to the output
1310 Output_section_element_input::set_section_addresses(
1313 Output_section
* output_section
,
1315 uint64_t* dot_value
,
1317 Output_section
** dot_section
,
1319 Input_section_list
* input_sections
)
1321 // We build a list of sections which match each
1322 // Input_section_pattern.
1324 typedef std::vector
<std::vector
<Input_section_info
> > Matching_sections
;
1325 size_t input_pattern_count
= this->input_section_patterns_
.size();
1326 if (input_pattern_count
== 0)
1327 input_pattern_count
= 1;
1328 Matching_sections
matching_sections(input_pattern_count
);
1330 // Look through the list of sections for this output section. Add
1331 // each one which matches to one of the elements of
1332 // MATCHING_SECTIONS.
1334 Input_section_list::iterator p
= input_sections
->begin();
1335 while (p
!= input_sections
->end())
1337 Relobj
* relobj
= p
->relobj();
1338 unsigned int shndx
= p
->shndx();
1339 Input_section_info
isi(*p
);
1341 // Calling section_name and section_addralign is not very
1344 // Lock the object so that we can get information about the
1345 // section. This is OK since we know we are single-threaded
1348 const Task
* task
= reinterpret_cast<const Task
*>(-1);
1349 Task_lock_obj
<Object
> tl(task
, relobj
);
1351 isi
.set_section_name(relobj
->section_name(shndx
));
1352 if (p
->is_relaxed_input_section())
1354 // We use current data size because relxed section sizes may not
1355 // have finalized yet.
1356 isi
.set_size(p
->relaxed_input_section()->current_data_size());
1357 isi
.set_addralign(p
->relaxed_input_section()->addralign());
1361 isi
.set_size(relobj
->section_size(shndx
));
1362 isi
.set_addralign(relobj
->section_addralign(shndx
));
1366 if (!this->match_file_name(relobj
->name().c_str()))
1368 else if (this->input_section_patterns_
.empty())
1370 matching_sections
[0].push_back(isi
);
1371 p
= input_sections
->erase(p
);
1376 for (i
= 0; i
< input_pattern_count
; ++i
)
1378 const Input_section_pattern
&
1379 isp(this->input_section_patterns_
[i
]);
1380 if (match(isi
.section_name().c_str(), isp
.pattern
.c_str(),
1381 isp
.pattern_is_wildcard
))
1385 if (i
>= this->input_section_patterns_
.size())
1389 matching_sections
[i
].push_back(isi
);
1390 p
= input_sections
->erase(p
);
1395 // Look through MATCHING_SECTIONS. Sort each one as specified,
1396 // using a stable sort so that we get the default order when
1397 // sections are otherwise equal. Add each input section to the
1400 uint64_t dot
= *dot_value
;
1401 for (size_t i
= 0; i
< input_pattern_count
; ++i
)
1403 if (matching_sections
[i
].empty())
1406 gold_assert(output_section
!= NULL
);
1408 const Input_section_pattern
& isp(this->input_section_patterns_
[i
]);
1409 if (isp
.sort
!= SORT_WILDCARD_NONE
1410 || this->filename_sort_
!= SORT_WILDCARD_NONE
)
1411 std::stable_sort(matching_sections
[i
].begin(),
1412 matching_sections
[i
].end(),
1413 Input_section_sorter(this->filename_sort_
,
1416 for (std::vector
<Input_section_info
>::const_iterator p
=
1417 matching_sections
[i
].begin();
1418 p
!= matching_sections
[i
].end();
1421 // Override the original address alignment if SUBALIGN is specified
1422 // and is greater than the original alignment. We need to make a
1423 // copy of the input section to modify the alignment.
1424 Output_section::Input_section
sis(p
->input_section());
1426 uint64_t this_subalign
= sis
.addralign();
1427 if (!sis
.is_input_section())
1428 sis
.output_section_data()->finalize_data_size();
1429 uint64_t data_size
= sis
.data_size();
1430 if (this_subalign
< subalign
)
1432 this_subalign
= subalign
;
1433 sis
.set_addralign(subalign
);
1436 uint64_t address
= align_address(dot
, this_subalign
);
1438 if (address
> dot
&& !fill
->empty())
1440 section_size_type length
=
1441 convert_to_section_size_type(address
- dot
);
1442 std::string this_fill
= this->get_fill_string(fill
, length
);
1443 Output_section_data
* posd
= new Output_data_const(this_fill
, 0);
1444 output_section
->add_output_section_data(posd
);
1445 layout
->new_output_section_data_from_script(posd
);
1448 output_section
->add_script_input_section(sis
);
1449 dot
= address
+ data_size
;
1453 // An SHF_TLS/SHT_NOBITS section does not take up any
1455 if (output_section
== NULL
1456 || (output_section
->flags() & elfcpp::SHF_TLS
) == 0
1457 || output_section
->type() != elfcpp::SHT_NOBITS
)
1460 this->final_dot_value_
= *dot_value
;
1461 this->final_dot_section_
= *dot_section
;
1464 // Print for debugging.
1467 Output_section_element_input::print(FILE* f
) const
1472 fprintf(f
, "KEEP(");
1474 if (!this->filename_pattern_
.empty())
1476 bool need_close_paren
= false;
1477 switch (this->filename_sort_
)
1479 case SORT_WILDCARD_NONE
:
1481 case SORT_WILDCARD_BY_NAME
:
1482 fprintf(f
, "SORT_BY_NAME(");
1483 need_close_paren
= true;
1489 fprintf(f
, "%s", this->filename_pattern_
.c_str());
1491 if (need_close_paren
)
1495 if (!this->input_section_patterns_
.empty()
1496 || !this->filename_exclusions_
.empty())
1500 bool need_space
= false;
1501 if (!this->filename_exclusions_
.empty())
1503 fprintf(f
, "EXCLUDE_FILE(");
1504 bool need_comma
= false;
1505 for (Filename_exclusions::const_iterator p
=
1506 this->filename_exclusions_
.begin();
1507 p
!= this->filename_exclusions_
.end();
1512 fprintf(f
, "%s", p
->first
.c_str());
1519 for (Input_section_patterns::const_iterator p
=
1520 this->input_section_patterns_
.begin();
1521 p
!= this->input_section_patterns_
.end();
1527 int close_parens
= 0;
1530 case SORT_WILDCARD_NONE
:
1532 case SORT_WILDCARD_BY_NAME
:
1533 fprintf(f
, "SORT_BY_NAME(");
1536 case SORT_WILDCARD_BY_ALIGNMENT
:
1537 fprintf(f
, "SORT_BY_ALIGNMENT(");
1540 case SORT_WILDCARD_BY_NAME_BY_ALIGNMENT
:
1541 fprintf(f
, "SORT_BY_NAME(SORT_BY_ALIGNMENT(");
1544 case SORT_WILDCARD_BY_ALIGNMENT_BY_NAME
:
1545 fprintf(f
, "SORT_BY_ALIGNMENT(SORT_BY_NAME(");
1552 fprintf(f
, "%s", p
->pattern
.c_str());
1554 for (int i
= 0; i
< close_parens
; ++i
)
1569 // An output section.
1571 class Output_section_definition
: public Sections_element
1574 typedef Output_section_element::Input_section_list Input_section_list
;
1576 Output_section_definition(const char* name
, size_t namelen
,
1577 const Parser_output_section_header
* header
);
1579 // Finish the output section with the information in the trailer.
1581 finish(const Parser_output_section_trailer
* trailer
);
1583 // Add a symbol to be defined.
1585 add_symbol_assignment(const char* name
, size_t length
, Expression
* value
,
1586 bool provide
, bool hidden
);
1588 // Add an assignment to the special dot symbol.
1590 add_dot_assignment(Expression
* value
);
1592 // Add an assertion.
1594 add_assertion(Expression
* check
, const char* message
, size_t messagelen
);
1596 // Add a data item to the current output section.
1598 add_data(int size
, bool is_signed
, Expression
* val
);
1600 // Add a setting for the fill value.
1602 add_fill(Expression
* val
);
1604 // Add an input section specification.
1606 add_input_section(const Input_section_spec
* spec
, bool keep
);
1608 // Return whether the output section is relro.
1611 { return this->is_relro_
; }
1613 // Record that the output section is relro.
1616 { this->is_relro_
= true; }
1618 // Create any required output sections.
1620 create_sections(Layout
*);
1622 // Add any symbols being defined to the symbol table.
1624 add_symbols_to_table(Symbol_table
* symtab
);
1626 // Finalize symbols and check assertions.
1628 finalize_symbols(Symbol_table
*, const Layout
*, uint64_t*);
1630 // Return the output section name to use for an input file name and
1633 output_section_name(const char* file_name
, const char* section_name
,
1634 Output_section
***, Script_sections::Section_type
*);
1636 // Initialize OSP with an output section.
1638 orphan_section_init(Orphan_section_placement
* osp
,
1639 Script_sections::Elements_iterator p
)
1640 { osp
->output_section_init(this->name_
, this->output_section_
, p
); }
1642 // Set the section address.
1644 set_section_addresses(Symbol_table
* symtab
, Layout
* layout
,
1645 uint64_t* dot_value
, uint64_t*,
1646 uint64_t* load_address
);
1648 // Check a constraint (ONLY_IF_RO, etc.) on an output section. If
1649 // this section is constrained, and the input sections do not match,
1650 // return the constraint, and set *POSD.
1652 check_constraint(Output_section_definition
** posd
);
1654 // See if this is the alternate output section for a constrained
1655 // output section. If it is, transfer the Output_section and return
1656 // true. Otherwise return false.
1658 alternate_constraint(Output_section_definition
*, Section_constraint
);
1660 // Get the list of segments to use for an allocated section when
1661 // using a PHDRS clause.
1663 allocate_to_segment(String_list
** phdrs_list
, bool* orphan
);
1665 // Look for an output section by name and return the address, the
1666 // load address, the alignment, and the size. This is used when an
1667 // expression refers to an output section which was not actually
1668 // created. This returns true if the section was found, false
1671 get_output_section_info(const char*, uint64_t*, uint64_t*, uint64_t*,
1674 // Return the associated Output_section if there is one.
1676 get_output_section() const
1677 { return this->output_section_
; }
1679 // Print the contents to the FILE. This is for debugging.
1683 // Return the output section type if specified or Script_sections::ST_NONE.
1684 Script_sections::Section_type
1685 section_type() const;
1689 script_section_type_name(Script_section_type
);
1691 typedef std::vector
<Output_section_element
*> Output_section_elements
;
1693 // The output section name.
1695 // The address. This may be NULL.
1696 Expression
* address_
;
1697 // The load address. This may be NULL.
1698 Expression
* load_address_
;
1699 // The alignment. This may be NULL.
1701 // The input section alignment. This may be NULL.
1702 Expression
* subalign_
;
1703 // The constraint, if any.
1704 Section_constraint constraint_
;
1705 // The fill value. This may be NULL.
1707 // The list of segments this section should go into. This may be
1709 String_list
* phdrs_
;
1710 // The list of elements defining the section.
1711 Output_section_elements elements_
;
1712 // The Output_section created for this definition. This will be
1713 // NULL if none was created.
1714 Output_section
* output_section_
;
1715 // The address after it has been evaluated.
1716 uint64_t evaluated_address_
;
1717 // The load address after it has been evaluated.
1718 uint64_t evaluated_load_address_
;
1719 // The alignment after it has been evaluated.
1720 uint64_t evaluated_addralign_
;
1721 // The output section is relro.
1723 // The output section type if specified.
1724 enum Script_section_type script_section_type_
;
1729 Output_section_definition::Output_section_definition(
1732 const Parser_output_section_header
* header
)
1733 : name_(name
, namelen
),
1734 address_(header
->address
),
1735 load_address_(header
->load_address
),
1736 align_(header
->align
),
1737 subalign_(header
->subalign
),
1738 constraint_(header
->constraint
),
1742 output_section_(NULL
),
1743 evaluated_address_(0),
1744 evaluated_load_address_(0),
1745 evaluated_addralign_(0),
1747 script_section_type_(header
->section_type
)
1751 // Finish an output section.
1754 Output_section_definition::finish(const Parser_output_section_trailer
* trailer
)
1756 this->fill_
= trailer
->fill
;
1757 this->phdrs_
= trailer
->phdrs
;
1760 // Add a symbol to be defined.
1763 Output_section_definition::add_symbol_assignment(const char* name
,
1769 Output_section_element
* p
= new Output_section_element_assignment(name
,
1774 this->elements_
.push_back(p
);
1777 // Add an assignment to the special dot symbol.
1780 Output_section_definition::add_dot_assignment(Expression
* value
)
1782 Output_section_element
* p
= new Output_section_element_dot_assignment(value
);
1783 this->elements_
.push_back(p
);
1786 // Add an assertion.
1789 Output_section_definition::add_assertion(Expression
* check
,
1790 const char* message
,
1793 Output_section_element
* p
= new Output_section_element_assertion(check
,
1796 this->elements_
.push_back(p
);
1799 // Add a data item to the current output section.
1802 Output_section_definition::add_data(int size
, bool is_signed
, Expression
* val
)
1804 Output_section_element
* p
= new Output_section_element_data(size
, is_signed
,
1806 this->elements_
.push_back(p
);
1809 // Add a setting for the fill value.
1812 Output_section_definition::add_fill(Expression
* val
)
1814 Output_section_element
* p
= new Output_section_element_fill(val
);
1815 this->elements_
.push_back(p
);
1818 // Add an input section specification.
1821 Output_section_definition::add_input_section(const Input_section_spec
* spec
,
1824 Output_section_element
* p
= new Output_section_element_input(spec
, keep
);
1825 this->elements_
.push_back(p
);
1828 // Create any required output sections. We need an output section if
1829 // there is a data statement here.
1832 Output_section_definition::create_sections(Layout
* layout
)
1834 if (this->output_section_
!= NULL
)
1836 for (Output_section_elements::const_iterator p
= this->elements_
.begin();
1837 p
!= this->elements_
.end();
1840 if ((*p
)->needs_output_section())
1842 const char* name
= this->name_
.c_str();
1843 this->output_section_
=
1844 layout
->make_output_section_for_script(name
, this->section_type());
1850 // Add any symbols being defined to the symbol table.
1853 Output_section_definition::add_symbols_to_table(Symbol_table
* symtab
)
1855 for (Output_section_elements::iterator p
= this->elements_
.begin();
1856 p
!= this->elements_
.end();
1858 (*p
)->add_symbols_to_table(symtab
);
1861 // Finalize symbols and check assertions.
1864 Output_section_definition::finalize_symbols(Symbol_table
* symtab
,
1865 const Layout
* layout
,
1866 uint64_t* dot_value
)
1868 if (this->output_section_
!= NULL
)
1869 *dot_value
= this->output_section_
->address();
1872 uint64_t address
= *dot_value
;
1873 if (this->address_
!= NULL
)
1875 Output_section
* dummy
;
1876 address
= this->address_
->eval_with_dot(symtab
, layout
, true,
1880 if (this->align_
!= NULL
)
1882 Output_section
* dummy
;
1883 uint64_t align
= this->align_
->eval_with_dot(symtab
, layout
, true,
1887 address
= align_address(address
, align
);
1889 *dot_value
= address
;
1892 Output_section
* dot_section
= this->output_section_
;
1893 for (Output_section_elements::iterator p
= this->elements_
.begin();
1894 p
!= this->elements_
.end();
1896 (*p
)->finalize_symbols(symtab
, layout
, dot_value
, &dot_section
);
1899 // Return the output section name to use for an input section name.
1902 Output_section_definition::output_section_name(
1903 const char* file_name
,
1904 const char* section_name
,
1905 Output_section
*** slot
,
1906 Script_sections::Section_type
*psection_type
)
1908 // Ask each element whether it matches NAME.
1909 for (Output_section_elements::const_iterator p
= this->elements_
.begin();
1910 p
!= this->elements_
.end();
1913 if ((*p
)->match_name(file_name
, section_name
))
1915 // We found a match for NAME, which means that it should go
1916 // into this output section.
1917 *slot
= &this->output_section_
;
1918 *psection_type
= this->section_type();
1919 return this->name_
.c_str();
1923 // We don't know about this section name.
1927 // Set the section address. Note that the OUTPUT_SECTION_ field will
1928 // be NULL if no input sections were mapped to this output section.
1929 // We still have to adjust dot and process symbol assignments.
1932 Output_section_definition::set_section_addresses(Symbol_table
* symtab
,
1934 uint64_t* dot_value
,
1935 uint64_t* dot_alignment
,
1936 uint64_t* load_address
)
1939 uint64_t old_dot_value
= *dot_value
;
1940 uint64_t old_load_address
= *load_address
;
1942 // Check for --section-start.
1943 bool is_address_set
= false;
1944 if (this->output_section_
!= NULL
)
1946 parameters
->options().section_start(this->output_section_
->name(),
1948 if (!is_address_set
)
1950 if (this->address_
== NULL
)
1951 address
= *dot_value
;
1954 Output_section
* dummy
;
1955 address
= this->address_
->eval_with_dot(symtab
, layout
, true,
1956 *dot_value
, NULL
, &dummy
,
1962 if (this->align_
== NULL
)
1964 if (this->output_section_
== NULL
)
1967 align
= this->output_section_
->addralign();
1971 Output_section
* align_section
;
1972 align
= this->align_
->eval_with_dot(symtab
, layout
, true, *dot_value
,
1973 NULL
, &align_section
, NULL
);
1974 if (align_section
!= NULL
)
1975 gold_warning(_("alignment of section %s is not absolute"),
1976 this->name_
.c_str());
1977 if (this->output_section_
!= NULL
)
1978 this->output_section_
->set_addralign(align
);
1981 address
= align_address(address
, align
);
1983 uint64_t start_address
= address
;
1985 *dot_value
= address
;
1987 // Except for NOLOAD sections, the address of non-SHF_ALLOC sections is
1988 // forced to zero, regardless of what the linker script wants.
1989 if (this->output_section_
!= NULL
1990 && ((this->output_section_
->flags() & elfcpp::SHF_ALLOC
) != 0
1991 || this->output_section_
->is_noload()))
1992 this->output_section_
->set_address(address
);
1994 this->evaluated_address_
= address
;
1995 this->evaluated_addralign_
= align
;
1997 if (this->load_address_
== NULL
)
1998 this->evaluated_load_address_
= address
;
2001 Output_section
* dummy
;
2003 this->load_address_
->eval_with_dot(symtab
, layout
, true, *dot_value
,
2004 this->output_section_
, &dummy
,
2006 if (this->output_section_
!= NULL
)
2007 this->output_section_
->set_load_address(laddr
);
2008 this->evaluated_load_address_
= laddr
;
2012 if (this->subalign_
== NULL
)
2016 Output_section
* subalign_section
;
2017 subalign
= this->subalign_
->eval_with_dot(symtab
, layout
, true,
2019 &subalign_section
, NULL
);
2020 if (subalign_section
!= NULL
)
2021 gold_warning(_("subalign of section %s is not absolute"),
2022 this->name_
.c_str());
2026 if (this->fill_
!= NULL
)
2028 // FIXME: The GNU linker supports fill values of arbitrary
2030 Output_section
* fill_section
;
2031 uint64_t fill_val
= this->fill_
->eval_with_dot(symtab
, layout
, true,
2033 NULL
, &fill_section
,
2035 if (fill_section
!= NULL
)
2036 gold_warning(_("fill of section %s is not absolute"),
2037 this->name_
.c_str());
2038 unsigned char fill_buff
[4];
2039 elfcpp::Swap_unaligned
<32, true>::writeval(fill_buff
, fill_val
);
2040 fill
.assign(reinterpret_cast<char*>(fill_buff
), 4);
2043 Input_section_list input_sections
;
2044 if (this->output_section_
!= NULL
)
2046 // Get the list of input sections attached to this output
2047 // section. This will leave the output section with only
2048 // Output_section_data entries.
2049 address
+= this->output_section_
->get_input_sections(address
,
2052 *dot_value
= address
;
2055 Output_section
* dot_section
= this->output_section_
;
2056 for (Output_section_elements::iterator p
= this->elements_
.begin();
2057 p
!= this->elements_
.end();
2059 (*p
)->set_section_addresses(symtab
, layout
, this->output_section_
,
2060 subalign
, dot_value
, dot_alignment
,
2061 &dot_section
, &fill
, &input_sections
);
2063 gold_assert(input_sections
.empty());
2065 if (this->load_address_
== NULL
|| this->output_section_
== NULL
)
2066 *load_address
= *dot_value
;
2068 *load_address
= (this->output_section_
->load_address()
2069 + (*dot_value
- start_address
));
2071 if (this->output_section_
!= NULL
)
2073 if (this->is_relro_
)
2074 this->output_section_
->set_is_relro();
2076 this->output_section_
->clear_is_relro();
2078 // If this is a NOLOAD section, keep dot and load address unchanged.
2079 if (this->output_section_
->is_noload())
2081 *dot_value
= old_dot_value
;
2082 *load_address
= old_load_address
;
2087 // Check a constraint (ONLY_IF_RO, etc.) on an output section. If
2088 // this section is constrained, and the input sections do not match,
2089 // return the constraint, and set *POSD.
2092 Output_section_definition::check_constraint(Output_section_definition
** posd
)
2094 switch (this->constraint_
)
2096 case CONSTRAINT_NONE
:
2097 return CONSTRAINT_NONE
;
2099 case CONSTRAINT_ONLY_IF_RO
:
2100 if (this->output_section_
!= NULL
2101 && (this->output_section_
->flags() & elfcpp::SHF_WRITE
) != 0)
2104 return CONSTRAINT_ONLY_IF_RO
;
2106 return CONSTRAINT_NONE
;
2108 case CONSTRAINT_ONLY_IF_RW
:
2109 if (this->output_section_
!= NULL
2110 && (this->output_section_
->flags() & elfcpp::SHF_WRITE
) == 0)
2113 return CONSTRAINT_ONLY_IF_RW
;
2115 return CONSTRAINT_NONE
;
2117 case CONSTRAINT_SPECIAL
:
2118 if (this->output_section_
!= NULL
)
2119 gold_error(_("SPECIAL constraints are not implemented"));
2120 return CONSTRAINT_NONE
;
2127 // See if this is the alternate output section for a constrained
2128 // output section. If it is, transfer the Output_section and return
2129 // true. Otherwise return false.
2132 Output_section_definition::alternate_constraint(
2133 Output_section_definition
* posd
,
2134 Section_constraint constraint
)
2136 if (this->name_
!= posd
->name_
)
2141 case CONSTRAINT_ONLY_IF_RO
:
2142 if (this->constraint_
!= CONSTRAINT_ONLY_IF_RW
)
2146 case CONSTRAINT_ONLY_IF_RW
:
2147 if (this->constraint_
!= CONSTRAINT_ONLY_IF_RO
)
2155 // We have found the alternate constraint. We just need to move
2156 // over the Output_section. When constraints are used properly,
2157 // THIS should not have an output_section pointer, as all the input
2158 // sections should have matched the other definition.
2160 if (this->output_section_
!= NULL
)
2161 gold_error(_("mismatched definition for constrained sections"));
2163 this->output_section_
= posd
->output_section_
;
2164 posd
->output_section_
= NULL
;
2166 if (this->is_relro_
)
2167 this->output_section_
->set_is_relro();
2169 this->output_section_
->clear_is_relro();
2174 // Get the list of segments to use for an allocated section when using
2178 Output_section_definition::allocate_to_segment(String_list
** phdrs_list
,
2181 // Update phdrs_list even if we don't have an output section. It
2182 // might be used by the following sections.
2183 if (this->phdrs_
!= NULL
)
2184 *phdrs_list
= this->phdrs_
;
2186 if (this->output_section_
== NULL
)
2188 if ((this->output_section_
->flags() & elfcpp::SHF_ALLOC
) == 0)
2191 return this->output_section_
;
2194 // Look for an output section by name and return the address, the load
2195 // address, the alignment, and the size. This is used when an
2196 // expression refers to an output section which was not actually
2197 // created. This returns true if the section was found, false
2201 Output_section_definition::get_output_section_info(const char* name
,
2203 uint64_t* load_address
,
2204 uint64_t* addralign
,
2205 uint64_t* size
) const
2207 if (this->name_
!= name
)
2210 if (this->output_section_
!= NULL
)
2212 *address
= this->output_section_
->address();
2213 if (this->output_section_
->has_load_address())
2214 *load_address
= this->output_section_
->load_address();
2216 *load_address
= *address
;
2217 *addralign
= this->output_section_
->addralign();
2218 *size
= this->output_section_
->current_data_size();
2222 *address
= this->evaluated_address_
;
2223 *load_address
= this->evaluated_load_address_
;
2224 *addralign
= this->evaluated_addralign_
;
2231 // Print for debugging.
2234 Output_section_definition::print(FILE* f
) const
2236 fprintf(f
, " %s ", this->name_
.c_str());
2238 if (this->address_
!= NULL
)
2240 this->address_
->print(f
);
2244 if (this->script_section_type_
!= SCRIPT_SECTION_TYPE_NONE
)
2246 this->script_section_type_name(this->script_section_type_
));
2250 if (this->load_address_
!= NULL
)
2253 this->load_address_
->print(f
);
2257 if (this->align_
!= NULL
)
2259 fprintf(f
, "ALIGN(");
2260 this->align_
->print(f
);
2264 if (this->subalign_
!= NULL
)
2266 fprintf(f
, "SUBALIGN(");
2267 this->subalign_
->print(f
);
2273 for (Output_section_elements::const_iterator p
= this->elements_
.begin();
2274 p
!= this->elements_
.end();
2280 if (this->fill_
!= NULL
)
2283 this->fill_
->print(f
);
2286 if (this->phdrs_
!= NULL
)
2288 for (String_list::const_iterator p
= this->phdrs_
->begin();
2289 p
!= this->phdrs_
->end();
2291 fprintf(f
, " :%s", p
->c_str());
2297 Script_sections::Section_type
2298 Output_section_definition::section_type() const
2300 switch (this->script_section_type_
)
2302 case SCRIPT_SECTION_TYPE_NONE
:
2303 return Script_sections::ST_NONE
;
2304 case SCRIPT_SECTION_TYPE_NOLOAD
:
2305 return Script_sections::ST_NOLOAD
;
2306 case SCRIPT_SECTION_TYPE_COPY
:
2307 case SCRIPT_SECTION_TYPE_DSECT
:
2308 case SCRIPT_SECTION_TYPE_INFO
:
2309 case SCRIPT_SECTION_TYPE_OVERLAY
:
2310 // There are not really support so we treat them as ST_NONE. The
2311 // parse should have issued errors for them already.
2312 return Script_sections::ST_NONE
;
2318 // Return the name of a script section type.
2321 Output_section_definition::script_section_type_name (
2322 Script_section_type script_section_type
)
2324 switch (script_section_type
)
2326 case SCRIPT_SECTION_TYPE_NONE
:
2328 case SCRIPT_SECTION_TYPE_NOLOAD
:
2330 case SCRIPT_SECTION_TYPE_DSECT
:
2332 case SCRIPT_SECTION_TYPE_COPY
:
2334 case SCRIPT_SECTION_TYPE_INFO
:
2336 case SCRIPT_SECTION_TYPE_OVERLAY
:
2343 // An output section created to hold orphaned input sections. These
2344 // do not actually appear in linker scripts. However, for convenience
2345 // when setting the output section addresses, we put a marker to these
2346 // sections in the appropriate place in the list of SECTIONS elements.
2348 class Orphan_output_section
: public Sections_element
2351 Orphan_output_section(Output_section
* os
)
2355 // Return whether the orphan output section is relro. We can just
2356 // check the output section because we always set the flag, if
2357 // needed, just after we create the Orphan_output_section.
2360 { return this->os_
->is_relro(); }
2362 // Initialize OSP with an output section. This should have been
2365 orphan_section_init(Orphan_section_placement
*,
2366 Script_sections::Elements_iterator
)
2367 { gold_unreachable(); }
2369 // Set section addresses.
2371 set_section_addresses(Symbol_table
*, Layout
*, uint64_t*, uint64_t*,
2374 // Get the list of segments to use for an allocated section when
2375 // using a PHDRS clause.
2377 allocate_to_segment(String_list
**, bool*);
2379 // Return the associated Output_section.
2381 get_output_section() const
2382 { return this->os_
; }
2384 // Print for debugging.
2386 print(FILE* f
) const
2388 fprintf(f
, " marker for orphaned output section %s\n",
2393 Output_section
* os_
;
2396 // Set section addresses.
2399 Orphan_output_section::set_section_addresses(Symbol_table
*, Layout
*,
2400 uint64_t* dot_value
,
2402 uint64_t* load_address
)
2404 typedef std::list
<Output_section::Input_section
> Input_section_list
;
2406 bool have_load_address
= *load_address
!= *dot_value
;
2408 uint64_t address
= *dot_value
;
2409 address
= align_address(address
, this->os_
->addralign());
2411 if ((this->os_
->flags() & elfcpp::SHF_ALLOC
) != 0)
2413 this->os_
->set_address(address
);
2414 if (have_load_address
)
2415 this->os_
->set_load_address(align_address(*load_address
,
2416 this->os_
->addralign()));
2419 Input_section_list input_sections
;
2420 address
+= this->os_
->get_input_sections(address
, "", &input_sections
);
2422 for (Input_section_list::iterator p
= input_sections
.begin();
2423 p
!= input_sections
.end();
2426 uint64_t addralign
= p
->addralign();
2427 if (!p
->is_input_section())
2428 p
->output_section_data()->finalize_data_size();
2429 uint64_t size
= p
->data_size();
2430 address
= align_address(address
, addralign
);
2431 this->os_
->add_script_input_section(*p
);
2435 // An SHF_TLS/SHT_NOBITS section does not take up any address space.
2436 if (this->os_
== NULL
2437 || (this->os_
->flags() & elfcpp::SHF_TLS
) == 0
2438 || this->os_
->type() != elfcpp::SHT_NOBITS
)
2440 if (!have_load_address
)
2441 *load_address
= address
;
2443 *load_address
+= address
- *dot_value
;
2445 *dot_value
= address
;
2449 // Get the list of segments to use for an allocated section when using
2450 // a PHDRS clause. If this is an allocated section, return the
2451 // Output_section. We don't change the list of segments.
2454 Orphan_output_section::allocate_to_segment(String_list
**, bool* orphan
)
2456 if ((this->os_
->flags() & elfcpp::SHF_ALLOC
) == 0)
2462 // Class Phdrs_element. A program header from a PHDRS clause.
2467 Phdrs_element(const char* name
, size_t namelen
, unsigned int type
,
2468 bool includes_filehdr
, bool includes_phdrs
,
2469 bool is_flags_valid
, unsigned int flags
,
2470 Expression
* load_address
)
2471 : name_(name
, namelen
), type_(type
), includes_filehdr_(includes_filehdr
),
2472 includes_phdrs_(includes_phdrs
), is_flags_valid_(is_flags_valid
),
2473 flags_(flags
), load_address_(load_address
), load_address_value_(0),
2477 // Return the name of this segment.
2480 { return this->name_
; }
2482 // Return the type of the segment.
2485 { return this->type_
; }
2487 // Whether to include the file header.
2489 includes_filehdr() const
2490 { return this->includes_filehdr_
; }
2492 // Whether to include the program headers.
2494 includes_phdrs() const
2495 { return this->includes_phdrs_
; }
2497 // Return whether there is a load address.
2499 has_load_address() const
2500 { return this->load_address_
!= NULL
; }
2502 // Evaluate the load address expression if there is one.
2504 eval_load_address(Symbol_table
* symtab
, Layout
* layout
)
2506 if (this->load_address_
!= NULL
)
2507 this->load_address_value_
= this->load_address_
->eval(symtab
, layout
,
2511 // Return the load address.
2513 load_address() const
2515 gold_assert(this->load_address_
!= NULL
);
2516 return this->load_address_value_
;
2519 // Create the segment.
2521 create_segment(Layout
* layout
)
2523 this->segment_
= layout
->make_output_segment(this->type_
, this->flags_
);
2524 return this->segment_
;
2527 // Return the segment.
2530 { return this->segment_
; }
2532 // Release the segment.
2535 { this->segment_
= NULL
; }
2537 // Set the segment flags if appropriate.
2539 set_flags_if_valid()
2541 if (this->is_flags_valid_
)
2542 this->segment_
->set_flags(this->flags_
);
2545 // Print for debugging.
2550 // The name used in the script.
2552 // The type of the segment (PT_LOAD, etc.).
2554 // Whether this segment includes the file header.
2555 bool includes_filehdr_
;
2556 // Whether this segment includes the section headers.
2557 bool includes_phdrs_
;
2558 // Whether the flags were explicitly specified.
2559 bool is_flags_valid_
;
2560 // The flags for this segment (PF_R, etc.) if specified.
2561 unsigned int flags_
;
2562 // The expression for the load address for this segment. This may
2564 Expression
* load_address_
;
2565 // The actual load address from evaluating the expression.
2566 uint64_t load_address_value_
;
2567 // The segment itself.
2568 Output_segment
* segment_
;
2571 // Print for debugging.
2574 Phdrs_element::print(FILE* f
) const
2576 fprintf(f
, " %s 0x%x", this->name_
.c_str(), this->type_
);
2577 if (this->includes_filehdr_
)
2578 fprintf(f
, " FILEHDR");
2579 if (this->includes_phdrs_
)
2580 fprintf(f
, " PHDRS");
2581 if (this->is_flags_valid_
)
2582 fprintf(f
, " FLAGS(%u)", this->flags_
);
2583 if (this->load_address_
!= NULL
)
2586 this->load_address_
->print(f
);
2592 // Class Script_sections.
2594 Script_sections::Script_sections()
2595 : saw_sections_clause_(false),
2596 in_sections_clause_(false),
2597 sections_elements_(NULL
),
2598 output_section_(NULL
),
2599 phdrs_elements_(NULL
),
2600 orphan_section_placement_(NULL
),
2601 data_segment_align_start_(),
2602 saw_data_segment_align_(false),
2603 saw_relro_end_(false),
2604 saw_segment_start_expression_(false)
2608 // Start a SECTIONS clause.
2611 Script_sections::start_sections()
2613 gold_assert(!this->in_sections_clause_
&& this->output_section_
== NULL
);
2614 this->saw_sections_clause_
= true;
2615 this->in_sections_clause_
= true;
2616 if (this->sections_elements_
== NULL
)
2617 this->sections_elements_
= new Sections_elements
;
2620 // Finish a SECTIONS clause.
2623 Script_sections::finish_sections()
2625 gold_assert(this->in_sections_clause_
&& this->output_section_
== NULL
);
2626 this->in_sections_clause_
= false;
2629 // Add a symbol to be defined.
2632 Script_sections::add_symbol_assignment(const char* name
, size_t length
,
2633 Expression
* val
, bool provide
,
2636 if (this->output_section_
!= NULL
)
2637 this->output_section_
->add_symbol_assignment(name
, length
, val
,
2641 Sections_element
* p
= new Sections_element_assignment(name
, length
,
2644 this->sections_elements_
->push_back(p
);
2648 // Add an assignment to the special dot symbol.
2651 Script_sections::add_dot_assignment(Expression
* val
)
2653 if (this->output_section_
!= NULL
)
2654 this->output_section_
->add_dot_assignment(val
);
2657 // The GNU linker permits assignments to . to appears outside of
2658 // a SECTIONS clause, and treats it as appearing inside, so
2659 // sections_elements_ may be NULL here.
2660 if (this->sections_elements_
== NULL
)
2662 this->sections_elements_
= new Sections_elements
;
2663 this->saw_sections_clause_
= true;
2666 Sections_element
* p
= new Sections_element_dot_assignment(val
);
2667 this->sections_elements_
->push_back(p
);
2671 // Add an assertion.
2674 Script_sections::add_assertion(Expression
* check
, const char* message
,
2677 if (this->output_section_
!= NULL
)
2678 this->output_section_
->add_assertion(check
, message
, messagelen
);
2681 Sections_element
* p
= new Sections_element_assertion(check
, message
,
2683 this->sections_elements_
->push_back(p
);
2687 // Start processing entries for an output section.
2690 Script_sections::start_output_section(
2693 const Parser_output_section_header
*header
)
2695 Output_section_definition
* posd
= new Output_section_definition(name
,
2698 this->sections_elements_
->push_back(posd
);
2699 gold_assert(this->output_section_
== NULL
);
2700 this->output_section_
= posd
;
2703 // Stop processing entries for an output section.
2706 Script_sections::finish_output_section(
2707 const Parser_output_section_trailer
* trailer
)
2709 gold_assert(this->output_section_
!= NULL
);
2710 this->output_section_
->finish(trailer
);
2711 this->output_section_
= NULL
;
2714 // Add a data item to the current output section.
2717 Script_sections::add_data(int size
, bool is_signed
, Expression
* val
)
2719 gold_assert(this->output_section_
!= NULL
);
2720 this->output_section_
->add_data(size
, is_signed
, val
);
2723 // Add a fill value setting to the current output section.
2726 Script_sections::add_fill(Expression
* val
)
2728 gold_assert(this->output_section_
!= NULL
);
2729 this->output_section_
->add_fill(val
);
2732 // Add an input section specification to the current output section.
2735 Script_sections::add_input_section(const Input_section_spec
* spec
, bool keep
)
2737 gold_assert(this->output_section_
!= NULL
);
2738 this->output_section_
->add_input_section(spec
, keep
);
2741 // This is called when we see DATA_SEGMENT_ALIGN. It means that any
2742 // subsequent output sections may be relro.
2745 Script_sections::data_segment_align()
2747 if (this->saw_data_segment_align_
)
2748 gold_error(_("DATA_SEGMENT_ALIGN may only appear once in a linker script"));
2749 gold_assert(!this->sections_elements_
->empty());
2750 Sections_elements::iterator p
= this->sections_elements_
->end();
2752 this->data_segment_align_start_
= p
;
2753 this->saw_data_segment_align_
= true;
2756 // This is called when we see DATA_SEGMENT_RELRO_END. It means that
2757 // any output sections seen since DATA_SEGMENT_ALIGN are relro.
2760 Script_sections::data_segment_relro_end()
2762 if (this->saw_relro_end_
)
2763 gold_error(_("DATA_SEGMENT_RELRO_END may only appear once "
2764 "in a linker script"));
2765 this->saw_relro_end_
= true;
2767 if (!this->saw_data_segment_align_
)
2768 gold_error(_("DATA_SEGMENT_RELRO_END must follow DATA_SEGMENT_ALIGN"));
2771 Sections_elements::iterator p
= this->data_segment_align_start_
;
2772 for (++p
; p
!= this->sections_elements_
->end(); ++p
)
2773 (*p
)->set_is_relro();
2777 // Create any required sections.
2780 Script_sections::create_sections(Layout
* layout
)
2782 if (!this->saw_sections_clause_
)
2784 for (Sections_elements::iterator p
= this->sections_elements_
->begin();
2785 p
!= this->sections_elements_
->end();
2787 (*p
)->create_sections(layout
);
2790 // Add any symbols we are defining to the symbol table.
2793 Script_sections::add_symbols_to_table(Symbol_table
* symtab
)
2795 if (!this->saw_sections_clause_
)
2797 for (Sections_elements::iterator p
= this->sections_elements_
->begin();
2798 p
!= this->sections_elements_
->end();
2800 (*p
)->add_symbols_to_table(symtab
);
2803 // Finalize symbols and check assertions.
2806 Script_sections::finalize_symbols(Symbol_table
* symtab
, const Layout
* layout
)
2808 if (!this->saw_sections_clause_
)
2810 uint64_t dot_value
= 0;
2811 for (Sections_elements::iterator p
= this->sections_elements_
->begin();
2812 p
!= this->sections_elements_
->end();
2814 (*p
)->finalize_symbols(symtab
, layout
, &dot_value
);
2817 // Return the name of the output section to use for an input file name
2818 // and section name.
2821 Script_sections::output_section_name(
2822 const char* file_name
,
2823 const char* section_name
,
2824 Output_section
*** output_section_slot
,
2825 Script_sections::Section_type
*psection_type
)
2827 for (Sections_elements::const_iterator p
= this->sections_elements_
->begin();
2828 p
!= this->sections_elements_
->end();
2831 const char* ret
= (*p
)->output_section_name(file_name
, section_name
,
2832 output_section_slot
,
2837 // The special name /DISCARD/ means that the input section
2838 // should be discarded.
2839 if (strcmp(ret
, "/DISCARD/") == 0)
2841 *output_section_slot
= NULL
;
2842 *psection_type
= Script_sections::ST_NONE
;
2849 // If we couldn't find a mapping for the name, the output section
2850 // gets the name of the input section.
2852 *output_section_slot
= NULL
;
2853 *psection_type
= Script_sections::ST_NONE
;
2855 return section_name
;
2858 // Place a marker for an orphan output section into the SECTIONS
2862 Script_sections::place_orphan(Output_section
* os
)
2864 Orphan_section_placement
* osp
= this->orphan_section_placement_
;
2867 // Initialize the Orphan_section_placement structure.
2868 osp
= new Orphan_section_placement();
2869 for (Sections_elements::iterator p
= this->sections_elements_
->begin();
2870 p
!= this->sections_elements_
->end();
2872 (*p
)->orphan_section_init(osp
, p
);
2873 gold_assert(!this->sections_elements_
->empty());
2874 Sections_elements::iterator last
= this->sections_elements_
->end();
2876 osp
->last_init(last
);
2877 this->orphan_section_placement_
= osp
;
2880 Orphan_output_section
* orphan
= new Orphan_output_section(os
);
2882 // Look for where to put ORPHAN.
2883 Sections_elements::iterator
* where
;
2884 if (osp
->find_place(os
, &where
))
2886 if ((**where
)->is_relro())
2889 os
->clear_is_relro();
2891 // We want to insert ORPHAN after *WHERE, and then update *WHERE
2892 // so that the next one goes after this one.
2893 Sections_elements::iterator p
= *where
;
2894 gold_assert(p
!= this->sections_elements_
->end());
2896 *where
= this->sections_elements_
->insert(p
, orphan
);
2900 os
->clear_is_relro();
2901 // We don't have a place to put this orphan section. Put it,
2902 // and all other sections like it, at the end, but before the
2903 // sections which always come at the end.
2904 Sections_elements::iterator last
= osp
->last_place();
2905 *where
= this->sections_elements_
->insert(last
, orphan
);
2909 // Set the addresses of all the output sections. Walk through all the
2910 // elements, tracking the dot symbol. Apply assignments which set
2911 // absolute symbol values, in case they are used when setting dot.
2912 // Fill in data statement values. As we find output sections, set the
2913 // address, set the address of all associated input sections, and
2914 // update dot. Return the segment which should hold the file header
2915 // and segment headers, if any.
2918 Script_sections::set_section_addresses(Symbol_table
* symtab
, Layout
* layout
)
2920 gold_assert(this->saw_sections_clause_
);
2922 // Implement ONLY_IF_RO/ONLY_IF_RW constraints. These are a pain
2923 // for our representation.
2924 for (Sections_elements::iterator p
= this->sections_elements_
->begin();
2925 p
!= this->sections_elements_
->end();
2928 Output_section_definition
* posd
;
2929 Section_constraint failed_constraint
= (*p
)->check_constraint(&posd
);
2930 if (failed_constraint
!= CONSTRAINT_NONE
)
2932 Sections_elements::iterator q
;
2933 for (q
= this->sections_elements_
->begin();
2934 q
!= this->sections_elements_
->end();
2939 if ((*q
)->alternate_constraint(posd
, failed_constraint
))
2944 if (q
== this->sections_elements_
->end())
2945 gold_error(_("no matching section constraint"));
2949 // Force the alignment of the first TLS section to be the maximum
2950 // alignment of all TLS sections.
2951 Output_section
* first_tls
= NULL
;
2952 uint64_t tls_align
= 0;
2953 for (Sections_elements::const_iterator p
= this->sections_elements_
->begin();
2954 p
!= this->sections_elements_
->end();
2957 Output_section
*os
= (*p
)->get_output_section();
2958 if (os
!= NULL
&& (os
->flags() & elfcpp::SHF_TLS
) != 0)
2960 if (first_tls
== NULL
)
2962 if (os
->addralign() > tls_align
)
2963 tls_align
= os
->addralign();
2966 if (first_tls
!= NULL
)
2967 first_tls
->set_addralign(tls_align
);
2969 // For a relocatable link, we implicitly set dot to zero.
2970 uint64_t dot_value
= 0;
2971 uint64_t dot_alignment
= 0;
2972 uint64_t load_address
= 0;
2974 // Check to see if we want to use any of -Ttext, -Tdata and -Tbss options
2975 // to set section addresses. If the script has any SEGMENT_START
2976 // expression, we do not set the section addresses.
2977 bool use_tsection_options
=
2978 (!this->saw_segment_start_expression_
2979 && (parameters
->options().user_set_Ttext()
2980 || parameters
->options().user_set_Tdata()
2981 || parameters
->options().user_set_Tbss()));
2983 for (Sections_elements::iterator p
= this->sections_elements_
->begin();
2984 p
!= this->sections_elements_
->end();
2987 Output_section
* os
= (*p
)->get_output_section();
2989 // Handle -Ttext, -Tdata and -Tbss options. We do this by looking for
2990 // the special sections by names and doing dot assignments.
2991 if (use_tsection_options
2993 && (os
->flags() & elfcpp::SHF_ALLOC
) != 0)
2995 uint64_t new_dot_value
= dot_value
;
2997 if (parameters
->options().user_set_Ttext()
2998 && strcmp(os
->name(), ".text") == 0)
2999 new_dot_value
= parameters
->options().Ttext();
3000 else if (parameters
->options().user_set_Tdata()
3001 && strcmp(os
->name(), ".data") == 0)
3002 new_dot_value
= parameters
->options().Tdata();
3003 else if (parameters
->options().user_set_Tbss()
3004 && strcmp(os
->name(), ".bss") == 0)
3005 new_dot_value
= parameters
->options().Tbss();
3007 // Update dot and load address if necessary.
3008 if (new_dot_value
< dot_value
)
3009 gold_error(_("dot may not move backward"));
3010 else if (new_dot_value
!= dot_value
)
3012 dot_value
= new_dot_value
;
3013 load_address
= new_dot_value
;
3017 (*p
)->set_section_addresses(symtab
, layout
, &dot_value
, &dot_alignment
,
3021 if (this->phdrs_elements_
!= NULL
)
3023 for (Phdrs_elements::iterator p
= this->phdrs_elements_
->begin();
3024 p
!= this->phdrs_elements_
->end();
3026 (*p
)->eval_load_address(symtab
, layout
);
3029 return this->create_segments(layout
, dot_alignment
);
3032 // Sort the sections in order to put them into segments.
3034 class Sort_output_sections
3038 operator()(const Output_section
* os1
, const Output_section
* os2
) const;
3042 Sort_output_sections::operator()(const Output_section
* os1
,
3043 const Output_section
* os2
) const
3045 // Sort first by the load address.
3046 uint64_t lma1
= (os1
->has_load_address()
3047 ? os1
->load_address()
3049 uint64_t lma2
= (os2
->has_load_address()
3050 ? os2
->load_address()
3055 // Then sort by the virtual address.
3056 if (os1
->address() != os2
->address())
3057 return os1
->address() < os2
->address();
3059 // Sort TLS sections to the end.
3060 bool tls1
= (os1
->flags() & elfcpp::SHF_TLS
) != 0;
3061 bool tls2
= (os2
->flags() & elfcpp::SHF_TLS
) != 0;
3065 // Sort PROGBITS before NOBITS.
3066 if (os1
->type() == elfcpp::SHT_PROGBITS
&& os2
->type() == elfcpp::SHT_NOBITS
)
3068 if (os1
->type() == elfcpp::SHT_NOBITS
&& os2
->type() == elfcpp::SHT_PROGBITS
)
3071 // Sort non-NOLOAD before NOLOAD.
3072 if (os1
->is_noload() && !os2
->is_noload())
3074 if (!os1
->is_noload() && os2
->is_noload())
3077 // Otherwise we don't care.
3081 // Return whether OS is a BSS section. This is a SHT_NOBITS section.
3082 // We treat a section with the SHF_TLS flag set as taking up space
3083 // even if it is SHT_NOBITS (this is true of .tbss), as we allocate
3084 // space for them in the file.
3087 Script_sections::is_bss_section(const Output_section
* os
)
3089 return (os
->type() == elfcpp::SHT_NOBITS
3090 && (os
->flags() & elfcpp::SHF_TLS
) == 0);
3093 // Return the size taken by the file header and the program headers.
3096 Script_sections::total_header_size(Layout
* layout
) const
3098 size_t segment_count
= layout
->segment_count();
3099 size_t file_header_size
;
3100 size_t segment_headers_size
;
3101 if (parameters
->target().get_size() == 32)
3103 file_header_size
= elfcpp::Elf_sizes
<32>::ehdr_size
;
3104 segment_headers_size
= segment_count
* elfcpp::Elf_sizes
<32>::phdr_size
;
3106 else if (parameters
->target().get_size() == 64)
3108 file_header_size
= elfcpp::Elf_sizes
<64>::ehdr_size
;
3109 segment_headers_size
= segment_count
* elfcpp::Elf_sizes
<64>::phdr_size
;
3114 return file_header_size
+ segment_headers_size
;
3117 // Return the amount we have to subtract from the LMA to accomodate
3118 // headers of the given size. The complication is that the file
3119 // header have to be at the start of a page, as otherwise it will not
3120 // be at the start of the file.
3123 Script_sections::header_size_adjustment(uint64_t lma
,
3124 size_t sizeof_headers
) const
3126 const uint64_t abi_pagesize
= parameters
->target().abi_pagesize();
3127 uint64_t hdr_lma
= lma
- sizeof_headers
;
3128 hdr_lma
&= ~(abi_pagesize
- 1);
3129 return lma
- hdr_lma
;
3132 // Create the PT_LOAD segments when using a SECTIONS clause. Returns
3133 // the segment which should hold the file header and segment headers,
3137 Script_sections::create_segments(Layout
* layout
, uint64_t dot_alignment
)
3139 gold_assert(this->saw_sections_clause_
);
3141 if (parameters
->options().relocatable())
3144 if (this->saw_phdrs_clause())
3145 return create_segments_from_phdrs_clause(layout
, dot_alignment
);
3147 Layout::Section_list sections
;
3148 layout
->get_allocated_sections(§ions
);
3150 // Sort the sections by address.
3151 std::stable_sort(sections
.begin(), sections
.end(), Sort_output_sections());
3153 this->create_note_and_tls_segments(layout
, §ions
);
3155 // Walk through the sections adding them to PT_LOAD segments.
3156 const uint64_t abi_pagesize
= parameters
->target().abi_pagesize();
3157 Output_segment
* first_seg
= NULL
;
3158 Output_segment
* current_seg
= NULL
;
3159 bool is_current_seg_readonly
= true;
3160 Layout::Section_list::iterator plast
= sections
.end();
3161 uint64_t last_vma
= 0;
3162 uint64_t last_lma
= 0;
3163 uint64_t last_size
= 0;
3164 for (Layout::Section_list::iterator p
= sections
.begin();
3165 p
!= sections
.end();
3168 const uint64_t vma
= (*p
)->address();
3169 const uint64_t lma
= ((*p
)->has_load_address()
3170 ? (*p
)->load_address()
3172 const uint64_t size
= (*p
)->current_data_size();
3174 bool need_new_segment
;
3175 if (current_seg
== NULL
)
3176 need_new_segment
= true;
3177 else if (lma
- vma
!= last_lma
- last_vma
)
3179 // This section has a different LMA relationship than the
3180 // last one; we need a new segment.
3181 need_new_segment
= true;
3183 else if (align_address(last_lma
+ last_size
, abi_pagesize
)
3184 < align_address(lma
, abi_pagesize
))
3186 // Putting this section in the segment would require
3188 need_new_segment
= true;
3190 else if (is_bss_section(*plast
) && !is_bss_section(*p
))
3192 // A non-BSS section can not follow a BSS section in the
3194 need_new_segment
= true;
3196 else if (is_current_seg_readonly
3197 && ((*p
)->flags() & elfcpp::SHF_WRITE
) != 0
3198 && !parameters
->options().omagic())
3200 // Don't put a writable section in the same segment as a
3201 // non-writable section.
3202 need_new_segment
= true;
3206 // Otherwise, reuse the existing segment.
3207 need_new_segment
= false;
3210 elfcpp::Elf_Word seg_flags
=
3211 Layout::section_flags_to_segment((*p
)->flags());
3213 if (need_new_segment
)
3215 current_seg
= layout
->make_output_segment(elfcpp::PT_LOAD
,
3217 current_seg
->set_addresses(vma
, lma
);
3218 current_seg
->set_minimum_p_align(dot_alignment
);
3219 if (first_seg
== NULL
)
3220 first_seg
= current_seg
;
3221 is_current_seg_readonly
= true;
3224 current_seg
->add_output_section(*p
, seg_flags
, false);
3226 if (((*p
)->flags() & elfcpp::SHF_WRITE
) != 0)
3227 is_current_seg_readonly
= false;
3235 // An ELF program should work even if the program headers are not in
3236 // a PT_LOAD segment. However, it appears that the Linux kernel
3237 // does not set the AT_PHDR auxiliary entry in that case. It sets
3238 // the load address to p_vaddr - p_offset of the first PT_LOAD
3239 // segment. It then sets AT_PHDR to the load address plus the
3240 // offset to the program headers, e_phoff in the file header. This
3241 // fails when the program headers appear in the file before the
3242 // first PT_LOAD segment. Therefore, we always create a PT_LOAD
3243 // segment to hold the file header and the program headers. This is
3244 // effectively what the GNU linker does, and it is slightly more
3245 // efficient in any case. We try to use the first PT_LOAD segment
3246 // if we can, otherwise we make a new one.
3248 if (first_seg
== NULL
)
3251 // -n or -N mean that the program is not demand paged and there is
3252 // no need to put the program headers in a PT_LOAD segment.
3253 if (parameters
->options().nmagic() || parameters
->options().omagic())
3256 size_t sizeof_headers
= this->total_header_size(layout
);
3258 uint64_t vma
= first_seg
->vaddr();
3259 uint64_t lma
= first_seg
->paddr();
3261 uint64_t subtract
= this->header_size_adjustment(lma
, sizeof_headers
);
3263 if ((lma
& (abi_pagesize
- 1)) >= sizeof_headers
)
3265 first_seg
->set_addresses(vma
- subtract
, lma
- subtract
);
3269 // If there is no room to squeeze in the headers, then punt. The
3270 // resulting executable probably won't run on GNU/Linux, but we
3271 // trust that the user knows what they are doing.
3272 if (lma
< subtract
|| vma
< subtract
)
3275 Output_segment
* load_seg
= layout
->make_output_segment(elfcpp::PT_LOAD
,
3277 load_seg
->set_addresses(vma
- subtract
, lma
- subtract
);
3282 // Create a PT_NOTE segment for each SHT_NOTE section and a PT_TLS
3283 // segment if there are any SHT_TLS sections.
3286 Script_sections::create_note_and_tls_segments(
3288 const Layout::Section_list
* sections
)
3290 gold_assert(!this->saw_phdrs_clause());
3292 bool saw_tls
= false;
3293 for (Layout::Section_list::const_iterator p
= sections
->begin();
3294 p
!= sections
->end();
3297 if ((*p
)->type() == elfcpp::SHT_NOTE
)
3299 elfcpp::Elf_Word seg_flags
=
3300 Layout::section_flags_to_segment((*p
)->flags());
3301 Output_segment
* oseg
= layout
->make_output_segment(elfcpp::PT_NOTE
,
3303 oseg
->add_output_section(*p
, seg_flags
, false);
3305 // Incorporate any subsequent SHT_NOTE sections, in the
3306 // hopes that the script is sensible.
3307 Layout::Section_list::const_iterator pnext
= p
+ 1;
3308 while (pnext
!= sections
->end()
3309 && (*pnext
)->type() == elfcpp::SHT_NOTE
)
3311 seg_flags
= Layout::section_flags_to_segment((*pnext
)->flags());
3312 oseg
->add_output_section(*pnext
, seg_flags
, false);
3318 if (((*p
)->flags() & elfcpp::SHF_TLS
) != 0)
3321 gold_error(_("TLS sections are not adjacent"));
3323 elfcpp::Elf_Word seg_flags
=
3324 Layout::section_flags_to_segment((*p
)->flags());
3325 Output_segment
* oseg
= layout
->make_output_segment(elfcpp::PT_TLS
,
3327 oseg
->add_output_section(*p
, seg_flags
, false);
3329 Layout::Section_list::const_iterator pnext
= p
+ 1;
3330 while (pnext
!= sections
->end()
3331 && ((*pnext
)->flags() & elfcpp::SHF_TLS
) != 0)
3333 seg_flags
= Layout::section_flags_to_segment((*pnext
)->flags());
3334 oseg
->add_output_section(*pnext
, seg_flags
, false);
3344 // Add a program header. The PHDRS clause is syntactically distinct
3345 // from the SECTIONS clause, but we implement it with the SECTIONS
3346 // support because PHDRS is useless if there is no SECTIONS clause.
3349 Script_sections::add_phdr(const char* name
, size_t namelen
, unsigned int type
,
3350 bool includes_filehdr
, bool includes_phdrs
,
3351 bool is_flags_valid
, unsigned int flags
,
3352 Expression
* load_address
)
3354 if (this->phdrs_elements_
== NULL
)
3355 this->phdrs_elements_
= new Phdrs_elements();
3356 this->phdrs_elements_
->push_back(new Phdrs_element(name
, namelen
, type
,
3359 is_flags_valid
, flags
,
3363 // Return the number of segments we expect to create based on the
3364 // SECTIONS clause. This is used to implement SIZEOF_HEADERS.
3367 Script_sections::expected_segment_count(const Layout
* layout
) const
3369 if (this->saw_phdrs_clause())
3370 return this->phdrs_elements_
->size();
3372 Layout::Section_list sections
;
3373 layout
->get_allocated_sections(§ions
);
3375 // We assume that we will need two PT_LOAD segments.
3378 bool saw_note
= false;
3379 bool saw_tls
= false;
3380 for (Layout::Section_list::const_iterator p
= sections
.begin();
3381 p
!= sections
.end();
3384 if ((*p
)->type() == elfcpp::SHT_NOTE
)
3386 // Assume that all note sections will fit into a single
3394 else if (((*p
)->flags() & elfcpp::SHF_TLS
) != 0)
3396 // There can only be one PT_TLS segment.
3408 // Create the segments from a PHDRS clause. Return the segment which
3409 // should hold the file header and program headers, if any.
3412 Script_sections::create_segments_from_phdrs_clause(Layout
* layout
,
3413 uint64_t dot_alignment
)
3415 this->attach_sections_using_phdrs_clause(layout
);
3416 return this->set_phdrs_clause_addresses(layout
, dot_alignment
);
3419 // Create the segments from the PHDRS clause, and put the output
3420 // sections in them.
3423 Script_sections::attach_sections_using_phdrs_clause(Layout
* layout
)
3425 typedef std::map
<std::string
, Output_segment
*> Name_to_segment
;
3426 Name_to_segment name_to_segment
;
3427 for (Phdrs_elements::const_iterator p
= this->phdrs_elements_
->begin();
3428 p
!= this->phdrs_elements_
->end();
3430 name_to_segment
[(*p
)->name()] = (*p
)->create_segment(layout
);
3432 // Walk through the output sections and attach them to segments.
3433 // Output sections in the script which do not list segments are
3434 // attached to the same set of segments as the immediately preceding
3437 String_list
* phdr_names
= NULL
;
3438 bool load_segments_only
= false;
3439 for (Sections_elements::const_iterator p
= this->sections_elements_
->begin();
3440 p
!= this->sections_elements_
->end();
3444 String_list
* old_phdr_names
= phdr_names
;
3445 Output_section
* os
= (*p
)->allocate_to_segment(&phdr_names
, &orphan
);
3449 if (phdr_names
== NULL
)
3451 gold_error(_("allocated section not in any segment"));
3455 // We see a list of segments names. Disable PT_LOAD segment only
3457 if (old_phdr_names
!= phdr_names
)
3458 load_segments_only
= false;
3460 // If this is an orphan section--one that was not explicitly
3461 // mentioned in the linker script--then it should not inherit
3462 // any segment type other than PT_LOAD. Otherwise, e.g., the
3463 // PT_INTERP segment will pick up following orphan sections,
3464 // which does not make sense. If this is not an orphan section,
3465 // we trust the linker script.
3468 // Enable PT_LOAD segments only filtering until we see another
3469 // list of segment names.
3470 load_segments_only
= true;
3473 bool in_load_segment
= false;
3474 for (String_list::const_iterator q
= phdr_names
->begin();
3475 q
!= phdr_names
->end();
3478 Name_to_segment::const_iterator r
= name_to_segment
.find(*q
);
3479 if (r
== name_to_segment
.end())
3480 gold_error(_("no segment %s"), q
->c_str());
3483 if (load_segments_only
3484 && r
->second
->type() != elfcpp::PT_LOAD
)
3487 elfcpp::Elf_Word seg_flags
=
3488 Layout::section_flags_to_segment(os
->flags());
3489 r
->second
->add_output_section(os
, seg_flags
, false);
3491 if (r
->second
->type() == elfcpp::PT_LOAD
)
3493 if (in_load_segment
)
3494 gold_error(_("section in two PT_LOAD segments"));
3495 in_load_segment
= true;
3500 if (!in_load_segment
)
3501 gold_error(_("allocated section not in any PT_LOAD segment"));
3505 // Set the addresses for segments created from a PHDRS clause. Return
3506 // the segment which should hold the file header and program headers,
3510 Script_sections::set_phdrs_clause_addresses(Layout
* layout
,
3511 uint64_t dot_alignment
)
3513 Output_segment
* load_seg
= NULL
;
3514 for (Phdrs_elements::const_iterator p
= this->phdrs_elements_
->begin();
3515 p
!= this->phdrs_elements_
->end();
3518 // Note that we have to set the flags after adding the output
3519 // sections to the segment, as adding an output segment can
3520 // change the flags.
3521 (*p
)->set_flags_if_valid();
3523 Output_segment
* oseg
= (*p
)->segment();
3525 if (oseg
->type() != elfcpp::PT_LOAD
)
3527 // The addresses of non-PT_LOAD segments are set from the
3528 // PT_LOAD segments.
3529 if ((*p
)->has_load_address())
3530 gold_error(_("may only specify load address for PT_LOAD segment"));
3534 oseg
->set_minimum_p_align(dot_alignment
);
3536 // The output sections should have addresses from the SECTIONS
3537 // clause. The addresses don't have to be in order, so find the
3538 // one with the lowest load address. Use that to set the
3539 // address of the segment.
3541 Output_section
* osec
= oseg
->section_with_lowest_load_address();
3544 oseg
->set_addresses(0, 0);
3548 uint64_t vma
= osec
->address();
3549 uint64_t lma
= osec
->has_load_address() ? osec
->load_address() : vma
;
3551 // Override the load address of the section with the load
3552 // address specified for the segment.
3553 if ((*p
)->has_load_address())
3555 if (osec
->has_load_address())
3556 gold_warning(_("PHDRS load address overrides "
3557 "section %s load address"),
3560 lma
= (*p
)->load_address();
3563 bool headers
= (*p
)->includes_filehdr() && (*p
)->includes_phdrs();
3564 if (!headers
&& ((*p
)->includes_filehdr() || (*p
)->includes_phdrs()))
3566 // We could support this if we wanted to.
3567 gold_error(_("using only one of FILEHDR and PHDRS is "
3568 "not currently supported"));
3572 size_t sizeof_headers
= this->total_header_size(layout
);
3573 uint64_t subtract
= this->header_size_adjustment(lma
,
3575 if (lma
>= subtract
&& vma
>= subtract
)
3582 gold_error(_("sections loaded on first page without room "
3583 "for file and program headers "
3584 "are not supported"));
3587 if (load_seg
!= NULL
)
3588 gold_error(_("using FILEHDR and PHDRS on more than one "
3589 "PT_LOAD segment is not currently supported"));
3593 oseg
->set_addresses(vma
, lma
);
3599 // Add the file header and segment headers to non-load segments
3600 // specified in the PHDRS clause.
3603 Script_sections::put_headers_in_phdrs(Output_data
* file_header
,
3604 Output_data
* segment_headers
)
3606 gold_assert(this->saw_phdrs_clause());
3607 for (Phdrs_elements::iterator p
= this->phdrs_elements_
->begin();
3608 p
!= this->phdrs_elements_
->end();
3611 if ((*p
)->type() != elfcpp::PT_LOAD
)
3613 if ((*p
)->includes_phdrs())
3614 (*p
)->segment()->add_initial_output_data(segment_headers
);
3615 if ((*p
)->includes_filehdr())
3616 (*p
)->segment()->add_initial_output_data(file_header
);
3621 // Look for an output section by name and return the address, the load
3622 // address, the alignment, and the size. This is used when an
3623 // expression refers to an output section which was not actually
3624 // created. This returns true if the section was found, false
3628 Script_sections::get_output_section_info(const char* name
, uint64_t* address
,
3629 uint64_t* load_address
,
3630 uint64_t* addralign
,
3631 uint64_t* size
) const
3633 if (!this->saw_sections_clause_
)
3635 for (Sections_elements::const_iterator p
= this->sections_elements_
->begin();
3636 p
!= this->sections_elements_
->end();
3638 if ((*p
)->get_output_section_info(name
, address
, load_address
, addralign
,
3644 // Release all Output_segments. This remove all pointers to all
3648 Script_sections::release_segments()
3650 if (this->saw_phdrs_clause())
3652 for (Phdrs_elements::const_iterator p
= this->phdrs_elements_
->begin();
3653 p
!= this->phdrs_elements_
->end();
3655 (*p
)->release_segment();
3659 // Print the SECTIONS clause to F for debugging.
3662 Script_sections::print(FILE* f
) const
3664 if (!this->saw_sections_clause_
)
3667 fprintf(f
, "SECTIONS {\n");
3669 for (Sections_elements::const_iterator p
= this->sections_elements_
->begin();
3670 p
!= this->sections_elements_
->end();
3676 if (this->phdrs_elements_
!= NULL
)
3678 fprintf(f
, "PHDRS {\n");
3679 for (Phdrs_elements::const_iterator p
= this->phdrs_elements_
->begin();
3680 p
!= this->phdrs_elements_
->end();
3687 } // End namespace gold.