1 // powerpc.cc -- powerpc target support for gold.
3 // Copyright 2008, 2009 Free Software Foundation, Inc.
4 // Written by David S. Miller <davem@davemloft.net>
5 // and David Edelsohn <edelsohn@gnu.org>
7 // This file is part of gold.
9 // This program is free software; you can redistribute it and/or modify
10 // it under the terms of the GNU General Public License as published by
11 // the Free Software Foundation; either version 3 of the License, or
12 // (at your option) any later version.
14 // This program is distributed in the hope that it will be useful,
15 // but WITHOUT ANY WARRANTY; without even the implied warranty of
16 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 // GNU General Public License for more details.
19 // You should have received a copy of the GNU General Public License
20 // along with this program; if not, write to the Free Software
21 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 // MA 02110-1301, USA.
27 #include "parameters.h"
34 #include "copy-relocs.h"
36 #include "target-reloc.h"
37 #include "target-select.h"
47 template<int size
, bool big_endian
>
48 class Output_data_plt_powerpc
;
50 template<int size
, bool big_endian
>
51 class Target_powerpc
: public Sized_target
<size
, big_endian
>
54 typedef Output_data_reloc
<elfcpp::SHT_RELA
, true, size
, big_endian
> Reloc_section
;
57 : Sized_target
<size
, big_endian
>(&powerpc_info
),
58 got_(NULL
), got2_(NULL
), toc_(NULL
),
59 plt_(NULL
), rela_dyn_(NULL
),
60 copy_relocs_(elfcpp::R_POWERPC_COPY
),
61 dynbss_(NULL
), got_mod_index_offset_(-1U)
65 // Process the relocations to determine unreferenced sections for
66 // garbage collection.
68 gc_process_relocs(Symbol_table
* symtab
,
70 Sized_relobj
<size
, big_endian
>* object
,
71 unsigned int data_shndx
,
73 const unsigned char* prelocs
,
75 Output_section
* output_section
,
76 bool needs_special_offset_handling
,
77 size_t local_symbol_count
,
78 const unsigned char* plocal_symbols
);
80 // Scan the relocations to look for symbol adjustments.
82 scan_relocs(Symbol_table
* symtab
,
84 Sized_relobj
<size
, big_endian
>* object
,
85 unsigned int data_shndx
,
87 const unsigned char* prelocs
,
89 Output_section
* output_section
,
90 bool needs_special_offset_handling
,
91 size_t local_symbol_count
,
92 const unsigned char* plocal_symbols
);
93 // Finalize the sections.
95 do_finalize_sections(Layout
*, const Input_objects
*, Symbol_table
*);
97 // Return the value to use for a dynamic which requires special
100 do_dynsym_value(const Symbol
*) const;
102 // Relocate a section.
104 relocate_section(const Relocate_info
<size
, big_endian
>*,
105 unsigned int sh_type
,
106 const unsigned char* prelocs
,
108 Output_section
* output_section
,
109 bool needs_special_offset_handling
,
111 typename
elfcpp::Elf_types
<size
>::Elf_Addr view_address
,
112 section_size_type view_size
,
113 const Reloc_symbol_changes
*);
115 // Scan the relocs during a relocatable link.
117 scan_relocatable_relocs(Symbol_table
* symtab
,
119 Sized_relobj
<size
, big_endian
>* object
,
120 unsigned int data_shndx
,
121 unsigned int sh_type
,
122 const unsigned char* prelocs
,
124 Output_section
* output_section
,
125 bool needs_special_offset_handling
,
126 size_t local_symbol_count
,
127 const unsigned char* plocal_symbols
,
128 Relocatable_relocs
*);
130 // Relocate a section during a relocatable link.
132 relocate_for_relocatable(const Relocate_info
<size
, big_endian
>*,
133 unsigned int sh_type
,
134 const unsigned char* prelocs
,
136 Output_section
* output_section
,
137 off_t offset_in_output_section
,
138 const Relocatable_relocs
*,
140 typename
elfcpp::Elf_types
<size
>::Elf_Addr view_address
,
141 section_size_type view_size
,
142 unsigned char* reloc_view
,
143 section_size_type reloc_view_size
);
145 // Return whether SYM is defined by the ABI.
147 do_is_defined_by_abi(const Symbol
* sym
) const
149 return strcmp(sym
->name(), "___tls_get_addr") == 0;
152 // Return the size of the GOT section.
156 gold_assert(this->got_
!= NULL
);
157 return this->got_
->data_size();
162 // The class which scans relocations.
167 : issued_non_pic_error_(false)
171 local(Symbol_table
* symtab
, Layout
* layout
, Target_powerpc
* target
,
172 Sized_relobj
<size
, big_endian
>* object
,
173 unsigned int data_shndx
,
174 Output_section
* output_section
,
175 const elfcpp::Rela
<size
, big_endian
>& reloc
, unsigned int r_type
,
176 const elfcpp::Sym
<size
, big_endian
>& lsym
);
179 global(Symbol_table
* symtab
, Layout
* layout
, Target_powerpc
* target
,
180 Sized_relobj
<size
, big_endian
>* object
,
181 unsigned int data_shndx
,
182 Output_section
* output_section
,
183 const elfcpp::Rela
<size
, big_endian
>& reloc
, unsigned int r_type
,
188 unsupported_reloc_local(Sized_relobj
<size
, big_endian
>*,
189 unsigned int r_type
);
192 unsupported_reloc_global(Sized_relobj
<size
, big_endian
>*,
193 unsigned int r_type
, Symbol
*);
196 generate_tls_call(Symbol_table
* symtab
, Layout
* layout
,
197 Target_powerpc
* target
);
200 check_non_pic(Relobj
*, unsigned int r_type
);
202 // Whether we have issued an error about a non-PIC compilation.
203 bool issued_non_pic_error_
;
206 // The class which implements relocation.
210 // Do a relocation. Return false if the caller should not issue
211 // any warnings about this relocation.
213 relocate(const Relocate_info
<size
, big_endian
>*, Target_powerpc
*,
214 Output_section
*, size_t relnum
,
215 const elfcpp::Rela
<size
, big_endian
>&,
216 unsigned int r_type
, const Sized_symbol
<size
>*,
217 const Symbol_value
<size
>*,
219 typename
elfcpp::Elf_types
<size
>::Elf_Addr
,
223 // Do a TLS relocation.
225 relocate_tls(const Relocate_info
<size
, big_endian
>*,
226 Target_powerpc
* target
,
227 size_t relnum
, const elfcpp::Rela
<size
, big_endian
>&,
228 unsigned int r_type
, const Sized_symbol
<size
>*,
229 const Symbol_value
<size
>*,
231 typename
elfcpp::Elf_types
<size
>::Elf_Addr
,
235 // A class which returns the size required for a relocation type,
236 // used while scanning relocs during a relocatable link.
237 class Relocatable_size_for_reloc
241 get_size_for_reloc(unsigned int, Relobj
*);
244 // Get the GOT section, creating it if necessary.
245 Output_data_got
<size
, big_endian
>*
246 got_section(Symbol_table
*, Layout
*);
251 gold_assert (this->got2_
!= NULL
);
255 // Get the TOC section.
259 gold_assert (this->toc_
!= NULL
);
263 // Create a PLT entry for a global symbol.
265 make_plt_entry(Symbol_table
*, Layout
*, Symbol
*);
267 // Create a GOT entry for the TLS module index.
269 got_mod_index_entry(Symbol_table
* symtab
, Layout
* layout
,
270 Sized_relobj
<size
, big_endian
>* object
);
272 // Get the PLT section.
273 const Output_data_plt_powerpc
<size
, big_endian
>*
276 gold_assert(this->plt_
!= NULL
);
280 // Get the dynamic reloc section, creating it if necessary.
282 rela_dyn_section(Layout
*);
284 // Copy a relocation against a global symbol.
286 copy_reloc(Symbol_table
* symtab
, Layout
* layout
,
287 Sized_relobj
<size
, big_endian
>* object
,
288 unsigned int shndx
, Output_section
* output_section
,
289 Symbol
* sym
, const elfcpp::Rela
<size
, big_endian
>& reloc
)
291 this->copy_relocs_
.copy_reloc(symtab
, layout
,
292 symtab
->get_sized_symbol
<size
>(sym
),
293 object
, shndx
, output_section
,
294 reloc
, this->rela_dyn_section(layout
));
297 // Information about this specific target which we pass to the
298 // general Target structure.
299 static Target::Target_info powerpc_info
;
301 // The types of GOT entries needed for this platform.
304 GOT_TYPE_STANDARD
= 0, // GOT entry for a regular symbol
305 GOT_TYPE_TLS_OFFSET
= 1, // GOT entry for TLS offset
306 GOT_TYPE_TLS_PAIR
= 2, // GOT entry for TLS module/offset pair
310 Output_data_got
<size
, big_endian
>* got_
;
312 Output_data_space
* got2_
;
314 Output_data_space
* toc_
;
316 Output_data_plt_powerpc
<size
, big_endian
>* plt_
;
317 // The dynamic reloc section.
318 Reloc_section
* rela_dyn_
;
319 // Relocs saved to avoid a COPY reloc.
320 Copy_relocs
<elfcpp::SHT_RELA
, size
, big_endian
> copy_relocs_
;
321 // Space for variables copied with a COPY reloc.
322 Output_data_space
* dynbss_
;
323 // Offset of the GOT entry for the TLS module index;
324 unsigned int got_mod_index_offset_
;
328 Target::Target_info Target_powerpc
<32, true>::powerpc_info
=
331 true, // is_big_endian
332 elfcpp::EM_PPC
, // machine_code
333 false, // has_make_symbol
334 false, // has_resolve
335 false, // has_code_fill
336 true, // is_default_stack_executable
338 "/usr/lib/ld.so.1", // dynamic_linker
339 0x10000000, // default_text_segment_address
340 64 * 1024, // abi_pagesize (overridable by -z max-page-size)
341 4 * 1024, // common_pagesize (overridable by -z common-page-size)
342 elfcpp::SHN_UNDEF
, // small_common_shndx
343 elfcpp::SHN_UNDEF
, // large_common_shndx
344 0, // small_common_section_flags
345 0, // large_common_section_flags
346 NULL
, // attributes_section
347 NULL
// attributes_vendor
351 Target::Target_info Target_powerpc
<32, false>::powerpc_info
=
354 false, // is_big_endian
355 elfcpp::EM_PPC
, // machine_code
356 false, // has_make_symbol
357 false, // has_resolve
358 false, // has_code_fill
359 true, // is_default_stack_executable
361 "/usr/lib/ld.so.1", // dynamic_linker
362 0x10000000, // default_text_segment_address
363 64 * 1024, // abi_pagesize (overridable by -z max-page-size)
364 4 * 1024, // common_pagesize (overridable by -z common-page-size)
365 elfcpp::SHN_UNDEF
, // small_common_shndx
366 elfcpp::SHN_UNDEF
, // large_common_shndx
367 0, // small_common_section_flags
368 0, // large_common_section_flags
369 NULL
, // attributes_section
370 NULL
// attributes_vendor
374 Target::Target_info Target_powerpc
<64, true>::powerpc_info
=
377 true, // is_big_endian
378 elfcpp::EM_PPC64
, // machine_code
379 false, // has_make_symbol
380 false, // has_resolve
381 false, // has_code_fill
382 true, // is_default_stack_executable
384 "/usr/lib/ld.so.1", // dynamic_linker
385 0x10000000, // default_text_segment_address
386 64 * 1024, // abi_pagesize (overridable by -z max-page-size)
387 8 * 1024, // common_pagesize (overridable by -z common-page-size)
388 elfcpp::SHN_UNDEF
, // small_common_shndx
389 elfcpp::SHN_UNDEF
, // large_common_shndx
390 0, // small_common_section_flags
391 0, // large_common_section_flags
392 NULL
, // attributes_section
393 NULL
// attributes_vendor
397 Target::Target_info Target_powerpc
<64, false>::powerpc_info
=
400 false, // is_big_endian
401 elfcpp::EM_PPC64
, // machine_code
402 false, // has_make_symbol
403 false, // has_resolve
404 false, // has_code_fill
405 true, // is_default_stack_executable
407 "/usr/lib/ld.so.1", // dynamic_linker
408 0x10000000, // default_text_segment_address
409 64 * 1024, // abi_pagesize (overridable by -z max-page-size)
410 8 * 1024, // common_pagesize (overridable by -z common-page-size)
411 elfcpp::SHN_UNDEF
, // small_common_shndx
412 elfcpp::SHN_UNDEF
, // large_common_shndx
413 0, // small_common_section_flags
414 0, // large_common_section_flags
415 NULL
, // attributes_section
416 NULL
// attributes_vendor
419 template<int size
, bool big_endian
>
420 class Powerpc_relocate_functions
423 // Do a simple relocation with the addend in the relocation.
424 template<int valsize
>
426 rela(unsigned char* view
,
427 unsigned int right_shift
,
428 elfcpp::Elf_Xword dst_mask
,
429 typename
elfcpp::Swap
<size
, big_endian
>::Valtype value
,
430 typename
elfcpp::Swap
<size
, big_endian
>::Valtype addend
)
432 typedef typename
elfcpp::Swap
<valsize
, big_endian
>::Valtype Valtype
;
433 Valtype
* wv
= reinterpret_cast<Valtype
*>(view
);
434 Valtype val
= elfcpp::Swap
<valsize
, big_endian
>::readval(wv
);
435 Valtype reloc
= ((value
+ addend
) >> right_shift
);
440 elfcpp::Swap
<valsize
, big_endian
>::writeval(wv
, val
| reloc
);
443 // Do a simple relocation using a symbol value with the addend in
445 template<int valsize
>
447 rela(unsigned char* view
,
448 unsigned int right_shift
,
449 elfcpp::Elf_Xword dst_mask
,
450 const Sized_relobj
<size
, big_endian
>* object
,
451 const Symbol_value
<size
>* psymval
,
452 typename
elfcpp::Swap
<valsize
, big_endian
>::Valtype addend
)
454 typedef typename
elfcpp::Swap
<valsize
, big_endian
>::Valtype Valtype
;
455 Valtype
* wv
= reinterpret_cast<Valtype
*>(view
);
456 Valtype val
= elfcpp::Swap
<valsize
, big_endian
>::readval(wv
);
457 Valtype reloc
= (psymval
->value(object
, addend
) >> right_shift
);
462 elfcpp::Swap
<valsize
, big_endian
>::writeval(wv
, val
| reloc
);
465 // Do a simple relocation using a symbol value with the addend in
466 // the relocation, unaligned.
467 template<int valsize
>
469 rela_ua(unsigned char* view
, unsigned int right_shift
,
470 elfcpp::Elf_Xword dst_mask
,
471 const Sized_relobj
<size
, big_endian
>* object
,
472 const Symbol_value
<size
>* psymval
,
473 typename
elfcpp::Swap
<size
, big_endian
>::Valtype addend
)
475 typedef typename
elfcpp::Swap_unaligned
<valsize
,
476 big_endian
>::Valtype Valtype
;
477 unsigned char* wv
= view
;
478 Valtype val
= elfcpp::Swap_unaligned
<valsize
, big_endian
>::readval(wv
);
479 Valtype reloc
= (psymval
->value(object
, addend
) >> right_shift
);
484 elfcpp::Swap_unaligned
<valsize
, big_endian
>::writeval(wv
, val
| reloc
);
487 // Do a simple PC relative relocation with a Symbol_value with the
488 // addend in the relocation.
489 template<int valsize
>
491 pcrela(unsigned char* view
, unsigned int right_shift
,
492 elfcpp::Elf_Xword dst_mask
,
493 const Sized_relobj
<size
, big_endian
>* object
,
494 const Symbol_value
<size
>* psymval
,
495 typename
elfcpp::Swap
<size
, big_endian
>::Valtype addend
,
496 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
)
498 typedef typename
elfcpp::Swap
<valsize
, big_endian
>::Valtype Valtype
;
499 Valtype
* wv
= reinterpret_cast<Valtype
*>(view
);
500 Valtype val
= elfcpp::Swap
<valsize
, big_endian
>::readval(wv
);
501 Valtype reloc
= ((psymval
->value(object
, addend
) - address
)
507 elfcpp::Swap
<valsize
, big_endian
>::writeval(wv
, val
| reloc
);
510 template<int valsize
>
512 pcrela_unaligned(unsigned char* view
,
513 const Sized_relobj
<size
, big_endian
>* object
,
514 const Symbol_value
<size
>* psymval
,
515 typename
elfcpp::Swap
<size
, big_endian
>::Valtype addend
,
516 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
)
518 typedef typename
elfcpp::Swap_unaligned
<valsize
,
519 big_endian
>::Valtype Valtype
;
520 unsigned char* wv
= view
;
521 Valtype reloc
= (psymval
->value(object
, addend
) - address
);
523 elfcpp::Swap_unaligned
<valsize
, big_endian
>::writeval(wv
, reloc
);
526 typedef Powerpc_relocate_functions
<size
, big_endian
> This
;
527 typedef Relocate_functions
<size
, big_endian
> This_reloc
;
529 // R_POWERPC_REL32: (Symbol + Addend - Address)
531 rel32(unsigned char* view
,
532 const Sized_relobj
<size
, big_endian
>* object
,
533 const Symbol_value
<size
>* psymval
,
534 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
,
535 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
)
536 { This_reloc::pcrela32(view
, object
, psymval
, addend
, address
); }
538 // R_POWERPC_REL24: (Symbol + Addend - Address) & 0x3fffffc
540 rel24(unsigned char* view
,
541 const Sized_relobj
<size
, big_endian
>* object
,
542 const Symbol_value
<size
>* psymval
,
543 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
,
544 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
)
546 This::template pcrela
<32>(view
, 0, 0x03fffffc, object
,
547 psymval
, addend
, address
);
550 // R_POWERPC_REL14: (Symbol + Addend - Address) & 0xfffc
552 rel14(unsigned char* view
,
553 const Sized_relobj
<size
, big_endian
>* object
,
554 const Symbol_value
<size
>* psymval
,
555 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
,
556 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
)
558 This::template pcrela
<32>(view
, 0, 0x0000fffc, object
,
559 psymval
, addend
, address
);
562 // R_POWERPC_ADDR16: (Symbol + Addend) & 0xffff
564 addr16(unsigned char* view
,
565 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
,
566 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
567 { This_reloc::rela16(view
, value
, addend
); }
570 addr16(unsigned char* view
,
571 const Sized_relobj
<size
, big_endian
>* object
,
572 const Symbol_value
<size
>* psymval
,
573 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
574 { This_reloc::rela16(view
, object
, psymval
, addend
); }
576 // R_POWERPC_ADDR16_DS: (Symbol + Addend) & 0xfffc
578 addr16_ds(unsigned char* view
,
579 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
,
580 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
582 This::template rela
<16>(view
, 0, 0xfffc, value
, addend
);
585 // R_POWERPC_ADDR16_LO: (Symbol + Addend) & 0xffff
587 addr16_lo(unsigned char* view
,
588 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
,
589 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
590 { This_reloc::rela16(view
, value
, addend
); }
593 addr16_lo(unsigned char* view
,
594 const Sized_relobj
<size
, big_endian
>* object
,
595 const Symbol_value
<size
>* psymval
,
596 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
597 { This_reloc::rela16(view
, object
, psymval
, addend
); }
599 // R_POWERPC_ADDR16_HI: ((Symbol + Addend) >> 16) & 0xffff
601 addr16_hi(unsigned char* view
,
602 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
,
603 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
605 This::template rela
<16>(view
, 16, 0xffff, value
, addend
);
609 addr16_hi(unsigned char* view
,
610 const Sized_relobj
<size
, big_endian
>* object
,
611 const Symbol_value
<size
>* psymval
,
612 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
614 This::template rela
<16>(view
, 16, 0xffff, object
, psymval
, addend
);
617 // R_POWERPC_ADDR16_HA: Same as R_POWERPC_ADDR16_HI except that if the
618 // final value of the low 16 bits of the
619 // relocation is negative, add one.
621 addr16_ha(unsigned char* view
,
622 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
,
623 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
625 typename
elfcpp::Elf_types
<size
>::Elf_Addr reloc
;
627 reloc
= value
+ addend
;
633 elfcpp::Swap
<16, big_endian
>::writeval(view
, reloc
);
637 addr16_ha(unsigned char* view
,
638 const Sized_relobj
<size
, big_endian
>* object
,
639 const Symbol_value
<size
>* psymval
,
640 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
642 typename
elfcpp::Elf_types
<size
>::Elf_Addr reloc
;
644 reloc
= psymval
->value(object
, addend
);
650 elfcpp::Swap
<16, big_endian
>::writeval(view
, reloc
);
653 // R_PPC_REL16: (Symbol + Addend - Address) & 0xffff
655 rel16(unsigned char* view
,
656 const Sized_relobj
<size
, big_endian
>* object
,
657 const Symbol_value
<size
>* psymval
,
658 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
,
659 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
)
660 { This_reloc::pcrela16(view
, object
, psymval
, addend
, address
); }
662 // R_PPC_REL16_LO: (Symbol + Addend - Address) & 0xffff
664 rel16_lo(unsigned char* view
,
665 const Sized_relobj
<size
, big_endian
>* object
,
666 const Symbol_value
<size
>* psymval
,
667 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
,
668 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
)
669 { This_reloc::pcrela16(view
, object
, psymval
, addend
, address
); }
671 // R_PPC_REL16_HI: ((Symbol + Addend - Address) >> 16) & 0xffff
673 rel16_hi(unsigned char* view
,
674 const Sized_relobj
<size
, big_endian
>* object
,
675 const Symbol_value
<size
>* psymval
,
676 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
,
677 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
)
679 This::template pcrela
<16>(view
, 16, 0xffff, object
,
680 psymval
, addend
, address
);
683 // R_PPC_REL16_HA: Same as R_PPC_REL16_HI except that if the
684 // final value of the low 16 bits of the
685 // relocation is negative, add one.
687 rel16_ha(unsigned char* view
,
688 const Sized_relobj
<size
, big_endian
>* object
,
689 const Symbol_value
<size
>* psymval
,
690 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
,
691 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
)
693 typename
elfcpp::Elf_types
<size
>::Elf_Addr reloc
;
695 reloc
= (psymval
->value(object
, addend
) - address
);
700 elfcpp::Swap
<16, big_endian
>::writeval(view
, reloc
);
704 // Get the GOT section, creating it if necessary.
706 template<int size
, bool big_endian
>
707 Output_data_got
<size
, big_endian
>*
708 Target_powerpc
<size
, big_endian
>::got_section(Symbol_table
* symtab
,
711 if (this->got_
== NULL
)
713 gold_assert(symtab
!= NULL
&& layout
!= NULL
);
715 this->got_
= new Output_data_got
<size
, big_endian
>();
717 layout
->add_output_section_data(".got", elfcpp::SHT_PROGBITS
,
718 elfcpp::SHF_ALLOC
| elfcpp::SHF_WRITE
,
721 // Create the GOT2 or TOC in the .got section.
724 this->got2_
= new Output_data_space(4, "** GOT2");
725 layout
->add_output_section_data(".got2", elfcpp::SHT_PROGBITS
,
732 this->toc_
= new Output_data_space(8, "** TOC");
733 layout
->add_output_section_data(".toc", elfcpp::SHT_PROGBITS
,
739 // Define _GLOBAL_OFFSET_TABLE_ at the start of the .got section.
740 symtab
->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL
,
741 Symbol_table::PREDEFINED
,
743 0, 0, elfcpp::STT_OBJECT
,
745 elfcpp::STV_HIDDEN
, 0,
752 // Get the dynamic reloc section, creating it if necessary.
754 template<int size
, bool big_endian
>
755 typename Target_powerpc
<size
, big_endian
>::Reloc_section
*
756 Target_powerpc
<size
, big_endian
>::rela_dyn_section(Layout
* layout
)
758 if (this->rela_dyn_
== NULL
)
760 gold_assert(layout
!= NULL
);
761 this->rela_dyn_
= new Reloc_section(parameters
->options().combreloc());
762 layout
->add_output_section_data(".rela.dyn", elfcpp::SHT_RELA
,
763 elfcpp::SHF_ALLOC
, this->rela_dyn_
, true);
765 return this->rela_dyn_
;
768 // A class to handle the PLT data.
770 template<int size
, bool big_endian
>
771 class Output_data_plt_powerpc
: public Output_section_data
774 typedef Output_data_reloc
<elfcpp::SHT_RELA
, true,
775 size
, big_endian
> Reloc_section
;
777 Output_data_plt_powerpc(Layout
*);
779 // Add an entry to the PLT.
780 void add_entry(Symbol
* gsym
);
782 // Return the .rela.plt section data.
783 const Reloc_section
* rel_plt() const
789 void do_adjust_output_section(Output_section
* os
);
792 // The size of an entry in the PLT.
793 static const int base_plt_entry_size
= (size
== 32 ? 16 : 24);
795 // Set the final size.
797 set_final_data_size()
799 unsigned int full_count
= this->count_
+ 4;
801 this->set_data_size(full_count
* base_plt_entry_size
);
804 // Write out the PLT data.
806 do_write(Output_file
*);
808 // The reloc section.
810 // The number of PLT entries.
814 // Create the PLT section. The ordinary .got section is an argument,
815 // since we need to refer to the start.
817 template<int size
, bool big_endian
>
818 Output_data_plt_powerpc
<size
, big_endian
>::Output_data_plt_powerpc(Layout
* layout
)
819 : Output_section_data(size
== 32 ? 4 : 8), count_(0)
821 this->rel_
= new Reloc_section(false);
822 layout
->add_output_section_data(".rela.plt", elfcpp::SHT_RELA
,
823 elfcpp::SHF_ALLOC
, this->rel_
, true);
826 template<int size
, bool big_endian
>
828 Output_data_plt_powerpc
<size
, big_endian
>::do_adjust_output_section(Output_section
* os
)
833 // Add an entry to the PLT.
835 template<int size
, bool big_endian
>
837 Output_data_plt_powerpc
<size
, big_endian
>::add_entry(Symbol
* gsym
)
839 gold_assert(!gsym
->has_plt_offset());
840 unsigned int index
= this->count_
+ + 4;
841 section_offset_type plt_offset
;
844 plt_offset
= index
* base_plt_entry_size
;
848 gsym
->set_plt_offset(plt_offset
);
852 gsym
->set_needs_dynsym_entry();
853 this->rel_
->add_global(gsym
, elfcpp::R_POWERPC_JMP_SLOT
, this,
857 static const unsigned int addis_11_11
= 0x3d6b0000;
858 static const unsigned int addis_11_30
= 0x3d7e0000;
859 static const unsigned int addis_12_12
= 0x3d8c0000;
860 static const unsigned int addi_11_11
= 0x396b0000;
861 static const unsigned int add_0_11_11
= 0x7c0b5a14;
862 static const unsigned int add_11_0_11
= 0x7d605a14;
863 static const unsigned int b
= 0x48000000;
864 static const unsigned int bcl_20_31
= 0x429f0005;
865 static const unsigned int bctr
= 0x4e800420;
866 static const unsigned int lis_11
= 0x3d600000;
867 static const unsigned int lis_12
= 0x3d800000;
868 static const unsigned int lwzu_0_12
= 0x840c0000;
869 static const unsigned int lwz_0_12
= 0x800c0000;
870 static const unsigned int lwz_11_11
= 0x816b0000;
871 static const unsigned int lwz_11_30
= 0x817e0000;
872 static const unsigned int lwz_12_12
= 0x818c0000;
873 static const unsigned int mflr_0
= 0x7c0802a6;
874 static const unsigned int mflr_12
= 0x7d8802a6;
875 static const unsigned int mtctr_0
= 0x7c0903a6;
876 static const unsigned int mtctr_11
= 0x7d6903a6;
877 static const unsigned int mtlr_0
= 0x7c0803a6;
878 static const unsigned int nop
= 0x60000000;
879 static const unsigned int sub_11_11_12
= 0x7d6c5850;
881 static const unsigned int addis_r12_r2
= 0x3d820000; /* addis %r12,%r2,xxx@ha */
882 static const unsigned int std_r2_40r1
= 0xf8410028; /* std %r2,40(%r1) */
883 static const unsigned int ld_r11_0r12
= 0xe96c0000; /* ld %r11,xxx+0@l(%r12) */
884 static const unsigned int ld_r2_0r12
= 0xe84c0000; /* ld %r2,xxx+8@l(%r12) */
885 /* ld %r11,xxx+16@l(%r12) */
888 // Write out the PLT.
890 template<int size
, bool big_endian
>
892 Output_data_plt_powerpc
<size
, big_endian
>::do_write(Output_file
* of
)
894 const off_t offset
= this->offset();
895 const section_size_type oview_size
=
896 convert_to_section_size_type(this->data_size());
897 unsigned char* const oview
= of
->get_output_view(offset
, oview_size
);
898 unsigned char* pov
= oview
;
900 memset(pov
, 0, base_plt_entry_size
* 4);
901 pov
+= base_plt_entry_size
* 4;
903 unsigned int plt_offset
= base_plt_entry_size
* 4;
904 const unsigned int count
= this->count_
;
908 for (unsigned int i
= 0; i
< count
; i
++)
914 for (unsigned int i
= 0; i
< count
; i
++)
916 elfcpp::Swap
<32, true>::writeval(pov
+ 0x00,
917 lwz_11_30
+ plt_offset
);
918 elfcpp::Swap
<32, true>::writeval(pov
+ 0x04, mtctr_11
);
919 elfcpp::Swap
<32, true>::writeval(pov
+ 0x08, bctr
);
920 elfcpp::Swap
<32, true>::writeval(pov
+ 0x0c, nop
);
921 pov
+= base_plt_entry_size
;
922 plt_offset
+= base_plt_entry_size
;
926 gold_assert(static_cast<section_size_type
>(pov
- oview
) == oview_size
);
928 of
->write_output_view(offset
, oview_size
, oview
);
931 // Create a PLT entry for a global symbol.
933 template<int size
, bool big_endian
>
935 Target_powerpc
<size
, big_endian
>::make_plt_entry(Symbol_table
* symtab
,
939 if (gsym
->has_plt_offset())
942 if (this->plt_
== NULL
)
944 // Create the GOT section first.
945 this->got_section(symtab
, layout
);
947 this->plt_
= new Output_data_plt_powerpc
<size
, big_endian
>(layout
);
948 layout
->add_output_section_data(".plt", elfcpp::SHT_PROGBITS
,
950 | elfcpp::SHF_EXECINSTR
951 | elfcpp::SHF_WRITE
),
954 // Define _PROCEDURE_LINKAGE_TABLE_ at the start of the .plt section.
955 symtab
->define_in_output_data("_PROCEDURE_LINKAGE_TABLE_", NULL
,
956 Symbol_table::PREDEFINED
,
958 0, 0, elfcpp::STT_OBJECT
,
960 elfcpp::STV_HIDDEN
, 0,
964 this->plt_
->add_entry(gsym
);
967 // Create a GOT entry for the TLS module index.
969 template<int size
, bool big_endian
>
971 Target_powerpc
<size
, big_endian
>::got_mod_index_entry(Symbol_table
* symtab
,
973 Sized_relobj
<size
, big_endian
>* object
)
975 if (this->got_mod_index_offset_
== -1U)
977 gold_assert(symtab
!= NULL
&& layout
!= NULL
&& object
!= NULL
);
978 Reloc_section
* rela_dyn
= this->rela_dyn_section(layout
);
979 Output_data_got
<size
, big_endian
>* got
;
980 unsigned int got_offset
;
982 got
= this->got_section(symtab
, layout
);
983 got_offset
= got
->add_constant(0);
984 rela_dyn
->add_local(object
, 0, elfcpp::R_POWERPC_DTPMOD
, got
,
986 got
->add_constant(0);
987 this->got_mod_index_offset_
= got_offset
;
989 return this->got_mod_index_offset_
;
992 // Optimize the TLS relocation type based on what we know about the
993 // symbol. IS_FINAL is true if the final address of this symbol is
994 // known at link time.
996 static tls::Tls_optimization
997 optimize_tls_reloc(bool /* is_final */, int r_type
)
999 // If we are generating a shared library, then we can't do anything
1001 if (parameters
->options().shared())
1002 return tls::TLSOPT_NONE
;
1011 // Report an unsupported relocation against a local symbol.
1013 template<int size
, bool big_endian
>
1015 Target_powerpc
<size
, big_endian
>::Scan::unsupported_reloc_local(
1016 Sized_relobj
<size
, big_endian
>* object
,
1017 unsigned int r_type
)
1019 gold_error(_("%s: unsupported reloc %u against local symbol"),
1020 object
->name().c_str(), r_type
);
1023 // We are about to emit a dynamic relocation of type R_TYPE. If the
1024 // dynamic linker does not support it, issue an error.
1026 template<int size
, bool big_endian
>
1028 Target_powerpc
<size
, big_endian
>::Scan::check_non_pic(Relobj
* object
,
1029 unsigned int r_type
)
1031 gold_assert(r_type
!= elfcpp::R_POWERPC_NONE
);
1033 // These are the relocation types supported by glibc for both 32-bit
1034 // and 64-bit powerpc.
1037 case elfcpp::R_POWERPC_RELATIVE
:
1038 case elfcpp::R_POWERPC_GLOB_DAT
:
1039 case elfcpp::R_POWERPC_DTPMOD
:
1040 case elfcpp::R_POWERPC_DTPREL
:
1041 case elfcpp::R_POWERPC_TPREL
:
1042 case elfcpp::R_POWERPC_JMP_SLOT
:
1043 case elfcpp::R_POWERPC_COPY
:
1044 case elfcpp::R_POWERPC_ADDR32
:
1045 case elfcpp::R_POWERPC_ADDR24
:
1046 case elfcpp::R_POWERPC_REL24
:
1057 // These are the relocation types supported only on 64-bit.
1058 case elfcpp::R_PPC64_ADDR64
:
1059 case elfcpp::R_PPC64_TPREL16_LO_DS
:
1060 case elfcpp::R_PPC64_TPREL16_DS
:
1061 case elfcpp::R_POWERPC_TPREL16
:
1062 case elfcpp::R_POWERPC_TPREL16_LO
:
1063 case elfcpp::R_POWERPC_TPREL16_HI
:
1064 case elfcpp::R_POWERPC_TPREL16_HA
:
1065 case elfcpp::R_PPC64_TPREL16_HIGHER
:
1066 case elfcpp::R_PPC64_TPREL16_HIGHEST
:
1067 case elfcpp::R_PPC64_TPREL16_HIGHERA
:
1068 case elfcpp::R_PPC64_TPREL16_HIGHESTA
:
1069 case elfcpp::R_PPC64_ADDR16_LO_DS
:
1070 case elfcpp::R_POWERPC_ADDR16_LO
:
1071 case elfcpp::R_POWERPC_ADDR16_HI
:
1072 case elfcpp::R_POWERPC_ADDR16_HA
:
1073 case elfcpp::R_POWERPC_ADDR30
:
1074 case elfcpp::R_PPC64_UADDR64
:
1075 case elfcpp::R_POWERPC_UADDR32
:
1076 case elfcpp::R_POWERPC_ADDR16
:
1077 case elfcpp::R_POWERPC_UADDR16
:
1078 case elfcpp::R_PPC64_ADDR16_DS
:
1079 case elfcpp::R_PPC64_ADDR16_HIGHER
:
1080 case elfcpp::R_PPC64_ADDR16_HIGHEST
:
1081 case elfcpp::R_PPC64_ADDR16_HIGHERA
:
1082 case elfcpp::R_PPC64_ADDR16_HIGHESTA
:
1083 case elfcpp::R_POWERPC_ADDR14_BRTAKEN
:
1084 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN
:
1085 case elfcpp::R_POWERPC_REL32
:
1086 case elfcpp::R_PPC64_REL64
:
1097 // These are the relocation types supported only on 32-bit.
1104 // This prevents us from issuing more than one error per reloc
1105 // section. But we can still wind up issuing more than one
1106 // error per object file.
1107 if (this->issued_non_pic_error_
)
1109 gold_assert(parameters
->options().output_is_position_independent());
1110 object
->error(_("requires unsupported dynamic reloc; "
1111 "recompile with -fPIC"));
1112 this->issued_non_pic_error_
= true;
1116 // Scan a relocation for a local symbol.
1118 template<int size
, bool big_endian
>
1120 Target_powerpc
<size
, big_endian
>::Scan::local(
1121 Symbol_table
* symtab
,
1123 Target_powerpc
<size
, big_endian
>* target
,
1124 Sized_relobj
<size
, big_endian
>* object
,
1125 unsigned int data_shndx
,
1126 Output_section
* output_section
,
1127 const elfcpp::Rela
<size
, big_endian
>& reloc
,
1128 unsigned int r_type
,
1129 const elfcpp::Sym
<size
, big_endian
>& lsym
)
1133 case elfcpp::R_POWERPC_NONE
:
1134 case elfcpp::R_POWERPC_GNU_VTINHERIT
:
1135 case elfcpp::R_POWERPC_GNU_VTENTRY
:
1138 case elfcpp::R_PPC64_ADDR64
:
1139 case elfcpp::R_POWERPC_ADDR32
:
1140 case elfcpp::R_POWERPC_ADDR16_HA
:
1141 case elfcpp::R_POWERPC_ADDR16_LO
:
1142 // If building a shared library (or a position-independent
1143 // executable), we need to create a dynamic relocation for
1145 if (parameters
->options().output_is_position_independent())
1147 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
1149 check_non_pic(object
, r_type
);
1150 if (lsym
.get_st_type() != elfcpp::STT_SECTION
)
1152 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(reloc
.get_r_info());
1153 rela_dyn
->add_local(object
, r_sym
, r_type
, output_section
,
1154 data_shndx
, reloc
.get_r_offset(),
1155 reloc
.get_r_addend());
1159 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(reloc
.get_r_info());
1160 gold_assert(lsym
.get_st_value() == 0);
1161 rela_dyn
->add_local_relative(object
, r_sym
, r_type
,
1162 output_section
, data_shndx
,
1163 reloc
.get_r_offset(),
1164 reloc
.get_r_addend());
1169 case elfcpp::R_POWERPC_REL24
:
1170 case elfcpp::R_PPC_LOCAL24PC
:
1171 case elfcpp::R_POWERPC_REL32
:
1172 case elfcpp::R_PPC_REL16_LO
:
1173 case elfcpp::R_PPC_REL16_HA
:
1176 case elfcpp::R_POWERPC_GOT16
:
1177 case elfcpp::R_POWERPC_GOT16_LO
:
1178 case elfcpp::R_POWERPC_GOT16_HI
:
1179 case elfcpp::R_POWERPC_GOT16_HA
:
1180 case elfcpp::R_PPC64_TOC16
:
1181 case elfcpp::R_PPC64_TOC16_LO
:
1182 case elfcpp::R_PPC64_TOC16_HI
:
1183 case elfcpp::R_PPC64_TOC16_HA
:
1184 case elfcpp::R_PPC64_TOC16_DS
:
1185 case elfcpp::R_PPC64_TOC16_LO_DS
:
1187 // The symbol requires a GOT entry.
1188 Output_data_got
<size
, big_endian
>* got
;
1191 got
= target
->got_section(symtab
, layout
);
1192 r_sym
= elfcpp::elf_r_sym
<size
>(reloc
.get_r_info());
1194 // If we are generating a shared object, we need to add a
1195 // dynamic relocation for this symbol's GOT entry.
1196 if (parameters
->options().output_is_position_independent())
1198 if (!object
->local_has_got_offset(r_sym
, GOT_TYPE_STANDARD
))
1200 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
1203 off
= got
->add_constant(0);
1204 object
->set_local_got_offset(r_sym
, GOT_TYPE_STANDARD
, off
);
1205 rela_dyn
->add_local_relative(object
, r_sym
,
1206 elfcpp::R_POWERPC_RELATIVE
,
1211 got
->add_local(object
, r_sym
, GOT_TYPE_STANDARD
);
1215 case elfcpp::R_PPC64_TOC
:
1216 // We need a GOT section.
1217 target
->got_section(symtab
, layout
);
1220 // These are relocations which should only be seen by the
1221 // dynamic linker, and should never be seen here.
1222 case elfcpp::R_POWERPC_COPY
:
1223 case elfcpp::R_POWERPC_GLOB_DAT
:
1224 case elfcpp::R_POWERPC_JMP_SLOT
:
1225 case elfcpp::R_POWERPC_RELATIVE
:
1226 case elfcpp::R_POWERPC_DTPMOD
:
1227 gold_error(_("%s: unexpected reloc %u in object file"),
1228 object
->name().c_str(), r_type
);
1232 unsupported_reloc_local(object
, r_type
);
1237 // Report an unsupported relocation against a global symbol.
1239 template<int size
, bool big_endian
>
1241 Target_powerpc
<size
, big_endian
>::Scan::unsupported_reloc_global(
1242 Sized_relobj
<size
, big_endian
>* object
,
1243 unsigned int r_type
,
1246 gold_error(_("%s: unsupported reloc %u against global symbol %s"),
1247 object
->name().c_str(), r_type
, gsym
->demangled_name().c_str());
1250 // Scan a relocation for a global symbol.
1252 template<int size
, bool big_endian
>
1254 Target_powerpc
<size
, big_endian
>::Scan::global(
1255 Symbol_table
* symtab
,
1257 Target_powerpc
<size
, big_endian
>* target
,
1258 Sized_relobj
<size
, big_endian
>* object
,
1259 unsigned int data_shndx
,
1260 Output_section
* output_section
,
1261 const elfcpp::Rela
<size
, big_endian
>& reloc
,
1262 unsigned int r_type
,
1267 case elfcpp::R_POWERPC_NONE
:
1268 case elfcpp::R_POWERPC_GNU_VTINHERIT
:
1269 case elfcpp::R_POWERPC_GNU_VTENTRY
:
1272 case elfcpp::R_PPC_PLTREL24
:
1273 // If the symbol is fully resolved, this is just a PC32 reloc.
1274 // Otherwise we need a PLT entry.
1275 if (gsym
->final_value_is_known())
1277 // If building a shared library, we can also skip the PLT entry
1278 // if the symbol is defined in the output file and is protected
1280 if (gsym
->is_defined()
1281 && !gsym
->is_from_dynobj()
1282 && !gsym
->is_preemptible())
1284 target
->make_plt_entry(symtab
, layout
, gsym
);
1287 case elfcpp::R_POWERPC_ADDR16
:
1288 case elfcpp::R_POWERPC_ADDR16_LO
:
1289 case elfcpp::R_POWERPC_ADDR16_HI
:
1290 case elfcpp::R_POWERPC_ADDR16_HA
:
1291 case elfcpp::R_POWERPC_ADDR32
:
1292 case elfcpp::R_PPC64_ADDR64
:
1294 // Make a PLT entry if necessary.
1295 if (gsym
->needs_plt_entry())
1297 target
->make_plt_entry(symtab
, layout
, gsym
);
1298 // Since this is not a PC-relative relocation, we may be
1299 // taking the address of a function. In that case we need to
1300 // set the entry in the dynamic symbol table to the address of
1302 if (gsym
->is_from_dynobj() && !parameters
->options().shared())
1303 gsym
->set_needs_dynsym_value();
1305 // Make a dynamic relocation if necessary.
1306 if (gsym
->needs_dynamic_reloc(Symbol::ABSOLUTE_REF
))
1308 if (gsym
->may_need_copy_reloc())
1310 target
->copy_reloc(symtab
, layout
, object
,
1311 data_shndx
, output_section
, gsym
, reloc
);
1313 else if ((r_type
== elfcpp::R_POWERPC_ADDR32
1314 || r_type
== elfcpp::R_PPC64_ADDR64
)
1315 && gsym
->can_use_relative_reloc(false))
1317 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
1318 rela_dyn
->add_global_relative(gsym
, elfcpp::R_POWERPC_RELATIVE
,
1319 output_section
, object
,
1320 data_shndx
, reloc
.get_r_offset(),
1321 reloc
.get_r_addend());
1325 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
1327 check_non_pic(object
, r_type
);
1328 if (gsym
->is_from_dynobj()
1329 || gsym
->is_undefined()
1330 || gsym
->is_preemptible())
1331 rela_dyn
->add_global(gsym
, r_type
, output_section
,
1333 reloc
.get_r_offset(),
1334 reloc
.get_r_addend());
1336 rela_dyn
->add_global_relative(gsym
, r_type
,
1337 output_section
, object
,
1339 reloc
.get_r_offset(),
1340 reloc
.get_r_addend());
1346 case elfcpp::R_POWERPC_REL24
:
1347 case elfcpp::R_PPC_LOCAL24PC
:
1348 case elfcpp::R_PPC_REL16
:
1349 case elfcpp::R_PPC_REL16_LO
:
1350 case elfcpp::R_PPC_REL16_HI
:
1351 case elfcpp::R_PPC_REL16_HA
:
1353 if (gsym
->needs_plt_entry())
1354 target
->make_plt_entry(symtab
, layout
, gsym
);
1355 // Make a dynamic relocation if necessary.
1356 int flags
= Symbol::NON_PIC_REF
;
1357 if (gsym
->type() == elfcpp::STT_FUNC
)
1358 flags
|= Symbol::FUNCTION_CALL
;
1359 if (gsym
->needs_dynamic_reloc(flags
))
1361 if (gsym
->may_need_copy_reloc())
1363 target
->copy_reloc(symtab
, layout
, object
,
1364 data_shndx
, output_section
, gsym
,
1369 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
1370 check_non_pic(object
, r_type
);
1371 rela_dyn
->add_global(gsym
, r_type
, output_section
, object
,
1372 data_shndx
, reloc
.get_r_offset(),
1373 reloc
.get_r_addend());
1379 case elfcpp::R_POWERPC_GOT16
:
1380 case elfcpp::R_POWERPC_GOT16_LO
:
1381 case elfcpp::R_POWERPC_GOT16_HI
:
1382 case elfcpp::R_POWERPC_GOT16_HA
:
1383 case elfcpp::R_PPC64_TOC16
:
1384 case elfcpp::R_PPC64_TOC16_LO
:
1385 case elfcpp::R_PPC64_TOC16_HI
:
1386 case elfcpp::R_PPC64_TOC16_HA
:
1387 case elfcpp::R_PPC64_TOC16_DS
:
1388 case elfcpp::R_PPC64_TOC16_LO_DS
:
1390 // The symbol requires a GOT entry.
1391 Output_data_got
<size
, big_endian
>* got
;
1393 got
= target
->got_section(symtab
, layout
);
1394 if (gsym
->final_value_is_known())
1395 got
->add_global(gsym
, GOT_TYPE_STANDARD
);
1398 // If this symbol is not fully resolved, we need to add a
1399 // dynamic relocation for it.
1400 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
1401 if (gsym
->is_from_dynobj()
1402 || gsym
->is_undefined()
1403 || gsym
->is_preemptible())
1404 got
->add_global_with_rela(gsym
, GOT_TYPE_STANDARD
, rela_dyn
,
1405 elfcpp::R_POWERPC_GLOB_DAT
);
1406 else if (!gsym
->has_got_offset(GOT_TYPE_STANDARD
))
1408 unsigned int off
= got
->add_constant(0);
1410 gsym
->set_got_offset(GOT_TYPE_STANDARD
, off
);
1411 rela_dyn
->add_global_relative(gsym
, elfcpp::R_POWERPC_RELATIVE
,
1418 case elfcpp::R_PPC64_TOC
:
1419 // We need a GOT section.
1420 target
->got_section(symtab
, layout
);
1423 case elfcpp::R_POWERPC_GOT_TPREL16
:
1424 case elfcpp::R_POWERPC_TLS
:
1428 // These are relocations which should only be seen by the
1429 // dynamic linker, and should never be seen here.
1430 case elfcpp::R_POWERPC_COPY
:
1431 case elfcpp::R_POWERPC_GLOB_DAT
:
1432 case elfcpp::R_POWERPC_JMP_SLOT
:
1433 case elfcpp::R_POWERPC_RELATIVE
:
1434 case elfcpp::R_POWERPC_DTPMOD
:
1435 gold_error(_("%s: unexpected reloc %u in object file"),
1436 object
->name().c_str(), r_type
);
1440 unsupported_reloc_global(object
, r_type
, gsym
);
1445 // Process relocations for gc.
1447 template<int size
, bool big_endian
>
1449 Target_powerpc
<size
, big_endian
>::gc_process_relocs(
1450 Symbol_table
* symtab
,
1452 Sized_relobj
<size
, big_endian
>* object
,
1453 unsigned int data_shndx
,
1455 const unsigned char* prelocs
,
1457 Output_section
* output_section
,
1458 bool needs_special_offset_handling
,
1459 size_t local_symbol_count
,
1460 const unsigned char* plocal_symbols
)
1462 typedef Target_powerpc
<size
, big_endian
> Powerpc
;
1463 typedef typename Target_powerpc
<size
, big_endian
>::Scan Scan
;
1465 gold::gc_process_relocs
<size
, big_endian
, Powerpc
, elfcpp::SHT_RELA
, Scan
>(
1474 needs_special_offset_handling
,
1479 // Scan relocations for a section.
1481 template<int size
, bool big_endian
>
1483 Target_powerpc
<size
, big_endian
>::scan_relocs(
1484 Symbol_table
* symtab
,
1486 Sized_relobj
<size
, big_endian
>* object
,
1487 unsigned int data_shndx
,
1488 unsigned int sh_type
,
1489 const unsigned char* prelocs
,
1491 Output_section
* output_section
,
1492 bool needs_special_offset_handling
,
1493 size_t local_symbol_count
,
1494 const unsigned char* plocal_symbols
)
1496 typedef Target_powerpc
<size
, big_endian
> Powerpc
;
1497 typedef typename Target_powerpc
<size
, big_endian
>::Scan Scan
;
1498 static Output_data_space
* sdata
;
1500 if (sh_type
== elfcpp::SHT_REL
)
1502 gold_error(_("%s: unsupported REL reloc section"),
1503 object
->name().c_str());
1507 // Define _SDA_BASE_ at the start of the .sdata section.
1510 // layout->find_output_section(".sdata") == NULL
1511 sdata
= new Output_data_space(4, "** sdata");
1512 Output_section
* os
= layout
->add_output_section_data(".sdata", 0,
1514 | elfcpp::SHF_WRITE
,
1516 symtab
->define_in_output_data("_SDA_BASE_", NULL
,
1517 Symbol_table::PREDEFINED
,
1522 elfcpp::STV_HIDDEN
, 0,
1526 gold::scan_relocs
<size
, big_endian
, Powerpc
, elfcpp::SHT_RELA
, Scan
>(
1535 needs_special_offset_handling
,
1540 // Finalize the sections.
1542 template<int size
, bool big_endian
>
1544 Target_powerpc
<size
, big_endian
>::do_finalize_sections(
1546 const Input_objects
*,
1549 // Fill in some more dynamic tags.
1550 Output_data_dynamic
* const odyn
= layout
->dynamic_data();
1553 if (this->plt_
!= NULL
1554 && this->plt_
->output_section() != NULL
)
1556 const Output_data
* od
= this->plt_
->rel_plt();
1557 odyn
->add_section_size(elfcpp::DT_PLTRELSZ
, od
);
1558 odyn
->add_section_address(elfcpp::DT_JMPREL
, od
);
1559 odyn
->add_constant(elfcpp::DT_PLTREL
, elfcpp::DT_RELA
);
1561 odyn
->add_section_address(elfcpp::DT_PLTGOT
, this->plt_
);
1564 if (this->rela_dyn_
!= NULL
1565 && this->rela_dyn_
->output_section() != NULL
)
1567 const Output_data
* od
= this->rela_dyn_
;
1568 odyn
->add_section_address(elfcpp::DT_RELA
, od
);
1569 odyn
->add_section_size(elfcpp::DT_RELASZ
, od
);
1570 odyn
->add_constant(elfcpp::DT_RELAENT
,
1571 elfcpp::Elf_sizes
<size
>::rela_size
);
1574 if (!parameters
->options().shared())
1576 // The value of the DT_DEBUG tag is filled in by the dynamic
1577 // linker at run time, and used by the debugger.
1578 odyn
->add_constant(elfcpp::DT_DEBUG
, 0);
1582 // Emit any relocs we saved in an attempt to avoid generating COPY
1584 if (this->copy_relocs_
.any_saved_relocs())
1585 this->copy_relocs_
.emit(this->rela_dyn_section(layout
));
1588 // Perform a relocation.
1590 template<int size
, bool big_endian
>
1592 Target_powerpc
<size
, big_endian
>::Relocate::relocate(
1593 const Relocate_info
<size
, big_endian
>* relinfo
,
1594 Target_powerpc
* target
,
1597 const elfcpp::Rela
<size
, big_endian
>& rela
,
1598 unsigned int r_type
,
1599 const Sized_symbol
<size
>* gsym
,
1600 const Symbol_value
<size
>* psymval
,
1601 unsigned char* view
,
1602 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
,
1603 section_size_type
/* view_size */)
1605 const unsigned int toc_base_offset
= 0x8000;
1606 typedef Powerpc_relocate_functions
<size
, big_endian
> Reloc
;
1608 // Pick the value to use for symbols defined in shared objects.
1609 Symbol_value
<size
> symval
;
1611 && gsym
->use_plt_offset(r_type
== elfcpp::R_POWERPC_REL24
1612 || r_type
== elfcpp::R_PPC_LOCAL24PC
1613 || r_type
== elfcpp::R_PPC_REL16
1614 || r_type
== elfcpp::R_PPC_REL16_LO
1615 || r_type
== elfcpp::R_PPC_REL16_HI
1616 || r_type
== elfcpp::R_PPC_REL16_HA
))
1618 elfcpp::Elf_Xword value
;
1620 value
= target
->plt_section()->address() + gsym
->plt_offset();
1622 symval
.set_output_value(value
);
1627 const Sized_relobj
<size
, big_endian
>* object
= relinfo
->object
;
1628 elfcpp::Elf_Xword addend
= rela
.get_r_addend();
1630 // Get the GOT offset if needed. Unlike i386 and x86_64, our GOT
1631 // pointer points to the beginning, not the end, of the table.
1632 // So we just use the plain offset.
1633 bool have_got_offset
= false;
1634 unsigned int got_offset
= 0;
1635 unsigned int got2_offset
= 0;
1638 case elfcpp::R_PPC64_TOC16
:
1639 case elfcpp::R_PPC64_TOC16_LO
:
1640 case elfcpp::R_PPC64_TOC16_HI
:
1641 case elfcpp::R_PPC64_TOC16_HA
:
1642 case elfcpp::R_PPC64_TOC16_DS
:
1643 case elfcpp::R_PPC64_TOC16_LO_DS
:
1644 // Subtract the TOC base address.
1645 addend
-= target
->toc_section()->address() + toc_base_offset
;
1648 case elfcpp::R_POWERPC_GOT16
:
1649 case elfcpp::R_POWERPC_GOT16_LO
:
1650 case elfcpp::R_POWERPC_GOT16_HI
:
1651 case elfcpp::R_POWERPC_GOT16_HA
:
1652 case elfcpp::R_PPC64_GOT16_DS
:
1653 case elfcpp::R_PPC64_GOT16_LO_DS
:
1656 gold_assert(gsym
->has_got_offset(GOT_TYPE_STANDARD
));
1657 got_offset
= gsym
->got_offset(GOT_TYPE_STANDARD
);
1661 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(rela
.get_r_info());
1662 gold_assert(object
->local_has_got_offset(r_sym
, GOT_TYPE_STANDARD
));
1663 got_offset
= object
->local_got_offset(r_sym
, GOT_TYPE_STANDARD
);
1665 have_got_offset
= true;
1668 // R_PPC_PLTREL24 is rather special. If non-zero,
1669 // the addend specifies the GOT pointer offset within .got2.
1670 case elfcpp::R_PPC_PLTREL24
:
1671 if (addend
>= 32768)
1673 Output_data_space
* got2
;
1674 got2
= target
->got2_section();
1675 got2_offset
= got2
->offset();
1676 addend
+= got2_offset
;
1678 have_got_offset
= true;
1687 case elfcpp::R_POWERPC_NONE
:
1688 case elfcpp::R_POWERPC_GNU_VTINHERIT
:
1689 case elfcpp::R_POWERPC_GNU_VTENTRY
:
1692 case elfcpp::R_POWERPC_REL32
:
1693 Reloc::rel32(view
, object
, psymval
, addend
, address
);
1696 case elfcpp::R_POWERPC_REL24
:
1697 Reloc::rel24(view
, object
, psymval
, addend
, address
);
1700 case elfcpp::R_POWERPC_REL14
:
1701 Reloc::rel14(view
, object
, psymval
, addend
, address
);
1704 case elfcpp::R_PPC_PLTREL24
:
1705 Reloc::rel24(view
, object
, psymval
, addend
, address
);
1708 case elfcpp::R_PPC_LOCAL24PC
:
1709 Reloc::rel24(view
, object
, psymval
, addend
, address
);
1712 case elfcpp::R_PPC64_ADDR64
:
1713 if (!parameters
->options().output_is_position_independent())
1714 Relocate_functions
<size
, big_endian
>::rela64(view
, object
,
1718 case elfcpp::R_POWERPC_ADDR32
:
1719 if (!parameters
->options().output_is_position_independent())
1720 Relocate_functions
<size
, big_endian
>::rela32(view
, object
,
1724 case elfcpp::R_POWERPC_ADDR16_LO
:
1725 Reloc::addr16_lo(view
, object
, psymval
, addend
);
1728 case elfcpp::R_POWERPC_ADDR16_HI
:
1729 Reloc::addr16_hi(view
, object
, psymval
, addend
);
1732 case elfcpp::R_POWERPC_ADDR16_HA
:
1733 Reloc::addr16_ha(view
, object
, psymval
, addend
);
1736 case elfcpp::R_PPC_REL16_LO
:
1737 Reloc::rel16_lo(view
, object
, psymval
, addend
, address
);
1740 case elfcpp::R_PPC_REL16_HI
:
1741 Reloc::rel16_lo(view
, object
, psymval
, addend
, address
);
1744 case elfcpp::R_PPC_REL16_HA
:
1745 Reloc::rel16_ha(view
, object
, psymval
, addend
, address
);
1748 case elfcpp::R_POWERPC_GOT16
:
1749 Reloc::addr16(view
, got_offset
, addend
);
1752 case elfcpp::R_POWERPC_GOT16_LO
:
1753 Reloc::addr16_lo(view
, got_offset
, addend
);
1756 case elfcpp::R_POWERPC_GOT16_HI
:
1757 Reloc::addr16_hi(view
, got_offset
, addend
);
1760 case elfcpp::R_POWERPC_GOT16_HA
:
1761 Reloc::addr16_ha(view
, got_offset
, addend
);
1764 case elfcpp::R_PPC64_TOC16
:
1765 Reloc::addr16(view
, got_offset
, addend
);
1768 case elfcpp::R_PPC64_TOC16_LO
:
1769 Reloc::addr16_lo(view
, got_offset
, addend
);
1772 case elfcpp::R_PPC64_TOC16_HI
:
1773 Reloc::addr16_hi(view
, got_offset
, addend
);
1776 case elfcpp::R_PPC64_TOC16_HA
:
1777 Reloc::addr16_ha(view
, got_offset
, addend
);
1780 case elfcpp::R_PPC64_TOC16_DS
:
1781 case elfcpp::R_PPC64_TOC16_LO_DS
:
1782 Reloc::addr16_ds(view
, got_offset
, addend
);
1785 case elfcpp::R_PPC64_TOC
:
1787 elfcpp::Elf_types
<64>::Elf_Addr value
;
1788 value
= target
->toc_section()->address() + toc_base_offset
;
1789 Relocate_functions
<64, false>::rela64(view
, value
, addend
);
1793 case elfcpp::R_POWERPC_COPY
:
1794 case elfcpp::R_POWERPC_GLOB_DAT
:
1795 case elfcpp::R_POWERPC_JMP_SLOT
:
1796 case elfcpp::R_POWERPC_RELATIVE
:
1797 // This is an outstanding tls reloc, which is unexpected when
1799 case elfcpp::R_POWERPC_DTPMOD
:
1800 gold_error_at_location(relinfo
, relnum
, rela
.get_r_offset(),
1801 _("unexpected reloc %u in object file"),
1806 gold_error_at_location(relinfo
, relnum
, rela
.get_r_offset(),
1807 _("unsupported reloc %u"),
1815 // Perform a TLS relocation.
1817 template<int size
, bool big_endian
>
1819 Target_powerpc
<size
, big_endian
>::Relocate::relocate_tls(
1820 const Relocate_info
<size
, big_endian
>* relinfo
,
1821 Target_powerpc
<size
, big_endian
>* target
,
1823 const elfcpp::Rela
<size
, big_endian
>& rela
,
1824 unsigned int r_type
,
1825 const Sized_symbol
<size
>* gsym
,
1826 const Symbol_value
<size
>* psymval
,
1827 unsigned char* view
,
1828 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
,
1831 Output_segment
* tls_segment
= relinfo
->layout
->tls_segment();
1832 typedef Powerpc_relocate_functions
<size
, big_endian
> Reloc
;
1833 const Sized_relobj
<size
, big_endian
>* object
= relinfo
->object
;
1835 const elfcpp::Elf_Xword addend
= rela
.get_r_addend();
1836 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
= psymval
->value(object
, 0);
1838 const bool is_final
=
1840 ? !parameters
->options().output_is_position_independent()
1841 : gsym
->final_value_is_known());
1842 const tls::Tls_optimization optimized_type
1843 = optimize_tls_reloc(is_final
, r_type
);
1851 // Relocate section data.
1853 template<int size
, bool big_endian
>
1855 Target_powerpc
<size
, big_endian
>::relocate_section(
1856 const Relocate_info
<size
, big_endian
>* relinfo
,
1857 unsigned int sh_type
,
1858 const unsigned char* prelocs
,
1860 Output_section
* output_section
,
1861 bool needs_special_offset_handling
,
1862 unsigned char* view
,
1863 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
,
1864 section_size_type view_size
,
1865 const Reloc_symbol_changes
* reloc_symbol_changes
)
1867 typedef Target_powerpc
<size
, big_endian
> Powerpc
;
1868 typedef typename Target_powerpc
<size
, big_endian
>::Relocate Powerpc_relocate
;
1870 gold_assert(sh_type
== elfcpp::SHT_RELA
);
1872 gold::relocate_section
<size
, big_endian
, Powerpc
, elfcpp::SHT_RELA
,
1879 needs_special_offset_handling
,
1883 reloc_symbol_changes
);
1886 // Return the size of a relocation while scanning during a relocatable
1889 template<int size
, bool big_endian
>
1891 Target_powerpc
<size
, big_endian
>::Relocatable_size_for_reloc::get_size_for_reloc(
1895 // We are always SHT_RELA, so we should never get here.
1900 // Scan the relocs during a relocatable link.
1902 template<int size
, bool big_endian
>
1904 Target_powerpc
<size
, big_endian
>::scan_relocatable_relocs(
1905 Symbol_table
* symtab
,
1907 Sized_relobj
<size
, big_endian
>* object
,
1908 unsigned int data_shndx
,
1909 unsigned int sh_type
,
1910 const unsigned char* prelocs
,
1912 Output_section
* output_section
,
1913 bool needs_special_offset_handling
,
1914 size_t local_symbol_count
,
1915 const unsigned char* plocal_symbols
,
1916 Relocatable_relocs
* rr
)
1918 gold_assert(sh_type
== elfcpp::SHT_RELA
);
1920 typedef gold::Default_scan_relocatable_relocs
<elfcpp::SHT_RELA
,
1921 Relocatable_size_for_reloc
> Scan_relocatable_relocs
;
1923 gold::scan_relocatable_relocs
<size
, big_endian
, elfcpp::SHT_RELA
,
1924 Scan_relocatable_relocs
>(
1932 needs_special_offset_handling
,
1938 // Relocate a section during a relocatable link.
1940 template<int size
, bool big_endian
>
1942 Target_powerpc
<size
, big_endian
>::relocate_for_relocatable(
1943 const Relocate_info
<size
, big_endian
>* relinfo
,
1944 unsigned int sh_type
,
1945 const unsigned char* prelocs
,
1947 Output_section
* output_section
,
1948 off_t offset_in_output_section
,
1949 const Relocatable_relocs
* rr
,
1950 unsigned char* view
,
1951 typename
elfcpp::Elf_types
<size
>::Elf_Addr view_address
,
1952 section_size_type view_size
,
1953 unsigned char* reloc_view
,
1954 section_size_type reloc_view_size
)
1956 gold_assert(sh_type
== elfcpp::SHT_RELA
);
1958 gold::relocate_for_relocatable
<size
, big_endian
, elfcpp::SHT_RELA
>(
1963 offset_in_output_section
,
1972 // Return the value to use for a dynamic which requires special
1973 // treatment. This is how we support equality comparisons of function
1974 // pointers across shared library boundaries, as described in the
1975 // processor specific ABI supplement.
1977 template<int size
, bool big_endian
>
1979 Target_powerpc
<size
, big_endian
>::do_dynsym_value(const Symbol
* gsym
) const
1981 gold_assert(gsym
->is_from_dynobj() && gsym
->has_plt_offset());
1982 return this->plt_section()->address() + gsym
->plt_offset();
1985 // The selector for powerpc object files.
1987 template<int size
, bool big_endian
>
1988 class Target_selector_powerpc
: public Target_selector
1991 Target_selector_powerpc()
1992 : Target_selector(elfcpp::EM_NONE
, size
, big_endian
,
1994 (big_endian
? "elf64-powerpc" : "elf64-powerpcle") :
1995 (big_endian
? "elf32-powerpc" : "elf32-powerpcle")))
1998 Target
* do_recognize(int machine
, int, int)
2003 if (machine
!= elfcpp::EM_PPC64
)
2008 if (machine
!= elfcpp::EM_PPC
)
2016 return this->instantiate_target();
2019 Target
* do_instantiate_target()
2020 { return new Target_powerpc
<size
, big_endian
>(); }
2023 Target_selector_powerpc
<32, true> target_selector_ppc32
;
2024 Target_selector_powerpc
<32, false> target_selector_ppc32le
;
2025 Target_selector_powerpc
<64, true> target_selector_ppc64
;
2026 Target_selector_powerpc
<64, false> target_selector_ppc64le
;
2028 } // End anonymous namespace.