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, false, 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, false, 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 uint64_t dot = *dot_value;
1376 for (size_t i = 0; i < input_pattern_count; ++i)
1378 if (matching_sections[i].empty())
1381 gold_assert(output_section != NULL);
1383 const Input_section_pattern& isp(this->input_section_patterns_[i]);
1384 if (isp.sort != SORT_WILDCARD_NONE
1385 || this->filename_sort_ != SORT_WILDCARD_NONE)
1386 std::stable_sort(matching_sections[i].begin(),
1387 matching_sections[i].end(),
1388 Input_section_sorter(this->filename_sort_,
1391 for (std::vector<Input_section_info>::const_iterator p =
1392 matching_sections[i].begin();
1393 p != matching_sections[i].end();
1396 uint64_t this_subalign = p->addralign();
1397 if (this_subalign < subalign)
1398 this_subalign = subalign;
1400 uint64_t address = align_address(dot, this_subalign);
1402 if (address > dot && !fill->empty())
1404 section_size_type length =
1405 convert_to_section_size_type(address - dot);
1406 std::string this_fill = this->get_fill_string(fill, length);
1407 Output_section_data* posd = new Output_data_const(this_fill, 0);
1408 output_section->add_output_section_data(posd);
1409 layout->new_output_section_data_from_script(posd);
1412 output_section->add_input_section_for_script(p->input_section(),
1416 dot = address + p->size();
1420 // An SHF_TLS/SHT_NOBITS section does not take up any
1422 if (output_section == NULL
1423 || (output_section->flags() & elfcpp::SHF_TLS) == 0
1424 || output_section->type() != elfcpp::SHT_NOBITS)
1427 this->final_dot_value_ = *dot_value;
1428 this->final_dot_section_ = *dot_section;
1431 // Print for debugging.
1434 Output_section_element_input::print(FILE* f) const
1439 fprintf(f, "KEEP(");
1441 if (!this->filename_pattern_.empty())
1443 bool need_close_paren = false;
1444 switch (this->filename_sort_)
1446 case SORT_WILDCARD_NONE:
1448 case SORT_WILDCARD_BY_NAME:
1449 fprintf(f, "SORT_BY_NAME(");
1450 need_close_paren = true;
1456 fprintf(f, "%s", this->filename_pattern_.c_str());
1458 if (need_close_paren)
1462 if (!this->input_section_patterns_.empty()
1463 || !this->filename_exclusions_.empty())
1467 bool need_space = false;
1468 if (!this->filename_exclusions_.empty())
1470 fprintf(f, "EXCLUDE_FILE(");
1471 bool need_comma = false;
1472 for (Filename_exclusions::const_iterator p =
1473 this->filename_exclusions_.begin();
1474 p != this->filename_exclusions_.end();
1479 fprintf(f, "%s", p->first.c_str());
1486 for (Input_section_patterns::const_iterator p =
1487 this->input_section_patterns_.begin();
1488 p != this->input_section_patterns_.end();
1494 int close_parens = 0;
1497 case SORT_WILDCARD_NONE:
1499 case SORT_WILDCARD_BY_NAME:
1500 fprintf(f, "SORT_BY_NAME(");
1503 case SORT_WILDCARD_BY_ALIGNMENT:
1504 fprintf(f, "SORT_BY_ALIGNMENT(");
1507 case SORT_WILDCARD_BY_NAME_BY_ALIGNMENT:
1508 fprintf(f, "SORT_BY_NAME(SORT_BY_ALIGNMENT(");
1511 case SORT_WILDCARD_BY_ALIGNMENT_BY_NAME:
1512 fprintf(f, "SORT_BY_ALIGNMENT(SORT_BY_NAME(");
1519 fprintf(f, "%s", p->pattern.c_str());
1521 for (int i = 0; i < close_parens; ++i)
1536 // An output section.
1538 class Output_section_definition : public Sections_element
1541 typedef Output_section_element::Input_section_list Input_section_list;
1543 Output_section_definition(const char* name, size_t namelen,
1544 const Parser_output_section_header* header);
1546 // Finish the output section with the information in the trailer.
1548 finish(const Parser_output_section_trailer* trailer);
1550 // Add a symbol to be defined.
1552 add_symbol_assignment(const char* name, size_t length, Expression* value,
1553 bool provide, bool hidden);
1555 // Add an assignment to the special dot symbol.
1557 add_dot_assignment(Expression* value);
1559 // Add an assertion.
1561 add_assertion(Expression* check, const char* message, size_t messagelen);
1563 // Add a data item to the current output section.
1565 add_data(int size, bool is_signed, Expression* val);
1567 // Add a setting for the fill value.
1569 add_fill(Expression* val);
1571 // Add an input section specification.
1573 add_input_section(const Input_section_spec* spec, bool keep);
1575 // Return whether the output section is relro.
1578 { return this->is_relro_; }
1580 // Record that the output section is relro.
1583 { this->is_relro_ = true; }
1585 // Create any required output sections.
1587 create_sections(Layout*);
1589 // Add any symbols being defined to the symbol table.
1591 add_symbols_to_table(Symbol_table* symtab);
1593 // Finalize symbols and check assertions.
1595 finalize_symbols(Symbol_table*, const Layout*, uint64_t*);
1597 // Return the output section name to use for an input file name and
1600 output_section_name(const char* file_name, const char* section_name,
1603 // Initialize OSP with an output section.
1605 orphan_section_init(Orphan_section_placement* osp,
1606 Script_sections::Elements_iterator p)
1607 { osp->output_section_init(this->name_, this->output_section_, p); }
1609 // Set the section address.
1611 set_section_addresses(Symbol_table* symtab, Layout* layout,
1612 uint64_t* dot_value, uint64_t* load_address);
1614 // Check a constraint (ONLY_IF_RO, etc.) on an output section. If
1615 // this section is constrained, and the input sections do not match,
1616 // return the constraint, and set *POSD.
1618 check_constraint(Output_section_definition** posd);
1620 // See if this is the alternate output section for a constrained
1621 // output section. If it is, transfer the Output_section and return
1622 // true. Otherwise return false.
1624 alternate_constraint(Output_section_definition*, Section_constraint);
1626 // Get the list of segments to use for an allocated section when
1627 // using a PHDRS clause.
1629 allocate_to_segment(String_list** phdrs_list, bool* orphan);
1631 // Look for an output section by name and return the address, the
1632 // load address, the alignment, and the size. This is used when an
1633 // expression refers to an output section which was not actually
1634 // created. This returns true if the section was found, false
1637 get_output_section_info(const char*, uint64_t*, uint64_t*, uint64_t*,
1640 // Return the associated Output_section if there is one.
1642 get_output_section() const
1643 { return this->output_section_; }
1645 // Print the contents to the FILE. This is for debugging.
1650 typedef std::vector<Output_section_element*> Output_section_elements;
1652 // The output section name.
1654 // The address. This may be NULL.
1655 Expression* address_;
1656 // The load address. This may be NULL.
1657 Expression* load_address_;
1658 // The alignment. This may be NULL.
1660 // The input section alignment. This may be NULL.
1661 Expression* subalign_;
1662 // The constraint, if any.
1663 Section_constraint constraint_;
1664 // The fill value. This may be NULL.
1666 // The list of segments this section should go into. This may be
1668 String_list* phdrs_;
1669 // The list of elements defining the section.
1670 Output_section_elements elements_;
1671 // The Output_section created for this definition. This will be
1672 // NULL if none was created.
1673 Output_section* output_section_;
1674 // The address after it has been evaluated.
1675 uint64_t evaluated_address_;
1676 // The load address after it has been evaluated.
1677 uint64_t evaluated_load_address_;
1678 // The alignment after it has been evaluated.
1679 uint64_t evaluated_addralign_;
1680 // The output section is relro.
1686 Output_section_definition::Output_section_definition(
1689 const Parser_output_section_header* header)
1690 : name_(name, namelen),
1691 address_(header->address),
1692 load_address_(header->load_address),
1693 align_(header->align),
1694 subalign_(header->subalign),
1695 constraint_(header->constraint),
1699 output_section_(NULL),
1700 evaluated_address_(0),
1701 evaluated_load_address_(0),
1702 evaluated_addralign_(0),
1707 // Finish an output section.
1710 Output_section_definition::finish(const Parser_output_section_trailer* trailer)
1712 this->fill_ = trailer->fill;
1713 this->phdrs_ = trailer->phdrs;
1716 // Add a symbol to be defined.
1719 Output_section_definition::add_symbol_assignment(const char* name,
1725 Output_section_element* p = new Output_section_element_assignment(name,
1730 this->elements_.push_back(p);
1733 // Add an assignment to the special dot symbol.
1736 Output_section_definition::add_dot_assignment(Expression* value)
1738 Output_section_element* p = new Output_section_element_dot_assignment(value);
1739 this->elements_.push_back(p);
1742 // Add an assertion.
1745 Output_section_definition::add_assertion(Expression* check,
1746 const char* message,
1749 Output_section_element* p = new Output_section_element_assertion(check,
1752 this->elements_.push_back(p);
1755 // Add a data item to the current output section.
1758 Output_section_definition::add_data(int size, bool is_signed, Expression* val)
1760 Output_section_element* p = new Output_section_element_data(size, is_signed,
1762 this->elements_.push_back(p);
1765 // Add a setting for the fill value.
1768 Output_section_definition::add_fill(Expression* val)
1770 Output_section_element* p = new Output_section_element_fill(val);
1771 this->elements_.push_back(p);
1774 // Add an input section specification.
1777 Output_section_definition::add_input_section(const Input_section_spec* spec,
1780 Output_section_element* p = new Output_section_element_input(spec, keep);
1781 this->elements_.push_back(p);
1784 // Create any required output sections. We need an output section if
1785 // there is a data statement here.
1788 Output_section_definition::create_sections(Layout* layout)
1790 if (this->output_section_ != NULL)
1792 for (Output_section_elements::const_iterator p = this->elements_.begin();
1793 p != this->elements_.end();
1796 if ((*p)->needs_output_section())
1798 const char* name = this->name_.c_str();
1799 this->output_section_ = layout->make_output_section_for_script(name);
1805 // Add any symbols being defined to the symbol table.
1808 Output_section_definition::add_symbols_to_table(Symbol_table* symtab)
1810 for (Output_section_elements::iterator p = this->elements_.begin();
1811 p != this->elements_.end();
1813 (*p)->add_symbols_to_table(symtab);
1816 // Finalize symbols and check assertions.
1819 Output_section_definition::finalize_symbols(Symbol_table* symtab,
1820 const Layout* layout,
1821 uint64_t* dot_value)
1823 if (this->output_section_ != NULL)
1824 *dot_value = this->output_section_->address();
1827 uint64_t address = *dot_value;
1828 if (this->address_ != NULL)
1830 Output_section* dummy;
1831 address = this->address_->eval_with_dot(symtab, layout, true,
1835 if (this->align_ != NULL)
1837 Output_section* dummy;
1838 uint64_t align = this->align_->eval_with_dot(symtab, layout, true,
1842 address = align_address(address, align);
1844 *dot_value = address;
1847 Output_section* dot_section = this->output_section_;
1848 for (Output_section_elements::iterator p = this->elements_.begin();
1849 p != this->elements_.end();
1851 (*p)->finalize_symbols(symtab, layout, dot_value, &dot_section);
1854 // Return the output section name to use for an input section name.
1857 Output_section_definition::output_section_name(const char* file_name,
1858 const char* section_name,
1859 Output_section*** slot)
1861 // Ask each element whether it matches NAME.
1862 for (Output_section_elements::const_iterator p = this->elements_.begin();
1863 p != this->elements_.end();
1866 if ((*p)->match_name(file_name, section_name))
1868 // We found a match for NAME, which means that it should go
1869 // into this output section.
1870 *slot = &this->output_section_;
1871 return this->name_.c_str();
1875 // We don't know about this section name.
1879 // Set the section address. Note that the OUTPUT_SECTION_ field will
1880 // be NULL if no input sections were mapped to this output section.
1881 // We still have to adjust dot and process symbol assignments.
1884 Output_section_definition::set_section_addresses(Symbol_table* symtab,
1886 uint64_t* dot_value,
1887 uint64_t* load_address)
1890 if (this->address_ == NULL)
1891 address = *dot_value;
1894 Output_section* dummy;
1895 address = this->address_->eval_with_dot(symtab, layout, true,
1896 *dot_value, NULL, &dummy);
1900 if (this->align_ == NULL)
1902 if (this->output_section_ == NULL)
1905 align = this->output_section_->addralign();
1909 Output_section* align_section;
1910 align = this->align_->eval_with_dot(symtab, layout, true, *dot_value,
1911 NULL, &align_section);
1912 if (align_section != NULL)
1913 gold_warning(_("alignment of section %s is not absolute"),
1914 this->name_.c_str());
1915 if (this->output_section_ != NULL)
1916 this->output_section_->set_addralign(align);
1919 address = align_address(address, align);
1921 uint64_t start_address = address;
1923 *dot_value = address;
1925 // The address of non-SHF_ALLOC sections is forced to zero,
1926 // regardless of what the linker script wants.
1927 if (this->output_section_ != NULL
1928 && (this->output_section_->flags() & elfcpp::SHF_ALLOC) != 0)
1929 this->output_section_->set_address(address);
1931 this->evaluated_address_ = address;
1932 this->evaluated_addralign_ = align;
1934 if (this->load_address_ == NULL)
1935 this->evaluated_load_address_ = address;
1938 Output_section* dummy;
1940 this->load_address_->eval_with_dot(symtab, layout, true, *dot_value,
1941 this->output_section_, &dummy);
1942 if (this->output_section_ != NULL)
1943 this->output_section_->set_load_address(laddr);
1944 this->evaluated_load_address_ = laddr;
1948 if (this->subalign_ == NULL)
1952 Output_section* subalign_section;
1953 subalign = this->subalign_->eval_with_dot(symtab, layout, true,
1956 if (subalign_section != NULL)
1957 gold_warning(_("subalign of section %s is not absolute"),
1958 this->name_.c_str());
1962 if (this->fill_ != NULL)
1964 // FIXME: The GNU linker supports fill values of arbitrary
1966 Output_section* fill_section;
1967 uint64_t fill_val = this->fill_->eval_with_dot(symtab, layout, true,
1971 if (fill_section != NULL)
1972 gold_warning(_("fill of section %s is not absolute"),
1973 this->name_.c_str());
1974 unsigned char fill_buff[4];
1975 elfcpp::Swap_unaligned<32, true>::writeval(fill_buff, fill_val);
1976 fill.assign(reinterpret_cast<char*>(fill_buff), 4);
1979 Input_section_list input_sections;
1980 if (this->output_section_ != NULL)
1982 // Get the list of input sections attached to this output
1983 // section. This will leave the output section with only
1984 // Output_section_data entries.
1985 address += this->output_section_->get_input_sections(address,
1988 *dot_value = address;
1991 Output_section* dot_section = this->output_section_;
1992 for (Output_section_elements::iterator p = this->elements_.begin();
1993 p != this->elements_.end();
1995 (*p)->set_section_addresses(symtab, layout, this->output_section_,
1996 subalign, dot_value, &dot_section, &fill,
1999 gold_assert(input_sections.empty());
2001 if (this->load_address_ == NULL || this->output_section_ == NULL)
2002 *load_address = *dot_value;
2004 *load_address = (this->output_section_->load_address()
2005 + (*dot_value - start_address));
2007 if (this->output_section_ != NULL)
2009 if (this->is_relro_)
2010 this->output_section_->set_is_relro();
2012 this->output_section_->clear_is_relro();
2016 // Check a constraint (ONLY_IF_RO, etc.) on an output section. If
2017 // this section is constrained, and the input sections do not match,
2018 // return the constraint, and set *POSD.
2021 Output_section_definition::check_constraint(Output_section_definition** posd)
2023 switch (this->constraint_)
2025 case CONSTRAINT_NONE:
2026 return CONSTRAINT_NONE;
2028 case CONSTRAINT_ONLY_IF_RO:
2029 if (this->output_section_ != NULL
2030 && (this->output_section_->flags() & elfcpp::SHF_WRITE) != 0)
2033 return CONSTRAINT_ONLY_IF_RO;
2035 return CONSTRAINT_NONE;
2037 case CONSTRAINT_ONLY_IF_RW:
2038 if (this->output_section_ != NULL
2039 && (this->output_section_->flags() & elfcpp::SHF_WRITE) == 0)
2042 return CONSTRAINT_ONLY_IF_RW;
2044 return CONSTRAINT_NONE;
2046 case CONSTRAINT_SPECIAL:
2047 if (this->output_section_ != NULL)
2048 gold_error(_("SPECIAL constraints are not implemented"));
2049 return CONSTRAINT_NONE;
2056 // See if this is the alternate output section for a constrained
2057 // output section. If it is, transfer the Output_section and return
2058 // true. Otherwise return false.
2061 Output_section_definition::alternate_constraint(
2062 Output_section_definition* posd,
2063 Section_constraint constraint)
2065 if (this->name_ != posd->name_)
2070 case CONSTRAINT_ONLY_IF_RO:
2071 if (this->constraint_ != CONSTRAINT_ONLY_IF_RW)
2075 case CONSTRAINT_ONLY_IF_RW:
2076 if (this->constraint_ != CONSTRAINT_ONLY_IF_RO)
2084 // We have found the alternate constraint. We just need to move
2085 // over the Output_section. When constraints are used properly,
2086 // THIS should not have an output_section pointer, as all the input
2087 // sections should have matched the other definition.
2089 if (this->output_section_ != NULL)
2090 gold_error(_("mismatched definition for constrained sections"));
2092 this->output_section_ = posd->output_section_;
2093 posd->output_section_ = NULL;
2095 if (this->is_relro_)
2096 this->output_section_->set_is_relro();
2098 this->output_section_->clear_is_relro();
2103 // Get the list of segments to use for an allocated section when using
2107 Output_section_definition::allocate_to_segment(String_list** phdrs_list,
2110 if (this->output_section_ == NULL)
2112 if ((this->output_section_->flags() & elfcpp::SHF_ALLOC) == 0)
2115 if (this->phdrs_ != NULL)
2116 *phdrs_list = this->phdrs_;
2117 return this->output_section_;
2120 // Look for an output section by name and return the address, the load
2121 // address, the alignment, and the size. This is used when an
2122 // expression refers to an output section which was not actually
2123 // created. This returns true if the section was found, false
2127 Output_section_definition::get_output_section_info(const char* name,
2129 uint64_t* load_address,
2130 uint64_t* addralign,
2131 uint64_t* size) const
2133 if (this->name_ != name)
2136 if (this->output_section_ != NULL)
2138 *address = this->output_section_->address();
2139 if (this->output_section_->has_load_address())
2140 *load_address = this->output_section_->load_address();
2142 *load_address = *address;
2143 *addralign = this->output_section_->addralign();
2144 *size = this->output_section_->current_data_size();
2148 *address = this->evaluated_address_;
2149 *load_address = this->evaluated_load_address_;
2150 *addralign = this->evaluated_addralign_;
2157 // Print for debugging.
2160 Output_section_definition::print(FILE* f) const
2162 fprintf(f, " %s ", this->name_.c_str());
2164 if (this->address_ != NULL)
2166 this->address_->print(f);
2172 if (this->load_address_ != NULL)
2175 this->load_address_->print(f);
2179 if (this->align_ != NULL)
2181 fprintf(f, "ALIGN(");
2182 this->align_->print(f);
2186 if (this->subalign_ != NULL)
2188 fprintf(f, "SUBALIGN(");
2189 this->subalign_->print(f);
2195 for (Output_section_elements::const_iterator p = this->elements_.begin();
2196 p != this->elements_.end();
2202 if (this->fill_ != NULL)
2205 this->fill_->print(f);
2208 if (this->phdrs_ != NULL)
2210 for (String_list::const_iterator p = this->phdrs_->begin();
2211 p != this->phdrs_->end();
2213 fprintf(f, " :%s", p->c_str());
2219 // An output section created to hold orphaned input sections. These
2220 // do not actually appear in linker scripts. However, for convenience
2221 // when setting the output section addresses, we put a marker to these
2222 // sections in the appropriate place in the list of SECTIONS elements.
2224 class Orphan_output_section : public Sections_element
2227 Orphan_output_section(Output_section* os)
2231 // Return whether the orphan output section is relro. We can just
2232 // check the output section because we always set the flag, if
2233 // needed, just after we create the Orphan_output_section.
2236 { return this->os_->is_relro(); }
2238 // Initialize OSP with an output section. This should have been
2241 orphan_section_init(Orphan_section_placement*,
2242 Script_sections::Elements_iterator)
2243 { gold_unreachable(); }
2245 // Set section addresses.
2247 set_section_addresses(Symbol_table*, Layout*, uint64_t*, uint64_t*);
2249 // Get the list of segments to use for an allocated section when
2250 // using a PHDRS clause.
2252 allocate_to_segment(String_list**, bool*);
2254 // Return the associated Output_section.
2256 get_output_section() const
2257 { return this->os_; }
2259 // Print for debugging.
2261 print(FILE* f) const
2263 fprintf(f, " marker for orphaned output section %s\n",
2268 Output_section* os_;
2271 // Set section addresses.
2274 Orphan_output_section::set_section_addresses(Symbol_table*, Layout*,
2275 uint64_t* dot_value,
2276 uint64_t* load_address)
2278 typedef std::list<Output_section::Simple_input_section> Input_section_list;
2280 bool have_load_address = *load_address != *dot_value;
2282 uint64_t address = *dot_value;
2283 address = align_address(address, this->os_->addralign());
2285 if ((this->os_->flags() & elfcpp::SHF_ALLOC) != 0)
2287 this->os_->set_address(address);
2288 if (have_load_address)
2289 this->os_->set_load_address(align_address(*load_address,
2290 this->os_->addralign()));
2293 Input_section_list input_sections;
2294 address += this->os_->get_input_sections(address, "", &input_sections);
2296 for (Input_section_list::iterator p = input_sections.begin();
2297 p != input_sections.end();
2303 // We know what are single-threaded, so it is OK to lock the
2306 const Task* task = reinterpret_cast<const Task*>(-1);
2307 Task_lock_obj<Object> tl(task, p->relobj());
2308 addralign = p->relobj()->section_addralign(p->shndx());
2309 if (p->is_relaxed_input_section())
2310 // We use current data size because relxed section sizes may not
2311 // have finalized yet.
2312 size = p->relaxed_input_section()->current_data_size();
2314 size = p->relobj()->section_size(p->shndx());
2317 address = align_address(address, addralign);
2318 this->os_->add_input_section_for_script(*p, size, addralign);
2322 // An SHF_TLS/SHT_NOBITS section does not take up any address space.
2323 if (this->os_ == NULL
2324 || (this->os_->flags() & elfcpp::SHF_TLS) == 0
2325 || this->os_->type() != elfcpp::SHT_NOBITS)
2327 if (!have_load_address)
2328 *load_address = address;
2330 *load_address += address - *dot_value;
2332 *dot_value = address;
2336 // Get the list of segments to use for an allocated section when using
2337 // a PHDRS clause. If this is an allocated section, return the
2338 // Output_section. We don't change the list of segments.
2341 Orphan_output_section::allocate_to_segment(String_list**, bool* orphan)
2343 if ((this->os_->flags() & elfcpp::SHF_ALLOC) == 0)
2349 // Class Phdrs_element. A program header from a PHDRS clause.
2354 Phdrs_element(const char* name, size_t namelen, unsigned int type,
2355 bool includes_filehdr, bool includes_phdrs,
2356 bool is_flags_valid, unsigned int flags,
2357 Expression* load_address)
2358 : name_(name, namelen), type_(type), includes_filehdr_(includes_filehdr),
2359 includes_phdrs_(includes_phdrs), is_flags_valid_(is_flags_valid),
2360 flags_(flags), load_address_(load_address), load_address_value_(0),
2364 // Return the name of this segment.
2367 { return this->name_; }
2369 // Return the type of the segment.
2372 { return this->type_; }
2374 // Whether to include the file header.
2376 includes_filehdr() const
2377 { return this->includes_filehdr_; }
2379 // Whether to include the program headers.
2381 includes_phdrs() const
2382 { return this->includes_phdrs_; }
2384 // Return whether there is a load address.
2386 has_load_address() const
2387 { return this->load_address_ != NULL; }
2389 // Evaluate the load address expression if there is one.
2391 eval_load_address(Symbol_table* symtab, Layout* layout)
2393 if (this->load_address_ != NULL)
2394 this->load_address_value_ = this->load_address_->eval(symtab, layout,
2398 // Return the load address.
2400 load_address() const
2402 gold_assert(this->load_address_ != NULL);
2403 return this->load_address_value_;
2406 // Create the segment.
2408 create_segment(Layout* layout)
2410 this->segment_ = layout->make_output_segment(this->type_, this->flags_);
2411 return this->segment_;
2414 // Return the segment.
2417 { return this->segment_; }
2419 // Release the segment.
2422 { this->segment_ = NULL; }
2424 // Set the segment flags if appropriate.
2426 set_flags_if_valid()
2428 if (this->is_flags_valid_)
2429 this->segment_->set_flags(this->flags_);
2432 // Print for debugging.
2437 // The name used in the script.
2439 // The type of the segment (PT_LOAD, etc.).
2441 // Whether this segment includes the file header.
2442 bool includes_filehdr_;
2443 // Whether this segment includes the section headers.
2444 bool includes_phdrs_;
2445 // Whether the flags were explicitly specified.
2446 bool is_flags_valid_;
2447 // The flags for this segment (PF_R, etc.) if specified.
2448 unsigned int flags_;
2449 // The expression for the load address for this segment. This may
2451 Expression* load_address_;
2452 // The actual load address from evaluating the expression.
2453 uint64_t load_address_value_;
2454 // The segment itself.
2455 Output_segment* segment_;
2458 // Print for debugging.
2461 Phdrs_element::print(FILE* f) const
2463 fprintf(f, " %s 0x%x", this->name_.c_str(), this->type_);
2464 if (this->includes_filehdr_)
2465 fprintf(f, " FILEHDR");
2466 if (this->includes_phdrs_)
2467 fprintf(f, " PHDRS");
2468 if (this->is_flags_valid_)
2469 fprintf(f, " FLAGS(%u)", this->flags_);
2470 if (this->load_address_ != NULL)
2473 this->load_address_->print(f);
2479 // Class Script_sections.
2481 Script_sections::Script_sections()
2482 : saw_sections_clause_(false),
2483 in_sections_clause_(false),
2484 sections_elements_(NULL),
2485 output_section_(NULL),
2486 phdrs_elements_(NULL),
2487 orphan_section_placement_(NULL),
2488 data_segment_align_start_(),
2489 saw_data_segment_align_(false),
2490 saw_relro_end_(false),
2491 saw_segment_start_expression_(false)
2495 // Start a SECTIONS clause.
2498 Script_sections::start_sections()
2500 gold_assert(!this->in_sections_clause_ && this->output_section_ == NULL);
2501 this->saw_sections_clause_ = true;
2502 this->in_sections_clause_ = true;
2503 if (this->sections_elements_ == NULL)
2504 this->sections_elements_ = new Sections_elements;
2507 // Finish a SECTIONS clause.
2510 Script_sections::finish_sections()
2512 gold_assert(this->in_sections_clause_ && this->output_section_ == NULL);
2513 this->in_sections_clause_ = false;
2516 // Add a symbol to be defined.
2519 Script_sections::add_symbol_assignment(const char* name, size_t length,
2520 Expression* val, bool provide,
2523 if (this->output_section_ != NULL)
2524 this->output_section_->add_symbol_assignment(name, length, val,
2528 Sections_element* p = new Sections_element_assignment(name, length,
2531 this->sections_elements_->push_back(p);
2535 // Add an assignment to the special dot symbol.
2538 Script_sections::add_dot_assignment(Expression* val)
2540 if (this->output_section_ != NULL)
2541 this->output_section_->add_dot_assignment(val);
2544 // The GNU linker permits assignments to . to appears outside of
2545 // a SECTIONS clause, and treats it as appearing inside, so
2546 // sections_elements_ may be NULL here.
2547 if (this->sections_elements_ == NULL)
2549 this->sections_elements_ = new Sections_elements;
2550 this->saw_sections_clause_ = true;
2553 Sections_element* p = new Sections_element_dot_assignment(val);
2554 this->sections_elements_->push_back(p);
2558 // Add an assertion.
2561 Script_sections::add_assertion(Expression* check, const char* message,
2564 if (this->output_section_ != NULL)
2565 this->output_section_->add_assertion(check, message, messagelen);
2568 Sections_element* p = new Sections_element_assertion(check, message,
2570 this->sections_elements_->push_back(p);
2574 // Start processing entries for an output section.
2577 Script_sections::start_output_section(
2580 const Parser_output_section_header *header)
2582 Output_section_definition* posd = new Output_section_definition(name,
2585 this->sections_elements_->push_back(posd);
2586 gold_assert(this->output_section_ == NULL);
2587 this->output_section_ = posd;
2590 // Stop processing entries for an output section.
2593 Script_sections::finish_output_section(
2594 const Parser_output_section_trailer* trailer)
2596 gold_assert(this->output_section_ != NULL);
2597 this->output_section_->finish(trailer);
2598 this->output_section_ = NULL;
2601 // Add a data item to the current output section.
2604 Script_sections::add_data(int size, bool is_signed, Expression* val)
2606 gold_assert(this->output_section_ != NULL);
2607 this->output_section_->add_data(size, is_signed, val);
2610 // Add a fill value setting to the current output section.
2613 Script_sections::add_fill(Expression* val)
2615 gold_assert(this->output_section_ != NULL);
2616 this->output_section_->add_fill(val);
2619 // Add an input section specification to the current output section.
2622 Script_sections::add_input_section(const Input_section_spec* spec, bool keep)
2624 gold_assert(this->output_section_ != NULL);
2625 this->output_section_->add_input_section(spec, keep);
2628 // This is called when we see DATA_SEGMENT_ALIGN. It means that any
2629 // subsequent output sections may be relro.
2632 Script_sections::data_segment_align()
2634 if (this->saw_data_segment_align_)
2635 gold_error(_("DATA_SEGMENT_ALIGN may only appear once in a linker script"));
2636 gold_assert(!this->sections_elements_->empty());
2637 Sections_elements::iterator p = this->sections_elements_->end();
2639 this->data_segment_align_start_ = p;
2640 this->saw_data_segment_align_ = true;
2643 // This is called when we see DATA_SEGMENT_RELRO_END. It means that
2644 // any output sections seen since DATA_SEGMENT_ALIGN are relro.
2647 Script_sections::data_segment_relro_end()
2649 if (this->saw_relro_end_)
2650 gold_error(_("DATA_SEGMENT_RELRO_END may only appear once "
2651 "in a linker script"));
2652 this->saw_relro_end_ = true;
2654 if (!this->saw_data_segment_align_)
2655 gold_error(_("DATA_SEGMENT_RELRO_END must follow DATA_SEGMENT_ALIGN"));
2658 Sections_elements::iterator p = this->data_segment_align_start_;
2659 for (++p; p != this->sections_elements_->end(); ++p)
2660 (*p)->set_is_relro();
2664 // Create any required sections.
2667 Script_sections::create_sections(Layout* layout)
2669 if (!this->saw_sections_clause_)
2671 for (Sections_elements::iterator p = this->sections_elements_->begin();
2672 p != this->sections_elements_->end();
2674 (*p)->create_sections(layout);
2677 // Add any symbols we are defining to the symbol table.
2680 Script_sections::add_symbols_to_table(Symbol_table* symtab)
2682 if (!this->saw_sections_clause_)
2684 for (Sections_elements::iterator p = this->sections_elements_->begin();
2685 p != this->sections_elements_->end();
2687 (*p)->add_symbols_to_table(symtab);
2690 // Finalize symbols and check assertions.
2693 Script_sections::finalize_symbols(Symbol_table* symtab, const Layout* layout)
2695 if (!this->saw_sections_clause_)
2697 uint64_t dot_value = 0;
2698 for (Sections_elements::iterator p = this->sections_elements_->begin();
2699 p != this->sections_elements_->end();
2701 (*p)->finalize_symbols(symtab, layout, &dot_value);
2704 // Return the name of the output section to use for an input file name
2705 // and section name.
2708 Script_sections::output_section_name(const char* file_name,
2709 const char* section_name,
2710 Output_section*** output_section_slot)
2712 for (Sections_elements::const_iterator p = this->sections_elements_->begin();
2713 p != this->sections_elements_->end();
2716 const char* ret = (*p)->output_section_name(file_name, section_name,
2717 output_section_slot);
2721 // The special name /DISCARD/ means that the input section
2722 // should be discarded.
2723 if (strcmp(ret, "/DISCARD/") == 0)
2725 *output_section_slot = NULL;
2732 // If we couldn't find a mapping for the name, the output section
2733 // gets the name of the input section.
2735 *output_section_slot = NULL;
2737 return section_name;
2740 // Place a marker for an orphan output section into the SECTIONS
2744 Script_sections::place_orphan(Output_section* os)
2746 Orphan_section_placement* osp = this->orphan_section_placement_;
2749 // Initialize the Orphan_section_placement structure.
2750 osp = new Orphan_section_placement();
2751 for (Sections_elements::iterator p = this->sections_elements_->begin();
2752 p != this->sections_elements_->end();
2754 (*p)->orphan_section_init(osp, p);
2755 gold_assert(!this->sections_elements_->empty());
2756 Sections_elements::iterator last = this->sections_elements_->end();
2758 osp->last_init(last);
2759 this->orphan_section_placement_ = osp;
2762 Orphan_output_section* orphan = new Orphan_output_section(os);
2764 // Look for where to put ORPHAN.
2765 Sections_elements::iterator* where;
2766 if (osp->find_place(os, &where))
2768 if ((**where)->is_relro())
2771 os->clear_is_relro();
2773 // We want to insert ORPHAN after *WHERE, and then update *WHERE
2774 // so that the next one goes after this one.
2775 Sections_elements::iterator p = *where;
2776 gold_assert(p != this->sections_elements_->end());
2778 *where = this->sections_elements_->insert(p, orphan);
2782 os->clear_is_relro();
2783 // We don't have a place to put this orphan section. Put it,
2784 // and all other sections like it, at the end, but before the
2785 // sections which always come at the end.
2786 Sections_elements::iterator last = osp->last_place();
2787 *where = this->sections_elements_->insert(last, orphan);
2791 // Set the addresses of all the output sections. Walk through all the
2792 // elements, tracking the dot symbol. Apply assignments which set
2793 // absolute symbol values, in case they are used when setting dot.
2794 // Fill in data statement values. As we find output sections, set the
2795 // address, set the address of all associated input sections, and
2796 // update dot. Return the segment which should hold the file header
2797 // and segment headers, if any.
2800 Script_sections::set_section_addresses(Symbol_table* symtab, Layout* layout)
2802 gold_assert(this->saw_sections_clause_);
2804 // Implement ONLY_IF_RO/ONLY_IF_RW constraints. These are a pain
2805 // for our representation.
2806 for (Sections_elements::iterator p = this->sections_elements_->begin();
2807 p != this->sections_elements_->end();
2810 Output_section_definition* posd;
2811 Section_constraint failed_constraint = (*p)->check_constraint(&posd);
2812 if (failed_constraint != CONSTRAINT_NONE)
2814 Sections_elements::iterator q;
2815 for (q = this->sections_elements_->begin();
2816 q != this->sections_elements_->end();
2821 if ((*q)->alternate_constraint(posd, failed_constraint))
2826 if (q == this->sections_elements_->end())
2827 gold_error(_("no matching section constraint"));
2831 // Force the alignment of the first TLS section to be the maximum
2832 // alignment of all TLS sections.
2833 Output_section* first_tls = NULL;
2834 uint64_t tls_align = 0;
2835 for (Sections_elements::const_iterator p = this->sections_elements_->begin();
2836 p != this->sections_elements_->end();
2839 Output_section *os = (*p)->get_output_section();
2840 if (os != NULL && (os->flags() & elfcpp::SHF_TLS) != 0)
2842 if (first_tls == NULL)
2844 if (os->addralign() > tls_align)
2845 tls_align = os->addralign();
2848 if (first_tls != NULL)
2849 first_tls->set_addralign(tls_align);
2851 // For a relocatable link, we implicitly set dot to zero.
2852 uint64_t dot_value = 0;
2853 uint64_t load_address = 0;
2855 // Check to see if we want to use any of -Ttext, -Tdata and -Tbss options
2856 // to set section addresses. If the script has any SEGMENT_START
2857 // expression, we do not set the section addresses.
2858 bool use_tsection_options =
2859 (!this->saw_segment_start_expression_
2860 && (parameters->options().user_set_Ttext()
2861 || parameters->options().user_set_Tdata()
2862 || parameters->options().user_set_Tbss()));
2864 for (Sections_elements::iterator p = this->sections_elements_->begin();
2865 p != this->sections_elements_->end();
2868 Output_section* os = (*p)->get_output_section();
2870 // Handle -Ttext, -Tdata and -Tbss options. We do this by looking for
2871 // the special sections by names and doing dot assignments.
2872 if (use_tsection_options
2874 && (os->flags() & elfcpp::SHF_ALLOC) != 0)
2876 uint64_t new_dot_value = dot_value;
2878 if (parameters->options().user_set_Ttext()
2879 && strcmp(os->name(), ".text") == 0)
2880 new_dot_value = parameters->options().Ttext();
2881 else if (parameters->options().user_set_Tdata()
2882 && strcmp(os->name(), ".data") == 0)
2883 new_dot_value = parameters->options().Tdata();
2884 else if (parameters->options().user_set_Tbss()
2885 && strcmp(os->name(), ".bss") == 0)
2886 new_dot_value = parameters->options().Tbss();
2888 // Update dot and load address if necessary.
2889 if (new_dot_value < dot_value)
2890 gold_error(_("dot may not move backward"));
2891 else if (new_dot_value != dot_value)
2893 dot_value = new_dot_value;
2894 load_address = new_dot_value;
2898 (*p)->set_section_addresses(symtab, layout, &dot_value, &load_address);
2901 if (this->phdrs_elements_ != NULL)
2903 for (Phdrs_elements::iterator p = this->phdrs_elements_->begin();
2904 p != this->phdrs_elements_->end();
2906 (*p)->eval_load_address(symtab, layout);
2909 return this->create_segments(layout);
2912 // Sort the sections in order to put them into segments.
2914 class Sort_output_sections
2918 operator()(const Output_section* os1, const Output_section* os2) const;
2922 Sort_output_sections::operator()(const Output_section* os1,
2923 const Output_section* os2) const
2925 // Sort first by the load address.
2926 uint64_t lma1 = (os1->has_load_address()
2927 ? os1->load_address()
2929 uint64_t lma2 = (os2->has_load_address()
2930 ? os2->load_address()
2935 // Then sort by the virtual address.
2936 if (os1->address() != os2->address())
2937 return os1->address() < os2->address();
2939 // Sort TLS sections to the end.
2940 bool tls1 = (os1->flags() & elfcpp::SHF_TLS) != 0;
2941 bool tls2 = (os2->flags() & elfcpp::SHF_TLS) != 0;
2945 // Sort PROGBITS before NOBITS.
2946 if (os1->type() == elfcpp::SHT_PROGBITS && os2->type() == elfcpp::SHT_NOBITS)
2948 if (os1->type() == elfcpp::SHT_NOBITS && os2->type() == elfcpp::SHT_PROGBITS)
2951 // Otherwise we don't care.
2955 // Return whether OS is a BSS section. This is a SHT_NOBITS section.
2956 // We treat a section with the SHF_TLS flag set as taking up space
2957 // even if it is SHT_NOBITS (this is true of .tbss), as we allocate
2958 // space for them in the file.
2961 Script_sections::is_bss_section(const Output_section* os)
2963 return (os->type() == elfcpp::SHT_NOBITS
2964 && (os->flags() & elfcpp::SHF_TLS) == 0);
2967 // Return the size taken by the file header and the program headers.
2970 Script_sections::total_header_size(Layout* layout) const
2972 size_t segment_count = layout->segment_count();
2973 size_t file_header_size;
2974 size_t segment_headers_size;
2975 if (parameters->target().get_size() == 32)
2977 file_header_size = elfcpp::Elf_sizes<32>::ehdr_size;
2978 segment_headers_size = segment_count * elfcpp::Elf_sizes<32>::phdr_size;
2980 else if (parameters->target().get_size() == 64)
2982 file_header_size = elfcpp::Elf_sizes<64>::ehdr_size;
2983 segment_headers_size = segment_count * elfcpp::Elf_sizes<64>::phdr_size;
2988 return file_header_size + segment_headers_size;
2991 // Return the amount we have to subtract from the LMA to accomodate
2992 // headers of the given size. The complication is that the file
2993 // header have to be at the start of a page, as otherwise it will not
2994 // be at the start of the file.
2997 Script_sections::header_size_adjustment(uint64_t lma,
2998 size_t sizeof_headers) const
3000 const uint64_t abi_pagesize = parameters->target().abi_pagesize();
3001 uint64_t hdr_lma = lma - sizeof_headers;
3002 hdr_lma &= ~(abi_pagesize - 1);
3003 return lma - hdr_lma;
3006 // Create the PT_LOAD segments when using a SECTIONS clause. Returns
3007 // the segment which should hold the file header and segment headers,
3011 Script_sections::create_segments(Layout* layout)
3013 gold_assert(this->saw_sections_clause_);
3015 if (parameters->options().relocatable())
3018 if (this->saw_phdrs_clause())
3019 return create_segments_from_phdrs_clause(layout);
3021 Layout::Section_list sections;
3022 layout->get_allocated_sections(§ions);
3024 // Sort the sections by address.
3025 std::stable_sort(sections.begin(), sections.end(), Sort_output_sections());
3027 this->create_note_and_tls_segments(layout, §ions);
3029 // Walk through the sections adding them to PT_LOAD segments.
3030 const uint64_t abi_pagesize = parameters->target().abi_pagesize();
3031 Output_segment* first_seg = NULL;
3032 Output_segment* current_seg = NULL;
3033 bool is_current_seg_readonly = true;
3034 Layout::Section_list::iterator plast = sections.end();
3035 uint64_t last_vma = 0;
3036 uint64_t last_lma = 0;
3037 uint64_t last_size = 0;
3038 for (Layout::Section_list::iterator p = sections.begin();
3039 p != sections.end();
3042 const uint64_t vma = (*p)->address();
3043 const uint64_t lma = ((*p)->has_load_address()
3044 ? (*p)->load_address()
3046 const uint64_t size = (*p)->current_data_size();
3048 bool need_new_segment;
3049 if (current_seg == NULL)
3050 need_new_segment = true;
3051 else if (lma - vma != last_lma - last_vma)
3053 // This section has a different LMA relationship than the
3054 // last one; we need a new segment.
3055 need_new_segment = true;
3057 else if (align_address(last_lma + last_size, abi_pagesize)
3058 < align_address(lma, abi_pagesize))
3060 // Putting this section in the segment would require
3062 need_new_segment = true;
3064 else if (is_bss_section(*plast) && !is_bss_section(*p))
3066 // A non-BSS section can not follow a BSS section in the
3068 need_new_segment = true;
3070 else if (is_current_seg_readonly
3071 && ((*p)->flags() & elfcpp::SHF_WRITE) != 0
3072 && !parameters->options().omagic())
3074 // Don't put a writable section in the same segment as a
3075 // non-writable section.
3076 need_new_segment = true;
3080 // Otherwise, reuse the existing segment.
3081 need_new_segment = false;
3084 elfcpp::Elf_Word seg_flags =
3085 Layout::section_flags_to_segment((*p)->flags());
3087 if (need_new_segment)
3089 current_seg = layout->make_output_segment(elfcpp::PT_LOAD,
3091 current_seg->set_addresses(vma, lma);
3092 if (first_seg == NULL)
3093 first_seg = current_seg;
3094 is_current_seg_readonly = true;
3097 current_seg->add_output_section(*p, seg_flags, false);
3099 if (((*p)->flags() & elfcpp::SHF_WRITE) != 0)
3100 is_current_seg_readonly = false;
3108 // An ELF program should work even if the program headers are not in
3109 // a PT_LOAD segment. However, it appears that the Linux kernel
3110 // does not set the AT_PHDR auxiliary entry in that case. It sets
3111 // the load address to p_vaddr - p_offset of the first PT_LOAD
3112 // segment. It then sets AT_PHDR to the load address plus the
3113 // offset to the program headers, e_phoff in the file header. This
3114 // fails when the program headers appear in the file before the
3115 // first PT_LOAD segment. Therefore, we always create a PT_LOAD
3116 // segment to hold the file header and the program headers. This is
3117 // effectively what the GNU linker does, and it is slightly more
3118 // efficient in any case. We try to use the first PT_LOAD segment
3119 // if we can, otherwise we make a new one.
3121 if (first_seg == NULL)
3124 // -n or -N mean that the program is not demand paged and there is
3125 // no need to put the program headers in a PT_LOAD segment.
3126 if (parameters->options().nmagic() || parameters->options().omagic())
3129 size_t sizeof_headers = this->total_header_size(layout);
3131 uint64_t vma = first_seg->vaddr();
3132 uint64_t lma = first_seg->paddr();
3134 uint64_t subtract = this->header_size_adjustment(lma, sizeof_headers);
3136 if ((lma & (abi_pagesize - 1)) >= sizeof_headers)
3138 first_seg->set_addresses(vma - subtract, lma - subtract);
3142 // If there is no room to squeeze in the headers, then punt. The
3143 // resulting executable probably won't run on GNU/Linux, but we
3144 // trust that the user knows what they are doing.
3145 if (lma < subtract || vma < subtract)
3148 Output_segment* load_seg = layout->make_output_segment(elfcpp::PT_LOAD,
3150 load_seg->set_addresses(vma - subtract, lma - subtract);
3155 // Create a PT_NOTE segment for each SHT_NOTE section and a PT_TLS
3156 // segment if there are any SHT_TLS sections.
3159 Script_sections::create_note_and_tls_segments(
3161 const Layout::Section_list* sections)
3163 gold_assert(!this->saw_phdrs_clause());
3165 bool saw_tls = false;
3166 for (Layout::Section_list::const_iterator p = sections->begin();
3167 p != sections->end();
3170 if ((*p)->type() == elfcpp::SHT_NOTE)
3172 elfcpp::Elf_Word seg_flags =
3173 Layout::section_flags_to_segment((*p)->flags());
3174 Output_segment* oseg = layout->make_output_segment(elfcpp::PT_NOTE,
3176 oseg->add_output_section(*p, seg_flags, false);
3178 // Incorporate any subsequent SHT_NOTE sections, in the
3179 // hopes that the script is sensible.
3180 Layout::Section_list::const_iterator pnext = p + 1;
3181 while (pnext != sections->end()
3182 && (*pnext)->type() == elfcpp::SHT_NOTE)
3184 seg_flags = Layout::section_flags_to_segment((*pnext)->flags());
3185 oseg->add_output_section(*pnext, seg_flags, false);
3191 if (((*p)->flags() & elfcpp::SHF_TLS) != 0)
3194 gold_error(_("TLS sections are not adjacent"));
3196 elfcpp::Elf_Word seg_flags =
3197 Layout::section_flags_to_segment((*p)->flags());
3198 Output_segment* oseg = layout->make_output_segment(elfcpp::PT_TLS,
3200 oseg->add_output_section(*p, seg_flags, false);
3202 Layout::Section_list::const_iterator pnext = p + 1;
3203 while (pnext != sections->end()
3204 && ((*pnext)->flags() & elfcpp::SHF_TLS) != 0)
3206 seg_flags = Layout::section_flags_to_segment((*pnext)->flags());
3207 oseg->add_output_section(*pnext, seg_flags, false);
3217 // Add a program header. The PHDRS clause is syntactically distinct
3218 // from the SECTIONS clause, but we implement it with the SECTIONS
3219 // support because PHDRS is useless if there is no SECTIONS clause.
3222 Script_sections::add_phdr(const char* name, size_t namelen, unsigned int type,
3223 bool includes_filehdr, bool includes_phdrs,
3224 bool is_flags_valid, unsigned int flags,
3225 Expression* load_address)
3227 if (this->phdrs_elements_ == NULL)
3228 this->phdrs_elements_ = new Phdrs_elements();
3229 this->phdrs_elements_->push_back(new Phdrs_element(name, namelen, type,
3232 is_flags_valid, flags,
3236 // Return the number of segments we expect to create based on the
3237 // SECTIONS clause. This is used to implement SIZEOF_HEADERS.
3240 Script_sections::expected_segment_count(const Layout* layout) const
3242 if (this->saw_phdrs_clause())
3243 return this->phdrs_elements_->size();
3245 Layout::Section_list sections;
3246 layout->get_allocated_sections(§ions);
3248 // We assume that we will need two PT_LOAD segments.
3251 bool saw_note = false;
3252 bool saw_tls = false;
3253 for (Layout::Section_list::const_iterator p = sections.begin();
3254 p != sections.end();
3257 if ((*p)->type() == elfcpp::SHT_NOTE)
3259 // Assume that all note sections will fit into a single
3267 else if (((*p)->flags() & elfcpp::SHF_TLS) != 0)
3269 // There can only be one PT_TLS segment.
3281 // Create the segments from a PHDRS clause. Return the segment which
3282 // should hold the file header and program headers, if any.
3285 Script_sections::create_segments_from_phdrs_clause(Layout* layout)
3287 this->attach_sections_using_phdrs_clause(layout);
3288 return this->set_phdrs_clause_addresses(layout);
3291 // Create the segments from the PHDRS clause, and put the output
3292 // sections in them.
3295 Script_sections::attach_sections_using_phdrs_clause(Layout* layout)
3297 typedef std::map<std::string, Output_segment*> Name_to_segment;
3298 Name_to_segment name_to_segment;
3299 for (Phdrs_elements::const_iterator p = this->phdrs_elements_->begin();
3300 p != this->phdrs_elements_->end();
3302 name_to_segment[(*p)->name()] = (*p)->create_segment(layout);
3304 // Walk through the output sections and attach them to segments.
3305 // Output sections in the script which do not list segments are
3306 // attached to the same set of segments as the immediately preceding
3309 String_list* phdr_names = NULL;
3310 bool load_segments_only = false;
3311 for (Sections_elements::const_iterator p = this->sections_elements_->begin();
3312 p != this->sections_elements_->end();
3316 String_list* old_phdr_names = phdr_names;
3317 Output_section* os = (*p)->allocate_to_segment(&phdr_names, &orphan);
3321 if (phdr_names == NULL)
3323 gold_error(_("allocated section not in any segment"));
3327 // We see a list of segments names. Disable PT_LOAD segment only
3329 if (old_phdr_names != phdr_names)
3330 load_segments_only = false;
3332 // If this is an orphan section--one that was not explicitly
3333 // mentioned in the linker script--then it should not inherit
3334 // any segment type other than PT_LOAD. Otherwise, e.g., the
3335 // PT_INTERP segment will pick up following orphan sections,
3336 // which does not make sense. If this is not an orphan section,
3337 // we trust the linker script.
3340 // Enable PT_LOAD segments only filtering until we see another
3341 // list of segment names.
3342 load_segments_only = true;
3345 bool in_load_segment = false;
3346 for (String_list::const_iterator q = phdr_names->begin();
3347 q != phdr_names->end();
3350 Name_to_segment::const_iterator r = name_to_segment.find(*q);
3351 if (r == name_to_segment.end())
3352 gold_error(_("no segment %s"), q->c_str());
3355 if (load_segments_only
3356 && r->second->type() != elfcpp::PT_LOAD)
3359 elfcpp::Elf_Word seg_flags =
3360 Layout::section_flags_to_segment(os->flags());
3361 r->second->add_output_section(os, seg_flags, false);
3363 if (r->second->type() == elfcpp::PT_LOAD)
3365 if (in_load_segment)
3366 gold_error(_("section in two PT_LOAD segments"));
3367 in_load_segment = true;
3372 if (!in_load_segment)
3373 gold_error(_("allocated section not in any PT_LOAD segment"));
3377 // Set the addresses for segments created from a PHDRS clause. Return
3378 // the segment which should hold the file header and program headers,
3382 Script_sections::set_phdrs_clause_addresses(Layout* layout)
3384 Output_segment* load_seg = NULL;
3385 for (Phdrs_elements::const_iterator p = this->phdrs_elements_->begin();
3386 p != this->phdrs_elements_->end();
3389 // Note that we have to set the flags after adding the output
3390 // sections to the segment, as adding an output segment can
3391 // change the flags.
3392 (*p)->set_flags_if_valid();
3394 Output_segment* oseg = (*p)->segment();
3396 if (oseg->type() != elfcpp::PT_LOAD)
3398 // The addresses of non-PT_LOAD segments are set from the
3399 // PT_LOAD segments.
3400 if ((*p)->has_load_address())
3401 gold_error(_("may only specify load address for PT_LOAD segment"));
3405 // The output sections should have addresses from the SECTIONS
3406 // clause. The addresses don't have to be in order, so find the
3407 // one with the lowest load address. Use that to set the
3408 // address of the segment.
3410 Output_section* osec = oseg->section_with_lowest_load_address();
3413 oseg->set_addresses(0, 0);
3417 uint64_t vma = osec->address();
3418 uint64_t lma = osec->has_load_address() ? osec->load_address() : vma;
3420 // Override the load address of the section with the load
3421 // address specified for the segment.
3422 if ((*p)->has_load_address())
3424 if (osec->has_load_address())
3425 gold_warning(_("PHDRS load address overrides "
3426 "section %s load address"),
3429 lma = (*p)->load_address();
3432 bool headers = (*p)->includes_filehdr() && (*p)->includes_phdrs();
3433 if (!headers && ((*p)->includes_filehdr() || (*p)->includes_phdrs()))
3435 // We could support this if we wanted to.
3436 gold_error(_("using only one of FILEHDR and PHDRS is "
3437 "not currently supported"));
3441 size_t sizeof_headers = this->total_header_size(layout);
3442 uint64_t subtract = this->header_size_adjustment(lma,
3444 if (lma >= subtract && vma >= subtract)
3451 gold_error(_("sections loaded on first page without room "
3452 "for file and program headers "
3453 "are not supported"));
3456 if (load_seg != NULL)
3457 gold_error(_("using FILEHDR and PHDRS on more than one "
3458 "PT_LOAD segment is not currently supported"));
3462 oseg->set_addresses(vma, lma);
3468 // Add the file header and segment headers to non-load segments
3469 // specified in the PHDRS clause.
3472 Script_sections::put_headers_in_phdrs(Output_data* file_header,
3473 Output_data* segment_headers)
3475 gold_assert(this->saw_phdrs_clause());
3476 for (Phdrs_elements::iterator p = this->phdrs_elements_->begin();
3477 p != this->phdrs_elements_->end();
3480 if ((*p)->type() != elfcpp::PT_LOAD)
3482 if ((*p)->includes_phdrs())
3483 (*p)->segment()->add_initial_output_data(segment_headers);
3484 if ((*p)->includes_filehdr())
3485 (*p)->segment()->add_initial_output_data(file_header);
3490 // Look for an output section by name and return the address, the load
3491 // address, the alignment, and the size. This is used when an
3492 // expression refers to an output section which was not actually
3493 // created. This returns true if the section was found, false
3497 Script_sections::get_output_section_info(const char* name, uint64_t* address,
3498 uint64_t* load_address,
3499 uint64_t* addralign,
3500 uint64_t* size) const
3502 if (!this->saw_sections_clause_)
3504 for (Sections_elements::const_iterator p = this->sections_elements_->begin();
3505 p != this->sections_elements_->end();
3507 if ((*p)->get_output_section_info(name, address, load_address, addralign,
3513 // Release all Output_segments. This remove all pointers to all
3517 Script_sections::release_segments()
3519 if (this->saw_phdrs_clause())
3521 for (Phdrs_elements::const_iterator p = this->phdrs_elements_->begin();
3522 p != this->phdrs_elements_->end();
3524 (*p)->release_segment();
3528 // Print the SECTIONS clause to F for debugging.
3531 Script_sections::print(FILE* f) const
3533 if (!this->saw_sections_clause_)
3536 fprintf(f, "SECTIONS {\n");
3538 for (Sections_elements::const_iterator p = this->sections_elements_->begin();
3539 p != this->sections_elements_->end();
3545 if (this->phdrs_elements_ != NULL)
3547 fprintf(f, "PHDRS {\n");
3548 for (Phdrs_elements::const_iterator p = this->phdrs_elements_->begin();
3549 p != this->phdrs_elements_->end();
3556 } // End namespace gold.