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.