const typename elfcpp::Ehdr<size, big_endian>& ehdr)
: Sized_relobj_file<size, big_endian>(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_(),
+ e_flags_(ehdr.get_e_flags()), st_other_()
+ {
+ this->set_abiversion(0);
+ }
~Powerpc_relobj()
{ }
+ // Read the symbols then set up st_other vector.
+ void
+ do_read_symbols(Read_symbols_data*);
+
// The .got2 section shndx.
unsigned int
got2_shndx() const
return NULL;
}
+ int
+ abiversion() const
+ { return this->e_flags_ & elfcpp::EF_PPC64_ABI; }
+
+ // Set ABI version for input and output
+ void
+ set_abiversion(int ver);
+
+ unsigned int
+ ppc64_local_entry_offset(const Symbol* sym) const
+ { return elfcpp::ppc64_decode_local_entry(sym->nonvis() >> 3); }
+
+ unsigned int
+ ppc64_local_entry_offset(unsigned int symndx) const
+ { return elfcpp::ppc64_decode_local_entry(this->st_other_[symndx] >> 5); }
+
private:
struct Opd_ent
{
// The stub table to use for a given input section.
std::vector<Stub_table<size, big_endian>*> stub_table_;
+
+ // Header e_flags
+ elfcpp::Elf_Word e_flags_;
+
+ // ELF st_other field for local symbols.
+ std::vector<unsigned char> st_other_;
};
template<int size, bool big_endian>
Powerpc_dynobj(const std::string& name, Input_file* input_file, off_t offset,
const typename elfcpp::Ehdr<size, big_endian>& ehdr)
: Sized_dynobj<size, big_endian>(name, input_file, offset, ehdr),
- opd_shndx_(0), opd_ent_()
- { }
+ opd_shndx_(0), opd_ent_(), e_flags_(ehdr.get_e_flags())
+ {
+ this->set_abiversion(0);
+ }
~Powerpc_dynobj()
{ }
this->opd_ent_[ndx].off = value;
}
+ int
+ abiversion() const
+ { return this->e_flags_ & elfcpp::EF_PPC64_ABI; }
+
+ // Set ABI version for input and output.
+ void
+ set_abiversion(int ver);
+
private:
// Used to specify extent of executable sections.
struct Sec_info
// corresponding to the address. Note that in dynamic objects,
// offset is *not* relative to the section.
std::vector<Opd_ent> opd_ent_;
+
+ // Header e_flags
+ elfcpp::Elf_Word e_flags_;
};
template<int size, bool big_endian>
// Return the offset of the first non-reserved PLT entry.
unsigned int
- first_plt_entry_offset() const;
+ first_plt_entry_offset() const
+ {
+ if (size == 32)
+ return 0;
+ if (this->abiversion() >= 2)
+ return 16;
+ return 24;
+ }
// Return the size of each PLT entry.
unsigned int
- plt_entry_size() const;
+ plt_entry_size() const
+ {
+ if (size == 32)
+ return 4;
+ if (this->abiversion() >= 2)
+ return 8;
+ return 24;
+ }
// Add any special sections for this symbol to the gc work list.
// For powerpc64, this adds the code section of a function
plt_thread_safe() const
{ return this->plt_thread_safe_; }
+ int
+ abiversion () const
+ { return this->processor_specific_flags() & elfcpp::EF_PPC64_ABI; }
+
+ void
+ set_abiversion (int ver)
+ {
+ elfcpp::Elf_Word flags = this->processor_specific_flags();
+ flags &= ~elfcpp::EF_PPC64_ABI;
+ flags |= ver & elfcpp::EF_PPC64_ABI;
+ this->set_processor_specific_flags(flags);
+ }
+
+ // Offset to to save stack slot
+ int
+ stk_toc () const
+ { return this->abiversion() < 2 ? 40 : 24; }
+
private:
class Track_tls
}
};
+// Set ABI version for input and output.
+
+template<int size, bool big_endian>
+void
+Powerpc_relobj<size, big_endian>::set_abiversion(int ver)
+{
+ this->e_flags_ |= ver;
+ if (this->abiversion() != 0)
+ {
+ Target_powerpc<size, big_endian>* target =
+ static_cast<Target_powerpc<size, big_endian>*>(
+ parameters->sized_target<size, big_endian>());
+ if (target->abiversion() == 0)
+ target->set_abiversion(this->abiversion());
+ else if (target->abiversion() != this->abiversion())
+ gold_error(_("%s: ABI version %d is not compatible "
+ "with ABI version %d output"),
+ this->name().c_str(),
+ this->abiversion(), target->abiversion());
+
+ }
+}
+
// Stash away the index of .got2 or .opd in a relocatable object, if
// such a section exists.
{
unsigned int ndx = (s - pshdrs) / elfcpp::Elf_sizes<size>::shdr_size;
this->special_ = ndx;
+ if (size == 64)
+ {
+ if (this->abiversion() == 0)
+ this->set_abiversion(1);
+ else if (this->abiversion() > 1)
+ gold_error(_("%s: .opd invalid in abiv%d"),
+ this->name().c_str(), this->abiversion());
+ }
}
return Sized_relobj_file<size, big_endian>::do_find_special_sections(sd);
}
}
}
+// Read the symbols then set up st_other vector.
+
+template<int size, bool big_endian>
+void
+Powerpc_relobj<size, big_endian>::do_read_symbols(Read_symbols_data* sd)
+{
+ Sized_relobj_file<size, big_endian>::do_read_symbols(sd);
+ if (size == 64)
+ {
+ const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
+ const unsigned char* const pshdrs = sd->section_headers->data();
+ const unsigned int loccount = this->do_local_symbol_count();
+ if (loccount != 0)
+ {
+ this->st_other_.resize(loccount);
+ const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
+ off_t locsize = loccount * sym_size;
+ const unsigned int symtab_shndx = this->symtab_shndx();
+ const unsigned char *psymtab = pshdrs + symtab_shndx * shdr_size;
+ typename elfcpp::Shdr<size, big_endian> shdr(psymtab);
+ const unsigned char* psyms = this->get_view(shdr.get_sh_offset(),
+ locsize, true, false);
+ psyms += sym_size;
+ for (unsigned int i = 1; i < loccount; ++i, psyms += sym_size)
+ {
+ elfcpp::Sym<size, big_endian> sym(psyms);
+ unsigned char st_other = sym.get_st_other();
+ this->st_other_[i] = st_other;
+ if ((st_other & elfcpp::STO_PPC64_LOCAL_MASK) != 0)
+ {
+ if (this->abiversion() == 0)
+ this->set_abiversion(2);
+ else if (this->abiversion() < 2)
+ gold_error(_("%s: local symbol %d has invalid st_other"
+ " for ABI version 1"),
+ this->name().c_str(), i);
+ }
+ }
+ }
+ }
+}
+
+template<int size, bool big_endian>
+void
+Powerpc_dynobj<size, big_endian>::set_abiversion(int ver)
+{
+ this->e_flags_ |= ver;
+ if (this->abiversion() != 0)
+ {
+ Target_powerpc<size, big_endian>* target =
+ static_cast<Target_powerpc<size, big_endian>*>(
+ parameters->sized_target<size, big_endian>());
+ if (target->abiversion() == 0)
+ target->set_abiversion(this->abiversion());
+ else if (target->abiversion() != this->abiversion())
+ gold_error(_("%s: ABI version %d is not compatible "
+ "with ABI version %d output"),
+ this->name().c_str(),
+ this->abiversion(), target->abiversion());
+
+ }
+}
+
// Call Sized_dynobj::do_read_symbols to read the symbols then
// read .opd from a dynamic object, filling in opd_ent_ vector,
if (shdr.get_sh_type() == elfcpp::SHT_PROGBITS
&& (shdr.get_sh_flags() & elfcpp::SHF_ALLOC) != 0)
{
+ if (this->abiversion() == 0)
+ this->set_abiversion(1);
+ else if (this->abiversion() > 1)
+ gold_error(_("%s: .opd invalid in abiv%d"),
+ this->name().c_str(), this->abiversion());
+
this->opd_shndx_ = (s - pshdrs) / shdr_size;
this->opd_address_ = shdr.get_sh_addr();
opd_size = convert_to_section_size_type(shdr.get_sh_size());
0, false, false);
}
}
+ else
+ {
+ // Define .TOC. as for 32-bit _GLOBAL_OFFSET_TABLE_
+ Symbol *gotsym = symtab->lookup(".TOC.", NULL);
+ if (gotsym != NULL && gotsym->is_undefined())
+ {
+ Target_powerpc<size, big_endian>* target =
+ static_cast<Target_powerpc<size, big_endian>*>(
+ parameters->sized_target<size, big_endian>());
+ Output_data_got_powerpc<size, big_endian>* got
+ = target->got_section(symtab, layout);
+ symtab->define_in_output_data(".TOC.", NULL,
+ Symbol_table::PREDEFINED,
+ got, 0x8000, 0,
+ elfcpp::STT_OBJECT,
+ elfcpp::STB_LOCAL,
+ elfcpp::STV_HIDDEN, 0,
+ false, false);
+ }
+ }
}
// Set up PowerPC target specific relobj.
}
else
{
- unsigned int max_branch_offset;
+ 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)
to = symtab->compute_final_value<size>(gsym, &status);
if (status != Symbol_table::CFVS_OK)
return;
+ to += this->object_->ppc64_local_entry_offset(gsym);
}
else
{
|| !symval.has_output_value())
return;
to = symval.value(this->object_, 0);
+ to += this->object_->ppc64_local_entry_offset(this->r_sym_);
}
to += this->addend_;
if (stub_table == NULL)
unsigned int prev_brlt_size = 0;
if (pass == 1)
{
- bool thread_safe = parameters->options().plt_thread_safe();
- if (size == 64 && !parameters->options().user_set_plt_thread_safe())
+ bool thread_safe
+ = this->abiversion() < 2 && parameters->options().plt_thread_safe();
+ if (size == 64
+ && this->abiversion() < 2
+ && !thread_safe
+ && !parameters->options().user_set_plt_thread_safe())
{
static const char* const thread_starter[] =
{
Output_data_plt_powerpc(Target_powerpc<size, big_endian>* targ,
Reloc_section* plt_rel,
- unsigned int reserved_size,
const char* name)
: Output_section_data_build(size == 32 ? 4 : 8),
rel_(plt_rel),
targ_(targ),
- initial_plt_entry_size_(reserved_size),
name_(name)
{ }
{
if (this->current_data_size() == 0)
return 0;
- return ((this->current_data_size() - this->initial_plt_entry_size_)
- / plt_entry_size);
+ return ((this->current_data_size() - this->first_plt_entry_offset())
+ / this->plt_entry_size());
}
- // Return the offset of the first non-reserved PLT entry.
- unsigned int
- first_plt_entry_offset()
- { return this->initial_plt_entry_size_; }
-
- // Return the size of a PLT entry.
- static unsigned int
- get_plt_entry_size()
- { return plt_entry_size; }
-
protected:
void
do_adjust_output_section(Output_section* os)
{ mapfile->print_output_data(this, this->name_); }
private:
- // The size of an entry in the PLT.
- static const int plt_entry_size = size == 32 ? 4 : 24;
+ // Return the offset of the first non-reserved PLT entry.
+ unsigned int
+ first_plt_entry_offset() const
+ {
+ // IPLT has no reserved entry.
+ if (this->name_[3] == 'I')
+ return 0;
+ return this->targ_->first_plt_entry_offset();
+ }
+
+ // Return the size of each PLT entry.
+ unsigned int
+ plt_entry_size() const
+ {
+ return this->targ_->plt_entry_size();
+ }
// Write out the PLT data.
void
Reloc_section* rel_;
// Allows access to .glink for do_write.
Target_powerpc<size, big_endian>* targ_;
- // The size of the first reserved entry.
- int initial_plt_entry_size_;
// What to report in map file.
const char *name_;
};
gsym->set_needs_dynsym_entry();
unsigned int dynrel = elfcpp::R_POWERPC_JMP_SLOT;
this->rel_->add_global(gsym, dynrel, this, off, 0);
- off += plt_entry_size;
+ off += this->plt_entry_size();
this->set_current_data_size(off);
}
}
section_size_type off = this->current_data_size();
gsym->set_plt_offset(off);
unsigned int dynrel = elfcpp::R_POWERPC_IRELATIVE;
- if (size == 64)
+ if (size == 64 && this->targ_->abiversion() < 2)
dynrel = elfcpp::R_PPC64_JMP_IREL;
this->rel_->add_symbolless_global_addend(gsym, dynrel, this, off, 0);
- off += plt_entry_size;
+ off += this->plt_entry_size();
this->set_current_data_size(off);
}
}
section_size_type off = this->current_data_size();
relobj->set_local_plt_offset(local_sym_index, off);
unsigned int dynrel = elfcpp::R_POWERPC_IRELATIVE;
- if (size == 64)
+ if (size == 64 && this->targ_->abiversion() < 2)
dynrel = elfcpp::R_PPC64_JMP_IREL;
this->rel_->add_symbolless_local_addend(relobj, local_sym_index, dynrel,
this, off, 0);
- off += plt_entry_size;
+ off += this->plt_entry_size();
this->set_current_data_size(off);
}
}
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;
-static const uint32_t add_12_2_11 = 0x7d825a14;
-static const uint32_t add_12_12_11 = 0x7d8c5a14;
-static const uint32_t addi_11_11 = 0x396b0000;
-static const uint32_t addi_12_12 = 0x398c0000;
+static const uint32_t add_11_2_11 = 0x7d625a14;
+static const uint32_t add_11_11_2 = 0x7d6b1214;
+static const uint32_t addi_0_12 = 0x380c0000;
static const uint32_t addi_2_2 = 0x38420000;
-static const uint32_t addi_3_2 = 0x38620000;
static const uint32_t addi_3_3 = 0x38630000;
+static const uint32_t addi_11_11 = 0x396b0000;
+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_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_12 = 0x3d8c0000;
-static const uint32_t addis_12_2 = 0x3d820000;
-static const uint32_t addis_3_2 = 0x3c620000;
-static const uint32_t addis_3_13 = 0x3c6d0000;
static const uint32_t b = 0x48000000;
static const uint32_t bcl_20_31 = 0x429f0005;
static const uint32_t bctr = 0x4e800420;
static const uint32_t blr = 0x4e800020;
-static const uint32_t blrl = 0x4e800021;
static const uint32_t bnectr_p4 = 0x4ce20420;
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;
static const uint32_t ld_0_1 = 0xe8010000;
static const uint32_t ld_0_12 = 0xe80c0000;
-static const uint32_t ld_11_12 = 0xe96c0000;
-static const uint32_t ld_11_2 = 0xe9620000;
static const uint32_t ld_2_1 = 0xe8410000;
-static const uint32_t ld_2_11 = 0xe84b0000;
-static const uint32_t ld_2_12 = 0xe84c0000;
static const uint32_t ld_2_2 = 0xe8420000;
+static const uint32_t ld_2_11 = 0xe84b0000;
+static const uint32_t ld_11_2 = 0xe9620000;
+static const uint32_t ld_11_11 = 0xe96b0000;
+static const uint32_t ld_12_2 = 0xe9820000;
+static const uint32_t ld_12_11 = 0xe98b0000;
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_11 = 0x3d600000;
static const uint32_t lis_12 = 0x3d800000;
+static const uint32_t lvx_0_12_0 = 0x7c0c00ce;
static const uint32_t lwz_0_12 = 0x800c0000;
static const uint32_t lwz_11_11 = 0x816b0000;
static const uint32_t lwz_11_30 = 0x817e0000;
static const uint32_t lwz_12_12 = 0x818c0000;
static const uint32_t lwzu_0_12 = 0x840c0000;
-static const uint32_t lvx_0_12_0 = 0x7c0c00ce;
static const uint32_t mflr_0 = 0x7c0802a6;
static const uint32_t mflr_11 = 0x7d6802a6;
static const uint32_t mflr_12 = 0x7d8802a6;
static const uint32_t mtlr_12 = 0x7d8803a6;
static const uint32_t nop = 0x60000000;
static const uint32_t ori_0_0_0 = 0x60000000;
+static const uint32_t srdi_0_0_2 = 0x7800f082;
static const uint32_t std_0_1 = 0xf8010000;
static const uint32_t std_0_12 = 0xf80c0000;
static const uint32_t std_2_1 = 0xf8410000;
static const uint32_t stfd_0_1 = 0xd8010000;
static const uint32_t stvx_0_12_0 = 0x7c0c01ce;
static const uint32_t sub_11_11_12 = 0x7d6c5850;
-static const uint32_t xor_11_11_11 = 0x7d6b5a78;
+static const uint32_t sub_12_12_11 = 0x7d8b6050;
+static const uint32_t xor_2_12_12 = 0x7d826278;
+static const uint32_t xor_11_12_12 = 0x7d8b6278;
// Write out the PLT.
ORDER_DYNAMIC_PLT_RELOCS, false);
this->plt_
= new Output_data_plt_powerpc<size, big_endian>(this, plt_rel,
- size == 32 ? 0 : 24,
"** PLT");
layout->add_output_section_data(".plt",
(size == 32
this->rela_dyn_->output_section()->add_output_section_data(iplt_rel);
this->iplt_
= new Output_data_plt_powerpc<size, big_endian>(this, iplt_rel,
- 0, "** IPLT");
+ "** IPLT");
this->plt_->output_section()->add_output_section_data(this->iplt_);
}
}
elfcpp::DW_CFA_def_cfa, 1, 0 // def_cfa: r1 offset 0.
};
-// Describe __glink_PLTresolve use of LR, 64-bit version.
-static const unsigned char glink_eh_frame_fde_64[] =
+// Describe __glink_PLTresolve use of LR, 64-bit version ABIv1.
+static const unsigned char glink_eh_frame_fde_64v1[] =
{
0, 0, 0, 0, // Replaced with offset to .glink.
0, 0, 0, 0, // Replaced with size of .glink.
elfcpp::DW_CFA_restore_extended, 65
};
+// Describe __glink_PLTresolve use of LR, 64-bit version ABIv2.
+static const unsigned char glink_eh_frame_fde_64v2[] =
+{
+ 0, 0, 0, 0, // Replaced with offset to .glink.
+ 0, 0, 0, 0, // Replaced with size of .glink.
+ 0, // Augmentation size.
+ elfcpp::DW_CFA_advance_loc + 1,
+ elfcpp::DW_CFA_register, 65, 0,
+ elfcpp::DW_CFA_advance_loc + 4,
+ elfcpp::DW_CFA_restore_extended, 65
+};
+
// Describe __glink_PLTresolve use of LR, 32-bit version.
static const unsigned char glink_eh_frame_fde_32[] =
{
<const Powerpc_relobj<size, big_endian>*>(p->first.object_);
got_addr += ppcobj->toc_base_offset();
Address off = plt_addr - got_addr;
- bool static_chain = parameters->options().plt_static_chain();
- bool thread_safe = this->targ_->plt_thread_safe();
- unsigned int bytes = (4 * 5
- + 4 * static_chain
- + 8 * thread_safe
- + 4 * (ha(off) != 0)
- + 4 * (ha(off + 8 + 8 * static_chain) != ha(off)));
+ unsigned int bytes = 4 * 4 + 4 * (ha(off) != 0);
+ if (this->targ_->abiversion() < 2)
+ {
+ bool static_chain = parameters->options().plt_static_chain();
+ bool thread_safe = this->targ_->plt_thread_safe();
+ bytes += (4
+ + 4 * static_chain
+ + 8 * thread_safe
+ + 4 * (ha(off + 8 + 8 * static_chain) != ha(off)));
+ }
unsigned int align = 1 << parameters->options().plt_align();
if (align > 1)
bytes = (bytes + align - 1) & -align;
return;
if (size == 64)
- layout->add_eh_frame_for_plt(this,
- Eh_cie<64>::eh_frame_cie,
- sizeof (Eh_cie<64>::eh_frame_cie),
- glink_eh_frame_fde_64,
- sizeof (glink_eh_frame_fde_64));
+ {
+ if (this->targ_->abiversion() < 2)
+ layout->add_eh_frame_for_plt(this,
+ Eh_cie<64>::eh_frame_cie,
+ sizeof (Eh_cie<64>::eh_frame_cie),
+ glink_eh_frame_fde_64v1,
+ sizeof (glink_eh_frame_fde_64v1));
+ else
+ layout->add_eh_frame_for_plt(this,
+ Eh_cie<64>::eh_frame_cie,
+ sizeof (Eh_cie<64>::eh_frame_cie),
+ glink_eh_frame_fde_64v2,
+ sizeof (glink_eh_frame_fde_64v2));
+ }
else
{
// 32-bit .glink can use the default since the CIE return
total += this->pltresolve_size;
// space for branch table
- total += 8 * count;
- if (count > 0x8000)
- total += 4 * (count - 0x8000);
+ total += 4 * count;
+ if (this->targ_->abiversion() < 2)
+ {
+ total += 4 * count;
+ if (count > 0x8000)
+ total += 4 * (count - 0x8000);
+ }
}
}
cs->first.object_->name().c_str(),
cs->first.sym_->demangled_name().c_str());
- bool static_chain = parameters->options().plt_static_chain();
- bool thread_safe = this->targ_->plt_thread_safe();
+ bool plt_load_toc = this->targ_->abiversion() < 2;
+ bool static_chain
+ = plt_load_toc && parameters->options().plt_static_chain();
+ bool thread_safe
+ = plt_load_toc && this->targ_->plt_thread_safe();
bool use_fake_dep = false;
Address cmp_branch_off = 0;
if (thread_safe)
p = oview + cs->second;
if (ha(off) != 0)
{
- write_insn<big_endian>(p, std_2_1 + 40), p += 4;
- write_insn<big_endian>(p, addis_12_2 + ha(off)), p += 4;
- write_insn<big_endian>(p, ld_11_12 + l(off)), p += 4;
- if (ha(off + 8 + 8 * static_chain) != ha(off))
+ write_insn<big_endian>(p, std_2_1 + this->targ_->stk_toc());
+ p += 4;
+ write_insn<big_endian>(p, addis_11_2 + ha(off));
+ p += 4;
+ write_insn<big_endian>(p, ld_12_11 + l(off));
+ p += 4;
+ if (plt_load_toc
+ && ha(off + 8 + 8 * static_chain) != ha(off))
{
- write_insn<big_endian>(p, addi_12_12 + l(off)), p += 4;
+ write_insn<big_endian>(p, addi_11_11 + l(off));
+ p += 4;
off = 0;
}
- write_insn<big_endian>(p, mtctr_11), p += 4;
- if (use_fake_dep)
+ write_insn<big_endian>(p, mtctr_12);
+ p += 4;
+ if (plt_load_toc)
{
- write_insn<big_endian>(p, xor_11_11_11), p += 4;
- write_insn<big_endian>(p, add_12_12_11), p += 4;
+ if (use_fake_dep)
+ {
+ write_insn<big_endian>(p, xor_2_12_12);
+ p += 4;
+ write_insn<big_endian>(p, add_11_11_2);
+ p += 4;
+ }
+ write_insn<big_endian>(p, ld_2_11 + l(off + 8));
+ p += 4;
+ if (static_chain)
+ {
+ write_insn<big_endian>(p, ld_11_11 + l(off + 16));
+ p += 4;
+ }
}
- write_insn<big_endian>(p, ld_2_12 + l(off + 8)), p += 4;
- if (static_chain)
- write_insn<big_endian>(p, ld_11_12 + l(off + 16)), p += 4;
}
else
{
- write_insn<big_endian>(p, std_2_1 + 40), p += 4;
- write_insn<big_endian>(p, ld_11_2 + l(off)), p += 4;
- if (ha(off + 8 + 8 * static_chain) != ha(off))
+ write_insn<big_endian>(p, std_2_1 + this->targ_->stk_toc());
+ p += 4;
+ write_insn<big_endian>(p, ld_12_2 + l(off));
+ p += 4;
+ if (plt_load_toc
+ && ha(off + 8 + 8 * static_chain) != ha(off))
{
- write_insn<big_endian>(p, addi_2_2 + l(off)), p += 4;
+ write_insn<big_endian>(p, addi_2_2 + l(off));
+ p += 4;
off = 0;
}
- write_insn<big_endian>(p, mtctr_11), p += 4;
- if (use_fake_dep)
+ write_insn<big_endian>(p, mtctr_12);
+ p += 4;
+ if (plt_load_toc)
{
- write_insn<big_endian>(p, xor_11_11_11), p += 4;
- write_insn<big_endian>(p, add_2_2_11), p += 4;
+ if (use_fake_dep)
+ {
+ write_insn<big_endian>(p, xor_11_12_12);
+ p += 4;
+ write_insn<big_endian>(p, add_2_2_11);
+ p += 4;
+ }
+ if (static_chain)
+ {
+ write_insn<big_endian>(p, ld_11_2 + l(off + 16));
+ p += 4;
+ }
+ write_insn<big_endian>(p, ld_2_2 + l(off + 8));
+ p += 4;
}
- if (static_chain)
- write_insn<big_endian>(p, ld_11_2 + l(off + 16)), p += 4;
- write_insn<big_endian>(p, ld_2_2 + l(off + 8)), p += 4;
}
if (thread_safe && !use_fake_dep)
{
- write_insn<big_endian>(p, cmpldi_2_0), p += 4;
- write_insn<big_endian>(p, bnectr_p4), p += 4;
+ write_insn<big_endian>(p, cmpldi_2_0);
+ p += 4;
+ write_insn<big_endian>(p, bnectr_p4);
+ p += 4;
write_insn<big_endian>(p, b | (cmp_branch_off & 0x3fffffc));
}
else
Address brltoff = brlt_addr - got_addr;
if (ha(brltoff) == 0)
{
- write_insn<big_endian>(p, ld_11_2 + l(brltoff)), p += 4;
+ write_insn<big_endian>(p, ld_12_2 + l(brltoff)), p += 4;
}
else
{
- write_insn<big_endian>(p, addis_12_2 + ha(brltoff)), p += 4;
- write_insn<big_endian>(p, ld_11_12 + l(brltoff)), p += 4;
+ write_insn<big_endian>(p, addis_11_2 + ha(brltoff)), p += 4;
+ write_insn<big_endian>(p, ld_12_11 + l(brltoff)), p += 4;
}
- write_insn<big_endian>(p, mtctr_11), p += 4;
+ write_insn<big_endian>(p, mtctr_12), p += 4;
write_insn<big_endian>(p, bctr);
}
}
elfcpp::Swap<64, big_endian>::writeval(p, pltoff), p += 8;
- write_insn<big_endian>(p, mflr_12), p += 4;
- write_insn<big_endian>(p, bcl_20_31), p += 4;
- write_insn<big_endian>(p, mflr_11), p += 4;
- write_insn<big_endian>(p, ld_2_11 + l(-16)), p += 4;
- write_insn<big_endian>(p, mtlr_12), p += 4;
- write_insn<big_endian>(p, add_12_2_11), p += 4;
- write_insn<big_endian>(p, ld_11_12 + 0), p += 4;
- write_insn<big_endian>(p, ld_2_12 + 8), p += 4;
- write_insn<big_endian>(p, mtctr_11), p += 4;
- write_insn<big_endian>(p, ld_11_12 + 16), p += 4;
+ if (this->targ_->abiversion() < 2)
+ {
+ write_insn<big_endian>(p, mflr_12), p += 4;
+ write_insn<big_endian>(p, bcl_20_31), p += 4;
+ write_insn<big_endian>(p, mflr_11), p += 4;
+ write_insn<big_endian>(p, ld_2_11 + l(-16)), p += 4;
+ write_insn<big_endian>(p, mtlr_12), p += 4;
+ write_insn<big_endian>(p, add_11_2_11), p += 4;
+ write_insn<big_endian>(p, ld_12_11 + 0), p += 4;
+ write_insn<big_endian>(p, ld_2_11 + 8), p += 4;
+ write_insn<big_endian>(p, mtctr_12), p += 4;
+ write_insn<big_endian>(p, ld_11_11 + 16), p += 4;
+ }
+ else
+ {
+ write_insn<big_endian>(p, mflr_0), p += 4;
+ write_insn<big_endian>(p, bcl_20_31), p += 4;
+ write_insn<big_endian>(p, mflr_11), p += 4;
+ write_insn<big_endian>(p, ld_2_11 + l(-16)), p += 4;
+ write_insn<big_endian>(p, mtlr_0), p += 4;
+ write_insn<big_endian>(p, sub_12_12_11), p += 4;
+ write_insn<big_endian>(p, add_11_2_11), p += 4;
+ write_insn<big_endian>(p, addi_0_12 + l(-48)), p += 4;
+ write_insn<big_endian>(p, ld_12_11 + 0), p += 4;
+ write_insn<big_endian>(p, srdi_0_0_2), p += 4;
+ write_insn<big_endian>(p, mtctr_12), p += 4;
+ write_insn<big_endian>(p, ld_11_11 + 8), p += 4;
+ }
write_insn<big_endian>(p, bctr), p += 4;
while (p < oview + this->pltresolve_size)
write_insn<big_endian>(p, nop), p += 4;
uint32_t indx = 0;
while (p < oview + oview_size)
{
- if (indx < 0x8000)
+ if (this->targ_->abiversion() < 2)
{
- write_insn<big_endian>(p, li_0_0 + indx), p += 4;
- }
- else
- {
- write_insn<big_endian>(p, lis_0_0 + hi(indx)), p += 4;
- write_insn<big_endian>(p, ori_0_0_0 + l(indx)), p += 4;
+ if (indx < 0x8000)
+ {
+ write_insn<big_endian>(p, li_0_0 + indx), p += 4;
+ }
+ else
+ {
+ write_insn<big_endian>(p, lis_0_0 + hi(indx)), p += 4;
+ write_insn<big_endian>(p, ori_0_0_0 + l(indx)), p += 4;
+ }
}
uint32_t branch_off = 8 - (p - oview);
write_insn<big_endian>(p, b + (branch_off & 0x3fffffc)), p += 4;
return this->plt_->entry_count();
}
-// Return the offset of the first non-reserved PLT entry.
-
-template<int size, bool big_endian>
-unsigned int
-Target_powerpc<size, big_endian>::first_plt_entry_offset() const
-{
- return this->plt_->first_plt_entry_offset();
-}
-
-// Return the size of each PLT entry.
-
-template<int size, bool big_endian>
-unsigned int
-Target_powerpc<size, big_endian>::plt_entry_size() const
-{
- return Output_data_plt_powerpc<size, big_endian>::get_plt_entry_size();
-}
-
// Create a GOT entry for local dynamic __tls_get_addr calls.
template<int size, bool big_endian>
&& (insn2 == nop
|| insn2 == cror_15_15_15 || insn2 == cror_31_31_31))
{
- elfcpp::Swap<32, big_endian>::writeval(wv + 1, ld_2_1 + 40);
+ elfcpp::Swap<32, big_endian>::
+ writeval(wv + 1, ld_2_1 + target->stk_toc());
can_plt_call = true;
}
}
if (r_type != elfcpp::R_PPC_PLTREL24)
addend = rela.get_r_addend();
value = psymval->value(object, addend);
+ if (gsym != NULL)
+ value += object->ppc64_local_entry_offset(gsym);
+ else
+ value += object->ppc64_local_entry_offset(r_sym);
if (size == 64 && is_branch_reloc(r_type))
value = target->symval_for_branch(relinfo->symtab, value,
gsym, object, &dest_shndx);
projects / binutils-gdb.git / commitdiff