1 // script-sections.cc -- linker script SECTIONS for gold
3 // Copyright (C) 2008-2016 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 // A region of memory.
50 Memory_region(const char* name
, size_t namelen
, unsigned int attributes
,
51 Expression
* start
, Expression
* length
)
52 : name_(name
, namelen
),
53 attributes_(attributes
),
62 // Return the name of this region.
65 { return this->name_
; }
67 // Return the start address of this region.
70 { return this->start_
; }
72 // Return the length of this region.
75 { return this->length_
; }
77 // Print the region (when debugging).
81 // Return true if <name,namelen> matches this region.
83 name_match(const char* name
, size_t namelen
)
85 return (this->name_
.length() == namelen
86 && strncmp(this->name_
.c_str(), name
, namelen
) == 0);
90 get_current_address() const
93 script_exp_binary_add(this->start_
,
94 script_exp_integer(this->current_offset_
));
98 set_address(uint64_t addr
, const Symbol_table
* symtab
, const Layout
* layout
)
100 uint64_t start
= this->start_
->eval(symtab
, layout
, false);
101 uint64_t len
= this->length_
->eval(symtab
, layout
, false);
102 if (addr
< start
|| addr
>= start
+ len
)
103 gold_error(_("address 0x%llx is not within region %s"),
104 static_cast<unsigned long long>(addr
),
105 this->name_
.c_str());
106 else if (addr
< start
+ this->current_offset_
)
107 gold_error(_("address 0x%llx moves dot backwards in region %s"),
108 static_cast<unsigned long long>(addr
),
109 this->name_
.c_str());
110 this->current_offset_
= addr
- start
;
114 increment_offset(std::string section_name
, uint64_t amount
,
115 const Symbol_table
* symtab
, const Layout
* layout
)
117 this->current_offset_
+= amount
;
119 if (this->current_offset_
120 > this->length_
->eval(symtab
, layout
, false))
121 gold_error(_("section %s overflows end of region %s"),
122 section_name
.c_str(), this->name_
.c_str());
125 // Returns true iff there is room left in this region
126 // for AMOUNT more bytes of data.
128 has_room_for(const Symbol_table
* symtab
, const Layout
* layout
,
129 uint64_t amount
) const
131 return (this->current_offset_
+ amount
132 < this->length_
->eval(symtab
, layout
, false));
135 // Return true if the provided section flags
136 // are compatible with this region's attributes.
138 attributes_compatible(elfcpp::Elf_Xword flags
, elfcpp::Elf_Xword type
) const;
141 add_section(Output_section_definition
* sec
, bool vma
)
144 this->vma_sections_
.push_back(sec
);
146 this->lma_sections_
.push_back(sec
);
149 typedef std::vector
<Output_section_definition
*> Section_list
;
151 // Return the start of the list of sections
152 // whose VMAs are taken from this region.
153 Section_list::const_iterator
154 get_vma_section_list_start() const
155 { return this->vma_sections_
.begin(); }
157 // Return the start of the list of sections
158 // whose LMAs are taken from this region.
159 Section_list::const_iterator
160 get_lma_section_list_start() const
161 { return this->lma_sections_
.begin(); }
163 // Return the end of the list of sections
164 // whose VMAs are taken from this region.
165 Section_list::const_iterator
166 get_vma_section_list_end() const
167 { return this->vma_sections_
.end(); }
169 // Return the end of the list of sections
170 // whose LMAs are taken from this region.
171 Section_list::const_iterator
172 get_lma_section_list_end() const
173 { return this->lma_sections_
.end(); }
175 Output_section_definition
*
176 get_last_section() const
177 { return this->last_section_
; }
180 set_last_section(Output_section_definition
* sec
)
181 { this->last_section_
= sec
; }
186 unsigned int attributes_
;
189 // The offset to the next free byte in the region.
190 // Note - for compatibility with GNU LD we only maintain one offset
191 // regardless of whether the region is being used for VMA values,
192 // LMA values, or both.
193 uint64_t current_offset_
;
194 // A list of sections whose VMAs are set inside this region.
195 Section_list vma_sections_
;
196 // A list of sections whose LMAs are set inside this region.
197 Section_list lma_sections_
;
198 // The latest section to make use of this region.
199 Output_section_definition
* last_section_
;
202 // Return true if the provided section flags
203 // are compatible with this region's attributes.
206 Memory_region::attributes_compatible(elfcpp::Elf_Xword flags
,
207 elfcpp::Elf_Xword type
) const
209 unsigned int attrs
= this->attributes_
;
211 // No attributes means that this region is not compatible with anything.
218 switch (attrs
& - attrs
)
221 if ((flags
& elfcpp::SHF_EXECINSTR
) == 0)
226 if ((flags
& elfcpp::SHF_WRITE
) == 0)
231 // All sections are presumed readable.
234 case MEM_ALLOCATABLE
:
235 if ((flags
& elfcpp::SHF_ALLOC
) == 0)
239 case MEM_INITIALIZED
:
240 if ((type
& elfcpp::SHT_NOBITS
) != 0)
244 attrs
&= ~ (attrs
& - attrs
);
251 // Print a memory region.
254 Memory_region::print(FILE* f
) const
256 fprintf(f
, " %s", this->name_
.c_str());
258 unsigned int attrs
= this->attributes_
;
264 switch (attrs
& - attrs
)
266 case MEM_EXECUTABLE
: fputc('x', f
); break;
267 case MEM_WRITEABLE
: fputc('w', f
); break;
268 case MEM_READABLE
: fputc('r', f
); break;
269 case MEM_ALLOCATABLE
: fputc('a', f
); break;
270 case MEM_INITIALIZED
: fputc('i', f
); break;
274 attrs
&= ~ (attrs
& - attrs
);
280 fprintf(f
, " : origin = ");
281 this->start_
->print(f
);
282 fprintf(f
, ", length = ");
283 this->length_
->print(f
);
287 // Manage orphan sections. This is intended to be largely compatible
288 // with the GNU linker. The Linux kernel implicitly relies on
289 // something similar to the GNU linker's orphan placement. We
290 // originally used a simpler scheme here, but it caused the kernel
291 // build to fail, and was also rather inefficient.
293 class Orphan_section_placement
296 typedef Script_sections::Elements_iterator Elements_iterator
;
299 Orphan_section_placement();
301 // Handle an output section during initialization of this mapping.
303 output_section_init(const std::string
& name
, Output_section
*,
304 Elements_iterator location
);
306 // Initialize the last location.
308 last_init(Elements_iterator location
);
310 // Set *PWHERE to the address of an iterator pointing to the
311 // location to use for an orphan section. Return true if the
312 // iterator has a value, false otherwise.
314 find_place(Output_section
*, Elements_iterator
** pwhere
);
316 // Return the iterator being used for sections at the very end of
317 // the linker script.
322 // The places that we specifically recognize. This list is copied
323 // from the GNU linker.
339 // The information we keep for a specific place.
342 // The name of sections for this place.
344 // Whether we have a location for this place.
346 // The iterator for this place.
347 Elements_iterator location
;
350 // Initialize one place element.
352 initialize_place(Place_index
, const char*);
355 Place places_
[PLACE_MAX
];
356 // True if this is the first call to output_section_init.
360 // Initialize Orphan_section_placement.
362 Orphan_section_placement::Orphan_section_placement()
365 this->initialize_place(PLACE_TEXT
, ".text");
366 this->initialize_place(PLACE_RODATA
, ".rodata");
367 this->initialize_place(PLACE_DATA
, ".data");
368 this->initialize_place(PLACE_TLS
, NULL
);
369 this->initialize_place(PLACE_TLS_BSS
, NULL
);
370 this->initialize_place(PLACE_BSS
, ".bss");
371 this->initialize_place(PLACE_REL
, NULL
);
372 this->initialize_place(PLACE_INTERP
, ".interp");
373 this->initialize_place(PLACE_NONALLOC
, NULL
);
374 this->initialize_place(PLACE_LAST
, NULL
);
377 // Initialize one place element.
380 Orphan_section_placement::initialize_place(Place_index index
, const char* name
)
382 this->places_
[index
].name
= name
;
383 this->places_
[index
].have_location
= false;
386 // While initializing the Orphan_section_placement information, this
387 // is called once for each output section named in the linker script.
388 // If we found an output section during the link, it will be passed in
392 Orphan_section_placement::output_section_init(const std::string
& name
,
394 Elements_iterator location
)
396 bool first_init
= this->first_init_
;
397 this->first_init_
= false;
399 for (int i
= 0; i
< PLACE_MAX
; ++i
)
401 if (this->places_
[i
].name
!= NULL
&& this->places_
[i
].name
== name
)
403 if (this->places_
[i
].have_location
)
405 // We have already seen a section with this name.
409 this->places_
[i
].location
= location
;
410 this->places_
[i
].have_location
= true;
412 // If we just found the .bss section, restart the search for
413 // an unallocated section. This follows the GNU linker's
416 this->places_
[PLACE_NONALLOC
].have_location
= false;
422 // Relocation sections.
423 if (!this->places_
[PLACE_REL
].have_location
425 && (os
->type() == elfcpp::SHT_REL
|| os
->type() == elfcpp::SHT_RELA
)
426 && (os
->flags() & elfcpp::SHF_ALLOC
) != 0)
428 this->places_
[PLACE_REL
].location
= location
;
429 this->places_
[PLACE_REL
].have_location
= true;
432 // We find the location for unallocated sections by finding the
433 // first debugging or comment section after the BSS section (if
435 if (!this->places_
[PLACE_NONALLOC
].have_location
436 && (name
== ".comment" || Layout::is_debug_info_section(name
.c_str())))
438 // We add orphan sections after the location in PLACES_. We
439 // want to store unallocated sections before LOCATION. If this
440 // is the very first section, we can't use it.
444 this->places_
[PLACE_NONALLOC
].location
= location
;
445 this->places_
[PLACE_NONALLOC
].have_location
= true;
450 // Initialize the last location.
453 Orphan_section_placement::last_init(Elements_iterator location
)
455 this->places_
[PLACE_LAST
].location
= location
;
456 this->places_
[PLACE_LAST
].have_location
= true;
459 // Set *PWHERE to the address of an iterator pointing to the location
460 // to use for an orphan section. Return true if the iterator has a
461 // value, false otherwise.
464 Orphan_section_placement::find_place(Output_section
* os
,
465 Elements_iterator
** pwhere
)
467 // Figure out where OS should go. This is based on the GNU linker
468 // code. FIXME: The GNU linker handles small data sections
469 // specially, but we don't.
470 elfcpp::Elf_Word type
= os
->type();
471 elfcpp::Elf_Xword flags
= os
->flags();
473 if ((flags
& elfcpp::SHF_ALLOC
) == 0
474 && !Layout::is_debug_info_section(os
->name()))
475 index
= PLACE_NONALLOC
;
476 else if ((flags
& elfcpp::SHF_ALLOC
) == 0)
478 else if (type
== elfcpp::SHT_NOTE
)
479 index
= PLACE_INTERP
;
480 else if ((flags
& elfcpp::SHF_TLS
) != 0)
482 if (type
== elfcpp::SHT_NOBITS
)
483 index
= PLACE_TLS_BSS
;
487 else if (type
== elfcpp::SHT_NOBITS
)
489 else if ((flags
& elfcpp::SHF_WRITE
) != 0)
491 else if (type
== elfcpp::SHT_REL
|| type
== elfcpp::SHT_RELA
)
493 else if ((flags
& elfcpp::SHF_EXECINSTR
) == 0)
494 index
= PLACE_RODATA
;
498 // If we don't have a location yet, try to find one based on a
499 // plausible ordering of sections.
500 if (!this->places_
[index
].have_location
)
525 if (!this->places_
[PLACE_TLS
].have_location
)
529 if (follow
!= PLACE_MAX
&& this->places_
[follow
].have_location
)
531 // Set the location of INDEX to the location of FOLLOW. The
532 // location of INDEX will then be incremented by the caller,
533 // so anything in INDEX will continue to be after anything
535 this->places_
[index
].location
= this->places_
[follow
].location
;
536 this->places_
[index
].have_location
= true;
540 *pwhere
= &this->places_
[index
].location
;
541 bool ret
= this->places_
[index
].have_location
;
543 // The caller will set the location.
544 this->places_
[index
].have_location
= true;
549 // Return the iterator being used for sections at the very end of the
552 Orphan_section_placement::Elements_iterator
553 Orphan_section_placement::last_place() const
555 gold_assert(this->places_
[PLACE_LAST
].have_location
);
556 return this->places_
[PLACE_LAST
].location
;
559 // An element in a SECTIONS clause.
561 class Sections_element
567 virtual ~Sections_element()
570 // Return whether an output section is relro.
575 // Record that an output section is relro.
580 // Create any required output sections. The only real
581 // implementation is in Output_section_definition.
583 create_sections(Layout
*)
586 // Add any symbol being defined to the symbol table.
588 add_symbols_to_table(Symbol_table
*)
591 // Finalize symbols and check assertions.
593 finalize_symbols(Symbol_table
*, const Layout
*, uint64_t*)
596 // Return the output section name to use for an input file name and
597 // section name. This only real implementation is in
598 // Output_section_definition.
600 output_section_name(const char*, const char*, Output_section
***,
601 Script_sections::Section_type
*, bool*)
604 // Initialize OSP with an output section.
606 orphan_section_init(Orphan_section_placement
*,
607 Script_sections::Elements_iterator
)
610 // Set section addresses. This includes applying assignments if the
611 // expression is an absolute value.
613 set_section_addresses(Symbol_table
*, Layout
*, uint64_t*, uint64_t*,
617 // Check a constraint (ONLY_IF_RO, etc.) on an output section. If
618 // this section is constrained, and the input sections do not match,
619 // return the constraint, and set *POSD.
620 virtual Section_constraint
621 check_constraint(Output_section_definition
**)
622 { return CONSTRAINT_NONE
; }
624 // See if this is the alternate output section for a constrained
625 // output section. If it is, transfer the Output_section and return
626 // true. Otherwise return false.
628 alternate_constraint(Output_section_definition
*, Section_constraint
)
631 // Get the list of segments to use for an allocated section when
632 // using a PHDRS clause. If this is an allocated section, return
633 // the Output_section, and set *PHDRS_LIST (the first parameter) to
634 // the list of PHDRS to which it should be attached. If the PHDRS
635 // were not specified, don't change *PHDRS_LIST. When not returning
636 // NULL, set *ORPHAN (the second parameter) according to whether
637 // this is an orphan section--one that is not mentioned in the
639 virtual Output_section
*
640 allocate_to_segment(String_list
**, bool*)
643 // Look for an output section by name and return the address, the
644 // load address, the alignment, and the size. This is used when an
645 // expression refers to an output section which was not actually
646 // created. This returns true if the section was found, false
647 // otherwise. The only real definition is for
648 // Output_section_definition.
650 get_output_section_info(const char*, uint64_t*, uint64_t*, uint64_t*,
654 // Return the associated Output_section if there is one.
655 virtual Output_section
*
656 get_output_section() const
659 // Set the section's memory regions.
661 set_memory_region(Memory_region
*, bool)
662 { gold_error(_("Attempt to set a memory region for a non-output section")); }
664 // Print the element for debugging purposes.
666 print(FILE* f
) const = 0;
669 // An assignment in a SECTIONS clause outside of an output section.
671 class Sections_element_assignment
: public Sections_element
674 Sections_element_assignment(const char* name
, size_t namelen
,
675 Expression
* val
, bool provide
, bool hidden
)
676 : assignment_(name
, namelen
, false, val
, provide
, hidden
)
679 // Add the symbol to the symbol table.
681 add_symbols_to_table(Symbol_table
* symtab
)
682 { this->assignment_
.add_to_table(symtab
); }
684 // Finalize the symbol.
686 finalize_symbols(Symbol_table
* symtab
, const Layout
* layout
,
689 this->assignment_
.finalize_with_dot(symtab
, layout
, *dot_value
, NULL
);
692 // Set the section address. There is no section here, but if the
693 // value is absolute, we set the symbol. This permits us to use
694 // absolute symbols when setting dot.
696 set_section_addresses(Symbol_table
* symtab
, Layout
* layout
,
697 uint64_t* dot_value
, uint64_t*, uint64_t*)
699 this->assignment_
.set_if_absolute(symtab
, layout
, true, *dot_value
, NULL
);
702 // Print for debugging.
707 this->assignment_
.print(f
);
711 Symbol_assignment assignment_
;
714 // An assignment to the dot symbol in a SECTIONS clause outside of an
717 class Sections_element_dot_assignment
: public Sections_element
720 Sections_element_dot_assignment(Expression
* val
)
724 // Finalize the symbol.
726 finalize_symbols(Symbol_table
* symtab
, const Layout
* layout
,
729 // We ignore the section of the result because outside of an
730 // output section definition the dot symbol is always considered
732 *dot_value
= this->val_
->eval_with_dot(symtab
, layout
, true, *dot_value
,
733 NULL
, NULL
, NULL
, false);
736 // Update the dot symbol while setting section addresses.
738 set_section_addresses(Symbol_table
* symtab
, Layout
* layout
,
739 uint64_t* dot_value
, uint64_t* dot_alignment
,
740 uint64_t* load_address
)
742 *dot_value
= this->val_
->eval_with_dot(symtab
, layout
, false, *dot_value
,
743 NULL
, NULL
, dot_alignment
, false);
744 *load_address
= *dot_value
;
747 // Print for debugging.
752 this->val_
->print(f
);
760 // An assertion in a SECTIONS clause outside of an output section.
762 class Sections_element_assertion
: public Sections_element
765 Sections_element_assertion(Expression
* check
, const char* message
,
767 : assertion_(check
, message
, messagelen
)
770 // Check the assertion.
772 finalize_symbols(Symbol_table
* symtab
, const Layout
* layout
, uint64_t*)
773 { this->assertion_
.check(symtab
, layout
); }
775 // Print for debugging.
780 this->assertion_
.print(f
);
784 Script_assertion assertion_
;
787 // An element in an output section in a SECTIONS clause.
789 class Output_section_element
792 // A list of input sections.
793 typedef std::list
<Output_section::Input_section
> Input_section_list
;
795 Output_section_element()
798 virtual ~Output_section_element()
801 // Return whether this element requires an output section to exist.
803 needs_output_section() const
806 // Add any symbol being defined to the symbol table.
808 add_symbols_to_table(Symbol_table
*)
811 // Finalize symbols and check assertions.
813 finalize_symbols(Symbol_table
*, const Layout
*, uint64_t*, Output_section
**)
816 // Return whether this element matches FILE_NAME and SECTION_NAME.
817 // The only real implementation is in Output_section_element_input.
819 match_name(const char*, const char*, bool *) const
822 // Set section addresses. This includes applying assignments if the
823 // expression is an absolute value.
825 set_section_addresses(Symbol_table
*, Layout
*, Output_section
*, uint64_t,
826 uint64_t*, uint64_t*, Output_section
**, std::string
*,
830 // Print the element for debugging purposes.
832 print(FILE* f
) const = 0;
835 // Return a fill string that is LENGTH bytes long, filling it with
838 get_fill_string(const std::string
* fill
, section_size_type length
) const;
842 Output_section_element::get_fill_string(const std::string
* fill
,
843 section_size_type length
) const
845 std::string this_fill
;
846 this_fill
.reserve(length
);
847 while (this_fill
.length() + fill
->length() <= length
)
849 if (this_fill
.length() < length
)
850 this_fill
.append(*fill
, 0, length
- this_fill
.length());
854 // A symbol assignment in an output section.
856 class Output_section_element_assignment
: public Output_section_element
859 Output_section_element_assignment(const char* name
, size_t namelen
,
860 Expression
* val
, bool provide
,
862 : assignment_(name
, namelen
, false, val
, provide
, hidden
)
865 // Add the symbol to the symbol table.
867 add_symbols_to_table(Symbol_table
* symtab
)
868 { this->assignment_
.add_to_table(symtab
); }
870 // Finalize the symbol.
872 finalize_symbols(Symbol_table
* symtab
, const Layout
* layout
,
873 uint64_t* dot_value
, Output_section
** dot_section
)
875 this->assignment_
.finalize_with_dot(symtab
, layout
, *dot_value
,
879 // Set the section address. There is no section here, but if the
880 // value is absolute, we set the symbol. This permits us to use
881 // absolute symbols when setting dot.
883 set_section_addresses(Symbol_table
* symtab
, Layout
* layout
, Output_section
*,
884 uint64_t, uint64_t* dot_value
, uint64_t*,
885 Output_section
** dot_section
, std::string
*,
888 this->assignment_
.set_if_absolute(symtab
, layout
, true, *dot_value
,
892 // Print for debugging.
897 this->assignment_
.print(f
);
901 Symbol_assignment assignment_
;
904 // An assignment to the dot symbol in an output section.
906 class Output_section_element_dot_assignment
: public Output_section_element
909 Output_section_element_dot_assignment(Expression
* val
)
913 // An assignment to dot within an output section is enough to force
914 // the output section to exist.
916 needs_output_section() const
919 // Finalize the symbol.
921 finalize_symbols(Symbol_table
* symtab
, const Layout
* layout
,
922 uint64_t* dot_value
, Output_section
** dot_section
)
924 *dot_value
= this->val_
->eval_with_dot(symtab
, layout
, true, *dot_value
,
925 *dot_section
, dot_section
, NULL
,
929 // Update the dot symbol while setting section addresses.
931 set_section_addresses(Symbol_table
* symtab
, Layout
* layout
, Output_section
*,
932 uint64_t, uint64_t* dot_value
, uint64_t*,
933 Output_section
** dot_section
, std::string
*,
934 Input_section_list
*);
936 // Print for debugging.
941 this->val_
->print(f
);
949 // Update the dot symbol while setting section addresses.
952 Output_section_element_dot_assignment::set_section_addresses(
953 Symbol_table
* symtab
,
955 Output_section
* output_section
,
958 uint64_t* dot_alignment
,
959 Output_section
** dot_section
,
963 uint64_t next_dot
= this->val_
->eval_with_dot(symtab
, layout
, false,
964 *dot_value
, *dot_section
,
965 dot_section
, dot_alignment
,
967 if (next_dot
< *dot_value
)
968 gold_error(_("dot may not move backward"));
969 if (next_dot
> *dot_value
&& output_section
!= NULL
)
971 section_size_type length
= convert_to_section_size_type(next_dot
973 Output_section_data
* posd
;
975 posd
= new Output_data_zero_fill(length
, 0);
978 std::string this_fill
= this->get_fill_string(fill
, length
);
979 posd
= new Output_data_const(this_fill
, 0);
981 output_section
->add_output_section_data(posd
);
982 layout
->new_output_section_data_from_script(posd
);
984 *dot_value
= next_dot
;
987 // An assertion in an output section.
989 class Output_section_element_assertion
: public Output_section_element
992 Output_section_element_assertion(Expression
* check
, const char* message
,
994 : assertion_(check
, message
, messagelen
)
1001 this->assertion_
.print(f
);
1005 Script_assertion assertion_
;
1008 // We use a special instance of Output_section_data to handle BYTE,
1009 // SHORT, etc. This permits forward references to symbols in the
1012 class Output_data_expression
: public Output_section_data
1015 Output_data_expression(int size
, bool is_signed
, Expression
* val
,
1016 const Symbol_table
* symtab
, const Layout
* layout
,
1017 uint64_t dot_value
, Output_section
* dot_section
)
1018 : Output_section_data(size
, 0, true),
1019 is_signed_(is_signed
), val_(val
), symtab_(symtab
),
1020 layout_(layout
), dot_value_(dot_value
), dot_section_(dot_section
)
1024 // Write the data to the output file.
1026 do_write(Output_file
*);
1028 // Write the data to a buffer.
1030 do_write_to_buffer(unsigned char*);
1032 // Write to a map file.
1034 do_print_to_mapfile(Mapfile
* mapfile
) const
1035 { mapfile
->print_output_data(this, _("** expression")); }
1038 template<bool big_endian
>
1040 endian_write_to_buffer(uint64_t, unsigned char*);
1044 const Symbol_table
* symtab_
;
1045 const Layout
* layout_
;
1046 uint64_t dot_value_
;
1047 Output_section
* dot_section_
;
1050 // Write the data element to the output file.
1053 Output_data_expression::do_write(Output_file
* of
)
1055 unsigned char* view
= of
->get_output_view(this->offset(), this->data_size());
1056 this->write_to_buffer(view
);
1057 of
->write_output_view(this->offset(), this->data_size(), view
);
1060 // Write the data element to a buffer.
1063 Output_data_expression::do_write_to_buffer(unsigned char* buf
)
1065 uint64_t val
= this->val_
->eval_with_dot(this->symtab_
, this->layout_
,
1066 true, this->dot_value_
,
1067 this->dot_section_
, NULL
, NULL
,
1070 if (parameters
->target().is_big_endian())
1071 this->endian_write_to_buffer
<true>(val
, buf
);
1073 this->endian_write_to_buffer
<false>(val
, buf
);
1076 template<bool big_endian
>
1078 Output_data_expression::endian_write_to_buffer(uint64_t val
,
1081 switch (this->data_size())
1084 elfcpp::Swap_unaligned
<8, big_endian
>::writeval(buf
, val
);
1087 elfcpp::Swap_unaligned
<16, big_endian
>::writeval(buf
, val
);
1090 elfcpp::Swap_unaligned
<32, big_endian
>::writeval(buf
, val
);
1093 if (parameters
->target().get_size() == 32)
1096 if (this->is_signed_
&& (val
& 0x80000000) != 0)
1097 val
|= 0xffffffff00000000LL
;
1099 elfcpp::Swap_unaligned
<64, big_endian
>::writeval(buf
, val
);
1106 // A data item in an output section.
1108 class Output_section_element_data
: public Output_section_element
1111 Output_section_element_data(int size
, bool is_signed
, Expression
* val
)
1112 : size_(size
), is_signed_(is_signed
), val_(val
)
1115 // If there is a data item, then we must create an output section.
1117 needs_output_section() const
1120 // Finalize symbols--we just need to update dot.
1122 finalize_symbols(Symbol_table
*, const Layout
*, uint64_t* dot_value
,
1124 { *dot_value
+= this->size_
; }
1126 // Store the value in the section.
1128 set_section_addresses(Symbol_table
*, Layout
*, Output_section
*, uint64_t,
1129 uint64_t* dot_value
, uint64_t*, Output_section
**,
1130 std::string
*, Input_section_list
*);
1132 // Print for debugging.
1137 // The size in bytes.
1139 // Whether the value is signed.
1145 // Store the value in the section.
1148 Output_section_element_data::set_section_addresses(
1149 Symbol_table
* symtab
,
1153 uint64_t* dot_value
,
1155 Output_section
** dot_section
,
1157 Input_section_list
*)
1159 gold_assert(os
!= NULL
);
1160 Output_data_expression
* expression
=
1161 new Output_data_expression(this->size_
, this->is_signed_
, this->val_
,
1162 symtab
, layout
, *dot_value
, *dot_section
);
1163 os
->add_output_section_data(expression
);
1164 layout
->new_output_section_data_from_script(expression
);
1165 *dot_value
+= this->size_
;
1168 // Print for debugging.
1171 Output_section_element_data::print(FILE* f
) const
1174 switch (this->size_
)
1186 if (this->is_signed_
)
1194 fprintf(f
, " %s(", s
);
1195 this->val_
->print(f
);
1199 // A fill value setting in an output section.
1201 class Output_section_element_fill
: public Output_section_element
1204 Output_section_element_fill(Expression
* val
)
1208 // Update the fill value while setting section addresses.
1210 set_section_addresses(Symbol_table
* symtab
, Layout
* layout
, Output_section
*,
1211 uint64_t, uint64_t* dot_value
, uint64_t*,
1212 Output_section
** dot_section
,
1213 std::string
* fill
, Input_section_list
*)
1215 Output_section
* fill_section
;
1216 uint64_t fill_val
= this->val_
->eval_with_dot(symtab
, layout
, false,
1217 *dot_value
, *dot_section
,
1218 &fill_section
, NULL
, false);
1219 if (fill_section
!= NULL
)
1220 gold_warning(_("fill value is not absolute"));
1221 // FIXME: The GNU linker supports fill values of arbitrary length.
1222 unsigned char fill_buff
[4];
1223 elfcpp::Swap_unaligned
<32, true>::writeval(fill_buff
, fill_val
);
1224 fill
->assign(reinterpret_cast<char*>(fill_buff
), 4);
1227 // Print for debugging.
1229 print(FILE* f
) const
1231 fprintf(f
, " FILL(");
1232 this->val_
->print(f
);
1237 // The new fill value.
1241 // An input section specification in an output section
1243 class Output_section_element_input
: public Output_section_element
1246 Output_section_element_input(const Input_section_spec
* spec
, bool keep
);
1248 // Finalize symbols--just update the value of the dot symbol.
1250 finalize_symbols(Symbol_table
*, const Layout
*, uint64_t* dot_value
,
1251 Output_section
** dot_section
)
1253 *dot_value
= this->final_dot_value_
;
1254 *dot_section
= this->final_dot_section_
;
1257 // See whether we match FILE_NAME and SECTION_NAME as an input section.
1258 // If we do then also indicate whether the section should be KEPT.
1260 match_name(const char* file_name
, const char* section_name
, bool* keep
) const;
1262 // Set the section address.
1264 set_section_addresses(Symbol_table
* symtab
, Layout
* layout
, Output_section
*,
1265 uint64_t subalign
, uint64_t* dot_value
, uint64_t*,
1266 Output_section
**, std::string
* fill
,
1267 Input_section_list
*);
1269 // Print for debugging.
1271 print(FILE* f
) const;
1274 // An input section pattern.
1275 struct Input_section_pattern
1277 std::string pattern
;
1278 bool pattern_is_wildcard
;
1281 Input_section_pattern(const char* patterna
, size_t patternlena
,
1282 Sort_wildcard sorta
)
1283 : pattern(patterna
, patternlena
),
1284 pattern_is_wildcard(is_wildcard_string(this->pattern
.c_str())),
1289 typedef std::vector
<Input_section_pattern
> Input_section_patterns
;
1291 // Filename_exclusions is a pair of filename pattern and a bool
1292 // indicating whether the filename is a wildcard.
1293 typedef std::vector
<std::pair
<std::string
, bool> > Filename_exclusions
;
1295 // Return whether STRING matches PATTERN, where IS_WILDCARD_PATTERN
1296 // indicates whether this is a wildcard pattern.
1298 match(const char* string
, const char* pattern
, bool is_wildcard_pattern
)
1300 return (is_wildcard_pattern
1301 ? fnmatch(pattern
, string
, 0) == 0
1302 : strcmp(string
, pattern
) == 0);
1305 // See if we match a file name.
1307 match_file_name(const char* file_name
) const;
1309 // The file name pattern. If this is the empty string, we match all
1311 std::string filename_pattern_
;
1312 // Whether the file name pattern is a wildcard.
1313 bool filename_is_wildcard_
;
1314 // How the file names should be sorted. This may only be
1315 // SORT_WILDCARD_NONE or SORT_WILDCARD_BY_NAME.
1316 Sort_wildcard filename_sort_
;
1317 // The list of file names to exclude.
1318 Filename_exclusions filename_exclusions_
;
1319 // The list of input section patterns.
1320 Input_section_patterns input_section_patterns_
;
1321 // Whether to keep this section when garbage collecting.
1323 // The value of dot after including all matching sections.
1324 uint64_t final_dot_value_
;
1325 // The section where dot is defined after including all matching
1327 Output_section
* final_dot_section_
;
1330 // Construct Output_section_element_input. The parser records strings
1331 // as pointers into a copy of the script file, which will go away when
1332 // parsing is complete. We make sure they are in std::string objects.
1334 Output_section_element_input::Output_section_element_input(
1335 const Input_section_spec
* spec
,
1337 : filename_pattern_(),
1338 filename_is_wildcard_(false),
1339 filename_sort_(spec
->file
.sort
),
1340 filename_exclusions_(),
1341 input_section_patterns_(),
1343 final_dot_value_(0),
1344 final_dot_section_(NULL
)
1346 // The filename pattern "*" is common, and matches all files. Turn
1347 // it into the empty string.
1348 if (spec
->file
.name
.length
!= 1 || spec
->file
.name
.value
[0] != '*')
1349 this->filename_pattern_
.assign(spec
->file
.name
.value
,
1350 spec
->file
.name
.length
);
1351 this->filename_is_wildcard_
= is_wildcard_string(this->filename_pattern_
.c_str());
1353 if (spec
->input_sections
.exclude
!= NULL
)
1355 for (String_list::const_iterator p
=
1356 spec
->input_sections
.exclude
->begin();
1357 p
!= spec
->input_sections
.exclude
->end();
1360 bool is_wildcard
= is_wildcard_string((*p
).c_str());
1361 this->filename_exclusions_
.push_back(std::make_pair(*p
,
1366 if (spec
->input_sections
.sections
!= NULL
)
1368 Input_section_patterns
& isp(this->input_section_patterns_
);
1369 for (String_sort_list::const_iterator p
=
1370 spec
->input_sections
.sections
->begin();
1371 p
!= spec
->input_sections
.sections
->end();
1373 isp
.push_back(Input_section_pattern(p
->name
.value
, p
->name
.length
,
1378 // See whether we match FILE_NAME.
1381 Output_section_element_input::match_file_name(const char* file_name
) const
1383 if (!this->filename_pattern_
.empty())
1385 // If we were called with no filename, we refuse to match a
1386 // pattern which requires a file name.
1387 if (file_name
== NULL
)
1390 if (!match(file_name
, this->filename_pattern_
.c_str(),
1391 this->filename_is_wildcard_
))
1395 if (file_name
!= NULL
)
1397 // Now we have to see whether FILE_NAME matches one of the
1398 // exclusion patterns, if any.
1399 for (Filename_exclusions::const_iterator p
=
1400 this->filename_exclusions_
.begin();
1401 p
!= this->filename_exclusions_
.end();
1404 if (match(file_name
, p
->first
.c_str(), p
->second
))
1412 // See whether we match FILE_NAME and SECTION_NAME. If we do then
1413 // KEEP indicates whether the section should survive garbage collection.
1416 Output_section_element_input::match_name(const char* file_name
,
1417 const char* section_name
,
1420 if (!this->match_file_name(file_name
))
1423 *keep
= this->keep_
;
1425 // If there are no section name patterns, then we match.
1426 if (this->input_section_patterns_
.empty())
1429 // See whether we match the section name patterns.
1430 for (Input_section_patterns::const_iterator p
=
1431 this->input_section_patterns_
.begin();
1432 p
!= this->input_section_patterns_
.end();
1435 if (match(section_name
, p
->pattern
.c_str(), p
->pattern_is_wildcard
))
1439 // We didn't match any section names, so we didn't match.
1443 // Information we use to sort the input sections.
1445 class Input_section_info
1448 Input_section_info(const Output_section::Input_section
& input_section
)
1449 : input_section_(input_section
), section_name_(),
1450 size_(0), addralign_(1)
1453 // Return the simple input section.
1454 const Output_section::Input_section
&
1455 input_section() const
1456 { return this->input_section_
; }
1458 // Return the object.
1461 { return this->input_section_
.relobj(); }
1463 // Return the section index.
1466 { return this->input_section_
.shndx(); }
1468 // Return the section name.
1470 section_name() const
1471 { return this->section_name_
; }
1473 // Set the section name.
1475 set_section_name(const std::string name
)
1477 if (is_compressed_debug_section(name
.c_str()))
1478 this->section_name_
= corresponding_uncompressed_section_name(name
);
1480 this->section_name_
= name
;
1483 // Return the section size.
1486 { return this->size_
; }
1488 // Set the section size.
1490 set_size(uint64_t size
)
1491 { this->size_
= size
; }
1493 // Return the address alignment.
1496 { return this->addralign_
; }
1498 // Set the address alignment.
1500 set_addralign(uint64_t addralign
)
1501 { this->addralign_
= addralign
; }
1504 // Input section, can be a relaxed section.
1505 Output_section::Input_section input_section_
;
1506 // Name of the section.
1507 std::string section_name_
;
1510 // Address alignment.
1511 uint64_t addralign_
;
1514 // A class to sort the input sections.
1516 class Input_section_sorter
1519 Input_section_sorter(Sort_wildcard filename_sort
, Sort_wildcard section_sort
)
1520 : filename_sort_(filename_sort
), section_sort_(section_sort
)
1524 operator()(const Input_section_info
&, const Input_section_info
&) const;
1527 Sort_wildcard filename_sort_
;
1528 Sort_wildcard section_sort_
;
1532 Input_section_sorter::operator()(const Input_section_info
& isi1
,
1533 const Input_section_info
& isi2
) const
1535 if (this->section_sort_
== SORT_WILDCARD_BY_NAME
1536 || this->section_sort_
== SORT_WILDCARD_BY_NAME_BY_ALIGNMENT
1537 || (this->section_sort_
== SORT_WILDCARD_BY_ALIGNMENT_BY_NAME
1538 && isi1
.addralign() == isi2
.addralign()))
1540 if (isi1
.section_name() != isi2
.section_name())
1541 return isi1
.section_name() < isi2
.section_name();
1543 if (this->section_sort_
== SORT_WILDCARD_BY_ALIGNMENT
1544 || this->section_sort_
== SORT_WILDCARD_BY_NAME_BY_ALIGNMENT
1545 || this->section_sort_
== SORT_WILDCARD_BY_ALIGNMENT_BY_NAME
)
1547 if (isi1
.addralign() != isi2
.addralign())
1548 return isi1
.addralign() < isi2
.addralign();
1550 if (this->filename_sort_
== SORT_WILDCARD_BY_NAME
)
1552 if (isi1
.relobj()->name() != isi2
.relobj()->name())
1553 return (isi1
.relobj()->name() < isi2
.relobj()->name());
1556 // Otherwise we leave them in the same order.
1560 // Set the section address. Look in INPUT_SECTIONS for sections which
1561 // match this spec, sort them as specified, and add them to the output
1565 Output_section_element_input::set_section_addresses(
1568 Output_section
* output_section
,
1570 uint64_t* dot_value
,
1572 Output_section
** dot_section
,
1574 Input_section_list
* input_sections
)
1576 // We build a list of sections which match each
1577 // Input_section_pattern.
1579 // If none of the patterns specify a sort option, we throw all
1580 // matching input sections into a single bin, in the order we
1581 // find them. Otherwise, we put matching input sections into
1582 // a separate bin for each pattern, and sort each one as
1583 // specified. Thus, an input section spec like this:
1585 // will group all .foo and .bar sections in the order seen,
1588 // will group all .foo sections followed by all .bar sections.
1589 // This matches Gnu ld behavior.
1591 // Things get really weird, though, when you add a sort spec
1592 // on some, but not all, of the patterns, like this:
1593 // *(SORT_BY_NAME(.foo) .bar)
1594 // We do not attempt to match Gnu ld behavior in this case.
1596 typedef std::vector
<std::vector
<Input_section_info
> > Matching_sections
;
1597 size_t input_pattern_count
= this->input_section_patterns_
.size();
1598 bool any_patterns_with_sort
= false;
1599 for (size_t i
= 0; i
< input_pattern_count
; ++i
)
1601 const Input_section_pattern
& isp(this->input_section_patterns_
[i
]);
1602 if (isp
.sort
!= SORT_WILDCARD_NONE
)
1603 any_patterns_with_sort
= true;
1605 if (input_pattern_count
== 0 || !any_patterns_with_sort
)
1606 input_pattern_count
= 1;
1607 Matching_sections
matching_sections(input_pattern_count
);
1609 // Look through the list of sections for this output section. Add
1610 // each one which matches to one of the elements of
1611 // MATCHING_SECTIONS.
1613 Input_section_list::iterator p
= input_sections
->begin();
1614 while (p
!= input_sections
->end())
1616 Relobj
* relobj
= p
->relobj();
1617 unsigned int shndx
= p
->shndx();
1618 Input_section_info
isi(*p
);
1620 // Calling section_name and section_addralign is not very
1623 // Lock the object so that we can get information about the
1624 // section. This is OK since we know we are single-threaded
1627 const Task
* task
= reinterpret_cast<const Task
*>(-1);
1628 Task_lock_obj
<Object
> tl(task
, relobj
);
1630 isi
.set_section_name(relobj
->section_name(shndx
));
1631 if (p
->is_relaxed_input_section())
1633 // We use current data size because relaxed section sizes may not
1634 // have finalized yet.
1635 isi
.set_size(p
->relaxed_input_section()->current_data_size());
1636 isi
.set_addralign(p
->relaxed_input_section()->addralign());
1640 isi
.set_size(relobj
->section_size(shndx
));
1641 isi
.set_addralign(relobj
->section_addralign(shndx
));
1645 if (!this->match_file_name(relobj
->name().c_str()))
1647 else if (this->input_section_patterns_
.empty())
1649 matching_sections
[0].push_back(isi
);
1650 p
= input_sections
->erase(p
);
1655 for (i
= 0; i
< input_pattern_count
; ++i
)
1657 const Input_section_pattern
&
1658 isp(this->input_section_patterns_
[i
]);
1659 if (match(isi
.section_name().c_str(), isp
.pattern
.c_str(),
1660 isp
.pattern_is_wildcard
))
1664 if (i
>= this->input_section_patterns_
.size())
1668 if (!any_patterns_with_sort
)
1670 matching_sections
[i
].push_back(isi
);
1671 p
= input_sections
->erase(p
);
1676 // Look through MATCHING_SECTIONS. Sort each one as specified,
1677 // using a stable sort so that we get the default order when
1678 // sections are otherwise equal. Add each input section to the
1681 uint64_t dot
= *dot_value
;
1682 for (size_t i
= 0; i
< input_pattern_count
; ++i
)
1684 if (matching_sections
[i
].empty())
1687 gold_assert(output_section
!= NULL
);
1689 const Input_section_pattern
& isp(this->input_section_patterns_
[i
]);
1690 if (isp
.sort
!= SORT_WILDCARD_NONE
1691 || this->filename_sort_
!= SORT_WILDCARD_NONE
)
1692 std::stable_sort(matching_sections
[i
].begin(),
1693 matching_sections
[i
].end(),
1694 Input_section_sorter(this->filename_sort_
,
1697 for (std::vector
<Input_section_info
>::const_iterator p
=
1698 matching_sections
[i
].begin();
1699 p
!= matching_sections
[i
].end();
1702 // Override the original address alignment if SUBALIGN is specified
1703 // and is greater than the original alignment. We need to make a
1704 // copy of the input section to modify the alignment.
1705 Output_section::Input_section
sis(p
->input_section());
1707 uint64_t this_subalign
= sis
.addralign();
1708 if (!sis
.is_input_section())
1709 sis
.output_section_data()->finalize_data_size();
1710 uint64_t data_size
= sis
.data_size();
1711 if (this_subalign
< subalign
)
1713 this_subalign
= subalign
;
1714 sis
.set_addralign(subalign
);
1717 uint64_t address
= align_address(dot
, this_subalign
);
1719 if (address
> dot
&& !fill
->empty())
1721 section_size_type length
=
1722 convert_to_section_size_type(address
- dot
);
1723 std::string this_fill
= this->get_fill_string(fill
, length
);
1724 Output_section_data
* posd
= new Output_data_const(this_fill
, 0);
1725 output_section
->add_output_section_data(posd
);
1726 layout
->new_output_section_data_from_script(posd
);
1729 output_section
->add_script_input_section(sis
);
1730 dot
= address
+ data_size
;
1734 // An SHF_TLS/SHT_NOBITS section does not take up any
1736 if (output_section
== NULL
1737 || (output_section
->flags() & elfcpp::SHF_TLS
) == 0
1738 || output_section
->type() != elfcpp::SHT_NOBITS
)
1741 this->final_dot_value_
= *dot_value
;
1742 this->final_dot_section_
= *dot_section
;
1745 // Print for debugging.
1748 Output_section_element_input::print(FILE* f
) const
1753 fprintf(f
, "KEEP(");
1755 if (!this->filename_pattern_
.empty())
1757 bool need_close_paren
= false;
1758 switch (this->filename_sort_
)
1760 case SORT_WILDCARD_NONE
:
1762 case SORT_WILDCARD_BY_NAME
:
1763 fprintf(f
, "SORT_BY_NAME(");
1764 need_close_paren
= true;
1770 fprintf(f
, "%s", this->filename_pattern_
.c_str());
1772 if (need_close_paren
)
1776 if (!this->input_section_patterns_
.empty()
1777 || !this->filename_exclusions_
.empty())
1781 bool need_space
= false;
1782 if (!this->filename_exclusions_
.empty())
1784 fprintf(f
, "EXCLUDE_FILE(");
1785 bool need_comma
= false;
1786 for (Filename_exclusions::const_iterator p
=
1787 this->filename_exclusions_
.begin();
1788 p
!= this->filename_exclusions_
.end();
1793 fprintf(f
, "%s", p
->first
.c_str());
1800 for (Input_section_patterns::const_iterator p
=
1801 this->input_section_patterns_
.begin();
1802 p
!= this->input_section_patterns_
.end();
1808 int close_parens
= 0;
1811 case SORT_WILDCARD_NONE
:
1813 case SORT_WILDCARD_BY_NAME
:
1814 fprintf(f
, "SORT_BY_NAME(");
1817 case SORT_WILDCARD_BY_ALIGNMENT
:
1818 fprintf(f
, "SORT_BY_ALIGNMENT(");
1821 case SORT_WILDCARD_BY_NAME_BY_ALIGNMENT
:
1822 fprintf(f
, "SORT_BY_NAME(SORT_BY_ALIGNMENT(");
1825 case SORT_WILDCARD_BY_ALIGNMENT_BY_NAME
:
1826 fprintf(f
, "SORT_BY_ALIGNMENT(SORT_BY_NAME(");
1833 fprintf(f
, "%s", p
->pattern
.c_str());
1835 for (int i
= 0; i
< close_parens
; ++i
)
1850 // An output section.
1852 class Output_section_definition
: public Sections_element
1855 typedef Output_section_element::Input_section_list Input_section_list
;
1857 Output_section_definition(const char* name
, size_t namelen
,
1858 const Parser_output_section_header
* header
);
1860 // Finish the output section with the information in the trailer.
1862 finish(const Parser_output_section_trailer
* trailer
);
1864 // Add a symbol to be defined.
1866 add_symbol_assignment(const char* name
, size_t length
, Expression
* value
,
1867 bool provide
, bool hidden
);
1869 // Add an assignment to the special dot symbol.
1871 add_dot_assignment(Expression
* value
);
1873 // Add an assertion.
1875 add_assertion(Expression
* check
, const char* message
, size_t messagelen
);
1877 // Add a data item to the current output section.
1879 add_data(int size
, bool is_signed
, Expression
* val
);
1881 // Add a setting for the fill value.
1883 add_fill(Expression
* val
);
1885 // Add an input section specification.
1887 add_input_section(const Input_section_spec
* spec
, bool keep
);
1889 // Return whether the output section is relro.
1892 { return this->is_relro_
; }
1894 // Record that the output section is relro.
1897 { this->is_relro_
= true; }
1899 // Create any required output sections.
1901 create_sections(Layout
*);
1903 // Add any symbols being defined to the symbol table.
1905 add_symbols_to_table(Symbol_table
* symtab
);
1907 // Finalize symbols and check assertions.
1909 finalize_symbols(Symbol_table
*, const Layout
*, uint64_t*);
1911 // Return the output section name to use for an input file name and
1914 output_section_name(const char* file_name
, const char* section_name
,
1915 Output_section
***, Script_sections::Section_type
*,
1918 // Initialize OSP with an output section.
1920 orphan_section_init(Orphan_section_placement
* osp
,
1921 Script_sections::Elements_iterator p
)
1922 { osp
->output_section_init(this->name_
, this->output_section_
, p
); }
1924 // Set the section address.
1926 set_section_addresses(Symbol_table
* symtab
, Layout
* layout
,
1927 uint64_t* dot_value
, uint64_t*,
1928 uint64_t* load_address
);
1930 // Check a constraint (ONLY_IF_RO, etc.) on an output section. If
1931 // this section is constrained, and the input sections do not match,
1932 // return the constraint, and set *POSD.
1934 check_constraint(Output_section_definition
** posd
);
1936 // See if this is the alternate output section for a constrained
1937 // output section. If it is, transfer the Output_section and return
1938 // true. Otherwise return false.
1940 alternate_constraint(Output_section_definition
*, Section_constraint
);
1942 // Get the list of segments to use for an allocated section when
1943 // using a PHDRS clause.
1945 allocate_to_segment(String_list
** phdrs_list
, bool* orphan
);
1947 // Look for an output section by name and return the address, the
1948 // load address, the alignment, and the size. This is used when an
1949 // expression refers to an output section which was not actually
1950 // created. This returns true if the section was found, false
1953 get_output_section_info(const char*, uint64_t*, uint64_t*, uint64_t*,
1956 // Return the associated Output_section if there is one.
1958 get_output_section() const
1959 { return this->output_section_
; }
1961 // Print the contents to the FILE. This is for debugging.
1965 // Return the output section type if specified or Script_sections::ST_NONE.
1966 Script_sections::Section_type
1967 section_type() const;
1969 // Store the memory region to use.
1971 set_memory_region(Memory_region
*, bool set_vma
);
1974 set_section_vma(Expression
* address
)
1975 { this->address_
= address
; }
1978 set_section_lma(Expression
* address
)
1979 { this->load_address_
= address
; }
1982 get_section_name() const
1983 { return this->name_
; }
1987 script_section_type_name(Script_section_type
);
1989 typedef std::vector
<Output_section_element
*> Output_section_elements
;
1991 // The output section name.
1993 // The address. This may be NULL.
1994 Expression
* address_
;
1995 // The load address. This may be NULL.
1996 Expression
* load_address_
;
1997 // The alignment. This may be NULL.
1999 // The input section alignment. This may be NULL.
2000 Expression
* subalign_
;
2001 // The constraint, if any.
2002 Section_constraint constraint_
;
2003 // The fill value. This may be NULL.
2005 // The list of segments this section should go into. This may be
2007 String_list
* phdrs_
;
2008 // The list of elements defining the section.
2009 Output_section_elements elements_
;
2010 // The Output_section created for this definition. This will be
2011 // NULL if none was created.
2012 Output_section
* output_section_
;
2013 // The address after it has been evaluated.
2014 uint64_t evaluated_address_
;
2015 // The load address after it has been evaluated.
2016 uint64_t evaluated_load_address_
;
2017 // The alignment after it has been evaluated.
2018 uint64_t evaluated_addralign_
;
2019 // The output section is relro.
2021 // The output section type if specified.
2022 enum Script_section_type script_section_type_
;
2027 Output_section_definition::Output_section_definition(
2030 const Parser_output_section_header
* header
)
2031 : name_(name
, namelen
),
2032 address_(header
->address
),
2033 load_address_(header
->load_address
),
2034 align_(header
->align
),
2035 subalign_(header
->subalign
),
2036 constraint_(header
->constraint
),
2040 output_section_(NULL
),
2041 evaluated_address_(0),
2042 evaluated_load_address_(0),
2043 evaluated_addralign_(0),
2045 script_section_type_(header
->section_type
)
2049 // Finish an output section.
2052 Output_section_definition::finish(const Parser_output_section_trailer
* trailer
)
2054 this->fill_
= trailer
->fill
;
2055 this->phdrs_
= trailer
->phdrs
;
2058 // Add a symbol to be defined.
2061 Output_section_definition::add_symbol_assignment(const char* name
,
2067 Output_section_element
* p
= new Output_section_element_assignment(name
,
2072 this->elements_
.push_back(p
);
2075 // Add an assignment to the special dot symbol.
2078 Output_section_definition::add_dot_assignment(Expression
* value
)
2080 Output_section_element
* p
= new Output_section_element_dot_assignment(value
);
2081 this->elements_
.push_back(p
);
2084 // Add an assertion.
2087 Output_section_definition::add_assertion(Expression
* check
,
2088 const char* message
,
2091 Output_section_element
* p
= new Output_section_element_assertion(check
,
2094 this->elements_
.push_back(p
);
2097 // Add a data item to the current output section.
2100 Output_section_definition::add_data(int size
, bool is_signed
, Expression
* val
)
2102 Output_section_element
* p
= new Output_section_element_data(size
, is_signed
,
2104 this->elements_
.push_back(p
);
2107 // Add a setting for the fill value.
2110 Output_section_definition::add_fill(Expression
* val
)
2112 Output_section_element
* p
= new Output_section_element_fill(val
);
2113 this->elements_
.push_back(p
);
2116 // Add an input section specification.
2119 Output_section_definition::add_input_section(const Input_section_spec
* spec
,
2122 Output_section_element
* p
= new Output_section_element_input(spec
, keep
);
2123 this->elements_
.push_back(p
);
2126 // Create any required output sections. We need an output section if
2127 // there is a data statement here.
2130 Output_section_definition::create_sections(Layout
* layout
)
2132 if (this->output_section_
!= NULL
)
2134 for (Output_section_elements::const_iterator p
= this->elements_
.begin();
2135 p
!= this->elements_
.end();
2138 if ((*p
)->needs_output_section())
2140 const char* name
= this->name_
.c_str();
2141 this->output_section_
=
2142 layout
->make_output_section_for_script(name
, this->section_type());
2148 // Add any symbols being defined to the symbol table.
2151 Output_section_definition::add_symbols_to_table(Symbol_table
* symtab
)
2153 for (Output_section_elements::iterator p
= this->elements_
.begin();
2154 p
!= this->elements_
.end();
2156 (*p
)->add_symbols_to_table(symtab
);
2159 // Finalize symbols and check assertions.
2162 Output_section_definition::finalize_symbols(Symbol_table
* symtab
,
2163 const Layout
* layout
,
2164 uint64_t* dot_value
)
2166 if (this->output_section_
!= NULL
)
2167 *dot_value
= this->output_section_
->address();
2170 uint64_t address
= *dot_value
;
2171 if (this->address_
!= NULL
)
2173 address
= this->address_
->eval_with_dot(symtab
, layout
, true,
2177 if (this->align_
!= NULL
)
2179 uint64_t align
= this->align_
->eval_with_dot(symtab
, layout
, true,
2182 address
= align_address(address
, align
);
2184 *dot_value
= address
;
2187 Output_section
* dot_section
= this->output_section_
;
2188 for (Output_section_elements::iterator p
= this->elements_
.begin();
2189 p
!= this->elements_
.end();
2191 (*p
)->finalize_symbols(symtab
, layout
, dot_value
, &dot_section
);
2194 // Return the output section name to use for an input section name.
2197 Output_section_definition::output_section_name(
2198 const char* file_name
,
2199 const char* section_name
,
2200 Output_section
*** slot
,
2201 Script_sections::Section_type
* psection_type
,
2204 // Ask each element whether it matches NAME.
2205 for (Output_section_elements::const_iterator p
= this->elements_
.begin();
2206 p
!= this->elements_
.end();
2209 if ((*p
)->match_name(file_name
, section_name
, keep
))
2211 // We found a match for NAME, which means that it should go
2212 // into this output section.
2213 *slot
= &this->output_section_
;
2214 *psection_type
= this->section_type();
2215 return this->name_
.c_str();
2219 // We don't know about this section name.
2223 // Return true if memory from START to START + LENGTH is contained
2224 // within a memory region.
2227 Script_sections::block_in_region(Symbol_table
* symtab
, Layout
* layout
,
2228 uint64_t start
, uint64_t length
) const
2230 if (this->memory_regions_
== NULL
)
2233 for (Memory_regions::const_iterator mr
= this->memory_regions_
->begin();
2234 mr
!= this->memory_regions_
->end();
2237 uint64_t s
= (*mr
)->start_address()->eval(symtab
, layout
, false);
2238 uint64_t l
= (*mr
)->length()->eval(symtab
, layout
, false);
2241 && (s
+ l
) >= (start
+ length
))
2248 // Find a memory region that should be used by a given output SECTION.
2249 // If provided set PREVIOUS_SECTION_RETURN to point to the last section
2250 // that used the return memory region.
2253 Script_sections::find_memory_region(
2254 Output_section_definition
* section
,
2255 bool find_vma_region
,
2257 Output_section_definition
** previous_section_return
)
2259 if (previous_section_return
!= NULL
)
2260 * previous_section_return
= NULL
;
2262 // Walk the memory regions specified in this script, if any.
2263 if (this->memory_regions_
== NULL
)
2266 // The /DISCARD/ section never gets assigned to any region.
2267 if (section
->get_section_name() == "/DISCARD/")
2270 Memory_region
* first_match
= NULL
;
2272 // First check to see if a region has been assigned to this section.
2273 for (Memory_regions::const_iterator mr
= this->memory_regions_
->begin();
2274 mr
!= this->memory_regions_
->end();
2277 if (find_vma_region
)
2279 for (Memory_region::Section_list::const_iterator s
=
2280 (*mr
)->get_vma_section_list_start();
2281 s
!= (*mr
)->get_vma_section_list_end();
2283 if ((*s
) == section
)
2285 (*mr
)->set_last_section(section
);
2291 for (Memory_region::Section_list::const_iterator s
=
2292 (*mr
)->get_lma_section_list_start();
2293 s
!= (*mr
)->get_lma_section_list_end();
2295 if ((*s
) == section
)
2297 (*mr
)->set_last_section(section
);
2304 // Make a note of the first memory region whose attributes
2305 // are compatible with the section. If we do not find an
2306 // explicit region assignment, then we will return this region.
2307 Output_section
* out_sec
= section
->get_output_section();
2308 if (first_match
== NULL
2310 && (*mr
)->attributes_compatible(out_sec
->flags(),
2316 // With LMA computations, if an explicit region has not been specified then
2317 // we will want to set the difference between the VMA and the LMA of the
2318 // section were searching for to be the same as the difference between the
2319 // VMA and LMA of the last section to be added to first matched region.
2320 // Hence, if it was asked for, we return a pointer to the last section
2321 // known to be used by the first matched region.
2322 if (first_match
!= NULL
2323 && previous_section_return
!= NULL
)
2324 *previous_section_return
= first_match
->get_last_section();
2329 // Set the section address. Note that the OUTPUT_SECTION_ field will
2330 // be NULL if no input sections were mapped to this output section.
2331 // We still have to adjust dot and process symbol assignments.
2334 Output_section_definition::set_section_addresses(Symbol_table
* symtab
,
2336 uint64_t* dot_value
,
2337 uint64_t* dot_alignment
,
2338 uint64_t* load_address
)
2340 Memory_region
* vma_region
= NULL
;
2341 Memory_region
* lma_region
= NULL
;
2342 Script_sections
* script_sections
=
2343 layout
->script_options()->script_sections();
2345 uint64_t old_dot_value
= *dot_value
;
2346 uint64_t old_load_address
= *load_address
;
2348 // If input section sorting is requested via --section-ordering-file or
2349 // linker plugins, then do it here. This is important because we want
2350 // any sorting specified in the linker scripts, which will be done after
2351 // this, to take precedence. The final order of input sections is then
2352 // guaranteed to be according to the linker script specification.
2353 if (this->output_section_
!= NULL
2354 && this->output_section_
->input_section_order_specified())
2355 this->output_section_
->sort_attached_input_sections();
2357 // Decide the start address for the section. The algorithm is:
2358 // 1) If an address has been specified in a linker script, use that.
2359 // 2) Otherwise if a memory region has been specified for the section,
2360 // use the next free address in the region.
2361 // 3) Otherwise if memory regions have been specified find the first
2362 // region whose attributes are compatible with this section and
2363 // install it into that region.
2364 // 4) Otherwise use the current location counter.
2366 if (this->output_section_
!= NULL
2367 // Check for --section-start.
2368 && parameters
->options().section_start(this->output_section_
->name(),
2371 else if (this->address_
== NULL
)
2373 vma_region
= script_sections
->find_memory_region(this, true, false, NULL
);
2374 if (vma_region
!= NULL
)
2375 address
= vma_region
->get_current_address()->eval(symtab
, layout
,
2378 address
= *dot_value
;
2382 vma_region
= script_sections
->find_memory_region(this, true, true, NULL
);
2383 address
= this->address_
->eval_with_dot(symtab
, layout
, true,
2384 *dot_value
, NULL
, NULL
,
2385 dot_alignment
, false);
2386 if (vma_region
!= NULL
)
2387 vma_region
->set_address(address
, symtab
, layout
);
2391 if (this->align_
== NULL
)
2393 if (this->output_section_
== NULL
)
2396 align
= this->output_section_
->addralign();
2400 Output_section
* align_section
;
2401 align
= this->align_
->eval_with_dot(symtab
, layout
, true, *dot_value
,
2402 NULL
, &align_section
, NULL
, false);
2403 if (align_section
!= NULL
)
2404 gold_warning(_("alignment of section %s is not absolute"),
2405 this->name_
.c_str());
2406 if (this->output_section_
!= NULL
)
2407 this->output_section_
->set_addralign(align
);
2410 address
= align_address(address
, align
);
2412 uint64_t start_address
= address
;
2414 *dot_value
= address
;
2416 // Except for NOLOAD sections, the address of non-SHF_ALLOC sections is
2417 // forced to zero, regardless of what the linker script wants.
2418 if (this->output_section_
!= NULL
2419 && ((this->output_section_
->flags() & elfcpp::SHF_ALLOC
) != 0
2420 || this->output_section_
->is_noload()))
2421 this->output_section_
->set_address(address
);
2423 this->evaluated_address_
= address
;
2424 this->evaluated_addralign_
= align
;
2428 if (this->load_address_
== NULL
)
2430 Output_section_definition
* previous_section
;
2432 // Determine if an LMA region has been set for this section.
2433 lma_region
= script_sections
->find_memory_region(this, false, false,
2436 if (lma_region
!= NULL
)
2438 if (previous_section
== NULL
)
2439 // The LMA address was explicitly set to the given region.
2440 laddr
= lma_region
->get_current_address()->eval(symtab
, layout
,
2444 // We are not going to use the discovered lma_region, so
2445 // make sure that we do not update it in the code below.
2448 if (this->address_
!= NULL
|| previous_section
== this)
2450 // Either an explicit VMA address has been set, or an
2451 // explicit VMA region has been set, so set the LMA equal to
2457 // The LMA address was not explicitly or implicitly set.
2459 // We have been given the first memory region that is
2460 // compatible with the current section and a pointer to the
2461 // last section to use this region. Set the LMA of this
2462 // section so that the difference between its' VMA and LMA
2463 // is the same as the difference between the VMA and LMA of
2464 // the last section in the given region.
2465 laddr
= address
+ (previous_section
->evaluated_load_address_
2466 - previous_section
->evaluated_address_
);
2470 if (this->output_section_
!= NULL
)
2471 this->output_section_
->set_load_address(laddr
);
2475 // Do not set the load address of the output section, if one exists.
2476 // This allows future sections to determine what the load address
2477 // should be. If none is ever set, it will default to being the
2478 // same as the vma address.
2484 laddr
= this->load_address_
->eval_with_dot(symtab
, layout
, true,
2486 this->output_section_
,
2488 if (this->output_section_
!= NULL
)
2489 this->output_section_
->set_load_address(laddr
);
2492 this->evaluated_load_address_
= laddr
;
2495 if (this->subalign_
== NULL
)
2499 Output_section
* subalign_section
;
2500 subalign
= this->subalign_
->eval_with_dot(symtab
, layout
, true,
2502 &subalign_section
, NULL
,
2504 if (subalign_section
!= NULL
)
2505 gold_warning(_("subalign of section %s is not absolute"),
2506 this->name_
.c_str());
2510 if (this->fill_
!= NULL
)
2512 // FIXME: The GNU linker supports fill values of arbitrary
2514 Output_section
* fill_section
;
2515 uint64_t fill_val
= this->fill_
->eval_with_dot(symtab
, layout
, true,
2517 NULL
, &fill_section
,
2519 if (fill_section
!= NULL
)
2520 gold_warning(_("fill of section %s is not absolute"),
2521 this->name_
.c_str());
2522 unsigned char fill_buff
[4];
2523 elfcpp::Swap_unaligned
<32, true>::writeval(fill_buff
, fill_val
);
2524 fill
.assign(reinterpret_cast<char*>(fill_buff
), 4);
2527 Input_section_list input_sections
;
2528 if (this->output_section_
!= NULL
)
2530 // Get the list of input sections attached to this output
2531 // section. This will leave the output section with only
2532 // Output_section_data entries.
2533 address
+= this->output_section_
->get_input_sections(address
,
2536 *dot_value
= address
;
2539 Output_section
* dot_section
= this->output_section_
;
2540 for (Output_section_elements::iterator p
= this->elements_
.begin();
2541 p
!= this->elements_
.end();
2543 (*p
)->set_section_addresses(symtab
, layout
, this->output_section_
,
2544 subalign
, dot_value
, dot_alignment
,
2545 &dot_section
, &fill
, &input_sections
);
2547 gold_assert(input_sections
.empty());
2549 if (vma_region
!= NULL
)
2551 // Update the VMA region being used by the section now that we know how
2552 // big it is. Use the current address in the region, rather than
2553 // start_address because that might have been aligned upwards and we
2554 // need to allow for the padding.
2555 Expression
* addr
= vma_region
->get_current_address();
2556 uint64_t size
= *dot_value
- addr
->eval(symtab
, layout
, false);
2558 vma_region
->increment_offset(this->get_section_name(), size
,
2562 // If the LMA region is different from the VMA region, then increment the
2563 // offset there as well. Note that we use the same "dot_value -
2564 // start_address" formula that is used in the load_address assignment below.
2565 if (lma_region
!= NULL
&& lma_region
!= vma_region
)
2566 lma_region
->increment_offset(this->get_section_name(),
2567 *dot_value
- start_address
,
2570 // Compute the load address for the following section.
2571 if (this->output_section_
== NULL
)
2572 *load_address
= *dot_value
;
2573 else if (this->load_address_
== NULL
)
2575 if (lma_region
== NULL
)
2576 *load_address
= *dot_value
;
2579 lma_region
->get_current_address()->eval(symtab
, layout
, false);
2582 *load_address
= (this->output_section_
->load_address()
2583 + (*dot_value
- start_address
));
2585 if (this->output_section_
!= NULL
)
2587 if (this->is_relro_
)
2588 this->output_section_
->set_is_relro();
2590 this->output_section_
->clear_is_relro();
2592 // If this is a NOLOAD section, keep dot and load address unchanged.
2593 if (this->output_section_
->is_noload())
2595 *dot_value
= old_dot_value
;
2596 *load_address
= old_load_address
;
2601 // Check a constraint (ONLY_IF_RO, etc.) on an output section. If
2602 // this section is constrained, and the input sections do not match,
2603 // return the constraint, and set *POSD.
2606 Output_section_definition::check_constraint(Output_section_definition
** posd
)
2608 switch (this->constraint_
)
2610 case CONSTRAINT_NONE
:
2611 return CONSTRAINT_NONE
;
2613 case CONSTRAINT_ONLY_IF_RO
:
2614 if (this->output_section_
!= NULL
2615 && (this->output_section_
->flags() & elfcpp::SHF_WRITE
) != 0)
2618 return CONSTRAINT_ONLY_IF_RO
;
2620 return CONSTRAINT_NONE
;
2622 case CONSTRAINT_ONLY_IF_RW
:
2623 if (this->output_section_
!= NULL
2624 && (this->output_section_
->flags() & elfcpp::SHF_WRITE
) == 0)
2627 return CONSTRAINT_ONLY_IF_RW
;
2629 return CONSTRAINT_NONE
;
2631 case CONSTRAINT_SPECIAL
:
2632 if (this->output_section_
!= NULL
)
2633 gold_error(_("SPECIAL constraints are not implemented"));
2634 return CONSTRAINT_NONE
;
2641 // See if this is the alternate output section for a constrained
2642 // output section. If it is, transfer the Output_section and return
2643 // true. Otherwise return false.
2646 Output_section_definition::alternate_constraint(
2647 Output_section_definition
* posd
,
2648 Section_constraint constraint
)
2650 if (this->name_
!= posd
->name_
)
2655 case CONSTRAINT_ONLY_IF_RO
:
2656 if (this->constraint_
!= CONSTRAINT_ONLY_IF_RW
)
2660 case CONSTRAINT_ONLY_IF_RW
:
2661 if (this->constraint_
!= CONSTRAINT_ONLY_IF_RO
)
2669 // We have found the alternate constraint. We just need to move
2670 // over the Output_section. When constraints are used properly,
2671 // THIS should not have an output_section pointer, as all the input
2672 // sections should have matched the other definition.
2674 if (this->output_section_
!= NULL
)
2675 gold_error(_("mismatched definition for constrained sections"));
2677 this->output_section_
= posd
->output_section_
;
2678 posd
->output_section_
= NULL
;
2680 if (this->is_relro_
)
2681 this->output_section_
->set_is_relro();
2683 this->output_section_
->clear_is_relro();
2688 // Get the list of segments to use for an allocated section when using
2692 Output_section_definition::allocate_to_segment(String_list
** phdrs_list
,
2695 // Update phdrs_list even if we don't have an output section. It
2696 // might be used by the following sections.
2697 if (this->phdrs_
!= NULL
)
2698 *phdrs_list
= this->phdrs_
;
2700 if (this->output_section_
== NULL
)
2702 if ((this->output_section_
->flags() & elfcpp::SHF_ALLOC
) == 0)
2705 return this->output_section_
;
2708 // Look for an output section by name and return the address, the load
2709 // address, the alignment, and the size. This is used when an
2710 // expression refers to an output section which was not actually
2711 // created. This returns true if the section was found, false
2715 Output_section_definition::get_output_section_info(const char* name
,
2717 uint64_t* load_address
,
2718 uint64_t* addralign
,
2719 uint64_t* size
) const
2721 if (this->name_
!= name
)
2724 if (this->output_section_
!= NULL
)
2726 *address
= this->output_section_
->address();
2727 if (this->output_section_
->has_load_address())
2728 *load_address
= this->output_section_
->load_address();
2730 *load_address
= *address
;
2731 *addralign
= this->output_section_
->addralign();
2732 *size
= this->output_section_
->current_data_size();
2736 *address
= this->evaluated_address_
;
2737 *load_address
= this->evaluated_load_address_
;
2738 *addralign
= this->evaluated_addralign_
;
2745 // Print for debugging.
2748 Output_section_definition::print(FILE* f
) const
2750 fprintf(f
, " %s ", this->name_
.c_str());
2752 if (this->address_
!= NULL
)
2754 this->address_
->print(f
);
2758 if (this->script_section_type_
!= SCRIPT_SECTION_TYPE_NONE
)
2760 this->script_section_type_name(this->script_section_type_
));
2764 if (this->load_address_
!= NULL
)
2767 this->load_address_
->print(f
);
2771 if (this->align_
!= NULL
)
2773 fprintf(f
, "ALIGN(");
2774 this->align_
->print(f
);
2778 if (this->subalign_
!= NULL
)
2780 fprintf(f
, "SUBALIGN(");
2781 this->subalign_
->print(f
);
2787 for (Output_section_elements::const_iterator p
= this->elements_
.begin();
2788 p
!= this->elements_
.end();
2794 if (this->fill_
!= NULL
)
2797 this->fill_
->print(f
);
2800 if (this->phdrs_
!= NULL
)
2802 for (String_list::const_iterator p
= this->phdrs_
->begin();
2803 p
!= this->phdrs_
->end();
2805 fprintf(f
, " :%s", p
->c_str());
2811 Script_sections::Section_type
2812 Output_section_definition::section_type() const
2814 switch (this->script_section_type_
)
2816 case SCRIPT_SECTION_TYPE_NONE
:
2817 return Script_sections::ST_NONE
;
2818 case SCRIPT_SECTION_TYPE_NOLOAD
:
2819 return Script_sections::ST_NOLOAD
;
2820 case SCRIPT_SECTION_TYPE_COPY
:
2821 case SCRIPT_SECTION_TYPE_DSECT
:
2822 case SCRIPT_SECTION_TYPE_INFO
:
2823 case SCRIPT_SECTION_TYPE_OVERLAY
:
2824 // There are not really support so we treat them as ST_NONE. The
2825 // parse should have issued errors for them already.
2826 return Script_sections::ST_NONE
;
2832 // Return the name of a script section type.
2835 Output_section_definition::script_section_type_name(
2836 Script_section_type script_section_type
)
2838 switch (script_section_type
)
2840 case SCRIPT_SECTION_TYPE_NONE
:
2842 case SCRIPT_SECTION_TYPE_NOLOAD
:
2844 case SCRIPT_SECTION_TYPE_DSECT
:
2846 case SCRIPT_SECTION_TYPE_COPY
:
2848 case SCRIPT_SECTION_TYPE_INFO
:
2850 case SCRIPT_SECTION_TYPE_OVERLAY
:
2858 Output_section_definition::set_memory_region(Memory_region
* mr
, bool set_vma
)
2860 gold_assert(mr
!= NULL
);
2861 // Add the current section to the specified region's list.
2862 mr
->add_section(this, set_vma
);
2865 // An output section created to hold orphaned input sections. These
2866 // do not actually appear in linker scripts. However, for convenience
2867 // when setting the output section addresses, we put a marker to these
2868 // sections in the appropriate place in the list of SECTIONS elements.
2870 class Orphan_output_section
: public Sections_element
2873 Orphan_output_section(Output_section
* os
)
2877 // Return whether the orphan output section is relro. We can just
2878 // check the output section because we always set the flag, if
2879 // needed, just after we create the Orphan_output_section.
2882 { return this->os_
->is_relro(); }
2884 // Initialize OSP with an output section. This should have been
2887 orphan_section_init(Orphan_section_placement
*,
2888 Script_sections::Elements_iterator
)
2889 { gold_unreachable(); }
2891 // Set section addresses.
2893 set_section_addresses(Symbol_table
*, Layout
*, uint64_t*, uint64_t*,
2896 // Get the list of segments to use for an allocated section when
2897 // using a PHDRS clause.
2899 allocate_to_segment(String_list
**, bool*);
2901 // Return the associated Output_section.
2903 get_output_section() const
2904 { return this->os_
; }
2906 // Print for debugging.
2908 print(FILE* f
) const
2910 fprintf(f
, " marker for orphaned output section %s\n",
2915 Output_section
* os_
;
2918 // Set section addresses.
2921 Orphan_output_section::set_section_addresses(Symbol_table
*, Layout
*,
2922 uint64_t* dot_value
,
2924 uint64_t* load_address
)
2926 typedef std::list
<Output_section::Input_section
> Input_section_list
;
2928 bool have_load_address
= *load_address
!= *dot_value
;
2930 uint64_t address
= *dot_value
;
2931 address
= align_address(address
, this->os_
->addralign());
2933 // If input section sorting is requested via --section-ordering-file or
2934 // linker plugins, then do it here. This is important because we want
2935 // any sorting specified in the linker scripts, which will be done after
2936 // this, to take precedence. The final order of input sections is then
2937 // guaranteed to be according to the linker script specification.
2938 if (this->os_
!= NULL
2939 && this->os_
->input_section_order_specified())
2940 this->os_
->sort_attached_input_sections();
2942 // For a relocatable link, all orphan sections are put at
2943 // address 0. In general we expect all sections to be at
2944 // address 0 for a relocatable link, but we permit the linker
2945 // script to override that for specific output sections.
2946 if (parameters
->options().relocatable())
2950 have_load_address
= false;
2953 if ((this->os_
->flags() & elfcpp::SHF_ALLOC
) != 0)
2955 this->os_
->set_address(address
);
2956 if (have_load_address
)
2957 this->os_
->set_load_address(align_address(*load_address
,
2958 this->os_
->addralign()));
2961 Input_section_list input_sections
;
2962 address
+= this->os_
->get_input_sections(address
, "", &input_sections
);
2964 for (Input_section_list::iterator p
= input_sections
.begin();
2965 p
!= input_sections
.end();
2968 uint64_t addralign
= p
->addralign();
2969 if (!p
->is_input_section())
2970 p
->output_section_data()->finalize_data_size();
2971 uint64_t size
= p
->data_size();
2972 address
= align_address(address
, addralign
);
2973 this->os_
->add_script_input_section(*p
);
2977 if (parameters
->options().relocatable())
2979 // For a relocatable link, reset DOT_VALUE to 0.
2983 else if (this->os_
== NULL
2984 || (this->os_
->flags() & elfcpp::SHF_TLS
) == 0
2985 || this->os_
->type() != elfcpp::SHT_NOBITS
)
2987 // An SHF_TLS/SHT_NOBITS section does not take up any address space.
2988 if (!have_load_address
)
2989 *load_address
= address
;
2991 *load_address
+= address
- *dot_value
;
2993 *dot_value
= address
;
2997 // Get the list of segments to use for an allocated section when using
2998 // a PHDRS clause. If this is an allocated section, return the
2999 // Output_section. We don't change the list of segments.
3002 Orphan_output_section::allocate_to_segment(String_list
**, bool* orphan
)
3004 if ((this->os_
->flags() & elfcpp::SHF_ALLOC
) == 0)
3010 // Class Phdrs_element. A program header from a PHDRS clause.
3015 Phdrs_element(const char* name
, size_t namelen
, unsigned int type
,
3016 bool includes_filehdr
, bool includes_phdrs
,
3017 bool is_flags_valid
, unsigned int flags
,
3018 Expression
* load_address
)
3019 : name_(name
, namelen
), type_(type
), includes_filehdr_(includes_filehdr
),
3020 includes_phdrs_(includes_phdrs
), is_flags_valid_(is_flags_valid
),
3021 flags_(flags
), load_address_(load_address
), load_address_value_(0),
3025 // Return the name of this segment.
3028 { return this->name_
; }
3030 // Return the type of the segment.
3033 { return this->type_
; }
3035 // Whether to include the file header.
3037 includes_filehdr() const
3038 { return this->includes_filehdr_
; }
3040 // Whether to include the program headers.
3042 includes_phdrs() const
3043 { return this->includes_phdrs_
; }
3045 // Return whether there is a load address.
3047 has_load_address() const
3048 { return this->load_address_
!= NULL
; }
3050 // Evaluate the load address expression if there is one.
3052 eval_load_address(Symbol_table
* symtab
, Layout
* layout
)
3054 if (this->load_address_
!= NULL
)
3055 this->load_address_value_
= this->load_address_
->eval(symtab
, layout
,
3059 // Return the load address.
3061 load_address() const
3063 gold_assert(this->load_address_
!= NULL
);
3064 return this->load_address_value_
;
3067 // Create the segment.
3069 create_segment(Layout
* layout
)
3071 this->segment_
= layout
->make_output_segment(this->type_
, this->flags_
);
3072 return this->segment_
;
3075 // Return the segment.
3078 { return this->segment_
; }
3080 // Release the segment.
3083 { this->segment_
= NULL
; }
3085 // Set the segment flags if appropriate.
3087 set_flags_if_valid()
3089 if (this->is_flags_valid_
)
3090 this->segment_
->set_flags(this->flags_
);
3093 // Print for debugging.
3098 // The name used in the script.
3100 // The type of the segment (PT_LOAD, etc.).
3102 // Whether this segment includes the file header.
3103 bool includes_filehdr_
;
3104 // Whether this segment includes the section headers.
3105 bool includes_phdrs_
;
3106 // Whether the flags were explicitly specified.
3107 bool is_flags_valid_
;
3108 // The flags for this segment (PF_R, etc.) if specified.
3109 unsigned int flags_
;
3110 // The expression for the load address for this segment. This may
3112 Expression
* load_address_
;
3113 // The actual load address from evaluating the expression.
3114 uint64_t load_address_value_
;
3115 // The segment itself.
3116 Output_segment
* segment_
;
3119 // Print for debugging.
3122 Phdrs_element::print(FILE* f
) const
3124 fprintf(f
, " %s 0x%x", this->name_
.c_str(), this->type_
);
3125 if (this->includes_filehdr_
)
3126 fprintf(f
, " FILEHDR");
3127 if (this->includes_phdrs_
)
3128 fprintf(f
, " PHDRS");
3129 if (this->is_flags_valid_
)
3130 fprintf(f
, " FLAGS(%u)", this->flags_
);
3131 if (this->load_address_
!= NULL
)
3134 this->load_address_
->print(f
);
3140 // Add a memory region.
3143 Script_sections::add_memory_region(const char* name
, size_t namelen
,
3144 unsigned int attributes
,
3145 Expression
* start
, Expression
* length
)
3147 if (this->memory_regions_
== NULL
)
3148 this->memory_regions_
= new Memory_regions();
3149 else if (this->find_memory_region(name
, namelen
))
3151 gold_error(_("region '%.*s' already defined"), static_cast<int>(namelen
),
3153 // FIXME: Add a GOLD extension to allow multiple regions with the same
3154 // name. This would amount to a single region covering disjoint blocks
3155 // of memory, which is useful for embedded devices.
3158 // FIXME: Check the length and start values. Currently we allow
3159 // non-constant expressions for these values, whereas LD does not.
3161 // FIXME: Add a GOLD extension to allow NEGATIVE LENGTHS. This would
3162 // describe a region that packs from the end address going down, rather
3163 // than the start address going up. This would be useful for embedded
3166 this->memory_regions_
->push_back(new Memory_region(name
, namelen
, attributes
,
3170 // Find a memory region.
3173 Script_sections::find_memory_region(const char* name
, size_t namelen
)
3175 if (this->memory_regions_
== NULL
)
3178 for (Memory_regions::const_iterator m
= this->memory_regions_
->begin();
3179 m
!= this->memory_regions_
->end();
3181 if ((*m
)->name_match(name
, namelen
))
3187 // Find a memory region's origin.
3190 Script_sections::find_memory_region_origin(const char* name
, size_t namelen
)
3192 Memory_region
* mr
= find_memory_region(name
, namelen
);
3196 return mr
->start_address();
3199 // Find a memory region's length.
3202 Script_sections::find_memory_region_length(const char* name
, size_t namelen
)
3204 Memory_region
* mr
= find_memory_region(name
, namelen
);
3208 return mr
->length();
3211 // Set the memory region to use for the current section.
3214 Script_sections::set_memory_region(Memory_region
* mr
, bool set_vma
)
3216 gold_assert(!this->sections_elements_
->empty());
3217 this->sections_elements_
->back()->set_memory_region(mr
, set_vma
);
3220 // Class Script_sections.
3222 Script_sections::Script_sections()
3223 : saw_sections_clause_(false),
3224 in_sections_clause_(false),
3225 sections_elements_(NULL
),
3226 output_section_(NULL
),
3227 memory_regions_(NULL
),
3228 phdrs_elements_(NULL
),
3229 orphan_section_placement_(NULL
),
3230 data_segment_align_start_(),
3231 saw_data_segment_align_(false),
3232 saw_relro_end_(false),
3233 saw_segment_start_expression_(false),
3234 segments_created_(false)
3238 // Start a SECTIONS clause.
3241 Script_sections::start_sections()
3243 gold_assert(!this->in_sections_clause_
&& this->output_section_
== NULL
);
3244 this->saw_sections_clause_
= true;
3245 this->in_sections_clause_
= true;
3246 if (this->sections_elements_
== NULL
)
3247 this->sections_elements_
= new Sections_elements
;
3250 // Finish a SECTIONS clause.
3253 Script_sections::finish_sections()
3255 gold_assert(this->in_sections_clause_
&& this->output_section_
== NULL
);
3256 this->in_sections_clause_
= false;
3259 // Add a symbol to be defined.
3262 Script_sections::add_symbol_assignment(const char* name
, size_t length
,
3263 Expression
* val
, bool provide
,
3266 if (this->output_section_
!= NULL
)
3267 this->output_section_
->add_symbol_assignment(name
, length
, val
,
3271 Sections_element
* p
= new Sections_element_assignment(name
, length
,
3274 this->sections_elements_
->push_back(p
);
3278 // Add an assignment to the special dot symbol.
3281 Script_sections::add_dot_assignment(Expression
* val
)
3283 if (this->output_section_
!= NULL
)
3284 this->output_section_
->add_dot_assignment(val
);
3287 // The GNU linker permits assignments to . to appears outside of
3288 // a SECTIONS clause, and treats it as appearing inside, so
3289 // sections_elements_ may be NULL here.
3290 if (this->sections_elements_
== NULL
)
3292 this->sections_elements_
= new Sections_elements
;
3293 this->saw_sections_clause_
= true;
3296 Sections_element
* p
= new Sections_element_dot_assignment(val
);
3297 this->sections_elements_
->push_back(p
);
3301 // Add an assertion.
3304 Script_sections::add_assertion(Expression
* check
, const char* message
,
3307 if (this->output_section_
!= NULL
)
3308 this->output_section_
->add_assertion(check
, message
, messagelen
);
3311 Sections_element
* p
= new Sections_element_assertion(check
, message
,
3313 this->sections_elements_
->push_back(p
);
3317 // Start processing entries for an output section.
3320 Script_sections::start_output_section(
3323 const Parser_output_section_header
* header
)
3325 Output_section_definition
* posd
= new Output_section_definition(name
,
3328 this->sections_elements_
->push_back(posd
);
3329 gold_assert(this->output_section_
== NULL
);
3330 this->output_section_
= posd
;
3333 // Stop processing entries for an output section.
3336 Script_sections::finish_output_section(
3337 const Parser_output_section_trailer
* trailer
)
3339 gold_assert(this->output_section_
!= NULL
);
3340 this->output_section_
->finish(trailer
);
3341 this->output_section_
= NULL
;
3344 // Add a data item to the current output section.
3347 Script_sections::add_data(int size
, bool is_signed
, Expression
* val
)
3349 gold_assert(this->output_section_
!= NULL
);
3350 this->output_section_
->add_data(size
, is_signed
, val
);
3353 // Add a fill value setting to the current output section.
3356 Script_sections::add_fill(Expression
* val
)
3358 gold_assert(this->output_section_
!= NULL
);
3359 this->output_section_
->add_fill(val
);
3362 // Add an input section specification to the current output section.
3365 Script_sections::add_input_section(const Input_section_spec
* spec
, bool keep
)
3367 gold_assert(this->output_section_
!= NULL
);
3368 this->output_section_
->add_input_section(spec
, keep
);
3371 // This is called when we see DATA_SEGMENT_ALIGN. It means that any
3372 // subsequent output sections may be relro.
3375 Script_sections::data_segment_align()
3377 if (this->saw_data_segment_align_
)
3378 gold_error(_("DATA_SEGMENT_ALIGN may only appear once in a linker script"));
3379 gold_assert(!this->sections_elements_
->empty());
3380 Sections_elements::iterator p
= this->sections_elements_
->end();
3382 this->data_segment_align_start_
= p
;
3383 this->saw_data_segment_align_
= true;
3386 // This is called when we see DATA_SEGMENT_RELRO_END. It means that
3387 // any output sections seen since DATA_SEGMENT_ALIGN are relro.
3390 Script_sections::data_segment_relro_end()
3392 if (this->saw_relro_end_
)
3393 gold_error(_("DATA_SEGMENT_RELRO_END may only appear once "
3394 "in a linker script"));
3395 this->saw_relro_end_
= true;
3397 if (!this->saw_data_segment_align_
)
3398 gold_error(_("DATA_SEGMENT_RELRO_END must follow DATA_SEGMENT_ALIGN"));
3401 Sections_elements::iterator p
= this->data_segment_align_start_
;
3402 for (++p
; p
!= this->sections_elements_
->end(); ++p
)
3403 (*p
)->set_is_relro();
3407 // Create any required sections.
3410 Script_sections::create_sections(Layout
* layout
)
3412 if (!this->saw_sections_clause_
)
3414 for (Sections_elements::iterator p
= this->sections_elements_
->begin();
3415 p
!= this->sections_elements_
->end();
3417 (*p
)->create_sections(layout
);
3420 // Add any symbols we are defining to the symbol table.
3423 Script_sections::add_symbols_to_table(Symbol_table
* symtab
)
3425 if (!this->saw_sections_clause_
)
3427 for (Sections_elements::iterator p
= this->sections_elements_
->begin();
3428 p
!= this->sections_elements_
->end();
3430 (*p
)->add_symbols_to_table(symtab
);
3433 // Finalize symbols and check assertions.
3436 Script_sections::finalize_symbols(Symbol_table
* symtab
, const Layout
* layout
)
3438 if (!this->saw_sections_clause_
)
3440 uint64_t dot_value
= 0;
3441 for (Sections_elements::iterator p
= this->sections_elements_
->begin();
3442 p
!= this->sections_elements_
->end();
3444 (*p
)->finalize_symbols(symtab
, layout
, &dot_value
);
3447 // Return the name of the output section to use for an input file name
3448 // and section name.
3451 Script_sections::output_section_name(
3452 const char* file_name
,
3453 const char* section_name
,
3454 Output_section
*** output_section_slot
,
3455 Script_sections::Section_type
* psection_type
,
3458 for (Sections_elements::const_iterator p
= this->sections_elements_
->begin();
3459 p
!= this->sections_elements_
->end();
3462 const char* ret
= (*p
)->output_section_name(file_name
, section_name
,
3463 output_section_slot
,
3464 psection_type
, keep
);
3468 // The special name /DISCARD/ means that the input section
3469 // should be discarded.
3470 if (strcmp(ret
, "/DISCARD/") == 0)
3472 *output_section_slot
= NULL
;
3473 *psection_type
= Script_sections::ST_NONE
;
3480 // If we couldn't find a mapping for the name, the output section
3481 // gets the name of the input section.
3483 *output_section_slot
= NULL
;
3484 *psection_type
= Script_sections::ST_NONE
;
3486 return section_name
;
3489 // Place a marker for an orphan output section into the SECTIONS
3493 Script_sections::place_orphan(Output_section
* os
)
3495 Orphan_section_placement
* osp
= this->orphan_section_placement_
;
3498 // Initialize the Orphan_section_placement structure.
3499 osp
= new Orphan_section_placement();
3500 for (Sections_elements::iterator p
= this->sections_elements_
->begin();
3501 p
!= this->sections_elements_
->end();
3503 (*p
)->orphan_section_init(osp
, p
);
3504 gold_assert(!this->sections_elements_
->empty());
3505 Sections_elements::iterator last
= this->sections_elements_
->end();
3507 osp
->last_init(last
);
3508 this->orphan_section_placement_
= osp
;
3511 Orphan_output_section
* orphan
= new Orphan_output_section(os
);
3513 // Look for where to put ORPHAN.
3514 Sections_elements::iterator
* where
;
3515 if (osp
->find_place(os
, &where
))
3517 if ((**where
)->is_relro())
3520 os
->clear_is_relro();
3522 // We want to insert ORPHAN after *WHERE, and then update *WHERE
3523 // so that the next one goes after this one.
3524 Sections_elements::iterator p
= *where
;
3525 gold_assert(p
!= this->sections_elements_
->end());
3527 *where
= this->sections_elements_
->insert(p
, orphan
);
3531 os
->clear_is_relro();
3532 // We don't have a place to put this orphan section. Put it,
3533 // and all other sections like it, at the end, but before the
3534 // sections which always come at the end.
3535 Sections_elements::iterator last
= osp
->last_place();
3536 *where
= this->sections_elements_
->insert(last
, orphan
);
3540 // Set the addresses of all the output sections. Walk through all the
3541 // elements, tracking the dot symbol. Apply assignments which set
3542 // absolute symbol values, in case they are used when setting dot.
3543 // Fill in data statement values. As we find output sections, set the
3544 // address, set the address of all associated input sections, and
3545 // update dot. Return the segment which should hold the file header
3546 // and segment headers, if any.
3549 Script_sections::set_section_addresses(Symbol_table
* symtab
, Layout
* layout
)
3551 gold_assert(this->saw_sections_clause_
);
3553 // Implement ONLY_IF_RO/ONLY_IF_RW constraints. These are a pain
3554 // for our representation.
3555 for (Sections_elements::iterator p
= this->sections_elements_
->begin();
3556 p
!= this->sections_elements_
->end();
3559 Output_section_definition
* posd
;
3560 Section_constraint failed_constraint
= (*p
)->check_constraint(&posd
);
3561 if (failed_constraint
!= CONSTRAINT_NONE
)
3563 Sections_elements::iterator q
;
3564 for (q
= this->sections_elements_
->begin();
3565 q
!= this->sections_elements_
->end();
3570 if ((*q
)->alternate_constraint(posd
, failed_constraint
))
3575 if (q
== this->sections_elements_
->end())
3576 gold_error(_("no matching section constraint"));
3580 // Force the alignment of the first TLS section to be the maximum
3581 // alignment of all TLS sections.
3582 Output_section
* first_tls
= NULL
;
3583 uint64_t tls_align
= 0;
3584 for (Sections_elements::const_iterator p
= this->sections_elements_
->begin();
3585 p
!= this->sections_elements_
->end();
3588 Output_section
* os
= (*p
)->get_output_section();
3589 if (os
!= NULL
&& (os
->flags() & elfcpp::SHF_TLS
) != 0)
3591 if (first_tls
== NULL
)
3593 if (os
->addralign() > tls_align
)
3594 tls_align
= os
->addralign();
3597 if (first_tls
!= NULL
)
3598 first_tls
->set_addralign(tls_align
);
3600 // For a relocatable link, we implicitly set dot to zero.
3601 uint64_t dot_value
= 0;
3602 uint64_t dot_alignment
= 0;
3603 uint64_t load_address
= 0;
3605 // Check to see if we want to use any of -Ttext, -Tdata and -Tbss options
3606 // to set section addresses. If the script has any SEGMENT_START
3607 // expression, we do not set the section addresses.
3608 bool use_tsection_options
=
3609 (!this->saw_segment_start_expression_
3610 && (parameters
->options().user_set_Ttext()
3611 || parameters
->options().user_set_Tdata()
3612 || parameters
->options().user_set_Tbss()));
3614 for (Sections_elements::iterator p
= this->sections_elements_
->begin();
3615 p
!= this->sections_elements_
->end();
3618 Output_section
* os
= (*p
)->get_output_section();
3620 // Handle -Ttext, -Tdata and -Tbss options. We do this by looking for
3621 // the special sections by names and doing dot assignments.
3622 if (use_tsection_options
3624 && (os
->flags() & elfcpp::SHF_ALLOC
) != 0)
3626 uint64_t new_dot_value
= dot_value
;
3628 if (parameters
->options().user_set_Ttext()
3629 && strcmp(os
->name(), ".text") == 0)
3630 new_dot_value
= parameters
->options().Ttext();
3631 else if (parameters
->options().user_set_Tdata()
3632 && strcmp(os
->name(), ".data") == 0)
3633 new_dot_value
= parameters
->options().Tdata();
3634 else if (parameters
->options().user_set_Tbss()
3635 && strcmp(os
->name(), ".bss") == 0)
3636 new_dot_value
= parameters
->options().Tbss();
3638 // Update dot and load address if necessary.
3639 if (new_dot_value
< dot_value
)
3640 gold_error(_("dot may not move backward"));
3641 else if (new_dot_value
!= dot_value
)
3643 dot_value
= new_dot_value
;
3644 load_address
= new_dot_value
;
3648 (*p
)->set_section_addresses(symtab
, layout
, &dot_value
, &dot_alignment
,
3652 if (this->phdrs_elements_
!= NULL
)
3654 for (Phdrs_elements::iterator p
= this->phdrs_elements_
->begin();
3655 p
!= this->phdrs_elements_
->end();
3657 (*p
)->eval_load_address(symtab
, layout
);
3660 return this->create_segments(layout
, dot_alignment
);
3663 // Sort the sections in order to put them into segments.
3665 class Sort_output_sections
3668 Sort_output_sections(const Script_sections::Sections_elements
* elements
)
3669 : elements_(elements
)
3673 operator()(const Output_section
* os1
, const Output_section
* os2
) const;
3677 script_compare(const Output_section
* os1
, const Output_section
* os2
) const;
3680 const Script_sections::Sections_elements
* elements_
;
3684 Sort_output_sections::operator()(const Output_section
* os1
,
3685 const Output_section
* os2
) const
3687 // Sort first by the load address.
3688 uint64_t lma1
= (os1
->has_load_address()
3689 ? os1
->load_address()
3691 uint64_t lma2
= (os2
->has_load_address()
3692 ? os2
->load_address()
3697 // Then sort by the virtual address.
3698 if (os1
->address() != os2
->address())
3699 return os1
->address() < os2
->address();
3701 // If the linker script says which of these sections is first, go
3702 // with what it says.
3703 int i
= this->script_compare(os1
, os2
);
3707 // Sort PROGBITS before NOBITS.
3708 bool nobits1
= os1
->type() == elfcpp::SHT_NOBITS
;
3709 bool nobits2
= os2
->type() == elfcpp::SHT_NOBITS
;
3710 if (nobits1
!= nobits2
)
3713 // Sort PROGBITS TLS sections to the end, NOBITS TLS sections to the
3715 bool tls1
= (os1
->flags() & elfcpp::SHF_TLS
) != 0;
3716 bool tls2
= (os2
->flags() & elfcpp::SHF_TLS
) != 0;
3718 return nobits1
? tls1
: tls2
;
3720 // Sort non-NOLOAD before NOLOAD.
3721 if (os1
->is_noload() && !os2
->is_noload())
3723 if (!os1
->is_noload() && os2
->is_noload())
3726 // The sections seem practically identical. Sort by name to get a
3728 return os1
->name() < os2
->name();
3731 // Return -1 if OS1 comes before OS2 in ELEMENTS_, 1 if comes after, 0
3732 // if either OS1 or OS2 is not mentioned. This ensures that we keep
3733 // empty sections in the order in which they appear in a linker
3737 Sort_output_sections::script_compare(const Output_section
* os1
,
3738 const Output_section
* os2
) const
3740 if (this->elements_
== NULL
)
3743 bool found_os1
= false;
3744 bool found_os2
= false;
3745 for (Script_sections::Sections_elements::const_iterator
3746 p
= this->elements_
->begin();
3747 p
!= this->elements_
->end();
3750 if (os2
== (*p
)->get_output_section())
3756 else if (os1
== (*p
)->get_output_section())
3767 // Return whether OS is a BSS section. This is a SHT_NOBITS section.
3768 // We treat a section with the SHF_TLS flag set as taking up space
3769 // even if it is SHT_NOBITS (this is true of .tbss), as we allocate
3770 // space for them in the file.
3773 Script_sections::is_bss_section(const Output_section
* os
)
3775 return (os
->type() == elfcpp::SHT_NOBITS
3776 && (os
->flags() & elfcpp::SHF_TLS
) == 0);
3779 // Return the size taken by the file header and the program headers.
3782 Script_sections::total_header_size(Layout
* layout
) const
3784 size_t segment_count
= layout
->segment_count();
3785 size_t file_header_size
;
3786 size_t segment_headers_size
;
3787 if (parameters
->target().get_size() == 32)
3789 file_header_size
= elfcpp::Elf_sizes
<32>::ehdr_size
;
3790 segment_headers_size
= segment_count
* elfcpp::Elf_sizes
<32>::phdr_size
;
3792 else if (parameters
->target().get_size() == 64)
3794 file_header_size
= elfcpp::Elf_sizes
<64>::ehdr_size
;
3795 segment_headers_size
= segment_count
* elfcpp::Elf_sizes
<64>::phdr_size
;
3800 return file_header_size
+ segment_headers_size
;
3803 // Return the amount we have to subtract from the LMA to accommodate
3804 // headers of the given size. The complication is that the file
3805 // header have to be at the start of a page, as otherwise it will not
3806 // be at the start of the file.
3809 Script_sections::header_size_adjustment(uint64_t lma
,
3810 size_t sizeof_headers
) const
3812 const uint64_t abi_pagesize
= parameters
->target().abi_pagesize();
3813 uint64_t hdr_lma
= lma
- sizeof_headers
;
3814 hdr_lma
&= ~(abi_pagesize
- 1);
3815 return lma
- hdr_lma
;
3818 // Create the PT_LOAD segments when using a SECTIONS clause. Returns
3819 // the segment which should hold the file header and segment headers,
3823 Script_sections::create_segments(Layout
* layout
, uint64_t dot_alignment
)
3825 gold_assert(this->saw_sections_clause_
);
3827 if (parameters
->options().relocatable())
3830 if (this->saw_phdrs_clause())
3831 return create_segments_from_phdrs_clause(layout
, dot_alignment
);
3833 Layout::Section_list sections
;
3834 layout
->get_allocated_sections(§ions
);
3836 // Sort the sections by address.
3837 std::stable_sort(sections
.begin(), sections
.end(),
3838 Sort_output_sections(this->sections_elements_
));
3840 this->create_note_and_tls_segments(layout
, §ions
);
3842 // Walk through the sections adding them to PT_LOAD segments.
3843 const uint64_t abi_pagesize
= parameters
->target().abi_pagesize();
3844 Output_segment
* first_seg
= NULL
;
3845 Output_segment
* current_seg
= NULL
;
3846 bool is_current_seg_readonly
= true;
3847 Layout::Section_list::iterator plast
= sections
.end();
3848 uint64_t last_vma
= 0;
3849 uint64_t last_lma
= 0;
3850 uint64_t last_size
= 0;
3851 for (Layout::Section_list::iterator p
= sections
.begin();
3852 p
!= sections
.end();
3855 const uint64_t vma
= (*p
)->address();
3856 const uint64_t lma
= ((*p
)->has_load_address()
3857 ? (*p
)->load_address()
3859 const uint64_t size
= (*p
)->current_data_size();
3861 bool need_new_segment
;
3862 if (current_seg
== NULL
)
3863 need_new_segment
= true;
3864 else if (lma
- vma
!= last_lma
- last_vma
)
3866 // This section has a different LMA relationship than the
3867 // last one; we need a new segment.
3868 need_new_segment
= true;
3870 else if (align_address(last_lma
+ last_size
, abi_pagesize
)
3871 < align_address(lma
, abi_pagesize
))
3873 // Putting this section in the segment would require
3875 need_new_segment
= true;
3877 else if (is_bss_section(*plast
) && !is_bss_section(*p
))
3879 // A non-BSS section can not follow a BSS section in the
3881 need_new_segment
= true;
3883 else if (is_current_seg_readonly
3884 && ((*p
)->flags() & elfcpp::SHF_WRITE
) != 0
3885 && !parameters
->options().omagic())
3887 // Don't put a writable section in the same segment as a
3888 // non-writable section.
3889 need_new_segment
= true;
3893 // Otherwise, reuse the existing segment.
3894 need_new_segment
= false;
3897 elfcpp::Elf_Word seg_flags
=
3898 Layout::section_flags_to_segment((*p
)->flags());
3900 if (need_new_segment
)
3902 current_seg
= layout
->make_output_segment(elfcpp::PT_LOAD
,
3904 current_seg
->set_addresses(vma
, lma
);
3905 current_seg
->set_minimum_p_align(dot_alignment
);
3906 if (first_seg
== NULL
)
3907 first_seg
= current_seg
;
3908 is_current_seg_readonly
= true;
3911 current_seg
->add_output_section_to_load(layout
, *p
, seg_flags
);
3913 if (((*p
)->flags() & elfcpp::SHF_WRITE
) != 0)
3914 is_current_seg_readonly
= false;
3922 // An ELF program should work even if the program headers are not in
3923 // a PT_LOAD segment. However, it appears that the Linux kernel
3924 // does not set the AT_PHDR auxiliary entry in that case. It sets
3925 // the load address to p_vaddr - p_offset of the first PT_LOAD
3926 // segment. It then sets AT_PHDR to the load address plus the
3927 // offset to the program headers, e_phoff in the file header. This
3928 // fails when the program headers appear in the file before the
3929 // first PT_LOAD segment. Therefore, we always create a PT_LOAD
3930 // segment to hold the file header and the program headers. This is
3931 // effectively what the GNU linker does, and it is slightly more
3932 // efficient in any case. We try to use the first PT_LOAD segment
3933 // if we can, otherwise we make a new one.
3935 if (first_seg
== NULL
)
3938 // -n or -N mean that the program is not demand paged and there is
3939 // no need to put the program headers in a PT_LOAD segment.
3940 if (parameters
->options().nmagic() || parameters
->options().omagic())
3943 size_t sizeof_headers
= this->total_header_size(layout
);
3945 uint64_t vma
= first_seg
->vaddr();
3946 uint64_t lma
= first_seg
->paddr();
3948 uint64_t subtract
= this->header_size_adjustment(lma
, sizeof_headers
);
3950 if ((lma
& (abi_pagesize
- 1)) >= sizeof_headers
)
3952 first_seg
->set_addresses(vma
- subtract
, lma
- subtract
);
3956 // If there is no room to squeeze in the headers, then punt. The
3957 // resulting executable probably won't run on GNU/Linux, but we
3958 // trust that the user knows what they are doing.
3959 if (lma
< subtract
|| vma
< subtract
)
3962 // If memory regions have been specified and the address range
3963 // we are about to use is not contained within any region then
3964 // issue a warning message about the segment we are going to
3965 // create. It will be outside of any region and so possibly
3966 // using non-existent or protected memory. We test LMA rather
3967 // than VMA since we assume that the headers will never be
3969 if (this->memory_regions_
!= NULL
3970 && !this->block_in_region (NULL
, layout
, lma
- subtract
, subtract
))
3971 gold_warning(_("creating a segment to contain the file and program"
3972 " headers outside of any MEMORY region"));
3974 Output_segment
* load_seg
= layout
->make_output_segment(elfcpp::PT_LOAD
,
3976 load_seg
->set_addresses(vma
- subtract
, lma
- subtract
);
3981 // Create a PT_NOTE segment for each SHT_NOTE section and a PT_TLS
3982 // segment if there are any SHT_TLS sections.
3985 Script_sections::create_note_and_tls_segments(
3987 const Layout::Section_list
* sections
)
3989 gold_assert(!this->saw_phdrs_clause());
3991 bool saw_tls
= false;
3992 for (Layout::Section_list::const_iterator p
= sections
->begin();
3993 p
!= sections
->end();
3996 if ((*p
)->type() == elfcpp::SHT_NOTE
)
3998 elfcpp::Elf_Word seg_flags
=
3999 Layout::section_flags_to_segment((*p
)->flags());
4000 Output_segment
* oseg
= layout
->make_output_segment(elfcpp::PT_NOTE
,
4002 oseg
->add_output_section_to_nonload(*p
, seg_flags
);
4004 // Incorporate any subsequent SHT_NOTE sections, in the
4005 // hopes that the script is sensible.
4006 Layout::Section_list::const_iterator pnext
= p
+ 1;
4007 while (pnext
!= sections
->end()
4008 && (*pnext
)->type() == elfcpp::SHT_NOTE
)
4010 seg_flags
= Layout::section_flags_to_segment((*pnext
)->flags());
4011 oseg
->add_output_section_to_nonload(*pnext
, seg_flags
);
4017 if (((*p
)->flags() & elfcpp::SHF_TLS
) != 0)
4020 gold_error(_("TLS sections are not adjacent"));
4022 elfcpp::Elf_Word seg_flags
=
4023 Layout::section_flags_to_segment((*p
)->flags());
4024 Output_segment
* oseg
= layout
->make_output_segment(elfcpp::PT_TLS
,
4026 oseg
->add_output_section_to_nonload(*p
, seg_flags
);
4028 Layout::Section_list::const_iterator pnext
= p
+ 1;
4029 while (pnext
!= sections
->end()
4030 && ((*pnext
)->flags() & elfcpp::SHF_TLS
) != 0)
4032 seg_flags
= Layout::section_flags_to_segment((*pnext
)->flags());
4033 oseg
->add_output_section_to_nonload(*pnext
, seg_flags
);
4041 // If we see a section named .interp then put the .interp section
4042 // in a PT_INTERP segment.
4043 // This is for GNU ld compatibility.
4044 if (strcmp((*p
)->name(), ".interp") == 0)
4046 elfcpp::Elf_Word seg_flags
=
4047 Layout::section_flags_to_segment((*p
)->flags());
4048 Output_segment
* oseg
= layout
->make_output_segment(elfcpp::PT_INTERP
,
4050 oseg
->add_output_section_to_nonload(*p
, seg_flags
);
4054 this->segments_created_
= true;
4057 // Add a program header. The PHDRS clause is syntactically distinct
4058 // from the SECTIONS clause, but we implement it with the SECTIONS
4059 // support because PHDRS is useless if there is no SECTIONS clause.
4062 Script_sections::add_phdr(const char* name
, size_t namelen
, unsigned int type
,
4063 bool includes_filehdr
, bool includes_phdrs
,
4064 bool is_flags_valid
, unsigned int flags
,
4065 Expression
* load_address
)
4067 if (this->phdrs_elements_
== NULL
)
4068 this->phdrs_elements_
= new Phdrs_elements();
4069 this->phdrs_elements_
->push_back(new Phdrs_element(name
, namelen
, type
,
4072 is_flags_valid
, flags
,
4076 // Return the number of segments we expect to create based on the
4077 // SECTIONS clause. This is used to implement SIZEOF_HEADERS.
4080 Script_sections::expected_segment_count(const Layout
* layout
) const
4082 // If we've already created the segments, we won't be adding any more.
4083 if (this->segments_created_
)
4086 if (this->saw_phdrs_clause())
4087 return this->phdrs_elements_
->size();
4089 Layout::Section_list sections
;
4090 layout
->get_allocated_sections(§ions
);
4092 // We assume that we will need two PT_LOAD segments.
4095 bool saw_note
= false;
4096 bool saw_tls
= false;
4097 bool saw_interp
= false;
4098 for (Layout::Section_list::const_iterator p
= sections
.begin();
4099 p
!= sections
.end();
4102 if ((*p
)->type() == elfcpp::SHT_NOTE
)
4104 // Assume that all note sections will fit into a single
4112 else if (((*p
)->flags() & elfcpp::SHF_TLS
) != 0)
4114 // There can only be one PT_TLS segment.
4121 else if (strcmp((*p
)->name(), ".interp") == 0)
4123 // There can only be one PT_INTERP segment.
4135 // Create the segments from a PHDRS clause. Return the segment which
4136 // should hold the file header and program headers, if any.
4139 Script_sections::create_segments_from_phdrs_clause(Layout
* layout
,
4140 uint64_t dot_alignment
)
4142 this->attach_sections_using_phdrs_clause(layout
);
4143 return this->set_phdrs_clause_addresses(layout
, dot_alignment
);
4146 // Create the segments from the PHDRS clause, and put the output
4147 // sections in them.
4150 Script_sections::attach_sections_using_phdrs_clause(Layout
* layout
)
4152 typedef std::map
<std::string
, Output_segment
*> Name_to_segment
;
4153 Name_to_segment name_to_segment
;
4154 for (Phdrs_elements::const_iterator p
= this->phdrs_elements_
->begin();
4155 p
!= this->phdrs_elements_
->end();
4157 name_to_segment
[(*p
)->name()] = (*p
)->create_segment(layout
);
4158 this->segments_created_
= true;
4160 // Walk through the output sections and attach them to segments.
4161 // Output sections in the script which do not list segments are
4162 // attached to the same set of segments as the immediately preceding
4165 String_list
* phdr_names
= NULL
;
4166 bool load_segments_only
= false;
4167 for (Sections_elements::const_iterator p
= this->sections_elements_
->begin();
4168 p
!= this->sections_elements_
->end();
4172 String_list
* old_phdr_names
= phdr_names
;
4173 Output_section
* os
= (*p
)->allocate_to_segment(&phdr_names
, &is_orphan
);
4177 elfcpp::Elf_Word seg_flags
=
4178 Layout::section_flags_to_segment(os
->flags());
4180 if (phdr_names
== NULL
)
4182 // Don't worry about empty orphan sections.
4183 if (is_orphan
&& os
->current_data_size() > 0)
4184 gold_error(_("allocated section %s not in any segment"),
4187 // To avoid later crashes drop this section into the first
4189 for (Phdrs_elements::const_iterator ppe
=
4190 this->phdrs_elements_
->begin();
4191 ppe
!= this->phdrs_elements_
->end();
4194 Output_segment
* oseg
= (*ppe
)->segment();
4195 if (oseg
->type() == elfcpp::PT_LOAD
)
4197 oseg
->add_output_section_to_load(layout
, os
, seg_flags
);
4205 // We see a list of segments names. Disable PT_LOAD segment only
4207 if (old_phdr_names
!= phdr_names
)
4208 load_segments_only
= false;
4210 // If this is an orphan section--one that was not explicitly
4211 // mentioned in the linker script--then it should not inherit
4212 // any segment type other than PT_LOAD. Otherwise, e.g., the
4213 // PT_INTERP segment will pick up following orphan sections,
4214 // which does not make sense. If this is not an orphan section,
4215 // we trust the linker script.
4218 // Enable PT_LOAD segments only filtering until we see another
4219 // list of segment names.
4220 load_segments_only
= true;
4223 bool in_load_segment
= false;
4224 for (String_list::const_iterator q
= phdr_names
->begin();
4225 q
!= phdr_names
->end();
4228 Name_to_segment::const_iterator r
= name_to_segment
.find(*q
);
4229 if (r
== name_to_segment
.end())
4230 gold_error(_("no segment %s"), q
->c_str());
4233 if (load_segments_only
4234 && r
->second
->type() != elfcpp::PT_LOAD
)
4237 if (r
->second
->type() != elfcpp::PT_LOAD
)
4238 r
->second
->add_output_section_to_nonload(os
, seg_flags
);
4241 r
->second
->add_output_section_to_load(layout
, os
, seg_flags
);
4242 if (in_load_segment
)
4243 gold_error(_("section in two PT_LOAD segments"));
4244 in_load_segment
= true;
4249 if (!in_load_segment
)
4250 gold_error(_("allocated section not in any PT_LOAD segment"));
4254 // Set the addresses for segments created from a PHDRS clause. Return
4255 // the segment which should hold the file header and program headers,
4259 Script_sections::set_phdrs_clause_addresses(Layout
* layout
,
4260 uint64_t dot_alignment
)
4262 Output_segment
* load_seg
= NULL
;
4263 for (Phdrs_elements::const_iterator p
= this->phdrs_elements_
->begin();
4264 p
!= this->phdrs_elements_
->end();
4267 // Note that we have to set the flags after adding the output
4268 // sections to the segment, as adding an output segment can
4269 // change the flags.
4270 (*p
)->set_flags_if_valid();
4272 Output_segment
* oseg
= (*p
)->segment();
4274 if (oseg
->type() != elfcpp::PT_LOAD
)
4276 // The addresses of non-PT_LOAD segments are set from the
4277 // PT_LOAD segments.
4278 if ((*p
)->has_load_address())
4279 gold_error(_("may only specify load address for PT_LOAD segment"));
4283 oseg
->set_minimum_p_align(dot_alignment
);
4285 // The output sections should have addresses from the SECTIONS
4286 // clause. The addresses don't have to be in order, so find the
4287 // one with the lowest load address. Use that to set the
4288 // address of the segment.
4290 Output_section
* osec
= oseg
->section_with_lowest_load_address();
4293 oseg
->set_addresses(0, 0);
4297 uint64_t vma
= osec
->address();
4298 uint64_t lma
= osec
->has_load_address() ? osec
->load_address() : vma
;
4300 // Override the load address of the section with the load
4301 // address specified for the segment.
4302 if ((*p
)->has_load_address())
4304 if (osec
->has_load_address())
4305 gold_warning(_("PHDRS load address overrides "
4306 "section %s load address"),
4309 lma
= (*p
)->load_address();
4312 bool headers
= (*p
)->includes_filehdr() && (*p
)->includes_phdrs();
4313 if (!headers
&& ((*p
)->includes_filehdr() || (*p
)->includes_phdrs()))
4315 // We could support this if we wanted to.
4316 gold_error(_("using only one of FILEHDR and PHDRS is "
4317 "not currently supported"));
4321 size_t sizeof_headers
= this->total_header_size(layout
);
4322 uint64_t subtract
= this->header_size_adjustment(lma
,
4324 if (lma
>= subtract
&& vma
>= subtract
)
4331 gold_error(_("sections loaded on first page without room "
4332 "for file and program headers "
4333 "are not supported"));
4336 if (load_seg
!= NULL
)
4337 gold_error(_("using FILEHDR and PHDRS on more than one "
4338 "PT_LOAD segment is not currently supported"));
4342 oseg
->set_addresses(vma
, lma
);
4348 // Add the file header and segment headers to non-load segments
4349 // specified in the PHDRS clause.
4352 Script_sections::put_headers_in_phdrs(Output_data
* file_header
,
4353 Output_data
* segment_headers
)
4355 gold_assert(this->saw_phdrs_clause());
4356 for (Phdrs_elements::iterator p
= this->phdrs_elements_
->begin();
4357 p
!= this->phdrs_elements_
->end();
4360 if ((*p
)->type() != elfcpp::PT_LOAD
)
4362 if ((*p
)->includes_phdrs())
4363 (*p
)->segment()->add_initial_output_data(segment_headers
);
4364 if ((*p
)->includes_filehdr())
4365 (*p
)->segment()->add_initial_output_data(file_header
);
4370 // Look for an output section by name and return the address, the load
4371 // address, the alignment, and the size. This is used when an
4372 // expression refers to an output section which was not actually
4373 // created. This returns true if the section was found, false
4377 Script_sections::get_output_section_info(const char* name
, uint64_t* address
,
4378 uint64_t* load_address
,
4379 uint64_t* addralign
,
4380 uint64_t* size
) const
4382 if (!this->saw_sections_clause_
)
4384 for (Sections_elements::const_iterator p
= this->sections_elements_
->begin();
4385 p
!= this->sections_elements_
->end();
4387 if ((*p
)->get_output_section_info(name
, address
, load_address
, addralign
,
4393 // Release all Output_segments. This remove all pointers to all
4397 Script_sections::release_segments()
4399 if (this->saw_phdrs_clause())
4401 for (Phdrs_elements::const_iterator p
= this->phdrs_elements_
->begin();
4402 p
!= this->phdrs_elements_
->end();
4404 (*p
)->release_segment();
4408 // Print the SECTIONS clause to F for debugging.
4411 Script_sections::print(FILE* f
) const
4413 if (this->phdrs_elements_
!= NULL
)
4415 fprintf(f
, "PHDRS {\n");
4416 for (Phdrs_elements::const_iterator p
= this->phdrs_elements_
->begin();
4417 p
!= this->phdrs_elements_
->end();
4423 if (this->memory_regions_
!= NULL
)
4425 fprintf(f
, "MEMORY {\n");
4426 for (Memory_regions::const_iterator m
= this->memory_regions_
->begin();
4427 m
!= this->memory_regions_
->end();
4433 if (!this->saw_sections_clause_
)
4436 fprintf(f
, "SECTIONS {\n");
4438 for (Sections_elements::const_iterator p
= this->sections_elements_
->begin();
4439 p
!= this->sections_elements_
->end();
4446 } // End namespace gold.