yggdrasil/binutils-gdb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

gold/

Browse Source 
* output.cc (Output_segment::set_section_addresses): Take new
	Target* argument.  If target->isolate_execinstr() and the segment
	is executable and starts at a target->abi_pagesize() boundary,
	pad its end out to a target->abi_pagesize() boundary with code fill.
	* output.h (Output_segment::set_section_addresses): Update decl.
	* layout.h (Layout::check_output_data_for_reset_values): Take new
	argument RELAX_OUTPUTS.
	(Layout): New member relax_output_list_.
	(Layout::add_relax_output): New method.
	* layout.cc (Layout::Layout): Update constructor.
	(Layout::reset_relax_output): New method.
	(Layout::clean_up_after_relaxation): Call it.
	(Layout::prepare_for_relaxation): Update caller.
	(Layout::set_segment_offsets): Update callers of set_section_addresses.
	Call reset_relax_output before re-processing segments for
	isolate_execinstr case.
	(Layout::write_data): Handle relax_output_list_.
	(Layout::Relaxation_debug_check::check_output_data_for_reset_values):
	Take new argument RELAX_OUTPUTS.  Assert it's an empty collection.
This commit is contained in:
Roland McGrath 2013-08-27 21:49:48 +00:00
parent 69d751e3c1
commit eb426534c3
5 changed files with 249 additions and 146 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
gold/ChangeLog
View File

@ -1,3 +1,25 @@
2013-08-27 Roland McGrath <mcgrathr@google.com>
* output.cc (Output_segment::set_section_addresses): Take new
Target* argument. If target->isolate_execinstr() and the segment
is executable and starts at a target->abi_pagesize() boundary,
pad its end out to a target->abi_pagesize() boundary with code fill.
* output.h (Output_segment::set_section_addresses): Update decl.
* layout.h (Layout::check_output_data_for_reset_values): Take new
argument RELAX_OUTPUTS.
(Layout): New member relax_output_list_.
(Layout::add_relax_output): New method.
* layout.cc (Layout::Layout): Update constructor.
(Layout::reset_relax_output): New method.
(Layout::clean_up_after_relaxation): Call it.
(Layout::prepare_for_relaxation): Update caller.
(Layout::set_segment_offsets): Update callers of set_section_addresses.
Call reset_relax_output before re-processing segments for
isolate_execinstr case.
(Layout::write_data): Handle relax_output_list_.
(Layout::Relaxation_debug_check::check_output_data_for_reset_values):
Take new argument RELAX_OUTPUTS. Assert it's an empty collection.
2013-08-23 Yuri Chornoivan <yurchor@ukr.net>
PR binutils/15834

42
gold/layout.cc
View File

