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.
96 // The information we keep for a specific place.
99 // The name of sections for this place.
101 // Whether we have a location for this place.
103 // The iterator for this place.
104 Elements_iterator location
;
107 // Initialize one place element.
109 initialize_place(Place_index
, const char*);
112 Place places_
[PLACE_MAX
];
113 // True if this is the first call to output_section_init.
117 // Initialize Orphan_section_placement.
119 Orphan_section_placement::Orphan_section_placement()
122 this->initialize_place(PLACE_TEXT
, ".text");
123 this->initialize_place(PLACE_RODATA
, ".rodata");
124 this->initialize_place(PLACE_DATA
, ".data");
125 this->initialize_place(PLACE_BSS
, ".bss");
126 this->initialize_place(PLACE_REL
, NULL
);
127 this->initialize_place(PLACE_INTERP
, ".interp");
128 this->initialize_place(PLACE_NONALLOC
, NULL
);
129 this->initialize_place(PLACE_LAST
, NULL
);
132 // Initialize one place element.
135 Orphan_section_placement::initialize_place(Place_index index
, const char* name
)
137 this->places_
[index
].name
= name
;
138 this->places_
[index
].have_location
= false;
141 // While initializing the Orphan_section_placement information, this
142 // is called once for each output section named in the linker script.
143 // If we found an output section during the link, it will be passed in
147 Orphan_section_placement::output_section_init(const std::string
& name
,
149 Elements_iterator location
)
151 bool first_init
= this->first_init_
;
152 this->first_init_
= false;
154 for (int i
= 0; i
< PLACE_MAX
; ++i
)
156 if (this->places_
[i
].name
!= NULL
&& this->places_
[i
].name
== name
)
158 if (this->places_
[i
].have_location
)
160 // We have already seen a section with this name.
164 this->places_
[i
].location
= location
;
165 this->places_
[i
].have_location
= true;
167 // If we just found the .bss section, restart the search for
168 // an unallocated section. This follows the GNU linker's
171 this->places_
[PLACE_NONALLOC
].have_location
= false;
177 // Relocation sections.
178 if (!this->places_
[PLACE_REL
].have_location
180 && (os
->type() == elfcpp::SHT_REL
|| os
->type() == elfcpp::SHT_RELA
)
181 && (os
->flags() & elfcpp::SHF_ALLOC
) != 0)
183 this->places_
[PLACE_REL
].location
= location
;
184 this->places_
[PLACE_REL
].have_location
= true;
187 // We find the location for unallocated sections by finding the
188 // first debugging or comment section after the BSS section (if
190 if (!this->places_
[PLACE_NONALLOC
].have_location
191 && (name
== ".comment" || Layout::is_debug_info_section(name
.c_str())))
193 // We add orphan sections after the location in PLACES_. We
194 // want to store unallocated sections before LOCATION. If this
195 // is the very first section, we can't use it.
199 this->places_
[PLACE_NONALLOC
].location
= location
;
200 this->places_
[PLACE_NONALLOC
].have_location
= true;
205 // Initialize the last location.
208 Orphan_section_placement::last_init(Elements_iterator location
)
210 this->places_
[PLACE_LAST
].location
= location
;
211 this->places_
[PLACE_LAST
].have_location
= true;
214 // Set *PWHERE to the address of an iterator pointing to the location
215 // to use for an orphan section. Return true if the iterator has a
216 // value, false otherwise.
219 Orphan_section_placement::find_place(Output_section
* os
,
220 Elements_iterator
** pwhere
)
222 // Figure out where OS should go. This is based on the GNU linker
223 // code. FIXME: The GNU linker handles small data sections
224 // specially, but we don't.
225 elfcpp::Elf_Word type
= os
->type();
226 elfcpp::Elf_Xword flags
= os
->flags();
228 if ((flags
& elfcpp::SHF_ALLOC
) == 0
229 && !Layout::is_debug_info_section(os
->name()))
230 index
= PLACE_NONALLOC
;
231 else if ((flags
& elfcpp::SHF_ALLOC
) == 0)
233 else if (type
== elfcpp::SHT_NOTE
)
234 index
= PLACE_INTERP
;
235 else if (type
== elfcpp::SHT_NOBITS
)
237 else if ((flags
& elfcpp::SHF_WRITE
) != 0)
239 else if (type
== elfcpp::SHT_REL
|| type
== elfcpp::SHT_RELA
)
241 else if ((flags
& elfcpp::SHF_EXECINSTR
) == 0)
242 index
= PLACE_RODATA
;
246 // If we don't have a location yet, try to find one based on a
247 // plausible ordering of sections.
248 if (!this->places_
[index
].have_location
)
269 if (follow
!= PLACE_MAX
&& this->places_
[follow
].have_location
)
271 // Set the location of INDEX to the location of FOLLOW. The
272 // location of INDEX will then be incremented by the caller,
273 // so anything in INDEX will continue to be after anything
275 this->places_
[index
].location
= this->places_
[follow
].location
;
276 this->places_
[index
].have_location
= true;
280 *pwhere
= &this->places_
[index
].location
;
281 bool ret
= this->places_
[index
].have_location
;
283 // The caller will set the location.
284 this->places_
[index
].have_location
= true;
289 // Return the iterator being used for sections at the very end of the
292 Orphan_section_placement::Elements_iterator
293 Orphan_section_placement::last_place() const
295 gold_assert(this->places_
[PLACE_LAST
].have_location
);
296 return this->places_
[PLACE_LAST
].location
;
299 // An element in a SECTIONS clause.
301 class Sections_element
307 virtual ~Sections_element()
310 // Return whether an output section is relro.
315 // Record that an output section is relro.
320 // Create any required output sections. The only real
321 // implementation is in Output_section_definition.
323 create_sections(Layout
*)
326 // Add any symbol being defined to the symbol table.
328 add_symbols_to_table(Symbol_table
*)
331 // Finalize symbols and check assertions.
333 finalize_symbols(Symbol_table
*, const Layout
*, uint64_t*)
336 // Return the output section name to use for an input file name and
337 // section name. This only real implementation is in
338 // Output_section_definition.
340 output_section_name(const char*, const char*, Output_section
***)
343 // Initialize OSP with an output section.
345 orphan_section_init(Orphan_section_placement
*,
346 Script_sections::Elements_iterator
)
349 // Set section addresses. This includes applying assignments if the
350 // the expression is an absolute value.
352 set_section_addresses(Symbol_table
*, Layout
*, uint64_t*, uint64_t*)
355 // Check a constraint (ONLY_IF_RO, etc.) on an output section. If
356 // this section is constrained, and the input sections do not match,
357 // return the constraint, and set *POSD.
358 virtual Section_constraint
359 check_constraint(Output_section_definition
**)
360 { return CONSTRAINT_NONE
; }
362 // See if this is the alternate output section for a constrained
363 // output section. If it is, transfer the Output_section and return
364 // true. Otherwise return false.
366 alternate_constraint(Output_section_definition
*, Section_constraint
)
369 // Get the list of segments to use for an allocated section when
370 // using a PHDRS clause. If this is an allocated section, return
371 // the Output_section, and set *PHDRS_LIST (the first parameter) to
372 // the list of PHDRS to which it should be attached. If the PHDRS
373 // were not specified, don't change *PHDRS_LIST. When not returning
374 // NULL, set *ORPHAN (the second parameter) according to whether
375 // this is an orphan section--one that is not mentioned in the
377 virtual Output_section
*
378 allocate_to_segment(String_list
**, bool*)
381 // Look for an output section by name and return the address, the
382 // load address, the alignment, and the size. This is used when an
383 // expression refers to an output section which was not actually
384 // created. This returns true if the section was found, false
385 // otherwise. The only real definition is for
386 // Output_section_definition.
388 get_output_section_info(const char*, uint64_t*, uint64_t*, uint64_t*,
392 // Return the associated Output_section if there is one.
393 virtual Output_section
*
394 get_output_section() const
397 // Print the element for debugging purposes.
399 print(FILE* f
) const = 0;
402 // An assignment in a SECTIONS clause outside of an output section.
404 class Sections_element_assignment
: public Sections_element
407 Sections_element_assignment(const char* name
, size_t namelen
,
408 Expression
* val
, bool provide
, bool hidden
)
409 : assignment_(name
, namelen
, val
, provide
, hidden
)
412 // Add the symbol to the symbol table.
414 add_symbols_to_table(Symbol_table
* symtab
)
415 { this->assignment_
.add_to_table(symtab
); }
417 // Finalize the symbol.
419 finalize_symbols(Symbol_table
* symtab
, const Layout
* layout
,
422 this->assignment_
.finalize_with_dot(symtab
, layout
, *dot_value
, NULL
);
425 // Set the section address. There is no section here, but if the
426 // value is absolute, we set the symbol. This permits us to use
427 // absolute symbols when setting dot.
429 set_section_addresses(Symbol_table
* symtab
, Layout
* layout
,
430 uint64_t* dot_value
, uint64_t*)
432 this->assignment_
.set_if_absolute(symtab
, layout
, true, *dot_value
);
435 // Print for debugging.
440 this->assignment_
.print(f
);
444 Symbol_assignment assignment_
;
447 // An assignment to the dot symbol in a SECTIONS clause outside of an
450 class Sections_element_dot_assignment
: public Sections_element
453 Sections_element_dot_assignment(Expression
* val
)
457 // Finalize the symbol.
459 finalize_symbols(Symbol_table
* symtab
, const Layout
* layout
,
462 // We ignore the section of the result because outside of an
463 // output section definition the dot symbol is always considered
465 Output_section
* dummy
;
466 *dot_value
= this->val_
->eval_with_dot(symtab
, layout
, true, *dot_value
,
470 // Update the dot symbol while setting section addresses.
472 set_section_addresses(Symbol_table
* symtab
, Layout
* layout
,
473 uint64_t* dot_value
, uint64_t* load_address
)
475 Output_section
* dummy
;
476 *dot_value
= this->val_
->eval_with_dot(symtab
, layout
, false, *dot_value
,
478 *load_address
= *dot_value
;
481 // Print for debugging.
486 this->val_
->print(f
);
494 // An assertion in a SECTIONS clause outside of an output section.
496 class Sections_element_assertion
: public Sections_element
499 Sections_element_assertion(Expression
* check
, const char* message
,
501 : assertion_(check
, message
, messagelen
)
504 // Check the assertion.
506 finalize_symbols(Symbol_table
* symtab
, const Layout
* layout
, uint64_t*)
507 { this->assertion_
.check(symtab
, layout
); }
509 // Print for debugging.
514 this->assertion_
.print(f
);
518 Script_assertion assertion_
;
521 // An element in an output section in a SECTIONS clause.
523 class Output_section_element
526 // A list of input sections.
527 typedef std::list
<Output_section::Simple_input_section
> Input_section_list
;
529 Output_section_element()
532 virtual ~Output_section_element()
535 // Return whether this element requires an output section to exist.
537 needs_output_section() const
540 // Add any symbol being defined to the symbol table.
542 add_symbols_to_table(Symbol_table
*)
545 // Finalize symbols and check assertions.
547 finalize_symbols(Symbol_table
*, const Layout
*, uint64_t*, Output_section
**)
550 // Return whether this element matches FILE_NAME and SECTION_NAME.
551 // The only real implementation is in Output_section_element_input.
553 match_name(const char*, const char*) const
556 // Set section addresses. This includes applying assignments if the
557 // the expression is an absolute value.
559 set_section_addresses(Symbol_table
*, Layout
*, Output_section
*, uint64_t,
560 uint64_t*, Output_section
**, std::string
*,
564 // Print the element for debugging purposes.
566 print(FILE* f
) const = 0;
569 // Return a fill string that is LENGTH bytes long, filling it with
572 get_fill_string(const std::string
* fill
, section_size_type length
) const;
576 Output_section_element::get_fill_string(const std::string
* fill
,
577 section_size_type length
) const
579 std::string this_fill
;
580 this_fill
.reserve(length
);
581 while (this_fill
.length() + fill
->length() <= length
)
583 if (this_fill
.length() < length
)
584 this_fill
.append(*fill
, 0, length
- this_fill
.length());
588 // A symbol assignment in an output section.
590 class Output_section_element_assignment
: public Output_section_element
593 Output_section_element_assignment(const char* name
, size_t namelen
,
594 Expression
* val
, bool provide
,
596 : assignment_(name
, namelen
, val
, provide
, hidden
)
599 // Add the symbol to the symbol table.
601 add_symbols_to_table(Symbol_table
* symtab
)
602 { this->assignment_
.add_to_table(symtab
); }
604 // Finalize the symbol.
606 finalize_symbols(Symbol_table
* symtab
, const Layout
* layout
,
607 uint64_t* dot_value
, Output_section
** dot_section
)
609 this->assignment_
.finalize_with_dot(symtab
, layout
, *dot_value
,
613 // Set the section address. There is no section here, but if the
614 // value is absolute, we set the symbol. This permits us to use
615 // absolute symbols when setting dot.
617 set_section_addresses(Symbol_table
* symtab
, Layout
* layout
, Output_section
*,
618 uint64_t, uint64_t* dot_value
, Output_section
**,
619 std::string
*, Input_section_list
*)
621 this->assignment_
.set_if_absolute(symtab
, layout
, true, *dot_value
);
624 // Print for debugging.
629 this->assignment_
.print(f
);
633 Symbol_assignment assignment_
;
636 // An assignment to the dot symbol in an output section.
638 class Output_section_element_dot_assignment
: public Output_section_element
641 Output_section_element_dot_assignment(Expression
* val
)
645 // Finalize the symbol.
647 finalize_symbols(Symbol_table
* symtab
, const Layout
* layout
,
648 uint64_t* dot_value
, Output_section
** dot_section
)
650 *dot_value
= this->val_
->eval_with_dot(symtab
, layout
, true, *dot_value
,
651 *dot_section
, dot_section
);
654 // Update the dot symbol while setting section addresses.
656 set_section_addresses(Symbol_table
* symtab
, Layout
* layout
, Output_section
*,
657 uint64_t, uint64_t* dot_value
, Output_section
**,
658 std::string
*, Input_section_list
*);
660 // Print for debugging.
665 this->val_
->print(f
);
673 // Update the dot symbol while setting section addresses.
676 Output_section_element_dot_assignment::set_section_addresses(
677 Symbol_table
* symtab
,
679 Output_section
* output_section
,
682 Output_section
** dot_section
,
686 uint64_t next_dot
= this->val_
->eval_with_dot(symtab
, layout
, false,
687 *dot_value
, *dot_section
,
689 if (next_dot
< *dot_value
)
690 gold_error(_("dot may not move backward"));
691 if (next_dot
> *dot_value
&& output_section
!= NULL
)
693 section_size_type length
= convert_to_section_size_type(next_dot
695 Output_section_data
* posd
;
697 posd
= new Output_data_zero_fill(length
, 0);
700 std::string this_fill
= this->get_fill_string(fill
, length
);
701 posd
= new Output_data_const(this_fill
, 0);
703 output_section
->add_output_section_data(posd
);
704 layout
->new_output_section_data_from_script(posd
);
706 *dot_value
= next_dot
;
709 // An assertion in an output section.
711 class Output_section_element_assertion
: public Output_section_element
714 Output_section_element_assertion(Expression
* check
, const char* message
,
716 : assertion_(check
, message
, messagelen
)
723 this->assertion_
.print(f
);
727 Script_assertion assertion_
;
730 // We use a special instance of Output_section_data to handle BYTE,
731 // SHORT, etc. This permits forward references to symbols in the
734 class Output_data_expression
: public Output_section_data
737 Output_data_expression(int size
, bool is_signed
, Expression
* val
,
738 const Symbol_table
* symtab
, const Layout
* layout
,
739 uint64_t dot_value
, Output_section
* dot_section
)
740 : Output_section_data(size
, 0, true),
741 is_signed_(is_signed
), val_(val
), symtab_(symtab
),
742 layout_(layout
), dot_value_(dot_value
), dot_section_(dot_section
)
746 // Write the data to the output file.
748 do_write(Output_file
*);
750 // Write the data to a buffer.
752 do_write_to_buffer(unsigned char*);
754 // Write to a map file.
756 do_print_to_mapfile(Mapfile
* mapfile
) const
757 { mapfile
->print_output_data(this, _("** expression")); }
760 template<bool big_endian
>
762 endian_write_to_buffer(uint64_t, unsigned char*);
766 const Symbol_table
* symtab_
;
767 const Layout
* layout_
;
769 Output_section
* dot_section_
;
772 // Write the data element to the output file.
775 Output_data_expression::do_write(Output_file
* of
)
777 unsigned char* view
= of
->get_output_view(this->offset(), this->data_size());
778 this->write_to_buffer(view
);
779 of
->write_output_view(this->offset(), this->data_size(), view
);
782 // Write the data element to a buffer.
785 Output_data_expression::do_write_to_buffer(unsigned char* buf
)
787 Output_section
* dummy
;
788 uint64_t val
= this->val_
->eval_with_dot(this->symtab_
, this->layout_
,
789 true, this->dot_value_
,
790 this->dot_section_
, &dummy
);
792 if (parameters
->target().is_big_endian())
793 this->endian_write_to_buffer
<true>(val
, buf
);
795 this->endian_write_to_buffer
<false>(val
, buf
);
798 template<bool big_endian
>
800 Output_data_expression::endian_write_to_buffer(uint64_t val
,
803 switch (this->data_size())
806 elfcpp::Swap_unaligned
<8, big_endian
>::writeval(buf
, val
);
809 elfcpp::Swap_unaligned
<16, big_endian
>::writeval(buf
, val
);
812 elfcpp::Swap_unaligned
<32, big_endian
>::writeval(buf
, val
);
815 if (parameters
->target().get_size() == 32)
818 if (this->is_signed_
&& (val
& 0x80000000) != 0)
819 val
|= 0xffffffff00000000LL
;
821 elfcpp::Swap_unaligned
<64, big_endian
>::writeval(buf
, val
);
828 // A data item in an output section.
830 class Output_section_element_data
: public Output_section_element
833 Output_section_element_data(int size
, bool is_signed
, Expression
* val
)
834 : size_(size
), is_signed_(is_signed
), val_(val
)
837 // If there is a data item, then we must create an output section.
839 needs_output_section() const
842 // Finalize symbols--we just need to update dot.
844 finalize_symbols(Symbol_table
*, const Layout
*, uint64_t* dot_value
,
846 { *dot_value
+= this->size_
; }
848 // Store the value in the section.
850 set_section_addresses(Symbol_table
*, Layout
*, Output_section
*, uint64_t,
851 uint64_t* dot_value
, Output_section
**, std::string
*,
852 Input_section_list
*);
854 // Print for debugging.
859 // The size in bytes.
861 // Whether the value is signed.
867 // Store the value in the section.
870 Output_section_element_data::set_section_addresses(
871 Symbol_table
* symtab
,
876 Output_section
** dot_section
,
880 gold_assert(os
!= NULL
);
881 Output_data_expression
* expression
=
882 new Output_data_expression(this->size_
, this->is_signed_
, this->val_
,
883 symtab
, layout
, *dot_value
, *dot_section
);
884 os
->add_output_section_data(expression
);
885 layout
->new_output_section_data_from_script(expression
);
886 *dot_value
+= this->size_
;
889 // Print for debugging.
892 Output_section_element_data::print(FILE* f
) const
907 if (this->is_signed_
)
915 fprintf(f
, " %s(", s
);
916 this->val_
->print(f
);
920 // A fill value setting in an output section.
922 class Output_section_element_fill
: public Output_section_element
925 Output_section_element_fill(Expression
* val
)
929 // Update the fill value while setting section addresses.
931 set_section_addresses(Symbol_table
* symtab
, Layout
* layout
, Output_section
*,
932 uint64_t, uint64_t* dot_value
,
933 Output_section
** dot_section
,
934 std::string
* fill
, Input_section_list
*)
936 Output_section
* fill_section
;
937 uint64_t fill_val
= this->val_
->eval_with_dot(symtab
, layout
, false,
938 *dot_value
, *dot_section
,
940 if (fill_section
!= NULL
)
941 gold_warning(_("fill value is not absolute"));
942 // FIXME: The GNU linker supports fill values of arbitrary length.
943 unsigned char fill_buff
[4];
944 elfcpp::Swap_unaligned
<32, true>::writeval(fill_buff
, fill_val
);
945 fill
->assign(reinterpret_cast<char*>(fill_buff
), 4);
948 // Print for debugging.
952 fprintf(f
, " FILL(");
953 this->val_
->print(f
);
958 // The new fill value.
962 // Return whether STRING contains a wildcard character. This is used
963 // to speed up matching.
966 is_wildcard_string(const std::string
& s
)
968 return strpbrk(s
.c_str(), "?*[") != NULL
;
971 // An input section specification in an output section
973 class Output_section_element_input
: public Output_section_element
976 Output_section_element_input(const Input_section_spec
* spec
, bool keep
);
978 // Finalize symbols--just update the value of the dot symbol.
980 finalize_symbols(Symbol_table
*, const Layout
*, uint64_t* dot_value
,
981 Output_section
** dot_section
)
983 *dot_value
= this->final_dot_value_
;
984 *dot_section
= this->final_dot_section_
;
987 // See whether we match FILE_NAME and SECTION_NAME as an input
990 match_name(const char* file_name
, const char* section_name
) const;
992 // Set the section address.
994 set_section_addresses(Symbol_table
* symtab
, Layout
* layout
, Output_section
*,
995 uint64_t subalign
, uint64_t* dot_value
,
996 Output_section
**, std::string
* fill
,
997 Input_section_list
*);
999 // Print for debugging.
1001 print(FILE* f
) const;
1004 // An input section pattern.
1005 struct Input_section_pattern
1007 std::string pattern
;
1008 bool pattern_is_wildcard
;
1011 Input_section_pattern(const char* patterna
, size_t patternlena
,
1012 Sort_wildcard sorta
)
1013 : pattern(patterna
, patternlena
),
1014 pattern_is_wildcard(is_wildcard_string(this->pattern
)),
1019 typedef std::vector
<Input_section_pattern
> Input_section_patterns
;
1021 // Filename_exclusions is a pair of filename pattern and a bool
1022 // indicating whether the filename is a wildcard.
1023 typedef std::vector
<std::pair
<std::string
, bool> > Filename_exclusions
;
1025 // Return whether STRING matches PATTERN, where IS_WILDCARD_PATTERN
1026 // indicates whether this is a wildcard pattern.
1028 match(const char* string
, const char* pattern
, bool is_wildcard_pattern
)
1030 return (is_wildcard_pattern
1031 ? fnmatch(pattern
, string
, 0) == 0
1032 : strcmp(string
, pattern
) == 0);
1035 // See if we match a file name.
1037 match_file_name(const char* file_name
) const;
1039 // The file name pattern. If this is the empty string, we match all
1041 std::string filename_pattern_
;
1042 // Whether the file name pattern is a wildcard.
1043 bool filename_is_wildcard_
;
1044 // How the file names should be sorted. This may only be
1045 // SORT_WILDCARD_NONE or SORT_WILDCARD_BY_NAME.
1046 Sort_wildcard filename_sort_
;
1047 // The list of file names to exclude.
1048 Filename_exclusions filename_exclusions_
;
1049 // The list of input section patterns.
1050 Input_section_patterns input_section_patterns_
;
1051 // Whether to keep this section when garbage collecting.
1053 // The value of dot after including all matching sections.
1054 uint64_t final_dot_value_
;
1055 // The section where dot is defined after including all matching
1057 Output_section
* final_dot_section_
;
1060 // Construct Output_section_element_input. The parser records strings
1061 // as pointers into a copy of the script file, which will go away when
1062 // parsing is complete. We make sure they are in std::string objects.
1064 Output_section_element_input::Output_section_element_input(
1065 const Input_section_spec
* spec
,
1067 : filename_pattern_(),
1068 filename_is_wildcard_(false),
1069 filename_sort_(spec
->file
.sort
),
1070 filename_exclusions_(),
1071 input_section_patterns_(),
1073 final_dot_value_(0),
1074 final_dot_section_(NULL
)
1076 // The filename pattern "*" is common, and matches all files. Turn
1077 // it into the empty string.
1078 if (spec
->file
.name
.length
!= 1 || spec
->file
.name
.value
[0] != '*')
1079 this->filename_pattern_
.assign(spec
->file
.name
.value
,
1080 spec
->file
.name
.length
);
1081 this->filename_is_wildcard_
= is_wildcard_string(this->filename_pattern_
);
1083 if (spec
->input_sections
.exclude
!= NULL
)
1085 for (String_list::const_iterator p
=
1086 spec
->input_sections
.exclude
->begin();
1087 p
!= spec
->input_sections
.exclude
->end();
1090 bool is_wildcard
= is_wildcard_string(*p
);
1091 this->filename_exclusions_
.push_back(std::make_pair(*p
,
1096 if (spec
->input_sections
.sections
!= NULL
)
1098 Input_section_patterns
& isp(this->input_section_patterns_
);
1099 for (String_sort_list::const_iterator p
=
1100 spec
->input_sections
.sections
->begin();
1101 p
!= spec
->input_sections
.sections
->end();
1103 isp
.push_back(Input_section_pattern(p
->name
.value
, p
->name
.length
,
1108 // See whether we match FILE_NAME.
1111 Output_section_element_input::match_file_name(const char* file_name
) const
1113 if (!this->filename_pattern_
.empty())
1115 // If we were called with no filename, we refuse to match a
1116 // pattern which requires a file name.
1117 if (file_name
== NULL
)
1120 if (!match(file_name
, this->filename_pattern_
.c_str(),
1121 this->filename_is_wildcard_
))
1125 if (file_name
!= NULL
)
1127 // Now we have to see whether FILE_NAME matches one of the
1128 // exclusion patterns, if any.
1129 for (Filename_exclusions::const_iterator p
=
1130 this->filename_exclusions_
.begin();
1131 p
!= this->filename_exclusions_
.end();
1134 if (match(file_name
, p
->first
.c_str(), p
->second
))
1142 // See whether we match FILE_NAME and SECTION_NAME.
1145 Output_section_element_input::match_name(const char* file_name
,
1146 const char* section_name
) const
1148 if (!this->match_file_name(file_name
))
1151 // If there are no section name patterns, then we match.
1152 if (this->input_section_patterns_
.empty())
1155 // See whether we match the section name patterns.
1156 for (Input_section_patterns::const_iterator p
=
1157 this->input_section_patterns_
.begin();
1158 p
!= this->input_section_patterns_
.end();
1161 if (match(section_name
, p
->pattern
.c_str(), p
->pattern_is_wildcard
))
1165 // We didn't match any section names, so we didn't match.
1169 // Information we use to sort the input sections.
1171 class Input_section_info
1174 Input_section_info(const Output_section::Simple_input_section
& input_section
)
1175 : input_section_(input_section
), section_name_(),
1176 size_(0), addralign_(1)
1179 // Return the simple input section.
1180 const Output_section::Simple_input_section
&
1181 input_section() const
1182 { return this->input_section_
; }
1184 // Return the object.
1187 { return this->input_section_
.relobj(); }
1189 // Return the section index.
1192 { return this->input_section_
.shndx(); }
1194 // Return the section name.
1196 section_name() const
1197 { return this->section_name_
; }
1199 // Set the section name.
1201 set_section_name(const std::string name
)
1202 { this->section_name_
= name
; }
1204 // Return the section size.
1207 { return this->size_
; }
1209 // Set the section size.
1211 set_size(uint64_t size
)
1212 { this->size_
= size
; }
1214 // Return the address alignment.
1217 { return this->addralign_
; }
1219 // Set the address alignment.
1221 set_addralign(uint64_t addralign
)
1222 { this->addralign_
= addralign
; }
1225 // Input section, can be a relaxed section.
1226 Output_section::Simple_input_section input_section_
;
1227 // Name of the section.
1228 std::string section_name_
;
1231 // Address alignment.
1232 uint64_t addralign_
;
1235 // A class to sort the input sections.
1237 class Input_section_sorter
1240 Input_section_sorter(Sort_wildcard filename_sort
, Sort_wildcard section_sort
)
1241 : filename_sort_(filename_sort
), section_sort_(section_sort
)
1245 operator()(const Input_section_info
&, const Input_section_info
&) const;
1248 Sort_wildcard filename_sort_
;
1249 Sort_wildcard section_sort_
;
1253 Input_section_sorter::operator()(const Input_section_info
& isi1
,
1254 const Input_section_info
& isi2
) const
1256 if (this->section_sort_
== SORT_WILDCARD_BY_NAME
1257 || this->section_sort_
== SORT_WILDCARD_BY_NAME_BY_ALIGNMENT
1258 || (this->section_sort_
== SORT_WILDCARD_BY_ALIGNMENT_BY_NAME
1259 && isi1
.addralign() == isi2
.addralign()))
1261 if (isi1
.section_name() != isi2
.section_name())
1262 return isi1
.section_name() < isi2
.section_name();
1264 if (this->section_sort_
== SORT_WILDCARD_BY_ALIGNMENT
1265 || this->section_sort_
== SORT_WILDCARD_BY_NAME_BY_ALIGNMENT
1266 || this->section_sort_
== SORT_WILDCARD_BY_ALIGNMENT_BY_NAME
)
1268 if (isi1
.addralign() != isi2
.addralign())
1269 return isi1
.addralign() < isi2
.addralign();
1271 if (this->filename_sort_
== SORT_WILDCARD_BY_NAME
)
1273 if (isi1
.relobj()->name() != isi2
.relobj()->name())
1274 return (isi1
.relobj()->name() < isi2
.relobj()->name());
1277 // Otherwise we leave them in the same order.
1281 // Set the section address. Look in INPUT_SECTIONS for sections which
1282 // match this spec, sort them as specified, and add them to the output
1286 Output_section_element_input::set_section_addresses(
1289 Output_section
* output_section
,
1291 uint64_t* dot_value
,
1292 Output_section
** dot_section
,
1294 Input_section_list
* input_sections
)
1296 // We build a list of sections which match each
1297 // Input_section_pattern.
1299 typedef std::vector
<std::vector
<Input_section_info
> > Matching_sections
;
1300 size_t input_pattern_count
= this->input_section_patterns_
.size();
1301 if (input_pattern_count
== 0)
1302 input_pattern_count
= 1;
1303 Matching_sections
matching_sections(input_pattern_count
);
1305 // Look through the list of sections for this output section. Add
1306 // each one which matches to one of the elements of
1307 // MATCHING_SECTIONS.
1309 Input_section_list::iterator p
= input_sections
->begin();
1310 while (p
!= input_sections
->end())
1312 Relobj
* relobj
= p
->relobj();
1313 unsigned int shndx
= p
->shndx();
1314 Input_section_info
isi(*p
);
1316 // Calling section_name and section_addralign is not very
1319 // Lock the object so that we can get information about the
1320 // section. This is OK since we know we are single-threaded
1323 const Task
* task
= reinterpret_cast<const Task
*>(-1);
1324 Task_lock_obj
<Object
> tl(task
, relobj
);
1326 isi
.set_section_name(relobj
->section_name(shndx
));
1327 if (p
->is_relaxed_input_section())
1329 // We use current data size because relxed section sizes may not
1330 // have finalized yet.
1331 isi
.set_size(p
->relaxed_input_section()->current_data_size());
1332 isi
.set_addralign(p
->relaxed_input_section()->addralign());
1336 isi
.set_size(relobj
->section_size(shndx
));
1337 isi
.set_addralign(relobj
->section_addralign(shndx
));
1341 if (!this->match_file_name(relobj
->name().c_str()))
1343 else if (this->input_section_patterns_
.empty())
1345 matching_sections
[0].push_back(isi
);
1346 p
= input_sections
->erase(p
);
1351 for (i
= 0; i
< input_pattern_count
; ++i
)
1353 const Input_section_pattern
&
1354 isp(this->input_section_patterns_
[i
]);
1355 if (match(isi
.section_name().c_str(), isp
.pattern
.c_str(),
1356 isp
.pattern_is_wildcard
))
1360 if (i
>= this->input_section_patterns_
.size())
1364 matching_sections
[i
].push_back(isi
);
1365 p
= input_sections
->erase(p
);
1370 // Look through MATCHING_SECTIONS. Sort each one as specified,
1371 // using a stable sort so that we get the default order when
1372 // sections are otherwise equal. Add each input section to the
1375 for (size_t i
= 0; i
< input_pattern_count
; ++i
)
1377 if (matching_sections
[i
].empty())
1380 gold_assert(output_section
!= NULL
);
1382 const Input_section_pattern
& isp(this->input_section_patterns_
[i
]);
1383 if (isp
.sort
!= SORT_WILDCARD_NONE
1384 || this->filename_sort_
!= SORT_WILDCARD_NONE
)
1385 std::stable_sort(matching_sections
[i
].begin(),
1386 matching_sections
[i
].end(),
1387 Input_section_sorter(this->filename_sort_
,
1390 for (std::vector
<Input_section_info
>::const_iterator p
=
1391 matching_sections
[i
].begin();
1392 p
!= matching_sections
[i
].end();
1395 uint64_t this_subalign
= p
->addralign();
1396 if (this_subalign
< subalign
)
1397 this_subalign
= subalign
;
1399 uint64_t address
= align_address(*dot_value
, this_subalign
);
1401 if (address
> *dot_value
&& !fill
->empty())
1403 section_size_type length
=
1404 convert_to_section_size_type(address
- *dot_value
);
1405 std::string this_fill
= this->get_fill_string(fill
, length
);
1406 Output_section_data
* posd
= new Output_data_const(this_fill
, 0);
1407 output_section
->add_output_section_data(posd
);
1408 layout
->new_output_section_data_from_script(posd
);
1411 output_section
->add_input_section_for_script(p
->input_section(),
1415 *dot_value
= address
+ p
->size();
1419 this->final_dot_value_
= *dot_value
;
1420 this->final_dot_section_
= *dot_section
;
1423 // Print for debugging.
1426 Output_section_element_input::print(FILE* f
) const
1431 fprintf(f
, "KEEP(");
1433 if (!this->filename_pattern_
.empty())
1435 bool need_close_paren
= false;
1436 switch (this->filename_sort_
)
1438 case SORT_WILDCARD_NONE
:
1440 case SORT_WILDCARD_BY_NAME
:
1441 fprintf(f
, "SORT_BY_NAME(");
1442 need_close_paren
= true;
1448 fprintf(f
, "%s", this->filename_pattern_
.c_str());
1450 if (need_close_paren
)
1454 if (!this->input_section_patterns_
.empty()
1455 || !this->filename_exclusions_
.empty())
1459 bool need_space
= false;
1460 if (!this->filename_exclusions_
.empty())
1462 fprintf(f
, "EXCLUDE_FILE(");
1463 bool need_comma
= false;
1464 for (Filename_exclusions::const_iterator p
=
1465 this->filename_exclusions_
.begin();
1466 p
!= this->filename_exclusions_
.end();
1471 fprintf(f
, "%s", p
->first
.c_str());
1478 for (Input_section_patterns::const_iterator p
=
1479 this->input_section_patterns_
.begin();
1480 p
!= this->input_section_patterns_
.end();
1486 int close_parens
= 0;
1489 case SORT_WILDCARD_NONE
:
1491 case SORT_WILDCARD_BY_NAME
:
1492 fprintf(f
, "SORT_BY_NAME(");
1495 case SORT_WILDCARD_BY_ALIGNMENT
:
1496 fprintf(f
, "SORT_BY_ALIGNMENT(");
1499 case SORT_WILDCARD_BY_NAME_BY_ALIGNMENT
:
1500 fprintf(f
, "SORT_BY_NAME(SORT_BY_ALIGNMENT(");
1503 case SORT_WILDCARD_BY_ALIGNMENT_BY_NAME
:
1504 fprintf(f
, "SORT_BY_ALIGNMENT(SORT_BY_NAME(");
1511 fprintf(f
, "%s", p
->pattern
.c_str());
1513 for (int i
= 0; i
< close_parens
; ++i
)
1528 // An output section.
1530 class Output_section_definition
: public Sections_element
1533 typedef Output_section_element::Input_section_list Input_section_list
;
1535 Output_section_definition(const char* name
, size_t namelen
,
1536 const Parser_output_section_header
* header
);
1538 // Finish the output section with the information in the trailer.
1540 finish(const Parser_output_section_trailer
* trailer
);
1542 // Add a symbol to be defined.
1544 add_symbol_assignment(const char* name
, size_t length
, Expression
* value
,
1545 bool provide
, bool hidden
);
1547 // Add an assignment to the special dot symbol.
1549 add_dot_assignment(Expression
* value
);
1551 // Add an assertion.
1553 add_assertion(Expression
* check
, const char* message
, size_t messagelen
);
1555 // Add a data item to the current output section.
1557 add_data(int size
, bool is_signed
, Expression
* val
);
1559 // Add a setting for the fill value.
1561 add_fill(Expression
* val
);
1563 // Add an input section specification.
1565 add_input_section(const Input_section_spec
* spec
, bool keep
);
1567 // Return whether the output section is relro.
1570 { return this->is_relro_
; }
1572 // Record that the output section is relro.
1575 { this->is_relro_
= true; }
1577 // Create any required output sections.
1579 create_sections(Layout
*);
1581 // Add any symbols being defined to the symbol table.
1583 add_symbols_to_table(Symbol_table
* symtab
);
1585 // Finalize symbols and check assertions.
1587 finalize_symbols(Symbol_table
*, const Layout
*, uint64_t*);
1589 // Return the output section name to use for an input file name and
1592 output_section_name(const char* file_name
, const char* section_name
,
1595 // Initialize OSP with an output section.
1597 orphan_section_init(Orphan_section_placement
* osp
,
1598 Script_sections::Elements_iterator p
)
1599 { osp
->output_section_init(this->name_
, this->output_section_
, p
); }
1601 // Set the section address.
1603 set_section_addresses(Symbol_table
* symtab
, Layout
* layout
,
1604 uint64_t* dot_value
, uint64_t* load_address
);
1606 // Check a constraint (ONLY_IF_RO, etc.) on an output section. If
1607 // this section is constrained, and the input sections do not match,
1608 // return the constraint, and set *POSD.
1610 check_constraint(Output_section_definition
** posd
);
1612 // See if this is the alternate output section for a constrained
1613 // output section. If it is, transfer the Output_section and return
1614 // true. Otherwise return false.
1616 alternate_constraint(Output_section_definition
*, Section_constraint
);
1618 // Get the list of segments to use for an allocated section when
1619 // using a PHDRS clause.
1621 allocate_to_segment(String_list
** phdrs_list
, bool* orphan
);
1623 // Look for an output section by name and return the address, the
1624 // load address, the alignment, and the size. This is used when an
1625 // expression refers to an output section which was not actually
1626 // created. This returns true if the section was found, false
1629 get_output_section_info(const char*, uint64_t*, uint64_t*, uint64_t*,
1632 // Return the associated Output_section if there is one.
1634 get_output_section() const
1635 { return this->output_section_
; }
1637 // Print the contents to the FILE. This is for debugging.
1642 typedef std::vector
<Output_section_element
*> Output_section_elements
;
1644 // The output section name.
1646 // The address. This may be NULL.
1647 Expression
* address_
;
1648 // The load address. This may be NULL.
1649 Expression
* load_address_
;
1650 // The alignment. This may be NULL.
1652 // The input section alignment. This may be NULL.
1653 Expression
* subalign_
;
1654 // The constraint, if any.
1655 Section_constraint constraint_
;
1656 // The fill value. This may be NULL.
1658 // The list of segments this section should go into. This may be
1660 String_list
* phdrs_
;
1661 // The list of elements defining the section.
1662 Output_section_elements elements_
;
1663 // The Output_section created for this definition. This will be
1664 // NULL if none was created.
1665 Output_section
* output_section_
;
1666 // The address after it has been evaluated.
1667 uint64_t evaluated_address_
;
1668 // The load address after it has been evaluated.
1669 uint64_t evaluated_load_address_
;
1670 // The alignment after it has been evaluated.
1671 uint64_t evaluated_addralign_
;
1672 // The output section is relro.
1678 Output_section_definition::Output_section_definition(
1681 const Parser_output_section_header
* header
)
1682 : name_(name
, namelen
),
1683 address_(header
->address
),
1684 load_address_(header
->load_address
),
1685 align_(header
->align
),
1686 subalign_(header
->subalign
),
1687 constraint_(header
->constraint
),
1691 output_section_(NULL
),
1692 evaluated_address_(0),
1693 evaluated_load_address_(0),
1694 evaluated_addralign_(0),
1699 // Finish an output section.
1702 Output_section_definition::finish(const Parser_output_section_trailer
* trailer
)
1704 this->fill_
= trailer
->fill
;
1705 this->phdrs_
= trailer
->phdrs
;
1708 // Add a symbol to be defined.
1711 Output_section_definition::add_symbol_assignment(const char* name
,
1717 Output_section_element
* p
= new Output_section_element_assignment(name
,
1722 this->elements_
.push_back(p
);
1725 // Add an assignment to the special dot symbol.
1728 Output_section_definition::add_dot_assignment(Expression
* value
)
1730 Output_section_element
* p
= new Output_section_element_dot_assignment(value
);
1731 this->elements_
.push_back(p
);
1734 // Add an assertion.
1737 Output_section_definition::add_assertion(Expression
* check
,
1738 const char* message
,
1741 Output_section_element
* p
= new Output_section_element_assertion(check
,
1744 this->elements_
.push_back(p
);
1747 // Add a data item to the current output section.
1750 Output_section_definition::add_data(int size
, bool is_signed
, Expression
* val
)
1752 Output_section_element
* p
= new Output_section_element_data(size
, is_signed
,
1754 this->elements_
.push_back(p
);
1757 // Add a setting for the fill value.
1760 Output_section_definition::add_fill(Expression
* val
)
1762 Output_section_element
* p
= new Output_section_element_fill(val
);
1763 this->elements_
.push_back(p
);
1766 // Add an input section specification.
1769 Output_section_definition::add_input_section(const Input_section_spec
* spec
,
1772 Output_section_element
* p
= new Output_section_element_input(spec
, keep
);
1773 this->elements_
.push_back(p
);
1776 // Create any required output sections. We need an output section if
1777 // there is a data statement here.
1780 Output_section_definition::create_sections(Layout
* layout
)
1782 if (this->output_section_
!= NULL
)
1784 for (Output_section_elements::const_iterator p
= this->elements_
.begin();
1785 p
!= this->elements_
.end();
1788 if ((*p
)->needs_output_section())
1790 const char* name
= this->name_
.c_str();
1791 this->output_section_
= layout
->make_output_section_for_script(name
);
1797 // Add any symbols being defined to the symbol table.
1800 Output_section_definition::add_symbols_to_table(Symbol_table
* symtab
)
1802 for (Output_section_elements::iterator p
= this->elements_
.begin();
1803 p
!= this->elements_
.end();
1805 (*p
)->add_symbols_to_table(symtab
);
1808 // Finalize symbols and check assertions.
1811 Output_section_definition::finalize_symbols(Symbol_table
* symtab
,
1812 const Layout
* layout
,
1813 uint64_t* dot_value
)
1815 if (this->output_section_
!= NULL
)
1816 *dot_value
= this->output_section_
->address();
1819 uint64_t address
= *dot_value
;
1820 if (this->address_
!= NULL
)
1822 Output_section
* dummy
;
1823 address
= this->address_
->eval_with_dot(symtab
, layout
, true,
1827 if (this->align_
!= NULL
)
1829 Output_section
* dummy
;
1830 uint64_t align
= this->align_
->eval_with_dot(symtab
, layout
, true,
1834 address
= align_address(address
, align
);
1836 *dot_value
= address
;
1839 Output_section
* dot_section
= this->output_section_
;
1840 for (Output_section_elements::iterator p
= this->elements_
.begin();
1841 p
!= this->elements_
.end();
1843 (*p
)->finalize_symbols(symtab
, layout
, dot_value
, &dot_section
);
1846 // Return the output section name to use for an input section name.
1849 Output_section_definition::output_section_name(const char* file_name
,
1850 const char* section_name
,
1851 Output_section
*** slot
)
1853 // Ask each element whether it matches NAME.
1854 for (Output_section_elements::const_iterator p
= this->elements_
.begin();
1855 p
!= this->elements_
.end();
1858 if ((*p
)->match_name(file_name
, section_name
))
1860 // We found a match for NAME, which means that it should go
1861 // into this output section.
1862 *slot
= &this->output_section_
;
1863 return this->name_
.c_str();
1867 // We don't know about this section name.
1871 // Set the section address. Note that the OUTPUT_SECTION_ field will
1872 // be NULL if no input sections were mapped to this output section.
1873 // We still have to adjust dot and process symbol assignments.
1876 Output_section_definition::set_section_addresses(Symbol_table
* symtab
,
1878 uint64_t* dot_value
,
1879 uint64_t* load_address
)
1882 if (this->address_
== NULL
)
1883 address
= *dot_value
;
1886 Output_section
* dummy
;
1887 address
= this->address_
->eval_with_dot(symtab
, layout
, true,
1888 *dot_value
, NULL
, &dummy
);
1892 if (this->align_
== NULL
)
1894 if (this->output_section_
== NULL
)
1897 align
= this->output_section_
->addralign();
1901 Output_section
* align_section
;
1902 align
= this->align_
->eval_with_dot(symtab
, layout
, true, *dot_value
,
1903 NULL
, &align_section
);
1904 if (align_section
!= NULL
)
1905 gold_warning(_("alignment of section %s is not absolute"),
1906 this->name_
.c_str());
1907 if (this->output_section_
!= NULL
)
1908 this->output_section_
->set_addralign(align
);
1911 address
= align_address(address
, align
);
1913 uint64_t start_address
= address
;
1915 *dot_value
= address
;
1917 // The address of non-SHF_ALLOC sections is forced to zero,
1918 // regardless of what the linker script wants.
1919 if (this->output_section_
!= NULL
1920 && (this->output_section_
->flags() & elfcpp::SHF_ALLOC
) != 0)
1921 this->output_section_
->set_address(address
);
1923 this->evaluated_address_
= address
;
1924 this->evaluated_addralign_
= align
;
1926 if (this->load_address_
== NULL
)
1927 this->evaluated_load_address_
= address
;
1930 Output_section
* dummy
;
1932 this->load_address_
->eval_with_dot(symtab
, layout
, true, *dot_value
,
1933 this->output_section_
, &dummy
);
1934 if (this->output_section_
!= NULL
)
1935 this->output_section_
->set_load_address(laddr
);
1936 this->evaluated_load_address_
= laddr
;
1940 if (this->subalign_
== NULL
)
1944 Output_section
* subalign_section
;
1945 subalign
= this->subalign_
->eval_with_dot(symtab
, layout
, true,
1948 if (subalign_section
!= NULL
)
1949 gold_warning(_("subalign of section %s is not absolute"),
1950 this->name_
.c_str());
1954 if (this->fill_
!= NULL
)
1956 // FIXME: The GNU linker supports fill values of arbitrary
1958 Output_section
* fill_section
;
1959 uint64_t fill_val
= this->fill_
->eval_with_dot(symtab
, layout
, true,
1963 if (fill_section
!= NULL
)
1964 gold_warning(_("fill of section %s is not absolute"),
1965 this->name_
.c_str());
1966 unsigned char fill_buff
[4];
1967 elfcpp::Swap_unaligned
<32, true>::writeval(fill_buff
, fill_val
);
1968 fill
.assign(reinterpret_cast<char*>(fill_buff
), 4);
1971 Input_section_list input_sections
;
1972 if (this->output_section_
!= NULL
)
1974 // Get the list of input sections attached to this output
1975 // section. This will leave the output section with only
1976 // Output_section_data entries.
1977 address
+= this->output_section_
->get_input_sections(address
,
1980 *dot_value
= address
;
1983 Output_section
* dot_section
= this->output_section_
;
1984 for (Output_section_elements::iterator p
= this->elements_
.begin();
1985 p
!= this->elements_
.end();
1987 (*p
)->set_section_addresses(symtab
, layout
, this->output_section_
,
1988 subalign
, dot_value
, &dot_section
, &fill
,
1991 gold_assert(input_sections
.empty());
1993 if (this->load_address_
== NULL
|| this->output_section_
== NULL
)
1994 *load_address
= *dot_value
;
1996 *load_address
= (this->output_section_
->load_address()
1997 + (*dot_value
- start_address
));
1999 if (this->output_section_
!= NULL
)
2001 if (this->is_relro_
)
2002 this->output_section_
->set_is_relro();
2004 this->output_section_
->clear_is_relro();
2008 // Check a constraint (ONLY_IF_RO, etc.) on an output section. If
2009 // this section is constrained, and the input sections do not match,
2010 // return the constraint, and set *POSD.
2013 Output_section_definition::check_constraint(Output_section_definition
** posd
)
2015 switch (this->constraint_
)
2017 case CONSTRAINT_NONE
:
2018 return CONSTRAINT_NONE
;
2020 case CONSTRAINT_ONLY_IF_RO
:
2021 if (this->output_section_
!= NULL
2022 && (this->output_section_
->flags() & elfcpp::SHF_WRITE
) != 0)
2025 return CONSTRAINT_ONLY_IF_RO
;
2027 return CONSTRAINT_NONE
;
2029 case CONSTRAINT_ONLY_IF_RW
:
2030 if (this->output_section_
!= NULL
2031 && (this->output_section_
->flags() & elfcpp::SHF_WRITE
) == 0)
2034 return CONSTRAINT_ONLY_IF_RW
;
2036 return CONSTRAINT_NONE
;
2038 case CONSTRAINT_SPECIAL
:
2039 if (this->output_section_
!= NULL
)
2040 gold_error(_("SPECIAL constraints are not implemented"));
2041 return CONSTRAINT_NONE
;
2048 // See if this is the alternate output section for a constrained
2049 // output section. If it is, transfer the Output_section and return
2050 // true. Otherwise return false.
2053 Output_section_definition::alternate_constraint(
2054 Output_section_definition
* posd
,
2055 Section_constraint constraint
)
2057 if (this->name_
!= posd
->name_
)
2062 case CONSTRAINT_ONLY_IF_RO
:
2063 if (this->constraint_
!= CONSTRAINT_ONLY_IF_RW
)
2067 case CONSTRAINT_ONLY_IF_RW
:
2068 if (this->constraint_
!= CONSTRAINT_ONLY_IF_RO
)
2076 // We have found the alternate constraint. We just need to move
2077 // over the Output_section. When constraints are used properly,
2078 // THIS should not have an output_section pointer, as all the input
2079 // sections should have matched the other definition.
2081 if (this->output_section_
!= NULL
)
2082 gold_error(_("mismatched definition for constrained sections"));
2084 this->output_section_
= posd
->output_section_
;
2085 posd
->output_section_
= NULL
;
2087 if (this->is_relro_
)
2088 this->output_section_
->set_is_relro();
2090 this->output_section_
->clear_is_relro();
2095 // Get the list of segments to use for an allocated section when using
2099 Output_section_definition::allocate_to_segment(String_list
** phdrs_list
,
2102 if (this->output_section_
== NULL
)
2104 if ((this->output_section_
->flags() & elfcpp::SHF_ALLOC
) == 0)
2107 if (this->phdrs_
!= NULL
)
2108 *phdrs_list
= this->phdrs_
;
2109 return this->output_section_
;
2112 // Look for an output section by name and return the address, the load
2113 // address, the alignment, and the size. This is used when an
2114 // expression refers to an output section which was not actually
2115 // created. This returns true if the section was found, false
2119 Output_section_definition::get_output_section_info(const char* name
,
2121 uint64_t* load_address
,
2122 uint64_t* addralign
,
2123 uint64_t* size
) const
2125 if (this->name_
!= name
)
2128 if (this->output_section_
!= NULL
)
2130 *address
= this->output_section_
->address();
2131 if (this->output_section_
->has_load_address())
2132 *load_address
= this->output_section_
->load_address();
2134 *load_address
= *address
;
2135 *addralign
= this->output_section_
->addralign();
2136 *size
= this->output_section_
->current_data_size();
2140 *address
= this->evaluated_address_
;
2141 *load_address
= this->evaluated_load_address_
;
2142 *addralign
= this->evaluated_addralign_
;
2149 // Print for debugging.
2152 Output_section_definition::print(FILE* f
) const
2154 fprintf(f
, " %s ", this->name_
.c_str());
2156 if (this->address_
!= NULL
)
2158 this->address_
->print(f
);
2164 if (this->load_address_
!= NULL
)
2167 this->load_address_
->print(f
);
2171 if (this->align_
!= NULL
)
2173 fprintf(f
, "ALIGN(");
2174 this->align_
->print(f
);
2178 if (this->subalign_
!= NULL
)
2180 fprintf(f
, "SUBALIGN(");
2181 this->subalign_
->print(f
);
2187 for (Output_section_elements::const_iterator p
= this->elements_
.begin();
2188 p
!= this->elements_
.end();
2194 if (this->fill_
!= NULL
)
2197 this->fill_
->print(f
);
2200 if (this->phdrs_
!= NULL
)
2202 for (String_list::const_iterator p
= this->phdrs_
->begin();
2203 p
!= this->phdrs_
->end();
2205 fprintf(f
, " :%s", p
->c_str());
2211 // An output section created to hold orphaned input sections. These
2212 // do not actually appear in linker scripts. However, for convenience
2213 // when setting the output section addresses, we put a marker to these
2214 // sections in the appropriate place in the list of SECTIONS elements.
2216 class Orphan_output_section
: public Sections_element
2219 Orphan_output_section(Output_section
* os
)
2223 // Return whether the orphan output section is relro. We can just
2224 // check the output section because we always set the flag, if
2225 // needed, just after we create the Orphan_output_section.
2228 { return this->os_
->is_relro(); }
2230 // Initialize OSP with an output section. This should have been
2233 orphan_section_init(Orphan_section_placement
*,
2234 Script_sections::Elements_iterator
)
2235 { gold_unreachable(); }
2237 // Set section addresses.
2239 set_section_addresses(Symbol_table
*, Layout
*, uint64_t*, uint64_t*);
2241 // Get the list of segments to use for an allocated section when
2242 // using a PHDRS clause.
2244 allocate_to_segment(String_list
**, bool*);
2246 // Return the associated Output_section.
2248 get_output_section() const
2249 { return this->os_
; }
2251 // Print for debugging.
2253 print(FILE* f
) const
2255 fprintf(f
, " marker for orphaned output section %s\n",
2260 Output_section
* os_
;
2263 // Set section addresses.
2266 Orphan_output_section::set_section_addresses(Symbol_table
*, Layout
*,
2267 uint64_t* dot_value
,
2268 uint64_t* load_address
)
2270 typedef std::list
<Output_section::Simple_input_section
> Input_section_list
;
2272 bool have_load_address
= *load_address
!= *dot_value
;
2274 uint64_t address
= *dot_value
;
2275 address
= align_address(address
, this->os_
->addralign());
2277 if ((this->os_
->flags() & elfcpp::SHF_ALLOC
) != 0)
2279 this->os_
->set_address(address
);
2280 if (have_load_address
)
2281 this->os_
->set_load_address(align_address(*load_address
,
2282 this->os_
->addralign()));
2285 Input_section_list input_sections
;
2286 address
+= this->os_
->get_input_sections(address
, "", &input_sections
);
2288 for (Input_section_list::iterator p
= input_sections
.begin();
2289 p
!= input_sections
.end();
2295 // We know what are single-threaded, so it is OK to lock the
2298 const Task
* task
= reinterpret_cast<const Task
*>(-1);
2299 Task_lock_obj
<Object
> tl(task
, p
->relobj());
2300 addralign
= p
->relobj()->section_addralign(p
->shndx());
2301 if (p
->is_relaxed_input_section())
2302 // We use current data size because relxed section sizes may not
2303 // have finalized yet.
2304 size
= p
->relaxed_input_section()->current_data_size();
2306 size
= p
->relobj()->section_size(p
->shndx());
2309 address
= align_address(address
, addralign
);
2310 this->os_
->add_input_section_for_script(*p
, size
, addralign
);
2314 if (!have_load_address
)
2315 *load_address
= address
;
2317 *load_address
+= address
- *dot_value
;
2319 *dot_value
= address
;
2322 // Get the list of segments to use for an allocated section when using
2323 // a PHDRS clause. If this is an allocated section, return the
2324 // Output_section. We don't change the list of segments.
2327 Orphan_output_section::allocate_to_segment(String_list
**, bool* orphan
)
2329 if ((this->os_
->flags() & elfcpp::SHF_ALLOC
) == 0)
2335 // Class Phdrs_element. A program header from a PHDRS clause.
2340 Phdrs_element(const char* name
, size_t namelen
, unsigned int type
,
2341 bool includes_filehdr
, bool includes_phdrs
,
2342 bool is_flags_valid
, unsigned int flags
,
2343 Expression
* load_address
)
2344 : name_(name
, namelen
), type_(type
), includes_filehdr_(includes_filehdr
),
2345 includes_phdrs_(includes_phdrs
), is_flags_valid_(is_flags_valid
),
2346 flags_(flags
), load_address_(load_address
), load_address_value_(0),
2350 // Return the name of this segment.
2353 { return this->name_
; }
2355 // Return the type of the segment.
2358 { return this->type_
; }
2360 // Whether to include the file header.
2362 includes_filehdr() const
2363 { return this->includes_filehdr_
; }
2365 // Whether to include the program headers.
2367 includes_phdrs() const
2368 { return this->includes_phdrs_
; }
2370 // Return whether there is a load address.
2372 has_load_address() const
2373 { return this->load_address_
!= NULL
; }
2375 // Evaluate the load address expression if there is one.
2377 eval_load_address(Symbol_table
* symtab
, Layout
* layout
)
2379 if (this->load_address_
!= NULL
)
2380 this->load_address_value_
= this->load_address_
->eval(symtab
, layout
,
2384 // Return the load address.
2386 load_address() const
2388 gold_assert(this->load_address_
!= NULL
);
2389 return this->load_address_value_
;
2392 // Create the segment.
2394 create_segment(Layout
* layout
)
2396 this->segment_
= layout
->make_output_segment(this->type_
, this->flags_
);
2397 return this->segment_
;
2400 // Return the segment.
2403 { return this->segment_
; }
2405 // Release the segment.
2408 { this->segment_
= NULL
; }
2410 // Set the segment flags if appropriate.
2412 set_flags_if_valid()
2414 if (this->is_flags_valid_
)
2415 this->segment_
->set_flags(this->flags_
);
2418 // Print for debugging.
2423 // The name used in the script.
2425 // The type of the segment (PT_LOAD, etc.).
2427 // Whether this segment includes the file header.
2428 bool includes_filehdr_
;
2429 // Whether this segment includes the section headers.
2430 bool includes_phdrs_
;
2431 // Whether the flags were explicitly specified.
2432 bool is_flags_valid_
;
2433 // The flags for this segment (PF_R, etc.) if specified.
2434 unsigned int flags_
;
2435 // The expression for the load address for this segment. This may
2437 Expression
* load_address_
;
2438 // The actual load address from evaluating the expression.
2439 uint64_t load_address_value_
;
2440 // The segment itself.
2441 Output_segment
* segment_
;
2444 // Print for debugging.
2447 Phdrs_element::print(FILE* f
) const
2449 fprintf(f
, " %s 0x%x", this->name_
.c_str(), this->type_
);
2450 if (this->includes_filehdr_
)
2451 fprintf(f
, " FILEHDR");
2452 if (this->includes_phdrs_
)
2453 fprintf(f
, " PHDRS");
2454 if (this->is_flags_valid_
)
2455 fprintf(f
, " FLAGS(%u)", this->flags_
);
2456 if (this->load_address_
!= NULL
)
2459 this->load_address_
->print(f
);
2465 // Class Script_sections.
2467 Script_sections::Script_sections()
2468 : saw_sections_clause_(false),
2469 in_sections_clause_(false),
2470 sections_elements_(NULL
),
2471 output_section_(NULL
),
2472 phdrs_elements_(NULL
),
2473 orphan_section_placement_(NULL
),
2474 data_segment_align_start_(),
2475 saw_data_segment_align_(false),
2476 saw_relro_end_(false)
2480 // Start a SECTIONS clause.
2483 Script_sections::start_sections()
2485 gold_assert(!this->in_sections_clause_
&& this->output_section_
== NULL
);
2486 this->saw_sections_clause_
= true;
2487 this->in_sections_clause_
= true;
2488 if (this->sections_elements_
== NULL
)
2489 this->sections_elements_
= new Sections_elements
;
2492 // Finish a SECTIONS clause.
2495 Script_sections::finish_sections()
2497 gold_assert(this->in_sections_clause_
&& this->output_section_
== NULL
);
2498 this->in_sections_clause_
= false;
2501 // Add a symbol to be defined.
2504 Script_sections::add_symbol_assignment(const char* name
, size_t length
,
2505 Expression
* val
, bool provide
,
2508 if (this->output_section_
!= NULL
)
2509 this->output_section_
->add_symbol_assignment(name
, length
, val
,
2513 Sections_element
* p
= new Sections_element_assignment(name
, length
,
2516 this->sections_elements_
->push_back(p
);
2520 // Add an assignment to the special dot symbol.
2523 Script_sections::add_dot_assignment(Expression
* val
)
2525 if (this->output_section_
!= NULL
)
2526 this->output_section_
->add_dot_assignment(val
);
2529 Sections_element
* p
= new Sections_element_dot_assignment(val
);
2530 this->sections_elements_
->push_back(p
);
2534 // Add an assertion.
2537 Script_sections::add_assertion(Expression
* check
, const char* message
,
2540 if (this->output_section_
!= NULL
)
2541 this->output_section_
->add_assertion(check
, message
, messagelen
);
2544 Sections_element
* p
= new Sections_element_assertion(check
, message
,
2546 this->sections_elements_
->push_back(p
);
2550 // Start processing entries for an output section.
2553 Script_sections::start_output_section(
2556 const Parser_output_section_header
*header
)
2558 Output_section_definition
* posd
= new Output_section_definition(name
,
2561 this->sections_elements_
->push_back(posd
);
2562 gold_assert(this->output_section_
== NULL
);
2563 this->output_section_
= posd
;
2566 // Stop processing entries for an output section.
2569 Script_sections::finish_output_section(
2570 const Parser_output_section_trailer
* trailer
)
2572 gold_assert(this->output_section_
!= NULL
);
2573 this->output_section_
->finish(trailer
);
2574 this->output_section_
= NULL
;
2577 // Add a data item to the current output section.
2580 Script_sections::add_data(int size
, bool is_signed
, Expression
* val
)
2582 gold_assert(this->output_section_
!= NULL
);
2583 this->output_section_
->add_data(size
, is_signed
, val
);
2586 // Add a fill value setting to the current output section.
2589 Script_sections::add_fill(Expression
* val
)
2591 gold_assert(this->output_section_
!= NULL
);
2592 this->output_section_
->add_fill(val
);
2595 // Add an input section specification to the current output section.
2598 Script_sections::add_input_section(const Input_section_spec
* spec
, bool keep
)
2600 gold_assert(this->output_section_
!= NULL
);
2601 this->output_section_
->add_input_section(spec
, keep
);
2604 // This is called when we see DATA_SEGMENT_ALIGN. It means that any
2605 // subsequent output sections may be relro.
2608 Script_sections::data_segment_align()
2610 if (this->saw_data_segment_align_
)
2611 gold_error(_("DATA_SEGMENT_ALIGN may only appear once in a linker script"));
2612 gold_assert(!this->sections_elements_
->empty());
2613 Sections_elements::iterator p
= this->sections_elements_
->end();
2615 this->data_segment_align_start_
= p
;
2616 this->saw_data_segment_align_
= true;
2619 // This is called when we see DATA_SEGMENT_RELRO_END. It means that
2620 // any output sections seen since DATA_SEGMENT_ALIGN are relro.
2623 Script_sections::data_segment_relro_end()
2625 if (this->saw_relro_end_
)
2626 gold_error(_("DATA_SEGMENT_RELRO_END may only appear once "
2627 "in a linker script"));
2628 this->saw_relro_end_
= true;
2630 if (!this->saw_data_segment_align_
)
2631 gold_error(_("DATA_SEGMENT_RELRO_END must follow DATA_SEGMENT_ALIGN"));
2634 Sections_elements::iterator p
= this->data_segment_align_start_
;
2635 for (++p
; p
!= this->sections_elements_
->end(); ++p
)
2636 (*p
)->set_is_relro();
2640 // Create any required sections.
2643 Script_sections::create_sections(Layout
* layout
)
2645 if (!this->saw_sections_clause_
)
2647 for (Sections_elements::iterator p
= this->sections_elements_
->begin();
2648 p
!= this->sections_elements_
->end();
2650 (*p
)->create_sections(layout
);
2653 // Add any symbols we are defining to the symbol table.
2656 Script_sections::add_symbols_to_table(Symbol_table
* symtab
)
2658 if (!this->saw_sections_clause_
)
2660 for (Sections_elements::iterator p
= this->sections_elements_
->begin();
2661 p
!= this->sections_elements_
->end();
2663 (*p
)->add_symbols_to_table(symtab
);
2666 // Finalize symbols and check assertions.
2669 Script_sections::finalize_symbols(Symbol_table
* symtab
, const Layout
* layout
)
2671 if (!this->saw_sections_clause_
)
2673 uint64_t dot_value
= 0;
2674 for (Sections_elements::iterator p
= this->sections_elements_
->begin();
2675 p
!= this->sections_elements_
->end();
2677 (*p
)->finalize_symbols(symtab
, layout
, &dot_value
);
2680 // Return the name of the output section to use for an input file name
2681 // and section name.
2684 Script_sections::output_section_name(const char* file_name
,
2685 const char* section_name
,
2686 Output_section
*** output_section_slot
)
2688 for (Sections_elements::const_iterator p
= this->sections_elements_
->begin();
2689 p
!= this->sections_elements_
->end();
2692 const char* ret
= (*p
)->output_section_name(file_name
, section_name
,
2693 output_section_slot
);
2697 // The special name /DISCARD/ means that the input section
2698 // should be discarded.
2699 if (strcmp(ret
, "/DISCARD/") == 0)
2701 *output_section_slot
= NULL
;
2708 // If we couldn't find a mapping for the name, the output section
2709 // gets the name of the input section.
2711 *output_section_slot
= NULL
;
2713 return section_name
;
2716 // Place a marker for an orphan output section into the SECTIONS
2720 Script_sections::place_orphan(Output_section
* os
)
2722 Orphan_section_placement
* osp
= this->orphan_section_placement_
;
2725 // Initialize the Orphan_section_placement structure.
2726 osp
= new Orphan_section_placement();
2727 for (Sections_elements::iterator p
= this->sections_elements_
->begin();
2728 p
!= this->sections_elements_
->end();
2730 (*p
)->orphan_section_init(osp
, p
);
2731 gold_assert(!this->sections_elements_
->empty());
2732 Sections_elements::iterator last
= this->sections_elements_
->end();
2734 osp
->last_init(last
);
2735 this->orphan_section_placement_
= osp
;
2738 Orphan_output_section
* orphan
= new Orphan_output_section(os
);
2740 // Look for where to put ORPHAN.
2741 Sections_elements::iterator
* where
;
2742 if (osp
->find_place(os
, &where
))
2744 if ((**where
)->is_relro())
2747 os
->clear_is_relro();
2749 // We want to insert ORPHAN after *WHERE, and then update *WHERE
2750 // so that the next one goes after this one.
2751 Sections_elements::iterator p
= *where
;
2752 gold_assert(p
!= this->sections_elements_
->end());
2754 *where
= this->sections_elements_
->insert(p
, orphan
);
2758 os
->clear_is_relro();
2759 // We don't have a place to put this orphan section. Put it,
2760 // and all other sections like it, at the end, but before the
2761 // sections which always come at the end.
2762 Sections_elements::iterator last
= osp
->last_place();
2763 *where
= this->sections_elements_
->insert(last
, orphan
);
2767 // Set the addresses of all the output sections. Walk through all the
2768 // elements, tracking the dot symbol. Apply assignments which set
2769 // absolute symbol values, in case they are used when setting dot.
2770 // Fill in data statement values. As we find output sections, set the
2771 // address, set the address of all associated input sections, and
2772 // update dot. Return the segment which should hold the file header
2773 // and segment headers, if any.
2776 Script_sections::set_section_addresses(Symbol_table
* symtab
, Layout
* layout
)
2778 gold_assert(this->saw_sections_clause_
);
2780 // Implement ONLY_IF_RO/ONLY_IF_RW constraints. These are a pain
2781 // for our representation.
2782 for (Sections_elements::iterator p
= this->sections_elements_
->begin();
2783 p
!= this->sections_elements_
->end();
2786 Output_section_definition
* posd
;
2787 Section_constraint failed_constraint
= (*p
)->check_constraint(&posd
);
2788 if (failed_constraint
!= CONSTRAINT_NONE
)
2790 Sections_elements::iterator q
;
2791 for (q
= this->sections_elements_
->begin();
2792 q
!= this->sections_elements_
->end();
2797 if ((*q
)->alternate_constraint(posd
, failed_constraint
))
2802 if (q
== this->sections_elements_
->end())
2803 gold_error(_("no matching section constraint"));
2807 // Force the alignment of the first TLS section to be the maximum
2808 // alignment of all TLS sections.
2809 Output_section
* first_tls
= NULL
;
2810 uint64_t tls_align
= 0;
2811 for (Sections_elements::const_iterator p
= this->sections_elements_
->begin();
2812 p
!= this->sections_elements_
->end();
2815 Output_section
*os
= (*p
)->get_output_section();
2816 if (os
!= NULL
&& (os
->flags() & elfcpp::SHF_TLS
) != 0)
2818 if (first_tls
== NULL
)
2820 if (os
->addralign() > tls_align
)
2821 tls_align
= os
->addralign();
2824 if (first_tls
!= NULL
)
2825 first_tls
->set_addralign(tls_align
);
2827 // For a relocatable link, we implicitly set dot to zero.
2828 uint64_t dot_value
= 0;
2829 uint64_t load_address
= 0;
2830 for (Sections_elements::iterator p
= this->sections_elements_
->begin();
2831 p
!= this->sections_elements_
->end();
2833 (*p
)->set_section_addresses(symtab
, layout
, &dot_value
, &load_address
);
2835 if (this->phdrs_elements_
!= NULL
)
2837 for (Phdrs_elements::iterator p
= this->phdrs_elements_
->begin();
2838 p
!= this->phdrs_elements_
->end();
2840 (*p
)->eval_load_address(symtab
, layout
);
2843 return this->create_segments(layout
);
2846 // Sort the sections in order to put them into segments.
2848 class Sort_output_sections
2852 operator()(const Output_section
* os1
, const Output_section
* os2
) const;
2856 Sort_output_sections::operator()(const Output_section
* os1
,
2857 const Output_section
* os2
) const
2859 // Sort first by the load address.
2860 uint64_t lma1
= (os1
->has_load_address()
2861 ? os1
->load_address()
2863 uint64_t lma2
= (os2
->has_load_address()
2864 ? os2
->load_address()
2869 // Then sort by the virtual address.
2870 if (os1
->address() != os2
->address())
2871 return os1
->address() < os2
->address();
2873 // Sort TLS sections to the end.
2874 bool tls1
= (os1
->flags() & elfcpp::SHF_TLS
) != 0;
2875 bool tls2
= (os2
->flags() & elfcpp::SHF_TLS
) != 0;
2879 // Sort PROGBITS before NOBITS.
2880 if (os1
->type() == elfcpp::SHT_PROGBITS
&& os2
->type() == elfcpp::SHT_NOBITS
)
2882 if (os1
->type() == elfcpp::SHT_NOBITS
&& os2
->type() == elfcpp::SHT_PROGBITS
)
2885 // Otherwise we don't care.
2889 // Return whether OS is a BSS section. This is a SHT_NOBITS section.
2890 // We treat a section with the SHF_TLS flag set as taking up space
2891 // even if it is SHT_NOBITS (this is true of .tbss), as we allocate
2892 // space for them in the file.
2895 Script_sections::is_bss_section(const Output_section
* os
)
2897 return (os
->type() == elfcpp::SHT_NOBITS
2898 && (os
->flags() & elfcpp::SHF_TLS
) == 0);
2901 // Return the size taken by the file header and the program headers.
2904 Script_sections::total_header_size(Layout
* layout
) const
2906 size_t segment_count
= layout
->segment_count();
2907 size_t file_header_size
;
2908 size_t segment_headers_size
;
2909 if (parameters
->target().get_size() == 32)
2911 file_header_size
= elfcpp::Elf_sizes
<32>::ehdr_size
;
2912 segment_headers_size
= segment_count
* elfcpp::Elf_sizes
<32>::phdr_size
;
2914 else if (parameters
->target().get_size() == 64)
2916 file_header_size
= elfcpp::Elf_sizes
<64>::ehdr_size
;
2917 segment_headers_size
= segment_count
* elfcpp::Elf_sizes
<64>::phdr_size
;
2922 return file_header_size
+ segment_headers_size
;
2925 // Return the amount we have to subtract from the LMA to accomodate
2926 // headers of the given size. The complication is that the file
2927 // header have to be at the start of a page, as otherwise it will not
2928 // be at the start of the file.
2931 Script_sections::header_size_adjustment(uint64_t lma
,
2932 size_t sizeof_headers
) const
2934 const uint64_t abi_pagesize
= parameters
->target().abi_pagesize();
2935 uint64_t hdr_lma
= lma
- sizeof_headers
;
2936 hdr_lma
&= ~(abi_pagesize
- 1);
2937 return lma
- hdr_lma
;
2940 // Create the PT_LOAD segments when using a SECTIONS clause. Returns
2941 // the segment which should hold the file header and segment headers,
2945 Script_sections::create_segments(Layout
* layout
)
2947 gold_assert(this->saw_sections_clause_
);
2949 if (parameters
->options().relocatable())
2952 if (this->saw_phdrs_clause())
2953 return create_segments_from_phdrs_clause(layout
);
2955 Layout::Section_list sections
;
2956 layout
->get_allocated_sections(§ions
);
2958 // Sort the sections by address.
2959 std::stable_sort(sections
.begin(), sections
.end(), Sort_output_sections());
2961 this->create_note_and_tls_segments(layout
, §ions
);
2963 // Walk through the sections adding them to PT_LOAD segments.
2964 const uint64_t abi_pagesize
= parameters
->target().abi_pagesize();
2965 Output_segment
* first_seg
= NULL
;
2966 Output_segment
* current_seg
= NULL
;
2967 bool is_current_seg_readonly
= true;
2968 Layout::Section_list::iterator plast
= sections
.end();
2969 uint64_t last_vma
= 0;
2970 uint64_t last_lma
= 0;
2971 uint64_t last_size
= 0;
2972 for (Layout::Section_list::iterator p
= sections
.begin();
2973 p
!= sections
.end();
2976 const uint64_t vma
= (*p
)->address();
2977 const uint64_t lma
= ((*p
)->has_load_address()
2978 ? (*p
)->load_address()
2980 const uint64_t size
= (*p
)->current_data_size();
2982 bool need_new_segment
;
2983 if (current_seg
== NULL
)
2984 need_new_segment
= true;
2985 else if (lma
- vma
!= last_lma
- last_vma
)
2987 // This section has a different LMA relationship than the
2988 // last one; we need a new segment.
2989 need_new_segment
= true;
2991 else if (align_address(last_lma
+ last_size
, abi_pagesize
)
2992 < align_address(lma
, abi_pagesize
))
2994 // Putting this section in the segment would require
2996 need_new_segment
= true;
2998 else if (is_bss_section(*plast
) && !is_bss_section(*p
))
3000 // A non-BSS section can not follow a BSS section in the
3002 need_new_segment
= true;
3004 else if (is_current_seg_readonly
3005 && ((*p
)->flags() & elfcpp::SHF_WRITE
) != 0
3006 && !parameters
->options().omagic())
3008 // Don't put a writable section in the same segment as a
3009 // non-writable section.
3010 need_new_segment
= true;
3014 // Otherwise, reuse the existing segment.
3015 need_new_segment
= false;
3018 elfcpp::Elf_Word seg_flags
=
3019 Layout::section_flags_to_segment((*p
)->flags());
3021 if (need_new_segment
)
3023 current_seg
= layout
->make_output_segment(elfcpp::PT_LOAD
,
3025 current_seg
->set_addresses(vma
, lma
);
3026 if (first_seg
== NULL
)
3027 first_seg
= current_seg
;
3028 is_current_seg_readonly
= true;
3031 current_seg
->add_output_section(*p
, seg_flags
);
3033 if (((*p
)->flags() & elfcpp::SHF_WRITE
) != 0)
3034 is_current_seg_readonly
= false;
3042 // An ELF program should work even if the program headers are not in
3043 // a PT_LOAD segment. However, it appears that the Linux kernel
3044 // does not set the AT_PHDR auxiliary entry in that case. It sets
3045 // the load address to p_vaddr - p_offset of the first PT_LOAD
3046 // segment. It then sets AT_PHDR to the load address plus the
3047 // offset to the program headers, e_phoff in the file header. This
3048 // fails when the program headers appear in the file before the
3049 // first PT_LOAD segment. Therefore, we always create a PT_LOAD
3050 // segment to hold the file header and the program headers. This is
3051 // effectively what the GNU linker does, and it is slightly more
3052 // efficient in any case. We try to use the first PT_LOAD segment
3053 // if we can, otherwise we make a new one.
3055 if (first_seg
== NULL
)
3058 // -n or -N mean that the program is not demand paged and there is
3059 // no need to put the program headers in a PT_LOAD segment.
3060 if (parameters
->options().nmagic() || parameters
->options().omagic())
3063 size_t sizeof_headers
= this->total_header_size(layout
);
3065 uint64_t vma
= first_seg
->vaddr();
3066 uint64_t lma
= first_seg
->paddr();
3068 uint64_t subtract
= this->header_size_adjustment(lma
, sizeof_headers
);
3070 if ((lma
& (abi_pagesize
- 1)) >= sizeof_headers
)
3072 first_seg
->set_addresses(vma
- subtract
, lma
- subtract
);
3076 // If there is no room to squeeze in the headers, then punt. The
3077 // resulting executable probably won't run on GNU/Linux, but we
3078 // trust that the user knows what they are doing.
3079 if (lma
< subtract
|| vma
< subtract
)
3082 Output_segment
* load_seg
= layout
->make_output_segment(elfcpp::PT_LOAD
,
3084 load_seg
->set_addresses(vma
- subtract
, lma
- subtract
);
3089 // Create a PT_NOTE segment for each SHT_NOTE section and a PT_TLS
3090 // segment if there are any SHT_TLS sections.
3093 Script_sections::create_note_and_tls_segments(
3095 const Layout::Section_list
* sections
)
3097 gold_assert(!this->saw_phdrs_clause());
3099 bool saw_tls
= false;
3100 for (Layout::Section_list::const_iterator p
= sections
->begin();
3101 p
!= sections
->end();
3104 if ((*p
)->type() == elfcpp::SHT_NOTE
)
3106 elfcpp::Elf_Word seg_flags
=
3107 Layout::section_flags_to_segment((*p
)->flags());
3108 Output_segment
* oseg
= layout
->make_output_segment(elfcpp::PT_NOTE
,
3110 oseg
->add_output_section(*p
, seg_flags
);
3112 // Incorporate any subsequent SHT_NOTE sections, in the
3113 // hopes that the script is sensible.
3114 Layout::Section_list::const_iterator pnext
= p
+ 1;
3115 while (pnext
!= sections
->end()
3116 && (*pnext
)->type() == elfcpp::SHT_NOTE
)
3118 seg_flags
= Layout::section_flags_to_segment((*pnext
)->flags());
3119 oseg
->add_output_section(*pnext
, seg_flags
);
3125 if (((*p
)->flags() & elfcpp::SHF_TLS
) != 0)
3128 gold_error(_("TLS sections are not adjacent"));
3130 elfcpp::Elf_Word seg_flags
=
3131 Layout::section_flags_to_segment((*p
)->flags());
3132 Output_segment
* oseg
= layout
->make_output_segment(elfcpp::PT_TLS
,
3134 oseg
->add_output_section(*p
, seg_flags
);
3136 Layout::Section_list::const_iterator pnext
= p
+ 1;
3137 while (pnext
!= sections
->end()
3138 && ((*pnext
)->flags() & elfcpp::SHF_TLS
) != 0)
3140 seg_flags
= Layout::section_flags_to_segment((*pnext
)->flags());
3141 oseg
->add_output_section(*pnext
, seg_flags
);
3151 // Add a program header. The PHDRS clause is syntactically distinct
3152 // from the SECTIONS clause, but we implement it with the SECTIONS
3153 // support because PHDRS is useless if there is no SECTIONS clause.
3156 Script_sections::add_phdr(const char* name
, size_t namelen
, unsigned int type
,
3157 bool includes_filehdr
, bool includes_phdrs
,
3158 bool is_flags_valid
, unsigned int flags
,
3159 Expression
* load_address
)
3161 if (this->phdrs_elements_
== NULL
)
3162 this->phdrs_elements_
= new Phdrs_elements();
3163 this->phdrs_elements_
->push_back(new Phdrs_element(name
, namelen
, type
,
3166 is_flags_valid
, flags
,
3170 // Return the number of segments we expect to create based on the
3171 // SECTIONS clause. This is used to implement SIZEOF_HEADERS.
3174 Script_sections::expected_segment_count(const Layout
* layout
) const
3176 if (this->saw_phdrs_clause())
3177 return this->phdrs_elements_
->size();
3179 Layout::Section_list sections
;
3180 layout
->get_allocated_sections(§ions
);
3182 // We assume that we will need two PT_LOAD segments.
3185 bool saw_note
= false;
3186 bool saw_tls
= false;
3187 for (Layout::Section_list::const_iterator p
= sections
.begin();
3188 p
!= sections
.end();
3191 if ((*p
)->type() == elfcpp::SHT_NOTE
)
3193 // Assume that all note sections will fit into a single
3201 else if (((*p
)->flags() & elfcpp::SHF_TLS
) != 0)
3203 // There can only be one PT_TLS segment.
3215 // Create the segments from a PHDRS clause. Return the segment which
3216 // should hold the file header and program headers, if any.
3219 Script_sections::create_segments_from_phdrs_clause(Layout
* layout
)
3221 this->attach_sections_using_phdrs_clause(layout
);
3222 return this->set_phdrs_clause_addresses(layout
);
3225 // Create the segments from the PHDRS clause, and put the output
3226 // sections in them.
3229 Script_sections::attach_sections_using_phdrs_clause(Layout
* layout
)
3231 typedef std::map
<std::string
, Output_segment
*> Name_to_segment
;
3232 Name_to_segment name_to_segment
;
3233 for (Phdrs_elements::const_iterator p
= this->phdrs_elements_
->begin();
3234 p
!= this->phdrs_elements_
->end();
3236 name_to_segment
[(*p
)->name()] = (*p
)->create_segment(layout
);
3238 // Walk through the output sections and attach them to segments.
3239 // Output sections in the script which do not list segments are
3240 // attached to the same set of segments as the immediately preceding
3243 String_list
* phdr_names
= NULL
;
3244 bool load_segments_only
= false;
3245 for (Sections_elements::const_iterator p
= this->sections_elements_
->begin();
3246 p
!= this->sections_elements_
->end();
3250 String_list
* old_phdr_names
= phdr_names
;
3251 Output_section
* os
= (*p
)->allocate_to_segment(&phdr_names
, &orphan
);
3255 if (phdr_names
== NULL
)
3257 gold_error(_("allocated section not in any segment"));
3261 // We see a list of segments names. Disable PT_LOAD segment only
3263 if (old_phdr_names
!= phdr_names
)
3264 load_segments_only
= false;
3266 // If this is an orphan section--one that was not explicitly
3267 // mentioned in the linker script--then it should not inherit
3268 // any segment type other than PT_LOAD. Otherwise, e.g., the
3269 // PT_INTERP segment will pick up following orphan sections,
3270 // which does not make sense. If this is not an orphan section,
3271 // we trust the linker script.
3274 // Enable PT_LOAD segments only filtering until we see another
3275 // list of segment names.
3276 load_segments_only
= true;
3279 bool in_load_segment
= false;
3280 for (String_list::const_iterator q
= phdr_names
->begin();
3281 q
!= phdr_names
->end();
3284 Name_to_segment::const_iterator r
= name_to_segment
.find(*q
);
3285 if (r
== name_to_segment
.end())
3286 gold_error(_("no segment %s"), q
->c_str());
3289 if (load_segments_only
3290 && r
->second
->type() != elfcpp::PT_LOAD
)
3293 elfcpp::Elf_Word seg_flags
=
3294 Layout::section_flags_to_segment(os
->flags());
3295 r
->second
->add_output_section(os
, seg_flags
);
3297 if (r
->second
->type() == elfcpp::PT_LOAD
)
3299 if (in_load_segment
)
3300 gold_error(_("section in two PT_LOAD segments"));
3301 in_load_segment
= true;
3306 if (!in_load_segment
)
3307 gold_error(_("allocated section not in any PT_LOAD segment"));
3311 // Set the addresses for segments created from a PHDRS clause. Return
3312 // the segment which should hold the file header and program headers,
3316 Script_sections::set_phdrs_clause_addresses(Layout
* layout
)
3318 Output_segment
* load_seg
= NULL
;
3319 for (Phdrs_elements::const_iterator p
= this->phdrs_elements_
->begin();
3320 p
!= this->phdrs_elements_
->end();
3323 // Note that we have to set the flags after adding the output
3324 // sections to the segment, as adding an output segment can
3325 // change the flags.
3326 (*p
)->set_flags_if_valid();
3328 Output_segment
* oseg
= (*p
)->segment();
3330 if (oseg
->type() != elfcpp::PT_LOAD
)
3332 // The addresses of non-PT_LOAD segments are set from the
3333 // PT_LOAD segments.
3334 if ((*p
)->has_load_address())
3335 gold_error(_("may only specify load address for PT_LOAD segment"));
3339 // The output sections should have addresses from the SECTIONS
3340 // clause. The addresses don't have to be in order, so find the
3341 // one with the lowest load address. Use that to set the
3342 // address of the segment.
3344 Output_section
* osec
= oseg
->section_with_lowest_load_address();
3347 oseg
->set_addresses(0, 0);
3351 uint64_t vma
= osec
->address();
3352 uint64_t lma
= osec
->has_load_address() ? osec
->load_address() : vma
;
3354 // Override the load address of the section with the load
3355 // address specified for the segment.
3356 if ((*p
)->has_load_address())
3358 if (osec
->has_load_address())
3359 gold_warning(_("PHDRS load address overrides "
3360 "section %s load address"),
3363 lma
= (*p
)->load_address();
3366 bool headers
= (*p
)->includes_filehdr() && (*p
)->includes_phdrs();
3367 if (!headers
&& ((*p
)->includes_filehdr() || (*p
)->includes_phdrs()))
3369 // We could support this if we wanted to.
3370 gold_error(_("using only one of FILEHDR and PHDRS is "
3371 "not currently supported"));
3375 size_t sizeof_headers
= this->total_header_size(layout
);
3376 uint64_t subtract
= this->header_size_adjustment(lma
,
3378 if (lma
>= subtract
&& vma
>= subtract
)
3385 gold_error(_("sections loaded on first page without room "
3386 "for file and program headers "
3387 "are not supported"));
3390 if (load_seg
!= NULL
)
3391 gold_error(_("using FILEHDR and PHDRS on more than one "
3392 "PT_LOAD segment is not currently supported"));
3396 oseg
->set_addresses(vma
, lma
);
3402 // Add the file header and segment headers to non-load segments
3403 // specified in the PHDRS clause.
3406 Script_sections::put_headers_in_phdrs(Output_data
* file_header
,
3407 Output_data
* segment_headers
)
3409 gold_assert(this->saw_phdrs_clause());
3410 for (Phdrs_elements::iterator p
= this->phdrs_elements_
->begin();
3411 p
!= this->phdrs_elements_
->end();
3414 if ((*p
)->type() != elfcpp::PT_LOAD
)
3416 if ((*p
)->includes_phdrs())
3417 (*p
)->segment()->add_initial_output_data(segment_headers
);
3418 if ((*p
)->includes_filehdr())
3419 (*p
)->segment()->add_initial_output_data(file_header
);
3424 // Look for an output section by name and return the address, the load
3425 // address, the alignment, and the size. This is used when an
3426 // expression refers to an output section which was not actually
3427 // created. This returns true if the section was found, false
3431 Script_sections::get_output_section_info(const char* name
, uint64_t* address
,
3432 uint64_t* load_address
,
3433 uint64_t* addralign
,
3434 uint64_t* size
) const
3436 if (!this->saw_sections_clause_
)
3438 for (Sections_elements::const_iterator p
= this->sections_elements_
->begin();
3439 p
!= this->sections_elements_
->end();
3441 if ((*p
)->get_output_section_info(name
, address
, load_address
, addralign
,
3447 // Release all Output_segments. This remove all pointers to all
3451 Script_sections::release_segments()
3453 if (this->saw_phdrs_clause())
3455 for (Phdrs_elements::const_iterator p
= this->phdrs_elements_
->begin();
3456 p
!= this->phdrs_elements_
->end();
3458 (*p
)->release_segment();
3462 // Print the SECTIONS clause to F for debugging.
3465 Script_sections::print(FILE* f
) const
3467 if (!this->saw_sections_clause_
)
3470 fprintf(f
, "SECTIONS {\n");
3472 for (Sections_elements::const_iterator p
= this->sections_elements_
->begin();
3473 p
!= this->sections_elements_
->end();
3479 if (this->phdrs_elements_
!= NULL
)
3481 fprintf(f
, "PHDRS {\n");
3482 for (Phdrs_elements::const_iterator p
= this->phdrs_elements_
->begin();
3483 p
!= this->phdrs_elements_
->end();
3490 } // End namespace gold.