| blob | 157c454d854116081e944a31809ed2fcefc75754 |
1 /* PowerPC64-specific support for 64-bit ELF.
2 Copyright (C) 1999-2020 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 /* All users of this file have bfd_octets_per_byte (abfd, sec) == 1. */
39 #define OCTETS_PER_BYTE(ABFD, SEC) 1
41 static bfd_reloc_status_type ppc64_elf_ha_reloc
43 static bfd_reloc_status_type ppc64_elf_branch_reloc
45 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
47 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
49 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
51 static bfd_reloc_status_type ppc64_elf_toc_reloc
53 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
55 static bfd_reloc_status_type ppc64_elf_toc64_reloc
57 static bfd_reloc_status_type ppc64_elf_prefix_reloc
59 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
61 static bfd_vma opd_entry_value
64 #define TARGET_LITTLE_SYM powerpc_elf64_le_vec
66 #define TARGET_BIG_SYM powerpc_elf64_vec
68 #define ELF_ARCH bfd_arch_powerpc
69 #define ELF_TARGET_ID PPC64_ELF_DATA
70 #define ELF_MACHINE_CODE EM_PPC64
71 #define ELF_MAXPAGESIZE 0x10000
72 #define ELF_COMMONPAGESIZE 0x1000
73 #define ELF_RELROPAGESIZE ELF_MAXPAGESIZE
74 #define elf_info_to_howto ppc64_elf_info_to_howto
76 #define elf_backend_want_got_sym 0
77 #define elf_backend_want_plt_sym 0
78 #define elf_backend_plt_alignment 3
79 #define elf_backend_plt_not_loaded 1
80 #define elf_backend_got_header_size 8
81 #define elf_backend_want_dynrelro 1
82 #define elf_backend_can_gc_sections 1
83 #define elf_backend_can_refcount 1
84 #define elf_backend_rela_normal 1
85 #define elf_backend_dtrel_excludes_plt 1
86 #define elf_backend_default_execstack 0
88 #define bfd_elf64_mkobject ppc64_elf_mkobject
89 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
90 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
91 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
92 #define bfd_elf64_bfd_print_private_bfd_data ppc64_elf_print_private_bfd_data
93 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
94 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
95 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
96 #define bfd_elf64_bfd_link_just_syms ppc64_elf_link_just_syms
97 #define bfd_elf64_bfd_gc_sections ppc64_elf_gc_sections
99 #define elf_backend_object_p ppc64_elf_object_p
100 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
101 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
102 #define elf_backend_write_core_note ppc64_elf_write_core_note
103 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
104 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
105 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
106 #define elf_backend_check_directives ppc64_elf_before_check_relocs
107 #define elf_backend_notice_as_needed ppc64_elf_notice_as_needed
108 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
109 #define elf_backend_check_relocs ppc64_elf_check_relocs
110 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
111 #define elf_backend_gc_keep ppc64_elf_gc_keep
112 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
113 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
114 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
115 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
116 #define elf_backend_maybe_function_sym ppc64_elf_maybe_function_sym
117 #define elf_backend_always_size_sections ppc64_elf_edit
118 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
119 #define elf_backend_hash_symbol ppc64_elf_hash_symbol
120 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
121 #define elf_backend_action_discarded ppc64_elf_action_discarded
122 #define elf_backend_relocate_section ppc64_elf_relocate_section
123 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
124 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
125 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
126 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
127 #define elf_backend_special_sections ppc64_elf_special_sections
128 #define elf_backend_section_flags ppc64_elf_section_flags
129 #define elf_backend_merge_symbol_attribute ppc64_elf_merge_symbol_attribute
130 #define elf_backend_merge_symbol ppc64_elf_merge_symbol
131 #define elf_backend_get_reloc_section bfd_get_section_by_name
133 /* The name of the dynamic interpreter. This is put in the .interp
134 section. */
137 /* The size in bytes of an entry in the procedure linkage table. */
138 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
139 #define LOCAL_PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 16 : 8)
141 /* The initial size of the plt reserved for the dynamic linker. */
142 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
144 /* Offsets to some stack save slots. */
145 #define STK_LR 16
146 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
147 /* This one is dodgy. ELFv2 does not have a linker word, so use the
148 CR save slot. Used only by optimised __tls_get_addr call stub,
149 relying on __tls_get_addr_opt not saving CR.. */
150 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
152 /* TOC base pointers offset from start of TOC. */
153 #define TOC_BASE_OFF 0x8000
154 /* TOC base alignment. */
155 #define TOC_BASE_ALIGN 256
157 /* Offset of tp and dtp pointers from start of TLS block. */
158 #define TP_OFFSET 0x7000
159 #define DTP_OFFSET 0x8000
161 /* .plt call stub instructions. The normal stub is like this, but
162 sometimes the .plt entry crosses a 64k boundary and we need to
163 insert an addi to adjust r11. */
210 #define PADDI_R12_PC 0x0610000039800000ULL
211 #define PLD_R12_PC 0x04100000e5800000ULL
212 #define PNOP 0x0700000000000000ULL
214 /* __glink_PLTresolve stub instructions. We enter with the index in
215 R0 for ELFv1, and the address of a glink branch in R12 for ELFv2. */
216 #define GLINK_PLTRESOLVE_SIZE(htab) \
217 (8u + (htab->opd_abi ? 11 * 4 : htab->has_plt_localentry0 ? 14 * 4 : 13 * 4))
218 /* 0: */
219 /* .quad plt0-1f */
220 /* __glink: */
223 /* 1: */
225 /* ld %2,(0b-1b)(%11) */
228 /* ld %12,0(%11) */
229 /* ld %2,8(%11) */
230 /* mtctr %12 */
231 /* ld %11,16(%11) */
232 /* bctr */
242 /* Pad with this. */
243 #define NOP 0x60000000
245 /* Some other nops. */
246 #define CROR_151515 0x4def7b82
247 #define CROR_313131 0x4ffffb82
249 /* .glink entries for the first 32k functions are two instructions. */
253 /* After that, we need two instructions to load the index, followed by
254 a branch. */
258 /* Instructions used by the save and restore reg functions. */
271 /* Since .opd is an array of descriptors and each entry will end up
272 with identical R_PPC64_RELATIVE relocs, there is really no need to
273 propagate .opd relocs; The dynamic linker should be taught to
274 relocate .opd without reloc entries. */
275 #ifndef NO_OPD_RELOCS
276 #define NO_OPD_RELOCS 0
277 #endif
279 #ifndef ARRAY_SIZE
280 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
281 #endif
285 {
287 }
291 {
294 }
295 \f
296 /* Relocation HOWTO's. */
297 /* Like other ELF RELA targets that don't apply multiple
298 field-altering relocations to the same localation, src_mask is
299 always zero and pcrel_offset is the same as pc_relative.
300 PowerPC can always use a zero bitpos, even when the field is not at
301 the LSB. For example, a REL24 could use rightshift=2, bisize=24
302 and bitpos=2 which matches the ABI description, or as we do here,
303 rightshift=0, bitsize=26 and bitpos=0. */
304 #define HOW(type, size, bitsize, mask, rightshift, pc_relative, \
305 complain, special_func) \
306 HOWTO (type, rightshift, size, bitsize, pc_relative, 0, \
307 complain_overflow_ ## complain, special_func, \
308 #type, FALSE, 0, mask, pc_relative)
313 {
314 /* This reloc does nothing. */
316 bfd_elf_generic_reloc),
318 /* A standard 32 bit relocation. */
320 bfd_elf_generic_reloc),
322 /* An absolute 26 bit branch; the lower two bits must be zero.
323 FIXME: we don't check that, we just clear them. */
325 bfd_elf_generic_reloc),
327 /* A standard 16 bit relocation. */
329 bfd_elf_generic_reloc),
331 /* A 16 bit relocation without overflow. */
333 bfd_elf_generic_reloc),
335 /* Bits 16-31 of an address. */
337 bfd_elf_generic_reloc),
339 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
340 bits, treated as a signed number, is negative. */
342 ppc64_elf_ha_reloc),
344 /* An absolute 16 bit branch; the lower two bits must be zero.
345 FIXME: we don't check that, we just clear them. */
347 ppc64_elf_branch_reloc),
349 /* An absolute 16 bit branch, for which bit 10 should be set to
350 indicate that the branch is expected to be taken. The lower two
351 bits must be zero. */
353 ppc64_elf_brtaken_reloc),
355 /* An absolute 16 bit branch, for which bit 10 should be set to
356 indicate that the branch is not expected to be taken. The lower
357 two bits must be zero. */
359 ppc64_elf_brtaken_reloc),
361 /* A relative 26 bit branch; the lower two bits must be zero. */
363 ppc64_elf_branch_reloc),
365 /* A variant of R_PPC64_REL24, used when r2 is not the toc pointer. */
367 ppc64_elf_branch_reloc),
369 /* A relative 16 bit branch; the lower two bits must be zero. */
371 ppc64_elf_branch_reloc),
373 /* A relative 16 bit branch. Bit 10 should be set to indicate that
374 the branch is expected to be taken. The lower two bits must be
375 zero. */
377 ppc64_elf_brtaken_reloc),
379 /* A relative 16 bit branch. Bit 10 should be set to indicate that
380 the branch is not expected to be taken. The lower two bits must
381 be zero. */
383 ppc64_elf_brtaken_reloc),
385 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
386 symbol. */
388 ppc64_elf_unhandled_reloc),
390 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
391 the symbol. */
393 ppc64_elf_unhandled_reloc),
395 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
396 the symbol. */
398 ppc64_elf_unhandled_reloc),
400 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
401 the symbol. */
403 ppc64_elf_unhandled_reloc),
405 /* This is used only by the dynamic linker. The symbol should exist
406 both in the object being run and in some shared library. The
407 dynamic linker copies the data addressed by the symbol from the
408 shared library into the object, because the object being
409 run has to have the data at some particular address. */
411 ppc64_elf_unhandled_reloc),
413 /* Like R_PPC64_ADDR64, but used when setting global offset table
414 entries. */
416 ppc64_elf_unhandled_reloc),
418 /* Created by the link editor. Marks a procedure linkage table
419 entry for a symbol. */
421 ppc64_elf_unhandled_reloc),
423 /* Used only by the dynamic linker. When the object is run, this
424 doubleword64 is set to the load address of the object, plus the
425 addend. */
427 bfd_elf_generic_reloc),
429 /* Like R_PPC64_ADDR32, but may be unaligned. */
431 bfd_elf_generic_reloc),
433 /* Like R_PPC64_ADDR16, but may be unaligned. */
435 bfd_elf_generic_reloc),
437 /* 32-bit PC relative. */
439 bfd_elf_generic_reloc),
441 /* 32-bit relocation to the symbol's procedure linkage table. */
443 ppc64_elf_unhandled_reloc),
445 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
446 FIXME: R_PPC64_PLTREL32 not supported. */
448 ppc64_elf_unhandled_reloc),
450 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
451 the symbol. */
453 ppc64_elf_unhandled_reloc),
455 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
456 the symbol. */
458 ppc64_elf_unhandled_reloc),
460 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
461 the symbol. */
463 ppc64_elf_unhandled_reloc),
465 /* 16-bit section relative relocation. */
467 ppc64_elf_sectoff_reloc),
469 /* Like R_PPC64_SECTOFF, but no overflow warning. */
471 ppc64_elf_sectoff_reloc),
473 /* 16-bit upper half section relative relocation. */
475 ppc64_elf_sectoff_reloc),
477 /* 16-bit upper half adjusted section relative relocation. */
479 ppc64_elf_sectoff_ha_reloc),
481 /* Like R_PPC64_REL24 without touching the two least significant bits. */
483 bfd_elf_generic_reloc),
485 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
487 /* A standard 64-bit relocation. */
489 bfd_elf_generic_reloc),
491 /* The bits 32-47 of an address. */
493 bfd_elf_generic_reloc),
495 /* The bits 32-47 of an address, plus 1 if the contents of the low
496 16 bits, treated as a signed number, is negative. */
498 ppc64_elf_ha_reloc),
500 /* The bits 48-63 of an address. */
502 bfd_elf_generic_reloc),
504 /* The bits 48-63 of an address, plus 1 if the contents of the low
505 16 bits, treated as a signed number, is negative. */
507 ppc64_elf_ha_reloc),
509 /* Like ADDR64, but may be unaligned. */
511 bfd_elf_generic_reloc),
513 /* 64-bit relative relocation. */
515 bfd_elf_generic_reloc),
517 /* 64-bit relocation to the symbol's procedure linkage table. */
519 ppc64_elf_unhandled_reloc),
521 /* 64-bit PC relative relocation to the symbol's procedure linkage
522 table. */
523 /* FIXME: R_PPC64_PLTREL64 not supported. */
525 ppc64_elf_unhandled_reloc),
527 /* 16 bit TOC-relative relocation. */
528 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
530 ppc64_elf_toc_reloc),
532 /* 16 bit TOC-relative relocation without overflow. */
533 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
535 ppc64_elf_toc_reloc),
537 /* 16 bit TOC-relative relocation, high 16 bits. */
538 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
540 ppc64_elf_toc_reloc),
542 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
543 contents of the low 16 bits, treated as a signed number, is
544 negative. */
545 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
547 ppc64_elf_toc_ha_reloc),
549 /* 64-bit relocation; insert value of TOC base (.TOC.). */
550 /* R_PPC64_TOC 51 doubleword64 .TOC. */
552 ppc64_elf_toc64_reloc),
554 /* Like R_PPC64_GOT16, but also informs the link editor that the
555 value to relocate may (!) refer to a PLT entry which the link
556 editor (a) may replace with the symbol value. If the link editor
557 is unable to fully resolve the symbol, it may (b) create a PLT
558 entry and store the address to the new PLT entry in the GOT.
559 This permits lazy resolution of function symbols at run time.
560 The link editor may also skip all of this and just (c) emit a
561 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
562 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
564 ppc64_elf_unhandled_reloc),
566 /* Like R_PPC64_PLTGOT16, but without overflow. */
567 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
569 ppc64_elf_unhandled_reloc),
571 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
572 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
574 ppc64_elf_unhandled_reloc),
576 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
577 1 if the contents of the low 16 bits, treated as a signed number,
578 is negative. */
579 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
581 ppc64_elf_unhandled_reloc),
583 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
585 bfd_elf_generic_reloc),
587 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
589 bfd_elf_generic_reloc),
591 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
593 ppc64_elf_unhandled_reloc),
595 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
597 ppc64_elf_unhandled_reloc),
599 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
601 ppc64_elf_unhandled_reloc),
603 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
605 ppc64_elf_sectoff_reloc),
607 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
609 ppc64_elf_sectoff_reloc),
611 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
613 ppc64_elf_toc_reloc),
615 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
617 ppc64_elf_toc_reloc),
619 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
620 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
622 ppc64_elf_unhandled_reloc),
624 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
625 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
627 ppc64_elf_unhandled_reloc),
629 /* Marker relocs for TLS. */
631 bfd_elf_generic_reloc),
634 bfd_elf_generic_reloc),
637 bfd_elf_generic_reloc),
639 /* Marker reloc for optimizing r2 save in prologue rather than on
640 each plt call stub. */
642 bfd_elf_generic_reloc),
644 /* Marker relocs on inline plt call instructions. */
646 bfd_elf_generic_reloc),
649 bfd_elf_generic_reloc),
651 /* Computes the load module index of the load module that contains the
652 definition of its TLS sym. */
654 ppc64_elf_unhandled_reloc),
656 /* Computes a dtv-relative displacement, the difference between the value
657 of sym+add and the base address of the thread-local storage block that
658 contains the definition of sym, minus 0x8000. */
660 ppc64_elf_unhandled_reloc),
662 /* A 16 bit dtprel reloc. */
664 ppc64_elf_unhandled_reloc),
666 /* Like DTPREL16, but no overflow. */
668 ppc64_elf_unhandled_reloc),
670 /* Like DTPREL16_LO, but next higher group of 16 bits. */
672 ppc64_elf_unhandled_reloc),
674 /* Like DTPREL16_HI, but adjust for low 16 bits. */
676 ppc64_elf_unhandled_reloc),
678 /* Like DTPREL16_HI, but next higher group of 16 bits. */
680 ppc64_elf_unhandled_reloc),
682 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
684 ppc64_elf_unhandled_reloc),
686 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
688 ppc64_elf_unhandled_reloc),
690 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
692 ppc64_elf_unhandled_reloc),
694 /* Like DTPREL16, but for insns with a DS field. */
696 ppc64_elf_unhandled_reloc),
698 /* Like DTPREL16_DS, but no overflow. */
700 ppc64_elf_unhandled_reloc),
702 /* Computes a tp-relative displacement, the difference between the value of
703 sym+add and the value of the thread pointer (r13). */
705 ppc64_elf_unhandled_reloc),
707 /* A 16 bit tprel reloc. */
709 ppc64_elf_unhandled_reloc),
711 /* Like TPREL16, but no overflow. */
713 ppc64_elf_unhandled_reloc),
715 /* Like TPREL16_LO, but next higher group of 16 bits. */
717 ppc64_elf_unhandled_reloc),
719 /* Like TPREL16_HI, but adjust for low 16 bits. */
721 ppc64_elf_unhandled_reloc),
723 /* Like TPREL16_HI, but next higher group of 16 bits. */
725 ppc64_elf_unhandled_reloc),
727 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
729 ppc64_elf_unhandled_reloc),
731 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
733 ppc64_elf_unhandled_reloc),
735 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
737 ppc64_elf_unhandled_reloc),
739 /* Like TPREL16, but for insns with a DS field. */
741 ppc64_elf_unhandled_reloc),
743 /* Like TPREL16_DS, but no overflow. */
745 ppc64_elf_unhandled_reloc),
747 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
748 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
749 to the first entry relative to the TOC base (r2). */
751 ppc64_elf_unhandled_reloc),
753 /* Like GOT_TLSGD16, but no overflow. */
755 ppc64_elf_unhandled_reloc),
757 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
759 ppc64_elf_unhandled_reloc),
761 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
763 ppc64_elf_unhandled_reloc),
765 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
766 with values (sym+add)@dtpmod and zero, and computes the offset to the
767 first entry relative to the TOC base (r2). */
769 ppc64_elf_unhandled_reloc),
771 /* Like GOT_TLSLD16, but no overflow. */
773 ppc64_elf_unhandled_reloc),
775 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
777 ppc64_elf_unhandled_reloc),
779 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
781 ppc64_elf_unhandled_reloc),
783 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
784 the offset to the entry relative to the TOC base (r2). */
786 ppc64_elf_unhandled_reloc),
788 /* Like GOT_DTPREL16_DS, but no overflow. */
790 ppc64_elf_unhandled_reloc),
792 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
794 ppc64_elf_unhandled_reloc),
796 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
798 ppc64_elf_unhandled_reloc),
800 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
801 offset to the entry relative to the TOC base (r2). */
803 ppc64_elf_unhandled_reloc),
805 /* Like GOT_TPREL16_DS, but no overflow. */
807 ppc64_elf_unhandled_reloc),
809 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
811 ppc64_elf_unhandled_reloc),
813 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
815 ppc64_elf_unhandled_reloc),
818 ppc64_elf_unhandled_reloc),
821 bfd_elf_generic_reloc),
823 /* A 16 bit relative relocation. */
825 bfd_elf_generic_reloc),
827 /* A 16 bit relative relocation without overflow. */
829 bfd_elf_generic_reloc),
831 /* The high order 16 bits of a relative address. */
833 bfd_elf_generic_reloc),
835 /* The high order 16 bits of a relative address, plus 1 if the contents of
836 the low 16 bits, treated as a signed number, is negative. */
838 ppc64_elf_ha_reloc),
841 bfd_elf_generic_reloc),
844 ppc64_elf_ha_reloc),
847 bfd_elf_generic_reloc),
850 ppc64_elf_ha_reloc),
853 bfd_elf_generic_reloc),
856 ppc64_elf_ha_reloc),
858 /* Like R_PPC64_REL16_HA but for split field in addpcis. */
860 ppc64_elf_ha_reloc),
862 /* A split-field reloc for addpcis, non-relative (gas internal use only). */
864 ppc64_elf_ha_reloc),
866 /* Like R_PPC64_ADDR16_HI, but no overflow. */
868 bfd_elf_generic_reloc),
870 /* Like R_PPC64_ADDR16_HA, but no overflow. */
872 ppc64_elf_ha_reloc),
874 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
876 ppc64_elf_unhandled_reloc),
878 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
880 ppc64_elf_unhandled_reloc),
882 /* Like R_PPC64_TPREL16_HI, but no overflow. */
884 ppc64_elf_unhandled_reloc),
886 /* Like R_PPC64_TPREL16_HA, but no overflow. */
888 ppc64_elf_unhandled_reloc),
890 /* Marker reloc on ELFv2 large-model function entry. */
892 bfd_elf_generic_reloc),
894 /* Like ADDR64, but use local entry point of function. */
896 bfd_elf_generic_reloc),
899 bfd_elf_generic_reloc),
902 bfd_elf_generic_reloc),
905 bfd_elf_generic_reloc),
908 ppc64_elf_prefix_reloc),
911 ppc64_elf_prefix_reloc),
914 ppc64_elf_prefix_reloc),
917 ppc64_elf_prefix_reloc),
920 ppc64_elf_prefix_reloc),
923 ppc64_elf_unhandled_reloc),
926 ppc64_elf_unhandled_reloc),
929 ppc64_elf_unhandled_reloc),
932 ppc64_elf_unhandled_reloc),
935 ppc64_elf_unhandled_reloc),
938 ppc64_elf_unhandled_reloc),
941 ppc64_elf_unhandled_reloc),
944 ppc64_elf_unhandled_reloc),
947 ppc64_elf_unhandled_reloc),
950 bfd_elf_generic_reloc),
953 ppc64_elf_ha_reloc),
956 bfd_elf_generic_reloc),
959 ppc64_elf_ha_reloc),
962 bfd_elf_generic_reloc),
965 ppc64_elf_ha_reloc),
968 bfd_elf_generic_reloc),
971 ppc64_elf_ha_reloc),
974 ppc64_elf_prefix_reloc),
977 ppc64_elf_prefix_reloc),
979 /* GNU extension to record C++ vtable hierarchy. */
981 NULL),
983 /* GNU extension to record C++ vtable member usage. */
985 NULL),
986 };
988 \f
989 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
990 be done. */
992 static void
994 {
998 {
1002 }
1003 }
1007 {
1011 /* Initialize howto table if needed. */
1015 {
1017 /* xgettext:c-format */
1318 }
1321 };
1325 {
1332 };
1339 /* Handle old names of relocations in case they were used by
1340 .reloc directives.
1341 FIXME: Remove this soon. Mapping the reloc names is very likely
1342 completely unnecessary. */
1345 {
1349 }
1352 }
1354 /* Set the howto pointer for a PowerPC ELF reloc. */
1356 static bfd_boolean
1359 {
1362 /* Initialize howto table if needed. */
1368 {
1369 /* xgettext:c-format */
1374 }
1377 {
1378 /* xgettext:c-format */
1383 }
1386 }
1388 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
1390 static bfd_reloc_status_type
1394 {
1397 bfd_size_type octets;
1398 bfd_vma value;
1400 /* If this is a relocatable link (output_bfd test tells us), just
1401 call the generic function. Any adjustment will be done at final
1402 link time. */
1407 /* Adjust the addend for sign extension of the low 16 (or 34) bits.
1408 We won't actually be using the low bits, so trashing them
1409 doesn't matter. */
1416 else
1440 }
1442 static bfd_reloc_status_type
1446 {
1453 {
1461 }
1462 else
1463 {
1469 {
1473 {
1477 {
1480 }
1481 }
1482 }
1483 reloc_entry->addend
1485 }
1487 }
1489 static bfd_reloc_status_type
1493 {
1496 bfd_size_type octets;
1497 /* Assume 'at' branch hints. */
1500 /* If this is a relocatable link (output_bfd test tells us), just
1501 call the generic function. Any adjustment will be done at final
1502 link time. */
1516 {
1517 /* Set 'a' bit. This is 0b00010 in BO field for branch
1518 on CR(BI) insns (BO == 001at or 011at), and 0b01000
1519 for branch on CTR insns (BO == 1a00t or 1a01t). */
1524 else
1526 }
1527 else
1528 {
1530 bfd_vma from;
1542 /* Invert 'y' bit if not the default. */
1545 }
1547 out:
1550 }
1552 static bfd_reloc_status_type
1556 {
1557 /* If this is a relocatable link (output_bfd test tells us), just
1558 call the generic function. Any adjustment will be done at final
1559 link time. */
1564 /* Subtract the symbol section base address. */
1567 }
1569 static bfd_reloc_status_type
1573 {
1574 /* If this is a relocatable link (output_bfd test tells us), just
1575 call the generic function. Any adjustment will be done at final
1576 link time. */
1581 /* Subtract the symbol section base address. */
1584 /* Adjust the addend for sign extension of the low 16 bits. */
1587 }
1589 static bfd_reloc_status_type
1593 {
1594 bfd_vma TOCstart;
1596 /* If this is a relocatable link (output_bfd test tells us), just
1597 call the generic function. Any adjustment will be done at final
1598 link time. */
1607 /* Subtract the TOC base address. */
1610 }
1612 static bfd_reloc_status_type
1616 {
1617 bfd_vma TOCstart;
1619 /* If this is a relocatable link (output_bfd test tells us), just
1620 call the generic function. Any adjustment will be done at final
1621 link time. */
1630 /* Subtract the TOC base address. */
1633 /* Adjust the addend for sign extension of the low 16 bits. */
1636 }
1638 static bfd_reloc_status_type
1642 {
1643 bfd_vma TOCstart;
1644 bfd_size_type octets;
1646 /* If this is a relocatable link (output_bfd test tells us), just
1647 call the generic function. Any adjustment will be done at final
1648 link time. */
1660 }
1662 static bfd_reloc_status_type
1666 {
1668 bfd_vma targ;
1686 {
1691 }
1702 }
1704 static bfd_reloc_status_type
1708 {
1709 /* If this is a relocatable link (output_bfd test tells us), just
1710 call the generic function. Any adjustment will be done at final
1711 link time. */
1717 {
1722 }
1724 }
1726 /* Track GOT entries needed for a given symbol. We might need more
1727 than one got entry per symbol. */
1728 struct got_entry
1729 {
1732 /* The symbol addend that we'll be placing in the GOT. */
1733 bfd_vma addend;
1735 /* Unlike other ELF targets, we use separate GOT entries for the same
1736 symbol referenced from different input files. This is to support
1737 automatic multiple TOC/GOT sections, where the TOC base can vary
1738 from one input file to another. After partitioning into TOC groups
1739 we merge entries within the group.
1741 Point to the BFD owning this GOT entry. */
1744 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
1745 TLS_TPREL or TLS_DTPREL for tls entries. */
1748 /* Non-zero if got.ent points to real entry. */
1751 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
1752 union
1753 {
1754 bfd_signed_vma refcount;
1755 bfd_vma offset;
1758 };
1760 /* The same for PLT. */
1761 struct plt_entry
1762 {
1765 bfd_vma addend;
1767 union
1768 {
1769 bfd_signed_vma refcount;
1770 bfd_vma offset;
1772 };
1774 struct ppc64_elf_obj_tdata
1775 {
1778 /* Shortcuts to dynamic linker sections. */
1782 /* Used during garbage collection. We attach global symbols defined
1783 on removed .opd entries to this section so that the sym is removed. */
1786 /* TLS local dynamic got entry handling. Support for multiple GOT
1787 sections means we potentially need one of these for each input bfd. */
1790 union
1791 {
1792 /* A copy of relocs before they are modified for --emit-relocs. */
1795 /* Section contents. */
1799 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
1800 the reloc to be in the range -32768 to 32767. */
1803 /* Set if toc/got ha relocs detected not using r2, or lo reloc
1804 instruction not one we handle. */
1807 /* Set if PLT/GOT/TOC relocs that can be optimised are present in
1808 this file. */
1810 };
1812 #define ppc64_elf_tdata(bfd) \
1813 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
1815 #define ppc64_tlsld_got(bfd) \
1816 (&ppc64_elf_tdata (bfd)->tlsld_got)
1818 #define is_ppc64_elf(bfd) \
1819 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
1820 && elf_object_id (bfd) == PPC64_ELF_DATA)
1822 /* Override the generic function because we store some extras. */
1824 static bfd_boolean
1826 {
1828 PPC64_ELF_DATA);
1829 }
1831 /* Fix bad default arch selected for a 64 bit input bfd when the
1832 default is 32 bit. Also select arch based on apuinfo. */
1834 static bfd_boolean
1836 {
1841 {
1845 {
1846 /* Relies on arch after 32 bit default being 64 bit default. */
1849 }
1850 }
1852 }
1854 /* Support for core dump NOTE sections. */
1856 static bfd_boolean
1858 {
1864 /* pr_cursig */
1867 /* pr_pid */
1870 /* pr_reg */
1874 /* Make a ".reg/999" section. */
1877 }
1879 static bfd_boolean
1881 {
1893 }
1897 ...)
1898 {
1900 {
1905 {
1912 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
1913 DIAGNOSTIC_PUSH;
1914 /* GCC 8.0 and 8.1 warn about 80 equals destination size with
1915 -Wstringop-truncation:
1916 https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85643
1917 */
1918 DIAGNOSTIC_IGNORE_STRINGOP_TRUNCATION;
1919 #endif
1921 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
1922 DIAGNOSTIC_POP;
1923 #endif
1927 }
1930 {
1949 }
1950 }
1951 }
1953 /* Add extra PPC sections. */
1956 {
1964 };
1970 };
1972 struct _ppc64_elf_section_data
1973 {
1976 union
1977 {
1978 /* An array with one entry for each opd function descriptor,
1979 and some spares since opd entries may be either 16 or 24 bytes. */
1980 #define OPD_NDX(OFF) ((OFF) >> 4)
1981 struct _opd_sec_data
1982 {
1983 /* Points to the function code section for local opd entries. */
1986 /* After editing .opd, adjust references to opd local syms. */
1990 /* An array for toc sections, indexed by offset/8. */
1991 struct _toc_sec_data
1992 {
1993 /* Specifies the relocation symbol index used at a given toc offset. */
1996 /* And the relocation addend. */
2003 /* Flag set when small branches are detected. Used to
2004 select suitable defaults for the stub group size. */
2007 /* Flag set when PLTCALL relocs are detected. */
2010 /* Flag set when section has PLT/GOT/TOC relocations that can be
2011 optimised. */
2013 };
2015 #define ppc64_elf_section_data(sec) \
2016 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2018 static bfd_boolean
2020 {
2022 {
2030 }
2033 }
2035 static bfd_boolean
2037 {
2045 }
2049 {
2055 }
2056 \f
2057 /* Parameters for the qsort hook. */
2061 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
2063 static int
2065 {
2069 /* Section symbols first. */
2075 /* then .opd symbols. */
2077 {
2084 }
2086 /* then other code symbols. */
2100 {
2106 }
2114 /* For syms with the same value, prefer strong dynamic global function
2115 syms over other syms. */
2140 /* Finally, sort on where the symbol is in memory. The symbols will
2141 be in at most two malloc'd blocks, one for static syms, one for
2142 dynamic syms, and we distinguish the two blocks above by testing
2143 BSF_DYNAMIC. Since we are sorting the symbol pointers which were
2144 originally in the same order as the symbols (and we're not
2145 sorting the symbols themselves), this ensures a stable sort. */
2151 }
2153 /* Search SYMS for a symbol of the given VALUE. */
2157 bfd_vma value)
2158 {
2162 {
2164 {
2170 else
2172 }
2173 }
2174 else
2175 {
2177 {
2187 else
2189 }
2190 }
2192 }
2194 static bfd_boolean
2196 {
2201 }
2203 /* Create synthetic symbols, effectively restoring "dot-symbol" function
2204 entry syms. Also generate @plt symbols for the glink branch table.
2205 Returns count of synthetic symbols in RET or -1 on error. */
2207 static long
2212 {
2225 {
2229 }
2238 {
2250 {
2251 /* Use both symbol tables. */
2255 }
2258 else
2261 /* Trim uninteresting symbols. Interesting symbols are section,
2262 function, and notype symbols. */
2274 {
2275 /* Trim duplicate syms, since we may have merged the normal
2276 and dynamic symbols. Actually, we only care about syms
2277 that have different values, so trim any with the same
2278 value. Don't consider ifunc and ifunc resolver symbols
2279 duplicates however, because GDB wants to know whether a
2280 text symbol is an ifunc resolver. */
2282 {
2291 }
2293 }
2296 /* Note that here and in compare_symbols we can't compare opd and
2297 sym->section directly. With separate debug info files, the
2298 symbols will be extracted from the debug file while abfd passed
2299 to this function is the real binary. */
2328 }
2332 {
2347 {
2350 }
2354 {
2373 {
2377 }
2378 }
2384 {
2387 }
2392 {
2411 {
2423 /* Have udata.p point back to the original symbol this
2424 synthetic symbol was derived from. */
2426 s++;
2427 }
2428 }
2429 }
2430 else
2431 {
2441 {
2442 free_contents_and_exit_err:
2444 free_contents_and_exit:
2447 }
2451 {
2452 bfd_vma ent;
2454 /* Ignore bogus symbols. */
2460 {
2464 }
2465 }
2467 /* Get start of .glink stubs from DT_PPC64_GLINK. */
2470 {
2484 {
2485 Elf_Internal_Dyn dyn;
2492 {
2493 /* The first glink stub starts at DT_PPC64_GLINK plus 32.
2494 See comment in ppc64_elf_finish_dynamic_sections. */
2496 /* The .glink section usually does not survive the final
2497 link; search for the section (usually .text) where the
2498 glink stubs now reside. */
2502 }
2503 }
2506 }
2509 {
2510 /* Determine __glink trampoline by reading the relative branch
2511 from the first glink stub. */
2517 {
2521 {
2522 resolv_vma
2525 }
2529 }
2536 {
2546 {
2550 }
2551 }
2552 }
2563 {
2564 bfd_vma ent;
2571 {
2580 {
2586 else
2587 {
2590 }
2591 }
2597 {
2600 /* SEC_LOAD may not be set if SEC is from a separate debug
2601 info file. */
2606 }
2614 /* Have udata.p point back to the original symbol this
2615 synthetic symbol was derived from. */
2617 s++;
2618 }
2619 }
2623 {
2625 {
2626 /* Add a symbol for the main glink trampoline. */
2636 s++;
2637 count++;
2638 }
2640 /* FIXME: It would be very much nicer to put sym@plt on the
2641 stub rather than on the glink branch table entry. The
2642 objdump disassembler would then use a sensible symbol
2643 name on plt calls. The difficulty in doing so is
2644 a) finding the stubs, and,
2645 b) matching stubs against plt entries, and,
2646 c) there can be multiple stubs for a given plt entry.
2648 Solving (a) could be done by code scanning, but older
2649 ppc64 binaries used different stubs to current code.
2650 (b) is the tricky one since you need to known the toc
2651 pointer for at least one function that uses a pic stub to
2652 be able to calculate the plt address referenced.
2653 (c) means gdb would need to set multiple breakpoints (or
2654 find the glink branch itself) when setting breakpoints
2655 for pending shared library loads. */
2658 {
2662 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
2663 we are defining a symbol, ensure one of them is set. */
2675 {
2680 }
2683 s++;
2685 {
2689 }
2690 else
2692 }
2694 }
2695 }
2697 done:
2700 }
2701 \f
2702 /* The following functions are specific to the ELF linker, while
2703 functions above are used generally. Those named ppc64_elf_* are
2704 called by the main ELF linker code. They appear in this file more
2705 or less in the order in which they are called. eg.
2706 ppc64_elf_check_relocs is called early in the link process,
2707 ppc64_elf_finish_dynamic_sections is one of the last functions
2708 called.
2710 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
2711 functions have both a function code symbol and a function descriptor
2712 symbol. A call to foo in a relocatable object file looks like:
2714 . .text
2715 . x:
2716 . bl .foo
2717 . nop
2719 The function definition in another object file might be:
2721 . .section .opd
2722 . foo: .quad .foo
2723 . .quad .TOC.@tocbase
2724 . .quad 0
2725 .
2726 . .text
2727 . .foo: blr
2729 When the linker resolves the call during a static link, the branch
2730 unsurprisingly just goes to .foo and the .opd information is unused.
2731 If the function definition is in a shared library, things are a little
2732 different: The call goes via a plt call stub, the opd information gets
2733 copied to the plt, and the linker patches the nop.
2735 . x:
2736 . bl .foo_stub
2737 . ld 2,40(1)
2738 .
2739 .
2740 . .foo_stub:
2741 . std 2,40(1) # in practice, the call stub
2742 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
2743 . addi 11,11,Lfoo@toc@l # this is the general idea
2744 . ld 12,0(11)
2745 . ld 2,8(11)
2746 . mtctr 12
2747 . ld 11,16(11)
2748 . bctr
2749 .
2750 . .section .plt
2751 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
2753 The "reloc ()" notation is supposed to indicate that the linker emits
2754 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
2755 copying.
2757 What are the difficulties here? Well, firstly, the relocations
2758 examined by the linker in check_relocs are against the function code
2759 sym .foo, while the dynamic relocation in the plt is emitted against
2760 the function descriptor symbol, foo. Somewhere along the line, we need
2761 to carefully copy dynamic link information from one symbol to the other.
2762 Secondly, the generic part of the elf linker will make .foo a dynamic
2763 symbol as is normal for most other backends. We need foo dynamic
2764 instead, at least for an application final link. However, when
2765 creating a shared library containing foo, we need to have both symbols
2766 dynamic so that references to .foo are satisfied during the early
2767 stages of linking. Otherwise the linker might decide to pull in a
2768 definition from some other object, eg. a static library.
2770 Update: As of August 2004, we support a new convention. Function
2771 calls may use the function descriptor symbol, ie. "bl foo". This
2772 behaves exactly as "bl .foo". */
2774 /* Of those relocs that might be copied as dynamic relocs, this
2775 function selects those that must be copied when linking a shared
2776 library or PIE, even when the symbol is local. */
2778 static int
2781 {
2783 {
2785 /* Only relative relocs can be resolved when the object load
2786 address isn't fixed. DTPREL64 is excluded because the
2787 dynamic linker needs to differentiate global dynamic from
2788 local dynamic __tls_index pairs when PPC64_OPT_TLS is set. */
2816 /* These relocations are relative but in a shared library the
2817 linker doesn't know the thread pointer base. */
2819 }
2820 }
2822 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
2823 copying dynamic variables from a shared lib into an app's .dynbss
2824 section, and instead use a dynamic relocation to point into the
2825 shared lib. With code that gcc generates it is vital that this be
2826 enabled; In the PowerPC64 ELFv1 ABI the address of a function is
2827 actually the address of a function descriptor which resides in the
2828 .opd section. gcc uses the descriptor directly rather than going
2829 via the GOT as some other ABIs do, which means that initialized
2830 function pointers reference the descriptor. Thus, a function
2831 pointer initialized to the address of a function in a shared
2832 library will either require a .dynbss copy and a copy reloc, or a
2833 dynamic reloc. Using a .dynbss copy redefines the function
2834 descriptor symbol to point to the copy. This presents a problem as
2835 a PLT entry for that function is also initialized from the function
2836 descriptor symbol and the copy may not be initialized first. */
2837 #define ELIMINATE_COPY_RELOCS 1
2839 /* Section name for stubs is the associated section name plus this
2840 string. */
2843 /* Linker stubs.
2844 ppc_stub_long_branch:
2845 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
2846 destination, but a 24 bit branch in a stub section will reach.
2847 . b dest
2849 ppc_stub_plt_branch:
2850 Similar to the above, but a 24 bit branch in the stub section won't
2851 reach its destination.
2852 . addis %r12,%r2,xxx@toc@ha
2853 . ld %r12,xxx@toc@l(%r12)
2854 . mtctr %r12
2855 . bctr
2857 ppc_stub_plt_call:
2858 Used to call a function in a shared library. If it so happens that
2859 the plt entry referenced crosses a 64k boundary, then an extra
2860 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
2861 ppc_stub_plt_call_r2save starts with "std %r2,40(%r1)".
2862 . addis %r11,%r2,xxx@toc@ha
2863 . ld %r12,xxx+0@toc@l(%r11)
2864 . mtctr %r12
2865 . ld %r2,xxx+8@toc@l(%r11)
2866 . ld %r11,xxx+16@toc@l(%r11)
2867 . bctr
2869 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
2870 code to adjust the value and save r2 to support multiple toc sections.
2871 A ppc_stub_long_branch with an r2 offset looks like:
2872 . std %r2,40(%r1)
2873 . addis %r2,%r2,off@ha
2874 . addi %r2,%r2,off@l
2875 . b dest
2877 A ppc_stub_plt_branch with an r2 offset looks like:
2878 . std %r2,40(%r1)
2879 . addis %r12,%r2,xxx@toc@ha
2880 . ld %r12,xxx@toc@l(%r12)
2881 . addis %r2,%r2,off@ha
2882 . addi %r2,%r2,off@l
2883 . mtctr %r12
2884 . bctr
2886 All of the above stubs are shown as their ELFv1 variants. ELFv2
2887 variants exist too, simpler for plt calls since a new toc pointer
2888 and static chain are not loaded by the stub. In addition, ELFv2
2889 has some more complex stubs to handle calls marked with NOTOC
2890 relocs from functions where r2 is not a valid toc pointer. These
2891 come in two flavours, the ones shown below, and _both variants that
2892 start with "std %r2,24(%r1)" to save r2 in the unlikely event that
2893 one call is from a function where r2 is used as the toc pointer but
2894 needs a toc adjusting stub for small-model multi-toc, and another
2895 call is from a function where r2 is not valid.
2896 ppc_stub_long_branch_notoc:
2897 . mflr %r12
2898 . bcl 20,31,1f
2899 . 1:
2900 . mflr %r11
2901 . mtlr %r12
2902 . addis %r12,%r11,dest-1b@ha
2903 . addi %r12,%r12,dest-1b@l
2904 . b dest
2906 ppc_stub_plt_branch_notoc:
2907 . mflr %r12
2908 . bcl 20,31,1f
2909 . 1:
2910 . mflr %r11
2911 . mtlr %r12
2912 . lis %r12,xxx-1b@highest
2913 . ori %r12,%r12,xxx-1b@higher
2914 . sldi %r12,%r12,32
2915 . oris %r12,%r12,xxx-1b@high
2916 . ori %r12,%r12,xxx-1b@l
2917 . add %r12,%r11,%r12
2918 . mtctr %r12
2919 . bctr
2921 ppc_stub_plt_call_notoc:
2922 . mflr %r12
2923 . bcl 20,31,1f
2924 . 1:
2925 . mflr %r11
2926 . mtlr %r12
2927 . lis %r12,xxx-1b@highest
2928 . ori %r12,%r12,xxx-1b@higher
2929 . sldi %r12,%r12,32
2930 . oris %r12,%r12,xxx-1b@high
2931 . ori %r12,%r12,xxx-1b@l
2932 . ldx %r12,%r11,%r12
2933 . mtctr %r12
2934 . bctr
2936 There are also ELFv1 power10 variants of these stubs.
2937 ppc_stub_long_branch_notoc:
2938 . pla %r12,dest@pcrel
2939 . b dest
2940 ppc_stub_plt_branch_notoc:
2941 . lis %r11,(dest-1f)@highesta34
2942 . ori %r11,%r11,(dest-1f)@highera34
2943 . sldi %r11,%r11,34
2944 . 1: pla %r12,dest@pcrel
2945 . add %r12,%r11,%r12
2946 . mtctr %r12
2947 . bctr
2948 ppc_stub_plt_call_notoc:
2949 . lis %r11,(xxx-1f)@highesta34
2950 . ori %r11,%r11,(xxx-1f)@highera34
2951 . sldi %r11,%r11,34
2952 . 1: pla %r12,xxx@pcrel
2953 . ldx %r12,%r11,%r12
2954 . mtctr %r12
2955 . bctr
2957 In cases where the high instructions would add zero, they are
2958 omitted and following instructions modified in some cases.
2959 For example, a power10 ppc_stub_plt_call_notoc might simplify down
2960 to
2961 . pld %r12,xxx@pcrel
2962 . mtctr %r12
2963 . bctr
2965 For a given stub group (a set of sections all using the same toc
2966 pointer value) there will be just one stub type used for any
2967 particular function symbol. For example, if printf is called from
2968 code with the tocsave optimization (ie. r2 saved in function
2969 prologue) and therefore calls use a ppc_stub_plt_call linkage stub,
2970 and from other code without the tocsave optimization requiring a
2971 ppc_stub_plt_call_r2save linkage stub, a single stub of the latter
2972 type will be created. Calls with the tocsave optimization will
2973 enter this stub after the instruction saving r2. A similar
2974 situation exists when calls are marked with R_PPC64_REL24_NOTOC
2975 relocations. These require a ppc_stub_plt_call_notoc linkage stub
2976 to call an external function like printf. If other calls to printf
2977 require a ppc_stub_plt_call linkage stub then a single
2978 ppc_stub_plt_call_notoc linkage stub will be used for both types of
2979 call. If other calls to printf require a ppc_stub_plt_call_r2save
2980 linkage stub then a single ppc_stub_plt_call_both linkage stub will
2981 be created and calls not requiring r2 to be saved will enter the
2982 stub after the r2 save instruction. There is an analogous
2983 hierarchy of long branch and plt branch stubs for local call
2984 linkage. */
2986 enum ppc_stub_type
2987 {
2988 ppc_stub_none,
2989 ppc_stub_long_branch,
2990 ppc_stub_long_branch_r2off,
2991 ppc_stub_long_branch_notoc,
2993 ppc_stub_plt_branch,
2994 ppc_stub_plt_branch_r2off,
2995 ppc_stub_plt_branch_notoc,
2996 ppc_stub_plt_branch_both,
2997 ppc_stub_plt_call,
2998 ppc_stub_plt_call_r2save,
2999 ppc_stub_plt_call_notoc,
3000 ppc_stub_plt_call_both,
3001 ppc_stub_global_entry,
3002 ppc_stub_save_res
3003 };
3005 /* Information on stub grouping. */
3006 struct map_stub
3007 {
3008 /* The stub section. */
3010 /* This is the section to which stubs in the group will be attached. */
3012 /* Next group. */
3014 /* Whether to emit a copy of register save/restore functions in this
3015 group. */
3017 /* Current offset within stubs after the insn restoring lr in a
3018 _notoc or _both stub using bcl for pc-relative addressing, or
3019 after the insn restoring lr in a __tls_get_addr_opt plt stub. */
3021 /* Accumulated size of EH info emitted to describe return address
3022 if stubs modify lr. Does not include 17 byte FDE header. */
3024 /* Offset in glink_eh_frame to the start of EH info for this group. */
3026 };
3028 struct ppc_stub_hash_entry
3029 {
3030 /* Base hash table entry structure. */
3035 /* Group information. */
3038 /* Offset within stub_sec of the beginning of this stub. */
3039 bfd_vma stub_offset;
3041 /* Given the symbol's value and its section we can determine its final
3042 value when building the stubs (so the stub knows where to jump. */
3043 bfd_vma target_value;
3046 /* The symbol table entry, if any, that this was derived from. */
3050 /* Symbol type. */
3053 /* Symbol st_other. */
3055 };
3057 struct ppc_branch_hash_entry
3058 {
3059 /* Base hash table entry structure. */
3062 /* Offset within branch lookup table. */
3065 /* Generation marker. */
3067 };
3069 /* Used to track dynamic relocations for local symbols. */
3070 struct ppc_dyn_relocs
3071 {
3074 /* The input section of the reloc. */
3077 /* Total number of relocs copied for the input section. */
3080 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3082 };
3084 struct ppc_link_hash_entry
3085 {
3088 union
3089 {
3090 /* A pointer to the most recently used stub hash entry against this
3091 symbol. */
3094 /* A pointer to the next symbol starting with a '.' */
3098 /* Link between function code and descriptor symbols. */
3101 /* Flag function code and descriptor symbols. */
3106 /* Whether global opd/toc sym has been adjusted or not.
3107 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3108 should be set for all globals defined in any opd/toc section. */
3111 /* Set if this is an out-of-line register save/restore function,
3112 with non-standard calling convention. */
3115 /* Set if a duplicate symbol with non-zero localentry is detected,
3116 even when the duplicate symbol does not provide a definition. */
3119 /* Contexts in which symbol is used in the GOT (or TOC).
3120 Bits are or'd into the mask as the corresponding relocs are
3121 encountered during check_relocs, with TLS_TLS being set when any
3122 of the other TLS bits are set. tls_optimize clears bits when
3123 optimizing to indicate the corresponding GOT entry type is not
3124 needed. If set, TLS_TLS is never cleared. tls_optimize may also
3125 set TLS_GDIE when a GD reloc turns into an IE one.
3126 These flags are also kept for local symbols. */
3137 /* The above field is also used to mark function symbols. In which
3138 case TLS_TLS will be 0. */
3142 };
3146 {
3148 }
3150 /* ppc64 ELF linker hash table. */
3152 struct ppc_link_hash_table
3153 {
3156 /* The stub hash table. */
3159 /* Another hash table for plt_branch stubs. */
3162 /* Hash table for function prologue tocsave. */
3163 htab_t tocsave_htab;
3165 /* Various options and other info passed from the linker. */
3168 /* The size of sec_info below. */
3171 /* Per-section array of extra section info. Done this way rather
3172 than as part of ppc64_elf_section_data so we have the info for
3173 non-ppc64 sections. */
3174 struct
3175 {
3176 /* Along with elf_gp, specifies the TOC pointer used by this section. */
3177 bfd_vma toc_off;
3179 union
3180 {
3181 /* The section group that this section belongs to. */
3183 /* A temp section list pointer. */
3188 /* Linked list of groups. */
3191 /* Temp used when calculating TOC pointers. */
3192 bfd_vma toc_curr;
3196 /* Used when adding symbols. */
3199 /* Shortcuts to get to dynamic linker sections. */
3209 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
3216 /* The size of reliplt used by got entry relocs. */
3217 bfd_size_type got_reli_size;
3219 /* Statistics. */
3222 /* Number of stubs against global syms. */
3225 /* Set if we're linking code with function descriptors. */
3228 /* Support for multiple toc sections. */
3234 /* Set if tls optimization is enabled. */
3237 /* Set if inline plt calls should be converted to direct calls. */
3240 /* Set on error. */
3243 /* Whether func_desc_adjust needs to be run over symbols. */
3246 /* Whether plt calls for ELFv2 localentry:0 funcs have been optimized. */
3249 /* Whether calls are made via the PLT from NOTOC functions. */
3252 /* Whether any code linked seems to be Power10. */
3255 /* Incremented every time we size stubs. */
3257 };
3259 /* Rename some of the generic section flags to better document how they
3260 are used here. */
3262 /* Nonzero if this section has TLS related relocations. */
3263 #define has_tls_reloc sec_flg0
3265 /* Nonzero if this section has a call to __tls_get_addr lacking marker
3266 relocations. */
3267 #define nomark_tls_get_addr sec_flg1
3269 /* Nonzero if this section has any toc or got relocs. */
3270 #define has_toc_reloc sec_flg2
3272 /* Nonzero if this section has a call to another section that uses
3273 the toc or got. */
3274 #define makes_toc_func_call sec_flg3
3276 /* Recursion protection when determining above flag. */
3277 #define call_check_in_progress sec_flg4
3278 #define call_check_done sec_flg5
3280 /* Get the ppc64 ELF linker hash table from a link_info structure. */
3282 #define ppc_hash_table(p) \
3283 ((is_elf_hash_table ((p)->hash) \
3284 && elf_hash_table_id (elf_hash_table (p)) == PPC64_ELF_DATA) \
3285 ? (struct ppc_link_hash_table *) (p)->hash : NULL)
3287 #define ppc_stub_hash_lookup(table, string, create, copy) \
3288 ((struct ppc_stub_hash_entry *) \
3289 bfd_hash_lookup ((table), (string), (create), (copy)))
3291 #define ppc_branch_hash_lookup(table, string, create, copy) \
3292 ((struct ppc_branch_hash_entry *) \
3293 bfd_hash_lookup ((table), (string), (create), (copy)))
3295 /* Create an entry in the stub hash table. */
3301 {
3302 /* Allocate the structure if it has not already been allocated by a
3303 subclass. */
3305 {
3309 }
3311 /* Call the allocation method of the superclass. */
3314 {
3317 /* Initialize the local fields. */
3327 }
3330 }
3332 /* Create an entry in the branch hash table. */
3338 {
3339 /* Allocate the structure if it has not already been allocated by a
3340 subclass. */
3342 {
3346 }
3348 /* Call the allocation method of the superclass. */
3351 {
3354 /* Initialize the local fields. */
3358 }
3361 }
3363 /* Create an entry in a ppc64 ELF linker hash table. */
3369 {
3370 /* Allocate the structure if it has not already been allocated by a
3371 subclass. */
3373 {
3377 }
3379 /* Call the allocation method of the superclass. */
3382 {
3389 /* When making function calls, old ABI code references function entry
3390 points (dot symbols), while new ABI code references the function
3391 descriptor symbol. We need to make any combination of reference and
3392 definition work together, without breaking archive linking.
3394 For a defined function "foo" and an undefined call to "bar":
3395 An old object defines "foo" and ".foo", references ".bar" (possibly
3396 "bar" too).
3397 A new object defines "foo" and references "bar".
3399 A new object thus has no problem with its undefined symbols being
3400 satisfied by definitions in an old object. On the other hand, the
3401 old object won't have ".bar" satisfied by a new object.
3403 Keep a list of newly added dot-symbols. */
3406 {
3412 }
3413 }
3416 }
3418 struct tocsave_entry
3419 {
3421 bfd_vma offset;
3422 };
3424 static hashval_t
3426 {
3429 }
3431 static int
3433 {
3437 }
3439 /* Destroy a ppc64 ELF linker hash table. */
3441 static void
3443 {
3452 }
3454 /* Create a ppc64 ELF linker hash table. */
3458 {
3468 PPC64_ELF_DATA))
3469 {
3472 }
3474 /* Init the stub hash table too. */
3477 {
3480 }
3482 /* And the branch hash table. */
3485 {
3489 }
3492 tocsave_htab_hash,
3493 tocsave_htab_eq,
3494 NULL);
3496 {
3499 }
3502 /* Initializing two fields of the union is just cosmetic. We really
3503 only care about glist, but when compiled on a 32-bit host the
3504 bfd_vma fields are larger. Setting the bfd_vma to zero makes
3505 debugger inspection of these fields look nicer. */
3516 }
3518 /* Create sections for linker generated code. */
3520 static bfd_boolean
3522 {
3524 flagword flags;
3531 {
3532 /* Create .sfpr for code to save and restore fp regs. */
3534 flags);
3538 }
3543 /* Create .glink for lazy dynamic linking support. */
3545 flags);
3550 /* The part of .glink used by global entry stubs, separate so that
3551 it can be aligned appropriately without affecting htab->glink. */
3553 flags);
3559 {
3564 flags);
3568 }
3584 /* Create branch lookup table for plt_branch stubs. */
3588 flags);
3593 /* Local plt entries, put in .branch_lt but a separate section for
3594 convenience. */
3596 flags);
3606 htab->relbrlt
3612 htab->relpltlocal
3619 }
3621 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
3623 bfd_boolean
3626 {
3631 /* Always hook our dynamic sections into the first bfd, which is the
3632 linker created stub bfd. This ensures that the GOT header is at
3633 the start of the output TOC section. */
3639 }
3641 /* Build a name for an entry in the stub hash table. */
3648 {
3650 ssize_t len;
3652 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
3653 offsets from a sym as a branch target? In fact, we could
3654 probably assume the addend is always zero. */
3658 {
3668 }
3669 else
3670 {
3681 }
3685 }
3687 /* If mixing power10 with non-power10 code and --power10-stubs is not
3688 specified (or is auto) then calls using @notoc relocations that
3689 need a stub will utilize power10 instructions in the stub, and
3690 calls without @notoc relocations will not use power10 instructions.
3691 The two classes of stubs are stored in separate stub_hash_table
3692 entries having the same key string. The two entries will always be
3693 adjacent on entry->root.next chain, even if hash table resizing
3694 occurs. This function selects the correct entry to use. */
3698 {
3699 bfd_boolean have_notoc;
3706 {
3713 }
3716 }
3718 /* Look up an entry in the stub hash. Stub entries are cached because
3719 creating the stub name takes a bit of time. */
3727 {
3731 /* If this input section is part of a group of sections sharing one
3732 stub section, then use the id of the first section in the group.
3733 Stub names need to include a section id, as there may well be
3734 more than one stub used to reach say, printf, and we need to
3735 distinguish between them. */
3743 {
3745 }
3746 else
3747 {
3760 }
3763 {
3767 }
3770 }
3772 /* Add a new stub entry to the stub hash. Not all fields of the new
3773 stub entry are initialised. */
3779 {
3790 {
3792 bfd_size_type len;
3807 }
3809 /* Enter this entry into the linker stub hash table. */
3813 {
3814 /* xgettext:c-format */
3818 }
3823 }
3825 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
3826 not already done. */
3828 static bfd_boolean
3830 {
3832 flagword flags;
3861 }
3863 /* Follow indirect and warning symbol links. */
3867 {
3872 }
3876 {
3878 }
3882 {
3884 }
3886 /* Merge PLT info on FROM with that on TO. */
3888 static void
3891 {
3893 {
3895 {
3900 {
3905 {
3909 }
3912 }
3914 }
3918 }
3919 }
3921 /* Copy the extra info we tack onto an elf_link_hash_entry. */
3923 static void
3927 {
3947 /* If we were called to copy over info for a weak sym, don't copy
3948 dyn_relocs, plt/got info, or dynindx. We used to copy dyn_relocs
3949 in order to simplify readonly_dynrelocs and save a field in the
3950 symbol hash entry, but that means dyn_relocs can't be used in any
3951 tests about a specific symbol, or affect other symbol flags which
3952 are then tested. */
3956 /* Copy over any dynamic relocs we may have on the indirect sym. */
3958 {
3960 {
3964 /* Add reloc counts against the indirect sym to the direct sym
3965 list. Merge any entries against the same section. */
3967 {
3972 {
3977 }
3980 }
3982 }
3986 }
3988 /* Copy over got entries that we may have already seen to the
3989 symbol which just became indirect. */
3991 {
3993 {
3998 {
4005 {
4009 }
4012 }
4014 }
4018 }
4020 /* And plt entries. */
4024 {
4032 }
4033 }
4035 /* Find the function descriptor hash entry from the given function code
4036 hash entry FH. Link the entries via their OH fields. */
4040 {
4044 {
4056 }
4062 }
4064 /* Make a fake function descriptor sym for the undefined code sym FH. */
4069 {
4074 ? BSF_WEAK
4091 }
4093 /* Fix function descriptor symbols defined in .opd sections to be
4094 function type. */
4096 static bfd_boolean
4104 {
4107 {
4114 /* If the symbol is a function defined in .opd, and the function
4115 code is in a discarded group, let it appear to be undefined. */
4121 {
4124 }
4125 }
4129 {
4133 }
4136 {
4140 {
4145 }
4146 }
4149 }
4151 /* Merge non-visibility st_other attributes: local entry point. */
4153 static void
4156 bfd_boolean definition,
4157 bfd_boolean dynamic)
4158 {
4162 }
4164 /* Hook called on merging a symbol. We use this to clear "fake" since
4165 we now have a real symbol. */
4167 static bfd_boolean
4171 bfd_boolean newdef ATTRIBUTE_UNUSED,
4172 bfd_boolean olddef ATTRIBUTE_UNUSED,
4175 {
4180 }
4182 /* This function makes an old ABI object reference to ".bar" cause the
4183 inclusion of a new ABI object archive that defines "bar".
4184 NAME is a symbol defined in an archive. Return a symbol in the hash
4185 table that might be satisfied by the archive symbols. */
4191 {
4198 /* Don't return this sym if it is a fake function descriptor
4199 created by add_symbol_adjust. */
4220 }
4222 /* This function satisfies all old ABI object references to ".bar" if a
4223 new ABI object defines "bar". Well, at least, undefined dot symbols
4224 are made weak. This stops later archive searches from including an
4225 object if we already have a function descriptor definition. It also
4226 prevents the linker complaining about undefined symbols.
4227 We also check and correct mismatched symbol visibility here. The
4228 most restrictive visibility of the function descriptor and the
4229 function entry symbol is used. */
4231 static bfd_boolean
4233 {
4256 {
4257 /* Make an undefined function descriptor sym, in order to
4258 pull in an --as-needed shared lib. Archives are handled
4259 elsewhere. */
4263 }
4266 {
4270 /* Make both descriptor and entry symbol have the most
4271 constraining visibility of either symbol. */
4277 /* Propagate reference flags from entry symbol to function
4278 descriptor symbol. */
4292 {
4295 }
4296 }
4299 }
4301 /* Set up opd section info and abiversion for IBFD, and process list
4302 of dot-symbols we made in link_hash_newfunc. */
4304 static bfd_boolean
4306 {
4312 {
4319 {
4320 /* xgettext:c-format */
4325 }
4326 }
4329 {
4330 /* For input files without an explicit abiversion in e_flags
4331 we should have flagged any with symbol st_other bits set
4332 as ELFv1 and above flagged those with .opd as ELFv2.
4333 Set the output abiversion if not yet set, and for any input
4334 still ambiguous, take its abiversion from the output.
4335 Differences in ABI are reported later. */
4340 }
4352 {
4353 /* Garbage collection needs some extra help with .opd sections.
4354 We don't want to necessarily keep everything referenced by
4355 relocs in .opd, as that would keep all functions. Instead,
4356 if we reference an .opd symbol (a function descriptor), we
4357 want to keep the function code symbol's section. This is
4358 easy for global symbols, but for local syms we need to keep
4359 information about the associated function section. */
4360 bfd_size_type amt;
4377 {
4384 {
4389 r_symndx);
4391 {
4395 }
4400 }
4401 }
4404 }
4408 {
4411 ;
4416 {
4420 }
4422 }
4424 }
4426 /* Undo hash table changes when an --as-needed input file is determined
4427 not to be needed. */
4429 static bfd_boolean
4433 {
4435 {
4442 }
4444 }
4446 /* If --just-symbols against a final linked binary, then assume we need
4447 toc adjusting stubs when calling functions defined there. */
4449 static void
4451 {
4455 {
4459 }
4461 }
4466 {
4472 {
4482 }
4485 {
4494 {
4506 }
4508 }
4515 }
4517 static bfd_boolean
4519 {
4526 {
4535 }
4538 }
4540 static bfd_boolean
4542 {
4554 }
4556 /* Relocs on inline plt call sequence insns prior to the call. */
4558 static bfd_boolean
4560 {
4569 }
4571 /* Look through the relocs for a section during the first phase, and
4572 calculate needed space in the global offset table, procedure
4573 linkage table, and dynamic reloc sections. */
4575 static bfd_boolean
4578 {
4586 bfd_boolean is_opd;
4607 {
4618 else
4619 {
4625 }
4629 {
4650 }
4653 {
4677 }
4681 {
4683 {
4686 }
4687 }
4688 else
4689 {
4696 {
4702 }
4703 }
4707 {
4710 /* These special tls relocs tie a call to __tls_get_addr with
4711 its parameter symbol. */
4714 else
4754 dogottls:
4765 dogot:
4766 /* This symbol requires a global offset table entry. */
4774 {
4777 }
4784 {
4795 {
4807 }
4810 }
4811 else
4812 /* This is a global offset table entry for a local symbol. */
4826 /* This symbol requires a procedure linkage table entry. */
4829 {
4836 }
4845 /* The following relocations don't need to propagate the
4846 relocation if linking a shared object since they are
4847 section relative. */
4868 /* Nor do these. */
4886 /* Not supported as a dynamic relocation. */
4889 {
4892 /* xgettext:c-format */
4899 }
4906 /* Fall through. */
4913 {
4914 /* We may need a copy reloc. */
4916 /* Strongly prefer a copy reloc over a dynamic reloc.
4917 glibc ld.so as of 2019-08 will error out if one of
4918 these relocations is emitted. */
4921 }
4924 /* Marker reloc. */
4928 /* This relocation describes the C++ object vtable hierarchy.
4929 Reconstruct it for later use during GC. */
4935 /* This relocation describes which C++ vtable entries are actually
4936 used. Record for later use during GC. */
4945 {
4948 /* Heuristic: If jumping outside our section, chances are
4949 we are going to need a stub. */
4951 {
4952 /* If the sym is weak it may be overridden later, so
4953 don't assume we know where a weak sym lives. */
4956 }
4957 else
4958 {
4967 }
4971 }
4977 /* Fall through. */
4981 rel24:
4984 {
4991 {
4996 /* We have a new-style __tls_get_addr call with
4997 a marker reloc. */
4998 ;
4999 else
5000 /* Mark this section as having an old-style call. */
5002 }
5004 }
5006 /* We may need a .plt entry if the function this reloc
5007 refers to is in a shared lib. */
5030 else
5039 /* This is the second reloc of a dtpmod, dtprel pair.
5040 Don't mark with TLS_DTPREL. */
5043 dotlstoc:
5047 else
5054 {
5055 bfd_size_type amt;
5057 /* One extra to simplify get_tls_mask. */
5068 }
5073 /* Mark the second slot of a GD or LD entry.
5074 -1 to indicate GD and -2 to indicate LD. */
5090 /* Fall through. */
5104 {
5107 }
5108 /* Fall through. */
5133 {
5134 /* We may need a .plt entry if this reloc refers to a
5135 function in a shared lib. */
5139 }
5140 /* Fall through. */
5151 /* We may need a copy reloc. */
5154 /* Don't propagate .opd relocs. */
5158 /* If we are creating a shared library, and this is a reloc
5159 against a global symbol, or a non PC relative reloc
5160 against a local symbol, then we need to copy the reloc
5161 into the shared library. However, if we are linking with
5162 -Bsymbolic, we do not need to copy a reloc against a
5163 global symbol which is defined in an object we are
5164 including in the link (i.e., DEF_REGULAR is set). At
5165 this point we have not seen all the input files, so it is
5166 possible that DEF_REGULAR is not set now but will be set
5167 later (it is never cleared). In case of a weak definition,
5168 DEF_REGULAR may be cleared later by a strong definition in
5169 a shared library. We account for that possibility below by
5170 storing information in the dyn_relocs field of the hash
5171 table entry. A similar situation occurs when creating
5172 shared libraries and symbol visibility changes render the
5173 symbol local.
5175 If on the other hand, we are creating an executable, we
5176 may need to keep relocations for symbols satisfied by a
5177 dynamic library if we manage to avoid copy relocs for the
5178 symbol. */
5179 dodyn:
5190 {
5191 /* We must copy these reloc types into the output file.
5192 Create a reloc section in dynobj and make room for
5193 this reloc. */
5195 {
5196 sreloc = _bfd_elf_make_dynamic_reloc_section
5201 }
5203 /* If this is a global symbol, we count the number of
5204 relocations we need for this symbol. */
5206 {
5213 {
5222 }
5226 }
5227 else
5228 {
5229 /* Track dynamic relocs needed for local syms too.
5230 We really need local syms available to do this
5231 easily. Oh well. */
5234 bfd_boolean is_ifunc;
5255 {
5264 }
5266 }
5267 }
5272 }
5273 }
5276 }
5278 /* Merge backend specific data from an object file to the output
5279 object file when linking. */
5281 static bfd_boolean
5283 {
5300 {
5301 _bfd_error_handler
5302 /* xgettext:c-format */
5306 }
5308 {
5309 _bfd_error_handler
5310 /* xgettext:c-format */
5315 }
5320 /* Merge Tag_compatibility attributes and any common GNU ones. */
5322 }
5324 static bfd_boolean
5326 {
5327 /* Print normal ELF private data. */
5331 {
5341 }
5344 }
5346 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
5347 of the code entry point, and its section, which must be in the same
5348 object as OPD_SEC. Returns (bfd_vma) -1 on error. */
5350 static bfd_vma
5352 bfd_vma offset,
5355 bfd_boolean in_code_sec)
5356 {
5360 bfd_vma val;
5362 /* No relocs implies we are linking a --just-symbols object, or looking
5363 at a final linked executable with addr2line or somesuch. */
5365 {
5369 {
5373 }
5375 /* PR 17512: file: 64b9dfbb. */
5381 {
5385 {
5390 else
5392 }
5393 else
5400 {
5404 }
5405 }
5407 }
5414 /* PR 17512: file: df8e1fd6. */
5418 /* Go find the opd reloc at the sym address. */
5423 {
5429 else
5430 {
5435 {
5441 {
5448 {
5454 {
5457 }
5458 }
5459 }
5462 {
5466 {
5469 {
5477 }
5479 }
5480 else
5481 {
5487 }
5493 }
5499 {
5502 else
5504 }
5507 }
5509 }
5510 }
5513 }
5515 /* If the ELF symbol SYM might be a function in SEC, return the
5516 function size and set *CODE_OFF to the function's entry point,
5517 otherwise return zero. */
5519 static bfd_size_type
5522 {
5523 bfd_size_type size;
5534 {
5541 {
5542 /* opd_entry_value will use cached relocs that have been
5543 adjusted, but with raw symbols. That means both local
5544 and global symbols need adjusting. */
5549 }
5554 /* An old ABI binary with dot-syms has a size of 24 on the .opd
5555 symbol. This size has nothing to do with the code size of the
5556 function, which is what we're supposed to return, but the
5557 code size isn't available without looking up the dot-sym.
5558 However, doing that would be a waste of time particularly
5559 since elf_find_function will look at the dot-sym anyway.
5560 Now, elf_find_function will keep the largest size of any
5561 function sym found at the code address of interest, so return
5562 1 here to avoid it incorrectly caching a larger function size
5563 for a small function. This does mean we return the wrong
5564 size for a new-ABI function of size 24, but all that does is
5565 disable caching for such functions. */
5568 }
5569 else
5570 {
5574 }
5578 }
5580 /* Return true if symbol is a strong function defined in an ELFv2
5581 object with st_other localentry bits of zero, ie. its local entry
5582 point coincides with its global entry point. */
5584 static bfd_boolean
5586 {
5594 }
5596 /* Return true if symbol is defined in a regular object file. */
5598 static bfd_boolean
5600 {
5605 }
5607 /* If FDH is a function descriptor symbol, return the associated code
5608 entry symbol if it is defined. Return NULL otherwise. */
5612 {
5614 {
5619 }
5621 }
5623 /* If FH is a function code entry symbol, return the associated
5624 function descriptor symbol if it is defined. Return NULL otherwise. */
5628 {
5631 {
5636 }
5638 }
5640 /* Given H is a symbol that satisfies is_static_defined, return the
5641 value in the output file. */
5643 static bfd_vma
5645 {
5649 }
5651 /* Return true if H matches __tls_get_addr or one of its variants. */
5653 static bfd_boolean
5656 {
5661 }
5665 /* Garbage collect sections, after first dealing with dot-symbols. */
5667 static bfd_boolean
5669 {
5673 {
5676 }
5678 }
5680 /* Mark all our entry sym sections, both opd and code section. */
5682 static void
5684 {
5692 {
5706 {
5709 }
5718 }
5719 }
5721 /* Mark sections containing dynamically referenced symbols. When
5722 building shared libraries, we must assume that any visible symbol is
5723 referenced. */
5725 static bfd_boolean
5727 {
5733 /* Dynamic linking info is on the func descriptor sym. */
5754 {
5760 /* Function descriptor syms cause the associated
5761 function code sym section to be marked. */
5764 {
5767 }
5773 }
5776 }
5778 /* Return the section that should be marked against GC for a given
5779 relocation. */
5787 {
5790 /* Syms return NULL if we're marking .opd, so we avoid marking all
5791 function sections, as all functions are referenced in .opd. */
5797 {
5803 {
5810 {
5816 {
5817 /* -mcall-aixdesc code references the dot-symbol on
5818 a call reloc. Mark the function descriptor too
5819 against garbage collection. */
5824 }
5826 /* Function descriptor syms cause the associated
5827 function code sym section to be marked. */
5830 {
5831 /* They also mark their opd section. */
5835 }
5841 else
5851 }
5852 }
5853 }
5854 else
5855 {
5861 {
5865 }
5866 }
5869 }
5871 /* The maximum size of .sfpr. */
5872 #define SFPR_MAX (218*4)
5874 struct sfpr_def_parms
5875 {
5880 };
5882 /* Auto-generate _save*, _rest* functions in .sfpr.
5883 If STUB_SEC is non-null, define alias symbols in STUB_SEC
5884 instead. */
5886 static bfd_boolean
5890 {
5904 {
5912 {
5916 {
5924 {
5935 }
5936 }
5938 }
5940 {
5943 {
5953 {
5958 }
5959 }
5960 }
5962 {
5966 else
5969 }
5970 }
5973 }
5977 {
5980 }
5984 {
5990 }
5994 {
5997 }
6001 {
6008 {
6011 }
6014 }
6018 {
6021 }
6025 {
6029 }
6033 {
6036 }
6040 {
6044 }
6048 {
6051 }
6055 {
6061 }
6065 {
6068 }
6072 {
6079 {
6082 }
6085 }
6089 {
6093 }
6097 {
6101 }
6105 {
6110 }
6114 {
6118 }
6122 {
6127 }
6131 {
6135 }
6137 #define STDU_R1_0R1 0xf8210001
6138 #define ADDI_R1_R1 0x38210000
6140 /* Emit prologue of wrapper preserving regs around a call to
6141 __tls_get_addr_opt. */
6145 {
6154 {
6156 {
6160 }
6163 }
6164 else
6165 {
6167 {
6171 }
6174 }
6176 }
6178 /* Emit epilogue of wrapper preserving regs around a call to
6179 __tls_get_addr_opt. */
6183 {
6187 {
6189 {
6192 }
6195 }
6196 else
6197 {
6199 {
6202 }
6205 }
6213 }
6215 /* Called via elf_link_hash_traverse to transfer dynamic linking
6216 information on function code symbol entries to their corresponding
6217 function descriptor symbol entries. */
6219 static bfd_boolean
6221 {
6226 bfd_boolean force_local;
6244 /* Find the corresponding function descriptor symbol. */
6247 /* Resolve undefined references to dot-symbols as the value
6248 in the function descriptor, if we have one in a regular object.
6249 This is to satisfy cases like ".quad .foo". Calls to functions
6250 in dynamic objects are handled elsewhere. */
6260 {
6265 }
6268 {
6276 }
6278 /* Create a descriptor as undefined if necessary. */
6283 {
6287 }
6289 /* We can't support overriding of symbols on a fake descriptor. */
6296 /* Transfer dynamic linking information to the function descriptor. */
6298 {
6313 }
6315 /* Now that the info is on the function descriptor, clear the
6316 function code sym info. Any function code syms for which we
6317 don't have a definition in a regular file, we force local.
6318 This prevents a shared library from exporting syms that have
6319 been imported from another library. Function code syms that
6320 are really in the library we must leave global to prevent the
6321 linker dragging in a definition from a static library. */
6329 }
6332 {
6345 };
6347 /* Called near the start of bfd_elf_size_dynamic_sections. We use
6348 this hook to a) run the edit functions in this file, b) provide
6349 some gcc support functions, and c) transfer dynamic linking
6350 information gathered so far on function code symbol entries, to
6351 their corresponding function descriptor symbol entries. */
6353 static bfd_boolean
6355 {
6362 /* Call back into the linker, which then runs the edit functions. */
6365 /* Provide any missing _save* and _rest* functions. */
6367 {
6376 }
6382 {
6384 /* Make .TOC. defined so as to prevent it being made dynamic.
6385 The wrong value here is fixed later in ppc64_elf_set_toc. */
6388 {
6394 }
6398 }
6401 {
6404 }
6407 }
6409 /* Return true if we have dynamic relocs against H or any of its weak
6410 aliases, that apply to read-only sections. Cannot be used after
6411 size_dynamic_sections. */
6413 static bfd_boolean
6415 {
6417 do
6418 {
6422 }
6426 }
6428 /* Return whether EH has pc-relative dynamic relocs. */
6430 static bfd_boolean
6432 {
6439 }
6441 /* Return true if a global entry stub will be created for H. Valid
6442 for ELFv2 before plt entries have been allocated. */
6444 static bfd_boolean
6446 {
6459 }
6461 /* Adjust a symbol defined by a dynamic object and referenced by a
6462 regular object. The current definition is in some section of the
6463 dynamic object, but we're not including those sections. We have to
6464 change the definition to something the rest of the link can
6465 understand. */
6467 static bfd_boolean
6470 {
6478 /* Deal with function syms. */
6482 {
6486 /* Discard dyn_relocs when non-pic if we've decided that a
6487 function symbol is local and not an ifunc. We keep dynamic
6488 relocs for ifuncs when local rather than always emitting a
6489 plt call stub for them and defining the symbol on the call
6490 stub. We can't do that for ELFv1 anyway (a function symbol
6491 is defined on a descriptor, not code) and it can be faster at
6492 run-time due to not needing to bounce through a stub. The
6493 dyn_relocs for ifuncs will be applied even in a static
6494 executable. */
6500 /* Clear procedure linkage table information for any symbol that
6501 won't need a .plt entry. */
6508 && local
6512 {
6516 }
6518 {
6519 /* Taking a function's address in a read/write section
6520 doesn't require us to define the function symbol in the
6521 executable on a global entry stub. A dynamic reloc can
6522 be used instead. The reason we prefer a few more dynamic
6523 relocs is that calling via a global entry stub costs a
6524 few more instructions, and pointer_equality_needed causes
6525 extra work in ld.so when resolving these symbols. */
6527 {
6529 {
6531 /* If we haven't seen a branch reloc and the symbol
6532 isn't an ifunc then we don't need a plt entry. */
6535 }
6537 /* We are going to be defining the function symbol on the
6538 plt stub, so no dyn_relocs needed when non-pic. */
6540 }
6542 /* ELFv2 function symbols can't have copy relocs. */
6544 }
6547 {
6548 /* If we haven't seen a branch reloc and the symbol isn't an
6549 ifunc then we don't need a plt entry. */
6553 }
6554 }
6555 else
6558 /* If this is a weak symbol, and there is a real definition, the
6559 processor independent code will have arranged for us to see the
6560 real definition first, and we can just use the same value. */
6562 {
6571 }
6573 /* If we are creating a shared library, we must presume that the
6574 only references to the symbol are via the global offset table.
6575 For such cases we need not do anything here; the relocations will
6576 be handled correctly by relocate_section. */
6580 /* If there are no references to this symbol that do not use the
6581 GOT, we don't need to generate a copy reloc. */
6585 /* Don't generate a copy reloc for symbols defined in the executable. */
6588 /* If -z nocopyreloc was given, don't generate them either. */
6591 /* If we don't find any dynamic relocs in read-only sections, then
6592 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
6593 || (ELIMINATE_COPY_RELOCS
6597 /* Protected variables do not work with .dynbss. The copy in
6598 .dynbss won't be used by the shared library with the protected
6599 definition for the variable. Text relocations are preferable
6600 to an incorrect program. */
6606 {
6607 /* .dynbss copies of function symbols only work if we have
6608 ELFv1 dot-symbols. ELFv1 compilers since 2004 default to not
6609 use dot-symbols and set the function symbol size to the text
6610 size of the function rather than the size of the descriptor.
6611 That's wrong for copying a descriptor. */
6616 /* We should never get here, but unfortunately there are old
6617 versions of gcc (circa gcc-3.2) that improperly for the
6618 ELFv1 ABI put initialized function pointers, vtable refs and
6619 suchlike in read-only sections. Allow them to proceed, but
6620 warn that this might break at runtime. */
6625 }
6627 /* This is a reference to a symbol defined by a dynamic object which
6628 is not a function. */
6630 /* We must allocate the symbol in our .dynbss section, which will
6631 become part of the .bss section of the executable. There will be
6632 an entry for this symbol in the .dynsym section. The dynamic
6633 object will contain position independent code, so all references
6634 from the dynamic object to this symbol will go through the global
6635 offset table. The dynamic linker will use the .dynsym entry to
6636 determine the address it must put in the global offset table, so
6637 both the dynamic object and the regular object will refer to the
6638 same memory location for the variable. */
6640 {
6643 }
6644 else
6645 {
6648 }
6650 {
6651 /* We must generate a R_PPC64_COPY reloc to tell the dynamic
6652 linker to copy the initial value out of the dynamic object
6653 and into the runtime process image. */
6656 }
6658 /* We no longer want dyn_relocs. */
6661 }
6663 /* If given a function descriptor symbol, hide both the function code
6664 sym and the descriptor. */
6665 static void
6668 bfd_boolean force_local)
6669 {
6678 {
6682 {
6687 /* We aren't supposed to use alloca in BFD because on
6688 systems which do not have alloca the version in libiberty
6689 calls xmalloc, which might cause the program to crash
6690 when it runs out of memory. This function doesn't have a
6691 return status, so there's no way to gracefully return an
6692 error. So cheat. We know that string[-1] can be safely
6693 accessed; It's either a string in an ELF string table,
6694 or allocated in an objalloc structure. */
6703 /* Unfortunately, if it so happens that the string we were
6704 looking for was allocated immediately before this string,
6705 then we overwrote the string terminator. That's the only
6706 reason the lookup should fail. */
6708 {
6715 }
6717 {
6720 }
6721 }
6724 }
6725 }
6727 static bfd_boolean
6735 {
6739 {
6753 {
6759 }
6763 }
6764 else
6765 {
6770 {
6779 }
6792 {
6799 {
6805 }
6807 }
6808 }
6810 }
6812 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
6813 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
6814 type suitable for optimization, and 1 otherwise. */
6816 static int
6823 {
6829 bfd_vma off;
6843 /* Look inside a TOC section too. */
6845 {
6848 }
6849 else
6865 }
6867 /* Find (or create) an entry in the tocsave hash table. */
6875 {
6880 hashval_t hash;
6887 {
6888 _bfd_error_handler
6891 }
6895 else
6906 {
6912 }
6914 }
6916 /* Adjust all global syms defined in opd sections. In gcc generated
6917 code for the old ABI, these will already have been done. */
6919 static bfd_boolean
6921 {
6940 {
6943 {
6944 /* This entry has been deleted. */
6947 {
6950 {
6953 }
6954 }
6957 }
6958 else
6961 }
6963 }
6965 /* Handles decrementing dynamic reloc counts for the reloc specified by
6966 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
6967 have already been determined. */
6969 static bfd_boolean
6976 {
6980 /* Can this reloc be dynamic? This switch, and later tests here
6981 should be kept in sync with the code in check_relocs. */
6984 {
7049 }
7052 {
7059 }
7073 ;
7074 else
7078 {
7083 /* elf_gc_sweep may have already removed all dyn relocs associated
7084 with local syms for a given section. Also, symbol flags are
7085 changed by elf_gc_sweep_symbol, confusing the test above. Don't
7086 report a dynreloc miscount. */
7091 {
7093 {
7100 }
7102 }
7103 }
7104 else
7105 {
7109 bfd_boolean is_ifunc;
7124 {
7126 {
7131 }
7133 }
7134 }
7136 /* xgettext:c-format */
7141 }
7143 /* Remove unused Official Procedure Descriptor entries. Currently we
7144 only remove those associated with functions in discarded link-once
7145 sections, or weakly defined functions that have been overridden. It
7146 would be possible to remove many more entries for statically linked
7147 applications. */
7149 bfd_boolean
7151 {
7162 {
7184 /* Look through the section relocs. */
7191 /* Read the relocations. */
7197 /* First run through the relocs to check they are sane, and to
7198 determine whether we need to edit this opd section. */
7204 {
7210 bfd_vma offset;
7212 /* .opd contains an array of 16 or 24 byte entries. We're
7213 only interested in the reloc pointing to a function entry
7214 point. */
7218 {
7219 /* If someone messes with .opd alignment then after a
7220 "ld -r" we might have padding in the middle of .opd.
7221 Also, there's nothing to prevent someone putting
7222 something silly in .opd with the assembler. No .opd
7223 optimization for them! */
7224 broken_opd:
7225 _bfd_error_handler
7229 }
7233 {
7234 _bfd_error_handler
7235 /* xgettext:c-format */
7240 }
7248 {
7252 else
7254 sym_sec);
7256 _bfd_error_handler
7257 /* xgettext:c-format */
7262 }
7264 /* opd entries are always for functions defined in the
7265 current input bfd. If the symbol isn't defined in the
7266 input bfd, then we won't be using the function in this
7267 bfd; It must be defined in a linkonce section in another
7268 bfd, or is weak. It's also possible that we are
7269 discarding the function due to a linker script /DISCARD/,
7270 which we test for via the output_section. */
7282 {
7284 {
7287 }
7289 {
7290 cnt_16b++;
7292 }
7294 }
7298 {
7300 cnt_16b++;
7303 }
7304 else
7306 }
7311 {
7316 bfd_size_type amt;
7325 /* This seems a waste of time as input .opd sections are all
7326 zeros as generated by gcc, but I suppose there's no reason
7327 this will always be so. We might start putting something in
7328 the third word of .opd entries. */
7330 {
7333 {
7335 error_ret:
7341 }
7344 }
7350 {
7355 }
7360 {
7368 bfd_boolean skip;
7381 /* See if the .opd entry is full 24 byte or
7382 16 byte (with fd_aux entry overlapped with next
7383 fd_func). */
7386 {
7389 }
7395 {
7398 {
7403 }
7404 }
7409 {
7411 {
7412 /* Arrange for the function descriptor sym
7413 to be dropped. */
7416 }
7421 else
7423 {
7435 }
7436 }
7437 else
7438 {
7439 /* We'll be keeping this opd entry. */
7443 {
7444 /* Redefine the function descriptor symbol to
7445 this location in the opd section. It is
7446 necessary to update the value here rather
7447 than using an array of adjustments as we do
7448 for local symbols, because various places
7449 in the generic ELF code use the value
7450 stored in u.def.value. */
7453 }
7455 /* Local syms are a bit tricky. We could
7456 tweak them as they can be cached, but
7457 we'd need to look through the local syms
7458 for the function descriptor sym which we
7459 don't have at the moment. So keep an
7460 array of adjustments. */
7468 {
7471 }
7473 /* We need to adjust any reloc offsets to point to the
7474 new opd entries. */
7476 {
7481 }
7482 }
7485 }
7490 {
7493 }
7495 /* Fudge the header size too, as this is used later in
7496 elf_bfd_final_link if we are emitting relocs. */
7500 }
7506 {
7509 else
7511 }
7512 }
7517 /* If we are doing a final link and the last .opd entry is just 16 byte
7518 long, add a 8 byte padding after it. */
7520 {
7524 {
7537 }
7538 else
7539 {
7545 }
7549 }
7552 }
7554 /* Analyze inline PLT call relocations to see whether calls to locally
7555 defined functions can be converted to direct calls. */
7557 bfd_boolean
7559 {
7569 /* A bl insn can reach -0x2000000 to 0x1fffffc. The limit is
7570 reduced somewhat to cater for possible stubs that might be added
7571 between the call and its destination. */
7573 {
7577 }
7578 else
7579 {
7583 }
7589 {
7594 }
7596 /* If a "bl" can reach anywhere in local code sections, then we can
7597 convert all inline PLT sequences to direct calls when the symbol
7598 is local. */
7600 {
7603 }
7605 /* Otherwise, go looking through relocs for cases where a direct
7606 call won't reach. Mark the symbol on any such reloc to disable
7607 the optimization and keep the PLT entry as it seems likely that
7608 this will be better than creating trampolines. Note that this
7609 will disable the optimization for all inline PLT calls to a
7610 particular symbol, not just those that won't reach. The
7611 difficulty in doing a more precise optimization is that the
7612 linker needs to make a decision depending on whether a
7613 particular R_PPC64_PLTCALL insn can be turned into a direct
7614 call, for each of the R_PPC64_PLTSEQ and R_PPC64_PLT16* insns in
7615 the sequence, and there is nothing that ties those relocs
7616 together except their symbol. */
7619 {
7632 {
7635 /* Read the relocations. */
7643 {
7659 {
7665 }
7668 {
7672 else
7686 }
7687 }
7690 }
7694 {
7697 else
7699 }
7700 }
7703 }
7705 /* Set htab->tls_get_addr and various other info specific to TLS.
7706 This needs to run before dynamic symbols are processed in
7707 bfd_elf_size_dynamic_sections. */
7709 bfd_boolean
7711 {
7727 /* Default to --no-plt-localentry, as this option can cause problems
7728 with symbol interposition. For example, glibc libpthread.so and
7729 libc.so duplicate many pthread symbols, with a fallback
7730 implementation in libc.so. In some cases the fallback does more
7731 work than the pthread implementation. __pthread_condattr_destroy
7732 is one such symbol: the libpthread.so implementation is
7733 localentry:0 while the libc.so implementation is localentry:8.
7734 An app that "cleverly" uses dlopen to only load necessary
7735 libraries at runtime may omit loading libpthread.so when not
7736 running multi-threaded, which then results in the libc.so
7737 fallback symbols being used and ld.so complaining. Now there
7738 are workarounds in ld (see non_zero_localentry) to detect the
7739 pthread situation, but that may not be the only case where
7740 --plt-localentry can cause trouble. */
7744 {
7745 /* The issue is that __glink_PLTresolve saves r2, which is done
7746 because glibc ld.so _dl_runtime_resolve restores r2 to support
7747 a glibc plt call optimisation where global entry code is
7748 skipped on calls that resolve to the same binary. The
7749 __glink_PLTresolve save of r2 is incompatible with code
7750 making tail calls, because the tail call might go via the
7751 resolver and thus overwrite the proper saved r2. */
7755 }
7759 _bfd_error_handler
7767 /* Move dynamic linking info to the function descriptor sym. */
7784 {
7796 {
7797 /* If glibc supports an optimized __tls_get_addr call stub,
7798 signalled by the presence of __tls_get_addr_opt, and we'll
7799 be calling __tls_get_addr via a plt call stub, then
7800 make __tls_get_addr point to __tls_get_addr_opt. */
7817 {
7829 {
7831 {
7836 }
7838 {
7843 }
7846 {
7847 /* Use __tls_get_addr_opt in dynamic relocations. */
7853 }
7855 {
7859 {
7868 }
7872 {
7875 }
7876 }
7878 {
7881 {
7890 }
7894 {
7897 }
7898 }
7899 }
7900 }
7901 }
7904 }
7912 }
7914 /* Return TRUE iff REL is a branch reloc with a global symbol matching
7915 any of HASH1, HASH2, HASH3, or HASH4. */
7917 static bfd_boolean
7924 {
7930 {
7941 }
7943 }
7945 /* Run through all the TLS relocs looking for optimization
7946 opportunities. The linker has been hacked (see ppc64elf.em) to do
7947 a preliminary section layout so that we know the TLS segment
7948 offsets. We can't optimize earlier because some optimizations need
7949 to know the tp offset, and we need to optimize before allocating
7950 dynamic relocations. */
7952 bfd_boolean
7954 {
7970 /* Make two passes over the relocs. On the first pass, mark toc
7971 entries involved with tls relocs, and check that tls relocs
7972 involved in setting up a tls_get_addr call are indeed followed by
7973 such a call. If they are not, we can't do any tls optimization.
7974 On the second pass twiddle tls_mask flags to notify
7975 relocate_section that optimization can be done, and adjust got
7976 and plt refcounts. */
7980 {
7986 {
7990 /* Read the relocations. */
7994 {
7997 }
8001 {
8009 bfd_vma value;
8018 {
8019 err_free_rel:
8027 }
8030 {
8036 else
8037 {
8040 }
8041 }
8042 else
8043 /* Symbols referenced by TLS relocs must be of type
8044 STT_TLS. So no need for .opd local sym adjust. */
8050 {
8056 {
8060 /* Note that even though the prefix insns
8061 allow a 1<<33 offset we use the same test
8062 as for addis;addi. There may be a mix of
8063 pcrel and non-pcrel code and the decision
8064 to optimise is per symbol, not per TLS
8065 sequence. */
8067 }
8068 }
8071 /* If this section has old-style __tls_get_addr calls
8072 without marker relocs, then check that each
8073 __tls_get_addr call reloc is preceded by a reloc
8074 that conceivably belongs to the __tls_get_addr arg
8075 setup insn. If we don't find matching arg setup
8076 relocs, don't do any tls optimization. */
8081 && !found_tls_get_addr_arg
8083 {
8089 }
8093 {
8099 /* Fall through. */
8103 /* These relocs should never be against a symbol
8104 defined in a shared lib. Leave them alone if
8105 that turns out to be the case. */
8109 /* LD -> LE */
8120 /* Fall through. */
8125 /* GD -> LE */
8127 else
8128 /* GD -> IE */
8140 {
8141 /* IE -> LE */
8146 }
8152 /* Fall through. */
8156 {
8162 {
8168 {
8180 }
8181 }
8183 }
8185 /* Fall through. */
8193 /* Mark this toc entry as referenced by a TLS
8194 code sequence. We can do that now in the
8195 case of R_PPC64_TLS, and after checking for
8196 tls_get_addr for the TOC16 relocs. */
8198 toc_ref
8205 else
8216 {
8219 }
8236 {
8237 /* IE -> LE */
8241 }
8254 {
8256 /* GD -> LE */
8258 else
8259 /* GD -> IE */
8262 }
8263 else
8264 {
8268 /* LD -> LE */
8271 }
8276 {
8284 /* addis rt,13,imm */
8287 {
8288 /* xgettext:c-format */
8293 }
8294 }
8304 /* These can all be used in sequences along with
8305 TPREL16_LO or TPREL16_LO_DS in ways we aren't
8306 able to verify easily. */
8312 }
8315 {
8326 {
8328 {
8329 /* Check for toc tls entries. */
8339 {
8345 }
8346 }
8348 }
8350 /* Uh oh, we didn't find the expected call. We
8351 could just mark this symbol to exclude it
8352 from tls optimization but it's safer to skip
8353 the entire optimization. */
8354 /* xgettext:c-format */
8360 }
8362 /* If we don't have old-style __tls_get_addr calls
8363 without TLSGD/TLSLD marker relocs, and we haven't
8364 found a new-style __tls_get_addr call with a
8365 marker for this symbol, then we either have a
8366 broken object file or an -mlongcall style
8367 indirect call to __tls_get_addr without a marker.
8368 Disable optimization in this case. */
8377 {
8411 }
8417 {
8420 /* Adjust got entry for this reloc. */
8423 else
8435 {
8436 /* We managed to get rid of a got entry. */
8439 }
8440 }
8441 else
8442 {
8443 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8444 we'll lose one or two dyn relocs. */
8450 {
8454 }
8455 }
8459 }
8463 }
8467 {
8470 else
8472 }
8473 }
8477 }
8479 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8480 the values of any global symbols in a toc section that has been
8481 edited. Globals in toc sections should be a rarity, so this function
8482 sets a flag if any are found in toc sections other than the one just
8483 edited, so that further hash table traversals can be avoided. */
8485 struct adjust_toc_info
8486 {
8489 bfd_boolean global_toc_syms;
8490 };
8494 static bfd_boolean
8496 {
8510 {
8513 else
8517 {
8518 _bfd_error_handler
8520 do
8524 }
8528 }
8533 }
8535 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
8536 on a _LO variety toc/got reloc. */
8538 static bfd_boolean
8540 {
8558 /* Exclude lfqu by testing reloc. If relocs are ever
8559 defined for the reduced D field in psq_lu then those
8560 will need testing too. */
8566 /* Exclude stfqu. psq_stu as above for psq_lu. */
8570 }
8572 /* PCREL_OPT in one instance flags to the linker that a pair of insns:
8573 pld ra,symbol@got@pcrel
8574 load/store rt,off(ra)
8575 or
8576 pla ra,symbol@pcrel
8577 load/store rt,off(ra)
8578 may be translated to
8579 pload/pstore rt,symbol+off@pcrel
8580 nop.
8581 This function returns true if the optimization is possible, placing
8582 the prefix insn in *PINSN1, a NOP in *PINSN2 and the offset in *POFF.
8584 On entry to this function, the linker has already determined that
8585 the pld can be replaced with pla: *PINSN1 is that pla insn,
8586 while *PINSN2 is the second instruction. */
8588 static bfd_boolean
8590 {
8593 bfd_signed_vma off;
8596 {
8597 /* Check that regs match. */
8601 /* P8LS or PMLS form, non-pcrel. */
8610 }
8614 /* Check that regs match. */
8619 {
8634 /* These are the PMLS cases, where we just need to tack a prefix
8635 on the insn. */
8663 {
8668 }
8669 else
8670 {
8675 }
8701 }
8707 }
8709 /* Examine all relocs referencing .toc sections in order to remove
8710 unused .toc entries. */
8712 bfd_boolean
8714 {
8722 {
8745 /* Look at sections dropped from the final link. */
8749 {
8761 /* Run through the relocs to see which toc entries might be
8762 unused. */
8764 {
8770 bfd_vma val;
8774 {
8785 }
8797 else
8804 /* Anything in the toc ought to be aligned to 8 bytes.
8805 If not, don't mark as unused. */
8810 {
8814 }
8817 }
8821 }
8823 /* For largetoc loads of address constants, we can convert
8824 . addis rx,2,addr@got@ha
8825 . ld ry,addr@got@l(rx)
8826 to
8827 . addis rx,2,addr@toc@ha
8828 . addi ry,rx,addr@toc@l
8829 when addr is within 2G of the toc pointer. This then means
8830 that the word storing "addr" in the toc is no longer needed. */
8835 {
8836 /* Read toc relocs. */
8843 {
8869 {
8873 }
8874 else
8875 {
8879 }
8883 /* We don't yet know the exact toc pointer value, but we
8884 know it will be somewhere in the toc section. Don't
8885 optimize if the difference from any possible toc
8886 pointer is outside [ff..f80008000, 7fff7fff]. */
8896 {
8900 }
8904 }
8905 }
8912 {
8913 error_ret:
8923 }
8925 /* Now check all kept sections that might reference the toc.
8926 Check the toc itself last. */
8934 {
8947 {
8950 }
8952 /* Mark toc entries referenced as used. */
8953 do
8954 {
8957 {
8963 bfd_vma val;
8967 {
8974 /* In case we're taking addresses of toc entries. */
8980 }
8985 {
8988 }
8995 else
9003 {
9004 bfd_vma off;
9008 {
9017 {
9020 }
9023 /* Fall through. */
9026 /* Wrong sort of reloc, or not a ld. We may
9027 as well clear ref_from_discarded too. */
9029 }
9030 }
9034 /* For the toc section, we only mark as used if this
9035 entry itself isn't unused. */
9039 {
9040 /* Do all the relocs again, to catch reference
9041 chains. */
9044 }
9045 }
9046 }
9051 }
9053 /* Merge the used and skip arrays. Assume that TOC
9054 doublewords not appearing as either used or unused belong
9055 to an entry more than one doubleword in size. */
9059 {
9061 {
9066 }
9068 {
9071 }
9072 else
9074 }
9079 {
9085 /* Shuffle the toc contents, and at the same time convert the
9086 skip array from booleans into offsets. */
9095 {
9099 {
9102 }
9103 }
9108 /* Adjust addends for relocs against the toc section sym,
9109 and optimize any accesses we can. */
9111 {
9122 {
9127 bfd_vma val;
9131 {
9143 }
9155 else
9156 {
9160 }
9169 {
9170 Elf_Internal_Rela *tocrel
9175 {
9188 /* xgettext:c-format */
9195 }
9199 }
9206 }
9210 }
9212 /* We shouldn't have local or global symbols defined in the TOC,
9213 but handle them anyway. */
9220 {
9225 else
9229 {
9231 _bfd_error_handler
9234 do
9238 }
9242 }
9244 /* Adjust any global syms defined in this toc input section. */
9246 {
9252 }
9255 {
9258 bfd_size_type sz;
9260 /* Remove unused toc relocs, and adjust those we keep. */
9271 {
9276 }
9286 }
9287 }
9293 {
9296 else
9298 }
9300 }
9302 /* Look for cases where we can change an indirect GOT access to
9303 a GOT relative or PC relative access, possibly reducing the
9304 number of GOT entries. */
9306 {
9311 bfd_vma got;
9328 {
9337 {
9338 got_error_ret:
9345 }
9348 {
9362 {
9389 }
9392 {
9403 {
9409 /* xgettext:c-format */
9414 }
9415 }
9418 {
9419 /* Note that we don't delete GOT entries for
9420 R_PPC64_GOT16_DS since we'd need a lot more
9421 analysis. For starters, the preliminary layout is
9422 before the GOT, PLT, dynamic sections and stubs are
9423 laid out. Then we'd need to allow for changes in
9424 distance between sections caused by alignment. */
9432 }
9452 else
9457 /* Fudge factor to allow for the fact that the preliminary layout
9458 isn't exact. Reduce limits by this factor. */
9459 #define LIMIT_ADJUST(LIMIT) ((LIMIT) - (LIMIT) / 16)
9462 {
9508 }
9509 #undef LIMIT_ADJUST
9513 else
9514 {
9517 }
9525 }
9529 }
9533 {
9536 else
9538 }
9539 }
9542 }
9544 /* Return true iff input section I references the TOC using
9545 instructions limited to +/-32k offsets. */
9547 bfd_boolean
9549 {
9552 }
9554 /* Allocate space for one GOT entry. */
9556 static void
9560 {
9573 {
9576 }
9585 {
9588 }
9589 }
9591 /* This function merges got entries in the same toc group. */
9593 static void
9595 {
9605 {
9608 }
9609 }
9611 /* If H is undefined, make it dynamic if that makes sense. */
9613 static bfd_boolean
9616 {
9628 }
9630 /* Allocate space in .plt, .got and associated reloc sections for
9631 dynamic relocs. */
9633 static bfd_boolean
9635 {
9651 /* Run through the TLS GD got entries first if we're changing them
9652 to TPREL. */
9657 {
9658 /* This was a GD entry that has been converted to TPREL. If
9659 there happens to be a TPREL entry we can use that one. */
9666 {
9669 }
9671 /* If not, then we'll be using our own TPREL entry. */
9674 }
9676 /* Remove any list entry that won't generate a word in the GOT before
9677 we call merge_got_entries. Otherwise we risk merging to empty
9678 entries. */
9682 {
9685 {
9688 }
9689 else
9691 }
9692 else
9700 {
9701 /* Ensure we catch all the cases where this symbol should
9702 be made dynamic. */
9710 }
9712 /* If no dynamic sections we can't have dynamic relocs, except for
9713 IFUNCs which are handled even in static executables. */
9718 /* Discard relocs on undefined symbols that must be local. */
9723 /* Also discard relocs on undefined weak syms with non-default
9724 visibility, or when dynamic_undefined_weak says so. */
9729 {
9732 /* In the shared -Bsymbolic case, discard space allocated for
9733 dynamic pc-relative relocs against symbols which turn out to
9734 be defined in regular objects. For the normal shared case,
9735 discard space for relocs that have become local due to symbol
9736 visibility changes. */
9738 {
9739 /* Relocs that use pc_count are those that appear on a call
9740 insn, or certain REL relocs (see must_be_dyn_reloc) that
9741 can be generated via assembly. We want calls to
9742 protected symbols to resolve directly to the function
9743 rather than going via the plt. If people want function
9744 pointer comparisons to work as expected then they should
9745 avoid writing weird assembly. */
9747 {
9749 {
9754 else
9756 }
9757 }
9760 {
9761 /* Ensure we catch all the cases where this symbol
9762 should be made dynamic. */
9765 }
9766 }
9768 /* For a fixed position executable, discard space for
9769 relocs against symbols which are not dynamic. */
9771 {
9775 {
9776 /* Ensure we catch all the cases where this symbol
9777 should be made dynamic. */
9781 /* But if that didn't work out, discard dynamic relocs. */
9784 }
9785 else
9787 }
9789 /* Finally, allocate space. */
9791 {
9796 }
9797 }
9799 /* We might need a PLT entry when the symbol
9800 a) is dynamic, or
9801 b) is an ifunc, or
9802 c) has plt16 relocs and has been processed by adjust_dynamic_symbol, or
9803 d) has plt16 relocs and we are linking statically. */
9813 {
9818 {
9821 {
9823 {
9828 }
9829 else
9830 {
9835 }
9836 }
9837 else
9838 {
9839 /* If this is the first .plt entry, make room for the special
9840 first entry. */
9847 /* Make room for this entry. */
9850 /* Make room for the .glink code. */
9855 {
9856 /* We need bigger stubs past index 32767. */
9860 }
9861 else
9864 /* We also need to make an entry in the .rela.plt section. */
9866 }
9870 }
9871 else
9874 {
9877 }
9878 }
9879 else
9880 {
9883 }
9886 }
9888 #define PPC_LO(v) ((v) & 0xffff)
9889 #define PPC_HI(v) (((v) >> 16) & 0xffff)
9890 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
9891 #define D34(v) \
9892 ((((v) & 0x3ffff0000ULL) << 16) | (v & 0xffff))
9893 #define HA34(v) ((v + (1ULL << 33)) >> 34)
9895 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9896 to set up space for global entry stubs. These are put in glink,
9897 after the branch table. */
9899 static bfd_boolean
9901 {
9926 {
9927 /* For ELFv2, if this symbol is not defined in a regular file
9928 and we are not generating a shared library or pie, then we
9929 need to define the symbol in the executable on a call stub.
9930 This is to avoid text relocations. */
9938 else
9940 /* Setting section alignment is delayed until we know it is
9941 non-empty. Otherwise the .text output section will be
9942 aligned at least to plt_stub_align even when no global
9943 entry stubs are needed. */
9954 /* Note that for --plt-stub-align negative we have a possible
9955 dependency between stub offset and size. Break that
9956 dependency by assuming the max stub size when calculating
9957 the stub offset. */
9965 }
9967 }
9969 /* Set the sizes of the dynamic sections. */
9971 static bfd_boolean
9974 {
9978 bfd_boolean relocs;
9991 {
9992 /* Set the contents of the .interp section to the interpreter. */
9994 {
10000 }
10001 }
10003 /* Set up .got offsets for local syms, and space for local dynamic
10004 relocs. */
10006 {
10012 bfd_size_type locsymcount;
10019 {
10023 {
10026 {
10027 /* Input section has been discarded, either because
10028 it is a copy of a linkonce section or due to
10029 linker script /DISCARD/, so we'll be discarding
10030 the relocs too. */
10031 }
10033 {
10040 }
10041 }
10042 }
10056 {
10062 {
10064 {
10067 }
10068 else
10069 {
10075 {
10078 }
10081 {
10084 }
10088 {
10091 }
10093 }
10094 }
10095 else
10097 }
10099 /* Allocate space for plt calls to local syms. */
10102 {
10107 {
10109 {
10114 }
10118 else
10119 {
10125 }
10126 }
10127 else
10129 }
10130 }
10132 /* Allocate global sym .plt and .got entries, and space for global
10133 sym dynamic relocs. */
10141 {
10149 {
10151 {
10154 }
10155 else
10156 {
10164 {
10167 }
10168 }
10169 }
10170 else
10172 }
10174 /* We now have determined the sizes of the various dynamic sections.
10175 Allocate memory for them. */
10178 {
10183 /* These haven't been allocated yet; don't strip. */
10193 {
10194 /* Strip this section if we don't need it; see the
10195 comment below. */
10196 }
10198 {
10200 /* Not sized yet. */
10202 }
10204 {
10206 {
10210 /* We use the reloc_count field as a counter if we need
10211 to copy relocs into the output file. */
10213 }
10214 }
10215 else
10216 {
10217 /* It's not one of our sections, so don't allocate space. */
10219 }
10222 {
10223 /* If we don't need this section, strip it from the
10224 output file. This is mostly to handle .rela.bss and
10225 .rela.plt. We must create both sections in
10226 create_dynamic_sections, because they must be created
10227 before the linker maps input sections to output
10228 sections. The linker does that before
10229 adjust_dynamic_symbol is called, and it is that
10230 function which decides whether anything needs to go
10231 into these sections. */
10234 }
10243 /* Allocate memory for the section contents. We use bfd_zalloc
10244 here in case unused entries are not reclaimed before the
10245 section's contents are written out. This should not happen,
10246 but this way if it does we get a R_PPC64_NONE reloc in .rela
10247 sections instead of garbage.
10248 We also rely on the section contents being zero when writing
10249 the GOT and .dynrelro. */
10253 }
10256 {
10262 {
10265 else
10266 {
10270 }
10271 }
10274 {
10277 else
10278 {
10284 }
10285 }
10286 }
10289 {
10290 bfd_boolean tls_opt;
10292 /* Add some entries to the .dynamic section. We fill in the
10293 values later, in ppc64_elf_finish_dynamic_sections, but we
10294 must add the entries now so that we get the correct size for
10295 the .dynamic section. The DT_DEBUG entry is filled in by the
10296 dynamic linker and used by the debugger. */
10297 #define add_dynamic_entry(TAG, VAL) \
10298 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10301 {
10304 }
10307 {
10314 }
10317 {
10321 }
10329 {
10332 }
10335 {
10341 /* If any dynamic relocs apply to a read-only section,
10342 then we need a DT_TEXTREL entry. */
10348 {
10351 }
10352 }
10353 }
10354 #undef add_dynamic_entry
10357 }
10359 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
10361 static bfd_boolean
10363 {
10370 }
10372 /* Determine the type of stub needed, if any, for a call. */
10379 bfd_vma destination,
10381 {
10383 bfd_vma location;
10384 bfd_vma branch_offset;
10385 bfd_vma max_branch_offset;
10389 {
10394 {
10397 }
10402 {
10405 }
10407 /* Here, we know we don't have a plt entry. If we don't have a
10408 either a defined function descriptor or a defined entry symbol
10409 in a regular object file, then it is pointless trying to make
10410 any other type of stub. */
10414 }
10416 {
10423 {
10429 {
10432 }
10433 }
10434 }
10436 /* Determine where the call point is. */
10444 /* Determine if a long branch stub is needed. */
10452 /* We need a stub. Figure out whether a long_branch or plt_branch
10453 is needed later. */
10457 }
10459 /* Gets the address of a label (1:) in r11 and builds an offset in r12,
10460 then adds it to r11 (LOAD false) or loads r12 from r11+r12 (LOAD true).
10461 . mflr %r12
10462 . bcl 20,31,1f
10463 .1: mflr %r11
10464 . mtlr %r12
10465 . lis %r12,xxx-1b@highest
10466 . ori %r12,%r12,xxx-1b@higher
10467 . sldi %r12,%r12,32
10468 . oris %r12,%r12,xxx-1b@high
10469 . ori %r12,%r12,xxx-1b@l
10470 . add/ldx %r12,%r11,%r12 */
10474 {
10484 {
10487 else
10490 }
10492 {
10497 else
10500 }
10501 else
10502 {
10504 {
10507 }
10508 else
10509 {
10513 {
10516 }
10517 }
10519 {
10522 }
10524 {
10527 }
10529 {
10532 }
10535 else
10538 }
10540 }
10542 static unsigned int
10544 {
10550 else
10551 {
10554 else
10555 {
10559 }
10567 }
10569 }
10571 static unsigned int
10573 {
10579 else
10580 {
10589 }
10591 }
10596 {
10605 {
10612 }
10613 else
10614 {
10617 else
10618 {
10621 {
10627 }
10628 }
10632 {
10638 }
10640 {
10646 }
10647 }
10649 }
10653 bfd_boolean load)
10654 {
10657 {
10660 {
10663 }
10666 else
10672 }
10673 /* The minimum value for paddi is -0x200000000. The minimum value
10674 for li is -0x8000, which when shifted by 34 and added gives a
10675 minimum value of -0x2000200000000. The maximum value is
10676 0x1ffffffff+0x7fff<<34 which is 0x2000200000000-1. */
10678 {
10683 {
10686 }
10693 {
10696 }
10699 else
10701 }
10702 else
10703 {
10710 {
10713 }
10720 {
10723 }
10726 else
10728 }
10731 }
10733 static unsigned int
10735 {
10740 else
10742 }
10744 static unsigned int
10746 {
10751 else
10753 }
10759 {
10763 {
10770 }
10771 else
10772 {
10784 }
10789 }
10791 /* Emit .eh_frame opcode to advance pc by DELTA. */
10795 {
10800 {
10803 }
10805 {
10809 }
10810 else
10811 {
10815 }
10817 }
10819 /* Size of required .eh_frame opcode to advance pc by DELTA. */
10821 static unsigned int
10823 {
10825 /* DW_CFA_advance_loc+[1..63]. */
10828 /* DW_CFA_advance_loc1, byte. */
10831 /* DW_CFA_advance_loc2, 2 bytes. */
10833 /* DW_CFA_advance_loc4, 4 bytes. */
10835 }
10837 /* With power7 weakly ordered memory model, it is possible for ld.so
10838 to update a plt entry in one thread and have another thread see a
10839 stale zero toc entry. To avoid this we need some sort of acquire
10840 barrier in the call stub. One solution is to make the load of the
10841 toc word seem to appear to depend on the load of the function entry
10842 word. Another solution is to test for r2 being zero, and branch to
10843 the appropriate glink entry if so.
10845 . fake dep barrier compare
10846 . ld 12,xxx(2) ld 12,xxx(2)
10847 . mtctr 12 mtctr 12
10848 . xor 11,12,12 ld 2,xxx+8(2)
10849 . add 2,2,11 cmpldi 2,0
10850 . ld 2,xxx+8(2) bnectr+
10851 . bctr b <glink_entry>
10853 The solution involving the compare turns out to be faster, so
10854 that's what we use unless the branch won't reach. */
10856 #define ALWAYS_USE_FAKE_DEP 0
10857 #define ALWAYS_EMIT_R2SAVE 0
10862 bfd_vma off,
10864 {
10868 {
10871 else
10875 }
10876 else
10877 {
10885 {
10897 }
10898 }
10902 {
10904 {
10909 }
10910 else
10911 {
10916 }
10917 }
10919 }
10921 /* Depending on the sign of plt_stub_align:
10922 If positive, return the padding to align to a 2**plt_stub_align
10923 boundary.
10924 If negative, if this stub would cross fewer 2**plt_stub_align
10925 boundaries if we align, then return the padding needed to do so. */
10930 bfd_vma plt_off,
10932 {
10938 {
10943 }
10951 }
10953 /* Build a .plt call stub. */
10959 {
10971 && plt_load_toc
10972 && plt_thread_safe
10976 {
10985 to = (glinkoff
11000 }
11003 {
11005 {
11014 {
11016 {
11020 }
11021 else
11022 {
11027 {
11031 }
11032 }
11033 }
11034 }
11039 {
11042 }
11043 else
11044 {
11047 }
11050 {
11053 }
11056 {
11058 {
11061 }
11065 }
11066 }
11067 else
11068 {
11070 {
11076 {
11078 {
11082 }
11083 else
11084 {
11089 {
11093 }
11094 }
11095 }
11096 }
11103 {
11106 }
11109 {
11111 {
11114 }
11118 }
11119 }
11121 {
11125 }
11126 else
11129 }
11131 /* Build a special .plt call stub for __tls_get_addr. */
11133 #define LD_R0_0R3 0xe8030000
11134 #define LD_R12_0R3 0xe9830000
11135 #define MR_R0_R3 0x7c601b78
11136 #define CMPDI_R0_0 0x2c200000
11137 #define ADD_R3_R12_R13 0x7c6c6a14
11138 #define BEQLR 0x4d820020
11139 #define MR_R3_R0 0x7c030378
11140 #define BCTRL 0x4e800421
11146 {
11161 {
11166 }
11168 }
11175 {
11179 {
11184 {
11187 }
11189 }
11192 {
11203 }
11207 {
11214 {
11217 /* After the bctrl, lr has been modified so we need to emit
11218 .eh_frame info saying the return address is on the stack. In
11219 fact we must put the EH info at or before the call rather
11220 than after it, because the EH info for a call needs to be
11221 specified by that point.
11222 See libgcc/unwind-dw2.c execute_cfa_program.
11223 Any stack pointer update must be described immediately after
11224 the instruction making the change, and since the stdu occurs
11225 after saving regs we put all the reg saves and the cfa
11226 change there. */
11234 {
11237 }
11238 else
11244 {
11247 }
11258 }
11261 {
11275 }
11276 }
11278 }
11282 {
11289 {
11290 bfd_size_type relsize;
11304 }
11308 }
11310 /* Convert the relocs R[0] thru R[-NUM_REL+1], which are all no-symbol
11311 forms, to the equivalent relocs against the global symbol given by
11312 STUB_ENTRY->H. */
11314 static bfd_boolean
11318 {
11322 bfd_vma symval;
11324 /* Relocs are always against symbols in their own object file. Fake
11325 up global sym hashes for the stub bfd (which has no symbols). */
11328 {
11329 bfd_size_type hsize;
11331 /* When called the first time, stub_globals will contain the
11332 total number of symbols seen during stub sizing. After
11333 allocating, stub_globals is used as an index to fill the
11334 hashes array. */
11341 }
11351 {
11354 {
11355 /* H is an opd symbol. The addend must be zero, and the
11356 branch reloc is the only one we can convert. */
11359 }
11360 else
11363 }
11365 }
11367 static bfd_vma
11370 {
11375 {
11376 /* Support linking -R objects. Get the toc pointer from the
11377 opd entry. */
11386 {
11392 }
11397 }
11400 }
11402 static bfd_boolean
11404 {
11417 bfd_boolean is_tga;
11419 /* Massage our args to the form they really have. */
11423 /* Fail if the target section could not be assigned to an output
11424 section. The user should fix his linker script. */
11432 /* Same for the group. */
11437 "output section. Retry without "
11451 {
11454 /* Branches are relative. This is where we are going to. */
11460 /* And this is where we are coming from. */
11469 {
11473 {
11476 }
11480 {
11483 }
11485 {
11488 }
11490 }
11495 {
11496 _bfd_error_handler
11501 }
11504 {
11514 }
11523 {
11528 }
11540 {
11544 {
11545 /* Create a reloc for the branch lookup table entry. */
11546 Elf_Internal_Rela rela;
11559 }
11561 {
11565 /* brlt, being SEC_LINKER_CREATED does not go through the
11566 normal reloc processing. Symbols and offsets are not
11567 translated from input file to output file form, so
11568 set up the offset per the output file. */
11574 }
11575 }
11586 {
11593 }
11596 {
11608 {
11613 }
11614 }
11619 {
11621 {
11625 }
11626 else
11628 }
11629 else
11630 {
11634 {
11637 }
11642 {
11646 }
11647 else
11651 {
11654 }
11656 {
11659 }
11660 }
11685 {
11688 }
11692 {
11696 }
11698 {
11707 {
11710 else
11712 }
11714 }
11715 else
11725 {
11728 }
11729 else
11730 {
11733 {
11751 }
11753 /* The notoc stubs calculate their target (either a PLT entry or
11754 the global entry point of a function) relative to the PC
11755 returned by the "bcl" two instructions past the start of the
11756 sequence emitted by build_offset. The offset is therefore 8
11757 less than calculated from the start of the sequence. */
11761 }
11764 {
11765 bfd_vma from;
11772 }
11773 else
11774 {
11778 }
11785 {
11789 else
11790 {
11793 }
11799 else
11803 {
11812 }
11813 }
11821 {
11824 /* If the old-ABI "dot-symbol" is undefined make it weak so
11825 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL. */
11830 }
11832 /* Now build the stub. */
11841 {
11844 else
11846 }
11854 {
11856 /* xgettext:c-format */
11864 }
11868 {
11881 }
11888 {
11892 }
11904 }
11909 {
11938 {
11948 }
11949 }
11952 }
11954 /* As above, but don't actually build the stub. Just bump offset so
11955 we know stub section sizes, and select plt_branch stubs where
11956 long_branch stubs won't do. */
11958 static bfd_boolean
11960 {
11968 /* Massage our args to the form they really have. */
11976 /* Fail if the target section could not be assigned to an output
11977 section. The user should fix his linker script. */
11985 /* Same for the group. */
11990 "output section. Retry without "
11995 /* Make a note of the offset within the stubs for this entry. */
12002 {
12003 /* Don't make stubs to out-of-line register save/restore
12004 functions. Instead, emit copies of the functions. */
12008 }
12011 {
12014 /* Reset the stub type from the plt branch variant in case we now
12015 can reach with a shorter stub. */
12017 /* Fall through. */
12031 {
12034 {
12037 }
12044 }
12047 /* If the branch offset is too big, use a ppc_stub_plt_branch.
12048 Do the same for -R objects without function descriptors. */
12053 {
12060 {
12065 }
12068 {
12076 {
12079 }
12080 }
12090 {
12094 }
12098 {
12102 }
12103 else
12104 {
12113 }
12114 }
12116 {
12119 }
12125 /* Fall through. */
12142 {
12146 else
12150 }
12154 else
12156 /* Include branch insn plus those in the offset sequence. */
12158 /* The branch insn is at the end, or "extra" bytes along. So
12159 its offset will be "extra" bytes less that that already
12160 calculated. */
12164 {
12165 /* After the bcl, lr has been modified so we need to emit
12166 .eh_frame info saying the return address is in r12. */
12170 /* The eh_frame info will consist of a DW_CFA_advance_loc or
12171 variant, DW_CFA_register, 65, 12, DW_CFA_advance_loc+2,
12172 DW_CFA_restore_extended 65. */
12176 }
12178 /* If the branch can't reach, use a plt_branch. */
12180 {
12184 }
12195 {
12201 }
12212 {
12215 else
12217 }
12227 {
12234 }
12237 {
12241 else
12245 }
12250 {
12251 /* After the bcl, lr has been modified so we need to emit
12252 .eh_frame info saying the return address is in r12. */
12254 /* The eh_frame info will consist of a DW_CFA_advance_loc or
12255 variant, DW_CFA_register, 65, 12, DW_CFA_advance_loc+2,
12256 DW_CFA_restore_extended 65. */
12260 }
12266 {
12268 {
12275 }
12277 {
12283 }
12284 }
12296 {
12299 else
12301 }
12309 {
12314 }
12317 {
12325 }
12333 {
12335 {
12336 /* Adjustments to r1 need to be described. */
12341 }
12342 else
12343 {
12345 /* The eh_frame info will consist of a DW_CFA_advance_loc
12346 or variant, DW_CFA_offset_externed_sf, 65, -stackoff,
12347 DW_CFA_advance_loc+4, DW_CFA_restore_extended, 65. */
12350 }
12352 }
12358 }
12362 }
12364 /* Set up various things so that we can make a list of input sections
12365 for each output section included in the link. Returns -1 on error,
12366 0 when no stubs will be needed, and 1 on success. */
12368 int
12370 {
12384 /* Set toc_off for com, und, abs and ind sections. */
12389 }
12391 /* Set up for first pass at multitoc partitioning. */
12393 void
12395 {
12401 }
12403 /* The linker repeatedly calls this function for each TOC input section
12404 and linker generated GOT section. Group input bfds such that the toc
12405 within a group is less than 64k in size. */
12407 bfd_boolean
12409 {
12417 {
12418 /* Keep track of the first .toc or .got section for this input bfd. */
12422 {
12425 }
12433 {
12438 }
12440 /* toc_curr is the base address of this toc group. Set elf_gp
12441 for the input section to be the offset relative to the
12442 output toc base plus 0x8000. Making the input elf_gp an
12443 offset allows us to move the toc as a whole without
12444 recalculating input elf_gp. */
12448 /* Die if someone uses a linker script that doesn't keep input
12449 file .toc and .got together. */
12457 }
12459 /* During the second pass toc_first_sec points to the start of
12460 a toc group, and toc_curr is used to track the old elf_gp.
12461 We use toc_bfd to ensure we only look at each bfd once. */
12468 {
12471 }
12478 }
12480 /* Called via elf_link_hash_traverse to merge GOT entries for global
12481 symbol H. */
12483 static bfd_boolean
12485 {
12492 }
12494 /* Called via elf_link_hash_traverse to allocate GOT entries for global
12495 symbol H. */
12497 static bfd_boolean
12499 {
12509 }
12511 /* Called on the first multitoc pass after the last call to
12512 ppc64_elf_next_toc_section. This function removes duplicate GOT
12513 entries. */
12515 bfd_boolean
12517 {
12520 bfd_boolean done_something;
12527 /* Merge global sym got entries within a toc group. */
12530 /* And tlsld_got. */
12532 {
12541 {
12543 {
12551 {
12554 }
12555 }
12556 }
12557 }
12559 /* Zap sizes of got sections. */
12565 {
12573 {
12579 }
12580 }
12582 /* Now reallocate the got, local syms first. We don't need to
12583 allocate section contents again since we never increase size. */
12585 {
12591 bfd_size_type locsymcount;
12610 {
12614 {
12620 {
12623 }
12626 {
12629 }
12633 {
12636 }
12637 }
12638 }
12639 }
12644 {
12653 {
12658 {
12661 }
12662 }
12663 }
12668 {
12676 {
12680 }
12681 }
12686 /* Set up for second pass over toc sections to recalculate elf_gp
12687 on input sections. */
12692 }
12694 /* Called after second pass of multitoc partitioning. */
12696 void
12698 {
12701 /* After the second pass, toc_curr tracks the TOC offset used
12702 for code sections below in ppc64_elf_next_input_section. */
12704 }
12706 /* No toc references were found in ISEC. If the code in ISEC makes no
12707 calls, then there's no need to use toc adjusting stubs when branching
12708 into ISEC. Actually, indirect calls from ISEC are OK as they will
12709 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
12710 needed, and 2 if a cyclical call-graph was found but no other reason
12711 for a stub was detected. If called from the top level, a return of
12712 2 means the same as a return of 0. */
12714 static int
12716 {
12719 /* Mark this section as checked. */
12722 /* We know none of our code bearing sections will need toc stubs. */
12734 {
12744 /* Look for branches to outside of this section. */
12751 {
12759 bfd_vma sym_value;
12760 bfd_vma dest;
12775 {
12778 }
12780 /* Calls to dynamic lib functions go through a plt call stub
12781 that uses r2. */
12787 {
12790 }
12793 /* Ignore other undefined symbols. */
12796 /* Assume branches to other sections not included in the
12797 link need stubs too, to cover -R and absolute syms. */
12799 {
12802 }
12806 else
12807 {
12812 }
12815 /* If this branch reloc uses an opd sym, find the code section. */
12818 {
12820 {
12825 /* Assume deleted functions won't ever be called. */
12828 }
12834 }
12835 else
12836 dest = (sym_value
12840 /* Ignore branch to self. */
12844 /* If the called function uses the toc, we need a stub. */
12847 {
12850 }
12852 /* Assume any branch that needs a long branch stub might in fact
12853 need a plt_branch stub. A plt_branch stub uses r2. */
12860 {
12863 }
12865 /* If calling back to a section in the process of being
12866 tested, we can't say for sure that no toc adjusting stubs
12867 are needed, so don't return zero. */
12871 /* Branches to another section that itself doesn't have any TOC
12872 references are OK. Recursively call ourselves to check. */
12874 {
12877 /* Mark current section as indeterminate, so that other
12878 sections that call back to current won't be marked as
12879 known. */
12885 {
12889 }
12890 }
12891 }
12898 }
12904 {
12909 {
12916 }
12917 }
12923 }
12925 /* The linker repeatedly calls this function for each input section,
12926 in the order that input sections are linked into output sections.
12927 Build lists of input sections to determine groupings between which
12928 we may insert linker stubs. */
12930 bfd_boolean
12932 {
12940 {
12941 /* This happens to make the list in reverse order,
12942 which is what we want. */
12946 }
12949 {
12950 /* Analyse sections that aren't already flagged as needing a
12951 valid toc pointer. Exclude .fixup for the linux kernel.
12952 .fixup contains branches, but only back to the function that
12953 hit an exception. */
12958 {
12961 }
12962 /* Make all sections use the TOC assigned for this object file.
12963 This will be wrong for pasted sections; We fix that in
12964 check_pasted_section(). */
12967 }
12971 }
12973 /* Check that all .init and .fini sections use the same toc, if they
12974 have toc relocs. */
12976 static bfd_boolean
12978 {
12982 {
12989 {
12994 }
12999 {
13002 }
13004 /* Make sure the whole pasted function uses the same toc offset. */
13008 }
13010 }
13012 bfd_boolean
13014 {
13017 }
13019 /* See whether we can group stub sections together. Grouping stub
13020 sections may result in fewer stubs. More importantly, we need to
13021 put all .init* and .fini* stubs at the beginning of the .init or
13022 .fini output sections respectively, because glibc splits the
13023 _init and _fini functions into multiple parts. Putting a stub in
13024 the middle of a function is not a good idea. */
13026 static bfd_boolean
13028 bfd_size_type stub_group_size,
13029 bfd_boolean stubs_always_before_branch)
13030 {
13033 bfd_boolean suppress_size_errors;
13041 {
13042 /* Default values. */
13045 else
13048 }
13051 {
13059 {
13062 bfd_size_type total;
13063 bfd_boolean big_sec;
13064 bfd_vma curr_toc;
13066 bfd_size_type group_size;
13076 /* xgettext:c-format */
13089 /* OK, the size from the start of CURR to the end is less
13090 than group_size and thus can be handled by one stub
13091 section. (or the tail section is itself larger than
13092 group_size, in which case we may be toast.) We should
13093 really be keeping track of the total size of stubs added
13094 here, as stubs contribute to the final output section
13095 size. That's a little tricky, and this way will only
13096 break if stubs added make the total size more than 2^25,
13097 ie. for the default stub_group_size, if stubs total more
13098 than 2097152 bytes, or nearly 75000 plt call stubs. */
13110 do
13111 {
13113 /* Set up this stub group. */
13115 }
13118 /* But wait, there's more! Input sections up to group_size
13119 bytes before the stub section can be handled by it too.
13120 Don't do this if we have a really large section after the
13121 stubs, as adding more stubs increases the chance that
13122 branches may not reach into the stub section. */
13124 {
13133 {
13137 }
13138 }
13140 }
13141 }
13143 }
13146 {
13157 };
13159 /* Stripping output sections is normally done before dynamic section
13160 symbols have been allocated. This function is called later, and
13161 handles cases like htab->brlt which is mapped to its own output
13162 section. */
13164 static void
13166 {
13173 {
13177 }
13178 }
13180 /* Determine and set the size of the stub section for a final link.
13182 The basic idea here is to examine all the relocations looking for
13183 PC-relative calls to a target that is unreachable with a "bl"
13184 instruction. */
13186 bfd_boolean
13188 {
13189 bfd_size_type stub_group_size;
13190 bfd_boolean stubs_always_before_branch;
13204 {
13206 {
13208 /* libstdc++ */
13210 /* librt */
13213 /* libanl */
13215 /* libgomp */
13228 /* libgo */
13230 };
13234 {
13241 }
13242 }
13246 else
13259 {
13261 bfd_vma sym_value;
13284 }
13286 #define STUB_SHRINK_ITER 20
13287 /* Loop until no stubs added. After iteration 20 of this loop we may
13288 exit on a stub section shrinking. This is to break out of a
13289 pathological case where adding stubs on one iteration decreases
13290 section gaps (perhaps due to alignment), which then requires
13291 fewer or smaller stubs on the next iteration. */
13294 {
13304 {
13312 /* We'll need the symbol table in a second. */
13317 /* Walk over each section attached to the input bfd. */
13321 {
13324 /* If there aren't any relocs, then there's nothing more
13325 to do. */
13333 /* If this section is a link-once section that will be
13334 discarded, then don't create any stubs. */
13339 /* Get the relocs. */
13340 internal_relocs
13346 /* Now examine each relocation. */
13350 {
13357 bfd_vma destination;
13359 bfd_boolean ok_dest;
13373 {
13376 }
13378 /* Only look for stubs on branch instructions. */
13386 /* Now determine the call target, its name, value,
13387 section. */
13397 {
13402 }
13405 {
13409 }
13412 {
13413 /* Recognise an old ABI func code entry sym, and
13414 use the func descriptor sym instead if it is
13415 defined. */
13418 {
13422 {
13427 }
13428 else
13430 }
13431 }
13432 else
13433 {
13436 }
13441 {
13443 destination = (sym_value
13449 }
13455 {
13456 bfd_vma dest;
13459 {
13465 }
13469 {
13472 {
13473 /* Fixup old ABI sym to point at code
13474 entry. */
13478 }
13479 }
13480 }
13482 /* Determine what (if any) linker stub is needed. */
13486 local_off);
13489 {
13499 }
13501 {
13502 /* Check whether we need a TOC adjusting stub.
13503 Since the linker pastes together pieces from
13504 different object files when creating the
13505 _init and _fini functions, it may be that a
13506 call to what looks like a local sym is in
13507 fact a call needing a TOC adjustment. */
13518 }
13523 /* __tls_get_addr calls might be eliminated. */
13530 {
13531 /* Get tls info. */
13540 }
13543 {
13552 {
13556 }
13557 else
13559 }
13561 /* Support for grouping stub sections. */
13564 /* Get the name of this stub. */
13572 {
13575 /* A stub has already been created, but it may
13576 not be the required type. We shouldn't be
13577 transitioning from plt_call to long_branch
13578 stubs or vice versa, but we might be
13579 upgrading from plt_call to plt_call_r2save or
13580 from long_branch to long_branch_r2off. */
13583 {
13584 /* For --power10-stubs=auto, don't merge _notoc
13585 and other varieties of stubs. (The _both
13586 variety won't be created.) */
13592 {
13598 {
13599 /* xgettext:c-format */
13600 _bfd_error_handler
13604 }
13608 /* Sort notoc stubs first, for no good
13609 reason. */
13612 }
13614 }
13617 {
13631 {
13634 }
13636 {
13639 }
13640 else
13648 old_type += (ppc_stub_long_branch
13650 /* Fall through. */
13658 {
13661 }
13663 {
13666 }
13667 else
13670 }
13674 }
13678 {
13680 error_ret_free_internal:
13683 error_ret_free_local:
13688 }
13693 {
13696 }
13697 else
13698 {
13701 }
13704 stub_entry->symtype
13712 }
13714 /* We're done with the internal relocs, free them. */
13717 }
13721 {
13724 else
13726 }
13727 }
13729 /* We may have added some stubs. Find out the new size of the
13730 stub sections. */
13732 {
13736 {
13741 /* Past STUB_SHRINK_ITER, rawsize is the max size seen. */
13746 }
13747 }
13749 {
13750 /* See emit_tga_desc and emit_tga_desc_eh_frame. */
13755 }
13774 {
13777 }
13782 {
13796 }
13801 {
13805 }
13824 /* Ask the linker to do its stuff. */
13826 }
13830 {
13831 bfd_vma val;
13836 /* It is necessary to at least have a rough outline of the
13837 linker generated CIEs and FDEs written before
13838 bfd_elf_discard_info is run, in order for these FDEs to be
13839 indexed in .eh_frame_hdr. */
13848 /* CIE length (rewrite in case little-endian). */
13855 {
13859 /* FDE length. */
13862 /* CIE pointer. */
13866 /* Offset to stub section, written later. */
13868 /* stub section size. */
13871 /* Augmentation. */
13873 /* Make sure we don't have all nops. This is enough for
13874 elf-eh-frame.c to detect the last non-nop opcode. */
13877 }
13879 {
13882 /* FDE length. */
13885 /* CIE pointer. */
13889 /* Offset to .glink, written later. */
13891 /* .glink size. */
13894 /* Augmentation. */
13905 }
13906 /* Subsume any padding into the last FDE if user .eh_frame
13907 sections are aligned more than glink_eh_frame. Otherwise any
13908 zero padding will be seen as a terminator. */
13914 }
13923 }
13925 /* Called after we have determined section placement. If sections
13926 move, we'll be called again. Provide a value for TOCstart. */
13928 bfd_vma
13930 {
13935 {
13942 else
13943 {
13947 }
13953 {
13957 }
13958 }
13960 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
13961 order. The TOC starts where the first of these sections starts. */
13970 {
13971 /* This may happen for
13972 o references to TOC base (SYM@toc / TOC[tc0]) without a
13973 .toc directive
13974 o bad linker script
13975 o --gc-sections and empty TOC sections
13977 FIXME: Warn user? */
13979 /* Look for a likely section. We probably won't even be
13980 using TOCstart. */
14000 }
14006 /* Force alignment. */
14012 {
14016 {
14018 {
14021 }
14022 }
14023 else
14024 {
14029 }
14030 }
14032 }
14034 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
14035 write out any global entry stubs, and PLT relocations. */
14037 static bfd_boolean
14039 {
14055 {
14056 /* This symbol has an entry in the procedure linkage
14057 table. Set it up. */
14058 Elf_Internal_Rela rela;
14064 {
14070 {
14076 else
14078 }
14079 else
14080 {
14083 {
14087 else
14089 }
14090 else
14092 }
14096 {
14100 {
14104 }
14105 }
14106 else
14107 {
14114 }
14115 }
14116 else
14117 {
14129 }
14130 }
14145 {
14148 bfd_vma off;
14154 {
14157 else
14159 }
14164 {
14170 }
14174 {
14186 {
14196 }
14197 }
14200 {
14203 }
14210 }
14212 }
14214 /* Write PLT relocs for locals. */
14216 static bfd_boolean
14218 {
14223 {
14227 bfd_size_type locsymcount;
14246 {
14251 bfd_vma val;
14255 {
14259 }
14266 {
14270 }
14271 else
14272 {
14275 }
14278 {
14282 {
14285 }
14286 }
14287 else
14288 {
14289 Elf_Internal_Rela rela;
14294 {
14297 else
14299 }
14300 else
14301 {
14304 else
14306 }
14311 }
14312 }
14316 {
14319 else
14321 }
14322 }
14324 }
14326 /* Emit the static wrapper function preserving registers around a
14327 __tls_get_addr_opt call. */
14329 static bfd_boolean
14331 {
14344 {
14348 }
14356 }
14358 /* Emit eh_frame describing the static wrapper function. */
14362 {
14369 {
14372 }
14373 else
14379 {
14382 }
14392 }
14394 /* Build all the stubs associated with the current output file.
14395 The stubs are kept in a hash table attached to the main linker
14396 hash table. This function is called via gldelf64ppc_finish. */
14398 bfd_boolean
14401 {
14411 /* Allocate memory to hold the linker stubs. */
14413 {
14418 {
14424 }
14425 }
14428 {
14430 bfd_vma plt0;
14432 /* Build the .glink plt call stub. */
14434 {
14441 {
14451 }
14452 }
14457 {
14465 }
14471 {
14492 }
14493 else
14494 {
14497 /* 0:
14498 . .quad plt0-1f # plt0 entry relative to 1:
14499 #
14500 # We get here with r12 initially @ a glink branch
14501 # Load the address of _dl_runtime_resolve from plt0 and
14502 # jump to it, with r0 set to the index of the PLT entry
14503 # to be resolved and r11 the link map.
14504 __glink_PLTresolve:
14505 . std %r2,24(%r1) # optional
14506 . mflr %r0
14507 . bcl 20,31,1f
14508 1:
14509 . mflr %r11
14510 . mtlr %r0
14511 . ld %r0,(0b-1b)(%r11)
14512 . sub %r12,%r12,%r11
14513 . add %r11,%r0,%r11
14514 . addi %r0,%r12,1b-2f
14515 . ld %r12,0(%r11)
14516 . srdi %r0,%r0,2
14517 . mtctr %r12
14518 . ld %r11,8(%r11)
14519 . bctr
14520 2:
14521 . b __glink_PLTresolve
14522 . ...
14523 . b __glink_PLTresolve */
14526 {
14529 }
14540 else
14558 }
14563 /* Build the .glink lazy link call stubs. */
14566 {
14568 {
14570 {
14573 }
14574 else
14575 {
14579 p);
14581 }
14582 }
14585 indx++;
14587 }
14588 }
14591 {
14598 {
14605 }
14606 }
14608 /* Build .glink global entry stubs, and PLT relocs for globals. */
14615 {
14620 }
14622 {
14627 }
14629 /* Build the stubs as directed by the stub hash table. */
14642 {
14645 }
14649 {
14654 {
14660 }
14661 }
14665 {
14666 bfd_vma val;
14674 {
14675 /* Offset to stub section. */
14682 {
14683 _bfd_error_handler
14687 }
14690 }
14692 {
14693 /* Offset to .glink. */
14701 {
14702 _bfd_error_handler
14706 }
14709 }
14710 }
14714 {
14720 }
14723 {
14726 }
14732 {
14737 stub_sec_count),
14740 else
14741 {
14756 groupmsg,
14772 }
14773 }
14775 }
14777 /* What to do when ld finds relocations against symbols defined in
14778 discarded sections. */
14780 static unsigned int
14782 {
14793 }
14795 /* These are the dynamic relocations supported by glibc. */
14797 static bfd_boolean
14799 {
14801 {
14852 }
14853 }
14855 /* The RELOCATE_SECTION function is called by the ELF backend linker
14856 to handle the relocations for a section.
14858 The relocs are always passed as Rela structures; if the section
14859 actually uses Rel structures, the r_addend field will always be
14860 zero.
14862 This function is responsible for adjust the section contents as
14863 necessary, and (if using Rela relocs and generating a
14864 relocatable output file) adjusting the reloc addend as
14865 necessary.
14867 This function does not have to worry about setting the reloc
14868 address or the reloc symbol index.
14870 LOCAL_SYMS is a pointer to the swapped in local symbols.
14872 LOCAL_SECTIONS is an array giving the section in the input file
14873 corresponding to the st_shndx field of each local symbol.
14875 The global hash table entry for the global symbols can be found
14876 via elf_sym_hashes (input_bfd).
14878 When generating relocatable output, this function must handle
14879 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
14880 going to be the section symbol corresponding to the output
14881 section, which means that the addend must be adjusted
14882 accordingly. */
14884 static bfd_boolean
14893 {
14900 Elf_Internal_Rela outrel;
14903 bfd_vma TOCstart;
14905 bfd_boolean is_opd;
14906 /* Assume 'at' branch hints. */
14911 /* Initialize howto table if needed. */
14919 /* Don't relocate stub sections. */
14924 {
14927 }
14938 {
14940 bfd_vma addend;
14941 bfd_reloc_status_type r;
14949 bfd_vma toc_addend;
14952 bfd_vma relocation;
14954 bfd_boolean warned;
14959 bfd_vma max_br_offset;
14960 bfd_vma from;
14961 Elf_Internal_Rela orig_rel;
14965 bfd_vma offset;
14967 again:
14973 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
14974 symbol of the previous ADDR64 reloc. The symbol gives us the
14975 proper TOC base to use. */
14990 {
14991 /* It's a local symbol. */
15001 {
15006 else
15007 {
15008 /* If this is a relocation against the opd section sym
15009 and we have edited .opd, adjust the reloc addend so
15010 that ld -r and ld --emit-relocs output is correct.
15011 If it is a reloc against some other .opd symbol,
15012 then the symbol value will be adjusted later. */
15015 else
15017 }
15018 }
15019 }
15020 else
15021 {
15022 bfd_boolean ignored;
15033 {
15034 /* This is a symbol defined in a linker script. All
15035 such are defined in output sections, even those
15036 defined by simple assignment from a symbol defined in
15037 an input section. Transfer the symbol to an
15038 appropriate input .opd section, so that a branch to
15039 this symbol will be mapped to the location specified
15040 by the opd entry. */
15044 {
15049 {
15054 }
15055 }
15056 }
15057 }
15061 {
15069 /* For ld -r, remove relocations in debug sections against
15070 symbols defined in discarded sections. Not done for
15071 non-debug to preserve relocs in .eh_frame which the
15072 eh_frame editing code expects to be present. */
15075 wrel--;
15078 }
15084 {
15088 }
15090 /* TLS optimizations. Replace instruction sequences and relocs
15091 based on information we collected in tls_optimize. We edit
15092 RELOCS so that --emit-relocs will output something sensible
15093 for the final instruction stream. */
15100 {
15106 }
15111 {
15112 /* Check for toc tls entries. */
15121 }
15123 /* Check that tls relocs are used with tls syms, and non-tls
15124 relocs are used with non-tls syms. */
15131 {
15136 /* R_PPC64_TLS is OK against a symbol in the TOC. */
15137 ;
15138 else
15141 /* xgettext:c-format */
15143 /* xgettext:c-format */
15147 sym_name);
15148 }
15150 /* Ensure reloc mapping code below stays sane. */
15164 {
15182 {
15183 /* Check for toc tls entries. */
15193 {
15197 {
15201 }
15202 else
15203 {
15204 /* If we found a GD reloc pair, then we might be
15205 doing a GD->IE transition. */
15207 {
15212 }
15214 {
15218 }
15219 }
15220 }
15221 }
15228 {
15233 }
15240 {
15241 toctprel:
15250 {
15253 /* We changed the symbol. Start over in order to
15254 get h, sym, sec etc. right. */
15256 }
15257 else
15259 }
15265 {
15266 /* pld ra,sym@got@tprel@pcrel -> paddi ra,r13,sym@tprel */
15278 }
15284 {
15290 {
15292 /* Was PPC64_TLS which sits on insn boundary, now
15293 PPC64_TPREL16_LO which is at low-order half-word. */
15297 {
15300 /* We changed the symbol. Start over in order to
15301 get h, sym, sec etc. right. */
15303 }
15304 else
15306 }
15308 {
15309 /* For pcrel IE to LE we already have the full
15310 offset and thus don't need an addi here. A nop
15311 or mr will do. */
15313 {
15314 /* Extract regs from addi rt,ra,si. */
15319 else
15320 {
15321 /* Build or ra,rs,rb with rb==rs, ie. mr ra,rs. */
15324 }
15325 }
15327 }
15328 }
15341 {
15342 tls_gdld_hi:
15346 else
15347 {
15351 }
15353 }
15366 {
15369 tls_ldgd_opt:
15371 /* If not using the newer R_PPC64_TLSGD/LD to mark
15372 __tls_get_addr calls, we must trust that the call
15373 stays with its arg setup insns, ie. that the next
15374 reloc is the __tls_get_addr call associated with
15375 the current reloc. Edit both insns. */
15384 /* We read the low GOT_TLS (or TOC16) insn because we
15385 need to keep the destination reg. It may be
15386 something other than the usual r3, and moved to r3
15387 before the call by intervening code. */
15391 {
15392 /* IE */
15401 else
15405 }
15406 else
15407 {
15408 /* LE */
15413 {
15414 /* Was an LD reloc. */
15417 }
15419 {
15422 }
15426 {
15428 R_PPC64_TPREL16_LO);
15431 }
15432 }
15436 {
15439 {
15443 }
15444 }
15447 {
15448 /* We changed the symbol. Start over in order
15449 to get h, sym, sec etc. right. */
15451 }
15452 }
15457 {
15462 {
15463 /* IE, pla -> pld */
15466 }
15467 else
15468 {
15469 /* LE, pla pcrel -> paddi r13 */
15472 }
15478 }
15483 {
15497 }
15503 {
15509 {
15516 }
15522 {
15523 /* IE */
15526 }
15527 else
15528 {
15529 /* LE */
15531 {
15534 }
15537 {
15540 }
15541 else
15542 {
15546 }
15547 }
15549 /* Zap the reloc on the _tls_get_addr call too. */
15557 }
15563 {
15569 {
15576 }
15583 {
15586 }
15587 else
15588 {
15594 }
15596 /* Zap the reloc on the _tls_get_addr call too. */
15602 }
15609 {
15611 {
15615 else
15616 {
15619 }
15621 }
15622 }
15623 else
15624 {
15626 {
15630 }
15631 }
15636 {
15639 }
15647 {
15654 {
15661 }
15662 }
15663 else
15664 {
15669 {
15676 {
15683 }
15684 }
15685 }
15689 /* If we are generating a non-PIC executable, edit
15690 . 0: addis 2,12,.TOC.-0b@ha
15691 . addi 2,2,.TOC.-0b@l
15692 used by ELFv2 global entry points to set up r2, to
15693 . lis 2,.TOC.@ha
15694 . addi 2,2,.TOC.@l
15695 if .TOC. is in range. */
15706 {
15713 {
15720 }
15721 }
15723 }
15725 /* Handle other relocations that tweak non-addend part of insn. */
15731 {
15741 {
15748 }
15751 /* Branch taken prediction relocations. */
15755 /* Fall through. */
15757 /* Branch not taken prediction relocations. */
15762 /* Fall through. */
15766 /* Fall through. */
15772 /* Calls to functions with a different TOC, such as calls to
15773 shared objects, need to alter the TOC pointer. This is
15774 done using a linkage stub. A REL24 branching to these
15775 linkage stubs needs to be followed by a nop, as the nop
15776 will be replaced with an instruction to restore the TOC
15777 base pointer. */
15784 htab);
15799 {
15807 {
15808 /* The function doesn't use or change r2. */
15810 }
15812 {
15813 /* NOTOC calls don't need to restore r2. */
15815 }
15817 /* All of these stubs may modify r2, so there must be a
15818 branch and link followed by a nop. The nop is
15819 replaced by an insn to restore r2. */
15821 {
15827 {
15837 {
15841 {
15842 /* Special stub used, leave nop alone. */
15843 }
15844 else
15849 }
15850 }
15851 }
15854 {
15862 {
15863 /* Allow crt1 branch to go via a toc adjusting
15864 stub. Other calls that never return could do
15865 the same, if we could detect such. */
15867 }
15868 }
15871 {
15872 /* g++ as of 20130507 emits self-calls without a
15873 following nop. This is arguably wrong since we
15874 have conflicting information. On the one hand a
15875 global symbol and on the other a local call
15876 sequence, but don't error for this special case.
15877 It isn't possible to cheaply verify we have
15878 exactly such a call. Allow all calls to the same
15879 section. */
15883 {
15889 }
15892 }
15895 {
15899 /* xgettext:c-format */
15903 else
15905 /* xgettext:c-format */
15912 }
15918 }
15924 {
15925 /* The branch destination is the value of the opd entry. */
15931 {
15935 }
15936 }
15938 /* If the branch is out of reach we ought to have a long
15939 branch stub. */
15955 /* Don't use the stub if this branch is in range. */
15981 {
15982 /* Munge up the value and addend so that we call the stub
15983 rather than the procedure directly. */
15992 else
16010 {
16011 /* Skip over the r2 store at the start of the stub. */
16017 }
16023 }
16026 {
16028 {
16029 /* Set 'a' bit. This is 0b00010 in BO field for branch
16030 on CR(BI) insns (BO == 001at or 011at), and 0b01000
16031 for branch on CTR insns (BO == 1a00t or 1a01t). */
16036 else
16038 }
16039 else
16040 {
16041 /* Invert 'y' bit if not the default. */
16044 }
16047 }
16049 /* NOP out calls to undefined weak functions.
16050 We can thus call a weak function without first
16051 checking whether the function is defined. */
16059 {
16062 }
16072 {
16075 {
16080 }
16081 }
16092 {
16096 {
16101 }
16104 {
16107 }
16108 }
16130 /* Replace with paddi. */
16136 /* Fall through. */
16144 {
16152 {
16155 /* zero means next insn. */
16159 {
16161 bfd_signed_vma addend_off;
16165 {
16170 }
16172 {
16184 }
16185 }
16186 }
16187 }
16189 }
16194 {
16196 /* xgettext:c-format */
16215 /* GOT16 relocations. Like an ADDR16 using the symbol's
16216 address in the GOT as relocation value instead of the
16217 symbol's value itself. Also, create a GOT entry for the
16218 symbol and put the symbol value there. */
16258 dogot:
16259 {
16260 /* Relocation is to the entry for this symbol in the global
16261 offset table. */
16264 bfd_vma off;
16271 else
16272 {
16274 {
16279 /* This is actually a static link, or it is a
16280 -Bsymbolic link and the symbol is defined
16281 locally, or the symbol was forced to be local
16282 because of a version file. */
16283 ;
16284 else
16285 {
16288 }
16290 }
16291 else
16292 {
16296 }
16303 }
16314 /* The offset must always be a multiple of 8. We use the
16315 least significant bit to record whether we have already
16316 processed this entry. */
16320 else
16321 {
16322 /* Generate relocs for the dynamic linker, except in
16323 the case of TLSLD where we'll use one entry per
16324 module. */
16326 bfd_boolean ifunc;
16334 {
16338 }
16350 {
16356 {
16360 {
16368 outrel.r_info
16370 }
16371 }
16378 else
16379 {
16382 else
16385 /* Write the .got section contents for the sake
16386 of prelink. */
16389 loc);
16390 }
16393 {
16396 {
16399 else
16401 }
16402 }
16407 }
16409 /* Init the .got section contents here if we're not
16410 emitting a reloc. */
16411 else
16412 {
16415 {
16418 else
16419 {
16422 else
16426 }
16429 {
16433 }
16434 }
16437 }
16438 }
16451 }
16466 /* Relocation is to the entry for this symbol in the
16467 procedure linkage table. */
16469 {
16474 {
16478 }
16480 {
16486 {
16488 bfd_vma got;
16494 {
16499 else
16501 }
16509 {
16513 }
16517 }
16518 }
16519 }
16523 /* Relocation value is TOC base. */
16528 ;
16531 else
16535 /* TOC16 relocs. We want the offset relative to the TOC base,
16536 which is the address of the start of the TOC plus 0x8000.
16537 The TOC consists of sections .got, .toc, .tocbss, and .plt,
16538 in this order. */
16550 /* Relocate against the beginning of the section. */
16601 {
16602 /* Make this relocation against an undefined weak symbol
16603 resolve to zero. This is really just a tweak, since
16604 code using weak externs ought to check that they are
16605 defined before using them. */
16613 }
16616 /* The TPREL16 relocs shouldn't really be used in shared
16617 libs or with non-local symbols as that will result in
16618 DT_TEXTREL being set, but support them anyway. */
16657 /* Fall through. */
16659 /* Relocations that may need to be propagated if this is a
16660 dynamic object. */
16694 dodyn:
16709 {
16712 bfd_vma out_off;
16715 /* When generating a dynamic object, these relocations
16716 are copied into the output file to be resolved at run
16717 time. */
16733 /* Optimize unaligned reloc use. */
16748 && !is_opd
16750 {
16754 }
16755 else
16756 {
16757 /* This symbol is local, or marked to become local,
16758 or this is an opd section reloc which must point
16759 at a local function. */
16762 {
16764 {
16765 /* Lie about opd entries. This case occurs
16766 when building shared libraries and we
16767 reference a function in another shared
16768 lib. The same thing happens for a weak
16769 definition in an application that's
16770 overridden by a strong definition in a
16771 shared lib. (I believe this is a generic
16772 bug in binutils handling of weak syms.)
16773 In these cases we won't use the opd
16774 entry in this lib. */
16776 }
16783 else
16784 {
16787 /* We need to relocate .opd contents for ld.so.
16788 Prelink also wants simple and consistent rules
16789 for relocs. This make all RELATIVE relocs have
16790 *r_offset equal to r_addend. */
16792 }
16793 }
16794 else
16795 {
16799 {
16801 /* xgettext:c-format */
16806 sym_name);
16808 }
16810 ;
16812 {
16815 }
16816 else
16817 {
16821 {
16822 /* TLS symbol values are relative to the
16823 TLS segment. Dynamic relocations for
16824 local TLS symbols therefore can't be
16825 reduced to a relocation against their
16826 section symbol because it holds the
16827 address of the section, not a value
16828 relative to the TLS segment. We could
16829 change the .tdata dynamic section symbol
16830 to be zero value but STN_UNDEF works
16831 and is used elsewhere, eg. for TPREL64
16832 GOT relocs against local TLS symbols. */
16835 }
16836 else
16837 {
16840 {
16844 else
16847 }
16849 }
16851 /* We are turning this relocation into one
16852 against a section symbol, so subtract out
16853 the output section's address but not the
16854 offset of the input section in the output
16855 section. */
16857 }
16860 }
16861 }
16867 {
16871 }
16884 {
16886 /* xgettext:c-format */
16889 input_bfd,
16891 sym_name);
16893 }
16895 /* If this reloc is against an external symbol, it will
16896 be computed at runtime, so there's no need to do
16897 anything now. However, for the sake of prelink ensure
16898 that the section contents are a known value. */
16900 {
16902 /* The value chosen here is quite arbitrary as ld.so
16903 ignores section contents except for the special
16904 case of .opd where the contents might be accessed
16905 before relocation. Choose zero, as that won't
16906 cause reloc overflow. */
16909 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
16910 to improve backward compatibility with older
16911 versions of ld. */
16914 /* Adjust pc_relative relocs to have zero in *r_offset. */
16917 }
16918 }
16926 /* We shouldn't ever see these dynamic relocs in relocatable
16927 files. */
16928 /* Fall through. */
16938 /* These ones haven't been implemented yet. */
16941 /* xgettext:c-format */
16943 input_bfd,
16949 }
16951 /* Multi-instruction sequences that access the TOC can be
16952 optimized, eg. addis ra,r2,0; addi rb,ra,x;
16953 to nop; addi rb,r2,x; */
16955 {
16965 /* These relocs would only be useful if building up an
16966 offset to later add to r2, perhaps in an indexed
16967 addressing mode instruction. Don't try to optimize.
16968 Unfortunately, the possibility of someone building up an
16969 offset like this or even with the HA relocs, means that
16970 we need to check the high insn when optimizing the low
16971 insn. */
16977 /* Fall through. */
16980 {
16981 /* No plt entry. Make this into a direct call. */
16990 }
16996 {
16999 }
17005 /* Fall through. */
17008 {
17014 }
17019 {
17022 }
17023 /* Fall through. */
17032 {
17034 nop_it:
17038 }
17044 {
17047 }
17048 /* Fall through. */
17059 {
17063 {
17064 /* Transform addic to addi when we change reg. */
17067 }
17068 else
17069 {
17072 }
17074 }
17079 {
17083 }
17089 {
17095 }
17097 }
17099 /* Do any further special processing. */
17101 {
17124 /* It's just possible that this symbol is a weak symbol
17125 that's not actually defined anywhere. In that case,
17126 'sec' would be NULL, and we should leave the symbol
17127 alone (it will be set to zero elsewhere in the link). */
17130 /* Fall through. */
17139 /* Add 0x10000 if sign bit in 0:15 is set.
17140 Bits 0:15 are not used. */
17174 /* If this reloc is against an lq, lxv, or stxv insn, then
17175 the value must be a multiple of 16. This is somewhat of
17176 a hack, but the "correct" way to do this by defining _DQ
17177 forms of all the _DS relocs bloats all reloc switches in
17178 this file. It doesn't make much sense to use these
17179 relocs in data, so testing the insn should be safe. */
17186 {
17189 /* xgettext:c-format */
17197 }
17199 }
17201 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
17202 because such sections are not SEC_ALLOC and thus ld.so will
17203 not process them. */
17210 {
17212 /* xgettext:c-format */
17218 }
17220 /* 16-bit fields in insns mostly have signed values, but a
17221 few insns have 16-bit unsigned values. Really, we should
17222 have different reloc types. */
17226 {
17241 {
17245 }
17246 }
17249 {
17250 /* Split field relocs aren't handled by _bfd_final_link_relocate. */
17269 else
17270 {
17292 }
17298 else
17299 {
17312 }
17319 }
17322 {
17327 {
17330 {
17335 }
17336 }
17339 {
17340 /* On code like "if (foo) foo();" don't report overflow
17341 on a branch to zero when foo is undefined. */
17352 }
17353 else
17354 {
17356 /* xgettext:c-format */
17361 }
17363 }
17364 copy_reloc:
17367 }
17370 {
17377 {
17378 /* It is too late to remove an empty reloc section. Leave
17379 one NONE reloc.
17380 ??? What is wrong with an empty section??? */
17383 }
17387 }
17389 /* If we're emitting relocations, then shortly after this function
17390 returns, reloc offsets and addends for this section will be
17391 adjusted. Worse, reloc symbol indices will be for the output
17392 file rather than the input. Save a copy of the relocs for
17393 opd_entry_value. */
17395 {
17396 bfd_size_type amt;
17404 }
17406 }
17408 /* Adjust the value of any local symbols in opd sections. */
17410 static int
17416 {
17419 bfd_vma value;
17438 }
17440 /* Finish up dynamic symbol handling. We set the contents of various
17441 dynamic sections here. */
17443 static bfd_boolean
17448 {
17459 {
17460 /* Mark the symbol as undefined, rather than as
17461 defined in glink. Leave the value if there were
17462 any relocations where pointer equality matters
17463 (this is a clue for the dynamic linker, to make
17464 function pointer comparisons work between an
17465 application and shared library), otherwise set it
17466 to zero. */
17471 {
17472 /* This breaks function pointer comparisons, but
17473 that is better than breaking tests for a NULL
17474 function pointer. */
17476 }
17478 }
17485 {
17486 /* This symbol needs a copy reloc. Set it up. */
17487 Elf_Internal_Rela rela;
17499 else
17504 }
17507 }
17509 /* Used to decide how to sort relocs in an optimal manner for the
17510 dynamic linker, before writing them out. */
17512 static enum elf_reloc_type_class
17516 {
17525 {
17534 }
17535 }
17537 /* Finish up the dynamic sections. */
17539 static bfd_boolean
17542 {
17555 {
17564 {
17565 Elf_Internal_Dyn dyn;
17571 {
17578 /* We stupidly defined DT_PPC64_GLINK to be the start
17579 of glink rather than the first entry point, which is
17580 what ld.so needs, and now have a bigger stub to
17581 support automatic multiple TOCs. */
17627 }
17630 }
17631 }
17635 {
17636 /* Fill in the first entry in the global offset table.
17637 We use it to hold the link-time TOCbase. */
17642 /* Set .got entry size. */
17645 }
17649 {
17650 /* Set .plt entry size. */
17653 }
17655 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
17656 brlt ourselves if emitrelocations. */
17663 NULL))
17672 NULL))
17684 /* We need to handle writing out multiple GOT sections ourselves,
17685 since we didn't add them to DYNOBJ. We know dynobj is the first
17686 bfd. */
17688 {
17710 }
17713 }
17717 /* FreeBSD support */
17719 #undef TARGET_LITTLE_SYM
17720 #define TARGET_LITTLE_SYM powerpc_elf64_fbsd_le_vec
17721 #undef TARGET_LITTLE_NAME
17724 #undef TARGET_BIG_SYM
17725 #define TARGET_BIG_SYM powerpc_elf64_fbsd_vec
17726 #undef TARGET_BIG_NAME
17729 #undef ELF_OSABI
17730 #define ELF_OSABI ELFOSABI_FREEBSD
17732 #undef elf64_bed
17733 #define elf64_bed elf64_powerpc_fbsd_bed