| blob | 4ece6fbde0195c5e4d9ebb702174bb2e53c421c6 |
1 /* PowerPC64-specific support for 64-bit ELF.
2 Copyright (C) 1999-2019 Free Software Foundation, Inc.
3 Written by Linus Nordberg, Swox AB <info@swox.com>,
4 based on elf32-ppc.c by Ian Lance Taylor.
5 Largely rewritten by Alan Modra.
7 This file is part of BFD, the Binary File Descriptor library.
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 along
20 with this program; if not, write to the Free Software Foundation, Inc.,
21 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
24 /* The 64-bit PowerPC ELF ABI may be found at
25 http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
26 http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html */
29 #include <stdarg.h>
38 static bfd_reloc_status_type ppc64_elf_ha_reloc
40 static bfd_reloc_status_type ppc64_elf_branch_reloc
42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
48 static bfd_reloc_status_type ppc64_elf_toc_reloc
50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
54 static bfd_reloc_status_type ppc64_elf_prefix_reloc
56 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
58 static bfd_vma opd_entry_value
61 #define TARGET_LITTLE_SYM powerpc_elf64_le_vec
63 #define TARGET_BIG_SYM powerpc_elf64_vec
65 #define ELF_ARCH bfd_arch_powerpc
66 #define ELF_TARGET_ID PPC64_ELF_DATA
67 #define ELF_MACHINE_CODE EM_PPC64
68 #define ELF_MAXPAGESIZE 0x10000
69 #define ELF_COMMONPAGESIZE 0x1000
70 #define ELF_RELROPAGESIZE ELF_MAXPAGESIZE
71 #define elf_info_to_howto ppc64_elf_info_to_howto
73 #define elf_backend_want_got_sym 0
74 #define elf_backend_want_plt_sym 0
75 #define elf_backend_plt_alignment 3
76 #define elf_backend_plt_not_loaded 1
77 #define elf_backend_got_header_size 8
78 #define elf_backend_want_dynrelro 1
79 #define elf_backend_can_gc_sections 1
80 #define elf_backend_can_refcount 1
81 #define elf_backend_rela_normal 1
82 #define elf_backend_dtrel_excludes_plt 1
83 #define elf_backend_default_execstack 0
85 #define bfd_elf64_mkobject ppc64_elf_mkobject
86 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
87 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
88 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
89 #define bfd_elf64_bfd_print_private_bfd_data ppc64_elf_print_private_bfd_data
90 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
91 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
92 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
93 #define bfd_elf64_bfd_link_just_syms ppc64_elf_link_just_syms
94 #define bfd_elf64_bfd_gc_sections ppc64_elf_gc_sections
96 #define elf_backend_object_p ppc64_elf_object_p
97 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
98 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
99 #define elf_backend_write_core_note ppc64_elf_write_core_note
100 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
101 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
102 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
103 #define elf_backend_check_directives ppc64_elf_before_check_relocs
104 #define elf_backend_notice_as_needed ppc64_elf_notice_as_needed
105 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
106 #define elf_backend_check_relocs ppc64_elf_check_relocs
107 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
108 #define elf_backend_gc_keep ppc64_elf_gc_keep
109 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
110 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
111 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
112 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
113 #define elf_backend_maybe_function_sym ppc64_elf_maybe_function_sym
114 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
115 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
116 #define elf_backend_hash_symbol ppc64_elf_hash_symbol
117 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
118 #define elf_backend_action_discarded ppc64_elf_action_discarded
119 #define elf_backend_relocate_section ppc64_elf_relocate_section
120 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
121 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
122 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
123 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
124 #define elf_backend_special_sections ppc64_elf_special_sections
125 #define elf_backend_merge_symbol_attribute ppc64_elf_merge_symbol_attribute
126 #define elf_backend_merge_symbol ppc64_elf_merge_symbol
127 #define elf_backend_get_reloc_section bfd_get_section_by_name
129 /* The name of the dynamic interpreter. This is put in the .interp
130 section. */
133 /* The size in bytes of an entry in the procedure linkage table. */
134 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
135 #define LOCAL_PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 16 : 8)
137 /* The initial size of the plt reserved for the dynamic linker. */
138 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
140 /* Offsets to some stack save slots. */
141 #define STK_LR 16
142 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
143 /* This one is dodgy. ELFv2 does not have a linker word, so use the
144 CR save slot. Used only by optimised __tls_get_addr call stub,
145 relying on __tls_get_addr_opt not saving CR.. */
146 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
148 /* TOC base pointers offset from start of TOC. */
149 #define TOC_BASE_OFF 0x8000
150 /* TOC base alignment. */
151 #define TOC_BASE_ALIGN 256
153 /* Offset of tp and dtp pointers from start of TLS block. */
154 #define TP_OFFSET 0x7000
155 #define DTP_OFFSET 0x8000
157 /* .plt call stub instructions. The normal stub is like this, but
158 sometimes the .plt entry crosses a 64k boundary and we need to
159 insert an addi to adjust r11. */
206 #define PADDI_R12_PC 0x0610000039800000ULL
207 #define PLD_R12_PC 0x04100000e5800000ULL
208 #define PNOP 0x0700000000000000ULL
210 /* __glink_PLTresolve stub instructions. We enter with the index in R0. */
211 #define GLINK_PLTRESOLVE_SIZE(htab) \
212 (8u + (htab->opd_abi ? 11 * 4 : 14 * 4))
213 /* 0: */
214 /* .quad plt0-1f */
215 /* __glink: */
218 /* 1: */
220 /* ld %2,(0b-1b)(%11) */
223 /* ld %12,0(%11) */
224 /* ld %2,8(%11) */
225 /* mtctr %12 */
226 /* ld %11,16(%11) */
227 /* bctr */
234 /* Pad with this. */
235 #define NOP 0x60000000
237 /* Some other nops. */
238 #define CROR_151515 0x4def7b82
239 #define CROR_313131 0x4ffffb82
241 /* .glink entries for the first 32k functions are two instructions. */
245 /* After that, we need two instructions to load the index, followed by
246 a branch. */
250 /* Instructions used by the save and restore reg functions. */
263 /* Since .opd is an array of descriptors and each entry will end up
264 with identical R_PPC64_RELATIVE relocs, there is really no need to
265 propagate .opd relocs; The dynamic linker should be taught to
266 relocate .opd without reloc entries. */
267 #ifndef NO_OPD_RELOCS
268 #define NO_OPD_RELOCS 0
269 #endif
271 #ifndef ARRAY_SIZE
272 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
273 #endif
277 {
279 }
283 {
286 }
287 \f
288 /* Relocation HOWTO's. */
289 /* Like other ELF RELA targets that don't apply multiple
290 field-altering relocations to the same localation, src_mask is
291 always zero and pcrel_offset is the same as pc_relative.
292 PowerPC can always use a zero bitpos, even when the field is not at
293 the LSB. For example, a REL24 could use rightshift=2, bisize=24
294 and bitpos=2 which matches the ABI description, or as we do here,
295 rightshift=0, bitsize=26 and bitpos=0. */
296 #define HOW(type, size, bitsize, mask, rightshift, pc_relative, \
297 complain, special_func) \
298 HOWTO (type, rightshift, size, bitsize, pc_relative, 0, \
299 complain_overflow_ ## complain, special_func, \
300 #type, FALSE, 0, mask, pc_relative)
305 {
306 /* This reloc does nothing. */
308 bfd_elf_generic_reloc),
310 /* A standard 32 bit relocation. */
312 bfd_elf_generic_reloc),
314 /* An absolute 26 bit branch; the lower two bits must be zero.
315 FIXME: we don't check that, we just clear them. */
317 bfd_elf_generic_reloc),
319 /* A standard 16 bit relocation. */
321 bfd_elf_generic_reloc),
323 /* A 16 bit relocation without overflow. */
325 bfd_elf_generic_reloc),
327 /* Bits 16-31 of an address. */
329 bfd_elf_generic_reloc),
331 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
332 bits, treated as a signed number, is negative. */
334 ppc64_elf_ha_reloc),
336 /* An absolute 16 bit branch; the lower two bits must be zero.
337 FIXME: we don't check that, we just clear them. */
339 ppc64_elf_branch_reloc),
341 /* An absolute 16 bit branch, for which bit 10 should be set to
342 indicate that the branch is expected to be taken. The lower two
343 bits must be zero. */
345 ppc64_elf_brtaken_reloc),
347 /* An absolute 16 bit branch, for which bit 10 should be set to
348 indicate that the branch is not expected to be taken. The lower
349 two bits must be zero. */
351 ppc64_elf_brtaken_reloc),
353 /* A relative 26 bit branch; the lower two bits must be zero. */
355 ppc64_elf_branch_reloc),
357 /* A variant of R_PPC64_REL24, used when r2 is not the toc pointer. */
359 ppc64_elf_branch_reloc),
361 /* A relative 16 bit branch; the lower two bits must be zero. */
363 ppc64_elf_branch_reloc),
365 /* A relative 16 bit branch. Bit 10 should be set to indicate that
366 the branch is expected to be taken. The lower two bits must be
367 zero. */
369 ppc64_elf_brtaken_reloc),
371 /* A relative 16 bit branch. Bit 10 should be set to indicate that
372 the branch is not expected to be taken. The lower two bits must
373 be zero. */
375 ppc64_elf_brtaken_reloc),
377 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
378 symbol. */
380 ppc64_elf_unhandled_reloc),
382 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
383 the symbol. */
385 ppc64_elf_unhandled_reloc),
387 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
388 the symbol. */
390 ppc64_elf_unhandled_reloc),
392 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
393 the symbol. */
395 ppc64_elf_unhandled_reloc),
397 /* This is used only by the dynamic linker. The symbol should exist
398 both in the object being run and in some shared library. The
399 dynamic linker copies the data addressed by the symbol from the
400 shared library into the object, because the object being
401 run has to have the data at some particular address. */
403 ppc64_elf_unhandled_reloc),
405 /* Like R_PPC64_ADDR64, but used when setting global offset table
406 entries. */
408 ppc64_elf_unhandled_reloc),
410 /* Created by the link editor. Marks a procedure linkage table
411 entry for a symbol. */
413 ppc64_elf_unhandled_reloc),
415 /* Used only by the dynamic linker. When the object is run, this
416 doubleword64 is set to the load address of the object, plus the
417 addend. */
419 bfd_elf_generic_reloc),
421 /* Like R_PPC64_ADDR32, but may be unaligned. */
423 bfd_elf_generic_reloc),
425 /* Like R_PPC64_ADDR16, but may be unaligned. */
427 bfd_elf_generic_reloc),
429 /* 32-bit PC relative. */
431 bfd_elf_generic_reloc),
433 /* 32-bit relocation to the symbol's procedure linkage table. */
435 ppc64_elf_unhandled_reloc),
437 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
438 FIXME: R_PPC64_PLTREL32 not supported. */
440 ppc64_elf_unhandled_reloc),
442 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
443 the symbol. */
445 ppc64_elf_unhandled_reloc),
447 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
448 the symbol. */
450 ppc64_elf_unhandled_reloc),
452 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
453 the symbol. */
455 ppc64_elf_unhandled_reloc),
457 /* 16-bit section relative relocation. */
459 ppc64_elf_sectoff_reloc),
461 /* Like R_PPC64_SECTOFF, but no overflow warning. */
463 ppc64_elf_sectoff_reloc),
465 /* 16-bit upper half section relative relocation. */
467 ppc64_elf_sectoff_reloc),
469 /* 16-bit upper half adjusted section relative relocation. */
471 ppc64_elf_sectoff_ha_reloc),
473 /* Like R_PPC64_REL24 without touching the two least significant bits. */
475 bfd_elf_generic_reloc),
477 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
479 /* A standard 64-bit relocation. */
481 bfd_elf_generic_reloc),
483 /* The bits 32-47 of an address. */
485 bfd_elf_generic_reloc),
487 /* The bits 32-47 of an address, plus 1 if the contents of the low
488 16 bits, treated as a signed number, is negative. */
490 ppc64_elf_ha_reloc),
492 /* The bits 48-63 of an address. */
494 bfd_elf_generic_reloc),
496 /* The bits 48-63 of an address, plus 1 if the contents of the low
497 16 bits, treated as a signed number, is negative. */
499 ppc64_elf_ha_reloc),
501 /* Like ADDR64, but may be unaligned. */
503 bfd_elf_generic_reloc),
505 /* 64-bit relative relocation. */
507 bfd_elf_generic_reloc),
509 /* 64-bit relocation to the symbol's procedure linkage table. */
511 ppc64_elf_unhandled_reloc),
513 /* 64-bit PC relative relocation to the symbol's procedure linkage
514 table. */
515 /* FIXME: R_PPC64_PLTREL64 not supported. */
517 ppc64_elf_unhandled_reloc),
519 /* 16 bit TOC-relative relocation. */
520 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
522 ppc64_elf_toc_reloc),
524 /* 16 bit TOC-relative relocation without overflow. */
525 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
527 ppc64_elf_toc_reloc),
529 /* 16 bit TOC-relative relocation, high 16 bits. */
530 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
532 ppc64_elf_toc_reloc),
534 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
535 contents of the low 16 bits, treated as a signed number, is
536 negative. */
537 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
539 ppc64_elf_toc_ha_reloc),
541 /* 64-bit relocation; insert value of TOC base (.TOC.). */
542 /* R_PPC64_TOC 51 doubleword64 .TOC. */
544 ppc64_elf_toc64_reloc),
546 /* Like R_PPC64_GOT16, but also informs the link editor that the
547 value to relocate may (!) refer to a PLT entry which the link
548 editor (a) may replace with the symbol value. If the link editor
549 is unable to fully resolve the symbol, it may (b) create a PLT
550 entry and store the address to the new PLT entry in the GOT.
551 This permits lazy resolution of function symbols at run time.
552 The link editor may also skip all of this and just (c) emit a
553 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
554 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
556 ppc64_elf_unhandled_reloc),
558 /* Like R_PPC64_PLTGOT16, but without overflow. */
559 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
561 ppc64_elf_unhandled_reloc),
563 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
564 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
566 ppc64_elf_unhandled_reloc),
568 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
569 1 if the contents of the low 16 bits, treated as a signed number,
570 is negative. */
571 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
573 ppc64_elf_unhandled_reloc),
575 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
577 bfd_elf_generic_reloc),
579 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
581 bfd_elf_generic_reloc),
583 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
585 ppc64_elf_unhandled_reloc),
587 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
589 ppc64_elf_unhandled_reloc),
591 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
593 ppc64_elf_unhandled_reloc),
595 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
597 ppc64_elf_sectoff_reloc),
599 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
601 ppc64_elf_sectoff_reloc),
603 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
605 ppc64_elf_toc_reloc),
607 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
609 ppc64_elf_toc_reloc),
611 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
612 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
614 ppc64_elf_unhandled_reloc),
616 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
617 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
619 ppc64_elf_unhandled_reloc),
621 /* Marker relocs for TLS. */
623 bfd_elf_generic_reloc),
626 bfd_elf_generic_reloc),
629 bfd_elf_generic_reloc),
631 /* Marker reloc for optimizing r2 save in prologue rather than on
632 each plt call stub. */
634 bfd_elf_generic_reloc),
636 /* Marker relocs on inline plt call instructions. */
638 bfd_elf_generic_reloc),
641 bfd_elf_generic_reloc),
643 /* Computes the load module index of the load module that contains the
644 definition of its TLS sym. */
646 ppc64_elf_unhandled_reloc),
648 /* Computes a dtv-relative displacement, the difference between the value
649 of sym+add and the base address of the thread-local storage block that
650 contains the definition of sym, minus 0x8000. */
652 ppc64_elf_unhandled_reloc),
654 /* A 16 bit dtprel reloc. */
656 ppc64_elf_unhandled_reloc),
658 /* Like DTPREL16, but no overflow. */
660 ppc64_elf_unhandled_reloc),
662 /* Like DTPREL16_LO, but next higher group of 16 bits. */
664 ppc64_elf_unhandled_reloc),
666 /* Like DTPREL16_HI, but adjust for low 16 bits. */
668 ppc64_elf_unhandled_reloc),
670 /* Like DTPREL16_HI, but next higher group of 16 bits. */
672 ppc64_elf_unhandled_reloc),
674 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
676 ppc64_elf_unhandled_reloc),
678 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
680 ppc64_elf_unhandled_reloc),
682 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
684 ppc64_elf_unhandled_reloc),
686 /* Like DTPREL16, but for insns with a DS field. */
688 ppc64_elf_unhandled_reloc),
690 /* Like DTPREL16_DS, but no overflow. */
692 ppc64_elf_unhandled_reloc),
694 /* Computes a tp-relative displacement, the difference between the value of
695 sym+add and the value of the thread pointer (r13). */
697 ppc64_elf_unhandled_reloc),
699 /* A 16 bit tprel reloc. */
701 ppc64_elf_unhandled_reloc),
703 /* Like TPREL16, but no overflow. */
705 ppc64_elf_unhandled_reloc),
707 /* Like TPREL16_LO, but next higher group of 16 bits. */
709 ppc64_elf_unhandled_reloc),
711 /* Like TPREL16_HI, but adjust for low 16 bits. */
713 ppc64_elf_unhandled_reloc),
715 /* Like TPREL16_HI, but next higher group of 16 bits. */
717 ppc64_elf_unhandled_reloc),
719 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
721 ppc64_elf_unhandled_reloc),
723 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
725 ppc64_elf_unhandled_reloc),
727 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
729 ppc64_elf_unhandled_reloc),
731 /* Like TPREL16, but for insns with a DS field. */
733 ppc64_elf_unhandled_reloc),
735 /* Like TPREL16_DS, but no overflow. */
737 ppc64_elf_unhandled_reloc),
739 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
740 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
741 to the first entry relative to the TOC base (r2). */
743 ppc64_elf_unhandled_reloc),
745 /* Like GOT_TLSGD16, but no overflow. */
747 ppc64_elf_unhandled_reloc),
749 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
751 ppc64_elf_unhandled_reloc),
753 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
755 ppc64_elf_unhandled_reloc),
757 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
758 with values (sym+add)@dtpmod and zero, and computes the offset to the
759 first entry relative to the TOC base (r2). */
761 ppc64_elf_unhandled_reloc),
763 /* Like GOT_TLSLD16, but no overflow. */
765 ppc64_elf_unhandled_reloc),
767 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
769 ppc64_elf_unhandled_reloc),
771 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
773 ppc64_elf_unhandled_reloc),
775 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
776 the offset to the entry relative to the TOC base (r2). */
778 ppc64_elf_unhandled_reloc),
780 /* Like GOT_DTPREL16_DS, but no overflow. */
782 ppc64_elf_unhandled_reloc),
784 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
786 ppc64_elf_unhandled_reloc),
788 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
790 ppc64_elf_unhandled_reloc),
792 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
793 offset to the entry relative to the TOC base (r2). */
795 ppc64_elf_unhandled_reloc),
797 /* Like GOT_TPREL16_DS, but no overflow. */
799 ppc64_elf_unhandled_reloc),
801 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
803 ppc64_elf_unhandled_reloc),
805 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
807 ppc64_elf_unhandled_reloc),
810 ppc64_elf_unhandled_reloc),
813 bfd_elf_generic_reloc),
815 /* A 16 bit relative relocation. */
817 bfd_elf_generic_reloc),
819 /* A 16 bit relative relocation without overflow. */
821 bfd_elf_generic_reloc),
823 /* The high order 16 bits of a relative address. */
825 bfd_elf_generic_reloc),
827 /* The high order 16 bits of a relative address, plus 1 if the contents of
828 the low 16 bits, treated as a signed number, is negative. */
830 ppc64_elf_ha_reloc),
833 bfd_elf_generic_reloc),
836 ppc64_elf_ha_reloc),
839 bfd_elf_generic_reloc),
842 ppc64_elf_ha_reloc),
845 bfd_elf_generic_reloc),
848 ppc64_elf_ha_reloc),
850 /* Like R_PPC64_REL16_HA but for split field in addpcis. */
852 ppc64_elf_ha_reloc),
854 /* A split-field reloc for addpcis, non-relative (gas internal use only). */
856 ppc64_elf_ha_reloc),
858 /* Like R_PPC64_ADDR16_HI, but no overflow. */
860 bfd_elf_generic_reloc),
862 /* Like R_PPC64_ADDR16_HA, but no overflow. */
864 ppc64_elf_ha_reloc),
866 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
868 ppc64_elf_unhandled_reloc),
870 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
872 ppc64_elf_unhandled_reloc),
874 /* Like R_PPC64_TPREL16_HI, but no overflow. */
876 ppc64_elf_unhandled_reloc),
878 /* Like R_PPC64_TPREL16_HA, but no overflow. */
880 ppc64_elf_unhandled_reloc),
882 /* Marker reloc on ELFv2 large-model function entry. */
884 bfd_elf_generic_reloc),
886 /* Like ADDR64, but use local entry point of function. */
888 bfd_elf_generic_reloc),
891 bfd_elf_generic_reloc),
894 bfd_elf_generic_reloc),
897 bfd_elf_generic_reloc),
900 ppc64_elf_prefix_reloc),
903 ppc64_elf_prefix_reloc),
906 ppc64_elf_prefix_reloc),
909 ppc64_elf_prefix_reloc),
912 ppc64_elf_prefix_reloc),
915 ppc64_elf_unhandled_reloc),
918 ppc64_elf_unhandled_reloc),
921 ppc64_elf_unhandled_reloc),
924 ppc64_elf_unhandled_reloc),
927 ppc64_elf_unhandled_reloc),
930 ppc64_elf_unhandled_reloc),
933 ppc64_elf_unhandled_reloc),
936 ppc64_elf_unhandled_reloc),
939 ppc64_elf_unhandled_reloc),
942 bfd_elf_generic_reloc),
945 ppc64_elf_ha_reloc),
948 bfd_elf_generic_reloc),
951 ppc64_elf_ha_reloc),
954 bfd_elf_generic_reloc),
957 ppc64_elf_ha_reloc),
960 bfd_elf_generic_reloc),
963 ppc64_elf_ha_reloc),
966 ppc64_elf_prefix_reloc),
969 ppc64_elf_prefix_reloc),
971 /* GNU extension to record C++ vtable hierarchy. */
973 NULL),
975 /* GNU extension to record C++ vtable member usage. */
977 NULL),
978 };
980 \f
981 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
982 be done. */
984 static void
986 {
990 {
994 }
995 }
999 bfd_reloc_code_real_type code)
1000 {
1004 /* Initialize howto table if needed. */
1008 {
1010 /* xgettext:c-format */
1311 }
1314 };
1319 {
1328 }
1330 /* Set the howto pointer for a PowerPC ELF reloc. */
1332 static bfd_boolean
1335 {
1338 /* Initialize howto table if needed. */
1344 {
1345 /* xgettext:c-format */
1350 }
1353 {
1354 /* xgettext:c-format */
1359 }
1362 }
1364 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
1366 static bfd_reloc_status_type
1370 {
1373 bfd_size_type octets;
1374 bfd_vma value;
1376 /* If this is a relocatable link (output_bfd test tells us), just
1377 call the generic function. Any adjustment will be done at final
1378 link time. */
1383 /* Adjust the addend for sign extension of the low 16 (or 34) bits.
1384 We won't actually be using the low bits, so trashing them
1385 doesn't matter. */
1392 else
1416 }
1418 static bfd_reloc_status_type
1422 {
1429 {
1437 }
1438 else
1439 {
1445 {
1449 {
1453 {
1456 }
1457 }
1458 }
1459 reloc_entry->addend
1461 }
1463 }
1465 static bfd_reloc_status_type
1469 {
1472 bfd_size_type octets;
1473 /* Assume 'at' branch hints. */
1476 /* If this is a relocatable link (output_bfd test tells us), just
1477 call the generic function. Any adjustment will be done at final
1478 link time. */
1492 {
1493 /* Set 'a' bit. This is 0b00010 in BO field for branch
1494 on CR(BI) insns (BO == 001at or 011at), and 0b01000
1495 for branch on CTR insns (BO == 1a00t or 1a01t). */
1500 else
1502 }
1503 else
1504 {
1506 bfd_vma from;
1518 /* Invert 'y' bit if not the default. */
1521 }
1523 out:
1526 }
1528 static bfd_reloc_status_type
1532 {
1533 /* If this is a relocatable link (output_bfd test tells us), just
1534 call the generic function. Any adjustment will be done at final
1535 link time. */
1540 /* Subtract the symbol section base address. */
1543 }
1545 static bfd_reloc_status_type
1549 {
1550 /* If this is a relocatable link (output_bfd test tells us), just
1551 call the generic function. Any adjustment will be done at final
1552 link time. */
1557 /* Subtract the symbol section base address. */
1560 /* Adjust the addend for sign extension of the low 16 bits. */
1563 }
1565 static bfd_reloc_status_type
1569 {
1570 bfd_vma TOCstart;
1572 /* If this is a relocatable link (output_bfd test tells us), just
1573 call the generic function. Any adjustment will be done at final
1574 link time. */
1583 /* Subtract the TOC base address. */
1586 }
1588 static bfd_reloc_status_type
1592 {
1593 bfd_vma TOCstart;
1595 /* If this is a relocatable link (output_bfd test tells us), just
1596 call the generic function. Any adjustment will be done at final
1597 link time. */
1606 /* Subtract the TOC base address. */
1609 /* Adjust the addend for sign extension of the low 16 bits. */
1612 }
1614 static bfd_reloc_status_type
1618 {
1619 bfd_vma TOCstart;
1620 bfd_size_type octets;
1622 /* If this is a relocatable link (output_bfd test tells us), just
1623 call the generic function. Any adjustment will be done at final
1624 link time. */
1636 }
1638 static bfd_reloc_status_type
1642 {
1644 bfd_vma targ;
1662 {
1667 }
1678 }
1680 static bfd_reloc_status_type
1684 {
1685 /* If this is a relocatable link (output_bfd test tells us), just
1686 call the generic function. Any adjustment will be done at final
1687 link time. */
1693 {
1698 }
1700 }
1702 /* Track GOT entries needed for a given symbol. We might need more
1703 than one got entry per symbol. */
1704 struct got_entry
1705 {
1708 /* The symbol addend that we'll be placing in the GOT. */
1709 bfd_vma addend;
1711 /* Unlike other ELF targets, we use separate GOT entries for the same
1712 symbol referenced from different input files. This is to support
1713 automatic multiple TOC/GOT sections, where the TOC base can vary
1714 from one input file to another. After partitioning into TOC groups
1715 we merge entries within the group.
1717 Point to the BFD owning this GOT entry. */
1720 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
1721 TLS_TPREL or TLS_DTPREL for tls entries. */
1724 /* Non-zero if got.ent points to real entry. */
1727 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
1728 union
1729 {
1730 bfd_signed_vma refcount;
1731 bfd_vma offset;
1734 };
1736 /* The same for PLT. */
1737 struct plt_entry
1738 {
1741 bfd_vma addend;
1743 union
1744 {
1745 bfd_signed_vma refcount;
1746 bfd_vma offset;
1748 };
1750 struct ppc64_elf_obj_tdata
1751 {
1754 /* Shortcuts to dynamic linker sections. */
1758 /* Used during garbage collection. We attach global symbols defined
1759 on removed .opd entries to this section so that the sym is removed. */
1762 /* TLS local dynamic got entry handling. Support for multiple GOT
1763 sections means we potentially need one of these for each input bfd. */
1766 union
1767 {
1768 /* A copy of relocs before they are modified for --emit-relocs. */
1771 /* Section contents. */
1775 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
1776 the reloc to be in the range -32768 to 32767. */
1779 /* Set if toc/got ha relocs detected not using r2, or lo reloc
1780 instruction not one we handle. */
1783 /* Set if PLT/GOT/TOC relocs that can be optimised are present in
1784 this file. */
1786 };
1788 #define ppc64_elf_tdata(bfd) \
1789 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
1791 #define ppc64_tlsld_got(bfd) \
1792 (&ppc64_elf_tdata (bfd)->tlsld_got)
1794 #define is_ppc64_elf(bfd) \
1795 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
1796 && elf_object_id (bfd) == PPC64_ELF_DATA)
1798 /* Override the generic function because we store some extras. */
1800 static bfd_boolean
1802 {
1804 PPC64_ELF_DATA);
1805 }
1807 /* Fix bad default arch selected for a 64 bit input bfd when the
1808 default is 32 bit. Also select arch based on apuinfo. */
1810 static bfd_boolean
1812 {
1817 {
1821 {
1822 /* Relies on arch after 32 bit default being 64 bit default. */
1825 }
1826 }
1828 }
1830 /* Support for core dump NOTE sections. */
1832 static bfd_boolean
1834 {
1840 /* pr_cursig */
1843 /* pr_pid */
1846 /* pr_reg */
1850 /* Make a ".reg/999" section. */
1853 }
1855 static bfd_boolean
1857 {
1869 }
1873 ...)
1874 {
1876 {
1881 {
1888 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
1889 DIAGNOSTIC_PUSH;
1890 /* GCC 8.0 and 8.1 warn about 80 equals destination size with
1891 -Wstringop-truncation:
1892 https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85643
1893 */
1894 DIAGNOSTIC_IGNORE_STRINGOP_TRUNCATION;
1895 #endif
1897 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
1898 DIAGNOSTIC_POP;
1899 #endif
1903 }
1906 {
1925 }
1926 }
1927 }
1929 /* Add extra PPC sections. */
1932 {
1940 };
1946 };
1948 struct _ppc64_elf_section_data
1949 {
1952 union
1953 {
1954 /* An array with one entry for each opd function descriptor,
1955 and some spares since opd entries may be either 16 or 24 bytes. */
1956 #define OPD_NDX(OFF) ((OFF) >> 4)
1957 struct _opd_sec_data
1958 {
1959 /* Points to the function code section for local opd entries. */
1962 /* After editing .opd, adjust references to opd local syms. */
1966 /* An array for toc sections, indexed by offset/8. */
1967 struct _toc_sec_data
1968 {
1969 /* Specifies the relocation symbol index used at a given toc offset. */
1972 /* And the relocation addend. */
1979 /* Flag set when small branches are detected. Used to
1980 select suitable defaults for the stub group size. */
1983 /* Flag set when PLTCALL relocs are detected. */
1986 /* Flag set when section has PLT/GOT/TOC relocations that can be
1987 optimised. */
1989 };
1991 #define ppc64_elf_section_data(sec) \
1992 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
1994 static bfd_boolean
1996 {
1998 {
2006 }
2009 }
2013 {
2019 }
2020 \f
2021 /* Parameters for the qsort hook. */
2025 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
2027 static int
2029 {
2033 /* Section symbols first. */
2039 /* then .opd symbols. */
2041 {
2048 }
2050 /* then other code symbols. */
2064 {
2070 }
2078 /* For syms with the same value, prefer strong dynamic global function
2079 syms over other syms. */
2104 /* Finally, sort on where the symbol is in memory. The symbols will
2105 be in at most two malloc'd blocks, one for static syms, one for
2106 dynamic syms, and we distinguish the two blocks above by testing
2107 BSF_DYNAMIC. Since we are sorting the symbol pointers which were
2108 originally in the same order as the symbols (and we're not
2109 sorting the symbols themselves), this ensures a stable sort. */
2115 }
2117 /* Search SYMS for a symbol of the given VALUE. */
2121 {
2125 {
2127 {
2133 else
2135 }
2136 }
2137 else
2138 {
2140 {
2150 else
2152 }
2153 }
2155 }
2157 static bfd_boolean
2159 {
2164 }
2166 /* Create synthetic symbols, effectively restoring "dot-symbol" function
2167 entry syms. Also generate @plt symbols for the glink branch table.
2168 Returns count of synthetic symbols in RET or -1 on error. */
2170 static long
2175 {
2188 {
2192 }
2201 {
2213 {
2214 /* Use both symbol tables. */
2218 }
2221 else
2224 /* Trim uninteresting symbols. Interesting symbols are section,
2225 function, and notype symbols. */
2237 {
2238 /* Trim duplicate syms, since we may have merged the normal
2239 and dynamic symbols. Actually, we only care about syms
2240 that have different values, so trim any with the same
2241 value. Don't consider ifunc and ifunc resolver symbols
2242 duplicates however, because GDB wants to know whether a
2243 text symbol is an ifunc resolver. */
2245 {
2254 }
2256 }
2259 /* Note that here and in compare_symbols we can't compare opd and
2260 sym->section directly. With separate debug info files, the
2261 symbols will be extracted from the debug file while abfd passed
2262 to this function is the real binary. */
2291 }
2295 {
2310 {
2313 }
2317 {
2336 {
2340 }
2341 }
2347 {
2350 }
2355 {
2374 {
2386 /* Have udata.p point back to the original symbol this
2387 synthetic symbol was derived from. */
2389 s++;
2390 }
2391 }
2392 }
2393 else
2394 {
2404 {
2405 free_contents_and_exit_err:
2407 free_contents_and_exit:
2411 }
2415 {
2416 bfd_vma ent;
2418 /* Ignore bogus symbols. */
2424 {
2428 }
2429 }
2431 /* Get start of .glink stubs from DT_PPC64_GLINK. */
2434 {
2448 {
2449 Elf_Internal_Dyn dyn;
2456 {
2457 /* The first glink stub starts at DT_PPC64_GLINK plus 32.
2458 See comment in ppc64_elf_finish_dynamic_sections. */
2460 /* The .glink section usually does not survive the final
2461 link; search for the section (usually .text) where the
2462 glink stubs now reside. */
2466 }
2467 }
2470 }
2473 {
2474 /* Determine __glink trampoline by reading the relative branch
2475 from the first glink stub. */
2481 {
2485 {
2486 resolv_vma
2489 }
2493 }
2500 {
2510 {
2514 }
2515 }
2516 }
2527 {
2528 bfd_vma ent;
2535 {
2544 {
2550 else
2551 {
2554 }
2555 }
2561 {
2564 /* SEC_LOAD may not be set if SEC is from a separate debug
2565 info file. */
2570 }
2578 /* Have udata.p point back to the original symbol this
2579 synthetic symbol was derived from. */
2581 s++;
2582 }
2583 }
2587 {
2589 {
2590 /* Add a symbol for the main glink trampoline. */
2600 s++;
2601 count++;
2602 }
2604 /* FIXME: It would be very much nicer to put sym@plt on the
2605 stub rather than on the glink branch table entry. The
2606 objdump disassembler would then use a sensible symbol
2607 name on plt calls. The difficulty in doing so is
2608 a) finding the stubs, and,
2609 b) matching stubs against plt entries, and,
2610 c) there can be multiple stubs for a given plt entry.
2612 Solving (a) could be done by code scanning, but older
2613 ppc64 binaries used different stubs to current code.
2614 (b) is the tricky one since you need to known the toc
2615 pointer for at least one function that uses a pic stub to
2616 be able to calculate the plt address referenced.
2617 (c) means gdb would need to set multiple breakpoints (or
2618 find the glink branch itself) when setting breakpoints
2619 for pending shared library loads. */
2622 {
2626 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
2627 we are defining a symbol, ensure one of them is set. */
2639 {
2644 }
2647 s++;
2649 {
2653 }
2654 else
2656 }
2658 }
2659 }
2661 done:
2664 }
2665 \f
2666 /* The following functions are specific to the ELF linker, while
2667 functions above are used generally. Those named ppc64_elf_* are
2668 called by the main ELF linker code. They appear in this file more
2669 or less in the order in which they are called. eg.
2670 ppc64_elf_check_relocs is called early in the link process,
2671 ppc64_elf_finish_dynamic_sections is one of the last functions
2672 called.
2674 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
2675 functions have both a function code symbol and a function descriptor
2676 symbol. A call to foo in a relocatable object file looks like:
2678 . .text
2679 . x:
2680 . bl .foo
2681 . nop
2683 The function definition in another object file might be:
2685 . .section .opd
2686 . foo: .quad .foo
2687 . .quad .TOC.@tocbase
2688 . .quad 0
2689 .
2690 . .text
2691 . .foo: blr
2693 When the linker resolves the call during a static link, the branch
2694 unsurprisingly just goes to .foo and the .opd information is unused.
2695 If the function definition is in a shared library, things are a little
2696 different: The call goes via a plt call stub, the opd information gets
2697 copied to the plt, and the linker patches the nop.
2699 . x:
2700 . bl .foo_stub
2701 . ld 2,40(1)
2702 .
2703 .
2704 . .foo_stub:
2705 . std 2,40(1) # in practice, the call stub
2706 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
2707 . addi 11,11,Lfoo@toc@l # this is the general idea
2708 . ld 12,0(11)
2709 . ld 2,8(11)
2710 . mtctr 12
2711 . ld 11,16(11)
2712 . bctr
2713 .
2714 . .section .plt
2715 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
2717 The "reloc ()" notation is supposed to indicate that the linker emits
2718 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
2719 copying.
2721 What are the difficulties here? Well, firstly, the relocations
2722 examined by the linker in check_relocs are against the function code
2723 sym .foo, while the dynamic relocation in the plt is emitted against
2724 the function descriptor symbol, foo. Somewhere along the line, we need
2725 to carefully copy dynamic link information from one symbol to the other.
2726 Secondly, the generic part of the elf linker will make .foo a dynamic
2727 symbol as is normal for most other backends. We need foo dynamic
2728 instead, at least for an application final link. However, when
2729 creating a shared library containing foo, we need to have both symbols
2730 dynamic so that references to .foo are satisfied during the early
2731 stages of linking. Otherwise the linker might decide to pull in a
2732 definition from some other object, eg. a static library.
2734 Update: As of August 2004, we support a new convention. Function
2735 calls may use the function descriptor symbol, ie. "bl foo". This
2736 behaves exactly as "bl .foo". */
2738 /* Of those relocs that might be copied as dynamic relocs, this
2739 function selects those that must be copied when linking a shared
2740 library or PIE, even when the symbol is local. */
2742 static int
2745 {
2747 {
2749 /* Only relative relocs can be resolved when the object load
2750 address isn't fixed. DTPREL64 is excluded because the
2751 dynamic linker needs to differentiate global dynamic from
2752 local dynamic __tls_index pairs when PPC64_OPT_TLS is set. */
2780 /* These relocations are relative but in a shared library the
2781 linker doesn't know the thread pointer base. */
2783 }
2784 }
2786 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
2787 copying dynamic variables from a shared lib into an app's dynbss
2788 section, and instead use a dynamic relocation to point into the
2789 shared lib. With code that gcc generates, it's vital that this be
2790 enabled; In the PowerPC64 ABI, the address of a function is actually
2791 the address of a function descriptor, which resides in the .opd
2792 section. gcc uses the descriptor directly rather than going via the
2793 GOT as some other ABI's do, which means that initialized function
2794 pointers must reference the descriptor. Thus, a function pointer
2795 initialized to the address of a function in a shared library will
2796 either require a copy reloc, or a dynamic reloc. Using a copy reloc
2797 redefines the function descriptor symbol to point to the copy. This
2798 presents a problem as a plt entry for that function is also
2799 initialized from the function descriptor symbol and the copy reloc
2800 may not be initialized first. */
2801 #define ELIMINATE_COPY_RELOCS 1
2803 /* Section name for stubs is the associated section name plus this
2804 string. */
2807 /* Linker stubs.
2808 ppc_stub_long_branch:
2809 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
2810 destination, but a 24 bit branch in a stub section will reach.
2811 . b dest
2813 ppc_stub_plt_branch:
2814 Similar to the above, but a 24 bit branch in the stub section won't
2815 reach its destination.
2816 . addis %r11,%r2,xxx@toc@ha
2817 . ld %r12,xxx@toc@l(%r11)
2818 . mtctr %r12
2819 . bctr
2821 ppc_stub_plt_call:
2822 Used to call a function in a shared library. If it so happens that
2823 the plt entry referenced crosses a 64k boundary, then an extra
2824 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
2825 ppc_stub_plt_call_r2save starts with "std %r2,40(%r1)".
2826 . addis %r11,%r2,xxx@toc@ha
2827 . ld %r12,xxx+0@toc@l(%r11)
2828 . mtctr %r12
2829 . ld %r2,xxx+8@toc@l(%r11)
2830 . ld %r11,xxx+16@toc@l(%r11)
2831 . bctr
2833 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
2834 code to adjust the value and save r2 to support multiple toc sections.
2835 A ppc_stub_long_branch with an r2 offset looks like:
2836 . std %r2,40(%r1)
2837 . addis %r2,%r2,off@ha
2838 . addi %r2,%r2,off@l
2839 . b dest
2841 A ppc_stub_plt_branch with an r2 offset looks like:
2842 . std %r2,40(%r1)
2843 . addis %r11,%r2,xxx@toc@ha
2844 . ld %r12,xxx@toc@l(%r11)
2845 . addis %r2,%r2,off@ha
2846 . addi %r2,%r2,off@l
2847 . mtctr %r12
2848 . bctr
2850 All of the above stubs are shown as their ELFv1 variants. ELFv2
2851 variants exist too, simpler for plt calls since a new toc pointer
2852 and static chain are not loaded by the stub. In addition, ELFv2
2853 has some more complex stubs to handle calls marked with NOTOC
2854 relocs from functions where r2 is not a valid toc pointer. These
2855 come in two flavours, the ones shown below, and _both variants that
2856 start with "std %r2,24(%r1)" to save r2 in the unlikely event that
2857 one call is from a function where r2 is used as the toc pointer but
2858 needs a toc adjusting stub for small-model multi-toc, and another
2859 call is from a function where r2 is not valid.
2860 ppc_stub_long_branch_notoc:
2861 . mflr %r12
2862 . bcl 20,31,1f
2863 . 1:
2864 . mflr %r11
2865 . mtlr %r12
2866 . addis %r12,%r11,dest-1b@ha
2867 . addi %r12,%r12,dest-1b@l
2868 . b dest
2870 ppc_stub_plt_branch_notoc:
2871 . mflr %r12
2872 . bcl 20,31,1f
2873 . 1:
2874 . mflr %r11
2875 . mtlr %r12
2876 . lis %r12,xxx-1b@highest
2877 . ori %r12,%r12,xxx-1b@higher
2878 . sldi %r12,%r12,32
2879 . oris %r12,%r12,xxx-1b@high
2880 . ori %r12,%r12,xxx-1b@l
2881 . add %r12,%r11,%r12
2882 . mtctr %r12
2883 . bctr
2885 ppc_stub_plt_call_notoc:
2886 . mflr %r12
2887 . bcl 20,31,1f
2888 . 1:
2889 . mflr %r11
2890 . mtlr %r12
2891 . lis %r12,xxx-1b@highest
2892 . ori %r12,%r12,xxx-1b@higher
2893 . sldi %r12,%r12,32
2894 . oris %r12,%r12,xxx-1b@high
2895 . ori %r12,%r12,xxx-1b@l
2896 . ldx %r12,%r11,%r12
2897 . mtctr %r12
2898 . bctr
2900 There are also ELFv1 powerxx variants of these stubs.
2901 ppc_stub_long_branch_notoc:
2902 . pla %r12,dest@pcrel
2903 . b dest
2904 ppc_stub_plt_branch_notoc:
2905 . lis %r11,(dest-1f)@highesta34
2906 . ori %r11,%r11,(dest-1f)@highera34
2907 . sldi %r11,%r11,34
2908 . 1: pla %r12,dest@pcrel
2909 . add %r12,%r11,%r12
2910 . mtctr %r12
2911 . bctr
2912 ppc_stub_plt_call_notoc:
2913 . lis %r11,(xxx-1f)@highesta34
2914 . ori %r11,%r11,(xxx-1f)@highera34
2915 . sldi %r11,%r11,34
2916 . 1: pla %r12,xxx@pcrel
2917 . ldx %r12,%r11,%r12
2918 . mtctr %r12
2919 . bctr
2921 In cases where the high instructions would add zero, they are
2922 omitted and following instructions modified in some cases.
2923 For example, a powerxx ppc_stub_plt_call_notoc might simplify down
2924 to
2925 . pld %r12,xxx@pcrel
2926 . mtctr %r12
2927 . bctr
2929 For a given stub group (a set of sections all using the same toc
2930 pointer value) there will be just one stub type used for any
2931 particular function symbol. For example, if printf is called from
2932 code with the tocsave optimization (ie. r2 saved in function
2933 prologue) and therefore calls use a ppc_stub_plt_call linkage stub,
2934 and from other code without the tocsave optimization requiring a
2935 ppc_stub_plt_call_r2save linkage stub, a single stub of the latter
2936 type will be created. Calls with the tocsave optimization will
2937 enter this stub after the instruction saving r2. A similar
2938 situation exists when calls are marked with R_PPC64_REL24_NOTOC
2939 relocations. These require a ppc_stub_plt_call_notoc linkage stub
2940 to call an external function like printf. If other calls to printf
2941 require a ppc_stub_plt_call linkage stub then a single
2942 ppc_stub_plt_call_notoc linkage stub will be used for both types of
2943 call. If other calls to printf require a ppc_stub_plt_call_r2save
2944 linkage stub then a single ppc_stub_plt_call_both linkage stub will
2945 be created and calls not requiring r2 to be saved will enter the
2946 stub after the r2 save instruction. There is an analogous
2947 hierarchy of long branch and plt branch stubs for local call
2948 linkage. */
2950 enum ppc_stub_type
2951 {
2952 ppc_stub_none,
2953 ppc_stub_long_branch,
2954 ppc_stub_long_branch_r2off,
2955 ppc_stub_long_branch_notoc,
2957 ppc_stub_plt_branch,
2958 ppc_stub_plt_branch_r2off,
2959 ppc_stub_plt_branch_notoc,
2960 ppc_stub_plt_branch_both,
2961 ppc_stub_plt_call,
2962 ppc_stub_plt_call_r2save,
2963 ppc_stub_plt_call_notoc,
2964 ppc_stub_plt_call_both,
2965 ppc_stub_global_entry,
2966 ppc_stub_save_res
2967 };
2969 /* Information on stub grouping. */
2970 struct map_stub
2971 {
2972 /* The stub section. */
2974 /* This is the section to which stubs in the group will be attached. */
2976 /* Next group. */
2978 /* Whether to emit a copy of register save/restore functions in this
2979 group. */
2981 /* Current offset within stubs after the insn restoring lr in a
2982 _notoc or _both stub using bcl for pc-relative addressing, or
2983 after the insn restoring lr in a __tls_get_addr_opt plt stub. */
2985 /* Accumulated size of EH info emitted to describe return address
2986 if stubs modify lr. Does not include 17 byte FDE header. */
2988 /* Offset in glink_eh_frame to the start of EH info for this group. */
2990 };
2992 struct ppc_stub_hash_entry
2993 {
2994 /* Base hash table entry structure. */
2999 /* Group information. */
3002 /* Offset within stub_sec of the beginning of this stub. */
3003 bfd_vma stub_offset;
3005 /* Given the symbol's value and its section we can determine its final
3006 value when building the stubs (so the stub knows where to jump. */
3007 bfd_vma target_value;
3010 /* The symbol table entry, if any, that this was derived from. */
3014 /* Symbol type. */
3017 /* Symbol st_other. */
3019 };
3021 struct ppc_branch_hash_entry
3022 {
3023 /* Base hash table entry structure. */
3026 /* Offset within branch lookup table. */
3029 /* Generation marker. */
3031 };
3033 /* Used to track dynamic relocations for local symbols. */
3034 struct ppc_dyn_relocs
3035 {
3038 /* The input section of the reloc. */
3041 /* Total number of relocs copied for the input section. */
3044 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3046 };
3048 struct ppc_link_hash_entry
3049 {
3052 union
3053 {
3054 /* A pointer to the most recently used stub hash entry against this
3055 symbol. */
3058 /* A pointer to the next symbol starting with a '.' */
3062 /* Track dynamic relocs copied for this symbol. */
3065 /* Link between function code and descriptor symbols. */
3068 /* Flag function code and descriptor symbols. */
3073 /* Whether global opd/toc sym has been adjusted or not.
3074 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3075 should be set for all globals defined in any opd/toc section. */
3078 /* Set if this is an out-of-line register save/restore function,
3079 with non-standard calling convention. */
3082 /* Set if a duplicate symbol with non-zero localentry is detected,
3083 even when the duplicate symbol does not provide a definition. */
3086 /* Contexts in which symbol is used in the GOT (or TOC).
3087 Bits are or'd into the mask as the corresponding relocs are
3088 encountered during check_relocs, with TLS_TLS being set when any
3089 of the other TLS bits are set. tls_optimize clears bits when
3090 optimizing to indicate the corresponding GOT entry type is not
3091 needed. If set, TLS_TLS is never cleared. tls_optimize may also
3092 set TLS_GDIE when a GD reloc turns into an IE one.
3093 These flags are also kept for local symbols. */
3104 /* The above field is also used to mark function symbols. In which
3105 case TLS_TLS will be 0. */
3109 };
3111 /* ppc64 ELF linker hash table. */
3113 struct ppc_link_hash_table
3114 {
3117 /* The stub hash table. */
3120 /* Another hash table for plt_branch stubs. */
3123 /* Hash table for function prologue tocsave. */
3124 htab_t tocsave_htab;
3126 /* Various options and other info passed from the linker. */
3129 /* The size of sec_info below. */
3132 /* Per-section array of extra section info. Done this way rather
3133 than as part of ppc64_elf_section_data so we have the info for
3134 non-ppc64 sections. */
3135 struct
3136 {
3137 /* Along with elf_gp, specifies the TOC pointer used by this section. */
3138 bfd_vma toc_off;
3140 union
3141 {
3142 /* The section group that this section belongs to. */
3144 /* A temp section list pointer. */
3149 /* Linked list of groups. */
3152 /* Temp used when calculating TOC pointers. */
3153 bfd_vma toc_curr;
3157 /* Used when adding symbols. */
3160 /* Shortcuts to get to dynamic linker sections. */
3170 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
3174 /* The size of reliplt used by got entry relocs. */
3175 bfd_size_type got_reli_size;
3177 /* Statistics. */
3180 /* Number of stubs against global syms. */
3183 /* Set if we're linking code with function descriptors. */
3186 /* Support for multiple toc sections. */
3192 /* Set if tls optimization is enabled. */
3195 /* Set if inline plt calls should be converted to direct calls. */
3198 /* Set on error. */
3201 /* Whether func_desc_adjust needs to be run over symbols. */
3204 /* Whether there exist local gnu indirect function resolvers,
3205 referenced by dynamic relocations. */
3209 /* Whether plt calls for ELFv2 localentry:0 funcs have been optimized. */
3212 /* Whether calls are made via the PLT from NOTOC functions. */
3215 /* Whether to use powerxx instructions in linkage stubs. */
3218 /* Incremented every time we size stubs. */
3221 /* Small local sym cache. */
3223 };
3225 /* Rename some of the generic section flags to better document how they
3226 are used here. */
3228 /* Nonzero if this section has TLS related relocations. */
3229 #define has_tls_reloc sec_flg0
3231 /* Nonzero if this section has a call to __tls_get_addr lacking marker
3232 relocations. */
3233 #define nomark_tls_get_addr sec_flg1
3235 /* Nonzero if this section has any toc or got relocs. */
3236 #define has_toc_reloc sec_flg2
3238 /* Nonzero if this section has a call to another section that uses
3239 the toc or got. */
3240 #define makes_toc_func_call sec_flg3
3242 /* Recursion protection when determining above flag. */
3243 #define call_check_in_progress sec_flg4
3244 #define call_check_done sec_flg5
3246 /* Get the ppc64 ELF linker hash table from a link_info structure. */
3248 #define ppc_hash_table(p) \
3249 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3250 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3252 #define ppc_stub_hash_lookup(table, string, create, copy) \
3253 ((struct ppc_stub_hash_entry *) \
3254 bfd_hash_lookup ((table), (string), (create), (copy)))
3256 #define ppc_branch_hash_lookup(table, string, create, copy) \
3257 ((struct ppc_branch_hash_entry *) \
3258 bfd_hash_lookup ((table), (string), (create), (copy)))
3260 /* Create an entry in the stub hash table. */
3266 {
3267 /* Allocate the structure if it has not already been allocated by a
3268 subclass. */
3270 {
3274 }
3276 /* Call the allocation method of the superclass. */
3279 {
3282 /* Initialize the local fields. */
3292 }
3295 }
3297 /* Create an entry in the branch hash table. */
3303 {
3304 /* Allocate the structure if it has not already been allocated by a
3305 subclass. */
3307 {
3311 }
3313 /* Call the allocation method of the superclass. */
3316 {
3319 /* Initialize the local fields. */
3323 }
3326 }
3328 /* Create an entry in a ppc64 ELF linker hash table. */
3334 {
3335 /* Allocate the structure if it has not already been allocated by a
3336 subclass. */
3338 {
3342 }
3344 /* Call the allocation method of the superclass. */
3347 {
3354 /* When making function calls, old ABI code references function entry
3355 points (dot symbols), while new ABI code references the function
3356 descriptor symbol. We need to make any combination of reference and
3357 definition work together, without breaking archive linking.
3359 For a defined function "foo" and an undefined call to "bar":
3360 An old object defines "foo" and ".foo", references ".bar" (possibly
3361 "bar" too).
3362 A new object defines "foo" and references "bar".
3364 A new object thus has no problem with its undefined symbols being
3365 satisfied by definitions in an old object. On the other hand, the
3366 old object won't have ".bar" satisfied by a new object.
3368 Keep a list of newly added dot-symbols. */
3371 {
3377 }
3378 }
3381 }
3383 struct tocsave_entry
3384 {
3386 bfd_vma offset;
3387 };
3389 static hashval_t
3391 {
3394 }
3396 static int
3398 {
3402 }
3404 /* Destroy a ppc64 ELF linker hash table. */
3406 static void
3408 {
3417 }
3419 /* Create a ppc64 ELF linker hash table. */
3423 {
3433 PPC64_ELF_DATA))
3434 {
3437 }
3439 /* Init the stub hash table too. */
3442 {
3445 }
3447 /* And the branch hash table. */
3450 {
3454 }
3457 tocsave_htab_hash,
3458 tocsave_htab_eq,
3459 NULL);
3461 {
3464 }
3467 /* Initializing two fields of the union is just cosmetic. We really
3468 only care about glist, but when compiled on a 32-bit host the
3469 bfd_vma fields are larger. Setting the bfd_vma to zero makes
3470 debugger inspection of these fields look nicer. */
3481 }
3483 /* Create sections for linker generated code. */
3485 static bfd_boolean
3487 {
3489 flagword flags;
3496 {
3497 /* Create .sfpr for code to save and restore fp regs. */
3499 flags);
3503 }
3508 /* Create .glink for lazy dynamic linking support. */
3510 flags);
3515 /* The part of .glink used by global entry stubs, separate so that
3516 it can be aligned appropriately without affecting htab->glink. */
3518 flags);
3524 {
3529 flags);
3533 }
3549 /* Create branch lookup table for plt_branch stubs. */
3553 flags);
3558 /* Local plt entries, put in .branch_lt but a separate section for
3559 convenience. */
3561 flags);
3571 htab->relbrlt
3577 htab->relpltlocal
3584 }
3586 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
3588 bfd_boolean
3591 {
3596 /* Always hook our dynamic sections into the first bfd, which is the
3597 linker created stub bfd. This ensures that the GOT header is at
3598 the start of the output TOC section. */
3604 }
3606 /* Build a name for an entry in the stub hash table. */
3613 {
3615 ssize_t len;
3617 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
3618 offsets from a sym as a branch target? In fact, we could
3619 probably assume the addend is always zero. */
3623 {
3633 }
3634 else
3635 {
3646 }
3650 }
3652 /* Look up an entry in the stub hash. Stub entries are cached because
3653 creating the stub name takes a bit of time. */
3661 {
3665 /* If this input section is part of a group of sections sharing one
3666 stub section, then use the id of the first section in the group.
3667 Stub names need to include a section id, as there may well be
3668 more than one stub used to reach say, printf, and we need to
3669 distinguish between them. */
3677 {
3679 }
3680 else
3681 {
3694 }
3697 }
3699 /* Add a new stub entry to the stub hash. Not all fields of the new
3700 stub entry are initialised. */
3706 {
3717 {
3719 bfd_size_type len;
3734 }
3736 /* Enter this entry into the linker stub hash table. */
3740 {
3741 /* xgettext:c-format */
3745 }
3750 }
3752 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
3753 not already done. */
3755 static bfd_boolean
3757 {
3759 flagword flags;
3788 }
3790 /* Follow indirect and warning symbol links. */
3794 {
3799 }
3803 {
3805 }
3809 {
3811 }
3813 /* Merge PLT info on FROM with that on TO. */
3815 static void
3818 {
3820 {
3822 {
3827 {
3832 {
3836 }
3839 }
3841 }
3845 }
3846 }
3848 /* Copy the extra info we tack onto an elf_link_hash_entry. */
3850 static void
3854 {
3874 /* If we were called to copy over info for a weak sym, don't copy
3875 dyn_relocs, plt/got info, or dynindx. We used to copy dyn_relocs
3876 in order to simplify readonly_dynrelocs and save a field in the
3877 symbol hash entry, but that means dyn_relocs can't be used in any
3878 tests about a specific symbol, or affect other symbol flags which
3879 are then tested. */
3883 /* Copy over any dynamic relocs we may have on the indirect sym. */
3885 {
3887 {
3891 /* Add reloc counts against the indirect sym to the direct sym
3892 list. Merge any entries against the same section. */
3894 {
3899 {
3904 }
3907 }
3909 }
3913 }
3915 /* Copy over got entries that we may have already seen to the
3916 symbol which just became indirect. */
3918 {
3920 {
3925 {
3932 {
3936 }
3939 }
3941 }
3945 }
3947 /* And plt entries. */
3951 {
3959 }
3960 }
3962 /* Find the function descriptor hash entry from the given function code
3963 hash entry FH. Link the entries via their OH fields. */
3967 {
3971 {
3983 }
3989 }
3991 /* Make a fake function descriptor sym for the undefined code sym FH. */
3996 {
4001 ? BSF_WEAK
4018 }
4020 /* Fix function descriptor symbols defined in .opd sections to be
4021 function type. */
4023 static bfd_boolean
4031 {
4034 {
4041 /* If the symbol is a function defined in .opd, and the function
4042 code is in a discarded group, let it appear to be undefined. */
4048 {
4051 }
4052 }
4056 {
4060 }
4063 {
4067 {
4072 }
4073 }
4076 }
4078 /* Merge non-visibility st_other attributes: local entry point. */
4080 static void
4083 bfd_boolean definition,
4084 bfd_boolean dynamic)
4085 {
4089 }
4091 /* Hook called on merging a symbol. We use this to clear "fake" since
4092 we now have a real symbol. */
4094 static bfd_boolean
4098 bfd_boolean newdef ATTRIBUTE_UNUSED,
4099 bfd_boolean olddef ATTRIBUTE_UNUSED,
4102 {
4107 }
4109 /* This function makes an old ABI object reference to ".bar" cause the
4110 inclusion of a new ABI object archive that defines "bar".
4111 NAME is a symbol defined in an archive. Return a symbol in the hash
4112 table that might be satisfied by the archive symbols. */
4118 {
4125 /* Don't return this sym if it is a fake function descriptor
4126 created by add_symbol_adjust. */
4142 }
4144 /* This function satisfies all old ABI object references to ".bar" if a
4145 new ABI object defines "bar". Well, at least, undefined dot symbols
4146 are made weak. This stops later archive searches from including an
4147 object if we already have a function descriptor definition. It also
4148 prevents the linker complaining about undefined symbols.
4149 We also check and correct mismatched symbol visibility here. The
4150 most restrictive visibility of the function descriptor and the
4151 function entry symbol is used. */
4153 static bfd_boolean
4155 {
4178 {
4179 /* Make an undefined function descriptor sym, in order to
4180 pull in an --as-needed shared lib. Archives are handled
4181 elsewhere. */
4185 }
4188 {
4192 /* Make both descriptor and entry symbol have the most
4193 constraining visibility of either symbol. */
4199 /* Propagate reference flags from entry symbol to function
4200 descriptor symbol. */
4214 {
4217 }
4218 }
4221 }
4223 /* Set up opd section info and abiversion for IBFD, and process list
4224 of dot-symbols we made in link_hash_newfunc. */
4226 static bfd_boolean
4228 {
4234 {
4241 {
4242 /* xgettext:c-format */
4247 }
4248 }
4251 {
4252 /* For input files without an explicit abiversion in e_flags
4253 we should have flagged any with symbol st_other bits set
4254 as ELFv1 and above flagged those with .opd as ELFv2.
4255 Set the output abiversion if not yet set, and for any input
4256 still ambiguous, take its abiversion from the output.
4257 Differences in ABI are reported later. */
4262 }
4274 {
4275 /* Garbage collection needs some extra help with .opd sections.
4276 We don't want to necessarily keep everything referenced by
4277 relocs in .opd, as that would keep all functions. Instead,
4278 if we reference an .opd symbol (a function descriptor), we
4279 want to keep the function code symbol's section. This is
4280 easy for global symbols, but for local syms we need to keep
4281 information about the associated function section. */
4282 bfd_size_type amt;
4299 {
4306 {
4312 {
4316 }
4321 }
4322 }
4325 }
4329 {
4332 ;
4337 {
4341 }
4343 }
4345 }
4347 /* Undo hash table changes when an --as-needed input file is determined
4348 not to be needed. */
4350 static bfd_boolean
4354 {
4356 {
4363 }
4365 }
4367 /* If --just-symbols against a final linked binary, then assume we need
4368 toc adjusting stubs when calling functions defined there. */
4370 static void
4372 {
4376 {
4380 }
4382 }
4387 {
4393 {
4403 }
4406 {
4415 {
4427 }
4429 }
4436 }
4438 static bfd_boolean
4440 {
4447 {
4456 }
4459 }
4461 static bfd_boolean
4463 {
4475 }
4477 /* Relocs on inline plt call sequence insns prior to the call. */
4479 static bfd_boolean
4481 {
4490 }
4492 /* Look through the relocs for a section during the first phase, and
4493 calculate needed space in the global offset table, procedure
4494 linkage table, and dynamic reloc sections. */
4496 static bfd_boolean
4499 {
4507 bfd_boolean is_opd;
4512 /* Don't do anything special with non-loaded, non-alloced sections.
4513 In particular, any relocs in such sections should not affect GOT
4514 and PLT reference counting (ie. we don't allow them to create GOT
4515 or PLT entries), there's no possibility or desire to optimize TLS
4516 relocs, and there's not much point in propagating relocs to shared
4517 libs that the dynamic linker won't relocate. */
4537 {
4548 else
4549 {
4555 }
4559 {
4580 }
4583 {
4607 }
4611 {
4613 {
4616 }
4617 }
4618 else
4619 {
4626 {
4632 }
4633 }
4637 {
4640 /* These special tls relocs tie a call to __tls_get_addr with
4641 its parameter symbol. */
4644 else
4684 dogottls:
4695 dogot:
4696 /* This symbol requires a global offset table entry. */
4704 {
4707 }
4714 {
4725 {
4737 }
4740 }
4741 else
4742 /* This is a global offset table entry for a local symbol. */
4747 /* We may also need a plt entry if the symbol turns out to be
4748 an ifunc. */
4750 {
4753 }
4764 /* This symbol requires a procedure linkage table entry. */
4767 {
4774 }
4783 /* The following relocations don't need to propagate the
4784 relocation if linking a shared object since they are
4785 section relative. */
4806 /* Nor do these. */
4824 /* Not supported as a dynamic relocation. */
4827 {
4830 /* xgettext:c-format */
4837 }
4844 /* Fall through. */
4851 {
4852 /* We may need a copy reloc. */
4854 /* Strongly prefer a copy reloc over a dynamic reloc.
4855 glibc ld.so as of 2019-08 will error out if one of
4856 these relocations is emitted. */
4859 }
4862 /* Marker reloc. */
4866 /* This relocation describes the C++ object vtable hierarchy.
4867 Reconstruct it for later use during GC. */
4873 /* This relocation describes which C++ vtable entries are actually
4874 used. Record for later use during GC. */
4883 {
4886 /* Heuristic: If jumping outside our section, chances are
4887 we are going to need a stub. */
4889 {
4890 /* If the sym is weak it may be overridden later, so
4891 don't assume we know where a weak sym lives. */
4894 }
4895 else
4896 {
4905 }
4909 }
4915 /* Fall through. */
4919 rel24:
4922 {
4929 {
4934 /* We have a new-style __tls_get_addr call with
4935 a marker reloc. */
4936 ;
4937 else
4938 /* Mark this section as having an old-style call. */
4940 }
4942 }
4944 /* We may need a .plt entry if the function this reloc
4945 refers to is in a shared lib. */
4968 else
4977 /* This is the second reloc of a dtpmod, dtprel pair.
4978 Don't mark with TLS_DTPREL. */
4981 dotlstoc:
4984 {
4988 }
4989 else
4996 {
4997 bfd_size_type amt;
4999 /* One extra to simplify get_tls_mask. */
5010 }
5015 /* Mark the second slot of a GD or LD entry.
5016 -1 to indicate GD and -2 to indicate LD. */
5044 {
5047 }
5048 /* Fall through. */
5073 {
5074 /* We may need a .plt entry if this reloc refers to a
5075 function in a shared lib. */
5079 }
5080 /* Fall through. */
5091 /* We may need a copy reloc. */
5094 /* Don't propagate .opd relocs. */
5098 /* If we are creating a shared library, and this is a reloc
5099 against a global symbol, or a non PC relative reloc
5100 against a local symbol, then we need to copy the reloc
5101 into the shared library. However, if we are linking with
5102 -Bsymbolic, we do not need to copy a reloc against a
5103 global symbol which is defined in an object we are
5104 including in the link (i.e., DEF_REGULAR is set). At
5105 this point we have not seen all the input files, so it is
5106 possible that DEF_REGULAR is not set now but will be set
5107 later (it is never cleared). In case of a weak definition,
5108 DEF_REGULAR may be cleared later by a strong definition in
5109 a shared library. We account for that possibility below by
5110 storing information in the dyn_relocs field of the hash
5111 table entry. A similar situation occurs when creating
5112 shared libraries and symbol visibility changes render the
5113 symbol local.
5115 If on the other hand, we are creating an executable, we
5116 may need to keep relocations for symbols satisfied by a
5117 dynamic library if we manage to avoid copy relocs for the
5118 symbol. */
5119 dodyn:
5130 {
5131 /* We must copy these reloc types into the output file.
5132 Create a reloc section in dynobj and make room for
5133 this reloc. */
5135 {
5136 sreloc = _bfd_elf_make_dynamic_reloc_section
5141 }
5143 /* If this is a global symbol, we count the number of
5144 relocations we need for this symbol. */
5146 {
5153 {
5162 }
5166 }
5167 else
5168 {
5169 /* Track dynamic relocs needed for local syms too.
5170 We really need local syms available to do this
5171 easily. Oh well. */
5174 bfd_boolean is_ifunc;
5195 {
5204 }
5206 }
5207 }
5212 }
5213 }
5216 }
5218 /* Merge backend specific data from an object file to the output
5219 object file when linking. */
5221 static bfd_boolean
5223 {
5240 {
5241 _bfd_error_handler
5242 /* xgettext:c-format */
5246 }
5248 {
5249 _bfd_error_handler
5250 /* xgettext:c-format */
5255 }
5260 /* Merge Tag_compatibility attributes and any common GNU ones. */
5262 }
5264 static bfd_boolean
5266 {
5267 /* Print normal ELF private data. */
5271 {
5281 }
5284 }
5286 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
5287 of the code entry point, and its section, which must be in the same
5288 object as OPD_SEC. Returns (bfd_vma) -1 on error. */
5290 static bfd_vma
5292 bfd_vma offset,
5295 bfd_boolean in_code_sec)
5296 {
5300 bfd_vma val;
5302 /* No relocs implies we are linking a --just-symbols object, or looking
5303 at a final linked executable with addr2line or somesuch. */
5305 {
5309 {
5313 }
5315 /* PR 17512: file: 64b9dfbb. */
5321 {
5325 {
5330 else
5332 }
5333 else
5340 {
5344 }
5345 }
5347 }
5354 /* PR 17512: file: df8e1fd6. */
5358 /* Go find the opd reloc at the sym address. */
5363 {
5369 else
5370 {
5375 {
5381 {
5388 {
5394 {
5397 }
5398 }
5399 }
5402 {
5406 {
5409 {
5417 }
5419 }
5420 else
5421 {
5427 }
5433 }
5439 {
5442 else
5444 }
5447 }
5449 }
5450 }
5453 }
5455 /* If the ELF symbol SYM might be a function in SEC, return the
5456 function size and set *CODE_OFF to the function's entry point,
5457 otherwise return zero. */
5459 static bfd_size_type
5462 {
5463 bfd_size_type size;
5474 {
5481 {
5482 /* opd_entry_value will use cached relocs that have been
5483 adjusted, but with raw symbols. That means both local
5484 and global symbols need adjusting. */
5489 }
5494 /* An old ABI binary with dot-syms has a size of 24 on the .opd
5495 symbol. This size has nothing to do with the code size of the
5496 function, which is what we're supposed to return, but the
5497 code size isn't available without looking up the dot-sym.
5498 However, doing that would be a waste of time particularly
5499 since elf_find_function will look at the dot-sym anyway.
5500 Now, elf_find_function will keep the largest size of any
5501 function sym found at the code address of interest, so return
5502 1 here to avoid it incorrectly caching a larger function size
5503 for a small function. This does mean we return the wrong
5504 size for a new-ABI function of size 24, but all that does is
5505 disable caching for such functions. */
5508 }
5509 else
5510 {
5514 }
5518 }
5520 /* Return true if symbol is a strong function defined in an ELFv2
5521 object with st_other localentry bits of zero, ie. its local entry
5522 point coincides with its global entry point. */
5524 static bfd_boolean
5526 {
5534 }
5536 /* Return true if symbol is defined in a regular object file. */
5538 static bfd_boolean
5540 {
5545 }
5547 /* If FDH is a function descriptor symbol, return the associated code
5548 entry symbol if it is defined. Return NULL otherwise. */
5552 {
5554 {
5559 }
5561 }
5563 /* If FH is a function code entry symbol, return the associated
5564 function descriptor symbol if it is defined. Return NULL otherwise. */
5568 {
5571 {
5576 }
5578 }
5582 /* Garbage collect sections, after first dealing with dot-symbols. */
5584 static bfd_boolean
5586 {
5590 {
5593 }
5595 }
5597 /* Mark all our entry sym sections, both opd and code section. */
5599 static void
5601 {
5609 {
5623 {
5626 }
5635 }
5636 }
5638 /* Mark sections containing dynamically referenced symbols. When
5639 building shared libraries, we must assume that any visible symbol is
5640 referenced. */
5642 static bfd_boolean
5644 {
5650 /* Dynamic linking info is on the func descriptor sym. */
5671 {
5677 /* Function descriptor syms cause the associated
5678 function code sym section to be marked. */
5681 {
5684 }
5690 }
5693 }
5695 /* Return the section that should be marked against GC for a given
5696 relocation. */
5704 {
5707 /* Syms return NULL if we're marking .opd, so we avoid marking all
5708 function sections, as all functions are referenced in .opd. */
5714 {
5720 {
5727 {
5733 {
5734 /* -mcall-aixdesc code references the dot-symbol on
5735 a call reloc. Mark the function descriptor too
5736 against garbage collection. */
5741 }
5743 /* Function descriptor syms cause the associated
5744 function code sym section to be marked. */
5747 {
5748 /* They also mark their opd section. */
5752 }
5758 else
5768 }
5769 }
5770 }
5771 else
5772 {
5778 {
5782 }
5783 }
5786 }
5788 /* The maximum size of .sfpr. */
5789 #define SFPR_MAX (218*4)
5791 struct sfpr_def_parms
5792 {
5797 };
5799 /* Auto-generate _save*, _rest* functions in .sfpr.
5800 If STUB_SEC is non-null, define alias symbols in STUB_SEC
5801 instead. */
5803 static bfd_boolean
5807 {
5821 {
5829 {
5833 {
5841 {
5852 }
5853 }
5855 }
5857 {
5860 {
5870 {
5875 }
5876 }
5877 }
5879 {
5883 else
5886 }
5887 }
5890 }
5894 {
5897 }
5901 {
5907 }
5911 {
5914 }
5918 {
5925 {
5928 }
5931 }
5935 {
5938 }
5942 {
5946 }
5950 {
5953 }
5957 {
5961 }
5965 {
5968 }
5972 {
5978 }
5982 {
5985 }
5989 {
5996 {
5999 }
6002 }
6006 {
6010 }
6014 {
6018 }
6022 {
6027 }
6031 {
6035 }
6039 {
6044 }
6048 {
6052 }
6054 /* Called via elf_link_hash_traverse to transfer dynamic linking
6055 information on function code symbol entries to their corresponding
6056 function descriptor symbol entries. */
6058 static bfd_boolean
6060 {
6065 bfd_boolean force_local;
6083 /* Find the corresponding function descriptor symbol. */
6086 /* Resolve undefined references to dot-symbols as the value
6087 in the function descriptor, if we have one in a regular object.
6088 This is to satisfy cases like ".quad .foo". Calls to functions
6089 in dynamic objects are handled elsewhere. */
6099 {
6104 }
6107 {
6115 }
6117 /* Create a descriptor as undefined if necessary. */
6122 {
6126 }
6128 /* We can't support overriding of symbols on a fake descriptor. */
6135 /* Transfer dynamic linking information to the function descriptor. */
6137 {
6152 }
6154 /* Now that the info is on the function descriptor, clear the
6155 function code sym info. Any function code syms for which we
6156 don't have a definition in a regular file, we force local.
6157 This prevents a shared library from exporting syms that have
6158 been imported from another library. Function code syms that
6159 are really in the library we must leave global to prevent the
6160 linker dragging in a definition from a static library. */
6168 }
6171 {
6184 };
6186 /* Called near the start of bfd_elf_size_dynamic_sections. We use
6187 this hook to a) provide some gcc support functions, and b) transfer
6188 dynamic linking information gathered so far on function code symbol
6189 entries, to their corresponding function descriptor symbol entries. */
6191 static bfd_boolean
6194 {
6201 /* Provide any missing _save* and _rest* functions. */
6203 {
6212 }
6218 {
6220 /* Make .TOC. defined so as to prevent it being made dynamic.
6221 The wrong value here is fixed later in ppc64_elf_set_toc. */
6224 {
6230 }
6234 }
6237 {
6240 }
6243 }
6245 /* Find dynamic relocs for H that apply to read-only sections. */
6249 {
6255 {
6260 }
6262 }
6264 /* Return true if we have dynamic relocs against H or any of its weak
6265 aliases, that apply to read-only sections. Cannot be used after
6266 size_dynamic_sections. */
6268 static bfd_boolean
6270 {
6274 do
6275 {
6279 }
6283 }
6285 /* Return whether EH has pc-relative dynamic relocs. */
6287 static bfd_boolean
6289 {
6296 }
6298 /* Return true if a global entry stub will be created for H. Valid
6299 for ELFv2 before plt entries have been allocated. */
6301 static bfd_boolean
6303 {
6316 }
6318 /* Adjust a symbol defined by a dynamic object and referenced by a
6319 regular object. The current definition is in some section of the
6320 dynamic object, but we're not including those sections. We have to
6321 change the definition to something the rest of the link can
6322 understand. */
6324 static bfd_boolean
6327 {
6335 /* Deal with function syms. */
6339 {
6343 /* Discard dyn_relocs when non-pic if we've decided that a
6344 function symbol is local and not an ifunc. We keep dynamic
6345 relocs for ifuncs when local rather than always emitting a
6346 plt call stub for them and defining the symbol on the call
6347 stub. We can't do that for ELFv1 anyway (a function symbol
6348 is defined on a descriptor, not code) and it can be faster at
6349 run-time due to not needing to bounce through a stub. The
6350 dyn_relocs for ifuncs will be applied even in a static
6351 executable. */
6357 /* Clear procedure linkage table information for any symbol that
6358 won't need a .plt entry. */
6365 && local
6369 {
6373 }
6375 {
6376 /* Taking a function's address in a read/write section
6377 doesn't require us to define the function symbol in the
6378 executable on a global entry stub. A dynamic reloc can
6379 be used instead. The reason we prefer a few more dynamic
6380 relocs is that calling via a global entry stub costs a
6381 few more instructions, and pointer_equality_needed causes
6382 extra work in ld.so when resolving these symbols. */
6384 {
6386 {
6388 /* If we haven't seen a branch reloc and the symbol
6389 isn't an ifunc then we don't need a plt entry. */
6392 }
6394 /* We are going to be defining the function symbol on the
6395 plt stub, so no dyn_relocs needed when non-pic. */
6397 }
6399 /* ELFv2 function symbols can't have copy relocs. */
6401 }
6404 {
6405 /* If we haven't seen a branch reloc and the symbol isn't an
6406 ifunc then we don't need a plt entry. */
6410 }
6411 }
6412 else
6415 /* If this is a weak symbol, and there is a real definition, the
6416 processor independent code will have arranged for us to see the
6417 real definition first, and we can just use the same value. */
6419 {
6428 }
6430 /* If we are creating a shared library, we must presume that the
6431 only references to the symbol are via the global offset table.
6432 For such cases we need not do anything here; the relocations will
6433 be handled correctly by relocate_section. */
6437 /* If there are no references to this symbol that do not use the
6438 GOT, we don't need to generate a copy reloc. */
6442 /* Don't generate a copy reloc for symbols defined in the executable. */
6445 /* If -z nocopyreloc was given, don't generate them either. */
6448 /* If we don't find any dynamic relocs in read-only sections, then
6449 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
6450 || (ELIMINATE_COPY_RELOCS
6454 /* Protected variables do not work with .dynbss. The copy in
6455 .dynbss won't be used by the shared library with the protected
6456 definition for the variable. Text relocations are preferable
6457 to an incorrect program. */
6462 {
6463 /* We should never get here, but unfortunately there are versions
6464 of gcc out there that improperly (for this ABI) put initialized
6465 function pointers, vtable refs and suchlike in read-only
6466 sections. Allow them to proceed, but warn that this might
6467 break at runtime. */
6472 }
6474 /* This is a reference to a symbol defined by a dynamic object which
6475 is not a function. */
6477 /* We must allocate the symbol in our .dynbss section, which will
6478 become part of the .bss section of the executable. There will be
6479 an entry for this symbol in the .dynsym section. The dynamic
6480 object will contain position independent code, so all references
6481 from the dynamic object to this symbol will go through the global
6482 offset table. The dynamic linker will use the .dynsym entry to
6483 determine the address it must put in the global offset table, so
6484 both the dynamic object and the regular object will refer to the
6485 same memory location for the variable. */
6487 {
6490 }
6491 else
6492 {
6495 }
6497 {
6498 /* We must generate a R_PPC64_COPY reloc to tell the dynamic
6499 linker to copy the initial value out of the dynamic object
6500 and into the runtime process image. */
6503 }
6505 /* We no longer want dyn_relocs. */
6508 }
6510 /* If given a function descriptor symbol, hide both the function code
6511 sym and the descriptor. */
6512 static void
6515 bfd_boolean force_local)
6516 {
6525 {
6529 {
6534 /* We aren't supposed to use alloca in BFD because on
6535 systems which do not have alloca the version in libiberty
6536 calls xmalloc, which might cause the program to crash
6537 when it runs out of memory. This function doesn't have a
6538 return status, so there's no way to gracefully return an
6539 error. So cheat. We know that string[-1] can be safely
6540 accessed; It's either a string in an ELF string table,
6541 or allocated in an objalloc structure. */
6550 /* Unfortunately, if it so happens that the string we were
6551 looking for was allocated immediately before this string,
6552 then we overwrote the string terminator. That's the only
6553 reason the lookup should fail. */
6555 {
6562 }
6564 {
6567 }
6568 }
6571 }
6572 }
6574 static bfd_boolean
6582 {
6586 {
6600 {
6606 }
6609 {
6614 }
6615 }
6616 else
6617 {
6622 {
6631 }
6644 {
6651 {
6657 }
6659 }
6660 }
6662 }
6664 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
6665 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
6666 type suitable for optimization, and 1 otherwise. */
6668 static int
6675 {
6681 bfd_vma off;
6695 /* Look inside a TOC section too. */
6697 {
6700 }
6701 else
6717 }
6719 /* Find (or create) an entry in the tocsave hash table. */
6727 {
6732 hashval_t hash;
6739 {
6740 _bfd_error_handler
6743 }
6747 else
6758 {
6764 }
6766 }
6768 /* Adjust all global syms defined in opd sections. In gcc generated
6769 code for the old ABI, these will already have been done. */
6771 static bfd_boolean
6773 {
6792 {
6795 {
6796 /* This entry has been deleted. */
6799 {
6802 {
6805 }
6806 }
6809 }
6810 else
6813 }
6815 }
6817 /* Handles decrementing dynamic reloc counts for the reloc specified by
6818 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
6819 have already been determined. */
6821 static bfd_boolean
6828 {
6832 /* Can this reloc be dynamic? This switch, and later tests here
6833 should be kept in sync with the code in check_relocs. */
6836 {
6901 }
6904 {
6911 }
6925 ;
6926 else
6930 {
6935 /* elf_gc_sweep may have already removed all dyn relocs associated
6936 with local syms for a given section. Also, symbol flags are
6937 changed by elf_gc_sweep_symbol, confusing the test above. Don't
6938 report a dynreloc miscount. */
6943 {
6945 {
6952 }
6954 }
6955 }
6956 else
6957 {
6961 bfd_boolean is_ifunc;
6976 {
6978 {
6983 }
6985 }
6986 }
6988 /* xgettext:c-format */
6993 }
6995 /* Remove unused Official Procedure Descriptor entries. Currently we
6996 only remove those associated with functions in discarded link-once
6997 sections, or weakly defined functions that have been overridden. It
6998 would be possible to remove many more entries for statically linked
6999 applications. */
7001 bfd_boolean
7003 {
7014 {
7036 /* Look through the section relocs. */
7043 /* Read the relocations. */
7049 /* First run through the relocs to check they are sane, and to
7050 determine whether we need to edit this opd section. */
7056 {
7062 bfd_vma offset;
7064 /* .opd contains an array of 16 or 24 byte entries. We're
7065 only interested in the reloc pointing to a function entry
7066 point. */
7070 {
7071 /* If someone messes with .opd alignment then after a
7072 "ld -r" we might have padding in the middle of .opd.
7073 Also, there's nothing to prevent someone putting
7074 something silly in .opd with the assembler. No .opd
7075 optimization for them! */
7076 broken_opd:
7077 _bfd_error_handler
7081 }
7085 {
7086 _bfd_error_handler
7087 /* xgettext:c-format */
7092 }
7100 {
7104 else
7106 sym_sec);
7108 _bfd_error_handler
7109 /* xgettext:c-format */
7114 }
7116 /* opd entries are always for functions defined in the
7117 current input bfd. If the symbol isn't defined in the
7118 input bfd, then we won't be using the function in this
7119 bfd; It must be defined in a linkonce section in another
7120 bfd, or is weak. It's also possible that we are
7121 discarding the function due to a linker script /DISCARD/,
7122 which we test for via the output_section. */
7134 {
7136 {
7139 }
7141 {
7142 cnt_16b++;
7144 }
7146 }
7150 {
7152 cnt_16b++;
7155 }
7156 else
7158 }
7163 {
7168 bfd_size_type amt;
7177 /* This seems a waste of time as input .opd sections are all
7178 zeros as generated by gcc, but I suppose there's no reason
7179 this will always be so. We might start putting something in
7180 the third word of .opd entries. */
7182 {
7185 {
7188 error_ret:
7195 }
7198 }
7204 {
7209 }
7214 {
7222 bfd_boolean skip;
7235 /* See if the .opd entry is full 24 byte or
7236 16 byte (with fd_aux entry overlapped with next
7237 fd_func). */
7240 {
7243 }
7249 {
7252 {
7257 }
7258 }
7263 {
7265 {
7266 /* Arrange for the function descriptor sym
7267 to be dropped. */
7270 }
7275 else
7277 {
7289 }
7290 }
7291 else
7292 {
7293 /* We'll be keeping this opd entry. */
7297 {
7298 /* Redefine the function descriptor symbol to
7299 this location in the opd section. It is
7300 necessary to update the value here rather
7301 than using an array of adjustments as we do
7302 for local symbols, because various places
7303 in the generic ELF code use the value
7304 stored in u.def.value. */
7307 }
7309 /* Local syms are a bit tricky. We could
7310 tweak them as they can be cached, but
7311 we'd need to look through the local syms
7312 for the function descriptor sym which we
7313 don't have at the moment. So keep an
7314 array of adjustments. */
7322 {
7325 }
7327 /* We need to adjust any reloc offsets to point to the
7328 new opd entries. */
7330 {
7335 }
7336 }
7339 }
7344 {
7347 }
7349 /* Fudge the header size too, as this is used later in
7350 elf_bfd_final_link if we are emitting relocs. */
7354 }
7360 {
7363 else
7365 }
7366 }
7371 /* If we are doing a final link and the last .opd entry is just 16 byte
7372 long, add a 8 byte padding after it. */
7374 {
7378 {
7391 }
7392 else
7393 {
7399 }
7403 }
7406 }
7408 /* Analyze inline PLT call relocations to see whether calls to locally
7409 defined functions can be converted to direct calls. */
7411 bfd_boolean
7413 {
7423 /* A bl insn can reach -0x2000000 to 0x1fffffc. The limit is
7424 reduced somewhat to cater for possible stubs that might be added
7425 between the call and its destination. */
7427 {
7431 }
7432 else
7433 {
7437 }
7443 {
7448 }
7450 /* If a "bl" can reach anywhere in local code sections, then we can
7451 convert all inline PLT sequences to direct calls when the symbol
7452 is local. */
7454 {
7457 }
7459 /* Otherwise, go looking through relocs for cases where a direct
7460 call won't reach. Mark the symbol on any such reloc to disable
7461 the optimization and keep the PLT entry as it seems likely that
7462 this will be better than creating trampolines. Note that this
7463 will disable the optimization for all inline PLT calls to a
7464 particular symbol, not just those that won't reach. The
7465 difficulty in doing a more precise optimization is that the
7466 linker needs to make a decision depending on whether a
7467 particular R_PPC64_PLTCALL insn can be turned into a direct
7468 call, for each of the R_PPC64_PLTSEQ and R_PPC64_PLT16* insns in
7469 the sequence, and there is nothing that ties those relocs
7470 together except their symbol. */
7473 {
7486 {
7489 /* Read the relocations. */
7497 {
7513 {
7520 }
7523 {
7527 else
7541 }
7542 }
7545 }
7549 {
7552 else
7554 }
7555 }
7558 }
7560 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
7562 asection *
7564 {
7579 /* Default to --no-plt-localentry, as this option can cause problems
7580 with symbol interposition. For example, glibc libpthread.so and
7581 libc.so duplicate many pthread symbols, with a fallback
7582 implementation in libc.so. In some cases the fallback does more
7583 work than the pthread implementation. __pthread_condattr_destroy
7584 is one such symbol: the libpthread.so implementation is
7585 localentry:0 while the libc.so implementation is localentry:8.
7586 An app that "cleverly" uses dlopen to only load necessary
7587 libraries at runtime may omit loading libpthread.so when not
7588 running multi-threaded, which then results in the libc.so
7589 fallback symbols being used and ld.so complaining. Now there
7590 are workarounds in ld (see non_zero_localentry) to detect the
7591 pthread situation, but that may not be the only case where
7592 --plt-localentry can cause trouble. */
7598 _bfd_error_handler
7605 /* Move dynamic linking info to the function descriptor sym. */
7612 {
7624 {
7625 /* If glibc supports an optimized __tls_get_addr call stub,
7626 signalled by the presence of __tls_get_addr_opt, and we'll
7627 be calling __tls_get_addr via a plt call stub, then
7628 make __tls_get_addr point to __tls_get_addr_opt. */
7636 {
7643 {
7649 {
7650 /* Use __tls_get_addr_opt in dynamic relocations. */
7656 }
7657 htab->tls_get_addr_fd
7661 {
7669 }
7673 {
7676 }
7677 }
7678 }
7679 }
7682 }
7684 }
7686 /* Return TRUE iff REL is a branch reloc with a global symbol matching
7687 HASH1 or HASH2. */
7689 static bfd_boolean
7694 {
7700 {
7708 }
7710 }
7712 /* Run through all the TLS relocs looking for optimization
7713 opportunities. The linker has been hacked (see ppc64elf.em) to do
7714 a preliminary section layout so that we know the TLS segment
7715 offsets. We can't optimize earlier because some optimizations need
7716 to know the tp offset, and we need to optimize before allocating
7717 dynamic relocations. */
7719 bfd_boolean
7721 {
7735 /* Make two passes over the relocs. On the first pass, mark toc
7736 entries involved with tls relocs, and check that tls relocs
7737 involved in setting up a tls_get_addr call are indeed followed by
7738 such a call. If they are not, we can't do any tls optimization.
7739 On the second pass twiddle tls_mask flags to notify
7740 relocate_section that optimization can be done, and adjust got
7741 and plt refcounts. */
7745 {
7751 {
7755 /* Read the relocations. */
7759 {
7762 }
7766 {
7774 bfd_vma value;
7783 {
7784 err_free_rel:
7794 }
7797 {
7803 else
7804 {
7807 }
7808 }
7809 else
7810 /* Symbols referenced by TLS relocs must be of type
7811 STT_TLS. So no need for .opd local sym adjust. */
7817 {
7823 {
7827 /* Note that even though the prefix insns
7828 allow a 1<<33 offset we use the same test
7829 as for addis;addi. There may be a mix of
7830 pcrel and non-pcrel code and the decision
7831 to optimise is per symbol, not per TLS
7832 sequence. */
7834 }
7835 }
7838 /* If this section has old-style __tls_get_addr calls
7839 without marker relocs, then check that each
7840 __tls_get_addr call reloc is preceded by a reloc
7841 that conceivably belongs to the __tls_get_addr arg
7842 setup insn. If we don't find matching arg setup
7843 relocs, don't do any tls optimization. */
7849 && !found_tls_get_addr_arg
7851 {
7857 }
7861 {
7867 /* Fall through. */
7871 /* These relocs should never be against a symbol
7872 defined in a shared lib. Leave them alone if
7873 that turns out to be the case. */
7877 /* LD -> LE */
7888 /* Fall through. */
7893 /* GD -> LE */
7895 else
7896 /* GD -> IE */
7908 {
7909 /* IE -> LE */
7914 }
7920 /* Fall through. */
7924 {
7930 {
7936 {
7948 }
7949 }
7951 }
7953 /* Fall through. */
7961 /* Mark this toc entry as referenced by a TLS
7962 code sequence. We can do that now in the
7963 case of R_PPC64_TLS, and after checking for
7964 tls_get_addr for the TOC16 relocs. */
7966 toc_ref
7973 else
7984 {
7987 }
8004 {
8005 /* IE -> LE */
8009 }
8022 {
8024 /* GD -> LE */
8026 else
8027 /* GD -> IE */
8030 }
8031 else
8032 {
8036 /* LD -> LE */
8039 }
8044 }
8047 {
8056 {
8058 {
8059 /* Check for toc tls entries. */
8069 {
8075 }
8076 }
8078 }
8080 /* Uh oh, we didn't find the expected call. We
8081 could just mark this symbol to exclude it
8082 from tls optimization but it's safer to skip
8083 the entire optimization. */
8084 /* xgettext:c-format */
8090 }
8092 /* If we don't have old-style __tls_get_addr calls
8093 without TLSGD/TLSLD marker relocs, and we haven't
8094 found a new-style __tls_get_addr call with a
8095 marker for this symbol, then we either have a
8096 broken object file or an -mlongcall style
8097 indirect call to __tls_get_addr without a marker.
8098 Disable optimization in this case. */
8107 {
8127 }
8133 {
8136 /* Adjust got entry for this reloc. */
8139 else
8151 {
8152 /* We managed to get rid of a got entry. */
8155 }
8156 }
8157 else
8158 {
8159 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8160 we'll lose one or two dyn relocs. */
8166 {
8170 }
8171 }
8175 }
8179 }
8183 {
8186 else
8188 }
8189 }
8195 }
8197 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8198 the values of any global symbols in a toc section that has been
8199 edited. Globals in toc sections should be a rarity, so this function
8200 sets a flag if any are found in toc sections other than the one just
8201 edited, so that further hash table traversals can be avoided. */
8203 struct adjust_toc_info
8204 {
8207 bfd_boolean global_toc_syms;
8208 };
8212 static bfd_boolean
8214 {
8228 {
8231 else
8235 {
8236 _bfd_error_handler
8238 do
8242 }
8246 }
8251 }
8253 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
8254 on a _LO variety toc/got reloc. */
8256 static bfd_boolean
8258 {
8276 /* Exclude lfqu by testing reloc. If relocs are ever
8277 defined for the reduced D field in psq_lu then those
8278 will need testing too. */
8284 /* Exclude stfqu. psq_stu as above for psq_lu. */
8288 }
8290 /* PCREL_OPT in one instance flags to the linker that a pair of insns:
8291 pld ra,symbol@got@pcrel
8292 load/store rt,off(ra)
8293 or
8294 pla ra,symbol@pcrel
8295 load/store rt,off(ra)
8296 may be translated to
8297 pload/pstore rt,symbol+off@pcrel
8298 nop.
8299 This function returns true if the optimization is possible, placing
8300 the prefix insn in *PINSN1, a NOP in *PINSN2 and the offset in *POFF.
8302 On entry to this function, the linker has already determined that
8303 the pld can be replaced with pla: *PINSN1 is that pla insn,
8304 while *PINSN2 is the second instruction. */
8306 static bfd_boolean
8308 {
8311 bfd_signed_vma off;
8314 {
8315 /* Check that regs match. */
8319 /* P8LS or PMLS form, non-pcrel. */
8328 }
8332 /* Check that regs match. */
8337 {
8352 /* These are the PMLS cases, where we just need to tack a prefix
8353 on the insn. */
8381 {
8386 }
8387 else
8388 {
8393 }
8410 }
8416 }
8418 /* Examine all relocs referencing .toc sections in order to remove
8419 unused .toc entries. */
8421 bfd_boolean
8423 {
8431 {
8454 /* Look at sections dropped from the final link. */
8458 {
8470 /* Run through the relocs to see which toc entries might be
8471 unused. */
8473 {
8479 bfd_vma val;
8483 {
8494 }
8506 else
8513 /* Anything in the toc ought to be aligned to 8 bytes.
8514 If not, don't mark as unused. */
8519 {
8523 }
8526 }
8530 }
8532 /* For largetoc loads of address constants, we can convert
8533 . addis rx,2,addr@got@ha
8534 . ld ry,addr@got@l(rx)
8535 to
8536 . addis rx,2,addr@toc@ha
8537 . addi ry,rx,addr@toc@l
8538 when addr is within 2G of the toc pointer. This then means
8539 that the word storing "addr" in the toc is no longer needed. */
8544 {
8545 /* Read toc relocs. */
8552 {
8578 {
8582 }
8583 else
8584 {
8588 }
8592 /* We don't yet know the exact toc pointer value, but we
8593 know it will be somewhere in the toc section. Don't
8594 optimize if the difference from any possible toc
8595 pointer is outside [ff..f80008000, 7fff7fff]. */
8605 {
8609 }
8613 }
8614 }
8621 {
8622 error_ret:
8636 }
8638 /* Now check all kept sections that might reference the toc.
8639 Check the toc itself last. */
8647 {
8660 {
8663 }
8665 /* Mark toc entries referenced as used. */
8666 do
8667 {
8670 {
8676 bfd_vma val;
8680 {
8687 /* In case we're taking addresses of toc entries. */
8693 }
8698 {
8701 }
8708 else
8716 {
8717 bfd_vma off;
8721 {
8730 {
8733 }
8736 /* Fall through. */
8739 /* Wrong sort of reloc, or not a ld. We may
8740 as well clear ref_from_discarded too. */
8742 }
8743 }
8747 /* For the toc section, we only mark as used if this
8748 entry itself isn't unused. */
8752 {
8753 /* Do all the relocs again, to catch reference
8754 chains. */
8757 }
8758 }
8759 }
8764 }
8766 /* Merge the used and skip arrays. Assume that TOC
8767 doublewords not appearing as either used or unused belong
8768 to an entry more than one doubleword in size. */
8772 {
8774 {
8779 }
8781 {
8784 }
8785 else
8787 }
8792 {
8798 /* Shuffle the toc contents, and at the same time convert the
8799 skip array from booleans into offsets. */
8808 {
8812 {
8815 }
8816 }
8821 /* Adjust addends for relocs against the toc section sym,
8822 and optimize any accesses we can. */
8824 {
8835 {
8840 bfd_vma val;
8844 {
8856 }
8868 else
8869 {
8873 }
8882 {
8883 Elf_Internal_Rela *tocrel
8888 {
8901 /* xgettext:c-format */
8908 }
8912 }
8919 }
8923 }
8925 /* We shouldn't have local or global symbols defined in the TOC,
8926 but handle them anyway. */
8933 {
8938 else
8942 {
8944 _bfd_error_handler
8947 do
8951 }
8955 }
8957 /* Adjust any global syms defined in this toc input section. */
8959 {
8965 }
8968 {
8971 bfd_size_type sz;
8973 /* Remove unused toc relocs, and adjust those we keep. */
8984 {
8989 }
8999 }
9000 }
9007 {
9010 else
9012 }
9014 }
9016 /* Look for cases where we can change an indirect GOT access to
9017 a GOT relative or PC relative access, possibly reducing the
9018 number of GOT entries. */
9020 {
9025 bfd_vma got;
9042 {
9051 {
9052 got_error_ret:
9061 }
9064 {
9078 {
9105 }
9108 {
9119 {
9125 /* xgettext:c-format */
9130 }
9131 }
9134 {
9135 /* Note that we don't delete GOT entries for
9136 R_PPC64_GOT16_DS since we'd need a lot more
9137 analysis. For starters, the preliminary layout is
9138 before the GOT, PLT, dynamic sections and stubs are
9139 laid out. Then we'd need to allow for changes in
9140 distance between sections caused by alignment. */
9148 }
9165 else
9170 /* Fudge factor to allow for the fact that the preliminary layout
9171 isn't exact. Reduce limits by this factor. */
9172 #define LIMIT_ADJUST(LIMIT) ((LIMIT) - (LIMIT) / 16)
9175 {
9221 }
9222 #undef LIMIT_ADJUST
9226 else
9227 {
9230 }
9238 }
9242 }
9246 {
9249 else
9251 }
9252 }
9255 }
9257 /* Return true iff input section I references the TOC using
9258 instructions limited to +/-32k offsets. */
9260 bfd_boolean
9262 {
9265 }
9267 /* Allocate space for one GOT entry. */
9269 static void
9273 {
9286 {
9289 }
9298 {
9301 }
9302 }
9304 /* This function merges got entries in the same toc group. */
9306 static void
9308 {
9318 {
9321 }
9322 }
9324 /* If H is undefined, make it dynamic if that makes sense. */
9326 static bfd_boolean
9329 {
9341 }
9343 /* Allocate space in .plt, .got and associated reloc sections for
9344 dynamic relocs. */
9346 static bfd_boolean
9348 {
9364 /* Run through the TLS GD got entries first if we're changing them
9365 to TPREL. */
9370 {
9371 /* This was a GD entry that has been converted to TPREL. If
9372 there happens to be a TPREL entry we can use that one. */
9379 {
9382 }
9384 /* If not, then we'll be using our own TPREL entry. */
9387 }
9389 /* Remove any list entry that won't generate a word in the GOT before
9390 we call merge_got_entries. Otherwise we risk merging to empty
9391 entries. */
9395 {
9398 {
9401 }
9402 else
9404 }
9405 else
9413 {
9414 /* Ensure we catch all the cases where this symbol should
9415 be made dynamic. */
9423 }
9425 /* If no dynamic sections we can't have dynamic relocs, except for
9426 IFUNCs which are handled even in static executables. */
9431 /* Discard relocs on undefined symbols that must be local. */
9436 /* Also discard relocs on undefined weak syms with non-default
9437 visibility, or when dynamic_undefined_weak says so. */
9442 {
9445 /* In the shared -Bsymbolic case, discard space allocated for
9446 dynamic pc-relative relocs against symbols which turn out to
9447 be defined in regular objects. For the normal shared case,
9448 discard space for relocs that have become local due to symbol
9449 visibility changes. */
9451 {
9452 /* Relocs that use pc_count are those that appear on a call
9453 insn, or certain REL relocs (see must_be_dyn_reloc) that
9454 can be generated via assembly. We want calls to
9455 protected symbols to resolve directly to the function
9456 rather than going via the plt. If people want function
9457 pointer comparisons to work as expected then they should
9458 avoid writing weird assembly. */
9460 {
9462 {
9467 else
9469 }
9470 }
9473 {
9474 /* Ensure we catch all the cases where this symbol
9475 should be made dynamic. */
9478 }
9479 }
9481 /* For a fixed position executable, discard space for
9482 relocs against symbols which are not dynamic. */
9484 {
9488 {
9489 /* Ensure we catch all the cases where this symbol
9490 should be made dynamic. */
9494 /* But if that didn't work out, discard dynamic relocs. */
9497 }
9498 else
9500 }
9502 /* Finally, allocate space. */
9504 {
9509 }
9510 }
9512 /* We might need a PLT entry when the symbol
9513 a) is dynamic, or
9514 b) is an ifunc, or
9515 c) has plt16 relocs and has been processed by adjust_dynamic_symbol, or
9516 d) has plt16 relocs and we are linking statically. */
9526 {
9531 {
9534 {
9536 {
9541 }
9542 else
9543 {
9548 }
9549 }
9550 else
9551 {
9552 /* If this is the first .plt entry, make room for the special
9553 first entry. */
9560 /* Make room for this entry. */
9563 /* Make room for the .glink code. */
9568 {
9569 /* We need bigger stubs past index 32767. */
9573 }
9574 else
9577 /* We also need to make an entry in the .rela.plt section. */
9579 }
9583 }
9584 else
9587 {
9590 }
9591 }
9592 else
9593 {
9596 }
9599 }
9601 #define PPC_LO(v) ((v) & 0xffff)
9602 #define PPC_HI(v) (((v) >> 16) & 0xffff)
9603 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
9604 #define D34(v) \
9605 ((((v) & 0x3ffff0000ULL) << 16) | (v & 0xffff))
9606 #define HA34(v) ((v + (1ULL << 33)) >> 34)
9608 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9609 to set up space for global entry stubs. These are put in glink,
9610 after the branch table. */
9612 static bfd_boolean
9614 {
9639 {
9640 /* For ELFv2, if this symbol is not defined in a regular file
9641 and we are not generating a shared library or pie, then we
9642 need to define the symbol in the executable on a call stub.
9643 This is to avoid text relocations. */
9651 else
9653 /* Setting section alignment is delayed until we know it is
9654 non-empty. Otherwise the .text output section will be
9655 aligned at least to plt_stub_align even when no global
9656 entry stubs are needed. */
9667 /* Note that for --plt-stub-align negative we have a possible
9668 dependency between stub offset and size. Break that
9669 dependency by assuming the max stub size when calculating
9670 the stub offset. */
9678 }
9680 }
9682 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9683 read-only sections. */
9685 static bfd_boolean
9687 {
9695 {
9703 /* Not an error, just cut short the traversal. */
9705 }
9707 }
9709 /* Set the sizes of the dynamic sections. */
9711 static bfd_boolean
9714 {
9718 bfd_boolean relocs;
9731 {
9732 /* Set the contents of the .interp section to the interpreter. */
9734 {
9740 }
9741 }
9743 /* Set up .got offsets for local syms, and space for local dynamic
9744 relocs. */
9746 {
9752 bfd_size_type locsymcount;
9759 {
9763 {
9766 {
9767 /* Input section has been discarded, either because
9768 it is a copy of a linkonce section or due to
9769 linker script /DISCARD/, so we'll be discarding
9770 the relocs too. */
9771 }
9773 {
9780 }
9781 }
9782 }
9796 {
9802 {
9804 {
9807 }
9808 else
9809 {
9815 {
9818 }
9821 {
9824 }
9828 {
9831 }
9833 }
9834 }
9835 else
9837 }
9839 /* Allocate space for plt calls to local syms. */
9842 {
9847 {
9849 {
9854 }
9858 else
9859 {
9865 }
9866 }
9867 else
9869 }
9870 }
9872 /* Allocate global sym .plt and .got entries, and space for global
9873 sym dynamic relocs. */
9881 {
9889 {
9891 {
9894 }
9895 else
9896 {
9904 {
9907 }
9908 }
9909 }
9910 else
9912 }
9914 /* We now have determined the sizes of the various dynamic sections.
9915 Allocate memory for them. */
9918 {
9923 /* These haven't been allocated yet; don't strip. */
9933 {
9934 /* Strip this section if we don't need it; see the
9935 comment below. */
9936 }
9938 {
9940 /* Not sized yet. */
9942 }
9944 {
9946 {
9950 /* We use the reloc_count field as a counter if we need
9951 to copy relocs into the output file. */
9953 }
9954 }
9955 else
9956 {
9957 /* It's not one of our sections, so don't allocate space. */
9959 }
9962 {
9963 /* If we don't need this section, strip it from the
9964 output file. This is mostly to handle .rela.bss and
9965 .rela.plt. We must create both sections in
9966 create_dynamic_sections, because they must be created
9967 before the linker maps input sections to output
9968 sections. The linker does that before
9969 adjust_dynamic_symbol is called, and it is that
9970 function which decides whether anything needs to go
9971 into these sections. */
9974 }
9983 /* Allocate memory for the section contents. We use bfd_zalloc
9984 here in case unused entries are not reclaimed before the
9985 section's contents are written out. This should not happen,
9986 but this way if it does we get a R_PPC64_NONE reloc in .rela
9987 sections instead of garbage.
9988 We also rely on the section contents being zero when writing
9989 the GOT and .dynrelro. */
9993 }
9996 {
10002 {
10005 else
10006 {
10010 }
10011 }
10014 {
10017 else
10018 {
10024 }
10025 }
10026 }
10029 {
10030 bfd_boolean tls_opt;
10032 /* Add some entries to the .dynamic section. We fill in the
10033 values later, in ppc64_elf_finish_dynamic_sections, but we
10034 must add the entries now so that we get the correct size for
10035 the .dynamic section. The DT_DEBUG entry is filled in by the
10036 dynamic linker and used by the debugger. */
10037 #define add_dynamic_entry(TAG, VAL) \
10038 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10041 {
10044 }
10047 {
10054 }
10057 {
10061 }
10067 {
10070 }
10073 {
10079 /* If any dynamic relocs apply to a read-only section,
10080 then we need a DT_TEXTREL entry. */
10085 {
10088 }
10089 }
10090 }
10091 #undef add_dynamic_entry
10094 }
10096 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
10098 static bfd_boolean
10100 {
10107 }
10109 /* Determine the type of stub needed, if any, for a call. */
10116 bfd_vma destination,
10118 {
10120 bfd_vma location;
10121 bfd_vma branch_offset;
10122 bfd_vma max_branch_offset;
10126 {
10131 {
10134 }
10139 {
10142 }
10144 /* Here, we know we don't have a plt entry. If we don't have a
10145 either a defined function descriptor or a defined entry symbol
10146 in a regular object file, then it is pointless trying to make
10147 any other type of stub. */
10151 }
10153 {
10160 {
10166 {
10169 }
10170 }
10171 }
10173 /* Determine where the call point is. */
10181 /* Determine if a long branch stub is needed. */
10189 /* We need a stub. Figure out whether a long_branch or plt_branch
10190 is needed later. */
10194 }
10196 /* Gets the address of a label (1:) in r11 and builds an offset in r12,
10197 then adds it to r11 (LOAD false) or loads r12 from r11+r12 (LOAD true).
10198 . mflr %r12
10199 . bcl 20,31,1f
10200 .1: mflr %r11
10201 . mtlr %r12
10202 . lis %r12,xxx-1b@highest
10203 . ori %r12,%r12,xxx-1b@higher
10204 . sldi %r12,%r12,32
10205 . oris %r12,%r12,xxx-1b@high
10206 . ori %r12,%r12,xxx-1b@l
10207 . add/ldx %r12,%r11,%r12 */
10211 {
10221 {
10224 else
10227 }
10229 {
10234 else
10237 }
10238 else
10239 {
10241 {
10244 }
10245 else
10246 {
10250 {
10253 }
10254 }
10256 {
10259 }
10261 {
10264 }
10266 {
10269 }
10272 else
10275 }
10277 }
10279 static unsigned int
10281 {
10287 else
10288 {
10291 else
10292 {
10296 }
10304 }
10306 }
10308 static unsigned int
10310 {
10316 else
10317 {
10326 }
10328 }
10333 {
10342 {
10349 }
10350 else
10351 {
10354 else
10355 {
10358 {
10364 }
10365 }
10369 {
10375 }
10377 {
10383 }
10384 }
10386 }
10390 bfd_boolean load)
10391 {
10394 {
10397 {
10400 }
10403 else
10409 }
10410 /* The minimum value for paddi is -0x200000000. The minimum value
10411 for li is -0x8000, which when shifted by 34 and added gives a
10412 minimum value of -0x2000200000000. The maximum value is
10413 0x1ffffffff+0x7fff<<34 which is 0x2000200000000-1. */
10415 {
10420 {
10423 }
10430 {
10433 }
10436 else
10438 }
10439 else
10440 {
10447 {
10450 }
10457 {
10460 }
10463 else
10465 }
10468 }
10470 static unsigned int
10472 {
10477 else
10479 }
10481 static unsigned int
10483 {
10488 else
10490 }
10496 {
10500 {
10507 }
10508 else
10509 {
10521 }
10526 }
10528 /* Emit .eh_frame opcode to advance pc by DELTA. */
10532 {
10537 {
10540 }
10542 {
10546 }
10547 else
10548 {
10552 }
10554 }
10556 /* Size of required .eh_frame opcode to advance pc by DELTA. */
10558 static unsigned int
10560 {
10562 /* DW_CFA_advance_loc+[1..63]. */
10565 /* DW_CFA_advance_loc1, byte. */
10568 /* DW_CFA_advance_loc2, 2 bytes. */
10570 /* DW_CFA_advance_loc4, 4 bytes. */
10572 }
10574 /* With power7 weakly ordered memory model, it is possible for ld.so
10575 to update a plt entry in one thread and have another thread see a
10576 stale zero toc entry. To avoid this we need some sort of acquire
10577 barrier in the call stub. One solution is to make the load of the
10578 toc word seem to appear to depend on the load of the function entry
10579 word. Another solution is to test for r2 being zero, and branch to
10580 the appropriate glink entry if so.
10582 . fake dep barrier compare
10583 . ld 12,xxx(2) ld 12,xxx(2)
10584 . mtctr 12 mtctr 12
10585 . xor 11,12,12 ld 2,xxx+8(2)
10586 . add 2,2,11 cmpldi 2,0
10587 . ld 2,xxx+8(2) bnectr+
10588 . bctr b <glink_entry>
10590 The solution involving the compare turns out to be faster, so
10591 that's what we use unless the branch won't reach. */
10593 #define ALWAYS_USE_FAKE_DEP 0
10594 #define ALWAYS_EMIT_R2SAVE 0
10599 bfd_vma off)
10600 {
10604 {
10606 {
10613 }
10614 else
10619 }
10628 {
10639 }
10644 {
10648 }
10650 }
10652 /* Depending on the sign of plt_stub_align:
10653 If positive, return the padding to align to a 2**plt_stub_align
10654 boundary.
10655 If negative, if this stub would cross fewer 2**plt_stub_align
10656 boundaries if we align, then return the padding needed to do so. */
10661 bfd_vma plt_off)
10662 {
10668 {
10673 }
10681 }
10683 /* Build a .plt call stub. */
10689 {
10701 && plt_load_toc
10702 && plt_thread_safe
10706 {
10715 to = (glinkoff
10730 }
10733 {
10735 {
10744 {
10746 {
10750 }
10751 else
10752 {
10757 {
10761 }
10762 }
10763 }
10764 }
10769 {
10772 }
10773 else
10774 {
10777 }
10780 {
10783 }
10786 {
10788 {
10791 }
10795 }
10796 }
10797 else
10798 {
10800 {
10806 {
10808 {
10812 }
10813 else
10814 {
10819 {
10823 }
10824 }
10825 }
10826 }
10833 {
10836 }
10839 {
10841 {
10844 }
10848 }
10849 }
10851 {
10855 }
10856 else
10859 }
10861 /* Build a special .plt call stub for __tls_get_addr. */
10863 #define LD_R11_0R3 0xe9630000
10864 #define LD_R12_0R3 0xe9830000
10865 #define MR_R0_R3 0x7c601b78
10866 #define CMPDI_R11_0 0x2c2b0000
10867 #define ADD_R3_R12_R13 0x7c6c6a14
10868 #define BEQLR 0x4d820020
10869 #define MR_R3_R0 0x7c030378
10870 #define STD_R11_0R1 0xf9610000
10871 #define BCTRL 0x4e800421
10872 #define LD_R11_0R1 0xe9610000
10873 #define MTLR_R11 0x7d6803a6
10879 {
10910 {
10927 }
10929 }
10933 {
10940 {
10941 bfd_size_type relsize;
10955 }
10959 }
10961 /* Convert the relocs R[0] thru R[-NUM_REL+1], which are all no-symbol
10962 forms, to the equivalent relocs against the global symbol given by
10963 STUB_ENTRY->H. */
10965 static bfd_boolean
10969 {
10973 bfd_vma symval;
10975 /* Relocs are always against symbols in their own object file. Fake
10976 up global sym hashes for the stub bfd (which has no symbols). */
10979 {
10980 bfd_size_type hsize;
10982 /* When called the first time, stub_globals will contain the
10983 total number of symbols seen during stub sizing. After
10984 allocating, stub_globals is used as an index to fill the
10985 hashes array. */
10992 }
11004 {
11007 {
11008 /* H is an opd symbol. The addend must be zero, and the
11009 branch reloc is the only one we can convert. */
11012 }
11013 else
11016 }
11018 }
11020 static bfd_vma
11023 {
11028 {
11029 /* Support linking -R objects. Get the toc pointer from the
11030 opd entry. */
11039 {
11045 }
11050 }
11053 }
11055 static bfd_boolean
11057 {
11070 /* Massage our args to the form they really have. */
11083 {
11086 /* Branches are relative. This is where we are going to. */
11092 /* And this is where we are coming from. */
11100 {
11104 {
11107 }
11111 {
11115 }
11117 {
11121 }
11123 }
11128 {
11129 _bfd_error_handler
11134 }
11137 {
11147 }
11156 {
11161 }
11173 {
11177 {
11178 /* Create a reloc for the branch lookup table entry. */
11179 Elf_Internal_Rela rela;
11192 }
11194 {
11198 /* brlt, being SEC_LINKER_CREATED does not go through the
11199 normal reloc processing. Symbols and offsets are not
11200 translated from input file to output file form, so
11201 set up the offset per the output file. */
11207 }
11208 }
11219 {
11226 }
11229 {
11241 {
11246 }
11247 }
11251 {
11253 {
11259 }
11260 else
11263 }
11264 else
11265 {
11269 {
11272 }
11277 {
11283 }
11284 else
11288 {
11292 }
11294 {
11298 }
11299 }
11320 {
11324 }
11326 {
11335 {
11338 else
11340 }
11342 }
11343 else
11353 {
11356 }
11357 else
11358 {
11359 /* The notoc stubs calculate their target (either a PLT entry or
11360 the global entry point of a function) relative to the PC
11361 returned by the "bcl" two instructions past the start of the
11362 sequence emitted by build_offset. The offset is therefore 8
11363 less than calculated from the start of the sequence. */
11367 }
11370 {
11371 bfd_vma from;
11379 }
11380 else
11381 {
11385 }
11389 {
11393 else
11394 {
11397 }
11403 else
11407 {
11416 }
11417 }
11422 {
11444 }
11452 {
11455 /* If the old-ABI "dot-symbol" is undefined make it weak so
11456 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL. */
11461 }
11463 /* Now build the stub. */
11472 {
11475 else
11477 }
11485 {
11487 /* xgettext:c-format */
11495 }
11499 {
11512 }
11518 else
11528 }
11533 {
11562 {
11572 }
11573 }
11576 }
11578 /* As above, but don't actually build the stub. Just bump offset so
11579 we know stub section sizes, and select plt_branch stubs where
11580 long_branch stubs won't do. */
11582 static bfd_boolean
11584 {
11592 /* Massage our args to the form they really have. */
11600 /* Make a note of the offset within the stubs for this entry. */
11607 {
11608 /* Don't make stubs to out-of-line register save/restore
11609 functions. Instead, emit copies of the functions. */
11613 }
11616 {
11619 /* Reset the stub type from the plt branch variant in case we now
11620 can reach with a shorter stub. */
11622 /* Fall through. */
11636 {
11639 {
11642 }
11649 }
11652 /* If the branch offset is too big, use a ppc_stub_plt_branch.
11653 Do the same for -R objects without function descriptors. */
11658 {
11665 {
11670 }
11673 {
11681 {
11684 }
11685 }
11695 {
11699 }
11703 {
11707 }
11708 else
11709 {
11718 }
11719 }
11721 {
11724 }
11730 /* Fall through. */
11747 {
11751 else
11755 }
11759 else
11761 /* Include branch insn plus those in the offset sequence. */
11763 /* The branch insn is at the end, or "extra" bytes along. So
11764 its offset will be "extra" bytes less that that already
11765 calculated. */
11769 {
11770 /* After the bcl, lr has been modified so we need to emit
11771 .eh_frame info saying the return address is in r12. */
11775 /* The eh_frame info will consist of a DW_CFA_advance_loc or
11776 variant, DW_CFA_register, 65, 12, DW_CFA_advance_loc+2,
11777 DW_CFA_restore_extended 65. */
11781 }
11783 /* If the branch can't reach, use a plt_branch. */
11785 {
11789 }
11809 {
11812 else
11814 }
11820 {
11826 }
11829 {
11833 else
11837 }
11842 {
11843 /* After the bcl, lr has been modified so we need to emit
11844 .eh_frame info saying the return address is in r12. */
11848 /* The eh_frame info will consist of a DW_CFA_advance_loc or
11849 variant, DW_CFA_register, 65, 12, DW_CFA_advance_loc+2,
11850 DW_CFA_restore_extended 65. */
11854 }
11866 {
11869 else
11871 }
11879 {
11884 }
11887 {
11895 }
11904 {
11905 /* After the bctrl, lr has been modified so we need to
11906 emit .eh_frame info saying the return address is
11907 on the stack. In fact we put the EH info specifying
11908 that the return address is on the stack *at* the
11909 call rather than after it, because the EH info for a
11910 call needs to be specified by that point.
11911 See libgcc/unwind-dw2.c execute_cfa_program. */
11913 /* The eh_frame info will consist of a DW_CFA_advance_loc
11914 or variant, DW_CFA_offset_externed_sf, 65, -stackoff,
11915 DW_CFA_advance_loc+4, DW_CFA_restore_extended, 65. */
11919 }
11925 }
11929 }
11931 /* Set up various things so that we can make a list of input sections
11932 for each output section included in the link. Returns -1 on error,
11933 0 when no stubs will be needed, and 1 on success. */
11935 int
11937 {
11939 bfd_size_type amt;
11951 /* Set toc_off for com, und, abs and ind sections. */
11956 }
11958 /* Set up for first pass at multitoc partitioning. */
11960 void
11962 {
11968 }
11970 /* The linker repeatedly calls this function for each TOC input section
11971 and linker generated GOT section. Group input bfds such that the toc
11972 within a group is less than 64k in size. */
11974 bfd_boolean
11976 {
11984 {
11985 /* Keep track of the first .toc or .got section for this input bfd. */
11989 {
11992 }
12000 {
12005 }
12007 /* toc_curr is the base address of this toc group. Set elf_gp
12008 for the input section to be the offset relative to the
12009 output toc base plus 0x8000. Making the input elf_gp an
12010 offset allows us to move the toc as a whole without
12011 recalculating input elf_gp. */
12015 /* Die if someone uses a linker script that doesn't keep input
12016 file .toc and .got together. */
12024 }
12026 /* During the second pass toc_first_sec points to the start of
12027 a toc group, and toc_curr is used to track the old elf_gp.
12028 We use toc_bfd to ensure we only look at each bfd once. */
12035 {
12038 }
12045 }
12047 /* Called via elf_link_hash_traverse to merge GOT entries for global
12048 symbol H. */
12050 static bfd_boolean
12052 {
12059 }
12061 /* Called via elf_link_hash_traverse to allocate GOT entries for global
12062 symbol H. */
12064 static bfd_boolean
12066 {
12076 }
12078 /* Called on the first multitoc pass after the last call to
12079 ppc64_elf_next_toc_section. This function removes duplicate GOT
12080 entries. */
12082 bfd_boolean
12084 {
12087 bfd_boolean done_something;
12094 /* Merge global sym got entries within a toc group. */
12097 /* And tlsld_got. */
12099 {
12108 {
12110 {
12118 {
12121 }
12122 }
12123 }
12124 }
12126 /* Zap sizes of got sections. */
12132 {
12140 {
12146 }
12147 }
12149 /* Now reallocate the got, local syms first. We don't need to
12150 allocate section contents again since we never increase size. */
12152 {
12158 bfd_size_type locsymcount;
12177 {
12181 {
12187 {
12190 }
12193 {
12196 }
12200 {
12203 }
12204 }
12205 }
12206 }
12211 {
12220 {
12225 {
12228 }
12229 }
12230 }
12235 {
12243 {
12247 }
12248 }
12253 /* Set up for second pass over toc sections to recalculate elf_gp
12254 on input sections. */
12259 }
12261 /* Called after second pass of multitoc partitioning. */
12263 void
12265 {
12268 /* After the second pass, toc_curr tracks the TOC offset used
12269 for code sections below in ppc64_elf_next_input_section. */
12271 }
12273 /* No toc references were found in ISEC. If the code in ISEC makes no
12274 calls, then there's no need to use toc adjusting stubs when branching
12275 into ISEC. Actually, indirect calls from ISEC are OK as they will
12276 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
12277 needed, and 2 if a cyclical call-graph was found but no other reason
12278 for a stub was detected. If called from the top level, a return of
12279 2 means the same as a return of 0. */
12281 static int
12283 {
12286 /* Mark this section as checked. */
12289 /* We know none of our code bearing sections will need toc stubs. */
12301 {
12311 /* Look for branches to outside of this section. */
12318 {
12326 bfd_vma sym_value;
12327 bfd_vma dest;
12342 {
12345 }
12347 /* Calls to dynamic lib functions go through a plt call stub
12348 that uses r2. */
12354 {
12357 }
12360 /* Ignore other undefined symbols. */
12363 /* Assume branches to other sections not included in the
12364 link need stubs too, to cover -R and absolute syms. */
12366 {
12369 }
12373 else
12374 {
12379 }
12382 /* If this branch reloc uses an opd sym, find the code section. */
12385 {
12387 {
12392 /* Assume deleted functions won't ever be called. */
12395 }
12401 }
12402 else
12403 dest = (sym_value
12407 /* Ignore branch to self. */
12411 /* If the called function uses the toc, we need a stub. */
12414 {
12417 }
12419 /* Assume any branch that needs a long branch stub might in fact
12420 need a plt_branch stub. A plt_branch stub uses r2. */
12427 {
12430 }
12432 /* If calling back to a section in the process of being
12433 tested, we can't say for sure that no toc adjusting stubs
12434 are needed, so don't return zero. */
12438 /* Branches to another section that itself doesn't have any TOC
12439 references are OK. Recursively call ourselves to check. */
12441 {
12444 /* Mark current section as indeterminate, so that other
12445 sections that call back to current won't be marked as
12446 known. */
12452 {
12456 }
12457 }
12458 }
12466 }
12472 {
12477 {
12484 }
12485 }
12491 }
12493 /* The linker repeatedly calls this function for each input section,
12494 in the order that input sections are linked into output sections.
12495 Build lists of input sections to determine groupings between which
12496 we may insert linker stubs. */
12498 bfd_boolean
12500 {
12508 {
12509 /* This happens to make the list in reverse order,
12510 which is what we want. */
12514 }
12517 {
12518 /* Analyse sections that aren't already flagged as needing a
12519 valid toc pointer. Exclude .fixup for the linux kernel.
12520 .fixup contains branches, but only back to the function that
12521 hit an exception. */
12526 {
12529 }
12530 /* Make all sections use the TOC assigned for this object file.
12531 This will be wrong for pasted sections; We fix that in
12532 check_pasted_section(). */
12535 }
12539 }
12541 /* Check that all .init and .fini sections use the same toc, if they
12542 have toc relocs. */
12544 static bfd_boolean
12546 {
12550 {
12557 {
12562 }
12567 {
12570 }
12572 /* Make sure the whole pasted function uses the same toc offset. */
12576 }
12578 }
12580 bfd_boolean
12582 {
12585 }
12587 /* See whether we can group stub sections together. Grouping stub
12588 sections may result in fewer stubs. More importantly, we need to
12589 put all .init* and .fini* stubs at the beginning of the .init or
12590 .fini output sections respectively, because glibc splits the
12591 _init and _fini functions into multiple parts. Putting a stub in
12592 the middle of a function is not a good idea. */
12594 static bfd_boolean
12596 bfd_size_type stub_group_size,
12597 bfd_boolean stubs_always_before_branch)
12598 {
12601 bfd_boolean suppress_size_errors;
12609 {
12610 /* Default values. */
12613 else
12616 }
12619 {
12627 {
12630 bfd_size_type total;
12631 bfd_boolean big_sec;
12632 bfd_vma curr_toc;
12634 bfd_size_type group_size;
12644 /* xgettext:c-format */
12657 /* OK, the size from the start of CURR to the end is less
12658 than group_size and thus can be handled by one stub
12659 section. (or the tail section is itself larger than
12660 group_size, in which case we may be toast.) We should
12661 really be keeping track of the total size of stubs added
12662 here, as stubs contribute to the final output section
12663 size. That's a little tricky, and this way will only
12664 break if stubs added make the total size more than 2^25,
12665 ie. for the default stub_group_size, if stubs total more
12666 than 2097152 bytes, or nearly 75000 plt call stubs. */
12678 do
12679 {
12681 /* Set up this stub group. */
12683 }
12686 /* But wait, there's more! Input sections up to group_size
12687 bytes before the stub section can be handled by it too.
12688 Don't do this if we have a really large section after the
12689 stubs, as adding more stubs increases the chance that
12690 branches may not reach into the stub section. */
12692 {
12701 {
12705 }
12706 }
12708 }
12709 }
12711 }
12714 {
12725 };
12727 /* Stripping output sections is normally done before dynamic section
12728 symbols have been allocated. This function is called later, and
12729 handles cases like htab->brlt which is mapped to its own output
12730 section. */
12732 static void
12734 {
12741 {
12745 }
12746 }
12748 /* Determine and set the size of the stub section for a final link.
12750 The basic idea here is to examine all the relocations looking for
12751 PC-relative calls to a target that is unreachable with a "bl"
12752 instruction. */
12754 bfd_boolean
12756 {
12757 bfd_size_type stub_group_size;
12758 bfd_boolean stubs_always_before_branch;
12769 {
12771 {
12773 /* libstdc++ */
12775 /* librt */
12778 /* libanl */
12780 /* libgomp */
12793 /* libgo */
12795 };
12799 {
12806 }
12807 }
12811 else
12817 #define STUB_SHRINK_ITER 20
12818 /* Loop until no stubs added. After iteration 20 of this loop we may
12819 exit on a stub section shrinking. This is to break out of a
12820 pathological case where adding stubs on one iteration decreases
12821 section gaps (perhaps due to alignment), which then requires
12822 fewer or smaller stubs on the next iteration. */
12825 {
12835 {
12843 /* We'll need the symbol table in a second. */
12848 /* Walk over each section attached to the input bfd. */
12852 {
12855 /* If there aren't any relocs, then there's nothing more
12856 to do. */
12864 /* If this section is a link-once section that will be
12865 discarded, then don't create any stubs. */
12870 /* Get the relocs. */
12871 internal_relocs
12877 /* Now examine each relocation. */
12881 {
12888 bfd_vma destination;
12890 bfd_boolean ok_dest;
12904 {
12907 }
12909 /* Only look for stubs on branch instructions. */
12917 /* Now determine the call target, its name, value,
12918 section. */
12928 {
12933 }
12936 {
12940 }
12943 {
12944 /* Recognise an old ABI func code entry sym, and
12945 use the func descriptor sym instead if it is
12946 defined. */
12949 {
12953 {
12958 }
12959 else
12961 }
12962 }
12963 else
12964 {
12967 }
12972 {
12974 destination = (sym_value
12980 }
12986 {
12987 bfd_vma dest;
12990 {
12996 }
13000 {
13003 {
13004 /* Fixup old ABI sym to point at code
13005 entry. */
13009 }
13010 }
13011 }
13013 /* Determine what (if any) linker stub is needed. */
13017 local_off);
13020 {
13030 }
13032 {
13033 /* Check whether we need a TOC adjusting stub.
13034 Since the linker pastes together pieces from
13035 different object files when creating the
13036 _init and _fini functions, it may be that a
13037 call to what looks like a local sym is in
13038 fact a call needing a TOC adjustment. */
13049 }
13054 /* __tls_get_addr calls might be eliminated. */
13062 {
13063 /* Get tls info. */
13071 }
13074 {
13083 {
13087 }
13088 else
13090 }
13092 /* Support for grouping stub sections. */
13095 /* Get the name of this stub. */
13103 {
13105 /* A stub has already been created, but it may
13106 not be the required type. We shouldn't be
13107 transitioning from plt_call to long_branch
13108 stubs or vice versa, but we might be
13109 upgrading from plt_call to plt_call_r2save or
13110 from long_branch to long_branch_r2off. */
13114 {
13128 {
13131 }
13133 {
13136 }
13137 else
13145 old_type += (ppc_stub_long_branch
13147 /* Fall through. */
13155 {
13158 }
13160 {
13163 }
13164 else
13167 }
13171 }
13175 {
13177 error_ret_free_internal:
13180 error_ret_free_local:
13186 }
13191 {
13194 }
13195 else
13196 {
13199 }
13202 stub_entry->symtype
13210 }
13212 /* We're done with the internal relocs, free them. */
13215 }
13219 {
13222 else
13224 }
13225 }
13227 /* We may have added some stubs. Find out the new size of the
13228 stub sections. */
13230 {
13234 {
13239 /* Past STUB_SHRINK_ITER, rawsize is the max size seen. */
13244 }
13245 }
13264 {
13267 }
13272 {
13286 }
13291 {
13295 }
13312 /* Ask the linker to do its stuff. */
13314 }
13318 {
13319 bfd_vma val;
13324 /* It is necessary to at least have a rough outline of the
13325 linker generated CIEs and FDEs written before
13326 bfd_elf_discard_info is run, in order for these FDEs to be
13327 indexed in .eh_frame_hdr. */
13336 /* CIE length (rewrite in case little-endian). */
13343 {
13347 /* FDE length. */
13350 /* CIE pointer. */
13354 /* Offset to stub section, written later. */
13356 /* stub section size. */
13359 /* Augmentation. */
13361 /* Make sure we don't have all nops. This is enough for
13362 elf-eh-frame.c to detect the last non-nop opcode. */
13365 }
13367 {
13370 /* FDE length. */
13373 /* CIE pointer. */
13377 /* Offset to .glink, written later. */
13379 /* .glink size. */
13382 /* Augmentation. */
13393 }
13394 /* Subsume any padding into the last FDE if user .eh_frame
13395 sections are aligned more than glink_eh_frame. Otherwise any
13396 zero padding will be seen as a terminator. */
13402 }
13409 }
13411 /* Called after we have determined section placement. If sections
13412 move, we'll be called again. Provide a value for TOCstart. */
13414 bfd_vma
13416 {
13421 {
13428 else
13429 {
13433 }
13439 {
13445 }
13446 }
13448 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
13449 order. The TOC starts where the first of these sections starts. */
13458 {
13459 /* This may happen for
13460 o references to TOC base (SYM@toc / TOC[tc0]) without a
13461 .toc directive
13462 o bad linker script
13463 o --gc-sections and empty TOC sections
13465 FIXME: Warn user? */
13467 /* Look for a likely section. We probably won't even be
13468 using TOCstart. */
13488 }
13494 /* Force alignment. */
13500 {
13504 {
13506 {
13509 }
13510 }
13511 else
13512 {
13517 }
13518 }
13520 }
13522 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
13523 write out any global entry stubs, and PLT relocations. */
13525 static bfd_boolean
13527 {
13543 {
13544 /* This symbol has an entry in the procedure linkage
13545 table. Set it up. */
13546 Elf_Internal_Rela rela;
13552 {
13558 {
13564 else
13566 }
13567 else
13568 {
13571 {
13575 else
13577 }
13578 else
13580 }
13587 {
13591 {
13595 }
13596 }
13597 else
13598 {
13605 }
13606 }
13607 else
13608 {
13620 }
13621 }
13636 {
13639 bfd_vma off;
13645 {
13648 else
13650 }
13655 {
13661 }
13665 {
13677 {
13687 }
13688 }
13691 {
13694 }
13701 }
13703 }
13705 /* Write PLT relocs for locals. */
13707 static bfd_boolean
13709 {
13714 {
13718 bfd_size_type locsymcount;
13737 {
13742 bfd_vma val;
13746 {
13751 }
13760 {
13764 }
13765 else
13766 {
13769 }
13772 {
13776 {
13779 }
13780 }
13781 else
13782 {
13783 Elf_Internal_Rela rela;
13788 {
13791 else
13793 }
13794 else
13795 {
13798 else
13800 }
13805 }
13806 }
13810 {
13813 else
13815 }
13816 }
13818 }
13820 /* Build all the stubs associated with the current output file.
13821 The stubs are kept in a hash table attached to the main linker
13822 hash table. This function is called via gldelf64ppc_finish. */
13824 bfd_boolean
13827 {
13837 /* Allocate memory to hold the linker stubs. */
13839 {
13844 {
13850 }
13851 }
13854 {
13856 bfd_vma plt0;
13858 /* Build the .glink plt call stub. */
13860 {
13867 {
13877 }
13878 }
13883 {
13891 }
13897 {
13918 }
13919 else
13920 {
13947 }
13952 /* Build the .glink lazy link call stubs. */
13955 {
13957 {
13959 {
13962 }
13963 else
13964 {
13968 p);
13970 }
13971 }
13974 indx++;
13976 }
13977 }
13979 /* Build .glink global entry stubs, and PLT relocs for globals. */
13986 {
13991 }
13993 {
13998 }
14000 /* Build the stubs as directed by the stub hash table. */
14013 {
14016 }
14020 {
14025 {
14031 }
14032 }
14036 {
14037 bfd_vma val;
14045 {
14046 /* Offset to stub section. */
14053 {
14054 _bfd_error_handler
14058 }
14061 }
14063 {
14064 /* Offset to .glink. */
14072 {
14073 _bfd_error_handler
14077 }
14080 }
14081 }
14085 {
14091 }
14094 {
14097 }
14103 {
14112 stub_sec_count),
14113 stub_sec_count);
14140 }
14142 }
14144 /* What to do when ld finds relocations against symbols defined in
14145 discarded sections. */
14147 static unsigned int
14149 {
14160 }
14162 /* These are the dynamic relocations supported by glibc. */
14164 static bfd_boolean
14166 {
14168 {
14219 }
14220 }
14222 /* The RELOCATE_SECTION function is called by the ELF backend linker
14223 to handle the relocations for a section.
14225 The relocs are always passed as Rela structures; if the section
14226 actually uses Rel structures, the r_addend field will always be
14227 zero.
14229 This function is responsible for adjust the section contents as
14230 necessary, and (if using Rela relocs and generating a
14231 relocatable output file) adjusting the reloc addend as
14232 necessary.
14234 This function does not have to worry about setting the reloc
14235 address or the reloc symbol index.
14237 LOCAL_SYMS is a pointer to the swapped in local symbols.
14239 LOCAL_SECTIONS is an array giving the section in the input file
14240 corresponding to the st_shndx field of each local symbol.
14242 The global hash table entry for the global symbols can be found
14243 via elf_sym_hashes (input_bfd).
14245 When generating relocatable output, this function must handle
14246 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
14247 going to be the section symbol corresponding to the output
14248 section, which means that the addend must be adjusted
14249 accordingly. */
14251 static bfd_boolean
14260 {
14267 Elf_Internal_Rela outrel;
14270 bfd_vma TOCstart;
14272 bfd_boolean is_opd;
14273 /* Assume 'at' branch hints. */
14278 /* Initialize howto table if needed. */
14286 /* Don't relocate stub sections. */
14291 {
14294 }
14305 {
14307 bfd_vma addend;
14308 bfd_reloc_status_type r;
14316 bfd_vma toc_addend;
14319 bfd_vma relocation;
14321 bfd_boolean warned;
14326 bfd_vma max_br_offset;
14327 bfd_vma from;
14328 Elf_Internal_Rela orig_rel;
14332 bfd_vma offset;
14334 again:
14340 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
14341 symbol of the previous ADDR64 reloc. The symbol gives us the
14342 proper TOC base to use. */
14357 {
14358 /* It's a local symbol. */
14368 {
14373 else
14374 {
14375 /* If this is a relocation against the opd section sym
14376 and we have edited .opd, adjust the reloc addend so
14377 that ld -r and ld --emit-relocs output is correct.
14378 If it is a reloc against some other .opd symbol,
14379 then the symbol value will be adjusted later. */
14382 else
14384 }
14385 }
14386 }
14387 else
14388 {
14389 bfd_boolean ignored;
14400 {
14401 /* This is a symbol defined in a linker script. All
14402 such are defined in output sections, even those
14403 defined by simple assignment from a symbol defined in
14404 an input section. Transfer the symbol to an
14405 appropriate input .opd section, so that a branch to
14406 this symbol will be mapped to the location specified
14407 by the opd entry. */
14411 {
14416 {
14421 }
14422 }
14423 }
14424 }
14428 {
14436 /* For ld -r, remove relocations in debug sections against
14437 symbols defined in discarded sections. Not done for
14438 non-debug to preserve relocs in .eh_frame which the
14439 eh_frame editing code expects to be present. */
14442 wrel--;
14445 }
14451 {
14455 }
14457 /* TLS optimizations. Replace instruction sequences and relocs
14458 based on information we collected in tls_optimize. We edit
14459 RELOCS so that --emit-relocs will output something sensible
14460 for the final instruction stream. */
14467 {
14473 }
14478 {
14479 /* Check for toc tls entries. */
14488 }
14490 /* Check that tls relocs are used with tls syms, and non-tls
14491 relocs are used with non-tls syms. */
14498 {
14503 /* R_PPC64_TLS is OK against a symbol in the TOC. */
14504 ;
14505 else
14508 /* xgettext:c-format */
14510 /* xgettext:c-format */
14514 sym_name);
14515 }
14517 /* Ensure reloc mapping code below stays sane. */
14531 {
14549 {
14550 /* Check for toc tls entries. */
14560 {
14564 {
14568 }
14569 else
14570 {
14571 /* If we found a GD reloc pair, then we might be
14572 doing a GD->IE transition. */
14574 {
14579 }
14581 {
14585 }
14586 }
14587 }
14588 }
14595 {
14600 }
14607 {
14608 toctprel:
14617 {
14620 /* We changed the symbol. Start over in order to
14621 get h, sym, sec etc. right. */
14623 }
14624 else
14626 }
14632 {
14633 /* pld ra,sym@got@tprel@pcrel -> paddi ra,r13,sym@tprel */
14645 }
14651 {
14657 {
14659 /* Was PPC64_TLS which sits on insn boundary, now
14660 PPC64_TPREL16_LO which is at low-order half-word. */
14664 {
14667 /* We changed the symbol. Start over in order to
14668 get h, sym, sec etc. right. */
14670 }
14671 else
14673 }
14675 {
14676 /* For pcrel IE to LE we already have the full
14677 offset and thus don't need an addi here. A nop
14678 or mr will do. */
14680 {
14681 /* Extract regs from addi rt,ra,si. */
14686 else
14687 {
14688 /* Build or ra,rs,rb with rb==rs, ie. mr ra,rs. */
14691 }
14692 }
14694 }
14695 }
14708 {
14709 tls_gdld_hi:
14713 else
14714 {
14718 }
14720 }
14733 {
14736 tls_ldgd_opt:
14738 /* If not using the newer R_PPC64_TLSGD/LD to mark
14739 __tls_get_addr calls, we must trust that the call
14740 stays with its arg setup insns, ie. that the next
14741 reloc is the __tls_get_addr call associated with
14742 the current reloc. Edit both insns. */
14749 /* We read the low GOT_TLS (or TOC16) insn because we
14750 need to keep the destination reg. It may be
14751 something other than the usual r3, and moved to r3
14752 before the call by intervening code. */
14756 {
14757 /* IE */
14766 else
14770 }
14771 else
14772 {
14773 /* LE */
14778 {
14779 /* Was an LD reloc. */
14782 }
14784 {
14787 }
14791 {
14793 R_PPC64_TPREL16_LO);
14796 }
14797 }
14801 {
14804 {
14808 }
14809 }
14812 {
14813 /* We changed the symbol. Start over in order
14814 to get h, sym, sec etc. right. */
14816 }
14817 }
14822 {
14827 {
14828 /* IE, pla -> pld */
14831 }
14832 else
14833 {
14834 /* LE, pla pcrel -> paddi r13 */
14837 }
14843 }
14848 {
14862 }
14868 {
14874 {
14881 }
14887 {
14888 /* IE */
14891 }
14892 else
14893 {
14894 /* LE */
14896 {
14899 }
14902 {
14905 }
14906 else
14907 {
14911 }
14912 }
14914 /* Zap the reloc on the _tls_get_addr call too. */
14922 }
14928 {
14934 {
14941 }
14948 {
14951 }
14952 else
14953 {
14959 }
14961 /* Zap the reloc on the _tls_get_addr call too. */
14967 }
14974 {
14976 {
14980 else
14981 {
14984 }
14986 }
14987 }
14988 else
14989 {
14991 {
14995 }
14996 }
15001 {
15004 }
15012 {
15019 {
15026 }
15027 }
15028 else
15029 {
15034 {
15041 {
15048 }
15049 }
15050 }
15054 /* If we are generating a non-PIC executable, edit
15055 . 0: addis 2,12,.TOC.-0b@ha
15056 . addi 2,2,.TOC.-0b@l
15057 used by ELFv2 global entry points to set up r2, to
15058 . lis 2,.TOC.@ha
15059 . addi 2,2,.TOC.@l
15060 if .TOC. is in range. */
15071 {
15078 {
15085 }
15086 }
15088 }
15090 /* Handle other relocations that tweak non-addend part of insn. */
15096 {
15106 {
15113 }
15116 /* Branch taken prediction relocations. */
15120 /* Fall through. */
15122 /* Branch not taken prediction relocations. */
15127 /* Fall through. */
15131 /* Fall through. */
15137 /* Calls to functions with a different TOC, such as calls to
15138 shared objects, need to alter the TOC pointer. This is
15139 done using a linkage stub. A REL24 branching to these
15140 linkage stubs needs to be followed by a nop, as the nop
15141 will be replaced with an instruction to restore the TOC
15142 base pointer. */
15149 htab);
15164 {
15171 {
15172 /* The function doesn't use or change r2. */
15174 }
15176 {
15177 /* NOTOC calls don't need to restore r2. */
15179 }
15181 /* All of these stubs may modify r2, so there must be a
15182 branch and link followed by a nop. The nop is
15183 replaced by an insn to restore r2. */
15185 {
15191 {
15201 {
15206 {
15207 /* Special stub used, leave nop alone. */
15208 }
15209 else
15214 }
15215 }
15216 }
15219 {
15227 {
15228 /* Allow crt1 branch to go via a toc adjusting
15229 stub. Other calls that never return could do
15230 the same, if we could detect such. */
15232 }
15233 }
15236 {
15237 /* g++ as of 20130507 emits self-calls without a
15238 following nop. This is arguably wrong since we
15239 have conflicting information. On the one hand a
15240 global symbol and on the other a local call
15241 sequence, but don't error for this special case.
15242 It isn't possible to cheaply verify we have
15243 exactly such a call. Allow all calls to the same
15244 section. */
15248 {
15254 }
15257 }
15260 {
15264 /* xgettext:c-format */
15268 else
15270 /* xgettext:c-format */
15277 }
15283 }
15289 {
15290 /* The branch destination is the value of the opd entry. */
15296 {
15300 }
15301 }
15303 /* If the branch is out of reach we ought to have a long
15304 branch stub. */
15320 /* Don't use the stub if this branch is in range. */
15346 {
15347 /* Munge up the value and addend so that we call the stub
15348 rather than the procedure directly. */
15357 else
15386 }
15389 {
15391 {
15392 /* Set 'a' bit. This is 0b00010 in BO field for branch
15393 on CR(BI) insns (BO == 001at or 011at), and 0b01000
15394 for branch on CTR insns (BO == 1a00t or 1a01t). */
15399 else
15401 }
15402 else
15403 {
15404 /* Invert 'y' bit if not the default. */
15407 }
15410 }
15412 /* NOP out calls to undefined weak functions.
15413 We can thus call a weak function without first
15414 checking whether the function is defined. */
15422 {
15425 }
15432 {
15435 {
15440 }
15441 }
15449 {
15452 {
15457 }
15459 {
15462 }
15463 }
15472 {
15479 {
15480 /* Replace with paddi. */
15487 }
15488 }
15493 {
15501 {
15502 pcrelopt:
15506 {
15509 /* zero means next insn. */
15513 {
15515 bfd_signed_vma addend_off;
15519 {
15524 }
15526 {
15538 }
15539 }
15540 }
15541 }
15542 }
15544 }
15549 {
15551 /* xgettext:c-format */
15570 /* GOT16 relocations. Like an ADDR16 using the symbol's
15571 address in the GOT as relocation value instead of the
15572 symbol's value itself. Also, create a GOT entry for the
15573 symbol and put the symbol value there. */
15613 dogot:
15614 {
15615 /* Relocation is to the entry for this symbol in the global
15616 offset table. */
15619 bfd_vma off;
15626 else
15627 {
15629 {
15634 /* This is actually a static link, or it is a
15635 -Bsymbolic link and the symbol is defined
15636 locally, or the symbol was forced to be local
15637 because of a version file. */
15638 ;
15639 else
15640 {
15643 }
15645 }
15646 else
15647 {
15651 }
15658 }
15669 /* The offset must always be a multiple of 8. We use the
15670 least significant bit to record whether we have already
15671 processed this entry. */
15675 else
15676 {
15677 /* Generate relocs for the dynamic linker, except in
15678 the case of TLSLD where we'll use one entry per
15679 module. */
15681 bfd_boolean ifunc;
15689 {
15695 }
15705 {
15711 {
15715 {
15723 outrel.r_info
15725 }
15726 }
15733 else
15734 {
15737 else
15740 /* Write the .got section contents for the sake
15741 of prelink. */
15744 loc);
15745 }
15748 {
15751 {
15754 else
15756 }
15757 }
15762 }
15764 /* Init the .got section contents here if we're not
15765 emitting a reloc. */
15766 else
15767 {
15770 {
15773 else
15774 {
15777 else
15781 }
15784 {
15788 }
15789 }
15792 }
15793 }
15806 }
15821 /* Relocation is to the entry for this symbol in the
15822 procedure linkage table. */
15824 {
15829 {
15833 }
15835 {
15841 {
15843 bfd_vma got;
15849 {
15854 else
15856 }
15864 {
15868 }
15872 }
15873 }
15874 }
15878 /* Relocation value is TOC base. */
15883 ;
15886 else
15890 /* TOC16 relocs. We want the offset relative to the TOC base,
15891 which is the address of the start of the TOC plus 0x8000.
15892 The TOC consists of sections .got, .toc, .tocbss, and .plt,
15893 in this order. */
15905 /* Relocate against the beginning of the section. */
15956 {
15957 /* Make this relocation against an undefined weak symbol
15958 resolve to zero. This is really just a tweak, since
15959 code using weak externs ought to check that they are
15960 defined before using them. */
15968 }
15971 /* The TPREL16 relocs shouldn't really be used in shared
15972 libs or with non-local symbols as that will result in
15973 DT_TEXTREL being set, but support them anyway. */
16012 /* Fall through. */
16014 /* Relocations that may need to be propagated if this is a
16015 dynamic object. */
16049 dodyn:
16064 {
16067 bfd_vma out_off;
16070 /* When generating a dynamic object, these relocations
16071 are copied into the output file to be resolved at run
16072 time. */
16088 /* Optimize unaligned reloc use. */
16102 && !is_opd
16104 {
16108 }
16109 else
16110 {
16111 /* This symbol is local, or marked to become local,
16112 or this is an opd section reloc which must point
16113 at a local function. */
16116 {
16118 {
16119 /* Lie about opd entries. This case occurs
16120 when building shared libraries and we
16121 reference a function in another shared
16122 lib. The same thing happens for a weak
16123 definition in an application that's
16124 overridden by a strong definition in a
16125 shared lib. (I believe this is a generic
16126 bug in binutils handling of weak syms.)
16127 In these cases we won't use the opd
16128 entry in this lib. */
16130 }
16137 else
16138 {
16141 /* We need to relocate .opd contents for ld.so.
16142 Prelink also wants simple and consistent rules
16143 for relocs. This make all RELATIVE relocs have
16144 *r_offset equal to r_addend. */
16146 }
16147 }
16148 else
16149 {
16153 {
16155 /* xgettext:c-format */
16160 sym_name);
16162 }
16164 ;
16166 {
16169 }
16170 else
16171 {
16175 {
16176 /* TLS symbol values are relative to the
16177 TLS segment. Dynamic relocations for
16178 local TLS symbols therefore can't be
16179 reduced to a relocation against their
16180 section symbol because it holds the
16181 address of the section, not a value
16182 relative to the TLS segment. We could
16183 change the .tdata dynamic section symbol
16184 to be zero value but STN_UNDEF works
16185 and is used elsewhere, eg. for TPREL64
16186 GOT relocs against local TLS symbols. */
16189 }
16190 else
16191 {
16194 {
16198 else
16201 }
16203 }
16205 /* We are turning this relocation into one
16206 against a section symbol, so subtract out
16207 the output section's address but not the
16208 offset of the input section in the output
16209 section. */
16211 }
16214 }
16215 }
16221 {
16227 }
16240 {
16242 /* xgettext:c-format */
16245 input_bfd,
16247 sym_name);
16249 }
16251 /* If this reloc is against an external symbol, it will
16252 be computed at runtime, so there's no need to do
16253 anything now. However, for the sake of prelink ensure
16254 that the section contents are a known value. */
16256 {
16258 /* The value chosen here is quite arbitrary as ld.so
16259 ignores section contents except for the special
16260 case of .opd where the contents might be accessed
16261 before relocation. Choose zero, as that won't
16262 cause reloc overflow. */
16265 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
16266 to improve backward compatibility with older
16267 versions of ld. */
16270 /* Adjust pc_relative relocs to have zero in *r_offset. */
16273 }
16274 }
16282 /* We shouldn't ever see these dynamic relocs in relocatable
16283 files. */
16284 /* Fall through. */
16294 /* These ones haven't been implemented yet. */
16297 /* xgettext:c-format */
16299 input_bfd,
16305 }
16307 /* Multi-instruction sequences that access the TOC can be
16308 optimized, eg. addis ra,r2,0; addi rb,ra,x;
16309 to nop; addi rb,r2,x; */
16311 {
16321 /* These relocs would only be useful if building up an
16322 offset to later add to r2, perhaps in an indexed
16323 addressing mode instruction. Don't try to optimize.
16324 Unfortunately, the possibility of someone building up an
16325 offset like this or even with the HA relocs, means that
16326 we need to check the high insn when optimizing the low
16327 insn. */
16333 /* Fall through. */
16336 {
16337 /* No plt entry. Make this into a direct call. */
16346 }
16352 {
16355 }
16361 /* Fall through. */
16364 {
16370 }
16375 {
16378 }
16379 /* Fall through. */
16388 {
16390 nop_it:
16394 }
16400 {
16403 }
16404 /* Fall through. */
16415 {
16419 {
16420 /* Transform addic to addi when we change reg. */
16423 }
16424 else
16425 {
16428 }
16430 }
16435 {
16440 /* xgettext:c-format */
16445 else
16446 {
16449 }
16450 }
16456 {
16462 }
16464 }
16466 /* Do any further special processing. */
16468 {
16491 /* It's just possible that this symbol is a weak symbol
16492 that's not actually defined anywhere. In that case,
16493 'sec' would be NULL, and we should leave the symbol
16494 alone (it will be set to zero elsewhere in the link). */
16497 /* Fall through. */
16506 /* Add 0x10000 if sign bit in 0:15 is set.
16507 Bits 0:15 are not used. */
16541 /* If this reloc is against an lq, lxv, or stxv insn, then
16542 the value must be a multiple of 16. This is somewhat of
16543 a hack, but the "correct" way to do this by defining _DQ
16544 forms of all the _DS relocs bloats all reloc switches in
16545 this file. It doesn't make much sense to use these
16546 relocs in data, so testing the insn should be safe. */
16553 {
16556 /* xgettext:c-format */
16564 }
16566 }
16568 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
16569 because such sections are not SEC_ALLOC and thus ld.so will
16570 not process them. */
16577 {
16579 /* xgettext:c-format */
16585 }
16587 /* 16-bit fields in insns mostly have signed values, but a
16588 few insns have 16-bit unsigned values. Really, we should
16589 have different reloc types. */
16593 {
16608 {
16612 }
16613 }
16616 {
16617 /* Split field relocs aren't handled by _bfd_final_link_relocate. */
16636 else
16637 {
16659 }
16665 else
16666 {
16679 }
16686 }
16689 {
16694 {
16697 {
16702 }
16703 }
16706 {
16707 /* On code like "if (foo) foo();" don't report overflow
16708 on a branch to zero when foo is undefined. */
16720 }
16721 else
16722 {
16724 /* xgettext:c-format */
16729 }
16732 }
16733 copy_reloc:
16736 }
16739 {
16746 {
16747 /* It is too late to remove an empty reloc section. Leave
16748 one NONE reloc.
16749 ??? What is wrong with an empty section??? */
16752 }
16756 }
16758 /* If we're emitting relocations, then shortly after this function
16759 returns, reloc offsets and addends for this section will be
16760 adjusted. Worse, reloc symbol indices will be for the output
16761 file rather than the input. Save a copy of the relocs for
16762 opd_entry_value. */
16764 {
16765 bfd_size_type amt;
16773 }
16775 }
16777 /* Adjust the value of any local symbols in opd sections. */
16779 static int
16785 {
16788 bfd_vma value;
16807 }
16809 /* Finish up dynamic symbol handling. We set the contents of various
16810 dynamic sections here. */
16812 static bfd_boolean
16817 {
16828 {
16829 /* Mark the symbol as undefined, rather than as
16830 defined in glink. Leave the value if there were
16831 any relocations where pointer equality matters
16832 (this is a clue for the dynamic linker, to make
16833 function pointer comparisons work between an
16834 application and shared library), otherwise set it
16835 to zero. */
16840 {
16841 /* This breaks function pointer comparisons, but
16842 that is better than breaking tests for a NULL
16843 function pointer. */
16845 }
16847 }
16854 {
16855 /* This symbol needs a copy reloc. Set it up. */
16856 Elf_Internal_Rela rela;
16870 else
16875 }
16878 }
16880 /* Used to decide how to sort relocs in an optimal manner for the
16881 dynamic linker, before writing them out. */
16883 static enum elf_reloc_type_class
16887 {
16896 {
16905 }
16906 }
16908 /* Finish up the dynamic sections. */
16910 static bfd_boolean
16913 {
16926 {
16935 {
16936 Elf_Internal_Dyn dyn;
16942 {
16949 /* We stupidly defined DT_PPC64_GLINK to be the start
16950 of glink rather than the first entry point, which is
16951 what ld.so needs, and now have a bigger stub to
16952 support automatic multiple TOCs. */
17002 }
17005 }
17006 }
17010 {
17011 /* Fill in the first entry in the global offset table.
17012 We use it to hold the link-time TOCbase. */
17017 /* Set .got entry size. */
17020 }
17024 {
17025 /* Set .plt entry size. */
17028 }
17030 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
17031 brlt ourselves if emitrelocations. */
17038 NULL))
17047 NULL))
17059 /* We need to handle writing out multiple GOT sections ourselves,
17060 since we didn't add them to DYNOBJ. We know dynobj is the first
17061 bfd. */
17063 {
17085 }
17088 }
17092 /* FreeBSD support */
17094 #undef TARGET_LITTLE_SYM
17095 #undef TARGET_LITTLE_NAME
17097 #undef TARGET_BIG_SYM
17098 #define TARGET_BIG_SYM powerpc_elf64_fbsd_vec
17099 #undef TARGET_BIG_NAME
17102 #undef ELF_OSABI
17103 #define ELF_OSABI ELFOSABI_FREEBSD
17105 #undef elf64_bed
17106 #define elf64_bed elf64_powerpc_fbsd_bed