X-Git-Url: http://drtracing.org/?a=blobdiff_plain;ds=sidebyside;f=gold%2Fpowerpc.cc;h=c269ae03514bf7ef5ed89b2b8f407a9f8d9c7319;hb=7229b687db8c5fe9c1534b763dea6d1211ff3993;hp=0442e56081fffd0d778261b00115d4819fb36aad;hpb=0cfb07174869f3542a96619fb36a85398af35da2;p=deliverable%2Fbinutils-gdb.git diff --git a/gold/powerpc.cc b/gold/powerpc.cc index 0442e56081..c269ae0351 100644 --- a/gold/powerpc.cc +++ b/gold/powerpc.cc @@ -1,6 +1,6 @@ // powerpc.cc -- powerpc target support for gold. -// Copyright (C) 2008-2014 Free Software Foundation, Inc. +// Copyright (C) 2008-2016 Free Software Foundation, Inc. // Written by David S. Miller // and David Edelsohn @@ -62,6 +62,18 @@ class Output_data_glink; template class Stub_table; +template +class Output_data_save_res; + +template +class Target_powerpc; + +struct Stub_table_owner +{ + Output_section* output_section; + const Output_section::Input_section* owner; +}; + inline bool is_branch_reloc(unsigned int r_type); @@ -77,7 +89,7 @@ public: const typename elfcpp::Ehdr& ehdr) : Sized_relobj_file(name, input_file, offset, ehdr), special_(0), has_small_toc_reloc_(false), opd_valid_(false), - opd_ent_(), access_from_map_(), has14_(), stub_table_(), + opd_ent_(), access_from_map_(), has14_(), stub_table_index_(), e_flags_(ehdr.get_e_flags()), st_other_() { this->set_abiversion(0); @@ -203,7 +215,7 @@ public: // Add a reference from SRC_OBJ, SRC_INDX to this object's .opd // section at DST_OFF. void - add_reference(Object* src_obj, + add_reference(Relobj* src_obj, unsigned int src_indx, typename elfcpp::Elf_types::Elf_Addr dst_off) { @@ -229,7 +241,7 @@ public: if (this->opd_ent_[i].gc_mark) { unsigned int shndx = this->opd_ent_[i].shndx; - symtab->gc()->worklist().push(Section_id(this, shndx)); + symtab->gc()->worklist().push_back(Section_id(this, shndx)); } } @@ -260,21 +272,34 @@ public: { return shndx < this->has14_.size() && this->has14_[shndx]; } void - set_stub_table(unsigned int shndx, Stub_table* stub_table) + set_stub_table(unsigned int shndx, unsigned int stub_index) { - if (shndx >= this->stub_table_.size()) - this->stub_table_.resize(shndx + 1); - this->stub_table_[shndx] = stub_table; + if (shndx >= this->stub_table_index_.size()) + this->stub_table_index_.resize(shndx + 1); + this->stub_table_index_[shndx] = stub_index; } Stub_table* stub_table(unsigned int shndx) { - if (shndx < this->stub_table_.size()) - return this->stub_table_[shndx]; + if (shndx < this->stub_table_index_.size()) + { + Target_powerpc* target + = static_cast*>( + parameters->sized_target()); + unsigned int indx = this->stub_table_index_[shndx]; + gold_assert(indx < target->stub_tables().size()); + return target->stub_tables()[indx]; + } return NULL; } + void + clear_stub_table() + { + this->stub_table_index_.clear(); + } + int abiversion() const { return this->e_flags_ & elfcpp::EF_PPC64_ABI; } @@ -343,7 +368,7 @@ private: std::vector has14_; // The stub table to use for a given input section. - std::vector*> stub_table_; + std::vector stub_table_index_; // Header e_flags elfcpp::Elf_Word e_flags_; @@ -487,7 +512,8 @@ class Target_powerpc : public Sized_target glink_(NULL), rela_dyn_(NULL), copy_relocs_(elfcpp::R_POWERPC_COPY), tlsld_got_offset_(-1U), stub_tables_(), branch_lookup_table_(), branch_info_(), - plt_thread_safe_(false) + plt_thread_safe_(false), relax_failed_(false), relax_fail_count_(0), + stub_group_size_(0), savres_section_(0) { } @@ -562,9 +588,6 @@ class Target_powerpc : public Sized_target ppc_object->set_has_14bit_branch(data_shndx); } - Stub_table* - new_stub_table(); - void do_define_standard_symbols(Symbol_table*, Layout*); @@ -604,6 +627,14 @@ class Target_powerpc : public Sized_target do_can_check_for_function_pointers() const { return true; } + // Adjust -fsplit-stack code which calls non-split-stack code. + void + do_calls_non_split(Relobj* object, unsigned int shndx, + section_offset_type fnoffset, section_size_type fnsize, + const unsigned char* prelocs, size_t reloc_count, + unsigned char* view, section_size_type view_size, + std::string* from, std::string* to) const; + // Relocate a section. void relocate_section(const Relocate_info*, @@ -632,6 +663,21 @@ class Target_powerpc : public Sized_target const unsigned char* plocal_symbols, Relocatable_relocs*); + // Scan the relocs for --emit-relocs. + void + emit_relocs_scan(Symbol_table* symtab, + Layout* layout, + Sized_relobj_file* object, + unsigned int data_shndx, + unsigned int sh_type, + const unsigned char* prelocs, + size_t reloc_count, + Output_section* output_section, + bool needs_special_offset_handling, + size_t local_symbol_count, + const unsigned char* plocal_syms, + Relocatable_relocs* rr); + // Emit relocations for a section. void relocate_relocs(const Relocate_info*, @@ -641,7 +687,6 @@ class Target_powerpc : public Sized_target Output_section* output_section, typename elfcpp::Elf_types::Elf_Off offset_in_output_section, - const Relocatable_relocs*, unsigned char*, Address view_address, section_size_type, @@ -748,6 +793,12 @@ class Target_powerpc : public Sized_target return 24; } + Output_data_save_res* + savres_section() const + { + return this->savres_section_; + } + // Add any special sections for this symbol to the gc work list. // For powerpc64, this adds the code section of a function // descriptor. @@ -760,9 +811,9 @@ class Target_powerpc : public Sized_target // section of a function descriptor. void do_gc_add_reference(Symbol_table* symtab, - Object* src_obj, + Relobj* src_obj, unsigned int src_shndx, - Object* dst_obj, + Relobj* dst_obj, unsigned int dst_shndx, Address dst_off) const; @@ -1015,11 +1066,11 @@ class Target_powerpc : public Sized_target bool issued_non_pic_error_; }; - Address - symval_for_branch(const Symbol_table* symtab, Address value, + bool + symval_for_branch(const Symbol_table* symtab, const Sized_symbol* gsym, Powerpc_relobj* object, - unsigned int *dest_shndx); + Address *value, unsigned int *dest_shndx); // The class which implements relocation. class Relocate : protected Track_tls @@ -1036,13 +1087,10 @@ class Target_powerpc : public Sized_target // Do a relocation. Return false if the caller should not issue // any warnings about this relocation. inline bool - relocate(const Relocate_info*, Target_powerpc*, - Output_section*, size_t relnum, - const elfcpp::Rela&, - unsigned int r_type, const Sized_symbol*, - const Symbol_value*, - unsigned char*, - typename elfcpp::Elf_types::Elf_Addr, + relocate(const Relocate_info*, unsigned int, + Target_powerpc*, Output_section*, size_t, const unsigned char*, + const Sized_symbol*, const Symbol_value*, + unsigned char*, typename elfcpp::Elf_types::Elf_Addr, section_size_type); }; @@ -1072,19 +1120,6 @@ class Target_powerpc : public Sized_target } }; - // A class which returns the size required for a relocation type, - // used while scanning relocs during a relocatable link. - class Relocatable_size_for_reloc - { - public: - unsigned int - get_size_for_reloc(unsigned int, Relobj*) - { - gold_unreachable(); - return 0; - } - }; - // Optimize the TLS relocation type based on what we know about the // symbol. IS_FINAL is true if the final address of this symbol is // known at link time. @@ -1171,15 +1206,18 @@ class Target_powerpc : public Sized_target unsigned int shndx, Output_section* output_section, Symbol* sym, const elfcpp::Rela& reloc) { + unsigned int r_type = elfcpp::elf_r_type(reloc.get_r_info()); this->copy_relocs_.copy_reloc(symtab, layout, symtab->get_sized_symbol(sym), object, shndx, output_section, - reloc, this->rela_dyn_section(layout)); + r_type, reloc.get_r_offset(), + reloc.get_r_addend(), + this->rela_dyn_section(layout)); } // Look over all the input sections, deciding where to place stubs. void - group_sections(Layout*, const Task*); + group_sections(Layout*, const Task*, bool); // Sort output sections by address. struct Sort_sections @@ -1206,7 +1244,7 @@ class Target_powerpc : public Sized_target { } // If this branch needs a plt call stub, or a long branch stub, make one. - void + bool make_stub(Stub_table*, Stub_table*, Symbol_table*) const; @@ -1284,6 +1322,12 @@ class Target_powerpc : public Sized_target Branches branch_info_; bool plt_thread_safe_; + + bool relax_failed_; + int relax_fail_count_; + int32_t stub_group_size_; + + Output_data_save_res *savres_section_; }; template<> @@ -1310,7 +1354,8 @@ Target::Target_info Target_powerpc<32, true>::powerpc_info = 0, // large_common_section_flags NULL, // attributes_section NULL, // attributes_vendor - "_start" // entry_symbol_name + "_start", // entry_symbol_name + 32, // hash_entry_size }; template<> @@ -1337,7 +1382,8 @@ Target::Target_info Target_powerpc<32, false>::powerpc_info = 0, // large_common_section_flags NULL, // attributes_section NULL, // attributes_vendor - "_start" // entry_symbol_name + "_start", // entry_symbol_name + 32, // hash_entry_size }; template<> @@ -1364,7 +1410,8 @@ Target::Target_info Target_powerpc<64, true>::powerpc_info = 0, // large_common_section_flags NULL, // attributes_section NULL, // attributes_vendor - "_start" // entry_symbol_name + "_start", // entry_symbol_name + 32, // hash_entry_size }; template<> @@ -1391,7 +1438,8 @@ Target::Target_info Target_powerpc<64, false>::powerpc_info = 0, // large_common_section_flags NULL, // attributes_section NULL, // attributes_vendor - "_start" // entry_symbol_name + "_start", // entry_symbol_name + 32, // hash_entry_size }; inline bool @@ -1471,6 +1519,7 @@ public: private: typedef Powerpc_relocate_functions This; typedef typename elfcpp::Elf_types::Elf_Addr Address; + typedef typename elfcpp::Elf_types::Elf_Swxword SignedAddress; template static inline bool @@ -1626,7 +1675,17 @@ public: addr16_ds(unsigned char* view, Address value, Overflow_check overflow) { Status stat = This::template rela<16,16>(view, 0, 0xfffc, value, overflow); - if (overflow != CHECK_NONE && (value & 3) != 0) + if ((value & 3) != 0) + stat = STATUS_OVERFLOW; + return stat; + } + + // R_POWERPC_ADDR16_DQ: (Symbol + Addend) & 0xfff0 + static inline Status + addr16_dq(unsigned char* view, Address value, Overflow_check overflow) + { + Status stat = This::template rela<16,16>(view, 0, 0xfff0, value, overflow); + if ((value & 15) != 0) stat = STATUS_OVERFLOW; return stat; } @@ -1670,6 +1729,20 @@ public: stat = STATUS_OVERFLOW; return stat; } + + // R_POWERPC_REL16DX_HA + static inline Status + addr16dx_ha(unsigned char *view, Address value, Overflow_check overflow) + { + typedef typename elfcpp::Swap<32, big_endian>::Valtype Valtype; + Valtype* wv = reinterpret_cast(view); + Valtype val = elfcpp::Swap<32, big_endian>::readval(wv); + value += 0x8000; + value = static_cast(value) >> 16; + val |= (value & 0xffc1) | ((value & 0x3e) << 15); + elfcpp::Swap<32, big_endian>::writeval(wv, val); + return overflowed<16>(value, overflow); + } }; // Set ABI version for input and output. @@ -2118,7 +2191,10 @@ public: symtab_(symtab), layout_(layout), header_ent_cnt_(size == 32 ? 3 : 1), header_index_(size == 32 ? 0x2000 : 0) - { } + { + if (size == 64) + this->set_addralign(256); + } // Override all the Output_data_got methods we use so as to first call // reserve_ent(). @@ -2361,27 +2437,13 @@ class Stub_control // value of the parameter --stub-group-size. If --stub-group-size // is passed a negative value, we restrict stubs to be always before // the stubbed branches. - Stub_control(int32_t size) + Stub_control(int32_t size, bool no_size_errors) : state_(NO_GROUP), stub_group_size_(abs(size)), stub14_group_size_(abs(size) >> 10), - stubs_always_before_branch_(size < 0), suppress_size_errors_(false), + stubs_always_before_branch_(size < 0), + suppress_size_errors_(no_size_errors), group_end_addr_(0), owner_(NULL), output_section_(NULL) { - if (stub_group_size_ == 1) - { - // Default values. - if (stubs_always_before_branch_) - { - stub_group_size_ = 0x1e00000; - stub14_group_size_ = 0x7800; - } - else - { - stub_group_size_ = 0x1c00000; - stub14_group_size_ = 0x7000; - } - suppress_size_errors_ = true; - } } // Return true iff input section can be handled by current stub @@ -2399,6 +2461,14 @@ class Stub_control output_section() { return output_section_; } + void + set_output_and_owner(Output_section* o, + const Output_section::Input_section* i) + { + this->output_section_ = o; + this->owner_ = i; + } + private: typedef enum { @@ -2487,12 +2557,14 @@ Stub_control::can_add_to_stub_group(Output_section* o, template void Target_powerpc::group_sections(Layout* layout, - const Task*) + const Task*, + bool no_size_errors) { - Stub_control stub_control(parameters->options().stub_group_size()); + Stub_control stub_control(this->stub_group_size_, no_size_errors); // Group input sections and insert stub table - Stub_table* stub_table = NULL; + Stub_table_owner* table_owner = NULL; + std::vector tables; Layout::Section_list section_list; layout->get_executable_sections(§ion_list); std::stable_sort(section_list.begin(), section_list.end(), Sort_sections()); @@ -2506,49 +2578,89 @@ Target_powerpc::group_sections(Layout* layout, i != (*o)->input_sections().rend(); ++i) { - if (i->is_input_section()) + if (i->is_input_section() + || i->is_relaxed_input_section()) { Powerpc_relobj* ppcobj = static_cast *>(i->relobj()); bool has14 = ppcobj->has_14bit_branch(i->shndx()); if (!stub_control.can_add_to_stub_group(*o, &*i, has14)) { - stub_table->init(stub_control.owner(), - stub_control.output_section()); - stub_table = NULL; + table_owner->output_section = stub_control.output_section(); + table_owner->owner = stub_control.owner(); + stub_control.set_output_and_owner(*o, &*i); + table_owner = NULL; } - if (stub_table == NULL) - stub_table = this->new_stub_table(); - ppcobj->set_stub_table(i->shndx(), stub_table); + if (table_owner == NULL) + { + table_owner = new Stub_table_owner; + tables.push_back(table_owner); + } + ppcobj->set_stub_table(i->shndx(), tables.size() - 1); } } } - if (stub_table != NULL) + if (table_owner != NULL) { const Output_section::Input_section* i = stub_control.owner(); - if (!i->is_input_section()) + + if (tables.size() >= 2 && tables[tables.size() - 2]->owner == i) { // Corner case. A new stub group was made for the first // section (last one looked at here) for some reason, but // the first section is already being used as the owner for // a stub table for following sections. Force it into that // stub group. - gold_assert(this->stub_tables_.size() >= 2); - this->stub_tables_.pop_back(); - delete stub_table; + tables.pop_back(); + delete table_owner; Powerpc_relobj* ppcobj = static_cast *>(i->relobj()); - ppcobj->set_stub_table(i->shndx(), this->stub_tables_.back()); + ppcobj->set_stub_table(i->shndx(), tables.size() - 1); + } + else + { + table_owner->output_section = stub_control.output_section(); + table_owner->owner = i; } + } + for (typename std::vector::iterator t = tables.begin(); + t != tables.end(); + ++t) + { + Stub_table* stub_table; + + if ((*t)->owner->is_input_section()) + stub_table = new Stub_table(this, + (*t)->output_section, + (*t)->owner); + else if ((*t)->owner->is_relaxed_input_section()) + stub_table = static_cast*>( + (*t)->owner->relaxed_input_section()); else - stub_table->init(i, stub_control.output_section()); + gold_unreachable(); + this->stub_tables_.push_back(stub_table); + delete *t; } } +static unsigned long +max_branch_delta (unsigned int r_type) +{ + if (r_type == elfcpp::R_POWERPC_REL14 + || r_type == elfcpp::R_POWERPC_REL14_BRTAKEN + || r_type == elfcpp::R_POWERPC_REL14_BRNTAKEN) + return 1L << 15; + if (r_type == elfcpp::R_POWERPC_REL24 + || r_type == elfcpp::R_PPC_PLTREL24 + || r_type == elfcpp::R_PPC_LOCAL24PC) + return 1L << 25; + return 0; +} + // If this branch needs a plt call stub, or a long branch stub, make one. template -void +bool Target_powerpc::Branch_info::make_stub( Stub_table* stub_table, Stub_table* ifunc_stub_table, @@ -2581,27 +2693,25 @@ Target_powerpc::Branch_info::make_stub( stub_table = ifunc_stub_table; } gold_assert(stub_table != NULL); + Address from = this->object_->get_output_section_offset(this->shndx_); + if (from != invalid_address) + from += (this->object_->output_section(this->shndx_)->address() + + this->offset_); if (gsym != NULL) - stub_table->add_plt_call_entry(this->object_, gsym, - this->r_type_, this->addend_); + return stub_table->add_plt_call_entry(from, + this->object_, gsym, + this->r_type_, this->addend_); else - stub_table->add_plt_call_entry(this->object_, this->r_sym_, - this->r_type_, this->addend_); + return stub_table->add_plt_call_entry(from, + this->object_, this->r_sym_, + this->r_type_, this->addend_); } } else { - unsigned long max_branch_offset; - if (this->r_type_ == elfcpp::R_POWERPC_REL14 - || this->r_type_ == elfcpp::R_POWERPC_REL14_BRTAKEN - || this->r_type_ == elfcpp::R_POWERPC_REL14_BRNTAKEN) - max_branch_offset = 1 << 15; - else if (this->r_type_ == elfcpp::R_POWERPC_REL24 - || this->r_type_ == elfcpp::R_PPC_PLTREL24 - || this->r_type_ == elfcpp::R_PPC_LOCAL24PC) - max_branch_offset = 1 << 25; - else - return; + Address max_branch_offset = max_branch_delta(this->r_type_); + if (max_branch_offset == 0) + return true; Address from = this->object_->get_output_section_offset(this->shndx_); gold_assert(from != invalid_address); from += (this->object_->output_section(this->shndx_)->address() @@ -2616,16 +2726,16 @@ Target_powerpc::Branch_info::make_stub( Object* symobj = gsym->object(); if (symobj->is_dynamic() || symobj->pluginobj() != NULL) - return; + return true; bool is_ordinary; unsigned int shndx = gsym->shndx(&is_ordinary); if (shndx == elfcpp::SHN_UNDEF) - return; + return true; } break; case Symbol::IS_UNDEFINED: - return; + return true; default: break; @@ -2633,7 +2743,7 @@ Target_powerpc::Branch_info::make_stub( Symbol_table::Compute_final_value_status status; to = symtab->compute_final_value(gsym, &status); if (status != Symbol_table::CFVS_OK) - return; + return true; if (size == 64) to += this->object_->ppc64_local_entry_offset(gsym); } @@ -2648,19 +2758,21 @@ Target_powerpc::Branch_info::make_stub( &symval, symtab); if (status != ObjType::CFLV_OK || !symval.has_output_value()) - return; + return true; to = symval.value(this->object_, 0); if (size == 64) to += this->object_->ppc64_local_entry_offset(this->r_sym_); } - to += this->addend_; + if (!(size == 32 && this->r_type_ == elfcpp::R_PPC_PLTREL24)) + to += this->addend_; if (stub_table == NULL) stub_table = this->object_->stub_table(this->shndx_); if (size == 64 && target->abiversion() < 2) { unsigned int dest_shndx; - to = target->symval_for_branch(symtab, to, gsym, - this->object_, &dest_shndx); + if (!target->symval_for_branch(symtab, gsym, this->object_, + &to, &dest_shndx)) + return true; } Address delta = to - from; if (delta + max_branch_offset >= 2 * max_branch_offset) @@ -2671,11 +2783,18 @@ Target_powerpc::Branch_info::make_stub( " no long branch stub for you"), this->object_->name().c_str(), this->object_->section_name(this->shndx_).c_str()); - return; + return true; } - stub_table->add_long_branch_entry(this->object_, to); + bool save_res = (size == 64 + && gsym != NULL + && gsym->source() == Symbol::IN_OUTPUT_DATA + && gsym->output_data() == target->savres_section()); + return stub_table->add_long_branch_entry(this->object_, + this->r_type_, + from, to, save_res); } } + return true; } // Relaxation hook. This is where we do stub generation. @@ -2743,7 +2862,34 @@ Target_powerpc::do_relax(int pass, } } this->plt_thread_safe_ = thread_safe; - this->group_sections(layout, task); + } + + if (pass == 1) + { + this->stub_group_size_ = parameters->options().stub_group_size(); + bool no_size_errors = true; + if (this->stub_group_size_ == 1) + this->stub_group_size_ = 0x1c00000; + else if (this->stub_group_size_ == -1) + this->stub_group_size_ = -0x1e00000; + else + no_size_errors = false; + this->group_sections(layout, task, no_size_errors); + } + else if (this->relax_failed_ && this->relax_fail_count_ < 3) + { + this->branch_lookup_table_.clear(); + for (typename Stub_tables::iterator p = this->stub_tables_.begin(); + p != this->stub_tables_.end(); + ++p) + { + (*p)->clear_stubs(true); + } + this->stub_tables_.clear(); + this->stub_group_size_ = this->stub_group_size_ / 4 * 3; + gold_info(_("%s: stub group size is too large; retrying with %d"), + program_name, this->stub_group_size_); + this->group_sections(layout, task, true); } // We need address of stub tables valid for make_stub. @@ -2768,11 +2914,12 @@ Target_powerpc::do_relax(int pass, p != this->stub_tables_.end(); ++p) { - (*p)->clear_stubs(); + (*p)->clear_stubs(false); } } // Build all the stubs. + this->relax_failed_ = false; Stub_table* ifunc_stub_table = this->stub_tables_.size() == 0 ? NULL : this->stub_tables_[0]; Stub_table* one_stub_table @@ -2781,7 +2928,14 @@ Target_powerpc::do_relax(int pass, b != this->branch_info_.end(); b++) { - b->make_stub(one_stub_table, ifunc_stub_table, symtab); + if (!b->make_stub(one_stub_table, ifunc_stub_table, symtab) + && !this->relax_failed_) + { + this->relax_failed_ = true; + this->relax_fail_count_++; + if (this->relax_fail_count_ < 3) + return true; + } } // Did anything change size? @@ -2828,7 +2982,13 @@ Target_powerpc::do_relax(int pass, Stub_table* stub_table = static_cast*>( i->relaxed_input_section()); - off += stub_table->set_address_and_size(os, off); + Address stub_table_size = stub_table->set_address_and_size(os, off); + off += stub_table_size; + // After a few iterations, set current stub table size + // as min size threshold, so later stub tables can only + // grow in size. + if (pass >= 4) + stub_table->set_min_size_threshold(stub_table_size); } else off += i->data_size(); @@ -3069,6 +3229,7 @@ Output_data_plt_powerpc::add_local_ifunc_entry( static const uint32_t add_0_11_11 = 0x7c0b5a14; static const uint32_t add_2_2_11 = 0x7c425a14; +static const uint32_t add_2_2_12 = 0x7c426214; static const uint32_t add_3_3_2 = 0x7c631214; static const uint32_t add_3_3_13 = 0x7c636a14; static const uint32_t add_11_0_11 = 0x7d605a14; @@ -3078,14 +3239,15 @@ static const uint32_t addi_0_12 = 0x380c0000; static const uint32_t addi_2_2 = 0x38420000; static const uint32_t addi_3_3 = 0x38630000; static const uint32_t addi_11_11 = 0x396b0000; +static const uint32_t addi_12_1 = 0x39810000; static const uint32_t addi_12_12 = 0x398c0000; static const uint32_t addis_0_2 = 0x3c020000; static const uint32_t addis_0_13 = 0x3c0d0000; -static const uint32_t addis_3_2 = 0x3c620000; -static const uint32_t addis_3_13 = 0x3c6d0000; +static const uint32_t addis_2_12 = 0x3c4c0000; static const uint32_t addis_11_2 = 0x3d620000; static const uint32_t addis_11_11 = 0x3d6b0000; static const uint32_t addis_11_30 = 0x3d7e0000; +static const uint32_t addis_12_1 = 0x3d810000; static const uint32_t addis_12_2 = 0x3d820000; static const uint32_t addis_12_12 = 0x3d8c0000; static const uint32_t b = 0x48000000; @@ -3093,6 +3255,7 @@ static const uint32_t bcl_20_31 = 0x429f0005; static const uint32_t bctr = 0x4e800420; static const uint32_t blr = 0x4e800020; static const uint32_t bnectr_p4 = 0x4ce20420; +static const uint32_t cmpld_7_12_0 = 0x7fac0040; static const uint32_t cmpldi_2_0 = 0x28220000; static const uint32_t cror_15_15_15 = 0x4def7b82; static const uint32_t cror_31_31_31 = 0x4ffffb82; @@ -3101,6 +3264,7 @@ static const uint32_t ld_0_12 = 0xe80c0000; static const uint32_t ld_2_1 = 0xe8410000; static const uint32_t ld_2_2 = 0xe8420000; static const uint32_t ld_2_11 = 0xe84b0000; +static const uint32_t ld_2_12 = 0xe84c0000; static const uint32_t ld_11_2 = 0xe9620000; static const uint32_t ld_11_11 = 0xe96b0000; static const uint32_t ld_12_2 = 0xe9820000; @@ -3109,7 +3273,8 @@ static const uint32_t ld_12_12 = 0xe98c0000; static const uint32_t lfd_0_1 = 0xc8010000; static const uint32_t li_0_0 = 0x38000000; static const uint32_t li_12_0 = 0x39800000; -static const uint32_t lis_0_0 = 0x3c000000; +static const uint32_t lis_0 = 0x3c000000; +static const uint32_t lis_2 = 0x3c400000; static const uint32_t lis_11 = 0x3d600000; static const uint32_t lis_12 = 0x3d800000; static const uint32_t lvx_0_12_0 = 0x7c0c00ce; @@ -3466,26 +3631,36 @@ class Stub_table : public Output_relaxed_input_section typedef typename elfcpp::Elf_types::Elf_Addr Address; static const Address invalid_address = static_cast
(0) - 1; - Stub_table(Target_powerpc* targ) - : Output_relaxed_input_section(NULL, 0, 0), + Stub_table(Target_powerpc* targ, + Output_section* output_section, + const Output_section::Input_section* owner) + : Output_relaxed_input_section(owner->relobj(), owner->shndx(), + owner->relobj() + ->section_addralign(owner->shndx())), targ_(targ), plt_call_stubs_(), long_branch_stubs_(), - orig_data_size_(0), plt_size_(0), last_plt_size_(0), - branch_size_(0), last_branch_size_(0), eh_frame_added_(false) - { } + orig_data_size_(owner->current_data_size()), + plt_size_(0), last_plt_size_(0), + branch_size_(0), last_branch_size_(0), min_size_threshold_(0), + eh_frame_added_(false), need_save_res_(false) + { + this->set_output_section(output_section); - // Delayed Output_relaxed_input_section init. - void - init(const Output_section::Input_section*, Output_section*); + std::vector new_relaxed; + new_relaxed.push_back(this); + output_section->convert_input_sections_to_relaxed_sections(new_relaxed); + } // Add a plt call stub. - void - add_plt_call_entry(const Sized_relobj_file*, + bool + add_plt_call_entry(Address, + const Sized_relobj_file*, const Symbol*, unsigned int, Address); - void - add_plt_call_entry(const Sized_relobj_file*, + bool + add_plt_call_entry(Address, + const Sized_relobj_file*, unsigned int, unsigned int, Address); @@ -3511,20 +3686,38 @@ class Stub_table : public Output_relaxed_input_section Address) const; // Add a long branch stub. - void - add_long_branch_entry(const Powerpc_relobj*, Address); + bool + add_long_branch_entry(const Powerpc_relobj*, + unsigned int, Address, Address, bool); Address find_long_branch_entry(const Powerpc_relobj*, Address) const; + bool + can_reach_stub(Address from, unsigned int off, unsigned int r_type) + { + Address max_branch_offset = max_branch_delta(r_type); + if (max_branch_offset == 0) + return true; + gold_assert(from != invalid_address); + Address loc = off + this->stub_address(); + return loc - from + max_branch_offset < 2 * max_branch_offset; + } + void - clear_stubs() + clear_stubs(bool all) { this->plt_call_stubs_.clear(); this->plt_size_ = 0; this->long_branch_stubs_.clear(); this->branch_size_ = 0; + this->need_save_res_ = false; + if (all) + { + this->last_plt_size_ = 0; + this->last_branch_size_ = 0; + } } Address @@ -3533,10 +3726,17 @@ class Stub_table : public Output_relaxed_input_section Address start_off = off; off += this->orig_data_size_; Address my_size = this->plt_size_ + this->branch_size_; + if (this->need_save_res_) + my_size += this->targ_->savres_section()->data_size(); if (my_size != 0) off = align_address(off, this->stub_align()); // Include original section size and alignment padding in size my_size += off - start_off; + // Ensure new size is always larger than min size + // threshold. Alignment requirement is included in "my_size", so + // increase "my_size" does not invalidate alignment. + if (my_size < this->min_size_threshold_) + my_size = this->min_size_threshold_; this->reset_address_and_file_offset(); this->set_current_data_size(my_size); this->set_address_and_file_offset(os->address() + start_off, @@ -3562,6 +3762,9 @@ class Stub_table : public Output_relaxed_input_section plt_size() const { return this->plt_size_; } + void set_min_size_threshold(Address min_size) + { this->min_size_threshold_ = min_size; } + bool size_update() { @@ -3787,8 +3990,9 @@ class Stub_table : public Output_relaxed_input_section class Branch_stub_ent { public: - Branch_stub_ent(const Powerpc_relobj* obj, Address to) - : dest_(to), toc_base_off_(0) + Branch_stub_ent(const Powerpc_relobj* obj, + Address to, bool save_res) + : dest_(to), toc_base_off_(0), save_res_(save_res) { if (size == 64) toc_base_off_ = obj->toc_base_offset(); @@ -3803,6 +4007,7 @@ class Stub_table : public Output_relaxed_input_section Address dest_; unsigned int toc_base_off_; + bool save_res_; }; class Branch_stub_ent_hash @@ -3824,48 +4029,27 @@ class Stub_table : public Output_relaxed_input_section section_size_type orig_data_size_; // size of stubs section_size_type plt_size_, last_plt_size_, branch_size_, last_branch_size_; + // Some rare cases cause (PR/20529) fluctuation in stub table + // size, which leads to an endless relax loop. This is to be fixed + // by, after the first few iterations, allowing only increase of + // stub table size. This variable sets the minimal possible size of + // a stub table, it is zero for the first few iterations, then + // increases monotonically. + Address min_size_threshold_; // Whether .eh_frame info has been created for this stub section. bool eh_frame_added_; + // Set if this stub group needs a copy of out-of-line register + // save/restore functions. + bool need_save_res_; }; -// Make a new stub table, and record. - -template -Stub_table* -Target_powerpc::new_stub_table() -{ - Stub_table* stub_table - = new Stub_table(this); - this->stub_tables_.push_back(stub_table); - return stub_table; -} - -// Delayed stub table initialisation, because we create the stub table -// before we know to which section it will be attached. - -template -void -Stub_table::init( - const Output_section::Input_section* owner, - Output_section* output_section) -{ - this->set_relobj(owner->relobj()); - this->set_shndx(owner->shndx()); - this->set_addralign(this->relobj()->section_addralign(this->shndx())); - this->set_output_section(output_section); - this->orig_data_size_ = owner->current_data_size(); - - std::vector new_relaxed; - new_relaxed.push_back(this); - output_section->convert_input_sections_to_relaxed_sections(new_relaxed); -} - // Add a plt call stub, if we do not already have one for this // sym/object/addend combo. template -void +bool Stub_table::add_plt_call_entry( + Address from, const Sized_relobj_file* object, const Symbol* gsym, unsigned int r_type, @@ -3877,11 +4061,13 @@ Stub_table::add_plt_call_entry( = this->plt_call_stubs_.insert(std::make_pair(ent, off)); if (p.second) this->plt_size_ = off + this->plt_call_size(p.first); + return this->can_reach_stub(from, off, r_type); } template -void +bool Stub_table::add_plt_call_entry( + Address from, const Sized_relobj_file* object, unsigned int locsym_index, unsigned int r_type, @@ -3893,6 +4079,7 @@ Stub_table::add_plt_call_entry( = this->plt_call_stubs_.insert(std::make_pair(ent, off)); if (p.second) this->plt_size_ = off + this->plt_call_size(p.first); + return this->can_reach_stub(from, off, r_type); } // Find a plt call stub. @@ -3947,23 +4134,32 @@ Stub_table::find_plt_call_entry( // destination. template -void +bool Stub_table::add_long_branch_entry( const Powerpc_relobj* object, - Address to) + unsigned int r_type, + Address from, + Address to, + bool save_res) { - Branch_stub_ent ent(object, to); + Branch_stub_ent ent(object, to, save_res); Address off = this->branch_size_; if (this->long_branch_stubs_.insert(std::make_pair(ent, off)).second) { - unsigned int stub_size = this->branch_stub_size(to); - this->branch_size_ = off + stub_size; - if (size == 64 && stub_size != 4) - this->targ_->add_branch_lookup_table(to); + if (save_res) + this->need_save_res_ = true; + else + { + unsigned int stub_size = this->branch_stub_size(to); + this->branch_size_ = off + stub_size; + if (size == 64 && stub_size != 4) + this->targ_->add_branch_lookup_table(to); + } } + return this->can_reach_stub(from, off, r_type); } -// Find long branch stub. +// Find long branch stub offset. template typename Stub_table::Address @@ -3971,10 +4167,14 @@ Stub_table::find_long_branch_entry( const Powerpc_relobj* object, Address to) const { - Branch_stub_ent ent(object, to); + Branch_stub_ent ent(object, to, false); typename Branch_stub_entries::const_iterator p = this->long_branch_stubs_.find(ent); - return p == this->long_branch_stubs_.end() ? invalid_address : p->second; + if (p == this->long_branch_stubs_.end()) + return invalid_address; + if (p->first.save_res_) + return to - this->targ_->savres_section()->address() + this->branch_size_; + return p->second; } // A class to handle .glink. @@ -4313,6 +4513,8 @@ Stub_table::do_write(Output_file* of) bs != this->long_branch_stubs_.end(); ++bs) { + if (bs->first.save_res_) + continue; p = oview + this->plt_size_ + bs->second; Address loc = this->stub_address() + this->plt_size_ + bs->second; Address delta = bs->first.dest_ - loc; @@ -4424,6 +4626,8 @@ Stub_table::do_write(Output_file* of) bs != this->long_branch_stubs_.end(); ++bs) { + if (bs->first.save_res_) + continue; p = oview + this->plt_size_ + bs->second; Address loc = this->stub_address() + this->plt_size_ + bs->second; Address delta = bs->first.dest_ - loc; @@ -4450,6 +4654,12 @@ Stub_table::do_write(Output_file* of) } } } + if (this->need_save_res_) + { + p = oview + this->plt_size_ + this->branch_size_; + memcpy (p, this->targ_->savres_section()->contents(), + this->targ_->savres_section()->data_size()); + } } // Write out .glink. @@ -4523,7 +4733,7 @@ Output_data_glink::do_write(Output_file* of) } else { - write_insn(p, lis_0_0 + hi(indx)), p += 4; + write_insn(p, lis_0 + hi(indx)), p += 4; write_insn(p, ori_0_0_0 + l(indx)), p += 4; } } @@ -4660,6 +4870,12 @@ class Output_data_save_res : public Output_section_data_build public: Output_data_save_res(Symbol_table* symtab); + const unsigned char* + contents() const + { + return contents_; + } + protected: // Write to a map file. void @@ -5136,8 +5352,7 @@ Target_powerpc::Scan::get_reference_flags( case elfcpp::R_PPC64_TOC16_HA: case elfcpp::R_PPC64_TOC16_DS: case elfcpp::R_PPC64_TOC16_LO_DS: - // Absolute in GOT. - ref = Symbol::ABSOLUTE_REF; + ref = Symbol::RELATIVE_REF; break; case elfcpp::R_POWERPC_GOT_TPREL16: @@ -5415,6 +5630,7 @@ Target_powerpc::Scan::local( case elfcpp::R_POWERPC_GNU_VTENTRY: case elfcpp::R_PPC64_TOCSAVE: case elfcpp::R_POWERPC_TLS: + case elfcpp::R_PPC64_ENTRY: break; case elfcpp::R_PPC64_TOC: @@ -5470,10 +5686,10 @@ Target_powerpc::Scan::local( { Reloc_section* rela_dyn = target->rela_dyn_section(symtab, layout, is_ifunc); + unsigned int r_sym = elfcpp::elf_r_sym(reloc.get_r_info()); if ((size == 32 && r_type == elfcpp::R_POWERPC_ADDR32) || (size == 64 && r_type == elfcpp::R_PPC64_ADDR64)) { - unsigned int r_sym = elfcpp::elf_r_sym(reloc.get_r_info()); unsigned int dynrel = (is_ifunc ? elfcpp::R_POWERPC_IRELATIVE : elfcpp::R_POWERPC_RELATIVE); rela_dyn->add_local_relative(object, r_sym, dynrel, @@ -5481,14 +5697,28 @@ Target_powerpc::Scan::local( reloc.get_r_offset(), reloc.get_r_addend(), false); } - else + else if (lsym.get_st_type() != elfcpp::STT_SECTION) { check_non_pic(object, r_type); - unsigned int r_sym = elfcpp::elf_r_sym(reloc.get_r_info()); rela_dyn->add_local(object, r_sym, r_type, output_section, data_shndx, reloc.get_r_offset(), reloc.get_r_addend()); } + else + { + gold_assert(lsym.get_st_value() == 0); + unsigned int shndx = lsym.get_st_shndx(); + bool is_ordinary; + shndx = object->adjust_sym_shndx(r_sym, shndx, + &is_ordinary); + if (!is_ordinary) + object->error(_("section symbol %u has bad shndx %u"), + r_sym, shndx); + else + rela_dyn->add_local_section(object, shndx, r_type, + output_section, data_shndx, + reloc.get_r_offset()); + } } break; @@ -5510,6 +5740,7 @@ Target_powerpc::Scan::local( case elfcpp::R_POWERPC_REL16_LO: case elfcpp::R_POWERPC_REL16_HI: case elfcpp::R_POWERPC_REL16_HA: + case elfcpp::R_POWERPC_REL16DX_HA: case elfcpp::R_POWERPC_SECTOFF: case elfcpp::R_POWERPC_SECTOFF_LO: case elfcpp::R_POWERPC_SECTOFF_HI: @@ -5559,8 +5790,8 @@ Target_powerpc::Scan::local( if (!parameters->options().output_is_position_independent()) { - if ((size == 32 && is_ifunc) - || (size == 64 && target->abiversion() >= 2)) + if (is_ifunc + && (size == 32 || target->abiversion() >= 2)) got->add_local_plt(object, r_sym, GOT_TYPE_STANDARD); else got->add_local(object, r_sym, GOT_TYPE_STANDARD); @@ -5775,6 +6006,7 @@ Target_powerpc::Scan::global( case elfcpp::R_POWERPC_GNU_VTENTRY: case elfcpp::R_PPC_LOCAL24PC: case elfcpp::R_POWERPC_TLS: + case elfcpp::R_PPC64_ENTRY: break; case elfcpp::R_PPC64_TOC: @@ -5959,6 +6191,7 @@ Target_powerpc::Scan::global( case elfcpp::R_POWERPC_REL16_LO: case elfcpp::R_POWERPC_REL16_HI: case elfcpp::R_POWERPC_REL16_HA: + case elfcpp::R_POWERPC_REL16DX_HA: case elfcpp::R_POWERPC_SECTOFF: case elfcpp::R_POWERPC_SECTOFF_LO: case elfcpp::R_POWERPC_SECTOFF_HI: @@ -6007,8 +6240,8 @@ Target_powerpc::Scan::global( got = target->got_section(symtab, layout); if (gsym->final_value_is_known()) { - if ((size == 32 && is_ifunc) - || (size == 64 && target->abiversion() >= 2)) + if (is_ifunc + && (size == 32 || target->abiversion() >= 2)) got->add_global_plt(gsym, GOT_TYPE_STANDARD); else got->add_global(gsym, GOT_TYPE_STANDARD); @@ -6220,7 +6453,9 @@ Target_powerpc::gc_process_relocs( const unsigned char* plocal_symbols) { typedef Target_powerpc Powerpc; - typedef typename Target_powerpc::Scan Scan; + typedef gold::Default_classify_reloc + Classify_reloc; + Powerpc_relobj* ppc_object = static_cast*>(object); if (size == 64) @@ -6237,7 +6472,7 @@ Target_powerpc::gc_process_relocs( typename Powerpc_relobj::Section_refs::iterator s; for (s = p->second.begin(); s != p->second.end(); ++s) { - Object* src_obj = s->first; + Relobj* src_obj = s->first; unsigned int src_indx = s->second; symtab->gc()->add_reference(src_obj, src_indx, ppc_object, dst_indx); @@ -6250,8 +6485,7 @@ Target_powerpc::gc_process_relocs( return; } - gold::gc_process_relocs( + gold::gc_process_relocs( symtab, layout, this, @@ -6274,9 +6508,9 @@ template void Target_powerpc::do_gc_add_reference( Symbol_table* symtab, - Object* src_obj, + Relobj* src_obj, unsigned int src_shndx, - Object* dst_obj, + Relobj* dst_obj, unsigned int dst_shndx, Address dst_off) const { @@ -6324,7 +6558,8 @@ Target_powerpc::do_gc_mark_symbol( if (ppc_object->opd_valid()) { unsigned int dst_indx = ppc_object->get_opd_ent(dst_off); - symtab->gc()->worklist().push(Section_id(ppc_object, dst_indx)); + symtab->gc()->worklist().push_back(Section_id(ppc_object, + dst_indx)); } else ppc_object->add_gc_mark(dst_off); @@ -6368,6 +6603,116 @@ Target_powerpc::do_function_location( } } +// FNOFFSET in section SHNDX in OBJECT is the start of a function +// compiled with -fsplit-stack. The function calls non-split-stack +// code. Change the function to ensure it has enough stack space to +// call some random function. + +template +void +Target_powerpc::do_calls_non_split( + Relobj* object, + unsigned int shndx, + section_offset_type fnoffset, + section_size_type fnsize, + const unsigned char* prelocs, + size_t reloc_count, + unsigned char* view, + section_size_type view_size, + std::string* from, + std::string* to) const +{ + // 32-bit not supported. + if (size == 32) + { + // warn + Target::do_calls_non_split(object, shndx, fnoffset, fnsize, + prelocs, reloc_count, view, view_size, + from, to); + return; + } + + // The function always starts with + // ld %r0,-0x7000-64(%r13) # tcbhead_t.__private_ss + // addis %r12,%r1,-allocate@ha + // addi %r12,%r12,-allocate@l + // cmpld %r12,%r0 + // but note that the addis or addi may be replaced with a nop + + unsigned char *entry = view + fnoffset; + uint32_t insn = elfcpp::Swap<32, big_endian>::readval(entry); + + if ((insn & 0xffff0000) == addis_2_12) + { + /* Skip ELFv2 global entry code. */ + entry += 8; + insn = elfcpp::Swap<32, big_endian>::readval(entry); + } + + unsigned char *pinsn = entry; + bool ok = false; + const uint32_t ld_private_ss = 0xe80d8fc0; + if (insn == ld_private_ss) + { + int32_t allocate = 0; + while (1) + { + pinsn += 4; + insn = elfcpp::Swap<32, big_endian>::readval(pinsn); + if ((insn & 0xffff0000) == addis_12_1) + allocate += (insn & 0xffff) << 16; + else if ((insn & 0xffff0000) == addi_12_1 + || (insn & 0xffff0000) == addi_12_12) + allocate += ((insn & 0xffff) ^ 0x8000) - 0x8000; + else if (insn != nop) + break; + } + if (insn == cmpld_7_12_0 && pinsn == entry + 12) + { + int extra = parameters->options().split_stack_adjust_size(); + allocate -= extra; + if (allocate >= 0 || extra < 0) + { + object->error(_("split-stack stack size overflow at " + "section %u offset %0zx"), + shndx, static_cast(fnoffset)); + return; + } + pinsn = entry + 4; + insn = addis_12_1 | (((allocate + 0x8000) >> 16) & 0xffff); + if (insn != addis_12_1) + { + elfcpp::Swap<32, big_endian>::writeval(pinsn, insn); + pinsn += 4; + insn = addi_12_12 | (allocate & 0xffff); + if (insn != addi_12_12) + { + elfcpp::Swap<32, big_endian>::writeval(pinsn, insn); + pinsn += 4; + } + } + else + { + insn = addi_12_1 | (allocate & 0xffff); + elfcpp::Swap<32, big_endian>::writeval(pinsn, insn); + pinsn += 4; + } + if (pinsn != entry + 12) + elfcpp::Swap<32, big_endian>::writeval(pinsn, nop); + + ok = true; + } + } + + if (!ok) + { + if (!object->has_no_split_stack()) + object->error(_("failed to match split-stack sequence at " + "section %u offset %0zx"), + shndx, static_cast(fnoffset)); + } +} + // Scan relocations for a section. template @@ -6386,7 +6731,8 @@ Target_powerpc::scan_relocs( const unsigned char* plocal_symbols) { typedef Target_powerpc Powerpc; - typedef typename Target_powerpc::Scan Scan; + typedef gold::Default_classify_reloc + Classify_reloc; if (sh_type == elfcpp::SHT_REL) { @@ -6395,7 +6741,7 @@ Target_powerpc::scan_relocs( return; } - gold::scan_relocs( + gold::scan_relocs( symtab, layout, this, @@ -6439,7 +6785,12 @@ class Global_symbol_visitor_opd unsigned int shndx = sym->shndx(&is_ordinary); if (shndx == symobj->opd_shndx() && symobj->get_opd_discard(sym->value())) - sym->set_symtab_index(-1U); + { + sym->set_undefined(); + sym->set_visibility(elfcpp::STV_DEFAULT); + sym->set_is_defined_in_discarded_section(); + sym->set_symtab_index(-1U); + } } }; @@ -6451,8 +6802,9 @@ Target_powerpc::define_save_restore_funcs( { if (size == 64) { - Output_data_save_res<64, big_endian>* savres - = new Output_data_save_res<64, big_endian>(symtab); + Output_data_save_res* savres + = new Output_data_save_res(symtab); + this->savres_section_ = savres; layout->add_output_section_data(".text", elfcpp::SHT_PROGBITS, elfcpp::SHF_ALLOC | elfcpp::SHF_EXECINSTR, savres, ORDER_TEXT, false); @@ -6617,12 +6969,12 @@ ok_lo_toc_insn(uint32_t insn) // Return the value to use for a branch relocation. template -typename Target_powerpc::Address +bool Target_powerpc::symval_for_branch( const Symbol_table* symtab, - Address value, const Sized_symbol* gsym, Powerpc_relobj* object, + Address *value, unsigned int *dest_shndx) { if (size == 32 || this->abiversion() >= 2) @@ -6634,20 +6986,20 @@ Target_powerpc::symval_for_branch( Powerpc_relobj* symobj = object; if (gsym != NULL && gsym->source() != Symbol::FROM_OBJECT) - return value; + return true; if (gsym != NULL) symobj = static_cast*>(gsym->object()); unsigned int shndx = symobj->opd_shndx(); if (shndx == 0) - return value; + return true; Address opd_addr = symobj->get_output_section_offset(shndx); if (opd_addr == invalid_address) - return value; + return true; opd_addr += symobj->output_section_address(shndx); - if (value >= opd_addr && value < opd_addr + symobj->section_size(shndx)) + if (*value >= opd_addr && *value < opd_addr + symobj->section_size(shndx)) { Address sec_off; - *dest_shndx = symobj->get_opd_ent(value - opd_addr, &sec_off); + *dest_shndx = symobj->get_opd_ent(*value - opd_addr, &sec_off); if (symtab->is_section_folded(symobj, *dest_shndx)) { Section_id folded @@ -6656,11 +7008,13 @@ Target_powerpc::symval_for_branch( *dest_shndx = folded.second; } Address sec_addr = symobj->get_output_section_offset(*dest_shndx); - gold_assert(sec_addr != invalid_address); + if (sec_addr == invalid_address) + return false; + sec_addr += symobj->output_section(*dest_shndx)->address(); - value = sec_addr + sec_off; + *value = sec_addr + sec_off; } - return value; + return true; } // Perform a relocation. @@ -6669,11 +7023,11 @@ template inline bool Target_powerpc::Relocate::relocate( const Relocate_info* relinfo, + unsigned int, Target_powerpc* target, Output_section* os, size_t relnum, - const elfcpp::Rela& rela, - unsigned int r_type, + const unsigned char* preloc, const Sized_symbol* gsym, const Symbol_value* psymval, unsigned char* view, @@ -6683,6 +7037,8 @@ Target_powerpc::Relocate::relocate( if (view == NULL) return true; + const elfcpp::Rela rela(preloc); + unsigned int r_type = elfcpp::elf_r_type(rela.get_r_info()); switch (this->maybe_skip_tls_get_addr_call(r_type, gsym)) { case Track_tls::NOT_EXPECTED: @@ -6700,6 +7056,11 @@ Target_powerpc::Relocate::relocate( typedef Powerpc_relocate_functions Reloc; typedef typename elfcpp::Swap<32, big_endian>::Valtype Insn; + typedef typename Reloc_types::Reloc Reltype; + // Offset from start of insn to d-field reloc. + const int d_offset = big_endian ? 2 : 0; + Powerpc_relobj* const object = static_cast*>(relinfo->object); Address value = 0; @@ -6717,9 +7078,12 @@ Target_powerpc::Relocate::relocate( && !parameters->options().output_is_position_independent() && !is_branch_reloc(r_type)) { - unsigned int off = target->glink_section()->find_global_entry(gsym); - gold_assert(off != (unsigned int)-1); - value = target->glink_section()->global_entry_address() + off; + Address off = target->glink_section()->find_global_entry(gsym); + if (off != invalid_address) + { + value = target->glink_section()->global_entry_address() + off; + has_stub_value = true; + } } else { @@ -6731,18 +7095,26 @@ Target_powerpc::Relocate::relocate( if (target->stub_tables().size() != 0) stub_table = target->stub_tables()[0]; } - gold_assert(stub_table != NULL); - Address off; - if (gsym != NULL) - off = stub_table->find_plt_call_entry(object, gsym, r_type, - rela.get_r_addend()); - else - off = stub_table->find_plt_call_entry(object, r_sym, r_type, - rela.get_r_addend()); - gold_assert(off != invalid_address); - value = stub_table->stub_address() + off; + if (stub_table != NULL) + { + Address off; + if (gsym != NULL) + off = stub_table->find_plt_call_entry(object, gsym, r_type, + rela.get_r_addend()); + else + off = stub_table->find_plt_call_entry(object, r_sym, r_type, + rela.get_r_addend()); + if (off != invalid_address) + { + value = stub_table->stub_address() + off; + has_stub_value = true; + } + } } - has_stub_value = true; + // We don't care too much about bogus debug references to + // non-local functions, but otherwise there had better be a plt + // call stub or global entry stub as appropriate. + gold_assert(has_stub_value || !(os->flags() & elfcpp::SHF_ALLOC)); } if (r_type == elfcpp::R_POWERPC_GOT16 @@ -6820,10 +7192,9 @@ Target_powerpc::Relocate::relocate( if (target->abiversion() < 2) { Address addend = rela.get_r_addend(); - Address opdent = psymval->value(object, addend); - code = target->symval_for_branch(relinfo->symtab, - opdent, gsym, object, - &dest_shndx); + code = psymval->value(object, addend); + target->symval_for_branch(relinfo->symtab, gsym, object, + &code, &dest_shndx); } bool is_ordinary; if (dest_shndx == 0) @@ -6873,7 +7244,7 @@ Target_powerpc::Relocate::relocate( if (r_type == elfcpp::R_POWERPC_GOT_TLSGD16 || r_type == elfcpp::R_POWERPC_GOT_TLSGD16_LO) { - Insn* iview = reinterpret_cast(view - 2 * big_endian); + Insn* iview = reinterpret_cast(view - d_offset); Insn insn = elfcpp::Swap<32, big_endian>::readval(iview); insn &= (1 << 26) - (1 << 16); // extract rt,ra from addi if (size == 32) @@ -6890,17 +7261,20 @@ Target_powerpc::Relocate::relocate( if (r_type == elfcpp::R_POWERPC_GOT_TLSGD16 || r_type == elfcpp::R_POWERPC_GOT_TLSGD16_LO) { - Insn* iview = reinterpret_cast(view - 2 * big_endian); - Insn insn = addis_3_13; + Insn* iview = reinterpret_cast(view - d_offset); + Insn insn = elfcpp::Swap<32, big_endian>::readval(iview); + insn &= (1 << 26) - (1 << 21); // extract rt if (size == 32) - insn = addis_3_2; + insn |= addis_0_2; + else + insn |= addis_0_13; elfcpp::Swap<32, big_endian>::writeval(iview, insn); r_type = elfcpp::R_POWERPC_TPREL16_HA; value = psymval->value(object, rela.get_r_addend()); } else { - Insn* iview = reinterpret_cast(view - 2 * big_endian); + Insn* iview = reinterpret_cast(view - d_offset); Insn insn = nop; elfcpp::Swap<32, big_endian>::writeval(iview, insn); r_type = elfcpp::R_POWERPC_NONE; @@ -6925,17 +7299,20 @@ Target_powerpc::Relocate::relocate( if (r_type == elfcpp::R_POWERPC_GOT_TLSLD16 || r_type == elfcpp::R_POWERPC_GOT_TLSLD16_LO) { - Insn* iview = reinterpret_cast(view - 2 * big_endian); - Insn insn = addis_3_13; + Insn* iview = reinterpret_cast(view - d_offset); + Insn insn = elfcpp::Swap<32, big_endian>::readval(iview); + insn &= (1 << 26) - (1 << 21); // extract rt if (size == 32) - insn = addis_3_2; + insn |= addis_0_2; + else + insn |= addis_0_13; elfcpp::Swap<32, big_endian>::writeval(iview, insn); r_type = elfcpp::R_POWERPC_TPREL16_HA; value = dtp_offset; } else { - Insn* iview = reinterpret_cast(view - 2 * big_endian); + Insn* iview = reinterpret_cast(view - d_offset); Insn insn = nop; elfcpp::Swap<32, big_endian>::writeval(iview, insn); r_type = elfcpp::R_POWERPC_NONE; @@ -6991,7 +7368,7 @@ Target_powerpc::Relocate::relocate( if (r_type == elfcpp::R_POWERPC_GOT_TPREL16 || r_type == elfcpp::R_POWERPC_GOT_TPREL16_LO) { - Insn* iview = reinterpret_cast(view - 2 * big_endian); + Insn* iview = reinterpret_cast(view - d_offset); Insn insn = elfcpp::Swap<32, big_endian>::readval(iview); insn &= (1 << 26) - (1 << 21); // extract rt from ld if (size == 32) @@ -7004,7 +7381,7 @@ Target_powerpc::Relocate::relocate( } else { - Insn* iview = reinterpret_cast(view - 2 * big_endian); + Insn* iview = reinterpret_cast(view - d_offset); Insn insn = nop; elfcpp::Swap<32, big_endian>::writeval(iview, insn); r_type = elfcpp::R_POWERPC_NONE; @@ -7036,7 +7413,7 @@ Target_powerpc::Relocate::relocate( Insn insn = addi_3_3; elfcpp::Swap<32, big_endian>::writeval(iview, insn); r_type = elfcpp::R_POWERPC_TPREL16_LO; - view += 2 * big_endian; + view += d_offset; value = psymval->value(object, rela.get_r_addend()); } this->skip_next_tls_get_addr_call(); @@ -7056,7 +7433,7 @@ Target_powerpc::Relocate::relocate( elfcpp::Swap<32, big_endian>::writeval(iview, insn); this->skip_next_tls_get_addr_call(); r_type = elfcpp::R_POWERPC_TPREL16_LO; - view += 2 * big_endian; + view += d_offset; value = dtp_offset; } } @@ -7074,15 +7451,14 @@ Target_powerpc::Relocate::relocate( gold_assert(insn != 0); elfcpp::Swap<32, big_endian>::writeval(iview, insn); r_type = elfcpp::R_POWERPC_TPREL16_LO; - view += 2 * big_endian; + view += d_offset; value = psymval->value(object, rela.get_r_addend()); } } else if (!has_stub_value) { Address addend = 0; - unsigned int dest_shndx; - if (r_type != elfcpp::R_PPC_PLTREL24) + if (!(size == 32 && r_type == elfcpp::R_PPC_PLTREL24)) addend = rela.get_r_addend(); value = psymval->value(object, addend); if (size == 64 && is_branch_reloc(r_type)) @@ -7095,18 +7471,13 @@ Target_powerpc::Relocate::relocate( value += object->ppc64_local_entry_offset(r_sym); } else - value = target->symval_for_branch(relinfo->symtab, value, - gsym, object, &dest_shndx); + { + unsigned int dest_shndx; + target->symval_for_branch(relinfo->symtab, gsym, object, + &value, &dest_shndx); + } } - unsigned int max_branch_offset = 0; - if (r_type == elfcpp::R_POWERPC_REL24 - || r_type == elfcpp::R_PPC_PLTREL24 - || r_type == elfcpp::R_PPC_LOCAL24PC) - max_branch_offset = 1 << 25; - else if (r_type == elfcpp::R_POWERPC_REL14 - || r_type == elfcpp::R_POWERPC_REL14_BRTAKEN - || r_type == elfcpp::R_POWERPC_REL14_BRNTAKEN) - max_branch_offset = 1 << 15; + Address max_branch_offset = max_branch_delta(r_type); if (max_branch_offset != 0 && value - address + max_branch_offset >= 2 * max_branch_offset) { @@ -7136,6 +7507,7 @@ Target_powerpc::Relocate::relocate( case elfcpp::R_POWERPC_REL16_LO: case elfcpp::R_POWERPC_REL16_HI: case elfcpp::R_POWERPC_REL16_HA: + case elfcpp::R_POWERPC_REL16DX_HA: case elfcpp::R_POWERPC_REL14: case elfcpp::R_POWERPC_REL14_BRTAKEN: case elfcpp::R_POWERPC_REL14_BRNTAKEN: @@ -7272,7 +7644,7 @@ Target_powerpc::Relocate::relocate( case elfcpp::R_PPC64_TOC16_HA: if (parameters->options().toc_optimize()) { - Insn* iview = reinterpret_cast(view - 2 * big_endian); + Insn* iview = reinterpret_cast(view - d_offset); Insn insn = elfcpp::Swap<32, big_endian>::readval(iview); if ((insn & ((0x3f << 26) | 0x1f << 16)) != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */) @@ -7297,7 +7669,7 @@ Target_powerpc::Relocate::relocate( case elfcpp::R_PPC64_TOC16_LO_DS: if (parameters->options().toc_optimize()) { - Insn* iview = reinterpret_cast(view - 2 * big_endian); + Insn* iview = reinterpret_cast(view - d_offset); Insn insn = elfcpp::Swap<32, big_endian>::readval(iview); if (!ok_lo_toc_insn(insn)) gold_error_at_location(relinfo, relnum, rela.get_r_offset(), @@ -7320,6 +7692,98 @@ Target_powerpc::Relocate::relocate( } } break; + + case elfcpp::R_PPC64_ENTRY: + value = (target->got_section()->output_section()->address() + + object->toc_base_offset()); + if (value + 0x80008000 <= 0xffffffff + && !parameters->options().output_is_position_independent()) + { + Insn* iview = reinterpret_cast(view); + Insn insn1 = elfcpp::Swap<32, big_endian>::readval(iview); + Insn insn2 = elfcpp::Swap<32, big_endian>::readval(iview + 1); + + if ((insn1 & ~0xfffc) == ld_2_12 + && insn2 == add_2_2_12) + { + insn1 = lis_2 + ha(value); + elfcpp::Swap<32, big_endian>::writeval(iview, insn1); + insn2 = addi_2_2 + l(value); + elfcpp::Swap<32, big_endian>::writeval(iview + 1, insn2); + return true; + } + } + else + { + value -= address; + if (value + 0x80008000 <= 0xffffffff) + { + Insn* iview = reinterpret_cast(view); + Insn insn1 = elfcpp::Swap<32, big_endian>::readval(iview); + Insn insn2 = elfcpp::Swap<32, big_endian>::readval(iview + 1); + + if ((insn1 & ~0xfffc) == ld_2_12 + && insn2 == add_2_2_12) + { + insn1 = addis_2_12 + ha(value); + elfcpp::Swap<32, big_endian>::writeval(iview, insn1); + insn2 = addi_2_2 + l(value); + elfcpp::Swap<32, big_endian>::writeval(iview + 1, insn2); + return true; + } + } + } + break; + + case elfcpp::R_POWERPC_REL16_LO: + // If we are generating a non-PIC executable, edit + // 0: addis 2,12,.TOC.-0b@ha + // addi 2,2,.TOC.-0b@l + // used by ELFv2 global entry points to set up r2, to + // lis 2,.TOC.@ha + // addi 2,2,.TOC.@l + // if .TOC. is in range. */ + if (value + address - 4 + 0x80008000 <= 0xffffffff + && relnum != 0 + && preloc != NULL + && target->abiversion() >= 2 + && !parameters->options().output_is_position_independent() + && rela.get_r_addend() == d_offset + 4 + && gsym != NULL + && strcmp(gsym->name(), ".TOC.") == 0) + { + const int reloc_size + = Reloc_types::reloc_size; + Reltype prev_rela(preloc - reloc_size); + if ((prev_rela.get_r_info() + == elfcpp::elf_r_info(r_sym, + elfcpp::R_POWERPC_REL16_HA)) + && prev_rela.get_r_offset() + 4 == rela.get_r_offset() + && prev_rela.get_r_addend() + 4 == rela.get_r_addend()) + { + Insn* iview = reinterpret_cast(view - d_offset); + Insn insn1 = elfcpp::Swap<32, big_endian>::readval(iview - 1); + Insn insn2 = elfcpp::Swap<32, big_endian>::readval(iview); + + if ((insn1 & 0xffff0000) == addis_2_12 + && (insn2 & 0xffff0000) == addi_2_2) + { + insn1 = lis_2 + ha(value + address - 4); + elfcpp::Swap<32, big_endian>::writeval(iview - 1, insn1); + insn2 = addi_2_2 + l(value + address - 4); + elfcpp::Swap<32, big_endian>::writeval(iview, insn2); + if (relinfo->rr) + { + relinfo->rr->set_strategy(relnum - 1, + Relocatable_relocs::RELOC_SPECIAL); + relinfo->rr->set_strategy(relnum, + Relocatable_relocs::RELOC_SPECIAL); + } + return true; + } + } + } + break; } } @@ -7334,6 +7798,7 @@ Target_powerpc::Relocate::relocate( break; case elfcpp::R_POWERPC_REL32: + case elfcpp::R_POWERPC_REL16DX_HA: if (size == 64) overflow = Reloc::CHECK_SIGNED; break; @@ -7414,13 +7879,14 @@ Target_powerpc::Relocate::relocate( break; } + Insn* iview = reinterpret_cast(view - d_offset); + Insn insn = 0; + if (overflow == Reloc::CHECK_LOW_INSN || overflow == Reloc::CHECK_HIGH_INSN) { - Insn* iview = reinterpret_cast(view - 2 * big_endian); - Insn insn = elfcpp::Swap<32, big_endian>::readval(iview); + insn = elfcpp::Swap<32, big_endian>::readval(iview); - overflow = Reloc::CHECK_SIGNED; if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */) overflow = Reloc::CHECK_BITFIELD; else if (overflow == Reloc::CHECK_LOW_INSN @@ -7431,8 +7897,11 @@ Target_powerpc::Relocate::relocate( || (insn & (0x3f << 26)) == 25u << 26 /* oris */ || (insn & (0x3f << 26)) == 27u << 26 /* xoris */)) overflow = Reloc::CHECK_UNSIGNED; + else + overflow = Reloc::CHECK_SIGNED; } + bool maybe_dq_reloc = false; typename Powerpc_relocate_functions::Status status = Powerpc_relocate_functions::STATUS_OK; switch (r_type) @@ -7480,9 +7949,12 @@ Target_powerpc::Relocate::relocate( case elfcpp::R_POWERPC_GOT_DTPREL16: case elfcpp::R_POWERPC_GOT_DTPREL16_LO: + case elfcpp::R_POWERPC_GOT_TPREL16: + case elfcpp::R_POWERPC_GOT_TPREL16_LO: if (size == 64) { - status = Reloc::addr16_ds(view, value, overflow); + // On ppc64 these are all ds form + maybe_dq_reloc = true; break; } case elfcpp::R_POWERPC_ADDR16: @@ -7494,7 +7966,6 @@ Target_powerpc::Relocate::relocate( case elfcpp::R_POWERPC_DTPREL16: case elfcpp::R_POWERPC_GOT_TLSGD16: case elfcpp::R_POWERPC_GOT_TLSLD16: - case elfcpp::R_POWERPC_GOT_TPREL16: case elfcpp::R_POWERPC_ADDR16_LO: case elfcpp::R_POWERPC_REL16_LO: case elfcpp::R_PPC64_TOC16_LO: @@ -7504,8 +7975,10 @@ Target_powerpc::Relocate::relocate( case elfcpp::R_POWERPC_DTPREL16_LO: case elfcpp::R_POWERPC_GOT_TLSGD16_LO: case elfcpp::R_POWERPC_GOT_TLSLD16_LO: - case elfcpp::R_POWERPC_GOT_TPREL16_LO: - status = Reloc::addr16(view, value, overflow); + if (size == 64) + status = Reloc::addr16(view, value, overflow); + else + maybe_dq_reloc = true; break; case elfcpp::R_POWERPC_UADDR16: @@ -7552,6 +8025,10 @@ Target_powerpc::Relocate::relocate( Reloc::addr16_ha(view, value); break; + case elfcpp::R_POWERPC_REL16DX_HA: + status = Reloc::addr16dx_ha(view, value, overflow); + break; + case elfcpp::R_PPC64_DTPREL16_HIGHER: if (size == 32) // R_PPC_EMB_NADDR16_LO @@ -7606,7 +8083,7 @@ Target_powerpc::Relocate::relocate( case elfcpp::R_PPC64_GOT16_LO_DS: case elfcpp::R_PPC64_SECTOFF_DS: case elfcpp::R_PPC64_SECTOFF_LO_DS: - status = Reloc::addr16_ds(view, value, overflow); + maybe_dq_reloc = true; break; case elfcpp::R_POWERPC_ADDR14: @@ -7671,11 +8148,31 @@ Target_powerpc::Relocate::relocate( r_type); break; } + + if (maybe_dq_reloc) + { + if (insn == 0) + insn = elfcpp::Swap<32, big_endian>::readval(iview); + + if ((insn & (0x3f << 26)) == 56u << 26 /* lq */ + || ((insn & (0x3f << 26)) == (61u << 26) /* lxv, stxv */ + && (insn & 3) == 1)) + status = Reloc::addr16_dq(view, value, overflow); + else if (size == 64 + || (insn & (0x3f << 26)) == 58u << 26 /* ld,ldu,lwa */ + || (insn & (0x3f << 26)) == 62u << 26 /* std,stdu,stq */ + || (insn & (0x3f << 26)) == 57u << 26 /* lfdp */ + || (insn & (0x3f << 26)) == 61u << 26 /* stfdp */) + status = Reloc::addr16_ds(view, value, overflow); + else + status = Reloc::addr16(view, value, overflow); + } + if (status != Powerpc_relocate_functions::STATUS_OK - && !has_stub_value - && !(gsym != NULL - && gsym->is_weak_undefined() - && is_branch_reloc(r_type))) + && (has_stub_value + || !(gsym != NULL + && gsym->is_undefined() + && is_branch_reloc(r_type)))) { gold_error_at_location(relinfo, relnum, rela.get_r_offset(), _("relocation overflow")); @@ -7706,11 +8203,13 @@ Target_powerpc::relocate_section( typedef typename Target_powerpc::Relocate Powerpc_relocate; typedef typename Target_powerpc::Relocate_comdat_behavior Powerpc_comdat_behavior; + typedef gold::Default_classify_reloc + Classify_reloc; gold_assert(sh_type == elfcpp::SHT_RELA); - gold::relocate_section( + gold::relocate_section( relinfo, this, prelocs, @@ -7723,9 +8222,26 @@ Target_powerpc::relocate_section( reloc_symbol_changes); } +template class Powerpc_scan_relocatable_reloc { public: + typedef typename Reloc_types::Reloc + Reltype; + static const int reloc_size = + Reloc_types::reloc_size; + static const int sh_type = elfcpp::SHT_RELA; + + // Return the symbol referred to by the relocation. + static inline unsigned int + get_r_sym(const Reltype* reloc) + { return elfcpp::elf_r_sym(reloc->get_r_info()); } + + // Return the type of the relocation. + static inline unsigned int + get_r_type(const Reltype* reloc) + { return elfcpp::elf_r_type(reloc->get_r_info()); } + // Return the strategy to use for a local symbol which is not a // section symbol, given the relocation type. inline Relocatable_relocs::Reloc_strategy @@ -7773,10 +8289,11 @@ Target_powerpc::scan_relocatable_relocs( const unsigned char* plocal_symbols, Relocatable_relocs* rr) { + typedef Powerpc_scan_relocatable_reloc Scan_strategy; + gold_assert(sh_type == elfcpp::SHT_RELA); - gold::scan_relocatable_relocs( + gold::scan_relocatable_relocs( symtab, layout, object, @@ -7790,6 +8307,45 @@ Target_powerpc::scan_relocatable_relocs( rr); } +// Scan the relocs for --emit-relocs. + +template +void +Target_powerpc::emit_relocs_scan( + Symbol_table* symtab, + Layout* layout, + Sized_relobj_file* object, + unsigned int data_shndx, + unsigned int sh_type, + const unsigned char* prelocs, + size_t reloc_count, + Output_section* output_section, + bool needs_special_offset_handling, + size_t local_symbol_count, + const unsigned char* plocal_syms, + Relocatable_relocs* rr) +{ + typedef gold::Default_classify_reloc + Classify_reloc; + typedef gold::Default_emit_relocs_strategy + Emit_relocs_strategy; + + gold_assert(sh_type == elfcpp::SHT_RELA); + + gold::scan_relocatable_relocs( + symtab, + layout, + object, + data_shndx, + prelocs, + reloc_count, + output_section, + needs_special_offset_handling, + local_symbol_count, + plocal_syms, + rr); +} + // Emit relocations for a section. // This is a modified version of the function by the same name in // target-reloc.h. Using relocate_special_relocatable for @@ -7805,7 +8361,6 @@ Target_powerpc::relocate_relocs( size_t reloc_count, Output_section* output_section, typename elfcpp::Elf_types::Elf_Off offset_in_output_section, - const Relocatable_relocs* rr, unsigned char*, Address view_address, section_size_type, @@ -7820,6 +8375,8 @@ Target_powerpc::relocate_relocs( Reltype_write; const int reloc_size = Reloc_types::reloc_size; + // Offset from start of insn to d-field reloc. + const int d_offset = big_endian ? 2 : 0; Powerpc_relobj* const object = static_cast*>(relinfo->object); @@ -7836,7 +8393,7 @@ Target_powerpc::relocate_relocs( bool zap_next = false; for (size_t i = 0; i < reloc_count; ++i, prelocs += reloc_size) { - Relocatable_relocs::Reloc_strategy strategy = rr->strategy(i); + Relocatable_relocs::Reloc_strategy strategy = relinfo->rr->strategy(i); if (strategy == Relocatable_relocs::RELOC_DISCARD) continue; @@ -7862,6 +8419,7 @@ Target_powerpc::relocate_relocs( } // Get the new symbol index. + Output_section* os = NULL; if (r_sym < local_count) { switch (strategy) @@ -7886,7 +8444,7 @@ Target_powerpc::relocate_relocs( unsigned int shndx = object->local_symbol_input_shndx(r_sym, &is_ordinary); gold_assert(is_ordinary); - Output_section* os = object->output_section(shndx); + os = object->output_section(shndx); gold_assert(os != NULL); gold_assert(os->needs_symtab_index()); r_sym = os->symtab_index(); @@ -7939,12 +8497,26 @@ Target_powerpc::relocate_relocs( else if (strategy == Relocatable_relocs::RELOC_ADJUST_FOR_SECTION_RELA) { const Symbol_value* psymval = object->local_symbol(orig_r_sym); - addend = psymval->value(object, addend); + gold_assert(os != NULL); + addend = psymval->value(object, addend) - os->address(); } else if (strategy == Relocatable_relocs::RELOC_SPECIAL) { - if (addend >= 32768) - addend += got2_addend; + if (size == 32) + { + if (addend >= 32768) + addend += got2_addend; + } + else if (r_type == elfcpp::R_POWERPC_REL16_HA) + { + r_type = elfcpp::R_POWERPC_ADDR16_HA; + addend -= d_offset; + } + else if (r_type == elfcpp::R_POWERPC_REL16_LO) + { + r_type = elfcpp::R_POWERPC_ADDR16_LO; + addend -= d_offset + 4; + } } else gold_unreachable(); @@ -7972,7 +8544,7 @@ Target_powerpc::relocate_relocs( else { r_type = elfcpp::R_POWERPC_NONE; - offset -= 2 * big_endian; + offset -= d_offset; } break; default: @@ -8002,7 +8574,7 @@ Target_powerpc::relocate_relocs( else { r_type = elfcpp::R_POWERPC_NONE; - offset -= 2 * big_endian; + offset -= d_offset; } } } @@ -8021,7 +8593,7 @@ Target_powerpc::relocate_relocs( else { r_type = elfcpp::R_POWERPC_NONE; - offset -= 2 * big_endian; + offset -= d_offset; } } } @@ -8039,7 +8611,7 @@ Target_powerpc::relocate_relocs( break; case tls::TLSOPT_TO_LE: r_type = elfcpp::R_POWERPC_TPREL16_LO; - offset += 2 * big_endian; + offset += d_offset; zap_next = true; break; default: @@ -8060,7 +8632,7 @@ Target_powerpc::relocate_relocs( r_sym = os->symtab_index(); addend = dtp_offset; r_type = elfcpp::R_POWERPC_TPREL16_LO; - offset += 2 * big_endian; + offset += d_offset; zap_next = true; } } @@ -8071,7 +8643,7 @@ Target_powerpc::relocate_relocs( if (this->optimize_tls_ie(final) == tls::TLSOPT_TO_LE) { r_type = elfcpp::R_POWERPC_TPREL16_LO; - offset += 2 * big_endian; + offset += d_offset; } } } @@ -8110,8 +8682,8 @@ Target_powerpc::do_dynsym_value(const Symbol* gsym) const } else if (this->abiversion() >= 2) { - unsigned int off = this->glink_section()->find_global_entry(gsym); - if (off != (unsigned int)-1) + Address off = this->glink_section()->find_global_entry(gsym); + if (off != invalid_address) return this->glink_section()->global_entry_address() + off; } gold_unreachable(); @@ -8160,8 +8732,8 @@ Target_powerpc::do_plt_address_for_global( } else if (this->abiversion() >= 2) { - unsigned int off = this->glink_section()->find_global_entry(gsym); - if (off != (unsigned int)-1) + Address off = this->glink_section()->find_global_entry(gsym); + if (off != invalid_address) return this->glink_section()->global_entry_address() + off; } gold_unreachable();