1 /* PowerPC64-specific support for 64-bit ELF.
2 Copyright (C) 1999-2021 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 /* All users of this file have bfd_octets_per_byte (abfd, sec) == 1. */
39 #define OCTETS_PER_BYTE(ABFD, SEC) 1
41 static bfd_reloc_status_type ppc64_elf_ha_reloc
42 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
43 static bfd_reloc_status_type ppc64_elf_branch_reloc
44 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
45 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
46 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
47 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
48 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
49 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
50 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
51 static bfd_reloc_status_type ppc64_elf_toc_reloc
52 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
53 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
54 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
55 static bfd_reloc_status_type ppc64_elf_toc64_reloc
56 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
57 static bfd_reloc_status_type ppc64_elf_prefix_reloc
58 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
59 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
60 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
61 static bfd_vma opd_entry_value
62 (asection
*, bfd_vma
, asection
**, bfd_vma
*, bfd_boolean
);
64 #define TARGET_LITTLE_SYM powerpc_elf64_le_vec
65 #define TARGET_LITTLE_NAME "elf64-powerpcle"
66 #define TARGET_BIG_SYM powerpc_elf64_vec
67 #define TARGET_BIG_NAME "elf64-powerpc"
68 #define ELF_ARCH bfd_arch_powerpc
69 #define ELF_TARGET_ID PPC64_ELF_DATA
70 #define ELF_MACHINE_CODE EM_PPC64
71 #define ELF_MAXPAGESIZE 0x10000
72 #define ELF_COMMONPAGESIZE 0x1000
73 #define ELF_RELROPAGESIZE ELF_MAXPAGESIZE
74 #define elf_info_to_howto ppc64_elf_info_to_howto
76 #define elf_backend_want_got_sym 0
77 #define elf_backend_want_plt_sym 0
78 #define elf_backend_plt_alignment 3
79 #define elf_backend_plt_not_loaded 1
80 #define elf_backend_got_header_size 8
81 #define elf_backend_want_dynrelro 1
82 #define elf_backend_can_gc_sections 1
83 #define elf_backend_can_refcount 1
84 #define elf_backend_rela_normal 1
85 #define elf_backend_dtrel_excludes_plt 1
86 #define elf_backend_default_execstack 0
88 #define bfd_elf64_mkobject ppc64_elf_mkobject
89 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
90 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
91 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
92 #define bfd_elf64_bfd_print_private_bfd_data ppc64_elf_print_private_bfd_data
93 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
94 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
95 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
96 #define bfd_elf64_bfd_link_just_syms ppc64_elf_link_just_syms
97 #define bfd_elf64_bfd_gc_sections ppc64_elf_gc_sections
99 #define elf_backend_object_p ppc64_elf_object_p
100 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
101 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
102 #define elf_backend_write_core_note ppc64_elf_write_core_note
103 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
104 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
105 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
106 #define elf_backend_check_directives ppc64_elf_before_check_relocs
107 #define elf_backend_notice_as_needed ppc64_elf_notice_as_needed
108 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
109 #define elf_backend_check_relocs ppc64_elf_check_relocs
110 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
111 #define elf_backend_gc_keep ppc64_elf_gc_keep
112 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
113 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
114 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
115 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
116 #define elf_backend_maybe_function_sym ppc64_elf_maybe_function_sym
117 #define elf_backend_always_size_sections ppc64_elf_edit
118 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
119 #define elf_backend_hash_symbol ppc64_elf_hash_symbol
120 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
121 #define elf_backend_action_discarded ppc64_elf_action_discarded
122 #define elf_backend_relocate_section ppc64_elf_relocate_section
123 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
124 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
125 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
126 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
127 #define elf_backend_special_sections ppc64_elf_special_sections
128 #define elf_backend_section_flags ppc64_elf_section_flags
129 #define elf_backend_merge_symbol_attribute ppc64_elf_merge_symbol_attribute
130 #define elf_backend_merge_symbol ppc64_elf_merge_symbol
131 #define elf_backend_get_reloc_section bfd_get_section_by_name
133 /* The name of the dynamic interpreter. This is put in the .interp
135 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
137 /* The size in bytes of an entry in the procedure linkage table. */
138 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
139 #define LOCAL_PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 16 : 8)
141 /* The initial size of the plt reserved for the dynamic linker. */
142 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
144 /* Offsets to some stack save slots. */
146 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
147 /* This one is dodgy. ELFv2 does not have a linker word, so use the
148 CR save slot. Used only by optimised __tls_get_addr call stub,
149 relying on __tls_get_addr_opt not saving CR.. */
150 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
152 /* TOC base pointers offset from start of TOC. */
153 #define TOC_BASE_OFF 0x8000
154 /* TOC base alignment. */
155 #define TOC_BASE_ALIGN 256
157 /* Offset of tp and dtp pointers from start of TLS block. */
158 #define TP_OFFSET 0x7000
159 #define DTP_OFFSET 0x8000
161 /* .plt call stub instructions. The normal stub is like this, but
162 sometimes the .plt entry crosses a 64k boundary and we need to
163 insert an addi to adjust r11. */
164 #define STD_R2_0R1 0xf8410000 /* std %r2,0+40(%r1) */
165 #define ADDIS_R11_R2 0x3d620000 /* addis %r11,%r2,xxx@ha */
166 #define LD_R12_0R11 0xe98b0000 /* ld %r12,xxx+0@l(%r11) */
167 #define MTCTR_R12 0x7d8903a6 /* mtctr %r12 */
168 #define LD_R2_0R11 0xe84b0000 /* ld %r2,xxx+8@l(%r11) */
169 #define LD_R11_0R11 0xe96b0000 /* ld %r11,xxx+16@l(%r11) */
170 #define BCTR 0x4e800420 /* bctr */
172 #define ADDI_R11_R11 0x396b0000 /* addi %r11,%r11,off@l */
173 #define ADDI_R12_R11 0x398b0000 /* addi %r12,%r11,off@l */
174 #define ADDI_R12_R12 0x398c0000 /* addi %r12,%r12,off@l */
175 #define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
176 #define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
178 #define XOR_R2_R12_R12 0x7d826278 /* xor %r2,%r12,%r12 */
179 #define ADD_R11_R11_R2 0x7d6b1214 /* add %r11,%r11,%r2 */
180 #define XOR_R11_R12_R12 0x7d8b6278 /* xor %r11,%r12,%r12 */
181 #define ADD_R2_R2_R11 0x7c425a14 /* add %r2,%r2,%r11 */
182 #define CMPLDI_R2_0 0x28220000 /* cmpldi %r2,0 */
183 #define BNECTR 0x4ca20420 /* bnectr+ */
184 #define BNECTR_P4 0x4ce20420 /* bnectr+ */
186 #define LD_R12_0R2 0xe9820000 /* ld %r12,xxx+0(%r2) */
187 #define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
188 #define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
190 #define LD_R2_0R1 0xe8410000 /* ld %r2,0(%r1) */
191 #define LD_R2_0R12 0xe84c0000 /* ld %r2,0(%r12) */
192 #define ADD_R2_R2_R12 0x7c426214 /* add %r2,%r2,%r12 */
194 #define LI_R11_0 0x39600000 /* li %r11,0 */
195 #define LIS_R2 0x3c400000 /* lis %r2,xxx@ha */
196 #define LIS_R11 0x3d600000 /* lis %r11,xxx@ha */
197 #define LIS_R12 0x3d800000 /* lis %r12,xxx@ha */
198 #define ADDIS_R2_R12 0x3c4c0000 /* addis %r2,%r12,xxx@ha */
199 #define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
200 #define ADDIS_R12_R11 0x3d8b0000 /* addis %r12,%r11,xxx@ha */
201 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,xxx@ha */
202 #define ORIS_R12_R12_0 0x658c0000 /* oris %r12,%r12,xxx@hi */
203 #define ORI_R11_R11_0 0x616b0000 /* ori %r11,%r11,xxx@l */
204 #define ORI_R12_R12_0 0x618c0000 /* ori %r12,%r12,xxx@l */
205 #define LD_R12_0R12 0xe98c0000 /* ld %r12,xxx@l(%r12) */
206 #define SLDI_R11_R11_34 0x796b1746 /* sldi %r11,%r11,34 */
207 #define SLDI_R12_R12_32 0x799c07c6 /* sldi %r12,%r12,32 */
208 #define LDX_R12_R11_R12 0x7d8b602a /* ldx %r12,%r11,%r12 */
209 #define ADD_R12_R11_R12 0x7d8b6214 /* add %r12,%r11,%r12 */
210 #define PADDI_R12_PC 0x0610000039800000ULL
211 #define PLD_R12_PC 0x04100000e5800000ULL
212 #define PNOP 0x0700000000000000ULL
214 /* __glink_PLTresolve stub instructions. We enter with the index in
215 R0 for ELFv1, and the address of a glink branch in R12 for ELFv2. */
216 #define GLINK_PLTRESOLVE_SIZE(htab) \
217 (8u + (htab->opd_abi ? 11 * 4 : htab->has_plt_localentry0 ? 14 * 4 : 13 * 4))
221 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
222 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
224 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
225 /* ld %2,(0b-1b)(%11) */
226 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
227 #define ADD_R11_R2_R11 0x7d625a14 /* add %11,%2,%11 */
234 #define MFLR_R0 0x7c0802a6 /* mflr %r0 */
235 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
236 #define SUB_R12_R12_R11 0x7d8b6050 /* subf %r12,%r11,%r12 */
237 #define ADDI_R0_R12 0x380c0000 /* addi %r0,%r12,0 */
238 #define SRDI_R0_R0_2 0x7800f082 /* rldicl %r0,%r0,62,2 */
239 #define LD_R0_0R11 0xe80b0000 /* ld %r0,0(%r11) */
240 #define ADD_R11_R0_R11 0x7d605a14 /* add %r11,%r0,%r11 */
243 #define NOP 0x60000000
245 /* Some other nops. */
246 #define CROR_151515 0x4def7b82
247 #define CROR_313131 0x4ffffb82
249 /* .glink entries for the first 32k functions are two instructions. */
250 #define LI_R0_0 0x38000000 /* li %r0,0 */
251 #define B_DOT 0x48000000 /* b . */
253 /* After that, we need two instructions to load the index, followed by
255 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
256 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
258 /* Instructions used by the save and restore reg functions. */
259 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
260 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
261 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
262 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
263 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
264 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
265 #define LI_R12_0 0x39800000 /* li %r12,0 */
266 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
267 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
268 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
269 #define BLR 0x4e800020 /* blr */
271 /* Since .opd is an array of descriptors and each entry will end up
272 with identical R_PPC64_RELATIVE relocs, there is really no need to
273 propagate .opd relocs; The dynamic linker should be taught to
274 relocate .opd without reloc entries. */
275 #ifndef NO_OPD_RELOCS
276 #define NO_OPD_RELOCS 0
280 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
284 abiversion (bfd
*abfd
)
286 return elf_elfheader (abfd
)->e_flags
& EF_PPC64_ABI
;
290 set_abiversion (bfd
*abfd
, int ver
)
292 elf_elfheader (abfd
)->e_flags
&= ~EF_PPC64_ABI
;
293 elf_elfheader (abfd
)->e_flags
|= ver
& EF_PPC64_ABI
;
296 /* Relocation HOWTO's. */
297 /* Like other ELF RELA targets that don't apply multiple
298 field-altering relocations to the same localation, src_mask is
299 always zero and pcrel_offset is the same as pc_relative.
300 PowerPC can always use a zero bitpos, even when the field is not at
301 the LSB. For example, a REL24 could use rightshift=2, bisize=24
302 and bitpos=2 which matches the ABI description, or as we do here,
303 rightshift=0, bitsize=26 and bitpos=0. */
304 #define HOW(type, size, bitsize, mask, rightshift, pc_relative, \
305 complain, special_func) \
306 HOWTO (type, rightshift, size, bitsize, pc_relative, 0, \
307 complain_overflow_ ## complain, special_func, \
308 #type, FALSE, 0, mask, pc_relative)
310 static reloc_howto_type
*ppc64_elf_howto_table
[(int) R_PPC64_max
];
312 static reloc_howto_type ppc64_elf_howto_raw
[] =
314 /* This reloc does nothing. */
315 HOW (R_PPC64_NONE
, 3, 0, 0, 0, FALSE
, dont
,
316 bfd_elf_generic_reloc
),
318 /* A standard 32 bit relocation. */
319 HOW (R_PPC64_ADDR32
, 2, 32, 0xffffffff, 0, FALSE
, bitfield
,
320 bfd_elf_generic_reloc
),
322 /* An absolute 26 bit branch; the lower two bits must be zero.
323 FIXME: we don't check that, we just clear them. */
324 HOW (R_PPC64_ADDR24
, 2, 26, 0x03fffffc, 0, FALSE
, bitfield
,
325 bfd_elf_generic_reloc
),
327 /* A standard 16 bit relocation. */
328 HOW (R_PPC64_ADDR16
, 1, 16, 0xffff, 0, FALSE
, bitfield
,
329 bfd_elf_generic_reloc
),
331 /* A 16 bit relocation without overflow. */
332 HOW (R_PPC64_ADDR16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
333 bfd_elf_generic_reloc
),
335 /* Bits 16-31 of an address. */
336 HOW (R_PPC64_ADDR16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
337 bfd_elf_generic_reloc
),
339 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
340 bits, treated as a signed number, is negative. */
341 HOW (R_PPC64_ADDR16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
344 /* An absolute 16 bit branch; the lower two bits must be zero.
345 FIXME: we don't check that, we just clear them. */
346 HOW (R_PPC64_ADDR14
, 2, 16, 0x0000fffc, 0, FALSE
, signed,
347 ppc64_elf_branch_reloc
),
349 /* An absolute 16 bit branch, for which bit 10 should be set to
350 indicate that the branch is expected to be taken. The lower two
351 bits must be zero. */
352 HOW (R_PPC64_ADDR14_BRTAKEN
, 2, 16, 0x0000fffc, 0, FALSE
, signed,
353 ppc64_elf_brtaken_reloc
),
355 /* An absolute 16 bit branch, for which bit 10 should be set to
356 indicate that the branch is not expected to be taken. The lower
357 two bits must be zero. */
358 HOW (R_PPC64_ADDR14_BRNTAKEN
, 2, 16, 0x0000fffc, 0, FALSE
, signed,
359 ppc64_elf_brtaken_reloc
),
361 /* A relative 26 bit branch; the lower two bits must be zero. */
362 HOW (R_PPC64_REL24
, 2, 26, 0x03fffffc, 0, TRUE
, signed,
363 ppc64_elf_branch_reloc
),
365 /* A variant of R_PPC64_REL24, used when r2 is not the toc pointer. */
366 HOW (R_PPC64_REL24_NOTOC
, 2, 26, 0x03fffffc, 0, TRUE
, signed,
367 ppc64_elf_branch_reloc
),
369 /* A relative 16 bit branch; the lower two bits must be zero. */
370 HOW (R_PPC64_REL14
, 2, 16, 0x0000fffc, 0, TRUE
, signed,
371 ppc64_elf_branch_reloc
),
373 /* A relative 16 bit branch. Bit 10 should be set to indicate that
374 the branch is expected to be taken. The lower two bits must be
376 HOW (R_PPC64_REL14_BRTAKEN
, 2, 16, 0x0000fffc, 0, TRUE
, signed,
377 ppc64_elf_brtaken_reloc
),
379 /* A relative 16 bit branch. Bit 10 should be set to indicate that
380 the branch is not expected to be taken. The lower two bits must
382 HOW (R_PPC64_REL14_BRNTAKEN
, 2, 16, 0x0000fffc, 0, TRUE
, signed,
383 ppc64_elf_brtaken_reloc
),
385 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
387 HOW (R_PPC64_GOT16
, 1, 16, 0xffff, 0, FALSE
, signed,
388 ppc64_elf_unhandled_reloc
),
390 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
392 HOW (R_PPC64_GOT16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
393 ppc64_elf_unhandled_reloc
),
395 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
397 HOW (R_PPC64_GOT16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
398 ppc64_elf_unhandled_reloc
),
400 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
402 HOW (R_PPC64_GOT16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
403 ppc64_elf_unhandled_reloc
),
405 /* This is used only by the dynamic linker. The symbol should exist
406 both in the object being run and in some shared library. The
407 dynamic linker copies the data addressed by the symbol from the
408 shared library into the object, because the object being
409 run has to have the data at some particular address. */
410 HOW (R_PPC64_COPY
, 0, 0, 0, 0, FALSE
, dont
,
411 ppc64_elf_unhandled_reloc
),
413 /* Like R_PPC64_ADDR64, but used when setting global offset table
415 HOW (R_PPC64_GLOB_DAT
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
416 ppc64_elf_unhandled_reloc
),
418 /* Created by the link editor. Marks a procedure linkage table
419 entry for a symbol. */
420 HOW (R_PPC64_JMP_SLOT
, 0, 0, 0, 0, FALSE
, dont
,
421 ppc64_elf_unhandled_reloc
),
423 /* Used only by the dynamic linker. When the object is run, this
424 doubleword64 is set to the load address of the object, plus the
426 HOW (R_PPC64_RELATIVE
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
427 bfd_elf_generic_reloc
),
429 /* Like R_PPC64_ADDR32, but may be unaligned. */
430 HOW (R_PPC64_UADDR32
, 2, 32, 0xffffffff, 0, FALSE
, bitfield
,
431 bfd_elf_generic_reloc
),
433 /* Like R_PPC64_ADDR16, but may be unaligned. */
434 HOW (R_PPC64_UADDR16
, 1, 16, 0xffff, 0, FALSE
, bitfield
,
435 bfd_elf_generic_reloc
),
437 /* 32-bit PC relative. */
438 HOW (R_PPC64_REL32
, 2, 32, 0xffffffff, 0, TRUE
, signed,
439 bfd_elf_generic_reloc
),
441 /* 32-bit relocation to the symbol's procedure linkage table. */
442 HOW (R_PPC64_PLT32
, 2, 32, 0xffffffff, 0, FALSE
, bitfield
,
443 ppc64_elf_unhandled_reloc
),
445 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
446 FIXME: R_PPC64_PLTREL32 not supported. */
447 HOW (R_PPC64_PLTREL32
, 2, 32, 0xffffffff, 0, TRUE
, signed,
448 ppc64_elf_unhandled_reloc
),
450 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
452 HOW (R_PPC64_PLT16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
453 ppc64_elf_unhandled_reloc
),
455 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
457 HOW (R_PPC64_PLT16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
458 ppc64_elf_unhandled_reloc
),
460 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
462 HOW (R_PPC64_PLT16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
463 ppc64_elf_unhandled_reloc
),
465 /* 16-bit section relative relocation. */
466 HOW (R_PPC64_SECTOFF
, 1, 16, 0xffff, 0, FALSE
, signed,
467 ppc64_elf_sectoff_reloc
),
469 /* Like R_PPC64_SECTOFF, but no overflow warning. */
470 HOW (R_PPC64_SECTOFF_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
471 ppc64_elf_sectoff_reloc
),
473 /* 16-bit upper half section relative relocation. */
474 HOW (R_PPC64_SECTOFF_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
475 ppc64_elf_sectoff_reloc
),
477 /* 16-bit upper half adjusted section relative relocation. */
478 HOW (R_PPC64_SECTOFF_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
479 ppc64_elf_sectoff_ha_reloc
),
481 /* Like R_PPC64_REL24 without touching the two least significant bits. */
482 HOW (R_PPC64_REL30
, 2, 30, 0xfffffffc, 2, TRUE
, dont
,
483 bfd_elf_generic_reloc
),
485 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
487 /* A standard 64-bit relocation. */
488 HOW (R_PPC64_ADDR64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
489 bfd_elf_generic_reloc
),
491 /* The bits 32-47 of an address. */
492 HOW (R_PPC64_ADDR16_HIGHER
, 1, 16, 0xffff, 32, FALSE
, dont
,
493 bfd_elf_generic_reloc
),
495 /* The bits 32-47 of an address, plus 1 if the contents of the low
496 16 bits, treated as a signed number, is negative. */
497 HOW (R_PPC64_ADDR16_HIGHERA
, 1, 16, 0xffff, 32, FALSE
, dont
,
500 /* The bits 48-63 of an address. */
501 HOW (R_PPC64_ADDR16_HIGHEST
, 1, 16, 0xffff, 48, FALSE
, dont
,
502 bfd_elf_generic_reloc
),
504 /* The bits 48-63 of an address, plus 1 if the contents of the low
505 16 bits, treated as a signed number, is negative. */
506 HOW (R_PPC64_ADDR16_HIGHESTA
, 1, 16, 0xffff, 48, FALSE
, dont
,
509 /* Like ADDR64, but may be unaligned. */
510 HOW (R_PPC64_UADDR64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
511 bfd_elf_generic_reloc
),
513 /* 64-bit relative relocation. */
514 HOW (R_PPC64_REL64
, 4, 64, 0xffffffffffffffffULL
, 0, TRUE
, dont
,
515 bfd_elf_generic_reloc
),
517 /* 64-bit relocation to the symbol's procedure linkage table. */
518 HOW (R_PPC64_PLT64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
519 ppc64_elf_unhandled_reloc
),
521 /* 64-bit PC relative relocation to the symbol's procedure linkage
523 /* FIXME: R_PPC64_PLTREL64 not supported. */
524 HOW (R_PPC64_PLTREL64
, 4, 64, 0xffffffffffffffffULL
, 0, TRUE
, dont
,
525 ppc64_elf_unhandled_reloc
),
527 /* 16 bit TOC-relative relocation. */
528 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
529 HOW (R_PPC64_TOC16
, 1, 16, 0xffff, 0, FALSE
, signed,
530 ppc64_elf_toc_reloc
),
532 /* 16 bit TOC-relative relocation without overflow. */
533 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
534 HOW (R_PPC64_TOC16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
535 ppc64_elf_toc_reloc
),
537 /* 16 bit TOC-relative relocation, high 16 bits. */
538 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
539 HOW (R_PPC64_TOC16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
540 ppc64_elf_toc_reloc
),
542 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
543 contents of the low 16 bits, treated as a signed number, is
545 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
546 HOW (R_PPC64_TOC16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
547 ppc64_elf_toc_ha_reloc
),
549 /* 64-bit relocation; insert value of TOC base (.TOC.). */
550 /* R_PPC64_TOC 51 doubleword64 .TOC. */
551 HOW (R_PPC64_TOC
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
552 ppc64_elf_toc64_reloc
),
554 /* Like R_PPC64_GOT16, but also informs the link editor that the
555 value to relocate may (!) refer to a PLT entry which the link
556 editor (a) may replace with the symbol value. If the link editor
557 is unable to fully resolve the symbol, it may (b) create a PLT
558 entry and store the address to the new PLT entry in the GOT.
559 This permits lazy resolution of function symbols at run time.
560 The link editor may also skip all of this and just (c) emit a
561 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
562 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
563 HOW (R_PPC64_PLTGOT16
, 1, 16, 0xffff, 0, FALSE
,signed,
564 ppc64_elf_unhandled_reloc
),
566 /* Like R_PPC64_PLTGOT16, but without overflow. */
567 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
568 HOW (R_PPC64_PLTGOT16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
569 ppc64_elf_unhandled_reloc
),
571 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
572 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
573 HOW (R_PPC64_PLTGOT16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
574 ppc64_elf_unhandled_reloc
),
576 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
577 1 if the contents of the low 16 bits, treated as a signed number,
579 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
580 HOW (R_PPC64_PLTGOT16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
581 ppc64_elf_unhandled_reloc
),
583 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
584 HOW (R_PPC64_ADDR16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
585 bfd_elf_generic_reloc
),
587 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
588 HOW (R_PPC64_ADDR16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
589 bfd_elf_generic_reloc
),
591 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
592 HOW (R_PPC64_GOT16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
593 ppc64_elf_unhandled_reloc
),
595 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
596 HOW (R_PPC64_GOT16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
597 ppc64_elf_unhandled_reloc
),
599 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
600 HOW (R_PPC64_PLT16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
601 ppc64_elf_unhandled_reloc
),
603 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
604 HOW (R_PPC64_SECTOFF_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
605 ppc64_elf_sectoff_reloc
),
607 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
608 HOW (R_PPC64_SECTOFF_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
609 ppc64_elf_sectoff_reloc
),
611 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
612 HOW (R_PPC64_TOC16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
613 ppc64_elf_toc_reloc
),
615 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
616 HOW (R_PPC64_TOC16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
617 ppc64_elf_toc_reloc
),
619 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
620 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
621 HOW (R_PPC64_PLTGOT16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
622 ppc64_elf_unhandled_reloc
),
624 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
625 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
626 HOW (R_PPC64_PLTGOT16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
627 ppc64_elf_unhandled_reloc
),
629 /* Marker relocs for TLS. */
630 HOW (R_PPC64_TLS
, 2, 32, 0, 0, FALSE
, dont
,
631 bfd_elf_generic_reloc
),
633 HOW (R_PPC64_TLSGD
, 2, 32, 0, 0, FALSE
, dont
,
634 bfd_elf_generic_reloc
),
636 HOW (R_PPC64_TLSLD
, 2, 32, 0, 0, FALSE
, dont
,
637 bfd_elf_generic_reloc
),
639 /* Marker reloc for optimizing r2 save in prologue rather than on
640 each plt call stub. */
641 HOW (R_PPC64_TOCSAVE
, 2, 32, 0, 0, FALSE
, dont
,
642 bfd_elf_generic_reloc
),
644 /* Marker relocs on inline plt call instructions. */
645 HOW (R_PPC64_PLTSEQ
, 2, 32, 0, 0, FALSE
, dont
,
646 bfd_elf_generic_reloc
),
648 HOW (R_PPC64_PLTCALL
, 2, 32, 0, 0, FALSE
, dont
,
649 bfd_elf_generic_reloc
),
651 /* Computes the load module index of the load module that contains the
652 definition of its TLS sym. */
653 HOW (R_PPC64_DTPMOD64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
654 ppc64_elf_unhandled_reloc
),
656 /* Computes a dtv-relative displacement, the difference between the value
657 of sym+add and the base address of the thread-local storage block that
658 contains the definition of sym, minus 0x8000. */
659 HOW (R_PPC64_DTPREL64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
660 ppc64_elf_unhandled_reloc
),
662 /* A 16 bit dtprel reloc. */
663 HOW (R_PPC64_DTPREL16
, 1, 16, 0xffff, 0, FALSE
, signed,
664 ppc64_elf_unhandled_reloc
),
666 /* Like DTPREL16, but no overflow. */
667 HOW (R_PPC64_DTPREL16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
668 ppc64_elf_unhandled_reloc
),
670 /* Like DTPREL16_LO, but next higher group of 16 bits. */
671 HOW (R_PPC64_DTPREL16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
672 ppc64_elf_unhandled_reloc
),
674 /* Like DTPREL16_HI, but adjust for low 16 bits. */
675 HOW (R_PPC64_DTPREL16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
676 ppc64_elf_unhandled_reloc
),
678 /* Like DTPREL16_HI, but next higher group of 16 bits. */
679 HOW (R_PPC64_DTPREL16_HIGHER
, 1, 16, 0xffff, 32, FALSE
, dont
,
680 ppc64_elf_unhandled_reloc
),
682 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
683 HOW (R_PPC64_DTPREL16_HIGHERA
, 1, 16, 0xffff, 32, FALSE
, dont
,
684 ppc64_elf_unhandled_reloc
),
686 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
687 HOW (R_PPC64_DTPREL16_HIGHEST
, 1, 16, 0xffff, 48, FALSE
, dont
,
688 ppc64_elf_unhandled_reloc
),
690 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
691 HOW (R_PPC64_DTPREL16_HIGHESTA
, 1, 16, 0xffff, 48, FALSE
, dont
,
692 ppc64_elf_unhandled_reloc
),
694 /* Like DTPREL16, but for insns with a DS field. */
695 HOW (R_PPC64_DTPREL16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
696 ppc64_elf_unhandled_reloc
),
698 /* Like DTPREL16_DS, but no overflow. */
699 HOW (R_PPC64_DTPREL16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
700 ppc64_elf_unhandled_reloc
),
702 /* Computes a tp-relative displacement, the difference between the value of
703 sym+add and the value of the thread pointer (r13). */
704 HOW (R_PPC64_TPREL64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
705 ppc64_elf_unhandled_reloc
),
707 /* A 16 bit tprel reloc. */
708 HOW (R_PPC64_TPREL16
, 1, 16, 0xffff, 0, FALSE
, signed,
709 ppc64_elf_unhandled_reloc
),
711 /* Like TPREL16, but no overflow. */
712 HOW (R_PPC64_TPREL16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
713 ppc64_elf_unhandled_reloc
),
715 /* Like TPREL16_LO, but next higher group of 16 bits. */
716 HOW (R_PPC64_TPREL16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
717 ppc64_elf_unhandled_reloc
),
719 /* Like TPREL16_HI, but adjust for low 16 bits. */
720 HOW (R_PPC64_TPREL16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
721 ppc64_elf_unhandled_reloc
),
723 /* Like TPREL16_HI, but next higher group of 16 bits. */
724 HOW (R_PPC64_TPREL16_HIGHER
, 1, 16, 0xffff, 32, FALSE
, dont
,
725 ppc64_elf_unhandled_reloc
),
727 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
728 HOW (R_PPC64_TPREL16_HIGHERA
, 1, 16, 0xffff, 32, FALSE
, dont
,
729 ppc64_elf_unhandled_reloc
),
731 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
732 HOW (R_PPC64_TPREL16_HIGHEST
, 1, 16, 0xffff, 48, FALSE
, dont
,
733 ppc64_elf_unhandled_reloc
),
735 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
736 HOW (R_PPC64_TPREL16_HIGHESTA
, 1, 16, 0xffff, 48, FALSE
, dont
,
737 ppc64_elf_unhandled_reloc
),
739 /* Like TPREL16, but for insns with a DS field. */
740 HOW (R_PPC64_TPREL16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
741 ppc64_elf_unhandled_reloc
),
743 /* Like TPREL16_DS, but no overflow. */
744 HOW (R_PPC64_TPREL16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
745 ppc64_elf_unhandled_reloc
),
747 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
748 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
749 to the first entry relative to the TOC base (r2). */
750 HOW (R_PPC64_GOT_TLSGD16
, 1, 16, 0xffff, 0, FALSE
, signed,
751 ppc64_elf_unhandled_reloc
),
753 /* Like GOT_TLSGD16, but no overflow. */
754 HOW (R_PPC64_GOT_TLSGD16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
755 ppc64_elf_unhandled_reloc
),
757 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
758 HOW (R_PPC64_GOT_TLSGD16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
759 ppc64_elf_unhandled_reloc
),
761 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
762 HOW (R_PPC64_GOT_TLSGD16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
763 ppc64_elf_unhandled_reloc
),
765 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
766 with values (sym+add)@dtpmod and zero, and computes the offset to the
767 first entry relative to the TOC base (r2). */
768 HOW (R_PPC64_GOT_TLSLD16
, 1, 16, 0xffff, 0, FALSE
, signed,
769 ppc64_elf_unhandled_reloc
),
771 /* Like GOT_TLSLD16, but no overflow. */
772 HOW (R_PPC64_GOT_TLSLD16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
773 ppc64_elf_unhandled_reloc
),
775 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
776 HOW (R_PPC64_GOT_TLSLD16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
777 ppc64_elf_unhandled_reloc
),
779 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
780 HOW (R_PPC64_GOT_TLSLD16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
781 ppc64_elf_unhandled_reloc
),
783 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
784 the offset to the entry relative to the TOC base (r2). */
785 HOW (R_PPC64_GOT_DTPREL16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
786 ppc64_elf_unhandled_reloc
),
788 /* Like GOT_DTPREL16_DS, but no overflow. */
789 HOW (R_PPC64_GOT_DTPREL16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
790 ppc64_elf_unhandled_reloc
),
792 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
793 HOW (R_PPC64_GOT_DTPREL16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
794 ppc64_elf_unhandled_reloc
),
796 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
797 HOW (R_PPC64_GOT_DTPREL16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
798 ppc64_elf_unhandled_reloc
),
800 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
801 offset to the entry relative to the TOC base (r2). */
802 HOW (R_PPC64_GOT_TPREL16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
803 ppc64_elf_unhandled_reloc
),
805 /* Like GOT_TPREL16_DS, but no overflow. */
806 HOW (R_PPC64_GOT_TPREL16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
807 ppc64_elf_unhandled_reloc
),
809 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
810 HOW (R_PPC64_GOT_TPREL16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
811 ppc64_elf_unhandled_reloc
),
813 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
814 HOW (R_PPC64_GOT_TPREL16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
815 ppc64_elf_unhandled_reloc
),
817 HOW (R_PPC64_JMP_IREL
, 0, 0, 0, 0, FALSE
, dont
,
818 ppc64_elf_unhandled_reloc
),
820 HOW (R_PPC64_IRELATIVE
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
821 bfd_elf_generic_reloc
),
823 /* A 16 bit relative relocation. */
824 HOW (R_PPC64_REL16
, 1, 16, 0xffff, 0, TRUE
, signed,
825 bfd_elf_generic_reloc
),
827 /* A 16 bit relative relocation without overflow. */
828 HOW (R_PPC64_REL16_LO
, 1, 16, 0xffff, 0, TRUE
, dont
,
829 bfd_elf_generic_reloc
),
831 /* The high order 16 bits of a relative address. */
832 HOW (R_PPC64_REL16_HI
, 1, 16, 0xffff, 16, TRUE
, signed,
833 bfd_elf_generic_reloc
),
835 /* The high order 16 bits of a relative address, plus 1 if the contents of
836 the low 16 bits, treated as a signed number, is negative. */
837 HOW (R_PPC64_REL16_HA
, 1, 16, 0xffff, 16, TRUE
, signed,
840 HOW (R_PPC64_REL16_HIGH
, 1, 16, 0xffff, 16, TRUE
, dont
,
841 bfd_elf_generic_reloc
),
843 HOW (R_PPC64_REL16_HIGHA
, 1, 16, 0xffff, 16, TRUE
, dont
,
846 HOW (R_PPC64_REL16_HIGHER
, 1, 16, 0xffff, 32, TRUE
, dont
,
847 bfd_elf_generic_reloc
),
849 HOW (R_PPC64_REL16_HIGHERA
, 1, 16, 0xffff, 32, TRUE
, dont
,
852 HOW (R_PPC64_REL16_HIGHEST
, 1, 16, 0xffff, 48, TRUE
, dont
,
853 bfd_elf_generic_reloc
),
855 HOW (R_PPC64_REL16_HIGHESTA
, 1, 16, 0xffff, 48, TRUE
, dont
,
858 /* Like R_PPC64_REL16_HA but for split field in addpcis. */
859 HOW (R_PPC64_REL16DX_HA
, 2, 16, 0x1fffc1, 16, TRUE
, signed,
862 /* A split-field reloc for addpcis, non-relative (gas internal use only). */
863 HOW (R_PPC64_16DX_HA
, 2, 16, 0x1fffc1, 16, FALSE
, signed,
866 /* Like R_PPC64_ADDR16_HI, but no overflow. */
867 HOW (R_PPC64_ADDR16_HIGH
, 1, 16, 0xffff, 16, FALSE
, dont
,
868 bfd_elf_generic_reloc
),
870 /* Like R_PPC64_ADDR16_HA, but no overflow. */
871 HOW (R_PPC64_ADDR16_HIGHA
, 1, 16, 0xffff, 16, FALSE
, dont
,
874 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
875 HOW (R_PPC64_DTPREL16_HIGH
, 1, 16, 0xffff, 16, FALSE
, dont
,
876 ppc64_elf_unhandled_reloc
),
878 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
879 HOW (R_PPC64_DTPREL16_HIGHA
, 1, 16, 0xffff, 16, FALSE
, dont
,
880 ppc64_elf_unhandled_reloc
),
882 /* Like R_PPC64_TPREL16_HI, but no overflow. */
883 HOW (R_PPC64_TPREL16_HIGH
, 1, 16, 0xffff, 16, FALSE
, dont
,
884 ppc64_elf_unhandled_reloc
),
886 /* Like R_PPC64_TPREL16_HA, but no overflow. */
887 HOW (R_PPC64_TPREL16_HIGHA
, 1, 16, 0xffff, 16, FALSE
, dont
,
888 ppc64_elf_unhandled_reloc
),
890 /* Marker reloc on ELFv2 large-model function entry. */
891 HOW (R_PPC64_ENTRY
, 2, 32, 0, 0, FALSE
, dont
,
892 bfd_elf_generic_reloc
),
894 /* Like ADDR64, but use local entry point of function. */
895 HOW (R_PPC64_ADDR64_LOCAL
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
896 bfd_elf_generic_reloc
),
898 HOW (R_PPC64_PLTSEQ_NOTOC
, 2, 32, 0, 0, FALSE
, dont
,
899 bfd_elf_generic_reloc
),
901 HOW (R_PPC64_PLTCALL_NOTOC
, 2, 32, 0, 0, FALSE
, dont
,
902 bfd_elf_generic_reloc
),
904 HOW (R_PPC64_PCREL_OPT
, 2, 32, 0, 0, FALSE
, dont
,
905 bfd_elf_generic_reloc
),
907 HOW (R_PPC64_D34
, 4, 34, 0x3ffff0000ffffULL
, 0, FALSE
, signed,
908 ppc64_elf_prefix_reloc
),
910 HOW (R_PPC64_D34_LO
, 4, 34, 0x3ffff0000ffffULL
, 0, FALSE
, dont
,
911 ppc64_elf_prefix_reloc
),
913 HOW (R_PPC64_D34_HI30
, 4, 34, 0x3ffff0000ffffULL
, 34, FALSE
, dont
,
914 ppc64_elf_prefix_reloc
),
916 HOW (R_PPC64_D34_HA30
, 4, 34, 0x3ffff0000ffffULL
, 34, FALSE
, dont
,
917 ppc64_elf_prefix_reloc
),
919 HOW (R_PPC64_PCREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
920 ppc64_elf_prefix_reloc
),
922 HOW (R_PPC64_GOT_PCREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
923 ppc64_elf_unhandled_reloc
),
925 HOW (R_PPC64_PLT_PCREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
926 ppc64_elf_unhandled_reloc
),
928 HOW (R_PPC64_PLT_PCREL34_NOTOC
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
929 ppc64_elf_unhandled_reloc
),
931 HOW (R_PPC64_TPREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, FALSE
, signed,
932 ppc64_elf_unhandled_reloc
),
934 HOW (R_PPC64_DTPREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, FALSE
, signed,
935 ppc64_elf_unhandled_reloc
),
937 HOW (R_PPC64_GOT_TLSGD_PCREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
938 ppc64_elf_unhandled_reloc
),
940 HOW (R_PPC64_GOT_TLSLD_PCREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
941 ppc64_elf_unhandled_reloc
),
943 HOW (R_PPC64_GOT_TPREL_PCREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
944 ppc64_elf_unhandled_reloc
),
946 HOW (R_PPC64_GOT_DTPREL_PCREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
947 ppc64_elf_unhandled_reloc
),
949 HOW (R_PPC64_ADDR16_HIGHER34
, 1, 16, 0xffff, 34, FALSE
, dont
,
950 bfd_elf_generic_reloc
),
952 HOW (R_PPC64_ADDR16_HIGHERA34
, 1, 16, 0xffff, 34, FALSE
, dont
,
955 HOW (R_PPC64_ADDR16_HIGHEST34
, 1, 16, 0xffff, 50, FALSE
, dont
,
956 bfd_elf_generic_reloc
),
958 HOW (R_PPC64_ADDR16_HIGHESTA34
, 1, 16, 0xffff, 50, FALSE
, dont
,
961 HOW (R_PPC64_REL16_HIGHER34
, 1, 16, 0xffff, 34, TRUE
, dont
,
962 bfd_elf_generic_reloc
),
964 HOW (R_PPC64_REL16_HIGHERA34
, 1, 16, 0xffff, 34, TRUE
, dont
,
967 HOW (R_PPC64_REL16_HIGHEST34
, 1, 16, 0xffff, 50, TRUE
, dont
,
968 bfd_elf_generic_reloc
),
970 HOW (R_PPC64_REL16_HIGHESTA34
, 1, 16, 0xffff, 50, TRUE
, dont
,
973 HOW (R_PPC64_D28
, 4, 28, 0xfff0000ffffULL
, 0, FALSE
, signed,
974 ppc64_elf_prefix_reloc
),
976 HOW (R_PPC64_PCREL28
, 4, 28, 0xfff0000ffffULL
, 0, TRUE
, signed,
977 ppc64_elf_prefix_reloc
),
979 /* GNU extension to record C++ vtable hierarchy. */
980 HOW (R_PPC64_GNU_VTINHERIT
, 0, 0, 0, 0, FALSE
, dont
,
983 /* GNU extension to record C++ vtable member usage. */
984 HOW (R_PPC64_GNU_VTENTRY
, 0, 0, 0, 0, FALSE
, dont
,
989 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
993 ppc_howto_init (void)
995 unsigned int i
, type
;
997 for (i
= 0; i
< ARRAY_SIZE (ppc64_elf_howto_raw
); i
++)
999 type
= ppc64_elf_howto_raw
[i
].type
;
1000 BFD_ASSERT (type
< ARRAY_SIZE (ppc64_elf_howto_table
));
1001 ppc64_elf_howto_table
[type
] = &ppc64_elf_howto_raw
[i
];
1005 static reloc_howto_type
*
1006 ppc64_elf_reloc_type_lookup (bfd
*abfd
, bfd_reloc_code_real_type code
)
1008 enum elf_ppc64_reloc_type r
= R_PPC64_NONE
;
1010 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
1011 /* Initialize howto table if needed. */
1017 /* xgettext:c-format */
1018 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd
,
1020 bfd_set_error (bfd_error_bad_value
);
1023 case BFD_RELOC_NONE
: r
= R_PPC64_NONE
;
1025 case BFD_RELOC_32
: r
= R_PPC64_ADDR32
;
1027 case BFD_RELOC_PPC_BA26
: r
= R_PPC64_ADDR24
;
1029 case BFD_RELOC_16
: r
= R_PPC64_ADDR16
;
1031 case BFD_RELOC_LO16
: r
= R_PPC64_ADDR16_LO
;
1033 case BFD_RELOC_HI16
: r
= R_PPC64_ADDR16_HI
;
1035 case BFD_RELOC_PPC64_ADDR16_HIGH
: r
= R_PPC64_ADDR16_HIGH
;
1037 case BFD_RELOC_HI16_S
: r
= R_PPC64_ADDR16_HA
;
1039 case BFD_RELOC_PPC64_ADDR16_HIGHA
: r
= R_PPC64_ADDR16_HIGHA
;
1041 case BFD_RELOC_PPC_BA16
: r
= R_PPC64_ADDR14
;
1043 case BFD_RELOC_PPC_BA16_BRTAKEN
: r
= R_PPC64_ADDR14_BRTAKEN
;
1045 case BFD_RELOC_PPC_BA16_BRNTAKEN
: r
= R_PPC64_ADDR14_BRNTAKEN
;
1047 case BFD_RELOC_PPC_B26
: r
= R_PPC64_REL24
;
1049 case BFD_RELOC_PPC64_REL24_NOTOC
: r
= R_PPC64_REL24_NOTOC
;
1051 case BFD_RELOC_PPC_B16
: r
= R_PPC64_REL14
;
1053 case BFD_RELOC_PPC_B16_BRTAKEN
: r
= R_PPC64_REL14_BRTAKEN
;
1055 case BFD_RELOC_PPC_B16_BRNTAKEN
: r
= R_PPC64_REL14_BRNTAKEN
;
1057 case BFD_RELOC_16_GOTOFF
: r
= R_PPC64_GOT16
;
1059 case BFD_RELOC_LO16_GOTOFF
: r
= R_PPC64_GOT16_LO
;
1061 case BFD_RELOC_HI16_GOTOFF
: r
= R_PPC64_GOT16_HI
;
1063 case BFD_RELOC_HI16_S_GOTOFF
: r
= R_PPC64_GOT16_HA
;
1065 case BFD_RELOC_PPC_COPY
: r
= R_PPC64_COPY
;
1067 case BFD_RELOC_PPC_GLOB_DAT
: r
= R_PPC64_GLOB_DAT
;
1069 case BFD_RELOC_32_PCREL
: r
= R_PPC64_REL32
;
1071 case BFD_RELOC_32_PLTOFF
: r
= R_PPC64_PLT32
;
1073 case BFD_RELOC_32_PLT_PCREL
: r
= R_PPC64_PLTREL32
;
1075 case BFD_RELOC_LO16_PLTOFF
: r
= R_PPC64_PLT16_LO
;
1077 case BFD_RELOC_HI16_PLTOFF
: r
= R_PPC64_PLT16_HI
;
1079 case BFD_RELOC_HI16_S_PLTOFF
: r
= R_PPC64_PLT16_HA
;
1081 case BFD_RELOC_16_BASEREL
: r
= R_PPC64_SECTOFF
;
1083 case BFD_RELOC_LO16_BASEREL
: r
= R_PPC64_SECTOFF_LO
;
1085 case BFD_RELOC_HI16_BASEREL
: r
= R_PPC64_SECTOFF_HI
;
1087 case BFD_RELOC_HI16_S_BASEREL
: r
= R_PPC64_SECTOFF_HA
;
1089 case BFD_RELOC_CTOR
: r
= R_PPC64_ADDR64
;
1091 case BFD_RELOC_64
: r
= R_PPC64_ADDR64
;
1093 case BFD_RELOC_PPC64_HIGHER
: r
= R_PPC64_ADDR16_HIGHER
;
1095 case BFD_RELOC_PPC64_HIGHER_S
: r
= R_PPC64_ADDR16_HIGHERA
;
1097 case BFD_RELOC_PPC64_HIGHEST
: r
= R_PPC64_ADDR16_HIGHEST
;
1099 case BFD_RELOC_PPC64_HIGHEST_S
: r
= R_PPC64_ADDR16_HIGHESTA
;
1101 case BFD_RELOC_64_PCREL
: r
= R_PPC64_REL64
;
1103 case BFD_RELOC_64_PLTOFF
: r
= R_PPC64_PLT64
;
1105 case BFD_RELOC_64_PLT_PCREL
: r
= R_PPC64_PLTREL64
;
1107 case BFD_RELOC_PPC_TOC16
: r
= R_PPC64_TOC16
;
1109 case BFD_RELOC_PPC64_TOC16_LO
: r
= R_PPC64_TOC16_LO
;
1111 case BFD_RELOC_PPC64_TOC16_HI
: r
= R_PPC64_TOC16_HI
;
1113 case BFD_RELOC_PPC64_TOC16_HA
: r
= R_PPC64_TOC16_HA
;
1115 case BFD_RELOC_PPC64_TOC
: r
= R_PPC64_TOC
;
1117 case BFD_RELOC_PPC64_PLTGOT16
: r
= R_PPC64_PLTGOT16
;
1119 case BFD_RELOC_PPC64_PLTGOT16_LO
: r
= R_PPC64_PLTGOT16_LO
;
1121 case BFD_RELOC_PPC64_PLTGOT16_HI
: r
= R_PPC64_PLTGOT16_HI
;
1123 case BFD_RELOC_PPC64_PLTGOT16_HA
: r
= R_PPC64_PLTGOT16_HA
;
1125 case BFD_RELOC_PPC64_ADDR16_DS
: r
= R_PPC64_ADDR16_DS
;
1127 case BFD_RELOC_PPC64_ADDR16_LO_DS
: r
= R_PPC64_ADDR16_LO_DS
;
1129 case BFD_RELOC_PPC64_GOT16_DS
: r
= R_PPC64_GOT16_DS
;
1131 case BFD_RELOC_PPC64_GOT16_LO_DS
: r
= R_PPC64_GOT16_LO_DS
;
1133 case BFD_RELOC_PPC64_PLT16_LO_DS
: r
= R_PPC64_PLT16_LO_DS
;
1135 case BFD_RELOC_PPC64_SECTOFF_DS
: r
= R_PPC64_SECTOFF_DS
;
1137 case BFD_RELOC_PPC64_SECTOFF_LO_DS
: r
= R_PPC64_SECTOFF_LO_DS
;
1139 case BFD_RELOC_PPC64_TOC16_DS
: r
= R_PPC64_TOC16_DS
;
1141 case BFD_RELOC_PPC64_TOC16_LO_DS
: r
= R_PPC64_TOC16_LO_DS
;
1143 case BFD_RELOC_PPC64_PLTGOT16_DS
: r
= R_PPC64_PLTGOT16_DS
;
1145 case BFD_RELOC_PPC64_PLTGOT16_LO_DS
: r
= R_PPC64_PLTGOT16_LO_DS
;
1147 case BFD_RELOC_PPC64_TLS_PCREL
:
1148 case BFD_RELOC_PPC_TLS
: r
= R_PPC64_TLS
;
1150 case BFD_RELOC_PPC_TLSGD
: r
= R_PPC64_TLSGD
;
1152 case BFD_RELOC_PPC_TLSLD
: r
= R_PPC64_TLSLD
;
1154 case BFD_RELOC_PPC_DTPMOD
: r
= R_PPC64_DTPMOD64
;
1156 case BFD_RELOC_PPC_TPREL16
: r
= R_PPC64_TPREL16
;
1158 case BFD_RELOC_PPC_TPREL16_LO
: r
= R_PPC64_TPREL16_LO
;
1160 case BFD_RELOC_PPC_TPREL16_HI
: r
= R_PPC64_TPREL16_HI
;
1162 case BFD_RELOC_PPC64_TPREL16_HIGH
: r
= R_PPC64_TPREL16_HIGH
;
1164 case BFD_RELOC_PPC_TPREL16_HA
: r
= R_PPC64_TPREL16_HA
;
1166 case BFD_RELOC_PPC64_TPREL16_HIGHA
: r
= R_PPC64_TPREL16_HIGHA
;
1168 case BFD_RELOC_PPC_TPREL
: r
= R_PPC64_TPREL64
;
1170 case BFD_RELOC_PPC_DTPREL16
: r
= R_PPC64_DTPREL16
;
1172 case BFD_RELOC_PPC_DTPREL16_LO
: r
= R_PPC64_DTPREL16_LO
;
1174 case BFD_RELOC_PPC_DTPREL16_HI
: r
= R_PPC64_DTPREL16_HI
;
1176 case BFD_RELOC_PPC64_DTPREL16_HIGH
: r
= R_PPC64_DTPREL16_HIGH
;
1178 case BFD_RELOC_PPC_DTPREL16_HA
: r
= R_PPC64_DTPREL16_HA
;
1180 case BFD_RELOC_PPC64_DTPREL16_HIGHA
: r
= R_PPC64_DTPREL16_HIGHA
;
1182 case BFD_RELOC_PPC_DTPREL
: r
= R_PPC64_DTPREL64
;
1184 case BFD_RELOC_PPC_GOT_TLSGD16
: r
= R_PPC64_GOT_TLSGD16
;
1186 case BFD_RELOC_PPC_GOT_TLSGD16_LO
: r
= R_PPC64_GOT_TLSGD16_LO
;
1188 case BFD_RELOC_PPC_GOT_TLSGD16_HI
: r
= R_PPC64_GOT_TLSGD16_HI
;
1190 case BFD_RELOC_PPC_GOT_TLSGD16_HA
: r
= R_PPC64_GOT_TLSGD16_HA
;
1192 case BFD_RELOC_PPC_GOT_TLSLD16
: r
= R_PPC64_GOT_TLSLD16
;
1194 case BFD_RELOC_PPC_GOT_TLSLD16_LO
: r
= R_PPC64_GOT_TLSLD16_LO
;
1196 case BFD_RELOC_PPC_GOT_TLSLD16_HI
: r
= R_PPC64_GOT_TLSLD16_HI
;
1198 case BFD_RELOC_PPC_GOT_TLSLD16_HA
: r
= R_PPC64_GOT_TLSLD16_HA
;
1200 case BFD_RELOC_PPC_GOT_TPREL16
: r
= R_PPC64_GOT_TPREL16_DS
;
1202 case BFD_RELOC_PPC_GOT_TPREL16_LO
: r
= R_PPC64_GOT_TPREL16_LO_DS
;
1204 case BFD_RELOC_PPC_GOT_TPREL16_HI
: r
= R_PPC64_GOT_TPREL16_HI
;
1206 case BFD_RELOC_PPC_GOT_TPREL16_HA
: r
= R_PPC64_GOT_TPREL16_HA
;
1208 case BFD_RELOC_PPC_GOT_DTPREL16
: r
= R_PPC64_GOT_DTPREL16_DS
;
1210 case BFD_RELOC_PPC_GOT_DTPREL16_LO
: r
= R_PPC64_GOT_DTPREL16_LO_DS
;
1212 case BFD_RELOC_PPC_GOT_DTPREL16_HI
: r
= R_PPC64_GOT_DTPREL16_HI
;
1214 case BFD_RELOC_PPC_GOT_DTPREL16_HA
: r
= R_PPC64_GOT_DTPREL16_HA
;
1216 case BFD_RELOC_PPC64_TPREL16_DS
: r
= R_PPC64_TPREL16_DS
;
1218 case BFD_RELOC_PPC64_TPREL16_LO_DS
: r
= R_PPC64_TPREL16_LO_DS
;
1220 case BFD_RELOC_PPC64_TPREL16_HIGHER
: r
= R_PPC64_TPREL16_HIGHER
;
1222 case BFD_RELOC_PPC64_TPREL16_HIGHERA
: r
= R_PPC64_TPREL16_HIGHERA
;
1224 case BFD_RELOC_PPC64_TPREL16_HIGHEST
: r
= R_PPC64_TPREL16_HIGHEST
;
1226 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
: r
= R_PPC64_TPREL16_HIGHESTA
;
1228 case BFD_RELOC_PPC64_DTPREL16_DS
: r
= R_PPC64_DTPREL16_DS
;
1230 case BFD_RELOC_PPC64_DTPREL16_LO_DS
: r
= R_PPC64_DTPREL16_LO_DS
;
1232 case BFD_RELOC_PPC64_DTPREL16_HIGHER
: r
= R_PPC64_DTPREL16_HIGHER
;
1234 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
: r
= R_PPC64_DTPREL16_HIGHERA
;
1236 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
: r
= R_PPC64_DTPREL16_HIGHEST
;
1238 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
: r
= R_PPC64_DTPREL16_HIGHESTA
;
1240 case BFD_RELOC_16_PCREL
: r
= R_PPC64_REL16
;
1242 case BFD_RELOC_LO16_PCREL
: r
= R_PPC64_REL16_LO
;
1244 case BFD_RELOC_HI16_PCREL
: r
= R_PPC64_REL16_HI
;
1246 case BFD_RELOC_HI16_S_PCREL
: r
= R_PPC64_REL16_HA
;
1248 case BFD_RELOC_PPC64_REL16_HIGH
: r
= R_PPC64_REL16_HIGH
;
1250 case BFD_RELOC_PPC64_REL16_HIGHA
: r
= R_PPC64_REL16_HIGHA
;
1252 case BFD_RELOC_PPC64_REL16_HIGHER
: r
= R_PPC64_REL16_HIGHER
;
1254 case BFD_RELOC_PPC64_REL16_HIGHERA
: r
= R_PPC64_REL16_HIGHERA
;
1256 case BFD_RELOC_PPC64_REL16_HIGHEST
: r
= R_PPC64_REL16_HIGHEST
;
1258 case BFD_RELOC_PPC64_REL16_HIGHESTA
: r
= R_PPC64_REL16_HIGHESTA
;
1260 case BFD_RELOC_PPC_16DX_HA
: r
= R_PPC64_16DX_HA
;
1262 case BFD_RELOC_PPC_REL16DX_HA
: r
= R_PPC64_REL16DX_HA
;
1264 case BFD_RELOC_PPC64_ENTRY
: r
= R_PPC64_ENTRY
;
1266 case BFD_RELOC_PPC64_ADDR64_LOCAL
: r
= R_PPC64_ADDR64_LOCAL
;
1268 case BFD_RELOC_PPC64_D34
: r
= R_PPC64_D34
;
1270 case BFD_RELOC_PPC64_D34_LO
: r
= R_PPC64_D34_LO
;
1272 case BFD_RELOC_PPC64_D34_HI30
: r
= R_PPC64_D34_HI30
;
1274 case BFD_RELOC_PPC64_D34_HA30
: r
= R_PPC64_D34_HA30
;
1276 case BFD_RELOC_PPC64_PCREL34
: r
= R_PPC64_PCREL34
;
1278 case BFD_RELOC_PPC64_GOT_PCREL34
: r
= R_PPC64_GOT_PCREL34
;
1280 case BFD_RELOC_PPC64_PLT_PCREL34
: r
= R_PPC64_PLT_PCREL34
;
1282 case BFD_RELOC_PPC64_TPREL34
: r
= R_PPC64_TPREL34
;
1284 case BFD_RELOC_PPC64_DTPREL34
: r
= R_PPC64_DTPREL34
;
1286 case BFD_RELOC_PPC64_GOT_TLSGD_PCREL34
: r
= R_PPC64_GOT_TLSGD_PCREL34
;
1288 case BFD_RELOC_PPC64_GOT_TLSLD_PCREL34
: r
= R_PPC64_GOT_TLSLD_PCREL34
;
1290 case BFD_RELOC_PPC64_GOT_TPREL_PCREL34
: r
= R_PPC64_GOT_TPREL_PCREL34
;
1292 case BFD_RELOC_PPC64_GOT_DTPREL_PCREL34
: r
= R_PPC64_GOT_DTPREL_PCREL34
;
1294 case BFD_RELOC_PPC64_ADDR16_HIGHER34
: r
= R_PPC64_ADDR16_HIGHER34
;
1296 case BFD_RELOC_PPC64_ADDR16_HIGHERA34
: r
= R_PPC64_ADDR16_HIGHERA34
;
1298 case BFD_RELOC_PPC64_ADDR16_HIGHEST34
: r
= R_PPC64_ADDR16_HIGHEST34
;
1300 case BFD_RELOC_PPC64_ADDR16_HIGHESTA34
: r
= R_PPC64_ADDR16_HIGHESTA34
;
1302 case BFD_RELOC_PPC64_REL16_HIGHER34
: r
= R_PPC64_REL16_HIGHER34
;
1304 case BFD_RELOC_PPC64_REL16_HIGHERA34
: r
= R_PPC64_REL16_HIGHERA34
;
1306 case BFD_RELOC_PPC64_REL16_HIGHEST34
: r
= R_PPC64_REL16_HIGHEST34
;
1308 case BFD_RELOC_PPC64_REL16_HIGHESTA34
: r
= R_PPC64_REL16_HIGHESTA34
;
1310 case BFD_RELOC_PPC64_D28
: r
= R_PPC64_D28
;
1312 case BFD_RELOC_PPC64_PCREL28
: r
= R_PPC64_PCREL28
;
1314 case BFD_RELOC_VTABLE_INHERIT
: r
= R_PPC64_GNU_VTINHERIT
;
1316 case BFD_RELOC_VTABLE_ENTRY
: r
= R_PPC64_GNU_VTENTRY
;
1320 return ppc64_elf_howto_table
[r
];
1323 static reloc_howto_type
*
1324 ppc64_elf_reloc_name_lookup (bfd
*abfd
, const char *r_name
)
1327 static char *compat_map
[][2] = {
1328 { "R_PPC64_GOT_TLSGD34", "R_PPC64_GOT_TLSGD_PCREL34" },
1329 { "R_PPC64_GOT_TLSLD34", "R_PPC64_GOT_TLSLD_PCREL34" },
1330 { "R_PPC64_GOT_TPREL34", "R_PPC64_GOT_TPREL_PCREL34" },
1331 { "R_PPC64_GOT_DTPREL34", "R_PPC64_GOT_DTPREL_PCREL34" }
1334 for (i
= 0; i
< ARRAY_SIZE (ppc64_elf_howto_raw
); i
++)
1335 if (ppc64_elf_howto_raw
[i
].name
!= NULL
1336 && strcasecmp (ppc64_elf_howto_raw
[i
].name
, r_name
) == 0)
1337 return &ppc64_elf_howto_raw
[i
];
1339 /* Handle old names of relocations in case they were used by
1341 FIXME: Remove this soon. Mapping the reloc names is very likely
1342 completely unnecessary. */
1343 for (i
= 0; i
< ARRAY_SIZE (compat_map
); i
++)
1344 if (strcasecmp (compat_map
[i
][0], r_name
) == 0)
1346 _bfd_error_handler (_("warning: %s should be used rather than %s"),
1347 compat_map
[i
][1], compat_map
[i
][0]);
1348 return ppc64_elf_reloc_name_lookup (abfd
, compat_map
[i
][1]);
1354 /* Set the howto pointer for a PowerPC ELF reloc. */
1357 ppc64_elf_info_to_howto (bfd
*abfd
, arelent
*cache_ptr
,
1358 Elf_Internal_Rela
*dst
)
1362 /* Initialize howto table if needed. */
1363 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
1366 type
= ELF64_R_TYPE (dst
->r_info
);
1367 if (type
>= ARRAY_SIZE (ppc64_elf_howto_table
))
1369 /* xgettext:c-format */
1370 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
1372 bfd_set_error (bfd_error_bad_value
);
1375 cache_ptr
->howto
= ppc64_elf_howto_table
[type
];
1376 if (cache_ptr
->howto
== NULL
|| cache_ptr
->howto
->name
== NULL
)
1378 /* xgettext:c-format */
1379 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
1381 bfd_set_error (bfd_error_bad_value
);
1388 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
1390 static bfd_reloc_status_type
1391 ppc64_elf_ha_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1392 void *data
, asection
*input_section
,
1393 bfd
*output_bfd
, char **error_message
)
1395 enum elf_ppc64_reloc_type r_type
;
1397 bfd_size_type octets
;
1400 /* If this is a relocatable link (output_bfd test tells us), just
1401 call the generic function. Any adjustment will be done at final
1403 if (output_bfd
!= NULL
)
1404 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1405 input_section
, output_bfd
, error_message
);
1407 /* Adjust the addend for sign extension of the low 16 (or 34) bits.
1408 We won't actually be using the low bits, so trashing them
1410 r_type
= reloc_entry
->howto
->type
;
1411 if (r_type
== R_PPC64_ADDR16_HIGHERA34
1412 || r_type
== R_PPC64_ADDR16_HIGHESTA34
1413 || r_type
== R_PPC64_REL16_HIGHERA34
1414 || r_type
== R_PPC64_REL16_HIGHESTA34
)
1415 reloc_entry
->addend
+= 1ULL << 33;
1417 reloc_entry
->addend
+= 1U << 15;
1418 if (r_type
!= R_PPC64_REL16DX_HA
)
1419 return bfd_reloc_continue
;
1422 if (!bfd_is_com_section (symbol
->section
))
1423 value
= symbol
->value
;
1424 value
+= (reloc_entry
->addend
1425 + symbol
->section
->output_offset
1426 + symbol
->section
->output_section
->vma
);
1427 value
-= (reloc_entry
->address
1428 + input_section
->output_offset
1429 + input_section
->output_section
->vma
);
1430 value
= (bfd_signed_vma
) value
>> 16;
1432 octets
= reloc_entry
->address
* OCTETS_PER_BYTE (abfd
, input_section
);
1433 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ octets
);
1435 insn
|= (value
& 0xffc1) | ((value
& 0x3e) << 15);
1436 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ octets
);
1437 if (value
+ 0x8000 > 0xffff)
1438 return bfd_reloc_overflow
;
1439 return bfd_reloc_ok
;
1442 static bfd_reloc_status_type
1443 ppc64_elf_branch_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1444 void *data
, asection
*input_section
,
1445 bfd
*output_bfd
, char **error_message
)
1447 if (output_bfd
!= NULL
)
1448 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1449 input_section
, output_bfd
, error_message
);
1451 if (strcmp (symbol
->section
->name
, ".opd") == 0
1452 && (symbol
->section
->owner
->flags
& DYNAMIC
) == 0)
1454 bfd_vma dest
= opd_entry_value (symbol
->section
,
1455 symbol
->value
+ reloc_entry
->addend
,
1457 if (dest
!= (bfd_vma
) -1)
1458 reloc_entry
->addend
= dest
- (symbol
->value
1459 + symbol
->section
->output_section
->vma
1460 + symbol
->section
->output_offset
);
1464 elf_symbol_type
*elfsym
= (elf_symbol_type
*) symbol
;
1466 if (symbol
->section
->owner
!= abfd
1467 && symbol
->section
->owner
!= NULL
1468 && abiversion (symbol
->section
->owner
) >= 2)
1472 for (i
= 0; i
< symbol
->section
->owner
->symcount
; ++i
)
1474 asymbol
*symdef
= symbol
->section
->owner
->outsymbols
[i
];
1476 if (strcmp (symdef
->name
, symbol
->name
) == 0)
1478 elfsym
= (elf_symbol_type
*) symdef
;
1484 += PPC64_LOCAL_ENTRY_OFFSET (elfsym
->internal_elf_sym
.st_other
);
1486 return bfd_reloc_continue
;
1489 static bfd_reloc_status_type
1490 ppc64_elf_brtaken_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1491 void *data
, asection
*input_section
,
1492 bfd
*output_bfd
, char **error_message
)
1495 enum elf_ppc64_reloc_type r_type
;
1496 bfd_size_type octets
;
1497 /* Assume 'at' branch hints. */
1498 bfd_boolean is_isa_v2
= TRUE
;
1500 /* If this is a relocatable link (output_bfd test tells us), just
1501 call the generic function. Any adjustment will be done at final
1503 if (output_bfd
!= NULL
)
1504 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1505 input_section
, output_bfd
, error_message
);
1507 octets
= reloc_entry
->address
* OCTETS_PER_BYTE (abfd
, input_section
);
1508 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ octets
);
1509 insn
&= ~(0x01 << 21);
1510 r_type
= reloc_entry
->howto
->type
;
1511 if (r_type
== R_PPC64_ADDR14_BRTAKEN
1512 || r_type
== R_PPC64_REL14_BRTAKEN
)
1513 insn
|= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
1517 /* Set 'a' bit. This is 0b00010 in BO field for branch
1518 on CR(BI) insns (BO == 001at or 011at), and 0b01000
1519 for branch on CTR insns (BO == 1a00t or 1a01t). */
1520 if ((insn
& (0x14 << 21)) == (0x04 << 21))
1522 else if ((insn
& (0x14 << 21)) == (0x10 << 21))
1532 if (!bfd_is_com_section (symbol
->section
))
1533 target
= symbol
->value
;
1534 target
+= symbol
->section
->output_section
->vma
;
1535 target
+= symbol
->section
->output_offset
;
1536 target
+= reloc_entry
->addend
;
1538 from
= (reloc_entry
->address
1539 + input_section
->output_offset
1540 + input_section
->output_section
->vma
);
1542 /* Invert 'y' bit if not the default. */
1543 if ((bfd_signed_vma
) (target
- from
) < 0)
1546 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ octets
);
1548 return ppc64_elf_branch_reloc (abfd
, reloc_entry
, symbol
, data
,
1549 input_section
, output_bfd
, error_message
);
1552 static bfd_reloc_status_type
1553 ppc64_elf_sectoff_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1554 void *data
, asection
*input_section
,
1555 bfd
*output_bfd
, char **error_message
)
1557 /* If this is a relocatable link (output_bfd test tells us), just
1558 call the generic function. Any adjustment will be done at final
1560 if (output_bfd
!= NULL
)
1561 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1562 input_section
, output_bfd
, error_message
);
1564 /* Subtract the symbol section base address. */
1565 reloc_entry
->addend
-= symbol
->section
->output_section
->vma
;
1566 return bfd_reloc_continue
;
1569 static bfd_reloc_status_type
1570 ppc64_elf_sectoff_ha_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1571 void *data
, asection
*input_section
,
1572 bfd
*output_bfd
, char **error_message
)
1574 /* If this is a relocatable link (output_bfd test tells us), just
1575 call the generic function. Any adjustment will be done at final
1577 if (output_bfd
!= NULL
)
1578 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1579 input_section
, output_bfd
, error_message
);
1581 /* Subtract the symbol section base address. */
1582 reloc_entry
->addend
-= symbol
->section
->output_section
->vma
;
1584 /* Adjust the addend for sign extension of the low 16 bits. */
1585 reloc_entry
->addend
+= 0x8000;
1586 return bfd_reloc_continue
;
1589 static bfd_reloc_status_type
1590 ppc64_elf_toc_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1591 void *data
, asection
*input_section
,
1592 bfd
*output_bfd
, char **error_message
)
1596 /* If this is a relocatable link (output_bfd test tells us), just
1597 call the generic function. Any adjustment will be done at final
1599 if (output_bfd
!= NULL
)
1600 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1601 input_section
, output_bfd
, error_message
);
1603 TOCstart
= _bfd_get_gp_value (input_section
->output_section
->owner
);
1605 TOCstart
= ppc64_elf_set_toc (NULL
, input_section
->output_section
->owner
);
1607 /* Subtract the TOC base address. */
1608 reloc_entry
->addend
-= TOCstart
+ TOC_BASE_OFF
;
1609 return bfd_reloc_continue
;
1612 static bfd_reloc_status_type
1613 ppc64_elf_toc_ha_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1614 void *data
, asection
*input_section
,
1615 bfd
*output_bfd
, char **error_message
)
1619 /* If this is a relocatable link (output_bfd test tells us), just
1620 call the generic function. Any adjustment will be done at final
1622 if (output_bfd
!= NULL
)
1623 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1624 input_section
, output_bfd
, error_message
);
1626 TOCstart
= _bfd_get_gp_value (input_section
->output_section
->owner
);
1628 TOCstart
= ppc64_elf_set_toc (NULL
, input_section
->output_section
->owner
);
1630 /* Subtract the TOC base address. */
1631 reloc_entry
->addend
-= TOCstart
+ TOC_BASE_OFF
;
1633 /* Adjust the addend for sign extension of the low 16 bits. */
1634 reloc_entry
->addend
+= 0x8000;
1635 return bfd_reloc_continue
;
1638 static bfd_reloc_status_type
1639 ppc64_elf_toc64_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1640 void *data
, asection
*input_section
,
1641 bfd
*output_bfd
, char **error_message
)
1644 bfd_size_type octets
;
1646 /* If this is a relocatable link (output_bfd test tells us), just
1647 call the generic function. Any adjustment will be done at final
1649 if (output_bfd
!= NULL
)
1650 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1651 input_section
, output_bfd
, error_message
);
1653 TOCstart
= _bfd_get_gp_value (input_section
->output_section
->owner
);
1655 TOCstart
= ppc64_elf_set_toc (NULL
, input_section
->output_section
->owner
);
1657 octets
= reloc_entry
->address
* OCTETS_PER_BYTE (abfd
, input_section
);
1658 bfd_put_64 (abfd
, TOCstart
+ TOC_BASE_OFF
, (bfd_byte
*) data
+ octets
);
1659 return bfd_reloc_ok
;
1662 static bfd_reloc_status_type
1663 ppc64_elf_prefix_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1664 void *data
, asection
*input_section
,
1665 bfd
*output_bfd
, char **error_message
)
1670 if (output_bfd
!= NULL
)
1671 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1672 input_section
, output_bfd
, error_message
);
1674 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1676 insn
|= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
+ 4);
1678 targ
= (symbol
->section
->output_section
->vma
1679 + symbol
->section
->output_offset
1680 + reloc_entry
->addend
);
1681 if (!bfd_is_com_section (symbol
->section
))
1682 targ
+= symbol
->value
;
1683 if (reloc_entry
->howto
->type
== R_PPC64_D34_HA30
)
1685 if (reloc_entry
->howto
->pc_relative
)
1687 bfd_vma from
= (reloc_entry
->address
1688 + input_section
->output_offset
1689 + input_section
->output_section
->vma
);
1692 targ
>>= reloc_entry
->howto
->rightshift
;
1693 insn
&= ~reloc_entry
->howto
->dst_mask
;
1694 insn
|= ((targ
<< 16) | (targ
& 0xffff)) & reloc_entry
->howto
->dst_mask
;
1695 bfd_put_32 (abfd
, insn
>> 32, (bfd_byte
*) data
+ reloc_entry
->address
);
1696 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ reloc_entry
->address
+ 4);
1697 if (reloc_entry
->howto
->complain_on_overflow
== complain_overflow_signed
1698 && (targ
+ (1ULL << (reloc_entry
->howto
->bitsize
- 1))
1699 >= 1ULL << reloc_entry
->howto
->bitsize
))
1700 return bfd_reloc_overflow
;
1701 return bfd_reloc_ok
;
1704 static bfd_reloc_status_type
1705 ppc64_elf_unhandled_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1706 void *data
, asection
*input_section
,
1707 bfd
*output_bfd
, char **error_message
)
1709 /* If this is a relocatable link (output_bfd test tells us), just
1710 call the generic function. Any adjustment will be done at final
1712 if (output_bfd
!= NULL
)
1713 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1714 input_section
, output_bfd
, error_message
);
1716 if (error_message
!= NULL
)
1718 static char *message
;
1720 if (asprintf (&message
, _("generic linker can't handle %s"),
1721 reloc_entry
->howto
->name
) < 0)
1723 *error_message
= message
;
1725 return bfd_reloc_dangerous
;
1728 /* Track GOT entries needed for a given symbol. We might need more
1729 than one got entry per symbol. */
1732 struct got_entry
*next
;
1734 /* The symbol addend that we'll be placing in the GOT. */
1737 /* Unlike other ELF targets, we use separate GOT entries for the same
1738 symbol referenced from different input files. This is to support
1739 automatic multiple TOC/GOT sections, where the TOC base can vary
1740 from one input file to another. After partitioning into TOC groups
1741 we merge entries within the group.
1743 Point to the BFD owning this GOT entry. */
1746 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
1747 TLS_TPREL or TLS_DTPREL for tls entries. */
1748 unsigned char tls_type
;
1750 /* Non-zero if got.ent points to real entry. */
1751 unsigned char is_indirect
;
1753 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
1756 bfd_signed_vma refcount
;
1758 struct got_entry
*ent
;
1762 /* The same for PLT. */
1765 struct plt_entry
*next
;
1771 bfd_signed_vma refcount
;
1776 struct ppc64_elf_obj_tdata
1778 struct elf_obj_tdata elf
;
1780 /* Shortcuts to dynamic linker sections. */
1784 /* Used during garbage collection. We attach global symbols defined
1785 on removed .opd entries to this section so that the sym is removed. */
1786 asection
*deleted_section
;
1788 /* TLS local dynamic got entry handling. Support for multiple GOT
1789 sections means we potentially need one of these for each input bfd. */
1790 struct got_entry tlsld_got
;
1794 /* A copy of relocs before they are modified for --emit-relocs. */
1795 Elf_Internal_Rela
*relocs
;
1797 /* Section contents. */
1801 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
1802 the reloc to be in the range -32768 to 32767. */
1803 unsigned int has_small_toc_reloc
: 1;
1805 /* Set if toc/got ha relocs detected not using r2, or lo reloc
1806 instruction not one we handle. */
1807 unsigned int unexpected_toc_insn
: 1;
1809 /* Set if PLT/GOT/TOC relocs that can be optimised are present in
1811 unsigned int has_optrel
: 1;
1814 #define ppc64_elf_tdata(bfd) \
1815 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
1817 #define ppc64_tlsld_got(bfd) \
1818 (&ppc64_elf_tdata (bfd)->tlsld_got)
1820 #define is_ppc64_elf(bfd) \
1821 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
1822 && elf_object_id (bfd) == PPC64_ELF_DATA)
1824 /* Override the generic function because we store some extras. */
1827 ppc64_elf_mkobject (bfd
*abfd
)
1829 return bfd_elf_allocate_object (abfd
, sizeof (struct ppc64_elf_obj_tdata
),
1833 /* Fix bad default arch selected for a 64 bit input bfd when the
1834 default is 32 bit. Also select arch based on apuinfo. */
1837 ppc64_elf_object_p (bfd
*abfd
)
1839 if (!abfd
->arch_info
->the_default
)
1842 if (abfd
->arch_info
->bits_per_word
== 32)
1844 Elf_Internal_Ehdr
*i_ehdr
= elf_elfheader (abfd
);
1846 if (i_ehdr
->e_ident
[EI_CLASS
] == ELFCLASS64
)
1848 /* Relies on arch after 32 bit default being 64 bit default. */
1849 abfd
->arch_info
= abfd
->arch_info
->next
;
1850 BFD_ASSERT (abfd
->arch_info
->bits_per_word
== 64);
1853 return _bfd_elf_ppc_set_arch (abfd
);
1856 /* Support for core dump NOTE sections. */
1859 ppc64_elf_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
1861 size_t offset
, size
;
1863 if (note
->descsz
!= 504)
1867 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
1870 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 32);
1876 /* Make a ".reg/999" section. */
1877 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
1878 size
, note
->descpos
+ offset
);
1882 ppc64_elf_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
1884 if (note
->descsz
!= 136)
1887 elf_tdata (abfd
)->core
->pid
1888 = bfd_get_32 (abfd
, note
->descdata
+ 24);
1889 elf_tdata (abfd
)->core
->program
1890 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 40, 16);
1891 elf_tdata (abfd
)->core
->command
1892 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 56, 80);
1898 ppc64_elf_write_core_note (bfd
*abfd
, char *buf
, int *bufsiz
, int note_type
,
1908 char data
[136] ATTRIBUTE_NONSTRING
;
1911 va_start (ap
, note_type
);
1912 memset (data
, 0, sizeof (data
));
1913 strncpy (data
+ 40, va_arg (ap
, const char *), 16);
1914 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
1916 /* GCC 8.0 and 8.1 warn about 80 equals destination size with
1917 -Wstringop-truncation:
1918 https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85643
1920 DIAGNOSTIC_IGNORE_STRINGOP_TRUNCATION
;
1922 strncpy (data
+ 56, va_arg (ap
, const char *), 80);
1923 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
1927 return elfcore_write_note (abfd
, buf
, bufsiz
,
1928 "CORE", note_type
, data
, sizeof (data
));
1939 va_start (ap
, note_type
);
1940 memset (data
, 0, 112);
1941 pid
= va_arg (ap
, long);
1942 bfd_put_32 (abfd
, pid
, data
+ 32);
1943 cursig
= va_arg (ap
, int);
1944 bfd_put_16 (abfd
, cursig
, data
+ 12);
1945 greg
= va_arg (ap
, const void *);
1946 memcpy (data
+ 112, greg
, 384);
1947 memset (data
+ 496, 0, 8);
1949 return elfcore_write_note (abfd
, buf
, bufsiz
,
1950 "CORE", note_type
, data
, sizeof (data
));
1955 /* Add extra PPC sections. */
1957 static const struct bfd_elf_special_section ppc64_elf_special_sections
[] =
1959 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS
, 0 },
1960 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
1961 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
1962 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
1963 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
1964 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
1965 { NULL
, 0, 0, 0, 0 }
1968 enum _ppc64_sec_type
{
1974 struct _ppc64_elf_section_data
1976 struct bfd_elf_section_data elf
;
1980 /* An array with one entry for each opd function descriptor,
1981 and some spares since opd entries may be either 16 or 24 bytes. */
1982 #define OPD_NDX(OFF) ((OFF) >> 4)
1983 struct _opd_sec_data
1985 /* Points to the function code section for local opd entries. */
1986 asection
**func_sec
;
1988 /* After editing .opd, adjust references to opd local syms. */
1992 /* An array for toc sections, indexed by offset/8. */
1993 struct _toc_sec_data
1995 /* Specifies the relocation symbol index used at a given toc offset. */
1998 /* And the relocation addend. */
2003 enum _ppc64_sec_type sec_type
:2;
2005 /* Flag set when small branches are detected. Used to
2006 select suitable defaults for the stub group size. */
2007 unsigned int has_14bit_branch
:1;
2009 /* Flag set when PLTCALL relocs are detected. */
2010 unsigned int has_pltcall
:1;
2012 /* Flag set when section has PLT/GOT/TOC relocations that can be
2014 unsigned int has_optrel
:1;
2017 #define ppc64_elf_section_data(sec) \
2018 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2021 ppc64_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
2023 if (!sec
->used_by_bfd
)
2025 struct _ppc64_elf_section_data
*sdata
;
2026 size_t amt
= sizeof (*sdata
);
2028 sdata
= bfd_zalloc (abfd
, amt
);
2031 sec
->used_by_bfd
= sdata
;
2034 return _bfd_elf_new_section_hook (abfd
, sec
);
2038 ppc64_elf_section_flags (const Elf_Internal_Shdr
*hdr
)
2040 const char *name
= hdr
->bfd_section
->name
;
2042 if (strncmp (name
, ".sbss", 5) == 0
2043 || strncmp (name
, ".sdata", 6) == 0)
2044 hdr
->bfd_section
->flags
|= SEC_SMALL_DATA
;
2049 static struct _opd_sec_data
*
2050 get_opd_info (asection
* sec
)
2053 && ppc64_elf_section_data (sec
) != NULL
2054 && ppc64_elf_section_data (sec
)->sec_type
== sec_opd
)
2055 return &ppc64_elf_section_data (sec
)->u
.opd
;
2059 /* Parameters for the qsort hook. */
2060 static bfd_boolean synthetic_relocatable
;
2061 static const asection
*synthetic_opd
;
2063 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
2066 compare_symbols (const void *ap
, const void *bp
)
2068 const asymbol
*a
= *(const asymbol
**) ap
;
2069 const asymbol
*b
= *(const asymbol
**) bp
;
2071 /* Section symbols first. */
2072 if ((a
->flags
& BSF_SECTION_SYM
) && !(b
->flags
& BSF_SECTION_SYM
))
2074 if (!(a
->flags
& BSF_SECTION_SYM
) && (b
->flags
& BSF_SECTION_SYM
))
2077 /* then .opd symbols. */
2078 if (synthetic_opd
!= NULL
)
2080 if (strcmp (a
->section
->name
, ".opd") == 0
2081 && strcmp (b
->section
->name
, ".opd") != 0)
2083 if (strcmp (a
->section
->name
, ".opd") != 0
2084 && strcmp (b
->section
->name
, ".opd") == 0)
2088 /* then other code symbols. */
2089 if (((a
->section
->flags
& (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
))
2090 == (SEC_CODE
| SEC_ALLOC
))
2091 && ((b
->section
->flags
& (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
))
2092 != (SEC_CODE
| SEC_ALLOC
)))
2095 if (((a
->section
->flags
& (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
))
2096 != (SEC_CODE
| SEC_ALLOC
))
2097 && ((b
->section
->flags
& (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
))
2098 == (SEC_CODE
| SEC_ALLOC
)))
2101 if (synthetic_relocatable
)
2103 if (a
->section
->id
< b
->section
->id
)
2106 if (a
->section
->id
> b
->section
->id
)
2110 if (a
->value
+ a
->section
->vma
< b
->value
+ b
->section
->vma
)
2113 if (a
->value
+ a
->section
->vma
> b
->value
+ b
->section
->vma
)
2116 /* For syms with the same value, prefer strong dynamic global function
2117 syms over other syms. */
2118 if ((a
->flags
& BSF_GLOBAL
) != 0 && (b
->flags
& BSF_GLOBAL
) == 0)
2121 if ((a
->flags
& BSF_GLOBAL
) == 0 && (b
->flags
& BSF_GLOBAL
) != 0)
2124 if ((a
->flags
& BSF_FUNCTION
) != 0 && (b
->flags
& BSF_FUNCTION
) == 0)
2127 if ((a
->flags
& BSF_FUNCTION
) == 0 && (b
->flags
& BSF_FUNCTION
) != 0)
2130 if ((a
->flags
& BSF_WEAK
) == 0 && (b
->flags
& BSF_WEAK
) != 0)
2133 if ((a
->flags
& BSF_WEAK
) != 0 && (b
->flags
& BSF_WEAK
) == 0)
2136 if ((a
->flags
& BSF_DYNAMIC
) != 0 && (b
->flags
& BSF_DYNAMIC
) == 0)
2139 if ((a
->flags
& BSF_DYNAMIC
) == 0 && (b
->flags
& BSF_DYNAMIC
) != 0)
2142 /* Finally, sort on where the symbol is in memory. The symbols will
2143 be in at most two malloc'd blocks, one for static syms, one for
2144 dynamic syms, and we distinguish the two blocks above by testing
2145 BSF_DYNAMIC. Since we are sorting the symbol pointers which were
2146 originally in the same order as the symbols (and we're not
2147 sorting the symbols themselves), this ensures a stable sort. */
2155 /* Search SYMS for a symbol of the given VALUE. */
2158 sym_exists_at (asymbol
**syms
, size_t lo
, size_t hi
, unsigned int id
,
2163 if (id
== (unsigned) -1)
2167 mid
= (lo
+ hi
) >> 1;
2168 if (syms
[mid
]->value
+ syms
[mid
]->section
->vma
< value
)
2170 else if (syms
[mid
]->value
+ syms
[mid
]->section
->vma
> value
)
2180 mid
= (lo
+ hi
) >> 1;
2181 if (syms
[mid
]->section
->id
< id
)
2183 else if (syms
[mid
]->section
->id
> id
)
2185 else if (syms
[mid
]->value
< value
)
2187 else if (syms
[mid
]->value
> value
)
2197 section_covers_vma (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*section
, void *ptr
)
2199 bfd_vma vma
= *(bfd_vma
*) ptr
;
2200 return ((section
->flags
& SEC_ALLOC
) != 0
2201 && section
->vma
<= vma
2202 && vma
< section
->vma
+ section
->size
);
2205 /* Create synthetic symbols, effectively restoring "dot-symbol" function
2206 entry syms. Also generate @plt symbols for the glink branch table.
2207 Returns count of synthetic symbols in RET or -1 on error. */
2210 ppc64_elf_get_synthetic_symtab (bfd
*abfd
,
2211 long static_count
, asymbol
**static_syms
,
2212 long dyn_count
, asymbol
**dyn_syms
,
2218 size_t symcount
, codesecsym
, codesecsymend
, secsymend
, opdsymend
;
2219 asection
*opd
= NULL
;
2220 bfd_boolean relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2222 int abi
= abiversion (abfd
);
2228 opd
= bfd_get_section_by_name (abfd
, ".opd");
2229 if (opd
== NULL
&& abi
== 1)
2241 symcount
= static_count
;
2243 symcount
+= dyn_count
;
2247 syms
= bfd_malloc ((symcount
+ 1) * sizeof (*syms
));
2251 if (!relocatable
&& static_count
!= 0 && dyn_count
!= 0)
2253 /* Use both symbol tables. */
2254 memcpy (syms
, static_syms
, static_count
* sizeof (*syms
));
2255 memcpy (syms
+ static_count
, dyn_syms
,
2256 (dyn_count
+ 1) * sizeof (*syms
));
2258 else if (!relocatable
&& static_count
== 0)
2259 memcpy (syms
, dyn_syms
, (symcount
+ 1) * sizeof (*syms
));
2261 memcpy (syms
, static_syms
, (symcount
+ 1) * sizeof (*syms
));
2263 /* Trim uninteresting symbols. Interesting symbols are section,
2264 function, and notype symbols. */
2265 for (i
= 0, j
= 0; i
< symcount
; ++i
)
2266 if ((syms
[i
]->flags
& (BSF_FILE
| BSF_OBJECT
| BSF_THREAD_LOCAL
2267 | BSF_RELC
| BSF_SRELC
)) == 0)
2268 syms
[j
++] = syms
[i
];
2271 synthetic_relocatable
= relocatable
;
2272 synthetic_opd
= opd
;
2273 qsort (syms
, symcount
, sizeof (*syms
), compare_symbols
);
2275 if (!relocatable
&& symcount
> 1)
2277 /* Trim duplicate syms, since we may have merged the normal
2278 and dynamic symbols. Actually, we only care about syms
2279 that have different values, so trim any with the same
2280 value. Don't consider ifunc and ifunc resolver symbols
2281 duplicates however, because GDB wants to know whether a
2282 text symbol is an ifunc resolver. */
2283 for (i
= 1, j
= 1; i
< symcount
; ++i
)
2285 const asymbol
*s0
= syms
[i
- 1];
2286 const asymbol
*s1
= syms
[i
];
2288 if ((s0
->value
+ s0
->section
->vma
2289 != s1
->value
+ s1
->section
->vma
)
2290 || ((s0
->flags
& BSF_GNU_INDIRECT_FUNCTION
)
2291 != (s1
->flags
& BSF_GNU_INDIRECT_FUNCTION
)))
2292 syms
[j
++] = syms
[i
];
2298 /* Note that here and in compare_symbols we can't compare opd and
2299 sym->section directly. With separate debug info files, the
2300 symbols will be extracted from the debug file while abfd passed
2301 to this function is the real binary. */
2302 if (strcmp (syms
[i
]->section
->name
, ".opd") == 0)
2306 for (; i
< symcount
; ++i
)
2307 if (((syms
[i
]->section
->flags
& (SEC_CODE
| SEC_ALLOC
2308 | SEC_THREAD_LOCAL
))
2309 != (SEC_CODE
| SEC_ALLOC
))
2310 || (syms
[i
]->flags
& BSF_SECTION_SYM
) == 0)
2314 for (; i
< symcount
; ++i
)
2315 if ((syms
[i
]->flags
& BSF_SECTION_SYM
) == 0)
2319 for (; i
< symcount
; ++i
)
2320 if (strcmp (syms
[i
]->section
->name
, ".opd") != 0)
2324 for (; i
< symcount
; ++i
)
2325 if (((syms
[i
]->section
->flags
2326 & (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
)))
2327 != (SEC_CODE
| SEC_ALLOC
))
2335 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
2340 if (opdsymend
== secsymend
)
2343 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
2344 relcount
= (opd
->flags
& SEC_RELOC
) ? opd
->reloc_count
: 0;
2348 if (!(*slurp_relocs
) (abfd
, opd
, static_syms
, FALSE
))
2355 for (i
= secsymend
, r
= opd
->relocation
; i
< opdsymend
; ++i
)
2359 while (r
< opd
->relocation
+ relcount
2360 && r
->address
< syms
[i
]->value
+ opd
->vma
)
2363 if (r
== opd
->relocation
+ relcount
)
2366 if (r
->address
!= syms
[i
]->value
+ opd
->vma
)
2369 if (r
->howto
->type
!= R_PPC64_ADDR64
)
2372 sym
= *r
->sym_ptr_ptr
;
2373 if (!sym_exists_at (syms
, opdsymend
, symcount
,
2374 sym
->section
->id
, sym
->value
+ r
->addend
))
2377 size
+= sizeof (asymbol
);
2378 size
+= strlen (syms
[i
]->name
) + 2;
2384 s
= *ret
= bfd_malloc (size
);
2391 names
= (char *) (s
+ count
);
2393 for (i
= secsymend
, r
= opd
->relocation
; i
< opdsymend
; ++i
)
2397 while (r
< opd
->relocation
+ relcount
2398 && r
->address
< syms
[i
]->value
+ opd
->vma
)
2401 if (r
== opd
->relocation
+ relcount
)
2404 if (r
->address
!= syms
[i
]->value
+ opd
->vma
)
2407 if (r
->howto
->type
!= R_PPC64_ADDR64
)
2410 sym
= *r
->sym_ptr_ptr
;
2411 if (!sym_exists_at (syms
, opdsymend
, symcount
,
2412 sym
->section
->id
, sym
->value
+ r
->addend
))
2417 s
->flags
|= BSF_SYNTHETIC
;
2418 s
->section
= sym
->section
;
2419 s
->value
= sym
->value
+ r
->addend
;
2422 len
= strlen (syms
[i
]->name
);
2423 memcpy (names
, syms
[i
]->name
, len
+ 1);
2425 /* Have udata.p point back to the original symbol this
2426 synthetic symbol was derived from. */
2427 s
->udata
.p
= syms
[i
];
2434 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
2435 bfd_byte
*contents
= NULL
;
2437 size_t plt_count
= 0;
2438 bfd_vma glink_vma
= 0, resolv_vma
= 0;
2439 asection
*dynamic
, *glink
= NULL
, *relplt
= NULL
;
2442 if (opd
!= NULL
&& !bfd_malloc_and_get_section (abfd
, opd
, &contents
))
2444 free_contents_and_exit_err
:
2446 free_contents_and_exit
:
2452 for (i
= secsymend
; i
< opdsymend
; ++i
)
2456 /* Ignore bogus symbols. */
2457 if (syms
[i
]->value
> opd
->size
- 8)
2460 ent
= bfd_get_64 (abfd
, contents
+ syms
[i
]->value
);
2461 if (!sym_exists_at (syms
, opdsymend
, symcount
, -1, ent
))
2464 size
+= sizeof (asymbol
);
2465 size
+= strlen (syms
[i
]->name
) + 2;
2469 /* Get start of .glink stubs from DT_PPC64_GLINK. */
2471 && (dynamic
= bfd_get_section_by_name (abfd
, ".dynamic")) != NULL
)
2473 bfd_byte
*dynbuf
, *extdyn
, *extdynend
;
2475 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
2477 if (!bfd_malloc_and_get_section (abfd
, dynamic
, &dynbuf
))
2478 goto free_contents_and_exit_err
;
2480 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
2481 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
2484 extdynend
= extdyn
+ dynamic
->size
;
2485 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
2487 Elf_Internal_Dyn dyn
;
2488 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
2490 if (dyn
.d_tag
== DT_NULL
)
2493 if (dyn
.d_tag
== DT_PPC64_GLINK
)
2495 /* The first glink stub starts at DT_PPC64_GLINK plus 32.
2496 See comment in ppc64_elf_finish_dynamic_sections. */
2497 glink_vma
= dyn
.d_un
.d_val
+ 8 * 4;
2498 /* The .glink section usually does not survive the final
2499 link; search for the section (usually .text) where the
2500 glink stubs now reside. */
2501 glink
= bfd_sections_find_if (abfd
, section_covers_vma
,
2512 /* Determine __glink trampoline by reading the relative branch
2513 from the first glink stub. */
2515 unsigned int off
= 0;
2517 while (bfd_get_section_contents (abfd
, glink
, buf
,
2518 glink_vma
+ off
- glink
->vma
, 4))
2520 unsigned int insn
= bfd_get_32 (abfd
, buf
);
2522 if ((insn
& ~0x3fffffc) == 0)
2525 = glink_vma
+ off
+ (insn
^ 0x2000000) - 0x2000000;
2534 size
+= sizeof (asymbol
) + sizeof ("__glink_PLTresolve");
2536 relplt
= bfd_get_section_by_name (abfd
, ".rela.plt");
2539 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
2540 if (!(*slurp_relocs
) (abfd
, relplt
, dyn_syms
, TRUE
))
2541 goto free_contents_and_exit_err
;
2543 plt_count
= relplt
->size
/ sizeof (Elf64_External_Rela
);
2544 size
+= plt_count
* sizeof (asymbol
);
2546 p
= relplt
->relocation
;
2547 for (i
= 0; i
< plt_count
; i
++, p
++)
2549 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
2551 size
+= sizeof ("+0x") - 1 + 16;
2557 goto free_contents_and_exit
;
2558 s
= *ret
= bfd_malloc (size
);
2560 goto free_contents_and_exit_err
;
2562 names
= (char *) (s
+ count
+ plt_count
+ (resolv_vma
!= 0));
2564 for (i
= secsymend
; i
< opdsymend
; ++i
)
2568 if (syms
[i
]->value
> opd
->size
- 8)
2571 ent
= bfd_get_64 (abfd
, contents
+ syms
[i
]->value
);
2572 if (!sym_exists_at (syms
, opdsymend
, symcount
, -1, ent
))
2576 asection
*sec
= abfd
->sections
;
2583 size_t mid
= (lo
+ hi
) >> 1;
2584 if (syms
[mid
]->section
->vma
< ent
)
2586 else if (syms
[mid
]->section
->vma
> ent
)
2590 sec
= syms
[mid
]->section
;
2595 if (lo
>= hi
&& lo
> codesecsym
)
2596 sec
= syms
[lo
- 1]->section
;
2598 for (; sec
!= NULL
; sec
= sec
->next
)
2602 /* SEC_LOAD may not be set if SEC is from a separate debug
2604 if ((sec
->flags
& SEC_ALLOC
) == 0)
2606 if ((sec
->flags
& SEC_CODE
) != 0)
2609 s
->flags
|= BSF_SYNTHETIC
;
2610 s
->value
= ent
- s
->section
->vma
;
2613 len
= strlen (syms
[i
]->name
);
2614 memcpy (names
, syms
[i
]->name
, len
+ 1);
2616 /* Have udata.p point back to the original symbol this
2617 synthetic symbol was derived from. */
2618 s
->udata
.p
= syms
[i
];
2624 if (glink
!= NULL
&& relplt
!= NULL
)
2628 /* Add a symbol for the main glink trampoline. */
2629 memset (s
, 0, sizeof *s
);
2631 s
->flags
= BSF_GLOBAL
| BSF_SYNTHETIC
;
2633 s
->value
= resolv_vma
- glink
->vma
;
2635 memcpy (names
, "__glink_PLTresolve",
2636 sizeof ("__glink_PLTresolve"));
2637 names
+= sizeof ("__glink_PLTresolve");
2642 /* FIXME: It would be very much nicer to put sym@plt on the
2643 stub rather than on the glink branch table entry. The
2644 objdump disassembler would then use a sensible symbol
2645 name on plt calls. The difficulty in doing so is
2646 a) finding the stubs, and,
2647 b) matching stubs against plt entries, and,
2648 c) there can be multiple stubs for a given plt entry.
2650 Solving (a) could be done by code scanning, but older
2651 ppc64 binaries used different stubs to current code.
2652 (b) is the tricky one since you need to known the toc
2653 pointer for at least one function that uses a pic stub to
2654 be able to calculate the plt address referenced.
2655 (c) means gdb would need to set multiple breakpoints (or
2656 find the glink branch itself) when setting breakpoints
2657 for pending shared library loads. */
2658 p
= relplt
->relocation
;
2659 for (i
= 0; i
< plt_count
; i
++, p
++)
2663 *s
= **p
->sym_ptr_ptr
;
2664 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
2665 we are defining a symbol, ensure one of them is set. */
2666 if ((s
->flags
& BSF_LOCAL
) == 0)
2667 s
->flags
|= BSF_GLOBAL
;
2668 s
->flags
|= BSF_SYNTHETIC
;
2670 s
->value
= glink_vma
- glink
->vma
;
2673 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
2674 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
2678 memcpy (names
, "+0x", sizeof ("+0x") - 1);
2679 names
+= sizeof ("+0x") - 1;
2680 bfd_sprintf_vma (abfd
, names
, p
->addend
);
2681 names
+= strlen (names
);
2683 memcpy (names
, "@plt", sizeof ("@plt"));
2684 names
+= sizeof ("@plt");
2704 /* The following functions are specific to the ELF linker, while
2705 functions above are used generally. Those named ppc64_elf_* are
2706 called by the main ELF linker code. They appear in this file more
2707 or less in the order in which they are called. eg.
2708 ppc64_elf_check_relocs is called early in the link process,
2709 ppc64_elf_finish_dynamic_sections is one of the last functions
2712 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
2713 functions have both a function code symbol and a function descriptor
2714 symbol. A call to foo in a relocatable object file looks like:
2721 The function definition in another object file might be:
2725 . .quad .TOC.@tocbase
2731 When the linker resolves the call during a static link, the branch
2732 unsurprisingly just goes to .foo and the .opd information is unused.
2733 If the function definition is in a shared library, things are a little
2734 different: The call goes via a plt call stub, the opd information gets
2735 copied to the plt, and the linker patches the nop.
2743 . std 2,40(1) # in practice, the call stub
2744 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
2745 . addi 11,11,Lfoo@toc@l # this is the general idea
2753 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
2755 The "reloc ()" notation is supposed to indicate that the linker emits
2756 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
2759 What are the difficulties here? Well, firstly, the relocations
2760 examined by the linker in check_relocs are against the function code
2761 sym .foo, while the dynamic relocation in the plt is emitted against
2762 the function descriptor symbol, foo. Somewhere along the line, we need
2763 to carefully copy dynamic link information from one symbol to the other.
2764 Secondly, the generic part of the elf linker will make .foo a dynamic
2765 symbol as is normal for most other backends. We need foo dynamic
2766 instead, at least for an application final link. However, when
2767 creating a shared library containing foo, we need to have both symbols
2768 dynamic so that references to .foo are satisfied during the early
2769 stages of linking. Otherwise the linker might decide to pull in a
2770 definition from some other object, eg. a static library.
2772 Update: As of August 2004, we support a new convention. Function
2773 calls may use the function descriptor symbol, ie. "bl foo". This
2774 behaves exactly as "bl .foo". */
2776 /* Of those relocs that might be copied as dynamic relocs, this
2777 function selects those that must be copied when linking a shared
2778 library or PIE, even when the symbol is local. */
2781 must_be_dyn_reloc (struct bfd_link_info
*info
,
2782 enum elf_ppc64_reloc_type r_type
)
2787 /* Only relative relocs can be resolved when the object load
2788 address isn't fixed. DTPREL64 is excluded because the
2789 dynamic linker needs to differentiate global dynamic from
2790 local dynamic __tls_index pairs when PPC64_OPT_TLS is set. */
2797 case R_PPC64_TOC16_DS
:
2798 case R_PPC64_TOC16_LO
:
2799 case R_PPC64_TOC16_HI
:
2800 case R_PPC64_TOC16_HA
:
2801 case R_PPC64_TOC16_LO_DS
:
2804 case R_PPC64_TPREL16
:
2805 case R_PPC64_TPREL16_LO
:
2806 case R_PPC64_TPREL16_HI
:
2807 case R_PPC64_TPREL16_HA
:
2808 case R_PPC64_TPREL16_DS
:
2809 case R_PPC64_TPREL16_LO_DS
:
2810 case R_PPC64_TPREL16_HIGH
:
2811 case R_PPC64_TPREL16_HIGHA
:
2812 case R_PPC64_TPREL16_HIGHER
:
2813 case R_PPC64_TPREL16_HIGHERA
:
2814 case R_PPC64_TPREL16_HIGHEST
:
2815 case R_PPC64_TPREL16_HIGHESTA
:
2816 case R_PPC64_TPREL64
:
2817 case R_PPC64_TPREL34
:
2818 /* These relocations are relative but in a shared library the
2819 linker doesn't know the thread pointer base. */
2820 return bfd_link_dll (info
);
2824 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
2825 copying dynamic variables from a shared lib into an app's .dynbss
2826 section, and instead use a dynamic relocation to point into the
2827 shared lib. With code that gcc generates it is vital that this be
2828 enabled; In the PowerPC64 ELFv1 ABI the address of a function is
2829 actually the address of a function descriptor which resides in the
2830 .opd section. gcc uses the descriptor directly rather than going
2831 via the GOT as some other ABIs do, which means that initialized
2832 function pointers reference the descriptor. Thus, a function
2833 pointer initialized to the address of a function in a shared
2834 library will either require a .dynbss copy and a copy reloc, or a
2835 dynamic reloc. Using a .dynbss copy redefines the function
2836 descriptor symbol to point to the copy. This presents a problem as
2837 a PLT entry for that function is also initialized from the function
2838 descriptor symbol and the copy may not be initialized first. */
2839 #define ELIMINATE_COPY_RELOCS 1
2841 /* Section name for stubs is the associated section name plus this
2843 #define STUB_SUFFIX ".stub"
2846 ppc_stub_long_branch:
2847 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
2848 destination, but a 24 bit branch in a stub section will reach.
2851 ppc_stub_plt_branch:
2852 Similar to the above, but a 24 bit branch in the stub section won't
2853 reach its destination.
2854 . addis %r12,%r2,xxx@toc@ha
2855 . ld %r12,xxx@toc@l(%r12)
2860 Used to call a function in a shared library. If it so happens that
2861 the plt entry referenced crosses a 64k boundary, then an extra
2862 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
2863 ppc_stub_plt_call_r2save starts with "std %r2,40(%r1)".
2864 . addis %r11,%r2,xxx@toc@ha
2865 . ld %r12,xxx+0@toc@l(%r11)
2867 . ld %r2,xxx+8@toc@l(%r11)
2868 . ld %r11,xxx+16@toc@l(%r11)
2871 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
2872 code to adjust the value and save r2 to support multiple toc sections.
2873 A ppc_stub_long_branch with an r2 offset looks like:
2875 . addis %r2,%r2,off@ha
2876 . addi %r2,%r2,off@l
2879 A ppc_stub_plt_branch with an r2 offset looks like:
2881 . addis %r12,%r2,xxx@toc@ha
2882 . ld %r12,xxx@toc@l(%r12)
2883 . addis %r2,%r2,off@ha
2884 . addi %r2,%r2,off@l
2888 All of the above stubs are shown as their ELFv1 variants. ELFv2
2889 variants exist too, simpler for plt calls since a new toc pointer
2890 and static chain are not loaded by the stub. In addition, ELFv2
2891 has some more complex stubs to handle calls marked with NOTOC
2892 relocs from functions where r2 is not a valid toc pointer. These
2893 come in two flavours, the ones shown below, and _both variants that
2894 start with "std %r2,24(%r1)" to save r2 in the unlikely event that
2895 one call is from a function where r2 is used as the toc pointer but
2896 needs a toc adjusting stub for small-model multi-toc, and another
2897 call is from a function where r2 is not valid.
2898 ppc_stub_long_branch_notoc:
2904 . addis %r12,%r11,dest-1b@ha
2905 . addi %r12,%r12,dest-1b@l
2908 ppc_stub_plt_branch_notoc:
2914 . lis %r12,xxx-1b@highest
2915 . ori %r12,%r12,xxx-1b@higher
2917 . oris %r12,%r12,xxx-1b@high
2918 . ori %r12,%r12,xxx-1b@l
2919 . add %r12,%r11,%r12
2923 ppc_stub_plt_call_notoc:
2929 . lis %r12,xxx-1b@highest
2930 . ori %r12,%r12,xxx-1b@higher
2932 . oris %r12,%r12,xxx-1b@high
2933 . ori %r12,%r12,xxx-1b@l
2934 . ldx %r12,%r11,%r12
2938 There are also ELFv1 power10 variants of these stubs.
2939 ppc_stub_long_branch_notoc:
2940 . pla %r12,dest@pcrel
2942 ppc_stub_plt_branch_notoc:
2943 . lis %r11,(dest-1f)@highesta34
2944 . ori %r11,%r11,(dest-1f)@highera34
2946 . 1: pla %r12,dest@pcrel
2947 . add %r12,%r11,%r12
2950 ppc_stub_plt_call_notoc:
2951 . lis %r11,(xxx-1f)@highesta34
2952 . ori %r11,%r11,(xxx-1f)@highera34
2954 . 1: pla %r12,xxx@pcrel
2955 . ldx %r12,%r11,%r12
2959 In cases where the high instructions would add zero, they are
2960 omitted and following instructions modified in some cases.
2961 For example, a power10 ppc_stub_plt_call_notoc might simplify down
2963 . pld %r12,xxx@pcrel
2967 For a given stub group (a set of sections all using the same toc
2968 pointer value) there will be just one stub type used for any
2969 particular function symbol. For example, if printf is called from
2970 code with the tocsave optimization (ie. r2 saved in function
2971 prologue) and therefore calls use a ppc_stub_plt_call linkage stub,
2972 and from other code without the tocsave optimization requiring a
2973 ppc_stub_plt_call_r2save linkage stub, a single stub of the latter
2974 type will be created. Calls with the tocsave optimization will
2975 enter this stub after the instruction saving r2. A similar
2976 situation exists when calls are marked with R_PPC64_REL24_NOTOC
2977 relocations. These require a ppc_stub_plt_call_notoc linkage stub
2978 to call an external function like printf. If other calls to printf
2979 require a ppc_stub_plt_call linkage stub then a single
2980 ppc_stub_plt_call_notoc linkage stub will be used for both types of
2981 call. If other calls to printf require a ppc_stub_plt_call_r2save
2982 linkage stub then a single ppc_stub_plt_call_both linkage stub will
2983 be created and calls not requiring r2 to be saved will enter the
2984 stub after the r2 save instruction. There is an analogous
2985 hierarchy of long branch and plt branch stubs for local call
2991 ppc_stub_long_branch
,
2992 ppc_stub_long_branch_r2off
,
2993 ppc_stub_long_branch_notoc
,
2994 ppc_stub_long_branch_both
, /* r2off and notoc variants both needed. */
2995 ppc_stub_plt_branch
,
2996 ppc_stub_plt_branch_r2off
,
2997 ppc_stub_plt_branch_notoc
,
2998 ppc_stub_plt_branch_both
,
3000 ppc_stub_plt_call_r2save
,
3001 ppc_stub_plt_call_notoc
,
3002 ppc_stub_plt_call_both
,
3003 ppc_stub_global_entry
,
3007 /* Information on stub grouping. */
3010 /* The stub section. */
3012 /* This is the section to which stubs in the group will be attached. */
3015 struct map_stub
*next
;
3016 /* Whether to emit a copy of register save/restore functions in this
3019 /* Current offset within stubs after the insn restoring lr in a
3020 _notoc or _both stub using bcl for pc-relative addressing, or
3021 after the insn restoring lr in a __tls_get_addr_opt plt stub. */
3022 unsigned int lr_restore
;
3023 /* Accumulated size of EH info emitted to describe return address
3024 if stubs modify lr. Does not include 17 byte FDE header. */
3025 unsigned int eh_size
;
3026 /* Offset in glink_eh_frame to the start of EH info for this group. */
3027 unsigned int eh_base
;
3030 struct ppc_stub_hash_entry
3032 /* Base hash table entry structure. */
3033 struct bfd_hash_entry root
;
3035 enum ppc_stub_type stub_type
;
3037 /* Group information. */
3038 struct map_stub
*group
;
3040 /* Offset within stub_sec of the beginning of this stub. */
3041 bfd_vma stub_offset
;
3043 /* Given the symbol's value and its section we can determine its final
3044 value when building the stubs (so the stub knows where to jump. */
3045 bfd_vma target_value
;
3046 asection
*target_section
;
3048 /* The symbol table entry, if any, that this was derived from. */
3049 struct ppc_link_hash_entry
*h
;
3050 struct plt_entry
*plt_ent
;
3053 unsigned char symtype
;
3055 /* Symbol st_other. */
3056 unsigned char other
;
3059 struct ppc_branch_hash_entry
3061 /* Base hash table entry structure. */
3062 struct bfd_hash_entry root
;
3064 /* Offset within branch lookup table. */
3065 unsigned int offset
;
3067 /* Generation marker. */
3071 /* Used to track dynamic relocations for local symbols. */
3072 struct ppc_dyn_relocs
3074 struct ppc_dyn_relocs
*next
;
3076 /* The input section of the reloc. */
3079 /* Total number of relocs copied for the input section. */
3080 unsigned int count
: 31;
3082 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3083 unsigned int ifunc
: 1;
3086 struct ppc_link_hash_entry
3088 struct elf_link_hash_entry elf
;
3092 /* A pointer to the most recently used stub hash entry against this
3094 struct ppc_stub_hash_entry
*stub_cache
;
3096 /* A pointer to the next symbol starting with a '.' */
3097 struct ppc_link_hash_entry
*next_dot_sym
;
3100 /* Link between function code and descriptor symbols. */
3101 struct ppc_link_hash_entry
*oh
;
3103 /* Flag function code and descriptor symbols. */
3104 unsigned int is_func
:1;
3105 unsigned int is_func_descriptor
:1;
3106 unsigned int fake
:1;
3108 /* Whether global opd/toc sym has been adjusted or not.
3109 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3110 should be set for all globals defined in any opd/toc section. */
3111 unsigned int adjust_done
:1;
3113 /* Set if this is an out-of-line register save/restore function,
3114 with non-standard calling convention. */
3115 unsigned int save_res
:1;
3117 /* Set if a duplicate symbol with non-zero localentry is detected,
3118 even when the duplicate symbol does not provide a definition. */
3119 unsigned int non_zero_localentry
:1;
3121 /* Contexts in which symbol is used in the GOT (or TOC).
3122 Bits are or'd into the mask as the corresponding relocs are
3123 encountered during check_relocs, with TLS_TLS being set when any
3124 of the other TLS bits are set. tls_optimize clears bits when
3125 optimizing to indicate the corresponding GOT entry type is not
3126 needed. If set, TLS_TLS is never cleared. tls_optimize may also
3127 set TLS_GDIE when a GD reloc turns into an IE one.
3128 These flags are also kept for local symbols. */
3129 #define TLS_TLS 1 /* Any TLS reloc. */
3130 #define TLS_GD 2 /* GD reloc. */
3131 #define TLS_LD 4 /* LD reloc. */
3132 #define TLS_TPREL 8 /* TPREL reloc, => IE. */
3133 #define TLS_DTPREL 16 /* DTPREL reloc, => LD. */
3134 #define TLS_MARK 32 /* __tls_get_addr call marked. */
3135 #define TLS_GDIE 64 /* GOT TPREL reloc resulting from GD->IE. */
3136 #define TLS_EXPLICIT 256 /* TOC section TLS reloc, not stored. */
3137 unsigned char tls_mask
;
3139 /* The above field is also used to mark function symbols. In which
3140 case TLS_TLS will be 0. */
3141 #define PLT_IFUNC 2 /* STT_GNU_IFUNC. */
3142 #define PLT_KEEP 4 /* inline plt call requires plt entry. */
3143 #define NON_GOT 256 /* local symbol plt, not stored. */
3146 static inline struct ppc_link_hash_entry
*
3147 ppc_elf_hash_entry (struct elf_link_hash_entry
*ent
)
3149 return (struct ppc_link_hash_entry
*) ent
;
3152 /* ppc64 ELF linker hash table. */
3154 struct ppc_link_hash_table
3156 struct elf_link_hash_table elf
;
3158 /* The stub hash table. */
3159 struct bfd_hash_table stub_hash_table
;
3161 /* Another hash table for plt_branch stubs. */
3162 struct bfd_hash_table branch_hash_table
;
3164 /* Hash table for function prologue tocsave. */
3165 htab_t tocsave_htab
;
3167 /* Various options and other info passed from the linker. */
3168 struct ppc64_elf_params
*params
;
3170 /* The size of sec_info below. */
3171 unsigned int sec_info_arr_size
;
3173 /* Per-section array of extra section info. Done this way rather
3174 than as part of ppc64_elf_section_data so we have the info for
3175 non-ppc64 sections. */
3178 /* Along with elf_gp, specifies the TOC pointer used by this section. */
3183 /* The section group that this section belongs to. */
3184 struct map_stub
*group
;
3185 /* A temp section list pointer. */
3190 /* Linked list of groups. */
3191 struct map_stub
*group
;
3193 /* Temp used when calculating TOC pointers. */
3196 asection
*toc_first_sec
;
3198 /* Used when adding symbols. */
3199 struct ppc_link_hash_entry
*dot_syms
;
3201 /* Shortcuts to get to dynamic linker sections. */
3203 asection
*global_entry
;
3206 asection
*relpltlocal
;
3209 asection
*glink_eh_frame
;
3211 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
3212 struct ppc_link_hash_entry
*tls_get_addr
;
3213 struct ppc_link_hash_entry
*tls_get_addr_fd
;
3214 struct ppc_link_hash_entry
*tga_desc
;
3215 struct ppc_link_hash_entry
*tga_desc_fd
;
3216 struct map_stub
*tga_group
;
3218 /* The size of reliplt used by got entry relocs. */
3219 bfd_size_type got_reli_size
;
3222 unsigned long stub_count
[ppc_stub_global_entry
];
3224 /* Number of stubs against global syms. */
3225 unsigned long stub_globals
;
3227 /* Set if we're linking code with function descriptors. */
3228 unsigned int opd_abi
:1;
3230 /* Support for multiple toc sections. */
3231 unsigned int do_multi_toc
:1;
3232 unsigned int multi_toc_needed
:1;
3233 unsigned int second_toc_pass
:1;
3234 unsigned int do_toc_opt
:1;
3236 /* Set if tls optimization is enabled. */
3237 unsigned int do_tls_opt
:1;
3239 /* Set if inline plt calls should be converted to direct calls. */
3240 unsigned int can_convert_all_inline_plt
:1;
3243 unsigned int stub_error
:1;
3245 /* Whether func_desc_adjust needs to be run over symbols. */
3246 unsigned int need_func_desc_adj
:1;
3248 /* Whether plt calls for ELFv2 localentry:0 funcs have been optimized. */
3249 unsigned int has_plt_localentry0
:1;
3251 /* Whether calls are made via the PLT from NOTOC functions. */
3252 unsigned int notoc_plt
:1;
3254 /* Whether any code linked seems to be Power10. */
3255 unsigned int has_power10_relocs
:1;
3257 /* Incremented every time we size stubs. */
3258 unsigned int stub_iteration
;
3261 /* Rename some of the generic section flags to better document how they
3264 /* Nonzero if this section has TLS related relocations. */
3265 #define has_tls_reloc sec_flg0
3267 /* Nonzero if this section has a call to __tls_get_addr lacking marker
3269 #define nomark_tls_get_addr sec_flg1
3271 /* Nonzero if this section has any toc or got relocs. */
3272 #define has_toc_reloc sec_flg2
3274 /* Nonzero if this section has a call to another section that uses
3276 #define makes_toc_func_call sec_flg3
3278 /* Recursion protection when determining above flag. */
3279 #define call_check_in_progress sec_flg4
3280 #define call_check_done sec_flg5
3282 /* Get the ppc64 ELF linker hash table from a link_info structure. */
3284 #define ppc_hash_table(p) \
3285 ((is_elf_hash_table ((p)->hash) \
3286 && elf_hash_table_id (elf_hash_table (p)) == PPC64_ELF_DATA) \
3287 ? (struct ppc_link_hash_table *) (p)->hash : NULL)
3289 #define ppc_stub_hash_lookup(table, string, create, copy) \
3290 ((struct ppc_stub_hash_entry *) \
3291 bfd_hash_lookup ((table), (string), (create), (copy)))
3293 #define ppc_branch_hash_lookup(table, string, create, copy) \
3294 ((struct ppc_branch_hash_entry *) \
3295 bfd_hash_lookup ((table), (string), (create), (copy)))
3297 /* Create an entry in the stub hash table. */
3299 static struct bfd_hash_entry
*
3300 stub_hash_newfunc (struct bfd_hash_entry
*entry
,
3301 struct bfd_hash_table
*table
,
3304 /* Allocate the structure if it has not already been allocated by a
3308 entry
= bfd_hash_allocate (table
, sizeof (struct ppc_stub_hash_entry
));
3313 /* Call the allocation method of the superclass. */
3314 entry
= bfd_hash_newfunc (entry
, table
, string
);
3317 struct ppc_stub_hash_entry
*eh
;
3319 /* Initialize the local fields. */
3320 eh
= (struct ppc_stub_hash_entry
*) entry
;
3321 eh
->stub_type
= ppc_stub_none
;
3323 eh
->stub_offset
= 0;
3324 eh
->target_value
= 0;
3325 eh
->target_section
= NULL
;
3334 /* Create an entry in the branch hash table. */
3336 static struct bfd_hash_entry
*
3337 branch_hash_newfunc (struct bfd_hash_entry
*entry
,
3338 struct bfd_hash_table
*table
,
3341 /* Allocate the structure if it has not already been allocated by a
3345 entry
= bfd_hash_allocate (table
, sizeof (struct ppc_branch_hash_entry
));
3350 /* Call the allocation method of the superclass. */
3351 entry
= bfd_hash_newfunc (entry
, table
, string
);
3354 struct ppc_branch_hash_entry
*eh
;
3356 /* Initialize the local fields. */
3357 eh
= (struct ppc_branch_hash_entry
*) entry
;
3365 /* Create an entry in a ppc64 ELF linker hash table. */
3367 static struct bfd_hash_entry
*
3368 link_hash_newfunc (struct bfd_hash_entry
*entry
,
3369 struct bfd_hash_table
*table
,
3372 /* Allocate the structure if it has not already been allocated by a
3376 entry
= bfd_hash_allocate (table
, sizeof (struct ppc_link_hash_entry
));
3381 /* Call the allocation method of the superclass. */
3382 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
3385 struct ppc_link_hash_entry
*eh
= (struct ppc_link_hash_entry
*) entry
;
3387 memset (&eh
->u
.stub_cache
, 0,
3388 (sizeof (struct ppc_link_hash_entry
)
3389 - offsetof (struct ppc_link_hash_entry
, u
.stub_cache
)));
3391 /* When making function calls, old ABI code references function entry
3392 points (dot symbols), while new ABI code references the function
3393 descriptor symbol. We need to make any combination of reference and
3394 definition work together, without breaking archive linking.
3396 For a defined function "foo" and an undefined call to "bar":
3397 An old object defines "foo" and ".foo", references ".bar" (possibly
3399 A new object defines "foo" and references "bar".
3401 A new object thus has no problem with its undefined symbols being
3402 satisfied by definitions in an old object. On the other hand, the
3403 old object won't have ".bar" satisfied by a new object.
3405 Keep a list of newly added dot-symbols. */
3407 if (string
[0] == '.')
3409 struct ppc_link_hash_table
*htab
;
3411 htab
= (struct ppc_link_hash_table
*) table
;
3412 eh
->u
.next_dot_sym
= htab
->dot_syms
;
3413 htab
->dot_syms
= eh
;
3420 struct tocsave_entry
3427 tocsave_htab_hash (const void *p
)
3429 const struct tocsave_entry
*e
= (const struct tocsave_entry
*) p
;
3430 return ((bfd_vma
) (intptr_t) e
->sec
^ e
->offset
) >> 3;
3434 tocsave_htab_eq (const void *p1
, const void *p2
)
3436 const struct tocsave_entry
*e1
= (const struct tocsave_entry
*) p1
;
3437 const struct tocsave_entry
*e2
= (const struct tocsave_entry
*) p2
;
3438 return e1
->sec
== e2
->sec
&& e1
->offset
== e2
->offset
;
3441 /* Destroy a ppc64 ELF linker hash table. */
3444 ppc64_elf_link_hash_table_free (bfd
*obfd
)
3446 struct ppc_link_hash_table
*htab
;
3448 htab
= (struct ppc_link_hash_table
*) obfd
->link
.hash
;
3449 if (htab
->tocsave_htab
)
3450 htab_delete (htab
->tocsave_htab
);
3451 bfd_hash_table_free (&htab
->branch_hash_table
);
3452 bfd_hash_table_free (&htab
->stub_hash_table
);
3453 _bfd_elf_link_hash_table_free (obfd
);
3456 /* Create a ppc64 ELF linker hash table. */
3458 static struct bfd_link_hash_table
*
3459 ppc64_elf_link_hash_table_create (bfd
*abfd
)
3461 struct ppc_link_hash_table
*htab
;
3462 size_t amt
= sizeof (struct ppc_link_hash_table
);
3464 htab
= bfd_zmalloc (amt
);
3468 if (!_bfd_elf_link_hash_table_init (&htab
->elf
, abfd
, link_hash_newfunc
,
3469 sizeof (struct ppc_link_hash_entry
),
3476 /* Init the stub hash table too. */
3477 if (!bfd_hash_table_init (&htab
->stub_hash_table
, stub_hash_newfunc
,
3478 sizeof (struct ppc_stub_hash_entry
)))
3480 _bfd_elf_link_hash_table_free (abfd
);
3484 /* And the branch hash table. */
3485 if (!bfd_hash_table_init (&htab
->branch_hash_table
, branch_hash_newfunc
,
3486 sizeof (struct ppc_branch_hash_entry
)))
3488 bfd_hash_table_free (&htab
->stub_hash_table
);
3489 _bfd_elf_link_hash_table_free (abfd
);
3493 htab
->tocsave_htab
= htab_try_create (1024,
3497 if (htab
->tocsave_htab
== NULL
)
3499 ppc64_elf_link_hash_table_free (abfd
);
3502 htab
->elf
.root
.hash_table_free
= ppc64_elf_link_hash_table_free
;
3504 /* Initializing two fields of the union is just cosmetic. We really
3505 only care about glist, but when compiled on a 32-bit host the
3506 bfd_vma fields are larger. Setting the bfd_vma to zero makes
3507 debugger inspection of these fields look nicer. */
3508 htab
->elf
.init_got_refcount
.refcount
= 0;
3509 htab
->elf
.init_got_refcount
.glist
= NULL
;
3510 htab
->elf
.init_plt_refcount
.refcount
= 0;
3511 htab
->elf
.init_plt_refcount
.glist
= NULL
;
3512 htab
->elf
.init_got_offset
.offset
= 0;
3513 htab
->elf
.init_got_offset
.glist
= NULL
;
3514 htab
->elf
.init_plt_offset
.offset
= 0;
3515 htab
->elf
.init_plt_offset
.glist
= NULL
;
3517 return &htab
->elf
.root
;
3520 /* Create sections for linker generated code. */
3523 create_linkage_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
3525 struct ppc_link_hash_table
*htab
;
3528 htab
= ppc_hash_table (info
);
3530 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_READONLY
3531 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3532 if (htab
->params
->save_restore_funcs
)
3534 /* Create .sfpr for code to save and restore fp regs. */
3535 htab
->sfpr
= bfd_make_section_anyway_with_flags (dynobj
, ".sfpr",
3537 if (htab
->sfpr
== NULL
3538 || !bfd_set_section_alignment (htab
->sfpr
, 2))
3542 if (bfd_link_relocatable (info
))
3545 /* Create .glink for lazy dynamic linking support. */
3546 htab
->glink
= bfd_make_section_anyway_with_flags (dynobj
, ".glink",
3548 if (htab
->glink
== NULL
3549 || !bfd_set_section_alignment (htab
->glink
, 3))
3552 /* The part of .glink used by global entry stubs, separate so that
3553 it can be aligned appropriately without affecting htab->glink. */
3554 htab
->global_entry
= bfd_make_section_anyway_with_flags (dynobj
, ".glink",
3556 if (htab
->global_entry
== NULL
3557 || !bfd_set_section_alignment (htab
->global_entry
, 2))
3560 if (!info
->no_ld_generated_unwind_info
)
3562 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_HAS_CONTENTS
3563 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3564 htab
->glink_eh_frame
= bfd_make_section_anyway_with_flags (dynobj
,
3567 if (htab
->glink_eh_frame
== NULL
3568 || !bfd_set_section_alignment (htab
->glink_eh_frame
, 2))
3572 flags
= SEC_ALLOC
| SEC_LINKER_CREATED
;
3573 htab
->elf
.iplt
= bfd_make_section_anyway_with_flags (dynobj
, ".iplt", flags
);
3574 if (htab
->elf
.iplt
== NULL
3575 || !bfd_set_section_alignment (htab
->elf
.iplt
, 3))
3578 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
3579 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3581 = bfd_make_section_anyway_with_flags (dynobj
, ".rela.iplt", flags
);
3582 if (htab
->elf
.irelplt
== NULL
3583 || !bfd_set_section_alignment (htab
->elf
.irelplt
, 3))
3586 /* Create branch lookup table for plt_branch stubs. */
3587 flags
= (SEC_ALLOC
| SEC_LOAD
3588 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3589 htab
->brlt
= bfd_make_section_anyway_with_flags (dynobj
, ".branch_lt",
3591 if (htab
->brlt
== NULL
3592 || !bfd_set_section_alignment (htab
->brlt
, 3))
3595 /* Local plt entries, put in .branch_lt but a separate section for
3597 htab
->pltlocal
= bfd_make_section_anyway_with_flags (dynobj
, ".branch_lt",
3599 if (htab
->pltlocal
== NULL
3600 || !bfd_set_section_alignment (htab
->pltlocal
, 3))
3603 if (!bfd_link_pic (info
))
3606 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
3607 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3609 = bfd_make_section_anyway_with_flags (dynobj
, ".rela.branch_lt", flags
);
3610 if (htab
->relbrlt
== NULL
3611 || !bfd_set_section_alignment (htab
->relbrlt
, 3))
3615 = bfd_make_section_anyway_with_flags (dynobj
, ".rela.branch_lt", flags
);
3616 if (htab
->relpltlocal
== NULL
3617 || !bfd_set_section_alignment (htab
->relpltlocal
, 3))
3623 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
3626 ppc64_elf_init_stub_bfd (struct bfd_link_info
*info
,
3627 struct ppc64_elf_params
*params
)
3629 struct ppc_link_hash_table
*htab
;
3631 elf_elfheader (params
->stub_bfd
)->e_ident
[EI_CLASS
] = ELFCLASS64
;
3633 /* Always hook our dynamic sections into the first bfd, which is the
3634 linker created stub bfd. This ensures that the GOT header is at
3635 the start of the output TOC section. */
3636 htab
= ppc_hash_table (info
);
3637 htab
->elf
.dynobj
= params
->stub_bfd
;
3638 htab
->params
= params
;
3640 return create_linkage_sections (htab
->elf
.dynobj
, info
);
3643 /* Build a name for an entry in the stub hash table. */
3646 ppc_stub_name (const asection
*input_section
,
3647 const asection
*sym_sec
,
3648 const struct ppc_link_hash_entry
*h
,
3649 const Elf_Internal_Rela
*rel
)
3654 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
3655 offsets from a sym as a branch target? In fact, we could
3656 probably assume the addend is always zero. */
3657 BFD_ASSERT (((int) rel
->r_addend
& 0xffffffff) == rel
->r_addend
);
3661 len
= 8 + 1 + strlen (h
->elf
.root
.root
.string
) + 1 + 8 + 1;
3662 stub_name
= bfd_malloc (len
);
3663 if (stub_name
== NULL
)
3666 len
= sprintf (stub_name
, "%08x.%s+%x",
3667 input_section
->id
& 0xffffffff,
3668 h
->elf
.root
.root
.string
,
3669 (int) rel
->r_addend
& 0xffffffff);
3673 len
= 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
3674 stub_name
= bfd_malloc (len
);
3675 if (stub_name
== NULL
)
3678 len
= sprintf (stub_name
, "%08x.%x:%x+%x",
3679 input_section
->id
& 0xffffffff,
3680 sym_sec
->id
& 0xffffffff,
3681 (int) ELF64_R_SYM (rel
->r_info
) & 0xffffffff,
3682 (int) rel
->r_addend
& 0xffffffff);
3684 if (len
> 2 && stub_name
[len
- 2] == '+' && stub_name
[len
- 1] == '0')
3685 stub_name
[len
- 2] = 0;
3689 /* If mixing power10 with non-power10 code and --power10-stubs is not
3690 specified (or is auto) then calls using @notoc relocations that
3691 need a stub will utilize power10 instructions in the stub, and
3692 calls without @notoc relocations will not use power10 instructions.
3693 The two classes of stubs are stored in separate stub_hash_table
3694 entries having the same key string. The two entries will always be
3695 adjacent on entry->root.next chain, even if hash table resizing
3696 occurs. This function selects the correct entry to use. */
3698 static struct ppc_stub_hash_entry
*
3699 select_alt_stub (struct ppc_stub_hash_entry
*entry
, bfd_boolean notoc
)
3701 bfd_boolean have_notoc
;
3703 have_notoc
= (entry
->stub_type
== ppc_stub_plt_call_notoc
3704 || entry
->stub_type
== ppc_stub_plt_branch_notoc
3705 || entry
->stub_type
== ppc_stub_long_branch_notoc
);
3707 if (have_notoc
!= notoc
)
3709 const char *stub_name
= entry
->root
.string
;
3711 entry
= (struct ppc_stub_hash_entry
*) entry
->root
.next
;
3713 && entry
->root
.string
!= stub_name
)
3720 /* Look up an entry in the stub hash. Stub entries are cached because
3721 creating the stub name takes a bit of time. */
3723 static struct ppc_stub_hash_entry
*
3724 ppc_get_stub_entry (const asection
*input_section
,
3725 const asection
*sym_sec
,
3726 struct ppc_link_hash_entry
*h
,
3727 const Elf_Internal_Rela
*rel
,
3728 struct ppc_link_hash_table
*htab
)
3730 struct ppc_stub_hash_entry
*stub_entry
;
3731 struct map_stub
*group
;
3733 /* If this input section is part of a group of sections sharing one
3734 stub section, then use the id of the first section in the group.
3735 Stub names need to include a section id, as there may well be
3736 more than one stub used to reach say, printf, and we need to
3737 distinguish between them. */
3738 group
= htab
->sec_info
[input_section
->id
].u
.group
;
3742 if (h
!= NULL
&& h
->u
.stub_cache
!= NULL
3743 && h
->u
.stub_cache
->h
== h
3744 && h
->u
.stub_cache
->group
== group
)
3746 stub_entry
= h
->u
.stub_cache
;
3752 stub_name
= ppc_stub_name (group
->link_sec
, sym_sec
, h
, rel
);
3753 if (stub_name
== NULL
)
3756 stub_entry
= ppc_stub_hash_lookup (&htab
->stub_hash_table
,
3757 stub_name
, FALSE
, FALSE
);
3759 h
->u
.stub_cache
= stub_entry
;
3764 if (stub_entry
!= NULL
&& htab
->params
->power10_stubs
== -1)
3766 bfd_boolean notoc
= ELF64_R_TYPE (rel
->r_info
) == R_PPC64_REL24_NOTOC
;
3768 stub_entry
= select_alt_stub (stub_entry
, notoc
);
3774 /* Add a new stub entry to the stub hash. Not all fields of the new
3775 stub entry are initialised. */
3777 static struct ppc_stub_hash_entry
*
3778 ppc_add_stub (const char *stub_name
,
3780 struct bfd_link_info
*info
)
3782 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
3783 struct map_stub
*group
;
3786 struct ppc_stub_hash_entry
*stub_entry
;
3788 group
= htab
->sec_info
[section
->id
].u
.group
;
3789 link_sec
= group
->link_sec
;
3790 stub_sec
= group
->stub_sec
;
3791 if (stub_sec
== NULL
)
3797 namelen
= strlen (link_sec
->name
);
3798 len
= namelen
+ sizeof (STUB_SUFFIX
);
3799 s_name
= bfd_alloc (htab
->params
->stub_bfd
, len
);
3803 memcpy (s_name
, link_sec
->name
, namelen
);
3804 memcpy (s_name
+ namelen
, STUB_SUFFIX
, sizeof (STUB_SUFFIX
));
3805 stub_sec
= (*htab
->params
->add_stub_section
) (s_name
, link_sec
);
3806 if (stub_sec
== NULL
)
3808 group
->stub_sec
= stub_sec
;
3811 /* Enter this entry into the linker stub hash table. */
3812 stub_entry
= ppc_stub_hash_lookup (&htab
->stub_hash_table
, stub_name
,
3814 if (stub_entry
== NULL
)
3816 /* xgettext:c-format */
3817 _bfd_error_handler (_("%pB: cannot create stub entry %s"),
3818 section
->owner
, stub_name
);
3822 stub_entry
->group
= group
;
3823 stub_entry
->stub_offset
= 0;
3827 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
3828 not already done. */
3831 create_got_section (bfd
*abfd
, struct bfd_link_info
*info
)
3833 asection
*got
, *relgot
;
3835 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
3837 if (!is_ppc64_elf (abfd
))
3843 && !_bfd_elf_create_got_section (htab
->elf
.dynobj
, info
))
3846 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
3847 | SEC_LINKER_CREATED
);
3849 got
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
3851 || !bfd_set_section_alignment (got
, 3))
3854 relgot
= bfd_make_section_anyway_with_flags (abfd
, ".rela.got",
3855 flags
| SEC_READONLY
);
3857 || !bfd_set_section_alignment (relgot
, 3))
3860 ppc64_elf_tdata (abfd
)->got
= got
;
3861 ppc64_elf_tdata (abfd
)->relgot
= relgot
;
3865 /* Follow indirect and warning symbol links. */
3867 static inline struct bfd_link_hash_entry
*
3868 follow_link (struct bfd_link_hash_entry
*h
)
3870 while (h
->type
== bfd_link_hash_indirect
3871 || h
->type
== bfd_link_hash_warning
)
3876 static inline struct elf_link_hash_entry
*
3877 elf_follow_link (struct elf_link_hash_entry
*h
)
3879 return (struct elf_link_hash_entry
*) follow_link (&h
->root
);
3882 static inline struct ppc_link_hash_entry
*
3883 ppc_follow_link (struct ppc_link_hash_entry
*h
)
3885 return ppc_elf_hash_entry (elf_follow_link (&h
->elf
));
3888 /* Merge PLT info on FROM with that on TO. */
3891 move_plt_plist (struct ppc_link_hash_entry
*from
,
3892 struct ppc_link_hash_entry
*to
)
3894 if (from
->elf
.plt
.plist
!= NULL
)
3896 if (to
->elf
.plt
.plist
!= NULL
)
3898 struct plt_entry
**entp
;
3899 struct plt_entry
*ent
;
3901 for (entp
= &from
->elf
.plt
.plist
; (ent
= *entp
) != NULL
; )
3903 struct plt_entry
*dent
;
3905 for (dent
= to
->elf
.plt
.plist
; dent
!= NULL
; dent
= dent
->next
)
3906 if (dent
->addend
== ent
->addend
)
3908 dent
->plt
.refcount
+= ent
->plt
.refcount
;
3915 *entp
= to
->elf
.plt
.plist
;
3918 to
->elf
.plt
.plist
= from
->elf
.plt
.plist
;
3919 from
->elf
.plt
.plist
= NULL
;
3923 /* Copy the extra info we tack onto an elf_link_hash_entry. */
3926 ppc64_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
3927 struct elf_link_hash_entry
*dir
,
3928 struct elf_link_hash_entry
*ind
)
3930 struct ppc_link_hash_entry
*edir
, *eind
;
3932 edir
= ppc_elf_hash_entry (dir
);
3933 eind
= ppc_elf_hash_entry (ind
);
3935 edir
->is_func
|= eind
->is_func
;
3936 edir
->is_func_descriptor
|= eind
->is_func_descriptor
;
3937 edir
->tls_mask
|= eind
->tls_mask
;
3938 if (eind
->oh
!= NULL
)
3939 edir
->oh
= ppc_follow_link (eind
->oh
);
3941 if (edir
->elf
.versioned
!= versioned_hidden
)
3942 edir
->elf
.ref_dynamic
|= eind
->elf
.ref_dynamic
;
3943 edir
->elf
.ref_regular
|= eind
->elf
.ref_regular
;
3944 edir
->elf
.ref_regular_nonweak
|= eind
->elf
.ref_regular_nonweak
;
3945 edir
->elf
.non_got_ref
|= eind
->elf
.non_got_ref
;
3946 edir
->elf
.needs_plt
|= eind
->elf
.needs_plt
;
3947 edir
->elf
.pointer_equality_needed
|= eind
->elf
.pointer_equality_needed
;
3949 /* If we were called to copy over info for a weak sym, don't copy
3950 dyn_relocs, plt/got info, or dynindx. We used to copy dyn_relocs
3951 in order to simplify readonly_dynrelocs and save a field in the
3952 symbol hash entry, but that means dyn_relocs can't be used in any
3953 tests about a specific symbol, or affect other symbol flags which
3955 if (eind
->elf
.root
.type
!= bfd_link_hash_indirect
)
3958 /* Copy over any dynamic relocs we may have on the indirect sym. */
3959 if (ind
->dyn_relocs
!= NULL
)
3961 if (dir
->dyn_relocs
!= NULL
)
3963 struct elf_dyn_relocs
**pp
;
3964 struct elf_dyn_relocs
*p
;
3966 /* Add reloc counts against the indirect sym to the direct sym
3967 list. Merge any entries against the same section. */
3968 for (pp
= &ind
->dyn_relocs
; (p
= *pp
) != NULL
; )
3970 struct elf_dyn_relocs
*q
;
3972 for (q
= dir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
3973 if (q
->sec
== p
->sec
)
3975 q
->pc_count
+= p
->pc_count
;
3976 q
->count
+= p
->count
;
3983 *pp
= dir
->dyn_relocs
;
3986 dir
->dyn_relocs
= ind
->dyn_relocs
;
3987 ind
->dyn_relocs
= NULL
;
3990 /* Copy over got entries that we may have already seen to the
3991 symbol which just became indirect. */
3992 if (eind
->elf
.got
.glist
!= NULL
)
3994 if (edir
->elf
.got
.glist
!= NULL
)
3996 struct got_entry
**entp
;
3997 struct got_entry
*ent
;
3999 for (entp
= &eind
->elf
.got
.glist
; (ent
= *entp
) != NULL
; )
4001 struct got_entry
*dent
;
4003 for (dent
= edir
->elf
.got
.glist
; dent
!= NULL
; dent
= dent
->next
)
4004 if (dent
->addend
== ent
->addend
4005 && dent
->owner
== ent
->owner
4006 && dent
->tls_type
== ent
->tls_type
)
4008 dent
->got
.refcount
+= ent
->got
.refcount
;
4015 *entp
= edir
->elf
.got
.glist
;
4018 edir
->elf
.got
.glist
= eind
->elf
.got
.glist
;
4019 eind
->elf
.got
.glist
= NULL
;
4022 /* And plt entries. */
4023 move_plt_plist (eind
, edir
);
4025 if (eind
->elf
.dynindx
!= -1)
4027 if (edir
->elf
.dynindx
!= -1)
4028 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
4029 edir
->elf
.dynstr_index
);
4030 edir
->elf
.dynindx
= eind
->elf
.dynindx
;
4031 edir
->elf
.dynstr_index
= eind
->elf
.dynstr_index
;
4032 eind
->elf
.dynindx
= -1;
4033 eind
->elf
.dynstr_index
= 0;
4037 /* Find the function descriptor hash entry from the given function code
4038 hash entry FH. Link the entries via their OH fields. */
4040 static struct ppc_link_hash_entry
*
4041 lookup_fdh (struct ppc_link_hash_entry
*fh
, struct ppc_link_hash_table
*htab
)
4043 struct ppc_link_hash_entry
*fdh
= fh
->oh
;
4047 const char *fd_name
= fh
->elf
.root
.root
.string
+ 1;
4049 fdh
= ppc_elf_hash_entry (elf_link_hash_lookup (&htab
->elf
, fd_name
,
4050 FALSE
, FALSE
, FALSE
));
4054 fdh
->is_func_descriptor
= 1;
4060 fdh
= ppc_follow_link (fdh
);
4061 fdh
->is_func_descriptor
= 1;
4066 /* Make a fake function descriptor sym for the undefined code sym FH. */
4068 static struct ppc_link_hash_entry
*
4069 make_fdh (struct bfd_link_info
*info
,
4070 struct ppc_link_hash_entry
*fh
)
4072 bfd
*abfd
= fh
->elf
.root
.u
.undef
.abfd
;
4073 struct bfd_link_hash_entry
*bh
= NULL
;
4074 struct ppc_link_hash_entry
*fdh
;
4075 flagword flags
= (fh
->elf
.root
.type
== bfd_link_hash_undefweak
4079 if (!_bfd_generic_link_add_one_symbol (info
, abfd
,
4080 fh
->elf
.root
.root
.string
+ 1,
4081 flags
, bfd_und_section_ptr
, 0,
4082 NULL
, FALSE
, FALSE
, &bh
))
4085 fdh
= (struct ppc_link_hash_entry
*) bh
;
4086 fdh
->elf
.non_elf
= 0;
4088 fdh
->is_func_descriptor
= 1;
4095 /* Fix function descriptor symbols defined in .opd sections to be
4099 ppc64_elf_add_symbol_hook (bfd
*ibfd
,
4100 struct bfd_link_info
*info
,
4101 Elf_Internal_Sym
*isym
,
4103 flagword
*flags ATTRIBUTE_UNUSED
,
4108 && strcmp ((*sec
)->name
, ".opd") == 0)
4112 if (!(ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
4113 || ELF_ST_TYPE (isym
->st_info
) == STT_FUNC
))
4114 isym
->st_info
= ELF_ST_INFO (ELF_ST_BIND (isym
->st_info
), STT_FUNC
);
4116 /* If the symbol is a function defined in .opd, and the function
4117 code is in a discarded group, let it appear to be undefined. */
4118 if (!bfd_link_relocatable (info
)
4119 && (*sec
)->reloc_count
!= 0
4120 && opd_entry_value (*sec
, *value
, &code_sec
, NULL
,
4121 FALSE
) != (bfd_vma
) -1
4122 && discarded_section (code_sec
))
4124 *sec
= bfd_und_section_ptr
;
4125 isym
->st_shndx
= SHN_UNDEF
;
4128 else if (*sec
!= NULL
4129 && strcmp ((*sec
)->name
, ".toc") == 0
4130 && ELF_ST_TYPE (isym
->st_info
) == STT_OBJECT
)
4132 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
4134 htab
->params
->object_in_toc
= 1;
4137 if ((STO_PPC64_LOCAL_MASK
& isym
->st_other
) != 0)
4139 if (abiversion (ibfd
) == 0)
4140 set_abiversion (ibfd
, 2);
4141 else if (abiversion (ibfd
) == 1)
4143 _bfd_error_handler (_("symbol '%s' has invalid st_other"
4144 " for ABI version 1"), *name
);
4145 bfd_set_error (bfd_error_bad_value
);
4153 /* Merge non-visibility st_other attributes: local entry point. */
4156 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry
*h
,
4157 unsigned int st_other
,
4158 bfd_boolean definition
,
4159 bfd_boolean dynamic
)
4161 if (definition
&& (!dynamic
|| !h
->def_regular
))
4162 h
->other
= ((st_other
& ~ELF_ST_VISIBILITY (-1))
4163 | ELF_ST_VISIBILITY (h
->other
));
4166 /* Hook called on merging a symbol. We use this to clear "fake" since
4167 we now have a real symbol. */
4170 ppc64_elf_merge_symbol (struct elf_link_hash_entry
*h
,
4171 const Elf_Internal_Sym
*isym
,
4172 asection
**psec ATTRIBUTE_UNUSED
,
4173 bfd_boolean newdef ATTRIBUTE_UNUSED
,
4174 bfd_boolean olddef ATTRIBUTE_UNUSED
,
4175 bfd
*oldbfd ATTRIBUTE_UNUSED
,
4176 const asection
*oldsec ATTRIBUTE_UNUSED
)
4178 ppc_elf_hash_entry (h
)->fake
= 0;
4179 if ((STO_PPC64_LOCAL_MASK
& isym
->st_other
) != 0)
4180 ppc_elf_hash_entry (h
)->non_zero_localentry
= 1;
4184 /* This function makes an old ABI object reference to ".bar" cause the
4185 inclusion of a new ABI object archive that defines "bar".
4186 NAME is a symbol defined in an archive. Return a symbol in the hash
4187 table that might be satisfied by the archive symbols. */
4189 static struct elf_link_hash_entry
*
4190 ppc64_elf_archive_symbol_lookup (bfd
*abfd
,
4191 struct bfd_link_info
*info
,
4194 struct elf_link_hash_entry
*h
;
4198 h
= _bfd_elf_archive_symbol_lookup (abfd
, info
, name
);
4200 /* Don't return this sym if it is a fake function descriptor
4201 created by add_symbol_adjust. */
4202 && !ppc_elf_hash_entry (h
)->fake
)
4208 len
= strlen (name
);
4209 dot_name
= bfd_alloc (abfd
, len
+ 2);
4210 if (dot_name
== NULL
)
4211 return (struct elf_link_hash_entry
*) -1;
4213 memcpy (dot_name
+ 1, name
, len
+ 1);
4214 h
= _bfd_elf_archive_symbol_lookup (abfd
, info
, dot_name
);
4215 bfd_release (abfd
, dot_name
);
4219 if (strcmp (name
, "__tls_get_addr_opt") == 0)
4220 h
= _bfd_elf_archive_symbol_lookup (abfd
, info
, "__tls_get_addr_desc");
4224 /* This function satisfies all old ABI object references to ".bar" if a
4225 new ABI object defines "bar". Well, at least, undefined dot symbols
4226 are made weak. This stops later archive searches from including an
4227 object if we already have a function descriptor definition. It also
4228 prevents the linker complaining about undefined symbols.
4229 We also check and correct mismatched symbol visibility here. The
4230 most restrictive visibility of the function descriptor and the
4231 function entry symbol is used. */
4234 add_symbol_adjust (struct ppc_link_hash_entry
*eh
, struct bfd_link_info
*info
)
4236 struct ppc_link_hash_table
*htab
;
4237 struct ppc_link_hash_entry
*fdh
;
4239 if (eh
->elf
.root
.type
== bfd_link_hash_warning
)
4240 eh
= (struct ppc_link_hash_entry
*) eh
->elf
.root
.u
.i
.link
;
4242 if (eh
->elf
.root
.type
== bfd_link_hash_indirect
)
4245 if (eh
->elf
.root
.root
.string
[0] != '.')
4248 htab
= ppc_hash_table (info
);
4252 fdh
= lookup_fdh (eh
, htab
);
4254 && !bfd_link_relocatable (info
)
4255 && (eh
->elf
.root
.type
== bfd_link_hash_undefined
4256 || eh
->elf
.root
.type
== bfd_link_hash_undefweak
)
4257 && eh
->elf
.ref_regular
)
4259 /* Make an undefined function descriptor sym, in order to
4260 pull in an --as-needed shared lib. Archives are handled
4262 fdh
= make_fdh (info
, eh
);
4269 unsigned entry_vis
= ELF_ST_VISIBILITY (eh
->elf
.other
) - 1;
4270 unsigned descr_vis
= ELF_ST_VISIBILITY (fdh
->elf
.other
) - 1;
4272 /* Make both descriptor and entry symbol have the most
4273 constraining visibility of either symbol. */
4274 if (entry_vis
< descr_vis
)
4275 fdh
->elf
.other
+= entry_vis
- descr_vis
;
4276 else if (entry_vis
> descr_vis
)
4277 eh
->elf
.other
+= descr_vis
- entry_vis
;
4279 /* Propagate reference flags from entry symbol to function
4280 descriptor symbol. */
4281 fdh
->elf
.root
.non_ir_ref_regular
|= eh
->elf
.root
.non_ir_ref_regular
;
4282 fdh
->elf
.root
.non_ir_ref_dynamic
|= eh
->elf
.root
.non_ir_ref_dynamic
;
4283 fdh
->elf
.ref_regular
|= eh
->elf
.ref_regular
;
4284 fdh
->elf
.ref_regular_nonweak
|= eh
->elf
.ref_regular_nonweak
;
4286 if (!fdh
->elf
.forced_local
4287 && fdh
->elf
.dynindx
== -1
4288 && fdh
->elf
.versioned
!= versioned_hidden
4289 && (bfd_link_dll (info
)
4290 || fdh
->elf
.def_dynamic
4291 || fdh
->elf
.ref_dynamic
)
4292 && (eh
->elf
.ref_regular
4293 || eh
->elf
.def_regular
))
4295 if (!bfd_elf_link_record_dynamic_symbol (info
, &fdh
->elf
))
4303 /* Set up opd section info and abiversion for IBFD, and process list
4304 of dot-symbols we made in link_hash_newfunc. */
4307 ppc64_elf_before_check_relocs (bfd
*ibfd
, struct bfd_link_info
*info
)
4309 struct ppc_link_hash_table
*htab
;
4310 struct ppc_link_hash_entry
**p
, *eh
;
4311 asection
*opd
= bfd_get_section_by_name (ibfd
, ".opd");
4313 if (opd
!= NULL
&& opd
->size
!= 0)
4315 BFD_ASSERT (ppc64_elf_section_data (opd
)->sec_type
== sec_normal
);
4316 ppc64_elf_section_data (opd
)->sec_type
= sec_opd
;
4318 if (abiversion (ibfd
) == 0)
4319 set_abiversion (ibfd
, 1);
4320 else if (abiversion (ibfd
) >= 2)
4322 /* xgettext:c-format */
4323 _bfd_error_handler (_("%pB .opd not allowed in ABI version %d"),
4324 ibfd
, abiversion (ibfd
));
4325 bfd_set_error (bfd_error_bad_value
);
4330 if (is_ppc64_elf (info
->output_bfd
))
4332 /* For input files without an explicit abiversion in e_flags
4333 we should have flagged any with symbol st_other bits set
4334 as ELFv1 and above flagged those with .opd as ELFv2.
4335 Set the output abiversion if not yet set, and for any input
4336 still ambiguous, take its abiversion from the output.
4337 Differences in ABI are reported later. */
4338 if (abiversion (info
->output_bfd
) == 0)
4339 set_abiversion (info
->output_bfd
, abiversion (ibfd
));
4340 else if (abiversion (ibfd
) == 0)
4341 set_abiversion (ibfd
, abiversion (info
->output_bfd
));
4344 htab
= ppc_hash_table (info
);
4348 if (opd
!= NULL
&& opd
->size
!= 0
4349 && (ibfd
->flags
& DYNAMIC
) == 0
4350 && (opd
->flags
& SEC_RELOC
) != 0
4351 && opd
->reloc_count
!= 0
4352 && !bfd_is_abs_section (opd
->output_section
)
4353 && info
->gc_sections
)
4355 /* Garbage collection needs some extra help with .opd sections.
4356 We don't want to necessarily keep everything referenced by
4357 relocs in .opd, as that would keep all functions. Instead,
4358 if we reference an .opd symbol (a function descriptor), we
4359 want to keep the function code symbol's section. This is
4360 easy for global symbols, but for local syms we need to keep
4361 information about the associated function section. */
4363 asection
**opd_sym_map
;
4364 Elf_Internal_Shdr
*symtab_hdr
;
4365 Elf_Internal_Rela
*relocs
, *rel_end
, *rel
;
4367 amt
= OPD_NDX (opd
->size
) * sizeof (*opd_sym_map
);
4368 opd_sym_map
= bfd_zalloc (ibfd
, amt
);
4369 if (opd_sym_map
== NULL
)
4371 ppc64_elf_section_data (opd
)->u
.opd
.func_sec
= opd_sym_map
;
4372 relocs
= _bfd_elf_link_read_relocs (ibfd
, opd
, NULL
, NULL
,
4376 symtab_hdr
= &elf_symtab_hdr (ibfd
);
4377 rel_end
= relocs
+ opd
->reloc_count
- 1;
4378 for (rel
= relocs
; rel
< rel_end
; rel
++)
4380 enum elf_ppc64_reloc_type r_type
= ELF64_R_TYPE (rel
->r_info
);
4381 unsigned long r_symndx
= ELF64_R_SYM (rel
->r_info
);
4383 if (r_type
== R_PPC64_ADDR64
4384 && ELF64_R_TYPE ((rel
+ 1)->r_info
) == R_PPC64_TOC
4385 && r_symndx
< symtab_hdr
->sh_info
)
4387 Elf_Internal_Sym
*isym
;
4390 isym
= bfd_sym_from_r_symndx (&htab
->elf
.sym_cache
, ibfd
,
4394 if (elf_section_data (opd
)->relocs
!= relocs
)
4399 s
= bfd_section_from_elf_index (ibfd
, isym
->st_shndx
);
4400 if (s
!= NULL
&& s
!= opd
)
4401 opd_sym_map
[OPD_NDX (rel
->r_offset
)] = s
;
4404 if (elf_section_data (opd
)->relocs
!= relocs
)
4408 p
= &htab
->dot_syms
;
4409 while ((eh
= *p
) != NULL
)
4412 if (&eh
->elf
== htab
->elf
.hgot
)
4414 else if (htab
->elf
.hgot
== NULL
4415 && strcmp (eh
->elf
.root
.root
.string
, ".TOC.") == 0)
4416 htab
->elf
.hgot
= &eh
->elf
;
4417 else if (abiversion (ibfd
) <= 1)
4419 htab
->need_func_desc_adj
= 1;
4420 if (!add_symbol_adjust (eh
, info
))
4423 p
= &eh
->u
.next_dot_sym
;
4428 /* Undo hash table changes when an --as-needed input file is determined
4429 not to be needed. */
4432 ppc64_elf_notice_as_needed (bfd
*ibfd
,
4433 struct bfd_link_info
*info
,
4434 enum notice_asneeded_action act
)
4436 if (act
== notice_not_needed
)
4438 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
4443 htab
->dot_syms
= NULL
;
4445 return _bfd_elf_notice_as_needed (ibfd
, info
, act
);
4448 /* If --just-symbols against a final linked binary, then assume we need
4449 toc adjusting stubs when calling functions defined there. */
4452 ppc64_elf_link_just_syms (asection
*sec
, struct bfd_link_info
*info
)
4454 if ((sec
->flags
& SEC_CODE
) != 0
4455 && (sec
->owner
->flags
& (EXEC_P
| DYNAMIC
)) != 0
4456 && is_ppc64_elf (sec
->owner
))
4458 if (abiversion (sec
->owner
) >= 2
4459 || bfd_get_section_by_name (sec
->owner
, ".opd") != NULL
)
4460 sec
->has_toc_reloc
= 1;
4462 _bfd_elf_link_just_syms (sec
, info
);
4465 static struct plt_entry
**
4466 update_local_sym_info (bfd
*abfd
, Elf_Internal_Shdr
*symtab_hdr
,
4467 unsigned long r_symndx
, bfd_vma r_addend
, int tls_type
)
4469 struct got_entry
**local_got_ents
= elf_local_got_ents (abfd
);
4470 struct plt_entry
**local_plt
;
4471 unsigned char *local_got_tls_masks
;
4473 if (local_got_ents
== NULL
)
4475 bfd_size_type size
= symtab_hdr
->sh_info
;
4477 size
*= (sizeof (*local_got_ents
)
4478 + sizeof (*local_plt
)
4479 + sizeof (*local_got_tls_masks
));
4480 local_got_ents
= bfd_zalloc (abfd
, size
);
4481 if (local_got_ents
== NULL
)
4483 elf_local_got_ents (abfd
) = local_got_ents
;
4486 if ((tls_type
& (NON_GOT
| TLS_EXPLICIT
)) == 0)
4488 struct got_entry
*ent
;
4490 for (ent
= local_got_ents
[r_symndx
]; ent
!= NULL
; ent
= ent
->next
)
4491 if (ent
->addend
== r_addend
4492 && ent
->owner
== abfd
4493 && ent
->tls_type
== tls_type
)
4497 size_t amt
= sizeof (*ent
);
4498 ent
= bfd_alloc (abfd
, amt
);
4501 ent
->next
= local_got_ents
[r_symndx
];
4502 ent
->addend
= r_addend
;
4504 ent
->tls_type
= tls_type
;
4505 ent
->is_indirect
= FALSE
;
4506 ent
->got
.refcount
= 0;
4507 local_got_ents
[r_symndx
] = ent
;
4509 ent
->got
.refcount
+= 1;
4512 local_plt
= (struct plt_entry
**) (local_got_ents
+ symtab_hdr
->sh_info
);
4513 local_got_tls_masks
= (unsigned char *) (local_plt
+ symtab_hdr
->sh_info
);
4514 local_got_tls_masks
[r_symndx
] |= tls_type
& 0xff;
4516 return local_plt
+ r_symndx
;
4520 update_plt_info (bfd
*abfd
, struct plt_entry
**plist
, bfd_vma addend
)
4522 struct plt_entry
*ent
;
4524 for (ent
= *plist
; ent
!= NULL
; ent
= ent
->next
)
4525 if (ent
->addend
== addend
)
4529 size_t amt
= sizeof (*ent
);
4530 ent
= bfd_alloc (abfd
, amt
);
4534 ent
->addend
= addend
;
4535 ent
->plt
.refcount
= 0;
4538 ent
->plt
.refcount
+= 1;
4543 is_branch_reloc (enum elf_ppc64_reloc_type r_type
)
4545 return (r_type
== R_PPC64_REL24
4546 || r_type
== R_PPC64_REL24_NOTOC
4547 || r_type
== R_PPC64_REL14
4548 || r_type
== R_PPC64_REL14_BRTAKEN
4549 || r_type
== R_PPC64_REL14_BRNTAKEN
4550 || r_type
== R_PPC64_ADDR24
4551 || r_type
== R_PPC64_ADDR14
4552 || r_type
== R_PPC64_ADDR14_BRTAKEN
4553 || r_type
== R_PPC64_ADDR14_BRNTAKEN
4554 || r_type
== R_PPC64_PLTCALL
4555 || r_type
== R_PPC64_PLTCALL_NOTOC
);
4558 /* Relocs on inline plt call sequence insns prior to the call. */
4561 is_plt_seq_reloc (enum elf_ppc64_reloc_type r_type
)
4563 return (r_type
== R_PPC64_PLT16_HA
4564 || r_type
== R_PPC64_PLT16_HI
4565 || r_type
== R_PPC64_PLT16_LO
4566 || r_type
== R_PPC64_PLT16_LO_DS
4567 || r_type
== R_PPC64_PLT_PCREL34
4568 || r_type
== R_PPC64_PLT_PCREL34_NOTOC
4569 || r_type
== R_PPC64_PLTSEQ
4570 || r_type
== R_PPC64_PLTSEQ_NOTOC
);
4573 /* Look through the relocs for a section during the first phase, and
4574 calculate needed space in the global offset table, procedure
4575 linkage table, and dynamic reloc sections. */
4578 ppc64_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
4579 asection
*sec
, const Elf_Internal_Rela
*relocs
)
4581 struct ppc_link_hash_table
*htab
;
4582 Elf_Internal_Shdr
*symtab_hdr
;
4583 struct elf_link_hash_entry
**sym_hashes
;
4584 const Elf_Internal_Rela
*rel
;
4585 const Elf_Internal_Rela
*rel_end
;
4587 struct elf_link_hash_entry
*tga
, *dottga
;
4590 if (bfd_link_relocatable (info
))
4593 BFD_ASSERT (is_ppc64_elf (abfd
));
4595 htab
= ppc_hash_table (info
);
4599 tga
= elf_link_hash_lookup (&htab
->elf
, "__tls_get_addr",
4600 FALSE
, FALSE
, TRUE
);
4601 dottga
= elf_link_hash_lookup (&htab
->elf
, ".__tls_get_addr",
4602 FALSE
, FALSE
, TRUE
);
4603 symtab_hdr
= &elf_symtab_hdr (abfd
);
4604 sym_hashes
= elf_sym_hashes (abfd
);
4606 is_opd
= ppc64_elf_section_data (sec
)->sec_type
== sec_opd
;
4607 rel_end
= relocs
+ sec
->reloc_count
;
4608 for (rel
= relocs
; rel
< rel_end
; rel
++)
4610 unsigned long r_symndx
;
4611 struct elf_link_hash_entry
*h
;
4612 enum elf_ppc64_reloc_type r_type
;
4614 struct _ppc64_elf_section_data
*ppc64_sec
;
4615 struct plt_entry
**ifunc
, **plt_list
;
4617 r_symndx
= ELF64_R_SYM (rel
->r_info
);
4618 if (r_symndx
< symtab_hdr
->sh_info
)
4622 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
4623 h
= elf_follow_link (h
);
4625 if (h
== htab
->elf
.hgot
)
4626 sec
->has_toc_reloc
= 1;
4629 r_type
= ELF64_R_TYPE (rel
->r_info
);
4633 case R_PPC64_D34_LO
:
4634 case R_PPC64_D34_HI30
:
4635 case R_PPC64_D34_HA30
:
4637 case R_PPC64_TPREL34
:
4638 case R_PPC64_DTPREL34
:
4639 case R_PPC64_PCREL34
:
4640 case R_PPC64_GOT_PCREL34
:
4641 case R_PPC64_GOT_TLSGD_PCREL34
:
4642 case R_PPC64_GOT_TLSLD_PCREL34
:
4643 case R_PPC64_GOT_TPREL_PCREL34
:
4644 case R_PPC64_GOT_DTPREL_PCREL34
:
4645 case R_PPC64_PLT_PCREL34
:
4646 case R_PPC64_PLT_PCREL34_NOTOC
:
4647 case R_PPC64_PCREL28
:
4648 htab
->has_power10_relocs
= 1;
4656 case R_PPC64_PLT16_HA
:
4657 case R_PPC64_GOT_TLSLD16_HA
:
4658 case R_PPC64_GOT_TLSGD16_HA
:
4659 case R_PPC64_GOT_TPREL16_HA
:
4660 case R_PPC64_GOT_DTPREL16_HA
:
4661 case R_PPC64_GOT16_HA
:
4662 case R_PPC64_TOC16_HA
:
4663 case R_PPC64_PLT16_LO
:
4664 case R_PPC64_PLT16_LO_DS
:
4665 case R_PPC64_GOT_TLSLD16_LO
:
4666 case R_PPC64_GOT_TLSGD16_LO
:
4667 case R_PPC64_GOT_TPREL16_LO_DS
:
4668 case R_PPC64_GOT_DTPREL16_LO_DS
:
4669 case R_PPC64_GOT16_LO
:
4670 case R_PPC64_GOT16_LO_DS
:
4671 case R_PPC64_TOC16_LO
:
4672 case R_PPC64_TOC16_LO_DS
:
4673 case R_PPC64_GOT_PCREL34
:
4674 ppc64_elf_tdata (abfd
)->has_optrel
= 1;
4675 ppc64_elf_section_data (sec
)->has_optrel
= 1;
4684 if (h
->type
== STT_GNU_IFUNC
)
4687 ifunc
= &h
->plt
.plist
;
4692 Elf_Internal_Sym
*isym
= bfd_sym_from_r_symndx (&htab
->elf
.sym_cache
,
4697 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
4699 ifunc
= update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4701 NON_GOT
| PLT_IFUNC
);
4712 /* These special tls relocs tie a call to __tls_get_addr with
4713 its parameter symbol. */
4715 ppc_elf_hash_entry (h
)->tls_mask
|= TLS_TLS
| TLS_MARK
;
4717 if (!update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4719 NON_GOT
| TLS_TLS
| TLS_MARK
))
4721 sec
->has_tls_reloc
= 1;
4724 case R_PPC64_GOT_TLSLD16
:
4725 case R_PPC64_GOT_TLSLD16_LO
:
4726 case R_PPC64_GOT_TLSLD16_HI
:
4727 case R_PPC64_GOT_TLSLD16_HA
:
4728 case R_PPC64_GOT_TLSLD_PCREL34
:
4729 tls_type
= TLS_TLS
| TLS_LD
;
4732 case R_PPC64_GOT_TLSGD16
:
4733 case R_PPC64_GOT_TLSGD16_LO
:
4734 case R_PPC64_GOT_TLSGD16_HI
:
4735 case R_PPC64_GOT_TLSGD16_HA
:
4736 case R_PPC64_GOT_TLSGD_PCREL34
:
4737 tls_type
= TLS_TLS
| TLS_GD
;
4740 case R_PPC64_GOT_TPREL16_DS
:
4741 case R_PPC64_GOT_TPREL16_LO_DS
:
4742 case R_PPC64_GOT_TPREL16_HI
:
4743 case R_PPC64_GOT_TPREL16_HA
:
4744 case R_PPC64_GOT_TPREL_PCREL34
:
4745 if (bfd_link_dll (info
))
4746 info
->flags
|= DF_STATIC_TLS
;
4747 tls_type
= TLS_TLS
| TLS_TPREL
;
4750 case R_PPC64_GOT_DTPREL16_DS
:
4751 case R_PPC64_GOT_DTPREL16_LO_DS
:
4752 case R_PPC64_GOT_DTPREL16_HI
:
4753 case R_PPC64_GOT_DTPREL16_HA
:
4754 case R_PPC64_GOT_DTPREL_PCREL34
:
4755 tls_type
= TLS_TLS
| TLS_DTPREL
;
4757 sec
->has_tls_reloc
= 1;
4761 case R_PPC64_GOT16_LO
:
4762 case R_PPC64_GOT16_HI
:
4763 case R_PPC64_GOT16_HA
:
4764 case R_PPC64_GOT16_DS
:
4765 case R_PPC64_GOT16_LO_DS
:
4766 case R_PPC64_GOT_PCREL34
:
4768 /* This symbol requires a global offset table entry. */
4769 sec
->has_toc_reloc
= 1;
4770 if (r_type
== R_PPC64_GOT_TLSLD16
4771 || r_type
== R_PPC64_GOT_TLSGD16
4772 || r_type
== R_PPC64_GOT_TPREL16_DS
4773 || r_type
== R_PPC64_GOT_DTPREL16_DS
4774 || r_type
== R_PPC64_GOT16
4775 || r_type
== R_PPC64_GOT16_DS
)
4777 htab
->do_multi_toc
= 1;
4778 ppc64_elf_tdata (abfd
)->has_small_toc_reloc
= 1;
4781 if (ppc64_elf_tdata (abfd
)->got
== NULL
4782 && !create_got_section (abfd
, info
))
4787 struct ppc_link_hash_entry
*eh
;
4788 struct got_entry
*ent
;
4790 eh
= ppc_elf_hash_entry (h
);
4791 for (ent
= eh
->elf
.got
.glist
; ent
!= NULL
; ent
= ent
->next
)
4792 if (ent
->addend
== rel
->r_addend
4793 && ent
->owner
== abfd
4794 && ent
->tls_type
== tls_type
)
4798 size_t amt
= sizeof (*ent
);
4799 ent
= bfd_alloc (abfd
, amt
);
4802 ent
->next
= eh
->elf
.got
.glist
;
4803 ent
->addend
= rel
->r_addend
;
4805 ent
->tls_type
= tls_type
;
4806 ent
->is_indirect
= FALSE
;
4807 ent
->got
.refcount
= 0;
4808 eh
->elf
.got
.glist
= ent
;
4810 ent
->got
.refcount
+= 1;
4811 eh
->tls_mask
|= tls_type
;
4814 /* This is a global offset table entry for a local symbol. */
4815 if (!update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4816 rel
->r_addend
, tls_type
))
4820 case R_PPC64_PLT16_HA
:
4821 case R_PPC64_PLT16_HI
:
4822 case R_PPC64_PLT16_LO
:
4823 case R_PPC64_PLT16_LO_DS
:
4824 case R_PPC64_PLT_PCREL34
:
4825 case R_PPC64_PLT_PCREL34_NOTOC
:
4828 /* This symbol requires a procedure linkage table entry. */
4833 if (h
->root
.root
.string
[0] == '.'
4834 && h
->root
.root
.string
[1] != '\0')
4835 ppc_elf_hash_entry (h
)->is_func
= 1;
4836 ppc_elf_hash_entry (h
)->tls_mask
|= PLT_KEEP
;
4837 plt_list
= &h
->plt
.plist
;
4839 if (plt_list
== NULL
)
4840 plt_list
= update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4842 NON_GOT
| PLT_KEEP
);
4843 if (!update_plt_info (abfd
, plt_list
, rel
->r_addend
))
4847 /* The following relocations don't need to propagate the
4848 relocation if linking a shared object since they are
4849 section relative. */
4850 case R_PPC64_SECTOFF
:
4851 case R_PPC64_SECTOFF_LO
:
4852 case R_PPC64_SECTOFF_HI
:
4853 case R_PPC64_SECTOFF_HA
:
4854 case R_PPC64_SECTOFF_DS
:
4855 case R_PPC64_SECTOFF_LO_DS
:
4856 case R_PPC64_DTPREL16
:
4857 case R_PPC64_DTPREL16_LO
:
4858 case R_PPC64_DTPREL16_HI
:
4859 case R_PPC64_DTPREL16_HA
:
4860 case R_PPC64_DTPREL16_DS
:
4861 case R_PPC64_DTPREL16_LO_DS
:
4862 case R_PPC64_DTPREL16_HIGH
:
4863 case R_PPC64_DTPREL16_HIGHA
:
4864 case R_PPC64_DTPREL16_HIGHER
:
4865 case R_PPC64_DTPREL16_HIGHERA
:
4866 case R_PPC64_DTPREL16_HIGHEST
:
4867 case R_PPC64_DTPREL16_HIGHESTA
:
4872 case R_PPC64_REL16_LO
:
4873 case R_PPC64_REL16_HI
:
4874 case R_PPC64_REL16_HA
:
4875 case R_PPC64_REL16_HIGH
:
4876 case R_PPC64_REL16_HIGHA
:
4877 case R_PPC64_REL16_HIGHER
:
4878 case R_PPC64_REL16_HIGHERA
:
4879 case R_PPC64_REL16_HIGHEST
:
4880 case R_PPC64_REL16_HIGHESTA
:
4881 case R_PPC64_REL16_HIGHER34
:
4882 case R_PPC64_REL16_HIGHERA34
:
4883 case R_PPC64_REL16_HIGHEST34
:
4884 case R_PPC64_REL16_HIGHESTA34
:
4885 case R_PPC64_REL16DX_HA
:
4888 /* Not supported as a dynamic relocation. */
4889 case R_PPC64_ADDR64_LOCAL
:
4890 if (bfd_link_pic (info
))
4892 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
4894 /* xgettext:c-format */
4895 info
->callbacks
->einfo (_("%H: %s reloc unsupported "
4896 "in shared libraries and PIEs\n"),
4897 abfd
, sec
, rel
->r_offset
,
4898 ppc64_elf_howto_table
[r_type
]->name
);
4899 bfd_set_error (bfd_error_bad_value
);
4905 case R_PPC64_TOC16_DS
:
4906 htab
->do_multi_toc
= 1;
4907 ppc64_elf_tdata (abfd
)->has_small_toc_reloc
= 1;
4909 case R_PPC64_TOC16_LO
:
4910 case R_PPC64_TOC16_HI
:
4911 case R_PPC64_TOC16_HA
:
4912 case R_PPC64_TOC16_LO_DS
:
4913 sec
->has_toc_reloc
= 1;
4914 if (h
!= NULL
&& bfd_link_executable (info
))
4916 /* We may need a copy reloc. */
4918 /* Strongly prefer a copy reloc over a dynamic reloc.
4919 glibc ld.so as of 2019-08 will error out if one of
4920 these relocations is emitted. */
4930 /* This relocation describes the C++ object vtable hierarchy.
4931 Reconstruct it for later use during GC. */
4932 case R_PPC64_GNU_VTINHERIT
:
4933 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
4937 /* This relocation describes which C++ vtable entries are actually
4938 used. Record for later use during GC. */
4939 case R_PPC64_GNU_VTENTRY
:
4940 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
4945 case R_PPC64_REL14_BRTAKEN
:
4946 case R_PPC64_REL14_BRNTAKEN
:
4948 asection
*dest
= NULL
;
4950 /* Heuristic: If jumping outside our section, chances are
4951 we are going to need a stub. */
4954 /* If the sym is weak it may be overridden later, so
4955 don't assume we know where a weak sym lives. */
4956 if (h
->root
.type
== bfd_link_hash_defined
)
4957 dest
= h
->root
.u
.def
.section
;
4961 Elf_Internal_Sym
*isym
;
4963 isym
= bfd_sym_from_r_symndx (&htab
->elf
.sym_cache
,
4968 dest
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
4972 ppc64_elf_section_data (sec
)->has_14bit_branch
= 1;
4976 case R_PPC64_PLTCALL
:
4977 case R_PPC64_PLTCALL_NOTOC
:
4978 ppc64_elf_section_data (sec
)->has_pltcall
= 1;
4982 case R_PPC64_REL24_NOTOC
:
4988 if (h
->root
.root
.string
[0] == '.'
4989 && h
->root
.root
.string
[1] != '\0')
4990 ppc_elf_hash_entry (h
)->is_func
= 1;
4992 if (h
== tga
|| h
== dottga
)
4994 sec
->has_tls_reloc
= 1;
4996 && (ELF64_R_TYPE (rel
[-1].r_info
) == R_PPC64_TLSGD
4997 || ELF64_R_TYPE (rel
[-1].r_info
) == R_PPC64_TLSLD
))
4998 /* We have a new-style __tls_get_addr call with
5002 /* Mark this section as having an old-style call. */
5003 sec
->nomark_tls_get_addr
= 1;
5005 plt_list
= &h
->plt
.plist
;
5008 /* We may need a .plt entry if the function this reloc
5009 refers to is in a shared lib. */
5011 && !update_plt_info (abfd
, plt_list
, rel
->r_addend
))
5015 case R_PPC64_ADDR14
:
5016 case R_PPC64_ADDR14_BRNTAKEN
:
5017 case R_PPC64_ADDR14_BRTAKEN
:
5018 case R_PPC64_ADDR24
:
5021 case R_PPC64_TPREL64
:
5022 tls_type
= TLS_EXPLICIT
| TLS_TLS
| TLS_TPREL
;
5023 if (bfd_link_dll (info
))
5024 info
->flags
|= DF_STATIC_TLS
;
5027 case R_PPC64_DTPMOD64
:
5028 if (rel
+ 1 < rel_end
5029 && rel
[1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_DTPREL64
)
5030 && rel
[1].r_offset
== rel
->r_offset
+ 8)
5031 tls_type
= TLS_EXPLICIT
| TLS_TLS
| TLS_GD
;
5033 tls_type
= TLS_EXPLICIT
| TLS_TLS
| TLS_LD
;
5036 case R_PPC64_DTPREL64
:
5037 tls_type
= TLS_EXPLICIT
| TLS_TLS
| TLS_DTPREL
;
5039 && rel
[-1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_DTPMOD64
)
5040 && rel
[-1].r_offset
== rel
->r_offset
- 8)
5041 /* This is the second reloc of a dtpmod, dtprel pair.
5042 Don't mark with TLS_DTPREL. */
5046 sec
->has_tls_reloc
= 1;
5048 ppc_elf_hash_entry (h
)->tls_mask
|= tls_type
& 0xff;
5050 if (!update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
5051 rel
->r_addend
, tls_type
))
5054 ppc64_sec
= ppc64_elf_section_data (sec
);
5055 if (ppc64_sec
->sec_type
!= sec_toc
)
5059 /* One extra to simplify get_tls_mask. */
5060 amt
= sec
->size
* sizeof (unsigned) / 8 + sizeof (unsigned);
5061 ppc64_sec
->u
.toc
.symndx
= bfd_zalloc (abfd
, amt
);
5062 if (ppc64_sec
->u
.toc
.symndx
== NULL
)
5064 amt
= sec
->size
* sizeof (bfd_vma
) / 8;
5065 ppc64_sec
->u
.toc
.add
= bfd_zalloc (abfd
, amt
);
5066 if (ppc64_sec
->u
.toc
.add
== NULL
)
5068 BFD_ASSERT (ppc64_sec
->sec_type
== sec_normal
);
5069 ppc64_sec
->sec_type
= sec_toc
;
5071 BFD_ASSERT (rel
->r_offset
% 8 == 0);
5072 ppc64_sec
->u
.toc
.symndx
[rel
->r_offset
/ 8] = r_symndx
;
5073 ppc64_sec
->u
.toc
.add
[rel
->r_offset
/ 8] = rel
->r_addend
;
5075 /* Mark the second slot of a GD or LD entry.
5076 -1 to indicate GD and -2 to indicate LD. */
5077 if (tls_type
== (TLS_EXPLICIT
| TLS_TLS
| TLS_GD
))
5078 ppc64_sec
->u
.toc
.symndx
[rel
->r_offset
/ 8 + 1] = -1;
5079 else if (tls_type
== (TLS_EXPLICIT
| TLS_TLS
| TLS_LD
))
5080 ppc64_sec
->u
.toc
.symndx
[rel
->r_offset
/ 8 + 1] = -2;
5083 case R_PPC64_TPREL16_HI
:
5084 case R_PPC64_TPREL16_HA
:
5085 case R_PPC64_TPREL16_HIGH
:
5086 case R_PPC64_TPREL16_HIGHA
:
5087 case R_PPC64_TPREL16_HIGHER
:
5088 case R_PPC64_TPREL16_HIGHERA
:
5089 case R_PPC64_TPREL16_HIGHEST
:
5090 case R_PPC64_TPREL16_HIGHESTA
:
5091 sec
->has_tls_reloc
= 1;
5093 case R_PPC64_TPREL34
:
5094 case R_PPC64_TPREL16
:
5095 case R_PPC64_TPREL16_DS
:
5096 case R_PPC64_TPREL16_LO
:
5097 case R_PPC64_TPREL16_LO_DS
:
5098 if (bfd_link_dll (info
))
5099 info
->flags
|= DF_STATIC_TLS
;
5102 case R_PPC64_ADDR64
:
5104 && rel
+ 1 < rel_end
5105 && ELF64_R_TYPE ((rel
+ 1)->r_info
) == R_PPC64_TOC
)
5108 ppc_elf_hash_entry (h
)->is_func
= 1;
5112 case R_PPC64_ADDR16
:
5113 case R_PPC64_ADDR16_DS
:
5114 case R_PPC64_ADDR16_HA
:
5115 case R_PPC64_ADDR16_HI
:
5116 case R_PPC64_ADDR16_HIGH
:
5117 case R_PPC64_ADDR16_HIGHA
:
5118 case R_PPC64_ADDR16_HIGHER
:
5119 case R_PPC64_ADDR16_HIGHERA
:
5120 case R_PPC64_ADDR16_HIGHEST
:
5121 case R_PPC64_ADDR16_HIGHESTA
:
5122 case R_PPC64_ADDR16_LO
:
5123 case R_PPC64_ADDR16_LO_DS
:
5125 case R_PPC64_D34_LO
:
5126 case R_PPC64_D34_HI30
:
5127 case R_PPC64_D34_HA30
:
5128 case R_PPC64_ADDR16_HIGHER34
:
5129 case R_PPC64_ADDR16_HIGHERA34
:
5130 case R_PPC64_ADDR16_HIGHEST34
:
5131 case R_PPC64_ADDR16_HIGHESTA34
:
5133 if (h
!= NULL
&& !bfd_link_pic (info
) && abiversion (abfd
) != 1
5134 && rel
->r_addend
== 0)
5136 /* We may need a .plt entry if this reloc refers to a
5137 function in a shared lib. */
5138 if (!update_plt_info (abfd
, &h
->plt
.plist
, 0))
5140 h
->pointer_equality_needed
= 1;
5147 case R_PPC64_ADDR32
:
5148 case R_PPC64_UADDR16
:
5149 case R_PPC64_UADDR32
:
5150 case R_PPC64_UADDR64
:
5152 if (h
!= NULL
&& bfd_link_executable (info
))
5153 /* We may need a copy reloc. */
5156 /* Don't propagate .opd relocs. */
5157 if (NO_OPD_RELOCS
&& is_opd
)
5160 /* If we are creating a shared library, and this is a reloc
5161 against a global symbol, or a non PC relative reloc
5162 against a local symbol, then we need to copy the reloc
5163 into the shared library. However, if we are linking with
5164 -Bsymbolic, we do not need to copy a reloc against a
5165 global symbol which is defined in an object we are
5166 including in the link (i.e., DEF_REGULAR is set). At
5167 this point we have not seen all the input files, so it is
5168 possible that DEF_REGULAR is not set now but will be set
5169 later (it is never cleared). In case of a weak definition,
5170 DEF_REGULAR may be cleared later by a strong definition in
5171 a shared library. We account for that possibility below by
5172 storing information in the dyn_relocs field of the hash
5173 table entry. A similar situation occurs when creating
5174 shared libraries and symbol visibility changes render the
5177 If on the other hand, we are creating an executable, we
5178 may need to keep relocations for symbols satisfied by a
5179 dynamic library if we manage to avoid copy relocs for the
5183 && (h
->root
.type
== bfd_link_hash_defweak
5184 || !h
->def_regular
))
5186 && !bfd_link_executable (info
)
5187 && !SYMBOLIC_BIND (info
, h
))
5188 || (bfd_link_pic (info
)
5189 && must_be_dyn_reloc (info
, r_type
))
5190 || (!bfd_link_pic (info
)
5193 /* We must copy these reloc types into the output file.
5194 Create a reloc section in dynobj and make room for
5198 sreloc
= _bfd_elf_make_dynamic_reloc_section
5199 (sec
, htab
->elf
.dynobj
, 3, abfd
, /*rela?*/ TRUE
);
5205 /* If this is a global symbol, we count the number of
5206 relocations we need for this symbol. */
5209 struct elf_dyn_relocs
*p
;
5210 struct elf_dyn_relocs
**head
;
5212 head
= &h
->dyn_relocs
;
5214 if (p
== NULL
|| p
->sec
!= sec
)
5216 p
= bfd_alloc (htab
->elf
.dynobj
, sizeof *p
);
5226 if (!must_be_dyn_reloc (info
, r_type
))
5231 /* Track dynamic relocs needed for local syms too.
5232 We really need local syms available to do this
5234 struct ppc_dyn_relocs
*p
;
5235 struct ppc_dyn_relocs
**head
;
5236 bfd_boolean is_ifunc
;
5239 Elf_Internal_Sym
*isym
;
5241 isym
= bfd_sym_from_r_symndx (&htab
->elf
.sym_cache
,
5246 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
5250 vpp
= &elf_section_data (s
)->local_dynrel
;
5251 head
= (struct ppc_dyn_relocs
**) vpp
;
5252 is_ifunc
= ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
;
5254 if (p
!= NULL
&& p
->sec
== sec
&& p
->ifunc
!= is_ifunc
)
5256 if (p
== NULL
|| p
->sec
!= sec
|| p
->ifunc
!= is_ifunc
)
5258 p
= bfd_alloc (htab
->elf
.dynobj
, sizeof *p
);
5264 p
->ifunc
= is_ifunc
;
5280 /* Merge backend specific data from an object file to the output
5281 object file when linking. */
5284 ppc64_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
5286 bfd
*obfd
= info
->output_bfd
;
5287 unsigned long iflags
, oflags
;
5289 if ((ibfd
->flags
& BFD_LINKER_CREATED
) != 0)
5292 if (!is_ppc64_elf (ibfd
) || !is_ppc64_elf (obfd
))
5295 if (!_bfd_generic_verify_endian_match (ibfd
, info
))
5298 iflags
= elf_elfheader (ibfd
)->e_flags
;
5299 oflags
= elf_elfheader (obfd
)->e_flags
;
5301 if (iflags
& ~EF_PPC64_ABI
)
5304 /* xgettext:c-format */
5305 (_("%pB uses unknown e_flags 0x%lx"), ibfd
, iflags
);
5306 bfd_set_error (bfd_error_bad_value
);
5309 else if (iflags
!= oflags
&& iflags
!= 0)
5312 /* xgettext:c-format */
5313 (_("%pB: ABI version %ld is not compatible with ABI version %ld output"),
5314 ibfd
, iflags
, oflags
);
5315 bfd_set_error (bfd_error_bad_value
);
5319 if (!_bfd_elf_ppc_merge_fp_attributes (ibfd
, info
))
5322 /* Merge Tag_compatibility attributes and any common GNU ones. */
5323 return _bfd_elf_merge_object_attributes (ibfd
, info
);
5327 ppc64_elf_print_private_bfd_data (bfd
*abfd
, void *ptr
)
5329 /* Print normal ELF private data. */
5330 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
5332 if (elf_elfheader (abfd
)->e_flags
!= 0)
5336 fprintf (file
, _("private flags = 0x%lx:"),
5337 elf_elfheader (abfd
)->e_flags
);
5339 if ((elf_elfheader (abfd
)->e_flags
& EF_PPC64_ABI
) != 0)
5340 fprintf (file
, _(" [abiv%ld]"),
5341 elf_elfheader (abfd
)->e_flags
& EF_PPC64_ABI
);
5348 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
5349 of the code entry point, and its section, which must be in the same
5350 object as OPD_SEC. Returns (bfd_vma) -1 on error. */
5353 opd_entry_value (asection
*opd_sec
,
5355 asection
**code_sec
,
5357 bfd_boolean in_code_sec
)
5359 bfd
*opd_bfd
= opd_sec
->owner
;
5360 Elf_Internal_Rela
*relocs
;
5361 Elf_Internal_Rela
*lo
, *hi
, *look
;
5364 /* No relocs implies we are linking a --just-symbols object, or looking
5365 at a final linked executable with addr2line or somesuch. */
5366 if (opd_sec
->reloc_count
== 0)
5368 bfd_byte
*contents
= ppc64_elf_tdata (opd_bfd
)->opd
.contents
;
5370 if (contents
== NULL
)
5372 if (!bfd_malloc_and_get_section (opd_bfd
, opd_sec
, &contents
))
5373 return (bfd_vma
) -1;
5374 ppc64_elf_tdata (opd_bfd
)->opd
.contents
= contents
;
5377 /* PR 17512: file: 64b9dfbb. */
5378 if (offset
+ 7 >= opd_sec
->size
|| offset
+ 7 < offset
)
5379 return (bfd_vma
) -1;
5381 val
= bfd_get_64 (opd_bfd
, contents
+ offset
);
5382 if (code_sec
!= NULL
)
5384 asection
*sec
, *likely
= NULL
;
5390 && val
< sec
->vma
+ sec
->size
)
5396 for (sec
= opd_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
5398 && (sec
->flags
& SEC_LOAD
) != 0
5399 && (sec
->flags
& SEC_ALLOC
) != 0)
5404 if (code_off
!= NULL
)
5405 *code_off
= val
- likely
->vma
;
5411 BFD_ASSERT (is_ppc64_elf (opd_bfd
));
5413 relocs
= ppc64_elf_tdata (opd_bfd
)->opd
.relocs
;
5415 relocs
= _bfd_elf_link_read_relocs (opd_bfd
, opd_sec
, NULL
, NULL
, TRUE
);
5416 /* PR 17512: file: df8e1fd6. */
5418 return (bfd_vma
) -1;
5420 /* Go find the opd reloc at the sym address. */
5422 hi
= lo
+ opd_sec
->reloc_count
- 1; /* ignore last reloc */
5426 look
= lo
+ (hi
- lo
) / 2;
5427 if (look
->r_offset
< offset
)
5429 else if (look
->r_offset
> offset
)
5433 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (opd_bfd
);
5435 if (ELF64_R_TYPE (look
->r_info
) == R_PPC64_ADDR64
5436 && ELF64_R_TYPE ((look
+ 1)->r_info
) == R_PPC64_TOC
)
5438 unsigned long symndx
= ELF64_R_SYM (look
->r_info
);
5439 asection
*sec
= NULL
;
5441 if (symndx
>= symtab_hdr
->sh_info
5442 && elf_sym_hashes (opd_bfd
) != NULL
)
5444 struct elf_link_hash_entry
**sym_hashes
;
5445 struct elf_link_hash_entry
*rh
;
5447 sym_hashes
= elf_sym_hashes (opd_bfd
);
5448 rh
= sym_hashes
[symndx
- symtab_hdr
->sh_info
];
5451 rh
= elf_follow_link (rh
);
5452 if (rh
->root
.type
!= bfd_link_hash_defined
5453 && rh
->root
.type
!= bfd_link_hash_defweak
)
5455 if (rh
->root
.u
.def
.section
->owner
== opd_bfd
)
5457 val
= rh
->root
.u
.def
.value
;
5458 sec
= rh
->root
.u
.def
.section
;
5465 Elf_Internal_Sym
*sym
;
5467 if (symndx
< symtab_hdr
->sh_info
)
5469 sym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
5472 size_t symcnt
= symtab_hdr
->sh_info
;
5473 sym
= bfd_elf_get_elf_syms (opd_bfd
, symtab_hdr
,
5478 symtab_hdr
->contents
= (bfd_byte
*) sym
;
5484 sym
= bfd_elf_get_elf_syms (opd_bfd
, symtab_hdr
,
5490 sec
= bfd_section_from_elf_index (opd_bfd
, sym
->st_shndx
);
5493 BFD_ASSERT ((sec
->flags
& SEC_MERGE
) == 0);
5494 val
= sym
->st_value
;
5497 val
+= look
->r_addend
;
5498 if (code_off
!= NULL
)
5500 if (code_sec
!= NULL
)
5502 if (in_code_sec
&& *code_sec
!= sec
)
5507 if (sec
->output_section
!= NULL
)
5508 val
+= sec
->output_section
->vma
+ sec
->output_offset
;
5517 /* If the ELF symbol SYM might be a function in SEC, return the
5518 function size and set *CODE_OFF to the function's entry point,
5519 otherwise return zero. */
5521 static bfd_size_type
5522 ppc64_elf_maybe_function_sym (const asymbol
*sym
, asection
*sec
,
5527 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_FILE
| BSF_OBJECT
5528 | BSF_THREAD_LOCAL
| BSF_RELC
| BSF_SRELC
)) != 0)
5532 if (!(sym
->flags
& BSF_SYNTHETIC
))
5533 size
= ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
5535 if (strcmp (sym
->section
->name
, ".opd") == 0)
5537 struct _opd_sec_data
*opd
= get_opd_info (sym
->section
);
5538 bfd_vma symval
= sym
->value
;
5541 && opd
->adjust
!= NULL
5542 && elf_section_data (sym
->section
)->relocs
!= NULL
)
5544 /* opd_entry_value will use cached relocs that have been
5545 adjusted, but with raw symbols. That means both local
5546 and global symbols need adjusting. */
5547 long adjust
= opd
->adjust
[OPD_NDX (symval
)];
5553 if (opd_entry_value (sym
->section
, symval
,
5554 &sec
, code_off
, TRUE
) == (bfd_vma
) -1)
5556 /* An old ABI binary with dot-syms has a size of 24 on the .opd
5557 symbol. This size has nothing to do with the code size of the
5558 function, which is what we're supposed to return, but the
5559 code size isn't available without looking up the dot-sym.
5560 However, doing that would be a waste of time particularly
5561 since elf_find_function will look at the dot-sym anyway.
5562 Now, elf_find_function will keep the largest size of any
5563 function sym found at the code address of interest, so return
5564 1 here to avoid it incorrectly caching a larger function size
5565 for a small function. This does mean we return the wrong
5566 size for a new-ABI function of size 24, but all that does is
5567 disable caching for such functions. */
5573 if (sym
->section
!= sec
)
5575 *code_off
= sym
->value
;
5582 /* Return true if symbol is a strong function defined in an ELFv2
5583 object with st_other localentry bits of zero, ie. its local entry
5584 point coincides with its global entry point. */
5587 is_elfv2_localentry0 (struct elf_link_hash_entry
*h
)
5590 && h
->type
== STT_FUNC
5591 && h
->root
.type
== bfd_link_hash_defined
5592 && (STO_PPC64_LOCAL_MASK
& h
->other
) == 0
5593 && !ppc_elf_hash_entry (h
)->non_zero_localentry
5594 && is_ppc64_elf (h
->root
.u
.def
.section
->owner
)
5595 && abiversion (h
->root
.u
.def
.section
->owner
) >= 2);
5598 /* Return true if symbol is defined in a regular object file. */
5601 is_static_defined (struct elf_link_hash_entry
*h
)
5603 return ((h
->root
.type
== bfd_link_hash_defined
5604 || h
->root
.type
== bfd_link_hash_defweak
)
5605 && h
->root
.u
.def
.section
!= NULL
5606 && h
->root
.u
.def
.section
->output_section
!= NULL
);
5609 /* If FDH is a function descriptor symbol, return the associated code
5610 entry symbol if it is defined. Return NULL otherwise. */
5612 static struct ppc_link_hash_entry
*
5613 defined_code_entry (struct ppc_link_hash_entry
*fdh
)
5615 if (fdh
->is_func_descriptor
)
5617 struct ppc_link_hash_entry
*fh
= ppc_follow_link (fdh
->oh
);
5618 if (fh
->elf
.root
.type
== bfd_link_hash_defined
5619 || fh
->elf
.root
.type
== bfd_link_hash_defweak
)
5625 /* If FH is a function code entry symbol, return the associated
5626 function descriptor symbol if it is defined. Return NULL otherwise. */
5628 static struct ppc_link_hash_entry
*
5629 defined_func_desc (struct ppc_link_hash_entry
*fh
)
5632 && fh
->oh
->is_func_descriptor
)
5634 struct ppc_link_hash_entry
*fdh
= ppc_follow_link (fh
->oh
);
5635 if (fdh
->elf
.root
.type
== bfd_link_hash_defined
5636 || fdh
->elf
.root
.type
== bfd_link_hash_defweak
)
5642 /* Given H is a symbol that satisfies is_static_defined, return the
5643 value in the output file. */
5646 defined_sym_val (struct elf_link_hash_entry
*h
)
5648 return (h
->root
.u
.def
.section
->output_section
->vma
5649 + h
->root
.u
.def
.section
->output_offset
5650 + h
->root
.u
.def
.value
);
5653 /* Return true if H matches __tls_get_addr or one of its variants. */
5656 is_tls_get_addr (struct elf_link_hash_entry
*h
,
5657 struct ppc_link_hash_table
*htab
)
5659 return (h
== (struct elf_link_hash_entry
*) htab
->tls_get_addr_fd
5660 || h
== (struct elf_link_hash_entry
*) htab
->tga_desc_fd
5661 || h
== (struct elf_link_hash_entry
*) htab
->tls_get_addr
5662 || h
== (struct elf_link_hash_entry
*) htab
->tga_desc
);
5665 static bfd_boolean
func_desc_adjust (struct elf_link_hash_entry
*, void *);
5667 /* Garbage collect sections, after first dealing with dot-symbols. */
5670 ppc64_elf_gc_sections (bfd
*abfd
, struct bfd_link_info
*info
)
5672 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
5674 if (htab
!= NULL
&& htab
->need_func_desc_adj
)
5676 elf_link_hash_traverse (&htab
->elf
, func_desc_adjust
, info
);
5677 htab
->need_func_desc_adj
= 0;
5679 return bfd_elf_gc_sections (abfd
, info
);
5682 /* Mark all our entry sym sections, both opd and code section. */
5685 ppc64_elf_gc_keep (struct bfd_link_info
*info
)
5687 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
5688 struct bfd_sym_chain
*sym
;
5693 for (sym
= info
->gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
5695 struct ppc_link_hash_entry
*eh
, *fh
;
5698 eh
= ppc_elf_hash_entry (elf_link_hash_lookup (&htab
->elf
, sym
->name
,
5699 FALSE
, FALSE
, TRUE
));
5702 if (eh
->elf
.root
.type
!= bfd_link_hash_defined
5703 && eh
->elf
.root
.type
!= bfd_link_hash_defweak
)
5706 fh
= defined_code_entry (eh
);
5709 sec
= fh
->elf
.root
.u
.def
.section
;
5710 sec
->flags
|= SEC_KEEP
;
5712 else if (get_opd_info (eh
->elf
.root
.u
.def
.section
) != NULL
5713 && opd_entry_value (eh
->elf
.root
.u
.def
.section
,
5714 eh
->elf
.root
.u
.def
.value
,
5715 &sec
, NULL
, FALSE
) != (bfd_vma
) -1)
5716 sec
->flags
|= SEC_KEEP
;
5718 sec
= eh
->elf
.root
.u
.def
.section
;
5719 sec
->flags
|= SEC_KEEP
;
5723 /* Mark sections containing dynamically referenced symbols. When
5724 building shared libraries, we must assume that any visible symbol is
5728 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry
*h
, void *inf
)
5730 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
5731 struct ppc_link_hash_entry
*eh
= ppc_elf_hash_entry (h
);
5732 struct ppc_link_hash_entry
*fdh
;
5733 struct bfd_elf_dynamic_list
*d
= info
->dynamic_list
;
5735 /* Dynamic linking info is on the func descriptor sym. */
5736 fdh
= defined_func_desc (eh
);
5740 if ((eh
->elf
.root
.type
== bfd_link_hash_defined
5741 || eh
->elf
.root
.type
== bfd_link_hash_defweak
)
5742 && ((eh
->elf
.ref_dynamic
&& !eh
->elf
.forced_local
)
5743 || ((eh
->elf
.def_regular
|| ELF_COMMON_DEF_P (&eh
->elf
))
5744 && ELF_ST_VISIBILITY (eh
->elf
.other
) != STV_INTERNAL
5745 && ELF_ST_VISIBILITY (eh
->elf
.other
) != STV_HIDDEN
5746 && (!bfd_link_executable (info
)
5747 || info
->gc_keep_exported
5748 || info
->export_dynamic
5751 && (*d
->match
) (&d
->head
, NULL
,
5752 eh
->elf
.root
.root
.string
)))
5753 && (eh
->elf
.versioned
>= versioned
5754 || !bfd_hide_sym_by_version (info
->version_info
,
5755 eh
->elf
.root
.root
.string
)))))
5758 struct ppc_link_hash_entry
*fh
;
5760 eh
->elf
.root
.u
.def
.section
->flags
|= SEC_KEEP
;
5762 /* Function descriptor syms cause the associated
5763 function code sym section to be marked. */
5764 fh
= defined_code_entry (eh
);
5767 code_sec
= fh
->elf
.root
.u
.def
.section
;
5768 code_sec
->flags
|= SEC_KEEP
;
5770 else if (get_opd_info (eh
->elf
.root
.u
.def
.section
) != NULL
5771 && opd_entry_value (eh
->elf
.root
.u
.def
.section
,
5772 eh
->elf
.root
.u
.def
.value
,
5773 &code_sec
, NULL
, FALSE
) != (bfd_vma
) -1)
5774 code_sec
->flags
|= SEC_KEEP
;
5780 /* Return the section that should be marked against GC for a given
5784 ppc64_elf_gc_mark_hook (asection
*sec
,
5785 struct bfd_link_info
*info
,
5786 Elf_Internal_Rela
*rel
,
5787 struct elf_link_hash_entry
*h
,
5788 Elf_Internal_Sym
*sym
)
5792 /* Syms return NULL if we're marking .opd, so we avoid marking all
5793 function sections, as all functions are referenced in .opd. */
5795 if (get_opd_info (sec
) != NULL
)
5800 enum elf_ppc64_reloc_type r_type
;
5801 struct ppc_link_hash_entry
*eh
, *fh
, *fdh
;
5803 r_type
= ELF64_R_TYPE (rel
->r_info
);
5806 case R_PPC64_GNU_VTINHERIT
:
5807 case R_PPC64_GNU_VTENTRY
:
5811 switch (h
->root
.type
)
5813 case bfd_link_hash_defined
:
5814 case bfd_link_hash_defweak
:
5815 eh
= ppc_elf_hash_entry (h
);
5816 fdh
= defined_func_desc (eh
);
5819 /* -mcall-aixdesc code references the dot-symbol on
5820 a call reloc. Mark the function descriptor too
5821 against garbage collection. */
5823 if (fdh
->elf
.is_weakalias
)
5824 weakdef (&fdh
->elf
)->mark
= 1;
5828 /* Function descriptor syms cause the associated
5829 function code sym section to be marked. */
5830 fh
= defined_code_entry (eh
);
5833 /* They also mark their opd section. */
5834 eh
->elf
.root
.u
.def
.section
->gc_mark
= 1;
5836 rsec
= fh
->elf
.root
.u
.def
.section
;
5838 else if (get_opd_info (eh
->elf
.root
.u
.def
.section
) != NULL
5839 && opd_entry_value (eh
->elf
.root
.u
.def
.section
,
5840 eh
->elf
.root
.u
.def
.value
,
5841 &rsec
, NULL
, FALSE
) != (bfd_vma
) -1)
5842 eh
->elf
.root
.u
.def
.section
->gc_mark
= 1;
5844 rsec
= h
->root
.u
.def
.section
;
5847 case bfd_link_hash_common
:
5848 rsec
= h
->root
.u
.c
.p
->section
;
5852 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
5858 struct _opd_sec_data
*opd
;
5860 rsec
= bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
5861 opd
= get_opd_info (rsec
);
5862 if (opd
!= NULL
&& opd
->func_sec
!= NULL
)
5866 rsec
= opd
->func_sec
[OPD_NDX (sym
->st_value
+ rel
->r_addend
)];
5873 /* The maximum size of .sfpr. */
5874 #define SFPR_MAX (218*4)
5876 struct sfpr_def_parms
5878 const char name
[12];
5879 unsigned char lo
, hi
;
5880 bfd_byte
*(*write_ent
) (bfd
*, bfd_byte
*, int);
5881 bfd_byte
*(*write_tail
) (bfd
*, bfd_byte
*, int);
5884 /* Auto-generate _save*, _rest* functions in .sfpr.
5885 If STUB_SEC is non-null, define alias symbols in STUB_SEC
5889 sfpr_define (struct bfd_link_info
*info
,
5890 const struct sfpr_def_parms
*parm
,
5893 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
5895 size_t len
= strlen (parm
->name
);
5896 bfd_boolean writing
= FALSE
;
5902 memcpy (sym
, parm
->name
, len
);
5905 for (i
= parm
->lo
; i
<= parm
->hi
; i
++)
5907 struct ppc_link_hash_entry
*h
;
5909 sym
[len
+ 0] = i
/ 10 + '0';
5910 sym
[len
+ 1] = i
% 10 + '0';
5911 h
= ppc_elf_hash_entry (elf_link_hash_lookup (&htab
->elf
, sym
,
5912 writing
, TRUE
, TRUE
));
5913 if (stub_sec
!= NULL
)
5916 && h
->elf
.root
.type
== bfd_link_hash_defined
5917 && h
->elf
.root
.u
.def
.section
== htab
->sfpr
)
5919 struct elf_link_hash_entry
*s
;
5921 sprintf (buf
, "%08x.%s", stub_sec
->id
& 0xffffffff, sym
);
5922 s
= elf_link_hash_lookup (&htab
->elf
, buf
, TRUE
, TRUE
, FALSE
);
5925 if (s
->root
.type
== bfd_link_hash_new
)
5927 s
->root
.type
= bfd_link_hash_defined
;
5928 s
->root
.u
.def
.section
= stub_sec
;
5929 s
->root
.u
.def
.value
= (stub_sec
->size
- htab
->sfpr
->size
5930 + h
->elf
.root
.u
.def
.value
);
5933 s
->ref_regular_nonweak
= 1;
5934 s
->forced_local
= 1;
5936 s
->root
.linker_def
= 1;
5944 if (!h
->elf
.def_regular
)
5946 h
->elf
.root
.type
= bfd_link_hash_defined
;
5947 h
->elf
.root
.u
.def
.section
= htab
->sfpr
;
5948 h
->elf
.root
.u
.def
.value
= htab
->sfpr
->size
;
5949 h
->elf
.type
= STT_FUNC
;
5950 h
->elf
.def_regular
= 1;
5952 _bfd_elf_link_hash_hide_symbol (info
, &h
->elf
, TRUE
);
5954 if (htab
->sfpr
->contents
== NULL
)
5956 htab
->sfpr
->contents
5957 = bfd_alloc (htab
->elf
.dynobj
, SFPR_MAX
);
5958 if (htab
->sfpr
->contents
== NULL
)
5965 bfd_byte
*p
= htab
->sfpr
->contents
+ htab
->sfpr
->size
;
5967 p
= (*parm
->write_ent
) (htab
->elf
.dynobj
, p
, i
);
5969 p
= (*parm
->write_tail
) (htab
->elf
.dynobj
, p
, i
);
5970 htab
->sfpr
->size
= p
- htab
->sfpr
->contents
;
5978 savegpr0 (bfd
*abfd
, bfd_byte
*p
, int r
)
5980 bfd_put_32 (abfd
, STD_R0_0R1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5985 savegpr0_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5987 p
= savegpr0 (abfd
, p
, r
);
5988 bfd_put_32 (abfd
, STD_R0_0R1
+ STK_LR
, p
);
5990 bfd_put_32 (abfd
, BLR
, p
);
5995 restgpr0 (bfd
*abfd
, bfd_byte
*p
, int r
)
5997 bfd_put_32 (abfd
, LD_R0_0R1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
6002 restgpr0_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6004 bfd_put_32 (abfd
, LD_R0_0R1
+ STK_LR
, p
);
6006 p
= restgpr0 (abfd
, p
, r
);
6007 bfd_put_32 (abfd
, MTLR_R0
, p
);
6011 p
= restgpr0 (abfd
, p
, 30);
6012 p
= restgpr0 (abfd
, p
, 31);
6014 bfd_put_32 (abfd
, BLR
, p
);
6019 savegpr1 (bfd
*abfd
, bfd_byte
*p
, int r
)
6021 bfd_put_32 (abfd
, STD_R0_0R12
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
6026 savegpr1_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6028 p
= savegpr1 (abfd
, p
, r
);
6029 bfd_put_32 (abfd
, BLR
, p
);
6034 restgpr1 (bfd
*abfd
, bfd_byte
*p
, int r
)
6036 bfd_put_32 (abfd
, LD_R0_0R12
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
6041 restgpr1_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6043 p
= restgpr1 (abfd
, p
, r
);
6044 bfd_put_32 (abfd
, BLR
, p
);
6049 savefpr (bfd
*abfd
, bfd_byte
*p
, int r
)
6051 bfd_put_32 (abfd
, STFD_FR0_0R1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
6056 savefpr0_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6058 p
= savefpr (abfd
, p
, r
);
6059 bfd_put_32 (abfd
, STD_R0_0R1
+ STK_LR
, p
);
6061 bfd_put_32 (abfd
, BLR
, p
);
6066 restfpr (bfd
*abfd
, bfd_byte
*p
, int r
)
6068 bfd_put_32 (abfd
, LFD_FR0_0R1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
6073 restfpr0_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6075 bfd_put_32 (abfd
, LD_R0_0R1
+ STK_LR
, p
);
6077 p
= restfpr (abfd
, p
, r
);
6078 bfd_put_32 (abfd
, MTLR_R0
, p
);
6082 p
= restfpr (abfd
, p
, 30);
6083 p
= restfpr (abfd
, p
, 31);
6085 bfd_put_32 (abfd
, BLR
, p
);
6090 savefpr1_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6092 p
= savefpr (abfd
, p
, r
);
6093 bfd_put_32 (abfd
, BLR
, p
);
6098 restfpr1_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6100 p
= restfpr (abfd
, p
, r
);
6101 bfd_put_32 (abfd
, BLR
, p
);
6106 savevr (bfd
*abfd
, bfd_byte
*p
, int r
)
6108 bfd_put_32 (abfd
, LI_R12_0
+ (1 << 16) - (32 - r
) * 16, p
);
6110 bfd_put_32 (abfd
, STVX_VR0_R12_R0
+ (r
<< 21), p
);
6115 savevr_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6117 p
= savevr (abfd
, p
, r
);
6118 bfd_put_32 (abfd
, BLR
, p
);
6123 restvr (bfd
*abfd
, bfd_byte
*p
, int r
)
6125 bfd_put_32 (abfd
, LI_R12_0
+ (1 << 16) - (32 - r
) * 16, p
);
6127 bfd_put_32 (abfd
, LVX_VR0_R12_R0
+ (r
<< 21), p
);
6132 restvr_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6134 p
= restvr (abfd
, p
, r
);
6135 bfd_put_32 (abfd
, BLR
, p
);
6139 #define STDU_R1_0R1 0xf8210001
6140 #define ADDI_R1_R1 0x38210000
6142 /* Emit prologue of wrapper preserving regs around a call to
6143 __tls_get_addr_opt. */
6146 tls_get_addr_prologue (bfd
*obfd
, bfd_byte
*p
, struct ppc_link_hash_table
*htab
)
6150 bfd_put_32 (obfd
, MFLR_R0
, p
);
6152 bfd_put_32 (obfd
, STD_R0_0R1
+ 16, p
);
6157 for (i
= 4; i
< 12; i
++)
6160 STD_R0_0R1
| i
<< 21 | (-(13 - i
) * 8 & 0xffff), p
);
6163 bfd_put_32 (obfd
, STDU_R1_0R1
| (-128 & 0xffff), p
);
6168 for (i
= 4; i
< 12; i
++)
6171 STD_R0_0R1
| i
<< 21 | (-(12 - i
) * 8 & 0xffff), p
);
6174 bfd_put_32 (obfd
, STDU_R1_0R1
| (-96 & 0xffff), p
);
6180 /* Emit epilogue of wrapper preserving regs around a call to
6181 __tls_get_addr_opt. */
6184 tls_get_addr_epilogue (bfd
*obfd
, bfd_byte
*p
, struct ppc_link_hash_table
*htab
)
6190 for (i
= 4; i
< 12; i
++)
6192 bfd_put_32 (obfd
, LD_R0_0R1
| i
<< 21 | (128 - (13 - i
) * 8), p
);
6195 bfd_put_32 (obfd
, ADDI_R1_R1
| 128, p
);
6200 for (i
= 4; i
< 12; i
++)
6202 bfd_put_32 (obfd
, LD_R0_0R1
| i
<< 21 | (96 - (12 - i
) * 8), p
);
6205 bfd_put_32 (obfd
, ADDI_R1_R1
| 96, p
);
6208 bfd_put_32 (obfd
, LD_R0_0R1
| 16, p
);
6210 bfd_put_32 (obfd
, MTLR_R0
, p
);
6212 bfd_put_32 (obfd
, BLR
, p
);
6217 /* Called via elf_link_hash_traverse to transfer dynamic linking
6218 information on function code symbol entries to their corresponding
6219 function descriptor symbol entries. */
6222 func_desc_adjust (struct elf_link_hash_entry
*h
, void *inf
)
6224 struct bfd_link_info
*info
;
6225 struct ppc_link_hash_table
*htab
;
6226 struct ppc_link_hash_entry
*fh
;
6227 struct ppc_link_hash_entry
*fdh
;
6228 bfd_boolean force_local
;
6230 fh
= ppc_elf_hash_entry (h
);
6231 if (fh
->elf
.root
.type
== bfd_link_hash_indirect
)
6237 if (fh
->elf
.root
.root
.string
[0] != '.'
6238 || fh
->elf
.root
.root
.string
[1] == '\0')
6242 htab
= ppc_hash_table (info
);
6246 /* Find the corresponding function descriptor symbol. */
6247 fdh
= lookup_fdh (fh
, htab
);
6249 /* Resolve undefined references to dot-symbols as the value
6250 in the function descriptor, if we have one in a regular object.
6251 This is to satisfy cases like ".quad .foo". Calls to functions
6252 in dynamic objects are handled elsewhere. */
6253 if ((fh
->elf
.root
.type
== bfd_link_hash_undefined
6254 || fh
->elf
.root
.type
== bfd_link_hash_undefweak
)
6255 && (fdh
->elf
.root
.type
== bfd_link_hash_defined
6256 || fdh
->elf
.root
.type
== bfd_link_hash_defweak
)
6257 && get_opd_info (fdh
->elf
.root
.u
.def
.section
) != NULL
6258 && opd_entry_value (fdh
->elf
.root
.u
.def
.section
,
6259 fdh
->elf
.root
.u
.def
.value
,
6260 &fh
->elf
.root
.u
.def
.section
,
6261 &fh
->elf
.root
.u
.def
.value
, FALSE
) != (bfd_vma
) -1)
6263 fh
->elf
.root
.type
= fdh
->elf
.root
.type
;
6264 fh
->elf
.forced_local
= 1;
6265 fh
->elf
.def_regular
= fdh
->elf
.def_regular
;
6266 fh
->elf
.def_dynamic
= fdh
->elf
.def_dynamic
;
6269 if (!fh
->elf
.dynamic
)
6271 struct plt_entry
*ent
;
6273 for (ent
= fh
->elf
.plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
6274 if (ent
->plt
.refcount
> 0)
6280 /* Create a descriptor as undefined if necessary. */
6282 && !bfd_link_executable (info
)
6283 && (fh
->elf
.root
.type
== bfd_link_hash_undefined
6284 || fh
->elf
.root
.type
== bfd_link_hash_undefweak
))
6286 fdh
= make_fdh (info
, fh
);
6291 /* We can't support overriding of symbols on a fake descriptor. */
6294 && (fh
->elf
.root
.type
== bfd_link_hash_defined
6295 || fh
->elf
.root
.type
== bfd_link_hash_defweak
))
6296 _bfd_elf_link_hash_hide_symbol (info
, &fdh
->elf
, TRUE
);
6298 /* Transfer dynamic linking information to the function descriptor. */
6301 fdh
->elf
.ref_regular
|= fh
->elf
.ref_regular
;
6302 fdh
->elf
.ref_dynamic
|= fh
->elf
.ref_dynamic
;
6303 fdh
->elf
.ref_regular_nonweak
|= fh
->elf
.ref_regular_nonweak
;
6304 fdh
->elf
.non_got_ref
|= fh
->elf
.non_got_ref
;
6305 fdh
->elf
.dynamic
|= fh
->elf
.dynamic
;
6306 fdh
->elf
.needs_plt
|= (fh
->elf
.needs_plt
6307 || fh
->elf
.type
== STT_FUNC
6308 || fh
->elf
.type
== STT_GNU_IFUNC
);
6309 move_plt_plist (fh
, fdh
);
6311 if (!fdh
->elf
.forced_local
6312 && fh
->elf
.dynindx
!= -1)
6313 if (!bfd_elf_link_record_dynamic_symbol (info
, &fdh
->elf
))
6317 /* Now that the info is on the function descriptor, clear the
6318 function code sym info. Any function code syms for which we
6319 don't have a definition in a regular file, we force local.
6320 This prevents a shared library from exporting syms that have
6321 been imported from another library. Function code syms that
6322 are really in the library we must leave global to prevent the
6323 linker dragging in a definition from a static library. */
6324 force_local
= (!fh
->elf
.def_regular
6326 || !fdh
->elf
.def_regular
6327 || fdh
->elf
.forced_local
);
6328 _bfd_elf_link_hash_hide_symbol (info
, &fh
->elf
, force_local
);
6333 static const struct sfpr_def_parms save_res_funcs
[] =
6335 { "_savegpr0_", 14, 31, savegpr0
, savegpr0_tail
},
6336 { "_restgpr0_", 14, 29, restgpr0
, restgpr0_tail
},
6337 { "_restgpr0_", 30, 31, restgpr0
, restgpr0_tail
},
6338 { "_savegpr1_", 14, 31, savegpr1
, savegpr1_tail
},
6339 { "_restgpr1_", 14, 31, restgpr1
, restgpr1_tail
},
6340 { "_savefpr_", 14, 31, savefpr
, savefpr0_tail
},
6341 { "_restfpr_", 14, 29, restfpr
, restfpr0_tail
},
6342 { "_restfpr_", 30, 31, restfpr
, restfpr0_tail
},
6343 { "._savef", 14, 31, savefpr
, savefpr1_tail
},
6344 { "._restf", 14, 31, restfpr
, restfpr1_tail
},
6345 { "_savevr_", 20, 31, savevr
, savevr_tail
},
6346 { "_restvr_", 20, 31, restvr
, restvr_tail
}
6349 /* Called near the start of bfd_elf_size_dynamic_sections. We use
6350 this hook to a) run the edit functions in this file, b) provide
6351 some gcc support functions, and c) transfer dynamic linking
6352 information gathered so far on function code symbol entries, to
6353 their corresponding function descriptor symbol entries. */
6356 ppc64_elf_edit (bfd
*obfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
6358 struct ppc_link_hash_table
*htab
;
6360 htab
= ppc_hash_table (info
);
6364 /* Call back into the linker, which then runs the edit functions. */
6365 htab
->params
->edit ();
6367 /* Provide any missing _save* and _rest* functions. */
6368 if (htab
->sfpr
!= NULL
)
6372 htab
->sfpr
->size
= 0;
6373 for (i
= 0; i
< ARRAY_SIZE (save_res_funcs
); i
++)
6374 if (!sfpr_define (info
, &save_res_funcs
[i
], NULL
))
6376 if (htab
->sfpr
->size
== 0)
6377 htab
->sfpr
->flags
|= SEC_EXCLUDE
;
6380 if (bfd_link_relocatable (info
))
6383 if (htab
->elf
.hgot
!= NULL
)
6385 _bfd_elf_link_hash_hide_symbol (info
, htab
->elf
.hgot
, TRUE
);
6386 /* Make .TOC. defined so as to prevent it being made dynamic.
6387 The wrong value here is fixed later in ppc64_elf_set_toc. */
6388 if (!htab
->elf
.hgot
->def_regular
6389 || htab
->elf
.hgot
->root
.type
!= bfd_link_hash_defined
)
6391 htab
->elf
.hgot
->root
.type
= bfd_link_hash_defined
;
6392 htab
->elf
.hgot
->root
.u
.def
.value
= 0;
6393 htab
->elf
.hgot
->root
.u
.def
.section
= bfd_abs_section_ptr
;
6394 htab
->elf
.hgot
->def_regular
= 1;
6395 htab
->elf
.hgot
->root
.linker_def
= 1;
6397 htab
->elf
.hgot
->type
= STT_OBJECT
;
6398 htab
->elf
.hgot
->other
6399 = (htab
->elf
.hgot
->other
& ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN
;
6402 if (htab
->need_func_desc_adj
)
6404 elf_link_hash_traverse (&htab
->elf
, func_desc_adjust
, info
);
6405 htab
->need_func_desc_adj
= 0;
6411 /* Return true if we have dynamic relocs against H or any of its weak
6412 aliases, that apply to read-only sections. Cannot be used after
6413 size_dynamic_sections. */
6416 alias_readonly_dynrelocs (struct elf_link_hash_entry
*h
)
6418 struct ppc_link_hash_entry
*eh
= ppc_elf_hash_entry (h
);
6421 if (_bfd_elf_readonly_dynrelocs (&eh
->elf
))
6423 eh
= ppc_elf_hash_entry (eh
->elf
.u
.alias
);
6425 while (eh
!= NULL
&& &eh
->elf
!= h
);
6430 /* Return whether EH has pc-relative dynamic relocs. */
6433 pc_dynrelocs (struct ppc_link_hash_entry
*eh
)
6435 struct elf_dyn_relocs
*p
;
6437 for (p
= eh
->elf
.dyn_relocs
; p
!= NULL
; p
= p
->next
)
6438 if (p
->pc_count
!= 0)
6443 /* Return true if a global entry stub will be created for H. Valid
6444 for ELFv2 before plt entries have been allocated. */
6447 global_entry_stub (struct elf_link_hash_entry
*h
)
6449 struct plt_entry
*pent
;
6451 if (!h
->pointer_equality_needed
6455 for (pent
= h
->plt
.plist
; pent
!= NULL
; pent
= pent
->next
)
6456 if (pent
->plt
.refcount
> 0
6457 && pent
->addend
== 0)
6463 /* Adjust a symbol defined by a dynamic object and referenced by a
6464 regular object. The current definition is in some section of the
6465 dynamic object, but we're not including those sections. We have to
6466 change the definition to something the rest of the link can
6470 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
6471 struct elf_link_hash_entry
*h
)
6473 struct ppc_link_hash_table
*htab
;
6476 htab
= ppc_hash_table (info
);
6480 /* Deal with function syms. */
6481 if (h
->type
== STT_FUNC
6482 || h
->type
== STT_GNU_IFUNC
6485 bfd_boolean local
= (ppc_elf_hash_entry (h
)->save_res
6486 || SYMBOL_CALLS_LOCAL (info
, h
)
6487 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
));
6488 /* Discard dyn_relocs when non-pic if we've decided that a
6489 function symbol is local and not an ifunc. We keep dynamic
6490 relocs for ifuncs when local rather than always emitting a
6491 plt call stub for them and defining the symbol on the call
6492 stub. We can't do that for ELFv1 anyway (a function symbol
6493 is defined on a descriptor, not code) and it can be faster at
6494 run-time due to not needing to bounce through a stub. The
6495 dyn_relocs for ifuncs will be applied even in a static
6497 if (!bfd_link_pic (info
)
6498 && h
->type
!= STT_GNU_IFUNC
6500 h
->dyn_relocs
= NULL
;
6502 /* Clear procedure linkage table information for any symbol that
6503 won't need a .plt entry. */
6504 struct plt_entry
*ent
;
6505 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
6506 if (ent
->plt
.refcount
> 0)
6509 || (h
->type
!= STT_GNU_IFUNC
6511 && (htab
->can_convert_all_inline_plt
6512 || (ppc_elf_hash_entry (h
)->tls_mask
6513 & (TLS_TLS
| PLT_KEEP
)) != PLT_KEEP
)))
6515 h
->plt
.plist
= NULL
;
6517 h
->pointer_equality_needed
= 0;
6519 else if (abiversion (info
->output_bfd
) >= 2)
6521 /* Taking a function's address in a read/write section
6522 doesn't require us to define the function symbol in the
6523 executable on a global entry stub. A dynamic reloc can
6524 be used instead. The reason we prefer a few more dynamic
6525 relocs is that calling via a global entry stub costs a
6526 few more instructions, and pointer_equality_needed causes
6527 extra work in ld.so when resolving these symbols. */
6528 if (global_entry_stub (h
))
6530 if (!_bfd_elf_readonly_dynrelocs (h
))
6532 h
->pointer_equality_needed
= 0;
6533 /* If we haven't seen a branch reloc and the symbol
6534 isn't an ifunc then we don't need a plt entry. */
6536 h
->plt
.plist
= NULL
;
6538 else if (!bfd_link_pic (info
))
6539 /* We are going to be defining the function symbol on the
6540 plt stub, so no dyn_relocs needed when non-pic. */
6541 h
->dyn_relocs
= NULL
;
6544 /* ELFv2 function symbols can't have copy relocs. */
6547 else if (!h
->needs_plt
6548 && !_bfd_elf_readonly_dynrelocs (h
))
6550 /* If we haven't seen a branch reloc and the symbol isn't an
6551 ifunc then we don't need a plt entry. */
6552 h
->plt
.plist
= NULL
;
6553 h
->pointer_equality_needed
= 0;
6558 h
->plt
.plist
= NULL
;
6560 /* If this is a weak symbol, and there is a real definition, the
6561 processor independent code will have arranged for us to see the
6562 real definition first, and we can just use the same value. */
6563 if (h
->is_weakalias
)
6565 struct elf_link_hash_entry
*def
= weakdef (h
);
6566 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
6567 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
6568 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
6569 if (def
->root
.u
.def
.section
== htab
->elf
.sdynbss
6570 || def
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
6571 h
->dyn_relocs
= NULL
;
6575 /* If we are creating a shared library, we must presume that the
6576 only references to the symbol are via the global offset table.
6577 For such cases we need not do anything here; the relocations will
6578 be handled correctly by relocate_section. */
6579 if (!bfd_link_executable (info
))
6582 /* If there are no references to this symbol that do not use the
6583 GOT, we don't need to generate a copy reloc. */
6584 if (!h
->non_got_ref
)
6587 /* Don't generate a copy reloc for symbols defined in the executable. */
6588 if (!h
->def_dynamic
|| !h
->ref_regular
|| h
->def_regular
6590 /* If -z nocopyreloc was given, don't generate them either. */
6591 || info
->nocopyreloc
6593 /* If we don't find any dynamic relocs in read-only sections, then
6594 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
6595 || (ELIMINATE_COPY_RELOCS
6597 && !alias_readonly_dynrelocs (h
))
6599 /* Protected variables do not work with .dynbss. The copy in
6600 .dynbss won't be used by the shared library with the protected
6601 definition for the variable. Text relocations are preferable
6602 to an incorrect program. */
6603 || h
->protected_def
)
6606 if (h
->type
== STT_FUNC
6607 || h
->type
== STT_GNU_IFUNC
)
6609 /* .dynbss copies of function symbols only work if we have
6610 ELFv1 dot-symbols. ELFv1 compilers since 2004 default to not
6611 use dot-symbols and set the function symbol size to the text
6612 size of the function rather than the size of the descriptor.
6613 That's wrong for copying a descriptor. */
6614 if (ppc_elf_hash_entry (h
)->oh
== NULL
6615 || !(h
->size
== 24 || h
->size
== 16))
6618 /* We should never get here, but unfortunately there are old
6619 versions of gcc (circa gcc-3.2) that improperly for the
6620 ELFv1 ABI put initialized function pointers, vtable refs and
6621 suchlike in read-only sections. Allow them to proceed, but
6622 warn that this might break at runtime. */
6623 info
->callbacks
->einfo
6624 (_("%P: copy reloc against `%pT' requires lazy plt linking; "
6625 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
6626 h
->root
.root
.string
);
6629 /* This is a reference to a symbol defined by a dynamic object which
6630 is not a function. */
6632 /* We must allocate the symbol in our .dynbss section, which will
6633 become part of the .bss section of the executable. There will be
6634 an entry for this symbol in the .dynsym section. The dynamic
6635 object will contain position independent code, so all references
6636 from the dynamic object to this symbol will go through the global
6637 offset table. The dynamic linker will use the .dynsym entry to
6638 determine the address it must put in the global offset table, so
6639 both the dynamic object and the regular object will refer to the
6640 same memory location for the variable. */
6641 if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
6643 s
= htab
->elf
.sdynrelro
;
6644 srel
= htab
->elf
.sreldynrelro
;
6648 s
= htab
->elf
.sdynbss
;
6649 srel
= htab
->elf
.srelbss
;
6651 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
6653 /* We must generate a R_PPC64_COPY reloc to tell the dynamic
6654 linker to copy the initial value out of the dynamic object
6655 and into the runtime process image. */
6656 srel
->size
+= sizeof (Elf64_External_Rela
);
6660 /* We no longer want dyn_relocs. */
6661 h
->dyn_relocs
= NULL
;
6662 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
6665 /* If given a function descriptor symbol, hide both the function code
6666 sym and the descriptor. */
6668 ppc64_elf_hide_symbol (struct bfd_link_info
*info
,
6669 struct elf_link_hash_entry
*h
,
6670 bfd_boolean force_local
)
6672 struct ppc_link_hash_entry
*eh
;
6673 _bfd_elf_link_hash_hide_symbol (info
, h
, force_local
);
6675 if (ppc_hash_table (info
) == NULL
)
6678 eh
= ppc_elf_hash_entry (h
);
6679 if (eh
->is_func_descriptor
)
6681 struct ppc_link_hash_entry
*fh
= eh
->oh
;
6686 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
6689 /* We aren't supposed to use alloca in BFD because on
6690 systems which do not have alloca the version in libiberty
6691 calls xmalloc, which might cause the program to crash
6692 when it runs out of memory. This function doesn't have a
6693 return status, so there's no way to gracefully return an
6694 error. So cheat. We know that string[-1] can be safely
6695 accessed; It's either a string in an ELF string table,
6696 or allocated in an objalloc structure. */
6698 p
= eh
->elf
.root
.root
.string
- 1;
6701 fh
= ppc_elf_hash_entry (elf_link_hash_lookup (htab
, p
, FALSE
,
6705 /* Unfortunately, if it so happens that the string we were
6706 looking for was allocated immediately before this string,
6707 then we overwrote the string terminator. That's the only
6708 reason the lookup should fail. */
6711 q
= eh
->elf
.root
.root
.string
+ strlen (eh
->elf
.root
.root
.string
);
6712 while (q
>= eh
->elf
.root
.root
.string
&& *q
== *p
)
6714 if (q
< eh
->elf
.root
.root
.string
&& *p
== '.')
6715 fh
= ppc_elf_hash_entry (elf_link_hash_lookup (htab
, p
, FALSE
,
6725 _bfd_elf_link_hash_hide_symbol (info
, &fh
->elf
, force_local
);
6730 get_sym_h (struct elf_link_hash_entry
**hp
,
6731 Elf_Internal_Sym
**symp
,
6733 unsigned char **tls_maskp
,
6734 Elf_Internal_Sym
**locsymsp
,
6735 unsigned long r_symndx
,
6738 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (ibfd
);
6740 if (r_symndx
>= symtab_hdr
->sh_info
)
6742 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (ibfd
);
6743 struct elf_link_hash_entry
*h
;
6745 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
6746 h
= elf_follow_link (h
);
6754 if (symsecp
!= NULL
)
6756 asection
*symsec
= NULL
;
6757 if (h
->root
.type
== bfd_link_hash_defined
6758 || h
->root
.type
== bfd_link_hash_defweak
)
6759 symsec
= h
->root
.u
.def
.section
;
6763 if (tls_maskp
!= NULL
)
6764 *tls_maskp
= &ppc_elf_hash_entry (h
)->tls_mask
;
6768 Elf_Internal_Sym
*sym
;
6769 Elf_Internal_Sym
*locsyms
= *locsymsp
;
6771 if (locsyms
== NULL
)
6773 locsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
6774 if (locsyms
== NULL
)
6775 locsyms
= bfd_elf_get_elf_syms (ibfd
, symtab_hdr
,
6776 symtab_hdr
->sh_info
,
6777 0, NULL
, NULL
, NULL
);
6778 if (locsyms
== NULL
)
6780 *locsymsp
= locsyms
;
6782 sym
= locsyms
+ r_symndx
;
6790 if (symsecp
!= NULL
)
6791 *symsecp
= bfd_section_from_elf_index (ibfd
, sym
->st_shndx
);
6793 if (tls_maskp
!= NULL
)
6795 struct got_entry
**lgot_ents
;
6796 unsigned char *tls_mask
;
6799 lgot_ents
= elf_local_got_ents (ibfd
);
6800 if (lgot_ents
!= NULL
)
6802 struct plt_entry
**local_plt
= (struct plt_entry
**)
6803 (lgot_ents
+ symtab_hdr
->sh_info
);
6804 unsigned char *lgot_masks
= (unsigned char *)
6805 (local_plt
+ symtab_hdr
->sh_info
);
6806 tls_mask
= &lgot_masks
[r_symndx
];
6808 *tls_maskp
= tls_mask
;
6814 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
6815 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
6816 type suitable for optimization, and 1 otherwise. */
6819 get_tls_mask (unsigned char **tls_maskp
,
6820 unsigned long *toc_symndx
,
6821 bfd_vma
*toc_addend
,
6822 Elf_Internal_Sym
**locsymsp
,
6823 const Elf_Internal_Rela
*rel
,
6826 unsigned long r_symndx
;
6828 struct elf_link_hash_entry
*h
;
6829 Elf_Internal_Sym
*sym
;
6833 r_symndx
= ELF64_R_SYM (rel
->r_info
);
6834 if (!get_sym_h (&h
, &sym
, &sec
, tls_maskp
, locsymsp
, r_symndx
, ibfd
))
6837 if ((*tls_maskp
!= NULL
6838 && (**tls_maskp
& TLS_TLS
) != 0
6839 && **tls_maskp
!= (TLS_TLS
| TLS_MARK
))
6841 || ppc64_elf_section_data (sec
) == NULL
6842 || ppc64_elf_section_data (sec
)->sec_type
!= sec_toc
)
6845 /* Look inside a TOC section too. */
6848 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
);
6849 off
= h
->root
.u
.def
.value
;
6852 off
= sym
->st_value
;
6853 off
+= rel
->r_addend
;
6854 BFD_ASSERT (off
% 8 == 0);
6855 r_symndx
= ppc64_elf_section_data (sec
)->u
.toc
.symndx
[off
/ 8];
6856 next_r
= ppc64_elf_section_data (sec
)->u
.toc
.symndx
[off
/ 8 + 1];
6857 if (toc_symndx
!= NULL
)
6858 *toc_symndx
= r_symndx
;
6859 if (toc_addend
!= NULL
)
6860 *toc_addend
= ppc64_elf_section_data (sec
)->u
.toc
.add
[off
/ 8];
6861 if (!get_sym_h (&h
, &sym
, &sec
, tls_maskp
, locsymsp
, r_symndx
, ibfd
))
6863 if ((h
== NULL
|| is_static_defined (h
))
6864 && (next_r
== -1 || next_r
== -2))
6869 /* Find (or create) an entry in the tocsave hash table. */
6871 static struct tocsave_entry
*
6872 tocsave_find (struct ppc_link_hash_table
*htab
,
6873 enum insert_option insert
,
6874 Elf_Internal_Sym
**local_syms
,
6875 const Elf_Internal_Rela
*irela
,
6878 unsigned long r_indx
;
6879 struct elf_link_hash_entry
*h
;
6880 Elf_Internal_Sym
*sym
;
6881 struct tocsave_entry ent
, *p
;
6883 struct tocsave_entry
**slot
;
6885 r_indx
= ELF64_R_SYM (irela
->r_info
);
6886 if (!get_sym_h (&h
, &sym
, &ent
.sec
, NULL
, local_syms
, r_indx
, ibfd
))
6888 if (ent
.sec
== NULL
|| ent
.sec
->output_section
== NULL
)
6891 (_("%pB: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd
);
6896 ent
.offset
= h
->root
.u
.def
.value
;
6898 ent
.offset
= sym
->st_value
;
6899 ent
.offset
+= irela
->r_addend
;
6901 hash
= tocsave_htab_hash (&ent
);
6902 slot
= ((struct tocsave_entry
**)
6903 htab_find_slot_with_hash (htab
->tocsave_htab
, &ent
, hash
, insert
));
6909 p
= (struct tocsave_entry
*) bfd_alloc (ibfd
, sizeof (*p
));
6918 /* Adjust all global syms defined in opd sections. In gcc generated
6919 code for the old ABI, these will already have been done. */
6922 adjust_opd_syms (struct elf_link_hash_entry
*h
, void *inf ATTRIBUTE_UNUSED
)
6924 struct ppc_link_hash_entry
*eh
;
6926 struct _opd_sec_data
*opd
;
6928 if (h
->root
.type
== bfd_link_hash_indirect
)
6931 if (h
->root
.type
!= bfd_link_hash_defined
6932 && h
->root
.type
!= bfd_link_hash_defweak
)
6935 eh
= ppc_elf_hash_entry (h
);
6936 if (eh
->adjust_done
)
6939 sym_sec
= eh
->elf
.root
.u
.def
.section
;
6940 opd
= get_opd_info (sym_sec
);
6941 if (opd
!= NULL
&& opd
->adjust
!= NULL
)
6943 long adjust
= opd
->adjust
[OPD_NDX (eh
->elf
.root
.u
.def
.value
)];
6946 /* This entry has been deleted. */
6947 asection
*dsec
= ppc64_elf_tdata (sym_sec
->owner
)->deleted_section
;
6950 for (dsec
= sym_sec
->owner
->sections
; dsec
; dsec
= dsec
->next
)
6951 if (discarded_section (dsec
))
6953 ppc64_elf_tdata (sym_sec
->owner
)->deleted_section
= dsec
;
6957 eh
->elf
.root
.u
.def
.value
= 0;
6958 eh
->elf
.root
.u
.def
.section
= dsec
;
6961 eh
->elf
.root
.u
.def
.value
+= adjust
;
6962 eh
->adjust_done
= 1;
6967 /* Handles decrementing dynamic reloc counts for the reloc specified by
6968 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
6969 have already been determined. */
6972 dec_dynrel_count (bfd_vma r_info
,
6974 struct bfd_link_info
*info
,
6975 Elf_Internal_Sym
**local_syms
,
6976 struct elf_link_hash_entry
*h
,
6977 Elf_Internal_Sym
*sym
)
6979 enum elf_ppc64_reloc_type r_type
;
6980 asection
*sym_sec
= NULL
;
6982 /* Can this reloc be dynamic? This switch, and later tests here
6983 should be kept in sync with the code in check_relocs. */
6984 r_type
= ELF64_R_TYPE (r_info
);
6991 case R_PPC64_TOC16_DS
:
6992 case R_PPC64_TOC16_LO
:
6993 case R_PPC64_TOC16_HI
:
6994 case R_PPC64_TOC16_HA
:
6995 case R_PPC64_TOC16_LO_DS
:
7000 case R_PPC64_TPREL16
:
7001 case R_PPC64_TPREL16_LO
:
7002 case R_PPC64_TPREL16_HI
:
7003 case R_PPC64_TPREL16_HA
:
7004 case R_PPC64_TPREL16_DS
:
7005 case R_PPC64_TPREL16_LO_DS
:
7006 case R_PPC64_TPREL16_HIGH
:
7007 case R_PPC64_TPREL16_HIGHA
:
7008 case R_PPC64_TPREL16_HIGHER
:
7009 case R_PPC64_TPREL16_HIGHERA
:
7010 case R_PPC64_TPREL16_HIGHEST
:
7011 case R_PPC64_TPREL16_HIGHESTA
:
7012 case R_PPC64_TPREL64
:
7013 case R_PPC64_TPREL34
:
7014 case R_PPC64_DTPMOD64
:
7015 case R_PPC64_DTPREL64
:
7016 case R_PPC64_ADDR64
:
7020 case R_PPC64_ADDR14
:
7021 case R_PPC64_ADDR14_BRNTAKEN
:
7022 case R_PPC64_ADDR14_BRTAKEN
:
7023 case R_PPC64_ADDR16
:
7024 case R_PPC64_ADDR16_DS
:
7025 case R_PPC64_ADDR16_HA
:
7026 case R_PPC64_ADDR16_HI
:
7027 case R_PPC64_ADDR16_HIGH
:
7028 case R_PPC64_ADDR16_HIGHA
:
7029 case R_PPC64_ADDR16_HIGHER
:
7030 case R_PPC64_ADDR16_HIGHERA
:
7031 case R_PPC64_ADDR16_HIGHEST
:
7032 case R_PPC64_ADDR16_HIGHESTA
:
7033 case R_PPC64_ADDR16_LO
:
7034 case R_PPC64_ADDR16_LO_DS
:
7035 case R_PPC64_ADDR24
:
7036 case R_PPC64_ADDR32
:
7037 case R_PPC64_UADDR16
:
7038 case R_PPC64_UADDR32
:
7039 case R_PPC64_UADDR64
:
7042 case R_PPC64_D34_LO
:
7043 case R_PPC64_D34_HI30
:
7044 case R_PPC64_D34_HA30
:
7045 case R_PPC64_ADDR16_HIGHER34
:
7046 case R_PPC64_ADDR16_HIGHERA34
:
7047 case R_PPC64_ADDR16_HIGHEST34
:
7048 case R_PPC64_ADDR16_HIGHESTA34
:
7053 if (local_syms
!= NULL
)
7055 unsigned long r_symndx
;
7056 bfd
*ibfd
= sec
->owner
;
7058 r_symndx
= ELF64_R_SYM (r_info
);
7059 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, local_syms
, r_symndx
, ibfd
))
7064 && (h
->root
.type
== bfd_link_hash_defweak
7065 || !h
->def_regular
))
7067 && !bfd_link_executable (info
)
7068 && !SYMBOLIC_BIND (info
, h
))
7069 || (bfd_link_pic (info
)
7070 && must_be_dyn_reloc (info
, r_type
))
7071 || (!bfd_link_pic (info
)
7073 ? h
->type
== STT_GNU_IFUNC
7074 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)))
7081 struct elf_dyn_relocs
*p
;
7082 struct elf_dyn_relocs
**pp
;
7083 pp
= &h
->dyn_relocs
;
7085 /* elf_gc_sweep may have already removed all dyn relocs associated
7086 with local syms for a given section. Also, symbol flags are
7087 changed by elf_gc_sweep_symbol, confusing the test above. Don't
7088 report a dynreloc miscount. */
7089 if (*pp
== NULL
&& info
->gc_sections
)
7092 while ((p
= *pp
) != NULL
)
7096 if (!must_be_dyn_reloc (info
, r_type
))
7108 struct ppc_dyn_relocs
*p
;
7109 struct ppc_dyn_relocs
**pp
;
7111 bfd_boolean is_ifunc
;
7113 if (local_syms
== NULL
)
7114 sym_sec
= bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
7115 if (sym_sec
== NULL
)
7118 vpp
= &elf_section_data (sym_sec
)->local_dynrel
;
7119 pp
= (struct ppc_dyn_relocs
**) vpp
;
7121 if (*pp
== NULL
&& info
->gc_sections
)
7124 is_ifunc
= ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
;
7125 while ((p
= *pp
) != NULL
)
7127 if (p
->sec
== sec
&& p
->ifunc
== is_ifunc
)
7138 /* xgettext:c-format */
7139 _bfd_error_handler (_("dynreloc miscount for %pB, section %pA"),
7141 bfd_set_error (bfd_error_bad_value
);
7145 /* Remove unused Official Procedure Descriptor entries. Currently we
7146 only remove those associated with functions in discarded link-once
7147 sections, or weakly defined functions that have been overridden. It
7148 would be possible to remove many more entries for statically linked
7152 ppc64_elf_edit_opd (struct bfd_link_info
*info
)
7155 bfd_boolean some_edited
= FALSE
;
7156 asection
*need_pad
= NULL
;
7157 struct ppc_link_hash_table
*htab
;
7159 htab
= ppc_hash_table (info
);
7163 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
7166 Elf_Internal_Rela
*relstart
, *rel
, *relend
;
7167 Elf_Internal_Shdr
*symtab_hdr
;
7168 Elf_Internal_Sym
*local_syms
;
7169 struct _opd_sec_data
*opd
;
7170 bfd_boolean need_edit
, add_aux_fields
, broken
;
7171 bfd_size_type cnt_16b
= 0;
7173 if (!is_ppc64_elf (ibfd
))
7176 sec
= bfd_get_section_by_name (ibfd
, ".opd");
7177 if (sec
== NULL
|| sec
->size
== 0)
7180 if (sec
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
7183 if (sec
->output_section
== bfd_abs_section_ptr
)
7186 /* Look through the section relocs. */
7187 if ((sec
->flags
& SEC_RELOC
) == 0 || sec
->reloc_count
== 0)
7191 symtab_hdr
= &elf_symtab_hdr (ibfd
);
7193 /* Read the relocations. */
7194 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
7196 if (relstart
== NULL
)
7199 /* First run through the relocs to check they are sane, and to
7200 determine whether we need to edit this opd section. */
7204 relend
= relstart
+ sec
->reloc_count
;
7205 for (rel
= relstart
; rel
< relend
; )
7207 enum elf_ppc64_reloc_type r_type
;
7208 unsigned long r_symndx
;
7210 struct elf_link_hash_entry
*h
;
7211 Elf_Internal_Sym
*sym
;
7214 /* .opd contains an array of 16 or 24 byte entries. We're
7215 only interested in the reloc pointing to a function entry
7217 offset
= rel
->r_offset
;
7218 if (rel
+ 1 == relend
7219 || rel
[1].r_offset
!= offset
+ 8)
7221 /* If someone messes with .opd alignment then after a
7222 "ld -r" we might have padding in the middle of .opd.
7223 Also, there's nothing to prevent someone putting
7224 something silly in .opd with the assembler. No .opd
7225 optimization for them! */
7228 (_("%pB: .opd is not a regular array of opd entries"), ibfd
);
7233 if ((r_type
= ELF64_R_TYPE (rel
->r_info
)) != R_PPC64_ADDR64
7234 || (r_type
= ELF64_R_TYPE ((rel
+ 1)->r_info
)) != R_PPC64_TOC
)
7237 /* xgettext:c-format */
7238 (_("%pB: unexpected reloc type %u in .opd section"),
7244 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7245 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
7249 if (sym_sec
== NULL
|| sym_sec
->owner
== NULL
)
7251 const char *sym_name
;
7253 sym_name
= h
->root
.root
.string
;
7255 sym_name
= bfd_elf_sym_name (ibfd
, symtab_hdr
, sym
,
7259 /* xgettext:c-format */
7260 (_("%pB: undefined sym `%s' in .opd section"),
7266 /* opd entries are always for functions defined in the
7267 current input bfd. If the symbol isn't defined in the
7268 input bfd, then we won't be using the function in this
7269 bfd; It must be defined in a linkonce section in another
7270 bfd, or is weak. It's also possible that we are
7271 discarding the function due to a linker script /DISCARD/,
7272 which we test for via the output_section. */
7273 if (sym_sec
->owner
!= ibfd
7274 || sym_sec
->output_section
== bfd_abs_section_ptr
)
7278 if (rel
+ 1 == relend
7279 || (rel
+ 2 < relend
7280 && ELF64_R_TYPE (rel
[2].r_info
) == R_PPC64_TOC
))
7285 if (sec
->size
== offset
+ 24)
7290 if (sec
->size
== offset
+ 16)
7297 else if (rel
+ 1 < relend
7298 && ELF64_R_TYPE (rel
[0].r_info
) == R_PPC64_ADDR64
7299 && ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_TOC
)
7301 if (rel
[0].r_offset
== offset
+ 16)
7303 else if (rel
[0].r_offset
!= offset
+ 24)
7310 add_aux_fields
= htab
->params
->non_overlapping_opd
&& cnt_16b
> 0;
7312 if (!broken
&& (need_edit
|| add_aux_fields
))
7314 Elf_Internal_Rela
*write_rel
;
7315 Elf_Internal_Shdr
*rel_hdr
;
7316 bfd_byte
*rptr
, *wptr
;
7317 bfd_byte
*new_contents
;
7320 new_contents
= NULL
;
7321 amt
= OPD_NDX (sec
->size
) * sizeof (long);
7322 opd
= &ppc64_elf_section_data (sec
)->u
.opd
;
7323 opd
->adjust
= bfd_zalloc (sec
->owner
, amt
);
7324 if (opd
->adjust
== NULL
)
7327 /* This seems a waste of time as input .opd sections are all
7328 zeros as generated by gcc, but I suppose there's no reason
7329 this will always be so. We might start putting something in
7330 the third word of .opd entries. */
7331 if ((sec
->flags
& SEC_IN_MEMORY
) == 0)
7334 if (!bfd_malloc_and_get_section (ibfd
, sec
, &loc
))
7338 if (symtab_hdr
->contents
!= (unsigned char *) local_syms
)
7340 if (elf_section_data (sec
)->relocs
!= relstart
)
7344 sec
->contents
= loc
;
7345 sec
->flags
|= (SEC_IN_MEMORY
| SEC_HAS_CONTENTS
);
7348 elf_section_data (sec
)->relocs
= relstart
;
7350 new_contents
= sec
->contents
;
7353 new_contents
= bfd_malloc (sec
->size
+ cnt_16b
* 8);
7354 if (new_contents
== NULL
)
7358 wptr
= new_contents
;
7359 rptr
= sec
->contents
;
7360 write_rel
= relstart
;
7361 for (rel
= relstart
; rel
< relend
; )
7363 unsigned long r_symndx
;
7365 struct elf_link_hash_entry
*h
;
7366 struct ppc_link_hash_entry
*fdh
= NULL
;
7367 Elf_Internal_Sym
*sym
;
7369 Elf_Internal_Rela
*next_rel
;
7372 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7373 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
7378 if (next_rel
+ 1 == relend
7379 || (next_rel
+ 2 < relend
7380 && ELF64_R_TYPE (next_rel
[2].r_info
) == R_PPC64_TOC
))
7383 /* See if the .opd entry is full 24 byte or
7384 16 byte (with fd_aux entry overlapped with next
7387 if (next_rel
== relend
)
7389 if (sec
->size
== rel
->r_offset
+ 16)
7392 else if (next_rel
->r_offset
== rel
->r_offset
+ 16)
7396 && h
->root
.root
.string
[0] == '.')
7398 fdh
= ppc_elf_hash_entry (h
)->oh
;
7401 fdh
= ppc_follow_link (fdh
);
7402 if (fdh
->elf
.root
.type
!= bfd_link_hash_defined
7403 && fdh
->elf
.root
.type
!= bfd_link_hash_defweak
)
7408 skip
= (sym_sec
->owner
!= ibfd
7409 || sym_sec
->output_section
== bfd_abs_section_ptr
);
7412 if (fdh
!= NULL
&& sym_sec
->owner
== ibfd
)
7414 /* Arrange for the function descriptor sym
7416 fdh
->elf
.root
.u
.def
.value
= 0;
7417 fdh
->elf
.root
.u
.def
.section
= sym_sec
;
7419 opd
->adjust
[OPD_NDX (rel
->r_offset
)] = -1;
7421 if (NO_OPD_RELOCS
|| bfd_link_relocatable (info
))
7426 if (!dec_dynrel_count (rel
->r_info
, sec
, info
,
7430 if (++rel
== next_rel
)
7433 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7434 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
7441 /* We'll be keeping this opd entry. */
7446 /* Redefine the function descriptor symbol to
7447 this location in the opd section. It is
7448 necessary to update the value here rather
7449 than using an array of adjustments as we do
7450 for local symbols, because various places
7451 in the generic ELF code use the value
7452 stored in u.def.value. */
7453 fdh
->elf
.root
.u
.def
.value
= wptr
- new_contents
;
7454 fdh
->adjust_done
= 1;
7457 /* Local syms are a bit tricky. We could
7458 tweak them as they can be cached, but
7459 we'd need to look through the local syms
7460 for the function descriptor sym which we
7461 don't have at the moment. So keep an
7462 array of adjustments. */
7463 adjust
= (wptr
- new_contents
) - (rptr
- sec
->contents
);
7464 opd
->adjust
[OPD_NDX (rel
->r_offset
)] = adjust
;
7467 memcpy (wptr
, rptr
, opd_ent_size
);
7468 wptr
+= opd_ent_size
;
7469 if (add_aux_fields
&& opd_ent_size
== 16)
7471 memset (wptr
, '\0', 8);
7475 /* We need to adjust any reloc offsets to point to the
7477 for ( ; rel
!= next_rel
; ++rel
)
7479 rel
->r_offset
+= adjust
;
7480 if (write_rel
!= rel
)
7481 memcpy (write_rel
, rel
, sizeof (*rel
));
7486 rptr
+= opd_ent_size
;
7489 sec
->size
= wptr
- new_contents
;
7490 sec
->reloc_count
= write_rel
- relstart
;
7493 free (sec
->contents
);
7494 sec
->contents
= new_contents
;
7497 /* Fudge the header size too, as this is used later in
7498 elf_bfd_final_link if we are emitting relocs. */
7499 rel_hdr
= _bfd_elf_single_rel_hdr (sec
);
7500 rel_hdr
->sh_size
= sec
->reloc_count
* rel_hdr
->sh_entsize
;
7503 else if (elf_section_data (sec
)->relocs
!= relstart
)
7506 if (local_syms
!= NULL
7507 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
7509 if (!info
->keep_memory
)
7512 symtab_hdr
->contents
= (unsigned char *) local_syms
;
7517 elf_link_hash_traverse (elf_hash_table (info
), adjust_opd_syms
, NULL
);
7519 /* If we are doing a final link and the last .opd entry is just 16 byte
7520 long, add a 8 byte padding after it. */
7521 if (need_pad
!= NULL
&& !bfd_link_relocatable (info
))
7525 if ((need_pad
->flags
& SEC_IN_MEMORY
) == 0)
7527 BFD_ASSERT (need_pad
->size
> 0);
7529 p
= bfd_malloc (need_pad
->size
+ 8);
7533 if (!bfd_get_section_contents (need_pad
->owner
, need_pad
,
7534 p
, 0, need_pad
->size
))
7537 need_pad
->contents
= p
;
7538 need_pad
->flags
|= (SEC_IN_MEMORY
| SEC_HAS_CONTENTS
);
7542 p
= bfd_realloc (need_pad
->contents
, need_pad
->size
+ 8);
7546 need_pad
->contents
= p
;
7549 memset (need_pad
->contents
+ need_pad
->size
, 0, 8);
7550 need_pad
->size
+= 8;
7556 /* Analyze inline PLT call relocations to see whether calls to locally
7557 defined functions can be converted to direct calls. */
7560 ppc64_elf_inline_plt (struct bfd_link_info
*info
)
7562 struct ppc_link_hash_table
*htab
;
7565 bfd_vma low_vma
, high_vma
, limit
;
7567 htab
= ppc_hash_table (info
);
7571 /* A bl insn can reach -0x2000000 to 0x1fffffc. The limit is
7572 reduced somewhat to cater for possible stubs that might be added
7573 between the call and its destination. */
7574 if (htab
->params
->group_size
< 0)
7576 limit
= -htab
->params
->group_size
;
7582 limit
= htab
->params
->group_size
;
7589 for (sec
= info
->output_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7590 if ((sec
->flags
& (SEC_ALLOC
| SEC_CODE
)) == (SEC_ALLOC
| SEC_CODE
))
7592 if (low_vma
> sec
->vma
)
7594 if (high_vma
< sec
->vma
+ sec
->size
)
7595 high_vma
= sec
->vma
+ sec
->size
;
7598 /* If a "bl" can reach anywhere in local code sections, then we can
7599 convert all inline PLT sequences to direct calls when the symbol
7601 if (high_vma
- low_vma
< limit
)
7603 htab
->can_convert_all_inline_plt
= 1;
7607 /* Otherwise, go looking through relocs for cases where a direct
7608 call won't reach. Mark the symbol on any such reloc to disable
7609 the optimization and keep the PLT entry as it seems likely that
7610 this will be better than creating trampolines. Note that this
7611 will disable the optimization for all inline PLT calls to a
7612 particular symbol, not just those that won't reach. The
7613 difficulty in doing a more precise optimization is that the
7614 linker needs to make a decision depending on whether a
7615 particular R_PPC64_PLTCALL insn can be turned into a direct
7616 call, for each of the R_PPC64_PLTSEQ and R_PPC64_PLT16* insns in
7617 the sequence, and there is nothing that ties those relocs
7618 together except their symbol. */
7620 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
7622 Elf_Internal_Shdr
*symtab_hdr
;
7623 Elf_Internal_Sym
*local_syms
;
7625 if (!is_ppc64_elf (ibfd
))
7629 symtab_hdr
= &elf_symtab_hdr (ibfd
);
7631 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7632 if (ppc64_elf_section_data (sec
)->has_pltcall
7633 && !bfd_is_abs_section (sec
->output_section
))
7635 Elf_Internal_Rela
*relstart
, *rel
, *relend
;
7637 /* Read the relocations. */
7638 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
7640 if (relstart
== NULL
)
7643 relend
= relstart
+ sec
->reloc_count
;
7644 for (rel
= relstart
; rel
< relend
; rel
++)
7646 enum elf_ppc64_reloc_type r_type
;
7647 unsigned long r_symndx
;
7649 struct elf_link_hash_entry
*h
;
7650 Elf_Internal_Sym
*sym
;
7651 unsigned char *tls_maskp
;
7653 r_type
= ELF64_R_TYPE (rel
->r_info
);
7654 if (r_type
!= R_PPC64_PLTCALL
7655 && r_type
!= R_PPC64_PLTCALL_NOTOC
)
7658 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7659 if (!get_sym_h (&h
, &sym
, &sym_sec
, &tls_maskp
, &local_syms
,
7662 if (elf_section_data (sec
)->relocs
!= relstart
)
7664 if (symtab_hdr
->contents
!= (bfd_byte
*) local_syms
)
7669 if (sym_sec
!= NULL
&& sym_sec
->output_section
!= NULL
)
7673 to
= h
->root
.u
.def
.value
;
7676 to
+= (rel
->r_addend
7677 + sym_sec
->output_offset
7678 + sym_sec
->output_section
->vma
);
7679 from
= (rel
->r_offset
7680 + sec
->output_offset
7681 + sec
->output_section
->vma
);
7682 if (to
- from
+ limit
< 2 * limit
7683 && !(r_type
== R_PPC64_PLTCALL_NOTOC
7684 && (((h
? h
->other
: sym
->st_other
)
7685 & STO_PPC64_LOCAL_MASK
)
7686 > 1 << STO_PPC64_LOCAL_BIT
)))
7687 *tls_maskp
&= ~PLT_KEEP
;
7690 if (elf_section_data (sec
)->relocs
!= relstart
)
7694 if (local_syms
!= NULL
7695 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
7697 if (!info
->keep_memory
)
7700 symtab_hdr
->contents
= (unsigned char *) local_syms
;
7707 /* Set htab->tls_get_addr and various other info specific to TLS.
7708 This needs to run before dynamic symbols are processed in
7709 bfd_elf_size_dynamic_sections. */
7712 ppc64_elf_tls_setup (struct bfd_link_info
*info
)
7714 struct ppc_link_hash_table
*htab
;
7715 struct elf_link_hash_entry
*tga
, *tga_fd
, *desc
, *desc_fd
;
7717 htab
= ppc_hash_table (info
);
7721 if (abiversion (info
->output_bfd
) == 1)
7724 if (htab
->params
->no_multi_toc
)
7725 htab
->do_multi_toc
= 0;
7726 else if (!htab
->do_multi_toc
)
7727 htab
->params
->no_multi_toc
= 1;
7729 /* Default to --no-plt-localentry, as this option can cause problems
7730 with symbol interposition. For example, glibc libpthread.so and
7731 libc.so duplicate many pthread symbols, with a fallback
7732 implementation in libc.so. In some cases the fallback does more
7733 work than the pthread implementation. __pthread_condattr_destroy
7734 is one such symbol: the libpthread.so implementation is
7735 localentry:0 while the libc.so implementation is localentry:8.
7736 An app that "cleverly" uses dlopen to only load necessary
7737 libraries at runtime may omit loading libpthread.so when not
7738 running multi-threaded, which then results in the libc.so
7739 fallback symbols being used and ld.so complaining. Now there
7740 are workarounds in ld (see non_zero_localentry) to detect the
7741 pthread situation, but that may not be the only case where
7742 --plt-localentry can cause trouble. */
7743 if (htab
->params
->plt_localentry0
< 0)
7744 htab
->params
->plt_localentry0
= 0;
7745 if (htab
->params
->plt_localentry0
&& htab
->has_power10_relocs
)
7747 /* The issue is that __glink_PLTresolve saves r2, which is done
7748 because glibc ld.so _dl_runtime_resolve restores r2 to support
7749 a glibc plt call optimisation where global entry code is
7750 skipped on calls that resolve to the same binary. The
7751 __glink_PLTresolve save of r2 is incompatible with code
7752 making tail calls, because the tail call might go via the
7753 resolver and thus overwrite the proper saved r2. */
7754 _bfd_error_handler (_("warning: --plt-localentry is incompatible with "
7755 "power10 pc-relative code"));
7756 htab
->params
->plt_localentry0
= 0;
7758 if (htab
->params
->plt_localentry0
7759 && elf_link_hash_lookup (&htab
->elf
, "GLIBC_2.26",
7760 FALSE
, FALSE
, FALSE
) == NULL
)
7762 (_("warning: --plt-localentry is especially dangerous without "
7763 "ld.so support to detect ABI violations"));
7765 tga
= elf_link_hash_lookup (&htab
->elf
, ".__tls_get_addr",
7766 FALSE
, FALSE
, TRUE
);
7767 htab
->tls_get_addr
= ppc_elf_hash_entry (tga
);
7769 /* Move dynamic linking info to the function descriptor sym. */
7771 func_desc_adjust (tga
, info
);
7772 tga_fd
= elf_link_hash_lookup (&htab
->elf
, "__tls_get_addr",
7773 FALSE
, FALSE
, TRUE
);
7774 htab
->tls_get_addr_fd
= ppc_elf_hash_entry (tga_fd
);
7776 desc
= elf_link_hash_lookup (&htab
->elf
, ".__tls_get_addr_desc",
7777 FALSE
, FALSE
, TRUE
);
7778 htab
->tga_desc
= ppc_elf_hash_entry (desc
);
7780 func_desc_adjust (desc
, info
);
7781 desc_fd
= elf_link_hash_lookup (&htab
->elf
, "__tls_get_addr_desc",
7782 FALSE
, FALSE
, TRUE
);
7783 htab
->tga_desc_fd
= ppc_elf_hash_entry (desc_fd
);
7785 if (htab
->params
->tls_get_addr_opt
)
7787 struct elf_link_hash_entry
*opt
, *opt_fd
;
7789 opt
= elf_link_hash_lookup (&htab
->elf
, ".__tls_get_addr_opt",
7790 FALSE
, FALSE
, TRUE
);
7792 func_desc_adjust (opt
, info
);
7793 opt_fd
= elf_link_hash_lookup (&htab
->elf
, "__tls_get_addr_opt",
7794 FALSE
, FALSE
, TRUE
);
7796 && (opt_fd
->root
.type
== bfd_link_hash_defined
7797 || opt_fd
->root
.type
== bfd_link_hash_defweak
))
7799 /* If glibc supports an optimized __tls_get_addr call stub,
7800 signalled by the presence of __tls_get_addr_opt, and we'll
7801 be calling __tls_get_addr via a plt call stub, then
7802 make __tls_get_addr point to __tls_get_addr_opt. */
7803 if (!(htab
->elf
.dynamic_sections_created
7805 && (tga_fd
->type
== STT_FUNC
7806 || tga_fd
->needs_plt
)
7807 && !(SYMBOL_CALLS_LOCAL (info
, tga_fd
)
7808 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, tga_fd
))))
7810 if (!(htab
->elf
.dynamic_sections_created
7812 && (desc_fd
->type
== STT_FUNC
7813 || desc_fd
->needs_plt
)
7814 && !(SYMBOL_CALLS_LOCAL (info
, desc_fd
)
7815 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, desc_fd
))))
7818 if (tga_fd
!= NULL
|| desc_fd
!= NULL
)
7820 struct plt_entry
*ent
= NULL
;
7823 for (ent
= tga_fd
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
7824 if (ent
->plt
.refcount
> 0)
7826 if (ent
== NULL
&& desc_fd
!= NULL
)
7827 for (ent
= desc_fd
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
7828 if (ent
->plt
.refcount
> 0)
7834 tga_fd
->root
.type
= bfd_link_hash_indirect
;
7835 tga_fd
->root
.u
.i
.link
= &opt_fd
->root
;
7836 tga_fd
->root
.u
.i
.warning
= NULL
;
7837 ppc64_elf_copy_indirect_symbol (info
, opt_fd
, tga_fd
);
7839 if (desc_fd
!= NULL
)
7841 desc_fd
->root
.type
= bfd_link_hash_indirect
;
7842 desc_fd
->root
.u
.i
.link
= &opt_fd
->root
;
7843 desc_fd
->root
.u
.i
.warning
= NULL
;
7844 ppc64_elf_copy_indirect_symbol (info
, opt_fd
, desc_fd
);
7847 if (opt_fd
->dynindx
!= -1)
7849 /* Use __tls_get_addr_opt in dynamic relocations. */
7850 opt_fd
->dynindx
= -1;
7851 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
7852 opt_fd
->dynstr_index
);
7853 if (!bfd_elf_link_record_dynamic_symbol (info
, opt_fd
))
7858 htab
->tls_get_addr_fd
= ppc_elf_hash_entry (opt_fd
);
7859 tga
= (struct elf_link_hash_entry
*) htab
->tls_get_addr
;
7860 if (opt
!= NULL
&& tga
!= NULL
)
7862 tga
->root
.type
= bfd_link_hash_indirect
;
7863 tga
->root
.u
.i
.link
= &opt
->root
;
7864 tga
->root
.u
.i
.warning
= NULL
;
7865 ppc64_elf_copy_indirect_symbol (info
, opt
, tga
);
7867 _bfd_elf_link_hash_hide_symbol (info
, opt
,
7869 htab
->tls_get_addr
= ppc_elf_hash_entry (opt
);
7871 htab
->tls_get_addr_fd
->oh
= htab
->tls_get_addr
;
7872 htab
->tls_get_addr_fd
->is_func_descriptor
= 1;
7873 if (htab
->tls_get_addr
!= NULL
)
7875 htab
->tls_get_addr
->oh
= htab
->tls_get_addr_fd
;
7876 htab
->tls_get_addr
->is_func
= 1;
7879 if (desc_fd
!= NULL
)
7881 htab
->tga_desc_fd
= ppc_elf_hash_entry (opt_fd
);
7882 if (opt
!= NULL
&& desc
!= NULL
)
7884 desc
->root
.type
= bfd_link_hash_indirect
;
7885 desc
->root
.u
.i
.link
= &opt
->root
;
7886 desc
->root
.u
.i
.warning
= NULL
;
7887 ppc64_elf_copy_indirect_symbol (info
, opt
, desc
);
7889 _bfd_elf_link_hash_hide_symbol (info
, opt
,
7890 desc
->forced_local
);
7891 htab
->tga_desc
= ppc_elf_hash_entry (opt
);
7893 htab
->tga_desc_fd
->oh
= htab
->tga_desc
;
7894 htab
->tga_desc_fd
->is_func_descriptor
= 1;
7895 if (htab
->tga_desc
!= NULL
)
7897 htab
->tga_desc
->oh
= htab
->tga_desc_fd
;
7898 htab
->tga_desc
->is_func
= 1;
7904 else if (htab
->params
->tls_get_addr_opt
< 0)
7905 htab
->params
->tls_get_addr_opt
= 0;
7908 if (htab
->tga_desc_fd
!= NULL
7909 && htab
->params
->tls_get_addr_opt
7910 && htab
->params
->no_tls_get_addr_regsave
== -1)
7911 htab
->params
->no_tls_get_addr_regsave
= 0;
7916 /* Return TRUE iff REL is a branch reloc with a global symbol matching
7917 any of HASH1, HASH2, HASH3, or HASH4. */
7920 branch_reloc_hash_match (const bfd
*ibfd
,
7921 const Elf_Internal_Rela
*rel
,
7922 const struct ppc_link_hash_entry
*hash1
,
7923 const struct ppc_link_hash_entry
*hash2
,
7924 const struct ppc_link_hash_entry
*hash3
,
7925 const struct ppc_link_hash_entry
*hash4
)
7927 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (ibfd
);
7928 enum elf_ppc64_reloc_type r_type
= ELF64_R_TYPE (rel
->r_info
);
7929 unsigned int r_symndx
= ELF64_R_SYM (rel
->r_info
);
7931 if (r_symndx
>= symtab_hdr
->sh_info
&& is_branch_reloc (r_type
))
7933 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (ibfd
);
7934 struct elf_link_hash_entry
*h
;
7936 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
7937 h
= elf_follow_link (h
);
7938 if (h
== (struct elf_link_hash_entry
*) hash1
7939 || h
== (struct elf_link_hash_entry
*) hash2
7940 || h
== (struct elf_link_hash_entry
*) hash3
7941 || h
== (struct elf_link_hash_entry
*) hash4
)
7947 /* Run through all the TLS relocs looking for optimization
7948 opportunities. The linker has been hacked (see ppc64elf.em) to do
7949 a preliminary section layout so that we know the TLS segment
7950 offsets. We can't optimize earlier because some optimizations need
7951 to know the tp offset, and we need to optimize before allocating
7952 dynamic relocations. */
7955 ppc64_elf_tls_optimize (struct bfd_link_info
*info
)
7959 struct ppc_link_hash_table
*htab
;
7960 unsigned char *toc_ref
;
7963 if (!bfd_link_executable (info
))
7966 htab
= ppc_hash_table (info
);
7970 htab
->do_tls_opt
= 1;
7972 /* Make two passes over the relocs. On the first pass, mark toc
7973 entries involved with tls relocs, and check that tls relocs
7974 involved in setting up a tls_get_addr call are indeed followed by
7975 such a call. If they are not, we can't do any tls optimization.
7976 On the second pass twiddle tls_mask flags to notify
7977 relocate_section that optimization can be done, and adjust got
7978 and plt refcounts. */
7980 for (pass
= 0; pass
< 2; ++pass
)
7981 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
7983 Elf_Internal_Sym
*locsyms
= NULL
;
7984 asection
*toc
= bfd_get_section_by_name (ibfd
, ".toc");
7986 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7987 if (sec
->has_tls_reloc
&& !bfd_is_abs_section (sec
->output_section
))
7989 Elf_Internal_Rela
*relstart
, *rel
, *relend
;
7990 bfd_boolean found_tls_get_addr_arg
= 0;
7992 /* Read the relocations. */
7993 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
7995 if (relstart
== NULL
)
8001 relend
= relstart
+ sec
->reloc_count
;
8002 for (rel
= relstart
; rel
< relend
; rel
++)
8004 enum elf_ppc64_reloc_type r_type
;
8005 unsigned long r_symndx
;
8006 struct elf_link_hash_entry
*h
;
8007 Elf_Internal_Sym
*sym
;
8009 unsigned char *tls_mask
;
8010 unsigned int tls_set
, tls_clear
, tls_type
= 0;
8012 bfd_boolean ok_tprel
, is_local
;
8013 long toc_ref_index
= 0;
8014 int expecting_tls_get_addr
= 0;
8015 bfd_boolean ret
= FALSE
;
8017 r_symndx
= ELF64_R_SYM (rel
->r_info
);
8018 if (!get_sym_h (&h
, &sym
, &sym_sec
, &tls_mask
, &locsyms
,
8022 if (elf_section_data (sec
)->relocs
!= relstart
)
8025 if (elf_symtab_hdr (ibfd
).contents
8026 != (unsigned char *) locsyms
)
8033 if (h
->root
.type
== bfd_link_hash_defined
8034 || h
->root
.type
== bfd_link_hash_defweak
)
8035 value
= h
->root
.u
.def
.value
;
8036 else if (h
->root
.type
== bfd_link_hash_undefweak
)
8040 found_tls_get_addr_arg
= 0;
8045 /* Symbols referenced by TLS relocs must be of type
8046 STT_TLS. So no need for .opd local sym adjust. */
8047 value
= sym
->st_value
;
8050 is_local
= SYMBOL_REFERENCES_LOCAL (info
, h
);
8054 && h
->root
.type
== bfd_link_hash_undefweak
)
8056 else if (sym_sec
!= NULL
8057 && sym_sec
->output_section
!= NULL
)
8059 value
+= sym_sec
->output_offset
;
8060 value
+= sym_sec
->output_section
->vma
;
8061 value
-= htab
->elf
.tls_sec
->vma
+ TP_OFFSET
;
8062 /* Note that even though the prefix insns
8063 allow a 1<<33 offset we use the same test
8064 as for addis;addi. There may be a mix of
8065 pcrel and non-pcrel code and the decision
8066 to optimise is per symbol, not per TLS
8068 ok_tprel
= value
+ 0x80008000ULL
< 1ULL << 32;
8072 r_type
= ELF64_R_TYPE (rel
->r_info
);
8073 /* If this section has old-style __tls_get_addr calls
8074 without marker relocs, then check that each
8075 __tls_get_addr call reloc is preceded by a reloc
8076 that conceivably belongs to the __tls_get_addr arg
8077 setup insn. If we don't find matching arg setup
8078 relocs, don't do any tls optimization. */
8080 && sec
->nomark_tls_get_addr
8082 && is_tls_get_addr (h
, htab
)
8083 && !found_tls_get_addr_arg
8084 && is_branch_reloc (r_type
))
8086 info
->callbacks
->minfo (_("%H __tls_get_addr lost arg, "
8087 "TLS optimization disabled\n"),
8088 ibfd
, sec
, rel
->r_offset
);
8093 found_tls_get_addr_arg
= 0;
8096 case R_PPC64_GOT_TLSLD16
:
8097 case R_PPC64_GOT_TLSLD16_LO
:
8098 case R_PPC64_GOT_TLSLD_PCREL34
:
8099 expecting_tls_get_addr
= 1;
8100 found_tls_get_addr_arg
= 1;
8103 case R_PPC64_GOT_TLSLD16_HI
:
8104 case R_PPC64_GOT_TLSLD16_HA
:
8105 /* These relocs should never be against a symbol
8106 defined in a shared lib. Leave them alone if
8107 that turns out to be the case. */
8114 tls_type
= TLS_TLS
| TLS_LD
;
8117 case R_PPC64_GOT_TLSGD16
:
8118 case R_PPC64_GOT_TLSGD16_LO
:
8119 case R_PPC64_GOT_TLSGD_PCREL34
:
8120 expecting_tls_get_addr
= 1;
8121 found_tls_get_addr_arg
= 1;
8124 case R_PPC64_GOT_TLSGD16_HI
:
8125 case R_PPC64_GOT_TLSGD16_HA
:
8131 tls_set
= TLS_TLS
| TLS_GDIE
;
8133 tls_type
= TLS_TLS
| TLS_GD
;
8136 case R_PPC64_GOT_TPREL_PCREL34
:
8137 case R_PPC64_GOT_TPREL16_DS
:
8138 case R_PPC64_GOT_TPREL16_LO_DS
:
8139 case R_PPC64_GOT_TPREL16_HI
:
8140 case R_PPC64_GOT_TPREL16_HA
:
8145 tls_clear
= TLS_TPREL
;
8146 tls_type
= TLS_TLS
| TLS_TPREL
;
8156 if (rel
+ 1 < relend
8157 && is_plt_seq_reloc (ELF64_R_TYPE (rel
[1].r_info
)))
8160 && (ELF64_R_TYPE (rel
[1].r_info
)
8162 && (ELF64_R_TYPE (rel
[1].r_info
)
8163 != R_PPC64_PLTSEQ_NOTOC
))
8165 r_symndx
= ELF64_R_SYM (rel
[1].r_info
);
8166 if (!get_sym_h (&h
, NULL
, NULL
, NULL
, &locsyms
,
8171 struct plt_entry
*ent
= NULL
;
8173 for (ent
= h
->plt
.plist
;
8176 if (ent
->addend
== rel
[1].r_addend
)
8180 && ent
->plt
.refcount
> 0)
8181 ent
->plt
.refcount
-= 1;
8186 found_tls_get_addr_arg
= 1;
8191 case R_PPC64_TOC16_LO
:
8192 if (sym_sec
== NULL
|| sym_sec
!= toc
)
8195 /* Mark this toc entry as referenced by a TLS
8196 code sequence. We can do that now in the
8197 case of R_PPC64_TLS, and after checking for
8198 tls_get_addr for the TOC16 relocs. */
8199 if (toc_ref
== NULL
)
8201 = bfd_zmalloc (toc
->output_section
->rawsize
/ 8);
8202 if (toc_ref
== NULL
)
8206 value
= h
->root
.u
.def
.value
;
8208 value
= sym
->st_value
;
8209 value
+= rel
->r_addend
;
8212 BFD_ASSERT (value
< toc
->size
8213 && toc
->output_offset
% 8 == 0);
8214 toc_ref_index
= (value
+ toc
->output_offset
) / 8;
8215 if (r_type
== R_PPC64_TLS
8216 || r_type
== R_PPC64_TLSGD
8217 || r_type
== R_PPC64_TLSLD
)
8219 toc_ref
[toc_ref_index
] = 1;
8223 if (pass
!= 0 && toc_ref
[toc_ref_index
] == 0)
8228 expecting_tls_get_addr
= 2;
8231 case R_PPC64_TPREL64
:
8235 || !toc_ref
[(rel
->r_offset
+ toc
->output_offset
) / 8])
8240 tls_set
= TLS_EXPLICIT
;
8241 tls_clear
= TLS_TPREL
;
8246 case R_PPC64_DTPMOD64
:
8250 || !toc_ref
[(rel
->r_offset
+ toc
->output_offset
) / 8])
8252 if (rel
+ 1 < relend
8254 == ELF64_R_INFO (r_symndx
, R_PPC64_DTPREL64
))
8255 && rel
[1].r_offset
== rel
->r_offset
+ 8)
8259 tls_set
= TLS_EXPLICIT
| TLS_GD
;
8262 tls_set
= TLS_EXPLICIT
| TLS_GD
| TLS_GDIE
;
8271 tls_set
= TLS_EXPLICIT
;
8276 case R_PPC64_TPREL16_HA
:
8279 unsigned char buf
[4];
8281 bfd_vma off
= rel
->r_offset
& ~3;
8282 if (!bfd_get_section_contents (ibfd
, sec
, buf
,
8285 insn
= bfd_get_32 (ibfd
, buf
);
8286 /* addis rt,13,imm */
8287 if ((insn
& ((0x3fu
<< 26) | 0x1f << 16))
8288 != ((15u << 26) | (13 << 16)))
8290 /* xgettext:c-format */
8291 info
->callbacks
->minfo
8292 (_("%H: warning: %s unexpected insn %#x.\n"),
8293 ibfd
, sec
, off
, "R_PPC64_TPREL16_HA", insn
);
8294 htab
->do_tls_opt
= 0;
8299 case R_PPC64_TPREL16_HI
:
8300 case R_PPC64_TPREL16_HIGH
:
8301 case R_PPC64_TPREL16_HIGHA
:
8302 case R_PPC64_TPREL16_HIGHER
:
8303 case R_PPC64_TPREL16_HIGHERA
:
8304 case R_PPC64_TPREL16_HIGHEST
:
8305 case R_PPC64_TPREL16_HIGHESTA
:
8306 /* These can all be used in sequences along with
8307 TPREL16_LO or TPREL16_LO_DS in ways we aren't
8308 able to verify easily. */
8309 htab
->do_tls_opt
= 0;
8318 if (!expecting_tls_get_addr
8319 || !sec
->nomark_tls_get_addr
)
8322 if (rel
+ 1 < relend
8323 && branch_reloc_hash_match (ibfd
, rel
+ 1,
8324 htab
->tls_get_addr_fd
,
8329 if (expecting_tls_get_addr
== 2)
8331 /* Check for toc tls entries. */
8332 unsigned char *toc_tls
;
8335 retval
= get_tls_mask (&toc_tls
, NULL
, NULL
,
8340 if (toc_tls
!= NULL
)
8342 if ((*toc_tls
& TLS_TLS
) != 0
8343 && ((*toc_tls
& (TLS_GD
| TLS_LD
)) != 0))
8344 found_tls_get_addr_arg
= 1;
8346 toc_ref
[toc_ref_index
] = 1;
8352 /* Uh oh, we didn't find the expected call. We
8353 could just mark this symbol to exclude it
8354 from tls optimization but it's safer to skip
8355 the entire optimization. */
8356 /* xgettext:c-format */
8357 info
->callbacks
->minfo (_("%H arg lost __tls_get_addr, "
8358 "TLS optimization disabled\n"),
8359 ibfd
, sec
, rel
->r_offset
);
8364 /* If we don't have old-style __tls_get_addr calls
8365 without TLSGD/TLSLD marker relocs, and we haven't
8366 found a new-style __tls_get_addr call with a
8367 marker for this symbol, then we either have a
8368 broken object file or an -mlongcall style
8369 indirect call to __tls_get_addr without a marker.
8370 Disable optimization in this case. */
8371 if ((tls_clear
& (TLS_GD
| TLS_LD
)) != 0
8372 && (tls_set
& TLS_EXPLICIT
) == 0
8373 && !sec
->nomark_tls_get_addr
8374 && ((*tls_mask
& (TLS_TLS
| TLS_MARK
))
8375 != (TLS_TLS
| TLS_MARK
)))
8378 if (expecting_tls_get_addr
== 1 + !sec
->nomark_tls_get_addr
)
8380 struct plt_entry
*ent
= NULL
;
8382 if (htab
->tls_get_addr_fd
!= NULL
)
8383 for (ent
= htab
->tls_get_addr_fd
->elf
.plt
.plist
;
8386 if (ent
->addend
== 0)
8389 if (ent
== NULL
&& htab
->tga_desc_fd
!= NULL
)
8390 for (ent
= htab
->tga_desc_fd
->elf
.plt
.plist
;
8393 if (ent
->addend
== 0)
8396 if (ent
== NULL
&& htab
->tls_get_addr
!= NULL
)
8397 for (ent
= htab
->tls_get_addr
->elf
.plt
.plist
;
8400 if (ent
->addend
== 0)
8403 if (ent
== NULL
&& htab
->tga_desc
!= NULL
)
8404 for (ent
= htab
->tga_desc
->elf
.plt
.plist
;
8407 if (ent
->addend
== 0)
8411 && ent
->plt
.refcount
> 0)
8412 ent
->plt
.refcount
-= 1;
8418 if ((tls_set
& TLS_EXPLICIT
) == 0)
8420 struct got_entry
*ent
;
8422 /* Adjust got entry for this reloc. */
8426 ent
= elf_local_got_ents (ibfd
)[r_symndx
];
8428 for (; ent
!= NULL
; ent
= ent
->next
)
8429 if (ent
->addend
== rel
->r_addend
8430 && ent
->owner
== ibfd
8431 && ent
->tls_type
== tls_type
)
8438 /* We managed to get rid of a got entry. */
8439 if (ent
->got
.refcount
> 0)
8440 ent
->got
.refcount
-= 1;
8445 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8446 we'll lose one or two dyn relocs. */
8447 if (!dec_dynrel_count (rel
->r_info
, sec
, info
,
8451 if (tls_set
== (TLS_EXPLICIT
| TLS_GD
))
8453 if (!dec_dynrel_count ((rel
+ 1)->r_info
, sec
, info
,
8459 *tls_mask
|= tls_set
& 0xff;
8460 *tls_mask
&= ~tls_clear
;
8463 if (elf_section_data (sec
)->relocs
!= relstart
)
8468 && (elf_symtab_hdr (ibfd
).contents
!= (unsigned char *) locsyms
))
8470 if (!info
->keep_memory
)
8473 elf_symtab_hdr (ibfd
).contents
= (unsigned char *) locsyms
;
8481 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8482 the values of any global symbols in a toc section that has been
8483 edited. Globals in toc sections should be a rarity, so this function
8484 sets a flag if any are found in toc sections other than the one just
8485 edited, so that further hash table traversals can be avoided. */
8487 struct adjust_toc_info
8490 unsigned long *skip
;
8491 bfd_boolean global_toc_syms
;
8494 enum toc_skip_enum
{ ref_from_discarded
= 1, can_optimize
= 2 };
8497 adjust_toc_syms (struct elf_link_hash_entry
*h
, void *inf
)
8499 struct ppc_link_hash_entry
*eh
;
8500 struct adjust_toc_info
*toc_inf
= (struct adjust_toc_info
*) inf
;
8503 if (h
->root
.type
!= bfd_link_hash_defined
8504 && h
->root
.type
!= bfd_link_hash_defweak
)
8507 eh
= ppc_elf_hash_entry (h
);
8508 if (eh
->adjust_done
)
8511 if (eh
->elf
.root
.u
.def
.section
== toc_inf
->toc
)
8513 if (eh
->elf
.root
.u
.def
.value
> toc_inf
->toc
->rawsize
)
8514 i
= toc_inf
->toc
->rawsize
>> 3;
8516 i
= eh
->elf
.root
.u
.def
.value
>> 3;
8518 if ((toc_inf
->skip
[i
] & (ref_from_discarded
| can_optimize
)) != 0)
8521 (_("%s defined on removed toc entry"), eh
->elf
.root
.root
.string
);
8524 while ((toc_inf
->skip
[i
] & (ref_from_discarded
| can_optimize
)) != 0);
8525 eh
->elf
.root
.u
.def
.value
= (bfd_vma
) i
<< 3;
8528 eh
->elf
.root
.u
.def
.value
-= toc_inf
->skip
[i
];
8529 eh
->adjust_done
= 1;
8531 else if (strcmp (eh
->elf
.root
.u
.def
.section
->name
, ".toc") == 0)
8532 toc_inf
->global_toc_syms
= TRUE
;
8537 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
8538 on a _LO variety toc/got reloc. */
8541 ok_lo_toc_insn (unsigned int insn
, enum elf_ppc64_reloc_type r_type
)
8543 return ((insn
& (0x3fu
<< 26)) == 12u << 26 /* addic */
8544 || (insn
& (0x3fu
<< 26)) == 14u << 26 /* addi */
8545 || (insn
& (0x3fu
<< 26)) == 32u << 26 /* lwz */
8546 || (insn
& (0x3fu
<< 26)) == 34u << 26 /* lbz */
8547 || (insn
& (0x3fu
<< 26)) == 36u << 26 /* stw */
8548 || (insn
& (0x3fu
<< 26)) == 38u << 26 /* stb */
8549 || (insn
& (0x3fu
<< 26)) == 40u << 26 /* lhz */
8550 || (insn
& (0x3fu
<< 26)) == 42u << 26 /* lha */
8551 || (insn
& (0x3fu
<< 26)) == 44u << 26 /* sth */
8552 || (insn
& (0x3fu
<< 26)) == 46u << 26 /* lmw */
8553 || (insn
& (0x3fu
<< 26)) == 47u << 26 /* stmw */
8554 || (insn
& (0x3fu
<< 26)) == 48u << 26 /* lfs */
8555 || (insn
& (0x3fu
<< 26)) == 50u << 26 /* lfd */
8556 || (insn
& (0x3fu
<< 26)) == 52u << 26 /* stfs */
8557 || (insn
& (0x3fu
<< 26)) == 54u << 26 /* stfd */
8558 || (insn
& (0x3fu
<< 26)) == 56u << 26 /* lq,lfq */
8559 || ((insn
& (0x3fu
<< 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
8560 /* Exclude lfqu by testing reloc. If relocs are ever
8561 defined for the reduced D field in psq_lu then those
8562 will need testing too. */
8563 && r_type
!= R_PPC64_TOC16_LO
&& r_type
!= R_PPC64_GOT16_LO
)
8564 || ((insn
& (0x3fu
<< 26)) == 58u << 26 /* ld,lwa */
8566 || (insn
& (0x3fu
<< 26)) == 60u << 26 /* stfq */
8567 || ((insn
& (0x3fu
<< 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
8568 /* Exclude stfqu. psq_stu as above for psq_lu. */
8569 && r_type
!= R_PPC64_TOC16_LO
&& r_type
!= R_PPC64_GOT16_LO
)
8570 || ((insn
& (0x3fu
<< 26)) == 62u << 26 /* std,stq */
8571 && (insn
& 1) == 0));
8574 /* PCREL_OPT in one instance flags to the linker that a pair of insns:
8575 pld ra,symbol@got@pcrel
8576 load/store rt,off(ra)
8579 load/store rt,off(ra)
8580 may be translated to
8581 pload/pstore rt,symbol+off@pcrel
8583 This function returns true if the optimization is possible, placing
8584 the prefix insn in *PINSN1, a NOP in *PINSN2 and the offset in *POFF.
8586 On entry to this function, the linker has already determined that
8587 the pld can be replaced with pla: *PINSN1 is that pla insn,
8588 while *PINSN2 is the second instruction. */
8591 xlate_pcrel_opt (uint64_t *pinsn1
, uint64_t *pinsn2
, bfd_signed_vma
*poff
)
8593 uint64_t insn1
= *pinsn1
;
8594 uint64_t insn2
= *pinsn2
;
8597 if ((insn2
& (63ULL << 58)) == 1ULL << 58)
8599 /* Check that regs match. */
8600 if (((insn2
>> 16) & 31) != ((insn1
>> 21) & 31))
8603 /* P8LS or PMLS form, non-pcrel. */
8604 if ((insn2
& (-1ULL << 50) & ~(1ULL << 56)) != (1ULL << 58))
8607 *pinsn1
= (insn2
& ~(31 << 16) & ~0x3ffff0000ffffULL
) | (1ULL << 52);
8609 off
= ((insn2
>> 16) & 0x3ffff0000ULL
) | (insn2
& 0xffff);
8610 *poff
= (off
^ 0x200000000ULL
) - 0x200000000ULL
;
8616 /* Check that regs match. */
8617 if (((insn2
>> 16) & 31) != ((insn1
>> 21) & 31))
8620 switch ((insn2
>> 26) & 63)
8636 /* These are the PMLS cases, where we just need to tack a prefix
8638 insn1
= ((1ULL << 58) | (2ULL << 56) | (1ULL << 52)
8639 | (insn2
& ((63ULL << 26) | (31ULL << 21))));
8640 off
= insn2
& 0xffff;
8643 case 58: /* lwa, ld */
8644 if ((insn2
& 1) != 0)
8646 insn1
= ((1ULL << 58) | (1ULL << 52)
8647 | (insn2
& 2 ? 41ULL << 26 : 57ULL << 26)
8648 | (insn2
& (31ULL << 21)));
8649 off
= insn2
& 0xfffc;
8652 case 57: /* lxsd, lxssp */
8653 if ((insn2
& 3) < 2)
8655 insn1
= ((1ULL << 58) | (1ULL << 52)
8656 | ((40ULL | (insn2
& 3)) << 26)
8657 | (insn2
& (31ULL << 21)));
8658 off
= insn2
& 0xfffc;
8661 case 61: /* stxsd, stxssp, lxv, stxv */
8662 if ((insn2
& 3) == 0)
8664 else if ((insn2
& 3) >= 2)
8666 insn1
= ((1ULL << 58) | (1ULL << 52)
8667 | ((44ULL | (insn2
& 3)) << 26)
8668 | (insn2
& (31ULL << 21)));
8669 off
= insn2
& 0xfffc;
8673 insn1
= ((1ULL << 58) | (1ULL << 52)
8674 | ((50ULL | (insn2
& 4) | ((insn2
& 8) >> 3)) << 26)
8675 | (insn2
& (31ULL << 21)));
8676 off
= insn2
& 0xfff0;
8681 insn1
= ((1ULL << 58) | (1ULL << 52)
8682 | (insn2
& ((63ULL << 26) | (31ULL << 21))));
8683 off
= insn2
& 0xffff;
8686 case 6: /* lxvp, stxvp */
8687 if ((insn2
& 0xe) != 0)
8689 insn1
= ((1ULL << 58) | (1ULL << 52)
8690 | ((insn2
& 1) == 0 ? 58ULL << 26 : 62ULL << 26)
8691 | (insn2
& (31ULL << 21)));
8692 off
= insn2
& 0xfff0;
8695 case 62: /* std, stq */
8696 if ((insn2
& 1) != 0)
8698 insn1
= ((1ULL << 58) | (1ULL << 52)
8699 | ((insn2
& 2) == 0 ? 61ULL << 26 : 60ULL << 26)
8700 | (insn2
& (31ULL << 21)));
8701 off
= insn2
& 0xfffc;
8706 *pinsn2
= (uint64_t) NOP
<< 32;
8707 *poff
= (off
^ 0x8000) - 0x8000;
8711 /* Examine all relocs referencing .toc sections in order to remove
8712 unused .toc entries. */
8715 ppc64_elf_edit_toc (struct bfd_link_info
*info
)
8718 struct adjust_toc_info toc_inf
;
8719 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
8721 htab
->do_toc_opt
= 1;
8722 toc_inf
.global_toc_syms
= TRUE
;
8723 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
8725 asection
*toc
, *sec
;
8726 Elf_Internal_Shdr
*symtab_hdr
;
8727 Elf_Internal_Sym
*local_syms
;
8728 Elf_Internal_Rela
*relstart
, *rel
, *toc_relocs
;
8729 unsigned long *skip
, *drop
;
8730 unsigned char *used
;
8731 unsigned char *keep
, last
, some_unused
;
8733 if (!is_ppc64_elf (ibfd
))
8736 toc
= bfd_get_section_by_name (ibfd
, ".toc");
8739 || toc
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
8740 || discarded_section (toc
))
8745 symtab_hdr
= &elf_symtab_hdr (ibfd
);
8747 /* Look at sections dropped from the final link. */
8750 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
8752 if (sec
->reloc_count
== 0
8753 || !discarded_section (sec
)
8754 || get_opd_info (sec
)
8755 || (sec
->flags
& SEC_ALLOC
) == 0
8756 || (sec
->flags
& SEC_DEBUGGING
) != 0)
8759 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
, FALSE
);
8760 if (relstart
== NULL
)
8763 /* Run through the relocs to see which toc entries might be
8765 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
8767 enum elf_ppc64_reloc_type r_type
;
8768 unsigned long r_symndx
;
8770 struct elf_link_hash_entry
*h
;
8771 Elf_Internal_Sym
*sym
;
8774 r_type
= ELF64_R_TYPE (rel
->r_info
);
8781 case R_PPC64_TOC16_LO
:
8782 case R_PPC64_TOC16_HI
:
8783 case R_PPC64_TOC16_HA
:
8784 case R_PPC64_TOC16_DS
:
8785 case R_PPC64_TOC16_LO_DS
:
8789 r_symndx
= ELF64_R_SYM (rel
->r_info
);
8790 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
8798 val
= h
->root
.u
.def
.value
;
8800 val
= sym
->st_value
;
8801 val
+= rel
->r_addend
;
8803 if (val
>= toc
->size
)
8806 /* Anything in the toc ought to be aligned to 8 bytes.
8807 If not, don't mark as unused. */
8813 skip
= bfd_zmalloc (sizeof (*skip
) * (toc
->size
+ 15) / 8);
8818 skip
[val
>> 3] = ref_from_discarded
;
8821 if (elf_section_data (sec
)->relocs
!= relstart
)
8825 /* For largetoc loads of address constants, we can convert
8826 . addis rx,2,addr@got@ha
8827 . ld ry,addr@got@l(rx)
8829 . addis rx,2,addr@toc@ha
8830 . addi ry,rx,addr@toc@l
8831 when addr is within 2G of the toc pointer. This then means
8832 that the word storing "addr" in the toc is no longer needed. */
8834 if (!ppc64_elf_tdata (ibfd
)->has_small_toc_reloc
8835 && toc
->output_section
->rawsize
< (bfd_vma
) 1 << 31
8836 && toc
->reloc_count
!= 0)
8838 /* Read toc relocs. */
8839 toc_relocs
= _bfd_elf_link_read_relocs (ibfd
, toc
, NULL
, NULL
,
8841 if (toc_relocs
== NULL
)
8844 for (rel
= toc_relocs
; rel
< toc_relocs
+ toc
->reloc_count
; ++rel
)
8846 enum elf_ppc64_reloc_type r_type
;
8847 unsigned long r_symndx
;
8849 struct elf_link_hash_entry
*h
;
8850 Elf_Internal_Sym
*sym
;
8853 r_type
= ELF64_R_TYPE (rel
->r_info
);
8854 if (r_type
!= R_PPC64_ADDR64
)
8857 r_symndx
= ELF64_R_SYM (rel
->r_info
);
8858 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
8863 || sym_sec
->output_section
== NULL
8864 || discarded_section (sym_sec
))
8867 if (!SYMBOL_REFERENCES_LOCAL (info
, h
))
8872 if (h
->type
== STT_GNU_IFUNC
)
8874 val
= h
->root
.u
.def
.value
;
8878 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
8880 val
= sym
->st_value
;
8882 val
+= rel
->r_addend
;
8883 val
+= sym_sec
->output_section
->vma
+ sym_sec
->output_offset
;
8885 /* We don't yet know the exact toc pointer value, but we
8886 know it will be somewhere in the toc section. Don't
8887 optimize if the difference from any possible toc
8888 pointer is outside [ff..f80008000, 7fff7fff]. */
8889 addr
= toc
->output_section
->vma
+ TOC_BASE_OFF
;
8890 if (val
- addr
+ (bfd_vma
) 0x80008000 >= (bfd_vma
) 1 << 32)
8893 addr
= toc
->output_section
->vma
+ toc
->output_section
->rawsize
;
8894 if (val
- addr
+ (bfd_vma
) 0x80008000 >= (bfd_vma
) 1 << 32)
8899 skip
= bfd_zmalloc (sizeof (*skip
) * (toc
->size
+ 15) / 8);
8904 skip
[rel
->r_offset
>> 3]
8905 |= can_optimize
| ((rel
- toc_relocs
) << 2);
8912 used
= bfd_zmalloc (sizeof (*used
) * (toc
->size
+ 7) / 8);
8916 if (symtab_hdr
->contents
!= (unsigned char *) local_syms
)
8919 && elf_section_data (sec
)->relocs
!= relstart
)
8921 if (elf_section_data (toc
)->relocs
!= toc_relocs
)
8927 /* Now check all kept sections that might reference the toc.
8928 Check the toc itself last. */
8929 for (sec
= (ibfd
->sections
== toc
&& toc
->next
? toc
->next
8932 sec
= (sec
== toc
? NULL
8933 : sec
->next
== NULL
? toc
8934 : sec
->next
== toc
&& toc
->next
? toc
->next
8939 if (sec
->reloc_count
== 0
8940 || discarded_section (sec
)
8941 || get_opd_info (sec
)
8942 || (sec
->flags
& SEC_ALLOC
) == 0
8943 || (sec
->flags
& SEC_DEBUGGING
) != 0)
8946 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
8948 if (relstart
== NULL
)
8954 /* Mark toc entries referenced as used. */
8958 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
8960 enum elf_ppc64_reloc_type r_type
;
8961 unsigned long r_symndx
;
8963 struct elf_link_hash_entry
*h
;
8964 Elf_Internal_Sym
*sym
;
8967 r_type
= ELF64_R_TYPE (rel
->r_info
);
8971 case R_PPC64_TOC16_LO
:
8972 case R_PPC64_TOC16_HI
:
8973 case R_PPC64_TOC16_HA
:
8974 case R_PPC64_TOC16_DS
:
8975 case R_PPC64_TOC16_LO_DS
:
8976 /* In case we're taking addresses of toc entries. */
8977 case R_PPC64_ADDR64
:
8984 r_symndx
= ELF64_R_SYM (rel
->r_info
);
8985 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
8996 val
= h
->root
.u
.def
.value
;
8998 val
= sym
->st_value
;
8999 val
+= rel
->r_addend
;
9001 if (val
>= toc
->size
)
9004 if ((skip
[val
>> 3] & can_optimize
) != 0)
9011 case R_PPC64_TOC16_HA
:
9014 case R_PPC64_TOC16_LO_DS
:
9015 off
= rel
->r_offset
;
9016 off
+= (bfd_big_endian (ibfd
) ? -2 : 3);
9017 if (!bfd_get_section_contents (ibfd
, sec
, &opc
,
9023 if ((opc
& (0x3f << 2)) == (58u << 2))
9028 /* Wrong sort of reloc, or not a ld. We may
9029 as well clear ref_from_discarded too. */
9036 /* For the toc section, we only mark as used if this
9037 entry itself isn't unused. */
9038 else if ((used
[rel
->r_offset
>> 3]
9039 || !(skip
[rel
->r_offset
>> 3] & ref_from_discarded
))
9042 /* Do all the relocs again, to catch reference
9051 if (elf_section_data (sec
)->relocs
!= relstart
)
9055 /* Merge the used and skip arrays. Assume that TOC
9056 doublewords not appearing as either used or unused belong
9057 to an entry more than one doubleword in size. */
9058 for (drop
= skip
, keep
= used
, last
= 0, some_unused
= 0;
9059 drop
< skip
+ (toc
->size
+ 7) / 8;
9064 *drop
&= ~ref_from_discarded
;
9065 if ((*drop
& can_optimize
) != 0)
9069 else if ((*drop
& ref_from_discarded
) != 0)
9072 last
= ref_from_discarded
;
9082 bfd_byte
*contents
, *src
;
9084 Elf_Internal_Sym
*sym
;
9085 bfd_boolean local_toc_syms
= FALSE
;
9087 /* Shuffle the toc contents, and at the same time convert the
9088 skip array from booleans into offsets. */
9089 if (!bfd_malloc_and_get_section (ibfd
, toc
, &contents
))
9092 elf_section_data (toc
)->this_hdr
.contents
= contents
;
9094 for (src
= contents
, off
= 0, drop
= skip
;
9095 src
< contents
+ toc
->size
;
9098 if ((*drop
& (can_optimize
| ref_from_discarded
)) != 0)
9103 memcpy (src
- off
, src
, 8);
9107 toc
->rawsize
= toc
->size
;
9108 toc
->size
= src
- contents
- off
;
9110 /* Adjust addends for relocs against the toc section sym,
9111 and optimize any accesses we can. */
9112 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
9114 if (sec
->reloc_count
== 0
9115 || discarded_section (sec
))
9118 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
9120 if (relstart
== NULL
)
9123 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
9125 enum elf_ppc64_reloc_type r_type
;
9126 unsigned long r_symndx
;
9128 struct elf_link_hash_entry
*h
;
9131 r_type
= ELF64_R_TYPE (rel
->r_info
);
9138 case R_PPC64_TOC16_LO
:
9139 case R_PPC64_TOC16_HI
:
9140 case R_PPC64_TOC16_HA
:
9141 case R_PPC64_TOC16_DS
:
9142 case R_PPC64_TOC16_LO_DS
:
9143 case R_PPC64_ADDR64
:
9147 r_symndx
= ELF64_R_SYM (rel
->r_info
);
9148 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
9156 val
= h
->root
.u
.def
.value
;
9159 val
= sym
->st_value
;
9161 local_toc_syms
= TRUE
;
9164 val
+= rel
->r_addend
;
9166 if (val
> toc
->rawsize
)
9168 else if ((skip
[val
>> 3] & ref_from_discarded
) != 0)
9170 else if ((skip
[val
>> 3] & can_optimize
) != 0)
9172 Elf_Internal_Rela
*tocrel
9173 = toc_relocs
+ (skip
[val
>> 3] >> 2);
9174 unsigned long tsym
= ELF64_R_SYM (tocrel
->r_info
);
9178 case R_PPC64_TOC16_HA
:
9179 rel
->r_info
= ELF64_R_INFO (tsym
, R_PPC64_TOC16_HA
);
9182 case R_PPC64_TOC16_LO_DS
:
9183 rel
->r_info
= ELF64_R_INFO (tsym
, R_PPC64_LO_DS_OPT
);
9187 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
9189 info
->callbacks
->einfo
9190 /* xgettext:c-format */
9191 (_("%H: %s references "
9192 "optimized away TOC entry\n"),
9193 ibfd
, sec
, rel
->r_offset
,
9194 ppc64_elf_howto_table
[r_type
]->name
);
9195 bfd_set_error (bfd_error_bad_value
);
9198 rel
->r_addend
= tocrel
->r_addend
;
9199 elf_section_data (sec
)->relocs
= relstart
;
9203 if (h
!= NULL
|| sym
->st_value
!= 0)
9206 rel
->r_addend
-= skip
[val
>> 3];
9207 elf_section_data (sec
)->relocs
= relstart
;
9210 if (elf_section_data (sec
)->relocs
!= relstart
)
9214 /* We shouldn't have local or global symbols defined in the TOC,
9215 but handle them anyway. */
9216 if (local_syms
!= NULL
)
9217 for (sym
= local_syms
;
9218 sym
< local_syms
+ symtab_hdr
->sh_info
;
9220 if (sym
->st_value
!= 0
9221 && bfd_section_from_elf_index (ibfd
, sym
->st_shndx
) == toc
)
9225 if (sym
->st_value
> toc
->rawsize
)
9226 i
= toc
->rawsize
>> 3;
9228 i
= sym
->st_value
>> 3;
9230 if ((skip
[i
] & (ref_from_discarded
| can_optimize
)) != 0)
9234 (_("%s defined on removed toc entry"),
9235 bfd_elf_sym_name (ibfd
, symtab_hdr
, sym
, NULL
));
9238 while ((skip
[i
] & (ref_from_discarded
| can_optimize
)));
9239 sym
->st_value
= (bfd_vma
) i
<< 3;
9242 sym
->st_value
-= skip
[i
];
9243 symtab_hdr
->contents
= (unsigned char *) local_syms
;
9246 /* Adjust any global syms defined in this toc input section. */
9247 if (toc_inf
.global_toc_syms
)
9250 toc_inf
.skip
= skip
;
9251 toc_inf
.global_toc_syms
= FALSE
;
9252 elf_link_hash_traverse (elf_hash_table (info
), adjust_toc_syms
,
9256 if (toc
->reloc_count
!= 0)
9258 Elf_Internal_Shdr
*rel_hdr
;
9259 Elf_Internal_Rela
*wrel
;
9262 /* Remove unused toc relocs, and adjust those we keep. */
9263 if (toc_relocs
== NULL
)
9264 toc_relocs
= _bfd_elf_link_read_relocs (ibfd
, toc
, NULL
, NULL
,
9266 if (toc_relocs
== NULL
)
9270 for (rel
= toc_relocs
; rel
< toc_relocs
+ toc
->reloc_count
; ++rel
)
9271 if ((skip
[rel
->r_offset
>> 3]
9272 & (ref_from_discarded
| can_optimize
)) == 0)
9274 wrel
->r_offset
= rel
->r_offset
- skip
[rel
->r_offset
>> 3];
9275 wrel
->r_info
= rel
->r_info
;
9276 wrel
->r_addend
= rel
->r_addend
;
9279 else if (!dec_dynrel_count (rel
->r_info
, toc
, info
,
9280 &local_syms
, NULL
, NULL
))
9283 elf_section_data (toc
)->relocs
= toc_relocs
;
9284 toc
->reloc_count
= wrel
- toc_relocs
;
9285 rel_hdr
= _bfd_elf_single_rel_hdr (toc
);
9286 sz
= rel_hdr
->sh_entsize
;
9287 rel_hdr
->sh_size
= toc
->reloc_count
* sz
;
9290 else if (elf_section_data (toc
)->relocs
!= toc_relocs
)
9293 if (local_syms
!= NULL
9294 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
9296 if (!info
->keep_memory
)
9299 symtab_hdr
->contents
= (unsigned char *) local_syms
;
9304 /* Look for cases where we can change an indirect GOT access to
9305 a GOT relative or PC relative access, possibly reducing the
9306 number of GOT entries. */
9307 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
9310 Elf_Internal_Shdr
*symtab_hdr
;
9311 Elf_Internal_Sym
*local_syms
;
9312 Elf_Internal_Rela
*relstart
, *rel
;
9315 if (!is_ppc64_elf (ibfd
))
9318 if (!ppc64_elf_tdata (ibfd
)->has_optrel
)
9321 sec
= ppc64_elf_tdata (ibfd
)->got
;
9324 got
= sec
->output_section
->vma
+ sec
->output_offset
+ 0x8000;
9327 symtab_hdr
= &elf_symtab_hdr (ibfd
);
9329 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
9331 if (sec
->reloc_count
== 0
9332 || !ppc64_elf_section_data (sec
)->has_optrel
9333 || discarded_section (sec
))
9336 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
9338 if (relstart
== NULL
)
9341 if (symtab_hdr
->contents
!= (unsigned char *) local_syms
)
9344 && elf_section_data (sec
)->relocs
!= relstart
)
9349 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
9351 enum elf_ppc64_reloc_type r_type
;
9352 unsigned long r_symndx
;
9353 Elf_Internal_Sym
*sym
;
9355 struct elf_link_hash_entry
*h
;
9356 struct got_entry
*ent
;
9358 unsigned char buf
[8];
9360 enum {no_check
, check_lo
, check_ha
} insn_check
;
9362 r_type
= ELF64_R_TYPE (rel
->r_info
);
9366 insn_check
= no_check
;
9369 case R_PPC64_PLT16_HA
:
9370 case R_PPC64_GOT_TLSLD16_HA
:
9371 case R_PPC64_GOT_TLSGD16_HA
:
9372 case R_PPC64_GOT_TPREL16_HA
:
9373 case R_PPC64_GOT_DTPREL16_HA
:
9374 case R_PPC64_GOT16_HA
:
9375 case R_PPC64_TOC16_HA
:
9376 insn_check
= check_ha
;
9379 case R_PPC64_PLT16_LO
:
9380 case R_PPC64_PLT16_LO_DS
:
9381 case R_PPC64_GOT_TLSLD16_LO
:
9382 case R_PPC64_GOT_TLSGD16_LO
:
9383 case R_PPC64_GOT_TPREL16_LO_DS
:
9384 case R_PPC64_GOT_DTPREL16_LO_DS
:
9385 case R_PPC64_GOT16_LO
:
9386 case R_PPC64_GOT16_LO_DS
:
9387 case R_PPC64_TOC16_LO
:
9388 case R_PPC64_TOC16_LO_DS
:
9389 insn_check
= check_lo
;
9393 if (insn_check
!= no_check
)
9395 bfd_vma off
= rel
->r_offset
& ~3;
9397 if (!bfd_get_section_contents (ibfd
, sec
, buf
, off
, 4))
9400 insn
= bfd_get_32 (ibfd
, buf
);
9401 if (insn_check
== check_lo
9402 ? !ok_lo_toc_insn (insn
, r_type
)
9403 : ((insn
& ((0x3fu
<< 26) | 0x1f << 16))
9404 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9408 ppc64_elf_tdata (ibfd
)->unexpected_toc_insn
= 1;
9409 sprintf (str
, "%#08x", insn
);
9410 info
->callbacks
->einfo
9411 /* xgettext:c-format */
9412 (_("%H: got/toc optimization is not supported for"
9413 " %s instruction\n"),
9414 ibfd
, sec
, rel
->r_offset
& ~3, str
);
9421 /* Note that we don't delete GOT entries for
9422 R_PPC64_GOT16_DS since we'd need a lot more
9423 analysis. For starters, the preliminary layout is
9424 before the GOT, PLT, dynamic sections and stubs are
9425 laid out. Then we'd need to allow for changes in
9426 distance between sections caused by alignment. */
9430 case R_PPC64_GOT16_HA
:
9431 case R_PPC64_GOT16_LO_DS
:
9432 case R_PPC64_GOT_PCREL34
:
9436 r_symndx
= ELF64_R_SYM (rel
->r_info
);
9437 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
9442 || sym_sec
->output_section
== NULL
9443 || discarded_section (sym_sec
))
9446 if ((h
? h
->type
: ELF_ST_TYPE (sym
->st_info
)) == STT_GNU_IFUNC
)
9449 if (!SYMBOL_REFERENCES_LOCAL (info
, h
))
9453 val
= h
->root
.u
.def
.value
;
9455 val
= sym
->st_value
;
9456 val
+= rel
->r_addend
;
9457 val
+= sym_sec
->output_section
->vma
+ sym_sec
->output_offset
;
9459 /* Fudge factor to allow for the fact that the preliminary layout
9460 isn't exact. Reduce limits by this factor. */
9461 #define LIMIT_ADJUST(LIMIT) ((LIMIT) - (LIMIT) / 16)
9468 case R_PPC64_GOT16_HA
:
9469 if (val
- got
+ LIMIT_ADJUST (0x80008000ULL
)
9470 >= LIMIT_ADJUST (0x100000000ULL
))
9473 if (!bfd_get_section_contents (ibfd
, sec
, buf
,
9474 rel
->r_offset
& ~3, 4))
9476 insn
= bfd_get_32 (ibfd
, buf
);
9477 if (((insn
& ((0x3fu
<< 26) | 0x1f << 16))
9478 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9482 case R_PPC64_GOT16_LO_DS
:
9483 if (val
- got
+ LIMIT_ADJUST (0x80008000ULL
)
9484 >= LIMIT_ADJUST (0x100000000ULL
))
9486 if (!bfd_get_section_contents (ibfd
, sec
, buf
,
9487 rel
->r_offset
& ~3, 4))
9489 insn
= bfd_get_32 (ibfd
, buf
);
9490 if ((insn
& (0x3fu
<< 26 | 0x3)) != 58u << 26 /* ld */)
9494 case R_PPC64_GOT_PCREL34
:
9496 pc
+= sec
->output_section
->vma
+ sec
->output_offset
;
9497 if (val
- pc
+ LIMIT_ADJUST (1ULL << 33)
9498 >= LIMIT_ADJUST (1ULL << 34))
9500 if (!bfd_get_section_contents (ibfd
, sec
, buf
,
9501 rel
->r_offset
& ~3, 8))
9503 insn
= bfd_get_32 (ibfd
, buf
);
9504 if ((insn
& (-1u << 18)) != ((1u << 26) | (1u << 20)))
9506 insn
= bfd_get_32 (ibfd
, buf
+ 4);
9507 if ((insn
& (0x3fu
<< 26)) != 57u << 26)
9517 struct got_entry
**local_got_ents
= elf_local_got_ents (ibfd
);
9518 ent
= local_got_ents
[r_symndx
];
9520 for (; ent
!= NULL
; ent
= ent
->next
)
9521 if (ent
->addend
== rel
->r_addend
9522 && ent
->owner
== ibfd
9523 && ent
->tls_type
== 0)
9525 BFD_ASSERT (ent
&& ent
->got
.refcount
> 0);
9526 ent
->got
.refcount
-= 1;
9529 if (elf_section_data (sec
)->relocs
!= relstart
)
9533 if (local_syms
!= NULL
9534 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
9536 if (!info
->keep_memory
)
9539 symtab_hdr
->contents
= (unsigned char *) local_syms
;
9546 /* Return true iff input section I references the TOC using
9547 instructions limited to +/-32k offsets. */
9550 ppc64_elf_has_small_toc_reloc (asection
*i
)
9552 return (is_ppc64_elf (i
->owner
)
9553 && ppc64_elf_tdata (i
->owner
)->has_small_toc_reloc
);
9556 /* Allocate space for one GOT entry. */
9559 allocate_got (struct elf_link_hash_entry
*h
,
9560 struct bfd_link_info
*info
,
9561 struct got_entry
*gent
)
9563 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
9564 struct ppc_link_hash_entry
*eh
= ppc_elf_hash_entry (h
);
9565 int entsize
= (gent
->tls_type
& eh
->tls_mask
& (TLS_GD
| TLS_LD
)
9567 int rentsize
= (gent
->tls_type
& eh
->tls_mask
& TLS_GD
9568 ? 2 : 1) * sizeof (Elf64_External_Rela
);
9569 asection
*got
= ppc64_elf_tdata (gent
->owner
)->got
;
9571 gent
->got
.offset
= got
->size
;
9572 got
->size
+= entsize
;
9574 if (h
->type
== STT_GNU_IFUNC
)
9576 htab
->elf
.irelplt
->size
+= rentsize
;
9577 htab
->got_reli_size
+= rentsize
;
9579 else if (((bfd_link_pic (info
)
9580 && !(gent
->tls_type
!= 0
9581 && bfd_link_executable (info
)
9582 && SYMBOL_REFERENCES_LOCAL (info
, h
)))
9583 || (htab
->elf
.dynamic_sections_created
9585 && !SYMBOL_REFERENCES_LOCAL (info
, h
)))
9586 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
9588 asection
*relgot
= ppc64_elf_tdata (gent
->owner
)->relgot
;
9589 relgot
->size
+= rentsize
;
9593 /* This function merges got entries in the same toc group. */
9596 merge_got_entries (struct got_entry
**pent
)
9598 struct got_entry
*ent
, *ent2
;
9600 for (ent
= *pent
; ent
!= NULL
; ent
= ent
->next
)
9601 if (!ent
->is_indirect
)
9602 for (ent2
= ent
->next
; ent2
!= NULL
; ent2
= ent2
->next
)
9603 if (!ent2
->is_indirect
9604 && ent2
->addend
== ent
->addend
9605 && ent2
->tls_type
== ent
->tls_type
9606 && elf_gp (ent2
->owner
) == elf_gp (ent
->owner
))
9608 ent2
->is_indirect
= TRUE
;
9609 ent2
->got
.ent
= ent
;
9613 /* If H is undefined, make it dynamic if that makes sense. */
9616 ensure_undef_dynamic (struct bfd_link_info
*info
,
9617 struct elf_link_hash_entry
*h
)
9619 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
9621 if (htab
->dynamic_sections_created
9622 && ((info
->dynamic_undefined_weak
!= 0
9623 && h
->root
.type
== bfd_link_hash_undefweak
)
9624 || h
->root
.type
== bfd_link_hash_undefined
)
9627 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
9628 return bfd_elf_link_record_dynamic_symbol (info
, h
);
9632 /* Allocate space in .plt, .got and associated reloc sections for
9636 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
9638 struct bfd_link_info
*info
;
9639 struct ppc_link_hash_table
*htab
;
9641 struct ppc_link_hash_entry
*eh
;
9642 struct got_entry
**pgent
, *gent
;
9644 if (h
->root
.type
== bfd_link_hash_indirect
)
9647 info
= (struct bfd_link_info
*) inf
;
9648 htab
= ppc_hash_table (info
);
9652 eh
= ppc_elf_hash_entry (h
);
9653 /* Run through the TLS GD got entries first if we're changing them
9655 if ((eh
->tls_mask
& (TLS_TLS
| TLS_GDIE
)) == (TLS_TLS
| TLS_GDIE
))
9656 for (gent
= h
->got
.glist
; gent
!= NULL
; gent
= gent
->next
)
9657 if (gent
->got
.refcount
> 0
9658 && (gent
->tls_type
& TLS_GD
) != 0)
9660 /* This was a GD entry that has been converted to TPREL. If
9661 there happens to be a TPREL entry we can use that one. */
9662 struct got_entry
*ent
;
9663 for (ent
= h
->got
.glist
; ent
!= NULL
; ent
= ent
->next
)
9664 if (ent
->got
.refcount
> 0
9665 && (ent
->tls_type
& TLS_TPREL
) != 0
9666 && ent
->addend
== gent
->addend
9667 && ent
->owner
== gent
->owner
)
9669 gent
->got
.refcount
= 0;
9673 /* If not, then we'll be using our own TPREL entry. */
9674 if (gent
->got
.refcount
!= 0)
9675 gent
->tls_type
= TLS_TLS
| TLS_TPREL
;
9678 /* Remove any list entry that won't generate a word in the GOT before
9679 we call merge_got_entries. Otherwise we risk merging to empty
9681 pgent
= &h
->got
.glist
;
9682 while ((gent
= *pgent
) != NULL
)
9683 if (gent
->got
.refcount
> 0)
9685 if ((gent
->tls_type
& TLS_LD
) != 0
9686 && SYMBOL_REFERENCES_LOCAL (info
, h
))
9688 ppc64_tlsld_got (gent
->owner
)->got
.refcount
+= 1;
9689 *pgent
= gent
->next
;
9692 pgent
= &gent
->next
;
9695 *pgent
= gent
->next
;
9697 if (!htab
->do_multi_toc
)
9698 merge_got_entries (&h
->got
.glist
);
9700 for (gent
= h
->got
.glist
; gent
!= NULL
; gent
= gent
->next
)
9701 if (!gent
->is_indirect
)
9703 /* Ensure we catch all the cases where this symbol should
9705 if (!ensure_undef_dynamic (info
, h
))
9708 if (!is_ppc64_elf (gent
->owner
))
9711 allocate_got (h
, info
, gent
);
9714 /* If no dynamic sections we can't have dynamic relocs, except for
9715 IFUNCs which are handled even in static executables. */
9716 if (!htab
->elf
.dynamic_sections_created
9717 && h
->type
!= STT_GNU_IFUNC
)
9718 h
->dyn_relocs
= NULL
;
9720 /* Discard relocs on undefined symbols that must be local. */
9721 else if (h
->root
.type
== bfd_link_hash_undefined
9722 && ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
9723 h
->dyn_relocs
= NULL
;
9725 /* Also discard relocs on undefined weak syms with non-default
9726 visibility, or when dynamic_undefined_weak says so. */
9727 else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
9728 h
->dyn_relocs
= NULL
;
9730 if (h
->dyn_relocs
!= NULL
)
9732 struct elf_dyn_relocs
*p
, **pp
;
9734 /* In the shared -Bsymbolic case, discard space allocated for
9735 dynamic pc-relative relocs against symbols which turn out to
9736 be defined in regular objects. For the normal shared case,
9737 discard space for relocs that have become local due to symbol
9738 visibility changes. */
9739 if (bfd_link_pic (info
))
9741 /* Relocs that use pc_count are those that appear on a call
9742 insn, or certain REL relocs (see must_be_dyn_reloc) that
9743 can be generated via assembly. We want calls to
9744 protected symbols to resolve directly to the function
9745 rather than going via the plt. If people want function
9746 pointer comparisons to work as expected then they should
9747 avoid writing weird assembly. */
9748 if (SYMBOL_CALLS_LOCAL (info
, h
))
9750 for (pp
= &h
->dyn_relocs
; (p
= *pp
) != NULL
; )
9752 p
->count
-= p
->pc_count
;
9761 if (h
->dyn_relocs
!= NULL
)
9763 /* Ensure we catch all the cases where this symbol
9764 should be made dynamic. */
9765 if (!ensure_undef_dynamic (info
, h
))
9770 /* For a fixed position executable, discard space for
9771 relocs against symbols which are not dynamic. */
9772 else if (h
->type
!= STT_GNU_IFUNC
)
9774 if (h
->dynamic_adjusted
9776 && !ELF_COMMON_DEF_P (h
))
9778 /* Ensure we catch all the cases where this symbol
9779 should be made dynamic. */
9780 if (!ensure_undef_dynamic (info
, h
))
9783 /* But if that didn't work out, discard dynamic relocs. */
9784 if (h
->dynindx
== -1)
9785 h
->dyn_relocs
= NULL
;
9788 h
->dyn_relocs
= NULL
;
9791 /* Finally, allocate space. */
9792 for (p
= h
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
9794 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
9795 if (eh
->elf
.type
== STT_GNU_IFUNC
)
9796 sreloc
= htab
->elf
.irelplt
;
9797 sreloc
->size
+= p
->count
* sizeof (Elf64_External_Rela
);
9801 /* We might need a PLT entry when the symbol
9804 c) has plt16 relocs and has been processed by adjust_dynamic_symbol, or
9805 d) has plt16 relocs and we are linking statically. */
9806 if ((htab
->elf
.dynamic_sections_created
&& h
->dynindx
!= -1)
9807 || h
->type
== STT_GNU_IFUNC
9808 || (h
->needs_plt
&& h
->dynamic_adjusted
)
9811 && !htab
->elf
.dynamic_sections_created
9812 && !htab
->can_convert_all_inline_plt
9813 && (ppc_elf_hash_entry (h
)->tls_mask
9814 & (TLS_TLS
| PLT_KEEP
)) == PLT_KEEP
))
9816 struct plt_entry
*pent
;
9817 bfd_boolean doneone
= FALSE
;
9818 for (pent
= h
->plt
.plist
; pent
!= NULL
; pent
= pent
->next
)
9819 if (pent
->plt
.refcount
> 0)
9821 if (!htab
->elf
.dynamic_sections_created
9822 || h
->dynindx
== -1)
9824 if (h
->type
== STT_GNU_IFUNC
)
9827 pent
->plt
.offset
= s
->size
;
9828 s
->size
+= PLT_ENTRY_SIZE (htab
);
9829 s
= htab
->elf
.irelplt
;
9834 pent
->plt
.offset
= s
->size
;
9835 s
->size
+= LOCAL_PLT_ENTRY_SIZE (htab
);
9836 s
= bfd_link_pic (info
) ? htab
->relpltlocal
: NULL
;
9841 /* If this is the first .plt entry, make room for the special
9845 s
->size
+= PLT_INITIAL_ENTRY_SIZE (htab
);
9847 pent
->plt
.offset
= s
->size
;
9849 /* Make room for this entry. */
9850 s
->size
+= PLT_ENTRY_SIZE (htab
);
9852 /* Make room for the .glink code. */
9855 s
->size
+= GLINK_PLTRESOLVE_SIZE (htab
);
9858 /* We need bigger stubs past index 32767. */
9859 if (s
->size
>= GLINK_PLTRESOLVE_SIZE (htab
) + 32768*2*4)
9866 /* We also need to make an entry in the .rela.plt section. */
9867 s
= htab
->elf
.srelplt
;
9870 s
->size
+= sizeof (Elf64_External_Rela
);
9874 pent
->plt
.offset
= (bfd_vma
) -1;
9877 h
->plt
.plist
= NULL
;
9883 h
->plt
.plist
= NULL
;
9890 #define PPC_LO(v) ((v) & 0xffff)
9891 #define PPC_HI(v) (((v) >> 16) & 0xffff)
9892 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
9894 ((((v) & 0x3ffff0000ULL) << 16) | (v & 0xffff))
9895 #define HA34(v) ((v + (1ULL << 33)) >> 34)
9897 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9898 to set up space for global entry stubs. These are put in glink,
9899 after the branch table. */
9902 size_global_entry_stubs (struct elf_link_hash_entry
*h
, void *inf
)
9904 struct bfd_link_info
*info
;
9905 struct ppc_link_hash_table
*htab
;
9906 struct plt_entry
*pent
;
9909 if (h
->root
.type
== bfd_link_hash_indirect
)
9912 if (!h
->pointer_equality_needed
)
9919 htab
= ppc_hash_table (info
);
9923 s
= htab
->global_entry
;
9924 plt
= htab
->elf
.splt
;
9925 for (pent
= h
->plt
.plist
; pent
!= NULL
; pent
= pent
->next
)
9926 if (pent
->plt
.offset
!= (bfd_vma
) -1
9927 && pent
->addend
== 0)
9929 /* For ELFv2, if this symbol is not defined in a regular file
9930 and we are not generating a shared library or pie, then we
9931 need to define the symbol in the executable on a call stub.
9932 This is to avoid text relocations. */
9933 bfd_vma off
, stub_align
, stub_off
, stub_size
;
9934 unsigned int align_power
;
9938 if (htab
->params
->plt_stub_align
>= 0)
9939 align_power
= htab
->params
->plt_stub_align
;
9941 align_power
= -htab
->params
->plt_stub_align
;
9942 /* Setting section alignment is delayed until we know it is
9943 non-empty. Otherwise the .text output section will be
9944 aligned at least to plt_stub_align even when no global
9945 entry stubs are needed. */
9946 if (s
->alignment_power
< align_power
)
9947 s
->alignment_power
= align_power
;
9948 stub_align
= (bfd_vma
) 1 << align_power
;
9949 if (htab
->params
->plt_stub_align
>= 0
9950 || ((((stub_off
+ stub_size
- 1) & -stub_align
)
9951 - (stub_off
& -stub_align
))
9952 > ((stub_size
- 1) & -stub_align
)))
9953 stub_off
= (stub_off
+ stub_align
- 1) & -stub_align
;
9954 off
= pent
->plt
.offset
+ plt
->output_offset
+ plt
->output_section
->vma
;
9955 off
-= stub_off
+ s
->output_offset
+ s
->output_section
->vma
;
9956 /* Note that for --plt-stub-align negative we have a possible
9957 dependency between stub offset and size. Break that
9958 dependency by assuming the max stub size when calculating
9960 if (PPC_HA (off
) == 0)
9962 h
->root
.type
= bfd_link_hash_defined
;
9963 h
->root
.u
.def
.section
= s
;
9964 h
->root
.u
.def
.value
= stub_off
;
9965 s
->size
= stub_off
+ stub_size
;
9971 /* Set the sizes of the dynamic sections. */
9974 ppc64_elf_size_dynamic_sections (bfd
*output_bfd
,
9975 struct bfd_link_info
*info
)
9977 struct ppc_link_hash_table
*htab
;
9982 struct got_entry
*first_tlsld
;
9984 htab
= ppc_hash_table (info
);
9988 dynobj
= htab
->elf
.dynobj
;
9992 if (htab
->elf
.dynamic_sections_created
)
9994 /* Set the contents of the .interp section to the interpreter. */
9995 if (bfd_link_executable (info
) && !info
->nointerp
)
9997 s
= bfd_get_linker_section (dynobj
, ".interp");
10000 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
10001 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
10005 /* Set up .got offsets for local syms, and space for local dynamic
10007 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
10009 struct got_entry
**lgot_ents
;
10010 struct got_entry
**end_lgot_ents
;
10011 struct plt_entry
**local_plt
;
10012 struct plt_entry
**end_local_plt
;
10013 unsigned char *lgot_masks
;
10014 bfd_size_type locsymcount
;
10015 Elf_Internal_Shdr
*symtab_hdr
;
10017 if (!is_ppc64_elf (ibfd
))
10020 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
10022 struct ppc_dyn_relocs
*p
;
10024 for (p
= elf_section_data (s
)->local_dynrel
; p
!= NULL
; p
= p
->next
)
10026 if (!bfd_is_abs_section (p
->sec
)
10027 && bfd_is_abs_section (p
->sec
->output_section
))
10029 /* Input section has been discarded, either because
10030 it is a copy of a linkonce section or due to
10031 linker script /DISCARD/, so we'll be discarding
10034 else if (p
->count
!= 0)
10036 asection
*srel
= elf_section_data (p
->sec
)->sreloc
;
10038 srel
= htab
->elf
.irelplt
;
10039 srel
->size
+= p
->count
* sizeof (Elf64_External_Rela
);
10040 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
10041 info
->flags
|= DF_TEXTREL
;
10046 lgot_ents
= elf_local_got_ents (ibfd
);
10050 symtab_hdr
= &elf_symtab_hdr (ibfd
);
10051 locsymcount
= symtab_hdr
->sh_info
;
10052 end_lgot_ents
= lgot_ents
+ locsymcount
;
10053 local_plt
= (struct plt_entry
**) end_lgot_ents
;
10054 end_local_plt
= local_plt
+ locsymcount
;
10055 lgot_masks
= (unsigned char *) end_local_plt
;
10056 s
= ppc64_elf_tdata (ibfd
)->got
;
10057 for (; lgot_ents
< end_lgot_ents
; ++lgot_ents
, ++lgot_masks
)
10059 struct got_entry
**pent
, *ent
;
10062 while ((ent
= *pent
) != NULL
)
10063 if (ent
->got
.refcount
> 0)
10065 if ((ent
->tls_type
& *lgot_masks
& TLS_LD
) != 0)
10067 ppc64_tlsld_got (ibfd
)->got
.refcount
+= 1;
10072 unsigned int ent_size
= 8;
10073 unsigned int rel_size
= sizeof (Elf64_External_Rela
);
10075 ent
->got
.offset
= s
->size
;
10076 if ((ent
->tls_type
& *lgot_masks
& TLS_GD
) != 0)
10081 s
->size
+= ent_size
;
10082 if ((*lgot_masks
& (TLS_TLS
| PLT_IFUNC
)) == PLT_IFUNC
)
10084 htab
->elf
.irelplt
->size
+= rel_size
;
10085 htab
->got_reli_size
+= rel_size
;
10087 else if (bfd_link_pic (info
)
10088 && !(ent
->tls_type
!= 0
10089 && bfd_link_executable (info
)))
10091 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
10092 srel
->size
+= rel_size
;
10101 /* Allocate space for plt calls to local syms. */
10102 lgot_masks
= (unsigned char *) end_local_plt
;
10103 for (; local_plt
< end_local_plt
; ++local_plt
, ++lgot_masks
)
10105 struct plt_entry
*ent
;
10107 for (ent
= *local_plt
; ent
!= NULL
; ent
= ent
->next
)
10108 if (ent
->plt
.refcount
> 0)
10110 if ((*lgot_masks
& (TLS_TLS
| PLT_IFUNC
)) == PLT_IFUNC
)
10112 s
= htab
->elf
.iplt
;
10113 ent
->plt
.offset
= s
->size
;
10114 s
->size
+= PLT_ENTRY_SIZE (htab
);
10115 htab
->elf
.irelplt
->size
+= sizeof (Elf64_External_Rela
);
10117 else if (htab
->can_convert_all_inline_plt
10118 || (*lgot_masks
& (TLS_TLS
| PLT_KEEP
)) != PLT_KEEP
)
10119 ent
->plt
.offset
= (bfd_vma
) -1;
10122 s
= htab
->pltlocal
;
10123 ent
->plt
.offset
= s
->size
;
10124 s
->size
+= LOCAL_PLT_ENTRY_SIZE (htab
);
10125 if (bfd_link_pic (info
))
10126 htab
->relpltlocal
->size
+= sizeof (Elf64_External_Rela
);
10130 ent
->plt
.offset
= (bfd_vma
) -1;
10134 /* Allocate global sym .plt and .got entries, and space for global
10135 sym dynamic relocs. */
10136 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, info
);
10138 if (!htab
->opd_abi
&& !bfd_link_pic (info
))
10139 elf_link_hash_traverse (&htab
->elf
, size_global_entry_stubs
, info
);
10141 first_tlsld
= NULL
;
10142 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
10144 struct got_entry
*ent
;
10146 if (!is_ppc64_elf (ibfd
))
10149 ent
= ppc64_tlsld_got (ibfd
);
10150 if (ent
->got
.refcount
> 0)
10152 if (!htab
->do_multi_toc
&& first_tlsld
!= NULL
)
10154 ent
->is_indirect
= TRUE
;
10155 ent
->got
.ent
= first_tlsld
;
10159 if (first_tlsld
== NULL
)
10161 s
= ppc64_elf_tdata (ibfd
)->got
;
10162 ent
->got
.offset
= s
->size
;
10165 if (bfd_link_dll (info
))
10167 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
10168 srel
->size
+= sizeof (Elf64_External_Rela
);
10173 ent
->got
.offset
= (bfd_vma
) -1;
10176 /* We now have determined the sizes of the various dynamic sections.
10177 Allocate memory for them. */
10179 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
10181 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
10184 if (s
== htab
->brlt
|| s
== htab
->relbrlt
)
10185 /* These haven't been allocated yet; don't strip. */
10187 else if (s
== htab
->elf
.sgot
10188 || s
== htab
->elf
.splt
10189 || s
== htab
->elf
.iplt
10190 || s
== htab
->pltlocal
10191 || s
== htab
->glink
10192 || s
== htab
->global_entry
10193 || s
== htab
->elf
.sdynbss
10194 || s
== htab
->elf
.sdynrelro
)
10196 /* Strip this section if we don't need it; see the
10199 else if (s
== htab
->glink_eh_frame
)
10201 if (!bfd_is_abs_section (s
->output_section
))
10202 /* Not sized yet. */
10205 else if (CONST_STRNEQ (s
->name
, ".rela"))
10209 if (s
!= htab
->elf
.srelplt
)
10212 /* We use the reloc_count field as a counter if we need
10213 to copy relocs into the output file. */
10214 s
->reloc_count
= 0;
10219 /* It's not one of our sections, so don't allocate space. */
10225 /* If we don't need this section, strip it from the
10226 output file. This is mostly to handle .rela.bss and
10227 .rela.plt. We must create both sections in
10228 create_dynamic_sections, because they must be created
10229 before the linker maps input sections to output
10230 sections. The linker does that before
10231 adjust_dynamic_symbol is called, and it is that
10232 function which decides whether anything needs to go
10233 into these sections. */
10234 s
->flags
|= SEC_EXCLUDE
;
10238 if (bfd_is_abs_section (s
->output_section
))
10239 _bfd_error_handler (_("warning: discarding dynamic section %s"),
10242 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
10245 /* Allocate memory for the section contents. We use bfd_zalloc
10246 here in case unused entries are not reclaimed before the
10247 section's contents are written out. This should not happen,
10248 but this way if it does we get a R_PPC64_NONE reloc in .rela
10249 sections instead of garbage.
10250 We also rely on the section contents being zero when writing
10251 the GOT and .dynrelro. */
10252 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
10253 if (s
->contents
== NULL
)
10257 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
10259 if (!is_ppc64_elf (ibfd
))
10262 s
= ppc64_elf_tdata (ibfd
)->got
;
10263 if (s
!= NULL
&& s
!= htab
->elf
.sgot
)
10266 s
->flags
|= SEC_EXCLUDE
;
10269 s
->contents
= bfd_zalloc (ibfd
, s
->size
);
10270 if (s
->contents
== NULL
)
10274 s
= ppc64_elf_tdata (ibfd
)->relgot
;
10278 s
->flags
|= SEC_EXCLUDE
;
10281 s
->contents
= bfd_zalloc (ibfd
, s
->size
);
10282 if (s
->contents
== NULL
)
10285 s
->reloc_count
= 0;
10290 if (htab
->elf
.dynamic_sections_created
)
10292 bfd_boolean tls_opt
;
10294 /* Add some entries to the .dynamic section. We fill in the
10295 values later, in ppc64_elf_finish_dynamic_sections, but we
10296 must add the entries now so that we get the correct size for
10297 the .dynamic section. The DT_DEBUG entry is filled in by the
10298 dynamic linker and used by the debugger. */
10299 #define add_dynamic_entry(TAG, VAL) \
10300 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10302 if (bfd_link_executable (info
))
10304 if (!add_dynamic_entry (DT_DEBUG
, 0))
10308 if (htab
->elf
.splt
!= NULL
&& htab
->elf
.splt
->size
!= 0)
10310 if (!add_dynamic_entry (DT_PLTGOT
, 0)
10311 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
10312 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
10313 || !add_dynamic_entry (DT_JMPREL
, 0)
10314 || !add_dynamic_entry (DT_PPC64_GLINK
, 0))
10318 if (NO_OPD_RELOCS
&& abiversion (output_bfd
) <= 1)
10320 if (!add_dynamic_entry (DT_PPC64_OPD
, 0)
10321 || !add_dynamic_entry (DT_PPC64_OPDSZ
, 0))
10325 tls_opt
= (htab
->params
->tls_get_addr_opt
10326 && ((htab
->tls_get_addr_fd
!= NULL
10327 && htab
->tls_get_addr_fd
->elf
.plt
.plist
!= NULL
)
10328 || (htab
->tga_desc_fd
!= NULL
10329 && htab
->tga_desc_fd
->elf
.plt
.plist
!= NULL
)));
10330 if (tls_opt
|| !htab
->opd_abi
)
10332 if (!add_dynamic_entry (DT_PPC64_OPT
, tls_opt
? PPC64_OPT_TLS
: 0))
10338 if (!add_dynamic_entry (DT_RELA
, 0)
10339 || !add_dynamic_entry (DT_RELASZ
, 0)
10340 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf64_External_Rela
)))
10343 /* If any dynamic relocs apply to a read-only section,
10344 then we need a DT_TEXTREL entry. */
10345 if ((info
->flags
& DF_TEXTREL
) == 0)
10346 elf_link_hash_traverse (&htab
->elf
,
10347 _bfd_elf_maybe_set_textrel
, info
);
10349 if ((info
->flags
& DF_TEXTREL
) != 0)
10351 if (!add_dynamic_entry (DT_TEXTREL
, 0))
10356 #undef add_dynamic_entry
10361 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
10364 ppc64_elf_hash_symbol (struct elf_link_hash_entry
*h
)
10366 if (h
->plt
.plist
!= NULL
10368 && !h
->pointer_equality_needed
)
10371 return _bfd_elf_hash_symbol (h
);
10374 /* Determine the type of stub needed, if any, for a call. */
10376 static inline enum ppc_stub_type
10377 ppc_type_of_stub (asection
*input_sec
,
10378 const Elf_Internal_Rela
*rel
,
10379 struct ppc_link_hash_entry
**hash
,
10380 struct plt_entry
**plt_ent
,
10381 bfd_vma destination
,
10382 unsigned long local_off
)
10384 struct ppc_link_hash_entry
*h
= *hash
;
10386 bfd_vma branch_offset
;
10387 bfd_vma max_branch_offset
;
10388 enum elf_ppc64_reloc_type r_type
;
10392 struct plt_entry
*ent
;
10393 struct ppc_link_hash_entry
*fdh
= h
;
10395 && h
->oh
->is_func_descriptor
)
10397 fdh
= ppc_follow_link (h
->oh
);
10401 for (ent
= fdh
->elf
.plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
10402 if (ent
->addend
== rel
->r_addend
10403 && ent
->plt
.offset
!= (bfd_vma
) -1)
10406 return ppc_stub_plt_call
;
10409 /* Here, we know we don't have a plt entry. If we don't have a
10410 either a defined function descriptor or a defined entry symbol
10411 in a regular object file, then it is pointless trying to make
10412 any other type of stub. */
10413 if (!is_static_defined (&fdh
->elf
)
10414 && !is_static_defined (&h
->elf
))
10415 return ppc_stub_none
;
10417 else if (elf_local_got_ents (input_sec
->owner
) != NULL
)
10419 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (input_sec
->owner
);
10420 struct plt_entry
**local_plt
= (struct plt_entry
**)
10421 elf_local_got_ents (input_sec
->owner
) + symtab_hdr
->sh_info
;
10422 unsigned long r_symndx
= ELF64_R_SYM (rel
->r_info
);
10424 if (local_plt
[r_symndx
] != NULL
)
10426 struct plt_entry
*ent
;
10428 for (ent
= local_plt
[r_symndx
]; ent
!= NULL
; ent
= ent
->next
)
10429 if (ent
->addend
== rel
->r_addend
10430 && ent
->plt
.offset
!= (bfd_vma
) -1)
10433 return ppc_stub_plt_call
;
10438 /* Determine where the call point is. */
10439 location
= (input_sec
->output_offset
10440 + input_sec
->output_section
->vma
10443 branch_offset
= destination
- location
;
10444 r_type
= ELF64_R_TYPE (rel
->r_info
);
10446 /* Determine if a long branch stub is needed. */
10447 max_branch_offset
= 1 << 25;
10448 if (r_type
== R_PPC64_REL14
10449 || r_type
== R_PPC64_REL14_BRTAKEN
10450 || r_type
== R_PPC64_REL14_BRNTAKEN
)
10451 max_branch_offset
= 1 << 15;
10453 if (branch_offset
+ max_branch_offset
>= 2 * max_branch_offset
- local_off
)
10454 /* We need a stub. Figure out whether a long_branch or plt_branch
10455 is needed later. */
10456 return ppc_stub_long_branch
;
10458 return ppc_stub_none
;
10461 /* Gets the address of a label (1:) in r11 and builds an offset in r12,
10462 then adds it to r11 (LOAD false) or loads r12 from r11+r12 (LOAD true).
10467 . lis %r12,xxx-1b@highest
10468 . ori %r12,%r12,xxx-1b@higher
10469 . sldi %r12,%r12,32
10470 . oris %r12,%r12,xxx-1b@high
10471 . ori %r12,%r12,xxx-1b@l
10472 . add/ldx %r12,%r11,%r12 */
10475 build_offset (bfd
*abfd
, bfd_byte
*p
, bfd_vma off
, bfd_boolean load
)
10477 bfd_put_32 (abfd
, MFLR_R12
, p
);
10479 bfd_put_32 (abfd
, BCL_20_31
, p
);
10481 bfd_put_32 (abfd
, MFLR_R11
, p
);
10483 bfd_put_32 (abfd
, MTLR_R12
, p
);
10485 if (off
+ 0x8000 < 0x10000)
10488 bfd_put_32 (abfd
, LD_R12_0R11
+ PPC_LO (off
), p
);
10490 bfd_put_32 (abfd
, ADDI_R12_R11
+ PPC_LO (off
), p
);
10493 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10495 bfd_put_32 (abfd
, ADDIS_R12_R11
+ PPC_HA (off
), p
);
10498 bfd_put_32 (abfd
, LD_R12_0R12
+ PPC_LO (off
), p
);
10500 bfd_put_32 (abfd
, ADDI_R12_R12
+ PPC_LO (off
), p
);
10505 if (off
+ 0x800000000000ULL
< 0x1000000000000ULL
)
10507 bfd_put_32 (abfd
, LI_R12_0
+ ((off
>> 32) & 0xffff), p
);
10512 bfd_put_32 (abfd
, LIS_R12
+ ((off
>> 48) & 0xffff), p
);
10514 if (((off
>> 32) & 0xffff) != 0)
10516 bfd_put_32 (abfd
, ORI_R12_R12_0
+ ((off
>> 32) & 0xffff), p
);
10520 if (((off
>> 32) & 0xffffffffULL
) != 0)
10522 bfd_put_32 (abfd
, SLDI_R12_R12_32
, p
);
10525 if (PPC_HI (off
) != 0)
10527 bfd_put_32 (abfd
, ORIS_R12_R12_0
+ PPC_HI (off
), p
);
10530 if (PPC_LO (off
) != 0)
10532 bfd_put_32 (abfd
, ORI_R12_R12_0
+ PPC_LO (off
), p
);
10536 bfd_put_32 (abfd
, LDX_R12_R11_R12
, p
);
10538 bfd_put_32 (abfd
, ADD_R12_R11_R12
, p
);
10544 static unsigned int
10545 size_offset (bfd_vma off
)
10548 if (off
+ 0x8000 < 0x10000)
10550 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10554 if (off
+ 0x800000000000ULL
< 0x1000000000000ULL
)
10559 if (((off
>> 32) & 0xffff) != 0)
10562 if (((off
>> 32) & 0xffffffffULL
) != 0)
10564 if (PPC_HI (off
) != 0)
10566 if (PPC_LO (off
) != 0)
10573 static unsigned int
10574 num_relocs_for_offset (bfd_vma off
)
10576 unsigned int num_rel
;
10577 if (off
+ 0x8000 < 0x10000)
10579 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10584 if (off
+ 0x800000000000ULL
>= 0x1000000000000ULL
10585 && ((off
>> 32) & 0xffff) != 0)
10587 if (PPC_HI (off
) != 0)
10589 if (PPC_LO (off
) != 0)
10595 static Elf_Internal_Rela
*
10596 emit_relocs_for_offset (struct bfd_link_info
*info
, Elf_Internal_Rela
*r
,
10597 bfd_vma roff
, bfd_vma targ
, bfd_vma off
)
10599 bfd_vma relative_targ
= targ
- (roff
- 8);
10600 if (bfd_big_endian (info
->output_bfd
))
10602 r
->r_offset
= roff
;
10603 r
->r_addend
= relative_targ
+ roff
;
10604 if (off
+ 0x8000 < 0x10000)
10605 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16
);
10606 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10608 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HA
);
10611 r
->r_offset
= roff
;
10612 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_LO
);
10613 r
->r_addend
= relative_targ
+ roff
;
10617 if (off
+ 0x800000000000ULL
< 0x1000000000000ULL
)
10618 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHER
);
10621 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHEST
);
10622 if (((off
>> 32) & 0xffff) != 0)
10626 r
->r_offset
= roff
;
10627 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHER
);
10628 r
->r_addend
= relative_targ
+ roff
;
10631 if (((off
>> 32) & 0xffffffffULL
) != 0)
10633 if (PPC_HI (off
) != 0)
10637 r
->r_offset
= roff
;
10638 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGH
);
10639 r
->r_addend
= relative_targ
+ roff
;
10641 if (PPC_LO (off
) != 0)
10645 r
->r_offset
= roff
;
10646 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_LO
);
10647 r
->r_addend
= relative_targ
+ roff
;
10654 build_power10_offset (bfd
*abfd
, bfd_byte
*p
, bfd_vma off
, int odd
,
10658 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10663 bfd_put_32 (abfd
, NOP
, p
);
10669 insn
= PADDI_R12_PC
;
10671 bfd_put_32 (abfd
, insn
>> 32, p
);
10673 bfd_put_32 (abfd
, insn
, p
);
10675 /* The minimum value for paddi is -0x200000000. The minimum value
10676 for li is -0x8000, which when shifted by 34 and added gives a
10677 minimum value of -0x2000200000000. The maximum value is
10678 0x1ffffffff+0x7fff<<34 which is 0x2000200000000-1. */
10679 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10682 bfd_put_32 (abfd
, LI_R11_0
| (HA34 (off
) & 0xffff), p
);
10686 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10689 insn
= PADDI_R12_PC
| D34 (off
);
10690 bfd_put_32 (abfd
, insn
>> 32, p
);
10692 bfd_put_32 (abfd
, insn
, p
);
10696 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10700 bfd_put_32 (abfd
, LDX_R12_R11_R12
, p
);
10702 bfd_put_32 (abfd
, ADD_R12_R11_R12
, p
);
10707 bfd_put_32 (abfd
, LIS_R11
| ((HA34 (off
) >> 16) & 0x3fff), p
);
10709 bfd_put_32 (abfd
, ORI_R11_R11_0
| (HA34 (off
) & 0xffff), p
);
10713 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10716 insn
= PADDI_R12_PC
| D34 (off
);
10717 bfd_put_32 (abfd
, insn
>> 32, p
);
10719 bfd_put_32 (abfd
, insn
, p
);
10723 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10727 bfd_put_32 (abfd
, LDX_R12_R11_R12
, p
);
10729 bfd_put_32 (abfd
, ADD_R12_R11_R12
, p
);
10735 static unsigned int
10736 size_power10_offset (bfd_vma off
, int odd
)
10738 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10740 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10746 static unsigned int
10747 num_relocs_for_power10_offset (bfd_vma off
, int odd
)
10749 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10751 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10757 static Elf_Internal_Rela
*
10758 emit_relocs_for_power10_offset (struct bfd_link_info
*info
,
10759 Elf_Internal_Rela
*r
, bfd_vma roff
,
10760 bfd_vma targ
, bfd_vma off
, int odd
)
10762 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10764 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10766 int d_offset
= bfd_big_endian (info
->output_bfd
) ? 2 : 0;
10767 r
->r_offset
= roff
+ d_offset
;
10768 r
->r_addend
= targ
+ 8 - odd
- d_offset
;
10769 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHERA34
);
10775 int d_offset
= bfd_big_endian (info
->output_bfd
) ? 2 : 0;
10776 r
->r_offset
= roff
+ d_offset
;
10777 r
->r_addend
= targ
+ 8 + odd
- d_offset
;
10778 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHESTA34
);
10781 r
->r_offset
= roff
+ d_offset
;
10782 r
->r_addend
= targ
+ 4 + odd
- d_offset
;
10783 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHERA34
);
10787 r
->r_offset
= roff
;
10788 r
->r_addend
= targ
;
10789 r
->r_info
= ELF64_R_INFO (0, R_PPC64_PCREL34
);
10793 /* Emit .eh_frame opcode to advance pc by DELTA. */
10796 eh_advance (bfd
*abfd
, bfd_byte
*eh
, unsigned int delta
)
10800 *eh
++ = DW_CFA_advance_loc
+ delta
;
10801 else if (delta
< 256)
10803 *eh
++ = DW_CFA_advance_loc1
;
10806 else if (delta
< 65536)
10808 *eh
++ = DW_CFA_advance_loc2
;
10809 bfd_put_16 (abfd
, delta
, eh
);
10814 *eh
++ = DW_CFA_advance_loc4
;
10815 bfd_put_32 (abfd
, delta
, eh
);
10821 /* Size of required .eh_frame opcode to advance pc by DELTA. */
10823 static unsigned int
10824 eh_advance_size (unsigned int delta
)
10826 if (delta
< 64 * 4)
10827 /* DW_CFA_advance_loc+[1..63]. */
10829 if (delta
< 256 * 4)
10830 /* DW_CFA_advance_loc1, byte. */
10832 if (delta
< 65536 * 4)
10833 /* DW_CFA_advance_loc2, 2 bytes. */
10835 /* DW_CFA_advance_loc4, 4 bytes. */
10839 /* With power7 weakly ordered memory model, it is possible for ld.so
10840 to update a plt entry in one thread and have another thread see a
10841 stale zero toc entry. To avoid this we need some sort of acquire
10842 barrier in the call stub. One solution is to make the load of the
10843 toc word seem to appear to depend on the load of the function entry
10844 word. Another solution is to test for r2 being zero, and branch to
10845 the appropriate glink entry if so.
10847 . fake dep barrier compare
10848 . ld 12,xxx(2) ld 12,xxx(2)
10849 . mtctr 12 mtctr 12
10850 . xor 11,12,12 ld 2,xxx+8(2)
10851 . add 2,2,11 cmpldi 2,0
10852 . ld 2,xxx+8(2) bnectr+
10853 . bctr b <glink_entry>
10855 The solution involving the compare turns out to be faster, so
10856 that's what we use unless the branch won't reach. */
10858 #define ALWAYS_USE_FAKE_DEP 0
10859 #define ALWAYS_EMIT_R2SAVE 0
10861 static inline unsigned int
10862 plt_stub_size (struct ppc_link_hash_table
*htab
,
10863 struct ppc_stub_hash_entry
*stub_entry
,
10869 if (stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
)
10871 if (htab
->params
->power10_stubs
!= 0)
10872 size
= 8 + size_power10_offset (off
, odd
);
10874 size
= 8 + size_offset (off
- 8);
10875 if (stub_entry
->stub_type
> ppc_stub_plt_call_notoc
)
10881 if (ALWAYS_EMIT_R2SAVE
10882 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10884 if (PPC_HA (off
) != 0)
10889 if (htab
->params
->plt_static_chain
)
10891 if (htab
->params
->plt_thread_safe
10892 && htab
->elf
.dynamic_sections_created
10893 && stub_entry
->h
!= NULL
10894 && stub_entry
->h
->elf
.dynindx
!= -1)
10896 if (PPC_HA (off
+ 8 + 8 * htab
->params
->plt_static_chain
)
10901 if (stub_entry
->h
!= NULL
10902 && is_tls_get_addr (&stub_entry
->h
->elf
, htab
)
10903 && htab
->params
->tls_get_addr_opt
)
10905 if (!htab
->params
->no_tls_get_addr_regsave
)
10908 if (stub_entry
->stub_type
== ppc_stub_plt_call_r2save
10909 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
10915 if (stub_entry
->stub_type
== ppc_stub_plt_call_r2save
10916 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
10923 /* Depending on the sign of plt_stub_align:
10924 If positive, return the padding to align to a 2**plt_stub_align
10926 If negative, if this stub would cross fewer 2**plt_stub_align
10927 boundaries if we align, then return the padding needed to do so. */
10929 static inline unsigned int
10930 plt_stub_pad (struct ppc_link_hash_table
*htab
,
10931 struct ppc_stub_hash_entry
*stub_entry
,
10936 unsigned stub_size
;
10937 bfd_vma stub_off
= stub_entry
->group
->stub_sec
->size
;
10939 if (htab
->params
->plt_stub_align
>= 0)
10941 stub_align
= 1 << htab
->params
->plt_stub_align
;
10942 if ((stub_off
& (stub_align
- 1)) != 0)
10943 return stub_align
- (stub_off
& (stub_align
- 1));
10947 stub_align
= 1 << -htab
->params
->plt_stub_align
;
10948 stub_size
= plt_stub_size (htab
, stub_entry
, plt_off
, odd
);
10949 if (((stub_off
+ stub_size
- 1) & -stub_align
) - (stub_off
& -stub_align
)
10950 > ((stub_size
- 1) & -stub_align
))
10951 return stub_align
- (stub_off
& (stub_align
- 1));
10955 /* Build a .plt call stub. */
10957 static inline bfd_byte
*
10958 build_plt_stub (struct ppc_link_hash_table
*htab
,
10959 struct ppc_stub_hash_entry
*stub_entry
,
10960 bfd_byte
*p
, bfd_vma offset
, Elf_Internal_Rela
*r
)
10962 bfd
*obfd
= htab
->params
->stub_bfd
;
10963 bfd_boolean plt_load_toc
= htab
->opd_abi
;
10964 bfd_boolean plt_static_chain
= htab
->params
->plt_static_chain
;
10965 bfd_boolean plt_thread_safe
= (htab
->params
->plt_thread_safe
10966 && htab
->elf
.dynamic_sections_created
10967 && stub_entry
->h
!= NULL
10968 && stub_entry
->h
->elf
.dynindx
!= -1);
10969 bfd_boolean use_fake_dep
= plt_thread_safe
;
10970 bfd_vma cmp_branch_off
= 0;
10972 if (!ALWAYS_USE_FAKE_DEP
10975 && !(stub_entry
->h
!= NULL
10976 && is_tls_get_addr (&stub_entry
->h
->elf
, htab
)
10977 && htab
->params
->tls_get_addr_opt
))
10979 bfd_vma pltoff
= stub_entry
->plt_ent
->plt
.offset
& ~1;
10980 bfd_vma pltindex
= ((pltoff
- PLT_INITIAL_ENTRY_SIZE (htab
))
10981 / PLT_ENTRY_SIZE (htab
));
10982 bfd_vma glinkoff
= GLINK_PLTRESOLVE_SIZE (htab
) + pltindex
* 8;
10985 if (pltindex
> 32768)
10986 glinkoff
+= (pltindex
- 32768) * 4;
10988 + htab
->glink
->output_offset
10989 + htab
->glink
->output_section
->vma
);
10990 from
= (p
- stub_entry
->group
->stub_sec
->contents
10991 + 4 * (ALWAYS_EMIT_R2SAVE
10992 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10993 + 4 * (PPC_HA (offset
) != 0)
10994 + 4 * (PPC_HA (offset
+ 8 + 8 * plt_static_chain
)
10995 != PPC_HA (offset
))
10996 + 4 * (plt_static_chain
!= 0)
10998 + stub_entry
->group
->stub_sec
->output_offset
10999 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11000 cmp_branch_off
= to
- from
;
11001 use_fake_dep
= cmp_branch_off
+ (1 << 25) >= (1 << 26);
11004 if (PPC_HA (offset
) != 0)
11008 if (ALWAYS_EMIT_R2SAVE
11009 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
11010 r
[0].r_offset
+= 4;
11011 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_HA
);
11012 r
[1].r_offset
= r
[0].r_offset
+ 4;
11013 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
11014 r
[1].r_addend
= r
[0].r_addend
;
11017 if (PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
11019 r
[2].r_offset
= r
[1].r_offset
+ 4;
11020 r
[2].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO
);
11021 r
[2].r_addend
= r
[0].r_addend
;
11025 r
[2].r_offset
= r
[1].r_offset
+ 8 + 8 * use_fake_dep
;
11026 r
[2].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
11027 r
[2].r_addend
= r
[0].r_addend
+ 8;
11028 if (plt_static_chain
)
11030 r
[3].r_offset
= r
[2].r_offset
+ 4;
11031 r
[3].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
11032 r
[3].r_addend
= r
[0].r_addend
+ 16;
11037 if (ALWAYS_EMIT_R2SAVE
11038 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
11039 bfd_put_32 (obfd
, STD_R2_0R1
+ STK_TOC (htab
), p
), p
+= 4;
11042 bfd_put_32 (obfd
, ADDIS_R11_R2
| PPC_HA (offset
), p
), p
+= 4;
11043 bfd_put_32 (obfd
, LD_R12_0R11
| PPC_LO (offset
), p
), p
+= 4;
11047 bfd_put_32 (obfd
, ADDIS_R12_R2
| PPC_HA (offset
), p
), p
+= 4;
11048 bfd_put_32 (obfd
, LD_R12_0R12
| PPC_LO (offset
), p
), p
+= 4;
11051 && PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
11053 bfd_put_32 (obfd
, ADDI_R11_R11
| PPC_LO (offset
), p
), p
+= 4;
11056 bfd_put_32 (obfd
, MTCTR_R12
, p
), p
+= 4;
11061 bfd_put_32 (obfd
, XOR_R2_R12_R12
, p
), p
+= 4;
11062 bfd_put_32 (obfd
, ADD_R11_R11_R2
, p
), p
+= 4;
11064 bfd_put_32 (obfd
, LD_R2_0R11
| PPC_LO (offset
+ 8), p
), p
+= 4;
11065 if (plt_static_chain
)
11066 bfd_put_32 (obfd
, LD_R11_0R11
| PPC_LO (offset
+ 16), p
), p
+= 4;
11073 if (ALWAYS_EMIT_R2SAVE
11074 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
11075 r
[0].r_offset
+= 4;
11076 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
11079 if (PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
11081 r
[1].r_offset
= r
[0].r_offset
+ 4;
11082 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16
);
11083 r
[1].r_addend
= r
[0].r_addend
;
11087 r
[1].r_offset
= r
[0].r_offset
+ 8 + 8 * use_fake_dep
;
11088 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
11089 r
[1].r_addend
= r
[0].r_addend
+ 8 + 8 * plt_static_chain
;
11090 if (plt_static_chain
)
11092 r
[2].r_offset
= r
[1].r_offset
+ 4;
11093 r
[2].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
11094 r
[2].r_addend
= r
[0].r_addend
+ 8;
11099 if (ALWAYS_EMIT_R2SAVE
11100 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
11101 bfd_put_32 (obfd
, STD_R2_0R1
+ STK_TOC (htab
), p
), p
+= 4;
11102 bfd_put_32 (obfd
, LD_R12_0R2
| PPC_LO (offset
), p
), p
+= 4;
11104 && PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
11106 bfd_put_32 (obfd
, ADDI_R2_R2
| PPC_LO (offset
), p
), p
+= 4;
11109 bfd_put_32 (obfd
, MTCTR_R12
, p
), p
+= 4;
11114 bfd_put_32 (obfd
, XOR_R11_R12_R12
, p
), p
+= 4;
11115 bfd_put_32 (obfd
, ADD_R2_R2_R11
, p
), p
+= 4;
11117 if (plt_static_chain
)
11118 bfd_put_32 (obfd
, LD_R11_0R2
| PPC_LO (offset
+ 16), p
), p
+= 4;
11119 bfd_put_32 (obfd
, LD_R2_0R2
| PPC_LO (offset
+ 8), p
), p
+= 4;
11122 if (plt_load_toc
&& plt_thread_safe
&& !use_fake_dep
)
11124 bfd_put_32 (obfd
, CMPLDI_R2_0
, p
), p
+= 4;
11125 bfd_put_32 (obfd
, BNECTR_P4
, p
), p
+= 4;
11126 bfd_put_32 (obfd
, B_DOT
| (cmp_branch_off
& 0x3fffffc), p
), p
+= 4;
11129 bfd_put_32 (obfd
, BCTR
, p
), p
+= 4;
11133 /* Build a special .plt call stub for __tls_get_addr. */
11135 #define LD_R0_0R3 0xe8030000
11136 #define LD_R12_0R3 0xe9830000
11137 #define MR_R0_R3 0x7c601b78
11138 #define CMPDI_R0_0 0x2c200000
11139 #define ADD_R3_R12_R13 0x7c6c6a14
11140 #define BEQLR 0x4d820020
11141 #define MR_R3_R0 0x7c030378
11142 #define BCTRL 0x4e800421
11145 build_tls_get_addr_head (struct ppc_link_hash_table
*htab
,
11146 struct ppc_stub_hash_entry
*stub_entry
,
11149 bfd
*obfd
= htab
->params
->stub_bfd
;
11151 bfd_put_32 (obfd
, LD_R0_0R3
+ 0, p
), p
+= 4;
11152 bfd_put_32 (obfd
, LD_R12_0R3
+ 8, p
), p
+= 4;
11153 bfd_put_32 (obfd
, CMPDI_R0_0
, p
), p
+= 4;
11154 bfd_put_32 (obfd
, MR_R0_R3
, p
), p
+= 4;
11155 bfd_put_32 (obfd
, ADD_R3_R12_R13
, p
), p
+= 4;
11156 bfd_put_32 (obfd
, BEQLR
, p
), p
+= 4;
11157 bfd_put_32 (obfd
, MR_R3_R0
, p
), p
+= 4;
11159 if (!htab
->params
->no_tls_get_addr_regsave
)
11160 p
= tls_get_addr_prologue (obfd
, p
, htab
);
11161 else if (stub_entry
->stub_type
== ppc_stub_plt_call_r2save
11162 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
11164 bfd_put_32 (obfd
, MFLR_R0
, p
);
11166 bfd_put_32 (obfd
, STD_R0_0R1
+ STK_LINKER (htab
), p
);
11173 build_tls_get_addr_tail (struct ppc_link_hash_table
*htab
,
11174 struct ppc_stub_hash_entry
*stub_entry
,
11178 bfd
*obfd
= htab
->params
->stub_bfd
;
11180 if (!htab
->params
->no_tls_get_addr_regsave
)
11182 bfd_put_32 (obfd
, BCTRL
, p
- 4);
11184 if (stub_entry
->stub_type
== ppc_stub_plt_call_r2save
11185 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
11187 bfd_put_32 (obfd
, LD_R2_0R1
+ STK_TOC (htab
), p
);
11190 p
= tls_get_addr_epilogue (obfd
, p
, htab
);
11192 else if (stub_entry
->stub_type
== ppc_stub_plt_call_r2save
11193 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
11195 bfd_put_32 (obfd
, BCTRL
, p
- 4);
11197 bfd_put_32 (obfd
, LD_R2_0R1
+ STK_TOC (htab
), p
);
11199 bfd_put_32 (obfd
, LD_R0_0R1
+ STK_LINKER (htab
), p
);
11201 bfd_put_32 (obfd
, MTLR_R0
, p
);
11203 bfd_put_32 (obfd
, BLR
, p
);
11207 if (htab
->glink_eh_frame
!= NULL
11208 && htab
->glink_eh_frame
->size
!= 0)
11210 bfd_byte
*base
, *eh
;
11212 base
= htab
->glink_eh_frame
->contents
+ stub_entry
->group
->eh_base
+ 17;
11213 eh
= base
+ stub_entry
->group
->eh_size
;
11215 if (!htab
->params
->no_tls_get_addr_regsave
)
11217 unsigned int cfa_updt
, delta
, i
;
11219 /* After the bctrl, lr has been modified so we need to emit
11220 .eh_frame info saying the return address is on the stack. In
11221 fact we must put the EH info at or before the call rather
11222 than after it, because the EH info for a call needs to be
11223 specified by that point.
11224 See libgcc/unwind-dw2.c execute_cfa_program.
11225 Any stack pointer update must be described immediately after
11226 the instruction making the change, and since the stdu occurs
11227 after saving regs we put all the reg saves and the cfa
11229 cfa_updt
= stub_entry
->stub_offset
+ 18 * 4;
11230 delta
= cfa_updt
- stub_entry
->group
->lr_restore
;
11231 stub_entry
->group
->lr_restore
11232 = stub_entry
->stub_offset
+ (p
- loc
) - 4;
11233 eh
= eh_advance (htab
->elf
.dynobj
, eh
, delta
);
11234 *eh
++ = DW_CFA_def_cfa_offset
;
11242 *eh
++ = DW_CFA_offset_extended_sf
;
11244 *eh
++ = (-16 / 8) & 0x7f;
11245 for (i
= 4; i
< 12; i
++)
11247 *eh
++ = DW_CFA_offset
+ i
;
11248 *eh
++ = (htab
->opd_abi
? 13 : 12) - i
;
11250 *eh
++ = (DW_CFA_advance_loc
11251 + (stub_entry
->group
->lr_restore
- 8 - cfa_updt
) / 4);
11252 *eh
++ = DW_CFA_def_cfa_offset
;
11254 for (i
= 4; i
< 12; i
++)
11255 *eh
++ = DW_CFA_restore
+ i
;
11256 *eh
++ = DW_CFA_advance_loc
+ 2;
11257 *eh
++ = DW_CFA_restore_extended
;
11259 stub_entry
->group
->eh_size
= eh
- base
;
11261 else if (stub_entry
->stub_type
== ppc_stub_plt_call_r2save
11262 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
11264 unsigned int lr_used
, delta
;
11266 lr_used
= stub_entry
->stub_offset
+ (p
- 20 - loc
);
11267 delta
= lr_used
- stub_entry
->group
->lr_restore
;
11268 stub_entry
->group
->lr_restore
= lr_used
+ 16;
11269 eh
= eh_advance (htab
->elf
.dynobj
, eh
, delta
);
11270 *eh
++ = DW_CFA_offset_extended_sf
;
11272 *eh
++ = -(STK_LINKER (htab
) / 8) & 0x7f;
11273 *eh
++ = DW_CFA_advance_loc
+ 4;
11274 *eh
++ = DW_CFA_restore_extended
;
11276 stub_entry
->group
->eh_size
= eh
- base
;
11282 static Elf_Internal_Rela
*
11283 get_relocs (asection
*sec
, int count
)
11285 Elf_Internal_Rela
*relocs
;
11286 struct bfd_elf_section_data
*elfsec_data
;
11288 elfsec_data
= elf_section_data (sec
);
11289 relocs
= elfsec_data
->relocs
;
11290 if (relocs
== NULL
)
11292 bfd_size_type relsize
;
11293 relsize
= sec
->reloc_count
* sizeof (*relocs
);
11294 relocs
= bfd_alloc (sec
->owner
, relsize
);
11295 if (relocs
== NULL
)
11297 elfsec_data
->relocs
= relocs
;
11298 elfsec_data
->rela
.hdr
= bfd_zalloc (sec
->owner
,
11299 sizeof (Elf_Internal_Shdr
));
11300 if (elfsec_data
->rela
.hdr
== NULL
)
11302 elfsec_data
->rela
.hdr
->sh_size
= (sec
->reloc_count
11303 * sizeof (Elf64_External_Rela
));
11304 elfsec_data
->rela
.hdr
->sh_entsize
= sizeof (Elf64_External_Rela
);
11305 sec
->reloc_count
= 0;
11307 relocs
+= sec
->reloc_count
;
11308 sec
->reloc_count
+= count
;
11312 /* Convert the relocs R[0] thru R[-NUM_REL+1], which are all no-symbol
11313 forms, to the equivalent relocs against the global symbol given by
11317 use_global_in_relocs (struct ppc_link_hash_table
*htab
,
11318 struct ppc_stub_hash_entry
*stub_entry
,
11319 Elf_Internal_Rela
*r
, unsigned int num_rel
)
11321 struct elf_link_hash_entry
**hashes
;
11322 unsigned long symndx
;
11323 struct ppc_link_hash_entry
*h
;
11326 /* Relocs are always against symbols in their own object file. Fake
11327 up global sym hashes for the stub bfd (which has no symbols). */
11328 hashes
= elf_sym_hashes (htab
->params
->stub_bfd
);
11329 if (hashes
== NULL
)
11331 bfd_size_type hsize
;
11333 /* When called the first time, stub_globals will contain the
11334 total number of symbols seen during stub sizing. After
11335 allocating, stub_globals is used as an index to fill the
11337 hsize
= (htab
->stub_globals
+ 1) * sizeof (*hashes
);
11338 hashes
= bfd_zalloc (htab
->params
->stub_bfd
, hsize
);
11339 if (hashes
== NULL
)
11341 elf_sym_hashes (htab
->params
->stub_bfd
) = hashes
;
11342 htab
->stub_globals
= 1;
11344 symndx
= htab
->stub_globals
++;
11346 hashes
[symndx
] = &h
->elf
;
11347 if (h
->oh
!= NULL
&& h
->oh
->is_func
)
11348 h
= ppc_follow_link (h
->oh
);
11349 BFD_ASSERT (h
->elf
.root
.type
== bfd_link_hash_defined
11350 || h
->elf
.root
.type
== bfd_link_hash_defweak
);
11351 symval
= defined_sym_val (&h
->elf
);
11352 while (num_rel
-- != 0)
11354 r
->r_info
= ELF64_R_INFO (symndx
, ELF64_R_TYPE (r
->r_info
));
11355 if (h
->elf
.root
.u
.def
.section
!= stub_entry
->target_section
)
11357 /* H is an opd symbol. The addend must be zero, and the
11358 branch reloc is the only one we can convert. */
11363 r
->r_addend
-= symval
;
11370 get_r2off (struct bfd_link_info
*info
,
11371 struct ppc_stub_hash_entry
*stub_entry
)
11373 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
11374 bfd_vma r2off
= htab
->sec_info
[stub_entry
->target_section
->id
].toc_off
;
11378 /* Support linking -R objects. Get the toc pointer from the
11381 if (!htab
->opd_abi
)
11383 asection
*opd
= stub_entry
->h
->elf
.root
.u
.def
.section
;
11384 bfd_vma opd_off
= stub_entry
->h
->elf
.root
.u
.def
.value
;
11386 if (strcmp (opd
->name
, ".opd") != 0
11387 || opd
->reloc_count
!= 0)
11389 info
->callbacks
->einfo
11390 (_("%P: cannot find opd entry toc for `%pT'\n"),
11391 stub_entry
->h
->elf
.root
.root
.string
);
11392 bfd_set_error (bfd_error_bad_value
);
11393 return (bfd_vma
) -1;
11395 if (!bfd_get_section_contents (opd
->owner
, opd
, buf
, opd_off
+ 8, 8))
11396 return (bfd_vma
) -1;
11397 r2off
= bfd_get_64 (opd
->owner
, buf
);
11398 r2off
-= elf_gp (info
->output_bfd
);
11400 r2off
-= htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
;
11405 ppc_build_one_stub (struct bfd_hash_entry
*gen_entry
, void *in_arg
)
11407 struct ppc_stub_hash_entry
*stub_entry
;
11408 struct ppc_branch_hash_entry
*br_entry
;
11409 struct bfd_link_info
*info
;
11410 struct ppc_link_hash_table
*htab
;
11413 bfd_byte
*p
, *relp
;
11415 Elf_Internal_Rela
*r
;
11419 bfd_boolean is_tga
;
11421 /* Massage our args to the form they really have. */
11422 stub_entry
= (struct ppc_stub_hash_entry
*) gen_entry
;
11425 /* Fail if the target section could not be assigned to an output
11426 section. The user should fix his linker script. */
11427 if (stub_entry
->target_section
!= NULL
11428 && stub_entry
->target_section
->output_section
== NULL
11429 && info
->non_contiguous_regions
)
11430 info
->callbacks
->einfo (_("%F%P: Could not assign '%pA' to an output section. "
11431 "Retry without --enable-non-contiguous-regions.\n"),
11432 stub_entry
->target_section
);
11434 /* Same for the group. */
11435 if (stub_entry
->group
->stub_sec
!= NULL
11436 && stub_entry
->group
->stub_sec
->output_section
== NULL
11437 && info
->non_contiguous_regions
)
11438 info
->callbacks
->einfo (_("%F%P: Could not assign group %pA target %pA to an "
11439 "output section. Retry without "
11440 "--enable-non-contiguous-regions.\n"),
11441 stub_entry
->group
->stub_sec
,
11442 stub_entry
->target_section
);
11444 htab
= ppc_hash_table (info
);
11448 BFD_ASSERT (stub_entry
->stub_offset
>= stub_entry
->group
->stub_sec
->size
);
11449 loc
= stub_entry
->group
->stub_sec
->contents
+ stub_entry
->stub_offset
;
11451 htab
->stub_count
[stub_entry
->stub_type
- 1] += 1;
11452 switch (stub_entry
->stub_type
)
11454 case ppc_stub_long_branch
:
11455 case ppc_stub_long_branch_r2off
:
11456 /* Branches are relative. This is where we are going to. */
11457 targ
= (stub_entry
->target_value
11458 + stub_entry
->target_section
->output_offset
11459 + stub_entry
->target_section
->output_section
->vma
);
11460 targ
+= PPC64_LOCAL_ENTRY_OFFSET (stub_entry
->other
);
11462 /* And this is where we are coming from. */
11463 off
= (stub_entry
->stub_offset
11464 + stub_entry
->group
->stub_sec
->output_offset
11465 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11469 obfd
= htab
->params
->stub_bfd
;
11470 if (stub_entry
->stub_type
== ppc_stub_long_branch_r2off
)
11472 bfd_vma r2off
= get_r2off (info
, stub_entry
);
11474 if (r2off
== (bfd_vma
) -1)
11476 htab
->stub_error
= TRUE
;
11479 bfd_put_32 (obfd
, STD_R2_0R1
+ STK_TOC (htab
), p
);
11481 if (PPC_HA (r2off
) != 0)
11483 bfd_put_32 (obfd
, ADDIS_R2_R2
| PPC_HA (r2off
), p
);
11486 if (PPC_LO (r2off
) != 0)
11488 bfd_put_32 (obfd
, ADDI_R2_R2
| PPC_LO (r2off
), p
);
11493 bfd_put_32 (obfd
, B_DOT
| (off
& 0x3fffffc), p
);
11496 if (off
+ (1 << 25) >= (bfd_vma
) (1 << 26))
11499 (_("long branch stub `%s' offset overflow"),
11500 stub_entry
->root
.string
);
11501 htab
->stub_error
= TRUE
;
11505 if (info
->emitrelocations
)
11507 r
= get_relocs (stub_entry
->group
->stub_sec
, 1);
11510 r
->r_offset
= p
- 4 - stub_entry
->group
->stub_sec
->contents
;
11511 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL24
);
11512 r
->r_addend
= targ
;
11513 if (stub_entry
->h
!= NULL
11514 && !use_global_in_relocs (htab
, stub_entry
, r
, 1))
11519 case ppc_stub_plt_branch
:
11520 case ppc_stub_plt_branch_r2off
:
11521 br_entry
= ppc_branch_hash_lookup (&htab
->branch_hash_table
,
11522 stub_entry
->root
.string
+ 9,
11524 if (br_entry
== NULL
)
11526 _bfd_error_handler (_("can't find branch stub `%s'"),
11527 stub_entry
->root
.string
);
11528 htab
->stub_error
= TRUE
;
11532 targ
= (stub_entry
->target_value
11533 + stub_entry
->target_section
->output_offset
11534 + stub_entry
->target_section
->output_section
->vma
);
11535 if (stub_entry
->stub_type
!= ppc_stub_plt_branch_r2off
)
11536 targ
+= PPC64_LOCAL_ENTRY_OFFSET (stub_entry
->other
);
11538 bfd_put_64 (htab
->brlt
->owner
, targ
,
11539 htab
->brlt
->contents
+ br_entry
->offset
);
11541 if (br_entry
->iter
== htab
->stub_iteration
)
11543 br_entry
->iter
= 0;
11545 if (htab
->relbrlt
!= NULL
)
11547 /* Create a reloc for the branch lookup table entry. */
11548 Elf_Internal_Rela rela
;
11551 rela
.r_offset
= (br_entry
->offset
11552 + htab
->brlt
->output_offset
11553 + htab
->brlt
->output_section
->vma
);
11554 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
11555 rela
.r_addend
= targ
;
11557 rl
= htab
->relbrlt
->contents
;
11558 rl
+= (htab
->relbrlt
->reloc_count
++
11559 * sizeof (Elf64_External_Rela
));
11560 bfd_elf64_swap_reloca_out (htab
->relbrlt
->owner
, &rela
, rl
);
11562 else if (info
->emitrelocations
)
11564 r
= get_relocs (htab
->brlt
, 1);
11567 /* brlt, being SEC_LINKER_CREATED does not go through the
11568 normal reloc processing. Symbols and offsets are not
11569 translated from input file to output file form, so
11570 set up the offset per the output file. */
11571 r
->r_offset
= (br_entry
->offset
11572 + htab
->brlt
->output_offset
11573 + htab
->brlt
->output_section
->vma
);
11574 r
->r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
11575 r
->r_addend
= targ
;
11579 targ
= (br_entry
->offset
11580 + htab
->brlt
->output_offset
11581 + htab
->brlt
->output_section
->vma
);
11583 off
= (elf_gp (info
->output_bfd
)
11584 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
11587 if (off
+ 0x80008000 > 0xffffffff || (off
& 7) != 0)
11589 info
->callbacks
->einfo
11590 (_("%P: linkage table error against `%pT'\n"),
11591 stub_entry
->root
.string
);
11592 bfd_set_error (bfd_error_bad_value
);
11593 htab
->stub_error
= TRUE
;
11597 if (info
->emitrelocations
)
11599 r
= get_relocs (stub_entry
->group
->stub_sec
, 1 + (PPC_HA (off
) != 0));
11602 r
[0].r_offset
= loc
- stub_entry
->group
->stub_sec
->contents
;
11603 if (bfd_big_endian (info
->output_bfd
))
11604 r
[0].r_offset
+= 2;
11605 if (stub_entry
->stub_type
== ppc_stub_plt_branch_r2off
)
11606 r
[0].r_offset
+= 4;
11607 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
11608 r
[0].r_addend
= targ
;
11609 if (PPC_HA (off
) != 0)
11611 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_HA
);
11612 r
[1].r_offset
= r
[0].r_offset
+ 4;
11613 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
11614 r
[1].r_addend
= r
[0].r_addend
;
11619 obfd
= htab
->params
->stub_bfd
;
11620 if (stub_entry
->stub_type
!= ppc_stub_plt_branch_r2off
)
11622 if (PPC_HA (off
) != 0)
11624 bfd_put_32 (obfd
, ADDIS_R12_R2
| PPC_HA (off
), p
);
11626 bfd_put_32 (obfd
, LD_R12_0R12
| PPC_LO (off
), p
);
11629 bfd_put_32 (obfd
, LD_R12_0R2
| PPC_LO (off
), p
);
11633 bfd_vma r2off
= get_r2off (info
, stub_entry
);
11635 if (r2off
== (bfd_vma
) -1)
11637 htab
->stub_error
= TRUE
;
11641 bfd_put_32 (obfd
, STD_R2_0R1
+ STK_TOC (htab
), p
);
11643 if (PPC_HA (off
) != 0)
11645 bfd_put_32 (obfd
, ADDIS_R12_R2
| PPC_HA (off
), p
);
11647 bfd_put_32 (obfd
, LD_R12_0R12
| PPC_LO (off
), p
);
11650 bfd_put_32 (obfd
, LD_R12_0R2
| PPC_LO (off
), p
);
11652 if (PPC_HA (r2off
) != 0)
11655 bfd_put_32 (obfd
, ADDIS_R2_R2
| PPC_HA (r2off
), p
);
11657 if (PPC_LO (r2off
) != 0)
11660 bfd_put_32 (obfd
, ADDI_R2_R2
| PPC_LO (r2off
), p
);
11664 bfd_put_32 (obfd
, MTCTR_R12
, p
);
11666 bfd_put_32 (obfd
, BCTR
, p
);
11670 case ppc_stub_long_branch_notoc
:
11671 case ppc_stub_long_branch_both
:
11672 case ppc_stub_plt_branch_notoc
:
11673 case ppc_stub_plt_branch_both
:
11674 case ppc_stub_plt_call_notoc
:
11675 case ppc_stub_plt_call_both
:
11677 off
= (stub_entry
->stub_offset
11678 + stub_entry
->group
->stub_sec
->output_offset
11679 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11680 obfd
= htab
->params
->stub_bfd
;
11681 is_tga
= ((stub_entry
->stub_type
== ppc_stub_plt_call_notoc
11682 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
11683 && stub_entry
->h
!= NULL
11684 && is_tls_get_addr (&stub_entry
->h
->elf
, htab
)
11685 && htab
->params
->tls_get_addr_opt
);
11688 p
= build_tls_get_addr_head (htab
, stub_entry
, p
);
11691 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
11692 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
11693 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
11696 bfd_put_32 (obfd
, STD_R2_0R1
+ STK_TOC (htab
), p
);
11699 if (stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
)
11701 targ
= stub_entry
->plt_ent
->plt
.offset
& ~1;
11702 if (targ
>= (bfd_vma
) -2)
11705 plt
= htab
->elf
.splt
;
11706 if (!htab
->elf
.dynamic_sections_created
11707 || stub_entry
->h
== NULL
11708 || stub_entry
->h
->elf
.dynindx
== -1)
11710 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
11711 plt
= htab
->elf
.iplt
;
11713 plt
= htab
->pltlocal
;
11715 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
11718 targ
= (stub_entry
->target_value
11719 + stub_entry
->target_section
->output_offset
11720 + stub_entry
->target_section
->output_section
->vma
);
11726 if (htab
->params
->power10_stubs
!= 0)
11728 bfd_boolean load
= stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
;
11729 p
= build_power10_offset (obfd
, p
, off
, odd
, load
);
11733 if (htab
->glink_eh_frame
!= NULL
11734 && htab
->glink_eh_frame
->size
!= 0)
11736 bfd_byte
*base
, *eh
;
11737 unsigned int lr_used
, delta
;
11739 base
= (htab
->glink_eh_frame
->contents
11740 + stub_entry
->group
->eh_base
+ 17);
11741 eh
= base
+ stub_entry
->group
->eh_size
;
11742 lr_used
= stub_entry
->stub_offset
+ (p
- loc
) + 8;
11743 delta
= lr_used
- stub_entry
->group
->lr_restore
;
11744 stub_entry
->group
->lr_restore
= lr_used
+ 8;
11745 eh
= eh_advance (htab
->elf
.dynobj
, eh
, delta
);
11746 *eh
++ = DW_CFA_register
;
11749 *eh
++ = DW_CFA_advance_loc
+ 2;
11750 *eh
++ = DW_CFA_restore_extended
;
11752 stub_entry
->group
->eh_size
= eh
- base
;
11755 /* The notoc stubs calculate their target (either a PLT entry or
11756 the global entry point of a function) relative to the PC
11757 returned by the "bcl" two instructions past the start of the
11758 sequence emitted by build_offset. The offset is therefore 8
11759 less than calculated from the start of the sequence. */
11761 p
= build_offset (obfd
, p
, off
,
11762 stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
);
11765 if (stub_entry
->stub_type
<= ppc_stub_long_branch_both
)
11769 from
= (stub_entry
->stub_offset
11770 + stub_entry
->group
->stub_sec
->output_offset
11771 + stub_entry
->group
->stub_sec
->output_section
->vma
11773 bfd_put_32 (obfd
, B_DOT
| ((targ
- from
) & 0x3fffffc), p
);
11777 bfd_put_32 (obfd
, MTCTR_R12
, p
);
11779 bfd_put_32 (obfd
, BCTR
, p
);
11784 p
= build_tls_get_addr_tail (htab
, stub_entry
, p
, loc
);
11786 if (info
->emitrelocations
)
11788 bfd_vma roff
= relp
- stub_entry
->group
->stub_sec
->contents
;
11789 if (htab
->params
->power10_stubs
!= 0)
11790 num_rel
+= num_relocs_for_power10_offset (off
, odd
);
11793 num_rel
+= num_relocs_for_offset (off
);
11796 r
= get_relocs (stub_entry
->group
->stub_sec
, num_rel
);
11799 if (htab
->params
->power10_stubs
!= 0)
11800 r
= emit_relocs_for_power10_offset (info
, r
, roff
, targ
, off
, odd
);
11802 r
= emit_relocs_for_offset (info
, r
, roff
, targ
, off
);
11803 if (stub_entry
->stub_type
== ppc_stub_long_branch_notoc
11804 || stub_entry
->stub_type
== ppc_stub_long_branch_both
)
11807 roff
= p
- 4 - stub_entry
->group
->stub_sec
->contents
;
11808 r
->r_offset
= roff
;
11809 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL24
);
11810 r
->r_addend
= targ
;
11811 if (stub_entry
->h
!= NULL
11812 && !use_global_in_relocs (htab
, stub_entry
, r
, num_rel
))
11818 case ppc_stub_plt_call
:
11819 case ppc_stub_plt_call_r2save
:
11820 if (stub_entry
->h
!= NULL
11821 && stub_entry
->h
->is_func_descriptor
11822 && stub_entry
->h
->oh
!= NULL
)
11824 struct ppc_link_hash_entry
*fh
= ppc_follow_link (stub_entry
->h
->oh
);
11826 /* If the old-ABI "dot-symbol" is undefined make it weak so
11827 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL. */
11828 if (fh
->elf
.root
.type
== bfd_link_hash_undefined
11829 && (stub_entry
->h
->elf
.root
.type
== bfd_link_hash_defined
11830 || stub_entry
->h
->elf
.root
.type
== bfd_link_hash_defweak
))
11831 fh
->elf
.root
.type
= bfd_link_hash_undefweak
;
11834 /* Now build the stub. */
11835 targ
= stub_entry
->plt_ent
->plt
.offset
& ~1;
11836 if (targ
>= (bfd_vma
) -2)
11839 plt
= htab
->elf
.splt
;
11840 if (!htab
->elf
.dynamic_sections_created
11841 || stub_entry
->h
== NULL
11842 || stub_entry
->h
->elf
.dynindx
== -1)
11844 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
11845 plt
= htab
->elf
.iplt
;
11847 plt
= htab
->pltlocal
;
11849 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
11851 off
= (elf_gp (info
->output_bfd
)
11852 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
11855 if (off
+ 0x80008000 > 0xffffffff || (off
& 7) != 0)
11857 info
->callbacks
->einfo
11858 /* xgettext:c-format */
11859 (_("%P: linkage table error against `%pT'\n"),
11860 stub_entry
->h
!= NULL
11861 ? stub_entry
->h
->elf
.root
.root
.string
11863 bfd_set_error (bfd_error_bad_value
);
11864 htab
->stub_error
= TRUE
;
11869 if (info
->emitrelocations
)
11871 r
= get_relocs (stub_entry
->group
->stub_sec
,
11872 ((PPC_HA (off
) != 0)
11874 ? 2 + (htab
->params
->plt_static_chain
11875 && PPC_HA (off
+ 16) == PPC_HA (off
))
11879 r
[0].r_offset
= loc
- stub_entry
->group
->stub_sec
->contents
;
11880 if (bfd_big_endian (info
->output_bfd
))
11881 r
[0].r_offset
+= 2;
11882 r
[0].r_addend
= targ
;
11885 obfd
= htab
->params
->stub_bfd
;
11886 is_tga
= (stub_entry
->h
!= NULL
11887 && is_tls_get_addr (&stub_entry
->h
->elf
, htab
)
11888 && htab
->params
->tls_get_addr_opt
);
11891 p
= build_tls_get_addr_head (htab
, stub_entry
, p
);
11893 r
[0].r_offset
+= p
- loc
;
11895 p
= build_plt_stub (htab
, stub_entry
, p
, off
, r
);
11897 p
= build_tls_get_addr_tail (htab
, stub_entry
, p
, loc
);
11900 case ppc_stub_save_res
:
11908 stub_entry
->group
->stub_sec
->size
= stub_entry
->stub_offset
+ (p
- loc
);
11910 if (htab
->params
->emit_stub_syms
)
11912 struct elf_link_hash_entry
*h
;
11915 const char *const stub_str
[] = { "long_branch",
11928 len1
= strlen (stub_str
[stub_entry
->stub_type
- 1]);
11929 len2
= strlen (stub_entry
->root
.string
);
11930 name
= bfd_malloc (len1
+ len2
+ 2);
11933 memcpy (name
, stub_entry
->root
.string
, 9);
11934 memcpy (name
+ 9, stub_str
[stub_entry
->stub_type
- 1], len1
);
11935 memcpy (name
+ len1
+ 9, stub_entry
->root
.string
+ 8, len2
- 8 + 1);
11936 h
= elf_link_hash_lookup (&htab
->elf
, name
, TRUE
, FALSE
, FALSE
);
11939 if (h
->root
.type
== bfd_link_hash_new
)
11941 h
->root
.type
= bfd_link_hash_defined
;
11942 h
->root
.u
.def
.section
= stub_entry
->group
->stub_sec
;
11943 h
->root
.u
.def
.value
= stub_entry
->stub_offset
;
11944 h
->ref_regular
= 1;
11945 h
->def_regular
= 1;
11946 h
->ref_regular_nonweak
= 1;
11947 h
->forced_local
= 1;
11949 h
->root
.linker_def
= 1;
11956 /* As above, but don't actually build the stub. Just bump offset so
11957 we know stub section sizes, and select plt_branch stubs where
11958 long_branch stubs won't do. */
11961 ppc_size_one_stub (struct bfd_hash_entry
*gen_entry
, void *in_arg
)
11963 struct ppc_stub_hash_entry
*stub_entry
;
11964 struct bfd_link_info
*info
;
11965 struct ppc_link_hash_table
*htab
;
11967 bfd_vma targ
, off
, r2off
;
11968 unsigned int size
, extra
, lr_used
, delta
, odd
;
11970 /* Massage our args to the form they really have. */
11971 stub_entry
= (struct ppc_stub_hash_entry
*) gen_entry
;
11974 htab
= ppc_hash_table (info
);
11978 /* Fail if the target section could not be assigned to an output
11979 section. The user should fix his linker script. */
11980 if (stub_entry
->target_section
!= NULL
11981 && stub_entry
->target_section
->output_section
== NULL
11982 && info
->non_contiguous_regions
)
11983 info
->callbacks
->einfo (_("%F%P: Could not assign %pA to an output section. "
11984 "Retry without --enable-non-contiguous-regions.\n"),
11985 stub_entry
->target_section
);
11987 /* Same for the group. */
11988 if (stub_entry
->group
->stub_sec
!= NULL
11989 && stub_entry
->group
->stub_sec
->output_section
== NULL
11990 && info
->non_contiguous_regions
)
11991 info
->callbacks
->einfo (_("%F%P: Could not assign group %pA target %pA to an "
11992 "output section. Retry without "
11993 "--enable-non-contiguous-regions.\n"),
11994 stub_entry
->group
->stub_sec
,
11995 stub_entry
->target_section
);
11997 /* Make a note of the offset within the stubs for this entry. */
11998 stub_entry
->stub_offset
= stub_entry
->group
->stub_sec
->size
;
12000 if (stub_entry
->h
!= NULL
12001 && stub_entry
->h
->save_res
12002 && stub_entry
->h
->elf
.root
.type
== bfd_link_hash_defined
12003 && stub_entry
->h
->elf
.root
.u
.def
.section
== htab
->sfpr
)
12005 /* Don't make stubs to out-of-line register save/restore
12006 functions. Instead, emit copies of the functions. */
12007 stub_entry
->group
->needs_save_res
= 1;
12008 stub_entry
->stub_type
= ppc_stub_save_res
;
12012 switch (stub_entry
->stub_type
)
12014 case ppc_stub_plt_branch
:
12015 case ppc_stub_plt_branch_r2off
:
12016 /* Reset the stub type from the plt branch variant in case we now
12017 can reach with a shorter stub. */
12018 stub_entry
->stub_type
+= ppc_stub_long_branch
- ppc_stub_plt_branch
;
12019 /* Fall through. */
12020 case ppc_stub_long_branch
:
12021 case ppc_stub_long_branch_r2off
:
12022 targ
= (stub_entry
->target_value
12023 + stub_entry
->target_section
->output_offset
12024 + stub_entry
->target_section
->output_section
->vma
);
12025 targ
+= PPC64_LOCAL_ENTRY_OFFSET (stub_entry
->other
);
12026 off
= (stub_entry
->stub_offset
12027 + stub_entry
->group
->stub_sec
->output_offset
12028 + stub_entry
->group
->stub_sec
->output_section
->vma
);
12032 if (stub_entry
->stub_type
== ppc_stub_long_branch_r2off
)
12034 r2off
= get_r2off (info
, stub_entry
);
12035 if (r2off
== (bfd_vma
) -1)
12037 htab
->stub_error
= TRUE
;
12041 if (PPC_HA (r2off
) != 0)
12043 if (PPC_LO (r2off
) != 0)
12049 /* If the branch offset is too big, use a ppc_stub_plt_branch.
12050 Do the same for -R objects without function descriptors. */
12051 if ((stub_entry
->stub_type
== ppc_stub_long_branch_r2off
12053 && htab
->sec_info
[stub_entry
->target_section
->id
].toc_off
== 0)
12054 || off
+ (1 << 25) >= (bfd_vma
) (1 << 26))
12056 struct ppc_branch_hash_entry
*br_entry
;
12058 br_entry
= ppc_branch_hash_lookup (&htab
->branch_hash_table
,
12059 stub_entry
->root
.string
+ 9,
12061 if (br_entry
== NULL
)
12063 _bfd_error_handler (_("can't build branch stub `%s'"),
12064 stub_entry
->root
.string
);
12065 htab
->stub_error
= TRUE
;
12069 if (br_entry
->iter
!= htab
->stub_iteration
)
12071 br_entry
->iter
= htab
->stub_iteration
;
12072 br_entry
->offset
= htab
->brlt
->size
;
12073 htab
->brlt
->size
+= 8;
12075 if (htab
->relbrlt
!= NULL
)
12076 htab
->relbrlt
->size
+= sizeof (Elf64_External_Rela
);
12077 else if (info
->emitrelocations
)
12079 htab
->brlt
->reloc_count
+= 1;
12080 htab
->brlt
->flags
|= SEC_RELOC
;
12084 targ
= (br_entry
->offset
12085 + htab
->brlt
->output_offset
12086 + htab
->brlt
->output_section
->vma
);
12087 off
= (elf_gp (info
->output_bfd
)
12088 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
12091 if (info
->emitrelocations
)
12093 stub_entry
->group
->stub_sec
->reloc_count
12094 += 1 + (PPC_HA (off
) != 0);
12095 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
12098 stub_entry
->stub_type
+= ppc_stub_plt_branch
- ppc_stub_long_branch
;
12099 if (stub_entry
->stub_type
!= ppc_stub_plt_branch_r2off
)
12102 if (PPC_HA (off
) != 0)
12108 if (PPC_HA (off
) != 0)
12111 if (PPC_HA (r2off
) != 0)
12113 if (PPC_LO (r2off
) != 0)
12117 else if (info
->emitrelocations
)
12119 stub_entry
->group
->stub_sec
->reloc_count
+= 1;
12120 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
12124 case ppc_stub_plt_branch_notoc
:
12125 case ppc_stub_plt_branch_both
:
12126 stub_entry
->stub_type
+= ppc_stub_long_branch
- ppc_stub_plt_branch
;
12127 /* Fall through. */
12128 case ppc_stub_long_branch_notoc
:
12129 case ppc_stub_long_branch_both
:
12130 off
= (stub_entry
->stub_offset
12131 + stub_entry
->group
->stub_sec
->output_offset
12132 + stub_entry
->group
->stub_sec
->output_section
->vma
);
12134 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
)
12137 targ
= (stub_entry
->target_value
12138 + stub_entry
->target_section
->output_offset
12139 + stub_entry
->target_section
->output_section
->vma
);
12143 if (info
->emitrelocations
)
12145 unsigned int num_rel
;
12146 if (htab
->params
->power10_stubs
!= 0)
12147 num_rel
= num_relocs_for_power10_offset (off
, odd
);
12149 num_rel
= num_relocs_for_offset (off
- 8);
12150 stub_entry
->group
->stub_sec
->reloc_count
+= num_rel
;
12151 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
12154 if (htab
->params
->power10_stubs
!= 0)
12155 extra
= size_power10_offset (off
, odd
);
12157 extra
= size_offset (off
- 8);
12158 /* Include branch insn plus those in the offset sequence. */
12160 /* The branch insn is at the end, or "extra" bytes along. So
12161 its offset will be "extra" bytes less that that already
12165 if (htab
->params
->power10_stubs
== 0)
12167 /* After the bcl, lr has been modified so we need to emit
12168 .eh_frame info saying the return address is in r12. */
12169 lr_used
= stub_entry
->stub_offset
+ 8;
12170 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
)
12172 /* The eh_frame info will consist of a DW_CFA_advance_loc or
12173 variant, DW_CFA_register, 65, 12, DW_CFA_advance_loc+2,
12174 DW_CFA_restore_extended 65. */
12175 delta
= lr_used
- stub_entry
->group
->lr_restore
;
12176 stub_entry
->group
->eh_size
+= eh_advance_size (delta
) + 6;
12177 stub_entry
->group
->lr_restore
= lr_used
+ 8;
12180 /* If the branch can't reach, use a plt_branch. */
12181 if (off
+ (1 << 25) >= (bfd_vma
) (1 << 26))
12183 stub_entry
->stub_type
+= (ppc_stub_plt_branch_notoc
12184 - ppc_stub_long_branch_notoc
);
12187 else if (info
->emitrelocations
)
12188 stub_entry
->group
->stub_sec
->reloc_count
+=1;
12191 case ppc_stub_plt_call_notoc
:
12192 case ppc_stub_plt_call_both
:
12194 if (stub_entry
->h
!= NULL
12195 && is_tls_get_addr (&stub_entry
->h
->elf
, htab
)
12196 && htab
->params
->tls_get_addr_opt
)
12199 if (!htab
->params
->no_tls_get_addr_regsave
)
12201 else if (stub_entry
->stub_type
== ppc_stub_plt_call_both
)
12204 if (stub_entry
->stub_type
== ppc_stub_plt_call_both
)
12206 targ
= stub_entry
->plt_ent
->plt
.offset
& ~1;
12207 if (targ
>= (bfd_vma
) -2)
12210 plt
= htab
->elf
.splt
;
12211 if (!htab
->elf
.dynamic_sections_created
12212 || stub_entry
->h
== NULL
12213 || stub_entry
->h
->elf
.dynindx
== -1)
12215 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
12216 plt
= htab
->elf
.iplt
;
12218 plt
= htab
->pltlocal
;
12220 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
12221 off
= (stub_entry
->stub_offset
12222 + stub_entry
->group
->stub_sec
->output_offset
12223 + stub_entry
->group
->stub_sec
->output_section
->vma
12228 if (htab
->params
->plt_stub_align
!= 0)
12230 unsigned pad
= plt_stub_pad (htab
, stub_entry
, off
, odd
);
12232 stub_entry
->group
->stub_sec
->size
+= pad
;
12233 stub_entry
->stub_offset
= stub_entry
->group
->stub_sec
->size
;
12238 if (info
->emitrelocations
)
12240 unsigned int num_rel
;
12241 if (htab
->params
->power10_stubs
!= 0)
12242 num_rel
= num_relocs_for_power10_offset (off
, odd
);
12244 num_rel
= num_relocs_for_offset (off
- 8);
12245 stub_entry
->group
->stub_sec
->reloc_count
+= num_rel
;
12246 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
12249 size
= plt_stub_size (htab
, stub_entry
, off
, odd
);
12251 if (htab
->params
->power10_stubs
== 0)
12253 /* After the bcl, lr has been modified so we need to emit
12254 .eh_frame info saying the return address is in r12. */
12255 lr_used
+= stub_entry
->stub_offset
+ 8;
12256 /* The eh_frame info will consist of a DW_CFA_advance_loc or
12257 variant, DW_CFA_register, 65, 12, DW_CFA_advance_loc+2,
12258 DW_CFA_restore_extended 65. */
12259 delta
= lr_used
- stub_entry
->group
->lr_restore
;
12260 stub_entry
->group
->eh_size
+= eh_advance_size (delta
) + 6;
12261 stub_entry
->group
->lr_restore
= lr_used
+ 8;
12263 if ((stub_entry
->stub_type
== ppc_stub_plt_call_notoc
12264 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
12265 && stub_entry
->h
!= NULL
12266 && is_tls_get_addr (&stub_entry
->h
->elf
, htab
)
12267 && htab
->params
->tls_get_addr_opt
)
12269 if (!htab
->params
->no_tls_get_addr_regsave
)
12271 unsigned int cfa_updt
= stub_entry
->stub_offset
+ 18 * 4;
12272 delta
= cfa_updt
- stub_entry
->group
->lr_restore
;
12273 stub_entry
->group
->eh_size
+= eh_advance_size (delta
);
12274 stub_entry
->group
->eh_size
+= htab
->opd_abi
? 36 : 35;
12275 stub_entry
->group
->lr_restore
12276 = stub_entry
->stub_offset
+ size
- 4;
12278 else if (stub_entry
->stub_type
== ppc_stub_plt_call_both
)
12280 lr_used
= stub_entry
->stub_offset
+ size
- 20;
12281 delta
= lr_used
- stub_entry
->group
->lr_restore
;
12282 stub_entry
->group
->eh_size
+= eh_advance_size (delta
) + 6;
12283 stub_entry
->group
->lr_restore
12284 = stub_entry
->stub_offset
+ size
- 4;
12289 case ppc_stub_plt_call
:
12290 case ppc_stub_plt_call_r2save
:
12291 targ
= stub_entry
->plt_ent
->plt
.offset
& ~(bfd_vma
) 1;
12292 if (targ
>= (bfd_vma
) -2)
12294 plt
= htab
->elf
.splt
;
12295 if (!htab
->elf
.dynamic_sections_created
12296 || stub_entry
->h
== NULL
12297 || stub_entry
->h
->elf
.dynindx
== -1)
12299 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
12300 plt
= htab
->elf
.iplt
;
12302 plt
= htab
->pltlocal
;
12304 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
12306 off
= (elf_gp (info
->output_bfd
)
12307 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
12310 if (htab
->params
->plt_stub_align
!= 0)
12312 unsigned pad
= plt_stub_pad (htab
, stub_entry
, off
, 0);
12314 stub_entry
->group
->stub_sec
->size
+= pad
;
12315 stub_entry
->stub_offset
= stub_entry
->group
->stub_sec
->size
;
12318 if (info
->emitrelocations
)
12320 stub_entry
->group
->stub_sec
->reloc_count
12321 += ((PPC_HA (off
) != 0)
12323 ? 2 + (htab
->params
->plt_static_chain
12324 && PPC_HA (off
+ 16) == PPC_HA (off
))
12326 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
12329 size
= plt_stub_size (htab
, stub_entry
, off
, 0);
12331 if (stub_entry
->h
!= NULL
12332 && is_tls_get_addr (&stub_entry
->h
->elf
, htab
)
12333 && htab
->params
->tls_get_addr_opt
12334 && stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
12336 if (!htab
->params
->no_tls_get_addr_regsave
)
12338 /* Adjustments to r1 need to be described. */
12339 unsigned int cfa_updt
= stub_entry
->stub_offset
+ 18 * 4;
12340 delta
= cfa_updt
- stub_entry
->group
->lr_restore
;
12341 stub_entry
->group
->eh_size
+= eh_advance_size (delta
);
12342 stub_entry
->group
->eh_size
+= htab
->opd_abi
? 36 : 35;
12346 lr_used
= stub_entry
->stub_offset
+ size
- 20;
12347 /* The eh_frame info will consist of a DW_CFA_advance_loc
12348 or variant, DW_CFA_offset_externed_sf, 65, -stackoff,
12349 DW_CFA_advance_loc+4, DW_CFA_restore_extended, 65. */
12350 delta
= lr_used
- stub_entry
->group
->lr_restore
;
12351 stub_entry
->group
->eh_size
+= eh_advance_size (delta
) + 6;
12353 stub_entry
->group
->lr_restore
= stub_entry
->stub_offset
+ size
- 4;
12362 stub_entry
->group
->stub_sec
->size
+= size
;
12366 /* Set up various things so that we can make a list of input sections
12367 for each output section included in the link. Returns -1 on error,
12368 0 when no stubs will be needed, and 1 on success. */
12371 ppc64_elf_setup_section_lists (struct bfd_link_info
*info
)
12375 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12380 htab
->sec_info_arr_size
= _bfd_section_id
;
12381 amt
= sizeof (*htab
->sec_info
) * (htab
->sec_info_arr_size
);
12382 htab
->sec_info
= bfd_zmalloc (amt
);
12383 if (htab
->sec_info
== NULL
)
12386 /* Set toc_off for com, und, abs and ind sections. */
12387 for (id
= 0; id
< 3; id
++)
12388 htab
->sec_info
[id
].toc_off
= TOC_BASE_OFF
;
12393 /* Set up for first pass at multitoc partitioning. */
12396 ppc64_elf_start_multitoc_partition (struct bfd_link_info
*info
)
12398 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12400 htab
->toc_curr
= ppc64_elf_set_toc (info
, info
->output_bfd
);
12401 htab
->toc_bfd
= NULL
;
12402 htab
->toc_first_sec
= NULL
;
12405 /* The linker repeatedly calls this function for each TOC input section
12406 and linker generated GOT section. Group input bfds such that the toc
12407 within a group is less than 64k in size. */
12410 ppc64_elf_next_toc_section (struct bfd_link_info
*info
, asection
*isec
)
12412 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12413 bfd_vma addr
, off
, limit
;
12418 if (!htab
->second_toc_pass
)
12420 /* Keep track of the first .toc or .got section for this input bfd. */
12421 bfd_boolean new_bfd
= htab
->toc_bfd
!= isec
->owner
;
12425 htab
->toc_bfd
= isec
->owner
;
12426 htab
->toc_first_sec
= isec
;
12429 addr
= isec
->output_offset
+ isec
->output_section
->vma
;
12430 off
= addr
- htab
->toc_curr
;
12431 limit
= 0x80008000;
12432 if (ppc64_elf_tdata (isec
->owner
)->has_small_toc_reloc
)
12434 if (off
+ isec
->size
> limit
)
12436 addr
= (htab
->toc_first_sec
->output_offset
12437 + htab
->toc_first_sec
->output_section
->vma
);
12438 htab
->toc_curr
= addr
;
12439 htab
->toc_curr
&= -TOC_BASE_ALIGN
;
12442 /* toc_curr is the base address of this toc group. Set elf_gp
12443 for the input section to be the offset relative to the
12444 output toc base plus 0x8000. Making the input elf_gp an
12445 offset allows us to move the toc as a whole without
12446 recalculating input elf_gp. */
12447 off
= htab
->toc_curr
- elf_gp (info
->output_bfd
);
12448 off
+= TOC_BASE_OFF
;
12450 /* Die if someone uses a linker script that doesn't keep input
12451 file .toc and .got together. */
12453 && elf_gp (isec
->owner
) != 0
12454 && elf_gp (isec
->owner
) != off
)
12457 elf_gp (isec
->owner
) = off
;
12461 /* During the second pass toc_first_sec points to the start of
12462 a toc group, and toc_curr is used to track the old elf_gp.
12463 We use toc_bfd to ensure we only look at each bfd once. */
12464 if (htab
->toc_bfd
== isec
->owner
)
12466 htab
->toc_bfd
= isec
->owner
;
12468 if (htab
->toc_first_sec
== NULL
12469 || htab
->toc_curr
!= elf_gp (isec
->owner
))
12471 htab
->toc_curr
= elf_gp (isec
->owner
);
12472 htab
->toc_first_sec
= isec
;
12474 addr
= (htab
->toc_first_sec
->output_offset
12475 + htab
->toc_first_sec
->output_section
->vma
);
12476 off
= addr
- elf_gp (info
->output_bfd
) + TOC_BASE_OFF
;
12477 elf_gp (isec
->owner
) = off
;
12482 /* Called via elf_link_hash_traverse to merge GOT entries for global
12486 merge_global_got (struct elf_link_hash_entry
*h
, void *inf ATTRIBUTE_UNUSED
)
12488 if (h
->root
.type
== bfd_link_hash_indirect
)
12491 merge_got_entries (&h
->got
.glist
);
12496 /* Called via elf_link_hash_traverse to allocate GOT entries for global
12500 reallocate_got (struct elf_link_hash_entry
*h
, void *inf
)
12502 struct got_entry
*gent
;
12504 if (h
->root
.type
== bfd_link_hash_indirect
)
12507 for (gent
= h
->got
.glist
; gent
!= NULL
; gent
= gent
->next
)
12508 if (!gent
->is_indirect
)
12509 allocate_got (h
, (struct bfd_link_info
*) inf
, gent
);
12513 /* Called on the first multitoc pass after the last call to
12514 ppc64_elf_next_toc_section. This function removes duplicate GOT
12518 ppc64_elf_layout_multitoc (struct bfd_link_info
*info
)
12520 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12521 struct bfd
*ibfd
, *ibfd2
;
12522 bfd_boolean done_something
;
12524 htab
->multi_toc_needed
= htab
->toc_curr
!= elf_gp (info
->output_bfd
);
12526 if (!htab
->do_multi_toc
)
12529 /* Merge global sym got entries within a toc group. */
12530 elf_link_hash_traverse (&htab
->elf
, merge_global_got
, info
);
12532 /* And tlsld_got. */
12533 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12535 struct got_entry
*ent
, *ent2
;
12537 if (!is_ppc64_elf (ibfd
))
12540 ent
= ppc64_tlsld_got (ibfd
);
12541 if (!ent
->is_indirect
12542 && ent
->got
.offset
!= (bfd_vma
) -1)
12544 for (ibfd2
= ibfd
->link
.next
; ibfd2
!= NULL
; ibfd2
= ibfd2
->link
.next
)
12546 if (!is_ppc64_elf (ibfd2
))
12549 ent2
= ppc64_tlsld_got (ibfd2
);
12550 if (!ent2
->is_indirect
12551 && ent2
->got
.offset
!= (bfd_vma
) -1
12552 && elf_gp (ibfd2
) == elf_gp (ibfd
))
12554 ent2
->is_indirect
= TRUE
;
12555 ent2
->got
.ent
= ent
;
12561 /* Zap sizes of got sections. */
12562 htab
->elf
.irelplt
->rawsize
= htab
->elf
.irelplt
->size
;
12563 htab
->elf
.irelplt
->size
-= htab
->got_reli_size
;
12564 htab
->got_reli_size
= 0;
12566 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12568 asection
*got
, *relgot
;
12570 if (!is_ppc64_elf (ibfd
))
12573 got
= ppc64_elf_tdata (ibfd
)->got
;
12576 got
->rawsize
= got
->size
;
12578 relgot
= ppc64_elf_tdata (ibfd
)->relgot
;
12579 relgot
->rawsize
= relgot
->size
;
12584 /* Now reallocate the got, local syms first. We don't need to
12585 allocate section contents again since we never increase size. */
12586 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12588 struct got_entry
**lgot_ents
;
12589 struct got_entry
**end_lgot_ents
;
12590 struct plt_entry
**local_plt
;
12591 struct plt_entry
**end_local_plt
;
12592 unsigned char *lgot_masks
;
12593 bfd_size_type locsymcount
;
12594 Elf_Internal_Shdr
*symtab_hdr
;
12597 if (!is_ppc64_elf (ibfd
))
12600 lgot_ents
= elf_local_got_ents (ibfd
);
12604 symtab_hdr
= &elf_symtab_hdr (ibfd
);
12605 locsymcount
= symtab_hdr
->sh_info
;
12606 end_lgot_ents
= lgot_ents
+ locsymcount
;
12607 local_plt
= (struct plt_entry
**) end_lgot_ents
;
12608 end_local_plt
= local_plt
+ locsymcount
;
12609 lgot_masks
= (unsigned char *) end_local_plt
;
12610 s
= ppc64_elf_tdata (ibfd
)->got
;
12611 for (; lgot_ents
< end_lgot_ents
; ++lgot_ents
, ++lgot_masks
)
12613 struct got_entry
*ent
;
12615 for (ent
= *lgot_ents
; ent
!= NULL
; ent
= ent
->next
)
12617 unsigned int ent_size
= 8;
12618 unsigned int rel_size
= sizeof (Elf64_External_Rela
);
12620 ent
->got
.offset
= s
->size
;
12621 if ((ent
->tls_type
& *lgot_masks
& TLS_GD
) != 0)
12626 s
->size
+= ent_size
;
12627 if ((*lgot_masks
& (TLS_TLS
| PLT_IFUNC
)) == PLT_IFUNC
)
12629 htab
->elf
.irelplt
->size
+= rel_size
;
12630 htab
->got_reli_size
+= rel_size
;
12632 else if (bfd_link_pic (info
)
12633 && !(ent
->tls_type
!= 0
12634 && bfd_link_executable (info
)))
12636 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
12637 srel
->size
+= rel_size
;
12643 elf_link_hash_traverse (&htab
->elf
, reallocate_got
, info
);
12645 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12647 struct got_entry
*ent
;
12649 if (!is_ppc64_elf (ibfd
))
12652 ent
= ppc64_tlsld_got (ibfd
);
12653 if (!ent
->is_indirect
12654 && ent
->got
.offset
!= (bfd_vma
) -1)
12656 asection
*s
= ppc64_elf_tdata (ibfd
)->got
;
12657 ent
->got
.offset
= s
->size
;
12659 if (bfd_link_dll (info
))
12661 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
12662 srel
->size
+= sizeof (Elf64_External_Rela
);
12667 done_something
= htab
->elf
.irelplt
->rawsize
!= htab
->elf
.irelplt
->size
;
12668 if (!done_something
)
12669 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12673 if (!is_ppc64_elf (ibfd
))
12676 got
= ppc64_elf_tdata (ibfd
)->got
;
12679 done_something
= got
->rawsize
!= got
->size
;
12680 if (done_something
)
12685 if (done_something
)
12686 (*htab
->params
->layout_sections_again
) ();
12688 /* Set up for second pass over toc sections to recalculate elf_gp
12689 on input sections. */
12690 htab
->toc_bfd
= NULL
;
12691 htab
->toc_first_sec
= NULL
;
12692 htab
->second_toc_pass
= TRUE
;
12693 return done_something
;
12696 /* Called after second pass of multitoc partitioning. */
12699 ppc64_elf_finish_multitoc_partition (struct bfd_link_info
*info
)
12701 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12703 /* After the second pass, toc_curr tracks the TOC offset used
12704 for code sections below in ppc64_elf_next_input_section. */
12705 htab
->toc_curr
= TOC_BASE_OFF
;
12708 /* No toc references were found in ISEC. If the code in ISEC makes no
12709 calls, then there's no need to use toc adjusting stubs when branching
12710 into ISEC. Actually, indirect calls from ISEC are OK as they will
12711 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
12712 needed, and 2 if a cyclical call-graph was found but no other reason
12713 for a stub was detected. If called from the top level, a return of
12714 2 means the same as a return of 0. */
12717 toc_adjusting_stub_needed (struct bfd_link_info
*info
, asection
*isec
)
12721 /* Mark this section as checked. */
12722 isec
->call_check_done
= 1;
12724 /* We know none of our code bearing sections will need toc stubs. */
12725 if ((isec
->flags
& SEC_LINKER_CREATED
) != 0)
12728 if (isec
->size
== 0)
12731 if (isec
->output_section
== NULL
)
12735 if (isec
->reloc_count
!= 0)
12737 Elf_Internal_Rela
*relstart
, *rel
;
12738 Elf_Internal_Sym
*local_syms
;
12739 struct ppc_link_hash_table
*htab
;
12741 relstart
= _bfd_elf_link_read_relocs (isec
->owner
, isec
, NULL
, NULL
,
12742 info
->keep_memory
);
12743 if (relstart
== NULL
)
12746 /* Look for branches to outside of this section. */
12748 htab
= ppc_hash_table (info
);
12752 for (rel
= relstart
; rel
< relstart
+ isec
->reloc_count
; ++rel
)
12754 enum elf_ppc64_reloc_type r_type
;
12755 unsigned long r_symndx
;
12756 struct elf_link_hash_entry
*h
;
12757 struct ppc_link_hash_entry
*eh
;
12758 Elf_Internal_Sym
*sym
;
12760 struct _opd_sec_data
*opd
;
12764 r_type
= ELF64_R_TYPE (rel
->r_info
);
12765 if (r_type
!= R_PPC64_REL24
12766 && r_type
!= R_PPC64_REL24_NOTOC
12767 && r_type
!= R_PPC64_REL14
12768 && r_type
!= R_PPC64_REL14_BRTAKEN
12769 && r_type
!= R_PPC64_REL14_BRNTAKEN
12770 && r_type
!= R_PPC64_PLTCALL
12771 && r_type
!= R_PPC64_PLTCALL_NOTOC
)
12774 r_symndx
= ELF64_R_SYM (rel
->r_info
);
12775 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
, r_symndx
,
12782 /* Calls to dynamic lib functions go through a plt call stub
12784 eh
= ppc_elf_hash_entry (h
);
12786 && (eh
->elf
.plt
.plist
!= NULL
12788 && ppc_follow_link (eh
->oh
)->elf
.plt
.plist
!= NULL
)))
12794 if (sym_sec
== NULL
)
12795 /* Ignore other undefined symbols. */
12798 /* Assume branches to other sections not included in the
12799 link need stubs too, to cover -R and absolute syms. */
12800 if (sym_sec
->output_section
== NULL
)
12807 sym_value
= sym
->st_value
;
12810 if (h
->root
.type
!= bfd_link_hash_defined
12811 && h
->root
.type
!= bfd_link_hash_defweak
)
12813 sym_value
= h
->root
.u
.def
.value
;
12815 sym_value
+= rel
->r_addend
;
12817 /* If this branch reloc uses an opd sym, find the code section. */
12818 opd
= get_opd_info (sym_sec
);
12821 if (h
== NULL
&& opd
->adjust
!= NULL
)
12825 adjust
= opd
->adjust
[OPD_NDX (sym_value
)];
12827 /* Assume deleted functions won't ever be called. */
12829 sym_value
+= adjust
;
12832 dest
= opd_entry_value (sym_sec
, sym_value
,
12833 &sym_sec
, NULL
, FALSE
);
12834 if (dest
== (bfd_vma
) -1)
12839 + sym_sec
->output_offset
12840 + sym_sec
->output_section
->vma
);
12842 /* Ignore branch to self. */
12843 if (sym_sec
== isec
)
12846 /* If the called function uses the toc, we need a stub. */
12847 if (sym_sec
->has_toc_reloc
12848 || sym_sec
->makes_toc_func_call
)
12854 /* Assume any branch that needs a long branch stub might in fact
12855 need a plt_branch stub. A plt_branch stub uses r2. */
12856 else if (dest
- (isec
->output_offset
12857 + isec
->output_section
->vma
12858 + rel
->r_offset
) + (1 << 25)
12859 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
12867 /* If calling back to a section in the process of being
12868 tested, we can't say for sure that no toc adjusting stubs
12869 are needed, so don't return zero. */
12870 else if (sym_sec
->call_check_in_progress
)
12873 /* Branches to another section that itself doesn't have any TOC
12874 references are OK. Recursively call ourselves to check. */
12875 else if (!sym_sec
->call_check_done
)
12879 /* Mark current section as indeterminate, so that other
12880 sections that call back to current won't be marked as
12882 isec
->call_check_in_progress
= 1;
12883 recur
= toc_adjusting_stub_needed (info
, sym_sec
);
12884 isec
->call_check_in_progress
= 0;
12895 if (elf_symtab_hdr (isec
->owner
).contents
12896 != (unsigned char *) local_syms
)
12898 if (elf_section_data (isec
)->relocs
!= relstart
)
12903 && isec
->map_head
.s
!= NULL
12904 && (strcmp (isec
->output_section
->name
, ".init") == 0
12905 || strcmp (isec
->output_section
->name
, ".fini") == 0))
12907 if (isec
->map_head
.s
->has_toc_reloc
12908 || isec
->map_head
.s
->makes_toc_func_call
)
12910 else if (!isec
->map_head
.s
->call_check_done
)
12913 isec
->call_check_in_progress
= 1;
12914 recur
= toc_adjusting_stub_needed (info
, isec
->map_head
.s
);
12915 isec
->call_check_in_progress
= 0;
12922 isec
->makes_toc_func_call
= 1;
12927 /* The linker repeatedly calls this function for each input section,
12928 in the order that input sections are linked into output sections.
12929 Build lists of input sections to determine groupings between which
12930 we may insert linker stubs. */
12933 ppc64_elf_next_input_section (struct bfd_link_info
*info
, asection
*isec
)
12935 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12940 if ((isec
->output_section
->flags
& SEC_CODE
) != 0
12941 && isec
->output_section
->id
< htab
->sec_info_arr_size
)
12943 /* This happens to make the list in reverse order,
12944 which is what we want. */
12945 htab
->sec_info
[isec
->id
].u
.list
12946 = htab
->sec_info
[isec
->output_section
->id
].u
.list
;
12947 htab
->sec_info
[isec
->output_section
->id
].u
.list
= isec
;
12950 if (htab
->multi_toc_needed
)
12952 /* Analyse sections that aren't already flagged as needing a
12953 valid toc pointer. Exclude .fixup for the linux kernel.
12954 .fixup contains branches, but only back to the function that
12955 hit an exception. */
12956 if (!(isec
->has_toc_reloc
12957 || (isec
->flags
& SEC_CODE
) == 0
12958 || strcmp (isec
->name
, ".fixup") == 0
12959 || isec
->call_check_done
))
12961 if (toc_adjusting_stub_needed (info
, isec
) < 0)
12964 /* Make all sections use the TOC assigned for this object file.
12965 This will be wrong for pasted sections; We fix that in
12966 check_pasted_section(). */
12967 if (elf_gp (isec
->owner
) != 0)
12968 htab
->toc_curr
= elf_gp (isec
->owner
);
12971 htab
->sec_info
[isec
->id
].toc_off
= htab
->toc_curr
;
12975 /* Check that all .init and .fini sections use the same toc, if they
12976 have toc relocs. */
12979 check_pasted_section (struct bfd_link_info
*info
, const char *name
)
12981 asection
*o
= bfd_get_section_by_name (info
->output_bfd
, name
);
12985 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12986 bfd_vma toc_off
= 0;
12989 for (i
= o
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
12990 if (i
->has_toc_reloc
)
12993 toc_off
= htab
->sec_info
[i
->id
].toc_off
;
12994 else if (toc_off
!= htab
->sec_info
[i
->id
].toc_off
)
12999 for (i
= o
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
13000 if (i
->makes_toc_func_call
)
13002 toc_off
= htab
->sec_info
[i
->id
].toc_off
;
13006 /* Make sure the whole pasted function uses the same toc offset. */
13008 for (i
= o
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
13009 htab
->sec_info
[i
->id
].toc_off
= toc_off
;
13015 ppc64_elf_check_init_fini (struct bfd_link_info
*info
)
13017 return (check_pasted_section (info
, ".init")
13018 & check_pasted_section (info
, ".fini"));
13021 /* See whether we can group stub sections together. Grouping stub
13022 sections may result in fewer stubs. More importantly, we need to
13023 put all .init* and .fini* stubs at the beginning of the .init or
13024 .fini output sections respectively, because glibc splits the
13025 _init and _fini functions into multiple parts. Putting a stub in
13026 the middle of a function is not a good idea. */
13029 group_sections (struct bfd_link_info
*info
,
13030 bfd_size_type stub_group_size
,
13031 bfd_boolean stubs_always_before_branch
)
13033 struct ppc_link_hash_table
*htab
;
13035 bfd_boolean suppress_size_errors
;
13037 htab
= ppc_hash_table (info
);
13041 suppress_size_errors
= FALSE
;
13042 if (stub_group_size
== 1)
13044 /* Default values. */
13045 if (stubs_always_before_branch
)
13046 stub_group_size
= 0x1e00000;
13048 stub_group_size
= 0x1c00000;
13049 suppress_size_errors
= TRUE
;
13052 for (osec
= info
->output_bfd
->sections
; osec
!= NULL
; osec
= osec
->next
)
13056 if (osec
->id
>= htab
->sec_info_arr_size
)
13059 tail
= htab
->sec_info
[osec
->id
].u
.list
;
13060 while (tail
!= NULL
)
13064 bfd_size_type total
;
13065 bfd_boolean big_sec
;
13067 struct map_stub
*group
;
13068 bfd_size_type group_size
;
13071 total
= tail
->size
;
13072 group_size
= (ppc64_elf_section_data (tail
) != NULL
13073 && ppc64_elf_section_data (tail
)->has_14bit_branch
13074 ? stub_group_size
>> 10 : stub_group_size
);
13076 big_sec
= total
> group_size
;
13077 if (big_sec
&& !suppress_size_errors
)
13078 /* xgettext:c-format */
13079 _bfd_error_handler (_("%pB section %pA exceeds stub group size"),
13080 tail
->owner
, tail
);
13081 curr_toc
= htab
->sec_info
[tail
->id
].toc_off
;
13083 while ((prev
= htab
->sec_info
[curr
->id
].u
.list
) != NULL
13084 && ((total
+= curr
->output_offset
- prev
->output_offset
)
13085 < (ppc64_elf_section_data (prev
) != NULL
13086 && ppc64_elf_section_data (prev
)->has_14bit_branch
13087 ? (group_size
= stub_group_size
>> 10) : group_size
))
13088 && htab
->sec_info
[prev
->id
].toc_off
== curr_toc
)
13091 /* OK, the size from the start of CURR to the end is less
13092 than group_size and thus can be handled by one stub
13093 section. (or the tail section is itself larger than
13094 group_size, in which case we may be toast.) We should
13095 really be keeping track of the total size of stubs added
13096 here, as stubs contribute to the final output section
13097 size. That's a little tricky, and this way will only
13098 break if stubs added make the total size more than 2^25,
13099 ie. for the default stub_group_size, if stubs total more
13100 than 2097152 bytes, or nearly 75000 plt call stubs. */
13101 group
= bfd_alloc (curr
->owner
, sizeof (*group
));
13104 group
->link_sec
= curr
;
13105 group
->stub_sec
= NULL
;
13106 group
->needs_save_res
= 0;
13107 group
->lr_restore
= 0;
13108 group
->eh_size
= 0;
13109 group
->eh_base
= 0;
13110 group
->next
= htab
->group
;
13111 htab
->group
= group
;
13114 prev
= htab
->sec_info
[tail
->id
].u
.list
;
13115 /* Set up this stub group. */
13116 htab
->sec_info
[tail
->id
].u
.group
= group
;
13118 while (tail
!= curr
&& (tail
= prev
) != NULL
);
13120 /* But wait, there's more! Input sections up to group_size
13121 bytes before the stub section can be handled by it too.
13122 Don't do this if we have a really large section after the
13123 stubs, as adding more stubs increases the chance that
13124 branches may not reach into the stub section. */
13125 if (!stubs_always_before_branch
&& !big_sec
)
13128 while (prev
!= NULL
13129 && ((total
+= tail
->output_offset
- prev
->output_offset
)
13130 < (ppc64_elf_section_data (prev
) != NULL
13131 && ppc64_elf_section_data (prev
)->has_14bit_branch
13132 ? (group_size
= stub_group_size
>> 10)
13134 && htab
->sec_info
[prev
->id
].toc_off
== curr_toc
)
13137 prev
= htab
->sec_info
[tail
->id
].u
.list
;
13138 htab
->sec_info
[tail
->id
].u
.group
= group
;
13147 static const unsigned char glink_eh_frame_cie
[] =
13149 0, 0, 0, 16, /* length. */
13150 0, 0, 0, 0, /* id. */
13151 1, /* CIE version. */
13152 'z', 'R', 0, /* Augmentation string. */
13153 4, /* Code alignment. */
13154 0x78, /* Data alignment. */
13156 1, /* Augmentation size. */
13157 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding. */
13158 DW_CFA_def_cfa
, 1, 0 /* def_cfa: r1 offset 0. */
13161 /* Stripping output sections is normally done before dynamic section
13162 symbols have been allocated. This function is called later, and
13163 handles cases like htab->brlt which is mapped to its own output
13167 maybe_strip_output (struct bfd_link_info
*info
, asection
*isec
)
13169 if (isec
->size
== 0
13170 && isec
->output_section
->size
== 0
13171 && !(isec
->output_section
->flags
& SEC_KEEP
)
13172 && !bfd_section_removed_from_list (info
->output_bfd
,
13173 isec
->output_section
)
13174 && elf_section_data (isec
->output_section
)->dynindx
== 0)
13176 isec
->output_section
->flags
|= SEC_EXCLUDE
;
13177 bfd_section_list_remove (info
->output_bfd
, isec
->output_section
);
13178 info
->output_bfd
->section_count
--;
13182 /* Determine and set the size of the stub section for a final link.
13184 The basic idea here is to examine all the relocations looking for
13185 PC-relative calls to a target that is unreachable with a "bl"
13189 ppc64_elf_size_stubs (struct bfd_link_info
*info
)
13191 bfd_size_type stub_group_size
;
13192 bfd_boolean stubs_always_before_branch
;
13193 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
13198 if (htab
->params
->power10_stubs
== -1 && !htab
->has_power10_relocs
)
13199 htab
->params
->power10_stubs
= 0;
13201 if (htab
->params
->plt_thread_safe
== -1 && !bfd_link_executable (info
))
13202 htab
->params
->plt_thread_safe
= 1;
13203 if (!htab
->opd_abi
)
13204 htab
->params
->plt_thread_safe
= 0;
13205 else if (htab
->params
->plt_thread_safe
== -1)
13207 static const char *const thread_starter
[] =
13211 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
13213 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
13214 "mq_notify", "create_timer",
13219 "GOMP_parallel_start",
13220 "GOMP_parallel_loop_static",
13221 "GOMP_parallel_loop_static_start",
13222 "GOMP_parallel_loop_dynamic",
13223 "GOMP_parallel_loop_dynamic_start",
13224 "GOMP_parallel_loop_guided",
13225 "GOMP_parallel_loop_guided_start",
13226 "GOMP_parallel_loop_runtime",
13227 "GOMP_parallel_loop_runtime_start",
13228 "GOMP_parallel_sections",
13229 "GOMP_parallel_sections_start",
13235 for (i
= 0; i
< ARRAY_SIZE (thread_starter
); i
++)
13237 struct elf_link_hash_entry
*h
;
13238 h
= elf_link_hash_lookup (&htab
->elf
, thread_starter
[i
],
13239 FALSE
, FALSE
, TRUE
);
13240 htab
->params
->plt_thread_safe
= h
!= NULL
&& h
->ref_regular
;
13241 if (htab
->params
->plt_thread_safe
)
13245 stubs_always_before_branch
= htab
->params
->group_size
< 0;
13246 if (htab
->params
->group_size
< 0)
13247 stub_group_size
= -htab
->params
->group_size
;
13249 stub_group_size
= htab
->params
->group_size
;
13251 if (!group_sections (info
, stub_group_size
, stubs_always_before_branch
))
13254 htab
->tga_group
= NULL
;
13255 if (!htab
->params
->no_tls_get_addr_regsave
13256 && htab
->tga_desc_fd
!= NULL
13257 && (htab
->tga_desc_fd
->elf
.root
.type
== bfd_link_hash_undefined
13258 || htab
->tga_desc_fd
->elf
.root
.type
== bfd_link_hash_undefweak
)
13259 && htab
->tls_get_addr_fd
!= NULL
13260 && is_static_defined (&htab
->tls_get_addr_fd
->elf
))
13262 asection
*sym_sec
, *code_sec
, *stub_sec
;
13264 struct _opd_sec_data
*opd
;
13266 sym_sec
= htab
->tls_get_addr_fd
->elf
.root
.u
.def
.section
;
13267 sym_value
= defined_sym_val (&htab
->tls_get_addr_fd
->elf
);
13268 code_sec
= sym_sec
;
13269 opd
= get_opd_info (sym_sec
);
13271 opd_entry_value (sym_sec
, sym_value
, &code_sec
, NULL
, FALSE
);
13272 htab
->tga_group
= htab
->sec_info
[code_sec
->id
].u
.group
;
13273 stub_sec
= (*htab
->params
->add_stub_section
) (".tga_desc.stub",
13274 htab
->tga_group
->link_sec
);
13275 if (stub_sec
== NULL
)
13277 htab
->tga_group
->stub_sec
= stub_sec
;
13279 htab
->tga_desc_fd
->elf
.root
.type
= bfd_link_hash_defined
;
13280 htab
->tga_desc_fd
->elf
.root
.u
.def
.section
= stub_sec
;
13281 htab
->tga_desc_fd
->elf
.root
.u
.def
.value
= 0;
13282 htab
->tga_desc_fd
->elf
.type
= STT_FUNC
;
13283 htab
->tga_desc_fd
->elf
.def_regular
= 1;
13284 htab
->tga_desc_fd
->elf
.non_elf
= 0;
13285 _bfd_elf_link_hash_hide_symbol (info
, &htab
->tga_desc_fd
->elf
, TRUE
);
13288 #define STUB_SHRINK_ITER 20
13289 /* Loop until no stubs added. After iteration 20 of this loop we may
13290 exit on a stub section shrinking. This is to break out of a
13291 pathological case where adding stubs on one iteration decreases
13292 section gaps (perhaps due to alignment), which then requires
13293 fewer or smaller stubs on the next iteration. */
13298 unsigned int bfd_indx
;
13299 struct map_stub
*group
;
13301 htab
->stub_iteration
+= 1;
13303 for (input_bfd
= info
->input_bfds
, bfd_indx
= 0;
13305 input_bfd
= input_bfd
->link
.next
, bfd_indx
++)
13307 Elf_Internal_Shdr
*symtab_hdr
;
13309 Elf_Internal_Sym
*local_syms
= NULL
;
13311 if (!is_ppc64_elf (input_bfd
))
13314 /* We'll need the symbol table in a second. */
13315 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
13316 if (symtab_hdr
->sh_info
== 0)
13319 /* Walk over each section attached to the input bfd. */
13320 for (section
= input_bfd
->sections
;
13322 section
= section
->next
)
13324 Elf_Internal_Rela
*internal_relocs
, *irelaend
, *irela
;
13326 /* If there aren't any relocs, then there's nothing more
13328 if ((section
->flags
& SEC_RELOC
) == 0
13329 || (section
->flags
& SEC_ALLOC
) == 0
13330 || (section
->flags
& SEC_LOAD
) == 0
13331 || (section
->flags
& SEC_CODE
) == 0
13332 || section
->reloc_count
== 0)
13335 /* If this section is a link-once section that will be
13336 discarded, then don't create any stubs. */
13337 if (section
->output_section
== NULL
13338 || section
->output_section
->owner
!= info
->output_bfd
)
13341 /* Get the relocs. */
13343 = _bfd_elf_link_read_relocs (input_bfd
, section
, NULL
, NULL
,
13344 info
->keep_memory
);
13345 if (internal_relocs
== NULL
)
13346 goto error_ret_free_local
;
13348 /* Now examine each relocation. */
13349 irela
= internal_relocs
;
13350 irelaend
= irela
+ section
->reloc_count
;
13351 for (; irela
< irelaend
; irela
++)
13353 enum elf_ppc64_reloc_type r_type
;
13354 unsigned int r_indx
;
13355 enum ppc_stub_type stub_type
;
13356 struct ppc_stub_hash_entry
*stub_entry
;
13357 asection
*sym_sec
, *code_sec
;
13358 bfd_vma sym_value
, code_value
;
13359 bfd_vma destination
;
13360 unsigned long local_off
;
13361 bfd_boolean ok_dest
;
13362 struct ppc_link_hash_entry
*hash
;
13363 struct ppc_link_hash_entry
*fdh
;
13364 struct elf_link_hash_entry
*h
;
13365 Elf_Internal_Sym
*sym
;
13367 const asection
*id_sec
;
13368 struct _opd_sec_data
*opd
;
13369 struct plt_entry
*plt_ent
;
13371 r_type
= ELF64_R_TYPE (irela
->r_info
);
13372 r_indx
= ELF64_R_SYM (irela
->r_info
);
13374 if (r_type
>= R_PPC64_max
)
13376 bfd_set_error (bfd_error_bad_value
);
13377 goto error_ret_free_internal
;
13380 /* Only look for stubs on branch instructions. */
13381 if (r_type
!= R_PPC64_REL24
13382 && r_type
!= R_PPC64_REL24_NOTOC
13383 && r_type
!= R_PPC64_REL14
13384 && r_type
!= R_PPC64_REL14_BRTAKEN
13385 && r_type
!= R_PPC64_REL14_BRNTAKEN
)
13388 /* Now determine the call target, its name, value,
13390 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
13391 r_indx
, input_bfd
))
13392 goto error_ret_free_internal
;
13393 hash
= ppc_elf_hash_entry (h
);
13400 sym_value
= sym
->st_value
;
13401 if (sym_sec
!= NULL
13402 && sym_sec
->output_section
!= NULL
)
13405 else if (hash
->elf
.root
.type
== bfd_link_hash_defined
13406 || hash
->elf
.root
.type
== bfd_link_hash_defweak
)
13408 sym_value
= hash
->elf
.root
.u
.def
.value
;
13409 if (sym_sec
->output_section
!= NULL
)
13412 else if (hash
->elf
.root
.type
== bfd_link_hash_undefweak
13413 || hash
->elf
.root
.type
== bfd_link_hash_undefined
)
13415 /* Recognise an old ABI func code entry sym, and
13416 use the func descriptor sym instead if it is
13418 if (hash
->elf
.root
.root
.string
[0] == '.'
13419 && hash
->oh
!= NULL
)
13421 fdh
= ppc_follow_link (hash
->oh
);
13422 if (fdh
->elf
.root
.type
== bfd_link_hash_defined
13423 || fdh
->elf
.root
.type
== bfd_link_hash_defweak
)
13425 sym_sec
= fdh
->elf
.root
.u
.def
.section
;
13426 sym_value
= fdh
->elf
.root
.u
.def
.value
;
13427 if (sym_sec
->output_section
!= NULL
)
13436 bfd_set_error (bfd_error_bad_value
);
13437 goto error_ret_free_internal
;
13444 sym_value
+= irela
->r_addend
;
13445 destination
= (sym_value
13446 + sym_sec
->output_offset
13447 + sym_sec
->output_section
->vma
);
13448 local_off
= PPC64_LOCAL_ENTRY_OFFSET (hash
13453 code_sec
= sym_sec
;
13454 code_value
= sym_value
;
13455 opd
= get_opd_info (sym_sec
);
13460 if (hash
== NULL
&& opd
->adjust
!= NULL
)
13462 long adjust
= opd
->adjust
[OPD_NDX (sym_value
)];
13465 code_value
+= adjust
;
13466 sym_value
+= adjust
;
13468 dest
= opd_entry_value (sym_sec
, sym_value
,
13469 &code_sec
, &code_value
, FALSE
);
13470 if (dest
!= (bfd_vma
) -1)
13472 destination
= dest
;
13475 /* Fixup old ABI sym to point at code
13477 hash
->elf
.root
.type
= bfd_link_hash_defweak
;
13478 hash
->elf
.root
.u
.def
.section
= code_sec
;
13479 hash
->elf
.root
.u
.def
.value
= code_value
;
13484 /* Determine what (if any) linker stub is needed. */
13486 stub_type
= ppc_type_of_stub (section
, irela
, &hash
,
13487 &plt_ent
, destination
,
13490 if (r_type
== R_PPC64_REL24_NOTOC
)
13492 if (stub_type
== ppc_stub_plt_call
)
13493 stub_type
= ppc_stub_plt_call_notoc
;
13494 else if (stub_type
== ppc_stub_long_branch
13495 || (code_sec
!= NULL
13496 && code_sec
->output_section
!= NULL
13497 && (((hash
? hash
->elf
.other
: sym
->st_other
)
13498 & STO_PPC64_LOCAL_MASK
)
13499 > 1 << STO_PPC64_LOCAL_BIT
)))
13500 stub_type
= ppc_stub_long_branch_notoc
;
13502 else if (stub_type
!= ppc_stub_plt_call
)
13504 /* Check whether we need a TOC adjusting stub.
13505 Since the linker pastes together pieces from
13506 different object files when creating the
13507 _init and _fini functions, it may be that a
13508 call to what looks like a local sym is in
13509 fact a call needing a TOC adjustment. */
13510 if ((code_sec
!= NULL
13511 && code_sec
->output_section
!= NULL
13512 && (code_sec
->has_toc_reloc
13513 || code_sec
->makes_toc_func_call
)
13514 && (htab
->sec_info
[code_sec
->id
].toc_off
13515 != htab
->sec_info
[section
->id
].toc_off
))
13516 || (((hash
? hash
->elf
.other
: sym
->st_other
)
13517 & STO_PPC64_LOCAL_MASK
)
13518 == 1 << STO_PPC64_LOCAL_BIT
))
13519 stub_type
= ppc_stub_long_branch_r2off
;
13522 if (stub_type
== ppc_stub_none
)
13525 /* __tls_get_addr calls might be eliminated. */
13526 if (stub_type
!= ppc_stub_plt_call
13527 && stub_type
!= ppc_stub_plt_call_notoc
13529 && is_tls_get_addr (&hash
->elf
, htab
)
13530 && section
->has_tls_reloc
13531 && irela
!= internal_relocs
)
13533 /* Get tls info. */
13534 unsigned char *tls_mask
;
13536 if (!get_tls_mask (&tls_mask
, NULL
, NULL
, &local_syms
,
13537 irela
- 1, input_bfd
))
13538 goto error_ret_free_internal
;
13539 if ((*tls_mask
& TLS_TLS
) != 0
13540 && (*tls_mask
& (TLS_GD
| TLS_LD
)) == 0)
13544 if (stub_type
== ppc_stub_plt_call
)
13547 && htab
->params
->plt_localentry0
!= 0
13548 && is_elfv2_localentry0 (&hash
->elf
))
13549 htab
->has_plt_localentry0
= 1;
13550 else if (irela
+ 1 < irelaend
13551 && irela
[1].r_offset
== irela
->r_offset
+ 4
13552 && (ELF64_R_TYPE (irela
[1].r_info
)
13553 == R_PPC64_TOCSAVE
))
13555 if (!tocsave_find (htab
, INSERT
,
13556 &local_syms
, irela
+ 1, input_bfd
))
13557 goto error_ret_free_internal
;
13560 stub_type
= ppc_stub_plt_call_r2save
;
13563 /* Support for grouping stub sections. */
13564 id_sec
= htab
->sec_info
[section
->id
].u
.group
->link_sec
;
13566 /* Get the name of this stub. */
13567 stub_name
= ppc_stub_name (id_sec
, sym_sec
, hash
, irela
);
13569 goto error_ret_free_internal
;
13571 stub_entry
= ppc_stub_hash_lookup (&htab
->stub_hash_table
,
13572 stub_name
, FALSE
, FALSE
);
13573 if (stub_entry
!= NULL
)
13575 enum ppc_stub_type old_type
;
13577 /* A stub has already been created, but it may
13578 not be the required type. We shouldn't be
13579 transitioning from plt_call to long_branch
13580 stubs or vice versa, but we might be
13581 upgrading from plt_call to plt_call_r2save or
13582 from long_branch to long_branch_r2off. */
13584 if (htab
->params
->power10_stubs
== -1)
13586 /* For --power10-stubs=auto, don't merge _notoc
13587 and other varieties of stubs. (The _both
13588 variety won't be created.) */
13589 bfd_boolean notoc
= r_type
== R_PPC64_REL24_NOTOC
;
13590 struct ppc_stub_hash_entry
*alt_stub
13591 = select_alt_stub (stub_entry
, notoc
);
13593 if (alt_stub
== NULL
)
13595 alt_stub
= (struct ppc_stub_hash_entry
*)
13596 stub_hash_newfunc (NULL
,
13597 &htab
->stub_hash_table
,
13598 stub_entry
->root
.string
);
13599 if (alt_stub
== NULL
)
13601 /* xgettext:c-format */
13603 (_("%pB: cannot create stub entry %s"),
13604 section
->owner
, stub_entry
->root
.string
);
13605 goto error_ret_free_internal
;
13607 *alt_stub
= *stub_entry
;
13608 stub_entry
->root
.next
= &alt_stub
->root
;
13610 /* Sort notoc stubs first, for no good
13612 alt_stub
= stub_entry
;
13613 alt_stub
->stub_type
= stub_type
;
13615 stub_entry
= alt_stub
;
13617 old_type
= stub_entry
->stub_type
;
13623 case ppc_stub_save_res
:
13626 case ppc_stub_plt_call
:
13627 case ppc_stub_plt_call_r2save
:
13628 case ppc_stub_plt_call_notoc
:
13629 case ppc_stub_plt_call_both
:
13630 if (stub_type
== ppc_stub_plt_call
)
13632 else if (stub_type
== ppc_stub_plt_call_r2save
)
13634 if (old_type
== ppc_stub_plt_call_notoc
)
13635 stub_type
= ppc_stub_plt_call_both
;
13637 else if (stub_type
== ppc_stub_plt_call_notoc
)
13639 if (old_type
== ppc_stub_plt_call_r2save
)
13640 stub_type
= ppc_stub_plt_call_both
;
13646 case ppc_stub_plt_branch
:
13647 case ppc_stub_plt_branch_r2off
:
13648 case ppc_stub_plt_branch_notoc
:
13649 case ppc_stub_plt_branch_both
:
13650 old_type
+= (ppc_stub_long_branch
13651 - ppc_stub_plt_branch
);
13652 /* Fall through. */
13653 case ppc_stub_long_branch
:
13654 case ppc_stub_long_branch_r2off
:
13655 case ppc_stub_long_branch_notoc
:
13656 case ppc_stub_long_branch_both
:
13657 if (stub_type
== ppc_stub_long_branch
)
13659 else if (stub_type
== ppc_stub_long_branch_r2off
)
13661 if (old_type
== ppc_stub_long_branch_notoc
)
13662 stub_type
= ppc_stub_long_branch_both
;
13664 else if (stub_type
== ppc_stub_long_branch_notoc
)
13666 if (old_type
== ppc_stub_long_branch_r2off
)
13667 stub_type
= ppc_stub_long_branch_both
;
13673 if (old_type
< stub_type
)
13674 stub_entry
->stub_type
= stub_type
;
13678 stub_entry
= ppc_add_stub (stub_name
, section
, info
);
13679 if (stub_entry
== NULL
)
13682 error_ret_free_internal
:
13683 if (elf_section_data (section
)->relocs
== NULL
)
13684 free (internal_relocs
);
13685 error_ret_free_local
:
13686 if (symtab_hdr
->contents
13687 != (unsigned char *) local_syms
)
13692 stub_entry
->stub_type
= stub_type
;
13693 if (stub_type
>= ppc_stub_plt_call
13694 && stub_type
<= ppc_stub_plt_call_both
)
13696 stub_entry
->target_value
= sym_value
;
13697 stub_entry
->target_section
= sym_sec
;
13701 stub_entry
->target_value
= code_value
;
13702 stub_entry
->target_section
= code_sec
;
13704 stub_entry
->h
= hash
;
13705 stub_entry
->plt_ent
= plt_ent
;
13706 stub_entry
->symtype
13707 = hash
? hash
->elf
.type
: ELF_ST_TYPE (sym
->st_info
);
13708 stub_entry
->other
= hash
? hash
->elf
.other
: sym
->st_other
;
13711 && (hash
->elf
.root
.type
== bfd_link_hash_defined
13712 || hash
->elf
.root
.type
== bfd_link_hash_defweak
))
13713 htab
->stub_globals
+= 1;
13716 /* We're done with the internal relocs, free them. */
13717 if (elf_section_data (section
)->relocs
!= internal_relocs
)
13718 free (internal_relocs
);
13721 if (local_syms
!= NULL
13722 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
13724 if (!info
->keep_memory
)
13727 symtab_hdr
->contents
= (unsigned char *) local_syms
;
13731 /* We may have added some stubs. Find out the new size of the
13733 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13735 group
->lr_restore
= 0;
13736 group
->eh_size
= 0;
13737 if (group
->stub_sec
!= NULL
)
13739 asection
*stub_sec
= group
->stub_sec
;
13741 if (htab
->stub_iteration
<= STUB_SHRINK_ITER
13742 || stub_sec
->rawsize
< stub_sec
->size
)
13743 /* Past STUB_SHRINK_ITER, rawsize is the max size seen. */
13744 stub_sec
->rawsize
= stub_sec
->size
;
13745 stub_sec
->size
= 0;
13746 stub_sec
->reloc_count
= 0;
13747 stub_sec
->flags
&= ~SEC_RELOC
;
13750 if (htab
->tga_group
!= NULL
)
13752 /* See emit_tga_desc and emit_tga_desc_eh_frame. */
13753 htab
->tga_group
->eh_size
13754 = 1 + 2 + (htab
->opd_abi
!= 0) + 3 + 8 * 2 + 3 + 8 + 3;
13755 htab
->tga_group
->lr_restore
= 23 * 4;
13756 htab
->tga_group
->stub_sec
->size
= 24 * 4;
13759 if (htab
->stub_iteration
<= STUB_SHRINK_ITER
13760 || htab
->brlt
->rawsize
< htab
->brlt
->size
)
13761 htab
->brlt
->rawsize
= htab
->brlt
->size
;
13762 htab
->brlt
->size
= 0;
13763 htab
->brlt
->reloc_count
= 0;
13764 htab
->brlt
->flags
&= ~SEC_RELOC
;
13765 if (htab
->relbrlt
!= NULL
)
13766 htab
->relbrlt
->size
= 0;
13768 bfd_hash_traverse (&htab
->stub_hash_table
, ppc_size_one_stub
, info
);
13770 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13771 if (group
->needs_save_res
)
13772 group
->stub_sec
->size
+= htab
->sfpr
->size
;
13774 if (info
->emitrelocations
13775 && htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
13777 htab
->glink
->reloc_count
= 1;
13778 htab
->glink
->flags
|= SEC_RELOC
;
13781 if (htab
->glink_eh_frame
!= NULL
13782 && !bfd_is_abs_section (htab
->glink_eh_frame
->output_section
)
13783 && htab
->glink_eh_frame
->output_section
->size
> 8)
13785 size_t size
= 0, align
= 4;
13787 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13788 if (group
->eh_size
!= 0)
13789 size
+= (group
->eh_size
+ 17 + align
- 1) & -align
;
13790 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
13791 size
+= (24 + align
- 1) & -align
;
13793 size
+= (sizeof (glink_eh_frame_cie
) + align
- 1) & -align
;
13794 align
= 1ul << htab
->glink_eh_frame
->output_section
->alignment_power
;
13795 size
= (size
+ align
- 1) & -align
;
13796 htab
->glink_eh_frame
->rawsize
= htab
->glink_eh_frame
->size
;
13797 htab
->glink_eh_frame
->size
= size
;
13800 if (htab
->params
->plt_stub_align
!= 0)
13801 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13802 if (group
->stub_sec
!= NULL
)
13804 int align
= abs (htab
->params
->plt_stub_align
);
13805 group
->stub_sec
->size
13806 = (group
->stub_sec
->size
+ (1 << align
) - 1) & -(1 << align
);
13809 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13810 if (group
->stub_sec
!= NULL
13811 && group
->stub_sec
->rawsize
!= group
->stub_sec
->size
13812 && (htab
->stub_iteration
<= STUB_SHRINK_ITER
13813 || group
->stub_sec
->rawsize
< group
->stub_sec
->size
))
13817 && (htab
->brlt
->rawsize
== htab
->brlt
->size
13818 || (htab
->stub_iteration
> STUB_SHRINK_ITER
13819 && htab
->brlt
->rawsize
> htab
->brlt
->size
))
13820 && (htab
->glink_eh_frame
== NULL
13821 || htab
->glink_eh_frame
->rawsize
== htab
->glink_eh_frame
->size
)
13822 && (htab
->tga_group
== NULL
13823 || htab
->stub_iteration
> 1))
13826 /* Ask the linker to do its stuff. */
13827 (*htab
->params
->layout_sections_again
) ();
13830 if (htab
->glink_eh_frame
!= NULL
13831 && htab
->glink_eh_frame
->size
!= 0)
13834 bfd_byte
*p
, *last_fde
;
13835 size_t last_fde_len
, size
, align
, pad
;
13836 struct map_stub
*group
;
13838 /* It is necessary to at least have a rough outline of the
13839 linker generated CIEs and FDEs written before
13840 bfd_elf_discard_info is run, in order for these FDEs to be
13841 indexed in .eh_frame_hdr. */
13842 p
= bfd_zalloc (htab
->glink_eh_frame
->owner
, htab
->glink_eh_frame
->size
);
13845 htab
->glink_eh_frame
->contents
= p
;
13849 memcpy (p
, glink_eh_frame_cie
, sizeof (glink_eh_frame_cie
));
13850 /* CIE length (rewrite in case little-endian). */
13851 last_fde_len
= ((sizeof (glink_eh_frame_cie
) + align
- 1) & -align
) - 4;
13852 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
, p
);
13853 p
+= last_fde_len
+ 4;
13855 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13856 if (group
->eh_size
!= 0)
13858 group
->eh_base
= p
- htab
->glink_eh_frame
->contents
;
13860 last_fde_len
= ((group
->eh_size
+ 17 + align
- 1) & -align
) - 4;
13862 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
, p
);
13865 val
= p
- htab
->glink_eh_frame
->contents
;
13866 bfd_put_32 (htab
->elf
.dynobj
, val
, p
);
13868 /* Offset to stub section, written later. */
13870 /* stub section size. */
13871 bfd_put_32 (htab
->elf
.dynobj
, group
->stub_sec
->size
, p
);
13873 /* Augmentation. */
13875 /* Make sure we don't have all nops. This is enough for
13876 elf-eh-frame.c to detect the last non-nop opcode. */
13877 p
[group
->eh_size
- 1] = DW_CFA_advance_loc
+ 1;
13878 p
= last_fde
+ last_fde_len
+ 4;
13880 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
13883 last_fde_len
= ((24 + align
- 1) & -align
) - 4;
13885 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
, p
);
13888 val
= p
- htab
->glink_eh_frame
->contents
;
13889 bfd_put_32 (htab
->elf
.dynobj
, val
, p
);
13891 /* Offset to .glink, written later. */
13894 bfd_put_32 (htab
->elf
.dynobj
, htab
->glink
->size
- 8, p
);
13896 /* Augmentation. */
13899 *p
++ = DW_CFA_advance_loc
+ (htab
->has_plt_localentry0
? 3 : 2);
13900 *p
++ = DW_CFA_register
;
13902 *p
++ = htab
->opd_abi
? 12 : 0;
13903 *p
++ = DW_CFA_advance_loc
+ (htab
->opd_abi
? 4 : 2);
13904 *p
++ = DW_CFA_restore_extended
;
13906 p
+= ((24 + align
- 1) & -align
) - 24;
13908 /* Subsume any padding into the last FDE if user .eh_frame
13909 sections are aligned more than glink_eh_frame. Otherwise any
13910 zero padding will be seen as a terminator. */
13911 align
= 1ul << htab
->glink_eh_frame
->output_section
->alignment_power
;
13912 size
= p
- htab
->glink_eh_frame
->contents
;
13913 pad
= ((size
+ align
- 1) & -align
) - size
;
13914 htab
->glink_eh_frame
->size
= size
+ pad
;
13915 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
+ pad
, last_fde
);
13918 maybe_strip_output (info
, htab
->brlt
);
13919 if (htab
->relbrlt
!= NULL
)
13920 maybe_strip_output (info
, htab
->relbrlt
);
13921 if (htab
->glink_eh_frame
!= NULL
)
13922 maybe_strip_output (info
, htab
->glink_eh_frame
);
13927 /* Called after we have determined section placement. If sections
13928 move, we'll be called again. Provide a value for TOCstart. */
13931 ppc64_elf_set_toc (struct bfd_link_info
*info
, bfd
*obfd
)
13934 bfd_vma TOCstart
, adjust
;
13938 struct elf_link_hash_entry
*h
;
13939 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
13941 if (is_elf_hash_table (htab
)
13942 && htab
->hgot
!= NULL
)
13946 h
= elf_link_hash_lookup (htab
, ".TOC.", FALSE
, FALSE
, TRUE
);
13947 if (is_elf_hash_table (htab
))
13951 && h
->root
.type
== bfd_link_hash_defined
13952 && !h
->root
.linker_def
13953 && (!is_elf_hash_table (htab
)
13954 || h
->def_regular
))
13956 TOCstart
= defined_sym_val (h
) - TOC_BASE_OFF
;
13957 _bfd_set_gp_value (obfd
, TOCstart
);
13962 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
13963 order. The TOC starts where the first of these sections starts. */
13964 s
= bfd_get_section_by_name (obfd
, ".got");
13965 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13966 s
= bfd_get_section_by_name (obfd
, ".toc");
13967 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13968 s
= bfd_get_section_by_name (obfd
, ".tocbss");
13969 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13970 s
= bfd_get_section_by_name (obfd
, ".plt");
13971 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13973 /* This may happen for
13974 o references to TOC base (SYM@toc / TOC[tc0]) without a
13976 o bad linker script
13977 o --gc-sections and empty TOC sections
13979 FIXME: Warn user? */
13981 /* Look for a likely section. We probably won't even be
13983 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13984 if ((s
->flags
& (SEC_ALLOC
| SEC_SMALL_DATA
| SEC_READONLY
13986 == (SEC_ALLOC
| SEC_SMALL_DATA
))
13989 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13990 if ((s
->flags
& (SEC_ALLOC
| SEC_SMALL_DATA
| SEC_EXCLUDE
))
13991 == (SEC_ALLOC
| SEC_SMALL_DATA
))
13994 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13995 if ((s
->flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_EXCLUDE
))
13999 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
14000 if ((s
->flags
& (SEC_ALLOC
| SEC_EXCLUDE
)) == SEC_ALLOC
)
14006 TOCstart
= s
->output_section
->vma
+ s
->output_offset
;
14008 /* Force alignment. */
14009 adjust
= TOCstart
& (TOC_BASE_ALIGN
- 1);
14010 TOCstart
-= adjust
;
14011 _bfd_set_gp_value (obfd
, TOCstart
);
14013 if (info
!= NULL
&& s
!= NULL
)
14015 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
14019 if (htab
->elf
.hgot
!= NULL
)
14021 htab
->elf
.hgot
->root
.u
.def
.value
= TOC_BASE_OFF
- adjust
;
14022 htab
->elf
.hgot
->root
.u
.def
.section
= s
;
14027 struct bfd_link_hash_entry
*bh
= NULL
;
14028 _bfd_generic_link_add_one_symbol (info
, obfd
, ".TOC.", BSF_GLOBAL
,
14029 s
, TOC_BASE_OFF
- adjust
,
14030 NULL
, FALSE
, FALSE
, &bh
);
14036 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
14037 write out any global entry stubs, and PLT relocations. */
14040 build_global_entry_stubs_and_plt (struct elf_link_hash_entry
*h
, void *inf
)
14042 struct bfd_link_info
*info
;
14043 struct ppc_link_hash_table
*htab
;
14044 struct plt_entry
*ent
;
14047 if (h
->root
.type
== bfd_link_hash_indirect
)
14051 htab
= ppc_hash_table (info
);
14055 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
14056 if (ent
->plt
.offset
!= (bfd_vma
) -1)
14058 /* This symbol has an entry in the procedure linkage
14059 table. Set it up. */
14060 Elf_Internal_Rela rela
;
14061 asection
*plt
, *relplt
;
14064 if (!htab
->elf
.dynamic_sections_created
14065 || h
->dynindx
== -1)
14067 if (!(h
->def_regular
14068 && (h
->root
.type
== bfd_link_hash_defined
14069 || h
->root
.type
== bfd_link_hash_defweak
)))
14071 if (h
->type
== STT_GNU_IFUNC
)
14073 plt
= htab
->elf
.iplt
;
14074 relplt
= htab
->elf
.irelplt
;
14075 htab
->elf
.ifunc_resolvers
= TRUE
;
14077 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_IREL
);
14079 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
14083 plt
= htab
->pltlocal
;
14084 if (bfd_link_pic (info
))
14086 relplt
= htab
->relpltlocal
;
14088 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_SLOT
);
14090 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
14095 rela
.r_addend
= defined_sym_val (h
) + ent
->addend
;
14097 if (relplt
== NULL
)
14099 loc
= plt
->contents
+ ent
->plt
.offset
;
14100 bfd_put_64 (info
->output_bfd
, rela
.r_addend
, loc
);
14103 bfd_vma toc
= elf_gp (info
->output_bfd
);
14104 toc
+= htab
->sec_info
[h
->root
.u
.def
.section
->id
].toc_off
;
14105 bfd_put_64 (info
->output_bfd
, toc
, loc
+ 8);
14110 rela
.r_offset
= (plt
->output_section
->vma
14111 + plt
->output_offset
14112 + ent
->plt
.offset
);
14113 loc
= relplt
->contents
+ (relplt
->reloc_count
++
14114 * sizeof (Elf64_External_Rela
));
14115 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rela
, loc
);
14120 rela
.r_offset
= (htab
->elf
.splt
->output_section
->vma
14121 + htab
->elf
.splt
->output_offset
14122 + ent
->plt
.offset
);
14123 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_PPC64_JMP_SLOT
);
14124 rela
.r_addend
= ent
->addend
;
14125 loc
= (htab
->elf
.srelplt
->contents
14126 + ((ent
->plt
.offset
- PLT_INITIAL_ENTRY_SIZE (htab
))
14127 / PLT_ENTRY_SIZE (htab
) * sizeof (Elf64_External_Rela
)));
14128 if (h
->type
== STT_GNU_IFUNC
&& is_static_defined (h
))
14129 htab
->elf
.ifunc_resolvers
= TRUE
;
14130 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rela
, loc
);
14134 if (!h
->pointer_equality_needed
)
14137 if (h
->def_regular
)
14140 s
= htab
->global_entry
;
14141 if (s
== NULL
|| s
->size
== 0)
14144 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
14145 if (ent
->plt
.offset
!= (bfd_vma
) -1
14146 && ent
->addend
== 0)
14152 p
= s
->contents
+ h
->root
.u
.def
.value
;
14153 plt
= htab
->elf
.splt
;
14154 if (!htab
->elf
.dynamic_sections_created
14155 || h
->dynindx
== -1)
14157 if (h
->type
== STT_GNU_IFUNC
)
14158 plt
= htab
->elf
.iplt
;
14160 plt
= htab
->pltlocal
;
14162 off
= ent
->plt
.offset
+ plt
->output_offset
+ plt
->output_section
->vma
;
14163 off
-= h
->root
.u
.def
.value
+ s
->output_offset
+ s
->output_section
->vma
;
14165 if (off
+ 0x80008000 > 0xffffffff || (off
& 3) != 0)
14167 info
->callbacks
->einfo
14168 (_("%P: linkage table error against `%pT'\n"),
14169 h
->root
.root
.string
);
14170 bfd_set_error (bfd_error_bad_value
);
14171 htab
->stub_error
= TRUE
;
14174 htab
->stub_count
[ppc_stub_global_entry
- 1] += 1;
14175 if (htab
->params
->emit_stub_syms
)
14177 size_t len
= strlen (h
->root
.root
.string
);
14178 char *name
= bfd_malloc (sizeof "12345678.global_entry." + len
);
14183 sprintf (name
, "%08x.global_entry.%s", s
->id
, h
->root
.root
.string
);
14184 h
= elf_link_hash_lookup (&htab
->elf
, name
, TRUE
, FALSE
, FALSE
);
14187 if (h
->root
.type
== bfd_link_hash_new
)
14189 h
->root
.type
= bfd_link_hash_defined
;
14190 h
->root
.u
.def
.section
= s
;
14191 h
->root
.u
.def
.value
= p
- s
->contents
;
14192 h
->ref_regular
= 1;
14193 h
->def_regular
= 1;
14194 h
->ref_regular_nonweak
= 1;
14195 h
->forced_local
= 1;
14197 h
->root
.linker_def
= 1;
14201 if (PPC_HA (off
) != 0)
14203 bfd_put_32 (s
->owner
, ADDIS_R12_R12
| PPC_HA (off
), p
);
14206 bfd_put_32 (s
->owner
, LD_R12_0R12
| PPC_LO (off
), p
);
14208 bfd_put_32 (s
->owner
, MTCTR_R12
, p
);
14210 bfd_put_32 (s
->owner
, BCTR
, p
);
14216 /* Write PLT relocs for locals. */
14219 write_plt_relocs_for_local_syms (struct bfd_link_info
*info
)
14221 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
14224 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
14226 struct got_entry
**lgot_ents
, **end_lgot_ents
;
14227 struct plt_entry
**local_plt
, **lplt
, **end_local_plt
;
14228 Elf_Internal_Shdr
*symtab_hdr
;
14229 bfd_size_type locsymcount
;
14230 Elf_Internal_Sym
*local_syms
= NULL
;
14231 struct plt_entry
*ent
;
14233 if (!is_ppc64_elf (ibfd
))
14236 lgot_ents
= elf_local_got_ents (ibfd
);
14240 symtab_hdr
= &elf_symtab_hdr (ibfd
);
14241 locsymcount
= symtab_hdr
->sh_info
;
14242 end_lgot_ents
= lgot_ents
+ locsymcount
;
14243 local_plt
= (struct plt_entry
**) end_lgot_ents
;
14244 end_local_plt
= local_plt
+ locsymcount
;
14245 for (lplt
= local_plt
; lplt
< end_local_plt
; ++lplt
)
14246 for (ent
= *lplt
; ent
!= NULL
; ent
= ent
->next
)
14247 if (ent
->plt
.offset
!= (bfd_vma
) -1)
14249 Elf_Internal_Sym
*sym
;
14251 asection
*plt
, *relplt
;
14255 if (!get_sym_h (NULL
, &sym
, &sym_sec
, NULL
, &local_syms
,
14256 lplt
- local_plt
, ibfd
))
14258 if (symtab_hdr
->contents
!= (unsigned char *) local_syms
)
14263 val
= sym
->st_value
+ ent
->addend
;
14264 if (sym_sec
!= NULL
&& sym_sec
->output_section
!= NULL
)
14265 val
+= sym_sec
->output_offset
+ sym_sec
->output_section
->vma
;
14267 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
14269 htab
->elf
.ifunc_resolvers
= TRUE
;
14270 plt
= htab
->elf
.iplt
;
14271 relplt
= htab
->elf
.irelplt
;
14275 plt
= htab
->pltlocal
;
14276 relplt
= bfd_link_pic (info
) ? htab
->relpltlocal
: NULL
;
14279 if (relplt
== NULL
)
14281 loc
= plt
->contents
+ ent
->plt
.offset
;
14282 bfd_put_64 (info
->output_bfd
, val
, loc
);
14285 bfd_vma toc
= elf_gp (ibfd
);
14286 bfd_put_64 (info
->output_bfd
, toc
, loc
+ 8);
14291 Elf_Internal_Rela rela
;
14292 rela
.r_offset
= (ent
->plt
.offset
14293 + plt
->output_offset
14294 + plt
->output_section
->vma
);
14295 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
14298 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_IREL
);
14300 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
14305 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_SLOT
);
14307 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
14309 rela
.r_addend
= val
;
14310 loc
= relplt
->contents
+ (relplt
->reloc_count
++
14311 * sizeof (Elf64_External_Rela
));
14312 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rela
, loc
);
14316 if (local_syms
!= NULL
14317 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
14319 if (!info
->keep_memory
)
14322 symtab_hdr
->contents
= (unsigned char *) local_syms
;
14328 /* Emit the static wrapper function preserving registers around a
14329 __tls_get_addr_opt call. */
14332 emit_tga_desc (struct ppc_link_hash_table
*htab
)
14334 asection
*stub_sec
= htab
->tga_group
->stub_sec
;
14335 unsigned int cfa_updt
= 11 * 4;
14337 bfd_vma to
, from
, delta
;
14339 BFD_ASSERT (htab
->tga_desc_fd
->elf
.root
.type
== bfd_link_hash_defined
14340 && htab
->tga_desc_fd
->elf
.root
.u
.def
.section
== stub_sec
14341 && htab
->tga_desc_fd
->elf
.root
.u
.def
.value
== 0);
14342 to
= defined_sym_val (&htab
->tls_get_addr_fd
->elf
);
14343 from
= defined_sym_val (&htab
->tga_desc_fd
->elf
) + cfa_updt
;
14345 if (delta
+ (1 << 25) >= 1 << 26)
14347 _bfd_error_handler (_("__tls_get_addr call offset overflow"));
14348 htab
->stub_error
= TRUE
;
14352 p
= stub_sec
->contents
;
14353 p
= tls_get_addr_prologue (htab
->elf
.dynobj
, p
, htab
);
14354 bfd_put_32 (stub_sec
->owner
, B_DOT
| 1 | (delta
& 0x3fffffc), p
);
14356 p
= tls_get_addr_epilogue (htab
->elf
.dynobj
, p
, htab
);
14357 return stub_sec
->size
== (bfd_size_type
) (p
- stub_sec
->contents
);
14360 /* Emit eh_frame describing the static wrapper function. */
14363 emit_tga_desc_eh_frame (struct ppc_link_hash_table
*htab
, bfd_byte
*p
)
14365 unsigned int cfa_updt
= 11 * 4;
14368 *p
++ = DW_CFA_advance_loc
+ cfa_updt
/ 4;
14369 *p
++ = DW_CFA_def_cfa_offset
;
14377 *p
++ = DW_CFA_offset_extended_sf
;
14379 *p
++ = (-16 / 8) & 0x7f;
14380 for (i
= 4; i
< 12; i
++)
14382 *p
++ = DW_CFA_offset
+ i
;
14383 *p
++ = (htab
->opd_abi
? 13 : 12) - i
;
14385 *p
++ = DW_CFA_advance_loc
+ 10;
14386 *p
++ = DW_CFA_def_cfa_offset
;
14388 for (i
= 4; i
< 12; i
++)
14389 *p
++ = DW_CFA_restore
+ i
;
14390 *p
++ = DW_CFA_advance_loc
+ 2;
14391 *p
++ = DW_CFA_restore_extended
;
14396 /* Build all the stubs associated with the current output file.
14397 The stubs are kept in a hash table attached to the main linker
14398 hash table. This function is called via gldelf64ppc_finish. */
14401 ppc64_elf_build_stubs (struct bfd_link_info
*info
,
14404 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
14405 struct map_stub
*group
;
14406 asection
*stub_sec
;
14408 int stub_sec_count
= 0;
14413 /* Allocate memory to hold the linker stubs. */
14414 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14416 group
->eh_size
= 0;
14417 group
->lr_restore
= 0;
14418 if ((stub_sec
= group
->stub_sec
) != NULL
14419 && stub_sec
->size
!= 0)
14421 stub_sec
->contents
= bfd_zalloc (htab
->params
->stub_bfd
,
14423 if (stub_sec
->contents
== NULL
)
14425 stub_sec
->size
= 0;
14429 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
14434 /* Build the .glink plt call stub. */
14435 if (htab
->params
->emit_stub_syms
)
14437 struct elf_link_hash_entry
*h
;
14438 h
= elf_link_hash_lookup (&htab
->elf
, "__glink_PLTresolve",
14439 TRUE
, FALSE
, FALSE
);
14442 if (h
->root
.type
== bfd_link_hash_new
)
14444 h
->root
.type
= bfd_link_hash_defined
;
14445 h
->root
.u
.def
.section
= htab
->glink
;
14446 h
->root
.u
.def
.value
= 8;
14447 h
->ref_regular
= 1;
14448 h
->def_regular
= 1;
14449 h
->ref_regular_nonweak
= 1;
14450 h
->forced_local
= 1;
14452 h
->root
.linker_def
= 1;
14455 plt0
= (htab
->elf
.splt
->output_section
->vma
14456 + htab
->elf
.splt
->output_offset
14458 if (info
->emitrelocations
)
14460 Elf_Internal_Rela
*r
= get_relocs (htab
->glink
, 1);
14463 r
->r_offset
= (htab
->glink
->output_offset
14464 + htab
->glink
->output_section
->vma
);
14465 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL64
);
14466 r
->r_addend
= plt0
;
14468 p
= htab
->glink
->contents
;
14469 plt0
-= htab
->glink
->output_section
->vma
+ htab
->glink
->output_offset
;
14470 bfd_put_64 (htab
->glink
->owner
, plt0
, p
);
14474 bfd_put_32 (htab
->glink
->owner
, MFLR_R12
, p
);
14476 bfd_put_32 (htab
->glink
->owner
, BCL_20_31
, p
);
14478 bfd_put_32 (htab
->glink
->owner
, MFLR_R11
, p
);
14480 bfd_put_32 (htab
->glink
->owner
, LD_R2_0R11
| (-16 & 0xfffc), p
);
14482 bfd_put_32 (htab
->glink
->owner
, MTLR_R12
, p
);
14484 bfd_put_32 (htab
->glink
->owner
, ADD_R11_R2_R11
, p
);
14486 bfd_put_32 (htab
->glink
->owner
, LD_R12_0R11
, p
);
14488 bfd_put_32 (htab
->glink
->owner
, LD_R2_0R11
| 8, p
);
14490 bfd_put_32 (htab
->glink
->owner
, MTCTR_R12
, p
);
14492 bfd_put_32 (htab
->glink
->owner
, LD_R11_0R11
| 16, p
);
14500 . .quad plt0-1f # plt0 entry relative to 1:
14502 # We get here with r12 initially @ a glink branch
14503 # Load the address of _dl_runtime_resolve from plt0 and
14504 # jump to it, with r0 set to the index of the PLT entry
14505 # to be resolved and r11 the link map.
14506 __glink_PLTresolve:
14507 . std %r2,24(%r1) # optional
14513 . ld %r0,(0b-1b)(%r11)
14514 . sub %r12,%r12,%r11
14515 . add %r11,%r0,%r11
14516 . addi %r0,%r12,1b-2f
14523 . b __glink_PLTresolve
14525 . b __glink_PLTresolve */
14527 if (htab
->has_plt_localentry0
)
14529 bfd_put_32 (htab
->glink
->owner
, STD_R2_0R1
+ 24, p
);
14532 bfd_put_32 (htab
->glink
->owner
, MFLR_R0
, p
);
14534 bfd_put_32 (htab
->glink
->owner
, BCL_20_31
, p
);
14536 bfd_put_32 (htab
->glink
->owner
, MFLR_R11
, p
);
14538 bfd_put_32 (htab
->glink
->owner
, MTLR_R0
, p
);
14540 if (htab
->has_plt_localentry0
)
14541 insn
= LD_R0_0R11
| (-20 & 0xfffc);
14543 insn
= LD_R0_0R11
| (-16 & 0xfffc);
14544 bfd_put_32 (htab
->glink
->owner
, insn
, p
);
14546 bfd_put_32 (htab
->glink
->owner
, SUB_R12_R12_R11
, p
);
14548 bfd_put_32 (htab
->glink
->owner
, ADD_R11_R0_R11
, p
);
14550 bfd_put_32 (htab
->glink
->owner
, ADDI_R0_R12
| (-44 & 0xffff), p
);
14552 bfd_put_32 (htab
->glink
->owner
, LD_R12_0R11
, p
);
14554 bfd_put_32 (htab
->glink
->owner
, SRDI_R0_R0_2
, p
);
14556 bfd_put_32 (htab
->glink
->owner
, MTCTR_R12
, p
);
14558 bfd_put_32 (htab
->glink
->owner
, LD_R11_0R11
| 8, p
);
14561 bfd_put_32 (htab
->glink
->owner
, BCTR
, p
);
14563 BFD_ASSERT (p
== htab
->glink
->contents
+ GLINK_PLTRESOLVE_SIZE (htab
));
14565 /* Build the .glink lazy link call stubs. */
14567 while (p
< htab
->glink
->contents
+ htab
->glink
->size
)
14573 bfd_put_32 (htab
->glink
->owner
, LI_R0_0
| indx
, p
);
14578 bfd_put_32 (htab
->glink
->owner
, LIS_R0_0
| PPC_HI (indx
), p
);
14580 bfd_put_32 (htab
->glink
->owner
, ORI_R0_R0_0
| PPC_LO (indx
),
14585 bfd_put_32 (htab
->glink
->owner
,
14586 B_DOT
| ((htab
->glink
->contents
- p
+ 8) & 0x3fffffc), p
);
14592 if (htab
->tga_group
!= NULL
)
14594 htab
->tga_group
->lr_restore
= 23 * 4;
14595 htab
->tga_group
->stub_sec
->size
= 24 * 4;
14596 if (!emit_tga_desc (htab
))
14598 if (htab
->glink_eh_frame
!= NULL
14599 && htab
->glink_eh_frame
->size
!= 0)
14603 p
= htab
->glink_eh_frame
->contents
;
14604 p
+= (sizeof (glink_eh_frame_cie
) + align
- 1) & -align
;
14606 htab
->tga_group
->eh_size
= emit_tga_desc_eh_frame (htab
, p
) - p
;
14610 /* Build .glink global entry stubs, and PLT relocs for globals. */
14611 elf_link_hash_traverse (&htab
->elf
, build_global_entry_stubs_and_plt
, info
);
14613 if (!write_plt_relocs_for_local_syms (info
))
14616 if (htab
->brlt
!= NULL
&& htab
->brlt
->size
!= 0)
14618 htab
->brlt
->contents
= bfd_zalloc (htab
->brlt
->owner
,
14620 if (htab
->brlt
->contents
== NULL
)
14623 if (htab
->relbrlt
!= NULL
&& htab
->relbrlt
->size
!= 0)
14625 htab
->relbrlt
->contents
= bfd_zalloc (htab
->relbrlt
->owner
,
14626 htab
->relbrlt
->size
);
14627 if (htab
->relbrlt
->contents
== NULL
)
14631 /* Build the stubs as directed by the stub hash table. */
14632 bfd_hash_traverse (&htab
->stub_hash_table
, ppc_build_one_stub
, info
);
14634 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14635 if (group
->needs_save_res
)
14636 group
->stub_sec
->size
+= htab
->sfpr
->size
;
14638 if (htab
->relbrlt
!= NULL
)
14639 htab
->relbrlt
->reloc_count
= 0;
14641 if (htab
->params
->plt_stub_align
!= 0)
14642 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14643 if ((stub_sec
= group
->stub_sec
) != NULL
)
14645 int align
= abs (htab
->params
->plt_stub_align
);
14646 stub_sec
->size
= (stub_sec
->size
+ (1 << align
) - 1) & -(1 << align
);
14649 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14650 if (group
->needs_save_res
)
14652 stub_sec
= group
->stub_sec
;
14653 memcpy (stub_sec
->contents
+ stub_sec
->size
- htab
->sfpr
->size
,
14654 htab
->sfpr
->contents
, htab
->sfpr
->size
);
14655 if (htab
->params
->emit_stub_syms
)
14659 for (i
= 0; i
< ARRAY_SIZE (save_res_funcs
); i
++)
14660 if (!sfpr_define (info
, &save_res_funcs
[i
], stub_sec
))
14665 if (htab
->glink_eh_frame
!= NULL
14666 && htab
->glink_eh_frame
->size
!= 0)
14671 p
= htab
->glink_eh_frame
->contents
;
14672 p
+= (sizeof (glink_eh_frame_cie
) + align
- 1) & -align
;
14674 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14675 if (group
->eh_size
!= 0)
14677 /* Offset to stub section. */
14678 val
= (group
->stub_sec
->output_section
->vma
14679 + group
->stub_sec
->output_offset
);
14680 val
-= (htab
->glink_eh_frame
->output_section
->vma
14681 + htab
->glink_eh_frame
->output_offset
14682 + (p
+ 8 - htab
->glink_eh_frame
->contents
));
14683 if (val
+ 0x80000000 > 0xffffffff)
14686 (_("%s offset too large for .eh_frame sdata4 encoding"),
14687 group
->stub_sec
->name
);
14690 bfd_put_32 (htab
->elf
.dynobj
, val
, p
+ 8);
14691 p
+= (group
->eh_size
+ 17 + 3) & -4;
14693 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
14695 /* Offset to .glink. */
14696 val
= (htab
->glink
->output_section
->vma
14697 + htab
->glink
->output_offset
14699 val
-= (htab
->glink_eh_frame
->output_section
->vma
14700 + htab
->glink_eh_frame
->output_offset
14701 + (p
+ 8 - htab
->glink_eh_frame
->contents
));
14702 if (val
+ 0x80000000 > 0xffffffff)
14705 (_("%s offset too large for .eh_frame sdata4 encoding"),
14706 htab
->glink
->name
);
14709 bfd_put_32 (htab
->elf
.dynobj
, val
, p
+ 8);
14710 p
+= (24 + align
- 1) & -align
;
14714 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14715 if ((stub_sec
= group
->stub_sec
) != NULL
)
14717 stub_sec_count
+= 1;
14718 if (stub_sec
->rawsize
!= stub_sec
->size
14719 && (htab
->stub_iteration
<= STUB_SHRINK_ITER
14720 || stub_sec
->rawsize
< stub_sec
->size
))
14726 htab
->stub_error
= TRUE
;
14727 _bfd_error_handler (_("stubs don't match calculated size"));
14730 if (htab
->stub_error
)
14736 if (asprintf (&groupmsg
,
14737 ngettext ("linker stubs in %u group\n",
14738 "linker stubs in %u groups\n",
14740 stub_sec_count
) < 0)
14744 if (asprintf (stats
, _("%s"
14746 " branch toc adj %lu\n"
14747 " branch notoc %lu\n"
14748 " branch both %lu\n"
14749 " long branch %lu\n"
14750 " long toc adj %lu\n"
14751 " long notoc %lu\n"
14754 " plt call save %lu\n"
14755 " plt call notoc %lu\n"
14756 " plt call both %lu\n"
14757 " global entry %lu"),
14759 htab
->stub_count
[ppc_stub_long_branch
- 1],
14760 htab
->stub_count
[ppc_stub_long_branch_r2off
- 1],
14761 htab
->stub_count
[ppc_stub_long_branch_notoc
- 1],
14762 htab
->stub_count
[ppc_stub_long_branch_both
- 1],
14763 htab
->stub_count
[ppc_stub_plt_branch
- 1],
14764 htab
->stub_count
[ppc_stub_plt_branch_r2off
- 1],
14765 htab
->stub_count
[ppc_stub_plt_branch_notoc
- 1],
14766 htab
->stub_count
[ppc_stub_plt_branch_both
- 1],
14767 htab
->stub_count
[ppc_stub_plt_call
- 1],
14768 htab
->stub_count
[ppc_stub_plt_call_r2save
- 1],
14769 htab
->stub_count
[ppc_stub_plt_call_notoc
- 1],
14770 htab
->stub_count
[ppc_stub_plt_call_both
- 1],
14771 htab
->stub_count
[ppc_stub_global_entry
- 1]) < 0)
14779 /* What to do when ld finds relocations against symbols defined in
14780 discarded sections. */
14782 static unsigned int
14783 ppc64_elf_action_discarded (asection
*sec
)
14785 if (strcmp (".opd", sec
->name
) == 0)
14788 if (strcmp (".toc", sec
->name
) == 0)
14791 if (strcmp (".toc1", sec
->name
) == 0)
14794 return _bfd_elf_default_action_discarded (sec
);
14797 /* These are the dynamic relocations supported by glibc. */
14800 ppc64_glibc_dynamic_reloc (enum elf_ppc64_reloc_type r_type
)
14804 case R_PPC64_RELATIVE
:
14806 case R_PPC64_ADDR64
:
14807 case R_PPC64_GLOB_DAT
:
14808 case R_PPC64_IRELATIVE
:
14809 case R_PPC64_JMP_IREL
:
14810 case R_PPC64_JMP_SLOT
:
14811 case R_PPC64_DTPMOD64
:
14812 case R_PPC64_DTPREL64
:
14813 case R_PPC64_TPREL64
:
14814 case R_PPC64_TPREL16_LO_DS
:
14815 case R_PPC64_TPREL16_DS
:
14816 case R_PPC64_TPREL16
:
14817 case R_PPC64_TPREL16_LO
:
14818 case R_PPC64_TPREL16_HI
:
14819 case R_PPC64_TPREL16_HIGH
:
14820 case R_PPC64_TPREL16_HA
:
14821 case R_PPC64_TPREL16_HIGHA
:
14822 case R_PPC64_TPREL16_HIGHER
:
14823 case R_PPC64_TPREL16_HIGHEST
:
14824 case R_PPC64_TPREL16_HIGHERA
:
14825 case R_PPC64_TPREL16_HIGHESTA
:
14826 case R_PPC64_ADDR16_LO_DS
:
14827 case R_PPC64_ADDR16_LO
:
14828 case R_PPC64_ADDR16_HI
:
14829 case R_PPC64_ADDR16_HIGH
:
14830 case R_PPC64_ADDR16_HA
:
14831 case R_PPC64_ADDR16_HIGHA
:
14832 case R_PPC64_REL30
:
14834 case R_PPC64_UADDR64
:
14835 case R_PPC64_UADDR32
:
14836 case R_PPC64_ADDR32
:
14837 case R_PPC64_ADDR24
:
14838 case R_PPC64_ADDR16
:
14839 case R_PPC64_UADDR16
:
14840 case R_PPC64_ADDR16_DS
:
14841 case R_PPC64_ADDR16_HIGHER
:
14842 case R_PPC64_ADDR16_HIGHEST
:
14843 case R_PPC64_ADDR16_HIGHERA
:
14844 case R_PPC64_ADDR16_HIGHESTA
:
14845 case R_PPC64_ADDR14
:
14846 case R_PPC64_ADDR14_BRTAKEN
:
14847 case R_PPC64_ADDR14_BRNTAKEN
:
14848 case R_PPC64_REL32
:
14849 case R_PPC64_REL64
:
14857 /* The RELOCATE_SECTION function is called by the ELF backend linker
14858 to handle the relocations for a section.
14860 The relocs are always passed as Rela structures; if the section
14861 actually uses Rel structures, the r_addend field will always be
14864 This function is responsible for adjust the section contents as
14865 necessary, and (if using Rela relocs and generating a
14866 relocatable output file) adjusting the reloc addend as
14869 This function does not have to worry about setting the reloc
14870 address or the reloc symbol index.
14872 LOCAL_SYMS is a pointer to the swapped in local symbols.
14874 LOCAL_SECTIONS is an array giving the section in the input file
14875 corresponding to the st_shndx field of each local symbol.
14877 The global hash table entry for the global symbols can be found
14878 via elf_sym_hashes (input_bfd).
14880 When generating relocatable output, this function must handle
14881 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
14882 going to be the section symbol corresponding to the output
14883 section, which means that the addend must be adjusted
14887 ppc64_elf_relocate_section (bfd
*output_bfd
,
14888 struct bfd_link_info
*info
,
14890 asection
*input_section
,
14891 bfd_byte
*contents
,
14892 Elf_Internal_Rela
*relocs
,
14893 Elf_Internal_Sym
*local_syms
,
14894 asection
**local_sections
)
14896 struct ppc_link_hash_table
*htab
;
14897 Elf_Internal_Shdr
*symtab_hdr
;
14898 struct elf_link_hash_entry
**sym_hashes
;
14899 Elf_Internal_Rela
*rel
;
14900 Elf_Internal_Rela
*wrel
;
14901 Elf_Internal_Rela
*relend
;
14902 Elf_Internal_Rela outrel
;
14904 struct got_entry
**local_got_ents
;
14906 bfd_boolean ret
= TRUE
;
14907 bfd_boolean is_opd
;
14908 /* Assume 'at' branch hints. */
14909 bfd_boolean is_isa_v2
= TRUE
;
14910 bfd_boolean warned_dynamic
= FALSE
;
14911 bfd_vma d_offset
= (bfd_big_endian (input_bfd
) ? 2 : 0);
14913 /* Initialize howto table if needed. */
14914 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
14917 htab
= ppc_hash_table (info
);
14921 /* Don't relocate stub sections. */
14922 if (input_section
->owner
== htab
->params
->stub_bfd
)
14925 if (!is_ppc64_elf (input_bfd
))
14927 bfd_set_error (bfd_error_wrong_format
);
14931 local_got_ents
= elf_local_got_ents (input_bfd
);
14932 TOCstart
= elf_gp (output_bfd
);
14933 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
14934 sym_hashes
= elf_sym_hashes (input_bfd
);
14935 is_opd
= ppc64_elf_section_data (input_section
)->sec_type
== sec_opd
;
14937 rel
= wrel
= relocs
;
14938 relend
= relocs
+ input_section
->reloc_count
;
14939 for (; rel
< relend
; wrel
++, rel
++)
14941 enum elf_ppc64_reloc_type r_type
;
14943 bfd_reloc_status_type r
;
14944 Elf_Internal_Sym
*sym
;
14946 struct elf_link_hash_entry
*h_elf
;
14947 struct ppc_link_hash_entry
*h
;
14948 struct ppc_link_hash_entry
*fdh
;
14949 const char *sym_name
;
14950 unsigned long r_symndx
, toc_symndx
;
14951 bfd_vma toc_addend
;
14952 unsigned char tls_mask
, tls_gd
, tls_type
;
14953 unsigned char sym_type
;
14954 bfd_vma relocation
;
14955 bfd_boolean unresolved_reloc
, save_unresolved_reloc
;
14956 bfd_boolean warned
;
14957 enum { DEST_NORMAL
, DEST_OPD
, DEST_STUB
} reloc_dest
;
14960 struct ppc_stub_hash_entry
*stub_entry
;
14961 bfd_vma max_br_offset
;
14963 Elf_Internal_Rela orig_rel
;
14964 reloc_howto_type
*howto
;
14965 struct reloc_howto_struct alt_howto
;
14972 r_type
= ELF64_R_TYPE (rel
->r_info
);
14973 r_symndx
= ELF64_R_SYM (rel
->r_info
);
14975 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
14976 symbol of the previous ADDR64 reloc. The symbol gives us the
14977 proper TOC base to use. */
14978 if (rel
->r_info
== ELF64_R_INFO (0, R_PPC64_TOC
)
14980 && ELF64_R_TYPE (wrel
[-1].r_info
) == R_PPC64_ADDR64
14982 r_symndx
= ELF64_R_SYM (wrel
[-1].r_info
);
14988 unresolved_reloc
= FALSE
;
14991 if (r_symndx
< symtab_hdr
->sh_info
)
14993 /* It's a local symbol. */
14994 struct _opd_sec_data
*opd
;
14996 sym
= local_syms
+ r_symndx
;
14997 sec
= local_sections
[r_symndx
];
14998 sym_name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
, sec
);
14999 sym_type
= ELF64_ST_TYPE (sym
->st_info
);
15000 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
15001 opd
= get_opd_info (sec
);
15002 if (opd
!= NULL
&& opd
->adjust
!= NULL
)
15004 long adjust
= opd
->adjust
[OPD_NDX (sym
->st_value
15010 /* If this is a relocation against the opd section sym
15011 and we have edited .opd, adjust the reloc addend so
15012 that ld -r and ld --emit-relocs output is correct.
15013 If it is a reloc against some other .opd symbol,
15014 then the symbol value will be adjusted later. */
15015 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
15016 rel
->r_addend
+= adjust
;
15018 relocation
+= adjust
;
15024 bfd_boolean ignored
;
15026 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
15027 r_symndx
, symtab_hdr
, sym_hashes
,
15028 h_elf
, sec
, relocation
,
15029 unresolved_reloc
, warned
, ignored
);
15030 sym_name
= h_elf
->root
.root
.string
;
15031 sym_type
= h_elf
->type
;
15033 && sec
->owner
== output_bfd
15034 && strcmp (sec
->name
, ".opd") == 0)
15036 /* This is a symbol defined in a linker script. All
15037 such are defined in output sections, even those
15038 defined by simple assignment from a symbol defined in
15039 an input section. Transfer the symbol to an
15040 appropriate input .opd section, so that a branch to
15041 this symbol will be mapped to the location specified
15042 by the opd entry. */
15043 struct bfd_link_order
*lo
;
15044 for (lo
= sec
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
15045 if (lo
->type
== bfd_indirect_link_order
)
15047 asection
*isec
= lo
->u
.indirect
.section
;
15048 if (h_elf
->root
.u
.def
.value
>= isec
->output_offset
15049 && h_elf
->root
.u
.def
.value
< (isec
->output_offset
15052 h_elf
->root
.u
.def
.value
-= isec
->output_offset
;
15053 h_elf
->root
.u
.def
.section
= isec
;
15060 h
= ppc_elf_hash_entry (h_elf
);
15062 if (sec
!= NULL
&& discarded_section (sec
))
15064 _bfd_clear_contents (ppc64_elf_howto_table
[r_type
],
15065 input_bfd
, input_section
,
15066 contents
, rel
->r_offset
);
15067 wrel
->r_offset
= rel
->r_offset
;
15069 wrel
->r_addend
= 0;
15071 /* For ld -r, remove relocations in debug sections against
15072 symbols defined in discarded sections. Not done for
15073 non-debug to preserve relocs in .eh_frame which the
15074 eh_frame editing code expects to be present. */
15075 if (bfd_link_relocatable (info
)
15076 && (input_section
->flags
& SEC_DEBUGGING
))
15082 if (bfd_link_relocatable (info
))
15085 if (h
!= NULL
&& &h
->elf
== htab
->elf
.hgot
)
15087 relocation
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
15088 sec
= bfd_abs_section_ptr
;
15089 unresolved_reloc
= FALSE
;
15092 /* TLS optimizations. Replace instruction sequences and relocs
15093 based on information we collected in tls_optimize. We edit
15094 RELOCS so that --emit-relocs will output something sensible
15095 for the final instruction stream. */
15100 tls_mask
= h
->tls_mask
;
15101 else if (local_got_ents
!= NULL
)
15103 struct plt_entry
**local_plt
= (struct plt_entry
**)
15104 (local_got_ents
+ symtab_hdr
->sh_info
);
15105 unsigned char *lgot_masks
= (unsigned char *)
15106 (local_plt
+ symtab_hdr
->sh_info
);
15107 tls_mask
= lgot_masks
[r_symndx
];
15109 if (((tls_mask
& TLS_TLS
) == 0 || tls_mask
== (TLS_TLS
| TLS_MARK
))
15110 && (r_type
== R_PPC64_TLS
15111 || r_type
== R_PPC64_TLSGD
15112 || r_type
== R_PPC64_TLSLD
))
15114 /* Check for toc tls entries. */
15115 unsigned char *toc_tls
;
15117 if (!get_tls_mask (&toc_tls
, &toc_symndx
, &toc_addend
,
15118 &local_syms
, rel
, input_bfd
))
15122 tls_mask
= *toc_tls
;
15125 /* Check that tls relocs are used with tls syms, and non-tls
15126 relocs are used with non-tls syms. */
15127 if (r_symndx
!= STN_UNDEF
15128 && r_type
!= R_PPC64_NONE
15130 || h
->elf
.root
.type
== bfd_link_hash_defined
15131 || h
->elf
.root
.type
== bfd_link_hash_defweak
)
15132 && IS_PPC64_TLS_RELOC (r_type
) != (sym_type
== STT_TLS
))
15134 if ((tls_mask
& TLS_TLS
) != 0
15135 && (r_type
== R_PPC64_TLS
15136 || r_type
== R_PPC64_TLSGD
15137 || r_type
== R_PPC64_TLSLD
))
15138 /* R_PPC64_TLS is OK against a symbol in the TOC. */
15141 info
->callbacks
->einfo
15142 (!IS_PPC64_TLS_RELOC (r_type
)
15143 /* xgettext:c-format */
15144 ? _("%H: %s used with TLS symbol `%pT'\n")
15145 /* xgettext:c-format */
15146 : _("%H: %s used with non-TLS symbol `%pT'\n"),
15147 input_bfd
, input_section
, rel
->r_offset
,
15148 ppc64_elf_howto_table
[r_type
]->name
,
15152 /* Ensure reloc mapping code below stays sane. */
15153 if (R_PPC64_TOC16_LO_DS
!= R_PPC64_TOC16_DS
+ 1
15154 || R_PPC64_TOC16_LO
!= R_PPC64_TOC16
+ 1
15155 || (R_PPC64_GOT_TLSLD16
& 3) != (R_PPC64_GOT_TLSGD16
& 3)
15156 || (R_PPC64_GOT_TLSLD16_LO
& 3) != (R_PPC64_GOT_TLSGD16_LO
& 3)
15157 || (R_PPC64_GOT_TLSLD16_HI
& 3) != (R_PPC64_GOT_TLSGD16_HI
& 3)
15158 || (R_PPC64_GOT_TLSLD16_HA
& 3) != (R_PPC64_GOT_TLSGD16_HA
& 3)
15159 || (R_PPC64_GOT_TLSLD16
& 3) != (R_PPC64_GOT_TPREL16_DS
& 3)
15160 || (R_PPC64_GOT_TLSLD16_LO
& 3) != (R_PPC64_GOT_TPREL16_LO_DS
& 3)
15161 || (R_PPC64_GOT_TLSLD16_HI
& 3) != (R_PPC64_GOT_TPREL16_HI
& 3)
15162 || (R_PPC64_GOT_TLSLD16_HA
& 3) != (R_PPC64_GOT_TPREL16_HA
& 3))
15170 case R_PPC64_LO_DS_OPT
:
15171 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
- d_offset
);
15172 if ((insn
& (0x3fu
<< 26)) != 58u << 26)
15174 insn
+= (14u << 26) - (58u << 26);
15175 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
- d_offset
);
15176 r_type
= R_PPC64_TOC16_LO
;
15177 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15180 case R_PPC64_TOC16
:
15181 case R_PPC64_TOC16_LO
:
15182 case R_PPC64_TOC16_DS
:
15183 case R_PPC64_TOC16_LO_DS
:
15185 /* Check for toc tls entries. */
15186 unsigned char *toc_tls
;
15189 retval
= get_tls_mask (&toc_tls
, &toc_symndx
, &toc_addend
,
15190 &local_syms
, rel
, input_bfd
);
15196 tls_mask
= *toc_tls
;
15197 if (r_type
== R_PPC64_TOC16_DS
15198 || r_type
== R_PPC64_TOC16_LO_DS
)
15200 if ((tls_mask
& TLS_TLS
) != 0
15201 && (tls_mask
& (TLS_DTPREL
| TLS_TPREL
)) == 0)
15206 /* If we found a GD reloc pair, then we might be
15207 doing a GD->IE transition. */
15211 if ((tls_mask
& TLS_TLS
) != 0
15212 && (tls_mask
& TLS_GD
) == 0)
15215 else if (retval
== 3)
15217 if ((tls_mask
& TLS_TLS
) != 0
15218 && (tls_mask
& TLS_LD
) == 0)
15226 case R_PPC64_GOT_TPREL16_HI
:
15227 case R_PPC64_GOT_TPREL16_HA
:
15228 if ((tls_mask
& TLS_TLS
) != 0
15229 && (tls_mask
& TLS_TPREL
) == 0)
15231 rel
->r_offset
-= d_offset
;
15232 bfd_put_32 (input_bfd
, NOP
, contents
+ rel
->r_offset
);
15233 r_type
= R_PPC64_NONE
;
15234 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15238 case R_PPC64_GOT_TPREL16_DS
:
15239 case R_PPC64_GOT_TPREL16_LO_DS
:
15240 if ((tls_mask
& TLS_TLS
) != 0
15241 && (tls_mask
& TLS_TPREL
) == 0)
15244 insn
= bfd_get_32 (input_bfd
,
15245 contents
+ rel
->r_offset
- d_offset
);
15247 insn
|= 0x3c0d0000; /* addis 0,13,0 */
15248 bfd_put_32 (input_bfd
, insn
,
15249 contents
+ rel
->r_offset
- d_offset
);
15250 r_type
= R_PPC64_TPREL16_HA
;
15251 if (toc_symndx
!= 0)
15253 rel
->r_info
= ELF64_R_INFO (toc_symndx
, r_type
);
15254 rel
->r_addend
= toc_addend
;
15255 /* We changed the symbol. Start over in order to
15256 get h, sym, sec etc. right. */
15260 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15264 case R_PPC64_GOT_TPREL_PCREL34
:
15265 if ((tls_mask
& TLS_TLS
) != 0
15266 && (tls_mask
& TLS_TPREL
) == 0)
15268 /* pld ra,sym@got@tprel@pcrel -> paddi ra,r13,sym@tprel */
15269 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15271 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15272 pinsn
+= ((2ULL << 56) + (-1ULL << 52)
15273 + (14ULL << 26) - (57ULL << 26) + (13ULL << 16));
15274 bfd_put_32 (input_bfd
, pinsn
>> 32,
15275 contents
+ rel
->r_offset
);
15276 bfd_put_32 (input_bfd
, pinsn
& 0xffffffff,
15277 contents
+ rel
->r_offset
+ 4);
15278 r_type
= R_PPC64_TPREL34
;
15279 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15284 if ((tls_mask
& TLS_TLS
) != 0
15285 && (tls_mask
& TLS_TPREL
) == 0)
15287 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
15288 insn
= _bfd_elf_ppc_at_tls_transform (insn
, 13);
15291 if ((rel
->r_offset
& 3) == 0)
15293 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
15294 /* Was PPC64_TLS which sits on insn boundary, now
15295 PPC64_TPREL16_LO which is at low-order half-word. */
15296 rel
->r_offset
+= d_offset
;
15297 r_type
= R_PPC64_TPREL16_LO
;
15298 if (toc_symndx
!= 0)
15300 rel
->r_info
= ELF64_R_INFO (toc_symndx
, r_type
);
15301 rel
->r_addend
= toc_addend
;
15302 /* We changed the symbol. Start over in order to
15303 get h, sym, sec etc. right. */
15307 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15309 else if ((rel
->r_offset
& 3) == 1)
15311 /* For pcrel IE to LE we already have the full
15312 offset and thus don't need an addi here. A nop
15314 if ((insn
& (0x3fu
<< 26)) == 14 << 26)
15316 /* Extract regs from addi rt,ra,si. */
15317 unsigned int rt
= (insn
>> 21) & 0x1f;
15318 unsigned int ra
= (insn
>> 16) & 0x1f;
15323 /* Build or ra,rs,rb with rb==rs, ie. mr ra,rs. */
15324 insn
= (rt
<< 16) | (ra
<< 21) | (ra
<< 11);
15325 insn
|= (31u << 26) | (444u << 1);
15328 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
- 1);
15333 case R_PPC64_GOT_TLSGD16_HI
:
15334 case R_PPC64_GOT_TLSGD16_HA
:
15336 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0)
15340 case R_PPC64_GOT_TLSLD16_HI
:
15341 case R_PPC64_GOT_TLSLD16_HA
:
15342 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0)
15345 if ((tls_mask
& tls_gd
) != 0)
15346 r_type
= (((r_type
- (R_PPC64_GOT_TLSGD16
& 3)) & 3)
15347 + R_PPC64_GOT_TPREL16_DS
);
15350 rel
->r_offset
-= d_offset
;
15351 bfd_put_32 (input_bfd
, NOP
, contents
+ rel
->r_offset
);
15352 r_type
= R_PPC64_NONE
;
15354 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15358 case R_PPC64_GOT_TLSGD16
:
15359 case R_PPC64_GOT_TLSGD16_LO
:
15361 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0)
15365 case R_PPC64_GOT_TLSLD16
:
15366 case R_PPC64_GOT_TLSLD16_LO
:
15367 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0)
15369 unsigned int insn1
, insn2
;
15372 offset
= (bfd_vma
) -1;
15373 /* If not using the newer R_PPC64_TLSGD/LD to mark
15374 __tls_get_addr calls, we must trust that the call
15375 stays with its arg setup insns, ie. that the next
15376 reloc is the __tls_get_addr call associated with
15377 the current reloc. Edit both insns. */
15378 if (input_section
->nomark_tls_get_addr
15379 && rel
+ 1 < relend
15380 && branch_reloc_hash_match (input_bfd
, rel
+ 1,
15381 htab
->tls_get_addr_fd
,
15383 htab
->tls_get_addr
,
15385 offset
= rel
[1].r_offset
;
15386 /* We read the low GOT_TLS (or TOC16) insn because we
15387 need to keep the destination reg. It may be
15388 something other than the usual r3, and moved to r3
15389 before the call by intervening code. */
15390 insn1
= bfd_get_32 (input_bfd
,
15391 contents
+ rel
->r_offset
- d_offset
);
15392 if ((tls_mask
& tls_gd
) != 0)
15395 insn1
&= (0x1f << 21) | (0x1f << 16);
15396 insn1
|= 58u << 26; /* ld */
15397 insn2
= 0x7c636a14; /* add 3,3,13 */
15398 if (offset
!= (bfd_vma
) -1)
15399 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
15400 if (r_type
== R_PPC64_TOC16
15401 || r_type
== R_PPC64_TOC16_LO
)
15402 r_type
+= R_PPC64_TOC16_DS
- R_PPC64_TOC16
;
15404 r_type
= (((r_type
- (R_PPC64_GOT_TLSGD16
& 1)) & 1)
15405 + R_PPC64_GOT_TPREL16_DS
);
15406 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15411 insn1
&= 0x1f << 21;
15412 insn1
|= 0x3c0d0000; /* addis r,13,0 */
15413 insn2
= 0x38630000; /* addi 3,3,0 */
15416 /* Was an LD reloc. */
15417 r_symndx
= STN_UNDEF
;
15418 rel
->r_addend
= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
15420 else if (toc_symndx
!= 0)
15422 r_symndx
= toc_symndx
;
15423 rel
->r_addend
= toc_addend
;
15425 r_type
= R_PPC64_TPREL16_HA
;
15426 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15427 if (offset
!= (bfd_vma
) -1)
15429 rel
[1].r_info
= ELF64_R_INFO (r_symndx
,
15430 R_PPC64_TPREL16_LO
);
15431 rel
[1].r_offset
= offset
+ d_offset
;
15432 rel
[1].r_addend
= rel
->r_addend
;
15435 bfd_put_32 (input_bfd
, insn1
,
15436 contents
+ rel
->r_offset
- d_offset
);
15437 if (offset
!= (bfd_vma
) -1)
15439 bfd_put_32 (input_bfd
, insn2
, contents
+ offset
);
15440 if (offset
+ 8 <= input_section
->size
)
15442 insn2
= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
15443 if (insn2
== LD_R2_0R1
+ STK_TOC (htab
))
15444 bfd_put_32 (input_bfd
, NOP
, contents
+ offset
+ 4);
15447 if ((tls_mask
& tls_gd
) == 0
15448 && (tls_gd
== 0 || toc_symndx
!= 0))
15450 /* We changed the symbol. Start over in order
15451 to get h, sym, sec etc. right. */
15457 case R_PPC64_GOT_TLSGD_PCREL34
:
15458 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0)
15460 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15462 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15463 if ((tls_mask
& TLS_GDIE
) != 0)
15465 /* IE, pla -> pld */
15466 pinsn
+= (-2ULL << 56) + (57ULL << 26) - (14ULL << 26);
15467 r_type
= R_PPC64_GOT_TPREL_PCREL34
;
15471 /* LE, pla pcrel -> paddi r13 */
15472 pinsn
+= (-1ULL << 52) + (13ULL << 16);
15473 r_type
= R_PPC64_TPREL34
;
15475 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15476 bfd_put_32 (input_bfd
, pinsn
>> 32,
15477 contents
+ rel
->r_offset
);
15478 bfd_put_32 (input_bfd
, pinsn
& 0xffffffff,
15479 contents
+ rel
->r_offset
+ 4);
15483 case R_PPC64_GOT_TLSLD_PCREL34
:
15484 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0)
15486 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15488 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15489 pinsn
+= (-1ULL << 52) + (13ULL << 16);
15490 bfd_put_32 (input_bfd
, pinsn
>> 32,
15491 contents
+ rel
->r_offset
);
15492 bfd_put_32 (input_bfd
, pinsn
& 0xffffffff,
15493 contents
+ rel
->r_offset
+ 4);
15494 rel
->r_addend
= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
15495 r_symndx
= STN_UNDEF
;
15496 r_type
= R_PPC64_TPREL34
;
15497 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15502 case R_PPC64_TLSGD
:
15503 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0
15504 && rel
+ 1 < relend
)
15506 unsigned int insn2
;
15507 enum elf_ppc64_reloc_type r_type1
= ELF64_R_TYPE (rel
[1].r_info
);
15509 offset
= rel
->r_offset
;
15510 if (is_plt_seq_reloc (r_type1
))
15512 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
);
15513 if (r_type1
== R_PPC64_PLT_PCREL34
15514 || r_type1
== R_PPC64_PLT_PCREL34_NOTOC
)
15515 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
15516 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
15520 if (ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_PLTCALL
)
15521 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
15523 if ((tls_mask
& TLS_GDIE
) != 0)
15526 r_type
= R_PPC64_NONE
;
15527 insn2
= 0x7c636a14; /* add 3,3,13 */
15532 if (toc_symndx
!= 0)
15534 r_symndx
= toc_symndx
;
15535 rel
->r_addend
= toc_addend
;
15537 if (r_type1
== R_PPC64_REL24_NOTOC
15538 || r_type1
== R_PPC64_PLTCALL_NOTOC
)
15540 r_type
= R_PPC64_NONE
;
15545 rel
->r_offset
= offset
+ d_offset
;
15546 r_type
= R_PPC64_TPREL16_LO
;
15547 insn2
= 0x38630000; /* addi 3,3,0 */
15550 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15551 /* Zap the reloc on the _tls_get_addr call too. */
15552 BFD_ASSERT (offset
== rel
[1].r_offset
);
15553 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
15554 bfd_put_32 (input_bfd
, insn2
, contents
+ offset
);
15555 if ((tls_mask
& TLS_GDIE
) == 0
15557 && r_type
!= R_PPC64_NONE
)
15562 case R_PPC64_TLSLD
:
15563 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0
15564 && rel
+ 1 < relend
)
15566 unsigned int insn2
;
15567 enum elf_ppc64_reloc_type r_type1
= ELF64_R_TYPE (rel
[1].r_info
);
15569 offset
= rel
->r_offset
;
15570 if (is_plt_seq_reloc (r_type1
))
15572 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
);
15573 if (r_type1
== R_PPC64_PLT_PCREL34
15574 || r_type1
== R_PPC64_PLT_PCREL34_NOTOC
)
15575 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
15576 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
15580 if (ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_PLTCALL
)
15581 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
15583 if (r_type1
== R_PPC64_REL24_NOTOC
15584 || r_type1
== R_PPC64_PLTCALL_NOTOC
)
15586 r_type
= R_PPC64_NONE
;
15591 rel
->r_offset
= offset
+ d_offset
;
15592 r_symndx
= STN_UNDEF
;
15593 r_type
= R_PPC64_TPREL16_LO
;
15594 rel
->r_addend
= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
15595 insn2
= 0x38630000; /* addi 3,3,0 */
15597 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15598 /* Zap the reloc on the _tls_get_addr call too. */
15599 BFD_ASSERT (offset
== rel
[1].r_offset
);
15600 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
15601 bfd_put_32 (input_bfd
, insn2
, contents
+ offset
);
15602 if (r_type
!= R_PPC64_NONE
)
15607 case R_PPC64_DTPMOD64
:
15608 if (rel
+ 1 < relend
15609 && rel
[1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_DTPREL64
)
15610 && rel
[1].r_offset
== rel
->r_offset
+ 8)
15612 if ((tls_mask
& TLS_GD
) == 0)
15614 rel
[1].r_info
= ELF64_R_INFO (r_symndx
, R_PPC64_NONE
);
15615 if ((tls_mask
& TLS_GDIE
) != 0)
15616 r_type
= R_PPC64_TPREL64
;
15619 bfd_put_64 (output_bfd
, 1, contents
+ rel
->r_offset
);
15620 r_type
= R_PPC64_NONE
;
15622 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15627 if ((tls_mask
& TLS_LD
) == 0)
15629 bfd_put_64 (output_bfd
, 1, contents
+ rel
->r_offset
);
15630 r_type
= R_PPC64_NONE
;
15631 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15636 case R_PPC64_TPREL64
:
15637 if ((tls_mask
& TLS_TPREL
) == 0)
15639 r_type
= R_PPC64_NONE
;
15640 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15644 case R_PPC64_ENTRY
:
15645 relocation
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
15646 if (!bfd_link_pic (info
)
15647 && !info
->traditional_format
15648 && relocation
+ 0x80008000 <= 0xffffffff)
15650 unsigned int insn1
, insn2
;
15652 insn1
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15653 insn2
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15654 if ((insn1
& ~0xfffc) == LD_R2_0R12
15655 && insn2
== ADD_R2_R2_R12
)
15657 bfd_put_32 (input_bfd
,
15658 LIS_R2
+ PPC_HA (relocation
),
15659 contents
+ rel
->r_offset
);
15660 bfd_put_32 (input_bfd
,
15661 ADDI_R2_R2
+ PPC_LO (relocation
),
15662 contents
+ rel
->r_offset
+ 4);
15667 relocation
-= (rel
->r_offset
15668 + input_section
->output_offset
15669 + input_section
->output_section
->vma
);
15670 if (relocation
+ 0x80008000 <= 0xffffffff)
15672 unsigned int insn1
, insn2
;
15674 insn1
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15675 insn2
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15676 if ((insn1
& ~0xfffc) == LD_R2_0R12
15677 && insn2
== ADD_R2_R2_R12
)
15679 bfd_put_32 (input_bfd
,
15680 ADDIS_R2_R12
+ PPC_HA (relocation
),
15681 contents
+ rel
->r_offset
);
15682 bfd_put_32 (input_bfd
,
15683 ADDI_R2_R2
+ PPC_LO (relocation
),
15684 contents
+ rel
->r_offset
+ 4);
15690 case R_PPC64_REL16_HA
:
15691 /* If we are generating a non-PIC executable, edit
15692 . 0: addis 2,12,.TOC.-0b@ha
15693 . addi 2,2,.TOC.-0b@l
15694 used by ELFv2 global entry points to set up r2, to
15697 if .TOC. is in range. */
15698 if (!bfd_link_pic (info
)
15699 && !info
->traditional_format
15701 && rel
->r_addend
== d_offset
15702 && h
!= NULL
&& &h
->elf
== htab
->elf
.hgot
15703 && rel
+ 1 < relend
15704 && rel
[1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_REL16_LO
)
15705 && rel
[1].r_offset
== rel
->r_offset
+ 4
15706 && rel
[1].r_addend
== rel
->r_addend
+ 4
15707 && relocation
+ 0x80008000 <= 0xffffffff)
15709 unsigned int insn1
, insn2
;
15710 offset
= rel
->r_offset
- d_offset
;
15711 insn1
= bfd_get_32 (input_bfd
, contents
+ offset
);
15712 insn2
= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
15713 if ((insn1
& 0xffff0000) == ADDIS_R2_R12
15714 && (insn2
& 0xffff0000) == ADDI_R2_R2
)
15716 r_type
= R_PPC64_ADDR16_HA
;
15717 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15718 rel
->r_addend
-= d_offset
;
15719 rel
[1].r_info
= ELF64_R_INFO (r_symndx
, R_PPC64_ADDR16_LO
);
15720 rel
[1].r_addend
-= d_offset
+ 4;
15721 bfd_put_32 (input_bfd
, LIS_R2
, contents
+ offset
);
15727 /* Handle other relocations that tweak non-addend part of insn. */
15729 max_br_offset
= 1 << 25;
15730 addend
= rel
->r_addend
;
15731 reloc_dest
= DEST_NORMAL
;
15737 case R_PPC64_TOCSAVE
:
15738 if (relocation
+ addend
== (rel
->r_offset
15739 + input_section
->output_offset
15740 + input_section
->output_section
->vma
)
15741 && tocsave_find (htab
, NO_INSERT
,
15742 &local_syms
, rel
, input_bfd
))
15744 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15746 || insn
== CROR_151515
|| insn
== CROR_313131
)
15747 bfd_put_32 (input_bfd
,
15748 STD_R2_0R1
+ STK_TOC (htab
),
15749 contents
+ rel
->r_offset
);
15753 /* Branch taken prediction relocations. */
15754 case R_PPC64_ADDR14_BRTAKEN
:
15755 case R_PPC64_REL14_BRTAKEN
:
15756 insn
= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
15757 /* Fall through. */
15759 /* Branch not taken prediction relocations. */
15760 case R_PPC64_ADDR14_BRNTAKEN
:
15761 case R_PPC64_REL14_BRNTAKEN
:
15762 insn
|= bfd_get_32 (input_bfd
,
15763 contents
+ rel
->r_offset
) & ~(0x01 << 21);
15764 /* Fall through. */
15766 case R_PPC64_REL14
:
15767 max_br_offset
= 1 << 15;
15768 /* Fall through. */
15770 case R_PPC64_REL24
:
15771 case R_PPC64_REL24_NOTOC
:
15772 case R_PPC64_PLTCALL
:
15773 case R_PPC64_PLTCALL_NOTOC
:
15774 /* Calls to functions with a different TOC, such as calls to
15775 shared objects, need to alter the TOC pointer. This is
15776 done using a linkage stub. A REL24 branching to these
15777 linkage stubs needs to be followed by a nop, as the nop
15778 will be replaced with an instruction to restore the TOC
15783 && h
->oh
->is_func_descriptor
)
15784 fdh
= ppc_follow_link (h
->oh
);
15785 stub_entry
= ppc_get_stub_entry (input_section
, sec
, fdh
, &orig_rel
,
15787 if ((r_type
== R_PPC64_PLTCALL
15788 || r_type
== R_PPC64_PLTCALL_NOTOC
)
15789 && stub_entry
!= NULL
15790 && stub_entry
->stub_type
>= ppc_stub_plt_call
15791 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15794 if (stub_entry
!= NULL
15795 && ((stub_entry
->stub_type
>= ppc_stub_plt_call
15796 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15797 || stub_entry
->stub_type
== ppc_stub_plt_branch_r2off
15798 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
15799 || stub_entry
->stub_type
== ppc_stub_long_branch_r2off
15800 || stub_entry
->stub_type
== ppc_stub_long_branch_both
))
15802 bfd_boolean can_plt_call
= FALSE
;
15804 if (stub_entry
->stub_type
== ppc_stub_plt_call
15806 && htab
->params
->plt_localentry0
!= 0
15808 && is_elfv2_localentry0 (&h
->elf
))
15810 /* The function doesn't use or change r2. */
15811 can_plt_call
= TRUE
;
15813 else if (r_type
== R_PPC64_REL24_NOTOC
)
15815 /* NOTOC calls don't need to restore r2. */
15816 can_plt_call
= TRUE
;
15819 /* All of these stubs may modify r2, so there must be a
15820 branch and link followed by a nop. The nop is
15821 replaced by an insn to restore r2. */
15822 else if (rel
->r_offset
+ 8 <= input_section
->size
)
15826 br
= bfd_get_32 (input_bfd
,
15827 contents
+ rel
->r_offset
);
15832 nop
= bfd_get_32 (input_bfd
,
15833 contents
+ rel
->r_offset
+ 4);
15834 if (nop
== LD_R2_0R1
+ STK_TOC (htab
))
15835 can_plt_call
= TRUE
;
15836 else if (nop
== NOP
15837 || nop
== CROR_151515
15838 || nop
== CROR_313131
)
15841 && is_tls_get_addr (&h
->elf
, htab
)
15842 && htab
->params
->tls_get_addr_opt
)
15844 /* Special stub used, leave nop alone. */
15847 bfd_put_32 (input_bfd
,
15848 LD_R2_0R1
+ STK_TOC (htab
),
15849 contents
+ rel
->r_offset
+ 4);
15850 can_plt_call
= TRUE
;
15855 if (!can_plt_call
&& h
!= NULL
)
15857 const char *name
= h
->elf
.root
.root
.string
;
15862 if (strncmp (name
, "__libc_start_main", 17) == 0
15863 && (name
[17] == 0 || name
[17] == '@'))
15865 /* Allow crt1 branch to go via a toc adjusting
15866 stub. Other calls that never return could do
15867 the same, if we could detect such. */
15868 can_plt_call
= TRUE
;
15874 /* g++ as of 20130507 emits self-calls without a
15875 following nop. This is arguably wrong since we
15876 have conflicting information. On the one hand a
15877 global symbol and on the other a local call
15878 sequence, but don't error for this special case.
15879 It isn't possible to cheaply verify we have
15880 exactly such a call. Allow all calls to the same
15882 asection
*code_sec
= sec
;
15884 if (get_opd_info (sec
) != NULL
)
15886 bfd_vma off
= (relocation
+ addend
15887 - sec
->output_section
->vma
15888 - sec
->output_offset
);
15890 opd_entry_value (sec
, off
, &code_sec
, NULL
, FALSE
);
15892 if (code_sec
== input_section
)
15893 can_plt_call
= TRUE
;
15898 if (stub_entry
->stub_type
>= ppc_stub_plt_call
15899 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15900 info
->callbacks
->einfo
15901 /* xgettext:c-format */
15902 (_("%H: call to `%pT' lacks nop, can't restore toc; "
15903 "(plt call stub)\n"),
15904 input_bfd
, input_section
, rel
->r_offset
, sym_name
);
15906 info
->callbacks
->einfo
15907 /* xgettext:c-format */
15908 (_("%H: call to `%pT' lacks nop, can't restore toc; "
15909 "(toc save/adjust stub)\n"),
15910 input_bfd
, input_section
, rel
->r_offset
, sym_name
);
15912 bfd_set_error (bfd_error_bad_value
);
15917 && stub_entry
->stub_type
>= ppc_stub_plt_call
15918 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15919 unresolved_reloc
= FALSE
;
15922 if ((stub_entry
== NULL
15923 || stub_entry
->stub_type
== ppc_stub_long_branch
15924 || stub_entry
->stub_type
== ppc_stub_plt_branch
)
15925 && get_opd_info (sec
) != NULL
)
15927 /* The branch destination is the value of the opd entry. */
15928 bfd_vma off
= (relocation
+ addend
15929 - sec
->output_section
->vma
15930 - sec
->output_offset
);
15931 bfd_vma dest
= opd_entry_value (sec
, off
, NULL
, NULL
, FALSE
);
15932 if (dest
!= (bfd_vma
) -1)
15936 reloc_dest
= DEST_OPD
;
15940 /* If the branch is out of reach we ought to have a long
15942 from
= (rel
->r_offset
15943 + input_section
->output_offset
15944 + input_section
->output_section
->vma
);
15946 relocation
+= PPC64_LOCAL_ENTRY_OFFSET (fdh
15950 if (stub_entry
!= NULL
15951 && (stub_entry
->stub_type
== ppc_stub_long_branch
15952 || stub_entry
->stub_type
== ppc_stub_plt_branch
)
15953 && (r_type
== R_PPC64_ADDR14_BRTAKEN
15954 || r_type
== R_PPC64_ADDR14_BRNTAKEN
15955 || (relocation
+ addend
- from
+ max_br_offset
15956 < 2 * max_br_offset
)))
15957 /* Don't use the stub if this branch is in range. */
15960 if (stub_entry
!= NULL
15961 && (stub_entry
->stub_type
== ppc_stub_long_branch_notoc
15962 || stub_entry
->stub_type
== ppc_stub_long_branch_both
15963 || stub_entry
->stub_type
== ppc_stub_plt_branch_notoc
15964 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
)
15965 && (r_type
!= R_PPC64_REL24_NOTOC
15966 || ((fdh
? fdh
->elf
.other
: sym
->st_other
)
15967 & STO_PPC64_LOCAL_MASK
) <= 1 << STO_PPC64_LOCAL_BIT
)
15968 && (relocation
+ addend
- from
+ max_br_offset
15969 < 2 * max_br_offset
))
15972 if (stub_entry
!= NULL
15973 && (stub_entry
->stub_type
== ppc_stub_long_branch_r2off
15974 || stub_entry
->stub_type
== ppc_stub_long_branch_both
15975 || stub_entry
->stub_type
== ppc_stub_plt_branch_r2off
15976 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
)
15977 && r_type
== R_PPC64_REL24_NOTOC
15978 && (relocation
+ addend
- from
+ max_br_offset
15979 < 2 * max_br_offset
))
15982 if (stub_entry
!= NULL
)
15984 /* Munge up the value and addend so that we call the stub
15985 rather than the procedure directly. */
15986 asection
*stub_sec
= stub_entry
->group
->stub_sec
;
15988 if (stub_entry
->stub_type
== ppc_stub_save_res
)
15989 relocation
+= (stub_sec
->output_offset
15990 + stub_sec
->output_section
->vma
15991 + stub_sec
->size
- htab
->sfpr
->size
15992 - htab
->sfpr
->output_offset
15993 - htab
->sfpr
->output_section
->vma
);
15995 relocation
= (stub_entry
->stub_offset
15996 + stub_sec
->output_offset
15997 + stub_sec
->output_section
->vma
);
15999 reloc_dest
= DEST_STUB
;
16001 if ((((stub_entry
->stub_type
== ppc_stub_plt_call
16002 && ALWAYS_EMIT_R2SAVE
)
16003 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
16004 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
16005 && rel
+ 1 < relend
16006 && rel
[1].r_offset
== rel
->r_offset
+ 4
16007 && ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_TOCSAVE
)
16008 || ((stub_entry
->stub_type
== ppc_stub_long_branch_both
16009 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
16010 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
16011 && r_type
== R_PPC64_REL24_NOTOC
))
16013 /* Skip over the r2 store at the start of the stub. */
16014 if (!(stub_entry
->stub_type
>= ppc_stub_plt_call
16015 && htab
->params
->tls_get_addr_opt
16017 && is_tls_get_addr (&h
->elf
, htab
)))
16021 if (r_type
== R_PPC64_REL24_NOTOC
16022 && (stub_entry
->stub_type
== ppc_stub_plt_call_notoc
16023 || stub_entry
->stub_type
== ppc_stub_plt_call_both
))
16024 htab
->notoc_plt
= 1;
16031 /* Set 'a' bit. This is 0b00010 in BO field for branch
16032 on CR(BI) insns (BO == 001at or 011at), and 0b01000
16033 for branch on CTR insns (BO == 1a00t or 1a01t). */
16034 if ((insn
& (0x14 << 21)) == (0x04 << 21))
16035 insn
|= 0x02 << 21;
16036 else if ((insn
& (0x14 << 21)) == (0x10 << 21))
16037 insn
|= 0x08 << 21;
16043 /* Invert 'y' bit if not the default. */
16044 if ((bfd_signed_vma
) (relocation
+ addend
- from
) < 0)
16045 insn
^= 0x01 << 21;
16048 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
16051 /* NOP out calls to undefined weak functions.
16052 We can thus call a weak function without first
16053 checking whether the function is defined. */
16055 && h
->elf
.root
.type
== bfd_link_hash_undefweak
16056 && h
->elf
.dynindx
== -1
16057 && (r_type
== R_PPC64_REL24
16058 || r_type
== R_PPC64_REL24_NOTOC
)
16062 bfd_put_32 (input_bfd
, NOP
, contents
+ rel
->r_offset
);
16067 case R_PPC64_GOT16_DS
:
16068 if ((h
? h
->elf
.type
: ELF_ST_TYPE (sym
->st_info
)) == STT_GNU_IFUNC
16069 || !htab
->do_toc_opt
)
16071 from
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
16072 if (relocation
+ addend
- from
+ 0x8000 < 0x10000
16073 && (h
== NULL
|| SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
)))
16075 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
16076 if ((insn
& (0x3fu
<< 26 | 0x3)) == 58u << 26 /* ld */)
16078 insn
+= (14u << 26) - (58u << 26);
16079 bfd_put_32 (input_bfd
, insn
, contents
+ (rel
->r_offset
& ~3));
16080 r_type
= R_PPC64_TOC16
;
16081 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
16086 case R_PPC64_GOT16_LO_DS
:
16087 case R_PPC64_GOT16_HA
:
16088 if ((h
? h
->elf
.type
: ELF_ST_TYPE (sym
->st_info
)) == STT_GNU_IFUNC
16089 || !htab
->do_toc_opt
)
16091 from
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
16092 if (relocation
+ addend
- from
+ 0x80008000ULL
< 0x100000000ULL
16093 && (h
== NULL
|| SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
)))
16095 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
16096 if (r_type
== R_PPC64_GOT16_LO_DS
16097 && (insn
& (0x3fu
<< 26 | 0x3)) == 58u << 26 /* ld */)
16099 insn
+= (14u << 26) - (58u << 26);
16100 bfd_put_32 (input_bfd
, insn
, contents
+ (rel
->r_offset
& ~3));
16101 r_type
= R_PPC64_TOC16_LO
;
16102 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
16104 else if (r_type
== R_PPC64_GOT16_HA
16105 && (insn
& (0x3fu
<< 26)) == 15u << 26 /* addis */)
16107 r_type
= R_PPC64_TOC16_HA
;
16108 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
16113 case R_PPC64_GOT_PCREL34
:
16114 if ((h
? h
->elf
.type
: ELF_ST_TYPE (sym
->st_info
)) == STT_GNU_IFUNC
16115 || !htab
->do_toc_opt
)
16117 from
= (rel
->r_offset
16118 + input_section
->output_section
->vma
16119 + input_section
->output_offset
);
16120 if (!(relocation
- from
+ (1ULL << 33) < 1ULL << 34
16121 && (h
== NULL
|| SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))))
16124 offset
= rel
->r_offset
;
16125 pinsn
= bfd_get_32 (input_bfd
, contents
+ offset
);
16127 pinsn
|= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
16128 if ((pinsn
& ((-1ULL << 50) | (63ULL << 26)))
16129 != ((1ULL << 58) | (1ULL << 52) | (57ULL << 26) /* pld */))
16132 /* Replace with paddi. */
16133 pinsn
+= (2ULL << 56) + (14ULL << 26) - (57ULL << 26);
16134 r_type
= R_PPC64_PCREL34
;
16135 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
16136 bfd_put_32 (input_bfd
, pinsn
>> 32, contents
+ offset
);
16137 bfd_put_32 (input_bfd
, pinsn
, contents
+ offset
+ 4);
16138 /* Fall through. */
16140 case R_PPC64_PCREL34
:
16141 if (!htab
->params
->no_pcrel_opt
16142 && rel
+ 1 < relend
16143 && rel
[1].r_offset
== rel
->r_offset
16144 && rel
[1].r_info
== ELF64_R_INFO (0, R_PPC64_PCREL_OPT
)
16145 && (h
== NULL
|| SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
)))
16147 offset
= rel
->r_offset
;
16148 pinsn
= bfd_get_32 (input_bfd
, contents
+ offset
);
16150 pinsn
|= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
16151 if ((pinsn
& ((-1ULL << 50) | (63ULL << 26)))
16152 == ((1ULL << 58) | (2ULL << 56) | (1ULL << 52)
16153 | (14ULL << 26) /* paddi */))
16155 bfd_vma off2
= rel
[1].r_addend
;
16157 /* zero means next insn. */
16160 if (off2
+ 4 <= input_section
->size
)
16163 bfd_signed_vma addend_off
;
16164 pinsn2
= bfd_get_32 (input_bfd
, contents
+ off2
);
16166 if ((pinsn2
& (63ULL << 58)) == 1ULL << 58)
16168 if (off2
+ 8 > input_section
->size
)
16170 pinsn2
|= bfd_get_32 (input_bfd
,
16171 contents
+ off2
+ 4);
16173 if (xlate_pcrel_opt (&pinsn
, &pinsn2
, &addend_off
))
16175 addend
+= addend_off
;
16176 rel
->r_addend
= addend
;
16177 bfd_put_32 (input_bfd
, pinsn
>> 32,
16178 contents
+ offset
);
16179 bfd_put_32 (input_bfd
, pinsn
,
16180 contents
+ offset
+ 4);
16181 bfd_put_32 (input_bfd
, pinsn2
>> 32,
16183 if ((pinsn2
& (63ULL << 58)) == 1ULL << 58)
16184 bfd_put_32 (input_bfd
, pinsn2
,
16185 contents
+ off2
+ 4);
16194 save_unresolved_reloc
= unresolved_reloc
;
16198 /* xgettext:c-format */
16199 _bfd_error_handler (_("%pB: %s unsupported"),
16200 input_bfd
, ppc64_elf_howto_table
[r_type
]->name
);
16202 bfd_set_error (bfd_error_bad_value
);
16208 case R_PPC64_TLSGD
:
16209 case R_PPC64_TLSLD
:
16210 case R_PPC64_TOCSAVE
:
16211 case R_PPC64_GNU_VTINHERIT
:
16212 case R_PPC64_GNU_VTENTRY
:
16213 case R_PPC64_ENTRY
:
16214 case R_PPC64_PCREL_OPT
:
16217 /* GOT16 relocations. Like an ADDR16 using the symbol's
16218 address in the GOT as relocation value instead of the
16219 symbol's value itself. Also, create a GOT entry for the
16220 symbol and put the symbol value there. */
16221 case R_PPC64_GOT_TLSGD16
:
16222 case R_PPC64_GOT_TLSGD16_LO
:
16223 case R_PPC64_GOT_TLSGD16_HI
:
16224 case R_PPC64_GOT_TLSGD16_HA
:
16225 case R_PPC64_GOT_TLSGD_PCREL34
:
16226 tls_type
= TLS_TLS
| TLS_GD
;
16229 case R_PPC64_GOT_TLSLD16
:
16230 case R_PPC64_GOT_TLSLD16_LO
:
16231 case R_PPC64_GOT_TLSLD16_HI
:
16232 case R_PPC64_GOT_TLSLD16_HA
:
16233 case R_PPC64_GOT_TLSLD_PCREL34
:
16234 tls_type
= TLS_TLS
| TLS_LD
;
16237 case R_PPC64_GOT_TPREL16_DS
:
16238 case R_PPC64_GOT_TPREL16_LO_DS
:
16239 case R_PPC64_GOT_TPREL16_HI
:
16240 case R_PPC64_GOT_TPREL16_HA
:
16241 case R_PPC64_GOT_TPREL_PCREL34
:
16242 tls_type
= TLS_TLS
| TLS_TPREL
;
16245 case R_PPC64_GOT_DTPREL16_DS
:
16246 case R_PPC64_GOT_DTPREL16_LO_DS
:
16247 case R_PPC64_GOT_DTPREL16_HI
:
16248 case R_PPC64_GOT_DTPREL16_HA
:
16249 case R_PPC64_GOT_DTPREL_PCREL34
:
16250 tls_type
= TLS_TLS
| TLS_DTPREL
;
16253 case R_PPC64_GOT16
:
16254 case R_PPC64_GOT16_LO
:
16255 case R_PPC64_GOT16_HI
:
16256 case R_PPC64_GOT16_HA
:
16257 case R_PPC64_GOT16_DS
:
16258 case R_PPC64_GOT16_LO_DS
:
16259 case R_PPC64_GOT_PCREL34
:
16262 /* Relocation is to the entry for this symbol in the global
16267 unsigned long indx
= 0;
16268 struct got_entry
*ent
;
16270 if (tls_type
== (TLS_TLS
| TLS_LD
)
16271 && (h
== NULL
|| SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
)))
16272 ent
= ppc64_tlsld_got (input_bfd
);
16277 if (!htab
->elf
.dynamic_sections_created
16278 || h
->elf
.dynindx
== -1
16279 || SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
)
16280 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, &h
->elf
))
16281 /* This is actually a static link, or it is a
16282 -Bsymbolic link and the symbol is defined
16283 locally, or the symbol was forced to be local
16284 because of a version file. */
16288 indx
= h
->elf
.dynindx
;
16289 unresolved_reloc
= FALSE
;
16291 ent
= h
->elf
.got
.glist
;
16295 if (local_got_ents
== NULL
)
16297 ent
= local_got_ents
[r_symndx
];
16300 for (; ent
!= NULL
; ent
= ent
->next
)
16301 if (ent
->addend
== orig_rel
.r_addend
16302 && ent
->owner
== input_bfd
16303 && ent
->tls_type
== tls_type
)
16309 if (ent
->is_indirect
)
16310 ent
= ent
->got
.ent
;
16311 offp
= &ent
->got
.offset
;
16312 got
= ppc64_elf_tdata (ent
->owner
)->got
;
16316 /* The offset must always be a multiple of 8. We use the
16317 least significant bit to record whether we have already
16318 processed this entry. */
16320 if ((off
& 1) != 0)
16324 /* Generate relocs for the dynamic linker, except in
16325 the case of TLSLD where we'll use one entry per
16333 ? h
->elf
.type
== STT_GNU_IFUNC
16334 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
);
16337 relgot
= htab
->elf
.irelplt
;
16338 if (indx
== 0 || is_static_defined (&h
->elf
))
16339 htab
->elf
.ifunc_resolvers
= TRUE
;
16342 || (bfd_link_pic (info
)
16344 || !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, &h
->elf
))
16346 && bfd_link_executable (info
)
16348 || SYMBOL_REFERENCES_LOCAL (info
,
16350 relgot
= ppc64_elf_tdata (ent
->owner
)->relgot
;
16351 if (relgot
!= NULL
)
16353 outrel
.r_offset
= (got
->output_section
->vma
16354 + got
->output_offset
16356 outrel
.r_addend
= orig_rel
.r_addend
;
16357 if (tls_type
& (TLS_LD
| TLS_GD
))
16359 outrel
.r_addend
= 0;
16360 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_DTPMOD64
);
16361 if (tls_type
== (TLS_TLS
| TLS_GD
))
16363 loc
= relgot
->contents
;
16364 loc
+= (relgot
->reloc_count
++
16365 * sizeof (Elf64_External_Rela
));
16366 bfd_elf64_swap_reloca_out (output_bfd
,
16368 outrel
.r_offset
+= 8;
16369 outrel
.r_addend
= orig_rel
.r_addend
;
16371 = ELF64_R_INFO (indx
, R_PPC64_DTPREL64
);
16374 else if (tls_type
== (TLS_TLS
| TLS_DTPREL
))
16375 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_DTPREL64
);
16376 else if (tls_type
== (TLS_TLS
| TLS_TPREL
))
16377 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_TPREL64
);
16378 else if (indx
!= 0)
16379 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_GLOB_DAT
);
16383 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
16385 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
16387 /* Write the .got section contents for the sake
16389 loc
= got
->contents
+ off
;
16390 bfd_put_64 (output_bfd
, outrel
.r_addend
+ relocation
,
16394 if (indx
== 0 && tls_type
!= (TLS_TLS
| TLS_LD
))
16396 outrel
.r_addend
+= relocation
;
16397 if (tls_type
& (TLS_GD
| TLS_DTPREL
| TLS_TPREL
))
16399 if (htab
->elf
.tls_sec
== NULL
)
16400 outrel
.r_addend
= 0;
16402 outrel
.r_addend
-= htab
->elf
.tls_sec
->vma
;
16405 loc
= relgot
->contents
;
16406 loc
+= (relgot
->reloc_count
++
16407 * sizeof (Elf64_External_Rela
));
16408 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
16411 /* Init the .got section contents here if we're not
16412 emitting a reloc. */
16415 relocation
+= orig_rel
.r_addend
;
16418 if (htab
->elf
.tls_sec
== NULL
)
16422 if (tls_type
& TLS_LD
)
16425 relocation
-= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
16426 if (tls_type
& TLS_TPREL
)
16427 relocation
+= DTP_OFFSET
- TP_OFFSET
;
16430 if (tls_type
& (TLS_GD
| TLS_LD
))
16432 bfd_put_64 (output_bfd
, relocation
,
16433 got
->contents
+ off
+ 8);
16437 bfd_put_64 (output_bfd
, relocation
,
16438 got
->contents
+ off
);
16442 if (off
>= (bfd_vma
) -2)
16445 relocation
= got
->output_section
->vma
+ got
->output_offset
+ off
;
16447 if (!(r_type
== R_PPC64_GOT_PCREL34
16448 || r_type
== R_PPC64_GOT_TLSGD_PCREL34
16449 || r_type
== R_PPC64_GOT_TLSLD_PCREL34
16450 || r_type
== R_PPC64_GOT_TPREL_PCREL34
16451 || r_type
== R_PPC64_GOT_DTPREL_PCREL34
))
16452 addend
= -(TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
);
16456 case R_PPC64_PLT16_HA
:
16457 case R_PPC64_PLT16_HI
:
16458 case R_PPC64_PLT16_LO
:
16459 case R_PPC64_PLT16_LO_DS
:
16460 case R_PPC64_PLT_PCREL34
:
16461 case R_PPC64_PLT_PCREL34_NOTOC
:
16462 case R_PPC64_PLT32
:
16463 case R_PPC64_PLT64
:
16464 case R_PPC64_PLTSEQ
:
16465 case R_PPC64_PLTSEQ_NOTOC
:
16466 case R_PPC64_PLTCALL
:
16467 case R_PPC64_PLTCALL_NOTOC
:
16468 /* Relocation is to the entry for this symbol in the
16469 procedure linkage table. */
16470 unresolved_reloc
= TRUE
;
16472 struct plt_entry
**plt_list
= NULL
;
16474 plt_list
= &h
->elf
.plt
.plist
;
16475 else if (local_got_ents
!= NULL
)
16477 struct plt_entry
**local_plt
= (struct plt_entry
**)
16478 (local_got_ents
+ symtab_hdr
->sh_info
);
16479 plt_list
= local_plt
+ r_symndx
;
16483 struct plt_entry
*ent
;
16485 for (ent
= *plt_list
; ent
!= NULL
; ent
= ent
->next
)
16486 if (ent
->plt
.offset
!= (bfd_vma
) -1
16487 && ent
->addend
== orig_rel
.r_addend
)
16492 plt
= htab
->elf
.splt
;
16493 if (!htab
->elf
.dynamic_sections_created
16495 || h
->elf
.dynindx
== -1)
16498 ? h
->elf
.type
== STT_GNU_IFUNC
16499 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
16500 plt
= htab
->elf
.iplt
;
16502 plt
= htab
->pltlocal
;
16504 relocation
= (plt
->output_section
->vma
16505 + plt
->output_offset
16506 + ent
->plt
.offset
);
16507 if (r_type
== R_PPC64_PLT16_HA
16508 || r_type
== R_PPC64_PLT16_HI
16509 || r_type
== R_PPC64_PLT16_LO
16510 || r_type
== R_PPC64_PLT16_LO_DS
)
16512 got
= (elf_gp (output_bfd
)
16513 + htab
->sec_info
[input_section
->id
].toc_off
);
16517 unresolved_reloc
= FALSE
;
16525 /* Relocation value is TOC base. */
16526 relocation
= TOCstart
;
16527 if (r_symndx
== STN_UNDEF
)
16528 relocation
+= htab
->sec_info
[input_section
->id
].toc_off
;
16529 else if (unresolved_reloc
)
16531 else if (sec
!= NULL
&& sec
->id
< htab
->sec_info_arr_size
)
16532 relocation
+= htab
->sec_info
[sec
->id
].toc_off
;
16534 unresolved_reloc
= TRUE
;
16537 /* TOC16 relocs. We want the offset relative to the TOC base,
16538 which is the address of the start of the TOC plus 0x8000.
16539 The TOC consists of sections .got, .toc, .tocbss, and .plt,
16541 case R_PPC64_TOC16
:
16542 case R_PPC64_TOC16_LO
:
16543 case R_PPC64_TOC16_HI
:
16544 case R_PPC64_TOC16_DS
:
16545 case R_PPC64_TOC16_LO_DS
:
16546 case R_PPC64_TOC16_HA
:
16547 addend
-= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
16552 /* Relocate against the beginning of the section. */
16553 case R_PPC64_SECTOFF
:
16554 case R_PPC64_SECTOFF_LO
:
16555 case R_PPC64_SECTOFF_HI
:
16556 case R_PPC64_SECTOFF_DS
:
16557 case R_PPC64_SECTOFF_LO_DS
:
16558 case R_PPC64_SECTOFF_HA
:
16560 addend
-= sec
->output_section
->vma
;
16563 case R_PPC64_REL16
:
16564 case R_PPC64_REL16_LO
:
16565 case R_PPC64_REL16_HI
:
16566 case R_PPC64_REL16_HA
:
16567 case R_PPC64_REL16_HIGH
:
16568 case R_PPC64_REL16_HIGHA
:
16569 case R_PPC64_REL16_HIGHER
:
16570 case R_PPC64_REL16_HIGHERA
:
16571 case R_PPC64_REL16_HIGHEST
:
16572 case R_PPC64_REL16_HIGHESTA
:
16573 case R_PPC64_REL16_HIGHER34
:
16574 case R_PPC64_REL16_HIGHERA34
:
16575 case R_PPC64_REL16_HIGHEST34
:
16576 case R_PPC64_REL16_HIGHESTA34
:
16577 case R_PPC64_REL16DX_HA
:
16578 case R_PPC64_REL14
:
16579 case R_PPC64_REL14_BRNTAKEN
:
16580 case R_PPC64_REL14_BRTAKEN
:
16581 case R_PPC64_REL24
:
16582 case R_PPC64_REL24_NOTOC
:
16583 case R_PPC64_PCREL34
:
16584 case R_PPC64_PCREL28
:
16587 case R_PPC64_TPREL16
:
16588 case R_PPC64_TPREL16_LO
:
16589 case R_PPC64_TPREL16_HI
:
16590 case R_PPC64_TPREL16_HA
:
16591 case R_PPC64_TPREL16_DS
:
16592 case R_PPC64_TPREL16_LO_DS
:
16593 case R_PPC64_TPREL16_HIGH
:
16594 case R_PPC64_TPREL16_HIGHA
:
16595 case R_PPC64_TPREL16_HIGHER
:
16596 case R_PPC64_TPREL16_HIGHERA
:
16597 case R_PPC64_TPREL16_HIGHEST
:
16598 case R_PPC64_TPREL16_HIGHESTA
:
16599 case R_PPC64_TPREL34
:
16601 && h
->elf
.root
.type
== bfd_link_hash_undefweak
16602 && h
->elf
.dynindx
== -1)
16604 /* Make this relocation against an undefined weak symbol
16605 resolve to zero. This is really just a tweak, since
16606 code using weak externs ought to check that they are
16607 defined before using them. */
16608 bfd_byte
*p
= contents
+ rel
->r_offset
- d_offset
;
16610 insn
= bfd_get_32 (input_bfd
, p
);
16611 insn
= _bfd_elf_ppc_at_tprel_transform (insn
, 13);
16613 bfd_put_32 (input_bfd
, insn
, p
);
16616 if (htab
->elf
.tls_sec
!= NULL
)
16617 addend
-= htab
->elf
.tls_sec
->vma
+ TP_OFFSET
;
16618 /* The TPREL16 relocs shouldn't really be used in shared
16619 libs or with non-local symbols as that will result in
16620 DT_TEXTREL being set, but support them anyway. */
16623 case R_PPC64_DTPREL16
:
16624 case R_PPC64_DTPREL16_LO
:
16625 case R_PPC64_DTPREL16_HI
:
16626 case R_PPC64_DTPREL16_HA
:
16627 case R_PPC64_DTPREL16_DS
:
16628 case R_PPC64_DTPREL16_LO_DS
:
16629 case R_PPC64_DTPREL16_HIGH
:
16630 case R_PPC64_DTPREL16_HIGHA
:
16631 case R_PPC64_DTPREL16_HIGHER
:
16632 case R_PPC64_DTPREL16_HIGHERA
:
16633 case R_PPC64_DTPREL16_HIGHEST
:
16634 case R_PPC64_DTPREL16_HIGHESTA
:
16635 case R_PPC64_DTPREL34
:
16636 if (htab
->elf
.tls_sec
!= NULL
)
16637 addend
-= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
16640 case R_PPC64_ADDR64_LOCAL
:
16641 addend
+= PPC64_LOCAL_ENTRY_OFFSET (h
!= NULL
16646 case R_PPC64_DTPMOD64
:
16651 case R_PPC64_TPREL64
:
16652 if (htab
->elf
.tls_sec
!= NULL
)
16653 addend
-= htab
->elf
.tls_sec
->vma
+ TP_OFFSET
;
16656 case R_PPC64_DTPREL64
:
16657 if (htab
->elf
.tls_sec
!= NULL
)
16658 addend
-= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
16659 /* Fall through. */
16661 /* Relocations that may need to be propagated if this is a
16663 case R_PPC64_REL30
:
16664 case R_PPC64_REL32
:
16665 case R_PPC64_REL64
:
16666 case R_PPC64_ADDR14
:
16667 case R_PPC64_ADDR14_BRNTAKEN
:
16668 case R_PPC64_ADDR14_BRTAKEN
:
16669 case R_PPC64_ADDR16
:
16670 case R_PPC64_ADDR16_DS
:
16671 case R_PPC64_ADDR16_HA
:
16672 case R_PPC64_ADDR16_HI
:
16673 case R_PPC64_ADDR16_HIGH
:
16674 case R_PPC64_ADDR16_HIGHA
:
16675 case R_PPC64_ADDR16_HIGHER
:
16676 case R_PPC64_ADDR16_HIGHERA
:
16677 case R_PPC64_ADDR16_HIGHEST
:
16678 case R_PPC64_ADDR16_HIGHESTA
:
16679 case R_PPC64_ADDR16_LO
:
16680 case R_PPC64_ADDR16_LO_DS
:
16681 case R_PPC64_ADDR16_HIGHER34
:
16682 case R_PPC64_ADDR16_HIGHERA34
:
16683 case R_PPC64_ADDR16_HIGHEST34
:
16684 case R_PPC64_ADDR16_HIGHESTA34
:
16685 case R_PPC64_ADDR24
:
16686 case R_PPC64_ADDR32
:
16687 case R_PPC64_ADDR64
:
16688 case R_PPC64_UADDR16
:
16689 case R_PPC64_UADDR32
:
16690 case R_PPC64_UADDR64
:
16692 case R_PPC64_D34_LO
:
16693 case R_PPC64_D34_HI30
:
16694 case R_PPC64_D34_HA30
:
16697 if ((input_section
->flags
& SEC_ALLOC
) == 0)
16700 if (NO_OPD_RELOCS
&& is_opd
)
16703 if (bfd_link_pic (info
)
16705 || h
->elf
.dyn_relocs
!= NULL
)
16706 && ((h
!= NULL
&& pc_dynrelocs (h
))
16707 || must_be_dyn_reloc (info
, r_type
)))
16709 ? h
->elf
.dyn_relocs
!= NULL
16710 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
))
16712 bfd_boolean skip
, relocate
;
16717 /* When generating a dynamic object, these relocations
16718 are copied into the output file to be resolved at run
16724 out_off
= _bfd_elf_section_offset (output_bfd
, info
,
16725 input_section
, rel
->r_offset
);
16726 if (out_off
== (bfd_vma
) -1)
16728 else if (out_off
== (bfd_vma
) -2)
16729 skip
= TRUE
, relocate
= TRUE
;
16730 out_off
+= (input_section
->output_section
->vma
16731 + input_section
->output_offset
);
16732 outrel
.r_offset
= out_off
;
16733 outrel
.r_addend
= rel
->r_addend
;
16735 /* Optimize unaligned reloc use. */
16736 if ((r_type
== R_PPC64_ADDR64
&& (out_off
& 7) != 0)
16737 || (r_type
== R_PPC64_UADDR64
&& (out_off
& 7) == 0))
16738 r_type
^= R_PPC64_ADDR64
^ R_PPC64_UADDR64
;
16739 else if ((r_type
== R_PPC64_ADDR32
&& (out_off
& 3) != 0)
16740 || (r_type
== R_PPC64_UADDR32
&& (out_off
& 3) == 0))
16741 r_type
^= R_PPC64_ADDR32
^ R_PPC64_UADDR32
;
16742 else if ((r_type
== R_PPC64_ADDR16
&& (out_off
& 1) != 0)
16743 || (r_type
== R_PPC64_UADDR16
&& (out_off
& 1) == 0))
16744 r_type
^= R_PPC64_ADDR16
^ R_PPC64_UADDR16
;
16747 memset (&outrel
, 0, sizeof outrel
);
16749 && !SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
)
16751 && r_type
!= R_PPC64_TOC
)
16753 indx
= h
->elf
.dynindx
;
16754 BFD_ASSERT (indx
!= -1);
16755 outrel
.r_info
= ELF64_R_INFO (indx
, r_type
);
16759 /* This symbol is local, or marked to become local,
16760 or this is an opd section reloc which must point
16761 at a local function. */
16762 outrel
.r_addend
+= relocation
;
16763 if (r_type
== R_PPC64_ADDR64
|| r_type
== R_PPC64_TOC
)
16765 if (is_opd
&& h
!= NULL
)
16767 /* Lie about opd entries. This case occurs
16768 when building shared libraries and we
16769 reference a function in another shared
16770 lib. The same thing happens for a weak
16771 definition in an application that's
16772 overridden by a strong definition in a
16773 shared lib. (I believe this is a generic
16774 bug in binutils handling of weak syms.)
16775 In these cases we won't use the opd
16776 entry in this lib. */
16777 unresolved_reloc
= FALSE
;
16780 && r_type
== R_PPC64_ADDR64
16782 ? h
->elf
.type
== STT_GNU_IFUNC
16783 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
))
16784 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
16787 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
16789 /* We need to relocate .opd contents for ld.so.
16790 Prelink also wants simple and consistent rules
16791 for relocs. This make all RELATIVE relocs have
16792 *r_offset equal to r_addend. */
16799 ? h
->elf
.type
== STT_GNU_IFUNC
16800 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
16802 info
->callbacks
->einfo
16803 /* xgettext:c-format */
16804 (_("%H: %s for indirect "
16805 "function `%pT' unsupported\n"),
16806 input_bfd
, input_section
, rel
->r_offset
,
16807 ppc64_elf_howto_table
[r_type
]->name
,
16811 else if (r_symndx
== STN_UNDEF
|| bfd_is_abs_section (sec
))
16813 else if (sec
== NULL
|| sec
->owner
== NULL
)
16815 bfd_set_error (bfd_error_bad_value
);
16820 asection
*osec
= sec
->output_section
;
16822 if ((osec
->flags
& SEC_THREAD_LOCAL
) != 0)
16824 /* TLS symbol values are relative to the
16825 TLS segment. Dynamic relocations for
16826 local TLS symbols therefore can't be
16827 reduced to a relocation against their
16828 section symbol because it holds the
16829 address of the section, not a value
16830 relative to the TLS segment. We could
16831 change the .tdata dynamic section symbol
16832 to be zero value but STN_UNDEF works
16833 and is used elsewhere, eg. for TPREL64
16834 GOT relocs against local TLS symbols. */
16835 osec
= htab
->elf
.tls_sec
;
16840 indx
= elf_section_data (osec
)->dynindx
;
16843 if ((osec
->flags
& SEC_READONLY
) == 0
16844 && htab
->elf
.data_index_section
!= NULL
)
16845 osec
= htab
->elf
.data_index_section
;
16847 osec
= htab
->elf
.text_index_section
;
16848 indx
= elf_section_data (osec
)->dynindx
;
16850 BFD_ASSERT (indx
!= 0);
16853 /* We are turning this relocation into one
16854 against a section symbol, so subtract out
16855 the output section's address but not the
16856 offset of the input section in the output
16858 outrel
.r_addend
-= osec
->vma
;
16861 outrel
.r_info
= ELF64_R_INFO (indx
, r_type
);
16865 sreloc
= elf_section_data (input_section
)->sreloc
;
16867 ? h
->elf
.type
== STT_GNU_IFUNC
16868 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
16870 sreloc
= htab
->elf
.irelplt
;
16871 if (indx
== 0 || is_static_defined (&h
->elf
))
16872 htab
->elf
.ifunc_resolvers
= TRUE
;
16874 if (sreloc
== NULL
)
16877 if (sreloc
->reloc_count
* sizeof (Elf64_External_Rela
)
16880 loc
= sreloc
->contents
;
16881 loc
+= sreloc
->reloc_count
++ * sizeof (Elf64_External_Rela
);
16882 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
16884 if (!warned_dynamic
16885 && !ppc64_glibc_dynamic_reloc (ELF64_R_TYPE (outrel
.r_info
)))
16887 info
->callbacks
->einfo
16888 /* xgettext:c-format */
16889 (_("%X%P: %pB: %s against %pT "
16890 "is not supported by glibc as a dynamic relocation\n"),
16892 ppc64_elf_howto_table
[ELF64_R_TYPE (outrel
.r_info
)]->name
,
16894 warned_dynamic
= TRUE
;
16897 /* If this reloc is against an external symbol, it will
16898 be computed at runtime, so there's no need to do
16899 anything now. However, for the sake of prelink ensure
16900 that the section contents are a known value. */
16903 unresolved_reloc
= FALSE
;
16904 /* The value chosen here is quite arbitrary as ld.so
16905 ignores section contents except for the special
16906 case of .opd where the contents might be accessed
16907 before relocation. Choose zero, as that won't
16908 cause reloc overflow. */
16911 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
16912 to improve backward compatibility with older
16914 if (r_type
== R_PPC64_ADDR64
)
16915 addend
= outrel
.r_addend
;
16916 /* Adjust pc_relative relocs to have zero in *r_offset. */
16917 else if (ppc64_elf_howto_table
[r_type
]->pc_relative
)
16918 addend
= outrel
.r_offset
;
16924 case R_PPC64_GLOB_DAT
:
16925 case R_PPC64_JMP_SLOT
:
16926 case R_PPC64_JMP_IREL
:
16927 case R_PPC64_RELATIVE
:
16928 /* We shouldn't ever see these dynamic relocs in relocatable
16930 /* Fall through. */
16932 case R_PPC64_PLTGOT16
:
16933 case R_PPC64_PLTGOT16_DS
:
16934 case R_PPC64_PLTGOT16_HA
:
16935 case R_PPC64_PLTGOT16_HI
:
16936 case R_PPC64_PLTGOT16_LO
:
16937 case R_PPC64_PLTGOT16_LO_DS
:
16938 case R_PPC64_PLTREL32
:
16939 case R_PPC64_PLTREL64
:
16940 /* These ones haven't been implemented yet. */
16942 info
->callbacks
->einfo
16943 /* xgettext:c-format */
16944 (_("%P: %pB: %s is not supported for `%pT'\n"),
16946 ppc64_elf_howto_table
[r_type
]->name
, sym_name
);
16948 bfd_set_error (bfd_error_invalid_operation
);
16953 /* Multi-instruction sequences that access the TOC can be
16954 optimized, eg. addis ra,r2,0; addi rb,ra,x;
16955 to nop; addi rb,r2,x; */
16961 case R_PPC64_GOT_TLSLD16_HI
:
16962 case R_PPC64_GOT_TLSGD16_HI
:
16963 case R_PPC64_GOT_TPREL16_HI
:
16964 case R_PPC64_GOT_DTPREL16_HI
:
16965 case R_PPC64_GOT16_HI
:
16966 case R_PPC64_TOC16_HI
:
16967 /* These relocs would only be useful if building up an
16968 offset to later add to r2, perhaps in an indexed
16969 addressing mode instruction. Don't try to optimize.
16970 Unfortunately, the possibility of someone building up an
16971 offset like this or even with the HA relocs, means that
16972 we need to check the high insn when optimizing the low
16976 case R_PPC64_PLTCALL_NOTOC
:
16977 if (!unresolved_reloc
)
16978 htab
->notoc_plt
= 1;
16979 /* Fall through. */
16980 case R_PPC64_PLTCALL
:
16981 if (unresolved_reloc
)
16983 /* No plt entry. Make this into a direct call. */
16984 bfd_byte
*p
= contents
+ rel
->r_offset
;
16985 insn
= bfd_get_32 (input_bfd
, p
);
16987 bfd_put_32 (input_bfd
, B_DOT
| insn
, p
);
16988 if (r_type
== R_PPC64_PLTCALL
)
16989 bfd_put_32 (input_bfd
, NOP
, p
+ 4);
16990 unresolved_reloc
= save_unresolved_reloc
;
16991 r_type
= R_PPC64_REL24
;
16995 case R_PPC64_PLTSEQ_NOTOC
:
16996 case R_PPC64_PLTSEQ
:
16997 if (unresolved_reloc
)
16999 unresolved_reloc
= FALSE
;
17004 case R_PPC64_PLT_PCREL34_NOTOC
:
17005 if (!unresolved_reloc
)
17006 htab
->notoc_plt
= 1;
17007 /* Fall through. */
17008 case R_PPC64_PLT_PCREL34
:
17009 if (unresolved_reloc
)
17011 bfd_byte
*p
= contents
+ rel
->r_offset
;
17012 bfd_put_32 (input_bfd
, PNOP
>> 32, p
);
17013 bfd_put_32 (input_bfd
, PNOP
, p
+ 4);
17014 unresolved_reloc
= FALSE
;
17019 case R_PPC64_PLT16_HA
:
17020 if (unresolved_reloc
)
17022 unresolved_reloc
= FALSE
;
17025 /* Fall through. */
17026 case R_PPC64_GOT_TLSLD16_HA
:
17027 case R_PPC64_GOT_TLSGD16_HA
:
17028 case R_PPC64_GOT_TPREL16_HA
:
17029 case R_PPC64_GOT_DTPREL16_HA
:
17030 case R_PPC64_GOT16_HA
:
17031 case R_PPC64_TOC16_HA
:
17032 if (htab
->do_toc_opt
&& relocation
+ addend
+ 0x8000 < 0x10000
17033 && !ppc64_elf_tdata (input_bfd
)->unexpected_toc_insn
)
17037 p
= contents
+ (rel
->r_offset
& ~3);
17038 bfd_put_32 (input_bfd
, NOP
, p
);
17043 case R_PPC64_PLT16_LO
:
17044 case R_PPC64_PLT16_LO_DS
:
17045 if (unresolved_reloc
)
17047 unresolved_reloc
= FALSE
;
17050 /* Fall through. */
17051 case R_PPC64_GOT_TLSLD16_LO
:
17052 case R_PPC64_GOT_TLSGD16_LO
:
17053 case R_PPC64_GOT_TPREL16_LO_DS
:
17054 case R_PPC64_GOT_DTPREL16_LO_DS
:
17055 case R_PPC64_GOT16_LO
:
17056 case R_PPC64_GOT16_LO_DS
:
17057 case R_PPC64_TOC16_LO
:
17058 case R_PPC64_TOC16_LO_DS
:
17059 if (htab
->do_toc_opt
&& relocation
+ addend
+ 0x8000 < 0x10000
17060 && !ppc64_elf_tdata (input_bfd
)->unexpected_toc_insn
)
17062 bfd_byte
*p
= contents
+ (rel
->r_offset
& ~3);
17063 insn
= bfd_get_32 (input_bfd
, p
);
17064 if ((insn
& (0x3fu
<< 26)) == 12u << 26 /* addic */)
17066 /* Transform addic to addi when we change reg. */
17067 insn
&= ~((0x3fu
<< 26) | (0x1f << 16));
17068 insn
|= (14u << 26) | (2 << 16);
17072 insn
&= ~(0x1f << 16);
17075 bfd_put_32 (input_bfd
, insn
, p
);
17079 case R_PPC64_TPREL16_HA
:
17080 if (htab
->do_tls_opt
&& relocation
+ addend
+ 0x8000 < 0x10000)
17082 bfd_byte
*p
= contents
+ (rel
->r_offset
& ~3);
17083 bfd_put_32 (input_bfd
, NOP
, p
);
17088 case R_PPC64_TPREL16_LO
:
17089 case R_PPC64_TPREL16_LO_DS
:
17090 if (htab
->do_tls_opt
&& relocation
+ addend
+ 0x8000 < 0x10000)
17092 bfd_byte
*p
= contents
+ (rel
->r_offset
& ~3);
17093 insn
= bfd_get_32 (input_bfd
, p
);
17094 insn
&= ~(0x1f << 16);
17096 bfd_put_32 (input_bfd
, insn
, p
);
17101 /* Do any further special processing. */
17107 case R_PPC64_REL16_HA
:
17108 case R_PPC64_REL16_HIGHA
:
17109 case R_PPC64_REL16_HIGHERA
:
17110 case R_PPC64_REL16_HIGHESTA
:
17111 case R_PPC64_REL16DX_HA
:
17112 case R_PPC64_ADDR16_HA
:
17113 case R_PPC64_ADDR16_HIGHA
:
17114 case R_PPC64_ADDR16_HIGHERA
:
17115 case R_PPC64_ADDR16_HIGHESTA
:
17116 case R_PPC64_TOC16_HA
:
17117 case R_PPC64_SECTOFF_HA
:
17118 case R_PPC64_TPREL16_HA
:
17119 case R_PPC64_TPREL16_HIGHA
:
17120 case R_PPC64_TPREL16_HIGHERA
:
17121 case R_PPC64_TPREL16_HIGHESTA
:
17122 case R_PPC64_DTPREL16_HA
:
17123 case R_PPC64_DTPREL16_HIGHA
:
17124 case R_PPC64_DTPREL16_HIGHERA
:
17125 case R_PPC64_DTPREL16_HIGHESTA
:
17126 /* It's just possible that this symbol is a weak symbol
17127 that's not actually defined anywhere. In that case,
17128 'sec' would be NULL, and we should leave the symbol
17129 alone (it will be set to zero elsewhere in the link). */
17132 /* Fall through. */
17134 case R_PPC64_GOT16_HA
:
17135 case R_PPC64_PLTGOT16_HA
:
17136 case R_PPC64_PLT16_HA
:
17137 case R_PPC64_GOT_TLSGD16_HA
:
17138 case R_PPC64_GOT_TLSLD16_HA
:
17139 case R_PPC64_GOT_TPREL16_HA
:
17140 case R_PPC64_GOT_DTPREL16_HA
:
17141 /* Add 0x10000 if sign bit in 0:15 is set.
17142 Bits 0:15 are not used. */
17146 case R_PPC64_D34_HA30
:
17147 case R_PPC64_ADDR16_HIGHERA34
:
17148 case R_PPC64_ADDR16_HIGHESTA34
:
17149 case R_PPC64_REL16_HIGHERA34
:
17150 case R_PPC64_REL16_HIGHESTA34
:
17152 addend
+= 1ULL << 33;
17155 case R_PPC64_ADDR16_DS
:
17156 case R_PPC64_ADDR16_LO_DS
:
17157 case R_PPC64_GOT16_DS
:
17158 case R_PPC64_GOT16_LO_DS
:
17159 case R_PPC64_PLT16_LO_DS
:
17160 case R_PPC64_SECTOFF_DS
:
17161 case R_PPC64_SECTOFF_LO_DS
:
17162 case R_PPC64_TOC16_DS
:
17163 case R_PPC64_TOC16_LO_DS
:
17164 case R_PPC64_PLTGOT16_DS
:
17165 case R_PPC64_PLTGOT16_LO_DS
:
17166 case R_PPC64_GOT_TPREL16_DS
:
17167 case R_PPC64_GOT_TPREL16_LO_DS
:
17168 case R_PPC64_GOT_DTPREL16_DS
:
17169 case R_PPC64_GOT_DTPREL16_LO_DS
:
17170 case R_PPC64_TPREL16_DS
:
17171 case R_PPC64_TPREL16_LO_DS
:
17172 case R_PPC64_DTPREL16_DS
:
17173 case R_PPC64_DTPREL16_LO_DS
:
17174 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
17176 /* If this reloc is against an lq, lxv, or stxv insn, then
17177 the value must be a multiple of 16. This is somewhat of
17178 a hack, but the "correct" way to do this by defining _DQ
17179 forms of all the _DS relocs bloats all reloc switches in
17180 this file. It doesn't make much sense to use these
17181 relocs in data, so testing the insn should be safe. */
17182 if ((insn
& (0x3fu
<< 26)) == (56u << 26)
17183 || ((insn
& (0x3fu
<< 26)) == (61u << 26) && (insn
& 3) == 1))
17185 relocation
+= addend
;
17186 addend
= insn
& (mask
^ 3);
17187 if ((relocation
& mask
) != 0)
17189 relocation
^= relocation
& mask
;
17190 info
->callbacks
->einfo
17191 /* xgettext:c-format */
17192 (_("%H: error: %s not a multiple of %u\n"),
17193 input_bfd
, input_section
, rel
->r_offset
,
17194 ppc64_elf_howto_table
[r_type
]->name
,
17196 bfd_set_error (bfd_error_bad_value
);
17203 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
17204 because such sections are not SEC_ALLOC and thus ld.so will
17205 not process them. */
17206 howto
= ppc64_elf_howto_table
[(int) r_type
];
17207 if (unresolved_reloc
17208 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
17209 && h
->elf
.def_dynamic
)
17210 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
17211 rel
->r_offset
) != (bfd_vma
) -1)
17213 info
->callbacks
->einfo
17214 /* xgettext:c-format */
17215 (_("%H: unresolvable %s against `%pT'\n"),
17216 input_bfd
, input_section
, rel
->r_offset
,
17218 h
->elf
.root
.root
.string
);
17222 /* 16-bit fields in insns mostly have signed values, but a
17223 few insns have 16-bit unsigned values. Really, we should
17224 have different reloc types. */
17225 if (howto
->complain_on_overflow
!= complain_overflow_dont
17226 && howto
->dst_mask
== 0xffff
17227 && (input_section
->flags
& SEC_CODE
) != 0)
17229 enum complain_overflow complain
= complain_overflow_signed
;
17231 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
17232 if ((insn
& (0x3fu
<< 26)) == 10u << 26 /* cmpli */)
17233 complain
= complain_overflow_bitfield
;
17234 else if (howto
->rightshift
== 0
17235 ? ((insn
& (0x3fu
<< 26)) == 28u << 26 /* andi */
17236 || (insn
& (0x3fu
<< 26)) == 24u << 26 /* ori */
17237 || (insn
& (0x3fu
<< 26)) == 26u << 26 /* xori */)
17238 : ((insn
& (0x3fu
<< 26)) == 29u << 26 /* andis */
17239 || (insn
& (0x3fu
<< 26)) == 25u << 26 /* oris */
17240 || (insn
& (0x3fu
<< 26)) == 27u << 26 /* xoris */))
17241 complain
= complain_overflow_unsigned
;
17242 if (howto
->complain_on_overflow
!= complain
)
17244 alt_howto
= *howto
;
17245 alt_howto
.complain_on_overflow
= complain
;
17246 howto
= &alt_howto
;
17252 /* Split field relocs aren't handled by _bfd_final_link_relocate. */
17254 case R_PPC64_D34_LO
:
17255 case R_PPC64_D34_HI30
:
17256 case R_PPC64_D34_HA30
:
17257 case R_PPC64_PCREL34
:
17258 case R_PPC64_GOT_PCREL34
:
17259 case R_PPC64_TPREL34
:
17260 case R_PPC64_DTPREL34
:
17261 case R_PPC64_GOT_TLSGD_PCREL34
:
17262 case R_PPC64_GOT_TLSLD_PCREL34
:
17263 case R_PPC64_GOT_TPREL_PCREL34
:
17264 case R_PPC64_GOT_DTPREL_PCREL34
:
17265 case R_PPC64_PLT_PCREL34
:
17266 case R_PPC64_PLT_PCREL34_NOTOC
:
17268 case R_PPC64_PCREL28
:
17269 if (rel
->r_offset
+ 8 > input_section
->size
)
17270 r
= bfd_reloc_outofrange
;
17273 relocation
+= addend
;
17274 if (howto
->pc_relative
)
17275 relocation
-= (rel
->r_offset
17276 + input_section
->output_offset
17277 + input_section
->output_section
->vma
);
17278 relocation
>>= howto
->rightshift
;
17280 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
17282 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
17284 pinsn
&= ~howto
->dst_mask
;
17285 pinsn
|= (((relocation
<< 16) | (relocation
& 0xffff))
17286 & howto
->dst_mask
);
17287 bfd_put_32 (input_bfd
, pinsn
>> 32, contents
+ rel
->r_offset
);
17288 bfd_put_32 (input_bfd
, pinsn
, contents
+ rel
->r_offset
+ 4);
17290 if (howto
->complain_on_overflow
== complain_overflow_signed
17291 && (relocation
+ (1ULL << (howto
->bitsize
- 1))
17292 >= 1ULL << howto
->bitsize
))
17293 r
= bfd_reloc_overflow
;
17297 case R_PPC64_REL16DX_HA
:
17298 if (rel
->r_offset
+ 4 > input_section
->size
)
17299 r
= bfd_reloc_outofrange
;
17302 relocation
+= addend
;
17303 relocation
-= (rel
->r_offset
17304 + input_section
->output_offset
17305 + input_section
->output_section
->vma
);
17306 relocation
= (bfd_signed_vma
) relocation
>> 16;
17307 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
17309 insn
|= (relocation
& 0xffc1) | ((relocation
& 0x3e) << 15);
17310 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
17312 if (relocation
+ 0x8000 > 0xffff)
17313 r
= bfd_reloc_overflow
;
17318 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
17319 contents
, rel
->r_offset
,
17320 relocation
, addend
);
17323 if (r
!= bfd_reloc_ok
)
17325 char *more_info
= NULL
;
17326 const char *reloc_name
= howto
->name
;
17328 if (reloc_dest
!= DEST_NORMAL
)
17330 more_info
= bfd_malloc (strlen (reloc_name
) + 8);
17331 if (more_info
!= NULL
)
17333 strcpy (more_info
, reloc_name
);
17334 strcat (more_info
, (reloc_dest
== DEST_OPD
17335 ? " (OPD)" : " (stub)"));
17336 reloc_name
= more_info
;
17340 if (r
== bfd_reloc_overflow
)
17342 /* On code like "if (foo) foo();" don't report overflow
17343 on a branch to zero when foo is undefined. */
17345 && (reloc_dest
== DEST_STUB
17347 && (h
->elf
.root
.type
== bfd_link_hash_undefweak
17348 || h
->elf
.root
.type
== bfd_link_hash_undefined
)
17349 && is_branch_reloc (r_type
))))
17350 info
->callbacks
->reloc_overflow
17351 (info
, (struct bfd_link_hash_entry
*) h
, sym_name
,
17352 reloc_name
, orig_rel
.r_addend
, input_bfd
, input_section
,
17357 info
->callbacks
->einfo
17358 /* xgettext:c-format */
17359 (_("%H: %s against `%pT': error %d\n"),
17360 input_bfd
, input_section
, rel
->r_offset
,
17361 reloc_name
, sym_name
, (int) r
);
17373 Elf_Internal_Shdr
*rel_hdr
;
17374 size_t deleted
= rel
- wrel
;
17376 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
17377 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
17378 if (rel_hdr
->sh_size
== 0)
17380 /* It is too late to remove an empty reloc section. Leave
17382 ??? What is wrong with an empty section??? */
17383 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
17386 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
17387 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
17388 input_section
->reloc_count
-= deleted
;
17391 /* If we're emitting relocations, then shortly after this function
17392 returns, reloc offsets and addends for this section will be
17393 adjusted. Worse, reloc symbol indices will be for the output
17394 file rather than the input. Save a copy of the relocs for
17395 opd_entry_value. */
17396 if (is_opd
&& (info
->emitrelocations
|| bfd_link_relocatable (info
)))
17399 amt
= input_section
->reloc_count
* sizeof (Elf_Internal_Rela
);
17400 rel
= bfd_alloc (input_bfd
, amt
);
17401 BFD_ASSERT (ppc64_elf_tdata (input_bfd
)->opd
.relocs
== NULL
);
17402 ppc64_elf_tdata (input_bfd
)->opd
.relocs
= rel
;
17405 memcpy (rel
, relocs
, amt
);
17410 /* Adjust the value of any local symbols in opd sections. */
17413 ppc64_elf_output_symbol_hook (struct bfd_link_info
*info
,
17414 const char *name ATTRIBUTE_UNUSED
,
17415 Elf_Internal_Sym
*elfsym
,
17416 asection
*input_sec
,
17417 struct elf_link_hash_entry
*h
)
17419 struct _opd_sec_data
*opd
;
17426 opd
= get_opd_info (input_sec
);
17427 if (opd
== NULL
|| opd
->adjust
== NULL
)
17430 value
= elfsym
->st_value
- input_sec
->output_offset
;
17431 if (!bfd_link_relocatable (info
))
17432 value
-= input_sec
->output_section
->vma
;
17434 adjust
= opd
->adjust
[OPD_NDX (value
)];
17438 elfsym
->st_value
+= adjust
;
17442 /* Finish up dynamic symbol handling. We set the contents of various
17443 dynamic sections here. */
17446 ppc64_elf_finish_dynamic_symbol (bfd
*output_bfd
,
17447 struct bfd_link_info
*info
,
17448 struct elf_link_hash_entry
*h
,
17449 Elf_Internal_Sym
*sym
)
17451 struct ppc_link_hash_table
*htab
;
17452 struct plt_entry
*ent
;
17454 htab
= ppc_hash_table (info
);
17458 if (!htab
->opd_abi
&& !h
->def_regular
)
17459 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
17460 if (ent
->plt
.offset
!= (bfd_vma
) -1)
17462 /* Mark the symbol as undefined, rather than as
17463 defined in glink. Leave the value if there were
17464 any relocations where pointer equality matters
17465 (this is a clue for the dynamic linker, to make
17466 function pointer comparisons work between an
17467 application and shared library), otherwise set it
17469 sym
->st_shndx
= SHN_UNDEF
;
17470 if (!h
->pointer_equality_needed
)
17472 else if (!h
->ref_regular_nonweak
)
17474 /* This breaks function pointer comparisons, but
17475 that is better than breaking tests for a NULL
17476 function pointer. */
17483 && (h
->root
.type
== bfd_link_hash_defined
17484 || h
->root
.type
== bfd_link_hash_defweak
)
17485 && (h
->root
.u
.def
.section
== htab
->elf
.sdynbss
17486 || h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
))
17488 /* This symbol needs a copy reloc. Set it up. */
17489 Elf_Internal_Rela rela
;
17493 if (h
->dynindx
== -1)
17496 rela
.r_offset
= defined_sym_val (h
);
17497 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_PPC64_COPY
);
17499 if (h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
17500 srel
= htab
->elf
.sreldynrelro
;
17502 srel
= htab
->elf
.srelbss
;
17503 loc
= srel
->contents
;
17504 loc
+= srel
->reloc_count
++ * sizeof (Elf64_External_Rela
);
17505 bfd_elf64_swap_reloca_out (output_bfd
, &rela
, loc
);
17511 /* Used to decide how to sort relocs in an optimal manner for the
17512 dynamic linker, before writing them out. */
17514 static enum elf_reloc_type_class
17515 ppc64_elf_reloc_type_class (const struct bfd_link_info
*info
,
17516 const asection
*rel_sec
,
17517 const Elf_Internal_Rela
*rela
)
17519 enum elf_ppc64_reloc_type r_type
;
17520 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
17522 if (rel_sec
== htab
->elf
.irelplt
)
17523 return reloc_class_ifunc
;
17525 r_type
= ELF64_R_TYPE (rela
->r_info
);
17528 case R_PPC64_RELATIVE
:
17529 return reloc_class_relative
;
17530 case R_PPC64_JMP_SLOT
:
17531 return reloc_class_plt
;
17533 return reloc_class_copy
;
17535 return reloc_class_normal
;
17539 /* Finish up the dynamic sections. */
17542 ppc64_elf_finish_dynamic_sections (bfd
*output_bfd
,
17543 struct bfd_link_info
*info
)
17545 struct ppc_link_hash_table
*htab
;
17549 htab
= ppc_hash_table (info
);
17553 dynobj
= htab
->elf
.dynobj
;
17554 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
17556 if (htab
->elf
.dynamic_sections_created
)
17558 Elf64_External_Dyn
*dyncon
, *dynconend
;
17560 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
17563 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
17564 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
17565 for (; dyncon
< dynconend
; dyncon
++)
17567 Elf_Internal_Dyn dyn
;
17570 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
17577 case DT_PPC64_GLINK
:
17579 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
17580 /* We stupidly defined DT_PPC64_GLINK to be the start
17581 of glink rather than the first entry point, which is
17582 what ld.so needs, and now have a bigger stub to
17583 support automatic multiple TOCs. */
17584 dyn
.d_un
.d_ptr
+= GLINK_PLTRESOLVE_SIZE (htab
) - 8 * 4;
17588 s
= bfd_get_section_by_name (output_bfd
, ".opd");
17591 dyn
.d_un
.d_ptr
= s
->vma
;
17595 if ((htab
->do_multi_toc
&& htab
->multi_toc_needed
)
17596 || htab
->notoc_plt
)
17597 dyn
.d_un
.d_val
|= PPC64_OPT_MULTI_TOC
;
17598 if (htab
->has_plt_localentry0
)
17599 dyn
.d_un
.d_val
|= PPC64_OPT_LOCALENTRY
;
17602 case DT_PPC64_OPDSZ
:
17603 s
= bfd_get_section_by_name (output_bfd
, ".opd");
17606 dyn
.d_un
.d_val
= s
->size
;
17610 s
= htab
->elf
.splt
;
17611 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
17615 s
= htab
->elf
.srelplt
;
17616 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
17620 dyn
.d_un
.d_val
= htab
->elf
.srelplt
->size
;
17624 if (htab
->elf
.ifunc_resolvers
)
17625 info
->callbacks
->einfo
17626 (_("%P: warning: text relocations and GNU indirect "
17627 "functions may result in a segfault at runtime\n"));
17631 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
17635 if (htab
->elf
.sgot
!= NULL
&& htab
->elf
.sgot
->size
!= 0
17636 && htab
->elf
.sgot
->output_section
!= bfd_abs_section_ptr
)
17638 /* Fill in the first entry in the global offset table.
17639 We use it to hold the link-time TOCbase. */
17640 bfd_put_64 (output_bfd
,
17641 elf_gp (output_bfd
) + TOC_BASE_OFF
,
17642 htab
->elf
.sgot
->contents
);
17644 /* Set .got entry size. */
17645 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
17649 if (htab
->elf
.splt
!= NULL
&& htab
->elf
.splt
->size
!= 0
17650 && htab
->elf
.splt
->output_section
!= bfd_abs_section_ptr
)
17652 /* Set .plt entry size. */
17653 elf_section_data (htab
->elf
.splt
->output_section
)->this_hdr
.sh_entsize
17654 = PLT_ENTRY_SIZE (htab
);
17657 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
17658 brlt ourselves if emitrelocations. */
17659 if (htab
->brlt
!= NULL
17660 && htab
->brlt
->reloc_count
!= 0
17661 && !_bfd_elf_link_output_relocs (output_bfd
,
17663 elf_section_data (htab
->brlt
)->rela
.hdr
,
17664 elf_section_data (htab
->brlt
)->relocs
,
17668 if (htab
->glink
!= NULL
17669 && htab
->glink
->reloc_count
!= 0
17670 && !_bfd_elf_link_output_relocs (output_bfd
,
17672 elf_section_data (htab
->glink
)->rela
.hdr
,
17673 elf_section_data (htab
->glink
)->relocs
,
17678 if (htab
->glink_eh_frame
!= NULL
17679 && htab
->glink_eh_frame
->size
!= 0
17680 && htab
->glink_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
17681 && !_bfd_elf_write_section_eh_frame (output_bfd
, info
,
17682 htab
->glink_eh_frame
,
17683 htab
->glink_eh_frame
->contents
))
17686 /* We need to handle writing out multiple GOT sections ourselves,
17687 since we didn't add them to DYNOBJ. We know dynobj is the first
17689 while ((dynobj
= dynobj
->link
.next
) != NULL
)
17693 if (!is_ppc64_elf (dynobj
))
17696 s
= ppc64_elf_tdata (dynobj
)->got
;
17699 && s
->output_section
!= bfd_abs_section_ptr
17700 && !bfd_set_section_contents (output_bfd
, s
->output_section
,
17701 s
->contents
, s
->output_offset
,
17704 s
= ppc64_elf_tdata (dynobj
)->relgot
;
17707 && s
->output_section
!= bfd_abs_section_ptr
17708 && !bfd_set_section_contents (output_bfd
, s
->output_section
,
17709 s
->contents
, s
->output_offset
,
17717 #include "elf64-target.h"
17719 /* FreeBSD support */
17721 #undef TARGET_LITTLE_SYM
17722 #define TARGET_LITTLE_SYM powerpc_elf64_fbsd_le_vec
17723 #undef TARGET_LITTLE_NAME
17724 #define TARGET_LITTLE_NAME "elf64-powerpcle-freebsd"
17726 #undef TARGET_BIG_SYM
17727 #define TARGET_BIG_SYM powerpc_elf64_fbsd_vec
17728 #undef TARGET_BIG_NAME
17729 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
17732 #define ELF_OSABI ELFOSABI_FREEBSD
17735 #define elf64_bed elf64_powerpc_fbsd_bed
17737 #include "elf64-target.h"