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_TPREL34, 4, 34, 0x3ffff0000ffffULL, 0, FALSE, signed,
924 ppc64_elf_unhandled_reloc),
926 HOW (R_PPC64_DTPREL34, 4, 34, 0x3ffff0000ffffULL, 0, FALSE, signed,
927 ppc64_elf_unhandled_reloc),
929 HOW (R_PPC64_GOT_TLSGD34, 4, 34, 0x3ffff0000ffffULL, 0, TRUE, signed,
930 ppc64_elf_unhandled_reloc),
932 HOW (R_PPC64_GOT_TLSLD34, 4, 34, 0x3ffff0000ffffULL, 0, TRUE, signed,
933 ppc64_elf_unhandled_reloc),
935 HOW (R_PPC64_GOT_TPREL34, 4, 34, 0x3ffff0000ffffULL, 0, TRUE, signed,
936 ppc64_elf_unhandled_reloc),
938 HOW (R_PPC64_GOT_DTPREL34, 4, 34, 0x3ffff0000ffffULL, 0, TRUE, signed,
939 ppc64_elf_unhandled_reloc),
941 HOW (R_PPC64_ADDR16_HIGHER34, 1, 16, 0xffff, 34, FALSE, dont,
942 bfd_elf_generic_reloc),
944 HOW (R_PPC64_ADDR16_HIGHERA34, 1, 16, 0xffff, 34, FALSE, dont,
947 HOW (R_PPC64_ADDR16_HIGHEST34, 1, 16, 0xffff, 50, FALSE, dont,
948 bfd_elf_generic_reloc),
950 HOW (R_PPC64_ADDR16_HIGHESTA34, 1, 16, 0xffff, 50, FALSE, dont,
953 HOW (R_PPC64_REL16_HIGHER34, 1, 16, 0xffff, 34, TRUE, dont,
954 bfd_elf_generic_reloc),
956 HOW (R_PPC64_REL16_HIGHERA34, 1, 16, 0xffff, 34, TRUE, dont,
959 HOW (R_PPC64_REL16_HIGHEST34, 1, 16, 0xffff, 50, TRUE, dont,
960 bfd_elf_generic_reloc),
962 HOW (R_PPC64_REL16_HIGHESTA34, 1, 16, 0xffff, 50, TRUE, dont,
965 HOW (R_PPC64_D28, 4, 28, 0xfff0000ffffULL, 0, FALSE, signed,
966 ppc64_elf_prefix_reloc),
968 HOW (R_PPC64_PCREL28, 4, 28, 0xfff0000ffffULL, 0, TRUE, signed,
969 ppc64_elf_prefix_reloc),
971 /* GNU extension to record C++ vtable hierarchy. */
972 HOW (R_PPC64_GNU_VTINHERIT, 0, 0, 0, 0, FALSE, dont,
975 /* GNU extension to record C++ vtable member usage. */
976 HOW (R_PPC64_GNU_VTENTRY, 0, 0, 0, 0, FALSE, dont,
981 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
985 ppc_howto_init (void)
987 unsigned int i, type;
989 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
991 type = ppc64_elf_howto_raw[i].type;
992 BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
993 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
997 static reloc_howto_type *
998 ppc64_elf_reloc_type_lookup (bfd *abfd,
999 bfd_reloc_code_real_type code)
1001 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
1003 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
1004 /* Initialize howto table if needed. */
1010 /* xgettext:c-format */
1011 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd,
1013 bfd_set_error (bfd_error_bad_value);
1016 case BFD_RELOC_NONE: r = R_PPC64_NONE;
1018 case BFD_RELOC_32: r = R_PPC64_ADDR32;
1020 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
1022 case BFD_RELOC_16: r = R_PPC64_ADDR16;
1024 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
1026 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
1028 case BFD_RELOC_PPC64_ADDR16_HIGH: r = R_PPC64_ADDR16_HIGH;
1030 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
1032 case BFD_RELOC_PPC64_ADDR16_HIGHA: r = R_PPC64_ADDR16_HIGHA;
1034 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
1036 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
1038 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
1040 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
1042 case BFD_RELOC_PPC64_REL24_NOTOC: r = R_PPC64_REL24_NOTOC;
1044 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
1046 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
1048 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
1050 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
1052 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
1054 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
1056 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
1058 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
1060 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
1062 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
1064 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
1066 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
1068 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
1070 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
1072 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
1074 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
1076 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
1078 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
1080 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
1082 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
1084 case BFD_RELOC_64: r = R_PPC64_ADDR64;
1086 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
1088 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
1090 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
1092 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
1094 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
1096 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
1098 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
1100 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
1102 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
1104 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
1106 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
1108 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
1110 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
1112 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
1114 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
1116 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
1118 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
1120 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
1122 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
1124 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
1126 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
1128 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
1130 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
1132 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
1134 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
1136 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
1138 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
1140 case BFD_RELOC_PPC64_TLS_PCREL:
1141 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
1143 case BFD_RELOC_PPC_TLSGD: r = R_PPC64_TLSGD;
1145 case BFD_RELOC_PPC_TLSLD: r = R_PPC64_TLSLD;
1147 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
1149 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
1151 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
1153 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
1155 case BFD_RELOC_PPC64_TPREL16_HIGH: r = R_PPC64_TPREL16_HIGH;
1157 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
1159 case BFD_RELOC_PPC64_TPREL16_HIGHA: r = R_PPC64_TPREL16_HIGHA;
1161 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
1163 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
1165 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
1167 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
1169 case BFD_RELOC_PPC64_DTPREL16_HIGH: r = R_PPC64_DTPREL16_HIGH;
1171 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
1173 case BFD_RELOC_PPC64_DTPREL16_HIGHA: r = R_PPC64_DTPREL16_HIGHA;
1175 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
1177 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
1179 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
1181 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
1183 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
1185 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
1187 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
1189 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
1191 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
1193 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
1195 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
1197 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
1199 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
1201 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
1203 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
1205 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
1207 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
1209 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
1211 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
1213 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
1215 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
1217 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
1219 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
1221 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
1223 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
1225 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
1227 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
1229 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
1231 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
1233 case BFD_RELOC_16_PCREL: r = R_PPC64_REL16;
1235 case BFD_RELOC_LO16_PCREL: r = R_PPC64_REL16_LO;
1237 case BFD_RELOC_HI16_PCREL: r = R_PPC64_REL16_HI;
1239 case BFD_RELOC_HI16_S_PCREL: r = R_PPC64_REL16_HA;
1241 case BFD_RELOC_PPC64_REL16_HIGH: r = R_PPC64_REL16_HIGH;
1243 case BFD_RELOC_PPC64_REL16_HIGHA: r = R_PPC64_REL16_HIGHA;
1245 case BFD_RELOC_PPC64_REL16_HIGHER: r = R_PPC64_REL16_HIGHER;
1247 case BFD_RELOC_PPC64_REL16_HIGHERA: r = R_PPC64_REL16_HIGHERA;
1249 case BFD_RELOC_PPC64_REL16_HIGHEST: r = R_PPC64_REL16_HIGHEST;
1251 case BFD_RELOC_PPC64_REL16_HIGHESTA: r = R_PPC64_REL16_HIGHESTA;
1253 case BFD_RELOC_PPC_16DX_HA: r = R_PPC64_16DX_HA;
1255 case BFD_RELOC_PPC_REL16DX_HA: r = R_PPC64_REL16DX_HA;
1257 case BFD_RELOC_PPC64_ENTRY: r = R_PPC64_ENTRY;
1259 case BFD_RELOC_PPC64_ADDR64_LOCAL: r = R_PPC64_ADDR64_LOCAL;
1261 case BFD_RELOC_PPC64_D34: r = R_PPC64_D34;
1263 case BFD_RELOC_PPC64_D34_LO: r = R_PPC64_D34_LO;
1265 case BFD_RELOC_PPC64_D34_HI30: r = R_PPC64_D34_HI30;
1267 case BFD_RELOC_PPC64_D34_HA30: r = R_PPC64_D34_HA30;
1269 case BFD_RELOC_PPC64_PCREL34: r = R_PPC64_PCREL34;
1271 case BFD_RELOC_PPC64_GOT_PCREL34: r = R_PPC64_GOT_PCREL34;
1273 case BFD_RELOC_PPC64_PLT_PCREL34: r = R_PPC64_PLT_PCREL34;
1275 case BFD_RELOC_PPC64_TPREL34: r = R_PPC64_TPREL34;
1277 case BFD_RELOC_PPC64_DTPREL34: r = R_PPC64_DTPREL34;
1279 case BFD_RELOC_PPC64_GOT_TLSGD34: r = R_PPC64_GOT_TLSGD34;
1281 case BFD_RELOC_PPC64_GOT_TLSLD34: r = R_PPC64_GOT_TLSLD34;
1283 case BFD_RELOC_PPC64_GOT_TPREL34: r = R_PPC64_GOT_TPREL34;
1285 case BFD_RELOC_PPC64_GOT_DTPREL34: r = R_PPC64_GOT_DTPREL34;
1287 case BFD_RELOC_PPC64_ADDR16_HIGHER34: r = R_PPC64_ADDR16_HIGHER34;
1289 case BFD_RELOC_PPC64_ADDR16_HIGHERA34: r = R_PPC64_ADDR16_HIGHERA34;
1291 case BFD_RELOC_PPC64_ADDR16_HIGHEST34: r = R_PPC64_ADDR16_HIGHEST34;
1293 case BFD_RELOC_PPC64_ADDR16_HIGHESTA34: r = R_PPC64_ADDR16_HIGHESTA34;
1295 case BFD_RELOC_PPC64_REL16_HIGHER34: r = R_PPC64_REL16_HIGHER34;
1297 case BFD_RELOC_PPC64_REL16_HIGHERA34: r = R_PPC64_REL16_HIGHERA34;
1299 case BFD_RELOC_PPC64_REL16_HIGHEST34: r = R_PPC64_REL16_HIGHEST34;
1301 case BFD_RELOC_PPC64_REL16_HIGHESTA34: r = R_PPC64_REL16_HIGHESTA34;
1303 case BFD_RELOC_PPC64_D28: r = R_PPC64_D28;
1305 case BFD_RELOC_PPC64_PCREL28: r = R_PPC64_PCREL28;
1307 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
1309 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
1313 return ppc64_elf_howto_table[r];
1316 static reloc_howto_type *
1317 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1322 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
1323 if (ppc64_elf_howto_raw[i].name != NULL
1324 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
1325 return &ppc64_elf_howto_raw[i];
1330 /* Set the howto pointer for a PowerPC ELF reloc. */
1333 ppc64_elf_info_to_howto (bfd *abfd, arelent *cache_ptr,
1334 Elf_Internal_Rela *dst)
1338 /* Initialize howto table if needed. */
1339 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
1342 type = ELF64_R_TYPE (dst->r_info);
1343 if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
1345 /* xgettext:c-format */
1346 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
1348 bfd_set_error (bfd_error_bad_value);
1351 cache_ptr->howto = ppc64_elf_howto_table[type];
1352 if (cache_ptr->howto == NULL || cache_ptr->howto->name == NULL)
1354 /* xgettext:c-format */
1355 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
1357 bfd_set_error (bfd_error_bad_value);
1364 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
1366 static bfd_reloc_status_type
1367 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1368 void *data, asection *input_section,
1369 bfd *output_bfd, char **error_message)
1371 enum elf_ppc64_reloc_type r_type;
1373 bfd_size_type octets;
1376 /* If this is a relocatable link (output_bfd test tells us), just
1377 call the generic function. Any adjustment will be done at final
1379 if (output_bfd != NULL)
1380 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1381 input_section, output_bfd, error_message);
1383 /* Adjust the addend for sign extension of the low 16 (or 34) bits.
1384 We won't actually be using the low bits, so trashing them
1386 r_type = reloc_entry->howto->type;
1387 if (r_type == R_PPC64_ADDR16_HIGHERA34
1388 || r_type == R_PPC64_ADDR16_HIGHESTA34
1389 || r_type == R_PPC64_REL16_HIGHERA34
1390 || r_type == R_PPC64_REL16_HIGHESTA34)
1391 reloc_entry->addend += 1ULL << 33;
1393 reloc_entry->addend += 1U << 15;
1394 if (r_type != R_PPC64_REL16DX_HA)
1395 return bfd_reloc_continue;
1398 if (!bfd_is_com_section (symbol->section))
1399 value = symbol->value;
1400 value += (reloc_entry->addend
1401 + symbol->section->output_offset
1402 + symbol->section->output_section->vma);
1403 value -= (reloc_entry->address
1404 + input_section->output_offset
1405 + input_section->output_section->vma);
1406 value = (bfd_signed_vma) value >> 16;
1408 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
1409 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
1411 insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
1412 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
1413 if (value + 0x8000 > 0xffff)
1414 return bfd_reloc_overflow;
1415 return bfd_reloc_ok;
1418 static bfd_reloc_status_type
1419 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1420 void *data, asection *input_section,
1421 bfd *output_bfd, char **error_message)
1423 if (output_bfd != NULL)
1424 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1425 input_section, output_bfd, error_message);
1427 if (strcmp (symbol->section->name, ".opd") == 0
1428 && (symbol->section->owner->flags & DYNAMIC) == 0)
1430 bfd_vma dest = opd_entry_value (symbol->section,
1431 symbol->value + reloc_entry->addend,
1433 if (dest != (bfd_vma) -1)
1434 reloc_entry->addend = dest - (symbol->value
1435 + symbol->section->output_section->vma
1436 + symbol->section->output_offset);
1440 elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
1442 if (symbol->section->owner != abfd
1443 && symbol->section->owner != NULL
1444 && abiversion (symbol->section->owner) >= 2)
1448 for (i = 0; i < symbol->section->owner->symcount; ++i)
1450 asymbol *symdef = symbol->section->owner->outsymbols[i];
1452 if (strcmp (symdef->name, symbol->name) == 0)
1454 elfsym = (elf_symbol_type *) symdef;
1460 += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
1462 return bfd_reloc_continue;
1465 static bfd_reloc_status_type
1466 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1467 void *data, asection *input_section,
1468 bfd *output_bfd, char **error_message)
1471 enum elf_ppc64_reloc_type r_type;
1472 bfd_size_type octets;
1473 /* Assume 'at' branch hints. */
1474 bfd_boolean is_isa_v2 = TRUE;
1476 /* If this is a relocatable link (output_bfd test tells us), just
1477 call the generic function. Any adjustment will be done at final
1479 if (output_bfd != NULL)
1480 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1481 input_section, output_bfd, error_message);
1483 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
1484 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
1485 insn &= ~(0x01 << 21);
1486 r_type = reloc_entry->howto->type;
1487 if (r_type == R_PPC64_ADDR14_BRTAKEN
1488 || r_type == R_PPC64_REL14_BRTAKEN)
1489 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
1493 /* Set 'a' bit. This is 0b00010 in BO field for branch
1494 on CR(BI) insns (BO == 001at or 011at), and 0b01000
1495 for branch on CTR insns (BO == 1a00t or 1a01t). */
1496 if ((insn & (0x14 << 21)) == (0x04 << 21))
1498 else if ((insn & (0x14 << 21)) == (0x10 << 21))
1508 if (!bfd_is_com_section (symbol->section))
1509 target = symbol->value;
1510 target += symbol->section->output_section->vma;
1511 target += symbol->section->output_offset;
1512 target += reloc_entry->addend;
1514 from = (reloc_entry->address
1515 + input_section->output_offset
1516 + input_section->output_section->vma);
1518 /* Invert 'y' bit if not the default. */
1519 if ((bfd_signed_vma) (target - from) < 0)
1522 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
1524 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
1525 input_section, output_bfd, error_message);
1528 static bfd_reloc_status_type
1529 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1530 void *data, asection *input_section,
1531 bfd *output_bfd, char **error_message)
1533 /* If this is a relocatable link (output_bfd test tells us), just
1534 call the generic function. Any adjustment will be done at final
1536 if (output_bfd != NULL)
1537 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1538 input_section, output_bfd, error_message);
1540 /* Subtract the symbol section base address. */
1541 reloc_entry->addend -= symbol->section->output_section->vma;
1542 return bfd_reloc_continue;
1545 static bfd_reloc_status_type
1546 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1547 void *data, asection *input_section,
1548 bfd *output_bfd, char **error_message)
1550 /* If this is a relocatable link (output_bfd test tells us), just
1551 call the generic function. Any adjustment will be done at final
1553 if (output_bfd != NULL)
1554 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1555 input_section, output_bfd, error_message);
1557 /* Subtract the symbol section base address. */
1558 reloc_entry->addend -= symbol->section->output_section->vma;
1560 /* Adjust the addend for sign extension of the low 16 bits. */
1561 reloc_entry->addend += 0x8000;
1562 return bfd_reloc_continue;
1565 static bfd_reloc_status_type
1566 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1567 void *data, asection *input_section,
1568 bfd *output_bfd, char **error_message)
1572 /* If this is a relocatable link (output_bfd test tells us), just
1573 call the generic function. Any adjustment will be done at final
1575 if (output_bfd != NULL)
1576 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1577 input_section, output_bfd, error_message);
1579 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
1581 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
1583 /* Subtract the TOC base address. */
1584 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
1585 return bfd_reloc_continue;
1588 static bfd_reloc_status_type
1589 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1590 void *data, asection *input_section,
1591 bfd *output_bfd, char **error_message)
1595 /* If this is a relocatable link (output_bfd test tells us), just
1596 call the generic function. Any adjustment will be done at final
1598 if (output_bfd != NULL)
1599 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1600 input_section, output_bfd, error_message);
1602 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
1604 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
1606 /* Subtract the TOC base address. */
1607 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
1609 /* Adjust the addend for sign extension of the low 16 bits. */
1610 reloc_entry->addend += 0x8000;
1611 return bfd_reloc_continue;
1614 static bfd_reloc_status_type
1615 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1616 void *data, asection *input_section,
1617 bfd *output_bfd, char **error_message)
1620 bfd_size_type octets;
1622 /* If this is a relocatable link (output_bfd test tells us), just
1623 call the generic function. Any adjustment will be done at final
1625 if (output_bfd != NULL)
1626 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1627 input_section, output_bfd, error_message);
1629 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
1631 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
1633 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
1634 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
1635 return bfd_reloc_ok;
1638 static bfd_reloc_status_type
1639 ppc64_elf_prefix_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1640 void *data, asection *input_section,
1641 bfd *output_bfd, char **error_message)
1646 if (output_bfd != NULL)
1647 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1648 input_section, output_bfd, error_message);
1650 insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
1652 insn |= bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address + 4);
1654 targ = (symbol->section->output_section->vma
1655 + symbol->section->output_offset
1656 + reloc_entry->addend);
1657 if (!bfd_is_com_section (symbol->section))
1658 targ += symbol->value;
1659 if (reloc_entry->howto->type == R_PPC64_D34_HA30)
1661 if (reloc_entry->howto->pc_relative)
1663 bfd_vma from = (reloc_entry->address
1664 + input_section->output_offset
1665 + input_section->output_section->vma);
1668 targ >>= reloc_entry->howto->rightshift;
1669 insn &= ~reloc_entry->howto->dst_mask;
1670 insn |= ((targ << 16) | (targ & 0xffff)) & reloc_entry->howto->dst_mask;
1671 bfd_put_32 (abfd, insn >> 32, (bfd_byte *) data + reloc_entry->address);
1672 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address + 4);
1673 if (reloc_entry->howto->complain_on_overflow == complain_overflow_signed
1674 && (targ + (1ULL << (reloc_entry->howto->bitsize - 1))
1675 >= 1ULL << reloc_entry->howto->bitsize))
1676 return bfd_reloc_overflow;
1677 return bfd_reloc_ok;
1680 static bfd_reloc_status_type
1681 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1682 void *data, asection *input_section,
1683 bfd *output_bfd, char **error_message)
1685 /* If this is a relocatable link (output_bfd test tells us), just
1686 call the generic function. Any adjustment will be done at final
1688 if (output_bfd != NULL)
1689 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1690 input_section, output_bfd, error_message);
1692 if (error_message != NULL)
1694 static char buf[60];
1695 sprintf (buf, "generic linker can't handle %s",
1696 reloc_entry->howto->name);
1697 *error_message = buf;
1699 return bfd_reloc_dangerous;
1702 /* Track GOT entries needed for a given symbol. We might need more
1703 than one got entry per symbol. */
1706 struct got_entry *next;
1708 /* The symbol addend that we'll be placing in the GOT. */
1711 /* Unlike other ELF targets, we use separate GOT entries for the same
1712 symbol referenced from different input files. This is to support
1713 automatic multiple TOC/GOT sections, where the TOC base can vary
1714 from one input file to another. After partitioning into TOC groups
1715 we merge entries within the group.
1717 Point to the BFD owning this GOT entry. */
1720 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
1721 TLS_TPREL or TLS_DTPREL for tls entries. */
1722 unsigned char tls_type;
1724 /* Non-zero if got.ent points to real entry. */
1725 unsigned char is_indirect;
1727 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
1730 bfd_signed_vma refcount;
1732 struct got_entry *ent;
1736 /* The same for PLT. */
1739 struct plt_entry *next;
1745 bfd_signed_vma refcount;
1750 struct ppc64_elf_obj_tdata
1752 struct elf_obj_tdata elf;
1754 /* Shortcuts to dynamic linker sections. */
1758 /* Used during garbage collection. We attach global symbols defined
1759 on removed .opd entries to this section so that the sym is removed. */
1760 asection *deleted_section;
1762 /* TLS local dynamic got entry handling. Support for multiple GOT
1763 sections means we potentially need one of these for each input bfd. */
1764 struct got_entry tlsld_got;
1768 /* A copy of relocs before they are modified for --emit-relocs. */
1769 Elf_Internal_Rela *relocs;
1771 /* Section contents. */
1775 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
1776 the reloc to be in the range -32768 to 32767. */
1777 unsigned int has_small_toc_reloc : 1;
1779 /* Set if toc/got ha relocs detected not using r2, or lo reloc
1780 instruction not one we handle. */
1781 unsigned int unexpected_toc_insn : 1;
1783 /* Set if PLT/GOT/TOC relocs that can be optimised are present in
1785 unsigned int has_optrel : 1;
1788 #define ppc64_elf_tdata(bfd) \
1789 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
1791 #define ppc64_tlsld_got(bfd) \
1792 (&ppc64_elf_tdata (bfd)->tlsld_got)
1794 #define is_ppc64_elf(bfd) \
1795 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
1796 && elf_object_id (bfd) == PPC64_ELF_DATA)
1798 /* Override the generic function because we store some extras. */
1801 ppc64_elf_mkobject (bfd *abfd)
1803 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
1807 /* Fix bad default arch selected for a 64 bit input bfd when the
1808 default is 32 bit. Also select arch based on apuinfo. */
1811 ppc64_elf_object_p (bfd *abfd)
1813 if (!abfd->arch_info->the_default)
1816 if (abfd->arch_info->bits_per_word == 32)
1818 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
1820 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
1822 /* Relies on arch after 32 bit default being 64 bit default. */
1823 abfd->arch_info = abfd->arch_info->next;
1824 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
1827 return _bfd_elf_ppc_set_arch (abfd);
1830 /* Support for core dump NOTE sections. */
1833 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
1835 size_t offset, size;
1837 if (note->descsz != 504)
1841 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
1844 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
1850 /* Make a ".reg/999" section. */
1851 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
1852 size, note->descpos + offset);
1856 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
1858 if (note->descsz != 136)
1861 elf_tdata (abfd)->core->pid
1862 = bfd_get_32 (abfd, note->descdata + 24);
1863 elf_tdata (abfd)->core->program
1864 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
1865 elf_tdata (abfd)->core->command
1866 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
1872 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
1882 char data[136] ATTRIBUTE_NONSTRING;
1885 va_start (ap, note_type);
1886 memset (data, 0, sizeof (data));
1887 strncpy (data + 40, va_arg (ap, const char *), 16);
1888 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
1890 /* GCC 8.0 and 8.1 warn about 80 equals destination size with
1891 -Wstringop-truncation:
1892 https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85643
1894 DIAGNOSTIC_IGNORE_STRINGOP_TRUNCATION;
1896 strncpy (data + 56, va_arg (ap, const char *), 80);
1897 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
1901 return elfcore_write_note (abfd, buf, bufsiz,
1902 "CORE", note_type, data, sizeof (data));
1913 va_start (ap, note_type);
1914 memset (data, 0, 112);
1915 pid = va_arg (ap, long);
1916 bfd_put_32 (abfd, pid, data + 32);
1917 cursig = va_arg (ap, int);
1918 bfd_put_16 (abfd, cursig, data + 12);
1919 greg = va_arg (ap, const void *);
1920 memcpy (data + 112, greg, 384);
1921 memset (data + 496, 0, 8);
1923 return elfcore_write_note (abfd, buf, bufsiz,
1924 "CORE", note_type, data, sizeof (data));
1929 /* Add extra PPC sections. */
1931 static const struct bfd_elf_special_section ppc64_elf_special_sections[] =
1933 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
1934 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
1935 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
1936 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
1937 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
1938 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
1939 { NULL, 0, 0, 0, 0 }
1942 enum _ppc64_sec_type {
1948 struct _ppc64_elf_section_data
1950 struct bfd_elf_section_data elf;
1954 /* An array with one entry for each opd function descriptor,
1955 and some spares since opd entries may be either 16 or 24 bytes. */
1956 #define OPD_NDX(OFF) ((OFF) >> 4)
1957 struct _opd_sec_data
1959 /* Points to the function code section for local opd entries. */
1960 asection **func_sec;
1962 /* After editing .opd, adjust references to opd local syms. */
1966 /* An array for toc sections, indexed by offset/8. */
1967 struct _toc_sec_data
1969 /* Specifies the relocation symbol index used at a given toc offset. */
1972 /* And the relocation addend. */
1977 enum _ppc64_sec_type sec_type:2;
1979 /* Flag set when small branches are detected. Used to
1980 select suitable defaults for the stub group size. */
1981 unsigned int has_14bit_branch:1;
1983 /* Flag set when PLTCALL relocs are detected. */
1984 unsigned int has_pltcall:1;
1986 /* Flag set when section has PLT/GOT/TOC relocations that can be
1988 unsigned int has_optrel:1;
1991 #define ppc64_elf_section_data(sec) \
1992 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
1995 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
1997 if (!sec->used_by_bfd)
1999 struct _ppc64_elf_section_data *sdata;
2000 bfd_size_type amt = sizeof (*sdata);
2002 sdata = bfd_zalloc (abfd, amt);
2005 sec->used_by_bfd = sdata;
2008 return _bfd_elf_new_section_hook (abfd, sec);
2011 static struct _opd_sec_data *
2012 get_opd_info (asection * sec)
2015 && ppc64_elf_section_data (sec) != NULL
2016 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2017 return &ppc64_elf_section_data (sec)->u.opd;
2021 /* Parameters for the qsort hook. */
2022 static bfd_boolean synthetic_relocatable;
2023 static asection *synthetic_opd;
2025 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
2028 compare_symbols (const void *ap, const void *bp)
2030 const asymbol *a = *(const asymbol **) ap;
2031 const asymbol *b = *(const asymbol **) bp;
2033 /* Section symbols first. */
2034 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
2036 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
2039 /* then .opd symbols. */
2040 if (synthetic_opd != NULL)
2042 if (strcmp (a->section->name, ".opd") == 0
2043 && strcmp (b->section->name, ".opd") != 0)
2045 if (strcmp (a->section->name, ".opd") != 0
2046 && strcmp (b->section->name, ".opd") == 0)
2050 /* then other code symbols. */
2051 if (((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2052 == (SEC_CODE | SEC_ALLOC))
2053 && ((b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2054 != (SEC_CODE | SEC_ALLOC)))
2057 if (((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2058 != (SEC_CODE | SEC_ALLOC))
2059 && ((b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2060 == (SEC_CODE | SEC_ALLOC)))
2063 if (synthetic_relocatable)
2065 if (a->section->id < b->section->id)
2068 if (a->section->id > b->section->id)
2072 if (a->value + a->section->vma < b->value + b->section->vma)
2075 if (a->value + a->section->vma > b->value + b->section->vma)
2078 /* For syms with the same value, prefer strong dynamic global function
2079 syms over other syms. */
2080 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
2083 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
2086 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
2089 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
2092 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
2095 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
2098 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
2101 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
2107 /* Search SYMS for a symbol of the given VALUE. */
2110 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
2114 if (id == (unsigned) -1)
2118 mid = (lo + hi) >> 1;
2119 if (syms[mid]->value + syms[mid]->section->vma < value)
2121 else if (syms[mid]->value + syms[mid]->section->vma > value)
2131 mid = (lo + hi) >> 1;
2132 if (syms[mid]->section->id < id)
2134 else if (syms[mid]->section->id > id)
2136 else if (syms[mid]->value < value)
2138 else if (syms[mid]->value > value)
2148 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
2150 bfd_vma vma = *(bfd_vma *) ptr;
2151 return ((section->flags & SEC_ALLOC) != 0
2152 && section->vma <= vma
2153 && vma < section->vma + section->size);
2156 /* Create synthetic symbols, effectively restoring "dot-symbol" function
2157 entry syms. Also generate @plt symbols for the glink branch table.
2158 Returns count of synthetic symbols in RET or -1 on error. */
2161 ppc64_elf_get_synthetic_symtab (bfd *abfd,
2162 long static_count, asymbol **static_syms,
2163 long dyn_count, asymbol **dyn_syms,
2169 size_t symcount, codesecsym, codesecsymend, secsymend, opdsymend;
2170 asection *opd = NULL;
2171 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2173 int abi = abiversion (abfd);
2179 opd = bfd_get_section_by_name (abfd, ".opd");
2180 if (opd == NULL && abi == 1)
2192 symcount = static_count;
2194 symcount += dyn_count;
2198 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
2202 if (!relocatable && static_count != 0 && dyn_count != 0)
2204 /* Use both symbol tables. */
2205 memcpy (syms, static_syms, static_count * sizeof (*syms));
2206 memcpy (syms + static_count, dyn_syms,
2207 (dyn_count + 1) * sizeof (*syms));
2209 else if (!relocatable && static_count == 0)
2210 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
2212 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
2214 /* Trim uninteresting symbols. Interesting symbols are section,
2215 function, and notype symbols. */
2216 for (i = 0, j = 0; i < symcount; ++i)
2217 if ((syms[i]->flags & (BSF_FILE | BSF_OBJECT | BSF_THREAD_LOCAL
2218 | BSF_RELC | BSF_SRELC)) == 0)
2219 syms[j++] = syms[i];
2222 synthetic_relocatable = relocatable;
2223 synthetic_opd = opd;
2224 qsort (syms, symcount, sizeof (*syms), compare_symbols);
2226 if (!relocatable && symcount > 1)
2228 /* Trim duplicate syms, since we may have merged the normal
2229 and dynamic symbols. Actually, we only care about syms
2230 that have different values, so trim any with the same
2231 value. Don't consider ifunc and ifunc resolver symbols
2232 duplicates however, because GDB wants to know whether a
2233 text symbol is an ifunc resolver. */
2234 for (i = 1, j = 1; i < symcount; ++i)
2236 const asymbol *s0 = syms[i - 1];
2237 const asymbol *s1 = syms[i];
2239 if ((s0->value + s0->section->vma
2240 != s1->value + s1->section->vma)
2241 || ((s0->flags & BSF_GNU_INDIRECT_FUNCTION)
2242 != (s1->flags & BSF_GNU_INDIRECT_FUNCTION)))
2243 syms[j++] = syms[i];
2249 /* Note that here and in compare_symbols we can't compare opd and
2250 sym->section directly. With separate debug info files, the
2251 symbols will be extracted from the debug file while abfd passed
2252 to this function is the real binary. */
2253 if (strcmp (syms[i]->section->name, ".opd") == 0)
2257 for (; i < symcount; ++i)
2258 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC
2259 | SEC_THREAD_LOCAL))
2260 != (SEC_CODE | SEC_ALLOC))
2261 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
2265 for (; i < symcount; ++i)
2266 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
2270 for (; i < symcount; ++i)
2271 if (strcmp (syms[i]->section->name, ".opd") != 0)
2275 for (; i < symcount; ++i)
2276 if (((syms[i]->section->flags
2277 & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL)))
2278 != (SEC_CODE | SEC_ALLOC))
2286 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
2291 if (opdsymend == secsymend)
2294 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
2295 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
2299 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
2306 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
2310 while (r < opd->relocation + relcount
2311 && r->address < syms[i]->value + opd->vma)
2314 if (r == opd->relocation + relcount)
2317 if (r->address != syms[i]->value + opd->vma)
2320 if (r->howto->type != R_PPC64_ADDR64)
2323 sym = *r->sym_ptr_ptr;
2324 if (!sym_exists_at (syms, opdsymend, symcount,
2325 sym->section->id, sym->value + r->addend))
2328 size += sizeof (asymbol);
2329 size += strlen (syms[i]->name) + 2;
2335 s = *ret = bfd_malloc (size);
2342 names = (char *) (s + count);
2344 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
2348 while (r < opd->relocation + relcount
2349 && r->address < syms[i]->value + opd->vma)
2352 if (r == opd->relocation + relcount)
2355 if (r->address != syms[i]->value + opd->vma)
2358 if (r->howto->type != R_PPC64_ADDR64)
2361 sym = *r->sym_ptr_ptr;
2362 if (!sym_exists_at (syms, opdsymend, symcount,
2363 sym->section->id, sym->value + r->addend))
2368 s->flags |= BSF_SYNTHETIC;
2369 s->section = sym->section;
2370 s->value = sym->value + r->addend;
2373 len = strlen (syms[i]->name);
2374 memcpy (names, syms[i]->name, len + 1);
2376 /* Have udata.p point back to the original symbol this
2377 synthetic symbol was derived from. */
2378 s->udata.p = syms[i];
2385 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
2386 bfd_byte *contents = NULL;
2388 size_t plt_count = 0;
2389 bfd_vma glink_vma = 0, resolv_vma = 0;
2390 asection *dynamic, *glink = NULL, *relplt = NULL;
2393 if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
2395 free_contents_and_exit_err:
2397 free_contents_and_exit:
2404 for (i = secsymend; i < opdsymend; ++i)
2408 /* Ignore bogus symbols. */
2409 if (syms[i]->value > opd->size - 8)
2412 ent = bfd_get_64 (abfd, contents + syms[i]->value);
2413 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
2416 size += sizeof (asymbol);
2417 size += strlen (syms[i]->name) + 2;
2421 /* Get start of .glink stubs from DT_PPC64_GLINK. */
2423 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
2425 bfd_byte *dynbuf, *extdyn, *extdynend;
2427 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
2429 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
2430 goto free_contents_and_exit_err;
2432 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
2433 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
2436 extdynend = extdyn + dynamic->size;
2437 for (; extdyn < extdynend; extdyn += extdynsize)
2439 Elf_Internal_Dyn dyn;
2440 (*swap_dyn_in) (abfd, extdyn, &dyn);
2442 if (dyn.d_tag == DT_NULL)
2445 if (dyn.d_tag == DT_PPC64_GLINK)
2447 /* The first glink stub starts at DT_PPC64_GLINK plus 32.
2448 See comment in ppc64_elf_finish_dynamic_sections. */
2449 glink_vma = dyn.d_un.d_val + 8 * 4;
2450 /* The .glink section usually does not survive the final
2451 link; search for the section (usually .text) where the
2452 glink stubs now reside. */
2453 glink = bfd_sections_find_if (abfd, section_covers_vma,
2464 /* Determine __glink trampoline by reading the relative branch
2465 from the first glink stub. */
2467 unsigned int off = 0;
2469 while (bfd_get_section_contents (abfd, glink, buf,
2470 glink_vma + off - glink->vma, 4))
2472 unsigned int insn = bfd_get_32 (abfd, buf);
2474 if ((insn & ~0x3fffffc) == 0)
2477 = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
2486 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
2488 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
2491 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
2492 if (!(*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
2493 goto free_contents_and_exit_err;
2495 plt_count = relplt->size / sizeof (Elf64_External_Rela);
2496 size += plt_count * sizeof (asymbol);
2498 p = relplt->relocation;
2499 for (i = 0; i < plt_count; i++, p++)
2501 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
2503 size += sizeof ("+0x") - 1 + 16;
2509 goto free_contents_and_exit;
2510 s = *ret = bfd_malloc (size);
2512 goto free_contents_and_exit_err;
2514 names = (char *) (s + count + plt_count + (resolv_vma != 0));
2516 for (i = secsymend; i < opdsymend; ++i)
2520 if (syms[i]->value > opd->size - 8)
2523 ent = bfd_get_64 (abfd, contents + syms[i]->value);
2524 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
2528 asection *sec = abfd->sections;
2535 size_t mid = (lo + hi) >> 1;
2536 if (syms[mid]->section->vma < ent)
2538 else if (syms[mid]->section->vma > ent)
2542 sec = syms[mid]->section;
2547 if (lo >= hi && lo > codesecsym)
2548 sec = syms[lo - 1]->section;
2550 for (; sec != NULL; sec = sec->next)
2554 /* SEC_LOAD may not be set if SEC is from a separate debug
2556 if ((sec->flags & SEC_ALLOC) == 0)
2558 if ((sec->flags & SEC_CODE) != 0)
2561 s->flags |= BSF_SYNTHETIC;
2562 s->value = ent - s->section->vma;
2565 len = strlen (syms[i]->name);
2566 memcpy (names, syms[i]->name, len + 1);
2568 /* Have udata.p point back to the original symbol this
2569 synthetic symbol was derived from. */
2570 s->udata.p = syms[i];
2576 if (glink != NULL && relplt != NULL)
2580 /* Add a symbol for the main glink trampoline. */
2581 memset (s, 0, sizeof *s);
2583 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
2585 s->value = resolv_vma - glink->vma;
2587 memcpy (names, "__glink_PLTresolve",
2588 sizeof ("__glink_PLTresolve"));
2589 names += sizeof ("__glink_PLTresolve");
2594 /* FIXME: It would be very much nicer to put sym@plt on the
2595 stub rather than on the glink branch table entry. The
2596 objdump disassembler would then use a sensible symbol
2597 name on plt calls. The difficulty in doing so is
2598 a) finding the stubs, and,
2599 b) matching stubs against plt entries, and,
2600 c) there can be multiple stubs for a given plt entry.
2602 Solving (a) could be done by code scanning, but older
2603 ppc64 binaries used different stubs to current code.
2604 (b) is the tricky one since you need to known the toc
2605 pointer for at least one function that uses a pic stub to
2606 be able to calculate the plt address referenced.
2607 (c) means gdb would need to set multiple breakpoints (or
2608 find the glink branch itself) when setting breakpoints
2609 for pending shared library loads. */
2610 p = relplt->relocation;
2611 for (i = 0; i < plt_count; i++, p++)
2615 *s = **p->sym_ptr_ptr;
2616 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
2617 we are defining a symbol, ensure one of them is set. */
2618 if ((s->flags & BSF_LOCAL) == 0)
2619 s->flags |= BSF_GLOBAL;
2620 s->flags |= BSF_SYNTHETIC;
2622 s->value = glink_vma - glink->vma;
2625 len = strlen ((*p->sym_ptr_ptr)->name);
2626 memcpy (names, (*p->sym_ptr_ptr)->name, len);
2630 memcpy (names, "+0x", sizeof ("+0x") - 1);
2631 names += sizeof ("+0x") - 1;
2632 bfd_sprintf_vma (abfd, names, p->addend);
2633 names += strlen (names);
2635 memcpy (names, "@plt", sizeof ("@plt"));
2636 names += sizeof ("@plt");
2656 /* The following functions are specific to the ELF linker, while
2657 functions above are used generally. Those named ppc64_elf_* are
2658 called by the main ELF linker code. They appear in this file more
2659 or less in the order in which they are called. eg.
2660 ppc64_elf_check_relocs is called early in the link process,
2661 ppc64_elf_finish_dynamic_sections is one of the last functions
2664 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
2665 functions have both a function code symbol and a function descriptor
2666 symbol. A call to foo in a relocatable object file looks like:
2673 The function definition in another object file might be:
2677 . .quad .TOC.@tocbase
2683 When the linker resolves the call during a static link, the branch
2684 unsurprisingly just goes to .foo and the .opd information is unused.
2685 If the function definition is in a shared library, things are a little
2686 different: The call goes via a plt call stub, the opd information gets
2687 copied to the plt, and the linker patches the nop.
2695 . std 2,40(1) # in practice, the call stub
2696 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
2697 . addi 11,11,Lfoo@toc@l # this is the general idea
2705 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
2707 The "reloc ()" notation is supposed to indicate that the linker emits
2708 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
2711 What are the difficulties here? Well, firstly, the relocations
2712 examined by the linker in check_relocs are against the function code
2713 sym .foo, while the dynamic relocation in the plt is emitted against
2714 the function descriptor symbol, foo. Somewhere along the line, we need
2715 to carefully copy dynamic link information from one symbol to the other.
2716 Secondly, the generic part of the elf linker will make .foo a dynamic
2717 symbol as is normal for most other backends. We need foo dynamic
2718 instead, at least for an application final link. However, when
2719 creating a shared library containing foo, we need to have both symbols
2720 dynamic so that references to .foo are satisfied during the early
2721 stages of linking. Otherwise the linker might decide to pull in a
2722 definition from some other object, eg. a static library.
2724 Update: As of August 2004, we support a new convention. Function
2725 calls may use the function descriptor symbol, ie. "bl foo". This
2726 behaves exactly as "bl .foo". */
2728 /* Of those relocs that might be copied as dynamic relocs, this
2729 function selects those that must be copied when linking a shared
2730 library or PIE, even when the symbol is local. */
2733 must_be_dyn_reloc (struct bfd_link_info *info,
2734 enum elf_ppc64_reloc_type r_type)
2739 /* Only relative relocs can be resolved when the object load
2740 address isn't fixed. DTPREL64 is excluded because the
2741 dynamic linker needs to differentiate global dynamic from
2742 local dynamic __tls_index pairs when PPC64_OPT_TLS is set. */
2750 case R_PPC64_TPREL16:
2751 case R_PPC64_TPREL16_LO:
2752 case R_PPC64_TPREL16_HI:
2753 case R_PPC64_TPREL16_HA:
2754 case R_PPC64_TPREL16_DS:
2755 case R_PPC64_TPREL16_LO_DS:
2756 case R_PPC64_TPREL16_HIGH:
2757 case R_PPC64_TPREL16_HIGHA:
2758 case R_PPC64_TPREL16_HIGHER:
2759 case R_PPC64_TPREL16_HIGHERA:
2760 case R_PPC64_TPREL16_HIGHEST:
2761 case R_PPC64_TPREL16_HIGHESTA:
2762 case R_PPC64_TPREL64:
2763 case R_PPC64_TPREL34:
2764 /* These relocations are relative but in a shared library the
2765 linker doesn't know the thread pointer base. */
2766 return bfd_link_dll (info);
2770 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
2771 copying dynamic variables from a shared lib into an app's dynbss
2772 section, and instead use a dynamic relocation to point into the
2773 shared lib. With code that gcc generates, it's vital that this be
2774 enabled; In the PowerPC64 ABI, the address of a function is actually
2775 the address of a function descriptor, which resides in the .opd
2776 section. gcc uses the descriptor directly rather than going via the
2777 GOT as some other ABI's do, which means that initialized function
2778 pointers must reference the descriptor. Thus, a function pointer
2779 initialized to the address of a function in a shared library will
2780 either require a copy reloc, or a dynamic reloc. Using a copy reloc
2781 redefines the function descriptor symbol to point to the copy. This
2782 presents a problem as a plt entry for that function is also
2783 initialized from the function descriptor symbol and the copy reloc
2784 may not be initialized first. */
2785 #define ELIMINATE_COPY_RELOCS 1
2787 /* Section name for stubs is the associated section name plus this
2789 #define STUB_SUFFIX ".stub"
2792 ppc_stub_long_branch:
2793 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
2794 destination, but a 24 bit branch in a stub section will reach.
2797 ppc_stub_plt_branch:
2798 Similar to the above, but a 24 bit branch in the stub section won't
2799 reach its destination.
2800 . addis %r11,%r2,xxx@toc@ha
2801 . ld %r12,xxx@toc@l(%r11)
2806 Used to call a function in a shared library. If it so happens that
2807 the plt entry referenced crosses a 64k boundary, then an extra
2808 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
2809 ppc_stub_plt_call_r2save starts with "std %r2,40(%r1)".
2810 . addis %r11,%r2,xxx@toc@ha
2811 . ld %r12,xxx+0@toc@l(%r11)
2813 . ld %r2,xxx+8@toc@l(%r11)
2814 . ld %r11,xxx+16@toc@l(%r11)
2817 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
2818 code to adjust the value and save r2 to support multiple toc sections.
2819 A ppc_stub_long_branch with an r2 offset looks like:
2821 . addis %r2,%r2,off@ha
2822 . addi %r2,%r2,off@l
2825 A ppc_stub_plt_branch with an r2 offset looks like:
2827 . addis %r11,%r2,xxx@toc@ha
2828 . ld %r12,xxx@toc@l(%r11)
2829 . addis %r2,%r2,off@ha
2830 . addi %r2,%r2,off@l
2834 All of the above stubs are shown as their ELFv1 variants. ELFv2
2835 variants exist too, simpler for plt calls since a new toc pointer
2836 and static chain are not loaded by the stub. In addition, ELFv2
2837 has some more complex stubs to handle calls marked with NOTOC
2838 relocs from functions where r2 is not a valid toc pointer. These
2839 come in two flavours, the ones shown below, and _both variants that
2840 start with "std %r2,24(%r1)" to save r2 in the unlikely event that
2841 one call is from a function where r2 is used as the toc pointer but
2842 needs a toc adjusting stub for small-model multi-toc, and another
2843 call is from a function where r2 is not valid.
2844 ppc_stub_long_branch_notoc:
2850 . addis %r12,%r11,dest-1b@ha
2851 . addi %r12,%r12,dest-1b@l
2854 ppc_stub_plt_branch_notoc:
2860 . lis %r12,xxx-1b@highest
2861 . ori %r12,%r12,xxx-1b@higher
2863 . oris %r12,%r12,xxx-1b@high
2864 . ori %r12,%r12,xxx-1b@l
2865 . add %r12,%r11,%r12
2869 ppc_stub_plt_call_notoc:
2875 . lis %r12,xxx-1b@highest
2876 . ori %r12,%r12,xxx-1b@higher
2878 . oris %r12,%r12,xxx-1b@high
2879 . ori %r12,%r12,xxx-1b@l
2880 . ldx %r12,%r11,%r12
2884 There are also ELFv1 powerxx variants of these stubs.
2885 ppc_stub_long_branch_notoc:
2886 . pla %r12,dest@pcrel
2888 ppc_stub_plt_branch_notoc:
2889 . lis %r11,(dest-1f)@highesta34
2890 . ori %r11,%r11,(dest-1f)@highera34
2892 . 1: pla %r12,dest@pcrel
2893 . add %r12,%r11,%r12
2896 ppc_stub_plt_call_notoc:
2897 . lis %r11,(xxx-1f)@highesta34
2898 . ori %r11,%r11,(xxx-1f)@highera34
2900 . 1: pla %r12,xxx@pcrel
2901 . ldx %r12,%r11,%r12
2905 In cases where the high instructions would add zero, they are
2906 omitted and following instructions modified in some cases.
2907 For example, a powerxx ppc_stub_plt_call_notoc might simplify down
2909 . pld %r12,xxx@pcrel
2913 For a given stub group (a set of sections all using the same toc
2914 pointer value) there will be just one stub type used for any
2915 particular function symbol. For example, if printf is called from
2916 code with the tocsave optimization (ie. r2 saved in function
2917 prologue) and therefore calls use a ppc_stub_plt_call linkage stub,
2918 and from other code without the tocsave optimization requiring a
2919 ppc_stub_plt_call_r2save linkage stub, a single stub of the latter
2920 type will be created. Calls with the tocsave optimization will
2921 enter this stub after the instruction saving r2. A similar
2922 situation exists when calls are marked with R_PPC64_REL24_NOTOC
2923 relocations. These require a ppc_stub_plt_call_notoc linkage stub
2924 to call an external function like printf. If other calls to printf
2925 require a ppc_stub_plt_call linkage stub then a single
2926 ppc_stub_plt_call_notoc linkage stub will be used for both types of
2927 call. If other calls to printf require a ppc_stub_plt_call_r2save
2928 linkage stub then a single ppc_stub_plt_call_both linkage stub will
2929 be created and calls not requiring r2 to be saved will enter the
2930 stub after the r2 save instruction. There is an analogous
2931 hierarchy of long branch and plt branch stubs for local call
2937 ppc_stub_long_branch,
2938 ppc_stub_long_branch_r2off,
2939 ppc_stub_long_branch_notoc,
2940 ppc_stub_long_branch_both, /* r2off and notoc variants both needed. */
2941 ppc_stub_plt_branch,
2942 ppc_stub_plt_branch_r2off,
2943 ppc_stub_plt_branch_notoc,
2944 ppc_stub_plt_branch_both,
2946 ppc_stub_plt_call_r2save,
2947 ppc_stub_plt_call_notoc,
2948 ppc_stub_plt_call_both,
2949 ppc_stub_global_entry,
2953 /* Information on stub grouping. */
2956 /* The stub section. */
2958 /* This is the section to which stubs in the group will be attached. */
2961 struct map_stub *next;
2962 /* Whether to emit a copy of register save/restore functions in this
2965 /* Current offset within stubs after the insn restoring lr in a
2966 _notoc or _both stub using bcl for pc-relative addressing, or
2967 after the insn restoring lr in a __tls_get_addr_opt plt stub. */
2968 unsigned int lr_restore;
2969 /* Accumulated size of EH info emitted to describe return address
2970 if stubs modify lr. Does not include 17 byte FDE header. */
2971 unsigned int eh_size;
2972 /* Offset in glink_eh_frame to the start of EH info for this group. */
2973 unsigned int eh_base;
2976 struct ppc_stub_hash_entry
2978 /* Base hash table entry structure. */
2979 struct bfd_hash_entry root;
2981 enum ppc_stub_type stub_type;
2983 /* Group information. */
2984 struct map_stub *group;
2986 /* Offset within stub_sec of the beginning of this stub. */
2987 bfd_vma stub_offset;
2989 /* Given the symbol's value and its section we can determine its final
2990 value when building the stubs (so the stub knows where to jump. */
2991 bfd_vma target_value;
2992 asection *target_section;
2994 /* The symbol table entry, if any, that this was derived from. */
2995 struct ppc_link_hash_entry *h;
2996 struct plt_entry *plt_ent;
2999 unsigned char symtype;
3001 /* Symbol st_other. */
3002 unsigned char other;
3005 struct ppc_branch_hash_entry
3007 /* Base hash table entry structure. */
3008 struct bfd_hash_entry root;
3010 /* Offset within branch lookup table. */
3011 unsigned int offset;
3013 /* Generation marker. */
3017 /* Used to track dynamic relocations for local symbols. */
3018 struct ppc_dyn_relocs
3020 struct ppc_dyn_relocs *next;
3022 /* The input section of the reloc. */
3025 /* Total number of relocs copied for the input section. */
3026 unsigned int count : 31;
3028 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3029 unsigned int ifunc : 1;
3032 struct ppc_link_hash_entry
3034 struct elf_link_hash_entry elf;
3038 /* A pointer to the most recently used stub hash entry against this
3040 struct ppc_stub_hash_entry *stub_cache;
3042 /* A pointer to the next symbol starting with a '.' */
3043 struct ppc_link_hash_entry *next_dot_sym;
3046 /* Track dynamic relocs copied for this symbol. */
3047 struct elf_dyn_relocs *dyn_relocs;
3049 /* Link between function code and descriptor symbols. */
3050 struct ppc_link_hash_entry *oh;
3052 /* Flag function code and descriptor symbols. */
3053 unsigned int is_func:1;
3054 unsigned int is_func_descriptor:1;
3055 unsigned int fake:1;
3057 /* Whether global opd/toc sym has been adjusted or not.
3058 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3059 should be set for all globals defined in any opd/toc section. */
3060 unsigned int adjust_done:1;
3062 /* Set if this is an out-of-line register save/restore function,
3063 with non-standard calling convention. */
3064 unsigned int save_res:1;
3066 /* Set if a duplicate symbol with non-zero localentry is detected,
3067 even when the duplicate symbol does not provide a definition. */
3068 unsigned int non_zero_localentry:1;
3070 /* Contexts in which symbol is used in the GOT (or TOC).
3071 Bits are or'd into the mask as the corresponding relocs are
3072 encountered during check_relocs, with TLS_TLS being set when any
3073 of the other TLS bits are set. tls_optimize clears bits when
3074 optimizing to indicate the corresponding GOT entry type is not
3075 needed. If set, TLS_TLS is never cleared. tls_optimize may also
3076 set TLS_GDIE when a GD reloc turns into an IE one.
3077 These flags are also kept for local symbols. */
3078 #define TLS_TLS 1 /* Any TLS reloc. */
3079 #define TLS_GD 2 /* GD reloc. */
3080 #define TLS_LD 4 /* LD reloc. */
3081 #define TLS_TPREL 8 /* TPREL reloc, => IE. */
3082 #define TLS_DTPREL 16 /* DTPREL reloc, => LD. */
3083 #define TLS_MARK 32 /* __tls_get_addr call marked. */
3084 #define TLS_GDIE 64 /* GOT TPREL reloc resulting from GD->IE. */
3085 #define TLS_EXPLICIT 256 /* TOC section TLS reloc, not stored. */
3086 unsigned char tls_mask;
3088 /* The above field is also used to mark function symbols. In which
3089 case TLS_TLS will be 0. */
3090 #define PLT_IFUNC 2 /* STT_GNU_IFUNC. */
3091 #define PLT_KEEP 4 /* inline plt call requires plt entry. */
3092 #define NON_GOT 256 /* local symbol plt, not stored. */
3095 /* ppc64 ELF linker hash table. */
3097 struct ppc_link_hash_table
3099 struct elf_link_hash_table elf;
3101 /* The stub hash table. */
3102 struct bfd_hash_table stub_hash_table;
3104 /* Another hash table for plt_branch stubs. */
3105 struct bfd_hash_table branch_hash_table;
3107 /* Hash table for function prologue tocsave. */
3108 htab_t tocsave_htab;
3110 /* Various options and other info passed from the linker. */
3111 struct ppc64_elf_params *params;
3113 /* The size of sec_info below. */
3114 unsigned int sec_info_arr_size;
3116 /* Per-section array of extra section info. Done this way rather
3117 than as part of ppc64_elf_section_data so we have the info for
3118 non-ppc64 sections. */
3121 /* Along with elf_gp, specifies the TOC pointer used by this section. */
3126 /* The section group that this section belongs to. */
3127 struct map_stub *group;
3128 /* A temp section list pointer. */
3133 /* Linked list of groups. */
3134 struct map_stub *group;
3136 /* Temp used when calculating TOC pointers. */
3139 asection *toc_first_sec;
3141 /* Used when adding symbols. */
3142 struct ppc_link_hash_entry *dot_syms;
3144 /* Shortcuts to get to dynamic linker sections. */
3146 asection *global_entry;
3149 asection *relpltlocal;
3152 asection *glink_eh_frame;
3154 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
3155 struct ppc_link_hash_entry *tls_get_addr;
3156 struct ppc_link_hash_entry *tls_get_addr_fd;
3158 /* The size of reliplt used by got entry relocs. */
3159 bfd_size_type got_reli_size;
3162 unsigned long stub_count[ppc_stub_global_entry];
3164 /* Number of stubs against global syms. */
3165 unsigned long stub_globals;
3167 /* Set if we're linking code with function descriptors. */
3168 unsigned int opd_abi:1;
3170 /* Support for multiple toc sections. */
3171 unsigned int do_multi_toc:1;
3172 unsigned int multi_toc_needed:1;
3173 unsigned int second_toc_pass:1;
3174 unsigned int do_toc_opt:1;
3176 /* Set if tls optimization is enabled. */
3177 unsigned int do_tls_opt:1;
3179 /* Set if inline plt calls should be converted to direct calls. */
3180 unsigned int can_convert_all_inline_plt:1;
3183 unsigned int stub_error:1;
3185 /* Whether func_desc_adjust needs to be run over symbols. */
3186 unsigned int need_func_desc_adj:1;
3188 /* Whether there exist local gnu indirect function resolvers,
3189 referenced by dynamic relocations. */
3190 unsigned int local_ifunc_resolver:1;
3191 unsigned int maybe_local_ifunc_resolver:1;
3193 /* Whether plt calls for ELFv2 localentry:0 funcs have been optimized. */
3194 unsigned int has_plt_localentry0:1;
3196 /* Whether calls are made via the PLT from NOTOC functions. */
3197 unsigned int notoc_plt:1;
3199 /* Whether to use powerxx instructions in linkage stubs. */
3200 unsigned int powerxx_stubs:1;
3202 /* Incremented every time we size stubs. */
3203 unsigned int stub_iteration;
3205 /* Small local sym cache. */
3206 struct sym_cache sym_cache;
3209 /* Rename some of the generic section flags to better document how they
3212 /* Nonzero if this section has TLS related relocations. */
3213 #define has_tls_reloc sec_flg0
3215 /* Nonzero if this section has an old-style call to __tls_get_addr. */
3216 #define has_tls_get_addr_call sec_flg1
3218 /* Nonzero if this section has any toc or got relocs. */
3219 #define has_toc_reloc sec_flg2
3221 /* Nonzero if this section has a call to another section that uses
3223 #define makes_toc_func_call sec_flg3
3225 /* Recursion protection when determining above flag. */
3226 #define call_check_in_progress sec_flg4
3227 #define call_check_done sec_flg5
3229 /* Get the ppc64 ELF linker hash table from a link_info structure. */
3231 #define ppc_hash_table(p) \
3232 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3233 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3235 #define ppc_stub_hash_lookup(table, string, create, copy) \
3236 ((struct ppc_stub_hash_entry *) \
3237 bfd_hash_lookup ((table), (string), (create), (copy)))
3239 #define ppc_branch_hash_lookup(table, string, create, copy) \
3240 ((struct ppc_branch_hash_entry *) \
3241 bfd_hash_lookup ((table), (string), (create), (copy)))
3243 /* Create an entry in the stub hash table. */
3245 static struct bfd_hash_entry *
3246 stub_hash_newfunc (struct bfd_hash_entry *entry,
3247 struct bfd_hash_table *table,
3250 /* Allocate the structure if it has not already been allocated by a
3254 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
3259 /* Call the allocation method of the superclass. */
3260 entry = bfd_hash_newfunc (entry, table, string);
3263 struct ppc_stub_hash_entry *eh;
3265 /* Initialize the local fields. */
3266 eh = (struct ppc_stub_hash_entry *) entry;
3267 eh->stub_type = ppc_stub_none;
3269 eh->stub_offset = 0;
3270 eh->target_value = 0;
3271 eh->target_section = NULL;
3280 /* Create an entry in the branch hash table. */
3282 static struct bfd_hash_entry *
3283 branch_hash_newfunc (struct bfd_hash_entry *entry,
3284 struct bfd_hash_table *table,
3287 /* Allocate the structure if it has not already been allocated by a
3291 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
3296 /* Call the allocation method of the superclass. */
3297 entry = bfd_hash_newfunc (entry, table, string);
3300 struct ppc_branch_hash_entry *eh;
3302 /* Initialize the local fields. */
3303 eh = (struct ppc_branch_hash_entry *) entry;
3311 /* Create an entry in a ppc64 ELF linker hash table. */
3313 static struct bfd_hash_entry *
3314 link_hash_newfunc (struct bfd_hash_entry *entry,
3315 struct bfd_hash_table *table,
3318 /* Allocate the structure if it has not already been allocated by a
3322 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
3327 /* Call the allocation method of the superclass. */
3328 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
3331 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
3333 memset (&eh->u.stub_cache, 0,
3334 (sizeof (struct ppc_link_hash_entry)
3335 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
3337 /* When making function calls, old ABI code references function entry
3338 points (dot symbols), while new ABI code references the function
3339 descriptor symbol. We need to make any combination of reference and
3340 definition work together, without breaking archive linking.
3342 For a defined function "foo" and an undefined call to "bar":
3343 An old object defines "foo" and ".foo", references ".bar" (possibly
3345 A new object defines "foo" and references "bar".
3347 A new object thus has no problem with its undefined symbols being
3348 satisfied by definitions in an old object. On the other hand, the
3349 old object won't have ".bar" satisfied by a new object.
3351 Keep a list of newly added dot-symbols. */
3353 if (string[0] == '.')
3355 struct ppc_link_hash_table *htab;
3357 htab = (struct ppc_link_hash_table *) table;
3358 eh->u.next_dot_sym = htab->dot_syms;
3359 htab->dot_syms = eh;
3366 struct tocsave_entry
3373 tocsave_htab_hash (const void *p)
3375 const struct tocsave_entry *e = (const struct tocsave_entry *) p;
3376 return ((bfd_vma) (intptr_t) e->sec ^ e->offset) >> 3;
3380 tocsave_htab_eq (const void *p1, const void *p2)
3382 const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
3383 const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
3384 return e1->sec == e2->sec && e1->offset == e2->offset;
3387 /* Destroy a ppc64 ELF linker hash table. */
3390 ppc64_elf_link_hash_table_free (bfd *obfd)
3392 struct ppc_link_hash_table *htab;
3394 htab = (struct ppc_link_hash_table *) obfd->link.hash;
3395 if (htab->tocsave_htab)
3396 htab_delete (htab->tocsave_htab);
3397 bfd_hash_table_free (&htab->branch_hash_table);
3398 bfd_hash_table_free (&htab->stub_hash_table);
3399 _bfd_elf_link_hash_table_free (obfd);
3402 /* Create a ppc64 ELF linker hash table. */
3404 static struct bfd_link_hash_table *
3405 ppc64_elf_link_hash_table_create (bfd *abfd)
3407 struct ppc_link_hash_table *htab;
3408 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
3410 htab = bfd_zmalloc (amt);
3414 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
3415 sizeof (struct ppc_link_hash_entry),
3422 /* Init the stub hash table too. */
3423 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
3424 sizeof (struct ppc_stub_hash_entry)))
3426 _bfd_elf_link_hash_table_free (abfd);
3430 /* And the branch hash table. */
3431 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
3432 sizeof (struct ppc_branch_hash_entry)))
3434 bfd_hash_table_free (&htab->stub_hash_table);
3435 _bfd_elf_link_hash_table_free (abfd);
3439 htab->tocsave_htab = htab_try_create (1024,
3443 if (htab->tocsave_htab == NULL)
3445 ppc64_elf_link_hash_table_free (abfd);
3448 htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
3450 /* Initializing two fields of the union is just cosmetic. We really
3451 only care about glist, but when compiled on a 32-bit host the
3452 bfd_vma fields are larger. Setting the bfd_vma to zero makes
3453 debugger inspection of these fields look nicer. */
3454 htab->elf.init_got_refcount.refcount = 0;
3455 htab->elf.init_got_refcount.glist = NULL;
3456 htab->elf.init_plt_refcount.refcount = 0;
3457 htab->elf.init_plt_refcount.glist = NULL;
3458 htab->elf.init_got_offset.offset = 0;
3459 htab->elf.init_got_offset.glist = NULL;
3460 htab->elf.init_plt_offset.offset = 0;
3461 htab->elf.init_plt_offset.glist = NULL;
3463 return &htab->elf.root;
3466 /* Create sections for linker generated code. */
3469 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
3471 struct ppc_link_hash_table *htab;
3474 htab = ppc_hash_table (info);
3476 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
3477 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3478 if (htab->params->save_restore_funcs)
3480 /* Create .sfpr for code to save and restore fp regs. */
3481 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
3483 if (htab->sfpr == NULL
3484 || !bfd_set_section_alignment (dynobj, htab->sfpr, 2))
3488 if (bfd_link_relocatable (info))
3491 /* Create .glink for lazy dynamic linking support. */
3492 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
3494 if (htab->glink == NULL
3495 || !bfd_set_section_alignment (dynobj, htab->glink, 3))
3498 /* The part of .glink used by global entry stubs, separate so that
3499 it can be aligned appropriately without affecting htab->glink. */
3500 htab->global_entry = bfd_make_section_anyway_with_flags (dynobj, ".glink",
3502 if (htab->global_entry == NULL
3503 || !bfd_set_section_alignment (dynobj, htab->global_entry, 2))
3506 if (!info->no_ld_generated_unwind_info)
3508 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
3509 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3510 htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
3513 if (htab->glink_eh_frame == NULL
3514 || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
3518 flags = SEC_ALLOC | SEC_LINKER_CREATED;
3519 htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
3520 if (htab->elf.iplt == NULL
3521 || !bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
3524 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
3525 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3527 = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
3528 if (htab->elf.irelplt == NULL
3529 || !bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
3532 /* Create branch lookup table for plt_branch stubs. */
3533 flags = (SEC_ALLOC | SEC_LOAD
3534 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3535 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
3537 if (htab->brlt == NULL
3538 || !bfd_set_section_alignment (dynobj, htab->brlt, 3))
3541 /* Local plt entries, put in .branch_lt but a separate section for
3543 htab->pltlocal = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
3545 if (htab->pltlocal == NULL
3546 || !bfd_set_section_alignment (dynobj, htab->pltlocal, 3))
3549 if (!bfd_link_pic (info))
3552 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
3553 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3555 = bfd_make_section_anyway_with_flags (dynobj, ".rela.branch_lt", flags);
3556 if (htab->relbrlt == NULL
3557 || !bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
3561 = bfd_make_section_anyway_with_flags (dynobj, ".rela.branch_lt", flags);
3562 if (htab->relpltlocal == NULL
3563 || !bfd_set_section_alignment (dynobj, htab->relpltlocal, 3))
3569 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
3572 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
3573 struct ppc64_elf_params *params)
3575 struct ppc_link_hash_table *htab;
3577 elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
3579 /* Always hook our dynamic sections into the first bfd, which is the
3580 linker created stub bfd. This ensures that the GOT header is at
3581 the start of the output TOC section. */
3582 htab = ppc_hash_table (info);
3583 htab->elf.dynobj = params->stub_bfd;
3584 htab->params = params;
3586 return create_linkage_sections (htab->elf.dynobj, info);
3589 /* Build a name for an entry in the stub hash table. */
3592 ppc_stub_name (const asection *input_section,
3593 const asection *sym_sec,
3594 const struct ppc_link_hash_entry *h,
3595 const Elf_Internal_Rela *rel)
3600 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
3601 offsets from a sym as a branch target? In fact, we could
3602 probably assume the addend is always zero. */
3603 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
3607 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
3608 stub_name = bfd_malloc (len);
3609 if (stub_name == NULL)
3612 len = sprintf (stub_name, "%08x.%s+%x",
3613 input_section->id & 0xffffffff,
3614 h->elf.root.root.string,
3615 (int) rel->r_addend & 0xffffffff);
3619 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
3620 stub_name = bfd_malloc (len);
3621 if (stub_name == NULL)
3624 len = sprintf (stub_name, "%08x.%x:%x+%x",
3625 input_section->id & 0xffffffff,
3626 sym_sec->id & 0xffffffff,
3627 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
3628 (int) rel->r_addend & 0xffffffff);
3630 if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
3631 stub_name[len - 2] = 0;
3635 /* Look up an entry in the stub hash. Stub entries are cached because
3636 creating the stub name takes a bit of time. */
3638 static struct ppc_stub_hash_entry *
3639 ppc_get_stub_entry (const asection *input_section,
3640 const asection *sym_sec,
3641 struct ppc_link_hash_entry *h,
3642 const Elf_Internal_Rela *rel,
3643 struct ppc_link_hash_table *htab)
3645 struct ppc_stub_hash_entry *stub_entry;
3646 struct map_stub *group;
3648 /* If this input section is part of a group of sections sharing one
3649 stub section, then use the id of the first section in the group.
3650 Stub names need to include a section id, as there may well be
3651 more than one stub used to reach say, printf, and we need to
3652 distinguish between them. */
3653 group = htab->sec_info[input_section->id].u.group;
3657 if (h != NULL && h->u.stub_cache != NULL
3658 && h->u.stub_cache->h == h
3659 && h->u.stub_cache->group == group)
3661 stub_entry = h->u.stub_cache;
3667 stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
3668 if (stub_name == NULL)
3671 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
3672 stub_name, FALSE, FALSE);
3674 h->u.stub_cache = stub_entry;
3682 /* Add a new stub entry to the stub hash. Not all fields of the new
3683 stub entry are initialised. */
3685 static struct ppc_stub_hash_entry *
3686 ppc_add_stub (const char *stub_name,
3688 struct bfd_link_info *info)
3690 struct ppc_link_hash_table *htab = ppc_hash_table (info);
3691 struct map_stub *group;
3694 struct ppc_stub_hash_entry *stub_entry;
3696 group = htab->sec_info[section->id].u.group;
3697 link_sec = group->link_sec;
3698 stub_sec = group->stub_sec;
3699 if (stub_sec == NULL)
3705 namelen = strlen (link_sec->name);
3706 len = namelen + sizeof (STUB_SUFFIX);
3707 s_name = bfd_alloc (htab->params->stub_bfd, len);
3711 memcpy (s_name, link_sec->name, namelen);
3712 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
3713 stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
3714 if (stub_sec == NULL)
3716 group->stub_sec = stub_sec;
3719 /* Enter this entry into the linker stub hash table. */
3720 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
3722 if (stub_entry == NULL)
3724 /* xgettext:c-format */
3725 _bfd_error_handler (_("%pB: cannot create stub entry %s"),
3726 section->owner, stub_name);
3730 stub_entry->group = group;
3731 stub_entry->stub_offset = 0;
3735 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
3736 not already done. */
3739 create_got_section (bfd *abfd, struct bfd_link_info *info)
3741 asection *got, *relgot;
3743 struct ppc_link_hash_table *htab = ppc_hash_table (info);
3745 if (!is_ppc64_elf (abfd))
3751 && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
3754 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3755 | SEC_LINKER_CREATED);
3757 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
3759 || !bfd_set_section_alignment (abfd, got, 3))
3762 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
3763 flags | SEC_READONLY);
3765 || !bfd_set_section_alignment (abfd, relgot, 3))
3768 ppc64_elf_tdata (abfd)->got = got;
3769 ppc64_elf_tdata (abfd)->relgot = relgot;
3773 /* Follow indirect and warning symbol links. */
3775 static inline struct bfd_link_hash_entry *
3776 follow_link (struct bfd_link_hash_entry *h)
3778 while (h->type == bfd_link_hash_indirect
3779 || h->type == bfd_link_hash_warning)
3784 static inline struct elf_link_hash_entry *
3785 elf_follow_link (struct elf_link_hash_entry *h)
3787 return (struct elf_link_hash_entry *) follow_link (&h->root);
3790 static inline struct ppc_link_hash_entry *
3791 ppc_follow_link (struct ppc_link_hash_entry *h)
3793 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
3796 /* Merge PLT info on FROM with that on TO. */
3799 move_plt_plist (struct ppc_link_hash_entry *from,
3800 struct ppc_link_hash_entry *to)
3802 if (from->elf.plt.plist != NULL)
3804 if (to->elf.plt.plist != NULL)
3806 struct plt_entry **entp;
3807 struct plt_entry *ent;
3809 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
3811 struct plt_entry *dent;
3813 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
3814 if (dent->addend == ent->addend)
3816 dent->plt.refcount += ent->plt.refcount;
3823 *entp = to->elf.plt.plist;
3826 to->elf.plt.plist = from->elf.plt.plist;
3827 from->elf.plt.plist = NULL;
3831 /* Copy the extra info we tack onto an elf_link_hash_entry. */
3834 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
3835 struct elf_link_hash_entry *dir,
3836 struct elf_link_hash_entry *ind)
3838 struct ppc_link_hash_entry *edir, *eind;
3840 edir = (struct ppc_link_hash_entry *) dir;
3841 eind = (struct ppc_link_hash_entry *) ind;
3843 edir->is_func |= eind->is_func;
3844 edir->is_func_descriptor |= eind->is_func_descriptor;
3845 edir->tls_mask |= eind->tls_mask;
3846 if (eind->oh != NULL)
3847 edir->oh = ppc_follow_link (eind->oh);
3849 if (edir->elf.versioned != versioned_hidden)
3850 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
3851 edir->elf.ref_regular |= eind->elf.ref_regular;
3852 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
3853 edir->elf.non_got_ref |= eind->elf.non_got_ref;
3854 edir->elf.needs_plt |= eind->elf.needs_plt;
3855 edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
3857 /* If we were called to copy over info for a weak sym, don't copy
3858 dyn_relocs, plt/got info, or dynindx. We used to copy dyn_relocs
3859 in order to simplify readonly_dynrelocs and save a field in the
3860 symbol hash entry, but that means dyn_relocs can't be used in any
3861 tests about a specific symbol, or affect other symbol flags which
3863 if (eind->elf.root.type != bfd_link_hash_indirect)
3866 /* Copy over any dynamic relocs we may have on the indirect sym. */
3867 if (eind->dyn_relocs != NULL)
3869 if (edir->dyn_relocs != NULL)
3871 struct elf_dyn_relocs **pp;
3872 struct elf_dyn_relocs *p;
3874 /* Add reloc counts against the indirect sym to the direct sym
3875 list. Merge any entries against the same section. */
3876 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
3878 struct elf_dyn_relocs *q;
3880 for (q = edir->dyn_relocs; q != NULL; q = q->next)
3881 if (q->sec == p->sec)
3883 q->pc_count += p->pc_count;
3884 q->count += p->count;
3891 *pp = edir->dyn_relocs;
3894 edir->dyn_relocs = eind->dyn_relocs;
3895 eind->dyn_relocs = NULL;
3898 /* Copy over got entries that we may have already seen to the
3899 symbol which just became indirect. */
3900 if (eind->elf.got.glist != NULL)
3902 if (edir->elf.got.glist != NULL)
3904 struct got_entry **entp;
3905 struct got_entry *ent;
3907 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
3909 struct got_entry *dent;
3911 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
3912 if (dent->addend == ent->addend
3913 && dent->owner == ent->owner
3914 && dent->tls_type == ent->tls_type)
3916 dent->got.refcount += ent->got.refcount;
3923 *entp = edir->elf.got.glist;
3926 edir->elf.got.glist = eind->elf.got.glist;
3927 eind->elf.got.glist = NULL;
3930 /* And plt entries. */
3931 move_plt_plist (eind, edir);
3933 if (eind->elf.dynindx != -1)
3935 if (edir->elf.dynindx != -1)
3936 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
3937 edir->elf.dynstr_index);
3938 edir->elf.dynindx = eind->elf.dynindx;
3939 edir->elf.dynstr_index = eind->elf.dynstr_index;
3940 eind->elf.dynindx = -1;
3941 eind->elf.dynstr_index = 0;
3945 /* Find the function descriptor hash entry from the given function code
3946 hash entry FH. Link the entries via their OH fields. */
3948 static struct ppc_link_hash_entry *
3949 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
3951 struct ppc_link_hash_entry *fdh = fh->oh;
3955 const char *fd_name = fh->elf.root.root.string + 1;
3957 fdh = (struct ppc_link_hash_entry *)
3958 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
3962 fdh->is_func_descriptor = 1;
3968 fdh = ppc_follow_link (fdh);
3969 fdh->is_func_descriptor = 1;
3974 /* Make a fake function descriptor sym for the undefined code sym FH. */
3976 static struct ppc_link_hash_entry *
3977 make_fdh (struct bfd_link_info *info,
3978 struct ppc_link_hash_entry *fh)
3980 bfd *abfd = fh->elf.root.u.undef.abfd;
3981 struct bfd_link_hash_entry *bh = NULL;
3982 struct ppc_link_hash_entry *fdh;
3983 flagword flags = (fh->elf.root.type == bfd_link_hash_undefweak
3987 if (!_bfd_generic_link_add_one_symbol (info, abfd,
3988 fh->elf.root.root.string + 1,
3989 flags, bfd_und_section_ptr, 0,
3990 NULL, FALSE, FALSE, &bh))
3993 fdh = (struct ppc_link_hash_entry *) bh;
3994 fdh->elf.non_elf = 0;
3996 fdh->is_func_descriptor = 1;
4003 /* Fix function descriptor symbols defined in .opd sections to be
4007 ppc64_elf_add_symbol_hook (bfd *ibfd,
4008 struct bfd_link_info *info,
4009 Elf_Internal_Sym *isym,
4011 flagword *flags ATTRIBUTE_UNUSED,
4016 && strcmp ((*sec)->name, ".opd") == 0)
4020 if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4021 || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4022 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4024 /* If the symbol is a function defined in .opd, and the function
4025 code is in a discarded group, let it appear to be undefined. */
4026 if (!bfd_link_relocatable (info)
4027 && (*sec)->reloc_count != 0
4028 && opd_entry_value (*sec, *value, &code_sec, NULL,
4029 FALSE) != (bfd_vma) -1
4030 && discarded_section (code_sec))
4032 *sec = bfd_und_section_ptr;
4033 isym->st_shndx = SHN_UNDEF;
4036 else if (*sec != NULL
4037 && strcmp ((*sec)->name, ".toc") == 0
4038 && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4040 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4042 htab->params->object_in_toc = 1;
4045 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4047 if (abiversion (ibfd) == 0)
4048 set_abiversion (ibfd, 2);
4049 else if (abiversion (ibfd) == 1)
4051 _bfd_error_handler (_("symbol '%s' has invalid st_other"
4052 " for ABI version 1"), *name);
4053 bfd_set_error (bfd_error_bad_value);
4061 /* Merge non-visibility st_other attributes: local entry point. */
4064 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4065 const Elf_Internal_Sym *isym,
4066 bfd_boolean definition,
4067 bfd_boolean dynamic)
4069 if (definition && (!dynamic || !h->def_regular))
4070 h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4071 | ELF_ST_VISIBILITY (h->other));
4074 /* Hook called on merging a symbol. We use this to clear "fake" since
4075 we now have a real symbol. */
4078 ppc64_elf_merge_symbol (struct elf_link_hash_entry *h,
4079 const Elf_Internal_Sym *isym,
4080 asection **psec ATTRIBUTE_UNUSED,
4081 bfd_boolean newdef ATTRIBUTE_UNUSED,
4082 bfd_boolean olddef ATTRIBUTE_UNUSED,
4083 bfd *oldbfd ATTRIBUTE_UNUSED,
4084 const asection *oldsec ATTRIBUTE_UNUSED)
4086 ((struct ppc_link_hash_entry *) h)->fake = 0;
4087 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4088 ((struct ppc_link_hash_entry *) h)->non_zero_localentry = 1;
4092 /* This function makes an old ABI object reference to ".bar" cause the
4093 inclusion of a new ABI object archive that defines "bar".
4094 NAME is a symbol defined in an archive. Return a symbol in the hash
4095 table that might be satisfied by the archive symbols. */
4097 static struct elf_link_hash_entry *
4098 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4099 struct bfd_link_info *info,
4102 struct elf_link_hash_entry *h;
4106 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4108 /* Don't return this sym if it is a fake function descriptor
4109 created by add_symbol_adjust. */
4110 && !((struct ppc_link_hash_entry *) h)->fake)
4116 len = strlen (name);
4117 dot_name = bfd_alloc (abfd, len + 2);
4118 if (dot_name == NULL)
4119 return (struct elf_link_hash_entry *) -1;
4121 memcpy (dot_name + 1, name, len + 1);
4122 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4123 bfd_release (abfd, dot_name);
4127 /* This function satisfies all old ABI object references to ".bar" if a
4128 new ABI object defines "bar". Well, at least, undefined dot symbols
4129 are made weak. This stops later archive searches from including an
4130 object if we already have a function descriptor definition. It also
4131 prevents the linker complaining about undefined symbols.
4132 We also check and correct mismatched symbol visibility here. The
4133 most restrictive visibility of the function descriptor and the
4134 function entry symbol is used. */
4137 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4139 struct ppc_link_hash_table *htab;
4140 struct ppc_link_hash_entry *fdh;
4142 if (eh->elf.root.type == bfd_link_hash_warning)
4143 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4145 if (eh->elf.root.type == bfd_link_hash_indirect)
4148 if (eh->elf.root.root.string[0] != '.')
4151 htab = ppc_hash_table (info);
4155 fdh = lookup_fdh (eh, htab);
4157 && !bfd_link_relocatable (info)
4158 && (eh->elf.root.type == bfd_link_hash_undefined
4159 || eh->elf.root.type == bfd_link_hash_undefweak)
4160 && eh->elf.ref_regular)
4162 /* Make an undefined function descriptor sym, in order to
4163 pull in an --as-needed shared lib. Archives are handled
4165 fdh = make_fdh (info, eh);
4172 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4173 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4175 /* Make both descriptor and entry symbol have the most
4176 constraining visibility of either symbol. */
4177 if (entry_vis < descr_vis)
4178 fdh->elf.other += entry_vis - descr_vis;
4179 else if (entry_vis > descr_vis)
4180 eh->elf.other += descr_vis - entry_vis;
4182 /* Propagate reference flags from entry symbol to function
4183 descriptor symbol. */
4184 fdh->elf.root.non_ir_ref_regular |= eh->elf.root.non_ir_ref_regular;
4185 fdh->elf.root.non_ir_ref_dynamic |= eh->elf.root.non_ir_ref_dynamic;
4186 fdh->elf.ref_regular |= eh->elf.ref_regular;
4187 fdh->elf.ref_regular_nonweak |= eh->elf.ref_regular_nonweak;
4189 if (!fdh->elf.forced_local
4190 && fdh->elf.dynindx == -1
4191 && fdh->elf.versioned != versioned_hidden
4192 && (bfd_link_dll (info)
4193 || fdh->elf.def_dynamic
4194 || fdh->elf.ref_dynamic)
4195 && (eh->elf.ref_regular
4196 || eh->elf.def_regular))
4198 if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
4206 /* Set up opd section info and abiversion for IBFD, and process list
4207 of dot-symbols we made in link_hash_newfunc. */
4210 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
4212 struct ppc_link_hash_table *htab;
4213 struct ppc_link_hash_entry **p, *eh;
4214 asection *opd = bfd_get_section_by_name (ibfd, ".opd");
4216 if (opd != NULL && opd->size != 0)
4218 BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
4219 ppc64_elf_section_data (opd)->sec_type = sec_opd;
4221 if (abiversion (ibfd) == 0)
4222 set_abiversion (ibfd, 1);
4223 else if (abiversion (ibfd) >= 2)
4225 /* xgettext:c-format */
4226 _bfd_error_handler (_("%pB .opd not allowed in ABI version %d"),
4227 ibfd, abiversion (ibfd));
4228 bfd_set_error (bfd_error_bad_value);
4233 if (is_ppc64_elf (info->output_bfd))
4235 /* For input files without an explicit abiversion in e_flags
4236 we should have flagged any with symbol st_other bits set
4237 as ELFv1 and above flagged those with .opd as ELFv2.
4238 Set the output abiversion if not yet set, and for any input
4239 still ambiguous, take its abiversion from the output.
4240 Differences in ABI are reported later. */
4241 if (abiversion (info->output_bfd) == 0)
4242 set_abiversion (info->output_bfd, abiversion (ibfd));
4243 else if (abiversion (ibfd) == 0)
4244 set_abiversion (ibfd, abiversion (info->output_bfd));
4247 htab = ppc_hash_table (info);
4251 if (opd != NULL && opd->size != 0
4252 && (ibfd->flags & DYNAMIC) == 0
4253 && (opd->flags & SEC_RELOC) != 0
4254 && opd->reloc_count != 0
4255 && !bfd_is_abs_section (opd->output_section)
4256 && info->gc_sections)
4258 /* Garbage collection needs some extra help with .opd sections.
4259 We don't want to necessarily keep everything referenced by
4260 relocs in .opd, as that would keep all functions. Instead,
4261 if we reference an .opd symbol (a function descriptor), we
4262 want to keep the function code symbol's section. This is
4263 easy for global symbols, but for local syms we need to keep
4264 information about the associated function section. */
4266 asection **opd_sym_map;
4267 Elf_Internal_Shdr *symtab_hdr;
4268 Elf_Internal_Rela *relocs, *rel_end, *rel;
4270 amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
4271 opd_sym_map = bfd_zalloc (ibfd, amt);
4272 if (opd_sym_map == NULL)
4274 ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
4275 relocs = _bfd_elf_link_read_relocs (ibfd, opd, NULL, NULL,
4279 symtab_hdr = &elf_symtab_hdr (ibfd);
4280 rel_end = relocs + opd->reloc_count - 1;
4281 for (rel = relocs; rel < rel_end; rel++)
4283 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
4284 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
4286 if (r_type == R_PPC64_ADDR64
4287 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC
4288 && r_symndx < symtab_hdr->sh_info)
4290 Elf_Internal_Sym *isym;
4293 isym = bfd_sym_from_r_symndx (&htab->sym_cache, ibfd, r_symndx);
4296 if (elf_section_data (opd)->relocs != relocs)
4301 s = bfd_section_from_elf_index (ibfd, isym->st_shndx);
4302 if (s != NULL && s != opd)
4303 opd_sym_map[OPD_NDX (rel->r_offset)] = s;
4306 if (elf_section_data (opd)->relocs != relocs)
4310 p = &htab->dot_syms;
4311 while ((eh = *p) != NULL)
4314 if (&eh->elf == htab->elf.hgot)
4316 else if (htab->elf.hgot == NULL
4317 && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
4318 htab->elf.hgot = &eh->elf;
4319 else if (abiversion (ibfd) <= 1)
4321 htab->need_func_desc_adj = 1;
4322 if (!add_symbol_adjust (eh, info))
4325 p = &eh->u.next_dot_sym;
4330 /* Undo hash table changes when an --as-needed input file is determined
4331 not to be needed. */
4334 ppc64_elf_notice_as_needed (bfd *ibfd,
4335 struct bfd_link_info *info,
4336 enum notice_asneeded_action act)
4338 if (act == notice_not_needed)
4340 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4345 htab->dot_syms = NULL;
4347 return _bfd_elf_notice_as_needed (ibfd, info, act);
4350 /* If --just-symbols against a final linked binary, then assume we need
4351 toc adjusting stubs when calling functions defined there. */
4354 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
4356 if ((sec->flags & SEC_CODE) != 0
4357 && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
4358 && is_ppc64_elf (sec->owner))
4360 if (abiversion (sec->owner) >= 2
4361 || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
4362 sec->has_toc_reloc = 1;
4364 _bfd_elf_link_just_syms (sec, info);
4367 static struct plt_entry **
4368 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
4369 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
4371 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
4372 struct plt_entry **local_plt;
4373 unsigned char *local_got_tls_masks;
4375 if (local_got_ents == NULL)
4377 bfd_size_type size = symtab_hdr->sh_info;
4379 size *= (sizeof (*local_got_ents)
4380 + sizeof (*local_plt)
4381 + sizeof (*local_got_tls_masks));
4382 local_got_ents = bfd_zalloc (abfd, size);
4383 if (local_got_ents == NULL)
4385 elf_local_got_ents (abfd) = local_got_ents;
4388 if ((tls_type & (NON_GOT | TLS_EXPLICIT)) == 0)
4390 struct got_entry *ent;
4392 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
4393 if (ent->addend == r_addend
4394 && ent->owner == abfd
4395 && ent->tls_type == tls_type)
4399 bfd_size_type amt = sizeof (*ent);
4400 ent = bfd_alloc (abfd, amt);
4403 ent->next = local_got_ents[r_symndx];
4404 ent->addend = r_addend;
4406 ent->tls_type = tls_type;
4407 ent->is_indirect = FALSE;
4408 ent->got.refcount = 0;
4409 local_got_ents[r_symndx] = ent;
4411 ent->got.refcount += 1;
4414 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
4415 local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
4416 local_got_tls_masks[r_symndx] |= tls_type & 0xff;
4418 return local_plt + r_symndx;
4422 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
4424 struct plt_entry *ent;
4426 for (ent = *plist; ent != NULL; ent = ent->next)
4427 if (ent->addend == addend)
4431 bfd_size_type amt = sizeof (*ent);
4432 ent = bfd_alloc (abfd, amt);
4436 ent->addend = addend;
4437 ent->plt.refcount = 0;
4440 ent->plt.refcount += 1;
4445 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
4447 return (r_type == R_PPC64_REL24
4448 || r_type == R_PPC64_REL24_NOTOC
4449 || r_type == R_PPC64_REL14
4450 || r_type == R_PPC64_REL14_BRTAKEN
4451 || r_type == R_PPC64_REL14_BRNTAKEN
4452 || r_type == R_PPC64_ADDR24
4453 || r_type == R_PPC64_ADDR14
4454 || r_type == R_PPC64_ADDR14_BRTAKEN
4455 || r_type == R_PPC64_ADDR14_BRNTAKEN
4456 || r_type == R_PPC64_PLTCALL
4457 || r_type == R_PPC64_PLTCALL_NOTOC);
4460 /* Relocs on inline plt call sequence insns prior to the call. */
4463 is_plt_seq_reloc (enum elf_ppc64_reloc_type r_type)
4465 return (r_type == R_PPC64_PLT16_HA
4466 || r_type == R_PPC64_PLT16_HI
4467 || r_type == R_PPC64_PLT16_LO
4468 || r_type == R_PPC64_PLT16_LO_DS
4469 || r_type == R_PPC64_PLT_PCREL34
4470 || r_type == R_PPC64_PLT_PCREL34_NOTOC
4471 || r_type == R_PPC64_PLTSEQ
4472 || r_type == R_PPC64_PLTSEQ_NOTOC);
4475 /* Look through the relocs for a section during the first phase, and
4476 calculate needed space in the global offset table, procedure
4477 linkage table, and dynamic reloc sections. */
4480 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
4481 asection *sec, const Elf_Internal_Rela *relocs)
4483 struct ppc_link_hash_table *htab;
4484 Elf_Internal_Shdr *symtab_hdr;
4485 struct elf_link_hash_entry **sym_hashes;
4486 const Elf_Internal_Rela *rel;
4487 const Elf_Internal_Rela *rel_end;
4489 struct elf_link_hash_entry *tga, *dottga;
4492 if (bfd_link_relocatable (info))
4495 /* Don't do anything special with non-loaded, non-alloced sections.
4496 In particular, any relocs in such sections should not affect GOT
4497 and PLT reference counting (ie. we don't allow them to create GOT
4498 or PLT entries), there's no possibility or desire to optimize TLS
4499 relocs, and there's not much point in propagating relocs to shared
4500 libs that the dynamic linker won't relocate. */
4501 if ((sec->flags & SEC_ALLOC) == 0)
4504 BFD_ASSERT (is_ppc64_elf (abfd));
4506 htab = ppc_hash_table (info);
4510 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
4511 FALSE, FALSE, TRUE);
4512 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
4513 FALSE, FALSE, TRUE);
4514 symtab_hdr = &elf_symtab_hdr (abfd);
4515 sym_hashes = elf_sym_hashes (abfd);
4517 is_opd = ppc64_elf_section_data (sec)->sec_type == sec_opd;
4518 rel_end = relocs + sec->reloc_count;
4519 for (rel = relocs; rel < rel_end; rel++)
4521 unsigned long r_symndx;
4522 struct elf_link_hash_entry *h;
4523 enum elf_ppc64_reloc_type r_type;
4525 struct _ppc64_elf_section_data *ppc64_sec;
4526 struct plt_entry **ifunc, **plt_list;
4529 r_symndx = ELF64_R_SYM (rel->r_info);
4530 if (r_symndx < symtab_hdr->sh_info)
4534 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4535 h = elf_follow_link (h);
4537 if (h == htab->elf.hgot)
4538 sec->has_toc_reloc = 1;
4543 r_type = ELF64_R_TYPE (rel->r_info);
4547 case R_PPC64_D34_LO:
4548 case R_PPC64_D34_HI30:
4549 case R_PPC64_D34_HA30:
4551 case R_PPC64_TPREL34:
4552 case R_PPC64_DTPREL34:
4553 htab->powerxx_stubs = 1;
4556 /* Somewhat foolishly, because the ABIs don't specifically
4557 allow it, ppc64 gas and ld support GOT and PLT relocs
4558 with non-zero addends where the addend results in
4559 sym+addend being stored in the GOT or PLT entry. This
4560 can't be supported for pcrel relocs because the addend is
4561 used to specify the pcrel offset. */
4562 sym_addend = rel->r_addend;
4565 case R_PPC64_PCREL34:
4566 case R_PPC64_GOT_PCREL34:
4567 case R_PPC64_GOT_TLSGD34:
4568 case R_PPC64_GOT_TLSLD34:
4569 case R_PPC64_GOT_TPREL34:
4570 case R_PPC64_GOT_DTPREL34:
4571 case R_PPC64_PLT_PCREL34:
4572 case R_PPC64_PLT_PCREL34_NOTOC:
4573 case R_PPC64_PCREL28:
4574 htab->powerxx_stubs = 1;
4581 case R_PPC64_PLT16_HA:
4582 case R_PPC64_GOT_TLSLD16_HA:
4583 case R_PPC64_GOT_TLSGD16_HA:
4584 case R_PPC64_GOT_TPREL16_HA:
4585 case R_PPC64_GOT_DTPREL16_HA:
4586 case R_PPC64_GOT16_HA:
4587 case R_PPC64_TOC16_HA:
4588 case R_PPC64_PLT16_LO:
4589 case R_PPC64_PLT16_LO_DS:
4590 case R_PPC64_GOT_TLSLD16_LO:
4591 case R_PPC64_GOT_TLSGD16_LO:
4592 case R_PPC64_GOT_TPREL16_LO_DS:
4593 case R_PPC64_GOT_DTPREL16_LO_DS:
4594 case R_PPC64_GOT16_LO:
4595 case R_PPC64_GOT16_LO_DS:
4596 case R_PPC64_TOC16_LO:
4597 case R_PPC64_TOC16_LO_DS:
4598 case R_PPC64_GOT_PCREL34:
4599 ppc64_elf_tdata (abfd)->has_optrel = 1;
4600 ppc64_elf_section_data (sec)->has_optrel = 1;
4608 if (h->type == STT_GNU_IFUNC)
4611 ifunc = &h->plt.plist;
4616 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
4621 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4623 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
4625 NON_GOT | PLT_IFUNC);
4635 /* These special tls relocs tie a call to __tls_get_addr with
4636 its parameter symbol. */
4638 ((struct ppc_link_hash_entry *) h)->tls_mask |= TLS_TLS | TLS_MARK;
4640 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
4642 NON_GOT | TLS_TLS | TLS_MARK))
4644 sec->has_tls_reloc = 1;
4647 case R_PPC64_GOT_TLSLD16:
4648 case R_PPC64_GOT_TLSLD16_LO:
4649 case R_PPC64_GOT_TLSLD16_HI:
4650 case R_PPC64_GOT_TLSLD16_HA:
4651 case R_PPC64_GOT_TLSLD34:
4652 tls_type = TLS_TLS | TLS_LD;
4655 case R_PPC64_GOT_TLSGD16:
4656 case R_PPC64_GOT_TLSGD16_LO:
4657 case R_PPC64_GOT_TLSGD16_HI:
4658 case R_PPC64_GOT_TLSGD16_HA:
4659 case R_PPC64_GOT_TLSGD34:
4660 tls_type = TLS_TLS | TLS_GD;
4663 case R_PPC64_GOT_TPREL16_DS:
4664 case R_PPC64_GOT_TPREL16_LO_DS:
4665 case R_PPC64_GOT_TPREL16_HI:
4666 case R_PPC64_GOT_TPREL16_HA:
4667 case R_PPC64_GOT_TPREL34:
4668 if (bfd_link_dll (info))
4669 info->flags |= DF_STATIC_TLS;
4670 tls_type = TLS_TLS | TLS_TPREL;
4673 case R_PPC64_GOT_DTPREL16_DS:
4674 case R_PPC64_GOT_DTPREL16_LO_DS:
4675 case R_PPC64_GOT_DTPREL16_HI:
4676 case R_PPC64_GOT_DTPREL16_HA:
4677 case R_PPC64_GOT_DTPREL34:
4678 tls_type = TLS_TLS | TLS_DTPREL;
4680 sec->has_tls_reloc = 1;
4684 case R_PPC64_GOT16_LO:
4685 case R_PPC64_GOT16_HI:
4686 case R_PPC64_GOT16_HA:
4687 case R_PPC64_GOT16_DS:
4688 case R_PPC64_GOT16_LO_DS:
4689 case R_PPC64_GOT_PCREL34:
4691 /* This symbol requires a global offset table entry. */
4692 sec->has_toc_reloc = 1;
4693 if (r_type == R_PPC64_GOT_TLSLD16
4694 || r_type == R_PPC64_GOT_TLSGD16
4695 || r_type == R_PPC64_GOT_TPREL16_DS
4696 || r_type == R_PPC64_GOT_DTPREL16_DS
4697 || r_type == R_PPC64_GOT16
4698 || r_type == R_PPC64_GOT16_DS)
4700 htab->do_multi_toc = 1;
4701 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
4704 if (ppc64_elf_tdata (abfd)->got == NULL
4705 && !create_got_section (abfd, info))
4710 struct ppc_link_hash_entry *eh;
4711 struct got_entry *ent;
4713 eh = (struct ppc_link_hash_entry *) h;
4714 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
4715 if (ent->addend == sym_addend
4716 && ent->owner == abfd
4717 && ent->tls_type == tls_type)
4721 bfd_size_type amt = sizeof (*ent);
4722 ent = bfd_alloc (abfd, amt);
4725 ent->next = eh->elf.got.glist;
4726 ent->addend = sym_addend;
4728 ent->tls_type = tls_type;
4729 ent->is_indirect = FALSE;
4730 ent->got.refcount = 0;
4731 eh->elf.got.glist = ent;
4733 ent->got.refcount += 1;
4734 eh->tls_mask |= tls_type;
4737 /* This is a global offset table entry for a local symbol. */
4738 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
4739 sym_addend, tls_type))
4742 /* We may also need a plt entry if the symbol turns out to be
4744 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
4746 if (!update_plt_info (abfd, &h->plt.plist, sym_addend))
4751 case R_PPC64_PLT16_HA:
4752 case R_PPC64_PLT16_HI:
4753 case R_PPC64_PLT16_LO:
4754 case R_PPC64_PLT16_LO_DS:
4755 case R_PPC64_PLT_PCREL34:
4756 case R_PPC64_PLT_PCREL34_NOTOC:
4759 /* This symbol requires a procedure linkage table entry. */
4764 if (h->root.root.string[0] == '.'
4765 && h->root.root.string[1] != '\0')
4766 ((struct ppc_link_hash_entry *) h)->is_func = 1;
4767 ((struct ppc_link_hash_entry *) h)->tls_mask |= PLT_KEEP;
4768 plt_list = &h->plt.plist;
4770 if (plt_list == NULL)
4771 plt_list = update_local_sym_info (abfd, symtab_hdr, r_symndx,
4773 NON_GOT | PLT_KEEP);
4774 if (!update_plt_info (abfd, plt_list, sym_addend))
4778 /* The following relocations don't need to propagate the
4779 relocation if linking a shared object since they are
4780 section relative. */
4781 case R_PPC64_SECTOFF:
4782 case R_PPC64_SECTOFF_LO:
4783 case R_PPC64_SECTOFF_HI:
4784 case R_PPC64_SECTOFF_HA:
4785 case R_PPC64_SECTOFF_DS:
4786 case R_PPC64_SECTOFF_LO_DS:
4787 case R_PPC64_DTPREL16:
4788 case R_PPC64_DTPREL16_LO:
4789 case R_PPC64_DTPREL16_HI:
4790 case R_PPC64_DTPREL16_HA:
4791 case R_PPC64_DTPREL16_DS:
4792 case R_PPC64_DTPREL16_LO_DS:
4793 case R_PPC64_DTPREL16_HIGH:
4794 case R_PPC64_DTPREL16_HIGHA:
4795 case R_PPC64_DTPREL16_HIGHER:
4796 case R_PPC64_DTPREL16_HIGHERA:
4797 case R_PPC64_DTPREL16_HIGHEST:
4798 case R_PPC64_DTPREL16_HIGHESTA:
4803 case R_PPC64_REL16_LO:
4804 case R_PPC64_REL16_HI:
4805 case R_PPC64_REL16_HA:
4806 case R_PPC64_REL16_HIGH:
4807 case R_PPC64_REL16_HIGHA:
4808 case R_PPC64_REL16_HIGHER:
4809 case R_PPC64_REL16_HIGHERA:
4810 case R_PPC64_REL16_HIGHEST:
4811 case R_PPC64_REL16_HIGHESTA:
4812 case R_PPC64_REL16_HIGHER34:
4813 case R_PPC64_REL16_HIGHERA34:
4814 case R_PPC64_REL16_HIGHEST34:
4815 case R_PPC64_REL16_HIGHESTA34:
4816 case R_PPC64_REL16DX_HA:
4819 /* Not supported as a dynamic relocation. */
4820 case R_PPC64_ADDR64_LOCAL:
4821 if (bfd_link_pic (info))
4823 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
4825 /* xgettext:c-format */
4826 info->callbacks->einfo (_("%H: %s reloc unsupported "
4827 "in shared libraries and PIEs\n"),
4828 abfd, sec, rel->r_offset,
4829 ppc64_elf_howto_table[r_type]->name);
4830 bfd_set_error (bfd_error_bad_value);
4836 case R_PPC64_TOC16_DS:
4837 htab->do_multi_toc = 1;
4838 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
4840 case R_PPC64_TOC16_LO:
4841 case R_PPC64_TOC16_HI:
4842 case R_PPC64_TOC16_HA:
4843 case R_PPC64_TOC16_LO_DS:
4844 sec->has_toc_reloc = 1;
4851 /* This relocation describes the C++ object vtable hierarchy.
4852 Reconstruct it for later use during GC. */
4853 case R_PPC64_GNU_VTINHERIT:
4854 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
4858 /* This relocation describes which C++ vtable entries are actually
4859 used. Record for later use during GC. */
4860 case R_PPC64_GNU_VTENTRY:
4861 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
4866 case R_PPC64_REL14_BRTAKEN:
4867 case R_PPC64_REL14_BRNTAKEN:
4869 asection *dest = NULL;
4871 /* Heuristic: If jumping outside our section, chances are
4872 we are going to need a stub. */
4875 /* If the sym is weak it may be overridden later, so
4876 don't assume we know where a weak sym lives. */
4877 if (h->root.type == bfd_link_hash_defined)
4878 dest = h->root.u.def.section;
4882 Elf_Internal_Sym *isym;
4884 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
4889 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
4893 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
4897 case R_PPC64_PLTCALL:
4898 case R_PPC64_PLTCALL_NOTOC:
4899 ppc64_elf_section_data (sec)->has_pltcall = 1;
4903 case R_PPC64_REL24_NOTOC:
4909 if (h->root.root.string[0] == '.'
4910 && h->root.root.string[1] != '\0')
4911 ((struct ppc_link_hash_entry *) h)->is_func = 1;
4913 if (h == tga || h == dottga)
4915 sec->has_tls_reloc = 1;
4917 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
4918 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
4919 /* We have a new-style __tls_get_addr call with
4923 /* Mark this section as having an old-style call. */
4924 sec->has_tls_get_addr_call = 1;
4926 plt_list = &h->plt.plist;
4929 /* We may need a .plt entry if the function this reloc
4930 refers to is in a shared lib. */
4932 && !update_plt_info (abfd, plt_list, sym_addend))
4936 case R_PPC64_ADDR14:
4937 case R_PPC64_ADDR14_BRNTAKEN:
4938 case R_PPC64_ADDR14_BRTAKEN:
4939 case R_PPC64_ADDR24:
4942 case R_PPC64_TPREL64:
4943 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
4944 if (bfd_link_dll (info))
4945 info->flags |= DF_STATIC_TLS;
4948 case R_PPC64_DTPMOD64:
4949 if (rel + 1 < rel_end
4950 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
4951 && rel[1].r_offset == rel->r_offset + 8)
4952 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
4954 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
4957 case R_PPC64_DTPREL64:
4958 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
4960 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
4961 && rel[-1].r_offset == rel->r_offset - 8)
4962 /* This is the second reloc of a dtpmod, dtprel pair.
4963 Don't mark with TLS_DTPREL. */
4967 sec->has_tls_reloc = 1;
4970 struct ppc_link_hash_entry *eh;
4971 eh = (struct ppc_link_hash_entry *) h;
4972 eh->tls_mask |= tls_type & 0xff;
4975 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
4976 sym_addend, tls_type))
4979 ppc64_sec = ppc64_elf_section_data (sec);
4980 if (ppc64_sec->sec_type != sec_toc)
4984 /* One extra to simplify get_tls_mask. */
4985 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
4986 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
4987 if (ppc64_sec->u.toc.symndx == NULL)
4989 amt = sec->size * sizeof (bfd_vma) / 8;
4990 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
4991 if (ppc64_sec->u.toc.add == NULL)
4993 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
4994 ppc64_sec->sec_type = sec_toc;
4996 BFD_ASSERT (rel->r_offset % 8 == 0);
4997 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
4998 ppc64_sec->u.toc.add[rel->r_offset / 8] = sym_addend;
5000 /* Mark the second slot of a GD or LD entry.
5001 -1 to indicate GD and -2 to indicate LD. */
5002 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5003 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5004 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5005 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5008 case R_PPC64_TPREL16:
5009 case R_PPC64_TPREL16_LO:
5010 case R_PPC64_TPREL16_HI:
5011 case R_PPC64_TPREL16_HA:
5012 case R_PPC64_TPREL16_DS:
5013 case R_PPC64_TPREL16_LO_DS:
5014 case R_PPC64_TPREL16_HIGH:
5015 case R_PPC64_TPREL16_HIGHA:
5016 case R_PPC64_TPREL16_HIGHER:
5017 case R_PPC64_TPREL16_HIGHERA:
5018 case R_PPC64_TPREL16_HIGHEST:
5019 case R_PPC64_TPREL16_HIGHESTA:
5020 case R_PPC64_TPREL34:
5021 if (bfd_link_dll (info))
5022 info->flags |= DF_STATIC_TLS;
5025 case R_PPC64_ADDR64:
5027 && rel + 1 < rel_end
5028 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5031 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5035 case R_PPC64_ADDR16:
5036 case R_PPC64_ADDR16_DS:
5037 case R_PPC64_ADDR16_HA:
5038 case R_PPC64_ADDR16_HI:
5039 case R_PPC64_ADDR16_HIGH:
5040 case R_PPC64_ADDR16_HIGHA:
5041 case R_PPC64_ADDR16_HIGHER:
5042 case R_PPC64_ADDR16_HIGHERA:
5043 case R_PPC64_ADDR16_HIGHEST:
5044 case R_PPC64_ADDR16_HIGHESTA:
5045 case R_PPC64_ADDR16_LO:
5046 case R_PPC64_ADDR16_LO_DS:
5048 case R_PPC64_D34_LO:
5049 case R_PPC64_D34_HI30:
5050 case R_PPC64_D34_HA30:
5051 case R_PPC64_ADDR16_HIGHER34:
5052 case R_PPC64_ADDR16_HIGHERA34:
5053 case R_PPC64_ADDR16_HIGHEST34:
5054 case R_PPC64_ADDR16_HIGHESTA34:
5056 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5057 && rel->r_addend == 0)
5059 /* We may need a .plt entry if this reloc refers to a
5060 function in a shared lib. */
5061 if (!update_plt_info (abfd, &h->plt.plist, 0))
5063 h->pointer_equality_needed = 1;
5070 case R_PPC64_ADDR32:
5071 case R_PPC64_UADDR16:
5072 case R_PPC64_UADDR32:
5073 case R_PPC64_UADDR64:
5075 if (h != NULL && !bfd_link_pic (info))
5076 /* We may need a copy reloc. */
5079 /* Don't propagate .opd relocs. */
5080 if (NO_OPD_RELOCS && is_opd)
5083 /* If we are creating a shared library, and this is a reloc
5084 against a global symbol, or a non PC relative reloc
5085 against a local symbol, then we need to copy the reloc
5086 into the shared library. However, if we are linking with
5087 -Bsymbolic, we do not need to copy a reloc against a
5088 global symbol which is defined in an object we are
5089 including in the link (i.e., DEF_REGULAR is set). At
5090 this point we have not seen all the input files, so it is
5091 possible that DEF_REGULAR is not set now but will be set
5092 later (it is never cleared). In case of a weak definition,
5093 DEF_REGULAR may be cleared later by a strong definition in
5094 a shared library. We account for that possibility below by
5095 storing information in the dyn_relocs field of the hash
5096 table entry. A similar situation occurs when creating
5097 shared libraries and symbol visibility changes render the
5100 If on the other hand, we are creating an executable, we
5101 may need to keep relocations for symbols satisfied by a
5102 dynamic library if we manage to avoid copy relocs for the
5105 if ((bfd_link_pic (info)
5106 && (must_be_dyn_reloc (info, r_type)
5108 && (!SYMBOLIC_BIND (info, h)
5109 || h->root.type == bfd_link_hash_defweak
5110 || !h->def_regular))))
5111 || (ELIMINATE_COPY_RELOCS
5112 && !bfd_link_pic (info)
5114 && (h->root.type == bfd_link_hash_defweak
5115 || !h->def_regular))
5116 || (!bfd_link_pic (info)
5119 /* We must copy these reloc types into the output file.
5120 Create a reloc section in dynobj and make room for
5124 sreloc = _bfd_elf_make_dynamic_reloc_section
5125 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5131 /* If this is a global symbol, we count the number of
5132 relocations we need for this symbol. */
5135 struct elf_dyn_relocs *p;
5136 struct elf_dyn_relocs **head;
5138 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5140 if (p == NULL || p->sec != sec)
5142 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5152 if (!must_be_dyn_reloc (info, r_type))
5157 /* Track dynamic relocs needed for local syms too.
5158 We really need local syms available to do this
5160 struct ppc_dyn_relocs *p;
5161 struct ppc_dyn_relocs **head;
5162 bfd_boolean is_ifunc;
5165 Elf_Internal_Sym *isym;
5167 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5172 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5176 vpp = &elf_section_data (s)->local_dynrel;
5177 head = (struct ppc_dyn_relocs **) vpp;
5178 is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5180 if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5182 if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5184 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5190 p->ifunc = is_ifunc;
5206 /* Merge backend specific data from an object file to the output
5207 object file when linking. */
5210 ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
5212 bfd *obfd = info->output_bfd;
5213 unsigned long iflags, oflags;
5215 if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5218 if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5221 if (!_bfd_generic_verify_endian_match (ibfd, info))
5224 iflags = elf_elfheader (ibfd)->e_flags;
5225 oflags = elf_elfheader (obfd)->e_flags;
5227 if (iflags & ~EF_PPC64_ABI)
5230 /* xgettext:c-format */
5231 (_("%pB uses unknown e_flags 0x%lx"), ibfd, iflags);
5232 bfd_set_error (bfd_error_bad_value);
5235 else if (iflags != oflags && iflags != 0)
5238 /* xgettext:c-format */
5239 (_("%pB: ABI version %ld is not compatible with ABI version %ld output"),
5240 ibfd, iflags, oflags);
5241 bfd_set_error (bfd_error_bad_value);
5245 if (!_bfd_elf_ppc_merge_fp_attributes (ibfd, info))
5248 /* Merge Tag_compatibility attributes and any common GNU ones. */
5249 return _bfd_elf_merge_object_attributes (ibfd, info);
5253 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5255 /* Print normal ELF private data. */
5256 _bfd_elf_print_private_bfd_data (abfd, ptr);
5258 if (elf_elfheader (abfd)->e_flags != 0)
5262 fprintf (file, _("private flags = 0x%lx:"),
5263 elf_elfheader (abfd)->e_flags);
5265 if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
5266 fprintf (file, _(" [abiv%ld]"),
5267 elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
5274 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
5275 of the code entry point, and its section, which must be in the same
5276 object as OPD_SEC. Returns (bfd_vma) -1 on error. */
5279 opd_entry_value (asection *opd_sec,
5281 asection **code_sec,
5283 bfd_boolean in_code_sec)
5285 bfd *opd_bfd = opd_sec->owner;
5286 Elf_Internal_Rela *relocs;
5287 Elf_Internal_Rela *lo, *hi, *look;
5290 /* No relocs implies we are linking a --just-symbols object, or looking
5291 at a final linked executable with addr2line or somesuch. */
5292 if (opd_sec->reloc_count == 0)
5294 bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
5296 if (contents == NULL)
5298 if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
5299 return (bfd_vma) -1;
5300 ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
5303 /* PR 17512: file: 64b9dfbb. */
5304 if (offset + 7 >= opd_sec->size || offset + 7 < offset)
5305 return (bfd_vma) -1;
5307 val = bfd_get_64 (opd_bfd, contents + offset);
5308 if (code_sec != NULL)
5310 asection *sec, *likely = NULL;
5316 && val < sec->vma + sec->size)
5322 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5324 && (sec->flags & SEC_LOAD) != 0
5325 && (sec->flags & SEC_ALLOC) != 0)
5330 if (code_off != NULL)
5331 *code_off = val - likely->vma;
5337 BFD_ASSERT (is_ppc64_elf (opd_bfd));
5339 relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
5341 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5342 /* PR 17512: file: df8e1fd6. */
5344 return (bfd_vma) -1;
5346 /* Go find the opd reloc at the sym address. */
5348 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5352 look = lo + (hi - lo) / 2;
5353 if (look->r_offset < offset)
5355 else if (look->r_offset > offset)
5359 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5361 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5362 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5364 unsigned long symndx = ELF64_R_SYM (look->r_info);
5365 asection *sec = NULL;
5367 if (symndx >= symtab_hdr->sh_info
5368 && elf_sym_hashes (opd_bfd) != NULL)
5370 struct elf_link_hash_entry **sym_hashes;
5371 struct elf_link_hash_entry *rh;
5373 sym_hashes = elf_sym_hashes (opd_bfd);
5374 rh = sym_hashes[symndx - symtab_hdr->sh_info];
5377 rh = elf_follow_link (rh);
5378 if (rh->root.type != bfd_link_hash_defined
5379 && rh->root.type != bfd_link_hash_defweak)
5381 if (rh->root.u.def.section->owner == opd_bfd)
5383 val = rh->root.u.def.value;
5384 sec = rh->root.u.def.section;
5391 Elf_Internal_Sym *sym;
5393 if (symndx < symtab_hdr->sh_info)
5395 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5398 size_t symcnt = symtab_hdr->sh_info;
5399 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
5404 symtab_hdr->contents = (bfd_byte *) sym;
5410 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
5416 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5419 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5420 val = sym->st_value;
5423 val += look->r_addend;
5424 if (code_off != NULL)
5426 if (code_sec != NULL)
5428 if (in_code_sec && *code_sec != sec)
5433 if (sec->output_section != NULL)
5434 val += sec->output_section->vma + sec->output_offset;
5443 /* If the ELF symbol SYM might be a function in SEC, return the
5444 function size and set *CODE_OFF to the function's entry point,
5445 otherwise return zero. */
5447 static bfd_size_type
5448 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
5453 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
5454 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
5458 if (!(sym->flags & BSF_SYNTHETIC))
5459 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
5461 if (strcmp (sym->section->name, ".opd") == 0)
5463 struct _opd_sec_data *opd = get_opd_info (sym->section);
5464 bfd_vma symval = sym->value;
5467 && opd->adjust != NULL
5468 && elf_section_data (sym->section)->relocs != NULL)
5470 /* opd_entry_value will use cached relocs that have been
5471 adjusted, but with raw symbols. That means both local
5472 and global symbols need adjusting. */
5473 long adjust = opd->adjust[OPD_NDX (symval)];
5479 if (opd_entry_value (sym->section, symval,
5480 &sec, code_off, TRUE) == (bfd_vma) -1)
5482 /* An old ABI binary with dot-syms has a size of 24 on the .opd
5483 symbol. This size has nothing to do with the code size of the
5484 function, which is what we're supposed to return, but the
5485 code size isn't available without looking up the dot-sym.
5486 However, doing that would be a waste of time particularly
5487 since elf_find_function will look at the dot-sym anyway.
5488 Now, elf_find_function will keep the largest size of any
5489 function sym found at the code address of interest, so return
5490 1 here to avoid it incorrectly caching a larger function size
5491 for a small function. This does mean we return the wrong
5492 size for a new-ABI function of size 24, but all that does is
5493 disable caching for such functions. */
5499 if (sym->section != sec)
5501 *code_off = sym->value;
5508 /* Return true if symbol is a strong function defined in an ELFv2
5509 object with st_other localentry bits of zero, ie. its local entry
5510 point coincides with its global entry point. */
5513 is_elfv2_localentry0 (struct elf_link_hash_entry *h)
5516 && h->type == STT_FUNC
5517 && h->root.type == bfd_link_hash_defined
5518 && (STO_PPC64_LOCAL_MASK & h->other) == 0
5519 && !((struct ppc_link_hash_entry *) h)->non_zero_localentry
5520 && is_ppc64_elf (h->root.u.def.section->owner)
5521 && abiversion (h->root.u.def.section->owner) >= 2);
5524 /* Return true if symbol is defined in a regular object file. */
5527 is_static_defined (struct elf_link_hash_entry *h)
5529 return ((h->root.type == bfd_link_hash_defined
5530 || h->root.type == bfd_link_hash_defweak)
5531 && h->root.u.def.section != NULL
5532 && h->root.u.def.section->output_section != NULL);
5535 /* If FDH is a function descriptor symbol, return the associated code
5536 entry symbol if it is defined. Return NULL otherwise. */
5538 static struct ppc_link_hash_entry *
5539 defined_code_entry (struct ppc_link_hash_entry *fdh)
5541 if (fdh->is_func_descriptor)
5543 struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
5544 if (fh->elf.root.type == bfd_link_hash_defined
5545 || fh->elf.root.type == bfd_link_hash_defweak)
5551 /* If FH is a function code entry symbol, return the associated
5552 function descriptor symbol if it is defined. Return NULL otherwise. */
5554 static struct ppc_link_hash_entry *
5555 defined_func_desc (struct ppc_link_hash_entry *fh)
5558 && fh->oh->is_func_descriptor)
5560 struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
5561 if (fdh->elf.root.type == bfd_link_hash_defined
5562 || fdh->elf.root.type == bfd_link_hash_defweak)
5568 static bfd_boolean func_desc_adjust (struct elf_link_hash_entry *, void *);
5570 /* Garbage collect sections, after first dealing with dot-symbols. */
5573 ppc64_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
5575 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5577 if (htab != NULL && htab->need_func_desc_adj)
5579 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
5580 htab->need_func_desc_adj = 0;
5582 return bfd_elf_gc_sections (abfd, info);
5585 /* Mark all our entry sym sections, both opd and code section. */
5588 ppc64_elf_gc_keep (struct bfd_link_info *info)
5590 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5591 struct bfd_sym_chain *sym;
5596 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
5598 struct ppc_link_hash_entry *eh, *fh;
5601 eh = (struct ppc_link_hash_entry *)
5602 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
5605 if (eh->elf.root.type != bfd_link_hash_defined
5606 && eh->elf.root.type != bfd_link_hash_defweak)
5609 fh = defined_code_entry (eh);
5612 sec = fh->elf.root.u.def.section;
5613 sec->flags |= SEC_KEEP;
5615 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5616 && opd_entry_value (eh->elf.root.u.def.section,
5617 eh->elf.root.u.def.value,
5618 &sec, NULL, FALSE) != (bfd_vma) -1)
5619 sec->flags |= SEC_KEEP;
5621 sec = eh->elf.root.u.def.section;
5622 sec->flags |= SEC_KEEP;
5626 /* Mark sections containing dynamically referenced symbols. When
5627 building shared libraries, we must assume that any visible symbol is
5631 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
5633 struct bfd_link_info *info = (struct bfd_link_info *) inf;
5634 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
5635 struct ppc_link_hash_entry *fdh;
5636 struct bfd_elf_dynamic_list *d = info->dynamic_list;
5638 /* Dynamic linking info is on the func descriptor sym. */
5639 fdh = defined_func_desc (eh);
5643 if ((eh->elf.root.type == bfd_link_hash_defined
5644 || eh->elf.root.type == bfd_link_hash_defweak)
5645 && ((eh->elf.ref_dynamic && !eh->elf.forced_local)
5646 || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
5647 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
5648 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
5649 && (!bfd_link_executable (info)
5650 || info->gc_keep_exported
5651 || info->export_dynamic
5654 && (*d->match) (&d->head, NULL,
5655 eh->elf.root.root.string)))
5656 && (eh->elf.versioned >= versioned
5657 || !bfd_hide_sym_by_version (info->version_info,
5658 eh->elf.root.root.string)))))
5661 struct ppc_link_hash_entry *fh;
5663 eh->elf.root.u.def.section->flags |= SEC_KEEP;
5665 /* Function descriptor syms cause the associated
5666 function code sym section to be marked. */
5667 fh = defined_code_entry (eh);
5670 code_sec = fh->elf.root.u.def.section;
5671 code_sec->flags |= SEC_KEEP;
5673 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5674 && opd_entry_value (eh->elf.root.u.def.section,
5675 eh->elf.root.u.def.value,
5676 &code_sec, NULL, FALSE) != (bfd_vma) -1)
5677 code_sec->flags |= SEC_KEEP;
5683 /* Return the section that should be marked against GC for a given
5687 ppc64_elf_gc_mark_hook (asection *sec,
5688 struct bfd_link_info *info,
5689 Elf_Internal_Rela *rel,
5690 struct elf_link_hash_entry *h,
5691 Elf_Internal_Sym *sym)
5695 /* Syms return NULL if we're marking .opd, so we avoid marking all
5696 function sections, as all functions are referenced in .opd. */
5698 if (get_opd_info (sec) != NULL)
5703 enum elf_ppc64_reloc_type r_type;
5704 struct ppc_link_hash_entry *eh, *fh, *fdh;
5706 r_type = ELF64_R_TYPE (rel->r_info);
5709 case R_PPC64_GNU_VTINHERIT:
5710 case R_PPC64_GNU_VTENTRY:
5714 switch (h->root.type)
5716 case bfd_link_hash_defined:
5717 case bfd_link_hash_defweak:
5718 eh = (struct ppc_link_hash_entry *) h;
5719 fdh = defined_func_desc (eh);
5722 /* -mcall-aixdesc code references the dot-symbol on
5723 a call reloc. Mark the function descriptor too
5724 against garbage collection. */
5726 if (fdh->elf.is_weakalias)
5727 weakdef (&fdh->elf)->mark = 1;
5731 /* Function descriptor syms cause the associated
5732 function code sym section to be marked. */
5733 fh = defined_code_entry (eh);
5736 /* They also mark their opd section. */
5737 eh->elf.root.u.def.section->gc_mark = 1;
5739 rsec = fh->elf.root.u.def.section;
5741 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5742 && opd_entry_value (eh->elf.root.u.def.section,
5743 eh->elf.root.u.def.value,
5744 &rsec, NULL, FALSE) != (bfd_vma) -1)
5745 eh->elf.root.u.def.section->gc_mark = 1;
5747 rsec = h->root.u.def.section;
5750 case bfd_link_hash_common:
5751 rsec = h->root.u.c.p->section;
5755 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
5761 struct _opd_sec_data *opd;
5763 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
5764 opd = get_opd_info (rsec);
5765 if (opd != NULL && opd->func_sec != NULL)
5769 rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
5776 /* The maximum size of .sfpr. */
5777 #define SFPR_MAX (218*4)
5779 struct sfpr_def_parms
5781 const char name[12];
5782 unsigned char lo, hi;
5783 bfd_byte *(*write_ent) (bfd *, bfd_byte *, int);
5784 bfd_byte *(*write_tail) (bfd *, bfd_byte *, int);
5787 /* Auto-generate _save*, _rest* functions in .sfpr.
5788 If STUB_SEC is non-null, define alias symbols in STUB_SEC
5792 sfpr_define (struct bfd_link_info *info,
5793 const struct sfpr_def_parms *parm,
5796 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5798 size_t len = strlen (parm->name);
5799 bfd_boolean writing = FALSE;
5805 memcpy (sym, parm->name, len);
5808 for (i = parm->lo; i <= parm->hi; i++)
5810 struct ppc_link_hash_entry *h;
5812 sym[len + 0] = i / 10 + '0';
5813 sym[len + 1] = i % 10 + '0';
5814 h = (struct ppc_link_hash_entry *)
5815 elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
5816 if (stub_sec != NULL)
5819 && h->elf.root.type == bfd_link_hash_defined
5820 && h->elf.root.u.def.section == htab->sfpr)
5822 struct elf_link_hash_entry *s;
5824 sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
5825 s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
5828 if (s->root.type == bfd_link_hash_new
5829 || (s->root.type = bfd_link_hash_defined
5830 && s->root.u.def.section == stub_sec))
5832 s->root.type = bfd_link_hash_defined;
5833 s->root.u.def.section = stub_sec;
5834 s->root.u.def.value = (stub_sec->size - htab->sfpr->size
5835 + h->elf.root.u.def.value);
5838 s->ref_regular_nonweak = 1;
5839 s->forced_local = 1;
5841 s->root.linker_def = 1;
5849 if (!h->elf.def_regular)
5851 h->elf.root.type = bfd_link_hash_defined;
5852 h->elf.root.u.def.section = htab->sfpr;
5853 h->elf.root.u.def.value = htab->sfpr->size;
5854 h->elf.type = STT_FUNC;
5855 h->elf.def_regular = 1;
5857 _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
5859 if (htab->sfpr->contents == NULL)
5861 htab->sfpr->contents
5862 = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
5863 if (htab->sfpr->contents == NULL)
5870 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
5872 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
5874 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
5875 htab->sfpr->size = p - htab->sfpr->contents;
5883 savegpr0 (bfd *abfd, bfd_byte *p, int r)
5885 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5890 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
5892 p = savegpr0 (abfd, p, r);
5893 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
5895 bfd_put_32 (abfd, BLR, p);
5900 restgpr0 (bfd *abfd, bfd_byte *p, int r)
5902 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5907 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
5909 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
5911 p = restgpr0 (abfd, p, r);
5912 bfd_put_32 (abfd, MTLR_R0, p);
5916 p = restgpr0 (abfd, p, 30);
5917 p = restgpr0 (abfd, p, 31);
5919 bfd_put_32 (abfd, BLR, p);
5924 savegpr1 (bfd *abfd, bfd_byte *p, int r)
5926 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5931 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
5933 p = savegpr1 (abfd, p, r);
5934 bfd_put_32 (abfd, BLR, p);
5939 restgpr1 (bfd *abfd, bfd_byte *p, int r)
5941 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5946 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
5948 p = restgpr1 (abfd, p, r);
5949 bfd_put_32 (abfd, BLR, p);
5954 savefpr (bfd *abfd, bfd_byte *p, int r)
5956 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5961 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
5963 p = savefpr (abfd, p, r);
5964 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
5966 bfd_put_32 (abfd, BLR, p);
5971 restfpr (bfd *abfd, bfd_byte *p, int r)
5973 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5978 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
5980 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
5982 p = restfpr (abfd, p, r);
5983 bfd_put_32 (abfd, MTLR_R0, p);
5987 p = restfpr (abfd, p, 30);
5988 p = restfpr (abfd, p, 31);
5990 bfd_put_32 (abfd, BLR, p);
5995 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
5997 p = savefpr (abfd, p, r);
5998 bfd_put_32 (abfd, BLR, p);
6003 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6005 p = restfpr (abfd, p, r);
6006 bfd_put_32 (abfd, BLR, p);
6011 savevr (bfd *abfd, bfd_byte *p, int r)
6013 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6015 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6020 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6022 p = savevr (abfd, p, r);
6023 bfd_put_32 (abfd, BLR, p);
6028 restvr (bfd *abfd, bfd_byte *p, int r)
6030 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6032 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6037 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6039 p = restvr (abfd, p, r);
6040 bfd_put_32 (abfd, BLR, p);
6044 /* Called via elf_link_hash_traverse to transfer dynamic linking
6045 information on function code symbol entries to their corresponding
6046 function descriptor symbol entries. */
6049 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6051 struct bfd_link_info *info;
6052 struct ppc_link_hash_table *htab;
6053 struct ppc_link_hash_entry *fh;
6054 struct ppc_link_hash_entry *fdh;
6055 bfd_boolean force_local;
6057 fh = (struct ppc_link_hash_entry *) h;
6058 if (fh->elf.root.type == bfd_link_hash_indirect)
6064 if (fh->elf.root.root.string[0] != '.'
6065 || fh->elf.root.root.string[1] == '\0')
6069 htab = ppc_hash_table (info);
6073 /* Find the corresponding function descriptor symbol. */
6074 fdh = lookup_fdh (fh, htab);
6076 /* Resolve undefined references to dot-symbols as the value
6077 in the function descriptor, if we have one in a regular object.
6078 This is to satisfy cases like ".quad .foo". Calls to functions
6079 in dynamic objects are handled elsewhere. */
6080 if ((fh->elf.root.type == bfd_link_hash_undefined
6081 || fh->elf.root.type == bfd_link_hash_undefweak)
6082 && (fdh->elf.root.type == bfd_link_hash_defined
6083 || fdh->elf.root.type == bfd_link_hash_defweak)
6084 && get_opd_info (fdh->elf.root.u.def.section) != NULL
6085 && opd_entry_value (fdh->elf.root.u.def.section,
6086 fdh->elf.root.u.def.value,
6087 &fh->elf.root.u.def.section,
6088 &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6090 fh->elf.root.type = fdh->elf.root.type;
6091 fh->elf.forced_local = 1;
6092 fh->elf.def_regular = fdh->elf.def_regular;
6093 fh->elf.def_dynamic = fdh->elf.def_dynamic;
6096 if (!fh->elf.dynamic)
6098 struct plt_entry *ent;
6100 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6101 if (ent->plt.refcount > 0)
6107 /* Create a descriptor as undefined if necessary. */
6109 && !bfd_link_executable (info)
6110 && (fh->elf.root.type == bfd_link_hash_undefined
6111 || fh->elf.root.type == bfd_link_hash_undefweak))
6113 fdh = make_fdh (info, fh);
6118 /* We can't support overriding of symbols on a fake descriptor. */
6121 && (fh->elf.root.type == bfd_link_hash_defined
6122 || fh->elf.root.type == bfd_link_hash_defweak))
6123 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6125 /* Transfer dynamic linking information to the function descriptor. */
6128 fdh->elf.ref_regular |= fh->elf.ref_regular;
6129 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6130 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6131 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6132 fdh->elf.dynamic |= fh->elf.dynamic;
6133 fdh->elf.needs_plt |= (fh->elf.needs_plt
6134 || fh->elf.type == STT_FUNC
6135 || fh->elf.type == STT_GNU_IFUNC);
6136 move_plt_plist (fh, fdh);
6138 if (!fdh->elf.forced_local
6139 && fh->elf.dynindx != -1)
6140 if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6144 /* Now that the info is on the function descriptor, clear the
6145 function code sym info. Any function code syms for which we
6146 don't have a definition in a regular file, we force local.
6147 This prevents a shared library from exporting syms that have
6148 been imported from another library. Function code syms that
6149 are really in the library we must leave global to prevent the
6150 linker dragging in a definition from a static library. */
6151 force_local = (!fh->elf.def_regular
6153 || !fdh->elf.def_regular
6154 || fdh->elf.forced_local);
6155 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6160 static const struct sfpr_def_parms save_res_funcs[] =
6162 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6163 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6164 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6165 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6166 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6167 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6168 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6169 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6170 { "._savef", 14, 31, savefpr, savefpr1_tail },
6171 { "._restf", 14, 31, restfpr, restfpr1_tail },
6172 { "_savevr_", 20, 31, savevr, savevr_tail },
6173 { "_restvr_", 20, 31, restvr, restvr_tail }
6176 /* Called near the start of bfd_elf_size_dynamic_sections. We use
6177 this hook to a) provide some gcc support functions, and b) transfer
6178 dynamic linking information gathered so far on function code symbol
6179 entries, to their corresponding function descriptor symbol entries. */
6182 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6183 struct bfd_link_info *info)
6185 struct ppc_link_hash_table *htab;
6187 htab = ppc_hash_table (info);
6191 /* Provide any missing _save* and _rest* functions. */
6192 if (htab->sfpr != NULL)
6196 htab->sfpr->size = 0;
6197 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
6198 if (!sfpr_define (info, &save_res_funcs[i], NULL))
6200 if (htab->sfpr->size == 0)
6201 htab->sfpr->flags |= SEC_EXCLUDE;
6204 if (bfd_link_relocatable (info))
6207 if (htab->elf.hgot != NULL)
6209 _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
6210 /* Make .TOC. defined so as to prevent it being made dynamic.
6211 The wrong value here is fixed later in ppc64_elf_set_toc. */
6212 if (!htab->elf.hgot->def_regular
6213 || htab->elf.hgot->root.type != bfd_link_hash_defined)
6215 htab->elf.hgot->root.type = bfd_link_hash_defined;
6216 htab->elf.hgot->root.u.def.value = 0;
6217 htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
6218 htab->elf.hgot->def_regular = 1;
6219 htab->elf.hgot->root.linker_def = 1;
6221 htab->elf.hgot->type = STT_OBJECT;
6222 htab->elf.hgot->other
6223 = (htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
6226 if (htab->need_func_desc_adj)
6228 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6229 htab->need_func_desc_adj = 0;
6235 /* Find dynamic relocs for H that apply to read-only sections. */
6238 readonly_dynrelocs (struct elf_link_hash_entry *h)
6240 struct ppc_link_hash_entry *eh;
6241 struct elf_dyn_relocs *p;
6243 eh = (struct ppc_link_hash_entry *) h;
6244 for (p = eh->dyn_relocs; p != NULL; p = p->next)
6246 asection *s = p->sec->output_section;
6248 if (s != NULL && (s->flags & SEC_READONLY) != 0)
6254 /* Return true if we have dynamic relocs against H or any of its weak
6255 aliases, that apply to read-only sections. Cannot be used after
6256 size_dynamic_sections. */
6259 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
6261 struct ppc_link_hash_entry *eh;
6263 eh = (struct ppc_link_hash_entry *) h;
6266 if (readonly_dynrelocs (&eh->elf))
6268 eh = (struct ppc_link_hash_entry *) eh->elf.u.alias;
6270 while (eh != NULL && &eh->elf != h);
6275 /* Return whether EH has pc-relative dynamic relocs. */
6278 pc_dynrelocs (struct ppc_link_hash_entry *eh)
6280 struct elf_dyn_relocs *p;
6282 for (p = eh->dyn_relocs; p != NULL; p = p->next)
6283 if (p->pc_count != 0)
6288 /* Return true if a global entry stub will be created for H. Valid
6289 for ELFv2 before plt entries have been allocated. */
6292 global_entry_stub (struct elf_link_hash_entry *h)
6294 struct plt_entry *pent;
6296 if (!h->pointer_equality_needed
6300 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
6301 if (pent->plt.refcount > 0
6302 && pent->addend == 0)
6308 /* Adjust a symbol defined by a dynamic object and referenced by a
6309 regular object. The current definition is in some section of the
6310 dynamic object, but we're not including those sections. We have to
6311 change the definition to something the rest of the link can
6315 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6316 struct elf_link_hash_entry *h)
6318 struct ppc_link_hash_table *htab;
6321 htab = ppc_hash_table (info);
6325 /* Deal with function syms. */
6326 if (h->type == STT_FUNC
6327 || h->type == STT_GNU_IFUNC
6330 bfd_boolean local = (((struct ppc_link_hash_entry *) h)->save_res
6331 || SYMBOL_CALLS_LOCAL (info, h)
6332 || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h));
6333 /* Discard dyn_relocs when non-pic if we've decided that a
6334 function symbol is local and not an ifunc. We keep dynamic
6335 relocs for ifuncs when local rather than always emitting a
6336 plt call stub for them and defining the symbol on the call
6337 stub. We can't do that for ELFv1 anyway (a function symbol
6338 is defined on a descriptor, not code) and it can be faster at
6339 run-time due to not needing to bounce through a stub. The
6340 dyn_relocs for ifuncs will be applied even in a static
6342 if (!bfd_link_pic (info)
6343 && h->type != STT_GNU_IFUNC
6345 ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
6347 /* Clear procedure linkage table information for any symbol that
6348 won't need a .plt entry. */
6349 struct plt_entry *ent;
6350 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6351 if (ent->plt.refcount > 0)
6354 || (h->type != STT_GNU_IFUNC
6356 && (htab->can_convert_all_inline_plt
6357 || (((struct ppc_link_hash_entry *) h)->tls_mask
6358 & (TLS_TLS | PLT_KEEP)) != PLT_KEEP)))
6360 h->plt.plist = NULL;
6362 h->pointer_equality_needed = 0;
6364 else if (abiversion (info->output_bfd) >= 2)
6366 /* Taking a function's address in a read/write section
6367 doesn't require us to define the function symbol in the
6368 executable on a global entry stub. A dynamic reloc can
6369 be used instead. The reason we prefer a few more dynamic
6370 relocs is that calling via a global entry stub costs a
6371 few more instructions, and pointer_equality_needed causes
6372 extra work in ld.so when resolving these symbols. */
6373 if (global_entry_stub (h))
6375 if (!readonly_dynrelocs (h))
6377 h->pointer_equality_needed = 0;
6378 /* If we haven't seen a branch reloc and the symbol
6379 isn't an ifunc then we don't need a plt entry. */
6381 h->plt.plist = NULL;
6383 else if (!bfd_link_pic (info))
6384 /* We are going to be defining the function symbol on the
6385 plt stub, so no dyn_relocs needed when non-pic. */
6386 ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
6389 /* ELFv2 function symbols can't have copy relocs. */
6392 else if (!h->needs_plt
6393 && !readonly_dynrelocs (h))
6395 /* If we haven't seen a branch reloc and the symbol isn't an
6396 ifunc then we don't need a plt entry. */
6397 h->plt.plist = NULL;
6398 h->pointer_equality_needed = 0;
6403 h->plt.plist = NULL;
6405 /* If this is a weak symbol, and there is a real definition, the
6406 processor independent code will have arranged for us to see the
6407 real definition first, and we can just use the same value. */
6408 if (h->is_weakalias)
6410 struct elf_link_hash_entry *def = weakdef (h);
6411 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
6412 h->root.u.def.section = def->root.u.def.section;
6413 h->root.u.def.value = def->root.u.def.value;
6414 if (def->root.u.def.section == htab->elf.sdynbss
6415 || def->root.u.def.section == htab->elf.sdynrelro)
6416 ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
6420 /* If we are creating a shared library, we must presume that the
6421 only references to the symbol are via the global offset table.
6422 For such cases we need not do anything here; the relocations will
6423 be handled correctly by relocate_section. */
6424 if (bfd_link_pic (info))
6427 /* If there are no references to this symbol that do not use the
6428 GOT, we don't need to generate a copy reloc. */
6429 if (!h->non_got_ref)
6432 /* Don't generate a copy reloc for symbols defined in the executable. */
6433 if (!h->def_dynamic || !h->ref_regular || h->def_regular
6435 /* If -z nocopyreloc was given, don't generate them either. */
6436 || info->nocopyreloc
6438 /* If we don't find any dynamic relocs in read-only sections, then
6439 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
6440 || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
6442 /* Protected variables do not work with .dynbss. The copy in
6443 .dynbss won't be used by the shared library with the protected
6444 definition for the variable. Text relocations are preferable
6445 to an incorrect program. */
6446 || h->protected_def)
6449 if (h->plt.plist != NULL)
6451 /* We should never get here, but unfortunately there are versions
6452 of gcc out there that improperly (for this ABI) put initialized
6453 function pointers, vtable refs and suchlike in read-only
6454 sections. Allow them to proceed, but warn that this might
6455 break at runtime. */
6456 info->callbacks->einfo
6457 (_("%P: copy reloc against `%pT' requires lazy plt linking; "
6458 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
6459 h->root.root.string);
6462 /* This is a reference to a symbol defined by a dynamic object which
6463 is not a function. */
6465 /* We must allocate the symbol in our .dynbss section, which will
6466 become part of the .bss section of the executable. There will be
6467 an entry for this symbol in the .dynsym section. The dynamic
6468 object will contain position independent code, so all references
6469 from the dynamic object to this symbol will go through the global
6470 offset table. The dynamic linker will use the .dynsym entry to
6471 determine the address it must put in the global offset table, so
6472 both the dynamic object and the regular object will refer to the
6473 same memory location for the variable. */
6474 if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
6476 s = htab->elf.sdynrelro;
6477 srel = htab->elf.sreldynrelro;
6481 s = htab->elf.sdynbss;
6482 srel = htab->elf.srelbss;
6484 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
6486 /* We must generate a R_PPC64_COPY reloc to tell the dynamic
6487 linker to copy the initial value out of the dynamic object
6488 and into the runtime process image. */
6489 srel->size += sizeof (Elf64_External_Rela);
6493 /* We no longer want dyn_relocs. */
6494 ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
6495 return _bfd_elf_adjust_dynamic_copy (info, h, s);
6498 /* If given a function descriptor symbol, hide both the function code
6499 sym and the descriptor. */
6501 ppc64_elf_hide_symbol (struct bfd_link_info *info,
6502 struct elf_link_hash_entry *h,
6503 bfd_boolean force_local)
6505 struct ppc_link_hash_entry *eh;
6506 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
6508 if (ppc_hash_table (info) == NULL)
6511 eh = (struct ppc_link_hash_entry *) h;
6512 if (eh->is_func_descriptor)
6514 struct ppc_link_hash_entry *fh = eh->oh;
6519 struct elf_link_hash_table *htab = elf_hash_table (info);
6522 /* We aren't supposed to use alloca in BFD because on
6523 systems which do not have alloca the version in libiberty
6524 calls xmalloc, which might cause the program to crash
6525 when it runs out of memory. This function doesn't have a
6526 return status, so there's no way to gracefully return an
6527 error. So cheat. We know that string[-1] can be safely
6528 accessed; It's either a string in an ELF string table,
6529 or allocated in an objalloc structure. */
6531 p = eh->elf.root.root.string - 1;
6534 fh = (struct ppc_link_hash_entry *)
6535 elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
6538 /* Unfortunately, if it so happens that the string we were
6539 looking for was allocated immediately before this string,
6540 then we overwrote the string terminator. That's the only
6541 reason the lookup should fail. */
6544 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
6545 while (q >= eh->elf.root.root.string && *q == *p)
6547 if (q < eh->elf.root.root.string && *p == '.')
6548 fh = (struct ppc_link_hash_entry *)
6549 elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
6558 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6563 get_sym_h (struct elf_link_hash_entry **hp,
6564 Elf_Internal_Sym **symp,
6566 unsigned char **tls_maskp,
6567 Elf_Internal_Sym **locsymsp,
6568 unsigned long r_symndx,
6571 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
6573 if (r_symndx >= symtab_hdr->sh_info)
6575 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
6576 struct elf_link_hash_entry *h;
6578 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6579 h = elf_follow_link (h);
6587 if (symsecp != NULL)
6589 asection *symsec = NULL;
6590 if (h->root.type == bfd_link_hash_defined
6591 || h->root.type == bfd_link_hash_defweak)
6592 symsec = h->root.u.def.section;
6596 if (tls_maskp != NULL)
6598 struct ppc_link_hash_entry *eh;
6600 eh = (struct ppc_link_hash_entry *) h;
6601 *tls_maskp = &eh->tls_mask;
6606 Elf_Internal_Sym *sym;
6607 Elf_Internal_Sym *locsyms = *locsymsp;
6609 if (locsyms == NULL)
6611 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
6612 if (locsyms == NULL)
6613 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
6614 symtab_hdr->sh_info,
6615 0, NULL, NULL, NULL);
6616 if (locsyms == NULL)
6618 *locsymsp = locsyms;
6620 sym = locsyms + r_symndx;
6628 if (symsecp != NULL)
6629 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
6631 if (tls_maskp != NULL)
6633 struct got_entry **lgot_ents;
6634 unsigned char *tls_mask;
6637 lgot_ents = elf_local_got_ents (ibfd);
6638 if (lgot_ents != NULL)
6640 struct plt_entry **local_plt = (struct plt_entry **)
6641 (lgot_ents + symtab_hdr->sh_info);
6642 unsigned char *lgot_masks = (unsigned char *)
6643 (local_plt + symtab_hdr->sh_info);
6644 tls_mask = &lgot_masks[r_symndx];
6646 *tls_maskp = tls_mask;
6652 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
6653 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
6654 type suitable for optimization, and 1 otherwise. */
6657 get_tls_mask (unsigned char **tls_maskp,
6658 unsigned long *toc_symndx,
6659 bfd_vma *toc_addend,
6660 Elf_Internal_Sym **locsymsp,
6661 const Elf_Internal_Rela *rel,
6664 unsigned long r_symndx;
6666 struct elf_link_hash_entry *h;
6667 Elf_Internal_Sym *sym;
6671 r_symndx = ELF64_R_SYM (rel->r_info);
6672 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6675 if ((*tls_maskp != NULL
6676 && (**tls_maskp & TLS_TLS) != 0
6677 && **tls_maskp != (TLS_TLS | TLS_MARK))
6679 || ppc64_elf_section_data (sec) == NULL
6680 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
6683 /* Look inside a TOC section too. */
6686 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
6687 off = h->root.u.def.value;
6690 off = sym->st_value;
6691 off += rel->r_addend;
6692 BFD_ASSERT (off % 8 == 0);
6693 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
6694 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
6695 if (toc_symndx != NULL)
6696 *toc_symndx = r_symndx;
6697 if (toc_addend != NULL)
6698 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
6699 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6701 if ((h == NULL || is_static_defined (h))
6702 && (next_r == -1 || next_r == -2))
6707 /* Find (or create) an entry in the tocsave hash table. */
6709 static struct tocsave_entry *
6710 tocsave_find (struct ppc_link_hash_table *htab,
6711 enum insert_option insert,
6712 Elf_Internal_Sym **local_syms,
6713 const Elf_Internal_Rela *irela,
6716 unsigned long r_indx;
6717 struct elf_link_hash_entry *h;
6718 Elf_Internal_Sym *sym;
6719 struct tocsave_entry ent, *p;
6721 struct tocsave_entry **slot;
6723 r_indx = ELF64_R_SYM (irela->r_info);
6724 if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
6726 if (ent.sec == NULL || ent.sec->output_section == NULL)
6729 (_("%pB: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd);
6734 ent.offset = h->root.u.def.value;
6736 ent.offset = sym->st_value;
6737 ent.offset += irela->r_addend;
6739 hash = tocsave_htab_hash (&ent);
6740 slot = ((struct tocsave_entry **)
6741 htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
6747 p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
6756 /* Adjust all global syms defined in opd sections. In gcc generated
6757 code for the old ABI, these will already have been done. */
6760 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
6762 struct ppc_link_hash_entry *eh;
6764 struct _opd_sec_data *opd;
6766 if (h->root.type == bfd_link_hash_indirect)
6769 if (h->root.type != bfd_link_hash_defined
6770 && h->root.type != bfd_link_hash_defweak)
6773 eh = (struct ppc_link_hash_entry *) h;
6774 if (eh->adjust_done)
6777 sym_sec = eh->elf.root.u.def.section;
6778 opd = get_opd_info (sym_sec);
6779 if (opd != NULL && opd->adjust != NULL)
6781 long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
6784 /* This entry has been deleted. */
6785 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
6788 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
6789 if (discarded_section (dsec))
6791 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
6795 eh->elf.root.u.def.value = 0;
6796 eh->elf.root.u.def.section = dsec;
6799 eh->elf.root.u.def.value += adjust;
6800 eh->adjust_done = 1;
6805 /* Handles decrementing dynamic reloc counts for the reloc specified by
6806 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
6807 have already been determined. */
6810 dec_dynrel_count (bfd_vma r_info,
6812 struct bfd_link_info *info,
6813 Elf_Internal_Sym **local_syms,
6814 struct elf_link_hash_entry *h,
6815 Elf_Internal_Sym *sym)
6817 enum elf_ppc64_reloc_type r_type;
6818 asection *sym_sec = NULL;
6820 /* Can this reloc be dynamic? This switch, and later tests here
6821 should be kept in sync with the code in check_relocs. */
6822 r_type = ELF64_R_TYPE (r_info);
6828 case R_PPC64_TPREL16:
6829 case R_PPC64_TPREL16_LO:
6830 case R_PPC64_TPREL16_HI:
6831 case R_PPC64_TPREL16_HA:
6832 case R_PPC64_TPREL16_DS:
6833 case R_PPC64_TPREL16_LO_DS:
6834 case R_PPC64_TPREL16_HIGH:
6835 case R_PPC64_TPREL16_HIGHA:
6836 case R_PPC64_TPREL16_HIGHER:
6837 case R_PPC64_TPREL16_HIGHERA:
6838 case R_PPC64_TPREL16_HIGHEST:
6839 case R_PPC64_TPREL16_HIGHESTA:
6840 case R_PPC64_TPREL64:
6841 case R_PPC64_TPREL34:
6842 case R_PPC64_DTPMOD64:
6843 case R_PPC64_DTPREL64:
6844 case R_PPC64_ADDR64:
6848 case R_PPC64_ADDR14:
6849 case R_PPC64_ADDR14_BRNTAKEN:
6850 case R_PPC64_ADDR14_BRTAKEN:
6851 case R_PPC64_ADDR16:
6852 case R_PPC64_ADDR16_DS:
6853 case R_PPC64_ADDR16_HA:
6854 case R_PPC64_ADDR16_HI:
6855 case R_PPC64_ADDR16_HIGH:
6856 case R_PPC64_ADDR16_HIGHA:
6857 case R_PPC64_ADDR16_HIGHER:
6858 case R_PPC64_ADDR16_HIGHERA:
6859 case R_PPC64_ADDR16_HIGHEST:
6860 case R_PPC64_ADDR16_HIGHESTA:
6861 case R_PPC64_ADDR16_LO:
6862 case R_PPC64_ADDR16_LO_DS:
6863 case R_PPC64_ADDR24:
6864 case R_PPC64_ADDR32:
6865 case R_PPC64_UADDR16:
6866 case R_PPC64_UADDR32:
6867 case R_PPC64_UADDR64:
6870 case R_PPC64_D34_LO:
6871 case R_PPC64_D34_HI30:
6872 case R_PPC64_D34_HA30:
6873 case R_PPC64_ADDR16_HIGHER34:
6874 case R_PPC64_ADDR16_HIGHERA34:
6875 case R_PPC64_ADDR16_HIGHEST34:
6876 case R_PPC64_ADDR16_HIGHESTA34:
6881 if (local_syms != NULL)
6883 unsigned long r_symndx;
6884 bfd *ibfd = sec->owner;
6886 r_symndx = ELF64_R_SYM (r_info);
6887 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
6891 if ((bfd_link_pic (info)
6892 && (must_be_dyn_reloc (info, r_type)
6894 && (!SYMBOLIC_BIND (info, h)
6895 || h->root.type == bfd_link_hash_defweak
6896 || !h->def_regular))))
6897 || (ELIMINATE_COPY_RELOCS
6898 && !bfd_link_pic (info)
6900 && (h->root.type == bfd_link_hash_defweak
6901 || !h->def_regular)))
6908 struct elf_dyn_relocs *p;
6909 struct elf_dyn_relocs **pp;
6910 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
6912 /* elf_gc_sweep may have already removed all dyn relocs associated
6913 with local syms for a given section. Also, symbol flags are
6914 changed by elf_gc_sweep_symbol, confusing the test above. Don't
6915 report a dynreloc miscount. */
6916 if (*pp == NULL && info->gc_sections)
6919 while ((p = *pp) != NULL)
6923 if (!must_be_dyn_reloc (info, r_type))
6935 struct ppc_dyn_relocs *p;
6936 struct ppc_dyn_relocs **pp;
6938 bfd_boolean is_ifunc;
6940 if (local_syms == NULL)
6941 sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6942 if (sym_sec == NULL)
6945 vpp = &elf_section_data (sym_sec)->local_dynrel;
6946 pp = (struct ppc_dyn_relocs **) vpp;
6948 if (*pp == NULL && info->gc_sections)
6951 is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
6952 while ((p = *pp) != NULL)
6954 if (p->sec == sec && p->ifunc == is_ifunc)
6965 /* xgettext:c-format */
6966 _bfd_error_handler (_("dynreloc miscount for %pB, section %pA"),
6968 bfd_set_error (bfd_error_bad_value);
6972 /* Remove unused Official Procedure Descriptor entries. Currently we
6973 only remove those associated with functions in discarded link-once
6974 sections, or weakly defined functions that have been overridden. It
6975 would be possible to remove many more entries for statically linked
6979 ppc64_elf_edit_opd (struct bfd_link_info *info)
6982 bfd_boolean some_edited = FALSE;
6983 asection *need_pad = NULL;
6984 struct ppc_link_hash_table *htab;
6986 htab = ppc_hash_table (info);
6990 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
6993 Elf_Internal_Rela *relstart, *rel, *relend;
6994 Elf_Internal_Shdr *symtab_hdr;
6995 Elf_Internal_Sym *local_syms;
6996 struct _opd_sec_data *opd;
6997 bfd_boolean need_edit, add_aux_fields, broken;
6998 bfd_size_type cnt_16b = 0;
7000 if (!is_ppc64_elf (ibfd))
7003 sec = bfd_get_section_by_name (ibfd, ".opd");
7004 if (sec == NULL || sec->size == 0)
7007 if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7010 if (sec->output_section == bfd_abs_section_ptr)
7013 /* Look through the section relocs. */
7014 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7018 symtab_hdr = &elf_symtab_hdr (ibfd);
7020 /* Read the relocations. */
7021 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7023 if (relstart == NULL)
7026 /* First run through the relocs to check they are sane, and to
7027 determine whether we need to edit this opd section. */
7031 relend = relstart + sec->reloc_count;
7032 for (rel = relstart; rel < relend; )
7034 enum elf_ppc64_reloc_type r_type;
7035 unsigned long r_symndx;
7037 struct elf_link_hash_entry *h;
7038 Elf_Internal_Sym *sym;
7041 /* .opd contains an array of 16 or 24 byte entries. We're
7042 only interested in the reloc pointing to a function entry
7044 offset = rel->r_offset;
7045 if (rel + 1 == relend
7046 || rel[1].r_offset != offset + 8)
7048 /* If someone messes with .opd alignment then after a
7049 "ld -r" we might have padding in the middle of .opd.
7050 Also, there's nothing to prevent someone putting
7051 something silly in .opd with the assembler. No .opd
7052 optimization for them! */
7055 (_("%pB: .opd is not a regular array of opd entries"), ibfd);
7060 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7061 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7064 /* xgettext:c-format */
7065 (_("%pB: unexpected reloc type %u in .opd section"),
7071 r_symndx = ELF64_R_SYM (rel->r_info);
7072 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7076 if (sym_sec == NULL || sym_sec->owner == NULL)
7078 const char *sym_name;
7080 sym_name = h->root.root.string;
7082 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7086 /* xgettext:c-format */
7087 (_("%pB: undefined sym `%s' in .opd section"),
7093 /* opd entries are always for functions defined in the
7094 current input bfd. If the symbol isn't defined in the
7095 input bfd, then we won't be using the function in this
7096 bfd; It must be defined in a linkonce section in another
7097 bfd, or is weak. It's also possible that we are
7098 discarding the function due to a linker script /DISCARD/,
7099 which we test for via the output_section. */
7100 if (sym_sec->owner != ibfd
7101 || sym_sec->output_section == bfd_abs_section_ptr)
7105 if (rel + 1 == relend
7106 || (rel + 2 < relend
7107 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
7112 if (sec->size == offset + 24)
7117 if (sec->size == offset + 16)
7124 else if (rel + 1 < relend
7125 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7126 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7128 if (rel[0].r_offset == offset + 16)
7130 else if (rel[0].r_offset != offset + 24)
7137 add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7139 if (!broken && (need_edit || add_aux_fields))
7141 Elf_Internal_Rela *write_rel;
7142 Elf_Internal_Shdr *rel_hdr;
7143 bfd_byte *rptr, *wptr;
7144 bfd_byte *new_contents;
7147 new_contents = NULL;
7148 amt = OPD_NDX (sec->size) * sizeof (long);
7149 opd = &ppc64_elf_section_data (sec)->u.opd;
7150 opd->adjust = bfd_zalloc (sec->owner, amt);
7151 if (opd->adjust == NULL)
7154 /* This seems a waste of time as input .opd sections are all
7155 zeros as generated by gcc, but I suppose there's no reason
7156 this will always be so. We might start putting something in
7157 the third word of .opd entries. */
7158 if ((sec->flags & SEC_IN_MEMORY) == 0)
7161 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7166 if (local_syms != NULL
7167 && symtab_hdr->contents != (unsigned char *) local_syms)
7169 if (elf_section_data (sec)->relocs != relstart)
7173 sec->contents = loc;
7174 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7177 elf_section_data (sec)->relocs = relstart;
7179 new_contents = sec->contents;
7182 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7183 if (new_contents == NULL)
7187 wptr = new_contents;
7188 rptr = sec->contents;
7189 write_rel = relstart;
7190 for (rel = relstart; rel < relend; )
7192 unsigned long r_symndx;
7194 struct elf_link_hash_entry *h;
7195 struct ppc_link_hash_entry *fdh = NULL;
7196 Elf_Internal_Sym *sym;
7198 Elf_Internal_Rela *next_rel;
7201 r_symndx = ELF64_R_SYM (rel->r_info);
7202 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7207 if (next_rel + 1 == relend
7208 || (next_rel + 2 < relend
7209 && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
7212 /* See if the .opd entry is full 24 byte or
7213 16 byte (with fd_aux entry overlapped with next
7216 if (next_rel == relend)
7218 if (sec->size == rel->r_offset + 16)
7221 else if (next_rel->r_offset == rel->r_offset + 16)
7225 && h->root.root.string[0] == '.')
7227 fdh = ((struct ppc_link_hash_entry *) h)->oh;
7230 fdh = ppc_follow_link (fdh);
7231 if (fdh->elf.root.type != bfd_link_hash_defined
7232 && fdh->elf.root.type != bfd_link_hash_defweak)
7237 skip = (sym_sec->owner != ibfd
7238 || sym_sec->output_section == bfd_abs_section_ptr);
7241 if (fdh != NULL && sym_sec->owner == ibfd)
7243 /* Arrange for the function descriptor sym
7245 fdh->elf.root.u.def.value = 0;
7246 fdh->elf.root.u.def.section = sym_sec;
7248 opd->adjust[OPD_NDX (rel->r_offset)] = -1;
7250 if (NO_OPD_RELOCS || bfd_link_relocatable (info))
7255 if (!dec_dynrel_count (rel->r_info, sec, info,
7259 if (++rel == next_rel)
7262 r_symndx = ELF64_R_SYM (rel->r_info);
7263 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7270 /* We'll be keeping this opd entry. */
7275 /* Redefine the function descriptor symbol to
7276 this location in the opd section. It is
7277 necessary to update the value here rather
7278 than using an array of adjustments as we do
7279 for local symbols, because various places
7280 in the generic ELF code use the value
7281 stored in u.def.value. */
7282 fdh->elf.root.u.def.value = wptr - new_contents;
7283 fdh->adjust_done = 1;
7286 /* Local syms are a bit tricky. We could
7287 tweak them as they can be cached, but
7288 we'd need to look through the local syms
7289 for the function descriptor sym which we
7290 don't have at the moment. So keep an
7291 array of adjustments. */
7292 adjust = (wptr - new_contents) - (rptr - sec->contents);
7293 opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
7296 memcpy (wptr, rptr, opd_ent_size);
7297 wptr += opd_ent_size;
7298 if (add_aux_fields && opd_ent_size == 16)
7300 memset (wptr, '\0', 8);
7304 /* We need to adjust any reloc offsets to point to the
7306 for ( ; rel != next_rel; ++rel)
7308 rel->r_offset += adjust;
7309 if (write_rel != rel)
7310 memcpy (write_rel, rel, sizeof (*rel));
7315 rptr += opd_ent_size;
7318 sec->size = wptr - new_contents;
7319 sec->reloc_count = write_rel - relstart;
7322 free (sec->contents);
7323 sec->contents = new_contents;
7326 /* Fudge the header size too, as this is used later in
7327 elf_bfd_final_link if we are emitting relocs. */
7328 rel_hdr = _bfd_elf_single_rel_hdr (sec);
7329 rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7332 else if (elf_section_data (sec)->relocs != relstart)
7335 if (local_syms != NULL
7336 && symtab_hdr->contents != (unsigned char *) local_syms)
7338 if (!info->keep_memory)
7341 symtab_hdr->contents = (unsigned char *) local_syms;
7346 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7348 /* If we are doing a final link and the last .opd entry is just 16 byte
7349 long, add a 8 byte padding after it. */
7350 if (need_pad != NULL && !bfd_link_relocatable (info))
7354 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7356 BFD_ASSERT (need_pad->size > 0);
7358 p = bfd_malloc (need_pad->size + 8);
7362 if (!bfd_get_section_contents (need_pad->owner, need_pad,
7363 p, 0, need_pad->size))
7366 need_pad->contents = p;
7367 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7371 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7375 need_pad->contents = p;
7378 memset (need_pad->contents + need_pad->size, 0, 8);
7379 need_pad->size += 8;
7385 /* Analyze inline PLT call relocations to see whether calls to locally
7386 defined functions can be converted to direct calls. */
7389 ppc64_elf_inline_plt (struct bfd_link_info *info)
7391 struct ppc_link_hash_table *htab;
7394 bfd_vma low_vma, high_vma, limit;
7396 htab = ppc_hash_table (info);
7400 /* A bl insn can reach -0x2000000 to 0x1fffffc. The limit is
7401 reduced somewhat to cater for possible stubs that might be added
7402 between the call and its destination. */
7403 if (htab->params->group_size < 0)
7405 limit = -htab->params->group_size;
7411 limit = htab->params->group_size;
7418 for (sec = info->output_bfd->sections; sec != NULL; sec = sec->next)
7419 if ((sec->flags & (SEC_ALLOC | SEC_CODE)) == (SEC_ALLOC | SEC_CODE))
7421 if (low_vma > sec->vma)
7423 if (high_vma < sec->vma + sec->size)
7424 high_vma = sec->vma + sec->size;
7427 /* If a "bl" can reach anywhere in local code sections, then we can
7428 convert all inline PLT sequences to direct calls when the symbol
7430 if (high_vma - low_vma < limit)
7432 htab->can_convert_all_inline_plt = 1;
7436 /* Otherwise, go looking through relocs for cases where a direct
7437 call won't reach. Mark the symbol on any such reloc to disable
7438 the optimization and keep the PLT entry as it seems likely that
7439 this will be better than creating trampolines. Note that this
7440 will disable the optimization for all inline PLT calls to a
7441 particular symbol, not just those that won't reach. The
7442 difficulty in doing a more precise optimization is that the
7443 linker needs to make a decision depending on whether a
7444 particular R_PPC64_PLTCALL insn can be turned into a direct
7445 call, for each of the R_PPC64_PLTSEQ and R_PPC64_PLT16* insns in
7446 the sequence, and there is nothing that ties those relocs
7447 together except their symbol. */
7449 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7451 Elf_Internal_Shdr *symtab_hdr;
7452 Elf_Internal_Sym *local_syms;
7454 if (!is_ppc64_elf (ibfd))
7458 symtab_hdr = &elf_symtab_hdr (ibfd);
7460 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7461 if (ppc64_elf_section_data (sec)->has_pltcall
7462 && !bfd_is_abs_section (sec->output_section))
7464 Elf_Internal_Rela *relstart, *rel, *relend;
7466 /* Read the relocations. */
7467 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7469 if (relstart == NULL)
7472 relend = relstart + sec->reloc_count;
7473 for (rel = relstart; rel < relend; )
7475 enum elf_ppc64_reloc_type r_type;
7476 unsigned long r_symndx;
7478 struct elf_link_hash_entry *h;
7479 Elf_Internal_Sym *sym;
7480 unsigned char *tls_maskp;
7482 r_type = ELF64_R_TYPE (rel->r_info);
7483 if (r_type != R_PPC64_PLTCALL
7484 && r_type != R_PPC64_PLTCALL_NOTOC)
7487 r_symndx = ELF64_R_SYM (rel->r_info);
7488 if (!get_sym_h (&h, &sym, &sym_sec, &tls_maskp, &local_syms,
7491 if (elf_section_data (sec)->relocs != relstart)
7493 if (local_syms != NULL
7494 && symtab_hdr->contents != (bfd_byte *) local_syms)
7499 if (sym_sec != NULL && sym_sec->output_section != NULL)
7503 to = h->root.u.def.value;
7506 to += (rel->r_addend
7507 + sym_sec->output_offset
7508 + sym_sec->output_section->vma);
7509 from = (rel->r_offset
7510 + sec->output_offset
7511 + sec->output_section->vma);
7512 if (to - from + limit < 2 * limit
7513 && !(r_type == R_PPC64_PLTCALL_NOTOC
7514 && (((h ? h->other : sym->st_other)
7515 & STO_PPC64_LOCAL_MASK)
7516 > 1 << STO_PPC64_LOCAL_BIT)))
7517 *tls_maskp &= ~PLT_KEEP;
7520 if (elf_section_data (sec)->relocs != relstart)
7524 if (local_syms != NULL
7525 && symtab_hdr->contents != (unsigned char *) local_syms)
7527 if (!info->keep_memory)
7530 symtab_hdr->contents = (unsigned char *) local_syms;
7537 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
7540 ppc64_elf_tls_setup (struct bfd_link_info *info)
7542 struct ppc_link_hash_table *htab;
7544 htab = ppc_hash_table (info);
7548 if (abiversion (info->output_bfd) == 1)
7551 if (htab->params->no_multi_toc)
7552 htab->do_multi_toc = 0;
7553 else if (!htab->do_multi_toc)
7554 htab->params->no_multi_toc = 1;
7556 /* Default to --no-plt-localentry, as this option can cause problems
7557 with symbol interposition. For example, glibc libpthread.so and
7558 libc.so duplicate many pthread symbols, with a fallback
7559 implementation in libc.so. In some cases the fallback does more
7560 work than the pthread implementation. __pthread_condattr_destroy
7561 is one such symbol: the libpthread.so implementation is
7562 localentry:0 while the libc.so implementation is localentry:8.
7563 An app that "cleverly" uses dlopen to only load necessary
7564 libraries at runtime may omit loading libpthread.so when not
7565 running multi-threaded, which then results in the libc.so
7566 fallback symbols being used and ld.so complaining. Now there
7567 are workarounds in ld (see non_zero_localentry) to detect the
7568 pthread situation, but that may not be the only case where
7569 --plt-localentry can cause trouble. */
7570 if (htab->params->plt_localentry0 < 0)
7571 htab->params->plt_localentry0 = 0;
7572 if (htab->params->plt_localentry0
7573 && elf_link_hash_lookup (&htab->elf, "GLIBC_2.26",
7574 FALSE, FALSE, FALSE) == NULL)
7576 (_("warning: --plt-localentry is especially dangerous without "
7577 "ld.so support to detect ABI violations"));
7579 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7580 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7581 FALSE, FALSE, TRUE));
7582 /* Move dynamic linking info to the function descriptor sym. */
7583 if (htab->tls_get_addr != NULL)
7584 func_desc_adjust (&htab->tls_get_addr->elf, info);
7585 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7586 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7587 FALSE, FALSE, TRUE));
7588 if (htab->params->tls_get_addr_opt)
7590 struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7592 opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7593 FALSE, FALSE, TRUE);
7595 func_desc_adjust (opt, info);
7596 opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7597 FALSE, FALSE, TRUE);
7599 && (opt_fd->root.type == bfd_link_hash_defined
7600 || opt_fd->root.type == bfd_link_hash_defweak))
7602 /* If glibc supports an optimized __tls_get_addr call stub,
7603 signalled by the presence of __tls_get_addr_opt, and we'll
7604 be calling __tls_get_addr via a plt call stub, then
7605 make __tls_get_addr point to __tls_get_addr_opt. */
7606 tga_fd = &htab->tls_get_addr_fd->elf;
7607 if (htab->elf.dynamic_sections_created
7609 && (tga_fd->type == STT_FUNC
7610 || tga_fd->needs_plt)
7611 && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
7612 || UNDEFWEAK_NO_DYNAMIC_RELOC (info, tga_fd)))
7614 struct plt_entry *ent;
7616 for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
7617 if (ent->plt.refcount > 0)
7621 tga_fd->root.type = bfd_link_hash_indirect;
7622 tga_fd->root.u.i.link = &opt_fd->root;
7623 ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
7625 if (opt_fd->dynindx != -1)
7627 /* Use __tls_get_addr_opt in dynamic relocations. */
7628 opt_fd->dynindx = -1;
7629 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
7630 opt_fd->dynstr_index);
7631 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
7634 htab->tls_get_addr_fd
7635 = (struct ppc_link_hash_entry *) opt_fd;
7636 tga = &htab->tls_get_addr->elf;
7637 if (opt != NULL && tga != NULL)
7639 tga->root.type = bfd_link_hash_indirect;
7640 tga->root.u.i.link = &opt->root;
7641 ppc64_elf_copy_indirect_symbol (info, opt, tga);
7643 _bfd_elf_link_hash_hide_symbol (info, opt,
7645 htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
7647 htab->tls_get_addr_fd->oh = htab->tls_get_addr;
7648 htab->tls_get_addr_fd->is_func_descriptor = 1;
7649 if (htab->tls_get_addr != NULL)
7651 htab->tls_get_addr->oh = htab->tls_get_addr_fd;
7652 htab->tls_get_addr->is_func = 1;
7657 else if (htab->params->tls_get_addr_opt < 0)
7658 htab->params->tls_get_addr_opt = 0;
7660 return _bfd_elf_tls_setup (info->output_bfd, info);
7663 /* Return TRUE iff REL is a branch reloc with a global symbol matching
7667 branch_reloc_hash_match (const bfd *ibfd,
7668 const Elf_Internal_Rela *rel,
7669 const struct ppc_link_hash_entry *hash1,
7670 const struct ppc_link_hash_entry *hash2)
7672 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7673 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
7674 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
7676 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
7678 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7679 struct elf_link_hash_entry *h;
7681 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7682 h = elf_follow_link (h);
7683 if (h == &hash1->elf || h == &hash2->elf)
7689 /* Run through all the TLS relocs looking for optimization
7690 opportunities. The linker has been hacked (see ppc64elf.em) to do
7691 a preliminary section layout so that we know the TLS segment
7692 offsets. We can't optimize earlier because some optimizations need
7693 to know the tp offset, and we need to optimize before allocating
7694 dynamic relocations. */
7697 ppc64_elf_tls_optimize (struct bfd_link_info *info)
7701 struct ppc_link_hash_table *htab;
7702 unsigned char *toc_ref;
7705 if (!bfd_link_executable (info))
7708 htab = ppc_hash_table (info);
7712 /* Make two passes over the relocs. On the first pass, mark toc
7713 entries involved with tls relocs, and check that tls relocs
7714 involved in setting up a tls_get_addr call are indeed followed by
7715 such a call. If they are not, we can't do any tls optimization.
7716 On the second pass twiddle tls_mask flags to notify
7717 relocate_section that optimization can be done, and adjust got
7718 and plt refcounts. */
7720 for (pass = 0; pass < 2; ++pass)
7721 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7723 Elf_Internal_Sym *locsyms = NULL;
7724 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
7726 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7727 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
7729 Elf_Internal_Rela *relstart, *rel, *relend;
7730 bfd_boolean found_tls_get_addr_arg = 0;
7732 /* Read the relocations. */
7733 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7735 if (relstart == NULL)
7741 relend = relstart + sec->reloc_count;
7742 for (rel = relstart; rel < relend; rel++)
7744 enum elf_ppc64_reloc_type r_type;
7745 unsigned long r_symndx;
7746 struct elf_link_hash_entry *h;
7747 Elf_Internal_Sym *sym;
7749 unsigned char *tls_mask;
7750 unsigned int tls_set, tls_clear, tls_type = 0;
7752 bfd_boolean ok_tprel, is_local;
7753 long toc_ref_index = 0;
7754 int expecting_tls_get_addr = 0;
7755 bfd_boolean ret = FALSE;
7757 r_symndx = ELF64_R_SYM (rel->r_info);
7758 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
7762 if (elf_section_data (sec)->relocs != relstart)
7764 if (toc_ref != NULL)
7767 && (elf_symtab_hdr (ibfd).contents
7768 != (unsigned char *) locsyms))
7775 if (h->root.type == bfd_link_hash_defined
7776 || h->root.type == bfd_link_hash_defweak)
7777 value = h->root.u.def.value;
7778 else if (h->root.type == bfd_link_hash_undefweak)
7782 found_tls_get_addr_arg = 0;
7787 /* Symbols referenced by TLS relocs must be of type
7788 STT_TLS. So no need for .opd local sym adjust. */
7789 value = sym->st_value;
7798 && h->root.type == bfd_link_hash_undefweak)
7800 else if (sym_sec != NULL
7801 && sym_sec->output_section != NULL)
7803 value += sym_sec->output_offset;
7804 value += sym_sec->output_section->vma;
7805 value -= htab->elf.tls_sec->vma + TP_OFFSET;
7806 /* Note that even though the prefix insns
7807 allow a 1<<33 offset we use the same test
7808 as for addis;addi. There may be a mix of
7809 pcrel and non-pcrel code and the decision
7810 to optimise is per symbol, not per TLS
7812 ok_tprel = value + 0x80008000ULL < 1ULL << 32;
7816 r_type = ELF64_R_TYPE (rel->r_info);
7817 /* If this section has old-style __tls_get_addr calls
7818 without marker relocs, then check that each
7819 __tls_get_addr call reloc is preceded by a reloc
7820 that conceivably belongs to the __tls_get_addr arg
7821 setup insn. If we don't find matching arg setup
7822 relocs, don't do any tls optimization. */
7824 && sec->has_tls_get_addr_call
7826 && (h == &htab->tls_get_addr->elf
7827 || h == &htab->tls_get_addr_fd->elf)
7828 && !found_tls_get_addr_arg
7829 && is_branch_reloc (r_type))
7831 info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
7832 "TLS optimization disabled\n"),
7833 ibfd, sec, rel->r_offset);
7838 found_tls_get_addr_arg = 0;
7841 case R_PPC64_GOT_TLSLD16:
7842 case R_PPC64_GOT_TLSLD16_LO:
7843 case R_PPC64_GOT_TLSLD34:
7844 expecting_tls_get_addr = 1;
7845 found_tls_get_addr_arg = 1;
7848 case R_PPC64_GOT_TLSLD16_HI:
7849 case R_PPC64_GOT_TLSLD16_HA:
7850 /* These relocs should never be against a symbol
7851 defined in a shared lib. Leave them alone if
7852 that turns out to be the case. */
7859 tls_type = TLS_TLS | TLS_LD;
7862 case R_PPC64_GOT_TLSGD16:
7863 case R_PPC64_GOT_TLSGD16_LO:
7864 case R_PPC64_GOT_TLSGD34:
7865 expecting_tls_get_addr = 1;
7866 found_tls_get_addr_arg = 1;
7869 case R_PPC64_GOT_TLSGD16_HI:
7870 case R_PPC64_GOT_TLSGD16_HA:
7876 tls_set = TLS_TLS | TLS_GDIE;
7878 tls_type = TLS_TLS | TLS_GD;
7881 case R_PPC64_GOT_TPREL34:
7882 case R_PPC64_GOT_TPREL16_DS:
7883 case R_PPC64_GOT_TPREL16_LO_DS:
7884 case R_PPC64_GOT_TPREL16_HI:
7885 case R_PPC64_GOT_TPREL16_HA:
7890 tls_clear = TLS_TPREL;
7891 tls_type = TLS_TLS | TLS_TPREL;
7898 if (rel + 1 < relend
7899 && is_plt_seq_reloc (ELF64_R_TYPE (rel[1].r_info)))
7902 && (ELF64_R_TYPE (rel[1].r_info)
7904 && (ELF64_R_TYPE (rel[1].r_info)
7905 != R_PPC64_PLTSEQ_NOTOC))
7907 r_symndx = ELF64_R_SYM (rel[1].r_info);
7908 if (!get_sym_h (&h, NULL, NULL, NULL, &locsyms,
7913 struct plt_entry *ent = NULL;
7915 for (ent = h->plt.plist;
7918 if (ent->addend == rel[1].r_addend)
7922 && ent->plt.refcount > 0)
7923 ent->plt.refcount -= 1;
7928 found_tls_get_addr_arg = 1;
7933 case R_PPC64_TOC16_LO:
7934 if (sym_sec == NULL || sym_sec != toc)
7937 /* Mark this toc entry as referenced by a TLS
7938 code sequence. We can do that now in the
7939 case of R_PPC64_TLS, and after checking for
7940 tls_get_addr for the TOC16 relocs. */
7941 if (toc_ref == NULL)
7943 = bfd_zmalloc (toc->output_section->rawsize / 8);
7944 if (toc_ref == NULL)
7948 value = h->root.u.def.value;
7950 value = sym->st_value;
7951 value += rel->r_addend;
7954 BFD_ASSERT (value < toc->size
7955 && toc->output_offset % 8 == 0);
7956 toc_ref_index = (value + toc->output_offset) / 8;
7957 if (r_type == R_PPC64_TLS
7958 || r_type == R_PPC64_TLSGD
7959 || r_type == R_PPC64_TLSLD)
7961 toc_ref[toc_ref_index] = 1;
7965 if (pass != 0 && toc_ref[toc_ref_index] == 0)
7970 expecting_tls_get_addr = 2;
7973 case R_PPC64_TPREL64:
7977 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
7982 tls_set = TLS_EXPLICIT;
7983 tls_clear = TLS_TPREL;
7988 case R_PPC64_DTPMOD64:
7992 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
7994 if (rel + 1 < relend
7996 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
7997 && rel[1].r_offset == rel->r_offset + 8)
8001 tls_set = TLS_EXPLICIT | TLS_GD;
8004 tls_set = TLS_EXPLICIT | TLS_GD | TLS_GDIE;
8013 tls_set = TLS_EXPLICIT;
8024 if (!expecting_tls_get_addr
8025 || !sec->has_tls_get_addr_call)
8028 if (rel + 1 < relend
8029 && branch_reloc_hash_match (ibfd, rel + 1,
8031 htab->tls_get_addr_fd))
8033 if (expecting_tls_get_addr == 2)
8035 /* Check for toc tls entries. */
8036 unsigned char *toc_tls;
8039 retval = get_tls_mask (&toc_tls, NULL, NULL,
8044 if (toc_tls != NULL)
8046 if ((*toc_tls & TLS_TLS) != 0
8047 && ((*toc_tls & (TLS_GD | TLS_LD)) != 0))
8048 found_tls_get_addr_arg = 1;
8050 toc_ref[toc_ref_index] = 1;
8056 /* Uh oh, we didn't find the expected call. We
8057 could just mark this symbol to exclude it
8058 from tls optimization but it's safer to skip
8059 the entire optimization. */
8060 /* xgettext:c-format */
8061 info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8062 "TLS optimization disabled\n"),
8063 ibfd, sec, rel->r_offset);
8068 /* If we don't have old-style __tls_get_addr calls
8069 without TLSGD/TLSLD marker relocs, and we haven't
8070 found a new-style __tls_get_addr call with a
8071 marker for this symbol, then we either have a
8072 broken object file or an -mlongcall style
8073 indirect call to __tls_get_addr without a marker.
8074 Disable optimization in this case. */
8075 if ((tls_clear & (TLS_GD | TLS_LD)) != 0
8076 && (tls_set & TLS_EXPLICIT) == 0
8077 && !sec->has_tls_get_addr_call
8078 && ((*tls_mask & (TLS_TLS | TLS_MARK))
8079 != (TLS_TLS | TLS_MARK)))
8082 if (expecting_tls_get_addr)
8084 struct plt_entry *ent = NULL;
8086 if (htab->tls_get_addr != NULL)
8087 for (ent = htab->tls_get_addr->elf.plt.plist;
8090 if (ent->addend == 0)
8093 if (ent == NULL && htab->tls_get_addr_fd != NULL)
8094 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8097 if (ent->addend == 0)
8101 && ent->plt.refcount > 0)
8102 ent->plt.refcount -= 1;
8108 if ((tls_set & TLS_EXPLICIT) == 0)
8110 struct got_entry *ent;
8112 /* Adjust got entry for this reloc. */
8116 ent = elf_local_got_ents (ibfd)[r_symndx];
8118 for (; ent != NULL; ent = ent->next)
8119 if (ent->addend == rel->r_addend
8120 && ent->owner == ibfd
8121 && ent->tls_type == tls_type)
8128 /* We managed to get rid of a got entry. */
8129 if (ent->got.refcount > 0)
8130 ent->got.refcount -= 1;
8135 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8136 we'll lose one or two dyn relocs. */
8137 if (!dec_dynrel_count (rel->r_info, sec, info,
8141 if (tls_set == (TLS_EXPLICIT | TLS_GD))
8143 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8149 *tls_mask |= tls_set & 0xff;
8150 *tls_mask &= ~tls_clear;
8153 if (elf_section_data (sec)->relocs != relstart)
8158 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8160 if (!info->keep_memory)
8163 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8167 if (toc_ref != NULL)
8169 htab->do_tls_opt = 1;
8173 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8174 the values of any global symbols in a toc section that has been
8175 edited. Globals in toc sections should be a rarity, so this function
8176 sets a flag if any are found in toc sections other than the one just
8177 edited, so that further hash table traversals can be avoided. */
8179 struct adjust_toc_info
8182 unsigned long *skip;
8183 bfd_boolean global_toc_syms;
8186 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8189 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8191 struct ppc_link_hash_entry *eh;
8192 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8195 if (h->root.type != bfd_link_hash_defined
8196 && h->root.type != bfd_link_hash_defweak)
8199 eh = (struct ppc_link_hash_entry *) h;
8200 if (eh->adjust_done)
8203 if (eh->elf.root.u.def.section == toc_inf->toc)
8205 if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8206 i = toc_inf->toc->rawsize >> 3;
8208 i = eh->elf.root.u.def.value >> 3;
8210 if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8213 (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8216 while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8217 eh->elf.root.u.def.value = (bfd_vma) i << 3;
8220 eh->elf.root.u.def.value -= toc_inf->skip[i];
8221 eh->adjust_done = 1;
8223 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8224 toc_inf->global_toc_syms = TRUE;
8229 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
8230 on a _LO variety toc/got reloc. */
8233 ok_lo_toc_insn (unsigned int insn, enum elf_ppc64_reloc_type r_type)
8235 return ((insn & (0x3f << 26)) == 12u << 26 /* addic */
8236 || (insn & (0x3f << 26)) == 14u << 26 /* addi */
8237 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8238 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8239 || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8240 || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8241 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8242 || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8243 || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8244 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8245 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8246 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8247 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8248 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8249 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8250 || (insn & (0x3f << 26)) == 56u << 26 /* lq,lfq */
8251 || ((insn & (0x3f << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
8252 /* Exclude lfqu by testing reloc. If relocs are ever
8253 defined for the reduced D field in psq_lu then those
8254 will need testing too. */
8255 && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8256 || ((insn & (0x3f << 26)) == 58u << 26 /* ld,lwa */
8258 || (insn & (0x3f << 26)) == 60u << 26 /* stfq */
8259 || ((insn & (0x3f << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
8260 /* Exclude stfqu. psq_stu as above for psq_lu. */
8261 && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8262 || ((insn & (0x3f << 26)) == 62u << 26 /* std,stq */
8263 && (insn & 1) == 0));
8266 /* PCREL_OPT in one instance flags to the linker that a pair of insns:
8267 pld ra,symbol@got@pcrel
8268 load/store rt,off(ra)
8271 load/store rt,off(ra)
8272 may be translated to
8273 pload/pstore rt,symbol+off@pcrel
8275 This function returns true if the optimization is possible, placing
8276 the prefix insn in *PINSN1, a NOP in *PINSN2 and the offset in *POFF.
8278 On entry to this function, the linker has already determined that
8279 the pld can be replaced with pla: *PINSN1 is that pla insn,
8280 while *PINSN2 is the second instruction. */
8283 xlate_pcrel_opt (uint64_t *pinsn1, uint64_t *pinsn2, bfd_signed_vma *poff)
8285 uint32_t insn2 = *pinsn2 >> 32;
8289 /* Check that regs match. */
8290 if (((insn2 >> 16) & 31) != ((*pinsn1 >> 21) & 31))
8293 switch ((insn2 >> 26) & 63)
8309 /* These are the PMLS cases, where we just need to tack a prefix
8311 i1new = ((1ULL << 58) | (2ULL << 56) | (1ULL << 52)
8312 | (insn2 & ((63ULL << 26) | (31ULL << 21))));
8313 off = insn2 & 0xffff;
8316 case 58: /* lwa, ld */
8317 if ((insn2 & 1) != 0)
8319 i1new = ((1ULL << 58) | (1ULL << 52)
8320 | (insn2 & 2 ? 41ULL << 26 : 57ULL << 26)
8321 | (insn2 & (31ULL << 21)));
8322 off = insn2 & 0xfffc;
8325 case 57: /* lxsd, lxssp */
8326 if ((insn2 & 3) < 2)
8328 i1new = ((1ULL << 58) | (1ULL << 52)
8329 | ((40ULL | (insn2 & 3)) << 26)
8330 | (insn2 & (31ULL << 21)));
8331 off = insn2 & 0xfffc;
8334 case 61: /* stxsd, stxssp, lxv, stxv */
8335 if ((insn2 & 3) == 0)
8337 else if ((insn2 & 3) >= 2)
8339 i1new = ((1ULL << 58) | (1ULL << 52)
8340 | ((44ULL | (insn2 & 3)) << 26)
8341 | (insn2 & (31ULL << 21)));
8342 off = insn2 & 0xfffc;
8346 i1new = ((1ULL << 58) | (1ULL << 52)
8347 | ((50ULL | (insn2 & 4) | ((insn2 & 8) >> 3)) << 26)
8348 | (insn2 & (31ULL << 21)));
8349 off = insn2 & 0xfff0;
8354 i1new = ((1ULL << 58) | (1ULL << 52)
8355 | (insn2 & ((63ULL << 26) | (31ULL << 21))));
8356 off = insn2 & 0xffff;
8359 case 62: /* std, stq */
8360 if ((insn2 & 1) != 0)
8362 i1new = ((1ULL << 58) | (1ULL << 52)
8363 | ((insn2 & 2) == 0 ? 61ULL << 26 : 60ULL << 26)
8364 | (insn2 & (31ULL << 21)));
8365 off = insn2 & 0xfffc;
8370 *pinsn2 = (uint64_t) NOP << 32;
8371 *poff = (off ^ 0x8000) - 0x8000;
8375 /* Examine all relocs referencing .toc sections in order to remove
8376 unused .toc entries. */
8379 ppc64_elf_edit_toc (struct bfd_link_info *info)
8382 struct adjust_toc_info toc_inf;
8383 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8385 htab->do_toc_opt = 1;
8386 toc_inf.global_toc_syms = TRUE;
8387 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8389 asection *toc, *sec;
8390 Elf_Internal_Shdr *symtab_hdr;
8391 Elf_Internal_Sym *local_syms;
8392 Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8393 unsigned long *skip, *drop;
8394 unsigned char *used;
8395 unsigned char *keep, last, some_unused;
8397 if (!is_ppc64_elf (ibfd))
8400 toc = bfd_get_section_by_name (ibfd, ".toc");
8403 || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8404 || discarded_section (toc))
8409 symtab_hdr = &elf_symtab_hdr (ibfd);
8411 /* Look at sections dropped from the final link. */
8414 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8416 if (sec->reloc_count == 0
8417 || !discarded_section (sec)
8418 || get_opd_info (sec)
8419 || (sec->flags & SEC_ALLOC) == 0
8420 || (sec->flags & SEC_DEBUGGING) != 0)
8423 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8424 if (relstart == NULL)
8427 /* Run through the relocs to see which toc entries might be
8429 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8431 enum elf_ppc64_reloc_type r_type;
8432 unsigned long r_symndx;
8434 struct elf_link_hash_entry *h;
8435 Elf_Internal_Sym *sym;
8438 r_type = ELF64_R_TYPE (rel->r_info);
8445 case R_PPC64_TOC16_LO:
8446 case R_PPC64_TOC16_HI:
8447 case R_PPC64_TOC16_HA:
8448 case R_PPC64_TOC16_DS:
8449 case R_PPC64_TOC16_LO_DS:
8453 r_symndx = ELF64_R_SYM (rel->r_info);
8454 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8462 val = h->root.u.def.value;
8464 val = sym->st_value;
8465 val += rel->r_addend;
8467 if (val >= toc->size)
8470 /* Anything in the toc ought to be aligned to 8 bytes.
8471 If not, don't mark as unused. */
8477 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8482 skip[val >> 3] = ref_from_discarded;
8485 if (elf_section_data (sec)->relocs != relstart)
8489 /* For largetoc loads of address constants, we can convert
8490 . addis rx,2,addr@got@ha
8491 . ld ry,addr@got@l(rx)
8493 . addis rx,2,addr@toc@ha
8494 . addi ry,rx,addr@toc@l
8495 when addr is within 2G of the toc pointer. This then means
8496 that the word storing "addr" in the toc is no longer needed. */
8498 if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8499 && toc->output_section->rawsize < (bfd_vma) 1 << 31
8500 && toc->reloc_count != 0)
8502 /* Read toc relocs. */
8503 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8505 if (toc_relocs == NULL)
8508 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8510 enum elf_ppc64_reloc_type r_type;
8511 unsigned long r_symndx;
8513 struct elf_link_hash_entry *h;
8514 Elf_Internal_Sym *sym;
8517 r_type = ELF64_R_TYPE (rel->r_info);
8518 if (r_type != R_PPC64_ADDR64)
8521 r_symndx = ELF64_R_SYM (rel->r_info);
8522 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8527 || sym_sec->output_section == NULL
8528 || discarded_section (sym_sec))
8531 if (!SYMBOL_REFERENCES_LOCAL (info, h))
8536 if (h->type == STT_GNU_IFUNC)
8538 val = h->root.u.def.value;
8542 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8544 val = sym->st_value;
8546 val += rel->r_addend;
8547 val += sym_sec->output_section->vma + sym_sec->output_offset;
8549 /* We don't yet know the exact toc pointer value, but we
8550 know it will be somewhere in the toc section. Don't
8551 optimize if the difference from any possible toc
8552 pointer is outside [ff..f80008000, 7fff7fff]. */
8553 addr = toc->output_section->vma + TOC_BASE_OFF;
8554 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8557 addr = toc->output_section->vma + toc->output_section->rawsize;
8558 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8563 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8568 skip[rel->r_offset >> 3]
8569 |= can_optimize | ((rel - toc_relocs) << 2);
8576 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8580 if (local_syms != NULL
8581 && symtab_hdr->contents != (unsigned char *) local_syms)
8585 && elf_section_data (sec)->relocs != relstart)
8587 if (toc_relocs != NULL
8588 && elf_section_data (toc)->relocs != toc_relocs)
8595 /* Now check all kept sections that might reference the toc.
8596 Check the toc itself last. */
8597 for (sec = (ibfd->sections == toc && toc->next ? toc->next
8600 sec = (sec == toc ? NULL
8601 : sec->next == NULL ? toc
8602 : sec->next == toc && toc->next ? toc->next
8607 if (sec->reloc_count == 0
8608 || discarded_section (sec)
8609 || get_opd_info (sec)
8610 || (sec->flags & SEC_ALLOC) == 0
8611 || (sec->flags & SEC_DEBUGGING) != 0)
8614 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8616 if (relstart == NULL)
8622 /* Mark toc entries referenced as used. */
8626 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8628 enum elf_ppc64_reloc_type r_type;
8629 unsigned long r_symndx;
8631 struct elf_link_hash_entry *h;
8632 Elf_Internal_Sym *sym;
8635 r_type = ELF64_R_TYPE (rel->r_info);
8639 case R_PPC64_TOC16_LO:
8640 case R_PPC64_TOC16_HI:
8641 case R_PPC64_TOC16_HA:
8642 case R_PPC64_TOC16_DS:
8643 case R_PPC64_TOC16_LO_DS:
8644 /* In case we're taking addresses of toc entries. */
8645 case R_PPC64_ADDR64:
8652 r_symndx = ELF64_R_SYM (rel->r_info);
8653 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8664 val = h->root.u.def.value;
8666 val = sym->st_value;
8667 val += rel->r_addend;
8669 if (val >= toc->size)
8672 if ((skip[val >> 3] & can_optimize) != 0)
8679 case R_PPC64_TOC16_HA:
8682 case R_PPC64_TOC16_LO_DS:
8683 off = rel->r_offset;
8684 off += (bfd_big_endian (ibfd) ? -2 : 3);
8685 if (!bfd_get_section_contents (ibfd, sec, &opc,
8691 if ((opc & (0x3f << 2)) == (58u << 2))
8696 /* Wrong sort of reloc, or not a ld. We may
8697 as well clear ref_from_discarded too. */
8704 /* For the toc section, we only mark as used if this
8705 entry itself isn't unused. */
8706 else if ((used[rel->r_offset >> 3]
8707 || !(skip[rel->r_offset >> 3] & ref_from_discarded))
8710 /* Do all the relocs again, to catch reference
8719 if (elf_section_data (sec)->relocs != relstart)
8723 /* Merge the used and skip arrays. Assume that TOC
8724 doublewords not appearing as either used or unused belong
8725 to an entry more than one doubleword in size. */
8726 for (drop = skip, keep = used, last = 0, some_unused = 0;
8727 drop < skip + (toc->size + 7) / 8;
8732 *drop &= ~ref_from_discarded;
8733 if ((*drop & can_optimize) != 0)
8737 else if ((*drop & ref_from_discarded) != 0)
8740 last = ref_from_discarded;
8750 bfd_byte *contents, *src;
8752 Elf_Internal_Sym *sym;
8753 bfd_boolean local_toc_syms = FALSE;
8755 /* Shuffle the toc contents, and at the same time convert the
8756 skip array from booleans into offsets. */
8757 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
8760 elf_section_data (toc)->this_hdr.contents = contents;
8762 for (src = contents, off = 0, drop = skip;
8763 src < contents + toc->size;
8766 if ((*drop & (can_optimize | ref_from_discarded)) != 0)
8771 memcpy (src - off, src, 8);
8775 toc->rawsize = toc->size;
8776 toc->size = src - contents - off;
8778 /* Adjust addends for relocs against the toc section sym,
8779 and optimize any accesses we can. */
8780 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8782 if (sec->reloc_count == 0
8783 || discarded_section (sec))
8786 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8788 if (relstart == NULL)
8791 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8793 enum elf_ppc64_reloc_type r_type;
8794 unsigned long r_symndx;
8796 struct elf_link_hash_entry *h;
8799 r_type = ELF64_R_TYPE (rel->r_info);
8806 case R_PPC64_TOC16_LO:
8807 case R_PPC64_TOC16_HI:
8808 case R_PPC64_TOC16_HA:
8809 case R_PPC64_TOC16_DS:
8810 case R_PPC64_TOC16_LO_DS:
8811 case R_PPC64_ADDR64:
8815 r_symndx = ELF64_R_SYM (rel->r_info);
8816 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8824 val = h->root.u.def.value;
8827 val = sym->st_value;
8829 local_toc_syms = TRUE;
8832 val += rel->r_addend;
8834 if (val > toc->rawsize)
8836 else if ((skip[val >> 3] & ref_from_discarded) != 0)
8838 else if ((skip[val >> 3] & can_optimize) != 0)
8840 Elf_Internal_Rela *tocrel
8841 = toc_relocs + (skip[val >> 3] >> 2);
8842 unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
8846 case R_PPC64_TOC16_HA:
8847 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
8850 case R_PPC64_TOC16_LO_DS:
8851 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
8855 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
8857 info->callbacks->einfo
8858 /* xgettext:c-format */
8859 (_("%H: %s references "
8860 "optimized away TOC entry\n"),
8861 ibfd, sec, rel->r_offset,
8862 ppc64_elf_howto_table[r_type]->name);
8863 bfd_set_error (bfd_error_bad_value);
8866 rel->r_addend = tocrel->r_addend;
8867 elf_section_data (sec)->relocs = relstart;
8871 if (h != NULL || sym->st_value != 0)
8874 rel->r_addend -= skip[val >> 3];
8875 elf_section_data (sec)->relocs = relstart;
8878 if (elf_section_data (sec)->relocs != relstart)
8882 /* We shouldn't have local or global symbols defined in the TOC,
8883 but handle them anyway. */
8884 if (local_syms != NULL)
8885 for (sym = local_syms;
8886 sym < local_syms + symtab_hdr->sh_info;
8888 if (sym->st_value != 0
8889 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
8893 if (sym->st_value > toc->rawsize)
8894 i = toc->rawsize >> 3;
8896 i = sym->st_value >> 3;
8898 if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
8902 (_("%s defined on removed toc entry"),
8903 bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
8906 while ((skip[i] & (ref_from_discarded | can_optimize)));
8907 sym->st_value = (bfd_vma) i << 3;
8910 sym->st_value -= skip[i];
8911 symtab_hdr->contents = (unsigned char *) local_syms;
8914 /* Adjust any global syms defined in this toc input section. */
8915 if (toc_inf.global_toc_syms)
8918 toc_inf.skip = skip;
8919 toc_inf.global_toc_syms = FALSE;
8920 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
8924 if (toc->reloc_count != 0)
8926 Elf_Internal_Shdr *rel_hdr;
8927 Elf_Internal_Rela *wrel;
8930 /* Remove unused toc relocs, and adjust those we keep. */
8931 if (toc_relocs == NULL)
8932 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8934 if (toc_relocs == NULL)
8938 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8939 if ((skip[rel->r_offset >> 3]
8940 & (ref_from_discarded | can_optimize)) == 0)
8942 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
8943 wrel->r_info = rel->r_info;
8944 wrel->r_addend = rel->r_addend;
8947 else if (!dec_dynrel_count (rel->r_info, toc, info,
8948 &local_syms, NULL, NULL))
8951 elf_section_data (toc)->relocs = toc_relocs;
8952 toc->reloc_count = wrel - toc_relocs;
8953 rel_hdr = _bfd_elf_single_rel_hdr (toc);
8954 sz = rel_hdr->sh_entsize;
8955 rel_hdr->sh_size = toc->reloc_count * sz;
8958 else if (toc_relocs != NULL
8959 && elf_section_data (toc)->relocs != toc_relocs)
8962 if (local_syms != NULL
8963 && symtab_hdr->contents != (unsigned char *) local_syms)
8965 if (!info->keep_memory)
8968 symtab_hdr->contents = (unsigned char *) local_syms;
8973 /* Look for cases where we can change an indirect GOT access to
8974 a GOT relative or PC relative access, possibly reducing the
8975 number of GOT entries. */
8976 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8979 Elf_Internal_Shdr *symtab_hdr;
8980 Elf_Internal_Sym *local_syms;
8981 Elf_Internal_Rela *relstart, *rel;
8984 if (!is_ppc64_elf (ibfd))
8987 if (!ppc64_elf_tdata (ibfd)->has_optrel)
8990 sec = ppc64_elf_tdata (ibfd)->got;
8993 got = sec->output_section->vma + sec->output_offset + 0x8000;
8996 symtab_hdr = &elf_symtab_hdr (ibfd);
8998 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9000 if (sec->reloc_count == 0
9001 || !ppc64_elf_section_data (sec)->has_optrel
9002 || discarded_section (sec))
9005 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9007 if (relstart == NULL)
9010 if (local_syms != NULL
9011 && symtab_hdr->contents != (unsigned char *) local_syms)
9015 && elf_section_data (sec)->relocs != relstart)
9020 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9022 enum elf_ppc64_reloc_type r_type;
9023 unsigned long r_symndx;
9024 Elf_Internal_Sym *sym;
9026 struct elf_link_hash_entry *h;
9027 struct got_entry *ent;
9028 bfd_vma sym_addend, val, pc;
9029 unsigned char buf[8];
9031 enum {no_check, check_lo, check_ha} insn_check;
9033 r_type = ELF64_R_TYPE (rel->r_info);
9037 insn_check = no_check;
9040 case R_PPC64_PLT16_HA:
9041 case R_PPC64_GOT_TLSLD16_HA:
9042 case R_PPC64_GOT_TLSGD16_HA:
9043 case R_PPC64_GOT_TPREL16_HA:
9044 case R_PPC64_GOT_DTPREL16_HA:
9045 case R_PPC64_GOT16_HA:
9046 case R_PPC64_TOC16_HA:
9047 insn_check = check_ha;
9050 case R_PPC64_PLT16_LO:
9051 case R_PPC64_PLT16_LO_DS:
9052 case R_PPC64_GOT_TLSLD16_LO:
9053 case R_PPC64_GOT_TLSGD16_LO:
9054 case R_PPC64_GOT_TPREL16_LO_DS:
9055 case R_PPC64_GOT_DTPREL16_LO_DS:
9056 case R_PPC64_GOT16_LO:
9057 case R_PPC64_GOT16_LO_DS:
9058 case R_PPC64_TOC16_LO:
9059 case R_PPC64_TOC16_LO_DS:
9060 insn_check = check_lo;
9064 if (insn_check != no_check)
9066 bfd_vma off = rel->r_offset & ~3;
9068 if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9071 insn = bfd_get_32 (ibfd, buf);
9072 if (insn_check == check_lo
9073 ? !ok_lo_toc_insn (insn, r_type)
9074 : ((insn & ((0x3f << 26) | 0x1f << 16))
9075 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9079 ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9080 sprintf (str, "%#08x", insn);
9081 info->callbacks->einfo
9082 /* xgettext:c-format */
9083 (_("%H: got/toc optimization is not supported for"
9084 " %s instruction\n"),
9085 ibfd, sec, rel->r_offset & ~3, str);
9092 /* Note that we don't delete GOT entries for
9093 R_PPC64_GOT16_DS since we'd need a lot more
9094 analysis. For starters, the preliminary layout is
9095 before the GOT, PLT, dynamic sections and stubs are
9096 laid out. Then we'd need to allow for changes in
9097 distance between sections caused by alignment. */
9101 case R_PPC64_GOT16_HA:
9102 case R_PPC64_GOT16_LO_DS:
9103 sym_addend = rel->r_addend;
9106 case R_PPC64_GOT_PCREL34:
9111 r_symndx = ELF64_R_SYM (rel->r_info);
9112 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9117 || sym_sec->output_section == NULL
9118 || discarded_section (sym_sec))
9121 if (!SYMBOL_REFERENCES_LOCAL (info, h))
9125 val = h->root.u.def.value;
9127 val = sym->st_value;
9129 val += sym_sec->output_section->vma + sym_sec->output_offset;
9131 /* Fudge factor to allow for the fact that the preliminary layout
9132 isn't exact. Reduce limits by this factor. */
9133 #define LIMIT_ADJUST(LIMIT) ((LIMIT) - (LIMIT) / 16)
9140 case R_PPC64_GOT16_HA:
9141 if (val - got + LIMIT_ADJUST (0x80008000ULL)
9142 >= LIMIT_ADJUST (0x100000000ULL))
9145 if (!bfd_get_section_contents (ibfd, sec, buf,
9146 rel->r_offset & ~3, 4))
9148 insn = bfd_get_32 (ibfd, buf);
9149 if (((insn & ((0x3f << 26) | 0x1f << 16))
9150 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9154 case R_PPC64_GOT16_LO_DS:
9155 if (val - got + LIMIT_ADJUST (0x80008000ULL)
9156 >= LIMIT_ADJUST (0x100000000ULL))
9158 if (!bfd_get_section_contents (ibfd, sec, buf,
9159 rel->r_offset & ~3, 4))
9161 insn = bfd_get_32 (ibfd, buf);
9162 if ((insn & (0x3f << 26 | 0x3)) != 58u << 26 /* ld */)
9166 case R_PPC64_GOT_PCREL34:
9168 pc += sec->output_section->vma + sec->output_offset;
9169 if (val - pc + LIMIT_ADJUST (1ULL << 33)
9170 >= LIMIT_ADJUST (1ULL << 34))
9172 if (!bfd_get_section_contents (ibfd, sec, buf,
9173 rel->r_offset & ~3, 8))
9175 insn = bfd_get_32 (ibfd, buf);
9176 if ((insn & (-1u << 18)) != ((1u << 26) | (1u << 20)))
9178 insn = bfd_get_32 (ibfd, buf + 4);
9179 if ((insn & (0x3f << 26)) != 57u << 26)
9189 struct got_entry **local_got_ents = elf_local_got_ents (ibfd);
9190 ent = local_got_ents[r_symndx];
9192 for (; ent != NULL; ent = ent->next)
9193 if (ent->addend == sym_addend
9194 && ent->owner == ibfd
9195 && ent->tls_type == 0)
9197 BFD_ASSERT (ent && ent->got.refcount > 0);
9198 ent->got.refcount -= 1;
9201 if (elf_section_data (sec)->relocs != relstart)
9205 if (local_syms != NULL
9206 && symtab_hdr->contents != (unsigned char *) local_syms)
9208 if (!info->keep_memory)
9211 symtab_hdr->contents = (unsigned char *) local_syms;
9218 /* Return true iff input section I references the TOC using
9219 instructions limited to +/-32k offsets. */
9222 ppc64_elf_has_small_toc_reloc (asection *i)
9224 return (is_ppc64_elf (i->owner)
9225 && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9228 /* Allocate space for one GOT entry. */
9231 allocate_got (struct elf_link_hash_entry *h,
9232 struct bfd_link_info *info,
9233 struct got_entry *gent)
9235 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9236 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9237 int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9239 int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9240 ? 2 : 1) * sizeof (Elf64_External_Rela);
9241 asection *got = ppc64_elf_tdata (gent->owner)->got;
9243 gent->got.offset = got->size;
9244 got->size += entsize;
9246 if (h->type == STT_GNU_IFUNC)
9248 htab->elf.irelplt->size += rentsize;
9249 htab->got_reli_size += rentsize;
9251 else if (((bfd_link_pic (info)
9252 && !((gent->tls_type & TLS_TPREL) != 0
9253 && bfd_link_executable (info)
9254 && SYMBOL_REFERENCES_LOCAL (info, h)))
9255 || (htab->elf.dynamic_sections_created
9257 && !SYMBOL_REFERENCES_LOCAL (info, h)))
9258 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9260 asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9261 relgot->size += rentsize;
9265 /* This function merges got entries in the same toc group. */
9268 merge_got_entries (struct got_entry **pent)
9270 struct got_entry *ent, *ent2;
9272 for (ent = *pent; ent != NULL; ent = ent->next)
9273 if (!ent->is_indirect)
9274 for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9275 if (!ent2->is_indirect
9276 && ent2->addend == ent->addend
9277 && ent2->tls_type == ent->tls_type
9278 && elf_gp (ent2->owner) == elf_gp (ent->owner))
9280 ent2->is_indirect = TRUE;
9281 ent2->got.ent = ent;
9285 /* If H is undefined, make it dynamic if that makes sense. */
9288 ensure_undef_dynamic (struct bfd_link_info *info,
9289 struct elf_link_hash_entry *h)
9291 struct elf_link_hash_table *htab = elf_hash_table (info);
9293 if (htab->dynamic_sections_created
9294 && ((info->dynamic_undefined_weak != 0
9295 && h->root.type == bfd_link_hash_undefweak)
9296 || h->root.type == bfd_link_hash_undefined)
9299 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
9300 return bfd_elf_link_record_dynamic_symbol (info, h);
9304 /* Allocate space in .plt, .got and associated reloc sections for
9308 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9310 struct bfd_link_info *info;
9311 struct ppc_link_hash_table *htab;
9313 struct ppc_link_hash_entry *eh;
9314 struct got_entry **pgent, *gent;
9316 if (h->root.type == bfd_link_hash_indirect)
9319 info = (struct bfd_link_info *) inf;
9320 htab = ppc_hash_table (info);
9324 eh = (struct ppc_link_hash_entry *) h;
9325 /* Run through the TLS GD got entries first if we're changing them
9327 if ((eh->tls_mask & (TLS_TLS | TLS_GDIE)) == (TLS_TLS | TLS_GDIE))
9328 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9329 if (gent->got.refcount > 0
9330 && (gent->tls_type & TLS_GD) != 0)
9332 /* This was a GD entry that has been converted to TPREL. If
9333 there happens to be a TPREL entry we can use that one. */
9334 struct got_entry *ent;
9335 for (ent = h->got.glist; ent != NULL; ent = ent->next)
9336 if (ent->got.refcount > 0
9337 && (ent->tls_type & TLS_TPREL) != 0
9338 && ent->addend == gent->addend
9339 && ent->owner == gent->owner)
9341 gent->got.refcount = 0;
9345 /* If not, then we'll be using our own TPREL entry. */
9346 if (gent->got.refcount != 0)
9347 gent->tls_type = TLS_TLS | TLS_TPREL;
9350 /* Remove any list entry that won't generate a word in the GOT before
9351 we call merge_got_entries. Otherwise we risk merging to empty
9353 pgent = &h->got.glist;
9354 while ((gent = *pgent) != NULL)
9355 if (gent->got.refcount > 0)
9357 if ((gent->tls_type & TLS_LD) != 0
9360 ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9361 *pgent = gent->next;
9364 pgent = &gent->next;
9367 *pgent = gent->next;
9369 if (!htab->do_multi_toc)
9370 merge_got_entries (&h->got.glist);
9372 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9373 if (!gent->is_indirect)
9375 /* Make sure this symbol is output as a dynamic symbol. */
9376 if (!ensure_undef_dynamic (info, h))
9379 if (!is_ppc64_elf (gent->owner))
9382 allocate_got (h, info, gent);
9385 /* If no dynamic sections we can't have dynamic relocs, except for
9386 IFUNCs which are handled even in static executables. */
9387 if (!htab->elf.dynamic_sections_created
9388 && h->type != STT_GNU_IFUNC)
9389 eh->dyn_relocs = NULL;
9391 /* Discard relocs on undefined symbols that must be local. */
9392 else if (h->root.type == bfd_link_hash_undefined
9393 && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9394 eh->dyn_relocs = NULL;
9396 /* Also discard relocs on undefined weak syms with non-default
9397 visibility, or when dynamic_undefined_weak says so. */
9398 else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9399 eh->dyn_relocs = NULL;
9401 if (eh->dyn_relocs != NULL)
9403 struct elf_dyn_relocs *p, **pp;
9405 /* In the shared -Bsymbolic case, discard space allocated for
9406 dynamic pc-relative relocs against symbols which turn out to
9407 be defined in regular objects. For the normal shared case,
9408 discard space for relocs that have become local due to symbol
9409 visibility changes. */
9411 if (bfd_link_pic (info))
9413 /* Relocs that use pc_count are those that appear on a call
9414 insn, or certain REL relocs (see must_be_dyn_reloc) that
9415 can be generated via assembly. We want calls to
9416 protected symbols to resolve directly to the function
9417 rather than going via the plt. If people want function
9418 pointer comparisons to work as expected then they should
9419 avoid writing weird assembly. */
9420 if (SYMBOL_CALLS_LOCAL (info, h))
9422 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9424 p->count -= p->pc_count;
9433 if (eh->dyn_relocs != NULL)
9435 /* Make sure this symbol is output as a dynamic symbol. */
9436 if (!ensure_undef_dynamic (info, h))
9440 else if (ELIMINATE_COPY_RELOCS && h->type != STT_GNU_IFUNC)
9442 /* For the non-pic case, discard space for relocs against
9443 symbols which turn out to need copy relocs or are not
9445 if (h->dynamic_adjusted
9447 && !ELF_COMMON_DEF_P (h))
9449 /* Make sure this symbol is output as a dynamic symbol. */
9450 if (!ensure_undef_dynamic (info, h))
9453 if (h->dynindx == -1)
9454 eh->dyn_relocs = NULL;
9457 eh->dyn_relocs = NULL;
9460 /* Finally, allocate space. */
9461 for (p = eh->dyn_relocs; p != NULL; p = p->next)
9463 asection *sreloc = elf_section_data (p->sec)->sreloc;
9464 if (eh->elf.type == STT_GNU_IFUNC)
9465 sreloc = htab->elf.irelplt;
9466 sreloc->size += p->count * sizeof (Elf64_External_Rela);
9470 /* We might need a PLT entry when the symbol
9473 c) has plt16 relocs and has been processed by adjust_dynamic_symbol, or
9474 d) has plt16 relocs and we are linking statically. */
9475 if ((htab->elf.dynamic_sections_created && h->dynindx != -1)
9476 || h->type == STT_GNU_IFUNC
9477 || (h->needs_plt && h->dynamic_adjusted)
9480 && !htab->elf.dynamic_sections_created
9481 && !htab->can_convert_all_inline_plt
9482 && (((struct ppc_link_hash_entry *) h)->tls_mask
9483 & (TLS_TLS | PLT_KEEP)) == PLT_KEEP))
9485 struct plt_entry *pent;
9486 bfd_boolean doneone = FALSE;
9487 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9488 if (pent->plt.refcount > 0)
9490 if (!htab->elf.dynamic_sections_created
9491 || h->dynindx == -1)
9493 if (h->type == STT_GNU_IFUNC)
9496 pent->plt.offset = s->size;
9497 s->size += PLT_ENTRY_SIZE (htab);
9498 s = htab->elf.irelplt;
9503 pent->plt.offset = s->size;
9504 s->size += LOCAL_PLT_ENTRY_SIZE (htab);
9505 s = bfd_link_pic (info) ? htab->relpltlocal : NULL;
9510 /* If this is the first .plt entry, make room for the special
9514 s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9516 pent->plt.offset = s->size;
9518 /* Make room for this entry. */
9519 s->size += PLT_ENTRY_SIZE (htab);
9521 /* Make room for the .glink code. */
9524 s->size += GLINK_PLTRESOLVE_SIZE (htab);
9527 /* We need bigger stubs past index 32767. */
9528 if (s->size >= GLINK_PLTRESOLVE_SIZE (htab) + 32768*2*4)
9535 /* We also need to make an entry in the .rela.plt section. */
9536 s = htab->elf.srelplt;
9539 s->size += sizeof (Elf64_External_Rela);
9543 pent->plt.offset = (bfd_vma) -1;
9546 h->plt.plist = NULL;
9552 h->plt.plist = NULL;
9559 #define PPC_LO(v) ((v) & 0xffff)
9560 #define PPC_HI(v) (((v) >> 16) & 0xffff)
9561 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
9563 ((((v) & 0x3ffff0000ULL) << 16) | (v & 0xffff))
9564 #define HA34(v) ((v + (1ULL << 33)) >> 34)
9566 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9567 to set up space for global entry stubs. These are put in glink,
9568 after the branch table. */
9571 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9573 struct bfd_link_info *info;
9574 struct ppc_link_hash_table *htab;
9575 struct plt_entry *pent;
9578 if (h->root.type == bfd_link_hash_indirect)
9581 if (!h->pointer_equality_needed)
9588 htab = ppc_hash_table (info);
9592 s = htab->global_entry;
9593 plt = htab->elf.splt;
9594 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9595 if (pent->plt.offset != (bfd_vma) -1
9596 && pent->addend == 0)
9598 /* For ELFv2, if this symbol is not defined in a regular file
9599 and we are not generating a shared library or pie, then we
9600 need to define the symbol in the executable on a call stub.
9601 This is to avoid text relocations. */
9602 bfd_vma off, stub_align, stub_off, stub_size;
9603 unsigned int align_power;
9607 if (htab->params->plt_stub_align >= 0)
9608 align_power = htab->params->plt_stub_align;
9610 align_power = -htab->params->plt_stub_align;
9611 /* Setting section alignment is delayed until we know it is
9612 non-empty. Otherwise the .text output section will be
9613 aligned at least to plt_stub_align even when no global
9614 entry stubs are needed. */
9615 if (s->alignment_power < align_power)
9616 s->alignment_power = align_power;
9617 stub_align = (bfd_vma) 1 << align_power;
9618 if (htab->params->plt_stub_align >= 0
9619 || ((((stub_off + stub_size - 1) & -stub_align)
9620 - (stub_off & -stub_align))
9621 > ((stub_size - 1) & -stub_align)))
9622 stub_off = (stub_off + stub_align - 1) & -stub_align;
9623 off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
9624 off -= stub_off + s->output_offset + s->output_section->vma;
9625 /* Note that for --plt-stub-align negative we have a possible
9626 dependency between stub offset and size. Break that
9627 dependency by assuming the max stub size when calculating
9629 if (PPC_HA (off) == 0)
9631 h->root.type = bfd_link_hash_defined;
9632 h->root.u.def.section = s;
9633 h->root.u.def.value = stub_off;
9634 s->size = stub_off + stub_size;
9640 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9641 read-only sections. */
9644 maybe_set_textrel (struct elf_link_hash_entry *h, void *inf)
9648 if (h->root.type == bfd_link_hash_indirect)
9651 sec = readonly_dynrelocs (h);
9654 struct bfd_link_info *info = (struct bfd_link_info *) inf;
9656 info->flags |= DF_TEXTREL;
9657 info->callbacks->minfo (_("%pB: dynamic relocation against `%pT'"
9658 " in read-only section `%pA'\n"),
9659 sec->owner, h->root.root.string, sec);
9661 /* Not an error, just cut short the traversal. */
9667 /* Set the sizes of the dynamic sections. */
9670 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9671 struct bfd_link_info *info)
9673 struct ppc_link_hash_table *htab;
9678 struct got_entry *first_tlsld;
9680 htab = ppc_hash_table (info);
9684 dynobj = htab->elf.dynobj;
9688 if (htab->elf.dynamic_sections_created)
9690 /* Set the contents of the .interp section to the interpreter. */
9691 if (bfd_link_executable (info) && !info->nointerp)
9693 s = bfd_get_linker_section (dynobj, ".interp");
9696 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9697 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9701 /* Set up .got offsets for local syms, and space for local dynamic
9703 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9705 struct got_entry **lgot_ents;
9706 struct got_entry **end_lgot_ents;
9707 struct plt_entry **local_plt;
9708 struct plt_entry **end_local_plt;
9709 unsigned char *lgot_masks;
9710 bfd_size_type locsymcount;
9711 Elf_Internal_Shdr *symtab_hdr;
9713 if (!is_ppc64_elf (ibfd))
9716 for (s = ibfd->sections; s != NULL; s = s->next)
9718 struct ppc_dyn_relocs *p;
9720 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9722 if (!bfd_is_abs_section (p->sec)
9723 && bfd_is_abs_section (p->sec->output_section))
9725 /* Input section has been discarded, either because
9726 it is a copy of a linkonce section or due to
9727 linker script /DISCARD/, so we'll be discarding
9730 else if (p->count != 0)
9732 asection *srel = elf_section_data (p->sec)->sreloc;
9734 srel = htab->elf.irelplt;
9735 srel->size += p->count * sizeof (Elf64_External_Rela);
9736 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9737 info->flags |= DF_TEXTREL;
9742 lgot_ents = elf_local_got_ents (ibfd);
9746 symtab_hdr = &elf_symtab_hdr (ibfd);
9747 locsymcount = symtab_hdr->sh_info;
9748 end_lgot_ents = lgot_ents + locsymcount;
9749 local_plt = (struct plt_entry **) end_lgot_ents;
9750 end_local_plt = local_plt + locsymcount;
9751 lgot_masks = (unsigned char *) end_local_plt;
9752 s = ppc64_elf_tdata (ibfd)->got;
9753 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9755 struct got_entry **pent, *ent;
9758 while ((ent = *pent) != NULL)
9759 if (ent->got.refcount > 0)
9761 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9763 ppc64_tlsld_got (ibfd)->got.refcount += 1;
9768 unsigned int ent_size = 8;
9769 unsigned int rel_size = sizeof (Elf64_External_Rela);
9771 ent->got.offset = s->size;
9772 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9777 s->size += ent_size;
9778 if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
9780 htab->elf.irelplt->size += rel_size;
9781 htab->got_reli_size += rel_size;
9783 else if (bfd_link_pic (info)
9784 && !((ent->tls_type & TLS_TPREL) != 0
9785 && bfd_link_executable (info)))
9787 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9788 srel->size += rel_size;
9797 /* Allocate space for plt calls to local syms. */
9798 lgot_masks = (unsigned char *) end_local_plt;
9799 for (; local_plt < end_local_plt; ++local_plt, ++lgot_masks)
9801 struct plt_entry *ent;
9803 for (ent = *local_plt; ent != NULL; ent = ent->next)
9804 if (ent->plt.refcount > 0)
9806 if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
9809 ent->plt.offset = s->size;
9810 s->size += PLT_ENTRY_SIZE (htab);
9811 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
9813 else if (htab->can_convert_all_inline_plt
9814 || (*lgot_masks & (TLS_TLS | PLT_KEEP)) != PLT_KEEP)
9815 ent->plt.offset = (bfd_vma) -1;
9819 ent->plt.offset = s->size;
9820 s->size += LOCAL_PLT_ENTRY_SIZE (htab);
9821 if (bfd_link_pic (info))
9822 htab->relpltlocal->size += sizeof (Elf64_External_Rela);
9826 ent->plt.offset = (bfd_vma) -1;
9830 /* Allocate global sym .plt and .got entries, and space for global
9831 sym dynamic relocs. */
9832 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9834 if (!htab->opd_abi && !bfd_link_pic (info))
9835 elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
9838 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9840 struct got_entry *ent;
9842 if (!is_ppc64_elf (ibfd))
9845 ent = ppc64_tlsld_got (ibfd);
9846 if (ent->got.refcount > 0)
9848 if (!htab->do_multi_toc && first_tlsld != NULL)
9850 ent->is_indirect = TRUE;
9851 ent->got.ent = first_tlsld;
9855 if (first_tlsld == NULL)
9857 s = ppc64_elf_tdata (ibfd)->got;
9858 ent->got.offset = s->size;
9861 if (bfd_link_pic (info))
9863 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9864 srel->size += sizeof (Elf64_External_Rela);
9869 ent->got.offset = (bfd_vma) -1;
9872 /* We now have determined the sizes of the various dynamic sections.
9873 Allocate memory for them. */
9875 for (s = dynobj->sections; s != NULL; s = s->next)
9877 if ((s->flags & SEC_LINKER_CREATED) == 0)
9880 if (s == htab->brlt || s == htab->relbrlt)
9881 /* These haven't been allocated yet; don't strip. */
9883 else if (s == htab->elf.sgot
9884 || s == htab->elf.splt
9885 || s == htab->elf.iplt
9886 || s == htab->pltlocal
9888 || s == htab->global_entry
9889 || s == htab->elf.sdynbss
9890 || s == htab->elf.sdynrelro)
9892 /* Strip this section if we don't need it; see the
9895 else if (s == htab->glink_eh_frame)
9897 if (!bfd_is_abs_section (s->output_section))
9898 /* Not sized yet. */
9901 else if (CONST_STRNEQ (s->name, ".rela"))
9905 if (s != htab->elf.srelplt)
9908 /* We use the reloc_count field as a counter if we need
9909 to copy relocs into the output file. */
9915 /* It's not one of our sections, so don't allocate space. */
9921 /* If we don't need this section, strip it from the
9922 output file. This is mostly to handle .rela.bss and
9923 .rela.plt. We must create both sections in
9924 create_dynamic_sections, because they must be created
9925 before the linker maps input sections to output
9926 sections. The linker does that before
9927 adjust_dynamic_symbol is called, and it is that
9928 function which decides whether anything needs to go
9929 into these sections. */
9930 s->flags |= SEC_EXCLUDE;
9934 if (bfd_is_abs_section (s->output_section))
9935 _bfd_error_handler (_("warning: discarding dynamic section %s"),
9938 if ((s->flags & SEC_HAS_CONTENTS) == 0)
9941 /* Allocate memory for the section contents. We use bfd_zalloc
9942 here in case unused entries are not reclaimed before the
9943 section's contents are written out. This should not happen,
9944 but this way if it does we get a R_PPC64_NONE reloc in .rela
9945 sections instead of garbage.
9946 We also rely on the section contents being zero when writing
9947 the GOT and .dynrelro. */
9948 s->contents = bfd_zalloc (dynobj, s->size);
9949 if (s->contents == NULL)
9953 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9955 if (!is_ppc64_elf (ibfd))
9958 s = ppc64_elf_tdata (ibfd)->got;
9959 if (s != NULL && s != htab->elf.sgot)
9962 s->flags |= SEC_EXCLUDE;
9965 s->contents = bfd_zalloc (ibfd, s->size);
9966 if (s->contents == NULL)
9970 s = ppc64_elf_tdata (ibfd)->relgot;
9974 s->flags |= SEC_EXCLUDE;
9977 s->contents = bfd_zalloc (ibfd, s->size);
9978 if (s->contents == NULL)
9986 if (htab->elf.dynamic_sections_created)
9988 bfd_boolean tls_opt;
9990 /* Add some entries to the .dynamic section. We fill in the
9991 values later, in ppc64_elf_finish_dynamic_sections, but we
9992 must add the entries now so that we get the correct size for
9993 the .dynamic section. The DT_DEBUG entry is filled in by the
9994 dynamic linker and used by the debugger. */
9995 #define add_dynamic_entry(TAG, VAL) \
9996 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9998 if (bfd_link_executable (info))
10000 if (!add_dynamic_entry (DT_DEBUG, 0))
10004 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10006 if (!add_dynamic_entry (DT_PLTGOT, 0)
10007 || !add_dynamic_entry (DT_PLTRELSZ, 0)
10008 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10009 || !add_dynamic_entry (DT_JMPREL, 0)
10010 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10014 if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10016 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10017 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10021 tls_opt = (htab->params->tls_get_addr_opt
10022 && htab->tls_get_addr_fd != NULL
10023 && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10024 if (tls_opt || !htab->opd_abi)
10026 if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10032 if (!add_dynamic_entry (DT_RELA, 0)
10033 || !add_dynamic_entry (DT_RELASZ, 0)
10034 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10037 /* If any dynamic relocs apply to a read-only section,
10038 then we need a DT_TEXTREL entry. */
10039 if ((info->flags & DF_TEXTREL) == 0)
10040 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10042 if ((info->flags & DF_TEXTREL) != 0)
10044 if (!add_dynamic_entry (DT_TEXTREL, 0))
10049 #undef add_dynamic_entry
10054 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
10057 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10059 if (h->plt.plist != NULL
10061 && !h->pointer_equality_needed)
10064 return _bfd_elf_hash_symbol (h);
10067 /* Determine the type of stub needed, if any, for a call. */
10069 static inline enum ppc_stub_type
10070 ppc_type_of_stub (asection *input_sec,
10071 const Elf_Internal_Rela *rel,
10072 struct ppc_link_hash_entry **hash,
10073 struct plt_entry **plt_ent,
10074 bfd_vma destination,
10075 unsigned long local_off)
10077 struct ppc_link_hash_entry *h = *hash;
10079 bfd_vma branch_offset;
10080 bfd_vma max_branch_offset;
10081 enum elf_ppc64_reloc_type r_type;
10085 struct plt_entry *ent;
10086 struct ppc_link_hash_entry *fdh = h;
10088 && h->oh->is_func_descriptor)
10090 fdh = ppc_follow_link (h->oh);
10094 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10095 if (ent->addend == rel->r_addend
10096 && ent->plt.offset != (bfd_vma) -1)
10099 return ppc_stub_plt_call;
10102 /* Here, we know we don't have a plt entry. If we don't have a
10103 either a defined function descriptor or a defined entry symbol
10104 in a regular object file, then it is pointless trying to make
10105 any other type of stub. */
10106 if (!is_static_defined (&fdh->elf)
10107 && !is_static_defined (&h->elf))
10108 return ppc_stub_none;
10110 else if (elf_local_got_ents (input_sec->owner) != NULL)
10112 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10113 struct plt_entry **local_plt = (struct plt_entry **)
10114 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10115 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10117 if (local_plt[r_symndx] != NULL)
10119 struct plt_entry *ent;
10121 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10122 if (ent->addend == rel->r_addend
10123 && ent->plt.offset != (bfd_vma) -1)
10126 return ppc_stub_plt_call;
10131 /* Determine where the call point is. */
10132 location = (input_sec->output_offset
10133 + input_sec->output_section->vma
10136 branch_offset = destination - location;
10137 r_type = ELF64_R_TYPE (rel->r_info);
10139 /* Determine if a long branch stub is needed. */
10140 max_branch_offset = 1 << 25;
10141 if (r_type == R_PPC64_REL14
10142 || r_type == R_PPC64_REL14_BRTAKEN
10143 || r_type == R_PPC64_REL14_BRNTAKEN)
10144 max_branch_offset = 1 << 15;
10146 if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10147 /* We need a stub. Figure out whether a long_branch or plt_branch
10148 is needed later. */
10149 return ppc_stub_long_branch;
10151 return ppc_stub_none;
10154 /* Gets the address of a label (1:) in r11 and builds an offset in r12,
10155 then adds it to r11 (LOAD false) or loads r12 from r11+r12 (LOAD true).
10160 . lis %r12,xxx-1b@highest
10161 . ori %r12,%r12,xxx-1b@higher
10162 . sldi %r12,%r12,32
10163 . oris %r12,%r12,xxx-1b@high
10164 . ori %r12,%r12,xxx-1b@l
10165 . add/ldx %r12,%r11,%r12 */
10168 build_offset (bfd *abfd, bfd_byte *p, bfd_vma off, bfd_boolean load)
10170 bfd_put_32 (abfd, MFLR_R12, p);
10172 bfd_put_32 (abfd, BCL_20_31, p);
10174 bfd_put_32 (abfd, MFLR_R11, p);
10176 bfd_put_32 (abfd, MTLR_R12, p);
10178 if (off + 0x8000 < 0x10000)
10181 bfd_put_32 (abfd, LD_R12_0R11 + PPC_LO (off), p);
10183 bfd_put_32 (abfd, ADDI_R12_R11 + PPC_LO (off), p);
10186 else if (off + 0x80008000ULL < 0x100000000ULL)
10188 bfd_put_32 (abfd, ADDIS_R12_R11 + PPC_HA (off), p);
10191 bfd_put_32 (abfd, LD_R12_0R12 + PPC_LO (off), p);
10193 bfd_put_32 (abfd, ADDI_R12_R12 + PPC_LO (off), p);
10198 if (off + 0x800000000000ULL < 0x1000000000000ULL)
10200 bfd_put_32 (abfd, LI_R12_0 + ((off >> 32) & 0xffff), p);
10205 bfd_put_32 (abfd, LIS_R12 + ((off >> 48) & 0xffff), p);
10207 if (((off >> 32) & 0xffff) != 0)
10209 bfd_put_32 (abfd, ORI_R12_R12_0 + ((off >> 32) & 0xffff), p);
10213 if (((off >> 32) & 0xffffffffULL) != 0)
10215 bfd_put_32 (abfd, SLDI_R12_R12_32, p);
10218 if (PPC_HI (off) != 0)
10220 bfd_put_32 (abfd, ORIS_R12_R12_0 + PPC_HI (off), p);
10223 if (PPC_LO (off) != 0)
10225 bfd_put_32 (abfd, ORI_R12_R12_0 + PPC_LO (off), p);
10229 bfd_put_32 (abfd, LDX_R12_R11_R12, p);
10231 bfd_put_32 (abfd, ADD_R12_R11_R12, p);
10237 static unsigned int
10238 size_offset (bfd_vma off)
10241 if (off + 0x8000 < 0x10000)
10243 else if (off + 0x80008000ULL < 0x100000000ULL)
10247 if (off + 0x800000000000ULL < 0x1000000000000ULL)
10252 if (((off >> 32) & 0xffff) != 0)
10255 if (((off >> 32) & 0xffffffffULL) != 0)
10257 if (PPC_HI (off) != 0)
10259 if (PPC_LO (off) != 0)
10266 static unsigned int
10267 num_relocs_for_offset (bfd_vma off)
10269 unsigned int num_rel;
10270 if (off + 0x8000 < 0x10000)
10272 else if (off + 0x80008000ULL < 0x100000000ULL)
10277 if (off + 0x800000000000ULL >= 0x1000000000000ULL
10278 && ((off >> 32) & 0xffff) != 0)
10280 if (PPC_HI (off) != 0)
10282 if (PPC_LO (off) != 0)
10288 static Elf_Internal_Rela *
10289 emit_relocs_for_offset (struct bfd_link_info *info, Elf_Internal_Rela *r,
10290 bfd_vma roff, bfd_vma targ, bfd_vma off)
10292 bfd_vma relative_targ = targ - (roff - 8);
10293 if (bfd_big_endian (info->output_bfd))
10295 r->r_offset = roff;
10296 r->r_addend = relative_targ + roff;
10297 if (off + 0x8000 < 0x10000)
10298 r->r_info = ELF64_R_INFO (0, R_PPC64_REL16);
10299 else if (off + 0x80008000ULL < 0x100000000ULL)
10301 r->r_info = ELF64_R_INFO (0, R_PPC64_REL16_HA);
10304 r->r_offset = roff;
10305 r->r_info = ELF64_R_INFO (0, R_PPC64_REL16_LO);
10306 r->r_addend = relative_targ + roff;
10310 if (off + 0x800000000000ULL < 0x1000000000000ULL)
10311 r->r_info = ELF64_R_INFO (0, R_PPC64_REL16_HIGHER);
10314 r->r_info = ELF64_R_INFO (0, R_PPC64_REL16_HIGHEST);
10315 if (((off >> 32) & 0xffff) != 0)
10319 r->r_offset = roff;
10320 r->r_info = ELF64_R_INFO (0, R_PPC64_REL16_HIGHER);
10321 r->r_addend = relative_targ + roff;
10324 if (((off >> 32) & 0xffffffffULL) != 0)
10326 if (PPC_HI (off) != 0)
10330 r->r_offset = roff;
10331 r->r_info = ELF64_R_INFO (0, R_PPC64_REL16_HIGH);
10332 r->r_addend = relative_targ + roff;
10334 if (PPC_LO (off) != 0)
10338 r->r_offset = roff;
10339 r->r_info = ELF64_R_INFO (0, R_PPC64_REL16_LO);
10340 r->r_addend = relative_targ + roff;
10347 build_powerxx_offset (bfd *abfd, bfd_byte *p, bfd_vma off, int odd,
10351 if (off - odd + (1ULL << 33) < 1ULL << 34)
10356 bfd_put_32 (abfd, NOP, p);
10362 insn = PADDI_R12_PC;
10364 bfd_put_32 (abfd, insn >> 32, p);
10366 bfd_put_32 (abfd, insn, p);
10368 /* The minimum value for paddi is -0x200000000. The minimum value
10369 for li is -0x8000, which when shifted by 34 and added gives a
10370 minimum value of -0x2000200000000. The maximum value is
10371 0x1ffffffff+0x7fff<<34 which is 0x2000200000000-1. */
10372 else if (off - (8 - odd) + (0x20002ULL << 32) < 0x40004ULL << 32)
10375 bfd_put_32 (abfd, LI_R11_0 | (HA34 (off) & 0xffff), p);
10379 bfd_put_32 (abfd, SLDI_R11_R11_34, p);
10382 insn = PADDI_R12_PC | D34 (off);
10383 bfd_put_32 (abfd, insn >> 32, p);
10385 bfd_put_32 (abfd, insn, p);
10389 bfd_put_32 (abfd, SLDI_R11_R11_34, p);
10393 bfd_put_32 (abfd, LDX_R12_R11_R12, p);
10395 bfd_put_32 (abfd, ADD_R12_R11_R12, p);
10400 bfd_put_32 (abfd, LIS_R11 | ((HA34 (off) >> 16) & 0x3fff), p);
10402 bfd_put_32 (abfd, ORI_R11_R11_0 | (HA34 (off) & 0xffff), p);
10406 bfd_put_32 (abfd, SLDI_R11_R11_34, p);
10409 insn = PADDI_R12_PC | D34 (off);
10410 bfd_put_32 (abfd, insn >> 32, p);
10412 bfd_put_32 (abfd, insn, p);
10416 bfd_put_32 (abfd, SLDI_R11_R11_34, p);
10420 bfd_put_32 (abfd, LDX_R12_R11_R12, p);
10422 bfd_put_32 (abfd, ADD_R12_R11_R12, p);
10428 static unsigned int
10429 size_powerxx_offset (bfd_vma off, int odd)
10431 if (off - odd + (1ULL << 33) < 1ULL << 34)
10433 else if (off - (8 - odd) + (0x20002ULL << 32) < 0x40004ULL << 32)
10439 static unsigned int
10440 num_relocs_for_powerxx_offset (bfd_vma off, int odd)
10442 if (off - odd + (1ULL << 33) < 1ULL << 34)
10444 else if (off - (8 - odd) + (0x20002ULL << 32) < 0x40004ULL << 32)
10450 static Elf_Internal_Rela *
10451 emit_relocs_for_powerxx_offset (struct bfd_link_info *info,
10452 Elf_Internal_Rela *r, bfd_vma roff,
10453 bfd_vma targ, bfd_vma off, int odd)
10455 if (off - odd + (1ULL << 33) < 1ULL << 34)
10457 else if (off - (8 - odd) + (0x20002ULL << 32) < 0x40004ULL << 32)
10459 int d_offset = bfd_big_endian (info->output_bfd) ? 2 : 0;
10460 r->r_offset = roff + d_offset;
10461 r->r_addend = targ + 8 - odd - d_offset;
10462 r->r_info = ELF64_R_INFO (0, R_PPC64_REL16_HIGHERA34);
10468 int d_offset = bfd_big_endian (info->output_bfd) ? 2 : 0;
10469 r->r_offset = roff + d_offset;
10470 r->r_addend = targ + 8 + odd - d_offset;
10471 r->r_info = ELF64_R_INFO (0, R_PPC64_REL16_HIGHESTA34);
10474 r->r_offset = roff + d_offset;
10475 r->r_addend = targ + 4 + odd - d_offset;
10476 r->r_info = ELF64_R_INFO (0, R_PPC64_REL16_HIGHERA34);
10480 r->r_offset = roff;
10481 r->r_addend = targ;
10482 r->r_info = ELF64_R_INFO (0, R_PPC64_PCREL34);
10486 /* Emit .eh_frame opcode to advance pc by DELTA. */
10489 eh_advance (bfd *abfd, bfd_byte *eh, unsigned int delta)
10493 *eh++ = DW_CFA_advance_loc + delta;
10494 else if (delta < 256)
10496 *eh++ = DW_CFA_advance_loc1;
10499 else if (delta < 65536)
10501 *eh++ = DW_CFA_advance_loc2;
10502 bfd_put_16 (abfd, delta, eh);
10507 *eh++ = DW_CFA_advance_loc4;
10508 bfd_put_32 (abfd, delta, eh);
10514 /* Size of required .eh_frame opcode to advance pc by DELTA. */
10516 static unsigned int
10517 eh_advance_size (unsigned int delta)
10519 if (delta < 64 * 4)
10520 /* DW_CFA_advance_loc+[1..63]. */
10522 if (delta < 256 * 4)
10523 /* DW_CFA_advance_loc1, byte. */
10525 if (delta < 65536 * 4)
10526 /* DW_CFA_advance_loc2, 2 bytes. */
10528 /* DW_CFA_advance_loc4, 4 bytes. */
10532 /* With power7 weakly ordered memory model, it is possible for ld.so
10533 to update a plt entry in one thread and have another thread see a
10534 stale zero toc entry. To avoid this we need some sort of acquire
10535 barrier in the call stub. One solution is to make the load of the
10536 toc word seem to appear to depend on the load of the function entry
10537 word. Another solution is to test for r2 being zero, and branch to
10538 the appropriate glink entry if so.
10540 . fake dep barrier compare
10541 . ld 12,xxx(2) ld 12,xxx(2)
10542 . mtctr 12 mtctr 12
10543 . xor 11,12,12 ld 2,xxx+8(2)
10544 . add 2,2,11 cmpldi 2,0
10545 . ld 2,xxx+8(2) bnectr+
10546 . bctr b <glink_entry>
10548 The solution involving the compare turns out to be faster, so
10549 that's what we use unless the branch won't reach. */
10551 #define ALWAYS_USE_FAKE_DEP 0
10552 #define ALWAYS_EMIT_R2SAVE 0
10554 static inline unsigned int
10555 plt_stub_size (struct ppc_link_hash_table *htab,
10556 struct ppc_stub_hash_entry *stub_entry,
10561 if (stub_entry->stub_type >= ppc_stub_plt_call_notoc)
10563 if (htab->powerxx_stubs)
10565 bfd_vma start = (stub_entry->stub_offset
10566 + stub_entry->group->stub_sec->output_offset
10567 + stub_entry->group->stub_sec->output_section->vma);
10568 if (stub_entry->stub_type > ppc_stub_plt_call_notoc)
10570 size = 8 + size_powerxx_offset (off, start & 4);
10573 size = 8 + size_offset (off - 8);
10574 if (stub_entry->stub_type > ppc_stub_plt_call_notoc)
10580 if (ALWAYS_EMIT_R2SAVE
10581 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10583 if (PPC_HA (off) != 0)
10588 if (htab->params->plt_static_chain)
10590 if (htab->params->plt_thread_safe
10591 && htab->elf.dynamic_sections_created
10592 && stub_entry->h != NULL
10593 && stub_entry->h->elf.dynindx != -1)
10595 if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10598 if (stub_entry->h != NULL
10599 && (stub_entry->h == htab->tls_get_addr_fd
10600 || stub_entry->h == htab->tls_get_addr)
10601 && htab->params->tls_get_addr_opt)
10604 if (stub_entry->stub_type == ppc_stub_plt_call_r2save)
10610 /* Depending on the sign of plt_stub_align:
10611 If positive, return the padding to align to a 2**plt_stub_align
10613 If negative, if this stub would cross fewer 2**plt_stub_align
10614 boundaries if we align, then return the padding needed to do so. */
10616 static inline unsigned int
10617 plt_stub_pad (struct ppc_link_hash_table *htab,
10618 struct ppc_stub_hash_entry *stub_entry,
10622 unsigned stub_size;
10623 bfd_vma stub_off = stub_entry->group->stub_sec->size;
10625 if (htab->params->plt_stub_align >= 0)
10627 stub_align = 1 << htab->params->plt_stub_align;
10628 if ((stub_off & (stub_align - 1)) != 0)
10629 return stub_align - (stub_off & (stub_align - 1));
10633 stub_align = 1 << -htab->params->plt_stub_align;
10634 stub_size = plt_stub_size (htab, stub_entry, plt_off);
10635 if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10636 > ((stub_size - 1) & -stub_align))
10637 return stub_align - (stub_off & (stub_align - 1));
10641 /* Build a .plt call stub. */
10643 static inline bfd_byte *
10644 build_plt_stub (struct ppc_link_hash_table *htab,
10645 struct ppc_stub_hash_entry *stub_entry,
10646 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10648 bfd *obfd = htab->params->stub_bfd;
10649 bfd_boolean plt_load_toc = htab->opd_abi;
10650 bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10651 bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10652 && htab->elf.dynamic_sections_created
10653 && stub_entry->h != NULL
10654 && stub_entry->h->elf.dynindx != -1);
10655 bfd_boolean use_fake_dep = plt_thread_safe;
10656 bfd_vma cmp_branch_off = 0;
10658 if (!ALWAYS_USE_FAKE_DEP
10661 && !((stub_entry->h == htab->tls_get_addr_fd
10662 || stub_entry->h == htab->tls_get_addr)
10663 && htab->params->tls_get_addr_opt))
10665 bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10666 bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10667 / PLT_ENTRY_SIZE (htab));
10668 bfd_vma glinkoff = GLINK_PLTRESOLVE_SIZE (htab) + pltindex * 8;
10671 if (pltindex > 32768)
10672 glinkoff += (pltindex - 32768) * 4;
10674 + htab->glink->output_offset
10675 + htab->glink->output_section->vma);
10676 from = (p - stub_entry->group->stub_sec->contents
10677 + 4 * (ALWAYS_EMIT_R2SAVE
10678 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10679 + 4 * (PPC_HA (offset) != 0)
10680 + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10681 != PPC_HA (offset))
10682 + 4 * (plt_static_chain != 0)
10684 + stub_entry->group->stub_sec->output_offset
10685 + stub_entry->group->stub_sec->output_section->vma);
10686 cmp_branch_off = to - from;
10687 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10690 if (PPC_HA (offset) != 0)
10694 if (ALWAYS_EMIT_R2SAVE
10695 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10696 r[0].r_offset += 4;
10697 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10698 r[1].r_offset = r[0].r_offset + 4;
10699 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10700 r[1].r_addend = r[0].r_addend;
10703 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10705 r[2].r_offset = r[1].r_offset + 4;
10706 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10707 r[2].r_addend = r[0].r_addend;
10711 r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10712 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10713 r[2].r_addend = r[0].r_addend + 8;
10714 if (plt_static_chain)
10716 r[3].r_offset = r[2].r_offset + 4;
10717 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10718 r[3].r_addend = r[0].r_addend + 16;
10723 if (ALWAYS_EMIT_R2SAVE
10724 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10725 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10728 bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10729 bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p), p += 4;
10733 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10734 bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p), p += 4;
10737 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10739 bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10742 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10747 bfd_put_32 (obfd, XOR_R2_R12_R12, p), p += 4;
10748 bfd_put_32 (obfd, ADD_R11_R11_R2, p), p += 4;
10750 bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10751 if (plt_static_chain)
10752 bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10759 if (ALWAYS_EMIT_R2SAVE
10760 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10761 r[0].r_offset += 4;
10762 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10765 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10767 r[1].r_offset = r[0].r_offset + 4;
10768 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10769 r[1].r_addend = r[0].r_addend;
10773 r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10774 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10775 r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10776 if (plt_static_chain)
10778 r[2].r_offset = r[1].r_offset + 4;
10779 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10780 r[2].r_addend = r[0].r_addend + 8;
10785 if (ALWAYS_EMIT_R2SAVE
10786 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10787 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10788 bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p), p += 4;
10790 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10792 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
10795 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10800 bfd_put_32 (obfd, XOR_R11_R12_R12, p), p += 4;
10801 bfd_put_32 (obfd, ADD_R2_R2_R11, p), p += 4;
10803 if (plt_static_chain)
10804 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10805 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10808 if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10810 bfd_put_32 (obfd, CMPLDI_R2_0, p), p += 4;
10811 bfd_put_32 (obfd, BNECTR_P4, p), p += 4;
10812 bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10815 bfd_put_32 (obfd, BCTR, p), p += 4;
10819 /* Build a special .plt call stub for __tls_get_addr. */
10821 #define LD_R11_0R3 0xe9630000
10822 #define LD_R12_0R3 0xe9830000
10823 #define MR_R0_R3 0x7c601b78
10824 #define CMPDI_R11_0 0x2c2b0000
10825 #define ADD_R3_R12_R13 0x7c6c6a14
10826 #define BEQLR 0x4d820020
10827 #define MR_R3_R0 0x7c030378
10828 #define STD_R11_0R1 0xf9610000
10829 #define BCTRL 0x4e800421
10830 #define LD_R11_0R1 0xe9610000
10831 #define MTLR_R11 0x7d6803a6
10833 static inline bfd_byte *
10834 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10835 struct ppc_stub_hash_entry *stub_entry,
10836 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10838 bfd *obfd = htab->params->stub_bfd;
10841 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4;
10842 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4;
10843 bfd_put_32 (obfd, MR_R0_R3, p), p += 4;
10844 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4;
10845 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4;
10846 bfd_put_32 (obfd, BEQLR, p), p += 4;
10847 bfd_put_32 (obfd, MR_R3_R0, p), p += 4;
10849 r[0].r_offset += 7 * 4;
10850 if (stub_entry->stub_type != ppc_stub_plt_call_r2save)
10851 return build_plt_stub (htab, stub_entry, p, offset, r);
10853 bfd_put_32 (obfd, MFLR_R11, p), p += 4;
10854 bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10857 r[0].r_offset += 2 * 4;
10858 p = build_plt_stub (htab, stub_entry, p, offset, r);
10859 bfd_put_32 (obfd, BCTRL, p - 4);
10861 bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p), p += 4;
10862 bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10863 bfd_put_32 (obfd, MTLR_R11, p), p += 4;
10864 bfd_put_32 (obfd, BLR, p), p += 4;
10866 if (htab->glink_eh_frame != NULL
10867 && htab->glink_eh_frame->size != 0)
10869 bfd_byte *base, *eh;
10870 unsigned int lr_used, delta;
10872 base = htab->glink_eh_frame->contents + stub_entry->group->eh_base + 17;
10873 eh = base + stub_entry->group->eh_size;
10874 lr_used = stub_entry->stub_offset + (p - 20 - loc);
10875 delta = lr_used - stub_entry->group->lr_restore;
10876 stub_entry->group->lr_restore = lr_used + 16;
10877 eh = eh_advance (htab->elf.dynobj, eh, delta);
10878 *eh++ = DW_CFA_offset_extended_sf;
10880 *eh++ = -(STK_LINKER (htab) / 8) & 0x7f;
10881 *eh++ = DW_CFA_advance_loc + 4;
10882 *eh++ = DW_CFA_restore_extended;
10884 stub_entry->group->eh_size = eh - base;
10889 static Elf_Internal_Rela *
10890 get_relocs (asection *sec, int count)
10892 Elf_Internal_Rela *relocs;
10893 struct bfd_elf_section_data *elfsec_data;
10895 elfsec_data = elf_section_data (sec);
10896 relocs = elfsec_data->relocs;
10897 if (relocs == NULL)
10899 bfd_size_type relsize;
10900 relsize = sec->reloc_count * sizeof (*relocs);
10901 relocs = bfd_alloc (sec->owner, relsize);
10902 if (relocs == NULL)
10904 elfsec_data->relocs = relocs;
10905 elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10906 sizeof (Elf_Internal_Shdr));
10907 if (elfsec_data->rela.hdr == NULL)
10909 elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10910 * sizeof (Elf64_External_Rela));
10911 elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10912 sec->reloc_count = 0;
10914 relocs += sec->reloc_count;
10915 sec->reloc_count += count;
10919 /* Convert the relocs R[0] thru R[-NUM_REL+1], which are all no-symbol
10920 forms, to the equivalent relocs against the global symbol given by
10924 use_global_in_relocs (struct ppc_link_hash_table *htab,
10925 struct ppc_stub_hash_entry *stub_entry,
10926 Elf_Internal_Rela *r, unsigned int num_rel)
10928 struct elf_link_hash_entry **hashes;
10929 unsigned long symndx;
10930 struct ppc_link_hash_entry *h;
10933 /* Relocs are always against symbols in their own object file. Fake
10934 up global sym hashes for the stub bfd (which has no symbols). */
10935 hashes = elf_sym_hashes (htab->params->stub_bfd);
10936 if (hashes == NULL)
10938 bfd_size_type hsize;
10940 /* When called the first time, stub_globals will contain the
10941 total number of symbols seen during stub sizing. After
10942 allocating, stub_globals is used as an index to fill the
10944 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10945 hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10946 if (hashes == NULL)
10948 elf_sym_hashes (htab->params->stub_bfd) = hashes;
10949 htab->stub_globals = 1;
10951 symndx = htab->stub_globals++;
10953 hashes[symndx] = &h->elf;
10954 if (h->oh != NULL && h->oh->is_func)
10955 h = ppc_follow_link (h->oh);
10956 BFD_ASSERT (h->elf.root.type == bfd_link_hash_defined
10957 || h->elf.root.type == bfd_link_hash_defweak);
10958 symval = (h->elf.root.u.def.value
10959 + h->elf.root.u.def.section->output_offset
10960 + h->elf.root.u.def.section->output_section->vma);
10961 while (num_rel-- != 0)
10963 r->r_info = ELF64_R_INFO (symndx, ELF64_R_TYPE (r->r_info));
10964 if (h->elf.root.u.def.section != stub_entry->target_section)
10966 /* H is an opd symbol. The addend must be zero, and the
10967 branch reloc is the only one we can convert. */
10972 r->r_addend -= symval;
10979 get_r2off (struct bfd_link_info *info,
10980 struct ppc_stub_hash_entry *stub_entry)
10982 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10983 bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10987 /* Support linking -R objects. Get the toc pointer from the
10990 if (!htab->opd_abi)
10992 asection *opd = stub_entry->h->elf.root.u.def.section;
10993 bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10995 if (strcmp (opd->name, ".opd") != 0
10996 || opd->reloc_count != 0)
10998 info->callbacks->einfo
10999 (_("%P: cannot find opd entry toc for `%pT'\n"),
11000 stub_entry->h->elf.root.root.string);
11001 bfd_set_error (bfd_error_bad_value);
11002 return (bfd_vma) -1;
11004 if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
11005 return (bfd_vma) -1;
11006 r2off = bfd_get_64 (opd->owner, buf);
11007 r2off -= elf_gp (info->output_bfd);
11009 r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
11014 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11016 struct ppc_stub_hash_entry *stub_entry;
11017 struct ppc_branch_hash_entry *br_entry;
11018 struct bfd_link_info *info;
11019 struct ppc_link_hash_table *htab;
11021 bfd_byte *p, *relp;
11023 Elf_Internal_Rela *r;
11028 /* Massage our args to the form they really have. */
11029 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11032 htab = ppc_hash_table (info);
11036 BFD_ASSERT (stub_entry->stub_offset >= stub_entry->group->stub_sec->size);
11037 loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
11039 htab->stub_count[stub_entry->stub_type - 1] += 1;
11040 switch (stub_entry->stub_type)
11042 case ppc_stub_long_branch:
11043 case ppc_stub_long_branch_r2off:
11044 /* Branches are relative. This is where we are going to. */
11045 targ = (stub_entry->target_value
11046 + stub_entry->target_section->output_offset
11047 + stub_entry->target_section->output_section->vma);
11048 targ += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11050 /* And this is where we are coming from. */
11051 off = (stub_entry->stub_offset
11052 + stub_entry->group->stub_sec->output_offset
11053 + stub_entry->group->stub_sec->output_section->vma);
11057 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11059 bfd_vma r2off = get_r2off (info, stub_entry);
11061 if (r2off == (bfd_vma) -1)
11063 htab->stub_error = TRUE;
11066 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
11068 if (PPC_HA (r2off) != 0)
11070 bfd_put_32 (htab->params->stub_bfd,
11071 ADDIS_R2_R2 | PPC_HA (r2off), p);
11074 if (PPC_LO (r2off) != 0)
11076 bfd_put_32 (htab->params->stub_bfd,
11077 ADDI_R2_R2 | PPC_LO (r2off), p);
11082 bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), p);
11085 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
11088 (_("long branch stub `%s' offset overflow"),
11089 stub_entry->root.string);
11090 htab->stub_error = TRUE;
11094 if (info->emitrelocations)
11096 r = get_relocs (stub_entry->group->stub_sec, 1);
11099 r->r_offset = p - 4 - stub_entry->group->stub_sec->contents;
11100 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
11101 r->r_addend = targ;
11102 if (stub_entry->h != NULL
11103 && !use_global_in_relocs (htab, stub_entry, r, 1))
11108 case ppc_stub_plt_branch:
11109 case ppc_stub_plt_branch_r2off:
11110 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11111 stub_entry->root.string + 9,
11113 if (br_entry == NULL)
11115 _bfd_error_handler (_("can't find branch stub `%s'"),
11116 stub_entry->root.string);
11117 htab->stub_error = TRUE;
11121 targ = (stub_entry->target_value
11122 + stub_entry->target_section->output_offset
11123 + stub_entry->target_section->output_section->vma);
11124 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11125 targ += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11127 bfd_put_64 (htab->brlt->owner, targ,
11128 htab->brlt->contents + br_entry->offset);
11130 if (br_entry->iter == htab->stub_iteration)
11132 br_entry->iter = 0;
11134 if (htab->relbrlt != NULL)
11136 /* Create a reloc for the branch lookup table entry. */
11137 Elf_Internal_Rela rela;
11140 rela.r_offset = (br_entry->offset
11141 + htab->brlt->output_offset
11142 + htab->brlt->output_section->vma);
11143 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11144 rela.r_addend = targ;
11146 rl = htab->relbrlt->contents;
11147 rl += (htab->relbrlt->reloc_count++
11148 * sizeof (Elf64_External_Rela));
11149 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
11151 else if (info->emitrelocations)
11153 r = get_relocs (htab->brlt, 1);
11156 /* brlt, being SEC_LINKER_CREATED does not go through the
11157 normal reloc processing. Symbols and offsets are not
11158 translated from input file to output file form, so
11159 set up the offset per the output file. */
11160 r->r_offset = (br_entry->offset
11161 + htab->brlt->output_offset
11162 + htab->brlt->output_section->vma);
11163 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11164 r->r_addend = targ;
11168 targ = (br_entry->offset
11169 + htab->brlt->output_offset
11170 + htab->brlt->output_section->vma);
11172 off = (elf_gp (info->output_bfd)
11173 + htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11176 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11178 info->callbacks->einfo
11179 (_("%P: linkage table error against `%pT'\n"),
11180 stub_entry->root.string);
11181 bfd_set_error (bfd_error_bad_value);
11182 htab->stub_error = TRUE;
11186 if (info->emitrelocations)
11188 r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
11191 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11192 if (bfd_big_endian (info->output_bfd))
11193 r[0].r_offset += 2;
11194 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
11195 r[0].r_offset += 4;
11196 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11197 r[0].r_addend = targ;
11198 if (PPC_HA (off) != 0)
11200 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11201 r[1].r_offset = r[0].r_offset + 4;
11202 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11203 r[1].r_addend = r[0].r_addend;
11208 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11210 if (PPC_HA (off) != 0)
11212 bfd_put_32 (htab->params->stub_bfd,
11213 ADDIS_R12_R2 | PPC_HA (off), p);
11215 bfd_put_32 (htab->params->stub_bfd,
11216 LD_R12_0R12 | PPC_LO (off), p);
11219 bfd_put_32 (htab->params->stub_bfd,
11220 LD_R12_0R2 | PPC_LO (off), p);
11224 bfd_vma r2off = get_r2off (info, stub_entry);
11226 if (r2off == (bfd_vma) -1)
11228 htab->stub_error = TRUE;
11232 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
11234 if (PPC_HA (off) != 0)
11236 bfd_put_32 (htab->params->stub_bfd,
11237 ADDIS_R12_R2 | PPC_HA (off), p);
11239 bfd_put_32 (htab->params->stub_bfd,
11240 LD_R12_0R12 | PPC_LO (off), p);
11243 bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), p);
11245 if (PPC_HA (r2off) != 0)
11248 bfd_put_32 (htab->params->stub_bfd,
11249 ADDIS_R2_R2 | PPC_HA (r2off), p);
11251 if (PPC_LO (r2off) != 0)
11254 bfd_put_32 (htab->params->stub_bfd,
11255 ADDI_R2_R2 | PPC_LO (r2off), p);
11259 bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, p);
11261 bfd_put_32 (htab->params->stub_bfd, BCTR, p);
11265 case ppc_stub_long_branch_notoc:
11266 case ppc_stub_long_branch_both:
11267 case ppc_stub_plt_branch_notoc:
11268 case ppc_stub_plt_branch_both:
11269 case ppc_stub_plt_call_notoc:
11270 case ppc_stub_plt_call_both:
11272 off = (stub_entry->stub_offset
11273 + stub_entry->group->stub_sec->output_offset
11274 + stub_entry->group->stub_sec->output_section->vma);
11275 if (stub_entry->stub_type == ppc_stub_long_branch_both
11276 || stub_entry->stub_type == ppc_stub_plt_branch_both
11277 || stub_entry->stub_type == ppc_stub_plt_call_both)
11280 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
11283 if (stub_entry->stub_type >= ppc_stub_plt_call_notoc)
11285 targ = stub_entry->plt_ent->plt.offset & ~1;
11286 if (targ >= (bfd_vma) -2)
11289 plt = htab->elf.splt;
11290 if (!htab->elf.dynamic_sections_created
11291 || stub_entry->h == NULL
11292 || stub_entry->h->elf.dynindx == -1)
11294 if (stub_entry->symtype == STT_GNU_IFUNC)
11295 plt = htab->elf.iplt;
11297 plt = htab->pltlocal;
11299 targ += plt->output_offset + plt->output_section->vma;
11302 targ = (stub_entry->target_value
11303 + stub_entry->target_section->output_offset
11304 + stub_entry->target_section->output_section->vma);
11310 if (htab->powerxx_stubs)
11312 bfd_boolean load = stub_entry->stub_type >= ppc_stub_plt_call_notoc;
11313 p = build_powerxx_offset (htab->params->stub_bfd, p, off, odd, load);
11317 /* The notoc stubs calculate their target (either a PLT entry or
11318 the global entry point of a function) relative to the PC
11319 returned by the "bcl" two instructions past the start of the
11320 sequence emitted by build_offset. The offset is therefore 8
11321 less than calculated from the start of the sequence. */
11323 p = build_offset (htab->params->stub_bfd, p, off,
11324 stub_entry->stub_type >= ppc_stub_plt_call_notoc);
11327 if (stub_entry->stub_type <= ppc_stub_long_branch_both)
11331 from = (stub_entry->stub_offset
11332 + stub_entry->group->stub_sec->output_offset
11333 + stub_entry->group->stub_sec->output_section->vma
11335 bfd_put_32 (htab->params->stub_bfd,
11336 B_DOT | ((targ - from) & 0x3fffffc), p);
11340 bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, p);
11342 bfd_put_32 (htab->params->stub_bfd, BCTR, p);
11346 if (info->emitrelocations)
11348 bfd_vma roff = relp - stub_entry->group->stub_sec->contents;
11349 if (htab->powerxx_stubs)
11350 num_rel += num_relocs_for_powerxx_offset (off, odd);
11353 num_rel += num_relocs_for_offset (off);
11356 r = get_relocs (stub_entry->group->stub_sec, num_rel);
11359 if (htab->powerxx_stubs)
11360 r = emit_relocs_for_powerxx_offset (info, r, roff, targ, off, odd);
11362 r = emit_relocs_for_offset (info, r, roff, targ, off);
11363 if (stub_entry->stub_type == ppc_stub_long_branch_notoc
11364 || stub_entry->stub_type == ppc_stub_long_branch_both)
11367 roff = p - 4 - stub_entry->group->stub_sec->contents;
11368 r->r_offset = roff;
11369 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
11370 r->r_addend = targ;
11371 if (stub_entry->h != NULL
11372 && !use_global_in_relocs (htab, stub_entry, r, num_rel))
11377 if (!htab->powerxx_stubs
11378 && htab->glink_eh_frame != NULL
11379 && htab->glink_eh_frame->size != 0)
11381 bfd_byte *base, *eh;
11382 unsigned int lr_used, delta;
11384 base = (htab->glink_eh_frame->contents
11385 + stub_entry->group->eh_base + 17);
11386 eh = base + stub_entry->group->eh_size;
11387 lr_used = stub_entry->stub_offset + 8;
11388 if (stub_entry->stub_type == ppc_stub_long_branch_both
11389 || stub_entry->stub_type == ppc_stub_plt_branch_both
11390 || stub_entry->stub_type == ppc_stub_plt_call_both)
11392 delta = lr_used - stub_entry->group->lr_restore;
11393 stub_entry->group->lr_restore = lr_used + 8;
11394 eh = eh_advance (htab->elf.dynobj, eh, delta);
11395 *eh++ = DW_CFA_register;
11398 *eh++ = DW_CFA_advance_loc + 2;
11399 *eh++ = DW_CFA_restore_extended;
11401 stub_entry->group->eh_size = eh - base;
11405 case ppc_stub_plt_call:
11406 case ppc_stub_plt_call_r2save:
11407 if (stub_entry->h != NULL
11408 && stub_entry->h->is_func_descriptor
11409 && stub_entry->h->oh != NULL)
11411 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11413 /* If the old-ABI "dot-symbol" is undefined make it weak so
11414 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL. */
11415 if (fh->elf.root.type == bfd_link_hash_undefined
11416 && (stub_entry->h->elf.root.type == bfd_link_hash_defined
11417 || stub_entry->h->elf.root.type == bfd_link_hash_defweak))
11418 fh->elf.root.type = bfd_link_hash_undefweak;
11421 /* Now build the stub. */
11422 targ = stub_entry->plt_ent->plt.offset & ~1;
11423 if (targ >= (bfd_vma) -2)
11426 plt = htab->elf.splt;
11427 if (!htab->elf.dynamic_sections_created
11428 || stub_entry->h == NULL
11429 || stub_entry->h->elf.dynindx == -1)
11431 if (stub_entry->symtype == STT_GNU_IFUNC)
11432 plt = htab->elf.iplt;
11434 plt = htab->pltlocal;
11436 targ += plt->output_offset + plt->output_section->vma;
11438 off = (elf_gp (info->output_bfd)
11439 + htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11442 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11444 info->callbacks->einfo
11445 /* xgettext:c-format */
11446 (_("%P: linkage table error against `%pT'\n"),
11447 stub_entry->h != NULL
11448 ? stub_entry->h->elf.root.root.string
11450 bfd_set_error (bfd_error_bad_value);
11451 htab->stub_error = TRUE;
11456 if (info->emitrelocations)
11458 r = get_relocs (stub_entry->group->stub_sec,
11459 ((PPC_HA (off) != 0)
11461 ? 2 + (htab->params->plt_static_chain
11462 && PPC_HA (off + 16) == PPC_HA (off))
11466 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11467 if (bfd_big_endian (info->output_bfd))
11468 r[0].r_offset += 2;
11469 r[0].r_addend = targ;
11471 if (stub_entry->h != NULL
11472 && (stub_entry->h == htab->tls_get_addr_fd
11473 || stub_entry->h == htab->tls_get_addr)
11474 && htab->params->tls_get_addr_opt)
11475 p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11477 p = build_plt_stub (htab, stub_entry, loc, off, r);
11480 case ppc_stub_save_res:
11488 stub_entry->group->stub_sec->size = stub_entry->stub_offset + (p - loc);
11490 if (htab->params->emit_stub_syms)
11492 struct elf_link_hash_entry *h;
11495 const char *const stub_str[] = { "long_branch",
11508 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11509 len2 = strlen (stub_entry->root.string);
11510 name = bfd_malloc (len1 + len2 + 2);
11513 memcpy (name, stub_entry->root.string, 9);
11514 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11515 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11516 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11519 if (h->root.type == bfd_link_hash_new)
11521 h->root.type = bfd_link_hash_defined;
11522 h->root.u.def.section = stub_entry->group->stub_sec;
11523 h->root.u.def.value = stub_entry->stub_offset;
11524 h->ref_regular = 1;
11525 h->def_regular = 1;
11526 h->ref_regular_nonweak = 1;
11527 h->forced_local = 1;
11529 h->root.linker_def = 1;
11536 /* As above, but don't actually build the stub. Just bump offset so
11537 we know stub section sizes, and select plt_branch stubs where
11538 long_branch stubs won't do. */
11541 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11543 struct ppc_stub_hash_entry *stub_entry;
11544 struct bfd_link_info *info;
11545 struct ppc_link_hash_table *htab;
11547 bfd_vma targ, off, r2off;
11548 unsigned int size, extra, lr_used, delta, odd;
11550 /* Massage our args to the form they really have. */
11551 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11554 htab = ppc_hash_table (info);
11558 /* Make a note of the offset within the stubs for this entry. */
11559 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11561 if (stub_entry->h != NULL
11562 && stub_entry->h->save_res
11563 && stub_entry->h->elf.root.type == bfd_link_hash_defined
11564 && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11566 /* Don't make stubs to out-of-line register save/restore
11567 functions. Instead, emit copies of the functions. */
11568 stub_entry->group->needs_save_res = 1;
11569 stub_entry->stub_type = ppc_stub_save_res;
11573 switch (stub_entry->stub_type)
11575 case ppc_stub_plt_branch:
11576 case ppc_stub_plt_branch_r2off:
11577 /* Reset the stub type from the plt branch variant in case we now
11578 can reach with a shorter stub. */
11579 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11580 /* Fall through. */
11581 case ppc_stub_long_branch:
11582 case ppc_stub_long_branch_r2off:
11583 targ = (stub_entry->target_value
11584 + stub_entry->target_section->output_offset
11585 + stub_entry->target_section->output_section->vma);
11586 targ += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11587 off = (stub_entry->stub_offset
11588 + stub_entry->group->stub_sec->output_offset
11589 + stub_entry->group->stub_sec->output_section->vma);
11593 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11595 r2off = get_r2off (info, stub_entry);
11596 if (r2off == (bfd_vma) -1)
11598 htab->stub_error = TRUE;
11602 if (PPC_HA (r2off) != 0)
11604 if (PPC_LO (r2off) != 0)
11610 /* If the branch offset is too big, use a ppc_stub_plt_branch.
11611 Do the same for -R objects without function descriptors. */
11612 if ((stub_entry->stub_type == ppc_stub_long_branch_r2off
11614 && htab->sec_info[stub_entry->target_section->id].toc_off == 0)
11615 || off + (1 << 25) >= (bfd_vma) (1 << 26))
11617 struct ppc_branch_hash_entry *br_entry;
11619 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11620 stub_entry->root.string + 9,
11622 if (br_entry == NULL)
11624 _bfd_error_handler (_("can't build branch stub `%s'"),
11625 stub_entry->root.string);
11626 htab->stub_error = TRUE;
11630 if (br_entry->iter != htab->stub_iteration)
11632 br_entry->iter = htab->stub_iteration;
11633 br_entry->offset = htab->brlt->size;
11634 htab->brlt->size += 8;
11636 if (htab->relbrlt != NULL)
11637 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11638 else if (info->emitrelocations)
11640 htab->brlt->reloc_count += 1;
11641 htab->brlt->flags |= SEC_RELOC;
11645 targ = (br_entry->offset
11646 + htab->brlt->output_offset
11647 + htab->brlt->output_section->vma);
11648 off = (elf_gp (info->output_bfd)
11649 + htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11652 if (info->emitrelocations)
11654 stub_entry->group->stub_sec->reloc_count
11655 += 1 + (PPC_HA (off) != 0);
11656 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11659 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11660 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11663 if (PPC_HA (off) != 0)
11669 if (PPC_HA (off) != 0)
11672 if (PPC_HA (r2off) != 0)
11674 if (PPC_LO (r2off) != 0)
11678 else if (info->emitrelocations)
11680 stub_entry->group->stub_sec->reloc_count += 1;
11681 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11685 case ppc_stub_plt_branch_notoc:
11686 case ppc_stub_plt_branch_both:
11687 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11688 /* Fall through. */
11689 case ppc_stub_long_branch_notoc:
11690 case ppc_stub_long_branch_both:
11691 off = (stub_entry->stub_offset
11692 + stub_entry->group->stub_sec->output_offset
11693 + stub_entry->group->stub_sec->output_section->vma);
11695 if (stub_entry->stub_type == ppc_stub_long_branch_both)
11698 targ = (stub_entry->target_value
11699 + stub_entry->target_section->output_offset
11700 + stub_entry->target_section->output_section->vma);
11704 if (info->emitrelocations)
11706 unsigned int num_rel;
11707 if (htab->powerxx_stubs)
11708 num_rel = num_relocs_for_powerxx_offset (off, odd);
11710 num_rel = num_relocs_for_offset (off - 8);
11711 stub_entry->group->stub_sec->reloc_count += num_rel;
11712 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11715 if (htab->powerxx_stubs)
11716 extra = size_powerxx_offset (off, odd);
11718 extra = size_offset (off - 8);
11719 /* Include branch insn plus those in the offset sequence. */
11721 /* The branch insn is at the end, or "extra" bytes along. So
11722 its offset will be "extra" bytes less that that already
11726 if (!htab->powerxx_stubs)
11728 /* After the bcl, lr has been modified so we need to emit
11729 .eh_frame info saying the return address is in r12. */
11730 lr_used = stub_entry->stub_offset + 8;
11731 if (stub_entry->stub_type == ppc_stub_long_branch_both)
11733 /* The eh_frame info will consist of a DW_CFA_advance_loc or
11734 variant, DW_CFA_register, 65, 12, DW_CFA_advance_loc+2,
11735 DW_CFA_restore_extended 65. */
11736 delta = lr_used - stub_entry->group->lr_restore;
11737 stub_entry->group->eh_size += eh_advance_size (delta) + 6;
11738 stub_entry->group->lr_restore = lr_used + 8;
11741 /* If the branch can't reach, use a plt_branch. */
11742 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
11744 stub_entry->stub_type += (ppc_stub_plt_branch_notoc
11745 - ppc_stub_long_branch_notoc);
11748 else if (info->emitrelocations)
11749 stub_entry->group->stub_sec->reloc_count +=1;
11752 case ppc_stub_plt_call_notoc:
11753 case ppc_stub_plt_call_both:
11754 off = (stub_entry->stub_offset
11755 + stub_entry->group->stub_sec->output_offset
11756 + stub_entry->group->stub_sec->output_section->vma);
11757 if (stub_entry->stub_type == ppc_stub_plt_call_both)
11759 targ = stub_entry->plt_ent->plt.offset & ~1;
11760 if (targ >= (bfd_vma) -2)
11763 plt = htab->elf.splt;
11764 if (!htab->elf.dynamic_sections_created
11765 || stub_entry->h == NULL
11766 || stub_entry->h->elf.dynindx == -1)
11768 if (stub_entry->symtype == STT_GNU_IFUNC)
11769 plt = htab->elf.iplt;
11771 plt = htab->pltlocal;
11773 targ += plt->output_offset + plt->output_section->vma;
11777 if (htab->params->plt_stub_align != 0)
11779 unsigned pad = plt_stub_pad (htab, stub_entry, off);
11781 stub_entry->group->stub_sec->size += pad;
11782 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11786 if (info->emitrelocations)
11788 unsigned int num_rel;
11789 if (htab->powerxx_stubs)
11790 num_rel = num_relocs_for_powerxx_offset (off, odd);
11792 num_rel = num_relocs_for_offset (off - 8);
11793 stub_entry->group->stub_sec->reloc_count += num_rel;
11794 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11797 size = plt_stub_size (htab, stub_entry, off);
11799 if (!htab->powerxx_stubs)
11801 /* After the bcl, lr has been modified so we need to emit
11802 .eh_frame info saying the return address is in r12. */
11803 lr_used = stub_entry->stub_offset + 8;
11804 if (stub_entry->stub_type == ppc_stub_plt_call_both)
11806 /* The eh_frame info will consist of a DW_CFA_advance_loc or
11807 variant, DW_CFA_register, 65, 12, DW_CFA_advance_loc+2,
11808 DW_CFA_restore_extended 65. */
11809 delta = lr_used - stub_entry->group->lr_restore;
11810 stub_entry->group->eh_size += eh_advance_size (delta) + 6;
11811 stub_entry->group->lr_restore = lr_used + 8;
11815 case ppc_stub_plt_call:
11816 case ppc_stub_plt_call_r2save:
11817 targ = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11818 if (targ >= (bfd_vma) -2)
11820 plt = htab->elf.splt;
11821 if (!htab->elf.dynamic_sections_created
11822 || stub_entry->h == NULL
11823 || stub_entry->h->elf.dynindx == -1)
11825 if (stub_entry->symtype == STT_GNU_IFUNC)
11826 plt = htab->elf.iplt;
11828 plt = htab->pltlocal;
11830 targ += plt->output_offset + plt->output_section->vma;
11832 off = (elf_gp (info->output_bfd)
11833 + htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11836 if (htab->params->plt_stub_align != 0)
11838 unsigned pad = plt_stub_pad (htab, stub_entry, off);
11840 stub_entry->group->stub_sec->size += pad;
11841 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11844 if (info->emitrelocations)
11846 stub_entry->group->stub_sec->reloc_count
11847 += ((PPC_HA (off) != 0)
11849 ? 2 + (htab->params->plt_static_chain
11850 && PPC_HA (off + 16) == PPC_HA (off))
11852 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11855 size = plt_stub_size (htab, stub_entry, off);
11857 if (stub_entry->h != NULL
11858 && (stub_entry->h == htab->tls_get_addr_fd
11859 || stub_entry->h == htab->tls_get_addr)
11860 && htab->params->tls_get_addr_opt
11861 && stub_entry->stub_type == ppc_stub_plt_call_r2save)
11863 /* After the bctrl, lr has been modified so we need to
11864 emit .eh_frame info saying the return address is
11865 on the stack. In fact we put the EH info specifying
11866 that the return address is on the stack *at* the
11867 call rather than after it, because the EH info for a
11868 call needs to be specified by that point.
11869 See libgcc/unwind-dw2.c execute_cfa_program. */
11870 lr_used = stub_entry->stub_offset + size - 20;
11871 /* The eh_frame info will consist of a DW_CFA_advance_loc
11872 or variant, DW_CFA_offset_externed_sf, 65, -stackoff,
11873 DW_CFA_advance_loc+4, DW_CFA_restore_extended, 65. */
11874 delta = lr_used - stub_entry->group->lr_restore;
11875 stub_entry->group->eh_size += eh_advance_size (delta) + 6;
11876 stub_entry->group->lr_restore = size - 4;
11885 stub_entry->group->stub_sec->size += size;
11889 /* Set up various things so that we can make a list of input sections
11890 for each output section included in the link. Returns -1 on error,
11891 0 when no stubs will be needed, and 1 on success. */
11894 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11898 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11903 htab->sec_info_arr_size = _bfd_section_id;
11904 amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11905 htab->sec_info = bfd_zmalloc (amt);
11906 if (htab->sec_info == NULL)
11909 /* Set toc_off for com, und, abs and ind sections. */
11910 for (id = 0; id < 3; id++)
11911 htab->sec_info[id].toc_off = TOC_BASE_OFF;
11916 /* Set up for first pass at multitoc partitioning. */
11919 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11921 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11923 htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11924 htab->toc_bfd = NULL;
11925 htab->toc_first_sec = NULL;
11928 /* The linker repeatedly calls this function for each TOC input section
11929 and linker generated GOT section. Group input bfds such that the toc
11930 within a group is less than 64k in size. */
11933 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11935 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11936 bfd_vma addr, off, limit;
11941 if (!htab->second_toc_pass)
11943 /* Keep track of the first .toc or .got section for this input bfd. */
11944 bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11948 htab->toc_bfd = isec->owner;
11949 htab->toc_first_sec = isec;
11952 addr = isec->output_offset + isec->output_section->vma;
11953 off = addr - htab->toc_curr;
11954 limit = 0x80008000;
11955 if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11957 if (off + isec->size > limit)
11959 addr = (htab->toc_first_sec->output_offset
11960 + htab->toc_first_sec->output_section->vma);
11961 htab->toc_curr = addr;
11962 htab->toc_curr &= -TOC_BASE_ALIGN;
11965 /* toc_curr is the base address of this toc group. Set elf_gp
11966 for the input section to be the offset relative to the
11967 output toc base plus 0x8000. Making the input elf_gp an
11968 offset allows us to move the toc as a whole without
11969 recalculating input elf_gp. */
11970 off = htab->toc_curr - elf_gp (info->output_bfd);
11971 off += TOC_BASE_OFF;
11973 /* Die if someone uses a linker script that doesn't keep input
11974 file .toc and .got together. */
11976 && elf_gp (isec->owner) != 0
11977 && elf_gp (isec->owner) != off)
11980 elf_gp (isec->owner) = off;
11984 /* During the second pass toc_first_sec points to the start of
11985 a toc group, and toc_curr is used to track the old elf_gp.
11986 We use toc_bfd to ensure we only look at each bfd once. */
11987 if (htab->toc_bfd == isec->owner)
11989 htab->toc_bfd = isec->owner;
11991 if (htab->toc_first_sec == NULL
11992 || htab->toc_curr != elf_gp (isec->owner))
11994 htab->toc_curr = elf_gp (isec->owner);
11995 htab->toc_first_sec = isec;
11997 addr = (htab->toc_first_sec->output_offset
11998 + htab->toc_first_sec->output_section->vma);
11999 off = addr - elf_gp (info->output_bfd) + TOC_BASE_OFF;
12000 elf_gp (isec->owner) = off;
12005 /* Called via elf_link_hash_traverse to merge GOT entries for global
12009 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12011 if (h->root.type == bfd_link_hash_indirect)
12014 merge_got_entries (&h->got.glist);
12019 /* Called via elf_link_hash_traverse to allocate GOT entries for global
12023 reallocate_got (struct elf_link_hash_entry *h, void *inf)
12025 struct got_entry *gent;
12027 if (h->root.type == bfd_link_hash_indirect)
12030 for (gent = h->got.glist; gent != NULL; gent = gent->next)
12031 if (!gent->is_indirect)
12032 allocate_got (h, (struct bfd_link_info *) inf, gent);
12036 /* Called on the first multitoc pass after the last call to
12037 ppc64_elf_next_toc_section. This function removes duplicate GOT
12041 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
12043 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12044 struct bfd *ibfd, *ibfd2;
12045 bfd_boolean done_something;
12047 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
12049 if (!htab->do_multi_toc)
12052 /* Merge global sym got entries within a toc group. */
12053 elf_link_hash_traverse (&htab->elf, merge_global_got, info);
12055 /* And tlsld_got. */
12056 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12058 struct got_entry *ent, *ent2;
12060 if (!is_ppc64_elf (ibfd))
12063 ent = ppc64_tlsld_got (ibfd);
12064 if (!ent->is_indirect
12065 && ent->got.offset != (bfd_vma) -1)
12067 for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
12069 if (!is_ppc64_elf (ibfd2))
12072 ent2 = ppc64_tlsld_got (ibfd2);
12073 if (!ent2->is_indirect
12074 && ent2->got.offset != (bfd_vma) -1
12075 && elf_gp (ibfd2) == elf_gp (ibfd))
12077 ent2->is_indirect = TRUE;
12078 ent2->got.ent = ent;
12084 /* Zap sizes of got sections. */
12085 htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
12086 htab->elf.irelplt->size -= htab->got_reli_size;
12087 htab->got_reli_size = 0;
12089 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12091 asection *got, *relgot;
12093 if (!is_ppc64_elf (ibfd))
12096 got = ppc64_elf_tdata (ibfd)->got;
12099 got->rawsize = got->size;
12101 relgot = ppc64_elf_tdata (ibfd)->relgot;
12102 relgot->rawsize = relgot->size;
12107 /* Now reallocate the got, local syms first. We don't need to
12108 allocate section contents again since we never increase size. */
12109 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12111 struct got_entry **lgot_ents;
12112 struct got_entry **end_lgot_ents;
12113 struct plt_entry **local_plt;
12114 struct plt_entry **end_local_plt;
12115 unsigned char *lgot_masks;
12116 bfd_size_type locsymcount;
12117 Elf_Internal_Shdr *symtab_hdr;
12120 if (!is_ppc64_elf (ibfd))
12123 lgot_ents = elf_local_got_ents (ibfd);
12127 symtab_hdr = &elf_symtab_hdr (ibfd);
12128 locsymcount = symtab_hdr->sh_info;
12129 end_lgot_ents = lgot_ents + locsymcount;
12130 local_plt = (struct plt_entry **) end_lgot_ents;
12131 end_local_plt = local_plt + locsymcount;
12132 lgot_masks = (unsigned char *) end_local_plt;
12133 s = ppc64_elf_tdata (ibfd)->got;
12134 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
12136 struct got_entry *ent;
12138 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
12140 unsigned int ent_size = 8;
12141 unsigned int rel_size = sizeof (Elf64_External_Rela);
12143 ent->got.offset = s->size;
12144 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
12149 s->size += ent_size;
12150 if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
12152 htab->elf.irelplt->size += rel_size;
12153 htab->got_reli_size += rel_size;
12155 else if (bfd_link_pic (info)
12156 && !((ent->tls_type & TLS_TPREL) != 0
12157 && bfd_link_executable (info)))
12159 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
12160 srel->size += rel_size;
12166 elf_link_hash_traverse (&htab->elf, reallocate_got, info);
12168 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12170 struct got_entry *ent;
12172 if (!is_ppc64_elf (ibfd))
12175 ent = ppc64_tlsld_got (ibfd);
12176 if (!ent->is_indirect
12177 && ent->got.offset != (bfd_vma) -1)
12179 asection *s = ppc64_elf_tdata (ibfd)->got;
12180 ent->got.offset = s->size;
12182 if (bfd_link_pic (info))
12184 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
12185 srel->size += sizeof (Elf64_External_Rela);
12190 done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
12191 if (!done_something)
12192 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12196 if (!is_ppc64_elf (ibfd))
12199 got = ppc64_elf_tdata (ibfd)->got;
12202 done_something = got->rawsize != got->size;
12203 if (done_something)
12208 if (done_something)
12209 (*htab->params->layout_sections_again) ();
12211 /* Set up for second pass over toc sections to recalculate elf_gp
12212 on input sections. */
12213 htab->toc_bfd = NULL;
12214 htab->toc_first_sec = NULL;
12215 htab->second_toc_pass = TRUE;
12216 return done_something;
12219 /* Called after second pass of multitoc partitioning. */
12222 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
12224 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12226 /* After the second pass, toc_curr tracks the TOC offset used
12227 for code sections below in ppc64_elf_next_input_section. */
12228 htab->toc_curr = TOC_BASE_OFF;
12231 /* No toc references were found in ISEC. If the code in ISEC makes no
12232 calls, then there's no need to use toc adjusting stubs when branching
12233 into ISEC. Actually, indirect calls from ISEC are OK as they will
12234 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
12235 needed, and 2 if a cyclical call-graph was found but no other reason
12236 for a stub was detected. If called from the top level, a return of
12237 2 means the same as a return of 0. */
12240 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
12244 /* Mark this section as checked. */
12245 isec->call_check_done = 1;
12247 /* We know none of our code bearing sections will need toc stubs. */
12248 if ((isec->flags & SEC_LINKER_CREATED) != 0)
12251 if (isec->size == 0)
12254 if (isec->output_section == NULL)
12258 if (isec->reloc_count != 0)
12260 Elf_Internal_Rela *relstart, *rel;
12261 Elf_Internal_Sym *local_syms;
12262 struct ppc_link_hash_table *htab;
12264 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
12265 info->keep_memory);
12266 if (relstart == NULL)
12269 /* Look for branches to outside of this section. */
12271 htab = ppc_hash_table (info);
12275 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
12277 enum elf_ppc64_reloc_type r_type;
12278 unsigned long r_symndx;
12279 struct elf_link_hash_entry *h;
12280 struct ppc_link_hash_entry *eh;
12281 Elf_Internal_Sym *sym;
12283 struct _opd_sec_data *opd;
12287 r_type = ELF64_R_TYPE (rel->r_info);
12288 if (r_type != R_PPC64_REL24
12289 && r_type != R_PPC64_REL24_NOTOC
12290 && r_type != R_PPC64_REL14
12291 && r_type != R_PPC64_REL14_BRTAKEN
12292 && r_type != R_PPC64_REL14_BRNTAKEN
12293 && r_type != R_PPC64_PLTCALL
12294 && r_type != R_PPC64_PLTCALL_NOTOC)
12297 r_symndx = ELF64_R_SYM (rel->r_info);
12298 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
12305 /* Calls to dynamic lib functions go through a plt call stub
12307 eh = (struct ppc_link_hash_entry *) h;
12309 && (eh->elf.plt.plist != NULL
12311 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
12317 if (sym_sec == NULL)
12318 /* Ignore other undefined symbols. */
12321 /* Assume branches to other sections not included in the
12322 link need stubs too, to cover -R and absolute syms. */
12323 if (sym_sec->output_section == NULL)
12330 sym_value = sym->st_value;
12333 if (h->root.type != bfd_link_hash_defined
12334 && h->root.type != bfd_link_hash_defweak)
12336 sym_value = h->root.u.def.value;
12338 sym_value += rel->r_addend;
12340 /* If this branch reloc uses an opd sym, find the code section. */
12341 opd = get_opd_info (sym_sec);
12344 if (h == NULL && opd->adjust != NULL)
12348 adjust = opd->adjust[OPD_NDX (sym_value)];
12350 /* Assume deleted functions won't ever be called. */
12352 sym_value += adjust;
12355 dest = opd_entry_value (sym_sec, sym_value,
12356 &sym_sec, NULL, FALSE);
12357 if (dest == (bfd_vma) -1)
12362 + sym_sec->output_offset
12363 + sym_sec->output_section->vma);
12365 /* Ignore branch to self. */
12366 if (sym_sec == isec)
12369 /* If the called function uses the toc, we need a stub. */
12370 if (sym_sec->has_toc_reloc
12371 || sym_sec->makes_toc_func_call)
12377 /* Assume any branch that needs a long branch stub might in fact
12378 need a plt_branch stub. A plt_branch stub uses r2. */
12379 else if (dest - (isec->output_offset
12380 + isec->output_section->vma
12381 + rel->r_offset) + (1 << 25)
12382 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
12390 /* If calling back to a section in the process of being
12391 tested, we can't say for sure that no toc adjusting stubs
12392 are needed, so don't return zero. */
12393 else if (sym_sec->call_check_in_progress)
12396 /* Branches to another section that itself doesn't have any TOC
12397 references are OK. Recursively call ourselves to check. */
12398 else if (!sym_sec->call_check_done)
12402 /* Mark current section as indeterminate, so that other
12403 sections that call back to current won't be marked as
12405 isec->call_check_in_progress = 1;
12406 recur = toc_adjusting_stub_needed (info, sym_sec);
12407 isec->call_check_in_progress = 0;
12418 if (local_syms != NULL
12419 && (elf_symtab_hdr (isec->owner).contents
12420 != (unsigned char *) local_syms))
12422 if (elf_section_data (isec)->relocs != relstart)
12427 && isec->map_head.s != NULL
12428 && (strcmp (isec->output_section->name, ".init") == 0
12429 || strcmp (isec->output_section->name, ".fini") == 0))
12431 if (isec->map_head.s->has_toc_reloc
12432 || isec->map_head.s->makes_toc_func_call)
12434 else if (!isec->map_head.s->call_check_done)
12437 isec->call_check_in_progress = 1;
12438 recur = toc_adjusting_stub_needed (info, isec->map_head.s);
12439 isec->call_check_in_progress = 0;
12446 isec->makes_toc_func_call = 1;
12451 /* The linker repeatedly calls this function for each input section,
12452 in the order that input sections are linked into output sections.
12453 Build lists of input sections to determine groupings between which
12454 we may insert linker stubs. */
12457 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
12459 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12464 if ((isec->output_section->flags & SEC_CODE) != 0
12465 && isec->output_section->id < htab->sec_info_arr_size)
12467 /* This happens to make the list in reverse order,
12468 which is what we want. */
12469 htab->sec_info[isec->id].u.list
12470 = htab->sec_info[isec->output_section->id].u.list;
12471 htab->sec_info[isec->output_section->id].u.list = isec;
12474 if (htab->multi_toc_needed)
12476 /* Analyse sections that aren't already flagged as needing a
12477 valid toc pointer. Exclude .fixup for the linux kernel.
12478 .fixup contains branches, but only back to the function that
12479 hit an exception. */
12480 if (!(isec->has_toc_reloc
12481 || (isec->flags & SEC_CODE) == 0
12482 || strcmp (isec->name, ".fixup") == 0
12483 || isec->call_check_done))
12485 if (toc_adjusting_stub_needed (info, isec) < 0)
12488 /* Make all sections use the TOC assigned for this object file.
12489 This will be wrong for pasted sections; We fix that in
12490 check_pasted_section(). */
12491 if (elf_gp (isec->owner) != 0)
12492 htab->toc_curr = elf_gp (isec->owner);
12495 htab->sec_info[isec->id].toc_off = htab->toc_curr;
12499 /* Check that all .init and .fini sections use the same toc, if they
12500 have toc relocs. */
12503 check_pasted_section (struct bfd_link_info *info, const char *name)
12505 asection *o = bfd_get_section_by_name (info->output_bfd, name);
12509 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12510 bfd_vma toc_off = 0;
12513 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12514 if (i->has_toc_reloc)
12517 toc_off = htab->sec_info[i->id].toc_off;
12518 else if (toc_off != htab->sec_info[i->id].toc_off)
12523 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12524 if (i->makes_toc_func_call)
12526 toc_off = htab->sec_info[i->id].toc_off;
12530 /* Make sure the whole pasted function uses the same toc offset. */
12532 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12533 htab->sec_info[i->id].toc_off = toc_off;
12539 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12541 return (check_pasted_section (info, ".init")
12542 & check_pasted_section (info, ".fini"));
12545 /* See whether we can group stub sections together. Grouping stub
12546 sections may result in fewer stubs. More importantly, we need to
12547 put all .init* and .fini* stubs at the beginning of the .init or
12548 .fini output sections respectively, because glibc splits the
12549 _init and _fini functions into multiple parts. Putting a stub in
12550 the middle of a function is not a good idea. */
12553 group_sections (struct bfd_link_info *info,
12554 bfd_size_type stub_group_size,
12555 bfd_boolean stubs_always_before_branch)
12557 struct ppc_link_hash_table *htab;
12559 bfd_boolean suppress_size_errors;
12561 htab = ppc_hash_table (info);
12565 suppress_size_errors = FALSE;
12566 if (stub_group_size == 1)
12568 /* Default values. */
12569 if (stubs_always_before_branch)
12570 stub_group_size = 0x1e00000;
12572 stub_group_size = 0x1c00000;
12573 suppress_size_errors = TRUE;
12576 for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12580 if (osec->id >= htab->sec_info_arr_size)
12583 tail = htab->sec_info[osec->id].u.list;
12584 while (tail != NULL)
12588 bfd_size_type total;
12589 bfd_boolean big_sec;
12591 struct map_stub *group;
12592 bfd_size_type group_size;
12595 total = tail->size;
12596 group_size = (ppc64_elf_section_data (tail) != NULL
12597 && ppc64_elf_section_data (tail)->has_14bit_branch
12598 ? stub_group_size >> 10 : stub_group_size);
12600 big_sec = total > group_size;
12601 if (big_sec && !suppress_size_errors)
12602 /* xgettext:c-format */
12603 _bfd_error_handler (_("%pB section %pA exceeds stub group size"),
12604 tail->owner, tail);
12605 curr_toc = htab->sec_info[tail->id].toc_off;
12607 while ((prev = htab->sec_info[curr->id].u.list) != NULL
12608 && ((total += curr->output_offset - prev->output_offset)
12609 < (ppc64_elf_section_data (prev) != NULL
12610 && ppc64_elf_section_data (prev)->has_14bit_branch
12611 ? (group_size = stub_group_size >> 10) : group_size))
12612 && htab->sec_info[prev->id].toc_off == curr_toc)
12615 /* OK, the size from the start of CURR to the end is less
12616 than group_size and thus can be handled by one stub
12617 section. (or the tail section is itself larger than
12618 group_size, in which case we may be toast.) We should
12619 really be keeping track of the total size of stubs added
12620 here, as stubs contribute to the final output section
12621 size. That's a little tricky, and this way will only
12622 break if stubs added make the total size more than 2^25,
12623 ie. for the default stub_group_size, if stubs total more
12624 than 2097152 bytes, or nearly 75000 plt call stubs. */
12625 group = bfd_alloc (curr->owner, sizeof (*group));
12628 group->link_sec = curr;
12629 group->stub_sec = NULL;
12630 group->needs_save_res = 0;
12631 group->lr_restore = 0;
12632 group->eh_size = 0;
12633 group->eh_base = 0;
12634 group->next = htab->group;
12635 htab->group = group;
12638 prev = htab->sec_info[tail->id].u.list;
12639 /* Set up this stub group. */
12640 htab->sec_info[tail->id].u.group = group;
12642 while (tail != curr && (tail = prev) != NULL);
12644 /* But wait, there's more! Input sections up to group_size
12645 bytes before the stub section can be handled by it too.
12646 Don't do this if we have a really large section after the
12647 stubs, as adding more stubs increases the chance that
12648 branches may not reach into the stub section. */
12649 if (!stubs_always_before_branch && !big_sec)
12652 while (prev != NULL
12653 && ((total += tail->output_offset - prev->output_offset)
12654 < (ppc64_elf_section_data (prev) != NULL
12655 && ppc64_elf_section_data (prev)->has_14bit_branch
12656 ? (group_size = stub_group_size >> 10)
12658 && htab->sec_info[prev->id].toc_off == curr_toc)
12661 prev = htab->sec_info[tail->id].u.list;
12662 htab->sec_info[tail->id].u.group = group;
12671 static const unsigned char glink_eh_frame_cie[] =
12673 0, 0, 0, 16, /* length. */
12674 0, 0, 0, 0, /* id. */
12675 1, /* CIE version. */
12676 'z', 'R', 0, /* Augmentation string. */
12677 4, /* Code alignment. */
12678 0x78, /* Data alignment. */
12680 1, /* Augmentation size. */
12681 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */
12682 DW_CFA_def_cfa, 1, 0 /* def_cfa: r1 offset 0. */
12685 /* Stripping output sections is normally done before dynamic section
12686 symbols have been allocated. This function is called later, and
12687 handles cases like htab->brlt which is mapped to its own output
12691 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12693 if (isec->size == 0
12694 && isec->output_section->size == 0
12695 && !(isec->output_section->flags & SEC_KEEP)
12696 && !bfd_section_removed_from_list (info->output_bfd,
12697 isec->output_section)
12698 && elf_section_data (isec->output_section)->dynindx == 0)
12700 isec->output_section->flags |= SEC_EXCLUDE;
12701 bfd_section_list_remove (info->output_bfd, isec->output_section);
12702 info->output_bfd->section_count--;
12706 /* Determine and set the size of the stub section for a final link.
12708 The basic idea here is to examine all the relocations looking for
12709 PC-relative calls to a target that is unreachable with a "bl"
12713 ppc64_elf_size_stubs (struct bfd_link_info *info)
12715 bfd_size_type stub_group_size;
12716 bfd_boolean stubs_always_before_branch;
12717 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12722 if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12723 htab->params->plt_thread_safe = 1;
12724 if (!htab->opd_abi)
12725 htab->params->plt_thread_safe = 0;
12726 else if (htab->params->plt_thread_safe == -1)
12728 static const char *const thread_starter[] =
12732 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12734 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12735 "mq_notify", "create_timer",
12740 "GOMP_parallel_start",
12741 "GOMP_parallel_loop_static",
12742 "GOMP_parallel_loop_static_start",
12743 "GOMP_parallel_loop_dynamic",
12744 "GOMP_parallel_loop_dynamic_start",
12745 "GOMP_parallel_loop_guided",
12746 "GOMP_parallel_loop_guided_start",
12747 "GOMP_parallel_loop_runtime",
12748 "GOMP_parallel_loop_runtime_start",
12749 "GOMP_parallel_sections",
12750 "GOMP_parallel_sections_start",
12756 for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12758 struct elf_link_hash_entry *h;
12759 h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12760 FALSE, FALSE, TRUE);
12761 htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12762 if (htab->params->plt_thread_safe)
12766 stubs_always_before_branch = htab->params->group_size < 0;
12767 if (htab->params->group_size < 0)
12768 stub_group_size = -htab->params->group_size;
12770 stub_group_size = htab->params->group_size;
12772 if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12775 #define STUB_SHRINK_ITER 20
12776 /* Loop until no stubs added. After iteration 20 of this loop we may
12777 exit on a stub section shrinking. This is to break out of a
12778 pathological case where adding stubs on one iteration decreases
12779 section gaps (perhaps due to alignment), which then requires
12780 fewer or smaller stubs on the next iteration. */
12785 unsigned int bfd_indx;
12786 struct map_stub *group;
12788 htab->stub_iteration += 1;
12790 for (input_bfd = info->input_bfds, bfd_indx = 0;
12792 input_bfd = input_bfd->link.next, bfd_indx++)
12794 Elf_Internal_Shdr *symtab_hdr;
12796 Elf_Internal_Sym *local_syms = NULL;
12798 if (!is_ppc64_elf (input_bfd))
12801 /* We'll need the symbol table in a second. */
12802 symtab_hdr = &elf_symtab_hdr (input_bfd);
12803 if (symtab_hdr->sh_info == 0)
12806 /* Walk over each section attached to the input bfd. */
12807 for (section = input_bfd->sections;
12809 section = section->next)
12811 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12813 /* If there aren't any relocs, then there's nothing more
12815 if ((section->flags & SEC_RELOC) == 0
12816 || (section->flags & SEC_ALLOC) == 0
12817 || (section->flags & SEC_LOAD) == 0
12818 || (section->flags & SEC_CODE) == 0
12819 || section->reloc_count == 0)
12822 /* If this section is a link-once section that will be
12823 discarded, then don't create any stubs. */
12824 if (section->output_section == NULL
12825 || section->output_section->owner != info->output_bfd)
12828 /* Get the relocs. */
12830 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12831 info->keep_memory);
12832 if (internal_relocs == NULL)
12833 goto error_ret_free_local;
12835 /* Now examine each relocation. */
12836 irela = internal_relocs;
12837 irelaend = irela + section->reloc_count;
12838 for (; irela < irelaend; irela++)
12840 enum elf_ppc64_reloc_type r_type;
12841 unsigned int r_indx;
12842 enum ppc_stub_type stub_type;
12843 struct ppc_stub_hash_entry *stub_entry;
12844 asection *sym_sec, *code_sec;
12845 bfd_vma sym_value, code_value;
12846 bfd_vma destination;
12847 unsigned long local_off;
12848 bfd_boolean ok_dest;
12849 struct ppc_link_hash_entry *hash;
12850 struct ppc_link_hash_entry *fdh;
12851 struct elf_link_hash_entry *h;
12852 Elf_Internal_Sym *sym;
12854 const asection *id_sec;
12855 struct _opd_sec_data *opd;
12856 struct plt_entry *plt_ent;
12858 r_type = ELF64_R_TYPE (irela->r_info);
12859 r_indx = ELF64_R_SYM (irela->r_info);
12861 if (r_type >= R_PPC64_max)
12863 bfd_set_error (bfd_error_bad_value);
12864 goto error_ret_free_internal;
12867 /* Only look for stubs on branch instructions. */
12868 if (r_type != R_PPC64_REL24
12869 && r_type != R_PPC64_REL24_NOTOC
12870 && r_type != R_PPC64_REL14
12871 && r_type != R_PPC64_REL14_BRTAKEN
12872 && r_type != R_PPC64_REL14_BRNTAKEN)
12875 /* Now determine the call target, its name, value,
12877 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12878 r_indx, input_bfd))
12879 goto error_ret_free_internal;
12880 hash = (struct ppc_link_hash_entry *) h;
12887 sym_value = sym->st_value;
12888 if (sym_sec != NULL
12889 && sym_sec->output_section != NULL)
12892 else if (hash->elf.root.type == bfd_link_hash_defined
12893 || hash->elf.root.type == bfd_link_hash_defweak)
12895 sym_value = hash->elf.root.u.def.value;
12896 if (sym_sec->output_section != NULL)
12899 else if (hash->elf.root.type == bfd_link_hash_undefweak
12900 || hash->elf.root.type == bfd_link_hash_undefined)
12902 /* Recognise an old ABI func code entry sym, and
12903 use the func descriptor sym instead if it is
12905 if (hash->elf.root.root.string[0] == '.'
12906 && hash->oh != NULL)
12908 fdh = ppc_follow_link (hash->oh);
12909 if (fdh->elf.root.type == bfd_link_hash_defined
12910 || fdh->elf.root.type == bfd_link_hash_defweak)
12912 sym_sec = fdh->elf.root.u.def.section;
12913 sym_value = fdh->elf.root.u.def.value;
12914 if (sym_sec->output_section != NULL)
12923 bfd_set_error (bfd_error_bad_value);
12924 goto error_ret_free_internal;
12931 sym_value += irela->r_addend;
12932 destination = (sym_value
12933 + sym_sec->output_offset
12934 + sym_sec->output_section->vma);
12935 local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12940 code_sec = sym_sec;
12941 code_value = sym_value;
12942 opd = get_opd_info (sym_sec);
12947 if (hash == NULL && opd->adjust != NULL)
12949 long adjust = opd->adjust[OPD_NDX (sym_value)];
12952 code_value += adjust;
12953 sym_value += adjust;
12955 dest = opd_entry_value (sym_sec, sym_value,
12956 &code_sec, &code_value, FALSE);
12957 if (dest != (bfd_vma) -1)
12959 destination = dest;
12962 /* Fixup old ABI sym to point at code
12964 hash->elf.root.type = bfd_link_hash_defweak;
12965 hash->elf.root.u.def.section = code_sec;
12966 hash->elf.root.u.def.value = code_value;
12971 /* Determine what (if any) linker stub is needed. */
12973 stub_type = ppc_type_of_stub (section, irela, &hash,
12974 &plt_ent, destination,
12977 if (r_type == R_PPC64_REL24_NOTOC)
12979 if (stub_type == ppc_stub_plt_call)
12980 stub_type = ppc_stub_plt_call_notoc;
12981 else if (stub_type == ppc_stub_long_branch
12982 || (code_sec != NULL
12983 && code_sec->output_section != NULL
12984 && (((hash ? hash->elf.other : sym->st_other)
12985 & STO_PPC64_LOCAL_MASK)
12986 > 1 << STO_PPC64_LOCAL_BIT)))
12987 stub_type = ppc_stub_long_branch_notoc;
12989 else if (stub_type != ppc_stub_plt_call)
12991 /* Check whether we need a TOC adjusting stub.
12992 Since the linker pastes together pieces from
12993 different object files when creating the
12994 _init and _fini functions, it may be that a
12995 call to what looks like a local sym is in
12996 fact a call needing a TOC adjustment. */
12997 if ((code_sec != NULL
12998 && code_sec->output_section != NULL
12999 && (htab->sec_info[code_sec->id].toc_off
13000 != htab->sec_info[section->id].toc_off)
13001 && (code_sec->has_toc_reloc
13002 || code_sec->makes_toc_func_call))
13003 || (((hash ? hash->elf.other : sym->st_other)
13004 & STO_PPC64_LOCAL_MASK)
13005 == 1 << STO_PPC64_LOCAL_BIT))
13006 stub_type = ppc_stub_long_branch_r2off;
13009 if (stub_type == ppc_stub_none)
13012 /* __tls_get_addr calls might be eliminated. */
13013 if (stub_type != ppc_stub_plt_call
13014 && stub_type != ppc_stub_plt_call_notoc
13016 && (hash == htab->tls_get_addr
13017 || hash == htab->tls_get_addr_fd)
13018 && section->has_tls_reloc
13019 && irela != internal_relocs)
13021 /* Get tls info. */
13022 unsigned char *tls_mask;
13024 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
13025 irela - 1, input_bfd))
13026 goto error_ret_free_internal;
13027 if ((*tls_mask & TLS_TLS) != 0)
13031 if (stub_type == ppc_stub_plt_call)
13034 && htab->params->plt_localentry0 != 0
13035 && is_elfv2_localentry0 (&hash->elf))
13036 htab->has_plt_localentry0 = 1;
13037 else if (irela + 1 < irelaend
13038 && irela[1].r_offset == irela->r_offset + 4
13039 && (ELF64_R_TYPE (irela[1].r_info)
13040 == R_PPC64_TOCSAVE))
13042 if (!tocsave_find (htab, INSERT,
13043 &local_syms, irela + 1, input_bfd))
13044 goto error_ret_free_internal;
13047 stub_type = ppc_stub_plt_call_r2save;
13050 /* Support for grouping stub sections. */
13051 id_sec = htab->sec_info[section->id].u.group->link_sec;
13053 /* Get the name of this stub. */
13054 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
13056 goto error_ret_free_internal;
13058 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
13059 stub_name, FALSE, FALSE);
13060 if (stub_entry != NULL)
13062 enum ppc_stub_type old_type;
13063 /* A stub has already been created, but it may
13064 not be the required type. We shouldn't be
13065 transitioning from plt_call to long_branch
13066 stubs or vice versa, but we might be
13067 upgrading from plt_call to plt_call_r2save or
13068 from long_branch to long_branch_r2off. */
13070 old_type = stub_entry->stub_type;
13076 case ppc_stub_save_res:
13079 case ppc_stub_plt_call:
13080 case ppc_stub_plt_call_r2save:
13081 case ppc_stub_plt_call_notoc:
13082 case ppc_stub_plt_call_both:
13083 if (stub_type == ppc_stub_plt_call)
13085 else if (stub_type == ppc_stub_plt_call_r2save)
13087 if (old_type == ppc_stub_plt_call_notoc)
13088 stub_type = ppc_stub_plt_call_both;
13090 else if (stub_type == ppc_stub_plt_call_notoc)
13092 if (old_type == ppc_stub_plt_call_r2save)
13093 stub_type = ppc_stub_plt_call_both;
13099 case ppc_stub_plt_branch:
13100 case ppc_stub_plt_branch_r2off:
13101 case ppc_stub_plt_branch_notoc:
13102 case ppc_stub_plt_branch_both:
13103 old_type += (ppc_stub_long_branch
13104 - ppc_stub_plt_branch);
13105 /* Fall through. */
13106 case ppc_stub_long_branch:
13107 case ppc_stub_long_branch_r2off:
13108 case ppc_stub_long_branch_notoc:
13109 case ppc_stub_long_branch_both:
13110 if (stub_type == ppc_stub_long_branch)
13112 else if (stub_type == ppc_stub_long_branch_r2off)
13114 if (old_type == ppc_stub_long_branch_notoc)
13115 stub_type = ppc_stub_long_branch_both;
13117 else if (stub_type == ppc_stub_long_branch_notoc)
13119 if (old_type == ppc_stub_long_branch_r2off)
13120 stub_type = ppc_stub_long_branch_both;
13126 if (old_type < stub_type)
13127 stub_entry->stub_type = stub_type;
13131 stub_entry = ppc_add_stub (stub_name, section, info);
13132 if (stub_entry == NULL)
13135 error_ret_free_internal:
13136 if (elf_section_data (section)->relocs == NULL)
13137 free (internal_relocs);
13138 error_ret_free_local:
13139 if (local_syms != NULL
13140 && (symtab_hdr->contents
13141 != (unsigned char *) local_syms))
13146 stub_entry->stub_type = stub_type;
13147 if (stub_type >= ppc_stub_plt_call
13148 && stub_type <= ppc_stub_plt_call_both)
13150 stub_entry->target_value = sym_value;
13151 stub_entry->target_section = sym_sec;
13155 stub_entry->target_value = code_value;
13156 stub_entry->target_section = code_sec;
13158 stub_entry->h = hash;
13159 stub_entry->plt_ent = plt_ent;
13160 stub_entry->symtype
13161 = hash ? hash->elf.type : ELF_ST_TYPE (sym->st_info);
13162 stub_entry->other = hash ? hash->elf.other : sym->st_other;
13165 && (hash->elf.root.type == bfd_link_hash_defined
13166 || hash->elf.root.type == bfd_link_hash_defweak))
13167 htab->stub_globals += 1;
13170 /* We're done with the internal relocs, free them. */
13171 if (elf_section_data (section)->relocs != internal_relocs)
13172 free (internal_relocs);
13175 if (local_syms != NULL
13176 && symtab_hdr->contents != (unsigned char *) local_syms)
13178 if (!info->keep_memory)
13181 symtab_hdr->contents = (unsigned char *) local_syms;
13185 /* We may have added some stubs. Find out the new size of the
13187 for (group = htab->group; group != NULL; group = group->next)
13189 group->lr_restore = 0;
13190 group->eh_size = 0;
13191 if (group->stub_sec != NULL)
13193 asection *stub_sec = group->stub_sec;
13195 if (htab->stub_iteration <= STUB_SHRINK_ITER
13196 || stub_sec->rawsize < stub_sec->size)
13197 /* Past STUB_SHRINK_ITER, rawsize is the max size seen. */
13198 stub_sec->rawsize = stub_sec->size;
13199 stub_sec->size = 0;
13200 stub_sec->reloc_count = 0;
13201 stub_sec->flags &= ~SEC_RELOC;
13205 if (htab->stub_iteration <= STUB_SHRINK_ITER
13206 || htab->brlt->rawsize < htab->brlt->size)
13207 htab->brlt->rawsize = htab->brlt->size;
13208 htab->brlt->size = 0;
13209 htab->brlt->reloc_count = 0;
13210 htab->brlt->flags &= ~SEC_RELOC;
13211 if (htab->relbrlt != NULL)
13212 htab->relbrlt->size = 0;
13214 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
13216 for (group = htab->group; group != NULL; group = group->next)
13217 if (group->needs_save_res)
13218 group->stub_sec->size += htab->sfpr->size;
13220 if (info->emitrelocations
13221 && htab->glink != NULL && htab->glink->size != 0)
13223 htab->glink->reloc_count = 1;
13224 htab->glink->flags |= SEC_RELOC;
13227 if (htab->glink_eh_frame != NULL
13228 && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
13229 && htab->glink_eh_frame->output_section->size > 8)
13231 size_t size = 0, align = 4;
13233 for (group = htab->group; group != NULL; group = group->next)
13234 if (group->eh_size != 0)
13235 size += (group->eh_size + 17 + align - 1) & -align;
13236 if (htab->glink != NULL && htab->glink->size != 0)
13237 size += (24 + align - 1) & -align;
13239 size += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
13240 align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
13241 size = (size + align - 1) & -align;
13242 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
13243 htab->glink_eh_frame->size = size;
13246 if (htab->params->plt_stub_align != 0)
13247 for (group = htab->group; group != NULL; group = group->next)
13248 if (group->stub_sec != NULL)
13250 int align = abs (htab->params->plt_stub_align);
13251 group->stub_sec->size
13252 = (group->stub_sec->size + (1 << align) - 1) & -(1 << align);
13255 for (group = htab->group; group != NULL; group = group->next)
13256 if (group->stub_sec != NULL
13257 && group->stub_sec->rawsize != group->stub_sec->size
13258 && (htab->stub_iteration <= STUB_SHRINK_ITER
13259 || group->stub_sec->rawsize < group->stub_sec->size))
13263 && (htab->brlt->rawsize == htab->brlt->size
13264 || (htab->stub_iteration > STUB_SHRINK_ITER
13265 && htab->brlt->rawsize > htab->brlt->size))
13266 && (htab->glink_eh_frame == NULL
13267 || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
13270 /* Ask the linker to do its stuff. */
13271 (*htab->params->layout_sections_again) ();
13274 if (htab->glink_eh_frame != NULL
13275 && htab->glink_eh_frame->size != 0)
13278 bfd_byte *p, *last_fde;
13279 size_t last_fde_len, size, align, pad;
13280 struct map_stub *group;
13282 /* It is necessary to at least have a rough outline of the
13283 linker generated CIEs and FDEs written before
13284 bfd_elf_discard_info is run, in order for these FDEs to be
13285 indexed in .eh_frame_hdr. */
13286 p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
13289 htab->glink_eh_frame->contents = p;
13293 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
13294 /* CIE length (rewrite in case little-endian). */
13295 last_fde_len = ((sizeof (glink_eh_frame_cie) + align - 1) & -align) - 4;
13296 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
13297 p += last_fde_len + 4;
13299 for (group = htab->group; group != NULL; group = group->next)
13300 if (group->eh_size != 0)
13302 group->eh_base = p - htab->glink_eh_frame->contents;
13304 last_fde_len = ((group->eh_size + 17 + align - 1) & -align) - 4;
13306 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
13309 val = p - htab->glink_eh_frame->contents;
13310 bfd_put_32 (htab->elf.dynobj, val, p);
13312 /* Offset to stub section, written later. */
13314 /* stub section size. */
13315 bfd_put_32 (htab->elf.dynobj, group->stub_sec->size, p);
13317 /* Augmentation. */
13319 /* Make sure we don't have all nops. This is enough for
13320 elf-eh-frame.c to detect the last non-nop opcode. */
13321 p[group->eh_size - 1] = DW_CFA_advance_loc + 1;
13322 p = last_fde + last_fde_len + 4;
13324 if (htab->glink != NULL && htab->glink->size != 0)
13327 last_fde_len = ((24 + align - 1) & -align) - 4;
13329 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
13332 val = p - htab->glink_eh_frame->contents;
13333 bfd_put_32 (htab->elf.dynobj, val, p);
13335 /* Offset to .glink, written later. */
13338 bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
13340 /* Augmentation. */
13343 *p++ = DW_CFA_advance_loc + 1;
13344 *p++ = DW_CFA_register;
13346 *p++ = htab->opd_abi ? 12 : 0;
13347 *p++ = DW_CFA_advance_loc + (htab->opd_abi ? 5 : 7);
13348 *p++ = DW_CFA_restore_extended;
13350 p += ((24 + align - 1) & -align) - 24;
13352 /* Subsume any padding into the last FDE if user .eh_frame
13353 sections are aligned more than glink_eh_frame. Otherwise any
13354 zero padding will be seen as a terminator. */
13355 align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
13356 size = p - htab->glink_eh_frame->contents;
13357 pad = ((size + align - 1) & -align) - size;
13358 htab->glink_eh_frame->size = size + pad;
13359 bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
13362 maybe_strip_output (info, htab->brlt);
13363 if (htab->glink_eh_frame != NULL)
13364 maybe_strip_output (info, htab->glink_eh_frame);
13369 /* Called after we have determined section placement. If sections
13370 move, we'll be called again. Provide a value for TOCstart. */
13373 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
13376 bfd_vma TOCstart, adjust;
13380 struct elf_link_hash_entry *h;
13381 struct elf_link_hash_table *htab = elf_hash_table (info);
13383 if (is_elf_hash_table (htab)
13384 && htab->hgot != NULL)
13388 h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
13389 if (is_elf_hash_table (htab))
13393 && h->root.type == bfd_link_hash_defined
13394 && !h->root.linker_def
13395 && (!is_elf_hash_table (htab)
13396 || h->def_regular))
13398 TOCstart = (h->root.u.def.value - TOC_BASE_OFF
13399 + h->root.u.def.section->output_offset
13400 + h->root.u.def.section->output_section->vma);
13401 _bfd_set_gp_value (obfd, TOCstart);
13406 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
13407 order. The TOC starts where the first of these sections starts. */
13408 s = bfd_get_section_by_name (obfd, ".got");
13409 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13410 s = bfd_get_section_by_name (obfd, ".toc");
13411 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13412 s = bfd_get_section_by_name (obfd, ".tocbss");
13413 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13414 s = bfd_get_section_by_name (obfd, ".plt");
13415 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13417 /* This may happen for
13418 o references to TOC base (SYM@toc / TOC[tc0]) without a
13420 o bad linker script
13421 o --gc-sections and empty TOC sections
13423 FIXME: Warn user? */
13425 /* Look for a likely section. We probably won't even be
13427 for (s = obfd->sections; s != NULL; s = s->next)
13428 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
13430 == (SEC_ALLOC | SEC_SMALL_DATA))
13433 for (s = obfd->sections; s != NULL; s = s->next)
13434 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
13435 == (SEC_ALLOC | SEC_SMALL_DATA))
13438 for (s = obfd->sections; s != NULL; s = s->next)
13439 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
13443 for (s = obfd->sections; s != NULL; s = s->next)
13444 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
13450 TOCstart = s->output_section->vma + s->output_offset;
13452 /* Force alignment. */
13453 adjust = TOCstart & (TOC_BASE_ALIGN - 1);
13454 TOCstart -= adjust;
13455 _bfd_set_gp_value (obfd, TOCstart);
13457 if (info != NULL && s != NULL)
13459 struct ppc_link_hash_table *htab = ppc_hash_table (info);
13463 if (htab->elf.hgot != NULL)
13465 htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
13466 htab->elf.hgot->root.u.def.section = s;
13471 struct bfd_link_hash_entry *bh = NULL;
13472 _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
13473 s, TOC_BASE_OFF - adjust,
13474 NULL, FALSE, FALSE, &bh);
13480 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
13481 write out any global entry stubs, and PLT relocations. */
13484 build_global_entry_stubs_and_plt (struct elf_link_hash_entry *h, void *inf)
13486 struct bfd_link_info *info;
13487 struct ppc_link_hash_table *htab;
13488 struct plt_entry *ent;
13491 if (h->root.type == bfd_link_hash_indirect)
13495 htab = ppc_hash_table (info);
13499 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
13500 if (ent->plt.offset != (bfd_vma) -1)
13502 /* This symbol has an entry in the procedure linkage
13503 table. Set it up. */
13504 Elf_Internal_Rela rela;
13505 asection *plt, *relplt;
13508 if (!htab->elf.dynamic_sections_created
13509 || h->dynindx == -1)
13511 if (!(h->def_regular
13512 && (h->root.type == bfd_link_hash_defined
13513 || h->root.type == bfd_link_hash_defweak)))
13515 if (h->type == STT_GNU_IFUNC)
13517 plt = htab->elf.iplt;
13518 relplt = htab->elf.irelplt;
13519 htab->local_ifunc_resolver = 1;
13521 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
13523 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13527 plt = htab->pltlocal;
13528 if (bfd_link_pic (info))
13530 relplt = htab->relpltlocal;
13532 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_SLOT);
13534 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13539 rela.r_addend = (h->root.u.def.value
13540 + h->root.u.def.section->output_offset
13541 + h->root.u.def.section->output_section->vma
13544 if (relplt == NULL)
13546 loc = plt->contents + ent->plt.offset;
13547 bfd_put_64 (info->output_bfd, rela.r_addend, loc);
13550 bfd_vma toc = elf_gp (info->output_bfd);
13551 toc += htab->sec_info[h->root.u.def.section->id].toc_off;
13552 bfd_put_64 (info->output_bfd, toc, loc + 8);
13557 rela.r_offset = (plt->output_section->vma
13558 + plt->output_offset
13559 + ent->plt.offset);
13560 loc = relplt->contents + (relplt->reloc_count++
13561 * sizeof (Elf64_External_Rela));
13562 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13567 rela.r_offset = (htab->elf.splt->output_section->vma
13568 + htab->elf.splt->output_offset
13569 + ent->plt.offset);
13570 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
13571 rela.r_addend = ent->addend;
13572 loc = (htab->elf.srelplt->contents
13573 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
13574 / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
13575 if (h->type == STT_GNU_IFUNC && is_static_defined (h))
13576 htab->maybe_local_ifunc_resolver = 1;
13577 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13581 if (!h->pointer_equality_needed)
13584 if (h->def_regular)
13587 s = htab->global_entry;
13588 if (s == NULL || s->size == 0)
13591 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
13592 if (ent->plt.offset != (bfd_vma) -1
13593 && ent->addend == 0)
13599 p = s->contents + h->root.u.def.value;
13600 plt = htab->elf.splt;
13601 if (!htab->elf.dynamic_sections_created
13602 || h->dynindx == -1)
13604 if (h->type == STT_GNU_IFUNC)
13605 plt = htab->elf.iplt;
13607 plt = htab->pltlocal;
13609 off = ent->plt.offset + plt->output_offset + plt->output_section->vma;
13610 off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
13612 if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
13614 info->callbacks->einfo
13615 (_("%P: linkage table error against `%pT'\n"),
13616 h->root.root.string);
13617 bfd_set_error (bfd_error_bad_value);
13618 htab->stub_error = TRUE;
13621 htab->stub_count[ppc_stub_global_entry - 1] += 1;
13622 if (htab->params->emit_stub_syms)
13624 size_t len = strlen (h->root.root.string);
13625 char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
13630 sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
13631 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
13634 if (h->root.type == bfd_link_hash_new)
13636 h->root.type = bfd_link_hash_defined;
13637 h->root.u.def.section = s;
13638 h->root.u.def.value = p - s->contents;
13639 h->ref_regular = 1;
13640 h->def_regular = 1;
13641 h->ref_regular_nonweak = 1;
13642 h->forced_local = 1;
13644 h->root.linker_def = 1;
13648 if (PPC_HA (off) != 0)
13650 bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
13653 bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
13655 bfd_put_32 (s->owner, MTCTR_R12, p);
13657 bfd_put_32 (s->owner, BCTR, p);
13663 /* Write PLT relocs for locals. */
13666 write_plt_relocs_for_local_syms (struct bfd_link_info *info)
13668 struct ppc_link_hash_table *htab = ppc_hash_table (info);
13671 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
13673 struct got_entry **lgot_ents, **end_lgot_ents;
13674 struct plt_entry **local_plt, **lplt, **end_local_plt;
13675 Elf_Internal_Shdr *symtab_hdr;
13676 bfd_size_type locsymcount;
13677 Elf_Internal_Sym *local_syms = NULL;
13678 struct plt_entry *ent;
13680 if (!is_ppc64_elf (ibfd))
13683 lgot_ents = elf_local_got_ents (ibfd);
13687 symtab_hdr = &elf_symtab_hdr (ibfd);
13688 locsymcount = symtab_hdr->sh_info;
13689 end_lgot_ents = lgot_ents + locsymcount;
13690 local_plt = (struct plt_entry **) end_lgot_ents;
13691 end_local_plt = local_plt + locsymcount;
13692 for (lplt = local_plt; lplt < end_local_plt; ++lplt)
13693 for (ent = *lplt; ent != NULL; ent = ent->next)
13694 if (ent->plt.offset != (bfd_vma) -1)
13696 Elf_Internal_Sym *sym;
13698 asection *plt, *relplt;
13702 if (!get_sym_h (NULL, &sym, &sym_sec, NULL, &local_syms,
13703 lplt - local_plt, ibfd))
13705 if (local_syms != NULL
13706 && symtab_hdr->contents != (unsigned char *) local_syms)
13711 val = sym->st_value + ent->addend;
13712 if (ELF_ST_TYPE (sym->st_info) != STT_GNU_IFUNC)
13713 val += PPC64_LOCAL_ENTRY_OFFSET (sym->st_other);
13714 if (sym_sec != NULL && sym_sec->output_section != NULL)
13715 val += sym_sec->output_offset + sym_sec->output_section->vma;
13717 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13719 htab->local_ifunc_resolver = 1;
13720 plt = htab->elf.iplt;
13721 relplt = htab->elf.irelplt;
13725 plt = htab->pltlocal;
13726 relplt = bfd_link_pic (info) ? htab->relpltlocal : NULL;
13729 if (relplt == NULL)
13731 loc = plt->contents + ent->plt.offset;
13732 bfd_put_64 (info->output_bfd, val, loc);
13735 bfd_vma toc = elf_gp (ibfd);
13736 bfd_put_64 (info->output_bfd, toc, loc + 8);
13741 Elf_Internal_Rela rela;
13742 rela.r_offset = (ent->plt.offset
13743 + plt->output_offset
13744 + plt->output_section->vma);
13745 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13748 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
13750 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13755 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_SLOT);
13757 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13759 rela.r_addend = val;
13760 loc = relplt->contents + (relplt->reloc_count++
13761 * sizeof (Elf64_External_Rela));
13762 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13766 if (local_syms != NULL
13767 && symtab_hdr->contents != (unsigned char *) local_syms)
13769 if (!info->keep_memory)
13772 symtab_hdr->contents = (unsigned char *) local_syms;
13778 /* Build all the stubs associated with the current output file.
13779 The stubs are kept in a hash table attached to the main linker
13780 hash table. This function is called via gldelf64ppc_finish. */
13783 ppc64_elf_build_stubs (struct bfd_link_info *info,
13786 struct ppc_link_hash_table *htab = ppc_hash_table (info);
13787 struct map_stub *group;
13788 asection *stub_sec;
13790 int stub_sec_count = 0;
13795 /* Allocate memory to hold the linker stubs. */
13796 for (group = htab->group; group != NULL; group = group->next)
13798 group->eh_size = 0;
13799 group->lr_restore = 0;
13800 if ((stub_sec = group->stub_sec) != NULL
13801 && stub_sec->size != 0)
13803 stub_sec->contents = bfd_zalloc (htab->params->stub_bfd,
13805 if (stub_sec->contents == NULL)
13807 stub_sec->size = 0;
13811 if (htab->glink != NULL && htab->glink->size != 0)
13816 /* Build the .glink plt call stub. */
13817 if (htab->params->emit_stub_syms)
13819 struct elf_link_hash_entry *h;
13820 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
13821 TRUE, FALSE, FALSE);
13824 if (h->root.type == bfd_link_hash_new)
13826 h->root.type = bfd_link_hash_defined;
13827 h->root.u.def.section = htab->glink;
13828 h->root.u.def.value = 8;
13829 h->ref_regular = 1;
13830 h->def_regular = 1;
13831 h->ref_regular_nonweak = 1;
13832 h->forced_local = 1;
13834 h->root.linker_def = 1;
13837 plt0 = (htab->elf.splt->output_section->vma
13838 + htab->elf.splt->output_offset
13840 if (info->emitrelocations)
13842 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
13845 r->r_offset = (htab->glink->output_offset
13846 + htab->glink->output_section->vma);
13847 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
13848 r->r_addend = plt0;
13850 p = htab->glink->contents;
13851 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
13852 bfd_put_64 (htab->glink->owner, plt0, p);
13856 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
13858 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13860 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13862 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13864 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
13866 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13868 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13870 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
13872 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13874 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
13879 bfd_put_32 (htab->glink->owner, MFLR_R0, p);
13881 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13883 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13885 bfd_put_32 (htab->glink->owner, STD_R2_0R1 + 24, p);
13887 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13889 bfd_put_32 (htab->glink->owner, MTLR_R0, p);
13891 bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
13893 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13895 bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
13897 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13899 bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
13901 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13903 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13906 bfd_put_32 (htab->glink->owner, BCTR, p);
13908 BFD_ASSERT (p == htab->glink->contents + GLINK_PLTRESOLVE_SIZE (htab));
13910 /* Build the .glink lazy link call stubs. */
13912 while (p < htab->glink->contents + htab->glink->size)
13918 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13923 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13925 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13930 bfd_put_32 (htab->glink->owner,
13931 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13937 /* Build .glink global entry stubs, and PLT relocs for globals. */
13938 elf_link_hash_traverse (&htab->elf, build_global_entry_stubs_and_plt, info);
13940 if (!write_plt_relocs_for_local_syms (info))
13943 if (htab->brlt != NULL && htab->brlt->size != 0)
13945 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13947 if (htab->brlt->contents == NULL)
13950 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13952 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13953 htab->relbrlt->size);
13954 if (htab->relbrlt->contents == NULL)
13958 /* Build the stubs as directed by the stub hash table. */
13959 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13961 for (group = htab->group; group != NULL; group = group->next)
13962 if (group->needs_save_res)
13963 group->stub_sec->size += htab->sfpr->size;
13965 if (htab->relbrlt != NULL)
13966 htab->relbrlt->reloc_count = 0;
13968 if (htab->params->plt_stub_align != 0)
13969 for (group = htab->group; group != NULL; group = group->next)
13970 if ((stub_sec = group->stub_sec) != NULL)
13972 int align = abs (htab->params->plt_stub_align);
13973 stub_sec->size = (stub_sec->size + (1 << align) - 1) & -(1 << align);
13976 for (group = htab->group; group != NULL; group = group->next)
13977 if (group->needs_save_res)
13979 stub_sec = group->stub_sec;
13980 memcpy (stub_sec->contents + stub_sec->size - htab->sfpr->size,
13981 htab->sfpr->contents, htab->sfpr->size);
13982 if (htab->params->emit_stub_syms)
13986 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13987 if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13992 if (htab->glink_eh_frame != NULL
13993 && htab->glink_eh_frame->size != 0)
13998 p = htab->glink_eh_frame->contents;
13999 p += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
14001 for (group = htab->group; group != NULL; group = group->next)
14002 if (group->eh_size != 0)
14004 /* Offset to stub section. */
14005 val = (group->stub_sec->output_section->vma
14006 + group->stub_sec->output_offset);
14007 val -= (htab->glink_eh_frame->output_section->vma
14008 + htab->glink_eh_frame->output_offset
14009 + (p + 8 - htab->glink_eh_frame->contents));
14010 if (val + 0x80000000 > 0xffffffff)
14013 (_("%s offset too large for .eh_frame sdata4 encoding"),
14014 group->stub_sec->name);
14017 bfd_put_32 (htab->elf.dynobj, val, p + 8);
14018 p += (group->eh_size + 17 + 3) & -4;
14020 if (htab->glink != NULL && htab->glink->size != 0)
14022 /* Offset to .glink. */
14023 val = (htab->glink->output_section->vma
14024 + htab->glink->output_offset
14026 val -= (htab->glink_eh_frame->output_section->vma
14027 + htab->glink_eh_frame->output_offset
14028 + (p + 8 - htab->glink_eh_frame->contents));
14029 if (val + 0x80000000 > 0xffffffff)
14032 (_("%s offset too large for .eh_frame sdata4 encoding"),
14033 htab->glink->name);
14036 bfd_put_32 (htab->elf.dynobj, val, p + 8);
14037 p += (24 + align - 1) & -align;
14041 for (group = htab->group; group != NULL; group = group->next)
14042 if ((stub_sec = group->stub_sec) != NULL)
14044 stub_sec_count += 1;
14045 if (stub_sec->rawsize != stub_sec->size
14046 && (htab->stub_iteration <= STUB_SHRINK_ITER
14047 || stub_sec->rawsize < stub_sec->size))
14053 htab->stub_error = TRUE;
14054 _bfd_error_handler (_("stubs don't match calculated size"));
14057 if (htab->stub_error)
14063 *stats = bfd_malloc (500);
14064 if (*stats == NULL)
14067 len = sprintf (*stats,
14068 ngettext ("linker stubs in %u group\n",
14069 "linker stubs in %u groups\n",
14072 sprintf (*stats + len, _(" branch %lu\n"
14073 " branch toc adj %lu\n"
14074 " branch notoc %lu\n"
14075 " branch both %lu\n"
14076 " long branch %lu\n"
14077 " long toc adj %lu\n"
14078 " long notoc %lu\n"
14081 " plt call save %lu\n"
14082 " plt call notoc %lu\n"
14083 " plt call both %lu\n"
14084 " global entry %lu"),
14085 htab->stub_count[ppc_stub_long_branch - 1],
14086 htab->stub_count[ppc_stub_long_branch_r2off - 1],
14087 htab->stub_count[ppc_stub_long_branch_notoc - 1],
14088 htab->stub_count[ppc_stub_long_branch_both - 1],
14089 htab->stub_count[ppc_stub_plt_branch - 1],
14090 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
14091 htab->stub_count[ppc_stub_plt_branch_notoc - 1],
14092 htab->stub_count[ppc_stub_plt_branch_both - 1],
14093 htab->stub_count[ppc_stub_plt_call - 1],
14094 htab->stub_count[ppc_stub_plt_call_r2save - 1],
14095 htab->stub_count[ppc_stub_plt_call_notoc - 1],
14096 htab->stub_count[ppc_stub_plt_call_both - 1],
14097 htab->stub_count[ppc_stub_global_entry - 1]);
14102 /* What to do when ld finds relocations against symbols defined in
14103 discarded sections. */
14105 static unsigned int
14106 ppc64_elf_action_discarded (asection *sec)
14108 if (strcmp (".opd", sec->name) == 0)
14111 if (strcmp (".toc", sec->name) == 0)
14114 if (strcmp (".toc1", sec->name) == 0)
14117 return _bfd_elf_default_action_discarded (sec);
14120 /* The RELOCATE_SECTION function is called by the ELF backend linker
14121 to handle the relocations for a section.
14123 The relocs are always passed as Rela structures; if the section
14124 actually uses Rel structures, the r_addend field will always be
14127 This function is responsible for adjust the section contents as
14128 necessary, and (if using Rela relocs and generating a
14129 relocatable output file) adjusting the reloc addend as
14132 This function does not have to worry about setting the reloc
14133 address or the reloc symbol index.
14135 LOCAL_SYMS is a pointer to the swapped in local symbols.
14137 LOCAL_SECTIONS is an array giving the section in the input file
14138 corresponding to the st_shndx field of each local symbol.
14140 The global hash table entry for the global symbols can be found
14141 via elf_sym_hashes (input_bfd).
14143 When generating relocatable output, this function must handle
14144 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
14145 going to be the section symbol corresponding to the output
14146 section, which means that the addend must be adjusted
14150 ppc64_elf_relocate_section (bfd *output_bfd,
14151 struct bfd_link_info *info,
14153 asection *input_section,
14154 bfd_byte *contents,
14155 Elf_Internal_Rela *relocs,
14156 Elf_Internal_Sym *local_syms,
14157 asection **local_sections)
14159 struct ppc_link_hash_table *htab;
14160 Elf_Internal_Shdr *symtab_hdr;
14161 struct elf_link_hash_entry **sym_hashes;
14162 Elf_Internal_Rela *rel;
14163 Elf_Internal_Rela *wrel;
14164 Elf_Internal_Rela *relend;
14165 Elf_Internal_Rela outrel;
14167 struct got_entry **local_got_ents;
14169 bfd_boolean ret = TRUE;
14170 bfd_boolean is_opd;
14171 /* Assume 'at' branch hints. */
14172 bfd_boolean is_isa_v2 = TRUE;
14173 bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
14175 /* Initialize howto table if needed. */
14176 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
14179 htab = ppc_hash_table (info);
14183 /* Don't relocate stub sections. */
14184 if (input_section->owner == htab->params->stub_bfd)
14187 if (!is_ppc64_elf (input_bfd))
14189 bfd_set_error (bfd_error_wrong_format);
14193 local_got_ents = elf_local_got_ents (input_bfd);
14194 TOCstart = elf_gp (output_bfd);
14195 symtab_hdr = &elf_symtab_hdr (input_bfd);
14196 sym_hashes = elf_sym_hashes (input_bfd);
14197 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
14199 rel = wrel = relocs;
14200 relend = relocs + input_section->reloc_count;
14201 for (; rel < relend; wrel++, rel++)
14203 enum elf_ppc64_reloc_type r_type;
14205 bfd_reloc_status_type r;
14206 Elf_Internal_Sym *sym;
14208 struct elf_link_hash_entry *h_elf;
14209 struct ppc_link_hash_entry *h;
14210 struct ppc_link_hash_entry *fdh;
14211 const char *sym_name;
14212 unsigned long r_symndx, toc_symndx;
14213 bfd_vma toc_addend;
14214 unsigned char tls_mask, tls_gd, tls_type;
14215 unsigned char sym_type;
14216 bfd_vma relocation;
14217 bfd_boolean unresolved_reloc, save_unresolved_reloc;
14218 bfd_boolean warned;
14219 enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
14222 struct ppc_stub_hash_entry *stub_entry;
14223 bfd_vma max_br_offset;
14225 Elf_Internal_Rela orig_rel;
14226 reloc_howto_type *howto;
14227 struct reloc_howto_struct alt_howto;
14234 r_type = ELF64_R_TYPE (rel->r_info);
14235 r_symndx = ELF64_R_SYM (rel->r_info);
14237 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
14238 symbol of the previous ADDR64 reloc. The symbol gives us the
14239 proper TOC base to use. */
14240 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
14242 && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
14244 r_symndx = ELF64_R_SYM (wrel[-1].r_info);
14250 unresolved_reloc = FALSE;
14253 if (r_symndx < symtab_hdr->sh_info)
14255 /* It's a local symbol. */
14256 struct _opd_sec_data *opd;
14258 sym = local_syms + r_symndx;
14259 sec = local_sections[r_symndx];
14260 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
14261 sym_type = ELF64_ST_TYPE (sym->st_info);
14262 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
14263 opd = get_opd_info (sec);
14264 if (opd != NULL && opd->adjust != NULL)
14266 long adjust = opd->adjust[OPD_NDX (sym->st_value
14272 /* If this is a relocation against the opd section sym
14273 and we have edited .opd, adjust the reloc addend so
14274 that ld -r and ld --emit-relocs output is correct.
14275 If it is a reloc against some other .opd symbol,
14276 then the symbol value will be adjusted later. */
14277 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
14278 rel->r_addend += adjust;
14280 relocation += adjust;
14286 bfd_boolean ignored;
14288 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
14289 r_symndx, symtab_hdr, sym_hashes,
14290 h_elf, sec, relocation,
14291 unresolved_reloc, warned, ignored);
14292 sym_name = h_elf->root.root.string;
14293 sym_type = h_elf->type;
14295 && sec->owner == output_bfd
14296 && strcmp (sec->name, ".opd") == 0)
14298 /* This is a symbol defined in a linker script. All
14299 such are defined in output sections, even those
14300 defined by simple assignment from a symbol defined in
14301 an input section. Transfer the symbol to an
14302 appropriate input .opd section, so that a branch to
14303 this symbol will be mapped to the location specified
14304 by the opd entry. */
14305 struct bfd_link_order *lo;
14306 for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
14307 if (lo->type == bfd_indirect_link_order)
14309 asection *isec = lo->u.indirect.section;
14310 if (h_elf->root.u.def.value >= isec->output_offset
14311 && h_elf->root.u.def.value < (isec->output_offset
14314 h_elf->root.u.def.value -= isec->output_offset;
14315 h_elf->root.u.def.section = isec;
14322 h = (struct ppc_link_hash_entry *) h_elf;
14324 if (sec != NULL && discarded_section (sec))
14326 _bfd_clear_contents (ppc64_elf_howto_table[r_type],
14327 input_bfd, input_section,
14328 contents, rel->r_offset);
14329 wrel->r_offset = rel->r_offset;
14331 wrel->r_addend = 0;
14333 /* For ld -r, remove relocations in debug sections against
14334 symbols defined in discarded sections. Not done for
14335 non-debug to preserve relocs in .eh_frame which the
14336 eh_frame editing code expects to be present. */
14337 if (bfd_link_relocatable (info)
14338 && (input_section->flags & SEC_DEBUGGING))
14344 if (bfd_link_relocatable (info))
14347 if (h != NULL && &h->elf == htab->elf.hgot)
14349 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
14350 sec = bfd_abs_section_ptr;
14351 unresolved_reloc = FALSE;
14354 /* TLS optimizations. Replace instruction sequences and relocs
14355 based on information we collected in tls_optimize. We edit
14356 RELOCS so that --emit-relocs will output something sensible
14357 for the final instruction stream. */
14362 tls_mask = h->tls_mask;
14363 else if (local_got_ents != NULL)
14365 struct plt_entry **local_plt = (struct plt_entry **)
14366 (local_got_ents + symtab_hdr->sh_info);
14367 unsigned char *lgot_masks = (unsigned char *)
14368 (local_plt + symtab_hdr->sh_info);
14369 tls_mask = lgot_masks[r_symndx];
14371 if (((tls_mask & TLS_TLS) == 0 || tls_mask == (TLS_TLS | TLS_MARK))
14372 && (r_type == R_PPC64_TLS
14373 || r_type == R_PPC64_TLSGD
14374 || r_type == R_PPC64_TLSLD))
14376 /* Check for toc tls entries. */
14377 unsigned char *toc_tls;
14379 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
14380 &local_syms, rel, input_bfd))
14384 tls_mask = *toc_tls;
14387 /* Check that tls relocs are used with tls syms, and non-tls
14388 relocs are used with non-tls syms. */
14389 if (r_symndx != STN_UNDEF
14390 && r_type != R_PPC64_NONE
14392 || h->elf.root.type == bfd_link_hash_defined
14393 || h->elf.root.type == bfd_link_hash_defweak)
14394 && IS_PPC64_TLS_RELOC (r_type) != (sym_type == STT_TLS))
14396 if ((tls_mask & TLS_TLS) != 0
14397 && (r_type == R_PPC64_TLS
14398 || r_type == R_PPC64_TLSGD
14399 || r_type == R_PPC64_TLSLD))
14400 /* R_PPC64_TLS is OK against a symbol in the TOC. */
14403 info->callbacks->einfo
14404 (!IS_PPC64_TLS_RELOC (r_type)
14405 /* xgettext:c-format */
14406 ? _("%H: %s used with TLS symbol `%pT'\n")
14407 /* xgettext:c-format */
14408 : _("%H: %s used with non-TLS symbol `%pT'\n"),
14409 input_bfd, input_section, rel->r_offset,
14410 ppc64_elf_howto_table[r_type]->name,
14414 /* Ensure reloc mapping code below stays sane. */
14415 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
14416 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
14417 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
14418 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
14419 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
14420 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
14421 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
14422 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
14423 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
14424 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
14432 case R_PPC64_LO_DS_OPT:
14433 insn = bfd_get_32 (input_bfd, contents + rel->r_offset - d_offset);
14434 if ((insn & (0x3f << 26)) != 58u << 26)
14436 insn += (14u << 26) - (58u << 26);
14437 bfd_put_32 (input_bfd, insn, contents + rel->r_offset - d_offset);
14438 r_type = R_PPC64_TOC16_LO;
14439 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14442 case R_PPC64_TOC16:
14443 case R_PPC64_TOC16_LO:
14444 case R_PPC64_TOC16_DS:
14445 case R_PPC64_TOC16_LO_DS:
14447 /* Check for toc tls entries. */
14448 unsigned char *toc_tls;
14451 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
14452 &local_syms, rel, input_bfd);
14458 tls_mask = *toc_tls;
14459 if (r_type == R_PPC64_TOC16_DS
14460 || r_type == R_PPC64_TOC16_LO_DS)
14462 if ((tls_mask & TLS_TLS) != 0
14463 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
14468 /* If we found a GD reloc pair, then we might be
14469 doing a GD->IE transition. */
14473 if ((tls_mask & TLS_TLS) != 0
14474 && (tls_mask & TLS_GD) == 0)
14477 else if (retval == 3)
14479 if ((tls_mask & TLS_TLS) != 0
14480 && (tls_mask & TLS_LD) == 0)
14488 case R_PPC64_GOT_TPREL16_HI:
14489 case R_PPC64_GOT_TPREL16_HA:
14490 if ((tls_mask & TLS_TLS) != 0
14491 && (tls_mask & TLS_TPREL) == 0)
14493 rel->r_offset -= d_offset;
14494 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14495 r_type = R_PPC64_NONE;
14496 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14500 case R_PPC64_GOT_TPREL16_DS:
14501 case R_PPC64_GOT_TPREL16_LO_DS:
14502 if ((tls_mask & TLS_TLS) != 0
14503 && (tls_mask & TLS_TPREL) == 0)
14506 insn = bfd_get_32 (input_bfd,
14507 contents + rel->r_offset - d_offset);
14509 insn |= 0x3c0d0000; /* addis 0,13,0 */
14510 bfd_put_32 (input_bfd, insn,
14511 contents + rel->r_offset - d_offset);
14512 r_type = R_PPC64_TPREL16_HA;
14513 if (toc_symndx != 0)
14515 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
14516 rel->r_addend = toc_addend;
14517 /* We changed the symbol. Start over in order to
14518 get h, sym, sec etc. right. */
14522 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14526 case R_PPC64_GOT_TPREL34:
14527 if ((tls_mask & TLS_TLS) != 0
14528 && (tls_mask & TLS_TPREL) == 0)
14530 /* pld ra,sym@got@tprel@pcrel -> paddi ra,r13,sym@tprel */
14531 pinsn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14533 pinsn |= bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14534 pinsn += ((2ULL << 56) + (-1ULL << 52)
14535 + (14ULL << 26) - (57ULL << 26) + (13ULL << 16));
14536 bfd_put_32 (input_bfd, pinsn >> 32,
14537 contents + rel->r_offset);
14538 bfd_put_32 (input_bfd, pinsn & 0xffffffff,
14539 contents + rel->r_offset + 4);
14540 r_type = R_PPC64_TPREL34;
14541 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14546 if ((tls_mask & TLS_TLS) != 0
14547 && (tls_mask & TLS_TPREL) == 0)
14549 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14550 insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
14553 if ((rel->r_offset & 3) == 0)
14555 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14556 /* Was PPC64_TLS which sits on insn boundary, now
14557 PPC64_TPREL16_LO which is at low-order half-word. */
14558 rel->r_offset += d_offset;
14559 r_type = R_PPC64_TPREL16_LO;
14560 if (toc_symndx != 0)
14562 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
14563 rel->r_addend = toc_addend;
14564 /* We changed the symbol. Start over in order to
14565 get h, sym, sec etc. right. */
14569 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14571 else if ((rel->r_offset & 3) == 1)
14573 /* For pcrel IE to LE we already have the full
14574 offset and thus don't need an addi here. A nop
14576 if ((insn & (0x3f << 26)) == 14 << 26)
14578 /* Extract regs from addi rt,ra,si. */
14579 unsigned int rt = (insn >> 21) & 0x1f;
14580 unsigned int ra = (insn >> 16) & 0x1f;
14585 /* Build or ra,rs,rb with rb==rs, ie. mr ra,rs. */
14586 insn = (rt << 16) | (ra << 21) | (ra << 11);
14587 insn |= (31u << 26) | (444u << 1);
14590 bfd_put_32 (input_bfd, insn, contents + rel->r_offset - 1);
14595 case R_PPC64_GOT_TLSGD16_HI:
14596 case R_PPC64_GOT_TLSGD16_HA:
14598 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
14602 case R_PPC64_GOT_TLSLD16_HI:
14603 case R_PPC64_GOT_TLSLD16_HA:
14604 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
14607 if ((tls_mask & tls_gd) != 0)
14608 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
14609 + R_PPC64_GOT_TPREL16_DS);
14612 rel->r_offset -= d_offset;
14613 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14614 r_type = R_PPC64_NONE;
14616 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14620 case R_PPC64_GOT_TLSGD16:
14621 case R_PPC64_GOT_TLSGD16_LO:
14623 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
14627 case R_PPC64_GOT_TLSLD16:
14628 case R_PPC64_GOT_TLSLD16_LO:
14629 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
14631 unsigned int insn1, insn2;
14634 offset = (bfd_vma) -1;
14635 /* If not using the newer R_PPC64_TLSGD/LD to mark
14636 __tls_get_addr calls, we must trust that the call
14637 stays with its arg setup insns, ie. that the next
14638 reloc is the __tls_get_addr call associated with
14639 the current reloc. Edit both insns. */
14640 if (input_section->has_tls_get_addr_call
14641 && rel + 1 < relend
14642 && branch_reloc_hash_match (input_bfd, rel + 1,
14643 htab->tls_get_addr,
14644 htab->tls_get_addr_fd))
14645 offset = rel[1].r_offset;
14646 /* We read the low GOT_TLS (or TOC16) insn because we
14647 need to keep the destination reg. It may be
14648 something other than the usual r3, and moved to r3
14649 before the call by intervening code. */
14650 insn1 = bfd_get_32 (input_bfd,
14651 contents + rel->r_offset - d_offset);
14652 if ((tls_mask & tls_gd) != 0)
14655 insn1 &= (0x1f << 21) | (0x1f << 16);
14656 insn1 |= 58 << 26; /* ld */
14657 insn2 = 0x7c636a14; /* add 3,3,13 */
14658 if (offset != (bfd_vma) -1)
14659 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14660 if (r_type == R_PPC64_TOC16
14661 || r_type == R_PPC64_TOC16_LO)
14662 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
14664 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 1)) & 1)
14665 + R_PPC64_GOT_TPREL16_DS);
14666 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14671 insn1 &= 0x1f << 21;
14672 insn1 |= 0x3c0d0000; /* addis r,13,0 */
14673 insn2 = 0x38630000; /* addi 3,3,0 */
14676 /* Was an LD reloc. */
14677 r_symndx = STN_UNDEF;
14678 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
14680 else if (toc_symndx != 0)
14682 r_symndx = toc_symndx;
14683 rel->r_addend = toc_addend;
14685 r_type = R_PPC64_TPREL16_HA;
14686 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14687 if (offset != (bfd_vma) -1)
14689 rel[1].r_info = ELF64_R_INFO (r_symndx,
14690 R_PPC64_TPREL16_LO);
14691 rel[1].r_offset = offset + d_offset;
14692 rel[1].r_addend = rel->r_addend;
14695 bfd_put_32 (input_bfd, insn1,
14696 contents + rel->r_offset - d_offset);
14697 if (offset != (bfd_vma) -1)
14699 bfd_put_32 (input_bfd, insn2, contents + offset);
14700 if (offset + 8 <= input_section->size)
14702 insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
14703 if (insn2 == LD_R2_0R1 + STK_TOC (htab))
14704 bfd_put_32 (input_bfd, NOP, contents + offset + 4);
14707 if ((tls_mask & tls_gd) == 0
14708 && (tls_gd == 0 || toc_symndx != 0))
14710 /* We changed the symbol. Start over in order
14711 to get h, sym, sec etc. right. */
14717 case R_PPC64_GOT_TLSGD34:
14718 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
14720 pinsn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14722 pinsn |= bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14723 if ((tls_mask & TLS_GDIE) != 0)
14725 /* IE, pla -> pld */
14726 pinsn += (-2ULL << 56) + (57ULL << 26) - (14ULL << 26);
14727 r_type = R_PPC64_GOT_TPREL34;
14731 /* LE, pla pcrel -> paddi r13 */
14732 pinsn += (-1ULL << 52) + (13ULL << 16);
14733 r_type = R_PPC64_TPREL34;
14735 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14736 bfd_put_32 (input_bfd, pinsn >> 32,
14737 contents + rel->r_offset);
14738 bfd_put_32 (input_bfd, pinsn & 0xffffffff,
14739 contents + rel->r_offset + 4);
14743 case R_PPC64_GOT_TLSLD34:
14744 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
14746 pinsn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14748 pinsn |= bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14749 pinsn += (-1ULL << 52) + (13ULL << 16);
14750 bfd_put_32 (input_bfd, pinsn >> 32,
14751 contents + rel->r_offset);
14752 bfd_put_32 (input_bfd, pinsn & 0xffffffff,
14753 contents + rel->r_offset + 4);
14754 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
14755 r_symndx = STN_UNDEF;
14756 r_type = R_PPC64_TPREL34;
14757 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14762 case R_PPC64_TLSGD:
14763 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0
14764 && rel + 1 < relend)
14766 unsigned int insn2;
14767 enum elf_ppc64_reloc_type r_type1 = ELF64_R_TYPE (rel[1].r_info);
14769 offset = rel->r_offset;
14770 if (is_plt_seq_reloc (r_type1))
14772 bfd_put_32 (output_bfd, NOP, contents + offset);
14773 if (r_type1 == R_PPC64_PLT_PCREL34
14774 || r_type1 == R_PPC64_PLT_PCREL34_NOTOC)
14775 bfd_put_32 (output_bfd, NOP, contents + offset + 4);
14776 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14780 if (ELF64_R_TYPE (rel[1].r_info) == R_PPC64_PLTCALL)
14781 bfd_put_32 (output_bfd, NOP, contents + offset + 4);
14783 if ((tls_mask & TLS_GDIE) != 0)
14786 r_type = R_PPC64_NONE;
14787 insn2 = 0x7c636a14; /* add 3,3,13 */
14792 if (toc_symndx != 0)
14794 r_symndx = toc_symndx;
14795 rel->r_addend = toc_addend;
14797 if (r_type1 == R_PPC64_REL24_NOTOC
14798 || r_type1 == R_PPC64_PLTCALL_NOTOC)
14800 r_type = R_PPC64_NONE;
14805 rel->r_offset = offset + d_offset;
14806 r_type = R_PPC64_TPREL16_LO;
14807 insn2 = 0x38630000; /* addi 3,3,0 */
14810 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14811 /* Zap the reloc on the _tls_get_addr call too. */
14812 BFD_ASSERT (offset == rel[1].r_offset);
14813 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14814 bfd_put_32 (input_bfd, insn2, contents + offset);
14815 if ((tls_mask & TLS_GDIE) == 0
14817 && r_type != R_PPC64_NONE)
14822 case R_PPC64_TLSLD:
14823 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0
14824 && rel + 1 < relend)
14826 unsigned int insn2;
14827 enum elf_ppc64_reloc_type r_type1 = ELF64_R_TYPE (rel[1].r_info);
14829 offset = rel->r_offset;
14830 if (is_plt_seq_reloc (r_type1))
14832 bfd_put_32 (output_bfd, NOP, contents + offset);
14833 if (r_type1 == R_PPC64_PLT_PCREL34
14834 || r_type1 == R_PPC64_PLT_PCREL34_NOTOC)
14835 bfd_put_32 (output_bfd, NOP, contents + offset + 4);
14836 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14840 if (ELF64_R_TYPE (rel[1].r_info) == R_PPC64_PLTCALL)
14841 bfd_put_32 (output_bfd, NOP, contents + offset + 4);
14843 if (r_type1 == R_PPC64_REL24_NOTOC
14844 || r_type1 == R_PPC64_PLTCALL_NOTOC)
14846 r_type = R_PPC64_NONE;
14851 rel->r_offset = offset + d_offset;
14852 r_symndx = STN_UNDEF;
14853 r_type = R_PPC64_TPREL16_LO;
14854 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
14855 insn2 = 0x38630000; /* addi 3,3,0 */
14857 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14858 /* Zap the reloc on the _tls_get_addr call too. */
14859 BFD_ASSERT (offset == rel[1].r_offset);
14860 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14861 bfd_put_32 (input_bfd, insn2, contents + offset);
14862 if (r_type != R_PPC64_NONE)
14867 case R_PPC64_DTPMOD64:
14868 if (rel + 1 < relend
14869 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
14870 && rel[1].r_offset == rel->r_offset + 8)
14872 if ((tls_mask & TLS_GD) == 0)
14874 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
14875 if ((tls_mask & TLS_GDIE) != 0)
14876 r_type = R_PPC64_TPREL64;
14879 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14880 r_type = R_PPC64_NONE;
14882 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14887 if ((tls_mask & TLS_LD) == 0)
14889 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14890 r_type = R_PPC64_NONE;
14891 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14896 case R_PPC64_TPREL64:
14897 if ((tls_mask & TLS_TPREL) == 0)
14899 r_type = R_PPC64_NONE;
14900 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14904 case R_PPC64_ENTRY:
14905 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
14906 if (!bfd_link_pic (info)
14907 && !info->traditional_format
14908 && relocation + 0x80008000 <= 0xffffffff)
14910 unsigned int insn1, insn2;
14912 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14913 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14914 if ((insn1 & ~0xfffc) == LD_R2_0R12
14915 && insn2 == ADD_R2_R2_R12)
14917 bfd_put_32 (input_bfd,
14918 LIS_R2 + PPC_HA (relocation),
14919 contents + rel->r_offset);
14920 bfd_put_32 (input_bfd,
14921 ADDI_R2_R2 + PPC_LO (relocation),
14922 contents + rel->r_offset + 4);
14927 relocation -= (rel->r_offset
14928 + input_section->output_offset
14929 + input_section->output_section->vma);
14930 if (relocation + 0x80008000 <= 0xffffffff)
14932 unsigned int insn1, insn2;
14934 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14935 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14936 if ((insn1 & ~0xfffc) == LD_R2_0R12
14937 && insn2 == ADD_R2_R2_R12)
14939 bfd_put_32 (input_bfd,
14940 ADDIS_R2_R12 + PPC_HA (relocation),
14941 contents + rel->r_offset);
14942 bfd_put_32 (input_bfd,
14943 ADDI_R2_R2 + PPC_LO (relocation),
14944 contents + rel->r_offset + 4);
14950 case R_PPC64_REL16_HA:
14951 /* If we are generating a non-PIC executable, edit
14952 . 0: addis 2,12,.TOC.-0b@ha
14953 . addi 2,2,.TOC.-0b@l
14954 used by ELFv2 global entry points to set up r2, to
14957 if .TOC. is in range. */
14958 if (!bfd_link_pic (info)
14959 && !info->traditional_format
14961 && rel->r_addend == d_offset
14962 && h != NULL && &h->elf == htab->elf.hgot
14963 && rel + 1 < relend
14964 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
14965 && rel[1].r_offset == rel->r_offset + 4
14966 && rel[1].r_addend == rel->r_addend + 4
14967 && relocation + 0x80008000 <= 0xffffffff)
14969 unsigned int insn1, insn2;
14970 offset = rel->r_offset - d_offset;
14971 insn1 = bfd_get_32 (input_bfd, contents + offset);
14972 insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
14973 if ((insn1 & 0xffff0000) == ADDIS_R2_R12
14974 && (insn2 & 0xffff0000) == ADDI_R2_R2)
14976 r_type = R_PPC64_ADDR16_HA;
14977 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14978 rel->r_addend -= d_offset;
14979 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
14980 rel[1].r_addend -= d_offset + 4;
14981 bfd_put_32 (input_bfd, LIS_R2, contents + offset);
14987 /* Handle other relocations that tweak non-addend part of insn. */
14989 max_br_offset = 1 << 25;
14990 addend = rel->r_addend;
14991 reloc_dest = DEST_NORMAL;
14997 case R_PPC64_TOCSAVE:
14998 if (relocation + addend == (rel->r_offset
14999 + input_section->output_offset
15000 + input_section->output_section->vma)
15001 && tocsave_find (htab, NO_INSERT,
15002 &local_syms, rel, input_bfd))
15004 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15006 || insn == CROR_151515 || insn == CROR_313131)
15007 bfd_put_32 (input_bfd,
15008 STD_R2_0R1 + STK_TOC (htab),
15009 contents + rel->r_offset);
15013 /* Branch taken prediction relocations. */
15014 case R_PPC64_ADDR14_BRTAKEN:
15015 case R_PPC64_REL14_BRTAKEN:
15016 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
15017 /* Fall through. */
15019 /* Branch not taken prediction relocations. */
15020 case R_PPC64_ADDR14_BRNTAKEN:
15021 case R_PPC64_REL14_BRNTAKEN:
15022 insn |= bfd_get_32 (input_bfd,
15023 contents + rel->r_offset) & ~(0x01 << 21);
15024 /* Fall through. */
15026 case R_PPC64_REL14:
15027 max_br_offset = 1 << 15;
15028 /* Fall through. */
15030 case R_PPC64_REL24:
15031 case R_PPC64_REL24_NOTOC:
15032 case R_PPC64_PLTCALL:
15033 case R_PPC64_PLTCALL_NOTOC:
15034 /* Calls to functions with a different TOC, such as calls to
15035 shared objects, need to alter the TOC pointer. This is
15036 done using a linkage stub. A REL24 branching to these
15037 linkage stubs needs to be followed by a nop, as the nop
15038 will be replaced with an instruction to restore the TOC
15043 && h->oh->is_func_descriptor)
15044 fdh = ppc_follow_link (h->oh);
15045 stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
15047 if ((r_type == R_PPC64_PLTCALL
15048 || r_type == R_PPC64_PLTCALL_NOTOC)
15049 && stub_entry != NULL
15050 && stub_entry->stub_type >= ppc_stub_plt_call
15051 && stub_entry->stub_type <= ppc_stub_plt_call_both)
15054 if (stub_entry != NULL
15055 && ((stub_entry->stub_type >= ppc_stub_plt_call
15056 && stub_entry->stub_type <= ppc_stub_plt_call_both)
15057 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
15058 || stub_entry->stub_type == ppc_stub_plt_branch_both
15059 || stub_entry->stub_type == ppc_stub_long_branch_r2off
15060 || stub_entry->stub_type == ppc_stub_long_branch_both))
15062 bfd_boolean can_plt_call = FALSE;
15064 if (stub_entry->stub_type == ppc_stub_plt_call
15066 && htab->params->plt_localentry0 != 0
15067 && is_elfv2_localentry0 (&h->elf))
15069 /* The function doesn't use or change r2. */
15070 can_plt_call = TRUE;
15072 else if (r_type == R_PPC64_REL24_NOTOC)
15074 /* NOTOC calls don't need to restore r2. */
15075 can_plt_call = TRUE;
15078 /* All of these stubs may modify r2, so there must be a
15079 branch and link followed by a nop. The nop is
15080 replaced by an insn to restore r2. */
15081 else if (rel->r_offset + 8 <= input_section->size)
15085 br = bfd_get_32 (input_bfd,
15086 contents + rel->r_offset);
15091 nop = bfd_get_32 (input_bfd,
15092 contents + rel->r_offset + 4);
15093 if (nop == LD_R2_0R1 + STK_TOC (htab))
15094 can_plt_call = TRUE;
15095 else if (nop == NOP
15096 || nop == CROR_151515
15097 || nop == CROR_313131)
15100 && (h == htab->tls_get_addr_fd
15101 || h == htab->tls_get_addr)
15102 && htab->params->tls_get_addr_opt)
15104 /* Special stub used, leave nop alone. */
15107 bfd_put_32 (input_bfd,
15108 LD_R2_0R1 + STK_TOC (htab),
15109 contents + rel->r_offset + 4);
15110 can_plt_call = TRUE;
15115 if (!can_plt_call && h != NULL)
15117 const char *name = h->elf.root.root.string;
15122 if (strncmp (name, "__libc_start_main", 17) == 0
15123 && (name[17] == 0 || name[17] == '@'))
15125 /* Allow crt1 branch to go via a toc adjusting
15126 stub. Other calls that never return could do
15127 the same, if we could detect such. */
15128 can_plt_call = TRUE;
15134 /* g++ as of 20130507 emits self-calls without a
15135 following nop. This is arguably wrong since we
15136 have conflicting information. On the one hand a
15137 global symbol and on the other a local call
15138 sequence, but don't error for this special case.
15139 It isn't possible to cheaply verify we have
15140 exactly such a call. Allow all calls to the same
15142 asection *code_sec = sec;
15144 if (get_opd_info (sec) != NULL)
15146 bfd_vma off = (relocation + addend
15147 - sec->output_section->vma
15148 - sec->output_offset);
15150 opd_entry_value (sec, off, &code_sec, NULL, FALSE);
15152 if (code_sec == input_section)
15153 can_plt_call = TRUE;
15158 if (stub_entry->stub_type >= ppc_stub_plt_call
15159 && stub_entry->stub_type <= ppc_stub_plt_call_both)
15160 info->callbacks->einfo
15161 /* xgettext:c-format */
15162 (_("%H: call to `%pT' lacks nop, can't restore toc; "
15163 "(plt call stub)\n"),
15164 input_bfd, input_section, rel->r_offset, sym_name);
15166 info->callbacks->einfo
15167 /* xgettext:c-format */
15168 (_("%H: call to `%pT' lacks nop, can't restore toc; "
15169 "(toc save/adjust stub)\n"),
15170 input_bfd, input_section, rel->r_offset, sym_name);
15172 bfd_set_error (bfd_error_bad_value);
15177 && stub_entry->stub_type >= ppc_stub_plt_call
15178 && stub_entry->stub_type <= ppc_stub_plt_call_both)
15179 unresolved_reloc = FALSE;
15182 if ((stub_entry == NULL
15183 || stub_entry->stub_type == ppc_stub_long_branch
15184 || stub_entry->stub_type == ppc_stub_plt_branch)
15185 && get_opd_info (sec) != NULL)
15187 /* The branch destination is the value of the opd entry. */
15188 bfd_vma off = (relocation + addend
15189 - sec->output_section->vma
15190 - sec->output_offset);
15191 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
15192 if (dest != (bfd_vma) -1)
15196 reloc_dest = DEST_OPD;
15200 /* If the branch is out of reach we ought to have a long
15202 from = (rel->r_offset
15203 + input_section->output_offset
15204 + input_section->output_section->vma);
15206 relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
15210 if (stub_entry != NULL
15211 && (stub_entry->stub_type == ppc_stub_long_branch
15212 || stub_entry->stub_type == ppc_stub_plt_branch)
15213 && (r_type == R_PPC64_ADDR14_BRTAKEN
15214 || r_type == R_PPC64_ADDR14_BRNTAKEN
15215 || (relocation + addend - from + max_br_offset
15216 < 2 * max_br_offset)))
15217 /* Don't use the stub if this branch is in range. */
15220 if (stub_entry != NULL
15221 && (stub_entry->stub_type == ppc_stub_long_branch_notoc
15222 || stub_entry->stub_type == ppc_stub_long_branch_both
15223 || stub_entry->stub_type == ppc_stub_plt_branch_notoc
15224 || stub_entry->stub_type == ppc_stub_plt_branch_both)
15225 && (r_type != R_PPC64_REL24_NOTOC
15226 || ((fdh ? fdh->elf.other : sym->st_other)
15227 & STO_PPC64_LOCAL_MASK) <= 1 << STO_PPC64_LOCAL_BIT)
15228 && (relocation + addend - from + max_br_offset
15229 < 2 * max_br_offset))
15232 if (stub_entry != NULL
15233 && (stub_entry->stub_type == ppc_stub_long_branch_r2off
15234 || stub_entry->stub_type == ppc_stub_long_branch_both
15235 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
15236 || stub_entry->stub_type == ppc_stub_plt_branch_both)
15237 && r_type == R_PPC64_REL24_NOTOC
15238 && (relocation + addend - from + max_br_offset
15239 < 2 * max_br_offset))
15242 if (stub_entry != NULL)
15244 /* Munge up the value and addend so that we call the stub
15245 rather than the procedure directly. */
15246 asection *stub_sec = stub_entry->group->stub_sec;
15248 if (stub_entry->stub_type == ppc_stub_save_res)
15249 relocation += (stub_sec->output_offset
15250 + stub_sec->output_section->vma
15251 + stub_sec->size - htab->sfpr->size
15252 - htab->sfpr->output_offset
15253 - htab->sfpr->output_section->vma);
15255 relocation = (stub_entry->stub_offset
15256 + stub_sec->output_offset
15257 + stub_sec->output_section->vma);
15259 reloc_dest = DEST_STUB;
15261 if (((stub_entry->stub_type == ppc_stub_plt_call
15262 && ALWAYS_EMIT_R2SAVE)
15263 || stub_entry->stub_type == ppc_stub_plt_call_r2save
15264 || stub_entry->stub_type == ppc_stub_plt_call_both)
15266 && (h == htab->tls_get_addr_fd
15267 || h == htab->tls_get_addr)
15268 && htab->params->tls_get_addr_opt)
15269 && rel + 1 < relend
15270 && rel[1].r_offset == rel->r_offset + 4
15271 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
15273 else if ((stub_entry->stub_type == ppc_stub_long_branch_both
15274 || stub_entry->stub_type == ppc_stub_plt_branch_both
15275 || stub_entry->stub_type == ppc_stub_plt_call_both)
15276 && r_type == R_PPC64_REL24_NOTOC)
15279 if (r_type == R_PPC64_REL24_NOTOC
15280 && (stub_entry->stub_type == ppc_stub_plt_call_notoc
15281 || stub_entry->stub_type == ppc_stub_plt_call_both))
15282 htab->notoc_plt = 1;
15289 /* Set 'a' bit. This is 0b00010 in BO field for branch
15290 on CR(BI) insns (BO == 001at or 011at), and 0b01000
15291 for branch on CTR insns (BO == 1a00t or 1a01t). */
15292 if ((insn & (0x14 << 21)) == (0x04 << 21))
15293 insn |= 0x02 << 21;
15294 else if ((insn & (0x14 << 21)) == (0x10 << 21))
15295 insn |= 0x08 << 21;
15301 /* Invert 'y' bit if not the default. */
15302 if ((bfd_signed_vma) (relocation + addend - from) < 0)
15303 insn ^= 0x01 << 21;
15306 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15309 /* NOP out calls to undefined weak functions.
15310 We can thus call a weak function without first
15311 checking whether the function is defined. */
15313 && h->elf.root.type == bfd_link_hash_undefweak
15314 && h->elf.dynindx == -1
15315 && (r_type == R_PPC64_REL24
15316 || r_type == R_PPC64_REL24_NOTOC)
15320 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
15325 case R_PPC64_GOT16_DS:
15326 from = TOCstart + htab->sec_info[input_section->id].toc_off;
15327 if (relocation + addend - from + 0x8000 < 0x10000
15328 && SYMBOL_REFERENCES_LOCAL (info, &h->elf))
15330 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15331 if ((insn & (0x3f << 26 | 0x3)) == 58u << 26 /* ld */)
15333 insn += (14u << 26) - (58u << 26);
15334 bfd_put_32 (input_bfd, insn, contents + (rel->r_offset & ~3));
15335 r_type = R_PPC64_TOC16;
15336 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
15341 case R_PPC64_GOT16_LO_DS:
15342 case R_PPC64_GOT16_HA:
15343 from = TOCstart + htab->sec_info[input_section->id].toc_off;
15344 if (relocation + addend - from + 0x80008000ULL < 0x100000000ULL
15345 && SYMBOL_REFERENCES_LOCAL (info, &h->elf))
15347 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15348 if ((insn & (0x3f << 26 | 0x3)) == 58u << 26 /* ld */)
15350 insn += (14u << 26) - (58u << 26);
15351 bfd_put_32 (input_bfd, insn, contents + (rel->r_offset & ~3));
15352 r_type = R_PPC64_TOC16_LO;
15353 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
15355 else if ((insn & (0x3f << 26)) == 15u << 26 /* addis */)
15357 r_type = R_PPC64_TOC16_HA;
15358 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
15363 case R_PPC64_GOT_PCREL34:
15364 from = (rel->r_offset
15365 + input_section->output_section->vma
15366 + input_section->output_offset);
15367 if (relocation - from + (1ULL << 33) < 1ULL << 34
15368 && SYMBOL_REFERENCES_LOCAL (info, &h->elf))
15370 offset = rel->r_offset;
15371 pinsn = bfd_get_32 (input_bfd, contents + offset);
15373 pinsn |= bfd_get_32 (input_bfd, contents + offset + 4);
15374 if ((pinsn & ((-1ULL << 50) | (63ULL << 26)))
15375 == ((1ULL << 58) | (1ULL << 52) | (57ULL << 26) /* pld */))
15377 /* Replace with paddi. */
15378 pinsn += (2ULL << 56) + (14ULL << 26) - (57ULL << 26);
15379 r_type = R_PPC64_PCREL34;
15380 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
15381 bfd_put_32 (input_bfd, pinsn >> 32, contents + offset);
15382 bfd_put_32 (input_bfd, pinsn, contents + offset + 4);
15388 case R_PPC64_PCREL34:
15389 if (SYMBOL_REFERENCES_LOCAL (info, &h->elf))
15391 offset = rel->r_offset;
15392 pinsn = bfd_get_32 (input_bfd, contents + offset);
15394 pinsn |= bfd_get_32 (input_bfd, contents + offset + 4);
15395 if ((pinsn & ((-1ULL << 50) | (63ULL << 26)))
15396 == ((1ULL << 58) | (2ULL << 56) | (1ULL << 52)
15397 | (14ULL << 26) /* paddi */))
15400 if (rel + 1 < relend
15401 && rel[1].r_offset == offset
15402 && rel[1].r_info == ELF64_R_INFO (0, R_PPC64_PCREL_OPT))
15404 bfd_vma off2 = rel[1].r_addend;
15406 /* zero means next insn. */
15409 if (off2 + 4 <= input_section->size)
15412 bfd_signed_vma addend_off;
15413 pinsn2 = bfd_get_32 (input_bfd, contents + off2);
15415 if ((pinsn2 & (63ULL << 58)) == 1ULL << 58)
15417 if (xlate_pcrel_opt (&pinsn, &pinsn2, &addend_off))
15419 addend += addend_off;
15420 rel->r_addend = addend;
15421 bfd_put_32 (input_bfd, pinsn >> 32,
15422 contents + offset);
15423 bfd_put_32 (input_bfd, pinsn,
15424 contents + offset + 4);
15425 bfd_put_32 (input_bfd, pinsn2 >> 32,
15436 save_unresolved_reloc = unresolved_reloc;
15440 /* xgettext:c-format */
15441 _bfd_error_handler (_("%pB: %s unsupported"),
15442 input_bfd, ppc64_elf_howto_table[r_type]->name);
15444 bfd_set_error (bfd_error_bad_value);
15450 case R_PPC64_TLSGD:
15451 case R_PPC64_TLSLD:
15452 case R_PPC64_TOCSAVE:
15453 case R_PPC64_GNU_VTINHERIT:
15454 case R_PPC64_GNU_VTENTRY:
15455 case R_PPC64_ENTRY:
15456 case R_PPC64_PCREL_OPT:
15459 /* GOT16 relocations. Like an ADDR16 using the symbol's
15460 address in the GOT as relocation value instead of the
15461 symbol's value itself. Also, create a GOT entry for the
15462 symbol and put the symbol value there. */
15463 case R_PPC64_GOT_TLSGD16:
15464 case R_PPC64_GOT_TLSGD16_LO:
15465 case R_PPC64_GOT_TLSGD16_HI:
15466 case R_PPC64_GOT_TLSGD16_HA:
15467 case R_PPC64_GOT_TLSGD34:
15468 tls_type = TLS_TLS | TLS_GD;
15471 case R_PPC64_GOT_TLSLD16:
15472 case R_PPC64_GOT_TLSLD16_LO:
15473 case R_PPC64_GOT_TLSLD16_HI:
15474 case R_PPC64_GOT_TLSLD16_HA:
15475 case R_PPC64_GOT_TLSLD34:
15476 tls_type = TLS_TLS | TLS_LD;
15479 case R_PPC64_GOT_TPREL16_DS:
15480 case R_PPC64_GOT_TPREL16_LO_DS:
15481 case R_PPC64_GOT_TPREL16_HI:
15482 case R_PPC64_GOT_TPREL16_HA:
15483 case R_PPC64_GOT_TPREL34:
15484 tls_type = TLS_TLS | TLS_TPREL;
15487 case R_PPC64_GOT_DTPREL16_DS:
15488 case R_PPC64_GOT_DTPREL16_LO_DS:
15489 case R_PPC64_GOT_DTPREL16_HI:
15490 case R_PPC64_GOT_DTPREL16_HA:
15491 case R_PPC64_GOT_DTPREL34:
15492 tls_type = TLS_TLS | TLS_DTPREL;
15495 case R_PPC64_GOT16:
15496 case R_PPC64_GOT16_LO:
15497 case R_PPC64_GOT16_HI:
15498 case R_PPC64_GOT16_HA:
15499 case R_PPC64_GOT16_DS:
15500 case R_PPC64_GOT16_LO_DS:
15501 case R_PPC64_GOT_PCREL34:
15504 /* Relocation is to the entry for this symbol in the global
15509 unsigned long indx = 0;
15510 struct got_entry *ent;
15511 bfd_vma sym_addend = orig_rel.r_addend;
15513 if (r_type == R_PPC64_GOT_PCREL34
15514 || r_type == R_PPC64_GOT_TLSGD34
15515 || r_type == R_PPC64_GOT_TLSLD34
15516 || r_type == R_PPC64_GOT_TPREL34
15517 || r_type == R_PPC64_GOT_DTPREL34)
15520 if (tls_type == (TLS_TLS | TLS_LD)
15522 || !h->elf.def_dynamic))
15523 ent = ppc64_tlsld_got (input_bfd);
15528 if (!htab->elf.dynamic_sections_created
15529 || h->elf.dynindx == -1
15530 || SYMBOL_REFERENCES_LOCAL (info, &h->elf)
15531 || UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf))
15532 /* This is actually a static link, or it is a
15533 -Bsymbolic link and the symbol is defined
15534 locally, or the symbol was forced to be local
15535 because of a version file. */
15539 indx = h->elf.dynindx;
15540 unresolved_reloc = FALSE;
15542 ent = h->elf.got.glist;
15546 if (local_got_ents == NULL)
15548 ent = local_got_ents[r_symndx];
15551 for (; ent != NULL; ent = ent->next)
15552 if (ent->addend == sym_addend
15553 && ent->owner == input_bfd
15554 && ent->tls_type == tls_type)
15560 if (ent->is_indirect)
15561 ent = ent->got.ent;
15562 offp = &ent->got.offset;
15563 got = ppc64_elf_tdata (ent->owner)->got;
15567 /* The offset must always be a multiple of 8. We use the
15568 least significant bit to record whether we have already
15569 processed this entry. */
15571 if ((off & 1) != 0)
15575 /* Generate relocs for the dynamic linker, except in
15576 the case of TLSLD where we'll use one entry per
15584 ? h->elf.type == STT_GNU_IFUNC
15585 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
15588 relgot = htab->elf.irelplt;
15590 htab->local_ifunc_resolver = 1;
15591 else if (is_static_defined (&h->elf))
15592 htab->maybe_local_ifunc_resolver = 1;
15595 || (bfd_link_pic (info)
15597 || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf)
15598 || (tls_type == (TLS_TLS | TLS_LD)
15599 && !h->elf.def_dynamic))
15600 && !(tls_type == (TLS_TLS | TLS_TPREL)
15601 && bfd_link_executable (info)
15602 && SYMBOL_REFERENCES_LOCAL (info, &h->elf))))
15603 relgot = ppc64_elf_tdata (ent->owner)->relgot;
15604 if (relgot != NULL)
15606 outrel.r_offset = (got->output_section->vma
15607 + got->output_offset
15609 outrel.r_addend = sym_addend;
15610 if (tls_type & (TLS_LD | TLS_GD))
15612 outrel.r_addend = 0;
15613 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
15614 if (tls_type == (TLS_TLS | TLS_GD))
15616 loc = relgot->contents;
15617 loc += (relgot->reloc_count++
15618 * sizeof (Elf64_External_Rela));
15619 bfd_elf64_swap_reloca_out (output_bfd,
15621 outrel.r_offset += 8;
15622 outrel.r_addend = sym_addend;
15624 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
15627 else if (tls_type == (TLS_TLS | TLS_DTPREL))
15628 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
15629 else if (tls_type == (TLS_TLS | TLS_TPREL))
15630 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
15631 else if (indx != 0)
15632 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
15636 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15638 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
15640 /* Write the .got section contents for the sake
15642 loc = got->contents + off;
15643 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
15647 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
15649 outrel.r_addend += relocation;
15650 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
15652 if (htab->elf.tls_sec == NULL)
15653 outrel.r_addend = 0;
15655 outrel.r_addend -= htab->elf.tls_sec->vma;
15658 loc = relgot->contents;
15659 loc += (relgot->reloc_count++
15660 * sizeof (Elf64_External_Rela));
15661 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
15664 /* Init the .got section contents here if we're not
15665 emitting a reloc. */
15668 relocation += sym_addend;
15671 if (htab->elf.tls_sec == NULL)
15675 if (tls_type & TLS_LD)
15678 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
15679 if (tls_type & TLS_TPREL)
15680 relocation += DTP_OFFSET - TP_OFFSET;
15683 if (tls_type & (TLS_GD | TLS_LD))
15685 bfd_put_64 (output_bfd, relocation,
15686 got->contents + off + 8);
15690 bfd_put_64 (output_bfd, relocation,
15691 got->contents + off);
15695 if (off >= (bfd_vma) -2)
15698 relocation = got->output_section->vma + got->output_offset + off;
15699 if (!(r_type == R_PPC64_GOT_PCREL34
15700 || r_type == R_PPC64_GOT_TLSGD34
15701 || r_type == R_PPC64_GOT_TLSLD34
15702 || r_type == R_PPC64_GOT_TPREL34
15703 || r_type == R_PPC64_GOT_DTPREL34))
15704 addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
15708 case R_PPC64_PLT16_HA:
15709 case R_PPC64_PLT16_HI:
15710 case R_PPC64_PLT16_LO:
15711 case R_PPC64_PLT16_LO_DS:
15712 case R_PPC64_PLT_PCREL34:
15713 case R_PPC64_PLT_PCREL34_NOTOC:
15714 case R_PPC64_PLT32:
15715 case R_PPC64_PLT64:
15716 case R_PPC64_PLTSEQ:
15717 case R_PPC64_PLTSEQ_NOTOC:
15718 case R_PPC64_PLTCALL:
15719 case R_PPC64_PLTCALL_NOTOC:
15720 /* Relocation is to the entry for this symbol in the
15721 procedure linkage table. */
15722 unresolved_reloc = TRUE;
15724 struct plt_entry **plt_list = NULL;
15726 plt_list = &h->elf.plt.plist;
15727 else if (local_got_ents != NULL)
15729 struct plt_entry **local_plt = (struct plt_entry **)
15730 (local_got_ents + symtab_hdr->sh_info);
15731 plt_list = local_plt + r_symndx;
15735 struct plt_entry *ent;
15736 bfd_vma sym_addend = orig_rel.r_addend;
15738 if (r_type == R_PPC64_PLT_PCREL34
15739 || r_type == R_PPC64_PLT_PCREL34_NOTOC)
15742 for (ent = *plt_list; ent != NULL; ent = ent->next)
15743 if (ent->plt.offset != (bfd_vma) -1
15744 && ent->addend == sym_addend)
15749 plt = htab->elf.splt;
15750 if (!htab->elf.dynamic_sections_created
15752 || h->elf.dynindx == -1)
15755 ? h->elf.type == STT_GNU_IFUNC
15756 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15757 plt = htab->elf.iplt;
15759 plt = htab->pltlocal;
15761 relocation = (plt->output_section->vma
15762 + plt->output_offset
15763 + ent->plt.offset);
15764 if (r_type == R_PPC64_PLT16_HA
15765 || r_type == R_PPC64_PLT16_HI
15766 || r_type == R_PPC64_PLT16_LO
15767 || r_type == R_PPC64_PLT16_LO_DS)
15769 got = (elf_gp (output_bfd)
15770 + htab->sec_info[input_section->id].toc_off);
15773 if (r_type != R_PPC64_PLT_PCREL34
15774 && r_type != R_PPC64_PLT_PCREL34_NOTOC)
15776 unresolved_reloc = FALSE;
15784 /* Relocation value is TOC base. */
15785 relocation = TOCstart;
15786 if (r_symndx == STN_UNDEF)
15787 relocation += htab->sec_info[input_section->id].toc_off;
15788 else if (unresolved_reloc)
15790 else if (sec != NULL && sec->id < htab->sec_info_arr_size)
15791 relocation += htab->sec_info[sec->id].toc_off;
15793 unresolved_reloc = TRUE;
15796 /* TOC16 relocs. We want the offset relative to the TOC base,
15797 which is the address of the start of the TOC plus 0x8000.
15798 The TOC consists of sections .got, .toc, .tocbss, and .plt,
15800 case R_PPC64_TOC16:
15801 case R_PPC64_TOC16_LO:
15802 case R_PPC64_TOC16_HI:
15803 case R_PPC64_TOC16_DS:
15804 case R_PPC64_TOC16_LO_DS:
15805 case R_PPC64_TOC16_HA:
15806 addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
15809 /* Relocate against the beginning of the section. */
15810 case R_PPC64_SECTOFF:
15811 case R_PPC64_SECTOFF_LO:
15812 case R_PPC64_SECTOFF_HI:
15813 case R_PPC64_SECTOFF_DS:
15814 case R_PPC64_SECTOFF_LO_DS:
15815 case R_PPC64_SECTOFF_HA:
15817 addend -= sec->output_section->vma;
15820 case R_PPC64_REL16:
15821 case R_PPC64_REL16_LO:
15822 case R_PPC64_REL16_HI:
15823 case R_PPC64_REL16_HA:
15824 case R_PPC64_REL16_HIGH:
15825 case R_PPC64_REL16_HIGHA:
15826 case R_PPC64_REL16_HIGHER:
15827 case R_PPC64_REL16_HIGHERA:
15828 case R_PPC64_REL16_HIGHEST:
15829 case R_PPC64_REL16_HIGHESTA:
15830 case R_PPC64_REL16_HIGHER34:
15831 case R_PPC64_REL16_HIGHERA34:
15832 case R_PPC64_REL16_HIGHEST34:
15833 case R_PPC64_REL16_HIGHESTA34:
15834 case R_PPC64_REL16DX_HA:
15835 case R_PPC64_REL14:
15836 case R_PPC64_REL14_BRNTAKEN:
15837 case R_PPC64_REL14_BRTAKEN:
15838 case R_PPC64_REL24:
15839 case R_PPC64_REL24_NOTOC:
15840 case R_PPC64_PCREL34:
15841 case R_PPC64_PCREL28:
15844 case R_PPC64_TPREL16:
15845 case R_PPC64_TPREL16_LO:
15846 case R_PPC64_TPREL16_HI:
15847 case R_PPC64_TPREL16_HA:
15848 case R_PPC64_TPREL16_DS:
15849 case R_PPC64_TPREL16_LO_DS:
15850 case R_PPC64_TPREL16_HIGH:
15851 case R_PPC64_TPREL16_HIGHA:
15852 case R_PPC64_TPREL16_HIGHER:
15853 case R_PPC64_TPREL16_HIGHERA:
15854 case R_PPC64_TPREL16_HIGHEST:
15855 case R_PPC64_TPREL16_HIGHESTA:
15856 case R_PPC64_TPREL34:
15858 && h->elf.root.type == bfd_link_hash_undefweak
15859 && h->elf.dynindx == -1)
15861 /* Make this relocation against an undefined weak symbol
15862 resolve to zero. This is really just a tweak, since
15863 code using weak externs ought to check that they are
15864 defined before using them. */
15865 bfd_byte *p = contents + rel->r_offset - d_offset;
15867 insn = bfd_get_32 (input_bfd, p);
15868 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
15870 bfd_put_32 (input_bfd, insn, p);
15873 if (htab->elf.tls_sec != NULL)
15874 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
15875 /* The TPREL16 relocs shouldn't really be used in shared
15876 libs or with non-local symbols as that will result in
15877 DT_TEXTREL being set, but support them anyway. */
15880 case R_PPC64_DTPREL16:
15881 case R_PPC64_DTPREL16_LO:
15882 case R_PPC64_DTPREL16_HI:
15883 case R_PPC64_DTPREL16_HA:
15884 case R_PPC64_DTPREL16_DS:
15885 case R_PPC64_DTPREL16_LO_DS:
15886 case R_PPC64_DTPREL16_HIGH:
15887 case R_PPC64_DTPREL16_HIGHA:
15888 case R_PPC64_DTPREL16_HIGHER:
15889 case R_PPC64_DTPREL16_HIGHERA:
15890 case R_PPC64_DTPREL16_HIGHEST:
15891 case R_PPC64_DTPREL16_HIGHESTA:
15892 case R_PPC64_DTPREL34:
15893 if (htab->elf.tls_sec != NULL)
15894 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
15897 case R_PPC64_ADDR64_LOCAL:
15898 addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
15903 case R_PPC64_DTPMOD64:
15908 case R_PPC64_TPREL64:
15909 if (htab->elf.tls_sec != NULL)
15910 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
15913 case R_PPC64_DTPREL64:
15914 if (htab->elf.tls_sec != NULL)
15915 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
15916 /* Fall through. */
15918 /* Relocations that may need to be propagated if this is a
15920 case R_PPC64_REL30:
15921 case R_PPC64_REL32:
15922 case R_PPC64_REL64:
15923 case R_PPC64_ADDR14:
15924 case R_PPC64_ADDR14_BRNTAKEN:
15925 case R_PPC64_ADDR14_BRTAKEN:
15926 case R_PPC64_ADDR16:
15927 case R_PPC64_ADDR16_DS:
15928 case R_PPC64_ADDR16_HA:
15929 case R_PPC64_ADDR16_HI:
15930 case R_PPC64_ADDR16_HIGH:
15931 case R_PPC64_ADDR16_HIGHA:
15932 case R_PPC64_ADDR16_HIGHER:
15933 case R_PPC64_ADDR16_HIGHERA:
15934 case R_PPC64_ADDR16_HIGHEST:
15935 case R_PPC64_ADDR16_HIGHESTA:
15936 case R_PPC64_ADDR16_LO:
15937 case R_PPC64_ADDR16_LO_DS:
15938 case R_PPC64_ADDR16_HIGHER34:
15939 case R_PPC64_ADDR16_HIGHERA34:
15940 case R_PPC64_ADDR16_HIGHEST34:
15941 case R_PPC64_ADDR16_HIGHESTA34:
15942 case R_PPC64_ADDR24:
15943 case R_PPC64_ADDR32:
15944 case R_PPC64_ADDR64:
15945 case R_PPC64_UADDR16:
15946 case R_PPC64_UADDR32:
15947 case R_PPC64_UADDR64:
15949 case R_PPC64_D34_LO:
15950 case R_PPC64_D34_HI30:
15951 case R_PPC64_D34_HA30:
15954 if ((input_section->flags & SEC_ALLOC) == 0)
15957 if (NO_OPD_RELOCS && is_opd)
15960 if (bfd_link_pic (info)
15962 || h->dyn_relocs != NULL)
15963 && ((h != NULL && pc_dynrelocs (h))
15964 || must_be_dyn_reloc (info, r_type)))
15966 ? h->dyn_relocs != NULL
15967 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
15969 bfd_boolean skip, relocate;
15974 /* When generating a dynamic object, these relocations
15975 are copied into the output file to be resolved at run
15981 out_off = _bfd_elf_section_offset (output_bfd, info,
15982 input_section, rel->r_offset);
15983 if (out_off == (bfd_vma) -1)
15985 else if (out_off == (bfd_vma) -2)
15986 skip = TRUE, relocate = TRUE;
15987 out_off += (input_section->output_section->vma
15988 + input_section->output_offset);
15989 outrel.r_offset = out_off;
15990 outrel.r_addend = rel->r_addend;
15992 /* Optimize unaligned reloc use. */
15993 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
15994 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
15995 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
15996 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
15997 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
15998 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
15999 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
16000 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
16001 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
16004 memset (&outrel, 0, sizeof outrel);
16005 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
16007 && r_type != R_PPC64_TOC)
16009 indx = h->elf.dynindx;
16010 BFD_ASSERT (indx != -1);
16011 outrel.r_info = ELF64_R_INFO (indx, r_type);
16015 /* This symbol is local, or marked to become local,
16016 or this is an opd section reloc which must point
16017 at a local function. */
16018 outrel.r_addend += relocation;
16019 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
16021 if (is_opd && h != NULL)
16023 /* Lie about opd entries. This case occurs
16024 when building shared libraries and we
16025 reference a function in another shared
16026 lib. The same thing happens for a weak
16027 definition in an application that's
16028 overridden by a strong definition in a
16029 shared lib. (I believe this is a generic
16030 bug in binutils handling of weak syms.)
16031 In these cases we won't use the opd
16032 entry in this lib. */
16033 unresolved_reloc = FALSE;
16036 && r_type == R_PPC64_ADDR64
16038 ? h->elf.type == STT_GNU_IFUNC
16039 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
16040 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
16043 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
16045 /* We need to relocate .opd contents for ld.so.
16046 Prelink also wants simple and consistent rules
16047 for relocs. This make all RELATIVE relocs have
16048 *r_offset equal to r_addend. */
16055 ? h->elf.type == STT_GNU_IFUNC
16056 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
16058 info->callbacks->einfo
16059 /* xgettext:c-format */
16060 (_("%H: %s for indirect "
16061 "function `%pT' unsupported\n"),
16062 input_bfd, input_section, rel->r_offset,
16063 ppc64_elf_howto_table[r_type]->name,
16067 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
16069 else if (sec == NULL || sec->owner == NULL)
16071 bfd_set_error (bfd_error_bad_value);
16076 asection *osec = sec->output_section;
16078 if ((osec->flags & SEC_THREAD_LOCAL) != 0)
16080 /* TLS symbol values are relative to the
16081 TLS segment. Dynamic relocations for
16082 local TLS symbols therefore can't be
16083 reduced to a relocation against their
16084 section symbol because it holds the
16085 address of the section, not a value
16086 relative to the TLS segment. We could
16087 change the .tdata dynamic section symbol
16088 to be zero value but STN_UNDEF works
16089 and is used elsewhere, eg. for TPREL64
16090 GOT relocs against local TLS symbols. */
16091 osec = htab->elf.tls_sec;
16096 indx = elf_section_data (osec)->dynindx;
16099 if ((osec->flags & SEC_READONLY) == 0
16100 && htab->elf.data_index_section != NULL)
16101 osec = htab->elf.data_index_section;
16103 osec = htab->elf.text_index_section;
16104 indx = elf_section_data (osec)->dynindx;
16106 BFD_ASSERT (indx != 0);
16109 /* We are turning this relocation into one
16110 against a section symbol, so subtract out
16111 the output section's address but not the
16112 offset of the input section in the output
16114 outrel.r_addend -= osec->vma;
16117 outrel.r_info = ELF64_R_INFO (indx, r_type);
16121 sreloc = elf_section_data (input_section)->sreloc;
16123 ? h->elf.type == STT_GNU_IFUNC
16124 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
16126 sreloc = htab->elf.irelplt;
16128 htab->local_ifunc_resolver = 1;
16129 else if (is_static_defined (&h->elf))
16130 htab->maybe_local_ifunc_resolver = 1;
16132 if (sreloc == NULL)
16135 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
16138 loc = sreloc->contents;
16139 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
16140 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
16142 /* If this reloc is against an external symbol, it will
16143 be computed at runtime, so there's no need to do
16144 anything now. However, for the sake of prelink ensure
16145 that the section contents are a known value. */
16148 unresolved_reloc = FALSE;
16149 /* The value chosen here is quite arbitrary as ld.so
16150 ignores section contents except for the special
16151 case of .opd where the contents might be accessed
16152 before relocation. Choose zero, as that won't
16153 cause reloc overflow. */
16156 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
16157 to improve backward compatibility with older
16159 if (r_type == R_PPC64_ADDR64)
16160 addend = outrel.r_addend;
16161 /* Adjust pc_relative relocs to have zero in *r_offset. */
16162 else if (ppc64_elf_howto_table[r_type]->pc_relative)
16163 addend = outrel.r_offset;
16169 case R_PPC64_GLOB_DAT:
16170 case R_PPC64_JMP_SLOT:
16171 case R_PPC64_JMP_IREL:
16172 case R_PPC64_RELATIVE:
16173 /* We shouldn't ever see these dynamic relocs in relocatable
16175 /* Fall through. */
16177 case R_PPC64_PLTGOT16:
16178 case R_PPC64_PLTGOT16_DS:
16179 case R_PPC64_PLTGOT16_HA:
16180 case R_PPC64_PLTGOT16_HI:
16181 case R_PPC64_PLTGOT16_LO:
16182 case R_PPC64_PLTGOT16_LO_DS:
16183 case R_PPC64_PLTREL32:
16184 case R_PPC64_PLTREL64:
16185 /* These ones haven't been implemented yet. */
16187 info->callbacks->einfo
16188 /* xgettext:c-format */
16189 (_("%P: %pB: %s is not supported for `%pT'\n"),
16191 ppc64_elf_howto_table[r_type]->name, sym_name);
16193 bfd_set_error (bfd_error_invalid_operation);
16198 /* Multi-instruction sequences that access the TOC can be
16199 optimized, eg. addis ra,r2,0; addi rb,ra,x;
16200 to nop; addi rb,r2,x; */
16206 case R_PPC64_GOT_TLSLD16_HI:
16207 case R_PPC64_GOT_TLSGD16_HI:
16208 case R_PPC64_GOT_TPREL16_HI:
16209 case R_PPC64_GOT_DTPREL16_HI:
16210 case R_PPC64_GOT16_HI:
16211 case R_PPC64_TOC16_HI:
16212 /* These relocs would only be useful if building up an
16213 offset to later add to r2, perhaps in an indexed
16214 addressing mode instruction. Don't try to optimize.
16215 Unfortunately, the possibility of someone building up an
16216 offset like this or even with the HA relocs, means that
16217 we need to check the high insn when optimizing the low
16221 case R_PPC64_PLTCALL_NOTOC:
16222 if (!unresolved_reloc)
16223 htab->notoc_plt = 1;
16224 /* Fall through. */
16225 case R_PPC64_PLTCALL:
16226 if (unresolved_reloc)
16228 /* No plt entry. Make this into a direct call. */
16229 bfd_byte *p = contents + rel->r_offset;
16230 insn = bfd_get_32 (input_bfd, p);
16232 bfd_put_32 (input_bfd, B_DOT | insn, p);
16233 if (r_type == R_PPC64_PLTCALL)
16234 bfd_put_32 (input_bfd, NOP, p + 4);
16235 unresolved_reloc = save_unresolved_reloc;
16236 r_type = R_PPC64_REL24;
16240 case R_PPC64_PLTSEQ_NOTOC:
16241 case R_PPC64_PLTSEQ:
16242 if (unresolved_reloc)
16244 unresolved_reloc = FALSE;
16249 case R_PPC64_PLT_PCREL34_NOTOC:
16250 if (!unresolved_reloc)
16251 htab->notoc_plt = 1;
16252 /* Fall through. */
16253 case R_PPC64_PLT_PCREL34:
16254 if (unresolved_reloc)
16256 bfd_byte *p = contents + rel->r_offset;
16257 bfd_put_32 (input_bfd, PNOP >> 32, p);
16258 bfd_put_32 (input_bfd, PNOP, p + 4);
16259 unresolved_reloc = FALSE;
16264 case R_PPC64_PLT16_HA:
16265 if (unresolved_reloc)
16267 unresolved_reloc = FALSE;
16270 /* Fall through. */
16271 case R_PPC64_GOT_TLSLD16_HA:
16272 case R_PPC64_GOT_TLSGD16_HA:
16273 case R_PPC64_GOT_TPREL16_HA:
16274 case R_PPC64_GOT_DTPREL16_HA:
16275 case R_PPC64_GOT16_HA:
16276 case R_PPC64_TOC16_HA:
16277 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
16278 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
16282 p = contents + (rel->r_offset & ~3);
16283 bfd_put_32 (input_bfd, NOP, p);
16288 case R_PPC64_PLT16_LO:
16289 case R_PPC64_PLT16_LO_DS:
16290 if (unresolved_reloc)
16292 unresolved_reloc = FALSE;
16295 /* Fall through. */
16296 case R_PPC64_GOT_TLSLD16_LO:
16297 case R_PPC64_GOT_TLSGD16_LO:
16298 case R_PPC64_GOT_TPREL16_LO_DS:
16299 case R_PPC64_GOT_DTPREL16_LO_DS:
16300 case R_PPC64_GOT16_LO:
16301 case R_PPC64_GOT16_LO_DS:
16302 case R_PPC64_TOC16_LO:
16303 case R_PPC64_TOC16_LO_DS:
16304 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
16305 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
16307 bfd_byte *p = contents + (rel->r_offset & ~3);
16308 insn = bfd_get_32 (input_bfd, p);
16309 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
16311 /* Transform addic to addi when we change reg. */
16312 insn &= ~((0x3f << 26) | (0x1f << 16));
16313 insn |= (14u << 26) | (2 << 16);
16317 insn &= ~(0x1f << 16);
16320 bfd_put_32 (input_bfd, insn, p);
16324 case R_PPC64_TPREL16_HA:
16325 if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
16327 bfd_byte *p = contents + (rel->r_offset & ~3);
16328 insn = bfd_get_32 (input_bfd, p);
16329 if ((insn & ((0x3f << 26) | 0x1f << 16))
16330 != ((15u << 26) | (13 << 16)) /* addis rt,13,imm */)
16331 /* xgettext:c-format */
16332 info->callbacks->minfo
16333 (_("%H: warning: %s unexpected insn %#x.\n"),
16334 input_bfd, input_section, rel->r_offset,
16335 ppc64_elf_howto_table[r_type]->name, insn);
16338 bfd_put_32 (input_bfd, NOP, p);
16344 case R_PPC64_TPREL16_LO:
16345 case R_PPC64_TPREL16_LO_DS:
16346 if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
16348 bfd_byte *p = contents + (rel->r_offset & ~3);
16349 insn = bfd_get_32 (input_bfd, p);
16350 insn &= ~(0x1f << 16);
16352 bfd_put_32 (input_bfd, insn, p);
16357 /* Do any further special processing. */
16363 case R_PPC64_REL16_HA:
16364 case R_PPC64_REL16_HIGHA:
16365 case R_PPC64_REL16_HIGHERA:
16366 case R_PPC64_REL16_HIGHESTA:
16367 case R_PPC64_REL16DX_HA:
16368 case R_PPC64_ADDR16_HA:
16369 case R_PPC64_ADDR16_HIGHA:
16370 case R_PPC64_ADDR16_HIGHERA:
16371 case R_PPC64_ADDR16_HIGHESTA:
16372 case R_PPC64_TOC16_HA:
16373 case R_PPC64_SECTOFF_HA:
16374 case R_PPC64_TPREL16_HA:
16375 case R_PPC64_TPREL16_HIGHA:
16376 case R_PPC64_TPREL16_HIGHERA:
16377 case R_PPC64_TPREL16_HIGHESTA:
16378 case R_PPC64_DTPREL16_HA:
16379 case R_PPC64_DTPREL16_HIGHA:
16380 case R_PPC64_DTPREL16_HIGHERA:
16381 case R_PPC64_DTPREL16_HIGHESTA:
16382 /* It's just possible that this symbol is a weak symbol
16383 that's not actually defined anywhere. In that case,
16384 'sec' would be NULL, and we should leave the symbol
16385 alone (it will be set to zero elsewhere in the link). */
16388 /* Fall through. */
16390 case R_PPC64_GOT16_HA:
16391 case R_PPC64_PLTGOT16_HA:
16392 case R_PPC64_PLT16_HA:
16393 case R_PPC64_GOT_TLSGD16_HA:
16394 case R_PPC64_GOT_TLSLD16_HA:
16395 case R_PPC64_GOT_TPREL16_HA:
16396 case R_PPC64_GOT_DTPREL16_HA:
16397 /* Add 0x10000 if sign bit in 0:15 is set.
16398 Bits 0:15 are not used. */
16402 case R_PPC64_D34_HA30:
16403 case R_PPC64_ADDR16_HIGHERA34:
16404 case R_PPC64_ADDR16_HIGHESTA34:
16405 case R_PPC64_REL16_HIGHERA34:
16406 case R_PPC64_REL16_HIGHESTA34:
16408 addend += 1ULL << 33;
16411 case R_PPC64_ADDR16_DS:
16412 case R_PPC64_ADDR16_LO_DS:
16413 case R_PPC64_GOT16_DS:
16414 case R_PPC64_GOT16_LO_DS:
16415 case R_PPC64_PLT16_LO_DS:
16416 case R_PPC64_SECTOFF_DS:
16417 case R_PPC64_SECTOFF_LO_DS:
16418 case R_PPC64_TOC16_DS:
16419 case R_PPC64_TOC16_LO_DS:
16420 case R_PPC64_PLTGOT16_DS:
16421 case R_PPC64_PLTGOT16_LO_DS:
16422 case R_PPC64_GOT_TPREL16_DS:
16423 case R_PPC64_GOT_TPREL16_LO_DS:
16424 case R_PPC64_GOT_DTPREL16_DS:
16425 case R_PPC64_GOT_DTPREL16_LO_DS:
16426 case R_PPC64_TPREL16_DS:
16427 case R_PPC64_TPREL16_LO_DS:
16428 case R_PPC64_DTPREL16_DS:
16429 case R_PPC64_DTPREL16_LO_DS:
16430 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
16432 /* If this reloc is against an lq, lxv, or stxv insn, then
16433 the value must be a multiple of 16. This is somewhat of
16434 a hack, but the "correct" way to do this by defining _DQ
16435 forms of all the _DS relocs bloats all reloc switches in
16436 this file. It doesn't make much sense to use these
16437 relocs in data, so testing the insn should be safe. */
16438 if ((insn & (0x3f << 26)) == (56u << 26)
16439 || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
16441 relocation += addend;
16442 addend = insn & (mask ^ 3);
16443 if ((relocation & mask) != 0)
16445 relocation ^= relocation & mask;
16446 info->callbacks->einfo
16447 /* xgettext:c-format */
16448 (_("%H: error: %s not a multiple of %u\n"),
16449 input_bfd, input_section, rel->r_offset,
16450 ppc64_elf_howto_table[r_type]->name,
16452 bfd_set_error (bfd_error_bad_value);
16459 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
16460 because such sections are not SEC_ALLOC and thus ld.so will
16461 not process them. */
16462 howto = ppc64_elf_howto_table[(int) r_type];
16463 if (unresolved_reloc
16464 && !((input_section->flags & SEC_DEBUGGING) != 0
16465 && h->elf.def_dynamic)
16466 && _bfd_elf_section_offset (output_bfd, info, input_section,
16467 rel->r_offset) != (bfd_vma) -1)
16469 info->callbacks->einfo
16470 /* xgettext:c-format */
16471 (_("%H: unresolvable %s against `%pT'\n"),
16472 input_bfd, input_section, rel->r_offset,
16474 h->elf.root.root.string);
16478 /* 16-bit fields in insns mostly have signed values, but a
16479 few insns have 16-bit unsigned values. Really, we should
16480 have different reloc types. */
16481 if (howto->complain_on_overflow != complain_overflow_dont
16482 && howto->dst_mask == 0xffff
16483 && (input_section->flags & SEC_CODE) != 0)
16485 enum complain_overflow complain = complain_overflow_signed;
16487 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
16488 if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
16489 complain = complain_overflow_bitfield;
16490 else if (howto->rightshift == 0
16491 ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
16492 || (insn & (0x3f << 26)) == 24u << 26 /* ori */
16493 || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
16494 : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
16495 || (insn & (0x3f << 26)) == 25u << 26 /* oris */
16496 || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
16497 complain = complain_overflow_unsigned;
16498 if (howto->complain_on_overflow != complain)
16500 alt_howto = *howto;
16501 alt_howto.complain_on_overflow = complain;
16502 howto = &alt_howto;
16508 /* Split field relocs aren't handled by _bfd_final_link_relocate. */
16510 case R_PPC64_D34_LO:
16511 case R_PPC64_D34_HI30:
16512 case R_PPC64_D34_HA30:
16513 case R_PPC64_PCREL34:
16514 case R_PPC64_GOT_PCREL34:
16515 case R_PPC64_TPREL34:
16516 case R_PPC64_DTPREL34:
16517 case R_PPC64_GOT_TLSGD34:
16518 case R_PPC64_GOT_TLSLD34:
16519 case R_PPC64_GOT_TPREL34:
16520 case R_PPC64_GOT_DTPREL34:
16521 case R_PPC64_PLT_PCREL34:
16522 case R_PPC64_PLT_PCREL34_NOTOC:
16524 case R_PPC64_PCREL28:
16525 if (rel->r_offset + 8 > input_section->size)
16526 r = bfd_reloc_outofrange;
16529 relocation += addend;
16530 if (howto->pc_relative)
16531 relocation -= (rel->r_offset
16532 + input_section->output_offset
16533 + input_section->output_section->vma);
16534 relocation >>= howto->rightshift;
16536 pinsn = bfd_get_32 (input_bfd, contents + rel->r_offset);
16538 pinsn |= bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
16540 pinsn &= ~howto->dst_mask;
16541 pinsn |= (((relocation << 16) | (relocation & 0xffff))
16542 & howto->dst_mask);
16543 bfd_put_32 (input_bfd, pinsn >> 32, contents + rel->r_offset);
16544 bfd_put_32 (input_bfd, pinsn, contents + rel->r_offset + 4);
16546 if (howto->complain_on_overflow == complain_overflow_signed
16547 && (relocation + (1ULL << (howto->bitsize - 1))
16548 >= 1ULL << howto->bitsize))
16549 r = bfd_reloc_overflow;
16553 case R_PPC64_REL16DX_HA:
16554 if (rel->r_offset + 4 > input_section->size)
16555 r = bfd_reloc_outofrange;
16558 relocation += addend;
16559 relocation -= (rel->r_offset
16560 + input_section->output_offset
16561 + input_section->output_section->vma);
16562 relocation = (bfd_signed_vma) relocation >> 16;
16563 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
16565 insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
16566 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
16568 if (relocation + 0x8000 > 0xffff)
16569 r = bfd_reloc_overflow;
16574 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
16575 contents, rel->r_offset,
16576 relocation, addend);
16579 if (r != bfd_reloc_ok)
16581 char *more_info = NULL;
16582 const char *reloc_name = howto->name;
16584 if (reloc_dest != DEST_NORMAL)
16586 more_info = bfd_malloc (strlen (reloc_name) + 8);
16587 if (more_info != NULL)
16589 strcpy (more_info, reloc_name);
16590 strcat (more_info, (reloc_dest == DEST_OPD
16591 ? " (OPD)" : " (stub)"));
16592 reloc_name = more_info;
16596 if (r == bfd_reloc_overflow)
16598 /* On code like "if (foo) foo();" don't report overflow
16599 on a branch to zero when foo is undefined. */
16601 && (reloc_dest == DEST_STUB
16603 && (h->elf.root.type == bfd_link_hash_undefweak
16604 || h->elf.root.type == bfd_link_hash_undefined)
16605 && is_branch_reloc (r_type))))
16606 info->callbacks->reloc_overflow (info, &h->elf.root,
16607 sym_name, reloc_name,
16609 input_bfd, input_section,
16614 info->callbacks->einfo
16615 /* xgettext:c-format */
16616 (_("%H: %s against `%pT': error %d\n"),
16617 input_bfd, input_section, rel->r_offset,
16618 reloc_name, sym_name, (int) r);
16621 if (more_info != NULL)
16631 Elf_Internal_Shdr *rel_hdr;
16632 size_t deleted = rel - wrel;
16634 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
16635 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
16636 if (rel_hdr->sh_size == 0)
16638 /* It is too late to remove an empty reloc section. Leave
16640 ??? What is wrong with an empty section??? */
16641 rel_hdr->sh_size = rel_hdr->sh_entsize;
16644 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
16645 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
16646 input_section->reloc_count -= deleted;
16649 /* If we're emitting relocations, then shortly after this function
16650 returns, reloc offsets and addends for this section will be
16651 adjusted. Worse, reloc symbol indices will be for the output
16652 file rather than the input. Save a copy of the relocs for
16653 opd_entry_value. */
16654 if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
16657 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
16658 rel = bfd_alloc (input_bfd, amt);
16659 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
16660 ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
16663 memcpy (rel, relocs, amt);
16668 /* Adjust the value of any local symbols in opd sections. */
16671 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
16672 const char *name ATTRIBUTE_UNUSED,
16673 Elf_Internal_Sym *elfsym,
16674 asection *input_sec,
16675 struct elf_link_hash_entry *h)
16677 struct _opd_sec_data *opd;
16684 opd = get_opd_info (input_sec);
16685 if (opd == NULL || opd->adjust == NULL)
16688 value = elfsym->st_value - input_sec->output_offset;
16689 if (!bfd_link_relocatable (info))
16690 value -= input_sec->output_section->vma;
16692 adjust = opd->adjust[OPD_NDX (value)];
16696 elfsym->st_value += adjust;
16700 /* Finish up dynamic symbol handling. We set the contents of various
16701 dynamic sections here. */
16704 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
16705 struct bfd_link_info *info,
16706 struct elf_link_hash_entry *h,
16707 Elf_Internal_Sym *sym)
16709 struct ppc_link_hash_table *htab;
16710 struct plt_entry *ent;
16712 htab = ppc_hash_table (info);
16716 if (!htab->opd_abi && !h->def_regular)
16717 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
16718 if (ent->plt.offset != (bfd_vma) -1)
16720 /* Mark the symbol as undefined, rather than as
16721 defined in glink. Leave the value if there were
16722 any relocations where pointer equality matters
16723 (this is a clue for the dynamic linker, to make
16724 function pointer comparisons work between an
16725 application and shared library), otherwise set it
16727 sym->st_shndx = SHN_UNDEF;
16728 if (!h->pointer_equality_needed)
16730 else if (!h->ref_regular_nonweak)
16732 /* This breaks function pointer comparisons, but
16733 that is better than breaking tests for a NULL
16734 function pointer. */
16742 /* This symbol needs a copy reloc. Set it up. */
16743 Elf_Internal_Rela rela;
16747 if (h->dynindx == -1
16748 || (h->root.type != bfd_link_hash_defined
16749 && h->root.type != bfd_link_hash_defweak)
16750 || htab->elf.srelbss == NULL
16751 || htab->elf.sreldynrelro == NULL)
16754 rela.r_offset = (h->root.u.def.value
16755 + h->root.u.def.section->output_section->vma
16756 + h->root.u.def.section->output_offset);
16757 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
16759 if (h->root.u.def.section == htab->elf.sdynrelro)
16760 srel = htab->elf.sreldynrelro;
16762 srel = htab->elf.srelbss;
16763 loc = srel->contents;
16764 loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
16765 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
16771 /* Used to decide how to sort relocs in an optimal manner for the
16772 dynamic linker, before writing them out. */
16774 static enum elf_reloc_type_class
16775 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
16776 const asection *rel_sec,
16777 const Elf_Internal_Rela *rela)
16779 enum elf_ppc64_reloc_type r_type;
16780 struct ppc_link_hash_table *htab = ppc_hash_table (info);
16782 if (rel_sec == htab->elf.irelplt)
16783 return reloc_class_ifunc;
16785 r_type = ELF64_R_TYPE (rela->r_info);
16788 case R_PPC64_RELATIVE:
16789 return reloc_class_relative;
16790 case R_PPC64_JMP_SLOT:
16791 return reloc_class_plt;
16793 return reloc_class_copy;
16795 return reloc_class_normal;
16799 /* Finish up the dynamic sections. */
16802 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
16803 struct bfd_link_info *info)
16805 struct ppc_link_hash_table *htab;
16809 htab = ppc_hash_table (info);
16813 dynobj = htab->elf.dynobj;
16814 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
16816 if (htab->elf.dynamic_sections_created)
16818 Elf64_External_Dyn *dyncon, *dynconend;
16820 if (sdyn == NULL || htab->elf.sgot == NULL)
16823 dyncon = (Elf64_External_Dyn *) sdyn->contents;
16824 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
16825 for (; dyncon < dynconend; dyncon++)
16827 Elf_Internal_Dyn dyn;
16830 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
16837 case DT_PPC64_GLINK:
16839 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16840 /* We stupidly defined DT_PPC64_GLINK to be the start
16841 of glink rather than the first entry point, which is
16842 what ld.so needs, and now have a bigger stub to
16843 support automatic multiple TOCs. */
16844 dyn.d_un.d_ptr += GLINK_PLTRESOLVE_SIZE (htab) - 8 * 4;
16848 s = bfd_get_section_by_name (output_bfd, ".opd");
16851 dyn.d_un.d_ptr = s->vma;
16855 if ((htab->do_multi_toc && htab->multi_toc_needed)
16856 || htab->notoc_plt)
16857 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
16858 if (htab->has_plt_localentry0)
16859 dyn.d_un.d_val |= PPC64_OPT_LOCALENTRY;
16862 case DT_PPC64_OPDSZ:
16863 s = bfd_get_section_by_name (output_bfd, ".opd");
16866 dyn.d_un.d_val = s->size;
16870 s = htab->elf.splt;
16871 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16875 s = htab->elf.srelplt;
16876 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16880 dyn.d_un.d_val = htab->elf.srelplt->size;
16884 if (htab->local_ifunc_resolver)
16885 info->callbacks->einfo
16886 (_("%X%P: text relocations and GNU indirect "
16887 "functions will result in a segfault at runtime\n"));
16888 else if (htab->maybe_local_ifunc_resolver)
16889 info->callbacks->einfo
16890 (_("%P: warning: text relocations and GNU indirect "
16891 "functions may result in a segfault at runtime\n"));
16895 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
16899 if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0
16900 && htab->elf.sgot->output_section != bfd_abs_section_ptr)
16902 /* Fill in the first entry in the global offset table.
16903 We use it to hold the link-time TOCbase. */
16904 bfd_put_64 (output_bfd,
16905 elf_gp (output_bfd) + TOC_BASE_OFF,
16906 htab->elf.sgot->contents);
16908 /* Set .got entry size. */
16909 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize
16913 if (htab->elf.splt != NULL && htab->elf.splt->size != 0
16914 && htab->elf.splt->output_section != bfd_abs_section_ptr)
16916 /* Set .plt entry size. */
16917 elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
16918 = PLT_ENTRY_SIZE (htab);
16921 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
16922 brlt ourselves if emitrelocations. */
16923 if (htab->brlt != NULL
16924 && htab->brlt->reloc_count != 0
16925 && !_bfd_elf_link_output_relocs (output_bfd,
16927 elf_section_data (htab->brlt)->rela.hdr,
16928 elf_section_data (htab->brlt)->relocs,
16932 if (htab->glink != NULL
16933 && htab->glink->reloc_count != 0
16934 && !_bfd_elf_link_output_relocs (output_bfd,
16936 elf_section_data (htab->glink)->rela.hdr,
16937 elf_section_data (htab->glink)->relocs,
16942 if (htab->glink_eh_frame != NULL
16943 && htab->glink_eh_frame->size != 0
16944 && htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
16945 && !_bfd_elf_write_section_eh_frame (output_bfd, info,
16946 htab->glink_eh_frame,
16947 htab->glink_eh_frame->contents))
16950 /* We need to handle writing out multiple GOT sections ourselves,
16951 since we didn't add them to DYNOBJ. We know dynobj is the first
16953 while ((dynobj = dynobj->link.next) != NULL)
16957 if (!is_ppc64_elf (dynobj))
16960 s = ppc64_elf_tdata (dynobj)->got;
16963 && s->output_section != bfd_abs_section_ptr
16964 && !bfd_set_section_contents (output_bfd, s->output_section,
16965 s->contents, s->output_offset,
16968 s = ppc64_elf_tdata (dynobj)->relgot;
16971 && s->output_section != bfd_abs_section_ptr
16972 && !bfd_set_section_contents (output_bfd, s->output_section,
16973 s->contents, s->output_offset,
16981 #include "elf64-target.h"
16983 /* FreeBSD support */
16985 #undef TARGET_LITTLE_SYM
16986 #undef TARGET_LITTLE_NAME
16988 #undef TARGET_BIG_SYM
16989 #define TARGET_BIG_SYM powerpc_elf64_fbsd_vec
16990 #undef TARGET_BIG_NAME
16991 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
16994 #define ELF_OSABI ELFOSABI_FREEBSD
16997 #define elf64_bed elf64_powerpc_fbsd_bed
16999 #include "elf64-target.h"