// 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.
os->set_needs_symtab_index();
}
-// An absolute relocation.
+// An absolute or relative relocation.
template<bool dynamic, int size, bool big_endian>
Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
unsigned int type,
Output_data* od,
- Address address)
+ Address address,
+ bool is_relative)
: address_(address), local_sym_index_(0), type_(type),
- is_relative_(false), is_symbolless_(false),
+ is_relative_(is_relative), is_symbolless_(false),
is_section_symbol_(false), 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_(0), type_(type),
- is_relative_(false), is_symbolless_(false),
+ is_relative_(is_relative), is_symbolless_(false),
is_section_symbol_(false), 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);
if (this->use_plt_offset_ && sym->has_plt_offset())
- {
- uint64_t plt_address =
- parameters->target().plt_address_for_global(sym);
- return plt_address + sym->plt_offset();
- }
+ return parameters->target().plt_address_for_global(sym);
else
return sym->value() + addend;
}
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(
+Output_data_got<got_size, big_endian>::Got_entry::write(
unsigned int got_indx,
unsigned char* pov) const
{
// RELATIVE relocation.
Symbol* gsym = this->u_.gsym;
if (this->use_plt_or_tls_offset_ && gsym->has_plt_offset())
- val = (parameters->target().plt_address_for_global(gsym)
- + gsym->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();
- if (this->use_plt_or_tls_offset_ && gsym->type() == elfcpp::STT_TLS)
+ 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);
}
default:
{
- const Sized_relobj_file<size, big_endian>* object
- = static_cast<Sized_relobj_file<size, big_endian>*>(this->u_.object);
+ const Relobj* object = this->u_.object;
const unsigned int lsi = this->local_sym_index_;
- bool is_tls = object->local_symbol(lsi)->is_tls_symbol();
+ bool is_tls = object->local_is_tls(lsi);
if (this->use_plt_or_tls_offset_ && !is_tls)
- {
- uint64_t plt_address =
- parameters->target().plt_address_for_local(object, lsi);
- val = plt_address + object->local_plt_offset(lsi);
- }
+ val = parameters->target().plt_address_for_local(object, lsi);
else
{
uint64_t lval = object->local_symbol_value(lsi, 0);
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>
+template<int got_size, bool big_endian>
void
-Output_data_got<size, big_endian>::add_global_with_rel(
+Output_data_got<got_size, big_endian>::add_global_with_rel(
Symbol* gsym,
unsigned int got_type,
Output_data_reloc_generic* rel_dyn,
// 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>
+template<int got_size, bool big_endian>
void
-Output_data_got<size, big_endian>::add_global_pair_with_rel(
+Output_data_got<got_size, big_endian>::add_global_pair_with_rel(
Symbol* gsym,
unsigned int got_type,
Output_data_reloc_generic* rel_dyn,
if (r_type_2 != 0)
rel_dyn->add_global_generic(gsym, r_type_2, this,
- got_offset + size / 8, 0);
+ 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(
+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(
+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>
+template<int got_size, bool big_endian>
void
-Output_data_got<size, big_endian>::add_local_with_rel(
+Output_data_got<got_size, big_endian>::add_local_with_rel(
Relobj* object,
unsigned int symndx,
unsigned int got_type,
// 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 size, bool big_endian>
+template<int got_size, bool big_endian>
void
-Output_data_got<size, big_endian>::add_local_pair_with_rel(
+Output_data_got<got_size, big_endian>::add_local_pair_with_rel(
Relobj* object,
unsigned int symndx,
unsigned int shndx,
// 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 size, bool big_endian>
+template<int got_size, bool big_endian>
void
-Output_data_got<size, big_endian>::add_local_tls_pair(
+Output_data_got<got_size, big_endian>::add_local_tls_pair(
Relobj* object,
unsigned int symndx,
unsigned int got_type,
// 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,
Relobj* object,
unsigned int sym_index,
// 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)
// 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();
// 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 size, bool big_endian>
+template<int got_size, bool big_endian>
void
-Output_data_got<size, big_endian>::replace_got_entry(
+Output_data_got<got_size, big_endian>::replace_got_entry(
unsigned int i,
Got_entry got_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);
}
}
// 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())
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_)
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