// script-sections.cc -- linker script SECTIONS for gold
-// Copyright 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
+// Copyright (C) 2008-2019 Free Software Foundation, Inc.
// Written by Ian Lance Taylor <iant@google.com>.
// This file is part of gold.
script_exp_binary_add(this->start_,
script_exp_integer(this->current_offset_));
}
-
+
+ void
+ set_address(uint64_t addr, const Symbol_table* symtab, const Layout* layout)
+ {
+ uint64_t start = this->start_->eval(symtab, layout, false);
+ uint64_t len = this->length_->eval(symtab, layout, false);
+ if (addr < start || addr >= start + len)
+ gold_error(_("address 0x%llx is not within region %s"),
+ static_cast<unsigned long long>(addr),
+ this->name_.c_str());
+ else if (addr < start + this->current_offset_)
+ gold_error(_("address 0x%llx moves dot backwards in region %s"),
+ static_cast<unsigned long long>(addr),
+ this->name_.c_str());
+ this->current_offset_ = addr - start;
+ }
+
void
increment_offset(std::string section_name, uint64_t amount,
const Symbol_table* symtab, const Layout* layout)
gold_error(_("section %s overflows end of region %s"),
section_name.c_str(), this->name_.c_str());
}
-
+
// Returns true iff there is room left in this region
// for AMOUNT more bytes of data.
bool
// are compatible with this region's attributes.
bool
attributes_compatible(elfcpp::Elf_Xword flags, elfcpp::Elf_Xword type) const;
-
+
void
add_section(Output_section_definition* sec, bool vma)
{
attrs &= ~ (attrs & - attrs);
}
while (attrs != 0);
-
+
return match;
}
-
+
// Print a memory region.
void
bool
find_place(Output_section*, Elements_iterator** pwhere);
+ // Update PLACE_LAST_ALLOC.
+ void
+ update_last_alloc(Elements_iterator where);
+
// Return the iterator being used for sections at the very end of
// the linker script.
Elements_iterator
PLACE_TLS,
PLACE_TLS_BSS,
PLACE_BSS,
+ PLACE_LAST_ALLOC,
PLACE_REL,
PLACE_INTERP,
PLACE_NONALLOC,
this->initialize_place(PLACE_TLS, NULL);
this->initialize_place(PLACE_TLS_BSS, NULL);
this->initialize_place(PLACE_BSS, ".bss");
+ this->initialize_place(PLACE_LAST_ALLOC, NULL);
this->initialize_place(PLACE_REL, NULL);
this->initialize_place(PLACE_INTERP, ".interp");
this->initialize_place(PLACE_NONALLOC, NULL);
bool first_init = this->first_init_;
this->first_init_ = false;
+ // Remember the last allocated section. Any orphan bss sections
+ // will be placed after it.
+ if (os != NULL
+ && (os->flags() & elfcpp::SHF_ALLOC) != 0)
+ {
+ this->places_[PLACE_LAST_ALLOC].location = location;
+ this->places_[PLACE_LAST_ALLOC].have_location = true;
+ }
+
for (int i = 0; i < PLACE_MAX; ++i)
{
if (this->places_[i].name != NULL && this->places_[i].name == name)
case PLACE_RODATA:
follow = PLACE_TEXT;
break;
+ case PLACE_DATA:
+ follow = PLACE_RODATA;
+ if (!this->places_[PLACE_RODATA].have_location)
+ follow = PLACE_TEXT;
+ break;
case PLACE_BSS:
- follow = PLACE_DATA;
+ follow = PLACE_LAST_ALLOC;
break;
case PLACE_REL:
follow = PLACE_TEXT;
return ret;
}
+// Update PLACE_LAST_ALLOC.
+void
+Orphan_section_placement::update_last_alloc(Elements_iterator elem)
+{
+ Elements_iterator prev = elem;
+ --prev;
+ if (this->places_[PLACE_LAST_ALLOC].have_location
+ && this->places_[PLACE_LAST_ALLOC].location == prev)
+ {
+ this->places_[PLACE_LAST_ALLOC].have_location = true;
+ this->places_[PLACE_LAST_ALLOC].location = elem;
+ }
+}
+
// Return the iterator being used for sections at the very end of the
// linker script.
// Output_section_definition.
virtual const char*
output_section_name(const char*, const char*, Output_section***,
- Script_sections::Section_type*)
+ Script_sections::Section_type*, bool*, bool)
{ return NULL; }
// Initialize OSP with an output section.
set_section_addresses(Symbol_table* symtab, Layout* layout,
uint64_t* dot_value, uint64_t*, uint64_t*)
{
- this->assignment_.set_if_absolute(symtab, layout, true, *dot_value);
+ this->assignment_.set_if_absolute(symtab, layout, true, *dot_value, NULL);
}
// Print for debugging.
// output section definition the dot symbol is always considered
// to be absolute.
*dot_value = this->val_->eval_with_dot(symtab, layout, true, *dot_value,
- NULL, NULL, NULL);
+ NULL, NULL, NULL, false);
}
// Update the dot symbol while setting section addresses.
uint64_t* load_address)
{
*dot_value = this->val_->eval_with_dot(symtab, layout, false, *dot_value,
- NULL, NULL, dot_alignment);
+ NULL, NULL, dot_alignment, false);
*load_address = *dot_value;
}
// Return whether this element matches FILE_NAME and SECTION_NAME.
// The only real implementation is in Output_section_element_input.
virtual bool
- match_name(const char*, const char*) const
+ match_name(const char*, const char*, bool *) const
{ return false; }
// Set section addresses. This includes applying assignments if the
void
set_section_addresses(Symbol_table* symtab, Layout* layout, Output_section*,
uint64_t, uint64_t* dot_value, uint64_t*,
- Output_section**, std::string*, Input_section_list*)
+ Output_section** dot_section, std::string*,
+ Input_section_list*)
{
- this->assignment_.set_if_absolute(symtab, layout, true, *dot_value);
+ this->assignment_.set_if_absolute(symtab, layout, true, *dot_value,
+ *dot_section);
}
// Print for debugging.
: val_(val)
{ }
+ // An assignment to dot within an output section is enough to force
+ // the output section to exist.
+ bool
+ needs_output_section() const
+ { return true; }
+
// Finalize the symbol.
void
finalize_symbols(Symbol_table* symtab, const Layout* layout,
uint64_t* dot_value, Output_section** dot_section)
{
*dot_value = this->val_->eval_with_dot(symtab, layout, true, *dot_value,
- *dot_section, dot_section, NULL);
+ *dot_section, dot_section, NULL,
+ true);
}
// Update the dot symbol while setting section addresses.
void
set_section_addresses(Symbol_table* symtab, Layout* layout, Output_section*,
uint64_t, uint64_t* dot_value, uint64_t*,
- Output_section**, std::string*, Input_section_list*);
+ Output_section** dot_section, std::string*,
+ Input_section_list*);
// Print for debugging.
void
{
uint64_t next_dot = this->val_->eval_with_dot(symtab, layout, false,
*dot_value, *dot_section,
- dot_section, dot_alignment);
+ dot_section, dot_alignment,
+ true);
if (next_dot < *dot_value)
gold_error(_("dot may not move backward"));
if (next_dot > *dot_value && output_section != NULL)
{
uint64_t val = this->val_->eval_with_dot(this->symtab_, this->layout_,
true, this->dot_value_,
- this->dot_section_, NULL, NULL);
+ this->dot_section_, NULL, NULL,
+ false);
if (parameters->target().is_big_endian())
this->endian_write_to_buffer<true>(val, buf);
Output_section* fill_section;
uint64_t fill_val = this->val_->eval_with_dot(symtab, layout, false,
*dot_value, *dot_section,
- &fill_section, NULL);
+ &fill_section, NULL, false);
if (fill_section != NULL)
gold_warning(_("fill value is not absolute"));
// FIXME: The GNU linker supports fill values of arbitrary length.
*dot_section = this->final_dot_section_;
}
- // See whether we match FILE_NAME and SECTION_NAME as an input
- // section.
+ // See whether we match FILE_NAME and SECTION_NAME as an input section.
+ // If we do then also indicate whether the section should be KEPT.
bool
- match_name(const char* file_name, const char* section_name) const;
+ match_name(const char* file_name, const char* section_name, bool* keep) const;
// Set the section address.
void
return true;
}
-// See whether we match FILE_NAME and SECTION_NAME.
+// See whether we match FILE_NAME and SECTION_NAME. If we do then
+// KEEP indicates whether the section should survive garbage collection.
bool
Output_section_element_input::match_name(const char* file_name,
- const char* section_name) const
+ const char* section_name,
+ bool *keep) const
{
if (!this->match_file_name(file_name))
return false;
+ *keep = this->keep_;
+
// If there are no section name patterns, then we match.
if (this->input_section_patterns_.empty())
return true;
// Set the section name.
void
set_section_name(const std::string name)
- { this->section_name_ = name; }
+ {
+ if (is_compressed_debug_section(name.c_str()))
+ this->section_name_ = corresponding_uncompressed_section_name(name);
+ else
+ this->section_name_ = name;
+ }
// Return the section size.
uint64_t
private:
// Input section, can be a relaxed section.
Output_section::Input_section input_section_;
- // Name of the section.
+ // Name of the section.
std::string section_name_;
// Section size.
uint64_t size_;
operator()(const Input_section_info&, const Input_section_info&) const;
private:
+ static unsigned long
+ get_init_priority(const char*);
+
Sort_wildcard filename_sort_;
Sort_wildcard section_sort_;
};
+// Return a relative priority of the section with the specified NAME
+// (a lower value meand a higher priority), or 0 if it should be compared
+// with others as strings.
+// The implementation of this function is copied from ld/ldlang.c.
+
+unsigned long
+Input_section_sorter::get_init_priority(const char* name)
+{
+ char* end;
+ unsigned long init_priority;
+
+ // GCC uses the following section names for the init_priority
+ // attribute with numerical values 101 and 65535 inclusive. A
+ // lower value means a higher priority.
+ //
+ // 1: .init_array.NNNN/.fini_array.NNNN: Where NNNN is the
+ // decimal numerical value of the init_priority attribute.
+ // The order of execution in .init_array is forward and
+ // .fini_array is backward.
+ // 2: .ctors.NNNN/.dtors.NNNN: Where NNNN is 65535 minus the
+ // decimal numerical value of the init_priority attribute.
+ // The order of execution in .ctors is backward and .dtors
+ // is forward.
+
+ if (strncmp(name, ".init_array.", 12) == 0
+ || strncmp(name, ".fini_array.", 12) == 0)
+ {
+ init_priority = strtoul(name + 12, &end, 10);
+ return *end ? 0 : init_priority;
+ }
+ else if (strncmp(name, ".ctors.", 7) == 0
+ || strncmp(name, ".dtors.", 7) == 0)
+ {
+ init_priority = strtoul(name + 7, &end, 10);
+ return *end ? 0 : 65535 - init_priority;
+ }
+
+ return 0;
+}
+
bool
Input_section_sorter::operator()(const Input_section_info& isi1,
const Input_section_info& isi2) const
{
+ if (this->section_sort_ == SORT_WILDCARD_BY_INIT_PRIORITY)
+ {
+ unsigned long ip1 = get_init_priority(isi1.section_name().c_str());
+ unsigned long ip2 = get_init_priority(isi2.section_name().c_str());
+ if (ip1 != 0 && ip2 != 0 && ip1 != ip2)
+ return ip1 < ip2;
+ }
if (this->section_sort_ == SORT_WILDCARD_BY_NAME
|| this->section_sort_ == SORT_WILDCARD_BY_NAME_BY_ALIGNMENT
|| (this->section_sort_ == SORT_WILDCARD_BY_ALIGNMENT_BY_NAME
- && isi1.addralign() == isi2.addralign()))
+ && isi1.addralign() == isi2.addralign())
+ || this->section_sort_ == SORT_WILDCARD_BY_INIT_PRIORITY)
{
if (isi1.section_name() != isi2.section_name())
return isi1.section_name() < isi2.section_name();
// We build a list of sections which match each
// Input_section_pattern.
+ // If none of the patterns specify a sort option, we throw all
+ // matching input sections into a single bin, in the order we
+ // find them. Otherwise, we put matching input sections into
+ // a separate bin for each pattern, and sort each one as
+ // specified. Thus, an input section spec like this:
+ // *(.foo .bar)
+ // will group all .foo and .bar sections in the order seen,
+ // whereas this:
+ // *(.foo) *(.bar)
+ // will group all .foo sections followed by all .bar sections.
+ // This matches Gnu ld behavior.
+
+ // Things get really weird, though, when you add a sort spec
+ // on some, but not all, of the patterns, like this:
+ // *(SORT_BY_NAME(.foo) .bar)
+ // We do not attempt to match Gnu ld behavior in this case.
+
typedef std::vector<std::vector<Input_section_info> > Matching_sections;
size_t input_pattern_count = this->input_section_patterns_.size();
- if (input_pattern_count == 0)
- input_pattern_count = 1;
- Matching_sections matching_sections(input_pattern_count);
+ size_t bin_count = 1;
+ bool any_patterns_with_sort = false;
+ for (size_t i = 0; i < input_pattern_count; ++i)
+ {
+ const Input_section_pattern& isp(this->input_section_patterns_[i]);
+ if (isp.sort != SORT_WILDCARD_NONE)
+ any_patterns_with_sort = true;
+ }
+ if (any_patterns_with_sort)
+ bin_count = input_pattern_count;
+ Matching_sections matching_sections(bin_count);
// Look through the list of sections for this output section. Add
// each one which matches to one of the elements of
while (p != input_sections->end())
{
Relobj* relobj = p->relobj();
- unsigned int shndx = p->shndx();
+ unsigned int shndx = p->shndx();
Input_section_info isi(*p);
// Calling section_name and section_addralign is not very
break;
}
- if (i >= this->input_section_patterns_.size())
+ if (i >= input_pattern_count)
++p;
else
{
+ if (i >= bin_count)
+ i = 0;
matching_sections[i].push_back(isi);
p = input_sections->erase(p);
}
// output section.
uint64_t dot = *dot_value;
- for (size_t i = 0; i < input_pattern_count; ++i)
+ for (size_t i = 0; i < bin_count; ++i)
{
if (matching_sections[i].empty())
continue;
p != matching_sections[i].end();
++p)
{
- // Override the original address alignment if SUBALIGN is specified
- // and is greater than the original alignment. We need to make a
- // copy of the input section to modify the alignment.
+ // Override the original address alignment if SUBALIGN is specified.
+ // We need to make a copy of the input section to modify the
+ // alignment.
Output_section::Input_section sis(p->input_section());
uint64_t this_subalign = sis.addralign();
if (!sis.is_input_section())
- sis.output_section_data()->finalize_data_size();
+ sis.output_section_data()->finalize_data_size();
uint64_t data_size = sis.data_size();
- if (this_subalign < subalign)
+ if (subalign > 0)
{
this_subalign = subalign;
sis.set_addralign(subalign);
fprintf(f, "SORT_BY_ALIGNMENT(SORT_BY_NAME(");
close_parens = 2;
break;
+ case SORT_WILDCARD_BY_INIT_PRIORITY:
+ fprintf(f, "SORT_BY_INIT_PRIORITY(");
+ close_parens = 1;
+ break;
default:
gold_unreachable();
}
// section name.
const char*
output_section_name(const char* file_name, const char* section_name,
- Output_section***, Script_sections::Section_type*);
+ Output_section***, Script_sections::Section_type*,
+ bool*, bool);
// Initialize OSP with an output section.
void
void
set_section_vma(Expression* address)
{ this->address_ = address; }
-
+
void
set_section_lma(Expression* address)
{ this->load_address_ = address; }
const std::string&
get_section_name() const
{ return this->name_; }
-
+
private:
static const char*
script_section_type_name(Script_section_type);
{
address = this->address_->eval_with_dot(symtab, layout, true,
*dot_value, NULL,
- NULL, NULL);
+ NULL, NULL, false);
}
if (this->align_ != NULL)
{
uint64_t align = this->align_->eval_with_dot(symtab, layout, true,
*dot_value, NULL,
- NULL, NULL);
+ NULL, NULL, false);
address = align_address(address, align);
}
*dot_value = address;
const char* file_name,
const char* section_name,
Output_section*** slot,
- Script_sections::Section_type* psection_type)
+ Script_sections::Section_type* psection_type,
+ bool* keep,
+ bool match_input_spec)
{
+ // If the section is a linker-created output section, just look for a match
+ // on the output section name.
+ if (!match_input_spec && this->name_ != "/DISCARD/")
+ {
+ if (this->name_ != section_name)
+ return NULL;
+ *slot = &this->output_section_;
+ *psection_type = this->section_type();
+ return this->name_.c_str();
+ }
+
// Ask each element whether it matches NAME.
for (Output_section_elements::const_iterator p = this->elements_.begin();
p != this->elements_.end();
++p)
{
- if ((*p)->match_name(file_name, section_name))
+ if ((*p)->match_name(file_name, section_name, keep))
{
// We found a match for NAME, which means that it should go
// into this output section.
Script_sections::find_memory_region(
Output_section_definition* section,
bool find_vma_region,
+ bool explicit_only,
Output_section_definition** previous_section_return)
{
if (previous_section_return != NULL)
}
}
- // Make a note of the first memory region whose attributes
- // are compatible with the section. If we do not find an
- // explicit region assignment, then we will return this region.
- Output_section* out_sec = section->get_output_section();
- if (first_match == NULL
- && out_sec != NULL
- && (*mr)->attributes_compatible(out_sec->flags(),
- out_sec->type()))
- first_match = *mr;
+ if (!explicit_only)
+ {
+ // Make a note of the first memory region whose attributes
+ // are compatible with the section. If we do not find an
+ // explicit region assignment, then we will return this region.
+ Output_section* out_sec = section->get_output_section();
+ if (first_match == NULL
+ && out_sec != NULL
+ && (*mr)->attributes_compatible(out_sec->flags(),
+ out_sec->type()))
+ first_match = *mr;
+ }
}
// With LMA computations, if an explicit region has not been specified then
uint64_t old_dot_value = *dot_value;
uint64_t old_load_address = *load_address;
+ // If input section sorting is requested via --section-ordering-file or
+ // linker plugins, then do it here. This is important because we want
+ // any sorting specified in the linker scripts, which will be done after
+ // this, to take precedence. The final order of input sections is then
+ // guaranteed to be according to the linker script specification.
+ if (this->output_section_ != NULL
+ && this->output_section_->input_section_order_specified())
+ this->output_section_->sort_attached_input_sections();
+
// Decide the start address for the section. The algorithm is:
// 1) If an address has been specified in a linker script, use that.
// 2) Otherwise if a memory region has been specified for the section,
;
else if (this->address_ == NULL)
{
- vma_region = script_sections->find_memory_region(this, true, NULL);
-
+ vma_region = script_sections->find_memory_region(this, true, false, NULL);
if (vma_region != NULL)
address = vma_region->get_current_address()->eval(symtab, layout,
false);
address = *dot_value;
}
else
- address = this->address_->eval_with_dot(symtab, layout, true,
- *dot_value, NULL, NULL,
- dot_alignment);
+ {
+ vma_region = script_sections->find_memory_region(this, true, true, NULL);
+ address = this->address_->eval_with_dot(symtab, layout, true,
+ *dot_value, NULL, NULL,
+ dot_alignment, false);
+ if (vma_region != NULL)
+ vma_region->set_address(address, symtab, layout);
+ }
+
uint64_t align;
if (this->align_ == NULL)
{
{
Output_section* align_section;
align = this->align_->eval_with_dot(symtab, layout, true, *dot_value,
- NULL, &align_section, NULL);
+ NULL, &align_section, NULL, false);
if (align_section != NULL)
gold_warning(_("alignment of section %s is not absolute"),
this->name_.c_str());
this->output_section_->set_addralign(align);
}
+ uint64_t subalign;
+ if (this->subalign_ == NULL)
+ subalign = 0;
+ else
+ {
+ Output_section* subalign_section;
+ subalign = this->subalign_->eval_with_dot(symtab, layout, true,
+ *dot_value, NULL,
+ &subalign_section, NULL,
+ false);
+ if (subalign_section != NULL)
+ gold_warning(_("subalign of section %s is not absolute"),
+ this->name_.c_str());
+
+ // Reserve a value of 0 to mean there is no SUBALIGN property.
+ if (subalign == 0)
+ subalign = 1;
+
+ // The external alignment of the output section must be at least
+ // as large as that of the input sections. If there is no
+ // explicit ALIGN property, we set the output section alignment
+ // to match the input section alignment.
+ if (align < subalign || this->align_ == NULL)
+ {
+ align = subalign;
+ this->output_section_->set_addralign(align);
+ }
+ }
+
address = align_address(address, align);
uint64_t start_address = address;
Output_section_definition* previous_section;
// Determine if an LMA region has been set for this section.
- lma_region = script_sections->find_memory_region(this, false,
+ lma_region = script_sections->find_memory_region(this, false, false,
&previous_section);
if (lma_region != NULL)
// The LMA address was explicitly set to the given region.
laddr = lma_region->get_current_address()->eval(symtab, layout,
false);
- else
+ else
{
// We are not going to use the discovered lma_region, so
// make sure that we do not update it in the code below.
laddr = this->load_address_->eval_with_dot(symtab, layout, true,
*dot_value,
this->output_section_,
- NULL, NULL);
+ NULL, NULL, false);
if (this->output_section_ != NULL)
this->output_section_->set_load_address(laddr);
}
this->evaluated_load_address_ = laddr;
- uint64_t subalign;
- if (this->subalign_ == NULL)
- subalign = 0;
- else
- {
- Output_section* subalign_section;
- subalign = this->subalign_->eval_with_dot(symtab, layout, true,
- *dot_value, NULL,
- &subalign_section, NULL);
- if (subalign_section != NULL)
- gold_warning(_("subalign of section %s is not absolute"),
- this->name_.c_str());
- }
-
std::string fill;
if (this->fill_ != NULL)
{
uint64_t fill_val = this->fill_->eval_with_dot(symtab, layout, true,
*dot_value,
NULL, &fill_section,
- NULL);
+ NULL, false);
if (fill_section != NULL)
gold_warning(_("fill of section %s is not absolute"),
this->name_.c_str());
uint64_t address = *dot_value;
address = align_address(address, this->os_->addralign());
+ // If input section sorting is requested via --section-ordering-file or
+ // linker plugins, then do it here. This is important because we want
+ // any sorting specified in the linker scripts, which will be done after
+ // this, to take precedence. The final order of input sections is then
+ // guaranteed to be according to the linker script specification.
+ if (this->os_ != NULL
+ && this->os_->input_section_order_specified())
+ this->os_->sort_attached_input_sections();
+
// For a relocatable link, all orphan sections are put at
// address 0. In general we expect all sections to be at
// address 0 for a relocatable link, but we permit the linker
{
uint64_t addralign = p->addralign();
if (!p->is_input_section())
- p->output_section_data()->finalize_data_size();
+ p->output_section_data()->finalize_data_size();
uint64_t size = p->data_size();
address = align_address(address, addralign);
this->os_->add_script_input_section(*p);
address += size;
}
- // An SHF_TLS/SHT_NOBITS section does not take up any address space.
- if (this->os_ == NULL
- || (this->os_->flags() & elfcpp::SHF_TLS) == 0
- || this->os_->type() != elfcpp::SHT_NOBITS)
+ if (parameters->options().relocatable())
{
+ // For a relocatable link, reset DOT_VALUE to 0.
+ *dot_value = 0;
+ *load_address = 0;
+ }
+ else if (this->os_ == NULL
+ || (this->os_->flags() & elfcpp::SHF_TLS) == 0
+ || this->os_->type() != elfcpp::SHT_NOBITS)
+ {
+ // An SHF_TLS/SHT_NOBITS section does not take up any address space.
if (!have_load_address)
*load_address = address;
else
data_segment_align_start_(),
saw_data_segment_align_(false),
saw_relro_end_(false),
- saw_segment_start_expression_(false)
+ saw_segment_start_expression_(false),
+ segments_created_(false)
{
}
const char* file_name,
const char* section_name,
Output_section*** output_section_slot,
- Script_sections::Section_type* psection_type)
+ Script_sections::Section_type* psection_type,
+ bool* keep,
+ bool is_input_section)
{
for (Sections_elements::const_iterator p = this->sections_elements_->begin();
p != this->sections_elements_->end();
{
const char* ret = (*p)->output_section_name(file_name, section_name,
output_section_slot,
- psection_type);
+ psection_type, keep,
+ is_input_section);
if (ret != NULL)
{
}
}
- // If we couldn't find a mapping for the name, the output section
- // gets the name of the input section.
-
+ // We have an orphan section.
*output_section_slot = NULL;
*psection_type = Script_sections::ST_NONE;
+ *keep = false;
+
+ General_options::Orphan_handling orphan_handling =
+ parameters->options().orphan_handling_enum();
+ if (orphan_handling == General_options::ORPHAN_DISCARD)
+ return NULL;
+ if (orphan_handling == General_options::ORPHAN_ERROR)
+ {
+ if (file_name == NULL)
+ gold_error(_("unplaced orphan section '%s'"), section_name);
+ else
+ gold_error(_("unplaced orphan section '%s' from '%s'"),
+ section_name, file_name);
+ return NULL;
+ }
+ if (orphan_handling == General_options::ORPHAN_WARN)
+ {
+ if (file_name == NULL)
+ gold_warning(_("orphan section '%s' is being placed in section '%s'"),
+ section_name, section_name);
+ else
+ gold_warning(_("orphan section '%s' from '%s' is being placed "
+ "in section '%s'"),
+ section_name, file_name, section_name);
+ }
+ // If we couldn't find a mapping for the name, the output section
+ // gets the name of the input section.
return section_name;
}
Sections_elements::iterator last = osp->last_place();
*where = this->sections_elements_->insert(last, orphan);
}
+
+ if ((os->flags() & elfcpp::SHF_ALLOC) != 0)
+ osp->update_last_alloc(*where);
}
// Set the addresses of all the output sections. Walk through all the
Script_sections::set_section_addresses(Symbol_table* symtab, Layout* layout)
{
gold_assert(this->saw_sections_clause_);
-
+
// Implement ONLY_IF_RO/ONLY_IF_RW constraints. These are a pain
// for our representation.
for (Sections_elements::iterator p = this->sections_elements_->begin();
Output_section* os = (*p)->get_output_section();
// Handle -Ttext, -Tdata and -Tbss options. We do this by looking for
- // the special sections by names and doing dot assignments.
+ // the special sections by names and doing dot assignments.
if (use_tsection_options
&& os != NULL
&& (os->flags() & elfcpp::SHF_ALLOC) != 0)
(*p)->set_section_addresses(symtab, layout, &dot_value, &dot_alignment,
&load_address);
- }
+ }
if (this->phdrs_elements_ != NULL)
{
layout->get_allocated_sections(§ions);
// Sort the sections by address.
- std::stable_sort(sections.begin(), sections.end(),
+ std::stable_sort(sections.begin(), sections.end(),
Sort_output_sections(this->sections_elements_));
this->create_note_and_tls_segments(layout, §ions);
Output_segment* first_seg = NULL;
Output_segment* current_seg = NULL;
bool is_current_seg_readonly = true;
- Layout::Section_list::iterator plast = sections.end();
uint64_t last_vma = 0;
uint64_t last_lma = 0;
uint64_t last_size = 0;
+ bool in_bss = false;
for (Layout::Section_list::iterator p = sections.begin();
p != sections.end();
++p)
// skipping a page.
need_new_segment = true;
}
- else if (is_bss_section(*plast) && !is_bss_section(*p))
+ else if (in_bss && !is_bss_section(*p))
{
// A non-BSS section can not follow a BSS section in the
// same segment.
if (first_seg == NULL)
first_seg = current_seg;
is_current_seg_readonly = true;
+ in_bss = false;
}
current_seg->add_output_section_to_load(layout, *p, seg_flags);
if (((*p)->flags() & elfcpp::SHF_WRITE) != 0)
is_current_seg_readonly = false;
- plast = p;
+ if (is_bss_section(*p) && size > 0)
+ in_bss = true;
+
last_vma = vma;
last_lma = lma;
last_size = size;
saw_tls = true;
}
- // If we are making a shared library, and we see a section named
- // .interp then put the .interp section in a PT_INTERP segment.
+ // If we see a section named .interp then put the .interp section
+ // in a PT_INTERP segment.
// This is for GNU ld compatibility.
if (strcmp((*p)->name(), ".interp") == 0)
{
oseg->add_output_section_to_nonload(*p, seg_flags);
}
}
+
+ this->segments_created_ = true;
}
// Add a program header. The PHDRS clause is syntactically distinct
size_t
Script_sections::expected_segment_count(const Layout* layout) const
{
+ // If we've already created the segments, we won't be adding any more.
+ if (this->segments_created_)
+ return 0;
+
if (this->saw_phdrs_clause())
return this->phdrs_elements_->size();
bool saw_note = false;
bool saw_tls = false;
+ bool saw_interp = false;
for (Layout::Section_list::const_iterator p = sections.begin();
p != sections.end();
++p)
saw_tls = true;
}
}
+ else if (strcmp((*p)->name(), ".interp") == 0)
+ {
+ // There can only be one PT_INTERP segment.
+ if (!saw_interp)
+ {
+ ++ret;
+ saw_interp = true;
+ }
+ }
}
return ret;
p != this->phdrs_elements_->end();
++p)
name_to_segment[(*p)->name()] = (*p)->create_segment(layout);
+ this->segments_created_ = true;
// Walk through the output sections and attach them to segments.
// Output sections in the script which do not list segments are
// attached to the same set of segments as the immediately preceding
// output section.
-
+
String_list* phdr_names = NULL;
bool load_segments_only = false;
for (Sections_elements::const_iterator p = this->sections_elements_->begin();
// filtering.
if (old_phdr_names != phdr_names)
load_segments_only = false;
-
+
// If this is an orphan section--one that was not explicitly
// mentioned in the linker script--then it should not inherit
// any segment type other than PT_LOAD. Otherwise, e.g., the
++p)
(*p)->release_segment();
}
+ this->segments_created_ = false;
}
// Print the SECTIONS clause to F for debugging.