1 // powerpc.cc -- powerpc target support for gold.
3 // Copyright 2008 Free Software Foundation, Inc.
4 // Written by David S. Miller <davem@davemloft.net>
5 // and David Edelsohn <edelsohn@gnu.org>
7 // This file is part of gold.
9 // This program is free software; you can redistribute it and/or modify
10 // it under the terms of the GNU General Public License as published by
11 // the Free Software Foundation; either version 3 of the License, or
12 // (at your option) any later version.
14 // This program is distributed in the hope that it will be useful,
15 // but WITHOUT ANY WARRANTY; without even the implied warranty of
16 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 // GNU General Public License for more details.
19 // You should have received a copy of the GNU General Public License
20 // along with this program; if not, write to the Free Software
21 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 // MA 02110-1301, USA.
27 #include "parameters.h"
34 #include "copy-relocs.h"
36 #include "target-reloc.h"
37 #include "target-select.h"
46 template<int size
, bool big_endian
>
47 class Output_data_plt_powerpc
;
49 template<int size
, bool big_endian
>
50 class Target_powerpc
: public Sized_target
<size
, big_endian
>
53 typedef Output_data_reloc
<elfcpp::SHT_RELA
, true, size
, big_endian
> Reloc_section
;
56 : Sized_target
<size
, big_endian
>(&powerpc_info
),
57 got_(NULL
), got2_(NULL
), toc_(NULL
),
58 plt_(NULL
), rela_dyn_(NULL
),
59 copy_relocs_(elfcpp::R_POWERPC_COPY
),
60 dynbss_(NULL
), got_mod_index_offset_(-1U)
64 // Scan the relocations to look for symbol adjustments.
66 scan_relocs(const General_options
& options
,
69 Sized_relobj
<size
, big_endian
>* object
,
70 unsigned int data_shndx
,
72 const unsigned char* prelocs
,
74 Output_section
* output_section
,
75 bool needs_special_offset_handling
,
76 size_t local_symbol_count
,
77 const unsigned char* plocal_symbols
);
78 // Finalize the sections.
80 do_finalize_sections(Layout
*);
82 // Return the value to use for a dynamic which requires special
85 do_dynsym_value(const Symbol
*) const;
87 // Relocate a section.
89 relocate_section(const Relocate_info
<size
, big_endian
>*,
91 const unsigned char* prelocs
,
93 Output_section
* output_section
,
94 bool needs_special_offset_handling
,
96 typename
elfcpp::Elf_types
<size
>::Elf_Addr view_address
,
97 section_size_type view_size
);
99 // Scan the relocs during a relocatable link.
101 scan_relocatable_relocs(const General_options
& options
,
102 Symbol_table
* symtab
,
104 Sized_relobj
<size
, big_endian
>* object
,
105 unsigned int data_shndx
,
106 unsigned int sh_type
,
107 const unsigned char* prelocs
,
109 Output_section
* output_section
,
110 bool needs_special_offset_handling
,
111 size_t local_symbol_count
,
112 const unsigned char* plocal_symbols
,
113 Relocatable_relocs
*);
115 // Relocate a section during a relocatable link.
117 relocate_for_relocatable(const Relocate_info
<size
, big_endian
>*,
118 unsigned int sh_type
,
119 const unsigned char* prelocs
,
121 Output_section
* output_section
,
122 off_t offset_in_output_section
,
123 const Relocatable_relocs
*,
125 typename
elfcpp::Elf_types
<size
>::Elf_Addr view_address
,
126 section_size_type view_size
,
127 unsigned char* reloc_view
,
128 section_size_type reloc_view_size
);
130 // Return whether SYM is defined by the ABI.
132 do_is_defined_by_abi(Symbol
* sym
) const
134 return strcmp(sym
->name(), "___tls_get_addr") == 0;
137 // Return the size of the GOT section.
141 gold_assert(this->got_
!= NULL
);
142 return this->got_
->data_size();
147 // The class which scans relocations.
152 : issued_non_pic_error_(false)
156 local(const General_options
& options
, Symbol_table
* symtab
,
157 Layout
* layout
, Target_powerpc
* target
,
158 Sized_relobj
<size
, big_endian
>* object
,
159 unsigned int data_shndx
,
160 Output_section
* output_section
,
161 const elfcpp::Rela
<size
, big_endian
>& reloc
, unsigned int r_type
,
162 const elfcpp::Sym
<size
, big_endian
>& lsym
);
165 global(const General_options
& options
, Symbol_table
* symtab
,
166 Layout
* layout
, Target_powerpc
* target
,
167 Sized_relobj
<size
, big_endian
>* object
,
168 unsigned int data_shndx
,
169 Output_section
* output_section
,
170 const elfcpp::Rela
<size
, big_endian
>& reloc
, unsigned int r_type
,
175 unsupported_reloc_local(Sized_relobj
<size
, big_endian
>*,
176 unsigned int r_type
);
179 unsupported_reloc_global(Sized_relobj
<size
, big_endian
>*,
180 unsigned int r_type
, Symbol
*);
183 generate_tls_call(Symbol_table
* symtab
, Layout
* layout
,
184 Target_powerpc
* target
);
187 check_non_pic(Relobj
*, unsigned int r_type
);
189 // Whether we have issued an error about a non-PIC compilation.
190 bool issued_non_pic_error_
;
193 // The class which implements relocation.
197 // Do a relocation. Return false if the caller should not issue
198 // any warnings about this relocation.
200 relocate(const Relocate_info
<size
, big_endian
>*, Target_powerpc
*,
201 size_t relnum
, const elfcpp::Rela
<size
, big_endian
>&,
202 unsigned int r_type
, const Sized_symbol
<size
>*,
203 const Symbol_value
<size
>*,
205 typename
elfcpp::Elf_types
<size
>::Elf_Addr
,
209 // Do a TLS relocation.
211 relocate_tls(const Relocate_info
<size
, big_endian
>*,
212 Target_powerpc
* target
,
213 size_t relnum
, const elfcpp::Rela
<size
, big_endian
>&,
214 unsigned int r_type
, const Sized_symbol
<size
>*,
215 const Symbol_value
<size
>*,
217 typename
elfcpp::Elf_types
<size
>::Elf_Addr
,
221 // A class which returns the size required for a relocation type,
222 // used while scanning relocs during a relocatable link.
223 class Relocatable_size_for_reloc
227 get_size_for_reloc(unsigned int, Relobj
*);
230 // Get the GOT section, creating it if necessary.
231 Output_data_got
<size
, big_endian
>*
232 got_section(Symbol_table
*, Layout
*);
237 gold_assert (this->got2_
!= NULL
);
241 // Get the TOC section.
245 gold_assert (this->toc_
!= NULL
);
249 // Create a PLT entry for a global symbol.
251 make_plt_entry(Symbol_table
*, Layout
*, Symbol
*);
253 // Create a GOT entry for the TLS module index.
255 got_mod_index_entry(Symbol_table
* symtab
, Layout
* layout
,
256 Sized_relobj
<size
, big_endian
>* object
);
258 // Get the PLT section.
259 const Output_data_plt_powerpc
<size
, big_endian
>*
262 gold_assert(this->plt_
!= NULL
);
266 // Get the dynamic reloc section, creating it if necessary.
268 rela_dyn_section(Layout
*);
270 // Return true if the symbol may need a COPY relocation.
271 // References from an executable object to non-function symbols
272 // defined in a dynamic object may need a COPY relocation.
274 may_need_copy_reloc(Symbol
* gsym
)
276 return (!parameters
->options().shared()
277 && gsym
->is_from_dynobj()
278 && gsym
->type() != elfcpp::STT_FUNC
);
281 // Copy a relocation against a global symbol.
283 copy_reloc(Symbol_table
* symtab
, Layout
* layout
, Relobj
* object
,
284 unsigned int shndx
, Output_section
* output_section
,
285 Symbol
* sym
, const elfcpp::Rela
<size
, big_endian
>& reloc
)
287 this->copy_relocs_
.copy_reloc(symtab
, layout
,
288 symtab
->get_sized_symbol
<size
>(sym
),
289 object
, shndx
, output_section
,
290 reloc
, this->rela_dyn_section(layout
));
293 // Information about this specific target which we pass to the
294 // general Target structure.
295 static Target::Target_info powerpc_info
;
297 // The types of GOT entries needed for this platform.
300 GOT_TYPE_STANDARD
= 0, // GOT entry for a regular symbol
301 GOT_TYPE_TLS_OFFSET
= 1, // GOT entry for TLS offset
302 GOT_TYPE_TLS_PAIR
= 2, // GOT entry for TLS module/offset pair
306 Output_data_got
<size
, big_endian
>* got_
;
308 Output_data_space
* got2_
;
310 Output_data_space
* toc_
;
312 Output_data_plt_powerpc
<size
, big_endian
>* plt_
;
313 // The dynamic reloc section.
314 Reloc_section
* rela_dyn_
;
315 // Relocs saved to avoid a COPY reloc.
316 Copy_relocs
<elfcpp::SHT_RELA
, size
, big_endian
> copy_relocs_
;
317 // Space for variables copied with a COPY reloc.
318 Output_data_space
* dynbss_
;
319 // Offset of the GOT entry for the TLS module index;
320 unsigned int got_mod_index_offset_
;
324 Target::Target_info Target_powerpc
<32, true>::powerpc_info
=
327 true, // is_big_endian
328 elfcpp::EM_PPC
, // machine_code
329 false, // has_make_symbol
330 false, // has_resolve
331 false, // has_code_fill
332 true, // is_default_stack_executable
334 "/usr/lib/ld.so.1", // dynamic_linker
335 0x10000000, // default_text_segment_address
336 64 * 1024, // abi_pagesize (overridable by -z max-page-size)
337 4 * 1024 // common_pagesize (overridable by -z common-page-size)
341 Target::Target_info Target_powerpc
<32, false>::powerpc_info
=
344 false, // is_big_endian
345 elfcpp::EM_PPC
, // machine_code
346 false, // has_make_symbol
347 false, // has_resolve
348 false, // has_code_fill
349 true, // is_default_stack_executable
351 "/usr/lib/ld.so.1", // dynamic_linker
352 0x10000000, // default_text_segment_address
353 64 * 1024, // abi_pagesize (overridable by -z max-page-size)
354 4 * 1024 // common_pagesize (overridable by -z common-page-size)
358 Target::Target_info Target_powerpc
<64, true>::powerpc_info
=
361 true, // is_big_endian
362 elfcpp::EM_PPC64
, // machine_code
363 false, // has_make_symbol
364 false, // has_resolve
365 false, // has_code_fill
366 true, // is_default_stack_executable
368 "/usr/lib/ld.so.1", // dynamic_linker
369 0x10000000, // default_text_segment_address
370 64 * 1024, // abi_pagesize (overridable by -z max-page-size)
371 8 * 1024 // common_pagesize (overridable by -z common-page-size)
375 Target::Target_info Target_powerpc
<64, false>::powerpc_info
=
378 false, // is_big_endian
379 elfcpp::EM_PPC64
, // machine_code
380 false, // has_make_symbol
381 false, // has_resolve
382 false, // has_code_fill
383 true, // is_default_stack_executable
385 "/usr/lib/ld.so.1", // dynamic_linker
386 0x10000000, // default_text_segment_address
387 64 * 1024, // abi_pagesize (overridable by -z max-page-size)
388 8 * 1024 // common_pagesize (overridable by -z common-page-size)
391 template<int size
, bool big_endian
>
392 class Powerpc_relocate_functions
395 // Do a simple relocation with the addend in the relocation.
396 template<int valsize
>
398 rela(unsigned char* view
,
399 unsigned int right_shift
,
400 elfcpp::Elf_Xword dst_mask
,
401 typename
elfcpp::Swap
<size
, big_endian
>::Valtype value
,
402 typename
elfcpp::Swap
<size
, big_endian
>::Valtype addend
)
404 typedef typename
elfcpp::Swap
<valsize
, big_endian
>::Valtype Valtype
;
405 Valtype
* wv
= reinterpret_cast<Valtype
*>(view
);
406 Valtype val
= elfcpp::Swap
<valsize
, big_endian
>::readval(wv
);
407 Valtype reloc
= ((value
+ addend
) >> right_shift
);
412 elfcpp::Swap
<valsize
, big_endian
>::writeval(wv
, val
| reloc
);
415 // Do a simple relocation using a symbol value with the addend in
417 template<int valsize
>
419 rela(unsigned char* view
,
420 unsigned int right_shift
,
421 elfcpp::Elf_Xword dst_mask
,
422 const Sized_relobj
<size
, big_endian
>* object
,
423 const Symbol_value
<size
>* psymval
,
424 typename
elfcpp::Swap
<valsize
, big_endian
>::Valtype addend
)
426 typedef typename
elfcpp::Swap
<valsize
, big_endian
>::Valtype Valtype
;
427 Valtype
* wv
= reinterpret_cast<Valtype
*>(view
);
428 Valtype val
= elfcpp::Swap
<valsize
, big_endian
>::readval(wv
);
429 Valtype reloc
= (psymval
->value(object
, addend
) >> right_shift
);
434 elfcpp::Swap
<valsize
, big_endian
>::writeval(wv
, val
| reloc
);
437 // Do a simple relocation using a symbol value with the addend in
438 // the relocation, unaligned.
439 template<int valsize
>
441 rela_ua(unsigned char* view
, unsigned int right_shift
,
442 elfcpp::Elf_Xword dst_mask
,
443 const Sized_relobj
<size
, big_endian
>* object
,
444 const Symbol_value
<size
>* psymval
,
445 typename
elfcpp::Swap
<size
, big_endian
>::Valtype addend
)
447 typedef typename
elfcpp::Swap_unaligned
<valsize
,
448 big_endian
>::Valtype Valtype
;
449 unsigned char* wv
= view
;
450 Valtype val
= elfcpp::Swap_unaligned
<valsize
, big_endian
>::readval(wv
);
451 Valtype reloc
= (psymval
->value(object
, addend
) >> right_shift
);
456 elfcpp::Swap_unaligned
<valsize
, big_endian
>::writeval(wv
, val
| reloc
);
459 // Do a simple PC relative relocation with a Symbol_value with the
460 // addend in the relocation.
461 template<int valsize
>
463 pcrela(unsigned char* view
, unsigned int right_shift
,
464 elfcpp::Elf_Xword dst_mask
,
465 const Sized_relobj
<size
, big_endian
>* object
,
466 const Symbol_value
<size
>* psymval
,
467 typename
elfcpp::Swap
<size
, big_endian
>::Valtype addend
,
468 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
)
470 typedef typename
elfcpp::Swap
<valsize
, big_endian
>::Valtype Valtype
;
471 Valtype
* wv
= reinterpret_cast<Valtype
*>(view
);
472 Valtype val
= elfcpp::Swap
<valsize
, big_endian
>::readval(wv
);
473 Valtype reloc
= ((psymval
->value(object
, addend
) - address
)
479 elfcpp::Swap
<valsize
, big_endian
>::writeval(wv
, val
| reloc
);
482 template<int valsize
>
484 pcrela_unaligned(unsigned char* view
,
485 const Sized_relobj
<size
, big_endian
>* object
,
486 const Symbol_value
<size
>* psymval
,
487 typename
elfcpp::Swap
<size
, big_endian
>::Valtype addend
,
488 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
)
490 typedef typename
elfcpp::Swap_unaligned
<valsize
,
491 big_endian
>::Valtype Valtype
;
492 unsigned char* wv
= view
;
493 Valtype reloc
= (psymval
->value(object
, addend
) - address
);
495 elfcpp::Swap_unaligned
<valsize
, big_endian
>::writeval(wv
, reloc
);
498 typedef Powerpc_relocate_functions
<size
, big_endian
> This
;
499 typedef Relocate_functions
<size
, big_endian
> This_reloc
;
501 // R_POWERPC_REL32: (Symbol + Addend - Address)
503 rel32(unsigned char* view
,
504 const Sized_relobj
<size
, big_endian
>* object
,
505 const Symbol_value
<size
>* psymval
,
506 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
,
507 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
)
508 { This_reloc::pcrela32(view
, object
, psymval
, addend
, address
); }
510 // R_POWERPC_REL24: (Symbol + Addend - Address) & 0x3fffffc
512 rel24(unsigned char* view
,
513 const Sized_relobj
<size
, big_endian
>* object
,
514 const Symbol_value
<size
>* psymval
,
515 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
,
516 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
)
518 This::template pcrela
<32>(view
, 0, 0x03fffffc, object
,
519 psymval
, addend
, address
);
522 // R_POWERPC_REL14: (Symbol + Addend - Address) & 0xfffc
524 rel14(unsigned char* view
,
525 const Sized_relobj
<size
, big_endian
>* object
,
526 const Symbol_value
<size
>* psymval
,
527 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
,
528 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
)
530 This::template pcrela
<32>(view
, 0, 0x0000fffc, object
,
531 psymval
, addend
, address
);
534 // R_POWERPC_ADDR16: (Symbol + Addend) & 0xffff
536 addr16(unsigned char* view
,
537 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
,
538 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
539 { This_reloc::rela16(view
, value
, addend
); }
542 addr16(unsigned char* view
,
543 const Sized_relobj
<size
, big_endian
>* object
,
544 const Symbol_value
<size
>* psymval
,
545 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
546 { This_reloc::rela16(view
, object
, psymval
, addend
); }
548 // R_POWERPC_ADDR16_DS: (Symbol + Addend) & 0xfffc
550 addr16_ds(unsigned char* view
,
551 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
,
552 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
554 This::template rela
<16>(view
, 0, 0xfffc, value
, addend
);
557 // R_POWERPC_ADDR16_LO: (Symbol + Addend) & 0xffff
559 addr16_lo(unsigned char* view
,
560 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
,
561 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
562 { This_reloc::rela16(view
, value
, addend
); }
565 addr16_lo(unsigned char* view
,
566 const Sized_relobj
<size
, big_endian
>* object
,
567 const Symbol_value
<size
>* psymval
,
568 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
569 { This_reloc::rela16(view
, object
, psymval
, addend
); }
571 // R_POWERPC_ADDR16_HI: ((Symbol + Addend) >> 16) & 0xffff
573 addr16_hi(unsigned char* view
,
574 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
,
575 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
577 This::template rela
<16>(view
, 16, 0xffff, value
, addend
);
581 addr16_hi(unsigned char* view
,
582 const Sized_relobj
<size
, big_endian
>* object
,
583 const Symbol_value
<size
>* psymval
,
584 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
586 This::template rela
<16>(view
, 16, 0xffff, object
, psymval
, addend
);
589 // R_POWERPC_ADDR16_HA: Same as R_POWERPC_ADDR16_HI except that if the
590 // final value of the low 16 bits of the
591 // relocation is negative, add one.
593 addr16_ha(unsigned char* view
,
594 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
,
595 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
597 typedef typename
elfcpp::Swap
<16, true>::Valtype Valtype
;
598 Valtype
* wv
= reinterpret_cast<Valtype
*>(view
);
599 Valtype val
= elfcpp::Swap
<16, true>::readval(wv
);
600 typename
elfcpp::Elf_types
<size
>::Elf_Addr reloc
;
602 reloc
= value
+ addend
;
611 elfcpp::Swap
<16, true>::writeval(wv
, val
| reloc
);
615 addr16_ha(unsigned char* view
,
616 const Sized_relobj
<size
, big_endian
>* object
,
617 const Symbol_value
<size
>* psymval
,
618 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
620 typedef typename
elfcpp::Swap
<16, true>::Valtype Valtype
;
621 Valtype
* wv
= reinterpret_cast<Valtype
*>(view
);
622 Valtype val
= elfcpp::Swap
<16, true>::readval(wv
);
623 typename
elfcpp::Elf_types
<size
>::Elf_Addr reloc
;
625 reloc
= psymval
->value(object
, addend
);
634 elfcpp::Swap
<16, true>::writeval(wv
, val
| reloc
);
637 // R_PPC_REL16: (Symbol + Addend - Address) & 0xffff
639 rel16(unsigned char* view
,
640 const Sized_relobj
<size
, big_endian
>* object
,
641 const Symbol_value
<size
>* psymval
,
642 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
,
643 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
)
644 { This_reloc::pcrela16(view
, object
, psymval
, addend
, address
); }
646 // R_PPC_REL16_LO: (Symbol + Addend - Address) & 0xffff
648 rel16_lo(unsigned char* view
,
649 const Sized_relobj
<size
, big_endian
>* object
,
650 const Symbol_value
<size
>* psymval
,
651 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
,
652 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
)
653 { This_reloc::pcrela16(view
, object
, psymval
, addend
, address
); }
655 // R_PPC_REL16_HI: ((Symbol + Addend - Address) >> 16) & 0xffff
657 rel16_hi(unsigned char* view
,
658 const Sized_relobj
<size
, big_endian
>* object
,
659 const Symbol_value
<size
>* psymval
,
660 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
,
661 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
)
663 This::template pcrela
<16>(view
, 16, 0xffff, object
,
664 psymval
, addend
, address
);
667 // R_PPC_REL16_HA: Same as R_PPC_REL16_HI except that if the
668 // final value of the low 16 bits of the
669 // relocation is negative, add one.
671 rel16_ha(unsigned char* view
,
672 const Sized_relobj
<size
, big_endian
>* object
,
673 const Symbol_value
<size
>* psymval
,
674 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
,
675 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
)
677 typedef typename
elfcpp::Swap
<16, true>::Valtype Valtype
;
678 Valtype
* wv
= reinterpret_cast<Valtype
*>(view
);
679 Valtype val
= elfcpp::Swap
<16, true>::readval(wv
);
680 typename
elfcpp::Elf_types
<size
>::Elf_Addr reloc
;
682 reloc
= (psymval
->value(object
, addend
) - address
);
690 elfcpp::Swap
<16, true>::writeval(wv
, val
| reloc
);
694 // Get the GOT section, creating it if necessary.
696 template<int size
, bool big_endian
>
697 Output_data_got
<size
, big_endian
>*
698 Target_powerpc
<size
, big_endian
>::got_section(Symbol_table
* symtab
,
701 if (this->got_
== NULL
)
703 gold_assert(symtab
!= NULL
&& layout
!= NULL
);
705 this->got_
= new Output_data_got
<size
, big_endian
>();
707 layout
->add_output_section_data(".got", elfcpp::SHT_PROGBITS
,
708 elfcpp::SHF_ALLOC
| elfcpp::SHF_WRITE
,
711 // Create the GOT2 or TOC in the .got section.
714 this->got2_
= new Output_data_space(4, "** GOT2");
715 layout
->add_output_section_data(".got2", elfcpp::SHT_PROGBITS
,
722 this->toc_
= new Output_data_space(8, "** TOC");
723 layout
->add_output_section_data(".toc", elfcpp::SHT_PROGBITS
,
729 // Define _GLOBAL_OFFSET_TABLE_ at the start of the .got section.
730 symtab
->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL
,
732 0, 0, elfcpp::STT_OBJECT
,
734 elfcpp::STV_HIDDEN
, 0,
741 // Get the dynamic reloc section, creating it if necessary.
743 template<int size
, bool big_endian
>
744 typename Target_powerpc
<size
, big_endian
>::Reloc_section
*
745 Target_powerpc
<size
, big_endian
>::rela_dyn_section(Layout
* layout
)
747 if (this->rela_dyn_
== NULL
)
749 gold_assert(layout
!= NULL
);
750 this->rela_dyn_
= new Reloc_section(parameters
->options().combreloc());
751 layout
->add_output_section_data(".rela.dyn", elfcpp::SHT_RELA
,
752 elfcpp::SHF_ALLOC
, this->rela_dyn_
);
754 return this->rela_dyn_
;
757 // A class to handle the PLT data.
759 template<int size
, bool big_endian
>
760 class Output_data_plt_powerpc
: public Output_section_data
763 typedef Output_data_reloc
<elfcpp::SHT_RELA
, true,
764 size
, big_endian
> Reloc_section
;
766 Output_data_plt_powerpc(Layout
*);
768 // Add an entry to the PLT.
769 void add_entry(Symbol
* gsym
);
771 // Return the .rela.plt section data.
772 const Reloc_section
* rel_plt() const
778 void do_adjust_output_section(Output_section
* os
);
781 // The size of an entry in the PLT.
782 static const int base_plt_entry_size
= (size
== 32 ? 16 : 24);
784 // Set the final size.
786 set_final_data_size()
788 unsigned int full_count
= this->count_
+ 4;
790 this->set_data_size(full_count
* base_plt_entry_size
);
793 // Write out the PLT data.
795 do_write(Output_file
*);
797 // The reloc section.
799 // The number of PLT entries.
803 // Create the PLT section. The ordinary .got section is an argument,
804 // since we need to refer to the start.
806 template<int size
, bool big_endian
>
807 Output_data_plt_powerpc
<size
, big_endian
>::Output_data_plt_powerpc(Layout
* layout
)
808 : Output_section_data(size
== 32 ? 4 : 8), count_(0)
810 this->rel_
= new Reloc_section(false);
811 layout
->add_output_section_data(".rela.plt", elfcpp::SHT_RELA
,
812 elfcpp::SHF_ALLOC
, this->rel_
);
815 template<int size
, bool big_endian
>
817 Output_data_plt_powerpc
<size
, big_endian
>::do_adjust_output_section(Output_section
* os
)
822 // Add an entry to the PLT.
824 template<int size
, bool big_endian
>
826 Output_data_plt_powerpc
<size
, big_endian
>::add_entry(Symbol
* gsym
)
828 gold_assert(!gsym
->has_plt_offset());
829 unsigned int index
= this->count_
+ + 4;
830 section_offset_type plt_offset
;
833 plt_offset
= index
* base_plt_entry_size
;
837 gsym
->set_plt_offset(plt_offset
);
841 gsym
->set_needs_dynsym_entry();
842 this->rel_
->add_global(gsym
, elfcpp::R_POWERPC_JMP_SLOT
, this,
846 static const unsigned int addis_11_11
= 0x3d6b0000;
847 static const unsigned int addis_11_30
= 0x3d7e0000;
848 static const unsigned int addis_12_12
= 0x3d8c0000;
849 static const unsigned int addi_11_11
= 0x396b0000;
850 static const unsigned int add_0_11_11
= 0x7c0b5a14;
851 static const unsigned int add_11_0_11
= 0x7d605a14;
852 static const unsigned int b
= 0x48000000;
853 static const unsigned int bcl_20_31
= 0x429f0005;
854 static const unsigned int bctr
= 0x4e800420;
855 static const unsigned int lis_11
= 0x3d600000;
856 static const unsigned int lis_12
= 0x3d800000;
857 static const unsigned int lwzu_0_12
= 0x840c0000;
858 static const unsigned int lwz_0_12
= 0x800c0000;
859 static const unsigned int lwz_11_11
= 0x816b0000;
860 static const unsigned int lwz_11_30
= 0x817e0000;
861 static const unsigned int lwz_12_12
= 0x818c0000;
862 static const unsigned int mflr_0
= 0x7c0802a6;
863 static const unsigned int mflr_12
= 0x7d8802a6;
864 static const unsigned int mtctr_0
= 0x7c0903a6;
865 static const unsigned int mtctr_11
= 0x7d6903a6;
866 static const unsigned int mtlr_0
= 0x7c0803a6;
867 static const unsigned int nop
= 0x60000000;
868 static const unsigned int sub_11_11_12
= 0x7d6c5850;
870 static const unsigned int addis_r12_r2
= 0x3d820000; /* addis %r12,%r2,xxx@ha */
871 static const unsigned int std_r2_40r1
= 0xf8410028; /* std %r2,40(%r1) */
872 static const unsigned int ld_r11_0r12
= 0xe96c0000; /* ld %r11,xxx+0@l(%r12) */
873 static const unsigned int ld_r2_0r12
= 0xe84c0000; /* ld %r2,xxx+8@l(%r12) */
874 /* ld %r11,xxx+16@l(%r12) */
877 // Write out the PLT.
879 template<int size
, bool big_endian
>
881 Output_data_plt_powerpc
<size
, big_endian
>::do_write(Output_file
* of
)
883 const off_t offset
= this->offset();
884 const section_size_type oview_size
=
885 convert_to_section_size_type(this->data_size());
886 unsigned char* const oview
= of
->get_output_view(offset
, oview_size
);
887 unsigned char* pov
= oview
;
889 memset(pov
, 0, base_plt_entry_size
* 4);
890 pov
+= base_plt_entry_size
* 4;
892 unsigned int plt_offset
= base_plt_entry_size
* 4;
893 const unsigned int count
= this->count_
;
897 for (unsigned int i
= 0; i
< count
; i
++)
903 for (unsigned int i
= 0; i
< count
; i
++)
905 elfcpp::Swap
<32, true>::writeval(pov
+ 0x00,
906 lwz_11_30
+ plt_offset
);
907 elfcpp::Swap
<32, true>::writeval(pov
+ 0x04, mtctr_11
);
908 elfcpp::Swap
<32, true>::writeval(pov
+ 0x08, bctr
);
909 elfcpp::Swap
<32, true>::writeval(pov
+ 0x0b, nop
);
910 pov
+= base_plt_entry_size
;
911 plt_offset
+= base_plt_entry_size
;
915 gold_assert(static_cast<section_size_type
>(pov
- oview
) == oview_size
);
917 of
->write_output_view(offset
, oview_size
, oview
);
920 // Create a PLT entry for a global symbol.
922 template<int size
, bool big_endian
>
924 Target_powerpc
<size
, big_endian
>::make_plt_entry(Symbol_table
* symtab
,
928 if (gsym
->has_plt_offset())
931 if (this->plt_
== NULL
)
933 // Create the GOT section first.
934 this->got_section(symtab
, layout
);
936 this->plt_
= new Output_data_plt_powerpc
<size
, big_endian
>(layout
);
937 layout
->add_output_section_data(".plt", elfcpp::SHT_PROGBITS
,
939 | elfcpp::SHF_EXECINSTR
940 | elfcpp::SHF_WRITE
),
943 // Define _PROCEDURE_LINKAGE_TABLE_ at the start of the .plt section.
944 symtab
->define_in_output_data("_PROCEDURE_LINKAGE_TABLE_", NULL
,
946 0, 0, elfcpp::STT_OBJECT
,
948 elfcpp::STV_HIDDEN
, 0,
952 this->plt_
->add_entry(gsym
);
955 // Create a GOT entry for the TLS module index.
957 template<int size
, bool big_endian
>
959 Target_powerpc
<size
, big_endian
>::got_mod_index_entry(Symbol_table
* symtab
,
961 Sized_relobj
<size
, big_endian
>* object
)
963 if (this->got_mod_index_offset_
== -1U)
965 gold_assert(symtab
!= NULL
&& layout
!= NULL
&& object
!= NULL
);
966 Reloc_section
* rela_dyn
= this->rela_dyn_section(layout
);
967 Output_data_got
<size
, big_endian
>* got
;
968 unsigned int got_offset
;
970 got
= this->got_section(symtab
, layout
);
971 got_offset
= got
->add_constant(0);
972 rela_dyn
->add_local(object
, 0, elfcpp::R_POWERPC_DTPMOD
, got
,
974 got
->add_constant(0);
975 this->got_mod_index_offset_
= got_offset
;
977 return this->got_mod_index_offset_
;
980 // Optimize the TLS relocation type based on what we know about the
981 // symbol. IS_FINAL is true if the final address of this symbol is
982 // known at link time.
984 static tls::Tls_optimization
985 optimize_tls_reloc(bool /* is_final */, int r_type
)
987 // If we are generating a shared library, then we can't do anything
989 if (parameters
->options().shared())
990 return tls::TLSOPT_NONE
;
999 // Report an unsupported relocation against a local symbol.
1001 template<int size
, bool big_endian
>
1003 Target_powerpc
<size
, big_endian
>::Scan::unsupported_reloc_local(
1004 Sized_relobj
<size
, big_endian
>* object
,
1005 unsigned int r_type
)
1007 gold_error(_("%s: unsupported reloc %u against local symbol"),
1008 object
->name().c_str(), r_type
);
1011 // We are about to emit a dynamic relocation of type R_TYPE. If the
1012 // dynamic linker does not support it, issue an error.
1014 template<int size
, bool big_endian
>
1016 Target_powerpc
<size
, big_endian
>::Scan::check_non_pic(Relobj
* object
,
1017 unsigned int r_type
)
1019 gold_assert(r_type
!= elfcpp::R_POWERPC_NONE
);
1021 // These are the relocation types supported by glibc for both 32-bit
1022 // and 64-bit powerpc.
1025 case elfcpp::R_POWERPC_RELATIVE
:
1026 case elfcpp::R_POWERPC_GLOB_DAT
:
1027 case elfcpp::R_POWERPC_DTPMOD
:
1028 case elfcpp::R_POWERPC_DTPREL
:
1029 case elfcpp::R_POWERPC_TPREL
:
1030 case elfcpp::R_POWERPC_JMP_SLOT
:
1031 case elfcpp::R_POWERPC_COPY
:
1032 case elfcpp::R_POWERPC_ADDR32
:
1033 case elfcpp::R_POWERPC_ADDR24
:
1034 case elfcpp::R_POWERPC_REL24
:
1045 // These are the relocation types supported only on 64-bit.
1046 case elfcpp::R_PPC64_ADDR64
:
1047 case elfcpp::R_PPC64_TPREL16_LO_DS
:
1048 case elfcpp::R_PPC64_TPREL16_DS
:
1049 case elfcpp::R_POWERPC_TPREL16
:
1050 case elfcpp::R_POWERPC_TPREL16_LO
:
1051 case elfcpp::R_POWERPC_TPREL16_HI
:
1052 case elfcpp::R_POWERPC_TPREL16_HA
:
1053 case elfcpp::R_PPC64_TPREL16_HIGHER
:
1054 case elfcpp::R_PPC64_TPREL16_HIGHEST
:
1055 case elfcpp::R_PPC64_TPREL16_HIGHERA
:
1056 case elfcpp::R_PPC64_TPREL16_HIGHESTA
:
1057 case elfcpp::R_PPC64_ADDR16_LO_DS
:
1058 case elfcpp::R_POWERPC_ADDR16_LO
:
1059 case elfcpp::R_POWERPC_ADDR16_HI
:
1060 case elfcpp::R_POWERPC_ADDR16_HA
:
1061 case elfcpp::R_POWERPC_ADDR30
:
1062 case elfcpp::R_PPC64_UADDR64
:
1063 case elfcpp::R_POWERPC_UADDR32
:
1064 case elfcpp::R_POWERPC_ADDR16
:
1065 case elfcpp::R_POWERPC_UADDR16
:
1066 case elfcpp::R_PPC64_ADDR16_DS
:
1067 case elfcpp::R_PPC64_ADDR16_HIGHER
:
1068 case elfcpp::R_PPC64_ADDR16_HIGHEST
:
1069 case elfcpp::R_PPC64_ADDR16_HIGHERA
:
1070 case elfcpp::R_PPC64_ADDR16_HIGHESTA
:
1071 case elfcpp::R_POWERPC_ADDR14_BRTAKEN
:
1072 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN
:
1073 case elfcpp::R_POWERPC_REL32
:
1074 case elfcpp::R_PPC64_REL64
:
1085 // These are the relocation types supported only on 32-bit.
1092 // This prevents us from issuing more than one error per reloc
1093 // section. But we can still wind up issuing more than one
1094 // error per object file.
1095 if (this->issued_non_pic_error_
)
1097 object
->error(_("requires unsupported dynamic reloc; "
1098 "recompile with -fPIC"));
1099 this->issued_non_pic_error_
= true;
1103 // Scan a relocation for a local symbol.
1105 template<int size
, bool big_endian
>
1107 Target_powerpc
<size
, big_endian
>::Scan::local(
1108 const General_options
&,
1109 Symbol_table
* symtab
,
1111 Target_powerpc
<size
, big_endian
>* target
,
1112 Sized_relobj
<size
, big_endian
>* object
,
1113 unsigned int data_shndx
,
1114 Output_section
* output_section
,
1115 const elfcpp::Rela
<size
, big_endian
>& reloc
,
1116 unsigned int r_type
,
1117 const elfcpp::Sym
<size
, big_endian
>& lsym
)
1121 case elfcpp::R_POWERPC_NONE
:
1122 case elfcpp::R_POWERPC_GNU_VTINHERIT
:
1123 case elfcpp::R_POWERPC_GNU_VTENTRY
:
1126 case elfcpp::R_PPC64_ADDR64
:
1127 case elfcpp::R_POWERPC_ADDR32
:
1128 case elfcpp::R_POWERPC_ADDR16_HA
:
1129 case elfcpp::R_POWERPC_ADDR16_LO
:
1130 // If building a shared library (or a position-independent
1131 // executable), we need to create a dynamic relocation for
1133 if (parameters
->options().output_is_position_independent())
1135 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
1137 check_non_pic(object
, r_type
);
1138 if (lsym
.get_st_type() != elfcpp::STT_SECTION
)
1140 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(reloc
.get_r_info());
1141 rela_dyn
->add_local(object
, r_sym
, r_type
, output_section
,
1142 data_shndx
, reloc
.get_r_offset(),
1143 reloc
.get_r_addend());
1147 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(reloc
.get_r_info());
1148 gold_assert(lsym
.get_st_value() == 0);
1149 rela_dyn
->add_local_relative(object
, r_sym
, r_type
,
1150 output_section
, data_shndx
,
1151 reloc
.get_r_offset(),
1152 reloc
.get_r_addend());
1157 case elfcpp::R_POWERPC_REL24
:
1158 case elfcpp::R_PPC_LOCAL24PC
:
1159 case elfcpp::R_POWERPC_REL32
:
1160 case elfcpp::R_PPC_REL16_LO
:
1161 case elfcpp::R_PPC_REL16_HA
:
1164 case elfcpp::R_POWERPC_GOT16
:
1165 case elfcpp::R_POWERPC_GOT16_LO
:
1166 case elfcpp::R_POWERPC_GOT16_HI
:
1167 case elfcpp::R_POWERPC_GOT16_HA
:
1168 case elfcpp::R_PPC64_TOC16
:
1169 case elfcpp::R_PPC64_TOC16_LO
:
1170 case elfcpp::R_PPC64_TOC16_HI
:
1171 case elfcpp::R_PPC64_TOC16_HA
:
1172 case elfcpp::R_PPC64_TOC16_DS
:
1173 case elfcpp::R_PPC64_TOC16_LO_DS
:
1175 // The symbol requires a GOT entry.
1176 Output_data_got
<size
, big_endian
>* got
;
1179 got
= target
->got_section(symtab
, layout
);
1180 r_sym
= elfcpp::elf_r_sym
<size
>(reloc
.get_r_info());
1182 // If we are generating a shared object, we need to add a
1183 // dynamic relocation for this symbol's GOT entry.
1184 if (parameters
->options().output_is_position_independent())
1186 if (!object
->local_has_got_offset(r_sym
, GOT_TYPE_STANDARD
))
1188 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
1191 off
= got
->add_constant(0);
1192 object
->set_local_got_offset(r_sym
, GOT_TYPE_STANDARD
, off
);
1193 rela_dyn
->add_local_relative(object
, r_sym
,
1194 elfcpp::R_POWERPC_RELATIVE
,
1199 got
->add_local(object
, r_sym
, GOT_TYPE_STANDARD
);
1203 case elfcpp::R_PPC64_TOC
:
1204 // We need a GOT section.
1205 target
->got_section(symtab
, layout
);
1208 // These are relocations which should only be seen by the
1209 // dynamic linker, and should never be seen here.
1210 case elfcpp::R_POWERPC_COPY
:
1211 case elfcpp::R_POWERPC_GLOB_DAT
:
1212 case elfcpp::R_POWERPC_JMP_SLOT
:
1213 case elfcpp::R_POWERPC_RELATIVE
:
1214 case elfcpp::R_POWERPC_DTPMOD
:
1215 gold_error(_("%s: unexpected reloc %u in object file"),
1216 object
->name().c_str(), r_type
);
1220 unsupported_reloc_local(object
, r_type
);
1225 // Report an unsupported relocation against a global symbol.
1227 template<int size
, bool big_endian
>
1229 Target_powerpc
<size
, big_endian
>::Scan::unsupported_reloc_global(
1230 Sized_relobj
<size
, big_endian
>* object
,
1231 unsigned int r_type
,
1234 gold_error(_("%s: unsupported reloc %u against global symbol %s"),
1235 object
->name().c_str(), r_type
, gsym
->demangled_name().c_str());
1238 // Scan a relocation for a global symbol.
1240 template<int size
, bool big_endian
>
1242 Target_powerpc
<size
, big_endian
>::Scan::global(
1243 const General_options
&,
1244 Symbol_table
* symtab
,
1246 Target_powerpc
<size
, big_endian
>* target
,
1247 Sized_relobj
<size
, big_endian
>* object
,
1248 unsigned int data_shndx
,
1249 Output_section
* output_section
,
1250 const elfcpp::Rela
<size
, big_endian
>& reloc
,
1251 unsigned int r_type
,
1256 case elfcpp::R_POWERPC_NONE
:
1257 case elfcpp::R_POWERPC_GNU_VTINHERIT
:
1258 case elfcpp::R_POWERPC_GNU_VTENTRY
:
1261 case elfcpp::R_PPC_PLTREL24
:
1262 // If the symbol is fully resolved, this is just a PC32 reloc.
1263 // Otherwise we need a PLT entry.
1264 if (gsym
->final_value_is_known())
1266 // If building a shared library, we can also skip the PLT entry
1267 // if the symbol is defined in the output file and is protected
1269 if (gsym
->is_defined()
1270 && !gsym
->is_from_dynobj()
1271 && !gsym
->is_preemptible())
1273 target
->make_plt_entry(symtab
, layout
, gsym
);
1276 case elfcpp::R_POWERPC_ADDR16
:
1277 case elfcpp::R_POWERPC_ADDR16_LO
:
1278 case elfcpp::R_POWERPC_ADDR16_HI
:
1279 case elfcpp::R_POWERPC_ADDR16_HA
:
1280 case elfcpp::R_POWERPC_ADDR32
:
1281 case elfcpp::R_PPC64_ADDR64
:
1283 // Make a PLT entry if necessary.
1284 if (gsym
->needs_plt_entry())
1286 target
->make_plt_entry(symtab
, layout
, gsym
);
1287 // Since this is not a PC-relative relocation, we may be
1288 // taking the address of a function. In that case we need to
1289 // set the entry in the dynamic symbol table to the address of
1291 if (gsym
->is_from_dynobj() && !parameters
->options().shared())
1292 gsym
->set_needs_dynsym_value();
1294 // Make a dynamic relocation if necessary.
1295 if (gsym
->needs_dynamic_reloc(Symbol::ABSOLUTE_REF
))
1297 if (target
->may_need_copy_reloc(gsym
))
1299 target
->copy_reloc(symtab
, layout
, object
,
1300 data_shndx
, output_section
, gsym
, reloc
);
1302 else if ((r_type
== elfcpp::R_POWERPC_ADDR32
1303 || r_type
== elfcpp::R_PPC64_ADDR64
)
1304 && gsym
->can_use_relative_reloc(false))
1306 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
1307 rela_dyn
->add_global_relative(gsym
, elfcpp::R_POWERPC_RELATIVE
,
1308 output_section
, object
,
1309 data_shndx
, reloc
.get_r_offset(),
1310 reloc
.get_r_addend());
1314 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
1316 check_non_pic(object
, r_type
);
1317 if (gsym
->is_from_dynobj()
1318 || gsym
->is_undefined()
1319 || gsym
->is_preemptible())
1320 rela_dyn
->add_global(gsym
, r_type
, output_section
,
1322 reloc
.get_r_offset(),
1323 reloc
.get_r_addend());
1325 rela_dyn
->add_global_relative(gsym
, r_type
,
1326 output_section
, object
,
1328 reloc
.get_r_offset(),
1329 reloc
.get_r_addend());
1335 case elfcpp::R_POWERPC_REL24
:
1336 case elfcpp::R_PPC_LOCAL24PC
:
1337 case elfcpp::R_PPC_REL16
:
1338 case elfcpp::R_PPC_REL16_LO
:
1339 case elfcpp::R_PPC_REL16_HI
:
1340 case elfcpp::R_PPC_REL16_HA
:
1342 if (gsym
->needs_plt_entry())
1343 target
->make_plt_entry(symtab
, layout
, gsym
);
1344 // Make a dynamic relocation if necessary.
1345 int flags
= Symbol::NON_PIC_REF
;
1346 if (gsym
->type() == elfcpp::STT_FUNC
)
1347 flags
|= Symbol::FUNCTION_CALL
;
1348 if (gsym
->needs_dynamic_reloc(flags
))
1350 if (target
->may_need_copy_reloc(gsym
))
1352 target
->copy_reloc(symtab
, layout
, object
,
1353 data_shndx
, output_section
, gsym
,
1358 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
1359 check_non_pic(object
, r_type
);
1360 rela_dyn
->add_global(gsym
, r_type
, output_section
, object
,
1361 data_shndx
, reloc
.get_r_offset(),
1362 reloc
.get_r_addend());
1368 case elfcpp::R_POWERPC_GOT16
:
1369 case elfcpp::R_POWERPC_GOT16_LO
:
1370 case elfcpp::R_POWERPC_GOT16_HI
:
1371 case elfcpp::R_POWERPC_GOT16_HA
:
1372 case elfcpp::R_PPC64_TOC16
:
1373 case elfcpp::R_PPC64_TOC16_LO
:
1374 case elfcpp::R_PPC64_TOC16_HI
:
1375 case elfcpp::R_PPC64_TOC16_HA
:
1376 case elfcpp::R_PPC64_TOC16_DS
:
1377 case elfcpp::R_PPC64_TOC16_LO_DS
:
1379 // The symbol requires a GOT entry.
1380 Output_data_got
<size
, big_endian
>* got
;
1382 got
= target
->got_section(symtab
, layout
);
1383 if (gsym
->final_value_is_known())
1384 got
->add_global(gsym
, GOT_TYPE_STANDARD
);
1387 // If this symbol is not fully resolved, we need to add a
1388 // dynamic relocation for it.
1389 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
1390 if (gsym
->is_from_dynobj()
1391 || gsym
->is_undefined()
1392 || gsym
->is_preemptible())
1393 got
->add_global_with_rela(gsym
, GOT_TYPE_STANDARD
, rela_dyn
,
1394 elfcpp::R_POWERPC_GLOB_DAT
);
1395 else if (!gsym
->has_got_offset(GOT_TYPE_STANDARD
))
1397 unsigned int off
= got
->add_constant(0);
1399 gsym
->set_got_offset(GOT_TYPE_STANDARD
, off
);
1400 rela_dyn
->add_global_relative(gsym
, elfcpp::R_POWERPC_RELATIVE
,
1407 case elfcpp::R_PPC64_TOC
:
1408 // We need a GOT section.
1409 target
->got_section(symtab
, layout
);
1412 case elfcpp::R_POWERPC_GOT_TPREL16
:
1413 case elfcpp::R_POWERPC_TLS
:
1417 // These are relocations which should only be seen by the
1418 // dynamic linker, and should never be seen here.
1419 case elfcpp::R_POWERPC_COPY
:
1420 case elfcpp::R_POWERPC_GLOB_DAT
:
1421 case elfcpp::R_POWERPC_JMP_SLOT
:
1422 case elfcpp::R_POWERPC_RELATIVE
:
1423 case elfcpp::R_POWERPC_DTPMOD
:
1424 gold_error(_("%s: unexpected reloc %u in object file"),
1425 object
->name().c_str(), r_type
);
1429 unsupported_reloc_global(object
, r_type
, gsym
);
1434 // Scan relocations for a section.
1436 template<int size
, bool big_endian
>
1438 Target_powerpc
<size
, big_endian
>::scan_relocs(
1439 const General_options
& options
,
1440 Symbol_table
* symtab
,
1442 Sized_relobj
<size
, big_endian
>* object
,
1443 unsigned int data_shndx
,
1444 unsigned int sh_type
,
1445 const unsigned char* prelocs
,
1447 Output_section
* output_section
,
1448 bool needs_special_offset_handling
,
1449 size_t local_symbol_count
,
1450 const unsigned char* plocal_symbols
)
1452 typedef Target_powerpc
<size
, big_endian
> Powerpc
;
1453 typedef typename Target_powerpc
<size
, big_endian
>::Scan Scan
;
1454 static Output_data_space
* sdata
;
1456 if (sh_type
== elfcpp::SHT_REL
)
1458 gold_error(_("%s: unsupported REL reloc section"),
1459 object
->name().c_str());
1463 // Define _SDA_BASE_ at the start of the .sdata section.
1466 // layout->find_output_section(".sdata") == NULL
1467 sdata
= new Output_data_space(4, "** sdata");
1468 Output_section
* os
= layout
->add_output_section_data(".sdata", 0,
1470 | elfcpp::SHF_WRITE
,
1472 symtab
->define_in_output_data("_SDA_BASE_", NULL
,
1477 elfcpp::STV_HIDDEN
, 0,
1481 gold::scan_relocs
<size
, big_endian
, Powerpc
, elfcpp::SHT_RELA
, Scan
>(
1491 needs_special_offset_handling
,
1496 // Finalize the sections.
1498 template<int size
, bool big_endian
>
1500 Target_powerpc
<size
, big_endian
>::do_finalize_sections(Layout
* layout
)
1502 // Fill in some more dynamic tags.
1503 Output_data_dynamic
* const odyn
= layout
->dynamic_data();
1506 if (this->plt_
!= NULL
)
1508 const Output_data
* od
= this->plt_
->rel_plt();
1509 odyn
->add_section_size(elfcpp::DT_PLTRELSZ
, od
);
1510 odyn
->add_section_address(elfcpp::DT_JMPREL
, od
);
1511 odyn
->add_constant(elfcpp::DT_PLTREL
, elfcpp::DT_RELA
);
1513 odyn
->add_section_address(elfcpp::DT_PLTGOT
, this->plt_
);
1516 if (this->rela_dyn_
!= NULL
)
1518 const Output_data
* od
= this->rela_dyn_
;
1519 odyn
->add_section_address(elfcpp::DT_RELA
, od
);
1520 odyn
->add_section_size(elfcpp::DT_RELASZ
, od
);
1521 odyn
->add_constant(elfcpp::DT_RELAENT
,
1522 elfcpp::Elf_sizes
<size
>::rela_size
);
1525 if (!parameters
->options().shared())
1527 // The value of the DT_DEBUG tag is filled in by the dynamic
1528 // linker at run time, and used by the debugger.
1529 odyn
->add_constant(elfcpp::DT_DEBUG
, 0);
1533 // Emit any relocs we saved in an attempt to avoid generating COPY
1535 if (this->copy_relocs_
.any_saved_relocs())
1536 this->copy_relocs_
.emit(this->rela_dyn_section(layout
));
1539 // Perform a relocation.
1541 template<int size
, bool big_endian
>
1543 Target_powerpc
<size
, big_endian
>::Relocate::relocate(
1544 const Relocate_info
<size
, big_endian
>* relinfo
,
1545 Target_powerpc
* target
,
1547 const elfcpp::Rela
<size
, big_endian
>& rela
,
1548 unsigned int r_type
,
1549 const Sized_symbol
<size
>* gsym
,
1550 const Symbol_value
<size
>* psymval
,
1551 unsigned char* view
,
1552 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
,
1553 section_size_type
/* view_size */)
1555 const unsigned int toc_base_offset
= 0x8000;
1556 typedef Powerpc_relocate_functions
<size
, big_endian
> Reloc
;
1558 // Pick the value to use for symbols defined in shared objects.
1559 Symbol_value
<size
> symval
;
1561 && (gsym
->is_from_dynobj()
1562 || (parameters
->options().shared()
1563 && (gsym
->is_undefined() || gsym
->is_preemptible())))
1564 && gsym
->has_plt_offset())
1566 elfcpp::Elf_Xword value
;
1568 value
= target
->plt_section()->address() + gsym
->plt_offset();
1570 symval
.set_output_value(value
);
1575 const Sized_relobj
<size
, big_endian
>* object
= relinfo
->object
;
1576 elfcpp::Elf_Xword addend
= rela
.get_r_addend();
1578 // Get the GOT offset if needed. Unlike i386 and x86_64, our GOT
1579 // pointer points to the beginning, not the end, of the table.
1580 // So we just use the plain offset.
1581 bool have_got_offset
= false;
1582 unsigned int got_offset
= 0;
1583 unsigned int got2_offset
= 0;
1586 case elfcpp::R_PPC64_TOC16
:
1587 case elfcpp::R_PPC64_TOC16_LO
:
1588 case elfcpp::R_PPC64_TOC16_HI
:
1589 case elfcpp::R_PPC64_TOC16_HA
:
1590 case elfcpp::R_PPC64_TOC16_DS
:
1591 case elfcpp::R_PPC64_TOC16_LO_DS
:
1592 // Subtract the TOC base address.
1593 addend
-= target
->toc_section()->address() + toc_base_offset
;
1596 case elfcpp::R_POWERPC_GOT16
:
1597 case elfcpp::R_POWERPC_GOT16_LO
:
1598 case elfcpp::R_POWERPC_GOT16_HI
:
1599 case elfcpp::R_POWERPC_GOT16_HA
:
1600 case elfcpp::R_PPC64_GOT16_DS
:
1601 case elfcpp::R_PPC64_GOT16_LO_DS
:
1604 gold_assert(gsym
->has_got_offset(GOT_TYPE_STANDARD
));
1605 got_offset
= gsym
->got_offset(GOT_TYPE_STANDARD
);
1609 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(rela
.get_r_info());
1610 gold_assert(object
->local_has_got_offset(r_sym
, GOT_TYPE_STANDARD
));
1611 got_offset
= object
->local_got_offset(r_sym
, GOT_TYPE_STANDARD
);
1613 have_got_offset
= true;
1616 // R_PPC_PLTREL24 is rather special. If non-zero,
1617 // the addend specifies the GOT pointer offset within .got2.
1618 case elfcpp::R_PPC_PLTREL24
:
1619 if (addend
>= 32768)
1621 Output_data_space
* got2
;
1622 got2
= target
->got2_section();
1623 got2_offset
= got2
->offset();
1624 addend
+= got2_offset
;
1626 have_got_offset
= true;
1635 case elfcpp::R_POWERPC_NONE
:
1636 case elfcpp::R_POWERPC_GNU_VTINHERIT
:
1637 case elfcpp::R_POWERPC_GNU_VTENTRY
:
1640 case elfcpp::R_POWERPC_REL32
:
1641 Reloc::rel32(view
, object
, psymval
, addend
, address
);
1644 case elfcpp::R_POWERPC_REL24
:
1645 Reloc::rel24(view
, object
, psymval
, addend
, address
);
1648 case elfcpp::R_POWERPC_REL14
:
1649 Reloc::rel14(view
, object
, psymval
, addend
, address
);
1652 case elfcpp::R_PPC_PLTREL24
:
1653 Reloc::rel24(view
, object
, psymval
, addend
, address
);
1656 case elfcpp::R_PPC_LOCAL24PC
:
1657 Reloc::rel24(view
, object
, psymval
, addend
, address
);
1660 case elfcpp::R_PPC64_ADDR64
:
1661 if (!parameters
->options().output_is_position_independent())
1662 Relocate_functions
<size
, big_endian
>::rela64(view
, object
,
1666 case elfcpp::R_POWERPC_ADDR32
:
1667 if (!parameters
->options().output_is_position_independent())
1668 Relocate_functions
<size
, big_endian
>::rela32(view
, object
,
1672 case elfcpp::R_POWERPC_ADDR16_LO
:
1673 Reloc::addr16_lo(view
, object
, psymval
, addend
);
1676 case elfcpp::R_POWERPC_ADDR16_HI
:
1677 Reloc::addr16_hi(view
, object
, psymval
, addend
);
1680 case elfcpp::R_POWERPC_ADDR16_HA
:
1681 Reloc::addr16_ha(view
, object
, psymval
, addend
);
1684 case elfcpp::R_PPC_REL16_LO
:
1685 Reloc::rel16_lo(view
, object
, psymval
, addend
, address
);
1688 case elfcpp::R_PPC_REL16_HI
:
1689 Reloc::rel16_lo(view
, object
, psymval
, addend
, address
);
1692 case elfcpp::R_PPC_REL16_HA
:
1693 Reloc::rel16_lo(view
, object
, psymval
, addend
, address
);
1696 case elfcpp::R_POWERPC_GOT16
:
1697 Reloc::addr16(view
, got_offset
, addend
);
1700 case elfcpp::R_POWERPC_GOT16_LO
:
1701 Reloc::addr16_lo(view
, got_offset
, addend
);
1704 case elfcpp::R_POWERPC_GOT16_HI
:
1705 Reloc::addr16_hi(view
, got_offset
, addend
);
1708 case elfcpp::R_POWERPC_GOT16_HA
:
1709 Reloc::addr16_ha(view
, got_offset
, addend
);
1712 case elfcpp::R_PPC64_TOC16
:
1713 Reloc::addr16(view
, got_offset
, addend
);
1716 case elfcpp::R_PPC64_TOC16_LO
:
1717 Reloc::addr16_lo(view
, got_offset
, addend
);
1720 case elfcpp::R_PPC64_TOC16_HI
:
1721 Reloc::addr16_hi(view
, got_offset
, addend
);
1724 case elfcpp::R_PPC64_TOC16_HA
:
1725 Reloc::addr16_ha(view
, got_offset
, addend
);
1728 case elfcpp::R_PPC64_TOC16_DS
:
1729 case elfcpp::R_PPC64_TOC16_LO_DS
:
1730 Reloc::addr16_ds(view
, got_offset
, addend
);
1733 case elfcpp::R_PPC64_TOC
:
1735 elfcpp::Elf_types
<64>::Elf_Addr value
;
1736 value
= target
->toc_section()->address() + toc_base_offset
;
1737 Relocate_functions
<64, false>::rela64(view
, value
, addend
);
1741 case elfcpp::R_POWERPC_COPY
:
1742 case elfcpp::R_POWERPC_GLOB_DAT
:
1743 case elfcpp::R_POWERPC_JMP_SLOT
:
1744 case elfcpp::R_POWERPC_RELATIVE
:
1745 // This is an outstanding tls reloc, which is unexpected when
1747 case elfcpp::R_POWERPC_DTPMOD
:
1748 gold_error_at_location(relinfo
, relnum
, rela
.get_r_offset(),
1749 _("unexpected reloc %u in object file"),
1754 gold_error_at_location(relinfo
, relnum
, rela
.get_r_offset(),
1755 _("unsupported reloc %u"),
1763 // Perform a TLS relocation.
1765 template<int size
, bool big_endian
>
1767 Target_powerpc
<size
, big_endian
>::Relocate::relocate_tls(
1768 const Relocate_info
<size
, big_endian
>* relinfo
,
1769 Target_powerpc
<size
, big_endian
>* target
,
1771 const elfcpp::Rela
<size
, big_endian
>& rela
,
1772 unsigned int r_type
,
1773 const Sized_symbol
<size
>* gsym
,
1774 const Symbol_value
<size
>* psymval
,
1775 unsigned char* view
,
1776 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
,
1779 Output_segment
* tls_segment
= relinfo
->layout
->tls_segment();
1780 typedef Powerpc_relocate_functions
<size
, big_endian
> Reloc
;
1781 const Sized_relobj
<size
, big_endian
>* object
= relinfo
->object
;
1783 const elfcpp::Elf_Xword addend
= rela
.get_r_addend();
1784 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
= psymval
->value(object
, 0);
1786 const bool is_final
=
1788 ? !parameters
->options().output_is_position_independent()
1789 : gsym
->final_value_is_known());
1790 const tls::Tls_optimization optimized_type
1791 = optimize_tls_reloc(is_final
, r_type
);
1799 // Relocate section data.
1801 template<int size
, bool big_endian
>
1803 Target_powerpc
<size
, big_endian
>::relocate_section(
1804 const Relocate_info
<size
, big_endian
>* relinfo
,
1805 unsigned int sh_type
,
1806 const unsigned char* prelocs
,
1808 Output_section
* output_section
,
1809 bool needs_special_offset_handling
,
1810 unsigned char* view
,
1811 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
,
1812 section_size_type view_size
)
1814 typedef Target_powerpc
<size
, big_endian
> Powerpc
;
1815 typedef typename Target_powerpc
<size
, big_endian
>::Relocate Powerpc_relocate
;
1817 gold_assert(sh_type
== elfcpp::SHT_RELA
);
1819 gold::relocate_section
<size
, big_endian
, Powerpc
, elfcpp::SHT_RELA
,
1826 needs_special_offset_handling
,
1832 // Return the size of a relocation while scanning during a relocatable
1835 template<int size
, bool big_endian
>
1837 Target_powerpc
<size
, big_endian
>::Relocatable_size_for_reloc::get_size_for_reloc(
1841 // We are always SHT_RELA, so we should never get here.
1846 // Scan the relocs during a relocatable link.
1848 template<int size
, bool big_endian
>
1850 Target_powerpc
<size
, big_endian
>::scan_relocatable_relocs(
1851 const General_options
& options
,
1852 Symbol_table
* symtab
,
1854 Sized_relobj
<size
, big_endian
>* object
,
1855 unsigned int data_shndx
,
1856 unsigned int sh_type
,
1857 const unsigned char* prelocs
,
1859 Output_section
* output_section
,
1860 bool needs_special_offset_handling
,
1861 size_t local_symbol_count
,
1862 const unsigned char* plocal_symbols
,
1863 Relocatable_relocs
* rr
)
1865 gold_assert(sh_type
== elfcpp::SHT_RELA
);
1867 typedef gold::Default_scan_relocatable_relocs
<elfcpp::SHT_RELA
,
1868 Relocatable_size_for_reloc
> Scan_relocatable_relocs
;
1870 gold::scan_relocatable_relocs
<size
, big_endian
, elfcpp::SHT_RELA
,
1871 Scan_relocatable_relocs
>(
1880 needs_special_offset_handling
,
1886 // Relocate a section during a relocatable link.
1888 template<int size
, bool big_endian
>
1890 Target_powerpc
<size
, big_endian
>::relocate_for_relocatable(
1891 const Relocate_info
<size
, big_endian
>* relinfo
,
1892 unsigned int sh_type
,
1893 const unsigned char* prelocs
,
1895 Output_section
* output_section
,
1896 off_t offset_in_output_section
,
1897 const Relocatable_relocs
* rr
,
1898 unsigned char* view
,
1899 typename
elfcpp::Elf_types
<size
>::Elf_Addr view_address
,
1900 section_size_type view_size
,
1901 unsigned char* reloc_view
,
1902 section_size_type reloc_view_size
)
1904 gold_assert(sh_type
== elfcpp::SHT_RELA
);
1906 gold::relocate_for_relocatable
<size
, big_endian
, elfcpp::SHT_RELA
>(
1911 offset_in_output_section
,
1920 // Return the value to use for a dynamic which requires special
1921 // treatment. This is how we support equality comparisons of function
1922 // pointers across shared library boundaries, as described in the
1923 // processor specific ABI supplement.
1925 template<int size
, bool big_endian
>
1927 Target_powerpc
<size
, big_endian
>::do_dynsym_value(const Symbol
* gsym
) const
1929 gold_assert(gsym
->is_from_dynobj() && gsym
->has_plt_offset());
1930 return this->plt_section()->address() + gsym
->plt_offset();
1933 // The selector for powerpc object files.
1935 template<int size
, bool big_endian
>
1936 class Target_selector_powerpc
: public Target_selector
1939 Target_selector_powerpc()
1940 : Target_selector(elfcpp::EM_NONE
, size
, big_endian
,
1942 (big_endian
? "elf64-powerpc" : "elf64-powerpcle") :
1943 (big_endian
? "elf32-powerpc" : "elf32-powerpcle")))
1946 Target
* instantiated_target_
;
1948 Target
* do_recognize(int machine
, int, int)
1953 if (machine
!= elfcpp::EM_PPC64
)
1958 if (machine
!= elfcpp::EM_PPC
)
1966 return do_instantiate_target();
1969 Target
* do_instantiate_target()
1971 if (this->instantiated_target_
== NULL
)
1972 this->instantiated_target_
= new Target_powerpc
<size
, big_endian
>();
1973 return this->instantiated_target_
;
1977 Target_selector_powerpc
<32, true> target_selector_ppc32
;
1978 Target_selector_powerpc
<32, false> target_selector_ppc32le
;
1979 Target_selector_powerpc
<64, true> target_selector_ppc64
;
1980 Target_selector_powerpc
<64, false> target_selector_ppc64le
;
1982 } // End anonymous namespace.