1 // powerpc.cc -- powerpc target support for gold.
3 // Copyright (C) 2008-2014 Free Software Foundation, Inc.
4 // Written by David S. Miller <davem@davemloft.net>
5 // and David Edelsohn <edelsohn@gnu.org>
7 // This file is part of gold.
9 // This program is free software; you can redistribute it and/or modify
10 // it under the terms of the GNU General Public License as published by
11 // the Free Software Foundation; either version 3 of the License, or
12 // (at your option) any later version.
14 // This program is distributed in the hope that it will be useful,
15 // but WITHOUT ANY WARRANTY; without even the implied warranty of
16 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 // GNU General Public License for more details.
19 // You should have received a copy of the GNU General Public License
20 // along with this program; if not, write to the Free Software
21 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 // MA 02110-1301, USA.
30 #include "parameters.h"
37 #include "copy-relocs.h"
39 #include "target-reloc.h"
40 #include "target-select.h"
50 template<int size
, bool big_endian
>
51 class Output_data_plt_powerpc
;
53 template<int size
, bool big_endian
>
54 class Output_data_brlt_powerpc
;
56 template<int size
, bool big_endian
>
57 class Output_data_got_powerpc
;
59 template<int size
, bool big_endian
>
60 class Output_data_glink
;
62 template<int size
, bool big_endian
>
66 is_branch_reloc(unsigned int r_type
);
68 template<int size
, bool big_endian
>
69 class Powerpc_relobj
: public Sized_relobj_file
<size
, big_endian
>
72 typedef typename
elfcpp::Elf_types
<size
>::Elf_Addr Address
;
73 typedef Unordered_set
<Section_id
, Section_id_hash
> Section_refs
;
74 typedef Unordered_map
<Address
, Section_refs
> Access_from
;
76 Powerpc_relobj(const std::string
& name
, Input_file
* input_file
, off_t offset
,
77 const typename
elfcpp::Ehdr
<size
, big_endian
>& ehdr
)
78 : Sized_relobj_file
<size
, big_endian
>(name
, input_file
, offset
, ehdr
),
79 special_(0), has_small_toc_reloc_(false), opd_valid_(false),
80 opd_ent_(), access_from_map_(), has14_(), stub_table_(),
81 e_flags_(ehdr
.get_e_flags()), st_other_()
83 this->set_abiversion(0);
89 // Read the symbols then set up st_other vector.
91 do_read_symbols(Read_symbols_data
*);
93 // The .got2 section shndx.
98 return this->special_
;
103 // The .opd section shndx.
110 return this->special_
;
113 // Init OPD entry arrays.
115 init_opd(size_t opd_size
)
117 size_t count
= this->opd_ent_ndx(opd_size
);
118 this->opd_ent_
.resize(count
);
121 // Return section and offset of function entry for .opd + R_OFF.
123 get_opd_ent(Address r_off
, Address
* value
= NULL
) const
125 size_t ndx
= this->opd_ent_ndx(r_off
);
126 gold_assert(ndx
< this->opd_ent_
.size());
127 gold_assert(this->opd_ent_
[ndx
].shndx
!= 0);
129 *value
= this->opd_ent_
[ndx
].off
;
130 return this->opd_ent_
[ndx
].shndx
;
133 // Set section and offset of function entry for .opd + R_OFF.
135 set_opd_ent(Address r_off
, unsigned int shndx
, Address value
)
137 size_t ndx
= this->opd_ent_ndx(r_off
);
138 gold_assert(ndx
< this->opd_ent_
.size());
139 this->opd_ent_
[ndx
].shndx
= shndx
;
140 this->opd_ent_
[ndx
].off
= value
;
143 // Return discard flag for .opd + R_OFF.
145 get_opd_discard(Address r_off
) const
147 size_t ndx
= this->opd_ent_ndx(r_off
);
148 gold_assert(ndx
< this->opd_ent_
.size());
149 return this->opd_ent_
[ndx
].discard
;
152 // Set discard flag for .opd + R_OFF.
154 set_opd_discard(Address r_off
)
156 size_t ndx
= this->opd_ent_ndx(r_off
);
157 gold_assert(ndx
< this->opd_ent_
.size());
158 this->opd_ent_
[ndx
].discard
= true;
163 { return this->opd_valid_
; }
167 { this->opd_valid_
= true; }
169 // Examine .rela.opd to build info about function entry points.
171 scan_opd_relocs(size_t reloc_count
,
172 const unsigned char* prelocs
,
173 const unsigned char* plocal_syms
);
175 // Perform the Sized_relobj_file method, then set up opd info from
178 do_read_relocs(Read_relocs_data
*);
181 do_find_special_sections(Read_symbols_data
* sd
);
183 // Adjust this local symbol value. Return false if the symbol
184 // should be discarded from the output file.
186 do_adjust_local_symbol(Symbol_value
<size
>* lv
) const
188 if (size
== 64 && this->opd_shndx() != 0)
191 if (lv
->input_shndx(&is_ordinary
) != this->opd_shndx())
193 if (this->get_opd_discard(lv
->input_value()))
201 { return &this->access_from_map_
; }
203 // Add a reference from SRC_OBJ, SRC_INDX to this object's .opd
204 // section at DST_OFF.
206 add_reference(Object
* src_obj
,
207 unsigned int src_indx
,
208 typename
elfcpp::Elf_types
<size
>::Elf_Addr dst_off
)
210 Section_id
src_id(src_obj
, src_indx
);
211 this->access_from_map_
[dst_off
].insert(src_id
);
214 // Add a reference to the code section specified by the .opd entry
217 add_gc_mark(typename
elfcpp::Elf_types
<size
>::Elf_Addr dst_off
)
219 size_t ndx
= this->opd_ent_ndx(dst_off
);
220 if (ndx
>= this->opd_ent_
.size())
221 this->opd_ent_
.resize(ndx
+ 1);
222 this->opd_ent_
[ndx
].gc_mark
= true;
226 process_gc_mark(Symbol_table
* symtab
)
228 for (size_t i
= 0; i
< this->opd_ent_
.size(); i
++)
229 if (this->opd_ent_
[i
].gc_mark
)
231 unsigned int shndx
= this->opd_ent_
[i
].shndx
;
232 symtab
->gc()->worklist().push(Section_id(this, shndx
));
236 // Return offset in output GOT section that this object will use
237 // as a TOC pointer. Won't be just a constant with multi-toc support.
239 toc_base_offset() const
243 set_has_small_toc_reloc()
244 { has_small_toc_reloc_
= true; }
247 has_small_toc_reloc() const
248 { return has_small_toc_reloc_
; }
251 set_has_14bit_branch(unsigned int shndx
)
253 if (shndx
>= this->has14_
.size())
254 this->has14_
.resize(shndx
+ 1);
255 this->has14_
[shndx
] = true;
259 has_14bit_branch(unsigned int shndx
) const
260 { return shndx
< this->has14_
.size() && this->has14_
[shndx
]; }
263 set_stub_table(unsigned int shndx
, Stub_table
<size
, big_endian
>* stub_table
)
265 if (shndx
>= this->stub_table_
.size())
266 this->stub_table_
.resize(shndx
+ 1);
267 this->stub_table_
[shndx
] = stub_table
;
270 Stub_table
<size
, big_endian
>*
271 stub_table(unsigned int shndx
)
273 if (shndx
< this->stub_table_
.size())
274 return this->stub_table_
[shndx
];
280 { return this->e_flags_
& elfcpp::EF_PPC64_ABI
; }
282 // Set ABI version for input and output
284 set_abiversion(int ver
);
287 ppc64_local_entry_offset(const Symbol
* sym
) const
288 { return elfcpp::ppc64_decode_local_entry(sym
->nonvis() >> 3); }
291 ppc64_local_entry_offset(unsigned int symndx
) const
292 { return elfcpp::ppc64_decode_local_entry(this->st_other_
[symndx
] >> 5); }
303 // Return index into opd_ent_ array for .opd entry at OFF.
304 // .opd entries are 24 bytes long, but they can be spaced 16 bytes
305 // apart when the language doesn't use the last 8-byte word, the
306 // environment pointer. Thus dividing the entry section offset by
307 // 16 will give an index into opd_ent_ that works for either layout
308 // of .opd. (It leaves some elements of the vector unused when .opd
309 // entries are spaced 24 bytes apart, but we don't know the spacing
310 // until relocations are processed, and in any case it is possible
311 // for an object to have some entries spaced 16 bytes apart and
312 // others 24 bytes apart.)
314 opd_ent_ndx(size_t off
) const
317 // For 32-bit the .got2 section shdnx, for 64-bit the .opd section shndx.
318 unsigned int special_
;
320 // For 64-bit, whether this object uses small model relocs to access
322 bool has_small_toc_reloc_
;
324 // Set at the start of gc_process_relocs, when we know opd_ent_
325 // vector is valid. The flag could be made atomic and set in
326 // do_read_relocs with memory_order_release and then tested with
327 // memory_order_acquire, potentially resulting in fewer entries in
331 // The first 8-byte word of an OPD entry gives the address of the
332 // entry point of the function. Relocatable object files have a
333 // relocation on this word. The following vector records the
334 // section and offset specified by these relocations.
335 std::vector
<Opd_ent
> opd_ent_
;
337 // References made to this object's .opd section when running
338 // gc_process_relocs for another object, before the opd_ent_ vector
339 // is valid for this object.
340 Access_from access_from_map_
;
342 // Whether input section has a 14-bit branch reloc.
343 std::vector
<bool> has14_
;
345 // The stub table to use for a given input section.
346 std::vector
<Stub_table
<size
, big_endian
>*> stub_table_
;
349 elfcpp::Elf_Word e_flags_
;
351 // ELF st_other field for local symbols.
352 std::vector
<unsigned char> st_other_
;
355 template<int size
, bool big_endian
>
356 class Powerpc_dynobj
: public Sized_dynobj
<size
, big_endian
>
359 typedef typename
elfcpp::Elf_types
<size
>::Elf_Addr Address
;
361 Powerpc_dynobj(const std::string
& name
, Input_file
* input_file
, off_t offset
,
362 const typename
elfcpp::Ehdr
<size
, big_endian
>& ehdr
)
363 : Sized_dynobj
<size
, big_endian
>(name
, input_file
, offset
, ehdr
),
364 opd_shndx_(0), opd_ent_(), e_flags_(ehdr
.get_e_flags())
366 this->set_abiversion(0);
372 // Call Sized_dynobj::do_read_symbols to read the symbols then
373 // read .opd from a dynamic object, filling in opd_ent_ vector,
375 do_read_symbols(Read_symbols_data
*);
377 // The .opd section shndx.
381 return this->opd_shndx_
;
384 // The .opd section address.
388 return this->opd_address_
;
391 // Init OPD entry arrays.
393 init_opd(size_t opd_size
)
395 size_t count
= this->opd_ent_ndx(opd_size
);
396 this->opd_ent_
.resize(count
);
399 // Return section and offset of function entry for .opd + R_OFF.
401 get_opd_ent(Address r_off
, Address
* value
= NULL
) const
403 size_t ndx
= this->opd_ent_ndx(r_off
);
404 gold_assert(ndx
< this->opd_ent_
.size());
405 gold_assert(this->opd_ent_
[ndx
].shndx
!= 0);
407 *value
= this->opd_ent_
[ndx
].off
;
408 return this->opd_ent_
[ndx
].shndx
;
411 // Set section and offset of function entry for .opd + R_OFF.
413 set_opd_ent(Address r_off
, unsigned int shndx
, Address value
)
415 size_t ndx
= this->opd_ent_ndx(r_off
);
416 gold_assert(ndx
< this->opd_ent_
.size());
417 this->opd_ent_
[ndx
].shndx
= shndx
;
418 this->opd_ent_
[ndx
].off
= value
;
423 { return this->e_flags_
& elfcpp::EF_PPC64_ABI
; }
425 // Set ABI version for input and output.
427 set_abiversion(int ver
);
430 // Used to specify extent of executable sections.
433 Sec_info(Address start_
, Address len_
, unsigned int shndx_
)
434 : start(start_
), len(len_
), shndx(shndx_
)
438 operator<(const Sec_info
& that
) const
439 { return this->start
< that
.start
; }
452 // Return index into opd_ent_ array for .opd entry at OFF.
454 opd_ent_ndx(size_t off
) const
457 // For 64-bit the .opd section shndx and address.
458 unsigned int opd_shndx_
;
459 Address opd_address_
;
461 // The first 8-byte word of an OPD entry gives the address of the
462 // entry point of the function. Records the section and offset
463 // corresponding to the address. Note that in dynamic objects,
464 // offset is *not* relative to the section.
465 std::vector
<Opd_ent
> opd_ent_
;
468 elfcpp::Elf_Word e_flags_
;
471 template<int size
, bool big_endian
>
472 class Target_powerpc
: public Sized_target
<size
, big_endian
>
476 Output_data_reloc
<elfcpp::SHT_RELA
, true, size
, big_endian
> Reloc_section
;
477 typedef typename
elfcpp::Elf_types
<size
>::Elf_Addr Address
;
478 typedef typename
elfcpp::Elf_types
<size
>::Elf_Swxword Signed_address
;
479 static const Address invalid_address
= static_cast<Address
>(0) - 1;
480 // Offset of tp and dtp pointers from start of TLS block.
481 static const Address tp_offset
= 0x7000;
482 static const Address dtp_offset
= 0x8000;
485 : Sized_target
<size
, big_endian
>(&powerpc_info
),
486 got_(NULL
), plt_(NULL
), iplt_(NULL
), brlt_section_(NULL
),
487 glink_(NULL
), rela_dyn_(NULL
), copy_relocs_(elfcpp::R_POWERPC_COPY
),
488 tlsld_got_offset_(-1U),
489 stub_tables_(), branch_lookup_table_(), branch_info_(),
490 plt_thread_safe_(false)
494 // Process the relocations to determine unreferenced sections for
495 // garbage collection.
497 gc_process_relocs(Symbol_table
* symtab
,
499 Sized_relobj_file
<size
, big_endian
>* object
,
500 unsigned int data_shndx
,
501 unsigned int sh_type
,
502 const unsigned char* prelocs
,
504 Output_section
* output_section
,
505 bool needs_special_offset_handling
,
506 size_t local_symbol_count
,
507 const unsigned char* plocal_symbols
);
509 // Scan the relocations to look for symbol adjustments.
511 scan_relocs(Symbol_table
* symtab
,
513 Sized_relobj_file
<size
, big_endian
>* object
,
514 unsigned int data_shndx
,
515 unsigned int sh_type
,
516 const unsigned char* prelocs
,
518 Output_section
* output_section
,
519 bool needs_special_offset_handling
,
520 size_t local_symbol_count
,
521 const unsigned char* plocal_symbols
);
523 // Map input .toc section to output .got section.
525 do_output_section_name(const Relobj
*, const char* name
, size_t* plen
) const
527 if (size
== 64 && strcmp(name
, ".toc") == 0)
535 // Provide linker defined save/restore functions.
537 define_save_restore_funcs(Layout
*, Symbol_table
*);
539 // No stubs unless a final link.
542 { return !parameters
->options().relocatable(); }
545 do_relax(int, const Input_objects
*, Symbol_table
*, Layout
*, const Task
*);
548 do_plt_fde_location(const Output_data
*, unsigned char*,
549 uint64_t*, off_t
*) const;
551 // Stash info about branches, for stub generation.
553 push_branch(Powerpc_relobj
<size
, big_endian
>* ppc_object
,
554 unsigned int data_shndx
, Address r_offset
,
555 unsigned int r_type
, unsigned int r_sym
, Address addend
)
557 Branch_info
info(ppc_object
, data_shndx
, r_offset
, r_type
, r_sym
, addend
);
558 this->branch_info_
.push_back(info
);
559 if (r_type
== elfcpp::R_POWERPC_REL14
560 || r_type
== elfcpp::R_POWERPC_REL14_BRTAKEN
561 || r_type
== elfcpp::R_POWERPC_REL14_BRNTAKEN
)
562 ppc_object
->set_has_14bit_branch(data_shndx
);
565 Stub_table
<size
, big_endian
>*
569 do_define_standard_symbols(Symbol_table
*, Layout
*);
571 // Finalize the sections.
573 do_finalize_sections(Layout
*, const Input_objects
*, Symbol_table
*);
575 // Return the value to use for a dynamic which requires special
578 do_dynsym_value(const Symbol
*) const;
580 // Return the PLT address to use for a local symbol.
582 do_plt_address_for_local(const Relobj
*, unsigned int) const;
584 // Return the PLT address to use for a global symbol.
586 do_plt_address_for_global(const Symbol
*) const;
588 // Return the offset to use for the GOT_INDX'th got entry which is
589 // for a local tls symbol specified by OBJECT, SYMNDX.
591 do_tls_offset_for_local(const Relobj
* object
,
593 unsigned int got_indx
) const;
595 // Return the offset to use for the GOT_INDX'th got entry which is
596 // for global tls symbol GSYM.
598 do_tls_offset_for_global(Symbol
* gsym
, unsigned int got_indx
) const;
601 do_function_location(Symbol_location
*) const;
604 do_can_check_for_function_pointers() const
607 // Relocate a section.
609 relocate_section(const Relocate_info
<size
, big_endian
>*,
610 unsigned int sh_type
,
611 const unsigned char* prelocs
,
613 Output_section
* output_section
,
614 bool needs_special_offset_handling
,
616 Address view_address
,
617 section_size_type view_size
,
618 const Reloc_symbol_changes
*);
620 // Scan the relocs during a relocatable link.
622 scan_relocatable_relocs(Symbol_table
* symtab
,
624 Sized_relobj_file
<size
, big_endian
>* object
,
625 unsigned int data_shndx
,
626 unsigned int sh_type
,
627 const unsigned char* prelocs
,
629 Output_section
* output_section
,
630 bool needs_special_offset_handling
,
631 size_t local_symbol_count
,
632 const unsigned char* plocal_symbols
,
633 Relocatable_relocs
*);
635 // Emit relocations for a section.
637 relocate_relocs(const Relocate_info
<size
, big_endian
>*,
638 unsigned int sh_type
,
639 const unsigned char* prelocs
,
641 Output_section
* output_section
,
642 typename
elfcpp::Elf_types
<size
>::Elf_Off
643 offset_in_output_section
,
644 const Relocatable_relocs
*,
646 Address view_address
,
648 unsigned char* reloc_view
,
649 section_size_type reloc_view_size
);
651 // Return whether SYM is defined by the ABI.
653 do_is_defined_by_abi(const Symbol
* sym
) const
655 return strcmp(sym
->name(), "__tls_get_addr") == 0;
658 // Return the size of the GOT section.
662 gold_assert(this->got_
!= NULL
);
663 return this->got_
->data_size();
666 // Get the PLT section.
667 const Output_data_plt_powerpc
<size
, big_endian
>*
670 gold_assert(this->plt_
!= NULL
);
674 // Get the IPLT section.
675 const Output_data_plt_powerpc
<size
, big_endian
>*
678 gold_assert(this->iplt_
!= NULL
);
682 // Get the .glink section.
683 const Output_data_glink
<size
, big_endian
>*
684 glink_section() const
686 gold_assert(this->glink_
!= NULL
);
690 Output_data_glink
<size
, big_endian
>*
693 gold_assert(this->glink_
!= NULL
);
697 bool has_glink() const
698 { return this->glink_
!= NULL
; }
700 // Get the GOT section.
701 const Output_data_got_powerpc
<size
, big_endian
>*
704 gold_assert(this->got_
!= NULL
);
708 // Get the GOT section, creating it if necessary.
709 Output_data_got_powerpc
<size
, big_endian
>*
710 got_section(Symbol_table
*, Layout
*);
713 do_make_elf_object(const std::string
&, Input_file
*, off_t
,
714 const elfcpp::Ehdr
<size
, big_endian
>&);
716 // Return the number of entries in the GOT.
718 got_entry_count() const
720 if (this->got_
== NULL
)
722 return this->got_size() / (size
/ 8);
725 // Return the number of entries in the PLT.
727 plt_entry_count() const;
729 // Return the offset of the first non-reserved PLT entry.
731 first_plt_entry_offset() const
735 if (this->abiversion() >= 2)
740 // Return the size of each PLT entry.
742 plt_entry_size() const
746 if (this->abiversion() >= 2)
751 // Add any special sections for this symbol to the gc work list.
752 // For powerpc64, this adds the code section of a function
755 do_gc_mark_symbol(Symbol_table
* symtab
, Symbol
* sym
) const;
757 // Handle target specific gc actions when adding a gc reference from
758 // SRC_OBJ, SRC_SHNDX to a location specified by DST_OBJ, DST_SHNDX
759 // and DST_OFF. For powerpc64, this adds a referenc to the code
760 // section of a function descriptor.
762 do_gc_add_reference(Symbol_table
* symtab
,
764 unsigned int src_shndx
,
766 unsigned int dst_shndx
,
767 Address dst_off
) const;
769 typedef std::vector
<Stub_table
<size
, big_endian
>*> Stub_tables
;
772 { return this->stub_tables_
; }
774 const Output_data_brlt_powerpc
<size
, big_endian
>*
776 { return this->brlt_section_
; }
779 add_branch_lookup_table(Address to
)
781 unsigned int off
= this->branch_lookup_table_
.size() * (size
/ 8);
782 this->branch_lookup_table_
.insert(std::make_pair(to
, off
));
786 find_branch_lookup_table(Address to
)
788 typename
Branch_lookup_table::const_iterator p
789 = this->branch_lookup_table_
.find(to
);
790 return p
== this->branch_lookup_table_
.end() ? invalid_address
: p
->second
;
794 write_branch_lookup_table(unsigned char *oview
)
796 for (typename
Branch_lookup_table::const_iterator p
797 = this->branch_lookup_table_
.begin();
798 p
!= this->branch_lookup_table_
.end();
801 elfcpp::Swap
<size
, big_endian
>::writeval(oview
+ p
->second
, p
->first
);
806 plt_thread_safe() const
807 { return this->plt_thread_safe_
; }
811 { return this->processor_specific_flags() & elfcpp::EF_PPC64_ABI
; }
814 set_abiversion (int ver
)
816 elfcpp::Elf_Word flags
= this->processor_specific_flags();
817 flags
&= ~elfcpp::EF_PPC64_ABI
;
818 flags
|= ver
& elfcpp::EF_PPC64_ABI
;
819 this->set_processor_specific_flags(flags
);
822 // Offset to to save stack slot
825 { return this->abiversion() < 2 ? 40 : 24; }
841 : tls_get_addr_(NOT_EXPECTED
),
842 relinfo_(NULL
), relnum_(0), r_offset_(0)
847 if (this->tls_get_addr_
!= NOT_EXPECTED
)
854 if (this->relinfo_
!= NULL
)
855 gold_error_at_location(this->relinfo_
, this->relnum_
, this->r_offset_
,
856 _("missing expected __tls_get_addr call"));
860 expect_tls_get_addr_call(
861 const Relocate_info
<size
, big_endian
>* relinfo
,
865 this->tls_get_addr_
= EXPECTED
;
866 this->relinfo_
= relinfo
;
867 this->relnum_
= relnum
;
868 this->r_offset_
= r_offset
;
872 expect_tls_get_addr_call()
873 { this->tls_get_addr_
= EXPECTED
; }
876 skip_next_tls_get_addr_call()
877 {this->tls_get_addr_
= SKIP
; }
880 maybe_skip_tls_get_addr_call(unsigned int r_type
, const Symbol
* gsym
)
882 bool is_tls_call
= ((r_type
== elfcpp::R_POWERPC_REL24
883 || r_type
== elfcpp::R_PPC_PLTREL24
)
885 && strcmp(gsym
->name(), "__tls_get_addr") == 0);
886 Tls_get_addr last_tls
= this->tls_get_addr_
;
887 this->tls_get_addr_
= NOT_EXPECTED
;
888 if (is_tls_call
&& last_tls
!= EXPECTED
)
890 else if (!is_tls_call
&& last_tls
!= NOT_EXPECTED
)
899 // What we're up to regarding calls to __tls_get_addr.
900 // On powerpc, the branch and link insn making a call to
901 // __tls_get_addr is marked with a relocation, R_PPC64_TLSGD,
902 // R_PPC64_TLSLD, R_PPC_TLSGD or R_PPC_TLSLD, in addition to the
903 // usual R_POWERPC_REL24 or R_PPC_PLTREL25 relocation on a call.
904 // The marker relocation always comes first, and has the same
905 // symbol as the reloc on the insn setting up the __tls_get_addr
906 // argument. This ties the arg setup insn with the call insn,
907 // allowing ld to safely optimize away the call. We check that
908 // every call to __tls_get_addr has a marker relocation, and that
909 // every marker relocation is on a call to __tls_get_addr.
910 Tls_get_addr tls_get_addr_
;
911 // Info about the last reloc for error message.
912 const Relocate_info
<size
, big_endian
>* relinfo_
;
917 // The class which scans relocations.
918 class Scan
: protected Track_tls
921 typedef typename
elfcpp::Elf_types
<size
>::Elf_Addr Address
;
924 : Track_tls(), issued_non_pic_error_(false)
928 get_reference_flags(unsigned int r_type
, const Target_powerpc
* target
);
931 local(Symbol_table
* symtab
, Layout
* layout
, Target_powerpc
* target
,
932 Sized_relobj_file
<size
, big_endian
>* object
,
933 unsigned int data_shndx
,
934 Output_section
* output_section
,
935 const elfcpp::Rela
<size
, big_endian
>& reloc
, unsigned int r_type
,
936 const elfcpp::Sym
<size
, big_endian
>& lsym
,
940 global(Symbol_table
* symtab
, Layout
* layout
, Target_powerpc
* target
,
941 Sized_relobj_file
<size
, big_endian
>* object
,
942 unsigned int data_shndx
,
943 Output_section
* output_section
,
944 const elfcpp::Rela
<size
, big_endian
>& reloc
, unsigned int r_type
,
948 local_reloc_may_be_function_pointer(Symbol_table
* , Layout
* ,
950 Sized_relobj_file
<size
, big_endian
>* relobj
,
953 const elfcpp::Rela
<size
, big_endian
>& ,
955 const elfcpp::Sym
<size
, big_endian
>&)
957 // PowerPC64 .opd is not folded, so any identical function text
958 // may be folded and we'll still keep function addresses distinct.
959 // That means no reloc is of concern here.
962 Powerpc_relobj
<size
, big_endian
>* ppcobj
= static_cast
963 <Powerpc_relobj
<size
, big_endian
>*>(relobj
);
964 if (ppcobj
->abiversion() == 1)
967 // For 32-bit and ELFv2, conservatively assume anything but calls to
968 // function code might be taking the address of the function.
969 return !is_branch_reloc(r_type
);
973 global_reloc_may_be_function_pointer(Symbol_table
* , Layout
* ,
975 Sized_relobj_file
<size
, big_endian
>* relobj
,
978 const elfcpp::Rela
<size
, big_endian
>& ,
985 Powerpc_relobj
<size
, big_endian
>* ppcobj
= static_cast
986 <Powerpc_relobj
<size
, big_endian
>*>(relobj
);
987 if (ppcobj
->abiversion() == 1)
990 return !is_branch_reloc(r_type
);
994 reloc_needs_plt_for_ifunc(Target_powerpc
<size
, big_endian
>* target
,
995 Sized_relobj_file
<size
, big_endian
>* object
,
996 unsigned int r_type
, bool report_err
);
1000 unsupported_reloc_local(Sized_relobj_file
<size
, big_endian
>*,
1001 unsigned int r_type
);
1004 unsupported_reloc_global(Sized_relobj_file
<size
, big_endian
>*,
1005 unsigned int r_type
, Symbol
*);
1008 generate_tls_call(Symbol_table
* symtab
, Layout
* layout
,
1009 Target_powerpc
* target
);
1012 check_non_pic(Relobj
*, unsigned int r_type
);
1014 // Whether we have issued an error about a non-PIC compilation.
1015 bool issued_non_pic_error_
;
1019 symval_for_branch(const Symbol_table
* symtab
, Address value
,
1020 const Sized_symbol
<size
>* gsym
,
1021 Powerpc_relobj
<size
, big_endian
>* object
,
1022 unsigned int *dest_shndx
);
1024 // The class which implements relocation.
1025 class Relocate
: protected Track_tls
1028 // Use 'at' branch hints when true, 'y' when false.
1029 // FIXME maybe: set this with an option.
1030 static const bool is_isa_v2
= true;
1036 // Do a relocation. Return false if the caller should not issue
1037 // any warnings about this relocation.
1039 relocate(const Relocate_info
<size
, big_endian
>*, Target_powerpc
*,
1040 Output_section
*, size_t relnum
,
1041 const elfcpp::Rela
<size
, big_endian
>&,
1042 unsigned int r_type
, const Sized_symbol
<size
>*,
1043 const Symbol_value
<size
>*,
1045 typename
elfcpp::Elf_types
<size
>::Elf_Addr
,
1049 class Relocate_comdat_behavior
1052 // Decide what the linker should do for relocations that refer to
1053 // discarded comdat sections.
1054 inline Comdat_behavior
1055 get(const char* name
)
1057 gold::Default_comdat_behavior default_behavior
;
1058 Comdat_behavior ret
= default_behavior
.get(name
);
1059 if (ret
== CB_WARNING
)
1062 && (strcmp(name
, ".fixup") == 0
1063 || strcmp(name
, ".got2") == 0))
1066 && (strcmp(name
, ".opd") == 0
1067 || strcmp(name
, ".toc") == 0
1068 || strcmp(name
, ".toc1") == 0))
1075 // A class which returns the size required for a relocation type,
1076 // used while scanning relocs during a relocatable link.
1077 class Relocatable_size_for_reloc
1081 get_size_for_reloc(unsigned int, Relobj
*)
1088 // Optimize the TLS relocation type based on what we know about the
1089 // symbol. IS_FINAL is true if the final address of this symbol is
1090 // known at link time.
1092 tls::Tls_optimization
1093 optimize_tls_gd(bool is_final
)
1095 // If we are generating a shared library, then we can't do anything
1097 if (parameters
->options().shared())
1098 return tls::TLSOPT_NONE
;
1101 return tls::TLSOPT_TO_IE
;
1102 return tls::TLSOPT_TO_LE
;
1105 tls::Tls_optimization
1108 if (parameters
->options().shared())
1109 return tls::TLSOPT_NONE
;
1111 return tls::TLSOPT_TO_LE
;
1114 tls::Tls_optimization
1115 optimize_tls_ie(bool is_final
)
1117 if (!is_final
|| parameters
->options().shared())
1118 return tls::TLSOPT_NONE
;
1120 return tls::TLSOPT_TO_LE
;
1125 make_glink_section(Layout
*);
1127 // Create the PLT section.
1129 make_plt_section(Symbol_table
*, Layout
*);
1132 make_iplt_section(Symbol_table
*, Layout
*);
1135 make_brlt_section(Layout
*);
1137 // Create a PLT entry for a global symbol.
1139 make_plt_entry(Symbol_table
*, Layout
*, Symbol
*);
1141 // Create a PLT entry for a local IFUNC symbol.
1143 make_local_ifunc_plt_entry(Symbol_table
*, Layout
*,
1144 Sized_relobj_file
<size
, big_endian
>*,
1148 // Create a GOT entry for local dynamic __tls_get_addr.
1150 tlsld_got_offset(Symbol_table
* symtab
, Layout
* layout
,
1151 Sized_relobj_file
<size
, big_endian
>* object
);
1154 tlsld_got_offset() const
1156 return this->tlsld_got_offset_
;
1159 // Get the dynamic reloc section, creating it if necessary.
1161 rela_dyn_section(Layout
*);
1163 // Similarly, but for ifunc symbols get the one for ifunc.
1165 rela_dyn_section(Symbol_table
*, Layout
*, bool for_ifunc
);
1167 // Copy a relocation against a global symbol.
1169 copy_reloc(Symbol_table
* symtab
, Layout
* layout
,
1170 Sized_relobj_file
<size
, big_endian
>* object
,
1171 unsigned int shndx
, Output_section
* output_section
,
1172 Symbol
* sym
, const elfcpp::Rela
<size
, big_endian
>& reloc
)
1174 this->copy_relocs_
.copy_reloc(symtab
, layout
,
1175 symtab
->get_sized_symbol
<size
>(sym
),
1176 object
, shndx
, output_section
,
1177 reloc
, this->rela_dyn_section(layout
));
1180 // Look over all the input sections, deciding where to place stubs.
1182 group_sections(Layout
*, const Task
*);
1184 // Sort output sections by address.
1185 struct Sort_sections
1188 operator()(const Output_section
* sec1
, const Output_section
* sec2
)
1189 { return sec1
->address() < sec2
->address(); }
1195 Branch_info(Powerpc_relobj
<size
, big_endian
>* ppc_object
,
1196 unsigned int data_shndx
,
1198 unsigned int r_type
,
1201 : object_(ppc_object
), shndx_(data_shndx
), offset_(r_offset
),
1202 r_type_(r_type
), r_sym_(r_sym
), addend_(addend
)
1208 // If this branch needs a plt call stub, or a long branch stub, make one.
1210 make_stub(Stub_table
<size
, big_endian
>*,
1211 Stub_table
<size
, big_endian
>*,
1212 Symbol_table
*) const;
1215 // The branch location..
1216 Powerpc_relobj
<size
, big_endian
>* object_
;
1217 unsigned int shndx_
;
1219 // ..and the branch type and destination.
1220 unsigned int r_type_
;
1221 unsigned int r_sym_
;
1225 // Information about this specific target which we pass to the
1226 // general Target structure.
1227 static Target::Target_info powerpc_info
;
1229 // The types of GOT entries needed for this platform.
1230 // These values are exposed to the ABI in an incremental link.
1231 // Do not renumber existing values without changing the version
1232 // number of the .gnu_incremental_inputs section.
1236 GOT_TYPE_TLSGD
, // double entry for @got@tlsgd
1237 GOT_TYPE_DTPREL
, // entry for @got@dtprel
1238 GOT_TYPE_TPREL
// entry for @got@tprel
1242 Output_data_got_powerpc
<size
, big_endian
>* got_
;
1243 // The PLT section. This is a container for a table of addresses,
1244 // and their relocations. Each address in the PLT has a dynamic
1245 // relocation (R_*_JMP_SLOT) and each address will have a
1246 // corresponding entry in .glink for lazy resolution of the PLT.
1247 // ppc32 initialises the PLT to point at the .glink entry, while
1248 // ppc64 leaves this to ld.so. To make a call via the PLT, the
1249 // linker adds a stub that loads the PLT entry into ctr then
1250 // branches to ctr. There may be more than one stub for each PLT
1251 // entry. DT_JMPREL points at the first PLT dynamic relocation and
1252 // DT_PLTRELSZ gives the total size of PLT dynamic relocations.
1253 Output_data_plt_powerpc
<size
, big_endian
>* plt_
;
1254 // The IPLT section. Like plt_, this is a container for a table of
1255 // addresses and their relocations, specifically for STT_GNU_IFUNC
1256 // functions that resolve locally (STT_GNU_IFUNC functions that
1257 // don't resolve locally go in PLT). Unlike plt_, these have no
1258 // entry in .glink for lazy resolution, and the relocation section
1259 // does not have a 1-1 correspondence with IPLT addresses. In fact,
1260 // the relocation section may contain relocations against
1261 // STT_GNU_IFUNC symbols at locations outside of IPLT. The
1262 // relocation section will appear at the end of other dynamic
1263 // relocations, so that ld.so applies these relocations after other
1264 // dynamic relocations. In a static executable, the relocation
1265 // section is emitted and marked with __rela_iplt_start and
1266 // __rela_iplt_end symbols.
1267 Output_data_plt_powerpc
<size
, big_endian
>* iplt_
;
1268 // Section holding long branch destinations.
1269 Output_data_brlt_powerpc
<size
, big_endian
>* brlt_section_
;
1270 // The .glink section.
1271 Output_data_glink
<size
, big_endian
>* glink_
;
1272 // The dynamic reloc section.
1273 Reloc_section
* rela_dyn_
;
1274 // Relocs saved to avoid a COPY reloc.
1275 Copy_relocs
<elfcpp::SHT_RELA
, size
, big_endian
> copy_relocs_
;
1276 // Offset of the GOT entry for local dynamic __tls_get_addr calls.
1277 unsigned int tlsld_got_offset_
;
1279 Stub_tables stub_tables_
;
1280 typedef Unordered_map
<Address
, unsigned int> Branch_lookup_table
;
1281 Branch_lookup_table branch_lookup_table_
;
1283 typedef std::vector
<Branch_info
> Branches
;
1284 Branches branch_info_
;
1286 bool plt_thread_safe_
;
1290 Target::Target_info Target_powerpc
<32, true>::powerpc_info
=
1293 true, // is_big_endian
1294 elfcpp::EM_PPC
, // machine_code
1295 false, // has_make_symbol
1296 false, // has_resolve
1297 false, // has_code_fill
1298 true, // is_default_stack_executable
1299 false, // can_icf_inline_merge_sections
1301 "/usr/lib/ld.so.1", // dynamic_linker
1302 0x10000000, // default_text_segment_address
1303 64 * 1024, // abi_pagesize (overridable by -z max-page-size)
1304 4 * 1024, // common_pagesize (overridable by -z common-page-size)
1305 false, // isolate_execinstr
1307 elfcpp::SHN_UNDEF
, // small_common_shndx
1308 elfcpp::SHN_UNDEF
, // large_common_shndx
1309 0, // small_common_section_flags
1310 0, // large_common_section_flags
1311 NULL
, // attributes_section
1312 NULL
, // attributes_vendor
1313 "_start" // entry_symbol_name
1317 Target::Target_info Target_powerpc
<32, false>::powerpc_info
=
1320 false, // is_big_endian
1321 elfcpp::EM_PPC
, // machine_code
1322 false, // has_make_symbol
1323 false, // has_resolve
1324 false, // has_code_fill
1325 true, // is_default_stack_executable
1326 false, // can_icf_inline_merge_sections
1328 "/usr/lib/ld.so.1", // dynamic_linker
1329 0x10000000, // default_text_segment_address
1330 64 * 1024, // abi_pagesize (overridable by -z max-page-size)
1331 4 * 1024, // common_pagesize (overridable by -z common-page-size)
1332 false, // isolate_execinstr
1334 elfcpp::SHN_UNDEF
, // small_common_shndx
1335 elfcpp::SHN_UNDEF
, // large_common_shndx
1336 0, // small_common_section_flags
1337 0, // large_common_section_flags
1338 NULL
, // attributes_section
1339 NULL
, // attributes_vendor
1340 "_start" // entry_symbol_name
1344 Target::Target_info Target_powerpc
<64, true>::powerpc_info
=
1347 true, // is_big_endian
1348 elfcpp::EM_PPC64
, // machine_code
1349 false, // has_make_symbol
1350 false, // has_resolve
1351 false, // has_code_fill
1352 true, // is_default_stack_executable
1353 false, // can_icf_inline_merge_sections
1355 "/usr/lib/ld.so.1", // dynamic_linker
1356 0x10000000, // default_text_segment_address
1357 64 * 1024, // abi_pagesize (overridable by -z max-page-size)
1358 4 * 1024, // common_pagesize (overridable by -z common-page-size)
1359 false, // isolate_execinstr
1361 elfcpp::SHN_UNDEF
, // small_common_shndx
1362 elfcpp::SHN_UNDEF
, // large_common_shndx
1363 0, // small_common_section_flags
1364 0, // large_common_section_flags
1365 NULL
, // attributes_section
1366 NULL
, // attributes_vendor
1367 "_start" // entry_symbol_name
1371 Target::Target_info Target_powerpc
<64, false>::powerpc_info
=
1374 false, // is_big_endian
1375 elfcpp::EM_PPC64
, // machine_code
1376 false, // has_make_symbol
1377 false, // has_resolve
1378 false, // has_code_fill
1379 true, // is_default_stack_executable
1380 false, // can_icf_inline_merge_sections
1382 "/usr/lib/ld.so.1", // dynamic_linker
1383 0x10000000, // default_text_segment_address
1384 64 * 1024, // abi_pagesize (overridable by -z max-page-size)
1385 4 * 1024, // common_pagesize (overridable by -z common-page-size)
1386 false, // isolate_execinstr
1388 elfcpp::SHN_UNDEF
, // small_common_shndx
1389 elfcpp::SHN_UNDEF
, // large_common_shndx
1390 0, // small_common_section_flags
1391 0, // large_common_section_flags
1392 NULL
, // attributes_section
1393 NULL
, // attributes_vendor
1394 "_start" // entry_symbol_name
1398 is_branch_reloc(unsigned int r_type
)
1400 return (r_type
== elfcpp::R_POWERPC_REL24
1401 || r_type
== elfcpp::R_PPC_PLTREL24
1402 || r_type
== elfcpp::R_PPC_LOCAL24PC
1403 || r_type
== elfcpp::R_POWERPC_REL14
1404 || r_type
== elfcpp::R_POWERPC_REL14_BRTAKEN
1405 || r_type
== elfcpp::R_POWERPC_REL14_BRNTAKEN
1406 || r_type
== elfcpp::R_POWERPC_ADDR24
1407 || r_type
== elfcpp::R_POWERPC_ADDR14
1408 || r_type
== elfcpp::R_POWERPC_ADDR14_BRTAKEN
1409 || r_type
== elfcpp::R_POWERPC_ADDR14_BRNTAKEN
);
1412 // If INSN is an opcode that may be used with an @tls operand, return
1413 // the transformed insn for TLS optimisation, otherwise return 0. If
1414 // REG is non-zero only match an insn with RB or RA equal to REG.
1416 at_tls_transform(uint32_t insn
, unsigned int reg
)
1418 if ((insn
& (0x3f << 26)) != 31 << 26)
1422 if (reg
== 0 || ((insn
>> 11) & 0x1f) == reg
)
1423 rtra
= insn
& ((1 << 26) - (1 << 16));
1424 else if (((insn
>> 16) & 0x1f) == reg
)
1425 rtra
= (insn
& (0x1f << 21)) | ((insn
& (0x1f << 11)) << 5);
1429 if ((insn
& (0x3ff << 1)) == 266 << 1)
1432 else if ((insn
& (0x1f << 1)) == 23 << 1
1433 && ((insn
& (0x1f << 6)) < 14 << 6
1434 || ((insn
& (0x1f << 6)) >= 16 << 6
1435 && (insn
& (0x1f << 6)) < 24 << 6)))
1436 // load and store indexed -> dform
1437 insn
= (32 | ((insn
>> 6) & 0x1f)) << 26;
1438 else if ((insn
& (((0x1a << 5) | 0x1f) << 1)) == 21 << 1)
1439 // ldx, ldux, stdx, stdux -> ld, ldu, std, stdu
1440 insn
= ((58 | ((insn
>> 6) & 4)) << 26) | ((insn
>> 6) & 1);
1441 else if ((insn
& (((0x1f << 5) | 0x1f) << 1)) == 341 << 1)
1443 insn
= (58 << 26) | 2;
1451 template<int size
, bool big_endian
>
1452 class Powerpc_relocate_functions
1472 typedef Powerpc_relocate_functions
<size
, big_endian
> This
;
1473 typedef typename
elfcpp::Elf_types
<size
>::Elf_Addr Address
;
1475 template<int valsize
>
1477 has_overflow_signed(Address value
)
1479 // limit = 1 << (valsize - 1) without shift count exceeding size of type
1480 Address limit
= static_cast<Address
>(1) << ((valsize
- 1) >> 1);
1481 limit
<<= ((valsize
- 1) >> 1);
1482 limit
<<= ((valsize
- 1) - 2 * ((valsize
- 1) >> 1));
1483 return value
+ limit
> (limit
<< 1) - 1;
1486 template<int valsize
>
1488 has_overflow_unsigned(Address value
)
1490 Address limit
= static_cast<Address
>(1) << ((valsize
- 1) >> 1);
1491 limit
<<= ((valsize
- 1) >> 1);
1492 limit
<<= ((valsize
- 1) - 2 * ((valsize
- 1) >> 1));
1493 return value
> (limit
<< 1) - 1;
1496 template<int valsize
>
1498 has_overflow_bitfield(Address value
)
1500 return (has_overflow_unsigned
<valsize
>(value
)
1501 && has_overflow_signed
<valsize
>(value
));
1504 template<int valsize
>
1505 static inline Status
1506 overflowed(Address value
, Overflow_check overflow
)
1508 if (overflow
== CHECK_SIGNED
)
1510 if (has_overflow_signed
<valsize
>(value
))
1511 return STATUS_OVERFLOW
;
1513 else if (overflow
== CHECK_UNSIGNED
)
1515 if (has_overflow_unsigned
<valsize
>(value
))
1516 return STATUS_OVERFLOW
;
1518 else if (overflow
== CHECK_BITFIELD
)
1520 if (has_overflow_bitfield
<valsize
>(value
))
1521 return STATUS_OVERFLOW
;
1526 // Do a simple RELA relocation
1527 template<int fieldsize
, int valsize
>
1528 static inline Status
1529 rela(unsigned char* view
, Address value
, Overflow_check overflow
)
1531 typedef typename
elfcpp::Swap
<fieldsize
, big_endian
>::Valtype Valtype
;
1532 Valtype
* wv
= reinterpret_cast<Valtype
*>(view
);
1533 elfcpp::Swap
<fieldsize
, big_endian
>::writeval(wv
, value
);
1534 return overflowed
<valsize
>(value
, overflow
);
1537 template<int fieldsize
, int valsize
>
1538 static inline Status
1539 rela(unsigned char* view
,
1540 unsigned int right_shift
,
1541 typename
elfcpp::Valtype_base
<fieldsize
>::Valtype dst_mask
,
1543 Overflow_check overflow
)
1545 typedef typename
elfcpp::Swap
<fieldsize
, big_endian
>::Valtype Valtype
;
1546 Valtype
* wv
= reinterpret_cast<Valtype
*>(view
);
1547 Valtype val
= elfcpp::Swap
<fieldsize
, big_endian
>::readval(wv
);
1548 Valtype reloc
= value
>> right_shift
;
1551 elfcpp::Swap
<fieldsize
, big_endian
>::writeval(wv
, val
| reloc
);
1552 return overflowed
<valsize
>(value
>> right_shift
, overflow
);
1555 // Do a simple RELA relocation, unaligned.
1556 template<int fieldsize
, int valsize
>
1557 static inline Status
1558 rela_ua(unsigned char* view
, Address value
, Overflow_check overflow
)
1560 elfcpp::Swap_unaligned
<fieldsize
, big_endian
>::writeval(view
, value
);
1561 return overflowed
<valsize
>(value
, overflow
);
1564 template<int fieldsize
, int valsize
>
1565 static inline Status
1566 rela_ua(unsigned char* view
,
1567 unsigned int right_shift
,
1568 typename
elfcpp::Valtype_base
<fieldsize
>::Valtype dst_mask
,
1570 Overflow_check overflow
)
1572 typedef typename
elfcpp::Swap_unaligned
<fieldsize
, big_endian
>::Valtype
1574 Valtype val
= elfcpp::Swap
<fieldsize
, big_endian
>::readval(view
);
1575 Valtype reloc
= value
>> right_shift
;
1578 elfcpp::Swap_unaligned
<fieldsize
, big_endian
>::writeval(view
, val
| reloc
);
1579 return overflowed
<valsize
>(value
>> right_shift
, overflow
);
1583 // R_PPC64_ADDR64: (Symbol + Addend)
1585 addr64(unsigned char* view
, Address value
)
1586 { This::template rela
<64,64>(view
, value
, CHECK_NONE
); }
1588 // R_PPC64_UADDR64: (Symbol + Addend) unaligned
1590 addr64_u(unsigned char* view
, Address value
)
1591 { This::template rela_ua
<64,64>(view
, value
, CHECK_NONE
); }
1593 // R_POWERPC_ADDR32: (Symbol + Addend)
1594 static inline Status
1595 addr32(unsigned char* view
, Address value
, Overflow_check overflow
)
1596 { return This::template rela
<32,32>(view
, value
, overflow
); }
1598 // R_POWERPC_UADDR32: (Symbol + Addend) unaligned
1599 static inline Status
1600 addr32_u(unsigned char* view
, Address value
, Overflow_check overflow
)
1601 { return This::template rela_ua
<32,32>(view
, value
, overflow
); }
1603 // R_POWERPC_ADDR24: (Symbol + Addend) & 0x3fffffc
1604 static inline Status
1605 addr24(unsigned char* view
, Address value
, Overflow_check overflow
)
1607 Status stat
= This::template rela
<32,26>(view
, 0, 0x03fffffc,
1609 if (overflow
!= CHECK_NONE
&& (value
& 3) != 0)
1610 stat
= STATUS_OVERFLOW
;
1614 // R_POWERPC_ADDR16: (Symbol + Addend) & 0xffff
1615 static inline Status
1616 addr16(unsigned char* view
, Address value
, Overflow_check overflow
)
1617 { return This::template rela
<16,16>(view
, value
, overflow
); }
1619 // R_POWERPC_ADDR16: (Symbol + Addend) & 0xffff, unaligned
1620 static inline Status
1621 addr16_u(unsigned char* view
, Address value
, Overflow_check overflow
)
1622 { return This::template rela_ua
<16,16>(view
, value
, overflow
); }
1624 // R_POWERPC_ADDR16_DS: (Symbol + Addend) & 0xfffc
1625 static inline Status
1626 addr16_ds(unsigned char* view
, Address value
, Overflow_check overflow
)
1628 Status stat
= This::template rela
<16,16>(view
, 0, 0xfffc, value
, overflow
);
1629 if (overflow
!= CHECK_NONE
&& (value
& 3) != 0)
1630 stat
= STATUS_OVERFLOW
;
1634 // R_POWERPC_ADDR16_HI: ((Symbol + Addend) >> 16) & 0xffff
1636 addr16_hi(unsigned char* view
, Address value
)
1637 { This::template rela
<16,16>(view
, 16, 0xffff, value
, CHECK_NONE
); }
1639 // R_POWERPC_ADDR16_HA: ((Symbol + Addend + 0x8000) >> 16) & 0xffff
1641 addr16_ha(unsigned char* view
, Address value
)
1642 { This::addr16_hi(view
, value
+ 0x8000); }
1644 // R_POWERPC_ADDR16_HIGHER: ((Symbol + Addend) >> 32) & 0xffff
1646 addr16_hi2(unsigned char* view
, Address value
)
1647 { This::template rela
<16,16>(view
, 32, 0xffff, value
, CHECK_NONE
); }
1649 // R_POWERPC_ADDR16_HIGHERA: ((Symbol + Addend + 0x8000) >> 32) & 0xffff
1651 addr16_ha2(unsigned char* view
, Address value
)
1652 { This::addr16_hi2(view
, value
+ 0x8000); }
1654 // R_POWERPC_ADDR16_HIGHEST: ((Symbol + Addend) >> 48) & 0xffff
1656 addr16_hi3(unsigned char* view
, Address value
)
1657 { This::template rela
<16,16>(view
, 48, 0xffff, value
, CHECK_NONE
); }
1659 // R_POWERPC_ADDR16_HIGHESTA: ((Symbol + Addend + 0x8000) >> 48) & 0xffff
1661 addr16_ha3(unsigned char* view
, Address value
)
1662 { This::addr16_hi3(view
, value
+ 0x8000); }
1664 // R_POWERPC_ADDR14: (Symbol + Addend) & 0xfffc
1665 static inline Status
1666 addr14(unsigned char* view
, Address value
, Overflow_check overflow
)
1668 Status stat
= This::template rela
<32,16>(view
, 0, 0xfffc, value
, overflow
);
1669 if (overflow
!= CHECK_NONE
&& (value
& 3) != 0)
1670 stat
= STATUS_OVERFLOW
;
1675 // Set ABI version for input and output.
1677 template<int size
, bool big_endian
>
1679 Powerpc_relobj
<size
, big_endian
>::set_abiversion(int ver
)
1681 this->e_flags_
|= ver
;
1682 if (this->abiversion() != 0)
1684 Target_powerpc
<size
, big_endian
>* target
=
1685 static_cast<Target_powerpc
<size
, big_endian
>*>(
1686 parameters
->sized_target
<size
, big_endian
>());
1687 if (target
->abiversion() == 0)
1688 target
->set_abiversion(this->abiversion());
1689 else if (target
->abiversion() != this->abiversion())
1690 gold_error(_("%s: ABI version %d is not compatible "
1691 "with ABI version %d output"),
1692 this->name().c_str(),
1693 this->abiversion(), target
->abiversion());
1698 // Stash away the index of .got2 or .opd in a relocatable object, if
1699 // such a section exists.
1701 template<int size
, bool big_endian
>
1703 Powerpc_relobj
<size
, big_endian
>::do_find_special_sections(
1704 Read_symbols_data
* sd
)
1706 const unsigned char* const pshdrs
= sd
->section_headers
->data();
1707 const unsigned char* namesu
= sd
->section_names
->data();
1708 const char* names
= reinterpret_cast<const char*>(namesu
);
1709 section_size_type names_size
= sd
->section_names_size
;
1710 const unsigned char* s
;
1712 s
= this->template find_shdr
<size
, big_endian
>(pshdrs
,
1713 size
== 32 ? ".got2" : ".opd",
1714 names
, names_size
, NULL
);
1717 unsigned int ndx
= (s
- pshdrs
) / elfcpp::Elf_sizes
<size
>::shdr_size
;
1718 this->special_
= ndx
;
1721 if (this->abiversion() == 0)
1722 this->set_abiversion(1);
1723 else if (this->abiversion() > 1)
1724 gold_error(_("%s: .opd invalid in abiv%d"),
1725 this->name().c_str(), this->abiversion());
1728 return Sized_relobj_file
<size
, big_endian
>::do_find_special_sections(sd
);
1731 // Examine .rela.opd to build info about function entry points.
1733 template<int size
, bool big_endian
>
1735 Powerpc_relobj
<size
, big_endian
>::scan_opd_relocs(
1737 const unsigned char* prelocs
,
1738 const unsigned char* plocal_syms
)
1742 typedef typename Reloc_types
<elfcpp::SHT_RELA
, size
, big_endian
>::Reloc
1744 const int reloc_size
1745 = Reloc_types
<elfcpp::SHT_RELA
, size
, big_endian
>::reloc_size
;
1746 const int sym_size
= elfcpp::Elf_sizes
<size
>::sym_size
;
1747 Address expected_off
= 0;
1748 bool regular
= true;
1749 unsigned int opd_ent_size
= 0;
1751 for (size_t i
= 0; i
< reloc_count
; ++i
, prelocs
+= reloc_size
)
1753 Reltype
reloc(prelocs
);
1754 typename
elfcpp::Elf_types
<size
>::Elf_WXword r_info
1755 = reloc
.get_r_info();
1756 unsigned int r_type
= elfcpp::elf_r_type
<size
>(r_info
);
1757 if (r_type
== elfcpp::R_PPC64_ADDR64
)
1759 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(r_info
);
1760 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
;
1763 if (r_sym
< this->local_symbol_count())
1765 typename
elfcpp::Sym
<size
, big_endian
>
1766 lsym(plocal_syms
+ r_sym
* sym_size
);
1767 shndx
= lsym
.get_st_shndx();
1768 shndx
= this->adjust_sym_shndx(r_sym
, shndx
, &is_ordinary
);
1769 value
= lsym
.get_st_value();
1772 shndx
= this->symbol_section_and_value(r_sym
, &value
,
1774 this->set_opd_ent(reloc
.get_r_offset(), shndx
,
1775 value
+ reloc
.get_r_addend());
1778 expected_off
= reloc
.get_r_offset();
1779 opd_ent_size
= expected_off
;
1781 else if (expected_off
!= reloc
.get_r_offset())
1783 expected_off
+= opd_ent_size
;
1785 else if (r_type
== elfcpp::R_PPC64_TOC
)
1787 if (expected_off
- opd_ent_size
+ 8 != reloc
.get_r_offset())
1792 gold_warning(_("%s: unexpected reloc type %u in .opd section"),
1793 this->name().c_str(), r_type
);
1797 if (reloc_count
<= 2)
1798 opd_ent_size
= this->section_size(this->opd_shndx());
1799 if (opd_ent_size
!= 24 && opd_ent_size
!= 16)
1803 gold_warning(_("%s: .opd is not a regular array of opd entries"),
1804 this->name().c_str());
1810 template<int size
, bool big_endian
>
1812 Powerpc_relobj
<size
, big_endian
>::do_read_relocs(Read_relocs_data
* rd
)
1814 Sized_relobj_file
<size
, big_endian
>::do_read_relocs(rd
);
1817 for (Read_relocs_data::Relocs_list::iterator p
= rd
->relocs
.begin();
1818 p
!= rd
->relocs
.end();
1821 if (p
->data_shndx
== this->opd_shndx())
1823 uint64_t opd_size
= this->section_size(this->opd_shndx());
1824 gold_assert(opd_size
== static_cast<size_t>(opd_size
));
1827 this->init_opd(opd_size
);
1828 this->scan_opd_relocs(p
->reloc_count
, p
->contents
->data(),
1829 rd
->local_symbols
->data());
1837 // Read the symbols then set up st_other vector.
1839 template<int size
, bool big_endian
>
1841 Powerpc_relobj
<size
, big_endian
>::do_read_symbols(Read_symbols_data
* sd
)
1843 this->base_read_symbols(sd
);
1846 const int shdr_size
= elfcpp::Elf_sizes
<size
>::shdr_size
;
1847 const unsigned char* const pshdrs
= sd
->section_headers
->data();
1848 const unsigned int loccount
= this->do_local_symbol_count();
1851 this->st_other_
.resize(loccount
);
1852 const int sym_size
= elfcpp::Elf_sizes
<size
>::sym_size
;
1853 off_t locsize
= loccount
* sym_size
;
1854 const unsigned int symtab_shndx
= this->symtab_shndx();
1855 const unsigned char *psymtab
= pshdrs
+ symtab_shndx
* shdr_size
;
1856 typename
elfcpp::Shdr
<size
, big_endian
> shdr(psymtab
);
1857 const unsigned char* psyms
= this->get_view(shdr
.get_sh_offset(),
1858 locsize
, true, false);
1860 for (unsigned int i
= 1; i
< loccount
; ++i
, psyms
+= sym_size
)
1862 elfcpp::Sym
<size
, big_endian
> sym(psyms
);
1863 unsigned char st_other
= sym
.get_st_other();
1864 this->st_other_
[i
] = st_other
;
1865 if ((st_other
& elfcpp::STO_PPC64_LOCAL_MASK
) != 0)
1867 if (this->abiversion() == 0)
1868 this->set_abiversion(2);
1869 else if (this->abiversion() < 2)
1870 gold_error(_("%s: local symbol %d has invalid st_other"
1871 " for ABI version 1"),
1872 this->name().c_str(), i
);
1879 template<int size
, bool big_endian
>
1881 Powerpc_dynobj
<size
, big_endian
>::set_abiversion(int ver
)
1883 this->e_flags_
|= ver
;
1884 if (this->abiversion() != 0)
1886 Target_powerpc
<size
, big_endian
>* target
=
1887 static_cast<Target_powerpc
<size
, big_endian
>*>(
1888 parameters
->sized_target
<size
, big_endian
>());
1889 if (target
->abiversion() == 0)
1890 target
->set_abiversion(this->abiversion());
1891 else if (target
->abiversion() != this->abiversion())
1892 gold_error(_("%s: ABI version %d is not compatible "
1893 "with ABI version %d output"),
1894 this->name().c_str(),
1895 this->abiversion(), target
->abiversion());
1900 // Call Sized_dynobj::base_read_symbols to read the symbols then
1901 // read .opd from a dynamic object, filling in opd_ent_ vector,
1903 template<int size
, bool big_endian
>
1905 Powerpc_dynobj
<size
, big_endian
>::do_read_symbols(Read_symbols_data
* sd
)
1907 this->base_read_symbols(sd
);
1910 const int shdr_size
= elfcpp::Elf_sizes
<size
>::shdr_size
;
1911 const unsigned char* const pshdrs
= sd
->section_headers
->data();
1912 const unsigned char* namesu
= sd
->section_names
->data();
1913 const char* names
= reinterpret_cast<const char*>(namesu
);
1914 const unsigned char* s
= NULL
;
1915 const unsigned char* opd
;
1916 section_size_type opd_size
;
1918 // Find and read .opd section.
1921 s
= this->template find_shdr
<size
, big_endian
>(pshdrs
, ".opd", names
,
1922 sd
->section_names_size
,
1927 typename
elfcpp::Shdr
<size
, big_endian
> shdr(s
);
1928 if (shdr
.get_sh_type() == elfcpp::SHT_PROGBITS
1929 && (shdr
.get_sh_flags() & elfcpp::SHF_ALLOC
) != 0)
1931 if (this->abiversion() == 0)
1932 this->set_abiversion(1);
1933 else if (this->abiversion() > 1)
1934 gold_error(_("%s: .opd invalid in abiv%d"),
1935 this->name().c_str(), this->abiversion());
1937 this->opd_shndx_
= (s
- pshdrs
) / shdr_size
;
1938 this->opd_address_
= shdr
.get_sh_addr();
1939 opd_size
= convert_to_section_size_type(shdr
.get_sh_size());
1940 opd
= this->get_view(shdr
.get_sh_offset(), opd_size
,
1946 // Build set of executable sections.
1947 // Using a set is probably overkill. There is likely to be only
1948 // a few executable sections, typically .init, .text and .fini,
1949 // and they are generally grouped together.
1950 typedef std::set
<Sec_info
> Exec_sections
;
1951 Exec_sections exec_sections
;
1953 for (unsigned int i
= 1; i
< this->shnum(); ++i
, s
+= shdr_size
)
1955 typename
elfcpp::Shdr
<size
, big_endian
> shdr(s
);
1956 if (shdr
.get_sh_type() == elfcpp::SHT_PROGBITS
1957 && ((shdr
.get_sh_flags()
1958 & (elfcpp::SHF_ALLOC
| elfcpp::SHF_EXECINSTR
))
1959 == (elfcpp::SHF_ALLOC
| elfcpp::SHF_EXECINSTR
))
1960 && shdr
.get_sh_size() != 0)
1962 exec_sections
.insert(Sec_info(shdr
.get_sh_addr(),
1963 shdr
.get_sh_size(), i
));
1966 if (exec_sections
.empty())
1969 // Look over the OPD entries. This is complicated by the fact
1970 // that some binaries will use two-word entries while others
1971 // will use the standard three-word entries. In most cases
1972 // the third word (the environment pointer for languages like
1973 // Pascal) is unused and will be zero. If the third word is
1974 // used it should not be pointing into executable sections,
1976 this->init_opd(opd_size
);
1977 for (const unsigned char* p
= opd
; p
< opd
+ opd_size
; p
+= 8)
1979 typedef typename
elfcpp::Swap
<64, big_endian
>::Valtype Valtype
;
1980 const Valtype
* valp
= reinterpret_cast<const Valtype
*>(p
);
1981 Valtype val
= elfcpp::Swap
<64, big_endian
>::readval(valp
);
1983 // Chances are that this is the third word of an OPD entry.
1985 typename
Exec_sections::const_iterator e
1986 = exec_sections
.upper_bound(Sec_info(val
, 0, 0));
1987 if (e
!= exec_sections
.begin())
1990 if (e
->start
<= val
&& val
< e
->start
+ e
->len
)
1992 // We have an address in an executable section.
1993 // VAL ought to be the function entry, set it up.
1994 this->set_opd_ent(p
- opd
, e
->shndx
, val
);
1995 // Skip second word of OPD entry, the TOC pointer.
1999 // If we didn't match any executable sections, we likely
2000 // have a non-zero third word in the OPD entry.
2005 // Set up some symbols.
2007 template<int size
, bool big_endian
>
2009 Target_powerpc
<size
, big_endian
>::do_define_standard_symbols(
2010 Symbol_table
* symtab
,
2015 // Define _GLOBAL_OFFSET_TABLE_ to ensure it isn't seen as
2016 // undefined when scanning relocs (and thus requires
2017 // non-relative dynamic relocs). The proper value will be
2019 Symbol
*gotsym
= symtab
->lookup("_GLOBAL_OFFSET_TABLE_", NULL
);
2020 if (gotsym
!= NULL
&& gotsym
->is_undefined())
2022 Target_powerpc
<size
, big_endian
>* target
=
2023 static_cast<Target_powerpc
<size
, big_endian
>*>(
2024 parameters
->sized_target
<size
, big_endian
>());
2025 Output_data_got_powerpc
<size
, big_endian
>* got
2026 = target
->got_section(symtab
, layout
);
2027 symtab
->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL
,
2028 Symbol_table::PREDEFINED
,
2032 elfcpp::STV_HIDDEN
, 0,
2036 // Define _SDA_BASE_ at the start of the .sdata section + 32768.
2037 Symbol
*sdasym
= symtab
->lookup("_SDA_BASE_", NULL
);
2038 if (sdasym
!= NULL
&& sdasym
->is_undefined())
2040 Output_data_space
* sdata
= new Output_data_space(4, "** sdata");
2042 = layout
->add_output_section_data(".sdata", 0,
2044 | elfcpp::SHF_WRITE
,
2045 sdata
, ORDER_SMALL_DATA
, false);
2046 symtab
->define_in_output_data("_SDA_BASE_", NULL
,
2047 Symbol_table::PREDEFINED
,
2048 os
, 32768, 0, elfcpp::STT_OBJECT
,
2049 elfcpp::STB_LOCAL
, elfcpp::STV_HIDDEN
,
2055 // Define .TOC. as for 32-bit _GLOBAL_OFFSET_TABLE_
2056 Symbol
*gotsym
= symtab
->lookup(".TOC.", NULL
);
2057 if (gotsym
!= NULL
&& gotsym
->is_undefined())
2059 Target_powerpc
<size
, big_endian
>* target
=
2060 static_cast<Target_powerpc
<size
, big_endian
>*>(
2061 parameters
->sized_target
<size
, big_endian
>());
2062 Output_data_got_powerpc
<size
, big_endian
>* got
2063 = target
->got_section(symtab
, layout
);
2064 symtab
->define_in_output_data(".TOC.", NULL
,
2065 Symbol_table::PREDEFINED
,
2069 elfcpp::STV_HIDDEN
, 0,
2075 // Set up PowerPC target specific relobj.
2077 template<int size
, bool big_endian
>
2079 Target_powerpc
<size
, big_endian
>::do_make_elf_object(
2080 const std::string
& name
,
2081 Input_file
* input_file
,
2082 off_t offset
, const elfcpp::Ehdr
<size
, big_endian
>& ehdr
)
2084 int et
= ehdr
.get_e_type();
2085 // ET_EXEC files are valid input for --just-symbols/-R,
2086 // and we treat them as relocatable objects.
2087 if (et
== elfcpp::ET_REL
2088 || (et
== elfcpp::ET_EXEC
&& input_file
->just_symbols()))
2090 Powerpc_relobj
<size
, big_endian
>* obj
=
2091 new Powerpc_relobj
<size
, big_endian
>(name
, input_file
, offset
, ehdr
);
2095 else if (et
== elfcpp::ET_DYN
)
2097 Powerpc_dynobj
<size
, big_endian
>* obj
=
2098 new Powerpc_dynobj
<size
, big_endian
>(name
, input_file
, offset
, ehdr
);
2104 gold_error(_("%s: unsupported ELF file type %d"), name
.c_str(), et
);
2109 template<int size
, bool big_endian
>
2110 class Output_data_got_powerpc
: public Output_data_got
<size
, big_endian
>
2113 typedef typename
elfcpp::Elf_types
<size
>::Elf_Addr Valtype
;
2114 typedef Output_data_reloc
<elfcpp::SHT_RELA
, true, size
, big_endian
> Rela_dyn
;
2116 Output_data_got_powerpc(Symbol_table
* symtab
, Layout
* layout
)
2117 : Output_data_got
<size
, big_endian
>(),
2118 symtab_(symtab
), layout_(layout
),
2119 header_ent_cnt_(size
== 32 ? 3 : 1),
2120 header_index_(size
== 32 ? 0x2000 : 0)
2123 // Override all the Output_data_got methods we use so as to first call
2126 add_global(Symbol
* gsym
, unsigned int got_type
)
2128 this->reserve_ent();
2129 return Output_data_got
<size
, big_endian
>::add_global(gsym
, got_type
);
2133 add_global_plt(Symbol
* gsym
, unsigned int got_type
)
2135 this->reserve_ent();
2136 return Output_data_got
<size
, big_endian
>::add_global_plt(gsym
, got_type
);
2140 add_global_tls(Symbol
* gsym
, unsigned int got_type
)
2141 { return this->add_global_plt(gsym
, got_type
); }
2144 add_global_with_rel(Symbol
* gsym
, unsigned int got_type
,
2145 Output_data_reloc_generic
* rel_dyn
, unsigned int r_type
)
2147 this->reserve_ent();
2148 Output_data_got
<size
, big_endian
>::
2149 add_global_with_rel(gsym
, got_type
, rel_dyn
, r_type
);
2153 add_global_pair_with_rel(Symbol
* gsym
, unsigned int got_type
,
2154 Output_data_reloc_generic
* rel_dyn
,
2155 unsigned int r_type_1
, unsigned int r_type_2
)
2157 this->reserve_ent(2);
2158 Output_data_got
<size
, big_endian
>::
2159 add_global_pair_with_rel(gsym
, got_type
, rel_dyn
, r_type_1
, r_type_2
);
2163 add_local(Relobj
* object
, unsigned int sym_index
, unsigned int got_type
)
2165 this->reserve_ent();
2166 return Output_data_got
<size
, big_endian
>::add_local(object
, sym_index
,
2171 add_local_plt(Relobj
* object
, unsigned int sym_index
, unsigned int got_type
)
2173 this->reserve_ent();
2174 return Output_data_got
<size
, big_endian
>::add_local_plt(object
, sym_index
,
2179 add_local_tls(Relobj
* object
, unsigned int sym_index
, unsigned int got_type
)
2180 { return this->add_local_plt(object
, sym_index
, got_type
); }
2183 add_local_tls_pair(Relobj
* object
, unsigned int sym_index
,
2184 unsigned int got_type
,
2185 Output_data_reloc_generic
* rel_dyn
,
2186 unsigned int r_type
)
2188 this->reserve_ent(2);
2189 Output_data_got
<size
, big_endian
>::
2190 add_local_tls_pair(object
, sym_index
, got_type
, rel_dyn
, r_type
);
2194 add_constant(Valtype constant
)
2196 this->reserve_ent();
2197 return Output_data_got
<size
, big_endian
>::add_constant(constant
);
2201 add_constant_pair(Valtype c1
, Valtype c2
)
2203 this->reserve_ent(2);
2204 return Output_data_got
<size
, big_endian
>::add_constant_pair(c1
, c2
);
2207 // Offset of _GLOBAL_OFFSET_TABLE_.
2211 return this->got_offset(this->header_index_
);
2214 // Offset of base used to access the GOT/TOC.
2215 // The got/toc pointer reg will be set to this value.
2217 got_base_offset(const Powerpc_relobj
<size
, big_endian
>* object
) const
2220 return this->g_o_t();
2222 return (this->output_section()->address()
2223 + object
->toc_base_offset()
2227 // Ensure our GOT has a header.
2229 set_final_data_size()
2231 if (this->header_ent_cnt_
!= 0)
2232 this->make_header();
2233 Output_data_got
<size
, big_endian
>::set_final_data_size();
2236 // First word of GOT header needs some values that are not
2237 // handled by Output_data_got so poke them in here.
2238 // For 32-bit, address of .dynamic, for 64-bit, address of TOCbase.
2240 do_write(Output_file
* of
)
2243 if (size
== 32 && this->layout_
->dynamic_data() != NULL
)
2244 val
= this->layout_
->dynamic_section()->address();
2246 val
= this->output_section()->address() + 0x8000;
2247 this->replace_constant(this->header_index_
, val
);
2248 Output_data_got
<size
, big_endian
>::do_write(of
);
2253 reserve_ent(unsigned int cnt
= 1)
2255 if (this->header_ent_cnt_
== 0)
2257 if (this->num_entries() + cnt
> this->header_index_
)
2258 this->make_header();
2264 this->header_ent_cnt_
= 0;
2265 this->header_index_
= this->num_entries();
2268 Output_data_got
<size
, big_endian
>::add_constant(0);
2269 Output_data_got
<size
, big_endian
>::add_constant(0);
2270 Output_data_got
<size
, big_endian
>::add_constant(0);
2272 // Define _GLOBAL_OFFSET_TABLE_ at the header
2273 Symbol
*gotsym
= this->symtab_
->lookup("_GLOBAL_OFFSET_TABLE_", NULL
);
2276 Sized_symbol
<size
>* sym
= static_cast<Sized_symbol
<size
>*>(gotsym
);
2277 sym
->set_value(this->g_o_t());
2280 this->symtab_
->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL
,
2281 Symbol_table::PREDEFINED
,
2282 this, this->g_o_t(), 0,
2285 elfcpp::STV_HIDDEN
, 0,
2289 Output_data_got
<size
, big_endian
>::add_constant(0);
2292 // Stashed pointers.
2293 Symbol_table
* symtab_
;
2297 unsigned int header_ent_cnt_
;
2298 // GOT header index.
2299 unsigned int header_index_
;
2302 // Get the GOT section, creating it if necessary.
2304 template<int size
, bool big_endian
>
2305 Output_data_got_powerpc
<size
, big_endian
>*
2306 Target_powerpc
<size
, big_endian
>::got_section(Symbol_table
* symtab
,
2309 if (this->got_
== NULL
)
2311 gold_assert(symtab
!= NULL
&& layout
!= NULL
);
2314 = new Output_data_got_powerpc
<size
, big_endian
>(symtab
, layout
);
2316 layout
->add_output_section_data(".got", elfcpp::SHT_PROGBITS
,
2317 elfcpp::SHF_ALLOC
| elfcpp::SHF_WRITE
,
2318 this->got_
, ORDER_DATA
, false);
2324 // Get the dynamic reloc section, creating it if necessary.
2326 template<int size
, bool big_endian
>
2327 typename Target_powerpc
<size
, big_endian
>::Reloc_section
*
2328 Target_powerpc
<size
, big_endian
>::rela_dyn_section(Layout
* layout
)
2330 if (this->rela_dyn_
== NULL
)
2332 gold_assert(layout
!= NULL
);
2333 this->rela_dyn_
= new Reloc_section(parameters
->options().combreloc());
2334 layout
->add_output_section_data(".rela.dyn", elfcpp::SHT_RELA
,
2335 elfcpp::SHF_ALLOC
, this->rela_dyn_
,
2336 ORDER_DYNAMIC_RELOCS
, false);
2338 return this->rela_dyn_
;
2341 // Similarly, but for ifunc symbols get the one for ifunc.
2343 template<int size
, bool big_endian
>
2344 typename Target_powerpc
<size
, big_endian
>::Reloc_section
*
2345 Target_powerpc
<size
, big_endian
>::rela_dyn_section(Symbol_table
* symtab
,
2350 return this->rela_dyn_section(layout
);
2352 if (this->iplt_
== NULL
)
2353 this->make_iplt_section(symtab
, layout
);
2354 return this->iplt_
->rel_plt();
2360 // Determine the stub group size. The group size is the absolute
2361 // value of the parameter --stub-group-size. If --stub-group-size
2362 // is passed a negative value, we restrict stubs to be always before
2363 // the stubbed branches.
2364 Stub_control(int32_t size
)
2365 : state_(NO_GROUP
), stub_group_size_(abs(size
)),
2366 stub14_group_size_(abs(size
) >> 10),
2367 stubs_always_before_branch_(size
< 0), suppress_size_errors_(false),
2368 group_end_addr_(0), owner_(NULL
), output_section_(NULL
)
2370 if (stub_group_size_
== 1)
2373 if (stubs_always_before_branch_
)
2375 stub_group_size_
= 0x1e00000;
2376 stub14_group_size_
= 0x7800;
2380 stub_group_size_
= 0x1c00000;
2381 stub14_group_size_
= 0x7000;
2383 suppress_size_errors_
= true;
2387 // Return true iff input section can be handled by current stub
2390 can_add_to_stub_group(Output_section
* o
,
2391 const Output_section::Input_section
* i
,
2394 const Output_section::Input_section
*
2400 { return output_section_
; }
2406 FINDING_STUB_SECTION
,
2411 uint32_t stub_group_size_
;
2412 uint32_t stub14_group_size_
;
2413 bool stubs_always_before_branch_
;
2414 bool suppress_size_errors_
;
2415 uint64_t group_end_addr_
;
2416 const Output_section::Input_section
* owner_
;
2417 Output_section
* output_section_
;
2420 // Return true iff input section can be handled by current stub
2424 Stub_control::can_add_to_stub_group(Output_section
* o
,
2425 const Output_section::Input_section
* i
,
2429 = has14
? this->stub14_group_size_
: this->stub_group_size_
;
2430 bool whole_sec
= o
->order() == ORDER_INIT
|| o
->order() == ORDER_FINI
;
2432 uint64_t start_addr
= o
->address();
2435 // .init and .fini sections are pasted together to form a single
2436 // function. We can't be adding stubs in the middle of the function.
2437 this_size
= o
->data_size();
2440 start_addr
+= i
->relobj()->output_section_offset(i
->shndx());
2441 this_size
= i
->data_size();
2443 uint64_t end_addr
= start_addr
+ this_size
;
2444 bool toobig
= this_size
> group_size
;
2446 if (toobig
&& !this->suppress_size_errors_
)
2447 gold_warning(_("%s:%s exceeds group size"),
2448 i
->relobj()->name().c_str(),
2449 i
->relobj()->section_name(i
->shndx()).c_str());
2451 if (this->state_
!= HAS_STUB_SECTION
2452 && (!whole_sec
|| this->output_section_
!= o
)
2453 && (this->state_
== NO_GROUP
2454 || this->group_end_addr_
- end_addr
< group_size
))
2457 this->output_section_
= o
;
2460 if (this->state_
== NO_GROUP
)
2462 this->state_
= FINDING_STUB_SECTION
;
2463 this->group_end_addr_
= end_addr
;
2465 else if (this->group_end_addr_
- start_addr
< group_size
)
2467 // Adding this section would make the group larger than GROUP_SIZE.
2468 else if (this->state_
== FINDING_STUB_SECTION
2469 && !this->stubs_always_before_branch_
2472 // But wait, there's more! Input sections up to GROUP_SIZE
2473 // bytes before the stub table can be handled by it too.
2474 this->state_
= HAS_STUB_SECTION
;
2475 this->group_end_addr_
= end_addr
;
2479 this->state_
= NO_GROUP
;
2485 // Look over all the input sections, deciding where to place stubs.
2487 template<int size
, bool big_endian
>
2489 Target_powerpc
<size
, big_endian
>::group_sections(Layout
* layout
,
2492 Stub_control
stub_control(parameters
->options().stub_group_size());
2494 // Group input sections and insert stub table
2495 Stub_table
<size
, big_endian
>* stub_table
= NULL
;
2496 Layout::Section_list section_list
;
2497 layout
->get_executable_sections(§ion_list
);
2498 std::stable_sort(section_list
.begin(), section_list
.end(), Sort_sections());
2499 for (Layout::Section_list::reverse_iterator o
= section_list
.rbegin();
2500 o
!= section_list
.rend();
2503 typedef Output_section::Input_section_list Input_section_list
;
2504 for (Input_section_list::const_reverse_iterator i
2505 = (*o
)->input_sections().rbegin();
2506 i
!= (*o
)->input_sections().rend();
2509 if (i
->is_input_section())
2511 Powerpc_relobj
<size
, big_endian
>* ppcobj
= static_cast
2512 <Powerpc_relobj
<size
, big_endian
>*>(i
->relobj());
2513 bool has14
= ppcobj
->has_14bit_branch(i
->shndx());
2514 if (!stub_control
.can_add_to_stub_group(*o
, &*i
, has14
))
2516 stub_table
->init(stub_control
.owner(),
2517 stub_control
.output_section());
2520 if (stub_table
== NULL
)
2521 stub_table
= this->new_stub_table();
2522 ppcobj
->set_stub_table(i
->shndx(), stub_table
);
2526 if (stub_table
!= NULL
)
2528 const Output_section::Input_section
* i
= stub_control
.owner();
2529 if (!i
->is_input_section())
2531 // Corner case. A new stub group was made for the first
2532 // section (last one looked at here) for some reason, but
2533 // the first section is already being used as the owner for
2534 // a stub table for following sections. Force it into that
2536 gold_assert(this->stub_tables_
.size() >= 2);
2537 this->stub_tables_
.pop_back();
2539 Powerpc_relobj
<size
, big_endian
>* ppcobj
= static_cast
2540 <Powerpc_relobj
<size
, big_endian
>*>(i
->relobj());
2541 ppcobj
->set_stub_table(i
->shndx(), this->stub_tables_
.back());
2544 stub_table
->init(i
, stub_control
.output_section());
2548 // If this branch needs a plt call stub, or a long branch stub, make one.
2550 template<int size
, bool big_endian
>
2552 Target_powerpc
<size
, big_endian
>::Branch_info::make_stub(
2553 Stub_table
<size
, big_endian
>* stub_table
,
2554 Stub_table
<size
, big_endian
>* ifunc_stub_table
,
2555 Symbol_table
* symtab
) const
2557 Symbol
* sym
= this->object_
->global_symbol(this->r_sym_
);
2558 if (sym
!= NULL
&& sym
->is_forwarder())
2559 sym
= symtab
->resolve_forwards(sym
);
2560 const Sized_symbol
<size
>* gsym
= static_cast<const Sized_symbol
<size
>*>(sym
);
2561 Target_powerpc
<size
, big_endian
>* target
=
2562 static_cast<Target_powerpc
<size
, big_endian
>*>(
2563 parameters
->sized_target
<size
, big_endian
>());
2565 ? gsym
->use_plt_offset(Scan::get_reference_flags(this->r_type_
, target
))
2566 : this->object_
->local_has_plt_offset(this->r_sym_
))
2570 && target
->abiversion() >= 2
2571 && !parameters
->options().output_is_position_independent()
2572 && !is_branch_reloc(this->r_type_
))
2573 target
->glink_section()->add_global_entry(gsym
);
2576 if (stub_table
== NULL
)
2577 stub_table
= this->object_
->stub_table(this->shndx_
);
2578 if (stub_table
== NULL
)
2580 // This is a ref from a data section to an ifunc symbol.
2581 stub_table
= ifunc_stub_table
;
2583 gold_assert(stub_table
!= NULL
);
2585 stub_table
->add_plt_call_entry(this->object_
, gsym
,
2586 this->r_type_
, this->addend_
);
2588 stub_table
->add_plt_call_entry(this->object_
, this->r_sym_
,
2589 this->r_type_
, this->addend_
);
2594 unsigned long max_branch_offset
;
2595 if (this->r_type_
== elfcpp::R_POWERPC_REL14
2596 || this->r_type_
== elfcpp::R_POWERPC_REL14_BRTAKEN
2597 || this->r_type_
== elfcpp::R_POWERPC_REL14_BRNTAKEN
)
2598 max_branch_offset
= 1 << 15;
2599 else if (this->r_type_
== elfcpp::R_POWERPC_REL24
2600 || this->r_type_
== elfcpp::R_PPC_PLTREL24
2601 || this->r_type_
== elfcpp::R_PPC_LOCAL24PC
)
2602 max_branch_offset
= 1 << 25;
2605 Address from
= this->object_
->get_output_section_offset(this->shndx_
);
2606 gold_assert(from
!= invalid_address
);
2607 from
+= (this->object_
->output_section(this->shndx_
)->address()
2612 switch (gsym
->source())
2614 case Symbol::FROM_OBJECT
:
2616 Object
* symobj
= gsym
->object();
2617 if (symobj
->is_dynamic()
2618 || symobj
->pluginobj() != NULL
)
2621 unsigned int shndx
= gsym
->shndx(&is_ordinary
);
2622 if (shndx
== elfcpp::SHN_UNDEF
)
2627 case Symbol::IS_UNDEFINED
:
2633 Symbol_table::Compute_final_value_status status
;
2634 to
= symtab
->compute_final_value
<size
>(gsym
, &status
);
2635 if (status
!= Symbol_table::CFVS_OK
)
2638 to
+= this->object_
->ppc64_local_entry_offset(gsym
);
2642 const Symbol_value
<size
>* psymval
2643 = this->object_
->local_symbol(this->r_sym_
);
2644 Symbol_value
<size
> symval
;
2645 typedef Sized_relobj_file
<size
, big_endian
> ObjType
;
2646 typename
ObjType::Compute_final_local_value_status status
2647 = this->object_
->compute_final_local_value(this->r_sym_
, psymval
,
2649 if (status
!= ObjType::CFLV_OK
2650 || !symval
.has_output_value())
2652 to
= symval
.value(this->object_
, 0);
2654 to
+= this->object_
->ppc64_local_entry_offset(this->r_sym_
);
2656 to
+= this->addend_
;
2657 if (stub_table
== NULL
)
2658 stub_table
= this->object_
->stub_table(this->shndx_
);
2659 if (size
== 64 && target
->abiversion() < 2)
2661 unsigned int dest_shndx
;
2662 to
= target
->symval_for_branch(symtab
, to
, gsym
,
2663 this->object_
, &dest_shndx
);
2665 Address delta
= to
- from
;
2666 if (delta
+ max_branch_offset
>= 2 * max_branch_offset
)
2668 if (stub_table
== NULL
)
2670 gold_warning(_("%s:%s: branch in non-executable section,"
2671 " no long branch stub for you"),
2672 this->object_
->name().c_str(),
2673 this->object_
->section_name(this->shndx_
).c_str());
2676 stub_table
->add_long_branch_entry(this->object_
, to
);
2681 // Relaxation hook. This is where we do stub generation.
2683 template<int size
, bool big_endian
>
2685 Target_powerpc
<size
, big_endian
>::do_relax(int pass
,
2686 const Input_objects
*,
2687 Symbol_table
* symtab
,
2691 unsigned int prev_brlt_size
= 0;
2695 = this->abiversion() < 2 && parameters
->options().plt_thread_safe();
2697 && this->abiversion() < 2
2699 && !parameters
->options().user_set_plt_thread_safe())
2701 static const char* const thread_starter
[] =
2705 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
2707 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
2708 "mq_notify", "create_timer",
2713 "GOMP_parallel_start",
2714 "GOMP_parallel_loop_static",
2715 "GOMP_parallel_loop_static_start",
2716 "GOMP_parallel_loop_dynamic",
2717 "GOMP_parallel_loop_dynamic_start",
2718 "GOMP_parallel_loop_guided",
2719 "GOMP_parallel_loop_guided_start",
2720 "GOMP_parallel_loop_runtime",
2721 "GOMP_parallel_loop_runtime_start",
2722 "GOMP_parallel_sections",
2723 "GOMP_parallel_sections_start",
2728 if (parameters
->options().shared())
2732 for (unsigned int i
= 0;
2733 i
< sizeof(thread_starter
) / sizeof(thread_starter
[0]);
2736 Symbol
* sym
= symtab
->lookup(thread_starter
[i
], NULL
);
2737 thread_safe
= (sym
!= NULL
2739 && sym
->in_real_elf());
2745 this->plt_thread_safe_
= thread_safe
;
2746 this->group_sections(layout
, task
);
2749 // We need address of stub tables valid for make_stub.
2750 for (typename
Stub_tables::iterator p
= this->stub_tables_
.begin();
2751 p
!= this->stub_tables_
.end();
2754 const Powerpc_relobj
<size
, big_endian
>* object
2755 = static_cast<const Powerpc_relobj
<size
, big_endian
>*>((*p
)->relobj());
2756 Address off
= object
->get_output_section_offset((*p
)->shndx());
2757 gold_assert(off
!= invalid_address
);
2758 Output_section
* os
= (*p
)->output_section();
2759 (*p
)->set_address_and_size(os
, off
);
2764 // Clear plt call stubs, long branch stubs and branch lookup table.
2765 prev_brlt_size
= this->branch_lookup_table_
.size();
2766 this->branch_lookup_table_
.clear();
2767 for (typename
Stub_tables::iterator p
= this->stub_tables_
.begin();
2768 p
!= this->stub_tables_
.end();
2771 (*p
)->clear_stubs();
2775 // Build all the stubs.
2776 Stub_table
<size
, big_endian
>* ifunc_stub_table
2777 = this->stub_tables_
.size() == 0 ? NULL
: this->stub_tables_
[0];
2778 Stub_table
<size
, big_endian
>* one_stub_table
2779 = this->stub_tables_
.size() != 1 ? NULL
: ifunc_stub_table
;
2780 for (typename
Branches::const_iterator b
= this->branch_info_
.begin();
2781 b
!= this->branch_info_
.end();
2784 b
->make_stub(one_stub_table
, ifunc_stub_table
, symtab
);
2787 // Did anything change size?
2788 unsigned int num_huge_branches
= this->branch_lookup_table_
.size();
2789 bool again
= num_huge_branches
!= prev_brlt_size
;
2790 if (size
== 64 && num_huge_branches
!= 0)
2791 this->make_brlt_section(layout
);
2792 if (size
== 64 && again
)
2793 this->brlt_section_
->set_current_size(num_huge_branches
);
2795 typedef Unordered_set
<Output_section
*> Output_sections
;
2796 Output_sections os_need_update
;
2797 for (typename
Stub_tables::iterator p
= this->stub_tables_
.begin();
2798 p
!= this->stub_tables_
.end();
2801 if ((*p
)->size_update())
2804 (*p
)->add_eh_frame(layout
);
2805 os_need_update
.insert((*p
)->output_section());
2809 // Set output section offsets for all input sections in an output
2810 // section that just changed size. Anything past the stubs will
2812 for (typename
Output_sections::iterator p
= os_need_update
.begin();
2813 p
!= os_need_update
.end();
2816 Output_section
* os
= *p
;
2818 typedef Output_section::Input_section_list Input_section_list
;
2819 for (Input_section_list::const_iterator i
= os
->input_sections().begin();
2820 i
!= os
->input_sections().end();
2823 off
= align_address(off
, i
->addralign());
2824 if (i
->is_input_section() || i
->is_relaxed_input_section())
2825 i
->relobj()->set_section_offset(i
->shndx(), off
);
2826 if (i
->is_relaxed_input_section())
2828 Stub_table
<size
, big_endian
>* stub_table
2829 = static_cast<Stub_table
<size
, big_endian
>*>(
2830 i
->relaxed_input_section());
2831 off
+= stub_table
->set_address_and_size(os
, off
);
2834 off
+= i
->data_size();
2836 // If .branch_lt is part of this output section, then we have
2837 // just done the offset adjustment.
2838 os
->clear_section_offsets_need_adjustment();
2843 && num_huge_branches
!= 0
2844 && parameters
->options().output_is_position_independent())
2846 // Fill in the BRLT relocs.
2847 this->brlt_section_
->reset_brlt_sizes();
2848 for (typename
Branch_lookup_table::const_iterator p
2849 = this->branch_lookup_table_
.begin();
2850 p
!= this->branch_lookup_table_
.end();
2853 this->brlt_section_
->add_reloc(p
->first
, p
->second
);
2855 this->brlt_section_
->finalize_brlt_sizes();
2860 template<int size
, bool big_endian
>
2862 Target_powerpc
<size
, big_endian
>::do_plt_fde_location(const Output_data
* plt
,
2863 unsigned char* oview
,
2867 uint64_t address
= plt
->address();
2868 off_t len
= plt
->data_size();
2870 if (plt
== this->glink_
)
2872 // See Output_data_glink::do_write() for glink contents.
2875 gold_assert(parameters
->doing_static_link());
2876 // Static linking may need stubs, to support ifunc and long
2877 // branches. We need to create an output section for
2878 // .eh_frame early in the link process, to have a place to
2879 // attach stub .eh_frame info. We also need to have
2880 // registered a CIE that matches the stub CIE. Both of
2881 // these requirements are satisfied by creating an FDE and
2882 // CIE for .glink, even though static linking will leave
2883 // .glink zero length.
2884 // ??? Hopefully generating an FDE with a zero address range
2885 // won't confuse anything that consumes .eh_frame info.
2887 else if (size
== 64)
2889 // There is one word before __glink_PLTresolve
2893 else if (parameters
->options().output_is_position_independent())
2895 // There are two FDEs for a position independent glink.
2896 // The first covers the branch table, the second
2897 // __glink_PLTresolve at the end of glink.
2898 off_t resolve_size
= this->glink_
->pltresolve_size
;
2899 if (oview
[9] == elfcpp::DW_CFA_nop
)
2900 len
-= resolve_size
;
2903 address
+= len
- resolve_size
;
2910 // Must be a stub table.
2911 const Stub_table
<size
, big_endian
>* stub_table
2912 = static_cast<const Stub_table
<size
, big_endian
>*>(plt
);
2913 uint64_t stub_address
= stub_table
->stub_address();
2914 len
-= stub_address
- address
;
2915 address
= stub_address
;
2918 *paddress
= address
;
2922 // A class to handle the PLT data.
2924 template<int size
, bool big_endian
>
2925 class Output_data_plt_powerpc
: public Output_section_data_build
2928 typedef Output_data_reloc
<elfcpp::SHT_RELA
, true,
2929 size
, big_endian
> Reloc_section
;
2931 Output_data_plt_powerpc(Target_powerpc
<size
, big_endian
>* targ
,
2932 Reloc_section
* plt_rel
,
2934 : Output_section_data_build(size
== 32 ? 4 : 8),
2940 // Add an entry to the PLT.
2945 add_ifunc_entry(Symbol
*);
2948 add_local_ifunc_entry(Sized_relobj_file
<size
, big_endian
>*, unsigned int);
2950 // Return the .rela.plt section data.
2957 // Return the number of PLT entries.
2961 if (this->current_data_size() == 0)
2963 return ((this->current_data_size() - this->first_plt_entry_offset())
2964 / this->plt_entry_size());
2969 do_adjust_output_section(Output_section
* os
)
2974 // Write to a map file.
2976 do_print_to_mapfile(Mapfile
* mapfile
) const
2977 { mapfile
->print_output_data(this, this->name_
); }
2980 // Return the offset of the first non-reserved PLT entry.
2982 first_plt_entry_offset() const
2984 // IPLT has no reserved entry.
2985 if (this->name_
[3] == 'I')
2987 return this->targ_
->first_plt_entry_offset();
2990 // Return the size of each PLT entry.
2992 plt_entry_size() const
2994 return this->targ_
->plt_entry_size();
2997 // Write out the PLT data.
2999 do_write(Output_file
*);
3001 // The reloc section.
3002 Reloc_section
* rel_
;
3003 // Allows access to .glink for do_write.
3004 Target_powerpc
<size
, big_endian
>* targ_
;
3005 // What to report in map file.
3009 // Add an entry to the PLT.
3011 template<int size
, bool big_endian
>
3013 Output_data_plt_powerpc
<size
, big_endian
>::add_entry(Symbol
* gsym
)
3015 if (!gsym
->has_plt_offset())
3017 section_size_type off
= this->current_data_size();
3019 off
+= this->first_plt_entry_offset();
3020 gsym
->set_plt_offset(off
);
3021 gsym
->set_needs_dynsym_entry();
3022 unsigned int dynrel
= elfcpp::R_POWERPC_JMP_SLOT
;
3023 this->rel_
->add_global(gsym
, dynrel
, this, off
, 0);
3024 off
+= this->plt_entry_size();
3025 this->set_current_data_size(off
);
3029 // Add an entry for a global ifunc symbol that resolves locally, to the IPLT.
3031 template<int size
, bool big_endian
>
3033 Output_data_plt_powerpc
<size
, big_endian
>::add_ifunc_entry(Symbol
* gsym
)
3035 if (!gsym
->has_plt_offset())
3037 section_size_type off
= this->current_data_size();
3038 gsym
->set_plt_offset(off
);
3039 unsigned int dynrel
= elfcpp::R_POWERPC_IRELATIVE
;
3040 if (size
== 64 && this->targ_
->abiversion() < 2)
3041 dynrel
= elfcpp::R_PPC64_JMP_IREL
;
3042 this->rel_
->add_symbolless_global_addend(gsym
, dynrel
, this, off
, 0);
3043 off
+= this->plt_entry_size();
3044 this->set_current_data_size(off
);
3048 // Add an entry for a local ifunc symbol to the IPLT.
3050 template<int size
, bool big_endian
>
3052 Output_data_plt_powerpc
<size
, big_endian
>::add_local_ifunc_entry(
3053 Sized_relobj_file
<size
, big_endian
>* relobj
,
3054 unsigned int local_sym_index
)
3056 if (!relobj
->local_has_plt_offset(local_sym_index
))
3058 section_size_type off
= this->current_data_size();
3059 relobj
->set_local_plt_offset(local_sym_index
, off
);
3060 unsigned int dynrel
= elfcpp::R_POWERPC_IRELATIVE
;
3061 if (size
== 64 && this->targ_
->abiversion() < 2)
3062 dynrel
= elfcpp::R_PPC64_JMP_IREL
;
3063 this->rel_
->add_symbolless_local_addend(relobj
, local_sym_index
, dynrel
,
3065 off
+= this->plt_entry_size();
3066 this->set_current_data_size(off
);
3070 static const uint32_t add_0_11_11
= 0x7c0b5a14;
3071 static const uint32_t add_2_2_11
= 0x7c425a14;
3072 static const uint32_t add_3_3_2
= 0x7c631214;
3073 static const uint32_t add_3_3_13
= 0x7c636a14;
3074 static const uint32_t add_11_0_11
= 0x7d605a14;
3075 static const uint32_t add_11_2_11
= 0x7d625a14;
3076 static const uint32_t add_11_11_2
= 0x7d6b1214;
3077 static const uint32_t addi_0_12
= 0x380c0000;
3078 static const uint32_t addi_2_2
= 0x38420000;
3079 static const uint32_t addi_3_3
= 0x38630000;
3080 static const uint32_t addi_11_11
= 0x396b0000;
3081 static const uint32_t addi_12_12
= 0x398c0000;
3082 static const uint32_t addis_0_2
= 0x3c020000;
3083 static const uint32_t addis_0_13
= 0x3c0d0000;
3084 static const uint32_t addis_3_2
= 0x3c620000;
3085 static const uint32_t addis_3_13
= 0x3c6d0000;
3086 static const uint32_t addis_11_2
= 0x3d620000;
3087 static const uint32_t addis_11_11
= 0x3d6b0000;
3088 static const uint32_t addis_11_30
= 0x3d7e0000;
3089 static const uint32_t addis_12_2
= 0x3d820000;
3090 static const uint32_t addis_12_12
= 0x3d8c0000;
3091 static const uint32_t b
= 0x48000000;
3092 static const uint32_t bcl_20_31
= 0x429f0005;
3093 static const uint32_t bctr
= 0x4e800420;
3094 static const uint32_t blr
= 0x4e800020;
3095 static const uint32_t bnectr_p4
= 0x4ce20420;
3096 static const uint32_t cmpldi_2_0
= 0x28220000;
3097 static const uint32_t cror_15_15_15
= 0x4def7b82;
3098 static const uint32_t cror_31_31_31
= 0x4ffffb82;
3099 static const uint32_t ld_0_1
= 0xe8010000;
3100 static const uint32_t ld_0_12
= 0xe80c0000;
3101 static const uint32_t ld_2_1
= 0xe8410000;
3102 static const uint32_t ld_2_2
= 0xe8420000;
3103 static const uint32_t ld_2_11
= 0xe84b0000;
3104 static const uint32_t ld_11_2
= 0xe9620000;
3105 static const uint32_t ld_11_11
= 0xe96b0000;
3106 static const uint32_t ld_12_2
= 0xe9820000;
3107 static const uint32_t ld_12_11
= 0xe98b0000;
3108 static const uint32_t ld_12_12
= 0xe98c0000;
3109 static const uint32_t lfd_0_1
= 0xc8010000;
3110 static const uint32_t li_0_0
= 0x38000000;
3111 static const uint32_t li_12_0
= 0x39800000;
3112 static const uint32_t lis_0_0
= 0x3c000000;
3113 static const uint32_t lis_11
= 0x3d600000;
3114 static const uint32_t lis_12
= 0x3d800000;
3115 static const uint32_t lvx_0_12_0
= 0x7c0c00ce;
3116 static const uint32_t lwz_0_12
= 0x800c0000;
3117 static const uint32_t lwz_11_11
= 0x816b0000;
3118 static const uint32_t lwz_11_30
= 0x817e0000;
3119 static const uint32_t lwz_12_12
= 0x818c0000;
3120 static const uint32_t lwzu_0_12
= 0x840c0000;
3121 static const uint32_t mflr_0
= 0x7c0802a6;
3122 static const uint32_t mflr_11
= 0x7d6802a6;
3123 static const uint32_t mflr_12
= 0x7d8802a6;
3124 static const uint32_t mtctr_0
= 0x7c0903a6;
3125 static const uint32_t mtctr_11
= 0x7d6903a6;
3126 static const uint32_t mtctr_12
= 0x7d8903a6;
3127 static const uint32_t mtlr_0
= 0x7c0803a6;
3128 static const uint32_t mtlr_12
= 0x7d8803a6;
3129 static const uint32_t nop
= 0x60000000;
3130 static const uint32_t ori_0_0_0
= 0x60000000;
3131 static const uint32_t srdi_0_0_2
= 0x7800f082;
3132 static const uint32_t std_0_1
= 0xf8010000;
3133 static const uint32_t std_0_12
= 0xf80c0000;
3134 static const uint32_t std_2_1
= 0xf8410000;
3135 static const uint32_t stfd_0_1
= 0xd8010000;
3136 static const uint32_t stvx_0_12_0
= 0x7c0c01ce;
3137 static const uint32_t sub_11_11_12
= 0x7d6c5850;
3138 static const uint32_t sub_12_12_11
= 0x7d8b6050;
3139 static const uint32_t xor_2_12_12
= 0x7d826278;
3140 static const uint32_t xor_11_12_12
= 0x7d8b6278;
3142 // Write out the PLT.
3144 template<int size
, bool big_endian
>
3146 Output_data_plt_powerpc
<size
, big_endian
>::do_write(Output_file
* of
)
3148 if (size
== 32 && this->name_
[3] != 'I')
3150 const section_size_type offset
= this->offset();
3151 const section_size_type oview_size
3152 = convert_to_section_size_type(this->data_size());
3153 unsigned char* const oview
= of
->get_output_view(offset
, oview_size
);
3154 unsigned char* pov
= oview
;
3155 unsigned char* endpov
= oview
+ oview_size
;
3157 // The address of the .glink branch table
3158 const Output_data_glink
<size
, big_endian
>* glink
3159 = this->targ_
->glink_section();
3160 elfcpp::Elf_types
<32>::Elf_Addr branch_tab
= glink
->address();
3162 while (pov
< endpov
)
3164 elfcpp::Swap
<32, big_endian
>::writeval(pov
, branch_tab
);
3169 of
->write_output_view(offset
, oview_size
, oview
);
3173 // Create the PLT section.
3175 template<int size
, bool big_endian
>
3177 Target_powerpc
<size
, big_endian
>::make_plt_section(Symbol_table
* symtab
,
3180 if (this->plt_
== NULL
)
3182 if (this->got_
== NULL
)
3183 this->got_section(symtab
, layout
);
3185 if (this->glink_
== NULL
)
3186 make_glink_section(layout
);
3188 // Ensure that .rela.dyn always appears before .rela.plt This is
3189 // necessary due to how, on PowerPC and some other targets, .rela.dyn
3190 // needs to include .rela.plt in its range.
3191 this->rela_dyn_section(layout
);
3193 Reloc_section
* plt_rel
= new Reloc_section(false);
3194 layout
->add_output_section_data(".rela.plt", elfcpp::SHT_RELA
,
3195 elfcpp::SHF_ALLOC
, plt_rel
,
3196 ORDER_DYNAMIC_PLT_RELOCS
, false);
3198 = new Output_data_plt_powerpc
<size
, big_endian
>(this, plt_rel
,
3200 layout
->add_output_section_data(".plt",
3202 ? elfcpp::SHT_PROGBITS
3203 : elfcpp::SHT_NOBITS
),
3204 elfcpp::SHF_ALLOC
| elfcpp::SHF_WRITE
,
3213 // Create the IPLT section.
3215 template<int size
, bool big_endian
>
3217 Target_powerpc
<size
, big_endian
>::make_iplt_section(Symbol_table
* symtab
,
3220 if (this->iplt_
== NULL
)
3222 this->make_plt_section(symtab
, layout
);
3224 Reloc_section
* iplt_rel
= new Reloc_section(false);
3225 this->rela_dyn_
->output_section()->add_output_section_data(iplt_rel
);
3227 = new Output_data_plt_powerpc
<size
, big_endian
>(this, iplt_rel
,
3229 this->plt_
->output_section()->add_output_section_data(this->iplt_
);
3233 // A section for huge long branch addresses, similar to plt section.
3235 template<int size
, bool big_endian
>
3236 class Output_data_brlt_powerpc
: public Output_section_data_build
3239 typedef typename
elfcpp::Elf_types
<size
>::Elf_Addr Address
;
3240 typedef Output_data_reloc
<elfcpp::SHT_RELA
, true,
3241 size
, big_endian
> Reloc_section
;
3243 Output_data_brlt_powerpc(Target_powerpc
<size
, big_endian
>* targ
,
3244 Reloc_section
* brlt_rel
)
3245 : Output_section_data_build(size
== 32 ? 4 : 8),
3253 this->reset_data_size();
3254 this->rel_
->reset_data_size();
3258 finalize_brlt_sizes()
3260 this->finalize_data_size();
3261 this->rel_
->finalize_data_size();
3264 // Add a reloc for an entry in the BRLT.
3266 add_reloc(Address to
, unsigned int off
)
3267 { this->rel_
->add_relative(elfcpp::R_POWERPC_RELATIVE
, this, off
, to
); }
3269 // Update section and reloc section size.
3271 set_current_size(unsigned int num_branches
)
3273 this->reset_address_and_file_offset();
3274 this->set_current_data_size(num_branches
* 16);
3275 this->finalize_data_size();
3276 Output_section
* os
= this->output_section();
3277 os
->set_section_offsets_need_adjustment();
3278 if (this->rel_
!= NULL
)
3280 unsigned int reloc_size
3281 = Reloc_types
<elfcpp::SHT_RELA
, size
, big_endian
>::reloc_size
;
3282 this->rel_
->reset_address_and_file_offset();
3283 this->rel_
->set_current_data_size(num_branches
* reloc_size
);
3284 this->rel_
->finalize_data_size();
3285 Output_section
* os
= this->rel_
->output_section();
3286 os
->set_section_offsets_need_adjustment();
3292 do_adjust_output_section(Output_section
* os
)
3297 // Write to a map file.
3299 do_print_to_mapfile(Mapfile
* mapfile
) const
3300 { mapfile
->print_output_data(this, "** BRLT"); }
3303 // Write out the BRLT data.
3305 do_write(Output_file
*);
3307 // The reloc section.
3308 Reloc_section
* rel_
;
3309 Target_powerpc
<size
, big_endian
>* targ_
;
3312 // Make the branch lookup table section.
3314 template<int size
, bool big_endian
>
3316 Target_powerpc
<size
, big_endian
>::make_brlt_section(Layout
* layout
)
3318 if (size
== 64 && this->brlt_section_
== NULL
)
3320 Reloc_section
* brlt_rel
= NULL
;
3321 bool is_pic
= parameters
->options().output_is_position_independent();
3324 // When PIC we can't fill in .branch_lt (like .plt it can be
3325 // a bss style section) but must initialise at runtime via
3326 // dynamic relocats.
3327 this->rela_dyn_section(layout
);
3328 brlt_rel
= new Reloc_section(false);
3329 this->rela_dyn_
->output_section()->add_output_section_data(brlt_rel
);
3332 = new Output_data_brlt_powerpc
<size
, big_endian
>(this, brlt_rel
);
3333 if (this->plt_
&& is_pic
)
3334 this->plt_
->output_section()
3335 ->add_output_section_data(this->brlt_section_
);
3337 layout
->add_output_section_data(".branch_lt",
3338 (is_pic
? elfcpp::SHT_NOBITS
3339 : elfcpp::SHT_PROGBITS
),
3340 elfcpp::SHF_ALLOC
| elfcpp::SHF_WRITE
,
3341 this->brlt_section_
,
3342 (is_pic
? ORDER_SMALL_BSS
3343 : ORDER_SMALL_DATA
),
3348 // Write out .branch_lt when non-PIC.
3350 template<int size
, bool big_endian
>
3352 Output_data_brlt_powerpc
<size
, big_endian
>::do_write(Output_file
* of
)
3354 if (size
== 64 && !parameters
->options().output_is_position_independent())
3356 const section_size_type offset
= this->offset();
3357 const section_size_type oview_size
3358 = convert_to_section_size_type(this->data_size());
3359 unsigned char* const oview
= of
->get_output_view(offset
, oview_size
);
3361 this->targ_
->write_branch_lookup_table(oview
);
3362 of
->write_output_view(offset
, oview_size
, oview
);
3366 static inline uint32_t
3372 static inline uint32_t
3378 static inline uint32_t
3381 return hi(a
+ 0x8000);
3387 static const unsigned char eh_frame_cie
[12];
3391 const unsigned char Eh_cie
<size
>::eh_frame_cie
[] =
3394 'z', 'R', 0, // Augmentation string.
3395 4, // Code alignment.
3396 0x80 - size
/ 8 , // Data alignment.
3398 1, // Augmentation size.
3399 (elfcpp::DW_EH_PE_pcrel
3400 | elfcpp::DW_EH_PE_sdata4
), // FDE encoding.
3401 elfcpp::DW_CFA_def_cfa
, 1, 0 // def_cfa: r1 offset 0.
3404 // Describe __glink_PLTresolve use of LR, 64-bit version ABIv1.
3405 static const unsigned char glink_eh_frame_fde_64v1
[] =
3407 0, 0, 0, 0, // Replaced with offset to .glink.
3408 0, 0, 0, 0, // Replaced with size of .glink.
3409 0, // Augmentation size.
3410 elfcpp::DW_CFA_advance_loc
+ 1,
3411 elfcpp::DW_CFA_register
, 65, 12,
3412 elfcpp::DW_CFA_advance_loc
+ 4,
3413 elfcpp::DW_CFA_restore_extended
, 65
3416 // Describe __glink_PLTresolve use of LR, 64-bit version ABIv2.
3417 static const unsigned char glink_eh_frame_fde_64v2
[] =
3419 0, 0, 0, 0, // Replaced with offset to .glink.
3420 0, 0, 0, 0, // Replaced with size of .glink.
3421 0, // Augmentation size.
3422 elfcpp::DW_CFA_advance_loc
+ 1,
3423 elfcpp::DW_CFA_register
, 65, 0,
3424 elfcpp::DW_CFA_advance_loc
+ 4,
3425 elfcpp::DW_CFA_restore_extended
, 65
3428 // Describe __glink_PLTresolve use of LR, 32-bit version.
3429 static const unsigned char glink_eh_frame_fde_32
[] =
3431 0, 0, 0, 0, // Replaced with offset to .glink.
3432 0, 0, 0, 0, // Replaced with size of .glink.
3433 0, // Augmentation size.
3434 elfcpp::DW_CFA_advance_loc
+ 2,
3435 elfcpp::DW_CFA_register
, 65, 0,
3436 elfcpp::DW_CFA_advance_loc
+ 4,
3437 elfcpp::DW_CFA_restore_extended
, 65
3440 static const unsigned char default_fde
[] =
3442 0, 0, 0, 0, // Replaced with offset to stubs.
3443 0, 0, 0, 0, // Replaced with size of stubs.
3444 0, // Augmentation size.
3445 elfcpp::DW_CFA_nop
, // Pad.
3450 template<bool big_endian
>
3452 write_insn(unsigned char* p
, uint32_t v
)
3454 elfcpp::Swap
<32, big_endian
>::writeval(p
, v
);
3457 // Stub_table holds information about plt and long branch stubs.
3458 // Stubs are built in an area following some input section determined
3459 // by group_sections(). This input section is converted to a relaxed
3460 // input section allowing it to be resized to accommodate the stubs
3462 template<int size
, bool big_endian
>
3463 class Stub_table
: public Output_relaxed_input_section
3466 typedef typename
elfcpp::Elf_types
<size
>::Elf_Addr Address
;
3467 static const Address invalid_address
= static_cast<Address
>(0) - 1;
3469 Stub_table(Target_powerpc
<size
, big_endian
>* targ
)
3470 : Output_relaxed_input_section(NULL
, 0, 0),
3471 targ_(targ
), plt_call_stubs_(), long_branch_stubs_(),
3472 orig_data_size_(0), plt_size_(0), last_plt_size_(0),
3473 branch_size_(0), last_branch_size_(0), eh_frame_added_(false)
3476 // Delayed Output_relaxed_input_section init.
3478 init(const Output_section::Input_section
*, Output_section
*);
3480 // Add a plt call stub.
3482 add_plt_call_entry(const Sized_relobj_file
<size
, big_endian
>*,
3488 add_plt_call_entry(const Sized_relobj_file
<size
, big_endian
>*,
3493 // Find a given plt call stub.
3495 find_plt_call_entry(const Symbol
*) const;
3498 find_plt_call_entry(const Sized_relobj_file
<size
, big_endian
>*,
3499 unsigned int) const;
3502 find_plt_call_entry(const Sized_relobj_file
<size
, big_endian
>*,
3508 find_plt_call_entry(const Sized_relobj_file
<size
, big_endian
>*,
3513 // Add a long branch stub.
3515 add_long_branch_entry(const Powerpc_relobj
<size
, big_endian
>*, Address
);
3518 find_long_branch_entry(const Powerpc_relobj
<size
, big_endian
>*,
3524 this->plt_call_stubs_
.clear();
3525 this->plt_size_
= 0;
3526 this->long_branch_stubs_
.clear();
3527 this->branch_size_
= 0;
3531 set_address_and_size(const Output_section
* os
, Address off
)
3533 Address start_off
= off
;
3534 off
+= this->orig_data_size_
;
3535 Address my_size
= this->plt_size_
+ this->branch_size_
;
3537 off
= align_address(off
, this->stub_align());
3538 // Include original section size and alignment padding in size
3539 my_size
+= off
- start_off
;
3540 this->reset_address_and_file_offset();
3541 this->set_current_data_size(my_size
);
3542 this->set_address_and_file_offset(os
->address() + start_off
,
3543 os
->offset() + start_off
);
3548 stub_address() const
3550 return align_address(this->address() + this->orig_data_size_
,
3551 this->stub_align());
3557 return align_address(this->offset() + this->orig_data_size_
,
3558 this->stub_align());
3563 { return this->plt_size_
; }
3568 Output_section
* os
= this->output_section();
3569 if (os
->addralign() < this->stub_align())
3571 os
->set_addralign(this->stub_align());
3572 // FIXME: get rid of the insane checkpointing.
3573 // We can't increase alignment of the input section to which
3574 // stubs are attached; The input section may be .init which
3575 // is pasted together with other .init sections to form a
3576 // function. Aligning might insert zero padding resulting in
3577 // sigill. However we do need to increase alignment of the
3578 // output section so that the align_address() on offset in
3579 // set_address_and_size() adds the same padding as the
3580 // align_address() on address in stub_address().
3581 // What's more, we need this alignment for the layout done in
3582 // relaxation_loop_body() so that the output section starts at
3583 // a suitably aligned address.
3584 os
->checkpoint_set_addralign(this->stub_align());
3586 if (this->last_plt_size_
!= this->plt_size_
3587 || this->last_branch_size_
!= this->branch_size_
)
3589 this->last_plt_size_
= this->plt_size_
;
3590 this->last_branch_size_
= this->branch_size_
;
3596 // Add .eh_frame info for this stub section. Unlike other linker
3597 // generated .eh_frame this is added late in the link, because we
3598 // only want the .eh_frame info if this particular stub section is
3601 add_eh_frame(Layout
* layout
)
3603 if (!this->eh_frame_added_
)
3605 if (!parameters
->options().ld_generated_unwind_info())
3608 // Since we add stub .eh_frame info late, it must be placed
3609 // after all other linker generated .eh_frame info so that
3610 // merge mapping need not be updated for input sections.
3611 // There is no provision to use a different CIE to that used
3613 if (!this->targ_
->has_glink())
3616 layout
->add_eh_frame_for_plt(this,
3617 Eh_cie
<size
>::eh_frame_cie
,
3618 sizeof (Eh_cie
<size
>::eh_frame_cie
),
3620 sizeof (default_fde
));
3621 this->eh_frame_added_
= true;
3625 Target_powerpc
<size
, big_endian
>*
3631 class Plt_stub_ent_hash
;
3632 typedef Unordered_map
<Plt_stub_ent
, unsigned int,
3633 Plt_stub_ent_hash
> Plt_stub_entries
;
3635 // Alignment of stub section.
3641 unsigned int min_align
= 32;
3642 unsigned int user_align
= 1 << parameters
->options().plt_align();
3643 return std::max(user_align
, min_align
);
3646 // Return the plt offset for the given call stub.
3648 plt_off(typename
Plt_stub_entries::const_iterator p
, bool* is_iplt
) const
3650 const Symbol
* gsym
= p
->first
.sym_
;
3653 *is_iplt
= (gsym
->type() == elfcpp::STT_GNU_IFUNC
3654 && gsym
->can_use_relative_reloc(false));
3655 return gsym
->plt_offset();
3660 const Sized_relobj_file
<size
, big_endian
>* relobj
= p
->first
.object_
;
3661 unsigned int local_sym_index
= p
->first
.locsym_
;
3662 return relobj
->local_plt_offset(local_sym_index
);
3666 // Size of a given plt call stub.
3668 plt_call_size(typename
Plt_stub_entries::const_iterator p
) const
3674 Address plt_addr
= this->plt_off(p
, &is_iplt
);
3676 plt_addr
+= this->targ_
->iplt_section()->address();
3678 plt_addr
+= this->targ_
->plt_section()->address();
3679 Address got_addr
= this->targ_
->got_section()->output_section()->address();
3680 const Powerpc_relobj
<size
, big_endian
>* ppcobj
= static_cast
3681 <const Powerpc_relobj
<size
, big_endian
>*>(p
->first
.object_
);
3682 got_addr
+= ppcobj
->toc_base_offset();
3683 Address off
= plt_addr
- got_addr
;
3684 unsigned int bytes
= 4 * 4 + 4 * (ha(off
) != 0);
3685 if (this->targ_
->abiversion() < 2)
3687 bool static_chain
= parameters
->options().plt_static_chain();
3688 bool thread_safe
= this->targ_
->plt_thread_safe();
3692 + 4 * (ha(off
+ 8 + 8 * static_chain
) != ha(off
)));
3694 unsigned int align
= 1 << parameters
->options().plt_align();
3696 bytes
= (bytes
+ align
- 1) & -align
;
3700 // Return long branch stub size.
3702 branch_stub_size(Address to
)
3705 = this->stub_address() + this->last_plt_size_
+ this->branch_size_
;
3706 if (to
- loc
+ (1 << 25) < 2 << 25)
3708 if (size
== 64 || !parameters
->options().output_is_position_independent())
3715 do_write(Output_file
*);
3717 // Plt call stub keys.
3721 Plt_stub_ent(const Symbol
* sym
)
3722 : sym_(sym
), object_(0), addend_(0), locsym_(0)
3725 Plt_stub_ent(const Sized_relobj_file
<size
, big_endian
>* object
,
3726 unsigned int locsym_index
)
3727 : sym_(NULL
), object_(object
), addend_(0), locsym_(locsym_index
)
3730 Plt_stub_ent(const Sized_relobj_file
<size
, big_endian
>* object
,
3732 unsigned int r_type
,
3734 : sym_(sym
), object_(0), addend_(0), locsym_(0)
3737 this->addend_
= addend
;
3738 else if (parameters
->options().output_is_position_independent()
3739 && r_type
== elfcpp::R_PPC_PLTREL24
)
3741 this->addend_
= addend
;
3742 if (this->addend_
>= 32768)
3743 this->object_
= object
;
3747 Plt_stub_ent(const Sized_relobj_file
<size
, big_endian
>* object
,
3748 unsigned int locsym_index
,
3749 unsigned int r_type
,
3751 : sym_(NULL
), object_(object
), addend_(0), locsym_(locsym_index
)
3754 this->addend_
= addend
;
3755 else if (parameters
->options().output_is_position_independent()
3756 && r_type
== elfcpp::R_PPC_PLTREL24
)
3757 this->addend_
= addend
;
3760 bool operator==(const Plt_stub_ent
& that
) const
3762 return (this->sym_
== that
.sym_
3763 && this->object_
== that
.object_
3764 && this->addend_
== that
.addend_
3765 && this->locsym_
== that
.locsym_
);
3769 const Sized_relobj_file
<size
, big_endian
>* object_
;
3770 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend_
;
3771 unsigned int locsym_
;
3774 class Plt_stub_ent_hash
3777 size_t operator()(const Plt_stub_ent
& ent
) const
3779 return (reinterpret_cast<uintptr_t>(ent
.sym_
)
3780 ^ reinterpret_cast<uintptr_t>(ent
.object_
)
3786 // Long branch stub keys.
3787 class Branch_stub_ent
3790 Branch_stub_ent(const Powerpc_relobj
<size
, big_endian
>* obj
, Address to
)
3791 : dest_(to
), toc_base_off_(0)
3794 toc_base_off_
= obj
->toc_base_offset();
3797 bool operator==(const Branch_stub_ent
& that
) const
3799 return (this->dest_
== that
.dest_
3801 || this->toc_base_off_
== that
.toc_base_off_
));
3805 unsigned int toc_base_off_
;
3808 class Branch_stub_ent_hash
3811 size_t operator()(const Branch_stub_ent
& ent
) const
3812 { return ent
.dest_
^ ent
.toc_base_off_
; }
3815 // In a sane world this would be a global.
3816 Target_powerpc
<size
, big_endian
>* targ_
;
3817 // Map sym/object/addend to stub offset.
3818 Plt_stub_entries plt_call_stubs_
;
3819 // Map destination address to stub offset.
3820 typedef Unordered_map
<Branch_stub_ent
, unsigned int,
3821 Branch_stub_ent_hash
> Branch_stub_entries
;
3822 Branch_stub_entries long_branch_stubs_
;
3823 // size of input section
3824 section_size_type orig_data_size_
;
3826 section_size_type plt_size_
, last_plt_size_
, branch_size_
, last_branch_size_
;
3827 // Whether .eh_frame info has been created for this stub section.
3828 bool eh_frame_added_
;
3831 // Make a new stub table, and record.
3833 template<int size
, bool big_endian
>
3834 Stub_table
<size
, big_endian
>*
3835 Target_powerpc
<size
, big_endian
>::new_stub_table()
3837 Stub_table
<size
, big_endian
>* stub_table
3838 = new Stub_table
<size
, big_endian
>(this);
3839 this->stub_tables_
.push_back(stub_table
);
3843 // Delayed stub table initialisation, because we create the stub table
3844 // before we know to which section it will be attached.
3846 template<int size
, bool big_endian
>
3848 Stub_table
<size
, big_endian
>::init(
3849 const Output_section::Input_section
* owner
,
3850 Output_section
* output_section
)
3852 this->set_relobj(owner
->relobj());
3853 this->set_shndx(owner
->shndx());
3854 this->set_addralign(this->relobj()->section_addralign(this->shndx()));
3855 this->set_output_section(output_section
);
3856 this->orig_data_size_
= owner
->current_data_size();
3858 std::vector
<Output_relaxed_input_section
*> new_relaxed
;
3859 new_relaxed
.push_back(this);
3860 output_section
->convert_input_sections_to_relaxed_sections(new_relaxed
);
3863 // Add a plt call stub, if we do not already have one for this
3864 // sym/object/addend combo.
3866 template<int size
, bool big_endian
>
3868 Stub_table
<size
, big_endian
>::add_plt_call_entry(
3869 const Sized_relobj_file
<size
, big_endian
>* object
,
3871 unsigned int r_type
,
3874 Plt_stub_ent
ent(object
, gsym
, r_type
, addend
);
3875 unsigned int off
= this->plt_size_
;
3876 std::pair
<typename
Plt_stub_entries::iterator
, bool> p
3877 = this->plt_call_stubs_
.insert(std::make_pair(ent
, off
));
3879 this->plt_size_
= off
+ this->plt_call_size(p
.first
);
3882 template<int size
, bool big_endian
>
3884 Stub_table
<size
, big_endian
>::add_plt_call_entry(
3885 const Sized_relobj_file
<size
, big_endian
>* object
,
3886 unsigned int locsym_index
,
3887 unsigned int r_type
,
3890 Plt_stub_ent
ent(object
, locsym_index
, r_type
, addend
);
3891 unsigned int off
= this->plt_size_
;
3892 std::pair
<typename
Plt_stub_entries::iterator
, bool> p
3893 = this->plt_call_stubs_
.insert(std::make_pair(ent
, off
));
3895 this->plt_size_
= off
+ this->plt_call_size(p
.first
);
3898 // Find a plt call stub.
3900 template<int size
, bool big_endian
>
3901 typename Stub_table
<size
, big_endian
>::Address
3902 Stub_table
<size
, big_endian
>::find_plt_call_entry(
3903 const Sized_relobj_file
<size
, big_endian
>* object
,
3905 unsigned int r_type
,
3906 Address addend
) const
3908 Plt_stub_ent
ent(object
, gsym
, r_type
, addend
);
3909 typename
Plt_stub_entries::const_iterator p
= this->plt_call_stubs_
.find(ent
);
3910 return p
== this->plt_call_stubs_
.end() ? invalid_address
: p
->second
;
3913 template<int size
, bool big_endian
>
3914 typename Stub_table
<size
, big_endian
>::Address
3915 Stub_table
<size
, big_endian
>::find_plt_call_entry(const Symbol
* gsym
) const
3917 Plt_stub_ent
ent(gsym
);
3918 typename
Plt_stub_entries::const_iterator p
= this->plt_call_stubs_
.find(ent
);
3919 return p
== this->plt_call_stubs_
.end() ? invalid_address
: p
->second
;
3922 template<int size
, bool big_endian
>
3923 typename Stub_table
<size
, big_endian
>::Address
3924 Stub_table
<size
, big_endian
>::find_plt_call_entry(
3925 const Sized_relobj_file
<size
, big_endian
>* object
,
3926 unsigned int locsym_index
,
3927 unsigned int r_type
,
3928 Address addend
) const
3930 Plt_stub_ent
ent(object
, locsym_index
, r_type
, addend
);
3931 typename
Plt_stub_entries::const_iterator p
= this->plt_call_stubs_
.find(ent
);
3932 return p
== this->plt_call_stubs_
.end() ? invalid_address
: p
->second
;
3935 template<int size
, bool big_endian
>
3936 typename Stub_table
<size
, big_endian
>::Address
3937 Stub_table
<size
, big_endian
>::find_plt_call_entry(
3938 const Sized_relobj_file
<size
, big_endian
>* object
,
3939 unsigned int locsym_index
) const
3941 Plt_stub_ent
ent(object
, locsym_index
);
3942 typename
Plt_stub_entries::const_iterator p
= this->plt_call_stubs_
.find(ent
);
3943 return p
== this->plt_call_stubs_
.end() ? invalid_address
: p
->second
;
3946 // Add a long branch stub if we don't already have one to given
3949 template<int size
, bool big_endian
>
3951 Stub_table
<size
, big_endian
>::add_long_branch_entry(
3952 const Powerpc_relobj
<size
, big_endian
>* object
,
3955 Branch_stub_ent
ent(object
, to
);
3956 Address off
= this->branch_size_
;
3957 if (this->long_branch_stubs_
.insert(std::make_pair(ent
, off
)).second
)
3959 unsigned int stub_size
= this->branch_stub_size(to
);
3960 this->branch_size_
= off
+ stub_size
;
3961 if (size
== 64 && stub_size
!= 4)
3962 this->targ_
->add_branch_lookup_table(to
);
3966 // Find long branch stub.
3968 template<int size
, bool big_endian
>
3969 typename Stub_table
<size
, big_endian
>::Address
3970 Stub_table
<size
, big_endian
>::find_long_branch_entry(
3971 const Powerpc_relobj
<size
, big_endian
>* object
,
3974 Branch_stub_ent
ent(object
, to
);
3975 typename
Branch_stub_entries::const_iterator p
3976 = this->long_branch_stubs_
.find(ent
);
3977 return p
== this->long_branch_stubs_
.end() ? invalid_address
: p
->second
;
3980 // A class to handle .glink.
3982 template<int size
, bool big_endian
>
3983 class Output_data_glink
: public Output_section_data
3986 typedef typename
elfcpp::Elf_types
<size
>::Elf_Addr Address
;
3987 static const Address invalid_address
= static_cast<Address
>(0) - 1;
3988 static const int pltresolve_size
= 16*4;
3990 Output_data_glink(Target_powerpc
<size
, big_endian
>* targ
)
3991 : Output_section_data(16), targ_(targ
), global_entry_stubs_(),
3992 end_branch_table_(), ge_size_(0)
3996 add_eh_frame(Layout
* layout
);
3999 add_global_entry(const Symbol
*);
4002 find_global_entry(const Symbol
*) const;
4005 global_entry_address() const
4007 gold_assert(this->is_data_size_valid());
4008 unsigned int global_entry_off
= (this->end_branch_table_
+ 15) & -16;
4009 return this->address() + global_entry_off
;
4013 // Write to a map file.
4015 do_print_to_mapfile(Mapfile
* mapfile
) const
4016 { mapfile
->print_output_data(this, _("** glink")); }
4020 set_final_data_size();
4024 do_write(Output_file
*);
4026 // Allows access to .got and .plt for do_write.
4027 Target_powerpc
<size
, big_endian
>* targ_
;
4029 // Map sym to stub offset.
4030 typedef Unordered_map
<const Symbol
*, unsigned int> Global_entry_stub_entries
;
4031 Global_entry_stub_entries global_entry_stubs_
;
4033 unsigned int end_branch_table_
, ge_size_
;
4036 template<int size
, bool big_endian
>
4038 Output_data_glink
<size
, big_endian
>::add_eh_frame(Layout
* layout
)
4040 if (!parameters
->options().ld_generated_unwind_info())
4045 if (this->targ_
->abiversion() < 2)
4046 layout
->add_eh_frame_for_plt(this,
4047 Eh_cie
<64>::eh_frame_cie
,
4048 sizeof (Eh_cie
<64>::eh_frame_cie
),
4049 glink_eh_frame_fde_64v1
,
4050 sizeof (glink_eh_frame_fde_64v1
));
4052 layout
->add_eh_frame_for_plt(this,
4053 Eh_cie
<64>::eh_frame_cie
,
4054 sizeof (Eh_cie
<64>::eh_frame_cie
),
4055 glink_eh_frame_fde_64v2
,
4056 sizeof (glink_eh_frame_fde_64v2
));
4060 // 32-bit .glink can use the default since the CIE return
4061 // address reg, LR, is valid.
4062 layout
->add_eh_frame_for_plt(this,
4063 Eh_cie
<32>::eh_frame_cie
,
4064 sizeof (Eh_cie
<32>::eh_frame_cie
),
4066 sizeof (default_fde
));
4067 // Except where LR is used in a PIC __glink_PLTresolve.
4068 if (parameters
->options().output_is_position_independent())
4069 layout
->add_eh_frame_for_plt(this,
4070 Eh_cie
<32>::eh_frame_cie
,
4071 sizeof (Eh_cie
<32>::eh_frame_cie
),
4072 glink_eh_frame_fde_32
,
4073 sizeof (glink_eh_frame_fde_32
));
4077 template<int size
, bool big_endian
>
4079 Output_data_glink
<size
, big_endian
>::add_global_entry(const Symbol
* gsym
)
4081 std::pair
<typename
Global_entry_stub_entries::iterator
, bool> p
4082 = this->global_entry_stubs_
.insert(std::make_pair(gsym
, this->ge_size_
));
4084 this->ge_size_
+= 16;
4087 template<int size
, bool big_endian
>
4088 typename Output_data_glink
<size
, big_endian
>::Address
4089 Output_data_glink
<size
, big_endian
>::find_global_entry(const Symbol
* gsym
) const
4091 typename
Global_entry_stub_entries::const_iterator p
4092 = this->global_entry_stubs_
.find(gsym
);
4093 return p
== this->global_entry_stubs_
.end() ? invalid_address
: p
->second
;
4096 template<int size
, bool big_endian
>
4098 Output_data_glink
<size
, big_endian
>::set_final_data_size()
4100 unsigned int count
= this->targ_
->plt_entry_count();
4101 section_size_type total
= 0;
4107 // space for branch table
4108 total
+= 4 * (count
- 1);
4110 total
+= -total
& 15;
4111 total
+= this->pltresolve_size
;
4115 total
+= this->pltresolve_size
;
4117 // space for branch table
4119 if (this->targ_
->abiversion() < 2)
4123 total
+= 4 * (count
- 0x8000);
4127 this->end_branch_table_
= total
;
4128 total
= (total
+ 15) & -16;
4129 total
+= this->ge_size_
;
4131 this->set_data_size(total
);
4134 // Write out plt and long branch stub code.
4136 template<int size
, bool big_endian
>
4138 Stub_table
<size
, big_endian
>::do_write(Output_file
* of
)
4140 if (this->plt_call_stubs_
.empty()
4141 && this->long_branch_stubs_
.empty())
4144 const section_size_type start_off
= this->offset();
4145 const section_size_type off
= this->stub_offset();
4146 const section_size_type oview_size
=
4147 convert_to_section_size_type(this->data_size() - (off
- start_off
));
4148 unsigned char* const oview
= of
->get_output_view(off
, oview_size
);
4153 const Output_data_got_powerpc
<size
, big_endian
>* got
4154 = this->targ_
->got_section();
4155 Address got_os_addr
= got
->output_section()->address();
4157 if (!this->plt_call_stubs_
.empty())
4159 // The base address of the .plt section.
4160 Address plt_base
= this->targ_
->plt_section()->address();
4161 Address iplt_base
= invalid_address
;
4163 // Write out plt call stubs.
4164 typename
Plt_stub_entries::const_iterator cs
;
4165 for (cs
= this->plt_call_stubs_
.begin();
4166 cs
!= this->plt_call_stubs_
.end();
4170 Address pltoff
= this->plt_off(cs
, &is_iplt
);
4171 Address plt_addr
= pltoff
;
4174 if (iplt_base
== invalid_address
)
4175 iplt_base
= this->targ_
->iplt_section()->address();
4176 plt_addr
+= iplt_base
;
4179 plt_addr
+= plt_base
;
4180 const Powerpc_relobj
<size
, big_endian
>* ppcobj
= static_cast
4181 <const Powerpc_relobj
<size
, big_endian
>*>(cs
->first
.object_
);
4182 Address got_addr
= got_os_addr
+ ppcobj
->toc_base_offset();
4183 Address off
= plt_addr
- got_addr
;
4185 if (off
+ 0x80008000 > 0xffffffff || (off
& 7) != 0)
4186 gold_error(_("%s: linkage table error against `%s'"),
4187 cs
->first
.object_
->name().c_str(),
4188 cs
->first
.sym_
->demangled_name().c_str());
4190 bool plt_load_toc
= this->targ_
->abiversion() < 2;
4192 = plt_load_toc
&& parameters
->options().plt_static_chain();
4194 = plt_load_toc
&& this->targ_
->plt_thread_safe();
4195 bool use_fake_dep
= false;
4196 Address cmp_branch_off
= 0;
4199 unsigned int pltindex
4200 = ((pltoff
- this->targ_
->first_plt_entry_offset())
4201 / this->targ_
->plt_entry_size());
4203 = (this->targ_
->glink_section()->pltresolve_size
4205 if (pltindex
> 32768)
4206 glinkoff
+= (pltindex
- 32768) * 4;
4208 = this->targ_
->glink_section()->address() + glinkoff
;
4210 = (this->stub_address() + cs
->second
+ 24
4211 + 4 * (ha(off
) != 0)
4212 + 4 * (ha(off
+ 8 + 8 * static_chain
) != ha(off
))
4213 + 4 * static_chain
);
4214 cmp_branch_off
= to
- from
;
4215 use_fake_dep
= cmp_branch_off
+ (1 << 25) >= (1 << 26);
4218 p
= oview
+ cs
->second
;
4221 write_insn
<big_endian
>(p
, std_2_1
+ this->targ_
->stk_toc());
4225 write_insn
<big_endian
>(p
, addis_11_2
+ ha(off
));
4227 write_insn
<big_endian
>(p
, ld_12_11
+ l(off
));
4232 write_insn
<big_endian
>(p
, addis_12_2
+ ha(off
));
4234 write_insn
<big_endian
>(p
, ld_12_12
+ l(off
));
4238 && ha(off
+ 8 + 8 * static_chain
) != ha(off
))
4240 write_insn
<big_endian
>(p
, addi_11_11
+ l(off
));
4244 write_insn
<big_endian
>(p
, mtctr_12
);
4250 write_insn
<big_endian
>(p
, xor_2_12_12
);
4252 write_insn
<big_endian
>(p
, add_11_11_2
);
4255 write_insn
<big_endian
>(p
, ld_2_11
+ l(off
+ 8));
4259 write_insn
<big_endian
>(p
, ld_11_11
+ l(off
+ 16));
4266 write_insn
<big_endian
>(p
, std_2_1
+ this->targ_
->stk_toc());
4268 write_insn
<big_endian
>(p
, ld_12_2
+ l(off
));
4271 && ha(off
+ 8 + 8 * static_chain
) != ha(off
))
4273 write_insn
<big_endian
>(p
, addi_2_2
+ l(off
));
4277 write_insn
<big_endian
>(p
, mtctr_12
);
4283 write_insn
<big_endian
>(p
, xor_11_12_12
);
4285 write_insn
<big_endian
>(p
, add_2_2_11
);
4290 write_insn
<big_endian
>(p
, ld_11_2
+ l(off
+ 16));
4293 write_insn
<big_endian
>(p
, ld_2_2
+ l(off
+ 8));
4297 if (thread_safe
&& !use_fake_dep
)
4299 write_insn
<big_endian
>(p
, cmpldi_2_0
);
4301 write_insn
<big_endian
>(p
, bnectr_p4
);
4303 write_insn
<big_endian
>(p
, b
| (cmp_branch_off
& 0x3fffffc));
4306 write_insn
<big_endian
>(p
, bctr
);
4310 // Write out long branch stubs.
4311 typename
Branch_stub_entries::const_iterator bs
;
4312 for (bs
= this->long_branch_stubs_
.begin();
4313 bs
!= this->long_branch_stubs_
.end();
4316 p
= oview
+ this->plt_size_
+ bs
->second
;
4317 Address loc
= this->stub_address() + this->plt_size_
+ bs
->second
;
4318 Address delta
= bs
->first
.dest_
- loc
;
4319 if (delta
+ (1 << 25) < 2 << 25)
4320 write_insn
<big_endian
>(p
, b
| (delta
& 0x3fffffc));
4324 = this->targ_
->find_branch_lookup_table(bs
->first
.dest_
);
4325 gold_assert(brlt_addr
!= invalid_address
);
4326 brlt_addr
+= this->targ_
->brlt_section()->address();
4327 Address got_addr
= got_os_addr
+ bs
->first
.toc_base_off_
;
4328 Address brltoff
= brlt_addr
- got_addr
;
4329 if (ha(brltoff
) == 0)
4331 write_insn
<big_endian
>(p
, ld_12_2
+ l(brltoff
)), p
+= 4;
4335 write_insn
<big_endian
>(p
, addis_12_2
+ ha(brltoff
)), p
+= 4;
4336 write_insn
<big_endian
>(p
, ld_12_12
+ l(brltoff
)), p
+= 4;
4338 write_insn
<big_endian
>(p
, mtctr_12
), p
+= 4;
4339 write_insn
<big_endian
>(p
, bctr
);
4345 if (!this->plt_call_stubs_
.empty())
4347 // The base address of the .plt section.
4348 Address plt_base
= this->targ_
->plt_section()->address();
4349 Address iplt_base
= invalid_address
;
4350 // The address of _GLOBAL_OFFSET_TABLE_.
4351 Address g_o_t
= invalid_address
;
4353 // Write out plt call stubs.
4354 typename
Plt_stub_entries::const_iterator cs
;
4355 for (cs
= this->plt_call_stubs_
.begin();
4356 cs
!= this->plt_call_stubs_
.end();
4360 Address plt_addr
= this->plt_off(cs
, &is_iplt
);
4363 if (iplt_base
== invalid_address
)
4364 iplt_base
= this->targ_
->iplt_section()->address();
4365 plt_addr
+= iplt_base
;
4368 plt_addr
+= plt_base
;
4370 p
= oview
+ cs
->second
;
4371 if (parameters
->options().output_is_position_independent())
4374 const Powerpc_relobj
<size
, big_endian
>* ppcobj
4375 = (static_cast<const Powerpc_relobj
<size
, big_endian
>*>
4376 (cs
->first
.object_
));
4377 if (ppcobj
!= NULL
&& cs
->first
.addend_
>= 32768)
4379 unsigned int got2
= ppcobj
->got2_shndx();
4380 got_addr
= ppcobj
->get_output_section_offset(got2
);
4381 gold_assert(got_addr
!= invalid_address
);
4382 got_addr
+= (ppcobj
->output_section(got2
)->address()
4383 + cs
->first
.addend_
);
4387 if (g_o_t
== invalid_address
)
4389 const Output_data_got_powerpc
<size
, big_endian
>* got
4390 = this->targ_
->got_section();
4391 g_o_t
= got
->address() + got
->g_o_t();
4396 Address off
= plt_addr
- got_addr
;
4399 write_insn
<big_endian
>(p
+ 0, lwz_11_30
+ l(off
));
4400 write_insn
<big_endian
>(p
+ 4, mtctr_11
);
4401 write_insn
<big_endian
>(p
+ 8, bctr
);
4405 write_insn
<big_endian
>(p
+ 0, addis_11_30
+ ha(off
));
4406 write_insn
<big_endian
>(p
+ 4, lwz_11_11
+ l(off
));
4407 write_insn
<big_endian
>(p
+ 8, mtctr_11
);
4408 write_insn
<big_endian
>(p
+ 12, bctr
);
4413 write_insn
<big_endian
>(p
+ 0, lis_11
+ ha(plt_addr
));
4414 write_insn
<big_endian
>(p
+ 4, lwz_11_11
+ l(plt_addr
));
4415 write_insn
<big_endian
>(p
+ 8, mtctr_11
);
4416 write_insn
<big_endian
>(p
+ 12, bctr
);
4421 // Write out long branch stubs.
4422 typename
Branch_stub_entries::const_iterator bs
;
4423 for (bs
= this->long_branch_stubs_
.begin();
4424 bs
!= this->long_branch_stubs_
.end();
4427 p
= oview
+ this->plt_size_
+ bs
->second
;
4428 Address loc
= this->stub_address() + this->plt_size_
+ bs
->second
;
4429 Address delta
= bs
->first
.dest_
- loc
;
4430 if (delta
+ (1 << 25) < 2 << 25)
4431 write_insn
<big_endian
>(p
, b
| (delta
& 0x3fffffc));
4432 else if (!parameters
->options().output_is_position_independent())
4434 write_insn
<big_endian
>(p
+ 0, lis_12
+ ha(bs
->first
.dest_
));
4435 write_insn
<big_endian
>(p
+ 4, addi_12_12
+ l(bs
->first
.dest_
));
4436 write_insn
<big_endian
>(p
+ 8, mtctr_12
);
4437 write_insn
<big_endian
>(p
+ 12, bctr
);
4442 write_insn
<big_endian
>(p
+ 0, mflr_0
);
4443 write_insn
<big_endian
>(p
+ 4, bcl_20_31
);
4444 write_insn
<big_endian
>(p
+ 8, mflr_12
);
4445 write_insn
<big_endian
>(p
+ 12, addis_12_12
+ ha(delta
));
4446 write_insn
<big_endian
>(p
+ 16, addi_12_12
+ l(delta
));
4447 write_insn
<big_endian
>(p
+ 20, mtlr_0
);
4448 write_insn
<big_endian
>(p
+ 24, mtctr_12
);
4449 write_insn
<big_endian
>(p
+ 28, bctr
);
4455 // Write out .glink.
4457 template<int size
, bool big_endian
>
4459 Output_data_glink
<size
, big_endian
>::do_write(Output_file
* of
)
4461 const section_size_type off
= this->offset();
4462 const section_size_type oview_size
=
4463 convert_to_section_size_type(this->data_size());
4464 unsigned char* const oview
= of
->get_output_view(off
, oview_size
);
4467 // The base address of the .plt section.
4468 typedef typename
elfcpp::Elf_types
<size
>::Elf_Addr Address
;
4469 Address plt_base
= this->targ_
->plt_section()->address();
4473 if (this->end_branch_table_
!= 0)
4475 // Write pltresolve stub.
4477 Address after_bcl
= this->address() + 16;
4478 Address pltoff
= plt_base
- after_bcl
;
4480 elfcpp::Swap
<64, big_endian
>::writeval(p
, pltoff
), p
+= 8;
4482 if (this->targ_
->abiversion() < 2)
4484 write_insn
<big_endian
>(p
, mflr_12
), p
+= 4;
4485 write_insn
<big_endian
>(p
, bcl_20_31
), p
+= 4;
4486 write_insn
<big_endian
>(p
, mflr_11
), p
+= 4;
4487 write_insn
<big_endian
>(p
, ld_2_11
+ l(-16)), p
+= 4;
4488 write_insn
<big_endian
>(p
, mtlr_12
), p
+= 4;
4489 write_insn
<big_endian
>(p
, add_11_2_11
), p
+= 4;
4490 write_insn
<big_endian
>(p
, ld_12_11
+ 0), p
+= 4;
4491 write_insn
<big_endian
>(p
, ld_2_11
+ 8), p
+= 4;
4492 write_insn
<big_endian
>(p
, mtctr_12
), p
+= 4;
4493 write_insn
<big_endian
>(p
, ld_11_11
+ 16), p
+= 4;
4497 write_insn
<big_endian
>(p
, mflr_0
), p
+= 4;
4498 write_insn
<big_endian
>(p
, bcl_20_31
), p
+= 4;
4499 write_insn
<big_endian
>(p
, mflr_11
), p
+= 4;
4500 write_insn
<big_endian
>(p
, ld_2_11
+ l(-16)), p
+= 4;
4501 write_insn
<big_endian
>(p
, mtlr_0
), p
+= 4;
4502 write_insn
<big_endian
>(p
, sub_12_12_11
), p
+= 4;
4503 write_insn
<big_endian
>(p
, add_11_2_11
), p
+= 4;
4504 write_insn
<big_endian
>(p
, addi_0_12
+ l(-48)), p
+= 4;
4505 write_insn
<big_endian
>(p
, ld_12_11
+ 0), p
+= 4;
4506 write_insn
<big_endian
>(p
, srdi_0_0_2
), p
+= 4;
4507 write_insn
<big_endian
>(p
, mtctr_12
), p
+= 4;
4508 write_insn
<big_endian
>(p
, ld_11_11
+ 8), p
+= 4;
4510 write_insn
<big_endian
>(p
, bctr
), p
+= 4;
4511 while (p
< oview
+ this->pltresolve_size
)
4512 write_insn
<big_endian
>(p
, nop
), p
+= 4;
4514 // Write lazy link call stubs.
4516 while (p
< oview
+ this->end_branch_table_
)
4518 if (this->targ_
->abiversion() < 2)
4522 write_insn
<big_endian
>(p
, li_0_0
+ indx
), p
+= 4;
4526 write_insn
<big_endian
>(p
, lis_0_0
+ hi(indx
)), p
+= 4;
4527 write_insn
<big_endian
>(p
, ori_0_0_0
+ l(indx
)), p
+= 4;
4530 uint32_t branch_off
= 8 - (p
- oview
);
4531 write_insn
<big_endian
>(p
, b
+ (branch_off
& 0x3fffffc)), p
+= 4;
4536 Address plt_base
= this->targ_
->plt_section()->address();
4537 Address iplt_base
= invalid_address
;
4538 unsigned int global_entry_off
= (this->end_branch_table_
+ 15) & -16;
4539 Address global_entry_base
= this->address() + global_entry_off
;
4540 typename
Global_entry_stub_entries::const_iterator ge
;
4541 for (ge
= this->global_entry_stubs_
.begin();
4542 ge
!= this->global_entry_stubs_
.end();
4545 p
= oview
+ global_entry_off
+ ge
->second
;
4546 Address plt_addr
= ge
->first
->plt_offset();
4547 if (ge
->first
->type() == elfcpp::STT_GNU_IFUNC
4548 && ge
->first
->can_use_relative_reloc(false))
4550 if (iplt_base
== invalid_address
)
4551 iplt_base
= this->targ_
->iplt_section()->address();
4552 plt_addr
+= iplt_base
;
4555 plt_addr
+= plt_base
;
4556 Address my_addr
= global_entry_base
+ ge
->second
;
4557 Address off
= plt_addr
- my_addr
;
4559 if (off
+ 0x80008000 > 0xffffffff || (off
& 3) != 0)
4560 gold_error(_("%s: linkage table error against `%s'"),
4561 ge
->first
->object()->name().c_str(),
4562 ge
->first
->demangled_name().c_str());
4564 write_insn
<big_endian
>(p
, addis_12_12
+ ha(off
)), p
+= 4;
4565 write_insn
<big_endian
>(p
, ld_12_12
+ l(off
)), p
+= 4;
4566 write_insn
<big_endian
>(p
, mtctr_12
), p
+= 4;
4567 write_insn
<big_endian
>(p
, bctr
);
4572 const Output_data_got_powerpc
<size
, big_endian
>* got
4573 = this->targ_
->got_section();
4574 // The address of _GLOBAL_OFFSET_TABLE_.
4575 Address g_o_t
= got
->address() + got
->g_o_t();
4577 // Write out pltresolve branch table.
4579 unsigned int the_end
= oview_size
- this->pltresolve_size
;
4580 unsigned char* end_p
= oview
+ the_end
;
4581 while (p
< end_p
- 8 * 4)
4582 write_insn
<big_endian
>(p
, b
+ end_p
- p
), p
+= 4;
4584 write_insn
<big_endian
>(p
, nop
), p
+= 4;
4586 // Write out pltresolve call stub.
4587 if (parameters
->options().output_is_position_independent())
4589 Address res0_off
= 0;
4590 Address after_bcl_off
= the_end
+ 12;
4591 Address bcl_res0
= after_bcl_off
- res0_off
;
4593 write_insn
<big_endian
>(p
+ 0, addis_11_11
+ ha(bcl_res0
));
4594 write_insn
<big_endian
>(p
+ 4, mflr_0
);
4595 write_insn
<big_endian
>(p
+ 8, bcl_20_31
);
4596 write_insn
<big_endian
>(p
+ 12, addi_11_11
+ l(bcl_res0
));
4597 write_insn
<big_endian
>(p
+ 16, mflr_12
);
4598 write_insn
<big_endian
>(p
+ 20, mtlr_0
);
4599 write_insn
<big_endian
>(p
+ 24, sub_11_11_12
);
4601 Address got_bcl
= g_o_t
+ 4 - (after_bcl_off
+ this->address());
4603 write_insn
<big_endian
>(p
+ 28, addis_12_12
+ ha(got_bcl
));
4604 if (ha(got_bcl
) == ha(got_bcl
+ 4))
4606 write_insn
<big_endian
>(p
+ 32, lwz_0_12
+ l(got_bcl
));
4607 write_insn
<big_endian
>(p
+ 36, lwz_12_12
+ l(got_bcl
+ 4));
4611 write_insn
<big_endian
>(p
+ 32, lwzu_0_12
+ l(got_bcl
));
4612 write_insn
<big_endian
>(p
+ 36, lwz_12_12
+ 4);
4614 write_insn
<big_endian
>(p
+ 40, mtctr_0
);
4615 write_insn
<big_endian
>(p
+ 44, add_0_11_11
);
4616 write_insn
<big_endian
>(p
+ 48, add_11_0_11
);
4617 write_insn
<big_endian
>(p
+ 52, bctr
);
4618 write_insn
<big_endian
>(p
+ 56, nop
);
4619 write_insn
<big_endian
>(p
+ 60, nop
);
4623 Address res0
= this->address();
4625 write_insn
<big_endian
>(p
+ 0, lis_12
+ ha(g_o_t
+ 4));
4626 write_insn
<big_endian
>(p
+ 4, addis_11_11
+ ha(-res0
));
4627 if (ha(g_o_t
+ 4) == ha(g_o_t
+ 8))
4628 write_insn
<big_endian
>(p
+ 8, lwz_0_12
+ l(g_o_t
+ 4));
4630 write_insn
<big_endian
>(p
+ 8, lwzu_0_12
+ l(g_o_t
+ 4));
4631 write_insn
<big_endian
>(p
+ 12, addi_11_11
+ l(-res0
));
4632 write_insn
<big_endian
>(p
+ 16, mtctr_0
);
4633 write_insn
<big_endian
>(p
+ 20, add_0_11_11
);
4634 if (ha(g_o_t
+ 4) == ha(g_o_t
+ 8))
4635 write_insn
<big_endian
>(p
+ 24, lwz_12_12
+ l(g_o_t
+ 8));
4637 write_insn
<big_endian
>(p
+ 24, lwz_12_12
+ 4);
4638 write_insn
<big_endian
>(p
+ 28, add_11_0_11
);
4639 write_insn
<big_endian
>(p
+ 32, bctr
);
4640 write_insn
<big_endian
>(p
+ 36, nop
);
4641 write_insn
<big_endian
>(p
+ 40, nop
);
4642 write_insn
<big_endian
>(p
+ 44, nop
);
4643 write_insn
<big_endian
>(p
+ 48, nop
);
4644 write_insn
<big_endian
>(p
+ 52, nop
);
4645 write_insn
<big_endian
>(p
+ 56, nop
);
4646 write_insn
<big_endian
>(p
+ 60, nop
);
4651 of
->write_output_view(off
, oview_size
, oview
);
4655 // A class to handle linker generated save/restore functions.
4657 template<int size
, bool big_endian
>
4658 class Output_data_save_res
: public Output_section_data_build
4661 Output_data_save_res(Symbol_table
* symtab
);
4664 // Write to a map file.
4666 do_print_to_mapfile(Mapfile
* mapfile
) const
4667 { mapfile
->print_output_data(this, _("** save/restore")); }
4670 do_write(Output_file
*);
4673 // The maximum size of save/restore contents.
4674 static const unsigned int savres_max
= 218*4;
4677 savres_define(Symbol_table
* symtab
,
4679 unsigned int lo
, unsigned int hi
,
4680 unsigned char* write_ent(unsigned char*, int),
4681 unsigned char* write_tail(unsigned char*, int));
4683 unsigned char *contents_
;
4686 template<bool big_endian
>
4687 static unsigned char*
4688 savegpr0(unsigned char* p
, int r
)
4690 uint32_t insn
= std_0_1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8;
4691 write_insn
<big_endian
>(p
, insn
);
4695 template<bool big_endian
>
4696 static unsigned char*
4697 savegpr0_tail(unsigned char* p
, int r
)
4699 p
= savegpr0
<big_endian
>(p
, r
);
4700 uint32_t insn
= std_0_1
+ 16;
4701 write_insn
<big_endian
>(p
, insn
);
4703 write_insn
<big_endian
>(p
, blr
);
4707 template<bool big_endian
>
4708 static unsigned char*
4709 restgpr0(unsigned char* p
, int r
)
4711 uint32_t insn
= ld_0_1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8;
4712 write_insn
<big_endian
>(p
, insn
);
4716 template<bool big_endian
>
4717 static unsigned char*
4718 restgpr0_tail(unsigned char* p
, int r
)
4720 uint32_t insn
= ld_0_1
+ 16;
4721 write_insn
<big_endian
>(p
, insn
);
4723 p
= restgpr0
<big_endian
>(p
, r
);
4724 write_insn
<big_endian
>(p
, mtlr_0
);
4728 p
= restgpr0
<big_endian
>(p
, 30);
4729 p
= restgpr0
<big_endian
>(p
, 31);
4731 write_insn
<big_endian
>(p
, blr
);
4735 template<bool big_endian
>
4736 static unsigned char*
4737 savegpr1(unsigned char* p
, int r
)
4739 uint32_t insn
= std_0_12
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8;
4740 write_insn
<big_endian
>(p
, insn
);
4744 template<bool big_endian
>
4745 static unsigned char*
4746 savegpr1_tail(unsigned char* p
, int r
)
4748 p
= savegpr1
<big_endian
>(p
, r
);
4749 write_insn
<big_endian
>(p
, blr
);
4753 template<bool big_endian
>
4754 static unsigned char*
4755 restgpr1(unsigned char* p
, int r
)
4757 uint32_t insn
= ld_0_12
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8;
4758 write_insn
<big_endian
>(p
, insn
);
4762 template<bool big_endian
>
4763 static unsigned char*
4764 restgpr1_tail(unsigned char* p
, int r
)
4766 p
= restgpr1
<big_endian
>(p
, r
);
4767 write_insn
<big_endian
>(p
, blr
);
4771 template<bool big_endian
>
4772 static unsigned char*
4773 savefpr(unsigned char* p
, int r
)
4775 uint32_t insn
= stfd_0_1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8;
4776 write_insn
<big_endian
>(p
, insn
);
4780 template<bool big_endian
>
4781 static unsigned char*
4782 savefpr0_tail(unsigned char* p
, int r
)
4784 p
= savefpr
<big_endian
>(p
, r
);
4785 write_insn
<big_endian
>(p
, std_0_1
+ 16);
4787 write_insn
<big_endian
>(p
, blr
);
4791 template<bool big_endian
>
4792 static unsigned char*
4793 restfpr(unsigned char* p
, int r
)
4795 uint32_t insn
= lfd_0_1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8;
4796 write_insn
<big_endian
>(p
, insn
);
4800 template<bool big_endian
>
4801 static unsigned char*
4802 restfpr0_tail(unsigned char* p
, int r
)
4804 write_insn
<big_endian
>(p
, ld_0_1
+ 16);
4806 p
= restfpr
<big_endian
>(p
, r
);
4807 write_insn
<big_endian
>(p
, mtlr_0
);
4811 p
= restfpr
<big_endian
>(p
, 30);
4812 p
= restfpr
<big_endian
>(p
, 31);
4814 write_insn
<big_endian
>(p
, blr
);
4818 template<bool big_endian
>
4819 static unsigned char*
4820 savefpr1_tail(unsigned char* p
, int r
)
4822 p
= savefpr
<big_endian
>(p
, r
);
4823 write_insn
<big_endian
>(p
, blr
);
4827 template<bool big_endian
>
4828 static unsigned char*
4829 restfpr1_tail(unsigned char* p
, int r
)
4831 p
= restfpr
<big_endian
>(p
, r
);
4832 write_insn
<big_endian
>(p
, blr
);
4836 template<bool big_endian
>
4837 static unsigned char*
4838 savevr(unsigned char* p
, int r
)
4840 uint32_t insn
= li_12_0
+ (1 << 16) - (32 - r
) * 16;
4841 write_insn
<big_endian
>(p
, insn
);
4843 insn
= stvx_0_12_0
+ (r
<< 21);
4844 write_insn
<big_endian
>(p
, insn
);
4848 template<bool big_endian
>
4849 static unsigned char*
4850 savevr_tail(unsigned char* p
, int r
)
4852 p
= savevr
<big_endian
>(p
, r
);
4853 write_insn
<big_endian
>(p
, blr
);
4857 template<bool big_endian
>
4858 static unsigned char*
4859 restvr(unsigned char* p
, int r
)
4861 uint32_t insn
= li_12_0
+ (1 << 16) - (32 - r
) * 16;
4862 write_insn
<big_endian
>(p
, insn
);
4864 insn
= lvx_0_12_0
+ (r
<< 21);
4865 write_insn
<big_endian
>(p
, insn
);
4869 template<bool big_endian
>
4870 static unsigned char*
4871 restvr_tail(unsigned char* p
, int r
)
4873 p
= restvr
<big_endian
>(p
, r
);
4874 write_insn
<big_endian
>(p
, blr
);
4879 template<int size
, bool big_endian
>
4880 Output_data_save_res
<size
, big_endian
>::Output_data_save_res(
4881 Symbol_table
* symtab
)
4882 : Output_section_data_build(4),
4885 this->savres_define(symtab
,
4886 "_savegpr0_", 14, 31,
4887 savegpr0
<big_endian
>, savegpr0_tail
<big_endian
>);
4888 this->savres_define(symtab
,
4889 "_restgpr0_", 14, 29,
4890 restgpr0
<big_endian
>, restgpr0_tail
<big_endian
>);
4891 this->savres_define(symtab
,
4892 "_restgpr0_", 30, 31,
4893 restgpr0
<big_endian
>, restgpr0_tail
<big_endian
>);
4894 this->savres_define(symtab
,
4895 "_savegpr1_", 14, 31,
4896 savegpr1
<big_endian
>, savegpr1_tail
<big_endian
>);
4897 this->savres_define(symtab
,
4898 "_restgpr1_", 14, 31,
4899 restgpr1
<big_endian
>, restgpr1_tail
<big_endian
>);
4900 this->savres_define(symtab
,
4901 "_savefpr_", 14, 31,
4902 savefpr
<big_endian
>, savefpr0_tail
<big_endian
>);
4903 this->savres_define(symtab
,
4904 "_restfpr_", 14, 29,
4905 restfpr
<big_endian
>, restfpr0_tail
<big_endian
>);
4906 this->savres_define(symtab
,
4907 "_restfpr_", 30, 31,
4908 restfpr
<big_endian
>, restfpr0_tail
<big_endian
>);
4909 this->savres_define(symtab
,
4911 savefpr
<big_endian
>, savefpr1_tail
<big_endian
>);
4912 this->savres_define(symtab
,
4914 restfpr
<big_endian
>, restfpr1_tail
<big_endian
>);
4915 this->savres_define(symtab
,
4917 savevr
<big_endian
>, savevr_tail
<big_endian
>);
4918 this->savres_define(symtab
,
4920 restvr
<big_endian
>, restvr_tail
<big_endian
>);
4923 template<int size
, bool big_endian
>
4925 Output_data_save_res
<size
, big_endian
>::savres_define(
4926 Symbol_table
* symtab
,
4928 unsigned int lo
, unsigned int hi
,
4929 unsigned char* write_ent(unsigned char*, int),
4930 unsigned char* write_tail(unsigned char*, int))
4932 size_t len
= strlen(name
);
4933 bool writing
= false;
4936 memcpy(sym
, name
, len
);
4939 for (unsigned int i
= lo
; i
<= hi
; i
++)
4941 sym
[len
+ 0] = i
/ 10 + '0';
4942 sym
[len
+ 1] = i
% 10 + '0';
4943 Symbol
* gsym
= symtab
->lookup(sym
);
4944 bool refd
= gsym
!= NULL
&& gsym
->is_undefined();
4945 writing
= writing
|| refd
;
4948 if (this->contents_
== NULL
)
4949 this->contents_
= new unsigned char[this->savres_max
];
4951 section_size_type value
= this->current_data_size();
4952 unsigned char* p
= this->contents_
+ value
;
4954 p
= write_ent(p
, i
);
4956 p
= write_tail(p
, i
);
4957 section_size_type cur_size
= p
- this->contents_
;
4958 this->set_current_data_size(cur_size
);
4960 symtab
->define_in_output_data(sym
, NULL
, Symbol_table::PREDEFINED
,
4961 this, value
, cur_size
- value
,
4962 elfcpp::STT_FUNC
, elfcpp::STB_GLOBAL
,
4963 elfcpp::STV_HIDDEN
, 0, false, false);
4968 // Write out save/restore.
4970 template<int size
, bool big_endian
>
4972 Output_data_save_res
<size
, big_endian
>::do_write(Output_file
* of
)
4974 const section_size_type off
= this->offset();
4975 const section_size_type oview_size
=
4976 convert_to_section_size_type(this->data_size());
4977 unsigned char* const oview
= of
->get_output_view(off
, oview_size
);
4978 memcpy(oview
, this->contents_
, oview_size
);
4979 of
->write_output_view(off
, oview_size
, oview
);
4983 // Create the glink section.
4985 template<int size
, bool big_endian
>
4987 Target_powerpc
<size
, big_endian
>::make_glink_section(Layout
* layout
)
4989 if (this->glink_
== NULL
)
4991 this->glink_
= new Output_data_glink
<size
, big_endian
>(this);
4992 this->glink_
->add_eh_frame(layout
);
4993 layout
->add_output_section_data(".text", elfcpp::SHT_PROGBITS
,
4994 elfcpp::SHF_ALLOC
| elfcpp::SHF_EXECINSTR
,
4995 this->glink_
, ORDER_TEXT
, false);
4999 // Create a PLT entry for a global symbol.
5001 template<int size
, bool big_endian
>
5003 Target_powerpc
<size
, big_endian
>::make_plt_entry(Symbol_table
* symtab
,
5007 if (gsym
->type() == elfcpp::STT_GNU_IFUNC
5008 && gsym
->can_use_relative_reloc(false))
5010 if (this->iplt_
== NULL
)
5011 this->make_iplt_section(symtab
, layout
);
5012 this->iplt_
->add_ifunc_entry(gsym
);
5016 if (this->plt_
== NULL
)
5017 this->make_plt_section(symtab
, layout
);
5018 this->plt_
->add_entry(gsym
);
5022 // Make a PLT entry for a local STT_GNU_IFUNC symbol.
5024 template<int size
, bool big_endian
>
5026 Target_powerpc
<size
, big_endian
>::make_local_ifunc_plt_entry(
5027 Symbol_table
* symtab
,
5029 Sized_relobj_file
<size
, big_endian
>* relobj
,
5032 if (this->iplt_
== NULL
)
5033 this->make_iplt_section(symtab
, layout
);
5034 this->iplt_
->add_local_ifunc_entry(relobj
, r_sym
);
5037 // Return the number of entries in the PLT.
5039 template<int size
, bool big_endian
>
5041 Target_powerpc
<size
, big_endian
>::plt_entry_count() const
5043 if (this->plt_
== NULL
)
5045 return this->plt_
->entry_count();
5048 // Create a GOT entry for local dynamic __tls_get_addr calls.
5050 template<int size
, bool big_endian
>
5052 Target_powerpc
<size
, big_endian
>::tlsld_got_offset(
5053 Symbol_table
* symtab
,
5055 Sized_relobj_file
<size
, big_endian
>* object
)
5057 if (this->tlsld_got_offset_
== -1U)
5059 gold_assert(symtab
!= NULL
&& layout
!= NULL
&& object
!= NULL
);
5060 Reloc_section
* rela_dyn
= this->rela_dyn_section(layout
);
5061 Output_data_got_powerpc
<size
, big_endian
>* got
5062 = this->got_section(symtab
, layout
);
5063 unsigned int got_offset
= got
->add_constant_pair(0, 0);
5064 rela_dyn
->add_local(object
, 0, elfcpp::R_POWERPC_DTPMOD
, got
,
5066 this->tlsld_got_offset_
= got_offset
;
5068 return this->tlsld_got_offset_
;
5071 // Get the Reference_flags for a particular relocation.
5073 template<int size
, bool big_endian
>
5075 Target_powerpc
<size
, big_endian
>::Scan::get_reference_flags(
5076 unsigned int r_type
,
5077 const Target_powerpc
* target
)
5083 case elfcpp::R_POWERPC_NONE
:
5084 case elfcpp::R_POWERPC_GNU_VTINHERIT
:
5085 case elfcpp::R_POWERPC_GNU_VTENTRY
:
5086 case elfcpp::R_PPC64_TOC
:
5087 // No symbol reference.
5090 case elfcpp::R_PPC64_ADDR64
:
5091 case elfcpp::R_PPC64_UADDR64
:
5092 case elfcpp::R_POWERPC_ADDR32
:
5093 case elfcpp::R_POWERPC_UADDR32
:
5094 case elfcpp::R_POWERPC_ADDR16
:
5095 case elfcpp::R_POWERPC_UADDR16
:
5096 case elfcpp::R_POWERPC_ADDR16_LO
:
5097 case elfcpp::R_POWERPC_ADDR16_HI
:
5098 case elfcpp::R_POWERPC_ADDR16_HA
:
5099 ref
= Symbol::ABSOLUTE_REF
;
5102 case elfcpp::R_POWERPC_ADDR24
:
5103 case elfcpp::R_POWERPC_ADDR14
:
5104 case elfcpp::R_POWERPC_ADDR14_BRTAKEN
:
5105 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN
:
5106 ref
= Symbol::FUNCTION_CALL
| Symbol::ABSOLUTE_REF
;
5109 case elfcpp::R_PPC64_REL64
:
5110 case elfcpp::R_POWERPC_REL32
:
5111 case elfcpp::R_PPC_LOCAL24PC
:
5112 case elfcpp::R_POWERPC_REL16
:
5113 case elfcpp::R_POWERPC_REL16_LO
:
5114 case elfcpp::R_POWERPC_REL16_HI
:
5115 case elfcpp::R_POWERPC_REL16_HA
:
5116 ref
= Symbol::RELATIVE_REF
;
5119 case elfcpp::R_POWERPC_REL24
:
5120 case elfcpp::R_PPC_PLTREL24
:
5121 case elfcpp::R_POWERPC_REL14
:
5122 case elfcpp::R_POWERPC_REL14_BRTAKEN
:
5123 case elfcpp::R_POWERPC_REL14_BRNTAKEN
:
5124 ref
= Symbol::FUNCTION_CALL
| Symbol::RELATIVE_REF
;
5127 case elfcpp::R_POWERPC_GOT16
:
5128 case elfcpp::R_POWERPC_GOT16_LO
:
5129 case elfcpp::R_POWERPC_GOT16_HI
:
5130 case elfcpp::R_POWERPC_GOT16_HA
:
5131 case elfcpp::R_PPC64_GOT16_DS
:
5132 case elfcpp::R_PPC64_GOT16_LO_DS
:
5133 case elfcpp::R_PPC64_TOC16
:
5134 case elfcpp::R_PPC64_TOC16_LO
:
5135 case elfcpp::R_PPC64_TOC16_HI
:
5136 case elfcpp::R_PPC64_TOC16_HA
:
5137 case elfcpp::R_PPC64_TOC16_DS
:
5138 case elfcpp::R_PPC64_TOC16_LO_DS
:
5140 ref
= Symbol::ABSOLUTE_REF
;
5143 case elfcpp::R_POWERPC_GOT_TPREL16
:
5144 case elfcpp::R_POWERPC_TLS
:
5145 ref
= Symbol::TLS_REF
;
5148 case elfcpp::R_POWERPC_COPY
:
5149 case elfcpp::R_POWERPC_GLOB_DAT
:
5150 case elfcpp::R_POWERPC_JMP_SLOT
:
5151 case elfcpp::R_POWERPC_RELATIVE
:
5152 case elfcpp::R_POWERPC_DTPMOD
:
5154 // Not expected. We will give an error later.
5158 if (size
== 64 && target
->abiversion() < 2)
5159 ref
|= Symbol::FUNC_DESC_ABI
;
5163 // Report an unsupported relocation against a local symbol.
5165 template<int size
, bool big_endian
>
5167 Target_powerpc
<size
, big_endian
>::Scan::unsupported_reloc_local(
5168 Sized_relobj_file
<size
, big_endian
>* object
,
5169 unsigned int r_type
)
5171 gold_error(_("%s: unsupported reloc %u against local symbol"),
5172 object
->name().c_str(), r_type
);
5175 // We are about to emit a dynamic relocation of type R_TYPE. If the
5176 // dynamic linker does not support it, issue an error.
5178 template<int size
, bool big_endian
>
5180 Target_powerpc
<size
, big_endian
>::Scan::check_non_pic(Relobj
* object
,
5181 unsigned int r_type
)
5183 gold_assert(r_type
!= elfcpp::R_POWERPC_NONE
);
5185 // These are the relocation types supported by glibc for both 32-bit
5186 // and 64-bit powerpc.
5189 case elfcpp::R_POWERPC_NONE
:
5190 case elfcpp::R_POWERPC_RELATIVE
:
5191 case elfcpp::R_POWERPC_GLOB_DAT
:
5192 case elfcpp::R_POWERPC_DTPMOD
:
5193 case elfcpp::R_POWERPC_DTPREL
:
5194 case elfcpp::R_POWERPC_TPREL
:
5195 case elfcpp::R_POWERPC_JMP_SLOT
:
5196 case elfcpp::R_POWERPC_COPY
:
5197 case elfcpp::R_POWERPC_IRELATIVE
:
5198 case elfcpp::R_POWERPC_ADDR32
:
5199 case elfcpp::R_POWERPC_UADDR32
:
5200 case elfcpp::R_POWERPC_ADDR24
:
5201 case elfcpp::R_POWERPC_ADDR16
:
5202 case elfcpp::R_POWERPC_UADDR16
:
5203 case elfcpp::R_POWERPC_ADDR16_LO
:
5204 case elfcpp::R_POWERPC_ADDR16_HI
:
5205 case elfcpp::R_POWERPC_ADDR16_HA
:
5206 case elfcpp::R_POWERPC_ADDR14
:
5207 case elfcpp::R_POWERPC_ADDR14_BRTAKEN
:
5208 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN
:
5209 case elfcpp::R_POWERPC_REL32
:
5210 case elfcpp::R_POWERPC_REL24
:
5211 case elfcpp::R_POWERPC_TPREL16
:
5212 case elfcpp::R_POWERPC_TPREL16_LO
:
5213 case elfcpp::R_POWERPC_TPREL16_HI
:
5214 case elfcpp::R_POWERPC_TPREL16_HA
:
5225 // These are the relocation types supported only on 64-bit.
5226 case elfcpp::R_PPC64_ADDR64
:
5227 case elfcpp::R_PPC64_UADDR64
:
5228 case elfcpp::R_PPC64_JMP_IREL
:
5229 case elfcpp::R_PPC64_ADDR16_DS
:
5230 case elfcpp::R_PPC64_ADDR16_LO_DS
:
5231 case elfcpp::R_PPC64_ADDR16_HIGH
:
5232 case elfcpp::R_PPC64_ADDR16_HIGHA
:
5233 case elfcpp::R_PPC64_ADDR16_HIGHER
:
5234 case elfcpp::R_PPC64_ADDR16_HIGHEST
:
5235 case elfcpp::R_PPC64_ADDR16_HIGHERA
:
5236 case elfcpp::R_PPC64_ADDR16_HIGHESTA
:
5237 case elfcpp::R_PPC64_REL64
:
5238 case elfcpp::R_POWERPC_ADDR30
:
5239 case elfcpp::R_PPC64_TPREL16_DS
:
5240 case elfcpp::R_PPC64_TPREL16_LO_DS
:
5241 case elfcpp::R_PPC64_TPREL16_HIGH
:
5242 case elfcpp::R_PPC64_TPREL16_HIGHA
:
5243 case elfcpp::R_PPC64_TPREL16_HIGHER
:
5244 case elfcpp::R_PPC64_TPREL16_HIGHEST
:
5245 case elfcpp::R_PPC64_TPREL16_HIGHERA
:
5246 case elfcpp::R_PPC64_TPREL16_HIGHESTA
:
5257 // These are the relocation types supported only on 32-bit.
5258 // ??? glibc ld.so doesn't need to support these.
5259 case elfcpp::R_POWERPC_DTPREL16
:
5260 case elfcpp::R_POWERPC_DTPREL16_LO
:
5261 case elfcpp::R_POWERPC_DTPREL16_HI
:
5262 case elfcpp::R_POWERPC_DTPREL16_HA
:
5270 // This prevents us from issuing more than one error per reloc
5271 // section. But we can still wind up issuing more than one
5272 // error per object file.
5273 if (this->issued_non_pic_error_
)
5275 gold_assert(parameters
->options().output_is_position_independent());
5276 object
->error(_("requires unsupported dynamic reloc; "
5277 "recompile with -fPIC"));
5278 this->issued_non_pic_error_
= true;
5282 // Return whether we need to make a PLT entry for a relocation of the
5283 // given type against a STT_GNU_IFUNC symbol.
5285 template<int size
, bool big_endian
>
5287 Target_powerpc
<size
, big_endian
>::Scan::reloc_needs_plt_for_ifunc(
5288 Target_powerpc
<size
, big_endian
>* target
,
5289 Sized_relobj_file
<size
, big_endian
>* object
,
5290 unsigned int r_type
,
5293 // In non-pic code any reference will resolve to the plt call stub
5294 // for the ifunc symbol.
5295 if ((size
== 32 || target
->abiversion() >= 2)
5296 && !parameters
->options().output_is_position_independent())
5301 // Word size refs from data sections are OK, but don't need a PLT entry.
5302 case elfcpp::R_POWERPC_ADDR32
:
5303 case elfcpp::R_POWERPC_UADDR32
:
5308 case elfcpp::R_PPC64_ADDR64
:
5309 case elfcpp::R_PPC64_UADDR64
:
5314 // GOT refs are good, but also don't need a PLT entry.
5315 case elfcpp::R_POWERPC_GOT16
:
5316 case elfcpp::R_POWERPC_GOT16_LO
:
5317 case elfcpp::R_POWERPC_GOT16_HI
:
5318 case elfcpp::R_POWERPC_GOT16_HA
:
5319 case elfcpp::R_PPC64_GOT16_DS
:
5320 case elfcpp::R_PPC64_GOT16_LO_DS
:
5323 // Function calls are good, and these do need a PLT entry.
5324 case elfcpp::R_POWERPC_ADDR24
:
5325 case elfcpp::R_POWERPC_ADDR14
:
5326 case elfcpp::R_POWERPC_ADDR14_BRTAKEN
:
5327 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN
:
5328 case elfcpp::R_POWERPC_REL24
:
5329 case elfcpp::R_PPC_PLTREL24
:
5330 case elfcpp::R_POWERPC_REL14
:
5331 case elfcpp::R_POWERPC_REL14_BRTAKEN
:
5332 case elfcpp::R_POWERPC_REL14_BRNTAKEN
:
5339 // Anything else is a problem.
5340 // If we are building a static executable, the libc startup function
5341 // responsible for applying indirect function relocations is going
5342 // to complain about the reloc type.
5343 // If we are building a dynamic executable, we will have a text
5344 // relocation. The dynamic loader will set the text segment
5345 // writable and non-executable to apply text relocations. So we'll
5346 // segfault when trying to run the indirection function to resolve
5349 gold_error(_("%s: unsupported reloc %u for IFUNC symbol"),
5350 object
->name().c_str(), r_type
);
5354 // Scan a relocation for a local symbol.
5356 template<int size
, bool big_endian
>
5358 Target_powerpc
<size
, big_endian
>::Scan::local(
5359 Symbol_table
* symtab
,
5361 Target_powerpc
<size
, big_endian
>* target
,
5362 Sized_relobj_file
<size
, big_endian
>* object
,
5363 unsigned int data_shndx
,
5364 Output_section
* output_section
,
5365 const elfcpp::Rela
<size
, big_endian
>& reloc
,
5366 unsigned int r_type
,
5367 const elfcpp::Sym
<size
, big_endian
>& lsym
,
5370 this->maybe_skip_tls_get_addr_call(r_type
, NULL
);
5372 if ((size
== 64 && r_type
== elfcpp::R_PPC64_TLSGD
)
5373 || (size
== 32 && r_type
== elfcpp::R_PPC_TLSGD
))
5375 this->expect_tls_get_addr_call();
5376 const tls::Tls_optimization tls_type
= target
->optimize_tls_gd(true);
5377 if (tls_type
!= tls::TLSOPT_NONE
)
5378 this->skip_next_tls_get_addr_call();
5380 else if ((size
== 64 && r_type
== elfcpp::R_PPC64_TLSLD
)
5381 || (size
== 32 && r_type
== elfcpp::R_PPC_TLSLD
))
5383 this->expect_tls_get_addr_call();
5384 const tls::Tls_optimization tls_type
= target
->optimize_tls_ld();
5385 if (tls_type
!= tls::TLSOPT_NONE
)
5386 this->skip_next_tls_get_addr_call();
5389 Powerpc_relobj
<size
, big_endian
>* ppc_object
5390 = static_cast<Powerpc_relobj
<size
, big_endian
>*>(object
);
5395 && data_shndx
== ppc_object
->opd_shndx()
5396 && r_type
== elfcpp::R_PPC64_ADDR64
)
5397 ppc_object
->set_opd_discard(reloc
.get_r_offset());
5401 // A local STT_GNU_IFUNC symbol may require a PLT entry.
5402 bool is_ifunc
= lsym
.get_st_type() == elfcpp::STT_GNU_IFUNC
;
5403 if (is_ifunc
&& this->reloc_needs_plt_for_ifunc(target
, object
, r_type
, true))
5405 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(reloc
.get_r_info());
5406 target
->push_branch(ppc_object
, data_shndx
, reloc
.get_r_offset(),
5407 r_type
, r_sym
, reloc
.get_r_addend());
5408 target
->make_local_ifunc_plt_entry(symtab
, layout
, object
, r_sym
);
5413 case elfcpp::R_POWERPC_NONE
:
5414 case elfcpp::R_POWERPC_GNU_VTINHERIT
:
5415 case elfcpp::R_POWERPC_GNU_VTENTRY
:
5416 case elfcpp::R_PPC64_TOCSAVE
:
5417 case elfcpp::R_POWERPC_TLS
:
5420 case elfcpp::R_PPC64_TOC
:
5422 Output_data_got_powerpc
<size
, big_endian
>* got
5423 = target
->got_section(symtab
, layout
);
5424 if (parameters
->options().output_is_position_independent())
5426 Address off
= reloc
.get_r_offset();
5428 && target
->abiversion() < 2
5429 && data_shndx
== ppc_object
->opd_shndx()
5430 && ppc_object
->get_opd_discard(off
- 8))
5433 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
5434 Powerpc_relobj
<size
, big_endian
>* symobj
= ppc_object
;
5435 rela_dyn
->add_output_section_relative(got
->output_section(),
5436 elfcpp::R_POWERPC_RELATIVE
,
5438 object
, data_shndx
, off
,
5439 symobj
->toc_base_offset());
5444 case elfcpp::R_PPC64_ADDR64
:
5445 case elfcpp::R_PPC64_UADDR64
:
5446 case elfcpp::R_POWERPC_ADDR32
:
5447 case elfcpp::R_POWERPC_UADDR32
:
5448 case elfcpp::R_POWERPC_ADDR24
:
5449 case elfcpp::R_POWERPC_ADDR16
:
5450 case elfcpp::R_POWERPC_ADDR16_LO
:
5451 case elfcpp::R_POWERPC_ADDR16_HI
:
5452 case elfcpp::R_POWERPC_ADDR16_HA
:
5453 case elfcpp::R_POWERPC_UADDR16
:
5454 case elfcpp::R_PPC64_ADDR16_HIGH
:
5455 case elfcpp::R_PPC64_ADDR16_HIGHA
:
5456 case elfcpp::R_PPC64_ADDR16_HIGHER
:
5457 case elfcpp::R_PPC64_ADDR16_HIGHERA
:
5458 case elfcpp::R_PPC64_ADDR16_HIGHEST
:
5459 case elfcpp::R_PPC64_ADDR16_HIGHESTA
:
5460 case elfcpp::R_PPC64_ADDR16_DS
:
5461 case elfcpp::R_PPC64_ADDR16_LO_DS
:
5462 case elfcpp::R_POWERPC_ADDR14
:
5463 case elfcpp::R_POWERPC_ADDR14_BRTAKEN
:
5464 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN
:
5465 // If building a shared library (or a position-independent
5466 // executable), we need to create a dynamic relocation for
5468 if (parameters
->options().output_is_position_independent()
5469 || (size
== 64 && is_ifunc
&& target
->abiversion() < 2))
5471 Reloc_section
* rela_dyn
= target
->rela_dyn_section(symtab
, layout
,
5473 if ((size
== 32 && r_type
== elfcpp::R_POWERPC_ADDR32
)
5474 || (size
== 64 && r_type
== elfcpp::R_PPC64_ADDR64
))
5476 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(reloc
.get_r_info());
5477 unsigned int dynrel
= (is_ifunc
? elfcpp::R_POWERPC_IRELATIVE
5478 : elfcpp::R_POWERPC_RELATIVE
);
5479 rela_dyn
->add_local_relative(object
, r_sym
, dynrel
,
5480 output_section
, data_shndx
,
5481 reloc
.get_r_offset(),
5482 reloc
.get_r_addend(), false);
5486 check_non_pic(object
, r_type
);
5487 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(reloc
.get_r_info());
5488 rela_dyn
->add_local(object
, r_sym
, r_type
, output_section
,
5489 data_shndx
, reloc
.get_r_offset(),
5490 reloc
.get_r_addend());
5495 case elfcpp::R_POWERPC_REL24
:
5496 case elfcpp::R_PPC_PLTREL24
:
5497 case elfcpp::R_PPC_LOCAL24PC
:
5498 case elfcpp::R_POWERPC_REL14
:
5499 case elfcpp::R_POWERPC_REL14_BRTAKEN
:
5500 case elfcpp::R_POWERPC_REL14_BRNTAKEN
:
5502 target
->push_branch(ppc_object
, data_shndx
, reloc
.get_r_offset(),
5503 r_type
, elfcpp::elf_r_sym
<size
>(reloc
.get_r_info()),
5504 reloc
.get_r_addend());
5507 case elfcpp::R_PPC64_REL64
:
5508 case elfcpp::R_POWERPC_REL32
:
5509 case elfcpp::R_POWERPC_REL16
:
5510 case elfcpp::R_POWERPC_REL16_LO
:
5511 case elfcpp::R_POWERPC_REL16_HI
:
5512 case elfcpp::R_POWERPC_REL16_HA
:
5513 case elfcpp::R_POWERPC_SECTOFF
:
5514 case elfcpp::R_POWERPC_SECTOFF_LO
:
5515 case elfcpp::R_POWERPC_SECTOFF_HI
:
5516 case elfcpp::R_POWERPC_SECTOFF_HA
:
5517 case elfcpp::R_PPC64_SECTOFF_DS
:
5518 case elfcpp::R_PPC64_SECTOFF_LO_DS
:
5519 case elfcpp::R_POWERPC_TPREL16
:
5520 case elfcpp::R_POWERPC_TPREL16_LO
:
5521 case elfcpp::R_POWERPC_TPREL16_HI
:
5522 case elfcpp::R_POWERPC_TPREL16_HA
:
5523 case elfcpp::R_PPC64_TPREL16_DS
:
5524 case elfcpp::R_PPC64_TPREL16_LO_DS
:
5525 case elfcpp::R_PPC64_TPREL16_HIGH
:
5526 case elfcpp::R_PPC64_TPREL16_HIGHA
:
5527 case elfcpp::R_PPC64_TPREL16_HIGHER
:
5528 case elfcpp::R_PPC64_TPREL16_HIGHERA
:
5529 case elfcpp::R_PPC64_TPREL16_HIGHEST
:
5530 case elfcpp::R_PPC64_TPREL16_HIGHESTA
:
5531 case elfcpp::R_POWERPC_DTPREL16
:
5532 case elfcpp::R_POWERPC_DTPREL16_LO
:
5533 case elfcpp::R_POWERPC_DTPREL16_HI
:
5534 case elfcpp::R_POWERPC_DTPREL16_HA
:
5535 case elfcpp::R_PPC64_DTPREL16_DS
:
5536 case elfcpp::R_PPC64_DTPREL16_LO_DS
:
5537 case elfcpp::R_PPC64_DTPREL16_HIGH
:
5538 case elfcpp::R_PPC64_DTPREL16_HIGHA
:
5539 case elfcpp::R_PPC64_DTPREL16_HIGHER
:
5540 case elfcpp::R_PPC64_DTPREL16_HIGHERA
:
5541 case elfcpp::R_PPC64_DTPREL16_HIGHEST
:
5542 case elfcpp::R_PPC64_DTPREL16_HIGHESTA
:
5543 case elfcpp::R_PPC64_TLSGD
:
5544 case elfcpp::R_PPC64_TLSLD
:
5545 case elfcpp::R_PPC64_ADDR64_LOCAL
:
5548 case elfcpp::R_POWERPC_GOT16
:
5549 case elfcpp::R_POWERPC_GOT16_LO
:
5550 case elfcpp::R_POWERPC_GOT16_HI
:
5551 case elfcpp::R_POWERPC_GOT16_HA
:
5552 case elfcpp::R_PPC64_GOT16_DS
:
5553 case elfcpp::R_PPC64_GOT16_LO_DS
:
5555 // The symbol requires a GOT entry.
5556 Output_data_got_powerpc
<size
, big_endian
>* got
5557 = target
->got_section(symtab
, layout
);
5558 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(reloc
.get_r_info());
5560 if (!parameters
->options().output_is_position_independent())
5562 if ((size
== 32 && is_ifunc
)
5563 || (size
== 64 && target
->abiversion() >= 2))
5564 got
->add_local_plt(object
, r_sym
, GOT_TYPE_STANDARD
);
5566 got
->add_local(object
, r_sym
, GOT_TYPE_STANDARD
);
5568 else if (!object
->local_has_got_offset(r_sym
, GOT_TYPE_STANDARD
))
5570 // If we are generating a shared object or a pie, this
5571 // symbol's GOT entry will be set by a dynamic relocation.
5573 off
= got
->add_constant(0);
5574 object
->set_local_got_offset(r_sym
, GOT_TYPE_STANDARD
, off
);
5576 Reloc_section
* rela_dyn
= target
->rela_dyn_section(symtab
, layout
,
5578 unsigned int dynrel
= (is_ifunc
? elfcpp::R_POWERPC_IRELATIVE
5579 : elfcpp::R_POWERPC_RELATIVE
);
5580 rela_dyn
->add_local_relative(object
, r_sym
, dynrel
,
5581 got
, off
, 0, false);
5586 case elfcpp::R_PPC64_TOC16
:
5587 case elfcpp::R_PPC64_TOC16_LO
:
5588 case elfcpp::R_PPC64_TOC16_HI
:
5589 case elfcpp::R_PPC64_TOC16_HA
:
5590 case elfcpp::R_PPC64_TOC16_DS
:
5591 case elfcpp::R_PPC64_TOC16_LO_DS
:
5592 // We need a GOT section.
5593 target
->got_section(symtab
, layout
);
5596 case elfcpp::R_POWERPC_GOT_TLSGD16
:
5597 case elfcpp::R_POWERPC_GOT_TLSGD16_LO
:
5598 case elfcpp::R_POWERPC_GOT_TLSGD16_HI
:
5599 case elfcpp::R_POWERPC_GOT_TLSGD16_HA
:
5601 const tls::Tls_optimization tls_type
= target
->optimize_tls_gd(true);
5602 if (tls_type
== tls::TLSOPT_NONE
)
5604 Output_data_got_powerpc
<size
, big_endian
>* got
5605 = target
->got_section(symtab
, layout
);
5606 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(reloc
.get_r_info());
5607 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
5608 got
->add_local_tls_pair(object
, r_sym
, GOT_TYPE_TLSGD
,
5609 rela_dyn
, elfcpp::R_POWERPC_DTPMOD
);
5611 else if (tls_type
== tls::TLSOPT_TO_LE
)
5613 // no GOT relocs needed for Local Exec.
5620 case elfcpp::R_POWERPC_GOT_TLSLD16
:
5621 case elfcpp::R_POWERPC_GOT_TLSLD16_LO
:
5622 case elfcpp::R_POWERPC_GOT_TLSLD16_HI
:
5623 case elfcpp::R_POWERPC_GOT_TLSLD16_HA
:
5625 const tls::Tls_optimization tls_type
= target
->optimize_tls_ld();
5626 if (tls_type
== tls::TLSOPT_NONE
)
5627 target
->tlsld_got_offset(symtab
, layout
, object
);
5628 else if (tls_type
== tls::TLSOPT_TO_LE
)
5630 // no GOT relocs needed for Local Exec.
5631 if (parameters
->options().emit_relocs())
5633 Output_section
* os
= layout
->tls_segment()->first_section();
5634 gold_assert(os
!= NULL
);
5635 os
->set_needs_symtab_index();
5643 case elfcpp::R_POWERPC_GOT_DTPREL16
:
5644 case elfcpp::R_POWERPC_GOT_DTPREL16_LO
:
5645 case elfcpp::R_POWERPC_GOT_DTPREL16_HI
:
5646 case elfcpp::R_POWERPC_GOT_DTPREL16_HA
:
5648 Output_data_got_powerpc
<size
, big_endian
>* got
5649 = target
->got_section(symtab
, layout
);
5650 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(reloc
.get_r_info());
5651 got
->add_local_tls(object
, r_sym
, GOT_TYPE_DTPREL
);
5655 case elfcpp::R_POWERPC_GOT_TPREL16
:
5656 case elfcpp::R_POWERPC_GOT_TPREL16_LO
:
5657 case elfcpp::R_POWERPC_GOT_TPREL16_HI
:
5658 case elfcpp::R_POWERPC_GOT_TPREL16_HA
:
5660 const tls::Tls_optimization tls_type
= target
->optimize_tls_ie(true);
5661 if (tls_type
== tls::TLSOPT_NONE
)
5663 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(reloc
.get_r_info());
5664 if (!object
->local_has_got_offset(r_sym
, GOT_TYPE_TPREL
))
5666 Output_data_got_powerpc
<size
, big_endian
>* got
5667 = target
->got_section(symtab
, layout
);
5668 unsigned int off
= got
->add_constant(0);
5669 object
->set_local_got_offset(r_sym
, GOT_TYPE_TPREL
, off
);
5671 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
5672 rela_dyn
->add_symbolless_local_addend(object
, r_sym
,
5673 elfcpp::R_POWERPC_TPREL
,
5677 else if (tls_type
== tls::TLSOPT_TO_LE
)
5679 // no GOT relocs needed for Local Exec.
5687 unsupported_reloc_local(object
, r_type
);
5693 case elfcpp::R_POWERPC_GOT_TLSLD16
:
5694 case elfcpp::R_POWERPC_GOT_TLSGD16
:
5695 case elfcpp::R_POWERPC_GOT_TPREL16
:
5696 case elfcpp::R_POWERPC_GOT_DTPREL16
:
5697 case elfcpp::R_POWERPC_GOT16
:
5698 case elfcpp::R_PPC64_GOT16_DS
:
5699 case elfcpp::R_PPC64_TOC16
:
5700 case elfcpp::R_PPC64_TOC16_DS
:
5701 ppc_object
->set_has_small_toc_reloc();
5707 // Report an unsupported relocation against a global symbol.
5709 template<int size
, bool big_endian
>
5711 Target_powerpc
<size
, big_endian
>::Scan::unsupported_reloc_global(
5712 Sized_relobj_file
<size
, big_endian
>* object
,
5713 unsigned int r_type
,
5716 gold_error(_("%s: unsupported reloc %u against global symbol %s"),
5717 object
->name().c_str(), r_type
, gsym
->demangled_name().c_str());
5720 // Scan a relocation for a global symbol.
5722 template<int size
, bool big_endian
>
5724 Target_powerpc
<size
, big_endian
>::Scan::global(
5725 Symbol_table
* symtab
,
5727 Target_powerpc
<size
, big_endian
>* target
,
5728 Sized_relobj_file
<size
, big_endian
>* object
,
5729 unsigned int data_shndx
,
5730 Output_section
* output_section
,
5731 const elfcpp::Rela
<size
, big_endian
>& reloc
,
5732 unsigned int r_type
,
5735 if (this->maybe_skip_tls_get_addr_call(r_type
, gsym
) == Track_tls::SKIP
)
5738 if ((size
== 64 && r_type
== elfcpp::R_PPC64_TLSGD
)
5739 || (size
== 32 && r_type
== elfcpp::R_PPC_TLSGD
))
5741 this->expect_tls_get_addr_call();
5742 const bool final
= gsym
->final_value_is_known();
5743 const tls::Tls_optimization tls_type
= target
->optimize_tls_gd(final
);
5744 if (tls_type
!= tls::TLSOPT_NONE
)
5745 this->skip_next_tls_get_addr_call();
5747 else if ((size
== 64 && r_type
== elfcpp::R_PPC64_TLSLD
)
5748 || (size
== 32 && r_type
== elfcpp::R_PPC_TLSLD
))
5750 this->expect_tls_get_addr_call();
5751 const tls::Tls_optimization tls_type
= target
->optimize_tls_ld();
5752 if (tls_type
!= tls::TLSOPT_NONE
)
5753 this->skip_next_tls_get_addr_call();
5756 Powerpc_relobj
<size
, big_endian
>* ppc_object
5757 = static_cast<Powerpc_relobj
<size
, big_endian
>*>(object
);
5759 // A STT_GNU_IFUNC symbol may require a PLT entry.
5760 bool is_ifunc
= gsym
->type() == elfcpp::STT_GNU_IFUNC
;
5761 bool pushed_ifunc
= false;
5762 if (is_ifunc
&& this->reloc_needs_plt_for_ifunc(target
, object
, r_type
, true))
5764 target
->push_branch(ppc_object
, data_shndx
, reloc
.get_r_offset(),
5765 r_type
, elfcpp::elf_r_sym
<size
>(reloc
.get_r_info()),
5766 reloc
.get_r_addend());
5767 target
->make_plt_entry(symtab
, layout
, gsym
);
5768 pushed_ifunc
= true;
5773 case elfcpp::R_POWERPC_NONE
:
5774 case elfcpp::R_POWERPC_GNU_VTINHERIT
:
5775 case elfcpp::R_POWERPC_GNU_VTENTRY
:
5776 case elfcpp::R_PPC_LOCAL24PC
:
5777 case elfcpp::R_POWERPC_TLS
:
5780 case elfcpp::R_PPC64_TOC
:
5782 Output_data_got_powerpc
<size
, big_endian
>* got
5783 = target
->got_section(symtab
, layout
);
5784 if (parameters
->options().output_is_position_independent())
5786 Address off
= reloc
.get_r_offset();
5788 && data_shndx
== ppc_object
->opd_shndx()
5789 && ppc_object
->get_opd_discard(off
- 8))
5792 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
5793 Powerpc_relobj
<size
, big_endian
>* symobj
= ppc_object
;
5794 if (data_shndx
!= ppc_object
->opd_shndx())
5795 symobj
= static_cast
5796 <Powerpc_relobj
<size
, big_endian
>*>(gsym
->object());
5797 rela_dyn
->add_output_section_relative(got
->output_section(),
5798 elfcpp::R_POWERPC_RELATIVE
,
5800 object
, data_shndx
, off
,
5801 symobj
->toc_base_offset());
5806 case elfcpp::R_PPC64_ADDR64
:
5808 && target
->abiversion() < 2
5809 && data_shndx
== ppc_object
->opd_shndx()
5810 && (gsym
->is_defined_in_discarded_section()
5811 || gsym
->object() != object
))
5813 ppc_object
->set_opd_discard(reloc
.get_r_offset());
5817 case elfcpp::R_PPC64_UADDR64
:
5818 case elfcpp::R_POWERPC_ADDR32
:
5819 case elfcpp::R_POWERPC_UADDR32
:
5820 case elfcpp::R_POWERPC_ADDR24
:
5821 case elfcpp::R_POWERPC_ADDR16
:
5822 case elfcpp::R_POWERPC_ADDR16_LO
:
5823 case elfcpp::R_POWERPC_ADDR16_HI
:
5824 case elfcpp::R_POWERPC_ADDR16_HA
:
5825 case elfcpp::R_POWERPC_UADDR16
:
5826 case elfcpp::R_PPC64_ADDR16_HIGH
:
5827 case elfcpp::R_PPC64_ADDR16_HIGHA
:
5828 case elfcpp::R_PPC64_ADDR16_HIGHER
:
5829 case elfcpp::R_PPC64_ADDR16_HIGHERA
:
5830 case elfcpp::R_PPC64_ADDR16_HIGHEST
:
5831 case elfcpp::R_PPC64_ADDR16_HIGHESTA
:
5832 case elfcpp::R_PPC64_ADDR16_DS
:
5833 case elfcpp::R_PPC64_ADDR16_LO_DS
:
5834 case elfcpp::R_POWERPC_ADDR14
:
5835 case elfcpp::R_POWERPC_ADDR14_BRTAKEN
:
5836 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN
:
5838 // Make a PLT entry if necessary.
5839 if (gsym
->needs_plt_entry())
5841 // Since this is not a PC-relative relocation, we may be
5842 // taking the address of a function. In that case we need to
5843 // set the entry in the dynamic symbol table to the address of
5844 // the PLT call stub.
5845 bool need_ifunc_plt
= false;
5846 if ((size
== 32 || target
->abiversion() >= 2)
5847 && gsym
->is_from_dynobj()
5848 && !parameters
->options().output_is_position_independent())
5850 gsym
->set_needs_dynsym_value();
5851 need_ifunc_plt
= true;
5853 if (!is_ifunc
|| (!pushed_ifunc
&& need_ifunc_plt
))
5855 target
->push_branch(ppc_object
, data_shndx
,
5856 reloc
.get_r_offset(), r_type
,
5857 elfcpp::elf_r_sym
<size
>(reloc
.get_r_info()),
5858 reloc
.get_r_addend());
5859 target
->make_plt_entry(symtab
, layout
, gsym
);
5862 // Make a dynamic relocation if necessary.
5863 if (gsym
->needs_dynamic_reloc(Scan::get_reference_flags(r_type
, target
))
5864 || (size
== 64 && is_ifunc
&& target
->abiversion() < 2))
5866 if (!parameters
->options().output_is_position_independent()
5867 && gsym
->may_need_copy_reloc())
5869 target
->copy_reloc(symtab
, layout
, object
,
5870 data_shndx
, output_section
, gsym
, reloc
);
5872 else if ((((size
== 32
5873 && r_type
== elfcpp::R_POWERPC_ADDR32
)
5875 && r_type
== elfcpp::R_PPC64_ADDR64
5876 && target
->abiversion() >= 2))
5877 && gsym
->can_use_relative_reloc(false)
5878 && !(gsym
->visibility() == elfcpp::STV_PROTECTED
5879 && parameters
->options().shared()))
5881 && r_type
== elfcpp::R_PPC64_ADDR64
5882 && target
->abiversion() < 2
5883 && (gsym
->can_use_relative_reloc(false)
5884 || data_shndx
== ppc_object
->opd_shndx())))
5886 Reloc_section
* rela_dyn
5887 = target
->rela_dyn_section(symtab
, layout
, is_ifunc
);
5888 unsigned int dynrel
= (is_ifunc
? elfcpp::R_POWERPC_IRELATIVE
5889 : elfcpp::R_POWERPC_RELATIVE
);
5890 rela_dyn
->add_symbolless_global_addend(
5891 gsym
, dynrel
, output_section
, object
, data_shndx
,
5892 reloc
.get_r_offset(), reloc
.get_r_addend());
5896 Reloc_section
* rela_dyn
5897 = target
->rela_dyn_section(symtab
, layout
, is_ifunc
);
5898 check_non_pic(object
, r_type
);
5899 rela_dyn
->add_global(gsym
, r_type
, output_section
,
5901 reloc
.get_r_offset(),
5902 reloc
.get_r_addend());
5908 case elfcpp::R_PPC_PLTREL24
:
5909 case elfcpp::R_POWERPC_REL24
:
5912 target
->push_branch(ppc_object
, data_shndx
, reloc
.get_r_offset(),
5914 elfcpp::elf_r_sym
<size
>(reloc
.get_r_info()),
5915 reloc
.get_r_addend());
5916 if (gsym
->needs_plt_entry()
5917 || (!gsym
->final_value_is_known()
5918 && (gsym
->is_undefined()
5919 || gsym
->is_from_dynobj()
5920 || gsym
->is_preemptible())))
5921 target
->make_plt_entry(symtab
, layout
, gsym
);
5925 case elfcpp::R_PPC64_REL64
:
5926 case elfcpp::R_POWERPC_REL32
:
5927 // Make a dynamic relocation if necessary.
5928 if (gsym
->needs_dynamic_reloc(Scan::get_reference_flags(r_type
, target
)))
5930 if (!parameters
->options().output_is_position_independent()
5931 && gsym
->may_need_copy_reloc())
5933 target
->copy_reloc(symtab
, layout
, object
,
5934 data_shndx
, output_section
, gsym
,
5939 Reloc_section
* rela_dyn
5940 = target
->rela_dyn_section(symtab
, layout
, is_ifunc
);
5941 check_non_pic(object
, r_type
);
5942 rela_dyn
->add_global(gsym
, r_type
, output_section
, object
,
5943 data_shndx
, reloc
.get_r_offset(),
5944 reloc
.get_r_addend());
5949 case elfcpp::R_POWERPC_REL14
:
5950 case elfcpp::R_POWERPC_REL14_BRTAKEN
:
5951 case elfcpp::R_POWERPC_REL14_BRNTAKEN
:
5953 target
->push_branch(ppc_object
, data_shndx
, reloc
.get_r_offset(),
5954 r_type
, elfcpp::elf_r_sym
<size
>(reloc
.get_r_info()),
5955 reloc
.get_r_addend());
5958 case elfcpp::R_POWERPC_REL16
:
5959 case elfcpp::R_POWERPC_REL16_LO
:
5960 case elfcpp::R_POWERPC_REL16_HI
:
5961 case elfcpp::R_POWERPC_REL16_HA
:
5962 case elfcpp::R_POWERPC_SECTOFF
:
5963 case elfcpp::R_POWERPC_SECTOFF_LO
:
5964 case elfcpp::R_POWERPC_SECTOFF_HI
:
5965 case elfcpp::R_POWERPC_SECTOFF_HA
:
5966 case elfcpp::R_PPC64_SECTOFF_DS
:
5967 case elfcpp::R_PPC64_SECTOFF_LO_DS
:
5968 case elfcpp::R_POWERPC_TPREL16
:
5969 case elfcpp::R_POWERPC_TPREL16_LO
:
5970 case elfcpp::R_POWERPC_TPREL16_HI
:
5971 case elfcpp::R_POWERPC_TPREL16_HA
:
5972 case elfcpp::R_PPC64_TPREL16_DS
:
5973 case elfcpp::R_PPC64_TPREL16_LO_DS
:
5974 case elfcpp::R_PPC64_TPREL16_HIGH
:
5975 case elfcpp::R_PPC64_TPREL16_HIGHA
:
5976 case elfcpp::R_PPC64_TPREL16_HIGHER
:
5977 case elfcpp::R_PPC64_TPREL16_HIGHERA
:
5978 case elfcpp::R_PPC64_TPREL16_HIGHEST
:
5979 case elfcpp::R_PPC64_TPREL16_HIGHESTA
:
5980 case elfcpp::R_POWERPC_DTPREL16
:
5981 case elfcpp::R_POWERPC_DTPREL16_LO
:
5982 case elfcpp::R_POWERPC_DTPREL16_HI
:
5983 case elfcpp::R_POWERPC_DTPREL16_HA
:
5984 case elfcpp::R_PPC64_DTPREL16_DS
:
5985 case elfcpp::R_PPC64_DTPREL16_LO_DS
:
5986 case elfcpp::R_PPC64_DTPREL16_HIGH
:
5987 case elfcpp::R_PPC64_DTPREL16_HIGHA
:
5988 case elfcpp::R_PPC64_DTPREL16_HIGHER
:
5989 case elfcpp::R_PPC64_DTPREL16_HIGHERA
:
5990 case elfcpp::R_PPC64_DTPREL16_HIGHEST
:
5991 case elfcpp::R_PPC64_DTPREL16_HIGHESTA
:
5992 case elfcpp::R_PPC64_TLSGD
:
5993 case elfcpp::R_PPC64_TLSLD
:
5994 case elfcpp::R_PPC64_ADDR64_LOCAL
:
5997 case elfcpp::R_POWERPC_GOT16
:
5998 case elfcpp::R_POWERPC_GOT16_LO
:
5999 case elfcpp::R_POWERPC_GOT16_HI
:
6000 case elfcpp::R_POWERPC_GOT16_HA
:
6001 case elfcpp::R_PPC64_GOT16_DS
:
6002 case elfcpp::R_PPC64_GOT16_LO_DS
:
6004 // The symbol requires a GOT entry.
6005 Output_data_got_powerpc
<size
, big_endian
>* got
;
6007 got
= target
->got_section(symtab
, layout
);
6008 if (gsym
->final_value_is_known())
6010 if ((size
== 32 && is_ifunc
)
6011 || (size
== 64 && target
->abiversion() >= 2))
6012 got
->add_global_plt(gsym
, GOT_TYPE_STANDARD
);
6014 got
->add_global(gsym
, GOT_TYPE_STANDARD
);
6016 else if (!gsym
->has_got_offset(GOT_TYPE_STANDARD
))
6018 // If we are generating a shared object or a pie, this
6019 // symbol's GOT entry will be set by a dynamic relocation.
6020 unsigned int off
= got
->add_constant(0);
6021 gsym
->set_got_offset(GOT_TYPE_STANDARD
, off
);
6023 Reloc_section
* rela_dyn
6024 = target
->rela_dyn_section(symtab
, layout
, is_ifunc
);
6026 if (gsym
->can_use_relative_reloc(false)
6028 || target
->abiversion() >= 2)
6029 && gsym
->visibility() == elfcpp::STV_PROTECTED
6030 && parameters
->options().shared()))
6032 unsigned int dynrel
= (is_ifunc
? elfcpp::R_POWERPC_IRELATIVE
6033 : elfcpp::R_POWERPC_RELATIVE
);
6034 rela_dyn
->add_global_relative(gsym
, dynrel
, got
, off
, 0, false);
6038 unsigned int dynrel
= elfcpp::R_POWERPC_GLOB_DAT
;
6039 rela_dyn
->add_global(gsym
, dynrel
, got
, off
, 0);
6045 case elfcpp::R_PPC64_TOC16
:
6046 case elfcpp::R_PPC64_TOC16_LO
:
6047 case elfcpp::R_PPC64_TOC16_HI
:
6048 case elfcpp::R_PPC64_TOC16_HA
:
6049 case elfcpp::R_PPC64_TOC16_DS
:
6050 case elfcpp::R_PPC64_TOC16_LO_DS
:
6051 // We need a GOT section.
6052 target
->got_section(symtab
, layout
);
6055 case elfcpp::R_POWERPC_GOT_TLSGD16
:
6056 case elfcpp::R_POWERPC_GOT_TLSGD16_LO
:
6057 case elfcpp::R_POWERPC_GOT_TLSGD16_HI
:
6058 case elfcpp::R_POWERPC_GOT_TLSGD16_HA
:
6060 const bool final
= gsym
->final_value_is_known();
6061 const tls::Tls_optimization tls_type
= target
->optimize_tls_gd(final
);
6062 if (tls_type
== tls::TLSOPT_NONE
)
6064 Output_data_got_powerpc
<size
, big_endian
>* got
6065 = target
->got_section(symtab
, layout
);
6066 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
6067 got
->add_global_pair_with_rel(gsym
, GOT_TYPE_TLSGD
, rela_dyn
,
6068 elfcpp::R_POWERPC_DTPMOD
,
6069 elfcpp::R_POWERPC_DTPREL
);
6071 else if (tls_type
== tls::TLSOPT_TO_IE
)
6073 if (!gsym
->has_got_offset(GOT_TYPE_TPREL
))
6075 Output_data_got_powerpc
<size
, big_endian
>* got
6076 = target
->got_section(symtab
, layout
);
6077 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
6078 if (gsym
->is_undefined()
6079 || gsym
->is_from_dynobj())
6081 got
->add_global_with_rel(gsym
, GOT_TYPE_TPREL
, rela_dyn
,
6082 elfcpp::R_POWERPC_TPREL
);
6086 unsigned int off
= got
->add_constant(0);
6087 gsym
->set_got_offset(GOT_TYPE_TPREL
, off
);
6088 unsigned int dynrel
= elfcpp::R_POWERPC_TPREL
;
6089 rela_dyn
->add_symbolless_global_addend(gsym
, dynrel
,
6094 else if (tls_type
== tls::TLSOPT_TO_LE
)
6096 // no GOT relocs needed for Local Exec.
6103 case elfcpp::R_POWERPC_GOT_TLSLD16
:
6104 case elfcpp::R_POWERPC_GOT_TLSLD16_LO
:
6105 case elfcpp::R_POWERPC_GOT_TLSLD16_HI
:
6106 case elfcpp::R_POWERPC_GOT_TLSLD16_HA
:
6108 const tls::Tls_optimization tls_type
= target
->optimize_tls_ld();
6109 if (tls_type
== tls::TLSOPT_NONE
)
6110 target
->tlsld_got_offset(symtab
, layout
, object
);
6111 else if (tls_type
== tls::TLSOPT_TO_LE
)
6113 // no GOT relocs needed for Local Exec.
6114 if (parameters
->options().emit_relocs())
6116 Output_section
* os
= layout
->tls_segment()->first_section();
6117 gold_assert(os
!= NULL
);
6118 os
->set_needs_symtab_index();
6126 case elfcpp::R_POWERPC_GOT_DTPREL16
:
6127 case elfcpp::R_POWERPC_GOT_DTPREL16_LO
:
6128 case elfcpp::R_POWERPC_GOT_DTPREL16_HI
:
6129 case elfcpp::R_POWERPC_GOT_DTPREL16_HA
:
6131 Output_data_got_powerpc
<size
, big_endian
>* got
6132 = target
->got_section(symtab
, layout
);
6133 if (!gsym
->final_value_is_known()
6134 && (gsym
->is_from_dynobj()
6135 || gsym
->is_undefined()
6136 || gsym
->is_preemptible()))
6137 got
->add_global_with_rel(gsym
, GOT_TYPE_DTPREL
,
6138 target
->rela_dyn_section(layout
),
6139 elfcpp::R_POWERPC_DTPREL
);
6141 got
->add_global_tls(gsym
, GOT_TYPE_DTPREL
);
6145 case elfcpp::R_POWERPC_GOT_TPREL16
:
6146 case elfcpp::R_POWERPC_GOT_TPREL16_LO
:
6147 case elfcpp::R_POWERPC_GOT_TPREL16_HI
:
6148 case elfcpp::R_POWERPC_GOT_TPREL16_HA
:
6150 const bool final
= gsym
->final_value_is_known();
6151 const tls::Tls_optimization tls_type
= target
->optimize_tls_ie(final
);
6152 if (tls_type
== tls::TLSOPT_NONE
)
6154 if (!gsym
->has_got_offset(GOT_TYPE_TPREL
))
6156 Output_data_got_powerpc
<size
, big_endian
>* got
6157 = target
->got_section(symtab
, layout
);
6158 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
6159 if (gsym
->is_undefined()
6160 || gsym
->is_from_dynobj())
6162 got
->add_global_with_rel(gsym
, GOT_TYPE_TPREL
, rela_dyn
,
6163 elfcpp::R_POWERPC_TPREL
);
6167 unsigned int off
= got
->add_constant(0);
6168 gsym
->set_got_offset(GOT_TYPE_TPREL
, off
);
6169 unsigned int dynrel
= elfcpp::R_POWERPC_TPREL
;
6170 rela_dyn
->add_symbolless_global_addend(gsym
, dynrel
,
6175 else if (tls_type
== tls::TLSOPT_TO_LE
)
6177 // no GOT relocs needed for Local Exec.
6185 unsupported_reloc_global(object
, r_type
, gsym
);
6191 case elfcpp::R_POWERPC_GOT_TLSLD16
:
6192 case elfcpp::R_POWERPC_GOT_TLSGD16
:
6193 case elfcpp::R_POWERPC_GOT_TPREL16
:
6194 case elfcpp::R_POWERPC_GOT_DTPREL16
:
6195 case elfcpp::R_POWERPC_GOT16
:
6196 case elfcpp::R_PPC64_GOT16_DS
:
6197 case elfcpp::R_PPC64_TOC16
:
6198 case elfcpp::R_PPC64_TOC16_DS
:
6199 ppc_object
->set_has_small_toc_reloc();
6205 // Process relocations for gc.
6207 template<int size
, bool big_endian
>
6209 Target_powerpc
<size
, big_endian
>::gc_process_relocs(
6210 Symbol_table
* symtab
,
6212 Sized_relobj_file
<size
, big_endian
>* object
,
6213 unsigned int data_shndx
,
6215 const unsigned char* prelocs
,
6217 Output_section
* output_section
,
6218 bool needs_special_offset_handling
,
6219 size_t local_symbol_count
,
6220 const unsigned char* plocal_symbols
)
6222 typedef Target_powerpc
<size
, big_endian
> Powerpc
;
6223 typedef typename Target_powerpc
<size
, big_endian
>::Scan Scan
;
6224 Powerpc_relobj
<size
, big_endian
>* ppc_object
6225 = static_cast<Powerpc_relobj
<size
, big_endian
>*>(object
);
6227 ppc_object
->set_opd_valid();
6228 if (size
== 64 && data_shndx
== ppc_object
->opd_shndx())
6230 typename Powerpc_relobj
<size
, big_endian
>::Access_from::iterator p
;
6231 for (p
= ppc_object
->access_from_map()->begin();
6232 p
!= ppc_object
->access_from_map()->end();
6235 Address dst_off
= p
->first
;
6236 unsigned int dst_indx
= ppc_object
->get_opd_ent(dst_off
);
6237 typename Powerpc_relobj
<size
, big_endian
>::Section_refs::iterator s
;
6238 for (s
= p
->second
.begin(); s
!= p
->second
.end(); ++s
)
6240 Object
* src_obj
= s
->first
;
6241 unsigned int src_indx
= s
->second
;
6242 symtab
->gc()->add_reference(src_obj
, src_indx
,
6243 ppc_object
, dst_indx
);
6247 ppc_object
->access_from_map()->clear();
6248 ppc_object
->process_gc_mark(symtab
);
6249 // Don't look at .opd relocs as .opd will reference everything.
6253 gold::gc_process_relocs
<size
, big_endian
, Powerpc
, elfcpp::SHT_RELA
, Scan
,
6254 typename
Target_powerpc::Relocatable_size_for_reloc
>(
6263 needs_special_offset_handling
,
6268 // Handle target specific gc actions when adding a gc reference from
6269 // SRC_OBJ, SRC_SHNDX to a location specified by DST_OBJ, DST_SHNDX
6270 // and DST_OFF. For powerpc64, this adds a referenc to the code
6271 // section of a function descriptor.
6273 template<int size
, bool big_endian
>
6275 Target_powerpc
<size
, big_endian
>::do_gc_add_reference(
6276 Symbol_table
* symtab
,
6278 unsigned int src_shndx
,
6280 unsigned int dst_shndx
,
6281 Address dst_off
) const
6283 if (size
!= 64 || dst_obj
->is_dynamic())
6286 Powerpc_relobj
<size
, big_endian
>* ppc_object
6287 = static_cast<Powerpc_relobj
<size
, big_endian
>*>(dst_obj
);
6288 if (dst_shndx
!= 0 && dst_shndx
== ppc_object
->opd_shndx())
6290 if (ppc_object
->opd_valid())
6292 dst_shndx
= ppc_object
->get_opd_ent(dst_off
);
6293 symtab
->gc()->add_reference(src_obj
, src_shndx
, dst_obj
, dst_shndx
);
6297 // If we haven't run scan_opd_relocs, we must delay
6298 // processing this function descriptor reference.
6299 ppc_object
->add_reference(src_obj
, src_shndx
, dst_off
);
6304 // Add any special sections for this symbol to the gc work list.
6305 // For powerpc64, this adds the code section of a function
6308 template<int size
, bool big_endian
>
6310 Target_powerpc
<size
, big_endian
>::do_gc_mark_symbol(
6311 Symbol_table
* symtab
,
6316 Powerpc_relobj
<size
, big_endian
>* ppc_object
6317 = static_cast<Powerpc_relobj
<size
, big_endian
>*>(sym
->object());
6319 unsigned int shndx
= sym
->shndx(&is_ordinary
);
6320 if (is_ordinary
&& shndx
!= 0 && shndx
== ppc_object
->opd_shndx())
6322 Sized_symbol
<size
>* gsym
= symtab
->get_sized_symbol
<size
>(sym
);
6323 Address dst_off
= gsym
->value();
6324 if (ppc_object
->opd_valid())
6326 unsigned int dst_indx
= ppc_object
->get_opd_ent(dst_off
);
6327 symtab
->gc()->worklist().push(Section_id(ppc_object
, dst_indx
));
6330 ppc_object
->add_gc_mark(dst_off
);
6335 // For a symbol location in .opd, set LOC to the location of the
6338 template<int size
, bool big_endian
>
6340 Target_powerpc
<size
, big_endian
>::do_function_location(
6341 Symbol_location
* loc
) const
6343 if (size
== 64 && loc
->shndx
!= 0)
6345 if (loc
->object
->is_dynamic())
6347 Powerpc_dynobj
<size
, big_endian
>* ppc_object
6348 = static_cast<Powerpc_dynobj
<size
, big_endian
>*>(loc
->object
);
6349 if (loc
->shndx
== ppc_object
->opd_shndx())
6352 Address off
= loc
->offset
- ppc_object
->opd_address();
6353 loc
->shndx
= ppc_object
->get_opd_ent(off
, &dest_off
);
6354 loc
->offset
= dest_off
;
6359 const Powerpc_relobj
<size
, big_endian
>* ppc_object
6360 = static_cast<const Powerpc_relobj
<size
, big_endian
>*>(loc
->object
);
6361 if (loc
->shndx
== ppc_object
->opd_shndx())
6364 loc
->shndx
= ppc_object
->get_opd_ent(loc
->offset
, &dest_off
);
6365 loc
->offset
= dest_off
;
6371 // Scan relocations for a section.
6373 template<int size
, bool big_endian
>
6375 Target_powerpc
<size
, big_endian
>::scan_relocs(
6376 Symbol_table
* symtab
,
6378 Sized_relobj_file
<size
, big_endian
>* object
,
6379 unsigned int data_shndx
,
6380 unsigned int sh_type
,
6381 const unsigned char* prelocs
,
6383 Output_section
* output_section
,
6384 bool needs_special_offset_handling
,
6385 size_t local_symbol_count
,
6386 const unsigned char* plocal_symbols
)
6388 typedef Target_powerpc
<size
, big_endian
> Powerpc
;
6389 typedef typename Target_powerpc
<size
, big_endian
>::Scan Scan
;
6391 if (sh_type
== elfcpp::SHT_REL
)
6393 gold_error(_("%s: unsupported REL reloc section"),
6394 object
->name().c_str());
6398 gold::scan_relocs
<size
, big_endian
, Powerpc
, elfcpp::SHT_RELA
, Scan
>(
6407 needs_special_offset_handling
,
6412 // Functor class for processing the global symbol table.
6413 // Removes symbols defined on discarded opd entries.
6415 template<bool big_endian
>
6416 class Global_symbol_visitor_opd
6419 Global_symbol_visitor_opd()
6423 operator()(Sized_symbol
<64>* sym
)
6425 if (sym
->has_symtab_index()
6426 || sym
->source() != Symbol::FROM_OBJECT
6427 || !sym
->in_real_elf())
6430 if (sym
->object()->is_dynamic())
6433 Powerpc_relobj
<64, big_endian
>* symobj
6434 = static_cast<Powerpc_relobj
<64, big_endian
>*>(sym
->object());
6435 if (symobj
->opd_shndx() == 0)
6439 unsigned int shndx
= sym
->shndx(&is_ordinary
);
6440 if (shndx
== symobj
->opd_shndx()
6441 && symobj
->get_opd_discard(sym
->value()))
6442 sym
->set_symtab_index(-1U);
6446 template<int size
, bool big_endian
>
6448 Target_powerpc
<size
, big_endian
>::define_save_restore_funcs(
6450 Symbol_table
* symtab
)
6454 Output_data_save_res
<64, big_endian
>* savres
6455 = new Output_data_save_res
<64, big_endian
>(symtab
);
6456 layout
->add_output_section_data(".text", elfcpp::SHT_PROGBITS
,
6457 elfcpp::SHF_ALLOC
| elfcpp::SHF_EXECINSTR
,
6458 savres
, ORDER_TEXT
, false);
6462 // Sort linker created .got section first (for the header), then input
6463 // sections belonging to files using small model code.
6465 template<bool big_endian
>
6466 class Sort_toc_sections
6470 operator()(const Output_section::Input_section
& is1
,
6471 const Output_section::Input_section
& is2
) const
6473 if (!is1
.is_input_section() && is2
.is_input_section())
6476 = (is1
.is_input_section()
6477 && (static_cast<const Powerpc_relobj
<64, big_endian
>*>(is1
.relobj())
6478 ->has_small_toc_reloc()));
6480 = (is2
.is_input_section()
6481 && (static_cast<const Powerpc_relobj
<64, big_endian
>*>(is2
.relobj())
6482 ->has_small_toc_reloc()));
6483 return small1
&& !small2
;
6487 // Finalize the sections.
6489 template<int size
, bool big_endian
>
6491 Target_powerpc
<size
, big_endian
>::do_finalize_sections(
6493 const Input_objects
*,
6494 Symbol_table
* symtab
)
6496 if (parameters
->doing_static_link())
6498 // At least some versions of glibc elf-init.o have a strong
6499 // reference to __rela_iplt marker syms. A weak ref would be
6501 if (this->iplt_
!= NULL
)
6503 Reloc_section
* rel
= this->iplt_
->rel_plt();
6504 symtab
->define_in_output_data("__rela_iplt_start", NULL
,
6505 Symbol_table::PREDEFINED
, rel
, 0, 0,
6506 elfcpp::STT_NOTYPE
, elfcpp::STB_GLOBAL
,
6507 elfcpp::STV_HIDDEN
, 0, false, true);
6508 symtab
->define_in_output_data("__rela_iplt_end", NULL
,
6509 Symbol_table::PREDEFINED
, rel
, 0, 0,
6510 elfcpp::STT_NOTYPE
, elfcpp::STB_GLOBAL
,
6511 elfcpp::STV_HIDDEN
, 0, true, true);
6515 symtab
->define_as_constant("__rela_iplt_start", NULL
,
6516 Symbol_table::PREDEFINED
, 0, 0,
6517 elfcpp::STT_NOTYPE
, elfcpp::STB_GLOBAL
,
6518 elfcpp::STV_HIDDEN
, 0, true, false);
6519 symtab
->define_as_constant("__rela_iplt_end", NULL
,
6520 Symbol_table::PREDEFINED
, 0, 0,
6521 elfcpp::STT_NOTYPE
, elfcpp::STB_GLOBAL
,
6522 elfcpp::STV_HIDDEN
, 0, true, false);
6528 typedef Global_symbol_visitor_opd
<big_endian
> Symbol_visitor
;
6529 symtab
->for_all_symbols
<64, Symbol_visitor
>(Symbol_visitor());
6531 if (!parameters
->options().relocatable())
6533 this->define_save_restore_funcs(layout
, symtab
);
6535 // Annoyingly, we need to make these sections now whether or
6536 // not we need them. If we delay until do_relax then we
6537 // need to mess with the relaxation machinery checkpointing.
6538 this->got_section(symtab
, layout
);
6539 this->make_brlt_section(layout
);
6541 if (parameters
->options().toc_sort())
6543 Output_section
* os
= this->got_
->output_section();
6544 if (os
!= NULL
&& os
->input_sections().size() > 1)
6545 std::stable_sort(os
->input_sections().begin(),
6546 os
->input_sections().end(),
6547 Sort_toc_sections
<big_endian
>());
6552 // Fill in some more dynamic tags.
6553 Output_data_dynamic
* odyn
= layout
->dynamic_data();
6556 const Reloc_section
* rel_plt
= (this->plt_
== NULL
6558 : this->plt_
->rel_plt());
6559 layout
->add_target_dynamic_tags(false, this->plt_
, rel_plt
,
6560 this->rela_dyn_
, true, size
== 32);
6564 if (this->got_
!= NULL
)
6566 this->got_
->finalize_data_size();
6567 odyn
->add_section_plus_offset(elfcpp::DT_PPC_GOT
,
6568 this->got_
, this->got_
->g_o_t());
6573 if (this->glink_
!= NULL
)
6575 this->glink_
->finalize_data_size();
6576 odyn
->add_section_plus_offset(elfcpp::DT_PPC64_GLINK
,
6578 (this->glink_
->pltresolve_size
6584 // Emit any relocs we saved in an attempt to avoid generating COPY
6586 if (this->copy_relocs_
.any_saved_relocs())
6587 this->copy_relocs_
.emit(this->rela_dyn_section(layout
));
6590 // Return TRUE iff INSN is one we expect on a _LO variety toc/got
6594 ok_lo_toc_insn(uint32_t insn
)
6596 return ((insn
& (0x3f << 26)) == 14u << 26 /* addi */
6597 || (insn
& (0x3f << 26)) == 32u << 26 /* lwz */
6598 || (insn
& (0x3f << 26)) == 34u << 26 /* lbz */
6599 || (insn
& (0x3f << 26)) == 36u << 26 /* stw */
6600 || (insn
& (0x3f << 26)) == 38u << 26 /* stb */
6601 || (insn
& (0x3f << 26)) == 40u << 26 /* lhz */
6602 || (insn
& (0x3f << 26)) == 42u << 26 /* lha */
6603 || (insn
& (0x3f << 26)) == 44u << 26 /* sth */
6604 || (insn
& (0x3f << 26)) == 46u << 26 /* lmw */
6605 || (insn
& (0x3f << 26)) == 47u << 26 /* stmw */
6606 || (insn
& (0x3f << 26)) == 48u << 26 /* lfs */
6607 || (insn
& (0x3f << 26)) == 50u << 26 /* lfd */
6608 || (insn
& (0x3f << 26)) == 52u << 26 /* stfs */
6609 || (insn
& (0x3f << 26)) == 54u << 26 /* stfd */
6610 || ((insn
& (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
6612 || ((insn
& (0x3f << 26)) == 62u << 26 /* std, stmd */
6613 && ((insn
& 3) == 0 || (insn
& 3) == 3))
6614 || (insn
& (0x3f << 26)) == 12u << 26 /* addic */);
6617 // Return the value to use for a branch relocation.
6619 template<int size
, bool big_endian
>
6620 typename Target_powerpc
<size
, big_endian
>::Address
6621 Target_powerpc
<size
, big_endian
>::symval_for_branch(
6622 const Symbol_table
* symtab
,
6624 const Sized_symbol
<size
>* gsym
,
6625 Powerpc_relobj
<size
, big_endian
>* object
,
6626 unsigned int *dest_shndx
)
6628 if (size
== 32 || this->abiversion() >= 2)
6632 // If the symbol is defined in an opd section, ie. is a function
6633 // descriptor, use the function descriptor code entry address
6634 Powerpc_relobj
<size
, big_endian
>* symobj
= object
;
6636 && gsym
->source() != Symbol::FROM_OBJECT
)
6639 symobj
= static_cast<Powerpc_relobj
<size
, big_endian
>*>(gsym
->object());
6640 unsigned int shndx
= symobj
->opd_shndx();
6643 Address opd_addr
= symobj
->get_output_section_offset(shndx
);
6644 if (opd_addr
== invalid_address
)
6646 opd_addr
+= symobj
->output_section_address(shndx
);
6647 if (value
>= opd_addr
&& value
< opd_addr
+ symobj
->section_size(shndx
))
6650 *dest_shndx
= symobj
->get_opd_ent(value
- opd_addr
, &sec_off
);
6651 if (symtab
->is_section_folded(symobj
, *dest_shndx
))
6654 = symtab
->icf()->get_folded_section(symobj
, *dest_shndx
);
6655 symobj
= static_cast<Powerpc_relobj
<size
, big_endian
>*>(folded
.first
);
6656 *dest_shndx
= folded
.second
;
6658 Address sec_addr
= symobj
->get_output_section_offset(*dest_shndx
);
6659 gold_assert(sec_addr
!= invalid_address
);
6660 sec_addr
+= symobj
->output_section(*dest_shndx
)->address();
6661 value
= sec_addr
+ sec_off
;
6666 // Perform a relocation.
6668 template<int size
, bool big_endian
>
6670 Target_powerpc
<size
, big_endian
>::Relocate::relocate(
6671 const Relocate_info
<size
, big_endian
>* relinfo
,
6672 Target_powerpc
* target
,
6675 const elfcpp::Rela
<size
, big_endian
>& rela
,
6676 unsigned int r_type
,
6677 const Sized_symbol
<size
>* gsym
,
6678 const Symbol_value
<size
>* psymval
,
6679 unsigned char* view
,
6681 section_size_type view_size
)
6686 switch (this->maybe_skip_tls_get_addr_call(r_type
, gsym
))
6688 case Track_tls::NOT_EXPECTED
:
6689 gold_error_at_location(relinfo
, relnum
, rela
.get_r_offset(),
6690 _("__tls_get_addr call lacks marker reloc"));
6692 case Track_tls::EXPECTED
:
6693 // We have already complained.
6695 case Track_tls::SKIP
:
6697 case Track_tls::NORMAL
:
6701 typedef Powerpc_relocate_functions
<size
, big_endian
> Reloc
;
6702 typedef typename
elfcpp::Swap
<32, big_endian
>::Valtype Insn
;
6703 Powerpc_relobj
<size
, big_endian
>* const object
6704 = static_cast<Powerpc_relobj
<size
, big_endian
>*>(relinfo
->object
);
6706 bool has_stub_value
= false;
6707 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(rela
.get_r_info());
6709 ? gsym
->use_plt_offset(Scan::get_reference_flags(r_type
, target
))
6710 : object
->local_has_plt_offset(r_sym
))
6711 && (!psymval
->is_ifunc_symbol()
6712 || Scan::reloc_needs_plt_for_ifunc(target
, object
, r_type
, false)))
6716 && target
->abiversion() >= 2
6717 && !parameters
->options().output_is_position_independent()
6718 && !is_branch_reloc(r_type
))
6720 unsigned int off
= target
->glink_section()->find_global_entry(gsym
);
6721 gold_assert(off
!= (unsigned int)-1);
6722 value
= target
->glink_section()->global_entry_address() + off
;
6726 Stub_table
<size
, big_endian
>* stub_table
6727 = object
->stub_table(relinfo
->data_shndx
);
6728 if (stub_table
== NULL
)
6730 // This is a ref from a data section to an ifunc symbol.
6731 if (target
->stub_tables().size() != 0)
6732 stub_table
= target
->stub_tables()[0];
6734 gold_assert(stub_table
!= NULL
);
6737 off
= stub_table
->find_plt_call_entry(object
, gsym
, r_type
,
6738 rela
.get_r_addend());
6740 off
= stub_table
->find_plt_call_entry(object
, r_sym
, r_type
,
6741 rela
.get_r_addend());
6742 gold_assert(off
!= invalid_address
);
6743 value
= stub_table
->stub_address() + off
;
6745 has_stub_value
= true;
6748 if (r_type
== elfcpp::R_POWERPC_GOT16
6749 || r_type
== elfcpp::R_POWERPC_GOT16_LO
6750 || r_type
== elfcpp::R_POWERPC_GOT16_HI
6751 || r_type
== elfcpp::R_POWERPC_GOT16_HA
6752 || r_type
== elfcpp::R_PPC64_GOT16_DS
6753 || r_type
== elfcpp::R_PPC64_GOT16_LO_DS
)
6757 gold_assert(gsym
->has_got_offset(GOT_TYPE_STANDARD
));
6758 value
= gsym
->got_offset(GOT_TYPE_STANDARD
);
6762 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(rela
.get_r_info());
6763 gold_assert(object
->local_has_got_offset(r_sym
, GOT_TYPE_STANDARD
));
6764 value
= object
->local_got_offset(r_sym
, GOT_TYPE_STANDARD
);
6766 value
-= target
->got_section()->got_base_offset(object
);
6768 else if (r_type
== elfcpp::R_PPC64_TOC
)
6770 value
= (target
->got_section()->output_section()->address()
6771 + object
->toc_base_offset());
6773 else if (gsym
!= NULL
6774 && (r_type
== elfcpp::R_POWERPC_REL24
6775 || r_type
== elfcpp::R_PPC_PLTREL24
)
6780 typedef typename
elfcpp::Swap
<32, big_endian
>::Valtype Valtype
;
6781 Valtype
* wv
= reinterpret_cast<Valtype
*>(view
);
6782 bool can_plt_call
= false;
6783 if (rela
.get_r_offset() + 8 <= view_size
)
6785 Valtype insn
= elfcpp::Swap
<32, big_endian
>::readval(wv
);
6786 Valtype insn2
= elfcpp::Swap
<32, big_endian
>::readval(wv
+ 1);
6789 || insn2
== cror_15_15_15
|| insn2
== cror_31_31_31
))
6791 elfcpp::Swap
<32, big_endian
>::
6792 writeval(wv
+ 1, ld_2_1
+ target
->stk_toc());
6793 can_plt_call
= true;
6798 // If we don't have a branch and link followed by a nop,
6799 // we can't go via the plt because there is no place to
6800 // put a toc restoring instruction.
6801 // Unless we know we won't be returning.
6802 if (strcmp(gsym
->name(), "__libc_start_main") == 0)
6803 can_plt_call
= true;
6807 // g++ as of 20130507 emits self-calls without a
6808 // following nop. This is arguably wrong since we have
6809 // conflicting information. On the one hand a global
6810 // symbol and on the other a local call sequence, but
6811 // don't error for this special case.
6812 // It isn't possible to cheaply verify we have exactly
6813 // such a call. Allow all calls to the same section.
6815 Address code
= value
;
6816 if (gsym
->source() == Symbol::FROM_OBJECT
6817 && gsym
->object() == object
)
6819 unsigned int dest_shndx
= 0;
6820 if (target
->abiversion() < 2)
6822 Address addend
= rela
.get_r_addend();
6823 Address opdent
= psymval
->value(object
, addend
);
6824 code
= target
->symval_for_branch(relinfo
->symtab
,
6825 opdent
, gsym
, object
,
6829 if (dest_shndx
== 0)
6830 dest_shndx
= gsym
->shndx(&is_ordinary
);
6831 ok
= dest_shndx
== relinfo
->data_shndx
;
6835 gold_error_at_location(relinfo
, relnum
, rela
.get_r_offset(),
6836 _("call lacks nop, can't restore toc; "
6837 "recompile with -fPIC"));
6843 else if (r_type
== elfcpp::R_POWERPC_GOT_TLSGD16
6844 || r_type
== elfcpp::R_POWERPC_GOT_TLSGD16_LO
6845 || r_type
== elfcpp::R_POWERPC_GOT_TLSGD16_HI
6846 || r_type
== elfcpp::R_POWERPC_GOT_TLSGD16_HA
)
6848 // First instruction of a global dynamic sequence, arg setup insn.
6849 const bool final
= gsym
== NULL
|| gsym
->final_value_is_known();
6850 const tls::Tls_optimization tls_type
= target
->optimize_tls_gd(final
);
6851 enum Got_type got_type
= GOT_TYPE_STANDARD
;
6852 if (tls_type
== tls::TLSOPT_NONE
)
6853 got_type
= GOT_TYPE_TLSGD
;
6854 else if (tls_type
== tls::TLSOPT_TO_IE
)
6855 got_type
= GOT_TYPE_TPREL
;
6856 if (got_type
!= GOT_TYPE_STANDARD
)
6860 gold_assert(gsym
->has_got_offset(got_type
));
6861 value
= gsym
->got_offset(got_type
);
6865 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(rela
.get_r_info());
6866 gold_assert(object
->local_has_got_offset(r_sym
, got_type
));
6867 value
= object
->local_got_offset(r_sym
, got_type
);
6869 value
-= target
->got_section()->got_base_offset(object
);
6871 if (tls_type
== tls::TLSOPT_TO_IE
)
6873 if (r_type
== elfcpp::R_POWERPC_GOT_TLSGD16
6874 || r_type
== elfcpp::R_POWERPC_GOT_TLSGD16_LO
)
6876 Insn
* iview
= reinterpret_cast<Insn
*>(view
- 2 * big_endian
);
6877 Insn insn
= elfcpp::Swap
<32, big_endian
>::readval(iview
);
6878 insn
&= (1 << 26) - (1 << 16); // extract rt,ra from addi
6880 insn
|= 32 << 26; // lwz
6882 insn
|= 58 << 26; // ld
6883 elfcpp::Swap
<32, big_endian
>::writeval(iview
, insn
);
6885 r_type
+= (elfcpp::R_POWERPC_GOT_TPREL16
6886 - elfcpp::R_POWERPC_GOT_TLSGD16
);
6888 else if (tls_type
== tls::TLSOPT_TO_LE
)
6890 if (r_type
== elfcpp::R_POWERPC_GOT_TLSGD16
6891 || r_type
== elfcpp::R_POWERPC_GOT_TLSGD16_LO
)
6893 Insn
* iview
= reinterpret_cast<Insn
*>(view
- 2 * big_endian
);
6894 Insn insn
= addis_3_13
;
6897 elfcpp::Swap
<32, big_endian
>::writeval(iview
, insn
);
6898 r_type
= elfcpp::R_POWERPC_TPREL16_HA
;
6899 value
= psymval
->value(object
, rela
.get_r_addend());
6903 Insn
* iview
= reinterpret_cast<Insn
*>(view
- 2 * big_endian
);
6905 elfcpp::Swap
<32, big_endian
>::writeval(iview
, insn
);
6906 r_type
= elfcpp::R_POWERPC_NONE
;
6910 else if (r_type
== elfcpp::R_POWERPC_GOT_TLSLD16
6911 || r_type
== elfcpp::R_POWERPC_GOT_TLSLD16_LO
6912 || r_type
== elfcpp::R_POWERPC_GOT_TLSLD16_HI
6913 || r_type
== elfcpp::R_POWERPC_GOT_TLSLD16_HA
)
6915 // First instruction of a local dynamic sequence, arg setup insn.
6916 const tls::Tls_optimization tls_type
= target
->optimize_tls_ld();
6917 if (tls_type
== tls::TLSOPT_NONE
)
6919 value
= target
->tlsld_got_offset();
6920 value
-= target
->got_section()->got_base_offset(object
);
6924 gold_assert(tls_type
== tls::TLSOPT_TO_LE
);
6925 if (r_type
== elfcpp::R_POWERPC_GOT_TLSLD16
6926 || r_type
== elfcpp::R_POWERPC_GOT_TLSLD16_LO
)
6928 Insn
* iview
= reinterpret_cast<Insn
*>(view
- 2 * big_endian
);
6929 Insn insn
= addis_3_13
;
6932 elfcpp::Swap
<32, big_endian
>::writeval(iview
, insn
);
6933 r_type
= elfcpp::R_POWERPC_TPREL16_HA
;
6938 Insn
* iview
= reinterpret_cast<Insn
*>(view
- 2 * big_endian
);
6940 elfcpp::Swap
<32, big_endian
>::writeval(iview
, insn
);
6941 r_type
= elfcpp::R_POWERPC_NONE
;
6945 else if (r_type
== elfcpp::R_POWERPC_GOT_DTPREL16
6946 || r_type
== elfcpp::R_POWERPC_GOT_DTPREL16_LO
6947 || r_type
== elfcpp::R_POWERPC_GOT_DTPREL16_HI
6948 || r_type
== elfcpp::R_POWERPC_GOT_DTPREL16_HA
)
6950 // Accesses relative to a local dynamic sequence address,
6951 // no optimisation here.
6954 gold_assert(gsym
->has_got_offset(GOT_TYPE_DTPREL
));
6955 value
= gsym
->got_offset(GOT_TYPE_DTPREL
);
6959 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(rela
.get_r_info());
6960 gold_assert(object
->local_has_got_offset(r_sym
, GOT_TYPE_DTPREL
));
6961 value
= object
->local_got_offset(r_sym
, GOT_TYPE_DTPREL
);
6963 value
-= target
->got_section()->got_base_offset(object
);
6965 else if (r_type
== elfcpp::R_POWERPC_GOT_TPREL16
6966 || r_type
== elfcpp::R_POWERPC_GOT_TPREL16_LO
6967 || r_type
== elfcpp::R_POWERPC_GOT_TPREL16_HI
6968 || r_type
== elfcpp::R_POWERPC_GOT_TPREL16_HA
)
6970 // First instruction of initial exec sequence.
6971 const bool final
= gsym
== NULL
|| gsym
->final_value_is_known();
6972 const tls::Tls_optimization tls_type
= target
->optimize_tls_ie(final
);
6973 if (tls_type
== tls::TLSOPT_NONE
)
6977 gold_assert(gsym
->has_got_offset(GOT_TYPE_TPREL
));
6978 value
= gsym
->got_offset(GOT_TYPE_TPREL
);
6982 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(rela
.get_r_info());
6983 gold_assert(object
->local_has_got_offset(r_sym
, GOT_TYPE_TPREL
));
6984 value
= object
->local_got_offset(r_sym
, GOT_TYPE_TPREL
);
6986 value
-= target
->got_section()->got_base_offset(object
);
6990 gold_assert(tls_type
== tls::TLSOPT_TO_LE
);
6991 if (r_type
== elfcpp::R_POWERPC_GOT_TPREL16
6992 || r_type
== elfcpp::R_POWERPC_GOT_TPREL16_LO
)
6994 Insn
* iview
= reinterpret_cast<Insn
*>(view
- 2 * big_endian
);
6995 Insn insn
= elfcpp::Swap
<32, big_endian
>::readval(iview
);
6996 insn
&= (1 << 26) - (1 << 21); // extract rt from ld
7001 elfcpp::Swap
<32, big_endian
>::writeval(iview
, insn
);
7002 r_type
= elfcpp::R_POWERPC_TPREL16_HA
;
7003 value
= psymval
->value(object
, rela
.get_r_addend());
7007 Insn
* iview
= reinterpret_cast<Insn
*>(view
- 2 * big_endian
);
7009 elfcpp::Swap
<32, big_endian
>::writeval(iview
, insn
);
7010 r_type
= elfcpp::R_POWERPC_NONE
;
7014 else if ((size
== 64 && r_type
== elfcpp::R_PPC64_TLSGD
)
7015 || (size
== 32 && r_type
== elfcpp::R_PPC_TLSGD
))
7017 // Second instruction of a global dynamic sequence,
7018 // the __tls_get_addr call
7019 this->expect_tls_get_addr_call(relinfo
, relnum
, rela
.get_r_offset());
7020 const bool final
= gsym
== NULL
|| gsym
->final_value_is_known();
7021 const tls::Tls_optimization tls_type
= target
->optimize_tls_gd(final
);
7022 if (tls_type
!= tls::TLSOPT_NONE
)
7024 if (tls_type
== tls::TLSOPT_TO_IE
)
7026 Insn
* iview
= reinterpret_cast<Insn
*>(view
);
7027 Insn insn
= add_3_3_13
;
7030 elfcpp::Swap
<32, big_endian
>::writeval(iview
, insn
);
7031 r_type
= elfcpp::R_POWERPC_NONE
;
7035 Insn
* iview
= reinterpret_cast<Insn
*>(view
);
7036 Insn insn
= addi_3_3
;
7037 elfcpp::Swap
<32, big_endian
>::writeval(iview
, insn
);
7038 r_type
= elfcpp::R_POWERPC_TPREL16_LO
;
7039 view
+= 2 * big_endian
;
7040 value
= psymval
->value(object
, rela
.get_r_addend());
7042 this->skip_next_tls_get_addr_call();
7045 else if ((size
== 64 && r_type
== elfcpp::R_PPC64_TLSLD
)
7046 || (size
== 32 && r_type
== elfcpp::R_PPC_TLSLD
))
7048 // Second instruction of a local dynamic sequence,
7049 // the __tls_get_addr call
7050 this->expect_tls_get_addr_call(relinfo
, relnum
, rela
.get_r_offset());
7051 const tls::Tls_optimization tls_type
= target
->optimize_tls_ld();
7052 if (tls_type
== tls::TLSOPT_TO_LE
)
7054 Insn
* iview
= reinterpret_cast<Insn
*>(view
);
7055 Insn insn
= addi_3_3
;
7056 elfcpp::Swap
<32, big_endian
>::writeval(iview
, insn
);
7057 this->skip_next_tls_get_addr_call();
7058 r_type
= elfcpp::R_POWERPC_TPREL16_LO
;
7059 view
+= 2 * big_endian
;
7063 else if (r_type
== elfcpp::R_POWERPC_TLS
)
7065 // Second instruction of an initial exec sequence
7066 const bool final
= gsym
== NULL
|| gsym
->final_value_is_known();
7067 const tls::Tls_optimization tls_type
= target
->optimize_tls_ie(final
);
7068 if (tls_type
== tls::TLSOPT_TO_LE
)
7070 Insn
* iview
= reinterpret_cast<Insn
*>(view
);
7071 Insn insn
= elfcpp::Swap
<32, big_endian
>::readval(iview
);
7072 unsigned int reg
= size
== 32 ? 2 : 13;
7073 insn
= at_tls_transform(insn
, reg
);
7074 gold_assert(insn
!= 0);
7075 elfcpp::Swap
<32, big_endian
>::writeval(iview
, insn
);
7076 r_type
= elfcpp::R_POWERPC_TPREL16_LO
;
7077 view
+= 2 * big_endian
;
7078 value
= psymval
->value(object
, rela
.get_r_addend());
7081 else if (!has_stub_value
)
7084 unsigned int dest_shndx
;
7085 if (r_type
!= elfcpp::R_PPC_PLTREL24
)
7086 addend
= rela
.get_r_addend();
7087 value
= psymval
->value(object
, addend
);
7088 if (size
== 64 && is_branch_reloc(r_type
))
7090 if (target
->abiversion() >= 2)
7093 value
+= object
->ppc64_local_entry_offset(gsym
);
7095 value
+= object
->ppc64_local_entry_offset(r_sym
);
7098 value
= target
->symval_for_branch(relinfo
->symtab
, value
,
7099 gsym
, object
, &dest_shndx
);
7101 unsigned int max_branch_offset
= 0;
7102 if (r_type
== elfcpp::R_POWERPC_REL24
7103 || r_type
== elfcpp::R_PPC_PLTREL24
7104 || r_type
== elfcpp::R_PPC_LOCAL24PC
)
7105 max_branch_offset
= 1 << 25;
7106 else if (r_type
== elfcpp::R_POWERPC_REL14
7107 || r_type
== elfcpp::R_POWERPC_REL14_BRTAKEN
7108 || r_type
== elfcpp::R_POWERPC_REL14_BRNTAKEN
)
7109 max_branch_offset
= 1 << 15;
7110 if (max_branch_offset
!= 0
7111 && value
- address
+ max_branch_offset
>= 2 * max_branch_offset
)
7113 Stub_table
<size
, big_endian
>* stub_table
7114 = object
->stub_table(relinfo
->data_shndx
);
7115 if (stub_table
!= NULL
)
7117 Address off
= stub_table
->find_long_branch_entry(object
, value
);
7118 if (off
!= invalid_address
)
7120 value
= (stub_table
->stub_address() + stub_table
->plt_size()
7122 has_stub_value
= true;
7130 case elfcpp::R_PPC64_REL64
:
7131 case elfcpp::R_POWERPC_REL32
:
7132 case elfcpp::R_POWERPC_REL24
:
7133 case elfcpp::R_PPC_PLTREL24
:
7134 case elfcpp::R_PPC_LOCAL24PC
:
7135 case elfcpp::R_POWERPC_REL16
:
7136 case elfcpp::R_POWERPC_REL16_LO
:
7137 case elfcpp::R_POWERPC_REL16_HI
:
7138 case elfcpp::R_POWERPC_REL16_HA
:
7139 case elfcpp::R_POWERPC_REL14
:
7140 case elfcpp::R_POWERPC_REL14_BRTAKEN
:
7141 case elfcpp::R_POWERPC_REL14_BRNTAKEN
:
7145 case elfcpp::R_PPC64_TOC16
:
7146 case elfcpp::R_PPC64_TOC16_LO
:
7147 case elfcpp::R_PPC64_TOC16_HI
:
7148 case elfcpp::R_PPC64_TOC16_HA
:
7149 case elfcpp::R_PPC64_TOC16_DS
:
7150 case elfcpp::R_PPC64_TOC16_LO_DS
:
7151 // Subtract the TOC base address.
7152 value
-= (target
->got_section()->output_section()->address()
7153 + object
->toc_base_offset());
7156 case elfcpp::R_POWERPC_SECTOFF
:
7157 case elfcpp::R_POWERPC_SECTOFF_LO
:
7158 case elfcpp::R_POWERPC_SECTOFF_HI
:
7159 case elfcpp::R_POWERPC_SECTOFF_HA
:
7160 case elfcpp::R_PPC64_SECTOFF_DS
:
7161 case elfcpp::R_PPC64_SECTOFF_LO_DS
:
7163 value
-= os
->address();
7166 case elfcpp::R_PPC64_TPREL16_DS
:
7167 case elfcpp::R_PPC64_TPREL16_LO_DS
:
7168 case elfcpp::R_PPC64_TPREL16_HIGH
:
7169 case elfcpp::R_PPC64_TPREL16_HIGHA
:
7171 // R_PPC_TLSGD, R_PPC_TLSLD, R_PPC_EMB_RELST_LO, R_PPC_EMB_RELST_HI
7173 case elfcpp::R_POWERPC_TPREL16
:
7174 case elfcpp::R_POWERPC_TPREL16_LO
:
7175 case elfcpp::R_POWERPC_TPREL16_HI
:
7176 case elfcpp::R_POWERPC_TPREL16_HA
:
7177 case elfcpp::R_POWERPC_TPREL
:
7178 case elfcpp::R_PPC64_TPREL16_HIGHER
:
7179 case elfcpp::R_PPC64_TPREL16_HIGHERA
:
7180 case elfcpp::R_PPC64_TPREL16_HIGHEST
:
7181 case elfcpp::R_PPC64_TPREL16_HIGHESTA
:
7182 // tls symbol values are relative to tls_segment()->vaddr()
7186 case elfcpp::R_PPC64_DTPREL16_DS
:
7187 case elfcpp::R_PPC64_DTPREL16_LO_DS
:
7188 case elfcpp::R_PPC64_DTPREL16_HIGHER
:
7189 case elfcpp::R_PPC64_DTPREL16_HIGHERA
:
7190 case elfcpp::R_PPC64_DTPREL16_HIGHEST
:
7191 case elfcpp::R_PPC64_DTPREL16_HIGHESTA
:
7193 // R_PPC_EMB_NADDR32, R_PPC_EMB_NADDR16, R_PPC_EMB_NADDR16_LO
7194 // R_PPC_EMB_NADDR16_HI, R_PPC_EMB_NADDR16_HA, R_PPC_EMB_SDAI16
7196 case elfcpp::R_POWERPC_DTPREL16
:
7197 case elfcpp::R_POWERPC_DTPREL16_LO
:
7198 case elfcpp::R_POWERPC_DTPREL16_HI
:
7199 case elfcpp::R_POWERPC_DTPREL16_HA
:
7200 case elfcpp::R_POWERPC_DTPREL
:
7201 case elfcpp::R_PPC64_DTPREL16_HIGH
:
7202 case elfcpp::R_PPC64_DTPREL16_HIGHA
:
7203 // tls symbol values are relative to tls_segment()->vaddr()
7204 value
-= dtp_offset
;
7207 case elfcpp::R_PPC64_ADDR64_LOCAL
:
7209 value
+= object
->ppc64_local_entry_offset(gsym
);
7211 value
+= object
->ppc64_local_entry_offset(r_sym
);
7218 Insn branch_bit
= 0;
7221 case elfcpp::R_POWERPC_ADDR14_BRTAKEN
:
7222 case elfcpp::R_POWERPC_REL14_BRTAKEN
:
7223 branch_bit
= 1 << 21;
7224 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN
:
7225 case elfcpp::R_POWERPC_REL14_BRNTAKEN
:
7227 Insn
* iview
= reinterpret_cast<Insn
*>(view
);
7228 Insn insn
= elfcpp::Swap
<32, big_endian
>::readval(iview
);
7231 if (this->is_isa_v2
)
7233 // Set 'a' bit. This is 0b00010 in BO field for branch
7234 // on CR(BI) insns (BO == 001at or 011at), and 0b01000
7235 // for branch on CTR insns (BO == 1a00t or 1a01t).
7236 if ((insn
& (0x14 << 21)) == (0x04 << 21))
7238 else if ((insn
& (0x14 << 21)) == (0x10 << 21))
7245 // Invert 'y' bit if not the default.
7246 if (static_cast<Signed_address
>(value
) < 0)
7249 elfcpp::Swap
<32, big_endian
>::writeval(iview
, insn
);
7259 // Multi-instruction sequences that access the TOC can be
7260 // optimized, eg. addis ra,r2,0; addi rb,ra,x;
7261 // to nop; addi rb,r2,x;
7267 case elfcpp::R_POWERPC_GOT_TLSLD16_HA
:
7268 case elfcpp::R_POWERPC_GOT_TLSGD16_HA
:
7269 case elfcpp::R_POWERPC_GOT_TPREL16_HA
:
7270 case elfcpp::R_POWERPC_GOT_DTPREL16_HA
:
7271 case elfcpp::R_POWERPC_GOT16_HA
:
7272 case elfcpp::R_PPC64_TOC16_HA
:
7273 if (parameters
->options().toc_optimize())
7275 Insn
* iview
= reinterpret_cast<Insn
*>(view
- 2 * big_endian
);
7276 Insn insn
= elfcpp::Swap
<32, big_endian
>::readval(iview
);
7277 if ((insn
& ((0x3f << 26) | 0x1f << 16))
7278 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */)
7279 gold_error_at_location(relinfo
, relnum
, rela
.get_r_offset(),
7280 _("toc optimization is not supported "
7281 "for %#08x instruction"), insn
);
7282 else if (value
+ 0x8000 < 0x10000)
7284 elfcpp::Swap
<32, big_endian
>::writeval(iview
, nop
);
7290 case elfcpp::R_POWERPC_GOT_TLSLD16_LO
:
7291 case elfcpp::R_POWERPC_GOT_TLSGD16_LO
:
7292 case elfcpp::R_POWERPC_GOT_TPREL16_LO
:
7293 case elfcpp::R_POWERPC_GOT_DTPREL16_LO
:
7294 case elfcpp::R_POWERPC_GOT16_LO
:
7295 case elfcpp::R_PPC64_GOT16_LO_DS
:
7296 case elfcpp::R_PPC64_TOC16_LO
:
7297 case elfcpp::R_PPC64_TOC16_LO_DS
:
7298 if (parameters
->options().toc_optimize())
7300 Insn
* iview
= reinterpret_cast<Insn
*>(view
- 2 * big_endian
);
7301 Insn insn
= elfcpp::Swap
<32, big_endian
>::readval(iview
);
7302 if (!ok_lo_toc_insn(insn
))
7303 gold_error_at_location(relinfo
, relnum
, rela
.get_r_offset(),
7304 _("toc optimization is not supported "
7305 "for %#08x instruction"), insn
);
7306 else if (value
+ 0x8000 < 0x10000)
7308 if ((insn
& (0x3f << 26)) == 12u << 26 /* addic */)
7310 // Transform addic to addi when we change reg.
7311 insn
&= ~((0x3f << 26) | (0x1f << 16));
7312 insn
|= (14u << 26) | (2 << 16);
7316 insn
&= ~(0x1f << 16);
7319 elfcpp::Swap
<32, big_endian
>::writeval(iview
, insn
);
7326 typename
Reloc::Overflow_check overflow
= Reloc::CHECK_NONE
;
7327 elfcpp::Shdr
<size
, big_endian
> shdr(relinfo
->data_shdr
);
7330 case elfcpp::R_POWERPC_ADDR32
:
7331 case elfcpp::R_POWERPC_UADDR32
:
7333 overflow
= Reloc::CHECK_BITFIELD
;
7336 case elfcpp::R_POWERPC_REL32
:
7338 overflow
= Reloc::CHECK_SIGNED
;
7341 case elfcpp::R_POWERPC_UADDR16
:
7342 overflow
= Reloc::CHECK_BITFIELD
;
7345 case elfcpp::R_POWERPC_ADDR16
:
7346 // We really should have three separate relocations,
7347 // one for 16-bit data, one for insns with 16-bit signed fields,
7348 // and one for insns with 16-bit unsigned fields.
7349 overflow
= Reloc::CHECK_BITFIELD
;
7350 if ((shdr
.get_sh_flags() & elfcpp::SHF_EXECINSTR
) != 0)
7351 overflow
= Reloc::CHECK_LOW_INSN
;
7354 case elfcpp::R_POWERPC_ADDR16_HI
:
7355 case elfcpp::R_POWERPC_ADDR16_HA
:
7356 case elfcpp::R_POWERPC_GOT16_HI
:
7357 case elfcpp::R_POWERPC_GOT16_HA
:
7358 case elfcpp::R_POWERPC_PLT16_HI
:
7359 case elfcpp::R_POWERPC_PLT16_HA
:
7360 case elfcpp::R_POWERPC_SECTOFF_HI
:
7361 case elfcpp::R_POWERPC_SECTOFF_HA
:
7362 case elfcpp::R_PPC64_TOC16_HI
:
7363 case elfcpp::R_PPC64_TOC16_HA
:
7364 case elfcpp::R_PPC64_PLTGOT16_HI
:
7365 case elfcpp::R_PPC64_PLTGOT16_HA
:
7366 case elfcpp::R_POWERPC_TPREL16_HI
:
7367 case elfcpp::R_POWERPC_TPREL16_HA
:
7368 case elfcpp::R_POWERPC_DTPREL16_HI
:
7369 case elfcpp::R_POWERPC_DTPREL16_HA
:
7370 case elfcpp::R_POWERPC_GOT_TLSGD16_HI
:
7371 case elfcpp::R_POWERPC_GOT_TLSGD16_HA
:
7372 case elfcpp::R_POWERPC_GOT_TLSLD16_HI
:
7373 case elfcpp::R_POWERPC_GOT_TLSLD16_HA
:
7374 case elfcpp::R_POWERPC_GOT_TPREL16_HI
:
7375 case elfcpp::R_POWERPC_GOT_TPREL16_HA
:
7376 case elfcpp::R_POWERPC_GOT_DTPREL16_HI
:
7377 case elfcpp::R_POWERPC_GOT_DTPREL16_HA
:
7378 case elfcpp::R_POWERPC_REL16_HI
:
7379 case elfcpp::R_POWERPC_REL16_HA
:
7381 overflow
= Reloc::CHECK_HIGH_INSN
;
7384 case elfcpp::R_POWERPC_REL16
:
7385 case elfcpp::R_PPC64_TOC16
:
7386 case elfcpp::R_POWERPC_GOT16
:
7387 case elfcpp::R_POWERPC_SECTOFF
:
7388 case elfcpp::R_POWERPC_TPREL16
:
7389 case elfcpp::R_POWERPC_DTPREL16
:
7390 case elfcpp::R_POWERPC_GOT_TLSGD16
:
7391 case elfcpp::R_POWERPC_GOT_TLSLD16
:
7392 case elfcpp::R_POWERPC_GOT_TPREL16
:
7393 case elfcpp::R_POWERPC_GOT_DTPREL16
:
7394 overflow
= Reloc::CHECK_LOW_INSN
;
7397 case elfcpp::R_POWERPC_ADDR24
:
7398 case elfcpp::R_POWERPC_ADDR14
:
7399 case elfcpp::R_POWERPC_ADDR14_BRTAKEN
:
7400 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN
:
7401 case elfcpp::R_PPC64_ADDR16_DS
:
7402 case elfcpp::R_POWERPC_REL24
:
7403 case elfcpp::R_PPC_PLTREL24
:
7404 case elfcpp::R_PPC_LOCAL24PC
:
7405 case elfcpp::R_PPC64_TPREL16_DS
:
7406 case elfcpp::R_PPC64_DTPREL16_DS
:
7407 case elfcpp::R_PPC64_TOC16_DS
:
7408 case elfcpp::R_PPC64_GOT16_DS
:
7409 case elfcpp::R_PPC64_SECTOFF_DS
:
7410 case elfcpp::R_POWERPC_REL14
:
7411 case elfcpp::R_POWERPC_REL14_BRTAKEN
:
7412 case elfcpp::R_POWERPC_REL14_BRNTAKEN
:
7413 overflow
= Reloc::CHECK_SIGNED
;
7417 if (overflow
== Reloc::CHECK_LOW_INSN
7418 || overflow
== Reloc::CHECK_HIGH_INSN
)
7420 Insn
* iview
= reinterpret_cast<Insn
*>(view
- 2 * big_endian
);
7421 Insn insn
= elfcpp::Swap
<32, big_endian
>::readval(iview
);
7423 overflow
= Reloc::CHECK_SIGNED
;
7424 if ((insn
& (0x3f << 26)) == 10u << 26 /* cmpli */)
7425 overflow
= Reloc::CHECK_BITFIELD
;
7426 else if (overflow
== Reloc::CHECK_LOW_INSN
7427 ? ((insn
& (0x3f << 26)) == 28u << 26 /* andi */
7428 || (insn
& (0x3f << 26)) == 24u << 26 /* ori */
7429 || (insn
& (0x3f << 26)) == 26u << 26 /* xori */)
7430 : ((insn
& (0x3f << 26)) == 29u << 26 /* andis */
7431 || (insn
& (0x3f << 26)) == 25u << 26 /* oris */
7432 || (insn
& (0x3f << 26)) == 27u << 26 /* xoris */))
7433 overflow
= Reloc::CHECK_UNSIGNED
;
7436 typename Powerpc_relocate_functions
<size
, big_endian
>::Status status
7437 = Powerpc_relocate_functions
<size
, big_endian
>::STATUS_OK
;
7440 case elfcpp::R_POWERPC_NONE
:
7441 case elfcpp::R_POWERPC_TLS
:
7442 case elfcpp::R_POWERPC_GNU_VTINHERIT
:
7443 case elfcpp::R_POWERPC_GNU_VTENTRY
:
7446 case elfcpp::R_PPC64_ADDR64
:
7447 case elfcpp::R_PPC64_REL64
:
7448 case elfcpp::R_PPC64_TOC
:
7449 case elfcpp::R_PPC64_ADDR64_LOCAL
:
7450 Reloc::addr64(view
, value
);
7453 case elfcpp::R_POWERPC_TPREL
:
7454 case elfcpp::R_POWERPC_DTPREL
:
7456 Reloc::addr64(view
, value
);
7458 status
= Reloc::addr32(view
, value
, overflow
);
7461 case elfcpp::R_PPC64_UADDR64
:
7462 Reloc::addr64_u(view
, value
);
7465 case elfcpp::R_POWERPC_ADDR32
:
7466 status
= Reloc::addr32(view
, value
, overflow
);
7469 case elfcpp::R_POWERPC_REL32
:
7470 case elfcpp::R_POWERPC_UADDR32
:
7471 status
= Reloc::addr32_u(view
, value
, overflow
);
7474 case elfcpp::R_POWERPC_ADDR24
:
7475 case elfcpp::R_POWERPC_REL24
:
7476 case elfcpp::R_PPC_PLTREL24
:
7477 case elfcpp::R_PPC_LOCAL24PC
:
7478 status
= Reloc::addr24(view
, value
, overflow
);
7481 case elfcpp::R_POWERPC_GOT_DTPREL16
:
7482 case elfcpp::R_POWERPC_GOT_DTPREL16_LO
:
7485 status
= Reloc::addr16_ds(view
, value
, overflow
);
7488 case elfcpp::R_POWERPC_ADDR16
:
7489 case elfcpp::R_POWERPC_REL16
:
7490 case elfcpp::R_PPC64_TOC16
:
7491 case elfcpp::R_POWERPC_GOT16
:
7492 case elfcpp::R_POWERPC_SECTOFF
:
7493 case elfcpp::R_POWERPC_TPREL16
:
7494 case elfcpp::R_POWERPC_DTPREL16
:
7495 case elfcpp::R_POWERPC_GOT_TLSGD16
:
7496 case elfcpp::R_POWERPC_GOT_TLSLD16
:
7497 case elfcpp::R_POWERPC_GOT_TPREL16
:
7498 case elfcpp::R_POWERPC_ADDR16_LO
:
7499 case elfcpp::R_POWERPC_REL16_LO
:
7500 case elfcpp::R_PPC64_TOC16_LO
:
7501 case elfcpp::R_POWERPC_GOT16_LO
:
7502 case elfcpp::R_POWERPC_SECTOFF_LO
:
7503 case elfcpp::R_POWERPC_TPREL16_LO
:
7504 case elfcpp::R_POWERPC_DTPREL16_LO
:
7505 case elfcpp::R_POWERPC_GOT_TLSGD16_LO
:
7506 case elfcpp::R_POWERPC_GOT_TLSLD16_LO
:
7507 case elfcpp::R_POWERPC_GOT_TPREL16_LO
:
7508 status
= Reloc::addr16(view
, value
, overflow
);
7511 case elfcpp::R_POWERPC_UADDR16
:
7512 status
= Reloc::addr16_u(view
, value
, overflow
);
7515 case elfcpp::R_PPC64_ADDR16_HIGH
:
7516 case elfcpp::R_PPC64_TPREL16_HIGH
:
7517 case elfcpp::R_PPC64_DTPREL16_HIGH
:
7519 // R_PPC_EMB_MRKREF, R_PPC_EMB_RELST_LO, R_PPC_EMB_RELST_HA
7521 case elfcpp::R_POWERPC_ADDR16_HI
:
7522 case elfcpp::R_POWERPC_REL16_HI
:
7523 case elfcpp::R_PPC64_TOC16_HI
:
7524 case elfcpp::R_POWERPC_GOT16_HI
:
7525 case elfcpp::R_POWERPC_SECTOFF_HI
:
7526 case elfcpp::R_POWERPC_TPREL16_HI
:
7527 case elfcpp::R_POWERPC_DTPREL16_HI
:
7528 case elfcpp::R_POWERPC_GOT_TLSGD16_HI
:
7529 case elfcpp::R_POWERPC_GOT_TLSLD16_HI
:
7530 case elfcpp::R_POWERPC_GOT_TPREL16_HI
:
7531 case elfcpp::R_POWERPC_GOT_DTPREL16_HI
:
7532 Reloc::addr16_hi(view
, value
);
7535 case elfcpp::R_PPC64_ADDR16_HIGHA
:
7536 case elfcpp::R_PPC64_TPREL16_HIGHA
:
7537 case elfcpp::R_PPC64_DTPREL16_HIGHA
:
7539 // R_PPC_EMB_RELSEC16, R_PPC_EMB_RELST_HI, R_PPC_EMB_BIT_FLD
7541 case elfcpp::R_POWERPC_ADDR16_HA
:
7542 case elfcpp::R_POWERPC_REL16_HA
:
7543 case elfcpp::R_PPC64_TOC16_HA
:
7544 case elfcpp::R_POWERPC_GOT16_HA
:
7545 case elfcpp::R_POWERPC_SECTOFF_HA
:
7546 case elfcpp::R_POWERPC_TPREL16_HA
:
7547 case elfcpp::R_POWERPC_DTPREL16_HA
:
7548 case elfcpp::R_POWERPC_GOT_TLSGD16_HA
:
7549 case elfcpp::R_POWERPC_GOT_TLSLD16_HA
:
7550 case elfcpp::R_POWERPC_GOT_TPREL16_HA
:
7551 case elfcpp::R_POWERPC_GOT_DTPREL16_HA
:
7552 Reloc::addr16_ha(view
, value
);
7555 case elfcpp::R_PPC64_DTPREL16_HIGHER
:
7557 // R_PPC_EMB_NADDR16_LO
7559 case elfcpp::R_PPC64_ADDR16_HIGHER
:
7560 case elfcpp::R_PPC64_TPREL16_HIGHER
:
7561 Reloc::addr16_hi2(view
, value
);
7564 case elfcpp::R_PPC64_DTPREL16_HIGHERA
:
7566 // R_PPC_EMB_NADDR16_HI
7568 case elfcpp::R_PPC64_ADDR16_HIGHERA
:
7569 case elfcpp::R_PPC64_TPREL16_HIGHERA
:
7570 Reloc::addr16_ha2(view
, value
);
7573 case elfcpp::R_PPC64_DTPREL16_HIGHEST
:
7575 // R_PPC_EMB_NADDR16_HA
7577 case elfcpp::R_PPC64_ADDR16_HIGHEST
:
7578 case elfcpp::R_PPC64_TPREL16_HIGHEST
:
7579 Reloc::addr16_hi3(view
, value
);
7582 case elfcpp::R_PPC64_DTPREL16_HIGHESTA
:
7586 case elfcpp::R_PPC64_ADDR16_HIGHESTA
:
7587 case elfcpp::R_PPC64_TPREL16_HIGHESTA
:
7588 Reloc::addr16_ha3(view
, value
);
7591 case elfcpp::R_PPC64_DTPREL16_DS
:
7592 case elfcpp::R_PPC64_DTPREL16_LO_DS
:
7594 // R_PPC_EMB_NADDR32, R_PPC_EMB_NADDR16
7596 case elfcpp::R_PPC64_TPREL16_DS
:
7597 case elfcpp::R_PPC64_TPREL16_LO_DS
:
7599 // R_PPC_TLSGD, R_PPC_TLSLD
7601 case elfcpp::R_PPC64_ADDR16_DS
:
7602 case elfcpp::R_PPC64_ADDR16_LO_DS
:
7603 case elfcpp::R_PPC64_TOC16_DS
:
7604 case elfcpp::R_PPC64_TOC16_LO_DS
:
7605 case elfcpp::R_PPC64_GOT16_DS
:
7606 case elfcpp::R_PPC64_GOT16_LO_DS
:
7607 case elfcpp::R_PPC64_SECTOFF_DS
:
7608 case elfcpp::R_PPC64_SECTOFF_LO_DS
:
7609 status
= Reloc::addr16_ds(view
, value
, overflow
);
7612 case elfcpp::R_POWERPC_ADDR14
:
7613 case elfcpp::R_POWERPC_ADDR14_BRTAKEN
:
7614 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN
:
7615 case elfcpp::R_POWERPC_REL14
:
7616 case elfcpp::R_POWERPC_REL14_BRTAKEN
:
7617 case elfcpp::R_POWERPC_REL14_BRNTAKEN
:
7618 status
= Reloc::addr14(view
, value
, overflow
);
7621 case elfcpp::R_POWERPC_COPY
:
7622 case elfcpp::R_POWERPC_GLOB_DAT
:
7623 case elfcpp::R_POWERPC_JMP_SLOT
:
7624 case elfcpp::R_POWERPC_RELATIVE
:
7625 case elfcpp::R_POWERPC_DTPMOD
:
7626 case elfcpp::R_PPC64_JMP_IREL
:
7627 case elfcpp::R_POWERPC_IRELATIVE
:
7628 gold_error_at_location(relinfo
, relnum
, rela
.get_r_offset(),
7629 _("unexpected reloc %u in object file"),
7633 case elfcpp::R_PPC_EMB_SDA21
:
7638 // R_PPC64_TOCSAVE. For the time being this can be ignored.
7642 case elfcpp::R_PPC_EMB_SDA2I16
:
7643 case elfcpp::R_PPC_EMB_SDA2REL
:
7646 // R_PPC64_TLSGD, R_PPC64_TLSLD
7649 case elfcpp::R_POWERPC_PLT32
:
7650 case elfcpp::R_POWERPC_PLTREL32
:
7651 case elfcpp::R_POWERPC_PLT16_LO
:
7652 case elfcpp::R_POWERPC_PLT16_HI
:
7653 case elfcpp::R_POWERPC_PLT16_HA
:
7654 case elfcpp::R_PPC_SDAREL16
:
7655 case elfcpp::R_POWERPC_ADDR30
:
7656 case elfcpp::R_PPC64_PLT64
:
7657 case elfcpp::R_PPC64_PLTREL64
:
7658 case elfcpp::R_PPC64_PLTGOT16
:
7659 case elfcpp::R_PPC64_PLTGOT16_LO
:
7660 case elfcpp::R_PPC64_PLTGOT16_HI
:
7661 case elfcpp::R_PPC64_PLTGOT16_HA
:
7662 case elfcpp::R_PPC64_PLT16_LO_DS
:
7663 case elfcpp::R_PPC64_PLTGOT16_DS
:
7664 case elfcpp::R_PPC64_PLTGOT16_LO_DS
:
7665 case elfcpp::R_PPC_EMB_RELSDA
:
7666 case elfcpp::R_PPC_TOC16
:
7669 gold_error_at_location(relinfo
, relnum
, rela
.get_r_offset(),
7670 _("unsupported reloc %u"),
7674 if (status
!= Powerpc_relocate_functions
<size
, big_endian
>::STATUS_OK
7677 && gsym
->is_weak_undefined()
7678 && is_branch_reloc(r_type
)))
7680 gold_error_at_location(relinfo
, relnum
, rela
.get_r_offset(),
7681 _("relocation overflow"));
7683 gold_info(_("try relinking with a smaller --stub-group-size"));
7689 // Relocate section data.
7691 template<int size
, bool big_endian
>
7693 Target_powerpc
<size
, big_endian
>::relocate_section(
7694 const Relocate_info
<size
, big_endian
>* relinfo
,
7695 unsigned int sh_type
,
7696 const unsigned char* prelocs
,
7698 Output_section
* output_section
,
7699 bool needs_special_offset_handling
,
7700 unsigned char* view
,
7702 section_size_type view_size
,
7703 const Reloc_symbol_changes
* reloc_symbol_changes
)
7705 typedef Target_powerpc
<size
, big_endian
> Powerpc
;
7706 typedef typename Target_powerpc
<size
, big_endian
>::Relocate Powerpc_relocate
;
7707 typedef typename Target_powerpc
<size
, big_endian
>::Relocate_comdat_behavior
7708 Powerpc_comdat_behavior
;
7710 gold_assert(sh_type
== elfcpp::SHT_RELA
);
7712 gold::relocate_section
<size
, big_endian
, Powerpc
, elfcpp::SHT_RELA
,
7713 Powerpc_relocate
, Powerpc_comdat_behavior
>(
7719 needs_special_offset_handling
,
7723 reloc_symbol_changes
);
7726 class Powerpc_scan_relocatable_reloc
7729 // Return the strategy to use for a local symbol which is not a
7730 // section symbol, given the relocation type.
7731 inline Relocatable_relocs::Reloc_strategy
7732 local_non_section_strategy(unsigned int r_type
, Relobj
*, unsigned int r_sym
)
7734 if (r_type
== 0 && r_sym
== 0)
7735 return Relocatable_relocs::RELOC_DISCARD
;
7736 return Relocatable_relocs::RELOC_COPY
;
7739 // Return the strategy to use for a local symbol which is a section
7740 // symbol, given the relocation type.
7741 inline Relocatable_relocs::Reloc_strategy
7742 local_section_strategy(unsigned int, Relobj
*)
7744 return Relocatable_relocs::RELOC_ADJUST_FOR_SECTION_RELA
;
7747 // Return the strategy to use for a global symbol, given the
7748 // relocation type, the object, and the symbol index.
7749 inline Relocatable_relocs::Reloc_strategy
7750 global_strategy(unsigned int r_type
, Relobj
*, unsigned int)
7752 if (r_type
== elfcpp::R_PPC_PLTREL24
)
7753 return Relocatable_relocs::RELOC_SPECIAL
;
7754 return Relocatable_relocs::RELOC_COPY
;
7758 // Scan the relocs during a relocatable link.
7760 template<int size
, bool big_endian
>
7762 Target_powerpc
<size
, big_endian
>::scan_relocatable_relocs(
7763 Symbol_table
* symtab
,
7765 Sized_relobj_file
<size
, big_endian
>* object
,
7766 unsigned int data_shndx
,
7767 unsigned int sh_type
,
7768 const unsigned char* prelocs
,
7770 Output_section
* output_section
,
7771 bool needs_special_offset_handling
,
7772 size_t local_symbol_count
,
7773 const unsigned char* plocal_symbols
,
7774 Relocatable_relocs
* rr
)
7776 gold_assert(sh_type
== elfcpp::SHT_RELA
);
7778 gold::scan_relocatable_relocs
<size
, big_endian
, elfcpp::SHT_RELA
,
7779 Powerpc_scan_relocatable_reloc
>(
7787 needs_special_offset_handling
,
7793 // Emit relocations for a section.
7794 // This is a modified version of the function by the same name in
7795 // target-reloc.h. Using relocate_special_relocatable for
7796 // R_PPC_PLTREL24 would require duplication of the entire body of the
7797 // loop, so we may as well duplicate the whole thing.
7799 template<int size
, bool big_endian
>
7801 Target_powerpc
<size
, big_endian
>::relocate_relocs(
7802 const Relocate_info
<size
, big_endian
>* relinfo
,
7803 unsigned int sh_type
,
7804 const unsigned char* prelocs
,
7806 Output_section
* output_section
,
7807 typename
elfcpp::Elf_types
<size
>::Elf_Off offset_in_output_section
,
7808 const Relocatable_relocs
* rr
,
7810 Address view_address
,
7812 unsigned char* reloc_view
,
7813 section_size_type reloc_view_size
)
7815 gold_assert(sh_type
== elfcpp::SHT_RELA
);
7817 typedef typename Reloc_types
<elfcpp::SHT_RELA
, size
, big_endian
>::Reloc
7819 typedef typename Reloc_types
<elfcpp::SHT_RELA
, size
, big_endian
>::Reloc_write
7821 const int reloc_size
7822 = Reloc_types
<elfcpp::SHT_RELA
, size
, big_endian
>::reloc_size
;
7824 Powerpc_relobj
<size
, big_endian
>* const object
7825 = static_cast<Powerpc_relobj
<size
, big_endian
>*>(relinfo
->object
);
7826 const unsigned int local_count
= object
->local_symbol_count();
7827 unsigned int got2_shndx
= object
->got2_shndx();
7828 Address got2_addend
= 0;
7829 if (got2_shndx
!= 0)
7831 got2_addend
= object
->get_output_section_offset(got2_shndx
);
7832 gold_assert(got2_addend
!= invalid_address
);
7835 unsigned char* pwrite
= reloc_view
;
7836 bool zap_next
= false;
7837 for (size_t i
= 0; i
< reloc_count
; ++i
, prelocs
+= reloc_size
)
7839 Relocatable_relocs::Reloc_strategy strategy
= rr
->strategy(i
);
7840 if (strategy
== Relocatable_relocs::RELOC_DISCARD
)
7843 Reltype
reloc(prelocs
);
7844 Reltype_write
reloc_write(pwrite
);
7846 Address offset
= reloc
.get_r_offset();
7847 typename
elfcpp::Elf_types
<size
>::Elf_WXword r_info
= reloc
.get_r_info();
7848 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(r_info
);
7849 unsigned int r_type
= elfcpp::elf_r_type
<size
>(r_info
);
7850 const unsigned int orig_r_sym
= r_sym
;
7851 typename
elfcpp::Elf_types
<size
>::Elf_Swxword addend
7852 = reloc
.get_r_addend();
7853 const Symbol
* gsym
= NULL
;
7857 // We could arrange to discard these and other relocs for
7858 // tls optimised sequences in the strategy methods, but for
7859 // now do as BFD ld does.
7860 r_type
= elfcpp::R_POWERPC_NONE
;
7864 // Get the new symbol index.
7865 if (r_sym
< local_count
)
7869 case Relocatable_relocs::RELOC_COPY
:
7870 case Relocatable_relocs::RELOC_SPECIAL
:
7873 r_sym
= object
->symtab_index(r_sym
);
7874 gold_assert(r_sym
!= -1U);
7878 case Relocatable_relocs::RELOC_ADJUST_FOR_SECTION_RELA
:
7880 // We are adjusting a section symbol. We need to find
7881 // the symbol table index of the section symbol for
7882 // the output section corresponding to input section
7883 // in which this symbol is defined.
7884 gold_assert(r_sym
< local_count
);
7886 unsigned int shndx
=
7887 object
->local_symbol_input_shndx(r_sym
, &is_ordinary
);
7888 gold_assert(is_ordinary
);
7889 Output_section
* os
= object
->output_section(shndx
);
7890 gold_assert(os
!= NULL
);
7891 gold_assert(os
->needs_symtab_index());
7892 r_sym
= os
->symtab_index();
7902 gsym
= object
->global_symbol(r_sym
);
7903 gold_assert(gsym
!= NULL
);
7904 if (gsym
->is_forwarder())
7905 gsym
= relinfo
->symtab
->resolve_forwards(gsym
);
7907 gold_assert(gsym
->has_symtab_index());
7908 r_sym
= gsym
->symtab_index();
7911 // Get the new offset--the location in the output section where
7912 // this relocation should be applied.
7913 if (static_cast<Address
>(offset_in_output_section
) != invalid_address
)
7914 offset
+= offset_in_output_section
;
7917 section_offset_type sot_offset
=
7918 convert_types
<section_offset_type
, Address
>(offset
);
7919 section_offset_type new_sot_offset
=
7920 output_section
->output_offset(object
, relinfo
->data_shndx
,
7922 gold_assert(new_sot_offset
!= -1);
7923 offset
= new_sot_offset
;
7926 // In an object file, r_offset is an offset within the section.
7927 // In an executable or dynamic object, generated by
7928 // --emit-relocs, r_offset is an absolute address.
7929 if (!parameters
->options().relocatable())
7931 offset
+= view_address
;
7932 if (static_cast<Address
>(offset_in_output_section
) != invalid_address
)
7933 offset
-= offset_in_output_section
;
7936 // Handle the reloc addend based on the strategy.
7937 if (strategy
== Relocatable_relocs::RELOC_COPY
)
7939 else if (strategy
== Relocatable_relocs::RELOC_ADJUST_FOR_SECTION_RELA
)
7941 const Symbol_value
<size
>* psymval
= object
->local_symbol(orig_r_sym
);
7942 addend
= psymval
->value(object
, addend
);
7944 else if (strategy
== Relocatable_relocs::RELOC_SPECIAL
)
7946 if (addend
>= 32768)
7947 addend
+= got2_addend
;
7952 if (!parameters
->options().relocatable())
7954 if (r_type
== elfcpp::R_POWERPC_GOT_TLSGD16
7955 || r_type
== elfcpp::R_POWERPC_GOT_TLSGD16_LO
7956 || r_type
== elfcpp::R_POWERPC_GOT_TLSGD16_HI
7957 || r_type
== elfcpp::R_POWERPC_GOT_TLSGD16_HA
)
7959 // First instruction of a global dynamic sequence,
7961 const bool final
= gsym
== NULL
|| gsym
->final_value_is_known();
7962 switch (this->optimize_tls_gd(final
))
7964 case tls::TLSOPT_TO_IE
:
7965 r_type
+= (elfcpp::R_POWERPC_GOT_TPREL16
7966 - elfcpp::R_POWERPC_GOT_TLSGD16
);
7968 case tls::TLSOPT_TO_LE
:
7969 if (r_type
== elfcpp::R_POWERPC_GOT_TLSGD16
7970 || r_type
== elfcpp::R_POWERPC_GOT_TLSGD16_LO
)
7971 r_type
= elfcpp::R_POWERPC_TPREL16_HA
;
7974 r_type
= elfcpp::R_POWERPC_NONE
;
7975 offset
-= 2 * big_endian
;
7982 else if (r_type
== elfcpp::R_POWERPC_GOT_TLSLD16
7983 || r_type
== elfcpp::R_POWERPC_GOT_TLSLD16_LO
7984 || r_type
== elfcpp::R_POWERPC_GOT_TLSLD16_HI
7985 || r_type
== elfcpp::R_POWERPC_GOT_TLSLD16_HA
)
7987 // First instruction of a local dynamic sequence,
7989 if (this->optimize_tls_ld() == tls::TLSOPT_TO_LE
)
7991 if (r_type
== elfcpp::R_POWERPC_GOT_TLSLD16
7992 || r_type
== elfcpp::R_POWERPC_GOT_TLSLD16_LO
)
7994 r_type
= elfcpp::R_POWERPC_TPREL16_HA
;
7995 const Output_section
* os
= relinfo
->layout
->tls_segment()
7997 gold_assert(os
!= NULL
);
7998 gold_assert(os
->needs_symtab_index());
7999 r_sym
= os
->symtab_index();
8000 addend
= dtp_offset
;
8004 r_type
= elfcpp::R_POWERPC_NONE
;
8005 offset
-= 2 * big_endian
;
8009 else if (r_type
== elfcpp::R_POWERPC_GOT_TPREL16
8010 || r_type
== elfcpp::R_POWERPC_GOT_TPREL16_LO
8011 || r_type
== elfcpp::R_POWERPC_GOT_TPREL16_HI
8012 || r_type
== elfcpp::R_POWERPC_GOT_TPREL16_HA
)
8014 // First instruction of initial exec sequence.
8015 const bool final
= gsym
== NULL
|| gsym
->final_value_is_known();
8016 if (this->optimize_tls_ie(final
) == tls::TLSOPT_TO_LE
)
8018 if (r_type
== elfcpp::R_POWERPC_GOT_TPREL16
8019 || r_type
== elfcpp::R_POWERPC_GOT_TPREL16_LO
)
8020 r_type
= elfcpp::R_POWERPC_TPREL16_HA
;
8023 r_type
= elfcpp::R_POWERPC_NONE
;
8024 offset
-= 2 * big_endian
;
8028 else if ((size
== 64 && r_type
== elfcpp::R_PPC64_TLSGD
)
8029 || (size
== 32 && r_type
== elfcpp::R_PPC_TLSGD
))
8031 // Second instruction of a global dynamic sequence,
8032 // the __tls_get_addr call
8033 const bool final
= gsym
== NULL
|| gsym
->final_value_is_known();
8034 switch (this->optimize_tls_gd(final
))
8036 case tls::TLSOPT_TO_IE
:
8037 r_type
= elfcpp::R_POWERPC_NONE
;
8040 case tls::TLSOPT_TO_LE
:
8041 r_type
= elfcpp::R_POWERPC_TPREL16_LO
;
8042 offset
+= 2 * big_endian
;
8049 else if ((size
== 64 && r_type
== elfcpp::R_PPC64_TLSLD
)
8050 || (size
== 32 && r_type
== elfcpp::R_PPC_TLSLD
))
8052 // Second instruction of a local dynamic sequence,
8053 // the __tls_get_addr call
8054 if (this->optimize_tls_ld() == tls::TLSOPT_TO_LE
)
8056 const Output_section
* os
= relinfo
->layout
->tls_segment()
8058 gold_assert(os
!= NULL
);
8059 gold_assert(os
->needs_symtab_index());
8060 r_sym
= os
->symtab_index();
8061 addend
= dtp_offset
;
8062 r_type
= elfcpp::R_POWERPC_TPREL16_LO
;
8063 offset
+= 2 * big_endian
;
8067 else if (r_type
== elfcpp::R_POWERPC_TLS
)
8069 // Second instruction of an initial exec sequence
8070 const bool final
= gsym
== NULL
|| gsym
->final_value_is_known();
8071 if (this->optimize_tls_ie(final
) == tls::TLSOPT_TO_LE
)
8073 r_type
= elfcpp::R_POWERPC_TPREL16_LO
;
8074 offset
+= 2 * big_endian
;
8079 reloc_write
.put_r_offset(offset
);
8080 reloc_write
.put_r_info(elfcpp::elf_r_info
<size
>(r_sym
, r_type
));
8081 reloc_write
.put_r_addend(addend
);
8083 pwrite
+= reloc_size
;
8086 gold_assert(static_cast<section_size_type
>(pwrite
- reloc_view
)
8087 == reloc_view_size
);
8090 // Return the value to use for a dynamic symbol which requires special
8091 // treatment. This is how we support equality comparisons of function
8092 // pointers across shared library boundaries, as described in the
8093 // processor specific ABI supplement.
8095 template<int size
, bool big_endian
>
8097 Target_powerpc
<size
, big_endian
>::do_dynsym_value(const Symbol
* gsym
) const
8101 gold_assert(gsym
->is_from_dynobj() && gsym
->has_plt_offset());
8102 for (typename
Stub_tables::const_iterator p
= this->stub_tables_
.begin();
8103 p
!= this->stub_tables_
.end();
8106 Address off
= (*p
)->find_plt_call_entry(gsym
);
8107 if (off
!= invalid_address
)
8108 return (*p
)->stub_address() + off
;
8111 else if (this->abiversion() >= 2)
8113 unsigned int off
= this->glink_section()->find_global_entry(gsym
);
8114 if (off
!= (unsigned int)-1)
8115 return this->glink_section()->global_entry_address() + off
;
8120 // Return the PLT address to use for a local symbol.
8121 template<int size
, bool big_endian
>
8123 Target_powerpc
<size
, big_endian
>::do_plt_address_for_local(
8124 const Relobj
* object
,
8125 unsigned int symndx
) const
8129 const Sized_relobj
<size
, big_endian
>* relobj
8130 = static_cast<const Sized_relobj
<size
, big_endian
>*>(object
);
8131 for (typename
Stub_tables::const_iterator p
= this->stub_tables_
.begin();
8132 p
!= this->stub_tables_
.end();
8135 Address off
= (*p
)->find_plt_call_entry(relobj
->sized_relobj(),
8137 if (off
!= invalid_address
)
8138 return (*p
)->stub_address() + off
;
8144 // Return the PLT address to use for a global symbol.
8145 template<int size
, bool big_endian
>
8147 Target_powerpc
<size
, big_endian
>::do_plt_address_for_global(
8148 const Symbol
* gsym
) const
8152 for (typename
Stub_tables::const_iterator p
= this->stub_tables_
.begin();
8153 p
!= this->stub_tables_
.end();
8156 Address off
= (*p
)->find_plt_call_entry(gsym
);
8157 if (off
!= invalid_address
)
8158 return (*p
)->stub_address() + off
;
8161 else if (this->abiversion() >= 2)
8163 unsigned int off
= this->glink_section()->find_global_entry(gsym
);
8164 if (off
!= (unsigned int)-1)
8165 return this->glink_section()->global_entry_address() + off
;
8170 // Return the offset to use for the GOT_INDX'th got entry which is
8171 // for a local tls symbol specified by OBJECT, SYMNDX.
8172 template<int size
, bool big_endian
>
8174 Target_powerpc
<size
, big_endian
>::do_tls_offset_for_local(
8175 const Relobj
* object
,
8176 unsigned int symndx
,
8177 unsigned int got_indx
) const
8179 const Powerpc_relobj
<size
, big_endian
>* ppc_object
8180 = static_cast<const Powerpc_relobj
<size
, big_endian
>*>(object
);
8181 if (ppc_object
->local_symbol(symndx
)->is_tls_symbol())
8183 for (Got_type got_type
= GOT_TYPE_TLSGD
;
8184 got_type
<= GOT_TYPE_TPREL
;
8185 got_type
= Got_type(got_type
+ 1))
8186 if (ppc_object
->local_has_got_offset(symndx
, got_type
))
8188 unsigned int off
= ppc_object
->local_got_offset(symndx
, got_type
);
8189 if (got_type
== GOT_TYPE_TLSGD
)
8191 if (off
== got_indx
* (size
/ 8))
8193 if (got_type
== GOT_TYPE_TPREL
)
8203 // Return the offset to use for the GOT_INDX'th got entry which is
8204 // for global tls symbol GSYM.
8205 template<int size
, bool big_endian
>
8207 Target_powerpc
<size
, big_endian
>::do_tls_offset_for_global(
8209 unsigned int got_indx
) const
8211 if (gsym
->type() == elfcpp::STT_TLS
)
8213 for (Got_type got_type
= GOT_TYPE_TLSGD
;
8214 got_type
<= GOT_TYPE_TPREL
;
8215 got_type
= Got_type(got_type
+ 1))
8216 if (gsym
->has_got_offset(got_type
))
8218 unsigned int off
= gsym
->got_offset(got_type
);
8219 if (got_type
== GOT_TYPE_TLSGD
)
8221 if (off
== got_indx
* (size
/ 8))
8223 if (got_type
== GOT_TYPE_TPREL
)
8233 // The selector for powerpc object files.
8235 template<int size
, bool big_endian
>
8236 class Target_selector_powerpc
: public Target_selector
8239 Target_selector_powerpc()
8240 : Target_selector(size
== 64 ? elfcpp::EM_PPC64
: elfcpp::EM_PPC
,
8243 ? (big_endian
? "elf64-powerpc" : "elf64-powerpcle")
8244 : (big_endian
? "elf32-powerpc" : "elf32-powerpcle")),
8246 ? (big_endian
? "elf64ppc" : "elf64lppc")
8247 : (big_endian
? "elf32ppc" : "elf32lppc")))
8251 do_instantiate_target()
8252 { return new Target_powerpc
<size
, big_endian
>(); }
8255 Target_selector_powerpc
<32, true> target_selector_ppc32
;
8256 Target_selector_powerpc
<32, false> target_selector_ppc32le
;
8257 Target_selector_powerpc
<64, true> target_selector_ppc64
;
8258 Target_selector_powerpc
<64, false> target_selector_ppc64le
;
8260 // Instantiate these constants for -O0
8261 template<int size
, bool big_endian
>
8262 const int Output_data_glink
<size
, big_endian
>::pltresolve_size
;
8263 template<int size
, bool big_endian
>
8264 const typename Output_data_glink
<size
, big_endian
>::Address
8265 Output_data_glink
<size
, big_endian
>::invalid_address
;
8266 template<int size
, bool big_endian
>
8267 const typename Stub_table
<size
, big_endian
>::Address
8268 Stub_table
<size
, big_endian
>::invalid_address
;
8269 template<int size
, bool big_endian
>
8270 const typename Target_powerpc
<size
, big_endian
>::Address
8271 Target_powerpc
<size
, big_endian
>::invalid_address
;
8273 } // End anonymous namespace.