1 /* PowerPC64-specific support for 64-bit ELF.
2 Copyright (C) 1999-2019 Free Software Foundation, Inc.
3 Written by Linus Nordberg, Swox AB <info@swox.com>,
4 based on elf32-ppc.c by Ian Lance Taylor.
5 Largely rewritten by Alan Modra.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License along
20 with this program; if not, write to the Free Software Foundation, Inc.,
21 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
24 /* The 64-bit PowerPC ELF ABI may be found at
25 http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
26 http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html */
34 #include "elf/ppc64.h"
35 #include "elf64-ppc.h"
38 static bfd_reloc_status_type ppc64_elf_ha_reloc
39 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
40 static bfd_reloc_status_type ppc64_elf_branch_reloc
41 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
43 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
45 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
47 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
48 static bfd_reloc_status_type ppc64_elf_toc_reloc
49 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
51 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
53 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
54 static bfd_reloc_status_type ppc64_elf_prefix_reloc
55 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
56 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
57 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
58 static bfd_vma opd_entry_value
59 (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
61 #define TARGET_LITTLE_SYM powerpc_elf64_le_vec
62 #define TARGET_LITTLE_NAME "elf64-powerpcle"
63 #define TARGET_BIG_SYM powerpc_elf64_vec
64 #define TARGET_BIG_NAME "elf64-powerpc"
65 #define ELF_ARCH bfd_arch_powerpc
66 #define ELF_TARGET_ID PPC64_ELF_DATA
67 #define ELF_MACHINE_CODE EM_PPC64
68 #define ELF_MAXPAGESIZE 0x10000
69 #define ELF_COMMONPAGESIZE 0x1000
70 #define ELF_RELROPAGESIZE ELF_MAXPAGESIZE
71 #define elf_info_to_howto ppc64_elf_info_to_howto
73 #define elf_backend_want_got_sym 0
74 #define elf_backend_want_plt_sym 0
75 #define elf_backend_plt_alignment 3
76 #define elf_backend_plt_not_loaded 1
77 #define elf_backend_got_header_size 8
78 #define elf_backend_want_dynrelro 1
79 #define elf_backend_can_gc_sections 1
80 #define elf_backend_can_refcount 1
81 #define elf_backend_rela_normal 1
82 #define elf_backend_dtrel_excludes_plt 1
83 #define elf_backend_default_execstack 0
85 #define bfd_elf64_mkobject ppc64_elf_mkobject
86 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
87 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
88 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
89 #define bfd_elf64_bfd_print_private_bfd_data ppc64_elf_print_private_bfd_data
90 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
91 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
92 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
93 #define bfd_elf64_bfd_link_just_syms ppc64_elf_link_just_syms
94 #define bfd_elf64_bfd_gc_sections ppc64_elf_gc_sections
96 #define elf_backend_object_p ppc64_elf_object_p
97 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
98 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
99 #define elf_backend_write_core_note ppc64_elf_write_core_note
100 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
101 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
102 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
103 #define elf_backend_check_directives ppc64_elf_before_check_relocs
104 #define elf_backend_notice_as_needed ppc64_elf_notice_as_needed
105 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
106 #define elf_backend_check_relocs ppc64_elf_check_relocs
107 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
108 #define elf_backend_gc_keep ppc64_elf_gc_keep
109 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
110 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
111 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
112 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
113 #define elf_backend_maybe_function_sym ppc64_elf_maybe_function_sym
114 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
115 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
116 #define elf_backend_hash_symbol ppc64_elf_hash_symbol
117 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
118 #define elf_backend_action_discarded ppc64_elf_action_discarded
119 #define elf_backend_relocate_section ppc64_elf_relocate_section
120 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
121 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
122 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
123 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
124 #define elf_backend_special_sections ppc64_elf_special_sections
125 #define elf_backend_merge_symbol_attribute ppc64_elf_merge_symbol_attribute
126 #define elf_backend_merge_symbol ppc64_elf_merge_symbol
127 #define elf_backend_get_reloc_section bfd_get_section_by_name
129 /* The name of the dynamic interpreter. This is put in the .interp
131 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
133 /* The size in bytes of an entry in the procedure linkage table. */
134 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
135 #define LOCAL_PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 16 : 8)
137 /* The initial size of the plt reserved for the dynamic linker. */
138 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
140 /* Offsets to some stack save slots. */
142 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
143 /* This one is dodgy. ELFv2 does not have a linker word, so use the
144 CR save slot. Used only by optimised __tls_get_addr call stub,
145 relying on __tls_get_addr_opt not saving CR.. */
146 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
148 /* TOC base pointers offset from start of TOC. */
149 #define TOC_BASE_OFF 0x8000
150 /* TOC base alignment. */
151 #define TOC_BASE_ALIGN 256
153 /* Offset of tp and dtp pointers from start of TLS block. */
154 #define TP_OFFSET 0x7000
155 #define DTP_OFFSET 0x8000
157 /* .plt call stub instructions. The normal stub is like this, but
158 sometimes the .plt entry crosses a 64k boundary and we need to
159 insert an addi to adjust r11. */
160 #define STD_R2_0R1 0xf8410000 /* std %r2,0+40(%r1) */
161 #define ADDIS_R11_R2 0x3d620000 /* addis %r11,%r2,xxx@ha */
162 #define LD_R12_0R11 0xe98b0000 /* ld %r12,xxx+0@l(%r11) */
163 #define MTCTR_R12 0x7d8903a6 /* mtctr %r12 */
164 #define LD_R2_0R11 0xe84b0000 /* ld %r2,xxx+8@l(%r11) */
165 #define LD_R11_0R11 0xe96b0000 /* ld %r11,xxx+16@l(%r11) */
166 #define BCTR 0x4e800420 /* bctr */
168 #define ADDI_R11_R11 0x396b0000 /* addi %r11,%r11,off@l */
169 #define ADDI_R12_R11 0x398b0000 /* addi %r12,%r11,off@l */
170 #define ADDI_R12_R12 0x398c0000 /* addi %r12,%r12,off@l */
171 #define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
172 #define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
174 #define XOR_R2_R12_R12 0x7d826278 /* xor %r2,%r12,%r12 */
175 #define ADD_R11_R11_R2 0x7d6b1214 /* add %r11,%r11,%r2 */
176 #define XOR_R11_R12_R12 0x7d8b6278 /* xor %r11,%r12,%r12 */
177 #define ADD_R2_R2_R11 0x7c425a14 /* add %r2,%r2,%r11 */
178 #define CMPLDI_R2_0 0x28220000 /* cmpldi %r2,0 */
179 #define BNECTR 0x4ca20420 /* bnectr+ */
180 #define BNECTR_P4 0x4ce20420 /* bnectr+ */
182 #define LD_R12_0R2 0xe9820000 /* ld %r12,xxx+0(%r2) */
183 #define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
184 #define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
186 #define LD_R2_0R1 0xe8410000 /* ld %r2,0(%r1) */
187 #define LD_R2_0R12 0xe84c0000 /* ld %r2,0(%r12) */
188 #define ADD_R2_R2_R12 0x7c426214 /* add %r2,%r2,%r12 */
190 #define LI_R11_0 0x39600000 /* li %r11,0 */
191 #define LIS_R2 0x3c400000 /* lis %r2,xxx@ha */
192 #define LIS_R11 0x3d600000 /* lis %r11,xxx@ha */
193 #define LIS_R12 0x3d800000 /* lis %r12,xxx@ha */
194 #define ADDIS_R2_R12 0x3c4c0000 /* addis %r2,%r12,xxx@ha */
195 #define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
196 #define ADDIS_R12_R11 0x3d8b0000 /* addis %r12,%r11,xxx@ha */
197 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,xxx@ha */
198 #define ORIS_R12_R12_0 0x658c0000 /* oris %r12,%r12,xxx@hi */
199 #define ORI_R11_R11_0 0x616b0000 /* ori %r11,%r11,xxx@l */
200 #define ORI_R12_R12_0 0x618c0000 /* ori %r12,%r12,xxx@l */
201 #define LD_R12_0R12 0xe98c0000 /* ld %r12,xxx@l(%r12) */
202 #define SLDI_R11_R11_34 0x796b1746 /* sldi %r11,%r11,34 */
203 #define SLDI_R12_R12_32 0x799c07c6 /* sldi %r12,%r12,32 */
204 #define LDX_R12_R11_R12 0x7d8b602a /* ldx %r12,%r11,%r12 */
205 #define ADD_R12_R11_R12 0x7d8b6214 /* add %r12,%r11,%r12 */
206 #define PADDI_R12_PC 0x0610000039800000ULL
207 #define PLD_R12_PC 0x04100000e5800000ULL
208 #define PNOP 0x0700000000000000ULL
210 /* __glink_PLTresolve stub instructions. We enter with the index in R0. */
211 #define GLINK_PLTRESOLVE_SIZE(htab) \
212 (8u + (htab->opd_abi ? 11 * 4 : 14 * 4))
216 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
217 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
219 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
220 /* ld %2,(0b-1b)(%11) */
221 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
222 #define ADD_R11_R2_R11 0x7d625a14 /* add %11,%2,%11 */
228 #define MFLR_R0 0x7c0802a6 /* mflr %r0 */
229 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
230 #define SUB_R12_R12_R11 0x7d8b6050 /* subf %r12,%r11,%r12 */
231 #define ADDI_R0_R12 0x380c0000 /* addi %r0,%r12,0 */
232 #define SRDI_R0_R0_2 0x7800f082 /* rldicl %r0,%r0,62,2 */
235 #define NOP 0x60000000
237 /* Some other nops. */
238 #define CROR_151515 0x4def7b82
239 #define CROR_313131 0x4ffffb82
241 /* .glink entries for the first 32k functions are two instructions. */
242 #define LI_R0_0 0x38000000 /* li %r0,0 */
243 #define B_DOT 0x48000000 /* b . */
245 /* After that, we need two instructions to load the index, followed by
247 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
248 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
250 /* Instructions used by the save and restore reg functions. */
251 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
252 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
253 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
254 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
255 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
256 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
257 #define LI_R12_0 0x39800000 /* li %r12,0 */
258 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
259 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
260 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
261 #define BLR 0x4e800020 /* blr */
263 /* Since .opd is an array of descriptors and each entry will end up
264 with identical R_PPC64_RELATIVE relocs, there is really no need to
265 propagate .opd relocs; The dynamic linker should be taught to
266 relocate .opd without reloc entries. */
267 #ifndef NO_OPD_RELOCS
268 #define NO_OPD_RELOCS 0
272 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
276 abiversion (bfd *abfd)
278 return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
282 set_abiversion (bfd *abfd, int ver)
284 elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
285 elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
288 /* Relocation HOWTO's. */
289 /* Like other ELF RELA targets that don't apply multiple
290 field-altering relocations to the same localation, src_mask is
291 always zero and pcrel_offset is the same as pc_relative.
292 PowerPC can always use a zero bitpos, even when the field is not at
293 the LSB. For example, a REL24 could use rightshift=2, bisize=24
294 and bitpos=2 which matches the ABI description, or as we do here,
295 rightshift=0, bitsize=26 and bitpos=0. */
296 #define HOW(type, size, bitsize, mask, rightshift, pc_relative, \
297 complain, special_func) \
298 HOWTO (type, rightshift, size, bitsize, pc_relative, 0, \
299 complain_overflow_ ## complain, special_func, \
300 #type, FALSE, 0, mask, pc_relative)
302 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
304 static reloc_howto_type ppc64_elf_howto_raw[] =
306 /* This reloc does nothing. */
307 HOW (R_PPC64_NONE, 3, 0, 0, 0, FALSE, dont,
308 bfd_elf_generic_reloc),
310 /* A standard 32 bit relocation. */
311 HOW (R_PPC64_ADDR32, 2, 32, 0xffffffff, 0, FALSE, bitfield,
312 bfd_elf_generic_reloc),
314 /* An absolute 26 bit branch; the lower two bits must be zero.
315 FIXME: we don't check that, we just clear them. */
316 HOW (R_PPC64_ADDR24, 2, 26, 0x03fffffc, 0, FALSE, bitfield,
317 bfd_elf_generic_reloc),
319 /* A standard 16 bit relocation. */
320 HOW (R_PPC64_ADDR16, 1, 16, 0xffff, 0, FALSE, bitfield,
321 bfd_elf_generic_reloc),
323 /* A 16 bit relocation without overflow. */
324 HOW (R_PPC64_ADDR16_LO, 1, 16, 0xffff, 0, FALSE, dont,
325 bfd_elf_generic_reloc),
327 /* Bits 16-31 of an address. */
328 HOW (R_PPC64_ADDR16_HI, 1, 16, 0xffff, 16, FALSE, signed,
329 bfd_elf_generic_reloc),
331 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
332 bits, treated as a signed number, is negative. */
333 HOW (R_PPC64_ADDR16_HA, 1, 16, 0xffff, 16, FALSE, signed,
336 /* An absolute 16 bit branch; the lower two bits must be zero.
337 FIXME: we don't check that, we just clear them. */
338 HOW (R_PPC64_ADDR14, 2, 16, 0x0000fffc, 0, FALSE, signed,
339 ppc64_elf_branch_reloc),
341 /* An absolute 16 bit branch, for which bit 10 should be set to
342 indicate that the branch is expected to be taken. The lower two
343 bits must be zero. */
344 HOW (R_PPC64_ADDR14_BRTAKEN, 2, 16, 0x0000fffc, 0, FALSE, signed,
345 ppc64_elf_brtaken_reloc),
347 /* An absolute 16 bit branch, for which bit 10 should be set to
348 indicate that the branch is not expected to be taken. The lower
349 two bits must be zero. */
350 HOW (R_PPC64_ADDR14_BRNTAKEN, 2, 16, 0x0000fffc, 0, FALSE, signed,
351 ppc64_elf_brtaken_reloc),
353 /* A relative 26 bit branch; the lower two bits must be zero. */
354 HOW (R_PPC64_REL24, 2, 26, 0x03fffffc, 0, TRUE, signed,
355 ppc64_elf_branch_reloc),
357 /* A variant of R_PPC64_REL24, used when r2 is not the toc pointer. */
358 HOW (R_PPC64_REL24_NOTOC, 2, 26, 0x03fffffc, 0, TRUE, signed,
359 ppc64_elf_branch_reloc),
361 /* A relative 16 bit branch; the lower two bits must be zero. */
362 HOW (R_PPC64_REL14, 2, 16, 0x0000fffc, 0, TRUE, signed,
363 ppc64_elf_branch_reloc),
365 /* A relative 16 bit branch. Bit 10 should be set to indicate that
366 the branch is expected to be taken. The lower two bits must be
368 HOW (R_PPC64_REL14_BRTAKEN, 2, 16, 0x0000fffc, 0, TRUE, signed,
369 ppc64_elf_brtaken_reloc),
371 /* A relative 16 bit branch. Bit 10 should be set to indicate that
372 the branch is not expected to be taken. The lower two bits must
374 HOW (R_PPC64_REL14_BRNTAKEN, 2, 16, 0x0000fffc, 0, TRUE, signed,
375 ppc64_elf_brtaken_reloc),
377 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
379 HOW (R_PPC64_GOT16, 1, 16, 0xffff, 0, FALSE, signed,
380 ppc64_elf_unhandled_reloc),
382 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
384 HOW (R_PPC64_GOT16_LO, 1, 16, 0xffff, 0, FALSE, dont,
385 ppc64_elf_unhandled_reloc),
387 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
389 HOW (R_PPC64_GOT16_HI, 1, 16, 0xffff, 16, FALSE, signed,
390 ppc64_elf_unhandled_reloc),
392 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
394 HOW (R_PPC64_GOT16_HA, 1, 16, 0xffff, 16, FALSE, signed,
395 ppc64_elf_unhandled_reloc),
397 /* This is used only by the dynamic linker. The symbol should exist
398 both in the object being run and in some shared library. The
399 dynamic linker copies the data addressed by the symbol from the
400 shared library into the object, because the object being
401 run has to have the data at some particular address. */
402 HOW (R_PPC64_COPY, 0, 0, 0, 0, FALSE, dont,
403 ppc64_elf_unhandled_reloc),
405 /* Like R_PPC64_ADDR64, but used when setting global offset table
407 HOW (R_PPC64_GLOB_DAT, 4, 64, 0xffffffffffffffffULL, 0, FALSE, dont,
408 ppc64_elf_unhandled_reloc),
410 /* Created by the link editor. Marks a procedure linkage table
411 entry for a symbol. */
412 HOW (R_PPC64_JMP_SLOT, 0, 0, 0, 0, FALSE, dont,
413 ppc64_elf_unhandled_reloc),
415 /* Used only by the dynamic linker. When the object is run, this
416 doubleword64 is set to the load address of the object, plus the
418 HOW (R_PPC64_RELATIVE, 4, 64, 0xffffffffffffffffULL, 0, FALSE, dont,
419 bfd_elf_generic_reloc),
421 /* Like R_PPC64_ADDR32, but may be unaligned. */
422 HOW (R_PPC64_UADDR32, 2, 32, 0xffffffff, 0, FALSE, bitfield,
423 bfd_elf_generic_reloc),
425 /* Like R_PPC64_ADDR16, but may be unaligned. */
426 HOW (R_PPC64_UADDR16, 1, 16, 0xffff, 0, FALSE, bitfield,
427 bfd_elf_generic_reloc),
429 /* 32-bit PC relative. */
430 HOW (R_PPC64_REL32, 2, 32, 0xffffffff, 0, TRUE, signed,
431 bfd_elf_generic_reloc),
433 /* 32-bit relocation to the symbol's procedure linkage table. */
434 HOW (R_PPC64_PLT32, 2, 32, 0xffffffff, 0, FALSE, bitfield,
435 ppc64_elf_unhandled_reloc),
437 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
438 FIXME: R_PPC64_PLTREL32 not supported. */
439 HOW (R_PPC64_PLTREL32, 2, 32, 0xffffffff, 0, TRUE, signed,
440 ppc64_elf_unhandled_reloc),
442 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
444 HOW (R_PPC64_PLT16_LO, 1, 16, 0xffff, 0, FALSE, dont,
445 ppc64_elf_unhandled_reloc),
447 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
449 HOW (R_PPC64_PLT16_HI, 1, 16, 0xffff, 16, FALSE, signed,
450 ppc64_elf_unhandled_reloc),
452 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
454 HOW (R_PPC64_PLT16_HA, 1, 16, 0xffff, 16, FALSE, signed,
455 ppc64_elf_unhandled_reloc),
457 /* 16-bit section relative relocation. */
458 HOW (R_PPC64_SECTOFF, 1, 16, 0xffff, 0, FALSE, signed,
459 ppc64_elf_sectoff_reloc),
461 /* Like R_PPC64_SECTOFF, but no overflow warning. */
462 HOW (R_PPC64_SECTOFF_LO, 1, 16, 0xffff, 0, FALSE, dont,
463 ppc64_elf_sectoff_reloc),
465 /* 16-bit upper half section relative relocation. */
466 HOW (R_PPC64_SECTOFF_HI, 1, 16, 0xffff, 16, FALSE, signed,
467 ppc64_elf_sectoff_reloc),
469 /* 16-bit upper half adjusted section relative relocation. */
470 HOW (R_PPC64_SECTOFF_HA, 1, 16, 0xffff, 16, FALSE, signed,
471 ppc64_elf_sectoff_ha_reloc),
473 /* Like R_PPC64_REL24 without touching the two least significant bits. */
474 HOW (R_PPC64_REL30, 2, 30, 0xfffffffc, 2, TRUE, dont,
475 bfd_elf_generic_reloc),
477 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
479 /* A standard 64-bit relocation. */
480 HOW (R_PPC64_ADDR64, 4, 64, 0xffffffffffffffffULL, 0, FALSE, dont,
481 bfd_elf_generic_reloc),
483 /* The bits 32-47 of an address. */
484 HOW (R_PPC64_ADDR16_HIGHER, 1, 16, 0xffff, 32, FALSE, dont,
485 bfd_elf_generic_reloc),
487 /* The bits 32-47 of an address, plus 1 if the contents of the low
488 16 bits, treated as a signed number, is negative. */
489 HOW (R_PPC64_ADDR16_HIGHERA, 1, 16, 0xffff, 32, FALSE, dont,
492 /* The bits 48-63 of an address. */
493 HOW (R_PPC64_ADDR16_HIGHEST, 1, 16, 0xffff, 48, FALSE, dont,
494 bfd_elf_generic_reloc),
496 /* The bits 48-63 of an address, plus 1 if the contents of the low
497 16 bits, treated as a signed number, is negative. */
498 HOW (R_PPC64_ADDR16_HIGHESTA, 1, 16, 0xffff, 48, FALSE, dont,
501 /* Like ADDR64, but may be unaligned. */
502 HOW (R_PPC64_UADDR64, 4, 64, 0xffffffffffffffffULL, 0, FALSE, dont,
503 bfd_elf_generic_reloc),
505 /* 64-bit relative relocation. */
506 HOW (R_PPC64_REL64, 4, 64, 0xffffffffffffffffULL, 0, TRUE, dont,
507 bfd_elf_generic_reloc),
509 /* 64-bit relocation to the symbol's procedure linkage table. */
510 HOW (R_PPC64_PLT64, 4, 64, 0xffffffffffffffffULL, 0, FALSE, dont,
511 ppc64_elf_unhandled_reloc),
513 /* 64-bit PC relative relocation to the symbol's procedure linkage
515 /* FIXME: R_PPC64_PLTREL64 not supported. */
516 HOW (R_PPC64_PLTREL64, 4, 64, 0xffffffffffffffffULL, 0, TRUE, dont,
517 ppc64_elf_unhandled_reloc),
519 /* 16 bit TOC-relative relocation. */
520 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
521 HOW (R_PPC64_TOC16, 1, 16, 0xffff, 0, FALSE, signed,
522 ppc64_elf_toc_reloc),
524 /* 16 bit TOC-relative relocation without overflow. */
525 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
526 HOW (R_PPC64_TOC16_LO, 1, 16, 0xffff, 0, FALSE, dont,
527 ppc64_elf_toc_reloc),
529 /* 16 bit TOC-relative relocation, high 16 bits. */
530 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
531 HOW (R_PPC64_TOC16_HI, 1, 16, 0xffff, 16, FALSE, signed,
532 ppc64_elf_toc_reloc),
534 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
535 contents of the low 16 bits, treated as a signed number, is
537 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
538 HOW (R_PPC64_TOC16_HA, 1, 16, 0xffff, 16, FALSE, signed,
539 ppc64_elf_toc_ha_reloc),
541 /* 64-bit relocation; insert value of TOC base (.TOC.). */
542 /* R_PPC64_TOC 51 doubleword64 .TOC. */
543 HOW (R_PPC64_TOC, 4, 64, 0xffffffffffffffffULL, 0, FALSE, dont,
544 ppc64_elf_toc64_reloc),
546 /* Like R_PPC64_GOT16, but also informs the link editor that the
547 value to relocate may (!) refer to a PLT entry which the link
548 editor (a) may replace with the symbol value. If the link editor
549 is unable to fully resolve the symbol, it may (b) create a PLT
550 entry and store the address to the new PLT entry in the GOT.
551 This permits lazy resolution of function symbols at run time.
552 The link editor may also skip all of this and just (c) emit a
553 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
554 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
555 HOW (R_PPC64_PLTGOT16, 1, 16, 0xffff, 0, FALSE,signed,
556 ppc64_elf_unhandled_reloc),
558 /* Like R_PPC64_PLTGOT16, but without overflow. */
559 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
560 HOW (R_PPC64_PLTGOT16_LO, 1, 16, 0xffff, 0, FALSE, dont,
561 ppc64_elf_unhandled_reloc),
563 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
564 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
565 HOW (R_PPC64_PLTGOT16_HI, 1, 16, 0xffff, 16, FALSE, signed,
566 ppc64_elf_unhandled_reloc),
568 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
569 1 if the contents of the low 16 bits, treated as a signed number,
571 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
572 HOW (R_PPC64_PLTGOT16_HA, 1, 16, 0xffff, 16, FALSE, signed,
573 ppc64_elf_unhandled_reloc),
575 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
576 HOW (R_PPC64_ADDR16_DS, 1, 16, 0xfffc, 0, FALSE, signed,
577 bfd_elf_generic_reloc),
579 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
580 HOW (R_PPC64_ADDR16_LO_DS, 1, 16, 0xfffc, 0, FALSE, dont,
581 bfd_elf_generic_reloc),
583 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
584 HOW (R_PPC64_GOT16_DS, 1, 16, 0xfffc, 0, FALSE, signed,
585 ppc64_elf_unhandled_reloc),
587 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
588 HOW (R_PPC64_GOT16_LO_DS, 1, 16, 0xfffc, 0, FALSE, dont,
589 ppc64_elf_unhandled_reloc),
591 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
592 HOW (R_PPC64_PLT16_LO_DS, 1, 16, 0xfffc, 0, FALSE, dont,
593 ppc64_elf_unhandled_reloc),
595 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
596 HOW (R_PPC64_SECTOFF_DS, 1, 16, 0xfffc, 0, FALSE, signed,
597 ppc64_elf_sectoff_reloc),
599 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
600 HOW (R_PPC64_SECTOFF_LO_DS, 1, 16, 0xfffc, 0, FALSE, dont,
601 ppc64_elf_sectoff_reloc),
603 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
604 HOW (R_PPC64_TOC16_DS, 1, 16, 0xfffc, 0, FALSE, signed,
605 ppc64_elf_toc_reloc),
607 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
608 HOW (R_PPC64_TOC16_LO_DS, 1, 16, 0xfffc, 0, FALSE, dont,
609 ppc64_elf_toc_reloc),
611 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
612 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
613 HOW (R_PPC64_PLTGOT16_DS, 1, 16, 0xfffc, 0, FALSE, signed,
614 ppc64_elf_unhandled_reloc),
616 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
617 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
618 HOW (R_PPC64_PLTGOT16_LO_DS, 1, 16, 0xfffc, 0, FALSE, dont,
619 ppc64_elf_unhandled_reloc),
621 /* Marker relocs for TLS. */
622 HOW (R_PPC64_TLS, 2, 32, 0, 0, FALSE, dont,
623 bfd_elf_generic_reloc),
625 HOW (R_PPC64_TLSGD, 2, 32, 0, 0, FALSE, dont,
626 bfd_elf_generic_reloc),
628 HOW (R_PPC64_TLSLD, 2, 32, 0, 0, FALSE, dont,
629 bfd_elf_generic_reloc),
631 /* Marker reloc for optimizing r2 save in prologue rather than on
632 each plt call stub. */
633 HOW (R_PPC64_TOCSAVE, 2, 32, 0, 0, FALSE, dont,
634 bfd_elf_generic_reloc),
636 /* Marker relocs on inline plt call instructions. */
637 HOW (R_PPC64_PLTSEQ, 2, 32, 0, 0, FALSE, dont,
638 bfd_elf_generic_reloc),
640 HOW (R_PPC64_PLTCALL, 2, 32, 0, 0, FALSE, dont,
641 bfd_elf_generic_reloc),
643 /* Computes the load module index of the load module that contains the
644 definition of its TLS sym. */
645 HOW (R_PPC64_DTPMOD64, 4, 64, 0xffffffffffffffffULL, 0, FALSE, dont,
646 ppc64_elf_unhandled_reloc),
648 /* Computes a dtv-relative displacement, the difference between the value
649 of sym+add and the base address of the thread-local storage block that
650 contains the definition of sym, minus 0x8000. */
651 HOW (R_PPC64_DTPREL64, 4, 64, 0xffffffffffffffffULL, 0, FALSE, dont,
652 ppc64_elf_unhandled_reloc),
654 /* A 16 bit dtprel reloc. */
655 HOW (R_PPC64_DTPREL16, 1, 16, 0xffff, 0, FALSE, signed,
656 ppc64_elf_unhandled_reloc),
658 /* Like DTPREL16, but no overflow. */
659 HOW (R_PPC64_DTPREL16_LO, 1, 16, 0xffff, 0, FALSE, dont,
660 ppc64_elf_unhandled_reloc),
662 /* Like DTPREL16_LO, but next higher group of 16 bits. */
663 HOW (R_PPC64_DTPREL16_HI, 1, 16, 0xffff, 16, FALSE, signed,
664 ppc64_elf_unhandled_reloc),
666 /* Like DTPREL16_HI, but adjust for low 16 bits. */
667 HOW (R_PPC64_DTPREL16_HA, 1, 16, 0xffff, 16, FALSE, signed,
668 ppc64_elf_unhandled_reloc),
670 /* Like DTPREL16_HI, but next higher group of 16 bits. */
671 HOW (R_PPC64_DTPREL16_HIGHER, 1, 16, 0xffff, 32, FALSE, dont,
672 ppc64_elf_unhandled_reloc),
674 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
675 HOW (R_PPC64_DTPREL16_HIGHERA, 1, 16, 0xffff, 32, FALSE, dont,
676 ppc64_elf_unhandled_reloc),
678 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
679 HOW (R_PPC64_DTPREL16_HIGHEST, 1, 16, 0xffff, 48, FALSE, dont,
680 ppc64_elf_unhandled_reloc),
682 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
683 HOW (R_PPC64_DTPREL16_HIGHESTA, 1, 16, 0xffff, 48, FALSE, dont,
684 ppc64_elf_unhandled_reloc),
686 /* Like DTPREL16, but for insns with a DS field. */
687 HOW (R_PPC64_DTPREL16_DS, 1, 16, 0xfffc, 0, FALSE, signed,
688 ppc64_elf_unhandled_reloc),
690 /* Like DTPREL16_DS, but no overflow. */
691 HOW (R_PPC64_DTPREL16_LO_DS, 1, 16, 0xfffc, 0, FALSE, dont,
692 ppc64_elf_unhandled_reloc),
694 /* Computes a tp-relative displacement, the difference between the value of
695 sym+add and the value of the thread pointer (r13). */
696 HOW (R_PPC64_TPREL64, 4, 64, 0xffffffffffffffffULL, 0, FALSE, dont,
697 ppc64_elf_unhandled_reloc),
699 /* A 16 bit tprel reloc. */
700 HOW (R_PPC64_TPREL16, 1, 16, 0xffff, 0, FALSE, signed,
701 ppc64_elf_unhandled_reloc),
703 /* Like TPREL16, but no overflow. */
704 HOW (R_PPC64_TPREL16_LO, 1, 16, 0xffff, 0, FALSE, dont,
705 ppc64_elf_unhandled_reloc),
707 /* Like TPREL16_LO, but next higher group of 16 bits. */
708 HOW (R_PPC64_TPREL16_HI, 1, 16, 0xffff, 16, FALSE, signed,
709 ppc64_elf_unhandled_reloc),
711 /* Like TPREL16_HI, but adjust for low 16 bits. */
712 HOW (R_PPC64_TPREL16_HA, 1, 16, 0xffff, 16, FALSE, signed,
713 ppc64_elf_unhandled_reloc),
715 /* Like TPREL16_HI, but next higher group of 16 bits. */
716 HOW (R_PPC64_TPREL16_HIGHER, 1, 16, 0xffff, 32, FALSE, dont,
717 ppc64_elf_unhandled_reloc),
719 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
720 HOW (R_PPC64_TPREL16_HIGHERA, 1, 16, 0xffff, 32, FALSE, dont,
721 ppc64_elf_unhandled_reloc),
723 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
724 HOW (R_PPC64_TPREL16_HIGHEST, 1, 16, 0xffff, 48, FALSE, dont,
725 ppc64_elf_unhandled_reloc),
727 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
728 HOW (R_PPC64_TPREL16_HIGHESTA, 1, 16, 0xffff, 48, FALSE, dont,
729 ppc64_elf_unhandled_reloc),
731 /* Like TPREL16, but for insns with a DS field. */
732 HOW (R_PPC64_TPREL16_DS, 1, 16, 0xfffc, 0, FALSE, signed,
733 ppc64_elf_unhandled_reloc),
735 /* Like TPREL16_DS, but no overflow. */
736 HOW (R_PPC64_TPREL16_LO_DS, 1, 16, 0xfffc, 0, FALSE, dont,
737 ppc64_elf_unhandled_reloc),
739 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
740 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
741 to the first entry relative to the TOC base (r2). */
742 HOW (R_PPC64_GOT_TLSGD16, 1, 16, 0xffff, 0, FALSE, signed,
743 ppc64_elf_unhandled_reloc),
745 /* Like GOT_TLSGD16, but no overflow. */
746 HOW (R_PPC64_GOT_TLSGD16_LO, 1, 16, 0xffff, 0, FALSE, dont,
747 ppc64_elf_unhandled_reloc),
749 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
750 HOW (R_PPC64_GOT_TLSGD16_HI, 1, 16, 0xffff, 16, FALSE, signed,
751 ppc64_elf_unhandled_reloc),
753 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
754 HOW (R_PPC64_GOT_TLSGD16_HA, 1, 16, 0xffff, 16, FALSE, signed,
755 ppc64_elf_unhandled_reloc),
757 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
758 with values (sym+add)@dtpmod and zero, and computes the offset to the
759 first entry relative to the TOC base (r2). */
760 HOW (R_PPC64_GOT_TLSLD16, 1, 16, 0xffff, 0, FALSE, signed,
761 ppc64_elf_unhandled_reloc),
763 /* Like GOT_TLSLD16, but no overflow. */
764 HOW (R_PPC64_GOT_TLSLD16_LO, 1, 16, 0xffff, 0, FALSE, dont,
765 ppc64_elf_unhandled_reloc),
767 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
768 HOW (R_PPC64_GOT_TLSLD16_HI, 1, 16, 0xffff, 16, FALSE, signed,
769 ppc64_elf_unhandled_reloc),
771 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
772 HOW (R_PPC64_GOT_TLSLD16_HA, 1, 16, 0xffff, 16, FALSE, signed,
773 ppc64_elf_unhandled_reloc),
775 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
776 the offset to the entry relative to the TOC base (r2). */
777 HOW (R_PPC64_GOT_DTPREL16_DS, 1, 16, 0xfffc, 0, FALSE, signed,
778 ppc64_elf_unhandled_reloc),
780 /* Like GOT_DTPREL16_DS, but no overflow. */
781 HOW (R_PPC64_GOT_DTPREL16_LO_DS, 1, 16, 0xfffc, 0, FALSE, dont,
782 ppc64_elf_unhandled_reloc),
784 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
785 HOW (R_PPC64_GOT_DTPREL16_HI, 1, 16, 0xffff, 16, FALSE, signed,
786 ppc64_elf_unhandled_reloc),
788 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
789 HOW (R_PPC64_GOT_DTPREL16_HA, 1, 16, 0xffff, 16, FALSE, signed,
790 ppc64_elf_unhandled_reloc),
792 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
793 offset to the entry relative to the TOC base (r2). */
794 HOW (R_PPC64_GOT_TPREL16_DS, 1, 16, 0xfffc, 0, FALSE, signed,
795 ppc64_elf_unhandled_reloc),
797 /* Like GOT_TPREL16_DS, but no overflow. */
798 HOW (R_PPC64_GOT_TPREL16_LO_DS, 1, 16, 0xfffc, 0, FALSE, dont,
799 ppc64_elf_unhandled_reloc),
801 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
802 HOW (R_PPC64_GOT_TPREL16_HI, 1, 16, 0xffff, 16, FALSE, signed,
803 ppc64_elf_unhandled_reloc),
805 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
806 HOW (R_PPC64_GOT_TPREL16_HA, 1, 16, 0xffff, 16, FALSE, signed,
807 ppc64_elf_unhandled_reloc),
809 HOW (R_PPC64_JMP_IREL, 0, 0, 0, 0, FALSE, dont,
810 ppc64_elf_unhandled_reloc),
812 HOW (R_PPC64_IRELATIVE, 4, 64, 0xffffffffffffffffULL, 0, FALSE, dont,
813 bfd_elf_generic_reloc),
815 /* A 16 bit relative relocation. */
816 HOW (R_PPC64_REL16, 1, 16, 0xffff, 0, TRUE, signed,
817 bfd_elf_generic_reloc),
819 /* A 16 bit relative relocation without overflow. */
820 HOW (R_PPC64_REL16_LO, 1, 16, 0xffff, 0, TRUE, dont,
821 bfd_elf_generic_reloc),
823 /* The high order 16 bits of a relative address. */
824 HOW (R_PPC64_REL16_HI, 1, 16, 0xffff, 16, TRUE, signed,
825 bfd_elf_generic_reloc),
827 /* The high order 16 bits of a relative address, plus 1 if the contents of
828 the low 16 bits, treated as a signed number, is negative. */
829 HOW (R_PPC64_REL16_HA, 1, 16, 0xffff, 16, TRUE, signed,
832 HOW (R_PPC64_REL16_HIGH, 1, 16, 0xffff, 16, TRUE, dont,
833 bfd_elf_generic_reloc),
835 HOW (R_PPC64_REL16_HIGHA, 1, 16, 0xffff, 16, TRUE, dont,
838 HOW (R_PPC64_REL16_HIGHER, 1, 16, 0xffff, 32, TRUE, dont,
839 bfd_elf_generic_reloc),
841 HOW (R_PPC64_REL16_HIGHERA, 1, 16, 0xffff, 32, TRUE, dont,
844 HOW (R_PPC64_REL16_HIGHEST, 1, 16, 0xffff, 48, TRUE, dont,
845 bfd_elf_generic_reloc),
847 HOW (R_PPC64_REL16_HIGHESTA, 1, 16, 0xffff, 48, TRUE, dont,
850 /* Like R_PPC64_REL16_HA but for split field in addpcis. */
851 HOW (R_PPC64_REL16DX_HA, 2, 16, 0x1fffc1, 16, TRUE, signed,
854 /* A split-field reloc for addpcis, non-relative (gas internal use only). */
855 HOW (R_PPC64_16DX_HA, 2, 16, 0x1fffc1, 16, FALSE, signed,
858 /* Like R_PPC64_ADDR16_HI, but no overflow. */
859 HOW (R_PPC64_ADDR16_HIGH, 1, 16, 0xffff, 16, FALSE, dont,
860 bfd_elf_generic_reloc),
862 /* Like R_PPC64_ADDR16_HA, but no overflow. */
863 HOW (R_PPC64_ADDR16_HIGHA, 1, 16, 0xffff, 16, FALSE, dont,
866 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
867 HOW (R_PPC64_DTPREL16_HIGH, 1, 16, 0xffff, 16, FALSE, dont,
868 ppc64_elf_unhandled_reloc),
870 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
871 HOW (R_PPC64_DTPREL16_HIGHA, 1, 16, 0xffff, 16, FALSE, dont,
872 ppc64_elf_unhandled_reloc),
874 /* Like R_PPC64_TPREL16_HI, but no overflow. */
875 HOW (R_PPC64_TPREL16_HIGH, 1, 16, 0xffff, 16, FALSE, dont,
876 ppc64_elf_unhandled_reloc),
878 /* Like R_PPC64_TPREL16_HA, but no overflow. */
879 HOW (R_PPC64_TPREL16_HIGHA, 1, 16, 0xffff, 16, FALSE, dont,
880 ppc64_elf_unhandled_reloc),
882 /* Marker reloc on ELFv2 large-model function entry. */
883 HOW (R_PPC64_ENTRY, 2, 32, 0, 0, FALSE, dont,
884 bfd_elf_generic_reloc),
886 /* Like ADDR64, but use local entry point of function. */
887 HOW (R_PPC64_ADDR64_LOCAL, 4, 64, 0xffffffffffffffffULL, 0, FALSE, dont,
888 bfd_elf_generic_reloc),
890 HOW (R_PPC64_PLTSEQ_NOTOC, 2, 32, 0, 0, FALSE, dont,
891 bfd_elf_generic_reloc),
893 HOW (R_PPC64_PLTCALL_NOTOC, 2, 32, 0, 0, FALSE, dont,
894 bfd_elf_generic_reloc),
896 HOW (R_PPC64_PCREL_OPT, 2, 32, 0, 0, FALSE, dont,
897 bfd_elf_generic_reloc),
899 HOW (R_PPC64_D34, 4, 34, 0x3ffff0000ffffULL, 0, FALSE, signed,
900 ppc64_elf_prefix_reloc),
902 HOW (R_PPC64_D34_LO, 4, 34, 0x3ffff0000ffffULL, 0, FALSE, dont,
903 ppc64_elf_prefix_reloc),
905 HOW (R_PPC64_D34_HI30, 4, 34, 0x3ffff0000ffffULL, 34, FALSE, dont,
906 ppc64_elf_prefix_reloc),
908 HOW (R_PPC64_D34_HA30, 4, 34, 0x3ffff0000ffffULL, 34, FALSE, dont,
909 ppc64_elf_prefix_reloc),
911 HOW (R_PPC64_PCREL34, 4, 34, 0x3ffff0000ffffULL, 0, TRUE, signed,
912 ppc64_elf_prefix_reloc),
914 HOW (R_PPC64_GOT_PCREL34, 4, 34, 0x3ffff0000ffffULL, 0, TRUE, signed,
915 ppc64_elf_unhandled_reloc),
917 HOW (R_PPC64_PLT_PCREL34, 4, 34, 0x3ffff0000ffffULL, 0, TRUE, signed,
918 ppc64_elf_unhandled_reloc),
920 HOW (R_PPC64_PLT_PCREL34_NOTOC, 4, 34, 0x3ffff0000ffffULL, 0, TRUE, signed,
921 ppc64_elf_unhandled_reloc),
923 HOW (R_PPC64_ADDR16_HIGHER34, 1, 16, 0xffff, 34, FALSE, dont,
924 bfd_elf_generic_reloc),
926 HOW (R_PPC64_ADDR16_HIGHERA34, 1, 16, 0xffff, 34, FALSE, dont,
929 HOW (R_PPC64_ADDR16_HIGHEST34, 1, 16, 0xffff, 50, FALSE, dont,
930 bfd_elf_generic_reloc),
932 HOW (R_PPC64_ADDR16_HIGHESTA34, 1, 16, 0xffff, 50, FALSE, dont,
935 HOW (R_PPC64_REL16_HIGHER34, 1, 16, 0xffff, 34, TRUE, dont,
936 bfd_elf_generic_reloc),
938 HOW (R_PPC64_REL16_HIGHERA34, 1, 16, 0xffff, 34, TRUE, dont,
941 HOW (R_PPC64_REL16_HIGHEST34, 1, 16, 0xffff, 50, TRUE, dont,
942 bfd_elf_generic_reloc),
944 HOW (R_PPC64_REL16_HIGHESTA34, 1, 16, 0xffff, 50, TRUE, dont,
947 HOW (R_PPC64_D28, 4, 28, 0xfff0000ffffULL, 0, FALSE, signed,
948 ppc64_elf_prefix_reloc),
950 HOW (R_PPC64_PCREL28, 4, 28, 0xfff0000ffffULL, 0, TRUE, signed,
951 ppc64_elf_prefix_reloc),
953 /* GNU extension to record C++ vtable hierarchy. */
954 HOW (R_PPC64_GNU_VTINHERIT, 0, 0, 0, 0, FALSE, dont,
957 /* GNU extension to record C++ vtable member usage. */
958 HOW (R_PPC64_GNU_VTENTRY, 0, 0, 0, 0, FALSE, dont,
963 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
967 ppc_howto_init (void)
969 unsigned int i, type;
971 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
973 type = ppc64_elf_howto_raw[i].type;
974 BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
975 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
979 static reloc_howto_type *
980 ppc64_elf_reloc_type_lookup (bfd *abfd,
981 bfd_reloc_code_real_type code)
983 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
985 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
986 /* Initialize howto table if needed. */
992 /* xgettext:c-format */
993 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd,
995 bfd_set_error (bfd_error_bad_value);
998 case BFD_RELOC_NONE: r = R_PPC64_NONE;
1000 case BFD_RELOC_32: r = R_PPC64_ADDR32;
1002 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
1004 case BFD_RELOC_16: r = R_PPC64_ADDR16;
1006 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
1008 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
1010 case BFD_RELOC_PPC64_ADDR16_HIGH: r = R_PPC64_ADDR16_HIGH;
1012 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
1014 case BFD_RELOC_PPC64_ADDR16_HIGHA: r = R_PPC64_ADDR16_HIGHA;
1016 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
1018 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
1020 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
1022 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
1024 case BFD_RELOC_PPC64_REL24_NOTOC: r = R_PPC64_REL24_NOTOC;
1026 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
1028 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
1030 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
1032 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
1034 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
1036 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
1038 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
1040 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
1042 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
1044 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
1046 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
1048 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
1050 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
1052 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
1054 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
1056 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
1058 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
1060 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
1062 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
1064 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
1066 case BFD_RELOC_64: r = R_PPC64_ADDR64;
1068 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
1070 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
1072 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
1074 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
1076 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
1078 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
1080 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
1082 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
1084 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
1086 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
1088 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
1090 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
1092 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
1094 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
1096 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
1098 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
1100 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
1102 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
1104 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
1106 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
1108 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
1110 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
1112 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
1114 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
1116 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
1118 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
1120 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
1122 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
1124 case BFD_RELOC_PPC_TLSGD: r = R_PPC64_TLSGD;
1126 case BFD_RELOC_PPC_TLSLD: r = R_PPC64_TLSLD;
1128 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
1130 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
1132 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
1134 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
1136 case BFD_RELOC_PPC64_TPREL16_HIGH: r = R_PPC64_TPREL16_HIGH;
1138 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
1140 case BFD_RELOC_PPC64_TPREL16_HIGHA: r = R_PPC64_TPREL16_HIGHA;
1142 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
1144 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
1146 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
1148 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
1150 case BFD_RELOC_PPC64_DTPREL16_HIGH: r = R_PPC64_DTPREL16_HIGH;
1152 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
1154 case BFD_RELOC_PPC64_DTPREL16_HIGHA: r = R_PPC64_DTPREL16_HIGHA;
1156 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
1158 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
1160 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
1162 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
1164 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
1166 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
1168 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
1170 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
1172 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
1174 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
1176 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
1178 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
1180 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
1182 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
1184 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
1186 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
1188 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
1190 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
1192 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
1194 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
1196 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
1198 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
1200 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
1202 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
1204 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
1206 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
1208 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
1210 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
1212 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
1214 case BFD_RELOC_16_PCREL: r = R_PPC64_REL16;
1216 case BFD_RELOC_LO16_PCREL: r = R_PPC64_REL16_LO;
1218 case BFD_RELOC_HI16_PCREL: r = R_PPC64_REL16_HI;
1220 case BFD_RELOC_HI16_S_PCREL: r = R_PPC64_REL16_HA;
1222 case BFD_RELOC_PPC64_REL16_HIGH: r = R_PPC64_REL16_HIGH;
1224 case BFD_RELOC_PPC64_REL16_HIGHA: r = R_PPC64_REL16_HIGHA;
1226 case BFD_RELOC_PPC64_REL16_HIGHER: r = R_PPC64_REL16_HIGHER;
1228 case BFD_RELOC_PPC64_REL16_HIGHERA: r = R_PPC64_REL16_HIGHERA;
1230 case BFD_RELOC_PPC64_REL16_HIGHEST: r = R_PPC64_REL16_HIGHEST;
1232 case BFD_RELOC_PPC64_REL16_HIGHESTA: r = R_PPC64_REL16_HIGHESTA;
1234 case BFD_RELOC_PPC_16DX_HA: r = R_PPC64_16DX_HA;
1236 case BFD_RELOC_PPC_REL16DX_HA: r = R_PPC64_REL16DX_HA;
1238 case BFD_RELOC_PPC64_ENTRY: r = R_PPC64_ENTRY;
1240 case BFD_RELOC_PPC64_ADDR64_LOCAL: r = R_PPC64_ADDR64_LOCAL;
1242 case BFD_RELOC_PPC64_D34: r = R_PPC64_D34;
1244 case BFD_RELOC_PPC64_D34_LO: r = R_PPC64_D34_LO;
1246 case BFD_RELOC_PPC64_D34_HI30: r = R_PPC64_D34_HI30;
1248 case BFD_RELOC_PPC64_D34_HA30: r = R_PPC64_D34_HA30;
1250 case BFD_RELOC_PPC64_PCREL34: r = R_PPC64_PCREL34;
1252 case BFD_RELOC_PPC64_GOT_PCREL34: r = R_PPC64_GOT_PCREL34;
1254 case BFD_RELOC_PPC64_PLT_PCREL34: r = R_PPC64_PLT_PCREL34;
1256 case BFD_RELOC_PPC64_ADDR16_HIGHER34: r = R_PPC64_ADDR16_HIGHER34;
1258 case BFD_RELOC_PPC64_ADDR16_HIGHERA34: r = R_PPC64_ADDR16_HIGHERA34;
1260 case BFD_RELOC_PPC64_ADDR16_HIGHEST34: r = R_PPC64_ADDR16_HIGHEST34;
1262 case BFD_RELOC_PPC64_ADDR16_HIGHESTA34: r = R_PPC64_ADDR16_HIGHESTA34;
1264 case BFD_RELOC_PPC64_REL16_HIGHER34: r = R_PPC64_REL16_HIGHER34;
1266 case BFD_RELOC_PPC64_REL16_HIGHERA34: r = R_PPC64_REL16_HIGHERA34;
1268 case BFD_RELOC_PPC64_REL16_HIGHEST34: r = R_PPC64_REL16_HIGHEST34;
1270 case BFD_RELOC_PPC64_REL16_HIGHESTA34: r = R_PPC64_REL16_HIGHESTA34;
1272 case BFD_RELOC_PPC64_D28: r = R_PPC64_D28;
1274 case BFD_RELOC_PPC64_PCREL28: r = R_PPC64_PCREL28;
1276 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
1278 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
1282 return ppc64_elf_howto_table[r];
1285 static reloc_howto_type *
1286 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1291 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
1292 if (ppc64_elf_howto_raw[i].name != NULL
1293 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
1294 return &ppc64_elf_howto_raw[i];
1299 /* Set the howto pointer for a PowerPC ELF reloc. */
1302 ppc64_elf_info_to_howto (bfd *abfd, arelent *cache_ptr,
1303 Elf_Internal_Rela *dst)
1307 /* Initialize howto table if needed. */
1308 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
1311 type = ELF64_R_TYPE (dst->r_info);
1312 if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
1314 /* xgettext:c-format */
1315 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
1317 bfd_set_error (bfd_error_bad_value);
1320 cache_ptr->howto = ppc64_elf_howto_table[type];
1321 if (cache_ptr->howto == NULL || cache_ptr->howto->name == NULL)
1323 /* xgettext:c-format */
1324 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
1326 bfd_set_error (bfd_error_bad_value);
1333 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
1335 static bfd_reloc_status_type
1336 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1337 void *data, asection *input_section,
1338 bfd *output_bfd, char **error_message)
1340 enum elf_ppc64_reloc_type r_type;
1342 bfd_size_type octets;
1345 /* If this is a relocatable link (output_bfd test tells us), just
1346 call the generic function. Any adjustment will be done at final
1348 if (output_bfd != NULL)
1349 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1350 input_section, output_bfd, error_message);
1352 /* Adjust the addend for sign extension of the low 16 (or 34) bits.
1353 We won't actually be using the low bits, so trashing them
1355 r_type = reloc_entry->howto->type;
1356 if (r_type == R_PPC64_ADDR16_HIGHERA34
1357 || r_type == R_PPC64_ADDR16_HIGHESTA34
1358 || r_type == R_PPC64_REL16_HIGHERA34
1359 || r_type == R_PPC64_REL16_HIGHESTA34)
1360 reloc_entry->addend += 1ULL << 33;
1362 reloc_entry->addend += 1U << 15;
1363 if (r_type != R_PPC64_REL16DX_HA)
1364 return bfd_reloc_continue;
1367 if (!bfd_is_com_section (symbol->section))
1368 value = symbol->value;
1369 value += (reloc_entry->addend
1370 + symbol->section->output_offset
1371 + symbol->section->output_section->vma);
1372 value -= (reloc_entry->address
1373 + input_section->output_offset
1374 + input_section->output_section->vma);
1375 value = (bfd_signed_vma) value >> 16;
1377 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
1378 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
1380 insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
1381 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
1382 if (value + 0x8000 > 0xffff)
1383 return bfd_reloc_overflow;
1384 return bfd_reloc_ok;
1387 static bfd_reloc_status_type
1388 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1389 void *data, asection *input_section,
1390 bfd *output_bfd, char **error_message)
1392 if (output_bfd != NULL)
1393 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1394 input_section, output_bfd, error_message);
1396 if (strcmp (symbol->section->name, ".opd") == 0
1397 && (symbol->section->owner->flags & DYNAMIC) == 0)
1399 bfd_vma dest = opd_entry_value (symbol->section,
1400 symbol->value + reloc_entry->addend,
1402 if (dest != (bfd_vma) -1)
1403 reloc_entry->addend = dest - (symbol->value
1404 + symbol->section->output_section->vma
1405 + symbol->section->output_offset);
1409 elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
1411 if (symbol->section->owner != abfd
1412 && symbol->section->owner != NULL
1413 && abiversion (symbol->section->owner) >= 2)
1417 for (i = 0; i < symbol->section->owner->symcount; ++i)
1419 asymbol *symdef = symbol->section->owner->outsymbols[i];
1421 if (strcmp (symdef->name, symbol->name) == 0)
1423 elfsym = (elf_symbol_type *) symdef;
1429 += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
1431 return bfd_reloc_continue;
1434 static bfd_reloc_status_type
1435 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1436 void *data, asection *input_section,
1437 bfd *output_bfd, char **error_message)
1440 enum elf_ppc64_reloc_type r_type;
1441 bfd_size_type octets;
1442 /* Assume 'at' branch hints. */
1443 bfd_boolean is_isa_v2 = TRUE;
1445 /* If this is a relocatable link (output_bfd test tells us), just
1446 call the generic function. Any adjustment will be done at final
1448 if (output_bfd != NULL)
1449 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1450 input_section, output_bfd, error_message);
1452 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
1453 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
1454 insn &= ~(0x01 << 21);
1455 r_type = reloc_entry->howto->type;
1456 if (r_type == R_PPC64_ADDR14_BRTAKEN
1457 || r_type == R_PPC64_REL14_BRTAKEN)
1458 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
1462 /* Set 'a' bit. This is 0b00010 in BO field for branch
1463 on CR(BI) insns (BO == 001at or 011at), and 0b01000
1464 for branch on CTR insns (BO == 1a00t or 1a01t). */
1465 if ((insn & (0x14 << 21)) == (0x04 << 21))
1467 else if ((insn & (0x14 << 21)) == (0x10 << 21))
1477 if (!bfd_is_com_section (symbol->section))
1478 target = symbol->value;
1479 target += symbol->section->output_section->vma;
1480 target += symbol->section->output_offset;
1481 target += reloc_entry->addend;
1483 from = (reloc_entry->address
1484 + input_section->output_offset
1485 + input_section->output_section->vma);
1487 /* Invert 'y' bit if not the default. */
1488 if ((bfd_signed_vma) (target - from) < 0)
1491 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
1493 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
1494 input_section, output_bfd, error_message);
1497 static bfd_reloc_status_type
1498 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1499 void *data, asection *input_section,
1500 bfd *output_bfd, char **error_message)
1502 /* If this is a relocatable link (output_bfd test tells us), just
1503 call the generic function. Any adjustment will be done at final
1505 if (output_bfd != NULL)
1506 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1507 input_section, output_bfd, error_message);
1509 /* Subtract the symbol section base address. */
1510 reloc_entry->addend -= symbol->section->output_section->vma;
1511 return bfd_reloc_continue;
1514 static bfd_reloc_status_type
1515 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1516 void *data, asection *input_section,
1517 bfd *output_bfd, char **error_message)
1519 /* If this is a relocatable link (output_bfd test tells us), just
1520 call the generic function. Any adjustment will be done at final
1522 if (output_bfd != NULL)
1523 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1524 input_section, output_bfd, error_message);
1526 /* Subtract the symbol section base address. */
1527 reloc_entry->addend -= symbol->section->output_section->vma;
1529 /* Adjust the addend for sign extension of the low 16 bits. */
1530 reloc_entry->addend += 0x8000;
1531 return bfd_reloc_continue;
1534 static bfd_reloc_status_type
1535 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1536 void *data, asection *input_section,
1537 bfd *output_bfd, char **error_message)
1541 /* If this is a relocatable link (output_bfd test tells us), just
1542 call the generic function. Any adjustment will be done at final
1544 if (output_bfd != NULL)
1545 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1546 input_section, output_bfd, error_message);
1548 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
1550 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
1552 /* Subtract the TOC base address. */
1553 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
1554 return bfd_reloc_continue;
1557 static bfd_reloc_status_type
1558 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1559 void *data, asection *input_section,
1560 bfd *output_bfd, char **error_message)
1564 /* If this is a relocatable link (output_bfd test tells us), just
1565 call the generic function. Any adjustment will be done at final
1567 if (output_bfd != NULL)
1568 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1569 input_section, output_bfd, error_message);
1571 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
1573 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
1575 /* Subtract the TOC base address. */
1576 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
1578 /* Adjust the addend for sign extension of the low 16 bits. */
1579 reloc_entry->addend += 0x8000;
1580 return bfd_reloc_continue;
1583 static bfd_reloc_status_type
1584 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1585 void *data, asection *input_section,
1586 bfd *output_bfd, char **error_message)
1589 bfd_size_type octets;
1591 /* If this is a relocatable link (output_bfd test tells us), just
1592 call the generic function. Any adjustment will be done at final
1594 if (output_bfd != NULL)
1595 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1596 input_section, output_bfd, error_message);
1598 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
1600 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
1602 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
1603 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
1604 return bfd_reloc_ok;
1607 static bfd_reloc_status_type
1608 ppc64_elf_prefix_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1609 void *data, asection *input_section,
1610 bfd *output_bfd, char **error_message)
1615 if (output_bfd != NULL)
1616 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1617 input_section, output_bfd, error_message);
1619 insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
1621 insn |= bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address + 4);
1623 targ = (symbol->section->output_section->vma
1624 + symbol->section->output_offset
1625 + reloc_entry->addend);
1626 if (!bfd_is_com_section (symbol->section))
1627 targ += symbol->value;
1628 if (reloc_entry->howto->type == R_PPC64_D34_HA30)
1630 if (reloc_entry->howto->pc_relative)
1632 bfd_vma from = (reloc_entry->address
1633 + input_section->output_offset
1634 + input_section->output_section->vma);
1637 targ >>= reloc_entry->howto->rightshift;
1638 insn &= ~reloc_entry->howto->dst_mask;
1639 insn |= ((targ << 16) | (targ & 0xffff)) & reloc_entry->howto->dst_mask;
1640 bfd_put_32 (abfd, insn >> 32, (bfd_byte *) data + reloc_entry->address);
1641 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address + 4);
1642 if (reloc_entry->howto->complain_on_overflow == complain_overflow_signed
1643 && (targ + (1ULL << (reloc_entry->howto->bitsize - 1))
1644 >= 1ULL << reloc_entry->howto->bitsize))
1645 return bfd_reloc_overflow;
1646 return bfd_reloc_ok;
1649 static bfd_reloc_status_type
1650 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1651 void *data, asection *input_section,
1652 bfd *output_bfd, char **error_message)
1654 /* If this is a relocatable link (output_bfd test tells us), just
1655 call the generic function. Any adjustment will be done at final
1657 if (output_bfd != NULL)
1658 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1659 input_section, output_bfd, error_message);
1661 if (error_message != NULL)
1663 static char buf[60];
1664 sprintf (buf, "generic linker can't handle %s",
1665 reloc_entry->howto->name);
1666 *error_message = buf;
1668 return bfd_reloc_dangerous;
1671 /* Track GOT entries needed for a given symbol. We might need more
1672 than one got entry per symbol. */
1675 struct got_entry *next;
1677 /* The symbol addend that we'll be placing in the GOT. */
1680 /* Unlike other ELF targets, we use separate GOT entries for the same
1681 symbol referenced from different input files. This is to support
1682 automatic multiple TOC/GOT sections, where the TOC base can vary
1683 from one input file to another. After partitioning into TOC groups
1684 we merge entries within the group.
1686 Point to the BFD owning this GOT entry. */
1689 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
1690 TLS_TPREL or TLS_DTPREL for tls entries. */
1691 unsigned char tls_type;
1693 /* Non-zero if got.ent points to real entry. */
1694 unsigned char is_indirect;
1696 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
1699 bfd_signed_vma refcount;
1701 struct got_entry *ent;
1705 /* The same for PLT. */
1708 struct plt_entry *next;
1714 bfd_signed_vma refcount;
1719 struct ppc64_elf_obj_tdata
1721 struct elf_obj_tdata elf;
1723 /* Shortcuts to dynamic linker sections. */
1727 /* Used during garbage collection. We attach global symbols defined
1728 on removed .opd entries to this section so that the sym is removed. */
1729 asection *deleted_section;
1731 /* TLS local dynamic got entry handling. Support for multiple GOT
1732 sections means we potentially need one of these for each input bfd. */
1733 struct got_entry tlsld_got;
1737 /* A copy of relocs before they are modified for --emit-relocs. */
1738 Elf_Internal_Rela *relocs;
1740 /* Section contents. */
1744 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
1745 the reloc to be in the range -32768 to 32767. */
1746 unsigned int has_small_toc_reloc : 1;
1748 /* Set if toc/got ha relocs detected not using r2, or lo reloc
1749 instruction not one we handle. */
1750 unsigned int unexpected_toc_insn : 1;
1752 /* Set if got relocs that can be optimised are present in this file. */
1753 unsigned int has_gotrel : 1;
1756 #define ppc64_elf_tdata(bfd) \
1757 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
1759 #define ppc64_tlsld_got(bfd) \
1760 (&ppc64_elf_tdata (bfd)->tlsld_got)
1762 #define is_ppc64_elf(bfd) \
1763 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
1764 && elf_object_id (bfd) == PPC64_ELF_DATA)
1766 /* Override the generic function because we store some extras. */
1769 ppc64_elf_mkobject (bfd *abfd)
1771 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
1775 /* Fix bad default arch selected for a 64 bit input bfd when the
1776 default is 32 bit. Also select arch based on apuinfo. */
1779 ppc64_elf_object_p (bfd *abfd)
1781 if (!abfd->arch_info->the_default)
1784 if (abfd->arch_info->bits_per_word == 32)
1786 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
1788 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
1790 /* Relies on arch after 32 bit default being 64 bit default. */
1791 abfd->arch_info = abfd->arch_info->next;
1792 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
1795 return _bfd_elf_ppc_set_arch (abfd);
1798 /* Support for core dump NOTE sections. */
1801 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
1803 size_t offset, size;
1805 if (note->descsz != 504)
1809 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
1812 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
1818 /* Make a ".reg/999" section. */
1819 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
1820 size, note->descpos + offset);
1824 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
1826 if (note->descsz != 136)
1829 elf_tdata (abfd)->core->pid
1830 = bfd_get_32 (abfd, note->descdata + 24);
1831 elf_tdata (abfd)->core->program
1832 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
1833 elf_tdata (abfd)->core->command
1834 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
1840 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
1850 char data[136] ATTRIBUTE_NONSTRING;
1853 va_start (ap, note_type);
1854 memset (data, 0, sizeof (data));
1855 strncpy (data + 40, va_arg (ap, const char *), 16);
1856 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
1858 /* GCC 8.0 and 8.1 warn about 80 equals destination size with
1859 -Wstringop-truncation:
1860 https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85643
1862 DIAGNOSTIC_IGNORE_STRINGOP_TRUNCATION;
1864 strncpy (data + 56, va_arg (ap, const char *), 80);
1865 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
1869 return elfcore_write_note (abfd, buf, bufsiz,
1870 "CORE", note_type, data, sizeof (data));
1881 va_start (ap, note_type);
1882 memset (data, 0, 112);
1883 pid = va_arg (ap, long);
1884 bfd_put_32 (abfd, pid, data + 32);
1885 cursig = va_arg (ap, int);
1886 bfd_put_16 (abfd, cursig, data + 12);
1887 greg = va_arg (ap, const void *);
1888 memcpy (data + 112, greg, 384);
1889 memset (data + 496, 0, 8);
1891 return elfcore_write_note (abfd, buf, bufsiz,
1892 "CORE", note_type, data, sizeof (data));
1897 /* Add extra PPC sections. */
1899 static const struct bfd_elf_special_section ppc64_elf_special_sections[] =
1901 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
1902 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
1903 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
1904 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
1905 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
1906 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
1907 { NULL, 0, 0, 0, 0 }
1910 enum _ppc64_sec_type {
1916 struct _ppc64_elf_section_data
1918 struct bfd_elf_section_data elf;
1922 /* An array with one entry for each opd function descriptor,
1923 and some spares since opd entries may be either 16 or 24 bytes. */
1924 #define OPD_NDX(OFF) ((OFF) >> 4)
1925 struct _opd_sec_data
1927 /* Points to the function code section for local opd entries. */
1928 asection **func_sec;
1930 /* After editing .opd, adjust references to opd local syms. */
1934 /* An array for toc sections, indexed by offset/8. */
1935 struct _toc_sec_data
1937 /* Specifies the relocation symbol index used at a given toc offset. */
1940 /* And the relocation addend. */
1945 enum _ppc64_sec_type sec_type:2;
1947 /* Flag set when small branches are detected. Used to
1948 select suitable defaults for the stub group size. */
1949 unsigned int has_14bit_branch:1;
1951 /* Flag set when PLTCALL relocs are detected. */
1952 unsigned int has_pltcall:1;
1954 /* Flag set when section has GOT relocations that can be optimised. */
1955 unsigned int has_gotrel:1;
1958 #define ppc64_elf_section_data(sec) \
1959 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
1962 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
1964 if (!sec->used_by_bfd)
1966 struct _ppc64_elf_section_data *sdata;
1967 bfd_size_type amt = sizeof (*sdata);
1969 sdata = bfd_zalloc (abfd, amt);
1972 sec->used_by_bfd = sdata;
1975 return _bfd_elf_new_section_hook (abfd, sec);
1978 static struct _opd_sec_data *
1979 get_opd_info (asection * sec)
1982 && ppc64_elf_section_data (sec) != NULL
1983 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
1984 return &ppc64_elf_section_data (sec)->u.opd;
1988 /* Parameters for the qsort hook. */
1989 static bfd_boolean synthetic_relocatable;
1990 static asection *synthetic_opd;
1992 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
1995 compare_symbols (const void *ap, const void *bp)
1997 const asymbol *a = *(const asymbol **) ap;
1998 const asymbol *b = *(const asymbol **) bp;
2000 /* Section symbols first. */
2001 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
2003 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
2006 /* then .opd symbols. */
2007 if (synthetic_opd != NULL)
2009 if (strcmp (a->section->name, ".opd") == 0
2010 && strcmp (b->section->name, ".opd") != 0)
2012 if (strcmp (a->section->name, ".opd") != 0
2013 && strcmp (b->section->name, ".opd") == 0)
2017 /* then other code symbols. */
2018 if (((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2019 == (SEC_CODE | SEC_ALLOC))
2020 && ((b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2021 != (SEC_CODE | SEC_ALLOC)))
2024 if (((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2025 != (SEC_CODE | SEC_ALLOC))
2026 && ((b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2027 == (SEC_CODE | SEC_ALLOC)))
2030 if (synthetic_relocatable)
2032 if (a->section->id < b->section->id)
2035 if (a->section->id > b->section->id)
2039 if (a->value + a->section->vma < b->value + b->section->vma)
2042 if (a->value + a->section->vma > b->value + b->section->vma)
2045 /* For syms with the same value, prefer strong dynamic global function
2046 syms over other syms. */
2047 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
2050 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
2053 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
2056 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
2059 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
2062 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
2065 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
2068 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
2074 /* Search SYMS for a symbol of the given VALUE. */
2077 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
2081 if (id == (unsigned) -1)
2085 mid = (lo + hi) >> 1;
2086 if (syms[mid]->value + syms[mid]->section->vma < value)
2088 else if (syms[mid]->value + syms[mid]->section->vma > value)
2098 mid = (lo + hi) >> 1;
2099 if (syms[mid]->section->id < id)
2101 else if (syms[mid]->section->id > id)
2103 else if (syms[mid]->value < value)
2105 else if (syms[mid]->value > value)
2115 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
2117 bfd_vma vma = *(bfd_vma *) ptr;
2118 return ((section->flags & SEC_ALLOC) != 0
2119 && section->vma <= vma
2120 && vma < section->vma + section->size);
2123 /* Create synthetic symbols, effectively restoring "dot-symbol" function
2124 entry syms. Also generate @plt symbols for the glink branch table.
2125 Returns count of synthetic symbols in RET or -1 on error. */
2128 ppc64_elf_get_synthetic_symtab (bfd *abfd,
2129 long static_count, asymbol **static_syms,
2130 long dyn_count, asymbol **dyn_syms,
2136 size_t symcount, codesecsym, codesecsymend, secsymend, opdsymend;
2137 asection *opd = NULL;
2138 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2140 int abi = abiversion (abfd);
2146 opd = bfd_get_section_by_name (abfd, ".opd");
2147 if (opd == NULL && abi == 1)
2159 symcount = static_count;
2161 symcount += dyn_count;
2165 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
2169 if (!relocatable && static_count != 0 && dyn_count != 0)
2171 /* Use both symbol tables. */
2172 memcpy (syms, static_syms, static_count * sizeof (*syms));
2173 memcpy (syms + static_count, dyn_syms,
2174 (dyn_count + 1) * sizeof (*syms));
2176 else if (!relocatable && static_count == 0)
2177 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
2179 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
2181 /* Trim uninteresting symbols. Interesting symbols are section,
2182 function, and notype symbols. */
2183 for (i = 0, j = 0; i < symcount; ++i)
2184 if ((syms[i]->flags & (BSF_FILE | BSF_OBJECT | BSF_THREAD_LOCAL
2185 | BSF_RELC | BSF_SRELC)) == 0)
2186 syms[j++] = syms[i];
2189 synthetic_relocatable = relocatable;
2190 synthetic_opd = opd;
2191 qsort (syms, symcount, sizeof (*syms), compare_symbols);
2193 if (!relocatable && symcount > 1)
2195 /* Trim duplicate syms, since we may have merged the normal
2196 and dynamic symbols. Actually, we only care about syms
2197 that have different values, so trim any with the same
2198 value. Don't consider ifunc and ifunc resolver symbols
2199 duplicates however, because GDB wants to know whether a
2200 text symbol is an ifunc resolver. */
2201 for (i = 1, j = 1; i < symcount; ++i)
2203 const asymbol *s0 = syms[i - 1];
2204 const asymbol *s1 = syms[i];
2206 if ((s0->value + s0->section->vma
2207 != s1->value + s1->section->vma)
2208 || ((s0->flags & BSF_GNU_INDIRECT_FUNCTION)
2209 != (s1->flags & BSF_GNU_INDIRECT_FUNCTION)))
2210 syms[j++] = syms[i];
2216 /* Note that here and in compare_symbols we can't compare opd and
2217 sym->section directly. With separate debug info files, the
2218 symbols will be extracted from the debug file while abfd passed
2219 to this function is the real binary. */
2220 if (strcmp (syms[i]->section->name, ".opd") == 0)
2224 for (; i < symcount; ++i)
2225 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC
2226 | SEC_THREAD_LOCAL))
2227 != (SEC_CODE | SEC_ALLOC))
2228 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
2232 for (; i < symcount; ++i)
2233 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
2237 for (; i < symcount; ++i)
2238 if (strcmp (syms[i]->section->name, ".opd") != 0)
2242 for (; i < symcount; ++i)
2243 if (((syms[i]->section->flags
2244 & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL)))
2245 != (SEC_CODE | SEC_ALLOC))
2253 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
2258 if (opdsymend == secsymend)
2261 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
2262 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
2266 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
2273 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
2277 while (r < opd->relocation + relcount
2278 && r->address < syms[i]->value + opd->vma)
2281 if (r == opd->relocation + relcount)
2284 if (r->address != syms[i]->value + opd->vma)
2287 if (r->howto->type != R_PPC64_ADDR64)
2290 sym = *r->sym_ptr_ptr;
2291 if (!sym_exists_at (syms, opdsymend, symcount,
2292 sym->section->id, sym->value + r->addend))
2295 size += sizeof (asymbol);
2296 size += strlen (syms[i]->name) + 2;
2302 s = *ret = bfd_malloc (size);
2309 names = (char *) (s + count);
2311 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
2315 while (r < opd->relocation + relcount
2316 && r->address < syms[i]->value + opd->vma)
2319 if (r == opd->relocation + relcount)
2322 if (r->address != syms[i]->value + opd->vma)
2325 if (r->howto->type != R_PPC64_ADDR64)
2328 sym = *r->sym_ptr_ptr;
2329 if (!sym_exists_at (syms, opdsymend, symcount,
2330 sym->section->id, sym->value + r->addend))
2335 s->flags |= BSF_SYNTHETIC;
2336 s->section = sym->section;
2337 s->value = sym->value + r->addend;
2340 len = strlen (syms[i]->name);
2341 memcpy (names, syms[i]->name, len + 1);
2343 /* Have udata.p point back to the original symbol this
2344 synthetic symbol was derived from. */
2345 s->udata.p = syms[i];
2352 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
2353 bfd_byte *contents = NULL;
2355 size_t plt_count = 0;
2356 bfd_vma glink_vma = 0, resolv_vma = 0;
2357 asection *dynamic, *glink = NULL, *relplt = NULL;
2360 if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
2362 free_contents_and_exit_err:
2364 free_contents_and_exit:
2371 for (i = secsymend; i < opdsymend; ++i)
2375 /* Ignore bogus symbols. */
2376 if (syms[i]->value > opd->size - 8)
2379 ent = bfd_get_64 (abfd, contents + syms[i]->value);
2380 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
2383 size += sizeof (asymbol);
2384 size += strlen (syms[i]->name) + 2;
2388 /* Get start of .glink stubs from DT_PPC64_GLINK. */
2390 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
2392 bfd_byte *dynbuf, *extdyn, *extdynend;
2394 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
2396 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
2397 goto free_contents_and_exit_err;
2399 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
2400 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
2403 extdynend = extdyn + dynamic->size;
2404 for (; extdyn < extdynend; extdyn += extdynsize)
2406 Elf_Internal_Dyn dyn;
2407 (*swap_dyn_in) (abfd, extdyn, &dyn);
2409 if (dyn.d_tag == DT_NULL)
2412 if (dyn.d_tag == DT_PPC64_GLINK)
2414 /* The first glink stub starts at DT_PPC64_GLINK plus 32.
2415 See comment in ppc64_elf_finish_dynamic_sections. */
2416 glink_vma = dyn.d_un.d_val + 8 * 4;
2417 /* The .glink section usually does not survive the final
2418 link; search for the section (usually .text) where the
2419 glink stubs now reside. */
2420 glink = bfd_sections_find_if (abfd, section_covers_vma,
2431 /* Determine __glink trampoline by reading the relative branch
2432 from the first glink stub. */
2434 unsigned int off = 0;
2436 while (bfd_get_section_contents (abfd, glink, buf,
2437 glink_vma + off - glink->vma, 4))
2439 unsigned int insn = bfd_get_32 (abfd, buf);
2441 if ((insn & ~0x3fffffc) == 0)
2444 = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
2453 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
2455 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
2458 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
2459 if (!(*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
2460 goto free_contents_and_exit_err;
2462 plt_count = relplt->size / sizeof (Elf64_External_Rela);
2463 size += plt_count * sizeof (asymbol);
2465 p = relplt->relocation;
2466 for (i = 0; i < plt_count; i++, p++)
2468 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
2470 size += sizeof ("+0x") - 1 + 16;
2476 goto free_contents_and_exit;
2477 s = *ret = bfd_malloc (size);
2479 goto free_contents_and_exit_err;
2481 names = (char *) (s + count + plt_count + (resolv_vma != 0));
2483 for (i = secsymend; i < opdsymend; ++i)
2487 if (syms[i]->value > opd->size - 8)
2490 ent = bfd_get_64 (abfd, contents + syms[i]->value);
2491 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
2495 asection *sec = abfd->sections;
2502 size_t mid = (lo + hi) >> 1;
2503 if (syms[mid]->section->vma < ent)
2505 else if (syms[mid]->section->vma > ent)
2509 sec = syms[mid]->section;
2514 if (lo >= hi && lo > codesecsym)
2515 sec = syms[lo - 1]->section;
2517 for (; sec != NULL; sec = sec->next)
2521 /* SEC_LOAD may not be set if SEC is from a separate debug
2523 if ((sec->flags & SEC_ALLOC) == 0)
2525 if ((sec->flags & SEC_CODE) != 0)
2528 s->flags |= BSF_SYNTHETIC;
2529 s->value = ent - s->section->vma;
2532 len = strlen (syms[i]->name);
2533 memcpy (names, syms[i]->name, len + 1);
2535 /* Have udata.p point back to the original symbol this
2536 synthetic symbol was derived from. */
2537 s->udata.p = syms[i];
2543 if (glink != NULL && relplt != NULL)
2547 /* Add a symbol for the main glink trampoline. */
2548 memset (s, 0, sizeof *s);
2550 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
2552 s->value = resolv_vma - glink->vma;
2554 memcpy (names, "__glink_PLTresolve",
2555 sizeof ("__glink_PLTresolve"));
2556 names += sizeof ("__glink_PLTresolve");
2561 /* FIXME: It would be very much nicer to put sym@plt on the
2562 stub rather than on the glink branch table entry. The
2563 objdump disassembler would then use a sensible symbol
2564 name on plt calls. The difficulty in doing so is
2565 a) finding the stubs, and,
2566 b) matching stubs against plt entries, and,
2567 c) there can be multiple stubs for a given plt entry.
2569 Solving (a) could be done by code scanning, but older
2570 ppc64 binaries used different stubs to current code.
2571 (b) is the tricky one since you need to known the toc
2572 pointer for at least one function that uses a pic stub to
2573 be able to calculate the plt address referenced.
2574 (c) means gdb would need to set multiple breakpoints (or
2575 find the glink branch itself) when setting breakpoints
2576 for pending shared library loads. */
2577 p = relplt->relocation;
2578 for (i = 0; i < plt_count; i++, p++)
2582 *s = **p->sym_ptr_ptr;
2583 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
2584 we are defining a symbol, ensure one of them is set. */
2585 if ((s->flags & BSF_LOCAL) == 0)
2586 s->flags |= BSF_GLOBAL;
2587 s->flags |= BSF_SYNTHETIC;
2589 s->value = glink_vma - glink->vma;
2592 len = strlen ((*p->sym_ptr_ptr)->name);
2593 memcpy (names, (*p->sym_ptr_ptr)->name, len);
2597 memcpy (names, "+0x", sizeof ("+0x") - 1);
2598 names += sizeof ("+0x") - 1;
2599 bfd_sprintf_vma (abfd, names, p->addend);
2600 names += strlen (names);
2602 memcpy (names, "@plt", sizeof ("@plt"));
2603 names += sizeof ("@plt");
2623 /* The following functions are specific to the ELF linker, while
2624 functions above are used generally. Those named ppc64_elf_* are
2625 called by the main ELF linker code. They appear in this file more
2626 or less in the order in which they are called. eg.
2627 ppc64_elf_check_relocs is called early in the link process,
2628 ppc64_elf_finish_dynamic_sections is one of the last functions
2631 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
2632 functions have both a function code symbol and a function descriptor
2633 symbol. A call to foo in a relocatable object file looks like:
2640 The function definition in another object file might be:
2644 . .quad .TOC.@tocbase
2650 When the linker resolves the call during a static link, the branch
2651 unsurprisingly just goes to .foo and the .opd information is unused.
2652 If the function definition is in a shared library, things are a little
2653 different: The call goes via a plt call stub, the opd information gets
2654 copied to the plt, and the linker patches the nop.
2662 . std 2,40(1) # in practice, the call stub
2663 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
2664 . addi 11,11,Lfoo@toc@l # this is the general idea
2672 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
2674 The "reloc ()" notation is supposed to indicate that the linker emits
2675 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
2678 What are the difficulties here? Well, firstly, the relocations
2679 examined by the linker in check_relocs are against the function code
2680 sym .foo, while the dynamic relocation in the plt is emitted against
2681 the function descriptor symbol, foo. Somewhere along the line, we need
2682 to carefully copy dynamic link information from one symbol to the other.
2683 Secondly, the generic part of the elf linker will make .foo a dynamic
2684 symbol as is normal for most other backends. We need foo dynamic
2685 instead, at least for an application final link. However, when
2686 creating a shared library containing foo, we need to have both symbols
2687 dynamic so that references to .foo are satisfied during the early
2688 stages of linking. Otherwise the linker might decide to pull in a
2689 definition from some other object, eg. a static library.
2691 Update: As of August 2004, we support a new convention. Function
2692 calls may use the function descriptor symbol, ie. "bl foo". This
2693 behaves exactly as "bl .foo". */
2695 /* Of those relocs that might be copied as dynamic relocs, this
2696 function selects those that must be copied when linking a shared
2697 library or PIE, even when the symbol is local. */
2700 must_be_dyn_reloc (struct bfd_link_info *info,
2701 enum elf_ppc64_reloc_type r_type)
2706 /* Only relative relocs can be resolved when the object load
2707 address isn't fixed. DTPREL64 is excluded because the
2708 dynamic linker needs to differentiate global dynamic from
2709 local dynamic __tls_index pairs when PPC64_OPT_TLS is set. */
2717 case R_PPC64_TPREL16:
2718 case R_PPC64_TPREL16_LO:
2719 case R_PPC64_TPREL16_HI:
2720 case R_PPC64_TPREL16_HA:
2721 case R_PPC64_TPREL16_DS:
2722 case R_PPC64_TPREL16_LO_DS:
2723 case R_PPC64_TPREL16_HIGH:
2724 case R_PPC64_TPREL16_HIGHA:
2725 case R_PPC64_TPREL16_HIGHER:
2726 case R_PPC64_TPREL16_HIGHERA:
2727 case R_PPC64_TPREL16_HIGHEST:
2728 case R_PPC64_TPREL16_HIGHESTA:
2729 case R_PPC64_TPREL64:
2730 /* These relocations are relative but in a shared library the
2731 linker doesn't know the thread pointer base. */
2732 return bfd_link_dll (info);
2736 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
2737 copying dynamic variables from a shared lib into an app's dynbss
2738 section, and instead use a dynamic relocation to point into the
2739 shared lib. With code that gcc generates, it's vital that this be
2740 enabled; In the PowerPC64 ABI, the address of a function is actually
2741 the address of a function descriptor, which resides in the .opd
2742 section. gcc uses the descriptor directly rather than going via the
2743 GOT as some other ABI's do, which means that initialized function
2744 pointers must reference the descriptor. Thus, a function pointer
2745 initialized to the address of a function in a shared library will
2746 either require a copy reloc, or a dynamic reloc. Using a copy reloc
2747 redefines the function descriptor symbol to point to the copy. This
2748 presents a problem as a plt entry for that function is also
2749 initialized from the function descriptor symbol and the copy reloc
2750 may not be initialized first. */
2751 #define ELIMINATE_COPY_RELOCS 1
2753 /* Section name for stubs is the associated section name plus this
2755 #define STUB_SUFFIX ".stub"
2758 ppc_stub_long_branch:
2759 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
2760 destination, but a 24 bit branch in a stub section will reach.
2763 ppc_stub_plt_branch:
2764 Similar to the above, but a 24 bit branch in the stub section won't
2765 reach its destination.
2766 . addis %r11,%r2,xxx@toc@ha
2767 . ld %r12,xxx@toc@l(%r11)
2772 Used to call a function in a shared library. If it so happens that
2773 the plt entry referenced crosses a 64k boundary, then an extra
2774 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
2775 ppc_stub_plt_call_r2save starts with "std %r2,40(%r1)".
2776 . addis %r11,%r2,xxx@toc@ha
2777 . ld %r12,xxx+0@toc@l(%r11)
2779 . ld %r2,xxx+8@toc@l(%r11)
2780 . ld %r11,xxx+16@toc@l(%r11)
2783 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
2784 code to adjust the value and save r2 to support multiple toc sections.
2785 A ppc_stub_long_branch with an r2 offset looks like:
2787 . addis %r2,%r2,off@ha
2788 . addi %r2,%r2,off@l
2791 A ppc_stub_plt_branch with an r2 offset looks like:
2793 . addis %r11,%r2,xxx@toc@ha
2794 . ld %r12,xxx@toc@l(%r11)
2795 . addis %r2,%r2,off@ha
2796 . addi %r2,%r2,off@l
2800 All of the above stubs are shown as their ELFv1 variants. ELFv2
2801 variants exist too, simpler for plt calls since a new toc pointer
2802 and static chain are not loaded by the stub. In addition, ELFv2
2803 has some more complex stubs to handle calls marked with NOTOC
2804 relocs from functions where r2 is not a valid toc pointer. These
2805 come in two flavours, the ones shown below, and _both variants that
2806 start with "std %r2,24(%r1)" to save r2 in the unlikely event that
2807 one call is from a function where r2 is used as the toc pointer but
2808 needs a toc adjusting stub for small-model multi-toc, and another
2809 call is from a function where r2 is not valid.
2810 ppc_stub_long_branch_notoc:
2816 . addis %r12,%r11,dest-1b@ha
2817 . addi %r12,%r12,dest-1b@l
2820 ppc_stub_plt_branch_notoc:
2826 . lis %r12,xxx-1b@highest
2827 . ori %r12,%r12,xxx-1b@higher
2829 . oris %r12,%r12,xxx-1b@high
2830 . ori %r12,%r12,xxx-1b@l
2831 . add %r12,%r11,%r12
2835 ppc_stub_plt_call_notoc:
2841 . lis %r12,xxx-1b@highest
2842 . ori %r12,%r12,xxx-1b@higher
2844 . oris %r12,%r12,xxx-1b@high
2845 . ori %r12,%r12,xxx-1b@l
2846 . ldx %r12,%r11,%r12
2850 There are also ELFv1 powerxx variants of these stubs.
2851 ppc_stub_long_branch_notoc:
2852 . pla %r12,dest@pcrel
2854 ppc_stub_plt_branch_notoc:
2855 . lis %r11,(dest-1f)@highesta34
2856 . ori %r11,%r11,(dest-1f)@highera34
2858 . 1: pla %r12,dest@pcrel
2859 . add %r12,%r11,%r12
2862 ppc_stub_plt_call_notoc:
2863 . lis %r11,(xxx-1f)@highesta34
2864 . ori %r11,%r11,(xxx-1f)@highera34
2866 . 1: pla %r12,xxx@pcrel
2867 . ldx %r12,%r11,%r12
2871 In cases where the high instructions would add zero, they are
2872 omitted and following instructions modified in some cases.
2873 For example, a powerxx ppc_stub_plt_call_notoc might simplify down
2875 . pld %r12,xxx@pcrel
2879 For a given stub group (a set of sections all using the same toc
2880 pointer value) there will be just one stub type used for any
2881 particular function symbol. For example, if printf is called from
2882 code with the tocsave optimization (ie. r2 saved in function
2883 prologue) and therefore calls use a ppc_stub_plt_call linkage stub,
2884 and from other code without the tocsave optimization requiring a
2885 ppc_stub_plt_call_r2save linkage stub, a single stub of the latter
2886 type will be created. Calls with the tocsave optimization will
2887 enter this stub after the instruction saving r2. A similar
2888 situation exists when calls are marked with R_PPC64_REL24_NOTOC
2889 relocations. These require a ppc_stub_plt_call_notoc linkage stub
2890 to call an external function like printf. If other calls to printf
2891 require a ppc_stub_plt_call linkage stub then a single
2892 ppc_stub_plt_call_notoc linkage stub will be used for both types of
2893 call. If other calls to printf require a ppc_stub_plt_call_r2save
2894 linkage stub then a single ppc_stub_plt_call_both linkage stub will
2895 be created and calls not requiring r2 to be saved will enter the
2896 stub after the r2 save instruction. There is an analogous
2897 hierarchy of long branch and plt branch stubs for local call
2903 ppc_stub_long_branch,
2904 ppc_stub_long_branch_r2off,
2905 ppc_stub_long_branch_notoc,
2906 ppc_stub_long_branch_both, /* r2off and notoc variants both needed. */
2907 ppc_stub_plt_branch,
2908 ppc_stub_plt_branch_r2off,
2909 ppc_stub_plt_branch_notoc,
2910 ppc_stub_plt_branch_both,
2912 ppc_stub_plt_call_r2save,
2913 ppc_stub_plt_call_notoc,
2914 ppc_stub_plt_call_both,
2915 ppc_stub_global_entry,
2919 /* Information on stub grouping. */
2922 /* The stub section. */
2924 /* This is the section to which stubs in the group will be attached. */
2927 struct map_stub *next;
2928 /* Whether to emit a copy of register save/restore functions in this
2931 /* Current offset within stubs after the insn restoring lr in a
2932 _notoc or _both stub using bcl for pc-relative addressing, or
2933 after the insn restoring lr in a __tls_get_addr_opt plt stub. */
2934 unsigned int lr_restore;
2935 /* Accumulated size of EH info emitted to describe return address
2936 if stubs modify lr. Does not include 17 byte FDE header. */
2937 unsigned int eh_size;
2938 /* Offset in glink_eh_frame to the start of EH info for this group. */
2939 unsigned int eh_base;
2942 struct ppc_stub_hash_entry
2944 /* Base hash table entry structure. */
2945 struct bfd_hash_entry root;
2947 enum ppc_stub_type stub_type;
2949 /* Group information. */
2950 struct map_stub *group;
2952 /* Offset within stub_sec of the beginning of this stub. */
2953 bfd_vma stub_offset;
2955 /* Given the symbol's value and its section we can determine its final
2956 value when building the stubs (so the stub knows where to jump. */
2957 bfd_vma target_value;
2958 asection *target_section;
2960 /* The symbol table entry, if any, that this was derived from. */
2961 struct ppc_link_hash_entry *h;
2962 struct plt_entry *plt_ent;
2965 unsigned char symtype;
2967 /* Symbol st_other. */
2968 unsigned char other;
2971 struct ppc_branch_hash_entry
2973 /* Base hash table entry structure. */
2974 struct bfd_hash_entry root;
2976 /* Offset within branch lookup table. */
2977 unsigned int offset;
2979 /* Generation marker. */
2983 /* Used to track dynamic relocations for local symbols. */
2984 struct ppc_dyn_relocs
2986 struct ppc_dyn_relocs *next;
2988 /* The input section of the reloc. */
2991 /* Total number of relocs copied for the input section. */
2992 unsigned int count : 31;
2994 /* Whether this entry is for STT_GNU_IFUNC symbols. */
2995 unsigned int ifunc : 1;
2998 struct ppc_link_hash_entry
3000 struct elf_link_hash_entry elf;
3004 /* A pointer to the most recently used stub hash entry against this
3006 struct ppc_stub_hash_entry *stub_cache;
3008 /* A pointer to the next symbol starting with a '.' */
3009 struct ppc_link_hash_entry *next_dot_sym;
3012 /* Track dynamic relocs copied for this symbol. */
3013 struct elf_dyn_relocs *dyn_relocs;
3015 /* Link between function code and descriptor symbols. */
3016 struct ppc_link_hash_entry *oh;
3018 /* Flag function code and descriptor symbols. */
3019 unsigned int is_func:1;
3020 unsigned int is_func_descriptor:1;
3021 unsigned int fake:1;
3023 /* Whether global opd/toc sym has been adjusted or not.
3024 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3025 should be set for all globals defined in any opd/toc section. */
3026 unsigned int adjust_done:1;
3028 /* Set if this is an out-of-line register save/restore function,
3029 with non-standard calling convention. */
3030 unsigned int save_res:1;
3032 /* Set if a duplicate symbol with non-zero localentry is detected,
3033 even when the duplicate symbol does not provide a definition. */
3034 unsigned int non_zero_localentry:1;
3036 /* Contexts in which symbol is used in the GOT (or TOC).
3037 Bits are or'd into the mask as the corresponding relocs are
3038 encountered during check_relocs, with TLS_TLS being set when any
3039 of the other TLS bits are set. tls_optimize clears bits when
3040 optimizing to indicate the corresponding GOT entry type is not
3041 needed. If set, TLS_TLS is never cleared. tls_optimize may also
3042 set TLS_GDIE when a GD reloc turns into an IE one.
3043 These flags are also kept for local symbols. */
3044 #define TLS_TLS 1 /* Any TLS reloc. */
3045 #define TLS_GD 2 /* GD reloc. */
3046 #define TLS_LD 4 /* LD reloc. */
3047 #define TLS_TPREL 8 /* TPREL reloc, => IE. */
3048 #define TLS_DTPREL 16 /* DTPREL reloc, => LD. */
3049 #define TLS_MARK 32 /* __tls_get_addr call marked. */
3050 #define TLS_GDIE 64 /* GOT TPREL reloc resulting from GD->IE. */
3051 #define TLS_EXPLICIT 256 /* TOC section TLS reloc, not stored. */
3052 unsigned char tls_mask;
3054 /* The above field is also used to mark function symbols. In which
3055 case TLS_TLS will be 0. */
3056 #define PLT_IFUNC 2 /* STT_GNU_IFUNC. */
3057 #define PLT_KEEP 4 /* inline plt call requires plt entry. */
3058 #define NON_GOT 256 /* local symbol plt, not stored. */
3061 /* ppc64 ELF linker hash table. */
3063 struct ppc_link_hash_table
3065 struct elf_link_hash_table elf;
3067 /* The stub hash table. */
3068 struct bfd_hash_table stub_hash_table;
3070 /* Another hash table for plt_branch stubs. */
3071 struct bfd_hash_table branch_hash_table;
3073 /* Hash table for function prologue tocsave. */
3074 htab_t tocsave_htab;
3076 /* Various options and other info passed from the linker. */
3077 struct ppc64_elf_params *params;
3079 /* The size of sec_info below. */
3080 unsigned int sec_info_arr_size;
3082 /* Per-section array of extra section info. Done this way rather
3083 than as part of ppc64_elf_section_data so we have the info for
3084 non-ppc64 sections. */
3087 /* Along with elf_gp, specifies the TOC pointer used by this section. */
3092 /* The section group that this section belongs to. */
3093 struct map_stub *group;
3094 /* A temp section list pointer. */
3099 /* Linked list of groups. */
3100 struct map_stub *group;
3102 /* Temp used when calculating TOC pointers. */
3105 asection *toc_first_sec;
3107 /* Used when adding symbols. */
3108 struct ppc_link_hash_entry *dot_syms;
3110 /* Shortcuts to get to dynamic linker sections. */
3112 asection *global_entry;
3115 asection *relpltlocal;
3118 asection *glink_eh_frame;
3120 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
3121 struct ppc_link_hash_entry *tls_get_addr;
3122 struct ppc_link_hash_entry *tls_get_addr_fd;
3124 /* The size of reliplt used by got entry relocs. */
3125 bfd_size_type got_reli_size;
3128 unsigned long stub_count[ppc_stub_global_entry];
3130 /* Number of stubs against global syms. */
3131 unsigned long stub_globals;
3133 /* Set if we're linking code with function descriptors. */
3134 unsigned int opd_abi:1;
3136 /* Support for multiple toc sections. */
3137 unsigned int do_multi_toc:1;
3138 unsigned int multi_toc_needed:1;
3139 unsigned int second_toc_pass:1;
3140 unsigned int do_toc_opt:1;
3142 /* Set if tls optimization is enabled. */
3143 unsigned int do_tls_opt:1;
3145 /* Set if inline plt calls should be converted to direct calls. */
3146 unsigned int can_convert_all_inline_plt:1;
3149 unsigned int stub_error:1;
3151 /* Whether func_desc_adjust needs to be run over symbols. */
3152 unsigned int need_func_desc_adj:1;
3154 /* Whether there exist local gnu indirect function resolvers,
3155 referenced by dynamic relocations. */
3156 unsigned int local_ifunc_resolver:1;
3157 unsigned int maybe_local_ifunc_resolver:1;
3159 /* Whether plt calls for ELFv2 localentry:0 funcs have been optimized. */
3160 unsigned int has_plt_localentry0:1;
3162 /* Whether calls are made via the PLT from NOTOC functions. */
3163 unsigned int notoc_plt:1;
3165 /* Whether to use powerxx instructions in linkage stubs. */
3166 unsigned int powerxx_stubs:1;
3168 /* Incremented every time we size stubs. */
3169 unsigned int stub_iteration;
3171 /* Small local sym cache. */
3172 struct sym_cache sym_cache;
3175 /* Rename some of the generic section flags to better document how they
3178 /* Nonzero if this section has TLS related relocations. */
3179 #define has_tls_reloc sec_flg0
3181 /* Nonzero if this section has an old-style call to __tls_get_addr. */
3182 #define has_tls_get_addr_call sec_flg1
3184 /* Nonzero if this section has any toc or got relocs. */
3185 #define has_toc_reloc sec_flg2
3187 /* Nonzero if this section has a call to another section that uses
3189 #define makes_toc_func_call sec_flg3
3191 /* Recursion protection when determining above flag. */
3192 #define call_check_in_progress sec_flg4
3193 #define call_check_done sec_flg5
3195 /* Get the ppc64 ELF linker hash table from a link_info structure. */
3197 #define ppc_hash_table(p) \
3198 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3199 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3201 #define ppc_stub_hash_lookup(table, string, create, copy) \
3202 ((struct ppc_stub_hash_entry *) \
3203 bfd_hash_lookup ((table), (string), (create), (copy)))
3205 #define ppc_branch_hash_lookup(table, string, create, copy) \
3206 ((struct ppc_branch_hash_entry *) \
3207 bfd_hash_lookup ((table), (string), (create), (copy)))
3209 /* Create an entry in the stub hash table. */
3211 static struct bfd_hash_entry *
3212 stub_hash_newfunc (struct bfd_hash_entry *entry,
3213 struct bfd_hash_table *table,
3216 /* Allocate the structure if it has not already been allocated by a
3220 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
3225 /* Call the allocation method of the superclass. */
3226 entry = bfd_hash_newfunc (entry, table, string);
3229 struct ppc_stub_hash_entry *eh;
3231 /* Initialize the local fields. */
3232 eh = (struct ppc_stub_hash_entry *) entry;
3233 eh->stub_type = ppc_stub_none;
3235 eh->stub_offset = 0;
3236 eh->target_value = 0;
3237 eh->target_section = NULL;
3246 /* Create an entry in the branch hash table. */
3248 static struct bfd_hash_entry *
3249 branch_hash_newfunc (struct bfd_hash_entry *entry,
3250 struct bfd_hash_table *table,
3253 /* Allocate the structure if it has not already been allocated by a
3257 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
3262 /* Call the allocation method of the superclass. */
3263 entry = bfd_hash_newfunc (entry, table, string);
3266 struct ppc_branch_hash_entry *eh;
3268 /* Initialize the local fields. */
3269 eh = (struct ppc_branch_hash_entry *) entry;
3277 /* Create an entry in a ppc64 ELF linker hash table. */
3279 static struct bfd_hash_entry *
3280 link_hash_newfunc (struct bfd_hash_entry *entry,
3281 struct bfd_hash_table *table,
3284 /* Allocate the structure if it has not already been allocated by a
3288 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
3293 /* Call the allocation method of the superclass. */
3294 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
3297 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
3299 memset (&eh->u.stub_cache, 0,
3300 (sizeof (struct ppc_link_hash_entry)
3301 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
3303 /* When making function calls, old ABI code references function entry
3304 points (dot symbols), while new ABI code references the function
3305 descriptor symbol. We need to make any combination of reference and
3306 definition work together, without breaking archive linking.
3308 For a defined function "foo" and an undefined call to "bar":
3309 An old object defines "foo" and ".foo", references ".bar" (possibly
3311 A new object defines "foo" and references "bar".
3313 A new object thus has no problem with its undefined symbols being
3314 satisfied by definitions in an old object. On the other hand, the
3315 old object won't have ".bar" satisfied by a new object.
3317 Keep a list of newly added dot-symbols. */
3319 if (string[0] == '.')
3321 struct ppc_link_hash_table *htab;
3323 htab = (struct ppc_link_hash_table *) table;
3324 eh->u.next_dot_sym = htab->dot_syms;
3325 htab->dot_syms = eh;
3332 struct tocsave_entry
3339 tocsave_htab_hash (const void *p)
3341 const struct tocsave_entry *e = (const struct tocsave_entry *) p;
3342 return ((bfd_vma) (intptr_t) e->sec ^ e->offset) >> 3;
3346 tocsave_htab_eq (const void *p1, const void *p2)
3348 const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
3349 const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
3350 return e1->sec == e2->sec && e1->offset == e2->offset;
3353 /* Destroy a ppc64 ELF linker hash table. */
3356 ppc64_elf_link_hash_table_free (bfd *obfd)
3358 struct ppc_link_hash_table *htab;
3360 htab = (struct ppc_link_hash_table *) obfd->link.hash;
3361 if (htab->tocsave_htab)
3362 htab_delete (htab->tocsave_htab);
3363 bfd_hash_table_free (&htab->branch_hash_table);
3364 bfd_hash_table_free (&htab->stub_hash_table);
3365 _bfd_elf_link_hash_table_free (obfd);
3368 /* Create a ppc64 ELF linker hash table. */
3370 static struct bfd_link_hash_table *
3371 ppc64_elf_link_hash_table_create (bfd *abfd)
3373 struct ppc_link_hash_table *htab;
3374 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
3376 htab = bfd_zmalloc (amt);
3380 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
3381 sizeof (struct ppc_link_hash_entry),
3388 /* Init the stub hash table too. */
3389 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
3390 sizeof (struct ppc_stub_hash_entry)))
3392 _bfd_elf_link_hash_table_free (abfd);
3396 /* And the branch hash table. */
3397 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
3398 sizeof (struct ppc_branch_hash_entry)))
3400 bfd_hash_table_free (&htab->stub_hash_table);
3401 _bfd_elf_link_hash_table_free (abfd);
3405 htab->tocsave_htab = htab_try_create (1024,
3409 if (htab->tocsave_htab == NULL)
3411 ppc64_elf_link_hash_table_free (abfd);
3414 htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
3416 /* Initializing two fields of the union is just cosmetic. We really
3417 only care about glist, but when compiled on a 32-bit host the
3418 bfd_vma fields are larger. Setting the bfd_vma to zero makes
3419 debugger inspection of these fields look nicer. */
3420 htab->elf.init_got_refcount.refcount = 0;
3421 htab->elf.init_got_refcount.glist = NULL;
3422 htab->elf.init_plt_refcount.refcount = 0;
3423 htab->elf.init_plt_refcount.glist = NULL;
3424 htab->elf.init_got_offset.offset = 0;
3425 htab->elf.init_got_offset.glist = NULL;
3426 htab->elf.init_plt_offset.offset = 0;
3427 htab->elf.init_plt_offset.glist = NULL;
3429 return &htab->elf.root;
3432 /* Create sections for linker generated code. */
3435 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
3437 struct ppc_link_hash_table *htab;
3440 htab = ppc_hash_table (info);
3442 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
3443 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3444 if (htab->params->save_restore_funcs)
3446 /* Create .sfpr for code to save and restore fp regs. */
3447 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
3449 if (htab->sfpr == NULL
3450 || !bfd_set_section_alignment (dynobj, htab->sfpr, 2))
3454 if (bfd_link_relocatable (info))
3457 /* Create .glink for lazy dynamic linking support. */
3458 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
3460 if (htab->glink == NULL
3461 || !bfd_set_section_alignment (dynobj, htab->glink, 3))
3464 /* The part of .glink used by global entry stubs, separate so that
3465 it can be aligned appropriately without affecting htab->glink. */
3466 htab->global_entry = bfd_make_section_anyway_with_flags (dynobj, ".glink",
3468 if (htab->global_entry == NULL
3469 || !bfd_set_section_alignment (dynobj, htab->global_entry, 2))
3472 if (!info->no_ld_generated_unwind_info)
3474 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
3475 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3476 htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
3479 if (htab->glink_eh_frame == NULL
3480 || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
3484 flags = SEC_ALLOC | SEC_LINKER_CREATED;
3485 htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
3486 if (htab->elf.iplt == NULL
3487 || !bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
3490 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
3491 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3493 = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
3494 if (htab->elf.irelplt == NULL
3495 || !bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
3498 /* Create branch lookup table for plt_branch stubs. */
3499 flags = (SEC_ALLOC | SEC_LOAD
3500 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3501 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
3503 if (htab->brlt == NULL
3504 || !bfd_set_section_alignment (dynobj, htab->brlt, 3))
3507 /* Local plt entries, put in .branch_lt but a separate section for
3509 htab->pltlocal = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
3511 if (htab->pltlocal == NULL
3512 || !bfd_set_section_alignment (dynobj, htab->pltlocal, 3))
3515 if (!bfd_link_pic (info))
3518 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
3519 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3521 = bfd_make_section_anyway_with_flags (dynobj, ".rela.branch_lt", flags);
3522 if (htab->relbrlt == NULL
3523 || !bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
3527 = bfd_make_section_anyway_with_flags (dynobj, ".rela.branch_lt", flags);
3528 if (htab->relpltlocal == NULL
3529 || !bfd_set_section_alignment (dynobj, htab->relpltlocal, 3))
3535 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
3538 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
3539 struct ppc64_elf_params *params)
3541 struct ppc_link_hash_table *htab;
3543 elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
3545 /* Always hook our dynamic sections into the first bfd, which is the
3546 linker created stub bfd. This ensures that the GOT header is at
3547 the start of the output TOC section. */
3548 htab = ppc_hash_table (info);
3549 htab->elf.dynobj = params->stub_bfd;
3550 htab->params = params;
3552 return create_linkage_sections (htab->elf.dynobj, info);
3555 /* Build a name for an entry in the stub hash table. */
3558 ppc_stub_name (const asection *input_section,
3559 const asection *sym_sec,
3560 const struct ppc_link_hash_entry *h,
3561 const Elf_Internal_Rela *rel)
3566 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
3567 offsets from a sym as a branch target? In fact, we could
3568 probably assume the addend is always zero. */
3569 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
3573 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
3574 stub_name = bfd_malloc (len);
3575 if (stub_name == NULL)
3578 len = sprintf (stub_name, "%08x.%s+%x",
3579 input_section->id & 0xffffffff,
3580 h->elf.root.root.string,
3581 (int) rel->r_addend & 0xffffffff);
3585 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
3586 stub_name = bfd_malloc (len);
3587 if (stub_name == NULL)
3590 len = sprintf (stub_name, "%08x.%x:%x+%x",
3591 input_section->id & 0xffffffff,
3592 sym_sec->id & 0xffffffff,
3593 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
3594 (int) rel->r_addend & 0xffffffff);
3596 if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
3597 stub_name[len - 2] = 0;
3601 /* Look up an entry in the stub hash. Stub entries are cached because
3602 creating the stub name takes a bit of time. */
3604 static struct ppc_stub_hash_entry *
3605 ppc_get_stub_entry (const asection *input_section,
3606 const asection *sym_sec,
3607 struct ppc_link_hash_entry *h,
3608 const Elf_Internal_Rela *rel,
3609 struct ppc_link_hash_table *htab)
3611 struct ppc_stub_hash_entry *stub_entry;
3612 struct map_stub *group;
3614 /* If this input section is part of a group of sections sharing one
3615 stub section, then use the id of the first section in the group.
3616 Stub names need to include a section id, as there may well be
3617 more than one stub used to reach say, printf, and we need to
3618 distinguish between them. */
3619 group = htab->sec_info[input_section->id].u.group;
3623 if (h != NULL && h->u.stub_cache != NULL
3624 && h->u.stub_cache->h == h
3625 && h->u.stub_cache->group == group)
3627 stub_entry = h->u.stub_cache;
3633 stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
3634 if (stub_name == NULL)
3637 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
3638 stub_name, FALSE, FALSE);
3640 h->u.stub_cache = stub_entry;
3648 /* Add a new stub entry to the stub hash. Not all fields of the new
3649 stub entry are initialised. */
3651 static struct ppc_stub_hash_entry *
3652 ppc_add_stub (const char *stub_name,
3654 struct bfd_link_info *info)
3656 struct ppc_link_hash_table *htab = ppc_hash_table (info);
3657 struct map_stub *group;
3660 struct ppc_stub_hash_entry *stub_entry;
3662 group = htab->sec_info[section->id].u.group;
3663 link_sec = group->link_sec;
3664 stub_sec = group->stub_sec;
3665 if (stub_sec == NULL)
3671 namelen = strlen (link_sec->name);
3672 len = namelen + sizeof (STUB_SUFFIX);
3673 s_name = bfd_alloc (htab->params->stub_bfd, len);
3677 memcpy (s_name, link_sec->name, namelen);
3678 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
3679 stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
3680 if (stub_sec == NULL)
3682 group->stub_sec = stub_sec;
3685 /* Enter this entry into the linker stub hash table. */
3686 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
3688 if (stub_entry == NULL)
3690 /* xgettext:c-format */
3691 _bfd_error_handler (_("%pB: cannot create stub entry %s"),
3692 section->owner, stub_name);
3696 stub_entry->group = group;
3697 stub_entry->stub_offset = 0;
3701 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
3702 not already done. */
3705 create_got_section (bfd *abfd, struct bfd_link_info *info)
3707 asection *got, *relgot;
3709 struct ppc_link_hash_table *htab = ppc_hash_table (info);
3711 if (!is_ppc64_elf (abfd))
3717 && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
3720 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3721 | SEC_LINKER_CREATED);
3723 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
3725 || !bfd_set_section_alignment (abfd, got, 3))
3728 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
3729 flags | SEC_READONLY);
3731 || !bfd_set_section_alignment (abfd, relgot, 3))
3734 ppc64_elf_tdata (abfd)->got = got;
3735 ppc64_elf_tdata (abfd)->relgot = relgot;
3739 /* Follow indirect and warning symbol links. */
3741 static inline struct bfd_link_hash_entry *
3742 follow_link (struct bfd_link_hash_entry *h)
3744 while (h->type == bfd_link_hash_indirect
3745 || h->type == bfd_link_hash_warning)
3750 static inline struct elf_link_hash_entry *
3751 elf_follow_link (struct elf_link_hash_entry *h)
3753 return (struct elf_link_hash_entry *) follow_link (&h->root);
3756 static inline struct ppc_link_hash_entry *
3757 ppc_follow_link (struct ppc_link_hash_entry *h)
3759 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
3762 /* Merge PLT info on FROM with that on TO. */
3765 move_plt_plist (struct ppc_link_hash_entry *from,
3766 struct ppc_link_hash_entry *to)
3768 if (from->elf.plt.plist != NULL)
3770 if (to->elf.plt.plist != NULL)
3772 struct plt_entry **entp;
3773 struct plt_entry *ent;
3775 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
3777 struct plt_entry *dent;
3779 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
3780 if (dent->addend == ent->addend)
3782 dent->plt.refcount += ent->plt.refcount;
3789 *entp = to->elf.plt.plist;
3792 to->elf.plt.plist = from->elf.plt.plist;
3793 from->elf.plt.plist = NULL;
3797 /* Copy the extra info we tack onto an elf_link_hash_entry. */
3800 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
3801 struct elf_link_hash_entry *dir,
3802 struct elf_link_hash_entry *ind)
3804 struct ppc_link_hash_entry *edir, *eind;
3806 edir = (struct ppc_link_hash_entry *) dir;
3807 eind = (struct ppc_link_hash_entry *) ind;
3809 edir->is_func |= eind->is_func;
3810 edir->is_func_descriptor |= eind->is_func_descriptor;
3811 edir->tls_mask |= eind->tls_mask;
3812 if (eind->oh != NULL)
3813 edir->oh = ppc_follow_link (eind->oh);
3815 if (edir->elf.versioned != versioned_hidden)
3816 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
3817 edir->elf.ref_regular |= eind->elf.ref_regular;
3818 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
3819 edir->elf.non_got_ref |= eind->elf.non_got_ref;
3820 edir->elf.needs_plt |= eind->elf.needs_plt;
3821 edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
3823 /* If we were called to copy over info for a weak sym, don't copy
3824 dyn_relocs, plt/got info, or dynindx. We used to copy dyn_relocs
3825 in order to simplify readonly_dynrelocs and save a field in the
3826 symbol hash entry, but that means dyn_relocs can't be used in any
3827 tests about a specific symbol, or affect other symbol flags which
3829 if (eind->elf.root.type != bfd_link_hash_indirect)
3832 /* Copy over any dynamic relocs we may have on the indirect sym. */
3833 if (eind->dyn_relocs != NULL)
3835 if (edir->dyn_relocs != NULL)
3837 struct elf_dyn_relocs **pp;
3838 struct elf_dyn_relocs *p;
3840 /* Add reloc counts against the indirect sym to the direct sym
3841 list. Merge any entries against the same section. */
3842 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
3844 struct elf_dyn_relocs *q;
3846 for (q = edir->dyn_relocs; q != NULL; q = q->next)
3847 if (q->sec == p->sec)
3849 q->pc_count += p->pc_count;
3850 q->count += p->count;
3857 *pp = edir->dyn_relocs;
3860 edir->dyn_relocs = eind->dyn_relocs;
3861 eind->dyn_relocs = NULL;
3864 /* Copy over got entries that we may have already seen to the
3865 symbol which just became indirect. */
3866 if (eind->elf.got.glist != NULL)
3868 if (edir->elf.got.glist != NULL)
3870 struct got_entry **entp;
3871 struct got_entry *ent;
3873 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
3875 struct got_entry *dent;
3877 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
3878 if (dent->addend == ent->addend
3879 && dent->owner == ent->owner
3880 && dent->tls_type == ent->tls_type)
3882 dent->got.refcount += ent->got.refcount;
3889 *entp = edir->elf.got.glist;
3892 edir->elf.got.glist = eind->elf.got.glist;
3893 eind->elf.got.glist = NULL;
3896 /* And plt entries. */
3897 move_plt_plist (eind, edir);
3899 if (eind->elf.dynindx != -1)
3901 if (edir->elf.dynindx != -1)
3902 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
3903 edir->elf.dynstr_index);
3904 edir->elf.dynindx = eind->elf.dynindx;
3905 edir->elf.dynstr_index = eind->elf.dynstr_index;
3906 eind->elf.dynindx = -1;
3907 eind->elf.dynstr_index = 0;
3911 /* Find the function descriptor hash entry from the given function code
3912 hash entry FH. Link the entries via their OH fields. */
3914 static struct ppc_link_hash_entry *
3915 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
3917 struct ppc_link_hash_entry *fdh = fh->oh;
3921 const char *fd_name = fh->elf.root.root.string + 1;
3923 fdh = (struct ppc_link_hash_entry *)
3924 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
3928 fdh->is_func_descriptor = 1;
3934 fdh = ppc_follow_link (fdh);
3935 fdh->is_func_descriptor = 1;
3940 /* Make a fake function descriptor sym for the undefined code sym FH. */
3942 static struct ppc_link_hash_entry *
3943 make_fdh (struct bfd_link_info *info,
3944 struct ppc_link_hash_entry *fh)
3946 bfd *abfd = fh->elf.root.u.undef.abfd;
3947 struct bfd_link_hash_entry *bh = NULL;
3948 struct ppc_link_hash_entry *fdh;
3949 flagword flags = (fh->elf.root.type == bfd_link_hash_undefweak
3953 if (!_bfd_generic_link_add_one_symbol (info, abfd,
3954 fh->elf.root.root.string + 1,
3955 flags, bfd_und_section_ptr, 0,
3956 NULL, FALSE, FALSE, &bh))
3959 fdh = (struct ppc_link_hash_entry *) bh;
3960 fdh->elf.non_elf = 0;
3962 fdh->is_func_descriptor = 1;
3969 /* Fix function descriptor symbols defined in .opd sections to be
3973 ppc64_elf_add_symbol_hook (bfd *ibfd,
3974 struct bfd_link_info *info,
3975 Elf_Internal_Sym *isym,
3977 flagword *flags ATTRIBUTE_UNUSED,
3982 && strcmp ((*sec)->name, ".opd") == 0)
3986 if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
3987 || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
3988 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
3990 /* If the symbol is a function defined in .opd, and the function
3991 code is in a discarded group, let it appear to be undefined. */
3992 if (!bfd_link_relocatable (info)
3993 && (*sec)->reloc_count != 0
3994 && opd_entry_value (*sec, *value, &code_sec, NULL,
3995 FALSE) != (bfd_vma) -1
3996 && discarded_section (code_sec))
3998 *sec = bfd_und_section_ptr;
3999 isym->st_shndx = SHN_UNDEF;
4002 else if (*sec != NULL
4003 && strcmp ((*sec)->name, ".toc") == 0
4004 && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4006 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4008 htab->params->object_in_toc = 1;
4011 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4013 if (abiversion (ibfd) == 0)
4014 set_abiversion (ibfd, 2);
4015 else if (abiversion (ibfd) == 1)
4017 _bfd_error_handler (_("symbol '%s' has invalid st_other"
4018 " for ABI version 1"), *name);
4019 bfd_set_error (bfd_error_bad_value);
4027 /* Merge non-visibility st_other attributes: local entry point. */
4030 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4031 const Elf_Internal_Sym *isym,
4032 bfd_boolean definition,
4033 bfd_boolean dynamic)
4035 if (definition && (!dynamic || !h->def_regular))
4036 h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4037 | ELF_ST_VISIBILITY (h->other));
4040 /* Hook called on merging a symbol. We use this to clear "fake" since
4041 we now have a real symbol. */
4044 ppc64_elf_merge_symbol (struct elf_link_hash_entry *h,
4045 const Elf_Internal_Sym *isym,
4046 asection **psec ATTRIBUTE_UNUSED,
4047 bfd_boolean newdef ATTRIBUTE_UNUSED,
4048 bfd_boolean olddef ATTRIBUTE_UNUSED,
4049 bfd *oldbfd ATTRIBUTE_UNUSED,
4050 const asection *oldsec ATTRIBUTE_UNUSED)
4052 ((struct ppc_link_hash_entry *) h)->fake = 0;
4053 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4054 ((struct ppc_link_hash_entry *) h)->non_zero_localentry = 1;
4058 /* This function makes an old ABI object reference to ".bar" cause the
4059 inclusion of a new ABI object archive that defines "bar".
4060 NAME is a symbol defined in an archive. Return a symbol in the hash
4061 table that might be satisfied by the archive symbols. */
4063 static struct elf_link_hash_entry *
4064 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4065 struct bfd_link_info *info,
4068 struct elf_link_hash_entry *h;
4072 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4074 /* Don't return this sym if it is a fake function descriptor
4075 created by add_symbol_adjust. */
4076 && !((struct ppc_link_hash_entry *) h)->fake)
4082 len = strlen (name);
4083 dot_name = bfd_alloc (abfd, len + 2);
4084 if (dot_name == NULL)
4085 return (struct elf_link_hash_entry *) -1;
4087 memcpy (dot_name + 1, name, len + 1);
4088 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4089 bfd_release (abfd, dot_name);
4093 /* This function satisfies all old ABI object references to ".bar" if a
4094 new ABI object defines "bar". Well, at least, undefined dot symbols
4095 are made weak. This stops later archive searches from including an
4096 object if we already have a function descriptor definition. It also
4097 prevents the linker complaining about undefined symbols.
4098 We also check and correct mismatched symbol visibility here. The
4099 most restrictive visibility of the function descriptor and the
4100 function entry symbol is used. */
4103 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4105 struct ppc_link_hash_table *htab;
4106 struct ppc_link_hash_entry *fdh;
4108 if (eh->elf.root.type == bfd_link_hash_warning)
4109 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4111 if (eh->elf.root.type == bfd_link_hash_indirect)
4114 if (eh->elf.root.root.string[0] != '.')
4117 htab = ppc_hash_table (info);
4121 fdh = lookup_fdh (eh, htab);
4123 && !bfd_link_relocatable (info)
4124 && (eh->elf.root.type == bfd_link_hash_undefined
4125 || eh->elf.root.type == bfd_link_hash_undefweak)
4126 && eh->elf.ref_regular)
4128 /* Make an undefined function descriptor sym, in order to
4129 pull in an --as-needed shared lib. Archives are handled
4131 fdh = make_fdh (info, eh);
4138 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4139 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4141 /* Make both descriptor and entry symbol have the most
4142 constraining visibility of either symbol. */
4143 if (entry_vis < descr_vis)
4144 fdh->elf.other += entry_vis - descr_vis;
4145 else if (entry_vis > descr_vis)
4146 eh->elf.other += descr_vis - entry_vis;
4148 /* Propagate reference flags from entry symbol to function
4149 descriptor symbol. */
4150 fdh->elf.root.non_ir_ref_regular |= eh->elf.root.non_ir_ref_regular;
4151 fdh->elf.root.non_ir_ref_dynamic |= eh->elf.root.non_ir_ref_dynamic;
4152 fdh->elf.ref_regular |= eh->elf.ref_regular;
4153 fdh->elf.ref_regular_nonweak |= eh->elf.ref_regular_nonweak;
4155 if (!fdh->elf.forced_local
4156 && fdh->elf.dynindx == -1
4157 && fdh->elf.versioned != versioned_hidden
4158 && (bfd_link_dll (info)
4159 || fdh->elf.def_dynamic
4160 || fdh->elf.ref_dynamic)
4161 && (eh->elf.ref_regular
4162 || eh->elf.def_regular))
4164 if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
4172 /* Set up opd section info and abiversion for IBFD, and process list
4173 of dot-symbols we made in link_hash_newfunc. */
4176 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
4178 struct ppc_link_hash_table *htab;
4179 struct ppc_link_hash_entry **p, *eh;
4180 asection *opd = bfd_get_section_by_name (ibfd, ".opd");
4182 if (opd != NULL && opd->size != 0)
4184 BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
4185 ppc64_elf_section_data (opd)->sec_type = sec_opd;
4187 if (abiversion (ibfd) == 0)
4188 set_abiversion (ibfd, 1);
4189 else if (abiversion (ibfd) >= 2)
4191 /* xgettext:c-format */
4192 _bfd_error_handler (_("%pB .opd not allowed in ABI version %d"),
4193 ibfd, abiversion (ibfd));
4194 bfd_set_error (bfd_error_bad_value);
4199 if (is_ppc64_elf (info->output_bfd))
4201 /* For input files without an explicit abiversion in e_flags
4202 we should have flagged any with symbol st_other bits set
4203 as ELFv1 and above flagged those with .opd as ELFv2.
4204 Set the output abiversion if not yet set, and for any input
4205 still ambiguous, take its abiversion from the output.
4206 Differences in ABI are reported later. */
4207 if (abiversion (info->output_bfd) == 0)
4208 set_abiversion (info->output_bfd, abiversion (ibfd));
4209 else if (abiversion (ibfd) == 0)
4210 set_abiversion (ibfd, abiversion (info->output_bfd));
4213 htab = ppc_hash_table (info);
4217 if (opd != NULL && opd->size != 0
4218 && (ibfd->flags & DYNAMIC) == 0
4219 && (opd->flags & SEC_RELOC) != 0
4220 && opd->reloc_count != 0
4221 && !bfd_is_abs_section (opd->output_section)
4222 && info->gc_sections)
4224 /* Garbage collection needs some extra help with .opd sections.
4225 We don't want to necessarily keep everything referenced by
4226 relocs in .opd, as that would keep all functions. Instead,
4227 if we reference an .opd symbol (a function descriptor), we
4228 want to keep the function code symbol's section. This is
4229 easy for global symbols, but for local syms we need to keep
4230 information about the associated function section. */
4232 asection **opd_sym_map;
4233 Elf_Internal_Shdr *symtab_hdr;
4234 Elf_Internal_Rela *relocs, *rel_end, *rel;
4236 amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
4237 opd_sym_map = bfd_zalloc (ibfd, amt);
4238 if (opd_sym_map == NULL)
4240 ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
4241 relocs = _bfd_elf_link_read_relocs (ibfd, opd, NULL, NULL,
4245 symtab_hdr = &elf_symtab_hdr (ibfd);
4246 rel_end = relocs + opd->reloc_count - 1;
4247 for (rel = relocs; rel < rel_end; rel++)
4249 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
4250 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
4252 if (r_type == R_PPC64_ADDR64
4253 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC
4254 && r_symndx < symtab_hdr->sh_info)
4256 Elf_Internal_Sym *isym;
4259 isym = bfd_sym_from_r_symndx (&htab->sym_cache, ibfd, r_symndx);
4262 if (elf_section_data (opd)->relocs != relocs)
4267 s = bfd_section_from_elf_index (ibfd, isym->st_shndx);
4268 if (s != NULL && s != opd)
4269 opd_sym_map[OPD_NDX (rel->r_offset)] = s;
4272 if (elf_section_data (opd)->relocs != relocs)
4276 p = &htab->dot_syms;
4277 while ((eh = *p) != NULL)
4280 if (&eh->elf == htab->elf.hgot)
4282 else if (htab->elf.hgot == NULL
4283 && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
4284 htab->elf.hgot = &eh->elf;
4285 else if (abiversion (ibfd) <= 1)
4287 htab->need_func_desc_adj = 1;
4288 if (!add_symbol_adjust (eh, info))
4291 p = &eh->u.next_dot_sym;
4296 /* Undo hash table changes when an --as-needed input file is determined
4297 not to be needed. */
4300 ppc64_elf_notice_as_needed (bfd *ibfd,
4301 struct bfd_link_info *info,
4302 enum notice_asneeded_action act)
4304 if (act == notice_not_needed)
4306 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4311 htab->dot_syms = NULL;
4313 return _bfd_elf_notice_as_needed (ibfd, info, act);
4316 /* If --just-symbols against a final linked binary, then assume we need
4317 toc adjusting stubs when calling functions defined there. */
4320 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
4322 if ((sec->flags & SEC_CODE) != 0
4323 && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
4324 && is_ppc64_elf (sec->owner))
4326 if (abiversion (sec->owner) >= 2
4327 || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
4328 sec->has_toc_reloc = 1;
4330 _bfd_elf_link_just_syms (sec, info);
4333 static struct plt_entry **
4334 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
4335 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
4337 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
4338 struct plt_entry **local_plt;
4339 unsigned char *local_got_tls_masks;
4341 if (local_got_ents == NULL)
4343 bfd_size_type size = symtab_hdr->sh_info;
4345 size *= (sizeof (*local_got_ents)
4346 + sizeof (*local_plt)
4347 + sizeof (*local_got_tls_masks));
4348 local_got_ents = bfd_zalloc (abfd, size);
4349 if (local_got_ents == NULL)
4351 elf_local_got_ents (abfd) = local_got_ents;
4354 if ((tls_type & (NON_GOT | TLS_EXPLICIT)) == 0)
4356 struct got_entry *ent;
4358 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
4359 if (ent->addend == r_addend
4360 && ent->owner == abfd
4361 && ent->tls_type == tls_type)
4365 bfd_size_type amt = sizeof (*ent);
4366 ent = bfd_alloc (abfd, amt);
4369 ent->next = local_got_ents[r_symndx];
4370 ent->addend = r_addend;
4372 ent->tls_type = tls_type;
4373 ent->is_indirect = FALSE;
4374 ent->got.refcount = 0;
4375 local_got_ents[r_symndx] = ent;
4377 ent->got.refcount += 1;
4380 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
4381 local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
4382 local_got_tls_masks[r_symndx] |= tls_type & 0xff;
4384 return local_plt + r_symndx;
4388 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
4390 struct plt_entry *ent;
4392 for (ent = *plist; ent != NULL; ent = ent->next)
4393 if (ent->addend == addend)
4397 bfd_size_type amt = sizeof (*ent);
4398 ent = bfd_alloc (abfd, amt);
4402 ent->addend = addend;
4403 ent->plt.refcount = 0;
4406 ent->plt.refcount += 1;
4411 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
4413 return (r_type == R_PPC64_REL24
4414 || r_type == R_PPC64_REL24_NOTOC
4415 || r_type == R_PPC64_REL14
4416 || r_type == R_PPC64_REL14_BRTAKEN
4417 || r_type == R_PPC64_REL14_BRNTAKEN
4418 || r_type == R_PPC64_ADDR24
4419 || r_type == R_PPC64_ADDR14
4420 || r_type == R_PPC64_ADDR14_BRTAKEN
4421 || r_type == R_PPC64_ADDR14_BRNTAKEN
4422 || r_type == R_PPC64_PLTCALL
4423 || r_type == R_PPC64_PLTCALL_NOTOC);
4426 /* Relocs on inline plt call sequence insns prior to the call. */
4429 is_plt_seq_reloc (enum elf_ppc64_reloc_type r_type)
4431 return (r_type == R_PPC64_PLT16_HA
4432 || r_type == R_PPC64_PLT16_HI
4433 || r_type == R_PPC64_PLT16_LO
4434 || r_type == R_PPC64_PLT16_LO_DS
4435 || r_type == R_PPC64_PLT_PCREL34
4436 || r_type == R_PPC64_PLT_PCREL34_NOTOC
4437 || r_type == R_PPC64_PLTSEQ
4438 || r_type == R_PPC64_PLTSEQ_NOTOC);
4441 /* Look through the relocs for a section during the first phase, and
4442 calculate needed space in the global offset table, procedure
4443 linkage table, and dynamic reloc sections. */
4446 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
4447 asection *sec, const Elf_Internal_Rela *relocs)
4449 struct ppc_link_hash_table *htab;
4450 Elf_Internal_Shdr *symtab_hdr;
4451 struct elf_link_hash_entry **sym_hashes;
4452 const Elf_Internal_Rela *rel;
4453 const Elf_Internal_Rela *rel_end;
4455 struct elf_link_hash_entry *tga, *dottga;
4458 if (bfd_link_relocatable (info))
4461 /* Don't do anything special with non-loaded, non-alloced sections.
4462 In particular, any relocs in such sections should not affect GOT
4463 and PLT reference counting (ie. we don't allow them to create GOT
4464 or PLT entries), there's no possibility or desire to optimize TLS
4465 relocs, and there's not much point in propagating relocs to shared
4466 libs that the dynamic linker won't relocate. */
4467 if ((sec->flags & SEC_ALLOC) == 0)
4470 BFD_ASSERT (is_ppc64_elf (abfd));
4472 htab = ppc_hash_table (info);
4476 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
4477 FALSE, FALSE, TRUE);
4478 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
4479 FALSE, FALSE, TRUE);
4480 symtab_hdr = &elf_symtab_hdr (abfd);
4481 sym_hashes = elf_sym_hashes (abfd);
4483 is_opd = ppc64_elf_section_data (sec)->sec_type == sec_opd;
4484 rel_end = relocs + sec->reloc_count;
4485 for (rel = relocs; rel < rel_end; rel++)
4487 unsigned long r_symndx;
4488 struct elf_link_hash_entry *h;
4489 enum elf_ppc64_reloc_type r_type;
4491 struct _ppc64_elf_section_data *ppc64_sec;
4492 struct plt_entry **ifunc, **plt_list;
4495 r_symndx = ELF64_R_SYM (rel->r_info);
4496 if (r_symndx < symtab_hdr->sh_info)
4500 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4501 h = elf_follow_link (h);
4503 if (h == htab->elf.hgot)
4504 sec->has_toc_reloc = 1;
4509 r_type = ELF64_R_TYPE (rel->r_info);
4513 case R_PPC64_D34_LO:
4514 case R_PPC64_D34_HI30:
4515 case R_PPC64_D34_HA30:
4517 htab->powerxx_stubs = 1;
4520 /* Somewhat foolishly, because the ABIs don't specifically
4521 allow it, ppc64 gas and ld support GOT and PLT relocs
4522 with non-zero addends where the addend results in
4523 sym+addend being stored in the GOT or PLT entry. This
4524 can't be supported for pcrel relocs because the addend is
4525 used to specify the pcrel offset. */
4526 sym_addend = rel->r_addend;
4529 case R_PPC64_PCREL34:
4530 case R_PPC64_GOT_PCREL34:
4531 case R_PPC64_PLT_PCREL34:
4532 case R_PPC64_PLT_PCREL34_NOTOC:
4533 case R_PPC64_PCREL28:
4534 htab->powerxx_stubs = 1;
4540 if (h->type == STT_GNU_IFUNC)
4543 ifunc = &h->plt.plist;
4548 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
4553 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4555 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
4557 NON_GOT | PLT_IFUNC);
4567 /* These special tls relocs tie a call to __tls_get_addr with
4568 its parameter symbol. */
4570 ((struct ppc_link_hash_entry *) h)->tls_mask |= TLS_TLS | TLS_MARK;
4572 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
4574 NON_GOT | TLS_TLS | TLS_MARK))
4576 sec->has_tls_reloc = 1;
4579 case R_PPC64_GOT_TLSLD16:
4580 case R_PPC64_GOT_TLSLD16_LO:
4581 case R_PPC64_GOT_TLSLD16_HI:
4582 case R_PPC64_GOT_TLSLD16_HA:
4583 tls_type = TLS_TLS | TLS_LD;
4586 case R_PPC64_GOT_TLSGD16:
4587 case R_PPC64_GOT_TLSGD16_LO:
4588 case R_PPC64_GOT_TLSGD16_HI:
4589 case R_PPC64_GOT_TLSGD16_HA:
4590 tls_type = TLS_TLS | TLS_GD;
4593 case R_PPC64_GOT_TPREL16_DS:
4594 case R_PPC64_GOT_TPREL16_LO_DS:
4595 case R_PPC64_GOT_TPREL16_HI:
4596 case R_PPC64_GOT_TPREL16_HA:
4597 if (bfd_link_dll (info))
4598 info->flags |= DF_STATIC_TLS;
4599 tls_type = TLS_TLS | TLS_TPREL;
4602 case R_PPC64_GOT_DTPREL16_DS:
4603 case R_PPC64_GOT_DTPREL16_LO_DS:
4604 case R_PPC64_GOT_DTPREL16_HI:
4605 case R_PPC64_GOT_DTPREL16_HA:
4606 tls_type = TLS_TLS | TLS_DTPREL;
4608 sec->has_tls_reloc = 1;
4611 case R_PPC64_GOT16_HA:
4612 case R_PPC64_GOT16_LO_DS:
4613 case R_PPC64_GOT_PCREL34:
4614 ppc64_elf_tdata (abfd)->has_gotrel = 1;
4615 ppc64_elf_section_data (sec)->has_gotrel = 1;
4618 case R_PPC64_GOT16_DS:
4620 case R_PPC64_GOT16_HI:
4621 case R_PPC64_GOT16_LO:
4623 /* This symbol requires a global offset table entry. */
4624 sec->has_toc_reloc = 1;
4625 if (r_type == R_PPC64_GOT_TLSLD16
4626 || r_type == R_PPC64_GOT_TLSGD16
4627 || r_type == R_PPC64_GOT_TPREL16_DS
4628 || r_type == R_PPC64_GOT_DTPREL16_DS
4629 || r_type == R_PPC64_GOT16
4630 || r_type == R_PPC64_GOT16_DS)
4632 htab->do_multi_toc = 1;
4633 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
4636 if (ppc64_elf_tdata (abfd)->got == NULL
4637 && !create_got_section (abfd, info))
4642 struct ppc_link_hash_entry *eh;
4643 struct got_entry *ent;
4645 eh = (struct ppc_link_hash_entry *) h;
4646 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
4647 if (ent->addend == sym_addend
4648 && ent->owner == abfd
4649 && ent->tls_type == tls_type)
4653 bfd_size_type amt = sizeof (*ent);
4654 ent = bfd_alloc (abfd, amt);
4657 ent->next = eh->elf.got.glist;
4658 ent->addend = sym_addend;
4660 ent->tls_type = tls_type;
4661 ent->is_indirect = FALSE;
4662 ent->got.refcount = 0;
4663 eh->elf.got.glist = ent;
4665 ent->got.refcount += 1;
4666 eh->tls_mask |= tls_type;
4669 /* This is a global offset table entry for a local symbol. */
4670 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
4671 sym_addend, tls_type))
4674 /* We may also need a plt entry if the symbol turns out to be
4676 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
4678 if (!update_plt_info (abfd, &h->plt.plist, sym_addend))
4683 case R_PPC64_PLT16_HA:
4684 case R_PPC64_PLT16_HI:
4685 case R_PPC64_PLT16_LO:
4686 case R_PPC64_PLT16_LO_DS:
4687 case R_PPC64_PLT_PCREL34:
4688 case R_PPC64_PLT_PCREL34_NOTOC:
4691 /* This symbol requires a procedure linkage table entry. */
4696 if (h->root.root.string[0] == '.'
4697 && h->root.root.string[1] != '\0')
4698 ((struct ppc_link_hash_entry *) h)->is_func = 1;
4699 ((struct ppc_link_hash_entry *) h)->tls_mask |= PLT_KEEP;
4700 plt_list = &h->plt.plist;
4702 if (plt_list == NULL)
4703 plt_list = update_local_sym_info (abfd, symtab_hdr, r_symndx,
4705 NON_GOT | PLT_KEEP);
4706 if (!update_plt_info (abfd, plt_list, sym_addend))
4710 /* The following relocations don't need to propagate the
4711 relocation if linking a shared object since they are
4712 section relative. */
4713 case R_PPC64_SECTOFF:
4714 case R_PPC64_SECTOFF_LO:
4715 case R_PPC64_SECTOFF_HI:
4716 case R_PPC64_SECTOFF_HA:
4717 case R_PPC64_SECTOFF_DS:
4718 case R_PPC64_SECTOFF_LO_DS:
4719 case R_PPC64_DTPREL16:
4720 case R_PPC64_DTPREL16_LO:
4721 case R_PPC64_DTPREL16_HI:
4722 case R_PPC64_DTPREL16_HA:
4723 case R_PPC64_DTPREL16_DS:
4724 case R_PPC64_DTPREL16_LO_DS:
4725 case R_PPC64_DTPREL16_HIGH:
4726 case R_PPC64_DTPREL16_HIGHA:
4727 case R_PPC64_DTPREL16_HIGHER:
4728 case R_PPC64_DTPREL16_HIGHERA:
4729 case R_PPC64_DTPREL16_HIGHEST:
4730 case R_PPC64_DTPREL16_HIGHESTA:
4735 case R_PPC64_REL16_LO:
4736 case R_PPC64_REL16_HI:
4737 case R_PPC64_REL16_HA:
4738 case R_PPC64_REL16_HIGH:
4739 case R_PPC64_REL16_HIGHA:
4740 case R_PPC64_REL16_HIGHER:
4741 case R_PPC64_REL16_HIGHERA:
4742 case R_PPC64_REL16_HIGHEST:
4743 case R_PPC64_REL16_HIGHESTA:
4744 case R_PPC64_REL16_HIGHER34:
4745 case R_PPC64_REL16_HIGHERA34:
4746 case R_PPC64_REL16_HIGHEST34:
4747 case R_PPC64_REL16_HIGHESTA34:
4748 case R_PPC64_REL16DX_HA:
4751 /* Not supported as a dynamic relocation. */
4752 case R_PPC64_ADDR64_LOCAL:
4753 if (bfd_link_pic (info))
4755 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
4757 /* xgettext:c-format */
4758 info->callbacks->einfo (_("%H: %s reloc unsupported "
4759 "in shared libraries and PIEs\n"),
4760 abfd, sec, rel->r_offset,
4761 ppc64_elf_howto_table[r_type]->name);
4762 bfd_set_error (bfd_error_bad_value);
4768 case R_PPC64_TOC16_DS:
4769 htab->do_multi_toc = 1;
4770 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
4772 case R_PPC64_TOC16_LO:
4773 case R_PPC64_TOC16_HI:
4774 case R_PPC64_TOC16_HA:
4775 case R_PPC64_TOC16_LO_DS:
4776 sec->has_toc_reloc = 1;
4783 /* This relocation describes the C++ object vtable hierarchy.
4784 Reconstruct it for later use during GC. */
4785 case R_PPC64_GNU_VTINHERIT:
4786 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
4790 /* This relocation describes which C++ vtable entries are actually
4791 used. Record for later use during GC. */
4792 case R_PPC64_GNU_VTENTRY:
4793 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
4798 case R_PPC64_REL14_BRTAKEN:
4799 case R_PPC64_REL14_BRNTAKEN:
4801 asection *dest = NULL;
4803 /* Heuristic: If jumping outside our section, chances are
4804 we are going to need a stub. */
4807 /* If the sym is weak it may be overridden later, so
4808 don't assume we know where a weak sym lives. */
4809 if (h->root.type == bfd_link_hash_defined)
4810 dest = h->root.u.def.section;
4814 Elf_Internal_Sym *isym;
4816 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
4821 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
4825 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
4829 case R_PPC64_PLTCALL:
4830 case R_PPC64_PLTCALL_NOTOC:
4831 ppc64_elf_section_data (sec)->has_pltcall = 1;
4835 case R_PPC64_REL24_NOTOC:
4841 if (h->root.root.string[0] == '.'
4842 && h->root.root.string[1] != '\0')
4843 ((struct ppc_link_hash_entry *) h)->is_func = 1;
4845 if (h == tga || h == dottga)
4847 sec->has_tls_reloc = 1;
4849 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
4850 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
4851 /* We have a new-style __tls_get_addr call with
4855 /* Mark this section as having an old-style call. */
4856 sec->has_tls_get_addr_call = 1;
4858 plt_list = &h->plt.plist;
4861 /* We may need a .plt entry if the function this reloc
4862 refers to is in a shared lib. */
4864 && !update_plt_info (abfd, plt_list, sym_addend))
4868 case R_PPC64_ADDR14:
4869 case R_PPC64_ADDR14_BRNTAKEN:
4870 case R_PPC64_ADDR14_BRTAKEN:
4871 case R_PPC64_ADDR24:
4874 case R_PPC64_TPREL64:
4875 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
4876 if (bfd_link_dll (info))
4877 info->flags |= DF_STATIC_TLS;
4880 case R_PPC64_DTPMOD64:
4881 if (rel + 1 < rel_end
4882 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
4883 && rel[1].r_offset == rel->r_offset + 8)
4884 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
4886 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
4889 case R_PPC64_DTPREL64:
4890 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
4892 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
4893 && rel[-1].r_offset == rel->r_offset - 8)
4894 /* This is the second reloc of a dtpmod, dtprel pair.
4895 Don't mark with TLS_DTPREL. */
4899 sec->has_tls_reloc = 1;
4902 struct ppc_link_hash_entry *eh;
4903 eh = (struct ppc_link_hash_entry *) h;
4904 eh->tls_mask |= tls_type & 0xff;
4907 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
4908 sym_addend, tls_type))
4911 ppc64_sec = ppc64_elf_section_data (sec);
4912 if (ppc64_sec->sec_type != sec_toc)
4916 /* One extra to simplify get_tls_mask. */
4917 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
4918 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
4919 if (ppc64_sec->u.toc.symndx == NULL)
4921 amt = sec->size * sizeof (bfd_vma) / 8;
4922 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
4923 if (ppc64_sec->u.toc.add == NULL)
4925 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
4926 ppc64_sec->sec_type = sec_toc;
4928 BFD_ASSERT (rel->r_offset % 8 == 0);
4929 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
4930 ppc64_sec->u.toc.add[rel->r_offset / 8] = sym_addend;
4932 /* Mark the second slot of a GD or LD entry.
4933 -1 to indicate GD and -2 to indicate LD. */
4934 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
4935 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
4936 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
4937 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
4940 case R_PPC64_TPREL16:
4941 case R_PPC64_TPREL16_LO:
4942 case R_PPC64_TPREL16_HI:
4943 case R_PPC64_TPREL16_HA:
4944 case R_PPC64_TPREL16_DS:
4945 case R_PPC64_TPREL16_LO_DS:
4946 case R_PPC64_TPREL16_HIGH:
4947 case R_PPC64_TPREL16_HIGHA:
4948 case R_PPC64_TPREL16_HIGHER:
4949 case R_PPC64_TPREL16_HIGHERA:
4950 case R_PPC64_TPREL16_HIGHEST:
4951 case R_PPC64_TPREL16_HIGHESTA:
4952 if (bfd_link_dll (info))
4953 info->flags |= DF_STATIC_TLS;
4956 case R_PPC64_ADDR64:
4958 && rel + 1 < rel_end
4959 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
4962 ((struct ppc_link_hash_entry *) h)->is_func = 1;
4966 case R_PPC64_ADDR16:
4967 case R_PPC64_ADDR16_DS:
4968 case R_PPC64_ADDR16_HA:
4969 case R_PPC64_ADDR16_HI:
4970 case R_PPC64_ADDR16_HIGH:
4971 case R_PPC64_ADDR16_HIGHA:
4972 case R_PPC64_ADDR16_HIGHER:
4973 case R_PPC64_ADDR16_HIGHERA:
4974 case R_PPC64_ADDR16_HIGHEST:
4975 case R_PPC64_ADDR16_HIGHESTA:
4976 case R_PPC64_ADDR16_LO:
4977 case R_PPC64_ADDR16_LO_DS:
4979 case R_PPC64_D34_LO:
4980 case R_PPC64_D34_HI30:
4981 case R_PPC64_D34_HA30:
4982 case R_PPC64_ADDR16_HIGHER34:
4983 case R_PPC64_ADDR16_HIGHERA34:
4984 case R_PPC64_ADDR16_HIGHEST34:
4985 case R_PPC64_ADDR16_HIGHESTA34:
4987 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
4988 && rel->r_addend == 0)
4990 /* We may need a .plt entry if this reloc refers to a
4991 function in a shared lib. */
4992 if (!update_plt_info (abfd, &h->plt.plist, 0))
4994 h->pointer_equality_needed = 1;
5001 case R_PPC64_ADDR32:
5002 case R_PPC64_UADDR16:
5003 case R_PPC64_UADDR32:
5004 case R_PPC64_UADDR64:
5006 if (h != NULL && !bfd_link_pic (info))
5007 /* We may need a copy reloc. */
5010 /* Don't propagate .opd relocs. */
5011 if (NO_OPD_RELOCS && is_opd)
5014 /* If we are creating a shared library, and this is a reloc
5015 against a global symbol, or a non PC relative reloc
5016 against a local symbol, then we need to copy the reloc
5017 into the shared library. However, if we are linking with
5018 -Bsymbolic, we do not need to copy a reloc against a
5019 global symbol which is defined in an object we are
5020 including in the link (i.e., DEF_REGULAR is set). At
5021 this point we have not seen all the input files, so it is
5022 possible that DEF_REGULAR is not set now but will be set
5023 later (it is never cleared). In case of a weak definition,
5024 DEF_REGULAR may be cleared later by a strong definition in
5025 a shared library. We account for that possibility below by
5026 storing information in the dyn_relocs field of the hash
5027 table entry. A similar situation occurs when creating
5028 shared libraries and symbol visibility changes render the
5031 If on the other hand, we are creating an executable, we
5032 may need to keep relocations for symbols satisfied by a
5033 dynamic library if we manage to avoid copy relocs for the
5036 if ((bfd_link_pic (info)
5037 && (must_be_dyn_reloc (info, r_type)
5039 && (!SYMBOLIC_BIND (info, h)
5040 || h->root.type == bfd_link_hash_defweak
5041 || !h->def_regular))))
5042 || (ELIMINATE_COPY_RELOCS
5043 && !bfd_link_pic (info)
5045 && (h->root.type == bfd_link_hash_defweak
5046 || !h->def_regular))
5047 || (!bfd_link_pic (info)
5050 /* We must copy these reloc types into the output file.
5051 Create a reloc section in dynobj and make room for
5055 sreloc = _bfd_elf_make_dynamic_reloc_section
5056 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5062 /* If this is a global symbol, we count the number of
5063 relocations we need for this symbol. */
5066 struct elf_dyn_relocs *p;
5067 struct elf_dyn_relocs **head;
5069 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5071 if (p == NULL || p->sec != sec)
5073 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5083 if (!must_be_dyn_reloc (info, r_type))
5088 /* Track dynamic relocs needed for local syms too.
5089 We really need local syms available to do this
5091 struct ppc_dyn_relocs *p;
5092 struct ppc_dyn_relocs **head;
5093 bfd_boolean is_ifunc;
5096 Elf_Internal_Sym *isym;
5098 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5103 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5107 vpp = &elf_section_data (s)->local_dynrel;
5108 head = (struct ppc_dyn_relocs **) vpp;
5109 is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5111 if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5113 if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5115 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5121 p->ifunc = is_ifunc;
5137 /* Merge backend specific data from an object file to the output
5138 object file when linking. */
5141 ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
5143 bfd *obfd = info->output_bfd;
5144 unsigned long iflags, oflags;
5146 if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5149 if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5152 if (!_bfd_generic_verify_endian_match (ibfd, info))
5155 iflags = elf_elfheader (ibfd)->e_flags;
5156 oflags = elf_elfheader (obfd)->e_flags;
5158 if (iflags & ~EF_PPC64_ABI)
5161 /* xgettext:c-format */
5162 (_("%pB uses unknown e_flags 0x%lx"), ibfd, iflags);
5163 bfd_set_error (bfd_error_bad_value);
5166 else if (iflags != oflags && iflags != 0)
5169 /* xgettext:c-format */
5170 (_("%pB: ABI version %ld is not compatible with ABI version %ld output"),
5171 ibfd, iflags, oflags);
5172 bfd_set_error (bfd_error_bad_value);
5176 if (!_bfd_elf_ppc_merge_fp_attributes (ibfd, info))
5179 /* Merge Tag_compatibility attributes and any common GNU ones. */
5180 return _bfd_elf_merge_object_attributes (ibfd, info);
5184 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5186 /* Print normal ELF private data. */
5187 _bfd_elf_print_private_bfd_data (abfd, ptr);
5189 if (elf_elfheader (abfd)->e_flags != 0)
5193 fprintf (file, _("private flags = 0x%lx:"),
5194 elf_elfheader (abfd)->e_flags);
5196 if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
5197 fprintf (file, _(" [abiv%ld]"),
5198 elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
5205 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
5206 of the code entry point, and its section, which must be in the same
5207 object as OPD_SEC. Returns (bfd_vma) -1 on error. */
5210 opd_entry_value (asection *opd_sec,
5212 asection **code_sec,
5214 bfd_boolean in_code_sec)
5216 bfd *opd_bfd = opd_sec->owner;
5217 Elf_Internal_Rela *relocs;
5218 Elf_Internal_Rela *lo, *hi, *look;
5221 /* No relocs implies we are linking a --just-symbols object, or looking
5222 at a final linked executable with addr2line or somesuch. */
5223 if (opd_sec->reloc_count == 0)
5225 bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
5227 if (contents == NULL)
5229 if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
5230 return (bfd_vma) -1;
5231 ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
5234 /* PR 17512: file: 64b9dfbb. */
5235 if (offset + 7 >= opd_sec->size || offset + 7 < offset)
5236 return (bfd_vma) -1;
5238 val = bfd_get_64 (opd_bfd, contents + offset);
5239 if (code_sec != NULL)
5241 asection *sec, *likely = NULL;
5247 && val < sec->vma + sec->size)
5253 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5255 && (sec->flags & SEC_LOAD) != 0
5256 && (sec->flags & SEC_ALLOC) != 0)
5261 if (code_off != NULL)
5262 *code_off = val - likely->vma;
5268 BFD_ASSERT (is_ppc64_elf (opd_bfd));
5270 relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
5272 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5273 /* PR 17512: file: df8e1fd6. */
5275 return (bfd_vma) -1;
5277 /* Go find the opd reloc at the sym address. */
5279 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5283 look = lo + (hi - lo) / 2;
5284 if (look->r_offset < offset)
5286 else if (look->r_offset > offset)
5290 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5292 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5293 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5295 unsigned long symndx = ELF64_R_SYM (look->r_info);
5296 asection *sec = NULL;
5298 if (symndx >= symtab_hdr->sh_info
5299 && elf_sym_hashes (opd_bfd) != NULL)
5301 struct elf_link_hash_entry **sym_hashes;
5302 struct elf_link_hash_entry *rh;
5304 sym_hashes = elf_sym_hashes (opd_bfd);
5305 rh = sym_hashes[symndx - symtab_hdr->sh_info];
5308 rh = elf_follow_link (rh);
5309 if (rh->root.type != bfd_link_hash_defined
5310 && rh->root.type != bfd_link_hash_defweak)
5312 if (rh->root.u.def.section->owner == opd_bfd)
5314 val = rh->root.u.def.value;
5315 sec = rh->root.u.def.section;
5322 Elf_Internal_Sym *sym;
5324 if (symndx < symtab_hdr->sh_info)
5326 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5329 size_t symcnt = symtab_hdr->sh_info;
5330 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
5335 symtab_hdr->contents = (bfd_byte *) sym;
5341 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
5347 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5350 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5351 val = sym->st_value;
5354 val += look->r_addend;
5355 if (code_off != NULL)
5357 if (code_sec != NULL)
5359 if (in_code_sec && *code_sec != sec)
5364 if (sec->output_section != NULL)
5365 val += sec->output_section->vma + sec->output_offset;
5374 /* If the ELF symbol SYM might be a function in SEC, return the
5375 function size and set *CODE_OFF to the function's entry point,
5376 otherwise return zero. */
5378 static bfd_size_type
5379 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
5384 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
5385 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
5389 if (!(sym->flags & BSF_SYNTHETIC))
5390 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
5392 if (strcmp (sym->section->name, ".opd") == 0)
5394 struct _opd_sec_data *opd = get_opd_info (sym->section);
5395 bfd_vma symval = sym->value;
5398 && opd->adjust != NULL
5399 && elf_section_data (sym->section)->relocs != NULL)
5401 /* opd_entry_value will use cached relocs that have been
5402 adjusted, but with raw symbols. That means both local
5403 and global symbols need adjusting. */
5404 long adjust = opd->adjust[OPD_NDX (symval)];
5410 if (opd_entry_value (sym->section, symval,
5411 &sec, code_off, TRUE) == (bfd_vma) -1)
5413 /* An old ABI binary with dot-syms has a size of 24 on the .opd
5414 symbol. This size has nothing to do with the code size of the
5415 function, which is what we're supposed to return, but the
5416 code size isn't available without looking up the dot-sym.
5417 However, doing that would be a waste of time particularly
5418 since elf_find_function will look at the dot-sym anyway.
5419 Now, elf_find_function will keep the largest size of any
5420 function sym found at the code address of interest, so return
5421 1 here to avoid it incorrectly caching a larger function size
5422 for a small function. This does mean we return the wrong
5423 size for a new-ABI function of size 24, but all that does is
5424 disable caching for such functions. */
5430 if (sym->section != sec)
5432 *code_off = sym->value;
5439 /* Return true if symbol is a strong function defined in an ELFv2
5440 object with st_other localentry bits of zero, ie. its local entry
5441 point coincides with its global entry point. */
5444 is_elfv2_localentry0 (struct elf_link_hash_entry *h)
5447 && h->type == STT_FUNC
5448 && h->root.type == bfd_link_hash_defined
5449 && (STO_PPC64_LOCAL_MASK & h->other) == 0
5450 && !((struct ppc_link_hash_entry *) h)->non_zero_localentry
5451 && is_ppc64_elf (h->root.u.def.section->owner)
5452 && abiversion (h->root.u.def.section->owner) >= 2);
5455 /* Return true if symbol is defined in a regular object file. */
5458 is_static_defined (struct elf_link_hash_entry *h)
5460 return ((h->root.type == bfd_link_hash_defined
5461 || h->root.type == bfd_link_hash_defweak)
5462 && h->root.u.def.section != NULL
5463 && h->root.u.def.section->output_section != NULL);
5466 /* If FDH is a function descriptor symbol, return the associated code
5467 entry symbol if it is defined. Return NULL otherwise. */
5469 static struct ppc_link_hash_entry *
5470 defined_code_entry (struct ppc_link_hash_entry *fdh)
5472 if (fdh->is_func_descriptor)
5474 struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
5475 if (fh->elf.root.type == bfd_link_hash_defined
5476 || fh->elf.root.type == bfd_link_hash_defweak)
5482 /* If FH is a function code entry symbol, return the associated
5483 function descriptor symbol if it is defined. Return NULL otherwise. */
5485 static struct ppc_link_hash_entry *
5486 defined_func_desc (struct ppc_link_hash_entry *fh)
5489 && fh->oh->is_func_descriptor)
5491 struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
5492 if (fdh->elf.root.type == bfd_link_hash_defined
5493 || fdh->elf.root.type == bfd_link_hash_defweak)
5499 static bfd_boolean func_desc_adjust (struct elf_link_hash_entry *, void *);
5501 /* Garbage collect sections, after first dealing with dot-symbols. */
5504 ppc64_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
5506 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5508 if (htab != NULL && htab->need_func_desc_adj)
5510 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
5511 htab->need_func_desc_adj = 0;
5513 return bfd_elf_gc_sections (abfd, info);
5516 /* Mark all our entry sym sections, both opd and code section. */
5519 ppc64_elf_gc_keep (struct bfd_link_info *info)
5521 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5522 struct bfd_sym_chain *sym;
5527 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
5529 struct ppc_link_hash_entry *eh, *fh;
5532 eh = (struct ppc_link_hash_entry *)
5533 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
5536 if (eh->elf.root.type != bfd_link_hash_defined
5537 && eh->elf.root.type != bfd_link_hash_defweak)
5540 fh = defined_code_entry (eh);
5543 sec = fh->elf.root.u.def.section;
5544 sec->flags |= SEC_KEEP;
5546 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5547 && opd_entry_value (eh->elf.root.u.def.section,
5548 eh->elf.root.u.def.value,
5549 &sec, NULL, FALSE) != (bfd_vma) -1)
5550 sec->flags |= SEC_KEEP;
5552 sec = eh->elf.root.u.def.section;
5553 sec->flags |= SEC_KEEP;
5557 /* Mark sections containing dynamically referenced symbols. When
5558 building shared libraries, we must assume that any visible symbol is
5562 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
5564 struct bfd_link_info *info = (struct bfd_link_info *) inf;
5565 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
5566 struct ppc_link_hash_entry *fdh;
5567 struct bfd_elf_dynamic_list *d = info->dynamic_list;
5569 /* Dynamic linking info is on the func descriptor sym. */
5570 fdh = defined_func_desc (eh);
5574 if ((eh->elf.root.type == bfd_link_hash_defined
5575 || eh->elf.root.type == bfd_link_hash_defweak)
5576 && ((eh->elf.ref_dynamic && !eh->elf.forced_local)
5577 || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
5578 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
5579 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
5580 && (!bfd_link_executable (info)
5581 || info->gc_keep_exported
5582 || info->export_dynamic
5585 && (*d->match) (&d->head, NULL,
5586 eh->elf.root.root.string)))
5587 && (eh->elf.versioned >= versioned
5588 || !bfd_hide_sym_by_version (info->version_info,
5589 eh->elf.root.root.string)))))
5592 struct ppc_link_hash_entry *fh;
5594 eh->elf.root.u.def.section->flags |= SEC_KEEP;
5596 /* Function descriptor syms cause the associated
5597 function code sym section to be marked. */
5598 fh = defined_code_entry (eh);
5601 code_sec = fh->elf.root.u.def.section;
5602 code_sec->flags |= SEC_KEEP;
5604 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5605 && opd_entry_value (eh->elf.root.u.def.section,
5606 eh->elf.root.u.def.value,
5607 &code_sec, NULL, FALSE) != (bfd_vma) -1)
5608 code_sec->flags |= SEC_KEEP;
5614 /* Return the section that should be marked against GC for a given
5618 ppc64_elf_gc_mark_hook (asection *sec,
5619 struct bfd_link_info *info,
5620 Elf_Internal_Rela *rel,
5621 struct elf_link_hash_entry *h,
5622 Elf_Internal_Sym *sym)
5626 /* Syms return NULL if we're marking .opd, so we avoid marking all
5627 function sections, as all functions are referenced in .opd. */
5629 if (get_opd_info (sec) != NULL)
5634 enum elf_ppc64_reloc_type r_type;
5635 struct ppc_link_hash_entry *eh, *fh, *fdh;
5637 r_type = ELF64_R_TYPE (rel->r_info);
5640 case R_PPC64_GNU_VTINHERIT:
5641 case R_PPC64_GNU_VTENTRY:
5645 switch (h->root.type)
5647 case bfd_link_hash_defined:
5648 case bfd_link_hash_defweak:
5649 eh = (struct ppc_link_hash_entry *) h;
5650 fdh = defined_func_desc (eh);
5653 /* -mcall-aixdesc code references the dot-symbol on
5654 a call reloc. Mark the function descriptor too
5655 against garbage collection. */
5657 if (fdh->elf.is_weakalias)
5658 weakdef (&fdh->elf)->mark = 1;
5662 /* Function descriptor syms cause the associated
5663 function code sym section to be marked. */
5664 fh = defined_code_entry (eh);
5667 /* They also mark their opd section. */
5668 eh->elf.root.u.def.section->gc_mark = 1;
5670 rsec = fh->elf.root.u.def.section;
5672 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5673 && opd_entry_value (eh->elf.root.u.def.section,
5674 eh->elf.root.u.def.value,
5675 &rsec, NULL, FALSE) != (bfd_vma) -1)
5676 eh->elf.root.u.def.section->gc_mark = 1;
5678 rsec = h->root.u.def.section;
5681 case bfd_link_hash_common:
5682 rsec = h->root.u.c.p->section;
5686 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
5692 struct _opd_sec_data *opd;
5694 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
5695 opd = get_opd_info (rsec);
5696 if (opd != NULL && opd->func_sec != NULL)
5700 rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
5707 /* The maximum size of .sfpr. */
5708 #define SFPR_MAX (218*4)
5710 struct sfpr_def_parms
5712 const char name[12];
5713 unsigned char lo, hi;
5714 bfd_byte *(*write_ent) (bfd *, bfd_byte *, int);
5715 bfd_byte *(*write_tail) (bfd *, bfd_byte *, int);
5718 /* Auto-generate _save*, _rest* functions in .sfpr.
5719 If STUB_SEC is non-null, define alias symbols in STUB_SEC
5723 sfpr_define (struct bfd_link_info *info,
5724 const struct sfpr_def_parms *parm,
5727 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5729 size_t len = strlen (parm->name);
5730 bfd_boolean writing = FALSE;
5736 memcpy (sym, parm->name, len);
5739 for (i = parm->lo; i <= parm->hi; i++)
5741 struct ppc_link_hash_entry *h;
5743 sym[len + 0] = i / 10 + '0';
5744 sym[len + 1] = i % 10 + '0';
5745 h = (struct ppc_link_hash_entry *)
5746 elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
5747 if (stub_sec != NULL)
5750 && h->elf.root.type == bfd_link_hash_defined
5751 && h->elf.root.u.def.section == htab->sfpr)
5753 struct elf_link_hash_entry *s;
5755 sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
5756 s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
5759 if (s->root.type == bfd_link_hash_new
5760 || (s->root.type = bfd_link_hash_defined
5761 && s->root.u.def.section == stub_sec))
5763 s->root.type = bfd_link_hash_defined;
5764 s->root.u.def.section = stub_sec;
5765 s->root.u.def.value = (stub_sec->size - htab->sfpr->size
5766 + h->elf.root.u.def.value);
5769 s->ref_regular_nonweak = 1;
5770 s->forced_local = 1;
5772 s->root.linker_def = 1;
5780 if (!h->elf.def_regular)
5782 h->elf.root.type = bfd_link_hash_defined;
5783 h->elf.root.u.def.section = htab->sfpr;
5784 h->elf.root.u.def.value = htab->sfpr->size;
5785 h->elf.type = STT_FUNC;
5786 h->elf.def_regular = 1;
5788 _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
5790 if (htab->sfpr->contents == NULL)
5792 htab->sfpr->contents
5793 = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
5794 if (htab->sfpr->contents == NULL)
5801 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
5803 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
5805 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
5806 htab->sfpr->size = p - htab->sfpr->contents;
5814 savegpr0 (bfd *abfd, bfd_byte *p, int r)
5816 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5821 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
5823 p = savegpr0 (abfd, p, r);
5824 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
5826 bfd_put_32 (abfd, BLR, p);
5831 restgpr0 (bfd *abfd, bfd_byte *p, int r)
5833 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5838 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
5840 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
5842 p = restgpr0 (abfd, p, r);
5843 bfd_put_32 (abfd, MTLR_R0, p);
5847 p = restgpr0 (abfd, p, 30);
5848 p = restgpr0 (abfd, p, 31);
5850 bfd_put_32 (abfd, BLR, p);
5855 savegpr1 (bfd *abfd, bfd_byte *p, int r)
5857 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5862 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
5864 p = savegpr1 (abfd, p, r);
5865 bfd_put_32 (abfd, BLR, p);
5870 restgpr1 (bfd *abfd, bfd_byte *p, int r)
5872 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5877 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
5879 p = restgpr1 (abfd, p, r);
5880 bfd_put_32 (abfd, BLR, p);
5885 savefpr (bfd *abfd, bfd_byte *p, int r)
5887 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5892 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
5894 p = savefpr (abfd, p, r);
5895 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
5897 bfd_put_32 (abfd, BLR, p);
5902 restfpr (bfd *abfd, bfd_byte *p, int r)
5904 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5909 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
5911 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
5913 p = restfpr (abfd, p, r);
5914 bfd_put_32 (abfd, MTLR_R0, p);
5918 p = restfpr (abfd, p, 30);
5919 p = restfpr (abfd, p, 31);
5921 bfd_put_32 (abfd, BLR, p);
5926 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
5928 p = savefpr (abfd, p, r);
5929 bfd_put_32 (abfd, BLR, p);
5934 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
5936 p = restfpr (abfd, p, r);
5937 bfd_put_32 (abfd, BLR, p);
5942 savevr (bfd *abfd, bfd_byte *p, int r)
5944 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
5946 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
5951 savevr_tail (bfd *abfd, bfd_byte *p, int r)
5953 p = savevr (abfd, p, r);
5954 bfd_put_32 (abfd, BLR, p);
5959 restvr (bfd *abfd, bfd_byte *p, int r)
5961 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
5963 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
5968 restvr_tail (bfd *abfd, bfd_byte *p, int r)
5970 p = restvr (abfd, p, r);
5971 bfd_put_32 (abfd, BLR, p);
5975 /* Called via elf_link_hash_traverse to transfer dynamic linking
5976 information on function code symbol entries to their corresponding
5977 function descriptor symbol entries. */
5980 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
5982 struct bfd_link_info *info;
5983 struct ppc_link_hash_table *htab;
5984 struct ppc_link_hash_entry *fh;
5985 struct ppc_link_hash_entry *fdh;
5986 bfd_boolean force_local;
5988 fh = (struct ppc_link_hash_entry *) h;
5989 if (fh->elf.root.type == bfd_link_hash_indirect)
5995 if (fh->elf.root.root.string[0] != '.'
5996 || fh->elf.root.root.string[1] == '\0')
6000 htab = ppc_hash_table (info);
6004 /* Find the corresponding function descriptor symbol. */
6005 fdh = lookup_fdh (fh, htab);
6007 /* Resolve undefined references to dot-symbols as the value
6008 in the function descriptor, if we have one in a regular object.
6009 This is to satisfy cases like ".quad .foo". Calls to functions
6010 in dynamic objects are handled elsewhere. */
6011 if ((fh->elf.root.type == bfd_link_hash_undefined
6012 || fh->elf.root.type == bfd_link_hash_undefweak)
6013 && (fdh->elf.root.type == bfd_link_hash_defined
6014 || fdh->elf.root.type == bfd_link_hash_defweak)
6015 && get_opd_info (fdh->elf.root.u.def.section) != NULL
6016 && opd_entry_value (fdh->elf.root.u.def.section,
6017 fdh->elf.root.u.def.value,
6018 &fh->elf.root.u.def.section,
6019 &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6021 fh->elf.root.type = fdh->elf.root.type;
6022 fh->elf.forced_local = 1;
6023 fh->elf.def_regular = fdh->elf.def_regular;
6024 fh->elf.def_dynamic = fdh->elf.def_dynamic;
6027 if (!fh->elf.dynamic)
6029 struct plt_entry *ent;
6031 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6032 if (ent->plt.refcount > 0)
6038 /* Create a descriptor as undefined if necessary. */
6040 && !bfd_link_executable (info)
6041 && (fh->elf.root.type == bfd_link_hash_undefined
6042 || fh->elf.root.type == bfd_link_hash_undefweak))
6044 fdh = make_fdh (info, fh);
6049 /* We can't support overriding of symbols on a fake descriptor. */
6052 && (fh->elf.root.type == bfd_link_hash_defined
6053 || fh->elf.root.type == bfd_link_hash_defweak))
6054 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6056 /* Transfer dynamic linking information to the function descriptor. */
6059 fdh->elf.ref_regular |= fh->elf.ref_regular;
6060 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6061 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6062 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6063 fdh->elf.dynamic |= fh->elf.dynamic;
6064 fdh->elf.needs_plt |= (fh->elf.needs_plt
6065 || fh->elf.type == STT_FUNC
6066 || fh->elf.type == STT_GNU_IFUNC);
6067 move_plt_plist (fh, fdh);
6069 if (!fdh->elf.forced_local
6070 && fh->elf.dynindx != -1)
6071 if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6075 /* Now that the info is on the function descriptor, clear the
6076 function code sym info. Any function code syms for which we
6077 don't have a definition in a regular file, we force local.
6078 This prevents a shared library from exporting syms that have
6079 been imported from another library. Function code syms that
6080 are really in the library we must leave global to prevent the
6081 linker dragging in a definition from a static library. */
6082 force_local = (!fh->elf.def_regular
6084 || !fdh->elf.def_regular
6085 || fdh->elf.forced_local);
6086 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6091 static const struct sfpr_def_parms save_res_funcs[] =
6093 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6094 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6095 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6096 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6097 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6098 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6099 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6100 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6101 { "._savef", 14, 31, savefpr, savefpr1_tail },
6102 { "._restf", 14, 31, restfpr, restfpr1_tail },
6103 { "_savevr_", 20, 31, savevr, savevr_tail },
6104 { "_restvr_", 20, 31, restvr, restvr_tail }
6107 /* Called near the start of bfd_elf_size_dynamic_sections. We use
6108 this hook to a) provide some gcc support functions, and b) transfer
6109 dynamic linking information gathered so far on function code symbol
6110 entries, to their corresponding function descriptor symbol entries. */
6113 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6114 struct bfd_link_info *info)
6116 struct ppc_link_hash_table *htab;
6118 htab = ppc_hash_table (info);
6122 /* Provide any missing _save* and _rest* functions. */
6123 if (htab->sfpr != NULL)
6127 htab->sfpr->size = 0;
6128 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
6129 if (!sfpr_define (info, &save_res_funcs[i], NULL))
6131 if (htab->sfpr->size == 0)
6132 htab->sfpr->flags |= SEC_EXCLUDE;
6135 if (bfd_link_relocatable (info))
6138 if (htab->elf.hgot != NULL)
6140 _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
6141 /* Make .TOC. defined so as to prevent it being made dynamic.
6142 The wrong value here is fixed later in ppc64_elf_set_toc. */
6143 if (!htab->elf.hgot->def_regular
6144 || htab->elf.hgot->root.type != bfd_link_hash_defined)
6146 htab->elf.hgot->root.type = bfd_link_hash_defined;
6147 htab->elf.hgot->root.u.def.value = 0;
6148 htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
6149 htab->elf.hgot->def_regular = 1;
6150 htab->elf.hgot->root.linker_def = 1;
6152 htab->elf.hgot->type = STT_OBJECT;
6153 htab->elf.hgot->other
6154 = (htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
6157 if (htab->need_func_desc_adj)
6159 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6160 htab->need_func_desc_adj = 0;
6166 /* Find dynamic relocs for H that apply to read-only sections. */
6169 readonly_dynrelocs (struct elf_link_hash_entry *h)
6171 struct ppc_link_hash_entry *eh;
6172 struct elf_dyn_relocs *p;
6174 eh = (struct ppc_link_hash_entry *) h;
6175 for (p = eh->dyn_relocs; p != NULL; p = p->next)
6177 asection *s = p->sec->output_section;
6179 if (s != NULL && (s->flags & SEC_READONLY) != 0)
6185 /* Return true if we have dynamic relocs against H or any of its weak
6186 aliases, that apply to read-only sections. Cannot be used after
6187 size_dynamic_sections. */
6190 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
6192 struct ppc_link_hash_entry *eh;
6194 eh = (struct ppc_link_hash_entry *) h;
6197 if (readonly_dynrelocs (&eh->elf))
6199 eh = (struct ppc_link_hash_entry *) eh->elf.u.alias;
6201 while (eh != NULL && &eh->elf != h);
6206 /* Return whether EH has pc-relative dynamic relocs. */
6209 pc_dynrelocs (struct ppc_link_hash_entry *eh)
6211 struct elf_dyn_relocs *p;
6213 for (p = eh->dyn_relocs; p != NULL; p = p->next)
6214 if (p->pc_count != 0)
6219 /* Return true if a global entry stub will be created for H. Valid
6220 for ELFv2 before plt entries have been allocated. */
6223 global_entry_stub (struct elf_link_hash_entry *h)
6225 struct plt_entry *pent;
6227 if (!h->pointer_equality_needed
6231 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
6232 if (pent->plt.refcount > 0
6233 && pent->addend == 0)
6239 /* Adjust a symbol defined by a dynamic object and referenced by a
6240 regular object. The current definition is in some section of the
6241 dynamic object, but we're not including those sections. We have to
6242 change the definition to something the rest of the link can
6246 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6247 struct elf_link_hash_entry *h)
6249 struct ppc_link_hash_table *htab;
6252 htab = ppc_hash_table (info);
6256 /* Deal with function syms. */
6257 if (h->type == STT_FUNC
6258 || h->type == STT_GNU_IFUNC
6261 bfd_boolean local = (((struct ppc_link_hash_entry *) h)->save_res
6262 || SYMBOL_CALLS_LOCAL (info, h)
6263 || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h));
6264 /* Discard dyn_relocs when non-pic if we've decided that a
6265 function symbol is local and not an ifunc. We keep dynamic
6266 relocs for ifuncs when local rather than always emitting a
6267 plt call stub for them and defining the symbol on the call
6268 stub. We can't do that for ELFv1 anyway (a function symbol
6269 is defined on a descriptor, not code) and it can be faster at
6270 run-time due to not needing to bounce through a stub. The
6271 dyn_relocs for ifuncs will be applied even in a static
6273 if (!bfd_link_pic (info)
6274 && h->type != STT_GNU_IFUNC
6276 ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
6278 /* Clear procedure linkage table information for any symbol that
6279 won't need a .plt entry. */
6280 struct plt_entry *ent;
6281 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6282 if (ent->plt.refcount > 0)
6285 || (h->type != STT_GNU_IFUNC
6287 && (htab->can_convert_all_inline_plt
6288 || (((struct ppc_link_hash_entry *) h)->tls_mask
6289 & (TLS_TLS | PLT_KEEP)) != PLT_KEEP)))
6291 h->plt.plist = NULL;
6293 h->pointer_equality_needed = 0;
6295 else if (abiversion (info->output_bfd) >= 2)
6297 /* Taking a function's address in a read/write section
6298 doesn't require us to define the function symbol in the
6299 executable on a global entry stub. A dynamic reloc can
6300 be used instead. The reason we prefer a few more dynamic
6301 relocs is that calling via a global entry stub costs a
6302 few more instructions, and pointer_equality_needed causes
6303 extra work in ld.so when resolving these symbols. */
6304 if (global_entry_stub (h))
6306 if (!readonly_dynrelocs (h))
6308 h->pointer_equality_needed = 0;
6309 /* If we haven't seen a branch reloc and the symbol
6310 isn't an ifunc then we don't need a plt entry. */
6312 h->plt.plist = NULL;
6314 else if (!bfd_link_pic (info))
6315 /* We are going to be defining the function symbol on the
6316 plt stub, so no dyn_relocs needed when non-pic. */
6317 ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
6320 /* ELFv2 function symbols can't have copy relocs. */
6323 else if (!h->needs_plt
6324 && !readonly_dynrelocs (h))
6326 /* If we haven't seen a branch reloc and the symbol isn't an
6327 ifunc then we don't need a plt entry. */
6328 h->plt.plist = NULL;
6329 h->pointer_equality_needed = 0;
6334 h->plt.plist = NULL;
6336 /* If this is a weak symbol, and there is a real definition, the
6337 processor independent code will have arranged for us to see the
6338 real definition first, and we can just use the same value. */
6339 if (h->is_weakalias)
6341 struct elf_link_hash_entry *def = weakdef (h);
6342 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
6343 h->root.u.def.section = def->root.u.def.section;
6344 h->root.u.def.value = def->root.u.def.value;
6345 if (def->root.u.def.section == htab->elf.sdynbss
6346 || def->root.u.def.section == htab->elf.sdynrelro)
6347 ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
6351 /* If we are creating a shared library, we must presume that the
6352 only references to the symbol are via the global offset table.
6353 For such cases we need not do anything here; the relocations will
6354 be handled correctly by relocate_section. */
6355 if (bfd_link_pic (info))
6358 /* If there are no references to this symbol that do not use the
6359 GOT, we don't need to generate a copy reloc. */
6360 if (!h->non_got_ref)
6363 /* Don't generate a copy reloc for symbols defined in the executable. */
6364 if (!h->def_dynamic || !h->ref_regular || h->def_regular
6366 /* If -z nocopyreloc was given, don't generate them either. */
6367 || info->nocopyreloc
6369 /* If we don't find any dynamic relocs in read-only sections, then
6370 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
6371 || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
6373 /* Protected variables do not work with .dynbss. The copy in
6374 .dynbss won't be used by the shared library with the protected
6375 definition for the variable. Text relocations are preferable
6376 to an incorrect program. */
6377 || h->protected_def)
6380 if (h->plt.plist != NULL)
6382 /* We should never get here, but unfortunately there are versions
6383 of gcc out there that improperly (for this ABI) put initialized
6384 function pointers, vtable refs and suchlike in read-only
6385 sections. Allow them to proceed, but warn that this might
6386 break at runtime. */
6387 info->callbacks->einfo
6388 (_("%P: copy reloc against `%pT' requires lazy plt linking; "
6389 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
6390 h->root.root.string);
6393 /* This is a reference to a symbol defined by a dynamic object which
6394 is not a function. */
6396 /* We must allocate the symbol in our .dynbss section, which will
6397 become part of the .bss section of the executable. There will be
6398 an entry for this symbol in the .dynsym section. The dynamic
6399 object will contain position independent code, so all references
6400 from the dynamic object to this symbol will go through the global
6401 offset table. The dynamic linker will use the .dynsym entry to
6402 determine the address it must put in the global offset table, so
6403 both the dynamic object and the regular object will refer to the
6404 same memory location for the variable. */
6405 if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
6407 s = htab->elf.sdynrelro;
6408 srel = htab->elf.sreldynrelro;
6412 s = htab->elf.sdynbss;
6413 srel = htab->elf.srelbss;
6415 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
6417 /* We must generate a R_PPC64_COPY reloc to tell the dynamic
6418 linker to copy the initial value out of the dynamic object
6419 and into the runtime process image. */
6420 srel->size += sizeof (Elf64_External_Rela);
6424 /* We no longer want dyn_relocs. */
6425 ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
6426 return _bfd_elf_adjust_dynamic_copy (info, h, s);
6429 /* If given a function descriptor symbol, hide both the function code
6430 sym and the descriptor. */
6432 ppc64_elf_hide_symbol (struct bfd_link_info *info,
6433 struct elf_link_hash_entry *h,
6434 bfd_boolean force_local)
6436 struct ppc_link_hash_entry *eh;
6437 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
6439 if (ppc_hash_table (info) == NULL)
6442 eh = (struct ppc_link_hash_entry *) h;
6443 if (eh->is_func_descriptor)
6445 struct ppc_link_hash_entry *fh = eh->oh;
6450 struct elf_link_hash_table *htab = elf_hash_table (info);
6453 /* We aren't supposed to use alloca in BFD because on
6454 systems which do not have alloca the version in libiberty
6455 calls xmalloc, which might cause the program to crash
6456 when it runs out of memory. This function doesn't have a
6457 return status, so there's no way to gracefully return an
6458 error. So cheat. We know that string[-1] can be safely
6459 accessed; It's either a string in an ELF string table,
6460 or allocated in an objalloc structure. */
6462 p = eh->elf.root.root.string - 1;
6465 fh = (struct ppc_link_hash_entry *)
6466 elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
6469 /* Unfortunately, if it so happens that the string we were
6470 looking for was allocated immediately before this string,
6471 then we overwrote the string terminator. That's the only
6472 reason the lookup should fail. */
6475 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
6476 while (q >= eh->elf.root.root.string && *q == *p)
6478 if (q < eh->elf.root.root.string && *p == '.')
6479 fh = (struct ppc_link_hash_entry *)
6480 elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
6489 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6494 get_sym_h (struct elf_link_hash_entry **hp,
6495 Elf_Internal_Sym **symp,
6497 unsigned char **tls_maskp,
6498 Elf_Internal_Sym **locsymsp,
6499 unsigned long r_symndx,
6502 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
6504 if (r_symndx >= symtab_hdr->sh_info)
6506 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
6507 struct elf_link_hash_entry *h;
6509 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6510 h = elf_follow_link (h);
6518 if (symsecp != NULL)
6520 asection *symsec = NULL;
6521 if (h->root.type == bfd_link_hash_defined
6522 || h->root.type == bfd_link_hash_defweak)
6523 symsec = h->root.u.def.section;
6527 if (tls_maskp != NULL)
6529 struct ppc_link_hash_entry *eh;
6531 eh = (struct ppc_link_hash_entry *) h;
6532 *tls_maskp = &eh->tls_mask;
6537 Elf_Internal_Sym *sym;
6538 Elf_Internal_Sym *locsyms = *locsymsp;
6540 if (locsyms == NULL)
6542 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
6543 if (locsyms == NULL)
6544 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
6545 symtab_hdr->sh_info,
6546 0, NULL, NULL, NULL);
6547 if (locsyms == NULL)
6549 *locsymsp = locsyms;
6551 sym = locsyms + r_symndx;
6559 if (symsecp != NULL)
6560 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
6562 if (tls_maskp != NULL)
6564 struct got_entry **lgot_ents;
6565 unsigned char *tls_mask;
6568 lgot_ents = elf_local_got_ents (ibfd);
6569 if (lgot_ents != NULL)
6571 struct plt_entry **local_plt = (struct plt_entry **)
6572 (lgot_ents + symtab_hdr->sh_info);
6573 unsigned char *lgot_masks = (unsigned char *)
6574 (local_plt + symtab_hdr->sh_info);
6575 tls_mask = &lgot_masks[r_symndx];
6577 *tls_maskp = tls_mask;
6583 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
6584 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
6585 type suitable for optimization, and 1 otherwise. */
6588 get_tls_mask (unsigned char **tls_maskp,
6589 unsigned long *toc_symndx,
6590 bfd_vma *toc_addend,
6591 Elf_Internal_Sym **locsymsp,
6592 const Elf_Internal_Rela *rel,
6595 unsigned long r_symndx;
6597 struct elf_link_hash_entry *h;
6598 Elf_Internal_Sym *sym;
6602 r_symndx = ELF64_R_SYM (rel->r_info);
6603 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6606 if ((*tls_maskp != NULL
6607 && (**tls_maskp & TLS_TLS) != 0
6608 && **tls_maskp != (TLS_TLS | TLS_MARK))
6610 || ppc64_elf_section_data (sec) == NULL
6611 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
6614 /* Look inside a TOC section too. */
6617 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
6618 off = h->root.u.def.value;
6621 off = sym->st_value;
6622 off += rel->r_addend;
6623 BFD_ASSERT (off % 8 == 0);
6624 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
6625 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
6626 if (toc_symndx != NULL)
6627 *toc_symndx = r_symndx;
6628 if (toc_addend != NULL)
6629 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
6630 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6632 if ((h == NULL || is_static_defined (h))
6633 && (next_r == -1 || next_r == -2))
6638 /* Find (or create) an entry in the tocsave hash table. */
6640 static struct tocsave_entry *
6641 tocsave_find (struct ppc_link_hash_table *htab,
6642 enum insert_option insert,
6643 Elf_Internal_Sym **local_syms,
6644 const Elf_Internal_Rela *irela,
6647 unsigned long r_indx;
6648 struct elf_link_hash_entry *h;
6649 Elf_Internal_Sym *sym;
6650 struct tocsave_entry ent, *p;
6652 struct tocsave_entry **slot;
6654 r_indx = ELF64_R_SYM (irela->r_info);
6655 if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
6657 if (ent.sec == NULL || ent.sec->output_section == NULL)
6660 (_("%pB: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd);
6665 ent.offset = h->root.u.def.value;
6667 ent.offset = sym->st_value;
6668 ent.offset += irela->r_addend;
6670 hash = tocsave_htab_hash (&ent);
6671 slot = ((struct tocsave_entry **)
6672 htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
6678 p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
6687 /* Adjust all global syms defined in opd sections. In gcc generated
6688 code for the old ABI, these will already have been done. */
6691 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
6693 struct ppc_link_hash_entry *eh;
6695 struct _opd_sec_data *opd;
6697 if (h->root.type == bfd_link_hash_indirect)
6700 if (h->root.type != bfd_link_hash_defined
6701 && h->root.type != bfd_link_hash_defweak)
6704 eh = (struct ppc_link_hash_entry *) h;
6705 if (eh->adjust_done)
6708 sym_sec = eh->elf.root.u.def.section;
6709 opd = get_opd_info (sym_sec);
6710 if (opd != NULL && opd->adjust != NULL)
6712 long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
6715 /* This entry has been deleted. */
6716 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
6719 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
6720 if (discarded_section (dsec))
6722 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
6726 eh->elf.root.u.def.value = 0;
6727 eh->elf.root.u.def.section = dsec;
6730 eh->elf.root.u.def.value += adjust;
6731 eh->adjust_done = 1;
6736 /* Handles decrementing dynamic reloc counts for the reloc specified by
6737 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
6738 have already been determined. */
6741 dec_dynrel_count (bfd_vma r_info,
6743 struct bfd_link_info *info,
6744 Elf_Internal_Sym **local_syms,
6745 struct elf_link_hash_entry *h,
6746 Elf_Internal_Sym *sym)
6748 enum elf_ppc64_reloc_type r_type;
6749 asection *sym_sec = NULL;
6751 /* Can this reloc be dynamic? This switch, and later tests here
6752 should be kept in sync with the code in check_relocs. */
6753 r_type = ELF64_R_TYPE (r_info);
6759 case R_PPC64_TPREL16:
6760 case R_PPC64_TPREL16_LO:
6761 case R_PPC64_TPREL16_HI:
6762 case R_PPC64_TPREL16_HA:
6763 case R_PPC64_TPREL16_DS:
6764 case R_PPC64_TPREL16_LO_DS:
6765 case R_PPC64_TPREL16_HIGH:
6766 case R_PPC64_TPREL16_HIGHA:
6767 case R_PPC64_TPREL16_HIGHER:
6768 case R_PPC64_TPREL16_HIGHERA:
6769 case R_PPC64_TPREL16_HIGHEST:
6770 case R_PPC64_TPREL16_HIGHESTA:
6771 case R_PPC64_TPREL64:
6772 case R_PPC64_DTPMOD64:
6773 case R_PPC64_DTPREL64:
6774 case R_PPC64_ADDR64:
6778 case R_PPC64_ADDR14:
6779 case R_PPC64_ADDR14_BRNTAKEN:
6780 case R_PPC64_ADDR14_BRTAKEN:
6781 case R_PPC64_ADDR16:
6782 case R_PPC64_ADDR16_DS:
6783 case R_PPC64_ADDR16_HA:
6784 case R_PPC64_ADDR16_HI:
6785 case R_PPC64_ADDR16_HIGH:
6786 case R_PPC64_ADDR16_HIGHA:
6787 case R_PPC64_ADDR16_HIGHER:
6788 case R_PPC64_ADDR16_HIGHERA:
6789 case R_PPC64_ADDR16_HIGHEST:
6790 case R_PPC64_ADDR16_HIGHESTA:
6791 case R_PPC64_ADDR16_LO:
6792 case R_PPC64_ADDR16_LO_DS:
6793 case R_PPC64_ADDR24:
6794 case R_PPC64_ADDR32:
6795 case R_PPC64_UADDR16:
6796 case R_PPC64_UADDR32:
6797 case R_PPC64_UADDR64:
6800 case R_PPC64_D34_LO:
6801 case R_PPC64_D34_HI30:
6802 case R_PPC64_D34_HA30:
6803 case R_PPC64_ADDR16_HIGHER34:
6804 case R_PPC64_ADDR16_HIGHERA34:
6805 case R_PPC64_ADDR16_HIGHEST34:
6806 case R_PPC64_ADDR16_HIGHESTA34:
6811 if (local_syms != NULL)
6813 unsigned long r_symndx;
6814 bfd *ibfd = sec->owner;
6816 r_symndx = ELF64_R_SYM (r_info);
6817 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
6821 if ((bfd_link_pic (info)
6822 && (must_be_dyn_reloc (info, r_type)
6824 && (!SYMBOLIC_BIND (info, h)
6825 || h->root.type == bfd_link_hash_defweak
6826 || !h->def_regular))))
6827 || (ELIMINATE_COPY_RELOCS
6828 && !bfd_link_pic (info)
6830 && (h->root.type == bfd_link_hash_defweak
6831 || !h->def_regular)))
6838 struct elf_dyn_relocs *p;
6839 struct elf_dyn_relocs **pp;
6840 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
6842 /* elf_gc_sweep may have already removed all dyn relocs associated
6843 with local syms for a given section. Also, symbol flags are
6844 changed by elf_gc_sweep_symbol, confusing the test above. Don't
6845 report a dynreloc miscount. */
6846 if (*pp == NULL && info->gc_sections)
6849 while ((p = *pp) != NULL)
6853 if (!must_be_dyn_reloc (info, r_type))
6865 struct ppc_dyn_relocs *p;
6866 struct ppc_dyn_relocs **pp;
6868 bfd_boolean is_ifunc;
6870 if (local_syms == NULL)
6871 sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6872 if (sym_sec == NULL)
6875 vpp = &elf_section_data (sym_sec)->local_dynrel;
6876 pp = (struct ppc_dyn_relocs **) vpp;
6878 if (*pp == NULL && info->gc_sections)
6881 is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
6882 while ((p = *pp) != NULL)
6884 if (p->sec == sec && p->ifunc == is_ifunc)
6895 /* xgettext:c-format */
6896 _bfd_error_handler (_("dynreloc miscount for %pB, section %pA"),
6898 bfd_set_error (bfd_error_bad_value);
6902 /* Remove unused Official Procedure Descriptor entries. Currently we
6903 only remove those associated with functions in discarded link-once
6904 sections, or weakly defined functions that have been overridden. It
6905 would be possible to remove many more entries for statically linked
6909 ppc64_elf_edit_opd (struct bfd_link_info *info)
6912 bfd_boolean some_edited = FALSE;
6913 asection *need_pad = NULL;
6914 struct ppc_link_hash_table *htab;
6916 htab = ppc_hash_table (info);
6920 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
6923 Elf_Internal_Rela *relstart, *rel, *relend;
6924 Elf_Internal_Shdr *symtab_hdr;
6925 Elf_Internal_Sym *local_syms;
6926 struct _opd_sec_data *opd;
6927 bfd_boolean need_edit, add_aux_fields, broken;
6928 bfd_size_type cnt_16b = 0;
6930 if (!is_ppc64_elf (ibfd))
6933 sec = bfd_get_section_by_name (ibfd, ".opd");
6934 if (sec == NULL || sec->size == 0)
6937 if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
6940 if (sec->output_section == bfd_abs_section_ptr)
6943 /* Look through the section relocs. */
6944 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
6948 symtab_hdr = &elf_symtab_hdr (ibfd);
6950 /* Read the relocations. */
6951 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
6953 if (relstart == NULL)
6956 /* First run through the relocs to check they are sane, and to
6957 determine whether we need to edit this opd section. */
6961 relend = relstart + sec->reloc_count;
6962 for (rel = relstart; rel < relend; )
6964 enum elf_ppc64_reloc_type r_type;
6965 unsigned long r_symndx;
6967 struct elf_link_hash_entry *h;
6968 Elf_Internal_Sym *sym;
6971 /* .opd contains an array of 16 or 24 byte entries. We're
6972 only interested in the reloc pointing to a function entry
6974 offset = rel->r_offset;
6975 if (rel + 1 == relend
6976 || rel[1].r_offset != offset + 8)
6978 /* If someone messes with .opd alignment then after a
6979 "ld -r" we might have padding in the middle of .opd.
6980 Also, there's nothing to prevent someone putting
6981 something silly in .opd with the assembler. No .opd
6982 optimization for them! */
6985 (_("%pB: .opd is not a regular array of opd entries"), ibfd);
6990 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
6991 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
6994 /* xgettext:c-format */
6995 (_("%pB: unexpected reloc type %u in .opd section"),
7001 r_symndx = ELF64_R_SYM (rel->r_info);
7002 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7006 if (sym_sec == NULL || sym_sec->owner == NULL)
7008 const char *sym_name;
7010 sym_name = h->root.root.string;
7012 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7016 /* xgettext:c-format */
7017 (_("%pB: undefined sym `%s' in .opd section"),
7023 /* opd entries are always for functions defined in the
7024 current input bfd. If the symbol isn't defined in the
7025 input bfd, then we won't be using the function in this
7026 bfd; It must be defined in a linkonce section in another
7027 bfd, or is weak. It's also possible that we are
7028 discarding the function due to a linker script /DISCARD/,
7029 which we test for via the output_section. */
7030 if (sym_sec->owner != ibfd
7031 || sym_sec->output_section == bfd_abs_section_ptr)
7035 if (rel + 1 == relend
7036 || (rel + 2 < relend
7037 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
7042 if (sec->size == offset + 24)
7047 if (sec->size == offset + 16)
7054 else if (rel + 1 < relend
7055 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7056 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7058 if (rel[0].r_offset == offset + 16)
7060 else if (rel[0].r_offset != offset + 24)
7067 add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7069 if (!broken && (need_edit || add_aux_fields))
7071 Elf_Internal_Rela *write_rel;
7072 Elf_Internal_Shdr *rel_hdr;
7073 bfd_byte *rptr, *wptr;
7074 bfd_byte *new_contents;
7077 new_contents = NULL;
7078 amt = OPD_NDX (sec->size) * sizeof (long);
7079 opd = &ppc64_elf_section_data (sec)->u.opd;
7080 opd->adjust = bfd_zalloc (sec->owner, amt);
7081 if (opd->adjust == NULL)
7084 /* This seems a waste of time as input .opd sections are all
7085 zeros as generated by gcc, but I suppose there's no reason
7086 this will always be so. We might start putting something in
7087 the third word of .opd entries. */
7088 if ((sec->flags & SEC_IN_MEMORY) == 0)
7091 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7096 if (local_syms != NULL
7097 && symtab_hdr->contents != (unsigned char *) local_syms)
7099 if (elf_section_data (sec)->relocs != relstart)
7103 sec->contents = loc;
7104 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7107 elf_section_data (sec)->relocs = relstart;
7109 new_contents = sec->contents;
7112 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7113 if (new_contents == NULL)
7117 wptr = new_contents;
7118 rptr = sec->contents;
7119 write_rel = relstart;
7120 for (rel = relstart; rel < relend; )
7122 unsigned long r_symndx;
7124 struct elf_link_hash_entry *h;
7125 struct ppc_link_hash_entry *fdh = NULL;
7126 Elf_Internal_Sym *sym;
7128 Elf_Internal_Rela *next_rel;
7131 r_symndx = ELF64_R_SYM (rel->r_info);
7132 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7137 if (next_rel + 1 == relend
7138 || (next_rel + 2 < relend
7139 && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
7142 /* See if the .opd entry is full 24 byte or
7143 16 byte (with fd_aux entry overlapped with next
7146 if (next_rel == relend)
7148 if (sec->size == rel->r_offset + 16)
7151 else if (next_rel->r_offset == rel->r_offset + 16)
7155 && h->root.root.string[0] == '.')
7157 fdh = ((struct ppc_link_hash_entry *) h)->oh;
7160 fdh = ppc_follow_link (fdh);
7161 if (fdh->elf.root.type != bfd_link_hash_defined
7162 && fdh->elf.root.type != bfd_link_hash_defweak)
7167 skip = (sym_sec->owner != ibfd
7168 || sym_sec->output_section == bfd_abs_section_ptr);
7171 if (fdh != NULL && sym_sec->owner == ibfd)
7173 /* Arrange for the function descriptor sym
7175 fdh->elf.root.u.def.value = 0;
7176 fdh->elf.root.u.def.section = sym_sec;
7178 opd->adjust[OPD_NDX (rel->r_offset)] = -1;
7180 if (NO_OPD_RELOCS || bfd_link_relocatable (info))
7185 if (!dec_dynrel_count (rel->r_info, sec, info,
7189 if (++rel == next_rel)
7192 r_symndx = ELF64_R_SYM (rel->r_info);
7193 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7200 /* We'll be keeping this opd entry. */
7205 /* Redefine the function descriptor symbol to
7206 this location in the opd section. It is
7207 necessary to update the value here rather
7208 than using an array of adjustments as we do
7209 for local symbols, because various places
7210 in the generic ELF code use the value
7211 stored in u.def.value. */
7212 fdh->elf.root.u.def.value = wptr - new_contents;
7213 fdh->adjust_done = 1;
7216 /* Local syms are a bit tricky. We could
7217 tweak them as they can be cached, but
7218 we'd need to look through the local syms
7219 for the function descriptor sym which we
7220 don't have at the moment. So keep an
7221 array of adjustments. */
7222 adjust = (wptr - new_contents) - (rptr - sec->contents);
7223 opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
7226 memcpy (wptr, rptr, opd_ent_size);
7227 wptr += opd_ent_size;
7228 if (add_aux_fields && opd_ent_size == 16)
7230 memset (wptr, '\0', 8);
7234 /* We need to adjust any reloc offsets to point to the
7236 for ( ; rel != next_rel; ++rel)
7238 rel->r_offset += adjust;
7239 if (write_rel != rel)
7240 memcpy (write_rel, rel, sizeof (*rel));
7245 rptr += opd_ent_size;
7248 sec->size = wptr - new_contents;
7249 sec->reloc_count = write_rel - relstart;
7252 free (sec->contents);
7253 sec->contents = new_contents;
7256 /* Fudge the header size too, as this is used later in
7257 elf_bfd_final_link if we are emitting relocs. */
7258 rel_hdr = _bfd_elf_single_rel_hdr (sec);
7259 rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7262 else if (elf_section_data (sec)->relocs != relstart)
7265 if (local_syms != NULL
7266 && symtab_hdr->contents != (unsigned char *) local_syms)
7268 if (!info->keep_memory)
7271 symtab_hdr->contents = (unsigned char *) local_syms;
7276 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7278 /* If we are doing a final link and the last .opd entry is just 16 byte
7279 long, add a 8 byte padding after it. */
7280 if (need_pad != NULL && !bfd_link_relocatable (info))
7284 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7286 BFD_ASSERT (need_pad->size > 0);
7288 p = bfd_malloc (need_pad->size + 8);
7292 if (!bfd_get_section_contents (need_pad->owner, need_pad,
7293 p, 0, need_pad->size))
7296 need_pad->contents = p;
7297 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7301 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7305 need_pad->contents = p;
7308 memset (need_pad->contents + need_pad->size, 0, 8);
7309 need_pad->size += 8;
7315 /* Analyze inline PLT call relocations to see whether calls to locally
7316 defined functions can be converted to direct calls. */
7319 ppc64_elf_inline_plt (struct bfd_link_info *info)
7321 struct ppc_link_hash_table *htab;
7324 bfd_vma low_vma, high_vma, limit;
7326 htab = ppc_hash_table (info);
7330 /* A bl insn can reach -0x2000000 to 0x1fffffc. The limit is
7331 reduced somewhat to cater for possible stubs that might be added
7332 between the call and its destination. */
7333 if (htab->params->group_size < 0)
7335 limit = -htab->params->group_size;
7341 limit = htab->params->group_size;
7348 for (sec = info->output_bfd->sections; sec != NULL; sec = sec->next)
7349 if ((sec->flags & (SEC_ALLOC | SEC_CODE)) == (SEC_ALLOC | SEC_CODE))
7351 if (low_vma > sec->vma)
7353 if (high_vma < sec->vma + sec->size)
7354 high_vma = sec->vma + sec->size;
7357 /* If a "bl" can reach anywhere in local code sections, then we can
7358 convert all inline PLT sequences to direct calls when the symbol
7360 if (high_vma - low_vma < limit)
7362 htab->can_convert_all_inline_plt = 1;
7366 /* Otherwise, go looking through relocs for cases where a direct
7367 call won't reach. Mark the symbol on any such reloc to disable
7368 the optimization and keep the PLT entry as it seems likely that
7369 this will be better than creating trampolines. Note that this
7370 will disable the optimization for all inline PLT calls to a
7371 particular symbol, not just those that won't reach. The
7372 difficulty in doing a more precise optimization is that the
7373 linker needs to make a decision depending on whether a
7374 particular R_PPC64_PLTCALL insn can be turned into a direct
7375 call, for each of the R_PPC64_PLTSEQ and R_PPC64_PLT16* insns in
7376 the sequence, and there is nothing that ties those relocs
7377 together except their symbol. */
7379 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7381 Elf_Internal_Shdr *symtab_hdr;
7382 Elf_Internal_Sym *local_syms;
7384 if (!is_ppc64_elf (ibfd))
7388 symtab_hdr = &elf_symtab_hdr (ibfd);
7390 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7391 if (ppc64_elf_section_data (sec)->has_pltcall
7392 && !bfd_is_abs_section (sec->output_section))
7394 Elf_Internal_Rela *relstart, *rel, *relend;
7396 /* Read the relocations. */
7397 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7399 if (relstart == NULL)
7402 relend = relstart + sec->reloc_count;
7403 for (rel = relstart; rel < relend; )
7405 enum elf_ppc64_reloc_type r_type;
7406 unsigned long r_symndx;
7408 struct elf_link_hash_entry *h;
7409 Elf_Internal_Sym *sym;
7410 unsigned char *tls_maskp;
7412 r_type = ELF64_R_TYPE (rel->r_info);
7413 if (r_type != R_PPC64_PLTCALL
7414 && r_type != R_PPC64_PLTCALL_NOTOC)
7417 r_symndx = ELF64_R_SYM (rel->r_info);
7418 if (!get_sym_h (&h, &sym, &sym_sec, &tls_maskp, &local_syms,
7421 if (elf_section_data (sec)->relocs != relstart)
7423 if (local_syms != NULL
7424 && symtab_hdr->contents != (bfd_byte *) local_syms)
7429 if (sym_sec != NULL && sym_sec->output_section != NULL)
7433 to = h->root.u.def.value;
7436 to += (rel->r_addend
7437 + sym_sec->output_offset
7438 + sym_sec->output_section->vma);
7439 from = (rel->r_offset
7440 + sec->output_offset
7441 + sec->output_section->vma);
7442 if (to - from + limit < 2 * limit
7443 && !(r_type == R_PPC64_PLTCALL_NOTOC
7444 && (((h ? h->other : sym->st_other)
7445 & STO_PPC64_LOCAL_MASK)
7446 > 1 << STO_PPC64_LOCAL_BIT)))
7447 *tls_maskp &= ~PLT_KEEP;
7450 if (elf_section_data (sec)->relocs != relstart)
7454 if (local_syms != NULL
7455 && symtab_hdr->contents != (unsigned char *) local_syms)
7457 if (!info->keep_memory)
7460 symtab_hdr->contents = (unsigned char *) local_syms;
7467 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
7470 ppc64_elf_tls_setup (struct bfd_link_info *info)
7472 struct ppc_link_hash_table *htab;
7474 htab = ppc_hash_table (info);
7478 if (abiversion (info->output_bfd) == 1)
7481 if (htab->params->no_multi_toc)
7482 htab->do_multi_toc = 0;
7483 else if (!htab->do_multi_toc)
7484 htab->params->no_multi_toc = 1;
7486 /* Default to --no-plt-localentry, as this option can cause problems
7487 with symbol interposition. For example, glibc libpthread.so and
7488 libc.so duplicate many pthread symbols, with a fallback
7489 implementation in libc.so. In some cases the fallback does more
7490 work than the pthread implementation. __pthread_condattr_destroy
7491 is one such symbol: the libpthread.so implementation is
7492 localentry:0 while the libc.so implementation is localentry:8.
7493 An app that "cleverly" uses dlopen to only load necessary
7494 libraries at runtime may omit loading libpthread.so when not
7495 running multi-threaded, which then results in the libc.so
7496 fallback symbols being used and ld.so complaining. Now there
7497 are workarounds in ld (see non_zero_localentry) to detect the
7498 pthread situation, but that may not be the only case where
7499 --plt-localentry can cause trouble. */
7500 if (htab->params->plt_localentry0 < 0)
7501 htab->params->plt_localentry0 = 0;
7502 if (htab->params->plt_localentry0
7503 && elf_link_hash_lookup (&htab->elf, "GLIBC_2.26",
7504 FALSE, FALSE, FALSE) == NULL)
7506 (_("warning: --plt-localentry is especially dangerous without "
7507 "ld.so support to detect ABI violations"));
7509 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7510 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7511 FALSE, FALSE, TRUE));
7512 /* Move dynamic linking info to the function descriptor sym. */
7513 if (htab->tls_get_addr != NULL)
7514 func_desc_adjust (&htab->tls_get_addr->elf, info);
7515 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7516 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7517 FALSE, FALSE, TRUE));
7518 if (htab->params->tls_get_addr_opt)
7520 struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7522 opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7523 FALSE, FALSE, TRUE);
7525 func_desc_adjust (opt, info);
7526 opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7527 FALSE, FALSE, TRUE);
7529 && (opt_fd->root.type == bfd_link_hash_defined
7530 || opt_fd->root.type == bfd_link_hash_defweak))
7532 /* If glibc supports an optimized __tls_get_addr call stub,
7533 signalled by the presence of __tls_get_addr_opt, and we'll
7534 be calling __tls_get_addr via a plt call stub, then
7535 make __tls_get_addr point to __tls_get_addr_opt. */
7536 tga_fd = &htab->tls_get_addr_fd->elf;
7537 if (htab->elf.dynamic_sections_created
7539 && (tga_fd->type == STT_FUNC
7540 || tga_fd->needs_plt)
7541 && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
7542 || UNDEFWEAK_NO_DYNAMIC_RELOC (info, tga_fd)))
7544 struct plt_entry *ent;
7546 for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
7547 if (ent->plt.refcount > 0)
7551 tga_fd->root.type = bfd_link_hash_indirect;
7552 tga_fd->root.u.i.link = &opt_fd->root;
7553 ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
7555 if (opt_fd->dynindx != -1)
7557 /* Use __tls_get_addr_opt in dynamic relocations. */
7558 opt_fd->dynindx = -1;
7559 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
7560 opt_fd->dynstr_index);
7561 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
7564 htab->tls_get_addr_fd
7565 = (struct ppc_link_hash_entry *) opt_fd;
7566 tga = &htab->tls_get_addr->elf;
7567 if (opt != NULL && tga != NULL)
7569 tga->root.type = bfd_link_hash_indirect;
7570 tga->root.u.i.link = &opt->root;
7571 ppc64_elf_copy_indirect_symbol (info, opt, tga);
7573 _bfd_elf_link_hash_hide_symbol (info, opt,
7575 htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
7577 htab->tls_get_addr_fd->oh = htab->tls_get_addr;
7578 htab->tls_get_addr_fd->is_func_descriptor = 1;
7579 if (htab->tls_get_addr != NULL)
7581 htab->tls_get_addr->oh = htab->tls_get_addr_fd;
7582 htab->tls_get_addr->is_func = 1;
7587 else if (htab->params->tls_get_addr_opt < 0)
7588 htab->params->tls_get_addr_opt = 0;
7590 return _bfd_elf_tls_setup (info->output_bfd, info);
7593 /* Return TRUE iff REL is a branch reloc with a global symbol matching
7597 branch_reloc_hash_match (const bfd *ibfd,
7598 const Elf_Internal_Rela *rel,
7599 const struct ppc_link_hash_entry *hash1,
7600 const struct ppc_link_hash_entry *hash2)
7602 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7603 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
7604 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
7606 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
7608 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7609 struct elf_link_hash_entry *h;
7611 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7612 h = elf_follow_link (h);
7613 if (h == &hash1->elf || h == &hash2->elf)
7619 /* Run through all the TLS relocs looking for optimization
7620 opportunities. The linker has been hacked (see ppc64elf.em) to do
7621 a preliminary section layout so that we know the TLS segment
7622 offsets. We can't optimize earlier because some optimizations need
7623 to know the tp offset, and we need to optimize before allocating
7624 dynamic relocations. */
7627 ppc64_elf_tls_optimize (struct bfd_link_info *info)
7631 struct ppc_link_hash_table *htab;
7632 unsigned char *toc_ref;
7635 if (!bfd_link_executable (info))
7638 htab = ppc_hash_table (info);
7642 /* Make two passes over the relocs. On the first pass, mark toc
7643 entries involved with tls relocs, and check that tls relocs
7644 involved in setting up a tls_get_addr call are indeed followed by
7645 such a call. If they are not, we can't do any tls optimization.
7646 On the second pass twiddle tls_mask flags to notify
7647 relocate_section that optimization can be done, and adjust got
7648 and plt refcounts. */
7650 for (pass = 0; pass < 2; ++pass)
7651 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7653 Elf_Internal_Sym *locsyms = NULL;
7654 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
7656 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7657 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
7659 Elf_Internal_Rela *relstart, *rel, *relend;
7660 bfd_boolean found_tls_get_addr_arg = 0;
7662 /* Read the relocations. */
7663 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7665 if (relstart == NULL)
7671 relend = relstart + sec->reloc_count;
7672 for (rel = relstart; rel < relend; rel++)
7674 enum elf_ppc64_reloc_type r_type;
7675 unsigned long r_symndx;
7676 struct elf_link_hash_entry *h;
7677 Elf_Internal_Sym *sym;
7679 unsigned char *tls_mask;
7680 unsigned int tls_set, tls_clear, tls_type = 0;
7682 bfd_boolean ok_tprel, is_local;
7683 long toc_ref_index = 0;
7684 int expecting_tls_get_addr = 0;
7685 bfd_boolean ret = FALSE;
7687 r_symndx = ELF64_R_SYM (rel->r_info);
7688 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
7692 if (elf_section_data (sec)->relocs != relstart)
7694 if (toc_ref != NULL)
7697 && (elf_symtab_hdr (ibfd).contents
7698 != (unsigned char *) locsyms))
7705 if (h->root.type == bfd_link_hash_defined
7706 || h->root.type == bfd_link_hash_defweak)
7707 value = h->root.u.def.value;
7708 else if (h->root.type == bfd_link_hash_undefweak)
7712 found_tls_get_addr_arg = 0;
7717 /* Symbols referenced by TLS relocs must be of type
7718 STT_TLS. So no need for .opd local sym adjust. */
7719 value = sym->st_value;
7728 && h->root.type == bfd_link_hash_undefweak)
7730 else if (sym_sec != NULL
7731 && sym_sec->output_section != NULL)
7733 value += sym_sec->output_offset;
7734 value += sym_sec->output_section->vma;
7735 value -= htab->elf.tls_sec->vma + TP_OFFSET;
7736 ok_tprel = value + 0x80008000ULL < 1ULL << 32;
7740 r_type = ELF64_R_TYPE (rel->r_info);
7741 /* If this section has old-style __tls_get_addr calls
7742 without marker relocs, then check that each
7743 __tls_get_addr call reloc is preceded by a reloc
7744 that conceivably belongs to the __tls_get_addr arg
7745 setup insn. If we don't find matching arg setup
7746 relocs, don't do any tls optimization. */
7748 && sec->has_tls_get_addr_call
7750 && (h == &htab->tls_get_addr->elf
7751 || h == &htab->tls_get_addr_fd->elf)
7752 && !found_tls_get_addr_arg
7753 && is_branch_reloc (r_type))
7755 info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
7756 "TLS optimization disabled\n"),
7757 ibfd, sec, rel->r_offset);
7762 found_tls_get_addr_arg = 0;
7765 case R_PPC64_GOT_TLSLD16:
7766 case R_PPC64_GOT_TLSLD16_LO:
7767 expecting_tls_get_addr = 1;
7768 found_tls_get_addr_arg = 1;
7771 case R_PPC64_GOT_TLSLD16_HI:
7772 case R_PPC64_GOT_TLSLD16_HA:
7773 /* These relocs should never be against a symbol
7774 defined in a shared lib. Leave them alone if
7775 that turns out to be the case. */
7782 tls_type = TLS_TLS | TLS_LD;
7785 case R_PPC64_GOT_TLSGD16:
7786 case R_PPC64_GOT_TLSGD16_LO:
7787 expecting_tls_get_addr = 1;
7788 found_tls_get_addr_arg = 1;
7791 case R_PPC64_GOT_TLSGD16_HI:
7792 case R_PPC64_GOT_TLSGD16_HA:
7798 tls_set = TLS_TLS | TLS_GDIE;
7800 tls_type = TLS_TLS | TLS_GD;
7803 case R_PPC64_GOT_TPREL16_DS:
7804 case R_PPC64_GOT_TPREL16_LO_DS:
7805 case R_PPC64_GOT_TPREL16_HI:
7806 case R_PPC64_GOT_TPREL16_HA:
7811 tls_clear = TLS_TPREL;
7812 tls_type = TLS_TLS | TLS_TPREL;
7819 if (rel + 1 < relend
7820 && is_plt_seq_reloc (ELF64_R_TYPE (rel[1].r_info)))
7823 && (ELF64_R_TYPE (rel[1].r_info)
7825 && (ELF64_R_TYPE (rel[1].r_info)
7826 != R_PPC64_PLTSEQ_NOTOC))
7828 r_symndx = ELF64_R_SYM (rel[1].r_info);
7829 if (!get_sym_h (&h, NULL, NULL, NULL, &locsyms,
7834 struct plt_entry *ent = NULL;
7836 for (ent = h->plt.plist;
7839 if (ent->addend == rel[1].r_addend)
7843 && ent->plt.refcount > 0)
7844 ent->plt.refcount -= 1;
7849 found_tls_get_addr_arg = 1;
7854 case R_PPC64_TOC16_LO:
7855 if (sym_sec == NULL || sym_sec != toc)
7858 /* Mark this toc entry as referenced by a TLS
7859 code sequence. We can do that now in the
7860 case of R_PPC64_TLS, and after checking for
7861 tls_get_addr for the TOC16 relocs. */
7862 if (toc_ref == NULL)
7864 = bfd_zmalloc (toc->output_section->rawsize / 8);
7865 if (toc_ref == NULL)
7869 value = h->root.u.def.value;
7871 value = sym->st_value;
7872 value += rel->r_addend;
7875 BFD_ASSERT (value < toc->size
7876 && toc->output_offset % 8 == 0);
7877 toc_ref_index = (value + toc->output_offset) / 8;
7878 if (r_type == R_PPC64_TLS
7879 || r_type == R_PPC64_TLSGD
7880 || r_type == R_PPC64_TLSLD)
7882 toc_ref[toc_ref_index] = 1;
7886 if (pass != 0 && toc_ref[toc_ref_index] == 0)
7891 expecting_tls_get_addr = 2;
7894 case R_PPC64_TPREL64:
7898 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
7903 tls_set = TLS_EXPLICIT;
7904 tls_clear = TLS_TPREL;
7909 case R_PPC64_DTPMOD64:
7913 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
7915 if (rel + 1 < relend
7917 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
7918 && rel[1].r_offset == rel->r_offset + 8)
7922 tls_set = TLS_EXPLICIT | TLS_GD;
7925 tls_set = TLS_EXPLICIT | TLS_GD | TLS_GDIE;
7934 tls_set = TLS_EXPLICIT;
7945 if (!expecting_tls_get_addr
7946 || !sec->has_tls_get_addr_call)
7949 if (rel + 1 < relend
7950 && branch_reloc_hash_match (ibfd, rel + 1,
7952 htab->tls_get_addr_fd))
7954 if (expecting_tls_get_addr == 2)
7956 /* Check for toc tls entries. */
7957 unsigned char *toc_tls;
7960 retval = get_tls_mask (&toc_tls, NULL, NULL,
7965 if (toc_tls != NULL)
7967 if ((*toc_tls & TLS_TLS) != 0
7968 && ((*toc_tls & (TLS_GD | TLS_LD)) != 0))
7969 found_tls_get_addr_arg = 1;
7971 toc_ref[toc_ref_index] = 1;
7977 /* Uh oh, we didn't find the expected call. We
7978 could just mark this symbol to exclude it
7979 from tls optimization but it's safer to skip
7980 the entire optimization. */
7981 /* xgettext:c-format */
7982 info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
7983 "TLS optimization disabled\n"),
7984 ibfd, sec, rel->r_offset);
7989 /* If we don't have old-style __tls_get_addr calls
7990 without TLSGD/TLSLD marker relocs, and we haven't
7991 found a new-style __tls_get_addr call with a
7992 marker for this symbol, then we either have a
7993 broken object file or an -mlongcall style
7994 indirect call to __tls_get_addr without a marker.
7995 Disable optimization in this case. */
7996 if ((tls_clear & (TLS_GD | TLS_LD)) != 0
7997 && (tls_set & TLS_EXPLICIT) == 0
7998 && !sec->has_tls_get_addr_call
7999 && ((*tls_mask & (TLS_TLS | TLS_MARK))
8000 != (TLS_TLS | TLS_MARK)))
8003 if (expecting_tls_get_addr)
8005 struct plt_entry *ent = NULL;
8007 if (htab->tls_get_addr != NULL)
8008 for (ent = htab->tls_get_addr->elf.plt.plist;
8011 if (ent->addend == 0)
8014 if (ent == NULL && htab->tls_get_addr_fd != NULL)
8015 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8018 if (ent->addend == 0)
8022 && ent->plt.refcount > 0)
8023 ent->plt.refcount -= 1;
8029 if ((tls_set & TLS_EXPLICIT) == 0)
8031 struct got_entry *ent;
8033 /* Adjust got entry for this reloc. */
8037 ent = elf_local_got_ents (ibfd)[r_symndx];
8039 for (; ent != NULL; ent = ent->next)
8040 if (ent->addend == rel->r_addend
8041 && ent->owner == ibfd
8042 && ent->tls_type == tls_type)
8049 /* We managed to get rid of a got entry. */
8050 if (ent->got.refcount > 0)
8051 ent->got.refcount -= 1;
8056 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8057 we'll lose one or two dyn relocs. */
8058 if (!dec_dynrel_count (rel->r_info, sec, info,
8062 if (tls_set == (TLS_EXPLICIT | TLS_GD))
8064 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8070 *tls_mask |= tls_set & 0xff;
8071 *tls_mask &= ~tls_clear;
8074 if (elf_section_data (sec)->relocs != relstart)
8079 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8081 if (!info->keep_memory)
8084 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8088 if (toc_ref != NULL)
8090 htab->do_tls_opt = 1;
8094 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8095 the values of any global symbols in a toc section that has been
8096 edited. Globals in toc sections should be a rarity, so this function
8097 sets a flag if any are found in toc sections other than the one just
8098 edited, so that further hash table traversals can be avoided. */
8100 struct adjust_toc_info
8103 unsigned long *skip;
8104 bfd_boolean global_toc_syms;
8107 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8110 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8112 struct ppc_link_hash_entry *eh;
8113 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8116 if (h->root.type != bfd_link_hash_defined
8117 && h->root.type != bfd_link_hash_defweak)
8120 eh = (struct ppc_link_hash_entry *) h;
8121 if (eh->adjust_done)
8124 if (eh->elf.root.u.def.section == toc_inf->toc)
8126 if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8127 i = toc_inf->toc->rawsize >> 3;
8129 i = eh->elf.root.u.def.value >> 3;
8131 if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8134 (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8137 while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8138 eh->elf.root.u.def.value = (bfd_vma) i << 3;
8141 eh->elf.root.u.def.value -= toc_inf->skip[i];
8142 eh->adjust_done = 1;
8144 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8145 toc_inf->global_toc_syms = TRUE;
8150 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
8151 on a _LO variety toc/got reloc. */
8154 ok_lo_toc_insn (unsigned int insn, enum elf_ppc64_reloc_type r_type)
8156 return ((insn & (0x3f << 26)) == 12u << 26 /* addic */
8157 || (insn & (0x3f << 26)) == 14u << 26 /* addi */
8158 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8159 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8160 || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8161 || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8162 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8163 || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8164 || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8165 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8166 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8167 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8168 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8169 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8170 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8171 || (insn & (0x3f << 26)) == 56u << 26 /* lq,lfq */
8172 || ((insn & (0x3f << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
8173 /* Exclude lfqu by testing reloc. If relocs are ever
8174 defined for the reduced D field in psq_lu then those
8175 will need testing too. */
8176 && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8177 || ((insn & (0x3f << 26)) == 58u << 26 /* ld,lwa */
8179 || (insn & (0x3f << 26)) == 60u << 26 /* stfq */
8180 || ((insn & (0x3f << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
8181 /* Exclude stfqu. psq_stu as above for psq_lu. */
8182 && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8183 || ((insn & (0x3f << 26)) == 62u << 26 /* std,stq */
8184 && (insn & 1) == 0));
8187 /* PCREL_OPT in one instance flags to the linker that a pair of insns:
8188 pld ra,symbol@got@pcrel
8193 may be translated to
8194 pload/pstore rt,symbol@pcrel
8196 This function returns true if the optimization is possible, placing
8197 the prefix insn in *PINSN1 and a NOP in *PINSN2.
8199 On entry to this function, the linker has already determined that
8200 the pld can be replaced with pla: *PINSN1 is that pla insn,
8201 while *PINSN2 is the second instruction. */
8204 xlate_pcrel_opt (uint64_t *pinsn1, uint64_t *pinsn2)
8206 uint32_t insn2 = *pinsn2 >> 32;
8209 /* Check that regs match. */
8210 if (((insn2 >> 16) & 31) != ((*pinsn1 >> 21) & 31))
8213 switch ((insn2 >> 26) & 63)
8229 /* These are the PMLS cases, where we just need to tack a prefix
8230 on the insn. Check that the D field is zero. */
8231 if ((insn2 & 0xffff) != 0)
8233 i1new = ((1ULL << 58) | (2ULL << 56) | (1ULL << 52)
8234 | (insn2 & ((63ULL << 26) | (31ULL << 21))));
8237 case 58: /* lwa, ld */
8238 if ((insn2 & 0xfffd) != 0)
8240 i1new = ((1ULL << 58) | (1ULL << 52)
8241 | (insn2 & 2 ? 41ULL << 26 : 57ULL << 26)
8242 | (insn2 & (31ULL << 21)));
8245 case 57: /* lxsd, lxssp */
8246 if ((insn2 & 0xfffc) != 0 || (insn2 & 3) < 2)
8248 i1new = ((1ULL << 58) | (1ULL << 52)
8249 | ((40ULL | (insn2 & 3)) << 26)
8250 | (insn2 & (31ULL << 21)));
8253 case 61: /* stxsd, stxssp, lxv, stxv */
8254 if ((insn2 & 3) == 0)
8256 else if ((insn2 & 3) >= 2)
8258 if ((insn2 & 0xfffc) != 0)
8260 i1new = ((1ULL << 58) | (1ULL << 52)
8261 | ((44ULL | (insn2 & 3)) << 26)
8262 | (insn2 & (31ULL << 21)));
8266 if ((insn2 & 0xfff0) != 0)
8268 i1new = ((1ULL << 58) | (1ULL << 52)
8269 | ((50ULL | (insn2 & 4) | ((insn2 & 8) >> 3)) << 26)
8270 | (insn2 & (31ULL << 21)));
8275 if ((insn2 & 0xffff) != 0)
8277 i1new = ((1ULL << 58) | (1ULL << 52)
8278 | (insn2 & ((63ULL << 26) | (31ULL << 21))));
8281 case 62: /* std, stq */
8282 if ((insn2 & 0xfffd) != 0)
8284 i1new = ((1ULL << 58) | (1ULL << 52)
8285 | ((insn2 & 2) == 0 ? 61ULL << 26 : 60ULL << 26)
8286 | (insn2 & (31ULL << 21)));
8291 *pinsn2 = (uint64_t) NOP << 32;
8295 /* Examine all relocs referencing .toc sections in order to remove
8296 unused .toc entries. */
8299 ppc64_elf_edit_toc (struct bfd_link_info *info)
8302 struct adjust_toc_info toc_inf;
8303 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8305 htab->do_toc_opt = 1;
8306 toc_inf.global_toc_syms = TRUE;
8307 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8309 asection *toc, *sec;
8310 Elf_Internal_Shdr *symtab_hdr;
8311 Elf_Internal_Sym *local_syms;
8312 Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8313 unsigned long *skip, *drop;
8314 unsigned char *used;
8315 unsigned char *keep, last, some_unused;
8317 if (!is_ppc64_elf (ibfd))
8320 toc = bfd_get_section_by_name (ibfd, ".toc");
8323 || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8324 || discarded_section (toc))
8329 symtab_hdr = &elf_symtab_hdr (ibfd);
8331 /* Look at sections dropped from the final link. */
8334 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8336 if (sec->reloc_count == 0
8337 || !discarded_section (sec)
8338 || get_opd_info (sec)
8339 || (sec->flags & SEC_ALLOC) == 0
8340 || (sec->flags & SEC_DEBUGGING) != 0)
8343 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8344 if (relstart == NULL)
8347 /* Run through the relocs to see which toc entries might be
8349 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8351 enum elf_ppc64_reloc_type r_type;
8352 unsigned long r_symndx;
8354 struct elf_link_hash_entry *h;
8355 Elf_Internal_Sym *sym;
8358 r_type = ELF64_R_TYPE (rel->r_info);
8365 case R_PPC64_TOC16_LO:
8366 case R_PPC64_TOC16_HI:
8367 case R_PPC64_TOC16_HA:
8368 case R_PPC64_TOC16_DS:
8369 case R_PPC64_TOC16_LO_DS:
8373 r_symndx = ELF64_R_SYM (rel->r_info);
8374 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8382 val = h->root.u.def.value;
8384 val = sym->st_value;
8385 val += rel->r_addend;
8387 if (val >= toc->size)
8390 /* Anything in the toc ought to be aligned to 8 bytes.
8391 If not, don't mark as unused. */
8397 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8402 skip[val >> 3] = ref_from_discarded;
8405 if (elf_section_data (sec)->relocs != relstart)
8409 /* For largetoc loads of address constants, we can convert
8410 . addis rx,2,addr@got@ha
8411 . ld ry,addr@got@l(rx)
8413 . addis rx,2,addr@toc@ha
8414 . addi ry,rx,addr@toc@l
8415 when addr is within 2G of the toc pointer. This then means
8416 that the word storing "addr" in the toc is no longer needed. */
8418 if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8419 && toc->output_section->rawsize < (bfd_vma) 1 << 31
8420 && toc->reloc_count != 0)
8422 /* Read toc relocs. */
8423 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8425 if (toc_relocs == NULL)
8428 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8430 enum elf_ppc64_reloc_type r_type;
8431 unsigned long r_symndx;
8433 struct elf_link_hash_entry *h;
8434 Elf_Internal_Sym *sym;
8437 r_type = ELF64_R_TYPE (rel->r_info);
8438 if (r_type != R_PPC64_ADDR64)
8441 r_symndx = ELF64_R_SYM (rel->r_info);
8442 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8447 || sym_sec->output_section == NULL
8448 || discarded_section (sym_sec))
8451 if (!SYMBOL_REFERENCES_LOCAL (info, h))
8456 if (h->type == STT_GNU_IFUNC)
8458 val = h->root.u.def.value;
8462 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8464 val = sym->st_value;
8466 val += rel->r_addend;
8467 val += sym_sec->output_section->vma + sym_sec->output_offset;
8469 /* We don't yet know the exact toc pointer value, but we
8470 know it will be somewhere in the toc section. Don't
8471 optimize if the difference from any possible toc
8472 pointer is outside [ff..f80008000, 7fff7fff]. */
8473 addr = toc->output_section->vma + TOC_BASE_OFF;
8474 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8477 addr = toc->output_section->vma + toc->output_section->rawsize;
8478 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8483 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8488 skip[rel->r_offset >> 3]
8489 |= can_optimize | ((rel - toc_relocs) << 2);
8496 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8500 if (local_syms != NULL
8501 && symtab_hdr->contents != (unsigned char *) local_syms)
8505 && elf_section_data (sec)->relocs != relstart)
8507 if (toc_relocs != NULL
8508 && elf_section_data (toc)->relocs != toc_relocs)
8515 /* Now check all kept sections that might reference the toc.
8516 Check the toc itself last. */
8517 for (sec = (ibfd->sections == toc && toc->next ? toc->next
8520 sec = (sec == toc ? NULL
8521 : sec->next == NULL ? toc
8522 : sec->next == toc && toc->next ? toc->next
8527 if (sec->reloc_count == 0
8528 || discarded_section (sec)
8529 || get_opd_info (sec)
8530 || (sec->flags & SEC_ALLOC) == 0
8531 || (sec->flags & SEC_DEBUGGING) != 0)
8534 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8536 if (relstart == NULL)
8542 /* Mark toc entries referenced as used. */
8546 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8548 enum elf_ppc64_reloc_type r_type;
8549 unsigned long r_symndx;
8551 struct elf_link_hash_entry *h;
8552 Elf_Internal_Sym *sym;
8554 enum {no_check, check_lo, check_ha} insn_check;
8556 r_type = ELF64_R_TYPE (rel->r_info);
8560 insn_check = no_check;
8563 case R_PPC64_GOT_TLSLD16_HA:
8564 case R_PPC64_GOT_TLSGD16_HA:
8565 case R_PPC64_GOT_TPREL16_HA:
8566 case R_PPC64_GOT_DTPREL16_HA:
8567 case R_PPC64_GOT16_HA:
8568 case R_PPC64_TOC16_HA:
8569 insn_check = check_ha;
8572 case R_PPC64_GOT_TLSLD16_LO:
8573 case R_PPC64_GOT_TLSGD16_LO:
8574 case R_PPC64_GOT_TPREL16_LO_DS:
8575 case R_PPC64_GOT_DTPREL16_LO_DS:
8576 case R_PPC64_GOT16_LO:
8577 case R_PPC64_GOT16_LO_DS:
8578 case R_PPC64_TOC16_LO:
8579 case R_PPC64_TOC16_LO_DS:
8580 insn_check = check_lo;
8584 if (insn_check != no_check)
8586 bfd_vma off = rel->r_offset & ~3;
8587 unsigned char buf[4];
8590 if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
8595 insn = bfd_get_32 (ibfd, buf);
8596 if (insn_check == check_lo
8597 ? !ok_lo_toc_insn (insn, r_type)
8598 : ((insn & ((0x3f << 26) | 0x1f << 16))
8599 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
8603 ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
8604 sprintf (str, "%#08x", insn);
8605 info->callbacks->einfo
8606 /* xgettext:c-format */
8607 (_("%H: toc optimization is not supported for"
8608 " %s instruction\n"),
8609 ibfd, sec, rel->r_offset & ~3, str);
8616 case R_PPC64_TOC16_LO:
8617 case R_PPC64_TOC16_HI:
8618 case R_PPC64_TOC16_HA:
8619 case R_PPC64_TOC16_DS:
8620 case R_PPC64_TOC16_LO_DS:
8621 /* In case we're taking addresses of toc entries. */
8622 case R_PPC64_ADDR64:
8629 r_symndx = ELF64_R_SYM (rel->r_info);
8630 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8641 val = h->root.u.def.value;
8643 val = sym->st_value;
8644 val += rel->r_addend;
8646 if (val >= toc->size)
8649 if ((skip[val >> 3] & can_optimize) != 0)
8656 case R_PPC64_TOC16_HA:
8659 case R_PPC64_TOC16_LO_DS:
8660 off = rel->r_offset;
8661 off += (bfd_big_endian (ibfd) ? -2 : 3);
8662 if (!bfd_get_section_contents (ibfd, sec, &opc,
8668 if ((opc & (0x3f << 2)) == (58u << 2))
8673 /* Wrong sort of reloc, or not a ld. We may
8674 as well clear ref_from_discarded too. */
8681 /* For the toc section, we only mark as used if this
8682 entry itself isn't unused. */
8683 else if ((used[rel->r_offset >> 3]
8684 || !(skip[rel->r_offset >> 3] & ref_from_discarded))
8687 /* Do all the relocs again, to catch reference
8696 if (elf_section_data (sec)->relocs != relstart)
8700 /* Merge the used and skip arrays. Assume that TOC
8701 doublewords not appearing as either used or unused belong
8702 to an entry more than one doubleword in size. */
8703 for (drop = skip, keep = used, last = 0, some_unused = 0;
8704 drop < skip + (toc->size + 7) / 8;
8709 *drop &= ~ref_from_discarded;
8710 if ((*drop & can_optimize) != 0)
8714 else if ((*drop & ref_from_discarded) != 0)
8717 last = ref_from_discarded;
8727 bfd_byte *contents, *src;
8729 Elf_Internal_Sym *sym;
8730 bfd_boolean local_toc_syms = FALSE;
8732 /* Shuffle the toc contents, and at the same time convert the
8733 skip array from booleans into offsets. */
8734 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
8737 elf_section_data (toc)->this_hdr.contents = contents;
8739 for (src = contents, off = 0, drop = skip;
8740 src < contents + toc->size;
8743 if ((*drop & (can_optimize | ref_from_discarded)) != 0)
8748 memcpy (src - off, src, 8);
8752 toc->rawsize = toc->size;
8753 toc->size = src - contents - off;
8755 /* Adjust addends for relocs against the toc section sym,
8756 and optimize any accesses we can. */
8757 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8759 if (sec->reloc_count == 0
8760 || discarded_section (sec))
8763 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8765 if (relstart == NULL)
8768 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8770 enum elf_ppc64_reloc_type r_type;
8771 unsigned long r_symndx;
8773 struct elf_link_hash_entry *h;
8776 r_type = ELF64_R_TYPE (rel->r_info);
8783 case R_PPC64_TOC16_LO:
8784 case R_PPC64_TOC16_HI:
8785 case R_PPC64_TOC16_HA:
8786 case R_PPC64_TOC16_DS:
8787 case R_PPC64_TOC16_LO_DS:
8788 case R_PPC64_ADDR64:
8792 r_symndx = ELF64_R_SYM (rel->r_info);
8793 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8801 val = h->root.u.def.value;
8804 val = sym->st_value;
8806 local_toc_syms = TRUE;
8809 val += rel->r_addend;
8811 if (val > toc->rawsize)
8813 else if ((skip[val >> 3] & ref_from_discarded) != 0)
8815 else if ((skip[val >> 3] & can_optimize) != 0)
8817 Elf_Internal_Rela *tocrel
8818 = toc_relocs + (skip[val >> 3] >> 2);
8819 unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
8823 case R_PPC64_TOC16_HA:
8824 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
8827 case R_PPC64_TOC16_LO_DS:
8828 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
8832 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
8834 info->callbacks->einfo
8835 /* xgettext:c-format */
8836 (_("%H: %s references "
8837 "optimized away TOC entry\n"),
8838 ibfd, sec, rel->r_offset,
8839 ppc64_elf_howto_table[r_type]->name);
8840 bfd_set_error (bfd_error_bad_value);
8843 rel->r_addend = tocrel->r_addend;
8844 elf_section_data (sec)->relocs = relstart;
8848 if (h != NULL || sym->st_value != 0)
8851 rel->r_addend -= skip[val >> 3];
8852 elf_section_data (sec)->relocs = relstart;
8855 if (elf_section_data (sec)->relocs != relstart)
8859 /* We shouldn't have local or global symbols defined in the TOC,
8860 but handle them anyway. */
8861 if (local_syms != NULL)
8862 for (sym = local_syms;
8863 sym < local_syms + symtab_hdr->sh_info;
8865 if (sym->st_value != 0
8866 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
8870 if (sym->st_value > toc->rawsize)
8871 i = toc->rawsize >> 3;
8873 i = sym->st_value >> 3;
8875 if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
8879 (_("%s defined on removed toc entry"),
8880 bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
8883 while ((skip[i] & (ref_from_discarded | can_optimize)));
8884 sym->st_value = (bfd_vma) i << 3;
8887 sym->st_value -= skip[i];
8888 symtab_hdr->contents = (unsigned char *) local_syms;
8891 /* Adjust any global syms defined in this toc input section. */
8892 if (toc_inf.global_toc_syms)
8895 toc_inf.skip = skip;
8896 toc_inf.global_toc_syms = FALSE;
8897 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
8901 if (toc->reloc_count != 0)
8903 Elf_Internal_Shdr *rel_hdr;
8904 Elf_Internal_Rela *wrel;
8907 /* Remove unused toc relocs, and adjust those we keep. */
8908 if (toc_relocs == NULL)
8909 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8911 if (toc_relocs == NULL)
8915 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8916 if ((skip[rel->r_offset >> 3]
8917 & (ref_from_discarded | can_optimize)) == 0)
8919 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
8920 wrel->r_info = rel->r_info;
8921 wrel->r_addend = rel->r_addend;
8924 else if (!dec_dynrel_count (rel->r_info, toc, info,
8925 &local_syms, NULL, NULL))
8928 elf_section_data (toc)->relocs = toc_relocs;
8929 toc->reloc_count = wrel - toc_relocs;
8930 rel_hdr = _bfd_elf_single_rel_hdr (toc);
8931 sz = rel_hdr->sh_entsize;
8932 rel_hdr->sh_size = toc->reloc_count * sz;
8935 else if (toc_relocs != NULL
8936 && elf_section_data (toc)->relocs != toc_relocs)
8939 if (local_syms != NULL
8940 && symtab_hdr->contents != (unsigned char *) local_syms)
8942 if (!info->keep_memory)
8945 symtab_hdr->contents = (unsigned char *) local_syms;
8950 /* Look for cases where we can change an indirect GOT access to
8951 a GOT relative or PC relative access, possibly reducing the
8952 number of GOT entries. */
8953 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8956 Elf_Internal_Shdr *symtab_hdr;
8957 Elf_Internal_Sym *local_syms;
8958 Elf_Internal_Rela *relstart, *rel;
8961 if (!is_ppc64_elf (ibfd))
8964 if (!ppc64_elf_tdata (ibfd)->has_gotrel)
8967 sec = ppc64_elf_tdata (ibfd)->got;
8968 got = sec->output_section->vma + sec->output_offset + 0x8000;
8971 symtab_hdr = &elf_symtab_hdr (ibfd);
8973 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8975 if (sec->reloc_count == 0
8976 || !ppc64_elf_section_data (sec)->has_gotrel
8977 || discarded_section (sec))
8980 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8982 if (relstart == NULL)
8985 if (local_syms != NULL
8986 && symtab_hdr->contents != (unsigned char *) local_syms)
8990 && elf_section_data (sec)->relocs != relstart)
8995 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8997 enum elf_ppc64_reloc_type r_type;
8998 unsigned long r_symndx;
8999 Elf_Internal_Sym *sym;
9001 struct elf_link_hash_entry *h;
9002 struct got_entry *ent;
9003 bfd_vma sym_addend, val, pc;
9004 unsigned char buf[8];
9007 r_type = ELF64_R_TYPE (rel->r_info);
9010 /* Note that we don't delete GOT entries for
9011 R_PPC64_GOT16_DS since we'd need a lot more
9012 analysis. For starters, the preliminary layout is
9013 before the GOT, PLT, dynamic sections and stubs are
9014 laid out. Then we'd need to allow for changes in
9015 distance between sections caused by alignment. */
9019 case R_PPC64_GOT16_HA:
9020 case R_PPC64_GOT16_LO_DS:
9021 sym_addend = rel->r_addend;
9024 case R_PPC64_GOT_PCREL34:
9029 r_symndx = ELF64_R_SYM (rel->r_info);
9030 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9034 if (!SYMBOL_REFERENCES_LOCAL (info, h))
9038 val = h->root.u.def.value;
9040 val = sym->st_value;
9042 val += sym_sec->output_section->vma + sym_sec->output_offset;
9044 /* Fudge factor to allow for the fact that the preliminary layout
9045 isn't exact. Reduce limits by this factor. */
9046 #define LIMIT_ADJUST(LIMIT) ((LIMIT) - (LIMIT) / 16)
9053 case R_PPC64_GOT16_HA:
9054 if (val - got + LIMIT_ADJUST (0x80008000ULL)
9055 >= LIMIT_ADJUST (0x100000000ULL))
9058 if (!bfd_get_section_contents (ibfd, sec, buf,
9059 rel->r_offset & ~3, 4))
9061 insn = bfd_get_32 (ibfd, buf);
9062 if (((insn & ((0x3f << 26) | 0x1f << 16))
9063 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9067 case R_PPC64_GOT16_LO_DS:
9068 if (val - got + LIMIT_ADJUST (0x80008000ULL)
9069 >= LIMIT_ADJUST (0x100000000ULL))
9071 if (!bfd_get_section_contents (ibfd, sec, buf,
9072 rel->r_offset & ~3, 4))
9074 insn = bfd_get_32 (ibfd, buf);
9075 if ((insn & (0x3f << 26 | 0x3)) != 58u << 26 /* ld */)
9079 case R_PPC64_GOT_PCREL34:
9081 pc += sec->output_section->vma + sec->output_offset;
9082 if (val - pc + LIMIT_ADJUST (1ULL << 33)
9083 >= LIMIT_ADJUST (1ULL << 34))
9085 if (!bfd_get_section_contents (ibfd, sec, buf,
9086 rel->r_offset & ~3, 8))
9088 insn = bfd_get_32 (ibfd, buf);
9089 if ((insn & (-1u << 18)) != ((1u << 26) | (1u << 20)))
9091 insn = bfd_get_32 (ibfd, buf + 4);
9092 if ((insn & (0x3f << 26)) != 57u << 26)
9102 struct got_entry **local_got_ents = elf_local_got_ents (ibfd);
9103 ent = local_got_ents[r_symndx];
9105 for (; ent != NULL; ent = ent->next)
9106 if (ent->addend == sym_addend
9107 && ent->owner == ibfd
9108 && ent->tls_type == 0)
9110 BFD_ASSERT (ent && ent->got.refcount > 0);
9111 ent->got.refcount -= 1;
9114 if (elf_section_data (sec)->relocs != relstart)
9118 if (local_syms != NULL
9119 && symtab_hdr->contents != (unsigned char *) local_syms)
9121 if (!info->keep_memory)
9124 symtab_hdr->contents = (unsigned char *) local_syms;
9131 /* Return true iff input section I references the TOC using
9132 instructions limited to +/-32k offsets. */
9135 ppc64_elf_has_small_toc_reloc (asection *i)
9137 return (is_ppc64_elf (i->owner)
9138 && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9141 /* Allocate space for one GOT entry. */
9144 allocate_got (struct elf_link_hash_entry *h,
9145 struct bfd_link_info *info,
9146 struct got_entry *gent)
9148 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9149 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9150 int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9152 int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9153 ? 2 : 1) * sizeof (Elf64_External_Rela);
9154 asection *got = ppc64_elf_tdata (gent->owner)->got;
9156 gent->got.offset = got->size;
9157 got->size += entsize;
9159 if (h->type == STT_GNU_IFUNC)
9161 htab->elf.irelplt->size += rentsize;
9162 htab->got_reli_size += rentsize;
9164 else if (((bfd_link_pic (info)
9165 && !((gent->tls_type & TLS_TPREL) != 0
9166 && bfd_link_executable (info)
9167 && SYMBOL_REFERENCES_LOCAL (info, h)))
9168 || (htab->elf.dynamic_sections_created
9170 && !SYMBOL_REFERENCES_LOCAL (info, h)))
9171 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9173 asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9174 relgot->size += rentsize;
9178 /* This function merges got entries in the same toc group. */
9181 merge_got_entries (struct got_entry **pent)
9183 struct got_entry *ent, *ent2;
9185 for (ent = *pent; ent != NULL; ent = ent->next)
9186 if (!ent->is_indirect)
9187 for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9188 if (!ent2->is_indirect
9189 && ent2->addend == ent->addend
9190 && ent2->tls_type == ent->tls_type
9191 && elf_gp (ent2->owner) == elf_gp (ent->owner))
9193 ent2->is_indirect = TRUE;
9194 ent2->got.ent = ent;
9198 /* If H is undefined, make it dynamic if that makes sense. */
9201 ensure_undef_dynamic (struct bfd_link_info *info,
9202 struct elf_link_hash_entry *h)
9204 struct elf_link_hash_table *htab = elf_hash_table (info);
9206 if (htab->dynamic_sections_created
9207 && ((info->dynamic_undefined_weak != 0
9208 && h->root.type == bfd_link_hash_undefweak)
9209 || h->root.type == bfd_link_hash_undefined)
9212 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
9213 return bfd_elf_link_record_dynamic_symbol (info, h);
9217 /* Allocate space in .plt, .got and associated reloc sections for
9221 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9223 struct bfd_link_info *info;
9224 struct ppc_link_hash_table *htab;
9226 struct ppc_link_hash_entry *eh;
9227 struct got_entry **pgent, *gent;
9229 if (h->root.type == bfd_link_hash_indirect)
9232 info = (struct bfd_link_info *) inf;
9233 htab = ppc_hash_table (info);
9237 eh = (struct ppc_link_hash_entry *) h;
9238 /* Run through the TLS GD got entries first if we're changing them
9240 if ((eh->tls_mask & (TLS_TLS | TLS_GDIE)) == (TLS_TLS | TLS_GDIE))
9241 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9242 if (gent->got.refcount > 0
9243 && (gent->tls_type & TLS_GD) != 0)
9245 /* This was a GD entry that has been converted to TPREL. If
9246 there happens to be a TPREL entry we can use that one. */
9247 struct got_entry *ent;
9248 for (ent = h->got.glist; ent != NULL; ent = ent->next)
9249 if (ent->got.refcount > 0
9250 && (ent->tls_type & TLS_TPREL) != 0
9251 && ent->addend == gent->addend
9252 && ent->owner == gent->owner)
9254 gent->got.refcount = 0;
9258 /* If not, then we'll be using our own TPREL entry. */
9259 if (gent->got.refcount != 0)
9260 gent->tls_type = TLS_TLS | TLS_TPREL;
9263 /* Remove any list entry that won't generate a word in the GOT before
9264 we call merge_got_entries. Otherwise we risk merging to empty
9266 pgent = &h->got.glist;
9267 while ((gent = *pgent) != NULL)
9268 if (gent->got.refcount > 0)
9270 if ((gent->tls_type & TLS_LD) != 0
9273 ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9274 *pgent = gent->next;
9277 pgent = &gent->next;
9280 *pgent = gent->next;
9282 if (!htab->do_multi_toc)
9283 merge_got_entries (&h->got.glist);
9285 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9286 if (!gent->is_indirect)
9288 /* Make sure this symbol is output as a dynamic symbol. */
9289 if (!ensure_undef_dynamic (info, h))
9292 if (!is_ppc64_elf (gent->owner))
9295 allocate_got (h, info, gent);
9298 /* If no dynamic sections we can't have dynamic relocs, except for
9299 IFUNCs which are handled even in static executables. */
9300 if (!htab->elf.dynamic_sections_created
9301 && h->type != STT_GNU_IFUNC)
9302 eh->dyn_relocs = NULL;
9304 /* Discard relocs on undefined symbols that must be local. */
9305 else if (h->root.type == bfd_link_hash_undefined
9306 && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9307 eh->dyn_relocs = NULL;
9309 /* Also discard relocs on undefined weak syms with non-default
9310 visibility, or when dynamic_undefined_weak says so. */
9311 else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9312 eh->dyn_relocs = NULL;
9314 if (eh->dyn_relocs != NULL)
9316 struct elf_dyn_relocs *p, **pp;
9318 /* In the shared -Bsymbolic case, discard space allocated for
9319 dynamic pc-relative relocs against symbols which turn out to
9320 be defined in regular objects. For the normal shared case,
9321 discard space for relocs that have become local due to symbol
9322 visibility changes. */
9324 if (bfd_link_pic (info))
9326 /* Relocs that use pc_count are those that appear on a call
9327 insn, or certain REL relocs (see must_be_dyn_reloc) that
9328 can be generated via assembly. We want calls to
9329 protected symbols to resolve directly to the function
9330 rather than going via the plt. If people want function
9331 pointer comparisons to work as expected then they should
9332 avoid writing weird assembly. */
9333 if (SYMBOL_CALLS_LOCAL (info, h))
9335 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9337 p->count -= p->pc_count;
9346 if (eh->dyn_relocs != NULL)
9348 /* Make sure this symbol is output as a dynamic symbol. */
9349 if (!ensure_undef_dynamic (info, h))
9353 else if (ELIMINATE_COPY_RELOCS && h->type != STT_GNU_IFUNC)
9355 /* For the non-pic case, discard space for relocs against
9356 symbols which turn out to need copy relocs or are not
9358 if (h->dynamic_adjusted
9360 && !ELF_COMMON_DEF_P (h))
9362 /* Make sure this symbol is output as a dynamic symbol. */
9363 if (!ensure_undef_dynamic (info, h))
9366 if (h->dynindx == -1)
9367 eh->dyn_relocs = NULL;
9370 eh->dyn_relocs = NULL;
9373 /* Finally, allocate space. */
9374 for (p = eh->dyn_relocs; p != NULL; p = p->next)
9376 asection *sreloc = elf_section_data (p->sec)->sreloc;
9377 if (eh->elf.type == STT_GNU_IFUNC)
9378 sreloc = htab->elf.irelplt;
9379 sreloc->size += p->count * sizeof (Elf64_External_Rela);
9383 /* We might need a PLT entry when the symbol
9386 c) has plt16 relocs and has been processed by adjust_dynamic_symbol, or
9387 d) has plt16 relocs and we are linking statically. */
9388 if ((htab->elf.dynamic_sections_created && h->dynindx != -1)
9389 || h->type == STT_GNU_IFUNC
9390 || (h->needs_plt && h->dynamic_adjusted)
9393 && !htab->elf.dynamic_sections_created
9394 && !htab->can_convert_all_inline_plt
9395 && (((struct ppc_link_hash_entry *) h)->tls_mask
9396 & (TLS_TLS | PLT_KEEP)) == PLT_KEEP))
9398 struct plt_entry *pent;
9399 bfd_boolean doneone = FALSE;
9400 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9401 if (pent->plt.refcount > 0)
9403 if (!htab->elf.dynamic_sections_created
9404 || h->dynindx == -1)
9406 if (h->type == STT_GNU_IFUNC)
9409 pent->plt.offset = s->size;
9410 s->size += PLT_ENTRY_SIZE (htab);
9411 s = htab->elf.irelplt;
9416 pent->plt.offset = s->size;
9417 s->size += LOCAL_PLT_ENTRY_SIZE (htab);
9418 s = bfd_link_pic (info) ? htab->relpltlocal : NULL;
9423 /* If this is the first .plt entry, make room for the special
9427 s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9429 pent->plt.offset = s->size;
9431 /* Make room for this entry. */
9432 s->size += PLT_ENTRY_SIZE (htab);
9434 /* Make room for the .glink code. */
9437 s->size += GLINK_PLTRESOLVE_SIZE (htab);
9440 /* We need bigger stubs past index 32767. */
9441 if (s->size >= GLINK_PLTRESOLVE_SIZE (htab) + 32768*2*4)
9448 /* We also need to make an entry in the .rela.plt section. */
9449 s = htab->elf.srelplt;
9452 s->size += sizeof (Elf64_External_Rela);
9456 pent->plt.offset = (bfd_vma) -1;
9459 h->plt.plist = NULL;
9465 h->plt.plist = NULL;
9472 #define PPC_LO(v) ((v) & 0xffff)
9473 #define PPC_HI(v) (((v) >> 16) & 0xffff)
9474 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
9476 ((((v) & 0x3ffff0000ULL) << 16) | (v & 0xffff))
9477 #define HA34(v) ((v + (1ULL << 33)) >> 34)
9479 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9480 to set up space for global entry stubs. These are put in glink,
9481 after the branch table. */
9484 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9486 struct bfd_link_info *info;
9487 struct ppc_link_hash_table *htab;
9488 struct plt_entry *pent;
9491 if (h->root.type == bfd_link_hash_indirect)
9494 if (!h->pointer_equality_needed)
9501 htab = ppc_hash_table (info);
9505 s = htab->global_entry;
9506 plt = htab->elf.splt;
9507 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9508 if (pent->plt.offset != (bfd_vma) -1
9509 && pent->addend == 0)
9511 /* For ELFv2, if this symbol is not defined in a regular file
9512 and we are not generating a shared library or pie, then we
9513 need to define the symbol in the executable on a call stub.
9514 This is to avoid text relocations. */
9515 bfd_vma off, stub_align, stub_off, stub_size;
9516 unsigned int align_power;
9520 if (htab->params->plt_stub_align >= 0)
9521 align_power = htab->params->plt_stub_align;
9523 align_power = -htab->params->plt_stub_align;
9524 /* Setting section alignment is delayed until we know it is
9525 non-empty. Otherwise the .text output section will be
9526 aligned at least to plt_stub_align even when no global
9527 entry stubs are needed. */
9528 if (s->alignment_power < align_power)
9529 s->alignment_power = align_power;
9530 stub_align = (bfd_vma) 1 << align_power;
9531 if (htab->params->plt_stub_align >= 0
9532 || ((((stub_off + stub_size - 1) & -stub_align)
9533 - (stub_off & -stub_align))
9534 > ((stub_size - 1) & -stub_align)))
9535 stub_off = (stub_off + stub_align - 1) & -stub_align;
9536 off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
9537 off -= stub_off + s->output_offset + s->output_section->vma;
9538 /* Note that for --plt-stub-align negative we have a possible
9539 dependency between stub offset and size. Break that
9540 dependency by assuming the max stub size when calculating
9542 if (PPC_HA (off) == 0)
9544 h->root.type = bfd_link_hash_defined;
9545 h->root.u.def.section = s;
9546 h->root.u.def.value = stub_off;
9547 s->size = stub_off + stub_size;
9553 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9554 read-only sections. */
9557 maybe_set_textrel (struct elf_link_hash_entry *h, void *inf)
9561 if (h->root.type == bfd_link_hash_indirect)
9564 sec = readonly_dynrelocs (h);
9567 struct bfd_link_info *info = (struct bfd_link_info *) inf;
9569 info->flags |= DF_TEXTREL;
9570 info->callbacks->minfo (_("%pB: dynamic relocation against `%pT'"
9571 " in read-only section `%pA'\n"),
9572 sec->owner, h->root.root.string, sec);
9574 /* Not an error, just cut short the traversal. */
9580 /* Set the sizes of the dynamic sections. */
9583 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9584 struct bfd_link_info *info)
9586 struct ppc_link_hash_table *htab;
9591 struct got_entry *first_tlsld;
9593 htab = ppc_hash_table (info);
9597 dynobj = htab->elf.dynobj;
9601 if (htab->elf.dynamic_sections_created)
9603 /* Set the contents of the .interp section to the interpreter. */
9604 if (bfd_link_executable (info) && !info->nointerp)
9606 s = bfd_get_linker_section (dynobj, ".interp");
9609 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9610 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9614 /* Set up .got offsets for local syms, and space for local dynamic
9616 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9618 struct got_entry **lgot_ents;
9619 struct got_entry **end_lgot_ents;
9620 struct plt_entry **local_plt;
9621 struct plt_entry **end_local_plt;
9622 unsigned char *lgot_masks;
9623 bfd_size_type locsymcount;
9624 Elf_Internal_Shdr *symtab_hdr;
9626 if (!is_ppc64_elf (ibfd))
9629 for (s = ibfd->sections; s != NULL; s = s->next)
9631 struct ppc_dyn_relocs *p;
9633 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9635 if (!bfd_is_abs_section (p->sec)
9636 && bfd_is_abs_section (p->sec->output_section))
9638 /* Input section has been discarded, either because
9639 it is a copy of a linkonce section or due to
9640 linker script /DISCARD/, so we'll be discarding
9643 else if (p->count != 0)
9645 asection *srel = elf_section_data (p->sec)->sreloc;
9647 srel = htab->elf.irelplt;
9648 srel->size += p->count * sizeof (Elf64_External_Rela);
9649 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9650 info->flags |= DF_TEXTREL;
9655 lgot_ents = elf_local_got_ents (ibfd);
9659 symtab_hdr = &elf_symtab_hdr (ibfd);
9660 locsymcount = symtab_hdr->sh_info;
9661 end_lgot_ents = lgot_ents + locsymcount;
9662 local_plt = (struct plt_entry **) end_lgot_ents;
9663 end_local_plt = local_plt + locsymcount;
9664 lgot_masks = (unsigned char *) end_local_plt;
9665 s = ppc64_elf_tdata (ibfd)->got;
9666 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9668 struct got_entry **pent, *ent;
9671 while ((ent = *pent) != NULL)
9672 if (ent->got.refcount > 0)
9674 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9676 ppc64_tlsld_got (ibfd)->got.refcount += 1;
9681 unsigned int ent_size = 8;
9682 unsigned int rel_size = sizeof (Elf64_External_Rela);
9684 ent->got.offset = s->size;
9685 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9690 s->size += ent_size;
9691 if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
9693 htab->elf.irelplt->size += rel_size;
9694 htab->got_reli_size += rel_size;
9696 else if (bfd_link_pic (info)
9697 && !((ent->tls_type & TLS_TPREL) != 0
9698 && bfd_link_executable (info)))
9700 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9701 srel->size += rel_size;
9710 /* Allocate space for plt calls to local syms. */
9711 lgot_masks = (unsigned char *) end_local_plt;
9712 for (; local_plt < end_local_plt; ++local_plt, ++lgot_masks)
9714 struct plt_entry *ent;
9716 for (ent = *local_plt; ent != NULL; ent = ent->next)
9717 if (ent->plt.refcount > 0)
9719 if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
9722 ent->plt.offset = s->size;
9723 s->size += PLT_ENTRY_SIZE (htab);
9724 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
9726 else if (htab->can_convert_all_inline_plt
9727 || (*lgot_masks & (TLS_TLS | PLT_KEEP)) != PLT_KEEP)
9728 ent->plt.offset = (bfd_vma) -1;
9732 ent->plt.offset = s->size;
9733 s->size += LOCAL_PLT_ENTRY_SIZE (htab);
9734 if (bfd_link_pic (info))
9735 htab->relpltlocal->size += sizeof (Elf64_External_Rela);
9739 ent->plt.offset = (bfd_vma) -1;
9743 /* Allocate global sym .plt and .got entries, and space for global
9744 sym dynamic relocs. */
9745 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9747 if (!htab->opd_abi && !bfd_link_pic (info))
9748 elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
9751 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9753 struct got_entry *ent;
9755 if (!is_ppc64_elf (ibfd))
9758 ent = ppc64_tlsld_got (ibfd);
9759 if (ent->got.refcount > 0)
9761 if (!htab->do_multi_toc && first_tlsld != NULL)
9763 ent->is_indirect = TRUE;
9764 ent->got.ent = first_tlsld;
9768 if (first_tlsld == NULL)
9770 s = ppc64_elf_tdata (ibfd)->got;
9771 ent->got.offset = s->size;
9774 if (bfd_link_pic (info))
9776 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9777 srel->size += sizeof (Elf64_External_Rela);
9782 ent->got.offset = (bfd_vma) -1;
9785 /* We now have determined the sizes of the various dynamic sections.
9786 Allocate memory for them. */
9788 for (s = dynobj->sections; s != NULL; s = s->next)
9790 if ((s->flags & SEC_LINKER_CREATED) == 0)
9793 if (s == htab->brlt || s == htab->relbrlt)
9794 /* These haven't been allocated yet; don't strip. */
9796 else if (s == htab->elf.sgot
9797 || s == htab->elf.splt
9798 || s == htab->elf.iplt
9799 || s == htab->pltlocal
9801 || s == htab->global_entry
9802 || s == htab->elf.sdynbss
9803 || s == htab->elf.sdynrelro)
9805 /* Strip this section if we don't need it; see the
9808 else if (s == htab->glink_eh_frame)
9810 if (!bfd_is_abs_section (s->output_section))
9811 /* Not sized yet. */
9814 else if (CONST_STRNEQ (s->name, ".rela"))
9818 if (s != htab->elf.srelplt)
9821 /* We use the reloc_count field as a counter if we need
9822 to copy relocs into the output file. */
9828 /* It's not one of our sections, so don't allocate space. */
9834 /* If we don't need this section, strip it from the
9835 output file. This is mostly to handle .rela.bss and
9836 .rela.plt. We must create both sections in
9837 create_dynamic_sections, because they must be created
9838 before the linker maps input sections to output
9839 sections. The linker does that before
9840 adjust_dynamic_symbol is called, and it is that
9841 function which decides whether anything needs to go
9842 into these sections. */
9843 s->flags |= SEC_EXCLUDE;
9847 if (bfd_is_abs_section (s->output_section))
9848 _bfd_error_handler (_("warning: discarding dynamic section %s"),
9851 if ((s->flags & SEC_HAS_CONTENTS) == 0)
9854 /* Allocate memory for the section contents. We use bfd_zalloc
9855 here in case unused entries are not reclaimed before the
9856 section's contents are written out. This should not happen,
9857 but this way if it does we get a R_PPC64_NONE reloc in .rela
9858 sections instead of garbage.
9859 We also rely on the section contents being zero when writing
9860 the GOT and .dynrelro. */
9861 s->contents = bfd_zalloc (dynobj, s->size);
9862 if (s->contents == NULL)
9866 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9868 if (!is_ppc64_elf (ibfd))
9871 s = ppc64_elf_tdata (ibfd)->got;
9872 if (s != NULL && s != htab->elf.sgot)
9875 s->flags |= SEC_EXCLUDE;
9878 s->contents = bfd_zalloc (ibfd, s->size);
9879 if (s->contents == NULL)
9883 s = ppc64_elf_tdata (ibfd)->relgot;
9887 s->flags |= SEC_EXCLUDE;
9890 s->contents = bfd_zalloc (ibfd, s->size);
9891 if (s->contents == NULL)
9899 if (htab->elf.dynamic_sections_created)
9901 bfd_boolean tls_opt;
9903 /* Add some entries to the .dynamic section. We fill in the
9904 values later, in ppc64_elf_finish_dynamic_sections, but we
9905 must add the entries now so that we get the correct size for
9906 the .dynamic section. The DT_DEBUG entry is filled in by the
9907 dynamic linker and used by the debugger. */
9908 #define add_dynamic_entry(TAG, VAL) \
9909 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9911 if (bfd_link_executable (info))
9913 if (!add_dynamic_entry (DT_DEBUG, 0))
9917 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
9919 if (!add_dynamic_entry (DT_PLTGOT, 0)
9920 || !add_dynamic_entry (DT_PLTRELSZ, 0)
9921 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9922 || !add_dynamic_entry (DT_JMPREL, 0)
9923 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9927 if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
9929 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9930 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9934 tls_opt = (htab->params->tls_get_addr_opt
9935 && htab->tls_get_addr_fd != NULL
9936 && htab->tls_get_addr_fd->elf.plt.plist != NULL);
9937 if (tls_opt || !htab->opd_abi)
9939 if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
9945 if (!add_dynamic_entry (DT_RELA, 0)
9946 || !add_dynamic_entry (DT_RELASZ, 0)
9947 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
9950 /* If any dynamic relocs apply to a read-only section,
9951 then we need a DT_TEXTREL entry. */
9952 if ((info->flags & DF_TEXTREL) == 0)
9953 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
9955 if ((info->flags & DF_TEXTREL) != 0)
9957 if (!add_dynamic_entry (DT_TEXTREL, 0))
9962 #undef add_dynamic_entry
9967 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
9970 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
9972 if (h->plt.plist != NULL
9974 && !h->pointer_equality_needed)
9977 return _bfd_elf_hash_symbol (h);
9980 /* Determine the type of stub needed, if any, for a call. */
9982 static inline enum ppc_stub_type
9983 ppc_type_of_stub (asection *input_sec,
9984 const Elf_Internal_Rela *rel,
9985 struct ppc_link_hash_entry **hash,
9986 struct plt_entry **plt_ent,
9987 bfd_vma destination,
9988 unsigned long local_off)
9990 struct ppc_link_hash_entry *h = *hash;
9992 bfd_vma branch_offset;
9993 bfd_vma max_branch_offset;
9994 enum elf_ppc64_reloc_type r_type;
9998 struct plt_entry *ent;
9999 struct ppc_link_hash_entry *fdh = h;
10001 && h->oh->is_func_descriptor)
10003 fdh = ppc_follow_link (h->oh);
10007 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10008 if (ent->addend == rel->r_addend
10009 && ent->plt.offset != (bfd_vma) -1)
10012 return ppc_stub_plt_call;
10015 /* Here, we know we don't have a plt entry. If we don't have a
10016 either a defined function descriptor or a defined entry symbol
10017 in a regular object file, then it is pointless trying to make
10018 any other type of stub. */
10019 if (!is_static_defined (&fdh->elf)
10020 && !is_static_defined (&h->elf))
10021 return ppc_stub_none;
10023 else if (elf_local_got_ents (input_sec->owner) != NULL)
10025 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10026 struct plt_entry **local_plt = (struct plt_entry **)
10027 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10028 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10030 if (local_plt[r_symndx] != NULL)
10032 struct plt_entry *ent;
10034 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10035 if (ent->addend == rel->r_addend
10036 && ent->plt.offset != (bfd_vma) -1)
10039 return ppc_stub_plt_call;
10044 /* Determine where the call point is. */
10045 location = (input_sec->output_offset
10046 + input_sec->output_section->vma
10049 branch_offset = destination - location;
10050 r_type = ELF64_R_TYPE (rel->r_info);
10052 /* Determine if a long branch stub is needed. */
10053 max_branch_offset = 1 << 25;
10054 if (r_type == R_PPC64_REL14
10055 || r_type == R_PPC64_REL14_BRTAKEN
10056 || r_type == R_PPC64_REL14_BRNTAKEN)
10057 max_branch_offset = 1 << 15;
10059 if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10060 /* We need a stub. Figure out whether a long_branch or plt_branch
10061 is needed later. */
10062 return ppc_stub_long_branch;
10064 return ppc_stub_none;
10067 /* Gets the address of a label (1:) in r11 and builds an offset in r12,
10068 then adds it to r11 (LOAD false) or loads r12 from r11+r12 (LOAD true).
10073 . lis %r12,xxx-1b@highest
10074 . ori %r12,%r12,xxx-1b@higher
10075 . sldi %r12,%r12,32
10076 . oris %r12,%r12,xxx-1b@high
10077 . ori %r12,%r12,xxx-1b@l
10078 . add/ldx %r12,%r11,%r12 */
10081 build_offset (bfd *abfd, bfd_byte *p, bfd_vma off, bfd_boolean load)
10083 bfd_put_32 (abfd, MFLR_R12, p);
10085 bfd_put_32 (abfd, BCL_20_31, p);
10087 bfd_put_32 (abfd, MFLR_R11, p);
10089 bfd_put_32 (abfd, MTLR_R12, p);
10091 if (off + 0x8000 < 0x10000)
10094 bfd_put_32 (abfd, LD_R12_0R11 + PPC_LO (off), p);
10096 bfd_put_32 (abfd, ADDI_R12_R11 + PPC_LO (off), p);
10099 else if (off + 0x80008000ULL < 0x100000000ULL)
10101 bfd_put_32 (abfd, ADDIS_R12_R11 + PPC_HA (off), p);
10104 bfd_put_32 (abfd, LD_R12_0R12 + PPC_LO (off), p);
10106 bfd_put_32 (abfd, ADDI_R12_R12 + PPC_LO (off), p);
10111 if (off + 0x800000000000ULL < 0x1000000000000ULL)
10113 bfd_put_32 (abfd, LI_R12_0 + ((off >> 32) & 0xffff), p);
10118 bfd_put_32 (abfd, LIS_R12 + ((off >> 48) & 0xffff), p);
10120 if (((off >> 32) & 0xffff) != 0)
10122 bfd_put_32 (abfd, ORI_R12_R12_0 + ((off >> 32) & 0xffff), p);
10126 if (((off >> 32) & 0xffffffffULL) != 0)
10128 bfd_put_32 (abfd, SLDI_R12_R12_32, p);
10131 if (PPC_HI (off) != 0)
10133 bfd_put_32 (abfd, ORIS_R12_R12_0 + PPC_HI (off), p);
10136 if (PPC_LO (off) != 0)
10138 bfd_put_32 (abfd, ORI_R12_R12_0 + PPC_LO (off), p);
10142 bfd_put_32 (abfd, LDX_R12_R11_R12, p);
10144 bfd_put_32 (abfd, ADD_R12_R11_R12, p);
10150 static unsigned int
10151 size_offset (bfd_vma off)
10154 if (off + 0x8000 < 0x10000)
10156 else if (off + 0x80008000ULL < 0x100000000ULL)
10160 if (off + 0x800000000000ULL < 0x1000000000000ULL)
10165 if (((off >> 32) & 0xffff) != 0)
10168 if (((off >> 32) & 0xffffffffULL) != 0)
10170 if (PPC_HI (off) != 0)
10172 if (PPC_LO (off) != 0)
10179 static unsigned int
10180 num_relocs_for_offset (bfd_vma off)
10182 unsigned int num_rel;
10183 if (off + 0x8000 < 0x10000)
10185 else if (off + 0x80008000ULL < 0x100000000ULL)
10190 if (off + 0x800000000000ULL >= 0x1000000000000ULL
10191 && ((off >> 32) & 0xffff) != 0)
10193 if (PPC_HI (off) != 0)
10195 if (PPC_LO (off) != 0)
10201 static Elf_Internal_Rela *
10202 emit_relocs_for_offset (struct bfd_link_info *info, Elf_Internal_Rela *r,
10203 bfd_vma roff, bfd_vma targ, bfd_vma off)
10205 bfd_vma relative_targ = targ - (roff - 8);
10206 if (bfd_big_endian (info->output_bfd))
10208 r->r_offset = roff;
10209 r->r_addend = relative_targ + roff;
10210 if (off + 0x8000 < 0x10000)
10211 r->r_info = ELF64_R_INFO (0, R_PPC64_REL16);
10212 else if (off + 0x80008000ULL < 0x100000000ULL)
10214 r->r_info = ELF64_R_INFO (0, R_PPC64_REL16_HA);
10217 r->r_offset = roff;
10218 r->r_info = ELF64_R_INFO (0, R_PPC64_REL16_LO);
10219 r->r_addend = relative_targ + roff;
10223 if (off + 0x800000000000ULL < 0x1000000000000ULL)
10224 r->r_info = ELF64_R_INFO (0, R_PPC64_REL16_HIGHER);
10227 r->r_info = ELF64_R_INFO (0, R_PPC64_REL16_HIGHEST);
10228 if (((off >> 32) & 0xffff) != 0)
10232 r->r_offset = roff;
10233 r->r_info = ELF64_R_INFO (0, R_PPC64_REL16_HIGHER);
10234 r->r_addend = relative_targ + roff;
10237 if (((off >> 32) & 0xffffffffULL) != 0)
10239 if (PPC_HI (off) != 0)
10243 r->r_offset = roff;
10244 r->r_info = ELF64_R_INFO (0, R_PPC64_REL16_HIGH);
10245 r->r_addend = relative_targ + roff;
10247 if (PPC_LO (off) != 0)
10251 r->r_offset = roff;
10252 r->r_info = ELF64_R_INFO (0, R_PPC64_REL16_LO);
10253 r->r_addend = relative_targ + roff;
10260 build_powerxx_offset (bfd *abfd, bfd_byte *p, bfd_vma off, int odd,
10264 if (off - odd + (1ULL << 33) < 1ULL << 34)
10269 bfd_put_32 (abfd, NOP, p);
10275 insn = PADDI_R12_PC;
10277 bfd_put_32 (abfd, insn >> 32, p);
10279 bfd_put_32 (abfd, insn, p);
10281 /* The minimum value for paddi is -0x200000000. The minimum value
10282 for li is -0x8000, which when shifted by 34 and added gives a
10283 minimum value of -0x2000200000000. The maximum value is
10284 0x1ffffffff+0x7fff<<34 which is 0x2000200000000-1. */
10285 else if (off - (8 - odd) + (0x20002ULL << 32) < 0x40004ULL << 32)
10288 bfd_put_32 (abfd, LI_R11_0 | (HA34 (off) & 0xffff), p);
10292 bfd_put_32 (abfd, SLDI_R11_R11_34, p);
10295 insn = PADDI_R12_PC | D34 (off);
10296 bfd_put_32 (abfd, insn >> 32, p);
10298 bfd_put_32 (abfd, insn, p);
10302 bfd_put_32 (abfd, SLDI_R11_R11_34, p);
10306 bfd_put_32 (abfd, LDX_R12_R11_R12, p);
10308 bfd_put_32 (abfd, ADD_R12_R11_R12, p);
10313 bfd_put_32 (abfd, LIS_R11 | ((HA34 (off) >> 16) & 0x3fff), p);
10315 bfd_put_32 (abfd, ORI_R11_R11_0 | (HA34 (off) & 0xffff), p);
10319 bfd_put_32 (abfd, SLDI_R11_R11_34, p);
10322 insn = PADDI_R12_PC | D34 (off);
10323 bfd_put_32 (abfd, insn >> 32, p);
10325 bfd_put_32 (abfd, insn, p);
10329 bfd_put_32 (abfd, SLDI_R11_R11_34, p);
10333 bfd_put_32 (abfd, LDX_R12_R11_R12, p);
10335 bfd_put_32 (abfd, ADD_R12_R11_R12, p);
10341 static unsigned int
10342 size_powerxx_offset (bfd_vma off, int odd)
10344 if (off - odd + (1ULL << 33) < 1ULL << 34)
10346 else if (off - (8 - odd) + (0x20002ULL << 32) < 0x40004ULL << 32)
10352 static unsigned int
10353 num_relocs_for_powerxx_offset (bfd_vma off, int odd)
10355 if (off - odd + (1ULL << 33) < 1ULL << 34)
10357 else if (off - (8 - odd) + (0x20002ULL << 32) < 0x40004ULL << 32)
10363 static Elf_Internal_Rela *
10364 emit_relocs_for_powerxx_offset (struct bfd_link_info *info,
10365 Elf_Internal_Rela *r, bfd_vma roff,
10366 bfd_vma targ, bfd_vma off, int odd)
10368 if (off - odd + (1ULL << 33) < 1ULL << 34)
10370 else if (off - (8 - odd) + (0x20002ULL << 32) < 0x40004ULL << 32)
10372 int d_offset = bfd_big_endian (info->output_bfd) ? 2 : 0;
10373 r->r_offset = roff + d_offset;
10374 r->r_addend = targ + 8 - odd - d_offset;
10375 r->r_info = ELF64_R_INFO (0, R_PPC64_REL16_HIGHERA34);
10381 int d_offset = bfd_big_endian (info->output_bfd) ? 2 : 0;
10382 r->r_offset = roff + d_offset;
10383 r->r_addend = targ + 8 + odd - d_offset;
10384 r->r_info = ELF64_R_INFO (0, R_PPC64_REL16_HIGHESTA34);
10387 r->r_offset = roff + d_offset;
10388 r->r_addend = targ + 4 + odd - d_offset;
10389 r->r_info = ELF64_R_INFO (0, R_PPC64_REL16_HIGHERA34);
10393 r->r_offset = roff;
10394 r->r_addend = targ;
10395 r->r_info = ELF64_R_INFO (0, R_PPC64_PCREL34);
10399 /* Emit .eh_frame opcode to advance pc by DELTA. */
10402 eh_advance (bfd *abfd, bfd_byte *eh, unsigned int delta)
10406 *eh++ = DW_CFA_advance_loc + delta;
10407 else if (delta < 256)
10409 *eh++ = DW_CFA_advance_loc1;
10412 else if (delta < 65536)
10414 *eh++ = DW_CFA_advance_loc2;
10415 bfd_put_16 (abfd, delta, eh);
10420 *eh++ = DW_CFA_advance_loc4;
10421 bfd_put_32 (abfd, delta, eh);
10427 /* Size of required .eh_frame opcode to advance pc by DELTA. */
10429 static unsigned int
10430 eh_advance_size (unsigned int delta)
10432 if (delta < 64 * 4)
10433 /* DW_CFA_advance_loc+[1..63]. */
10435 if (delta < 256 * 4)
10436 /* DW_CFA_advance_loc1, byte. */
10438 if (delta < 65536 * 4)
10439 /* DW_CFA_advance_loc2, 2 bytes. */
10441 /* DW_CFA_advance_loc4, 4 bytes. */
10445 /* With power7 weakly ordered memory model, it is possible for ld.so
10446 to update a plt entry in one thread and have another thread see a
10447 stale zero toc entry. To avoid this we need some sort of acquire
10448 barrier in the call stub. One solution is to make the load of the
10449 toc word seem to appear to depend on the load of the function entry
10450 word. Another solution is to test for r2 being zero, and branch to
10451 the appropriate glink entry if so.
10453 . fake dep barrier compare
10454 . ld 12,xxx(2) ld 12,xxx(2)
10455 . mtctr 12 mtctr 12
10456 . xor 11,12,12 ld 2,xxx+8(2)
10457 . add 2,2,11 cmpldi 2,0
10458 . ld 2,xxx+8(2) bnectr+
10459 . bctr b <glink_entry>
10461 The solution involving the compare turns out to be faster, so
10462 that's what we use unless the branch won't reach. */
10464 #define ALWAYS_USE_FAKE_DEP 0
10465 #define ALWAYS_EMIT_R2SAVE 0
10467 static inline unsigned int
10468 plt_stub_size (struct ppc_link_hash_table *htab,
10469 struct ppc_stub_hash_entry *stub_entry,
10474 if (stub_entry->stub_type >= ppc_stub_plt_call_notoc)
10476 if (htab->powerxx_stubs)
10478 bfd_vma start = (stub_entry->stub_offset
10479 + stub_entry->group->stub_sec->output_offset
10480 + stub_entry->group->stub_sec->output_section->vma);
10481 if (stub_entry->stub_type > ppc_stub_plt_call_notoc)
10483 size = 8 + size_powerxx_offset (off, start & 4);
10486 size = 8 + size_offset (off - 8);
10487 if (stub_entry->stub_type > ppc_stub_plt_call_notoc)
10493 if (ALWAYS_EMIT_R2SAVE
10494 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10496 if (PPC_HA (off) != 0)
10501 if (htab->params->plt_static_chain)
10503 if (htab->params->plt_thread_safe
10504 && htab->elf.dynamic_sections_created
10505 && stub_entry->h != NULL
10506 && stub_entry->h->elf.dynindx != -1)
10508 if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10511 if (stub_entry->h != NULL
10512 && (stub_entry->h == htab->tls_get_addr_fd
10513 || stub_entry->h == htab->tls_get_addr)
10514 && htab->params->tls_get_addr_opt)
10517 if (stub_entry->stub_type == ppc_stub_plt_call_r2save)
10523 /* Depending on the sign of plt_stub_align:
10524 If positive, return the padding to align to a 2**plt_stub_align
10526 If negative, if this stub would cross fewer 2**plt_stub_align
10527 boundaries if we align, then return the padding needed to do so. */
10529 static inline unsigned int
10530 plt_stub_pad (struct ppc_link_hash_table *htab,
10531 struct ppc_stub_hash_entry *stub_entry,
10535 unsigned stub_size;
10536 bfd_vma stub_off = stub_entry->group->stub_sec->size;
10538 if (htab->params->plt_stub_align >= 0)
10540 stub_align = 1 << htab->params->plt_stub_align;
10541 if ((stub_off & (stub_align - 1)) != 0)
10542 return stub_align - (stub_off & (stub_align - 1));
10546 stub_align = 1 << -htab->params->plt_stub_align;
10547 stub_size = plt_stub_size (htab, stub_entry, plt_off);
10548 if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10549 > ((stub_size - 1) & -stub_align))
10550 return stub_align - (stub_off & (stub_align - 1));
10554 /* Build a .plt call stub. */
10556 static inline bfd_byte *
10557 build_plt_stub (struct ppc_link_hash_table *htab,
10558 struct ppc_stub_hash_entry *stub_entry,
10559 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10561 bfd *obfd = htab->params->stub_bfd;
10562 bfd_boolean plt_load_toc = htab->opd_abi;
10563 bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10564 bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10565 && htab->elf.dynamic_sections_created
10566 && stub_entry->h != NULL
10567 && stub_entry->h->elf.dynindx != -1);
10568 bfd_boolean use_fake_dep = plt_thread_safe;
10569 bfd_vma cmp_branch_off = 0;
10571 if (!ALWAYS_USE_FAKE_DEP
10574 && !((stub_entry->h == htab->tls_get_addr_fd
10575 || stub_entry->h == htab->tls_get_addr)
10576 && htab->params->tls_get_addr_opt))
10578 bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10579 bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10580 / PLT_ENTRY_SIZE (htab));
10581 bfd_vma glinkoff = GLINK_PLTRESOLVE_SIZE (htab) + pltindex * 8;
10584 if (pltindex > 32768)
10585 glinkoff += (pltindex - 32768) * 4;
10587 + htab->glink->output_offset
10588 + htab->glink->output_section->vma);
10589 from = (p - stub_entry->group->stub_sec->contents
10590 + 4 * (ALWAYS_EMIT_R2SAVE
10591 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10592 + 4 * (PPC_HA (offset) != 0)
10593 + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10594 != PPC_HA (offset))
10595 + 4 * (plt_static_chain != 0)
10597 + stub_entry->group->stub_sec->output_offset
10598 + stub_entry->group->stub_sec->output_section->vma);
10599 cmp_branch_off = to - from;
10600 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10603 if (PPC_HA (offset) != 0)
10607 if (ALWAYS_EMIT_R2SAVE
10608 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10609 r[0].r_offset += 4;
10610 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10611 r[1].r_offset = r[0].r_offset + 4;
10612 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10613 r[1].r_addend = r[0].r_addend;
10616 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10618 r[2].r_offset = r[1].r_offset + 4;
10619 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10620 r[2].r_addend = r[0].r_addend;
10624 r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10625 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10626 r[2].r_addend = r[0].r_addend + 8;
10627 if (plt_static_chain)
10629 r[3].r_offset = r[2].r_offset + 4;
10630 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10631 r[3].r_addend = r[0].r_addend + 16;
10636 if (ALWAYS_EMIT_R2SAVE
10637 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10638 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10641 bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10642 bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p), p += 4;
10646 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10647 bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p), p += 4;
10650 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10652 bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10655 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10660 bfd_put_32 (obfd, XOR_R2_R12_R12, p), p += 4;
10661 bfd_put_32 (obfd, ADD_R11_R11_R2, p), p += 4;
10663 bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10664 if (plt_static_chain)
10665 bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10672 if (ALWAYS_EMIT_R2SAVE
10673 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10674 r[0].r_offset += 4;
10675 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10678 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10680 r[1].r_offset = r[0].r_offset + 4;
10681 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10682 r[1].r_addend = r[0].r_addend;
10686 r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10687 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10688 r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10689 if (plt_static_chain)
10691 r[2].r_offset = r[1].r_offset + 4;
10692 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10693 r[2].r_addend = r[0].r_addend + 8;
10698 if (ALWAYS_EMIT_R2SAVE
10699 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10700 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10701 bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p), p += 4;
10703 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10705 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
10708 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10713 bfd_put_32 (obfd, XOR_R11_R12_R12, p), p += 4;
10714 bfd_put_32 (obfd, ADD_R2_R2_R11, p), p += 4;
10716 if (plt_static_chain)
10717 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10718 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10721 if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10723 bfd_put_32 (obfd, CMPLDI_R2_0, p), p += 4;
10724 bfd_put_32 (obfd, BNECTR_P4, p), p += 4;
10725 bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10728 bfd_put_32 (obfd, BCTR, p), p += 4;
10732 /* Build a special .plt call stub for __tls_get_addr. */
10734 #define LD_R11_0R3 0xe9630000
10735 #define LD_R12_0R3 0xe9830000
10736 #define MR_R0_R3 0x7c601b78
10737 #define CMPDI_R11_0 0x2c2b0000
10738 #define ADD_R3_R12_R13 0x7c6c6a14
10739 #define BEQLR 0x4d820020
10740 #define MR_R3_R0 0x7c030378
10741 #define STD_R11_0R1 0xf9610000
10742 #define BCTRL 0x4e800421
10743 #define LD_R11_0R1 0xe9610000
10744 #define MTLR_R11 0x7d6803a6
10746 static inline bfd_byte *
10747 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10748 struct ppc_stub_hash_entry *stub_entry,
10749 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10751 bfd *obfd = htab->params->stub_bfd;
10754 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4;
10755 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4;
10756 bfd_put_32 (obfd, MR_R0_R3, p), p += 4;
10757 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4;
10758 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4;
10759 bfd_put_32 (obfd, BEQLR, p), p += 4;
10760 bfd_put_32 (obfd, MR_R3_R0, p), p += 4;
10762 r[0].r_offset += 7 * 4;
10763 if (stub_entry->stub_type != ppc_stub_plt_call_r2save)
10764 return build_plt_stub (htab, stub_entry, p, offset, r);
10766 bfd_put_32 (obfd, MFLR_R11, p), p += 4;
10767 bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10770 r[0].r_offset += 2 * 4;
10771 p = build_plt_stub (htab, stub_entry, p, offset, r);
10772 bfd_put_32 (obfd, BCTRL, p - 4);
10774 bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p), p += 4;
10775 bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10776 bfd_put_32 (obfd, MTLR_R11, p), p += 4;
10777 bfd_put_32 (obfd, BLR, p), p += 4;
10779 if (htab->glink_eh_frame != NULL
10780 && htab->glink_eh_frame->size != 0)
10782 bfd_byte *base, *eh;
10783 unsigned int lr_used, delta;
10785 base = htab->glink_eh_frame->contents + stub_entry->group->eh_base + 17;
10786 eh = base + stub_entry->group->eh_size;
10787 lr_used = stub_entry->stub_offset + (p - 20 - loc);
10788 delta = lr_used - stub_entry->group->lr_restore;
10789 stub_entry->group->lr_restore = lr_used + 16;
10790 eh = eh_advance (htab->elf.dynobj, eh, delta);
10791 *eh++ = DW_CFA_offset_extended_sf;
10793 *eh++ = -(STK_LINKER (htab) / 8) & 0x7f;
10794 *eh++ = DW_CFA_advance_loc + 4;
10795 *eh++ = DW_CFA_restore_extended;
10797 stub_entry->group->eh_size = eh - base;
10802 static Elf_Internal_Rela *
10803 get_relocs (asection *sec, int count)
10805 Elf_Internal_Rela *relocs;
10806 struct bfd_elf_section_data *elfsec_data;
10808 elfsec_data = elf_section_data (sec);
10809 relocs = elfsec_data->relocs;
10810 if (relocs == NULL)
10812 bfd_size_type relsize;
10813 relsize = sec->reloc_count * sizeof (*relocs);
10814 relocs = bfd_alloc (sec->owner, relsize);
10815 if (relocs == NULL)
10817 elfsec_data->relocs = relocs;
10818 elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10819 sizeof (Elf_Internal_Shdr));
10820 if (elfsec_data->rela.hdr == NULL)
10822 elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10823 * sizeof (Elf64_External_Rela));
10824 elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10825 sec->reloc_count = 0;
10827 relocs += sec->reloc_count;
10828 sec->reloc_count += count;
10832 /* Convert the relocs R[0] thru R[-NUM_REL+1], which are all no-symbol
10833 forms, to the equivalent relocs against the global symbol given by
10837 use_global_in_relocs (struct ppc_link_hash_table *htab,
10838 struct ppc_stub_hash_entry *stub_entry,
10839 Elf_Internal_Rela *r, unsigned int num_rel)
10841 struct elf_link_hash_entry **hashes;
10842 unsigned long symndx;
10843 struct ppc_link_hash_entry *h;
10846 /* Relocs are always against symbols in their own object file. Fake
10847 up global sym hashes for the stub bfd (which has no symbols). */
10848 hashes = elf_sym_hashes (htab->params->stub_bfd);
10849 if (hashes == NULL)
10851 bfd_size_type hsize;
10853 /* When called the first time, stub_globals will contain the
10854 total number of symbols seen during stub sizing. After
10855 allocating, stub_globals is used as an index to fill the
10857 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10858 hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10859 if (hashes == NULL)
10861 elf_sym_hashes (htab->params->stub_bfd) = hashes;
10862 htab->stub_globals = 1;
10864 symndx = htab->stub_globals++;
10866 hashes[symndx] = &h->elf;
10867 if (h->oh != NULL && h->oh->is_func)
10868 h = ppc_follow_link (h->oh);
10869 BFD_ASSERT (h->elf.root.type == bfd_link_hash_defined
10870 || h->elf.root.type == bfd_link_hash_defweak);
10871 symval = (h->elf.root.u.def.value
10872 + h->elf.root.u.def.section->output_offset
10873 + h->elf.root.u.def.section->output_section->vma);
10874 while (num_rel-- != 0)
10876 r->r_info = ELF64_R_INFO (symndx, ELF64_R_TYPE (r->r_info));
10877 if (h->elf.root.u.def.section != stub_entry->target_section)
10879 /* H is an opd symbol. The addend must be zero, and the
10880 branch reloc is the only one we can convert. */
10885 r->r_addend -= symval;
10892 get_r2off (struct bfd_link_info *info,
10893 struct ppc_stub_hash_entry *stub_entry)
10895 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10896 bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10900 /* Support linking -R objects. Get the toc pointer from the
10903 if (!htab->opd_abi)
10905 asection *opd = stub_entry->h->elf.root.u.def.section;
10906 bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10908 if (strcmp (opd->name, ".opd") != 0
10909 || opd->reloc_count != 0)
10911 info->callbacks->einfo
10912 (_("%P: cannot find opd entry toc for `%pT'\n"),
10913 stub_entry->h->elf.root.root.string);
10914 bfd_set_error (bfd_error_bad_value);
10915 return (bfd_vma) -1;
10917 if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10918 return (bfd_vma) -1;
10919 r2off = bfd_get_64 (opd->owner, buf);
10920 r2off -= elf_gp (info->output_bfd);
10922 r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10927 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10929 struct ppc_stub_hash_entry *stub_entry;
10930 struct ppc_branch_hash_entry *br_entry;
10931 struct bfd_link_info *info;
10932 struct ppc_link_hash_table *htab;
10934 bfd_byte *p, *relp;
10936 Elf_Internal_Rela *r;
10941 /* Massage our args to the form they really have. */
10942 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10945 htab = ppc_hash_table (info);
10949 BFD_ASSERT (stub_entry->stub_offset >= stub_entry->group->stub_sec->size);
10950 loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10952 htab->stub_count[stub_entry->stub_type - 1] += 1;
10953 switch (stub_entry->stub_type)
10955 case ppc_stub_long_branch:
10956 case ppc_stub_long_branch_r2off:
10957 /* Branches are relative. This is where we are going to. */
10958 targ = (stub_entry->target_value
10959 + stub_entry->target_section->output_offset
10960 + stub_entry->target_section->output_section->vma);
10961 targ += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10963 /* And this is where we are coming from. */
10964 off = (stub_entry->stub_offset
10965 + stub_entry->group->stub_sec->output_offset
10966 + stub_entry->group->stub_sec->output_section->vma);
10970 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10972 bfd_vma r2off = get_r2off (info, stub_entry);
10974 if (r2off == (bfd_vma) -1)
10976 htab->stub_error = TRUE;
10979 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
10981 if (PPC_HA (r2off) != 0)
10983 bfd_put_32 (htab->params->stub_bfd,
10984 ADDIS_R2_R2 | PPC_HA (r2off), p);
10987 if (PPC_LO (r2off) != 0)
10989 bfd_put_32 (htab->params->stub_bfd,
10990 ADDI_R2_R2 | PPC_LO (r2off), p);
10995 bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), p);
10998 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
11001 (_("long branch stub `%s' offset overflow"),
11002 stub_entry->root.string);
11003 htab->stub_error = TRUE;
11007 if (info->emitrelocations)
11009 r = get_relocs (stub_entry->group->stub_sec, 1);
11012 r->r_offset = p - 4 - stub_entry->group->stub_sec->contents;
11013 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
11014 r->r_addend = targ;
11015 if (stub_entry->h != NULL
11016 && !use_global_in_relocs (htab, stub_entry, r, 1))
11021 case ppc_stub_plt_branch:
11022 case ppc_stub_plt_branch_r2off:
11023 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11024 stub_entry->root.string + 9,
11026 if (br_entry == NULL)
11028 _bfd_error_handler (_("can't find branch stub `%s'"),
11029 stub_entry->root.string);
11030 htab->stub_error = TRUE;
11034 targ = (stub_entry->target_value
11035 + stub_entry->target_section->output_offset
11036 + stub_entry->target_section->output_section->vma);
11037 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11038 targ += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11040 bfd_put_64 (htab->brlt->owner, targ,
11041 htab->brlt->contents + br_entry->offset);
11043 if (br_entry->iter == htab->stub_iteration)
11045 br_entry->iter = 0;
11047 if (htab->relbrlt != NULL)
11049 /* Create a reloc for the branch lookup table entry. */
11050 Elf_Internal_Rela rela;
11053 rela.r_offset = (br_entry->offset
11054 + htab->brlt->output_offset
11055 + htab->brlt->output_section->vma);
11056 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11057 rela.r_addend = targ;
11059 rl = htab->relbrlt->contents;
11060 rl += (htab->relbrlt->reloc_count++
11061 * sizeof (Elf64_External_Rela));
11062 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
11064 else if (info->emitrelocations)
11066 r = get_relocs (htab->brlt, 1);
11069 /* brlt, being SEC_LINKER_CREATED does not go through the
11070 normal reloc processing. Symbols and offsets are not
11071 translated from input file to output file form, so
11072 set up the offset per the output file. */
11073 r->r_offset = (br_entry->offset
11074 + htab->brlt->output_offset
11075 + htab->brlt->output_section->vma);
11076 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11077 r->r_addend = targ;
11081 targ = (br_entry->offset
11082 + htab->brlt->output_offset
11083 + htab->brlt->output_section->vma);
11085 off = (elf_gp (info->output_bfd)
11086 + htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11089 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11091 info->callbacks->einfo
11092 (_("%P: linkage table error against `%pT'\n"),
11093 stub_entry->root.string);
11094 bfd_set_error (bfd_error_bad_value);
11095 htab->stub_error = TRUE;
11099 if (info->emitrelocations)
11101 r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
11104 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11105 if (bfd_big_endian (info->output_bfd))
11106 r[0].r_offset += 2;
11107 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
11108 r[0].r_offset += 4;
11109 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11110 r[0].r_addend = targ;
11111 if (PPC_HA (off) != 0)
11113 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11114 r[1].r_offset = r[0].r_offset + 4;
11115 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11116 r[1].r_addend = r[0].r_addend;
11121 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11123 if (PPC_HA (off) != 0)
11125 bfd_put_32 (htab->params->stub_bfd,
11126 ADDIS_R12_R2 | PPC_HA (off), p);
11128 bfd_put_32 (htab->params->stub_bfd,
11129 LD_R12_0R12 | PPC_LO (off), p);
11132 bfd_put_32 (htab->params->stub_bfd,
11133 LD_R12_0R2 | PPC_LO (off), p);
11137 bfd_vma r2off = get_r2off (info, stub_entry);
11139 if (r2off == (bfd_vma) -1)
11141 htab->stub_error = TRUE;
11145 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
11147 if (PPC_HA (off) != 0)
11149 bfd_put_32 (htab->params->stub_bfd,
11150 ADDIS_R12_R2 | PPC_HA (off), p);
11152 bfd_put_32 (htab->params->stub_bfd,
11153 LD_R12_0R12 | PPC_LO (off), p);
11156 bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), p);
11158 if (PPC_HA (r2off) != 0)
11161 bfd_put_32 (htab->params->stub_bfd,
11162 ADDIS_R2_R2 | PPC_HA (r2off), p);
11164 if (PPC_LO (r2off) != 0)
11167 bfd_put_32 (htab->params->stub_bfd,
11168 ADDI_R2_R2 | PPC_LO (r2off), p);
11172 bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, p);
11174 bfd_put_32 (htab->params->stub_bfd, BCTR, p);
11178 case ppc_stub_long_branch_notoc:
11179 case ppc_stub_long_branch_both:
11180 case ppc_stub_plt_branch_notoc:
11181 case ppc_stub_plt_branch_both:
11182 case ppc_stub_plt_call_notoc:
11183 case ppc_stub_plt_call_both:
11185 off = (stub_entry->stub_offset
11186 + stub_entry->group->stub_sec->output_offset
11187 + stub_entry->group->stub_sec->output_section->vma);
11188 if (stub_entry->stub_type == ppc_stub_long_branch_both
11189 || stub_entry->stub_type == ppc_stub_plt_branch_both
11190 || stub_entry->stub_type == ppc_stub_plt_call_both)
11193 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
11196 if (stub_entry->stub_type >= ppc_stub_plt_call_notoc)
11198 targ = stub_entry->plt_ent->plt.offset & ~1;
11199 if (targ >= (bfd_vma) -2)
11202 plt = htab->elf.splt;
11203 if (!htab->elf.dynamic_sections_created
11204 || stub_entry->h == NULL
11205 || stub_entry->h->elf.dynindx == -1)
11207 if (stub_entry->symtype == STT_GNU_IFUNC)
11208 plt = htab->elf.iplt;
11210 plt = htab->pltlocal;
11212 targ += plt->output_offset + plt->output_section->vma;
11215 targ = (stub_entry->target_value
11216 + stub_entry->target_section->output_offset
11217 + stub_entry->target_section->output_section->vma);
11223 if (htab->powerxx_stubs)
11225 bfd_boolean load = stub_entry->stub_type >= ppc_stub_plt_call_notoc;
11226 p = build_powerxx_offset (htab->params->stub_bfd, p, off, odd, load);
11230 /* The notoc stubs calculate their target (either a PLT entry or
11231 the global entry point of a function) relative to the PC
11232 returned by the "bcl" two instructions past the start of the
11233 sequence emitted by build_offset. The offset is therefore 8
11234 less than calculated from the start of the sequence. */
11236 p = build_offset (htab->params->stub_bfd, p, off,
11237 stub_entry->stub_type >= ppc_stub_plt_call_notoc);
11240 if (stub_entry->stub_type <= ppc_stub_long_branch_both)
11244 from = (stub_entry->stub_offset
11245 + stub_entry->group->stub_sec->output_offset
11246 + stub_entry->group->stub_sec->output_section->vma
11248 bfd_put_32 (htab->params->stub_bfd,
11249 B_DOT | ((targ - from) & 0x3fffffc), p);
11253 bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, p);
11255 bfd_put_32 (htab->params->stub_bfd, BCTR, p);
11259 if (info->emitrelocations)
11261 bfd_vma roff = relp - stub_entry->group->stub_sec->contents;
11262 if (htab->powerxx_stubs)
11263 num_rel += num_relocs_for_powerxx_offset (off, odd);
11266 num_rel += num_relocs_for_offset (off);
11269 r = get_relocs (stub_entry->group->stub_sec, num_rel);
11272 if (htab->powerxx_stubs)
11273 r = emit_relocs_for_powerxx_offset (info, r, roff, targ, off, odd);
11275 r = emit_relocs_for_offset (info, r, roff, targ, off);
11276 if (stub_entry->stub_type == ppc_stub_long_branch_notoc
11277 || stub_entry->stub_type == ppc_stub_long_branch_both)
11280 roff = p - 4 - stub_entry->group->stub_sec->contents;
11281 r->r_offset = roff;
11282 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
11283 r->r_addend = targ;
11284 if (stub_entry->h != NULL
11285 && !use_global_in_relocs (htab, stub_entry, r, num_rel))
11290 if (!htab->powerxx_stubs
11291 && htab->glink_eh_frame != NULL
11292 && htab->glink_eh_frame->size != 0)
11294 bfd_byte *base, *eh;
11295 unsigned int lr_used, delta;
11297 base = (htab->glink_eh_frame->contents
11298 + stub_entry->group->eh_base + 17);
11299 eh = base + stub_entry->group->eh_size;
11300 lr_used = stub_entry->stub_offset + 8;
11301 if (stub_entry->stub_type == ppc_stub_long_branch_both
11302 || stub_entry->stub_type == ppc_stub_plt_branch_both
11303 || stub_entry->stub_type == ppc_stub_plt_call_both)
11305 delta = lr_used - stub_entry->group->lr_restore;
11306 stub_entry->group->lr_restore = lr_used + 8;
11307 eh = eh_advance (htab->elf.dynobj, eh, delta);
11308 *eh++ = DW_CFA_register;
11311 *eh++ = DW_CFA_advance_loc + 2;
11312 *eh++ = DW_CFA_restore_extended;
11314 stub_entry->group->eh_size = eh - base;
11318 case ppc_stub_plt_call:
11319 case ppc_stub_plt_call_r2save:
11320 if (stub_entry->h != NULL
11321 && stub_entry->h->is_func_descriptor
11322 && stub_entry->h->oh != NULL)
11324 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11326 /* If the old-ABI "dot-symbol" is undefined make it weak so
11327 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL. */
11328 if (fh->elf.root.type == bfd_link_hash_undefined
11329 && (stub_entry->h->elf.root.type == bfd_link_hash_defined
11330 || stub_entry->h->elf.root.type == bfd_link_hash_defweak))
11331 fh->elf.root.type = bfd_link_hash_undefweak;
11334 /* Now build the stub. */
11335 targ = stub_entry->plt_ent->plt.offset & ~1;
11336 if (targ >= (bfd_vma) -2)
11339 plt = htab->elf.splt;
11340 if (!htab->elf.dynamic_sections_created
11341 || stub_entry->h == NULL
11342 || stub_entry->h->elf.dynindx == -1)
11344 if (stub_entry->symtype == STT_GNU_IFUNC)
11345 plt = htab->elf.iplt;
11347 plt = htab->pltlocal;
11349 targ += plt->output_offset + plt->output_section->vma;
11351 off = (elf_gp (info->output_bfd)
11352 + htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11355 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11357 info->callbacks->einfo
11358 /* xgettext:c-format */
11359 (_("%P: linkage table error against `%pT'\n"),
11360 stub_entry->h != NULL
11361 ? stub_entry->h->elf.root.root.string
11363 bfd_set_error (bfd_error_bad_value);
11364 htab->stub_error = TRUE;
11369 if (info->emitrelocations)
11371 r = get_relocs (stub_entry->group->stub_sec,
11372 ((PPC_HA (off) != 0)
11374 ? 2 + (htab->params->plt_static_chain
11375 && PPC_HA (off + 16) == PPC_HA (off))
11379 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11380 if (bfd_big_endian (info->output_bfd))
11381 r[0].r_offset += 2;
11382 r[0].r_addend = targ;
11384 if (stub_entry->h != NULL
11385 && (stub_entry->h == htab->tls_get_addr_fd
11386 || stub_entry->h == htab->tls_get_addr)
11387 && htab->params->tls_get_addr_opt)
11388 p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11390 p = build_plt_stub (htab, stub_entry, loc, off, r);
11393 case ppc_stub_save_res:
11401 stub_entry->group->stub_sec->size = stub_entry->stub_offset + (p - loc);
11403 if (htab->params->emit_stub_syms)
11405 struct elf_link_hash_entry *h;
11408 const char *const stub_str[] = { "long_branch",
11421 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11422 len2 = strlen (stub_entry->root.string);
11423 name = bfd_malloc (len1 + len2 + 2);
11426 memcpy (name, stub_entry->root.string, 9);
11427 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11428 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11429 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11432 if (h->root.type == bfd_link_hash_new)
11434 h->root.type = bfd_link_hash_defined;
11435 h->root.u.def.section = stub_entry->group->stub_sec;
11436 h->root.u.def.value = stub_entry->stub_offset;
11437 h->ref_regular = 1;
11438 h->def_regular = 1;
11439 h->ref_regular_nonweak = 1;
11440 h->forced_local = 1;
11442 h->root.linker_def = 1;
11449 /* As above, but don't actually build the stub. Just bump offset so
11450 we know stub section sizes, and select plt_branch stubs where
11451 long_branch stubs won't do. */
11454 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11456 struct ppc_stub_hash_entry *stub_entry;
11457 struct bfd_link_info *info;
11458 struct ppc_link_hash_table *htab;
11460 bfd_vma targ, off, r2off;
11461 unsigned int size, extra, lr_used, delta, odd;
11463 /* Massage our args to the form they really have. */
11464 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11467 htab = ppc_hash_table (info);
11471 /* Make a note of the offset within the stubs for this entry. */
11472 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11474 if (stub_entry->h != NULL
11475 && stub_entry->h->save_res
11476 && stub_entry->h->elf.root.type == bfd_link_hash_defined
11477 && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11479 /* Don't make stubs to out-of-line register save/restore
11480 functions. Instead, emit copies of the functions. */
11481 stub_entry->group->needs_save_res = 1;
11482 stub_entry->stub_type = ppc_stub_save_res;
11486 switch (stub_entry->stub_type)
11488 case ppc_stub_plt_branch:
11489 case ppc_stub_plt_branch_r2off:
11490 /* Reset the stub type from the plt branch variant in case we now
11491 can reach with a shorter stub. */
11492 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11493 /* Fall through. */
11494 case ppc_stub_long_branch:
11495 case ppc_stub_long_branch_r2off:
11496 targ = (stub_entry->target_value
11497 + stub_entry->target_section->output_offset
11498 + stub_entry->target_section->output_section->vma);
11499 targ += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11500 off = (stub_entry->stub_offset
11501 + stub_entry->group->stub_sec->output_offset
11502 + stub_entry->group->stub_sec->output_section->vma);
11506 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11508 r2off = get_r2off (info, stub_entry);
11509 if (r2off == (bfd_vma) -1)
11511 htab->stub_error = TRUE;
11515 if (PPC_HA (r2off) != 0)
11517 if (PPC_LO (r2off) != 0)
11523 /* If the branch offset is too big, use a ppc_stub_plt_branch.
11524 Do the same for -R objects without function descriptors. */
11525 if ((stub_entry->stub_type == ppc_stub_long_branch_r2off
11527 && htab->sec_info[stub_entry->target_section->id].toc_off == 0)
11528 || off + (1 << 25) >= (bfd_vma) (1 << 26))
11530 struct ppc_branch_hash_entry *br_entry;
11532 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11533 stub_entry->root.string + 9,
11535 if (br_entry == NULL)
11537 _bfd_error_handler (_("can't build branch stub `%s'"),
11538 stub_entry->root.string);
11539 htab->stub_error = TRUE;
11543 if (br_entry->iter != htab->stub_iteration)
11545 br_entry->iter = htab->stub_iteration;
11546 br_entry->offset = htab->brlt->size;
11547 htab->brlt->size += 8;
11549 if (htab->relbrlt != NULL)
11550 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11551 else if (info->emitrelocations)
11553 htab->brlt->reloc_count += 1;
11554 htab->brlt->flags |= SEC_RELOC;
11558 targ = (br_entry->offset
11559 + htab->brlt->output_offset
11560 + htab->brlt->output_section->vma);
11561 off = (elf_gp (info->output_bfd)
11562 + htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11565 if (info->emitrelocations)
11567 stub_entry->group->stub_sec->reloc_count
11568 += 1 + (PPC_HA (off) != 0);
11569 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11572 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11573 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11576 if (PPC_HA (off) != 0)
11582 if (PPC_HA (off) != 0)
11585 if (PPC_HA (r2off) != 0)
11587 if (PPC_LO (r2off) != 0)
11591 else if (info->emitrelocations)
11593 stub_entry->group->stub_sec->reloc_count += 1;
11594 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11598 case ppc_stub_plt_branch_notoc:
11599 case ppc_stub_plt_branch_both:
11600 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11601 /* Fall through. */
11602 case ppc_stub_long_branch_notoc:
11603 case ppc_stub_long_branch_both:
11604 off = (stub_entry->stub_offset
11605 + stub_entry->group->stub_sec->output_offset
11606 + stub_entry->group->stub_sec->output_section->vma);
11608 if (stub_entry->stub_type == ppc_stub_long_branch_both)
11611 targ = (stub_entry->target_value
11612 + stub_entry->target_section->output_offset
11613 + stub_entry->target_section->output_section->vma);
11617 if (info->emitrelocations)
11619 unsigned int num_rel;
11620 if (htab->powerxx_stubs)
11621 num_rel = num_relocs_for_powerxx_offset (off, odd);
11623 num_rel = num_relocs_for_offset (off - 8);
11624 stub_entry->group->stub_sec->reloc_count += num_rel;
11625 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11628 if (htab->powerxx_stubs)
11629 extra = size_powerxx_offset (off, odd);
11631 extra = size_offset (off - 8);
11632 /* Include branch insn plus those in the offset sequence. */
11634 /* The branch insn is at the end, or "extra" bytes along. So
11635 its offset will be "extra" bytes less that that already
11639 if (!htab->powerxx_stubs)
11641 /* After the bcl, lr has been modified so we need to emit
11642 .eh_frame info saying the return address is in r12. */
11643 lr_used = stub_entry->stub_offset + 8;
11644 if (stub_entry->stub_type == ppc_stub_long_branch_both)
11646 /* The eh_frame info will consist of a DW_CFA_advance_loc or
11647 variant, DW_CFA_register, 65, 12, DW_CFA_advance_loc+2,
11648 DW_CFA_restore_extended 65. */
11649 delta = lr_used - stub_entry->group->lr_restore;
11650 stub_entry->group->eh_size += eh_advance_size (delta) + 6;
11651 stub_entry->group->lr_restore = lr_used + 8;
11654 /* If the branch can't reach, use a plt_branch. */
11655 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
11657 stub_entry->stub_type += (ppc_stub_plt_branch_notoc
11658 - ppc_stub_long_branch_notoc);
11661 else if (info->emitrelocations)
11662 stub_entry->group->stub_sec->reloc_count +=1;
11665 case ppc_stub_plt_call_notoc:
11666 case ppc_stub_plt_call_both:
11667 off = (stub_entry->stub_offset
11668 + stub_entry->group->stub_sec->output_offset
11669 + stub_entry->group->stub_sec->output_section->vma);
11670 if (stub_entry->stub_type == ppc_stub_plt_call_both)
11672 targ = stub_entry->plt_ent->plt.offset & ~1;
11673 if (targ >= (bfd_vma) -2)
11676 plt = htab->elf.splt;
11677 if (!htab->elf.dynamic_sections_created
11678 || stub_entry->h == NULL
11679 || stub_entry->h->elf.dynindx == -1)
11681 if (stub_entry->symtype == STT_GNU_IFUNC)
11682 plt = htab->elf.iplt;
11684 plt = htab->pltlocal;
11686 targ += plt->output_offset + plt->output_section->vma;
11690 if (htab->params->plt_stub_align != 0)
11692 unsigned pad = plt_stub_pad (htab, stub_entry, off);
11694 stub_entry->group->stub_sec->size += pad;
11695 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11699 if (info->emitrelocations)
11701 unsigned int num_rel;
11702 if (htab->powerxx_stubs)
11703 num_rel = num_relocs_for_powerxx_offset (off, odd);
11705 num_rel = num_relocs_for_offset (off - 8);
11706 stub_entry->group->stub_sec->reloc_count += num_rel;
11707 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11710 size = plt_stub_size (htab, stub_entry, off);
11712 if (!htab->powerxx_stubs)
11714 /* After the bcl, lr has been modified so we need to emit
11715 .eh_frame info saying the return address is in r12. */
11716 lr_used = stub_entry->stub_offset + 8;
11717 if (stub_entry->stub_type == ppc_stub_plt_call_both)
11719 /* The eh_frame info will consist of a DW_CFA_advance_loc or
11720 variant, DW_CFA_register, 65, 12, DW_CFA_advance_loc+2,
11721 DW_CFA_restore_extended 65. */
11722 delta = lr_used - stub_entry->group->lr_restore;
11723 stub_entry->group->eh_size += eh_advance_size (delta) + 6;
11724 stub_entry->group->lr_restore = lr_used + 8;
11728 case ppc_stub_plt_call:
11729 case ppc_stub_plt_call_r2save:
11730 targ = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11731 if (targ >= (bfd_vma) -2)
11733 plt = htab->elf.splt;
11734 if (!htab->elf.dynamic_sections_created
11735 || stub_entry->h == NULL
11736 || stub_entry->h->elf.dynindx == -1)
11738 if (stub_entry->symtype == STT_GNU_IFUNC)
11739 plt = htab->elf.iplt;
11741 plt = htab->pltlocal;
11743 targ += plt->output_offset + plt->output_section->vma;
11745 off = (elf_gp (info->output_bfd)
11746 + htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11749 if (htab->params->plt_stub_align != 0)
11751 unsigned pad = plt_stub_pad (htab, stub_entry, off);
11753 stub_entry->group->stub_sec->size += pad;
11754 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11757 if (info->emitrelocations)
11759 stub_entry->group->stub_sec->reloc_count
11760 += ((PPC_HA (off) != 0)
11762 ? 2 + (htab->params->plt_static_chain
11763 && PPC_HA (off + 16) == PPC_HA (off))
11765 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11768 size = plt_stub_size (htab, stub_entry, off);
11770 if (stub_entry->h != NULL
11771 && (stub_entry->h == htab->tls_get_addr_fd
11772 || stub_entry->h == htab->tls_get_addr)
11773 && htab->params->tls_get_addr_opt
11774 && stub_entry->stub_type == ppc_stub_plt_call_r2save)
11776 /* After the bctrl, lr has been modified so we need to
11777 emit .eh_frame info saying the return address is
11778 on the stack. In fact we put the EH info specifying
11779 that the return address is on the stack *at* the
11780 call rather than after it, because the EH info for a
11781 call needs to be specified by that point.
11782 See libgcc/unwind-dw2.c execute_cfa_program. */
11783 lr_used = stub_entry->stub_offset + size - 20;
11784 /* The eh_frame info will consist of a DW_CFA_advance_loc
11785 or variant, DW_CFA_offset_externed_sf, 65, -stackoff,
11786 DW_CFA_advance_loc+4, DW_CFA_restore_extended, 65. */
11787 delta = lr_used - stub_entry->group->lr_restore;
11788 stub_entry->group->eh_size += eh_advance_size (delta) + 6;
11789 stub_entry->group->lr_restore = size - 4;
11798 stub_entry->group->stub_sec->size += size;
11802 /* Set up various things so that we can make a list of input sections
11803 for each output section included in the link. Returns -1 on error,
11804 0 when no stubs will be needed, and 1 on success. */
11807 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11811 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11816 htab->sec_info_arr_size = _bfd_section_id;
11817 amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11818 htab->sec_info = bfd_zmalloc (amt);
11819 if (htab->sec_info == NULL)
11822 /* Set toc_off for com, und, abs and ind sections. */
11823 for (id = 0; id < 3; id++)
11824 htab->sec_info[id].toc_off = TOC_BASE_OFF;
11829 /* Set up for first pass at multitoc partitioning. */
11832 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11834 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11836 htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11837 htab->toc_bfd = NULL;
11838 htab->toc_first_sec = NULL;
11841 /* The linker repeatedly calls this function for each TOC input section
11842 and linker generated GOT section. Group input bfds such that the toc
11843 within a group is less than 64k in size. */
11846 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11848 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11849 bfd_vma addr, off, limit;
11854 if (!htab->second_toc_pass)
11856 /* Keep track of the first .toc or .got section for this input bfd. */
11857 bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11861 htab->toc_bfd = isec->owner;
11862 htab->toc_first_sec = isec;
11865 addr = isec->output_offset + isec->output_section->vma;
11866 off = addr - htab->toc_curr;
11867 limit = 0x80008000;
11868 if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11870 if (off + isec->size > limit)
11872 addr = (htab->toc_first_sec->output_offset
11873 + htab->toc_first_sec->output_section->vma);
11874 htab->toc_curr = addr;
11875 htab->toc_curr &= -TOC_BASE_ALIGN;
11878 /* toc_curr is the base address of this toc group. Set elf_gp
11879 for the input section to be the offset relative to the
11880 output toc base plus 0x8000. Making the input elf_gp an
11881 offset allows us to move the toc as a whole without
11882 recalculating input elf_gp. */
11883 off = htab->toc_curr - elf_gp (info->output_bfd);
11884 off += TOC_BASE_OFF;
11886 /* Die if someone uses a linker script that doesn't keep input
11887 file .toc and .got together. */
11889 && elf_gp (isec->owner) != 0
11890 && elf_gp (isec->owner) != off)
11893 elf_gp (isec->owner) = off;
11897 /* During the second pass toc_first_sec points to the start of
11898 a toc group, and toc_curr is used to track the old elf_gp.
11899 We use toc_bfd to ensure we only look at each bfd once. */
11900 if (htab->toc_bfd == isec->owner)
11902 htab->toc_bfd = isec->owner;
11904 if (htab->toc_first_sec == NULL
11905 || htab->toc_curr != elf_gp (isec->owner))
11907 htab->toc_curr = elf_gp (isec->owner);
11908 htab->toc_first_sec = isec;
11910 addr = (htab->toc_first_sec->output_offset
11911 + htab->toc_first_sec->output_section->vma);
11912 off = addr - elf_gp (info->output_bfd) + TOC_BASE_OFF;
11913 elf_gp (isec->owner) = off;
11918 /* Called via elf_link_hash_traverse to merge GOT entries for global
11922 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11924 if (h->root.type == bfd_link_hash_indirect)
11927 merge_got_entries (&h->got.glist);
11932 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11936 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11938 struct got_entry *gent;
11940 if (h->root.type == bfd_link_hash_indirect)
11943 for (gent = h->got.glist; gent != NULL; gent = gent->next)
11944 if (!gent->is_indirect)
11945 allocate_got (h, (struct bfd_link_info *) inf, gent);
11949 /* Called on the first multitoc pass after the last call to
11950 ppc64_elf_next_toc_section. This function removes duplicate GOT
11954 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11956 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11957 struct bfd *ibfd, *ibfd2;
11958 bfd_boolean done_something;
11960 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11962 if (!htab->do_multi_toc)
11965 /* Merge global sym got entries within a toc group. */
11966 elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11968 /* And tlsld_got. */
11969 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11971 struct got_entry *ent, *ent2;
11973 if (!is_ppc64_elf (ibfd))
11976 ent = ppc64_tlsld_got (ibfd);
11977 if (!ent->is_indirect
11978 && ent->got.offset != (bfd_vma) -1)
11980 for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11982 if (!is_ppc64_elf (ibfd2))
11985 ent2 = ppc64_tlsld_got (ibfd2);
11986 if (!ent2->is_indirect
11987 && ent2->got.offset != (bfd_vma) -1
11988 && elf_gp (ibfd2) == elf_gp (ibfd))
11990 ent2->is_indirect = TRUE;
11991 ent2->got.ent = ent;
11997 /* Zap sizes of got sections. */
11998 htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11999 htab->elf.irelplt->size -= htab->got_reli_size;
12000 htab->got_reli_size = 0;
12002 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12004 asection *got, *relgot;
12006 if (!is_ppc64_elf (ibfd))
12009 got = ppc64_elf_tdata (ibfd)->got;
12012 got->rawsize = got->size;
12014 relgot = ppc64_elf_tdata (ibfd)->relgot;
12015 relgot->rawsize = relgot->size;
12020 /* Now reallocate the got, local syms first. We don't need to
12021 allocate section contents again since we never increase size. */
12022 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12024 struct got_entry **lgot_ents;
12025 struct got_entry **end_lgot_ents;
12026 struct plt_entry **local_plt;
12027 struct plt_entry **end_local_plt;
12028 unsigned char *lgot_masks;
12029 bfd_size_type locsymcount;
12030 Elf_Internal_Shdr *symtab_hdr;
12033 if (!is_ppc64_elf (ibfd))
12036 lgot_ents = elf_local_got_ents (ibfd);
12040 symtab_hdr = &elf_symtab_hdr (ibfd);
12041 locsymcount = symtab_hdr->sh_info;
12042 end_lgot_ents = lgot_ents + locsymcount;
12043 local_plt = (struct plt_entry **) end_lgot_ents;
12044 end_local_plt = local_plt + locsymcount;
12045 lgot_masks = (unsigned char *) end_local_plt;
12046 s = ppc64_elf_tdata (ibfd)->got;
12047 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
12049 struct got_entry *ent;
12051 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
12053 unsigned int ent_size = 8;
12054 unsigned int rel_size = sizeof (Elf64_External_Rela);
12056 ent->got.offset = s->size;
12057 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
12062 s->size += ent_size;
12063 if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
12065 htab->elf.irelplt->size += rel_size;
12066 htab->got_reli_size += rel_size;
12068 else if (bfd_link_pic (info)
12069 && !((ent->tls_type & TLS_TPREL) != 0
12070 && bfd_link_executable (info)))
12072 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
12073 srel->size += rel_size;
12079 elf_link_hash_traverse (&htab->elf, reallocate_got, info);
12081 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12083 struct got_entry *ent;
12085 if (!is_ppc64_elf (ibfd))
12088 ent = ppc64_tlsld_got (ibfd);
12089 if (!ent->is_indirect
12090 && ent->got.offset != (bfd_vma) -1)
12092 asection *s = ppc64_elf_tdata (ibfd)->got;
12093 ent->got.offset = s->size;
12095 if (bfd_link_pic (info))
12097 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
12098 srel->size += sizeof (Elf64_External_Rela);
12103 done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
12104 if (!done_something)
12105 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12109 if (!is_ppc64_elf (ibfd))
12112 got = ppc64_elf_tdata (ibfd)->got;
12115 done_something = got->rawsize != got->size;
12116 if (done_something)
12121 if (done_something)
12122 (*htab->params->layout_sections_again) ();
12124 /* Set up for second pass over toc sections to recalculate elf_gp
12125 on input sections. */
12126 htab->toc_bfd = NULL;
12127 htab->toc_first_sec = NULL;
12128 htab->second_toc_pass = TRUE;
12129 return done_something;
12132 /* Called after second pass of multitoc partitioning. */
12135 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
12137 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12139 /* After the second pass, toc_curr tracks the TOC offset used
12140 for code sections below in ppc64_elf_next_input_section. */
12141 htab->toc_curr = TOC_BASE_OFF;
12144 /* No toc references were found in ISEC. If the code in ISEC makes no
12145 calls, then there's no need to use toc adjusting stubs when branching
12146 into ISEC. Actually, indirect calls from ISEC are OK as they will
12147 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
12148 needed, and 2 if a cyclical call-graph was found but no other reason
12149 for a stub was detected. If called from the top level, a return of
12150 2 means the same as a return of 0. */
12153 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
12157 /* Mark this section as checked. */
12158 isec->call_check_done = 1;
12160 /* We know none of our code bearing sections will need toc stubs. */
12161 if ((isec->flags & SEC_LINKER_CREATED) != 0)
12164 if (isec->size == 0)
12167 if (isec->output_section == NULL)
12171 if (isec->reloc_count != 0)
12173 Elf_Internal_Rela *relstart, *rel;
12174 Elf_Internal_Sym *local_syms;
12175 struct ppc_link_hash_table *htab;
12177 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
12178 info->keep_memory);
12179 if (relstart == NULL)
12182 /* Look for branches to outside of this section. */
12184 htab = ppc_hash_table (info);
12188 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
12190 enum elf_ppc64_reloc_type r_type;
12191 unsigned long r_symndx;
12192 struct elf_link_hash_entry *h;
12193 struct ppc_link_hash_entry *eh;
12194 Elf_Internal_Sym *sym;
12196 struct _opd_sec_data *opd;
12200 r_type = ELF64_R_TYPE (rel->r_info);
12201 if (r_type != R_PPC64_REL24
12202 && r_type != R_PPC64_REL24_NOTOC
12203 && r_type != R_PPC64_REL14
12204 && r_type != R_PPC64_REL14_BRTAKEN
12205 && r_type != R_PPC64_REL14_BRNTAKEN
12206 && r_type != R_PPC64_PLTCALL
12207 && r_type != R_PPC64_PLTCALL_NOTOC)
12210 r_symndx = ELF64_R_SYM (rel->r_info);
12211 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
12218 /* Calls to dynamic lib functions go through a plt call stub
12220 eh = (struct ppc_link_hash_entry *) h;
12222 && (eh->elf.plt.plist != NULL
12224 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
12230 if (sym_sec == NULL)
12231 /* Ignore other undefined symbols. */
12234 /* Assume branches to other sections not included in the
12235 link need stubs too, to cover -R and absolute syms. */
12236 if (sym_sec->output_section == NULL)
12243 sym_value = sym->st_value;
12246 if (h->root.type != bfd_link_hash_defined
12247 && h->root.type != bfd_link_hash_defweak)
12249 sym_value = h->root.u.def.value;
12251 sym_value += rel->r_addend;
12253 /* If this branch reloc uses an opd sym, find the code section. */
12254 opd = get_opd_info (sym_sec);
12257 if (h == NULL && opd->adjust != NULL)
12261 adjust = opd->adjust[OPD_NDX (sym_value)];
12263 /* Assume deleted functions won't ever be called. */
12265 sym_value += adjust;
12268 dest = opd_entry_value (sym_sec, sym_value,
12269 &sym_sec, NULL, FALSE);
12270 if (dest == (bfd_vma) -1)
12275 + sym_sec->output_offset
12276 + sym_sec->output_section->vma);
12278 /* Ignore branch to self. */
12279 if (sym_sec == isec)
12282 /* If the called function uses the toc, we need a stub. */
12283 if (sym_sec->has_toc_reloc
12284 || sym_sec->makes_toc_func_call)
12290 /* Assume any branch that needs a long branch stub might in fact
12291 need a plt_branch stub. A plt_branch stub uses r2. */
12292 else if (dest - (isec->output_offset
12293 + isec->output_section->vma
12294 + rel->r_offset) + (1 << 25)
12295 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
12303 /* If calling back to a section in the process of being
12304 tested, we can't say for sure that no toc adjusting stubs
12305 are needed, so don't return zero. */
12306 else if (sym_sec->call_check_in_progress)
12309 /* Branches to another section that itself doesn't have any TOC
12310 references are OK. Recursively call ourselves to check. */
12311 else if (!sym_sec->call_check_done)
12315 /* Mark current section as indeterminate, so that other
12316 sections that call back to current won't be marked as
12318 isec->call_check_in_progress = 1;
12319 recur = toc_adjusting_stub_needed (info, sym_sec);
12320 isec->call_check_in_progress = 0;
12331 if (local_syms != NULL
12332 && (elf_symtab_hdr (isec->owner).contents
12333 != (unsigned char *) local_syms))
12335 if (elf_section_data (isec)->relocs != relstart)
12340 && isec->map_head.s != NULL
12341 && (strcmp (isec->output_section->name, ".init") == 0
12342 || strcmp (isec->output_section->name, ".fini") == 0))
12344 if (isec->map_head.s->has_toc_reloc
12345 || isec->map_head.s->makes_toc_func_call)
12347 else if (!isec->map_head.s->call_check_done)
12350 isec->call_check_in_progress = 1;
12351 recur = toc_adjusting_stub_needed (info, isec->map_head.s);
12352 isec->call_check_in_progress = 0;
12359 isec->makes_toc_func_call = 1;
12364 /* The linker repeatedly calls this function for each input section,
12365 in the order that input sections are linked into output sections.
12366 Build lists of input sections to determine groupings between which
12367 we may insert linker stubs. */
12370 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
12372 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12377 if ((isec->output_section->flags & SEC_CODE) != 0
12378 && isec->output_section->id < htab->sec_info_arr_size)
12380 /* This happens to make the list in reverse order,
12381 which is what we want. */
12382 htab->sec_info[isec->id].u.list
12383 = htab->sec_info[isec->output_section->id].u.list;
12384 htab->sec_info[isec->output_section->id].u.list = isec;
12387 if (htab->multi_toc_needed)
12389 /* Analyse sections that aren't already flagged as needing a
12390 valid toc pointer. Exclude .fixup for the linux kernel.
12391 .fixup contains branches, but only back to the function that
12392 hit an exception. */
12393 if (!(isec->has_toc_reloc
12394 || (isec->flags & SEC_CODE) == 0
12395 || strcmp (isec->name, ".fixup") == 0
12396 || isec->call_check_done))
12398 if (toc_adjusting_stub_needed (info, isec) < 0)
12401 /* Make all sections use the TOC assigned for this object file.
12402 This will be wrong for pasted sections; We fix that in
12403 check_pasted_section(). */
12404 if (elf_gp (isec->owner) != 0)
12405 htab->toc_curr = elf_gp (isec->owner);
12408 htab->sec_info[isec->id].toc_off = htab->toc_curr;
12412 /* Check that all .init and .fini sections use the same toc, if they
12413 have toc relocs. */
12416 check_pasted_section (struct bfd_link_info *info, const char *name)
12418 asection *o = bfd_get_section_by_name (info->output_bfd, name);
12422 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12423 bfd_vma toc_off = 0;
12426 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12427 if (i->has_toc_reloc)
12430 toc_off = htab->sec_info[i->id].toc_off;
12431 else if (toc_off != htab->sec_info[i->id].toc_off)
12436 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12437 if (i->makes_toc_func_call)
12439 toc_off = htab->sec_info[i->id].toc_off;
12443 /* Make sure the whole pasted function uses the same toc offset. */
12445 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12446 htab->sec_info[i->id].toc_off = toc_off;
12452 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12454 return (check_pasted_section (info, ".init")
12455 & check_pasted_section (info, ".fini"));
12458 /* See whether we can group stub sections together. Grouping stub
12459 sections may result in fewer stubs. More importantly, we need to
12460 put all .init* and .fini* stubs at the beginning of the .init or
12461 .fini output sections respectively, because glibc splits the
12462 _init and _fini functions into multiple parts. Putting a stub in
12463 the middle of a function is not a good idea. */
12466 group_sections (struct bfd_link_info *info,
12467 bfd_size_type stub_group_size,
12468 bfd_boolean stubs_always_before_branch)
12470 struct ppc_link_hash_table *htab;
12472 bfd_boolean suppress_size_errors;
12474 htab = ppc_hash_table (info);
12478 suppress_size_errors = FALSE;
12479 if (stub_group_size == 1)
12481 /* Default values. */
12482 if (stubs_always_before_branch)
12483 stub_group_size = 0x1e00000;
12485 stub_group_size = 0x1c00000;
12486 suppress_size_errors = TRUE;
12489 for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12493 if (osec->id >= htab->sec_info_arr_size)
12496 tail = htab->sec_info[osec->id].u.list;
12497 while (tail != NULL)
12501 bfd_size_type total;
12502 bfd_boolean big_sec;
12504 struct map_stub *group;
12505 bfd_size_type group_size;
12508 total = tail->size;
12509 group_size = (ppc64_elf_section_data (tail) != NULL
12510 && ppc64_elf_section_data (tail)->has_14bit_branch
12511 ? stub_group_size >> 10 : stub_group_size);
12513 big_sec = total > group_size;
12514 if (big_sec && !suppress_size_errors)
12515 /* xgettext:c-format */
12516 _bfd_error_handler (_("%pB section %pA exceeds stub group size"),
12517 tail->owner, tail);
12518 curr_toc = htab->sec_info[tail->id].toc_off;
12520 while ((prev = htab->sec_info[curr->id].u.list) != NULL
12521 && ((total += curr->output_offset - prev->output_offset)
12522 < (ppc64_elf_section_data (prev) != NULL
12523 && ppc64_elf_section_data (prev)->has_14bit_branch
12524 ? (group_size = stub_group_size >> 10) : group_size))
12525 && htab->sec_info[prev->id].toc_off == curr_toc)
12528 /* OK, the size from the start of CURR to the end is less
12529 than group_size and thus can be handled by one stub
12530 section. (or the tail section is itself larger than
12531 group_size, in which case we may be toast.) We should
12532 really be keeping track of the total size of stubs added
12533 here, as stubs contribute to the final output section
12534 size. That's a little tricky, and this way will only
12535 break if stubs added make the total size more than 2^25,
12536 ie. for the default stub_group_size, if stubs total more
12537 than 2097152 bytes, or nearly 75000 plt call stubs. */
12538 group = bfd_alloc (curr->owner, sizeof (*group));
12541 group->link_sec = curr;
12542 group->stub_sec = NULL;
12543 group->needs_save_res = 0;
12544 group->lr_restore = 0;
12545 group->eh_size = 0;
12546 group->eh_base = 0;
12547 group->next = htab->group;
12548 htab->group = group;
12551 prev = htab->sec_info[tail->id].u.list;
12552 /* Set up this stub group. */
12553 htab->sec_info[tail->id].u.group = group;
12555 while (tail != curr && (tail = prev) != NULL);
12557 /* But wait, there's more! Input sections up to group_size
12558 bytes before the stub section can be handled by it too.
12559 Don't do this if we have a really large section after the
12560 stubs, as adding more stubs increases the chance that
12561 branches may not reach into the stub section. */
12562 if (!stubs_always_before_branch && !big_sec)
12565 while (prev != NULL
12566 && ((total += tail->output_offset - prev->output_offset)
12567 < (ppc64_elf_section_data (prev) != NULL
12568 && ppc64_elf_section_data (prev)->has_14bit_branch
12569 ? (group_size = stub_group_size >> 10)
12571 && htab->sec_info[prev->id].toc_off == curr_toc)
12574 prev = htab->sec_info[tail->id].u.list;
12575 htab->sec_info[tail->id].u.group = group;
12584 static const unsigned char glink_eh_frame_cie[] =
12586 0, 0, 0, 16, /* length. */
12587 0, 0, 0, 0, /* id. */
12588 1, /* CIE version. */
12589 'z', 'R', 0, /* Augmentation string. */
12590 4, /* Code alignment. */
12591 0x78, /* Data alignment. */
12593 1, /* Augmentation size. */
12594 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */
12595 DW_CFA_def_cfa, 1, 0 /* def_cfa: r1 offset 0. */
12598 /* Stripping output sections is normally done before dynamic section
12599 symbols have been allocated. This function is called later, and
12600 handles cases like htab->brlt which is mapped to its own output
12604 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12606 if (isec->size == 0
12607 && isec->output_section->size == 0
12608 && !(isec->output_section->flags & SEC_KEEP)
12609 && !bfd_section_removed_from_list (info->output_bfd,
12610 isec->output_section)
12611 && elf_section_data (isec->output_section)->dynindx == 0)
12613 isec->output_section->flags |= SEC_EXCLUDE;
12614 bfd_section_list_remove (info->output_bfd, isec->output_section);
12615 info->output_bfd->section_count--;
12619 /* Determine and set the size of the stub section for a final link.
12621 The basic idea here is to examine all the relocations looking for
12622 PC-relative calls to a target that is unreachable with a "bl"
12626 ppc64_elf_size_stubs (struct bfd_link_info *info)
12628 bfd_size_type stub_group_size;
12629 bfd_boolean stubs_always_before_branch;
12630 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12635 if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12636 htab->params->plt_thread_safe = 1;
12637 if (!htab->opd_abi)
12638 htab->params->plt_thread_safe = 0;
12639 else if (htab->params->plt_thread_safe == -1)
12641 static const char *const thread_starter[] =
12645 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12647 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12648 "mq_notify", "create_timer",
12653 "GOMP_parallel_start",
12654 "GOMP_parallel_loop_static",
12655 "GOMP_parallel_loop_static_start",
12656 "GOMP_parallel_loop_dynamic",
12657 "GOMP_parallel_loop_dynamic_start",
12658 "GOMP_parallel_loop_guided",
12659 "GOMP_parallel_loop_guided_start",
12660 "GOMP_parallel_loop_runtime",
12661 "GOMP_parallel_loop_runtime_start",
12662 "GOMP_parallel_sections",
12663 "GOMP_parallel_sections_start",
12669 for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12671 struct elf_link_hash_entry *h;
12672 h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12673 FALSE, FALSE, TRUE);
12674 htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12675 if (htab->params->plt_thread_safe)
12679 stubs_always_before_branch = htab->params->group_size < 0;
12680 if (htab->params->group_size < 0)
12681 stub_group_size = -htab->params->group_size;
12683 stub_group_size = htab->params->group_size;
12685 if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12688 #define STUB_SHRINK_ITER 20
12689 /* Loop until no stubs added. After iteration 20 of this loop we may
12690 exit on a stub section shrinking. This is to break out of a
12691 pathological case where adding stubs on one iteration decreases
12692 section gaps (perhaps due to alignment), which then requires
12693 fewer or smaller stubs on the next iteration. */
12698 unsigned int bfd_indx;
12699 struct map_stub *group;
12701 htab->stub_iteration += 1;
12703 for (input_bfd = info->input_bfds, bfd_indx = 0;
12705 input_bfd = input_bfd->link.next, bfd_indx++)
12707 Elf_Internal_Shdr *symtab_hdr;
12709 Elf_Internal_Sym *local_syms = NULL;
12711 if (!is_ppc64_elf (input_bfd))
12714 /* We'll need the symbol table in a second. */
12715 symtab_hdr = &elf_symtab_hdr (input_bfd);
12716 if (symtab_hdr->sh_info == 0)
12719 /* Walk over each section attached to the input bfd. */
12720 for (section = input_bfd->sections;
12722 section = section->next)
12724 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12726 /* If there aren't any relocs, then there's nothing more
12728 if ((section->flags & SEC_RELOC) == 0
12729 || (section->flags & SEC_ALLOC) == 0
12730 || (section->flags & SEC_LOAD) == 0
12731 || (section->flags & SEC_CODE) == 0
12732 || section->reloc_count == 0)
12735 /* If this section is a link-once section that will be
12736 discarded, then don't create any stubs. */
12737 if (section->output_section == NULL
12738 || section->output_section->owner != info->output_bfd)
12741 /* Get the relocs. */
12743 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12744 info->keep_memory);
12745 if (internal_relocs == NULL)
12746 goto error_ret_free_local;
12748 /* Now examine each relocation. */
12749 irela = internal_relocs;
12750 irelaend = irela + section->reloc_count;
12751 for (; irela < irelaend; irela++)
12753 enum elf_ppc64_reloc_type r_type;
12754 unsigned int r_indx;
12755 enum ppc_stub_type stub_type;
12756 struct ppc_stub_hash_entry *stub_entry;
12757 asection *sym_sec, *code_sec;
12758 bfd_vma sym_value, code_value;
12759 bfd_vma destination;
12760 unsigned long local_off;
12761 bfd_boolean ok_dest;
12762 struct ppc_link_hash_entry *hash;
12763 struct ppc_link_hash_entry *fdh;
12764 struct elf_link_hash_entry *h;
12765 Elf_Internal_Sym *sym;
12767 const asection *id_sec;
12768 struct _opd_sec_data *opd;
12769 struct plt_entry *plt_ent;
12771 r_type = ELF64_R_TYPE (irela->r_info);
12772 r_indx = ELF64_R_SYM (irela->r_info);
12774 if (r_type >= R_PPC64_max)
12776 bfd_set_error (bfd_error_bad_value);
12777 goto error_ret_free_internal;
12780 /* Only look for stubs on branch instructions. */
12781 if (r_type != R_PPC64_REL24
12782 && r_type != R_PPC64_REL24_NOTOC
12783 && r_type != R_PPC64_REL14
12784 && r_type != R_PPC64_REL14_BRTAKEN
12785 && r_type != R_PPC64_REL14_BRNTAKEN)
12788 /* Now determine the call target, its name, value,
12790 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12791 r_indx, input_bfd))
12792 goto error_ret_free_internal;
12793 hash = (struct ppc_link_hash_entry *) h;
12800 sym_value = sym->st_value;
12801 if (sym_sec != NULL
12802 && sym_sec->output_section != NULL)
12805 else if (hash->elf.root.type == bfd_link_hash_defined
12806 || hash->elf.root.type == bfd_link_hash_defweak)
12808 sym_value = hash->elf.root.u.def.value;
12809 if (sym_sec->output_section != NULL)
12812 else if (hash->elf.root.type == bfd_link_hash_undefweak
12813 || hash->elf.root.type == bfd_link_hash_undefined)
12815 /* Recognise an old ABI func code entry sym, and
12816 use the func descriptor sym instead if it is
12818 if (hash->elf.root.root.string[0] == '.'
12819 && hash->oh != NULL)
12821 fdh = ppc_follow_link (hash->oh);
12822 if (fdh->elf.root.type == bfd_link_hash_defined
12823 || fdh->elf.root.type == bfd_link_hash_defweak)
12825 sym_sec = fdh->elf.root.u.def.section;
12826 sym_value = fdh->elf.root.u.def.value;
12827 if (sym_sec->output_section != NULL)
12836 bfd_set_error (bfd_error_bad_value);
12837 goto error_ret_free_internal;
12844 sym_value += irela->r_addend;
12845 destination = (sym_value
12846 + sym_sec->output_offset
12847 + sym_sec->output_section->vma);
12848 local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12853 code_sec = sym_sec;
12854 code_value = sym_value;
12855 opd = get_opd_info (sym_sec);
12860 if (hash == NULL && opd->adjust != NULL)
12862 long adjust = opd->adjust[OPD_NDX (sym_value)];
12865 code_value += adjust;
12866 sym_value += adjust;
12868 dest = opd_entry_value (sym_sec, sym_value,
12869 &code_sec, &code_value, FALSE);
12870 if (dest != (bfd_vma) -1)
12872 destination = dest;
12875 /* Fixup old ABI sym to point at code
12877 hash->elf.root.type = bfd_link_hash_defweak;
12878 hash->elf.root.u.def.section = code_sec;
12879 hash->elf.root.u.def.value = code_value;
12884 /* Determine what (if any) linker stub is needed. */
12886 stub_type = ppc_type_of_stub (section, irela, &hash,
12887 &plt_ent, destination,
12890 if (r_type == R_PPC64_REL24_NOTOC)
12892 if (stub_type == ppc_stub_plt_call)
12893 stub_type = ppc_stub_plt_call_notoc;
12894 else if (stub_type == ppc_stub_long_branch
12895 || (code_sec != NULL
12896 && code_sec->output_section != NULL
12897 && (((hash ? hash->elf.other : sym->st_other)
12898 & STO_PPC64_LOCAL_MASK)
12899 > 1 << STO_PPC64_LOCAL_BIT)))
12900 stub_type = ppc_stub_long_branch_notoc;
12902 else if (stub_type != ppc_stub_plt_call)
12904 /* Check whether we need a TOC adjusting stub.
12905 Since the linker pastes together pieces from
12906 different object files when creating the
12907 _init and _fini functions, it may be that a
12908 call to what looks like a local sym is in
12909 fact a call needing a TOC adjustment. */
12910 if ((code_sec != NULL
12911 && code_sec->output_section != NULL
12912 && (htab->sec_info[code_sec->id].toc_off
12913 != htab->sec_info[section->id].toc_off)
12914 && (code_sec->has_toc_reloc
12915 || code_sec->makes_toc_func_call))
12916 || (((hash ? hash->elf.other : sym->st_other)
12917 & STO_PPC64_LOCAL_MASK)
12918 == 1 << STO_PPC64_LOCAL_BIT))
12919 stub_type = ppc_stub_long_branch_r2off;
12922 if (stub_type == ppc_stub_none)
12925 /* __tls_get_addr calls might be eliminated. */
12926 if (stub_type != ppc_stub_plt_call
12927 && stub_type != ppc_stub_plt_call_notoc
12929 && (hash == htab->tls_get_addr
12930 || hash == htab->tls_get_addr_fd)
12931 && section->has_tls_reloc
12932 && irela != internal_relocs)
12934 /* Get tls info. */
12935 unsigned char *tls_mask;
12937 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12938 irela - 1, input_bfd))
12939 goto error_ret_free_internal;
12940 if ((*tls_mask & TLS_TLS) != 0)
12944 if (stub_type == ppc_stub_plt_call)
12947 && htab->params->plt_localentry0 != 0
12948 && is_elfv2_localentry0 (&hash->elf))
12949 htab->has_plt_localentry0 = 1;
12950 else if (irela + 1 < irelaend
12951 && irela[1].r_offset == irela->r_offset + 4
12952 && (ELF64_R_TYPE (irela[1].r_info)
12953 == R_PPC64_TOCSAVE))
12955 if (!tocsave_find (htab, INSERT,
12956 &local_syms, irela + 1, input_bfd))
12957 goto error_ret_free_internal;
12960 stub_type = ppc_stub_plt_call_r2save;
12963 /* Support for grouping stub sections. */
12964 id_sec = htab->sec_info[section->id].u.group->link_sec;
12966 /* Get the name of this stub. */
12967 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12969 goto error_ret_free_internal;
12971 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12972 stub_name, FALSE, FALSE);
12973 if (stub_entry != NULL)
12975 enum ppc_stub_type old_type;
12976 /* A stub has already been created, but it may
12977 not be the required type. We shouldn't be
12978 transitioning from plt_call to long_branch
12979 stubs or vice versa, but we might be
12980 upgrading from plt_call to plt_call_r2save or
12981 from long_branch to long_branch_r2off. */
12983 old_type = stub_entry->stub_type;
12989 case ppc_stub_save_res:
12992 case ppc_stub_plt_call:
12993 case ppc_stub_plt_call_r2save:
12994 case ppc_stub_plt_call_notoc:
12995 case ppc_stub_plt_call_both:
12996 if (stub_type == ppc_stub_plt_call)
12998 else if (stub_type == ppc_stub_plt_call_r2save)
13000 if (old_type == ppc_stub_plt_call_notoc)
13001 stub_type = ppc_stub_plt_call_both;
13003 else if (stub_type == ppc_stub_plt_call_notoc)
13005 if (old_type == ppc_stub_plt_call_r2save)
13006 stub_type = ppc_stub_plt_call_both;
13012 case ppc_stub_plt_branch:
13013 case ppc_stub_plt_branch_r2off:
13014 case ppc_stub_plt_branch_notoc:
13015 case ppc_stub_plt_branch_both:
13016 old_type += (ppc_stub_long_branch
13017 - ppc_stub_plt_branch);
13018 /* Fall through. */
13019 case ppc_stub_long_branch:
13020 case ppc_stub_long_branch_r2off:
13021 case ppc_stub_long_branch_notoc:
13022 case ppc_stub_long_branch_both:
13023 if (stub_type == ppc_stub_long_branch)
13025 else if (stub_type == ppc_stub_long_branch_r2off)
13027 if (old_type == ppc_stub_long_branch_notoc)
13028 stub_type = ppc_stub_long_branch_both;
13030 else if (stub_type == ppc_stub_long_branch_notoc)
13032 if (old_type == ppc_stub_long_branch_r2off)
13033 stub_type = ppc_stub_long_branch_both;
13039 if (old_type < stub_type)
13040 stub_entry->stub_type = stub_type;
13044 stub_entry = ppc_add_stub (stub_name, section, info);
13045 if (stub_entry == NULL)
13048 error_ret_free_internal:
13049 if (elf_section_data (section)->relocs == NULL)
13050 free (internal_relocs);
13051 error_ret_free_local:
13052 if (local_syms != NULL
13053 && (symtab_hdr->contents
13054 != (unsigned char *) local_syms))
13059 stub_entry->stub_type = stub_type;
13060 if (stub_type >= ppc_stub_plt_call
13061 && stub_type <= ppc_stub_plt_call_both)
13063 stub_entry->target_value = sym_value;
13064 stub_entry->target_section = sym_sec;
13068 stub_entry->target_value = code_value;
13069 stub_entry->target_section = code_sec;
13071 stub_entry->h = hash;
13072 stub_entry->plt_ent = plt_ent;
13073 stub_entry->symtype
13074 = hash ? hash->elf.type : ELF_ST_TYPE (sym->st_info);
13075 stub_entry->other = hash ? hash->elf.other : sym->st_other;
13078 && (hash->elf.root.type == bfd_link_hash_defined
13079 || hash->elf.root.type == bfd_link_hash_defweak))
13080 htab->stub_globals += 1;
13083 /* We're done with the internal relocs, free them. */
13084 if (elf_section_data (section)->relocs != internal_relocs)
13085 free (internal_relocs);
13088 if (local_syms != NULL
13089 && symtab_hdr->contents != (unsigned char *) local_syms)
13091 if (!info->keep_memory)
13094 symtab_hdr->contents = (unsigned char *) local_syms;
13098 /* We may have added some stubs. Find out the new size of the
13100 for (group = htab->group; group != NULL; group = group->next)
13102 group->lr_restore = 0;
13103 group->eh_size = 0;
13104 if (group->stub_sec != NULL)
13106 asection *stub_sec = group->stub_sec;
13108 if (htab->stub_iteration <= STUB_SHRINK_ITER
13109 || stub_sec->rawsize < stub_sec->size)
13110 /* Past STUB_SHRINK_ITER, rawsize is the max size seen. */
13111 stub_sec->rawsize = stub_sec->size;
13112 stub_sec->size = 0;
13113 stub_sec->reloc_count = 0;
13114 stub_sec->flags &= ~SEC_RELOC;
13118 if (htab->stub_iteration <= STUB_SHRINK_ITER
13119 || htab->brlt->rawsize < htab->brlt->size)
13120 htab->brlt->rawsize = htab->brlt->size;
13121 htab->brlt->size = 0;
13122 htab->brlt->reloc_count = 0;
13123 htab->brlt->flags &= ~SEC_RELOC;
13124 if (htab->relbrlt != NULL)
13125 htab->relbrlt->size = 0;
13127 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
13129 for (group = htab->group; group != NULL; group = group->next)
13130 if (group->needs_save_res)
13131 group->stub_sec->size += htab->sfpr->size;
13133 if (info->emitrelocations
13134 && htab->glink != NULL && htab->glink->size != 0)
13136 htab->glink->reloc_count = 1;
13137 htab->glink->flags |= SEC_RELOC;
13140 if (htab->glink_eh_frame != NULL
13141 && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
13142 && htab->glink_eh_frame->output_section->size > 8)
13144 size_t size = 0, align = 4;
13146 for (group = htab->group; group != NULL; group = group->next)
13147 if (group->eh_size != 0)
13148 size += (group->eh_size + 17 + align - 1) & -align;
13149 if (htab->glink != NULL && htab->glink->size != 0)
13150 size += (24 + align - 1) & -align;
13152 size += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
13153 align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
13154 size = (size + align - 1) & -align;
13155 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
13156 htab->glink_eh_frame->size = size;
13159 if (htab->params->plt_stub_align != 0)
13160 for (group = htab->group; group != NULL; group = group->next)
13161 if (group->stub_sec != NULL)
13163 int align = abs (htab->params->plt_stub_align);
13164 group->stub_sec->size
13165 = (group->stub_sec->size + (1 << align) - 1) & -(1 << align);
13168 for (group = htab->group; group != NULL; group = group->next)
13169 if (group->stub_sec != NULL
13170 && group->stub_sec->rawsize != group->stub_sec->size
13171 && (htab->stub_iteration <= STUB_SHRINK_ITER
13172 || group->stub_sec->rawsize < group->stub_sec->size))
13176 && (htab->brlt->rawsize == htab->brlt->size
13177 || (htab->stub_iteration > STUB_SHRINK_ITER
13178 && htab->brlt->rawsize > htab->brlt->size))
13179 && (htab->glink_eh_frame == NULL
13180 || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
13183 /* Ask the linker to do its stuff. */
13184 (*htab->params->layout_sections_again) ();
13187 if (htab->glink_eh_frame != NULL
13188 && htab->glink_eh_frame->size != 0)
13191 bfd_byte *p, *last_fde;
13192 size_t last_fde_len, size, align, pad;
13193 struct map_stub *group;
13195 /* It is necessary to at least have a rough outline of the
13196 linker generated CIEs and FDEs written before
13197 bfd_elf_discard_info is run, in order for these FDEs to be
13198 indexed in .eh_frame_hdr. */
13199 p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
13202 htab->glink_eh_frame->contents = p;
13206 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
13207 /* CIE length (rewrite in case little-endian). */
13208 last_fde_len = ((sizeof (glink_eh_frame_cie) + align - 1) & -align) - 4;
13209 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
13210 p += last_fde_len + 4;
13212 for (group = htab->group; group != NULL; group = group->next)
13213 if (group->eh_size != 0)
13215 group->eh_base = p - htab->glink_eh_frame->contents;
13217 last_fde_len = ((group->eh_size + 17 + align - 1) & -align) - 4;
13219 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
13222 val = p - htab->glink_eh_frame->contents;
13223 bfd_put_32 (htab->elf.dynobj, val, p);
13225 /* Offset to stub section, written later. */
13227 /* stub section size. */
13228 bfd_put_32 (htab->elf.dynobj, group->stub_sec->size, p);
13230 /* Augmentation. */
13232 /* Make sure we don't have all nops. This is enough for
13233 elf-eh-frame.c to detect the last non-nop opcode. */
13234 p[group->eh_size - 1] = DW_CFA_advance_loc + 1;
13235 p = last_fde + last_fde_len + 4;
13237 if (htab->glink != NULL && htab->glink->size != 0)
13240 last_fde_len = ((24 + align - 1) & -align) - 4;
13242 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
13245 val = p - htab->glink_eh_frame->contents;
13246 bfd_put_32 (htab->elf.dynobj, val, p);
13248 /* Offset to .glink, written later. */
13251 bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
13253 /* Augmentation. */
13256 *p++ = DW_CFA_advance_loc + 1;
13257 *p++ = DW_CFA_register;
13259 *p++ = htab->opd_abi ? 12 : 0;
13260 *p++ = DW_CFA_advance_loc + (htab->opd_abi ? 5 : 7);
13261 *p++ = DW_CFA_restore_extended;
13263 p += ((24 + align - 1) & -align) - 24;
13265 /* Subsume any padding into the last FDE if user .eh_frame
13266 sections are aligned more than glink_eh_frame. Otherwise any
13267 zero padding will be seen as a terminator. */
13268 align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
13269 size = p - htab->glink_eh_frame->contents;
13270 pad = ((size + align - 1) & -align) - size;
13271 htab->glink_eh_frame->size = size + pad;
13272 bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
13275 maybe_strip_output (info, htab->brlt);
13276 if (htab->glink_eh_frame != NULL)
13277 maybe_strip_output (info, htab->glink_eh_frame);
13282 /* Called after we have determined section placement. If sections
13283 move, we'll be called again. Provide a value for TOCstart. */
13286 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
13289 bfd_vma TOCstart, adjust;
13293 struct elf_link_hash_entry *h;
13294 struct elf_link_hash_table *htab = elf_hash_table (info);
13296 if (is_elf_hash_table (htab)
13297 && htab->hgot != NULL)
13301 h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
13302 if (is_elf_hash_table (htab))
13306 && h->root.type == bfd_link_hash_defined
13307 && !h->root.linker_def
13308 && (!is_elf_hash_table (htab)
13309 || h->def_regular))
13311 TOCstart = (h->root.u.def.value - TOC_BASE_OFF
13312 + h->root.u.def.section->output_offset
13313 + h->root.u.def.section->output_section->vma);
13314 _bfd_set_gp_value (obfd, TOCstart);
13319 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
13320 order. The TOC starts where the first of these sections starts. */
13321 s = bfd_get_section_by_name (obfd, ".got");
13322 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13323 s = bfd_get_section_by_name (obfd, ".toc");
13324 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13325 s = bfd_get_section_by_name (obfd, ".tocbss");
13326 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13327 s = bfd_get_section_by_name (obfd, ".plt");
13328 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13330 /* This may happen for
13331 o references to TOC base (SYM@toc / TOC[tc0]) without a
13333 o bad linker script
13334 o --gc-sections and empty TOC sections
13336 FIXME: Warn user? */
13338 /* Look for a likely section. We probably won't even be
13340 for (s = obfd->sections; s != NULL; s = s->next)
13341 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
13343 == (SEC_ALLOC | SEC_SMALL_DATA))
13346 for (s = obfd->sections; s != NULL; s = s->next)
13347 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
13348 == (SEC_ALLOC | SEC_SMALL_DATA))
13351 for (s = obfd->sections; s != NULL; s = s->next)
13352 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
13356 for (s = obfd->sections; s != NULL; s = s->next)
13357 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
13363 TOCstart = s->output_section->vma + s->output_offset;
13365 /* Force alignment. */
13366 adjust = TOCstart & (TOC_BASE_ALIGN - 1);
13367 TOCstart -= adjust;
13368 _bfd_set_gp_value (obfd, TOCstart);
13370 if (info != NULL && s != NULL)
13372 struct ppc_link_hash_table *htab = ppc_hash_table (info);
13376 if (htab->elf.hgot != NULL)
13378 htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
13379 htab->elf.hgot->root.u.def.section = s;
13384 struct bfd_link_hash_entry *bh = NULL;
13385 _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
13386 s, TOC_BASE_OFF - adjust,
13387 NULL, FALSE, FALSE, &bh);
13393 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
13394 write out any global entry stubs, and PLT relocations. */
13397 build_global_entry_stubs_and_plt (struct elf_link_hash_entry *h, void *inf)
13399 struct bfd_link_info *info;
13400 struct ppc_link_hash_table *htab;
13401 struct plt_entry *ent;
13404 if (h->root.type == bfd_link_hash_indirect)
13408 htab = ppc_hash_table (info);
13412 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
13413 if (ent->plt.offset != (bfd_vma) -1)
13415 /* This symbol has an entry in the procedure linkage
13416 table. Set it up. */
13417 Elf_Internal_Rela rela;
13418 asection *plt, *relplt;
13421 if (!htab->elf.dynamic_sections_created
13422 || h->dynindx == -1)
13424 if (!(h->def_regular
13425 && (h->root.type == bfd_link_hash_defined
13426 || h->root.type == bfd_link_hash_defweak)))
13428 if (h->type == STT_GNU_IFUNC)
13430 plt = htab->elf.iplt;
13431 relplt = htab->elf.irelplt;
13432 htab->local_ifunc_resolver = 1;
13434 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
13436 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13440 plt = htab->pltlocal;
13441 if (bfd_link_pic (info))
13443 relplt = htab->relpltlocal;
13445 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_SLOT);
13447 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13452 rela.r_addend = (h->root.u.def.value
13453 + h->root.u.def.section->output_offset
13454 + h->root.u.def.section->output_section->vma
13457 if (relplt == NULL)
13459 loc = plt->contents + ent->plt.offset;
13460 bfd_put_64 (info->output_bfd, rela.r_addend, loc);
13463 bfd_vma toc = elf_gp (info->output_bfd);
13464 toc += htab->sec_info[h->root.u.def.section->id].toc_off;
13465 bfd_put_64 (info->output_bfd, toc, loc + 8);
13470 rela.r_offset = (plt->output_section->vma
13471 + plt->output_offset
13472 + ent->plt.offset);
13473 loc = relplt->contents + (relplt->reloc_count++
13474 * sizeof (Elf64_External_Rela));
13475 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13480 rela.r_offset = (htab->elf.splt->output_section->vma
13481 + htab->elf.splt->output_offset
13482 + ent->plt.offset);
13483 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
13484 rela.r_addend = ent->addend;
13485 loc = (htab->elf.srelplt->contents
13486 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
13487 / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
13488 if (h->type == STT_GNU_IFUNC && is_static_defined (h))
13489 htab->maybe_local_ifunc_resolver = 1;
13490 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13494 if (!h->pointer_equality_needed)
13497 if (h->def_regular)
13500 s = htab->global_entry;
13501 if (s == NULL || s->size == 0)
13504 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
13505 if (ent->plt.offset != (bfd_vma) -1
13506 && ent->addend == 0)
13512 p = s->contents + h->root.u.def.value;
13513 plt = htab->elf.splt;
13514 if (!htab->elf.dynamic_sections_created
13515 || h->dynindx == -1)
13517 if (h->type == STT_GNU_IFUNC)
13518 plt = htab->elf.iplt;
13520 plt = htab->pltlocal;
13522 off = ent->plt.offset + plt->output_offset + plt->output_section->vma;
13523 off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
13525 if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
13527 info->callbacks->einfo
13528 (_("%P: linkage table error against `%pT'\n"),
13529 h->root.root.string);
13530 bfd_set_error (bfd_error_bad_value);
13531 htab->stub_error = TRUE;
13534 htab->stub_count[ppc_stub_global_entry - 1] += 1;
13535 if (htab->params->emit_stub_syms)
13537 size_t len = strlen (h->root.root.string);
13538 char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
13543 sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
13544 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
13547 if (h->root.type == bfd_link_hash_new)
13549 h->root.type = bfd_link_hash_defined;
13550 h->root.u.def.section = s;
13551 h->root.u.def.value = p - s->contents;
13552 h->ref_regular = 1;
13553 h->def_regular = 1;
13554 h->ref_regular_nonweak = 1;
13555 h->forced_local = 1;
13557 h->root.linker_def = 1;
13561 if (PPC_HA (off) != 0)
13563 bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
13566 bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
13568 bfd_put_32 (s->owner, MTCTR_R12, p);
13570 bfd_put_32 (s->owner, BCTR, p);
13576 /* Write PLT relocs for locals. */
13579 write_plt_relocs_for_local_syms (struct bfd_link_info *info)
13581 struct ppc_link_hash_table *htab = ppc_hash_table (info);
13584 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
13586 struct got_entry **lgot_ents, **end_lgot_ents;
13587 struct plt_entry **local_plt, **lplt, **end_local_plt;
13588 Elf_Internal_Shdr *symtab_hdr;
13589 bfd_size_type locsymcount;
13590 Elf_Internal_Sym *local_syms = NULL;
13591 struct plt_entry *ent;
13593 if (!is_ppc64_elf (ibfd))
13596 lgot_ents = elf_local_got_ents (ibfd);
13600 symtab_hdr = &elf_symtab_hdr (ibfd);
13601 locsymcount = symtab_hdr->sh_info;
13602 end_lgot_ents = lgot_ents + locsymcount;
13603 local_plt = (struct plt_entry **) end_lgot_ents;
13604 end_local_plt = local_plt + locsymcount;
13605 for (lplt = local_plt; lplt < end_local_plt; ++lplt)
13606 for (ent = *lplt; ent != NULL; ent = ent->next)
13607 if (ent->plt.offset != (bfd_vma) -1)
13609 Elf_Internal_Sym *sym;
13611 asection *plt, *relplt;
13615 if (!get_sym_h (NULL, &sym, &sym_sec, NULL, &local_syms,
13616 lplt - local_plt, ibfd))
13618 if (local_syms != NULL
13619 && symtab_hdr->contents != (unsigned char *) local_syms)
13624 val = sym->st_value + ent->addend;
13625 if (ELF_ST_TYPE (sym->st_info) != STT_GNU_IFUNC)
13626 val += PPC64_LOCAL_ENTRY_OFFSET (sym->st_other);
13627 if (sym_sec != NULL && sym_sec->output_section != NULL)
13628 val += sym_sec->output_offset + sym_sec->output_section->vma;
13630 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13632 htab->local_ifunc_resolver = 1;
13633 plt = htab->elf.iplt;
13634 relplt = htab->elf.irelplt;
13638 plt = htab->pltlocal;
13639 relplt = bfd_link_pic (info) ? htab->relpltlocal : NULL;
13642 if (relplt == NULL)
13644 loc = plt->contents + ent->plt.offset;
13645 bfd_put_64 (info->output_bfd, val, loc);
13648 bfd_vma toc = elf_gp (ibfd);
13649 bfd_put_64 (info->output_bfd, toc, loc + 8);
13654 Elf_Internal_Rela rela;
13655 rela.r_offset = (ent->plt.offset
13656 + plt->output_offset
13657 + plt->output_section->vma);
13658 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13661 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
13663 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13668 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_SLOT);
13670 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13672 rela.r_addend = val;
13673 loc = relplt->contents + (relplt->reloc_count++
13674 * sizeof (Elf64_External_Rela));
13675 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13679 if (local_syms != NULL
13680 && symtab_hdr->contents != (unsigned char *) local_syms)
13682 if (!info->keep_memory)
13685 symtab_hdr->contents = (unsigned char *) local_syms;
13691 /* Build all the stubs associated with the current output file.
13692 The stubs are kept in a hash table attached to the main linker
13693 hash table. This function is called via gldelf64ppc_finish. */
13696 ppc64_elf_build_stubs (struct bfd_link_info *info,
13699 struct ppc_link_hash_table *htab = ppc_hash_table (info);
13700 struct map_stub *group;
13701 asection *stub_sec;
13703 int stub_sec_count = 0;
13708 /* Allocate memory to hold the linker stubs. */
13709 for (group = htab->group; group != NULL; group = group->next)
13711 group->eh_size = 0;
13712 group->lr_restore = 0;
13713 if ((stub_sec = group->stub_sec) != NULL
13714 && stub_sec->size != 0)
13716 stub_sec->contents = bfd_zalloc (htab->params->stub_bfd,
13718 if (stub_sec->contents == NULL)
13720 stub_sec->size = 0;
13724 if (htab->glink != NULL && htab->glink->size != 0)
13729 /* Build the .glink plt call stub. */
13730 if (htab->params->emit_stub_syms)
13732 struct elf_link_hash_entry *h;
13733 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
13734 TRUE, FALSE, FALSE);
13737 if (h->root.type == bfd_link_hash_new)
13739 h->root.type = bfd_link_hash_defined;
13740 h->root.u.def.section = htab->glink;
13741 h->root.u.def.value = 8;
13742 h->ref_regular = 1;
13743 h->def_regular = 1;
13744 h->ref_regular_nonweak = 1;
13745 h->forced_local = 1;
13747 h->root.linker_def = 1;
13750 plt0 = (htab->elf.splt->output_section->vma
13751 + htab->elf.splt->output_offset
13753 if (info->emitrelocations)
13755 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
13758 r->r_offset = (htab->glink->output_offset
13759 + htab->glink->output_section->vma);
13760 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
13761 r->r_addend = plt0;
13763 p = htab->glink->contents;
13764 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
13765 bfd_put_64 (htab->glink->owner, plt0, p);
13769 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
13771 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13773 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13775 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13777 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
13779 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13781 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13783 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
13785 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13787 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
13792 bfd_put_32 (htab->glink->owner, MFLR_R0, p);
13794 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13796 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13798 bfd_put_32 (htab->glink->owner, STD_R2_0R1 + 24, p);
13800 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13802 bfd_put_32 (htab->glink->owner, MTLR_R0, p);
13804 bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
13806 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13808 bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
13810 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13812 bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
13814 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13816 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13819 bfd_put_32 (htab->glink->owner, BCTR, p);
13821 BFD_ASSERT (p == htab->glink->contents + GLINK_PLTRESOLVE_SIZE (htab));
13823 /* Build the .glink lazy link call stubs. */
13825 while (p < htab->glink->contents + htab->glink->size)
13831 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13836 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13838 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13843 bfd_put_32 (htab->glink->owner,
13844 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13850 /* Build .glink global entry stubs, and PLT relocs for globals. */
13851 elf_link_hash_traverse (&htab->elf, build_global_entry_stubs_and_plt, info);
13853 if (!write_plt_relocs_for_local_syms (info))
13856 if (htab->brlt != NULL && htab->brlt->size != 0)
13858 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13860 if (htab->brlt->contents == NULL)
13863 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13865 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13866 htab->relbrlt->size);
13867 if (htab->relbrlt->contents == NULL)
13871 /* Build the stubs as directed by the stub hash table. */
13872 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13874 for (group = htab->group; group != NULL; group = group->next)
13875 if (group->needs_save_res)
13876 group->stub_sec->size += htab->sfpr->size;
13878 if (htab->relbrlt != NULL)
13879 htab->relbrlt->reloc_count = 0;
13881 if (htab->params->plt_stub_align != 0)
13882 for (group = htab->group; group != NULL; group = group->next)
13883 if ((stub_sec = group->stub_sec) != NULL)
13885 int align = abs (htab->params->plt_stub_align);
13886 stub_sec->size = (stub_sec->size + (1 << align) - 1) & -(1 << align);
13889 for (group = htab->group; group != NULL; group = group->next)
13890 if (group->needs_save_res)
13892 stub_sec = group->stub_sec;
13893 memcpy (stub_sec->contents + stub_sec->size - htab->sfpr->size,
13894 htab->sfpr->contents, htab->sfpr->size);
13895 if (htab->params->emit_stub_syms)
13899 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13900 if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13905 if (htab->glink_eh_frame != NULL
13906 && htab->glink_eh_frame->size != 0)
13911 p = htab->glink_eh_frame->contents;
13912 p += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
13914 for (group = htab->group; group != NULL; group = group->next)
13915 if (group->eh_size != 0)
13917 /* Offset to stub section. */
13918 val = (group->stub_sec->output_section->vma
13919 + group->stub_sec->output_offset);
13920 val -= (htab->glink_eh_frame->output_section->vma
13921 + htab->glink_eh_frame->output_offset
13922 + (p + 8 - htab->glink_eh_frame->contents));
13923 if (val + 0x80000000 > 0xffffffff)
13926 (_("%s offset too large for .eh_frame sdata4 encoding"),
13927 group->stub_sec->name);
13930 bfd_put_32 (htab->elf.dynobj, val, p + 8);
13931 p += (group->eh_size + 17 + 3) & -4;
13933 if (htab->glink != NULL && htab->glink->size != 0)
13935 /* Offset to .glink. */
13936 val = (htab->glink->output_section->vma
13937 + htab->glink->output_offset
13939 val -= (htab->glink_eh_frame->output_section->vma
13940 + htab->glink_eh_frame->output_offset
13941 + (p + 8 - htab->glink_eh_frame->contents));
13942 if (val + 0x80000000 > 0xffffffff)
13945 (_("%s offset too large for .eh_frame sdata4 encoding"),
13946 htab->glink->name);
13949 bfd_put_32 (htab->elf.dynobj, val, p + 8);
13950 p += (24 + align - 1) & -align;
13954 for (group = htab->group; group != NULL; group = group->next)
13955 if ((stub_sec = group->stub_sec) != NULL)
13957 stub_sec_count += 1;
13958 if (stub_sec->rawsize != stub_sec->size
13959 && (htab->stub_iteration <= STUB_SHRINK_ITER
13960 || stub_sec->rawsize < stub_sec->size))
13966 htab->stub_error = TRUE;
13967 _bfd_error_handler (_("stubs don't match calculated size"));
13970 if (htab->stub_error)
13976 *stats = bfd_malloc (500);
13977 if (*stats == NULL)
13980 len = sprintf (*stats,
13981 ngettext ("linker stubs in %u group\n",
13982 "linker stubs in %u groups\n",
13985 sprintf (*stats + len, _(" branch %lu\n"
13986 " branch toc adj %lu\n"
13987 " branch notoc %lu\n"
13988 " branch both %lu\n"
13989 " long branch %lu\n"
13990 " long toc adj %lu\n"
13991 " long notoc %lu\n"
13994 " plt call save %lu\n"
13995 " plt call notoc %lu\n"
13996 " plt call both %lu\n"
13997 " global entry %lu"),
13998 htab->stub_count[ppc_stub_long_branch - 1],
13999 htab->stub_count[ppc_stub_long_branch_r2off - 1],
14000 htab->stub_count[ppc_stub_long_branch_notoc - 1],
14001 htab->stub_count[ppc_stub_long_branch_both - 1],
14002 htab->stub_count[ppc_stub_plt_branch - 1],
14003 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
14004 htab->stub_count[ppc_stub_plt_branch_notoc - 1],
14005 htab->stub_count[ppc_stub_plt_branch_both - 1],
14006 htab->stub_count[ppc_stub_plt_call - 1],
14007 htab->stub_count[ppc_stub_plt_call_r2save - 1],
14008 htab->stub_count[ppc_stub_plt_call_notoc - 1],
14009 htab->stub_count[ppc_stub_plt_call_both - 1],
14010 htab->stub_count[ppc_stub_global_entry - 1]);
14015 /* What to do when ld finds relocations against symbols defined in
14016 discarded sections. */
14018 static unsigned int
14019 ppc64_elf_action_discarded (asection *sec)
14021 if (strcmp (".opd", sec->name) == 0)
14024 if (strcmp (".toc", sec->name) == 0)
14027 if (strcmp (".toc1", sec->name) == 0)
14030 return _bfd_elf_default_action_discarded (sec);
14033 /* The RELOCATE_SECTION function is called by the ELF backend linker
14034 to handle the relocations for a section.
14036 The relocs are always passed as Rela structures; if the section
14037 actually uses Rel structures, the r_addend field will always be
14040 This function is responsible for adjust the section contents as
14041 necessary, and (if using Rela relocs and generating a
14042 relocatable output file) adjusting the reloc addend as
14045 This function does not have to worry about setting the reloc
14046 address or the reloc symbol index.
14048 LOCAL_SYMS is a pointer to the swapped in local symbols.
14050 LOCAL_SECTIONS is an array giving the section in the input file
14051 corresponding to the st_shndx field of each local symbol.
14053 The global hash table entry for the global symbols can be found
14054 via elf_sym_hashes (input_bfd).
14056 When generating relocatable output, this function must handle
14057 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
14058 going to be the section symbol corresponding to the output
14059 section, which means that the addend must be adjusted
14063 ppc64_elf_relocate_section (bfd *output_bfd,
14064 struct bfd_link_info *info,
14066 asection *input_section,
14067 bfd_byte *contents,
14068 Elf_Internal_Rela *relocs,
14069 Elf_Internal_Sym *local_syms,
14070 asection **local_sections)
14072 struct ppc_link_hash_table *htab;
14073 Elf_Internal_Shdr *symtab_hdr;
14074 struct elf_link_hash_entry **sym_hashes;
14075 Elf_Internal_Rela *rel;
14076 Elf_Internal_Rela *wrel;
14077 Elf_Internal_Rela *relend;
14078 Elf_Internal_Rela outrel;
14080 struct got_entry **local_got_ents;
14082 bfd_boolean ret = TRUE;
14083 bfd_boolean is_opd;
14084 /* Assume 'at' branch hints. */
14085 bfd_boolean is_isa_v2 = TRUE;
14086 bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
14088 /* Initialize howto table if needed. */
14089 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
14092 htab = ppc_hash_table (info);
14096 /* Don't relocate stub sections. */
14097 if (input_section->owner == htab->params->stub_bfd)
14100 if (!is_ppc64_elf (input_bfd))
14102 bfd_set_error (bfd_error_wrong_format);
14106 local_got_ents = elf_local_got_ents (input_bfd);
14107 TOCstart = elf_gp (output_bfd);
14108 symtab_hdr = &elf_symtab_hdr (input_bfd);
14109 sym_hashes = elf_sym_hashes (input_bfd);
14110 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
14112 rel = wrel = relocs;
14113 relend = relocs + input_section->reloc_count;
14114 for (; rel < relend; wrel++, rel++)
14116 enum elf_ppc64_reloc_type r_type;
14118 bfd_reloc_status_type r;
14119 Elf_Internal_Sym *sym;
14121 struct elf_link_hash_entry *h_elf;
14122 struct ppc_link_hash_entry *h;
14123 struct ppc_link_hash_entry *fdh;
14124 const char *sym_name;
14125 unsigned long r_symndx, toc_symndx;
14126 bfd_vma toc_addend;
14127 unsigned char tls_mask, tls_gd, tls_type;
14128 unsigned char sym_type;
14129 bfd_vma relocation;
14130 bfd_boolean unresolved_reloc, save_unresolved_reloc;
14131 bfd_boolean warned;
14132 enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
14135 struct ppc_stub_hash_entry *stub_entry;
14136 bfd_vma max_br_offset;
14138 Elf_Internal_Rela orig_rel;
14139 reloc_howto_type *howto;
14140 struct reloc_howto_struct alt_howto;
14147 r_type = ELF64_R_TYPE (rel->r_info);
14148 r_symndx = ELF64_R_SYM (rel->r_info);
14150 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
14151 symbol of the previous ADDR64 reloc. The symbol gives us the
14152 proper TOC base to use. */
14153 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
14155 && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
14157 r_symndx = ELF64_R_SYM (wrel[-1].r_info);
14163 unresolved_reloc = FALSE;
14166 if (r_symndx < symtab_hdr->sh_info)
14168 /* It's a local symbol. */
14169 struct _opd_sec_data *opd;
14171 sym = local_syms + r_symndx;
14172 sec = local_sections[r_symndx];
14173 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
14174 sym_type = ELF64_ST_TYPE (sym->st_info);
14175 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
14176 opd = get_opd_info (sec);
14177 if (opd != NULL && opd->adjust != NULL)
14179 long adjust = opd->adjust[OPD_NDX (sym->st_value
14185 /* If this is a relocation against the opd section sym
14186 and we have edited .opd, adjust the reloc addend so
14187 that ld -r and ld --emit-relocs output is correct.
14188 If it is a reloc against some other .opd symbol,
14189 then the symbol value will be adjusted later. */
14190 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
14191 rel->r_addend += adjust;
14193 relocation += adjust;
14199 bfd_boolean ignored;
14201 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
14202 r_symndx, symtab_hdr, sym_hashes,
14203 h_elf, sec, relocation,
14204 unresolved_reloc, warned, ignored);
14205 sym_name = h_elf->root.root.string;
14206 sym_type = h_elf->type;
14208 && sec->owner == output_bfd
14209 && strcmp (sec->name, ".opd") == 0)
14211 /* This is a symbol defined in a linker script. All
14212 such are defined in output sections, even those
14213 defined by simple assignment from a symbol defined in
14214 an input section. Transfer the symbol to an
14215 appropriate input .opd section, so that a branch to
14216 this symbol will be mapped to the location specified
14217 by the opd entry. */
14218 struct bfd_link_order *lo;
14219 for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
14220 if (lo->type == bfd_indirect_link_order)
14222 asection *isec = lo->u.indirect.section;
14223 if (h_elf->root.u.def.value >= isec->output_offset
14224 && h_elf->root.u.def.value < (isec->output_offset
14227 h_elf->root.u.def.value -= isec->output_offset;
14228 h_elf->root.u.def.section = isec;
14235 h = (struct ppc_link_hash_entry *) h_elf;
14237 if (sec != NULL && discarded_section (sec))
14239 _bfd_clear_contents (ppc64_elf_howto_table[r_type],
14240 input_bfd, input_section,
14241 contents, rel->r_offset);
14242 wrel->r_offset = rel->r_offset;
14244 wrel->r_addend = 0;
14246 /* For ld -r, remove relocations in debug sections against
14247 symbols defined in discarded sections. Not done for
14248 non-debug to preserve relocs in .eh_frame which the
14249 eh_frame editing code expects to be present. */
14250 if (bfd_link_relocatable (info)
14251 && (input_section->flags & SEC_DEBUGGING))
14257 if (bfd_link_relocatable (info))
14260 if (h != NULL && &h->elf == htab->elf.hgot)
14262 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
14263 sec = bfd_abs_section_ptr;
14264 unresolved_reloc = FALSE;
14267 /* TLS optimizations. Replace instruction sequences and relocs
14268 based on information we collected in tls_optimize. We edit
14269 RELOCS so that --emit-relocs will output something sensible
14270 for the final instruction stream. */
14275 tls_mask = h->tls_mask;
14276 else if (local_got_ents != NULL)
14278 struct plt_entry **local_plt = (struct plt_entry **)
14279 (local_got_ents + symtab_hdr->sh_info);
14280 unsigned char *lgot_masks = (unsigned char *)
14281 (local_plt + symtab_hdr->sh_info);
14282 tls_mask = lgot_masks[r_symndx];
14284 if (((tls_mask & TLS_TLS) == 0 || tls_mask == (TLS_TLS | TLS_MARK))
14285 && (r_type == R_PPC64_TLS
14286 || r_type == R_PPC64_TLSGD
14287 || r_type == R_PPC64_TLSLD))
14289 /* Check for toc tls entries. */
14290 unsigned char *toc_tls;
14292 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
14293 &local_syms, rel, input_bfd))
14297 tls_mask = *toc_tls;
14300 /* Check that tls relocs are used with tls syms, and non-tls
14301 relocs are used with non-tls syms. */
14302 if (r_symndx != STN_UNDEF
14303 && r_type != R_PPC64_NONE
14305 || h->elf.root.type == bfd_link_hash_defined
14306 || h->elf.root.type == bfd_link_hash_defweak)
14307 && (IS_PPC64_TLS_RELOC (r_type)
14308 != (sym_type == STT_TLS
14309 || (sym_type == STT_SECTION
14310 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
14312 if ((tls_mask & TLS_TLS) != 0
14313 && (r_type == R_PPC64_TLS
14314 || r_type == R_PPC64_TLSGD
14315 || r_type == R_PPC64_TLSLD))
14316 /* R_PPC64_TLS is OK against a symbol in the TOC. */
14319 info->callbacks->einfo
14320 (!IS_PPC64_TLS_RELOC (r_type)
14321 /* xgettext:c-format */
14322 ? _("%H: %s used with TLS symbol `%pT'\n")
14323 /* xgettext:c-format */
14324 : _("%H: %s used with non-TLS symbol `%pT'\n"),
14325 input_bfd, input_section, rel->r_offset,
14326 ppc64_elf_howto_table[r_type]->name,
14330 /* Ensure reloc mapping code below stays sane. */
14331 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
14332 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
14333 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
14334 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
14335 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
14336 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
14337 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
14338 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
14339 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
14340 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
14348 case R_PPC64_LO_DS_OPT:
14349 insn = bfd_get_32 (input_bfd, contents + rel->r_offset - d_offset);
14350 if ((insn & (0x3f << 26)) != 58u << 26)
14352 insn += (14u << 26) - (58u << 26);
14353 bfd_put_32 (input_bfd, insn, contents + rel->r_offset - d_offset);
14354 r_type = R_PPC64_TOC16_LO;
14355 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14358 case R_PPC64_TOC16:
14359 case R_PPC64_TOC16_LO:
14360 case R_PPC64_TOC16_DS:
14361 case R_PPC64_TOC16_LO_DS:
14363 /* Check for toc tls entries. */
14364 unsigned char *toc_tls;
14367 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
14368 &local_syms, rel, input_bfd);
14374 tls_mask = *toc_tls;
14375 if (r_type == R_PPC64_TOC16_DS
14376 || r_type == R_PPC64_TOC16_LO_DS)
14378 if ((tls_mask & TLS_TLS) != 0
14379 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
14384 /* If we found a GD reloc pair, then we might be
14385 doing a GD->IE transition. */
14389 if ((tls_mask & TLS_TLS) != 0
14390 && (tls_mask & TLS_GD) == 0)
14393 else if (retval == 3)
14395 if ((tls_mask & TLS_TLS) != 0
14396 && (tls_mask & TLS_LD) == 0)
14404 case R_PPC64_GOT_TPREL16_HI:
14405 case R_PPC64_GOT_TPREL16_HA:
14406 if ((tls_mask & TLS_TLS) != 0
14407 && (tls_mask & TLS_TPREL) == 0)
14409 rel->r_offset -= d_offset;
14410 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14411 r_type = R_PPC64_NONE;
14412 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14416 case R_PPC64_GOT_TPREL16_DS:
14417 case R_PPC64_GOT_TPREL16_LO_DS:
14418 if ((tls_mask & TLS_TLS) != 0
14419 && (tls_mask & TLS_TPREL) == 0)
14422 insn = bfd_get_32 (input_bfd,
14423 contents + rel->r_offset - d_offset);
14425 insn |= 0x3c0d0000; /* addis 0,13,0 */
14426 bfd_put_32 (input_bfd, insn,
14427 contents + rel->r_offset - d_offset);
14428 r_type = R_PPC64_TPREL16_HA;
14429 if (toc_symndx != 0)
14431 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
14432 rel->r_addend = toc_addend;
14433 /* We changed the symbol. Start over in order to
14434 get h, sym, sec etc. right. */
14438 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14443 if ((tls_mask & TLS_TLS) != 0
14444 && (tls_mask & TLS_TPREL) == 0)
14446 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14447 insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
14450 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14451 /* Was PPC64_TLS which sits on insn boundary, now
14452 PPC64_TPREL16_LO which is at low-order half-word. */
14453 rel->r_offset += d_offset;
14454 r_type = R_PPC64_TPREL16_LO;
14455 if (toc_symndx != 0)
14457 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
14458 rel->r_addend = toc_addend;
14459 /* We changed the symbol. Start over in order to
14460 get h, sym, sec etc. right. */
14464 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14468 case R_PPC64_GOT_TLSGD16_HI:
14469 case R_PPC64_GOT_TLSGD16_HA:
14471 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
14475 case R_PPC64_GOT_TLSLD16_HI:
14476 case R_PPC64_GOT_TLSLD16_HA:
14477 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
14480 if ((tls_mask & tls_gd) != 0)
14481 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
14482 + R_PPC64_GOT_TPREL16_DS);
14485 rel->r_offset -= d_offset;
14486 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14487 r_type = R_PPC64_NONE;
14489 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14493 case R_PPC64_GOT_TLSGD16:
14494 case R_PPC64_GOT_TLSGD16_LO:
14496 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
14500 case R_PPC64_GOT_TLSLD16:
14501 case R_PPC64_GOT_TLSLD16_LO:
14502 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
14504 unsigned int insn1, insn2;
14507 offset = (bfd_vma) -1;
14508 /* If not using the newer R_PPC64_TLSGD/LD to mark
14509 __tls_get_addr calls, we must trust that the call
14510 stays with its arg setup insns, ie. that the next
14511 reloc is the __tls_get_addr call associated with
14512 the current reloc. Edit both insns. */
14513 if (input_section->has_tls_get_addr_call
14514 && rel + 1 < relend
14515 && branch_reloc_hash_match (input_bfd, rel + 1,
14516 htab->tls_get_addr,
14517 htab->tls_get_addr_fd))
14518 offset = rel[1].r_offset;
14519 /* We read the low GOT_TLS (or TOC16) insn because we
14520 need to keep the destination reg. It may be
14521 something other than the usual r3, and moved to r3
14522 before the call by intervening code. */
14523 insn1 = bfd_get_32 (input_bfd,
14524 contents + rel->r_offset - d_offset);
14525 if ((tls_mask & tls_gd) != 0)
14528 insn1 &= (0x1f << 21) | (0x1f << 16);
14529 insn1 |= 58 << 26; /* ld */
14530 insn2 = 0x7c636a14; /* add 3,3,13 */
14531 if (offset != (bfd_vma) -1)
14532 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14533 if (r_type == R_PPC64_TOC16
14534 || r_type == R_PPC64_TOC16_LO)
14535 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
14537 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 1)) & 1)
14538 + R_PPC64_GOT_TPREL16_DS);
14539 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14544 insn1 &= 0x1f << 21;
14545 insn1 |= 0x3c0d0000; /* addis r,13,0 */
14546 insn2 = 0x38630000; /* addi 3,3,0 */
14549 /* Was an LD reloc. */
14551 sec = local_sections[toc_symndx];
14553 r_symndx < symtab_hdr->sh_info;
14555 if (local_sections[r_symndx] == sec)
14557 if (r_symndx >= symtab_hdr->sh_info)
14558 r_symndx = STN_UNDEF;
14559 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
14560 if (r_symndx != STN_UNDEF)
14561 rel->r_addend -= (local_syms[r_symndx].st_value
14562 + sec->output_offset
14563 + sec->output_section->vma);
14565 else if (toc_symndx != 0)
14567 r_symndx = toc_symndx;
14568 rel->r_addend = toc_addend;
14570 r_type = R_PPC64_TPREL16_HA;
14571 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14572 if (offset != (bfd_vma) -1)
14574 rel[1].r_info = ELF64_R_INFO (r_symndx,
14575 R_PPC64_TPREL16_LO);
14576 rel[1].r_offset = offset + d_offset;
14577 rel[1].r_addend = rel->r_addend;
14580 bfd_put_32 (input_bfd, insn1,
14581 contents + rel->r_offset - d_offset);
14582 if (offset != (bfd_vma) -1)
14584 bfd_put_32 (input_bfd, insn2, contents + offset);
14585 if (offset + 8 <= input_section->size)
14587 insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
14588 if (insn2 == LD_R2_0R1 + STK_TOC (htab))
14589 bfd_put_32 (input_bfd, NOP, contents + offset + 4);
14592 if ((tls_mask & tls_gd) == 0
14593 && (tls_gd == 0 || toc_symndx != 0))
14595 /* We changed the symbol. Start over in order
14596 to get h, sym, sec etc. right. */
14602 case R_PPC64_TLSGD:
14603 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0
14604 && rel + 1 < relend)
14606 unsigned int insn2;
14607 enum elf_ppc64_reloc_type r_type1 = ELF64_R_TYPE (rel[1].r_info);
14609 offset = rel->r_offset;
14610 if (is_plt_seq_reloc (r_type1))
14612 bfd_put_32 (output_bfd, NOP, contents + offset);
14613 if (r_type1 == R_PPC64_PLT_PCREL34
14614 || r_type1 == R_PPC64_PLT_PCREL34_NOTOC)
14615 bfd_put_32 (output_bfd, NOP, contents + offset + 4);
14616 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14620 if (ELF64_R_TYPE (rel[1].r_info) == R_PPC64_PLTCALL)
14621 bfd_put_32 (output_bfd, NOP, contents + offset + 4);
14623 if ((tls_mask & TLS_GDIE) != 0)
14626 r_type = R_PPC64_NONE;
14627 insn2 = 0x7c636a14; /* add 3,3,13 */
14632 if (toc_symndx != 0)
14634 r_symndx = toc_symndx;
14635 rel->r_addend = toc_addend;
14637 r_type = R_PPC64_TPREL16_LO;
14638 rel->r_offset = offset + d_offset;
14639 insn2 = 0x38630000; /* addi 3,3,0 */
14641 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14642 /* Zap the reloc on the _tls_get_addr call too. */
14643 BFD_ASSERT (offset == rel[1].r_offset);
14644 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14645 bfd_put_32 (input_bfd, insn2, contents + offset);
14646 if ((tls_mask & TLS_GDIE) == 0 && toc_symndx != 0)
14651 case R_PPC64_TLSLD:
14652 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0
14653 && rel + 1 < relend)
14655 unsigned int insn2;
14656 enum elf_ppc64_reloc_type r_type1 = ELF64_R_TYPE (rel[1].r_info);
14658 offset = rel->r_offset;
14659 if (is_plt_seq_reloc (r_type1))
14661 bfd_put_32 (output_bfd, NOP, contents + offset);
14662 if (r_type1 == R_PPC64_PLT_PCREL34
14663 || r_type1 == R_PPC64_PLT_PCREL34_NOTOC)
14664 bfd_put_32 (output_bfd, NOP, contents + offset + 4);
14665 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14669 if (ELF64_R_TYPE (rel[1].r_info) == R_PPC64_PLTCALL)
14670 bfd_put_32 (output_bfd, NOP, contents + offset + 4);
14673 sec = local_sections[toc_symndx];
14675 r_symndx < symtab_hdr->sh_info;
14677 if (local_sections[r_symndx] == sec)
14679 if (r_symndx >= symtab_hdr->sh_info)
14680 r_symndx = STN_UNDEF;
14681 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
14682 if (r_symndx != STN_UNDEF)
14683 rel->r_addend -= (local_syms[r_symndx].st_value
14684 + sec->output_offset
14685 + sec->output_section->vma);
14687 r_type = R_PPC64_TPREL16_LO;
14688 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14689 rel->r_offset = offset + d_offset;
14690 /* Zap the reloc on the _tls_get_addr call too. */
14691 BFD_ASSERT (offset == rel[1].r_offset);
14692 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14693 insn2 = 0x38630000; /* addi 3,3,0 */
14694 bfd_put_32 (input_bfd, insn2, contents + offset);
14699 case R_PPC64_DTPMOD64:
14700 if (rel + 1 < relend
14701 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
14702 && rel[1].r_offset == rel->r_offset + 8)
14704 if ((tls_mask & TLS_GD) == 0)
14706 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
14707 if ((tls_mask & TLS_GDIE) != 0)
14708 r_type = R_PPC64_TPREL64;
14711 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14712 r_type = R_PPC64_NONE;
14714 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14719 if ((tls_mask & TLS_LD) == 0)
14721 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14722 r_type = R_PPC64_NONE;
14723 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14728 case R_PPC64_TPREL64:
14729 if ((tls_mask & TLS_TPREL) == 0)
14731 r_type = R_PPC64_NONE;
14732 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14736 case R_PPC64_ENTRY:
14737 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
14738 if (!bfd_link_pic (info)
14739 && !info->traditional_format
14740 && relocation + 0x80008000 <= 0xffffffff)
14742 unsigned int insn1, insn2;
14744 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14745 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14746 if ((insn1 & ~0xfffc) == LD_R2_0R12
14747 && insn2 == ADD_R2_R2_R12)
14749 bfd_put_32 (input_bfd,
14750 LIS_R2 + PPC_HA (relocation),
14751 contents + rel->r_offset);
14752 bfd_put_32 (input_bfd,
14753 ADDI_R2_R2 + PPC_LO (relocation),
14754 contents + rel->r_offset + 4);
14759 relocation -= (rel->r_offset
14760 + input_section->output_offset
14761 + input_section->output_section->vma);
14762 if (relocation + 0x80008000 <= 0xffffffff)
14764 unsigned int insn1, insn2;
14766 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14767 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14768 if ((insn1 & ~0xfffc) == LD_R2_0R12
14769 && insn2 == ADD_R2_R2_R12)
14771 bfd_put_32 (input_bfd,
14772 ADDIS_R2_R12 + PPC_HA (relocation),
14773 contents + rel->r_offset);
14774 bfd_put_32 (input_bfd,
14775 ADDI_R2_R2 + PPC_LO (relocation),
14776 contents + rel->r_offset + 4);
14782 case R_PPC64_REL16_HA:
14783 /* If we are generating a non-PIC executable, edit
14784 . 0: addis 2,12,.TOC.-0b@ha
14785 . addi 2,2,.TOC.-0b@l
14786 used by ELFv2 global entry points to set up r2, to
14789 if .TOC. is in range. */
14790 if (!bfd_link_pic (info)
14791 && !info->traditional_format
14793 && rel->r_addend == d_offset
14794 && h != NULL && &h->elf == htab->elf.hgot
14795 && rel + 1 < relend
14796 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
14797 && rel[1].r_offset == rel->r_offset + 4
14798 && rel[1].r_addend == rel->r_addend + 4
14799 && relocation + 0x80008000 <= 0xffffffff)
14801 unsigned int insn1, insn2;
14802 offset = rel->r_offset - d_offset;
14803 insn1 = bfd_get_32 (input_bfd, contents + offset);
14804 insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
14805 if ((insn1 & 0xffff0000) == ADDIS_R2_R12
14806 && (insn2 & 0xffff0000) == ADDI_R2_R2)
14808 r_type = R_PPC64_ADDR16_HA;
14809 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14810 rel->r_addend -= d_offset;
14811 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
14812 rel[1].r_addend -= d_offset + 4;
14813 bfd_put_32 (input_bfd, LIS_R2, contents + offset);
14819 /* Handle other relocations that tweak non-addend part of insn. */
14821 max_br_offset = 1 << 25;
14822 addend = rel->r_addend;
14823 reloc_dest = DEST_NORMAL;
14829 case R_PPC64_TOCSAVE:
14830 if (relocation + addend == (rel->r_offset
14831 + input_section->output_offset
14832 + input_section->output_section->vma)
14833 && tocsave_find (htab, NO_INSERT,
14834 &local_syms, rel, input_bfd))
14836 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14838 || insn == CROR_151515 || insn == CROR_313131)
14839 bfd_put_32 (input_bfd,
14840 STD_R2_0R1 + STK_TOC (htab),
14841 contents + rel->r_offset);
14845 /* Branch taken prediction relocations. */
14846 case R_PPC64_ADDR14_BRTAKEN:
14847 case R_PPC64_REL14_BRTAKEN:
14848 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
14849 /* Fall through. */
14851 /* Branch not taken prediction relocations. */
14852 case R_PPC64_ADDR14_BRNTAKEN:
14853 case R_PPC64_REL14_BRNTAKEN:
14854 insn |= bfd_get_32 (input_bfd,
14855 contents + rel->r_offset) & ~(0x01 << 21);
14856 /* Fall through. */
14858 case R_PPC64_REL14:
14859 max_br_offset = 1 << 15;
14860 /* Fall through. */
14862 case R_PPC64_REL24:
14863 case R_PPC64_REL24_NOTOC:
14864 case R_PPC64_PLTCALL:
14865 case R_PPC64_PLTCALL_NOTOC:
14866 /* Calls to functions with a different TOC, such as calls to
14867 shared objects, need to alter the TOC pointer. This is
14868 done using a linkage stub. A REL24 branching to these
14869 linkage stubs needs to be followed by a nop, as the nop
14870 will be replaced with an instruction to restore the TOC
14875 && h->oh->is_func_descriptor)
14876 fdh = ppc_follow_link (h->oh);
14877 stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14879 if ((r_type == R_PPC64_PLTCALL
14880 || r_type == R_PPC64_PLTCALL_NOTOC)
14881 && stub_entry != NULL
14882 && stub_entry->stub_type >= ppc_stub_plt_call
14883 && stub_entry->stub_type <= ppc_stub_plt_call_both)
14886 if (stub_entry != NULL
14887 && ((stub_entry->stub_type >= ppc_stub_plt_call
14888 && stub_entry->stub_type <= ppc_stub_plt_call_both)
14889 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14890 || stub_entry->stub_type == ppc_stub_plt_branch_both
14891 || stub_entry->stub_type == ppc_stub_long_branch_r2off
14892 || stub_entry->stub_type == ppc_stub_long_branch_both))
14894 bfd_boolean can_plt_call = FALSE;
14896 if (stub_entry->stub_type == ppc_stub_plt_call
14898 && htab->params->plt_localentry0 != 0
14899 && is_elfv2_localentry0 (&h->elf))
14901 /* The function doesn't use or change r2. */
14902 can_plt_call = TRUE;
14904 else if (r_type == R_PPC64_REL24_NOTOC)
14906 /* NOTOC calls don't need to restore r2. */
14907 can_plt_call = TRUE;
14910 /* All of these stubs may modify r2, so there must be a
14911 branch and link followed by a nop. The nop is
14912 replaced by an insn to restore r2. */
14913 else if (rel->r_offset + 8 <= input_section->size)
14917 br = bfd_get_32 (input_bfd,
14918 contents + rel->r_offset);
14923 nop = bfd_get_32 (input_bfd,
14924 contents + rel->r_offset + 4);
14925 if (nop == LD_R2_0R1 + STK_TOC (htab))
14926 can_plt_call = TRUE;
14927 else if (nop == NOP
14928 || nop == CROR_151515
14929 || nop == CROR_313131)
14932 && (h == htab->tls_get_addr_fd
14933 || h == htab->tls_get_addr)
14934 && htab->params->tls_get_addr_opt)
14936 /* Special stub used, leave nop alone. */
14939 bfd_put_32 (input_bfd,
14940 LD_R2_0R1 + STK_TOC (htab),
14941 contents + rel->r_offset + 4);
14942 can_plt_call = TRUE;
14947 if (!can_plt_call && h != NULL)
14949 const char *name = h->elf.root.root.string;
14954 if (strncmp (name, "__libc_start_main", 17) == 0
14955 && (name[17] == 0 || name[17] == '@'))
14957 /* Allow crt1 branch to go via a toc adjusting
14958 stub. Other calls that never return could do
14959 the same, if we could detect such. */
14960 can_plt_call = TRUE;
14966 /* g++ as of 20130507 emits self-calls without a
14967 following nop. This is arguably wrong since we
14968 have conflicting information. On the one hand a
14969 global symbol and on the other a local call
14970 sequence, but don't error for this special case.
14971 It isn't possible to cheaply verify we have
14972 exactly such a call. Allow all calls to the same
14974 asection *code_sec = sec;
14976 if (get_opd_info (sec) != NULL)
14978 bfd_vma off = (relocation + addend
14979 - sec->output_section->vma
14980 - sec->output_offset);
14982 opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14984 if (code_sec == input_section)
14985 can_plt_call = TRUE;
14990 if (stub_entry->stub_type >= ppc_stub_plt_call
14991 && stub_entry->stub_type <= ppc_stub_plt_call_both)
14992 info->callbacks->einfo
14993 /* xgettext:c-format */
14994 (_("%H: call to `%pT' lacks nop, can't restore toc; "
14995 "(plt call stub)\n"),
14996 input_bfd, input_section, rel->r_offset, sym_name);
14998 info->callbacks->einfo
14999 /* xgettext:c-format */
15000 (_("%H: call to `%pT' lacks nop, can't restore toc; "
15001 "(toc save/adjust stub)\n"),
15002 input_bfd, input_section, rel->r_offset, sym_name);
15004 bfd_set_error (bfd_error_bad_value);
15009 && stub_entry->stub_type >= ppc_stub_plt_call
15010 && stub_entry->stub_type <= ppc_stub_plt_call_both)
15011 unresolved_reloc = FALSE;
15014 if ((stub_entry == NULL
15015 || stub_entry->stub_type == ppc_stub_long_branch
15016 || stub_entry->stub_type == ppc_stub_plt_branch)
15017 && get_opd_info (sec) != NULL)
15019 /* The branch destination is the value of the opd entry. */
15020 bfd_vma off = (relocation + addend
15021 - sec->output_section->vma
15022 - sec->output_offset);
15023 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
15024 if (dest != (bfd_vma) -1)
15028 reloc_dest = DEST_OPD;
15032 /* If the branch is out of reach we ought to have a long
15034 from = (rel->r_offset
15035 + input_section->output_offset
15036 + input_section->output_section->vma);
15038 relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
15042 if (stub_entry != NULL
15043 && (stub_entry->stub_type == ppc_stub_long_branch
15044 || stub_entry->stub_type == ppc_stub_plt_branch)
15045 && (r_type == R_PPC64_ADDR14_BRTAKEN
15046 || r_type == R_PPC64_ADDR14_BRNTAKEN
15047 || (relocation + addend - from + max_br_offset
15048 < 2 * max_br_offset)))
15049 /* Don't use the stub if this branch is in range. */
15052 if (stub_entry != NULL
15053 && (stub_entry->stub_type == ppc_stub_long_branch_notoc
15054 || stub_entry->stub_type == ppc_stub_long_branch_both
15055 || stub_entry->stub_type == ppc_stub_plt_branch_notoc
15056 || stub_entry->stub_type == ppc_stub_plt_branch_both)
15057 && (r_type != R_PPC64_REL24_NOTOC
15058 || ((fdh ? fdh->elf.other : sym->st_other)
15059 & STO_PPC64_LOCAL_MASK) <= 1 << STO_PPC64_LOCAL_BIT)
15060 && (relocation + addend - from + max_br_offset
15061 < 2 * max_br_offset))
15064 if (stub_entry != NULL
15065 && (stub_entry->stub_type == ppc_stub_long_branch_r2off
15066 || stub_entry->stub_type == ppc_stub_long_branch_both
15067 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
15068 || stub_entry->stub_type == ppc_stub_plt_branch_both)
15069 && r_type == R_PPC64_REL24_NOTOC
15070 && (relocation + addend - from + max_br_offset
15071 < 2 * max_br_offset))
15074 if (stub_entry != NULL)
15076 /* Munge up the value and addend so that we call the stub
15077 rather than the procedure directly. */
15078 asection *stub_sec = stub_entry->group->stub_sec;
15080 if (stub_entry->stub_type == ppc_stub_save_res)
15081 relocation += (stub_sec->output_offset
15082 + stub_sec->output_section->vma
15083 + stub_sec->size - htab->sfpr->size
15084 - htab->sfpr->output_offset
15085 - htab->sfpr->output_section->vma);
15087 relocation = (stub_entry->stub_offset
15088 + stub_sec->output_offset
15089 + stub_sec->output_section->vma);
15091 reloc_dest = DEST_STUB;
15093 if (((stub_entry->stub_type == ppc_stub_plt_call
15094 && ALWAYS_EMIT_R2SAVE)
15095 || stub_entry->stub_type == ppc_stub_plt_call_r2save
15096 || stub_entry->stub_type == ppc_stub_plt_call_both)
15098 && (h == htab->tls_get_addr_fd
15099 || h == htab->tls_get_addr)
15100 && htab->params->tls_get_addr_opt)
15101 && rel + 1 < relend
15102 && rel[1].r_offset == rel->r_offset + 4
15103 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
15105 else if ((stub_entry->stub_type == ppc_stub_long_branch_both
15106 || stub_entry->stub_type == ppc_stub_plt_branch_both
15107 || stub_entry->stub_type == ppc_stub_plt_call_both)
15108 && r_type == R_PPC64_REL24_NOTOC)
15111 if (r_type == R_PPC64_REL24_NOTOC
15112 && (stub_entry->stub_type == ppc_stub_plt_call_notoc
15113 || stub_entry->stub_type == ppc_stub_plt_call_both))
15114 htab->notoc_plt = 1;
15121 /* Set 'a' bit. This is 0b00010 in BO field for branch
15122 on CR(BI) insns (BO == 001at or 011at), and 0b01000
15123 for branch on CTR insns (BO == 1a00t or 1a01t). */
15124 if ((insn & (0x14 << 21)) == (0x04 << 21))
15125 insn |= 0x02 << 21;
15126 else if ((insn & (0x14 << 21)) == (0x10 << 21))
15127 insn |= 0x08 << 21;
15133 /* Invert 'y' bit if not the default. */
15134 if ((bfd_signed_vma) (relocation + addend - from) < 0)
15135 insn ^= 0x01 << 21;
15138 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15141 /* NOP out calls to undefined weak functions.
15142 We can thus call a weak function without first
15143 checking whether the function is defined. */
15145 && h->elf.root.type == bfd_link_hash_undefweak
15146 && h->elf.dynindx == -1
15147 && (r_type == R_PPC64_REL24
15148 || r_type == R_PPC64_REL24_NOTOC)
15152 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
15157 case R_PPC64_GOT16_DS:
15158 from = TOCstart + htab->sec_info[input_section->id].toc_off;
15159 if (relocation + addend - from + 0x8000 < 0x10000
15160 && SYMBOL_REFERENCES_LOCAL (info, &h->elf))
15162 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15163 if ((insn & (0x3f << 26 | 0x3)) == 58u << 26 /* ld */)
15165 insn += (14u << 26) - (58u << 26);
15166 bfd_put_32 (input_bfd, insn, contents + (rel->r_offset & ~3));
15167 r_type = R_PPC64_TOC16;
15168 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
15173 case R_PPC64_GOT16_LO_DS:
15174 case R_PPC64_GOT16_HA:
15175 from = TOCstart + htab->sec_info[input_section->id].toc_off;
15176 if (relocation + addend - from + 0x80008000ULL < 0x100000000ULL
15177 && SYMBOL_REFERENCES_LOCAL (info, &h->elf))
15179 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15180 if ((insn & (0x3f << 26 | 0x3)) == 58u << 26 /* ld */)
15182 insn += (14u << 26) - (58u << 26);
15183 bfd_put_32 (input_bfd, insn, contents + (rel->r_offset & ~3));
15184 r_type = R_PPC64_TOC16_LO;
15185 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
15187 else if ((insn & (0x3f << 26)) == 15u << 26 /* addis */)
15189 r_type = R_PPC64_TOC16_HA;
15190 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
15195 case R_PPC64_GOT_PCREL34:
15196 from = (rel->r_offset
15197 + input_section->output_section->vma
15198 + input_section->output_offset);
15199 if (relocation - from + (1ULL << 33) < 1ULL << 34
15200 && SYMBOL_REFERENCES_LOCAL (info, &h->elf))
15202 offset = rel->r_offset;
15203 pinsn = bfd_get_32 (input_bfd, contents + offset);
15205 pinsn |= bfd_get_32 (input_bfd, contents + offset + 4);
15206 if ((pinsn & ((-1ULL << 50) | (63ULL << 26)))
15207 == ((1ULL << 58) | (1ULL << 52) | (57ULL << 26) /* pld */))
15209 /* Replace with paddi. */
15210 pinsn += (2ULL << 56) + (14ULL << 26) - (57ULL << 26);
15211 r_type = R_PPC64_PCREL34;
15212 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
15213 bfd_put_32 (input_bfd, pinsn >> 32, contents + offset);
15214 bfd_put_32 (input_bfd, pinsn, contents + offset + 4);
15220 case R_PPC64_PCREL34:
15221 if (SYMBOL_REFERENCES_LOCAL (info, &h->elf))
15223 offset = rel->r_offset;
15224 pinsn = bfd_get_32 (input_bfd, contents + offset);
15226 pinsn |= bfd_get_32 (input_bfd, contents + offset + 4);
15227 if ((pinsn & ((-1ULL << 50) | (63ULL << 26)))
15228 == ((1ULL << 58) | (2ULL << 56) | (1ULL << 52)
15229 | (14ULL << 26) /* paddi */))
15232 if (rel + 1 < relend
15233 && rel[1].r_offset == offset
15234 && rel[1].r_info == ELF64_R_INFO (0, R_PPC64_PCREL_OPT))
15236 bfd_vma off2 = rel[1].r_addend;
15238 /* zero means next insn. */
15241 if (off2 + 4 <= input_section->size)
15244 pinsn2 = bfd_get_32 (input_bfd, contents + off2);
15246 if ((pinsn2 & (63ULL << 58)) == 1ULL << 58)
15248 if (xlate_pcrel_opt (&pinsn, &pinsn2))
15250 bfd_put_32 (input_bfd, pinsn >> 32,
15251 contents + offset);
15252 bfd_put_32 (input_bfd, pinsn,
15253 contents + offset + 4);
15254 bfd_put_32 (input_bfd, pinsn2 >> 32,
15264 /* Set `addend'. */
15266 save_unresolved_reloc = unresolved_reloc;
15270 /* xgettext:c-format */
15271 _bfd_error_handler (_("%pB: %s unsupported"),
15272 input_bfd, ppc64_elf_howto_table[r_type]->name);
15274 bfd_set_error (bfd_error_bad_value);
15280 case R_PPC64_TLSGD:
15281 case R_PPC64_TLSLD:
15282 case R_PPC64_TOCSAVE:
15283 case R_PPC64_GNU_VTINHERIT:
15284 case R_PPC64_GNU_VTENTRY:
15285 case R_PPC64_ENTRY:
15286 case R_PPC64_PCREL_OPT:
15289 /* GOT16 relocations. Like an ADDR16 using the symbol's
15290 address in the GOT as relocation value instead of the
15291 symbol's value itself. Also, create a GOT entry for the
15292 symbol and put the symbol value there. */
15293 case R_PPC64_GOT_TLSGD16:
15294 case R_PPC64_GOT_TLSGD16_LO:
15295 case R_PPC64_GOT_TLSGD16_HI:
15296 case R_PPC64_GOT_TLSGD16_HA:
15297 tls_type = TLS_TLS | TLS_GD;
15300 case R_PPC64_GOT_TLSLD16:
15301 case R_PPC64_GOT_TLSLD16_LO:
15302 case R_PPC64_GOT_TLSLD16_HI:
15303 case R_PPC64_GOT_TLSLD16_HA:
15304 tls_type = TLS_TLS | TLS_LD;
15307 case R_PPC64_GOT_TPREL16_DS:
15308 case R_PPC64_GOT_TPREL16_LO_DS:
15309 case R_PPC64_GOT_TPREL16_HI:
15310 case R_PPC64_GOT_TPREL16_HA:
15311 tls_type = TLS_TLS | TLS_TPREL;
15314 case R_PPC64_GOT_DTPREL16_DS:
15315 case R_PPC64_GOT_DTPREL16_LO_DS:
15316 case R_PPC64_GOT_DTPREL16_HI:
15317 case R_PPC64_GOT_DTPREL16_HA:
15318 tls_type = TLS_TLS | TLS_DTPREL;
15321 case R_PPC64_GOT16:
15322 case R_PPC64_GOT16_LO:
15323 case R_PPC64_GOT16_HI:
15324 case R_PPC64_GOT16_HA:
15325 case R_PPC64_GOT16_DS:
15326 case R_PPC64_GOT16_LO_DS:
15327 case R_PPC64_GOT_PCREL34:
15330 /* Relocation is to the entry for this symbol in the global
15335 unsigned long indx = 0;
15336 struct got_entry *ent;
15337 bfd_vma sym_addend = orig_rel.r_addend;
15339 if (r_type == R_PPC64_GOT_PCREL34)
15342 if (tls_type == (TLS_TLS | TLS_LD)
15344 || !h->elf.def_dynamic))
15345 ent = ppc64_tlsld_got (input_bfd);
15350 if (!htab->elf.dynamic_sections_created
15351 || h->elf.dynindx == -1
15352 || SYMBOL_REFERENCES_LOCAL (info, &h->elf)
15353 || UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf))
15354 /* This is actually a static link, or it is a
15355 -Bsymbolic link and the symbol is defined
15356 locally, or the symbol was forced to be local
15357 because of a version file. */
15361 indx = h->elf.dynindx;
15362 unresolved_reloc = FALSE;
15364 ent = h->elf.got.glist;
15368 if (local_got_ents == NULL)
15370 ent = local_got_ents[r_symndx];
15373 for (; ent != NULL; ent = ent->next)
15374 if (ent->addend == sym_addend
15375 && ent->owner == input_bfd
15376 && ent->tls_type == tls_type)
15382 if (ent->is_indirect)
15383 ent = ent->got.ent;
15384 offp = &ent->got.offset;
15385 got = ppc64_elf_tdata (ent->owner)->got;
15389 /* The offset must always be a multiple of 8. We use the
15390 least significant bit to record whether we have already
15391 processed this entry. */
15393 if ((off & 1) != 0)
15397 /* Generate relocs for the dynamic linker, except in
15398 the case of TLSLD where we'll use one entry per
15406 ? h->elf.type == STT_GNU_IFUNC
15407 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
15410 relgot = htab->elf.irelplt;
15412 htab->local_ifunc_resolver = 1;
15413 else if (is_static_defined (&h->elf))
15414 htab->maybe_local_ifunc_resolver = 1;
15417 || (bfd_link_pic (info)
15419 || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf)
15420 || (tls_type == (TLS_TLS | TLS_LD)
15421 && !h->elf.def_dynamic))
15422 && !(tls_type == (TLS_TLS | TLS_TPREL)
15423 && bfd_link_executable (info)
15424 && SYMBOL_REFERENCES_LOCAL (info, &h->elf))))
15425 relgot = ppc64_elf_tdata (ent->owner)->relgot;
15426 if (relgot != NULL)
15428 outrel.r_offset = (got->output_section->vma
15429 + got->output_offset
15431 outrel.r_addend = sym_addend;
15432 if (tls_type & (TLS_LD | TLS_GD))
15434 outrel.r_addend = 0;
15435 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
15436 if (tls_type == (TLS_TLS | TLS_GD))
15438 loc = relgot->contents;
15439 loc += (relgot->reloc_count++
15440 * sizeof (Elf64_External_Rela));
15441 bfd_elf64_swap_reloca_out (output_bfd,
15443 outrel.r_offset += 8;
15444 outrel.r_addend = sym_addend;
15446 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
15449 else if (tls_type == (TLS_TLS | TLS_DTPREL))
15450 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
15451 else if (tls_type == (TLS_TLS | TLS_TPREL))
15452 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
15453 else if (indx != 0)
15454 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
15458 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15460 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
15462 /* Write the .got section contents for the sake
15464 loc = got->contents + off;
15465 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
15469 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
15471 outrel.r_addend += relocation;
15472 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
15474 if (htab->elf.tls_sec == NULL)
15475 outrel.r_addend = 0;
15477 outrel.r_addend -= htab->elf.tls_sec->vma;
15480 loc = relgot->contents;
15481 loc += (relgot->reloc_count++
15482 * sizeof (Elf64_External_Rela));
15483 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
15486 /* Init the .got section contents here if we're not
15487 emitting a reloc. */
15490 relocation += sym_addend;
15493 if (htab->elf.tls_sec == NULL)
15497 if (tls_type & TLS_LD)
15500 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
15501 if (tls_type & TLS_TPREL)
15502 relocation += DTP_OFFSET - TP_OFFSET;
15505 if (tls_type & (TLS_GD | TLS_LD))
15507 bfd_put_64 (output_bfd, relocation,
15508 got->contents + off + 8);
15512 bfd_put_64 (output_bfd, relocation,
15513 got->contents + off);
15517 if (off >= (bfd_vma) -2)
15520 relocation = got->output_section->vma + got->output_offset + off;
15521 if (r_type != R_PPC64_GOT_PCREL34)
15522 addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
15526 case R_PPC64_PLT16_HA:
15527 case R_PPC64_PLT16_HI:
15528 case R_PPC64_PLT16_LO:
15529 case R_PPC64_PLT16_LO_DS:
15530 case R_PPC64_PLT_PCREL34:
15531 case R_PPC64_PLT_PCREL34_NOTOC:
15532 case R_PPC64_PLT32:
15533 case R_PPC64_PLT64:
15534 case R_PPC64_PLTSEQ:
15535 case R_PPC64_PLTSEQ_NOTOC:
15536 case R_PPC64_PLTCALL:
15537 case R_PPC64_PLTCALL_NOTOC:
15538 /* Relocation is to the entry for this symbol in the
15539 procedure linkage table. */
15540 unresolved_reloc = TRUE;
15542 struct plt_entry **plt_list = NULL;
15544 plt_list = &h->elf.plt.plist;
15545 else if (local_got_ents != NULL)
15547 struct plt_entry **local_plt = (struct plt_entry **)
15548 (local_got_ents + symtab_hdr->sh_info);
15549 plt_list = local_plt + r_symndx;
15553 struct plt_entry *ent;
15554 bfd_vma sym_addend = orig_rel.r_addend;
15556 if (r_type == R_PPC64_PLT_PCREL34
15557 || r_type == R_PPC64_PLT_PCREL34_NOTOC)
15560 for (ent = *plt_list; ent != NULL; ent = ent->next)
15561 if (ent->plt.offset != (bfd_vma) -1
15562 && ent->addend == sym_addend)
15567 plt = htab->elf.splt;
15568 if (!htab->elf.dynamic_sections_created
15570 || h->elf.dynindx == -1)
15573 ? h->elf.type == STT_GNU_IFUNC
15574 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15575 plt = htab->elf.iplt;
15577 plt = htab->pltlocal;
15579 relocation = (plt->output_section->vma
15580 + plt->output_offset
15581 + ent->plt.offset);
15582 if (r_type == R_PPC64_PLT16_HA
15583 || r_type == R_PPC64_PLT16_HI
15584 || r_type == R_PPC64_PLT16_LO
15585 || r_type == R_PPC64_PLT16_LO_DS)
15587 got = (elf_gp (output_bfd)
15588 + htab->sec_info[input_section->id].toc_off);
15591 if (r_type != R_PPC64_PLT_PCREL34
15592 && r_type != R_PPC64_PLT_PCREL34_NOTOC)
15594 unresolved_reloc = FALSE;
15602 /* Relocation value is TOC base. */
15603 relocation = TOCstart;
15604 if (r_symndx == STN_UNDEF)
15605 relocation += htab->sec_info[input_section->id].toc_off;
15606 else if (unresolved_reloc)
15608 else if (sec != NULL && sec->id < htab->sec_info_arr_size)
15609 relocation += htab->sec_info[sec->id].toc_off;
15611 unresolved_reloc = TRUE;
15614 /* TOC16 relocs. We want the offset relative to the TOC base,
15615 which is the address of the start of the TOC plus 0x8000.
15616 The TOC consists of sections .got, .toc, .tocbss, and .plt,
15618 case R_PPC64_TOC16:
15619 case R_PPC64_TOC16_LO:
15620 case R_PPC64_TOC16_HI:
15621 case R_PPC64_TOC16_DS:
15622 case R_PPC64_TOC16_LO_DS:
15623 case R_PPC64_TOC16_HA:
15624 addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
15627 /* Relocate against the beginning of the section. */
15628 case R_PPC64_SECTOFF:
15629 case R_PPC64_SECTOFF_LO:
15630 case R_PPC64_SECTOFF_HI:
15631 case R_PPC64_SECTOFF_DS:
15632 case R_PPC64_SECTOFF_LO_DS:
15633 case R_PPC64_SECTOFF_HA:
15635 addend -= sec->output_section->vma;
15638 case R_PPC64_REL16:
15639 case R_PPC64_REL16_LO:
15640 case R_PPC64_REL16_HI:
15641 case R_PPC64_REL16_HA:
15642 case R_PPC64_REL16_HIGH:
15643 case R_PPC64_REL16_HIGHA:
15644 case R_PPC64_REL16_HIGHER:
15645 case R_PPC64_REL16_HIGHERA:
15646 case R_PPC64_REL16_HIGHEST:
15647 case R_PPC64_REL16_HIGHESTA:
15648 case R_PPC64_REL16_HIGHER34:
15649 case R_PPC64_REL16_HIGHERA34:
15650 case R_PPC64_REL16_HIGHEST34:
15651 case R_PPC64_REL16_HIGHESTA34:
15652 case R_PPC64_REL16DX_HA:
15653 case R_PPC64_REL14:
15654 case R_PPC64_REL14_BRNTAKEN:
15655 case R_PPC64_REL14_BRTAKEN:
15656 case R_PPC64_REL24:
15657 case R_PPC64_REL24_NOTOC:
15658 case R_PPC64_PCREL34:
15659 case R_PPC64_PCREL28:
15662 case R_PPC64_TPREL16:
15663 case R_PPC64_TPREL16_LO:
15664 case R_PPC64_TPREL16_HI:
15665 case R_PPC64_TPREL16_HA:
15666 case R_PPC64_TPREL16_DS:
15667 case R_PPC64_TPREL16_LO_DS:
15668 case R_PPC64_TPREL16_HIGH:
15669 case R_PPC64_TPREL16_HIGHA:
15670 case R_PPC64_TPREL16_HIGHER:
15671 case R_PPC64_TPREL16_HIGHERA:
15672 case R_PPC64_TPREL16_HIGHEST:
15673 case R_PPC64_TPREL16_HIGHESTA:
15675 && h->elf.root.type == bfd_link_hash_undefweak
15676 && h->elf.dynindx == -1)
15678 /* Make this relocation against an undefined weak symbol
15679 resolve to zero. This is really just a tweak, since
15680 code using weak externs ought to check that they are
15681 defined before using them. */
15682 bfd_byte *p = contents + rel->r_offset - d_offset;
15684 insn = bfd_get_32 (input_bfd, p);
15685 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
15687 bfd_put_32 (input_bfd, insn, p);
15690 if (htab->elf.tls_sec != NULL)
15691 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
15692 /* The TPREL16 relocs shouldn't really be used in shared
15693 libs or with non-local symbols as that will result in
15694 DT_TEXTREL being set, but support them anyway. */
15697 case R_PPC64_DTPREL16:
15698 case R_PPC64_DTPREL16_LO:
15699 case R_PPC64_DTPREL16_HI:
15700 case R_PPC64_DTPREL16_HA:
15701 case R_PPC64_DTPREL16_DS:
15702 case R_PPC64_DTPREL16_LO_DS:
15703 case R_PPC64_DTPREL16_HIGH:
15704 case R_PPC64_DTPREL16_HIGHA:
15705 case R_PPC64_DTPREL16_HIGHER:
15706 case R_PPC64_DTPREL16_HIGHERA:
15707 case R_PPC64_DTPREL16_HIGHEST:
15708 case R_PPC64_DTPREL16_HIGHESTA:
15709 if (htab->elf.tls_sec != NULL)
15710 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
15713 case R_PPC64_ADDR64_LOCAL:
15714 addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
15719 case R_PPC64_DTPMOD64:
15724 case R_PPC64_TPREL64:
15725 if (htab->elf.tls_sec != NULL)
15726 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
15729 case R_PPC64_DTPREL64:
15730 if (htab->elf.tls_sec != NULL)
15731 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
15732 /* Fall through. */
15734 /* Relocations that may need to be propagated if this is a
15736 case R_PPC64_REL30:
15737 case R_PPC64_REL32:
15738 case R_PPC64_REL64:
15739 case R_PPC64_ADDR14:
15740 case R_PPC64_ADDR14_BRNTAKEN:
15741 case R_PPC64_ADDR14_BRTAKEN:
15742 case R_PPC64_ADDR16:
15743 case R_PPC64_ADDR16_DS:
15744 case R_PPC64_ADDR16_HA:
15745 case R_PPC64_ADDR16_HI:
15746 case R_PPC64_ADDR16_HIGH:
15747 case R_PPC64_ADDR16_HIGHA:
15748 case R_PPC64_ADDR16_HIGHER:
15749 case R_PPC64_ADDR16_HIGHERA:
15750 case R_PPC64_ADDR16_HIGHEST:
15751 case R_PPC64_ADDR16_HIGHESTA:
15752 case R_PPC64_ADDR16_LO:
15753 case R_PPC64_ADDR16_LO_DS:
15754 case R_PPC64_ADDR16_HIGHER34:
15755 case R_PPC64_ADDR16_HIGHERA34:
15756 case R_PPC64_ADDR16_HIGHEST34:
15757 case R_PPC64_ADDR16_HIGHESTA34:
15758 case R_PPC64_ADDR24:
15759 case R_PPC64_ADDR32:
15760 case R_PPC64_ADDR64:
15761 case R_PPC64_UADDR16:
15762 case R_PPC64_UADDR32:
15763 case R_PPC64_UADDR64:
15765 case R_PPC64_D34_LO:
15766 case R_PPC64_D34_HI30:
15767 case R_PPC64_D34_HA30:
15770 if ((input_section->flags & SEC_ALLOC) == 0)
15773 if (NO_OPD_RELOCS && is_opd)
15776 if (bfd_link_pic (info)
15778 || h->dyn_relocs != NULL)
15779 && ((h != NULL && pc_dynrelocs (h))
15780 || must_be_dyn_reloc (info, r_type)))
15782 ? h->dyn_relocs != NULL
15783 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
15785 bfd_boolean skip, relocate;
15790 /* When generating a dynamic object, these relocations
15791 are copied into the output file to be resolved at run
15797 out_off = _bfd_elf_section_offset (output_bfd, info,
15798 input_section, rel->r_offset);
15799 if (out_off == (bfd_vma) -1)
15801 else if (out_off == (bfd_vma) -2)
15802 skip = TRUE, relocate = TRUE;
15803 out_off += (input_section->output_section->vma
15804 + input_section->output_offset);
15805 outrel.r_offset = out_off;
15806 outrel.r_addend = rel->r_addend;
15808 /* Optimize unaligned reloc use. */
15809 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
15810 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
15811 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
15812 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
15813 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
15814 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
15815 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
15816 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
15817 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
15820 memset (&outrel, 0, sizeof outrel);
15821 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
15823 && r_type != R_PPC64_TOC)
15825 indx = h->elf.dynindx;
15826 BFD_ASSERT (indx != -1);
15827 outrel.r_info = ELF64_R_INFO (indx, r_type);
15831 /* This symbol is local, or marked to become local,
15832 or this is an opd section reloc which must point
15833 at a local function. */
15834 outrel.r_addend += relocation;
15835 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
15837 if (is_opd && h != NULL)
15839 /* Lie about opd entries. This case occurs
15840 when building shared libraries and we
15841 reference a function in another shared
15842 lib. The same thing happens for a weak
15843 definition in an application that's
15844 overridden by a strong definition in a
15845 shared lib. (I believe this is a generic
15846 bug in binutils handling of weak syms.)
15847 In these cases we won't use the opd
15848 entry in this lib. */
15849 unresolved_reloc = FALSE;
15852 && r_type == R_PPC64_ADDR64
15854 ? h->elf.type == STT_GNU_IFUNC
15855 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
15856 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15859 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
15861 /* We need to relocate .opd contents for ld.so.
15862 Prelink also wants simple and consistent rules
15863 for relocs. This make all RELATIVE relocs have
15864 *r_offset equal to r_addend. */
15871 ? h->elf.type == STT_GNU_IFUNC
15872 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15874 info->callbacks->einfo
15875 /* xgettext:c-format */
15876 (_("%H: %s for indirect "
15877 "function `%pT' unsupported\n"),
15878 input_bfd, input_section, rel->r_offset,
15879 ppc64_elf_howto_table[r_type]->name,
15883 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
15885 else if (sec == NULL || sec->owner == NULL)
15887 bfd_set_error (bfd_error_bad_value);
15892 asection *osec = sec->output_section;
15894 if ((osec->flags & SEC_THREAD_LOCAL) != 0)
15896 /* TLS symbol values are relative to the
15897 TLS segment. Dynamic relocations for
15898 local TLS symbols therefore can't be
15899 reduced to a relocation against their
15900 section symbol because it holds the
15901 address of the section, not a value
15902 relative to the TLS segment. We could
15903 change the .tdata dynamic section symbol
15904 to be zero value but STN_UNDEF works
15905 and is used elsewhere, eg. for TPREL64
15906 GOT relocs against local TLS symbols. */
15907 osec = htab->elf.tls_sec;
15912 indx = elf_section_data (osec)->dynindx;
15915 if ((osec->flags & SEC_READONLY) == 0
15916 && htab->elf.data_index_section != NULL)
15917 osec = htab->elf.data_index_section;
15919 osec = htab->elf.text_index_section;
15920 indx = elf_section_data (osec)->dynindx;
15922 BFD_ASSERT (indx != 0);
15925 /* We are turning this relocation into one
15926 against a section symbol, so subtract out
15927 the output section's address but not the
15928 offset of the input section in the output
15930 outrel.r_addend -= osec->vma;
15933 outrel.r_info = ELF64_R_INFO (indx, r_type);
15937 sreloc = elf_section_data (input_section)->sreloc;
15939 ? h->elf.type == STT_GNU_IFUNC
15940 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15942 sreloc = htab->elf.irelplt;
15944 htab->local_ifunc_resolver = 1;
15945 else if (is_static_defined (&h->elf))
15946 htab->maybe_local_ifunc_resolver = 1;
15948 if (sreloc == NULL)
15951 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
15954 loc = sreloc->contents;
15955 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
15956 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
15958 /* If this reloc is against an external symbol, it will
15959 be computed at runtime, so there's no need to do
15960 anything now. However, for the sake of prelink ensure
15961 that the section contents are a known value. */
15964 unresolved_reloc = FALSE;
15965 /* The value chosen here is quite arbitrary as ld.so
15966 ignores section contents except for the special
15967 case of .opd where the contents might be accessed
15968 before relocation. Choose zero, as that won't
15969 cause reloc overflow. */
15972 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
15973 to improve backward compatibility with older
15975 if (r_type == R_PPC64_ADDR64)
15976 addend = outrel.r_addend;
15977 /* Adjust pc_relative relocs to have zero in *r_offset. */
15978 else if (ppc64_elf_howto_table[r_type]->pc_relative)
15979 addend = outrel.r_offset;
15985 case R_PPC64_GLOB_DAT:
15986 case R_PPC64_JMP_SLOT:
15987 case R_PPC64_JMP_IREL:
15988 case R_PPC64_RELATIVE:
15989 /* We shouldn't ever see these dynamic relocs in relocatable
15991 /* Fall through. */
15993 case R_PPC64_PLTGOT16:
15994 case R_PPC64_PLTGOT16_DS:
15995 case R_PPC64_PLTGOT16_HA:
15996 case R_PPC64_PLTGOT16_HI:
15997 case R_PPC64_PLTGOT16_LO:
15998 case R_PPC64_PLTGOT16_LO_DS:
15999 case R_PPC64_PLTREL32:
16000 case R_PPC64_PLTREL64:
16001 /* These ones haven't been implemented yet. */
16003 info->callbacks->einfo
16004 /* xgettext:c-format */
16005 (_("%P: %pB: %s is not supported for `%pT'\n"),
16007 ppc64_elf_howto_table[r_type]->name, sym_name);
16009 bfd_set_error (bfd_error_invalid_operation);
16014 /* Multi-instruction sequences that access the TOC can be
16015 optimized, eg. addis ra,r2,0; addi rb,ra,x;
16016 to nop; addi rb,r2,x; */
16022 case R_PPC64_GOT_TLSLD16_HI:
16023 case R_PPC64_GOT_TLSGD16_HI:
16024 case R_PPC64_GOT_TPREL16_HI:
16025 case R_PPC64_GOT_DTPREL16_HI:
16026 case R_PPC64_GOT16_HI:
16027 case R_PPC64_TOC16_HI:
16028 /* These relocs would only be useful if building up an
16029 offset to later add to r2, perhaps in an indexed
16030 addressing mode instruction. Don't try to optimize.
16031 Unfortunately, the possibility of someone building up an
16032 offset like this or even with the HA relocs, means that
16033 we need to check the high insn when optimizing the low
16037 case R_PPC64_PLTCALL_NOTOC:
16038 if (!unresolved_reloc)
16039 htab->notoc_plt = 1;
16040 /* Fall through. */
16041 case R_PPC64_PLTCALL:
16042 if (unresolved_reloc)
16044 /* No plt entry. Make this into a direct call. */
16045 bfd_byte *p = contents + rel->r_offset;
16046 insn = bfd_get_32 (input_bfd, p);
16048 bfd_put_32 (input_bfd, B_DOT | insn, p);
16049 if (r_type == R_PPC64_PLTCALL)
16050 bfd_put_32 (input_bfd, NOP, p + 4);
16051 unresolved_reloc = save_unresolved_reloc;
16052 r_type = R_PPC64_REL24;
16056 case R_PPC64_PLTSEQ_NOTOC:
16057 case R_PPC64_PLTSEQ:
16058 if (unresolved_reloc)
16060 unresolved_reloc = FALSE;
16065 case R_PPC64_PLT_PCREL34_NOTOC:
16066 if (!unresolved_reloc)
16067 htab->notoc_plt = 1;
16068 /* Fall through. */
16069 case R_PPC64_PLT_PCREL34:
16070 if (unresolved_reloc)
16072 bfd_byte *p = contents + rel->r_offset;
16073 bfd_put_32 (input_bfd, PNOP >> 32, p);
16074 bfd_put_32 (input_bfd, PNOP, p + 4);
16075 unresolved_reloc = FALSE;
16080 case R_PPC64_PLT16_HA:
16081 if (unresolved_reloc)
16083 unresolved_reloc = FALSE;
16086 /* Fall through. */
16087 case R_PPC64_GOT_TLSLD16_HA:
16088 case R_PPC64_GOT_TLSGD16_HA:
16089 case R_PPC64_GOT_TPREL16_HA:
16090 case R_PPC64_GOT_DTPREL16_HA:
16091 case R_PPC64_GOT16_HA:
16092 case R_PPC64_TOC16_HA:
16093 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
16094 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
16098 p = contents + (rel->r_offset & ~3);
16099 bfd_put_32 (input_bfd, NOP, p);
16104 case R_PPC64_PLT16_LO:
16105 case R_PPC64_PLT16_LO_DS:
16106 if (unresolved_reloc)
16108 unresolved_reloc = FALSE;
16111 /* Fall through. */
16112 case R_PPC64_GOT_TLSLD16_LO:
16113 case R_PPC64_GOT_TLSGD16_LO:
16114 case R_PPC64_GOT_TPREL16_LO_DS:
16115 case R_PPC64_GOT_DTPREL16_LO_DS:
16116 case R_PPC64_GOT16_LO:
16117 case R_PPC64_GOT16_LO_DS:
16118 case R_PPC64_TOC16_LO:
16119 case R_PPC64_TOC16_LO_DS:
16120 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
16121 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
16123 bfd_byte *p = contents + (rel->r_offset & ~3);
16124 insn = bfd_get_32 (input_bfd, p);
16125 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
16127 /* Transform addic to addi when we change reg. */
16128 insn &= ~((0x3f << 26) | (0x1f << 16));
16129 insn |= (14u << 26) | (2 << 16);
16133 insn &= ~(0x1f << 16);
16136 bfd_put_32 (input_bfd, insn, p);
16140 case R_PPC64_TPREL16_HA:
16141 if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
16143 bfd_byte *p = contents + (rel->r_offset & ~3);
16144 insn = bfd_get_32 (input_bfd, p);
16145 if ((insn & ((0x3f << 26) | 0x1f << 16))
16146 != ((15u << 26) | (13 << 16)) /* addis rt,13,imm */)
16147 /* xgettext:c-format */
16148 info->callbacks->minfo
16149 (_("%H: warning: %s unexpected insn %#x.\n"),
16150 input_bfd, input_section, rel->r_offset,
16151 ppc64_elf_howto_table[r_type]->name, insn);
16154 bfd_put_32 (input_bfd, NOP, p);
16160 case R_PPC64_TPREL16_LO:
16161 case R_PPC64_TPREL16_LO_DS:
16162 if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
16164 bfd_byte *p = contents + (rel->r_offset & ~3);
16165 insn = bfd_get_32 (input_bfd, p);
16166 insn &= ~(0x1f << 16);
16168 bfd_put_32 (input_bfd, insn, p);
16173 /* Do any further special processing. */
16179 case R_PPC64_REL16_HA:
16180 case R_PPC64_REL16_HIGHA:
16181 case R_PPC64_REL16_HIGHERA:
16182 case R_PPC64_REL16_HIGHESTA:
16183 case R_PPC64_REL16DX_HA:
16184 case R_PPC64_ADDR16_HA:
16185 case R_PPC64_ADDR16_HIGHA:
16186 case R_PPC64_ADDR16_HIGHERA:
16187 case R_PPC64_ADDR16_HIGHESTA:
16188 case R_PPC64_TOC16_HA:
16189 case R_PPC64_SECTOFF_HA:
16190 case R_PPC64_TPREL16_HA:
16191 case R_PPC64_TPREL16_HIGHA:
16192 case R_PPC64_TPREL16_HIGHERA:
16193 case R_PPC64_TPREL16_HIGHESTA:
16194 case R_PPC64_DTPREL16_HA:
16195 case R_PPC64_DTPREL16_HIGHA:
16196 case R_PPC64_DTPREL16_HIGHERA:
16197 case R_PPC64_DTPREL16_HIGHESTA:
16198 /* It's just possible that this symbol is a weak symbol
16199 that's not actually defined anywhere. In that case,
16200 'sec' would be NULL, and we should leave the symbol
16201 alone (it will be set to zero elsewhere in the link). */
16204 /* Fall through. */
16206 case R_PPC64_GOT16_HA:
16207 case R_PPC64_PLTGOT16_HA:
16208 case R_PPC64_PLT16_HA:
16209 case R_PPC64_GOT_TLSGD16_HA:
16210 case R_PPC64_GOT_TLSLD16_HA:
16211 case R_PPC64_GOT_TPREL16_HA:
16212 case R_PPC64_GOT_DTPREL16_HA:
16213 /* Add 0x10000 if sign bit in 0:15 is set.
16214 Bits 0:15 are not used. */
16218 case R_PPC64_D34_HA30:
16219 case R_PPC64_ADDR16_HIGHERA34:
16220 case R_PPC64_ADDR16_HIGHESTA34:
16221 case R_PPC64_REL16_HIGHERA34:
16222 case R_PPC64_REL16_HIGHESTA34:
16224 addend += 1ULL << 33;
16227 case R_PPC64_ADDR16_DS:
16228 case R_PPC64_ADDR16_LO_DS:
16229 case R_PPC64_GOT16_DS:
16230 case R_PPC64_GOT16_LO_DS:
16231 case R_PPC64_PLT16_LO_DS:
16232 case R_PPC64_SECTOFF_DS:
16233 case R_PPC64_SECTOFF_LO_DS:
16234 case R_PPC64_TOC16_DS:
16235 case R_PPC64_TOC16_LO_DS:
16236 case R_PPC64_PLTGOT16_DS:
16237 case R_PPC64_PLTGOT16_LO_DS:
16238 case R_PPC64_GOT_TPREL16_DS:
16239 case R_PPC64_GOT_TPREL16_LO_DS:
16240 case R_PPC64_GOT_DTPREL16_DS:
16241 case R_PPC64_GOT_DTPREL16_LO_DS:
16242 case R_PPC64_TPREL16_DS:
16243 case R_PPC64_TPREL16_LO_DS:
16244 case R_PPC64_DTPREL16_DS:
16245 case R_PPC64_DTPREL16_LO_DS:
16246 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
16248 /* If this reloc is against an lq, lxv, or stxv insn, then
16249 the value must be a multiple of 16. This is somewhat of
16250 a hack, but the "correct" way to do this by defining _DQ
16251 forms of all the _DS relocs bloats all reloc switches in
16252 this file. It doesn't make much sense to use these
16253 relocs in data, so testing the insn should be safe. */
16254 if ((insn & (0x3f << 26)) == (56u << 26)
16255 || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
16257 relocation += addend;
16258 addend = insn & (mask ^ 3);
16259 if ((relocation & mask) != 0)
16261 relocation ^= relocation & mask;
16262 info->callbacks->einfo
16263 /* xgettext:c-format */
16264 (_("%H: error: %s not a multiple of %u\n"),
16265 input_bfd, input_section, rel->r_offset,
16266 ppc64_elf_howto_table[r_type]->name,
16268 bfd_set_error (bfd_error_bad_value);
16275 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
16276 because such sections are not SEC_ALLOC and thus ld.so will
16277 not process them. */
16278 howto = ppc64_elf_howto_table[(int) r_type];
16279 if (unresolved_reloc
16280 && !((input_section->flags & SEC_DEBUGGING) != 0
16281 && h->elf.def_dynamic)
16282 && _bfd_elf_section_offset (output_bfd, info, input_section,
16283 rel->r_offset) != (bfd_vma) -1)
16285 info->callbacks->einfo
16286 /* xgettext:c-format */
16287 (_("%H: unresolvable %s against `%pT'\n"),
16288 input_bfd, input_section, rel->r_offset,
16290 h->elf.root.root.string);
16294 /* 16-bit fields in insns mostly have signed values, but a
16295 few insns have 16-bit unsigned values. Really, we should
16296 have different reloc types. */
16297 if (howto->complain_on_overflow != complain_overflow_dont
16298 && howto->dst_mask == 0xffff
16299 && (input_section->flags & SEC_CODE) != 0)
16301 enum complain_overflow complain = complain_overflow_signed;
16303 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
16304 if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
16305 complain = complain_overflow_bitfield;
16306 else if (howto->rightshift == 0
16307 ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
16308 || (insn & (0x3f << 26)) == 24u << 26 /* ori */
16309 || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
16310 : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
16311 || (insn & (0x3f << 26)) == 25u << 26 /* oris */
16312 || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
16313 complain = complain_overflow_unsigned;
16314 if (howto->complain_on_overflow != complain)
16316 alt_howto = *howto;
16317 alt_howto.complain_on_overflow = complain;
16318 howto = &alt_howto;
16324 /* Split field relocs aren't handled by _bfd_final_link_relocate. */
16326 case R_PPC64_D34_LO:
16327 case R_PPC64_D34_HI30:
16328 case R_PPC64_D34_HA30:
16329 case R_PPC64_PCREL34:
16330 case R_PPC64_GOT_PCREL34:
16331 case R_PPC64_PLT_PCREL34:
16332 case R_PPC64_PLT_PCREL34_NOTOC:
16334 case R_PPC64_PCREL28:
16335 if (rel->r_offset + 8 > input_section->size)
16336 r = bfd_reloc_outofrange;
16339 relocation += addend;
16340 if (howto->pc_relative)
16341 relocation -= (rel->r_offset
16342 + input_section->output_offset
16343 + input_section->output_section->vma);
16344 relocation >>= howto->rightshift;
16346 pinsn = bfd_get_32 (input_bfd, contents + rel->r_offset);
16348 pinsn |= bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
16350 pinsn &= ~howto->dst_mask;
16351 pinsn |= (((relocation << 16) | (relocation & 0xffff))
16352 & howto->dst_mask);
16353 bfd_put_32 (input_bfd, pinsn >> 32, contents + rel->r_offset);
16354 bfd_put_32 (input_bfd, pinsn, contents + rel->r_offset + 4);
16356 if (howto->complain_on_overflow == complain_overflow_signed
16357 && (relocation + (1ULL << (howto->bitsize - 1))
16358 >= 1ULL << howto->bitsize))
16359 r = bfd_reloc_overflow;
16363 case R_PPC64_REL16DX_HA:
16364 if (rel->r_offset + 4 > input_section->size)
16365 r = bfd_reloc_outofrange;
16368 relocation += addend;
16369 relocation -= (rel->r_offset
16370 + input_section->output_offset
16371 + input_section->output_section->vma);
16372 relocation = (bfd_signed_vma) relocation >> 16;
16373 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
16375 insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
16376 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
16378 if (relocation + 0x8000 > 0xffff)
16379 r = bfd_reloc_overflow;
16384 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
16385 contents, rel->r_offset,
16386 relocation, addend);
16389 if (r != bfd_reloc_ok)
16391 char *more_info = NULL;
16392 const char *reloc_name = howto->name;
16394 if (reloc_dest != DEST_NORMAL)
16396 more_info = bfd_malloc (strlen (reloc_name) + 8);
16397 if (more_info != NULL)
16399 strcpy (more_info, reloc_name);
16400 strcat (more_info, (reloc_dest == DEST_OPD
16401 ? " (OPD)" : " (stub)"));
16402 reloc_name = more_info;
16406 if (r == bfd_reloc_overflow)
16408 /* On code like "if (foo) foo();" don't report overflow
16409 on a branch to zero when foo is undefined. */
16411 && (reloc_dest == DEST_STUB
16413 && (h->elf.root.type == bfd_link_hash_undefweak
16414 || h->elf.root.type == bfd_link_hash_undefined)
16415 && is_branch_reloc (r_type))))
16416 info->callbacks->reloc_overflow (info, &h->elf.root,
16417 sym_name, reloc_name,
16419 input_bfd, input_section,
16424 info->callbacks->einfo
16425 /* xgettext:c-format */
16426 (_("%H: %s against `%pT': error %d\n"),
16427 input_bfd, input_section, rel->r_offset,
16428 reloc_name, sym_name, (int) r);
16431 if (more_info != NULL)
16441 Elf_Internal_Shdr *rel_hdr;
16442 size_t deleted = rel - wrel;
16444 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
16445 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
16446 if (rel_hdr->sh_size == 0)
16448 /* It is too late to remove an empty reloc section. Leave
16450 ??? What is wrong with an empty section??? */
16451 rel_hdr->sh_size = rel_hdr->sh_entsize;
16454 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
16455 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
16456 input_section->reloc_count -= deleted;
16459 /* If we're emitting relocations, then shortly after this function
16460 returns, reloc offsets and addends for this section will be
16461 adjusted. Worse, reloc symbol indices will be for the output
16462 file rather than the input. Save a copy of the relocs for
16463 opd_entry_value. */
16464 if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
16467 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
16468 rel = bfd_alloc (input_bfd, amt);
16469 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
16470 ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
16473 memcpy (rel, relocs, amt);
16478 /* Adjust the value of any local symbols in opd sections. */
16481 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
16482 const char *name ATTRIBUTE_UNUSED,
16483 Elf_Internal_Sym *elfsym,
16484 asection *input_sec,
16485 struct elf_link_hash_entry *h)
16487 struct _opd_sec_data *opd;
16494 opd = get_opd_info (input_sec);
16495 if (opd == NULL || opd->adjust == NULL)
16498 value = elfsym->st_value - input_sec->output_offset;
16499 if (!bfd_link_relocatable (info))
16500 value -= input_sec->output_section->vma;
16502 adjust = opd->adjust[OPD_NDX (value)];
16506 elfsym->st_value += adjust;
16510 /* Finish up dynamic symbol handling. We set the contents of various
16511 dynamic sections here. */
16514 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
16515 struct bfd_link_info *info,
16516 struct elf_link_hash_entry *h,
16517 Elf_Internal_Sym *sym)
16519 struct ppc_link_hash_table *htab;
16520 struct plt_entry *ent;
16522 htab = ppc_hash_table (info);
16526 if (!htab->opd_abi && !h->def_regular)
16527 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
16528 if (ent->plt.offset != (bfd_vma) -1)
16530 /* Mark the symbol as undefined, rather than as
16531 defined in glink. Leave the value if there were
16532 any relocations where pointer equality matters
16533 (this is a clue for the dynamic linker, to make
16534 function pointer comparisons work between an
16535 application and shared library), otherwise set it
16537 sym->st_shndx = SHN_UNDEF;
16538 if (!h->pointer_equality_needed)
16540 else if (!h->ref_regular_nonweak)
16542 /* This breaks function pointer comparisons, but
16543 that is better than breaking tests for a NULL
16544 function pointer. */
16552 /* This symbol needs a copy reloc. Set it up. */
16553 Elf_Internal_Rela rela;
16557 if (h->dynindx == -1
16558 || (h->root.type != bfd_link_hash_defined
16559 && h->root.type != bfd_link_hash_defweak)
16560 || htab->elf.srelbss == NULL
16561 || htab->elf.sreldynrelro == NULL)
16564 rela.r_offset = (h->root.u.def.value
16565 + h->root.u.def.section->output_section->vma
16566 + h->root.u.def.section->output_offset);
16567 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
16569 if (h->root.u.def.section == htab->elf.sdynrelro)
16570 srel = htab->elf.sreldynrelro;
16572 srel = htab->elf.srelbss;
16573 loc = srel->contents;
16574 loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
16575 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
16581 /* Used to decide how to sort relocs in an optimal manner for the
16582 dynamic linker, before writing them out. */
16584 static enum elf_reloc_type_class
16585 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
16586 const asection *rel_sec,
16587 const Elf_Internal_Rela *rela)
16589 enum elf_ppc64_reloc_type r_type;
16590 struct ppc_link_hash_table *htab = ppc_hash_table (info);
16592 if (rel_sec == htab->elf.irelplt)
16593 return reloc_class_ifunc;
16595 r_type = ELF64_R_TYPE (rela->r_info);
16598 case R_PPC64_RELATIVE:
16599 return reloc_class_relative;
16600 case R_PPC64_JMP_SLOT:
16601 return reloc_class_plt;
16603 return reloc_class_copy;
16605 return reloc_class_normal;
16609 /* Finish up the dynamic sections. */
16612 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
16613 struct bfd_link_info *info)
16615 struct ppc_link_hash_table *htab;
16619 htab = ppc_hash_table (info);
16623 dynobj = htab->elf.dynobj;
16624 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
16626 if (htab->elf.dynamic_sections_created)
16628 Elf64_External_Dyn *dyncon, *dynconend;
16630 if (sdyn == NULL || htab->elf.sgot == NULL)
16633 dyncon = (Elf64_External_Dyn *) sdyn->contents;
16634 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
16635 for (; dyncon < dynconend; dyncon++)
16637 Elf_Internal_Dyn dyn;
16640 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
16647 case DT_PPC64_GLINK:
16649 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16650 /* We stupidly defined DT_PPC64_GLINK to be the start
16651 of glink rather than the first entry point, which is
16652 what ld.so needs, and now have a bigger stub to
16653 support automatic multiple TOCs. */
16654 dyn.d_un.d_ptr += GLINK_PLTRESOLVE_SIZE (htab) - 8 * 4;
16658 s = bfd_get_section_by_name (output_bfd, ".opd");
16661 dyn.d_un.d_ptr = s->vma;
16665 if ((htab->do_multi_toc && htab->multi_toc_needed)
16666 || htab->notoc_plt)
16667 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
16668 if (htab->has_plt_localentry0)
16669 dyn.d_un.d_val |= PPC64_OPT_LOCALENTRY;
16672 case DT_PPC64_OPDSZ:
16673 s = bfd_get_section_by_name (output_bfd, ".opd");
16676 dyn.d_un.d_val = s->size;
16680 s = htab->elf.splt;
16681 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16685 s = htab->elf.srelplt;
16686 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16690 dyn.d_un.d_val = htab->elf.srelplt->size;
16694 if (htab->local_ifunc_resolver)
16695 info->callbacks->einfo
16696 (_("%X%P: text relocations and GNU indirect "
16697 "functions will result in a segfault at runtime\n"));
16698 else if (htab->maybe_local_ifunc_resolver)
16699 info->callbacks->einfo
16700 (_("%P: warning: text relocations and GNU indirect "
16701 "functions may result in a segfault at runtime\n"));
16705 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
16709 if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0
16710 && htab->elf.sgot->output_section != bfd_abs_section_ptr)
16712 /* Fill in the first entry in the global offset table.
16713 We use it to hold the link-time TOCbase. */
16714 bfd_put_64 (output_bfd,
16715 elf_gp (output_bfd) + TOC_BASE_OFF,
16716 htab->elf.sgot->contents);
16718 /* Set .got entry size. */
16719 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize
16723 if (htab->elf.splt != NULL && htab->elf.splt->size != 0
16724 && htab->elf.splt->output_section != bfd_abs_section_ptr)
16726 /* Set .plt entry size. */
16727 elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
16728 = PLT_ENTRY_SIZE (htab);
16731 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
16732 brlt ourselves if emitrelocations. */
16733 if (htab->brlt != NULL
16734 && htab->brlt->reloc_count != 0
16735 && !_bfd_elf_link_output_relocs (output_bfd,
16737 elf_section_data (htab->brlt)->rela.hdr,
16738 elf_section_data (htab->brlt)->relocs,
16742 if (htab->glink != NULL
16743 && htab->glink->reloc_count != 0
16744 && !_bfd_elf_link_output_relocs (output_bfd,
16746 elf_section_data (htab->glink)->rela.hdr,
16747 elf_section_data (htab->glink)->relocs,
16752 if (htab->glink_eh_frame != NULL
16753 && htab->glink_eh_frame->size != 0
16754 && htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
16755 && !_bfd_elf_write_section_eh_frame (output_bfd, info,
16756 htab->glink_eh_frame,
16757 htab->glink_eh_frame->contents))
16760 /* We need to handle writing out multiple GOT sections ourselves,
16761 since we didn't add them to DYNOBJ. We know dynobj is the first
16763 while ((dynobj = dynobj->link.next) != NULL)
16767 if (!is_ppc64_elf (dynobj))
16770 s = ppc64_elf_tdata (dynobj)->got;
16773 && s->output_section != bfd_abs_section_ptr
16774 && !bfd_set_section_contents (output_bfd, s->output_section,
16775 s->contents, s->output_offset,
16778 s = ppc64_elf_tdata (dynobj)->relgot;
16781 && s->output_section != bfd_abs_section_ptr
16782 && !bfd_set_section_contents (output_bfd, s->output_section,
16783 s->contents, s->output_offset,
16791 #include "elf64-target.h"
16793 /* FreeBSD support */
16795 #undef TARGET_LITTLE_SYM
16796 #undef TARGET_LITTLE_NAME
16798 #undef TARGET_BIG_SYM
16799 #define TARGET_BIG_SYM powerpc_elf64_fbsd_vec
16800 #undef TARGET_BIG_NAME
16801 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
16804 #define ELF_OSABI ELFOSABI_FREEBSD
16807 #define elf64_bed elf64_powerpc_fbsd_bed
16809 #include "elf64-target.h"