// Output_section_definition.
virtual const char*
output_section_name(const char*, const char*, Output_section***,
- Script_sections::Section_type*)
+ Script_sections::Section_type*, 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;
// 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*);
// Initialize OSP with an output section.
void
{
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)
{
// 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.
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
address = this->address_->eval_with_dot(symtab, layout, true,
*dot_value, NULL, NULL,
- dot_alignment);
+ dot_alignment, false);
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());
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);
}
Output_section* subalign_section;
subalign = this->subalign_->eval_with_dot(symtab, layout, true,
*dot_value, NULL,
- &subalign_section, NULL);
+ &subalign_section, NULL,
+ false);
if (subalign_section != NULL)
gold_warning(_("subalign of section %s is not absolute"),
this->name_.c_str());
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
+ // script to override that for specific output sections.
+ if (parameters->options().relocatable())
+ {
+ address = 0;
+ *load_address = 0;
+ have_load_address = false;
+ }
+
if ((this->os_->flags() & elfcpp::SHF_ALLOC) != 0)
{
this->os_->set_address(address);
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
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)
{
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);
if (ret != NULL)
{
operator()(const Output_section* os1, const Output_section* os2) const;
private:
- bool
- is_before(const Output_section* os1, const Output_section* os2) const;
+ int
+ script_compare(const Output_section* os1, const Output_section* os2) const;
private:
const Script_sections::Sections_elements* elements_;
if (os1->address() != os2->address())
return os1->address() < os2->address();
+ // If the linker script says which of these sections is first, go
+ // with what it says.
+ int i = this->script_compare(os1, os2);
+ if (i != 0)
+ return i < 0;
+
// Sort PROGBITS before NOBITS.
bool nobits1 = os1->type() == elfcpp::SHT_NOBITS;
bool nobits2 = os2->type() == elfcpp::SHT_NOBITS;
return true;
if (!os1->is_noload() && os2->is_noload())
return true;
-
- // The sections have the same address. Check the section positions
- // in accordance with the linker script.
- return this->is_before(os1, os2);
+
+ // The sections seem practically identical. Sort by name to get a
+ // stable sort.
+ return os1->name() < os2->name();
}
-// Return true if OS1 comes before OS2 in ELEMENTS_. This ensures
-// that we keep empty sections in the order in which they appear in a
-// linker script.
+// Return -1 if OS1 comes before OS2 in ELEMENTS_, 1 if comes after, 0
+// if either OS1 or OS2 is not mentioned. This ensures that we keep
+// empty sections in the order in which they appear in a linker
+// script.
-bool
-Sort_output_sections::is_before(const Output_section* os1,
- const Output_section* os2) const
+int
+Sort_output_sections::script_compare(const Output_section* os1,
+ const Output_section* os2) const
{
if (this->elements_ == NULL)
- return false;
+ return 0;
+ bool found_os1 = false;
+ bool found_os2 = false;
for (Script_sections::Sections_elements::const_iterator
p = this->elements_->begin();
p != this->elements_->end();
++p)
{
- if (os1 == (*p)->get_output_section())
+ if (os2 == (*p)->get_output_section())
{
- for (++p; p != this->elements_->end(); ++p)
- if (os2 == (*p)->get_output_section())
- return true;
- break;
+ if (found_os1)
+ return -1;
+ found_os2 = true;
+ }
+ else if (os1 == (*p)->get_output_section())
+ {
+ if (found_os2)
+ return 1;
+ found_os1 = true;
}
}
- return false;
+ return 0;
}
// Return whether OS is a BSS section. This is a SHT_NOBITS section.
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.
+ // This is for GNU ld compatibility.
+ if (strcmp((*p)->name(), ".interp") == 0)
+ {
+ elfcpp::Elf_Word seg_flags =
+ Layout::section_flags_to_segment((*p)->flags());
+ Output_segment* oseg = layout->make_output_segment(elfcpp::PT_INTERP,
+ seg_flags);
+ oseg->add_output_section_to_nonload(*p, seg_flags);
+ }
}
}
p != this->sections_elements_->end();
++p)
{
- bool orphan;
+ bool is_orphan;
String_list* old_phdr_names = phdr_names;
- Output_section* os = (*p)->allocate_to_segment(&phdr_names, &orphan);
+ Output_section* os = (*p)->allocate_to_segment(&phdr_names, &is_orphan);
if (os == NULL)
continue;
+ elfcpp::Elf_Word seg_flags =
+ Layout::section_flags_to_segment(os->flags());
+
if (phdr_names == NULL)
{
- gold_error(_("allocated section not in any segment"));
+ // Don't worry about empty orphan sections.
+ if (is_orphan && os->current_data_size() > 0)
+ gold_error(_("allocated section %s not in any segment"),
+ os->name());
+
+ // To avoid later crashes drop this section into the first
+ // PT_LOAD segment.
+ for (Phdrs_elements::const_iterator ppe =
+ this->phdrs_elements_->begin();
+ ppe != this->phdrs_elements_->end();
+ ++ppe)
+ {
+ Output_segment* oseg = (*ppe)->segment();
+ if (oseg->type() == elfcpp::PT_LOAD)
+ {
+ oseg->add_output_section_to_load(layout, os, seg_flags);
+ break;
+ }
+ }
+
continue;
}
// PT_INTERP segment will pick up following orphan sections,
// which does not make sense. If this is not an orphan section,
// we trust the linker script.
- if (orphan)
+ if (is_orphan)
{
// Enable PT_LOAD segments only filtering until we see another
// list of segment names.
&& r->second->type() != elfcpp::PT_LOAD)
continue;
- elfcpp::Elf_Word seg_flags =
- Layout::section_flags_to_segment(os->flags());
-
if (r->second->type() != elfcpp::PT_LOAD)
r->second->add_output_section_to_nonload(os, seg_flags);
else