@ -293,7 +293,8 @@ Hash_task::is_runnable()
void
Layout::Relaxation_debug_check::check_output_data_for_reset_values(
const Layout::Section_list& sections,
const Layout::Data_list& special_outputs)
const Layout::Data_list& special_outputs,
const Layout::Data_list& relax_outputs)
{
for(Layout::Section_list::const_iterator p = sections.begin();
p != sections.end();
@ -304,6 +305,8 @@ Layout::Relaxation_debug_check::check_output_data_for_reset_values(
p != special_outputs.end();
++p)
gold_assert((*p)->address_and_file_offset_have_reset_values());
gold_assert(relax_outputs.empty());
}
// Save information of SECTIONS for checking later.
@ -428,6 +431,7 @@ Layout::Layout(int number_of_input_files, Script_options* script_options)
section_list_(),
unattached_section_list_(),
special_output_list_(),
relax_output_list_(),
section_headers_(NULL),
tls_segment_(NULL),
relro_segment_(NULL),
@ -2341,6 +2345,20 @@ Layout::clean_up_after_relaxation()
++p)
delete *p;
this->script_output_section_data_list_.clear();
// Special-case fill output objects are recreated each time through
// the relaxation loop.
this->reset_relax_output();
}
void
Layout::reset_relax_output()
{
for (Data_list::const_iterator p = this->relax_output_list_.begin();
p != this->relax_output_list_.end();
++p)
delete *p;
this->relax_output_list_.clear();
}
// Prepare for relaxation.
@ -2363,7 +2381,8 @@ Layout::prepare_for_relaxation()
if (is_debugging_enabled(DEBUG_RELAXATION))
this->relaxation_debug_check_->check_output_data_for_reset_values(
this->section_list_, this->special_output_list_);
this->section_list_, this->special_output_list_,
this->relax_output_list_);
// Also enable recording of output section data from scripts.
this->record_output_section_data_from_script_ = true;
@ -3540,7 +3559,8 @@ Layout::set_segment_offsets(const Target* target, Output_segment* load_seg,
unsigned int shndx_hold = *pshndx;
bool has_relro = false;
uint64_t new_addr = (*p)->set_section_addresses(this, false, addr,
uint64_t new_addr = (*p)->set_section_addresses(target, this,
false, addr,
&increase_relro,
&has_relro,
&off, pshndx);
@ -3581,7 +3601,8 @@ Layout::set_segment_offsets(const Target* target, Output_segment* load_seg,
increase_relro = 0;
has_relro = false;
new_addr = (*p)->set_section_addresses(this, true, addr,
new_addr = (*p)->set_section_addresses(target, this,
true, addr,
&increase_relro,
&has_relro,
&off, pshndx);
@ -3617,6 +3638,8 @@ Layout::set_segment_offsets(const Target* target, Output_segment* load_seg,
// so they land after the segments starting at LOAD_SEG.
off = align_file_offset(off, 0, target->abi_pagesize());
this->reset_relax_output();
for (Segment_list::iterator p = this->segment_list_.begin();
*p != load_seg;
++p)
@ -3630,8 +3653,8 @@ Layout::set_segment_offsets(const Target* target, Output_segment* load_seg,
bool has_relro = false;
const uint64_t old_addr = (*p)->vaddr();
const uint64_t old_end = old_addr + (*p)->memsz();
uint64_t new_addr = (*p)->set_section_addresses(this, true,
old_addr,
uint64_t new_addr = (*p)->set_section_addresses(target, this,
true, old_addr,
&increase_relro,
&has_relro,
&off,
@ -5268,6 +5291,13 @@ Layout::write_data(const Symbol_table* symtab, Output_file* of) const
p != this->special_output_list_.end();
++p)
(*p)->write(of);
// Write out the Output_data which are not in an Output_section
// and are regenerated in each iteration of relaxation.
for (Data_list::const_iterator p = this->relax_output_list_.begin();
p != this->relax_output_list_.end();
++p)
(*p)->write(of);
}
// Write out the Output_sections which can only be written after the

22
gold/layout.h
View File

@ -1,6 +1,6 @@
// layout.h -- lay out output file sections for gold -*- C++ -*-
// Copyright 2006, 2007, 2008, 2009, 2010, 2011, 2012
// Copyright 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013
// Free Software Foundation, Inc.
// Written by Ian Lance Taylor <iant@google.com>.
@ -897,7 +897,7 @@ class Layout
// they finish. Otherwise return BUILD_ID_BLOCKER.
Task_token*
queue_build_id_tasks(Workqueue* workqueue, Task_token* build_id_blocker,
Output_file* of);
Output_file* of);
// Compute and write out the build ID if needed.
void
@ -976,7 +976,17 @@ class Layout
// be mapped to an output section that should be KEPT.
bool
keep_input_section(const Relobj*, const char*);
// Add a special output object that will be recreated afresh
// if there is another relaxation iteration.
void
add_relax_output(Output_data* data)
{ this->relax_output_list_.push_back(data); }
// Clear out (and free) everything added by add_relax_output.
void
reset_relax_output();
private:
Layout(const Layout&);
Layout& operator=(const Layout&);
@ -1272,7 +1282,8 @@ class Layout
// Check that sections and special data are in reset states.
void
check_output_data_for_reset_values(const Layout::Section_list&,
const Layout::Data_list&);
const Layout::Data_list& special_outputs,
const Layout::Data_list& relax_outputs);
// Record information of a section list.
void
@ -1324,6 +1335,9 @@ class Layout
// The list of unattached Output_data objects which require special
// handling because they are not Output_sections.
Data_list special_output_list_;
// Like special_output_list_, but cleared and recreated on each
// iteration of relaxation.
Data_list relax_output_list_;
// The section headers.
Output_section_headers* section_headers_;
// A pointer to the PT_TLS segment if there is one.

304
gold/output.cc
View File

@ -1,6 +1,6 @@
// output.cc -- manage the output file for gold
// Copyright 2006, 2007, 2008, 2009, 2010, 2011, 2012
// Copyright 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013
// Free Software Foundation, Inc.
// Written by Ian Lance Taylor <iant@google.com>.
@ -590,7 +590,7 @@ Output_file_header::entry()
{
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);
@ -769,7 +769,7 @@ Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
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;
@ -795,7 +795,7 @@ Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
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);
@ -954,14 +954,14 @@ set_needs_dynsym_index()
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;
}
@ -1010,26 +1010,26 @@ Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::get_symbol_index()
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;
}
@ -1046,11 +1046,11 @@ Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::
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);
@ -1141,9 +1141,9 @@ Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::symbol_value(
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();
@ -1425,14 +1425,14 @@ Output_data_got<got_size, big_endian>::Got_entry::write(
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);
@ -2246,9 +2246,9 @@ Output_section::Input_section::print_to_mapfile(Mapfile* mapfile) const
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;
@ -2429,7 +2429,7 @@ Output_section::add_input_section(Layout* layout,
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());
return offset_in_section;
@ -2450,7 +2450,7 @@ Output_section::add_input_section(Layout* layout,
&& (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;
@ -2467,13 +2467,13 @@ Output_section::add_input_section(Layout* layout,
// 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
@ -2496,15 +2496,15 @@ Output_section::add_input_section(Layout* layout,
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));
{
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();
}
}
{
isecn.set_section_order_index(section_order_index);
this->set_input_section_order_specified();
}
}
this->input_sections_.push_back(isecn);
}
@ -2573,12 +2573,12 @@ Output_section::add_relaxed_input_section(Layout* layout,
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);
@ -3127,7 +3127,7 @@ Output_section::set_final_data_size()
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;
@ -3215,7 +3215,7 @@ class Output_section::Input_section_sort_entry
|| 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
@ -3323,10 +3323,10 @@ class Output_section::Input_section_sort_entry
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;
}
@ -3568,10 +3568,10 @@ Output_section::update_section_layout(
{
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));
@ -3579,11 +3579,11 @@ Output_section::update_section_layout(
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();
}
}
}
}
}
@ -3613,16 +3613,16 @@ Output_section::sort_attached_input_sections()
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()));
// 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());
@ -3630,14 +3630,14 @@ Output_section::sort_attached_input_sections()
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.
@ -4299,8 +4299,9 @@ Output_segment::has_dynamic_reloc_list(const Output_data_list* pdl) const
// 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,
@ -4439,6 +4440,41 @@ Output_segment::set_section_addresses(Layout* layout, bool reset,
// 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;
}
@ -4447,10 +4483,10 @@ Output_segment::set_section_addresses(Layout* layout, bool reset,
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
@ -4469,40 +4505,40 @@ Output_segment::set_section_list_addresses(Layout* layout, bool reset,
// the section will most likely already have an address.
if (!(*p)->is_address_valid())
{
uint64_t align = (*p)->addralign();
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;
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 = 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;
}
}
*in_tls = false;
}
}
if (!parameters->incremental_update())
{
@ -4516,12 +4552,12 @@ Output_segment::set_section_list_addresses(Layout* layout, bool reset,
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)
{
@ -4533,11 +4569,11 @@ Output_segment::set_section_list_addresses(Layout* layout, bool reset,
}
}
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
@ -4587,7 +4623,7 @@ Output_segment::set_section_list_addresses(Layout* layout, bool reset,
off += (*p)->data_size();
if (off > maxoff)
maxoff = off;
maxoff = off;
if ((*p)->is_section())
{
@ -5184,8 +5220,8 @@ Output_file::map()
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.
@ -5217,19 +5253,19 @@ Output_file::close()
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();

5
gold/output.h
View File

@ -1,6 +1,7 @@
// output.h -- manage the output file for gold -*- C++ -*-
// Copyright 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
// Copyright 2006, 2007, 2008, 2009, 2010, 2011, 2013
// Free Software Foundation, Inc.
// Written by Ian Lance Taylor <iant@google.com>.
// This file is part of gold.
@ -4596,7 +4597,7 @@ class Output_segment
// address of the immediately following segment. Update *POFF and
// *PSHNDX. This should only be called for a PT_LOAD segment.
uint64_t
set_section_addresses(Layout*, bool reset, uint64_t addr,
set_section_addresses(const Target*, Layout*, bool reset, uint64_t addr,
unsigned int* increase_relro, bool* has_relro,
off_t* poff, unsigned int* pshndx);