// output.cc -- manage the output file for gold
-// Copyright 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
+// Copyright 2006, 2007, 2008, 2009, 2010, 2011, 2012
+// Free Software Foundation, Inc.
// Written by Ian Lance Taylor <iant@google.com>.
// This file is part of gold.
# define MREMAP_MAYMOVE 1
#endif
-#ifndef HAVE_POSIX_FALLOCATE
-// A dummy, non general, version of posix_fallocate. Here we just set
-// the file size and hope that there is enough disk space. FIXME: We
-// could allocate disk space by walking block by block and writing a
-// zero byte into each block.
-static int
-posix_fallocate(int o, off_t offset, off_t len)
-{
- if (ftruncate(o, offset + len) < 0)
- return errno;
- return 0;
-}
-#endif // !defined(HAVE_POSIX_FALLOCATE)
-
// Mingw does not have S_ISLNK.
#ifndef S_ISLNK
# define S_ISLNK(mode) 0
namespace gold
{
+// A wrapper around posix_fallocate. If we don't have posix_fallocate,
+// or the --no-posix-fallocate option is set, we try the fallocate
+// system call directly. If that fails, we use ftruncate to set
+// the file size and hope that there is enough disk space.
+
+static int
+gold_fallocate(int o, off_t offset, off_t len)
+{
+#ifdef HAVE_POSIX_FALLOCATE
+ if (parameters->options().posix_fallocate())
+ return ::posix_fallocate(o, offset, len);
+#endif // defined(HAVE_POSIX_FALLOCATE)
+#ifdef HAVE_FALLOCATE
+ if (::fallocate(o, 0, offset, len) == 0)
+ return 0;
+#endif // defined(HAVE_FALLOCATE)
+ if (::ftruncate(o, offset + len) < 0)
+ return errno;
+ return 0;
+}
+
// Output_data variables.
bool Output_data::allocated_sizes_are_fixed;
Output_data* od,
Address address,
bool is_relative,
- bool is_symbolless)
+ bool is_symbolless,
+ bool use_plt_offset)
: address_(address), local_sym_index_(GSYM_CODE), type_(type),
is_relative_(is_relative), is_symbolless_(is_symbolless),
- is_section_symbol_(false), use_plt_offset_(false), shndx_(INVALID_CODE)
+ is_section_symbol_(false), use_plt_offset_(use_plt_offset), shndx_(INVALID_CODE)
{
// this->type_ is a bitfield; make sure TYPE fits.
gold_assert(this->type_ == type);
unsigned int shndx,
Address address,
bool is_relative,
- bool is_symbolless)
+ bool is_symbolless,
+ bool use_plt_offset)
: address_(address), local_sym_index_(GSYM_CODE), type_(type),
is_relative_(is_relative), is_symbolless_(is_symbolless),
- is_section_symbol_(false), use_plt_offset_(false), shndx_(shndx)
+ is_section_symbol_(false), use_plt_offset_(use_plt_offset), shndx_(shndx)
{
gold_assert(shndx != INVALID_CODE);
// this->type_ is a bitfield; make sure TYPE fits.
Output_section* os,
unsigned int type,
Output_data* od,
- Address address)
+ Address address,
+ bool is_relative)
: address_(address), local_sym_index_(SECTION_CODE), type_(type),
- is_relative_(false), is_symbolless_(false),
+ is_relative_(is_relative), is_symbolless_(is_relative),
is_section_symbol_(true), use_plt_offset_(false), shndx_(INVALID_CODE)
{
// this->type_ is a bitfield; make sure TYPE fits.
unsigned int type,
Sized_relobj<size, big_endian>* relobj,
unsigned int shndx,
- Address address)
+ Address address,
+ bool is_relative)
: address_(address), local_sym_index_(SECTION_CODE), type_(type),
- is_relative_(false), is_symbolless_(false),
+ is_relative_(is_relative), is_symbolless_(is_relative),
is_section_symbol_(true), use_plt_offset_(false), shndx_(shndx)
{
gold_assert(shndx != INVALID_CODE);
{
const Sized_symbol<size>* sym;
sym = static_cast<const Sized_symbol<size>*>(this->u1_.gsym);
- return sym->value() + addend;
+ if (this->use_plt_offset_ && sym->has_plt_offset())
+ return parameters->target().plt_address_for_global(sym);
+ else
+ return sym->value() + addend;
}
- gold_assert(this->local_sym_index_ != SECTION_CODE
- && this->local_sym_index_ != TARGET_CODE
+ if (this->local_sym_index_ == SECTION_CODE)
+ {
+ gold_assert(!this->use_plt_offset_);
+ return this->u1_.os->address() + addend;
+ }
+ gold_assert(this->local_sym_index_ != TARGET_CODE
&& this->local_sym_index_ != INVALID_CODE
&& this->local_sym_index_ != 0
&& !this->is_section_symbol_);
this->u1_.relobj->sized_relobj();
gold_assert(relobj != NULL);
if (this->use_plt_offset_)
- {
- uint64_t plt_address =
- parameters->target().plt_address_for_local(relobj, lsi);
- return plt_address + relobj->local_plt_offset(lsi);
- }
+ return parameters->target().plt_address_for_local(relobj, lsi);
const Symbol_value<size>* symval = relobj->local_symbol(lsi);
return symval->value(relobj, addend);
}
// Write out the entry.
-template<int size, bool big_endian>
+template<int got_size, bool big_endian>
void
-Output_data_got<size, big_endian>::Got_entry::write(unsigned char* pov) const
+Output_data_got<got_size, big_endian>::Got_entry::write(
+ unsigned int got_indx,
+ unsigned char* pov) const
{
Valtype val = 0;
// link-time value, which will be relocated dynamically by a
// RELATIVE relocation.
Symbol* gsym = this->u_.gsym;
- if (this->use_plt_offset_ && gsym->has_plt_offset())
- val = (parameters->target().plt_address_for_global(gsym)
- + gsym->plt_offset());
+ if (this->use_plt_or_tls_offset_ && gsym->has_plt_offset())
+ val = parameters->target().plt_address_for_global(gsym);
else
{
- Sized_symbol<size>* sgsym;
- // This cast is a bit ugly. We don't want to put a
- // virtual method in Symbol, because we want Symbol to be
- // as small as possible.
- sgsym = static_cast<Sized_symbol<size>*>(gsym);
- val = sgsym->value();
+ switch (parameters->size_and_endianness())
+ {
+#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
+ case Parameters::TARGET_32_LITTLE:
+ case Parameters::TARGET_32_BIG:
+ {
+ // This cast is ugly. We don't want to put a
+ // virtual method in Symbol, because we want Symbol
+ // to be as small as possible.
+ Sized_symbol<32>::Value_type v;
+ v = static_cast<Sized_symbol<32>*>(gsym)->value();
+ val = convert_types<Valtype, Sized_symbol<32>::Value_type>(v);
+ }
+ break;
+#endif
+#if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
+ case Parameters::TARGET_64_LITTLE:
+ case Parameters::TARGET_64_BIG:
+ {
+ Sized_symbol<64>::Value_type v;
+ v = static_cast<Sized_symbol<64>*>(gsym)->value();
+ val = convert_types<Valtype, Sized_symbol<64>::Value_type>(v);
+ }
+ break;
+#endif
+ default:
+ gold_unreachable();
+ }
+ if (this->use_plt_or_tls_offset_
+ && gsym->type() == elfcpp::STT_TLS)
+ val += parameters->target().tls_offset_for_global(gsym,
+ got_indx);
}
}
break;
default:
{
- const Sized_relobj_file<size, big_endian>* object = this->u_.object;
+ const Relobj* object = this->u_.object;
const unsigned int lsi = this->local_sym_index_;
- const Symbol_value<size>* symval = object->local_symbol(lsi);
- if (!this->use_plt_offset_)
- val = symval->value(this->u_.object, 0);
+ 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);
else
{
- uint64_t plt_address =
- parameters->target().plt_address_for_local(object, lsi);
- val = plt_address + object->local_plt_offset(lsi);
+ uint64_t lval = object->local_symbol_value(lsi, 0);
+ val = convert_types<Valtype, uint64_t>(lval);
+ if (this->use_plt_or_tls_offset_ && is_tls)
+ val += parameters->target().tls_offset_for_local(object, lsi,
+ got_indx);
}
}
break;
}
- elfcpp::Swap<size, big_endian>::writeval(pov, val);
+ elfcpp::Swap<got_size, big_endian>::writeval(pov, val);
}
// Output_data_got methods.
// this is a new GOT entry, false if the symbol already had a GOT
// entry.
-template<int size, bool big_endian>
+template<int got_size, bool big_endian>
bool
-Output_data_got<size, big_endian>::add_global(
+Output_data_got<got_size, big_endian>::add_global(
Symbol* gsym,
unsigned int got_type)
{
// Like add_global, but use the PLT offset.
-template<int size, bool big_endian>
+template<int got_size, bool big_endian>
bool
-Output_data_got<size, big_endian>::add_global_plt(Symbol* gsym,
- unsigned int got_type)
+Output_data_got<got_size, big_endian>::add_global_plt(Symbol* gsym,
+ unsigned int got_type)
{
if (gsym->has_got_offset(got_type))
return false;
// Add an entry for a global symbol to the GOT, and add a dynamic
// relocation of type R_TYPE for the GOT entry.
-template<int size, bool big_endian>
-void
-Output_data_got<size, big_endian>::add_global_with_rel(
- Symbol* gsym,
- unsigned int got_type,
- Rel_dyn* rel_dyn,
- unsigned int r_type)
-{
- if (gsym->has_got_offset(got_type))
- return;
-
- unsigned int got_offset = this->add_got_entry(Got_entry());
- gsym->set_got_offset(got_type, got_offset);
- rel_dyn->add_global(gsym, r_type, this, got_offset);
-}
-
-template<int size, bool big_endian>
+template<int got_size, bool big_endian>
void
-Output_data_got<size, big_endian>::add_global_with_rela(
+Output_data_got<got_size, big_endian>::add_global_with_rel(
Symbol* gsym,
unsigned int got_type,
- Rela_dyn* rela_dyn,
+ Output_data_reloc_generic* rel_dyn,
unsigned int r_type)
{
if (gsym->has_got_offset(got_type))
unsigned int got_offset = this->add_got_entry(Got_entry());
gsym->set_got_offset(got_type, got_offset);
- rela_dyn->add_global(gsym, r_type, this, got_offset, 0);
+ rel_dyn->add_global_generic(gsym, r_type, this, got_offset, 0);
}
// Add a pair of entries for a global symbol to the GOT, and add
// dynamic relocations of type R_TYPE_1 and R_TYPE_2, respectively.
// If R_TYPE_2 == 0, add the second entry with no relocation.
-template<int size, bool big_endian>
-void
-Output_data_got<size, big_endian>::add_global_pair_with_rel(
- Symbol* gsym,
- unsigned int got_type,
- Rel_dyn* rel_dyn,
- unsigned int r_type_1,
- unsigned int r_type_2)
-{
- if (gsym->has_got_offset(got_type))
- return;
-
- unsigned int got_offset = this->add_got_entry_pair(Got_entry(), Got_entry());
- gsym->set_got_offset(got_type, got_offset);
- rel_dyn->add_global(gsym, r_type_1, this, got_offset);
-
- if (r_type_2 != 0)
- rel_dyn->add_global(gsym, r_type_2, this, got_offset + size / 8);
-}
-
-template<int size, bool big_endian>
+template<int got_size, bool big_endian>
void
-Output_data_got<size, big_endian>::add_global_pair_with_rela(
+Output_data_got<got_size, big_endian>::add_global_pair_with_rel(
Symbol* gsym,
unsigned int got_type,
- Rela_dyn* rela_dyn,
+ Output_data_reloc_generic* rel_dyn,
unsigned int r_type_1,
unsigned int r_type_2)
{
unsigned int got_offset = this->add_got_entry_pair(Got_entry(), Got_entry());
gsym->set_got_offset(got_type, got_offset);
- rela_dyn->add_global(gsym, r_type_1, this, got_offset, 0);
+ rel_dyn->add_global_generic(gsym, r_type_1, this, got_offset, 0);
if (r_type_2 != 0)
- rela_dyn->add_global(gsym, r_type_2, this, got_offset + size / 8, 0);
+ rel_dyn->add_global_generic(gsym, r_type_2, this,
+ got_offset + got_size / 8, 0);
}
// Add an entry for a local symbol to the GOT. This returns true if
// this is a new GOT entry, false if the symbol already has a GOT
// entry.
-template<int size, bool big_endian>
+template<int got_size, bool big_endian>
bool
-Output_data_got<size, big_endian>::add_local(
- Sized_relobj_file<size, big_endian>* object,
+Output_data_got<got_size, big_endian>::add_local(
+ Relobj* object,
unsigned int symndx,
unsigned int got_type)
{
// Like add_local, but use the PLT offset.
-template<int size, bool big_endian>
+template<int got_size, bool big_endian>
bool
-Output_data_got<size, big_endian>::add_local_plt(
- Sized_relobj_file<size, big_endian>* object,
+Output_data_got<got_size, big_endian>::add_local_plt(
+ Relobj* object,
unsigned int symndx,
unsigned int got_type)
{
// Add an entry for a local symbol to the GOT, and add a dynamic
// relocation of type R_TYPE for the GOT entry.
-template<int size, bool big_endian>
-void
-Output_data_got<size, big_endian>::add_local_with_rel(
- Sized_relobj_file<size, big_endian>* object,
- unsigned int symndx,
- unsigned int got_type,
- Rel_dyn* rel_dyn,
- unsigned int r_type)
-{
- if (object->local_has_got_offset(symndx, got_type))
- return;
-
- unsigned int got_offset = this->add_got_entry(Got_entry());
- object->set_local_got_offset(symndx, got_type, got_offset);
- rel_dyn->add_local(object, symndx, r_type, this, got_offset);
-}
-
-template<int size, bool big_endian>
+template<int got_size, bool big_endian>
void
-Output_data_got<size, big_endian>::add_local_with_rela(
- Sized_relobj_file<size, big_endian>* object,
+Output_data_got<got_size, big_endian>::add_local_with_rel(
+ Relobj* object,
unsigned int symndx,
unsigned int got_type,
- Rela_dyn* rela_dyn,
+ Output_data_reloc_generic* rel_dyn,
unsigned int r_type)
{
if (object->local_has_got_offset(symndx, got_type))
unsigned int got_offset = this->add_got_entry(Got_entry());
object->set_local_got_offset(symndx, got_type, got_offset);
- rela_dyn->add_local(object, symndx, r_type, this, got_offset, 0);
+ rel_dyn->add_local_generic(object, symndx, r_type, this, got_offset, 0);
}
// Add a pair of entries for a local symbol to the GOT, and add
-// dynamic relocations of type R_TYPE_1 and R_TYPE_2, respectively.
-// If R_TYPE_2 == 0, add the second entry with no relocation.
-template<int size, bool big_endian>
+// a dynamic relocation of type R_TYPE using the section symbol of
+// the output section to which input section SHNDX maps, on the first.
+// The first got entry will have a value of zero, the second the
+// value of the local symbol.
+template<int got_size, bool big_endian>
void
-Output_data_got<size, big_endian>::add_local_pair_with_rel(
- Sized_relobj_file<size, big_endian>* object,
+Output_data_got<got_size, big_endian>::add_local_pair_with_rel(
+ Relobj* object,
unsigned int symndx,
unsigned int shndx,
unsigned int got_type,
- Rel_dyn* rel_dyn,
- unsigned int r_type_1,
- unsigned int r_type_2)
+ Output_data_reloc_generic* rel_dyn,
+ unsigned int r_type)
{
if (object->local_has_got_offset(symndx, got_type))
return;
Got_entry(object, symndx, false));
object->set_local_got_offset(symndx, got_type, got_offset);
Output_section* os = object->output_section(shndx);
- rel_dyn->add_output_section(os, r_type_1, this, got_offset);
-
- if (r_type_2 != 0)
- rel_dyn->add_output_section(os, r_type_2, this, got_offset + size / 8);
+ rel_dyn->add_output_section_generic(os, r_type, this, got_offset, 0);
}
-template<int size, bool big_endian>
+// Add a pair of entries for a local symbol to the GOT, and add
+// a dynamic relocation of type R_TYPE using STN_UNDEF on the first.
+// The first got entry will have a value of zero, the second the
+// value of the local symbol offset by Target::tls_offset_for_local.
+template<int got_size, bool big_endian>
void
-Output_data_got<size, big_endian>::add_local_pair_with_rela(
- Sized_relobj_file<size, big_endian>* object,
+Output_data_got<got_size, big_endian>::add_local_tls_pair(
+ Relobj* object,
unsigned int symndx,
- unsigned int shndx,
unsigned int got_type,
- Rela_dyn* rela_dyn,
- unsigned int r_type_1,
- unsigned int r_type_2)
+ Output_data_reloc_generic* rel_dyn,
+ unsigned int r_type)
{
if (object->local_has_got_offset(symndx, got_type))
return;
- unsigned int got_offset =
- this->add_got_entry_pair(Got_entry(),
- Got_entry(object, symndx, false));
+ unsigned int got_offset
+ = this->add_got_entry_pair(Got_entry(),
+ Got_entry(object, symndx, true));
object->set_local_got_offset(symndx, got_type, got_offset);
- Output_section* os = object->output_section(shndx);
- rela_dyn->add_output_section(os, r_type_1, this, got_offset, 0);
-
- if (r_type_2 != 0)
- rela_dyn->add_output_section(os, r_type_2, this, got_offset + size / 8, 0);
+ rel_dyn->add_local_generic(object, 0, r_type, this, got_offset, 0);
}
// Reserve a slot in the GOT for a local symbol or the second slot of a pair.
-template<int size, bool big_endian>
+template<int got_size, bool big_endian>
void
-Output_data_got<size, big_endian>::reserve_local(
+Output_data_got<got_size, big_endian>::reserve_local(
unsigned int i,
- Sized_relobj<size, big_endian>* object,
+ Relobj* object,
unsigned int sym_index,
unsigned int got_type)
{
- this->reserve_slot(i);
+ this->do_reserve_slot(i);
object->set_local_got_offset(sym_index, got_type, this->got_offset(i));
}
// Reserve a slot in the GOT for a global symbol.
-template<int size, bool big_endian>
+template<int got_size, bool big_endian>
void
-Output_data_got<size, big_endian>::reserve_global(
+Output_data_got<got_size, big_endian>::reserve_global(
unsigned int i,
Symbol* gsym,
unsigned int got_type)
{
- this->reserve_slot(i);
+ this->do_reserve_slot(i);
gsym->set_got_offset(got_type, this->got_offset(i));
}
// Write out the GOT.
-template<int size, bool big_endian>
+template<int got_size, bool big_endian>
void
-Output_data_got<size, big_endian>::do_write(Output_file* of)
+Output_data_got<got_size, big_endian>::do_write(Output_file* of)
{
- const int add = size / 8;
+ const int add = got_size / 8;
const off_t off = this->offset();
const off_t oview_size = this->data_size();
unsigned char* const oview = of->get_output_view(off, oview_size);
unsigned char* pov = oview;
- for (typename Got_entries::const_iterator p = this->entries_.begin();
- p != this->entries_.end();
- ++p)
+ for (unsigned int i = 0; i < this->entries_.size(); ++i)
{
- p->write(pov);
+ this->entries_[i].write(i, pov);
pov += add;
}
// Create a new GOT entry and return its offset.
-template<int size, bool big_endian>
+template<int got_size, bool big_endian>
unsigned int
-Output_data_got<size, big_endian>::add_got_entry(Got_entry got_entry)
+Output_data_got<got_size, big_endian>::add_got_entry(Got_entry got_entry)
{
if (!this->is_data_size_valid())
{
else
{
// For an incremental update, find an available slot.
- off_t got_offset = this->free_list_.allocate(size / 8, size / 8, 0);
+ off_t got_offset = this->free_list_.allocate(got_size / 8,
+ got_size / 8, 0);
if (got_offset == -1)
gold_fallback(_("out of patch space (GOT);"
" relink with --incremental-full"));
- unsigned int got_index = got_offset / (size / 8);
+ unsigned int got_index = got_offset / (got_size / 8);
gold_assert(got_index < this->entries_.size());
this->entries_[got_index] = got_entry;
return static_cast<unsigned int>(got_offset);
// Create a pair of new GOT entries and return the offset of the first.
-template<int size, bool big_endian>
+template<int got_size, bool big_endian>
unsigned int
-Output_data_got<size, big_endian>::add_got_entry_pair(Got_entry got_entry_1,
- Got_entry got_entry_2)
+Output_data_got<got_size, big_endian>::add_got_entry_pair(
+ Got_entry got_entry_1,
+ Got_entry got_entry_2)
{
if (!this->is_data_size_valid())
{
else
{
// For an incremental update, find an available pair of slots.
- off_t got_offset = this->free_list_.allocate(2 * size / 8, size / 8, 0);
+ off_t got_offset = this->free_list_.allocate(2 * got_size / 8,
+ got_size / 8, 0);
if (got_offset == -1)
gold_fallback(_("out of patch space (GOT);"
" relink with --incremental-full"));
- unsigned int got_index = got_offset / (size / 8);
+ unsigned int got_index = got_offset / (got_size / 8);
gold_assert(got_index < this->entries_.size());
this->entries_[got_index] = got_entry_1;
this->entries_[got_index + 1] = got_entry_2;
}
}
+// Replace GOT entry I with a new value.
+
+template<int got_size, bool big_endian>
+void
+Output_data_got<got_size, big_endian>::replace_got_entry(
+ unsigned int i,
+ Got_entry got_entry)
+{
+ gold_assert(i < this->entries_.size());
+ this->entries_[i] = got_entry;
+}
+
// Output_data_dynamic::Dynamic_entry methods.
// Write out the entry.
++p)
{
unsigned int symndx = p->first;
- gold_assert(symndx * 4 < this->data_size());
+ gold_assert(static_cast<off_t>(symndx) * 4 < this->data_size());
elfcpp::Swap<32, big_endian>::writeval(oview + symndx * 4, p->second);
}
}
always_keeps_input_sections_(false),
has_fixed_layout_(false),
is_patch_space_allowed_(false),
+ is_unique_segment_(false),
tls_offset_(0),
+ extra_segment_flags_(0),
+ segment_alignment_(0),
checkpoint_(NULL),
lookup_maps_(new Output_section_lookup_maps),
free_list_(),
// For a relaxed section, we use the current data size. Linker scripts
// get all the input sections, including relaxed one from an output
- // section and add them back to them same output section to compute the
+ // section and add them back to the same output section to compute the
// output section size. If we do not account for sizes of relaxed input
- // sections, an output section would be incorrectly sized.
+ // sections, an output section would be incorrectly sized.
off_t offset_in_section = this->current_data_size_for_child();
off_t aligned_offset_in_section = align_address(offset_in_section,
poris->addralign());
(*input_sections)[p->second].set_section_order_index(soi);
}
}
-
+
// Convert regular input sections into relaxed input sections. RELAXED_SECTIONS
// is a vector of pointers to Output_relaxed_input_section or its derived
// classes. The relaxed sections must correspond to existing input sections.
// this. If there is no checkpoint active, just search the current
// input section list and replace the sections there. If there is
// a checkpoint, also replace the sections there.
-
+
// By default, we look at the whole list.
size_t limit = this->input_sections_.size();
for (Output_merge_base::Input_sections::const_iterator is =
pomb->input_sections_begin();
is != pomb->input_sections_end();
- ++is)
+ ++is)
{
const Const_section_id& csid = *is;
this->lookup_maps_->add_merge_input_section(csid.first,
csid.second, pomb);
}
-
+
}
else if (p->is_relaxed_input_section())
{
{
section_offset_type output_offset;
bool found = posd->output_offset(object, shndx, offset, &output_offset);
- gold_assert(found);
+ gold_assert(found);
return output_offset != -1;
}
// Look at the Output_section_data_maps first.
const Output_section_data* posd = this->find_merge_section(object, shndx);
- if (posd == NULL)
+ if (posd == NULL)
posd = this->find_relaxed_input_section(object, shndx);
if (posd != NULL)
{
section_offset_type output_offset;
bool found = posd->output_offset(object, shndx, offset, &output_offset);
- gold_assert(found);
+ gold_assert(found);
return output_offset;
}
// Look at the Output_section_data_maps first.
const Output_section_data* posd = this->find_merge_section(object, shndx);
- if (posd == NULL)
+ if (posd == NULL)
posd = this->find_relaxed_input_section(object, shndx);
if (posd != NULL && posd->is_address_valid())
{
// 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;
}
this->input_sections_.push_back(sis);
- // Update fast lookup maps if necessary.
+ // Update fast lookup maps if necessary.
if (this->lookup_maps_->is_valid())
{
if (sis.is_merge_section())
flags_(flags),
is_max_align_known_(false),
are_addresses_set_(false),
- is_large_data_segment_(false)
+ is_large_data_segment_(false),
+ is_unique_segment_(false)
{
// The ELF ABI specifies that a PT_TLS segment always has PF_R as
// the flags.
if (!this->is_max_align_known_)
{
for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
- {
+ {
const Output_data_list* pdl = &this->output_lists_[i];
uint64_t addralign = Output_segment::maximum_alignment_list(pdl);
if (addralign > this->max_align_)
bool in_tls = false;
// If we have relro sections, we need to pad forward now so that the
- // relro sections plus INCREASE_RELRO end on a common page boundary.
+ // relro sections plus INCREASE_RELRO end on an abi page boundary.
if (parameters->options().relro()
&& this->is_first_section_relro()
&& (!this->are_addresses_set_ || reset))
last_relro_pad = aligned_size - relro_size;
*has_relro = true;
- uint64_t page_align = parameters->target().common_pagesize();
+ uint64_t page_align = parameters->target().abi_pagesize();
// Align to offset N such that (N + RELRO_SIZE) % PAGE_ALIGN == 0.
uint64_t desired_align = page_align - (aligned_size % page_align);
// page boundary.
if (this->type_ == elfcpp::PT_GNU_RELRO)
{
- uint64_t page_align = parameters->target().common_pagesize();
+ uint64_t page_align = parameters->target().abi_pagesize();
uint64_t segment_end = this->vaddr_ + this->memsz_;
if (parameters->incremental_update())
{
(*p)->set_tls_offset(this->vaddr_);
}
-// Return the load address of the first section.
+// Return the first section.
-uint64_t
-Output_segment::first_section_load_address() const
+Output_section*
+Output_segment::first_section() const
{
for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
{
++p)
{
if ((*p)->is_section())
- return ((*p)->has_load_address()
- ? (*p)->load_address()
- : (*p)->address());
+ return (*p)->output_section();
}
}
gold_unreachable();
// but that would be a more significant performance hit.
if (writable)
{
- int err = ::posix_fallocate(o, 0, this->file_size_);
+ int err = gold_fallocate(o, 0, this->file_size_);
if (err != 0)
gold_fatal(_("%s: %s"), this->name_, strerror(err));
}
void
Output_file::map()
{
- if (this->map_no_anonymous(true))
+ if (parameters->options().mmap_output_file()
+ && this->map_no_anonymous(true))
return;
// The mmap call might fail because of file system issues: the file
class Output_data_group<64, true>;
#endif
-#ifdef HAVE_TARGET_32_LITTLE
template
class Output_data_got<32, false>;
-#endif
-#ifdef HAVE_TARGET_32_BIG
template
class Output_data_got<32, true>;
-#endif
-#ifdef HAVE_TARGET_64_LITTLE
template
class Output_data_got<64, false>;
-#endif
-#ifdef HAVE_TARGET_64_BIG
template
class Output_data_got<64, true>;
-#endif
} // End namespace gold.
projects / external / binutils.git / blobdiff