X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gold%2Freloc.h;h=073928e146dbd890ee1fd715e5fe5ed78e9af680;hb=cf950fd4dd4581849a445a76b57514d72074927d;hp=fb6c8460b4398264794d1a2c5fc213f22fa8cc76;hpb=7019cd256559b48bc642fcb8ff9a4ea9e98bced7;p=deliverable%2Fbinutils-gdb.git diff --git a/gold/reloc.h b/gold/reloc.h index fb6c8460b4..073928e146 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-2019 Free Software Foundation, Inc. // Written by Ian Lance Taylor . // This file is part of gold. @@ -24,7 +24,9 @@ #define GOLD_RELOC_H #include +#ifdef HAVE_BYTESWAP_H #include +#endif #include "elfcpp.h" #include "workqueue.h" @@ -35,7 +37,7 @@ namespace gold class General_options; class Object; class Relobj; -class Read_relocs_data; +struct Read_relocs_data; class Symbol; class Layout; class Output_data; @@ -45,7 +47,7 @@ template class Sized_symbol; template -class Sized_relobj; +class Sized_relobj_file; template class Symbol_value; @@ -60,13 +62,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. @@ -84,12 +86,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 @@ -98,15 +140,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* @@ -122,13 +167,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. @@ -136,12 +180,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) { } @@ -161,7 +205,6 @@ class Relocate_task : public Task get_name() const; private: - const General_options& options_; const Symbol_table* symtab_; const Layout* layout_; Relobj* object_; @@ -204,6 +247,8 @@ class Relocatable_relocs 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, @@ -251,6 +296,14 @@ class Relocatable_relocs return static_cast(this->reloc_strategies_[i]); } + // Set the strategy for reloc I. + void + set_strategy(unsigned int i, Reloc_strategy strategy) + { + gold_assert(i < this->reloc_strategies_.size()); + this->reloc_strategies_[i] = strategy; + } + // Return the number of relocations to create in the output file. size_t output_reloc_count() const @@ -268,445 +321,817 @@ class Relocatable_relocs Output_data* posd_; }; +template +class Bits; + // Standard relocation routines which are used on many targets. Here // SIZE and BIG_ENDIAN refer to the target, not the relocation type. template class Relocate_functions { -private: + public: + typedef typename elfcpp::Elf_types::Elf_Addr Address; + typedef typename elfcpp::Elf_types::Elf_Swxword Addendtype; + + enum Overflow_check + { + // No overflow checking. + CHECK_NONE, + // Check for overflow of a signed value. + CHECK_SIGNED, + // Check for overflow of an unsigned value. + CHECK_UNSIGNED, + // Check for overflow of a signed or unsigned value. + // (i.e., no error if either signed or unsigned fits.) + CHECK_SIGNED_OR_UNSIGNED + }; + + enum Reloc_status + { + RELOC_OK, + RELOC_OVERFLOW + }; + + private: + // Check for overflow. + template + static inline Reloc_status + check_overflow(Address value, Overflow_check check) + { + switch (check) + { + case CHECK_SIGNED: + if (size == 32) + return (Bits::has_overflow32(value) + ? RELOC_OVERFLOW + : RELOC_OK); + else + return (Bits::has_overflow(value) + ? RELOC_OVERFLOW + : RELOC_OK); + case CHECK_UNSIGNED: + if (size == 32) + return (Bits::has_unsigned_overflow32(value) + ? RELOC_OVERFLOW + : RELOC_OK); + else + return (Bits::has_unsigned_overflow(value) + ? RELOC_OVERFLOW + : RELOC_OK); + case CHECK_SIGNED_OR_UNSIGNED: + if (size == 32) + return (Bits::has_signed_unsigned_overflow32(value) + ? RELOC_OVERFLOW + : RELOC_OK); + else + return (Bits::has_signed_unsigned_overflow64(value) + ? RELOC_OVERFLOW + : RELOC_OK); + case CHECK_NONE: + default: + return RELOC_OK; + } + } + // Do a simple relocation with the addend in the section contents. // VALSIZE is the size of the value. template - static inline void - rel(unsigned char* view, - typename elfcpp::Swap::Valtype value) + static inline Reloc_status + rel(unsigned char* view, Address value, Overflow_check check) { typedef typename elfcpp::Swap::Valtype Valtype; Valtype* wv = reinterpret_cast(view); - Valtype x = elfcpp::Swap::readval(wv); - elfcpp::Swap::writeval(wv, x + value); + Valtype addend = elfcpp::Swap::readval(wv); + value += addend; + elfcpp::Swap:: + writeval(wv, static_cast(value)); + return check_overflow(value, check); + } + + // Like the above but for relocs at unaligned addresses. + template + static inline Reloc_status + rel_unaligned(unsigned char* view, Address value, Overflow_check check) + { + typedef typename elfcpp::Swap_unaligned::Valtype + Valtype; + Valtype addend = elfcpp::Swap_unaligned::readval(view); + value += addend; + elfcpp::Swap_unaligned:: + writeval(view, static_cast(value)); + return check_overflow(value, check); } // 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 + static inline Reloc_status rel(unsigned char* view, - const Sized_relobj* object, - const Symbol_value* psymval) + const Sized_relobj_file* object, + const Symbol_value* psymval, + Overflow_check check) { typedef typename elfcpp::Swap::Valtype Valtype; Valtype* wv = reinterpret_cast(view); - Valtype x = elfcpp::Swap::readval(wv); - x = psymval->value(object, x); - elfcpp::Swap::writeval(wv, x); + Valtype addend = elfcpp::Swap::readval(wv); + Address value = psymval->value(object, addend); + elfcpp::Swap:: + writeval(wv, static_cast(value)); + return check_overflow(value, check); + } + + // Like the above but for relocs at unaligned addresses. + template + static inline Reloc_status + rel_unaligned(unsigned char* view, + const Sized_relobj_file* object, + const Symbol_value* psymval, + Overflow_check check) + { + typedef typename elfcpp::Swap_unaligned::Valtype + Valtype; + Valtype addend = elfcpp::Swap_unaligned::readval(view); + Address value = psymval->value(object, addend); + elfcpp::Swap_unaligned::writeval(view, value); + return check_overflow(value, check); } // Do a simple relocation with the addend in the relocation. // VALSIZE is the size of the value. template - static inline void - rela(unsigned char* view, - typename elfcpp::Swap::Valtype value, - typename elfcpp::Swap::Valtype addend) + static inline Reloc_status + rela(unsigned char* view, Address value, Addendtype addend, + Overflow_check check) { typedef typename elfcpp::Swap::Valtype Valtype; Valtype* wv = reinterpret_cast(view); - elfcpp::Swap::writeval(wv, value + addend); + value += addend; + elfcpp::Swap::writeval(wv, value); + return check_overflow(value, check); } // Do a simple relocation using a symbol value with the addend in // the relocation. VALSIZE is the size of the value. template - static inline void + static inline Reloc_status rela(unsigned char* view, - const Sized_relobj* object, + const Sized_relobj_file* object, const Symbol_value* psymval, - typename elfcpp::Swap::Valtype addend) + Addendtype addend, + Overflow_check check) { typedef typename elfcpp::Swap::Valtype Valtype; Valtype* wv = reinterpret_cast(view); - Valtype x = psymval->value(object, addend); - elfcpp::Swap::writeval(wv, x); + Address value = psymval->value(object, addend); + elfcpp::Swap::writeval(wv, value); + return check_overflow(value, check); } // Do a simple PC relative relocation with the addend in the section // contents. VALSIZE is the size of the value. template - static inline void - pcrel(unsigned char* view, - typename elfcpp::Swap::Valtype value, - typename elfcpp::Elf_types::Elf_Addr address) + static inline Reloc_status + pcrel(unsigned char* view, Address value, Address address, + Overflow_check check) { typedef typename elfcpp::Swap::Valtype Valtype; Valtype* wv = reinterpret_cast(view); - Valtype x = elfcpp::Swap::readval(wv); - elfcpp::Swap::writeval(wv, x + value - address); + Valtype addend = elfcpp::Swap::readval(wv); + value = value + addend - address; + elfcpp::Swap::writeval(wv, value); + return check_overflow(value, check); + } + + // Like the above but for relocs at unaligned addresses. + template + static inline Reloc_status + pcrel_unaligned(unsigned char* view, Address value, Address address, + Overflow_check check) + { + typedef typename elfcpp::Swap::Valtype Valtype; + Valtype addend = elfcpp::Swap_unaligned::readval(view); + value = value + addend - address; + elfcpp::Swap_unaligned::writeval(view, value); + return check_overflow(value, check); } // 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 + static inline Reloc_status pcrel(unsigned char* view, - const Sized_relobj* object, + const Sized_relobj_file* object, const Symbol_value* psymval, - typename elfcpp::Elf_types::Elf_Addr address) + Address address, + Overflow_check check) { typedef typename elfcpp::Swap::Valtype Valtype; Valtype* wv = reinterpret_cast(view); - Valtype x = elfcpp::Swap::readval(wv); - x = psymval->value(object, x); - elfcpp::Swap::writeval(wv, x - address); + Valtype addend = elfcpp::Swap::readval(wv); + Address value = psymval->value(object, addend) - address; + elfcpp::Swap::writeval(wv, value); + return check_overflow(value, check); } // Do a simple PC relative relocation with the addend in the // relocation. VALSIZE is the size of the value. template - static inline void - pcrela(unsigned char* view, - typename elfcpp::Swap::Valtype value, - typename elfcpp::Swap::Valtype addend, - typename elfcpp::Elf_types::Elf_Addr address) + static inline Reloc_status + pcrela(unsigned char* view, Address value, Addendtype addend, Address address, + Overflow_check check) { typedef typename elfcpp::Swap::Valtype Valtype; Valtype* wv = reinterpret_cast(view); - elfcpp::Swap::writeval(wv, value + addend - address); + value = value + addend - address; + elfcpp::Swap::writeval(wv, value); + return check_overflow(value, check); } // Do a simple PC relative relocation with a Symbol_value with the // addend in the relocation. VALSIZE is the size of the value. template - static inline void + static inline Reloc_status 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) + Addendtype addend, + Address address, + Overflow_check check) { typedef typename elfcpp::Swap::Valtype Valtype; Valtype* wv = reinterpret_cast(view); - Valtype x = psymval->value(object, addend); - elfcpp::Swap::writeval(wv, x - address); + Address value = psymval->value(object, addend) - address; + elfcpp::Swap::writeval(wv, value); + return check_overflow(value, check); } typedef Relocate_functions This; -public: + public: // Do a simple 8-bit REL relocation with the addend in the section // contents. static inline void - rel8(unsigned char* view, unsigned char value) - { This::template rel<8>(view, value); } + rel8(unsigned char* view, Address value) + { This::template rel<8>(view, value, CHECK_NONE); } + + static inline Reloc_status + rel8_check(unsigned char* view, Address value, Overflow_check check) + { return This::template rel<8>(view, value, check); } 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); } + { This::template rel<8>(view, object, psymval, CHECK_NONE); } + + static inline Reloc_status + rel8_check(unsigned char* view, + const Sized_relobj_file* object, + const Symbol_value* psymval, + Overflow_check check) + { return This::template rel<8>(view, object, psymval, check); } // Do an 8-bit RELA relocation with the addend in the relocation. static inline void - rela8(unsigned char* view, unsigned char value, unsigned char addend) - { This::template rela<8>(view, value, addend); } + rela8(unsigned char* view, Address value, Addendtype addend) + { This::template rela<8>(view, value, addend, CHECK_NONE); } + + static inline Reloc_status + rela8_check(unsigned char* view, Address value, Addendtype addend, + Overflow_check check) + { return This::template rela<8>(view, value, addend, check); } 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); } + Addendtype addend) + { This::template rela<8>(view, object, psymval, addend, CHECK_NONE); } + + static inline Reloc_status + rela8_check(unsigned char* view, + const Sized_relobj_file* object, + const Symbol_value* psymval, + Addendtype addend, + Overflow_check check) + { return This::template rela<8>(view, object, psymval, addend, check); } // Do a simple 8-bit PC relative relocation with the addend in the // section contents. static inline void - pcrel8(unsigned char* view, unsigned char value, - typename elfcpp::Elf_types::Elf_Addr address) - { This::template pcrel<8>(view, value, address); } + pcrel8(unsigned char* view, unsigned char value, Address address) + { This::template pcrel<8>(view, value, address, CHECK_NONE); } + + static inline Reloc_status + pcrel8_check(unsigned char* view, unsigned char value, Address address, + Overflow_check check) + { return This::template pcrel<8>(view, value, address, check); } 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); } + Address address) + { This::template pcrel<8>(view, object, psymval, address, CHECK_NONE); } + + static inline Reloc_status + pcrel8_check(unsigned char* view, + const Sized_relobj_file* object, + const Symbol_value* psymval, + Address address, + Overflow_check check) + { return This::template pcrel<8>(view, object, psymval, address, check); } // Do a simple 8-bit PC relative RELA relocation with the addend in // the reloc. static inline void - pcrela8(unsigned char* view, unsigned char value, unsigned char addend, - typename elfcpp::Elf_types::Elf_Addr address) - { This::template pcrela<8>(view, value, addend, address); } + pcrela8(unsigned char* view, Address value, Addendtype addend, + Address address) + { This::template pcrela<8>(view, value, addend, address, CHECK_NONE); } + + static inline Reloc_status + pcrela8_check(unsigned char* view, Address value, Addendtype addend, + Address address, Overflow_check check) + { return This::template pcrela<8>(view, value, addend, address, check); } 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) - { This::template pcrela<8>(view, object, psymval, addend, address); } + Addendtype addend, + Address address) + { This::template pcrela<8>(view, object, psymval, addend, address, + CHECK_NONE); } + + static inline Reloc_status + pcrela8_check(unsigned char* view, + const Sized_relobj_file* object, + const Symbol_value* psymval, + Addendtype addend, + Address address, + Overflow_check check) + { return This::template pcrela<8>(view, object, psymval, addend, address, + check); } // Do a simple 16-bit REL relocation with the addend in the section // contents. static inline void - rel16(unsigned char* view, elfcpp::Elf_Half value) - { This::template rel<16>(view, value); } + rel16(unsigned char* view, Address value) + { This::template rel<16>(view, value, CHECK_NONE); } + + static inline Reloc_status + rel16_check(unsigned char* view, Address value, Overflow_check check) + { return This::template rel<16>(view, value, check); } 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); } + { This::template rel<16>(view, object, psymval, CHECK_NONE); } + + static inline Reloc_status + rel16_check(unsigned char* view, + const Sized_relobj_file* object, + const Symbol_value* psymval, + Overflow_check check) + { return This::template rel<16>(view, object, psymval, check); } // Do an 16-bit RELA relocation with the addend in the relocation. static inline void - rela16(unsigned char* view, elfcpp::Elf_Half value, elfcpp::Elf_Half addend) - { This::template rela<16>(view, value, addend); } + rela16(unsigned char* view, Address value, Addendtype addend) + { This::template rela<16>(view, value, addend, CHECK_NONE); } + + static inline Reloc_status + rela16_check(unsigned char* view, Address value, Addendtype addend, + Overflow_check check) + { return This::template rela<16>(view, value, addend, check); } 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); } + Addendtype addend) + { This::template rela<16>(view, object, psymval, addend, CHECK_NONE); } + + static inline Reloc_status + rela16_check(unsigned char* view, + const Sized_relobj_file* object, + const Symbol_value* psymval, + Addendtype addend, + Overflow_check check) + { return This::template rela<16>(view, object, psymval, addend, check); } // Do a simple 16-bit PC relative REL relocation with the addend in // the section contents. static inline void - pcrel16(unsigned char* view, elfcpp::Elf_Half value, - typename elfcpp::Elf_types::Elf_Addr address) - { This::template pcrel<16>(view, value, address); } + pcrel16(unsigned char* view, Address value, Address address) + { This::template pcrel<16>(view, value, address, CHECK_NONE); } + + static inline Reloc_status + pcrel16_check(unsigned char* view, Address value, Address address, + Overflow_check check) + { return This::template pcrel<16>(view, value, address, check); } 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); } + Address address) + { This::template pcrel<16>(view, object, psymval, address, CHECK_NONE); } + + static inline Reloc_status + pcrel16_check(unsigned char* view, + const Sized_relobj_file* object, + const Symbol_value* psymval, + Address address, + Overflow_check check) + { return This::template pcrel<16>(view, object, psymval, address, check); } // Do a simple 16-bit PC relative RELA relocation with the addend in // the reloc. static inline void - pcrela16(unsigned char* view, elfcpp::Elf_Half value, - elfcpp::Elf_Half addend, - typename elfcpp::Elf_types::Elf_Addr address) - { This::template pcrela<16>(view, value, addend, address); } + pcrela16(unsigned char* view, Address value, Addendtype addend, + Address address) + { This::template pcrela<16>(view, value, addend, address, CHECK_NONE); } + + static inline Reloc_status + pcrela16_check(unsigned char* view, Address value, Addendtype addend, + Address address, Overflow_check check) + { return This::template pcrela<16>(view, value, addend, address, check); } 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) - { This::template pcrela<16>(view, object, psymval, addend, address); } + Addendtype addend, + Address address) + { This::template pcrela<16>(view, object, psymval, addend, address, + CHECK_NONE); } + + static inline Reloc_status + pcrela16_check(unsigned char* view, + const Sized_relobj_file* object, + const Symbol_value* psymval, + Addendtype addend, + Address address, + Overflow_check check) + { return This::template pcrela<16>(view, object, psymval, addend, address, + check); } // Do a simple 32-bit REL relocation with the addend in the section // contents. static inline void - rel32(unsigned char* view, elfcpp::Elf_Word value) - { This::template rel<32>(view, value); } + rel32(unsigned char* view, Address value) + { This::template rel<32>(view, value, CHECK_NONE); } + + static inline Reloc_status + rel32_check(unsigned char* view, Address value, Overflow_check check) + { return This::template rel<32>(view, value, check); } + + // Like above but for relocs at unaligned addresses. + static inline void + rel32_unaligned(unsigned char* view, Address value) + { This::template rel_unaligned<32>(view, value, CHECK_NONE); } + + static inline Reloc_status + rel32_unaligned_check(unsigned char* view, Address value, + Overflow_check check) + { return This::template rel_unaligned<32>(view, value, check); } 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); } + { This::template rel<32>(view, object, psymval, CHECK_NONE); } + + static inline Reloc_status + rel32_check(unsigned char* view, + const Sized_relobj_file* object, + const Symbol_value* psymval, + Overflow_check check) + { return This::template rel<32>(view, object, psymval, check); } - // Do an 32-bit RELA relocation with the addend in the relocation. + // Like above but for relocs at unaligned addresses. static inline void - rela32(unsigned char* view, elfcpp::Elf_Word value, elfcpp::Elf_Word addend) - { This::template rela<32>(view, value, addend); } + rel32_unaligned(unsigned char* view, + const Sized_relobj_file* object, + const Symbol_value* psymval) + { This::template rel_unaligned<32>(view, object, psymval, CHECK_NONE); } + + static inline Reloc_status + rel32_unaligned_check(unsigned char* view, + const Sized_relobj_file* object, + const Symbol_value* psymval, + Overflow_check check) + { return This::template rel_unaligned<32>(view, object, psymval, check); } + + // Do a 32-bit RELA relocation with the addend in the relocation. + static inline void + rela32(unsigned char* view, Address value, Addendtype addend) + { This::template rela<32>(view, value, addend, CHECK_NONE); } + + static inline Reloc_status + rela32(unsigned char* view, Address value, Addendtype addend, + Overflow_check check) + { return This::template rela<32>(view, value, addend, check); } 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); } + Addendtype addend) + { This::template rela<32>(view, object, psymval, addend, CHECK_NONE); } + + static inline Reloc_status + rela32_check(unsigned char* view, + const Sized_relobj_file* object, + const Symbol_value* psymval, + Addendtype addend, + Overflow_check check) + { return This::template rela<32>(view, object, psymval, addend, check); } // Do a simple 32-bit PC relative REL relocation with the addend in // the section contents. static inline void - pcrel32(unsigned char* view, elfcpp::Elf_Word value, - typename elfcpp::Elf_types::Elf_Addr address) - { This::template pcrel<32>(view, value, address); } + pcrel32(unsigned char* view, Address value, Address address) + { This::template pcrel<32>(view, value, address, CHECK_NONE); } + + static inline Reloc_status + pcrel32_check(unsigned char* view, Address value, Address address, + Overflow_check check) + { return This::template pcrel<32>(view, value, address, check); } + + // Unaligned version of the above. + static inline void + pcrel32_unaligned(unsigned char* view, Address value, Address address) + { This::template pcrel_unaligned<32>(view, value, address, CHECK_NONE); } + + static inline Reloc_status + pcrel32_unaligned_check(unsigned char* view, Address value, Address address, + Overflow_check check) + { return This::template pcrel_unaligned<32>(view, value, address, check); } 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); } + Address address) + { This::template pcrel<32>(view, object, psymval, address, CHECK_NONE); } + + static inline Reloc_status + pcrel32_check(unsigned char* view, + const Sized_relobj_file* object, + const Symbol_value* psymval, + Address address, + Overflow_check check) + { return This::template pcrel<32>(view, object, psymval, address, check); } // Do a simple 32-bit PC relative RELA relocation with the addend in // the relocation. static inline void - pcrela32(unsigned char* view, elfcpp::Elf_Word value, - elfcpp::Elf_Word addend, - typename elfcpp::Elf_types::Elf_Addr address) - { This::template pcrela<32>(view, value, addend, address); } + pcrela32(unsigned char* view, Address value, Addendtype addend, + Address address) + { This::template pcrela<32>(view, value, addend, address, CHECK_NONE); } + + static inline Reloc_status + pcrela32_check(unsigned char* view, Address value, Addendtype addend, + Address address, Overflow_check check) + { return This::template pcrela<32>(view, value, addend, address, check); } static inline void pcrela32(unsigned char* view, - const Sized_relobj* object, + const Sized_relobj_file* object, + const Symbol_value* psymval, + Addendtype addend, + Address address) + { This::template pcrela<32>(view, object, psymval, addend, address, + CHECK_NONE); } + + static inline Reloc_status + pcrela32_check(unsigned char* view, + const Sized_relobj_file* object, const Symbol_value* psymval, - elfcpp::Elf_Word addend, - typename elfcpp::Elf_types::Elf_Addr address) - { This::template pcrela<32>(view, object, psymval, addend, address); } + Addendtype addend, + Address address, + Overflow_check check) + { return This::template pcrela<32>(view, object, psymval, addend, address, + check); } // Do a simple 64-bit REL relocation with the addend in the section // contents. static inline void - rel64(unsigned char* view, elfcpp::Elf_Xword value) - { This::template rel<64>(view, value); } + rel64(unsigned char* view, Address value) + { This::template rel<64>(view, value, CHECK_NONE); } 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); } + { This::template rel<64>(view, object, psymval, CHECK_NONE); } // Do a 64-bit RELA relocation with the addend in the relocation. static inline void - rela64(unsigned char* view, elfcpp::Elf_Xword value, - elfcpp::Elf_Xword addend) - { This::template rela<64>(view, value, addend); } + rela64(unsigned char* view, Address value, Addendtype addend) + { This::template rela<64>(view, value, addend, CHECK_NONE); } 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); } + Addendtype addend) + { This::template rela<64>(view, object, psymval, addend, CHECK_NONE); } // Do a simple 64-bit PC relative REL relocation with the addend in // the section contents. static inline void - pcrel64(unsigned char* view, elfcpp::Elf_Xword value, - typename elfcpp::Elf_types::Elf_Addr address) - { This::template pcrel<64>(view, value, address); } + pcrel64(unsigned char* view, Address value, Address address) + { This::template pcrel<64>(view, value, address, CHECK_NONE); } 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); } + Address address) + { This::template pcrel<64>(view, object, psymval, address, CHECK_NONE); } // Do a simple 64-bit PC relative RELA relocation with the addend in // the relocation. static inline void - pcrela64(unsigned char* view, elfcpp::Elf_Xword value, - elfcpp::Elf_Xword addend, - typename elfcpp::Elf_types::Elf_Addr address) - { This::template pcrela<64>(view, value, addend, address); } + pcrela64(unsigned char* view, Address value, Addendtype addend, + Address address) + { This::template pcrela<64>(view, value, addend, address, CHECK_NONE); } 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); } + Addendtype addend, + Address address) + { This::template pcrela<64>(view, object, psymval, addend, address, + CHECK_NONE); } }; -// 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. +// Convenience class for min and max values of a given BITS length. -template -class Copy_relocs +template +class Limits { public: - Copy_relocs() - : entries_() - { } + static const uint64_t MAX_UNSIGNED = (1ULL << bits) - 1; + static const int64_t MAX_SIGNED = MAX_UNSIGNED >> 1; + static const int64_t MIN_SIGNED = -MAX_SIGNED - 1; +}; - // 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); +template<> +class Limits<64> +{ + public: + static const uint64_t MAX_UNSIGNED = ~0ULL; + static const int64_t MAX_SIGNED = MAX_UNSIGNED >> 1; + static const int64_t MIN_SIGNED = -MAX_SIGNED - 1; +}; - // 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&); +// Integer manipulation functions used by various targets when +// performing relocations. - // Save a Rela against SYM for possible emission later. - void - save(Symbol* sym, Relobj*, unsigned int shndx, - Output_section* output_section, const elfcpp::Rela&); +template +class Bits +{ + public: + // 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; + const int32_t max = static_cast(Limits::MAX_SIGNED); + const int32_t min = static_cast(Limits::MIN_SIGNED); + 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 an unsigned + // value with BITS bits. + static inline bool + has_unsigned_overflow32(uint32_t val) + { + gold_assert(bits > 0 && bits <= 32); + if (bits == 32) + return false; + const uint32_t max = static_cast(Limits::MAX_UNSIGNED); + return val > max; + } - private: - typedef typename elfcpp::Elf_types::Elf_Addr Address; - typedef typename elfcpp::Elf_types::Elf_Addr Addend; + // 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; + const int32_t max = static_cast(Limits::MAX_UNSIGNED); + const int32_t min = static_cast(Limits::MIN_SIGNED); + int32_t as_signed = static_cast(val); + return as_signed > max || as_signed < min; + } - // This POD class holds the entries we are saving. - class Copy_reloc_entry + // 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) { - 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 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; + } - // A list of relocs to be saved. - typedef std::vector Copy_reloc_entries; + // 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; + const int64_t max = Limits::MAX_SIGNED; + const int64_t min = Limits::MIN_SIGNED; + 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_; + // Return true if VAL (stored in a uint64_t) has overflowed an unsigned + // value with BITS bits. + static inline bool + has_unsigned_overflow(uint64_t val) + { + gold_assert(bits > 0 && bits <= 64); + if (bits == 64) + return false; + const uint64_t max = Limits::MAX_UNSIGNED; + return val > max; + } + + // 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; + const int64_t max = static_cast(Limits::MAX_UNSIGNED); + const int64_t min = Limits::MIN_SIGNED; + int64_t as_signed = static_cast(val); + return as_signed > max || as_signed < min; + } + + // 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 @@ -731,7 +1156,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; @@ -740,11 +1165,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_;