// 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.
// Written by Ian Lance Taylor <iant@google.com>.
// 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);
val = pool->get_offset(this->u_.str);
break;
+ case DYNAMIC_CUSTOM:
+ val = parameters->target().dynamic_tag_custom_value(this->tag_);
+ break;
+
default:
val = this->u_.od->address() + this->offset_;
break;
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));
- }
+ {
+ 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
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;
{
public:
Input_section_sort_entry()
- : input_section_(), index_(-1U), section_has_name_(false),
- section_name_()
+ : input_section_(), index_(-1U), section_name_()
{ }
Input_section_sort_entry(const Input_section& input_section,
unsigned int index,
- bool must_sort_attached_input_sections)
- : input_section_(input_section), index_(index),
- section_has_name_(input_section.is_input_section()
- || input_section.is_relaxed_input_section())
+ bool must_sort_attached_input_sections,
+ const char* output_section_name)
+ : input_section_(input_section), index_(index), section_name_()
{
- if (this->section_has_name_
- && must_sort_attached_input_sections)
+ if ((input_section.is_input_section()
+ || input_section.is_relaxed_input_section())
+ && 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
// Layout::layout if this becomes a speed problem.
this->section_name_ = obj->section_name(input_section.shndx());
}
+ else if (input_section.is_output_section_data()
+ && must_sort_attached_input_sections)
+ {
+ // For linker-generated sections, use the output section name.
+ this->section_name_.assign(output_section_name);
+ }
}
// Return the Input_section.
return this->index_;
}
- // Whether there is a section name.
- bool
- section_has_name() const
- { return this->section_has_name_; }
-
// The section name.
const std::string&
section_name() const
{
- gold_assert(this->section_has_name_);
return this->section_name_;
}
bool
has_priority() const
{
- gold_assert(this->section_has_name_);
return this->section_name_.find('.', 1) != std::string::npos;
}
unsigned int
get_priority() const
{
- gold_assert(this->section_has_name_);
bool is_ctors;
if (is_prefix_of(".ctors.", this->section_name_.c_str())
|| is_prefix_of(".dtors.", this->section_name_.c_str()))
// 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;
}
Input_section input_section_;
// The index of this Input_section in the original list.
unsigned int index_;
- // Whether this Input_section has a section name--it won't if this
- // is some random Output_section_data.
- bool section_has_name_;
// The section name if there is one.
std::string section_name_;
};
return s1.index() < s2.index();
}
- // 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 true;
- if (s2.section_has_name())
- return false;
- return s1.index() < s2.index();
- }
-
// A section with a priority follows a section without a priority.
bool s1_has_priority = s1.has_priority();
bool s2_has_priority = s2.has_priority();
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 true;
- if (s2.section_has_name())
- return false;
- return s1.index() < s2.index();
- }
-
// A section without a priority follows a section with a priority.
// This is the reverse of .ctors and .dtors sections.
bool s1_has_priority = s1.has_priority();
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.
+
+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
+{
+ // 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;
+ }
+
+ // Keep input order otherwise.
+ return s1.index() < s2.index();
+}
+
+// Return true if S1 should come before S2. This is the sort comparison
+// function for sections to sort them by name.
+
+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 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
// the order specified in the mapping from Section id to order index.
{
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->must_sort_attached_input_sections(),
+ this->name()));
// 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 / platform / upstream / binutils.git / blobdiff