1 // powerpc.cc -- powerpc target support for gold.
3 // Copyright (C) 2008-2017 Free Software Foundation, Inc.
4 // Written by David S. Miller <davem@davemloft.net>
5 // and David Edelsohn <edelsohn@gnu.org>
7 // This file is part of gold.
9 // This program is free software; you can redistribute it and/or modify
10 // it under the terms of the GNU General Public License as published by
11 // the Free Software Foundation; either version 3 of the License, or
12 // (at your option) any later version.
14 // This program is distributed in the hope that it will be useful,
15 // but WITHOUT ANY WARRANTY; without even the implied warranty of
16 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 // GNU General Public License for more details.
19 // You should have received a copy of the GNU General Public License
20 // along with this program; if not, write to the Free Software
21 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 // MA 02110-1301, USA.
30 #include "parameters.h"
37 #include "copy-relocs.h"
39 #include "target-reloc.h"
40 #include "target-select.h"
50 template<int size, bool big_endian>
51 class Output_data_plt_powerpc;
53 template<int size, bool big_endian>
54 class Output_data_brlt_powerpc;
56 template<int size, bool big_endian>
57 class Output_data_got_powerpc;
59 template<int size, bool big_endian>
60 class Output_data_glink;
62 template<int size, bool big_endian>
65 template<int size, bool big_endian>
66 class Output_data_save_res;
68 template<int size, bool big_endian>
71 struct Stub_table_owner
74 : output_section(NULL), owner(NULL)
77 Output_section* output_section;
78 const Output_section::Input_section* owner;
82 is_branch_reloc(unsigned int r_type);
84 template<int size, bool big_endian>
85 class Powerpc_relobj : public Sized_relobj_file<size, big_endian>
88 typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
89 typedef Unordered_set<Section_id, Section_id_hash> Section_refs;
90 typedef Unordered_map<Address, Section_refs> Access_from;
92 Powerpc_relobj(const std::string& name, Input_file* input_file, off_t offset,
93 const typename elfcpp::Ehdr<size, big_endian>& ehdr)
94 : Sized_relobj_file<size, big_endian>(name, input_file, offset, ehdr),
95 special_(0), relatoc_(0), toc_(0), no_toc_opt_(),
96 has_small_toc_reloc_(false), opd_valid_(false), opd_ent_(),
97 access_from_map_(), has14_(), stub_table_index_(),
98 e_flags_(ehdr.get_e_flags()), st_other_()
100 this->set_abiversion(0);
106 // Read the symbols then set up st_other vector.
108 do_read_symbols(Read_symbols_data*);
110 // Arrange to always relocate .toc first.
112 do_relocate_sections(
113 const Symbol_table* symtab, const Layout* layout,
114 const unsigned char* pshdrs, Output_file* of,
115 typename Sized_relobj_file<size, big_endian>::Views* pviews);
117 // The .toc section index.
124 // Mark .toc entry at OFF as not optimizable.
126 set_no_toc_opt(Address off)
128 if (this->no_toc_opt_.empty())
129 this->no_toc_opt_.resize(this->section_size(this->toc_shndx())
132 if (off < this->no_toc_opt_.size())
133 this->no_toc_opt_[off] = true;
136 // Mark the entire .toc as not optimizable.
140 this->no_toc_opt_.resize(1);
141 this->no_toc_opt_[0] = true;
144 // Return true if code using the .toc entry at OFF should not be edited.
146 no_toc_opt(Address off) const
148 if (this->no_toc_opt_.empty())
151 if (off >= this->no_toc_opt_.size())
153 return this->no_toc_opt_[off];
156 // The .got2 section shndx.
161 return this->special_;
166 // The .opd section shndx.
173 return this->special_;
176 // Init OPD entry arrays.
178 init_opd(size_t opd_size)
180 size_t count = this->opd_ent_ndx(opd_size);
181 this->opd_ent_.resize(count);
184 // Return section and offset of function entry for .opd + R_OFF.
186 get_opd_ent(Address r_off, Address* value = NULL) const
188 size_t ndx = this->opd_ent_ndx(r_off);
189 gold_assert(ndx < this->opd_ent_.size());
190 gold_assert(this->opd_ent_[ndx].shndx != 0);
192 *value = this->opd_ent_[ndx].off;
193 return this->opd_ent_[ndx].shndx;
196 // Set section and offset of function entry for .opd + R_OFF.
198 set_opd_ent(Address r_off, unsigned int shndx, Address value)
200 size_t ndx = this->opd_ent_ndx(r_off);
201 gold_assert(ndx < this->opd_ent_.size());
202 this->opd_ent_[ndx].shndx = shndx;
203 this->opd_ent_[ndx].off = value;
206 // Return discard flag for .opd + R_OFF.
208 get_opd_discard(Address r_off) const
210 size_t ndx = this->opd_ent_ndx(r_off);
211 gold_assert(ndx < this->opd_ent_.size());
212 return this->opd_ent_[ndx].discard;
215 // Set discard flag for .opd + R_OFF.
217 set_opd_discard(Address r_off)
219 size_t ndx = this->opd_ent_ndx(r_off);
220 gold_assert(ndx < this->opd_ent_.size());
221 this->opd_ent_[ndx].discard = true;
226 { return this->opd_valid_; }
230 { this->opd_valid_ = true; }
232 // Examine .rela.opd to build info about function entry points.
234 scan_opd_relocs(size_t reloc_count,
235 const unsigned char* prelocs,
236 const unsigned char* plocal_syms);
238 // Returns true if a code sequence loading a TOC entry can be
239 // converted into code calculating a TOC pointer relative offset.
241 make_toc_relative(Target_powerpc<size, big_endian>* target,
244 // Perform the Sized_relobj_file method, then set up opd info from
247 do_read_relocs(Read_relocs_data*);
250 do_find_special_sections(Read_symbols_data* sd);
252 // Adjust this local symbol value. Return false if the symbol
253 // should be discarded from the output file.
255 do_adjust_local_symbol(Symbol_value<size>* lv) const
257 if (size == 64 && this->opd_shndx() != 0)
260 if (lv->input_shndx(&is_ordinary) != this->opd_shndx())
262 if (this->get_opd_discard(lv->input_value()))
270 { return &this->access_from_map_; }
272 // Add a reference from SRC_OBJ, SRC_INDX to this object's .opd
273 // section at DST_OFF.
275 add_reference(Relobj* src_obj,
276 unsigned int src_indx,
277 typename elfcpp::Elf_types<size>::Elf_Addr dst_off)
279 Section_id src_id(src_obj, src_indx);
280 this->access_from_map_[dst_off].insert(src_id);
283 // Add a reference to the code section specified by the .opd entry
286 add_gc_mark(typename elfcpp::Elf_types<size>::Elf_Addr dst_off)
288 size_t ndx = this->opd_ent_ndx(dst_off);
289 if (ndx >= this->opd_ent_.size())
290 this->opd_ent_.resize(ndx + 1);
291 this->opd_ent_[ndx].gc_mark = true;
295 process_gc_mark(Symbol_table* symtab)
297 for (size_t i = 0; i < this->opd_ent_.size(); i++)
298 if (this->opd_ent_[i].gc_mark)
300 unsigned int shndx = this->opd_ent_[i].shndx;
301 symtab->gc()->worklist().push_back(Section_id(this, shndx));
305 // Return offset in output GOT section that this object will use
306 // as a TOC pointer. Won't be just a constant with multi-toc support.
308 toc_base_offset() const
312 set_has_small_toc_reloc()
313 { has_small_toc_reloc_ = true; }
316 has_small_toc_reloc() const
317 { return has_small_toc_reloc_; }
320 set_has_14bit_branch(unsigned int shndx)
322 if (shndx >= this->has14_.size())
323 this->has14_.resize(shndx + 1);
324 this->has14_[shndx] = true;
328 has_14bit_branch(unsigned int shndx) const
329 { return shndx < this->has14_.size() && this->has14_[shndx]; }
332 set_stub_table(unsigned int shndx, unsigned int stub_index)
334 if (shndx >= this->stub_table_index_.size())
335 this->stub_table_index_.resize(shndx + 1, -1);
336 this->stub_table_index_[shndx] = stub_index;
339 Stub_table<size, big_endian>*
340 stub_table(unsigned int shndx)
342 if (shndx < this->stub_table_index_.size())
344 Target_powerpc<size, big_endian>* target
345 = static_cast<Target_powerpc<size, big_endian>*>(
346 parameters->sized_target<size, big_endian>());
347 unsigned int indx = this->stub_table_index_[shndx];
348 if (indx < target->stub_tables().size())
349 return target->stub_tables()[indx];
357 this->stub_table_index_.clear();
362 { return this->e_flags_ & elfcpp::EF_PPC64_ABI; }
364 // Set ABI version for input and output
366 set_abiversion(int ver);
369 ppc64_local_entry_offset(const Symbol* sym) const
370 { return elfcpp::ppc64_decode_local_entry(sym->nonvis() >> 3); }
373 ppc64_local_entry_offset(unsigned int symndx) const
374 { return elfcpp::ppc64_decode_local_entry(this->st_other_[symndx] >> 5); }
385 // Return index into opd_ent_ array for .opd entry at OFF.
386 // .opd entries are 24 bytes long, but they can be spaced 16 bytes
387 // apart when the language doesn't use the last 8-byte word, the
388 // environment pointer. Thus dividing the entry section offset by
389 // 16 will give an index into opd_ent_ that works for either layout
390 // of .opd. (It leaves some elements of the vector unused when .opd
391 // entries are spaced 24 bytes apart, but we don't know the spacing
392 // until relocations are processed, and in any case it is possible
393 // for an object to have some entries spaced 16 bytes apart and
394 // others 24 bytes apart.)
396 opd_ent_ndx(size_t off) const
399 // For 32-bit the .got2 section shdnx, for 64-bit the .opd section shndx.
400 unsigned int special_;
402 // For 64-bit the .rela.toc and .toc section shdnx.
403 unsigned int relatoc_;
406 // For 64-bit, an array with one entry per 64-bit word in the .toc
407 // section, set if accesses using that word cannot be optimised.
408 std::vector<bool> no_toc_opt_;
410 // For 64-bit, whether this object uses small model relocs to access
412 bool has_small_toc_reloc_;
414 // Set at the start of gc_process_relocs, when we know opd_ent_
415 // vector is valid. The flag could be made atomic and set in
416 // do_read_relocs with memory_order_release and then tested with
417 // memory_order_acquire, potentially resulting in fewer entries in
421 // The first 8-byte word of an OPD entry gives the address of the
422 // entry point of the function. Relocatable object files have a
423 // relocation on this word. The following vector records the
424 // section and offset specified by these relocations.
425 std::vector<Opd_ent> opd_ent_;
427 // References made to this object's .opd section when running
428 // gc_process_relocs for another object, before the opd_ent_ vector
429 // is valid for this object.
430 Access_from access_from_map_;
432 // Whether input section has a 14-bit branch reloc.
433 std::vector<bool> has14_;
435 // The stub table to use for a given input section.
436 std::vector<unsigned int> stub_table_index_;
439 elfcpp::Elf_Word e_flags_;
441 // ELF st_other field for local symbols.
442 std::vector<unsigned char> st_other_;
445 template<int size, bool big_endian>
446 class Powerpc_dynobj : public Sized_dynobj<size, big_endian>
449 typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
451 Powerpc_dynobj(const std::string& name, Input_file* input_file, off_t offset,
452 const typename elfcpp::Ehdr<size, big_endian>& ehdr)
453 : Sized_dynobj<size, big_endian>(name, input_file, offset, ehdr),
454 opd_shndx_(0), opd_ent_(), e_flags_(ehdr.get_e_flags())
456 this->set_abiversion(0);
462 // Call Sized_dynobj::do_read_symbols to read the symbols then
463 // read .opd from a dynamic object, filling in opd_ent_ vector,
465 do_read_symbols(Read_symbols_data*);
467 // The .opd section shndx.
471 return this->opd_shndx_;
474 // The .opd section address.
478 return this->opd_address_;
481 // Init OPD entry arrays.
483 init_opd(size_t opd_size)
485 size_t count = this->opd_ent_ndx(opd_size);
486 this->opd_ent_.resize(count);
489 // Return section and offset of function entry for .opd + R_OFF.
491 get_opd_ent(Address r_off, Address* value = NULL) const
493 size_t ndx = this->opd_ent_ndx(r_off);
494 gold_assert(ndx < this->opd_ent_.size());
495 gold_assert(this->opd_ent_[ndx].shndx != 0);
497 *value = this->opd_ent_[ndx].off;
498 return this->opd_ent_[ndx].shndx;
501 // Set section and offset of function entry for .opd + R_OFF.
503 set_opd_ent(Address r_off, unsigned int shndx, Address value)
505 size_t ndx = this->opd_ent_ndx(r_off);
506 gold_assert(ndx < this->opd_ent_.size());
507 this->opd_ent_[ndx].shndx = shndx;
508 this->opd_ent_[ndx].off = value;
513 { return this->e_flags_ & elfcpp::EF_PPC64_ABI; }
515 // Set ABI version for input and output.
517 set_abiversion(int ver);
520 // Used to specify extent of executable sections.
523 Sec_info(Address start_, Address len_, unsigned int shndx_)
524 : start(start_), len(len_), shndx(shndx_)
528 operator<(const Sec_info& that) const
529 { return this->start < that.start; }
542 // Return index into opd_ent_ array for .opd entry at OFF.
544 opd_ent_ndx(size_t off) const
547 // For 64-bit the .opd section shndx and address.
548 unsigned int opd_shndx_;
549 Address opd_address_;
551 // The first 8-byte word of an OPD entry gives the address of the
552 // entry point of the function. Records the section and offset
553 // corresponding to the address. Note that in dynamic objects,
554 // offset is *not* relative to the section.
555 std::vector<Opd_ent> opd_ent_;
558 elfcpp::Elf_Word e_flags_;
561 // Powerpc_copy_relocs class. Needed to peek at dynamic relocs the
562 // base class will emit.
564 template<int sh_type, int size, bool big_endian>
565 class Powerpc_copy_relocs : public Copy_relocs<sh_type, size, big_endian>
568 Powerpc_copy_relocs()
569 : Copy_relocs<sh_type, size, big_endian>(elfcpp::R_POWERPC_COPY)
572 // Emit any saved relocations which turn out to be needed. This is
573 // called after all the relocs have been scanned.
575 emit(Output_data_reloc<sh_type, true, size, big_endian>*);
578 template<int size, bool big_endian>
579 class Target_powerpc : public Sized_target<size, big_endian>
583 Output_data_reloc<elfcpp::SHT_RELA, true, size, big_endian> Reloc_section;
584 typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
585 typedef typename elfcpp::Elf_types<size>::Elf_Swxword Signed_address;
586 static const Address invalid_address = static_cast<Address>(0) - 1;
587 // Offset of tp and dtp pointers from start of TLS block.
588 static const Address tp_offset = 0x7000;
589 static const Address dtp_offset = 0x8000;
592 : Sized_target<size, big_endian>(&powerpc_info),
593 got_(NULL), plt_(NULL), iplt_(NULL), brlt_section_(NULL),
594 glink_(NULL), rela_dyn_(NULL), copy_relocs_(),
595 tlsld_got_offset_(-1U),
596 stub_tables_(), branch_lookup_table_(), branch_info_(),
597 plt_thread_safe_(false), relax_failed_(false), relax_fail_count_(0),
598 stub_group_size_(0), savres_section_(0)
602 // Process the relocations to determine unreferenced sections for
603 // garbage collection.
605 gc_process_relocs(Symbol_table* symtab,
607 Sized_relobj_file<size, big_endian>* object,
608 unsigned int data_shndx,
609 unsigned int sh_type,
610 const unsigned char* prelocs,
612 Output_section* output_section,
613 bool needs_special_offset_handling,
614 size_t local_symbol_count,
615 const unsigned char* plocal_symbols);
617 // Scan the relocations to look for symbol adjustments.
619 scan_relocs(Symbol_table* symtab,
621 Sized_relobj_file<size, big_endian>* object,
622 unsigned int data_shndx,
623 unsigned int sh_type,
624 const unsigned char* prelocs,
626 Output_section* output_section,
627 bool needs_special_offset_handling,
628 size_t local_symbol_count,
629 const unsigned char* plocal_symbols);
631 // Map input .toc section to output .got section.
633 do_output_section_name(const Relobj*, const char* name, size_t* plen) const
635 if (size == 64 && strcmp(name, ".toc") == 0)
643 // Provide linker defined save/restore functions.
645 define_save_restore_funcs(Layout*, Symbol_table*);
647 // No stubs unless a final link.
650 { return !parameters->options().relocatable(); }
653 do_relax(int, const Input_objects*, Symbol_table*, Layout*, const Task*);
656 do_plt_fde_location(const Output_data*, unsigned char*,
657 uint64_t*, off_t*) const;
659 // Stash info about branches, for stub generation.
661 push_branch(Powerpc_relobj<size, big_endian>* ppc_object,
662 unsigned int data_shndx, Address r_offset,
663 unsigned int r_type, unsigned int r_sym, Address addend)
665 Branch_info info(ppc_object, data_shndx, r_offset, r_type, r_sym, addend);
666 this->branch_info_.push_back(info);
667 if (r_type == elfcpp::R_POWERPC_REL14
668 || r_type == elfcpp::R_POWERPC_REL14_BRTAKEN
669 || r_type == elfcpp::R_POWERPC_REL14_BRNTAKEN)
670 ppc_object->set_has_14bit_branch(data_shndx);
674 do_define_standard_symbols(Symbol_table*, Layout*);
676 // Finalize the sections.
678 do_finalize_sections(Layout*, const Input_objects*, Symbol_table*);
680 // Return the value to use for a dynamic which requires special
683 do_dynsym_value(const Symbol*) const;
685 // Return the PLT address to use for a local symbol.
687 do_plt_address_for_local(const Relobj*, unsigned int) const;
689 // Return the PLT address to use for a global symbol.
691 do_plt_address_for_global(const Symbol*) const;
693 // Return the offset to use for the GOT_INDX'th got entry which is
694 // for a local tls symbol specified by OBJECT, SYMNDX.
696 do_tls_offset_for_local(const Relobj* object,
698 unsigned int got_indx) const;
700 // Return the offset to use for the GOT_INDX'th got entry which is
701 // for global tls symbol GSYM.
703 do_tls_offset_for_global(Symbol* gsym, unsigned int got_indx) const;
706 do_function_location(Symbol_location*) const;
709 do_can_check_for_function_pointers() const
712 // Adjust -fsplit-stack code which calls non-split-stack code.
714 do_calls_non_split(Relobj* object, unsigned int shndx,
715 section_offset_type fnoffset, section_size_type fnsize,
716 const unsigned char* prelocs, size_t reloc_count,
717 unsigned char* view, section_size_type view_size,
718 std::string* from, std::string* to) const;
720 // Relocate a section.
722 relocate_section(const Relocate_info<size, big_endian>*,
723 unsigned int sh_type,
724 const unsigned char* prelocs,
726 Output_section* output_section,
727 bool needs_special_offset_handling,
729 Address view_address,
730 section_size_type view_size,
731 const Reloc_symbol_changes*);
733 // Scan the relocs during a relocatable link.
735 scan_relocatable_relocs(Symbol_table* symtab,
737 Sized_relobj_file<size, big_endian>* object,
738 unsigned int data_shndx,
739 unsigned int sh_type,
740 const unsigned char* prelocs,
742 Output_section* output_section,
743 bool needs_special_offset_handling,
744 size_t local_symbol_count,
745 const unsigned char* plocal_symbols,
746 Relocatable_relocs*);
748 // Scan the relocs for --emit-relocs.
750 emit_relocs_scan(Symbol_table* symtab,
752 Sized_relobj_file<size, big_endian>* object,
753 unsigned int data_shndx,
754 unsigned int sh_type,
755 const unsigned char* prelocs,
757 Output_section* output_section,
758 bool needs_special_offset_handling,
759 size_t local_symbol_count,
760 const unsigned char* plocal_syms,
761 Relocatable_relocs* rr);
763 // Emit relocations for a section.
765 relocate_relocs(const Relocate_info<size, big_endian>*,
766 unsigned int sh_type,
767 const unsigned char* prelocs,
769 Output_section* output_section,
770 typename elfcpp::Elf_types<size>::Elf_Off
771 offset_in_output_section,
773 Address view_address,
775 unsigned char* reloc_view,
776 section_size_type reloc_view_size);
778 // Return whether SYM is defined by the ABI.
780 do_is_defined_by_abi(const Symbol* sym) const
782 return strcmp(sym->name(), "__tls_get_addr") == 0;
785 // Return the size of the GOT section.
789 gold_assert(this->got_ != NULL);
790 return this->got_->data_size();
793 // Get the PLT section.
794 const Output_data_plt_powerpc<size, big_endian>*
797 gold_assert(this->plt_ != NULL);
801 // Get the IPLT section.
802 const Output_data_plt_powerpc<size, big_endian>*
805 gold_assert(this->iplt_ != NULL);
809 // Get the .glink section.
810 const Output_data_glink<size, big_endian>*
811 glink_section() const
813 gold_assert(this->glink_ != NULL);
817 Output_data_glink<size, big_endian>*
820 gold_assert(this->glink_ != NULL);
824 bool has_glink() const
825 { return this->glink_ != NULL; }
827 // Get the GOT section.
828 const Output_data_got_powerpc<size, big_endian>*
831 gold_assert(this->got_ != NULL);
835 // Get the GOT section, creating it if necessary.
836 Output_data_got_powerpc<size, big_endian>*
837 got_section(Symbol_table*, Layout*);
840 do_make_elf_object(const std::string&, Input_file*, off_t,
841 const elfcpp::Ehdr<size, big_endian>&);
843 // Return the number of entries in the GOT.
845 got_entry_count() const
847 if (this->got_ == NULL)
849 return this->got_size() / (size / 8);
852 // Return the number of entries in the PLT.
854 plt_entry_count() const;
856 // Return the offset of the first non-reserved PLT entry.
858 first_plt_entry_offset() const
862 if (this->abiversion() >= 2)
867 // Return the size of each PLT entry.
869 plt_entry_size() const
873 if (this->abiversion() >= 2)
878 Output_data_save_res<size, big_endian>*
879 savres_section() const
881 return this->savres_section_;
884 // Add any special sections for this symbol to the gc work list.
885 // For powerpc64, this adds the code section of a function
888 do_gc_mark_symbol(Symbol_table* symtab, Symbol* sym) const;
890 // Handle target specific gc actions when adding a gc reference from
891 // SRC_OBJ, SRC_SHNDX to a location specified by DST_OBJ, DST_SHNDX
892 // and DST_OFF. For powerpc64, this adds a referenc to the code
893 // section of a function descriptor.
895 do_gc_add_reference(Symbol_table* symtab,
897 unsigned int src_shndx,
899 unsigned int dst_shndx,
900 Address dst_off) const;
902 typedef std::vector<Stub_table<size, big_endian>*> Stub_tables;
905 { return this->stub_tables_; }
907 const Output_data_brlt_powerpc<size, big_endian>*
909 { return this->brlt_section_; }
912 add_branch_lookup_table(Address to)
914 unsigned int off = this->branch_lookup_table_.size() * (size / 8);
915 this->branch_lookup_table_.insert(std::make_pair(to, off));
919 find_branch_lookup_table(Address to)
921 typename Branch_lookup_table::const_iterator p
922 = this->branch_lookup_table_.find(to);
923 return p == this->branch_lookup_table_.end() ? invalid_address : p->second;
927 write_branch_lookup_table(unsigned char *oview)
929 for (typename Branch_lookup_table::const_iterator p
930 = this->branch_lookup_table_.begin();
931 p != this->branch_lookup_table_.end();
934 elfcpp::Swap<size, big_endian>::writeval(oview + p->second, p->first);
939 plt_thread_safe() const
940 { return this->plt_thread_safe_; }
944 { return this->processor_specific_flags() & elfcpp::EF_PPC64_ABI; }
947 set_abiversion (int ver)
949 elfcpp::Elf_Word flags = this->processor_specific_flags();
950 flags &= ~elfcpp::EF_PPC64_ABI;
951 flags |= ver & elfcpp::EF_PPC64_ABI;
952 this->set_processor_specific_flags(flags);
955 // Offset to to save stack slot
958 { return this->abiversion() < 2 ? 40 : 24; }
974 : tls_get_addr_(NOT_EXPECTED),
975 relinfo_(NULL), relnum_(0), r_offset_(0)
980 if (this->tls_get_addr_ != NOT_EXPECTED)
987 if (this->relinfo_ != NULL)
988 gold_error_at_location(this->relinfo_, this->relnum_, this->r_offset_,
989 _("missing expected __tls_get_addr call"));
993 expect_tls_get_addr_call(
994 const Relocate_info<size, big_endian>* relinfo,
998 this->tls_get_addr_ = EXPECTED;
999 this->relinfo_ = relinfo;
1000 this->relnum_ = relnum;
1001 this->r_offset_ = r_offset;
1005 expect_tls_get_addr_call()
1006 { this->tls_get_addr_ = EXPECTED; }
1009 skip_next_tls_get_addr_call()
1010 {this->tls_get_addr_ = SKIP; }
1013 maybe_skip_tls_get_addr_call(unsigned int r_type, const Symbol* gsym)
1015 bool is_tls_call = ((r_type == elfcpp::R_POWERPC_REL24
1016 || r_type == elfcpp::R_PPC_PLTREL24)
1018 && strcmp(gsym->name(), "__tls_get_addr") == 0);
1019 Tls_get_addr last_tls = this->tls_get_addr_;
1020 this->tls_get_addr_ = NOT_EXPECTED;
1021 if (is_tls_call && last_tls != EXPECTED)
1023 else if (!is_tls_call && last_tls != NOT_EXPECTED)
1032 // What we're up to regarding calls to __tls_get_addr.
1033 // On powerpc, the branch and link insn making a call to
1034 // __tls_get_addr is marked with a relocation, R_PPC64_TLSGD,
1035 // R_PPC64_TLSLD, R_PPC_TLSGD or R_PPC_TLSLD, in addition to the
1036 // usual R_POWERPC_REL24 or R_PPC_PLTREL25 relocation on a call.
1037 // The marker relocation always comes first, and has the same
1038 // symbol as the reloc on the insn setting up the __tls_get_addr
1039 // argument. This ties the arg setup insn with the call insn,
1040 // allowing ld to safely optimize away the call. We check that
1041 // every call to __tls_get_addr has a marker relocation, and that
1042 // every marker relocation is on a call to __tls_get_addr.
1043 Tls_get_addr tls_get_addr_;
1044 // Info about the last reloc for error message.
1045 const Relocate_info<size, big_endian>* relinfo_;
1050 // The class which scans relocations.
1051 class Scan : protected Track_tls
1054 typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
1057 : Track_tls(), issued_non_pic_error_(false)
1061 get_reference_flags(unsigned int r_type, const Target_powerpc* target);
1064 local(Symbol_table* symtab, Layout* layout, Target_powerpc* target,
1065 Sized_relobj_file<size, big_endian>* object,
1066 unsigned int data_shndx,
1067 Output_section* output_section,
1068 const elfcpp::Rela<size, big_endian>& reloc, unsigned int r_type,
1069 const elfcpp::Sym<size, big_endian>& lsym,
1073 global(Symbol_table* symtab, Layout* layout, Target_powerpc* target,
1074 Sized_relobj_file<size, big_endian>* object,
1075 unsigned int data_shndx,
1076 Output_section* output_section,
1077 const elfcpp::Rela<size, big_endian>& reloc, unsigned int r_type,
1081 local_reloc_may_be_function_pointer(Symbol_table* , Layout* ,
1083 Sized_relobj_file<size, big_endian>* relobj,
1086 const elfcpp::Rela<size, big_endian>& ,
1087 unsigned int r_type,
1088 const elfcpp::Sym<size, big_endian>&)
1090 // PowerPC64 .opd is not folded, so any identical function text
1091 // may be folded and we'll still keep function addresses distinct.
1092 // That means no reloc is of concern here.
1095 Powerpc_relobj<size, big_endian>* ppcobj = static_cast
1096 <Powerpc_relobj<size, big_endian>*>(relobj);
1097 if (ppcobj->abiversion() == 1)
1100 // For 32-bit and ELFv2, conservatively assume anything but calls to
1101 // function code might be taking the address of the function.
1102 return !is_branch_reloc(r_type);
1106 global_reloc_may_be_function_pointer(Symbol_table* , Layout* ,
1108 Sized_relobj_file<size, big_endian>* relobj,
1111 const elfcpp::Rela<size, big_endian>& ,
1112 unsigned int r_type,
1118 Powerpc_relobj<size, big_endian>* ppcobj = static_cast
1119 <Powerpc_relobj<size, big_endian>*>(relobj);
1120 if (ppcobj->abiversion() == 1)
1123 return !is_branch_reloc(r_type);
1127 reloc_needs_plt_for_ifunc(Target_powerpc<size, big_endian>* target,
1128 Sized_relobj_file<size, big_endian>* object,
1129 unsigned int r_type, bool report_err);
1133 unsupported_reloc_local(Sized_relobj_file<size, big_endian>*,
1134 unsigned int r_type);
1137 unsupported_reloc_global(Sized_relobj_file<size, big_endian>*,
1138 unsigned int r_type, Symbol*);
1141 generate_tls_call(Symbol_table* symtab, Layout* layout,
1142 Target_powerpc* target);
1145 check_non_pic(Relobj*, unsigned int r_type);
1147 // Whether we have issued an error about a non-PIC compilation.
1148 bool issued_non_pic_error_;
1152 symval_for_branch(const Symbol_table* symtab,
1153 const Sized_symbol<size>* gsym,
1154 Powerpc_relobj<size, big_endian>* object,
1155 Address *value, unsigned int *dest_shndx);
1157 // The class which implements relocation.
1158 class Relocate : protected Track_tls
1161 // Use 'at' branch hints when true, 'y' when false.
1162 // FIXME maybe: set this with an option.
1163 static const bool is_isa_v2 = true;
1169 // Do a relocation. Return false if the caller should not issue
1170 // any warnings about this relocation.
1172 relocate(const Relocate_info<size, big_endian>*, unsigned int,
1173 Target_powerpc*, Output_section*, size_t, const unsigned char*,
1174 const Sized_symbol<size>*, const Symbol_value<size>*,
1175 unsigned char*, typename elfcpp::Elf_types<size>::Elf_Addr,
1179 class Relocate_comdat_behavior
1182 // Decide what the linker should do for relocations that refer to
1183 // discarded comdat sections.
1184 inline Comdat_behavior
1185 get(const char* name)
1187 gold::Default_comdat_behavior default_behavior;
1188 Comdat_behavior ret = default_behavior.get(name);
1189 if (ret == CB_WARNING)
1192 && (strcmp(name, ".fixup") == 0
1193 || strcmp(name, ".got2") == 0))
1196 && (strcmp(name, ".opd") == 0
1197 || strcmp(name, ".toc") == 0
1198 || strcmp(name, ".toc1") == 0))
1205 // Optimize the TLS relocation type based on what we know about the
1206 // symbol. IS_FINAL is true if the final address of this symbol is
1207 // known at link time.
1209 tls::Tls_optimization
1210 optimize_tls_gd(bool is_final)
1212 // If we are generating a shared library, then we can't do anything
1214 if (parameters->options().shared())
1215 return tls::TLSOPT_NONE;
1218 return tls::TLSOPT_TO_IE;
1219 return tls::TLSOPT_TO_LE;
1222 tls::Tls_optimization
1225 if (parameters->options().shared())
1226 return tls::TLSOPT_NONE;
1228 return tls::TLSOPT_TO_LE;
1231 tls::Tls_optimization
1232 optimize_tls_ie(bool is_final)
1234 if (!is_final || parameters->options().shared())
1235 return tls::TLSOPT_NONE;
1237 return tls::TLSOPT_TO_LE;
1242 make_glink_section(Layout*);
1244 // Create the PLT section.
1246 make_plt_section(Symbol_table*, Layout*);
1249 make_iplt_section(Symbol_table*, Layout*);
1252 make_brlt_section(Layout*);
1254 // Create a PLT entry for a global symbol.
1256 make_plt_entry(Symbol_table*, Layout*, Symbol*);
1258 // Create a PLT entry for a local IFUNC symbol.
1260 make_local_ifunc_plt_entry(Symbol_table*, Layout*,
1261 Sized_relobj_file<size, big_endian>*,
1265 // Create a GOT entry for local dynamic __tls_get_addr.
1267 tlsld_got_offset(Symbol_table* symtab, Layout* layout,
1268 Sized_relobj_file<size, big_endian>* object);
1271 tlsld_got_offset() const
1273 return this->tlsld_got_offset_;
1276 // Get the dynamic reloc section, creating it if necessary.
1278 rela_dyn_section(Layout*);
1280 // Similarly, but for ifunc symbols get the one for ifunc.
1282 rela_dyn_section(Symbol_table*, Layout*, bool for_ifunc);
1284 // Copy a relocation against a global symbol.
1286 copy_reloc(Symbol_table* symtab, Layout* layout,
1287 Sized_relobj_file<size, big_endian>* object,
1288 unsigned int shndx, Output_section* output_section,
1289 Symbol* sym, const elfcpp::Rela<size, big_endian>& reloc)
1291 unsigned int r_type = elfcpp::elf_r_type<size>(reloc.get_r_info());
1292 this->copy_relocs_.copy_reloc(symtab, layout,
1293 symtab->get_sized_symbol<size>(sym),
1294 object, shndx, output_section,
1295 r_type, reloc.get_r_offset(),
1296 reloc.get_r_addend(),
1297 this->rela_dyn_section(layout));
1300 // Look over all the input sections, deciding where to place stubs.
1302 group_sections(Layout*, const Task*, bool);
1304 // Sort output sections by address.
1305 struct Sort_sections
1308 operator()(const Output_section* sec1, const Output_section* sec2)
1309 { return sec1->address() < sec2->address(); }
1315 Branch_info(Powerpc_relobj<size, big_endian>* ppc_object,
1316 unsigned int data_shndx,
1318 unsigned int r_type,
1321 : object_(ppc_object), shndx_(data_shndx), offset_(r_offset),
1322 r_type_(r_type), r_sym_(r_sym), addend_(addend)
1328 // If this branch needs a plt call stub, or a long branch stub, make one.
1330 make_stub(Stub_table<size, big_endian>*,
1331 Stub_table<size, big_endian>*,
1332 Symbol_table*) const;
1335 // The branch location..
1336 Powerpc_relobj<size, big_endian>* object_;
1337 unsigned int shndx_;
1339 // ..and the branch type and destination.
1340 unsigned int r_type_;
1341 unsigned int r_sym_;
1345 // Information about this specific target which we pass to the
1346 // general Target structure.
1347 static Target::Target_info powerpc_info;
1349 // The types of GOT entries needed for this platform.
1350 // These values are exposed to the ABI in an incremental link.
1351 // Do not renumber existing values without changing the version
1352 // number of the .gnu_incremental_inputs section.
1356 GOT_TYPE_TLSGD, // double entry for @got@tlsgd
1357 GOT_TYPE_DTPREL, // entry for @got@dtprel
1358 GOT_TYPE_TPREL // entry for @got@tprel
1362 Output_data_got_powerpc<size, big_endian>* got_;
1363 // The PLT section. This is a container for a table of addresses,
1364 // and their relocations. Each address in the PLT has a dynamic
1365 // relocation (R_*_JMP_SLOT) and each address will have a
1366 // corresponding entry in .glink for lazy resolution of the PLT.
1367 // ppc32 initialises the PLT to point at the .glink entry, while
1368 // ppc64 leaves this to ld.so. To make a call via the PLT, the
1369 // linker adds a stub that loads the PLT entry into ctr then
1370 // branches to ctr. There may be more than one stub for each PLT
1371 // entry. DT_JMPREL points at the first PLT dynamic relocation and
1372 // DT_PLTRELSZ gives the total size of PLT dynamic relocations.
1373 Output_data_plt_powerpc<size, big_endian>* plt_;
1374 // The IPLT section. Like plt_, this is a container for a table of
1375 // addresses and their relocations, specifically for STT_GNU_IFUNC
1376 // functions that resolve locally (STT_GNU_IFUNC functions that
1377 // don't resolve locally go in PLT). Unlike plt_, these have no
1378 // entry in .glink for lazy resolution, and the relocation section
1379 // does not have a 1-1 correspondence with IPLT addresses. In fact,
1380 // the relocation section may contain relocations against
1381 // STT_GNU_IFUNC symbols at locations outside of IPLT. The
1382 // relocation section will appear at the end of other dynamic
1383 // relocations, so that ld.so applies these relocations after other
1384 // dynamic relocations. In a static executable, the relocation
1385 // section is emitted and marked with __rela_iplt_start and
1386 // __rela_iplt_end symbols.
1387 Output_data_plt_powerpc<size, big_endian>* iplt_;
1388 // Section holding long branch destinations.
1389 Output_data_brlt_powerpc<size, big_endian>* brlt_section_;
1390 // The .glink section.
1391 Output_data_glink<size, big_endian>* glink_;
1392 // The dynamic reloc section.
1393 Reloc_section* rela_dyn_;
1394 // Relocs saved to avoid a COPY reloc.
1395 Powerpc_copy_relocs<elfcpp::SHT_RELA, size, big_endian> copy_relocs_;
1396 // Offset of the GOT entry for local dynamic __tls_get_addr calls.
1397 unsigned int tlsld_got_offset_;
1399 Stub_tables stub_tables_;
1400 typedef Unordered_map<Address, unsigned int> Branch_lookup_table;
1401 Branch_lookup_table branch_lookup_table_;
1403 typedef std::vector<Branch_info> Branches;
1404 Branches branch_info_;
1406 bool plt_thread_safe_;
1409 int relax_fail_count_;
1410 int32_t stub_group_size_;
1412 Output_data_save_res<size, big_endian> *savres_section_;
1416 Target::Target_info Target_powerpc<32, true>::powerpc_info =
1419 true, // is_big_endian
1420 elfcpp::EM_PPC, // machine_code
1421 false, // has_make_symbol
1422 false, // has_resolve
1423 false, // has_code_fill
1424 true, // is_default_stack_executable
1425 false, // can_icf_inline_merge_sections
1427 "/usr/lib/ld.so.1", // dynamic_linker
1428 0x10000000, // default_text_segment_address
1429 64 * 1024, // abi_pagesize (overridable by -z max-page-size)
1430 4 * 1024, // common_pagesize (overridable by -z common-page-size)
1431 false, // isolate_execinstr
1433 elfcpp::SHN_UNDEF, // small_common_shndx
1434 elfcpp::SHN_UNDEF, // large_common_shndx
1435 0, // small_common_section_flags
1436 0, // large_common_section_flags
1437 NULL, // attributes_section
1438 NULL, // attributes_vendor
1439 "_start", // entry_symbol_name
1440 32, // hash_entry_size
1444 Target::Target_info Target_powerpc<32, false>::powerpc_info =
1447 false, // is_big_endian
1448 elfcpp::EM_PPC, // machine_code
1449 false, // has_make_symbol
1450 false, // has_resolve
1451 false, // has_code_fill
1452 true, // is_default_stack_executable
1453 false, // can_icf_inline_merge_sections
1455 "/usr/lib/ld.so.1", // dynamic_linker
1456 0x10000000, // default_text_segment_address
1457 64 * 1024, // abi_pagesize (overridable by -z max-page-size)
1458 4 * 1024, // common_pagesize (overridable by -z common-page-size)
1459 false, // isolate_execinstr
1461 elfcpp::SHN_UNDEF, // small_common_shndx
1462 elfcpp::SHN_UNDEF, // large_common_shndx
1463 0, // small_common_section_flags
1464 0, // large_common_section_flags
1465 NULL, // attributes_section
1466 NULL, // attributes_vendor
1467 "_start", // entry_symbol_name
1468 32, // hash_entry_size
1472 Target::Target_info Target_powerpc<64, true>::powerpc_info =
1475 true, // is_big_endian
1476 elfcpp::EM_PPC64, // machine_code
1477 false, // has_make_symbol
1478 false, // has_resolve
1479 false, // has_code_fill
1480 true, // is_default_stack_executable
1481 false, // can_icf_inline_merge_sections
1483 "/usr/lib/ld.so.1", // dynamic_linker
1484 0x10000000, // default_text_segment_address
1485 64 * 1024, // abi_pagesize (overridable by -z max-page-size)
1486 4 * 1024, // common_pagesize (overridable by -z common-page-size)
1487 false, // isolate_execinstr
1489 elfcpp::SHN_UNDEF, // small_common_shndx
1490 elfcpp::SHN_UNDEF, // large_common_shndx
1491 0, // small_common_section_flags
1492 0, // large_common_section_flags
1493 NULL, // attributes_section
1494 NULL, // attributes_vendor
1495 "_start", // entry_symbol_name
1496 32, // hash_entry_size
1500 Target::Target_info Target_powerpc<64, false>::powerpc_info =
1503 false, // is_big_endian
1504 elfcpp::EM_PPC64, // machine_code
1505 false, // has_make_symbol
1506 false, // has_resolve
1507 false, // has_code_fill
1508 true, // is_default_stack_executable
1509 false, // can_icf_inline_merge_sections
1511 "/usr/lib/ld.so.1", // dynamic_linker
1512 0x10000000, // default_text_segment_address
1513 64 * 1024, // abi_pagesize (overridable by -z max-page-size)
1514 4 * 1024, // common_pagesize (overridable by -z common-page-size)
1515 false, // isolate_execinstr
1517 elfcpp::SHN_UNDEF, // small_common_shndx
1518 elfcpp::SHN_UNDEF, // large_common_shndx
1519 0, // small_common_section_flags
1520 0, // large_common_section_flags
1521 NULL, // attributes_section
1522 NULL, // attributes_vendor
1523 "_start", // entry_symbol_name
1524 32, // hash_entry_size
1528 is_branch_reloc(unsigned int r_type)
1530 return (r_type == elfcpp::R_POWERPC_REL24
1531 || r_type == elfcpp::R_PPC_PLTREL24
1532 || r_type == elfcpp::R_PPC_LOCAL24PC
1533 || r_type == elfcpp::R_POWERPC_REL14
1534 || r_type == elfcpp::R_POWERPC_REL14_BRTAKEN
1535 || r_type == elfcpp::R_POWERPC_REL14_BRNTAKEN
1536 || r_type == elfcpp::R_POWERPC_ADDR24
1537 || r_type == elfcpp::R_POWERPC_ADDR14
1538 || r_type == elfcpp::R_POWERPC_ADDR14_BRTAKEN
1539 || r_type == elfcpp::R_POWERPC_ADDR14_BRNTAKEN);
1542 // If INSN is an opcode that may be used with an @tls operand, return
1543 // the transformed insn for TLS optimisation, otherwise return 0. If
1544 // REG is non-zero only match an insn with RB or RA equal to REG.
1546 at_tls_transform(uint32_t insn, unsigned int reg)
1548 if ((insn & (0x3f << 26)) != 31 << 26)
1552 if (reg == 0 || ((insn >> 11) & 0x1f) == reg)
1553 rtra = insn & ((1 << 26) - (1 << 16));
1554 else if (((insn >> 16) & 0x1f) == reg)
1555 rtra = (insn & (0x1f << 21)) | ((insn & (0x1f << 11)) << 5);
1559 if ((insn & (0x3ff << 1)) == 266 << 1)
1562 else if ((insn & (0x1f << 1)) == 23 << 1
1563 && ((insn & (0x1f << 6)) < 14 << 6
1564 || ((insn & (0x1f << 6)) >= 16 << 6
1565 && (insn & (0x1f << 6)) < 24 << 6)))
1566 // load and store indexed -> dform
1567 insn = (32 | ((insn >> 6) & 0x1f)) << 26;
1568 else if ((insn & (((0x1a << 5) | 0x1f) << 1)) == 21 << 1)
1569 // ldx, ldux, stdx, stdux -> ld, ldu, std, stdu
1570 insn = ((58 | ((insn >> 6) & 4)) << 26) | ((insn >> 6) & 1);
1571 else if ((insn & (((0x1f << 5) | 0x1f) << 1)) == 341 << 1)
1573 insn = (58 << 26) | 2;
1581 template<int size, bool big_endian>
1582 class Powerpc_relocate_functions
1602 typedef Powerpc_relocate_functions<size, big_endian> This;
1603 typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
1604 typedef typename elfcpp::Elf_types<size>::Elf_Swxword SignedAddress;
1606 template<int valsize>
1608 has_overflow_signed(Address value)
1610 // limit = 1 << (valsize - 1) without shift count exceeding size of type
1611 Address limit = static_cast<Address>(1) << ((valsize - 1) >> 1);
1612 limit <<= ((valsize - 1) >> 1);
1613 limit <<= ((valsize - 1) - 2 * ((valsize - 1) >> 1));
1614 return value + limit > (limit << 1) - 1;
1617 template<int valsize>
1619 has_overflow_unsigned(Address value)
1621 Address limit = static_cast<Address>(1) << ((valsize - 1) >> 1);
1622 limit <<= ((valsize - 1) >> 1);
1623 limit <<= ((valsize - 1) - 2 * ((valsize - 1) >> 1));
1624 return value > (limit << 1) - 1;
1627 template<int valsize>
1629 has_overflow_bitfield(Address value)
1631 return (has_overflow_unsigned<valsize>(value)
1632 && has_overflow_signed<valsize>(value));
1635 template<int valsize>
1636 static inline Status
1637 overflowed(Address value, Overflow_check overflow)
1639 if (overflow == CHECK_SIGNED)
1641 if (has_overflow_signed<valsize>(value))
1642 return STATUS_OVERFLOW;
1644 else if (overflow == CHECK_UNSIGNED)
1646 if (has_overflow_unsigned<valsize>(value))
1647 return STATUS_OVERFLOW;
1649 else if (overflow == CHECK_BITFIELD)
1651 if (has_overflow_bitfield<valsize>(value))
1652 return STATUS_OVERFLOW;
1657 // Do a simple RELA relocation
1658 template<int fieldsize, int valsize>
1659 static inline Status
1660 rela(unsigned char* view, Address value, Overflow_check overflow)
1662 typedef typename elfcpp::Swap<fieldsize, big_endian>::Valtype Valtype;
1663 Valtype* wv = reinterpret_cast<Valtype*>(view);
1664 elfcpp::Swap<fieldsize, big_endian>::writeval(wv, value);
1665 return overflowed<valsize>(value, overflow);
1668 template<int fieldsize, int valsize>
1669 static inline Status
1670 rela(unsigned char* view,
1671 unsigned int right_shift,
1672 typename elfcpp::Valtype_base<fieldsize>::Valtype dst_mask,
1674 Overflow_check overflow)
1676 typedef typename elfcpp::Swap<fieldsize, big_endian>::Valtype Valtype;
1677 Valtype* wv = reinterpret_cast<Valtype*>(view);
1678 Valtype val = elfcpp::Swap<fieldsize, big_endian>::readval(wv);
1679 Valtype reloc = value >> right_shift;
1682 elfcpp::Swap<fieldsize, big_endian>::writeval(wv, val | reloc);
1683 return overflowed<valsize>(value >> right_shift, overflow);
1686 // Do a simple RELA relocation, unaligned.
1687 template<int fieldsize, int valsize>
1688 static inline Status
1689 rela_ua(unsigned char* view, Address value, Overflow_check overflow)
1691 elfcpp::Swap_unaligned<fieldsize, big_endian>::writeval(view, value);
1692 return overflowed<valsize>(value, overflow);
1695 template<int fieldsize, int valsize>
1696 static inline Status
1697 rela_ua(unsigned char* view,
1698 unsigned int right_shift,
1699 typename elfcpp::Valtype_base<fieldsize>::Valtype dst_mask,
1701 Overflow_check overflow)
1703 typedef typename elfcpp::Swap_unaligned<fieldsize, big_endian>::Valtype
1705 Valtype val = elfcpp::Swap<fieldsize, big_endian>::readval(view);
1706 Valtype reloc = value >> right_shift;
1709 elfcpp::Swap_unaligned<fieldsize, big_endian>::writeval(view, val | reloc);
1710 return overflowed<valsize>(value >> right_shift, overflow);
1714 // R_PPC64_ADDR64: (Symbol + Addend)
1716 addr64(unsigned char* view, Address value)
1717 { This::template rela<64,64>(view, value, CHECK_NONE); }
1719 // R_PPC64_UADDR64: (Symbol + Addend) unaligned
1721 addr64_u(unsigned char* view, Address value)
1722 { This::template rela_ua<64,64>(view, value, CHECK_NONE); }
1724 // R_POWERPC_ADDR32: (Symbol + Addend)
1725 static inline Status
1726 addr32(unsigned char* view, Address value, Overflow_check overflow)
1727 { return This::template rela<32,32>(view, value, overflow); }
1729 // R_POWERPC_UADDR32: (Symbol + Addend) unaligned
1730 static inline Status
1731 addr32_u(unsigned char* view, Address value, Overflow_check overflow)
1732 { return This::template rela_ua<32,32>(view, value, overflow); }
1734 // R_POWERPC_ADDR24: (Symbol + Addend) & 0x3fffffc
1735 static inline Status
1736 addr24(unsigned char* view, Address value, Overflow_check overflow)
1738 Status stat = This::template rela<32,26>(view, 0, 0x03fffffc,
1740 if (overflow != CHECK_NONE && (value & 3) != 0)
1741 stat = STATUS_OVERFLOW;
1745 // R_POWERPC_ADDR16: (Symbol + Addend) & 0xffff
1746 static inline Status
1747 addr16(unsigned char* view, Address value, Overflow_check overflow)
1748 { return This::template rela<16,16>(view, value, overflow); }
1750 // R_POWERPC_ADDR16: (Symbol + Addend) & 0xffff, unaligned
1751 static inline Status
1752 addr16_u(unsigned char* view, Address value, Overflow_check overflow)
1753 { return This::template rela_ua<16,16>(view, value, overflow); }
1755 // R_POWERPC_ADDR16_DS: (Symbol + Addend) & 0xfffc
1756 static inline Status
1757 addr16_ds(unsigned char* view, Address value, Overflow_check overflow)
1759 Status stat = This::template rela<16,16>(view, 0, 0xfffc, value, overflow);
1760 if ((value & 3) != 0)
1761 stat = STATUS_OVERFLOW;
1765 // R_POWERPC_ADDR16_DQ: (Symbol + Addend) & 0xfff0
1766 static inline Status
1767 addr16_dq(unsigned char* view, Address value, Overflow_check overflow)
1769 Status stat = This::template rela<16,16>(view, 0, 0xfff0, value, overflow);
1770 if ((value & 15) != 0)
1771 stat = STATUS_OVERFLOW;
1775 // R_POWERPC_ADDR16_HI: ((Symbol + Addend) >> 16) & 0xffff
1777 addr16_hi(unsigned char* view, Address value)
1778 { This::template rela<16,16>(view, 16, 0xffff, value, CHECK_NONE); }
1780 // R_POWERPC_ADDR16_HA: ((Symbol + Addend + 0x8000) >> 16) & 0xffff
1782 addr16_ha(unsigned char* view, Address value)
1783 { This::addr16_hi(view, value + 0x8000); }
1785 // R_POWERPC_ADDR16_HIGHER: ((Symbol + Addend) >> 32) & 0xffff
1787 addr16_hi2(unsigned char* view, Address value)
1788 { This::template rela<16,16>(view, 32, 0xffff, value, CHECK_NONE); }
1790 // R_POWERPC_ADDR16_HIGHERA: ((Symbol + Addend + 0x8000) >> 32) & 0xffff
1792 addr16_ha2(unsigned char* view, Address value)
1793 { This::addr16_hi2(view, value + 0x8000); }
1795 // R_POWERPC_ADDR16_HIGHEST: ((Symbol + Addend) >> 48) & 0xffff
1797 addr16_hi3(unsigned char* view, Address value)
1798 { This::template rela<16,16>(view, 48, 0xffff, value, CHECK_NONE); }
1800 // R_POWERPC_ADDR16_HIGHESTA: ((Symbol + Addend + 0x8000) >> 48) & 0xffff
1802 addr16_ha3(unsigned char* view, Address value)
1803 { This::addr16_hi3(view, value + 0x8000); }
1805 // R_POWERPC_ADDR14: (Symbol + Addend) & 0xfffc
1806 static inline Status
1807 addr14(unsigned char* view, Address value, Overflow_check overflow)
1809 Status stat = This::template rela<32,16>(view, 0, 0xfffc, value, overflow);
1810 if (overflow != CHECK_NONE && (value & 3) != 0)
1811 stat = STATUS_OVERFLOW;
1815 // R_POWERPC_REL16DX_HA
1816 static inline Status
1817 addr16dx_ha(unsigned char *view, Address value, Overflow_check overflow)
1819 typedef typename elfcpp::Swap<32, big_endian>::Valtype Valtype;
1820 Valtype* wv = reinterpret_cast<Valtype*>(view);
1821 Valtype val = elfcpp::Swap<32, big_endian>::readval(wv);
1823 value = static_cast<SignedAddress>(value) >> 16;
1824 val |= (value & 0xffc1) | ((value & 0x3e) << 15);
1825 elfcpp::Swap<32, big_endian>::writeval(wv, val);
1826 return overflowed<16>(value, overflow);
1830 // Set ABI version for input and output.
1832 template<int size, bool big_endian>
1834 Powerpc_relobj<size, big_endian>::set_abiversion(int ver)
1836 this->e_flags_ |= ver;
1837 if (this->abiversion() != 0)
1839 Target_powerpc<size, big_endian>* target =
1840 static_cast<Target_powerpc<size, big_endian>*>(
1841 parameters->sized_target<size, big_endian>());
1842 if (target->abiversion() == 0)
1843 target->set_abiversion(this->abiversion());
1844 else if (target->abiversion() != this->abiversion())
1845 gold_error(_("%s: ABI version %d is not compatible "
1846 "with ABI version %d output"),
1847 this->name().c_str(),
1848 this->abiversion(), target->abiversion());
1853 // Stash away the index of .got2, .opd, .rela.toc, and .toc in a
1854 // relocatable object, if such sections exists.
1856 template<int size, bool big_endian>
1858 Powerpc_relobj<size, big_endian>::do_find_special_sections(
1859 Read_symbols_data* sd)
1861 const unsigned char* const pshdrs = sd->section_headers->data();
1862 const unsigned char* namesu = sd->section_names->data();
1863 const char* names = reinterpret_cast<const char*>(namesu);
1864 section_size_type names_size = sd->section_names_size;
1865 const unsigned char* s;
1867 s = this->template find_shdr<size, big_endian>(pshdrs,
1868 size == 32 ? ".got2" : ".opd",
1869 names, names_size, NULL);
1872 unsigned int ndx = (s - pshdrs) / elfcpp::Elf_sizes<size>::shdr_size;
1873 this->special_ = ndx;
1876 if (this->abiversion() == 0)
1877 this->set_abiversion(1);
1878 else if (this->abiversion() > 1)
1879 gold_error(_("%s: .opd invalid in abiv%d"),
1880 this->name().c_str(), this->abiversion());
1885 s = this->template find_shdr<size, big_endian>(pshdrs, ".rela.toc",
1886 names, names_size, NULL);
1889 unsigned int ndx = (s - pshdrs) / elfcpp::Elf_sizes<size>::shdr_size;
1890 this->relatoc_ = ndx;
1891 typename elfcpp::Shdr<size, big_endian> shdr(s);
1892 this->toc_ = this->adjust_shndx(shdr.get_sh_info());
1895 return Sized_relobj_file<size, big_endian>::do_find_special_sections(sd);
1898 // Examine .rela.opd to build info about function entry points.
1900 template<int size, bool big_endian>
1902 Powerpc_relobj<size, big_endian>::scan_opd_relocs(
1904 const unsigned char* prelocs,
1905 const unsigned char* plocal_syms)
1909 typedef typename elfcpp::Rela<size, big_endian> Reltype;
1910 const int reloc_size = elfcpp::Elf_sizes<size>::rela_size;
1911 const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
1912 Address expected_off = 0;
1913 bool regular = true;
1914 unsigned int opd_ent_size = 0;
1916 for (size_t i = 0; i < reloc_count; ++i, prelocs += reloc_size)
1918 Reltype reloc(prelocs);
1919 typename elfcpp::Elf_types<size>::Elf_WXword r_info
1920 = reloc.get_r_info();
1921 unsigned int r_type = elfcpp::elf_r_type<size>(r_info);
1922 if (r_type == elfcpp::R_PPC64_ADDR64)
1924 unsigned int r_sym = elfcpp::elf_r_sym<size>(r_info);
1925 typename elfcpp::Elf_types<size>::Elf_Addr value;
1928 if (r_sym < this->local_symbol_count())
1930 typename elfcpp::Sym<size, big_endian>
1931 lsym(plocal_syms + r_sym * sym_size);
1932 shndx = lsym.get_st_shndx();
1933 shndx = this->adjust_sym_shndx(r_sym, shndx, &is_ordinary);
1934 value = lsym.get_st_value();
1937 shndx = this->symbol_section_and_value(r_sym, &value,
1939 this->set_opd_ent(reloc.get_r_offset(), shndx,
1940 value + reloc.get_r_addend());
1943 expected_off = reloc.get_r_offset();
1944 opd_ent_size = expected_off;
1946 else if (expected_off != reloc.get_r_offset())
1948 expected_off += opd_ent_size;
1950 else if (r_type == elfcpp::R_PPC64_TOC)
1952 if (expected_off - opd_ent_size + 8 != reloc.get_r_offset())
1957 gold_warning(_("%s: unexpected reloc type %u in .opd section"),
1958 this->name().c_str(), r_type);
1962 if (reloc_count <= 2)
1963 opd_ent_size = this->section_size(this->opd_shndx());
1964 if (opd_ent_size != 24 && opd_ent_size != 16)
1968 gold_warning(_("%s: .opd is not a regular array of opd entries"),
1969 this->name().c_str());
1975 // Returns true if a code sequence loading the TOC entry at VALUE
1976 // relative to the TOC pointer can be converted into code calculating
1977 // a TOC pointer relative offset.
1978 // If so, the TOC pointer relative offset is stored to VALUE.
1980 template<int size, bool big_endian>
1982 Powerpc_relobj<size, big_endian>::make_toc_relative(
1983 Target_powerpc<size, big_endian>* target,
1989 // Convert VALUE back to an address by adding got_base (see below),
1990 // then to an offset in the TOC by subtracting the TOC output
1991 // section address and the TOC output offset. Since this TOC output
1992 // section and the got output section are one and the same, we can
1993 // omit adding and subtracting the output section address.
1994 Address off = (*value + this->toc_base_offset()
1995 - this->output_section_offset(this->toc_shndx()));
1996 // Is this offset in the TOC? -mcmodel=medium code may be using
1997 // TOC relative access to variables outside the TOC. Those of
1998 // course can't be optimized. We also don't try to optimize code
1999 // that is using a different object's TOC.
2000 if (off >= this->section_size(this->toc_shndx()))
2003 if (this->no_toc_opt(off))
2006 section_size_type vlen;
2007 unsigned char* view = this->get_output_view(this->toc_shndx(), &vlen);
2008 Address addr = elfcpp::Swap<size, big_endian>::readval(view + off);
2010 Address got_base = (target->got_section()->output_section()->address()
2011 + this->toc_base_offset());
2013 if (addr + (uint64_t) 0x80008000 >= (uint64_t) 1 << 32)
2020 // Perform the Sized_relobj_file method, then set up opd info from
2023 template<int size, bool big_endian>
2025 Powerpc_relobj<size, big_endian>::do_read_relocs(Read_relocs_data* rd)
2027 Sized_relobj_file<size, big_endian>::do_read_relocs(rd);
2030 for (Read_relocs_data::Relocs_list::iterator p = rd->relocs.begin();
2031 p != rd->relocs.end();
2034 if (p->data_shndx == this->opd_shndx())
2036 uint64_t opd_size = this->section_size(this->opd_shndx());
2037 gold_assert(opd_size == static_cast<size_t>(opd_size));
2040 this->init_opd(opd_size);
2041 this->scan_opd_relocs(p->reloc_count, p->contents->data(),
2042 rd->local_symbols->data());
2050 // Read the symbols then set up st_other vector.
2052 template<int size, bool big_endian>
2054 Powerpc_relobj<size, big_endian>::do_read_symbols(Read_symbols_data* sd)
2056 this->base_read_symbols(sd);
2059 const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
2060 const unsigned char* const pshdrs = sd->section_headers->data();
2061 const unsigned int loccount = this->do_local_symbol_count();
2064 this->st_other_.resize(loccount);
2065 const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
2066 off_t locsize = loccount * sym_size;
2067 const unsigned int symtab_shndx = this->symtab_shndx();
2068 const unsigned char *psymtab = pshdrs + symtab_shndx * shdr_size;
2069 typename elfcpp::Shdr<size, big_endian> shdr(psymtab);
2070 const unsigned char* psyms = this->get_view(shdr.get_sh_offset(),
2071 locsize, true, false);
2073 for (unsigned int i = 1; i < loccount; ++i, psyms += sym_size)
2075 elfcpp::Sym<size, big_endian> sym(psyms);
2076 unsigned char st_other = sym.get_st_other();
2077 this->st_other_[i] = st_other;
2078 if ((st_other & elfcpp::STO_PPC64_LOCAL_MASK) != 0)
2080 if (this->abiversion() == 0)
2081 this->set_abiversion(2);
2082 else if (this->abiversion() < 2)
2083 gold_error(_("%s: local symbol %d has invalid st_other"
2084 " for ABI version 1"),
2085 this->name().c_str(), i);
2092 template<int size, bool big_endian>
2094 Powerpc_dynobj<size, big_endian>::set_abiversion(int ver)
2096 this->e_flags_ |= ver;
2097 if (this->abiversion() != 0)
2099 Target_powerpc<size, big_endian>* target =
2100 static_cast<Target_powerpc<size, big_endian>*>(
2101 parameters->sized_target<size, big_endian>());
2102 if (target->abiversion() == 0)
2103 target->set_abiversion(this->abiversion());
2104 else if (target->abiversion() != this->abiversion())
2105 gold_error(_("%s: ABI version %d is not compatible "
2106 "with ABI version %d output"),
2107 this->name().c_str(),
2108 this->abiversion(), target->abiversion());
2113 // Call Sized_dynobj::base_read_symbols to read the symbols then
2114 // read .opd from a dynamic object, filling in opd_ent_ vector,
2116 template<int size, bool big_endian>
2118 Powerpc_dynobj<size, big_endian>::do_read_symbols(Read_symbols_data* sd)
2120 this->base_read_symbols(sd);
2123 const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
2124 const unsigned char* const pshdrs = sd->section_headers->data();
2125 const unsigned char* namesu = sd->section_names->data();
2126 const char* names = reinterpret_cast<const char*>(namesu);
2127 const unsigned char* s = NULL;
2128 const unsigned char* opd;
2129 section_size_type opd_size;
2131 // Find and read .opd section.
2134 s = this->template find_shdr<size, big_endian>(pshdrs, ".opd", names,
2135 sd->section_names_size,
2140 typename elfcpp::Shdr<size, big_endian> shdr(s);
2141 if (shdr.get_sh_type() == elfcpp::SHT_PROGBITS
2142 && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC) != 0)
2144 if (this->abiversion() == 0)
2145 this->set_abiversion(1);
2146 else if (this->abiversion() > 1)
2147 gold_error(_("%s: .opd invalid in abiv%d"),
2148 this->name().c_str(), this->abiversion());
2150 this->opd_shndx_ = (s - pshdrs) / shdr_size;
2151 this->opd_address_ = shdr.get_sh_addr();
2152 opd_size = convert_to_section_size_type(shdr.get_sh_size());
2153 opd = this->get_view(shdr.get_sh_offset(), opd_size,
2159 // Build set of executable sections.
2160 // Using a set is probably overkill. There is likely to be only
2161 // a few executable sections, typically .init, .text and .fini,
2162 // and they are generally grouped together.
2163 typedef std::set<Sec_info> Exec_sections;
2164 Exec_sections exec_sections;
2166 for (unsigned int i = 1; i < this->shnum(); ++i, s += shdr_size)
2168 typename elfcpp::Shdr<size, big_endian> shdr(s);
2169 if (shdr.get_sh_type() == elfcpp::SHT_PROGBITS
2170 && ((shdr.get_sh_flags()
2171 & (elfcpp::SHF_ALLOC | elfcpp::SHF_EXECINSTR))
2172 == (elfcpp::SHF_ALLOC | elfcpp::SHF_EXECINSTR))
2173 && shdr.get_sh_size() != 0)
2175 exec_sections.insert(Sec_info(shdr.get_sh_addr(),
2176 shdr.get_sh_size(), i));
2179 if (exec_sections.empty())
2182 // Look over the OPD entries. This is complicated by the fact
2183 // that some binaries will use two-word entries while others
2184 // will use the standard three-word entries. In most cases
2185 // the third word (the environment pointer for languages like
2186 // Pascal) is unused and will be zero. If the third word is
2187 // used it should not be pointing into executable sections,
2189 this->init_opd(opd_size);
2190 for (const unsigned char* p = opd; p < opd + opd_size; p += 8)
2192 typedef typename elfcpp::Swap<64, big_endian>::Valtype Valtype;
2193 const Valtype* valp = reinterpret_cast<const Valtype*>(p);
2194 Valtype val = elfcpp::Swap<64, big_endian>::readval(valp);
2196 // Chances are that this is the third word of an OPD entry.
2198 typename Exec_sections::const_iterator e
2199 = exec_sections.upper_bound(Sec_info(val, 0, 0));
2200 if (e != exec_sections.begin())
2203 if (e->start <= val && val < e->start + e->len)
2205 // We have an address in an executable section.
2206 // VAL ought to be the function entry, set it up.
2207 this->set_opd_ent(p - opd, e->shndx, val);
2208 // Skip second word of OPD entry, the TOC pointer.
2212 // If we didn't match any executable sections, we likely
2213 // have a non-zero third word in the OPD entry.
2218 // Relocate sections.
2220 template<int size, bool big_endian>
2222 Powerpc_relobj<size, big_endian>::do_relocate_sections(
2223 const Symbol_table* symtab, const Layout* layout,
2224 const unsigned char* pshdrs, Output_file* of,
2225 typename Sized_relobj_file<size, big_endian>::Views* pviews)
2227 unsigned int start = 1;
2229 && this->relatoc_ != 0
2230 && !parameters->options().relocatable())
2232 // Relocate .toc first.
2233 this->relocate_section_range(symtab, layout, pshdrs, of, pviews,
2234 this->relatoc_, this->relatoc_);
2235 this->relocate_section_range(symtab, layout, pshdrs, of, pviews,
2236 1, this->relatoc_ - 1);
2237 start = this->relatoc_ + 1;
2239 this->relocate_section_range(symtab, layout, pshdrs, of, pviews,
2240 start, this->shnum() - 1);
2243 // Set up some symbols.
2245 template<int size, bool big_endian>
2247 Target_powerpc<size, big_endian>::do_define_standard_symbols(
2248 Symbol_table* symtab,
2253 // Define _GLOBAL_OFFSET_TABLE_ to ensure it isn't seen as
2254 // undefined when scanning relocs (and thus requires
2255 // non-relative dynamic relocs). The proper value will be
2257 Symbol *gotsym = symtab->lookup("_GLOBAL_OFFSET_TABLE_", NULL);
2258 if (gotsym != NULL && gotsym->is_undefined())
2260 Target_powerpc<size, big_endian>* target =
2261 static_cast<Target_powerpc<size, big_endian>*>(
2262 parameters->sized_target<size, big_endian>());
2263 Output_data_got_powerpc<size, big_endian>* got
2264 = target->got_section(symtab, layout);
2265 symtab->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL,
2266 Symbol_table::PREDEFINED,
2270 elfcpp::STV_HIDDEN, 0,
2274 // Define _SDA_BASE_ at the start of the .sdata section + 32768.
2275 Symbol *sdasym = symtab->lookup("_SDA_BASE_", NULL);
2276 if (sdasym != NULL && sdasym->is_undefined())
2278 Output_data_space* sdata = new Output_data_space(4, "** sdata");
2280 = layout->add_output_section_data(".sdata", 0,
2282 | elfcpp::SHF_WRITE,
2283 sdata, ORDER_SMALL_DATA, false);
2284 symtab->define_in_output_data("_SDA_BASE_", NULL,
2285 Symbol_table::PREDEFINED,
2286 os, 32768, 0, elfcpp::STT_OBJECT,
2287 elfcpp::STB_LOCAL, elfcpp::STV_HIDDEN,
2293 // Define .TOC. as for 32-bit _GLOBAL_OFFSET_TABLE_
2294 Symbol *gotsym = symtab->lookup(".TOC.", NULL);
2295 if (gotsym != NULL && gotsym->is_undefined())
2297 Target_powerpc<size, big_endian>* target =
2298 static_cast<Target_powerpc<size, big_endian>*>(
2299 parameters->sized_target<size, big_endian>());
2300 Output_data_got_powerpc<size, big_endian>* got
2301 = target->got_section(symtab, layout);
2302 symtab->define_in_output_data(".TOC.", NULL,
2303 Symbol_table::PREDEFINED,
2307 elfcpp::STV_HIDDEN, 0,
2313 // Set up PowerPC target specific relobj.
2315 template<int size, bool big_endian>
2317 Target_powerpc<size, big_endian>::do_make_elf_object(
2318 const std::string& name,
2319 Input_file* input_file,
2320 off_t offset, const elfcpp::Ehdr<size, big_endian>& ehdr)
2322 int et = ehdr.get_e_type();
2323 // ET_EXEC files are valid input for --just-symbols/-R,
2324 // and we treat them as relocatable objects.
2325 if (et == elfcpp::ET_REL
2326 || (et == elfcpp::ET_EXEC && input_file->just_symbols()))
2328 Powerpc_relobj<size, big_endian>* obj =
2329 new Powerpc_relobj<size, big_endian>(name, input_file, offset, ehdr);
2333 else if (et == elfcpp::ET_DYN)
2335 Powerpc_dynobj<size, big_endian>* obj =
2336 new Powerpc_dynobj<size, big_endian>(name, input_file, offset, ehdr);
2342 gold_error(_("%s: unsupported ELF file type %d"), name.c_str(), et);
2347 template<int size, bool big_endian>
2348 class Output_data_got_powerpc : public Output_data_got<size, big_endian>
2351 typedef typename elfcpp::Elf_types<size>::Elf_Addr Valtype;
2352 typedef Output_data_reloc<elfcpp::SHT_RELA, true, size, big_endian> Rela_dyn;
2354 Output_data_got_powerpc(Symbol_table* symtab, Layout* layout)
2355 : Output_data_got<size, big_endian>(),
2356 symtab_(symtab), layout_(layout),
2357 header_ent_cnt_(size == 32 ? 3 : 1),
2358 header_index_(size == 32 ? 0x2000 : 0)
2361 this->set_addralign(256);
2364 // Override all the Output_data_got methods we use so as to first call
2367 add_global(Symbol* gsym, unsigned int got_type)
2369 this->reserve_ent();
2370 return Output_data_got<size, big_endian>::add_global(gsym, got_type);
2374 add_global_plt(Symbol* gsym, unsigned int got_type)
2376 this->reserve_ent();
2377 return Output_data_got<size, big_endian>::add_global_plt(gsym, got_type);
2381 add_global_tls(Symbol* gsym, unsigned int got_type)
2382 { return this->add_global_plt(gsym, got_type); }
2385 add_global_with_rel(Symbol* gsym, unsigned int got_type,
2386 Output_data_reloc_generic* rel_dyn, unsigned int r_type)
2388 this->reserve_ent();
2389 Output_data_got<size, big_endian>::
2390 add_global_with_rel(gsym, got_type, rel_dyn, r_type);
2394 add_global_pair_with_rel(Symbol* gsym, unsigned int got_type,
2395 Output_data_reloc_generic* rel_dyn,
2396 unsigned int r_type_1, unsigned int r_type_2)
2398 this->reserve_ent(2);
2399 Output_data_got<size, big_endian>::
2400 add_global_pair_with_rel(gsym, got_type, rel_dyn, r_type_1, r_type_2);
2404 add_local(Relobj* object, unsigned int sym_index, unsigned int got_type)
2406 this->reserve_ent();
2407 return Output_data_got<size, big_endian>::add_local(object, sym_index,
2412 add_local_plt(Relobj* object, unsigned int sym_index, unsigned int got_type)
2414 this->reserve_ent();
2415 return Output_data_got<size, big_endian>::add_local_plt(object, sym_index,
2420 add_local_tls(Relobj* object, unsigned int sym_index, unsigned int got_type)
2421 { return this->add_local_plt(object, sym_index, got_type); }
2424 add_local_tls_pair(Relobj* object, unsigned int sym_index,
2425 unsigned int got_type,
2426 Output_data_reloc_generic* rel_dyn,
2427 unsigned int r_type)
2429 this->reserve_ent(2);
2430 Output_data_got<size, big_endian>::
2431 add_local_tls_pair(object, sym_index, got_type, rel_dyn, r_type);
2435 add_constant(Valtype constant)
2437 this->reserve_ent();
2438 return Output_data_got<size, big_endian>::add_constant(constant);
2442 add_constant_pair(Valtype c1, Valtype c2)
2444 this->reserve_ent(2);
2445 return Output_data_got<size, big_endian>::add_constant_pair(c1, c2);
2448 // Offset of _GLOBAL_OFFSET_TABLE_.
2452 return this->got_offset(this->header_index_);
2455 // Offset of base used to access the GOT/TOC.
2456 // The got/toc pointer reg will be set to this value.
2458 got_base_offset(const Powerpc_relobj<size, big_endian>* object) const
2461 return this->g_o_t();
2463 return (this->output_section()->address()
2464 + object->toc_base_offset()
2468 // Ensure our GOT has a header.
2470 set_final_data_size()
2472 if (this->header_ent_cnt_ != 0)
2473 this->make_header();
2474 Output_data_got<size, big_endian>::set_final_data_size();
2477 // First word of GOT header needs some values that are not
2478 // handled by Output_data_got so poke them in here.
2479 // For 32-bit, address of .dynamic, for 64-bit, address of TOCbase.
2481 do_write(Output_file* of)
2484 if (size == 32 && this->layout_->dynamic_data() != NULL)
2485 val = this->layout_->dynamic_section()->address();
2487 val = this->output_section()->address() + 0x8000;
2488 this->replace_constant(this->header_index_, val);
2489 Output_data_got<size, big_endian>::do_write(of);
2494 reserve_ent(unsigned int cnt = 1)
2496 if (this->header_ent_cnt_ == 0)
2498 if (this->num_entries() + cnt > this->header_index_)
2499 this->make_header();
2505 this->header_ent_cnt_ = 0;
2506 this->header_index_ = this->num_entries();
2509 Output_data_got<size, big_endian>::add_constant(0);
2510 Output_data_got<size, big_endian>::add_constant(0);
2511 Output_data_got<size, big_endian>::add_constant(0);
2513 // Define _GLOBAL_OFFSET_TABLE_ at the header
2514 Symbol *gotsym = this->symtab_->lookup("_GLOBAL_OFFSET_TABLE_", NULL);
2517 Sized_symbol<size>* sym = static_cast<Sized_symbol<size>*>(gotsym);
2518 sym->set_value(this->g_o_t());
2521 this->symtab_->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL,
2522 Symbol_table::PREDEFINED,
2523 this, this->g_o_t(), 0,
2526 elfcpp::STV_HIDDEN, 0,
2530 Output_data_got<size, big_endian>::add_constant(0);
2533 // Stashed pointers.
2534 Symbol_table* symtab_;
2538 unsigned int header_ent_cnt_;
2539 // GOT header index.
2540 unsigned int header_index_;
2543 // Get the GOT section, creating it if necessary.
2545 template<int size, bool big_endian>
2546 Output_data_got_powerpc<size, big_endian>*
2547 Target_powerpc<size, big_endian>::got_section(Symbol_table* symtab,
2550 if (this->got_ == NULL)
2552 gold_assert(symtab != NULL && layout != NULL);
2555 = new Output_data_got_powerpc<size, big_endian>(symtab, layout);
2557 layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS,
2558 elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE,
2559 this->got_, ORDER_DATA, false);
2565 // Get the dynamic reloc section, creating it if necessary.
2567 template<int size, bool big_endian>
2568 typename Target_powerpc<size, big_endian>::Reloc_section*
2569 Target_powerpc<size, big_endian>::rela_dyn_section(Layout* layout)
2571 if (this->rela_dyn_ == NULL)
2573 gold_assert(layout != NULL);
2574 this->rela_dyn_ = new Reloc_section(parameters->options().combreloc());
2575 layout->add_output_section_data(".rela.dyn", elfcpp::SHT_RELA,
2576 elfcpp::SHF_ALLOC, this->rela_dyn_,
2577 ORDER_DYNAMIC_RELOCS, false);
2579 return this->rela_dyn_;
2582 // Similarly, but for ifunc symbols get the one for ifunc.
2584 template<int size, bool big_endian>
2585 typename Target_powerpc<size, big_endian>::Reloc_section*
2586 Target_powerpc<size, big_endian>::rela_dyn_section(Symbol_table* symtab,
2591 return this->rela_dyn_section(layout);
2593 if (this->iplt_ == NULL)
2594 this->make_iplt_section(symtab, layout);
2595 return this->iplt_->rel_plt();
2601 // Determine the stub group size. The group size is the absolute
2602 // value of the parameter --stub-group-size. If --stub-group-size
2603 // is passed a negative value, we restrict stubs to be always after
2604 // the stubbed branches.
2605 Stub_control(int32_t size, bool no_size_errors, bool multi_os)
2606 : stub_group_size_(abs(size)), stubs_always_after_branch_(size < 0),
2607 suppress_size_errors_(no_size_errors), multi_os_(multi_os),
2608 state_(NO_GROUP), group_size_(0), group_start_addr_(0),
2609 owner_(NULL), output_section_(NULL)
2613 // Return true iff input section can be handled by current stub
2616 can_add_to_stub_group(Output_section* o,
2617 const Output_section::Input_section* i,
2620 const Output_section::Input_section*
2626 { return output_section_; }
2629 set_output_and_owner(Output_section* o,
2630 const Output_section::Input_section* i)
2632 this->output_section_ = o;
2641 // Adding group sections before the stubs.
2642 FINDING_STUB_SECTION,
2643 // Adding group sections after the stubs.
2647 uint32_t stub_group_size_;
2648 bool stubs_always_after_branch_;
2649 bool suppress_size_errors_;
2650 // True if a stub group can serve multiple output sections.
2653 // Current max size of group. Starts at stub_group_size_ but is
2654 // reduced to stub_group_size_/1024 on seeing a section with
2655 // external conditional branches.
2656 uint32_t group_size_;
2657 uint64_t group_start_addr_;
2658 // owner_ and output_section_ specify the section to which stubs are
2659 // attached. The stubs are placed at the end of this section.
2660 const Output_section::Input_section* owner_;
2661 Output_section* output_section_;
2664 // Return true iff input section can be handled by current stub
2665 // group. Sections are presented to this function in order,
2666 // so the first section is the head of the group.
2669 Stub_control::can_add_to_stub_group(Output_section* o,
2670 const Output_section::Input_section* i,
2673 bool whole_sec = o->order() == ORDER_INIT || o->order() == ORDER_FINI;
2675 uint64_t start_addr = o->address();
2678 // .init and .fini sections are pasted together to form a single
2679 // function. We can't be adding stubs in the middle of the function.
2680 this_size = o->data_size();
2683 start_addr += i->relobj()->output_section_offset(i->shndx());
2684 this_size = i->data_size();
2687 uint64_t end_addr = start_addr + this_size;
2688 uint32_t group_size = this->stub_group_size_;
2690 this->group_size_ = group_size = group_size >> 10;
2692 if (this_size > group_size && !this->suppress_size_errors_)
2693 gold_warning(_("%s:%s exceeds group size"),
2694 i->relobj()->name().c_str(),
2695 i->relobj()->section_name(i->shndx()).c_str());
2697 gold_debug(DEBUG_TARGET, "maybe add%s %s:%s size=%#llx total=%#llx",
2698 has14 ? " 14bit" : "",
2699 i->relobj()->name().c_str(),
2700 i->relobj()->section_name(i->shndx()).c_str(),
2701 (long long) this_size,
2702 (this->state_ == NO_GROUP
2704 : (long long) end_addr - this->group_start_addr_));
2706 if (this->state_ == NO_GROUP)
2708 // Only here on very first use of Stub_control
2710 this->output_section_ = o;
2711 this->state_ = FINDING_STUB_SECTION;
2712 this->group_size_ = group_size;
2713 this->group_start_addr_ = start_addr;
2716 else if (!this->multi_os_ && this->output_section_ != o)
2718 else if (this->state_ == HAS_STUB_SECTION)
2720 // Can we add this section, which is after the stubs, to the
2722 if (end_addr - this->group_start_addr_ <= this->group_size_)
2725 else if (this->state_ == FINDING_STUB_SECTION)
2727 if ((whole_sec && this->output_section_ == o)
2728 || end_addr - this->group_start_addr_ <= this->group_size_)
2730 // Stubs are added at the end of "owner_".
2732 this->output_section_ = o;
2735 // The group before the stubs has reached maximum size.
2736 // Now see about adding sections after the stubs to the
2737 // group. If the current section has a 14-bit branch and
2738 // the group before the stubs exceeds group_size_ (because
2739 // they didn't have 14-bit branches), don't add sections
2740 // after the stubs: The size of stubs for such a large
2741 // group may exceed the reach of a 14-bit branch.
2742 if (!this->stubs_always_after_branch_
2743 && this_size <= this->group_size_
2744 && start_addr - this->group_start_addr_ <= this->group_size_)
2746 gold_debug(DEBUG_TARGET, "adding after stubs");
2747 this->state_ = HAS_STUB_SECTION;
2748 this->group_start_addr_ = start_addr;
2755 gold_debug(DEBUG_TARGET,
2756 !this->multi_os_ && this->output_section_ != o
2757 ? "nope, new output section\n"
2758 : "nope, didn't fit\n");
2760 // The section fails to fit in the current group. Set up a few
2761 // things for the next group. owner_ and output_section_ will be
2762 // set later after we've retrieved those values for the current
2764 this->state_ = FINDING_STUB_SECTION;
2765 this->group_size_ = group_size;
2766 this->group_start_addr_ = start_addr;
2770 // Look over all the input sections, deciding where to place stubs.
2772 template<int size, bool big_endian>
2774 Target_powerpc<size, big_endian>::group_sections(Layout* layout,
2776 bool no_size_errors)
2778 Stub_control stub_control(this->stub_group_size_, no_size_errors,
2779 parameters->options().stub_group_multi());
2781 // Group input sections and insert stub table
2782 Stub_table_owner* table_owner = NULL;
2783 std::vector<Stub_table_owner*> tables;
2784 Layout::Section_list section_list;
2785 layout->get_executable_sections(§ion_list);
2786 std::stable_sort(section_list.begin(), section_list.end(), Sort_sections());
2787 for (Layout::Section_list::iterator o = section_list.begin();
2788 o != section_list.end();
2791 typedef Output_section::Input_section_list Input_section_list;
2792 for (Input_section_list::const_iterator i
2793 = (*o)->input_sections().begin();
2794 i != (*o)->input_sections().end();
2797 if (i->is_input_section()
2798 || i->is_relaxed_input_section())
2800 Powerpc_relobj<size, big_endian>* ppcobj = static_cast
2801 <Powerpc_relobj<size, big_endian>*>(i->relobj());
2802 bool has14 = ppcobj->has_14bit_branch(i->shndx());
2803 if (!stub_control.can_add_to_stub_group(*o, &*i, has14))
2805 table_owner->output_section = stub_control.output_section();
2806 table_owner->owner = stub_control.owner();
2807 stub_control.set_output_and_owner(*o, &*i);
2810 if (table_owner == NULL)
2812 table_owner = new Stub_table_owner;
2813 tables.push_back(table_owner);
2815 ppcobj->set_stub_table(i->shndx(), tables.size() - 1);
2819 if (table_owner != NULL)
2821 table_owner->output_section = stub_control.output_section();
2822 table_owner->owner = stub_control.owner();;
2824 for (typename std::vector<Stub_table_owner*>::iterator t = tables.begin();
2828 Stub_table<size, big_endian>* stub_table;
2830 if ((*t)->owner->is_input_section())
2831 stub_table = new Stub_table<size, big_endian>(this,
2832 (*t)->output_section,
2834 else if ((*t)->owner->is_relaxed_input_section())
2835 stub_table = static_cast<Stub_table<size, big_endian>*>(
2836 (*t)->owner->relaxed_input_section());
2839 this->stub_tables_.push_back(stub_table);
2844 static unsigned long
2845 max_branch_delta (unsigned int r_type)
2847 if (r_type == elfcpp::R_POWERPC_REL14
2848 || r_type == elfcpp::R_POWERPC_REL14_BRTAKEN
2849 || r_type == elfcpp::R_POWERPC_REL14_BRNTAKEN)
2851 if (r_type == elfcpp::R_POWERPC_REL24
2852 || r_type == elfcpp::R_PPC_PLTREL24
2853 || r_type == elfcpp::R_PPC_LOCAL24PC)
2858 // If this branch needs a plt call stub, or a long branch stub, make one.
2860 template<int size, bool big_endian>
2862 Target_powerpc<size, big_endian>::Branch_info::make_stub(
2863 Stub_table<size, big_endian>* stub_table,
2864 Stub_table<size, big_endian>* ifunc_stub_table,
2865 Symbol_table* symtab) const
2867 Symbol* sym = this->object_->global_symbol(this->r_sym_);
2868 if (sym != NULL && sym->is_forwarder())
2869 sym = symtab->resolve_forwards(sym);
2870 const Sized_symbol<size>* gsym = static_cast<const Sized_symbol<size>*>(sym);
2871 Target_powerpc<size, big_endian>* target =
2872 static_cast<Target_powerpc<size, big_endian>*>(
2873 parameters->sized_target<size, big_endian>());
2877 ? gsym->use_plt_offset(Scan::get_reference_flags(this->r_type_, target))
2878 : this->object_->local_has_plt_offset(this->r_sym_))
2882 && target->abiversion() >= 2
2883 && !parameters->options().output_is_position_independent()
2884 && !is_branch_reloc(this->r_type_))
2885 target->glink_section()->add_global_entry(gsym);
2888 if (stub_table == NULL)
2889 stub_table = this->object_->stub_table(this->shndx_);
2890 if (stub_table == NULL)
2892 // This is a ref from a data section to an ifunc symbol.
2893 stub_table = ifunc_stub_table;
2895 gold_assert(stub_table != NULL);
2896 Address from = this->object_->get_output_section_offset(this->shndx_);
2897 if (from != invalid_address)
2898 from += (this->object_->output_section(this->shndx_)->address()
2901 ok = stub_table->add_plt_call_entry(from,
2902 this->object_, gsym,
2903 this->r_type_, this->addend_);
2905 ok = stub_table->add_plt_call_entry(from,
2906 this->object_, this->r_sym_,
2907 this->r_type_, this->addend_);
2912 Address max_branch_offset = max_branch_delta(this->r_type_);
2913 if (max_branch_offset == 0)
2915 Address from = this->object_->get_output_section_offset(this->shndx_);
2916 gold_assert(from != invalid_address);
2917 from += (this->object_->output_section(this->shndx_)->address()
2922 switch (gsym->source())
2924 case Symbol::FROM_OBJECT:
2926 Object* symobj = gsym->object();
2927 if (symobj->is_dynamic()
2928 || symobj->pluginobj() != NULL)
2931 unsigned int shndx = gsym->shndx(&is_ordinary);
2932 if (shndx == elfcpp::SHN_UNDEF)
2937 case Symbol::IS_UNDEFINED:
2943 Symbol_table::Compute_final_value_status status;
2944 to = symtab->compute_final_value<size>(gsym, &status);
2945 if (status != Symbol_table::CFVS_OK)
2948 to += this->object_->ppc64_local_entry_offset(gsym);
2952 const Symbol_value<size>* psymval
2953 = this->object_->local_symbol(this->r_sym_);
2954 Symbol_value<size> symval;
2955 if (psymval->is_section_symbol())
2956 symval.set_is_section_symbol();
2957 typedef Sized_relobj_file<size, big_endian> ObjType;
2958 typename ObjType::Compute_final_local_value_status status
2959 = this->object_->compute_final_local_value(this->r_sym_, psymval,
2961 if (status != ObjType::CFLV_OK
2962 || !symval.has_output_value())
2964 to = symval.value(this->object_, 0);
2966 to += this->object_->ppc64_local_entry_offset(this->r_sym_);
2968 if (!(size == 32 && this->r_type_ == elfcpp::R_PPC_PLTREL24))
2969 to += this->addend_;
2970 if (stub_table == NULL)
2971 stub_table = this->object_->stub_table(this->shndx_);
2972 if (size == 64 && target->abiversion() < 2)
2974 unsigned int dest_shndx;
2975 if (!target->symval_for_branch(symtab, gsym, this->object_,
2979 Address delta = to - from;
2980 if (delta + max_branch_offset >= 2 * max_branch_offset)
2982 if (stub_table == NULL)
2984 gold_warning(_("%s:%s: branch in non-executable section,"
2985 " no long branch stub for you"),
2986 this->object_->name().c_str(),
2987 this->object_->section_name(this->shndx_).c_str());
2990 bool save_res = (size == 64
2992 && gsym->source() == Symbol::IN_OUTPUT_DATA
2993 && gsym->output_data() == target->savres_section());
2994 ok = stub_table->add_long_branch_entry(this->object_,
2996 from, to, save_res);
3000 gold_debug(DEBUG_TARGET,
3001 "branch at %s:%s+%#lx\n"
3002 "can't reach stub attached to %s:%s",
3003 this->object_->name().c_str(),
3004 this->object_->section_name(this->shndx_).c_str(),
3005 (unsigned long) this->offset_,
3006 stub_table->relobj()->name().c_str(),
3007 stub_table->relobj()->section_name(stub_table->shndx()).c_str());
3012 // Relaxation hook. This is where we do stub generation.
3014 template<int size, bool big_endian>
3016 Target_powerpc<size, big_endian>::do_relax(int pass,
3017 const Input_objects*,
3018 Symbol_table* symtab,
3022 unsigned int prev_brlt_size = 0;
3026 = this->abiversion() < 2 && parameters->options().plt_thread_safe();
3028 && this->abiversion() < 2
3030 && !parameters->options().user_set_plt_thread_safe())
3032 static const char* const thread_starter[] =
3036 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
3038 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
3039 "mq_notify", "create_timer",
3044 "GOMP_parallel_start",
3045 "GOMP_parallel_loop_static",
3046 "GOMP_parallel_loop_static_start",
3047 "GOMP_parallel_loop_dynamic",
3048 "GOMP_parallel_loop_dynamic_start",
3049 "GOMP_parallel_loop_guided",
3050 "GOMP_parallel_loop_guided_start",
3051 "GOMP_parallel_loop_runtime",
3052 "GOMP_parallel_loop_runtime_start",
3053 "GOMP_parallel_sections",
3054 "GOMP_parallel_sections_start",
3059 if (parameters->options().shared())
3063 for (unsigned int i = 0;
3064 i < sizeof(thread_starter) / sizeof(thread_starter[0]);
3067 Symbol* sym = symtab->lookup(thread_starter[i], NULL);
3068 thread_safe = (sym != NULL
3070 && sym->in_real_elf());
3076 this->plt_thread_safe_ = thread_safe;
3081 this->stub_group_size_ = parameters->options().stub_group_size();
3082 bool no_size_errors = true;
3083 if (this->stub_group_size_ == 1)
3084 this->stub_group_size_ = 0x1c00000;
3085 else if (this->stub_group_size_ == -1)
3086 this->stub_group_size_ = -0x1e00000;
3088 no_size_errors = false;
3089 this->group_sections(layout, task, no_size_errors);
3091 else if (this->relax_failed_ && this->relax_fail_count_ < 3)
3093 this->branch_lookup_table_.clear();
3094 for (typename Stub_tables::iterator p = this->stub_tables_.begin();
3095 p != this->stub_tables_.end();
3098 (*p)->clear_stubs(true);
3100 this->stub_tables_.clear();
3101 this->stub_group_size_ = this->stub_group_size_ / 4 * 3;
3102 gold_info(_("%s: stub group size is too large; retrying with %#x"),
3103 program_name, this->stub_group_size_);
3104 this->group_sections(layout, task, true);
3107 // We need address of stub tables valid for make_stub.
3108 for (typename Stub_tables::iterator p = this->stub_tables_.begin();
3109 p != this->stub_tables_.end();
3112 const Powerpc_relobj<size, big_endian>* object
3113 = static_cast<const Powerpc_relobj<size, big_endian>*>((*p)->relobj());
3114 Address off = object->get_output_section_offset((*p)->shndx());
3115 gold_assert(off != invalid_address);
3116 Output_section* os = (*p)->output_section();
3117 (*p)->set_address_and_size(os, off);
3122 // Clear plt call stubs, long branch stubs and branch lookup table.
3123 prev_brlt_size = this->branch_lookup_table_.size();
3124 this->branch_lookup_table_.clear();
3125 for (typename Stub_tables::iterator p = this->stub_tables_.begin();
3126 p != this->stub_tables_.end();
3129 (*p)->clear_stubs(false);
3133 // Build all the stubs.
3134 this->relax_failed_ = false;
3135 Stub_table<size, big_endian>* ifunc_stub_table
3136 = this->stub_tables_.size() == 0 ? NULL : this->stub_tables_[0];
3137 Stub_table<size, big_endian>* one_stub_table
3138 = this->stub_tables_.size() != 1 ? NULL : ifunc_stub_table;
3139 for (typename Branches::const_iterator b = this->branch_info_.begin();
3140 b != this->branch_info_.end();
3143 if (!b->make_stub(one_stub_table, ifunc_stub_table, symtab)
3144 && !this->relax_failed_)
3146 this->relax_failed_ = true;
3147 this->relax_fail_count_++;
3148 if (this->relax_fail_count_ < 3)
3153 // Did anything change size?
3154 unsigned int num_huge_branches = this->branch_lookup_table_.size();
3155 bool again = num_huge_branches != prev_brlt_size;
3156 if (size == 64 && num_huge_branches != 0)
3157 this->make_brlt_section(layout);
3158 if (size == 64 && again)
3159 this->brlt_section_->set_current_size(num_huge_branches);
3161 typedef Unordered_set<Output_section*> Output_sections;
3162 Output_sections os_need_update;
3163 for (typename Stub_tables::iterator p = this->stub_tables_.begin();
3164 p != this->stub_tables_.end();
3167 if ((*p)->size_update())
3170 (*p)->add_eh_frame(layout);
3171 os_need_update.insert((*p)->output_section());
3175 // Set output section offsets for all input sections in an output
3176 // section that just changed size. Anything past the stubs will
3178 for (typename Output_sections::iterator p = os_need_update.begin();
3179 p != os_need_update.end();
3182 Output_section* os = *p;
3184 typedef Output_section::Input_section_list Input_section_list;
3185 for (Input_section_list::const_iterator i = os->input_sections().begin();
3186 i != os->input_sections().end();
3189 off = align_address(off, i->addralign());
3190 if (i->is_input_section() || i->is_relaxed_input_section())
3191 i->relobj()->set_section_offset(i->shndx(), off);
3192 if (i->is_relaxed_input_section())
3194 Stub_table<size, big_endian>* stub_table
3195 = static_cast<Stub_table<size, big_endian>*>(
3196 i->relaxed_input_section());
3197 Address stub_table_size = stub_table->set_address_and_size(os, off);
3198 off += stub_table_size;
3199 // After a few iterations, set current stub table size
3200 // as min size threshold, so later stub tables can only
3203 stub_table->set_min_size_threshold(stub_table_size);
3206 off += i->data_size();
3208 // If .branch_lt is part of this output section, then we have
3209 // just done the offset adjustment.
3210 os->clear_section_offsets_need_adjustment();
3215 && num_huge_branches != 0
3216 && parameters->options().output_is_position_independent())
3218 // Fill in the BRLT relocs.
3219 this->brlt_section_->reset_brlt_sizes();
3220 for (typename Branch_lookup_table::const_iterator p
3221 = this->branch_lookup_table_.begin();
3222 p != this->branch_lookup_table_.end();
3225 this->brlt_section_->add_reloc(p->first, p->second);
3227 this->brlt_section_->finalize_brlt_sizes();
3232 template<int size, bool big_endian>
3234 Target_powerpc<size, big_endian>::do_plt_fde_location(const Output_data* plt,
3235 unsigned char* oview,
3239 uint64_t address = plt->address();
3240 off_t len = plt->data_size();
3242 if (plt == this->glink_)
3244 // See Output_data_glink::do_write() for glink contents.
3247 gold_assert(parameters->doing_static_link());
3248 // Static linking may need stubs, to support ifunc and long
3249 // branches. We need to create an output section for
3250 // .eh_frame early in the link process, to have a place to
3251 // attach stub .eh_frame info. We also need to have
3252 // registered a CIE that matches the stub CIE. Both of
3253 // these requirements are satisfied by creating an FDE and
3254 // CIE for .glink, even though static linking will leave
3255 // .glink zero length.
3256 // ??? Hopefully generating an FDE with a zero address range
3257 // won't confuse anything that consumes .eh_frame info.
3259 else if (size == 64)
3261 // There is one word before __glink_PLTresolve
3265 else if (parameters->options().output_is_position_independent())
3267 // There are two FDEs for a position independent glink.
3268 // The first covers the branch table, the second
3269 // __glink_PLTresolve at the end of glink.
3270 off_t resolve_size = this->glink_->pltresolve_size;
3271 if (oview[9] == elfcpp::DW_CFA_nop)
3272 len -= resolve_size;
3275 address += len - resolve_size;
3282 // Must be a stub table.
3283 const Stub_table<size, big_endian>* stub_table
3284 = static_cast<const Stub_table<size, big_endian>*>(plt);
3285 uint64_t stub_address = stub_table->stub_address();
3286 len -= stub_address - address;
3287 address = stub_address;
3290 *paddress = address;
3294 // A class to handle the PLT data.
3296 template<int size, bool big_endian>
3297 class Output_data_plt_powerpc : public Output_section_data_build
3300 typedef Output_data_reloc<elfcpp::SHT_RELA, true,
3301 size, big_endian> Reloc_section;
3303 Output_data_plt_powerpc(Target_powerpc<size, big_endian>* targ,
3304 Reloc_section* plt_rel,
3306 : Output_section_data_build(size == 32 ? 4 : 8),
3312 // Add an entry to the PLT.
3317 add_ifunc_entry(Symbol*);
3320 add_local_ifunc_entry(Sized_relobj_file<size, big_endian>*, unsigned int);
3322 // Return the .rela.plt section data.
3329 // Return the number of PLT entries.
3333 if (this->current_data_size() == 0)
3335 return ((this->current_data_size() - this->first_plt_entry_offset())
3336 / this->plt_entry_size());
3341 do_adjust_output_section(Output_section* os)
3346 // Write to a map file.
3348 do_print_to_mapfile(Mapfile* mapfile) const
3349 { mapfile->print_output_data(this, this->name_); }
3352 // Return the offset of the first non-reserved PLT entry.
3354 first_plt_entry_offset() const
3356 // IPLT has no reserved entry.
3357 if (this->name_[3] == 'I')
3359 return this->targ_->first_plt_entry_offset();
3362 // Return the size of each PLT entry.
3364 plt_entry_size() const
3366 return this->targ_->plt_entry_size();
3369 // Write out the PLT data.
3371 do_write(Output_file*);
3373 // The reloc section.
3374 Reloc_section* rel_;
3375 // Allows access to .glink for do_write.
3376 Target_powerpc<size, big_endian>* targ_;
3377 // What to report in map file.
3381 // Add an entry to the PLT.
3383 template<int size, bool big_endian>
3385 Output_data_plt_powerpc<size, big_endian>::add_entry(Symbol* gsym)
3387 if (!gsym->has_plt_offset())
3389 section_size_type off = this->current_data_size();
3391 off += this->first_plt_entry_offset();
3392 gsym->set_plt_offset(off);
3393 gsym->set_needs_dynsym_entry();
3394 unsigned int dynrel = elfcpp::R_POWERPC_JMP_SLOT;
3395 this->rel_->add_global(gsym, dynrel, this, off, 0);
3396 off += this->plt_entry_size();
3397 this->set_current_data_size(off);
3401 // Add an entry for a global ifunc symbol that resolves locally, to the IPLT.
3403 template<int size, bool big_endian>
3405 Output_data_plt_powerpc<size, big_endian>::add_ifunc_entry(Symbol* gsym)
3407 if (!gsym->has_plt_offset())
3409 section_size_type off = this->current_data_size();
3410 gsym->set_plt_offset(off);
3411 unsigned int dynrel = elfcpp::R_POWERPC_IRELATIVE;
3412 if (size == 64 && this->targ_->abiversion() < 2)
3413 dynrel = elfcpp::R_PPC64_JMP_IREL;
3414 this->rel_->add_symbolless_global_addend(gsym, dynrel, this, off, 0);
3415 off += this->plt_entry_size();
3416 this->set_current_data_size(off);
3420 // Add an entry for a local ifunc symbol to the IPLT.
3422 template<int size, bool big_endian>
3424 Output_data_plt_powerpc<size, big_endian>::add_local_ifunc_entry(
3425 Sized_relobj_file<size, big_endian>* relobj,
3426 unsigned int local_sym_index)
3428 if (!relobj->local_has_plt_offset(local_sym_index))
3430 section_size_type off = this->current_data_size();
3431 relobj->set_local_plt_offset(local_sym_index, off);
3432 unsigned int dynrel = elfcpp::R_POWERPC_IRELATIVE;
3433 if (size == 64 && this->targ_->abiversion() < 2)
3434 dynrel = elfcpp::R_PPC64_JMP_IREL;
3435 this->rel_->add_symbolless_local_addend(relobj, local_sym_index, dynrel,
3437 off += this->plt_entry_size();
3438 this->set_current_data_size(off);
3442 static const uint32_t add_0_11_11 = 0x7c0b5a14;
3443 static const uint32_t add_2_2_11 = 0x7c425a14;
3444 static const uint32_t add_2_2_12 = 0x7c426214;
3445 static const uint32_t add_3_3_2 = 0x7c631214;
3446 static const uint32_t add_3_3_13 = 0x7c636a14;
3447 static const uint32_t add_11_0_11 = 0x7d605a14;
3448 static const uint32_t add_11_2_11 = 0x7d625a14;
3449 static const uint32_t add_11_11_2 = 0x7d6b1214;
3450 static const uint32_t addi_0_12 = 0x380c0000;
3451 static const uint32_t addi_2_2 = 0x38420000;
3452 static const uint32_t addi_3_3 = 0x38630000;
3453 static const uint32_t addi_11_11 = 0x396b0000;
3454 static const uint32_t addi_12_1 = 0x39810000;
3455 static const uint32_t addi_12_12 = 0x398c0000;
3456 static const uint32_t addis_0_2 = 0x3c020000;
3457 static const uint32_t addis_0_13 = 0x3c0d0000;
3458 static const uint32_t addis_2_12 = 0x3c4c0000;
3459 static const uint32_t addis_11_2 = 0x3d620000;
3460 static const uint32_t addis_11_11 = 0x3d6b0000;
3461 static const uint32_t addis_11_30 = 0x3d7e0000;
3462 static const uint32_t addis_12_1 = 0x3d810000;
3463 static const uint32_t addis_12_2 = 0x3d820000;
3464 static const uint32_t addis_12_12 = 0x3d8c0000;
3465 static const uint32_t b = 0x48000000;
3466 static const uint32_t bcl_20_31 = 0x429f0005;
3467 static const uint32_t bctr = 0x4e800420;
3468 static const uint32_t blr = 0x4e800020;
3469 static const uint32_t bnectr_p4 = 0x4ce20420;
3470 static const uint32_t cmpld_7_12_0 = 0x7fac0040;
3471 static const uint32_t cmpldi_2_0 = 0x28220000;
3472 static const uint32_t cror_15_15_15 = 0x4def7b82;
3473 static const uint32_t cror_31_31_31 = 0x4ffffb82;
3474 static const uint32_t ld_0_1 = 0xe8010000;
3475 static const uint32_t ld_0_12 = 0xe80c0000;
3476 static const uint32_t ld_2_1 = 0xe8410000;
3477 static const uint32_t ld_2_2 = 0xe8420000;
3478 static const uint32_t ld_2_11 = 0xe84b0000;
3479 static const uint32_t ld_2_12 = 0xe84c0000;
3480 static const uint32_t ld_11_2 = 0xe9620000;
3481 static const uint32_t ld_11_11 = 0xe96b0000;
3482 static const uint32_t ld_12_2 = 0xe9820000;
3483 static const uint32_t ld_12_11 = 0xe98b0000;
3484 static const uint32_t ld_12_12 = 0xe98c0000;
3485 static const uint32_t lfd_0_1 = 0xc8010000;
3486 static const uint32_t li_0_0 = 0x38000000;
3487 static const uint32_t li_12_0 = 0x39800000;
3488 static const uint32_t lis_0 = 0x3c000000;
3489 static const uint32_t lis_2 = 0x3c400000;
3490 static const uint32_t lis_11 = 0x3d600000;
3491 static const uint32_t lis_12 = 0x3d800000;
3492 static const uint32_t lvx_0_12_0 = 0x7c0c00ce;
3493 static const uint32_t lwz_0_12 = 0x800c0000;
3494 static const uint32_t lwz_11_11 = 0x816b0000;
3495 static const uint32_t lwz_11_30 = 0x817e0000;
3496 static const uint32_t lwz_12_12 = 0x818c0000;
3497 static const uint32_t lwzu_0_12 = 0x840c0000;
3498 static const uint32_t mflr_0 = 0x7c0802a6;
3499 static const uint32_t mflr_11 = 0x7d6802a6;
3500 static const uint32_t mflr_12 = 0x7d8802a6;
3501 static const uint32_t mtctr_0 = 0x7c0903a6;
3502 static const uint32_t mtctr_11 = 0x7d6903a6;
3503 static const uint32_t mtctr_12 = 0x7d8903a6;
3504 static const uint32_t mtlr_0 = 0x7c0803a6;
3505 static const uint32_t mtlr_12 = 0x7d8803a6;
3506 static const uint32_t nop = 0x60000000;
3507 static const uint32_t ori_0_0_0 = 0x60000000;
3508 static const uint32_t srdi_0_0_2 = 0x7800f082;
3509 static const uint32_t std_0_1 = 0xf8010000;
3510 static const uint32_t std_0_12 = 0xf80c0000;
3511 static const uint32_t std_2_1 = 0xf8410000;
3512 static const uint32_t stfd_0_1 = 0xd8010000;
3513 static const uint32_t stvx_0_12_0 = 0x7c0c01ce;
3514 static const uint32_t sub_11_11_12 = 0x7d6c5850;
3515 static const uint32_t sub_12_12_11 = 0x7d8b6050;
3516 static const uint32_t xor_2_12_12 = 0x7d826278;
3517 static const uint32_t xor_11_12_12 = 0x7d8b6278;
3519 // Write out the PLT.
3521 template<int size, bool big_endian>
3523 Output_data_plt_powerpc<size, big_endian>::do_write(Output_file* of)
3525 if (size == 32 && this->name_[3] != 'I')
3527 const section_size_type offset = this->offset();
3528 const section_size_type oview_size
3529 = convert_to_section_size_type(this->data_size());
3530 unsigned char* const oview = of->get_output_view(offset, oview_size);
3531 unsigned char* pov = oview;
3532 unsigned char* endpov = oview + oview_size;
3534 // The address of the .glink branch table
3535 const Output_data_glink<size, big_endian>* glink
3536 = this->targ_->glink_section();
3537 elfcpp::Elf_types<32>::Elf_Addr branch_tab = glink->address();
3539 while (pov < endpov)
3541 elfcpp::Swap<32, big_endian>::writeval(pov, branch_tab);
3546 of->write_output_view(offset, oview_size, oview);
3550 // Create the PLT section.
3552 template<int size, bool big_endian>
3554 Target_powerpc<size, big_endian>::make_plt_section(Symbol_table* symtab,
3557 if (this->plt_ == NULL)
3559 if (this->got_ == NULL)
3560 this->got_section(symtab, layout);
3562 if (this->glink_ == NULL)
3563 make_glink_section(layout);
3565 // Ensure that .rela.dyn always appears before .rela.plt This is
3566 // necessary due to how, on PowerPC and some other targets, .rela.dyn
3567 // needs to include .rela.plt in its range.
3568 this->rela_dyn_section(layout);
3570 Reloc_section* plt_rel = new Reloc_section(false);
3571 layout->add_output_section_data(".rela.plt", elfcpp::SHT_RELA,
3572 elfcpp::SHF_ALLOC, plt_rel,
3573 ORDER_DYNAMIC_PLT_RELOCS, false);
3575 = new Output_data_plt_powerpc<size, big_endian>(this, plt_rel,
3577 layout->add_output_section_data(".plt",
3579 ? elfcpp::SHT_PROGBITS
3580 : elfcpp::SHT_NOBITS),
3581 elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE,
3588 Output_section* rela_plt_os = plt_rel->output_section();
3589 rela_plt_os->set_info_section(this->plt_->output_section());
3593 // Create the IPLT section.
3595 template<int size, bool big_endian>
3597 Target_powerpc<size, big_endian>::make_iplt_section(Symbol_table* symtab,
3600 if (this->iplt_ == NULL)
3602 this->make_plt_section(symtab, layout);
3604 Reloc_section* iplt_rel = new Reloc_section(false);
3605 this->rela_dyn_->output_section()->add_output_section_data(iplt_rel);
3607 = new Output_data_plt_powerpc<size, big_endian>(this, iplt_rel,
3609 this->plt_->output_section()->add_output_section_data(this->iplt_);
3613 // A section for huge long branch addresses, similar to plt section.
3615 template<int size, bool big_endian>
3616 class Output_data_brlt_powerpc : public Output_section_data_build
3619 typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
3620 typedef Output_data_reloc<elfcpp::SHT_RELA, true,
3621 size, big_endian> Reloc_section;
3623 Output_data_brlt_powerpc(Target_powerpc<size, big_endian>* targ,
3624 Reloc_section* brlt_rel)
3625 : Output_section_data_build(size == 32 ? 4 : 8),
3633 this->reset_data_size();
3634 this->rel_->reset_data_size();
3638 finalize_brlt_sizes()
3640 this->finalize_data_size();
3641 this->rel_->finalize_data_size();
3644 // Add a reloc for an entry in the BRLT.
3646 add_reloc(Address to, unsigned int off)
3647 { this->rel_->add_relative(elfcpp::R_POWERPC_RELATIVE, this, off, to); }
3649 // Update section and reloc section size.
3651 set_current_size(unsigned int num_branches)
3653 this->reset_address_and_file_offset();
3654 this->set_current_data_size(num_branches * 16);
3655 this->finalize_data_size();
3656 Output_section* os = this->output_section();
3657 os->set_section_offsets_need_adjustment();
3658 if (this->rel_ != NULL)
3660 const unsigned int reloc_size = elfcpp::Elf_sizes<size>::rela_size;
3661 this->rel_->reset_address_and_file_offset();
3662 this->rel_->set_current_data_size(num_branches * reloc_size);
3663 this->rel_->finalize_data_size();
3664 Output_section* os = this->rel_->output_section();
3665 os->set_section_offsets_need_adjustment();
3671 do_adjust_output_section(Output_section* os)
3676 // Write to a map file.
3678 do_print_to_mapfile(Mapfile* mapfile) const
3679 { mapfile->print_output_data(this, "** BRLT"); }
3682 // Write out the BRLT data.
3684 do_write(Output_file*);
3686 // The reloc section.
3687 Reloc_section* rel_;
3688 Target_powerpc<size, big_endian>* targ_;
3691 // Make the branch lookup table section.
3693 template<int size, bool big_endian>
3695 Target_powerpc<size, big_endian>::make_brlt_section(Layout* layout)
3697 if (size == 64 && this->brlt_section_ == NULL)
3699 Reloc_section* brlt_rel = NULL;
3700 bool is_pic = parameters->options().output_is_position_independent();
3703 // When PIC we can't fill in .branch_lt (like .plt it can be
3704 // a bss style section) but must initialise at runtime via
3705 // dynamic relocats.
3706 this->rela_dyn_section(layout);
3707 brlt_rel = new Reloc_section(false);
3708 this->rela_dyn_->output_section()->add_output_section_data(brlt_rel);
3711 = new Output_data_brlt_powerpc<size, big_endian>(this, brlt_rel);
3712 if (this->plt_ && is_pic)
3713 this->plt_->output_section()
3714 ->add_output_section_data(this->brlt_section_);
3716 layout->add_output_section_data(".branch_lt",
3717 (is_pic ? elfcpp::SHT_NOBITS
3718 : elfcpp::SHT_PROGBITS),
3719 elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE,
3720 this->brlt_section_,
3721 (is_pic ? ORDER_SMALL_BSS
3722 : ORDER_SMALL_DATA),
3727 // Write out .branch_lt when non-PIC.
3729 template<int size, bool big_endian>
3731 Output_data_brlt_powerpc<size, big_endian>::do_write(Output_file* of)
3733 if (size == 64 && !parameters->options().output_is_position_independent())
3735 const section_size_type offset = this->offset();
3736 const section_size_type oview_size
3737 = convert_to_section_size_type(this->data_size());
3738 unsigned char* const oview = of->get_output_view(offset, oview_size);
3740 this->targ_->write_branch_lookup_table(oview);
3741 of->write_output_view(offset, oview_size, oview);
3745 static inline uint32_t
3751 static inline uint32_t
3757 static inline uint32_t
3760 return hi(a + 0x8000);
3766 static const unsigned char eh_frame_cie[12];
3770 const unsigned char Eh_cie<size>::eh_frame_cie[] =
3773 'z', 'R', 0, // Augmentation string.
3774 4, // Code alignment.
3775 0x80 - size / 8 , // Data alignment.
3777 1, // Augmentation size.
3778 (elfcpp::DW_EH_PE_pcrel
3779 | elfcpp::DW_EH_PE_sdata4), // FDE encoding.
3780 elfcpp::DW_CFA_def_cfa, 1, 0 // def_cfa: r1 offset 0.
3783 // Describe __glink_PLTresolve use of LR, 64-bit version ABIv1.
3784 static const unsigned char glink_eh_frame_fde_64v1[] =
3786 0, 0, 0, 0, // Replaced with offset to .glink.
3787 0, 0, 0, 0, // Replaced with size of .glink.
3788 0, // Augmentation size.
3789 elfcpp::DW_CFA_advance_loc + 1,
3790 elfcpp::DW_CFA_register, 65, 12,
3791 elfcpp::DW_CFA_advance_loc + 4,
3792 elfcpp::DW_CFA_restore_extended, 65
3795 // Describe __glink_PLTresolve use of LR, 64-bit version ABIv2.
3796 static const unsigned char glink_eh_frame_fde_64v2[] =
3798 0, 0, 0, 0, // Replaced with offset to .glink.
3799 0, 0, 0, 0, // Replaced with size of .glink.
3800 0, // Augmentation size.
3801 elfcpp::DW_CFA_advance_loc + 1,
3802 elfcpp::DW_CFA_register, 65, 0,
3803 elfcpp::DW_CFA_advance_loc + 4,
3804 elfcpp::DW_CFA_restore_extended, 65
3807 // Describe __glink_PLTresolve use of LR, 32-bit version.
3808 static const unsigned char glink_eh_frame_fde_32[] =
3810 0, 0, 0, 0, // Replaced with offset to .glink.
3811 0, 0, 0, 0, // Replaced with size of .glink.
3812 0, // Augmentation size.
3813 elfcpp::DW_CFA_advance_loc + 2,
3814 elfcpp::DW_CFA_register, 65, 0,
3815 elfcpp::DW_CFA_advance_loc + 4,
3816 elfcpp::DW_CFA_restore_extended, 65
3819 static const unsigned char default_fde[] =
3821 0, 0, 0, 0, // Replaced with offset to stubs.
3822 0, 0, 0, 0, // Replaced with size of stubs.
3823 0, // Augmentation size.
3824 elfcpp::DW_CFA_nop, // Pad.
3829 template<bool big_endian>
3831 write_insn(unsigned char* p, uint32_t v)
3833 elfcpp::Swap<32, big_endian>::writeval(p, v);
3836 // Stub_table holds information about plt and long branch stubs.
3837 // Stubs are built in an area following some input section determined
3838 // by group_sections(). This input section is converted to a relaxed
3839 // input section allowing it to be resized to accommodate the stubs
3841 template<int size, bool big_endian>
3842 class Stub_table : public Output_relaxed_input_section
3845 typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
3846 static const Address invalid_address = static_cast<Address>(0) - 1;
3848 Stub_table(Target_powerpc<size, big_endian>* targ,
3849 Output_section* output_section,
3850 const Output_section::Input_section* owner)
3851 : Output_relaxed_input_section(owner->relobj(), owner->shndx(),
3853 ->section_addralign(owner->shndx())),
3854 targ_(targ), plt_call_stubs_(), long_branch_stubs_(),
3855 orig_data_size_(owner->current_data_size()),
3856 plt_size_(0), last_plt_size_(0),
3857 branch_size_(0), last_branch_size_(0), min_size_threshold_(0),
3858 eh_frame_added_(false), need_save_res_(false)
3860 this->set_output_section(output_section);
3862 std::vector<Output_relaxed_input_section*> new_relaxed;
3863 new_relaxed.push_back(this);
3864 output_section->convert_input_sections_to_relaxed_sections(new_relaxed);
3867 // Add a plt call stub.
3869 add_plt_call_entry(Address,
3870 const Sized_relobj_file<size, big_endian>*,
3876 add_plt_call_entry(Address,
3877 const Sized_relobj_file<size, big_endian>*,
3882 // Find a given plt call stub.
3884 find_plt_call_entry(const Symbol*) const;
3887 find_plt_call_entry(const Sized_relobj_file<size, big_endian>*,
3888 unsigned int) const;
3891 find_plt_call_entry(const Sized_relobj_file<size, big_endian>*,
3897 find_plt_call_entry(const Sized_relobj_file<size, big_endian>*,
3902 // Add a long branch stub.
3904 add_long_branch_entry(const Powerpc_relobj<size, big_endian>*,
3905 unsigned int, Address, Address, bool);
3908 find_long_branch_entry(const Powerpc_relobj<size, big_endian>*,
3912 can_reach_stub(Address from, unsigned int off, unsigned int r_type)
3914 Address max_branch_offset = max_branch_delta(r_type);
3915 if (max_branch_offset == 0)
3917 gold_assert(from != invalid_address);
3918 Address loc = off + this->stub_address();
3919 return loc - from + max_branch_offset < 2 * max_branch_offset;
3923 clear_stubs(bool all)
3925 this->plt_call_stubs_.clear();
3926 this->plt_size_ = 0;
3927 this->long_branch_stubs_.clear();
3928 this->branch_size_ = 0;
3929 this->need_save_res_ = false;
3932 this->last_plt_size_ = 0;
3933 this->last_branch_size_ = 0;
3938 set_address_and_size(const Output_section* os, Address off)
3940 Address start_off = off;
3941 off += this->orig_data_size_;
3942 Address my_size = this->plt_size_ + this->branch_size_;
3943 if (this->need_save_res_)
3944 my_size += this->targ_->savres_section()->data_size();
3946 off = align_address(off, this->stub_align());
3947 // Include original section size and alignment padding in size
3948 my_size += off - start_off;
3949 // Ensure new size is always larger than min size
3950 // threshold. Alignment requirement is included in "my_size", so
3951 // increase "my_size" does not invalidate alignment.
3952 if (my_size < this->min_size_threshold_)
3953 my_size = this->min_size_threshold_;
3954 this->reset_address_and_file_offset();
3955 this->set_current_data_size(my_size);
3956 this->set_address_and_file_offset(os->address() + start_off,
3957 os->offset() + start_off);
3962 stub_address() const
3964 return align_address(this->address() + this->orig_data_size_,
3965 this->stub_align());
3971 return align_address(this->offset() + this->orig_data_size_,
3972 this->stub_align());
3977 { return this->plt_size_; }
3979 void set_min_size_threshold(Address min_size)
3980 { this->min_size_threshold_ = min_size; }
3985 Output_section* os = this->output_section();
3986 if (os->addralign() < this->stub_align())
3988 os->set_addralign(this->stub_align());
3989 // FIXME: get rid of the insane checkpointing.
3990 // We can't increase alignment of the input section to which
3991 // stubs are attached; The input section may be .init which
3992 // is pasted together with other .init sections to form a
3993 // function. Aligning might insert zero padding resulting in
3994 // sigill. However we do need to increase alignment of the
3995 // output section so that the align_address() on offset in
3996 // set_address_and_size() adds the same padding as the
3997 // align_address() on address in stub_address().
3998 // What's more, we need this alignment for the layout done in
3999 // relaxation_loop_body() so that the output section starts at
4000 // a suitably aligned address.
4001 os->checkpoint_set_addralign(this->stub_align());
4003 if (this->last_plt_size_ != this->plt_size_
4004 || this->last_branch_size_ != this->branch_size_)
4006 this->last_plt_size_ = this->plt_size_;
4007 this->last_branch_size_ = this->branch_size_;
4013 // Add .eh_frame info for this stub section. Unlike other linker
4014 // generated .eh_frame this is added late in the link, because we
4015 // only want the .eh_frame info if this particular stub section is
4018 add_eh_frame(Layout* layout)
4020 if (!this->eh_frame_added_)
4022 if (!parameters->options().ld_generated_unwind_info())
4025 // Since we add stub .eh_frame info late, it must be placed
4026 // after all other linker generated .eh_frame info so that
4027 // merge mapping need not be updated for input sections.
4028 // There is no provision to use a different CIE to that used
4030 if (!this->targ_->has_glink())
4033 layout->add_eh_frame_for_plt(this,
4034 Eh_cie<size>::eh_frame_cie,
4035 sizeof (Eh_cie<size>::eh_frame_cie),
4037 sizeof (default_fde));
4038 this->eh_frame_added_ = true;
4042 Target_powerpc<size, big_endian>*
4048 class Plt_stub_ent_hash;
4049 typedef Unordered_map<Plt_stub_ent, unsigned int,
4050 Plt_stub_ent_hash> Plt_stub_entries;
4052 // Alignment of stub section.
4058 unsigned int min_align = 32;
4059 unsigned int user_align = 1 << parameters->options().plt_align();
4060 return std::max(user_align, min_align);
4063 // Return the plt offset for the given call stub.
4065 plt_off(typename Plt_stub_entries::const_iterator p, bool* is_iplt) const
4067 const Symbol* gsym = p->first.sym_;
4070 *is_iplt = (gsym->type() == elfcpp::STT_GNU_IFUNC
4071 && gsym->can_use_relative_reloc(false));
4072 return gsym->plt_offset();
4077 const Sized_relobj_file<size, big_endian>* relobj = p->first.object_;
4078 unsigned int local_sym_index = p->first.locsym_;
4079 return relobj->local_plt_offset(local_sym_index);
4083 // Size of a given plt call stub.
4085 plt_call_size(typename Plt_stub_entries::const_iterator p) const
4091 Address plt_addr = this->plt_off(p, &is_iplt);
4093 plt_addr += this->targ_->iplt_section()->address();
4095 plt_addr += this->targ_->plt_section()->address();
4096 Address got_addr = this->targ_->got_section()->output_section()->address();
4097 const Powerpc_relobj<size, big_endian>* ppcobj = static_cast
4098 <const Powerpc_relobj<size, big_endian>*>(p->first.object_);
4099 got_addr += ppcobj->toc_base_offset();
4100 Address off = plt_addr - got_addr;
4101 unsigned int bytes = 4 * 4 + 4 * (ha(off) != 0);
4102 if (this->targ_->abiversion() < 2)
4104 bool static_chain = parameters->options().plt_static_chain();
4105 bool thread_safe = this->targ_->plt_thread_safe();
4109 + 4 * (ha(off + 8 + 8 * static_chain) != ha(off)));
4111 unsigned int align = 1 << parameters->options().plt_align();
4113 bytes = (bytes + align - 1) & -align;
4117 // Return long branch stub size.
4119 branch_stub_size(Address to)
4122 = this->stub_address() + this->last_plt_size_ + this->branch_size_;
4123 if (to - loc + (1 << 25) < 2 << 25)
4125 if (size == 64 || !parameters->options().output_is_position_independent())
4132 do_write(Output_file*);
4134 // Plt call stub keys.
4138 Plt_stub_ent(const Symbol* sym)
4139 : sym_(sym), object_(0), addend_(0), locsym_(0)
4142 Plt_stub_ent(const Sized_relobj_file<size, big_endian>* object,
4143 unsigned int locsym_index)
4144 : sym_(NULL), object_(object), addend_(0), locsym_(locsym_index)
4147 Plt_stub_ent(const Sized_relobj_file<size, big_endian>* object,
4149 unsigned int r_type,
4151 : sym_(sym), object_(0), addend_(0), locsym_(0)
4154 this->addend_ = addend;
4155 else if (parameters->options().output_is_position_independent()
4156 && r_type == elfcpp::R_PPC_PLTREL24)
4158 this->addend_ = addend;
4159 if (this->addend_ >= 32768)
4160 this->object_ = object;
4164 Plt_stub_ent(const Sized_relobj_file<size, big_endian>* object,
4165 unsigned int locsym_index,
4166 unsigned int r_type,
4168 : sym_(NULL), object_(object), addend_(0), locsym_(locsym_index)
4171 this->addend_ = addend;
4172 else if (parameters->options().output_is_position_independent()
4173 && r_type == elfcpp::R_PPC_PLTREL24)
4174 this->addend_ = addend;
4177 bool operator==(const Plt_stub_ent& that) const
4179 return (this->sym_ == that.sym_
4180 && this->object_ == that.object_
4181 && this->addend_ == that.addend_
4182 && this->locsym_ == that.locsym_);
4186 const Sized_relobj_file<size, big_endian>* object_;
4187 typename elfcpp::Elf_types<size>::Elf_Addr addend_;
4188 unsigned int locsym_;
4191 class Plt_stub_ent_hash
4194 size_t operator()(const Plt_stub_ent& ent) const
4196 return (reinterpret_cast<uintptr_t>(ent.sym_)
4197 ^ reinterpret_cast<uintptr_t>(ent.object_)
4203 // Long branch stub keys.
4204 class Branch_stub_ent
4207 Branch_stub_ent(const Powerpc_relobj<size, big_endian>* obj,
4208 Address to, bool save_res)
4209 : dest_(to), toc_base_off_(0), save_res_(save_res)
4212 toc_base_off_ = obj->toc_base_offset();
4215 bool operator==(const Branch_stub_ent& that) const
4217 return (this->dest_ == that.dest_
4219 || this->toc_base_off_ == that.toc_base_off_));
4223 unsigned int toc_base_off_;
4227 class Branch_stub_ent_hash
4230 size_t operator()(const Branch_stub_ent& ent) const
4231 { return ent.dest_ ^ ent.toc_base_off_; }
4234 // In a sane world this would be a global.
4235 Target_powerpc<size, big_endian>* targ_;
4236 // Map sym/object/addend to stub offset.
4237 Plt_stub_entries plt_call_stubs_;
4238 // Map destination address to stub offset.
4239 typedef Unordered_map<Branch_stub_ent, unsigned int,
4240 Branch_stub_ent_hash> Branch_stub_entries;
4241 Branch_stub_entries long_branch_stubs_;
4242 // size of input section
4243 section_size_type orig_data_size_;
4245 section_size_type plt_size_, last_plt_size_, branch_size_, last_branch_size_;
4246 // Some rare cases cause (PR/20529) fluctuation in stub table
4247 // size, which leads to an endless relax loop. This is to be fixed
4248 // by, after the first few iterations, allowing only increase of
4249 // stub table size. This variable sets the minimal possible size of
4250 // a stub table, it is zero for the first few iterations, then
4251 // increases monotonically.
4252 Address min_size_threshold_;
4253 // Whether .eh_frame info has been created for this stub section.
4254 bool eh_frame_added_;
4255 // Set if this stub group needs a copy of out-of-line register
4256 // save/restore functions.
4257 bool need_save_res_;
4260 // Add a plt call stub, if we do not already have one for this
4261 // sym/object/addend combo.
4263 template<int size, bool big_endian>
4265 Stub_table<size, big_endian>::add_plt_call_entry(
4267 const Sized_relobj_file<size, big_endian>* object,
4269 unsigned int r_type,
4272 Plt_stub_ent ent(object, gsym, r_type, addend);
4273 unsigned int off = this->plt_size_;
4274 std::pair<typename Plt_stub_entries::iterator, bool> p
4275 = this->plt_call_stubs_.insert(std::make_pair(ent, off));
4277 this->plt_size_ = off + this->plt_call_size(p.first);
4278 return this->can_reach_stub(from, off, r_type);
4281 template<int size, bool big_endian>
4283 Stub_table<size, big_endian>::add_plt_call_entry(
4285 const Sized_relobj_file<size, big_endian>* object,
4286 unsigned int locsym_index,
4287 unsigned int r_type,
4290 Plt_stub_ent ent(object, locsym_index, r_type, addend);
4291 unsigned int off = this->plt_size_;
4292 std::pair<typename Plt_stub_entries::iterator, bool> p
4293 = this->plt_call_stubs_.insert(std::make_pair(ent, off));
4295 this->plt_size_ = off + this->plt_call_size(p.first);
4296 return this->can_reach_stub(from, off, r_type);
4299 // Find a plt call stub.
4301 template<int size, bool big_endian>
4302 typename Stub_table<size, big_endian>::Address
4303 Stub_table<size, big_endian>::find_plt_call_entry(
4304 const Sized_relobj_file<size, big_endian>* object,
4306 unsigned int r_type,
4307 Address addend) const
4309 Plt_stub_ent ent(object, gsym, r_type, addend);
4310 typename Plt_stub_entries::const_iterator p = this->plt_call_stubs_.find(ent);
4311 return p == this->plt_call_stubs_.end() ? invalid_address : p->second;
4314 template<int size, bool big_endian>
4315 typename Stub_table<size, big_endian>::Address
4316 Stub_table<size, big_endian>::find_plt_call_entry(const Symbol* gsym) const
4318 Plt_stub_ent ent(gsym);
4319 typename Plt_stub_entries::const_iterator p = this->plt_call_stubs_.find(ent);
4320 return p == this->plt_call_stubs_.end() ? invalid_address : p->second;
4323 template<int size, bool big_endian>
4324 typename Stub_table<size, big_endian>::Address
4325 Stub_table<size, big_endian>::find_plt_call_entry(
4326 const Sized_relobj_file<size, big_endian>* object,
4327 unsigned int locsym_index,
4328 unsigned int r_type,
4329 Address addend) const
4331 Plt_stub_ent ent(object, locsym_index, r_type, addend);
4332 typename Plt_stub_entries::const_iterator p = this->plt_call_stubs_.find(ent);
4333 return p == this->plt_call_stubs_.end() ? invalid_address : p->second;
4336 template<int size, bool big_endian>
4337 typename Stub_table<size, big_endian>::Address
4338 Stub_table<size, big_endian>::find_plt_call_entry(
4339 const Sized_relobj_file<size, big_endian>* object,
4340 unsigned int locsym_index) const
4342 Plt_stub_ent ent(object, locsym_index);
4343 typename Plt_stub_entries::const_iterator p = this->plt_call_stubs_.find(ent);
4344 return p == this->plt_call_stubs_.end() ? invalid_address : p->second;
4347 // Add a long branch stub if we don't already have one to given
4350 template<int size, bool big_endian>
4352 Stub_table<size, big_endian>::add_long_branch_entry(
4353 const Powerpc_relobj<size, big_endian>* object,
4354 unsigned int r_type,
4359 Branch_stub_ent ent(object, to, save_res);
4360 Address off = this->branch_size_;
4361 if (this->long_branch_stubs_.insert(std::make_pair(ent, off)).second)
4364 this->need_save_res_ = true;
4367 unsigned int stub_size = this->branch_stub_size(to);
4368 this->branch_size_ = off + stub_size;
4369 if (size == 64 && stub_size != 4)
4370 this->targ_->add_branch_lookup_table(to);
4373 return this->can_reach_stub(from, off, r_type);
4376 // Find long branch stub offset.
4378 template<int size, bool big_endian>
4379 typename Stub_table<size, big_endian>::Address
4380 Stub_table<size, big_endian>::find_long_branch_entry(
4381 const Powerpc_relobj<size, big_endian>* object,
4384 Branch_stub_ent ent(object, to, false);
4385 typename Branch_stub_entries::const_iterator p
4386 = this->long_branch_stubs_.find(ent);
4387 if (p == this->long_branch_stubs_.end())
4388 return invalid_address;
4389 if (p->first.save_res_)
4390 return to - this->targ_->savres_section()->address() + this->branch_size_;
4394 // A class to handle .glink.
4396 template<int size, bool big_endian>
4397 class Output_data_glink : public Output_section_data
4400 typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
4401 static const Address invalid_address = static_cast<Address>(0) - 1;
4402 static const int pltresolve_size = 16*4;
4404 Output_data_glink(Target_powerpc<size, big_endian>* targ)
4405 : Output_section_data(16), targ_(targ), global_entry_stubs_(),
4406 end_branch_table_(), ge_size_(0)
4410 add_eh_frame(Layout* layout);
4413 add_global_entry(const Symbol*);
4416 find_global_entry(const Symbol*) const;
4419 global_entry_address() const
4421 gold_assert(this->is_data_size_valid());
4422 unsigned int global_entry_off = (this->end_branch_table_ + 15) & -16;
4423 return this->address() + global_entry_off;
4427 // Write to a map file.
4429 do_print_to_mapfile(Mapfile* mapfile) const
4430 { mapfile->print_output_data(this, _("** glink")); }
4434 set_final_data_size();
4438 do_write(Output_file*);
4440 // Allows access to .got and .plt for do_write.
4441 Target_powerpc<size, big_endian>* targ_;
4443 // Map sym to stub offset.
4444 typedef Unordered_map<const Symbol*, unsigned int> Global_entry_stub_entries;
4445 Global_entry_stub_entries global_entry_stubs_;
4447 unsigned int end_branch_table_, ge_size_;
4450 template<int size, bool big_endian>
4452 Output_data_glink<size, big_endian>::add_eh_frame(Layout* layout)
4454 if (!parameters->options().ld_generated_unwind_info())
4459 if (this->targ_->abiversion() < 2)
4460 layout->add_eh_frame_for_plt(this,
4461 Eh_cie<64>::eh_frame_cie,
4462 sizeof (Eh_cie<64>::eh_frame_cie),
4463 glink_eh_frame_fde_64v1,
4464 sizeof (glink_eh_frame_fde_64v1));
4466 layout->add_eh_frame_for_plt(this,
4467 Eh_cie<64>::eh_frame_cie,
4468 sizeof (Eh_cie<64>::eh_frame_cie),
4469 glink_eh_frame_fde_64v2,
4470 sizeof (glink_eh_frame_fde_64v2));
4474 // 32-bit .glink can use the default since the CIE return
4475 // address reg, LR, is valid.
4476 layout->add_eh_frame_for_plt(this,
4477 Eh_cie<32>::eh_frame_cie,
4478 sizeof (Eh_cie<32>::eh_frame_cie),
4480 sizeof (default_fde));
4481 // Except where LR is used in a PIC __glink_PLTresolve.
4482 if (parameters->options().output_is_position_independent())
4483 layout->add_eh_frame_for_plt(this,
4484 Eh_cie<32>::eh_frame_cie,
4485 sizeof (Eh_cie<32>::eh_frame_cie),
4486 glink_eh_frame_fde_32,
4487 sizeof (glink_eh_frame_fde_32));
4491 template<int size, bool big_endian>
4493 Output_data_glink<size, big_endian>::add_global_entry(const Symbol* gsym)
4495 std::pair<typename Global_entry_stub_entries::iterator, bool> p
4496 = this->global_entry_stubs_.insert(std::make_pair(gsym, this->ge_size_));
4498 this->ge_size_ += 16;
4501 template<int size, bool big_endian>
4502 typename Output_data_glink<size, big_endian>::Address
4503 Output_data_glink<size, big_endian>::find_global_entry(const Symbol* gsym) const
4505 typename Global_entry_stub_entries::const_iterator p
4506 = this->global_entry_stubs_.find(gsym);
4507 return p == this->global_entry_stubs_.end() ? invalid_address : p->second;
4510 template<int size, bool big_endian>
4512 Output_data_glink<size, big_endian>::set_final_data_size()
4514 unsigned int count = this->targ_->plt_entry_count();
4515 section_size_type total = 0;
4521 // space for branch table
4522 total += 4 * (count - 1);
4524 total += -total & 15;
4525 total += this->pltresolve_size;
4529 total += this->pltresolve_size;
4531 // space for branch table
4533 if (this->targ_->abiversion() < 2)
4537 total += 4 * (count - 0x8000);
4541 this->end_branch_table_ = total;
4542 total = (total + 15) & -16;
4543 total += this->ge_size_;
4545 this->set_data_size(total);
4548 // Write out plt and long branch stub code.
4550 template<int size, bool big_endian>
4552 Stub_table<size, big_endian>::do_write(Output_file* of)
4554 if (this->plt_call_stubs_.empty()
4555 && this->long_branch_stubs_.empty())
4558 const section_size_type start_off = this->offset();
4559 const section_size_type off = this->stub_offset();
4560 const section_size_type oview_size =
4561 convert_to_section_size_type(this->data_size() - (off - start_off));
4562 unsigned char* const oview = of->get_output_view(off, oview_size);
4567 const Output_data_got_powerpc<size, big_endian>* got
4568 = this->targ_->got_section();
4569 Address got_os_addr = got->output_section()->address();
4571 if (!this->plt_call_stubs_.empty())
4573 // The base address of the .plt section.
4574 Address plt_base = this->targ_->plt_section()->address();
4575 Address iplt_base = invalid_address;
4577 // Write out plt call stubs.
4578 typename Plt_stub_entries::const_iterator cs;
4579 for (cs = this->plt_call_stubs_.begin();
4580 cs != this->plt_call_stubs_.end();
4584 Address pltoff = this->plt_off(cs, &is_iplt);
4585 Address plt_addr = pltoff;
4588 if (iplt_base == invalid_address)
4589 iplt_base = this->targ_->iplt_section()->address();
4590 plt_addr += iplt_base;
4593 plt_addr += plt_base;
4594 const Powerpc_relobj<size, big_endian>* ppcobj = static_cast
4595 <const Powerpc_relobj<size, big_endian>*>(cs->first.object_);
4596 Address got_addr = got_os_addr + ppcobj->toc_base_offset();
4597 Address off = plt_addr - got_addr;
4599 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
4600 gold_error(_("%s: linkage table error against `%s'"),
4601 cs->first.object_->name().c_str(),
4602 cs->first.sym_->demangled_name().c_str());
4604 bool plt_load_toc = this->targ_->abiversion() < 2;
4606 = plt_load_toc && parameters->options().plt_static_chain();
4608 = plt_load_toc && this->targ_->plt_thread_safe();
4609 bool use_fake_dep = false;
4610 Address cmp_branch_off = 0;
4613 unsigned int pltindex
4614 = ((pltoff - this->targ_->first_plt_entry_offset())
4615 / this->targ_->plt_entry_size());
4617 = (this->targ_->glink_section()->pltresolve_size
4619 if (pltindex > 32768)
4620 glinkoff += (pltindex - 32768) * 4;
4622 = this->targ_->glink_section()->address() + glinkoff;
4624 = (this->stub_address() + cs->second + 24
4625 + 4 * (ha(off) != 0)
4626 + 4 * (ha(off + 8 + 8 * static_chain) != ha(off))
4627 + 4 * static_chain);
4628 cmp_branch_off = to - from;
4629 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
4632 p = oview + cs->second;
4635 write_insn<big_endian>(p, std_2_1 + this->targ_->stk_toc());
4639 write_insn<big_endian>(p, addis_11_2 + ha(off));
4641 write_insn<big_endian>(p, ld_12_11 + l(off));
4646 write_insn<big_endian>(p, addis_12_2 + ha(off));
4648 write_insn<big_endian>(p, ld_12_12 + l(off));
4652 && ha(off + 8 + 8 * static_chain) != ha(off))
4654 write_insn<big_endian>(p, addi_11_11 + l(off));
4658 write_insn<big_endian>(p, mtctr_12);
4664 write_insn<big_endian>(p, xor_2_12_12);
4666 write_insn<big_endian>(p, add_11_11_2);
4669 write_insn<big_endian>(p, ld_2_11 + l(off + 8));
4673 write_insn<big_endian>(p, ld_11_11 + l(off + 16));
4680 write_insn<big_endian>(p, std_2_1 + this->targ_->stk_toc());
4682 write_insn<big_endian>(p, ld_12_2 + l(off));
4685 && ha(off + 8 + 8 * static_chain) != ha(off))
4687 write_insn<big_endian>(p, addi_2_2 + l(off));
4691 write_insn<big_endian>(p, mtctr_12);
4697 write_insn<big_endian>(p, xor_11_12_12);
4699 write_insn<big_endian>(p, add_2_2_11);
4704 write_insn<big_endian>(p, ld_11_2 + l(off + 16));
4707 write_insn<big_endian>(p, ld_2_2 + l(off + 8));
4711 if (thread_safe && !use_fake_dep)
4713 write_insn<big_endian>(p, cmpldi_2_0);
4715 write_insn<big_endian>(p, bnectr_p4);
4717 write_insn<big_endian>(p, b | (cmp_branch_off & 0x3fffffc));
4720 write_insn<big_endian>(p, bctr);
4724 // Write out long branch stubs.
4725 typename Branch_stub_entries::const_iterator bs;
4726 for (bs = this->long_branch_stubs_.begin();
4727 bs != this->long_branch_stubs_.end();
4730 if (bs->first.save_res_)
4732 p = oview + this->plt_size_ + bs->second;
4733 Address loc = this->stub_address() + this->plt_size_ + bs->second;
4734 Address delta = bs->first.dest_ - loc;
4735 if (delta + (1 << 25) < 2 << 25)
4736 write_insn<big_endian>(p, b | (delta & 0x3fffffc));
4740 = this->targ_->find_branch_lookup_table(bs->first.dest_);
4741 gold_assert(brlt_addr != invalid_address);
4742 brlt_addr += this->targ_->brlt_section()->address();
4743 Address got_addr = got_os_addr + bs->first.toc_base_off_;
4744 Address brltoff = brlt_addr - got_addr;
4745 if (ha(brltoff) == 0)
4747 write_insn<big_endian>(p, ld_12_2 + l(brltoff)), p += 4;
4751 write_insn<big_endian>(p, addis_12_2 + ha(brltoff)), p += 4;
4752 write_insn<big_endian>(p, ld_12_12 + l(brltoff)), p += 4;
4754 write_insn<big_endian>(p, mtctr_12), p += 4;
4755 write_insn<big_endian>(p, bctr);
4761 if (!this->plt_call_stubs_.empty())
4763 // The base address of the .plt section.
4764 Address plt_base = this->targ_->plt_section()->address();
4765 Address iplt_base = invalid_address;
4766 // The address of _GLOBAL_OFFSET_TABLE_.
4767 Address g_o_t = invalid_address;
4769 // Write out plt call stubs.
4770 typename Plt_stub_entries::const_iterator cs;
4771 for (cs = this->plt_call_stubs_.begin();
4772 cs != this->plt_call_stubs_.end();
4776 Address plt_addr = this->plt_off(cs, &is_iplt);
4779 if (iplt_base == invalid_address)
4780 iplt_base = this->targ_->iplt_section()->address();
4781 plt_addr += iplt_base;
4784 plt_addr += plt_base;
4786 p = oview + cs->second;
4787 if (parameters->options().output_is_position_independent())
4790 const Powerpc_relobj<size, big_endian>* ppcobj
4791 = (static_cast<const Powerpc_relobj<size, big_endian>*>
4792 (cs->first.object_));
4793 if (ppcobj != NULL && cs->first.addend_ >= 32768)
4795 unsigned int got2 = ppcobj->got2_shndx();
4796 got_addr = ppcobj->get_output_section_offset(got2);
4797 gold_assert(got_addr != invalid_address);
4798 got_addr += (ppcobj->output_section(got2)->address()
4799 + cs->first.addend_);
4803 if (g_o_t == invalid_address)
4805 const Output_data_got_powerpc<size, big_endian>* got
4806 = this->targ_->got_section();
4807 g_o_t = got->address() + got->g_o_t();
4812 Address off = plt_addr - got_addr;
4815 write_insn<big_endian>(p + 0, lwz_11_30 + l(off));
4816 write_insn<big_endian>(p + 4, mtctr_11);
4817 write_insn<big_endian>(p + 8, bctr);
4821 write_insn<big_endian>(p + 0, addis_11_30 + ha(off));
4822 write_insn<big_endian>(p + 4, lwz_11_11 + l(off));
4823 write_insn<big_endian>(p + 8, mtctr_11);
4824 write_insn<big_endian>(p + 12, bctr);
4829 write_insn<big_endian>(p + 0, lis_11 + ha(plt_addr));
4830 write_insn<big_endian>(p + 4, lwz_11_11 + l(plt_addr));
4831 write_insn<big_endian>(p + 8, mtctr_11);
4832 write_insn<big_endian>(p + 12, bctr);
4837 // Write out long branch stubs.
4838 typename Branch_stub_entries::const_iterator bs;
4839 for (bs = this->long_branch_stubs_.begin();
4840 bs != this->long_branch_stubs_.end();
4843 if (bs->first.save_res_)
4845 p = oview + this->plt_size_ + bs->second;
4846 Address loc = this->stub_address() + this->plt_size_ + bs->second;
4847 Address delta = bs->first.dest_ - loc;
4848 if (delta + (1 << 25) < 2 << 25)
4849 write_insn<big_endian>(p, b | (delta & 0x3fffffc));
4850 else if (!parameters->options().output_is_position_independent())
4852 write_insn<big_endian>(p + 0, lis_12 + ha(bs->first.dest_));
4853 write_insn<big_endian>(p + 4, addi_12_12 + l(bs->first.dest_));
4854 write_insn<big_endian>(p + 8, mtctr_12);
4855 write_insn<big_endian>(p + 12, bctr);
4860 write_insn<big_endian>(p + 0, mflr_0);
4861 write_insn<big_endian>(p + 4, bcl_20_31);
4862 write_insn<big_endian>(p + 8, mflr_12);
4863 write_insn<big_endian>(p + 12, addis_12_12 + ha(delta));
4864 write_insn<big_endian>(p + 16, addi_12_12 + l(delta));
4865 write_insn<big_endian>(p + 20, mtlr_0);
4866 write_insn<big_endian>(p + 24, mtctr_12);
4867 write_insn<big_endian>(p + 28, bctr);
4871 if (this->need_save_res_)
4873 p = oview + this->plt_size_ + this->branch_size_;
4874 memcpy (p, this->targ_->savres_section()->contents(),
4875 this->targ_->savres_section()->data_size());
4879 // Write out .glink.
4881 template<int size, bool big_endian>
4883 Output_data_glink<size, big_endian>::do_write(Output_file* of)
4885 const section_size_type off = this->offset();
4886 const section_size_type oview_size =
4887 convert_to_section_size_type(this->data_size());
4888 unsigned char* const oview = of->get_output_view(off, oview_size);
4891 // The base address of the .plt section.
4892 typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
4893 Address plt_base = this->targ_->plt_section()->address();
4897 if (this->end_branch_table_ != 0)
4899 // Write pltresolve stub.
4901 Address after_bcl = this->address() + 16;
4902 Address pltoff = plt_base - after_bcl;
4904 elfcpp::Swap<64, big_endian>::writeval(p, pltoff), p += 8;
4906 if (this->targ_->abiversion() < 2)
4908 write_insn<big_endian>(p, mflr_12), p += 4;
4909 write_insn<big_endian>(p, bcl_20_31), p += 4;
4910 write_insn<big_endian>(p, mflr_11), p += 4;
4911 write_insn<big_endian>(p, ld_2_11 + l(-16)), p += 4;
4912 write_insn<big_endian>(p, mtlr_12), p += 4;
4913 write_insn<big_endian>(p, add_11_2_11), p += 4;
4914 write_insn<big_endian>(p, ld_12_11 + 0), p += 4;
4915 write_insn<big_endian>(p, ld_2_11 + 8), p += 4;
4916 write_insn<big_endian>(p, mtctr_12), p += 4;
4917 write_insn<big_endian>(p, ld_11_11 + 16), p += 4;
4921 write_insn<big_endian>(p, mflr_0), p += 4;
4922 write_insn<big_endian>(p, bcl_20_31), p += 4;
4923 write_insn<big_endian>(p, mflr_11), p += 4;
4924 write_insn<big_endian>(p, ld_2_11 + l(-16)), p += 4;
4925 write_insn<big_endian>(p, mtlr_0), p += 4;
4926 write_insn<big_endian>(p, sub_12_12_11), p += 4;
4927 write_insn<big_endian>(p, add_11_2_11), p += 4;
4928 write_insn<big_endian>(p, addi_0_12 + l(-48)), p += 4;
4929 write_insn<big_endian>(p, ld_12_11 + 0), p += 4;
4930 write_insn<big_endian>(p, srdi_0_0_2), p += 4;
4931 write_insn<big_endian>(p, mtctr_12), p += 4;
4932 write_insn<big_endian>(p, ld_11_11 + 8), p += 4;
4934 write_insn<big_endian>(p, bctr), p += 4;
4935 while (p < oview + this->pltresolve_size)
4936 write_insn<big_endian>(p, nop), p += 4;
4938 // Write lazy link call stubs.
4940 while (p < oview + this->end_branch_table_)
4942 if (this->targ_->abiversion() < 2)
4946 write_insn<big_endian>(p, li_0_0 + indx), p += 4;
4950 write_insn<big_endian>(p, lis_0 + hi(indx)), p += 4;
4951 write_insn<big_endian>(p, ori_0_0_0 + l(indx)), p += 4;
4954 uint32_t branch_off = 8 - (p - oview);
4955 write_insn<big_endian>(p, b + (branch_off & 0x3fffffc)), p += 4;
4960 Address plt_base = this->targ_->plt_section()->address();
4961 Address iplt_base = invalid_address;
4962 unsigned int global_entry_off = (this->end_branch_table_ + 15) & -16;
4963 Address global_entry_base = this->address() + global_entry_off;
4964 typename Global_entry_stub_entries::const_iterator ge;
4965 for (ge = this->global_entry_stubs_.begin();
4966 ge != this->global_entry_stubs_.end();
4969 p = oview + global_entry_off + ge->second;
4970 Address plt_addr = ge->first->plt_offset();
4971 if (ge->first->type() == elfcpp::STT_GNU_IFUNC
4972 && ge->first->can_use_relative_reloc(false))
4974 if (iplt_base == invalid_address)
4975 iplt_base = this->targ_->iplt_section()->address();
4976 plt_addr += iplt_base;
4979 plt_addr += plt_base;
4980 Address my_addr = global_entry_base + ge->second;
4981 Address off = plt_addr - my_addr;
4983 if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
4984 gold_error(_("%s: linkage table error against `%s'"),
4985 ge->first->object()->name().c_str(),
4986 ge->first->demangled_name().c_str());
4988 write_insn<big_endian>(p, addis_12_12 + ha(off)), p += 4;
4989 write_insn<big_endian>(p, ld_12_12 + l(off)), p += 4;
4990 write_insn<big_endian>(p, mtctr_12), p += 4;
4991 write_insn<big_endian>(p, bctr);
4996 const Output_data_got_powerpc<size, big_endian>* got
4997 = this->targ_->got_section();
4998 // The address of _GLOBAL_OFFSET_TABLE_.
4999 Address g_o_t = got->address() + got->g_o_t();
5001 // Write out pltresolve branch table.
5003 unsigned int the_end = oview_size - this->pltresolve_size;
5004 unsigned char* end_p = oview + the_end;
5005 while (p < end_p - 8 * 4)
5006 write_insn<big_endian>(p, b + end_p - p), p += 4;
5008 write_insn<big_endian>(p, nop), p += 4;
5010 // Write out pltresolve call stub.
5011 if (parameters->options().output_is_position_independent())
5013 Address res0_off = 0;
5014 Address after_bcl_off = the_end + 12;
5015 Address bcl_res0 = after_bcl_off - res0_off;
5017 write_insn<big_endian>(p + 0, addis_11_11 + ha(bcl_res0));
5018 write_insn<big_endian>(p + 4, mflr_0);
5019 write_insn<big_endian>(p + 8, bcl_20_31);
5020 write_insn<big_endian>(p + 12, addi_11_11 + l(bcl_res0));
5021 write_insn<big_endian>(p + 16, mflr_12);
5022 write_insn<big_endian>(p + 20, mtlr_0);
5023 write_insn<big_endian>(p + 24, sub_11_11_12);
5025 Address got_bcl = g_o_t + 4 - (after_bcl_off + this->address());
5027 write_insn<big_endian>(p + 28, addis_12_12 + ha(got_bcl));
5028 if (ha(got_bcl) == ha(got_bcl + 4))
5030 write_insn<big_endian>(p + 32, lwz_0_12 + l(got_bcl));
5031 write_insn<big_endian>(p + 36, lwz_12_12 + l(got_bcl + 4));
5035 write_insn<big_endian>(p + 32, lwzu_0_12 + l(got_bcl));
5036 write_insn<big_endian>(p + 36, lwz_12_12 + 4);
5038 write_insn<big_endian>(p + 40, mtctr_0);
5039 write_insn<big_endian>(p + 44, add_0_11_11);
5040 write_insn<big_endian>(p + 48, add_11_0_11);
5041 write_insn<big_endian>(p + 52, bctr);
5042 write_insn<big_endian>(p + 56, nop);
5043 write_insn<big_endian>(p + 60, nop);
5047 Address res0 = this->address();
5049 write_insn<big_endian>(p + 0, lis_12 + ha(g_o_t + 4));
5050 write_insn<big_endian>(p + 4, addis_11_11 + ha(-res0));
5051 if (ha(g_o_t + 4) == ha(g_o_t + 8))
5052 write_insn<big_endian>(p + 8, lwz_0_12 + l(g_o_t + 4));
5054 write_insn<big_endian>(p + 8, lwzu_0_12 + l(g_o_t + 4));
5055 write_insn<big_endian>(p + 12, addi_11_11 + l(-res0));
5056 write_insn<big_endian>(p + 16, mtctr_0);
5057 write_insn<big_endian>(p + 20, add_0_11_11);
5058 if (ha(g_o_t + 4) == ha(g_o_t + 8))
5059 write_insn<big_endian>(p + 24, lwz_12_12 + l(g_o_t + 8));
5061 write_insn<big_endian>(p + 24, lwz_12_12 + 4);
5062 write_insn<big_endian>(p + 28, add_11_0_11);
5063 write_insn<big_endian>(p + 32, bctr);
5064 write_insn<big_endian>(p + 36, nop);
5065 write_insn<big_endian>(p + 40, nop);
5066 write_insn<big_endian>(p + 44, nop);
5067 write_insn<big_endian>(p + 48, nop);
5068 write_insn<big_endian>(p + 52, nop);
5069 write_insn<big_endian>(p + 56, nop);
5070 write_insn<big_endian>(p + 60, nop);
5075 of->write_output_view(off, oview_size, oview);
5079 // A class to handle linker generated save/restore functions.
5081 template<int size, bool big_endian>
5082 class Output_data_save_res : public Output_section_data_build
5085 Output_data_save_res(Symbol_table* symtab);
5087 const unsigned char*
5094 // Write to a map file.
5096 do_print_to_mapfile(Mapfile* mapfile) const
5097 { mapfile->print_output_data(this, _("** save/restore")); }
5100 do_write(Output_file*);
5103 // The maximum size of save/restore contents.
5104 static const unsigned int savres_max = 218*4;
5107 savres_define(Symbol_table* symtab,
5109 unsigned int lo, unsigned int hi,
5110 unsigned char* write_ent(unsigned char*, int),
5111 unsigned char* write_tail(unsigned char*, int));
5113 unsigned char *contents_;
5116 template<bool big_endian>
5117 static unsigned char*
5118 savegpr0(unsigned char* p, int r)
5120 uint32_t insn = std_0_1 + (r << 21) + (1 << 16) - (32 - r) * 8;
5121 write_insn<big_endian>(p, insn);
5125 template<bool big_endian>
5126 static unsigned char*
5127 savegpr0_tail(unsigned char* p, int r)
5129 p = savegpr0<big_endian>(p, r);
5130 uint32_t insn = std_0_1 + 16;
5131 write_insn<big_endian>(p, insn);
5133 write_insn<big_endian>(p, blr);
5137 template<bool big_endian>
5138 static unsigned char*
5139 restgpr0(unsigned char* p, int r)
5141 uint32_t insn = ld_0_1 + (r << 21) + (1 << 16) - (32 - r) * 8;
5142 write_insn<big_endian>(p, insn);
5146 template<bool big_endian>
5147 static unsigned char*
5148 restgpr0_tail(unsigned char* p, int r)
5150 uint32_t insn = ld_0_1 + 16;
5151 write_insn<big_endian>(p, insn);
5153 p = restgpr0<big_endian>(p, r);
5154 write_insn<big_endian>(p, mtlr_0);
5158 p = restgpr0<big_endian>(p, 30);
5159 p = restgpr0<big_endian>(p, 31);
5161 write_insn<big_endian>(p, blr);
5165 template<bool big_endian>
5166 static unsigned char*
5167 savegpr1(unsigned char* p, int r)
5169 uint32_t insn = std_0_12 + (r << 21) + (1 << 16) - (32 - r) * 8;
5170 write_insn<big_endian>(p, insn);
5174 template<bool big_endian>
5175 static unsigned char*
5176 savegpr1_tail(unsigned char* p, int r)
5178 p = savegpr1<big_endian>(p, r);
5179 write_insn<big_endian>(p, blr);
5183 template<bool big_endian>
5184 static unsigned char*
5185 restgpr1(unsigned char* p, int r)
5187 uint32_t insn = ld_0_12 + (r << 21) + (1 << 16) - (32 - r) * 8;
5188 write_insn<big_endian>(p, insn);
5192 template<bool big_endian>
5193 static unsigned char*
5194 restgpr1_tail(unsigned char* p, int r)
5196 p = restgpr1<big_endian>(p, r);
5197 write_insn<big_endian>(p, blr);
5201 template<bool big_endian>
5202 static unsigned char*
5203 savefpr(unsigned char* p, int r)
5205 uint32_t insn = stfd_0_1 + (r << 21) + (1 << 16) - (32 - r) * 8;
5206 write_insn<big_endian>(p, insn);
5210 template<bool big_endian>
5211 static unsigned char*
5212 savefpr0_tail(unsigned char* p, int r)
5214 p = savefpr<big_endian>(p, r);
5215 write_insn<big_endian>(p, std_0_1 + 16);
5217 write_insn<big_endian>(p, blr);
5221 template<bool big_endian>
5222 static unsigned char*
5223 restfpr(unsigned char* p, int r)
5225 uint32_t insn = lfd_0_1 + (r << 21) + (1 << 16) - (32 - r) * 8;
5226 write_insn<big_endian>(p, insn);
5230 template<bool big_endian>
5231 static unsigned char*
5232 restfpr0_tail(unsigned char* p, int r)
5234 write_insn<big_endian>(p, ld_0_1 + 16);
5236 p = restfpr<big_endian>(p, r);
5237 write_insn<big_endian>(p, mtlr_0);
5241 p = restfpr<big_endian>(p, 30);
5242 p = restfpr<big_endian>(p, 31);
5244 write_insn<big_endian>(p, blr);
5248 template<bool big_endian>
5249 static unsigned char*
5250 savefpr1_tail(unsigned char* p, int r)
5252 p = savefpr<big_endian>(p, r);
5253 write_insn<big_endian>(p, blr);
5257 template<bool big_endian>
5258 static unsigned char*
5259 restfpr1_tail(unsigned char* p, int r)
5261 p = restfpr<big_endian>(p, r);
5262 write_insn<big_endian>(p, blr);
5266 template<bool big_endian>
5267 static unsigned char*
5268 savevr(unsigned char* p, int r)
5270 uint32_t insn = li_12_0 + (1 << 16) - (32 - r) * 16;
5271 write_insn<big_endian>(p, insn);
5273 insn = stvx_0_12_0 + (r << 21);
5274 write_insn<big_endian>(p, insn);
5278 template<bool big_endian>
5279 static unsigned char*
5280 savevr_tail(unsigned char* p, int r)
5282 p = savevr<big_endian>(p, r);
5283 write_insn<big_endian>(p, blr);
5287 template<bool big_endian>
5288 static unsigned char*
5289 restvr(unsigned char* p, int r)
5291 uint32_t insn = li_12_0 + (1 << 16) - (32 - r) * 16;
5292 write_insn<big_endian>(p, insn);
5294 insn = lvx_0_12_0 + (r << 21);
5295 write_insn<big_endian>(p, insn);
5299 template<bool big_endian>
5300 static unsigned char*
5301 restvr_tail(unsigned char* p, int r)
5303 p = restvr<big_endian>(p, r);
5304 write_insn<big_endian>(p, blr);
5309 template<int size, bool big_endian>
5310 Output_data_save_res<size, big_endian>::Output_data_save_res(
5311 Symbol_table* symtab)
5312 : Output_section_data_build(4),
5315 this->savres_define(symtab,
5316 "_savegpr0_", 14, 31,
5317 savegpr0<big_endian>, savegpr0_tail<big_endian>);
5318 this->savres_define(symtab,
5319 "_restgpr0_", 14, 29,
5320 restgpr0<big_endian>, restgpr0_tail<big_endian>);
5321 this->savres_define(symtab,
5322 "_restgpr0_", 30, 31,
5323 restgpr0<big_endian>, restgpr0_tail<big_endian>);
5324 this->savres_define(symtab,
5325 "_savegpr1_", 14, 31,
5326 savegpr1<big_endian>, savegpr1_tail<big_endian>);
5327 this->savres_define(symtab,
5328 "_restgpr1_", 14, 31,
5329 restgpr1<big_endian>, restgpr1_tail<big_endian>);
5330 this->savres_define(symtab,
5331 "_savefpr_", 14, 31,
5332 savefpr<big_endian>, savefpr0_tail<big_endian>);
5333 this->savres_define(symtab,
5334 "_restfpr_", 14, 29,
5335 restfpr<big_endian>, restfpr0_tail<big_endian>);
5336 this->savres_define(symtab,
5337 "_restfpr_", 30, 31,
5338 restfpr<big_endian>, restfpr0_tail<big_endian>);
5339 this->savres_define(symtab,
5341 savefpr<big_endian>, savefpr1_tail<big_endian>);
5342 this->savres_define(symtab,
5344 restfpr<big_endian>, restfpr1_tail<big_endian>);
5345 this->savres_define(symtab,
5347 savevr<big_endian>, savevr_tail<big_endian>);
5348 this->savres_define(symtab,
5350 restvr<big_endian>, restvr_tail<big_endian>);
5353 template<int size, bool big_endian>
5355 Output_data_save_res<size, big_endian>::savres_define(
5356 Symbol_table* symtab,
5358 unsigned int lo, unsigned int hi,
5359 unsigned char* write_ent(unsigned char*, int),
5360 unsigned char* write_tail(unsigned char*, int))
5362 size_t len = strlen(name);
5363 bool writing = false;
5366 memcpy(sym, name, len);
5369 for (unsigned int i = lo; i <= hi; i++)
5371 sym[len + 0] = i / 10 + '0';
5372 sym[len + 1] = i % 10 + '0';
5373 Symbol* gsym = symtab->lookup(sym);
5374 bool refd = gsym != NULL && gsym->is_undefined();
5375 writing = writing || refd;
5378 if (this->contents_ == NULL)
5379 this->contents_ = new unsigned char[this->savres_max];
5381 section_size_type value = this->current_data_size();
5382 unsigned char* p = this->contents_ + value;
5384 p = write_ent(p, i);
5386 p = write_tail(p, i);
5387 section_size_type cur_size = p - this->contents_;
5388 this->set_current_data_size(cur_size);
5390 symtab->define_in_output_data(sym, NULL, Symbol_table::PREDEFINED,
5391 this, value, cur_size - value,
5392 elfcpp::STT_FUNC, elfcpp::STB_GLOBAL,
5393 elfcpp::STV_HIDDEN, 0, false, false);
5398 // Write out save/restore.
5400 template<int size, bool big_endian>
5402 Output_data_save_res<size, big_endian>::do_write(Output_file* of)
5404 const section_size_type off = this->offset();
5405 const section_size_type oview_size =
5406 convert_to_section_size_type(this->data_size());
5407 unsigned char* const oview = of->get_output_view(off, oview_size);
5408 memcpy(oview, this->contents_, oview_size);
5409 of->write_output_view(off, oview_size, oview);
5413 // Create the glink section.
5415 template<int size, bool big_endian>
5417 Target_powerpc<size, big_endian>::make_glink_section(Layout* layout)
5419 if (this->glink_ == NULL)
5421 this->glink_ = new Output_data_glink<size, big_endian>(this);
5422 this->glink_->add_eh_frame(layout);
5423 layout->add_output_section_data(".text", elfcpp::SHT_PROGBITS,
5424 elfcpp::SHF_ALLOC | elfcpp::SHF_EXECINSTR,
5425 this->glink_, ORDER_TEXT, false);
5429 // Create a PLT entry for a global symbol.
5431 template<int size, bool big_endian>
5433 Target_powerpc<size, big_endian>::make_plt_entry(Symbol_table* symtab,
5437 if (gsym->type() == elfcpp::STT_GNU_IFUNC
5438 && gsym->can_use_relative_reloc(false))
5440 if (this->iplt_ == NULL)
5441 this->make_iplt_section(symtab, layout);
5442 this->iplt_->add_ifunc_entry(gsym);
5446 if (this->plt_ == NULL)
5447 this->make_plt_section(symtab, layout);
5448 this->plt_->add_entry(gsym);
5452 // Make a PLT entry for a local STT_GNU_IFUNC symbol.
5454 template<int size, bool big_endian>
5456 Target_powerpc<size, big_endian>::make_local_ifunc_plt_entry(
5457 Symbol_table* symtab,
5459 Sized_relobj_file<size, big_endian>* relobj,
5462 if (this->iplt_ == NULL)
5463 this->make_iplt_section(symtab, layout);
5464 this->iplt_->add_local_ifunc_entry(relobj, r_sym);
5467 // Return the number of entries in the PLT.
5469 template<int size, bool big_endian>
5471 Target_powerpc<size, big_endian>::plt_entry_count() const
5473 if (this->plt_ == NULL)
5475 return this->plt_->entry_count();
5478 // Create a GOT entry for local dynamic __tls_get_addr calls.
5480 template<int size, bool big_endian>
5482 Target_powerpc<size, big_endian>::tlsld_got_offset(
5483 Symbol_table* symtab,
5485 Sized_relobj_file<size, big_endian>* object)
5487 if (this->tlsld_got_offset_ == -1U)
5489 gold_assert(symtab != NULL && layout != NULL && object != NULL);
5490 Reloc_section* rela_dyn = this->rela_dyn_section(layout);
5491 Output_data_got_powerpc<size, big_endian>* got
5492 = this->got_section(symtab, layout);
5493 unsigned int got_offset = got->add_constant_pair(0, 0);
5494 rela_dyn->add_local(object, 0, elfcpp::R_POWERPC_DTPMOD, got,
5496 this->tlsld_got_offset_ = got_offset;
5498 return this->tlsld_got_offset_;
5501 // Get the Reference_flags for a particular relocation.
5503 template<int size, bool big_endian>
5505 Target_powerpc<size, big_endian>::Scan::get_reference_flags(
5506 unsigned int r_type,
5507 const Target_powerpc* target)
5513 case elfcpp::R_POWERPC_NONE:
5514 case elfcpp::R_POWERPC_GNU_VTINHERIT:
5515 case elfcpp::R_POWERPC_GNU_VTENTRY:
5516 case elfcpp::R_PPC64_TOC:
5517 // No symbol reference.
5520 case elfcpp::R_PPC64_ADDR64:
5521 case elfcpp::R_PPC64_UADDR64:
5522 case elfcpp::R_POWERPC_ADDR32:
5523 case elfcpp::R_POWERPC_UADDR32:
5524 case elfcpp::R_POWERPC_ADDR16:
5525 case elfcpp::R_POWERPC_UADDR16:
5526 case elfcpp::R_POWERPC_ADDR16_LO:
5527 case elfcpp::R_POWERPC_ADDR16_HI:
5528 case elfcpp::R_POWERPC_ADDR16_HA:
5529 ref = Symbol::ABSOLUTE_REF;
5532 case elfcpp::R_POWERPC_ADDR24:
5533 case elfcpp::R_POWERPC_ADDR14:
5534 case elfcpp::R_POWERPC_ADDR14_BRTAKEN:
5535 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN:
5536 ref = Symbol::FUNCTION_CALL | Symbol::ABSOLUTE_REF;
5539 case elfcpp::R_PPC64_REL64:
5540 case elfcpp::R_POWERPC_REL32:
5541 case elfcpp::R_PPC_LOCAL24PC:
5542 case elfcpp::R_POWERPC_REL16:
5543 case elfcpp::R_POWERPC_REL16_LO:
5544 case elfcpp::R_POWERPC_REL16_HI:
5545 case elfcpp::R_POWERPC_REL16_HA:
5546 ref = Symbol::RELATIVE_REF;
5549 case elfcpp::R_POWERPC_REL24:
5550 case elfcpp::R_PPC_PLTREL24:
5551 case elfcpp::R_POWERPC_REL14:
5552 case elfcpp::R_POWERPC_REL14_BRTAKEN:
5553 case elfcpp::R_POWERPC_REL14_BRNTAKEN:
5554 ref = Symbol::FUNCTION_CALL | Symbol::RELATIVE_REF;
5557 case elfcpp::R_POWERPC_GOT16:
5558 case elfcpp::R_POWERPC_GOT16_LO:
5559 case elfcpp::R_POWERPC_GOT16_HI:
5560 case elfcpp::R_POWERPC_GOT16_HA:
5561 case elfcpp::R_PPC64_GOT16_DS:
5562 case elfcpp::R_PPC64_GOT16_LO_DS:
5563 case elfcpp::R_PPC64_TOC16:
5564 case elfcpp::R_PPC64_TOC16_LO:
5565 case elfcpp::R_PPC64_TOC16_HI:
5566 case elfcpp::R_PPC64_TOC16_HA:
5567 case elfcpp::R_PPC64_TOC16_DS:
5568 case elfcpp::R_PPC64_TOC16_LO_DS:
5569 ref = Symbol::RELATIVE_REF;
5572 case elfcpp::R_POWERPC_GOT_TPREL16:
5573 case elfcpp::R_POWERPC_TLS:
5574 ref = Symbol::TLS_REF;
5577 case elfcpp::R_POWERPC_COPY:
5578 case elfcpp::R_POWERPC_GLOB_DAT:
5579 case elfcpp::R_POWERPC_JMP_SLOT:
5580 case elfcpp::R_POWERPC_RELATIVE:
5581 case elfcpp::R_POWERPC_DTPMOD:
5583 // Not expected. We will give an error later.
5587 if (size == 64 && target->abiversion() < 2)
5588 ref |= Symbol::FUNC_DESC_ABI;
5592 // Report an unsupported relocation against a local symbol.
5594 template<int size, bool big_endian>
5596 Target_powerpc<size, big_endian>::Scan::unsupported_reloc_local(
5597 Sized_relobj_file<size, big_endian>* object,
5598 unsigned int r_type)
5600 gold_error(_("%s: unsupported reloc %u against local symbol"),
5601 object->name().c_str(), r_type);
5604 // We are about to emit a dynamic relocation of type R_TYPE. If the
5605 // dynamic linker does not support it, issue an error.
5607 template<int size, bool big_endian>
5609 Target_powerpc<size, big_endian>::Scan::check_non_pic(Relobj* object,
5610 unsigned int r_type)
5612 gold_assert(r_type != elfcpp::R_POWERPC_NONE);
5614 // These are the relocation types supported by glibc for both 32-bit
5615 // and 64-bit powerpc.
5618 case elfcpp::R_POWERPC_NONE:
5619 case elfcpp::R_POWERPC_RELATIVE:
5620 case elfcpp::R_POWERPC_GLOB_DAT:
5621 case elfcpp::R_POWERPC_DTPMOD:
5622 case elfcpp::R_POWERPC_DTPREL:
5623 case elfcpp::R_POWERPC_TPREL:
5624 case elfcpp::R_POWERPC_JMP_SLOT:
5625 case elfcpp::R_POWERPC_COPY:
5626 case elfcpp::R_POWERPC_IRELATIVE:
5627 case elfcpp::R_POWERPC_ADDR32:
5628 case elfcpp::R_POWERPC_UADDR32:
5629 case elfcpp::R_POWERPC_ADDR24:
5630 case elfcpp::R_POWERPC_ADDR16:
5631 case elfcpp::R_POWERPC_UADDR16:
5632 case elfcpp::R_POWERPC_ADDR16_LO:
5633 case elfcpp::R_POWERPC_ADDR16_HI:
5634 case elfcpp::R_POWERPC_ADDR16_HA:
5635 case elfcpp::R_POWERPC_ADDR14:
5636 case elfcpp::R_POWERPC_ADDR14_BRTAKEN:
5637 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN:
5638 case elfcpp::R_POWERPC_REL32:
5639 case elfcpp::R_POWERPC_REL24:
5640 case elfcpp::R_POWERPC_TPREL16:
5641 case elfcpp::R_POWERPC_TPREL16_LO:
5642 case elfcpp::R_POWERPC_TPREL16_HI:
5643 case elfcpp::R_POWERPC_TPREL16_HA:
5654 // These are the relocation types supported only on 64-bit.
5655 case elfcpp::R_PPC64_ADDR64:
5656 case elfcpp::R_PPC64_UADDR64:
5657 case elfcpp::R_PPC64_JMP_IREL:
5658 case elfcpp::R_PPC64_ADDR16_DS:
5659 case elfcpp::R_PPC64_ADDR16_LO_DS:
5660 case elfcpp::R_PPC64_ADDR16_HIGH:
5661 case elfcpp::R_PPC64_ADDR16_HIGHA:
5662 case elfcpp::R_PPC64_ADDR16_HIGHER:
5663 case elfcpp::R_PPC64_ADDR16_HIGHEST:
5664 case elfcpp::R_PPC64_ADDR16_HIGHERA:
5665 case elfcpp::R_PPC64_ADDR16_HIGHESTA:
5666 case elfcpp::R_PPC64_REL64:
5667 case elfcpp::R_POWERPC_ADDR30:
5668 case elfcpp::R_PPC64_TPREL16_DS:
5669 case elfcpp::R_PPC64_TPREL16_LO_DS:
5670 case elfcpp::R_PPC64_TPREL16_HIGH:
5671 case elfcpp::R_PPC64_TPREL16_HIGHA:
5672 case elfcpp::R_PPC64_TPREL16_HIGHER:
5673 case elfcpp::R_PPC64_TPREL16_HIGHEST:
5674 case elfcpp::R_PPC64_TPREL16_HIGHERA:
5675 case elfcpp::R_PPC64_TPREL16_HIGHESTA:
5686 // These are the relocation types supported only on 32-bit.
5687 // ??? glibc ld.so doesn't need to support these.
5688 case elfcpp::R_POWERPC_DTPREL16:
5689 case elfcpp::R_POWERPC_DTPREL16_LO:
5690 case elfcpp::R_POWERPC_DTPREL16_HI:
5691 case elfcpp::R_POWERPC_DTPREL16_HA:
5699 // This prevents us from issuing more than one error per reloc
5700 // section. But we can still wind up issuing more than one
5701 // error per object file.
5702 if (this->issued_non_pic_error_)
5704 gold_assert(parameters->options().output_is_position_independent());
5705 object->error(_("requires unsupported dynamic reloc; "
5706 "recompile with -fPIC"));
5707 this->issued_non_pic_error_ = true;
5711 // Return whether we need to make a PLT entry for a relocation of the
5712 // given type against a STT_GNU_IFUNC symbol.
5714 template<int size, bool big_endian>
5716 Target_powerpc<size, big_endian>::Scan::reloc_needs_plt_for_ifunc(
5717 Target_powerpc<size, big_endian>* target,
5718 Sized_relobj_file<size, big_endian>* object,
5719 unsigned int r_type,
5722 // In non-pic code any reference will resolve to the plt call stub
5723 // for the ifunc symbol.
5724 if ((size == 32 || target->abiversion() >= 2)
5725 && !parameters->options().output_is_position_independent())
5730 // Word size refs from data sections are OK, but don't need a PLT entry.
5731 case elfcpp::R_POWERPC_ADDR32:
5732 case elfcpp::R_POWERPC_UADDR32:
5737 case elfcpp::R_PPC64_ADDR64:
5738 case elfcpp::R_PPC64_UADDR64:
5743 // GOT refs are good, but also don't need a PLT entry.
5744 case elfcpp::R_POWERPC_GOT16:
5745 case elfcpp::R_POWERPC_GOT16_LO:
5746 case elfcpp::R_POWERPC_GOT16_HI:
5747 case elfcpp::R_POWERPC_GOT16_HA:
5748 case elfcpp::R_PPC64_GOT16_DS:
5749 case elfcpp::R_PPC64_GOT16_LO_DS:
5752 // Function calls are good, and these do need a PLT entry.
5753 case elfcpp::R_POWERPC_ADDR24:
5754 case elfcpp::R_POWERPC_ADDR14:
5755 case elfcpp::R_POWERPC_ADDR14_BRTAKEN:
5756 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN:
5757 case elfcpp::R_POWERPC_REL24:
5758 case elfcpp::R_PPC_PLTREL24:
5759 case elfcpp::R_POWERPC_REL14:
5760 case elfcpp::R_POWERPC_REL14_BRTAKEN:
5761 case elfcpp::R_POWERPC_REL14_BRNTAKEN:
5768 // Anything else is a problem.
5769 // If we are building a static executable, the libc startup function
5770 // responsible for applying indirect function relocations is going
5771 // to complain about the reloc type.
5772 // If we are building a dynamic executable, we will have a text
5773 // relocation. The dynamic loader will set the text segment
5774 // writable and non-executable to apply text relocations. So we'll
5775 // segfault when trying to run the indirection function to resolve
5778 gold_error(_("%s: unsupported reloc %u for IFUNC symbol"),
5779 object->name().c_str(), r_type);
5783 // Return TRUE iff INSN is one we expect on a _LO variety toc/got
5787 ok_lo_toc_insn(uint32_t insn, unsigned int r_type)
5789 return ((insn & (0x3f << 26)) == 12u << 26 /* addic */
5790 || (insn & (0x3f << 26)) == 14u << 26 /* addi */
5791 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
5792 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
5793 || (insn & (0x3f << 26)) == 36u << 26 /* stw */
5794 || (insn & (0x3f << 26)) == 38u << 26 /* stb */
5795 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
5796 || (insn & (0x3f << 26)) == 42u << 26 /* lha */
5797 || (insn & (0x3f << 26)) == 44u << 26 /* sth */
5798 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
5799 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
5800 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
5801 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
5802 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
5803 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
5804 || (insn & (0x3f << 26)) == 56u << 26 /* lq,lfq */
5805 || ((insn & (0x3f << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
5806 /* Exclude lfqu by testing reloc. If relocs are ever
5807 defined for the reduced D field in psq_lu then those
5808 will need testing too. */
5809 && r_type != elfcpp::R_PPC64_TOC16_LO
5810 && r_type != elfcpp::R_POWERPC_GOT16_LO)
5811 || ((insn & (0x3f << 26)) == 58u << 26 /* ld,lwa */
5813 || (insn & (0x3f << 26)) == 60u << 26 /* stfq */
5814 || ((insn & (0x3f << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
5815 /* Exclude stfqu. psq_stu as above for psq_lu. */
5816 && r_type != elfcpp::R_PPC64_TOC16_LO
5817 && r_type != elfcpp::R_POWERPC_GOT16_LO)
5818 || ((insn & (0x3f << 26)) == 62u << 26 /* std,stq */
5819 && (insn & 1) == 0));
5822 // Scan a relocation for a local symbol.
5824 template<int size, bool big_endian>
5826 Target_powerpc<size, big_endian>::Scan::local(
5827 Symbol_table* symtab,
5829 Target_powerpc<size, big_endian>* target,
5830 Sized_relobj_file<size, big_endian>* object,
5831 unsigned int data_shndx,
5832 Output_section* output_section,
5833 const elfcpp::Rela<size, big_endian>& reloc,
5834 unsigned int r_type,
5835 const elfcpp::Sym<size, big_endian>& lsym,
5838 this->maybe_skip_tls_get_addr_call(r_type, NULL);
5840 if ((size == 64 && r_type == elfcpp::R_PPC64_TLSGD)
5841 || (size == 32 && r_type == elfcpp::R_PPC_TLSGD))
5843 this->expect_tls_get_addr_call();
5844 const tls::Tls_optimization tls_type = target->optimize_tls_gd(true);
5845 if (tls_type != tls::TLSOPT_NONE)
5846 this->skip_next_tls_get_addr_call();
5848 else if ((size == 64 && r_type == elfcpp::R_PPC64_TLSLD)
5849 || (size == 32 && r_type == elfcpp::R_PPC_TLSLD))
5851 this->expect_tls_get_addr_call();
5852 const tls::Tls_optimization tls_type = target->optimize_tls_ld();
5853 if (tls_type != tls::TLSOPT_NONE)
5854 this->skip_next_tls_get_addr_call();
5857 Powerpc_relobj<size, big_endian>* ppc_object
5858 = static_cast<Powerpc_relobj<size, big_endian>*>(object);
5863 && data_shndx == ppc_object->opd_shndx()
5864 && r_type == elfcpp::R_PPC64_ADDR64)
5865 ppc_object->set_opd_discard(reloc.get_r_offset());
5869 // A local STT_GNU_IFUNC symbol may require a PLT entry.
5870 bool is_ifunc = lsym.get_st_type() == elfcpp::STT_GNU_IFUNC;
5871 if (is_ifunc && this->reloc_needs_plt_for_ifunc(target, object, r_type, true))
5873 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
5874 target->push_branch(ppc_object, data_shndx, reloc.get_r_offset(),
5875 r_type, r_sym, reloc.get_r_addend());
5876 target->make_local_ifunc_plt_entry(symtab, layout, object, r_sym);
5881 case elfcpp::R_POWERPC_NONE:
5882 case elfcpp::R_POWERPC_GNU_VTINHERIT:
5883 case elfcpp::R_POWERPC_GNU_VTENTRY:
5884 case elfcpp::R_PPC64_TOCSAVE:
5885 case elfcpp::R_POWERPC_TLS:
5886 case elfcpp::R_PPC64_ENTRY:
5889 case elfcpp::R_PPC64_TOC:
5891 Output_data_got_powerpc<size, big_endian>* got
5892 = target->got_section(symtab, layout);
5893 if (parameters->options().output_is_position_independent())
5895 Address off = reloc.get_r_offset();
5897 && target->abiversion() < 2
5898 && data_shndx == ppc_object->opd_shndx()
5899 && ppc_object->get_opd_discard(off - 8))
5902 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
5903 Powerpc_relobj<size, big_endian>* symobj = ppc_object;
5904 rela_dyn->add_output_section_relative(got->output_section(),
5905 elfcpp::R_POWERPC_RELATIVE,
5907 object, data_shndx, off,
5908 symobj->toc_base_offset());
5913 case elfcpp::R_PPC64_ADDR64:
5914 case elfcpp::R_PPC64_UADDR64:
5915 case elfcpp::R_POWERPC_ADDR32:
5916 case elfcpp::R_POWERPC_UADDR32:
5917 case elfcpp::R_POWERPC_ADDR24:
5918 case elfcpp::R_POWERPC_ADDR16:
5919 case elfcpp::R_POWERPC_ADDR16_LO:
5920 case elfcpp::R_POWERPC_ADDR16_HI:
5921 case elfcpp::R_POWERPC_ADDR16_HA:
5922 case elfcpp::R_POWERPC_UADDR16:
5923 case elfcpp::R_PPC64_ADDR16_HIGH:
5924 case elfcpp::R_PPC64_ADDR16_HIGHA:
5925 case elfcpp::R_PPC64_ADDR16_HIGHER:
5926 case elfcpp::R_PPC64_ADDR16_HIGHERA:
5927 case elfcpp::R_PPC64_ADDR16_HIGHEST:
5928 case elfcpp::R_PPC64_ADDR16_HIGHESTA:
5929 case elfcpp::R_PPC64_ADDR16_DS:
5930 case elfcpp::R_PPC64_ADDR16_LO_DS:
5931 case elfcpp::R_POWERPC_ADDR14:
5932 case elfcpp::R_POWERPC_ADDR14_BRTAKEN:
5933 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN:
5934 // If building a shared library (or a position-independent
5935 // executable), we need to create a dynamic relocation for
5937 if (parameters->options().output_is_position_independent()
5938 || (size == 64 && is_ifunc && target->abiversion() < 2))
5940 Reloc_section* rela_dyn = target->rela_dyn_section(symtab, layout,
5942 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
5943 if ((size == 32 && r_type == elfcpp::R_POWERPC_ADDR32)
5944 || (size == 64 && r_type == elfcpp::R_PPC64_ADDR64))
5946 unsigned int dynrel = (is_ifunc ? elfcpp::R_POWERPC_IRELATIVE
5947 : elfcpp::R_POWERPC_RELATIVE);
5948 rela_dyn->add_local_relative(object, r_sym, dynrel,
5949 output_section, data_shndx,
5950 reloc.get_r_offset(),
5951 reloc.get_r_addend(), false);
5953 else if (lsym.get_st_type() != elfcpp::STT_SECTION)
5955 check_non_pic(object, r_type);
5956 rela_dyn->add_local(object, r_sym, r_type, output_section,
5957 data_shndx, reloc.get_r_offset(),
5958 reloc.get_r_addend());
5962 gold_assert(lsym.get_st_value() == 0);
5963 unsigned int shndx = lsym.get_st_shndx();
5965 shndx = object->adjust_sym_shndx(r_sym, shndx,
5968 object->error(_("section symbol %u has bad shndx %u"),
5971 rela_dyn->add_local_section(object, shndx, r_type,
5972 output_section, data_shndx,
5973 reloc.get_r_offset());
5978 case elfcpp::R_POWERPC_REL24:
5979 case elfcpp::R_PPC_PLTREL24:
5980 case elfcpp::R_PPC_LOCAL24PC:
5981 case elfcpp::R_POWERPC_REL14:
5982 case elfcpp::R_POWERPC_REL14_BRTAKEN:
5983 case elfcpp::R_POWERPC_REL14_BRNTAKEN:
5986 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
5987 target->push_branch(ppc_object, data_shndx, reloc.get_r_offset(),
5988 r_type, r_sym, reloc.get_r_addend());
5992 case elfcpp::R_PPC64_REL64:
5993 case elfcpp::R_POWERPC_REL32:
5994 case elfcpp::R_POWERPC_REL16:
5995 case elfcpp::R_POWERPC_REL16_LO:
5996 case elfcpp::R_POWERPC_REL16_HI:
5997 case elfcpp::R_POWERPC_REL16_HA:
5998 case elfcpp::R_POWERPC_REL16DX_HA:
5999 case elfcpp::R_POWERPC_SECTOFF:
6000 case elfcpp::R_POWERPC_SECTOFF_LO:
6001 case elfcpp::R_POWERPC_SECTOFF_HI:
6002 case elfcpp::R_POWERPC_SECTOFF_HA:
6003 case elfcpp::R_PPC64_SECTOFF_DS:
6004 case elfcpp::R_PPC64_SECTOFF_LO_DS:
6005 case elfcpp::R_POWERPC_TPREL16:
6006 case elfcpp::R_POWERPC_TPREL16_LO:
6007 case elfcpp::R_POWERPC_TPREL16_HI:
6008 case elfcpp::R_POWERPC_TPREL16_HA:
6009 case elfcpp::R_PPC64_TPREL16_DS:
6010 case elfcpp::R_PPC64_TPREL16_LO_DS:
6011 case elfcpp::R_PPC64_TPREL16_HIGH:
6012 case elfcpp::R_PPC64_TPREL16_HIGHA:
6013 case elfcpp::R_PPC64_TPREL16_HIGHER:
6014 case elfcpp::R_PPC64_TPREL16_HIGHERA:
6015 case elfcpp::R_PPC64_TPREL16_HIGHEST:
6016 case elfcpp::R_PPC64_TPREL16_HIGHESTA:
6017 case elfcpp::R_POWERPC_DTPREL16:
6018 case elfcpp::R_POWERPC_DTPREL16_LO:
6019 case elfcpp::R_POWERPC_DTPREL16_HI:
6020 case elfcpp::R_POWERPC_DTPREL16_HA:
6021 case elfcpp::R_PPC64_DTPREL16_DS:
6022 case elfcpp::R_PPC64_DTPREL16_LO_DS:
6023 case elfcpp::R_PPC64_DTPREL16_HIGH:
6024 case elfcpp::R_PPC64_DTPREL16_HIGHA:
6025 case elfcpp::R_PPC64_DTPREL16_HIGHER:
6026 case elfcpp::R_PPC64_DTPREL16_HIGHERA:
6027 case elfcpp::R_PPC64_DTPREL16_HIGHEST:
6028 case elfcpp::R_PPC64_DTPREL16_HIGHESTA:
6029 case elfcpp::R_PPC64_TLSGD:
6030 case elfcpp::R_PPC64_TLSLD:
6031 case elfcpp::R_PPC64_ADDR64_LOCAL:
6034 case elfcpp::R_POWERPC_GOT16:
6035 case elfcpp::R_POWERPC_GOT16_LO:
6036 case elfcpp::R_POWERPC_GOT16_HI:
6037 case elfcpp::R_POWERPC_GOT16_HA:
6038 case elfcpp::R_PPC64_GOT16_DS:
6039 case elfcpp::R_PPC64_GOT16_LO_DS:
6041 // The symbol requires a GOT entry.
6042 Output_data_got_powerpc<size, big_endian>* got
6043 = target->got_section(symtab, layout);
6044 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
6046 if (!parameters->options().output_is_position_independent())
6049 && (size == 32 || target->abiversion() >= 2))
6050 got->add_local_plt(object, r_sym, GOT_TYPE_STANDARD);
6052 got->add_local(object, r_sym, GOT_TYPE_STANDARD);
6054 else if (!object->local_has_got_offset(r_sym, GOT_TYPE_STANDARD))
6056 // If we are generating a shared object or a pie, this
6057 // symbol's GOT entry will be set by a dynamic relocation.
6059 off = got->add_constant(0);
6060 object->set_local_got_offset(r_sym, GOT_TYPE_STANDARD, off);
6062 Reloc_section* rela_dyn = target->rela_dyn_section(symtab, layout,
6064 unsigned int dynrel = (is_ifunc ? elfcpp::R_POWERPC_IRELATIVE
6065 : elfcpp::R_POWERPC_RELATIVE);
6066 rela_dyn->add_local_relative(object, r_sym, dynrel,
6067 got, off, 0, false);
6072 case elfcpp::R_PPC64_TOC16:
6073 case elfcpp::R_PPC64_TOC16_LO:
6074 case elfcpp::R_PPC64_TOC16_HI:
6075 case elfcpp::R_PPC64_TOC16_HA:
6076 case elfcpp::R_PPC64_TOC16_DS:
6077 case elfcpp::R_PPC64_TOC16_LO_DS:
6078 // We need a GOT section.
6079 target->got_section(symtab, layout);
6082 case elfcpp::R_POWERPC_GOT_TLSGD16:
6083 case elfcpp::R_POWERPC_GOT_TLSGD16_LO:
6084 case elfcpp::R_POWERPC_GOT_TLSGD16_HI:
6085 case elfcpp::R_POWERPC_GOT_TLSGD16_HA:
6087 const tls::Tls_optimization tls_type = target->optimize_tls_gd(true);
6088 if (tls_type == tls::TLSOPT_NONE)
6090 Output_data_got_powerpc<size, big_endian>* got
6091 = target->got_section(symtab, layout);
6092 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
6093 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
6094 got->add_local_tls_pair(object, r_sym, GOT_TYPE_TLSGD,
6095 rela_dyn, elfcpp::R_POWERPC_DTPMOD);
6097 else if (tls_type == tls::TLSOPT_TO_LE)
6099 // no GOT relocs needed for Local Exec.
6106 case elfcpp::R_POWERPC_GOT_TLSLD16:
6107 case elfcpp::R_POWERPC_GOT_TLSLD16_LO:
6108 case elfcpp::R_POWERPC_GOT_TLSLD16_HI:
6109 case elfcpp::R_POWERPC_GOT_TLSLD16_HA:
6111 const tls::Tls_optimization tls_type = target->optimize_tls_ld();
6112 if (tls_type == tls::TLSOPT_NONE)
6113 target->tlsld_got_offset(symtab, layout, object);
6114 else if (tls_type == tls::TLSOPT_TO_LE)
6116 // no GOT relocs needed for Local Exec.
6117 if (parameters->options().emit_relocs())
6119 Output_section* os = layout->tls_segment()->first_section();
6120 gold_assert(os != NULL);
6121 os->set_needs_symtab_index();
6129 case elfcpp::R_POWERPC_GOT_DTPREL16:
6130 case elfcpp::R_POWERPC_GOT_DTPREL16_LO:
6131 case elfcpp::R_POWERPC_GOT_DTPREL16_HI:
6132 case elfcpp::R_POWERPC_GOT_DTPREL16_HA:
6134 Output_data_got_powerpc<size, big_endian>* got
6135 = target->got_section(symtab, layout);
6136 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
6137 got->add_local_tls(object, r_sym, GOT_TYPE_DTPREL);
6141 case elfcpp::R_POWERPC_GOT_TPREL16:
6142 case elfcpp::R_POWERPC_GOT_TPREL16_LO:
6143 case elfcpp::R_POWERPC_GOT_TPREL16_HI:
6144 case elfcpp::R_POWERPC_GOT_TPREL16_HA:
6146 const tls::Tls_optimization tls_type = target->optimize_tls_ie(true);
6147 if (tls_type == tls::TLSOPT_NONE)
6149 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
6150 if (!object->local_has_got_offset(r_sym, GOT_TYPE_TPREL))
6152 Output_data_got_powerpc<size, big_endian>* got
6153 = target->got_section(symtab, layout);
6154 unsigned int off = got->add_constant(0);
6155 object->set_local_got_offset(r_sym, GOT_TYPE_TPREL, off);
6157 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
6158 rela_dyn->add_symbolless_local_addend(object, r_sym,
6159 elfcpp::R_POWERPC_TPREL,
6163 else if (tls_type == tls::TLSOPT_TO_LE)
6165 // no GOT relocs needed for Local Exec.
6173 unsupported_reloc_local(object, r_type);
6178 && parameters->options().toc_optimize())
6180 if (data_shndx == ppc_object->toc_shndx())
6183 if (r_type != elfcpp::R_PPC64_ADDR64
6184 || (is_ifunc && target->abiversion() < 2))
6186 else if (parameters->options().output_is_position_independent())
6192 unsigned int shndx = lsym.get_st_shndx();
6193 if (shndx >= elfcpp::SHN_LORESERVE
6194 && shndx != elfcpp::SHN_XINDEX)
6199 ppc_object->set_no_toc_opt(reloc.get_r_offset());
6202 enum {no_check, check_lo, check_ha} insn_check;
6206 insn_check = no_check;
6209 case elfcpp::R_POWERPC_GOT_TLSLD16_HA:
6210 case elfcpp::R_POWERPC_GOT_TLSGD16_HA:
6211 case elfcpp::R_POWERPC_GOT_TPREL16_HA:
6212 case elfcpp::R_POWERPC_GOT_DTPREL16_HA:
6213 case elfcpp::R_POWERPC_GOT16_HA:
6214 case elfcpp::R_PPC64_TOC16_HA:
6215 insn_check = check_ha;
6218 case elfcpp::R_POWERPC_GOT_TLSLD16_LO:
6219 case elfcpp::R_POWERPC_GOT_TLSGD16_LO:
6220 case elfcpp::R_POWERPC_GOT_TPREL16_LO:
6221 case elfcpp::R_POWERPC_GOT_DTPREL16_LO:
6222 case elfcpp::R_POWERPC_GOT16_LO:
6223 case elfcpp::R_PPC64_GOT16_LO_DS:
6224 case elfcpp::R_PPC64_TOC16_LO:
6225 case elfcpp::R_PPC64_TOC16_LO_DS:
6226 insn_check = check_lo;
6230 section_size_type slen;
6231 const unsigned char* view = NULL;
6232 if (insn_check != no_check)
6234 view = ppc_object->section_contents(data_shndx, &slen, false);
6235 section_size_type off =
6236 convert_to_section_size_type(reloc.get_r_offset()) & -4;
6239 uint32_t insn = elfcpp::Swap<32, big_endian>::readval(view + off);
6240 if (insn_check == check_lo
6241 ? !ok_lo_toc_insn(insn, r_type)
6242 : ((insn & ((0x3f << 26) | 0x1f << 16))
6243 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
6245 ppc_object->set_no_toc_opt();
6246 gold_warning(_("%s: toc optimization is not supported "
6247 "for %#08x instruction"),
6248 ppc_object->name().c_str(), insn);
6257 case elfcpp::R_PPC64_TOC16:
6258 case elfcpp::R_PPC64_TOC16_LO:
6259 case elfcpp::R_PPC64_TOC16_HI:
6260 case elfcpp::R_PPC64_TOC16_HA:
6261 case elfcpp::R_PPC64_TOC16_DS:
6262 case elfcpp::R_PPC64_TOC16_LO_DS:
6263 unsigned int shndx = lsym.get_st_shndx();
6264 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
6266 shndx = ppc_object->adjust_sym_shndx(r_sym, shndx, &is_ordinary);
6267 if (is_ordinary && shndx == ppc_object->toc_shndx())
6269 Address dst_off = lsym.get_st_value() + reloc.get_r_offset();
6270 if (dst_off < ppc_object->section_size(shndx))
6273 if (r_type == elfcpp::R_PPC64_TOC16_HA)
6275 else if (r_type == elfcpp::R_PPC64_TOC16_LO_DS)
6277 // Need to check that the insn is a ld
6279 view = ppc_object->section_contents(data_shndx,
6282 section_size_type off =
6283 (convert_to_section_size_type(reloc.get_r_offset())
6284 + (big_endian ? -2 : 3));
6286 && (view[off] & (0x3f << 2)) == 58u << 2)
6290 ppc_object->set_no_toc_opt(dst_off);
6301 case elfcpp::R_POWERPC_REL32:
6302 if (ppc_object->got2_shndx() != 0
6303 && parameters->options().output_is_position_independent())
6305 unsigned int shndx = lsym.get_st_shndx();
6306 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
6308 shndx = ppc_object->adjust_sym_shndx(r_sym, shndx, &is_ordinary);
6309 if (is_ordinary && shndx == ppc_object->got2_shndx()
6310 && (ppc_object->section_flags(data_shndx)
6311 & elfcpp::SHF_EXECINSTR) != 0)
6312 gold_error(_("%s: unsupported -mbss-plt code"),
6313 ppc_object->name().c_str());
6323 case elfcpp::R_POWERPC_GOT_TLSLD16:
6324 case elfcpp::R_POWERPC_GOT_TLSGD16:
6325 case elfcpp::R_POWERPC_GOT_TPREL16:
6326 case elfcpp::R_POWERPC_GOT_DTPREL16:
6327 case elfcpp::R_POWERPC_GOT16:
6328 case elfcpp::R_PPC64_GOT16_DS:
6329 case elfcpp::R_PPC64_TOC16:
6330 case elfcpp::R_PPC64_TOC16_DS:
6331 ppc_object->set_has_small_toc_reloc();
6337 // Report an unsupported relocation against a global symbol.
6339 template<int size, bool big_endian>
6341 Target_powerpc<size, big_endian>::Scan::unsupported_reloc_global(
6342 Sized_relobj_file<size, big_endian>* object,
6343 unsigned int r_type,
6346 gold_error(_("%s: unsupported reloc %u against global symbol %s"),
6347 object->name().c_str(), r_type, gsym->demangled_name().c_str());
6350 // Scan a relocation for a global symbol.
6352 template<int size, bool big_endian>
6354 Target_powerpc<size, big_endian>::Scan::global(
6355 Symbol_table* symtab,
6357 Target_powerpc<size, big_endian>* target,
6358 Sized_relobj_file<size, big_endian>* object,
6359 unsigned int data_shndx,
6360 Output_section* output_section,
6361 const elfcpp::Rela<size, big_endian>& reloc,
6362 unsigned int r_type,
6365 if (this->maybe_skip_tls_get_addr_call(r_type, gsym) == Track_tls::SKIP)
6368 if ((size == 64 && r_type == elfcpp::R_PPC64_TLSGD)
6369 || (size == 32 && r_type == elfcpp::R_PPC_TLSGD))
6371 this->expect_tls_get_addr_call();
6372 const bool final = gsym->final_value_is_known();
6373 const tls::Tls_optimization tls_type = target->optimize_tls_gd(final);
6374 if (tls_type != tls::TLSOPT_NONE)
6375 this->skip_next_tls_get_addr_call();
6377 else if ((size == 64 && r_type == elfcpp::R_PPC64_TLSLD)
6378 || (size == 32 && r_type == elfcpp::R_PPC_TLSLD))
6380 this->expect_tls_get_addr_call();
6381 const tls::Tls_optimization tls_type = target->optimize_tls_ld();
6382 if (tls_type != tls::TLSOPT_NONE)
6383 this->skip_next_tls_get_addr_call();
6386 Powerpc_relobj<size, big_endian>* ppc_object
6387 = static_cast<Powerpc_relobj<size, big_endian>*>(object);
6389 // A STT_GNU_IFUNC symbol may require a PLT entry.
6390 bool is_ifunc = gsym->type() == elfcpp::STT_GNU_IFUNC;
6391 bool pushed_ifunc = false;
6392 if (is_ifunc && this->reloc_needs_plt_for_ifunc(target, object, r_type, true))
6394 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
6395 target->push_branch(ppc_object, data_shndx, reloc.get_r_offset(),
6396 r_type, r_sym, reloc.get_r_addend());
6397 target->make_plt_entry(symtab, layout, gsym);
6398 pushed_ifunc = true;
6403 case elfcpp::R_POWERPC_NONE:
6404 case elfcpp::R_POWERPC_GNU_VTINHERIT:
6405 case elfcpp::R_POWERPC_GNU_VTENTRY:
6406 case elfcpp::R_PPC_LOCAL24PC:
6407 case elfcpp::R_POWERPC_TLS:
6408 case elfcpp::R_PPC64_ENTRY:
6411 case elfcpp::R_PPC64_TOC:
6413 Output_data_got_powerpc<size, big_endian>* got
6414 = target->got_section(symtab, layout);
6415 if (parameters->options().output_is_position_independent())
6417 Address off = reloc.get_r_offset();
6419 && data_shndx == ppc_object->opd_shndx()
6420 && ppc_object->get_opd_discard(off - 8))
6423 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
6424 Powerpc_relobj<size, big_endian>* symobj = ppc_object;
6425 if (data_shndx != ppc_object->opd_shndx())
6426 symobj = static_cast
6427 <Powerpc_relobj<size, big_endian>*>(gsym->object());
6428 rela_dyn->add_output_section_relative(got->output_section(),
6429 elfcpp::R_POWERPC_RELATIVE,
6431 object, data_shndx, off,
6432 symobj->toc_base_offset());
6437 case elfcpp::R_PPC64_ADDR64:
6439 && target->abiversion() < 2
6440 && data_shndx == ppc_object->opd_shndx()
6441 && (gsym->is_defined_in_discarded_section()
6442 || gsym->object() != object))
6444 ppc_object->set_opd_discard(reloc.get_r_offset());
6448 case elfcpp::R_PPC64_UADDR64:
6449 case elfcpp::R_POWERPC_ADDR32:
6450 case elfcpp::R_POWERPC_UADDR32:
6451 case elfcpp::R_POWERPC_ADDR24:
6452 case elfcpp::R_POWERPC_ADDR16:
6453 case elfcpp::R_POWERPC_ADDR16_LO:
6454 case elfcpp::R_POWERPC_ADDR16_HI:
6455 case elfcpp::R_POWERPC_ADDR16_HA:
6456 case elfcpp::R_POWERPC_UADDR16:
6457 case elfcpp::R_PPC64_ADDR16_HIGH:
6458 case elfcpp::R_PPC64_ADDR16_HIGHA:
6459 case elfcpp::R_PPC64_ADDR16_HIGHER:
6460 case elfcpp::R_PPC64_ADDR16_HIGHERA:
6461 case elfcpp::R_PPC64_ADDR16_HIGHEST:
6462 case elfcpp::R_PPC64_ADDR16_HIGHESTA:
6463 case elfcpp::R_PPC64_ADDR16_DS:
6464 case elfcpp::R_PPC64_ADDR16_LO_DS:
6465 case elfcpp::R_POWERPC_ADDR14:
6466 case elfcpp::R_POWERPC_ADDR14_BRTAKEN:
6467 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN:
6469 // Make a PLT entry if necessary.
6470 if (gsym->needs_plt_entry())
6472 // Since this is not a PC-relative relocation, we may be
6473 // taking the address of a function. In that case we need to
6474 // set the entry in the dynamic symbol table to the address of
6475 // the PLT call stub.
6476 bool need_ifunc_plt = false;
6477 if ((size == 32 || target->abiversion() >= 2)
6478 && gsym->is_from_dynobj()
6479 && !parameters->options().output_is_position_independent())
6481 gsym->set_needs_dynsym_value();
6482 need_ifunc_plt = true;
6484 if (!is_ifunc || (!pushed_ifunc && need_ifunc_plt))
6486 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
6487 target->push_branch(ppc_object, data_shndx,
6488 reloc.get_r_offset(), r_type, r_sym,
6489 reloc.get_r_addend());
6490 target->make_plt_entry(symtab, layout, gsym);
6493 // Make a dynamic relocation if necessary.
6494 if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type, target))
6495 || (size == 64 && is_ifunc && target->abiversion() < 2))
6497 if (!parameters->options().output_is_position_independent()
6498 && gsym->may_need_copy_reloc())
6500 target->copy_reloc(symtab, layout, object,
6501 data_shndx, output_section, gsym, reloc);
6503 else if ((((size == 32
6504 && r_type == elfcpp::R_POWERPC_ADDR32)
6506 && r_type == elfcpp::R_PPC64_ADDR64
6507 && target->abiversion() >= 2))
6508 && gsym->can_use_relative_reloc(false)
6509 && !(gsym->visibility() == elfcpp::STV_PROTECTED
6510 && parameters->options().shared()))
6512 && r_type == elfcpp::R_PPC64_ADDR64
6513 && target->abiversion() < 2
6514 && (gsym->can_use_relative_reloc(false)
6515 || data_shndx == ppc_object->opd_shndx())))
6517 Reloc_section* rela_dyn
6518 = target->rela_dyn_section(symtab, layout, is_ifunc);
6519 unsigned int dynrel = (is_ifunc ? elfcpp::R_POWERPC_IRELATIVE
6520 : elfcpp::R_POWERPC_RELATIVE);
6521 rela_dyn->add_symbolless_global_addend(
6522 gsym, dynrel, output_section, object, data_shndx,
6523 reloc.get_r_offset(), reloc.get_r_addend());
6527 Reloc_section* rela_dyn
6528 = target->rela_dyn_section(symtab, layout, is_ifunc);
6529 check_non_pic(object, r_type);
6530 rela_dyn->add_global(gsym, r_type, output_section,
6532 reloc.get_r_offset(),
6533 reloc.get_r_addend());
6536 && parameters->options().toc_optimize()
6537 && data_shndx == ppc_object->toc_shndx())
6538 ppc_object->set_no_toc_opt(reloc.get_r_offset());
6544 case elfcpp::R_PPC_PLTREL24:
6545 case elfcpp::R_POWERPC_REL24:
6548 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
6549 target->push_branch(ppc_object, data_shndx, reloc.get_r_offset(),
6550 r_type, r_sym, reloc.get_r_addend());
6551 if (gsym->needs_plt_entry()
6552 || (!gsym->final_value_is_known()
6553 && (gsym->is_undefined()
6554 || gsym->is_from_dynobj()
6555 || gsym->is_preemptible())))
6556 target->make_plt_entry(symtab, layout, gsym);
6560 case elfcpp::R_PPC64_REL64:
6561 case elfcpp::R_POWERPC_REL32:
6562 // Make a dynamic relocation if necessary.
6563 if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type, target)))
6565 if (!parameters->options().output_is_position_independent()
6566 && gsym->may_need_copy_reloc())
6568 target->copy_reloc(symtab, layout, object,
6569 data_shndx, output_section, gsym,
6574 Reloc_section* rela_dyn
6575 = target->rela_dyn_section(symtab, layout, is_ifunc);
6576 check_non_pic(object, r_type);
6577 rela_dyn->add_global(gsym, r_type, output_section, object,
6578 data_shndx, reloc.get_r_offset(),
6579 reloc.get_r_addend());
6584 case elfcpp::R_POWERPC_REL14:
6585 case elfcpp::R_POWERPC_REL14_BRTAKEN:
6586 case elfcpp::R_POWERPC_REL14_BRNTAKEN:
6589 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
6590 target->push_branch(ppc_object, data_shndx, reloc.get_r_offset(),
6591 r_type, r_sym, reloc.get_r_addend());
6595 case elfcpp::R_POWERPC_REL16:
6596 case elfcpp::R_POWERPC_REL16_LO:
6597 case elfcpp::R_POWERPC_REL16_HI:
6598 case elfcpp::R_POWERPC_REL16_HA:
6599 case elfcpp::R_POWERPC_REL16DX_HA:
6600 case elfcpp::R_POWERPC_SECTOFF:
6601 case elfcpp::R_POWERPC_SECTOFF_LO:
6602 case elfcpp::R_POWERPC_SECTOFF_HI:
6603 case elfcpp::R_POWERPC_SECTOFF_HA:
6604 case elfcpp::R_PPC64_SECTOFF_DS:
6605 case elfcpp::R_PPC64_SECTOFF_LO_DS:
6606 case elfcpp::R_POWERPC_TPREL16:
6607 case elfcpp::R_POWERPC_TPREL16_LO:
6608 case elfcpp::R_POWERPC_TPREL16_HI:
6609 case elfcpp::R_POWERPC_TPREL16_HA:
6610 case elfcpp::R_PPC64_TPREL16_DS:
6611 case elfcpp::R_PPC64_TPREL16_LO_DS:
6612 case elfcpp::R_PPC64_TPREL16_HIGH:
6613 case elfcpp::R_PPC64_TPREL16_HIGHA:
6614 case elfcpp::R_PPC64_TPREL16_HIGHER:
6615 case elfcpp::R_PPC64_TPREL16_HIGHERA:
6616 case elfcpp::R_PPC64_TPREL16_HIGHEST:
6617 case elfcpp::R_PPC64_TPREL16_HIGHESTA:
6618 case elfcpp::R_POWERPC_DTPREL16:
6619 case elfcpp::R_POWERPC_DTPREL16_LO:
6620 case elfcpp::R_POWERPC_DTPREL16_HI:
6621 case elfcpp::R_POWERPC_DTPREL16_HA:
6622 case elfcpp::R_PPC64_DTPREL16_DS:
6623 case elfcpp::R_PPC64_DTPREL16_LO_DS:
6624 case elfcpp::R_PPC64_DTPREL16_HIGH:
6625 case elfcpp::R_PPC64_DTPREL16_HIGHA:
6626 case elfcpp::R_PPC64_DTPREL16_HIGHER:
6627 case elfcpp::R_PPC64_DTPREL16_HIGHERA:
6628 case elfcpp::R_PPC64_DTPREL16_HIGHEST:
6629 case elfcpp::R_PPC64_DTPREL16_HIGHESTA:
6630 case elfcpp::R_PPC64_TLSGD:
6631 case elfcpp::R_PPC64_TLSLD:
6632 case elfcpp::R_PPC64_ADDR64_LOCAL:
6635 case elfcpp::R_POWERPC_GOT16:
6636 case elfcpp::R_POWERPC_GOT16_LO:
6637 case elfcpp::R_POWERPC_GOT16_HI:
6638 case elfcpp::R_POWERPC_GOT16_HA:
6639 case elfcpp::R_PPC64_GOT16_DS:
6640 case elfcpp::R_PPC64_GOT16_LO_DS:
6642 // The symbol requires a GOT entry.
6643 Output_data_got_powerpc<size, big_endian>* got;
6645 got = target->got_section(symtab, layout);
6646 if (gsym->final_value_is_known())
6649 && (size == 32 || target->abiversion() >= 2))
6650 got->add_global_plt(gsym, GOT_TYPE_STANDARD);
6652 got->add_global(gsym, GOT_TYPE_STANDARD);
6654 else if (!gsym->has_got_offset(GOT_TYPE_STANDARD))
6656 // If we are generating a shared object or a pie, this
6657 // symbol's GOT entry will be set by a dynamic relocation.
6658 unsigned int off = got->add_constant(0);
6659 gsym->set_got_offset(GOT_TYPE_STANDARD, off);
6661 Reloc_section* rela_dyn
6662 = target->rela_dyn_section(symtab, layout, is_ifunc);
6664 if (gsym->can_use_relative_reloc(false)
6666 || target->abiversion() >= 2)
6667 && gsym->visibility() == elfcpp::STV_PROTECTED
6668 && parameters->options().shared()))
6670 unsigned int dynrel = (is_ifunc ? elfcpp::R_POWERPC_IRELATIVE
6671 : elfcpp::R_POWERPC_RELATIVE);
6672 rela_dyn->add_global_relative(gsym, dynrel, got, off, 0, false);
6676 unsigned int dynrel = elfcpp::R_POWERPC_GLOB_DAT;
6677 rela_dyn->add_global(gsym, dynrel, got, off, 0);
6683 case elfcpp::R_PPC64_TOC16:
6684 case elfcpp::R_PPC64_TOC16_LO:
6685 case elfcpp::R_PPC64_TOC16_HI:
6686 case elfcpp::R_PPC64_TOC16_HA:
6687 case elfcpp::R_PPC64_TOC16_DS:
6688 case elfcpp::R_PPC64_TOC16_LO_DS:
6689 // We need a GOT section.
6690 target->got_section(symtab, layout);
6693 case elfcpp::R_POWERPC_GOT_TLSGD16:
6694 case elfcpp::R_POWERPC_GOT_TLSGD16_LO:
6695 case elfcpp::R_POWERPC_GOT_TLSGD16_HI:
6696 case elfcpp::R_POWERPC_GOT_TLSGD16_HA:
6698 const bool final = gsym->final_value_is_known();
6699 const tls::Tls_optimization tls_type = target->optimize_tls_gd(final);
6700 if (tls_type == tls::TLSOPT_NONE)
6702 Output_data_got_powerpc<size, big_endian>* got
6703 = target->got_section(symtab, layout);
6704 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
6705 got->add_global_pair_with_rel(gsym, GOT_TYPE_TLSGD, rela_dyn,
6706 elfcpp::R_POWERPC_DTPMOD,
6707 elfcpp::R_POWERPC_DTPREL);
6709 else if (tls_type == tls::TLSOPT_TO_IE)
6711 if (!gsym->has_got_offset(GOT_TYPE_TPREL))
6713 Output_data_got_powerpc<size, big_endian>* got
6714 = target->got_section(symtab, layout);
6715 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
6716 if (gsym->is_undefined()
6717 || gsym->is_from_dynobj())
6719 got->add_global_with_rel(gsym, GOT_TYPE_TPREL, rela_dyn,
6720 elfcpp::R_POWERPC_TPREL);
6724 unsigned int off = got->add_constant(0);
6725 gsym->set_got_offset(GOT_TYPE_TPREL, off);
6726 unsigned int dynrel = elfcpp::R_POWERPC_TPREL;
6727 rela_dyn->add_symbolless_global_addend(gsym, dynrel,
6732 else if (tls_type == tls::TLSOPT_TO_LE)
6734 // no GOT relocs needed for Local Exec.
6741 case elfcpp::R_POWERPC_GOT_TLSLD16:
6742 case elfcpp::R_POWERPC_GOT_TLSLD16_LO:
6743 case elfcpp::R_POWERPC_GOT_TLSLD16_HI:
6744 case elfcpp::R_POWERPC_GOT_TLSLD16_HA:
6746 const tls::Tls_optimization tls_type = target->optimize_tls_ld();
6747 if (tls_type == tls::TLSOPT_NONE)
6748 target->tlsld_got_offset(symtab, layout, object);
6749 else if (tls_type == tls::TLSOPT_TO_LE)
6751 // no GOT relocs needed for Local Exec.
6752 if (parameters->options().emit_relocs())
6754 Output_section* os = layout->tls_segment()->first_section();
6755 gold_assert(os != NULL);
6756 os->set_needs_symtab_index();
6764 case elfcpp::R_POWERPC_GOT_DTPREL16:
6765 case elfcpp::R_POWERPC_GOT_DTPREL16_LO:
6766 case elfcpp::R_POWERPC_GOT_DTPREL16_HI:
6767 case elfcpp::R_POWERPC_GOT_DTPREL16_HA:
6769 Output_data_got_powerpc<size, big_endian>* got
6770 = target->got_section(symtab, layout);
6771 if (!gsym->final_value_is_known()
6772 && (gsym->is_from_dynobj()
6773 || gsym->is_undefined()
6774 || gsym->is_preemptible()))
6775 got->add_global_with_rel(gsym, GOT_TYPE_DTPREL,
6776 target->rela_dyn_section(layout),
6777 elfcpp::R_POWERPC_DTPREL);
6779 got->add_global_tls(gsym, GOT_TYPE_DTPREL);
6783 case elfcpp::R_POWERPC_GOT_TPREL16:
6784 case elfcpp::R_POWERPC_GOT_TPREL16_LO:
6785 case elfcpp::R_POWERPC_GOT_TPREL16_HI:
6786 case elfcpp::R_POWERPC_GOT_TPREL16_HA:
6788 const bool final = gsym->final_value_is_known();
6789 const tls::Tls_optimization tls_type = target->optimize_tls_ie(final);
6790 if (tls_type == tls::TLSOPT_NONE)
6792 if (!gsym->has_got_offset(GOT_TYPE_TPREL))
6794 Output_data_got_powerpc<size, big_endian>* got
6795 = target->got_section(symtab, layout);
6796 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
6797 if (gsym->is_undefined()
6798 || gsym->is_from_dynobj())
6800 got->add_global_with_rel(gsym, GOT_TYPE_TPREL, rela_dyn,
6801 elfcpp::R_POWERPC_TPREL);
6805 unsigned int off = got->add_constant(0);
6806 gsym->set_got_offset(GOT_TYPE_TPREL, off);
6807 unsigned int dynrel = elfcpp::R_POWERPC_TPREL;
6808 rela_dyn->add_symbolless_global_addend(gsym, dynrel,
6813 else if (tls_type == tls::TLSOPT_TO_LE)
6815 // no GOT relocs needed for Local Exec.
6823 unsupported_reloc_global(object, r_type, gsym);
6828 && parameters->options().toc_optimize())
6830 if (data_shndx == ppc_object->toc_shndx())
6833 if (r_type != elfcpp::R_PPC64_ADDR64
6834 || (is_ifunc && target->abiversion() < 2))
6836 else if (parameters->options().output_is_position_independent()
6837 && (is_ifunc || gsym->is_absolute() || gsym->is_undefined()))
6840 ppc_object->set_no_toc_opt(reloc.get_r_offset());
6843 enum {no_check, check_lo, check_ha} insn_check;
6847 insn_check = no_check;
6850 case elfcpp::R_POWERPC_GOT_TLSLD16_HA:
6851 case elfcpp::R_POWERPC_GOT_TLSGD16_HA:
6852 case elfcpp::R_POWERPC_GOT_TPREL16_HA:
6853 case elfcpp::R_POWERPC_GOT_DTPREL16_HA:
6854 case elfcpp::R_POWERPC_GOT16_HA:
6855 case elfcpp::R_PPC64_TOC16_HA:
6856 insn_check = check_ha;
6859 case elfcpp::R_POWERPC_GOT_TLSLD16_LO:
6860 case elfcpp::R_POWERPC_GOT_TLSGD16_LO:
6861 case elfcpp::R_POWERPC_GOT_TPREL16_LO:
6862 case elfcpp::R_POWERPC_GOT_DTPREL16_LO:
6863 case elfcpp::R_POWERPC_GOT16_LO:
6864 case elfcpp::R_PPC64_GOT16_LO_DS:
6865 case elfcpp::R_PPC64_TOC16_LO:
6866 case elfcpp::R_PPC64_TOC16_LO_DS:
6867 insn_check = check_lo;
6871 section_size_type slen;
6872 const unsigned char* view = NULL;
6873 if (insn_check != no_check)
6875 view = ppc_object->section_contents(data_shndx, &slen, false);
6876 section_size_type off =
6877 convert_to_section_size_type(reloc.get_r_offset()) & -4;
6880 uint32_t insn = elfcpp::Swap<32, big_endian>::readval(view + off);
6881 if (insn_check == check_lo
6882 ? !ok_lo_toc_insn(insn, r_type)
6883 : ((insn & ((0x3f << 26) | 0x1f << 16))
6884 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
6886 ppc_object->set_no_toc_opt();
6887 gold_warning(_("%s: toc optimization is not supported "
6888 "for %#08x instruction"),
6889 ppc_object->name().c_str(), insn);
6898 case elfcpp::R_PPC64_TOC16:
6899 case elfcpp::R_PPC64_TOC16_LO:
6900 case elfcpp::R_PPC64_TOC16_HI:
6901 case elfcpp::R_PPC64_TOC16_HA:
6902 case elfcpp::R_PPC64_TOC16_DS:
6903 case elfcpp::R_PPC64_TOC16_LO_DS:
6904 if (gsym->source() == Symbol::FROM_OBJECT
6905 && !gsym->object()->is_dynamic())
6907 Powerpc_relobj<size, big_endian>* sym_object
6908 = static_cast<Powerpc_relobj<size, big_endian>*>(gsym->object());
6910 unsigned int shndx = gsym->shndx(&is_ordinary);
6911 if (shndx == sym_object->toc_shndx())
6913 Sized_symbol<size>* sym = symtab->get_sized_symbol<size>(gsym);
6914 Address dst_off = sym->value() + reloc.get_r_offset();
6915 if (dst_off < sym_object->section_size(shndx))
6918 if (r_type == elfcpp::R_PPC64_TOC16_HA)
6920 else if (r_type == elfcpp::R_PPC64_TOC16_LO_DS)
6922 // Need to check that the insn is a ld
6924 view = ppc_object->section_contents(data_shndx,
6927 section_size_type off =
6928 (convert_to_section_size_type(reloc.get_r_offset())
6929 + (big_endian ? -2 : 3));
6931 && (view[off] & (0x3f << 2)) == (58u << 2))
6935 sym_object->set_no_toc_opt(dst_off);
6947 case elfcpp::R_PPC_LOCAL24PC:
6948 if (strcmp(gsym->name(), "_GLOBAL_OFFSET_TABLE_") == 0)
6949 gold_error(_("%s: unsupported -mbss-plt code"),
6950 ppc_object->name().c_str());
6959 case elfcpp::R_POWERPC_GOT_TLSLD16:
6960 case elfcpp::R_POWERPC_GOT_TLSGD16:
6961 case elfcpp::R_POWERPC_GOT_TPREL16:
6962 case elfcpp::R_POWERPC_GOT_DTPREL16:
6963 case elfcpp::R_POWERPC_GOT16:
6964 case elfcpp::R_PPC64_GOT16_DS:
6965 case elfcpp::R_PPC64_TOC16:
6966 case elfcpp::R_PPC64_TOC16_DS:
6967 ppc_object->set_has_small_toc_reloc();
6973 // Process relocations for gc.
6975 template<int size, bool big_endian>
6977 Target_powerpc<size, big_endian>::gc_process_relocs(
6978 Symbol_table* symtab,
6980 Sized_relobj_file<size, big_endian>* object,
6981 unsigned int data_shndx,
6983 const unsigned char* prelocs,
6985 Output_section* output_section,
6986 bool needs_special_offset_handling,
6987 size_t local_symbol_count,
6988 const unsigned char* plocal_symbols)
6990 typedef Target_powerpc<size, big_endian> Powerpc;
6991 typedef gold::Default_classify_reloc<elfcpp::SHT_RELA, size, big_endian>
6994 Powerpc_relobj<size, big_endian>* ppc_object
6995 = static_cast<Powerpc_relobj<size, big_endian>*>(object);
6997 ppc_object->set_opd_valid();
6998 if (size == 64 && data_shndx == ppc_object->opd_shndx())
7000 typename Powerpc_relobj<size, big_endian>::Access_from::iterator p;
7001 for (p = ppc_object->access_from_map()->begin();
7002 p != ppc_object->access_from_map()->end();
7005 Address dst_off = p->first;
7006 unsigned int dst_indx = ppc_object->get_opd_ent(dst_off);
7007 typename Powerpc_relobj<size, big_endian>::Section_refs::iterator s;
7008 for (s = p->second.begin(); s != p->second.end(); ++s)
7010 Relobj* src_obj = s->first;
7011 unsigned int src_indx = s->second;
7012 symtab->gc()->add_reference(src_obj, src_indx,
7013 ppc_object, dst_indx);
7017 ppc_object->access_from_map()->clear();
7018 ppc_object->process_gc_mark(symtab);
7019 // Don't look at .opd relocs as .opd will reference everything.
7023 gold::gc_process_relocs<size, big_endian, Powerpc, Scan, Classify_reloc>(
7032 needs_special_offset_handling,
7037 // Handle target specific gc actions when adding a gc reference from
7038 // SRC_OBJ, SRC_SHNDX to a location specified by DST_OBJ, DST_SHNDX
7039 // and DST_OFF. For powerpc64, this adds a referenc to the code
7040 // section of a function descriptor.
7042 template<int size, bool big_endian>
7044 Target_powerpc<size, big_endian>::do_gc_add_reference(
7045 Symbol_table* symtab,
7047 unsigned int src_shndx,
7049 unsigned int dst_shndx,
7050 Address dst_off) const
7052 if (size != 64 || dst_obj->is_dynamic())
7055 Powerpc_relobj<size, big_endian>* ppc_object
7056 = static_cast<Powerpc_relobj<size, big_endian>*>(dst_obj);
7057 if (dst_shndx != 0 && dst_shndx == ppc_object->opd_shndx())
7059 if (ppc_object->opd_valid())
7061 dst_shndx = ppc_object->get_opd_ent(dst_off);
7062 symtab->gc()->add_reference(src_obj, src_shndx, dst_obj, dst_shndx);
7066 // If we haven't run scan_opd_relocs, we must delay
7067 // processing this function descriptor reference.
7068 ppc_object->add_reference(src_obj, src_shndx, dst_off);
7073 // Add any special sections for this symbol to the gc work list.
7074 // For powerpc64, this adds the code section of a function
7077 template<int size, bool big_endian>
7079 Target_powerpc<size, big_endian>::do_gc_mark_symbol(
7080 Symbol_table* symtab,
7085 Powerpc_relobj<size, big_endian>* ppc_object
7086 = static_cast<Powerpc_relobj<size, big_endian>*>(sym->object());
7088 unsigned int shndx = sym->shndx(&is_ordinary);
7089 if (is_ordinary && shndx != 0 && shndx == ppc_object->opd_shndx())
7091 Sized_symbol<size>* gsym = symtab->get_sized_symbol<size>(sym);
7092 Address dst_off = gsym->value();
7093 if (ppc_object->opd_valid())
7095 unsigned int dst_indx = ppc_object->get_opd_ent(dst_off);
7096 symtab->gc()->worklist().push_back(Section_id(ppc_object,
7100 ppc_object->add_gc_mark(dst_off);
7105 // For a symbol location in .opd, set LOC to the location of the
7108 template<int size, bool big_endian>
7110 Target_powerpc<size, big_endian>::do_function_location(
7111 Symbol_location* loc) const
7113 if (size == 64 && loc->shndx != 0)
7115 if (loc->object->is_dynamic())
7117 Powerpc_dynobj<size, big_endian>* ppc_object
7118 = static_cast<Powerpc_dynobj<size, big_endian>*>(loc->object);
7119 if (loc->shndx == ppc_object->opd_shndx())
7122 Address off = loc->offset - ppc_object->opd_address();
7123 loc->shndx = ppc_object->get_opd_ent(off, &dest_off);
7124 loc->offset = dest_off;
7129 const Powerpc_relobj<size, big_endian>* ppc_object
7130 = static_cast<const Powerpc_relobj<size, big_endian>*>(loc->object);
7131 if (loc->shndx == ppc_object->opd_shndx())
7134 loc->shndx = ppc_object->get_opd_ent(loc->offset, &dest_off);
7135 loc->offset = dest_off;
7141 // FNOFFSET in section SHNDX in OBJECT is the start of a function
7142 // compiled with -fsplit-stack. The function calls non-split-stack
7143 // code. Change the function to ensure it has enough stack space to
7144 // call some random function.
7146 template<int size, bool big_endian>
7148 Target_powerpc<size, big_endian>::do_calls_non_split(
7151 section_offset_type fnoffset,
7152 section_size_type fnsize,
7153 const unsigned char* prelocs,
7155 unsigned char* view,
7156 section_size_type view_size,
7158 std::string* to) const
7160 // 32-bit not supported.
7164 Target::do_calls_non_split(object, shndx, fnoffset, fnsize,
7165 prelocs, reloc_count, view, view_size,
7170 // The function always starts with
7171 // ld %r0,-0x7000-64(%r13) # tcbhead_t.__private_ss
7172 // addis %r12,%r1,-allocate@ha
7173 // addi %r12,%r12,-allocate@l
7175 // but note that the addis or addi may be replaced with a nop
7177 unsigned char *entry = view + fnoffset;
7178 uint32_t insn = elfcpp::Swap<32, big_endian>::readval(entry);
7180 if ((insn & 0xffff0000) == addis_2_12)
7182 /* Skip ELFv2 global entry code. */
7184 insn = elfcpp::Swap<32, big_endian>::readval(entry);
7187 unsigned char *pinsn = entry;
7189 const uint32_t ld_private_ss = 0xe80d8fc0;
7190 if (insn == ld_private_ss)
7192 int32_t allocate = 0;
7196 insn = elfcpp::Swap<32, big_endian>::readval(pinsn);
7197 if ((insn & 0xffff0000) == addis_12_1)
7198 allocate += (insn & 0xffff) << 16;
7199 else if ((insn & 0xffff0000) == addi_12_1
7200 || (insn & 0xffff0000) == addi_12_12)
7201 allocate += ((insn & 0xffff) ^ 0x8000) - 0x8000;
7202 else if (insn != nop)
7205 if (insn == cmpld_7_12_0 && pinsn == entry + 12)
7207 int extra = parameters->options().split_stack_adjust_size();
7209 if (allocate >= 0 || extra < 0)
7211 object->error(_("split-stack stack size overflow at "
7212 "section %u offset %0zx"),
7213 shndx, static_cast<size_t>(fnoffset));
7217 insn = addis_12_1 | (((allocate + 0x8000) >> 16) & 0xffff);
7218 if (insn != addis_12_1)
7220 elfcpp::Swap<32, big_endian>::writeval(pinsn, insn);
7222 insn = addi_12_12 | (allocate & 0xffff);
7223 if (insn != addi_12_12)
7225 elfcpp::Swap<32, big_endian>::writeval(pinsn, insn);
7231 insn = addi_12_1 | (allocate & 0xffff);
7232 elfcpp::Swap<32, big_endian>::writeval(pinsn, insn);
7235 if (pinsn != entry + 12)
7236 elfcpp::Swap<32, big_endian>::writeval(pinsn, nop);
7244 if (!object->has_no_split_stack())
7245 object->error(_("failed to match split-stack sequence at "
7246 "section %u offset %0zx"),
7247 shndx, static_cast<size_t>(fnoffset));
7251 // Scan relocations for a section.
7253 template<int size, bool big_endian>
7255 Target_powerpc<size, big_endian>::scan_relocs(
7256 Symbol_table* symtab,
7258 Sized_relobj_file<size, big_endian>* object,
7259 unsigned int data_shndx,
7260 unsigned int sh_type,
7261 const unsigned char* prelocs,
7263 Output_section* output_section,
7264 bool needs_special_offset_handling,
7265 size_t local_symbol_count,
7266 const unsigned char* plocal_symbols)
7268 typedef Target_powerpc<size, big_endian> Powerpc;
7269 typedef gold::Default_classify_reloc<elfcpp::SHT_RELA, size, big_endian>
7272 if (sh_type == elfcpp::SHT_REL)
7274 gold_error(_("%s: unsupported REL reloc section"),
7275 object->name().c_str());
7279 gold::scan_relocs<size, big_endian, Powerpc, Scan, Classify_reloc>(
7288 needs_special_offset_handling,
7293 // Functor class for processing the global symbol table.
7294 // Removes symbols defined on discarded opd entries.
7296 template<bool big_endian>
7297 class Global_symbol_visitor_opd
7300 Global_symbol_visitor_opd()
7304 operator()(Sized_symbol<64>* sym)
7306 if (sym->has_symtab_index()
7307 || sym->source() != Symbol::FROM_OBJECT
7308 || !sym->in_real_elf())
7311 if (sym->object()->is_dynamic())
7314 Powerpc_relobj<64, big_endian>* symobj
7315 = static_cast<Powerpc_relobj<64, big_endian>*>(sym->object());
7316 if (symobj->opd_shndx() == 0)
7320 unsigned int shndx = sym->shndx(&is_ordinary);
7321 if (shndx == symobj->opd_shndx()
7322 && symobj->get_opd_discard(sym->value()))
7324 sym->set_undefined();
7325 sym->set_visibility(elfcpp::STV_DEFAULT);
7326 sym->set_is_defined_in_discarded_section();
7327 sym->set_symtab_index(-1U);
7332 template<int size, bool big_endian>
7334 Target_powerpc<size, big_endian>::define_save_restore_funcs(
7336 Symbol_table* symtab)
7340 Output_data_save_res<size, big_endian>* savres
7341 = new Output_data_save_res<size, big_endian>(symtab);
7342 this->savres_section_ = savres;
7343 layout->add_output_section_data(".text", elfcpp::SHT_PROGBITS,
7344 elfcpp::SHF_ALLOC | elfcpp::SHF_EXECINSTR,
7345 savres, ORDER_TEXT, false);
7349 // Sort linker created .got section first (for the header), then input
7350 // sections belonging to files using small model code.
7352 template<bool big_endian>
7353 class Sort_toc_sections
7357 operator()(const Output_section::Input_section& is1,
7358 const Output_section::Input_section& is2) const
7360 if (!is1.is_input_section() && is2.is_input_section())
7363 = (is1.is_input_section()
7364 && (static_cast<const Powerpc_relobj<64, big_endian>*>(is1.relobj())
7365 ->has_small_toc_reloc()));
7367 = (is2.is_input_section()
7368 && (static_cast<const Powerpc_relobj<64, big_endian>*>(is2.relobj())
7369 ->has_small_toc_reloc()));
7370 return small1 && !small2;
7374 // Finalize the sections.
7376 template<int size, bool big_endian>
7378 Target_powerpc<size, big_endian>::do_finalize_sections(
7380 const Input_objects*,
7381 Symbol_table* symtab)
7383 if (parameters->doing_static_link())
7385 // At least some versions of glibc elf-init.o have a strong
7386 // reference to __rela_iplt marker syms. A weak ref would be
7388 if (this->iplt_ != NULL)
7390 Reloc_section* rel = this->iplt_->rel_plt();
7391 symtab->define_in_output_data("__rela_iplt_start", NULL,
7392 Symbol_table::PREDEFINED, rel, 0, 0,
7393 elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL,
7394 elfcpp::STV_HIDDEN, 0, false, true);
7395 symtab->define_in_output_data("__rela_iplt_end", NULL,
7396 Symbol_table::PREDEFINED, rel, 0, 0,
7397 elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL,
7398 elfcpp::STV_HIDDEN, 0, true, true);
7402 symtab->define_as_constant("__rela_iplt_start", NULL,
7403 Symbol_table::PREDEFINED, 0, 0,
7404 elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL,
7405 elfcpp::STV_HIDDEN, 0, true, false);
7406 symtab->define_as_constant("__rela_iplt_end", NULL,
7407 Symbol_table::PREDEFINED, 0, 0,
7408 elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL,
7409 elfcpp::STV_HIDDEN, 0, true, false);
7415 typedef Global_symbol_visitor_opd<big_endian> Symbol_visitor;
7416 symtab->for_all_symbols<64, Symbol_visitor>(Symbol_visitor());
7418 if (!parameters->options().relocatable())
7420 this->define_save_restore_funcs(layout, symtab);
7422 // Annoyingly, we need to make these sections now whether or
7423 // not we need them. If we delay until do_relax then we
7424 // need to mess with the relaxation machinery checkpointing.
7425 this->got_section(symtab, layout);
7426 this->make_brlt_section(layout);
7428 if (parameters->options().toc_sort())
7430 Output_section* os = this->got_->output_section();
7431 if (os != NULL && os->input_sections().size() > 1)
7432 std::stable_sort(os->input_sections().begin(),
7433 os->input_sections().end(),
7434 Sort_toc_sections<big_endian>());
7439 // Fill in some more dynamic tags.
7440 Output_data_dynamic* odyn = layout->dynamic_data();
7443 const Reloc_section* rel_plt = (this->plt_ == NULL
7445 : this->plt_->rel_plt());
7446 layout->add_target_dynamic_tags(false, this->plt_, rel_plt,
7447 this->rela_dyn_, true, size == 32);
7451 if (this->got_ != NULL)
7453 this->got_->finalize_data_size();
7454 odyn->add_section_plus_offset(elfcpp::DT_PPC_GOT,
7455 this->got_, this->got_->g_o_t());
7460 if (this->glink_ != NULL)
7462 this->glink_->finalize_data_size();
7463 odyn->add_section_plus_offset(elfcpp::DT_PPC64_GLINK,
7465 (this->glink_->pltresolve_size
7471 // Emit any relocs we saved in an attempt to avoid generating COPY
7473 if (this->copy_relocs_.any_saved_relocs())
7474 this->copy_relocs_.emit(this->rela_dyn_section(layout));
7477 // Emit any saved relocs, and mark toc entries using any of these
7478 // relocs as not optimizable.
7480 template<int sh_type, int size, bool big_endian>
7482 Powerpc_copy_relocs<sh_type, size, big_endian>::emit(
7483 Output_data_reloc<sh_type, true, size, big_endian>* reloc_section)
7486 && parameters->options().toc_optimize())
7488 for (typename Copy_relocs<sh_type, size, big_endian>::
7489 Copy_reloc_entries::iterator p = this->entries_.begin();
7490 p != this->entries_.end();
7493 typename Copy_relocs<sh_type, size, big_endian>::Copy_reloc_entry&
7496 // If the symbol is no longer defined in a dynamic object,
7497 // then we emitted a COPY relocation. If it is still
7498 // dynamic then we'll need dynamic relocations and thus
7499 // can't optimize toc entries.
7500 if (entry.sym_->is_from_dynobj())
7502 Powerpc_relobj<size, big_endian>* ppc_object
7503 = static_cast<Powerpc_relobj<size, big_endian>*>(entry.relobj_);
7504 if (entry.shndx_ == ppc_object->toc_shndx())
7505 ppc_object->set_no_toc_opt(entry.address_);
7510 Copy_relocs<sh_type, size, big_endian>::emit(reloc_section);
7513 // Return the value to use for a branch relocation.
7515 template<int size, bool big_endian>
7517 Target_powerpc<size, big_endian>::symval_for_branch(
7518 const Symbol_table* symtab,
7519 const Sized_symbol<size>* gsym,
7520 Powerpc_relobj<size, big_endian>* object,
7522 unsigned int *dest_shndx)
7524 if (size == 32 || this->abiversion() >= 2)
7528 // If the symbol is defined in an opd section, ie. is a function
7529 // descriptor, use the function descriptor code entry address
7530 Powerpc_relobj<size, big_endian>* symobj = object;
7532 && (gsym->source() != Symbol::FROM_OBJECT
7533 || gsym->object()->is_dynamic()))
7536 symobj = static_cast<Powerpc_relobj<size, big_endian>*>(gsym->object());
7537 unsigned int shndx = symobj->opd_shndx();
7540 Address opd_addr = symobj->get_output_section_offset(shndx);
7541 if (opd_addr == invalid_address)
7543 opd_addr += symobj->output_section_address(shndx);
7544 if (*value >= opd_addr && *value < opd_addr + symobj->section_size(shndx))
7547 *dest_shndx = symobj->get_opd_ent(*value - opd_addr, &sec_off);
7548 if (symtab->is_section_folded(symobj, *dest_shndx))
7551 = symtab->icf()->get_folded_section(symobj, *dest_shndx);
7552 symobj = static_cast<Powerpc_relobj<size, big_endian>*>(folded.first);
7553 *dest_shndx = folded.second;
7555 Address sec_addr = symobj->get_output_section_offset(*dest_shndx);
7556 if (sec_addr == invalid_address)
7559 sec_addr += symobj->output_section(*dest_shndx)->address();
7560 *value = sec_addr + sec_off;
7565 // Perform a relocation.
7567 template<int size, bool big_endian>
7569 Target_powerpc<size, big_endian>::Relocate::relocate(
7570 const Relocate_info<size, big_endian>* relinfo,
7572 Target_powerpc* target,
7575 const unsigned char* preloc,
7576 const Sized_symbol<size>* gsym,
7577 const Symbol_value<size>* psymval,
7578 unsigned char* view,
7580 section_size_type view_size)
7585 const elfcpp::Rela<size, big_endian> rela(preloc);
7586 unsigned int r_type = elfcpp::elf_r_type<size>(rela.get_r_info());
7587 switch (this->maybe_skip_tls_get_addr_call(r_type, gsym))
7589 case Track_tls::NOT_EXPECTED:
7590 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
7591 _("__tls_get_addr call lacks marker reloc"));
7593 case Track_tls::EXPECTED:
7594 // We have already complained.
7596 case Track_tls::SKIP:
7598 case Track_tls::NORMAL:
7602 typedef Powerpc_relocate_functions<size, big_endian> Reloc;
7603 typedef typename elfcpp::Swap<32, big_endian>::Valtype Insn;
7604 typedef typename elfcpp::Rela<size, big_endian> Reltype;
7605 // Offset from start of insn to d-field reloc.
7606 const int d_offset = big_endian ? 2 : 0;
7608 Powerpc_relobj<size, big_endian>* const object
7609 = static_cast<Powerpc_relobj<size, big_endian>*>(relinfo->object);
7611 bool has_stub_value = false;
7612 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info());
7614 ? gsym->use_plt_offset(Scan::get_reference_flags(r_type, target))
7615 : object->local_has_plt_offset(r_sym))
7616 && (!psymval->is_ifunc_symbol()
7617 || Scan::reloc_needs_plt_for_ifunc(target, object, r_type, false)))
7621 && target->abiversion() >= 2
7622 && !parameters->options().output_is_position_independent()
7623 && !is_branch_reloc(r_type))
7625 Address off = target->glink_section()->find_global_entry(gsym);
7626 if (off != invalid_address)
7628 value = target->glink_section()->global_entry_address() + off;
7629 has_stub_value = true;
7634 Stub_table<size, big_endian>* stub_table
7635 = object->stub_table(relinfo->data_shndx);
7636 if (stub_table == NULL)
7638 // This is a ref from a data section to an ifunc symbol.
7639 if (target->stub_tables().size() != 0)
7640 stub_table = target->stub_tables()[0];
7642 if (stub_table != NULL)
7646 off = stub_table->find_plt_call_entry(object, gsym, r_type,
7647 rela.get_r_addend());
7649 off = stub_table->find_plt_call_entry(object, r_sym, r_type,
7650 rela.get_r_addend());
7651 if (off != invalid_address)
7653 value = stub_table->stub_address() + off;
7654 has_stub_value = true;
7658 // We don't care too much about bogus debug references to
7659 // non-local functions, but otherwise there had better be a plt
7660 // call stub or global entry stub as appropriate.
7661 gold_assert(has_stub_value || !(os->flags() & elfcpp::SHF_ALLOC));
7664 if (r_type == elfcpp::R_POWERPC_GOT16
7665 || r_type == elfcpp::R_POWERPC_GOT16_LO
7666 || r_type == elfcpp::R_POWERPC_GOT16_HI
7667 || r_type == elfcpp::R_POWERPC_GOT16_HA
7668 || r_type == elfcpp::R_PPC64_GOT16_DS
7669 || r_type == elfcpp::R_PPC64_GOT16_LO_DS)
7673 gold_assert(gsym->has_got_offset(GOT_TYPE_STANDARD));
7674 value = gsym->got_offset(GOT_TYPE_STANDARD);
7678 gold_assert(object->local_has_got_offset(r_sym, GOT_TYPE_STANDARD));
7679 value = object->local_got_offset(r_sym, GOT_TYPE_STANDARD);
7681 value -= target->got_section()->got_base_offset(object);
7683 else if (r_type == elfcpp::R_PPC64_TOC)
7685 value = (target->got_section()->output_section()->address()
7686 + object->toc_base_offset());
7688 else if (gsym != NULL
7689 && (r_type == elfcpp::R_POWERPC_REL24
7690 || r_type == elfcpp::R_PPC_PLTREL24)
7695 typedef typename elfcpp::Swap<32, big_endian>::Valtype Valtype;
7696 Valtype* wv = reinterpret_cast<Valtype*>(view);
7697 bool can_plt_call = false;
7698 if (rela.get_r_offset() + 8 <= view_size)
7700 Valtype insn = elfcpp::Swap<32, big_endian>::readval(wv);
7701 Valtype insn2 = elfcpp::Swap<32, big_endian>::readval(wv + 1);
7704 || insn2 == cror_15_15_15 || insn2 == cror_31_31_31))
7706 elfcpp::Swap<32, big_endian>::
7707 writeval(wv + 1, ld_2_1 + target->stk_toc());
7708 can_plt_call = true;
7713 // If we don't have a branch and link followed by a nop,
7714 // we can't go via the plt because there is no place to
7715 // put a toc restoring instruction.
7716 // Unless we know we won't be returning.
7717 if (strcmp(gsym->name(), "__libc_start_main") == 0)
7718 can_plt_call = true;
7722 // g++ as of 20130507 emits self-calls without a
7723 // following nop. This is arguably wrong since we have
7724 // conflicting information. On the one hand a global
7725 // symbol and on the other a local call sequence, but
7726 // don't error for this special case.
7727 // It isn't possible to cheaply verify we have exactly
7728 // such a call. Allow all calls to the same section.
7730 Address code = value;
7731 if (gsym->source() == Symbol::FROM_OBJECT
7732 && gsym->object() == object)
7734 unsigned int dest_shndx = 0;
7735 if (target->abiversion() < 2)
7737 Address addend = rela.get_r_addend();
7738 code = psymval->value(object, addend);
7739 target->symval_for_branch(relinfo->symtab, gsym, object,
7740 &code, &dest_shndx);
7743 if (dest_shndx == 0)
7744 dest_shndx = gsym->shndx(&is_ordinary);
7745 ok = dest_shndx == relinfo->data_shndx;
7749 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
7750 _("call lacks nop, can't restore toc; "
7751 "recompile with -fPIC"));
7757 else if (r_type == elfcpp::R_POWERPC_GOT_TLSGD16
7758 || r_type == elfcpp::R_POWERPC_GOT_TLSGD16_LO
7759 || r_type == elfcpp::R_POWERPC_GOT_TLSGD16_HI
7760 || r_type == elfcpp::R_POWERPC_GOT_TLSGD16_HA)
7762 // First instruction of a global dynamic sequence, arg setup insn.
7763 const bool final = gsym == NULL || gsym->final_value_is_known();
7764 const tls::Tls_optimization tls_type = target->optimize_tls_gd(final);
7765 enum Got_type got_type = GOT_TYPE_STANDARD;
7766 if (tls_type == tls::TLSOPT_NONE)
7767 got_type = GOT_TYPE_TLSGD;
7768 else if (tls_type == tls::TLSOPT_TO_IE)
7769 got_type = GOT_TYPE_TPREL;
7770 if (got_type != GOT_TYPE_STANDARD)
7774 gold_assert(gsym->has_got_offset(got_type));
7775 value = gsym->got_offset(got_type);
7779 gold_assert(object->local_has_got_offset(r_sym, got_type));
7780 value = object->local_got_offset(r_sym, got_type);
7782 value -= target->got_section()->got_base_offset(object);
7784 if (tls_type == tls::TLSOPT_TO_IE)
7786 if (r_type == elfcpp::R_POWERPC_GOT_TLSGD16
7787 || r_type == elfcpp::R_POWERPC_GOT_TLSGD16_LO)
7789 Insn* iview = reinterpret_cast<Insn*>(view - d_offset);
7790 Insn insn = elfcpp::Swap<32, big_endian>::readval(iview);
7791 insn &= (1 << 26) - (1 << 16); // extract rt,ra from addi
7793 insn |= 32 << 26; // lwz
7795 insn |= 58 << 26; // ld
7796 elfcpp::Swap<32, big_endian>::writeval(iview, insn);
7798 r_type += (elfcpp::R_POWERPC_GOT_TPREL16
7799 - elfcpp::R_POWERPC_GOT_TLSGD16);
7801 else if (tls_type == tls::TLSOPT_TO_LE)
7803 if (r_type == elfcpp::R_POWERPC_GOT_TLSGD16
7804 || r_type == elfcpp::R_POWERPC_GOT_TLSGD16_LO)
7806 Insn* iview = reinterpret_cast<Insn*>(view - d_offset);
7807 Insn insn = elfcpp::Swap<32, big_endian>::readval(iview);
7808 insn &= (1 << 26) - (1 << 21); // extract rt
7813 elfcpp::Swap<32, big_endian>::writeval(iview, insn);
7814 r_type = elfcpp::R_POWERPC_TPREL16_HA;
7815 value = psymval->value(object, rela.get_r_addend());
7819 Insn* iview = reinterpret_cast<Insn*>(view - d_offset);
7821 elfcpp::Swap<32, big_endian>::writeval(iview, insn);
7822 r_type = elfcpp::R_POWERPC_NONE;
7826 else if (r_type == elfcpp::R_POWERPC_GOT_TLSLD16
7827 || r_type == elfcpp::R_POWERPC_GOT_TLSLD16_LO
7828 || r_type == elfcpp::R_POWERPC_GOT_TLSLD16_HI
7829 || r_type == elfcpp::R_POWERPC_GOT_TLSLD16_HA)
7831 // First instruction of a local dynamic sequence, arg setup insn.
7832 const tls::Tls_optimization tls_type = target->optimize_tls_ld();
7833 if (tls_type == tls::TLSOPT_NONE)
7835 value = target->tlsld_got_offset();
7836 value -= target->got_section()->got_base_offset(object);
7840 gold_assert(tls_type == tls::TLSOPT_TO_LE);
7841 if (r_type == elfcpp::R_POWERPC_GOT_TLSLD16
7842 || r_type == elfcpp::R_POWERPC_GOT_TLSLD16_LO)
7844 Insn* iview = reinterpret_cast<Insn*>(view - d_offset);
7845 Insn insn = elfcpp::Swap<32, big_endian>::readval(iview);
7846 insn &= (1 << 26) - (1 << 21); // extract rt
7851 elfcpp::Swap<32, big_endian>::writeval(iview, insn);
7852 r_type = elfcpp::R_POWERPC_TPREL16_HA;
7857 Insn* iview = reinterpret_cast<Insn*>(view - d_offset);
7859 elfcpp::Swap<32, big_endian>::writeval(iview, insn);
7860 r_type = elfcpp::R_POWERPC_NONE;
7864 else if (r_type == elfcpp::R_POWERPC_GOT_DTPREL16
7865 || r_type == elfcpp::R_POWERPC_GOT_DTPREL16_LO
7866 || r_type == elfcpp::R_POWERPC_GOT_DTPREL16_HI
7867 || r_type == elfcpp::R_POWERPC_GOT_DTPREL16_HA)
7869 // Accesses relative to a local dynamic sequence address,
7870 // no optimisation here.
7873 gold_assert(gsym->has_got_offset(GOT_TYPE_DTPREL));
7874 value = gsym->got_offset(GOT_TYPE_DTPREL);
7878 gold_assert(object->local_has_got_offset(r_sym, GOT_TYPE_DTPREL));
7879 value = object->local_got_offset(r_sym, GOT_TYPE_DTPREL);
7881 value -= target->got_section()->got_base_offset(object);
7883 else if (r_type == elfcpp::R_POWERPC_GOT_TPREL16
7884 || r_type == elfcpp::R_POWERPC_GOT_TPREL16_LO
7885 || r_type == elfcpp::R_POWERPC_GOT_TPREL16_HI
7886 || r_type == elfcpp::R_POWERPC_GOT_TPREL16_HA)
7888 // First instruction of initial exec sequence.
7889 const bool final = gsym == NULL || gsym->final_value_is_known();
7890 const tls::Tls_optimization tls_type = target->optimize_tls_ie(final);
7891 if (tls_type == tls::TLSOPT_NONE)
7895 gold_assert(gsym->has_got_offset(GOT_TYPE_TPREL));
7896 value = gsym->got_offset(GOT_TYPE_TPREL);
7900 gold_assert(object->local_has_got_offset(r_sym, GOT_TYPE_TPREL));
7901 value = object->local_got_offset(r_sym, GOT_TYPE_TPREL);
7903 value -= target->got_section()->got_base_offset(object);
7907 gold_assert(tls_type == tls::TLSOPT_TO_LE);
7908 if (r_type == elfcpp::R_POWERPC_GOT_TPREL16
7909 || r_type == elfcpp::R_POWERPC_GOT_TPREL16_LO)
7911 Insn* iview = reinterpret_cast<Insn*>(view - d_offset);
7912 Insn insn = elfcpp::Swap<32, big_endian>::readval(iview);
7913 insn &= (1 << 26) - (1 << 21); // extract rt from ld
7918 elfcpp::Swap<32, big_endian>::writeval(iview, insn);
7919 r_type = elfcpp::R_POWERPC_TPREL16_HA;
7920 value = psymval->value(object, rela.get_r_addend());
7924 Insn* iview = reinterpret_cast<Insn*>(view - d_offset);
7926 elfcpp::Swap<32, big_endian>::writeval(iview, insn);
7927 r_type = elfcpp::R_POWERPC_NONE;
7931 else if ((size == 64 && r_type == elfcpp::R_PPC64_TLSGD)
7932 || (size == 32 && r_type == elfcpp::R_PPC_TLSGD))
7934 // Second instruction of a global dynamic sequence,
7935 // the __tls_get_addr call
7936 this->expect_tls_get_addr_call(relinfo, relnum, rela.get_r_offset());
7937 const bool final = gsym == NULL || gsym->final_value_is_known();
7938 const tls::Tls_optimization tls_type = target->optimize_tls_gd(final);
7939 if (tls_type != tls::TLSOPT_NONE)
7941 if (tls_type == tls::TLSOPT_TO_IE)
7943 Insn* iview = reinterpret_cast<Insn*>(view);
7944 Insn insn = add_3_3_13;
7947 elfcpp::Swap<32, big_endian>::writeval(iview, insn);
7948 r_type = elfcpp::R_POWERPC_NONE;
7952 Insn* iview = reinterpret_cast<Insn*>(view);
7953 Insn insn = addi_3_3;
7954 elfcpp::Swap<32, big_endian>::writeval(iview, insn);
7955 r_type = elfcpp::R_POWERPC_TPREL16_LO;
7957 value = psymval->value(object, rela.get_r_addend());
7959 this->skip_next_tls_get_addr_call();
7962 else if ((size == 64 && r_type == elfcpp::R_PPC64_TLSLD)
7963 || (size == 32 && r_type == elfcpp::R_PPC_TLSLD))
7965 // Second instruction of a local dynamic sequence,
7966 // the __tls_get_addr call
7967 this->expect_tls_get_addr_call(relinfo, relnum, rela.get_r_offset());
7968 const tls::Tls_optimization tls_type = target->optimize_tls_ld();
7969 if (tls_type == tls::TLSOPT_TO_LE)
7971 Insn* iview = reinterpret_cast<Insn*>(view);
7972 Insn insn = addi_3_3;
7973 elfcpp::Swap<32, big_endian>::writeval(iview, insn);
7974 this->skip_next_tls_get_addr_call();
7975 r_type = elfcpp::R_POWERPC_TPREL16_LO;
7980 else if (r_type == elfcpp::R_POWERPC_TLS)
7982 // Second instruction of an initial exec sequence
7983 const bool final = gsym == NULL || gsym->final_value_is_known();
7984 const tls::Tls_optimization tls_type = target->optimize_tls_ie(final);
7985 if (tls_type == tls::TLSOPT_TO_LE)
7987 Insn* iview = reinterpret_cast<Insn*>(view);
7988 Insn insn = elfcpp::Swap<32, big_endian>::readval(iview);
7989 unsigned int reg = size == 32 ? 2 : 13;
7990 insn = at_tls_transform(insn, reg);
7991 gold_assert(insn != 0);
7992 elfcpp::Swap<32, big_endian>::writeval(iview, insn);
7993 r_type = elfcpp::R_POWERPC_TPREL16_LO;
7995 value = psymval->value(object, rela.get_r_addend());
7998 else if (!has_stub_value)
8001 if (!(size == 32 && r_type == elfcpp::R_PPC_PLTREL24))
8002 addend = rela.get_r_addend();
8003 value = psymval->value(object, addend);
8004 if (size == 64 && is_branch_reloc(r_type))
8006 if (target->abiversion() >= 2)
8009 value += object->ppc64_local_entry_offset(gsym);
8011 value += object->ppc64_local_entry_offset(r_sym);
8015 unsigned int dest_shndx;
8016 target->symval_for_branch(relinfo->symtab, gsym, object,
8017 &value, &dest_shndx);
8020 Address max_branch_offset = max_branch_delta(r_type);
8021 if (max_branch_offset != 0
8022 && value - address + max_branch_offset >= 2 * max_branch_offset)
8024 Stub_table<size, big_endian>* stub_table
8025 = object->stub_table(relinfo->data_shndx);
8026 if (stub_table != NULL)
8028 Address off = stub_table->find_long_branch_entry(object, value);
8029 if (off != invalid_address)
8031 value = (stub_table->stub_address() + stub_table->plt_size()
8033 has_stub_value = true;
8041 case elfcpp::R_PPC64_REL64:
8042 case elfcpp::R_POWERPC_REL32:
8043 case elfcpp::R_POWERPC_REL24:
8044 case elfcpp::R_PPC_PLTREL24:
8045 case elfcpp::R_PPC_LOCAL24PC:
8046 case elfcpp::R_POWERPC_REL16:
8047 case elfcpp::R_POWERPC_REL16_LO:
8048 case elfcpp::R_POWERPC_REL16_HI:
8049 case elfcpp::R_POWERPC_REL16_HA:
8050 case elfcpp::R_POWERPC_REL16DX_HA:
8051 case elfcpp::R_POWERPC_REL14:
8052 case elfcpp::R_POWERPC_REL14_BRTAKEN:
8053 case elfcpp::R_POWERPC_REL14_BRNTAKEN:
8057 case elfcpp::R_PPC64_TOC16:
8058 case elfcpp::R_PPC64_TOC16_LO:
8059 case elfcpp::R_PPC64_TOC16_HI:
8060 case elfcpp::R_PPC64_TOC16_HA:
8061 case elfcpp::R_PPC64_TOC16_DS:
8062 case elfcpp::R_PPC64_TOC16_LO_DS:
8063 // Subtract the TOC base address.
8064 value -= (target->got_section()->output_section()->address()
8065 + object->toc_base_offset());
8068 case elfcpp::R_POWERPC_SECTOFF:
8069 case elfcpp::R_POWERPC_SECTOFF_LO:
8070 case elfcpp::R_POWERPC_SECTOFF_HI:
8071 case elfcpp::R_POWERPC_SECTOFF_HA:
8072 case elfcpp::R_PPC64_SECTOFF_DS:
8073 case elfcpp::R_PPC64_SECTOFF_LO_DS:
8075 value -= os->address();
8078 case elfcpp::R_PPC64_TPREL16_DS:
8079 case elfcpp::R_PPC64_TPREL16_LO_DS:
8080 case elfcpp::R_PPC64_TPREL16_HIGH:
8081 case elfcpp::R_PPC64_TPREL16_HIGHA:
8083 // R_PPC_TLSGD, R_PPC_TLSLD, R_PPC_EMB_RELST_LO, R_PPC_EMB_RELST_HI
8086 case elfcpp::R_POWERPC_TPREL16:
8087 case elfcpp::R_POWERPC_TPREL16_LO:
8088 case elfcpp::R_POWERPC_TPREL16_HI:
8089 case elfcpp::R_POWERPC_TPREL16_HA:
8090 case elfcpp::R_POWERPC_TPREL:
8091 case elfcpp::R_PPC64_TPREL16_HIGHER:
8092 case elfcpp::R_PPC64_TPREL16_HIGHERA:
8093 case elfcpp::R_PPC64_TPREL16_HIGHEST:
8094 case elfcpp::R_PPC64_TPREL16_HIGHESTA:
8095 // tls symbol values are relative to tls_segment()->vaddr()
8099 case elfcpp::R_PPC64_DTPREL16_DS:
8100 case elfcpp::R_PPC64_DTPREL16_LO_DS:
8101 case elfcpp::R_PPC64_DTPREL16_HIGHER:
8102 case elfcpp::R_PPC64_DTPREL16_HIGHERA:
8103 case elfcpp::R_PPC64_DTPREL16_HIGHEST:
8104 case elfcpp::R_PPC64_DTPREL16_HIGHESTA:
8106 // R_PPC_EMB_NADDR32, R_PPC_EMB_NADDR16, R_PPC_EMB_NADDR16_LO
8107 // R_PPC_EMB_NADDR16_HI, R_PPC_EMB_NADDR16_HA, R_PPC_EMB_SDAI16
8110 case elfcpp::R_POWERPC_DTPREL16:
8111 case elfcpp::R_POWERPC_DTPREL16_LO:
8112 case elfcpp::R_POWERPC_DTPREL16_HI:
8113 case elfcpp::R_POWERPC_DTPREL16_HA:
8114 case elfcpp::R_POWERPC_DTPREL:
8115 case elfcpp::R_PPC64_DTPREL16_HIGH:
8116 case elfcpp::R_PPC64_DTPREL16_HIGHA:
8117 // tls symbol values are relative to tls_segment()->vaddr()
8118 value -= dtp_offset;
8121 case elfcpp::R_PPC64_ADDR64_LOCAL:
8123 value += object->ppc64_local_entry_offset(gsym);
8125 value += object->ppc64_local_entry_offset(r_sym);
8132 Insn branch_bit = 0;
8135 case elfcpp::R_POWERPC_ADDR14_BRTAKEN:
8136 case elfcpp::R_POWERPC_REL14_BRTAKEN:
8137 branch_bit = 1 << 21;
8139 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN:
8140 case elfcpp::R_POWERPC_REL14_BRNTAKEN:
8142 Insn* iview = reinterpret_cast<Insn*>(view);
8143 Insn insn = elfcpp::Swap<32, big_endian>::readval(iview);
8146 if (this->is_isa_v2)
8148 // Set 'a' bit. This is 0b00010 in BO field for branch
8149 // on CR(BI) insns (BO == 001at or 011at), and 0b01000
8150 // for branch on CTR insns (BO == 1a00t or 1a01t).
8151 if ((insn & (0x14 << 21)) == (0x04 << 21))
8153 else if ((insn & (0x14 << 21)) == (0x10 << 21))
8160 // Invert 'y' bit if not the default.
8161 if (static_cast<Signed_address>(value) < 0)
8164 elfcpp::Swap<32, big_endian>::writeval(iview, insn);
8179 // Multi-instruction sequences that access the GOT/TOC can
8180 // be optimized, eg.
8181 // addis ra,r2,x@got@ha; ld rb,x@got@l(ra);
8182 // to addis ra,r2,x@toc@ha; addi rb,ra,x@toc@l;
8184 // addis ra,r2,0; addi rb,ra,x@toc@l;
8185 // to nop; addi rb,r2,x@toc;
8186 // FIXME: the @got sequence shown above is not yet
8187 // optimized. Note that gcc as of 2017-01-07 doesn't use
8188 // the ELF @got relocs except for TLS, instead using the
8189 // PowerOpen variant of a compiler managed GOT (called TOC).
8190 // The PowerOpen TOC sequence equivalent to the first
8191 // example is optimized.
8192 case elfcpp::R_POWERPC_GOT_TLSLD16_HA:
8193 case elfcpp::R_POWERPC_GOT_TLSGD16_HA:
8194 case elfcpp::R_POWERPC_GOT_TPREL16_HA:
8195 case elfcpp::R_POWERPC_GOT_DTPREL16_HA:
8196 case elfcpp::R_POWERPC_GOT16_HA:
8197 case elfcpp::R_PPC64_TOC16_HA:
8198 if (parameters->options().toc_optimize())
8200 Insn* iview = reinterpret_cast<Insn*>(view - d_offset);
8201 Insn insn = elfcpp::Swap<32, big_endian>::readval(iview);
8202 if (r_type == elfcpp::R_PPC64_TOC16_HA
8203 && object->make_toc_relative(target, &value))
8205 gold_assert((insn & ((0x3f << 26) | 0x1f << 16))
8206 == ((15u << 26) | (2 << 16)));
8208 if (((insn & ((0x3f << 26) | 0x1f << 16))
8209 == ((15u << 26) | (2 << 16)) /* addis rt,2,imm */)
8210 && value + 0x8000 < 0x10000)
8212 elfcpp::Swap<32, big_endian>::writeval(iview, nop);
8218 case elfcpp::R_POWERPC_GOT_TLSLD16_LO:
8219 case elfcpp::R_POWERPC_GOT_TLSGD16_LO:
8220 case elfcpp::R_POWERPC_GOT_TPREL16_LO:
8221 case elfcpp::R_POWERPC_GOT_DTPREL16_LO:
8222 case elfcpp::R_POWERPC_GOT16_LO:
8223 case elfcpp::R_PPC64_GOT16_LO_DS:
8224 case elfcpp::R_PPC64_TOC16_LO:
8225 case elfcpp::R_PPC64_TOC16_LO_DS:
8226 if (parameters->options().toc_optimize())
8228 Insn* iview = reinterpret_cast<Insn*>(view - d_offset);
8229 Insn insn = elfcpp::Swap<32, big_endian>::readval(iview);
8230 bool changed = false;
8231 if (r_type == elfcpp::R_PPC64_TOC16_LO_DS
8232 && object->make_toc_relative(target, &value))
8234 gold_assert ((insn & (0x3f << 26)) == 58u << 26 /* ld */);
8235 insn ^= (14u << 26) ^ (58u << 26);
8236 r_type = elfcpp::R_PPC64_TOC16_LO;
8239 if (ok_lo_toc_insn(insn, r_type)
8240 && value + 0x8000 < 0x10000)
8242 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
8244 // Transform addic to addi when we change reg.
8245 insn &= ~((0x3f << 26) | (0x1f << 16));
8246 insn |= (14u << 26) | (2 << 16);
8250 insn &= ~(0x1f << 16);
8256 elfcpp::Swap<32, big_endian>::writeval(iview, insn);
8260 case elfcpp::R_PPC64_ENTRY:
8261 value = (target->got_section()->output_section()->address()
8262 + object->toc_base_offset());
8263 if (value + 0x80008000 <= 0xffffffff
8264 && !parameters->options().output_is_position_independent())
8266 Insn* iview = reinterpret_cast<Insn*>(view);
8267 Insn insn1 = elfcpp::Swap<32, big_endian>::readval(iview);
8268 Insn insn2 = elfcpp::Swap<32, big_endian>::readval(iview + 1);
8270 if ((insn1 & ~0xfffc) == ld_2_12
8271 && insn2 == add_2_2_12)
8273 insn1 = lis_2 + ha(value);
8274 elfcpp::Swap<32, big_endian>::writeval(iview, insn1);
8275 insn2 = addi_2_2 + l(value);
8276 elfcpp::Swap<32, big_endian>::writeval(iview + 1, insn2);
8283 if (value + 0x80008000 <= 0xffffffff)
8285 Insn* iview = reinterpret_cast<Insn*>(view);
8286 Insn insn1 = elfcpp::Swap<32, big_endian>::readval(iview);
8287 Insn insn2 = elfcpp::Swap<32, big_endian>::readval(iview + 1);
8289 if ((insn1 & ~0xfffc) == ld_2_12
8290 && insn2 == add_2_2_12)
8292 insn1 = addis_2_12 + ha(value);
8293 elfcpp::Swap<32, big_endian>::writeval(iview, insn1);
8294 insn2 = addi_2_2 + l(value);
8295 elfcpp::Swap<32, big_endian>::writeval(iview + 1, insn2);
8302 case elfcpp::R_POWERPC_REL16_LO:
8303 // If we are generating a non-PIC executable, edit
8304 // 0: addis 2,12,.TOC.-0b@ha
8305 // addi 2,2,.TOC.-0b@l
8306 // used by ELFv2 global entry points to set up r2, to
8309 // if .TOC. is in range. */
8310 if (value + address - 4 + 0x80008000 <= 0xffffffff
8313 && target->abiversion() >= 2
8314 && !parameters->options().output_is_position_independent()
8315 && rela.get_r_addend() == d_offset + 4
8317 && strcmp(gsym->name(), ".TOC.") == 0)
8319 const int reloc_size = elfcpp::Elf_sizes<size>::rela_size;
8320 Reltype prev_rela(preloc - reloc_size);
8321 if ((prev_rela.get_r_info()
8322 == elfcpp::elf_r_info<size>(r_sym,
8323 elfcpp::R_POWERPC_REL16_HA))
8324 && prev_rela.get_r_offset() + 4 == rela.get_r_offset()
8325 && prev_rela.get_r_addend() + 4 == rela.get_r_addend())
8327 Insn* iview = reinterpret_cast<Insn*>(view - d_offset);
8328 Insn insn1 = elfcpp::Swap<32, big_endian>::readval(iview - 1);
8329 Insn insn2 = elfcpp::Swap<32, big_endian>::readval(iview);
8331 if ((insn1 & 0xffff0000) == addis_2_12
8332 && (insn2 & 0xffff0000) == addi_2_2)
8334 insn1 = lis_2 + ha(value + address - 4);
8335 elfcpp::Swap<32, big_endian>::writeval(iview - 1, insn1);
8336 insn2 = addi_2_2 + l(value + address - 4);
8337 elfcpp::Swap<32, big_endian>::writeval(iview, insn2);
8340 relinfo->rr->set_strategy(relnum - 1,
8341 Relocatable_relocs::RELOC_SPECIAL);
8342 relinfo->rr->set_strategy(relnum,
8343 Relocatable_relocs::RELOC_SPECIAL);
8353 typename Reloc::Overflow_check overflow = Reloc::CHECK_NONE;
8354 elfcpp::Shdr<size, big_endian> shdr(relinfo->data_shdr);
8357 case elfcpp::R_POWERPC_ADDR32:
8358 case elfcpp::R_POWERPC_UADDR32:
8360 overflow = Reloc::CHECK_BITFIELD;
8363 case elfcpp::R_POWERPC_REL32:
8364 case elfcpp::R_POWERPC_REL16DX_HA:
8366 overflow = Reloc::CHECK_SIGNED;
8369 case elfcpp::R_POWERPC_UADDR16:
8370 overflow = Reloc::CHECK_BITFIELD;
8373 case elfcpp::R_POWERPC_ADDR16:
8374 // We really should have three separate relocations,
8375 // one for 16-bit data, one for insns with 16-bit signed fields,
8376 // and one for insns with 16-bit unsigned fields.
8377 overflow = Reloc::CHECK_BITFIELD;
8378 if ((shdr.get_sh_flags() & elfcpp::SHF_EXECINSTR) != 0)
8379 overflow = Reloc::CHECK_LOW_INSN;
8382 case elfcpp::R_POWERPC_ADDR16_HI:
8383 case elfcpp::R_POWERPC_ADDR16_HA:
8384 case elfcpp::R_POWERPC_GOT16_HI:
8385 case elfcpp::R_POWERPC_GOT16_HA:
8386 case elfcpp::R_POWERPC_PLT16_HI:
8387 case elfcpp::R_POWERPC_PLT16_HA:
8388 case elfcpp::R_POWERPC_SECTOFF_HI:
8389 case elfcpp::R_POWERPC_SECTOFF_HA:
8390 case elfcpp::R_PPC64_TOC16_HI:
8391 case elfcpp::R_PPC64_TOC16_HA:
8392 case elfcpp::R_PPC64_PLTGOT16_HI:
8393 case elfcpp::R_PPC64_PLTGOT16_HA:
8394 case elfcpp::R_POWERPC_TPREL16_HI:
8395 case elfcpp::R_POWERPC_TPREL16_HA:
8396 case elfcpp::R_POWERPC_DTPREL16_HI:
8397 case elfcpp::R_POWERPC_DTPREL16_HA:
8398 case elfcpp::R_POWERPC_GOT_TLSGD16_HI:
8399 case elfcpp::R_POWERPC_GOT_TLSGD16_HA:
8400 case elfcpp::R_POWERPC_GOT_TLSLD16_HI:
8401 case elfcpp::R_POWERPC_GOT_TLSLD16_HA:
8402 case elfcpp::R_POWERPC_GOT_TPREL16_HI:
8403 case elfcpp::R_POWERPC_GOT_TPREL16_HA:
8404 case elfcpp::R_POWERPC_GOT_DTPREL16_HI:
8405 case elfcpp::R_POWERPC_GOT_DTPREL16_HA:
8406 case elfcpp::R_POWERPC_REL16_HI:
8407 case elfcpp::R_POWERPC_REL16_HA:
8409 overflow = Reloc::CHECK_HIGH_INSN;
8412 case elfcpp::R_POWERPC_REL16:
8413 case elfcpp::R_PPC64_TOC16:
8414 case elfcpp::R_POWERPC_GOT16:
8415 case elfcpp::R_POWERPC_SECTOFF:
8416 case elfcpp::R_POWERPC_TPREL16:
8417 case elfcpp::R_POWERPC_DTPREL16:
8418 case elfcpp::R_POWERPC_GOT_TLSGD16:
8419 case elfcpp::R_POWERPC_GOT_TLSLD16:
8420 case elfcpp::R_POWERPC_GOT_TPREL16:
8421 case elfcpp::R_POWERPC_GOT_DTPREL16:
8422 overflow = Reloc::CHECK_LOW_INSN;
8425 case elfcpp::R_POWERPC_ADDR24:
8426 case elfcpp::R_POWERPC_ADDR14:
8427 case elfcpp::R_POWERPC_ADDR14_BRTAKEN:
8428 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN:
8429 case elfcpp::R_PPC64_ADDR16_DS:
8430 case elfcpp::R_POWERPC_REL24:
8431 case elfcpp::R_PPC_PLTREL24:
8432 case elfcpp::R_PPC_LOCAL24PC:
8433 case elfcpp::R_PPC64_TPREL16_DS:
8434 case elfcpp::R_PPC64_DTPREL16_DS:
8435 case elfcpp::R_PPC64_TOC16_DS:
8436 case elfcpp::R_PPC64_GOT16_DS:
8437 case elfcpp::R_PPC64_SECTOFF_DS:
8438 case elfcpp::R_POWERPC_REL14:
8439 case elfcpp::R_POWERPC_REL14_BRTAKEN:
8440 case elfcpp::R_POWERPC_REL14_BRNTAKEN:
8441 overflow = Reloc::CHECK_SIGNED;
8445 Insn* iview = reinterpret_cast<Insn*>(view - d_offset);
8448 if (overflow == Reloc::CHECK_LOW_INSN
8449 || overflow == Reloc::CHECK_HIGH_INSN)
8451 insn = elfcpp::Swap<32, big_endian>::readval(iview);
8453 if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
8454 overflow = Reloc::CHECK_BITFIELD;
8455 else if (overflow == Reloc::CHECK_LOW_INSN
8456 ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
8457 || (insn & (0x3f << 26)) == 24u << 26 /* ori */
8458 || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
8459 : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
8460 || (insn & (0x3f << 26)) == 25u << 26 /* oris */
8461 || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
8462 overflow = Reloc::CHECK_UNSIGNED;
8464 overflow = Reloc::CHECK_SIGNED;
8467 bool maybe_dq_reloc = false;
8468 typename Powerpc_relocate_functions<size, big_endian>::Status status
8469 = Powerpc_relocate_functions<size, big_endian>::STATUS_OK;
8472 case elfcpp::R_POWERPC_NONE:
8473 case elfcpp::R_POWERPC_TLS:
8474 case elfcpp::R_POWERPC_GNU_VTINHERIT:
8475 case elfcpp::R_POWERPC_GNU_VTENTRY:
8478 case elfcpp::R_PPC64_ADDR64:
8479 case elfcpp::R_PPC64_REL64:
8480 case elfcpp::R_PPC64_TOC:
8481 case elfcpp::R_PPC64_ADDR64_LOCAL:
8482 Reloc::addr64(view, value);
8485 case elfcpp::R_POWERPC_TPREL:
8486 case elfcpp::R_POWERPC_DTPREL:
8488 Reloc::addr64(view, value);
8490 status = Reloc::addr32(view, value, overflow);
8493 case elfcpp::R_PPC64_UADDR64:
8494 Reloc::addr64_u(view, value);
8497 case elfcpp::R_POWERPC_ADDR32:
8498 status = Reloc::addr32(view, value, overflow);
8501 case elfcpp::R_POWERPC_REL32:
8502 case elfcpp::R_POWERPC_UADDR32:
8503 status = Reloc::addr32_u(view, value, overflow);
8506 case elfcpp::R_POWERPC_ADDR24:
8507 case elfcpp::R_POWERPC_REL24:
8508 case elfcpp::R_PPC_PLTREL24:
8509 case elfcpp::R_PPC_LOCAL24PC:
8510 status = Reloc::addr24(view, value, overflow);
8513 case elfcpp::R_POWERPC_GOT_DTPREL16:
8514 case elfcpp::R_POWERPC_GOT_DTPREL16_LO:
8515 case elfcpp::R_POWERPC_GOT_TPREL16:
8516 case elfcpp::R_POWERPC_GOT_TPREL16_LO:
8519 // On ppc64 these are all ds form
8520 maybe_dq_reloc = true;
8524 case elfcpp::R_POWERPC_ADDR16:
8525 case elfcpp::R_POWERPC_REL16:
8526 case elfcpp::R_PPC64_TOC16:
8527 case elfcpp::R_POWERPC_GOT16:
8528 case elfcpp::R_POWERPC_SECTOFF:
8529 case elfcpp::R_POWERPC_TPREL16:
8530 case elfcpp::R_POWERPC_DTPREL16:
8531 case elfcpp::R_POWERPC_GOT_TLSGD16:
8532 case elfcpp::R_POWERPC_GOT_TLSLD16:
8533 case elfcpp::R_POWERPC_ADDR16_LO:
8534 case elfcpp::R_POWERPC_REL16_LO:
8535 case elfcpp::R_PPC64_TOC16_LO:
8536 case elfcpp::R_POWERPC_GOT16_LO:
8537 case elfcpp::R_POWERPC_SECTOFF_LO:
8538 case elfcpp::R_POWERPC_TPREL16_LO:
8539 case elfcpp::R_POWERPC_DTPREL16_LO:
8540 case elfcpp::R_POWERPC_GOT_TLSGD16_LO:
8541 case elfcpp::R_POWERPC_GOT_TLSLD16_LO:
8543 status = Reloc::addr16(view, value, overflow);
8545 maybe_dq_reloc = true;
8548 case elfcpp::R_POWERPC_UADDR16:
8549 status = Reloc::addr16_u(view, value, overflow);
8552 case elfcpp::R_PPC64_ADDR16_HIGH:
8553 case elfcpp::R_PPC64_TPREL16_HIGH:
8554 case elfcpp::R_PPC64_DTPREL16_HIGH:
8556 // R_PPC_EMB_MRKREF, R_PPC_EMB_RELST_LO, R_PPC_EMB_RELST_HA
8559 case elfcpp::R_POWERPC_ADDR16_HI:
8560 case elfcpp::R_POWERPC_REL16_HI:
8561 case elfcpp::R_PPC64_TOC16_HI:
8562 case elfcpp::R_POWERPC_GOT16_HI:
8563 case elfcpp::R_POWERPC_SECTOFF_HI:
8564 case elfcpp::R_POWERPC_TPREL16_HI:
8565 case elfcpp::R_POWERPC_DTPREL16_HI:
8566 case elfcpp::R_POWERPC_GOT_TLSGD16_HI:
8567 case elfcpp::R_POWERPC_GOT_TLSLD16_HI:
8568 case elfcpp::R_POWERPC_GOT_TPREL16_HI:
8569 case elfcpp::R_POWERPC_GOT_DTPREL16_HI:
8570 Reloc::addr16_hi(view, value);
8573 case elfcpp::R_PPC64_ADDR16_HIGHA:
8574 case elfcpp::R_PPC64_TPREL16_HIGHA:
8575 case elfcpp::R_PPC64_DTPREL16_HIGHA:
8577 // R_PPC_EMB_RELSEC16, R_PPC_EMB_RELST_HI, R_PPC_EMB_BIT_FLD
8580 case elfcpp::R_POWERPC_ADDR16_HA:
8581 case elfcpp::R_POWERPC_REL16_HA:
8582 case elfcpp::R_PPC64_TOC16_HA:
8583 case elfcpp::R_POWERPC_GOT16_HA:
8584 case elfcpp::R_POWERPC_SECTOFF_HA:
8585 case elfcpp::R_POWERPC_TPREL16_HA:
8586 case elfcpp::R_POWERPC_DTPREL16_HA:
8587 case elfcpp::R_POWERPC_GOT_TLSGD16_HA:
8588 case elfcpp::R_POWERPC_GOT_TLSLD16_HA:
8589 case elfcpp::R_POWERPC_GOT_TPREL16_HA:
8590 case elfcpp::R_POWERPC_GOT_DTPREL16_HA:
8591 Reloc::addr16_ha(view, value);
8594 case elfcpp::R_POWERPC_REL16DX_HA:
8595 status = Reloc::addr16dx_ha(view, value, overflow);
8598 case elfcpp::R_PPC64_DTPREL16_HIGHER:
8600 // R_PPC_EMB_NADDR16_LO
8603 case elfcpp::R_PPC64_ADDR16_HIGHER:
8604 case elfcpp::R_PPC64_TPREL16_HIGHER:
8605 Reloc::addr16_hi2(view, value);
8608 case elfcpp::R_PPC64_DTPREL16_HIGHERA:
8610 // R_PPC_EMB_NADDR16_HI
8613 case elfcpp::R_PPC64_ADDR16_HIGHERA:
8614 case elfcpp::R_PPC64_TPREL16_HIGHERA:
8615 Reloc::addr16_ha2(view, value);
8618 case elfcpp::R_PPC64_DTPREL16_HIGHEST:
8620 // R_PPC_EMB_NADDR16_HA
8623 case elfcpp::R_PPC64_ADDR16_HIGHEST:
8624 case elfcpp::R_PPC64_TPREL16_HIGHEST:
8625 Reloc::addr16_hi3(view, value);
8628 case elfcpp::R_PPC64_DTPREL16_HIGHESTA:
8633 case elfcpp::R_PPC64_ADDR16_HIGHESTA:
8634 case elfcpp::R_PPC64_TPREL16_HIGHESTA:
8635 Reloc::addr16_ha3(view, value);
8638 case elfcpp::R_PPC64_DTPREL16_DS:
8639 case elfcpp::R_PPC64_DTPREL16_LO_DS:
8641 // R_PPC_EMB_NADDR32, R_PPC_EMB_NADDR16
8644 case elfcpp::R_PPC64_TPREL16_DS:
8645 case elfcpp::R_PPC64_TPREL16_LO_DS:
8647 // R_PPC_TLSGD, R_PPC_TLSLD
8650 case elfcpp::R_PPC64_ADDR16_DS:
8651 case elfcpp::R_PPC64_ADDR16_LO_DS:
8652 case elfcpp::R_PPC64_TOC16_DS:
8653 case elfcpp::R_PPC64_TOC16_LO_DS:
8654 case elfcpp::R_PPC64_GOT16_DS:
8655 case elfcpp::R_PPC64_GOT16_LO_DS:
8656 case elfcpp::R_PPC64_SECTOFF_DS:
8657 case elfcpp::R_PPC64_SECTOFF_LO_DS:
8658 maybe_dq_reloc = true;
8661 case elfcpp::R_POWERPC_ADDR14:
8662 case elfcpp::R_POWERPC_ADDR14_BRTAKEN:
8663 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN:
8664 case elfcpp::R_POWERPC_REL14:
8665 case elfcpp::R_POWERPC_REL14_BRTAKEN:
8666 case elfcpp::R_POWERPC_REL14_BRNTAKEN:
8667 status = Reloc::addr14(view, value, overflow);
8670 case elfcpp::R_POWERPC_COPY:
8671 case elfcpp::R_POWERPC_GLOB_DAT:
8672 case elfcpp::R_POWERPC_JMP_SLOT:
8673 case elfcpp::R_POWERPC_RELATIVE:
8674 case elfcpp::R_POWERPC_DTPMOD:
8675 case elfcpp::R_PPC64_JMP_IREL:
8676 case elfcpp::R_POWERPC_IRELATIVE:
8677 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
8678 _("unexpected reloc %u in object file"),
8682 case elfcpp::R_PPC_EMB_SDA21:
8687 // R_PPC64_TOCSAVE. For the time being this can be ignored.
8691 case elfcpp::R_PPC_EMB_SDA2I16:
8692 case elfcpp::R_PPC_EMB_SDA2REL:
8695 // R_PPC64_TLSGD, R_PPC64_TLSLD
8698 case elfcpp::R_POWERPC_PLT32:
8699 case elfcpp::R_POWERPC_PLTREL32:
8700 case elfcpp::R_POWERPC_PLT16_LO:
8701 case elfcpp::R_POWERPC_PLT16_HI:
8702 case elfcpp::R_POWERPC_PLT16_HA:
8703 case elfcpp::R_PPC_SDAREL16:
8704 case elfcpp::R_POWERPC_ADDR30:
8705 case elfcpp::R_PPC64_PLT64:
8706 case elfcpp::R_PPC64_PLTREL64:
8707 case elfcpp::R_PPC64_PLTGOT16:
8708 case elfcpp::R_PPC64_PLTGOT16_LO:
8709 case elfcpp::R_PPC64_PLTGOT16_HI:
8710 case elfcpp::R_PPC64_PLTGOT16_HA:
8711 case elfcpp::R_PPC64_PLT16_LO_DS:
8712 case elfcpp::R_PPC64_PLTGOT16_DS:
8713 case elfcpp::R_PPC64_PLTGOT16_LO_DS:
8714 case elfcpp::R_PPC_EMB_RELSDA:
8715 case elfcpp::R_PPC_TOC16:
8718 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
8719 _("unsupported reloc %u"),
8727 insn = elfcpp::Swap<32, big_endian>::readval(iview);
8729 if ((insn & (0x3f << 26)) == 56u << 26 /* lq */
8730 || ((insn & (0x3f << 26)) == (61u << 26) /* lxv, stxv */
8731 && (insn & 3) == 1))
8732 status = Reloc::addr16_dq(view, value, overflow);
8734 || (insn & (0x3f << 26)) == 58u << 26 /* ld,ldu,lwa */
8735 || (insn & (0x3f << 26)) == 62u << 26 /* std,stdu,stq */
8736 || (insn & (0x3f << 26)) == 57u << 26 /* lfdp */
8737 || (insn & (0x3f << 26)) == 61u << 26 /* stfdp */)
8738 status = Reloc::addr16_ds(view, value, overflow);
8740 status = Reloc::addr16(view, value, overflow);
8743 if (status != Powerpc_relocate_functions<size, big_endian>::STATUS_OK
8746 && gsym->is_undefined()
8747 && is_branch_reloc(r_type))))
8749 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
8750 _("relocation overflow"));
8752 gold_info(_("try relinking with a smaller --stub-group-size"));
8758 // Relocate section data.
8760 template<int size, bool big_endian>
8762 Target_powerpc<size, big_endian>::relocate_section(
8763 const Relocate_info<size, big_endian>* relinfo,
8764 unsigned int sh_type,
8765 const unsigned char* prelocs,
8767 Output_section* output_section,
8768 bool needs_special_offset_handling,
8769 unsigned char* view,
8771 section_size_type view_size,
8772 const Reloc_symbol_changes* reloc_symbol_changes)
8774 typedef Target_powerpc<size, big_endian> Powerpc;
8775 typedef typename Target_powerpc<size, big_endian>::Relocate Powerpc_relocate;
8776 typedef typename Target_powerpc<size, big_endian>::Relocate_comdat_behavior
8777 Powerpc_comdat_behavior;
8778 typedef gold::Default_classify_reloc<elfcpp::SHT_RELA, size, big_endian>
8781 gold_assert(sh_type == elfcpp::SHT_RELA);
8783 gold::relocate_section<size, big_endian, Powerpc, Powerpc_relocate,
8784 Powerpc_comdat_behavior, Classify_reloc>(
8790 needs_special_offset_handling,
8794 reloc_symbol_changes);
8797 template<int size, bool big_endian>
8798 class Powerpc_scan_relocatable_reloc
8801 typedef typename elfcpp::Rela<size, big_endian> Reltype;
8802 static const int reloc_size = elfcpp::Elf_sizes<size>::rela_size;
8803 static const int sh_type = elfcpp::SHT_RELA;
8805 // Return the symbol referred to by the relocation.
8806 static inline unsigned int
8807 get_r_sym(const Reltype* reloc)
8808 { return elfcpp::elf_r_sym<size>(reloc->get_r_info()); }
8810 // Return the type of the relocation.
8811 static inline unsigned int
8812 get_r_type(const Reltype* reloc)
8813 { return elfcpp::elf_r_type<size>(reloc->get_r_info()); }
8815 // Return the strategy to use for a local symbol which is not a
8816 // section symbol, given the relocation type.
8817 inline Relocatable_relocs::Reloc_strategy
8818 local_non_section_strategy(unsigned int r_type, Relobj*, unsigned int r_sym)
8820 if (r_type == 0 && r_sym == 0)
8821 return Relocatable_relocs::RELOC_DISCARD;
8822 return Relocatable_relocs::RELOC_COPY;
8825 // Return the strategy to use for a local symbol which is a section
8826 // symbol, given the relocation type.
8827 inline Relocatable_relocs::Reloc_strategy
8828 local_section_strategy(unsigned int, Relobj*)
8830 return Relocatable_relocs::RELOC_ADJUST_FOR_SECTION_RELA;
8833 // Return the strategy to use for a global symbol, given the
8834 // relocation type, the object, and the symbol index.
8835 inline Relocatable_relocs::Reloc_strategy
8836 global_strategy(unsigned int r_type, Relobj*, unsigned int)
8838 if (r_type == elfcpp::R_PPC_PLTREL24)
8839 return Relocatable_relocs::RELOC_SPECIAL;
8840 return Relocatable_relocs::RELOC_COPY;
8844 // Scan the relocs during a relocatable link.
8846 template<int size, bool big_endian>
8848 Target_powerpc<size, big_endian>::scan_relocatable_relocs(
8849 Symbol_table* symtab,
8851 Sized_relobj_file<size, big_endian>* object,
8852 unsigned int data_shndx,
8853 unsigned int sh_type,
8854 const unsigned char* prelocs,
8856 Output_section* output_section,
8857 bool needs_special_offset_handling,
8858 size_t local_symbol_count,
8859 const unsigned char* plocal_symbols,
8860 Relocatable_relocs* rr)
8862 typedef Powerpc_scan_relocatable_reloc<size, big_endian> Scan_strategy;
8864 gold_assert(sh_type == elfcpp::SHT_RELA);
8866 gold::scan_relocatable_relocs<size, big_endian, Scan_strategy>(
8874 needs_special_offset_handling,
8880 // Scan the relocs for --emit-relocs.
8882 template<int size, bool big_endian>
8884 Target_powerpc<size, big_endian>::emit_relocs_scan(
8885 Symbol_table* symtab,
8887 Sized_relobj_file<size, big_endian>* object,
8888 unsigned int data_shndx,
8889 unsigned int sh_type,
8890 const unsigned char* prelocs,
8892 Output_section* output_section,
8893 bool needs_special_offset_handling,
8894 size_t local_symbol_count,
8895 const unsigned char* plocal_syms,
8896 Relocatable_relocs* rr)
8898 typedef gold::Default_classify_reloc<elfcpp::SHT_RELA, size, big_endian>
8900 typedef gold::Default_emit_relocs_strategy<Classify_reloc>
8901 Emit_relocs_strategy;
8903 gold_assert(sh_type == elfcpp::SHT_RELA);
8905 gold::scan_relocatable_relocs<size, big_endian, Emit_relocs_strategy>(
8913 needs_special_offset_handling,
8919 // Emit relocations for a section.
8920 // This is a modified version of the function by the same name in
8921 // target-reloc.h. Using relocate_special_relocatable for
8922 // R_PPC_PLTREL24 would require duplication of the entire body of the
8923 // loop, so we may as well duplicate the whole thing.
8925 template<int size, bool big_endian>
8927 Target_powerpc<size, big_endian>::relocate_relocs(
8928 const Relocate_info<size, big_endian>* relinfo,
8929 unsigned int sh_type,
8930 const unsigned char* prelocs,
8932 Output_section* output_section,
8933 typename elfcpp::Elf_types<size>::Elf_Off offset_in_output_section,
8935 Address view_address,
8937 unsigned char* reloc_view,
8938 section_size_type reloc_view_size)
8940 gold_assert(sh_type == elfcpp::SHT_RELA);
8942 typedef typename elfcpp::Rela<size, big_endian> Reltype;
8943 typedef typename elfcpp::Rela_write<size, big_endian> Reltype_write;
8944 const int reloc_size = elfcpp::Elf_sizes<size>::rela_size;
8945 // Offset from start of insn to d-field reloc.
8946 const int d_offset = big_endian ? 2 : 0;
8948 Powerpc_relobj<size, big_endian>* const object
8949 = static_cast<Powerpc_relobj<size, big_endian>*>(relinfo->object);
8950 const unsigned int local_count = object->local_symbol_count();
8951 unsigned int got2_shndx = object->got2_shndx();
8952 Address got2_addend = 0;
8953 if (got2_shndx != 0)
8955 got2_addend = object->get_output_section_offset(got2_shndx);
8956 gold_assert(got2_addend != invalid_address);
8959 unsigned char* pwrite = reloc_view;
8960 bool zap_next = false;
8961 for (size_t i = 0; i < reloc_count; ++i, prelocs += reloc_size)
8963 Relocatable_relocs::Reloc_strategy strategy = relinfo->rr->strategy(i);
8964 if (strategy == Relocatable_relocs::RELOC_DISCARD)
8967 Reltype reloc(prelocs);
8968 Reltype_write reloc_write(pwrite);
8970 Address offset = reloc.get_r_offset();
8971 typename elfcpp::Elf_types<size>::Elf_WXword r_info = reloc.get_r_info();
8972 unsigned int r_sym = elfcpp::elf_r_sym<size>(r_info);
8973 unsigned int r_type = elfcpp::elf_r_type<size>(r_info);
8974 const unsigned int orig_r_sym = r_sym;
8975 typename elfcpp::Elf_types<size>::Elf_Swxword addend
8976 = reloc.get_r_addend();
8977 const Symbol* gsym = NULL;
8981 // We could arrange to discard these and other relocs for
8982 // tls optimised sequences in the strategy methods, but for
8983 // now do as BFD ld does.
8984 r_type = elfcpp::R_POWERPC_NONE;
8988 // Get the new symbol index.
8989 Output_section* os = NULL;
8990 if (r_sym < local_count)
8994 case Relocatable_relocs::RELOC_COPY:
8995 case Relocatable_relocs::RELOC_SPECIAL:
8998 r_sym = object->symtab_index(r_sym);
8999 gold_assert(r_sym != -1U);
9003 case Relocatable_relocs::RELOC_ADJUST_FOR_SECTION_RELA:
9005 // We are adjusting a section symbol. We need to find
9006 // the symbol table index of the section symbol for
9007 // the output section corresponding to input section
9008 // in which this symbol is defined.
9009 gold_assert(r_sym < local_count);
9011 unsigned int shndx =
9012 object->local_symbol_input_shndx(r_sym, &is_ordinary);
9013 gold_assert(is_ordinary);
9014 os = object->output_section(shndx);
9015 gold_assert(os != NULL);
9016 gold_assert(os->needs_symtab_index());
9017 r_sym = os->symtab_index();
9027 gsym = object->global_symbol(r_sym);
9028 gold_assert(gsym != NULL);
9029 if (gsym->is_forwarder())
9030 gsym = relinfo->symtab->resolve_forwards(gsym);
9032 gold_assert(gsym->has_symtab_index());
9033 r_sym = gsym->symtab_index();
9036 // Get the new offset--the location in the output section where
9037 // this relocation should be applied.
9038 if (static_cast<Address>(offset_in_output_section) != invalid_address)
9039 offset += offset_in_output_section;
9042 section_offset_type sot_offset =
9043 convert_types<section_offset_type, Address>(offset);
9044 section_offset_type new_sot_offset =
9045 output_section->output_offset(object, relinfo->data_shndx,
9047 gold_assert(new_sot_offset != -1);
9048 offset = new_sot_offset;
9051 // In an object file, r_offset is an offset within the section.
9052 // In an executable or dynamic object, generated by
9053 // --emit-relocs, r_offset is an absolute address.
9054 if (!parameters->options().relocatable())
9056 offset += view_address;
9057 if (static_cast<Address>(offset_in_output_section) != invalid_address)
9058 offset -= offset_in_output_section;
9061 // Handle the reloc addend based on the strategy.
9062 if (strategy == Relocatable_relocs::RELOC_COPY)
9064 else if (strategy == Relocatable_relocs::RELOC_ADJUST_FOR_SECTION_RELA)
9066 const Symbol_value<size>* psymval = object->local_symbol(orig_r_sym);
9067 gold_assert(os != NULL);
9068 addend = psymval->value(object, addend) - os->address();
9070 else if (strategy == Relocatable_relocs::RELOC_SPECIAL)
9074 if (addend >= 32768)
9075 addend += got2_addend;
9077 else if (r_type == elfcpp::R_POWERPC_REL16_HA)
9079 r_type = elfcpp::R_POWERPC_ADDR16_HA;
9082 else if (r_type == elfcpp::R_POWERPC_REL16_LO)
9084 r_type = elfcpp::R_POWERPC_ADDR16_LO;
9085 addend -= d_offset + 4;
9091 if (!parameters->options().relocatable())
9093 if (r_type == elfcpp::R_POWERPC_GOT_TLSGD16
9094 || r_type == elfcpp::R_POWERPC_GOT_TLSGD16_LO
9095 || r_type == elfcpp::R_POWERPC_GOT_TLSGD16_HI
9096 || r_type == elfcpp::R_POWERPC_GOT_TLSGD16_HA)
9098 // First instruction of a global dynamic sequence,
9100 const bool final = gsym == NULL || gsym->final_value_is_known();
9101 switch (this->optimize_tls_gd(final))
9103 case tls::TLSOPT_TO_IE:
9104 r_type += (elfcpp::R_POWERPC_GOT_TPREL16
9105 - elfcpp::R_POWERPC_GOT_TLSGD16);
9107 case tls::TLSOPT_TO_LE:
9108 if (r_type == elfcpp::R_POWERPC_GOT_TLSGD16
9109 || r_type == elfcpp::R_POWERPC_GOT_TLSGD16_LO)
9110 r_type = elfcpp::R_POWERPC_TPREL16_HA;
9113 r_type = elfcpp::R_POWERPC_NONE;
9121 else if (r_type == elfcpp::R_POWERPC_GOT_TLSLD16
9122 || r_type == elfcpp::R_POWERPC_GOT_TLSLD16_LO
9123 || r_type == elfcpp::R_POWERPC_GOT_TLSLD16_HI
9124 || r_type == elfcpp::R_POWERPC_GOT_TLSLD16_HA)
9126 // First instruction of a local dynamic sequence,
9128 if (this->optimize_tls_ld() == tls::TLSOPT_TO_LE)
9130 if (r_type == elfcpp::R_POWERPC_GOT_TLSLD16
9131 || r_type == elfcpp::R_POWERPC_GOT_TLSLD16_LO)
9133 r_type = elfcpp::R_POWERPC_TPREL16_HA;
9134 const Output_section* os = relinfo->layout->tls_segment()
9136 gold_assert(os != NULL);
9137 gold_assert(os->needs_symtab_index());
9138 r_sym = os->symtab_index();
9139 addend = dtp_offset;
9143 r_type = elfcpp::R_POWERPC_NONE;
9148 else if (r_type == elfcpp::R_POWERPC_GOT_TPREL16
9149 || r_type == elfcpp::R_POWERPC_GOT_TPREL16_LO
9150 || r_type == elfcpp::R_POWERPC_GOT_TPREL16_HI
9151 || r_type == elfcpp::R_POWERPC_GOT_TPREL16_HA)
9153 // First instruction of initial exec sequence.
9154 const bool final = gsym == NULL || gsym->final_value_is_known();
9155 if (this->optimize_tls_ie(final) == tls::TLSOPT_TO_LE)
9157 if (r_type == elfcpp::R_POWERPC_GOT_TPREL16
9158 || r_type == elfcpp::R_POWERPC_GOT_TPREL16_LO)
9159 r_type = elfcpp::R_POWERPC_TPREL16_HA;
9162 r_type = elfcpp::R_POWERPC_NONE;
9167 else if ((size == 64 && r_type == elfcpp::R_PPC64_TLSGD)
9168 || (size == 32 && r_type == elfcpp::R_PPC_TLSGD))
9170 // Second instruction of a global dynamic sequence,
9171 // the __tls_get_addr call
9172 const bool final = gsym == NULL || gsym->final_value_is_known();
9173 switch (this->optimize_tls_gd(final))
9175 case tls::TLSOPT_TO_IE:
9176 r_type = elfcpp::R_POWERPC_NONE;
9179 case tls::TLSOPT_TO_LE:
9180 r_type = elfcpp::R_POWERPC_TPREL16_LO;
9188 else if ((size == 64 && r_type == elfcpp::R_PPC64_TLSLD)
9189 || (size == 32 && r_type == elfcpp::R_PPC_TLSLD))
9191 // Second instruction of a local dynamic sequence,
9192 // the __tls_get_addr call
9193 if (this->optimize_tls_ld() == tls::TLSOPT_TO_LE)
9195 const Output_section* os = relinfo->layout->tls_segment()
9197 gold_assert(os != NULL);
9198 gold_assert(os->needs_symtab_index());
9199 r_sym = os->symtab_index();
9200 addend = dtp_offset;
9201 r_type = elfcpp::R_POWERPC_TPREL16_LO;
9206 else if (r_type == elfcpp::R_POWERPC_TLS)
9208 // Second instruction of an initial exec sequence
9209 const bool final = gsym == NULL || gsym->final_value_is_known();
9210 if (this->optimize_tls_ie(final) == tls::TLSOPT_TO_LE)
9212 r_type = elfcpp::R_POWERPC_TPREL16_LO;
9218 reloc_write.put_r_offset(offset);
9219 reloc_write.put_r_info(elfcpp::elf_r_info<size>(r_sym, r_type));
9220 reloc_write.put_r_addend(addend);
9222 pwrite += reloc_size;
9225 gold_assert(static_cast<section_size_type>(pwrite - reloc_view)
9226 == reloc_view_size);
9229 // Return the value to use for a dynamic symbol which requires special
9230 // treatment. This is how we support equality comparisons of function
9231 // pointers across shared library boundaries, as described in the
9232 // processor specific ABI supplement.
9234 template<int size, bool big_endian>
9236 Target_powerpc<size, big_endian>::do_dynsym_value(const Symbol* gsym) const
9240 gold_assert(gsym->is_from_dynobj() && gsym->has_plt_offset());
9241 for (typename Stub_tables::const_iterator p = this->stub_tables_.begin();
9242 p != this->stub_tables_.end();
9245 Address off = (*p)->find_plt_call_entry(gsym);
9246 if (off != invalid_address)
9247 return (*p)->stub_address() + off;
9250 else if (this->abiversion() >= 2)
9252 Address off = this->glink_section()->find_global_entry(gsym);
9253 if (off != invalid_address)
9254 return this->glink_section()->global_entry_address() + off;
9259 // Return the PLT address to use for a local symbol.
9260 template<int size, bool big_endian>
9262 Target_powerpc<size, big_endian>::do_plt_address_for_local(
9263 const Relobj* object,
9264 unsigned int symndx) const
9268 const Sized_relobj<size, big_endian>* relobj
9269 = static_cast<const Sized_relobj<size, big_endian>*>(object);
9270 for (typename Stub_tables::const_iterator p = this->stub_tables_.begin();
9271 p != this->stub_tables_.end();
9274 Address off = (*p)->find_plt_call_entry(relobj->sized_relobj(),
9276 if (off != invalid_address)
9277 return (*p)->stub_address() + off;
9283 // Return the PLT address to use for a global symbol.
9284 template<int size, bool big_endian>
9286 Target_powerpc<size, big_endian>::do_plt_address_for_global(
9287 const Symbol* gsym) const
9291 for (typename Stub_tables::const_iterator p = this->stub_tables_.begin();
9292 p != this->stub_tables_.end();
9295 Address off = (*p)->find_plt_call_entry(gsym);
9296 if (off != invalid_address)
9297 return (*p)->stub_address() + off;
9300 else if (this->abiversion() >= 2)
9302 Address off = this->glink_section()->find_global_entry(gsym);
9303 if (off != invalid_address)
9304 return this->glink_section()->global_entry_address() + off;
9309 // Return the offset to use for the GOT_INDX'th got entry which is
9310 // for a local tls symbol specified by OBJECT, SYMNDX.
9311 template<int size, bool big_endian>
9313 Target_powerpc<size, big_endian>::do_tls_offset_for_local(
9314 const Relobj* object,
9315 unsigned int symndx,
9316 unsigned int got_indx) const
9318 const Powerpc_relobj<size, big_endian>* ppc_object
9319 = static_cast<const Powerpc_relobj<size, big_endian>*>(object);
9320 if (ppc_object->local_symbol(symndx)->is_tls_symbol())
9322 for (Got_type got_type = GOT_TYPE_TLSGD;
9323 got_type <= GOT_TYPE_TPREL;
9324 got_type = Got_type(got_type + 1))
9325 if (ppc_object->local_has_got_offset(symndx, got_type))
9327 unsigned int off = ppc_object->local_got_offset(symndx, got_type);
9328 if (got_type == GOT_TYPE_TLSGD)
9330 if (off == got_indx * (size / 8))
9332 if (got_type == GOT_TYPE_TPREL)
9342 // Return the offset to use for the GOT_INDX'th got entry which is
9343 // for global tls symbol GSYM.
9344 template<int size, bool big_endian>
9346 Target_powerpc<size, big_endian>::do_tls_offset_for_global(
9348 unsigned int got_indx) const
9350 if (gsym->type() == elfcpp::STT_TLS)
9352 for (Got_type got_type = GOT_TYPE_TLSGD;
9353 got_type <= GOT_TYPE_TPREL;
9354 got_type = Got_type(got_type + 1))
9355 if (gsym->has_got_offset(got_type))
9357 unsigned int off = gsym->got_offset(got_type);
9358 if (got_type == GOT_TYPE_TLSGD)
9360 if (off == got_indx * (size / 8))
9362 if (got_type == GOT_TYPE_TPREL)
9372 // The selector for powerpc object files.
9374 template<int size, bool big_endian>
9375 class Target_selector_powerpc : public Target_selector
9378 Target_selector_powerpc()
9379 : Target_selector(size == 64 ? elfcpp::EM_PPC64 : elfcpp::EM_PPC,
9382 ? (big_endian ? "elf64-powerpc" : "elf64-powerpcle")
9383 : (big_endian ? "elf32-powerpc" : "elf32-powerpcle")),
9385 ? (big_endian ? "elf64ppc" : "elf64lppc")
9386 : (big_endian ? "elf32ppc" : "elf32lppc")))
9390 do_instantiate_target()
9391 { return new Target_powerpc<size, big_endian>(); }
9394 Target_selector_powerpc<32, true> target_selector_ppc32;
9395 Target_selector_powerpc<32, false> target_selector_ppc32le;
9396 Target_selector_powerpc<64, true> target_selector_ppc64;
9397 Target_selector_powerpc<64, false> target_selector_ppc64le;
9399 // Instantiate these constants for -O0
9400 template<int size, bool big_endian>
9401 const int Output_data_glink<size, big_endian>::pltresolve_size;
9402 template<int size, bool big_endian>
9403 const typename Output_data_glink<size, big_endian>::Address
9404 Output_data_glink<size, big_endian>::invalid_address;
9405 template<int size, bool big_endian>
9406 const typename Stub_table<size, big_endian>::Address
9407 Stub_table<size, big_endian>::invalid_address;
9408 template<int size, bool big_endian>
9409 const typename Target_powerpc<size, big_endian>::Address
9410 Target_powerpc<size, big_endian>::invalid_address;
9412 } // End anonymous namespace.