+static inline uint32_t
+ha(uint32_t a)
+{
+ return hi(a + 0x8000);
+}
+
+template<int size>
+struct Eh_cie
+{
+ static const unsigned char eh_frame_cie[12];
+};
+
+template<int size>
+const unsigned char Eh_cie<size>::eh_frame_cie[] =
+{
+ 1, // CIE version.
+ 'z', 'R', 0, // Augmentation string.
+ 4, // Code alignment.
+ 0x80 - size / 8 , // Data alignment.
+ 65, // RA reg.
+ 1, // Augmentation size.
+ (elfcpp::DW_EH_PE_pcrel
+ | elfcpp::DW_EH_PE_sdata4), // FDE encoding.
+ elfcpp::DW_CFA_def_cfa, 1, 0 // def_cfa: r1 offset 0.
+};
+
+// 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.
+ 0, // Augmentation size.
+ elfcpp::DW_CFA_advance_loc + 1,
+ elfcpp::DW_CFA_register, 65, 12,
+ elfcpp::DW_CFA_advance_loc + 4,
+ 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[] =
+{
+ 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 + 2,
+ elfcpp::DW_CFA_register, 65, 0,
+ elfcpp::DW_CFA_advance_loc + 4,
+ elfcpp::DW_CFA_restore_extended, 65
+};
+
+static const unsigned char default_fde[] =
+{
+ 0, 0, 0, 0, // Replaced with offset to stubs.
+ 0, 0, 0, 0, // Replaced with size of stubs.
+ 0, // Augmentation size.
+ elfcpp::DW_CFA_nop, // Pad.
+ elfcpp::DW_CFA_nop,
+ elfcpp::DW_CFA_nop
+};
+
+template<bool big_endian>
+static inline void
+write_insn(unsigned char* p, uint32_t v)
+{
+ elfcpp::Swap<32, big_endian>::writeval(p, v);
+}
+
+// Stub_table holds information about plt and long branch stubs.
+// Stubs are built in an area following some input section determined
+// by group_sections(). This input section is converted to a relaxed
+// input section allowing it to be resized to accommodate the stubs
+
+template<int size, bool big_endian>
+class Stub_table : public Output_relaxed_input_section
+{
+ public:
+ typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
+ static const Address invalid_address = static_cast<Address>(0) - 1;
+
+ Stub_table(Target_powerpc<size, big_endian>* targ)
+ : Output_relaxed_input_section(NULL, 0, 0),
+ 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)
+ { }
+
+ // Delayed Output_relaxed_input_section init.
+ void
+ init(const Output_section::Input_section*, Output_section*);
+
+ // Add a plt call stub.
+ void
+ add_plt_call_entry(const Sized_relobj_file<size, big_endian>*,
+ const Symbol*,
+ unsigned int,
+ Address);
+
+ void
+ add_plt_call_entry(const Sized_relobj_file<size, big_endian>*,
+ unsigned int,
+ unsigned int,
+ Address);
+
+ // Find a given plt call stub.
+ Address
+ find_plt_call_entry(const Symbol*) const;
+
+ Address
+ find_plt_call_entry(const Sized_relobj_file<size, big_endian>*,
+ unsigned int) const;
+
+ Address
+ find_plt_call_entry(const Sized_relobj_file<size, big_endian>*,
+ const Symbol*,
+ unsigned int,
+ Address) const;
+
+ Address
+ find_plt_call_entry(const Sized_relobj_file<size, big_endian>*,
+ unsigned int,
+ unsigned int,
+ Address) const;
+
+ // Add a long branch stub.
+ void
+ add_long_branch_entry(const Powerpc_relobj<size, big_endian>*, Address);
+
+ Address
+ find_long_branch_entry(const Powerpc_relobj<size, big_endian>*,
+ Address) const;
+
+ void
+ clear_stubs()
+ {
+ this->plt_call_stubs_.clear();
+ this->plt_size_ = 0;
+ this->long_branch_stubs_.clear();
+ this->branch_size_ = 0;
+ }
+
+ Address
+ set_address_and_size(const Output_section* os, Address off)
+ {
+ Address start_off = off;
+ off += this->orig_data_size_;
+ Address my_size = this->plt_size_ + this->branch_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;
+ this->reset_address_and_file_offset();
+ this->set_current_data_size(my_size);
+ this->set_address_and_file_offset(os->address() + start_off,
+ os->offset() + start_off);
+ return my_size;
+ }
+
+ Address
+ stub_address() const
+ {
+ return align_address(this->address() + this->orig_data_size_,
+ this->stub_align());
+ }
+
+ Address
+ stub_offset() const
+ {
+ return align_address(this->offset() + this->orig_data_size_,
+ this->stub_align());
+ }
+
+ section_size_type
+ plt_size() const
+ { return this->plt_size_; }
+
+ bool
+ size_update()
+ {
+ Output_section* os = this->output_section();
+ if (os->addralign() < this->stub_align())
+ {
+ os->set_addralign(this->stub_align());
+ // FIXME: get rid of the insane checkpointing.
+ // We can't increase alignment of the input section to which
+ // stubs are attached; The input section may be .init which
+ // is pasted together with other .init sections to form a
+ // function. Aligning might insert zero padding resulting in
+ // sigill. However we do need to increase alignment of the
+ // output section so that the align_address() on offset in
+ // set_address_and_size() adds the same padding as the
+ // align_address() on address in stub_address().
+ // What's more, we need this alignment for the layout done in
+ // relaxation_loop_body() so that the output section starts at
+ // a suitably aligned address.
+ os->checkpoint_set_addralign(this->stub_align());
+ }
+ if (this->last_plt_size_ != this->plt_size_
+ || this->last_branch_size_ != this->branch_size_)
+ {
+ this->last_plt_size_ = this->plt_size_;
+ this->last_branch_size_ = this->branch_size_;
+ return true;
+ }
+ return false;
+ }
+
+ // Add .eh_frame info for this stub section. Unlike other linker
+ // generated .eh_frame this is added late in the link, because we
+ // only want the .eh_frame info if this particular stub section is
+ // non-empty.
+ void
+ add_eh_frame(Layout* layout)
+ {
+ if (!this->eh_frame_added_)
+ {
+ if (!parameters->options().ld_generated_unwind_info())
+ return;
+
+ // Since we add stub .eh_frame info late, it must be placed
+ // after all other linker generated .eh_frame info so that
+ // merge mapping need not be updated for input sections.
+ // There is no provision to use a different CIE to that used
+ // by .glink.
+ if (!this->targ_->has_glink())
+ return;
+
+ layout->add_eh_frame_for_plt(this,
+ Eh_cie<size>::eh_frame_cie,
+ sizeof (Eh_cie<size>::eh_frame_cie),
+ default_fde,
+ sizeof (default_fde));
+ this->eh_frame_added_ = true;
+ }
+ }
+
+ Target_powerpc<size, big_endian>*
+ targ() const
+ { return targ_; }
+
+ private:
+ class Plt_stub_ent;
+ class Plt_stub_ent_hash;
+ typedef Unordered_map<Plt_stub_ent, unsigned int,
+ Plt_stub_ent_hash> Plt_stub_entries;
+
+ // Alignment of stub section.
+ unsigned int
+ stub_align() const
+ {
+ if (size == 32)
+ return 16;
+ unsigned int min_align = 32;
+ unsigned int user_align = 1 << parameters->options().plt_align();
+ return std::max(user_align, min_align);
+ }
+
+ // Return the plt offset for the given call stub.
+ Address
+ plt_off(typename Plt_stub_entries::const_iterator p, bool* is_iplt) const
+ {
+ const Symbol* gsym = p->first.sym_;
+ if (gsym != NULL)
+ {
+ *is_iplt = (gsym->type() == elfcpp::STT_GNU_IFUNC
+ && gsym->can_use_relative_reloc(false));
+ return gsym->plt_offset();
+ }
+ else
+ {
+ *is_iplt = true;
+ const Sized_relobj_file<size, big_endian>* relobj = p->first.object_;
+ unsigned int local_sym_index = p->first.locsym_;
+ return relobj->local_plt_offset(local_sym_index);
+ }
+ }
+
+ // Size of a given plt call stub.
+ unsigned int
+ plt_call_size(typename Plt_stub_entries::const_iterator p) const
+ {
+ if (size == 32)
+ return 16;
+
+ bool is_iplt;
+ Address plt_addr = this->plt_off(p, &is_iplt);
+ if (is_iplt)
+ plt_addr += this->targ_->iplt_section()->address();
+ else
+ plt_addr += this->targ_->plt_section()->address();
+ Address got_addr = this->targ_->got_section()->output_section()->address();
+ const Powerpc_relobj<size, big_endian>* ppcobj = static_cast
+ <const Powerpc_relobj<size, big_endian>*>(p->first.object_);
+ got_addr += ppcobj->toc_base_offset();
+ Address off = plt_addr - got_addr;
+ 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 bytes;
+ }
+
+ // Return long branch stub size.
+ unsigned int
+ branch_stub_size(Address to)
+ {
+ Address loc
+ = this->stub_address() + this->last_plt_size_ + this->branch_size_;
+ if (to - loc + (1 << 25) < 2 << 25)
+ return 4;
+ if (size == 64 || !parameters->options().output_is_position_independent())
+ return 16;
+ return 32;
+ }
+
+ // Write out stubs.
+ void
+ do_write(Output_file*);
+
+ // Plt call stub keys.
+ class Plt_stub_ent
+ {
+ public:
+ Plt_stub_ent(const Symbol* sym)
+ : sym_(sym), object_(0), addend_(0), locsym_(0)
+ { }
+
+ Plt_stub_ent(const Sized_relobj_file<size, big_endian>* object,
+ unsigned int locsym_index)
+ : sym_(NULL), object_(object), addend_(0), locsym_(locsym_index)
+ { }
+
+ Plt_stub_ent(const Sized_relobj_file<size, big_endian>* object,
+ const Symbol* sym,
+ unsigned int r_type,
+ Address addend)
+ : sym_(sym), object_(0), addend_(0), locsym_(0)
+ {
+ if (size != 32)
+ this->addend_ = addend;
+ else if (parameters->options().output_is_position_independent()
+ && r_type == elfcpp::R_PPC_PLTREL24)
+ {
+ this->addend_ = addend;
+ if (this->addend_ >= 32768)
+ this->object_ = object;
+ }
+ }
+
+ Plt_stub_ent(const Sized_relobj_file<size, big_endian>* object,
+ unsigned int locsym_index,
+ unsigned int r_type,
+ Address addend)
+ : sym_(NULL), object_(object), addend_(0), locsym_(locsym_index)
+ {
+ if (size != 32)
+ this->addend_ = addend;
+ else if (parameters->options().output_is_position_independent()
+ && r_type == elfcpp::R_PPC_PLTREL24)
+ this->addend_ = addend;
+ }
+
+ bool operator==(const Plt_stub_ent& that) const
+ {
+ return (this->sym_ == that.sym_
+ && this->object_ == that.object_
+ && this->addend_ == that.addend_
+ && this->locsym_ == that.locsym_);
+ }
+
+ const Symbol* sym_;
+ const Sized_relobj_file<size, big_endian>* object_;
+ typename elfcpp::Elf_types<size>::Elf_Addr addend_;
+ unsigned int locsym_;
+ };
+
+ class Plt_stub_ent_hash
+ {
+ public:
+ size_t operator()(const Plt_stub_ent& ent) const
+ {
+ return (reinterpret_cast<uintptr_t>(ent.sym_)
+ ^ reinterpret_cast<uintptr_t>(ent.object_)
+ ^ ent.addend_
+ ^ ent.locsym_);
+ }
+ };
+
+ // Long branch stub keys.
+ class Branch_stub_ent
+ {
+ public:
+ Branch_stub_ent(const Powerpc_relobj<size, big_endian>* obj, Address to)
+ : dest_(to), toc_base_off_(0)
+ {
+ if (size == 64)
+ toc_base_off_ = obj->toc_base_offset();
+ }
+
+ bool operator==(const Branch_stub_ent& that) const
+ {
+ return (this->dest_ == that.dest_
+ && (size == 32
+ || this->toc_base_off_ == that.toc_base_off_));
+ }
+
+ Address dest_;
+ unsigned int toc_base_off_;
+ };
+
+ class Branch_stub_ent_hash
+ {
+ public:
+ size_t operator()(const Branch_stub_ent& ent) const
+ { return ent.dest_ ^ ent.toc_base_off_; }
+ };
+
+ // In a sane world this would be a global.
+ Target_powerpc<size, big_endian>* targ_;
+ // Map sym/object/addend to stub offset.
+ Plt_stub_entries plt_call_stubs_;
+ // Map destination address to stub offset.
+ typedef Unordered_map<Branch_stub_ent, unsigned int,
+ Branch_stub_ent_hash> Branch_stub_entries;
+ Branch_stub_entries long_branch_stubs_;
+ // size of input section
+ section_size_type orig_data_size_;
+ // size of stubs
+ section_size_type plt_size_, last_plt_size_, branch_size_, last_branch_size_;
+ // Whether .eh_frame info has been created for this stub section.
+ bool eh_frame_added_;
+};
+
+// Make a new stub table, and record.
+
+template<int size, bool big_endian>
+Stub_table<size, big_endian>*
+Target_powerpc<size, big_endian>::new_stub_table()
+{
+ Stub_table<size, big_endian>* stub_table
+ = new Stub_table<size, big_endian>(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<int size, bool big_endian>
+void
+Stub_table<size, big_endian>::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<Output_relaxed_input_section*> 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<int size, bool big_endian>
+void
+Stub_table<size, big_endian>::add_plt_call_entry(
+ const Sized_relobj_file<size, big_endian>* object,
+ const Symbol* gsym,
+ unsigned int r_type,
+ Address addend)
+{
+ Plt_stub_ent ent(object, gsym, r_type, addend);
+ unsigned int off = this->plt_size_;
+ std::pair<typename Plt_stub_entries::iterator, bool> p
+ = this->plt_call_stubs_.insert(std::make_pair(ent, off));
+ if (p.second)
+ this->plt_size_ = off + this->plt_call_size(p.first);
+}
+
+template<int size, bool big_endian>
+void
+Stub_table<size, big_endian>::add_plt_call_entry(
+ const Sized_relobj_file<size, big_endian>* object,
+ unsigned int locsym_index,
+ unsigned int r_type,
+ Address addend)
+{
+ Plt_stub_ent ent(object, locsym_index, r_type, addend);
+ unsigned int off = this->plt_size_;
+ std::pair<typename Plt_stub_entries::iterator, bool> p
+ = this->plt_call_stubs_.insert(std::make_pair(ent, off));
+ if (p.second)
+ this->plt_size_ = off + this->plt_call_size(p.first);
+}
+
+// Find a plt call stub.
+
+template<int size, bool big_endian>
+typename Stub_table<size, big_endian>::Address
+Stub_table<size, big_endian>::find_plt_call_entry(
+ const Sized_relobj_file<size, big_endian>* object,
+ const Symbol* gsym,
+ unsigned int r_type,
+ Address addend) const
+{
+ Plt_stub_ent ent(object, gsym, r_type, addend);
+ typename Plt_stub_entries::const_iterator p = this->plt_call_stubs_.find(ent);
+ return p == this->plt_call_stubs_.end() ? invalid_address : p->second;
+}
+
+template<int size, bool big_endian>
+typename Stub_table<size, big_endian>::Address
+Stub_table<size, big_endian>::find_plt_call_entry(const Symbol* gsym) const
+{
+ Plt_stub_ent ent(gsym);
+ typename Plt_stub_entries::const_iterator p = this->plt_call_stubs_.find(ent);
+ return p == this->plt_call_stubs_.end() ? invalid_address : p->second;
+}
+
+template<int size, bool big_endian>
+typename Stub_table<size, big_endian>::Address
+Stub_table<size, big_endian>::find_plt_call_entry(
+ const Sized_relobj_file<size, big_endian>* object,
+ unsigned int locsym_index,
+ unsigned int r_type,
+ Address addend) const
+{
+ Plt_stub_ent ent(object, locsym_index, r_type, addend);
+ typename Plt_stub_entries::const_iterator p = this->plt_call_stubs_.find(ent);
+ return p == this->plt_call_stubs_.end() ? invalid_address : p->second;
+}
+
+template<int size, bool big_endian>
+typename Stub_table<size, big_endian>::Address
+Stub_table<size, big_endian>::find_plt_call_entry(
+ const Sized_relobj_file<size, big_endian>* object,
+ unsigned int locsym_index) const
+{
+ Plt_stub_ent ent(object, locsym_index);
+ typename Plt_stub_entries::const_iterator p = this->plt_call_stubs_.find(ent);
+ return p == this->plt_call_stubs_.end() ? invalid_address : p->second;
+}
+
+// Add a long branch stub if we don't already have one to given
+// destination.
+
+template<int size, bool big_endian>
+void
+Stub_table<size, big_endian>::add_long_branch_entry(
+ const Powerpc_relobj<size, big_endian>* object,
+ Address to)
+{
+ Branch_stub_ent ent(object, to);
+ 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);
+ }
+}
+
+// Find long branch stub.
+
+template<int size, bool big_endian>
+typename Stub_table<size, big_endian>::Address
+Stub_table<size, big_endian>::find_long_branch_entry(
+ const Powerpc_relobj<size, big_endian>* object,
+ Address to) const
+{
+ Branch_stub_ent ent(object, to);
+ typename Branch_stub_entries::const_iterator p
+ = this->long_branch_stubs_.find(ent);
+ return p == this->long_branch_stubs_.end() ? invalid_address : p->second;
+}
+
+// A class to handle .glink.
+
+template<int size, bool big_endian>
+class Output_data_glink : public Output_section_data
+{
+ public:
+ typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
+ static const Address invalid_address = static_cast<Address>(0) - 1;
+ static const int pltresolve_size = 16*4;
+
+ Output_data_glink(Target_powerpc<size, big_endian>* targ)
+ : Output_section_data(16), targ_(targ), global_entry_stubs_(),
+ end_branch_table_(), ge_size_(0)
+ { }
+
+ void
+ add_eh_frame(Layout* layout);
+
+ void
+ add_global_entry(const Symbol*);
+
+ Address
+ find_global_entry(const Symbol*) const;
+
+ Address
+ global_entry_address() const
+ {
+ gold_assert(this->is_data_size_valid());
+ unsigned int global_entry_off = (this->end_branch_table_ + 15) & -16;
+ return this->address() + global_entry_off;
+ }
+
+ protected:
+ // Write to a map file.
+ void
+ do_print_to_mapfile(Mapfile* mapfile) const
+ { mapfile->print_output_data(this, _("** glink")); }
+
+ private:
+ void
+ set_final_data_size();
+
+ // Write out .glink
+ void
+ do_write(Output_file*);
+
+ // Allows access to .got and .plt for do_write.
+ Target_powerpc<size, big_endian>* targ_;
+
+ // Map sym to stub offset.
+ typedef Unordered_map<const Symbol*, unsigned int> Global_entry_stub_entries;
+ Global_entry_stub_entries global_entry_stubs_;
+
+ unsigned int end_branch_table_, ge_size_;
+};
+
+template<int size, bool big_endian>
+void
+Output_data_glink<size, big_endian>::add_eh_frame(Layout* layout)
+{
+ if (!parameters->options().ld_generated_unwind_info())
+ return;
+
+ if (size == 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
+ // address reg, LR, is valid.
+ layout->add_eh_frame_for_plt(this,
+ Eh_cie<32>::eh_frame_cie,
+ sizeof (Eh_cie<32>::eh_frame_cie),
+ default_fde,
+ sizeof (default_fde));
+ // Except where LR is used in a PIC __glink_PLTresolve.
+ if (parameters->options().output_is_position_independent())
+ layout->add_eh_frame_for_plt(this,
+ Eh_cie<32>::eh_frame_cie,
+ sizeof (Eh_cie<32>::eh_frame_cie),
+ glink_eh_frame_fde_32,
+ sizeof (glink_eh_frame_fde_32));
+ }
+}
+
+template<int size, bool big_endian>
+void
+Output_data_glink<size, big_endian>::add_global_entry(const Symbol* gsym)
+{
+ std::pair<typename Global_entry_stub_entries::iterator, bool> p
+ = this->global_entry_stubs_.insert(std::make_pair(gsym, this->ge_size_));
+ if (p.second)
+ this->ge_size_ += 16;
+}
+
+template<int size, bool big_endian>
+typename Output_data_glink<size, big_endian>::Address
+Output_data_glink<size, big_endian>::find_global_entry(const Symbol* gsym) const
+{
+ typename Global_entry_stub_entries::const_iterator p
+ = this->global_entry_stubs_.find(gsym);
+ return p == this->global_entry_stubs_.end() ? invalid_address : p->second;
+}
+
+template<int size, bool big_endian>
+void
+Output_data_glink<size, big_endian>::set_final_data_size()
+{
+ unsigned int count = this->targ_->plt_entry_count();
+ section_size_type total = 0;
+
+ if (count != 0)
+ {
+ if (size == 32)
+ {
+ // space for branch table
+ total += 4 * (count - 1);
+
+ total += -total & 15;
+ total += this->pltresolve_size;
+ }
+ else
+ {
+ total += this->pltresolve_size;
+
+ // space for branch table
+ total += 4 * count;
+ if (this->targ_->abiversion() < 2)
+ {
+ total += 4 * count;
+ if (count > 0x8000)
+ total += 4 * (count - 0x8000);
+ }
+ }
+ }
+ this->end_branch_table_ = total;
+ total = (total + 15) & -16;
+ total += this->ge_size_;
+
+ this->set_data_size(total);
+}
+
+// Write out plt and long branch stub code.
+
+template<int size, bool big_endian>
+void
+Stub_table<size, big_endian>::do_write(Output_file* of)
+{
+ if (this->plt_call_stubs_.empty()
+ && this->long_branch_stubs_.empty())
+ return;
+
+ const section_size_type start_off = this->offset();
+ const section_size_type off = this->stub_offset();
+ const section_size_type oview_size =
+ convert_to_section_size_type(this->data_size() - (off - start_off));
+ unsigned char* const oview = of->get_output_view(off, oview_size);
+ unsigned char* p;
+
+ if (size == 64)
+ {
+ const Output_data_got_powerpc<size, big_endian>* got
+ = this->targ_->got_section();
+ Address got_os_addr = got->output_section()->address();
+
+ if (!this->plt_call_stubs_.empty())
+ {
+ // The base address of the .plt section.
+ Address plt_base = this->targ_->plt_section()->address();
+ Address iplt_base = invalid_address;
+
+ // Write out plt call stubs.
+ typename Plt_stub_entries::const_iterator cs;
+ for (cs = this->plt_call_stubs_.begin();
+ cs != this->plt_call_stubs_.end();
+ ++cs)
+ {
+ bool is_iplt;
+ Address pltoff = this->plt_off(cs, &is_iplt);
+ Address plt_addr = pltoff;
+ if (is_iplt)
+ {
+ if (iplt_base == invalid_address)
+ iplt_base = this->targ_->iplt_section()->address();
+ plt_addr += iplt_base;
+ }
+ else
+ plt_addr += plt_base;
+ const Powerpc_relobj<size, big_endian>* ppcobj = static_cast
+ <const Powerpc_relobj<size, big_endian>*>(cs->first.object_);
+ Address got_addr = got_os_addr + ppcobj->toc_base_offset();
+ Address off = plt_addr - got_addr;
+
+ if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
+ gold_error(_("%s: linkage table error against `%s'"),
+ cs->first.object_->name().c_str(),
+ cs->first.sym_->demangled_name().c_str());
+
+ 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)
+ {
+ unsigned int pltindex
+ = ((pltoff - this->targ_->first_plt_entry_offset())
+ / this->targ_->plt_entry_size());
+ Address glinkoff
+ = (this->targ_->glink_section()->pltresolve_size
+ + pltindex * 8);
+ if (pltindex > 32768)
+ glinkoff += (pltindex - 32768) * 4;
+ Address to
+ = this->targ_->glink_section()->address() + glinkoff;
+ Address from
+ = (this->stub_address() + cs->second + 24
+ + 4 * (ha(off) != 0)
+ + 4 * (ha(off + 8 + 8 * static_chain) != ha(off))
+ + 4 * static_chain);
+ cmp_branch_off = to - from;
+ use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
+ }
+
+ p = oview + cs->second;
+ if (ha(off) != 0)
+ {
+ write_insn<big_endian>(p, std_2_1 + this->targ_->stk_toc());
+ p += 4;
+ if (plt_load_toc)
+ {
+ write_insn<big_endian>(p, addis_11_2 + ha(off));
+ p += 4;
+ write_insn<big_endian>(p, ld_12_11 + l(off));
+ p += 4;
+ }
+ else
+ {
+ write_insn<big_endian>(p, addis_12_2 + ha(off));
+ p += 4;
+ write_insn<big_endian>(p, ld_12_12 + l(off));
+ p += 4;
+ }
+ if (plt_load_toc
+ && ha(off + 8 + 8 * static_chain) != ha(off))
+ {
+ write_insn<big_endian>(p, addi_11_11 + l(off));
+ p += 4;
+ off = 0;
+ }
+ write_insn<big_endian>(p, mtctr_12);
+ p += 4;
+ if (plt_load_toc)
+ {
+ 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;
+ }
+ }
+ }
+ else
+ {
+ 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;
+ off = 0;
+ }
+ write_insn<big_endian>(p, mtctr_12);
+ p += 4;
+ if (plt_load_toc)
+ {
+ 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 (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, b | (cmp_branch_off & 0x3fffffc));
+ }
+ else
+ write_insn<big_endian>(p, bctr);
+ }
+ }
+
+ // Write out long branch stubs.
+ typename Branch_stub_entries::const_iterator bs;
+ for (bs = this->long_branch_stubs_.begin();
+ bs != this->long_branch_stubs_.end();
+ ++bs)
+ {
+ p = oview + this->plt_size_ + bs->second;
+ Address loc = this->stub_address() + this->plt_size_ + bs->second;
+ Address delta = bs->first.dest_ - loc;
+ if (delta + (1 << 25) < 2 << 25)
+ write_insn<big_endian>(p, b | (delta & 0x3fffffc));
+ else
+ {
+ Address brlt_addr
+ = this->targ_->find_branch_lookup_table(bs->first.dest_);
+ gold_assert(brlt_addr != invalid_address);
+ brlt_addr += this->targ_->brlt_section()->address();
+ Address got_addr = got_os_addr + bs->first.toc_base_off_;
+ Address brltoff = brlt_addr - got_addr;
+ if (ha(brltoff) == 0)
+ {
+ 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_12_12 + l(brltoff)), p += 4;
+ }
+ write_insn<big_endian>(p, mtctr_12), p += 4;
+ write_insn<big_endian>(p, bctr);
+ }
+ }
+ }
+ else
+ {
+ if (!this->plt_call_stubs_.empty())
+ {
+ // The base address of the .plt section.
+ Address plt_base = this->targ_->plt_section()->address();
+ Address iplt_base = invalid_address;
+ // The address of _GLOBAL_OFFSET_TABLE_.
+ Address g_o_t = invalid_address;
+
+ // Write out plt call stubs.
+ typename Plt_stub_entries::const_iterator cs;
+ for (cs = this->plt_call_stubs_.begin();
+ cs != this->plt_call_stubs_.end();
+ ++cs)
+ {
+ bool is_iplt;
+ Address plt_addr = this->plt_off(cs, &is_iplt);
+ if (is_iplt)
+ {
+ if (iplt_base == invalid_address)
+ iplt_base = this->targ_->iplt_section()->address();
+ plt_addr += iplt_base;
+ }
+ else
+ plt_addr += plt_base;
+
+ p = oview + cs->second;
+ if (parameters->options().output_is_position_independent())
+ {
+ Address got_addr;
+ const Powerpc_relobj<size, big_endian>* ppcobj
+ = (static_cast<const Powerpc_relobj<size, big_endian>*>
+ (cs->first.object_));
+ if (ppcobj != NULL && cs->first.addend_ >= 32768)
+ {
+ unsigned int got2 = ppcobj->got2_shndx();
+ got_addr = ppcobj->get_output_section_offset(got2);
+ gold_assert(got_addr != invalid_address);
+ got_addr += (ppcobj->output_section(got2)->address()
+ + cs->first.addend_);
+ }
+ else
+ {
+ if (g_o_t == invalid_address)
+ {
+ const Output_data_got_powerpc<size, big_endian>* got
+ = this->targ_->got_section();
+ g_o_t = got->address() + got->g_o_t();
+ }
+ got_addr = g_o_t;
+ }
+
+ Address off = plt_addr - got_addr;
+ if (ha(off) == 0)
+ {
+ write_insn<big_endian>(p + 0, lwz_11_30 + l(off));
+ write_insn<big_endian>(p + 4, mtctr_11);
+ write_insn<big_endian>(p + 8, bctr);
+ }
+ else
+ {
+ write_insn<big_endian>(p + 0, addis_11_30 + ha(off));
+ write_insn<big_endian>(p + 4, lwz_11_11 + l(off));
+ write_insn<big_endian>(p + 8, mtctr_11);
+ write_insn<big_endian>(p + 12, bctr);
+ }
+ }
+ else
+ {
+ write_insn<big_endian>(p + 0, lis_11 + ha(plt_addr));
+ write_insn<big_endian>(p + 4, lwz_11_11 + l(plt_addr));
+ write_insn<big_endian>(p + 8, mtctr_11);
+ write_insn<big_endian>(p + 12, bctr);
+ }
+ }
+ }
+
+ // Write out long branch stubs.
+ typename Branch_stub_entries::const_iterator bs;
+ for (bs = this->long_branch_stubs_.begin();
+ bs != this->long_branch_stubs_.end();
+ ++bs)
+ {
+ p = oview + this->plt_size_ + bs->second;
+ Address loc = this->stub_address() + this->plt_size_ + bs->second;
+ Address delta = bs->first.dest_ - loc;
+ if (delta + (1 << 25) < 2 << 25)
+ write_insn<big_endian>(p, b | (delta & 0x3fffffc));
+ else if (!parameters->options().output_is_position_independent())
+ {
+ write_insn<big_endian>(p + 0, lis_12 + ha(bs->first.dest_));
+ write_insn<big_endian>(p + 4, addi_12_12 + l(bs->first.dest_));
+ write_insn<big_endian>(p + 8, mtctr_12);
+ write_insn<big_endian>(p + 12, bctr);
+ }
+ else
+ {
+ delta -= 8;
+ write_insn<big_endian>(p + 0, mflr_0);
+ write_insn<big_endian>(p + 4, bcl_20_31);
+ write_insn<big_endian>(p + 8, mflr_12);
+ write_insn<big_endian>(p + 12, addis_12_12 + ha(delta));
+ write_insn<big_endian>(p + 16, addi_12_12 + l(delta));
+ write_insn<big_endian>(p + 20, mtlr_0);
+ write_insn<big_endian>(p + 24, mtctr_12);
+ write_insn<big_endian>(p + 28, bctr);
+ }
+ }
+ }
+}
+
+// Write out .glink.
+
+template<int size, bool big_endian>
+void
+Output_data_glink<size, big_endian>::do_write(Output_file* of)
+{
+ const section_size_type off = this->offset();
+ const section_size_type oview_size =
+ convert_to_section_size_type(this->data_size());
+ unsigned char* const oview = of->get_output_view(off, oview_size);
+ unsigned char* p;
+
+ // The base address of the .plt section.
+ typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
+ Address plt_base = this->targ_->plt_section()->address();
+
+ if (size == 64)
+ {
+ if (this->end_branch_table_ != 0)
+ {
+ // Write pltresolve stub.
+ p = oview;
+ Address after_bcl = this->address() + 16;
+ Address pltoff = plt_base - after_bcl;
+
+ elfcpp::Swap<64, big_endian>::writeval(p, pltoff), p += 8;
+
+ 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;
+
+ // Write lazy link call stubs.
+ uint32_t indx = 0;
+ while (p < oview + this->end_branch_table_)
+ {
+ if (this->targ_->abiversion() < 2)
+ {
+ 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;
+ indx++;
+ }
+ }
+
+ Address plt_base = this->targ_->plt_section()->address();
+ Address iplt_base = invalid_address;
+ unsigned int global_entry_off = (this->end_branch_table_ + 15) & -16;
+ Address global_entry_base = this->address() + global_entry_off;
+ typename Global_entry_stub_entries::const_iterator ge;
+ for (ge = this->global_entry_stubs_.begin();
+ ge != this->global_entry_stubs_.end();
+ ++ge)
+ {
+ p = oview + global_entry_off + ge->second;
+ Address plt_addr = ge->first->plt_offset();
+ if (ge->first->type() == elfcpp::STT_GNU_IFUNC
+ && ge->first->can_use_relative_reloc(false))
+ {
+ if (iplt_base == invalid_address)
+ iplt_base = this->targ_->iplt_section()->address();
+ plt_addr += iplt_base;
+ }
+ else
+ plt_addr += plt_base;
+ Address my_addr = global_entry_base + ge->second;
+ Address off = plt_addr - my_addr;
+
+ if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
+ gold_error(_("%s: linkage table error against `%s'"),
+ ge->first->object()->name().c_str(),
+ ge->first->demangled_name().c_str());
+
+ write_insn<big_endian>(p, addis_12_12 + ha(off)), p += 4;
+ write_insn<big_endian>(p, ld_12_12 + l(off)), p += 4;
+ write_insn<big_endian>(p, mtctr_12), p += 4;
+ write_insn<big_endian>(p, bctr);
+ }
+ }