X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gold%2Freloc.h;h=4eca71a7081ee90305341cee7a0bca7afa9d7941;hb=c3d399e712774f8c8e4cd6b6a5bb8230c42bc760;hp=39ffe4ac229eef971dc8c780d4becd899cc11147;hpb=8383303e0acce6e4332e2a2097b832e2deb880ec;p=deliverable%2Fbinutils-gdb.git diff --git a/gold/reloc.h b/gold/reloc.h index 39ffe4ac22..4eca71a708 100644 --- a/gold/reloc.h +++ b/gold/reloc.h @@ -1,6 +1,7 @@ // reloc.h -- relocate input files for gold -*- C++ -*- -// Copyright 2006, 2007 Free Software Foundation, Inc. +// Copyright 2006, 2007, 2008, 2009, 2010, 2011, 2012 +// Free Software Foundation, Inc. // Written by Ian Lance Taylor . // This file is part of gold. @@ -24,7 +25,9 @@ #define GOLD_RELOC_H #include +#ifdef HAVE_BYTESWAP_H #include +#endif #include "elfcpp.h" #include "workqueue.h" @@ -35,16 +38,17 @@ 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; @@ -59,13 +63,13 @@ 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. @@ -83,12 +87,52 @@ class Read_relocs : public Task 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 @@ -97,15 +141,18 @@ 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. Task_token* @@ -121,13 +168,12 @@ class Scan_relocs : public Task get_name() const; private: - const General_options& options_; 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. @@ -135,12 +181,12 @@ 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, + 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) { } @@ -160,7 +206,6 @@ class Relocate_task : public Task get_name() const; private: - const General_options& options_; const Symbol_table* symtab_; const Layout* layout_; Relobj* object_; @@ -170,6 +215,105 @@ class Relocate_task : public Task 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. @@ -190,13 +334,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; @@ -206,6 +362,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 @@ -224,7 +394,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) { @@ -248,13 +418,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) { @@ -284,7 +467,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) @@ -306,7 +489,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); } @@ -317,7 +500,7 @@ 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); } @@ -331,7 +514,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); } @@ -345,7 +528,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) @@ -359,7 +542,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); } @@ -370,7 +553,7 @@ 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); } @@ -384,7 +567,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); } @@ -399,7 +582,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) @@ -411,12 +594,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) @@ -424,7 +619,7 @@ 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); } @@ -436,9 +631,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); } @@ -453,7 +654,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) @@ -467,7 +668,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); } @@ -479,7 +680,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); } @@ -493,7 +694,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); } @@ -508,107 +709,127 @@ 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_() - { } - - // 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); - - // 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, - Output_section* output_section, const elfcpp::Rel&); - - // Save a Rela against SYM for possible emission later. - void - save(Symbol* sym, Relobj*, unsigned int shndx, - Output_section* output_section, const elfcpp::Rela&); + // 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 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(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 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; + } - 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 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; + } - // 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, - Output_section* output_section, - Address address, Addend addend) - : sym_(sym), reloc_type_(reloc_type), relobj_(relobj), - shndx_(shndx), output_section_(output_section), - 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_; - Output_section* output_section_; - Address address_; - Addend addend_; - }; + 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; + } - // A list of relocs to be saved. - typedef std::vector 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((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; + } - // 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 @@ -633,7 +854,7 @@ class Track_relocs 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; @@ -642,11 +863,26 @@ class Track_relocs 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_;