diff options
| -rw-r--r-- | meta/recipes-devtools/binutils/binutils-2.25.1.inc | 1 | ||||
| -rw-r--r-- | meta/recipes-devtools/binutils/binutils/0016-This-patch-adds-IFUNC-support-for-arm-gold-backend.patch | 1004 |
2 files changed, 1005 insertions, 0 deletions
diff --git a/meta/recipes-devtools/binutils/binutils-2.25.1.inc b/meta/recipes-devtools/binutils/binutils-2.25.1.inc index bf29da16f5..dc23c4d9d9 100644 --- a/meta/recipes-devtools/binutils/binutils-2.25.1.inc +++ b/meta/recipes-devtools/binutils/binutils-2.25.1.inc @@ -35,6 +35,7 @@ SRC_URI = "\ file://0013-Fix-an-internal-error-in-do_print_to_mapfile-seen-wi.patch \ file://0014-gold-arm-Skip-pic-check-for-R_ARM_REL32.patch \ file://0015-Fix-dynamic-list-so-that-symbols-not-in-the-list-are.patch \ + file://0016-This-patch-adds-IFUNC-support-for-arm-gold-backend.patch \ file://binutils-octeon3.patch \ file://add-thunderx-support-for-gas.patch \ " diff --git a/meta/recipes-devtools/binutils/binutils/0016-This-patch-adds-IFUNC-support-for-arm-gold-backend.patch b/meta/recipes-devtools/binutils/binutils/0016-This-patch-adds-IFUNC-support-for-arm-gold-backend.patch new file mode 100644 index 0000000000..dcac308bcc --- /dev/null +++ b/meta/recipes-devtools/binutils/binutils/0016-This-patch-adds-IFUNC-support-for-arm-gold-backend.patch @@ -0,0 +1,1004 @@ +From b780c9e06cabe6d8e301aaf46f33f116f3224021 Mon Sep 17 00:00:00 2001 +From: Han Shen <shenhan@google.com> +Date: Thu, 29 Jan 2015 10:00:46 -0800 +Subject: [PATCH] This patch adds IFUNC support for arm gold backend. + +This is a feature required in chromeos arm development work. + +Tested: +1) Built passed all-gold on x86_64 machine +2) Tested with basic gold aarch64 ifunc unittests - + a) global ifunc, statically/non-statically linked + b) local ifunc, statically/non-statically linked + c) global/local, other shared library routine mixed, + statically/non-statically linked + d) arm/thumb mode ifunc + e) linking chrome browser passed +--- +Upstream-Status: Backport +Signed-off-by: Khem Raj <raj.khem@gmail.com> + + elfcpp/arm.h | 5 +- + gold/aarch64.cc | 2 +- + gold/arm.cc | 593 +++++++++++++++++++++++++++++++++++++++++++++++++++----- + gold/output.h | 11 ++ + 4 files changed, 561 insertions(+), 50 deletions(-) + +diff --git a/elfcpp/arm.h b/elfcpp/arm.h +index 8c6b6bf..1c13dc9 100644 +--- a/elfcpp/arm.h ++++ b/elfcpp/arm.h +@@ -192,11 +192,12 @@ enum + R_ARM_PRIVATE_14 = 126, + R_ARM_PRIVATE_15 = 127, + R_ARM_ME_TOO = 128, // Obsolete +- R_ARM_THM_TLS_DESCSEQ16 = 129,// Static Thumb16 ++ R_ARM_THM_TLS_DESCSEQ16 = 129,// Static Thumb16 + R_ARM_THM_TLS_DESCSEQ32 = 130,// Static Thumb32 + // 131 - 139 Unallocated + // 140 - 159 Dynamic Reserved for future allocation +- // 160 - 255 Unallocated ++ R_ARM_IRELATIVE = 160, // Dynamic ++ // 161 - 255 Unallocated + }; + + // e_flags values used for ARM. We only support flags defined in AAELF. +diff --git a/gold/aarch64.cc b/gold/aarch64.cc +index afb9024..7fbbdbd 100644 +--- a/gold/aarch64.cc ++++ b/gold/aarch64.cc +@@ -1226,7 +1226,7 @@ class Output_data_plt_aarch64 : public Output_section_data + // The number of PLT entries. + unsigned int count_; + +- // Number of PLT entries with R_X86_64_IRELATIVE relocs. These ++ // Number of PLT entries with R_AARCH64_IRELATIVE relocs. These + // follow the regular PLT entries. + unsigned int irelative_count_; + +diff --git a/gold/arm.cc b/gold/arm.cc +index 6c472bb..8719cc9 100644 +--- a/gold/arm.cc ++++ b/gold/arm.cc +@@ -2119,8 +2119,8 @@ class Target_arm : public Sized_target<32, big_endian> + + Target_arm(const Target::Target_info* info = &arm_info) + : Sized_target<32, big_endian>(info), +- got_(NULL), plt_(NULL), got_plt_(NULL), rel_dyn_(NULL), +- copy_relocs_(elfcpp::R_ARM_COPY), ++ got_(NULL), plt_(NULL), got_plt_(NULL), got_irelative_(NULL), ++ rel_dyn_(NULL), rel_irelative_(NULL), copy_relocs_(elfcpp::R_ARM_COPY), + got_mod_index_offset_(-1U), tls_base_symbol_defined_(false), + stub_tables_(), stub_factory_(Stub_factory::get_instance()), + should_force_pic_veneer_(false), +@@ -2258,6 +2258,18 @@ class Target_arm : public Sized_target<32, big_endian> + uint64_t + do_dynsym_value(const Symbol*) const; + ++ // Return the plt address for globals. Since we have irelative plt entries, ++ // address calculation is not as straightforward as plt_address + plt_offset. ++ uint64_t ++ do_plt_address_for_global(const Symbol* gsym) const ++ { return this->plt_section()->address_for_global(gsym); } ++ ++ // Return the plt address for locals. Since we have irelative plt entries, ++ // address calculation is not as straightforward as plt_address + plt_offset. ++ uint64_t ++ do_plt_address_for_local(const Relobj* relobj, unsigned int symndx) const ++ { return this->plt_section()->address_for_local(relobj, symndx); } ++ + // Relocate a section. + void + relocate_section(const Relocate_info<32, big_endian>*, +@@ -2357,6 +2369,10 @@ class Target_arm : public Sized_target<32, big_endian> + unsigned int + plt_entry_size() const; + ++ // Get the section to use for IRELATIVE relocations, create it if necessary. ++ Reloc_section* ++ rel_irelative_section(Layout*); ++ + // Map platform-specific reloc types + static unsigned int + get_real_reloc_type(unsigned int r_type); +@@ -2448,8 +2464,11 @@ class Target_arm : public Sized_target<32, big_endian> + protected: + // Make the PLT-generator object. + Output_data_plt_arm<big_endian>* +- make_data_plt(Layout* layout, Output_data_space* got_plt) +- { return this->do_make_data_plt(layout, got_plt); } ++ make_data_plt(Layout* layout, ++ Arm_output_data_got<big_endian>* got, ++ Output_data_space* got_plt, ++ Output_data_space* got_irelative) ++ { return this->do_make_data_plt(layout, got, got_plt, got_irelative); } + + // Make an ELF object. + Object* +@@ -2530,9 +2549,14 @@ class Target_arm : public Sized_target<32, big_endian> + do_define_standard_symbols(Symbol_table*, Layout*); + + virtual Output_data_plt_arm<big_endian>* +- do_make_data_plt(Layout* layout, Output_data_space* got_plt) ++ do_make_data_plt(Layout* layout, ++ Arm_output_data_got<big_endian>* got, ++ Output_data_space* got_plt, ++ Output_data_space* got_irelative) + { +- return new Output_data_plt_arm_standard<big_endian>(layout, got_plt); ++ gold_assert(got_plt != NULL && got_irelative != NULL); ++ return new Output_data_plt_arm_standard<big_endian>( ++ layout, got, got_plt, got_irelative); + } + + private: +@@ -2602,6 +2626,9 @@ class Target_arm : public Sized_target<32, big_endian> + if (sym->is_undefined() && !parameters->options().shared()) + return false; + ++ if (sym->type() == elfcpp::STT_GNU_IFUNC) ++ return true; ++ + return (!parameters->doing_static_link() + && (sym->type() == elfcpp::STT_FUNC + || sym->type() == elfcpp::STT_ARM_TFUNC) +@@ -2613,6 +2640,11 @@ class Target_arm : public Sized_target<32, big_endian> + inline bool + possible_function_pointer_reloc(unsigned int r_type); + ++ // Whether a plt entry is needed for ifunc. ++ bool ++ reloc_needs_plt_for_ifunc(Sized_relobj_file<32, big_endian>*, ++ unsigned int r_type); ++ + // Whether we have issued an error about a non-PIC compilation. + bool issued_non_pic_error_; + }; +@@ -2718,10 +2750,20 @@ class Target_arm : public Sized_target<32, big_endian> + return this->got_plt_; + } + ++ // Create the PLT section. ++ void ++ make_plt_section(Symbol_table* symtab, Layout* layout); ++ + // Create a PLT entry for a global symbol. + void + make_plt_entry(Symbol_table*, Layout*, Symbol*); + ++ // Create a PLT entry for a local STT_GNU_IFUNC symbol. ++ void ++ make_local_ifunc_plt_entry(Symbol_table*, Layout*, ++ Sized_relobj_file<32, big_endian>* relobj, ++ unsigned int local_sym_index); ++ + // Define the _TLS_MODULE_BASE_ symbol in the TLS segment. + void + define_tls_base_symbol(Symbol_table*, Layout*); +@@ -2903,8 +2945,12 @@ class Target_arm : public Sized_target<32, big_endian> + Output_data_plt_arm<big_endian>* plt_; + // The GOT PLT section. + Output_data_space* got_plt_; ++ // The GOT section for IRELATIVE relocations. ++ Output_data_space* got_irelative_; + // The dynamic reloc section. + Reloc_section* rel_dyn_; ++ // The section to use for IRELATIVE relocs. ++ Reloc_section* rel_irelative_; + // Relocs saved to avoid a COPY reloc. + Copy_relocs<elfcpp::SHT_REL, 32, big_endian> copy_relocs_; + // Offset of the GOT entry for the TLS module index. +@@ -4244,6 +4290,15 @@ Target_arm<big_endian>::got_section(Symbol_table* symtab, Layout* layout) + elfcpp::STB_LOCAL, + elfcpp::STV_HIDDEN, 0, + false, false); ++ ++ // If there are any IRELATIVE relocations, they get GOT entries ++ // in .got.plt after the jump slot entries. ++ this->got_irelative_ = new Output_data_space(4, "** GOT IRELATIVE PLT"); ++ layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS, ++ (elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE), ++ this->got_irelative_, ++ got_order, is_got_relro); ++ + } + return this->got_; + } +@@ -4257,14 +4312,43 @@ Target_arm<big_endian>::rel_dyn_section(Layout* layout) + if (this->rel_dyn_ == NULL) + { + gold_assert(layout != NULL); ++ // Create both relocation sections in the same place, so as to ensure ++ // their relative order in the output section. + this->rel_dyn_ = new Reloc_section(parameters->options().combreloc()); ++ this->rel_irelative_ = new Reloc_section(false); + layout->add_output_section_data(".rel.dyn", elfcpp::SHT_REL, + elfcpp::SHF_ALLOC, this->rel_dyn_, + ORDER_DYNAMIC_RELOCS, false); ++ layout->add_output_section_data(".rel.dyn", elfcpp::SHT_REL, ++ elfcpp::SHF_ALLOC, this->rel_irelative_, ++ ORDER_DYNAMIC_RELOCS, false); + } + return this->rel_dyn_; + } + ++ ++// Get the section to use for IRELATIVE relocs, creating it if necessary. These ++// go in .rela.dyn, but only after all other dynamic relocations. They need to ++// follow the other dynamic relocations so that they can refer to global ++// variables initialized by those relocs. ++ ++template<bool big_endian> ++typename Target_arm<big_endian>::Reloc_section* ++Target_arm<big_endian>::rel_irelative_section(Layout* layout) ++{ ++ if (this->rel_irelative_ == NULL) ++ { ++ // Delegate the creation to rel_dyn_section so as to ensure their order in ++ // the output section. ++ this->rel_dyn_section(layout); ++ gold_assert(this->rel_irelative_ != NULL ++ && (this->rel_dyn_->output_section() ++ == this->rel_irelative_->output_section())); ++ } ++ return this->rel_irelative_; ++} ++ ++ + // Insn_template methods. + + // Return byte size of an instruction template. +@@ -7221,24 +7305,80 @@ template<bool big_endian> + class Output_data_plt_arm : public Output_section_data + { + public: ++ // Unlike aarch64, which records symbol value in "addend" field of relocations ++ // and could be done at the same time an IRelative reloc is created for the ++ // symbol, arm puts the symbol value into "GOT" table, which, however, is ++ // issued later in Output_data_plt_arm::do_write(). So we have a struct here ++ // to keep necessary symbol information for later use in do_write. We usually ++ // have only a very limited number of ifuncs, so the extra data required here ++ // is also limited. ++ ++ struct IRelative_data ++ { ++ IRelative_data(Sized_symbol<32>* sized_symbol) ++ : symbol_is_global_(true) ++ { ++ u_.global = sized_symbol; ++ } ++ ++ IRelative_data(Sized_relobj_file<32, big_endian>* relobj, ++ unsigned int index) ++ : symbol_is_global_(false) ++ { ++ u_.local.relobj = relobj; ++ u_.local.index = index; ++ } ++ ++ union ++ { ++ Sized_symbol<32>* global; ++ ++ struct ++ { ++ Sized_relobj_file<32, big_endian>* relobj; ++ unsigned int index; ++ } local; ++ } u_; ++ ++ bool symbol_is_global_; ++ }; ++ + typedef Output_data_reloc<elfcpp::SHT_REL, true, 32, big_endian> + Reloc_section; + +- Output_data_plt_arm(Layout*, uint64_t addralign, Output_data_space*); ++ Output_data_plt_arm(Layout* layout, uint64_t addralign, ++ Arm_output_data_got<big_endian>* got, ++ Output_data_space* got_plt, ++ Output_data_space* got_irelative); + + // Add an entry to the PLT. + void +- add_entry(Symbol* gsym); ++ add_entry(Symbol_table* symtab, Layout* layout, Symbol* gsym); ++ ++ // Add the relocation for a plt entry. ++ void ++ add_relocation(Symbol_table* symtab, Layout* layout, ++ Symbol* gsym, unsigned int got_offset); ++ ++ // Add an entry to the PLT for a local STT_GNU_IFUNC symbol. ++ unsigned int ++ add_local_ifunc_entry(Symbol_table* symtab, Layout*, ++ Sized_relobj_file<32, big_endian>* relobj, ++ unsigned int local_sym_index); + + // Return the .rel.plt section data. + const Reloc_section* + rel_plt() const + { return this->rel_; } + ++ // Return the PLT relocation container for IRELATIVE. ++ Reloc_section* ++ rel_irelative(Symbol_table*, Layout*); ++ + // Return the number of PLT entries. + unsigned int + entry_count() const +- { return this->count_; } ++ { return this->count_ + this->irelative_count_; } + + // Return the offset of the first non-reserved PLT entry. + unsigned int +@@ -7250,6 +7390,14 @@ class Output_data_plt_arm : public Output_section_data + get_plt_entry_size() const + { return this->do_get_plt_entry_size(); } + ++ // Return the PLT address for globals. ++ uint32_t ++ address_for_global(const Symbol*) const; ++ ++ // Return the PLT address for locals. ++ uint32_t ++ address_for_local(const Relobj*, unsigned int symndx) const; ++ + protected: + // Fill in the first PLT entry. + void +@@ -7298,19 +7446,37 @@ class Output_data_plt_arm : public Output_section_data + set_final_data_size() + { + this->set_data_size(this->first_plt_entry_offset() +- + this->count_ * this->get_plt_entry_size()); ++ + ((this->count_ + this->irelative_count_) ++ * this->get_plt_entry_size())); + } + + // Write out the PLT data. + void + do_write(Output_file*); + ++ // Record irelative symbol data. ++ void insert_irelative_data(const IRelative_data& idata) ++ { irelative_data_vec_.push_back(idata); } ++ + // The reloc section. + Reloc_section* rel_; ++ // The IRELATIVE relocs, if necessary. These must follow the ++ // regular PLT relocations. ++ Reloc_section* irelative_rel_; ++ // The .got section. ++ Arm_output_data_got<big_endian>* got_; + // The .got.plt section. + Output_data_space* got_plt_; ++ // The part of the .got.plt section used for IRELATIVE relocs. ++ Output_data_space* got_irelative_; + // The number of PLT entries. + unsigned int count_; ++ // Number of PLT entries with R_ARM_IRELATIVE relocs. These ++ // follow the regular PLT entries. ++ unsigned int irelative_count_; ++ // Vector for irelative data. ++ typedef std::vector<IRelative_data> IRelative_data_vec; ++ IRelative_data_vec irelative_data_vec_; + }; + + // Create the PLT section. The ordinary .got section is an argument, +@@ -7318,10 +7484,14 @@ class Output_data_plt_arm : public Output_section_data + // section just for PLT entries. + + template<bool big_endian> +-Output_data_plt_arm<big_endian>::Output_data_plt_arm(Layout* layout, +- uint64_t addralign, +- Output_data_space* got_plt) +- : Output_section_data(addralign), got_plt_(got_plt), count_(0) ++Output_data_plt_arm<big_endian>::Output_data_plt_arm( ++ Layout* layout, uint64_t addralign, ++ Arm_output_data_got<big_endian>* got, ++ Output_data_space* got_plt, ++ Output_data_space* got_irelative) ++ : Output_section_data(addralign), irelative_rel_(NULL), ++ got_(got), got_plt_(got_plt), got_irelative_(got_irelative), ++ count_(0), irelative_count_(0) + { + this->rel_ = new Reloc_section(false); + layout->add_output_section_data(".rel.plt", elfcpp::SHT_REL, +@@ -7340,40 +7510,210 @@ Output_data_plt_arm<big_endian>::do_adjust_output_section(Output_section* os) + + template<bool big_endian> + void +-Output_data_plt_arm<big_endian>::add_entry(Symbol* gsym) ++Output_data_plt_arm<big_endian>::add_entry(Symbol_table* symtab, ++ Layout* layout, ++ Symbol* gsym) + { + gold_assert(!gsym->has_plt_offset()); + +- // Note that when setting the PLT offset we skip the initial +- // reserved PLT entry. +- gsym->set_plt_offset((this->count_) * this->get_plt_entry_size() +- + this->first_plt_entry_offset()); ++ unsigned int* entry_count; ++ Output_section_data_build* got; ++ ++ // We have 2 different types of plt entry here, normal and ifunc. ++ ++ // For normal plt, the offset begins with first_plt_entry_offset(20), and the ++ // 1st entry offset would be 20, the second 32, third 44 ... etc. ++ ++ // For ifunc plt, the offset begins with 0. So the first offset would 0, ++ // second 12, third 24 ... etc. ++ ++ // IFunc plt entries *always* come after *normal* plt entries. ++ ++ // Notice, when computing the plt address of a certain symbol, "plt_address + ++ // plt_offset" is no longer correct. Use target->plt_address_for_global() or ++ // target->plt_address_for_local() instead. ++ ++ int begin_offset = 0; ++ if (gsym->type() == elfcpp::STT_GNU_IFUNC ++ && gsym->can_use_relative_reloc(false)) ++ { ++ entry_count = &this->irelative_count_; ++ got = this->got_irelative_; ++ // For irelative plt entries, offset is relative to the end of normal plt ++ // entries, so it starts from 0. ++ begin_offset = 0; ++ // Record symbol information. ++ this->insert_irelative_data( ++ IRelative_data(symtab->get_sized_symbol<32>(gsym))); ++ } ++ else ++ { ++ entry_count = &this->count_; ++ got = this->got_plt_; ++ // Note that for normal plt entries, when setting the PLT offset we skip ++ // the initial reserved PLT entry. ++ begin_offset = this->first_plt_entry_offset(); ++ } ++ ++ gsym->set_plt_offset(begin_offset ++ + (*entry_count) * this->get_plt_entry_size()); + +- ++this->count_; ++ ++(*entry_count); + +- section_offset_type got_offset = this->got_plt_->current_data_size(); ++ section_offset_type got_offset = got->current_data_size(); + + // Every PLT entry needs a GOT entry which points back to the PLT + // entry (this will be changed by the dynamic linker, normally + // lazily when the function is called). +- this->got_plt_->set_current_data_size(got_offset + 4); ++ got->set_current_data_size(got_offset + 4); + + // Every PLT entry needs a reloc. +- gsym->set_needs_dynsym_entry(); +- this->rel_->add_global(gsym, elfcpp::R_ARM_JUMP_SLOT, this->got_plt_, +- got_offset); ++ this->add_relocation(symtab, layout, gsym, got_offset); + + // Note that we don't need to save the symbol. The contents of the + // PLT are independent of which symbols are used. The symbols only + // appear in the relocations. + } + ++// Add an entry to the PLT for a local STT_GNU_IFUNC symbol. Return ++// the PLT offset. ++ ++template<bool big_endian> ++unsigned int ++Output_data_plt_arm<big_endian>::add_local_ifunc_entry( ++ Symbol_table* symtab, ++ Layout* layout, ++ Sized_relobj_file<32, big_endian>* relobj, ++ unsigned int local_sym_index) ++{ ++ this->insert_irelative_data(IRelative_data(relobj, local_sym_index)); ++ ++ // Notice, when computingthe plt entry address, "plt_address + plt_offset" is ++ // no longer correct. Use target->plt_address_for_local() instead. ++ unsigned int plt_offset = this->irelative_count_ * this->get_plt_entry_size(); ++ ++this->irelative_count_; ++ ++ section_offset_type got_offset = this->got_irelative_->current_data_size(); ++ ++ // Every PLT entry needs a GOT entry which points back to the PLT ++ // entry. ++ this->got_irelative_->set_current_data_size(got_offset + 4); ++ ++ ++ // Every PLT entry needs a reloc. ++ Reloc_section* rel = this->rel_irelative(symtab, layout); ++ rel->add_symbolless_local_addend(relobj, local_sym_index, ++ elfcpp::R_ARM_IRELATIVE, ++ this->got_irelative_, got_offset); ++ return plt_offset; ++} ++ ++ ++// Add the relocation for a PLT entry. ++ ++template<bool big_endian> ++void ++Output_data_plt_arm<big_endian>::add_relocation( ++ Symbol_table* symtab, Layout* layout, Symbol* gsym, unsigned int got_offset) ++{ ++ if (gsym->type() == elfcpp::STT_GNU_IFUNC ++ && gsym->can_use_relative_reloc(false)) ++ { ++ Reloc_section* rel = this->rel_irelative(symtab, layout); ++ rel->add_symbolless_global_addend(gsym, elfcpp::R_ARM_IRELATIVE, ++ this->got_irelative_, got_offset); ++ } ++ else ++ { ++ gsym->set_needs_dynsym_entry(); ++ this->rel_->add_global(gsym, elfcpp::R_ARM_JUMP_SLOT, this->got_plt_, ++ got_offset); ++ } ++} ++ ++ ++// Create the irelative relocation data. ++ ++template<bool big_endian> ++typename Output_data_plt_arm<big_endian>::Reloc_section* ++Output_data_plt_arm<big_endian>::rel_irelative(Symbol_table* symtab, ++ Layout* layout) ++{ ++ if (this->irelative_rel_ == NULL) ++ { ++ // Since irelative relocations goes into 'rel.dyn', we delegate the ++ // creation of irelative_rel_ to where rel_dyn section gets created. ++ Target_arm<big_endian>* arm_target = ++ Target_arm<big_endian>::default_target(); ++ this->irelative_rel_ = arm_target->rel_irelative_section(layout); ++ ++ // Make sure we have a place for the TLSDESC relocations, in ++ // case we see any later on. ++ // this->rel_tlsdesc(layout); ++ if (parameters->doing_static_link()) ++ { ++ // A statically linked executable will only have a .rel.plt section to ++ // hold R_ARM_IRELATIVE relocs for STT_GNU_IFUNC symbols. The library ++ // will use these symbols to locate the IRELATIVE relocs at program ++ // startup time. ++ symtab->define_in_output_data("__rel_iplt_start", NULL, ++ Symbol_table::PREDEFINED, ++ this->irelative_rel_, 0, 0, ++ elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL, ++ elfcpp::STV_HIDDEN, 0, false, true); ++ symtab->define_in_output_data("__rel_iplt_end", NULL, ++ Symbol_table::PREDEFINED, ++ this->irelative_rel_, 0, 0, ++ elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL, ++ elfcpp::STV_HIDDEN, 0, true, true); ++ } ++ } ++ return this->irelative_rel_; ++} ++ ++ ++// Return the PLT address for a global symbol. ++ ++template<bool big_endian> ++uint32_t ++Output_data_plt_arm<big_endian>::address_for_global(const Symbol* gsym) const ++{ ++ uint64_t begin_offset = 0; ++ if (gsym->type() == elfcpp::STT_GNU_IFUNC ++ && gsym->can_use_relative_reloc(false)) ++ { ++ begin_offset = (this->first_plt_entry_offset() + ++ this->count_ * this->get_plt_entry_size()); ++ } ++ return this->address() + begin_offset + gsym->plt_offset(); ++} ++ ++ ++// Return the PLT address for a local symbol. These are always ++// IRELATIVE relocs. ++ ++template<bool big_endian> ++uint32_t ++Output_data_plt_arm<big_endian>::address_for_local( ++ const Relobj* object, ++ unsigned int r_sym) const ++{ ++ return (this->address() ++ + this->first_plt_entry_offset() ++ + this->count_ * this->get_plt_entry_size() ++ + object->local_plt_offset(r_sym)); ++} ++ ++ + template<bool big_endian> + class Output_data_plt_arm_standard : public Output_data_plt_arm<big_endian> + { + public: +- Output_data_plt_arm_standard(Layout* layout, Output_data_space* got_plt) +- : Output_data_plt_arm<big_endian>(layout, 4, got_plt) ++ Output_data_plt_arm_standard(Layout* layout, ++ Arm_output_data_got<big_endian>* got, ++ Output_data_space* got_plt, ++ Output_data_space* got_irelative) ++ : Output_data_plt_arm<big_endian>(layout, 4, got, got_plt, got_irelative) + { } + + protected: +@@ -7485,8 +7825,11 @@ Output_data_plt_arm<big_endian>::do_write(Output_file* of) + unsigned char* const oview = of->get_output_view(offset, oview_size); + + const off_t got_file_offset = this->got_plt_->offset(); ++ gold_assert(got_file_offset + this->got_plt_->data_size() ++ == this->got_irelative_->offset()); + const section_size_type got_size = +- convert_to_section_size_type(this->got_plt_->data_size()); ++ convert_to_section_size_type(this->got_plt_->data_size() ++ + this->got_irelative_->data_size()); + unsigned char* const got_view = of->get_output_view(got_file_offset, + got_size); + unsigned char* pov = oview; +@@ -7505,7 +7848,8 @@ Output_data_plt_arm<big_endian>::do_write(Output_file* of) + + unsigned int plt_offset = this->first_plt_entry_offset(); + unsigned int got_offset = 12; +- const unsigned int count = this->count_; ++ const unsigned int count = this->count_ + this->irelative_count_; ++ gold_assert(this->irelative_count_ == this->irelative_data_vec_.size()); + for (unsigned int i = 0; + i < count; + ++i, +@@ -7518,8 +7862,33 @@ Output_data_plt_arm<big_endian>::do_write(Output_file* of) + this->fill_plt_entry(pov, got_address, plt_address, + got_offset, plt_offset); + +- // Set the entry in the GOT. +- elfcpp::Swap<32, big_endian>::writeval(got_pov, plt_address); ++ Arm_address value; ++ if (i < this->count_) ++ { ++ // For non-irelative got entries, the value is the beginning of plt. ++ value = plt_address; ++ } ++ else ++ { ++ // For irelative got entries, the value is the (global/local) symbol ++ // address. ++ const IRelative_data& idata = ++ this->irelative_data_vec_[i - this->count_]; ++ if (idata.symbol_is_global_) ++ { ++ // Set the entry in the GOT for irelative symbols. The content is ++ // the address of the ifunc, not the address of plt start. ++ const Sized_symbol<32>* sized_symbol = idata.u_.global; ++ gold_assert(sized_symbol->type() == elfcpp::STT_GNU_IFUNC); ++ value = sized_symbol->value(); ++ } ++ else ++ { ++ value = idata.u_.local.relobj->local_symbol_value( ++ idata.u_.local.index, 0); ++ } ++ } ++ elfcpp::Swap<32, big_endian>::writeval(got_pov, value); + } + + gold_assert(static_cast<section_size_type>(pov - oview) == oview_size); +@@ -7529,6 +7898,7 @@ Output_data_plt_arm<big_endian>::do_write(Output_file* of) + of->write_output_view(got_file_offset, got_size, got_view); + } + ++ + // Create a PLT entry for a global symbol. + + template<bool big_endian> +@@ -7540,20 +7910,58 @@ Target_arm<big_endian>::make_plt_entry(Symbol_table* symtab, Layout* layout, + return; + + if (this->plt_ == NULL) ++ this->make_plt_section(symtab, layout); ++ ++ this->plt_->add_entry(symtab, layout, gsym); ++} ++ ++ ++// Create the PLT section. ++template<bool big_endian> ++void ++Target_arm<big_endian>::make_plt_section( ++ Symbol_table* symtab, Layout* layout) ++{ ++ if (this->plt_ == NULL) + { +- // Create the GOT sections first. ++ // Create the GOT section first. + this->got_section(symtab, layout); + +- this->plt_ = this->make_data_plt(layout, this->got_plt_); ++ // GOT for irelatives is create along with got.plt. ++ gold_assert(this->got_ != NULL ++ && this->got_plt_ != NULL ++ && this->got_irelative_ != NULL); ++ this->plt_ = this->make_data_plt(layout, this->got_, this->got_plt_, ++ this->got_irelative_); + + layout->add_output_section_data(".plt", elfcpp::SHT_PROGBITS, + (elfcpp::SHF_ALLOC + | elfcpp::SHF_EXECINSTR), + this->plt_, ORDER_PLT, false); + } +- this->plt_->add_entry(gsym); + } + ++ ++// Make a PLT entry for a local STT_GNU_IFUNC symbol. ++ ++template<bool big_endian> ++void ++Target_arm<big_endian>::make_local_ifunc_plt_entry( ++ Symbol_table* symtab, Layout* layout, ++ Sized_relobj_file<32, big_endian>* relobj, ++ unsigned int local_sym_index) ++{ ++ if (relobj->local_has_plt_offset(local_sym_index)) ++ return; ++ if (this->plt_ == NULL) ++ this->make_plt_section(symtab, layout); ++ unsigned int plt_offset = this->plt_->add_local_ifunc_entry(symtab, layout, ++ relobj, ++ local_sym_index); ++ relobj->set_local_plt_offset(local_sym_index, plt_offset); ++} ++ ++ + // Return the number of entries in the PLT. + + template<bool big_endian> +@@ -7823,6 +8231,7 @@ Target_arm<big_endian>::Scan::check_non_pic(Relobj* object, + case elfcpp::R_ARM_JUMP_SLOT: + case elfcpp::R_ARM_ABS32: + case elfcpp::R_ARM_ABS32_NOI: ++ case elfcpp::R_ARM_IRELATIVE: + case elfcpp::R_ARM_PC24: + // FIXME: The following 3 types are not supported by Android's dynamic + // linker. +@@ -7853,6 +8262,27 @@ Target_arm<big_endian>::Scan::check_non_pic(Relobj* object, + } + } + ++ ++// Return whether we need to make a PLT entry for a relocation of the ++// given type against a STT_GNU_IFUNC symbol. ++ ++template<bool big_endian> ++bool ++Target_arm<big_endian>::Scan::reloc_needs_plt_for_ifunc( ++ Sized_relobj_file<32, big_endian>* object, ++ unsigned int r_type) ++{ ++ int flags = Scan::get_reference_flags(r_type); ++ if (flags & Symbol::TLS_REF) ++ { ++ gold_error(_("%s: unsupported TLS reloc %u for IFUNC symbol"), ++ object->name().c_str(), r_type); ++ return false; ++ } ++ return flags != 0; ++} ++ ++ + // Scan a relocation for a local symbol. + // FIXME: This only handles a subset of relocation types used by Android + // on ARM v5te devices. +@@ -7874,6 +8304,15 @@ Target_arm<big_endian>::Scan::local(Symbol_table* symtab, + return; + + r_type = get_real_reloc_type(r_type); ++ ++ // A local STT_GNU_IFUNC symbol may require a PLT entry. ++ bool is_ifunc = lsym.get_st_type() == elfcpp::STT_GNU_IFUNC; ++ if (is_ifunc && this->reloc_needs_plt_for_ifunc(object, r_type)) ++ { ++ unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info()); ++ target->make_local_ifunc_plt_entry(symtab, layout, object, r_sym); ++ } ++ + switch (r_type) + { + case elfcpp::R_ARM_NONE: +@@ -7898,7 +8337,7 @@ Target_arm<big_endian>::Scan::local(Symbol_table* symtab, + // we need to add check_non_pic(object, r_type) here. + rel_dyn->add_local_relative(object, r_sym, elfcpp::R_ARM_RELATIVE, + output_section, data_shndx, +- reloc.get_r_offset()); ++ reloc.get_r_offset(), is_ifunc); + } + break; + +@@ -8265,6 +8704,11 @@ Target_arm<big_endian>::Scan::global(Symbol_table* symtab, + && strcmp(gsym->name(), "_GLOBAL_OFFSET_TABLE_") == 0) + target->got_section(symtab, layout); + ++ // A STT_GNU_IFUNC symbol may require a PLT entry. ++ if (gsym->type() == elfcpp::STT_GNU_IFUNC ++ && this->reloc_needs_plt_for_ifunc(object, r_type)) ++ target->make_plt_entry(symtab, layout, gsym); ++ + r_type = get_real_reloc_type(r_type); + switch (r_type) + { +@@ -8309,6 +8753,24 @@ Target_arm<big_endian>::Scan::global(Symbol_table* symtab, + } + else if ((r_type == elfcpp::R_ARM_ABS32 + || r_type == elfcpp::R_ARM_ABS32_NOI) ++ && gsym->type() == elfcpp::STT_GNU_IFUNC ++ && gsym->can_use_relative_reloc(false) ++ && !gsym->is_from_dynobj() ++ && !gsym->is_undefined() ++ && !gsym->is_preemptible()) ++ { ++ // Use an IRELATIVE reloc for a locally defined STT_GNU_IFUNC ++ // symbol. This makes a function address in a PIE executable ++ // match the address in a shared library that it links against. ++ Reloc_section* rel_irelative = ++ target->rel_irelative_section(layout); ++ unsigned int r_type = elfcpp::R_ARM_IRELATIVE; ++ rel_irelative->add_symbolless_global_addend( ++ gsym, r_type, output_section, object, ++ data_shndx, reloc.get_r_offset()); ++ } ++ else if ((r_type == elfcpp::R_ARM_ABS32 ++ || r_type == elfcpp::R_ARM_ABS32_NOI) + && gsym->can_use_relative_reloc(false)) + { + Reloc_section* rel_dyn = target->rel_dyn_section(layout); +@@ -8442,7 +8904,13 @@ Target_arm<big_endian>::Scan::global(Symbol_table* symtab, + Arm_output_data_got<big_endian>* got = + target->got_section(symtab, layout); + if (gsym->final_value_is_known()) +- got->add_global(gsym, GOT_TYPE_STANDARD); ++ { ++ // For a STT_GNU_IFUNC symbol we want the PLT address. ++ if (gsym->type() == elfcpp::STT_GNU_IFUNC) ++ got->add_global_plt(gsym, GOT_TYPE_STANDARD); ++ else ++ got->add_global(gsym, GOT_TYPE_STANDARD); ++ } + else + { + // If this symbol is not fully resolved, we need to add a +@@ -8452,12 +8920,29 @@ Target_arm<big_endian>::Scan::global(Symbol_table* symtab, + || gsym->is_undefined() + || gsym->is_preemptible() + || (gsym->visibility() == elfcpp::STV_PROTECTED +- && parameters->options().shared())) ++ && parameters->options().shared()) ++ || (gsym->type() == elfcpp::STT_GNU_IFUNC ++ && parameters->options().output_is_position_independent())) + got->add_global_with_rel(gsym, GOT_TYPE_STANDARD, + rel_dyn, elfcpp::R_ARM_GLOB_DAT); + else + { +- if (got->add_global(gsym, GOT_TYPE_STANDARD)) ++ // For a STT_GNU_IFUNC symbol we want to write the PLT ++ // offset into the GOT, so that function pointer ++ // comparisons work correctly. ++ bool is_new; ++ if (gsym->type() != elfcpp::STT_GNU_IFUNC) ++ is_new = got->add_global(gsym, GOT_TYPE_STANDARD); ++ else ++ { ++ is_new = got->add_global_plt(gsym, GOT_TYPE_STANDARD); ++ // Tell the dynamic linker to use the PLT address ++ // when resolving relocations. ++ if (gsym->is_from_dynobj() ++ && !parameters->options().shared()) ++ gsym->set_needs_dynsym_value(); ++ } ++ if (is_new) + rel_dyn->add_global_relative( + gsym, elfcpp::R_ARM_RELATIVE, got, + gsym->got_offset(GOT_TYPE_STANDARD)); +@@ -8919,8 +9404,7 @@ Target_arm<big_endian>::Relocate::relocate( + if (gsym->use_plt_offset(Scan::get_reference_flags(r_type))) + { + // This uses a PLT, change the symbol value. +- symval.set_output_value(target->plt_section()->address() +- + gsym->plt_offset()); ++ symval.set_output_value(target->plt_address_for_global(gsym)); + psymval = &symval; + } + else if (gsym->is_weak_undefined()) +@@ -8958,6 +9442,13 @@ Target_arm<big_endian>::Relocate::relocate( + elfcpp::Elf_types<32>::Elf_WXword r_info = rel.get_r_info(); + unsigned int r_sym = elfcpp::elf_r_sym<32>(r_info); + thumb_bit = object->local_symbol_is_thumb_function(r_sym) ? 1 : 0; ++ ++ if (psymval->is_ifunc_symbol() && object->local_has_plt_offset(r_sym)) ++ { ++ symval.set_output_value( ++ target->plt_address_for_local(object, r_sym)); ++ psymval = &symval; ++ } + } + } + else +@@ -9936,7 +10427,7 @@ uint64_t + Target_arm<big_endian>::do_dynsym_value(const Symbol* gsym) const + { + gold_assert(gsym->is_from_dynobj() && gsym->has_plt_offset()); +- return this->plt_section()->address() + gsym->plt_offset(); ++ return this->plt_address_for_global(gsym); + } + + // Map platform-specific relocs to real relocs +@@ -11083,8 +11574,7 @@ Target_arm<big_endian>::scan_reloc_for_stub( + if (gsym->use_plt_offset(Scan::get_reference_flags(r_type))) + { + // This uses a PLT, change the symbol value. +- symval.set_output_value(this->plt_section()->address() +- + gsym->plt_offset()); ++ symval.set_output_value(this->plt_address_for_global(gsym)); + psymval = &symval; + target_is_thumb = false; + } +@@ -12187,8 +12677,13 @@ class Target_arm_nacl : public Target_arm<big_endian> + + protected: + virtual Output_data_plt_arm<big_endian>* +- do_make_data_plt(Layout* layout, Output_data_space* got_plt) +- { return new Output_data_plt_arm_nacl<big_endian>(layout, got_plt); } ++ do_make_data_plt( ++ Layout* layout, ++ Arm_output_data_got<big_endian>* got, ++ Output_data_space* got_plt, ++ Output_data_space* got_irelative) ++ { return new Output_data_plt_arm_nacl<big_endian>( ++ layout, got, got_plt, got_irelative); } + + private: + static const Target::Target_info arm_nacl_info; +@@ -12225,8 +12720,12 @@ template<bool big_endian> + class Output_data_plt_arm_nacl : public Output_data_plt_arm<big_endian> + { + public: +- Output_data_plt_arm_nacl(Layout* layout, Output_data_space* got_plt) +- : Output_data_plt_arm<big_endian>(layout, 16, got_plt) ++ Output_data_plt_arm_nacl( ++ Layout* layout, ++ Arm_output_data_got<big_endian>* got, ++ Output_data_space* got_plt, ++ Output_data_space* got_irelative) ++ : Output_data_plt_arm<big_endian>(layout, 16, got, got_plt, got_irelative) + { } + + protected: +diff --git a/gold/output.h b/gold/output.h +index ba0cdaa..599c2b7 100644 +--- a/gold/output.h ++++ b/gold/output.h +@@ -1714,6 +1714,17 @@ class Output_data_reloc<elfcpp::SHT_REL, dynamic, size, big_endian> + address, true, true, false, false)); + } + ++ void ++ add_local_relative(Sized_relobj<size, big_endian>* relobj, ++ unsigned int local_sym_index, unsigned int type, ++ Output_data* od, unsigned int shndx, Address address, ++ bool use_plt_offset) ++ { ++ this->add(od, Output_reloc_type(relobj, local_sym_index, type, shndx, ++ address, true, true, false, ++ use_plt_offset)); ++ } ++ + // Add a local relocation which does not use a symbol for the relocation, + // but which gets its addend from a symbol. + +-- +2.7.0 + |