1 // powerpc.cc -- powerpc target support for gold.
3 // Copyright 2008, 2009, 2010, 2011, 2012 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.
27 #include "parameters.h"
34 #include "copy-relocs.h"
36 #include "target-reloc.h"
37 #include "target-select.h"
47 template<int size, bool big_endian>
48 class Output_data_plt_powerpc;
50 template<int size, bool big_endian>
51 class Output_data_got_powerpc;
53 template<int size, bool big_endian>
54 class Output_data_glink;
56 template<int size, bool big_endian>
57 class Powerpc_relobj : public Sized_relobj_file<size, big_endian>
60 typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
61 typedef typename elfcpp::Elf_types<size>::Elf_Off Offset;
62 typedef Unordered_set<Section_id, Section_id_hash> Section_refs;
63 typedef Unordered_map<Address, Section_refs> Access_from;
65 Powerpc_relobj(const std::string& name, Input_file* input_file, off_t offset,
66 const typename elfcpp::Ehdr<size, big_endian>& ehdr)
67 : Sized_relobj_file<size, big_endian>(name, input_file, offset, ehdr),
68 special_(0), opd_valid_(false), opd_ent_(), access_from_map_()
74 // The .got2 section shndx.
79 return this->special_;
84 // The .opd section shndx.
91 return this->special_;
94 // Init OPD entry arrays.
96 init_opd(size_t opd_size)
98 size_t count = this->opd_ent_ndx(opd_size);
99 this->opd_ent_.resize(count);
102 // Return section and offset of function entry for .opd + R_OFF.
104 get_opd_ent(Address r_off, Address* value = NULL) const
106 size_t ndx = this->opd_ent_ndx(r_off);
107 gold_assert(ndx < this->opd_ent_.size());
108 gold_assert(this->opd_ent_[ndx].shndx != 0);
110 *value = this->opd_ent_[ndx].off;
111 return this->opd_ent_[ndx].shndx;
114 // Set section and offset of function entry for .opd + R_OFF.
116 set_opd_ent(Address r_off, unsigned int shndx, Address value)
118 size_t ndx = this->opd_ent_ndx(r_off);
119 gold_assert(ndx < this->opd_ent_.size());
120 this->opd_ent_[ndx].shndx = shndx;
121 this->opd_ent_[ndx].off = value;
124 // Return discard flag for .opd + R_OFF.
126 get_opd_discard(Address r_off) const
128 size_t ndx = this->opd_ent_ndx(r_off);
129 gold_assert(ndx < this->opd_ent_.size());
130 return this->opd_ent_[ndx].discard;
133 // Set discard flag for .opd + R_OFF.
135 set_opd_discard(Address r_off)
137 size_t ndx = this->opd_ent_ndx(r_off);
138 gold_assert(ndx < this->opd_ent_.size());
139 this->opd_ent_[ndx].discard = true;
144 { return &this->access_from_map_; }
146 // Add a reference from SRC_OBJ, SRC_INDX to this object's .opd
147 // section at DST_OFF.
149 add_reference(Object* src_obj,
150 unsigned int src_indx,
151 typename elfcpp::Elf_types<size>::Elf_Addr dst_off)
153 Section_id src_id(src_obj, src_indx);
154 this->access_from_map_[dst_off].insert(src_id);
159 { return this->opd_valid_; }
163 { this->opd_valid_ = true; }
165 // Examine .rela.opd to build info about function entry points.
167 scan_opd_relocs(size_t reloc_count,
168 const unsigned char* prelocs,
169 const unsigned char* plocal_syms);
172 do_read_relocs(Read_relocs_data*);
175 do_find_special_sections(Read_symbols_data* sd);
177 // Adjust this local symbol value. Return false if the symbol
178 // should be discarded from the output file.
180 do_adjust_local_symbol(Symbol_value<size>* lv) const
182 if (size == 64 && this->opd_shndx() != 0)
185 if (lv->input_shndx(&is_ordinary) != this->opd_shndx())
187 if (this->get_opd_discard(lv->input_value()))
193 // Return offset in output GOT section that this object will use
194 // as a TOC pointer. Won't be just a constant with multi-toc support.
196 toc_base_offset() const
207 // Return index into opd_ent_ array for .opd entry at OFF.
208 // .opd entries are 24 bytes long, but they can be spaced 16 bytes
209 // apart when the language doesn't use the last 8-byte word, the
210 // environment pointer. Thus dividing the entry section offset by
211 // 16 will give an index into opd_ent_ that works for either layout
212 // of .opd. (It leaves some elements of the vector unused when .opd
213 // entries are spaced 24 bytes apart, but we don't know the spacing
214 // until relocations are processed, and in any case it is possible
215 // for an object to have some entries spaced 16 bytes apart and
216 // others 24 bytes apart.)
218 opd_ent_ndx(size_t off) const
221 // For 32-bit the .got2 section shdnx, for 64-bit the .opd section shndx.
222 unsigned int special_;
224 // Set at the start of gc_process_relocs, when we know opd_ent_
225 // vector is valid. The flag could be made atomic and set in
226 // do_read_relocs with memory_order_release and then tested with
227 // memory_order_acquire, potentially resulting in fewer entries in
231 // The first 8-byte word of an OPD entry gives the address of the
232 // entry point of the function. Relocatable object files have a
233 // relocation on this word. The following vector records the
234 // section and offset specified by these relocations.
235 std::vector<Opd_ent> opd_ent_;
237 // References made to this object's .opd section when running
238 // gc_process_relocs for another object, before the opd_ent_ vector
239 // is valid for this object.
240 Access_from access_from_map_;
243 template<int size, bool big_endian>
244 class Target_powerpc : public Sized_target<size, big_endian>
248 Output_data_reloc<elfcpp::SHT_RELA, true, size, big_endian> Reloc_section;
249 typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
250 typedef typename elfcpp::Elf_types<size>::Elf_Swxword Signed_address;
251 static const Address invalid_address = static_cast<Address>(0) - 1;
252 // Offset of tp and dtp pointers from start of TLS block.
253 static const Address tp_offset = 0x7000;
254 static const Address dtp_offset = 0x8000;
257 : Sized_target<size, big_endian>(&powerpc_info),
258 got_(NULL), plt_(NULL), iplt_(NULL), glink_(NULL), rela_dyn_(NULL),
259 copy_relocs_(elfcpp::R_POWERPC_COPY),
260 dynbss_(NULL), tlsld_got_offset_(-1U)
264 // Process the relocations to determine unreferenced sections for
265 // garbage collection.
267 gc_process_relocs(Symbol_table* symtab,
269 Sized_relobj_file<size, big_endian>* object,
270 unsigned int data_shndx,
271 unsigned int sh_type,
272 const unsigned char* prelocs,
274 Output_section* output_section,
275 bool needs_special_offset_handling,
276 size_t local_symbol_count,
277 const unsigned char* plocal_symbols);
279 // Scan the relocations to look for symbol adjustments.
281 scan_relocs(Symbol_table* symtab,
283 Sized_relobj_file<size, big_endian>* object,
284 unsigned int data_shndx,
285 unsigned int sh_type,
286 const unsigned char* prelocs,
288 Output_section* output_section,
289 bool needs_special_offset_handling,
290 size_t local_symbol_count,
291 const unsigned char* plocal_symbols);
293 // Map input .toc section to output .got section.
295 do_output_section_name(const Relobj*, const char* name, size_t* plen) const
297 if (size == 64 && strcmp(name, ".toc") == 0)
305 // Finalize the sections.
307 do_finalize_sections(Layout*, const Input_objects*, Symbol_table*);
309 // Return the value to use for a dynamic which requires special
312 do_dynsym_value(const Symbol*) const;
314 // Return the offset to use for the GOT_INDX'th got entry which is
315 // for a local tls symbol specified by OBJECT, SYMNDX.
317 do_tls_offset_for_local(const Relobj* object,
319 unsigned int got_indx) const;
321 // Return the offset to use for the GOT_INDX'th got entry which is
322 // for global tls symbol GSYM.
324 do_tls_offset_for_global(Symbol* gsym, unsigned int got_indx) const;
326 // Relocate a section.
328 relocate_section(const Relocate_info<size, big_endian>*,
329 unsigned int sh_type,
330 const unsigned char* prelocs,
332 Output_section* output_section,
333 bool needs_special_offset_handling,
335 Address view_address,
336 section_size_type view_size,
337 const Reloc_symbol_changes*);
339 // Scan the relocs during a relocatable link.
341 scan_relocatable_relocs(Symbol_table* symtab,
343 Sized_relobj_file<size, big_endian>* object,
344 unsigned int data_shndx,
345 unsigned int sh_type,
346 const unsigned char* prelocs,
348 Output_section* output_section,
349 bool needs_special_offset_handling,
350 size_t local_symbol_count,
351 const unsigned char* plocal_symbols,
352 Relocatable_relocs*);
354 // Emit relocations for a section.
356 relocate_relocs(const Relocate_info<size, big_endian>*,
357 unsigned int sh_type,
358 const unsigned char* prelocs,
360 Output_section* output_section,
361 off_t offset_in_output_section,
362 const Relocatable_relocs*,
364 Address view_address,
366 unsigned char* reloc_view,
367 section_size_type reloc_view_size);
369 // Return whether SYM is defined by the ABI.
371 do_is_defined_by_abi(const Symbol* sym) const
373 return strcmp(sym->name(), "__tls_get_addr") == 0;
376 // Return the size of the GOT section.
380 gold_assert(this->got_ != NULL);
381 return this->got_->data_size();
384 // Get the PLT section.
385 const Output_data_plt_powerpc<size, big_endian>*
388 gold_assert(this->plt_ != NULL);
392 // Get the IPLT section.
393 const Output_data_plt_powerpc<size, big_endian>*
396 gold_assert(this->iplt_ != NULL);
400 // Get the .glink section.
401 const Output_data_glink<size, big_endian>*
402 glink_section() const
404 gold_assert(this->glink_ != NULL);
408 // Get the GOT section.
409 const Output_data_got_powerpc<size, big_endian>*
412 gold_assert(this->got_ != NULL);
417 do_make_elf_object(const std::string&, Input_file*, off_t,
418 const elfcpp::Ehdr<size, big_endian>&);
420 // Return the number of entries in the GOT.
422 got_entry_count() const
424 if (this->got_ == NULL)
426 return this->got_size() / (size / 8);
429 // Return the number of entries in the PLT.
431 plt_entry_count() const;
433 // Return the offset of the first non-reserved PLT entry.
435 first_plt_entry_offset() const;
437 // Return the size of each PLT entry.
439 plt_entry_size() const;
441 // Add any special sections for this symbol to the gc work list.
442 // For powerpc64, this adds the code section of a function
445 do_gc_mark_symbol(Symbol_table* symtab, Symbol* sym) const;
447 // Handle target specific gc actions when adding a gc reference from
448 // SRC_OBJ, SRC_SHNDX to a location specified by DST_OBJ, DST_SHNDX
449 // and DST_OFF. For powerpc64, this adds a referenc to the code
450 // section of a function descriptor.
452 do_gc_add_reference(Symbol_table* symtab,
454 unsigned int src_shndx,
456 unsigned int dst_shndx,
457 Address dst_off) const;
461 // The class which scans relocations.
465 typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
468 : issued_non_pic_error_(false)
472 get_reference_flags(unsigned int r_type);
475 local(Symbol_table* symtab, Layout* layout, Target_powerpc* target,
476 Sized_relobj_file<size, big_endian>* object,
477 unsigned int data_shndx,
478 Output_section* output_section,
479 const elfcpp::Rela<size, big_endian>& reloc, unsigned int r_type,
480 const elfcpp::Sym<size, big_endian>& lsym,
484 global(Symbol_table* symtab, Layout* layout, Target_powerpc* target,
485 Sized_relobj_file<size, big_endian>* object,
486 unsigned int data_shndx,
487 Output_section* output_section,
488 const elfcpp::Rela<size, big_endian>& reloc, unsigned int r_type,
492 local_reloc_may_be_function_pointer(Symbol_table* , Layout* ,
494 Sized_relobj_file<size, big_endian>* ,
497 const elfcpp::Rela<size, big_endian>& ,
499 const elfcpp::Sym<size, big_endian>&)
503 global_reloc_may_be_function_pointer(Symbol_table* , Layout* ,
505 Sized_relobj_file<size, big_endian>* ,
508 const elfcpp::Rela<size,
510 unsigned int , Symbol*)
515 unsupported_reloc_local(Sized_relobj_file<size, big_endian>*,
516 unsigned int r_type);
519 unsupported_reloc_global(Sized_relobj_file<size, big_endian>*,
520 unsigned int r_type, Symbol*);
523 generate_tls_call(Symbol_table* symtab, Layout* layout,
524 Target_powerpc* target);
527 check_non_pic(Relobj*, unsigned int r_type);
530 reloc_needs_plt_for_ifunc(Sized_relobj_file<size, big_endian>* object,
531 unsigned int r_type);
533 // Whether we have issued an error about a non-PIC compilation.
534 bool issued_non_pic_error_;
538 symval_for_branch(Address value, const Sized_symbol<size>* gsym,
539 Powerpc_relobj<size, big_endian>* object,
540 unsigned int *dest_shndx);
542 // The class which implements relocation.
546 // Use 'at' branch hints when true, 'y' when false.
547 // FIXME maybe: set this with an option.
548 static const bool is_isa_v2 = true;
552 CALL_NOT_EXPECTED = 0,
558 : call_tls_get_addr_(CALL_NOT_EXPECTED)
563 if (this->call_tls_get_addr_ != CALL_NOT_EXPECTED)
565 // FIXME: This needs to specify the location somehow.
566 gold_error(_("missing expected __tls_get_addr call"));
570 // Do a relocation. Return false if the caller should not issue
571 // any warnings about this relocation.
573 relocate(const Relocate_info<size, big_endian>*, Target_powerpc*,
574 Output_section*, size_t relnum,
575 const elfcpp::Rela<size, big_endian>&,
576 unsigned int r_type, const Sized_symbol<size>*,
577 const Symbol_value<size>*,
579 typename elfcpp::Elf_types<size>::Elf_Addr,
582 // This is set if we should skip the next reloc, which should be a
583 // call to __tls_get_addr.
584 enum skip_tls call_tls_get_addr_;
587 // A class which returns the size required for a relocation type,
588 // used while scanning relocs during a relocatable link.
589 class Relocatable_size_for_reloc
593 get_size_for_reloc(unsigned int, Relobj*)
600 // Optimize the TLS relocation type based on what we know about the
601 // symbol. IS_FINAL is true if the final address of this symbol is
602 // known at link time.
604 tls::Tls_optimization
605 optimize_tls_gd(bool is_final)
607 // If we are generating a shared library, then we can't do anything
609 if (parameters->options().shared())
610 return tls::TLSOPT_NONE;
613 return tls::TLSOPT_TO_IE;
614 return tls::TLSOPT_TO_LE;
617 tls::Tls_optimization
620 if (parameters->options().shared())
621 return tls::TLSOPT_NONE;
623 return tls::TLSOPT_TO_LE;
626 tls::Tls_optimization
627 optimize_tls_ie(bool is_final)
629 if (!is_final || parameters->options().shared())
630 return tls::TLSOPT_NONE;
632 return tls::TLSOPT_TO_LE;
635 // Get the GOT section, creating it if necessary.
636 Output_data_got_powerpc<size, big_endian>*
637 got_section(Symbol_table*, Layout*);
641 make_glink_section(Layout*);
643 // Create the PLT section.
645 make_plt_section(Layout*);
648 make_iplt_section(Layout*, Symbol_table*);
650 // Create a PLT entry for a global symbol.
652 make_plt_entry(Layout*, Symbol_table*, Symbol*,
653 const elfcpp::Rela<size, big_endian>&,
654 const Sized_relobj_file<size, big_endian>* object);
656 // Create a PLT entry for a local IFUNC symbol.
658 make_local_ifunc_plt_entry(Layout*, Symbol_table*,
659 const elfcpp::Rela<size, big_endian>&,
660 Sized_relobj_file<size, big_endian>*);
662 // Create a GOT entry for local dynamic __tls_get_addr.
664 tlsld_got_offset(Symbol_table* symtab, Layout* layout,
665 Sized_relobj_file<size, big_endian>* object);
668 tlsld_got_offset() const
670 return this->tlsld_got_offset_;
673 // Get the dynamic reloc section, creating it if necessary.
675 rela_dyn_section(Layout*);
677 // Copy a relocation against a global symbol.
679 copy_reloc(Symbol_table* symtab, Layout* layout,
680 Sized_relobj_file<size, big_endian>* object,
681 unsigned int shndx, Output_section* output_section,
682 Symbol* sym, const elfcpp::Rela<size, big_endian>& reloc)
684 this->copy_relocs_.copy_reloc(symtab, layout,
685 symtab->get_sized_symbol<size>(sym),
686 object, shndx, output_section,
687 reloc, this->rela_dyn_section(layout));
690 // Information about this specific target which we pass to the
691 // general Target structure.
692 static Target::Target_info powerpc_info;
694 // The types of GOT entries needed for this platform.
695 // These values are exposed to the ABI in an incremental link.
696 // Do not renumber existing values without changing the version
697 // number of the .gnu_incremental_inputs section.
701 GOT_TYPE_TLSGD, // double entry for @got@tlsgd
702 GOT_TYPE_DTPREL, // entry for @got@dtprel
703 GOT_TYPE_TPREL // entry for @got@tprel
706 // The GOT output section.
707 Output_data_got_powerpc<size, big_endian>* got_;
708 // The PLT output section.
709 Output_data_plt_powerpc<size, big_endian>* plt_;
710 // The IPLT output section.
711 Output_data_plt_powerpc<size, big_endian>* iplt_;
712 // The .glink output section.
713 Output_data_glink<size, big_endian>* glink_;
714 // The dynamic reloc output section.
715 Reloc_section* rela_dyn_;
716 // Relocs saved to avoid a COPY reloc.
717 Copy_relocs<elfcpp::SHT_RELA, size, big_endian> copy_relocs_;
718 // Space for variables copied with a COPY reloc.
719 Output_data_space* dynbss_;
720 // Offset of the GOT entry for local dynamic __tls_get_addr calls.
721 unsigned int tlsld_got_offset_;
725 Target::Target_info Target_powerpc<32, true>::powerpc_info =
728 true, // is_big_endian
729 elfcpp::EM_PPC, // machine_code
730 false, // has_make_symbol
731 false, // has_resolve
732 false, // has_code_fill
733 true, // is_default_stack_executable
734 false, // can_icf_inline_merge_sections
736 "/usr/lib/ld.so.1", // dynamic_linker
737 0x10000000, // default_text_segment_address
738 64 * 1024, // abi_pagesize (overridable by -z max-page-size)
739 4 * 1024, // common_pagesize (overridable by -z common-page-size)
740 false, // isolate_execinstr
742 elfcpp::SHN_UNDEF, // small_common_shndx
743 elfcpp::SHN_UNDEF, // large_common_shndx
744 0, // small_common_section_flags
745 0, // large_common_section_flags
746 NULL, // attributes_section
747 NULL // attributes_vendor
751 Target::Target_info Target_powerpc<32, false>::powerpc_info =
754 false, // is_big_endian
755 elfcpp::EM_PPC, // machine_code
756 false, // has_make_symbol
757 false, // has_resolve
758 false, // has_code_fill
759 true, // is_default_stack_executable
760 false, // can_icf_inline_merge_sections
762 "/usr/lib/ld.so.1", // dynamic_linker
763 0x10000000, // default_text_segment_address
764 64 * 1024, // abi_pagesize (overridable by -z max-page-size)
765 4 * 1024, // common_pagesize (overridable by -z common-page-size)
766 false, // isolate_execinstr
768 elfcpp::SHN_UNDEF, // small_common_shndx
769 elfcpp::SHN_UNDEF, // large_common_shndx
770 0, // small_common_section_flags
771 0, // large_common_section_flags
772 NULL, // attributes_section
773 NULL // attributes_vendor
777 Target::Target_info Target_powerpc<64, true>::powerpc_info =
780 true, // is_big_endian
781 elfcpp::EM_PPC64, // machine_code
782 false, // has_make_symbol
783 false, // has_resolve
784 false, // has_code_fill
785 true, // is_default_stack_executable
786 false, // can_icf_inline_merge_sections
788 "/usr/lib/ld.so.1", // dynamic_linker
789 0x10000000, // default_text_segment_address
790 64 * 1024, // abi_pagesize (overridable by -z max-page-size)
791 4 * 1024, // common_pagesize (overridable by -z common-page-size)
792 false, // isolate_execinstr
794 elfcpp::SHN_UNDEF, // small_common_shndx
795 elfcpp::SHN_UNDEF, // large_common_shndx
796 0, // small_common_section_flags
797 0, // large_common_section_flags
798 NULL, // attributes_section
799 NULL // attributes_vendor
803 Target::Target_info Target_powerpc<64, false>::powerpc_info =
806 false, // is_big_endian
807 elfcpp::EM_PPC64, // machine_code
808 false, // has_make_symbol
809 false, // has_resolve
810 false, // has_code_fill
811 true, // is_default_stack_executable
812 false, // can_icf_inline_merge_sections
814 "/usr/lib/ld.so.1", // dynamic_linker
815 0x10000000, // default_text_segment_address
816 64 * 1024, // abi_pagesize (overridable by -z max-page-size)
817 4 * 1024, // common_pagesize (overridable by -z common-page-size)
818 false, // isolate_execinstr
820 elfcpp::SHN_UNDEF, // small_common_shndx
821 elfcpp::SHN_UNDEF, // large_common_shndx
822 0, // small_common_section_flags
823 0, // large_common_section_flags
824 NULL, // attributes_section
825 NULL // attributes_vendor
829 is_branch_reloc(unsigned int r_type)
831 return (r_type == elfcpp::R_POWERPC_REL24
832 || r_type == elfcpp::R_PPC_PLTREL24
833 || r_type == elfcpp::R_PPC_LOCAL24PC
834 || r_type == elfcpp::R_POWERPC_REL14
835 || r_type == elfcpp::R_POWERPC_REL14_BRTAKEN
836 || r_type == elfcpp::R_POWERPC_REL14_BRNTAKEN
837 || r_type == elfcpp::R_POWERPC_ADDR24
838 || r_type == elfcpp::R_POWERPC_ADDR14
839 || r_type == elfcpp::R_POWERPC_ADDR14_BRTAKEN
840 || r_type == elfcpp::R_POWERPC_ADDR14_BRNTAKEN);
843 // If INSN is an opcode that may be used with an @tls operand, return
844 // the transformed insn for TLS optimisation, otherwise return 0. If
845 // REG is non-zero only match an insn with RB or RA equal to REG.
847 at_tls_transform(uint32_t insn, unsigned int reg)
849 if ((insn & (0x3f << 26)) != 31 << 26)
853 if (reg == 0 || ((insn >> 11) & 0x1f) == reg)
854 rtra = insn & ((1 << 26) - (1 << 16));
855 else if (((insn >> 16) & 0x1f) == reg)
856 rtra = (insn & (0x1f << 21)) | ((insn & (0x1f << 11)) << 5);
860 if ((insn & (0x3ff << 1)) == 266 << 1)
863 else if ((insn & (0x1f << 1)) == 23 << 1
864 && ((insn & (0x1f << 6)) < 14 << 6
865 || ((insn & (0x1f << 6)) >= 16 << 6
866 && (insn & (0x1f << 6)) < 24 << 6)))
867 // load and store indexed -> dform
868 insn = (32 | ((insn >> 6) & 0x1f)) << 26;
869 else if ((insn & (((0x1a << 5) | 0x1f) << 1)) == 21 << 1)
870 // ldx, ldux, stdx, stdux -> ld, ldu, std, stdu
871 insn = ((58 | ((insn >> 6) & 4)) << 26) | ((insn >> 6) & 1);
872 else if ((insn & (((0x1f << 5) | 0x1f) << 1)) == 341 << 1)
874 insn = (58 << 26) | 2;
881 // Modified version of symtab.h class Symbol member
882 // Given a direct absolute or pc-relative static relocation against
883 // the global symbol, this function returns whether a dynamic relocation
888 needs_dynamic_reloc(const Symbol* gsym, int flags)
890 // No dynamic relocations in a static link!
891 if (parameters->doing_static_link())
894 // A reference to an undefined symbol from an executable should be
895 // statically resolved to 0, and does not need a dynamic relocation.
896 // This matches gnu ld behavior.
897 if (gsym->is_undefined() && !parameters->options().shared())
900 // A reference to an absolute symbol does not need a dynamic relocation.
901 if (gsym->is_absolute())
904 // An absolute reference within a position-independent output file
905 // will need a dynamic relocation.
906 if ((flags & Symbol::ABSOLUTE_REF)
907 && parameters->options().output_is_position_independent())
910 // A function call that can branch to a local PLT entry does not need
911 // a dynamic relocation.
912 if ((flags & Symbol::FUNCTION_CALL) && gsym->has_plt_offset())
915 // A reference to any PLT entry in a non-position-independent executable
916 // does not need a dynamic relocation.
917 // Except due to having function descriptors on powerpc64 we don't define
918 // functions to their plt code in an executable, so this doesn't apply.
920 && !parameters->options().output_is_position_independent()
921 && gsym->has_plt_offset())
924 // A reference to a symbol defined in a dynamic object or to a
925 // symbol that is preemptible will need a dynamic relocation.
926 if (gsym->is_from_dynobj()
927 || gsym->is_undefined()
928 || gsym->is_preemptible())
931 // For all other cases, return FALSE.
935 // Modified version of symtab.h class Symbol member
936 // Whether we should use the PLT offset associated with a symbol for
937 // a relocation. FLAGS is a set of Reference_flags.
941 use_plt_offset(const Symbol* gsym, int flags)
943 // If the symbol doesn't have a PLT offset, then naturally we
944 // don't want to use it.
945 if (!gsym->has_plt_offset())
948 // For a STT_GNU_IFUNC symbol we always have to use the PLT entry.
949 if (gsym->type() == elfcpp::STT_GNU_IFUNC)
952 // If we are going to generate a dynamic relocation, then we will
953 // wind up using that, so no need to use the PLT entry.
954 if (needs_dynamic_reloc<size>(gsym, flags))
957 // If the symbol is from a dynamic object, we need to use the PLT
959 if (gsym->is_from_dynobj())
962 // If we are generating a shared object, and gsym symbol is
963 // undefined or preemptible, we need to use the PLT entry.
964 if (parameters->options().shared()
965 && (gsym->is_undefined() || gsym->is_preemptible()))
968 // If gsym is a call to a weak undefined symbol, we need to use
969 // the PLT entry; the symbol may be defined by a library loaded
971 if ((flags & Symbol::FUNCTION_CALL) && gsym->is_weak_undefined())
974 // Otherwise we can use the regular definition.
978 template<int size, bool big_endian>
979 class Powerpc_relocate_functions
996 typedef Powerpc_relocate_functions<size, big_endian> This;
997 typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
999 template<int valsize>
1001 has_overflow_signed(Address value)
1003 // limit = 1 << (valsize - 1) without shift count exceeding size of type
1004 Address limit = static_cast<Address>(1) << ((valsize - 1) >> 1);
1005 limit <<= ((valsize - 1) >> 1);
1006 limit <<= ((valsize - 1) - 2 * ((valsize - 1) >> 1));
1007 return value + limit > (limit << 1) - 1;
1010 template<int valsize>
1012 has_overflow_bitfield(Address value)
1014 Address limit = static_cast<Address>(1) << ((valsize - 1) >> 1);
1015 limit <<= ((valsize - 1) >> 1);
1016 limit <<= ((valsize - 1) - 2 * ((valsize - 1) >> 1));
1017 return value > (limit << 1) - 1 && value + limit > (limit << 1) - 1;
1020 template<int valsize>
1021 static inline Status
1022 overflowed(Address value, Overflow_check overflow)
1024 if (overflow == CHECK_SIGNED)
1026 if (has_overflow_signed<valsize>(value))
1027 return STATUS_OVERFLOW;
1029 else if (overflow == CHECK_BITFIELD)
1031 if (has_overflow_bitfield<valsize>(value))
1032 return STATUS_OVERFLOW;
1037 // Do a simple RELA relocation
1038 template<int valsize>
1039 static inline Status
1040 rela(unsigned char* view, Address value, Overflow_check overflow)
1042 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
1043 Valtype* wv = reinterpret_cast<Valtype*>(view);
1044 elfcpp::Swap<valsize, big_endian>::writeval(wv, value);
1045 return overflowed<valsize>(value, overflow);
1048 template<int valsize>
1049 static inline Status
1050 rela(unsigned char* view,
1051 unsigned int right_shift,
1052 typename elfcpp::Valtype_base<valsize>::Valtype dst_mask,
1054 Overflow_check overflow)
1056 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
1057 Valtype* wv = reinterpret_cast<Valtype*>(view);
1058 Valtype val = elfcpp::Swap<valsize, big_endian>::readval(wv);
1059 Valtype reloc = value >> right_shift;
1062 elfcpp::Swap<valsize, big_endian>::writeval(wv, val | reloc);
1063 return overflowed<valsize>(value >> right_shift, overflow);
1066 // Do a simple RELA relocation, unaligned.
1067 template<int valsize>
1068 static inline Status
1069 rela_ua(unsigned char* view, Address value, Overflow_check overflow)
1071 elfcpp::Swap_unaligned<valsize, big_endian>::writeval(view, value);
1072 return overflowed<valsize>(value, overflow);
1075 template<int valsize>
1076 static inline Status
1077 rela_ua(unsigned char* view,
1078 unsigned int right_shift,
1079 typename elfcpp::Valtype_base<valsize>::Valtype dst_mask,
1081 Overflow_check overflow)
1083 typedef typename elfcpp::Swap_unaligned<valsize, big_endian>::Valtype
1085 Valtype val = elfcpp::Swap<valsize, big_endian>::readval(view);
1086 Valtype reloc = value >> right_shift;
1089 elfcpp::Swap_unaligned<valsize, big_endian>::writeval(view, val | reloc);
1090 return overflowed<valsize>(value >> right_shift, overflow);
1094 // R_PPC64_ADDR64: (Symbol + Addend)
1096 addr64(unsigned char* view, Address value)
1097 { This::template rela<64>(view, value, CHECK_NONE); }
1099 // R_PPC64_UADDR64: (Symbol + Addend) unaligned
1101 addr64_u(unsigned char* view, Address value)
1102 { This::template rela_ua<64>(view, value, CHECK_NONE); }
1104 // R_POWERPC_ADDR32: (Symbol + Addend)
1105 static inline Status
1106 addr32(unsigned char* view, Address value, Overflow_check overflow)
1107 { return This::template rela<32>(view, value, overflow); }
1109 // R_POWERPC_UADDR32: (Symbol + Addend) unaligned
1110 static inline Status
1111 addr32_u(unsigned char* view, Address value, Overflow_check overflow)
1112 { return This::template rela_ua<32>(view, value, overflow); }
1114 // R_POWERPC_ADDR24: (Symbol + Addend) & 0x3fffffc
1115 static inline Status
1116 addr24(unsigned char* view, Address value, Overflow_check overflow)
1118 Status stat = This::template rela<32>(view, 0, 0x03fffffc, value, overflow);
1119 if (overflow != CHECK_NONE && (value & 3) != 0)
1120 stat = STATUS_OVERFLOW;
1124 // R_POWERPC_ADDR16: (Symbol + Addend) & 0xffff
1125 static inline Status
1126 addr16(unsigned char* view, Address value, Overflow_check overflow)
1127 { return This::template rela<16>(view, value, overflow); }
1129 // R_POWERPC_ADDR16: (Symbol + Addend) & 0xffff, unaligned
1130 static inline Status
1131 addr16_u(unsigned char* view, Address value, Overflow_check overflow)
1132 { return This::template rela_ua<16>(view, value, overflow); }
1134 // R_POWERPC_ADDR16_DS: (Symbol + Addend) & 0xfffc
1135 static inline Status
1136 addr16_ds(unsigned char* view, Address value, Overflow_check overflow)
1138 Status stat = This::template rela<16>(view, 0, 0xfffc, value, overflow);
1139 if (overflow != CHECK_NONE && (value & 3) != 0)
1140 stat = STATUS_OVERFLOW;
1144 // R_POWERPC_ADDR16_HI: ((Symbol + Addend) >> 16) & 0xffff
1146 addr16_hi(unsigned char* view, Address value)
1147 { This::template rela<16>(view, 16, 0xffff, value, CHECK_NONE); }
1149 // R_POWERPC_ADDR16_HA: ((Symbol + Addend + 0x8000) >> 16) & 0xffff
1151 addr16_ha(unsigned char* view, Address value)
1152 { This::addr16_hi(view, value + 0x8000); }
1154 // R_POWERPC_ADDR16_HIGHER: ((Symbol + Addend) >> 32) & 0xffff
1156 addr16_hi2(unsigned char* view, Address value)
1157 { This::template rela<16>(view, 32, 0xffff, value, CHECK_NONE); }
1159 // R_POWERPC_ADDR16_HIGHERA: ((Symbol + Addend + 0x8000) >> 32) & 0xffff
1161 addr16_ha2(unsigned char* view, Address value)
1162 { This::addr16_hi2(view, value + 0x8000); }
1164 // R_POWERPC_ADDR16_HIGHEST: ((Symbol + Addend) >> 48) & 0xffff
1166 addr16_hi3(unsigned char* view, Address value)
1167 { This::template rela<16>(view, 48, 0xffff, value, CHECK_NONE); }
1169 // R_POWERPC_ADDR16_HIGHESTA: ((Symbol + Addend + 0x8000) >> 48) & 0xffff
1171 addr16_ha3(unsigned char* view, Address value)
1172 { This::addr16_hi3(view, value + 0x8000); }
1174 // R_POWERPC_ADDR14: (Symbol + Addend) & 0xfffc
1175 static inline Status
1176 addr14(unsigned char* view, Address value, Overflow_check overflow)
1178 Status stat = This::template rela<32>(view, 0, 0xfffc, value, overflow);
1179 if (overflow != CHECK_NONE && (value & 3) != 0)
1180 stat = STATUS_OVERFLOW;
1185 // Stash away the index of .got2 or .opd in a relocatable object, if
1186 // such a section exists.
1188 template<int size, bool big_endian>
1190 Powerpc_relobj<size, big_endian>::do_find_special_sections(
1191 Read_symbols_data* sd)
1193 const unsigned char* const pshdrs = sd->section_headers->data();
1194 const unsigned char* namesu = sd->section_names->data();
1195 const char* names = reinterpret_cast<const char*>(namesu);
1196 section_size_type names_size = sd->section_names_size;
1197 const unsigned char* s;
1199 s = this->find_shdr(pshdrs, size == 32 ? ".got2" : ".opd",
1200 names, names_size, NULL);
1203 unsigned int ndx = (s - pshdrs) / elfcpp::Elf_sizes<size>::shdr_size;
1204 this->special_ = ndx;
1206 return Sized_relobj_file<size, big_endian>::do_find_special_sections(sd);
1209 // Examine .rela.opd to build info about function entry points.
1211 template<int size, bool big_endian>
1213 Powerpc_relobj<size, big_endian>::scan_opd_relocs(
1215 const unsigned char* prelocs,
1216 const unsigned char* plocal_syms)
1220 typedef typename Reloc_types<elfcpp::SHT_RELA, size, big_endian>::Reloc
1222 const int reloc_size
1223 = Reloc_types<elfcpp::SHT_RELA, size, big_endian>::reloc_size;
1224 const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
1225 Address expected_off = 0;
1226 bool regular = true;
1227 unsigned int opd_ent_size = 0;
1229 for (size_t i = 0; i < reloc_count; ++i, prelocs += reloc_size)
1231 Reltype reloc(prelocs);
1232 typename elfcpp::Elf_types<size>::Elf_WXword r_info
1233 = reloc.get_r_info();
1234 unsigned int r_type = elfcpp::elf_r_type<size>(r_info);
1235 if (r_type == elfcpp::R_PPC64_ADDR64)
1237 unsigned int r_sym = elfcpp::elf_r_sym<size>(r_info);
1238 typename elfcpp::Elf_types<size>::Elf_Addr value;
1241 if (r_sym < this->local_symbol_count())
1243 typename elfcpp::Sym<size, big_endian>
1244 lsym(plocal_syms + r_sym * sym_size);
1245 shndx = lsym.get_st_shndx();
1246 shndx = this->adjust_sym_shndx(r_sym, shndx, &is_ordinary);
1247 value = lsym.get_st_value();
1250 shndx = this->symbol_section_and_value(r_sym, &value,
1252 this->set_opd_ent(reloc.get_r_offset(), shndx,
1253 value + reloc.get_r_addend());
1256 expected_off = reloc.get_r_offset();
1257 opd_ent_size = expected_off;
1259 else if (expected_off != reloc.get_r_offset())
1261 expected_off += opd_ent_size;
1263 else if (r_type == elfcpp::R_PPC64_TOC)
1265 if (expected_off - opd_ent_size + 8 != reloc.get_r_offset())
1270 gold_warning(_("%s: unexpected reloc type %u in .opd section"),
1271 this->name().c_str(), r_type);
1275 if (reloc_count <= 2)
1276 opd_ent_size = this->section_size(this->opd_shndx());
1277 if (opd_ent_size != 24 && opd_ent_size != 16)
1281 gold_warning(_("%s: .opd is not a regular array of opd entries"),
1282 this->name().c_str());
1288 template<int size, bool big_endian>
1290 Powerpc_relobj<size, big_endian>::do_read_relocs(Read_relocs_data* rd)
1292 Sized_relobj_file<size, big_endian>::do_read_relocs(rd);
1295 for (Read_relocs_data::Relocs_list::iterator p = rd->relocs.begin();
1296 p != rd->relocs.end();
1299 if (p->data_shndx == this->opd_shndx())
1301 uint64_t opd_size = this->section_size(this->opd_shndx());
1302 gold_assert(opd_size == static_cast<size_t>(opd_size));
1305 this->init_opd(opd_size);
1306 this->scan_opd_relocs(p->reloc_count, p->contents->data(),
1307 rd->local_symbols->data());
1315 // Set up PowerPC target specific relobj.
1317 template<int size, bool big_endian>
1319 Target_powerpc<size, big_endian>::do_make_elf_object(
1320 const std::string& name,
1321 Input_file* input_file,
1322 off_t offset, const elfcpp::Ehdr<size, big_endian>& ehdr)
1324 int et = ehdr.get_e_type();
1325 // ET_EXEC files are valid input for --just-symbols/-R,
1326 // and we treat them as relocatable objects.
1327 if (et == elfcpp::ET_REL
1328 || (et == elfcpp::ET_EXEC && input_file->just_symbols()))
1330 Powerpc_relobj<size, big_endian>* obj =
1331 new Powerpc_relobj<size, big_endian>(name, input_file, offset, ehdr);
1335 else if (et == elfcpp::ET_DYN)
1337 Sized_dynobj<size, big_endian>* obj =
1338 new Sized_dynobj<size, big_endian>(name, input_file, offset, ehdr);
1344 gold_error(_("%s: unsupported ELF file type %d"), name.c_str(), et);
1349 template<int size, bool big_endian>
1350 class Output_data_got_powerpc : public Output_data_got<size, big_endian>
1353 typedef typename elfcpp::Elf_types<size>::Elf_Addr Valtype;
1354 typedef Output_data_reloc<elfcpp::SHT_RELA, true, size, big_endian> Rela_dyn;
1356 Output_data_got_powerpc(Symbol_table* symtab, Layout* layout)
1357 : Output_data_got<size, big_endian>(),
1358 symtab_(symtab), layout_(layout),
1359 header_ent_cnt_(size == 32 ? 3 : 1),
1360 header_index_(size == 32 ? 0x2000 : 0)
1365 // Create a new GOT entry and return its offset.
1367 add_got_entry(Got_entry got_entry)
1369 this->reserve_ent();
1370 return Output_data_got<size, big_endian>::add_got_entry(got_entry);
1373 // Create a pair of new GOT entries and return the offset of the first.
1375 add_got_entry_pair(Got_entry got_entry_1, Got_entry got_entry_2)
1377 this->reserve_ent(2);
1378 return Output_data_got<size, big_endian>::add_got_entry_pair(got_entry_1,
1383 add_constant_pair(Valtype c1, Valtype c2)
1385 this->reserve_ent(2);
1386 unsigned int got_offset = this->add_constant(c1);
1387 this->add_constant(c2);
1391 // Offset of _GLOBAL_OFFSET_TABLE_.
1395 return this->got_offset(this->header_index_);
1398 // Offset of base used to access the GOT/TOC.
1399 // The got/toc pointer reg will be set to this value.
1400 typename elfcpp::Elf_types<size>::Elf_Off
1401 got_base_offset(const Powerpc_relobj<size, big_endian>* object) const
1404 return this->g_o_t();
1406 return (this->output_section()->address()
1407 + object->toc_base_offset()
1411 // Ensure our GOT has a header.
1413 set_final_data_size()
1415 if (this->header_ent_cnt_ != 0)
1416 this->make_header();
1417 Output_data_got<size, big_endian>::set_final_data_size();
1420 // First word of GOT header needs some values that are not
1421 // handled by Output_data_got so poke them in here.
1422 // For 32-bit, address of .dynamic, for 64-bit, address of TOCbase.
1424 do_write(Output_file* of)
1426 this->replace_constant(this->header_index_,
1428 ? this->layout_->dynamic_section()->address()
1429 : this->output_section()->address() + 0x8000));
1431 Output_data_got<size, big_endian>::do_write(of);
1436 reserve_ent(unsigned int cnt = 1)
1438 if (this->header_ent_cnt_ == 0)
1440 if (this->num_entries() + cnt > this->header_index_)
1441 this->make_header();
1447 this->header_ent_cnt_ = 0;
1448 this->header_index_ = this->num_entries();
1451 Output_data_got<size, big_endian>::add_constant(0);
1452 Output_data_got<size, big_endian>::add_constant(0);
1453 Output_data_got<size, big_endian>::add_constant(0);
1455 // Define _GLOBAL_OFFSET_TABLE_ at the header
1456 this->symtab_->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL,
1457 Symbol_table::PREDEFINED,
1458 this, this->g_o_t(), 0,
1465 Output_data_got<size, big_endian>::add_constant(0);
1468 // Stashed pointers.
1469 Symbol_table* symtab_;
1473 unsigned int header_ent_cnt_;
1474 // GOT header index.
1475 unsigned int header_index_;
1478 // Get the GOT section, creating it if necessary.
1480 template<int size, bool big_endian>
1481 Output_data_got_powerpc<size, big_endian>*
1482 Target_powerpc<size, big_endian>::got_section(Symbol_table* symtab,
1485 if (this->got_ == NULL)
1487 gold_assert(symtab != NULL && layout != NULL);
1490 = new Output_data_got_powerpc<size, big_endian>(symtab, layout);
1492 layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS,
1493 elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE,
1494 this->got_, ORDER_DATA, false);
1500 // Get the dynamic reloc section, creating it if necessary.
1502 template<int size, bool big_endian>
1503 typename Target_powerpc<size, big_endian>::Reloc_section*
1504 Target_powerpc<size, big_endian>::rela_dyn_section(Layout* layout)
1506 if (this->rela_dyn_ == NULL)
1508 gold_assert(layout != NULL);
1509 this->rela_dyn_ = new Reloc_section(parameters->options().combreloc());
1510 layout->add_output_section_data(".rela.dyn", elfcpp::SHT_RELA,
1511 elfcpp::SHF_ALLOC, this->rela_dyn_,
1512 ORDER_DYNAMIC_RELOCS, false);
1514 return this->rela_dyn_;
1517 // A class to handle the PLT data.
1519 template<int size, bool big_endian>
1520 class Output_data_plt_powerpc : public Output_section_data_build
1523 typedef Output_data_reloc<elfcpp::SHT_RELA, true,
1524 size, big_endian> Reloc_section;
1526 Output_data_plt_powerpc(Target_powerpc<size, big_endian>* targ,
1527 Reloc_section* plt_rel,
1528 unsigned int reserved_size,
1530 : Output_section_data_build(size == 32 ? 4 : 8),
1533 initial_plt_entry_size_(reserved_size),
1537 // Add an entry to the PLT.
1542 add_ifunc_entry(Symbol*);
1545 add_local_ifunc_entry(Sized_relobj_file<size, big_endian>*, unsigned int);
1547 // Return the .rela.plt section data.
1554 // Return the number of PLT entries.
1558 return ((this->current_data_size() - this->initial_plt_entry_size_)
1562 // Return the offset of the first non-reserved PLT entry.
1564 first_plt_entry_offset()
1565 { return this->initial_plt_entry_size_; }
1567 // Return the size of a PLT entry.
1569 get_plt_entry_size()
1570 { return plt_entry_size; }
1574 do_adjust_output_section(Output_section* os)
1579 // Write to a map file.
1581 do_print_to_mapfile(Mapfile* mapfile) const
1582 { mapfile->print_output_data(this, this->name_); }
1585 // The size of an entry in the PLT.
1586 static const int plt_entry_size = size == 32 ? 4 : 24;
1588 // Write out the PLT data.
1590 do_write(Output_file*);
1592 // The reloc section.
1593 Reloc_section* rel_;
1594 // Allows access to .glink for do_write.
1595 Target_powerpc<size, big_endian>* targ_;
1596 // The size of the first reserved entry.
1597 int initial_plt_entry_size_;
1598 // What to report in map file.
1602 // Add an entry to the PLT.
1604 template<int size, bool big_endian>
1606 Output_data_plt_powerpc<size, big_endian>::add_entry(Symbol* gsym)
1608 if (!gsym->has_plt_offset())
1610 off_t off = this->current_data_size();
1612 off += this->first_plt_entry_offset();
1613 gsym->set_plt_offset(off);
1614 gsym->set_needs_dynsym_entry();
1615 unsigned int dynrel = elfcpp::R_POWERPC_JMP_SLOT;
1616 this->rel_->add_global(gsym, dynrel, this, off, 0);
1617 off += plt_entry_size;
1618 this->set_current_data_size(off);
1622 // Add an entry for a global ifunc symbol that resolves locally, to the IPLT.
1624 template<int size, bool big_endian>
1626 Output_data_plt_powerpc<size, big_endian>::add_ifunc_entry(Symbol* gsym)
1628 if (!gsym->has_plt_offset())
1630 off_t off = this->current_data_size();
1631 gsym->set_plt_offset(off);
1632 unsigned int dynrel = elfcpp::R_POWERPC_IRELATIVE;
1634 dynrel = elfcpp::R_PPC64_JMP_IREL;
1635 this->rel_->add_symbolless_global_addend(gsym, dynrel, this, off, 0);
1636 off += plt_entry_size;
1637 this->set_current_data_size(off);
1641 // Add an entry for a local ifunc symbol to the IPLT.
1643 template<int size, bool big_endian>
1645 Output_data_plt_powerpc<size, big_endian>::add_local_ifunc_entry(
1646 Sized_relobj_file<size, big_endian>* relobj,
1647 unsigned int local_sym_index)
1649 if (!relobj->local_has_plt_offset(local_sym_index))
1651 off_t off = this->current_data_size();
1652 relobj->set_local_plt_offset(local_sym_index, off);
1653 unsigned int dynrel = elfcpp::R_POWERPC_IRELATIVE;
1655 dynrel = elfcpp::R_PPC64_JMP_IREL;
1656 this->rel_->add_symbolless_local_addend(relobj, local_sym_index, dynrel,
1658 off += plt_entry_size;
1659 this->set_current_data_size(off);
1663 static const uint32_t add_0_11_11 = 0x7c0b5a14;
1664 static const uint32_t add_3_3_2 = 0x7c631214;
1665 static const uint32_t add_3_3_13 = 0x7c636a14;
1666 static const uint32_t add_11_0_11 = 0x7d605a14;
1667 static const uint32_t add_12_2_11 = 0x7d825a14;
1668 static const uint32_t addi_11_11 = 0x396b0000;
1669 static const uint32_t addi_12_12 = 0x398c0000;
1670 static const uint32_t addi_2_2 = 0x38420000;
1671 static const uint32_t addi_3_2 = 0x38620000;
1672 static const uint32_t addi_3_3 = 0x38630000;
1673 static const uint32_t addis_0_2 = 0x3c020000;
1674 static const uint32_t addis_0_13 = 0x3c0d0000;
1675 static const uint32_t addis_11_11 = 0x3d6b0000;
1676 static const uint32_t addis_11_30 = 0x3d7e0000;
1677 static const uint32_t addis_12_12 = 0x3d8c0000;
1678 static const uint32_t addis_12_2 = 0x3d820000;
1679 static const uint32_t addis_3_2 = 0x3c620000;
1680 static const uint32_t addis_3_13 = 0x3c6d0000;
1681 static const uint32_t b = 0x48000000;
1682 static const uint32_t bcl_20_31 = 0x429f0005;
1683 static const uint32_t bctr = 0x4e800420;
1684 static const uint32_t blrl = 0x4e800021;
1685 static const uint32_t cror_15_15_15 = 0x4def7b82;
1686 static const uint32_t cror_31_31_31 = 0x4ffffb82;
1687 static const uint32_t ld_11_12 = 0xe96c0000;
1688 static const uint32_t ld_11_2 = 0xe9620000;
1689 static const uint32_t ld_2_1 = 0xe8410000;
1690 static const uint32_t ld_2_11 = 0xe84b0000;
1691 static const uint32_t ld_2_12 = 0xe84c0000;
1692 static const uint32_t ld_2_2 = 0xe8420000;
1693 static const uint32_t li_0_0 = 0x38000000;
1694 static const uint32_t lis_0_0 = 0x3c000000;
1695 static const uint32_t lis_11 = 0x3d600000;
1696 static const uint32_t lis_12 = 0x3d800000;
1697 static const uint32_t lwz_0_12 = 0x800c0000;
1698 static const uint32_t lwz_11_11 = 0x816b0000;
1699 static const uint32_t lwz_11_30 = 0x817e0000;
1700 static const uint32_t lwz_12_12 = 0x818c0000;
1701 static const uint32_t lwzu_0_12 = 0x840c0000;
1702 static const uint32_t mflr_0 = 0x7c0802a6;
1703 static const uint32_t mflr_11 = 0x7d6802a6;
1704 static const uint32_t mflr_12 = 0x7d8802a6;
1705 static const uint32_t mtctr_0 = 0x7c0903a6;
1706 static const uint32_t mtctr_11 = 0x7d6903a6;
1707 static const uint32_t mtlr_0 = 0x7c0803a6;
1708 static const uint32_t mtlr_12 = 0x7d8803a6;
1709 static const uint32_t nop = 0x60000000;
1710 static const uint32_t ori_0_0_0 = 0x60000000;
1711 static const uint32_t std_2_1 = 0xf8410000;
1712 static const uint32_t sub_11_11_12 = 0x7d6c5850;
1714 // Write out the PLT.
1716 template<int size, bool big_endian>
1718 Output_data_plt_powerpc<size, big_endian>::do_write(Output_file* of)
1722 const off_t offset = this->offset();
1723 const section_size_type oview_size
1724 = convert_to_section_size_type(this->data_size());
1725 unsigned char* const oview = of->get_output_view(offset, oview_size);
1726 unsigned char* pov = oview;
1727 unsigned char* endpov = oview + oview_size;
1729 // The address of the .glink branch table
1730 const Output_data_glink<size, big_endian>* glink
1731 = this->targ_->glink_section();
1732 elfcpp::Elf_types<32>::Elf_Addr branch_tab
1733 = glink->address() + glink->pltresolve();
1735 while (pov < endpov)
1737 elfcpp::Swap<32, big_endian>::writeval(pov, branch_tab);
1742 of->write_output_view(offset, oview_size, oview);
1746 // Create the PLT section.
1748 template<int size, bool big_endian>
1750 Target_powerpc<size, big_endian>::make_plt_section(Layout* layout)
1752 if (this->plt_ == NULL)
1754 if (this->glink_ == NULL)
1755 make_glink_section(layout);
1757 // Ensure that .rela.dyn always appears before .rela.plt This is
1758 // necessary due to how, on PowerPC and some other targets, .rela.dyn
1759 // needs to include .rela.plt in it's range.
1760 this->rela_dyn_section(layout);
1762 Reloc_section* plt_rel = new Reloc_section(false);
1763 layout->add_output_section_data(".rela.plt", elfcpp::SHT_RELA,
1764 elfcpp::SHF_ALLOC, plt_rel,
1765 ORDER_DYNAMIC_PLT_RELOCS, false);
1767 = new Output_data_plt_powerpc<size, big_endian>(this, plt_rel,
1768 size == 32 ? 0 : 24,
1770 layout->add_output_section_data(".plt",
1772 ? elfcpp::SHT_PROGBITS
1773 : elfcpp::SHT_NOBITS),
1774 elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE,
1783 // Create the IPLT section.
1785 template<int size, bool big_endian>
1787 Target_powerpc<size, big_endian>::make_iplt_section(Layout* layout,
1788 Symbol_table* symtab)
1790 if (this->iplt_ == NULL)
1792 this->make_plt_section(layout);
1794 Reloc_section* iplt_rel = new Reloc_section(false);
1795 this->rela_dyn_->output_section()->add_output_section_data(iplt_rel);
1797 = new Output_data_plt_powerpc<size, big_endian>(this, iplt_rel,
1799 this->plt_->output_section()->add_output_section_data(this->iplt_);
1800 if (parameters->doing_static_link())
1802 symtab->define_in_output_data("__rela_iplt_start", NULL,
1803 Symbol_table::PREDEFINED,
1805 elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL,
1806 elfcpp::STV_HIDDEN, 0, false, true);
1807 symtab->define_in_output_data("__rela_iplt_end", NULL,
1808 Symbol_table::PREDEFINED,
1810 elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL,
1811 elfcpp::STV_HIDDEN, 0, true, true);
1816 // A class to handle .glink.
1818 template<int size, bool big_endian>
1819 class Output_data_glink : public Output_section_data
1822 static const int pltresolve_size = 16*4;
1824 Output_data_glink(Target_powerpc<size, big_endian>*);
1828 add_entry(const Symbol*, const elfcpp::Rela<size, big_endian>&,
1829 const Sized_relobj_file<size, big_endian>*);
1832 add_entry(unsigned int, const elfcpp::Rela<size, big_endian>&,
1833 const Sized_relobj_file<size, big_endian>*);
1836 find_entry(const Symbol*, const elfcpp::Rela<size, big_endian>&,
1837 const Sized_relobj_file<size, big_endian>*) const;
1840 find_entry(unsigned int, const elfcpp::Rela<size, big_endian>&,
1841 const Sized_relobj_file<size, big_endian>*) const;
1844 glink_entry_size() const
1849 // FIXME: We should be using multiple glink sections for
1850 // stubs to support > 33M applications.
1857 return this->pltresolve_;
1861 // Write to a map file.
1863 do_print_to_mapfile(Mapfile* mapfile) const
1864 { mapfile->print_output_data(this, _("** glink")); }
1868 set_final_data_size();
1872 do_write(Output_file*);
1877 Glink_sym_ent(const Symbol* sym,
1878 const elfcpp::Rela<size, big_endian>& reloc,
1879 const Sized_relobj_file<size, big_endian>* object)
1880 : sym_(sym), object_(0), addend_(0), locsym_(0)
1883 this->addend_ = reloc.get_r_addend();
1884 else if (parameters->options().output_is_position_independent()
1885 && (elfcpp::elf_r_type<size>(reloc.get_r_info())
1886 == elfcpp::R_PPC_PLTREL24))
1888 this->addend_ = reloc.get_r_addend();
1889 if (this->addend_ >= 32768)
1890 this->object_ = object;
1894 Glink_sym_ent(unsigned int locsym_index,
1895 const elfcpp::Rela<size, big_endian>& reloc,
1896 const Sized_relobj_file<size, big_endian>* object)
1897 : sym_(NULL), object_(object), addend_(0), locsym_(locsym_index)
1900 this->addend_ = reloc.get_r_addend();
1901 else if (parameters->options().output_is_position_independent()
1902 && (elfcpp::elf_r_type<size>(reloc.get_r_info())
1903 == elfcpp::R_PPC_PLTREL24))
1904 this->addend_ = reloc.get_r_addend();
1907 bool operator==(const Glink_sym_ent& that) const
1909 return (this->sym_ == that.sym_
1910 && this->object_ == that.object_
1911 && this->addend_ == that.addend_
1912 && this->locsym_ == that.locsym_);
1916 const Sized_relobj_file<size, big_endian>* object_;
1917 typename elfcpp::Elf_types<size>::Elf_Addr addend_;
1918 unsigned int locsym_;
1921 class Glink_sym_ent_hash
1924 size_t operator()(const Glink_sym_ent& ent) const
1926 return (reinterpret_cast<uintptr_t>(ent.sym_)
1927 ^ reinterpret_cast<uintptr_t>(ent.object_)
1933 // Map sym/object/addend to index.
1934 typedef Unordered_map<Glink_sym_ent, unsigned int,
1935 Glink_sym_ent_hash> Glink_entries;
1936 Glink_entries glink_entries_;
1938 // Offset of pltresolve stub (actually, branch table for 32-bit)
1941 // Allows access to .got and .plt for do_write.
1942 Target_powerpc<size, big_endian>* targ_;
1945 // Create the glink section.
1947 template<int size, bool big_endian>
1948 Output_data_glink<size, big_endian>::Output_data_glink(
1949 Target_powerpc<size, big_endian>* targ)
1950 : Output_section_data(16),
1951 pltresolve_(0), targ_(targ)
1955 // Add an entry to glink, if we do not already have one for this
1956 // sym/object/addend combo.
1958 template<int size, bool big_endian>
1960 Output_data_glink<size, big_endian>::add_entry(
1962 const elfcpp::Rela<size, big_endian>& reloc,
1963 const Sized_relobj_file<size, big_endian>* object)
1965 Glink_sym_ent ent(gsym, reloc, object);
1966 unsigned int indx = this->glink_entries_.size();
1967 this->glink_entries_.insert(std::make_pair(ent, indx));
1970 template<int size, bool big_endian>
1972 Output_data_glink<size, big_endian>::add_entry(
1973 unsigned int locsym_index,
1974 const elfcpp::Rela<size, big_endian>& reloc,
1975 const Sized_relobj_file<size, big_endian>* object)
1977 Glink_sym_ent ent(locsym_index, reloc, object);
1978 unsigned int indx = this->glink_entries_.size();
1979 this->glink_entries_.insert(std::make_pair(ent, indx));
1982 template<int size, bool big_endian>
1984 Output_data_glink<size, big_endian>::find_entry(
1986 const elfcpp::Rela<size, big_endian>& reloc,
1987 const Sized_relobj_file<size, big_endian>* object) const
1989 Glink_sym_ent ent(gsym, reloc, object);
1990 typename Glink_entries::const_iterator p = this->glink_entries_.find(ent);
1991 gold_assert(p != this->glink_entries_.end());
1995 template<int size, bool big_endian>
1997 Output_data_glink<size, big_endian>::find_entry(
1998 unsigned int locsym_index,
1999 const elfcpp::Rela<size, big_endian>& reloc,
2000 const Sized_relobj_file<size, big_endian>* object) const
2002 Glink_sym_ent ent(locsym_index, reloc, object);
2003 typename Glink_entries::const_iterator p = this->glink_entries_.find(ent);
2004 gold_assert(p != this->glink_entries_.end());
2008 template<int size, bool big_endian>
2010 Output_data_glink<size, big_endian>::set_final_data_size()
2012 unsigned int count = this->glink_entries_.size();
2013 off_t total = count;
2020 this->pltresolve_ = total;
2022 // space for branch table
2023 total += 4 * (count - 1);
2025 total += -total & 15;
2026 total += this->pltresolve_size;
2031 this->pltresolve_ = total;
2032 total += this->pltresolve_size;
2034 // space for branch table
2037 total += 4 * (count - 0x8000);
2041 this->set_data_size(total);
2044 static inline uint32_t
2050 static inline uint32_t
2056 static inline uint32_t
2059 return hi(a + 0x8000);
2062 template<bool big_endian>
2064 write_insn(unsigned char* p, uint32_t v)
2066 elfcpp::Swap<32, big_endian>::writeval(p, v);
2069 // Write out .glink.
2071 template<int size, bool big_endian>
2073 Output_data_glink<size, big_endian>::do_write(Output_file* of)
2075 const off_t off = this->offset();
2076 const section_size_type oview_size =
2077 convert_to_section_size_type(this->data_size());
2078 unsigned char* const oview = of->get_output_view(off, oview_size);
2081 // The base address of the .plt section.
2082 typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
2083 static const Address invalid_address = static_cast<Address>(0) - 1;
2084 Address plt_base = this->targ_->plt_section()->address();
2085 Address iplt_base = invalid_address;
2087 const Output_data_got_powerpc<size, big_endian>* got
2088 = this->targ_->got_section();
2092 Address got_os_addr = got->output_section()->address();
2094 // Write out call stubs.
2095 typename Glink_entries::const_iterator g;
2096 for (g = this->glink_entries_.begin();
2097 g != this->glink_entries_.end();
2102 const Symbol* gsym = g->first.sym_;
2105 is_ifunc = (gsym->type() == elfcpp::STT_GNU_IFUNC
2106 && gsym->can_use_relative_reloc(false));
2107 plt_addr = gsym->plt_offset();
2112 const Sized_relobj_file<size, big_endian>* relobj
2114 unsigned int local_sym_index = g->first.locsym_;
2115 plt_addr = relobj->local_plt_offset(local_sym_index);
2119 if (iplt_base == invalid_address)
2120 iplt_base = this->targ_->iplt_section()->address();
2121 plt_addr += iplt_base;
2124 plt_addr += plt_base;
2125 const Powerpc_relobj<size, big_endian>* ppcobj = static_cast
2126 <const Powerpc_relobj<size, big_endian>*>(g->first.object_);
2127 Address got_addr = got_os_addr + ppcobj->toc_base_offset();
2128 Address pltoff = plt_addr - got_addr;
2130 if (pltoff + 0x80008000 > 0xffffffff || (pltoff & 7) != 0)
2131 gold_error(_("%s: linkage table error against `%s'"),
2132 g->first.object_->name().c_str(),
2133 g->first.sym_->demangled_name().c_str());
2135 p = oview + g->second * this->glink_entry_size();
2136 if (ha(pltoff) != 0)
2138 write_insn<big_endian>(p, addis_12_2 + ha(pltoff)), p += 4;
2139 write_insn<big_endian>(p, std_2_1 + 40), p += 4;
2140 write_insn<big_endian>(p, ld_11_12 + l(pltoff)), p += 4;
2141 if (ha(pltoff + 16) != ha(pltoff))
2143 write_insn<big_endian>(p, addi_12_12 + l(pltoff)), p += 4;
2146 write_insn<big_endian>(p, mtctr_11), p += 4;
2147 write_insn<big_endian>(p, ld_2_12 + l(pltoff + 8)), p += 4;
2148 write_insn<big_endian>(p, ld_11_12 + l(pltoff + 16)), p += 4;
2149 write_insn<big_endian>(p, bctr), p += 4;
2153 write_insn<big_endian>(p, std_2_1 + 40), p += 4;
2154 write_insn<big_endian>(p, ld_11_2 + l(pltoff)), p += 4;
2155 if (ha(pltoff + 16) != ha(pltoff))
2157 write_insn<big_endian>(p, addi_2_2 + l(pltoff)), p += 4;
2160 write_insn<big_endian>(p, mtctr_11), p += 4;
2161 write_insn<big_endian>(p, ld_11_2 + l(pltoff + 16)), p += 4;
2162 write_insn<big_endian>(p, ld_2_2 + l(pltoff + 8)), p += 4;
2163 write_insn<big_endian>(p, bctr), p += 4;
2167 // Write pltresolve stub.
2168 p = oview + this->pltresolve_;
2169 Address after_bcl = this->address() + this->pltresolve_ + 16;
2170 Address pltoff = plt_base - after_bcl;
2172 elfcpp::Swap<64, big_endian>::writeval(p, pltoff), p += 8;
2174 write_insn<big_endian>(p, mflr_12), p += 4;
2175 write_insn<big_endian>(p, bcl_20_31), p += 4;
2176 write_insn<big_endian>(p, mflr_11), p += 4;
2177 write_insn<big_endian>(p, ld_2_11 + l(-16)), p += 4;
2178 write_insn<big_endian>(p, mtlr_12), p += 4;
2179 write_insn<big_endian>(p, add_12_2_11), p += 4;
2180 write_insn<big_endian>(p, ld_11_12 + 0), p += 4;
2181 write_insn<big_endian>(p, ld_2_12 + 8), p += 4;
2182 write_insn<big_endian>(p, mtctr_11), p += 4;
2183 write_insn<big_endian>(p, ld_11_12 + 16), p += 4;
2184 write_insn<big_endian>(p, bctr), p += 4;
2185 while (p < oview + this->pltresolve_ + this->pltresolve_size)
2186 write_insn<big_endian>(p, nop), p += 4;
2188 // Write lazy link call stubs.
2190 while (p < oview + oview_size)
2194 write_insn<big_endian>(p, li_0_0 + indx), p += 4;
2198 write_insn<big_endian>(p, lis_0_0 + hi(indx)), p += 4;
2199 write_insn<big_endian>(p, ori_0_0_0 + l(indx)), p += 4;
2201 uint32_t branch_off = this->pltresolve_ + 8 - (p - oview);
2202 write_insn<big_endian>(p, b + (branch_off & 0x3fffffc)), p += 4;
2208 // The address of _GLOBAL_OFFSET_TABLE_.
2209 Address g_o_t = got->address() + got->g_o_t();
2211 // Write out call stubs.
2212 typename Glink_entries::const_iterator g;
2213 for (g = this->glink_entries_.begin();
2214 g != this->glink_entries_.end();
2219 const Symbol* gsym = g->first.sym_;
2222 is_ifunc = (gsym->type() == elfcpp::STT_GNU_IFUNC
2223 && gsym->can_use_relative_reloc(false));
2224 plt_addr = gsym->plt_offset();
2229 const Sized_relobj_file<size, big_endian>* relobj
2231 unsigned int local_sym_index = g->first.locsym_;
2232 plt_addr = relobj->local_plt_offset(local_sym_index);
2236 if (iplt_base == invalid_address)
2237 iplt_base = this->targ_->iplt_section()->address();
2238 plt_addr += iplt_base;
2241 plt_addr += plt_base;
2243 p = oview + g->second * this->glink_entry_size();
2244 if (parameters->options().output_is_position_independent())
2247 const Powerpc_relobj<size, big_endian>* object = static_cast
2248 <const Powerpc_relobj<size, big_endian>*>(g->first.object_);
2249 if (object != NULL && g->first.addend_ >= 32768)
2251 unsigned int got2 = object->got2_shndx();
2252 got_addr = g->first.object_->get_output_section_offset(got2);
2253 gold_assert(got_addr != invalid_address);
2254 got_addr += (g->first.object_->output_section(got2)->address()
2255 + g->first.addend_);
2260 Address pltoff = plt_addr - got_addr;
2261 if (ha(pltoff) == 0)
2263 write_insn<big_endian>(p + 0, lwz_11_30 + l(pltoff));
2264 write_insn<big_endian>(p + 4, mtctr_11);
2265 write_insn<big_endian>(p + 8, bctr);
2269 write_insn<big_endian>(p + 0, addis_11_30 + ha(pltoff));
2270 write_insn<big_endian>(p + 4, lwz_11_11 + l(pltoff));
2271 write_insn<big_endian>(p + 8, mtctr_11);
2272 write_insn<big_endian>(p + 12, bctr);
2277 write_insn<big_endian>(p + 0, lis_11 + ha(plt_addr));
2278 write_insn<big_endian>(p + 4, lwz_11_11 + l(plt_addr));
2279 write_insn<big_endian>(p + 8, mtctr_11);
2280 write_insn<big_endian>(p + 12, bctr);
2284 // Write out pltresolve branch table.
2285 p = oview + this->pltresolve_;
2286 unsigned int the_end = oview_size - this->pltresolve_size;
2287 unsigned char* end_p = oview + the_end;
2288 while (p < end_p - 8 * 4)
2289 write_insn<big_endian>(p, b + end_p - p), p += 4;
2291 write_insn<big_endian>(p, nop), p += 4;
2293 // Write out pltresolve call stub.
2294 if (parameters->options().output_is_position_independent())
2296 Address res0_off = this->pltresolve_;
2297 Address after_bcl_off = the_end + 12;
2298 Address bcl_res0 = after_bcl_off - res0_off;
2300 write_insn<big_endian>(p + 0, addis_11_11 + ha(bcl_res0));
2301 write_insn<big_endian>(p + 4, mflr_0);
2302 write_insn<big_endian>(p + 8, bcl_20_31);
2303 write_insn<big_endian>(p + 12, addi_11_11 + l(bcl_res0));
2304 write_insn<big_endian>(p + 16, mflr_12);
2305 write_insn<big_endian>(p + 20, mtlr_0);
2306 write_insn<big_endian>(p + 24, sub_11_11_12);
2308 Address got_bcl = g_o_t + 4 - (after_bcl_off + this->address());
2310 write_insn<big_endian>(p + 28, addis_12_12 + ha(got_bcl));
2311 if (ha(got_bcl) == ha(got_bcl + 4))
2313 write_insn<big_endian>(p + 32, lwz_0_12 + l(got_bcl));
2314 write_insn<big_endian>(p + 36, lwz_12_12 + l(got_bcl + 4));
2318 write_insn<big_endian>(p + 32, lwzu_0_12 + l(got_bcl));
2319 write_insn<big_endian>(p + 36, lwz_12_12 + 4);
2321 write_insn<big_endian>(p + 40, mtctr_0);
2322 write_insn<big_endian>(p + 44, add_0_11_11);
2323 write_insn<big_endian>(p + 48, add_11_0_11);
2324 write_insn<big_endian>(p + 52, bctr);
2325 write_insn<big_endian>(p + 56, nop);
2326 write_insn<big_endian>(p + 60, nop);
2330 Address res0 = this->pltresolve_ + this->address();
2332 write_insn<big_endian>(p + 0, lis_12 + ha(g_o_t + 4));
2333 write_insn<big_endian>(p + 4, addis_11_11 + ha(-res0));
2334 if (ha(g_o_t + 4) == ha(g_o_t + 8))
2335 write_insn<big_endian>(p + 8, lwz_0_12 + l(g_o_t + 4));
2337 write_insn<big_endian>(p + 8, lwzu_0_12 + l(g_o_t + 4));
2338 write_insn<big_endian>(p + 12, addi_11_11 + l(-res0));
2339 write_insn<big_endian>(p + 16, mtctr_0);
2340 write_insn<big_endian>(p + 20, add_0_11_11);
2341 if (ha(g_o_t + 4) == ha(g_o_t + 8))
2342 write_insn<big_endian>(p + 24, lwz_12_12 + l(g_o_t + 8));
2344 write_insn<big_endian>(p + 24, lwz_12_12 + 4);
2345 write_insn<big_endian>(p + 28, add_11_0_11);
2346 write_insn<big_endian>(p + 32, bctr);
2347 write_insn<big_endian>(p + 36, nop);
2348 write_insn<big_endian>(p + 40, nop);
2349 write_insn<big_endian>(p + 44, nop);
2350 write_insn<big_endian>(p + 48, nop);
2351 write_insn<big_endian>(p + 52, nop);
2352 write_insn<big_endian>(p + 56, nop);
2353 write_insn<big_endian>(p + 60, nop);
2358 of->write_output_view(off, oview_size, oview);
2361 // Create the glink section.
2363 template<int size, bool big_endian>
2365 Target_powerpc<size, big_endian>::make_glink_section(Layout* layout)
2367 if (this->glink_ == NULL)
2369 this->glink_ = new Output_data_glink<size, big_endian>(this);
2370 layout->add_output_section_data(".text", elfcpp::SHT_PROGBITS,
2371 elfcpp::SHF_ALLOC | elfcpp::SHF_EXECINSTR,
2372 this->glink_, ORDER_TEXT, false);
2376 // Create a PLT entry for a global symbol.
2378 template<int size, bool big_endian>
2380 Target_powerpc<size, big_endian>::make_plt_entry(
2382 Symbol_table* symtab,
2384 const elfcpp::Rela<size, big_endian>& reloc,
2385 const Sized_relobj_file<size, big_endian>* object)
2387 if (gsym->type() == elfcpp::STT_GNU_IFUNC
2388 && gsym->can_use_relative_reloc(false))
2390 if (this->iplt_ == NULL)
2391 this->make_iplt_section(layout, symtab);
2392 this->iplt_->add_ifunc_entry(gsym);
2396 if (this->plt_ == NULL)
2397 this->make_plt_section(layout);
2398 this->plt_->add_entry(gsym);
2400 this->glink_->add_entry(gsym, reloc, object);
2403 // Make a PLT entry for a local STT_GNU_IFUNC symbol.
2405 template<int size, bool big_endian>
2407 Target_powerpc<size, big_endian>::make_local_ifunc_plt_entry(
2409 Symbol_table* symtab,
2410 const elfcpp::Rela<size, big_endian>& reloc,
2411 Sized_relobj_file<size, big_endian>* relobj)
2413 if (this->iplt_ == NULL)
2414 this->make_iplt_section(layout, symtab);
2415 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
2416 this->iplt_->add_local_ifunc_entry(relobj, r_sym);
2417 this->glink_->add_entry(r_sym, reloc, relobj);
2420 // Return the number of entries in the PLT.
2422 template<int size, bool big_endian>
2424 Target_powerpc<size, big_endian>::plt_entry_count() const
2426 if (this->plt_ == NULL)
2428 unsigned int count = this->plt_->entry_count();
2429 if (this->iplt_ != NULL)
2430 count += this->iplt_->entry_count();
2434 // Return the offset of the first non-reserved PLT entry.
2436 template<int size, bool big_endian>
2438 Target_powerpc<size, big_endian>::first_plt_entry_offset() const
2440 return this->plt_->first_plt_entry_offset();
2443 // Return the size of each PLT entry.
2445 template<int size, bool big_endian>
2447 Target_powerpc<size, big_endian>::plt_entry_size() const
2449 return Output_data_plt_powerpc<size, big_endian>::get_plt_entry_size();
2452 // Create a GOT entry for local dynamic __tls_get_addr calls.
2454 template<int size, bool big_endian>
2456 Target_powerpc<size, big_endian>::tlsld_got_offset(
2457 Symbol_table* symtab,
2459 Sized_relobj_file<size, big_endian>* object)
2461 if (this->tlsld_got_offset_ == -1U)
2463 gold_assert(symtab != NULL && layout != NULL && object != NULL);
2464 Reloc_section* rela_dyn = this->rela_dyn_section(layout);
2465 Output_data_got_powerpc<size, big_endian>* got
2466 = this->got_section(symtab, layout);
2467 unsigned int got_offset = got->add_constant_pair(0, 0);
2468 rela_dyn->add_local(object, 0, elfcpp::R_POWERPC_DTPMOD, got,
2470 this->tlsld_got_offset_ = got_offset;
2472 return this->tlsld_got_offset_;
2475 // Get the Reference_flags for a particular relocation.
2477 template<int size, bool big_endian>
2479 Target_powerpc<size, big_endian>::Scan::get_reference_flags(unsigned int r_type)
2483 case elfcpp::R_POWERPC_NONE:
2484 case elfcpp::R_POWERPC_GNU_VTINHERIT:
2485 case elfcpp::R_POWERPC_GNU_VTENTRY:
2486 case elfcpp::R_PPC64_TOC:
2487 // No symbol reference.
2490 case elfcpp::R_PPC64_ADDR64:
2491 case elfcpp::R_PPC64_UADDR64:
2492 case elfcpp::R_POWERPC_ADDR32:
2493 case elfcpp::R_POWERPC_UADDR32:
2494 case elfcpp::R_POWERPC_ADDR16:
2495 case elfcpp::R_POWERPC_UADDR16:
2496 case elfcpp::R_POWERPC_ADDR16_LO:
2497 case elfcpp::R_POWERPC_ADDR16_HI:
2498 case elfcpp::R_POWERPC_ADDR16_HA:
2499 return Symbol::ABSOLUTE_REF;
2501 case elfcpp::R_POWERPC_ADDR24:
2502 case elfcpp::R_POWERPC_ADDR14:
2503 case elfcpp::R_POWERPC_ADDR14_BRTAKEN:
2504 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN:
2505 return Symbol::FUNCTION_CALL | Symbol::ABSOLUTE_REF;
2507 case elfcpp::R_PPC64_REL64:
2508 case elfcpp::R_POWERPC_REL32:
2509 case elfcpp::R_PPC_LOCAL24PC:
2510 case elfcpp::R_POWERPC_REL16:
2511 case elfcpp::R_POWERPC_REL16_LO:
2512 case elfcpp::R_POWERPC_REL16_HI:
2513 case elfcpp::R_POWERPC_REL16_HA:
2514 return Symbol::RELATIVE_REF;
2516 case elfcpp::R_POWERPC_REL24:
2517 case elfcpp::R_PPC_PLTREL24:
2518 case elfcpp::R_POWERPC_REL14:
2519 case elfcpp::R_POWERPC_REL14_BRTAKEN:
2520 case elfcpp::R_POWERPC_REL14_BRNTAKEN:
2521 return Symbol::FUNCTION_CALL | Symbol::RELATIVE_REF;
2523 case elfcpp::R_POWERPC_GOT16:
2524 case elfcpp::R_POWERPC_GOT16_LO:
2525 case elfcpp::R_POWERPC_GOT16_HI:
2526 case elfcpp::R_POWERPC_GOT16_HA:
2527 case elfcpp::R_PPC64_GOT16_DS:
2528 case elfcpp::R_PPC64_GOT16_LO_DS:
2529 case elfcpp::R_PPC64_TOC16:
2530 case elfcpp::R_PPC64_TOC16_LO:
2531 case elfcpp::R_PPC64_TOC16_HI:
2532 case elfcpp::R_PPC64_TOC16_HA:
2533 case elfcpp::R_PPC64_TOC16_DS:
2534 case elfcpp::R_PPC64_TOC16_LO_DS:
2536 return Symbol::ABSOLUTE_REF;
2538 case elfcpp::R_POWERPC_GOT_TPREL16:
2539 case elfcpp::R_POWERPC_TLS:
2540 return Symbol::TLS_REF;
2542 case elfcpp::R_POWERPC_COPY:
2543 case elfcpp::R_POWERPC_GLOB_DAT:
2544 case elfcpp::R_POWERPC_JMP_SLOT:
2545 case elfcpp::R_POWERPC_RELATIVE:
2546 case elfcpp::R_POWERPC_DTPMOD:
2548 // Not expected. We will give an error later.
2553 // Report an unsupported relocation against a local symbol.
2555 template<int size, bool big_endian>
2557 Target_powerpc<size, big_endian>::Scan::unsupported_reloc_local(
2558 Sized_relobj_file<size, big_endian>* object,
2559 unsigned int r_type)
2561 gold_error(_("%s: unsupported reloc %u against local symbol"),
2562 object->name().c_str(), r_type);
2565 // We are about to emit a dynamic relocation of type R_TYPE. If the
2566 // dynamic linker does not support it, issue an error.
2568 template<int size, bool big_endian>
2570 Target_powerpc<size, big_endian>::Scan::check_non_pic(Relobj* object,
2571 unsigned int r_type)
2573 gold_assert(r_type != elfcpp::R_POWERPC_NONE);
2575 // These are the relocation types supported by glibc for both 32-bit
2576 // and 64-bit powerpc.
2579 case elfcpp::R_POWERPC_NONE:
2580 case elfcpp::R_POWERPC_RELATIVE:
2581 case elfcpp::R_POWERPC_GLOB_DAT:
2582 case elfcpp::R_POWERPC_DTPMOD:
2583 case elfcpp::R_POWERPC_DTPREL:
2584 case elfcpp::R_POWERPC_TPREL:
2585 case elfcpp::R_POWERPC_JMP_SLOT:
2586 case elfcpp::R_POWERPC_COPY:
2587 case elfcpp::R_POWERPC_IRELATIVE:
2588 case elfcpp::R_POWERPC_ADDR32:
2589 case elfcpp::R_POWERPC_UADDR32:
2590 case elfcpp::R_POWERPC_ADDR24:
2591 case elfcpp::R_POWERPC_ADDR16:
2592 case elfcpp::R_POWERPC_UADDR16:
2593 case elfcpp::R_POWERPC_ADDR16_LO:
2594 case elfcpp::R_POWERPC_ADDR16_HI:
2595 case elfcpp::R_POWERPC_ADDR16_HA:
2596 case elfcpp::R_POWERPC_ADDR14:
2597 case elfcpp::R_POWERPC_ADDR14_BRTAKEN:
2598 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN:
2599 case elfcpp::R_POWERPC_REL32:
2600 case elfcpp::R_POWERPC_REL24:
2601 case elfcpp::R_POWERPC_TPREL16:
2602 case elfcpp::R_POWERPC_TPREL16_LO:
2603 case elfcpp::R_POWERPC_TPREL16_HI:
2604 case elfcpp::R_POWERPC_TPREL16_HA:
2615 // These are the relocation types supported only on 64-bit.
2616 case elfcpp::R_PPC64_ADDR64:
2617 case elfcpp::R_PPC64_UADDR64:
2618 case elfcpp::R_PPC64_JMP_IREL:
2619 case elfcpp::R_PPC64_ADDR16_DS:
2620 case elfcpp::R_PPC64_ADDR16_LO_DS:
2621 case elfcpp::R_PPC64_ADDR16_HIGHER:
2622 case elfcpp::R_PPC64_ADDR16_HIGHEST:
2623 case elfcpp::R_PPC64_ADDR16_HIGHERA:
2624 case elfcpp::R_PPC64_ADDR16_HIGHESTA:
2625 case elfcpp::R_PPC64_REL64:
2626 case elfcpp::R_POWERPC_ADDR30:
2627 case elfcpp::R_PPC64_TPREL16_DS:
2628 case elfcpp::R_PPC64_TPREL16_LO_DS:
2629 case elfcpp::R_PPC64_TPREL16_HIGHER:
2630 case elfcpp::R_PPC64_TPREL16_HIGHEST:
2631 case elfcpp::R_PPC64_TPREL16_HIGHERA:
2632 case elfcpp::R_PPC64_TPREL16_HIGHESTA:
2643 // These are the relocation types supported only on 32-bit.
2644 // ??? glibc ld.so doesn't need to support these.
2645 case elfcpp::R_POWERPC_DTPREL16:
2646 case elfcpp::R_POWERPC_DTPREL16_LO:
2647 case elfcpp::R_POWERPC_DTPREL16_HI:
2648 case elfcpp::R_POWERPC_DTPREL16_HA:
2656 // This prevents us from issuing more than one error per reloc
2657 // section. But we can still wind up issuing more than one
2658 // error per object file.
2659 if (this->issued_non_pic_error_)
2661 gold_assert(parameters->options().output_is_position_independent());
2662 object->error(_("requires unsupported dynamic reloc; "
2663 "recompile with -fPIC"));
2664 this->issued_non_pic_error_ = true;
2668 // Return whether we need to make a PLT entry for a relocation of the
2669 // given type against a STT_GNU_IFUNC symbol.
2671 template<int size, bool big_endian>
2673 Target_powerpc<size, big_endian>::Scan::reloc_needs_plt_for_ifunc(
2674 Sized_relobj_file<size, big_endian>* object,
2675 unsigned int r_type)
2679 // Word size refs from data sections are OK.
2680 case elfcpp::R_POWERPC_ADDR32:
2681 case elfcpp::R_POWERPC_UADDR32:
2686 case elfcpp::R_PPC64_ADDR64:
2687 case elfcpp::R_PPC64_UADDR64:
2692 // GOT refs are good.
2693 case elfcpp::R_POWERPC_GOT16:
2694 case elfcpp::R_POWERPC_GOT16_LO:
2695 case elfcpp::R_POWERPC_GOT16_HI:
2696 case elfcpp::R_POWERPC_GOT16_HA:
2697 case elfcpp::R_PPC64_GOT16_DS:
2698 case elfcpp::R_PPC64_GOT16_LO_DS:
2701 // So are function calls.
2702 case elfcpp::R_POWERPC_ADDR24:
2703 case elfcpp::R_POWERPC_ADDR14:
2704 case elfcpp::R_POWERPC_ADDR14_BRTAKEN:
2705 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN:
2706 case elfcpp::R_POWERPC_REL24:
2707 case elfcpp::R_PPC_PLTREL24:
2708 case elfcpp::R_POWERPC_REL14:
2709 case elfcpp::R_POWERPC_REL14_BRTAKEN:
2710 case elfcpp::R_POWERPC_REL14_BRNTAKEN:
2717 // Anything else is a problem.
2718 // If we are building a static executable, the libc startup function
2719 // responsible for applying indirect function relocations is going
2720 // to complain about the reloc type.
2721 // If we are building a dynamic executable, we will have a text
2722 // relocation. The dynamic loader will set the text segment
2723 // writable and non-executable to apply text relocations. So we'll
2724 // segfault when trying to run the indirection function to resolve
2726 gold_error(_("%s: unsupported reloc %u for IFUNC symbol"),
2727 object->name().c_str(), r_type);
2731 // Scan a relocation for a local symbol.
2733 template<int size, bool big_endian>
2735 Target_powerpc<size, big_endian>::Scan::local(
2736 Symbol_table* symtab,
2738 Target_powerpc<size, big_endian>* target,
2739 Sized_relobj_file<size, big_endian>* object,
2740 unsigned int data_shndx,
2741 Output_section* output_section,
2742 const elfcpp::Rela<size, big_endian>& reloc,
2743 unsigned int r_type,
2744 const elfcpp::Sym<size, big_endian>& lsym,
2747 Powerpc_relobj<size, big_endian>* ppc_object
2748 = static_cast<Powerpc_relobj<size, big_endian>*>(object);
2753 && data_shndx == ppc_object->opd_shndx()
2754 && r_type == elfcpp::R_PPC64_ADDR64)
2755 ppc_object->set_opd_discard(reloc.get_r_offset());
2759 // A local STT_GNU_IFUNC symbol may require a PLT entry.
2760 bool is_ifunc = lsym.get_st_type() == elfcpp::STT_GNU_IFUNC;
2761 if (is_ifunc && this->reloc_needs_plt_for_ifunc(object, r_type))
2762 target->make_local_ifunc_plt_entry(layout, symtab, reloc, object);
2766 case elfcpp::R_POWERPC_NONE:
2767 case elfcpp::R_POWERPC_GNU_VTINHERIT:
2768 case elfcpp::R_POWERPC_GNU_VTENTRY:
2769 case elfcpp::R_PPC64_TOCSAVE:
2770 case elfcpp::R_PPC_EMB_MRKREF:
2771 case elfcpp::R_POWERPC_TLS:
2774 case elfcpp::R_PPC64_TOC:
2776 Output_data_got_powerpc<size, big_endian>* got
2777 = target->got_section(symtab, layout);
2778 if (parameters->options().output_is_position_independent())
2780 Address off = reloc.get_r_offset();
2782 && data_shndx == ppc_object->opd_shndx()
2783 && ppc_object->get_opd_discard(off - 8))
2786 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
2787 Powerpc_relobj<size, big_endian>* symobj = ppc_object;
2788 rela_dyn->add_output_section_relative(got->output_section(),
2789 elfcpp::R_POWERPC_RELATIVE,
2791 object, data_shndx, off,
2792 symobj->toc_base_offset());
2797 case elfcpp::R_PPC64_ADDR64:
2798 case elfcpp::R_PPC64_UADDR64:
2799 case elfcpp::R_POWERPC_ADDR32:
2800 case elfcpp::R_POWERPC_UADDR32:
2801 case elfcpp::R_POWERPC_ADDR24:
2802 case elfcpp::R_POWERPC_ADDR16:
2803 case elfcpp::R_POWERPC_ADDR16_LO:
2804 case elfcpp::R_POWERPC_ADDR16_HI:
2805 case elfcpp::R_POWERPC_ADDR16_HA:
2806 case elfcpp::R_POWERPC_UADDR16:
2807 case elfcpp::R_PPC64_ADDR16_HIGHER:
2808 case elfcpp::R_PPC64_ADDR16_HIGHERA:
2809 case elfcpp::R_PPC64_ADDR16_HIGHEST:
2810 case elfcpp::R_PPC64_ADDR16_HIGHESTA:
2811 case elfcpp::R_PPC64_ADDR16_DS:
2812 case elfcpp::R_PPC64_ADDR16_LO_DS:
2813 case elfcpp::R_POWERPC_ADDR14:
2814 case elfcpp::R_POWERPC_ADDR14_BRTAKEN:
2815 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN:
2816 // If building a shared library (or a position-independent
2817 // executable), we need to create a dynamic relocation for
2819 if (parameters->options().output_is_position_independent())
2821 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
2823 if ((size == 32 && r_type == elfcpp::R_POWERPC_ADDR32)
2824 || (size == 64 && r_type == elfcpp::R_PPC64_ADDR64))
2826 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
2827 unsigned int dynrel = elfcpp::R_POWERPC_RELATIVE;
2830 rela_dyn = target->iplt_section()->rel_plt();
2831 dynrel = elfcpp::R_POWERPC_IRELATIVE;
2833 rela_dyn->add_local_relative(object, r_sym, dynrel,
2834 output_section, data_shndx,
2835 reloc.get_r_offset(),
2836 reloc.get_r_addend(), is_ifunc);
2840 check_non_pic(object, r_type);
2841 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
2842 rela_dyn->add_local(object, r_sym, r_type, output_section,
2843 data_shndx, reloc.get_r_offset(),
2844 reloc.get_r_addend());
2849 case elfcpp::R_PPC64_REL64:
2850 case elfcpp::R_POWERPC_REL32:
2851 case elfcpp::R_POWERPC_REL24:
2852 case elfcpp::R_PPC_LOCAL24PC:
2853 case elfcpp::R_POWERPC_REL16:
2854 case elfcpp::R_POWERPC_REL16_LO:
2855 case elfcpp::R_POWERPC_REL16_HI:
2856 case elfcpp::R_POWERPC_REL16_HA:
2857 case elfcpp::R_POWERPC_REL14:
2858 case elfcpp::R_POWERPC_REL14_BRTAKEN:
2859 case elfcpp::R_POWERPC_REL14_BRNTAKEN:
2860 case elfcpp::R_POWERPC_SECTOFF:
2861 case elfcpp::R_POWERPC_TPREL16:
2862 case elfcpp::R_POWERPC_DTPREL16:
2863 case elfcpp::R_POWERPC_SECTOFF_LO:
2864 case elfcpp::R_POWERPC_TPREL16_LO:
2865 case elfcpp::R_POWERPC_DTPREL16_LO:
2866 case elfcpp::R_POWERPC_SECTOFF_HI:
2867 case elfcpp::R_POWERPC_TPREL16_HI:
2868 case elfcpp::R_POWERPC_DTPREL16_HI:
2869 case elfcpp::R_POWERPC_SECTOFF_HA:
2870 case elfcpp::R_POWERPC_TPREL16_HA:
2871 case elfcpp::R_POWERPC_DTPREL16_HA:
2872 case elfcpp::R_PPC64_DTPREL16_HIGHER:
2873 case elfcpp::R_PPC64_TPREL16_HIGHER:
2874 case elfcpp::R_PPC64_DTPREL16_HIGHERA:
2875 case elfcpp::R_PPC64_TPREL16_HIGHERA:
2876 case elfcpp::R_PPC64_DTPREL16_HIGHEST:
2877 case elfcpp::R_PPC64_TPREL16_HIGHEST:
2878 case elfcpp::R_PPC64_DTPREL16_HIGHESTA:
2879 case elfcpp::R_PPC64_TPREL16_HIGHESTA:
2880 case elfcpp::R_PPC64_TPREL16_DS:
2881 case elfcpp::R_PPC64_TPREL16_LO_DS:
2882 case elfcpp::R_PPC64_DTPREL16_DS:
2883 case elfcpp::R_PPC64_DTPREL16_LO_DS:
2884 case elfcpp::R_PPC64_SECTOFF_DS:
2885 case elfcpp::R_PPC64_SECTOFF_LO_DS:
2886 case elfcpp::R_PPC64_TLSGD:
2887 case elfcpp::R_PPC64_TLSLD:
2890 case elfcpp::R_POWERPC_GOT16:
2891 case elfcpp::R_POWERPC_GOT16_LO:
2892 case elfcpp::R_POWERPC_GOT16_HI:
2893 case elfcpp::R_POWERPC_GOT16_HA:
2894 case elfcpp::R_PPC64_GOT16_DS:
2895 case elfcpp::R_PPC64_GOT16_LO_DS:
2897 // The symbol requires a GOT entry.
2898 Output_data_got_powerpc<size, big_endian>* got
2899 = target->got_section(symtab, layout);
2900 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
2902 if (!parameters->options().output_is_position_independent())
2904 if (size == 32 && is_ifunc)
2905 got->add_local_plt(object, r_sym, GOT_TYPE_STANDARD);
2907 got->add_local(object, r_sym, GOT_TYPE_STANDARD);
2909 else if (!object->local_has_got_offset(r_sym, GOT_TYPE_STANDARD))
2911 // If we are generating a shared object or a pie, this
2912 // symbol's GOT entry will be set by a dynamic relocation.
2914 off = got->add_constant(0);
2915 object->set_local_got_offset(r_sym, GOT_TYPE_STANDARD, off);
2917 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
2918 unsigned int dynrel = elfcpp::R_POWERPC_RELATIVE;
2921 rela_dyn = target->iplt_section()->rel_plt();
2922 dynrel = elfcpp::R_POWERPC_IRELATIVE;
2924 rela_dyn->add_local_relative(object, r_sym, dynrel,
2925 got, off, 0, is_ifunc);
2930 case elfcpp::R_PPC64_TOC16:
2931 case elfcpp::R_PPC64_TOC16_LO:
2932 case elfcpp::R_PPC64_TOC16_HI:
2933 case elfcpp::R_PPC64_TOC16_HA:
2934 case elfcpp::R_PPC64_TOC16_DS:
2935 case elfcpp::R_PPC64_TOC16_LO_DS:
2936 // We need a GOT section.
2937 target->got_section(symtab, layout);
2940 case elfcpp::R_POWERPC_GOT_TLSGD16:
2941 case elfcpp::R_POWERPC_GOT_TLSGD16_LO:
2942 case elfcpp::R_POWERPC_GOT_TLSGD16_HI:
2943 case elfcpp::R_POWERPC_GOT_TLSGD16_HA:
2945 const tls::Tls_optimization tls_type = target->optimize_tls_gd(true);
2946 if (tls_type == tls::TLSOPT_NONE)
2948 Output_data_got_powerpc<size, big_endian>* got
2949 = target->got_section(symtab, layout);
2950 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
2951 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
2952 got->add_local_tls_pair(object, r_sym, GOT_TYPE_TLSGD,
2953 rela_dyn, elfcpp::R_POWERPC_DTPMOD);
2955 else if (tls_type == tls::TLSOPT_TO_LE)
2957 // no GOT relocs needed for Local Exec.
2964 case elfcpp::R_POWERPC_GOT_TLSLD16:
2965 case elfcpp::R_POWERPC_GOT_TLSLD16_LO:
2966 case elfcpp::R_POWERPC_GOT_TLSLD16_HI:
2967 case elfcpp::R_POWERPC_GOT_TLSLD16_HA:
2969 const tls::Tls_optimization tls_type = target->optimize_tls_ld();
2970 if (tls_type == tls::TLSOPT_NONE)
2971 target->tlsld_got_offset(symtab, layout, object);
2972 else if (tls_type == tls::TLSOPT_TO_LE)
2974 // no GOT relocs needed for Local Exec.
2975 if (parameters->options().emit_relocs())
2977 Output_section* os = layout->tls_segment()->first_section();
2978 gold_assert(os != NULL);
2979 os->set_needs_symtab_index();
2987 case elfcpp::R_POWERPC_GOT_DTPREL16:
2988 case elfcpp::R_POWERPC_GOT_DTPREL16_LO:
2989 case elfcpp::R_POWERPC_GOT_DTPREL16_HI:
2990 case elfcpp::R_POWERPC_GOT_DTPREL16_HA:
2992 Output_data_got_powerpc<size, big_endian>* got
2993 = target->got_section(symtab, layout);
2994 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
2995 got->add_local_tls(object, r_sym, GOT_TYPE_DTPREL);
2999 case elfcpp::R_POWERPC_GOT_TPREL16:
3000 case elfcpp::R_POWERPC_GOT_TPREL16_LO:
3001 case elfcpp::R_POWERPC_GOT_TPREL16_HI:
3002 case elfcpp::R_POWERPC_GOT_TPREL16_HA:
3004 const tls::Tls_optimization tls_type = target->optimize_tls_ie(true);
3005 if (tls_type == tls::TLSOPT_NONE)
3007 Output_data_got_powerpc<size, big_endian>* got
3008 = target->got_section(symtab, layout);
3009 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
3010 got->add_local_tls(object, r_sym, GOT_TYPE_TPREL);
3012 else if (tls_type == tls::TLSOPT_TO_LE)
3014 // no GOT relocs needed for Local Exec.
3022 unsupported_reloc_local(object, r_type);
3027 // Report an unsupported relocation against a global symbol.
3029 template<int size, bool big_endian>
3031 Target_powerpc<size, big_endian>::Scan::unsupported_reloc_global(
3032 Sized_relobj_file<size, big_endian>* object,
3033 unsigned int r_type,
3036 gold_error(_("%s: unsupported reloc %u against global symbol %s"),
3037 object->name().c_str(), r_type, gsym->demangled_name().c_str());
3040 // Scan a relocation for a global symbol.
3042 template<int size, bool big_endian>
3044 Target_powerpc<size, big_endian>::Scan::global(
3045 Symbol_table* symtab,
3047 Target_powerpc<size, big_endian>* target,
3048 Sized_relobj_file<size, big_endian>* object,
3049 unsigned int data_shndx,
3050 Output_section* output_section,
3051 const elfcpp::Rela<size, big_endian>& reloc,
3052 unsigned int r_type,
3055 Powerpc_relobj<size, big_endian>* ppc_object
3056 = static_cast<Powerpc_relobj<size, big_endian>*>(object);
3058 // A STT_GNU_IFUNC symbol may require a PLT entry.
3059 if (gsym->type() == elfcpp::STT_GNU_IFUNC
3060 && this->reloc_needs_plt_for_ifunc(object, r_type))
3061 target->make_plt_entry(layout, symtab, gsym, reloc, object);
3065 case elfcpp::R_POWERPC_NONE:
3066 case elfcpp::R_POWERPC_GNU_VTINHERIT:
3067 case elfcpp::R_POWERPC_GNU_VTENTRY:
3068 case elfcpp::R_PPC_LOCAL24PC:
3069 case elfcpp::R_PPC_EMB_MRKREF:
3070 case elfcpp::R_POWERPC_TLS:
3073 case elfcpp::R_PPC64_TOC:
3075 Output_data_got_powerpc<size, big_endian>* got
3076 = target->got_section(symtab, layout);
3077 if (parameters->options().output_is_position_independent())
3079 Address off = reloc.get_r_offset();
3081 && data_shndx == ppc_object->opd_shndx()
3082 && ppc_object->get_opd_discard(off - 8))
3085 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
3086 Powerpc_relobj<size, big_endian>* symobj = ppc_object;
3087 if (data_shndx != ppc_object->opd_shndx())
3088 symobj = static_cast
3089 <Powerpc_relobj<size, big_endian>*>(gsym->object());
3090 rela_dyn->add_output_section_relative(got->output_section(),
3091 elfcpp::R_POWERPC_RELATIVE,
3093 object, data_shndx, off,
3094 symobj->toc_base_offset());
3099 case elfcpp::R_PPC64_ADDR64:
3101 && data_shndx == ppc_object->opd_shndx()
3102 && (gsym->is_defined_in_discarded_section()
3103 || gsym->object() != object))
3105 ppc_object->set_opd_discard(reloc.get_r_offset());
3109 case elfcpp::R_PPC64_UADDR64:
3110 case elfcpp::R_POWERPC_ADDR32:
3111 case elfcpp::R_POWERPC_UADDR32:
3112 case elfcpp::R_POWERPC_ADDR24:
3113 case elfcpp::R_POWERPC_ADDR16:
3114 case elfcpp::R_POWERPC_ADDR16_LO:
3115 case elfcpp::R_POWERPC_ADDR16_HI:
3116 case elfcpp::R_POWERPC_ADDR16_HA:
3117 case elfcpp::R_POWERPC_UADDR16:
3118 case elfcpp::R_PPC64_ADDR16_HIGHER:
3119 case elfcpp::R_PPC64_ADDR16_HIGHERA:
3120 case elfcpp::R_PPC64_ADDR16_HIGHEST:
3121 case elfcpp::R_PPC64_ADDR16_HIGHESTA:
3122 case elfcpp::R_PPC64_ADDR16_DS:
3123 case elfcpp::R_PPC64_ADDR16_LO_DS:
3124 case elfcpp::R_POWERPC_ADDR14:
3125 case elfcpp::R_POWERPC_ADDR14_BRTAKEN:
3126 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN:
3128 // Make a PLT entry if necessary.
3129 if (gsym->needs_plt_entry())
3131 target->make_plt_entry(layout, symtab, gsym, reloc, 0);
3132 // Since this is not a PC-relative relocation, we may be
3133 // taking the address of a function. In that case we need to
3134 // set the entry in the dynamic symbol table to the address of
3135 // the PLT call stub.
3137 && gsym->is_from_dynobj()
3138 && !parameters->options().output_is_position_independent())
3139 gsym->set_needs_dynsym_value();
3141 // Make a dynamic relocation if necessary.
3142 if (needs_dynamic_reloc<size>(gsym, Scan::get_reference_flags(r_type)))
3144 if (gsym->may_need_copy_reloc())
3146 target->copy_reloc(symtab, layout, object,
3147 data_shndx, output_section, gsym, reloc);
3149 else if (((size == 32 && r_type == elfcpp::R_POWERPC_ADDR32)
3150 || (size == 64 && r_type == elfcpp::R_PPC64_ADDR64))
3151 && (gsym->can_use_relative_reloc(false)
3153 && data_shndx == ppc_object->opd_shndx())))
3155 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
3156 unsigned int dynrel = elfcpp::R_POWERPC_RELATIVE;
3157 if (gsym->type() == elfcpp::STT_GNU_IFUNC)
3159 rela_dyn = target->iplt_section()->rel_plt();
3160 dynrel = elfcpp::R_POWERPC_IRELATIVE;
3162 rela_dyn->add_symbolless_global_addend(
3163 gsym, dynrel, output_section, object, data_shndx,
3164 reloc.get_r_offset(), reloc.get_r_addend());
3168 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
3169 check_non_pic(object, r_type);
3170 rela_dyn->add_global(gsym, r_type, output_section,
3172 reloc.get_r_offset(),
3173 reloc.get_r_addend());
3179 case elfcpp::R_PPC_PLTREL24:
3180 case elfcpp::R_POWERPC_REL24:
3181 if (gsym->needs_plt_entry()
3182 || (!gsym->final_value_is_known()
3183 && (gsym->is_undefined()
3184 || gsym->is_from_dynobj()
3185 || gsym->is_preemptible())))
3186 target->make_plt_entry(layout, symtab, gsym, reloc, object);
3189 case elfcpp::R_PPC64_REL64:
3190 case elfcpp::R_POWERPC_REL32:
3191 // Make a dynamic relocation if necessary.
3192 if (needs_dynamic_reloc<size>(gsym, Scan::get_reference_flags(r_type)))
3194 if (gsym->may_need_copy_reloc())
3196 target->copy_reloc(symtab, layout, object,
3197 data_shndx, output_section, gsym,
3202 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
3203 check_non_pic(object, r_type);
3204 rela_dyn->add_global(gsym, r_type, output_section, object,
3205 data_shndx, reloc.get_r_offset(),
3206 reloc.get_r_addend());
3211 case elfcpp::R_POWERPC_REL16:
3212 case elfcpp::R_POWERPC_REL16_LO:
3213 case elfcpp::R_POWERPC_REL16_HI:
3214 case elfcpp::R_POWERPC_REL16_HA:
3215 case elfcpp::R_POWERPC_REL14:
3216 case elfcpp::R_POWERPC_REL14_BRTAKEN:
3217 case elfcpp::R_POWERPC_REL14_BRNTAKEN:
3218 case elfcpp::R_POWERPC_SECTOFF:
3219 case elfcpp::R_POWERPC_TPREL16:
3220 case elfcpp::R_POWERPC_DTPREL16:
3221 case elfcpp::R_POWERPC_SECTOFF_LO:
3222 case elfcpp::R_POWERPC_TPREL16_LO:
3223 case elfcpp::R_POWERPC_DTPREL16_LO:
3224 case elfcpp::R_POWERPC_SECTOFF_HI:
3225 case elfcpp::R_POWERPC_TPREL16_HI:
3226 case elfcpp::R_POWERPC_DTPREL16_HI:
3227 case elfcpp::R_POWERPC_SECTOFF_HA:
3228 case elfcpp::R_POWERPC_TPREL16_HA:
3229 case elfcpp::R_POWERPC_DTPREL16_HA:
3230 case elfcpp::R_PPC64_DTPREL16_HIGHER:
3231 case elfcpp::R_PPC64_TPREL16_HIGHER:
3232 case elfcpp::R_PPC64_DTPREL16_HIGHERA:
3233 case elfcpp::R_PPC64_TPREL16_HIGHERA:
3234 case elfcpp::R_PPC64_DTPREL16_HIGHEST:
3235 case elfcpp::R_PPC64_TPREL16_HIGHEST:
3236 case elfcpp::R_PPC64_DTPREL16_HIGHESTA:
3237 case elfcpp::R_PPC64_TPREL16_HIGHESTA:
3238 case elfcpp::R_PPC64_TPREL16_DS:
3239 case elfcpp::R_PPC64_TPREL16_LO_DS:
3240 case elfcpp::R_PPC64_DTPREL16_DS:
3241 case elfcpp::R_PPC64_DTPREL16_LO_DS:
3242 case elfcpp::R_PPC64_SECTOFF_DS:
3243 case elfcpp::R_PPC64_SECTOFF_LO_DS:
3244 case elfcpp::R_PPC64_TLSGD:
3245 case elfcpp::R_PPC64_TLSLD:
3248 case elfcpp::R_POWERPC_GOT16:
3249 case elfcpp::R_POWERPC_GOT16_LO:
3250 case elfcpp::R_POWERPC_GOT16_HI:
3251 case elfcpp::R_POWERPC_GOT16_HA:
3252 case elfcpp::R_PPC64_GOT16_DS:
3253 case elfcpp::R_PPC64_GOT16_LO_DS:
3255 // The symbol requires a GOT entry.
3256 Output_data_got_powerpc<size, big_endian>* got;
3258 got = target->got_section(symtab, layout);
3259 if (gsym->final_value_is_known())
3261 if (size == 32 && gsym->type() == elfcpp::STT_GNU_IFUNC)
3262 got->add_global_plt(gsym, GOT_TYPE_STANDARD);
3264 got->add_global(gsym, GOT_TYPE_STANDARD);
3266 else if (!gsym->has_got_offset(GOT_TYPE_STANDARD))
3268 // If we are generating a shared object or a pie, this
3269 // symbol's GOT entry will be set by a dynamic relocation.
3270 unsigned int off = got->add_constant(0);
3271 gsym->set_got_offset(GOT_TYPE_STANDARD, off);
3273 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
3274 if (gsym->can_use_relative_reloc(false)
3276 && gsym->visibility() == elfcpp::STV_PROTECTED
3277 && parameters->options().shared()))
3279 unsigned int dynrel = elfcpp::R_POWERPC_RELATIVE;
3280 if (gsym->type() == elfcpp::STT_GNU_IFUNC)
3282 rela_dyn = target->iplt_section()->rel_plt();
3283 dynrel = elfcpp::R_POWERPC_IRELATIVE;
3285 rela_dyn->add_global_relative(gsym, dynrel, got, off, 0, false);
3289 unsigned int dynrel = elfcpp::R_POWERPC_GLOB_DAT;
3290 rela_dyn->add_global(gsym, dynrel, got, off, 0);
3296 case elfcpp::R_PPC64_TOC16:
3297 case elfcpp::R_PPC64_TOC16_LO:
3298 case elfcpp::R_PPC64_TOC16_HI:
3299 case elfcpp::R_PPC64_TOC16_HA:
3300 case elfcpp::R_PPC64_TOC16_DS:
3301 case elfcpp::R_PPC64_TOC16_LO_DS:
3302 // We need a GOT section.
3303 target->got_section(symtab, layout);
3306 case elfcpp::R_POWERPC_GOT_TLSGD16:
3307 case elfcpp::R_POWERPC_GOT_TLSGD16_LO:
3308 case elfcpp::R_POWERPC_GOT_TLSGD16_HI:
3309 case elfcpp::R_POWERPC_GOT_TLSGD16_HA:
3311 const bool final = gsym->final_value_is_known();
3312 const tls::Tls_optimization tls_type = target->optimize_tls_gd(final);
3313 if (tls_type == tls::TLSOPT_NONE)
3315 Output_data_got_powerpc<size, big_endian>* got
3316 = target->got_section(symtab, layout);
3317 got->add_global_pair_with_rel(gsym, GOT_TYPE_TLSGD,
3318 target->rela_dyn_section(layout),
3319 elfcpp::R_POWERPC_DTPMOD,
3320 elfcpp::R_POWERPC_DTPREL);
3322 else if (tls_type == tls::TLSOPT_TO_IE)
3324 Output_data_got_powerpc<size, big_endian>* got
3325 = target->got_section(symtab, layout);
3326 got->add_global_with_rel(gsym, GOT_TYPE_TPREL,
3327 target->rela_dyn_section(layout),
3328 elfcpp::R_POWERPC_TPREL);
3330 else if (tls_type == tls::TLSOPT_TO_LE)
3332 // no GOT relocs needed for Local Exec.
3339 case elfcpp::R_POWERPC_GOT_TLSLD16:
3340 case elfcpp::R_POWERPC_GOT_TLSLD16_LO:
3341 case elfcpp::R_POWERPC_GOT_TLSLD16_HI:
3342 case elfcpp::R_POWERPC_GOT_TLSLD16_HA:
3344 const tls::Tls_optimization tls_type = target->optimize_tls_ld();
3345 if (tls_type == tls::TLSOPT_NONE)
3346 target->tlsld_got_offset(symtab, layout, object);
3347 else if (tls_type == tls::TLSOPT_TO_LE)
3349 // no GOT relocs needed for Local Exec.
3350 if (parameters->options().emit_relocs())
3352 Output_section* os = layout->tls_segment()->first_section();
3353 gold_assert(os != NULL);
3354 os->set_needs_symtab_index();
3362 case elfcpp::R_POWERPC_GOT_DTPREL16:
3363 case elfcpp::R_POWERPC_GOT_DTPREL16_LO:
3364 case elfcpp::R_POWERPC_GOT_DTPREL16_HI:
3365 case elfcpp::R_POWERPC_GOT_DTPREL16_HA:
3367 Output_data_got_powerpc<size, big_endian>* got
3368 = target->got_section(symtab, layout);
3369 if (!gsym->final_value_is_known()
3370 && (gsym->is_from_dynobj()
3371 || gsym->is_undefined()
3372 || gsym->is_preemptible()))
3373 got->add_global_with_rel(gsym, GOT_TYPE_DTPREL,
3374 target->rela_dyn_section(layout),
3375 elfcpp::R_POWERPC_DTPREL);
3377 got->add_global_tls(gsym, GOT_TYPE_DTPREL);
3381 case elfcpp::R_POWERPC_GOT_TPREL16:
3382 case elfcpp::R_POWERPC_GOT_TPREL16_LO:
3383 case elfcpp::R_POWERPC_GOT_TPREL16_HI:
3384 case elfcpp::R_POWERPC_GOT_TPREL16_HA:
3386 const bool final = gsym->final_value_is_known();
3387 const tls::Tls_optimization tls_type = target->optimize_tls_ie(final);
3388 if (tls_type == tls::TLSOPT_NONE)
3390 Output_data_got_powerpc<size, big_endian>* got
3391 = target->got_section(symtab, layout);
3392 if (!gsym->final_value_is_known()
3393 && (gsym->is_from_dynobj()
3394 || gsym->is_undefined()
3395 || gsym->is_preemptible()))
3396 got->add_global_with_rel(gsym, GOT_TYPE_TPREL,
3397 target->rela_dyn_section(layout),
3398 elfcpp::R_POWERPC_TPREL);
3400 got->add_global_tls(gsym, GOT_TYPE_TPREL);
3402 else if (tls_type == tls::TLSOPT_TO_LE)
3404 // no GOT relocs needed for Local Exec.
3412 unsupported_reloc_global(object, r_type, gsym);
3417 // Process relocations for gc.
3419 template<int size, bool big_endian>
3421 Target_powerpc<size, big_endian>::gc_process_relocs(
3422 Symbol_table* symtab,
3424 Sized_relobj_file<size, big_endian>* object,
3425 unsigned int data_shndx,
3427 const unsigned char* prelocs,
3429 Output_section* output_section,
3430 bool needs_special_offset_handling,
3431 size_t local_symbol_count,
3432 const unsigned char* plocal_symbols)
3434 typedef Target_powerpc<size, big_endian> Powerpc;
3435 typedef typename Target_powerpc<size, big_endian>::Scan Scan;
3436 Powerpc_relobj<size, big_endian>* ppc_object
3437 = static_cast<Powerpc_relobj<size, big_endian>*>(object);
3439 ppc_object->set_opd_valid();
3440 if (size == 64 && data_shndx == ppc_object->opd_shndx())
3442 typename Powerpc_relobj<size, big_endian>::Access_from::iterator p;
3443 for (p = ppc_object->access_from_map()->begin();
3444 p != ppc_object->access_from_map()->end();
3447 Address dst_off = p->first;
3448 unsigned int dst_indx = ppc_object->get_opd_ent(dst_off);
3449 typename Powerpc_relobj<size, big_endian>::Section_refs::iterator s;
3450 for (s = p->second.begin(); s != p->second.end(); ++s)
3452 Object* src_obj = s->first;
3453 unsigned int src_indx = s->second;
3454 symtab->gc()->add_reference(src_obj, src_indx,
3455 ppc_object, dst_indx);
3459 ppc_object->access_from_map()->clear();
3460 // Don't look at .opd relocs as .opd will reference everything.
3464 gold::gc_process_relocs<size, big_endian, Powerpc, elfcpp::SHT_RELA, Scan,
3465 typename Target_powerpc::Relocatable_size_for_reloc>(
3474 needs_special_offset_handling,
3479 // Handle target specific gc actions when adding a gc reference from
3480 // SRC_OBJ, SRC_SHNDX to a location specified by DST_OBJ, DST_SHNDX
3481 // and DST_OFF. For powerpc64, this adds a referenc to the code
3482 // section of a function descriptor.
3484 template<int size, bool big_endian>
3486 Target_powerpc<size, big_endian>::do_gc_add_reference(
3487 Symbol_table* symtab,
3489 unsigned int src_shndx,
3491 unsigned int dst_shndx,
3492 Address dst_off) const
3494 Powerpc_relobj<size, big_endian>* ppc_object
3495 = static_cast<Powerpc_relobj<size, big_endian>*>(dst_obj);
3496 if (size == 64 && dst_shndx == ppc_object->opd_shndx())
3498 if (ppc_object->opd_valid())
3500 dst_shndx = ppc_object->get_opd_ent(dst_off);
3501 symtab->gc()->add_reference(src_obj, src_shndx, dst_obj, dst_shndx);
3505 // If we haven't run scan_opd_relocs, we must delay
3506 // processing this function descriptor reference.
3507 ppc_object->add_reference(src_obj, src_shndx, dst_off);
3512 // Add any special sections for this symbol to the gc work list.
3513 // For powerpc64, this adds the code section of a function
3516 template<int size, bool big_endian>
3518 Target_powerpc<size, big_endian>::do_gc_mark_symbol(
3519 Symbol_table* symtab,
3524 Powerpc_relobj<size, big_endian>* ppc_object
3525 = static_cast<Powerpc_relobj<size, big_endian>*>(sym->object());
3527 unsigned int shndx = sym->shndx(&is_ordinary);
3528 if (is_ordinary && shndx == ppc_object->opd_shndx())
3530 Sized_symbol<size>* gsym = symtab->get_sized_symbol<size>(sym);
3531 Address dst_off = gsym->value();
3532 unsigned int dst_indx = ppc_object->get_opd_ent(dst_off);
3533 symtab->gc()->worklist().push(Section_id(ppc_object, dst_indx));
3538 // Scan relocations for a section.
3540 template<int size, bool big_endian>
3542 Target_powerpc<size, big_endian>::scan_relocs(
3543 Symbol_table* symtab,
3545 Sized_relobj_file<size, big_endian>* object,
3546 unsigned int data_shndx,
3547 unsigned int sh_type,
3548 const unsigned char* prelocs,
3550 Output_section* output_section,
3551 bool needs_special_offset_handling,
3552 size_t local_symbol_count,
3553 const unsigned char* plocal_symbols)
3555 typedef Target_powerpc<size, big_endian> Powerpc;
3556 typedef typename Target_powerpc<size, big_endian>::Scan Scan;
3558 if (sh_type == elfcpp::SHT_REL)
3560 gold_error(_("%s: unsupported REL reloc section"),
3561 object->name().c_str());
3567 static Output_data_space* sdata;
3569 // Define _SDA_BASE_ at the start of the .sdata section.
3572 // layout->find_output_section(".sdata") == NULL
3573 sdata = new Output_data_space(4, "** sdata");
3575 = layout->add_output_section_data(".sdata", 0,
3577 | elfcpp::SHF_WRITE,
3578 sdata, ORDER_SMALL_DATA, false);
3579 symtab->define_in_output_data("_SDA_BASE_", NULL,
3580 Symbol_table::PREDEFINED,
3581 os, 32768, 0, elfcpp::STT_OBJECT,
3582 elfcpp::STB_LOCAL, elfcpp::STV_HIDDEN,
3587 gold::scan_relocs<size, big_endian, Powerpc, elfcpp::SHT_RELA, Scan>(
3596 needs_special_offset_handling,
3601 // Functor class for processing the global symbol table.
3602 // Removes symbols defined on discarded opd entries.
3604 template<bool big_endian>
3605 class Global_symbol_visitor_opd
3608 Global_symbol_visitor_opd()
3612 operator()(Sized_symbol<64>* sym)
3614 if (sym->has_symtab_index()
3615 || sym->source() != Symbol::FROM_OBJECT
3616 || !sym->in_real_elf())
3619 Powerpc_relobj<64, big_endian>* symobj
3620 = static_cast<Powerpc_relobj<64, big_endian>*>(sym->object());
3621 if (symobj->is_dynamic()
3622 || symobj->opd_shndx() == 0)
3626 unsigned int shndx = sym->shndx(&is_ordinary);
3627 if (shndx == symobj->opd_shndx()
3628 && symobj->get_opd_discard(sym->value()))
3629 sym->set_symtab_index(-1U);
3633 // Finalize the sections.
3635 template<int size, bool big_endian>
3637 Target_powerpc<size, big_endian>::do_finalize_sections(
3639 const Input_objects*,
3640 Symbol_table* symtab)
3644 typedef Global_symbol_visitor_opd<big_endian> Symbol_visitor;
3645 symtab->for_all_symbols<64, Symbol_visitor>(Symbol_visitor());
3648 // Fill in some more dynamic tags.
3649 const Reloc_section* rel_plt = (this->plt_ == NULL
3651 : this->plt_->rel_plt());
3652 layout->add_target_dynamic_tags(false, this->plt_, rel_plt,
3653 this->rela_dyn_, true, size == 32);
3655 Output_data_dynamic* odyn = layout->dynamic_data();
3658 if (this->got_ != NULL)
3660 this->got_->finalize_data_size();
3661 odyn->add_section_plus_offset(elfcpp::DT_PPC_GOT,
3662 this->got_, this->got_->g_o_t());
3667 if (this->glink_ != NULL)
3669 this->glink_->finalize_data_size();
3670 odyn->add_section_plus_offset(elfcpp::DT_PPC64_GLINK,
3672 (this->glink_->pltresolve()
3673 + this->glink_->pltresolve_size - 32));
3677 // Emit any relocs we saved in an attempt to avoid generating COPY
3679 if (this->copy_relocs_.any_saved_relocs())
3680 this->copy_relocs_.emit(this->rela_dyn_section(layout));
3683 // Return the value to use for a branch relocation.
3685 template<int size, bool big_endian>
3686 typename elfcpp::Elf_types<size>::Elf_Addr
3687 Target_powerpc<size, big_endian>::symval_for_branch(
3689 const Sized_symbol<size>* gsym,
3690 Powerpc_relobj<size, big_endian>* object,
3691 unsigned int *dest_shndx)
3697 // If the symbol is defined in an opd section, ie. is a function
3698 // descriptor, use the function descriptor code entry address
3699 Powerpc_relobj<size, big_endian>* symobj = object;
3701 symobj = static_cast<Powerpc_relobj<size, big_endian>*>(gsym->object());
3702 unsigned int shndx = symobj->opd_shndx();
3705 Address opd_addr = symobj->get_output_section_offset(shndx);
3706 gold_assert(opd_addr != invalid_address);
3707 opd_addr += symobj->output_section(shndx)->address();
3708 if (value >= opd_addr && value < opd_addr + symobj->section_size(shndx))
3711 *dest_shndx = symobj->get_opd_ent(value - opd_addr, &sec_off);
3712 Address sec_addr = symobj->get_output_section_offset(*dest_shndx);
3713 gold_assert(sec_addr != invalid_address);
3714 sec_addr += symobj->output_section(*dest_shndx)->address();
3715 value = sec_addr + sec_off;
3720 // Perform a relocation.
3722 template<int size, bool big_endian>
3724 Target_powerpc<size, big_endian>::Relocate::relocate(
3725 const Relocate_info<size, big_endian>* relinfo,
3726 Target_powerpc* target,
3729 const elfcpp::Rela<size, big_endian>& rela,
3730 unsigned int r_type,
3731 const Sized_symbol<size>* gsym,
3732 const Symbol_value<size>* psymval,
3733 unsigned char* view,
3735 section_size_type view_size)
3738 bool is_tls_call = ((r_type == elfcpp::R_POWERPC_REL24
3739 || r_type == elfcpp::R_PPC_PLTREL24)
3741 && strcmp(gsym->name(), "__tls_get_addr") == 0);
3742 enum skip_tls last_tls = this->call_tls_get_addr_;
3743 this->call_tls_get_addr_ = CALL_NOT_EXPECTED;
3746 if (last_tls == CALL_NOT_EXPECTED)
3747 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
3748 _("__tls_get_addr call lacks marker reloc"));
3749 else if (last_tls == CALL_SKIP)
3752 else if (last_tls != CALL_NOT_EXPECTED)
3753 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
3754 _("missing expected __tls_get_addr call"));
3756 typedef Powerpc_relocate_functions<size, big_endian> Reloc;
3757 typedef typename elfcpp::Swap<32, big_endian>::Valtype Insn;
3758 Powerpc_relobj<size, big_endian>* const object
3759 = static_cast<Powerpc_relobj<size, big_endian>*>(relinfo->object);
3761 bool has_plt_value = false;
3762 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info());
3764 ? use_plt_offset<size>(gsym, Scan::get_reference_flags(r_type))
3765 : object->local_has_plt_offset(r_sym))
3767 const Output_data_glink<size, big_endian>* glink
3768 = target->glink_section();
3769 unsigned int glink_index = glink->find_entry(gsym, rela, object);
3770 value = glink->address() + glink_index * glink->glink_entry_size();
3771 has_plt_value = true;
3774 if (r_type == elfcpp::R_POWERPC_GOT16
3775 || r_type == elfcpp::R_POWERPC_GOT16_LO
3776 || r_type == elfcpp::R_POWERPC_GOT16_HI
3777 || r_type == elfcpp::R_POWERPC_GOT16_HA
3778 || r_type == elfcpp::R_PPC64_GOT16_DS
3779 || r_type == elfcpp::R_PPC64_GOT16_LO_DS)
3783 gold_assert(gsym->has_got_offset(GOT_TYPE_STANDARD));
3784 value = gsym->got_offset(GOT_TYPE_STANDARD);
3788 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info());
3789 gold_assert(object->local_has_got_offset(r_sym, GOT_TYPE_STANDARD));
3790 value = object->local_got_offset(r_sym, GOT_TYPE_STANDARD);
3792 value -= target->got_section()->got_base_offset(object);
3794 else if (r_type == elfcpp::R_PPC64_TOC)
3796 value = (target->got_section()->output_section()->address()
3797 + object->toc_base_offset());
3799 else if (gsym != NULL
3800 && (r_type == elfcpp::R_POWERPC_REL24
3801 || r_type == elfcpp::R_PPC_PLTREL24)
3806 typedef typename elfcpp::Swap<32, big_endian>::Valtype Valtype;
3807 Valtype* wv = reinterpret_cast<Valtype*>(view);
3808 bool can_plt_call = false;
3809 if (rela.get_r_offset() + 8 <= view_size)
3811 Valtype insn = elfcpp::Swap<32, big_endian>::readval(wv);
3812 Valtype insn2 = elfcpp::Swap<32, big_endian>::readval(wv + 1);
3815 || insn2 == cror_15_15_15 || insn2 == cror_31_31_31))
3817 elfcpp::Swap<32, big_endian>::writeval(wv + 1, ld_2_1 + 40);
3818 can_plt_call = true;
3823 // If we don't have a branch and link followed by a nop,
3824 // we can't go via the plt because there is no place to
3825 // put a toc restoring instruction.
3826 // Unless we know we won't be returning.
3827 if (strcmp(gsym->name(), "__libc_start_main") == 0)
3828 can_plt_call = true;
3832 // This is not an error in one special case: A self
3833 // call. It isn't possible to cheaply verify we have
3834 // such a call so just check for a call to the same
3837 if (gsym->source() == Symbol::FROM_OBJECT
3838 && gsym->object() == object)
3840 Address addend = rela.get_r_addend();
3841 unsigned int dest_shndx;
3842 value = psymval->value(object, addend);
3843 value = target->symval_for_branch(value, gsym, object,
3846 if (dest_shndx == 0)
3847 dest_shndx = gsym->shndx(&is_ordinary);
3848 ok = dest_shndx == relinfo->data_shndx;
3851 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
3852 _("call lacks nop, can't restore toc; "
3853 "recompile with -fPIC"));
3857 else if (r_type == elfcpp::R_POWERPC_GOT_TLSGD16
3858 || r_type == elfcpp::R_POWERPC_GOT_TLSGD16_LO
3859 || r_type == elfcpp::R_POWERPC_GOT_TLSGD16_HI
3860 || r_type == elfcpp::R_POWERPC_GOT_TLSGD16_HA)
3862 // First instruction of a global dynamic sequence, arg setup insn.
3863 const bool final = gsym == NULL || gsym->final_value_is_known();
3864 const tls::Tls_optimization tls_type = target->optimize_tls_gd(final);
3865 enum Got_type got_type = GOT_TYPE_STANDARD;
3866 if (tls_type == tls::TLSOPT_NONE)
3867 got_type = GOT_TYPE_TLSGD;
3868 else if (tls_type == tls::TLSOPT_TO_IE)
3869 got_type = GOT_TYPE_TPREL;
3870 if (got_type != GOT_TYPE_STANDARD)
3874 gold_assert(gsym->has_got_offset(got_type));
3875 value = gsym->got_offset(got_type);
3879 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info());
3880 gold_assert(object->local_has_got_offset(r_sym, got_type));
3881 value = object->local_got_offset(r_sym, got_type);
3883 value -= target->got_section()->got_base_offset(object);
3885 if (tls_type == tls::TLSOPT_TO_IE)
3887 if (r_type == elfcpp::R_POWERPC_GOT_TLSGD16
3888 || r_type == elfcpp::R_POWERPC_GOT_TLSGD16_LO)
3890 Insn* iview = reinterpret_cast<Insn*>(view - 2 * big_endian);
3891 Insn insn = elfcpp::Swap<32, big_endian>::readval(iview);
3892 insn &= (1 << 26) - (1 << 16); // extract rt,ra from addi
3894 insn |= 32 << 26; // lwz
3896 insn |= 58 << 26; // ld
3897 elfcpp::Swap<32, big_endian>::writeval(iview, insn);
3899 r_type += (elfcpp::R_POWERPC_GOT_TPREL16
3900 - elfcpp::R_POWERPC_GOT_TLSGD16);
3902 else if (tls_type == tls::TLSOPT_TO_LE)
3904 if (r_type == elfcpp::R_POWERPC_GOT_TLSGD16
3905 || r_type == elfcpp::R_POWERPC_GOT_TLSGD16_LO)
3907 Insn* iview = reinterpret_cast<Insn*>(view - 2 * big_endian);
3908 Insn insn = addis_3_13;
3911 elfcpp::Swap<32, big_endian>::writeval(iview, insn);
3912 r_type = elfcpp::R_POWERPC_TPREL16_HA;
3913 value = psymval->value(object, rela.get_r_addend());
3917 Insn* iview = reinterpret_cast<Insn*>(view - 2 * big_endian);
3919 elfcpp::Swap<32, big_endian>::writeval(iview, insn);
3920 r_type = elfcpp::R_POWERPC_NONE;
3924 else if (r_type == elfcpp::R_POWERPC_GOT_TLSLD16
3925 || r_type == elfcpp::R_POWERPC_GOT_TLSLD16_LO
3926 || r_type == elfcpp::R_POWERPC_GOT_TLSLD16_HI
3927 || r_type == elfcpp::R_POWERPC_GOT_TLSLD16_HA)
3929 // First instruction of a local dynamic sequence, arg setup insn.
3930 const tls::Tls_optimization tls_type = target->optimize_tls_ld();
3931 if (tls_type == tls::TLSOPT_NONE)
3933 value = target->tlsld_got_offset();
3934 value -= target->got_section()->got_base_offset(object);
3938 gold_assert(tls_type == tls::TLSOPT_TO_LE);
3939 if (r_type == elfcpp::R_POWERPC_GOT_TLSLD16
3940 || r_type == elfcpp::R_POWERPC_GOT_TLSLD16_LO)
3942 Insn* iview = reinterpret_cast<Insn*>(view - 2 * big_endian);
3943 Insn insn = addis_3_13;
3946 elfcpp::Swap<32, big_endian>::writeval(iview, insn);
3947 r_type = elfcpp::R_POWERPC_TPREL16_HA;
3952 Insn* iview = reinterpret_cast<Insn*>(view - 2 * big_endian);
3954 elfcpp::Swap<32, big_endian>::writeval(iview, insn);
3955 r_type = elfcpp::R_POWERPC_NONE;
3959 else if (r_type == elfcpp::R_POWERPC_GOT_DTPREL16
3960 || r_type == elfcpp::R_POWERPC_GOT_DTPREL16_LO
3961 || r_type == elfcpp::R_POWERPC_GOT_DTPREL16_HI
3962 || r_type == elfcpp::R_POWERPC_GOT_DTPREL16_HA)
3964 // Accesses relative to a local dynamic sequence address,
3965 // no optimisation here.
3968 gold_assert(gsym->has_got_offset(GOT_TYPE_DTPREL));
3969 value = gsym->got_offset(GOT_TYPE_DTPREL);
3973 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info());
3974 gold_assert(object->local_has_got_offset(r_sym, GOT_TYPE_DTPREL));
3975 value = object->local_got_offset(r_sym, GOT_TYPE_DTPREL);
3977 value -= target->got_section()->got_base_offset(object);
3979 else if (r_type == elfcpp::R_POWERPC_GOT_TPREL16
3980 || r_type == elfcpp::R_POWERPC_GOT_TPREL16_LO
3981 || r_type == elfcpp::R_POWERPC_GOT_TPREL16_HI
3982 || r_type == elfcpp::R_POWERPC_GOT_TPREL16_HA)
3984 // First instruction of initial exec sequence.
3985 const bool final = gsym == NULL || gsym->final_value_is_known();
3986 const tls::Tls_optimization tls_type = target->optimize_tls_ie(final);
3987 if (tls_type == tls::TLSOPT_NONE)
3991 gold_assert(gsym->has_got_offset(GOT_TYPE_TPREL));
3992 value = gsym->got_offset(GOT_TYPE_TPREL);
3996 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info());
3997 gold_assert(object->local_has_got_offset(r_sym, GOT_TYPE_TPREL));
3998 value = object->local_got_offset(r_sym, GOT_TYPE_TPREL);
4000 value -= target->got_section()->got_base_offset(object);
4004 gold_assert(tls_type == tls::TLSOPT_TO_LE);
4005 if (r_type == elfcpp::R_POWERPC_GOT_TPREL16
4006 || r_type == elfcpp::R_POWERPC_GOT_TPREL16_LO)
4008 Insn* iview = reinterpret_cast<Insn*>(view - 2 * big_endian);
4009 Insn insn = elfcpp::Swap<32, big_endian>::readval(iview);
4010 insn &= (1 << 26) - (1 << 21); // extract rt from ld
4015 elfcpp::Swap<32, big_endian>::writeval(iview, insn);
4016 r_type = elfcpp::R_POWERPC_TPREL16_HA;
4017 value = psymval->value(object, rela.get_r_addend());
4021 Insn* iview = reinterpret_cast<Insn*>(view - 2 * big_endian);
4023 elfcpp::Swap<32, big_endian>::writeval(iview, insn);
4024 r_type = elfcpp::R_POWERPC_NONE;
4028 else if ((size == 64 && r_type == elfcpp::R_PPC64_TLSGD)
4029 || (size == 32 && r_type == elfcpp::R_PPC_TLSGD))
4031 // Second instruction of a global dynamic sequence,
4032 // the __tls_get_addr call
4033 this->call_tls_get_addr_ = CALL_EXPECTED;
4034 const bool final = gsym == NULL || gsym->final_value_is_known();
4035 const tls::Tls_optimization tls_type = target->optimize_tls_gd(final);
4036 if (tls_type != tls::TLSOPT_NONE)
4038 if (tls_type == tls::TLSOPT_TO_IE)
4040 Insn* iview = reinterpret_cast<Insn*>(view);
4041 Insn insn = add_3_3_13;
4044 elfcpp::Swap<32, big_endian>::writeval(iview, insn);
4045 r_type = elfcpp::R_POWERPC_NONE;
4049 Insn* iview = reinterpret_cast<Insn*>(view);
4050 Insn insn = addi_3_3;
4051 elfcpp::Swap<32, big_endian>::writeval(iview, insn);
4052 r_type = elfcpp::R_POWERPC_TPREL16_LO;
4053 view += 2 * big_endian;
4054 value = psymval->value(object, rela.get_r_addend());
4056 this->call_tls_get_addr_ = CALL_SKIP;
4059 else if ((size == 64 && r_type == elfcpp::R_PPC64_TLSLD)
4060 || (size == 32 && r_type == elfcpp::R_PPC_TLSLD))
4062 // Second instruction of a local dynamic sequence,
4063 // the __tls_get_addr call
4064 this->call_tls_get_addr_ = CALL_EXPECTED;
4065 const tls::Tls_optimization tls_type = target->optimize_tls_ld();
4066 if (tls_type == tls::TLSOPT_TO_LE)
4068 Insn* iview = reinterpret_cast<Insn*>(view);
4069 Insn insn = addi_3_3;
4070 elfcpp::Swap<32, big_endian>::writeval(iview, insn);
4071 this->call_tls_get_addr_ = CALL_SKIP;
4072 r_type = elfcpp::R_POWERPC_TPREL16_LO;
4073 view += 2 * big_endian;
4077 else if (r_type == elfcpp::R_POWERPC_TLS)
4079 // Second instruction of an initial exec sequence
4080 const bool final = gsym == NULL || gsym->final_value_is_known();
4081 const tls::Tls_optimization tls_type = target->optimize_tls_ie(final);
4082 if (tls_type == tls::TLSOPT_TO_LE)
4084 Insn* iview = reinterpret_cast<Insn*>(view);
4085 Insn insn = elfcpp::Swap<32, big_endian>::readval(iview);
4086 unsigned int reg = size == 32 ? 2 : 13;
4087 insn = at_tls_transform(insn, reg);
4088 gold_assert(insn != 0);
4089 elfcpp::Swap<32, big_endian>::writeval(iview, insn);
4090 r_type = elfcpp::R_POWERPC_TPREL16_LO;
4091 view += 2 * big_endian;
4092 value = psymval->value(object, rela.get_r_addend());
4098 unsigned int dest_shndx;
4099 if (r_type != elfcpp::R_PPC_PLTREL24)
4100 addend = rela.get_r_addend();
4101 if (size == 64 || !has_plt_value)
4102 value = psymval->value(object, addend);
4103 if (size == 64 && is_branch_reloc(r_type))
4104 value = target->symval_for_branch(value, gsym, object, &dest_shndx);
4109 case elfcpp::R_PPC64_REL64:
4110 case elfcpp::R_POWERPC_REL32:
4111 case elfcpp::R_POWERPC_REL24:
4112 case elfcpp::R_PPC_PLTREL24:
4113 case elfcpp::R_PPC_LOCAL24PC:
4114 case elfcpp::R_POWERPC_REL16:
4115 case elfcpp::R_POWERPC_REL16_LO:
4116 case elfcpp::R_POWERPC_REL16_HI:
4117 case elfcpp::R_POWERPC_REL16_HA:
4118 case elfcpp::R_POWERPC_REL14:
4119 case elfcpp::R_POWERPC_REL14_BRTAKEN:
4120 case elfcpp::R_POWERPC_REL14_BRNTAKEN:
4124 case elfcpp::R_PPC64_TOC16:
4125 case elfcpp::R_PPC64_TOC16_LO:
4126 case elfcpp::R_PPC64_TOC16_HI:
4127 case elfcpp::R_PPC64_TOC16_HA:
4128 case elfcpp::R_PPC64_TOC16_DS:
4129 case elfcpp::R_PPC64_TOC16_LO_DS:
4130 // Subtract the TOC base address.
4131 value -= (target->got_section()->output_section()->address()
4132 + object->toc_base_offset());
4135 case elfcpp::R_POWERPC_SECTOFF:
4136 case elfcpp::R_POWERPC_SECTOFF_LO:
4137 case elfcpp::R_POWERPC_SECTOFF_HI:
4138 case elfcpp::R_POWERPC_SECTOFF_HA:
4139 case elfcpp::R_PPC64_SECTOFF_DS:
4140 case elfcpp::R_PPC64_SECTOFF_LO_DS:
4142 value -= os->address();
4145 case elfcpp::R_PPC64_TPREL16_DS:
4146 case elfcpp::R_PPC64_TPREL16_LO_DS:
4148 // R_PPC_TLSGD and R_PPC_TLSLD
4150 case elfcpp::R_POWERPC_TPREL16:
4151 case elfcpp::R_POWERPC_TPREL16_LO:
4152 case elfcpp::R_POWERPC_TPREL16_HI:
4153 case elfcpp::R_POWERPC_TPREL16_HA:
4154 case elfcpp::R_POWERPC_TPREL:
4155 case elfcpp::R_PPC64_TPREL16_HIGHER:
4156 case elfcpp::R_PPC64_TPREL16_HIGHERA:
4157 case elfcpp::R_PPC64_TPREL16_HIGHEST:
4158 case elfcpp::R_PPC64_TPREL16_HIGHESTA:
4159 // tls symbol values are relative to tls_segment()->vaddr()
4163 case elfcpp::R_PPC64_DTPREL16_DS:
4164 case elfcpp::R_PPC64_DTPREL16_LO_DS:
4165 case elfcpp::R_PPC64_DTPREL16_HIGHER:
4166 case elfcpp::R_PPC64_DTPREL16_HIGHERA:
4167 case elfcpp::R_PPC64_DTPREL16_HIGHEST:
4168 case elfcpp::R_PPC64_DTPREL16_HIGHESTA:
4170 // R_PPC_EMB_NADDR32, R_PPC_EMB_NADDR16, R_PPC_EMB_NADDR16_LO
4171 // R_PPC_EMB_NADDR16_HI, R_PPC_EMB_NADDR16_HA, R_PPC_EMB_SDAI16
4173 case elfcpp::R_POWERPC_DTPREL16:
4174 case elfcpp::R_POWERPC_DTPREL16_LO:
4175 case elfcpp::R_POWERPC_DTPREL16_HI:
4176 case elfcpp::R_POWERPC_DTPREL16_HA:
4177 case elfcpp::R_POWERPC_DTPREL:
4178 // tls symbol values are relative to tls_segment()->vaddr()
4179 value -= dtp_offset;
4186 Insn branch_bit = 0;
4189 case elfcpp::R_POWERPC_ADDR14_BRTAKEN:
4190 case elfcpp::R_POWERPC_REL14_BRTAKEN:
4191 branch_bit = 1 << 21;
4192 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN:
4193 case elfcpp::R_POWERPC_REL14_BRNTAKEN:
4195 Insn* iview = reinterpret_cast<Insn*>(view);
4196 Insn insn = elfcpp::Swap<32, big_endian>::readval(iview);
4199 if (this->is_isa_v2)
4201 // Set 'a' bit. This is 0b00010 in BO field for branch
4202 // on CR(BI) insns (BO == 001at or 011at), and 0b01000
4203 // for branch on CTR insns (BO == 1a00t or 1a01t).
4204 if ((insn & (0x14 << 21)) == (0x04 << 21))
4206 else if ((insn & (0x14 << 21)) == (0x10 << 21))
4213 // Invert 'y' bit if not the default.
4214 if (static_cast<Signed_address>(value) < 0)
4217 elfcpp::Swap<32, big_endian>::writeval(iview, insn);
4225 typename Reloc::Overflow_check overflow = Reloc::CHECK_NONE;
4228 case elfcpp::R_POWERPC_ADDR32:
4229 case elfcpp::R_POWERPC_UADDR32:
4231 overflow = Reloc::CHECK_BITFIELD;
4234 case elfcpp::R_POWERPC_REL32:
4236 overflow = Reloc::CHECK_SIGNED;
4239 case elfcpp::R_POWERPC_ADDR24:
4240 case elfcpp::R_POWERPC_ADDR16:
4241 case elfcpp::R_POWERPC_UADDR16:
4242 case elfcpp::R_PPC64_ADDR16_DS:
4243 case elfcpp::R_POWERPC_ADDR14:
4244 case elfcpp::R_POWERPC_ADDR14_BRTAKEN:
4245 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN:
4246 overflow = Reloc::CHECK_BITFIELD;
4249 case elfcpp::R_POWERPC_REL24:
4250 case elfcpp::R_PPC_PLTREL24:
4251 case elfcpp::R_PPC_LOCAL24PC:
4252 case elfcpp::R_POWERPC_REL16:
4253 case elfcpp::R_PPC64_TOC16:
4254 case elfcpp::R_POWERPC_GOT16:
4255 case elfcpp::R_POWERPC_SECTOFF:
4256 case elfcpp::R_POWERPC_TPREL16:
4257 case elfcpp::R_POWERPC_DTPREL16:
4258 case elfcpp::R_PPC64_TPREL16_DS:
4259 case elfcpp::R_PPC64_DTPREL16_DS:
4260 case elfcpp::R_PPC64_TOC16_DS:
4261 case elfcpp::R_PPC64_GOT16_DS:
4262 case elfcpp::R_PPC64_SECTOFF_DS:
4263 case elfcpp::R_POWERPC_REL14:
4264 case elfcpp::R_POWERPC_REL14_BRTAKEN:
4265 case elfcpp::R_POWERPC_REL14_BRNTAKEN:
4266 case elfcpp::R_POWERPC_GOT_TLSGD16:
4267 case elfcpp::R_POWERPC_GOT_TLSLD16:
4268 case elfcpp::R_POWERPC_GOT_TPREL16:
4269 case elfcpp::R_POWERPC_GOT_DTPREL16:
4270 overflow = Reloc::CHECK_SIGNED;
4274 typename Powerpc_relocate_functions<size, big_endian>::Status status
4275 = Powerpc_relocate_functions<size, big_endian>::STATUS_OK;
4278 case elfcpp::R_POWERPC_NONE:
4279 case elfcpp::R_POWERPC_TLS:
4280 case elfcpp::R_POWERPC_GNU_VTINHERIT:
4281 case elfcpp::R_POWERPC_GNU_VTENTRY:
4282 case elfcpp::R_PPC_EMB_MRKREF:
4285 case elfcpp::R_PPC64_ADDR64:
4286 case elfcpp::R_PPC64_REL64:
4287 case elfcpp::R_PPC64_TOC:
4288 Reloc::addr64(view, value);
4291 case elfcpp::R_POWERPC_TPREL:
4292 case elfcpp::R_POWERPC_DTPREL:
4294 Reloc::addr64(view, value);
4296 status = Reloc::addr32(view, value, overflow);
4299 case elfcpp::R_PPC64_UADDR64:
4300 Reloc::addr64_u(view, value);
4303 case elfcpp::R_POWERPC_ADDR32:
4304 case elfcpp::R_POWERPC_REL32:
4305 status = Reloc::addr32(view, value, overflow);
4308 case elfcpp::R_POWERPC_UADDR32:
4309 status = Reloc::addr32_u(view, value, overflow);
4312 case elfcpp::R_POWERPC_ADDR24:
4313 case elfcpp::R_POWERPC_REL24:
4314 case elfcpp::R_PPC_PLTREL24:
4315 case elfcpp::R_PPC_LOCAL24PC:
4316 status = Reloc::addr24(view, value, overflow);
4319 case elfcpp::R_POWERPC_GOT_DTPREL16:
4320 case elfcpp::R_POWERPC_GOT_DTPREL16_LO:
4323 status = Reloc::addr16_ds(view, value, overflow);
4326 case elfcpp::R_POWERPC_ADDR16:
4327 case elfcpp::R_POWERPC_REL16:
4328 case elfcpp::R_PPC64_TOC16:
4329 case elfcpp::R_POWERPC_GOT16:
4330 case elfcpp::R_POWERPC_SECTOFF:
4331 case elfcpp::R_POWERPC_TPREL16:
4332 case elfcpp::R_POWERPC_DTPREL16:
4333 case elfcpp::R_POWERPC_GOT_TLSGD16:
4334 case elfcpp::R_POWERPC_GOT_TLSLD16:
4335 case elfcpp::R_POWERPC_GOT_TPREL16:
4336 case elfcpp::R_POWERPC_ADDR16_LO:
4337 case elfcpp::R_POWERPC_REL16_LO:
4338 case elfcpp::R_PPC64_TOC16_LO:
4339 case elfcpp::R_POWERPC_GOT16_LO:
4340 case elfcpp::R_POWERPC_SECTOFF_LO:
4341 case elfcpp::R_POWERPC_TPREL16_LO:
4342 case elfcpp::R_POWERPC_DTPREL16_LO:
4343 case elfcpp::R_POWERPC_GOT_TLSGD16_LO:
4344 case elfcpp::R_POWERPC_GOT_TLSLD16_LO:
4345 case elfcpp::R_POWERPC_GOT_TPREL16_LO:
4346 status = Reloc::addr16(view, value, overflow);
4349 case elfcpp::R_POWERPC_UADDR16:
4350 status = Reloc::addr16_u(view, value, overflow);
4353 case elfcpp::R_POWERPC_ADDR16_HI:
4354 case elfcpp::R_POWERPC_REL16_HI:
4355 case elfcpp::R_PPC64_TOC16_HI:
4356 case elfcpp::R_POWERPC_GOT16_HI:
4357 case elfcpp::R_POWERPC_SECTOFF_HI:
4358 case elfcpp::R_POWERPC_TPREL16_HI:
4359 case elfcpp::R_POWERPC_DTPREL16_HI:
4360 case elfcpp::R_POWERPC_GOT_TLSGD16_HI:
4361 case elfcpp::R_POWERPC_GOT_TLSLD16_HI:
4362 case elfcpp::R_POWERPC_GOT_TPREL16_HI:
4363 case elfcpp::R_POWERPC_GOT_DTPREL16_HI:
4364 Reloc::addr16_hi(view, value);
4367 case elfcpp::R_POWERPC_ADDR16_HA:
4368 case elfcpp::R_POWERPC_REL16_HA:
4369 case elfcpp::R_PPC64_TOC16_HA:
4370 case elfcpp::R_POWERPC_GOT16_HA:
4371 case elfcpp::R_POWERPC_SECTOFF_HA:
4372 case elfcpp::R_POWERPC_TPREL16_HA:
4373 case elfcpp::R_POWERPC_DTPREL16_HA:
4374 case elfcpp::R_POWERPC_GOT_TLSGD16_HA:
4375 case elfcpp::R_POWERPC_GOT_TLSLD16_HA:
4376 case elfcpp::R_POWERPC_GOT_TPREL16_HA:
4377 case elfcpp::R_POWERPC_GOT_DTPREL16_HA:
4378 Reloc::addr16_ha(view, value);
4381 case elfcpp::R_PPC64_DTPREL16_HIGHER:
4383 // R_PPC_EMB_NADDR16_LO
4385 case elfcpp::R_PPC64_ADDR16_HIGHER:
4386 case elfcpp::R_PPC64_TPREL16_HIGHER:
4387 Reloc::addr16_hi2(view, value);
4390 case elfcpp::R_PPC64_DTPREL16_HIGHERA:
4392 // R_PPC_EMB_NADDR16_HI
4394 case elfcpp::R_PPC64_ADDR16_HIGHERA:
4395 case elfcpp::R_PPC64_TPREL16_HIGHERA:
4396 Reloc::addr16_ha2(view, value);
4399 case elfcpp::R_PPC64_DTPREL16_HIGHEST:
4401 // R_PPC_EMB_NADDR16_HA
4403 case elfcpp::R_PPC64_ADDR16_HIGHEST:
4404 case elfcpp::R_PPC64_TPREL16_HIGHEST:
4405 Reloc::addr16_hi3(view, value);
4408 case elfcpp::R_PPC64_DTPREL16_HIGHESTA:
4412 case elfcpp::R_PPC64_ADDR16_HIGHESTA:
4413 case elfcpp::R_PPC64_TPREL16_HIGHESTA:
4414 Reloc::addr16_ha3(view, value);
4417 case elfcpp::R_PPC64_DTPREL16_DS:
4418 case elfcpp::R_PPC64_DTPREL16_LO_DS:
4420 // R_PPC_EMB_NADDR32, R_PPC_EMB_NADDR16
4422 case elfcpp::R_PPC64_TPREL16_DS:
4423 case elfcpp::R_PPC64_TPREL16_LO_DS:
4425 // R_PPC_TLSGD, R_PPC_TLSLD
4427 case elfcpp::R_PPC64_ADDR16_DS:
4428 case elfcpp::R_PPC64_ADDR16_LO_DS:
4429 case elfcpp::R_PPC64_TOC16_DS:
4430 case elfcpp::R_PPC64_TOC16_LO_DS:
4431 case elfcpp::R_PPC64_GOT16_DS:
4432 case elfcpp::R_PPC64_GOT16_LO_DS:
4433 case elfcpp::R_PPC64_SECTOFF_DS:
4434 case elfcpp::R_PPC64_SECTOFF_LO_DS:
4435 status = Reloc::addr16_ds(view, value, overflow);
4438 case elfcpp::R_POWERPC_ADDR14:
4439 case elfcpp::R_POWERPC_ADDR14_BRTAKEN:
4440 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN:
4441 case elfcpp::R_POWERPC_REL14:
4442 case elfcpp::R_POWERPC_REL14_BRTAKEN:
4443 case elfcpp::R_POWERPC_REL14_BRNTAKEN:
4444 status = Reloc::addr14(view, value, overflow);
4447 case elfcpp::R_POWERPC_COPY:
4448 case elfcpp::R_POWERPC_GLOB_DAT:
4449 case elfcpp::R_POWERPC_JMP_SLOT:
4450 case elfcpp::R_POWERPC_RELATIVE:
4451 case elfcpp::R_POWERPC_DTPMOD:
4452 case elfcpp::R_PPC64_JMP_IREL:
4453 case elfcpp::R_POWERPC_IRELATIVE:
4454 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
4455 _("unexpected reloc %u in object file"),
4459 case elfcpp::R_PPC_EMB_SDA21:
4464 // R_PPC64_TOCSAVE. For the time being this can be ignored.
4468 case elfcpp::R_PPC_EMB_SDA2I16:
4469 case elfcpp::R_PPC_EMB_SDA2REL:
4472 // R_PPC64_TLSGD, R_PPC64_TLSLD
4475 case elfcpp::R_POWERPC_PLT32:
4476 case elfcpp::R_POWERPC_PLTREL32:
4477 case elfcpp::R_POWERPC_PLT16_LO:
4478 case elfcpp::R_POWERPC_PLT16_HI:
4479 case elfcpp::R_POWERPC_PLT16_HA:
4480 case elfcpp::R_PPC_SDAREL16:
4481 case elfcpp::R_POWERPC_ADDR30:
4482 case elfcpp::R_PPC64_PLT64:
4483 case elfcpp::R_PPC64_PLTREL64:
4484 case elfcpp::R_PPC64_PLTGOT16:
4485 case elfcpp::R_PPC64_PLTGOT16_LO:
4486 case elfcpp::R_PPC64_PLTGOT16_HI:
4487 case elfcpp::R_PPC64_PLTGOT16_HA:
4488 case elfcpp::R_PPC64_PLT16_LO_DS:
4489 case elfcpp::R_PPC64_PLTGOT16_DS:
4490 case elfcpp::R_PPC64_PLTGOT16_LO_DS:
4491 case elfcpp::R_PPC_EMB_RELSEC16:
4492 case elfcpp::R_PPC_EMB_RELST_LO:
4493 case elfcpp::R_PPC_EMB_RELST_HI:
4494 case elfcpp::R_PPC_EMB_RELST_HA:
4495 case elfcpp::R_PPC_EMB_BIT_FLD:
4496 case elfcpp::R_PPC_EMB_RELSDA:
4497 case elfcpp::R_PPC_TOC16:
4500 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
4501 _("unsupported reloc %u"),
4505 if (status != Powerpc_relocate_functions<size, big_endian>::STATUS_OK)
4506 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
4507 _("relocation overflow"));
4512 // Relocate section data.
4514 template<int size, bool big_endian>
4516 Target_powerpc<size, big_endian>::relocate_section(
4517 const Relocate_info<size, big_endian>* relinfo,
4518 unsigned int sh_type,
4519 const unsigned char* prelocs,
4521 Output_section* output_section,
4522 bool needs_special_offset_handling,
4523 unsigned char* view,
4525 section_size_type view_size,
4526 const Reloc_symbol_changes* reloc_symbol_changes)
4528 typedef Target_powerpc<size, big_endian> Powerpc;
4529 typedef typename Target_powerpc<size, big_endian>::Relocate Powerpc_relocate;
4531 gold_assert(sh_type == elfcpp::SHT_RELA);
4533 unsigned char *opd_rel = NULL;
4534 Powerpc_relobj<size, big_endian>* const object
4535 = static_cast<Powerpc_relobj<size, big_endian>*>(relinfo->object);
4537 && relinfo->data_shndx == object->opd_shndx())
4539 // Rewrite opd relocs, omitting those for discarded sections
4540 // to silence gold::relocate_section errors.
4541 const int reloc_size
4542 = Reloc_types<elfcpp::SHT_RELA, size, big_endian>::reloc_size;
4543 opd_rel = new unsigned char[reloc_count * reloc_size];
4544 const unsigned char* rrel = prelocs;
4545 unsigned char* wrel = opd_rel;
4549 ++i, rrel += reloc_size, wrel += reloc_size)
4551 typename Reloc_types<elfcpp::SHT_RELA, size, big_endian>::Reloc
4553 typename elfcpp::Elf_types<size>::Elf_WXword r_info
4554 = reloc.get_r_info();
4555 unsigned int r_type = elfcpp::elf_r_type<size>(r_info);
4556 Address r_off = reloc.get_r_offset();
4557 if (r_type == elfcpp::R_PPC64_TOC)
4559 bool is_discarded = object->get_opd_discard(r_off);
4561 // Reloc number is reported in some errors, so keep all relocs.
4563 memset(wrel, 0, reloc_size);
4565 memcpy(wrel, rrel, reloc_size);
4570 gold::relocate_section<size, big_endian, Powerpc, elfcpp::SHT_RELA,
4577 needs_special_offset_handling,
4581 reloc_symbol_changes);
4583 if (opd_rel != NULL)
4587 class Powerpc_scan_relocatable_reloc
4590 // Return the strategy to use for a local symbol which is not a
4591 // section symbol, given the relocation type.
4592 inline Relocatable_relocs::Reloc_strategy
4593 local_non_section_strategy(unsigned int r_type, Relobj*, unsigned int r_sym)
4595 if (r_type == 0 && r_sym == 0)
4596 return Relocatable_relocs::RELOC_DISCARD;
4597 return Relocatable_relocs::RELOC_COPY;
4600 // Return the strategy to use for a local symbol which is a section
4601 // symbol, given the relocation type.
4602 inline Relocatable_relocs::Reloc_strategy
4603 local_section_strategy(unsigned int, Relobj*)
4605 return Relocatable_relocs::RELOC_ADJUST_FOR_SECTION_RELA;
4608 // Return the strategy to use for a global symbol, given the
4609 // relocation type, the object, and the symbol index.
4610 inline Relocatable_relocs::Reloc_strategy
4611 global_strategy(unsigned int r_type, Relobj*, unsigned int)
4613 if (r_type == elfcpp::R_PPC_PLTREL24)
4614 return Relocatable_relocs::RELOC_SPECIAL;
4615 return Relocatable_relocs::RELOC_COPY;
4619 // Scan the relocs during a relocatable link.
4621 template<int size, bool big_endian>
4623 Target_powerpc<size, big_endian>::scan_relocatable_relocs(
4624 Symbol_table* symtab,
4626 Sized_relobj_file<size, big_endian>* object,
4627 unsigned int data_shndx,
4628 unsigned int sh_type,
4629 const unsigned char* prelocs,
4631 Output_section* output_section,
4632 bool needs_special_offset_handling,
4633 size_t local_symbol_count,
4634 const unsigned char* plocal_symbols,
4635 Relocatable_relocs* rr)
4637 gold_assert(sh_type == elfcpp::SHT_RELA);
4639 gold::scan_relocatable_relocs<size, big_endian, elfcpp::SHT_RELA,
4640 Powerpc_scan_relocatable_reloc>(
4648 needs_special_offset_handling,
4654 // Emit relocations for a section.
4655 // This is a modified version of the function by the same name in
4656 // target-reloc.h. Using relocate_special_relocatable for
4657 // R_PPC_PLTREL24 would require duplication of the entire body of the
4658 // loop, so we may as well duplicate the whole thing.
4660 template<int size, bool big_endian>
4662 Target_powerpc<size, big_endian>::relocate_relocs(
4663 const Relocate_info<size, big_endian>* relinfo,
4664 unsigned int sh_type,
4665 const unsigned char* prelocs,
4667 Output_section* output_section,
4668 off_t offset_in_output_section,
4669 const Relocatable_relocs* rr,
4671 Address view_address,
4673 unsigned char* reloc_view,
4674 section_size_type reloc_view_size)
4676 gold_assert(sh_type == elfcpp::SHT_RELA);
4678 typedef typename Reloc_types<elfcpp::SHT_RELA, size, big_endian>::Reloc
4680 typedef typename Reloc_types<elfcpp::SHT_RELA, size, big_endian>::Reloc_write
4682 const int reloc_size
4683 = Reloc_types<elfcpp::SHT_RELA, size, big_endian>::reloc_size;
4685 Powerpc_relobj<size, big_endian>* const object
4686 = static_cast<Powerpc_relobj<size, big_endian>*>(relinfo->object);
4687 const unsigned int local_count = object->local_symbol_count();
4688 unsigned int got2_shndx = object->got2_shndx();
4689 Address got2_addend = 0;
4690 if (got2_shndx != 0)
4692 got2_addend = object->get_output_section_offset(got2_shndx);
4693 gold_assert(got2_addend != invalid_address);
4696 unsigned char* pwrite = reloc_view;
4697 bool zap_next = false;
4698 for (size_t i = 0; i < reloc_count; ++i, prelocs += reloc_size)
4700 Relocatable_relocs::Reloc_strategy strategy = rr->strategy(i);
4701 if (strategy == Relocatable_relocs::RELOC_DISCARD)
4704 Reltype reloc(prelocs);
4705 Reltype_write reloc_write(pwrite);
4707 Address offset = reloc.get_r_offset();
4708 typename elfcpp::Elf_types<size>::Elf_WXword r_info = reloc.get_r_info();
4709 unsigned int r_sym = elfcpp::elf_r_sym<size>(r_info);
4710 unsigned int r_type = elfcpp::elf_r_type<size>(r_info);
4711 const unsigned int orig_r_sym = r_sym;
4712 typename elfcpp::Elf_types<size>::Elf_Swxword addend
4713 = reloc.get_r_addend();
4714 const Symbol* gsym = NULL;
4718 // We could arrange to discard these and other relocs for
4719 // tls optimised sequences in the strategy methods, but for
4720 // now do as BFD ld does.
4721 r_type = elfcpp::R_POWERPC_NONE;
4725 // Get the new symbol index.
4726 if (r_sym < local_count)
4730 case Relocatable_relocs::RELOC_COPY:
4731 case Relocatable_relocs::RELOC_SPECIAL:
4734 r_sym = object->symtab_index(r_sym);
4735 gold_assert(r_sym != -1U);
4739 case Relocatable_relocs::RELOC_ADJUST_FOR_SECTION_RELA:
4741 // We are adjusting a section symbol. We need to find
4742 // the symbol table index of the section symbol for
4743 // the output section corresponding to input section
4744 // in which this symbol is defined.
4745 gold_assert(r_sym < local_count);
4747 unsigned int shndx =
4748 object->local_symbol_input_shndx(r_sym, &is_ordinary);
4749 gold_assert(is_ordinary);
4750 Output_section* os = object->output_section(shndx);
4751 gold_assert(os != NULL);
4752 gold_assert(os->needs_symtab_index());
4753 r_sym = os->symtab_index();
4763 gsym = object->global_symbol(r_sym);
4764 gold_assert(gsym != NULL);
4765 if (gsym->is_forwarder())
4766 gsym = relinfo->symtab->resolve_forwards(gsym);
4768 gold_assert(gsym->has_symtab_index());
4769 r_sym = gsym->symtab_index();
4772 // Get the new offset--the location in the output section where
4773 // this relocation should be applied.
4774 if (static_cast<Address>(offset_in_output_section) != invalid_address)
4775 offset += offset_in_output_section;
4778 section_offset_type sot_offset =
4779 convert_types<section_offset_type, Address>(offset);
4780 section_offset_type new_sot_offset =
4781 output_section->output_offset(object, relinfo->data_shndx,
4783 gold_assert(new_sot_offset != -1);
4784 offset = new_sot_offset;
4787 // In an object file, r_offset is an offset within the section.
4788 // In an executable or dynamic object, generated by
4789 // --emit-relocs, r_offset is an absolute address.
4790 if (!parameters->options().relocatable())
4792 offset += view_address;
4793 if (static_cast<Address>(offset_in_output_section) != invalid_address)
4794 offset -= offset_in_output_section;
4797 // Handle the reloc addend based on the strategy.
4798 if (strategy == Relocatable_relocs::RELOC_COPY)
4800 else if (strategy == Relocatable_relocs::RELOC_ADJUST_FOR_SECTION_RELA)
4802 const Symbol_value<size>* psymval = object->local_symbol(orig_r_sym);
4803 addend = psymval->value(object, addend);
4805 else if (strategy == Relocatable_relocs::RELOC_SPECIAL)
4807 if (addend >= 32768)
4808 addend += got2_addend;
4813 if (!parameters->options().relocatable())
4815 if (r_type == elfcpp::R_POWERPC_GOT_TLSGD16
4816 || r_type == elfcpp::R_POWERPC_GOT_TLSGD16_LO
4817 || r_type == elfcpp::R_POWERPC_GOT_TLSGD16_HI
4818 || r_type == elfcpp::R_POWERPC_GOT_TLSGD16_HA)
4820 // First instruction of a global dynamic sequence,
4822 const bool final = gsym == NULL || gsym->final_value_is_known();
4823 switch (this->optimize_tls_gd(final))
4825 case tls::TLSOPT_TO_IE:
4826 r_type += (elfcpp::R_POWERPC_GOT_TPREL16
4827 - elfcpp::R_POWERPC_GOT_TLSGD16);
4829 case tls::TLSOPT_TO_LE:
4830 if (r_type == elfcpp::R_POWERPC_GOT_TLSGD16
4831 || r_type == elfcpp::R_POWERPC_GOT_TLSGD16_LO)
4832 r_type = elfcpp::R_POWERPC_TPREL16_HA;
4835 r_type = elfcpp::R_POWERPC_NONE;
4836 offset -= 2 * big_endian;
4843 else if (r_type == elfcpp::R_POWERPC_GOT_TLSLD16
4844 || r_type == elfcpp::R_POWERPC_GOT_TLSLD16_LO
4845 || r_type == elfcpp::R_POWERPC_GOT_TLSLD16_HI
4846 || r_type == elfcpp::R_POWERPC_GOT_TLSLD16_HA)
4848 // First instruction of a local dynamic sequence,
4850 if (this->optimize_tls_ld() == tls::TLSOPT_TO_LE)
4852 if (r_type == elfcpp::R_POWERPC_GOT_TLSLD16
4853 || r_type == elfcpp::R_POWERPC_GOT_TLSLD16_LO)
4855 r_type = elfcpp::R_POWERPC_TPREL16_HA;
4856 const Output_section* os = relinfo->layout->tls_segment()
4858 gold_assert(os != NULL);
4859 gold_assert(os->needs_symtab_index());
4860 r_sym = os->symtab_index();
4861 addend = dtp_offset;
4865 r_type = elfcpp::R_POWERPC_NONE;
4866 offset -= 2 * big_endian;
4870 else if (r_type == elfcpp::R_POWERPC_GOT_TPREL16
4871 || r_type == elfcpp::R_POWERPC_GOT_TPREL16_LO
4872 || r_type == elfcpp::R_POWERPC_GOT_TPREL16_HI
4873 || r_type == elfcpp::R_POWERPC_GOT_TPREL16_HA)
4875 // First instruction of initial exec sequence.
4876 const bool final = gsym == NULL || gsym->final_value_is_known();
4877 if (this->optimize_tls_ie(final) == tls::TLSOPT_TO_LE)
4879 if (r_type == elfcpp::R_POWERPC_GOT_TPREL16
4880 || r_type == elfcpp::R_POWERPC_GOT_TPREL16_LO)
4881 r_type = elfcpp::R_POWERPC_TPREL16_HA;
4884 r_type = elfcpp::R_POWERPC_NONE;
4885 offset -= 2 * big_endian;
4889 else if ((size == 64 && r_type == elfcpp::R_PPC64_TLSGD)
4890 || (size == 32 && r_type == elfcpp::R_PPC_TLSGD))
4892 // Second instruction of a global dynamic sequence,
4893 // the __tls_get_addr call
4894 const bool final = gsym == NULL || gsym->final_value_is_known();
4895 switch (this->optimize_tls_gd(final))
4897 case tls::TLSOPT_TO_IE:
4898 r_type = elfcpp::R_POWERPC_NONE;
4901 case tls::TLSOPT_TO_LE:
4902 r_type = elfcpp::R_POWERPC_TPREL16_LO;
4903 offset += 2 * big_endian;
4910 else if ((size == 64 && r_type == elfcpp::R_PPC64_TLSLD)
4911 || (size == 32 && r_type == elfcpp::R_PPC_TLSLD))
4913 // Second instruction of a local dynamic sequence,
4914 // the __tls_get_addr call
4915 if (this->optimize_tls_ld() == tls::TLSOPT_TO_LE)
4917 const Output_section* os = relinfo->layout->tls_segment()
4919 gold_assert(os != NULL);
4920 gold_assert(os->needs_symtab_index());
4921 r_sym = os->symtab_index();
4922 addend = dtp_offset;
4923 r_type = elfcpp::R_POWERPC_TPREL16_LO;
4924 offset += 2 * big_endian;
4928 else if (r_type == elfcpp::R_POWERPC_TLS)
4930 // Second instruction of an initial exec sequence
4931 const bool final = gsym == NULL || gsym->final_value_is_known();
4932 if (this->optimize_tls_ie(final) == tls::TLSOPT_TO_LE)
4934 r_type = elfcpp::R_POWERPC_TPREL16_LO;
4935 offset += 2 * big_endian;
4940 reloc_write.put_r_offset(offset);
4941 reloc_write.put_r_info(elfcpp::elf_r_info<size>(r_sym, r_type));
4942 reloc_write.put_r_addend(addend);
4944 pwrite += reloc_size;
4947 gold_assert(static_cast<section_size_type>(pwrite - reloc_view)
4948 == reloc_view_size);
4951 // Return the value to use for a dynamic which requires special
4952 // treatment. This is how we support equality comparisons of function
4953 // pointers across shared library boundaries, as described in the
4954 // processor specific ABI supplement.
4956 template<int size, bool big_endian>
4958 Target_powerpc<size, big_endian>::do_dynsym_value(const Symbol* gsym) const
4962 gold_assert(gsym->is_from_dynobj() && gsym->has_plt_offset());
4963 const Output_data_glink<size, big_endian>* glink = this->glink_section();
4964 static const unsigned char zeros[elfcpp::Elf_sizes<32>::rela_size] = {0};
4965 const elfcpp::Rela<size, big_endian> zero_reloc(zeros);
4966 unsigned int glink_index = glink->find_entry(gsym, zero_reloc, NULL);
4967 return glink->address() + glink_index * glink->glink_entry_size();
4973 // Return the offset to use for the GOT_INDX'th got entry which is
4974 // for a local tls symbol specified by OBJECT, SYMNDX.
4975 template<int size, bool big_endian>
4977 Target_powerpc<size, big_endian>::do_tls_offset_for_local(
4978 const Relobj* object,
4979 unsigned int symndx,
4980 unsigned int got_indx) const
4982 const Powerpc_relobj<size, big_endian>* ppc_object
4983 = static_cast<const Powerpc_relobj<size, big_endian>*>(object);
4984 if (ppc_object->local_symbol(symndx)->is_tls_symbol())
4986 for (Got_type got_type = GOT_TYPE_TLSGD;
4987 got_type <= GOT_TYPE_TPREL;
4988 got_type = Got_type(got_type + 1))
4989 if (ppc_object->local_has_got_offset(symndx, got_type))
4991 unsigned int off = ppc_object->local_got_offset(symndx, got_type);
4992 if (got_type == GOT_TYPE_TLSGD)
4994 if (off == got_indx * (size / 8))
4996 if (got_type == GOT_TYPE_TPREL)
5006 // Return the offset to use for the GOT_INDX'th got entry which is
5007 // for global tls symbol GSYM.
5008 template<int size, bool big_endian>
5010 Target_powerpc<size, big_endian>::do_tls_offset_for_global(
5012 unsigned int got_indx) const
5014 if (gsym->type() == elfcpp::STT_TLS)
5016 for (Got_type got_type = GOT_TYPE_TLSGD;
5017 got_type <= GOT_TYPE_TPREL;
5018 got_type = Got_type(got_type + 1))
5019 if (gsym->has_got_offset(got_type))
5021 unsigned int off = gsym->got_offset(got_type);
5022 if (got_type == GOT_TYPE_TLSGD)
5024 if (off == got_indx * (size / 8))
5026 if (got_type == GOT_TYPE_TPREL)
5036 // The selector for powerpc object files.
5038 template<int size, bool big_endian>
5039 class Target_selector_powerpc : public Target_selector
5042 Target_selector_powerpc()
5043 : Target_selector(elfcpp::EM_NONE, size, big_endian,
5045 ? (big_endian ? "elf64-powerpc" : "elf64-powerpcle")
5046 : (big_endian ? "elf32-powerpc" : "elf32-powerpcle")),
5048 ? (big_endian ? "elf64ppc" : "elf64lppc")
5049 : (big_endian ? "elf32ppc" : "elf32lppc")))
5053 do_recognize(Input_file*, off_t, int machine, int, int)
5058 if (machine != elfcpp::EM_PPC64)
5063 if (machine != elfcpp::EM_PPC)
5071 return this->instantiate_target();
5075 do_instantiate_target()
5076 { return new Target_powerpc<size, big_endian>(); }
5079 Target_selector_powerpc<32, true> target_selector_ppc32;
5080 Target_selector_powerpc<32, false> target_selector_ppc32le;
5081 Target_selector_powerpc<64, true> target_selector_ppc64;
5082 Target_selector_powerpc<64, false> target_selector_ppc64le;
5084 } // End anonymous namespace.