X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gold%2Freloc.h;h=da14ec1828a2c393d6109f8ed3033b8c52304133;hb=89e0345fdfad506e4692126cabd618ef859dc63f;hp=bc538c561f86d8a70445b4e7053aea47ae9ca8de;hpb=5b3463d9ee95e3b9631851ef51dd37377949b06d;p=platform%2Fupstream%2Fbinutils.git diff --git a/gold/reloc.h b/gold/reloc.h index bc538c5..da14ec1 100644 --- a/gold/reloc.h +++ b/gold/reloc.h @@ -1,6 +1,6 @@ // 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 . // This file is part of gold. @@ -23,24 +23,31 @@ #ifndef GOLD_RELOC_H #define GOLD_RELOC_H +#include +#ifdef HAVE_BYTESWAP_H #include +#endif +#include "elfcpp.h" #include "workqueue.h" namespace gold { 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 class Sized_symbol; template -class Sized_relobj; +class Sized_relobj_file; template class Symbol_value; @@ -55,33 +62,76 @@ class Output_data_reloc; 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: + Symbol_table* symtab_; + Layout* layout_; + Relobj* object_; + 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: - const General_options& options_; Symbol_table* symtab_; Layout* layout_; Relobj* object_; - Task_token* symtab_lock_; - Task_token* blocker_; + Read_relocs_data* rd_; + Task_token* this_blocker_; + Task_token* next_blocker_; }; // Scan the relocations for an object to see if they require any @@ -90,36 +140,39 @@ class Read_relocs : public Task 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. @@ -127,35 +180,139 @@ class Scan_relocs : public Task class Relocate_task : public Task { public: - Relocate_task(const General_options& options, const Symbol_table* symtab, - const Layout* layout, Relobj* object, Output_file* of, - Task_token* final_blocker) - : options_(options), symtab_(symtab), layout_(layout), object_(object), - of_(of), final_blocker_(final_blocker) + 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) + : 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_; Output_file* of_; + Task_token* input_sections_blocker_; + Task_token* output_sections_blocker_; 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(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(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 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. @@ -176,13 +333,25 @@ private: elfcpp::Swap::writeval(wv, x + value); } + // Like the above but for relocs at unaligned addresses. + template + static inline void + rel_unaligned(unsigned char* view, + typename elfcpp::Swap::Valtype value) + { + typedef typename elfcpp::Swap_unaligned::Valtype + Valtype; + Valtype x = elfcpp::Swap_unaligned::readval(view); + elfcpp::Swap_unaligned::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 static inline void rel(unsigned char* view, - const Sized_relobj* object, + const Sized_relobj_file* object, const Symbol_value* psymval) { typedef typename elfcpp::Swap::Valtype Valtype; @@ -192,6 +361,20 @@ private: elfcpp::Swap::writeval(wv, x); } + // Like the above but for relocs at unaligned addresses. + template + static inline void + rel_unaligned(unsigned char* view, + const Sized_relobj_file* object, + const Symbol_value* psymval) + { + typedef typename elfcpp::Swap_unaligned::Valtype + Valtype; + Valtype x = elfcpp::Swap_unaligned::readval(view); + x = psymval->value(object, x); + elfcpp::Swap_unaligned::writeval(view, x); + } + // Do a simple relocation with the addend in the relocation. // VALSIZE is the size of the value. template @@ -210,7 +393,7 @@ private: template static inline void rela(unsigned char* view, - const Sized_relobj* object, + const Sized_relobj_file* object, const Symbol_value* psymval, typename elfcpp::Swap::Valtype addend) { @@ -220,31 +403,6 @@ private: elfcpp::Swap::writeval(wv, x); } - // Like rel(), but sign-extends the value to SIZE. - template - static inline void - signedrel(unsigned char* view, - const Sized_relobj* object, - const Symbol_value* psymval) - { - typedef typename elfcpp::Swap::Valtype Valtype; - typedef typename elfcpp::Swap::Signed_valtype - Signed_valtype; - typedef typename elfcpp::Swap::Valtype Sizetype; - typedef typename elfcpp::Swap::Signed_valtype - Signed_sizetype; - Valtype* wv = reinterpret_cast(view); - Valtype x = elfcpp::Swap::readval(wv); - - // Sign extend the value. - Signed_valtype signed_x = static_cast(x); - Signed_sizetype signed_extended_x = static_cast(signed_x); - Sizetype unsigned_extended_x = static_cast(signed_extended_x); - - x = psymval->value(object, unsigned_extended_x); - elfcpp::Swap::writeval(wv, x); - } - // Do a simple PC relative relocation with the addend in the section // contents. VALSIZE is the size of the value. template @@ -259,13 +417,26 @@ private: elfcpp::Swap::writeval(wv, x + value - address); } + // Like the above but for relocs at unaligned addresses. + template + static inline void + pcrel_unaligned(unsigned char* view, + typename elfcpp::Swap::Valtype value, + typename elfcpp::Elf_types::Elf_Addr address) + { + typedef typename elfcpp::Swap::Valtype Valtype; + Valtype x = elfcpp::Swap_unaligned::readval(view); + elfcpp::Swap_unaligned::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 static inline void pcrel(unsigned char* view, - const Sized_relobj* object, + const Sized_relobj_file* object, const Symbol_value* psymval, typename elfcpp::Elf_types::Elf_Addr address) { @@ -295,7 +466,7 @@ private: template static inline void pcrela(unsigned char* view, - const Sized_relobj* object, + const Sized_relobj_file* object, const Symbol_value* psymval, typename elfcpp::Swap::Valtype addend, typename elfcpp::Elf_types::Elf_Addr address) @@ -317,7 +488,7 @@ public: static inline void rel8(unsigned char* view, - const Sized_relobj* object, + const Sized_relobj_file* object, const Symbol_value* psymval) { This::template rel<8>(view, object, psymval); } @@ -328,18 +499,11 @@ public: static inline void rela8(unsigned char* view, - const Sized_relobj* object, + const Sized_relobj_file* object, const Symbol_value* psymval, unsigned char addend) { This::template rela<8>(view, object, psymval, addend); } - // Do an 8-bit REL relocation, sign extending the addend to SIZE. - static inline void - rel8s(unsigned char* view, - const Sized_relobj* object, - const Symbol_value* psymval) - { This::template signedrel<8>(view, object, psymval); } - // Do a simple 8-bit PC relative relocation with the addend in the // section contents. static inline void @@ -349,7 +513,7 @@ public: static inline void pcrel8(unsigned char* view, - const Sized_relobj* object, + const Sized_relobj_file* object, const Symbol_value* psymval, typename elfcpp::Elf_types::Elf_Addr address) { This::template pcrel<8>(view, object, psymval, address); } @@ -363,7 +527,7 @@ public: static inline void pcrela8(unsigned char* view, - const Sized_relobj* object, + const Sized_relobj_file* object, const Symbol_value* psymval, unsigned char addend, typename elfcpp::Elf_types::Elf_Addr address) @@ -377,7 +541,7 @@ public: static inline void rel16(unsigned char* view, - const Sized_relobj* object, + const Sized_relobj_file* object, const Symbol_value* psymval) { This::template rel<16>(view, object, psymval); } @@ -388,18 +552,11 @@ public: static inline void rela16(unsigned char* view, - const Sized_relobj* object, + const Sized_relobj_file* object, const Symbol_value* psymval, elfcpp::Elf_Half addend) { This::template rela<16>(view, object, psymval, addend); } - // Do a 16-bit REL relocation, sign extending the addend to SIZE. - static inline void - rel16s(unsigned char* view, - const Sized_relobj* object, - const Symbol_value* psymval) - { This::template signedrel<16>(view, object, psymval); } - // Do a simple 16-bit PC relative REL relocation with the addend in // the section contents. static inline void @@ -409,7 +566,7 @@ public: static inline void pcrel16(unsigned char* view, - const Sized_relobj* object, + const Sized_relobj_file* object, const Symbol_value* psymval, typename elfcpp::Elf_types::Elf_Addr address) { This::template pcrel<16>(view, object, psymval, address); } @@ -424,7 +581,7 @@ public: static inline void pcrela16(unsigned char* view, - const Sized_relobj* object, + const Sized_relobj_file* object, const Symbol_value* psymval, elfcpp::Elf_Half addend, typename elfcpp::Elf_types::Elf_Addr address) @@ -436,12 +593,24 @@ public: 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* object, + const Sized_relobj_file* object, const Symbol_value* 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* object, + const Symbol_value* 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) @@ -449,18 +618,11 @@ public: static inline void rela32(unsigned char* view, - const Sized_relobj* object, + const Sized_relobj_file* object, const Symbol_value* psymval, elfcpp::Elf_Word addend) { This::template rela<32>(view, object, psymval, addend); } - // Do a 32-bit REL relocation, sign extending the addend to SIZE. - static inline void - rel32s(unsigned char* view, - const Sized_relobj* object, - const Symbol_value* psymval) - { This::template signedrel<32>(view, object, psymval); } - // Do a simple 32-bit PC relative REL relocation with the addend in // the section contents. static inline void @@ -468,9 +630,15 @@ public: typename elfcpp::Elf_types::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::Elf_Addr address) + { This::template pcrel_unaligned<32>(view, value, address); } + static inline void pcrel32(unsigned char* view, - const Sized_relobj* object, + const Sized_relobj_file* object, const Symbol_value* psymval, typename elfcpp::Elf_types::Elf_Addr address) { This::template pcrel<32>(view, object, psymval, address); } @@ -485,7 +653,7 @@ public: static inline void pcrela32(unsigned char* view, - const Sized_relobj* object, + const Sized_relobj_file* object, const Symbol_value* psymval, elfcpp::Elf_Word addend, typename elfcpp::Elf_types::Elf_Addr address) @@ -499,7 +667,7 @@ public: static inline void rel64(unsigned char* view, - const Sized_relobj* object, + const Sized_relobj_file* object, const Symbol_value* psymval) { This::template rel<64>(view, object, psymval); } @@ -511,7 +679,7 @@ public: static inline void rela64(unsigned char* view, - const Sized_relobj* object, + const Sized_relobj_file* object, const Symbol_value* psymval, elfcpp::Elf_Xword addend) { This::template rela<64>(view, object, psymval, addend); } @@ -525,7 +693,7 @@ public: static inline void pcrel64(unsigned char* view, - const Sized_relobj* object, + const Sized_relobj_file* object, const Symbol_value* psymval, typename elfcpp::Elf_types::Elf_Addr address) { This::template pcrel<64>(view, object, psymval, address); } @@ -540,104 +708,189 @@ public: static inline void pcrela64(unsigned char* view, - const Sized_relobj* object, + const Sized_relobj_file* object, const Symbol_value* psymval, elfcpp::Elf_Xword addend, typename elfcpp::Elf_types::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 -class Copy_relocs +template +class Bits { public: - Copy_relocs() - : entries_() - { } + // 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(val); + uint32_t mask = (~static_cast(0)) >> (32 - bits); + val &= mask; + uint32_t top_bit = 1U << (bits - 1); + int32_t as_signed = static_cast(val); + if ((val & top_bit) != 0) + as_signed -= static_cast(top_bit * 2); + return as_signed; + } - // 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* gsym); + // 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(val); + return as_signed > max || as_signed < min; + } - // 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&); + // 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((1U << bits) - 1); + int32_t min = -(1 << (bits - 1)); + int32_t as_signed = static_cast(val); + return as_signed > max || as_signed < min; + } - // Save a Rela against SYM for possible emission later. - void - save(Symbol* sym, Relobj*, unsigned int shndx, - const elfcpp::Rela&); + // 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(val); + uint64_t mask = (~static_cast(0)) >> (64 - bits); + val &= mask; + uint64_t top_bit = static_cast(1) << (bits - 1); + int64_t as_signed = static_cast(val); + if ((val & top_bit) != 0) + as_signed -= static_cast(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 uint64_t) has overflowed a signed + // value with BITS bits. + static inline bool + has_overflow(uint64_t val) + { + gold_assert(bits > 0 && bits <= 64); + if (bits == 64) + return false; + int64_t max = (static_cast(1) << (bits - 1)) - 1; + int64_t min = -(static_cast(1) << (bits - 1)); + int64_t as_signed = static_cast(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 - void - emit(Output_data_reloc*); + // 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((static_cast(1) << bits) - 1); + int64_t min = -(static_cast(1) << (bits - 1)); + int64_t as_signed = static_cast(val); + return as_signed > max || as_signed < min; + } - private: - typedef typename elfcpp::Elf_types::Elf_Addr Address; - typedef typename elfcpp::Elf_types::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 uint64_t + bit_select64(uint64_t a, uint64_t b, uint64_t mask) + { return (a & ~mask) | (b & mask); } +}; - // This POD class holds the entries we are saving. - class Copy_reloc_entry - { - 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*); - - void - emit(Output_data_reloc*); - - private: - Symbol* sym_; - unsigned int reloc_type_; - Relobj* relobj_; - unsigned int shndx_; - Address address_; - Addend addend_; - }; +// Track relocations while reading a section. This lets you ask for +// the relocation at a certain offset, and see how relocs occur +// between points of interest. - // A list of relocs to be saved. - typedef std::vector Copy_reloc_entries; +template +class Track_relocs +{ + public: + Track_relocs() + : prelocs_(NULL), len_(0), pos_(0), reloc_size_(0) + { } - // The list of relocs we are saving. - Copy_reloc_entries entries_; + // Initialize the Track_relocs object. OBJECT is the object holding + // the reloc section, RELOC_SHNDX is the section index of the reloc + // section, and RELOC_TYPE is the type of the reloc section + // (elfcpp::SHT_REL or elfcpp::SHT_RELA). This returns false if + // something went wrong. + bool + 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. + off_t + next_offset() const; + + // Return the symbol index of the next reloc. This returns -1U if + // there is no next reloc. + 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 contents of the input object's reloc section. + const unsigned char* prelocs_; + // The length of the reloc section. + section_size_type len_; + // Our current position in the reloc section. + section_size_type pos_; + // The size of the relocs in the section. + int reloc_size_; }; } // End namespace gold.