// output.cc -- manage the output file for gold
-// Copyright 2006, 2007, 2008, 2009, 2010, 2011, 2012
-// Free Software Foundation, Inc.
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
// This file is part of gold.
// Output_file_header methods.
-Output_file_header::Output_file_header(const Target* target,
+Output_file_header::Output_file_header(Target* target,
const Symbol_table* symtab,
const Output_segment_headers* osh)
: target_(target),
// Let the target adjust the ELF header, e.g., to set EI_OSABI in
// the e_ident field.
- parameters->target().adjust_elf_header(view, ehdr_size);
+ this->target_->adjust_elf_header(view, ehdr_size);
of->write_output_view(0, ehdr_size, view);
}
{
const bool should_issue_warning = (parameters->options().entry() != NULL
&& !parameters->options().relocatable()
- && !parameters->options().shared());
+ && !parameters->options().shared());
const char* entry = parameters->entry();
Symbol* sym = this->symtab_->lookup(entry);
shndx_(INVALID_CODE)
{
gold_assert(local_sym_index != GSYM_CODE
- && local_sym_index != INVALID_CODE);
+ && local_sym_index != INVALID_CODE);
// this->type_ is a bitfield; make sure TYPE fits.
gold_assert(this->type_ == type);
this->u1_.relobj = relobj;
shndx_(shndx)
{
gold_assert(local_sym_index != GSYM_CODE
- && local_sym_index != INVALID_CODE);
+ && local_sym_index != INVALID_CODE);
gold_assert(shndx != INVALID_CODE);
// this->type_ is a bitfield; make sure TYPE fits.
gold_assert(this->type_ == type);
default:
{
- const unsigned int lsi = this->local_sym_index_;
+ const unsigned int lsi = this->local_sym_index_;
Sized_relobj_file<size, big_endian>* relobj =
this->u1_.relobj->sized_relobj();
gold_assert(relobj != NULL);
- if (!this->is_section_symbol_)
- relobj->set_needs_output_dynsym_entry(lsi);
- else
- relobj->output_section(lsi)->set_needs_dynsym_index();
+ if (!this->is_section_symbol_)
+ relobj->set_needs_output_dynsym_entry(lsi);
+ else
+ relobj->output_section(lsi)->set_needs_dynsym_index();
}
break;
}
default:
{
- const unsigned int lsi = this->local_sym_index_;
+ const unsigned int lsi = this->local_sym_index_;
Sized_relobj_file<size, big_endian>* relobj =
this->u1_.relobj->sized_relobj();
gold_assert(relobj != NULL);
- if (!this->is_section_symbol_)
- {
- if (dynamic)
- index = relobj->dynsym_index(lsi);
- else
- index = relobj->symtab_index(lsi);
- }
- else
- {
- Output_section* os = relobj->output_section(lsi);
- gold_assert(os != NULL);
- if (dynamic)
- index = os->dynsym_index();
- else
- index = os->symtab_index();
- }
+ if (!this->is_section_symbol_)
+ {
+ if (dynamic)
+ index = relobj->dynsym_index(lsi);
+ else
+ index = relobj->symtab_index(lsi);
+ }
+ else
+ {
+ Output_section* os = relobj->output_section(lsi);
+ gold_assert(os != NULL);
+ if (dynamic)
+ index = os->dynsym_index();
+ else
+ index = os->symtab_index();
+ }
}
break;
}
local_section_offset(Addend addend) const
{
gold_assert(this->local_sym_index_ != GSYM_CODE
- && this->local_sym_index_ != SECTION_CODE
+ && this->local_sym_index_ != SECTION_CODE
&& this->local_sym_index_ != TARGET_CODE
- && this->local_sym_index_ != INVALID_CODE
+ && this->local_sym_index_ != INVALID_CODE
&& this->local_sym_index_ != 0
- && this->is_section_symbol_);
+ && this->is_section_symbol_);
const unsigned int lsi = this->local_sym_index_;
Output_section* os = this->u1_.relobj->output_section(lsi);
gold_assert(os != NULL);
return this->u1_.os->address() + addend;
}
gold_assert(this->local_sym_index_ != TARGET_CODE
- && this->local_sym_index_ != INVALID_CODE
+ && this->local_sym_index_ != INVALID_CODE
&& this->local_sym_index_ != 0
- && !this->is_section_symbol_);
+ && !this->is_section_symbol_);
const unsigned int lsi = this->local_sym_index_;
Sized_relobj_file<size, big_endian>* relobj =
this->u1_.relobj->sized_relobj();
case RESERVED_CODE:
// If we're doing an incremental update, don't touch this GOT entry.
if (parameters->incremental_update())
- return;
+ return;
val = this->u_.constant;
break;
default:
{
const Relobj* object = this->u_.object;
- const unsigned int lsi = this->local_sym_index_;
+ const unsigned int lsi = this->local_sym_index_;
bool is_tls = object->local_is_tls(lsi);
if (this->use_plt_or_tls_offset_ && !is_tls)
val = parameters->target().plt_address_for_local(object, lsi);
case RELAXED_INPUT_SECTION_CODE:
{
- Output_relaxed_input_section* relaxed_section =
+ Output_relaxed_input_section* relaxed_section =
this->relaxed_input_section();
- mapfile->print_input_section(relaxed_section->relobj(),
+ mapfile->print_input_section(relaxed_section->relobj(),
relaxed_section->shndx());
}
break;
input_section_size = uncompressed_size;
off_t offset_in_section;
- off_t aligned_offset_in_section;
+
if (this->has_fixed_layout())
{
// For incremental updates, find a chunk of unused space in the section.
offset_in_section = this->free_list_.allocate(input_section_size,
addralign, 0);
if (offset_in_section == -1)
- gold_fallback(_("out of patch space in section %s; "
+ gold_fallback(_("out of patch space in section %s; "
"relink with --incremental-full"),
this->name());
- aligned_offset_in_section = offset_in_section;
- }
- else
- {
- offset_in_section = this->current_data_size_for_child();
- aligned_offset_in_section = align_address(offset_in_section,
- addralign);
- this->set_current_data_size_for_child(aligned_offset_in_section
- + input_section_size);
+ return offset_in_section;
}
+ offset_in_section = this->current_data_size_for_child();
+ off_t aligned_offset_in_section = align_address(offset_in_section,
+ addralign);
+ this->set_current_data_size_for_child(aligned_offset_in_section
+ + input_section_size);
+
// Determine if we want to delay code-fill generation until the output
// section is written. When the target is relaxing, we want to delay fill
// generating to avoid adjusting them during relaxation. Also, if we are
&& (sh_flags & elfcpp::SHF_EXECINSTR) != 0
&& parameters->target().has_code_fill()
&& (parameters->target().may_relax()
- || layout->is_section_ordering_specified()))
+ || layout->is_section_ordering_specified()))
{
gold_assert(this->fills_.empty());
this->generate_code_fills_at_write_ = true;
// sections without input sections.
off_t fill_len = aligned_offset_in_section - offset_in_section;
if (this->input_sections_.empty())
- this->fills_.push_back(Fill(offset_in_section, fill_len));
+ this->fills_.push_back(Fill(offset_in_section, fill_len));
else
- {
- std::string fill_data(parameters->target().code_fill(fill_len));
- Output_data_const* odc = new Output_data_const(fill_data, 1);
- this->input_sections_.push_back(Input_section(odc));
- }
- }
-
- // The GNU linker groups input sections whose names match .text.unlikely.*.
- // This is used to get better code layout. We are compatible.
- // Additionally, it could also be beneficial to group .text.hot.*,
- // .text.startup.* prefixed input sections. Function
- // "is_section_name_prefix_grouped" in layout.cc determines the input
- // section prefixes that must be grouped.
- if (!have_sections_script
- && !parameters->options().relocatable()
- && !this->input_section_order_specified()
- && !this->must_sort_attached_input_sections()
- && layout->is_section_name_prefix_grouped(secname))
- this->set_input_section_order_specified();
+ {
+ std::string fill_data(parameters->target().code_fill(fill_len));
+ Output_data_const* odc = new Output_data_const(fill_data, 1);
+ this->input_sections_.push_back(Input_section(odc));
+ }
+ }
// We need to keep track of this section if we are already keeping
// track of sections, or if we are relaxing. Also, if this is a
|| this->must_sort_attached_input_sections()
|| parameters->options().user_set_Map()
|| parameters->target().may_relax()
- || layout->is_section_ordering_specified()
- || this->input_section_order_specified())
+ || layout->is_section_ordering_specified())
{
Input_section isecn(object, shndx, input_section_size, addralign);
/* If section ordering is requested by specifying a ordering file,
using --section-ordering-file, match the section name with
a pattern. */
if (parameters->options().section_ordering_file())
- {
- unsigned int section_order_index =
- layout->find_section_order_index(std::string(secname));
- if (section_order_index != 0)
- {
- isecn.set_section_order_index(section_order_index);
- this->set_input_section_order_specified();
- }
- }
- if (this->has_fixed_layout())
{
- // For incremental updates, finalize the address and offset now.
- uint64_t addr = this->address();
- isecn.set_address_and_file_offset(addr + aligned_offset_in_section,
- aligned_offset_in_section,
- this->offset());
+ unsigned int section_order_index =
+ layout->find_section_order_index(std::string(secname));
+ if (section_order_index != 0)
+ {
+ isecn.set_section_order_index(section_order_index);
+ this->set_input_section_order_specified();
+ }
}
this->input_sections_.push_back(isecn);
}
if (layout->is_section_ordering_specified())
{
unsigned int section_order_index =
- layout->find_section_order_index(name);
+ layout->find_section_order_index(name);
if (section_order_index != 0)
- {
- inp.set_section_order_index(section_order_index);
- this->set_input_section_order_specified();
- }
+ {
+ inp.set_section_order_index(section_order_index);
+ this->set_input_section_order_specified();
+ }
}
this->add_output_section_data(&inp);
{
bool is_string = (flags & elfcpp::SHF_STRINGS) != 0;
- // We only merge strings if the alignment is not more than the
- // character size. This could be handled, but it's unusual.
- if (is_string && addralign > entsize)
- return false;
-
// We cannot restore merged input section states.
gold_assert(this->checkpoint_ == NULL);
double pct = parameters->options().incremental_patch();
size_t extra = static_cast<size_t>(data_size * pct);
if (this->free_space_fill_ != NULL
- && this->free_space_fill_->minimum_hole_size() > extra)
+ && this->free_space_fill_->minimum_hole_size() > extra)
extra = this->free_space_fill_->minimum_hole_size();
off_t new_size = align_address(data_size + extra, this->addralign());
this->patch_space_ = new_size - data_size;
|| input_section.is_relaxed_input_section())
{
if (this->section_has_name_
- && must_sort_attached_input_sections)
+ && must_sort_attached_input_sections)
{
// This is only called single-threaded from Layout::finalize,
// so it is OK to lock. Unfortunately we have no way to pass
// in order to better support gcc, and we need to be compatible.
bool
match_file_name(const char* file_name) const
- { return Layout::match_file_name(this->input_section_.relobj(), file_name); }
+ {
+ if (this->input_section_.is_output_section_data())
+ return false;
+ return Layout::match_file_name(this->input_section_.relobj(), file_name);
+ }
// Returns 1 if THIS should appear before S in section order, -1 if S
// appears before THIS and 0 if they are not comparable.
unsigned int s_secn_index = s.input_section().section_order_index();
if (this_secn_index > 0 && s_secn_index > 0)
{
- if (this_secn_index < s_secn_index)
- return 1;
- else if (this_secn_index > s_secn_index)
- return -1;
+ if (this_secn_index < s_secn_index)
+ return 1;
+ else if (this_secn_index > s_secn_index)
+ return -1;
}
return 0;
}
// Return true if S1 should come before S2. Sections that do not match
// any pattern in the section ordering file are placed ahead of the sections
-// that match some pattern. This function is also used to group text according
-// to their prefix. The following prefixes are recognized: ".text.startup",
-// ".text.hot", and ".text.unlikely".
+// that match some pattern.
bool
Output_section::Input_section_sort_section_order_index_compare::operator()(
unsigned int s1_secn_index = s1.input_section().section_order_index();
unsigned int s2_secn_index = s2.input_section().section_order_index();
- // If section ordering is specified, it takes precedence.
- if (s1_secn_index != s2_secn_index)
- return s1_secn_index < s2_secn_index;
+ // Keep input order if section ordering cannot determine order.
+ if (s1_secn_index == s2_secn_index)
+ return s1.index() < s2.index();
+
+ return s1_secn_index < s2_secn_index;
+}
+
+// Return true if S1 should come before S2. This is the sort comparison
+// function for .text to sort sections with prefixes
+// .text.{unlikely,exit,startup,hot} before other sections.
- // Sort all the sections with no names to the end.
+bool
+Output_section::Input_section_sort_section_prefix_special_ordering_compare
+ ::operator()(
+ const Output_section::Input_section_sort_entry& s1,
+ const Output_section::Input_section_sort_entry& s2) const
+{
+ // We sort all the sections with no names to the end.
if (!s1.section_has_name() || !s2.section_has_name())
{
if (s1.section_has_name())
return s1.index() < s2.index();
}
- // If it is a text section use the following order:
- // .text.unlikely, .text.startup, .text.hot. The prefixes
- // must match those in function is_section_name_prefix_grouped
- // in layout.cc
- const char* section_prefix [] =
- {
- ".text.unlikely",
- ".text.startup",
- ".text.hot"
- };
+ // Some input section names have special ordering requirements.
+ int o1 = Layout::special_ordering_of_input_section(s1.section_name().c_str());
+ int o2 = Layout::special_ordering_of_input_section(s2.section_name().c_str());
+ if (o1 != o2)
+ {
+ if (o1 < 0)
+ return false;
+ else if (o2 < 0)
+ return true;
+ else
+ return o1 < o2;
+ }
- const unsigned int num_prefixes
- = sizeof(section_prefix) / sizeof(const char*);
+ // Keep input order otherwise.
+ return s1.index() < s2.index();
+}
- unsigned int s1_group_index = num_prefixes;
- unsigned int s2_group_index = num_prefixes;
+// Return true if S1 should come before S2. This is the sort comparison
+// function for sections to sort them by name.
- unsigned int flag_done = 0;
- for (unsigned int i = 0; i < num_prefixes && flag_done < 2; i++)
+bool
+Output_section::Input_section_sort_section_name_compare
+ ::operator()(
+ const Output_section::Input_section_sort_entry& s1,
+ const Output_section::Input_section_sort_entry& s2) const
+{
+ // We sort all the sections with no names to the end.
+ if (!s1.section_has_name() || !s2.section_has_name())
{
- if (s1_group_index == num_prefixes
- && is_prefix_of(section_prefix[i], s1.section_name().c_str()))
- {
- s1_group_index = i;
- flag_done++;
- }
-
- if (s2_group_index == num_prefixes
- && is_prefix_of(section_prefix[i], s2.section_name().c_str()))
- {
- s2_group_index = i;
- flag_done++;
- }
+ if (s1.section_has_name())
+ return true;
+ if (s2.section_has_name())
+ return false;
+ return s1.index() < s2.index();
}
- if (s1_group_index == s2_group_index)
- return s1.index() < s2.index();
- else
- return s1_group_index < s2_group_index;
+ // We sort by name.
+ int compare = s1.section_name().compare(s2.section_name());
+ if (compare != 0)
+ return compare < 0;
+
+ // Keep input order otherwise.
+ return s1.index() < s2.index();
}
// This updates the section order index of input sections according to the
{
if (p->is_input_section()
|| p->is_relaxed_input_section())
- {
+ {
Object* obj = (p->is_input_section()
? p->relobj()
- : p->relaxed_input_section()->relobj());
+ : p->relaxed_input_section()->relobj());
unsigned int shndx = p->shndx();
Section_layout_order::const_iterator it
= order_map->find(Section_id(obj, shndx));
continue;
unsigned int section_order_index = it->second;
if (section_order_index != 0)
- {
- p->set_section_order_index(section_order_index);
- this->set_input_section_order_specified();
+ {
+ p->set_section_order_index(section_order_index);
+ this->set_input_section_order_specified();
}
- }
+ }
}
}
p != this->input_sections_.end();
++p, ++i)
sort_list.push_back(Input_section_sort_entry(*p, i,
- (this->must_sort_attached_input_sections()
- || this->input_section_order_specified())));
+ this->must_sort_attached_input_sections()));
// Sort the input sections.
if (this->must_sort_attached_input_sections())
{
if (this->type() == elfcpp::SHT_PREINIT_ARRAY
- || this->type() == elfcpp::SHT_INIT_ARRAY
- || this->type() == elfcpp::SHT_FINI_ARRAY)
- std::sort(sort_list.begin(), sort_list.end(),
- Input_section_sort_init_fini_compare());
+ || this->type() == elfcpp::SHT_INIT_ARRAY
+ || this->type() == elfcpp::SHT_FINI_ARRAY)
+ std::sort(sort_list.begin(), sort_list.end(),
+ Input_section_sort_init_fini_compare());
+ else if (strcmp(parameters->options().sort_section(), "name") == 0)
+ std::sort(sort_list.begin(), sort_list.end(),
+ Input_section_sort_section_name_compare());
+ else if (strcmp(this->name(), ".text") == 0)
+ std::sort(sort_list.begin(), sort_list.end(),
+ Input_section_sort_section_prefix_special_ordering_compare());
else
- std::sort(sort_list.begin(), sort_list.end(),
- Input_section_sort_compare());
+ std::sort(sort_list.begin(), sort_list.end(),
+ Input_section_sort_compare());
}
else
{
gold_assert(this->input_section_order_specified());
std::sort(sort_list.begin(), sort_list.end(),
- Input_section_sort_section_order_index_compare());
+ Input_section_sort_section_order_index_compare());
}
// Copy the sorted input sections back to our list.
// and *PSHNDX.
uint64_t
-Output_segment::set_section_addresses(Layout* layout, bool reset,
- uint64_t addr,
+Output_segment::set_section_addresses(const Target* target,
+ Layout* layout, bool reset,
+ uint64_t addr,
unsigned int* increase_relro,
bool* has_relro,
off_t* poff,
// objects.
*poff = off;
+ // If code segments must contain only code, and this code segment is
+ // page-aligned in the file, then fill it out to a whole page with
+ // code fill (the tail of the segment will not be within any section).
+ // Thus the entire code segment can be mapped from the file as whole
+ // pages and that mapping will contain only valid instructions.
+ if (target->isolate_execinstr() && (this->flags() & elfcpp::PF_X) != 0)
+ {
+ uint64_t abi_pagesize = target->abi_pagesize();
+ if (orig_off % abi_pagesize == 0 && off % abi_pagesize != 0)
+ {
+ size_t fill_size = abi_pagesize - (off % abi_pagesize);
+
+ std::string fill_data;
+ if (target->has_code_fill())
+ fill_data = target->code_fill(fill_size);
+ else
+ fill_data.resize(fill_size); // Zero fill.
+
+ Output_data_const* fill = new Output_data_const(fill_data, 0);
+ fill->set_address(this->vaddr_ + this->memsz_);
+ fill->set_file_offset(off);
+ layout->add_relax_output(fill);
+
+ off += fill_size;
+ gold_assert(off % abi_pagesize == 0);
+ ret += fill_size;
+ gold_assert(ret % abi_pagesize == 0);
+
+ gold_assert((uint64_t) this->filesz_ == this->memsz_);
+ this->memsz_ = this->filesz_ += fill_size;
+
+ *poff = off;
+ }
+ }
+
return ret;
}
uint64_t
Output_segment::set_section_list_addresses(Layout* layout, bool reset,
- Output_data_list* pdl,
+ Output_data_list* pdl,
uint64_t addr, off_t* poff,
unsigned int* pshndx,
- bool* in_tls)
+ bool* in_tls)
{
off_t startoff = *poff;
// For incremental updates, we may allocate non-fixed sections from
// the section will most likely already have an address.
if (!(*p)->is_address_valid())
{
- uint64_t align = (*p)->addralign();
-
- if ((*p)->is_section_flag_set(elfcpp::SHF_TLS))
- {
- // Give the first TLS section the alignment of the
- // entire TLS segment. Otherwise the TLS segment as a
- // whole may be misaligned.
- if (!*in_tls)
- {
- Output_segment* tls_segment = layout->tls_segment();
- gold_assert(tls_segment != NULL);
- uint64_t segment_align = tls_segment->maximum_alignment();
- gold_assert(segment_align >= align);
- align = segment_align;
-
- *in_tls = true;
- }
- }
- else
- {
- // If this is the first section after the TLS segment,
- // align it to at least the alignment of the TLS
- // segment, so that the size of the overall TLS segment
- // is aligned.
- if (*in_tls)
- {
- uint64_t segment_align =
- layout->tls_segment()->maximum_alignment();
- if (segment_align > align)
- align = segment_align;
-
- *in_tls = false;
- }
- }
+ uint64_t align = (*p)->addralign();
+
+ if ((*p)->is_section_flag_set(elfcpp::SHF_TLS))
+ {
+ // Give the first TLS section the alignment of the
+ // entire TLS segment. Otherwise the TLS segment as a
+ // whole may be misaligned.
+ if (!*in_tls)
+ {
+ Output_segment* tls_segment = layout->tls_segment();
+ gold_assert(tls_segment != NULL);
+ uint64_t segment_align = tls_segment->maximum_alignment();
+ gold_assert(segment_align >= align);
+ align = segment_align;
+
+ *in_tls = true;
+ }
+ }
+ else
+ {
+ // If this is the first section after the TLS segment,
+ // align it to at least the alignment of the TLS
+ // segment, so that the size of the overall TLS segment
+ // is aligned.
+ if (*in_tls)
+ {
+ uint64_t segment_align =
+ layout->tls_segment()->maximum_alignment();
+ if (segment_align > align)
+ align = segment_align;
+
+ *in_tls = false;
+ }
+ }
if (!parameters->incremental_update())
{
off_t current_size = (*p)->current_data_size();
off = layout->allocate(current_size, align, startoff);
if (off == -1)
- {
+ {
gold_assert((*p)->output_section() != NULL);
gold_fallback(_("out of patch space for section %s; "
"relink with --incremental-full"),
(*p)->output_section()->name());
- }
+ }
(*p)->set_address_and_file_offset(addr + (off - startoff), off);
if ((*p)->data_size() > current_size)
{
}
}
else if (parameters->incremental_update())
- {
- // For incremental updates, use the fixed offset for the
- // high-water mark computation.
- off = (*p)->offset();
- }
+ {
+ // For incremental updates, use the fixed offset for the
+ // high-water mark computation.
+ off = (*p)->offset();
+ }
else
{
// The script may have inserted a skip forward, but it
off += (*p)->data_size();
if (off > maxoff)
- maxoff = off;
+ maxoff = off;
if ((*p)->is_section())
{
return;
gold_fatal(_("%s: mmap: failed to allocate %lu bytes for output file: %s"),
- this->name_, static_cast<unsigned long>(this->file_size_),
- strerror(errno));
+ this->name_, static_cast<unsigned long>(this->file_size_),
+ strerror(errno));
}
// Unmap the file from memory.
size_t bytes_to_write = this->file_size_;
size_t offset = 0;
while (bytes_to_write > 0)
- {
- ssize_t bytes_written = ::write(this->o_, this->base_ + offset,
- bytes_to_write);
- if (bytes_written == 0)
- gold_error(_("%s: write: unexpected 0 return-value"), this->name_);
- else if (bytes_written < 0)
- gold_error(_("%s: write: %s"), this->name_, strerror(errno));
- else
- {
- bytes_to_write -= bytes_written;
- offset += bytes_written;
- }
- }
+ {
+ ssize_t bytes_written = ::write(this->o_, this->base_ + offset,
+ bytes_to_write);
+ if (bytes_written == 0)
+ gold_error(_("%s: write: unexpected 0 return-value"), this->name_);
+ else if (bytes_written < 0)
+ gold_error(_("%s: write: %s"), this->name_, strerror(errno));
+ else
+ {
+ bytes_to_write -= bytes_written;
+ offset += bytes_written;
+ }
+ }
}
this->unmap();
projects / binutils.git / blobdiff