X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gold%2Fpowerpc.cc;h=c269ae03514bf7ef5ed89b2b8f407a9f8d9c7319;hb=7229b687db8c5fe9c1534b763dea6d1211ff3993;hp=9a0bd9d782f315351c07d4d8809d90cc0aa8ebc7;hpb=faa2211d4d3dad3f381164cdb29d27b9108760ea;p=deliverable%2Fbinutils-gdb.git diff --git a/gold/powerpc.cc b/gold/powerpc.cc index 9a0bd9d782..c269ae0351 100644 --- a/gold/powerpc.cc +++ b/gold/powerpc.cc @@ -1,6 +1,6 @@ // powerpc.cc -- powerpc target support for gold. -// Copyright (C) 2008-2015 Free Software Foundation, Inc. +// Copyright (C) 2008-2016 Free Software Foundation, Inc. // Written by David S. Miller // and David Edelsohn @@ -62,6 +62,9 @@ class Output_data_glink; template class Stub_table; +template +class Output_data_save_res; + template class Target_powerpc; @@ -212,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) { @@ -510,7 +513,7 @@ class Target_powerpc : public Sized_target tlsld_got_offset_(-1U), stub_tables_(), branch_lookup_table_(), branch_info_(), plt_thread_safe_(false), relax_failed_(false), relax_fail_count_(0), - stub_group_size_(0) + stub_group_size_(0), savres_section_(0) { } @@ -624,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*, @@ -652,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*, @@ -661,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, @@ -768,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. @@ -780,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; @@ -1056,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); }; @@ -1092,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. @@ -1191,10 +1206,13 @@ 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. @@ -1308,6 +1326,8 @@ class Target_powerpc : public Sized_target bool relax_failed_; int relax_fail_count_; int32_t stub_group_size_; + + Output_data_save_res *savres_section_; }; template<> @@ -1334,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<> @@ -1361,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<> @@ -1388,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<> @@ -1415,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 @@ -1495,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 @@ -1655,6 +1680,16 @@ public: 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; + } + // R_POWERPC_ADDR16_HI: ((Symbol + Addend) >> 16) & 0xffff static inline void addr16_hi(unsigned char* view, Address value) @@ -1694,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. @@ -2142,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(). @@ -2733,8 +2785,13 @@ Target_powerpc::Branch_info::make_stub( this->object_->section_name(this->shndx_).c_str()); return true; } + 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); + this->r_type_, + from, to, save_res); } } return true; @@ -2925,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(); @@ -3166,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; @@ -3175,12 +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_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; @@ -3188,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; @@ -3196,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; @@ -3204,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; @@ -3570,7 +3640,8 @@ class Stub_table : public Output_relaxed_input_section targ_(targ), plt_call_stubs_(), long_branch_stubs_(), orig_data_size_(owner->current_data_size()), plt_size_(0), last_plt_size_(0), - branch_size_(0), last_branch_size_(0), eh_frame_added_(false) + 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); @@ -3617,7 +3688,7 @@ class Stub_table : public Output_relaxed_input_section // Add a long branch stub. bool add_long_branch_entry(const Powerpc_relobj*, - unsigned int, Address, Address); + unsigned int, Address, Address, bool); Address find_long_branch_entry(const Powerpc_relobj*, @@ -3641,6 +3712,7 @@ class Stub_table : public Output_relaxed_input_section 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; @@ -3654,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, @@ -3683,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() { @@ -3908,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(); @@ -3924,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 @@ -3945,8 +4029,18 @@ 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_; }; // Add a plt call stub, if we do not already have one for this @@ -4045,21 +4139,27 @@ Stub_table::add_long_branch_entry( const Powerpc_relobj* object, unsigned int r_type, Address from, - Address to) + 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 @@ -4067,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. @@ -4409,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; @@ -4520,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; @@ -4546,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. @@ -4619,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; } } @@ -4756,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 @@ -5232,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: @@ -5511,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: @@ -5620,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: @@ -5885,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: @@ -6069,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: @@ -6330,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) @@ -6347,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); @@ -6360,8 +6485,7 @@ Target_powerpc::gc_process_relocs( return; } - gold::gc_process_relocs( + gold::gc_process_relocs( symtab, layout, this, @@ -6384,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 { @@ -6479,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 @@ -6497,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) { @@ -6506,7 +6741,7 @@ Target_powerpc::scan_relocs( return; } - gold::scan_relocs( + gold::scan_relocs( symtab, layout, this, @@ -6567,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); @@ -6787,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, @@ -6801,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: @@ -6818,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; @@ -7001,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) @@ -7018,7 +7261,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 << 21); // extract rt if (size == 32) @@ -7031,7 +7274,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; @@ -7056,7 +7299,7 @@ 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* 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) @@ -7069,7 +7312,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; @@ -7125,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) @@ -7138,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; @@ -7170,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(); @@ -7190,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; } } @@ -7208,7 +7451,7 @@ 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()); } } @@ -7264,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: @@ -7400,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 */) @@ -7425,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(), @@ -7448,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; } } @@ -7462,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; @@ -7542,11 +7879,13 @@ 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); if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */) overflow = Reloc::CHECK_BITFIELD; @@ -7562,6 +7901,7 @@ Target_powerpc::Relocate::relocate( overflow = Reloc::CHECK_SIGNED; } + bool maybe_dq_reloc = false; typename Powerpc_relocate_functions::Status status = Powerpc_relocate_functions::STATUS_OK; switch (r_type) @@ -7614,7 +7954,7 @@ Target_powerpc::Relocate::relocate( if (size == 64) { // On ppc64 these are all ds form - status = Reloc::addr16_ds(view, value, overflow); + maybe_dq_reloc = true; break; } case elfcpp::R_POWERPC_ADDR16: @@ -7635,7 +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: - 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: @@ -7682,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 @@ -7736,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: @@ -7801,6 +8148,26 @@ 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 @@ -7836,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, @@ -7853,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 @@ -7903,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, @@ -7920,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 @@ -7935,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, @@ -7950,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); @@ -7966,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; @@ -7992,6 +8419,7 @@ Target_powerpc::relocate_relocs( } // Get the new symbol index. + Output_section* os = NULL; if (r_sym < local_count) { switch (strategy) @@ -8016,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(); @@ -8069,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(); @@ -8102,7 +8544,7 @@ Target_powerpc::relocate_relocs( else { r_type = elfcpp::R_POWERPC_NONE; - offset -= 2 * big_endian; + offset -= d_offset; } break; default: @@ -8132,7 +8574,7 @@ Target_powerpc::relocate_relocs( else { r_type = elfcpp::R_POWERPC_NONE; - offset -= 2 * big_endian; + offset -= d_offset; } } } @@ -8151,7 +8593,7 @@ Target_powerpc::relocate_relocs( else { r_type = elfcpp::R_POWERPC_NONE; - offset -= 2 * big_endian; + offset -= d_offset; } } } @@ -8169,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: @@ -8190,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; } } @@ -8201,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; } } }