// reloc.h -- relocate input files for gold -*- C++ -*-
-// Copyright 2006, 2007 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.
#ifndef GOLD_RELOC_H
#define GOLD_RELOC_H
+#include <vector>
+#ifdef HAVE_BYTESWAP_H
#include <byteswap.h>
+#endif
#include "elfcpp.h"
#include "workqueue.h"
{
class General_options;
+class Object;
class Relobj;
-class Read_relocs_data;
+struct Read_relocs_data;
class Symbol;
class Layout;
+class Output_data;
+class Output_section;
template<int size>
class Sized_symbol;
template<int size, bool big_endian>
-class Sized_relobj;
+class Sized_relobj_file;
template<int size>
class Symbol_value;
class Read_relocs : public Task
{
public:
- // SYMTAB_LOCK is used to lock the symbol table. BLOCKER should be
- // unblocked when the Scan_relocs task completes.
- Read_relocs(const General_options& options, Symbol_table* symtab,
- Layout* layout, Relobj* object, Task_token* symtab_lock,
- Task_token* blocker)
- : options_(options), symtab_(symtab), layout_(layout), object_(object),
- symtab_lock_(symtab_lock), blocker_(blocker)
+ // THIS_BLOCKER and NEXT_BLOCKER are passed along to a Scan_relocs
+ // or Gc_process_relocs task, so that they run in a deterministic
+ // order.
+ Read_relocs(Symbol_table* symtab, Layout* layout, Relobj* object,
+ Task_token* this_blocker, Task_token* next_blocker)
+ : symtab_(symtab), layout_(layout), object_(object),
+ this_blocker_(this_blocker), next_blocker_(next_blocker)
{ }
// The standard Task methods.
- Is_runnable_type
- is_runnable(Workqueue*);
+ Task_token*
+ is_runnable();
- Task_locker*
- locks(Workqueue*);
+ void
+ locks(Task_locker*);
void
run(Workqueue*);
+ std::string
+ get_name() const;
+
private:
- const General_options& options_;
Symbol_table* symtab_;
Layout* layout_;
Relobj* object_;
- Task_token* symtab_lock_;
- Task_token* blocker_;
+ Task_token* this_blocker_;
+ Task_token* next_blocker_;
+};
+
+// Process the relocs to figure out which sections are garbage.
+// Very similar to scan relocs.
+
+class Gc_process_relocs : public Task
+{
+ public:
+ // THIS_BLOCKER prevents this task from running until the previous
+ // one is finished. NEXT_BLOCKER prevents the next task from
+ // running.
+ Gc_process_relocs(Symbol_table* symtab, Layout* layout, Relobj* object,
+ Read_relocs_data* rd, Task_token* this_blocker,
+ Task_token* next_blocker)
+ : symtab_(symtab), layout_(layout), object_(object), rd_(rd),
+ this_blocker_(this_blocker), next_blocker_(next_blocker)
+ { }
+
+ ~Gc_process_relocs();
+
+ // The standard Task methods.
+
+ Task_token*
+ is_runnable();
+
+ void
+ locks(Task_locker*);
+
+ void
+ run(Workqueue*);
+
+ std::string
+ get_name() const;
+
+ private:
+ Symbol_table* symtab_;
+ Layout* layout_;
+ Relobj* object_;
+ Read_relocs_data* rd_;
+ Task_token* this_blocker_;
+ Task_token* next_blocker_;
};
// Scan the relocations for an object to see if they require any
class Scan_relocs : public Task
{
public:
- // SYMTAB_LOCK is used to lock the symbol table. BLOCKER should be
- // unblocked when the task completes.
- Scan_relocs(const General_options& options, Symbol_table* symtab,
- Layout* layout, Relobj* object, Read_relocs_data* rd,
- Task_token* symtab_lock, Task_token* blocker)
- : options_(options), symtab_(symtab), layout_(layout), object_(object),
- rd_(rd), symtab_lock_(symtab_lock), blocker_(blocker)
+ // THIS_BLOCKER prevents this task from running until the previous
+ // one is finished. NEXT_BLOCKER prevents the next task from
+ // running.
+ Scan_relocs(Symbol_table* symtab, Layout* layout, Relobj* object,
+ Read_relocs_data* rd, Task_token* this_blocker,
+ Task_token* next_blocker)
+ : symtab_(symtab), layout_(layout), object_(object), rd_(rd),
+ this_blocker_(this_blocker), next_blocker_(next_blocker)
{ }
+ ~Scan_relocs();
+
// The standard Task methods.
- Is_runnable_type
- is_runnable(Workqueue*);
+ Task_token*
+ is_runnable();
- Task_locker*
- locks(Workqueue*);
+ void
+ locks(Task_locker*);
void
run(Workqueue*);
- private:
- class Scan_relocs_locker;
+ std::string
+ get_name() const;
- const General_options& options_;
+ private:
Symbol_table* symtab_;
Layout* layout_;
Relobj* object_;
Read_relocs_data* rd_;
- Task_token* symtab_lock_;
- Task_token* blocker_;
+ Task_token* this_blocker_;
+ Task_token* next_blocker_;
};
// A class to perform all the relocations for an object file.
class Relocate_task : public Task
{
public:
- Relocate_task(const General_options& options, const Symbol_table* symtab,
- const Layout* layout, Relobj* object, Output_file* of,
+ Relocate_task(const Symbol_table* symtab, const Layout* layout,
+ Relobj* object, Output_file* of,
Task_token* input_sections_blocker,
Task_token* output_sections_blocker, Task_token* final_blocker)
- : options_(options), symtab_(symtab), layout_(layout), object_(object),
- of_(of), input_sections_blocker_(input_sections_blocker),
+ : symtab_(symtab), layout_(layout), object_(object), of_(of),
+ input_sections_blocker_(input_sections_blocker),
output_sections_blocker_(output_sections_blocker),
final_blocker_(final_blocker)
{ }
// The standard Task methods.
- Is_runnable_type
- is_runnable(Workqueue*);
+ Task_token*
+ is_runnable();
- Task_locker*
- locks(Workqueue*);
+ void
+ locks(Task_locker*);
void
run(Workqueue*);
- private:
- class Relocate_locker;
+ std::string
+ get_name() const;
- const General_options& options_;
+ private:
const Symbol_table* symtab_;
const Layout* layout_;
Relobj* object_;
Task_token* final_blocker_;
};
+// During a relocatable link, this class records how relocations
+// should be handled for a single input reloc section. An instance of
+// this class is created while scanning relocs, and it is used while
+// processing relocs.
+
+class Relocatable_relocs
+{
+ public:
+ // We use a vector of unsigned char to indicate how the input relocs
+ // should be handled. Each element is one of the following values.
+ // We create this vector when we initially scan the relocations.
+ enum Reloc_strategy
+ {
+ // Copy the input reloc. Don't modify it other than updating the
+ // r_offset field and the r_sym part of the r_info field.
+ RELOC_COPY,
+ // Copy the input reloc which is against an STT_SECTION symbol.
+ // Update the r_offset and r_sym part of the r_info field. Adjust
+ // the addend by subtracting the value of the old local symbol and
+ // adding the value of the new local symbol. The addend is in the
+ // SHT_RELA reloc and the contents of the data section do not need
+ // to be changed.
+ RELOC_ADJUST_FOR_SECTION_RELA,
+ // Like RELOC_ADJUST_FOR_SECTION_RELA but the addend should not be
+ // adjusted.
+ RELOC_ADJUST_FOR_SECTION_0,
+ // Like RELOC_ADJUST_FOR_SECTION_RELA but the contents of the
+ // section need to be changed. The number indicates the number of
+ // bytes in the addend in the section contents.
+ RELOC_ADJUST_FOR_SECTION_1,
+ RELOC_ADJUST_FOR_SECTION_2,
+ RELOC_ADJUST_FOR_SECTION_4,
+ RELOC_ADJUST_FOR_SECTION_8,
+ // Like RELOC_ADJUST_FOR_SECTION_4 but for unaligned relocs.
+ RELOC_ADJUST_FOR_SECTION_4_UNALIGNED,
+ // Discard the input reloc--process it completely when relocating
+ // the data section contents.
+ RELOC_DISCARD,
+ // An input reloc which is not discarded, but which requires
+ // target specific processing in order to update it.
+ RELOC_SPECIAL
+ };
+
+ Relocatable_relocs()
+ : reloc_strategies_(), output_reloc_count_(0), posd_(NULL)
+ { }
+
+ // Record the number of relocs.
+ void
+ set_reloc_count(size_t reloc_count)
+ { this->reloc_strategies_.reserve(reloc_count); }
+
+ // Record what to do for the next reloc.
+ void
+ set_next_reloc_strategy(Reloc_strategy strategy)
+ {
+ this->reloc_strategies_.push_back(static_cast<unsigned char>(strategy));
+ if (strategy != RELOC_DISCARD)
+ ++this->output_reloc_count_;
+ }
+
+ // Record the Output_data associated with this reloc section.
+ void
+ set_output_data(Output_data* posd)
+ {
+ gold_assert(this->posd_ == NULL);
+ this->posd_ = posd;
+ }
+
+ // Return the Output_data associated with this reloc section.
+ Output_data*
+ output_data() const
+ { return this->posd_; }
+
+ // Return what to do for reloc I.
+ Reloc_strategy
+ strategy(unsigned int i) const
+ {
+ gold_assert(i < this->reloc_strategies_.size());
+ return static_cast<Reloc_strategy>(this->reloc_strategies_[i]);
+ }
+
+ // Return the number of relocations to create in the output file.
+ size_t
+ output_reloc_count() const
+ { return this->output_reloc_count_; }
+
+ private:
+ typedef std::vector<unsigned char> Reloc_strategies;
+
+ // The strategies for the input reloc. There is one entry in this
+ // vector for each relocation in the input section.
+ Reloc_strategies reloc_strategies_;
+ // The number of relocations to be created in the output file.
+ size_t output_reloc_count_;
+ // The output data structure associated with this relocation.
+ Output_data* posd_;
+};
+
// Standard relocation routines which are used on many targets. Here
// SIZE and BIG_ENDIAN refer to the target, not the relocation type.
elfcpp::Swap<valsize, big_endian>::writeval(wv, x + value);
}
+ // Like the above but for relocs at unaligned addresses.
+ template<int valsize>
+ static inline void
+ rel_unaligned(unsigned char* view,
+ typename elfcpp::Swap<valsize, big_endian>::Valtype value)
+ {
+ typedef typename elfcpp::Swap_unaligned<valsize, big_endian>::Valtype
+ Valtype;
+ Valtype x = elfcpp::Swap_unaligned<valsize, big_endian>::readval(view);
+ elfcpp::Swap_unaligned<valsize, big_endian>::writeval(view, x + value);
+ }
+
// Do a simple relocation using a Symbol_value with the addend in
// the section contents. VALSIZE is the size of the value to
// relocate.
template<int valsize>
static inline void
rel(unsigned char* view,
- const Sized_relobj<size, big_endian>* object,
+ const Sized_relobj_file<size, big_endian>* object,
const Symbol_value<size>* psymval)
{
typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
elfcpp::Swap<valsize, big_endian>::writeval(wv, x);
}
+ // Like the above but for relocs at unaligned addresses.
+ template<int valsize>
+ static inline void
+ rel_unaligned(unsigned char* view,
+ const Sized_relobj_file<size, big_endian>* object,
+ const Symbol_value<size>* psymval)
+ {
+ typedef typename elfcpp::Swap_unaligned<valsize, big_endian>::Valtype
+ Valtype;
+ Valtype x = elfcpp::Swap_unaligned<valsize, big_endian>::readval(view);
+ x = psymval->value(object, x);
+ elfcpp::Swap_unaligned<valsize, big_endian>::writeval(view, x);
+ }
+
// Do a simple relocation with the addend in the relocation.
// VALSIZE is the size of the value.
template<int valsize>
template<int valsize>
static inline void
rela(unsigned char* view,
- const Sized_relobj<size, big_endian>* object,
+ const Sized_relobj_file<size, big_endian>* object,
const Symbol_value<size>* psymval,
typename elfcpp::Swap<valsize, big_endian>::Valtype addend)
{
elfcpp::Swap<valsize, big_endian>::writeval(wv, x + value - address);
}
+ // Like the above but for relocs at unaligned addresses.
+ template<int valsize>
+ static inline void
+ pcrel_unaligned(unsigned char* view,
+ typename elfcpp::Swap<valsize, big_endian>::Valtype value,
+ typename elfcpp::Elf_types<size>::Elf_Addr address)
+ {
+ typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
+ Valtype x = elfcpp::Swap_unaligned<valsize, big_endian>::readval(view);
+ elfcpp::Swap_unaligned<valsize, big_endian>::writeval(view,
+ x + value - address);
+ }
+
// Do a simple PC relative relocation with a Symbol_value with the
// addend in the section contents. VALSIZE is the size of the
// value.
template<int valsize>
static inline void
pcrel(unsigned char* view,
- const Sized_relobj<size, big_endian>* object,
+ const Sized_relobj_file<size, big_endian>* object,
const Symbol_value<size>* psymval,
typename elfcpp::Elf_types<size>::Elf_Addr address)
{
template<int valsize>
static inline void
pcrela(unsigned char* view,
- const Sized_relobj<size, big_endian>* object,
+ const Sized_relobj_file<size, big_endian>* object,
const Symbol_value<size>* psymval,
typename elfcpp::Swap<valsize, big_endian>::Valtype addend,
typename elfcpp::Elf_types<size>::Elf_Addr address)
static inline void
rel8(unsigned char* view,
- const Sized_relobj<size, big_endian>* object,
+ const Sized_relobj_file<size, big_endian>* object,
const Symbol_value<size>* psymval)
{ This::template rel<8>(view, object, psymval); }
static inline void
rela8(unsigned char* view,
- const Sized_relobj<size, big_endian>* object,
+ const Sized_relobj_file<size, big_endian>* object,
const Symbol_value<size>* psymval,
unsigned char addend)
{ This::template rela<8>(view, object, psymval, addend); }
static inline void
pcrel8(unsigned char* view,
- const Sized_relobj<size, big_endian>* object,
+ const Sized_relobj_file<size, big_endian>* object,
const Symbol_value<size>* psymval,
typename elfcpp::Elf_types<size>::Elf_Addr address)
{ This::template pcrel<8>(view, object, psymval, address); }
static inline void
pcrela8(unsigned char* view,
- const Sized_relobj<size, big_endian>* object,
+ const Sized_relobj_file<size, big_endian>* object,
const Symbol_value<size>* psymval,
unsigned char addend,
typename elfcpp::Elf_types<size>::Elf_Addr address)
static inline void
rel16(unsigned char* view,
- const Sized_relobj<size, big_endian>* object,
+ const Sized_relobj_file<size, big_endian>* object,
const Symbol_value<size>* psymval)
{ This::template rel<16>(view, object, psymval); }
static inline void
rela16(unsigned char* view,
- const Sized_relobj<size, big_endian>* object,
+ const Sized_relobj_file<size, big_endian>* object,
const Symbol_value<size>* psymval,
elfcpp::Elf_Half addend)
{ This::template rela<16>(view, object, psymval, addend); }
static inline void
pcrel16(unsigned char* view,
- const Sized_relobj<size, big_endian>* object,
+ const Sized_relobj_file<size, big_endian>* object,
const Symbol_value<size>* psymval,
typename elfcpp::Elf_types<size>::Elf_Addr address)
{ This::template pcrel<16>(view, object, psymval, address); }
static inline void
pcrela16(unsigned char* view,
- const Sized_relobj<size, big_endian>* object,
+ const Sized_relobj_file<size, big_endian>* object,
const Symbol_value<size>* psymval,
elfcpp::Elf_Half addend,
typename elfcpp::Elf_types<size>::Elf_Addr address)
rel32(unsigned char* view, elfcpp::Elf_Word value)
{ This::template rel<32>(view, value); }
+ // Like above but for relocs at unaligned addresses.
+ static inline void
+ rel32_unaligned(unsigned char* view, elfcpp::Elf_Word value)
+ { This::template rel_unaligned<32>(view, value); }
+
static inline void
rel32(unsigned char* view,
- const Sized_relobj<size, big_endian>* object,
+ const Sized_relobj_file<size, big_endian>* object,
const Symbol_value<size>* psymval)
{ This::template rel<32>(view, object, psymval); }
+ // Like above but for relocs at unaligned addresses.
+ static inline void
+ rel32_unaligned(unsigned char* view,
+ const Sized_relobj_file<size, big_endian>* object,
+ const Symbol_value<size>* psymval)
+ { This::template rel_unaligned<32>(view, object, psymval); }
+
// Do an 32-bit RELA relocation with the addend in the relocation.
static inline void
rela32(unsigned char* view, elfcpp::Elf_Word value, elfcpp::Elf_Word addend)
static inline void
rela32(unsigned char* view,
- const Sized_relobj<size, big_endian>* object,
+ const Sized_relobj_file<size, big_endian>* object,
const Symbol_value<size>* psymval,
elfcpp::Elf_Word addend)
{ This::template rela<32>(view, object, psymval, addend); }
typename elfcpp::Elf_types<size>::Elf_Addr address)
{ This::template pcrel<32>(view, value, address); }
+ // Unaligned version of the above.
+ static inline void
+ pcrel32_unaligned(unsigned char* view, elfcpp::Elf_Word value,
+ typename elfcpp::Elf_types<size>::Elf_Addr address)
+ { This::template pcrel_unaligned<32>(view, value, address); }
+
static inline void
pcrel32(unsigned char* view,
- const Sized_relobj<size, big_endian>* object,
+ const Sized_relobj_file<size, big_endian>* object,
const Symbol_value<size>* psymval,
typename elfcpp::Elf_types<size>::Elf_Addr address)
{ This::template pcrel<32>(view, object, psymval, address); }
static inline void
pcrela32(unsigned char* view,
- const Sized_relobj<size, big_endian>* object,
+ const Sized_relobj_file<size, big_endian>* object,
const Symbol_value<size>* psymval,
elfcpp::Elf_Word addend,
typename elfcpp::Elf_types<size>::Elf_Addr address)
static inline void
rel64(unsigned char* view,
- const Sized_relobj<size, big_endian>* object,
+ const Sized_relobj_file<size, big_endian>* object,
const Symbol_value<size>* psymval)
{ This::template rel<64>(view, object, psymval); }
static inline void
rela64(unsigned char* view,
- const Sized_relobj<size, big_endian>* object,
+ const Sized_relobj_file<size, big_endian>* object,
const Symbol_value<size>* psymval,
elfcpp::Elf_Xword addend)
{ This::template rela<64>(view, object, psymval, addend); }
static inline void
pcrel64(unsigned char* view,
- const Sized_relobj<size, big_endian>* object,
+ const Sized_relobj_file<size, big_endian>* object,
const Symbol_value<size>* psymval,
typename elfcpp::Elf_types<size>::Elf_Addr address)
{ This::template pcrel<64>(view, object, psymval, address); }
static inline void
pcrela64(unsigned char* view,
- const Sized_relobj<size, big_endian>* object,
+ const Sized_relobj_file<size, big_endian>* object,
const Symbol_value<size>* psymval,
elfcpp::Elf_Xword addend,
typename elfcpp::Elf_types<size>::Elf_Addr address)
{ This::template pcrela<64>(view, object, psymval, addend, address); }
};
-// We try to avoid COPY relocations when possible. A COPY relocation
-// may be required when an executable refers to a variable defined in
-// a shared library. COPY relocations are problematic because they
-// tie the executable to the exact size of the variable in the shared
-// library. We can avoid them if all the references to the variable
-// are in a writeable section. In that case we can simply use dynamic
-// relocations. However, when scanning relocs, we don't know when we
-// see the relocation whether we will be forced to use a COPY
-// relocation or not. So we have to save the relocation during the
-// reloc scanning, and then emit it as a dynamic relocation if
-// necessary. This class implements that. It is used by the target
-// specific code.
+// Integer manipulation functions used by various targets when
+// performing relocations.
-template<int size, bool big_endian>
-class Copy_relocs
+template<int bits>
+class Bits
{
public:
- Copy_relocs()
- : entries_()
- { }
-
- // Return whether we need a COPY reloc for a reloc against GSYM,
- // which is being applied to section SHNDX in OBJECT.
- static bool
- need_copy_reloc(const General_options*, Relobj* object, unsigned int shndx,
- Sized_symbol<size>* gsym);
-
- // Save a Rel against SYM for possible emission later. SHNDX is the
- // index of the section to which the reloc is being applied.
- void
- save(Symbol* sym, Relobj*, unsigned int shndx,
- const elfcpp::Rel<size, big_endian>&);
-
- // Save a Rela against SYM for possible emission later.
- void
- save(Symbol* sym, Relobj*, unsigned int shndx,
- const elfcpp::Rela<size, big_endian>&);
+ // Sign extend an n-bit unsigned integer stored in a uint32_t into
+ // an int32_t. BITS must be between 1 and 32.
+ static inline int32_t
+ sign_extend32(uint32_t val)
+ {
+ gold_assert(bits > 0 && bits <= 32);
+ if (bits == 32)
+ return static_cast<int32_t>(val);
+ uint32_t mask = (~static_cast<uint32_t>(0)) >> (32 - bits);
+ val &= mask;
+ uint32_t top_bit = 1U << (bits - 1);
+ int32_t as_signed = static_cast<int32_t>(val);
+ if ((val & top_bit) != 0)
+ as_signed -= static_cast<int32_t>(top_bit * 2);
+ return as_signed;
+ }
- // Return whether there are any relocs to emit. This also discards
- // entries which need not be emitted.
- bool
- any_to_emit();
+ // Return true if VAL (stored in a uint32_t) has overflowed a signed
+ // value with BITS bits.
+ static inline bool
+ has_overflow32(uint32_t val)
+ {
+ gold_assert(bits > 0 && bits <= 32);
+ if (bits == 32)
+ return false;
+ int32_t max = (1 << (bits - 1)) - 1;
+ int32_t min = -(1 << (bits - 1));
+ int32_t as_signed = static_cast<int32_t>(val);
+ return as_signed > max || as_signed < min;
+ }
- // Emit relocs for each symbol which did not get a COPY reloc (i.e.,
- // is still defined in the dynamic object).
- template<int sh_type>
- void
- emit(Output_data_reloc<sh_type, true, size, big_endian>*);
+ // Return true if VAL (stored in a uint32_t) has overflowed both a
+ // signed and an unsigned value. E.g.,
+ // Bits<8>::has_signed_unsigned_overflow32 would check -128 <= VAL <
+ // 255.
+ static inline bool
+ has_signed_unsigned_overflow32(uint32_t val)
+ {
+ gold_assert(bits > 0 && bits <= 32);
+ if (bits == 32)
+ return false;
+ int32_t max = static_cast<int32_t>((1U << bits) - 1);
+ int32_t min = -(1 << (bits - 1));
+ int32_t as_signed = static_cast<int32_t>(val);
+ return as_signed > max || as_signed < min;
+ }
- private:
- typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
- typedef typename elfcpp::Elf_types<size>::Elf_Addr Addend;
+ // Select bits from A and B using bits in MASK. For each n in
+ // [0..31], the n-th bit in the result is chosen from the n-th bits
+ // of A and B. A zero selects A and a one selects B.
+ static inline uint32_t
+ bit_select32(uint32_t a, uint32_t b, uint32_t mask)
+ { return (a & ~mask) | (b & mask); }
+
+ // Sign extend an n-bit unsigned integer stored in a uint64_t into
+ // an int64_t. BITS must be between 1 and 64.
+ static inline int64_t
+ sign_extend(uint64_t val)
+ {
+ gold_assert(bits > 0 && bits <= 64);
+ if (bits == 64)
+ return static_cast<int64_t>(val);
+ uint64_t mask = (~static_cast<uint64_t>(0)) >> (64 - bits);
+ val &= mask;
+ uint64_t top_bit = static_cast<uint64_t>(1) << (bits - 1);
+ int64_t as_signed = static_cast<int64_t>(val);
+ if ((val & top_bit) != 0)
+ as_signed -= static_cast<int64_t>(top_bit * 2);
+ return as_signed;
+ }
- // This POD class holds the entries we are saving.
- class Copy_reloc_entry
+ // Return true if VAL (stored in a uint64_t) has overflowed a signed
+ // value with BITS bits.
+ static inline bool
+ has_overflow(uint64_t val)
{
- public:
- Copy_reloc_entry(Symbol* sym, unsigned int reloc_type,
- Relobj* relobj, unsigned int shndx,
- Address address, Addend addend)
- : sym_(sym), reloc_type_(reloc_type), relobj_(relobj),
- shndx_(shndx), address_(address), addend_(addend)
- { }
-
- // Return whether we should emit this reloc. If we should not
- // emit, we clear it.
- bool
- should_emit();
-
- // Emit this reloc.
-
- void
- emit(Output_data_reloc<elfcpp::SHT_REL, true, size, big_endian>*);
-
- void
- emit(Output_data_reloc<elfcpp::SHT_RELA, true, size, big_endian>*);
-
- private:
- Symbol* sym_;
- unsigned int reloc_type_;
- Relobj* relobj_;
- unsigned int shndx_;
- Address address_;
- Addend addend_;
- };
+ gold_assert(bits > 0 && bits <= 64);
+ if (bits == 64)
+ return false;
+ int64_t max = (static_cast<int64_t>(1) << (bits - 1)) - 1;
+ int64_t min = -(static_cast<int64_t>(1) << (bits - 1));
+ int64_t as_signed = static_cast<int64_t>(val);
+ return as_signed > max || as_signed < min;
+ }
- // A list of relocs to be saved.
- typedef std::vector<Copy_reloc_entry> Copy_reloc_entries;
+ // Return true if VAL (stored in a uint64_t) has overflowed both a
+ // signed and an unsigned value. E.g.,
+ // Bits<8>::has_signed_unsigned_overflow would check -128 <= VAL <
+ // 255.
+ static inline bool
+ has_signed_unsigned_overflow64(uint64_t val)
+ {
+ gold_assert(bits > 0 && bits <= 64);
+ if (bits == 64)
+ return false;
+ int64_t max = static_cast<int64_t>((static_cast<uint64_t>(1) << bits) - 1);
+ int64_t min = -(static_cast<int64_t>(1) << (bits - 1));
+ int64_t as_signed = static_cast<int64_t>(val);
+ return as_signed > max || as_signed < min;
+ }
- // The list of relocs we are saving.
- Copy_reloc_entries entries_;
+ // Select bits from A and B using bits in MASK. For each n in
+ // [0..31], the n-th bit in the result is chosen from the n-th bits
+ // of A and B. A zero selects A and a one selects B.
+ static inline uint64_t
+ bit_select64(uint64_t a, uint64_t b, uint64_t mask)
+ { return (a & ~mask) | (b & mask); }
};
// Track relocations while reading a section. This lets you ask for
{
public:
Track_relocs()
- : object_(NULL), prelocs_(NULL), len_(0), pos_(0), reloc_size_(0)
+ : prelocs_(NULL), len_(0), pos_(0), reloc_size_(0)
{ }
// Initialize the Track_relocs object. OBJECT is the object holding
// (elfcpp::SHT_REL or elfcpp::SHT_RELA). This returns false if
// something went wrong.
bool
- initialize(Sized_relobj<size, big_endian>* object, unsigned int reloc_shndx,
+ initialize(Object* object, unsigned int reloc_shndx,
unsigned int reloc_type);
// Return the offset in the data section to which the next reloc
- // applies. THis returns -1 if there is no next reloc.
+ // applies. This returns -1 if there is no next reloc.
off_t
next_offset() const;
unsigned int
next_symndx() const;
+ // Return the addend of the next reloc. This returns 0 if there is
+ // no next reloc.
+ uint64_t
+ next_addend() const;
+
// Advance to OFFSET within the data section, and return the number
// of relocs which would be skipped.
int
advance(off_t offset);
+ // Checkpoint the current position in the reloc section.
+ section_size_type
+ checkpoint() const
+ { return this->pos_; }
+
+ // Reset the position to CHECKPOINT.
+ void
+ reset(section_size_type checkpoint)
+ { this->pos_ = checkpoint; }
+
private:
- // The object file.
- Sized_relobj<size, big_endian>* object_;
- // The contents of the reloc section.
+ // The contents of the input object's reloc section.
const unsigned char* prelocs_;
// The length of the reloc section.
- off_t len_;
+ section_size_type len_;
// Our current position in the reloc section.
- off_t pos_;
+ section_size_type pos_;
// The size of the relocs in the section.
int reloc_size_;
};