1 /* PowerPC64-specific support for 64-bit ELF.
2 Copyright (C) 1999-2019 Free Software Foundation, Inc.
3 Written by Linus Nordberg, Swox AB <info@swox.com>,
4 based on elf32-ppc.c by Ian Lance Taylor.
5 Largely rewritten by Alan Modra.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License along
20 with this program; if not, write to the Free Software Foundation, Inc.,
21 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
24 /* The 64-bit PowerPC ELF ABI may be found at
25 http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
26 http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html */
34 #include "elf/ppc64.h"
35 #include "elf64-ppc.h"
38 static bfd_reloc_status_type ppc64_elf_ha_reloc
39 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
40 static bfd_reloc_status_type ppc64_elf_branch_reloc
41 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
43 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
45 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
47 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
48 static bfd_reloc_status_type ppc64_elf_toc_reloc
49 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
51 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
53 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
54 static bfd_reloc_status_type ppc64_elf_prefix_reloc
55 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
56 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
57 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
58 static bfd_vma opd_entry_value
59 (asection
*, bfd_vma
, asection
**, bfd_vma
*, bfd_boolean
);
61 #define TARGET_LITTLE_SYM powerpc_elf64_le_vec
62 #define TARGET_LITTLE_NAME "elf64-powerpcle"
63 #define TARGET_BIG_SYM powerpc_elf64_vec
64 #define TARGET_BIG_NAME "elf64-powerpc"
65 #define ELF_ARCH bfd_arch_powerpc
66 #define ELF_TARGET_ID PPC64_ELF_DATA
67 #define ELF_MACHINE_CODE EM_PPC64
68 #define ELF_MAXPAGESIZE 0x10000
69 #define ELF_COMMONPAGESIZE 0x1000
70 #define ELF_RELROPAGESIZE ELF_MAXPAGESIZE
71 #define elf_info_to_howto ppc64_elf_info_to_howto
73 #define elf_backend_want_got_sym 0
74 #define elf_backend_want_plt_sym 0
75 #define elf_backend_plt_alignment 3
76 #define elf_backend_plt_not_loaded 1
77 #define elf_backend_got_header_size 8
78 #define elf_backend_want_dynrelro 1
79 #define elf_backend_can_gc_sections 1
80 #define elf_backend_can_refcount 1
81 #define elf_backend_rela_normal 1
82 #define elf_backend_dtrel_excludes_plt 1
83 #define elf_backend_default_execstack 0
85 #define bfd_elf64_mkobject ppc64_elf_mkobject
86 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
87 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
88 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
89 #define bfd_elf64_bfd_print_private_bfd_data ppc64_elf_print_private_bfd_data
90 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
91 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
92 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
93 #define bfd_elf64_bfd_link_just_syms ppc64_elf_link_just_syms
94 #define bfd_elf64_bfd_gc_sections ppc64_elf_gc_sections
96 #define elf_backend_object_p ppc64_elf_object_p
97 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
98 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
99 #define elf_backend_write_core_note ppc64_elf_write_core_note
100 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
101 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
102 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
103 #define elf_backend_check_directives ppc64_elf_before_check_relocs
104 #define elf_backend_notice_as_needed ppc64_elf_notice_as_needed
105 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
106 #define elf_backend_check_relocs ppc64_elf_check_relocs
107 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
108 #define elf_backend_gc_keep ppc64_elf_gc_keep
109 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
110 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
111 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
112 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
113 #define elf_backend_maybe_function_sym ppc64_elf_maybe_function_sym
114 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
115 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
116 #define elf_backend_hash_symbol ppc64_elf_hash_symbol
117 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
118 #define elf_backend_action_discarded ppc64_elf_action_discarded
119 #define elf_backend_relocate_section ppc64_elf_relocate_section
120 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
121 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
122 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
123 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
124 #define elf_backend_special_sections ppc64_elf_special_sections
125 #define elf_backend_merge_symbol_attribute ppc64_elf_merge_symbol_attribute
126 #define elf_backend_merge_symbol ppc64_elf_merge_symbol
127 #define elf_backend_get_reloc_section bfd_get_section_by_name
129 /* The name of the dynamic interpreter. This is put in the .interp
131 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
133 /* The size in bytes of an entry in the procedure linkage table. */
134 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
135 #define LOCAL_PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 16 : 8)
137 /* The initial size of the plt reserved for the dynamic linker. */
138 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
140 /* Offsets to some stack save slots. */
142 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
143 /* This one is dodgy. ELFv2 does not have a linker word, so use the
144 CR save slot. Used only by optimised __tls_get_addr call stub,
145 relying on __tls_get_addr_opt not saving CR.. */
146 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
148 /* TOC base pointers offset from start of TOC. */
149 #define TOC_BASE_OFF 0x8000
150 /* TOC base alignment. */
151 #define TOC_BASE_ALIGN 256
153 /* Offset of tp and dtp pointers from start of TLS block. */
154 #define TP_OFFSET 0x7000
155 #define DTP_OFFSET 0x8000
157 /* .plt call stub instructions. The normal stub is like this, but
158 sometimes the .plt entry crosses a 64k boundary and we need to
159 insert an addi to adjust r11. */
160 #define STD_R2_0R1 0xf8410000 /* std %r2,0+40(%r1) */
161 #define ADDIS_R11_R2 0x3d620000 /* addis %r11,%r2,xxx@ha */
162 #define LD_R12_0R11 0xe98b0000 /* ld %r12,xxx+0@l(%r11) */
163 #define MTCTR_R12 0x7d8903a6 /* mtctr %r12 */
164 #define LD_R2_0R11 0xe84b0000 /* ld %r2,xxx+8@l(%r11) */
165 #define LD_R11_0R11 0xe96b0000 /* ld %r11,xxx+16@l(%r11) */
166 #define BCTR 0x4e800420 /* bctr */
168 #define ADDI_R11_R11 0x396b0000 /* addi %r11,%r11,off@l */
169 #define ADDI_R12_R11 0x398b0000 /* addi %r12,%r11,off@l */
170 #define ADDI_R12_R12 0x398c0000 /* addi %r12,%r12,off@l */
171 #define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
172 #define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
174 #define XOR_R2_R12_R12 0x7d826278 /* xor %r2,%r12,%r12 */
175 #define ADD_R11_R11_R2 0x7d6b1214 /* add %r11,%r11,%r2 */
176 #define XOR_R11_R12_R12 0x7d8b6278 /* xor %r11,%r12,%r12 */
177 #define ADD_R2_R2_R11 0x7c425a14 /* add %r2,%r2,%r11 */
178 #define CMPLDI_R2_0 0x28220000 /* cmpldi %r2,0 */
179 #define BNECTR 0x4ca20420 /* bnectr+ */
180 #define BNECTR_P4 0x4ce20420 /* bnectr+ */
182 #define LD_R12_0R2 0xe9820000 /* ld %r12,xxx+0(%r2) */
183 #define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
184 #define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
186 #define LD_R2_0R1 0xe8410000 /* ld %r2,0(%r1) */
187 #define LD_R2_0R12 0xe84c0000 /* ld %r2,0(%r12) */
188 #define ADD_R2_R2_R12 0x7c426214 /* add %r2,%r2,%r12 */
190 #define LI_R11_0 0x39600000 /* li %r11,0 */
191 #define LIS_R2 0x3c400000 /* lis %r2,xxx@ha */
192 #define LIS_R11 0x3d600000 /* lis %r11,xxx@ha */
193 #define LIS_R12 0x3d800000 /* lis %r12,xxx@ha */
194 #define ADDIS_R2_R12 0x3c4c0000 /* addis %r2,%r12,xxx@ha */
195 #define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
196 #define ADDIS_R12_R11 0x3d8b0000 /* addis %r12,%r11,xxx@ha */
197 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,xxx@ha */
198 #define ORIS_R12_R12_0 0x658c0000 /* oris %r12,%r12,xxx@hi */
199 #define ORI_R11_R11_0 0x616b0000 /* ori %r11,%r11,xxx@l */
200 #define ORI_R12_R12_0 0x618c0000 /* ori %r12,%r12,xxx@l */
201 #define LD_R12_0R12 0xe98c0000 /* ld %r12,xxx@l(%r12) */
202 #define SLDI_R11_R11_34 0x796b1746 /* sldi %r11,%r11,34 */
203 #define SLDI_R12_R12_32 0x799c07c6 /* sldi %r12,%r12,32 */
204 #define LDX_R12_R11_R12 0x7d8b602a /* ldx %r12,%r11,%r12 */
205 #define ADD_R12_R11_R12 0x7d8b6214 /* add %r12,%r11,%r12 */
206 #define PADDI_R12_PC 0x0610000039800000ULL
207 #define PLD_R12_PC 0x04100000e5800000ULL
208 #define PNOP 0x0700000000000000ULL
210 /* __glink_PLTresolve stub instructions. We enter with the index in R0. */
211 #define GLINK_PLTRESOLVE_SIZE(htab) \
212 (8u + (htab->opd_abi ? 11 * 4 : 14 * 4))
216 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
217 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
219 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
220 /* ld %2,(0b-1b)(%11) */
221 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
222 #define ADD_R11_R2_R11 0x7d625a14 /* add %11,%2,%11 */
228 #define MFLR_R0 0x7c0802a6 /* mflr %r0 */
229 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
230 #define SUB_R12_R12_R11 0x7d8b6050 /* subf %r12,%r11,%r12 */
231 #define ADDI_R0_R12 0x380c0000 /* addi %r0,%r12,0 */
232 #define SRDI_R0_R0_2 0x7800f082 /* rldicl %r0,%r0,62,2 */
235 #define NOP 0x60000000
237 /* Some other nops. */
238 #define CROR_151515 0x4def7b82
239 #define CROR_313131 0x4ffffb82
241 /* .glink entries for the first 32k functions are two instructions. */
242 #define LI_R0_0 0x38000000 /* li %r0,0 */
243 #define B_DOT 0x48000000 /* b . */
245 /* After that, we need two instructions to load the index, followed by
247 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
248 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
250 /* Instructions used by the save and restore reg functions. */
251 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
252 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
253 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
254 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
255 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
256 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
257 #define LI_R12_0 0x39800000 /* li %r12,0 */
258 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
259 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
260 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
261 #define BLR 0x4e800020 /* blr */
263 /* Since .opd is an array of descriptors and each entry will end up
264 with identical R_PPC64_RELATIVE relocs, there is really no need to
265 propagate .opd relocs; The dynamic linker should be taught to
266 relocate .opd without reloc entries. */
267 #ifndef NO_OPD_RELOCS
268 #define NO_OPD_RELOCS 0
272 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
276 abiversion (bfd
*abfd
)
278 return elf_elfheader (abfd
)->e_flags
& EF_PPC64_ABI
;
282 set_abiversion (bfd
*abfd
, int ver
)
284 elf_elfheader (abfd
)->e_flags
&= ~EF_PPC64_ABI
;
285 elf_elfheader (abfd
)->e_flags
|= ver
& EF_PPC64_ABI
;
288 /* Relocation HOWTO's. */
289 /* Like other ELF RELA targets that don't apply multiple
290 field-altering relocations to the same localation, src_mask is
291 always zero and pcrel_offset is the same as pc_relative.
292 PowerPC can always use a zero bitpos, even when the field is not at
293 the LSB. For example, a REL24 could use rightshift=2, bisize=24
294 and bitpos=2 which matches the ABI description, or as we do here,
295 rightshift=0, bitsize=26 and bitpos=0. */
296 #define HOW(type, size, bitsize, mask, rightshift, pc_relative, \
297 complain, special_func) \
298 HOWTO (type, rightshift, size, bitsize, pc_relative, 0, \
299 complain_overflow_ ## complain, special_func, \
300 #type, FALSE, 0, mask, pc_relative)
302 static reloc_howto_type
*ppc64_elf_howto_table
[(int) R_PPC64_max
];
304 static reloc_howto_type ppc64_elf_howto_raw
[] =
306 /* This reloc does nothing. */
307 HOW (R_PPC64_NONE
, 3, 0, 0, 0, FALSE
, dont
,
308 bfd_elf_generic_reloc
),
310 /* A standard 32 bit relocation. */
311 HOW (R_PPC64_ADDR32
, 2, 32, 0xffffffff, 0, FALSE
, bitfield
,
312 bfd_elf_generic_reloc
),
314 /* An absolute 26 bit branch; the lower two bits must be zero.
315 FIXME: we don't check that, we just clear them. */
316 HOW (R_PPC64_ADDR24
, 2, 26, 0x03fffffc, 0, FALSE
, bitfield
,
317 bfd_elf_generic_reloc
),
319 /* A standard 16 bit relocation. */
320 HOW (R_PPC64_ADDR16
, 1, 16, 0xffff, 0, FALSE
, bitfield
,
321 bfd_elf_generic_reloc
),
323 /* A 16 bit relocation without overflow. */
324 HOW (R_PPC64_ADDR16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
325 bfd_elf_generic_reloc
),
327 /* Bits 16-31 of an address. */
328 HOW (R_PPC64_ADDR16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
329 bfd_elf_generic_reloc
),
331 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
332 bits, treated as a signed number, is negative. */
333 HOW (R_PPC64_ADDR16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
336 /* An absolute 16 bit branch; the lower two bits must be zero.
337 FIXME: we don't check that, we just clear them. */
338 HOW (R_PPC64_ADDR14
, 2, 16, 0x0000fffc, 0, FALSE
, signed,
339 ppc64_elf_branch_reloc
),
341 /* An absolute 16 bit branch, for which bit 10 should be set to
342 indicate that the branch is expected to be taken. The lower two
343 bits must be zero. */
344 HOW (R_PPC64_ADDR14_BRTAKEN
, 2, 16, 0x0000fffc, 0, FALSE
, signed,
345 ppc64_elf_brtaken_reloc
),
347 /* An absolute 16 bit branch, for which bit 10 should be set to
348 indicate that the branch is not expected to be taken. The lower
349 two bits must be zero. */
350 HOW (R_PPC64_ADDR14_BRNTAKEN
, 2, 16, 0x0000fffc, 0, FALSE
, signed,
351 ppc64_elf_brtaken_reloc
),
353 /* A relative 26 bit branch; the lower two bits must be zero. */
354 HOW (R_PPC64_REL24
, 2, 26, 0x03fffffc, 0, TRUE
, signed,
355 ppc64_elf_branch_reloc
),
357 /* A variant of R_PPC64_REL24, used when r2 is not the toc pointer. */
358 HOW (R_PPC64_REL24_NOTOC
, 2, 26, 0x03fffffc, 0, TRUE
, signed,
359 ppc64_elf_branch_reloc
),
361 /* A relative 16 bit branch; the lower two bits must be zero. */
362 HOW (R_PPC64_REL14
, 2, 16, 0x0000fffc, 0, TRUE
, signed,
363 ppc64_elf_branch_reloc
),
365 /* A relative 16 bit branch. Bit 10 should be set to indicate that
366 the branch is expected to be taken. The lower two bits must be
368 HOW (R_PPC64_REL14_BRTAKEN
, 2, 16, 0x0000fffc, 0, TRUE
, signed,
369 ppc64_elf_brtaken_reloc
),
371 /* A relative 16 bit branch. Bit 10 should be set to indicate that
372 the branch is not expected to be taken. The lower two bits must
374 HOW (R_PPC64_REL14_BRNTAKEN
, 2, 16, 0x0000fffc, 0, TRUE
, signed,
375 ppc64_elf_brtaken_reloc
),
377 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
379 HOW (R_PPC64_GOT16
, 1, 16, 0xffff, 0, FALSE
, signed,
380 ppc64_elf_unhandled_reloc
),
382 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
384 HOW (R_PPC64_GOT16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
385 ppc64_elf_unhandled_reloc
),
387 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
389 HOW (R_PPC64_GOT16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
390 ppc64_elf_unhandled_reloc
),
392 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
394 HOW (R_PPC64_GOT16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
395 ppc64_elf_unhandled_reloc
),
397 /* This is used only by the dynamic linker. The symbol should exist
398 both in the object being run and in some shared library. The
399 dynamic linker copies the data addressed by the symbol from the
400 shared library into the object, because the object being
401 run has to have the data at some particular address. */
402 HOW (R_PPC64_COPY
, 0, 0, 0, 0, FALSE
, dont
,
403 ppc64_elf_unhandled_reloc
),
405 /* Like R_PPC64_ADDR64, but used when setting global offset table
407 HOW (R_PPC64_GLOB_DAT
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
408 ppc64_elf_unhandled_reloc
),
410 /* Created by the link editor. Marks a procedure linkage table
411 entry for a symbol. */
412 HOW (R_PPC64_JMP_SLOT
, 0, 0, 0, 0, FALSE
, dont
,
413 ppc64_elf_unhandled_reloc
),
415 /* Used only by the dynamic linker. When the object is run, this
416 doubleword64 is set to the load address of the object, plus the
418 HOW (R_PPC64_RELATIVE
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
419 bfd_elf_generic_reloc
),
421 /* Like R_PPC64_ADDR32, but may be unaligned. */
422 HOW (R_PPC64_UADDR32
, 2, 32, 0xffffffff, 0, FALSE
, bitfield
,
423 bfd_elf_generic_reloc
),
425 /* Like R_PPC64_ADDR16, but may be unaligned. */
426 HOW (R_PPC64_UADDR16
, 1, 16, 0xffff, 0, FALSE
, bitfield
,
427 bfd_elf_generic_reloc
),
429 /* 32-bit PC relative. */
430 HOW (R_PPC64_REL32
, 2, 32, 0xffffffff, 0, TRUE
, signed,
431 bfd_elf_generic_reloc
),
433 /* 32-bit relocation to the symbol's procedure linkage table. */
434 HOW (R_PPC64_PLT32
, 2, 32, 0xffffffff, 0, FALSE
, bitfield
,
435 ppc64_elf_unhandled_reloc
),
437 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
438 FIXME: R_PPC64_PLTREL32 not supported. */
439 HOW (R_PPC64_PLTREL32
, 2, 32, 0xffffffff, 0, TRUE
, signed,
440 ppc64_elf_unhandled_reloc
),
442 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
444 HOW (R_PPC64_PLT16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
445 ppc64_elf_unhandled_reloc
),
447 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
449 HOW (R_PPC64_PLT16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
450 ppc64_elf_unhandled_reloc
),
452 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
454 HOW (R_PPC64_PLT16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
455 ppc64_elf_unhandled_reloc
),
457 /* 16-bit section relative relocation. */
458 HOW (R_PPC64_SECTOFF
, 1, 16, 0xffff, 0, FALSE
, signed,
459 ppc64_elf_sectoff_reloc
),
461 /* Like R_PPC64_SECTOFF, but no overflow warning. */
462 HOW (R_PPC64_SECTOFF_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
463 ppc64_elf_sectoff_reloc
),
465 /* 16-bit upper half section relative relocation. */
466 HOW (R_PPC64_SECTOFF_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
467 ppc64_elf_sectoff_reloc
),
469 /* 16-bit upper half adjusted section relative relocation. */
470 HOW (R_PPC64_SECTOFF_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
471 ppc64_elf_sectoff_ha_reloc
),
473 /* Like R_PPC64_REL24 without touching the two least significant bits. */
474 HOW (R_PPC64_REL30
, 2, 30, 0xfffffffc, 2, TRUE
, dont
,
475 bfd_elf_generic_reloc
),
477 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
479 /* A standard 64-bit relocation. */
480 HOW (R_PPC64_ADDR64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
481 bfd_elf_generic_reloc
),
483 /* The bits 32-47 of an address. */
484 HOW (R_PPC64_ADDR16_HIGHER
, 1, 16, 0xffff, 32, FALSE
, dont
,
485 bfd_elf_generic_reloc
),
487 /* The bits 32-47 of an address, plus 1 if the contents of the low
488 16 bits, treated as a signed number, is negative. */
489 HOW (R_PPC64_ADDR16_HIGHERA
, 1, 16, 0xffff, 32, FALSE
, dont
,
492 /* The bits 48-63 of an address. */
493 HOW (R_PPC64_ADDR16_HIGHEST
, 1, 16, 0xffff, 48, FALSE
, dont
,
494 bfd_elf_generic_reloc
),
496 /* The bits 48-63 of an address, plus 1 if the contents of the low
497 16 bits, treated as a signed number, is negative. */
498 HOW (R_PPC64_ADDR16_HIGHESTA
, 1, 16, 0xffff, 48, FALSE
, dont
,
501 /* Like ADDR64, but may be unaligned. */
502 HOW (R_PPC64_UADDR64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
503 bfd_elf_generic_reloc
),
505 /* 64-bit relative relocation. */
506 HOW (R_PPC64_REL64
, 4, 64, 0xffffffffffffffffULL
, 0, TRUE
, dont
,
507 bfd_elf_generic_reloc
),
509 /* 64-bit relocation to the symbol's procedure linkage table. */
510 HOW (R_PPC64_PLT64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
511 ppc64_elf_unhandled_reloc
),
513 /* 64-bit PC relative relocation to the symbol's procedure linkage
515 /* FIXME: R_PPC64_PLTREL64 not supported. */
516 HOW (R_PPC64_PLTREL64
, 4, 64, 0xffffffffffffffffULL
, 0, TRUE
, dont
,
517 ppc64_elf_unhandled_reloc
),
519 /* 16 bit TOC-relative relocation. */
520 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
521 HOW (R_PPC64_TOC16
, 1, 16, 0xffff, 0, FALSE
, signed,
522 ppc64_elf_toc_reloc
),
524 /* 16 bit TOC-relative relocation without overflow. */
525 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
526 HOW (R_PPC64_TOC16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
527 ppc64_elf_toc_reloc
),
529 /* 16 bit TOC-relative relocation, high 16 bits. */
530 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
531 HOW (R_PPC64_TOC16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
532 ppc64_elf_toc_reloc
),
534 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
535 contents of the low 16 bits, treated as a signed number, is
537 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
538 HOW (R_PPC64_TOC16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
539 ppc64_elf_toc_ha_reloc
),
541 /* 64-bit relocation; insert value of TOC base (.TOC.). */
542 /* R_PPC64_TOC 51 doubleword64 .TOC. */
543 HOW (R_PPC64_TOC
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
544 ppc64_elf_toc64_reloc
),
546 /* Like R_PPC64_GOT16, but also informs the link editor that the
547 value to relocate may (!) refer to a PLT entry which the link
548 editor (a) may replace with the symbol value. If the link editor
549 is unable to fully resolve the symbol, it may (b) create a PLT
550 entry and store the address to the new PLT entry in the GOT.
551 This permits lazy resolution of function symbols at run time.
552 The link editor may also skip all of this and just (c) emit a
553 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
554 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
555 HOW (R_PPC64_PLTGOT16
, 1, 16, 0xffff, 0, FALSE
,signed,
556 ppc64_elf_unhandled_reloc
),
558 /* Like R_PPC64_PLTGOT16, but without overflow. */
559 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
560 HOW (R_PPC64_PLTGOT16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
561 ppc64_elf_unhandled_reloc
),
563 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
564 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
565 HOW (R_PPC64_PLTGOT16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
566 ppc64_elf_unhandled_reloc
),
568 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
569 1 if the contents of the low 16 bits, treated as a signed number,
571 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
572 HOW (R_PPC64_PLTGOT16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
573 ppc64_elf_unhandled_reloc
),
575 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
576 HOW (R_PPC64_ADDR16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
577 bfd_elf_generic_reloc
),
579 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
580 HOW (R_PPC64_ADDR16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
581 bfd_elf_generic_reloc
),
583 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
584 HOW (R_PPC64_GOT16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
585 ppc64_elf_unhandled_reloc
),
587 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
588 HOW (R_PPC64_GOT16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
589 ppc64_elf_unhandled_reloc
),
591 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
592 HOW (R_PPC64_PLT16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
593 ppc64_elf_unhandled_reloc
),
595 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
596 HOW (R_PPC64_SECTOFF_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
597 ppc64_elf_sectoff_reloc
),
599 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
600 HOW (R_PPC64_SECTOFF_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
601 ppc64_elf_sectoff_reloc
),
603 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
604 HOW (R_PPC64_TOC16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
605 ppc64_elf_toc_reloc
),
607 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
608 HOW (R_PPC64_TOC16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
609 ppc64_elf_toc_reloc
),
611 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
612 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
613 HOW (R_PPC64_PLTGOT16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
614 ppc64_elf_unhandled_reloc
),
616 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
617 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
618 HOW (R_PPC64_PLTGOT16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
619 ppc64_elf_unhandled_reloc
),
621 /* Marker relocs for TLS. */
622 HOW (R_PPC64_TLS
, 2, 32, 0, 0, FALSE
, dont
,
623 bfd_elf_generic_reloc
),
625 HOW (R_PPC64_TLSGD
, 2, 32, 0, 0, FALSE
, dont
,
626 bfd_elf_generic_reloc
),
628 HOW (R_PPC64_TLSLD
, 2, 32, 0, 0, FALSE
, dont
,
629 bfd_elf_generic_reloc
),
631 /* Marker reloc for optimizing r2 save in prologue rather than on
632 each plt call stub. */
633 HOW (R_PPC64_TOCSAVE
, 2, 32, 0, 0, FALSE
, dont
,
634 bfd_elf_generic_reloc
),
636 /* Marker relocs on inline plt call instructions. */
637 HOW (R_PPC64_PLTSEQ
, 2, 32, 0, 0, FALSE
, dont
,
638 bfd_elf_generic_reloc
),
640 HOW (R_PPC64_PLTCALL
, 2, 32, 0, 0, FALSE
, dont
,
641 bfd_elf_generic_reloc
),
643 /* Computes the load module index of the load module that contains the
644 definition of its TLS sym. */
645 HOW (R_PPC64_DTPMOD64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
646 ppc64_elf_unhandled_reloc
),
648 /* Computes a dtv-relative displacement, the difference between the value
649 of sym+add and the base address of the thread-local storage block that
650 contains the definition of sym, minus 0x8000. */
651 HOW (R_PPC64_DTPREL64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
652 ppc64_elf_unhandled_reloc
),
654 /* A 16 bit dtprel reloc. */
655 HOW (R_PPC64_DTPREL16
, 1, 16, 0xffff, 0, FALSE
, signed,
656 ppc64_elf_unhandled_reloc
),
658 /* Like DTPREL16, but no overflow. */
659 HOW (R_PPC64_DTPREL16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
660 ppc64_elf_unhandled_reloc
),
662 /* Like DTPREL16_LO, but next higher group of 16 bits. */
663 HOW (R_PPC64_DTPREL16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
664 ppc64_elf_unhandled_reloc
),
666 /* Like DTPREL16_HI, but adjust for low 16 bits. */
667 HOW (R_PPC64_DTPREL16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
668 ppc64_elf_unhandled_reloc
),
670 /* Like DTPREL16_HI, but next higher group of 16 bits. */
671 HOW (R_PPC64_DTPREL16_HIGHER
, 1, 16, 0xffff, 32, FALSE
, dont
,
672 ppc64_elf_unhandled_reloc
),
674 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
675 HOW (R_PPC64_DTPREL16_HIGHERA
, 1, 16, 0xffff, 32, FALSE
, dont
,
676 ppc64_elf_unhandled_reloc
),
678 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
679 HOW (R_PPC64_DTPREL16_HIGHEST
, 1, 16, 0xffff, 48, FALSE
, dont
,
680 ppc64_elf_unhandled_reloc
),
682 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
683 HOW (R_PPC64_DTPREL16_HIGHESTA
, 1, 16, 0xffff, 48, FALSE
, dont
,
684 ppc64_elf_unhandled_reloc
),
686 /* Like DTPREL16, but for insns with a DS field. */
687 HOW (R_PPC64_DTPREL16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
688 ppc64_elf_unhandled_reloc
),
690 /* Like DTPREL16_DS, but no overflow. */
691 HOW (R_PPC64_DTPREL16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
692 ppc64_elf_unhandled_reloc
),
694 /* Computes a tp-relative displacement, the difference between the value of
695 sym+add and the value of the thread pointer (r13). */
696 HOW (R_PPC64_TPREL64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
697 ppc64_elf_unhandled_reloc
),
699 /* A 16 bit tprel reloc. */
700 HOW (R_PPC64_TPREL16
, 1, 16, 0xffff, 0, FALSE
, signed,
701 ppc64_elf_unhandled_reloc
),
703 /* Like TPREL16, but no overflow. */
704 HOW (R_PPC64_TPREL16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
705 ppc64_elf_unhandled_reloc
),
707 /* Like TPREL16_LO, but next higher group of 16 bits. */
708 HOW (R_PPC64_TPREL16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
709 ppc64_elf_unhandled_reloc
),
711 /* Like TPREL16_HI, but adjust for low 16 bits. */
712 HOW (R_PPC64_TPREL16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
713 ppc64_elf_unhandled_reloc
),
715 /* Like TPREL16_HI, but next higher group of 16 bits. */
716 HOW (R_PPC64_TPREL16_HIGHER
, 1, 16, 0xffff, 32, FALSE
, dont
,
717 ppc64_elf_unhandled_reloc
),
719 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
720 HOW (R_PPC64_TPREL16_HIGHERA
, 1, 16, 0xffff, 32, FALSE
, dont
,
721 ppc64_elf_unhandled_reloc
),
723 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
724 HOW (R_PPC64_TPREL16_HIGHEST
, 1, 16, 0xffff, 48, FALSE
, dont
,
725 ppc64_elf_unhandled_reloc
),
727 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
728 HOW (R_PPC64_TPREL16_HIGHESTA
, 1, 16, 0xffff, 48, FALSE
, dont
,
729 ppc64_elf_unhandled_reloc
),
731 /* Like TPREL16, but for insns with a DS field. */
732 HOW (R_PPC64_TPREL16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
733 ppc64_elf_unhandled_reloc
),
735 /* Like TPREL16_DS, but no overflow. */
736 HOW (R_PPC64_TPREL16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
737 ppc64_elf_unhandled_reloc
),
739 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
740 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
741 to the first entry relative to the TOC base (r2). */
742 HOW (R_PPC64_GOT_TLSGD16
, 1, 16, 0xffff, 0, FALSE
, signed,
743 ppc64_elf_unhandled_reloc
),
745 /* Like GOT_TLSGD16, but no overflow. */
746 HOW (R_PPC64_GOT_TLSGD16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
747 ppc64_elf_unhandled_reloc
),
749 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
750 HOW (R_PPC64_GOT_TLSGD16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
751 ppc64_elf_unhandled_reloc
),
753 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
754 HOW (R_PPC64_GOT_TLSGD16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
755 ppc64_elf_unhandled_reloc
),
757 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
758 with values (sym+add)@dtpmod and zero, and computes the offset to the
759 first entry relative to the TOC base (r2). */
760 HOW (R_PPC64_GOT_TLSLD16
, 1, 16, 0xffff, 0, FALSE
, signed,
761 ppc64_elf_unhandled_reloc
),
763 /* Like GOT_TLSLD16, but no overflow. */
764 HOW (R_PPC64_GOT_TLSLD16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
765 ppc64_elf_unhandled_reloc
),
767 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
768 HOW (R_PPC64_GOT_TLSLD16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
769 ppc64_elf_unhandled_reloc
),
771 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
772 HOW (R_PPC64_GOT_TLSLD16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
773 ppc64_elf_unhandled_reloc
),
775 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
776 the offset to the entry relative to the TOC base (r2). */
777 HOW (R_PPC64_GOT_DTPREL16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
778 ppc64_elf_unhandled_reloc
),
780 /* Like GOT_DTPREL16_DS, but no overflow. */
781 HOW (R_PPC64_GOT_DTPREL16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
782 ppc64_elf_unhandled_reloc
),
784 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
785 HOW (R_PPC64_GOT_DTPREL16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
786 ppc64_elf_unhandled_reloc
),
788 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
789 HOW (R_PPC64_GOT_DTPREL16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
790 ppc64_elf_unhandled_reloc
),
792 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
793 offset to the entry relative to the TOC base (r2). */
794 HOW (R_PPC64_GOT_TPREL16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
795 ppc64_elf_unhandled_reloc
),
797 /* Like GOT_TPREL16_DS, but no overflow. */
798 HOW (R_PPC64_GOT_TPREL16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
799 ppc64_elf_unhandled_reloc
),
801 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
802 HOW (R_PPC64_GOT_TPREL16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
803 ppc64_elf_unhandled_reloc
),
805 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
806 HOW (R_PPC64_GOT_TPREL16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
807 ppc64_elf_unhandled_reloc
),
809 HOW (R_PPC64_JMP_IREL
, 0, 0, 0, 0, FALSE
, dont
,
810 ppc64_elf_unhandled_reloc
),
812 HOW (R_PPC64_IRELATIVE
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
813 bfd_elf_generic_reloc
),
815 /* A 16 bit relative relocation. */
816 HOW (R_PPC64_REL16
, 1, 16, 0xffff, 0, TRUE
, signed,
817 bfd_elf_generic_reloc
),
819 /* A 16 bit relative relocation without overflow. */
820 HOW (R_PPC64_REL16_LO
, 1, 16, 0xffff, 0, TRUE
, dont
,
821 bfd_elf_generic_reloc
),
823 /* The high order 16 bits of a relative address. */
824 HOW (R_PPC64_REL16_HI
, 1, 16, 0xffff, 16, TRUE
, signed,
825 bfd_elf_generic_reloc
),
827 /* The high order 16 bits of a relative address, plus 1 if the contents of
828 the low 16 bits, treated as a signed number, is negative. */
829 HOW (R_PPC64_REL16_HA
, 1, 16, 0xffff, 16, TRUE
, signed,
832 HOW (R_PPC64_REL16_HIGH
, 1, 16, 0xffff, 16, TRUE
, dont
,
833 bfd_elf_generic_reloc
),
835 HOW (R_PPC64_REL16_HIGHA
, 1, 16, 0xffff, 16, TRUE
, dont
,
838 HOW (R_PPC64_REL16_HIGHER
, 1, 16, 0xffff, 32, TRUE
, dont
,
839 bfd_elf_generic_reloc
),
841 HOW (R_PPC64_REL16_HIGHERA
, 1, 16, 0xffff, 32, TRUE
, dont
,
844 HOW (R_PPC64_REL16_HIGHEST
, 1, 16, 0xffff, 48, TRUE
, dont
,
845 bfd_elf_generic_reloc
),
847 HOW (R_PPC64_REL16_HIGHESTA
, 1, 16, 0xffff, 48, TRUE
, dont
,
850 /* Like R_PPC64_REL16_HA but for split field in addpcis. */
851 HOW (R_PPC64_REL16DX_HA
, 2, 16, 0x1fffc1, 16, TRUE
, signed,
854 /* A split-field reloc for addpcis, non-relative (gas internal use only). */
855 HOW (R_PPC64_16DX_HA
, 2, 16, 0x1fffc1, 16, FALSE
, signed,
858 /* Like R_PPC64_ADDR16_HI, but no overflow. */
859 HOW (R_PPC64_ADDR16_HIGH
, 1, 16, 0xffff, 16, FALSE
, dont
,
860 bfd_elf_generic_reloc
),
862 /* Like R_PPC64_ADDR16_HA, but no overflow. */
863 HOW (R_PPC64_ADDR16_HIGHA
, 1, 16, 0xffff, 16, FALSE
, dont
,
866 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
867 HOW (R_PPC64_DTPREL16_HIGH
, 1, 16, 0xffff, 16, FALSE
, dont
,
868 ppc64_elf_unhandled_reloc
),
870 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
871 HOW (R_PPC64_DTPREL16_HIGHA
, 1, 16, 0xffff, 16, FALSE
, dont
,
872 ppc64_elf_unhandled_reloc
),
874 /* Like R_PPC64_TPREL16_HI, but no overflow. */
875 HOW (R_PPC64_TPREL16_HIGH
, 1, 16, 0xffff, 16, FALSE
, dont
,
876 ppc64_elf_unhandled_reloc
),
878 /* Like R_PPC64_TPREL16_HA, but no overflow. */
879 HOW (R_PPC64_TPREL16_HIGHA
, 1, 16, 0xffff, 16, FALSE
, dont
,
880 ppc64_elf_unhandled_reloc
),
882 /* Marker reloc on ELFv2 large-model function entry. */
883 HOW (R_PPC64_ENTRY
, 2, 32, 0, 0, FALSE
, dont
,
884 bfd_elf_generic_reloc
),
886 /* Like ADDR64, but use local entry point of function. */
887 HOW (R_PPC64_ADDR64_LOCAL
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
888 bfd_elf_generic_reloc
),
890 HOW (R_PPC64_PLTSEQ_NOTOC
, 2, 32, 0, 0, FALSE
, dont
,
891 bfd_elf_generic_reloc
),
893 HOW (R_PPC64_PLTCALL_NOTOC
, 2, 32, 0, 0, FALSE
, dont
,
894 bfd_elf_generic_reloc
),
896 HOW (R_PPC64_PCREL_OPT
, 2, 32, 0, 0, FALSE
, dont
,
897 bfd_elf_generic_reloc
),
899 HOW (R_PPC64_D34
, 4, 34, 0x3ffff0000ffffULL
, 0, FALSE
, signed,
900 ppc64_elf_prefix_reloc
),
902 HOW (R_PPC64_D34_LO
, 4, 34, 0x3ffff0000ffffULL
, 0, FALSE
, dont
,
903 ppc64_elf_prefix_reloc
),
905 HOW (R_PPC64_D34_HI30
, 4, 34, 0x3ffff0000ffffULL
, 34, FALSE
, dont
,
906 ppc64_elf_prefix_reloc
),
908 HOW (R_PPC64_D34_HA30
, 4, 34, 0x3ffff0000ffffULL
, 34, FALSE
, dont
,
909 ppc64_elf_prefix_reloc
),
911 HOW (R_PPC64_PCREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
912 ppc64_elf_prefix_reloc
),
914 HOW (R_PPC64_GOT_PCREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
915 ppc64_elf_unhandled_reloc
),
917 HOW (R_PPC64_PLT_PCREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
918 ppc64_elf_unhandled_reloc
),
920 HOW (R_PPC64_PLT_PCREL34_NOTOC
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
921 ppc64_elf_unhandled_reloc
),
923 HOW (R_PPC64_TPREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, FALSE
, signed,
924 ppc64_elf_unhandled_reloc
),
926 HOW (R_PPC64_DTPREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, FALSE
, signed,
927 ppc64_elf_unhandled_reloc
),
929 HOW (R_PPC64_GOT_TLSGD34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
930 ppc64_elf_unhandled_reloc
),
932 HOW (R_PPC64_GOT_TLSLD34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
933 ppc64_elf_unhandled_reloc
),
935 HOW (R_PPC64_GOT_TPREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
936 ppc64_elf_unhandled_reloc
),
938 HOW (R_PPC64_GOT_DTPREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
939 ppc64_elf_unhandled_reloc
),
941 HOW (R_PPC64_ADDR16_HIGHER34
, 1, 16, 0xffff, 34, FALSE
, dont
,
942 bfd_elf_generic_reloc
),
944 HOW (R_PPC64_ADDR16_HIGHERA34
, 1, 16, 0xffff, 34, FALSE
, dont
,
947 HOW (R_PPC64_ADDR16_HIGHEST34
, 1, 16, 0xffff, 50, FALSE
, dont
,
948 bfd_elf_generic_reloc
),
950 HOW (R_PPC64_ADDR16_HIGHESTA34
, 1, 16, 0xffff, 50, FALSE
, dont
,
953 HOW (R_PPC64_REL16_HIGHER34
, 1, 16, 0xffff, 34, TRUE
, dont
,
954 bfd_elf_generic_reloc
),
956 HOW (R_PPC64_REL16_HIGHERA34
, 1, 16, 0xffff, 34, TRUE
, dont
,
959 HOW (R_PPC64_REL16_HIGHEST34
, 1, 16, 0xffff, 50, TRUE
, dont
,
960 bfd_elf_generic_reloc
),
962 HOW (R_PPC64_REL16_HIGHESTA34
, 1, 16, 0xffff, 50, TRUE
, dont
,
965 HOW (R_PPC64_D28
, 4, 28, 0xfff0000ffffULL
, 0, FALSE
, signed,
966 ppc64_elf_prefix_reloc
),
968 HOW (R_PPC64_PCREL28
, 4, 28, 0xfff0000ffffULL
, 0, TRUE
, signed,
969 ppc64_elf_prefix_reloc
),
971 /* GNU extension to record C++ vtable hierarchy. */
972 HOW (R_PPC64_GNU_VTINHERIT
, 0, 0, 0, 0, FALSE
, dont
,
975 /* GNU extension to record C++ vtable member usage. */
976 HOW (R_PPC64_GNU_VTENTRY
, 0, 0, 0, 0, FALSE
, dont
,
981 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
985 ppc_howto_init (void)
987 unsigned int i
, type
;
989 for (i
= 0; i
< ARRAY_SIZE (ppc64_elf_howto_raw
); i
++)
991 type
= ppc64_elf_howto_raw
[i
].type
;
992 BFD_ASSERT (type
< ARRAY_SIZE (ppc64_elf_howto_table
));
993 ppc64_elf_howto_table
[type
] = &ppc64_elf_howto_raw
[i
];
997 static reloc_howto_type
*
998 ppc64_elf_reloc_type_lookup (bfd
*abfd
,
999 bfd_reloc_code_real_type code
)
1001 enum elf_ppc64_reloc_type r
= R_PPC64_NONE
;
1003 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
1004 /* Initialize howto table if needed. */
1010 /* xgettext:c-format */
1011 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd
,
1013 bfd_set_error (bfd_error_bad_value
);
1016 case BFD_RELOC_NONE
: r
= R_PPC64_NONE
;
1018 case BFD_RELOC_32
: r
= R_PPC64_ADDR32
;
1020 case BFD_RELOC_PPC_BA26
: r
= R_PPC64_ADDR24
;
1022 case BFD_RELOC_16
: r
= R_PPC64_ADDR16
;
1024 case BFD_RELOC_LO16
: r
= R_PPC64_ADDR16_LO
;
1026 case BFD_RELOC_HI16
: r
= R_PPC64_ADDR16_HI
;
1028 case BFD_RELOC_PPC64_ADDR16_HIGH
: r
= R_PPC64_ADDR16_HIGH
;
1030 case BFD_RELOC_HI16_S
: r
= R_PPC64_ADDR16_HA
;
1032 case BFD_RELOC_PPC64_ADDR16_HIGHA
: r
= R_PPC64_ADDR16_HIGHA
;
1034 case BFD_RELOC_PPC_BA16
: r
= R_PPC64_ADDR14
;
1036 case BFD_RELOC_PPC_BA16_BRTAKEN
: r
= R_PPC64_ADDR14_BRTAKEN
;
1038 case BFD_RELOC_PPC_BA16_BRNTAKEN
: r
= R_PPC64_ADDR14_BRNTAKEN
;
1040 case BFD_RELOC_PPC_B26
: r
= R_PPC64_REL24
;
1042 case BFD_RELOC_PPC64_REL24_NOTOC
: r
= R_PPC64_REL24_NOTOC
;
1044 case BFD_RELOC_PPC_B16
: r
= R_PPC64_REL14
;
1046 case BFD_RELOC_PPC_B16_BRTAKEN
: r
= R_PPC64_REL14_BRTAKEN
;
1048 case BFD_RELOC_PPC_B16_BRNTAKEN
: r
= R_PPC64_REL14_BRNTAKEN
;
1050 case BFD_RELOC_16_GOTOFF
: r
= R_PPC64_GOT16
;
1052 case BFD_RELOC_LO16_GOTOFF
: r
= R_PPC64_GOT16_LO
;
1054 case BFD_RELOC_HI16_GOTOFF
: r
= R_PPC64_GOT16_HI
;
1056 case BFD_RELOC_HI16_S_GOTOFF
: r
= R_PPC64_GOT16_HA
;
1058 case BFD_RELOC_PPC_COPY
: r
= R_PPC64_COPY
;
1060 case BFD_RELOC_PPC_GLOB_DAT
: r
= R_PPC64_GLOB_DAT
;
1062 case BFD_RELOC_32_PCREL
: r
= R_PPC64_REL32
;
1064 case BFD_RELOC_32_PLTOFF
: r
= R_PPC64_PLT32
;
1066 case BFD_RELOC_32_PLT_PCREL
: r
= R_PPC64_PLTREL32
;
1068 case BFD_RELOC_LO16_PLTOFF
: r
= R_PPC64_PLT16_LO
;
1070 case BFD_RELOC_HI16_PLTOFF
: r
= R_PPC64_PLT16_HI
;
1072 case BFD_RELOC_HI16_S_PLTOFF
: r
= R_PPC64_PLT16_HA
;
1074 case BFD_RELOC_16_BASEREL
: r
= R_PPC64_SECTOFF
;
1076 case BFD_RELOC_LO16_BASEREL
: r
= R_PPC64_SECTOFF_LO
;
1078 case BFD_RELOC_HI16_BASEREL
: r
= R_PPC64_SECTOFF_HI
;
1080 case BFD_RELOC_HI16_S_BASEREL
: r
= R_PPC64_SECTOFF_HA
;
1082 case BFD_RELOC_CTOR
: r
= R_PPC64_ADDR64
;
1084 case BFD_RELOC_64
: r
= R_PPC64_ADDR64
;
1086 case BFD_RELOC_PPC64_HIGHER
: r
= R_PPC64_ADDR16_HIGHER
;
1088 case BFD_RELOC_PPC64_HIGHER_S
: r
= R_PPC64_ADDR16_HIGHERA
;
1090 case BFD_RELOC_PPC64_HIGHEST
: r
= R_PPC64_ADDR16_HIGHEST
;
1092 case BFD_RELOC_PPC64_HIGHEST_S
: r
= R_PPC64_ADDR16_HIGHESTA
;
1094 case BFD_RELOC_64_PCREL
: r
= R_PPC64_REL64
;
1096 case BFD_RELOC_64_PLTOFF
: r
= R_PPC64_PLT64
;
1098 case BFD_RELOC_64_PLT_PCREL
: r
= R_PPC64_PLTREL64
;
1100 case BFD_RELOC_PPC_TOC16
: r
= R_PPC64_TOC16
;
1102 case BFD_RELOC_PPC64_TOC16_LO
: r
= R_PPC64_TOC16_LO
;
1104 case BFD_RELOC_PPC64_TOC16_HI
: r
= R_PPC64_TOC16_HI
;
1106 case BFD_RELOC_PPC64_TOC16_HA
: r
= R_PPC64_TOC16_HA
;
1108 case BFD_RELOC_PPC64_TOC
: r
= R_PPC64_TOC
;
1110 case BFD_RELOC_PPC64_PLTGOT16
: r
= R_PPC64_PLTGOT16
;
1112 case BFD_RELOC_PPC64_PLTGOT16_LO
: r
= R_PPC64_PLTGOT16_LO
;
1114 case BFD_RELOC_PPC64_PLTGOT16_HI
: r
= R_PPC64_PLTGOT16_HI
;
1116 case BFD_RELOC_PPC64_PLTGOT16_HA
: r
= R_PPC64_PLTGOT16_HA
;
1118 case BFD_RELOC_PPC64_ADDR16_DS
: r
= R_PPC64_ADDR16_DS
;
1120 case BFD_RELOC_PPC64_ADDR16_LO_DS
: r
= R_PPC64_ADDR16_LO_DS
;
1122 case BFD_RELOC_PPC64_GOT16_DS
: r
= R_PPC64_GOT16_DS
;
1124 case BFD_RELOC_PPC64_GOT16_LO_DS
: r
= R_PPC64_GOT16_LO_DS
;
1126 case BFD_RELOC_PPC64_PLT16_LO_DS
: r
= R_PPC64_PLT16_LO_DS
;
1128 case BFD_RELOC_PPC64_SECTOFF_DS
: r
= R_PPC64_SECTOFF_DS
;
1130 case BFD_RELOC_PPC64_SECTOFF_LO_DS
: r
= R_PPC64_SECTOFF_LO_DS
;
1132 case BFD_RELOC_PPC64_TOC16_DS
: r
= R_PPC64_TOC16_DS
;
1134 case BFD_RELOC_PPC64_TOC16_LO_DS
: r
= R_PPC64_TOC16_LO_DS
;
1136 case BFD_RELOC_PPC64_PLTGOT16_DS
: r
= R_PPC64_PLTGOT16_DS
;
1138 case BFD_RELOC_PPC64_PLTGOT16_LO_DS
: r
= R_PPC64_PLTGOT16_LO_DS
;
1140 case BFD_RELOC_PPC64_TLS_PCREL
:
1141 case BFD_RELOC_PPC_TLS
: r
= R_PPC64_TLS
;
1143 case BFD_RELOC_PPC_TLSGD
: r
= R_PPC64_TLSGD
;
1145 case BFD_RELOC_PPC_TLSLD
: r
= R_PPC64_TLSLD
;
1147 case BFD_RELOC_PPC_DTPMOD
: r
= R_PPC64_DTPMOD64
;
1149 case BFD_RELOC_PPC_TPREL16
: r
= R_PPC64_TPREL16
;
1151 case BFD_RELOC_PPC_TPREL16_LO
: r
= R_PPC64_TPREL16_LO
;
1153 case BFD_RELOC_PPC_TPREL16_HI
: r
= R_PPC64_TPREL16_HI
;
1155 case BFD_RELOC_PPC64_TPREL16_HIGH
: r
= R_PPC64_TPREL16_HIGH
;
1157 case BFD_RELOC_PPC_TPREL16_HA
: r
= R_PPC64_TPREL16_HA
;
1159 case BFD_RELOC_PPC64_TPREL16_HIGHA
: r
= R_PPC64_TPREL16_HIGHA
;
1161 case BFD_RELOC_PPC_TPREL
: r
= R_PPC64_TPREL64
;
1163 case BFD_RELOC_PPC_DTPREL16
: r
= R_PPC64_DTPREL16
;
1165 case BFD_RELOC_PPC_DTPREL16_LO
: r
= R_PPC64_DTPREL16_LO
;
1167 case BFD_RELOC_PPC_DTPREL16_HI
: r
= R_PPC64_DTPREL16_HI
;
1169 case BFD_RELOC_PPC64_DTPREL16_HIGH
: r
= R_PPC64_DTPREL16_HIGH
;
1171 case BFD_RELOC_PPC_DTPREL16_HA
: r
= R_PPC64_DTPREL16_HA
;
1173 case BFD_RELOC_PPC64_DTPREL16_HIGHA
: r
= R_PPC64_DTPREL16_HIGHA
;
1175 case BFD_RELOC_PPC_DTPREL
: r
= R_PPC64_DTPREL64
;
1177 case BFD_RELOC_PPC_GOT_TLSGD16
: r
= R_PPC64_GOT_TLSGD16
;
1179 case BFD_RELOC_PPC_GOT_TLSGD16_LO
: r
= R_PPC64_GOT_TLSGD16_LO
;
1181 case BFD_RELOC_PPC_GOT_TLSGD16_HI
: r
= R_PPC64_GOT_TLSGD16_HI
;
1183 case BFD_RELOC_PPC_GOT_TLSGD16_HA
: r
= R_PPC64_GOT_TLSGD16_HA
;
1185 case BFD_RELOC_PPC_GOT_TLSLD16
: r
= R_PPC64_GOT_TLSLD16
;
1187 case BFD_RELOC_PPC_GOT_TLSLD16_LO
: r
= R_PPC64_GOT_TLSLD16_LO
;
1189 case BFD_RELOC_PPC_GOT_TLSLD16_HI
: r
= R_PPC64_GOT_TLSLD16_HI
;
1191 case BFD_RELOC_PPC_GOT_TLSLD16_HA
: r
= R_PPC64_GOT_TLSLD16_HA
;
1193 case BFD_RELOC_PPC_GOT_TPREL16
: r
= R_PPC64_GOT_TPREL16_DS
;
1195 case BFD_RELOC_PPC_GOT_TPREL16_LO
: r
= R_PPC64_GOT_TPREL16_LO_DS
;
1197 case BFD_RELOC_PPC_GOT_TPREL16_HI
: r
= R_PPC64_GOT_TPREL16_HI
;
1199 case BFD_RELOC_PPC_GOT_TPREL16_HA
: r
= R_PPC64_GOT_TPREL16_HA
;
1201 case BFD_RELOC_PPC_GOT_DTPREL16
: r
= R_PPC64_GOT_DTPREL16_DS
;
1203 case BFD_RELOC_PPC_GOT_DTPREL16_LO
: r
= R_PPC64_GOT_DTPREL16_LO_DS
;
1205 case BFD_RELOC_PPC_GOT_DTPREL16_HI
: r
= R_PPC64_GOT_DTPREL16_HI
;
1207 case BFD_RELOC_PPC_GOT_DTPREL16_HA
: r
= R_PPC64_GOT_DTPREL16_HA
;
1209 case BFD_RELOC_PPC64_TPREL16_DS
: r
= R_PPC64_TPREL16_DS
;
1211 case BFD_RELOC_PPC64_TPREL16_LO_DS
: r
= R_PPC64_TPREL16_LO_DS
;
1213 case BFD_RELOC_PPC64_TPREL16_HIGHER
: r
= R_PPC64_TPREL16_HIGHER
;
1215 case BFD_RELOC_PPC64_TPREL16_HIGHERA
: r
= R_PPC64_TPREL16_HIGHERA
;
1217 case BFD_RELOC_PPC64_TPREL16_HIGHEST
: r
= R_PPC64_TPREL16_HIGHEST
;
1219 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
: r
= R_PPC64_TPREL16_HIGHESTA
;
1221 case BFD_RELOC_PPC64_DTPREL16_DS
: r
= R_PPC64_DTPREL16_DS
;
1223 case BFD_RELOC_PPC64_DTPREL16_LO_DS
: r
= R_PPC64_DTPREL16_LO_DS
;
1225 case BFD_RELOC_PPC64_DTPREL16_HIGHER
: r
= R_PPC64_DTPREL16_HIGHER
;
1227 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
: r
= R_PPC64_DTPREL16_HIGHERA
;
1229 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
: r
= R_PPC64_DTPREL16_HIGHEST
;
1231 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
: r
= R_PPC64_DTPREL16_HIGHESTA
;
1233 case BFD_RELOC_16_PCREL
: r
= R_PPC64_REL16
;
1235 case BFD_RELOC_LO16_PCREL
: r
= R_PPC64_REL16_LO
;
1237 case BFD_RELOC_HI16_PCREL
: r
= R_PPC64_REL16_HI
;
1239 case BFD_RELOC_HI16_S_PCREL
: r
= R_PPC64_REL16_HA
;
1241 case BFD_RELOC_PPC64_REL16_HIGH
: r
= R_PPC64_REL16_HIGH
;
1243 case BFD_RELOC_PPC64_REL16_HIGHA
: r
= R_PPC64_REL16_HIGHA
;
1245 case BFD_RELOC_PPC64_REL16_HIGHER
: r
= R_PPC64_REL16_HIGHER
;
1247 case BFD_RELOC_PPC64_REL16_HIGHERA
: r
= R_PPC64_REL16_HIGHERA
;
1249 case BFD_RELOC_PPC64_REL16_HIGHEST
: r
= R_PPC64_REL16_HIGHEST
;
1251 case BFD_RELOC_PPC64_REL16_HIGHESTA
: r
= R_PPC64_REL16_HIGHESTA
;
1253 case BFD_RELOC_PPC_16DX_HA
: r
= R_PPC64_16DX_HA
;
1255 case BFD_RELOC_PPC_REL16DX_HA
: r
= R_PPC64_REL16DX_HA
;
1257 case BFD_RELOC_PPC64_ENTRY
: r
= R_PPC64_ENTRY
;
1259 case BFD_RELOC_PPC64_ADDR64_LOCAL
: r
= R_PPC64_ADDR64_LOCAL
;
1261 case BFD_RELOC_PPC64_D34
: r
= R_PPC64_D34
;
1263 case BFD_RELOC_PPC64_D34_LO
: r
= R_PPC64_D34_LO
;
1265 case BFD_RELOC_PPC64_D34_HI30
: r
= R_PPC64_D34_HI30
;
1267 case BFD_RELOC_PPC64_D34_HA30
: r
= R_PPC64_D34_HA30
;
1269 case BFD_RELOC_PPC64_PCREL34
: r
= R_PPC64_PCREL34
;
1271 case BFD_RELOC_PPC64_GOT_PCREL34
: r
= R_PPC64_GOT_PCREL34
;
1273 case BFD_RELOC_PPC64_PLT_PCREL34
: r
= R_PPC64_PLT_PCREL34
;
1275 case BFD_RELOC_PPC64_TPREL34
: r
= R_PPC64_TPREL34
;
1277 case BFD_RELOC_PPC64_DTPREL34
: r
= R_PPC64_DTPREL34
;
1279 case BFD_RELOC_PPC64_GOT_TLSGD34
: r
= R_PPC64_GOT_TLSGD34
;
1281 case BFD_RELOC_PPC64_GOT_TLSLD34
: r
= R_PPC64_GOT_TLSLD34
;
1283 case BFD_RELOC_PPC64_GOT_TPREL34
: r
= R_PPC64_GOT_TPREL34
;
1285 case BFD_RELOC_PPC64_GOT_DTPREL34
: r
= R_PPC64_GOT_DTPREL34
;
1287 case BFD_RELOC_PPC64_ADDR16_HIGHER34
: r
= R_PPC64_ADDR16_HIGHER34
;
1289 case BFD_RELOC_PPC64_ADDR16_HIGHERA34
: r
= R_PPC64_ADDR16_HIGHERA34
;
1291 case BFD_RELOC_PPC64_ADDR16_HIGHEST34
: r
= R_PPC64_ADDR16_HIGHEST34
;
1293 case BFD_RELOC_PPC64_ADDR16_HIGHESTA34
: r
= R_PPC64_ADDR16_HIGHESTA34
;
1295 case BFD_RELOC_PPC64_REL16_HIGHER34
: r
= R_PPC64_REL16_HIGHER34
;
1297 case BFD_RELOC_PPC64_REL16_HIGHERA34
: r
= R_PPC64_REL16_HIGHERA34
;
1299 case BFD_RELOC_PPC64_REL16_HIGHEST34
: r
= R_PPC64_REL16_HIGHEST34
;
1301 case BFD_RELOC_PPC64_REL16_HIGHESTA34
: r
= R_PPC64_REL16_HIGHESTA34
;
1303 case BFD_RELOC_PPC64_D28
: r
= R_PPC64_D28
;
1305 case BFD_RELOC_PPC64_PCREL28
: r
= R_PPC64_PCREL28
;
1307 case BFD_RELOC_VTABLE_INHERIT
: r
= R_PPC64_GNU_VTINHERIT
;
1309 case BFD_RELOC_VTABLE_ENTRY
: r
= R_PPC64_GNU_VTENTRY
;
1313 return ppc64_elf_howto_table
[r
];
1316 static reloc_howto_type
*
1317 ppc64_elf_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
1322 for (i
= 0; i
< ARRAY_SIZE (ppc64_elf_howto_raw
); i
++)
1323 if (ppc64_elf_howto_raw
[i
].name
!= NULL
1324 && strcasecmp (ppc64_elf_howto_raw
[i
].name
, r_name
) == 0)
1325 return &ppc64_elf_howto_raw
[i
];
1330 /* Set the howto pointer for a PowerPC ELF reloc. */
1333 ppc64_elf_info_to_howto (bfd
*abfd
, arelent
*cache_ptr
,
1334 Elf_Internal_Rela
*dst
)
1338 /* Initialize howto table if needed. */
1339 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
1342 type
= ELF64_R_TYPE (dst
->r_info
);
1343 if (type
>= ARRAY_SIZE (ppc64_elf_howto_table
))
1345 /* xgettext:c-format */
1346 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
1348 bfd_set_error (bfd_error_bad_value
);
1351 cache_ptr
->howto
= ppc64_elf_howto_table
[type
];
1352 if (cache_ptr
->howto
== NULL
|| cache_ptr
->howto
->name
== NULL
)
1354 /* xgettext:c-format */
1355 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
1357 bfd_set_error (bfd_error_bad_value
);
1364 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
1366 static bfd_reloc_status_type
1367 ppc64_elf_ha_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1368 void *data
, asection
*input_section
,
1369 bfd
*output_bfd
, char **error_message
)
1371 enum elf_ppc64_reloc_type r_type
;
1373 bfd_size_type octets
;
1376 /* If this is a relocatable link (output_bfd test tells us), just
1377 call the generic function. Any adjustment will be done at final
1379 if (output_bfd
!= NULL
)
1380 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1381 input_section
, output_bfd
, error_message
);
1383 /* Adjust the addend for sign extension of the low 16 (or 34) bits.
1384 We won't actually be using the low bits, so trashing them
1386 r_type
= reloc_entry
->howto
->type
;
1387 if (r_type
== R_PPC64_ADDR16_HIGHERA34
1388 || r_type
== R_PPC64_ADDR16_HIGHESTA34
1389 || r_type
== R_PPC64_REL16_HIGHERA34
1390 || r_type
== R_PPC64_REL16_HIGHESTA34
)
1391 reloc_entry
->addend
+= 1ULL << 33;
1393 reloc_entry
->addend
+= 1U << 15;
1394 if (r_type
!= R_PPC64_REL16DX_HA
)
1395 return bfd_reloc_continue
;
1398 if (!bfd_is_com_section (symbol
->section
))
1399 value
= symbol
->value
;
1400 value
+= (reloc_entry
->addend
1401 + symbol
->section
->output_offset
1402 + symbol
->section
->output_section
->vma
);
1403 value
-= (reloc_entry
->address
1404 + input_section
->output_offset
1405 + input_section
->output_section
->vma
);
1406 value
= (bfd_signed_vma
) value
>> 16;
1408 octets
= reloc_entry
->address
* bfd_octets_per_byte (abfd
);
1409 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ octets
);
1411 insn
|= (value
& 0xffc1) | ((value
& 0x3e) << 15);
1412 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ octets
);
1413 if (value
+ 0x8000 > 0xffff)
1414 return bfd_reloc_overflow
;
1415 return bfd_reloc_ok
;
1418 static bfd_reloc_status_type
1419 ppc64_elf_branch_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1420 void *data
, asection
*input_section
,
1421 bfd
*output_bfd
, char **error_message
)
1423 if (output_bfd
!= NULL
)
1424 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1425 input_section
, output_bfd
, error_message
);
1427 if (strcmp (symbol
->section
->name
, ".opd") == 0
1428 && (symbol
->section
->owner
->flags
& DYNAMIC
) == 0)
1430 bfd_vma dest
= opd_entry_value (symbol
->section
,
1431 symbol
->value
+ reloc_entry
->addend
,
1433 if (dest
!= (bfd_vma
) -1)
1434 reloc_entry
->addend
= dest
- (symbol
->value
1435 + symbol
->section
->output_section
->vma
1436 + symbol
->section
->output_offset
);
1440 elf_symbol_type
*elfsym
= (elf_symbol_type
*) symbol
;
1442 if (symbol
->section
->owner
!= abfd
1443 && symbol
->section
->owner
!= NULL
1444 && abiversion (symbol
->section
->owner
) >= 2)
1448 for (i
= 0; i
< symbol
->section
->owner
->symcount
; ++i
)
1450 asymbol
*symdef
= symbol
->section
->owner
->outsymbols
[i
];
1452 if (strcmp (symdef
->name
, symbol
->name
) == 0)
1454 elfsym
= (elf_symbol_type
*) symdef
;
1460 += PPC64_LOCAL_ENTRY_OFFSET (elfsym
->internal_elf_sym
.st_other
);
1462 return bfd_reloc_continue
;
1465 static bfd_reloc_status_type
1466 ppc64_elf_brtaken_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1467 void *data
, asection
*input_section
,
1468 bfd
*output_bfd
, char **error_message
)
1471 enum elf_ppc64_reloc_type r_type
;
1472 bfd_size_type octets
;
1473 /* Assume 'at' branch hints. */
1474 bfd_boolean is_isa_v2
= TRUE
;
1476 /* If this is a relocatable link (output_bfd test tells us), just
1477 call the generic function. Any adjustment will be done at final
1479 if (output_bfd
!= NULL
)
1480 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1481 input_section
, output_bfd
, error_message
);
1483 octets
= reloc_entry
->address
* bfd_octets_per_byte (abfd
);
1484 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ octets
);
1485 insn
&= ~(0x01 << 21);
1486 r_type
= reloc_entry
->howto
->type
;
1487 if (r_type
== R_PPC64_ADDR14_BRTAKEN
1488 || r_type
== R_PPC64_REL14_BRTAKEN
)
1489 insn
|= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
1493 /* Set 'a' bit. This is 0b00010 in BO field for branch
1494 on CR(BI) insns (BO == 001at or 011at), and 0b01000
1495 for branch on CTR insns (BO == 1a00t or 1a01t). */
1496 if ((insn
& (0x14 << 21)) == (0x04 << 21))
1498 else if ((insn
& (0x14 << 21)) == (0x10 << 21))
1508 if (!bfd_is_com_section (symbol
->section
))
1509 target
= symbol
->value
;
1510 target
+= symbol
->section
->output_section
->vma
;
1511 target
+= symbol
->section
->output_offset
;
1512 target
+= reloc_entry
->addend
;
1514 from
= (reloc_entry
->address
1515 + input_section
->output_offset
1516 + input_section
->output_section
->vma
);
1518 /* Invert 'y' bit if not the default. */
1519 if ((bfd_signed_vma
) (target
- from
) < 0)
1522 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ octets
);
1524 return ppc64_elf_branch_reloc (abfd
, reloc_entry
, symbol
, data
,
1525 input_section
, output_bfd
, error_message
);
1528 static bfd_reloc_status_type
1529 ppc64_elf_sectoff_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1530 void *data
, asection
*input_section
,
1531 bfd
*output_bfd
, char **error_message
)
1533 /* If this is a relocatable link (output_bfd test tells us), just
1534 call the generic function. Any adjustment will be done at final
1536 if (output_bfd
!= NULL
)
1537 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1538 input_section
, output_bfd
, error_message
);
1540 /* Subtract the symbol section base address. */
1541 reloc_entry
->addend
-= symbol
->section
->output_section
->vma
;
1542 return bfd_reloc_continue
;
1545 static bfd_reloc_status_type
1546 ppc64_elf_sectoff_ha_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1547 void *data
, asection
*input_section
,
1548 bfd
*output_bfd
, char **error_message
)
1550 /* If this is a relocatable link (output_bfd test tells us), just
1551 call the generic function. Any adjustment will be done at final
1553 if (output_bfd
!= NULL
)
1554 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1555 input_section
, output_bfd
, error_message
);
1557 /* Subtract the symbol section base address. */
1558 reloc_entry
->addend
-= symbol
->section
->output_section
->vma
;
1560 /* Adjust the addend for sign extension of the low 16 bits. */
1561 reloc_entry
->addend
+= 0x8000;
1562 return bfd_reloc_continue
;
1565 static bfd_reloc_status_type
1566 ppc64_elf_toc_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1567 void *data
, asection
*input_section
,
1568 bfd
*output_bfd
, char **error_message
)
1572 /* If this is a relocatable link (output_bfd test tells us), just
1573 call the generic function. Any adjustment will be done at final
1575 if (output_bfd
!= NULL
)
1576 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1577 input_section
, output_bfd
, error_message
);
1579 TOCstart
= _bfd_get_gp_value (input_section
->output_section
->owner
);
1581 TOCstart
= ppc64_elf_set_toc (NULL
, input_section
->output_section
->owner
);
1583 /* Subtract the TOC base address. */
1584 reloc_entry
->addend
-= TOCstart
+ TOC_BASE_OFF
;
1585 return bfd_reloc_continue
;
1588 static bfd_reloc_status_type
1589 ppc64_elf_toc_ha_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1590 void *data
, asection
*input_section
,
1591 bfd
*output_bfd
, char **error_message
)
1595 /* If this is a relocatable link (output_bfd test tells us), just
1596 call the generic function. Any adjustment will be done at final
1598 if (output_bfd
!= NULL
)
1599 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1600 input_section
, output_bfd
, error_message
);
1602 TOCstart
= _bfd_get_gp_value (input_section
->output_section
->owner
);
1604 TOCstart
= ppc64_elf_set_toc (NULL
, input_section
->output_section
->owner
);
1606 /* Subtract the TOC base address. */
1607 reloc_entry
->addend
-= TOCstart
+ TOC_BASE_OFF
;
1609 /* Adjust the addend for sign extension of the low 16 bits. */
1610 reloc_entry
->addend
+= 0x8000;
1611 return bfd_reloc_continue
;
1614 static bfd_reloc_status_type
1615 ppc64_elf_toc64_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1616 void *data
, asection
*input_section
,
1617 bfd
*output_bfd
, char **error_message
)
1620 bfd_size_type octets
;
1622 /* If this is a relocatable link (output_bfd test tells us), just
1623 call the generic function. Any adjustment will be done at final
1625 if (output_bfd
!= NULL
)
1626 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1627 input_section
, output_bfd
, error_message
);
1629 TOCstart
= _bfd_get_gp_value (input_section
->output_section
->owner
);
1631 TOCstart
= ppc64_elf_set_toc (NULL
, input_section
->output_section
->owner
);
1633 octets
= reloc_entry
->address
* bfd_octets_per_byte (abfd
);
1634 bfd_put_64 (abfd
, TOCstart
+ TOC_BASE_OFF
, (bfd_byte
*) data
+ octets
);
1635 return bfd_reloc_ok
;
1638 static bfd_reloc_status_type
1639 ppc64_elf_prefix_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1640 void *data
, asection
*input_section
,
1641 bfd
*output_bfd
, char **error_message
)
1646 if (output_bfd
!= NULL
)
1647 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1648 input_section
, output_bfd
, error_message
);
1650 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1652 insn
|= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
+ 4);
1654 targ
= (symbol
->section
->output_section
->vma
1655 + symbol
->section
->output_offset
1656 + reloc_entry
->addend
);
1657 if (!bfd_is_com_section (symbol
->section
))
1658 targ
+= symbol
->value
;
1659 if (reloc_entry
->howto
->type
== R_PPC64_D34_HA30
)
1661 if (reloc_entry
->howto
->pc_relative
)
1663 bfd_vma from
= (reloc_entry
->address
1664 + input_section
->output_offset
1665 + input_section
->output_section
->vma
);
1668 targ
>>= reloc_entry
->howto
->rightshift
;
1669 insn
&= ~reloc_entry
->howto
->dst_mask
;
1670 insn
|= ((targ
<< 16) | (targ
& 0xffff)) & reloc_entry
->howto
->dst_mask
;
1671 bfd_put_32 (abfd
, insn
>> 32, (bfd_byte
*) data
+ reloc_entry
->address
);
1672 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ reloc_entry
->address
+ 4);
1673 if (reloc_entry
->howto
->complain_on_overflow
== complain_overflow_signed
1674 && (targ
+ (1ULL << (reloc_entry
->howto
->bitsize
- 1))
1675 >= 1ULL << reloc_entry
->howto
->bitsize
))
1676 return bfd_reloc_overflow
;
1677 return bfd_reloc_ok
;
1680 static bfd_reloc_status_type
1681 ppc64_elf_unhandled_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1682 void *data
, asection
*input_section
,
1683 bfd
*output_bfd
, char **error_message
)
1685 /* If this is a relocatable link (output_bfd test tells us), just
1686 call the generic function. Any adjustment will be done at final
1688 if (output_bfd
!= NULL
)
1689 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1690 input_section
, output_bfd
, error_message
);
1692 if (error_message
!= NULL
)
1694 static char buf
[60];
1695 sprintf (buf
, "generic linker can't handle %s",
1696 reloc_entry
->howto
->name
);
1697 *error_message
= buf
;
1699 return bfd_reloc_dangerous
;
1702 /* Track GOT entries needed for a given symbol. We might need more
1703 than one got entry per symbol. */
1706 struct got_entry
*next
;
1708 /* The symbol addend that we'll be placing in the GOT. */
1711 /* Unlike other ELF targets, we use separate GOT entries for the same
1712 symbol referenced from different input files. This is to support
1713 automatic multiple TOC/GOT sections, where the TOC base can vary
1714 from one input file to another. After partitioning into TOC groups
1715 we merge entries within the group.
1717 Point to the BFD owning this GOT entry. */
1720 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
1721 TLS_TPREL or TLS_DTPREL for tls entries. */
1722 unsigned char tls_type
;
1724 /* Non-zero if got.ent points to real entry. */
1725 unsigned char is_indirect
;
1727 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
1730 bfd_signed_vma refcount
;
1732 struct got_entry
*ent
;
1736 /* The same for PLT. */
1739 struct plt_entry
*next
;
1745 bfd_signed_vma refcount
;
1750 struct ppc64_elf_obj_tdata
1752 struct elf_obj_tdata elf
;
1754 /* Shortcuts to dynamic linker sections. */
1758 /* Used during garbage collection. We attach global symbols defined
1759 on removed .opd entries to this section so that the sym is removed. */
1760 asection
*deleted_section
;
1762 /* TLS local dynamic got entry handling. Support for multiple GOT
1763 sections means we potentially need one of these for each input bfd. */
1764 struct got_entry tlsld_got
;
1768 /* A copy of relocs before they are modified for --emit-relocs. */
1769 Elf_Internal_Rela
*relocs
;
1771 /* Section contents. */
1775 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
1776 the reloc to be in the range -32768 to 32767. */
1777 unsigned int has_small_toc_reloc
: 1;
1779 /* Set if toc/got ha relocs detected not using r2, or lo reloc
1780 instruction not one we handle. */
1781 unsigned int unexpected_toc_insn
: 1;
1783 /* Set if PLT/GOT/TOC relocs that can be optimised are present in
1785 unsigned int has_optrel
: 1;
1788 #define ppc64_elf_tdata(bfd) \
1789 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
1791 #define ppc64_tlsld_got(bfd) \
1792 (&ppc64_elf_tdata (bfd)->tlsld_got)
1794 #define is_ppc64_elf(bfd) \
1795 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
1796 && elf_object_id (bfd) == PPC64_ELF_DATA)
1798 /* Override the generic function because we store some extras. */
1801 ppc64_elf_mkobject (bfd
*abfd
)
1803 return bfd_elf_allocate_object (abfd
, sizeof (struct ppc64_elf_obj_tdata
),
1807 /* Fix bad default arch selected for a 64 bit input bfd when the
1808 default is 32 bit. Also select arch based on apuinfo. */
1811 ppc64_elf_object_p (bfd
*abfd
)
1813 if (!abfd
->arch_info
->the_default
)
1816 if (abfd
->arch_info
->bits_per_word
== 32)
1818 Elf_Internal_Ehdr
*i_ehdr
= elf_elfheader (abfd
);
1820 if (i_ehdr
->e_ident
[EI_CLASS
] == ELFCLASS64
)
1822 /* Relies on arch after 32 bit default being 64 bit default. */
1823 abfd
->arch_info
= abfd
->arch_info
->next
;
1824 BFD_ASSERT (abfd
->arch_info
->bits_per_word
== 64);
1827 return _bfd_elf_ppc_set_arch (abfd
);
1830 /* Support for core dump NOTE sections. */
1833 ppc64_elf_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
1835 size_t offset
, size
;
1837 if (note
->descsz
!= 504)
1841 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
1844 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 32);
1850 /* Make a ".reg/999" section. */
1851 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
1852 size
, note
->descpos
+ offset
);
1856 ppc64_elf_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
1858 if (note
->descsz
!= 136)
1861 elf_tdata (abfd
)->core
->pid
1862 = bfd_get_32 (abfd
, note
->descdata
+ 24);
1863 elf_tdata (abfd
)->core
->program
1864 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 40, 16);
1865 elf_tdata (abfd
)->core
->command
1866 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 56, 80);
1872 ppc64_elf_write_core_note (bfd
*abfd
, char *buf
, int *bufsiz
, int note_type
,
1882 char data
[136] ATTRIBUTE_NONSTRING
;
1885 va_start (ap
, note_type
);
1886 memset (data
, 0, sizeof (data
));
1887 strncpy (data
+ 40, va_arg (ap
, const char *), 16);
1888 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
1890 /* GCC 8.0 and 8.1 warn about 80 equals destination size with
1891 -Wstringop-truncation:
1892 https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85643
1894 DIAGNOSTIC_IGNORE_STRINGOP_TRUNCATION
;
1896 strncpy (data
+ 56, va_arg (ap
, const char *), 80);
1897 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
1901 return elfcore_write_note (abfd
, buf
, bufsiz
,
1902 "CORE", note_type
, data
, sizeof (data
));
1913 va_start (ap
, note_type
);
1914 memset (data
, 0, 112);
1915 pid
= va_arg (ap
, long);
1916 bfd_put_32 (abfd
, pid
, data
+ 32);
1917 cursig
= va_arg (ap
, int);
1918 bfd_put_16 (abfd
, cursig
, data
+ 12);
1919 greg
= va_arg (ap
, const void *);
1920 memcpy (data
+ 112, greg
, 384);
1921 memset (data
+ 496, 0, 8);
1923 return elfcore_write_note (abfd
, buf
, bufsiz
,
1924 "CORE", note_type
, data
, sizeof (data
));
1929 /* Add extra PPC sections. */
1931 static const struct bfd_elf_special_section ppc64_elf_special_sections
[] =
1933 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS
, 0 },
1934 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
1935 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
1936 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
1937 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
1938 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
1939 { NULL
, 0, 0, 0, 0 }
1942 enum _ppc64_sec_type
{
1948 struct _ppc64_elf_section_data
1950 struct bfd_elf_section_data elf
;
1954 /* An array with one entry for each opd function descriptor,
1955 and some spares since opd entries may be either 16 or 24 bytes. */
1956 #define OPD_NDX(OFF) ((OFF) >> 4)
1957 struct _opd_sec_data
1959 /* Points to the function code section for local opd entries. */
1960 asection
**func_sec
;
1962 /* After editing .opd, adjust references to opd local syms. */
1966 /* An array for toc sections, indexed by offset/8. */
1967 struct _toc_sec_data
1969 /* Specifies the relocation symbol index used at a given toc offset. */
1972 /* And the relocation addend. */
1977 enum _ppc64_sec_type sec_type
:2;
1979 /* Flag set when small branches are detected. Used to
1980 select suitable defaults for the stub group size. */
1981 unsigned int has_14bit_branch
:1;
1983 /* Flag set when PLTCALL relocs are detected. */
1984 unsigned int has_pltcall
:1;
1986 /* Flag set when section has PLT/GOT/TOC relocations that can be
1988 unsigned int has_optrel
:1;
1991 #define ppc64_elf_section_data(sec) \
1992 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
1995 ppc64_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
1997 if (!sec
->used_by_bfd
)
1999 struct _ppc64_elf_section_data
*sdata
;
2000 bfd_size_type amt
= sizeof (*sdata
);
2002 sdata
= bfd_zalloc (abfd
, amt
);
2005 sec
->used_by_bfd
= sdata
;
2008 return _bfd_elf_new_section_hook (abfd
, sec
);
2011 static struct _opd_sec_data
*
2012 get_opd_info (asection
* sec
)
2015 && ppc64_elf_section_data (sec
) != NULL
2016 && ppc64_elf_section_data (sec
)->sec_type
== sec_opd
)
2017 return &ppc64_elf_section_data (sec
)->u
.opd
;
2021 /* Parameters for the qsort hook. */
2022 static bfd_boolean synthetic_relocatable
;
2023 static asection
*synthetic_opd
;
2025 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
2028 compare_symbols (const void *ap
, const void *bp
)
2030 const asymbol
*a
= *(const asymbol
**) ap
;
2031 const asymbol
*b
= *(const asymbol
**) bp
;
2033 /* Section symbols first. */
2034 if ((a
->flags
& BSF_SECTION_SYM
) && !(b
->flags
& BSF_SECTION_SYM
))
2036 if (!(a
->flags
& BSF_SECTION_SYM
) && (b
->flags
& BSF_SECTION_SYM
))
2039 /* then .opd symbols. */
2040 if (synthetic_opd
!= NULL
)
2042 if (strcmp (a
->section
->name
, ".opd") == 0
2043 && strcmp (b
->section
->name
, ".opd") != 0)
2045 if (strcmp (a
->section
->name
, ".opd") != 0
2046 && strcmp (b
->section
->name
, ".opd") == 0)
2050 /* then other code symbols. */
2051 if (((a
->section
->flags
& (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
))
2052 == (SEC_CODE
| SEC_ALLOC
))
2053 && ((b
->section
->flags
& (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
))
2054 != (SEC_CODE
| SEC_ALLOC
)))
2057 if (((a
->section
->flags
& (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
))
2058 != (SEC_CODE
| SEC_ALLOC
))
2059 && ((b
->section
->flags
& (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
))
2060 == (SEC_CODE
| SEC_ALLOC
)))
2063 if (synthetic_relocatable
)
2065 if (a
->section
->id
< b
->section
->id
)
2068 if (a
->section
->id
> b
->section
->id
)
2072 if (a
->value
+ a
->section
->vma
< b
->value
+ b
->section
->vma
)
2075 if (a
->value
+ a
->section
->vma
> b
->value
+ b
->section
->vma
)
2078 /* For syms with the same value, prefer strong dynamic global function
2079 syms over other syms. */
2080 if ((a
->flags
& BSF_GLOBAL
) != 0 && (b
->flags
& BSF_GLOBAL
) == 0)
2083 if ((a
->flags
& BSF_GLOBAL
) == 0 && (b
->flags
& BSF_GLOBAL
) != 0)
2086 if ((a
->flags
& BSF_FUNCTION
) != 0 && (b
->flags
& BSF_FUNCTION
) == 0)
2089 if ((a
->flags
& BSF_FUNCTION
) == 0 && (b
->flags
& BSF_FUNCTION
) != 0)
2092 if ((a
->flags
& BSF_WEAK
) == 0 && (b
->flags
& BSF_WEAK
) != 0)
2095 if ((a
->flags
& BSF_WEAK
) != 0 && (b
->flags
& BSF_WEAK
) == 0)
2098 if ((a
->flags
& BSF_DYNAMIC
) != 0 && (b
->flags
& BSF_DYNAMIC
) == 0)
2101 if ((a
->flags
& BSF_DYNAMIC
) == 0 && (b
->flags
& BSF_DYNAMIC
) != 0)
2107 /* Search SYMS for a symbol of the given VALUE. */
2110 sym_exists_at (asymbol
**syms
, long lo
, long hi
, unsigned int id
, bfd_vma value
)
2114 if (id
== (unsigned) -1)
2118 mid
= (lo
+ hi
) >> 1;
2119 if (syms
[mid
]->value
+ syms
[mid
]->section
->vma
< value
)
2121 else if (syms
[mid
]->value
+ syms
[mid
]->section
->vma
> value
)
2131 mid
= (lo
+ hi
) >> 1;
2132 if (syms
[mid
]->section
->id
< id
)
2134 else if (syms
[mid
]->section
->id
> id
)
2136 else if (syms
[mid
]->value
< value
)
2138 else if (syms
[mid
]->value
> value
)
2148 section_covers_vma (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*section
, void *ptr
)
2150 bfd_vma vma
= *(bfd_vma
*) ptr
;
2151 return ((section
->flags
& SEC_ALLOC
) != 0
2152 && section
->vma
<= vma
2153 && vma
< section
->vma
+ section
->size
);
2156 /* Create synthetic symbols, effectively restoring "dot-symbol" function
2157 entry syms. Also generate @plt symbols for the glink branch table.
2158 Returns count of synthetic symbols in RET or -1 on error. */
2161 ppc64_elf_get_synthetic_symtab (bfd
*abfd
,
2162 long static_count
, asymbol
**static_syms
,
2163 long dyn_count
, asymbol
**dyn_syms
,
2169 size_t symcount
, codesecsym
, codesecsymend
, secsymend
, opdsymend
;
2170 asection
*opd
= NULL
;
2171 bfd_boolean relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2173 int abi
= abiversion (abfd
);
2179 opd
= bfd_get_section_by_name (abfd
, ".opd");
2180 if (opd
== NULL
&& abi
== 1)
2192 symcount
= static_count
;
2194 symcount
+= dyn_count
;
2198 syms
= bfd_malloc ((symcount
+ 1) * sizeof (*syms
));
2202 if (!relocatable
&& static_count
!= 0 && dyn_count
!= 0)
2204 /* Use both symbol tables. */
2205 memcpy (syms
, static_syms
, static_count
* sizeof (*syms
));
2206 memcpy (syms
+ static_count
, dyn_syms
,
2207 (dyn_count
+ 1) * sizeof (*syms
));
2209 else if (!relocatable
&& static_count
== 0)
2210 memcpy (syms
, dyn_syms
, (symcount
+ 1) * sizeof (*syms
));
2212 memcpy (syms
, static_syms
, (symcount
+ 1) * sizeof (*syms
));
2214 /* Trim uninteresting symbols. Interesting symbols are section,
2215 function, and notype symbols. */
2216 for (i
= 0, j
= 0; i
< symcount
; ++i
)
2217 if ((syms
[i
]->flags
& (BSF_FILE
| BSF_OBJECT
| BSF_THREAD_LOCAL
2218 | BSF_RELC
| BSF_SRELC
)) == 0)
2219 syms
[j
++] = syms
[i
];
2222 synthetic_relocatable
= relocatable
;
2223 synthetic_opd
= opd
;
2224 qsort (syms
, symcount
, sizeof (*syms
), compare_symbols
);
2226 if (!relocatable
&& symcount
> 1)
2228 /* Trim duplicate syms, since we may have merged the normal
2229 and dynamic symbols. Actually, we only care about syms
2230 that have different values, so trim any with the same
2231 value. Don't consider ifunc and ifunc resolver symbols
2232 duplicates however, because GDB wants to know whether a
2233 text symbol is an ifunc resolver. */
2234 for (i
= 1, j
= 1; i
< symcount
; ++i
)
2236 const asymbol
*s0
= syms
[i
- 1];
2237 const asymbol
*s1
= syms
[i
];
2239 if ((s0
->value
+ s0
->section
->vma
2240 != s1
->value
+ s1
->section
->vma
)
2241 || ((s0
->flags
& BSF_GNU_INDIRECT_FUNCTION
)
2242 != (s1
->flags
& BSF_GNU_INDIRECT_FUNCTION
)))
2243 syms
[j
++] = syms
[i
];
2249 /* Note that here and in compare_symbols we can't compare opd and
2250 sym->section directly. With separate debug info files, the
2251 symbols will be extracted from the debug file while abfd passed
2252 to this function is the real binary. */
2253 if (strcmp (syms
[i
]->section
->name
, ".opd") == 0)
2257 for (; i
< symcount
; ++i
)
2258 if (((syms
[i
]->section
->flags
& (SEC_CODE
| SEC_ALLOC
2259 | SEC_THREAD_LOCAL
))
2260 != (SEC_CODE
| SEC_ALLOC
))
2261 || (syms
[i
]->flags
& BSF_SECTION_SYM
) == 0)
2265 for (; i
< symcount
; ++i
)
2266 if ((syms
[i
]->flags
& BSF_SECTION_SYM
) == 0)
2270 for (; i
< symcount
; ++i
)
2271 if (strcmp (syms
[i
]->section
->name
, ".opd") != 0)
2275 for (; i
< symcount
; ++i
)
2276 if (((syms
[i
]->section
->flags
2277 & (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
)))
2278 != (SEC_CODE
| SEC_ALLOC
))
2286 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
2291 if (opdsymend
== secsymend
)
2294 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
2295 relcount
= (opd
->flags
& SEC_RELOC
) ? opd
->reloc_count
: 0;
2299 if (!(*slurp_relocs
) (abfd
, opd
, static_syms
, FALSE
))
2306 for (i
= secsymend
, r
= opd
->relocation
; i
< opdsymend
; ++i
)
2310 while (r
< opd
->relocation
+ relcount
2311 && r
->address
< syms
[i
]->value
+ opd
->vma
)
2314 if (r
== opd
->relocation
+ relcount
)
2317 if (r
->address
!= syms
[i
]->value
+ opd
->vma
)
2320 if (r
->howto
->type
!= R_PPC64_ADDR64
)
2323 sym
= *r
->sym_ptr_ptr
;
2324 if (!sym_exists_at (syms
, opdsymend
, symcount
,
2325 sym
->section
->id
, sym
->value
+ r
->addend
))
2328 size
+= sizeof (asymbol
);
2329 size
+= strlen (syms
[i
]->name
) + 2;
2335 s
= *ret
= bfd_malloc (size
);
2342 names
= (char *) (s
+ count
);
2344 for (i
= secsymend
, r
= opd
->relocation
; i
< opdsymend
; ++i
)
2348 while (r
< opd
->relocation
+ relcount
2349 && r
->address
< syms
[i
]->value
+ opd
->vma
)
2352 if (r
== opd
->relocation
+ relcount
)
2355 if (r
->address
!= syms
[i
]->value
+ opd
->vma
)
2358 if (r
->howto
->type
!= R_PPC64_ADDR64
)
2361 sym
= *r
->sym_ptr_ptr
;
2362 if (!sym_exists_at (syms
, opdsymend
, symcount
,
2363 sym
->section
->id
, sym
->value
+ r
->addend
))
2368 s
->flags
|= BSF_SYNTHETIC
;
2369 s
->section
= sym
->section
;
2370 s
->value
= sym
->value
+ r
->addend
;
2373 len
= strlen (syms
[i
]->name
);
2374 memcpy (names
, syms
[i
]->name
, len
+ 1);
2376 /* Have udata.p point back to the original symbol this
2377 synthetic symbol was derived from. */
2378 s
->udata
.p
= syms
[i
];
2385 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
2386 bfd_byte
*contents
= NULL
;
2388 size_t plt_count
= 0;
2389 bfd_vma glink_vma
= 0, resolv_vma
= 0;
2390 asection
*dynamic
, *glink
= NULL
, *relplt
= NULL
;
2393 if (opd
!= NULL
&& !bfd_malloc_and_get_section (abfd
, opd
, &contents
))
2395 free_contents_and_exit_err
:
2397 free_contents_and_exit
:
2404 for (i
= secsymend
; i
< opdsymend
; ++i
)
2408 /* Ignore bogus symbols. */
2409 if (syms
[i
]->value
> opd
->size
- 8)
2412 ent
= bfd_get_64 (abfd
, contents
+ syms
[i
]->value
);
2413 if (!sym_exists_at (syms
, opdsymend
, symcount
, -1, ent
))
2416 size
+= sizeof (asymbol
);
2417 size
+= strlen (syms
[i
]->name
) + 2;
2421 /* Get start of .glink stubs from DT_PPC64_GLINK. */
2423 && (dynamic
= bfd_get_section_by_name (abfd
, ".dynamic")) != NULL
)
2425 bfd_byte
*dynbuf
, *extdyn
, *extdynend
;
2427 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
2429 if (!bfd_malloc_and_get_section (abfd
, dynamic
, &dynbuf
))
2430 goto free_contents_and_exit_err
;
2432 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
2433 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
2436 extdynend
= extdyn
+ dynamic
->size
;
2437 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
2439 Elf_Internal_Dyn dyn
;
2440 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
2442 if (dyn
.d_tag
== DT_NULL
)
2445 if (dyn
.d_tag
== DT_PPC64_GLINK
)
2447 /* The first glink stub starts at DT_PPC64_GLINK plus 32.
2448 See comment in ppc64_elf_finish_dynamic_sections. */
2449 glink_vma
= dyn
.d_un
.d_val
+ 8 * 4;
2450 /* The .glink section usually does not survive the final
2451 link; search for the section (usually .text) where the
2452 glink stubs now reside. */
2453 glink
= bfd_sections_find_if (abfd
, section_covers_vma
,
2464 /* Determine __glink trampoline by reading the relative branch
2465 from the first glink stub. */
2467 unsigned int off
= 0;
2469 while (bfd_get_section_contents (abfd
, glink
, buf
,
2470 glink_vma
+ off
- glink
->vma
, 4))
2472 unsigned int insn
= bfd_get_32 (abfd
, buf
);
2474 if ((insn
& ~0x3fffffc) == 0)
2477 = glink_vma
+ off
+ (insn
^ 0x2000000) - 0x2000000;
2486 size
+= sizeof (asymbol
) + sizeof ("__glink_PLTresolve");
2488 relplt
= bfd_get_section_by_name (abfd
, ".rela.plt");
2491 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
2492 if (!(*slurp_relocs
) (abfd
, relplt
, dyn_syms
, TRUE
))
2493 goto free_contents_and_exit_err
;
2495 plt_count
= relplt
->size
/ sizeof (Elf64_External_Rela
);
2496 size
+= plt_count
* sizeof (asymbol
);
2498 p
= relplt
->relocation
;
2499 for (i
= 0; i
< plt_count
; i
++, p
++)
2501 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
2503 size
+= sizeof ("+0x") - 1 + 16;
2509 goto free_contents_and_exit
;
2510 s
= *ret
= bfd_malloc (size
);
2512 goto free_contents_and_exit_err
;
2514 names
= (char *) (s
+ count
+ plt_count
+ (resolv_vma
!= 0));
2516 for (i
= secsymend
; i
< opdsymend
; ++i
)
2520 if (syms
[i
]->value
> opd
->size
- 8)
2523 ent
= bfd_get_64 (abfd
, contents
+ syms
[i
]->value
);
2524 if (!sym_exists_at (syms
, opdsymend
, symcount
, -1, ent
))
2528 asection
*sec
= abfd
->sections
;
2535 size_t mid
= (lo
+ hi
) >> 1;
2536 if (syms
[mid
]->section
->vma
< ent
)
2538 else if (syms
[mid
]->section
->vma
> ent
)
2542 sec
= syms
[mid
]->section
;
2547 if (lo
>= hi
&& lo
> codesecsym
)
2548 sec
= syms
[lo
- 1]->section
;
2550 for (; sec
!= NULL
; sec
= sec
->next
)
2554 /* SEC_LOAD may not be set if SEC is from a separate debug
2556 if ((sec
->flags
& SEC_ALLOC
) == 0)
2558 if ((sec
->flags
& SEC_CODE
) != 0)
2561 s
->flags
|= BSF_SYNTHETIC
;
2562 s
->value
= ent
- s
->section
->vma
;
2565 len
= strlen (syms
[i
]->name
);
2566 memcpy (names
, syms
[i
]->name
, len
+ 1);
2568 /* Have udata.p point back to the original symbol this
2569 synthetic symbol was derived from. */
2570 s
->udata
.p
= syms
[i
];
2576 if (glink
!= NULL
&& relplt
!= NULL
)
2580 /* Add a symbol for the main glink trampoline. */
2581 memset (s
, 0, sizeof *s
);
2583 s
->flags
= BSF_GLOBAL
| BSF_SYNTHETIC
;
2585 s
->value
= resolv_vma
- glink
->vma
;
2587 memcpy (names
, "__glink_PLTresolve",
2588 sizeof ("__glink_PLTresolve"));
2589 names
+= sizeof ("__glink_PLTresolve");
2594 /* FIXME: It would be very much nicer to put sym@plt on the
2595 stub rather than on the glink branch table entry. The
2596 objdump disassembler would then use a sensible symbol
2597 name on plt calls. The difficulty in doing so is
2598 a) finding the stubs, and,
2599 b) matching stubs against plt entries, and,
2600 c) there can be multiple stubs for a given plt entry.
2602 Solving (a) could be done by code scanning, but older
2603 ppc64 binaries used different stubs to current code.
2604 (b) is the tricky one since you need to known the toc
2605 pointer for at least one function that uses a pic stub to
2606 be able to calculate the plt address referenced.
2607 (c) means gdb would need to set multiple breakpoints (or
2608 find the glink branch itself) when setting breakpoints
2609 for pending shared library loads. */
2610 p
= relplt
->relocation
;
2611 for (i
= 0; i
< plt_count
; i
++, p
++)
2615 *s
= **p
->sym_ptr_ptr
;
2616 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
2617 we are defining a symbol, ensure one of them is set. */
2618 if ((s
->flags
& BSF_LOCAL
) == 0)
2619 s
->flags
|= BSF_GLOBAL
;
2620 s
->flags
|= BSF_SYNTHETIC
;
2622 s
->value
= glink_vma
- glink
->vma
;
2625 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
2626 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
2630 memcpy (names
, "+0x", sizeof ("+0x") - 1);
2631 names
+= sizeof ("+0x") - 1;
2632 bfd_sprintf_vma (abfd
, names
, p
->addend
);
2633 names
+= strlen (names
);
2635 memcpy (names
, "@plt", sizeof ("@plt"));
2636 names
+= sizeof ("@plt");
2656 /* The following functions are specific to the ELF linker, while
2657 functions above are used generally. Those named ppc64_elf_* are
2658 called by the main ELF linker code. They appear in this file more
2659 or less in the order in which they are called. eg.
2660 ppc64_elf_check_relocs is called early in the link process,
2661 ppc64_elf_finish_dynamic_sections is one of the last functions
2664 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
2665 functions have both a function code symbol and a function descriptor
2666 symbol. A call to foo in a relocatable object file looks like:
2673 The function definition in another object file might be:
2677 . .quad .TOC.@tocbase
2683 When the linker resolves the call during a static link, the branch
2684 unsurprisingly just goes to .foo and the .opd information is unused.
2685 If the function definition is in a shared library, things are a little
2686 different: The call goes via a plt call stub, the opd information gets
2687 copied to the plt, and the linker patches the nop.
2695 . std 2,40(1) # in practice, the call stub
2696 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
2697 . addi 11,11,Lfoo@toc@l # this is the general idea
2705 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
2707 The "reloc ()" notation is supposed to indicate that the linker emits
2708 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
2711 What are the difficulties here? Well, firstly, the relocations
2712 examined by the linker in check_relocs are against the function code
2713 sym .foo, while the dynamic relocation in the plt is emitted against
2714 the function descriptor symbol, foo. Somewhere along the line, we need
2715 to carefully copy dynamic link information from one symbol to the other.
2716 Secondly, the generic part of the elf linker will make .foo a dynamic
2717 symbol as is normal for most other backends. We need foo dynamic
2718 instead, at least for an application final link. However, when
2719 creating a shared library containing foo, we need to have both symbols
2720 dynamic so that references to .foo are satisfied during the early
2721 stages of linking. Otherwise the linker might decide to pull in a
2722 definition from some other object, eg. a static library.
2724 Update: As of August 2004, we support a new convention. Function
2725 calls may use the function descriptor symbol, ie. "bl foo". This
2726 behaves exactly as "bl .foo". */
2728 /* Of those relocs that might be copied as dynamic relocs, this
2729 function selects those that must be copied when linking a shared
2730 library or PIE, even when the symbol is local. */
2733 must_be_dyn_reloc (struct bfd_link_info
*info
,
2734 enum elf_ppc64_reloc_type r_type
)
2739 /* Only relative relocs can be resolved when the object load
2740 address isn't fixed. DTPREL64 is excluded because the
2741 dynamic linker needs to differentiate global dynamic from
2742 local dynamic __tls_index pairs when PPC64_OPT_TLS is set. */
2749 case R_PPC64_TOC16_DS
:
2750 case R_PPC64_TOC16_LO
:
2751 case R_PPC64_TOC16_HI
:
2752 case R_PPC64_TOC16_HA
:
2753 case R_PPC64_TOC16_LO_DS
:
2756 case R_PPC64_TPREL16
:
2757 case R_PPC64_TPREL16_LO
:
2758 case R_PPC64_TPREL16_HI
:
2759 case R_PPC64_TPREL16_HA
:
2760 case R_PPC64_TPREL16_DS
:
2761 case R_PPC64_TPREL16_LO_DS
:
2762 case R_PPC64_TPREL16_HIGH
:
2763 case R_PPC64_TPREL16_HIGHA
:
2764 case R_PPC64_TPREL16_HIGHER
:
2765 case R_PPC64_TPREL16_HIGHERA
:
2766 case R_PPC64_TPREL16_HIGHEST
:
2767 case R_PPC64_TPREL16_HIGHESTA
:
2768 case R_PPC64_TPREL64
:
2769 case R_PPC64_TPREL34
:
2770 /* These relocations are relative but in a shared library the
2771 linker doesn't know the thread pointer base. */
2772 return bfd_link_dll (info
);
2776 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
2777 copying dynamic variables from a shared lib into an app's dynbss
2778 section, and instead use a dynamic relocation to point into the
2779 shared lib. With code that gcc generates, it's vital that this be
2780 enabled; In the PowerPC64 ABI, the address of a function is actually
2781 the address of a function descriptor, which resides in the .opd
2782 section. gcc uses the descriptor directly rather than going via the
2783 GOT as some other ABI's do, which means that initialized function
2784 pointers must reference the descriptor. Thus, a function pointer
2785 initialized to the address of a function in a shared library will
2786 either require a copy reloc, or a dynamic reloc. Using a copy reloc
2787 redefines the function descriptor symbol to point to the copy. This
2788 presents a problem as a plt entry for that function is also
2789 initialized from the function descriptor symbol and the copy reloc
2790 may not be initialized first. */
2791 #define ELIMINATE_COPY_RELOCS 1
2793 /* Section name for stubs is the associated section name plus this
2795 #define STUB_SUFFIX ".stub"
2798 ppc_stub_long_branch:
2799 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
2800 destination, but a 24 bit branch in a stub section will reach.
2803 ppc_stub_plt_branch:
2804 Similar to the above, but a 24 bit branch in the stub section won't
2805 reach its destination.
2806 . addis %r11,%r2,xxx@toc@ha
2807 . ld %r12,xxx@toc@l(%r11)
2812 Used to call a function in a shared library. If it so happens that
2813 the plt entry referenced crosses a 64k boundary, then an extra
2814 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
2815 ppc_stub_plt_call_r2save starts with "std %r2,40(%r1)".
2816 . addis %r11,%r2,xxx@toc@ha
2817 . ld %r12,xxx+0@toc@l(%r11)
2819 . ld %r2,xxx+8@toc@l(%r11)
2820 . ld %r11,xxx+16@toc@l(%r11)
2823 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
2824 code to adjust the value and save r2 to support multiple toc sections.
2825 A ppc_stub_long_branch with an r2 offset looks like:
2827 . addis %r2,%r2,off@ha
2828 . addi %r2,%r2,off@l
2831 A ppc_stub_plt_branch with an r2 offset looks like:
2833 . addis %r11,%r2,xxx@toc@ha
2834 . ld %r12,xxx@toc@l(%r11)
2835 . addis %r2,%r2,off@ha
2836 . addi %r2,%r2,off@l
2840 All of the above stubs are shown as their ELFv1 variants. ELFv2
2841 variants exist too, simpler for plt calls since a new toc pointer
2842 and static chain are not loaded by the stub. In addition, ELFv2
2843 has some more complex stubs to handle calls marked with NOTOC
2844 relocs from functions where r2 is not a valid toc pointer. These
2845 come in two flavours, the ones shown below, and _both variants that
2846 start with "std %r2,24(%r1)" to save r2 in the unlikely event that
2847 one call is from a function where r2 is used as the toc pointer but
2848 needs a toc adjusting stub for small-model multi-toc, and another
2849 call is from a function where r2 is not valid.
2850 ppc_stub_long_branch_notoc:
2856 . addis %r12,%r11,dest-1b@ha
2857 . addi %r12,%r12,dest-1b@l
2860 ppc_stub_plt_branch_notoc:
2866 . lis %r12,xxx-1b@highest
2867 . ori %r12,%r12,xxx-1b@higher
2869 . oris %r12,%r12,xxx-1b@high
2870 . ori %r12,%r12,xxx-1b@l
2871 . add %r12,%r11,%r12
2875 ppc_stub_plt_call_notoc:
2881 . lis %r12,xxx-1b@highest
2882 . ori %r12,%r12,xxx-1b@higher
2884 . oris %r12,%r12,xxx-1b@high
2885 . ori %r12,%r12,xxx-1b@l
2886 . ldx %r12,%r11,%r12
2890 There are also ELFv1 powerxx variants of these stubs.
2891 ppc_stub_long_branch_notoc:
2892 . pla %r12,dest@pcrel
2894 ppc_stub_plt_branch_notoc:
2895 . lis %r11,(dest-1f)@highesta34
2896 . ori %r11,%r11,(dest-1f)@highera34
2898 . 1: pla %r12,dest@pcrel
2899 . add %r12,%r11,%r12
2902 ppc_stub_plt_call_notoc:
2903 . lis %r11,(xxx-1f)@highesta34
2904 . ori %r11,%r11,(xxx-1f)@highera34
2906 . 1: pla %r12,xxx@pcrel
2907 . ldx %r12,%r11,%r12
2911 In cases where the high instructions would add zero, they are
2912 omitted and following instructions modified in some cases.
2913 For example, a powerxx ppc_stub_plt_call_notoc might simplify down
2915 . pld %r12,xxx@pcrel
2919 For a given stub group (a set of sections all using the same toc
2920 pointer value) there will be just one stub type used for any
2921 particular function symbol. For example, if printf is called from
2922 code with the tocsave optimization (ie. r2 saved in function
2923 prologue) and therefore calls use a ppc_stub_plt_call linkage stub,
2924 and from other code without the tocsave optimization requiring a
2925 ppc_stub_plt_call_r2save linkage stub, a single stub of the latter
2926 type will be created. Calls with the tocsave optimization will
2927 enter this stub after the instruction saving r2. A similar
2928 situation exists when calls are marked with R_PPC64_REL24_NOTOC
2929 relocations. These require a ppc_stub_plt_call_notoc linkage stub
2930 to call an external function like printf. If other calls to printf
2931 require a ppc_stub_plt_call linkage stub then a single
2932 ppc_stub_plt_call_notoc linkage stub will be used for both types of
2933 call. If other calls to printf require a ppc_stub_plt_call_r2save
2934 linkage stub then a single ppc_stub_plt_call_both linkage stub will
2935 be created and calls not requiring r2 to be saved will enter the
2936 stub after the r2 save instruction. There is an analogous
2937 hierarchy of long branch and plt branch stubs for local call
2943 ppc_stub_long_branch
,
2944 ppc_stub_long_branch_r2off
,
2945 ppc_stub_long_branch_notoc
,
2946 ppc_stub_long_branch_both
, /* r2off and notoc variants both needed. */
2947 ppc_stub_plt_branch
,
2948 ppc_stub_plt_branch_r2off
,
2949 ppc_stub_plt_branch_notoc
,
2950 ppc_stub_plt_branch_both
,
2952 ppc_stub_plt_call_r2save
,
2953 ppc_stub_plt_call_notoc
,
2954 ppc_stub_plt_call_both
,
2955 ppc_stub_global_entry
,
2959 /* Information on stub grouping. */
2962 /* The stub section. */
2964 /* This is the section to which stubs in the group will be attached. */
2967 struct map_stub
*next
;
2968 /* Whether to emit a copy of register save/restore functions in this
2971 /* Current offset within stubs after the insn restoring lr in a
2972 _notoc or _both stub using bcl for pc-relative addressing, or
2973 after the insn restoring lr in a __tls_get_addr_opt plt stub. */
2974 unsigned int lr_restore
;
2975 /* Accumulated size of EH info emitted to describe return address
2976 if stubs modify lr. Does not include 17 byte FDE header. */
2977 unsigned int eh_size
;
2978 /* Offset in glink_eh_frame to the start of EH info for this group. */
2979 unsigned int eh_base
;
2982 struct ppc_stub_hash_entry
2984 /* Base hash table entry structure. */
2985 struct bfd_hash_entry root
;
2987 enum ppc_stub_type stub_type
;
2989 /* Group information. */
2990 struct map_stub
*group
;
2992 /* Offset within stub_sec of the beginning of this stub. */
2993 bfd_vma stub_offset
;
2995 /* Given the symbol's value and its section we can determine its final
2996 value when building the stubs (so the stub knows where to jump. */
2997 bfd_vma target_value
;
2998 asection
*target_section
;
3000 /* The symbol table entry, if any, that this was derived from. */
3001 struct ppc_link_hash_entry
*h
;
3002 struct plt_entry
*plt_ent
;
3005 unsigned char symtype
;
3007 /* Symbol st_other. */
3008 unsigned char other
;
3011 struct ppc_branch_hash_entry
3013 /* Base hash table entry structure. */
3014 struct bfd_hash_entry root
;
3016 /* Offset within branch lookup table. */
3017 unsigned int offset
;
3019 /* Generation marker. */
3023 /* Used to track dynamic relocations for local symbols. */
3024 struct ppc_dyn_relocs
3026 struct ppc_dyn_relocs
*next
;
3028 /* The input section of the reloc. */
3031 /* Total number of relocs copied for the input section. */
3032 unsigned int count
: 31;
3034 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3035 unsigned int ifunc
: 1;
3038 struct ppc_link_hash_entry
3040 struct elf_link_hash_entry elf
;
3044 /* A pointer to the most recently used stub hash entry against this
3046 struct ppc_stub_hash_entry
*stub_cache
;
3048 /* A pointer to the next symbol starting with a '.' */
3049 struct ppc_link_hash_entry
*next_dot_sym
;
3052 /* Track dynamic relocs copied for this symbol. */
3053 struct elf_dyn_relocs
*dyn_relocs
;
3055 /* Link between function code and descriptor symbols. */
3056 struct ppc_link_hash_entry
*oh
;
3058 /* Flag function code and descriptor symbols. */
3059 unsigned int is_func
:1;
3060 unsigned int is_func_descriptor
:1;
3061 unsigned int fake
:1;
3063 /* Whether global opd/toc sym has been adjusted or not.
3064 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3065 should be set for all globals defined in any opd/toc section. */
3066 unsigned int adjust_done
:1;
3068 /* Set if this is an out-of-line register save/restore function,
3069 with non-standard calling convention. */
3070 unsigned int save_res
:1;
3072 /* Set if a duplicate symbol with non-zero localentry is detected,
3073 even when the duplicate symbol does not provide a definition. */
3074 unsigned int non_zero_localentry
:1;
3076 /* Contexts in which symbol is used in the GOT (or TOC).
3077 Bits are or'd into the mask as the corresponding relocs are
3078 encountered during check_relocs, with TLS_TLS being set when any
3079 of the other TLS bits are set. tls_optimize clears bits when
3080 optimizing to indicate the corresponding GOT entry type is not
3081 needed. If set, TLS_TLS is never cleared. tls_optimize may also
3082 set TLS_GDIE when a GD reloc turns into an IE one.
3083 These flags are also kept for local symbols. */
3084 #define TLS_TLS 1 /* Any TLS reloc. */
3085 #define TLS_GD 2 /* GD reloc. */
3086 #define TLS_LD 4 /* LD reloc. */
3087 #define TLS_TPREL 8 /* TPREL reloc, => IE. */
3088 #define TLS_DTPREL 16 /* DTPREL reloc, => LD. */
3089 #define TLS_MARK 32 /* __tls_get_addr call marked. */
3090 #define TLS_GDIE 64 /* GOT TPREL reloc resulting from GD->IE. */
3091 #define TLS_EXPLICIT 256 /* TOC section TLS reloc, not stored. */
3092 unsigned char tls_mask
;
3094 /* The above field is also used to mark function symbols. In which
3095 case TLS_TLS will be 0. */
3096 #define PLT_IFUNC 2 /* STT_GNU_IFUNC. */
3097 #define PLT_KEEP 4 /* inline plt call requires plt entry. */
3098 #define NON_GOT 256 /* local symbol plt, not stored. */
3101 /* ppc64 ELF linker hash table. */
3103 struct ppc_link_hash_table
3105 struct elf_link_hash_table elf
;
3107 /* The stub hash table. */
3108 struct bfd_hash_table stub_hash_table
;
3110 /* Another hash table for plt_branch stubs. */
3111 struct bfd_hash_table branch_hash_table
;
3113 /* Hash table for function prologue tocsave. */
3114 htab_t tocsave_htab
;
3116 /* Various options and other info passed from the linker. */
3117 struct ppc64_elf_params
*params
;
3119 /* The size of sec_info below. */
3120 unsigned int sec_info_arr_size
;
3122 /* Per-section array of extra section info. Done this way rather
3123 than as part of ppc64_elf_section_data so we have the info for
3124 non-ppc64 sections. */
3127 /* Along with elf_gp, specifies the TOC pointer used by this section. */
3132 /* The section group that this section belongs to. */
3133 struct map_stub
*group
;
3134 /* A temp section list pointer. */
3139 /* Linked list of groups. */
3140 struct map_stub
*group
;
3142 /* Temp used when calculating TOC pointers. */
3145 asection
*toc_first_sec
;
3147 /* Used when adding symbols. */
3148 struct ppc_link_hash_entry
*dot_syms
;
3150 /* Shortcuts to get to dynamic linker sections. */
3152 asection
*global_entry
;
3155 asection
*relpltlocal
;
3158 asection
*glink_eh_frame
;
3160 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
3161 struct ppc_link_hash_entry
*tls_get_addr
;
3162 struct ppc_link_hash_entry
*tls_get_addr_fd
;
3164 /* The size of reliplt used by got entry relocs. */
3165 bfd_size_type got_reli_size
;
3168 unsigned long stub_count
[ppc_stub_global_entry
];
3170 /* Number of stubs against global syms. */
3171 unsigned long stub_globals
;
3173 /* Set if we're linking code with function descriptors. */
3174 unsigned int opd_abi
:1;
3176 /* Support for multiple toc sections. */
3177 unsigned int do_multi_toc
:1;
3178 unsigned int multi_toc_needed
:1;
3179 unsigned int second_toc_pass
:1;
3180 unsigned int do_toc_opt
:1;
3182 /* Set if tls optimization is enabled. */
3183 unsigned int do_tls_opt
:1;
3185 /* Set if inline plt calls should be converted to direct calls. */
3186 unsigned int can_convert_all_inline_plt
:1;
3189 unsigned int stub_error
:1;
3191 /* Whether func_desc_adjust needs to be run over symbols. */
3192 unsigned int need_func_desc_adj
:1;
3194 /* Whether there exist local gnu indirect function resolvers,
3195 referenced by dynamic relocations. */
3196 unsigned int local_ifunc_resolver
:1;
3197 unsigned int maybe_local_ifunc_resolver
:1;
3199 /* Whether plt calls for ELFv2 localentry:0 funcs have been optimized. */
3200 unsigned int has_plt_localentry0
:1;
3202 /* Whether calls are made via the PLT from NOTOC functions. */
3203 unsigned int notoc_plt
:1;
3205 /* Whether to use powerxx instructions in linkage stubs. */
3206 unsigned int powerxx_stubs
:1;
3208 /* Incremented every time we size stubs. */
3209 unsigned int stub_iteration
;
3211 /* Small local sym cache. */
3212 struct sym_cache sym_cache
;
3215 /* Rename some of the generic section flags to better document how they
3218 /* Nonzero if this section has TLS related relocations. */
3219 #define has_tls_reloc sec_flg0
3221 /* Nonzero if this section has an old-style call to __tls_get_addr. */
3222 #define has_tls_get_addr_call sec_flg1
3224 /* Nonzero if this section has any toc or got relocs. */
3225 #define has_toc_reloc sec_flg2
3227 /* Nonzero if this section has a call to another section that uses
3229 #define makes_toc_func_call sec_flg3
3231 /* Recursion protection when determining above flag. */
3232 #define call_check_in_progress sec_flg4
3233 #define call_check_done sec_flg5
3235 /* Get the ppc64 ELF linker hash table from a link_info structure. */
3237 #define ppc_hash_table(p) \
3238 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3239 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3241 #define ppc_stub_hash_lookup(table, string, create, copy) \
3242 ((struct ppc_stub_hash_entry *) \
3243 bfd_hash_lookup ((table), (string), (create), (copy)))
3245 #define ppc_branch_hash_lookup(table, string, create, copy) \
3246 ((struct ppc_branch_hash_entry *) \
3247 bfd_hash_lookup ((table), (string), (create), (copy)))
3249 /* Create an entry in the stub hash table. */
3251 static struct bfd_hash_entry
*
3252 stub_hash_newfunc (struct bfd_hash_entry
*entry
,
3253 struct bfd_hash_table
*table
,
3256 /* Allocate the structure if it has not already been allocated by a
3260 entry
= bfd_hash_allocate (table
, sizeof (struct ppc_stub_hash_entry
));
3265 /* Call the allocation method of the superclass. */
3266 entry
= bfd_hash_newfunc (entry
, table
, string
);
3269 struct ppc_stub_hash_entry
*eh
;
3271 /* Initialize the local fields. */
3272 eh
= (struct ppc_stub_hash_entry
*) entry
;
3273 eh
->stub_type
= ppc_stub_none
;
3275 eh
->stub_offset
= 0;
3276 eh
->target_value
= 0;
3277 eh
->target_section
= NULL
;
3286 /* Create an entry in the branch hash table. */
3288 static struct bfd_hash_entry
*
3289 branch_hash_newfunc (struct bfd_hash_entry
*entry
,
3290 struct bfd_hash_table
*table
,
3293 /* Allocate the structure if it has not already been allocated by a
3297 entry
= bfd_hash_allocate (table
, sizeof (struct ppc_branch_hash_entry
));
3302 /* Call the allocation method of the superclass. */
3303 entry
= bfd_hash_newfunc (entry
, table
, string
);
3306 struct ppc_branch_hash_entry
*eh
;
3308 /* Initialize the local fields. */
3309 eh
= (struct ppc_branch_hash_entry
*) entry
;
3317 /* Create an entry in a ppc64 ELF linker hash table. */
3319 static struct bfd_hash_entry
*
3320 link_hash_newfunc (struct bfd_hash_entry
*entry
,
3321 struct bfd_hash_table
*table
,
3324 /* Allocate the structure if it has not already been allocated by a
3328 entry
= bfd_hash_allocate (table
, sizeof (struct ppc_link_hash_entry
));
3333 /* Call the allocation method of the superclass. */
3334 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
3337 struct ppc_link_hash_entry
*eh
= (struct ppc_link_hash_entry
*) entry
;
3339 memset (&eh
->u
.stub_cache
, 0,
3340 (sizeof (struct ppc_link_hash_entry
)
3341 - offsetof (struct ppc_link_hash_entry
, u
.stub_cache
)));
3343 /* When making function calls, old ABI code references function entry
3344 points (dot symbols), while new ABI code references the function
3345 descriptor symbol. We need to make any combination of reference and
3346 definition work together, without breaking archive linking.
3348 For a defined function "foo" and an undefined call to "bar":
3349 An old object defines "foo" and ".foo", references ".bar" (possibly
3351 A new object defines "foo" and references "bar".
3353 A new object thus has no problem with its undefined symbols being
3354 satisfied by definitions in an old object. On the other hand, the
3355 old object won't have ".bar" satisfied by a new object.
3357 Keep a list of newly added dot-symbols. */
3359 if (string
[0] == '.')
3361 struct ppc_link_hash_table
*htab
;
3363 htab
= (struct ppc_link_hash_table
*) table
;
3364 eh
->u
.next_dot_sym
= htab
->dot_syms
;
3365 htab
->dot_syms
= eh
;
3372 struct tocsave_entry
3379 tocsave_htab_hash (const void *p
)
3381 const struct tocsave_entry
*e
= (const struct tocsave_entry
*) p
;
3382 return ((bfd_vma
) (intptr_t) e
->sec
^ e
->offset
) >> 3;
3386 tocsave_htab_eq (const void *p1
, const void *p2
)
3388 const struct tocsave_entry
*e1
= (const struct tocsave_entry
*) p1
;
3389 const struct tocsave_entry
*e2
= (const struct tocsave_entry
*) p2
;
3390 return e1
->sec
== e2
->sec
&& e1
->offset
== e2
->offset
;
3393 /* Destroy a ppc64 ELF linker hash table. */
3396 ppc64_elf_link_hash_table_free (bfd
*obfd
)
3398 struct ppc_link_hash_table
*htab
;
3400 htab
= (struct ppc_link_hash_table
*) obfd
->link
.hash
;
3401 if (htab
->tocsave_htab
)
3402 htab_delete (htab
->tocsave_htab
);
3403 bfd_hash_table_free (&htab
->branch_hash_table
);
3404 bfd_hash_table_free (&htab
->stub_hash_table
);
3405 _bfd_elf_link_hash_table_free (obfd
);
3408 /* Create a ppc64 ELF linker hash table. */
3410 static struct bfd_link_hash_table
*
3411 ppc64_elf_link_hash_table_create (bfd
*abfd
)
3413 struct ppc_link_hash_table
*htab
;
3414 bfd_size_type amt
= sizeof (struct ppc_link_hash_table
);
3416 htab
= bfd_zmalloc (amt
);
3420 if (!_bfd_elf_link_hash_table_init (&htab
->elf
, abfd
, link_hash_newfunc
,
3421 sizeof (struct ppc_link_hash_entry
),
3428 /* Init the stub hash table too. */
3429 if (!bfd_hash_table_init (&htab
->stub_hash_table
, stub_hash_newfunc
,
3430 sizeof (struct ppc_stub_hash_entry
)))
3432 _bfd_elf_link_hash_table_free (abfd
);
3436 /* And the branch hash table. */
3437 if (!bfd_hash_table_init (&htab
->branch_hash_table
, branch_hash_newfunc
,
3438 sizeof (struct ppc_branch_hash_entry
)))
3440 bfd_hash_table_free (&htab
->stub_hash_table
);
3441 _bfd_elf_link_hash_table_free (abfd
);
3445 htab
->tocsave_htab
= htab_try_create (1024,
3449 if (htab
->tocsave_htab
== NULL
)
3451 ppc64_elf_link_hash_table_free (abfd
);
3454 htab
->elf
.root
.hash_table_free
= ppc64_elf_link_hash_table_free
;
3456 /* Initializing two fields of the union is just cosmetic. We really
3457 only care about glist, but when compiled on a 32-bit host the
3458 bfd_vma fields are larger. Setting the bfd_vma to zero makes
3459 debugger inspection of these fields look nicer. */
3460 htab
->elf
.init_got_refcount
.refcount
= 0;
3461 htab
->elf
.init_got_refcount
.glist
= NULL
;
3462 htab
->elf
.init_plt_refcount
.refcount
= 0;
3463 htab
->elf
.init_plt_refcount
.glist
= NULL
;
3464 htab
->elf
.init_got_offset
.offset
= 0;
3465 htab
->elf
.init_got_offset
.glist
= NULL
;
3466 htab
->elf
.init_plt_offset
.offset
= 0;
3467 htab
->elf
.init_plt_offset
.glist
= NULL
;
3469 return &htab
->elf
.root
;
3472 /* Create sections for linker generated code. */
3475 create_linkage_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
3477 struct ppc_link_hash_table
*htab
;
3480 htab
= ppc_hash_table (info
);
3482 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_READONLY
3483 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3484 if (htab
->params
->save_restore_funcs
)
3486 /* Create .sfpr for code to save and restore fp regs. */
3487 htab
->sfpr
= bfd_make_section_anyway_with_flags (dynobj
, ".sfpr",
3489 if (htab
->sfpr
== NULL
3490 || !bfd_set_section_alignment (htab
->sfpr
, 2))
3494 if (bfd_link_relocatable (info
))
3497 /* Create .glink for lazy dynamic linking support. */
3498 htab
->glink
= bfd_make_section_anyway_with_flags (dynobj
, ".glink",
3500 if (htab
->glink
== NULL
3501 || !bfd_set_section_alignment (htab
->glink
, 3))
3504 /* The part of .glink used by global entry stubs, separate so that
3505 it can be aligned appropriately without affecting htab->glink. */
3506 htab
->global_entry
= bfd_make_section_anyway_with_flags (dynobj
, ".glink",
3508 if (htab
->global_entry
== NULL
3509 || !bfd_set_section_alignment (htab
->global_entry
, 2))
3512 if (!info
->no_ld_generated_unwind_info
)
3514 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_HAS_CONTENTS
3515 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3516 htab
->glink_eh_frame
= bfd_make_section_anyway_with_flags (dynobj
,
3519 if (htab
->glink_eh_frame
== NULL
3520 || !bfd_set_section_alignment (htab
->glink_eh_frame
, 2))
3524 flags
= SEC_ALLOC
| SEC_LINKER_CREATED
;
3525 htab
->elf
.iplt
= bfd_make_section_anyway_with_flags (dynobj
, ".iplt", flags
);
3526 if (htab
->elf
.iplt
== NULL
3527 || !bfd_set_section_alignment (htab
->elf
.iplt
, 3))
3530 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
3531 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3533 = bfd_make_section_anyway_with_flags (dynobj
, ".rela.iplt", flags
);
3534 if (htab
->elf
.irelplt
== NULL
3535 || !bfd_set_section_alignment (htab
->elf
.irelplt
, 3))
3538 /* Create branch lookup table for plt_branch stubs. */
3539 flags
= (SEC_ALLOC
| SEC_LOAD
3540 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3541 htab
->brlt
= bfd_make_section_anyway_with_flags (dynobj
, ".branch_lt",
3543 if (htab
->brlt
== NULL
3544 || !bfd_set_section_alignment (htab
->brlt
, 3))
3547 /* Local plt entries, put in .branch_lt but a separate section for
3549 htab
->pltlocal
= bfd_make_section_anyway_with_flags (dynobj
, ".branch_lt",
3551 if (htab
->pltlocal
== NULL
3552 || !bfd_set_section_alignment (htab
->pltlocal
, 3))
3555 if (!bfd_link_pic (info
))
3558 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
3559 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3561 = bfd_make_section_anyway_with_flags (dynobj
, ".rela.branch_lt", flags
);
3562 if (htab
->relbrlt
== NULL
3563 || !bfd_set_section_alignment (htab
->relbrlt
, 3))
3567 = bfd_make_section_anyway_with_flags (dynobj
, ".rela.branch_lt", flags
);
3568 if (htab
->relpltlocal
== NULL
3569 || !bfd_set_section_alignment (htab
->relpltlocal
, 3))
3575 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
3578 ppc64_elf_init_stub_bfd (struct bfd_link_info
*info
,
3579 struct ppc64_elf_params
*params
)
3581 struct ppc_link_hash_table
*htab
;
3583 elf_elfheader (params
->stub_bfd
)->e_ident
[EI_CLASS
] = ELFCLASS64
;
3585 /* Always hook our dynamic sections into the first bfd, which is the
3586 linker created stub bfd. This ensures that the GOT header is at
3587 the start of the output TOC section. */
3588 htab
= ppc_hash_table (info
);
3589 htab
->elf
.dynobj
= params
->stub_bfd
;
3590 htab
->params
= params
;
3592 return create_linkage_sections (htab
->elf
.dynobj
, info
);
3595 /* Build a name for an entry in the stub hash table. */
3598 ppc_stub_name (const asection
*input_section
,
3599 const asection
*sym_sec
,
3600 const struct ppc_link_hash_entry
*h
,
3601 const Elf_Internal_Rela
*rel
)
3606 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
3607 offsets from a sym as a branch target? In fact, we could
3608 probably assume the addend is always zero. */
3609 BFD_ASSERT (((int) rel
->r_addend
& 0xffffffff) == rel
->r_addend
);
3613 len
= 8 + 1 + strlen (h
->elf
.root
.root
.string
) + 1 + 8 + 1;
3614 stub_name
= bfd_malloc (len
);
3615 if (stub_name
== NULL
)
3618 len
= sprintf (stub_name
, "%08x.%s+%x",
3619 input_section
->id
& 0xffffffff,
3620 h
->elf
.root
.root
.string
,
3621 (int) rel
->r_addend
& 0xffffffff);
3625 len
= 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
3626 stub_name
= bfd_malloc (len
);
3627 if (stub_name
== NULL
)
3630 len
= sprintf (stub_name
, "%08x.%x:%x+%x",
3631 input_section
->id
& 0xffffffff,
3632 sym_sec
->id
& 0xffffffff,
3633 (int) ELF64_R_SYM (rel
->r_info
) & 0xffffffff,
3634 (int) rel
->r_addend
& 0xffffffff);
3636 if (len
> 2 && stub_name
[len
- 2] == '+' && stub_name
[len
- 1] == '0')
3637 stub_name
[len
- 2] = 0;
3641 /* Look up an entry in the stub hash. Stub entries are cached because
3642 creating the stub name takes a bit of time. */
3644 static struct ppc_stub_hash_entry
*
3645 ppc_get_stub_entry (const asection
*input_section
,
3646 const asection
*sym_sec
,
3647 struct ppc_link_hash_entry
*h
,
3648 const Elf_Internal_Rela
*rel
,
3649 struct ppc_link_hash_table
*htab
)
3651 struct ppc_stub_hash_entry
*stub_entry
;
3652 struct map_stub
*group
;
3654 /* If this input section is part of a group of sections sharing one
3655 stub section, then use the id of the first section in the group.
3656 Stub names need to include a section id, as there may well be
3657 more than one stub used to reach say, printf, and we need to
3658 distinguish between them. */
3659 group
= htab
->sec_info
[input_section
->id
].u
.group
;
3663 if (h
!= NULL
&& h
->u
.stub_cache
!= NULL
3664 && h
->u
.stub_cache
->h
== h
3665 && h
->u
.stub_cache
->group
== group
)
3667 stub_entry
= h
->u
.stub_cache
;
3673 stub_name
= ppc_stub_name (group
->link_sec
, sym_sec
, h
, rel
);
3674 if (stub_name
== NULL
)
3677 stub_entry
= ppc_stub_hash_lookup (&htab
->stub_hash_table
,
3678 stub_name
, FALSE
, FALSE
);
3680 h
->u
.stub_cache
= stub_entry
;
3688 /* Add a new stub entry to the stub hash. Not all fields of the new
3689 stub entry are initialised. */
3691 static struct ppc_stub_hash_entry
*
3692 ppc_add_stub (const char *stub_name
,
3694 struct bfd_link_info
*info
)
3696 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
3697 struct map_stub
*group
;
3700 struct ppc_stub_hash_entry
*stub_entry
;
3702 group
= htab
->sec_info
[section
->id
].u
.group
;
3703 link_sec
= group
->link_sec
;
3704 stub_sec
= group
->stub_sec
;
3705 if (stub_sec
== NULL
)
3711 namelen
= strlen (link_sec
->name
);
3712 len
= namelen
+ sizeof (STUB_SUFFIX
);
3713 s_name
= bfd_alloc (htab
->params
->stub_bfd
, len
);
3717 memcpy (s_name
, link_sec
->name
, namelen
);
3718 memcpy (s_name
+ namelen
, STUB_SUFFIX
, sizeof (STUB_SUFFIX
));
3719 stub_sec
= (*htab
->params
->add_stub_section
) (s_name
, link_sec
);
3720 if (stub_sec
== NULL
)
3722 group
->stub_sec
= stub_sec
;
3725 /* Enter this entry into the linker stub hash table. */
3726 stub_entry
= ppc_stub_hash_lookup (&htab
->stub_hash_table
, stub_name
,
3728 if (stub_entry
== NULL
)
3730 /* xgettext:c-format */
3731 _bfd_error_handler (_("%pB: cannot create stub entry %s"),
3732 section
->owner
, stub_name
);
3736 stub_entry
->group
= group
;
3737 stub_entry
->stub_offset
= 0;
3741 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
3742 not already done. */
3745 create_got_section (bfd
*abfd
, struct bfd_link_info
*info
)
3747 asection
*got
, *relgot
;
3749 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
3751 if (!is_ppc64_elf (abfd
))
3757 && !_bfd_elf_create_got_section (htab
->elf
.dynobj
, info
))
3760 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
3761 | SEC_LINKER_CREATED
);
3763 got
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
3765 || !bfd_set_section_alignment (got
, 3))
3768 relgot
= bfd_make_section_anyway_with_flags (abfd
, ".rela.got",
3769 flags
| SEC_READONLY
);
3771 || !bfd_set_section_alignment (relgot
, 3))
3774 ppc64_elf_tdata (abfd
)->got
= got
;
3775 ppc64_elf_tdata (abfd
)->relgot
= relgot
;
3779 /* Follow indirect and warning symbol links. */
3781 static inline struct bfd_link_hash_entry
*
3782 follow_link (struct bfd_link_hash_entry
*h
)
3784 while (h
->type
== bfd_link_hash_indirect
3785 || h
->type
== bfd_link_hash_warning
)
3790 static inline struct elf_link_hash_entry
*
3791 elf_follow_link (struct elf_link_hash_entry
*h
)
3793 return (struct elf_link_hash_entry
*) follow_link (&h
->root
);
3796 static inline struct ppc_link_hash_entry
*
3797 ppc_follow_link (struct ppc_link_hash_entry
*h
)
3799 return (struct ppc_link_hash_entry
*) follow_link (&h
->elf
.root
);
3802 /* Merge PLT info on FROM with that on TO. */
3805 move_plt_plist (struct ppc_link_hash_entry
*from
,
3806 struct ppc_link_hash_entry
*to
)
3808 if (from
->elf
.plt
.plist
!= NULL
)
3810 if (to
->elf
.plt
.plist
!= NULL
)
3812 struct plt_entry
**entp
;
3813 struct plt_entry
*ent
;
3815 for (entp
= &from
->elf
.plt
.plist
; (ent
= *entp
) != NULL
; )
3817 struct plt_entry
*dent
;
3819 for (dent
= to
->elf
.plt
.plist
; dent
!= NULL
; dent
= dent
->next
)
3820 if (dent
->addend
== ent
->addend
)
3822 dent
->plt
.refcount
+= ent
->plt
.refcount
;
3829 *entp
= to
->elf
.plt
.plist
;
3832 to
->elf
.plt
.plist
= from
->elf
.plt
.plist
;
3833 from
->elf
.plt
.plist
= NULL
;
3837 /* Copy the extra info we tack onto an elf_link_hash_entry. */
3840 ppc64_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
3841 struct elf_link_hash_entry
*dir
,
3842 struct elf_link_hash_entry
*ind
)
3844 struct ppc_link_hash_entry
*edir
, *eind
;
3846 edir
= (struct ppc_link_hash_entry
*) dir
;
3847 eind
= (struct ppc_link_hash_entry
*) ind
;
3849 edir
->is_func
|= eind
->is_func
;
3850 edir
->is_func_descriptor
|= eind
->is_func_descriptor
;
3851 edir
->tls_mask
|= eind
->tls_mask
;
3852 if (eind
->oh
!= NULL
)
3853 edir
->oh
= ppc_follow_link (eind
->oh
);
3855 if (edir
->elf
.versioned
!= versioned_hidden
)
3856 edir
->elf
.ref_dynamic
|= eind
->elf
.ref_dynamic
;
3857 edir
->elf
.ref_regular
|= eind
->elf
.ref_regular
;
3858 edir
->elf
.ref_regular_nonweak
|= eind
->elf
.ref_regular_nonweak
;
3859 edir
->elf
.non_got_ref
|= eind
->elf
.non_got_ref
;
3860 edir
->elf
.needs_plt
|= eind
->elf
.needs_plt
;
3861 edir
->elf
.pointer_equality_needed
|= eind
->elf
.pointer_equality_needed
;
3863 /* If we were called to copy over info for a weak sym, don't copy
3864 dyn_relocs, plt/got info, or dynindx. We used to copy dyn_relocs
3865 in order to simplify readonly_dynrelocs and save a field in the
3866 symbol hash entry, but that means dyn_relocs can't be used in any
3867 tests about a specific symbol, or affect other symbol flags which
3869 if (eind
->elf
.root
.type
!= bfd_link_hash_indirect
)
3872 /* Copy over any dynamic relocs we may have on the indirect sym. */
3873 if (eind
->dyn_relocs
!= NULL
)
3875 if (edir
->dyn_relocs
!= NULL
)
3877 struct elf_dyn_relocs
**pp
;
3878 struct elf_dyn_relocs
*p
;
3880 /* Add reloc counts against the indirect sym to the direct sym
3881 list. Merge any entries against the same section. */
3882 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
3884 struct elf_dyn_relocs
*q
;
3886 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
3887 if (q
->sec
== p
->sec
)
3889 q
->pc_count
+= p
->pc_count
;
3890 q
->count
+= p
->count
;
3897 *pp
= edir
->dyn_relocs
;
3900 edir
->dyn_relocs
= eind
->dyn_relocs
;
3901 eind
->dyn_relocs
= NULL
;
3904 /* Copy over got entries that we may have already seen to the
3905 symbol which just became indirect. */
3906 if (eind
->elf
.got
.glist
!= NULL
)
3908 if (edir
->elf
.got
.glist
!= NULL
)
3910 struct got_entry
**entp
;
3911 struct got_entry
*ent
;
3913 for (entp
= &eind
->elf
.got
.glist
; (ent
= *entp
) != NULL
; )
3915 struct got_entry
*dent
;
3917 for (dent
= edir
->elf
.got
.glist
; dent
!= NULL
; dent
= dent
->next
)
3918 if (dent
->addend
== ent
->addend
3919 && dent
->owner
== ent
->owner
3920 && dent
->tls_type
== ent
->tls_type
)
3922 dent
->got
.refcount
+= ent
->got
.refcount
;
3929 *entp
= edir
->elf
.got
.glist
;
3932 edir
->elf
.got
.glist
= eind
->elf
.got
.glist
;
3933 eind
->elf
.got
.glist
= NULL
;
3936 /* And plt entries. */
3937 move_plt_plist (eind
, edir
);
3939 if (eind
->elf
.dynindx
!= -1)
3941 if (edir
->elf
.dynindx
!= -1)
3942 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
3943 edir
->elf
.dynstr_index
);
3944 edir
->elf
.dynindx
= eind
->elf
.dynindx
;
3945 edir
->elf
.dynstr_index
= eind
->elf
.dynstr_index
;
3946 eind
->elf
.dynindx
= -1;
3947 eind
->elf
.dynstr_index
= 0;
3951 /* Find the function descriptor hash entry from the given function code
3952 hash entry FH. Link the entries via their OH fields. */
3954 static struct ppc_link_hash_entry
*
3955 lookup_fdh (struct ppc_link_hash_entry
*fh
, struct ppc_link_hash_table
*htab
)
3957 struct ppc_link_hash_entry
*fdh
= fh
->oh
;
3961 const char *fd_name
= fh
->elf
.root
.root
.string
+ 1;
3963 fdh
= (struct ppc_link_hash_entry
*)
3964 elf_link_hash_lookup (&htab
->elf
, fd_name
, FALSE
, FALSE
, FALSE
);
3968 fdh
->is_func_descriptor
= 1;
3974 fdh
= ppc_follow_link (fdh
);
3975 fdh
->is_func_descriptor
= 1;
3980 /* Make a fake function descriptor sym for the undefined code sym FH. */
3982 static struct ppc_link_hash_entry
*
3983 make_fdh (struct bfd_link_info
*info
,
3984 struct ppc_link_hash_entry
*fh
)
3986 bfd
*abfd
= fh
->elf
.root
.u
.undef
.abfd
;
3987 struct bfd_link_hash_entry
*bh
= NULL
;
3988 struct ppc_link_hash_entry
*fdh
;
3989 flagword flags
= (fh
->elf
.root
.type
== bfd_link_hash_undefweak
3993 if (!_bfd_generic_link_add_one_symbol (info
, abfd
,
3994 fh
->elf
.root
.root
.string
+ 1,
3995 flags
, bfd_und_section_ptr
, 0,
3996 NULL
, FALSE
, FALSE
, &bh
))
3999 fdh
= (struct ppc_link_hash_entry
*) bh
;
4000 fdh
->elf
.non_elf
= 0;
4002 fdh
->is_func_descriptor
= 1;
4009 /* Fix function descriptor symbols defined in .opd sections to be
4013 ppc64_elf_add_symbol_hook (bfd
*ibfd
,
4014 struct bfd_link_info
*info
,
4015 Elf_Internal_Sym
*isym
,
4017 flagword
*flags ATTRIBUTE_UNUSED
,
4022 && strcmp ((*sec
)->name
, ".opd") == 0)
4026 if (!(ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
4027 || ELF_ST_TYPE (isym
->st_info
) == STT_FUNC
))
4028 isym
->st_info
= ELF_ST_INFO (ELF_ST_BIND (isym
->st_info
), STT_FUNC
);
4030 /* If the symbol is a function defined in .opd, and the function
4031 code is in a discarded group, let it appear to be undefined. */
4032 if (!bfd_link_relocatable (info
)
4033 && (*sec
)->reloc_count
!= 0
4034 && opd_entry_value (*sec
, *value
, &code_sec
, NULL
,
4035 FALSE
) != (bfd_vma
) -1
4036 && discarded_section (code_sec
))
4038 *sec
= bfd_und_section_ptr
;
4039 isym
->st_shndx
= SHN_UNDEF
;
4042 else if (*sec
!= NULL
4043 && strcmp ((*sec
)->name
, ".toc") == 0
4044 && ELF_ST_TYPE (isym
->st_info
) == STT_OBJECT
)
4046 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
4048 htab
->params
->object_in_toc
= 1;
4051 if ((STO_PPC64_LOCAL_MASK
& isym
->st_other
) != 0)
4053 if (abiversion (ibfd
) == 0)
4054 set_abiversion (ibfd
, 2);
4055 else if (abiversion (ibfd
) == 1)
4057 _bfd_error_handler (_("symbol '%s' has invalid st_other"
4058 " for ABI version 1"), *name
);
4059 bfd_set_error (bfd_error_bad_value
);
4067 /* Merge non-visibility st_other attributes: local entry point. */
4070 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry
*h
,
4071 const Elf_Internal_Sym
*isym
,
4072 bfd_boolean definition
,
4073 bfd_boolean dynamic
)
4075 if (definition
&& (!dynamic
|| !h
->def_regular
))
4076 h
->other
= ((isym
->st_other
& ~ELF_ST_VISIBILITY (-1))
4077 | ELF_ST_VISIBILITY (h
->other
));
4080 /* Hook called on merging a symbol. We use this to clear "fake" since
4081 we now have a real symbol. */
4084 ppc64_elf_merge_symbol (struct elf_link_hash_entry
*h
,
4085 const Elf_Internal_Sym
*isym
,
4086 asection
**psec ATTRIBUTE_UNUSED
,
4087 bfd_boolean newdef ATTRIBUTE_UNUSED
,
4088 bfd_boolean olddef ATTRIBUTE_UNUSED
,
4089 bfd
*oldbfd ATTRIBUTE_UNUSED
,
4090 const asection
*oldsec ATTRIBUTE_UNUSED
)
4092 ((struct ppc_link_hash_entry
*) h
)->fake
= 0;
4093 if ((STO_PPC64_LOCAL_MASK
& isym
->st_other
) != 0)
4094 ((struct ppc_link_hash_entry
*) h
)->non_zero_localentry
= 1;
4098 /* This function makes an old ABI object reference to ".bar" cause the
4099 inclusion of a new ABI object archive that defines "bar".
4100 NAME is a symbol defined in an archive. Return a symbol in the hash
4101 table that might be satisfied by the archive symbols. */
4103 static struct elf_link_hash_entry
*
4104 ppc64_elf_archive_symbol_lookup (bfd
*abfd
,
4105 struct bfd_link_info
*info
,
4108 struct elf_link_hash_entry
*h
;
4112 h
= _bfd_elf_archive_symbol_lookup (abfd
, info
, name
);
4114 /* Don't return this sym if it is a fake function descriptor
4115 created by add_symbol_adjust. */
4116 && !((struct ppc_link_hash_entry
*) h
)->fake
)
4122 len
= strlen (name
);
4123 dot_name
= bfd_alloc (abfd
, len
+ 2);
4124 if (dot_name
== NULL
)
4125 return (struct elf_link_hash_entry
*) -1;
4127 memcpy (dot_name
+ 1, name
, len
+ 1);
4128 h
= _bfd_elf_archive_symbol_lookup (abfd
, info
, dot_name
);
4129 bfd_release (abfd
, dot_name
);
4133 /* This function satisfies all old ABI object references to ".bar" if a
4134 new ABI object defines "bar". Well, at least, undefined dot symbols
4135 are made weak. This stops later archive searches from including an
4136 object if we already have a function descriptor definition. It also
4137 prevents the linker complaining about undefined symbols.
4138 We also check and correct mismatched symbol visibility here. The
4139 most restrictive visibility of the function descriptor and the
4140 function entry symbol is used. */
4143 add_symbol_adjust (struct ppc_link_hash_entry
*eh
, struct bfd_link_info
*info
)
4145 struct ppc_link_hash_table
*htab
;
4146 struct ppc_link_hash_entry
*fdh
;
4148 if (eh
->elf
.root
.type
== bfd_link_hash_warning
)
4149 eh
= (struct ppc_link_hash_entry
*) eh
->elf
.root
.u
.i
.link
;
4151 if (eh
->elf
.root
.type
== bfd_link_hash_indirect
)
4154 if (eh
->elf
.root
.root
.string
[0] != '.')
4157 htab
= ppc_hash_table (info
);
4161 fdh
= lookup_fdh (eh
, htab
);
4163 && !bfd_link_relocatable (info
)
4164 && (eh
->elf
.root
.type
== bfd_link_hash_undefined
4165 || eh
->elf
.root
.type
== bfd_link_hash_undefweak
)
4166 && eh
->elf
.ref_regular
)
4168 /* Make an undefined function descriptor sym, in order to
4169 pull in an --as-needed shared lib. Archives are handled
4171 fdh
= make_fdh (info
, eh
);
4178 unsigned entry_vis
= ELF_ST_VISIBILITY (eh
->elf
.other
) - 1;
4179 unsigned descr_vis
= ELF_ST_VISIBILITY (fdh
->elf
.other
) - 1;
4181 /* Make both descriptor and entry symbol have the most
4182 constraining visibility of either symbol. */
4183 if (entry_vis
< descr_vis
)
4184 fdh
->elf
.other
+= entry_vis
- descr_vis
;
4185 else if (entry_vis
> descr_vis
)
4186 eh
->elf
.other
+= descr_vis
- entry_vis
;
4188 /* Propagate reference flags from entry symbol to function
4189 descriptor symbol. */
4190 fdh
->elf
.root
.non_ir_ref_regular
|= eh
->elf
.root
.non_ir_ref_regular
;
4191 fdh
->elf
.root
.non_ir_ref_dynamic
|= eh
->elf
.root
.non_ir_ref_dynamic
;
4192 fdh
->elf
.ref_regular
|= eh
->elf
.ref_regular
;
4193 fdh
->elf
.ref_regular_nonweak
|= eh
->elf
.ref_regular_nonweak
;
4195 if (!fdh
->elf
.forced_local
4196 && fdh
->elf
.dynindx
== -1
4197 && fdh
->elf
.versioned
!= versioned_hidden
4198 && (bfd_link_dll (info
)
4199 || fdh
->elf
.def_dynamic
4200 || fdh
->elf
.ref_dynamic
)
4201 && (eh
->elf
.ref_regular
4202 || eh
->elf
.def_regular
))
4204 if (!bfd_elf_link_record_dynamic_symbol (info
, &fdh
->elf
))
4212 /* Set up opd section info and abiversion for IBFD, and process list
4213 of dot-symbols we made in link_hash_newfunc. */
4216 ppc64_elf_before_check_relocs (bfd
*ibfd
, struct bfd_link_info
*info
)
4218 struct ppc_link_hash_table
*htab
;
4219 struct ppc_link_hash_entry
**p
, *eh
;
4220 asection
*opd
= bfd_get_section_by_name (ibfd
, ".opd");
4222 if (opd
!= NULL
&& opd
->size
!= 0)
4224 BFD_ASSERT (ppc64_elf_section_data (opd
)->sec_type
== sec_normal
);
4225 ppc64_elf_section_data (opd
)->sec_type
= sec_opd
;
4227 if (abiversion (ibfd
) == 0)
4228 set_abiversion (ibfd
, 1);
4229 else if (abiversion (ibfd
) >= 2)
4231 /* xgettext:c-format */
4232 _bfd_error_handler (_("%pB .opd not allowed in ABI version %d"),
4233 ibfd
, abiversion (ibfd
));
4234 bfd_set_error (bfd_error_bad_value
);
4239 if (is_ppc64_elf (info
->output_bfd
))
4241 /* For input files without an explicit abiversion in e_flags
4242 we should have flagged any with symbol st_other bits set
4243 as ELFv1 and above flagged those with .opd as ELFv2.
4244 Set the output abiversion if not yet set, and for any input
4245 still ambiguous, take its abiversion from the output.
4246 Differences in ABI are reported later. */
4247 if (abiversion (info
->output_bfd
) == 0)
4248 set_abiversion (info
->output_bfd
, abiversion (ibfd
));
4249 else if (abiversion (ibfd
) == 0)
4250 set_abiversion (ibfd
, abiversion (info
->output_bfd
));
4253 htab
= ppc_hash_table (info
);
4257 if (opd
!= NULL
&& opd
->size
!= 0
4258 && (ibfd
->flags
& DYNAMIC
) == 0
4259 && (opd
->flags
& SEC_RELOC
) != 0
4260 && opd
->reloc_count
!= 0
4261 && !bfd_is_abs_section (opd
->output_section
)
4262 && info
->gc_sections
)
4264 /* Garbage collection needs some extra help with .opd sections.
4265 We don't want to necessarily keep everything referenced by
4266 relocs in .opd, as that would keep all functions. Instead,
4267 if we reference an .opd symbol (a function descriptor), we
4268 want to keep the function code symbol's section. This is
4269 easy for global symbols, but for local syms we need to keep
4270 information about the associated function section. */
4272 asection
**opd_sym_map
;
4273 Elf_Internal_Shdr
*symtab_hdr
;
4274 Elf_Internal_Rela
*relocs
, *rel_end
, *rel
;
4276 amt
= OPD_NDX (opd
->size
) * sizeof (*opd_sym_map
);
4277 opd_sym_map
= bfd_zalloc (ibfd
, amt
);
4278 if (opd_sym_map
== NULL
)
4280 ppc64_elf_section_data (opd
)->u
.opd
.func_sec
= opd_sym_map
;
4281 relocs
= _bfd_elf_link_read_relocs (ibfd
, opd
, NULL
, NULL
,
4285 symtab_hdr
= &elf_symtab_hdr (ibfd
);
4286 rel_end
= relocs
+ opd
->reloc_count
- 1;
4287 for (rel
= relocs
; rel
< rel_end
; rel
++)
4289 enum elf_ppc64_reloc_type r_type
= ELF64_R_TYPE (rel
->r_info
);
4290 unsigned long r_symndx
= ELF64_R_SYM (rel
->r_info
);
4292 if (r_type
== R_PPC64_ADDR64
4293 && ELF64_R_TYPE ((rel
+ 1)->r_info
) == R_PPC64_TOC
4294 && r_symndx
< symtab_hdr
->sh_info
)
4296 Elf_Internal_Sym
*isym
;
4299 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
, ibfd
, r_symndx
);
4302 if (elf_section_data (opd
)->relocs
!= relocs
)
4307 s
= bfd_section_from_elf_index (ibfd
, isym
->st_shndx
);
4308 if (s
!= NULL
&& s
!= opd
)
4309 opd_sym_map
[OPD_NDX (rel
->r_offset
)] = s
;
4312 if (elf_section_data (opd
)->relocs
!= relocs
)
4316 p
= &htab
->dot_syms
;
4317 while ((eh
= *p
) != NULL
)
4320 if (&eh
->elf
== htab
->elf
.hgot
)
4322 else if (htab
->elf
.hgot
== NULL
4323 && strcmp (eh
->elf
.root
.root
.string
, ".TOC.") == 0)
4324 htab
->elf
.hgot
= &eh
->elf
;
4325 else if (abiversion (ibfd
) <= 1)
4327 htab
->need_func_desc_adj
= 1;
4328 if (!add_symbol_adjust (eh
, info
))
4331 p
= &eh
->u
.next_dot_sym
;
4336 /* Undo hash table changes when an --as-needed input file is determined
4337 not to be needed. */
4340 ppc64_elf_notice_as_needed (bfd
*ibfd
,
4341 struct bfd_link_info
*info
,
4342 enum notice_asneeded_action act
)
4344 if (act
== notice_not_needed
)
4346 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
4351 htab
->dot_syms
= NULL
;
4353 return _bfd_elf_notice_as_needed (ibfd
, info
, act
);
4356 /* If --just-symbols against a final linked binary, then assume we need
4357 toc adjusting stubs when calling functions defined there. */
4360 ppc64_elf_link_just_syms (asection
*sec
, struct bfd_link_info
*info
)
4362 if ((sec
->flags
& SEC_CODE
) != 0
4363 && (sec
->owner
->flags
& (EXEC_P
| DYNAMIC
)) != 0
4364 && is_ppc64_elf (sec
->owner
))
4366 if (abiversion (sec
->owner
) >= 2
4367 || bfd_get_section_by_name (sec
->owner
, ".opd") != NULL
)
4368 sec
->has_toc_reloc
= 1;
4370 _bfd_elf_link_just_syms (sec
, info
);
4373 static struct plt_entry
**
4374 update_local_sym_info (bfd
*abfd
, Elf_Internal_Shdr
*symtab_hdr
,
4375 unsigned long r_symndx
, bfd_vma r_addend
, int tls_type
)
4377 struct got_entry
**local_got_ents
= elf_local_got_ents (abfd
);
4378 struct plt_entry
**local_plt
;
4379 unsigned char *local_got_tls_masks
;
4381 if (local_got_ents
== NULL
)
4383 bfd_size_type size
= symtab_hdr
->sh_info
;
4385 size
*= (sizeof (*local_got_ents
)
4386 + sizeof (*local_plt
)
4387 + sizeof (*local_got_tls_masks
));
4388 local_got_ents
= bfd_zalloc (abfd
, size
);
4389 if (local_got_ents
== NULL
)
4391 elf_local_got_ents (abfd
) = local_got_ents
;
4394 if ((tls_type
& (NON_GOT
| TLS_EXPLICIT
)) == 0)
4396 struct got_entry
*ent
;
4398 for (ent
= local_got_ents
[r_symndx
]; ent
!= NULL
; ent
= ent
->next
)
4399 if (ent
->addend
== r_addend
4400 && ent
->owner
== abfd
4401 && ent
->tls_type
== tls_type
)
4405 bfd_size_type amt
= sizeof (*ent
);
4406 ent
= bfd_alloc (abfd
, amt
);
4409 ent
->next
= local_got_ents
[r_symndx
];
4410 ent
->addend
= r_addend
;
4412 ent
->tls_type
= tls_type
;
4413 ent
->is_indirect
= FALSE
;
4414 ent
->got
.refcount
= 0;
4415 local_got_ents
[r_symndx
] = ent
;
4417 ent
->got
.refcount
+= 1;
4420 local_plt
= (struct plt_entry
**) (local_got_ents
+ symtab_hdr
->sh_info
);
4421 local_got_tls_masks
= (unsigned char *) (local_plt
+ symtab_hdr
->sh_info
);
4422 local_got_tls_masks
[r_symndx
] |= tls_type
& 0xff;
4424 return local_plt
+ r_symndx
;
4428 update_plt_info (bfd
*abfd
, struct plt_entry
**plist
, bfd_vma addend
)
4430 struct plt_entry
*ent
;
4432 for (ent
= *plist
; ent
!= NULL
; ent
= ent
->next
)
4433 if (ent
->addend
== addend
)
4437 bfd_size_type amt
= sizeof (*ent
);
4438 ent
= bfd_alloc (abfd
, amt
);
4442 ent
->addend
= addend
;
4443 ent
->plt
.refcount
= 0;
4446 ent
->plt
.refcount
+= 1;
4451 is_branch_reloc (enum elf_ppc64_reloc_type r_type
)
4453 return (r_type
== R_PPC64_REL24
4454 || r_type
== R_PPC64_REL24_NOTOC
4455 || r_type
== R_PPC64_REL14
4456 || r_type
== R_PPC64_REL14_BRTAKEN
4457 || r_type
== R_PPC64_REL14_BRNTAKEN
4458 || r_type
== R_PPC64_ADDR24
4459 || r_type
== R_PPC64_ADDR14
4460 || r_type
== R_PPC64_ADDR14_BRTAKEN
4461 || r_type
== R_PPC64_ADDR14_BRNTAKEN
4462 || r_type
== R_PPC64_PLTCALL
4463 || r_type
== R_PPC64_PLTCALL_NOTOC
);
4466 /* Relocs on inline plt call sequence insns prior to the call. */
4469 is_plt_seq_reloc (enum elf_ppc64_reloc_type r_type
)
4471 return (r_type
== R_PPC64_PLT16_HA
4472 || r_type
== R_PPC64_PLT16_HI
4473 || r_type
== R_PPC64_PLT16_LO
4474 || r_type
== R_PPC64_PLT16_LO_DS
4475 || r_type
== R_PPC64_PLT_PCREL34
4476 || r_type
== R_PPC64_PLT_PCREL34_NOTOC
4477 || r_type
== R_PPC64_PLTSEQ
4478 || r_type
== R_PPC64_PLTSEQ_NOTOC
);
4481 /* Look through the relocs for a section during the first phase, and
4482 calculate needed space in the global offset table, procedure
4483 linkage table, and dynamic reloc sections. */
4486 ppc64_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
4487 asection
*sec
, const Elf_Internal_Rela
*relocs
)
4489 struct ppc_link_hash_table
*htab
;
4490 Elf_Internal_Shdr
*symtab_hdr
;
4491 struct elf_link_hash_entry
**sym_hashes
;
4492 const Elf_Internal_Rela
*rel
;
4493 const Elf_Internal_Rela
*rel_end
;
4495 struct elf_link_hash_entry
*tga
, *dottga
;
4498 if (bfd_link_relocatable (info
))
4501 /* Don't do anything special with non-loaded, non-alloced sections.
4502 In particular, any relocs in such sections should not affect GOT
4503 and PLT reference counting (ie. we don't allow them to create GOT
4504 or PLT entries), there's no possibility or desire to optimize TLS
4505 relocs, and there's not much point in propagating relocs to shared
4506 libs that the dynamic linker won't relocate. */
4507 if ((sec
->flags
& SEC_ALLOC
) == 0)
4510 BFD_ASSERT (is_ppc64_elf (abfd
));
4512 htab
= ppc_hash_table (info
);
4516 tga
= elf_link_hash_lookup (&htab
->elf
, "__tls_get_addr",
4517 FALSE
, FALSE
, TRUE
);
4518 dottga
= elf_link_hash_lookup (&htab
->elf
, ".__tls_get_addr",
4519 FALSE
, FALSE
, TRUE
);
4520 symtab_hdr
= &elf_symtab_hdr (abfd
);
4521 sym_hashes
= elf_sym_hashes (abfd
);
4523 is_opd
= ppc64_elf_section_data (sec
)->sec_type
== sec_opd
;
4524 rel_end
= relocs
+ sec
->reloc_count
;
4525 for (rel
= relocs
; rel
< rel_end
; rel
++)
4527 unsigned long r_symndx
;
4528 struct elf_link_hash_entry
*h
;
4529 enum elf_ppc64_reloc_type r_type
;
4531 struct _ppc64_elf_section_data
*ppc64_sec
;
4532 struct plt_entry
**ifunc
, **plt_list
;
4534 r_symndx
= ELF64_R_SYM (rel
->r_info
);
4535 if (r_symndx
< symtab_hdr
->sh_info
)
4539 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
4540 h
= elf_follow_link (h
);
4542 if (h
== htab
->elf
.hgot
)
4543 sec
->has_toc_reloc
= 1;
4548 r_type
= ELF64_R_TYPE (rel
->r_info
);
4552 case R_PPC64_D34_LO
:
4553 case R_PPC64_D34_HI30
:
4554 case R_PPC64_D34_HA30
:
4556 case R_PPC64_TPREL34
:
4557 case R_PPC64_DTPREL34
:
4558 case R_PPC64_PCREL34
:
4559 case R_PPC64_GOT_PCREL34
:
4560 case R_PPC64_GOT_TLSGD34
:
4561 case R_PPC64_GOT_TLSLD34
:
4562 case R_PPC64_GOT_TPREL34
:
4563 case R_PPC64_GOT_DTPREL34
:
4564 case R_PPC64_PLT_PCREL34
:
4565 case R_PPC64_PLT_PCREL34_NOTOC
:
4566 case R_PPC64_PCREL28
:
4567 htab
->powerxx_stubs
= 1;
4575 case R_PPC64_PLT16_HA
:
4576 case R_PPC64_GOT_TLSLD16_HA
:
4577 case R_PPC64_GOT_TLSGD16_HA
:
4578 case R_PPC64_GOT_TPREL16_HA
:
4579 case R_PPC64_GOT_DTPREL16_HA
:
4580 case R_PPC64_GOT16_HA
:
4581 case R_PPC64_TOC16_HA
:
4582 case R_PPC64_PLT16_LO
:
4583 case R_PPC64_PLT16_LO_DS
:
4584 case R_PPC64_GOT_TLSLD16_LO
:
4585 case R_PPC64_GOT_TLSGD16_LO
:
4586 case R_PPC64_GOT_TPREL16_LO_DS
:
4587 case R_PPC64_GOT_DTPREL16_LO_DS
:
4588 case R_PPC64_GOT16_LO
:
4589 case R_PPC64_GOT16_LO_DS
:
4590 case R_PPC64_TOC16_LO
:
4591 case R_PPC64_TOC16_LO_DS
:
4592 case R_PPC64_GOT_PCREL34
:
4593 ppc64_elf_tdata (abfd
)->has_optrel
= 1;
4594 ppc64_elf_section_data (sec
)->has_optrel
= 1;
4602 if (h
->type
== STT_GNU_IFUNC
)
4605 ifunc
= &h
->plt
.plist
;
4610 Elf_Internal_Sym
*isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
4615 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
4617 ifunc
= update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4619 NON_GOT
| PLT_IFUNC
);
4629 /* These special tls relocs tie a call to __tls_get_addr with
4630 its parameter symbol. */
4632 ((struct ppc_link_hash_entry
*) h
)->tls_mask
|= TLS_TLS
| TLS_MARK
;
4634 if (!update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4636 NON_GOT
| TLS_TLS
| TLS_MARK
))
4638 sec
->has_tls_reloc
= 1;
4641 case R_PPC64_GOT_TLSLD16
:
4642 case R_PPC64_GOT_TLSLD16_LO
:
4643 case R_PPC64_GOT_TLSLD16_HI
:
4644 case R_PPC64_GOT_TLSLD16_HA
:
4645 case R_PPC64_GOT_TLSLD34
:
4646 tls_type
= TLS_TLS
| TLS_LD
;
4649 case R_PPC64_GOT_TLSGD16
:
4650 case R_PPC64_GOT_TLSGD16_LO
:
4651 case R_PPC64_GOT_TLSGD16_HI
:
4652 case R_PPC64_GOT_TLSGD16_HA
:
4653 case R_PPC64_GOT_TLSGD34
:
4654 tls_type
= TLS_TLS
| TLS_GD
;
4657 case R_PPC64_GOT_TPREL16_DS
:
4658 case R_PPC64_GOT_TPREL16_LO_DS
:
4659 case R_PPC64_GOT_TPREL16_HI
:
4660 case R_PPC64_GOT_TPREL16_HA
:
4661 case R_PPC64_GOT_TPREL34
:
4662 if (bfd_link_dll (info
))
4663 info
->flags
|= DF_STATIC_TLS
;
4664 tls_type
= TLS_TLS
| TLS_TPREL
;
4667 case R_PPC64_GOT_DTPREL16_DS
:
4668 case R_PPC64_GOT_DTPREL16_LO_DS
:
4669 case R_PPC64_GOT_DTPREL16_HI
:
4670 case R_PPC64_GOT_DTPREL16_HA
:
4671 case R_PPC64_GOT_DTPREL34
:
4672 tls_type
= TLS_TLS
| TLS_DTPREL
;
4674 sec
->has_tls_reloc
= 1;
4678 case R_PPC64_GOT16_LO
:
4679 case R_PPC64_GOT16_HI
:
4680 case R_PPC64_GOT16_HA
:
4681 case R_PPC64_GOT16_DS
:
4682 case R_PPC64_GOT16_LO_DS
:
4683 case R_PPC64_GOT_PCREL34
:
4685 /* This symbol requires a global offset table entry. */
4686 sec
->has_toc_reloc
= 1;
4687 if (r_type
== R_PPC64_GOT_TLSLD16
4688 || r_type
== R_PPC64_GOT_TLSGD16
4689 || r_type
== R_PPC64_GOT_TPREL16_DS
4690 || r_type
== R_PPC64_GOT_DTPREL16_DS
4691 || r_type
== R_PPC64_GOT16
4692 || r_type
== R_PPC64_GOT16_DS
)
4694 htab
->do_multi_toc
= 1;
4695 ppc64_elf_tdata (abfd
)->has_small_toc_reloc
= 1;
4698 if (ppc64_elf_tdata (abfd
)->got
== NULL
4699 && !create_got_section (abfd
, info
))
4704 struct ppc_link_hash_entry
*eh
;
4705 struct got_entry
*ent
;
4707 eh
= (struct ppc_link_hash_entry
*) h
;
4708 for (ent
= eh
->elf
.got
.glist
; ent
!= NULL
; ent
= ent
->next
)
4709 if (ent
->addend
== rel
->r_addend
4710 && ent
->owner
== abfd
4711 && ent
->tls_type
== tls_type
)
4715 bfd_size_type amt
= sizeof (*ent
);
4716 ent
= bfd_alloc (abfd
, amt
);
4719 ent
->next
= eh
->elf
.got
.glist
;
4720 ent
->addend
= rel
->r_addend
;
4722 ent
->tls_type
= tls_type
;
4723 ent
->is_indirect
= FALSE
;
4724 ent
->got
.refcount
= 0;
4725 eh
->elf
.got
.glist
= ent
;
4727 ent
->got
.refcount
+= 1;
4728 eh
->tls_mask
|= tls_type
;
4731 /* This is a global offset table entry for a local symbol. */
4732 if (!update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4733 rel
->r_addend
, tls_type
))
4736 /* We may also need a plt entry if the symbol turns out to be
4738 if (h
!= NULL
&& !bfd_link_pic (info
) && abiversion (abfd
) != 1)
4740 if (!update_plt_info (abfd
, &h
->plt
.plist
, rel
->r_addend
))
4745 case R_PPC64_PLT16_HA
:
4746 case R_PPC64_PLT16_HI
:
4747 case R_PPC64_PLT16_LO
:
4748 case R_PPC64_PLT16_LO_DS
:
4749 case R_PPC64_PLT_PCREL34
:
4750 case R_PPC64_PLT_PCREL34_NOTOC
:
4753 /* This symbol requires a procedure linkage table entry. */
4758 if (h
->root
.root
.string
[0] == '.'
4759 && h
->root
.root
.string
[1] != '\0')
4760 ((struct ppc_link_hash_entry
*) h
)->is_func
= 1;
4761 ((struct ppc_link_hash_entry
*) h
)->tls_mask
|= PLT_KEEP
;
4762 plt_list
= &h
->plt
.plist
;
4764 if (plt_list
== NULL
)
4765 plt_list
= update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4767 NON_GOT
| PLT_KEEP
);
4768 if (!update_plt_info (abfd
, plt_list
, rel
->r_addend
))
4772 /* The following relocations don't need to propagate the
4773 relocation if linking a shared object since they are
4774 section relative. */
4775 case R_PPC64_SECTOFF
:
4776 case R_PPC64_SECTOFF_LO
:
4777 case R_PPC64_SECTOFF_HI
:
4778 case R_PPC64_SECTOFF_HA
:
4779 case R_PPC64_SECTOFF_DS
:
4780 case R_PPC64_SECTOFF_LO_DS
:
4781 case R_PPC64_DTPREL16
:
4782 case R_PPC64_DTPREL16_LO
:
4783 case R_PPC64_DTPREL16_HI
:
4784 case R_PPC64_DTPREL16_HA
:
4785 case R_PPC64_DTPREL16_DS
:
4786 case R_PPC64_DTPREL16_LO_DS
:
4787 case R_PPC64_DTPREL16_HIGH
:
4788 case R_PPC64_DTPREL16_HIGHA
:
4789 case R_PPC64_DTPREL16_HIGHER
:
4790 case R_PPC64_DTPREL16_HIGHERA
:
4791 case R_PPC64_DTPREL16_HIGHEST
:
4792 case R_PPC64_DTPREL16_HIGHESTA
:
4797 case R_PPC64_REL16_LO
:
4798 case R_PPC64_REL16_HI
:
4799 case R_PPC64_REL16_HA
:
4800 case R_PPC64_REL16_HIGH
:
4801 case R_PPC64_REL16_HIGHA
:
4802 case R_PPC64_REL16_HIGHER
:
4803 case R_PPC64_REL16_HIGHERA
:
4804 case R_PPC64_REL16_HIGHEST
:
4805 case R_PPC64_REL16_HIGHESTA
:
4806 case R_PPC64_REL16_HIGHER34
:
4807 case R_PPC64_REL16_HIGHERA34
:
4808 case R_PPC64_REL16_HIGHEST34
:
4809 case R_PPC64_REL16_HIGHESTA34
:
4810 case R_PPC64_REL16DX_HA
:
4813 /* Not supported as a dynamic relocation. */
4814 case R_PPC64_ADDR64_LOCAL
:
4815 if (bfd_link_pic (info
))
4817 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
4819 /* xgettext:c-format */
4820 info
->callbacks
->einfo (_("%H: %s reloc unsupported "
4821 "in shared libraries and PIEs\n"),
4822 abfd
, sec
, rel
->r_offset
,
4823 ppc64_elf_howto_table
[r_type
]->name
);
4824 bfd_set_error (bfd_error_bad_value
);
4830 case R_PPC64_TOC16_DS
:
4831 htab
->do_multi_toc
= 1;
4832 ppc64_elf_tdata (abfd
)->has_small_toc_reloc
= 1;
4834 case R_PPC64_TOC16_LO
:
4835 case R_PPC64_TOC16_HI
:
4836 case R_PPC64_TOC16_HA
:
4837 case R_PPC64_TOC16_LO_DS
:
4838 sec
->has_toc_reloc
= 1;
4839 if (h
!= NULL
&& bfd_link_executable (info
))
4841 /* We may need a copy reloc. */
4843 /* Strongly prefer a copy reloc over a dynamic reloc.
4844 glibc ld.so as of 2019-08 will error out if one of
4845 these relocations is emitted. */
4855 /* This relocation describes the C++ object vtable hierarchy.
4856 Reconstruct it for later use during GC. */
4857 case R_PPC64_GNU_VTINHERIT
:
4858 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
4862 /* This relocation describes which C++ vtable entries are actually
4863 used. Record for later use during GC. */
4864 case R_PPC64_GNU_VTENTRY
:
4865 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
4870 case R_PPC64_REL14_BRTAKEN
:
4871 case R_PPC64_REL14_BRNTAKEN
:
4873 asection
*dest
= NULL
;
4875 /* Heuristic: If jumping outside our section, chances are
4876 we are going to need a stub. */
4879 /* If the sym is weak it may be overridden later, so
4880 don't assume we know where a weak sym lives. */
4881 if (h
->root
.type
== bfd_link_hash_defined
)
4882 dest
= h
->root
.u
.def
.section
;
4886 Elf_Internal_Sym
*isym
;
4888 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
4893 dest
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
4897 ppc64_elf_section_data (sec
)->has_14bit_branch
= 1;
4901 case R_PPC64_PLTCALL
:
4902 case R_PPC64_PLTCALL_NOTOC
:
4903 ppc64_elf_section_data (sec
)->has_pltcall
= 1;
4907 case R_PPC64_REL24_NOTOC
:
4913 if (h
->root
.root
.string
[0] == '.'
4914 && h
->root
.root
.string
[1] != '\0')
4915 ((struct ppc_link_hash_entry
*) h
)->is_func
= 1;
4917 if (h
== tga
|| h
== dottga
)
4919 sec
->has_tls_reloc
= 1;
4921 && (ELF64_R_TYPE (rel
[-1].r_info
) == R_PPC64_TLSGD
4922 || ELF64_R_TYPE (rel
[-1].r_info
) == R_PPC64_TLSLD
))
4923 /* We have a new-style __tls_get_addr call with
4927 /* Mark this section as having an old-style call. */
4928 sec
->has_tls_get_addr_call
= 1;
4930 plt_list
= &h
->plt
.plist
;
4933 /* We may need a .plt entry if the function this reloc
4934 refers to is in a shared lib. */
4936 && !update_plt_info (abfd
, plt_list
, rel
->r_addend
))
4940 case R_PPC64_ADDR14
:
4941 case R_PPC64_ADDR14_BRNTAKEN
:
4942 case R_PPC64_ADDR14_BRTAKEN
:
4943 case R_PPC64_ADDR24
:
4946 case R_PPC64_TPREL64
:
4947 tls_type
= TLS_EXPLICIT
| TLS_TLS
| TLS_TPREL
;
4948 if (bfd_link_dll (info
))
4949 info
->flags
|= DF_STATIC_TLS
;
4952 case R_PPC64_DTPMOD64
:
4953 if (rel
+ 1 < rel_end
4954 && rel
[1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_DTPREL64
)
4955 && rel
[1].r_offset
== rel
->r_offset
+ 8)
4956 tls_type
= TLS_EXPLICIT
| TLS_TLS
| TLS_GD
;
4958 tls_type
= TLS_EXPLICIT
| TLS_TLS
| TLS_LD
;
4961 case R_PPC64_DTPREL64
:
4962 tls_type
= TLS_EXPLICIT
| TLS_TLS
| TLS_DTPREL
;
4964 && rel
[-1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_DTPMOD64
)
4965 && rel
[-1].r_offset
== rel
->r_offset
- 8)
4966 /* This is the second reloc of a dtpmod, dtprel pair.
4967 Don't mark with TLS_DTPREL. */
4971 sec
->has_tls_reloc
= 1;
4974 struct ppc_link_hash_entry
*eh
;
4975 eh
= (struct ppc_link_hash_entry
*) h
;
4976 eh
->tls_mask
|= tls_type
& 0xff;
4979 if (!update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4980 rel
->r_addend
, tls_type
))
4983 ppc64_sec
= ppc64_elf_section_data (sec
);
4984 if (ppc64_sec
->sec_type
!= sec_toc
)
4988 /* One extra to simplify get_tls_mask. */
4989 amt
= sec
->size
* sizeof (unsigned) / 8 + sizeof (unsigned);
4990 ppc64_sec
->u
.toc
.symndx
= bfd_zalloc (abfd
, amt
);
4991 if (ppc64_sec
->u
.toc
.symndx
== NULL
)
4993 amt
= sec
->size
* sizeof (bfd_vma
) / 8;
4994 ppc64_sec
->u
.toc
.add
= bfd_zalloc (abfd
, amt
);
4995 if (ppc64_sec
->u
.toc
.add
== NULL
)
4997 BFD_ASSERT (ppc64_sec
->sec_type
== sec_normal
);
4998 ppc64_sec
->sec_type
= sec_toc
;
5000 BFD_ASSERT (rel
->r_offset
% 8 == 0);
5001 ppc64_sec
->u
.toc
.symndx
[rel
->r_offset
/ 8] = r_symndx
;
5002 ppc64_sec
->u
.toc
.add
[rel
->r_offset
/ 8] = rel
->r_addend
;
5004 /* Mark the second slot of a GD or LD entry.
5005 -1 to indicate GD and -2 to indicate LD. */
5006 if (tls_type
== (TLS_EXPLICIT
| TLS_TLS
| TLS_GD
))
5007 ppc64_sec
->u
.toc
.symndx
[rel
->r_offset
/ 8 + 1] = -1;
5008 else if (tls_type
== (TLS_EXPLICIT
| TLS_TLS
| TLS_LD
))
5009 ppc64_sec
->u
.toc
.symndx
[rel
->r_offset
/ 8 + 1] = -2;
5012 case R_PPC64_TPREL16
:
5013 case R_PPC64_TPREL16_LO
:
5014 case R_PPC64_TPREL16_HI
:
5015 case R_PPC64_TPREL16_HA
:
5016 case R_PPC64_TPREL16_DS
:
5017 case R_PPC64_TPREL16_LO_DS
:
5018 case R_PPC64_TPREL16_HIGH
:
5019 case R_PPC64_TPREL16_HIGHA
:
5020 case R_PPC64_TPREL16_HIGHER
:
5021 case R_PPC64_TPREL16_HIGHERA
:
5022 case R_PPC64_TPREL16_HIGHEST
:
5023 case R_PPC64_TPREL16_HIGHESTA
:
5024 case R_PPC64_TPREL34
:
5025 if (bfd_link_dll (info
))
5026 info
->flags
|= DF_STATIC_TLS
;
5029 case R_PPC64_ADDR64
:
5031 && rel
+ 1 < rel_end
5032 && ELF64_R_TYPE ((rel
+ 1)->r_info
) == R_PPC64_TOC
)
5035 ((struct ppc_link_hash_entry
*) h
)->is_func
= 1;
5039 case R_PPC64_ADDR16
:
5040 case R_PPC64_ADDR16_DS
:
5041 case R_PPC64_ADDR16_HA
:
5042 case R_PPC64_ADDR16_HI
:
5043 case R_PPC64_ADDR16_HIGH
:
5044 case R_PPC64_ADDR16_HIGHA
:
5045 case R_PPC64_ADDR16_HIGHER
:
5046 case R_PPC64_ADDR16_HIGHERA
:
5047 case R_PPC64_ADDR16_HIGHEST
:
5048 case R_PPC64_ADDR16_HIGHESTA
:
5049 case R_PPC64_ADDR16_LO
:
5050 case R_PPC64_ADDR16_LO_DS
:
5052 case R_PPC64_D34_LO
:
5053 case R_PPC64_D34_HI30
:
5054 case R_PPC64_D34_HA30
:
5055 case R_PPC64_ADDR16_HIGHER34
:
5056 case R_PPC64_ADDR16_HIGHERA34
:
5057 case R_PPC64_ADDR16_HIGHEST34
:
5058 case R_PPC64_ADDR16_HIGHESTA34
:
5060 if (h
!= NULL
&& !bfd_link_pic (info
) && abiversion (abfd
) != 1
5061 && rel
->r_addend
== 0)
5063 /* We may need a .plt entry if this reloc refers to a
5064 function in a shared lib. */
5065 if (!update_plt_info (abfd
, &h
->plt
.plist
, 0))
5067 h
->pointer_equality_needed
= 1;
5074 case R_PPC64_ADDR32
:
5075 case R_PPC64_UADDR16
:
5076 case R_PPC64_UADDR32
:
5077 case R_PPC64_UADDR64
:
5079 if (h
!= NULL
&& bfd_link_executable (info
))
5080 /* We may need a copy reloc. */
5083 /* Don't propagate .opd relocs. */
5084 if (NO_OPD_RELOCS
&& is_opd
)
5087 /* If we are creating a shared library, and this is a reloc
5088 against a global symbol, or a non PC relative reloc
5089 against a local symbol, then we need to copy the reloc
5090 into the shared library. However, if we are linking with
5091 -Bsymbolic, we do not need to copy a reloc against a
5092 global symbol which is defined in an object we are
5093 including in the link (i.e., DEF_REGULAR is set). At
5094 this point we have not seen all the input files, so it is
5095 possible that DEF_REGULAR is not set now but will be set
5096 later (it is never cleared). In case of a weak definition,
5097 DEF_REGULAR may be cleared later by a strong definition in
5098 a shared library. We account for that possibility below by
5099 storing information in the dyn_relocs field of the hash
5100 table entry. A similar situation occurs when creating
5101 shared libraries and symbol visibility changes render the
5104 If on the other hand, we are creating an executable, we
5105 may need to keep relocations for symbols satisfied by a
5106 dynamic library if we manage to avoid copy relocs for the
5110 && (h
->root
.type
== bfd_link_hash_defweak
5111 || !h
->def_regular
))
5113 && !bfd_link_executable (info
)
5114 && !SYMBOLIC_BIND (info
, h
))
5115 || (bfd_link_pic (info
)
5116 && must_be_dyn_reloc (info
, r_type
))
5117 || (!bfd_link_pic (info
)
5120 /* We must copy these reloc types into the output file.
5121 Create a reloc section in dynobj and make room for
5125 sreloc
= _bfd_elf_make_dynamic_reloc_section
5126 (sec
, htab
->elf
.dynobj
, 3, abfd
, /*rela?*/ TRUE
);
5132 /* If this is a global symbol, we count the number of
5133 relocations we need for this symbol. */
5136 struct elf_dyn_relocs
*p
;
5137 struct elf_dyn_relocs
**head
;
5139 head
= &((struct ppc_link_hash_entry
*) h
)->dyn_relocs
;
5141 if (p
== NULL
|| p
->sec
!= sec
)
5143 p
= bfd_alloc (htab
->elf
.dynobj
, sizeof *p
);
5153 if (!must_be_dyn_reloc (info
, r_type
))
5158 /* Track dynamic relocs needed for local syms too.
5159 We really need local syms available to do this
5161 struct ppc_dyn_relocs
*p
;
5162 struct ppc_dyn_relocs
**head
;
5163 bfd_boolean is_ifunc
;
5166 Elf_Internal_Sym
*isym
;
5168 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
5173 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
5177 vpp
= &elf_section_data (s
)->local_dynrel
;
5178 head
= (struct ppc_dyn_relocs
**) vpp
;
5179 is_ifunc
= ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
;
5181 if (p
!= NULL
&& p
->sec
== sec
&& p
->ifunc
!= is_ifunc
)
5183 if (p
== NULL
|| p
->sec
!= sec
|| p
->ifunc
!= is_ifunc
)
5185 p
= bfd_alloc (htab
->elf
.dynobj
, sizeof *p
);
5191 p
->ifunc
= is_ifunc
;
5207 /* Merge backend specific data from an object file to the output
5208 object file when linking. */
5211 ppc64_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
5213 bfd
*obfd
= info
->output_bfd
;
5214 unsigned long iflags
, oflags
;
5216 if ((ibfd
->flags
& BFD_LINKER_CREATED
) != 0)
5219 if (!is_ppc64_elf (ibfd
) || !is_ppc64_elf (obfd
))
5222 if (!_bfd_generic_verify_endian_match (ibfd
, info
))
5225 iflags
= elf_elfheader (ibfd
)->e_flags
;
5226 oflags
= elf_elfheader (obfd
)->e_flags
;
5228 if (iflags
& ~EF_PPC64_ABI
)
5231 /* xgettext:c-format */
5232 (_("%pB uses unknown e_flags 0x%lx"), ibfd
, iflags
);
5233 bfd_set_error (bfd_error_bad_value
);
5236 else if (iflags
!= oflags
&& iflags
!= 0)
5239 /* xgettext:c-format */
5240 (_("%pB: ABI version %ld is not compatible with ABI version %ld output"),
5241 ibfd
, iflags
, oflags
);
5242 bfd_set_error (bfd_error_bad_value
);
5246 if (!_bfd_elf_ppc_merge_fp_attributes (ibfd
, info
))
5249 /* Merge Tag_compatibility attributes and any common GNU ones. */
5250 return _bfd_elf_merge_object_attributes (ibfd
, info
);
5254 ppc64_elf_print_private_bfd_data (bfd
*abfd
, void *ptr
)
5256 /* Print normal ELF private data. */
5257 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
5259 if (elf_elfheader (abfd
)->e_flags
!= 0)
5263 fprintf (file
, _("private flags = 0x%lx:"),
5264 elf_elfheader (abfd
)->e_flags
);
5266 if ((elf_elfheader (abfd
)->e_flags
& EF_PPC64_ABI
) != 0)
5267 fprintf (file
, _(" [abiv%ld]"),
5268 elf_elfheader (abfd
)->e_flags
& EF_PPC64_ABI
);
5275 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
5276 of the code entry point, and its section, which must be in the same
5277 object as OPD_SEC. Returns (bfd_vma) -1 on error. */
5280 opd_entry_value (asection
*opd_sec
,
5282 asection
**code_sec
,
5284 bfd_boolean in_code_sec
)
5286 bfd
*opd_bfd
= opd_sec
->owner
;
5287 Elf_Internal_Rela
*relocs
;
5288 Elf_Internal_Rela
*lo
, *hi
, *look
;
5291 /* No relocs implies we are linking a --just-symbols object, or looking
5292 at a final linked executable with addr2line or somesuch. */
5293 if (opd_sec
->reloc_count
== 0)
5295 bfd_byte
*contents
= ppc64_elf_tdata (opd_bfd
)->opd
.contents
;
5297 if (contents
== NULL
)
5299 if (!bfd_malloc_and_get_section (opd_bfd
, opd_sec
, &contents
))
5300 return (bfd_vma
) -1;
5301 ppc64_elf_tdata (opd_bfd
)->opd
.contents
= contents
;
5304 /* PR 17512: file: 64b9dfbb. */
5305 if (offset
+ 7 >= opd_sec
->size
|| offset
+ 7 < offset
)
5306 return (bfd_vma
) -1;
5308 val
= bfd_get_64 (opd_bfd
, contents
+ offset
);
5309 if (code_sec
!= NULL
)
5311 asection
*sec
, *likely
= NULL
;
5317 && val
< sec
->vma
+ sec
->size
)
5323 for (sec
= opd_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
5325 && (sec
->flags
& SEC_LOAD
) != 0
5326 && (sec
->flags
& SEC_ALLOC
) != 0)
5331 if (code_off
!= NULL
)
5332 *code_off
= val
- likely
->vma
;
5338 BFD_ASSERT (is_ppc64_elf (opd_bfd
));
5340 relocs
= ppc64_elf_tdata (opd_bfd
)->opd
.relocs
;
5342 relocs
= _bfd_elf_link_read_relocs (opd_bfd
, opd_sec
, NULL
, NULL
, TRUE
);
5343 /* PR 17512: file: df8e1fd6. */
5345 return (bfd_vma
) -1;
5347 /* Go find the opd reloc at the sym address. */
5349 hi
= lo
+ opd_sec
->reloc_count
- 1; /* ignore last reloc */
5353 look
= lo
+ (hi
- lo
) / 2;
5354 if (look
->r_offset
< offset
)
5356 else if (look
->r_offset
> offset
)
5360 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (opd_bfd
);
5362 if (ELF64_R_TYPE (look
->r_info
) == R_PPC64_ADDR64
5363 && ELF64_R_TYPE ((look
+ 1)->r_info
) == R_PPC64_TOC
)
5365 unsigned long symndx
= ELF64_R_SYM (look
->r_info
);
5366 asection
*sec
= NULL
;
5368 if (symndx
>= symtab_hdr
->sh_info
5369 && elf_sym_hashes (opd_bfd
) != NULL
)
5371 struct elf_link_hash_entry
**sym_hashes
;
5372 struct elf_link_hash_entry
*rh
;
5374 sym_hashes
= elf_sym_hashes (opd_bfd
);
5375 rh
= sym_hashes
[symndx
- symtab_hdr
->sh_info
];
5378 rh
= elf_follow_link (rh
);
5379 if (rh
->root
.type
!= bfd_link_hash_defined
5380 && rh
->root
.type
!= bfd_link_hash_defweak
)
5382 if (rh
->root
.u
.def
.section
->owner
== opd_bfd
)
5384 val
= rh
->root
.u
.def
.value
;
5385 sec
= rh
->root
.u
.def
.section
;
5392 Elf_Internal_Sym
*sym
;
5394 if (symndx
< symtab_hdr
->sh_info
)
5396 sym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
5399 size_t symcnt
= symtab_hdr
->sh_info
;
5400 sym
= bfd_elf_get_elf_syms (opd_bfd
, symtab_hdr
,
5405 symtab_hdr
->contents
= (bfd_byte
*) sym
;
5411 sym
= bfd_elf_get_elf_syms (opd_bfd
, symtab_hdr
,
5417 sec
= bfd_section_from_elf_index (opd_bfd
, sym
->st_shndx
);
5420 BFD_ASSERT ((sec
->flags
& SEC_MERGE
) == 0);
5421 val
= sym
->st_value
;
5424 val
+= look
->r_addend
;
5425 if (code_off
!= NULL
)
5427 if (code_sec
!= NULL
)
5429 if (in_code_sec
&& *code_sec
!= sec
)
5434 if (sec
->output_section
!= NULL
)
5435 val
+= sec
->output_section
->vma
+ sec
->output_offset
;
5444 /* If the ELF symbol SYM might be a function in SEC, return the
5445 function size and set *CODE_OFF to the function's entry point,
5446 otherwise return zero. */
5448 static bfd_size_type
5449 ppc64_elf_maybe_function_sym (const asymbol
*sym
, asection
*sec
,
5454 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_FILE
| BSF_OBJECT
5455 | BSF_THREAD_LOCAL
| BSF_RELC
| BSF_SRELC
)) != 0)
5459 if (!(sym
->flags
& BSF_SYNTHETIC
))
5460 size
= ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
5462 if (strcmp (sym
->section
->name
, ".opd") == 0)
5464 struct _opd_sec_data
*opd
= get_opd_info (sym
->section
);
5465 bfd_vma symval
= sym
->value
;
5468 && opd
->adjust
!= NULL
5469 && elf_section_data (sym
->section
)->relocs
!= NULL
)
5471 /* opd_entry_value will use cached relocs that have been
5472 adjusted, but with raw symbols. That means both local
5473 and global symbols need adjusting. */
5474 long adjust
= opd
->adjust
[OPD_NDX (symval
)];
5480 if (opd_entry_value (sym
->section
, symval
,
5481 &sec
, code_off
, TRUE
) == (bfd_vma
) -1)
5483 /* An old ABI binary with dot-syms has a size of 24 on the .opd
5484 symbol. This size has nothing to do with the code size of the
5485 function, which is what we're supposed to return, but the
5486 code size isn't available without looking up the dot-sym.
5487 However, doing that would be a waste of time particularly
5488 since elf_find_function will look at the dot-sym anyway.
5489 Now, elf_find_function will keep the largest size of any
5490 function sym found at the code address of interest, so return
5491 1 here to avoid it incorrectly caching a larger function size
5492 for a small function. This does mean we return the wrong
5493 size for a new-ABI function of size 24, but all that does is
5494 disable caching for such functions. */
5500 if (sym
->section
!= sec
)
5502 *code_off
= sym
->value
;
5509 /* Return true if symbol is a strong function defined in an ELFv2
5510 object with st_other localentry bits of zero, ie. its local entry
5511 point coincides with its global entry point. */
5514 is_elfv2_localentry0 (struct elf_link_hash_entry
*h
)
5517 && h
->type
== STT_FUNC
5518 && h
->root
.type
== bfd_link_hash_defined
5519 && (STO_PPC64_LOCAL_MASK
& h
->other
) == 0
5520 && !((struct ppc_link_hash_entry
*) h
)->non_zero_localentry
5521 && is_ppc64_elf (h
->root
.u
.def
.section
->owner
)
5522 && abiversion (h
->root
.u
.def
.section
->owner
) >= 2);
5525 /* Return true if symbol is defined in a regular object file. */
5528 is_static_defined (struct elf_link_hash_entry
*h
)
5530 return ((h
->root
.type
== bfd_link_hash_defined
5531 || h
->root
.type
== bfd_link_hash_defweak
)
5532 && h
->root
.u
.def
.section
!= NULL
5533 && h
->root
.u
.def
.section
->output_section
!= NULL
);
5536 /* If FDH is a function descriptor symbol, return the associated code
5537 entry symbol if it is defined. Return NULL otherwise. */
5539 static struct ppc_link_hash_entry
*
5540 defined_code_entry (struct ppc_link_hash_entry
*fdh
)
5542 if (fdh
->is_func_descriptor
)
5544 struct ppc_link_hash_entry
*fh
= ppc_follow_link (fdh
->oh
);
5545 if (fh
->elf
.root
.type
== bfd_link_hash_defined
5546 || fh
->elf
.root
.type
== bfd_link_hash_defweak
)
5552 /* If FH is a function code entry symbol, return the associated
5553 function descriptor symbol if it is defined. Return NULL otherwise. */
5555 static struct ppc_link_hash_entry
*
5556 defined_func_desc (struct ppc_link_hash_entry
*fh
)
5559 && fh
->oh
->is_func_descriptor
)
5561 struct ppc_link_hash_entry
*fdh
= ppc_follow_link (fh
->oh
);
5562 if (fdh
->elf
.root
.type
== bfd_link_hash_defined
5563 || fdh
->elf
.root
.type
== bfd_link_hash_defweak
)
5569 static bfd_boolean
func_desc_adjust (struct elf_link_hash_entry
*, void *);
5571 /* Garbage collect sections, after first dealing with dot-symbols. */
5574 ppc64_elf_gc_sections (bfd
*abfd
, struct bfd_link_info
*info
)
5576 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
5578 if (htab
!= NULL
&& htab
->need_func_desc_adj
)
5580 elf_link_hash_traverse (&htab
->elf
, func_desc_adjust
, info
);
5581 htab
->need_func_desc_adj
= 0;
5583 return bfd_elf_gc_sections (abfd
, info
);
5586 /* Mark all our entry sym sections, both opd and code section. */
5589 ppc64_elf_gc_keep (struct bfd_link_info
*info
)
5591 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
5592 struct bfd_sym_chain
*sym
;
5597 for (sym
= info
->gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
5599 struct ppc_link_hash_entry
*eh
, *fh
;
5602 eh
= (struct ppc_link_hash_entry
*)
5603 elf_link_hash_lookup (&htab
->elf
, sym
->name
, FALSE
, FALSE
, TRUE
);
5606 if (eh
->elf
.root
.type
!= bfd_link_hash_defined
5607 && eh
->elf
.root
.type
!= bfd_link_hash_defweak
)
5610 fh
= defined_code_entry (eh
);
5613 sec
= fh
->elf
.root
.u
.def
.section
;
5614 sec
->flags
|= SEC_KEEP
;
5616 else if (get_opd_info (eh
->elf
.root
.u
.def
.section
) != NULL
5617 && opd_entry_value (eh
->elf
.root
.u
.def
.section
,
5618 eh
->elf
.root
.u
.def
.value
,
5619 &sec
, NULL
, FALSE
) != (bfd_vma
) -1)
5620 sec
->flags
|= SEC_KEEP
;
5622 sec
= eh
->elf
.root
.u
.def
.section
;
5623 sec
->flags
|= SEC_KEEP
;
5627 /* Mark sections containing dynamically referenced symbols. When
5628 building shared libraries, we must assume that any visible symbol is
5632 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry
*h
, void *inf
)
5634 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
5635 struct ppc_link_hash_entry
*eh
= (struct ppc_link_hash_entry
*) h
;
5636 struct ppc_link_hash_entry
*fdh
;
5637 struct bfd_elf_dynamic_list
*d
= info
->dynamic_list
;
5639 /* Dynamic linking info is on the func descriptor sym. */
5640 fdh
= defined_func_desc (eh
);
5644 if ((eh
->elf
.root
.type
== bfd_link_hash_defined
5645 || eh
->elf
.root
.type
== bfd_link_hash_defweak
)
5646 && ((eh
->elf
.ref_dynamic
&& !eh
->elf
.forced_local
)
5647 || ((eh
->elf
.def_regular
|| ELF_COMMON_DEF_P (&eh
->elf
))
5648 && ELF_ST_VISIBILITY (eh
->elf
.other
) != STV_INTERNAL
5649 && ELF_ST_VISIBILITY (eh
->elf
.other
) != STV_HIDDEN
5650 && (!bfd_link_executable (info
)
5651 || info
->gc_keep_exported
5652 || info
->export_dynamic
5655 && (*d
->match
) (&d
->head
, NULL
,
5656 eh
->elf
.root
.root
.string
)))
5657 && (eh
->elf
.versioned
>= versioned
5658 || !bfd_hide_sym_by_version (info
->version_info
,
5659 eh
->elf
.root
.root
.string
)))))
5662 struct ppc_link_hash_entry
*fh
;
5664 eh
->elf
.root
.u
.def
.section
->flags
|= SEC_KEEP
;
5666 /* Function descriptor syms cause the associated
5667 function code sym section to be marked. */
5668 fh
= defined_code_entry (eh
);
5671 code_sec
= fh
->elf
.root
.u
.def
.section
;
5672 code_sec
->flags
|= SEC_KEEP
;
5674 else if (get_opd_info (eh
->elf
.root
.u
.def
.section
) != NULL
5675 && opd_entry_value (eh
->elf
.root
.u
.def
.section
,
5676 eh
->elf
.root
.u
.def
.value
,
5677 &code_sec
, NULL
, FALSE
) != (bfd_vma
) -1)
5678 code_sec
->flags
|= SEC_KEEP
;
5684 /* Return the section that should be marked against GC for a given
5688 ppc64_elf_gc_mark_hook (asection
*sec
,
5689 struct bfd_link_info
*info
,
5690 Elf_Internal_Rela
*rel
,
5691 struct elf_link_hash_entry
*h
,
5692 Elf_Internal_Sym
*sym
)
5696 /* Syms return NULL if we're marking .opd, so we avoid marking all
5697 function sections, as all functions are referenced in .opd. */
5699 if (get_opd_info (sec
) != NULL
)
5704 enum elf_ppc64_reloc_type r_type
;
5705 struct ppc_link_hash_entry
*eh
, *fh
, *fdh
;
5707 r_type
= ELF64_R_TYPE (rel
->r_info
);
5710 case R_PPC64_GNU_VTINHERIT
:
5711 case R_PPC64_GNU_VTENTRY
:
5715 switch (h
->root
.type
)
5717 case bfd_link_hash_defined
:
5718 case bfd_link_hash_defweak
:
5719 eh
= (struct ppc_link_hash_entry
*) h
;
5720 fdh
= defined_func_desc (eh
);
5723 /* -mcall-aixdesc code references the dot-symbol on
5724 a call reloc. Mark the function descriptor too
5725 against garbage collection. */
5727 if (fdh
->elf
.is_weakalias
)
5728 weakdef (&fdh
->elf
)->mark
= 1;
5732 /* Function descriptor syms cause the associated
5733 function code sym section to be marked. */
5734 fh
= defined_code_entry (eh
);
5737 /* They also mark their opd section. */
5738 eh
->elf
.root
.u
.def
.section
->gc_mark
= 1;
5740 rsec
= fh
->elf
.root
.u
.def
.section
;
5742 else if (get_opd_info (eh
->elf
.root
.u
.def
.section
) != NULL
5743 && opd_entry_value (eh
->elf
.root
.u
.def
.section
,
5744 eh
->elf
.root
.u
.def
.value
,
5745 &rsec
, NULL
, FALSE
) != (bfd_vma
) -1)
5746 eh
->elf
.root
.u
.def
.section
->gc_mark
= 1;
5748 rsec
= h
->root
.u
.def
.section
;
5751 case bfd_link_hash_common
:
5752 rsec
= h
->root
.u
.c
.p
->section
;
5756 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
5762 struct _opd_sec_data
*opd
;
5764 rsec
= bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
5765 opd
= get_opd_info (rsec
);
5766 if (opd
!= NULL
&& opd
->func_sec
!= NULL
)
5770 rsec
= opd
->func_sec
[OPD_NDX (sym
->st_value
+ rel
->r_addend
)];
5777 /* The maximum size of .sfpr. */
5778 #define SFPR_MAX (218*4)
5780 struct sfpr_def_parms
5782 const char name
[12];
5783 unsigned char lo
, hi
;
5784 bfd_byte
*(*write_ent
) (bfd
*, bfd_byte
*, int);
5785 bfd_byte
*(*write_tail
) (bfd
*, bfd_byte
*, int);
5788 /* Auto-generate _save*, _rest* functions in .sfpr.
5789 If STUB_SEC is non-null, define alias symbols in STUB_SEC
5793 sfpr_define (struct bfd_link_info
*info
,
5794 const struct sfpr_def_parms
*parm
,
5797 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
5799 size_t len
= strlen (parm
->name
);
5800 bfd_boolean writing
= FALSE
;
5806 memcpy (sym
, parm
->name
, len
);
5809 for (i
= parm
->lo
; i
<= parm
->hi
; i
++)
5811 struct ppc_link_hash_entry
*h
;
5813 sym
[len
+ 0] = i
/ 10 + '0';
5814 sym
[len
+ 1] = i
% 10 + '0';
5815 h
= (struct ppc_link_hash_entry
*)
5816 elf_link_hash_lookup (&htab
->elf
, sym
, writing
, TRUE
, TRUE
);
5817 if (stub_sec
!= NULL
)
5820 && h
->elf
.root
.type
== bfd_link_hash_defined
5821 && h
->elf
.root
.u
.def
.section
== htab
->sfpr
)
5823 struct elf_link_hash_entry
*s
;
5825 sprintf (buf
, "%08x.%s", stub_sec
->id
& 0xffffffff, sym
);
5826 s
= elf_link_hash_lookup (&htab
->elf
, buf
, TRUE
, TRUE
, FALSE
);
5829 if (s
->root
.type
== bfd_link_hash_new
5830 || (s
->root
.type
= bfd_link_hash_defined
5831 && s
->root
.u
.def
.section
== stub_sec
))
5833 s
->root
.type
= bfd_link_hash_defined
;
5834 s
->root
.u
.def
.section
= stub_sec
;
5835 s
->root
.u
.def
.value
= (stub_sec
->size
- htab
->sfpr
->size
5836 + h
->elf
.root
.u
.def
.value
);
5839 s
->ref_regular_nonweak
= 1;
5840 s
->forced_local
= 1;
5842 s
->root
.linker_def
= 1;
5850 if (!h
->elf
.def_regular
)
5852 h
->elf
.root
.type
= bfd_link_hash_defined
;
5853 h
->elf
.root
.u
.def
.section
= htab
->sfpr
;
5854 h
->elf
.root
.u
.def
.value
= htab
->sfpr
->size
;
5855 h
->elf
.type
= STT_FUNC
;
5856 h
->elf
.def_regular
= 1;
5858 _bfd_elf_link_hash_hide_symbol (info
, &h
->elf
, TRUE
);
5860 if (htab
->sfpr
->contents
== NULL
)
5862 htab
->sfpr
->contents
5863 = bfd_alloc (htab
->elf
.dynobj
, SFPR_MAX
);
5864 if (htab
->sfpr
->contents
== NULL
)
5871 bfd_byte
*p
= htab
->sfpr
->contents
+ htab
->sfpr
->size
;
5873 p
= (*parm
->write_ent
) (htab
->elf
.dynobj
, p
, i
);
5875 p
= (*parm
->write_tail
) (htab
->elf
.dynobj
, p
, i
);
5876 htab
->sfpr
->size
= p
- htab
->sfpr
->contents
;
5884 savegpr0 (bfd
*abfd
, bfd_byte
*p
, int r
)
5886 bfd_put_32 (abfd
, STD_R0_0R1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5891 savegpr0_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5893 p
= savegpr0 (abfd
, p
, r
);
5894 bfd_put_32 (abfd
, STD_R0_0R1
+ STK_LR
, p
);
5896 bfd_put_32 (abfd
, BLR
, p
);
5901 restgpr0 (bfd
*abfd
, bfd_byte
*p
, int r
)
5903 bfd_put_32 (abfd
, LD_R0_0R1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5908 restgpr0_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5910 bfd_put_32 (abfd
, LD_R0_0R1
+ STK_LR
, p
);
5912 p
= restgpr0 (abfd
, p
, r
);
5913 bfd_put_32 (abfd
, MTLR_R0
, p
);
5917 p
= restgpr0 (abfd
, p
, 30);
5918 p
= restgpr0 (abfd
, p
, 31);
5920 bfd_put_32 (abfd
, BLR
, p
);
5925 savegpr1 (bfd
*abfd
, bfd_byte
*p
, int r
)
5927 bfd_put_32 (abfd
, STD_R0_0R12
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5932 savegpr1_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5934 p
= savegpr1 (abfd
, p
, r
);
5935 bfd_put_32 (abfd
, BLR
, p
);
5940 restgpr1 (bfd
*abfd
, bfd_byte
*p
, int r
)
5942 bfd_put_32 (abfd
, LD_R0_0R12
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5947 restgpr1_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5949 p
= restgpr1 (abfd
, p
, r
);
5950 bfd_put_32 (abfd
, BLR
, p
);
5955 savefpr (bfd
*abfd
, bfd_byte
*p
, int r
)
5957 bfd_put_32 (abfd
, STFD_FR0_0R1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5962 savefpr0_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5964 p
= savefpr (abfd
, p
, r
);
5965 bfd_put_32 (abfd
, STD_R0_0R1
+ STK_LR
, p
);
5967 bfd_put_32 (abfd
, BLR
, p
);
5972 restfpr (bfd
*abfd
, bfd_byte
*p
, int r
)
5974 bfd_put_32 (abfd
, LFD_FR0_0R1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5979 restfpr0_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5981 bfd_put_32 (abfd
, LD_R0_0R1
+ STK_LR
, p
);
5983 p
= restfpr (abfd
, p
, r
);
5984 bfd_put_32 (abfd
, MTLR_R0
, p
);
5988 p
= restfpr (abfd
, p
, 30);
5989 p
= restfpr (abfd
, p
, 31);
5991 bfd_put_32 (abfd
, BLR
, p
);
5996 savefpr1_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5998 p
= savefpr (abfd
, p
, r
);
5999 bfd_put_32 (abfd
, BLR
, p
);
6004 restfpr1_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6006 p
= restfpr (abfd
, p
, r
);
6007 bfd_put_32 (abfd
, BLR
, p
);
6012 savevr (bfd
*abfd
, bfd_byte
*p
, int r
)
6014 bfd_put_32 (abfd
, LI_R12_0
+ (1 << 16) - (32 - r
) * 16, p
);
6016 bfd_put_32 (abfd
, STVX_VR0_R12_R0
+ (r
<< 21), p
);
6021 savevr_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6023 p
= savevr (abfd
, p
, r
);
6024 bfd_put_32 (abfd
, BLR
, p
);
6029 restvr (bfd
*abfd
, bfd_byte
*p
, int r
)
6031 bfd_put_32 (abfd
, LI_R12_0
+ (1 << 16) - (32 - r
) * 16, p
);
6033 bfd_put_32 (abfd
, LVX_VR0_R12_R0
+ (r
<< 21), p
);
6038 restvr_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6040 p
= restvr (abfd
, p
, r
);
6041 bfd_put_32 (abfd
, BLR
, p
);
6045 /* Called via elf_link_hash_traverse to transfer dynamic linking
6046 information on function code symbol entries to their corresponding
6047 function descriptor symbol entries. */
6050 func_desc_adjust (struct elf_link_hash_entry
*h
, void *inf
)
6052 struct bfd_link_info
*info
;
6053 struct ppc_link_hash_table
*htab
;
6054 struct ppc_link_hash_entry
*fh
;
6055 struct ppc_link_hash_entry
*fdh
;
6056 bfd_boolean force_local
;
6058 fh
= (struct ppc_link_hash_entry
*) h
;
6059 if (fh
->elf
.root
.type
== bfd_link_hash_indirect
)
6065 if (fh
->elf
.root
.root
.string
[0] != '.'
6066 || fh
->elf
.root
.root
.string
[1] == '\0')
6070 htab
= ppc_hash_table (info
);
6074 /* Find the corresponding function descriptor symbol. */
6075 fdh
= lookup_fdh (fh
, htab
);
6077 /* Resolve undefined references to dot-symbols as the value
6078 in the function descriptor, if we have one in a regular object.
6079 This is to satisfy cases like ".quad .foo". Calls to functions
6080 in dynamic objects are handled elsewhere. */
6081 if ((fh
->elf
.root
.type
== bfd_link_hash_undefined
6082 || fh
->elf
.root
.type
== bfd_link_hash_undefweak
)
6083 && (fdh
->elf
.root
.type
== bfd_link_hash_defined
6084 || fdh
->elf
.root
.type
== bfd_link_hash_defweak
)
6085 && get_opd_info (fdh
->elf
.root
.u
.def
.section
) != NULL
6086 && opd_entry_value (fdh
->elf
.root
.u
.def
.section
,
6087 fdh
->elf
.root
.u
.def
.value
,
6088 &fh
->elf
.root
.u
.def
.section
,
6089 &fh
->elf
.root
.u
.def
.value
, FALSE
) != (bfd_vma
) -1)
6091 fh
->elf
.root
.type
= fdh
->elf
.root
.type
;
6092 fh
->elf
.forced_local
= 1;
6093 fh
->elf
.def_regular
= fdh
->elf
.def_regular
;
6094 fh
->elf
.def_dynamic
= fdh
->elf
.def_dynamic
;
6097 if (!fh
->elf
.dynamic
)
6099 struct plt_entry
*ent
;
6101 for (ent
= fh
->elf
.plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
6102 if (ent
->plt
.refcount
> 0)
6108 /* Create a descriptor as undefined if necessary. */
6110 && !bfd_link_executable (info
)
6111 && (fh
->elf
.root
.type
== bfd_link_hash_undefined
6112 || fh
->elf
.root
.type
== bfd_link_hash_undefweak
))
6114 fdh
= make_fdh (info
, fh
);
6119 /* We can't support overriding of symbols on a fake descriptor. */
6122 && (fh
->elf
.root
.type
== bfd_link_hash_defined
6123 || fh
->elf
.root
.type
== bfd_link_hash_defweak
))
6124 _bfd_elf_link_hash_hide_symbol (info
, &fdh
->elf
, TRUE
);
6126 /* Transfer dynamic linking information to the function descriptor. */
6129 fdh
->elf
.ref_regular
|= fh
->elf
.ref_regular
;
6130 fdh
->elf
.ref_dynamic
|= fh
->elf
.ref_dynamic
;
6131 fdh
->elf
.ref_regular_nonweak
|= fh
->elf
.ref_regular_nonweak
;
6132 fdh
->elf
.non_got_ref
|= fh
->elf
.non_got_ref
;
6133 fdh
->elf
.dynamic
|= fh
->elf
.dynamic
;
6134 fdh
->elf
.needs_plt
|= (fh
->elf
.needs_plt
6135 || fh
->elf
.type
== STT_FUNC
6136 || fh
->elf
.type
== STT_GNU_IFUNC
);
6137 move_plt_plist (fh
, fdh
);
6139 if (!fdh
->elf
.forced_local
6140 && fh
->elf
.dynindx
!= -1)
6141 if (!bfd_elf_link_record_dynamic_symbol (info
, &fdh
->elf
))
6145 /* Now that the info is on the function descriptor, clear the
6146 function code sym info. Any function code syms for which we
6147 don't have a definition in a regular file, we force local.
6148 This prevents a shared library from exporting syms that have
6149 been imported from another library. Function code syms that
6150 are really in the library we must leave global to prevent the
6151 linker dragging in a definition from a static library. */
6152 force_local
= (!fh
->elf
.def_regular
6154 || !fdh
->elf
.def_regular
6155 || fdh
->elf
.forced_local
);
6156 _bfd_elf_link_hash_hide_symbol (info
, &fh
->elf
, force_local
);
6161 static const struct sfpr_def_parms save_res_funcs
[] =
6163 { "_savegpr0_", 14, 31, savegpr0
, savegpr0_tail
},
6164 { "_restgpr0_", 14, 29, restgpr0
, restgpr0_tail
},
6165 { "_restgpr0_", 30, 31, restgpr0
, restgpr0_tail
},
6166 { "_savegpr1_", 14, 31, savegpr1
, savegpr1_tail
},
6167 { "_restgpr1_", 14, 31, restgpr1
, restgpr1_tail
},
6168 { "_savefpr_", 14, 31, savefpr
, savefpr0_tail
},
6169 { "_restfpr_", 14, 29, restfpr
, restfpr0_tail
},
6170 { "_restfpr_", 30, 31, restfpr
, restfpr0_tail
},
6171 { "._savef", 14, 31, savefpr
, savefpr1_tail
},
6172 { "._restf", 14, 31, restfpr
, restfpr1_tail
},
6173 { "_savevr_", 20, 31, savevr
, savevr_tail
},
6174 { "_restvr_", 20, 31, restvr
, restvr_tail
}
6177 /* Called near the start of bfd_elf_size_dynamic_sections. We use
6178 this hook to a) provide some gcc support functions, and b) transfer
6179 dynamic linking information gathered so far on function code symbol
6180 entries, to their corresponding function descriptor symbol entries. */
6183 ppc64_elf_func_desc_adjust (bfd
*obfd ATTRIBUTE_UNUSED
,
6184 struct bfd_link_info
*info
)
6186 struct ppc_link_hash_table
*htab
;
6188 htab
= ppc_hash_table (info
);
6192 /* Provide any missing _save* and _rest* functions. */
6193 if (htab
->sfpr
!= NULL
)
6197 htab
->sfpr
->size
= 0;
6198 for (i
= 0; i
< ARRAY_SIZE (save_res_funcs
); i
++)
6199 if (!sfpr_define (info
, &save_res_funcs
[i
], NULL
))
6201 if (htab
->sfpr
->size
== 0)
6202 htab
->sfpr
->flags
|= SEC_EXCLUDE
;
6205 if (bfd_link_relocatable (info
))
6208 if (htab
->elf
.hgot
!= NULL
)
6210 _bfd_elf_link_hash_hide_symbol (info
, htab
->elf
.hgot
, TRUE
);
6211 /* Make .TOC. defined so as to prevent it being made dynamic.
6212 The wrong value here is fixed later in ppc64_elf_set_toc. */
6213 if (!htab
->elf
.hgot
->def_regular
6214 || htab
->elf
.hgot
->root
.type
!= bfd_link_hash_defined
)
6216 htab
->elf
.hgot
->root
.type
= bfd_link_hash_defined
;
6217 htab
->elf
.hgot
->root
.u
.def
.value
= 0;
6218 htab
->elf
.hgot
->root
.u
.def
.section
= bfd_abs_section_ptr
;
6219 htab
->elf
.hgot
->def_regular
= 1;
6220 htab
->elf
.hgot
->root
.linker_def
= 1;
6222 htab
->elf
.hgot
->type
= STT_OBJECT
;
6223 htab
->elf
.hgot
->other
6224 = (htab
->elf
.hgot
->other
& ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN
;
6227 if (htab
->need_func_desc_adj
)
6229 elf_link_hash_traverse (&htab
->elf
, func_desc_adjust
, info
);
6230 htab
->need_func_desc_adj
= 0;
6236 /* Find dynamic relocs for H that apply to read-only sections. */
6239 readonly_dynrelocs (struct elf_link_hash_entry
*h
)
6241 struct ppc_link_hash_entry
*eh
;
6242 struct elf_dyn_relocs
*p
;
6244 eh
= (struct ppc_link_hash_entry
*) h
;
6245 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
6247 asection
*s
= p
->sec
->output_section
;
6249 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
6255 /* Return true if we have dynamic relocs against H or any of its weak
6256 aliases, that apply to read-only sections. Cannot be used after
6257 size_dynamic_sections. */
6260 alias_readonly_dynrelocs (struct elf_link_hash_entry
*h
)
6262 struct ppc_link_hash_entry
*eh
;
6264 eh
= (struct ppc_link_hash_entry
*) h
;
6267 if (readonly_dynrelocs (&eh
->elf
))
6269 eh
= (struct ppc_link_hash_entry
*) eh
->elf
.u
.alias
;
6271 while (eh
!= NULL
&& &eh
->elf
!= h
);
6276 /* Return whether EH has pc-relative dynamic relocs. */
6279 pc_dynrelocs (struct ppc_link_hash_entry
*eh
)
6281 struct elf_dyn_relocs
*p
;
6283 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
6284 if (p
->pc_count
!= 0)
6289 /* Return true if a global entry stub will be created for H. Valid
6290 for ELFv2 before plt entries have been allocated. */
6293 global_entry_stub (struct elf_link_hash_entry
*h
)
6295 struct plt_entry
*pent
;
6297 if (!h
->pointer_equality_needed
6301 for (pent
= h
->plt
.plist
; pent
!= NULL
; pent
= pent
->next
)
6302 if (pent
->plt
.refcount
> 0
6303 && pent
->addend
== 0)
6309 /* Adjust a symbol defined by a dynamic object and referenced by a
6310 regular object. The current definition is in some section of the
6311 dynamic object, but we're not including those sections. We have to
6312 change the definition to something the rest of the link can
6316 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
6317 struct elf_link_hash_entry
*h
)
6319 struct ppc_link_hash_table
*htab
;
6322 htab
= ppc_hash_table (info
);
6326 /* Deal with function syms. */
6327 if (h
->type
== STT_FUNC
6328 || h
->type
== STT_GNU_IFUNC
6331 bfd_boolean local
= (((struct ppc_link_hash_entry
*) h
)->save_res
6332 || SYMBOL_CALLS_LOCAL (info
, h
)
6333 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
));
6334 /* Discard dyn_relocs when non-pic if we've decided that a
6335 function symbol is local and not an ifunc. We keep dynamic
6336 relocs for ifuncs when local rather than always emitting a
6337 plt call stub for them and defining the symbol on the call
6338 stub. We can't do that for ELFv1 anyway (a function symbol
6339 is defined on a descriptor, not code) and it can be faster at
6340 run-time due to not needing to bounce through a stub. The
6341 dyn_relocs for ifuncs will be applied even in a static
6343 if (!bfd_link_pic (info
)
6344 && h
->type
!= STT_GNU_IFUNC
6346 ((struct ppc_link_hash_entry
*) h
)->dyn_relocs
= NULL
;
6348 /* Clear procedure linkage table information for any symbol that
6349 won't need a .plt entry. */
6350 struct plt_entry
*ent
;
6351 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
6352 if (ent
->plt
.refcount
> 0)
6355 || (h
->type
!= STT_GNU_IFUNC
6357 && (htab
->can_convert_all_inline_plt
6358 || (((struct ppc_link_hash_entry
*) h
)->tls_mask
6359 & (TLS_TLS
| PLT_KEEP
)) != PLT_KEEP
)))
6361 h
->plt
.plist
= NULL
;
6363 h
->pointer_equality_needed
= 0;
6365 else if (abiversion (info
->output_bfd
) >= 2)
6367 /* Taking a function's address in a read/write section
6368 doesn't require us to define the function symbol in the
6369 executable on a global entry stub. A dynamic reloc can
6370 be used instead. The reason we prefer a few more dynamic
6371 relocs is that calling via a global entry stub costs a
6372 few more instructions, and pointer_equality_needed causes
6373 extra work in ld.so when resolving these symbols. */
6374 if (global_entry_stub (h
))
6376 if (!readonly_dynrelocs (h
))
6378 h
->pointer_equality_needed
= 0;
6379 /* If we haven't seen a branch reloc and the symbol
6380 isn't an ifunc then we don't need a plt entry. */
6382 h
->plt
.plist
= NULL
;
6384 else if (!bfd_link_pic (info
))
6385 /* We are going to be defining the function symbol on the
6386 plt stub, so no dyn_relocs needed when non-pic. */
6387 ((struct ppc_link_hash_entry
*) h
)->dyn_relocs
= NULL
;
6390 /* ELFv2 function symbols can't have copy relocs. */
6393 else if (!h
->needs_plt
6394 && !readonly_dynrelocs (h
))
6396 /* If we haven't seen a branch reloc and the symbol isn't an
6397 ifunc then we don't need a plt entry. */
6398 h
->plt
.plist
= NULL
;
6399 h
->pointer_equality_needed
= 0;
6404 h
->plt
.plist
= NULL
;
6406 /* If this is a weak symbol, and there is a real definition, the
6407 processor independent code will have arranged for us to see the
6408 real definition first, and we can just use the same value. */
6409 if (h
->is_weakalias
)
6411 struct elf_link_hash_entry
*def
= weakdef (h
);
6412 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
6413 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
6414 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
6415 if (def
->root
.u
.def
.section
== htab
->elf
.sdynbss
6416 || def
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
6417 ((struct ppc_link_hash_entry
*) h
)->dyn_relocs
= NULL
;
6421 /* If we are creating a shared library, we must presume that the
6422 only references to the symbol are via the global offset table.
6423 For such cases we need not do anything here; the relocations will
6424 be handled correctly by relocate_section. */
6425 if (!bfd_link_executable (info
))
6428 /* If there are no references to this symbol that do not use the
6429 GOT, we don't need to generate a copy reloc. */
6430 if (!h
->non_got_ref
)
6433 /* Don't generate a copy reloc for symbols defined in the executable. */
6434 if (!h
->def_dynamic
|| !h
->ref_regular
|| h
->def_regular
6436 /* If -z nocopyreloc was given, don't generate them either. */
6437 || info
->nocopyreloc
6439 /* If we don't find any dynamic relocs in read-only sections, then
6440 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
6441 || (ELIMINATE_COPY_RELOCS
6443 && !alias_readonly_dynrelocs (h
))
6445 /* Protected variables do not work with .dynbss. The copy in
6446 .dynbss won't be used by the shared library with the protected
6447 definition for the variable. Text relocations are preferable
6448 to an incorrect program. */
6449 || h
->protected_def
)
6452 if (h
->plt
.plist
!= NULL
)
6454 /* We should never get here, but unfortunately there are versions
6455 of gcc out there that improperly (for this ABI) put initialized
6456 function pointers, vtable refs and suchlike in read-only
6457 sections. Allow them to proceed, but warn that this might
6458 break at runtime. */
6459 info
->callbacks
->einfo
6460 (_("%P: copy reloc against `%pT' requires lazy plt linking; "
6461 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
6462 h
->root
.root
.string
);
6465 /* This is a reference to a symbol defined by a dynamic object which
6466 is not a function. */
6468 /* We must allocate the symbol in our .dynbss section, which will
6469 become part of the .bss section of the executable. There will be
6470 an entry for this symbol in the .dynsym section. The dynamic
6471 object will contain position independent code, so all references
6472 from the dynamic object to this symbol will go through the global
6473 offset table. The dynamic linker will use the .dynsym entry to
6474 determine the address it must put in the global offset table, so
6475 both the dynamic object and the regular object will refer to the
6476 same memory location for the variable. */
6477 if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
6479 s
= htab
->elf
.sdynrelro
;
6480 srel
= htab
->elf
.sreldynrelro
;
6484 s
= htab
->elf
.sdynbss
;
6485 srel
= htab
->elf
.srelbss
;
6487 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
6489 /* We must generate a R_PPC64_COPY reloc to tell the dynamic
6490 linker to copy the initial value out of the dynamic object
6491 and into the runtime process image. */
6492 srel
->size
+= sizeof (Elf64_External_Rela
);
6496 /* We no longer want dyn_relocs. */
6497 ((struct ppc_link_hash_entry
*) h
)->dyn_relocs
= NULL
;
6498 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
6501 /* If given a function descriptor symbol, hide both the function code
6502 sym and the descriptor. */
6504 ppc64_elf_hide_symbol (struct bfd_link_info
*info
,
6505 struct elf_link_hash_entry
*h
,
6506 bfd_boolean force_local
)
6508 struct ppc_link_hash_entry
*eh
;
6509 _bfd_elf_link_hash_hide_symbol (info
, h
, force_local
);
6511 if (ppc_hash_table (info
) == NULL
)
6514 eh
= (struct ppc_link_hash_entry
*) h
;
6515 if (eh
->is_func_descriptor
)
6517 struct ppc_link_hash_entry
*fh
= eh
->oh
;
6522 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
6525 /* We aren't supposed to use alloca in BFD because on
6526 systems which do not have alloca the version in libiberty
6527 calls xmalloc, which might cause the program to crash
6528 when it runs out of memory. This function doesn't have a
6529 return status, so there's no way to gracefully return an
6530 error. So cheat. We know that string[-1] can be safely
6531 accessed; It's either a string in an ELF string table,
6532 or allocated in an objalloc structure. */
6534 p
= eh
->elf
.root
.root
.string
- 1;
6537 fh
= (struct ppc_link_hash_entry
*)
6538 elf_link_hash_lookup (htab
, p
, FALSE
, FALSE
, FALSE
);
6541 /* Unfortunately, if it so happens that the string we were
6542 looking for was allocated immediately before this string,
6543 then we overwrote the string terminator. That's the only
6544 reason the lookup should fail. */
6547 q
= eh
->elf
.root
.root
.string
+ strlen (eh
->elf
.root
.root
.string
);
6548 while (q
>= eh
->elf
.root
.root
.string
&& *q
== *p
)
6550 if (q
< eh
->elf
.root
.root
.string
&& *p
== '.')
6551 fh
= (struct ppc_link_hash_entry
*)
6552 elf_link_hash_lookup (htab
, p
, FALSE
, FALSE
, FALSE
);
6561 _bfd_elf_link_hash_hide_symbol (info
, &fh
->elf
, force_local
);
6566 get_sym_h (struct elf_link_hash_entry
**hp
,
6567 Elf_Internal_Sym
**symp
,
6569 unsigned char **tls_maskp
,
6570 Elf_Internal_Sym
**locsymsp
,
6571 unsigned long r_symndx
,
6574 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (ibfd
);
6576 if (r_symndx
>= symtab_hdr
->sh_info
)
6578 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (ibfd
);
6579 struct elf_link_hash_entry
*h
;
6581 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
6582 h
= elf_follow_link (h
);
6590 if (symsecp
!= NULL
)
6592 asection
*symsec
= NULL
;
6593 if (h
->root
.type
== bfd_link_hash_defined
6594 || h
->root
.type
== bfd_link_hash_defweak
)
6595 symsec
= h
->root
.u
.def
.section
;
6599 if (tls_maskp
!= NULL
)
6601 struct ppc_link_hash_entry
*eh
;
6603 eh
= (struct ppc_link_hash_entry
*) h
;
6604 *tls_maskp
= &eh
->tls_mask
;
6609 Elf_Internal_Sym
*sym
;
6610 Elf_Internal_Sym
*locsyms
= *locsymsp
;
6612 if (locsyms
== NULL
)
6614 locsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
6615 if (locsyms
== NULL
)
6616 locsyms
= bfd_elf_get_elf_syms (ibfd
, symtab_hdr
,
6617 symtab_hdr
->sh_info
,
6618 0, NULL
, NULL
, NULL
);
6619 if (locsyms
== NULL
)
6621 *locsymsp
= locsyms
;
6623 sym
= locsyms
+ r_symndx
;
6631 if (symsecp
!= NULL
)
6632 *symsecp
= bfd_section_from_elf_index (ibfd
, sym
->st_shndx
);
6634 if (tls_maskp
!= NULL
)
6636 struct got_entry
**lgot_ents
;
6637 unsigned char *tls_mask
;
6640 lgot_ents
= elf_local_got_ents (ibfd
);
6641 if (lgot_ents
!= NULL
)
6643 struct plt_entry
**local_plt
= (struct plt_entry
**)
6644 (lgot_ents
+ symtab_hdr
->sh_info
);
6645 unsigned char *lgot_masks
= (unsigned char *)
6646 (local_plt
+ symtab_hdr
->sh_info
);
6647 tls_mask
= &lgot_masks
[r_symndx
];
6649 *tls_maskp
= tls_mask
;
6655 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
6656 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
6657 type suitable for optimization, and 1 otherwise. */
6660 get_tls_mask (unsigned char **tls_maskp
,
6661 unsigned long *toc_symndx
,
6662 bfd_vma
*toc_addend
,
6663 Elf_Internal_Sym
**locsymsp
,
6664 const Elf_Internal_Rela
*rel
,
6667 unsigned long r_symndx
;
6669 struct elf_link_hash_entry
*h
;
6670 Elf_Internal_Sym
*sym
;
6674 r_symndx
= ELF64_R_SYM (rel
->r_info
);
6675 if (!get_sym_h (&h
, &sym
, &sec
, tls_maskp
, locsymsp
, r_symndx
, ibfd
))
6678 if ((*tls_maskp
!= NULL
6679 && (**tls_maskp
& TLS_TLS
) != 0
6680 && **tls_maskp
!= (TLS_TLS
| TLS_MARK
))
6682 || ppc64_elf_section_data (sec
) == NULL
6683 || ppc64_elf_section_data (sec
)->sec_type
!= sec_toc
)
6686 /* Look inside a TOC section too. */
6689 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
);
6690 off
= h
->root
.u
.def
.value
;
6693 off
= sym
->st_value
;
6694 off
+= rel
->r_addend
;
6695 BFD_ASSERT (off
% 8 == 0);
6696 r_symndx
= ppc64_elf_section_data (sec
)->u
.toc
.symndx
[off
/ 8];
6697 next_r
= ppc64_elf_section_data (sec
)->u
.toc
.symndx
[off
/ 8 + 1];
6698 if (toc_symndx
!= NULL
)
6699 *toc_symndx
= r_symndx
;
6700 if (toc_addend
!= NULL
)
6701 *toc_addend
= ppc64_elf_section_data (sec
)->u
.toc
.add
[off
/ 8];
6702 if (!get_sym_h (&h
, &sym
, &sec
, tls_maskp
, locsymsp
, r_symndx
, ibfd
))
6704 if ((h
== NULL
|| is_static_defined (h
))
6705 && (next_r
== -1 || next_r
== -2))
6710 /* Find (or create) an entry in the tocsave hash table. */
6712 static struct tocsave_entry
*
6713 tocsave_find (struct ppc_link_hash_table
*htab
,
6714 enum insert_option insert
,
6715 Elf_Internal_Sym
**local_syms
,
6716 const Elf_Internal_Rela
*irela
,
6719 unsigned long r_indx
;
6720 struct elf_link_hash_entry
*h
;
6721 Elf_Internal_Sym
*sym
;
6722 struct tocsave_entry ent
, *p
;
6724 struct tocsave_entry
**slot
;
6726 r_indx
= ELF64_R_SYM (irela
->r_info
);
6727 if (!get_sym_h (&h
, &sym
, &ent
.sec
, NULL
, local_syms
, r_indx
, ibfd
))
6729 if (ent
.sec
== NULL
|| ent
.sec
->output_section
== NULL
)
6732 (_("%pB: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd
);
6737 ent
.offset
= h
->root
.u
.def
.value
;
6739 ent
.offset
= sym
->st_value
;
6740 ent
.offset
+= irela
->r_addend
;
6742 hash
= tocsave_htab_hash (&ent
);
6743 slot
= ((struct tocsave_entry
**)
6744 htab_find_slot_with_hash (htab
->tocsave_htab
, &ent
, hash
, insert
));
6750 p
= (struct tocsave_entry
*) bfd_alloc (ibfd
, sizeof (*p
));
6759 /* Adjust all global syms defined in opd sections. In gcc generated
6760 code for the old ABI, these will already have been done. */
6763 adjust_opd_syms (struct elf_link_hash_entry
*h
, void *inf ATTRIBUTE_UNUSED
)
6765 struct ppc_link_hash_entry
*eh
;
6767 struct _opd_sec_data
*opd
;
6769 if (h
->root
.type
== bfd_link_hash_indirect
)
6772 if (h
->root
.type
!= bfd_link_hash_defined
6773 && h
->root
.type
!= bfd_link_hash_defweak
)
6776 eh
= (struct ppc_link_hash_entry
*) h
;
6777 if (eh
->adjust_done
)
6780 sym_sec
= eh
->elf
.root
.u
.def
.section
;
6781 opd
= get_opd_info (sym_sec
);
6782 if (opd
!= NULL
&& opd
->adjust
!= NULL
)
6784 long adjust
= opd
->adjust
[OPD_NDX (eh
->elf
.root
.u
.def
.value
)];
6787 /* This entry has been deleted. */
6788 asection
*dsec
= ppc64_elf_tdata (sym_sec
->owner
)->deleted_section
;
6791 for (dsec
= sym_sec
->owner
->sections
; dsec
; dsec
= dsec
->next
)
6792 if (discarded_section (dsec
))
6794 ppc64_elf_tdata (sym_sec
->owner
)->deleted_section
= dsec
;
6798 eh
->elf
.root
.u
.def
.value
= 0;
6799 eh
->elf
.root
.u
.def
.section
= dsec
;
6802 eh
->elf
.root
.u
.def
.value
+= adjust
;
6803 eh
->adjust_done
= 1;
6808 /* Handles decrementing dynamic reloc counts for the reloc specified by
6809 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
6810 have already been determined. */
6813 dec_dynrel_count (bfd_vma r_info
,
6815 struct bfd_link_info
*info
,
6816 Elf_Internal_Sym
**local_syms
,
6817 struct elf_link_hash_entry
*h
,
6818 Elf_Internal_Sym
*sym
)
6820 enum elf_ppc64_reloc_type r_type
;
6821 asection
*sym_sec
= NULL
;
6823 /* Can this reloc be dynamic? This switch, and later tests here
6824 should be kept in sync with the code in check_relocs. */
6825 r_type
= ELF64_R_TYPE (r_info
);
6832 case R_PPC64_TOC16_DS
:
6833 case R_PPC64_TOC16_LO
:
6834 case R_PPC64_TOC16_HI
:
6835 case R_PPC64_TOC16_HA
:
6836 case R_PPC64_TOC16_LO_DS
:
6841 case R_PPC64_TPREL16
:
6842 case R_PPC64_TPREL16_LO
:
6843 case R_PPC64_TPREL16_HI
:
6844 case R_PPC64_TPREL16_HA
:
6845 case R_PPC64_TPREL16_DS
:
6846 case R_PPC64_TPREL16_LO_DS
:
6847 case R_PPC64_TPREL16_HIGH
:
6848 case R_PPC64_TPREL16_HIGHA
:
6849 case R_PPC64_TPREL16_HIGHER
:
6850 case R_PPC64_TPREL16_HIGHERA
:
6851 case R_PPC64_TPREL16_HIGHEST
:
6852 case R_PPC64_TPREL16_HIGHESTA
:
6853 case R_PPC64_TPREL64
:
6854 case R_PPC64_TPREL34
:
6855 case R_PPC64_DTPMOD64
:
6856 case R_PPC64_DTPREL64
:
6857 case R_PPC64_ADDR64
:
6861 case R_PPC64_ADDR14
:
6862 case R_PPC64_ADDR14_BRNTAKEN
:
6863 case R_PPC64_ADDR14_BRTAKEN
:
6864 case R_PPC64_ADDR16
:
6865 case R_PPC64_ADDR16_DS
:
6866 case R_PPC64_ADDR16_HA
:
6867 case R_PPC64_ADDR16_HI
:
6868 case R_PPC64_ADDR16_HIGH
:
6869 case R_PPC64_ADDR16_HIGHA
:
6870 case R_PPC64_ADDR16_HIGHER
:
6871 case R_PPC64_ADDR16_HIGHERA
:
6872 case R_PPC64_ADDR16_HIGHEST
:
6873 case R_PPC64_ADDR16_HIGHESTA
:
6874 case R_PPC64_ADDR16_LO
:
6875 case R_PPC64_ADDR16_LO_DS
:
6876 case R_PPC64_ADDR24
:
6877 case R_PPC64_ADDR32
:
6878 case R_PPC64_UADDR16
:
6879 case R_PPC64_UADDR32
:
6880 case R_PPC64_UADDR64
:
6883 case R_PPC64_D34_LO
:
6884 case R_PPC64_D34_HI30
:
6885 case R_PPC64_D34_HA30
:
6886 case R_PPC64_ADDR16_HIGHER34
:
6887 case R_PPC64_ADDR16_HIGHERA34
:
6888 case R_PPC64_ADDR16_HIGHEST34
:
6889 case R_PPC64_ADDR16_HIGHESTA34
:
6894 if (local_syms
!= NULL
)
6896 unsigned long r_symndx
;
6897 bfd
*ibfd
= sec
->owner
;
6899 r_symndx
= ELF64_R_SYM (r_info
);
6900 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, local_syms
, r_symndx
, ibfd
))
6905 && (h
->root
.type
== bfd_link_hash_defweak
6906 || !h
->def_regular
))
6908 && !bfd_link_executable (info
)
6909 && !SYMBOLIC_BIND (info
, h
))
6910 || (bfd_link_pic (info
)
6911 && must_be_dyn_reloc (info
, r_type
))
6912 || (!bfd_link_pic (info
)
6914 ? h
->type
== STT_GNU_IFUNC
6915 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)))
6922 struct elf_dyn_relocs
*p
;
6923 struct elf_dyn_relocs
**pp
;
6924 pp
= &((struct ppc_link_hash_entry
*) h
)->dyn_relocs
;
6926 /* elf_gc_sweep may have already removed all dyn relocs associated
6927 with local syms for a given section. Also, symbol flags are
6928 changed by elf_gc_sweep_symbol, confusing the test above. Don't
6929 report a dynreloc miscount. */
6930 if (*pp
== NULL
&& info
->gc_sections
)
6933 while ((p
= *pp
) != NULL
)
6937 if (!must_be_dyn_reloc (info
, r_type
))
6949 struct ppc_dyn_relocs
*p
;
6950 struct ppc_dyn_relocs
**pp
;
6952 bfd_boolean is_ifunc
;
6954 if (local_syms
== NULL
)
6955 sym_sec
= bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
6956 if (sym_sec
== NULL
)
6959 vpp
= &elf_section_data (sym_sec
)->local_dynrel
;
6960 pp
= (struct ppc_dyn_relocs
**) vpp
;
6962 if (*pp
== NULL
&& info
->gc_sections
)
6965 is_ifunc
= ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
;
6966 while ((p
= *pp
) != NULL
)
6968 if (p
->sec
== sec
&& p
->ifunc
== is_ifunc
)
6979 /* xgettext:c-format */
6980 _bfd_error_handler (_("dynreloc miscount for %pB, section %pA"),
6982 bfd_set_error (bfd_error_bad_value
);
6986 /* Remove unused Official Procedure Descriptor entries. Currently we
6987 only remove those associated with functions in discarded link-once
6988 sections, or weakly defined functions that have been overridden. It
6989 would be possible to remove many more entries for statically linked
6993 ppc64_elf_edit_opd (struct bfd_link_info
*info
)
6996 bfd_boolean some_edited
= FALSE
;
6997 asection
*need_pad
= NULL
;
6998 struct ppc_link_hash_table
*htab
;
7000 htab
= ppc_hash_table (info
);
7004 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
7007 Elf_Internal_Rela
*relstart
, *rel
, *relend
;
7008 Elf_Internal_Shdr
*symtab_hdr
;
7009 Elf_Internal_Sym
*local_syms
;
7010 struct _opd_sec_data
*opd
;
7011 bfd_boolean need_edit
, add_aux_fields
, broken
;
7012 bfd_size_type cnt_16b
= 0;
7014 if (!is_ppc64_elf (ibfd
))
7017 sec
= bfd_get_section_by_name (ibfd
, ".opd");
7018 if (sec
== NULL
|| sec
->size
== 0)
7021 if (sec
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
7024 if (sec
->output_section
== bfd_abs_section_ptr
)
7027 /* Look through the section relocs. */
7028 if ((sec
->flags
& SEC_RELOC
) == 0 || sec
->reloc_count
== 0)
7032 symtab_hdr
= &elf_symtab_hdr (ibfd
);
7034 /* Read the relocations. */
7035 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
7037 if (relstart
== NULL
)
7040 /* First run through the relocs to check they are sane, and to
7041 determine whether we need to edit this opd section. */
7045 relend
= relstart
+ sec
->reloc_count
;
7046 for (rel
= relstart
; rel
< relend
; )
7048 enum elf_ppc64_reloc_type r_type
;
7049 unsigned long r_symndx
;
7051 struct elf_link_hash_entry
*h
;
7052 Elf_Internal_Sym
*sym
;
7055 /* .opd contains an array of 16 or 24 byte entries. We're
7056 only interested in the reloc pointing to a function entry
7058 offset
= rel
->r_offset
;
7059 if (rel
+ 1 == relend
7060 || rel
[1].r_offset
!= offset
+ 8)
7062 /* If someone messes with .opd alignment then after a
7063 "ld -r" we might have padding in the middle of .opd.
7064 Also, there's nothing to prevent someone putting
7065 something silly in .opd with the assembler. No .opd
7066 optimization for them! */
7069 (_("%pB: .opd is not a regular array of opd entries"), ibfd
);
7074 if ((r_type
= ELF64_R_TYPE (rel
->r_info
)) != R_PPC64_ADDR64
7075 || (r_type
= ELF64_R_TYPE ((rel
+ 1)->r_info
)) != R_PPC64_TOC
)
7078 /* xgettext:c-format */
7079 (_("%pB: unexpected reloc type %u in .opd section"),
7085 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7086 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
7090 if (sym_sec
== NULL
|| sym_sec
->owner
== NULL
)
7092 const char *sym_name
;
7094 sym_name
= h
->root
.root
.string
;
7096 sym_name
= bfd_elf_sym_name (ibfd
, symtab_hdr
, sym
,
7100 /* xgettext:c-format */
7101 (_("%pB: undefined sym `%s' in .opd section"),
7107 /* opd entries are always for functions defined in the
7108 current input bfd. If the symbol isn't defined in the
7109 input bfd, then we won't be using the function in this
7110 bfd; It must be defined in a linkonce section in another
7111 bfd, or is weak. It's also possible that we are
7112 discarding the function due to a linker script /DISCARD/,
7113 which we test for via the output_section. */
7114 if (sym_sec
->owner
!= ibfd
7115 || sym_sec
->output_section
== bfd_abs_section_ptr
)
7119 if (rel
+ 1 == relend
7120 || (rel
+ 2 < relend
7121 && ELF64_R_TYPE (rel
[2].r_info
) == R_PPC64_TOC
))
7126 if (sec
->size
== offset
+ 24)
7131 if (sec
->size
== offset
+ 16)
7138 else if (rel
+ 1 < relend
7139 && ELF64_R_TYPE (rel
[0].r_info
) == R_PPC64_ADDR64
7140 && ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_TOC
)
7142 if (rel
[0].r_offset
== offset
+ 16)
7144 else if (rel
[0].r_offset
!= offset
+ 24)
7151 add_aux_fields
= htab
->params
->non_overlapping_opd
&& cnt_16b
> 0;
7153 if (!broken
&& (need_edit
|| add_aux_fields
))
7155 Elf_Internal_Rela
*write_rel
;
7156 Elf_Internal_Shdr
*rel_hdr
;
7157 bfd_byte
*rptr
, *wptr
;
7158 bfd_byte
*new_contents
;
7161 new_contents
= NULL
;
7162 amt
= OPD_NDX (sec
->size
) * sizeof (long);
7163 opd
= &ppc64_elf_section_data (sec
)->u
.opd
;
7164 opd
->adjust
= bfd_zalloc (sec
->owner
, amt
);
7165 if (opd
->adjust
== NULL
)
7168 /* This seems a waste of time as input .opd sections are all
7169 zeros as generated by gcc, but I suppose there's no reason
7170 this will always be so. We might start putting something in
7171 the third word of .opd entries. */
7172 if ((sec
->flags
& SEC_IN_MEMORY
) == 0)
7175 if (!bfd_malloc_and_get_section (ibfd
, sec
, &loc
))
7180 if (local_syms
!= NULL
7181 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
7183 if (elf_section_data (sec
)->relocs
!= relstart
)
7187 sec
->contents
= loc
;
7188 sec
->flags
|= (SEC_IN_MEMORY
| SEC_HAS_CONTENTS
);
7191 elf_section_data (sec
)->relocs
= relstart
;
7193 new_contents
= sec
->contents
;
7196 new_contents
= bfd_malloc (sec
->size
+ cnt_16b
* 8);
7197 if (new_contents
== NULL
)
7201 wptr
= new_contents
;
7202 rptr
= sec
->contents
;
7203 write_rel
= relstart
;
7204 for (rel
= relstart
; rel
< relend
; )
7206 unsigned long r_symndx
;
7208 struct elf_link_hash_entry
*h
;
7209 struct ppc_link_hash_entry
*fdh
= NULL
;
7210 Elf_Internal_Sym
*sym
;
7212 Elf_Internal_Rela
*next_rel
;
7215 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7216 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
7221 if (next_rel
+ 1 == relend
7222 || (next_rel
+ 2 < relend
7223 && ELF64_R_TYPE (next_rel
[2].r_info
) == R_PPC64_TOC
))
7226 /* See if the .opd entry is full 24 byte or
7227 16 byte (with fd_aux entry overlapped with next
7230 if (next_rel
== relend
)
7232 if (sec
->size
== rel
->r_offset
+ 16)
7235 else if (next_rel
->r_offset
== rel
->r_offset
+ 16)
7239 && h
->root
.root
.string
[0] == '.')
7241 fdh
= ((struct ppc_link_hash_entry
*) h
)->oh
;
7244 fdh
= ppc_follow_link (fdh
);
7245 if (fdh
->elf
.root
.type
!= bfd_link_hash_defined
7246 && fdh
->elf
.root
.type
!= bfd_link_hash_defweak
)
7251 skip
= (sym_sec
->owner
!= ibfd
7252 || sym_sec
->output_section
== bfd_abs_section_ptr
);
7255 if (fdh
!= NULL
&& sym_sec
->owner
== ibfd
)
7257 /* Arrange for the function descriptor sym
7259 fdh
->elf
.root
.u
.def
.value
= 0;
7260 fdh
->elf
.root
.u
.def
.section
= sym_sec
;
7262 opd
->adjust
[OPD_NDX (rel
->r_offset
)] = -1;
7264 if (NO_OPD_RELOCS
|| bfd_link_relocatable (info
))
7269 if (!dec_dynrel_count (rel
->r_info
, sec
, info
,
7273 if (++rel
== next_rel
)
7276 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7277 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
7284 /* We'll be keeping this opd entry. */
7289 /* Redefine the function descriptor symbol to
7290 this location in the opd section. It is
7291 necessary to update the value here rather
7292 than using an array of adjustments as we do
7293 for local symbols, because various places
7294 in the generic ELF code use the value
7295 stored in u.def.value. */
7296 fdh
->elf
.root
.u
.def
.value
= wptr
- new_contents
;
7297 fdh
->adjust_done
= 1;
7300 /* Local syms are a bit tricky. We could
7301 tweak them as they can be cached, but
7302 we'd need to look through the local syms
7303 for the function descriptor sym which we
7304 don't have at the moment. So keep an
7305 array of adjustments. */
7306 adjust
= (wptr
- new_contents
) - (rptr
- sec
->contents
);
7307 opd
->adjust
[OPD_NDX (rel
->r_offset
)] = adjust
;
7310 memcpy (wptr
, rptr
, opd_ent_size
);
7311 wptr
+= opd_ent_size
;
7312 if (add_aux_fields
&& opd_ent_size
== 16)
7314 memset (wptr
, '\0', 8);
7318 /* We need to adjust any reloc offsets to point to the
7320 for ( ; rel
!= next_rel
; ++rel
)
7322 rel
->r_offset
+= adjust
;
7323 if (write_rel
!= rel
)
7324 memcpy (write_rel
, rel
, sizeof (*rel
));
7329 rptr
+= opd_ent_size
;
7332 sec
->size
= wptr
- new_contents
;
7333 sec
->reloc_count
= write_rel
- relstart
;
7336 free (sec
->contents
);
7337 sec
->contents
= new_contents
;
7340 /* Fudge the header size too, as this is used later in
7341 elf_bfd_final_link if we are emitting relocs. */
7342 rel_hdr
= _bfd_elf_single_rel_hdr (sec
);
7343 rel_hdr
->sh_size
= sec
->reloc_count
* rel_hdr
->sh_entsize
;
7346 else if (elf_section_data (sec
)->relocs
!= relstart
)
7349 if (local_syms
!= NULL
7350 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
7352 if (!info
->keep_memory
)
7355 symtab_hdr
->contents
= (unsigned char *) local_syms
;
7360 elf_link_hash_traverse (elf_hash_table (info
), adjust_opd_syms
, NULL
);
7362 /* If we are doing a final link and the last .opd entry is just 16 byte
7363 long, add a 8 byte padding after it. */
7364 if (need_pad
!= NULL
&& !bfd_link_relocatable (info
))
7368 if ((need_pad
->flags
& SEC_IN_MEMORY
) == 0)
7370 BFD_ASSERT (need_pad
->size
> 0);
7372 p
= bfd_malloc (need_pad
->size
+ 8);
7376 if (!bfd_get_section_contents (need_pad
->owner
, need_pad
,
7377 p
, 0, need_pad
->size
))
7380 need_pad
->contents
= p
;
7381 need_pad
->flags
|= (SEC_IN_MEMORY
| SEC_HAS_CONTENTS
);
7385 p
= bfd_realloc (need_pad
->contents
, need_pad
->size
+ 8);
7389 need_pad
->contents
= p
;
7392 memset (need_pad
->contents
+ need_pad
->size
, 0, 8);
7393 need_pad
->size
+= 8;
7399 /* Analyze inline PLT call relocations to see whether calls to locally
7400 defined functions can be converted to direct calls. */
7403 ppc64_elf_inline_plt (struct bfd_link_info
*info
)
7405 struct ppc_link_hash_table
*htab
;
7408 bfd_vma low_vma
, high_vma
, limit
;
7410 htab
= ppc_hash_table (info
);
7414 /* A bl insn can reach -0x2000000 to 0x1fffffc. The limit is
7415 reduced somewhat to cater for possible stubs that might be added
7416 between the call and its destination. */
7417 if (htab
->params
->group_size
< 0)
7419 limit
= -htab
->params
->group_size
;
7425 limit
= htab
->params
->group_size
;
7432 for (sec
= info
->output_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7433 if ((sec
->flags
& (SEC_ALLOC
| SEC_CODE
)) == (SEC_ALLOC
| SEC_CODE
))
7435 if (low_vma
> sec
->vma
)
7437 if (high_vma
< sec
->vma
+ sec
->size
)
7438 high_vma
= sec
->vma
+ sec
->size
;
7441 /* If a "bl" can reach anywhere in local code sections, then we can
7442 convert all inline PLT sequences to direct calls when the symbol
7444 if (high_vma
- low_vma
< limit
)
7446 htab
->can_convert_all_inline_plt
= 1;
7450 /* Otherwise, go looking through relocs for cases where a direct
7451 call won't reach. Mark the symbol on any such reloc to disable
7452 the optimization and keep the PLT entry as it seems likely that
7453 this will be better than creating trampolines. Note that this
7454 will disable the optimization for all inline PLT calls to a
7455 particular symbol, not just those that won't reach. The
7456 difficulty in doing a more precise optimization is that the
7457 linker needs to make a decision depending on whether a
7458 particular R_PPC64_PLTCALL insn can be turned into a direct
7459 call, for each of the R_PPC64_PLTSEQ and R_PPC64_PLT16* insns in
7460 the sequence, and there is nothing that ties those relocs
7461 together except their symbol. */
7463 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
7465 Elf_Internal_Shdr
*symtab_hdr
;
7466 Elf_Internal_Sym
*local_syms
;
7468 if (!is_ppc64_elf (ibfd
))
7472 symtab_hdr
= &elf_symtab_hdr (ibfd
);
7474 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7475 if (ppc64_elf_section_data (sec
)->has_pltcall
7476 && !bfd_is_abs_section (sec
->output_section
))
7478 Elf_Internal_Rela
*relstart
, *rel
, *relend
;
7480 /* Read the relocations. */
7481 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
7483 if (relstart
== NULL
)
7486 relend
= relstart
+ sec
->reloc_count
;
7487 for (rel
= relstart
; rel
< relend
; )
7489 enum elf_ppc64_reloc_type r_type
;
7490 unsigned long r_symndx
;
7492 struct elf_link_hash_entry
*h
;
7493 Elf_Internal_Sym
*sym
;
7494 unsigned char *tls_maskp
;
7496 r_type
= ELF64_R_TYPE (rel
->r_info
);
7497 if (r_type
!= R_PPC64_PLTCALL
7498 && r_type
!= R_PPC64_PLTCALL_NOTOC
)
7501 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7502 if (!get_sym_h (&h
, &sym
, &sym_sec
, &tls_maskp
, &local_syms
,
7505 if (elf_section_data (sec
)->relocs
!= relstart
)
7507 if (local_syms
!= NULL
7508 && symtab_hdr
->contents
!= (bfd_byte
*) local_syms
)
7513 if (sym_sec
!= NULL
&& sym_sec
->output_section
!= NULL
)
7517 to
= h
->root
.u
.def
.value
;
7520 to
+= (rel
->r_addend
7521 + sym_sec
->output_offset
7522 + sym_sec
->output_section
->vma
);
7523 from
= (rel
->r_offset
7524 + sec
->output_offset
7525 + sec
->output_section
->vma
);
7526 if (to
- from
+ limit
< 2 * limit
7527 && !(r_type
== R_PPC64_PLTCALL_NOTOC
7528 && (((h
? h
->other
: sym
->st_other
)
7529 & STO_PPC64_LOCAL_MASK
)
7530 > 1 << STO_PPC64_LOCAL_BIT
)))
7531 *tls_maskp
&= ~PLT_KEEP
;
7534 if (elf_section_data (sec
)->relocs
!= relstart
)
7538 if (local_syms
!= NULL
7539 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
7541 if (!info
->keep_memory
)
7544 symtab_hdr
->contents
= (unsigned char *) local_syms
;
7551 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
7554 ppc64_elf_tls_setup (struct bfd_link_info
*info
)
7556 struct ppc_link_hash_table
*htab
;
7558 htab
= ppc_hash_table (info
);
7562 if (abiversion (info
->output_bfd
) == 1)
7565 if (htab
->params
->no_multi_toc
)
7566 htab
->do_multi_toc
= 0;
7567 else if (!htab
->do_multi_toc
)
7568 htab
->params
->no_multi_toc
= 1;
7570 /* Default to --no-plt-localentry, as this option can cause problems
7571 with symbol interposition. For example, glibc libpthread.so and
7572 libc.so duplicate many pthread symbols, with a fallback
7573 implementation in libc.so. In some cases the fallback does more
7574 work than the pthread implementation. __pthread_condattr_destroy
7575 is one such symbol: the libpthread.so implementation is
7576 localentry:0 while the libc.so implementation is localentry:8.
7577 An app that "cleverly" uses dlopen to only load necessary
7578 libraries at runtime may omit loading libpthread.so when not
7579 running multi-threaded, which then results in the libc.so
7580 fallback symbols being used and ld.so complaining. Now there
7581 are workarounds in ld (see non_zero_localentry) to detect the
7582 pthread situation, but that may not be the only case where
7583 --plt-localentry can cause trouble. */
7584 if (htab
->params
->plt_localentry0
< 0)
7585 htab
->params
->plt_localentry0
= 0;
7586 if (htab
->params
->plt_localentry0
7587 && elf_link_hash_lookup (&htab
->elf
, "GLIBC_2.26",
7588 FALSE
, FALSE
, FALSE
) == NULL
)
7590 (_("warning: --plt-localentry is especially dangerous without "
7591 "ld.so support to detect ABI violations"));
7593 htab
->tls_get_addr
= ((struct ppc_link_hash_entry
*)
7594 elf_link_hash_lookup (&htab
->elf
, ".__tls_get_addr",
7595 FALSE
, FALSE
, TRUE
));
7596 /* Move dynamic linking info to the function descriptor sym. */
7597 if (htab
->tls_get_addr
!= NULL
)
7598 func_desc_adjust (&htab
->tls_get_addr
->elf
, info
);
7599 htab
->tls_get_addr_fd
= ((struct ppc_link_hash_entry
*)
7600 elf_link_hash_lookup (&htab
->elf
, "__tls_get_addr",
7601 FALSE
, FALSE
, TRUE
));
7602 if (htab
->params
->tls_get_addr_opt
)
7604 struct elf_link_hash_entry
*opt
, *opt_fd
, *tga
, *tga_fd
;
7606 opt
= elf_link_hash_lookup (&htab
->elf
, ".__tls_get_addr_opt",
7607 FALSE
, FALSE
, TRUE
);
7609 func_desc_adjust (opt
, info
);
7610 opt_fd
= elf_link_hash_lookup (&htab
->elf
, "__tls_get_addr_opt",
7611 FALSE
, FALSE
, TRUE
);
7613 && (opt_fd
->root
.type
== bfd_link_hash_defined
7614 || opt_fd
->root
.type
== bfd_link_hash_defweak
))
7616 /* If glibc supports an optimized __tls_get_addr call stub,
7617 signalled by the presence of __tls_get_addr_opt, and we'll
7618 be calling __tls_get_addr via a plt call stub, then
7619 make __tls_get_addr point to __tls_get_addr_opt. */
7620 tga_fd
= &htab
->tls_get_addr_fd
->elf
;
7621 if (htab
->elf
.dynamic_sections_created
7623 && (tga_fd
->type
== STT_FUNC
7624 || tga_fd
->needs_plt
)
7625 && !(SYMBOL_CALLS_LOCAL (info
, tga_fd
)
7626 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, tga_fd
)))
7628 struct plt_entry
*ent
;
7630 for (ent
= tga_fd
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
7631 if (ent
->plt
.refcount
> 0)
7635 tga_fd
->root
.type
= bfd_link_hash_indirect
;
7636 tga_fd
->root
.u
.i
.link
= &opt_fd
->root
;
7637 ppc64_elf_copy_indirect_symbol (info
, opt_fd
, tga_fd
);
7639 if (opt_fd
->dynindx
!= -1)
7641 /* Use __tls_get_addr_opt in dynamic relocations. */
7642 opt_fd
->dynindx
= -1;
7643 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
7644 opt_fd
->dynstr_index
);
7645 if (!bfd_elf_link_record_dynamic_symbol (info
, opt_fd
))
7648 htab
->tls_get_addr_fd
7649 = (struct ppc_link_hash_entry
*) opt_fd
;
7650 tga
= &htab
->tls_get_addr
->elf
;
7651 if (opt
!= NULL
&& tga
!= NULL
)
7653 tga
->root
.type
= bfd_link_hash_indirect
;
7654 tga
->root
.u
.i
.link
= &opt
->root
;
7655 ppc64_elf_copy_indirect_symbol (info
, opt
, tga
);
7657 _bfd_elf_link_hash_hide_symbol (info
, opt
,
7659 htab
->tls_get_addr
= (struct ppc_link_hash_entry
*) opt
;
7661 htab
->tls_get_addr_fd
->oh
= htab
->tls_get_addr
;
7662 htab
->tls_get_addr_fd
->is_func_descriptor
= 1;
7663 if (htab
->tls_get_addr
!= NULL
)
7665 htab
->tls_get_addr
->oh
= htab
->tls_get_addr_fd
;
7666 htab
->tls_get_addr
->is_func
= 1;
7671 else if (htab
->params
->tls_get_addr_opt
< 0)
7672 htab
->params
->tls_get_addr_opt
= 0;
7674 return _bfd_elf_tls_setup (info
->output_bfd
, info
);
7677 /* Return TRUE iff REL is a branch reloc with a global symbol matching
7681 branch_reloc_hash_match (const bfd
*ibfd
,
7682 const Elf_Internal_Rela
*rel
,
7683 const struct ppc_link_hash_entry
*hash1
,
7684 const struct ppc_link_hash_entry
*hash2
)
7686 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (ibfd
);
7687 enum elf_ppc64_reloc_type r_type
= ELF64_R_TYPE (rel
->r_info
);
7688 unsigned int r_symndx
= ELF64_R_SYM (rel
->r_info
);
7690 if (r_symndx
>= symtab_hdr
->sh_info
&& is_branch_reloc (r_type
))
7692 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (ibfd
);
7693 struct elf_link_hash_entry
*h
;
7695 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
7696 h
= elf_follow_link (h
);
7697 if (h
== &hash1
->elf
|| h
== &hash2
->elf
)
7703 /* Run through all the TLS relocs looking for optimization
7704 opportunities. The linker has been hacked (see ppc64elf.em) to do
7705 a preliminary section layout so that we know the TLS segment
7706 offsets. We can't optimize earlier because some optimizations need
7707 to know the tp offset, and we need to optimize before allocating
7708 dynamic relocations. */
7711 ppc64_elf_tls_optimize (struct bfd_link_info
*info
)
7715 struct ppc_link_hash_table
*htab
;
7716 unsigned char *toc_ref
;
7719 if (!bfd_link_executable (info
))
7722 htab
= ppc_hash_table (info
);
7726 /* Make two passes over the relocs. On the first pass, mark toc
7727 entries involved with tls relocs, and check that tls relocs
7728 involved in setting up a tls_get_addr call are indeed followed by
7729 such a call. If they are not, we can't do any tls optimization.
7730 On the second pass twiddle tls_mask flags to notify
7731 relocate_section that optimization can be done, and adjust got
7732 and plt refcounts. */
7734 for (pass
= 0; pass
< 2; ++pass
)
7735 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
7737 Elf_Internal_Sym
*locsyms
= NULL
;
7738 asection
*toc
= bfd_get_section_by_name (ibfd
, ".toc");
7740 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7741 if (sec
->has_tls_reloc
&& !bfd_is_abs_section (sec
->output_section
))
7743 Elf_Internal_Rela
*relstart
, *rel
, *relend
;
7744 bfd_boolean found_tls_get_addr_arg
= 0;
7746 /* Read the relocations. */
7747 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
7749 if (relstart
== NULL
)
7755 relend
= relstart
+ sec
->reloc_count
;
7756 for (rel
= relstart
; rel
< relend
; rel
++)
7758 enum elf_ppc64_reloc_type r_type
;
7759 unsigned long r_symndx
;
7760 struct elf_link_hash_entry
*h
;
7761 Elf_Internal_Sym
*sym
;
7763 unsigned char *tls_mask
;
7764 unsigned int tls_set
, tls_clear
, tls_type
= 0;
7766 bfd_boolean ok_tprel
, is_local
;
7767 long toc_ref_index
= 0;
7768 int expecting_tls_get_addr
= 0;
7769 bfd_boolean ret
= FALSE
;
7771 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7772 if (!get_sym_h (&h
, &sym
, &sym_sec
, &tls_mask
, &locsyms
,
7776 if (elf_section_data (sec
)->relocs
!= relstart
)
7778 if (toc_ref
!= NULL
)
7781 && (elf_symtab_hdr (ibfd
).contents
7782 != (unsigned char *) locsyms
))
7789 if (h
->root
.type
== bfd_link_hash_defined
7790 || h
->root
.type
== bfd_link_hash_defweak
)
7791 value
= h
->root
.u
.def
.value
;
7792 else if (h
->root
.type
== bfd_link_hash_undefweak
)
7796 found_tls_get_addr_arg
= 0;
7801 /* Symbols referenced by TLS relocs must be of type
7802 STT_TLS. So no need for .opd local sym adjust. */
7803 value
= sym
->st_value
;
7812 && h
->root
.type
== bfd_link_hash_undefweak
)
7814 else if (sym_sec
!= NULL
7815 && sym_sec
->output_section
!= NULL
)
7817 value
+= sym_sec
->output_offset
;
7818 value
+= sym_sec
->output_section
->vma
;
7819 value
-= htab
->elf
.tls_sec
->vma
+ TP_OFFSET
;
7820 /* Note that even though the prefix insns
7821 allow a 1<<33 offset we use the same test
7822 as for addis;addi. There may be a mix of
7823 pcrel and non-pcrel code and the decision
7824 to optimise is per symbol, not per TLS
7826 ok_tprel
= value
+ 0x80008000ULL
< 1ULL << 32;
7830 r_type
= ELF64_R_TYPE (rel
->r_info
);
7831 /* If this section has old-style __tls_get_addr calls
7832 without marker relocs, then check that each
7833 __tls_get_addr call reloc is preceded by a reloc
7834 that conceivably belongs to the __tls_get_addr arg
7835 setup insn. If we don't find matching arg setup
7836 relocs, don't do any tls optimization. */
7838 && sec
->has_tls_get_addr_call
7840 && (h
== &htab
->tls_get_addr
->elf
7841 || h
== &htab
->tls_get_addr_fd
->elf
)
7842 && !found_tls_get_addr_arg
7843 && is_branch_reloc (r_type
))
7845 info
->callbacks
->minfo (_("%H __tls_get_addr lost arg, "
7846 "TLS optimization disabled\n"),
7847 ibfd
, sec
, rel
->r_offset
);
7852 found_tls_get_addr_arg
= 0;
7855 case R_PPC64_GOT_TLSLD16
:
7856 case R_PPC64_GOT_TLSLD16_LO
:
7857 case R_PPC64_GOT_TLSLD34
:
7858 expecting_tls_get_addr
= 1;
7859 found_tls_get_addr_arg
= 1;
7862 case R_PPC64_GOT_TLSLD16_HI
:
7863 case R_PPC64_GOT_TLSLD16_HA
:
7864 /* These relocs should never be against a symbol
7865 defined in a shared lib. Leave them alone if
7866 that turns out to be the case. */
7873 tls_type
= TLS_TLS
| TLS_LD
;
7876 case R_PPC64_GOT_TLSGD16
:
7877 case R_PPC64_GOT_TLSGD16_LO
:
7878 case R_PPC64_GOT_TLSGD34
:
7879 expecting_tls_get_addr
= 1;
7880 found_tls_get_addr_arg
= 1;
7883 case R_PPC64_GOT_TLSGD16_HI
:
7884 case R_PPC64_GOT_TLSGD16_HA
:
7890 tls_set
= TLS_TLS
| TLS_GDIE
;
7892 tls_type
= TLS_TLS
| TLS_GD
;
7895 case R_PPC64_GOT_TPREL34
:
7896 case R_PPC64_GOT_TPREL16_DS
:
7897 case R_PPC64_GOT_TPREL16_LO_DS
:
7898 case R_PPC64_GOT_TPREL16_HI
:
7899 case R_PPC64_GOT_TPREL16_HA
:
7904 tls_clear
= TLS_TPREL
;
7905 tls_type
= TLS_TLS
| TLS_TPREL
;
7912 if (rel
+ 1 < relend
7913 && is_plt_seq_reloc (ELF64_R_TYPE (rel
[1].r_info
)))
7916 && (ELF64_R_TYPE (rel
[1].r_info
)
7918 && (ELF64_R_TYPE (rel
[1].r_info
)
7919 != R_PPC64_PLTSEQ_NOTOC
))
7921 r_symndx
= ELF64_R_SYM (rel
[1].r_info
);
7922 if (!get_sym_h (&h
, NULL
, NULL
, NULL
, &locsyms
,
7927 struct plt_entry
*ent
= NULL
;
7929 for (ent
= h
->plt
.plist
;
7932 if (ent
->addend
== rel
[1].r_addend
)
7936 && ent
->plt
.refcount
> 0)
7937 ent
->plt
.refcount
-= 1;
7942 found_tls_get_addr_arg
= 1;
7947 case R_PPC64_TOC16_LO
:
7948 if (sym_sec
== NULL
|| sym_sec
!= toc
)
7951 /* Mark this toc entry as referenced by a TLS
7952 code sequence. We can do that now in the
7953 case of R_PPC64_TLS, and after checking for
7954 tls_get_addr for the TOC16 relocs. */
7955 if (toc_ref
== NULL
)
7957 = bfd_zmalloc (toc
->output_section
->rawsize
/ 8);
7958 if (toc_ref
== NULL
)
7962 value
= h
->root
.u
.def
.value
;
7964 value
= sym
->st_value
;
7965 value
+= rel
->r_addend
;
7968 BFD_ASSERT (value
< toc
->size
7969 && toc
->output_offset
% 8 == 0);
7970 toc_ref_index
= (value
+ toc
->output_offset
) / 8;
7971 if (r_type
== R_PPC64_TLS
7972 || r_type
== R_PPC64_TLSGD
7973 || r_type
== R_PPC64_TLSLD
)
7975 toc_ref
[toc_ref_index
] = 1;
7979 if (pass
!= 0 && toc_ref
[toc_ref_index
] == 0)
7984 expecting_tls_get_addr
= 2;
7987 case R_PPC64_TPREL64
:
7991 || !toc_ref
[(rel
->r_offset
+ toc
->output_offset
) / 8])
7996 tls_set
= TLS_EXPLICIT
;
7997 tls_clear
= TLS_TPREL
;
8002 case R_PPC64_DTPMOD64
:
8006 || !toc_ref
[(rel
->r_offset
+ toc
->output_offset
) / 8])
8008 if (rel
+ 1 < relend
8010 == ELF64_R_INFO (r_symndx
, R_PPC64_DTPREL64
))
8011 && rel
[1].r_offset
== rel
->r_offset
+ 8)
8015 tls_set
= TLS_EXPLICIT
| TLS_GD
;
8018 tls_set
= TLS_EXPLICIT
| TLS_GD
| TLS_GDIE
;
8027 tls_set
= TLS_EXPLICIT
;
8038 if (!expecting_tls_get_addr
8039 || !sec
->has_tls_get_addr_call
)
8042 if (rel
+ 1 < relend
8043 && branch_reloc_hash_match (ibfd
, rel
+ 1,
8045 htab
->tls_get_addr_fd
))
8047 if (expecting_tls_get_addr
== 2)
8049 /* Check for toc tls entries. */
8050 unsigned char *toc_tls
;
8053 retval
= get_tls_mask (&toc_tls
, NULL
, NULL
,
8058 if (toc_tls
!= NULL
)
8060 if ((*toc_tls
& TLS_TLS
) != 0
8061 && ((*toc_tls
& (TLS_GD
| TLS_LD
)) != 0))
8062 found_tls_get_addr_arg
= 1;
8064 toc_ref
[toc_ref_index
] = 1;
8070 /* Uh oh, we didn't find the expected call. We
8071 could just mark this symbol to exclude it
8072 from tls optimization but it's safer to skip
8073 the entire optimization. */
8074 /* xgettext:c-format */
8075 info
->callbacks
->minfo (_("%H arg lost __tls_get_addr, "
8076 "TLS optimization disabled\n"),
8077 ibfd
, sec
, rel
->r_offset
);
8082 /* If we don't have old-style __tls_get_addr calls
8083 without TLSGD/TLSLD marker relocs, and we haven't
8084 found a new-style __tls_get_addr call with a
8085 marker for this symbol, then we either have a
8086 broken object file or an -mlongcall style
8087 indirect call to __tls_get_addr without a marker.
8088 Disable optimization in this case. */
8089 if ((tls_clear
& (TLS_GD
| TLS_LD
)) != 0
8090 && (tls_set
& TLS_EXPLICIT
) == 0
8091 && !sec
->has_tls_get_addr_call
8092 && ((*tls_mask
& (TLS_TLS
| TLS_MARK
))
8093 != (TLS_TLS
| TLS_MARK
)))
8096 if (expecting_tls_get_addr
)
8098 struct plt_entry
*ent
= NULL
;
8100 if (htab
->tls_get_addr
!= NULL
)
8101 for (ent
= htab
->tls_get_addr
->elf
.plt
.plist
;
8104 if (ent
->addend
== 0)
8107 if (ent
== NULL
&& htab
->tls_get_addr_fd
!= NULL
)
8108 for (ent
= htab
->tls_get_addr_fd
->elf
.plt
.plist
;
8111 if (ent
->addend
== 0)
8115 && ent
->plt
.refcount
> 0)
8116 ent
->plt
.refcount
-= 1;
8122 if ((tls_set
& TLS_EXPLICIT
) == 0)
8124 struct got_entry
*ent
;
8126 /* Adjust got entry for this reloc. */
8130 ent
= elf_local_got_ents (ibfd
)[r_symndx
];
8132 for (; ent
!= NULL
; ent
= ent
->next
)
8133 if (ent
->addend
== rel
->r_addend
8134 && ent
->owner
== ibfd
8135 && ent
->tls_type
== tls_type
)
8142 /* We managed to get rid of a got entry. */
8143 if (ent
->got
.refcount
> 0)
8144 ent
->got
.refcount
-= 1;
8149 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8150 we'll lose one or two dyn relocs. */
8151 if (!dec_dynrel_count (rel
->r_info
, sec
, info
,
8155 if (tls_set
== (TLS_EXPLICIT
| TLS_GD
))
8157 if (!dec_dynrel_count ((rel
+ 1)->r_info
, sec
, info
,
8163 *tls_mask
|= tls_set
& 0xff;
8164 *tls_mask
&= ~tls_clear
;
8167 if (elf_section_data (sec
)->relocs
!= relstart
)
8172 && (elf_symtab_hdr (ibfd
).contents
!= (unsigned char *) locsyms
))
8174 if (!info
->keep_memory
)
8177 elf_symtab_hdr (ibfd
).contents
= (unsigned char *) locsyms
;
8181 if (toc_ref
!= NULL
)
8183 htab
->do_tls_opt
= 1;
8187 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8188 the values of any global symbols in a toc section that has been
8189 edited. Globals in toc sections should be a rarity, so this function
8190 sets a flag if any are found in toc sections other than the one just
8191 edited, so that further hash table traversals can be avoided. */
8193 struct adjust_toc_info
8196 unsigned long *skip
;
8197 bfd_boolean global_toc_syms
;
8200 enum toc_skip_enum
{ ref_from_discarded
= 1, can_optimize
= 2 };
8203 adjust_toc_syms (struct elf_link_hash_entry
*h
, void *inf
)
8205 struct ppc_link_hash_entry
*eh
;
8206 struct adjust_toc_info
*toc_inf
= (struct adjust_toc_info
*) inf
;
8209 if (h
->root
.type
!= bfd_link_hash_defined
8210 && h
->root
.type
!= bfd_link_hash_defweak
)
8213 eh
= (struct ppc_link_hash_entry
*) h
;
8214 if (eh
->adjust_done
)
8217 if (eh
->elf
.root
.u
.def
.section
== toc_inf
->toc
)
8219 if (eh
->elf
.root
.u
.def
.value
> toc_inf
->toc
->rawsize
)
8220 i
= toc_inf
->toc
->rawsize
>> 3;
8222 i
= eh
->elf
.root
.u
.def
.value
>> 3;
8224 if ((toc_inf
->skip
[i
] & (ref_from_discarded
| can_optimize
)) != 0)
8227 (_("%s defined on removed toc entry"), eh
->elf
.root
.root
.string
);
8230 while ((toc_inf
->skip
[i
] & (ref_from_discarded
| can_optimize
)) != 0);
8231 eh
->elf
.root
.u
.def
.value
= (bfd_vma
) i
<< 3;
8234 eh
->elf
.root
.u
.def
.value
-= toc_inf
->skip
[i
];
8235 eh
->adjust_done
= 1;
8237 else if (strcmp (eh
->elf
.root
.u
.def
.section
->name
, ".toc") == 0)
8238 toc_inf
->global_toc_syms
= TRUE
;
8243 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
8244 on a _LO variety toc/got reloc. */
8247 ok_lo_toc_insn (unsigned int insn
, enum elf_ppc64_reloc_type r_type
)
8249 return ((insn
& (0x3f << 26)) == 12u << 26 /* addic */
8250 || (insn
& (0x3f << 26)) == 14u << 26 /* addi */
8251 || (insn
& (0x3f << 26)) == 32u << 26 /* lwz */
8252 || (insn
& (0x3f << 26)) == 34u << 26 /* lbz */
8253 || (insn
& (0x3f << 26)) == 36u << 26 /* stw */
8254 || (insn
& (0x3f << 26)) == 38u << 26 /* stb */
8255 || (insn
& (0x3f << 26)) == 40u << 26 /* lhz */
8256 || (insn
& (0x3f << 26)) == 42u << 26 /* lha */
8257 || (insn
& (0x3f << 26)) == 44u << 26 /* sth */
8258 || (insn
& (0x3f << 26)) == 46u << 26 /* lmw */
8259 || (insn
& (0x3f << 26)) == 47u << 26 /* stmw */
8260 || (insn
& (0x3f << 26)) == 48u << 26 /* lfs */
8261 || (insn
& (0x3f << 26)) == 50u << 26 /* lfd */
8262 || (insn
& (0x3f << 26)) == 52u << 26 /* stfs */
8263 || (insn
& (0x3f << 26)) == 54u << 26 /* stfd */
8264 || (insn
& (0x3f << 26)) == 56u << 26 /* lq,lfq */
8265 || ((insn
& (0x3f << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
8266 /* Exclude lfqu by testing reloc. If relocs are ever
8267 defined for the reduced D field in psq_lu then those
8268 will need testing too. */
8269 && r_type
!= R_PPC64_TOC16_LO
&& r_type
!= R_PPC64_GOT16_LO
)
8270 || ((insn
& (0x3f << 26)) == 58u << 26 /* ld,lwa */
8272 || (insn
& (0x3f << 26)) == 60u << 26 /* stfq */
8273 || ((insn
& (0x3f << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
8274 /* Exclude stfqu. psq_stu as above for psq_lu. */
8275 && r_type
!= R_PPC64_TOC16_LO
&& r_type
!= R_PPC64_GOT16_LO
)
8276 || ((insn
& (0x3f << 26)) == 62u << 26 /* std,stq */
8277 && (insn
& 1) == 0));
8280 /* PCREL_OPT in one instance flags to the linker that a pair of insns:
8281 pld ra,symbol@got@pcrel
8282 load/store rt,off(ra)
8285 load/store rt,off(ra)
8286 may be translated to
8287 pload/pstore rt,symbol+off@pcrel
8289 This function returns true if the optimization is possible, placing
8290 the prefix insn in *PINSN1, a NOP in *PINSN2 and the offset in *POFF.
8292 On entry to this function, the linker has already determined that
8293 the pld can be replaced with pla: *PINSN1 is that pla insn,
8294 while *PINSN2 is the second instruction. */
8297 xlate_pcrel_opt (uint64_t *pinsn1
, uint64_t *pinsn2
, bfd_signed_vma
*poff
)
8299 uint64_t insn1
= *pinsn1
;
8300 uint64_t insn2
= *pinsn2
;
8303 if ((insn2
& (63ULL << 58)) == 1ULL << 58)
8305 /* Check that regs match. */
8306 if (((insn2
>> 16) & 31) != ((insn1
>> 21) & 31))
8309 /* P8LS or PMLS form, non-pcrel. */
8310 if ((insn2
& (-1ULL << 50) & ~(1ULL << 56)) != (1ULL << 58))
8313 *pinsn1
= (insn2
& ~(31 << 16) & ~0x3ffff0000ffffULL
) | (1ULL << 52);
8315 off
= ((insn2
>> 16) & 0x3ffff0000ULL
) | (insn2
& 0xffff);
8316 *poff
= (off
^ 0x200000000ULL
) - 0x200000000ULL
;
8322 /* Check that regs match. */
8323 if (((insn2
>> 16) & 31) != ((insn1
>> 21) & 31))
8326 switch ((insn2
>> 26) & 63)
8342 /* These are the PMLS cases, where we just need to tack a prefix
8344 insn1
= ((1ULL << 58) | (2ULL << 56) | (1ULL << 52)
8345 | (insn2
& ((63ULL << 26) | (31ULL << 21))));
8346 off
= insn2
& 0xffff;
8349 case 58: /* lwa, ld */
8350 if ((insn2
& 1) != 0)
8352 insn1
= ((1ULL << 58) | (1ULL << 52)
8353 | (insn2
& 2 ? 41ULL << 26 : 57ULL << 26)
8354 | (insn2
& (31ULL << 21)));
8355 off
= insn2
& 0xfffc;
8358 case 57: /* lxsd, lxssp */
8359 if ((insn2
& 3) < 2)
8361 insn1
= ((1ULL << 58) | (1ULL << 52)
8362 | ((40ULL | (insn2
& 3)) << 26)
8363 | (insn2
& (31ULL << 21)));
8364 off
= insn2
& 0xfffc;
8367 case 61: /* stxsd, stxssp, lxv, stxv */
8368 if ((insn2
& 3) == 0)
8370 else if ((insn2
& 3) >= 2)
8372 insn1
= ((1ULL << 58) | (1ULL << 52)
8373 | ((44ULL | (insn2
& 3)) << 26)
8374 | (insn2
& (31ULL << 21)));
8375 off
= insn2
& 0xfffc;
8379 insn1
= ((1ULL << 58) | (1ULL << 52)
8380 | ((50ULL | (insn2
& 4) | ((insn2
& 8) >> 3)) << 26)
8381 | (insn2
& (31ULL << 21)));
8382 off
= insn2
& 0xfff0;
8387 insn1
= ((1ULL << 58) | (1ULL << 52)
8388 | (insn2
& ((63ULL << 26) | (31ULL << 21))));
8389 off
= insn2
& 0xffff;
8392 case 62: /* std, stq */
8393 if ((insn2
& 1) != 0)
8395 insn1
= ((1ULL << 58) | (1ULL << 52)
8396 | ((insn2
& 2) == 0 ? 61ULL << 26 : 60ULL << 26)
8397 | (insn2
& (31ULL << 21)));
8398 off
= insn2
& 0xfffc;
8403 *pinsn2
= (uint64_t) NOP
<< 32;
8404 *poff
= (off
^ 0x8000) - 0x8000;
8408 /* Examine all relocs referencing .toc sections in order to remove
8409 unused .toc entries. */
8412 ppc64_elf_edit_toc (struct bfd_link_info
*info
)
8415 struct adjust_toc_info toc_inf
;
8416 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
8418 htab
->do_toc_opt
= 1;
8419 toc_inf
.global_toc_syms
= TRUE
;
8420 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
8422 asection
*toc
, *sec
;
8423 Elf_Internal_Shdr
*symtab_hdr
;
8424 Elf_Internal_Sym
*local_syms
;
8425 Elf_Internal_Rela
*relstart
, *rel
, *toc_relocs
;
8426 unsigned long *skip
, *drop
;
8427 unsigned char *used
;
8428 unsigned char *keep
, last
, some_unused
;
8430 if (!is_ppc64_elf (ibfd
))
8433 toc
= bfd_get_section_by_name (ibfd
, ".toc");
8436 || toc
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
8437 || discarded_section (toc
))
8442 symtab_hdr
= &elf_symtab_hdr (ibfd
);
8444 /* Look at sections dropped from the final link. */
8447 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
8449 if (sec
->reloc_count
== 0
8450 || !discarded_section (sec
)
8451 || get_opd_info (sec
)
8452 || (sec
->flags
& SEC_ALLOC
) == 0
8453 || (sec
->flags
& SEC_DEBUGGING
) != 0)
8456 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
, FALSE
);
8457 if (relstart
== NULL
)
8460 /* Run through the relocs to see which toc entries might be
8462 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
8464 enum elf_ppc64_reloc_type r_type
;
8465 unsigned long r_symndx
;
8467 struct elf_link_hash_entry
*h
;
8468 Elf_Internal_Sym
*sym
;
8471 r_type
= ELF64_R_TYPE (rel
->r_info
);
8478 case R_PPC64_TOC16_LO
:
8479 case R_PPC64_TOC16_HI
:
8480 case R_PPC64_TOC16_HA
:
8481 case R_PPC64_TOC16_DS
:
8482 case R_PPC64_TOC16_LO_DS
:
8486 r_symndx
= ELF64_R_SYM (rel
->r_info
);
8487 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
8495 val
= h
->root
.u
.def
.value
;
8497 val
= sym
->st_value
;
8498 val
+= rel
->r_addend
;
8500 if (val
>= toc
->size
)
8503 /* Anything in the toc ought to be aligned to 8 bytes.
8504 If not, don't mark as unused. */
8510 skip
= bfd_zmalloc (sizeof (*skip
) * (toc
->size
+ 15) / 8);
8515 skip
[val
>> 3] = ref_from_discarded
;
8518 if (elf_section_data (sec
)->relocs
!= relstart
)
8522 /* For largetoc loads of address constants, we can convert
8523 . addis rx,2,addr@got@ha
8524 . ld ry,addr@got@l(rx)
8526 . addis rx,2,addr@toc@ha
8527 . addi ry,rx,addr@toc@l
8528 when addr is within 2G of the toc pointer. This then means
8529 that the word storing "addr" in the toc is no longer needed. */
8531 if (!ppc64_elf_tdata (ibfd
)->has_small_toc_reloc
8532 && toc
->output_section
->rawsize
< (bfd_vma
) 1 << 31
8533 && toc
->reloc_count
!= 0)
8535 /* Read toc relocs. */
8536 toc_relocs
= _bfd_elf_link_read_relocs (ibfd
, toc
, NULL
, NULL
,
8538 if (toc_relocs
== NULL
)
8541 for (rel
= toc_relocs
; rel
< toc_relocs
+ toc
->reloc_count
; ++rel
)
8543 enum elf_ppc64_reloc_type r_type
;
8544 unsigned long r_symndx
;
8546 struct elf_link_hash_entry
*h
;
8547 Elf_Internal_Sym
*sym
;
8550 r_type
= ELF64_R_TYPE (rel
->r_info
);
8551 if (r_type
!= R_PPC64_ADDR64
)
8554 r_symndx
= ELF64_R_SYM (rel
->r_info
);
8555 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
8560 || sym_sec
->output_section
== NULL
8561 || discarded_section (sym_sec
))
8564 if (!SYMBOL_REFERENCES_LOCAL (info
, h
))
8569 if (h
->type
== STT_GNU_IFUNC
)
8571 val
= h
->root
.u
.def
.value
;
8575 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
8577 val
= sym
->st_value
;
8579 val
+= rel
->r_addend
;
8580 val
+= sym_sec
->output_section
->vma
+ sym_sec
->output_offset
;
8582 /* We don't yet know the exact toc pointer value, but we
8583 know it will be somewhere in the toc section. Don't
8584 optimize if the difference from any possible toc
8585 pointer is outside [ff..f80008000, 7fff7fff]. */
8586 addr
= toc
->output_section
->vma
+ TOC_BASE_OFF
;
8587 if (val
- addr
+ (bfd_vma
) 0x80008000 >= (bfd_vma
) 1 << 32)
8590 addr
= toc
->output_section
->vma
+ toc
->output_section
->rawsize
;
8591 if (val
- addr
+ (bfd_vma
) 0x80008000 >= (bfd_vma
) 1 << 32)
8596 skip
= bfd_zmalloc (sizeof (*skip
) * (toc
->size
+ 15) / 8);
8601 skip
[rel
->r_offset
>> 3]
8602 |= can_optimize
| ((rel
- toc_relocs
) << 2);
8609 used
= bfd_zmalloc (sizeof (*used
) * (toc
->size
+ 7) / 8);
8613 if (local_syms
!= NULL
8614 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
8618 && elf_section_data (sec
)->relocs
!= relstart
)
8620 if (toc_relocs
!= NULL
8621 && elf_section_data (toc
)->relocs
!= toc_relocs
)
8628 /* Now check all kept sections that might reference the toc.
8629 Check the toc itself last. */
8630 for (sec
= (ibfd
->sections
== toc
&& toc
->next
? toc
->next
8633 sec
= (sec
== toc
? NULL
8634 : sec
->next
== NULL
? toc
8635 : sec
->next
== toc
&& toc
->next
? toc
->next
8640 if (sec
->reloc_count
== 0
8641 || discarded_section (sec
)
8642 || get_opd_info (sec
)
8643 || (sec
->flags
& SEC_ALLOC
) == 0
8644 || (sec
->flags
& SEC_DEBUGGING
) != 0)
8647 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
8649 if (relstart
== NULL
)
8655 /* Mark toc entries referenced as used. */
8659 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
8661 enum elf_ppc64_reloc_type r_type
;
8662 unsigned long r_symndx
;
8664 struct elf_link_hash_entry
*h
;
8665 Elf_Internal_Sym
*sym
;
8668 r_type
= ELF64_R_TYPE (rel
->r_info
);
8672 case R_PPC64_TOC16_LO
:
8673 case R_PPC64_TOC16_HI
:
8674 case R_PPC64_TOC16_HA
:
8675 case R_PPC64_TOC16_DS
:
8676 case R_PPC64_TOC16_LO_DS
:
8677 /* In case we're taking addresses of toc entries. */
8678 case R_PPC64_ADDR64
:
8685 r_symndx
= ELF64_R_SYM (rel
->r_info
);
8686 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
8697 val
= h
->root
.u
.def
.value
;
8699 val
= sym
->st_value
;
8700 val
+= rel
->r_addend
;
8702 if (val
>= toc
->size
)
8705 if ((skip
[val
>> 3] & can_optimize
) != 0)
8712 case R_PPC64_TOC16_HA
:
8715 case R_PPC64_TOC16_LO_DS
:
8716 off
= rel
->r_offset
;
8717 off
+= (bfd_big_endian (ibfd
) ? -2 : 3);
8718 if (!bfd_get_section_contents (ibfd
, sec
, &opc
,
8724 if ((opc
& (0x3f << 2)) == (58u << 2))
8729 /* Wrong sort of reloc, or not a ld. We may
8730 as well clear ref_from_discarded too. */
8737 /* For the toc section, we only mark as used if this
8738 entry itself isn't unused. */
8739 else if ((used
[rel
->r_offset
>> 3]
8740 || !(skip
[rel
->r_offset
>> 3] & ref_from_discarded
))
8743 /* Do all the relocs again, to catch reference
8752 if (elf_section_data (sec
)->relocs
!= relstart
)
8756 /* Merge the used and skip arrays. Assume that TOC
8757 doublewords not appearing as either used or unused belong
8758 to an entry more than one doubleword in size. */
8759 for (drop
= skip
, keep
= used
, last
= 0, some_unused
= 0;
8760 drop
< skip
+ (toc
->size
+ 7) / 8;
8765 *drop
&= ~ref_from_discarded
;
8766 if ((*drop
& can_optimize
) != 0)
8770 else if ((*drop
& ref_from_discarded
) != 0)
8773 last
= ref_from_discarded
;
8783 bfd_byte
*contents
, *src
;
8785 Elf_Internal_Sym
*sym
;
8786 bfd_boolean local_toc_syms
= FALSE
;
8788 /* Shuffle the toc contents, and at the same time convert the
8789 skip array from booleans into offsets. */
8790 if (!bfd_malloc_and_get_section (ibfd
, toc
, &contents
))
8793 elf_section_data (toc
)->this_hdr
.contents
= contents
;
8795 for (src
= contents
, off
= 0, drop
= skip
;
8796 src
< contents
+ toc
->size
;
8799 if ((*drop
& (can_optimize
| ref_from_discarded
)) != 0)
8804 memcpy (src
- off
, src
, 8);
8808 toc
->rawsize
= toc
->size
;
8809 toc
->size
= src
- contents
- off
;
8811 /* Adjust addends for relocs against the toc section sym,
8812 and optimize any accesses we can. */
8813 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
8815 if (sec
->reloc_count
== 0
8816 || discarded_section (sec
))
8819 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
8821 if (relstart
== NULL
)
8824 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
8826 enum elf_ppc64_reloc_type r_type
;
8827 unsigned long r_symndx
;
8829 struct elf_link_hash_entry
*h
;
8832 r_type
= ELF64_R_TYPE (rel
->r_info
);
8839 case R_PPC64_TOC16_LO
:
8840 case R_PPC64_TOC16_HI
:
8841 case R_PPC64_TOC16_HA
:
8842 case R_PPC64_TOC16_DS
:
8843 case R_PPC64_TOC16_LO_DS
:
8844 case R_PPC64_ADDR64
:
8848 r_symndx
= ELF64_R_SYM (rel
->r_info
);
8849 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
8857 val
= h
->root
.u
.def
.value
;
8860 val
= sym
->st_value
;
8862 local_toc_syms
= TRUE
;
8865 val
+= rel
->r_addend
;
8867 if (val
> toc
->rawsize
)
8869 else if ((skip
[val
>> 3] & ref_from_discarded
) != 0)
8871 else if ((skip
[val
>> 3] & can_optimize
) != 0)
8873 Elf_Internal_Rela
*tocrel
8874 = toc_relocs
+ (skip
[val
>> 3] >> 2);
8875 unsigned long tsym
= ELF64_R_SYM (tocrel
->r_info
);
8879 case R_PPC64_TOC16_HA
:
8880 rel
->r_info
= ELF64_R_INFO (tsym
, R_PPC64_TOC16_HA
);
8883 case R_PPC64_TOC16_LO_DS
:
8884 rel
->r_info
= ELF64_R_INFO (tsym
, R_PPC64_LO_DS_OPT
);
8888 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
8890 info
->callbacks
->einfo
8891 /* xgettext:c-format */
8892 (_("%H: %s references "
8893 "optimized away TOC entry\n"),
8894 ibfd
, sec
, rel
->r_offset
,
8895 ppc64_elf_howto_table
[r_type
]->name
);
8896 bfd_set_error (bfd_error_bad_value
);
8899 rel
->r_addend
= tocrel
->r_addend
;
8900 elf_section_data (sec
)->relocs
= relstart
;
8904 if (h
!= NULL
|| sym
->st_value
!= 0)
8907 rel
->r_addend
-= skip
[val
>> 3];
8908 elf_section_data (sec
)->relocs
= relstart
;
8911 if (elf_section_data (sec
)->relocs
!= relstart
)
8915 /* We shouldn't have local or global symbols defined in the TOC,
8916 but handle them anyway. */
8917 if (local_syms
!= NULL
)
8918 for (sym
= local_syms
;
8919 sym
< local_syms
+ symtab_hdr
->sh_info
;
8921 if (sym
->st_value
!= 0
8922 && bfd_section_from_elf_index (ibfd
, sym
->st_shndx
) == toc
)
8926 if (sym
->st_value
> toc
->rawsize
)
8927 i
= toc
->rawsize
>> 3;
8929 i
= sym
->st_value
>> 3;
8931 if ((skip
[i
] & (ref_from_discarded
| can_optimize
)) != 0)
8935 (_("%s defined on removed toc entry"),
8936 bfd_elf_sym_name (ibfd
, symtab_hdr
, sym
, NULL
));
8939 while ((skip
[i
] & (ref_from_discarded
| can_optimize
)));
8940 sym
->st_value
= (bfd_vma
) i
<< 3;
8943 sym
->st_value
-= skip
[i
];
8944 symtab_hdr
->contents
= (unsigned char *) local_syms
;
8947 /* Adjust any global syms defined in this toc input section. */
8948 if (toc_inf
.global_toc_syms
)
8951 toc_inf
.skip
= skip
;
8952 toc_inf
.global_toc_syms
= FALSE
;
8953 elf_link_hash_traverse (elf_hash_table (info
), adjust_toc_syms
,
8957 if (toc
->reloc_count
!= 0)
8959 Elf_Internal_Shdr
*rel_hdr
;
8960 Elf_Internal_Rela
*wrel
;
8963 /* Remove unused toc relocs, and adjust those we keep. */
8964 if (toc_relocs
== NULL
)
8965 toc_relocs
= _bfd_elf_link_read_relocs (ibfd
, toc
, NULL
, NULL
,
8967 if (toc_relocs
== NULL
)
8971 for (rel
= toc_relocs
; rel
< toc_relocs
+ toc
->reloc_count
; ++rel
)
8972 if ((skip
[rel
->r_offset
>> 3]
8973 & (ref_from_discarded
| can_optimize
)) == 0)
8975 wrel
->r_offset
= rel
->r_offset
- skip
[rel
->r_offset
>> 3];
8976 wrel
->r_info
= rel
->r_info
;
8977 wrel
->r_addend
= rel
->r_addend
;
8980 else if (!dec_dynrel_count (rel
->r_info
, toc
, info
,
8981 &local_syms
, NULL
, NULL
))
8984 elf_section_data (toc
)->relocs
= toc_relocs
;
8985 toc
->reloc_count
= wrel
- toc_relocs
;
8986 rel_hdr
= _bfd_elf_single_rel_hdr (toc
);
8987 sz
= rel_hdr
->sh_entsize
;
8988 rel_hdr
->sh_size
= toc
->reloc_count
* sz
;
8991 else if (toc_relocs
!= NULL
8992 && elf_section_data (toc
)->relocs
!= toc_relocs
)
8995 if (local_syms
!= NULL
8996 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
8998 if (!info
->keep_memory
)
9001 symtab_hdr
->contents
= (unsigned char *) local_syms
;
9006 /* Look for cases where we can change an indirect GOT access to
9007 a GOT relative or PC relative access, possibly reducing the
9008 number of GOT entries. */
9009 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
9012 Elf_Internal_Shdr
*symtab_hdr
;
9013 Elf_Internal_Sym
*local_syms
;
9014 Elf_Internal_Rela
*relstart
, *rel
;
9017 if (!is_ppc64_elf (ibfd
))
9020 if (!ppc64_elf_tdata (ibfd
)->has_optrel
)
9023 sec
= ppc64_elf_tdata (ibfd
)->got
;
9026 got
= sec
->output_section
->vma
+ sec
->output_offset
+ 0x8000;
9029 symtab_hdr
= &elf_symtab_hdr (ibfd
);
9031 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
9033 if (sec
->reloc_count
== 0
9034 || !ppc64_elf_section_data (sec
)->has_optrel
9035 || discarded_section (sec
))
9038 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
9040 if (relstart
== NULL
)
9043 if (local_syms
!= NULL
9044 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
9048 && elf_section_data (sec
)->relocs
!= relstart
)
9053 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
9055 enum elf_ppc64_reloc_type r_type
;
9056 unsigned long r_symndx
;
9057 Elf_Internal_Sym
*sym
;
9059 struct elf_link_hash_entry
*h
;
9060 struct got_entry
*ent
;
9062 unsigned char buf
[8];
9064 enum {no_check
, check_lo
, check_ha
} insn_check
;
9066 r_type
= ELF64_R_TYPE (rel
->r_info
);
9070 insn_check
= no_check
;
9073 case R_PPC64_PLT16_HA
:
9074 case R_PPC64_GOT_TLSLD16_HA
:
9075 case R_PPC64_GOT_TLSGD16_HA
:
9076 case R_PPC64_GOT_TPREL16_HA
:
9077 case R_PPC64_GOT_DTPREL16_HA
:
9078 case R_PPC64_GOT16_HA
:
9079 case R_PPC64_TOC16_HA
:
9080 insn_check
= check_ha
;
9083 case R_PPC64_PLT16_LO
:
9084 case R_PPC64_PLT16_LO_DS
:
9085 case R_PPC64_GOT_TLSLD16_LO
:
9086 case R_PPC64_GOT_TLSGD16_LO
:
9087 case R_PPC64_GOT_TPREL16_LO_DS
:
9088 case R_PPC64_GOT_DTPREL16_LO_DS
:
9089 case R_PPC64_GOT16_LO
:
9090 case R_PPC64_GOT16_LO_DS
:
9091 case R_PPC64_TOC16_LO
:
9092 case R_PPC64_TOC16_LO_DS
:
9093 insn_check
= check_lo
;
9097 if (insn_check
!= no_check
)
9099 bfd_vma off
= rel
->r_offset
& ~3;
9101 if (!bfd_get_section_contents (ibfd
, sec
, buf
, off
, 4))
9104 insn
= bfd_get_32 (ibfd
, buf
);
9105 if (insn_check
== check_lo
9106 ? !ok_lo_toc_insn (insn
, r_type
)
9107 : ((insn
& ((0x3f << 26) | 0x1f << 16))
9108 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9112 ppc64_elf_tdata (ibfd
)->unexpected_toc_insn
= 1;
9113 sprintf (str
, "%#08x", insn
);
9114 info
->callbacks
->einfo
9115 /* xgettext:c-format */
9116 (_("%H: got/toc optimization is not supported for"
9117 " %s instruction\n"),
9118 ibfd
, sec
, rel
->r_offset
& ~3, str
);
9125 /* Note that we don't delete GOT entries for
9126 R_PPC64_GOT16_DS since we'd need a lot more
9127 analysis. For starters, the preliminary layout is
9128 before the GOT, PLT, dynamic sections and stubs are
9129 laid out. Then we'd need to allow for changes in
9130 distance between sections caused by alignment. */
9134 case R_PPC64_GOT16_HA
:
9135 case R_PPC64_GOT16_LO_DS
:
9136 case R_PPC64_GOT_PCREL34
:
9140 r_symndx
= ELF64_R_SYM (rel
->r_info
);
9141 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
9146 || sym_sec
->output_section
== NULL
9147 || discarded_section (sym_sec
))
9150 if (!SYMBOL_REFERENCES_LOCAL (info
, h
))
9154 val
= h
->root
.u
.def
.value
;
9156 val
= sym
->st_value
;
9157 val
+= rel
->r_addend
;
9158 val
+= sym_sec
->output_section
->vma
+ sym_sec
->output_offset
;
9160 /* Fudge factor to allow for the fact that the preliminary layout
9161 isn't exact. Reduce limits by this factor. */
9162 #define LIMIT_ADJUST(LIMIT) ((LIMIT) - (LIMIT) / 16)
9169 case R_PPC64_GOT16_HA
:
9170 if (val
- got
+ LIMIT_ADJUST (0x80008000ULL
)
9171 >= LIMIT_ADJUST (0x100000000ULL
))
9174 if (!bfd_get_section_contents (ibfd
, sec
, buf
,
9175 rel
->r_offset
& ~3, 4))
9177 insn
= bfd_get_32 (ibfd
, buf
);
9178 if (((insn
& ((0x3f << 26) | 0x1f << 16))
9179 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9183 case R_PPC64_GOT16_LO_DS
:
9184 if (val
- got
+ LIMIT_ADJUST (0x80008000ULL
)
9185 >= LIMIT_ADJUST (0x100000000ULL
))
9187 if (!bfd_get_section_contents (ibfd
, sec
, buf
,
9188 rel
->r_offset
& ~3, 4))
9190 insn
= bfd_get_32 (ibfd
, buf
);
9191 if ((insn
& (0x3f << 26 | 0x3)) != 58u << 26 /* ld */)
9195 case R_PPC64_GOT_PCREL34
:
9197 pc
+= sec
->output_section
->vma
+ sec
->output_offset
;
9198 if (val
- pc
+ LIMIT_ADJUST (1ULL << 33)
9199 >= LIMIT_ADJUST (1ULL << 34))
9201 if (!bfd_get_section_contents (ibfd
, sec
, buf
,
9202 rel
->r_offset
& ~3, 8))
9204 insn
= bfd_get_32 (ibfd
, buf
);
9205 if ((insn
& (-1u << 18)) != ((1u << 26) | (1u << 20)))
9207 insn
= bfd_get_32 (ibfd
, buf
+ 4);
9208 if ((insn
& (0x3f << 26)) != 57u << 26)
9218 struct got_entry
**local_got_ents
= elf_local_got_ents (ibfd
);
9219 ent
= local_got_ents
[r_symndx
];
9221 for (; ent
!= NULL
; ent
= ent
->next
)
9222 if (ent
->addend
== rel
->r_addend
9223 && ent
->owner
== ibfd
9224 && ent
->tls_type
== 0)
9226 BFD_ASSERT (ent
&& ent
->got
.refcount
> 0);
9227 ent
->got
.refcount
-= 1;
9230 if (elf_section_data (sec
)->relocs
!= relstart
)
9234 if (local_syms
!= NULL
9235 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
9237 if (!info
->keep_memory
)
9240 symtab_hdr
->contents
= (unsigned char *) local_syms
;
9247 /* Return true iff input section I references the TOC using
9248 instructions limited to +/-32k offsets. */
9251 ppc64_elf_has_small_toc_reloc (asection
*i
)
9253 return (is_ppc64_elf (i
->owner
)
9254 && ppc64_elf_tdata (i
->owner
)->has_small_toc_reloc
);
9257 /* Allocate space for one GOT entry. */
9260 allocate_got (struct elf_link_hash_entry
*h
,
9261 struct bfd_link_info
*info
,
9262 struct got_entry
*gent
)
9264 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
9265 struct ppc_link_hash_entry
*eh
= (struct ppc_link_hash_entry
*) h
;
9266 int entsize
= (gent
->tls_type
& eh
->tls_mask
& (TLS_GD
| TLS_LD
)
9268 int rentsize
= (gent
->tls_type
& eh
->tls_mask
& TLS_GD
9269 ? 2 : 1) * sizeof (Elf64_External_Rela
);
9270 asection
*got
= ppc64_elf_tdata (gent
->owner
)->got
;
9272 gent
->got
.offset
= got
->size
;
9273 got
->size
+= entsize
;
9275 if (h
->type
== STT_GNU_IFUNC
)
9277 htab
->elf
.irelplt
->size
+= rentsize
;
9278 htab
->got_reli_size
+= rentsize
;
9280 else if (((bfd_link_pic (info
)
9281 && !((gent
->tls_type
& TLS_TPREL
) != 0
9282 && bfd_link_executable (info
)
9283 && SYMBOL_REFERENCES_LOCAL (info
, h
)))
9284 || (htab
->elf
.dynamic_sections_created
9286 && !SYMBOL_REFERENCES_LOCAL (info
, h
)))
9287 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
9289 asection
*relgot
= ppc64_elf_tdata (gent
->owner
)->relgot
;
9290 relgot
->size
+= rentsize
;
9294 /* This function merges got entries in the same toc group. */
9297 merge_got_entries (struct got_entry
**pent
)
9299 struct got_entry
*ent
, *ent2
;
9301 for (ent
= *pent
; ent
!= NULL
; ent
= ent
->next
)
9302 if (!ent
->is_indirect
)
9303 for (ent2
= ent
->next
; ent2
!= NULL
; ent2
= ent2
->next
)
9304 if (!ent2
->is_indirect
9305 && ent2
->addend
== ent
->addend
9306 && ent2
->tls_type
== ent
->tls_type
9307 && elf_gp (ent2
->owner
) == elf_gp (ent
->owner
))
9309 ent2
->is_indirect
= TRUE
;
9310 ent2
->got
.ent
= ent
;
9314 /* If H is undefined, make it dynamic if that makes sense. */
9317 ensure_undef_dynamic (struct bfd_link_info
*info
,
9318 struct elf_link_hash_entry
*h
)
9320 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
9322 if (htab
->dynamic_sections_created
9323 && ((info
->dynamic_undefined_weak
!= 0
9324 && h
->root
.type
== bfd_link_hash_undefweak
)
9325 || h
->root
.type
== bfd_link_hash_undefined
)
9328 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
9329 return bfd_elf_link_record_dynamic_symbol (info
, h
);
9333 /* Allocate space in .plt, .got and associated reloc sections for
9337 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
9339 struct bfd_link_info
*info
;
9340 struct ppc_link_hash_table
*htab
;
9342 struct ppc_link_hash_entry
*eh
;
9343 struct got_entry
**pgent
, *gent
;
9345 if (h
->root
.type
== bfd_link_hash_indirect
)
9348 info
= (struct bfd_link_info
*) inf
;
9349 htab
= ppc_hash_table (info
);
9353 eh
= (struct ppc_link_hash_entry
*) h
;
9354 /* Run through the TLS GD got entries first if we're changing them
9356 if ((eh
->tls_mask
& (TLS_TLS
| TLS_GDIE
)) == (TLS_TLS
| TLS_GDIE
))
9357 for (gent
= h
->got
.glist
; gent
!= NULL
; gent
= gent
->next
)
9358 if (gent
->got
.refcount
> 0
9359 && (gent
->tls_type
& TLS_GD
) != 0)
9361 /* This was a GD entry that has been converted to TPREL. If
9362 there happens to be a TPREL entry we can use that one. */
9363 struct got_entry
*ent
;
9364 for (ent
= h
->got
.glist
; ent
!= NULL
; ent
= ent
->next
)
9365 if (ent
->got
.refcount
> 0
9366 && (ent
->tls_type
& TLS_TPREL
) != 0
9367 && ent
->addend
== gent
->addend
9368 && ent
->owner
== gent
->owner
)
9370 gent
->got
.refcount
= 0;
9374 /* If not, then we'll be using our own TPREL entry. */
9375 if (gent
->got
.refcount
!= 0)
9376 gent
->tls_type
= TLS_TLS
| TLS_TPREL
;
9379 /* Remove any list entry that won't generate a word in the GOT before
9380 we call merge_got_entries. Otherwise we risk merging to empty
9382 pgent
= &h
->got
.glist
;
9383 while ((gent
= *pgent
) != NULL
)
9384 if (gent
->got
.refcount
> 0)
9386 if ((gent
->tls_type
& TLS_LD
) != 0
9389 ppc64_tlsld_got (gent
->owner
)->got
.refcount
+= 1;
9390 *pgent
= gent
->next
;
9393 pgent
= &gent
->next
;
9396 *pgent
= gent
->next
;
9398 if (!htab
->do_multi_toc
)
9399 merge_got_entries (&h
->got
.glist
);
9401 for (gent
= h
->got
.glist
; gent
!= NULL
; gent
= gent
->next
)
9402 if (!gent
->is_indirect
)
9404 /* Ensure we catch all the cases where this symbol should
9406 if (!ensure_undef_dynamic (info
, h
))
9409 if (!is_ppc64_elf (gent
->owner
))
9412 allocate_got (h
, info
, gent
);
9415 /* If no dynamic sections we can't have dynamic relocs, except for
9416 IFUNCs which are handled even in static executables. */
9417 if (!htab
->elf
.dynamic_sections_created
9418 && h
->type
!= STT_GNU_IFUNC
)
9419 eh
->dyn_relocs
= NULL
;
9421 /* Discard relocs on undefined symbols that must be local. */
9422 else if (h
->root
.type
== bfd_link_hash_undefined
9423 && ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
9424 eh
->dyn_relocs
= NULL
;
9426 /* Also discard relocs on undefined weak syms with non-default
9427 visibility, or when dynamic_undefined_weak says so. */
9428 else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
9429 eh
->dyn_relocs
= NULL
;
9431 if (eh
->dyn_relocs
!= NULL
)
9433 struct elf_dyn_relocs
*p
, **pp
;
9435 /* In the shared -Bsymbolic case, discard space allocated for
9436 dynamic pc-relative relocs against symbols which turn out to
9437 be defined in regular objects. For the normal shared case,
9438 discard space for relocs that have become local due to symbol
9439 visibility changes. */
9440 if (bfd_link_pic (info
))
9442 /* Relocs that use pc_count are those that appear on a call
9443 insn, or certain REL relocs (see must_be_dyn_reloc) that
9444 can be generated via assembly. We want calls to
9445 protected symbols to resolve directly to the function
9446 rather than going via the plt. If people want function
9447 pointer comparisons to work as expected then they should
9448 avoid writing weird assembly. */
9449 if (SYMBOL_CALLS_LOCAL (info
, h
))
9451 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
9453 p
->count
-= p
->pc_count
;
9462 if (eh
->dyn_relocs
!= NULL
)
9464 /* Ensure we catch all the cases where this symbol
9465 should be made dynamic. */
9466 if (!ensure_undef_dynamic (info
, h
))
9471 /* For a fixed position executable, discard space for
9472 relocs against symbols which are not dynamic. */
9473 else if (h
->type
!= STT_GNU_IFUNC
)
9475 if (h
->dynamic_adjusted
9477 && !ELF_COMMON_DEF_P (h
))
9479 /* Ensure we catch all the cases where this symbol
9480 should be made dynamic. */
9481 if (!ensure_undef_dynamic (info
, h
))
9484 /* But if that didn't work out, discard dynamic relocs. */
9485 if (h
->dynindx
== -1)
9486 eh
->dyn_relocs
= NULL
;
9489 eh
->dyn_relocs
= NULL
;
9492 /* Finally, allocate space. */
9493 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
9495 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
9496 if (eh
->elf
.type
== STT_GNU_IFUNC
)
9497 sreloc
= htab
->elf
.irelplt
;
9498 sreloc
->size
+= p
->count
* sizeof (Elf64_External_Rela
);
9502 /* We might need a PLT entry when the symbol
9505 c) has plt16 relocs and has been processed by adjust_dynamic_symbol, or
9506 d) has plt16 relocs and we are linking statically. */
9507 if ((htab
->elf
.dynamic_sections_created
&& h
->dynindx
!= -1)
9508 || h
->type
== STT_GNU_IFUNC
9509 || (h
->needs_plt
&& h
->dynamic_adjusted
)
9512 && !htab
->elf
.dynamic_sections_created
9513 && !htab
->can_convert_all_inline_plt
9514 && (((struct ppc_link_hash_entry
*) h
)->tls_mask
9515 & (TLS_TLS
| PLT_KEEP
)) == PLT_KEEP
))
9517 struct plt_entry
*pent
;
9518 bfd_boolean doneone
= FALSE
;
9519 for (pent
= h
->plt
.plist
; pent
!= NULL
; pent
= pent
->next
)
9520 if (pent
->plt
.refcount
> 0)
9522 if (!htab
->elf
.dynamic_sections_created
9523 || h
->dynindx
== -1)
9525 if (h
->type
== STT_GNU_IFUNC
)
9528 pent
->plt
.offset
= s
->size
;
9529 s
->size
+= PLT_ENTRY_SIZE (htab
);
9530 s
= htab
->elf
.irelplt
;
9535 pent
->plt
.offset
= s
->size
;
9536 s
->size
+= LOCAL_PLT_ENTRY_SIZE (htab
);
9537 s
= bfd_link_pic (info
) ? htab
->relpltlocal
: NULL
;
9542 /* If this is the first .plt entry, make room for the special
9546 s
->size
+= PLT_INITIAL_ENTRY_SIZE (htab
);
9548 pent
->plt
.offset
= s
->size
;
9550 /* Make room for this entry. */
9551 s
->size
+= PLT_ENTRY_SIZE (htab
);
9553 /* Make room for the .glink code. */
9556 s
->size
+= GLINK_PLTRESOLVE_SIZE (htab
);
9559 /* We need bigger stubs past index 32767. */
9560 if (s
->size
>= GLINK_PLTRESOLVE_SIZE (htab
) + 32768*2*4)
9567 /* We also need to make an entry in the .rela.plt section. */
9568 s
= htab
->elf
.srelplt
;
9571 s
->size
+= sizeof (Elf64_External_Rela
);
9575 pent
->plt
.offset
= (bfd_vma
) -1;
9578 h
->plt
.plist
= NULL
;
9584 h
->plt
.plist
= NULL
;
9591 #define PPC_LO(v) ((v) & 0xffff)
9592 #define PPC_HI(v) (((v) >> 16) & 0xffff)
9593 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
9595 ((((v) & 0x3ffff0000ULL) << 16) | (v & 0xffff))
9596 #define HA34(v) ((v + (1ULL << 33)) >> 34)
9598 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9599 to set up space for global entry stubs. These are put in glink,
9600 after the branch table. */
9603 size_global_entry_stubs (struct elf_link_hash_entry
*h
, void *inf
)
9605 struct bfd_link_info
*info
;
9606 struct ppc_link_hash_table
*htab
;
9607 struct plt_entry
*pent
;
9610 if (h
->root
.type
== bfd_link_hash_indirect
)
9613 if (!h
->pointer_equality_needed
)
9620 htab
= ppc_hash_table (info
);
9624 s
= htab
->global_entry
;
9625 plt
= htab
->elf
.splt
;
9626 for (pent
= h
->plt
.plist
; pent
!= NULL
; pent
= pent
->next
)
9627 if (pent
->plt
.offset
!= (bfd_vma
) -1
9628 && pent
->addend
== 0)
9630 /* For ELFv2, if this symbol is not defined in a regular file
9631 and we are not generating a shared library or pie, then we
9632 need to define the symbol in the executable on a call stub.
9633 This is to avoid text relocations. */
9634 bfd_vma off
, stub_align
, stub_off
, stub_size
;
9635 unsigned int align_power
;
9639 if (htab
->params
->plt_stub_align
>= 0)
9640 align_power
= htab
->params
->plt_stub_align
;
9642 align_power
= -htab
->params
->plt_stub_align
;
9643 /* Setting section alignment is delayed until we know it is
9644 non-empty. Otherwise the .text output section will be
9645 aligned at least to plt_stub_align even when no global
9646 entry stubs are needed. */
9647 if (s
->alignment_power
< align_power
)
9648 s
->alignment_power
= align_power
;
9649 stub_align
= (bfd_vma
) 1 << align_power
;
9650 if (htab
->params
->plt_stub_align
>= 0
9651 || ((((stub_off
+ stub_size
- 1) & -stub_align
)
9652 - (stub_off
& -stub_align
))
9653 > ((stub_size
- 1) & -stub_align
)))
9654 stub_off
= (stub_off
+ stub_align
- 1) & -stub_align
;
9655 off
= pent
->plt
.offset
+ plt
->output_offset
+ plt
->output_section
->vma
;
9656 off
-= stub_off
+ s
->output_offset
+ s
->output_section
->vma
;
9657 /* Note that for --plt-stub-align negative we have a possible
9658 dependency between stub offset and size. Break that
9659 dependency by assuming the max stub size when calculating
9661 if (PPC_HA (off
) == 0)
9663 h
->root
.type
= bfd_link_hash_defined
;
9664 h
->root
.u
.def
.section
= s
;
9665 h
->root
.u
.def
.value
= stub_off
;
9666 s
->size
= stub_off
+ stub_size
;
9672 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9673 read-only sections. */
9676 maybe_set_textrel (struct elf_link_hash_entry
*h
, void *inf
)
9680 if (h
->root
.type
== bfd_link_hash_indirect
)
9683 sec
= readonly_dynrelocs (h
);
9686 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
9688 info
->flags
|= DF_TEXTREL
;
9689 info
->callbacks
->minfo (_("%pB: dynamic relocation against `%pT'"
9690 " in read-only section `%pA'\n"),
9691 sec
->owner
, h
->root
.root
.string
, sec
);
9693 /* Not an error, just cut short the traversal. */
9699 /* Set the sizes of the dynamic sections. */
9702 ppc64_elf_size_dynamic_sections (bfd
*output_bfd
,
9703 struct bfd_link_info
*info
)
9705 struct ppc_link_hash_table
*htab
;
9710 struct got_entry
*first_tlsld
;
9712 htab
= ppc_hash_table (info
);
9716 dynobj
= htab
->elf
.dynobj
;
9720 if (htab
->elf
.dynamic_sections_created
)
9722 /* Set the contents of the .interp section to the interpreter. */
9723 if (bfd_link_executable (info
) && !info
->nointerp
)
9725 s
= bfd_get_linker_section (dynobj
, ".interp");
9728 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
9729 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
9733 /* Set up .got offsets for local syms, and space for local dynamic
9735 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
9737 struct got_entry
**lgot_ents
;
9738 struct got_entry
**end_lgot_ents
;
9739 struct plt_entry
**local_plt
;
9740 struct plt_entry
**end_local_plt
;
9741 unsigned char *lgot_masks
;
9742 bfd_size_type locsymcount
;
9743 Elf_Internal_Shdr
*symtab_hdr
;
9745 if (!is_ppc64_elf (ibfd
))
9748 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
9750 struct ppc_dyn_relocs
*p
;
9752 for (p
= elf_section_data (s
)->local_dynrel
; p
!= NULL
; p
= p
->next
)
9754 if (!bfd_is_abs_section (p
->sec
)
9755 && bfd_is_abs_section (p
->sec
->output_section
))
9757 /* Input section has been discarded, either because
9758 it is a copy of a linkonce section or due to
9759 linker script /DISCARD/, so we'll be discarding
9762 else if (p
->count
!= 0)
9764 asection
*srel
= elf_section_data (p
->sec
)->sreloc
;
9766 srel
= htab
->elf
.irelplt
;
9767 srel
->size
+= p
->count
* sizeof (Elf64_External_Rela
);
9768 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
9769 info
->flags
|= DF_TEXTREL
;
9774 lgot_ents
= elf_local_got_ents (ibfd
);
9778 symtab_hdr
= &elf_symtab_hdr (ibfd
);
9779 locsymcount
= symtab_hdr
->sh_info
;
9780 end_lgot_ents
= lgot_ents
+ locsymcount
;
9781 local_plt
= (struct plt_entry
**) end_lgot_ents
;
9782 end_local_plt
= local_plt
+ locsymcount
;
9783 lgot_masks
= (unsigned char *) end_local_plt
;
9784 s
= ppc64_elf_tdata (ibfd
)->got
;
9785 for (; lgot_ents
< end_lgot_ents
; ++lgot_ents
, ++lgot_masks
)
9787 struct got_entry
**pent
, *ent
;
9790 while ((ent
= *pent
) != NULL
)
9791 if (ent
->got
.refcount
> 0)
9793 if ((ent
->tls_type
& *lgot_masks
& TLS_LD
) != 0)
9795 ppc64_tlsld_got (ibfd
)->got
.refcount
+= 1;
9800 unsigned int ent_size
= 8;
9801 unsigned int rel_size
= sizeof (Elf64_External_Rela
);
9803 ent
->got
.offset
= s
->size
;
9804 if ((ent
->tls_type
& *lgot_masks
& TLS_GD
) != 0)
9809 s
->size
+= ent_size
;
9810 if ((*lgot_masks
& (TLS_TLS
| PLT_IFUNC
)) == PLT_IFUNC
)
9812 htab
->elf
.irelplt
->size
+= rel_size
;
9813 htab
->got_reli_size
+= rel_size
;
9815 else if (bfd_link_pic (info
)
9816 && !((ent
->tls_type
& TLS_TPREL
) != 0
9817 && bfd_link_executable (info
)))
9819 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
9820 srel
->size
+= rel_size
;
9829 /* Allocate space for plt calls to local syms. */
9830 lgot_masks
= (unsigned char *) end_local_plt
;
9831 for (; local_plt
< end_local_plt
; ++local_plt
, ++lgot_masks
)
9833 struct plt_entry
*ent
;
9835 for (ent
= *local_plt
; ent
!= NULL
; ent
= ent
->next
)
9836 if (ent
->plt
.refcount
> 0)
9838 if ((*lgot_masks
& (TLS_TLS
| PLT_IFUNC
)) == PLT_IFUNC
)
9841 ent
->plt
.offset
= s
->size
;
9842 s
->size
+= PLT_ENTRY_SIZE (htab
);
9843 htab
->elf
.irelplt
->size
+= sizeof (Elf64_External_Rela
);
9845 else if (htab
->can_convert_all_inline_plt
9846 || (*lgot_masks
& (TLS_TLS
| PLT_KEEP
)) != PLT_KEEP
)
9847 ent
->plt
.offset
= (bfd_vma
) -1;
9851 ent
->plt
.offset
= s
->size
;
9852 s
->size
+= LOCAL_PLT_ENTRY_SIZE (htab
);
9853 if (bfd_link_pic (info
))
9854 htab
->relpltlocal
->size
+= sizeof (Elf64_External_Rela
);
9858 ent
->plt
.offset
= (bfd_vma
) -1;
9862 /* Allocate global sym .plt and .got entries, and space for global
9863 sym dynamic relocs. */
9864 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, info
);
9866 if (!htab
->opd_abi
&& !bfd_link_pic (info
))
9867 elf_link_hash_traverse (&htab
->elf
, size_global_entry_stubs
, info
);
9870 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
9872 struct got_entry
*ent
;
9874 if (!is_ppc64_elf (ibfd
))
9877 ent
= ppc64_tlsld_got (ibfd
);
9878 if (ent
->got
.refcount
> 0)
9880 if (!htab
->do_multi_toc
&& first_tlsld
!= NULL
)
9882 ent
->is_indirect
= TRUE
;
9883 ent
->got
.ent
= first_tlsld
;
9887 if (first_tlsld
== NULL
)
9889 s
= ppc64_elf_tdata (ibfd
)->got
;
9890 ent
->got
.offset
= s
->size
;
9893 if (bfd_link_pic (info
))
9895 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
9896 srel
->size
+= sizeof (Elf64_External_Rela
);
9901 ent
->got
.offset
= (bfd_vma
) -1;
9904 /* We now have determined the sizes of the various dynamic sections.
9905 Allocate memory for them. */
9907 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
9909 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
9912 if (s
== htab
->brlt
|| s
== htab
->relbrlt
)
9913 /* These haven't been allocated yet; don't strip. */
9915 else if (s
== htab
->elf
.sgot
9916 || s
== htab
->elf
.splt
9917 || s
== htab
->elf
.iplt
9918 || s
== htab
->pltlocal
9920 || s
== htab
->global_entry
9921 || s
== htab
->elf
.sdynbss
9922 || s
== htab
->elf
.sdynrelro
)
9924 /* Strip this section if we don't need it; see the
9927 else if (s
== htab
->glink_eh_frame
)
9929 if (!bfd_is_abs_section (s
->output_section
))
9930 /* Not sized yet. */
9933 else if (CONST_STRNEQ (s
->name
, ".rela"))
9937 if (s
!= htab
->elf
.srelplt
)
9940 /* We use the reloc_count field as a counter if we need
9941 to copy relocs into the output file. */
9947 /* It's not one of our sections, so don't allocate space. */
9953 /* If we don't need this section, strip it from the
9954 output file. This is mostly to handle .rela.bss and
9955 .rela.plt. We must create both sections in
9956 create_dynamic_sections, because they must be created
9957 before the linker maps input sections to output
9958 sections. The linker does that before
9959 adjust_dynamic_symbol is called, and it is that
9960 function which decides whether anything needs to go
9961 into these sections. */
9962 s
->flags
|= SEC_EXCLUDE
;
9966 if (bfd_is_abs_section (s
->output_section
))
9967 _bfd_error_handler (_("warning: discarding dynamic section %s"),
9970 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
9973 /* Allocate memory for the section contents. We use bfd_zalloc
9974 here in case unused entries are not reclaimed before the
9975 section's contents are written out. This should not happen,
9976 but this way if it does we get a R_PPC64_NONE reloc in .rela
9977 sections instead of garbage.
9978 We also rely on the section contents being zero when writing
9979 the GOT and .dynrelro. */
9980 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
9981 if (s
->contents
== NULL
)
9985 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
9987 if (!is_ppc64_elf (ibfd
))
9990 s
= ppc64_elf_tdata (ibfd
)->got
;
9991 if (s
!= NULL
&& s
!= htab
->elf
.sgot
)
9994 s
->flags
|= SEC_EXCLUDE
;
9997 s
->contents
= bfd_zalloc (ibfd
, s
->size
);
9998 if (s
->contents
== NULL
)
10002 s
= ppc64_elf_tdata (ibfd
)->relgot
;
10006 s
->flags
|= SEC_EXCLUDE
;
10009 s
->contents
= bfd_zalloc (ibfd
, s
->size
);
10010 if (s
->contents
== NULL
)
10013 s
->reloc_count
= 0;
10018 if (htab
->elf
.dynamic_sections_created
)
10020 bfd_boolean tls_opt
;
10022 /* Add some entries to the .dynamic section. We fill in the
10023 values later, in ppc64_elf_finish_dynamic_sections, but we
10024 must add the entries now so that we get the correct size for
10025 the .dynamic section. The DT_DEBUG entry is filled in by the
10026 dynamic linker and used by the debugger. */
10027 #define add_dynamic_entry(TAG, VAL) \
10028 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10030 if (bfd_link_executable (info
))
10032 if (!add_dynamic_entry (DT_DEBUG
, 0))
10036 if (htab
->elf
.splt
!= NULL
&& htab
->elf
.splt
->size
!= 0)
10038 if (!add_dynamic_entry (DT_PLTGOT
, 0)
10039 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
10040 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
10041 || !add_dynamic_entry (DT_JMPREL
, 0)
10042 || !add_dynamic_entry (DT_PPC64_GLINK
, 0))
10046 if (NO_OPD_RELOCS
&& abiversion (output_bfd
) <= 1)
10048 if (!add_dynamic_entry (DT_PPC64_OPD
, 0)
10049 || !add_dynamic_entry (DT_PPC64_OPDSZ
, 0))
10053 tls_opt
= (htab
->params
->tls_get_addr_opt
10054 && htab
->tls_get_addr_fd
!= NULL
10055 && htab
->tls_get_addr_fd
->elf
.plt
.plist
!= NULL
);
10056 if (tls_opt
|| !htab
->opd_abi
)
10058 if (!add_dynamic_entry (DT_PPC64_OPT
, tls_opt
? PPC64_OPT_TLS
: 0))
10064 if (!add_dynamic_entry (DT_RELA
, 0)
10065 || !add_dynamic_entry (DT_RELASZ
, 0)
10066 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf64_External_Rela
)))
10069 /* If any dynamic relocs apply to a read-only section,
10070 then we need a DT_TEXTREL entry. */
10071 if ((info
->flags
& DF_TEXTREL
) == 0)
10072 elf_link_hash_traverse (&htab
->elf
, maybe_set_textrel
, info
);
10074 if ((info
->flags
& DF_TEXTREL
) != 0)
10076 if (!add_dynamic_entry (DT_TEXTREL
, 0))
10081 #undef add_dynamic_entry
10086 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
10089 ppc64_elf_hash_symbol (struct elf_link_hash_entry
*h
)
10091 if (h
->plt
.plist
!= NULL
10093 && !h
->pointer_equality_needed
)
10096 return _bfd_elf_hash_symbol (h
);
10099 /* Determine the type of stub needed, if any, for a call. */
10101 static inline enum ppc_stub_type
10102 ppc_type_of_stub (asection
*input_sec
,
10103 const Elf_Internal_Rela
*rel
,
10104 struct ppc_link_hash_entry
**hash
,
10105 struct plt_entry
**plt_ent
,
10106 bfd_vma destination
,
10107 unsigned long local_off
)
10109 struct ppc_link_hash_entry
*h
= *hash
;
10111 bfd_vma branch_offset
;
10112 bfd_vma max_branch_offset
;
10113 enum elf_ppc64_reloc_type r_type
;
10117 struct plt_entry
*ent
;
10118 struct ppc_link_hash_entry
*fdh
= h
;
10120 && h
->oh
->is_func_descriptor
)
10122 fdh
= ppc_follow_link (h
->oh
);
10126 for (ent
= fdh
->elf
.plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
10127 if (ent
->addend
== rel
->r_addend
10128 && ent
->plt
.offset
!= (bfd_vma
) -1)
10131 return ppc_stub_plt_call
;
10134 /* Here, we know we don't have a plt entry. If we don't have a
10135 either a defined function descriptor or a defined entry symbol
10136 in a regular object file, then it is pointless trying to make
10137 any other type of stub. */
10138 if (!is_static_defined (&fdh
->elf
)
10139 && !is_static_defined (&h
->elf
))
10140 return ppc_stub_none
;
10142 else if (elf_local_got_ents (input_sec
->owner
) != NULL
)
10144 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (input_sec
->owner
);
10145 struct plt_entry
**local_plt
= (struct plt_entry
**)
10146 elf_local_got_ents (input_sec
->owner
) + symtab_hdr
->sh_info
;
10147 unsigned long r_symndx
= ELF64_R_SYM (rel
->r_info
);
10149 if (local_plt
[r_symndx
] != NULL
)
10151 struct plt_entry
*ent
;
10153 for (ent
= local_plt
[r_symndx
]; ent
!= NULL
; ent
= ent
->next
)
10154 if (ent
->addend
== rel
->r_addend
10155 && ent
->plt
.offset
!= (bfd_vma
) -1)
10158 return ppc_stub_plt_call
;
10163 /* Determine where the call point is. */
10164 location
= (input_sec
->output_offset
10165 + input_sec
->output_section
->vma
10168 branch_offset
= destination
- location
;
10169 r_type
= ELF64_R_TYPE (rel
->r_info
);
10171 /* Determine if a long branch stub is needed. */
10172 max_branch_offset
= 1 << 25;
10173 if (r_type
== R_PPC64_REL14
10174 || r_type
== R_PPC64_REL14_BRTAKEN
10175 || r_type
== R_PPC64_REL14_BRNTAKEN
)
10176 max_branch_offset
= 1 << 15;
10178 if (branch_offset
+ max_branch_offset
>= 2 * max_branch_offset
- local_off
)
10179 /* We need a stub. Figure out whether a long_branch or plt_branch
10180 is needed later. */
10181 return ppc_stub_long_branch
;
10183 return ppc_stub_none
;
10186 /* Gets the address of a label (1:) in r11 and builds an offset in r12,
10187 then adds it to r11 (LOAD false) or loads r12 from r11+r12 (LOAD true).
10192 . lis %r12,xxx-1b@highest
10193 . ori %r12,%r12,xxx-1b@higher
10194 . sldi %r12,%r12,32
10195 . oris %r12,%r12,xxx-1b@high
10196 . ori %r12,%r12,xxx-1b@l
10197 . add/ldx %r12,%r11,%r12 */
10200 build_offset (bfd
*abfd
, bfd_byte
*p
, bfd_vma off
, bfd_boolean load
)
10202 bfd_put_32 (abfd
, MFLR_R12
, p
);
10204 bfd_put_32 (abfd
, BCL_20_31
, p
);
10206 bfd_put_32 (abfd
, MFLR_R11
, p
);
10208 bfd_put_32 (abfd
, MTLR_R12
, p
);
10210 if (off
+ 0x8000 < 0x10000)
10213 bfd_put_32 (abfd
, LD_R12_0R11
+ PPC_LO (off
), p
);
10215 bfd_put_32 (abfd
, ADDI_R12_R11
+ PPC_LO (off
), p
);
10218 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10220 bfd_put_32 (abfd
, ADDIS_R12_R11
+ PPC_HA (off
), p
);
10223 bfd_put_32 (abfd
, LD_R12_0R12
+ PPC_LO (off
), p
);
10225 bfd_put_32 (abfd
, ADDI_R12_R12
+ PPC_LO (off
), p
);
10230 if (off
+ 0x800000000000ULL
< 0x1000000000000ULL
)
10232 bfd_put_32 (abfd
, LI_R12_0
+ ((off
>> 32) & 0xffff), p
);
10237 bfd_put_32 (abfd
, LIS_R12
+ ((off
>> 48) & 0xffff), p
);
10239 if (((off
>> 32) & 0xffff) != 0)
10241 bfd_put_32 (abfd
, ORI_R12_R12_0
+ ((off
>> 32) & 0xffff), p
);
10245 if (((off
>> 32) & 0xffffffffULL
) != 0)
10247 bfd_put_32 (abfd
, SLDI_R12_R12_32
, p
);
10250 if (PPC_HI (off
) != 0)
10252 bfd_put_32 (abfd
, ORIS_R12_R12_0
+ PPC_HI (off
), p
);
10255 if (PPC_LO (off
) != 0)
10257 bfd_put_32 (abfd
, ORI_R12_R12_0
+ PPC_LO (off
), p
);
10261 bfd_put_32 (abfd
, LDX_R12_R11_R12
, p
);
10263 bfd_put_32 (abfd
, ADD_R12_R11_R12
, p
);
10269 static unsigned int
10270 size_offset (bfd_vma off
)
10273 if (off
+ 0x8000 < 0x10000)
10275 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10279 if (off
+ 0x800000000000ULL
< 0x1000000000000ULL
)
10284 if (((off
>> 32) & 0xffff) != 0)
10287 if (((off
>> 32) & 0xffffffffULL
) != 0)
10289 if (PPC_HI (off
) != 0)
10291 if (PPC_LO (off
) != 0)
10298 static unsigned int
10299 num_relocs_for_offset (bfd_vma off
)
10301 unsigned int num_rel
;
10302 if (off
+ 0x8000 < 0x10000)
10304 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10309 if (off
+ 0x800000000000ULL
>= 0x1000000000000ULL
10310 && ((off
>> 32) & 0xffff) != 0)
10312 if (PPC_HI (off
) != 0)
10314 if (PPC_LO (off
) != 0)
10320 static Elf_Internal_Rela
*
10321 emit_relocs_for_offset (struct bfd_link_info
*info
, Elf_Internal_Rela
*r
,
10322 bfd_vma roff
, bfd_vma targ
, bfd_vma off
)
10324 bfd_vma relative_targ
= targ
- (roff
- 8);
10325 if (bfd_big_endian (info
->output_bfd
))
10327 r
->r_offset
= roff
;
10328 r
->r_addend
= relative_targ
+ roff
;
10329 if (off
+ 0x8000 < 0x10000)
10330 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16
);
10331 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10333 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HA
);
10336 r
->r_offset
= roff
;
10337 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_LO
);
10338 r
->r_addend
= relative_targ
+ roff
;
10342 if (off
+ 0x800000000000ULL
< 0x1000000000000ULL
)
10343 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHER
);
10346 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHEST
);
10347 if (((off
>> 32) & 0xffff) != 0)
10351 r
->r_offset
= roff
;
10352 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHER
);
10353 r
->r_addend
= relative_targ
+ roff
;
10356 if (((off
>> 32) & 0xffffffffULL
) != 0)
10358 if (PPC_HI (off
) != 0)
10362 r
->r_offset
= roff
;
10363 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGH
);
10364 r
->r_addend
= relative_targ
+ roff
;
10366 if (PPC_LO (off
) != 0)
10370 r
->r_offset
= roff
;
10371 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_LO
);
10372 r
->r_addend
= relative_targ
+ roff
;
10379 build_powerxx_offset (bfd
*abfd
, bfd_byte
*p
, bfd_vma off
, int odd
,
10383 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10388 bfd_put_32 (abfd
, NOP
, p
);
10394 insn
= PADDI_R12_PC
;
10396 bfd_put_32 (abfd
, insn
>> 32, p
);
10398 bfd_put_32 (abfd
, insn
, p
);
10400 /* The minimum value for paddi is -0x200000000. The minimum value
10401 for li is -0x8000, which when shifted by 34 and added gives a
10402 minimum value of -0x2000200000000. The maximum value is
10403 0x1ffffffff+0x7fff<<34 which is 0x2000200000000-1. */
10404 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10407 bfd_put_32 (abfd
, LI_R11_0
| (HA34 (off
) & 0xffff), p
);
10411 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10414 insn
= PADDI_R12_PC
| D34 (off
);
10415 bfd_put_32 (abfd
, insn
>> 32, p
);
10417 bfd_put_32 (abfd
, insn
, p
);
10421 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10425 bfd_put_32 (abfd
, LDX_R12_R11_R12
, p
);
10427 bfd_put_32 (abfd
, ADD_R12_R11_R12
, p
);
10432 bfd_put_32 (abfd
, LIS_R11
| ((HA34 (off
) >> 16) & 0x3fff), p
);
10434 bfd_put_32 (abfd
, ORI_R11_R11_0
| (HA34 (off
) & 0xffff), p
);
10438 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10441 insn
= PADDI_R12_PC
| D34 (off
);
10442 bfd_put_32 (abfd
, insn
>> 32, p
);
10444 bfd_put_32 (abfd
, insn
, p
);
10448 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10452 bfd_put_32 (abfd
, LDX_R12_R11_R12
, p
);
10454 bfd_put_32 (abfd
, ADD_R12_R11_R12
, p
);
10460 static unsigned int
10461 size_powerxx_offset (bfd_vma off
, int odd
)
10463 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10465 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10471 static unsigned int
10472 num_relocs_for_powerxx_offset (bfd_vma off
, int odd
)
10474 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10476 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10482 static Elf_Internal_Rela
*
10483 emit_relocs_for_powerxx_offset (struct bfd_link_info
*info
,
10484 Elf_Internal_Rela
*r
, bfd_vma roff
,
10485 bfd_vma targ
, bfd_vma off
, int odd
)
10487 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10489 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10491 int d_offset
= bfd_big_endian (info
->output_bfd
) ? 2 : 0;
10492 r
->r_offset
= roff
+ d_offset
;
10493 r
->r_addend
= targ
+ 8 - odd
- d_offset
;
10494 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHERA34
);
10500 int d_offset
= bfd_big_endian (info
->output_bfd
) ? 2 : 0;
10501 r
->r_offset
= roff
+ d_offset
;
10502 r
->r_addend
= targ
+ 8 + odd
- d_offset
;
10503 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHESTA34
);
10506 r
->r_offset
= roff
+ d_offset
;
10507 r
->r_addend
= targ
+ 4 + odd
- d_offset
;
10508 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHERA34
);
10512 r
->r_offset
= roff
;
10513 r
->r_addend
= targ
;
10514 r
->r_info
= ELF64_R_INFO (0, R_PPC64_PCREL34
);
10518 /* Emit .eh_frame opcode to advance pc by DELTA. */
10521 eh_advance (bfd
*abfd
, bfd_byte
*eh
, unsigned int delta
)
10525 *eh
++ = DW_CFA_advance_loc
+ delta
;
10526 else if (delta
< 256)
10528 *eh
++ = DW_CFA_advance_loc1
;
10531 else if (delta
< 65536)
10533 *eh
++ = DW_CFA_advance_loc2
;
10534 bfd_put_16 (abfd
, delta
, eh
);
10539 *eh
++ = DW_CFA_advance_loc4
;
10540 bfd_put_32 (abfd
, delta
, eh
);
10546 /* Size of required .eh_frame opcode to advance pc by DELTA. */
10548 static unsigned int
10549 eh_advance_size (unsigned int delta
)
10551 if (delta
< 64 * 4)
10552 /* DW_CFA_advance_loc+[1..63]. */
10554 if (delta
< 256 * 4)
10555 /* DW_CFA_advance_loc1, byte. */
10557 if (delta
< 65536 * 4)
10558 /* DW_CFA_advance_loc2, 2 bytes. */
10560 /* DW_CFA_advance_loc4, 4 bytes. */
10564 /* With power7 weakly ordered memory model, it is possible for ld.so
10565 to update a plt entry in one thread and have another thread see a
10566 stale zero toc entry. To avoid this we need some sort of acquire
10567 barrier in the call stub. One solution is to make the load of the
10568 toc word seem to appear to depend on the load of the function entry
10569 word. Another solution is to test for r2 being zero, and branch to
10570 the appropriate glink entry if so.
10572 . fake dep barrier compare
10573 . ld 12,xxx(2) ld 12,xxx(2)
10574 . mtctr 12 mtctr 12
10575 . xor 11,12,12 ld 2,xxx+8(2)
10576 . add 2,2,11 cmpldi 2,0
10577 . ld 2,xxx+8(2) bnectr+
10578 . bctr b <glink_entry>
10580 The solution involving the compare turns out to be faster, so
10581 that's what we use unless the branch won't reach. */
10583 #define ALWAYS_USE_FAKE_DEP 0
10584 #define ALWAYS_EMIT_R2SAVE 0
10586 static inline unsigned int
10587 plt_stub_size (struct ppc_link_hash_table
*htab
,
10588 struct ppc_stub_hash_entry
*stub_entry
,
10593 if (stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
)
10595 if (htab
->powerxx_stubs
)
10597 bfd_vma start
= (stub_entry
->stub_offset
10598 + stub_entry
->group
->stub_sec
->output_offset
10599 + stub_entry
->group
->stub_sec
->output_section
->vma
);
10600 if (stub_entry
->stub_type
> ppc_stub_plt_call_notoc
)
10602 size
= 8 + size_powerxx_offset (off
, start
& 4);
10605 size
= 8 + size_offset (off
- 8);
10606 if (stub_entry
->stub_type
> ppc_stub_plt_call_notoc
)
10612 if (ALWAYS_EMIT_R2SAVE
10613 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10615 if (PPC_HA (off
) != 0)
10620 if (htab
->params
->plt_static_chain
)
10622 if (htab
->params
->plt_thread_safe
10623 && htab
->elf
.dynamic_sections_created
10624 && stub_entry
->h
!= NULL
10625 && stub_entry
->h
->elf
.dynindx
!= -1)
10627 if (PPC_HA (off
+ 8 + 8 * htab
->params
->plt_static_chain
) != PPC_HA (off
))
10630 if (stub_entry
->h
!= NULL
10631 && (stub_entry
->h
== htab
->tls_get_addr_fd
10632 || stub_entry
->h
== htab
->tls_get_addr
)
10633 && htab
->params
->tls_get_addr_opt
)
10636 if (stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10642 /* Depending on the sign of plt_stub_align:
10643 If positive, return the padding to align to a 2**plt_stub_align
10645 If negative, if this stub would cross fewer 2**plt_stub_align
10646 boundaries if we align, then return the padding needed to do so. */
10648 static inline unsigned int
10649 plt_stub_pad (struct ppc_link_hash_table
*htab
,
10650 struct ppc_stub_hash_entry
*stub_entry
,
10654 unsigned stub_size
;
10655 bfd_vma stub_off
= stub_entry
->group
->stub_sec
->size
;
10657 if (htab
->params
->plt_stub_align
>= 0)
10659 stub_align
= 1 << htab
->params
->plt_stub_align
;
10660 if ((stub_off
& (stub_align
- 1)) != 0)
10661 return stub_align
- (stub_off
& (stub_align
- 1));
10665 stub_align
= 1 << -htab
->params
->plt_stub_align
;
10666 stub_size
= plt_stub_size (htab
, stub_entry
, plt_off
);
10667 if (((stub_off
+ stub_size
- 1) & -stub_align
) - (stub_off
& -stub_align
)
10668 > ((stub_size
- 1) & -stub_align
))
10669 return stub_align
- (stub_off
& (stub_align
- 1));
10673 /* Build a .plt call stub. */
10675 static inline bfd_byte
*
10676 build_plt_stub (struct ppc_link_hash_table
*htab
,
10677 struct ppc_stub_hash_entry
*stub_entry
,
10678 bfd_byte
*p
, bfd_vma offset
, Elf_Internal_Rela
*r
)
10680 bfd
*obfd
= htab
->params
->stub_bfd
;
10681 bfd_boolean plt_load_toc
= htab
->opd_abi
;
10682 bfd_boolean plt_static_chain
= htab
->params
->plt_static_chain
;
10683 bfd_boolean plt_thread_safe
= (htab
->params
->plt_thread_safe
10684 && htab
->elf
.dynamic_sections_created
10685 && stub_entry
->h
!= NULL
10686 && stub_entry
->h
->elf
.dynindx
!= -1);
10687 bfd_boolean use_fake_dep
= plt_thread_safe
;
10688 bfd_vma cmp_branch_off
= 0;
10690 if (!ALWAYS_USE_FAKE_DEP
10693 && !((stub_entry
->h
== htab
->tls_get_addr_fd
10694 || stub_entry
->h
== htab
->tls_get_addr
)
10695 && htab
->params
->tls_get_addr_opt
))
10697 bfd_vma pltoff
= stub_entry
->plt_ent
->plt
.offset
& ~1;
10698 bfd_vma pltindex
= ((pltoff
- PLT_INITIAL_ENTRY_SIZE (htab
))
10699 / PLT_ENTRY_SIZE (htab
));
10700 bfd_vma glinkoff
= GLINK_PLTRESOLVE_SIZE (htab
) + pltindex
* 8;
10703 if (pltindex
> 32768)
10704 glinkoff
+= (pltindex
- 32768) * 4;
10706 + htab
->glink
->output_offset
10707 + htab
->glink
->output_section
->vma
);
10708 from
= (p
- stub_entry
->group
->stub_sec
->contents
10709 + 4 * (ALWAYS_EMIT_R2SAVE
10710 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10711 + 4 * (PPC_HA (offset
) != 0)
10712 + 4 * (PPC_HA (offset
+ 8 + 8 * plt_static_chain
)
10713 != PPC_HA (offset
))
10714 + 4 * (plt_static_chain
!= 0)
10716 + stub_entry
->group
->stub_sec
->output_offset
10717 + stub_entry
->group
->stub_sec
->output_section
->vma
);
10718 cmp_branch_off
= to
- from
;
10719 use_fake_dep
= cmp_branch_off
+ (1 << 25) >= (1 << 26);
10722 if (PPC_HA (offset
) != 0)
10726 if (ALWAYS_EMIT_R2SAVE
10727 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10728 r
[0].r_offset
+= 4;
10729 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_HA
);
10730 r
[1].r_offset
= r
[0].r_offset
+ 4;
10731 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
10732 r
[1].r_addend
= r
[0].r_addend
;
10735 if (PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
10737 r
[2].r_offset
= r
[1].r_offset
+ 4;
10738 r
[2].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO
);
10739 r
[2].r_addend
= r
[0].r_addend
;
10743 r
[2].r_offset
= r
[1].r_offset
+ 8 + 8 * use_fake_dep
;
10744 r
[2].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
10745 r
[2].r_addend
= r
[0].r_addend
+ 8;
10746 if (plt_static_chain
)
10748 r
[3].r_offset
= r
[2].r_offset
+ 4;
10749 r
[3].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
10750 r
[3].r_addend
= r
[0].r_addend
+ 16;
10755 if (ALWAYS_EMIT_R2SAVE
10756 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10757 bfd_put_32 (obfd
, STD_R2_0R1
+ STK_TOC (htab
), p
), p
+= 4;
10760 bfd_put_32 (obfd
, ADDIS_R11_R2
| PPC_HA (offset
), p
), p
+= 4;
10761 bfd_put_32 (obfd
, LD_R12_0R11
| PPC_LO (offset
), p
), p
+= 4;
10765 bfd_put_32 (obfd
, ADDIS_R12_R2
| PPC_HA (offset
), p
), p
+= 4;
10766 bfd_put_32 (obfd
, LD_R12_0R12
| PPC_LO (offset
), p
), p
+= 4;
10769 && PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
10771 bfd_put_32 (obfd
, ADDI_R11_R11
| PPC_LO (offset
), p
), p
+= 4;
10774 bfd_put_32 (obfd
, MTCTR_R12
, p
), p
+= 4;
10779 bfd_put_32 (obfd
, XOR_R2_R12_R12
, p
), p
+= 4;
10780 bfd_put_32 (obfd
, ADD_R11_R11_R2
, p
), p
+= 4;
10782 bfd_put_32 (obfd
, LD_R2_0R11
| PPC_LO (offset
+ 8), p
), p
+= 4;
10783 if (plt_static_chain
)
10784 bfd_put_32 (obfd
, LD_R11_0R11
| PPC_LO (offset
+ 16), p
), p
+= 4;
10791 if (ALWAYS_EMIT_R2SAVE
10792 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10793 r
[0].r_offset
+= 4;
10794 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
10797 if (PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
10799 r
[1].r_offset
= r
[0].r_offset
+ 4;
10800 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16
);
10801 r
[1].r_addend
= r
[0].r_addend
;
10805 r
[1].r_offset
= r
[0].r_offset
+ 8 + 8 * use_fake_dep
;
10806 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
10807 r
[1].r_addend
= r
[0].r_addend
+ 8 + 8 * plt_static_chain
;
10808 if (plt_static_chain
)
10810 r
[2].r_offset
= r
[1].r_offset
+ 4;
10811 r
[2].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
10812 r
[2].r_addend
= r
[0].r_addend
+ 8;
10817 if (ALWAYS_EMIT_R2SAVE
10818 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10819 bfd_put_32 (obfd
, STD_R2_0R1
+ STK_TOC (htab
), p
), p
+= 4;
10820 bfd_put_32 (obfd
, LD_R12_0R2
| PPC_LO (offset
), p
), p
+= 4;
10822 && PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
10824 bfd_put_32 (obfd
, ADDI_R2_R2
| PPC_LO (offset
), p
), p
+= 4;
10827 bfd_put_32 (obfd
, MTCTR_R12
, p
), p
+= 4;
10832 bfd_put_32 (obfd
, XOR_R11_R12_R12
, p
), p
+= 4;
10833 bfd_put_32 (obfd
, ADD_R2_R2_R11
, p
), p
+= 4;
10835 if (plt_static_chain
)
10836 bfd_put_32 (obfd
, LD_R11_0R2
| PPC_LO (offset
+ 16), p
), p
+= 4;
10837 bfd_put_32 (obfd
, LD_R2_0R2
| PPC_LO (offset
+ 8), p
), p
+= 4;
10840 if (plt_load_toc
&& plt_thread_safe
&& !use_fake_dep
)
10842 bfd_put_32 (obfd
, CMPLDI_R2_0
, p
), p
+= 4;
10843 bfd_put_32 (obfd
, BNECTR_P4
, p
), p
+= 4;
10844 bfd_put_32 (obfd
, B_DOT
| (cmp_branch_off
& 0x3fffffc), p
), p
+= 4;
10847 bfd_put_32 (obfd
, BCTR
, p
), p
+= 4;
10851 /* Build a special .plt call stub for __tls_get_addr. */
10853 #define LD_R11_0R3 0xe9630000
10854 #define LD_R12_0R3 0xe9830000
10855 #define MR_R0_R3 0x7c601b78
10856 #define CMPDI_R11_0 0x2c2b0000
10857 #define ADD_R3_R12_R13 0x7c6c6a14
10858 #define BEQLR 0x4d820020
10859 #define MR_R3_R0 0x7c030378
10860 #define STD_R11_0R1 0xf9610000
10861 #define BCTRL 0x4e800421
10862 #define LD_R11_0R1 0xe9610000
10863 #define MTLR_R11 0x7d6803a6
10865 static inline bfd_byte
*
10866 build_tls_get_addr_stub (struct ppc_link_hash_table
*htab
,
10867 struct ppc_stub_hash_entry
*stub_entry
,
10868 bfd_byte
*p
, bfd_vma offset
, Elf_Internal_Rela
*r
)
10870 bfd
*obfd
= htab
->params
->stub_bfd
;
10873 bfd_put_32 (obfd
, LD_R11_0R3
+ 0, p
), p
+= 4;
10874 bfd_put_32 (obfd
, LD_R12_0R3
+ 8, p
), p
+= 4;
10875 bfd_put_32 (obfd
, MR_R0_R3
, p
), p
+= 4;
10876 bfd_put_32 (obfd
, CMPDI_R11_0
, p
), p
+= 4;
10877 bfd_put_32 (obfd
, ADD_R3_R12_R13
, p
), p
+= 4;
10878 bfd_put_32 (obfd
, BEQLR
, p
), p
+= 4;
10879 bfd_put_32 (obfd
, MR_R3_R0
, p
), p
+= 4;
10881 r
[0].r_offset
+= 7 * 4;
10882 if (stub_entry
->stub_type
!= ppc_stub_plt_call_r2save
)
10883 return build_plt_stub (htab
, stub_entry
, p
, offset
, r
);
10885 bfd_put_32 (obfd
, MFLR_R11
, p
), p
+= 4;
10886 bfd_put_32 (obfd
, STD_R11_0R1
+ STK_LINKER (htab
), p
), p
+= 4;
10889 r
[0].r_offset
+= 2 * 4;
10890 p
= build_plt_stub (htab
, stub_entry
, p
, offset
, r
);
10891 bfd_put_32 (obfd
, BCTRL
, p
- 4);
10893 bfd_put_32 (obfd
, LD_R2_0R1
+ STK_TOC (htab
), p
), p
+= 4;
10894 bfd_put_32 (obfd
, LD_R11_0R1
+ STK_LINKER (htab
), p
), p
+= 4;
10895 bfd_put_32 (obfd
, MTLR_R11
, p
), p
+= 4;
10896 bfd_put_32 (obfd
, BLR
, p
), p
+= 4;
10898 if (htab
->glink_eh_frame
!= NULL
10899 && htab
->glink_eh_frame
->size
!= 0)
10901 bfd_byte
*base
, *eh
;
10902 unsigned int lr_used
, delta
;
10904 base
= htab
->glink_eh_frame
->contents
+ stub_entry
->group
->eh_base
+ 17;
10905 eh
= base
+ stub_entry
->group
->eh_size
;
10906 lr_used
= stub_entry
->stub_offset
+ (p
- 20 - loc
);
10907 delta
= lr_used
- stub_entry
->group
->lr_restore
;
10908 stub_entry
->group
->lr_restore
= lr_used
+ 16;
10909 eh
= eh_advance (htab
->elf
.dynobj
, eh
, delta
);
10910 *eh
++ = DW_CFA_offset_extended_sf
;
10912 *eh
++ = -(STK_LINKER (htab
) / 8) & 0x7f;
10913 *eh
++ = DW_CFA_advance_loc
+ 4;
10914 *eh
++ = DW_CFA_restore_extended
;
10916 stub_entry
->group
->eh_size
= eh
- base
;
10921 static Elf_Internal_Rela
*
10922 get_relocs (asection
*sec
, int count
)
10924 Elf_Internal_Rela
*relocs
;
10925 struct bfd_elf_section_data
*elfsec_data
;
10927 elfsec_data
= elf_section_data (sec
);
10928 relocs
= elfsec_data
->relocs
;
10929 if (relocs
== NULL
)
10931 bfd_size_type relsize
;
10932 relsize
= sec
->reloc_count
* sizeof (*relocs
);
10933 relocs
= bfd_alloc (sec
->owner
, relsize
);
10934 if (relocs
== NULL
)
10936 elfsec_data
->relocs
= relocs
;
10937 elfsec_data
->rela
.hdr
= bfd_zalloc (sec
->owner
,
10938 sizeof (Elf_Internal_Shdr
));
10939 if (elfsec_data
->rela
.hdr
== NULL
)
10941 elfsec_data
->rela
.hdr
->sh_size
= (sec
->reloc_count
10942 * sizeof (Elf64_External_Rela
));
10943 elfsec_data
->rela
.hdr
->sh_entsize
= sizeof (Elf64_External_Rela
);
10944 sec
->reloc_count
= 0;
10946 relocs
+= sec
->reloc_count
;
10947 sec
->reloc_count
+= count
;
10951 /* Convert the relocs R[0] thru R[-NUM_REL+1], which are all no-symbol
10952 forms, to the equivalent relocs against the global symbol given by
10956 use_global_in_relocs (struct ppc_link_hash_table
*htab
,
10957 struct ppc_stub_hash_entry
*stub_entry
,
10958 Elf_Internal_Rela
*r
, unsigned int num_rel
)
10960 struct elf_link_hash_entry
**hashes
;
10961 unsigned long symndx
;
10962 struct ppc_link_hash_entry
*h
;
10965 /* Relocs are always against symbols in their own object file. Fake
10966 up global sym hashes for the stub bfd (which has no symbols). */
10967 hashes
= elf_sym_hashes (htab
->params
->stub_bfd
);
10968 if (hashes
== NULL
)
10970 bfd_size_type hsize
;
10972 /* When called the first time, stub_globals will contain the
10973 total number of symbols seen during stub sizing. After
10974 allocating, stub_globals is used as an index to fill the
10976 hsize
= (htab
->stub_globals
+ 1) * sizeof (*hashes
);
10977 hashes
= bfd_zalloc (htab
->params
->stub_bfd
, hsize
);
10978 if (hashes
== NULL
)
10980 elf_sym_hashes (htab
->params
->stub_bfd
) = hashes
;
10981 htab
->stub_globals
= 1;
10983 symndx
= htab
->stub_globals
++;
10985 hashes
[symndx
] = &h
->elf
;
10986 if (h
->oh
!= NULL
&& h
->oh
->is_func
)
10987 h
= ppc_follow_link (h
->oh
);
10988 BFD_ASSERT (h
->elf
.root
.type
== bfd_link_hash_defined
10989 || h
->elf
.root
.type
== bfd_link_hash_defweak
);
10990 symval
= (h
->elf
.root
.u
.def
.value
10991 + h
->elf
.root
.u
.def
.section
->output_offset
10992 + h
->elf
.root
.u
.def
.section
->output_section
->vma
);
10993 while (num_rel
-- != 0)
10995 r
->r_info
= ELF64_R_INFO (symndx
, ELF64_R_TYPE (r
->r_info
));
10996 if (h
->elf
.root
.u
.def
.section
!= stub_entry
->target_section
)
10998 /* H is an opd symbol. The addend must be zero, and the
10999 branch reloc is the only one we can convert. */
11004 r
->r_addend
-= symval
;
11011 get_r2off (struct bfd_link_info
*info
,
11012 struct ppc_stub_hash_entry
*stub_entry
)
11014 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
11015 bfd_vma r2off
= htab
->sec_info
[stub_entry
->target_section
->id
].toc_off
;
11019 /* Support linking -R objects. Get the toc pointer from the
11022 if (!htab
->opd_abi
)
11024 asection
*opd
= stub_entry
->h
->elf
.root
.u
.def
.section
;
11025 bfd_vma opd_off
= stub_entry
->h
->elf
.root
.u
.def
.value
;
11027 if (strcmp (opd
->name
, ".opd") != 0
11028 || opd
->reloc_count
!= 0)
11030 info
->callbacks
->einfo
11031 (_("%P: cannot find opd entry toc for `%pT'\n"),
11032 stub_entry
->h
->elf
.root
.root
.string
);
11033 bfd_set_error (bfd_error_bad_value
);
11034 return (bfd_vma
) -1;
11036 if (!bfd_get_section_contents (opd
->owner
, opd
, buf
, opd_off
+ 8, 8))
11037 return (bfd_vma
) -1;
11038 r2off
= bfd_get_64 (opd
->owner
, buf
);
11039 r2off
-= elf_gp (info
->output_bfd
);
11041 r2off
-= htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
;
11046 ppc_build_one_stub (struct bfd_hash_entry
*gen_entry
, void *in_arg
)
11048 struct ppc_stub_hash_entry
*stub_entry
;
11049 struct ppc_branch_hash_entry
*br_entry
;
11050 struct bfd_link_info
*info
;
11051 struct ppc_link_hash_table
*htab
;
11053 bfd_byte
*p
, *relp
;
11055 Elf_Internal_Rela
*r
;
11060 /* Massage our args to the form they really have. */
11061 stub_entry
= (struct ppc_stub_hash_entry
*) gen_entry
;
11064 htab
= ppc_hash_table (info
);
11068 BFD_ASSERT (stub_entry
->stub_offset
>= stub_entry
->group
->stub_sec
->size
);
11069 loc
= stub_entry
->group
->stub_sec
->contents
+ stub_entry
->stub_offset
;
11071 htab
->stub_count
[stub_entry
->stub_type
- 1] += 1;
11072 switch (stub_entry
->stub_type
)
11074 case ppc_stub_long_branch
:
11075 case ppc_stub_long_branch_r2off
:
11076 /* Branches are relative. This is where we are going to. */
11077 targ
= (stub_entry
->target_value
11078 + stub_entry
->target_section
->output_offset
11079 + stub_entry
->target_section
->output_section
->vma
);
11080 targ
+= PPC64_LOCAL_ENTRY_OFFSET (stub_entry
->other
);
11082 /* And this is where we are coming from. */
11083 off
= (stub_entry
->stub_offset
11084 + stub_entry
->group
->stub_sec
->output_offset
11085 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11089 if (stub_entry
->stub_type
== ppc_stub_long_branch_r2off
)
11091 bfd_vma r2off
= get_r2off (info
, stub_entry
);
11093 if (r2off
== (bfd_vma
) -1)
11095 htab
->stub_error
= TRUE
;
11098 bfd_put_32 (htab
->params
->stub_bfd
, STD_R2_0R1
+ STK_TOC (htab
), p
);
11100 if (PPC_HA (r2off
) != 0)
11102 bfd_put_32 (htab
->params
->stub_bfd
,
11103 ADDIS_R2_R2
| PPC_HA (r2off
), p
);
11106 if (PPC_LO (r2off
) != 0)
11108 bfd_put_32 (htab
->params
->stub_bfd
,
11109 ADDI_R2_R2
| PPC_LO (r2off
), p
);
11114 bfd_put_32 (htab
->params
->stub_bfd
, B_DOT
| (off
& 0x3fffffc), p
);
11117 if (off
+ (1 << 25) >= (bfd_vma
) (1 << 26))
11120 (_("long branch stub `%s' offset overflow"),
11121 stub_entry
->root
.string
);
11122 htab
->stub_error
= TRUE
;
11126 if (info
->emitrelocations
)
11128 r
= get_relocs (stub_entry
->group
->stub_sec
, 1);
11131 r
->r_offset
= p
- 4 - stub_entry
->group
->stub_sec
->contents
;
11132 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL24
);
11133 r
->r_addend
= targ
;
11134 if (stub_entry
->h
!= NULL
11135 && !use_global_in_relocs (htab
, stub_entry
, r
, 1))
11140 case ppc_stub_plt_branch
:
11141 case ppc_stub_plt_branch_r2off
:
11142 br_entry
= ppc_branch_hash_lookup (&htab
->branch_hash_table
,
11143 stub_entry
->root
.string
+ 9,
11145 if (br_entry
== NULL
)
11147 _bfd_error_handler (_("can't find branch stub `%s'"),
11148 stub_entry
->root
.string
);
11149 htab
->stub_error
= TRUE
;
11153 targ
= (stub_entry
->target_value
11154 + stub_entry
->target_section
->output_offset
11155 + stub_entry
->target_section
->output_section
->vma
);
11156 if (stub_entry
->stub_type
!= ppc_stub_plt_branch_r2off
)
11157 targ
+= PPC64_LOCAL_ENTRY_OFFSET (stub_entry
->other
);
11159 bfd_put_64 (htab
->brlt
->owner
, targ
,
11160 htab
->brlt
->contents
+ br_entry
->offset
);
11162 if (br_entry
->iter
== htab
->stub_iteration
)
11164 br_entry
->iter
= 0;
11166 if (htab
->relbrlt
!= NULL
)
11168 /* Create a reloc for the branch lookup table entry. */
11169 Elf_Internal_Rela rela
;
11172 rela
.r_offset
= (br_entry
->offset
11173 + htab
->brlt
->output_offset
11174 + htab
->brlt
->output_section
->vma
);
11175 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
11176 rela
.r_addend
= targ
;
11178 rl
= htab
->relbrlt
->contents
;
11179 rl
+= (htab
->relbrlt
->reloc_count
++
11180 * sizeof (Elf64_External_Rela
));
11181 bfd_elf64_swap_reloca_out (htab
->relbrlt
->owner
, &rela
, rl
);
11183 else if (info
->emitrelocations
)
11185 r
= get_relocs (htab
->brlt
, 1);
11188 /* brlt, being SEC_LINKER_CREATED does not go through the
11189 normal reloc processing. Symbols and offsets are not
11190 translated from input file to output file form, so
11191 set up the offset per the output file. */
11192 r
->r_offset
= (br_entry
->offset
11193 + htab
->brlt
->output_offset
11194 + htab
->brlt
->output_section
->vma
);
11195 r
->r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
11196 r
->r_addend
= targ
;
11200 targ
= (br_entry
->offset
11201 + htab
->brlt
->output_offset
11202 + htab
->brlt
->output_section
->vma
);
11204 off
= (elf_gp (info
->output_bfd
)
11205 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
11208 if (off
+ 0x80008000 > 0xffffffff || (off
& 7) != 0)
11210 info
->callbacks
->einfo
11211 (_("%P: linkage table error against `%pT'\n"),
11212 stub_entry
->root
.string
);
11213 bfd_set_error (bfd_error_bad_value
);
11214 htab
->stub_error
= TRUE
;
11218 if (info
->emitrelocations
)
11220 r
= get_relocs (stub_entry
->group
->stub_sec
, 1 + (PPC_HA (off
) != 0));
11223 r
[0].r_offset
= loc
- stub_entry
->group
->stub_sec
->contents
;
11224 if (bfd_big_endian (info
->output_bfd
))
11225 r
[0].r_offset
+= 2;
11226 if (stub_entry
->stub_type
== ppc_stub_plt_branch_r2off
)
11227 r
[0].r_offset
+= 4;
11228 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
11229 r
[0].r_addend
= targ
;
11230 if (PPC_HA (off
) != 0)
11232 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_HA
);
11233 r
[1].r_offset
= r
[0].r_offset
+ 4;
11234 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
11235 r
[1].r_addend
= r
[0].r_addend
;
11240 if (stub_entry
->stub_type
!= ppc_stub_plt_branch_r2off
)
11242 if (PPC_HA (off
) != 0)
11244 bfd_put_32 (htab
->params
->stub_bfd
,
11245 ADDIS_R12_R2
| PPC_HA (off
), p
);
11247 bfd_put_32 (htab
->params
->stub_bfd
,
11248 LD_R12_0R12
| PPC_LO (off
), p
);
11251 bfd_put_32 (htab
->params
->stub_bfd
,
11252 LD_R12_0R2
| PPC_LO (off
), p
);
11256 bfd_vma r2off
= get_r2off (info
, stub_entry
);
11258 if (r2off
== (bfd_vma
) -1)
11260 htab
->stub_error
= TRUE
;
11264 bfd_put_32 (htab
->params
->stub_bfd
, STD_R2_0R1
+ STK_TOC (htab
), p
);
11266 if (PPC_HA (off
) != 0)
11268 bfd_put_32 (htab
->params
->stub_bfd
,
11269 ADDIS_R12_R2
| PPC_HA (off
), p
);
11271 bfd_put_32 (htab
->params
->stub_bfd
,
11272 LD_R12_0R12
| PPC_LO (off
), p
);
11275 bfd_put_32 (htab
->params
->stub_bfd
, LD_R12_0R2
| PPC_LO (off
), p
);
11277 if (PPC_HA (r2off
) != 0)
11280 bfd_put_32 (htab
->params
->stub_bfd
,
11281 ADDIS_R2_R2
| PPC_HA (r2off
), p
);
11283 if (PPC_LO (r2off
) != 0)
11286 bfd_put_32 (htab
->params
->stub_bfd
,
11287 ADDI_R2_R2
| PPC_LO (r2off
), p
);
11291 bfd_put_32 (htab
->params
->stub_bfd
, MTCTR_R12
, p
);
11293 bfd_put_32 (htab
->params
->stub_bfd
, BCTR
, p
);
11297 case ppc_stub_long_branch_notoc
:
11298 case ppc_stub_long_branch_both
:
11299 case ppc_stub_plt_branch_notoc
:
11300 case ppc_stub_plt_branch_both
:
11301 case ppc_stub_plt_call_notoc
:
11302 case ppc_stub_plt_call_both
:
11304 off
= (stub_entry
->stub_offset
11305 + stub_entry
->group
->stub_sec
->output_offset
11306 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11307 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
11308 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
11309 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
11312 bfd_put_32 (htab
->params
->stub_bfd
, STD_R2_0R1
+ STK_TOC (htab
), p
);
11315 if (stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
)
11317 targ
= stub_entry
->plt_ent
->plt
.offset
& ~1;
11318 if (targ
>= (bfd_vma
) -2)
11321 plt
= htab
->elf
.splt
;
11322 if (!htab
->elf
.dynamic_sections_created
11323 || stub_entry
->h
== NULL
11324 || stub_entry
->h
->elf
.dynindx
== -1)
11326 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
11327 plt
= htab
->elf
.iplt
;
11329 plt
= htab
->pltlocal
;
11331 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
11334 targ
= (stub_entry
->target_value
11335 + stub_entry
->target_section
->output_offset
11336 + stub_entry
->target_section
->output_section
->vma
);
11342 if (htab
->powerxx_stubs
)
11344 bfd_boolean load
= stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
;
11345 p
= build_powerxx_offset (htab
->params
->stub_bfd
, p
, off
, odd
, load
);
11349 /* The notoc stubs calculate their target (either a PLT entry or
11350 the global entry point of a function) relative to the PC
11351 returned by the "bcl" two instructions past the start of the
11352 sequence emitted by build_offset. The offset is therefore 8
11353 less than calculated from the start of the sequence. */
11355 p
= build_offset (htab
->params
->stub_bfd
, p
, off
,
11356 stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
);
11359 if (stub_entry
->stub_type
<= ppc_stub_long_branch_both
)
11363 from
= (stub_entry
->stub_offset
11364 + stub_entry
->group
->stub_sec
->output_offset
11365 + stub_entry
->group
->stub_sec
->output_section
->vma
11367 bfd_put_32 (htab
->params
->stub_bfd
,
11368 B_DOT
| ((targ
- from
) & 0x3fffffc), p
);
11372 bfd_put_32 (htab
->params
->stub_bfd
, MTCTR_R12
, p
);
11374 bfd_put_32 (htab
->params
->stub_bfd
, BCTR
, p
);
11378 if (info
->emitrelocations
)
11380 bfd_vma roff
= relp
- stub_entry
->group
->stub_sec
->contents
;
11381 if (htab
->powerxx_stubs
)
11382 num_rel
+= num_relocs_for_powerxx_offset (off
, odd
);
11385 num_rel
+= num_relocs_for_offset (off
);
11388 r
= get_relocs (stub_entry
->group
->stub_sec
, num_rel
);
11391 if (htab
->powerxx_stubs
)
11392 r
= emit_relocs_for_powerxx_offset (info
, r
, roff
, targ
, off
, odd
);
11394 r
= emit_relocs_for_offset (info
, r
, roff
, targ
, off
);
11395 if (stub_entry
->stub_type
== ppc_stub_long_branch_notoc
11396 || stub_entry
->stub_type
== ppc_stub_long_branch_both
)
11399 roff
= p
- 4 - stub_entry
->group
->stub_sec
->contents
;
11400 r
->r_offset
= roff
;
11401 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL24
);
11402 r
->r_addend
= targ
;
11403 if (stub_entry
->h
!= NULL
11404 && !use_global_in_relocs (htab
, stub_entry
, r
, num_rel
))
11409 if (!htab
->powerxx_stubs
11410 && htab
->glink_eh_frame
!= NULL
11411 && htab
->glink_eh_frame
->size
!= 0)
11413 bfd_byte
*base
, *eh
;
11414 unsigned int lr_used
, delta
;
11416 base
= (htab
->glink_eh_frame
->contents
11417 + stub_entry
->group
->eh_base
+ 17);
11418 eh
= base
+ stub_entry
->group
->eh_size
;
11419 lr_used
= stub_entry
->stub_offset
+ 8;
11420 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
11421 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
11422 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
11424 delta
= lr_used
- stub_entry
->group
->lr_restore
;
11425 stub_entry
->group
->lr_restore
= lr_used
+ 8;
11426 eh
= eh_advance (htab
->elf
.dynobj
, eh
, delta
);
11427 *eh
++ = DW_CFA_register
;
11430 *eh
++ = DW_CFA_advance_loc
+ 2;
11431 *eh
++ = DW_CFA_restore_extended
;
11433 stub_entry
->group
->eh_size
= eh
- base
;
11437 case ppc_stub_plt_call
:
11438 case ppc_stub_plt_call_r2save
:
11439 if (stub_entry
->h
!= NULL
11440 && stub_entry
->h
->is_func_descriptor
11441 && stub_entry
->h
->oh
!= NULL
)
11443 struct ppc_link_hash_entry
*fh
= ppc_follow_link (stub_entry
->h
->oh
);
11445 /* If the old-ABI "dot-symbol" is undefined make it weak so
11446 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL. */
11447 if (fh
->elf
.root
.type
== bfd_link_hash_undefined
11448 && (stub_entry
->h
->elf
.root
.type
== bfd_link_hash_defined
11449 || stub_entry
->h
->elf
.root
.type
== bfd_link_hash_defweak
))
11450 fh
->elf
.root
.type
= bfd_link_hash_undefweak
;
11453 /* Now build the stub. */
11454 targ
= stub_entry
->plt_ent
->plt
.offset
& ~1;
11455 if (targ
>= (bfd_vma
) -2)
11458 plt
= htab
->elf
.splt
;
11459 if (!htab
->elf
.dynamic_sections_created
11460 || stub_entry
->h
== NULL
11461 || stub_entry
->h
->elf
.dynindx
== -1)
11463 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
11464 plt
= htab
->elf
.iplt
;
11466 plt
= htab
->pltlocal
;
11468 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
11470 off
= (elf_gp (info
->output_bfd
)
11471 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
11474 if (off
+ 0x80008000 > 0xffffffff || (off
& 7) != 0)
11476 info
->callbacks
->einfo
11477 /* xgettext:c-format */
11478 (_("%P: linkage table error against `%pT'\n"),
11479 stub_entry
->h
!= NULL
11480 ? stub_entry
->h
->elf
.root
.root
.string
11482 bfd_set_error (bfd_error_bad_value
);
11483 htab
->stub_error
= TRUE
;
11488 if (info
->emitrelocations
)
11490 r
= get_relocs (stub_entry
->group
->stub_sec
,
11491 ((PPC_HA (off
) != 0)
11493 ? 2 + (htab
->params
->plt_static_chain
11494 && PPC_HA (off
+ 16) == PPC_HA (off
))
11498 r
[0].r_offset
= loc
- stub_entry
->group
->stub_sec
->contents
;
11499 if (bfd_big_endian (info
->output_bfd
))
11500 r
[0].r_offset
+= 2;
11501 r
[0].r_addend
= targ
;
11503 if (stub_entry
->h
!= NULL
11504 && (stub_entry
->h
== htab
->tls_get_addr_fd
11505 || stub_entry
->h
== htab
->tls_get_addr
)
11506 && htab
->params
->tls_get_addr_opt
)
11507 p
= build_tls_get_addr_stub (htab
, stub_entry
, loc
, off
, r
);
11509 p
= build_plt_stub (htab
, stub_entry
, loc
, off
, r
);
11512 case ppc_stub_save_res
:
11520 stub_entry
->group
->stub_sec
->size
= stub_entry
->stub_offset
+ (p
- loc
);
11522 if (htab
->params
->emit_stub_syms
)
11524 struct elf_link_hash_entry
*h
;
11527 const char *const stub_str
[] = { "long_branch",
11540 len1
= strlen (stub_str
[stub_entry
->stub_type
- 1]);
11541 len2
= strlen (stub_entry
->root
.string
);
11542 name
= bfd_malloc (len1
+ len2
+ 2);
11545 memcpy (name
, stub_entry
->root
.string
, 9);
11546 memcpy (name
+ 9, stub_str
[stub_entry
->stub_type
- 1], len1
);
11547 memcpy (name
+ len1
+ 9, stub_entry
->root
.string
+ 8, len2
- 8 + 1);
11548 h
= elf_link_hash_lookup (&htab
->elf
, name
, TRUE
, FALSE
, FALSE
);
11551 if (h
->root
.type
== bfd_link_hash_new
)
11553 h
->root
.type
= bfd_link_hash_defined
;
11554 h
->root
.u
.def
.section
= stub_entry
->group
->stub_sec
;
11555 h
->root
.u
.def
.value
= stub_entry
->stub_offset
;
11556 h
->ref_regular
= 1;
11557 h
->def_regular
= 1;
11558 h
->ref_regular_nonweak
= 1;
11559 h
->forced_local
= 1;
11561 h
->root
.linker_def
= 1;
11568 /* As above, but don't actually build the stub. Just bump offset so
11569 we know stub section sizes, and select plt_branch stubs where
11570 long_branch stubs won't do. */
11573 ppc_size_one_stub (struct bfd_hash_entry
*gen_entry
, void *in_arg
)
11575 struct ppc_stub_hash_entry
*stub_entry
;
11576 struct bfd_link_info
*info
;
11577 struct ppc_link_hash_table
*htab
;
11579 bfd_vma targ
, off
, r2off
;
11580 unsigned int size
, extra
, lr_used
, delta
, odd
;
11582 /* Massage our args to the form they really have. */
11583 stub_entry
= (struct ppc_stub_hash_entry
*) gen_entry
;
11586 htab
= ppc_hash_table (info
);
11590 /* Make a note of the offset within the stubs for this entry. */
11591 stub_entry
->stub_offset
= stub_entry
->group
->stub_sec
->size
;
11593 if (stub_entry
->h
!= NULL
11594 && stub_entry
->h
->save_res
11595 && stub_entry
->h
->elf
.root
.type
== bfd_link_hash_defined
11596 && stub_entry
->h
->elf
.root
.u
.def
.section
== htab
->sfpr
)
11598 /* Don't make stubs to out-of-line register save/restore
11599 functions. Instead, emit copies of the functions. */
11600 stub_entry
->group
->needs_save_res
= 1;
11601 stub_entry
->stub_type
= ppc_stub_save_res
;
11605 switch (stub_entry
->stub_type
)
11607 case ppc_stub_plt_branch
:
11608 case ppc_stub_plt_branch_r2off
:
11609 /* Reset the stub type from the plt branch variant in case we now
11610 can reach with a shorter stub. */
11611 stub_entry
->stub_type
+= ppc_stub_long_branch
- ppc_stub_plt_branch
;
11612 /* Fall through. */
11613 case ppc_stub_long_branch
:
11614 case ppc_stub_long_branch_r2off
:
11615 targ
= (stub_entry
->target_value
11616 + stub_entry
->target_section
->output_offset
11617 + stub_entry
->target_section
->output_section
->vma
);
11618 targ
+= PPC64_LOCAL_ENTRY_OFFSET (stub_entry
->other
);
11619 off
= (stub_entry
->stub_offset
11620 + stub_entry
->group
->stub_sec
->output_offset
11621 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11625 if (stub_entry
->stub_type
== ppc_stub_long_branch_r2off
)
11627 r2off
= get_r2off (info
, stub_entry
);
11628 if (r2off
== (bfd_vma
) -1)
11630 htab
->stub_error
= TRUE
;
11634 if (PPC_HA (r2off
) != 0)
11636 if (PPC_LO (r2off
) != 0)
11642 /* If the branch offset is too big, use a ppc_stub_plt_branch.
11643 Do the same for -R objects without function descriptors. */
11644 if ((stub_entry
->stub_type
== ppc_stub_long_branch_r2off
11646 && htab
->sec_info
[stub_entry
->target_section
->id
].toc_off
== 0)
11647 || off
+ (1 << 25) >= (bfd_vma
) (1 << 26))
11649 struct ppc_branch_hash_entry
*br_entry
;
11651 br_entry
= ppc_branch_hash_lookup (&htab
->branch_hash_table
,
11652 stub_entry
->root
.string
+ 9,
11654 if (br_entry
== NULL
)
11656 _bfd_error_handler (_("can't build branch stub `%s'"),
11657 stub_entry
->root
.string
);
11658 htab
->stub_error
= TRUE
;
11662 if (br_entry
->iter
!= htab
->stub_iteration
)
11664 br_entry
->iter
= htab
->stub_iteration
;
11665 br_entry
->offset
= htab
->brlt
->size
;
11666 htab
->brlt
->size
+= 8;
11668 if (htab
->relbrlt
!= NULL
)
11669 htab
->relbrlt
->size
+= sizeof (Elf64_External_Rela
);
11670 else if (info
->emitrelocations
)
11672 htab
->brlt
->reloc_count
+= 1;
11673 htab
->brlt
->flags
|= SEC_RELOC
;
11677 targ
= (br_entry
->offset
11678 + htab
->brlt
->output_offset
11679 + htab
->brlt
->output_section
->vma
);
11680 off
= (elf_gp (info
->output_bfd
)
11681 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
11684 if (info
->emitrelocations
)
11686 stub_entry
->group
->stub_sec
->reloc_count
11687 += 1 + (PPC_HA (off
) != 0);
11688 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
11691 stub_entry
->stub_type
+= ppc_stub_plt_branch
- ppc_stub_long_branch
;
11692 if (stub_entry
->stub_type
!= ppc_stub_plt_branch_r2off
)
11695 if (PPC_HA (off
) != 0)
11701 if (PPC_HA (off
) != 0)
11704 if (PPC_HA (r2off
) != 0)
11706 if (PPC_LO (r2off
) != 0)
11710 else if (info
->emitrelocations
)
11712 stub_entry
->group
->stub_sec
->reloc_count
+= 1;
11713 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
11717 case ppc_stub_plt_branch_notoc
:
11718 case ppc_stub_plt_branch_both
:
11719 stub_entry
->stub_type
+= ppc_stub_long_branch
- ppc_stub_plt_branch
;
11720 /* Fall through. */
11721 case ppc_stub_long_branch_notoc
:
11722 case ppc_stub_long_branch_both
:
11723 off
= (stub_entry
->stub_offset
11724 + stub_entry
->group
->stub_sec
->output_offset
11725 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11727 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
)
11730 targ
= (stub_entry
->target_value
11731 + stub_entry
->target_section
->output_offset
11732 + stub_entry
->target_section
->output_section
->vma
);
11736 if (info
->emitrelocations
)
11738 unsigned int num_rel
;
11739 if (htab
->powerxx_stubs
)
11740 num_rel
= num_relocs_for_powerxx_offset (off
, odd
);
11742 num_rel
= num_relocs_for_offset (off
- 8);
11743 stub_entry
->group
->stub_sec
->reloc_count
+= num_rel
;
11744 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
11747 if (htab
->powerxx_stubs
)
11748 extra
= size_powerxx_offset (off
, odd
);
11750 extra
= size_offset (off
- 8);
11751 /* Include branch insn plus those in the offset sequence. */
11753 /* The branch insn is at the end, or "extra" bytes along. So
11754 its offset will be "extra" bytes less that that already
11758 if (!htab
->powerxx_stubs
)
11760 /* After the bcl, lr has been modified so we need to emit
11761 .eh_frame info saying the return address is in r12. */
11762 lr_used
= stub_entry
->stub_offset
+ 8;
11763 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
)
11765 /* The eh_frame info will consist of a DW_CFA_advance_loc or
11766 variant, DW_CFA_register, 65, 12, DW_CFA_advance_loc+2,
11767 DW_CFA_restore_extended 65. */
11768 delta
= lr_used
- stub_entry
->group
->lr_restore
;
11769 stub_entry
->group
->eh_size
+= eh_advance_size (delta
) + 6;
11770 stub_entry
->group
->lr_restore
= lr_used
+ 8;
11773 /* If the branch can't reach, use a plt_branch. */
11774 if (off
+ (1 << 25) >= (bfd_vma
) (1 << 26))
11776 stub_entry
->stub_type
+= (ppc_stub_plt_branch_notoc
11777 - ppc_stub_long_branch_notoc
);
11780 else if (info
->emitrelocations
)
11781 stub_entry
->group
->stub_sec
->reloc_count
+=1;
11784 case ppc_stub_plt_call_notoc
:
11785 case ppc_stub_plt_call_both
:
11786 off
= (stub_entry
->stub_offset
11787 + stub_entry
->group
->stub_sec
->output_offset
11788 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11789 if (stub_entry
->stub_type
== ppc_stub_plt_call_both
)
11791 targ
= stub_entry
->plt_ent
->plt
.offset
& ~1;
11792 if (targ
>= (bfd_vma
) -2)
11795 plt
= htab
->elf
.splt
;
11796 if (!htab
->elf
.dynamic_sections_created
11797 || stub_entry
->h
== NULL
11798 || stub_entry
->h
->elf
.dynindx
== -1)
11800 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
11801 plt
= htab
->elf
.iplt
;
11803 plt
= htab
->pltlocal
;
11805 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
11809 if (htab
->params
->plt_stub_align
!= 0)
11811 unsigned pad
= plt_stub_pad (htab
, stub_entry
, off
);
11813 stub_entry
->group
->stub_sec
->size
+= pad
;
11814 stub_entry
->stub_offset
= stub_entry
->group
->stub_sec
->size
;
11818 if (info
->emitrelocations
)
11820 unsigned int num_rel
;
11821 if (htab
->powerxx_stubs
)
11822 num_rel
= num_relocs_for_powerxx_offset (off
, odd
);
11824 num_rel
= num_relocs_for_offset (off
- 8);
11825 stub_entry
->group
->stub_sec
->reloc_count
+= num_rel
;
11826 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
11829 size
= plt_stub_size (htab
, stub_entry
, off
);
11831 if (!htab
->powerxx_stubs
)
11833 /* After the bcl, lr has been modified so we need to emit
11834 .eh_frame info saying the return address is in r12. */
11835 lr_used
= stub_entry
->stub_offset
+ 8;
11836 if (stub_entry
->stub_type
== ppc_stub_plt_call_both
)
11838 /* The eh_frame info will consist of a DW_CFA_advance_loc or
11839 variant, DW_CFA_register, 65, 12, DW_CFA_advance_loc+2,
11840 DW_CFA_restore_extended 65. */
11841 delta
= lr_used
- stub_entry
->group
->lr_restore
;
11842 stub_entry
->group
->eh_size
+= eh_advance_size (delta
) + 6;
11843 stub_entry
->group
->lr_restore
= lr_used
+ 8;
11847 case ppc_stub_plt_call
:
11848 case ppc_stub_plt_call_r2save
:
11849 targ
= stub_entry
->plt_ent
->plt
.offset
& ~(bfd_vma
) 1;
11850 if (targ
>= (bfd_vma
) -2)
11852 plt
= htab
->elf
.splt
;
11853 if (!htab
->elf
.dynamic_sections_created
11854 || stub_entry
->h
== NULL
11855 || stub_entry
->h
->elf
.dynindx
== -1)
11857 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
11858 plt
= htab
->elf
.iplt
;
11860 plt
= htab
->pltlocal
;
11862 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
11864 off
= (elf_gp (info
->output_bfd
)
11865 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
11868 if (htab
->params
->plt_stub_align
!= 0)
11870 unsigned pad
= plt_stub_pad (htab
, stub_entry
, off
);
11872 stub_entry
->group
->stub_sec
->size
+= pad
;
11873 stub_entry
->stub_offset
= stub_entry
->group
->stub_sec
->size
;
11876 if (info
->emitrelocations
)
11878 stub_entry
->group
->stub_sec
->reloc_count
11879 += ((PPC_HA (off
) != 0)
11881 ? 2 + (htab
->params
->plt_static_chain
11882 && PPC_HA (off
+ 16) == PPC_HA (off
))
11884 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
11887 size
= plt_stub_size (htab
, stub_entry
, off
);
11889 if (stub_entry
->h
!= NULL
11890 && (stub_entry
->h
== htab
->tls_get_addr_fd
11891 || stub_entry
->h
== htab
->tls_get_addr
)
11892 && htab
->params
->tls_get_addr_opt
11893 && stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
11895 /* After the bctrl, lr has been modified so we need to
11896 emit .eh_frame info saying the return address is
11897 on the stack. In fact we put the EH info specifying
11898 that the return address is on the stack *at* the
11899 call rather than after it, because the EH info for a
11900 call needs to be specified by that point.
11901 See libgcc/unwind-dw2.c execute_cfa_program. */
11902 lr_used
= stub_entry
->stub_offset
+ size
- 20;
11903 /* The eh_frame info will consist of a DW_CFA_advance_loc
11904 or variant, DW_CFA_offset_externed_sf, 65, -stackoff,
11905 DW_CFA_advance_loc+4, DW_CFA_restore_extended, 65. */
11906 delta
= lr_used
- stub_entry
->group
->lr_restore
;
11907 stub_entry
->group
->eh_size
+= eh_advance_size (delta
) + 6;
11908 stub_entry
->group
->lr_restore
= size
- 4;
11917 stub_entry
->group
->stub_sec
->size
+= size
;
11921 /* Set up various things so that we can make a list of input sections
11922 for each output section included in the link. Returns -1 on error,
11923 0 when no stubs will be needed, and 1 on success. */
11926 ppc64_elf_setup_section_lists (struct bfd_link_info
*info
)
11930 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
11935 htab
->sec_info_arr_size
= _bfd_section_id
;
11936 amt
= sizeof (*htab
->sec_info
) * (htab
->sec_info_arr_size
);
11937 htab
->sec_info
= bfd_zmalloc (amt
);
11938 if (htab
->sec_info
== NULL
)
11941 /* Set toc_off for com, und, abs and ind sections. */
11942 for (id
= 0; id
< 3; id
++)
11943 htab
->sec_info
[id
].toc_off
= TOC_BASE_OFF
;
11948 /* Set up for first pass at multitoc partitioning. */
11951 ppc64_elf_start_multitoc_partition (struct bfd_link_info
*info
)
11953 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
11955 htab
->toc_curr
= ppc64_elf_set_toc (info
, info
->output_bfd
);
11956 htab
->toc_bfd
= NULL
;
11957 htab
->toc_first_sec
= NULL
;
11960 /* The linker repeatedly calls this function for each TOC input section
11961 and linker generated GOT section. Group input bfds such that the toc
11962 within a group is less than 64k in size. */
11965 ppc64_elf_next_toc_section (struct bfd_link_info
*info
, asection
*isec
)
11967 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
11968 bfd_vma addr
, off
, limit
;
11973 if (!htab
->second_toc_pass
)
11975 /* Keep track of the first .toc or .got section for this input bfd. */
11976 bfd_boolean new_bfd
= htab
->toc_bfd
!= isec
->owner
;
11980 htab
->toc_bfd
= isec
->owner
;
11981 htab
->toc_first_sec
= isec
;
11984 addr
= isec
->output_offset
+ isec
->output_section
->vma
;
11985 off
= addr
- htab
->toc_curr
;
11986 limit
= 0x80008000;
11987 if (ppc64_elf_tdata (isec
->owner
)->has_small_toc_reloc
)
11989 if (off
+ isec
->size
> limit
)
11991 addr
= (htab
->toc_first_sec
->output_offset
11992 + htab
->toc_first_sec
->output_section
->vma
);
11993 htab
->toc_curr
= addr
;
11994 htab
->toc_curr
&= -TOC_BASE_ALIGN
;
11997 /* toc_curr is the base address of this toc group. Set elf_gp
11998 for the input section to be the offset relative to the
11999 output toc base plus 0x8000. Making the input elf_gp an
12000 offset allows us to move the toc as a whole without
12001 recalculating input elf_gp. */
12002 off
= htab
->toc_curr
- elf_gp (info
->output_bfd
);
12003 off
+= TOC_BASE_OFF
;
12005 /* Die if someone uses a linker script that doesn't keep input
12006 file .toc and .got together. */
12008 && elf_gp (isec
->owner
) != 0
12009 && elf_gp (isec
->owner
) != off
)
12012 elf_gp (isec
->owner
) = off
;
12016 /* During the second pass toc_first_sec points to the start of
12017 a toc group, and toc_curr is used to track the old elf_gp.
12018 We use toc_bfd to ensure we only look at each bfd once. */
12019 if (htab
->toc_bfd
== isec
->owner
)
12021 htab
->toc_bfd
= isec
->owner
;
12023 if (htab
->toc_first_sec
== NULL
12024 || htab
->toc_curr
!= elf_gp (isec
->owner
))
12026 htab
->toc_curr
= elf_gp (isec
->owner
);
12027 htab
->toc_first_sec
= isec
;
12029 addr
= (htab
->toc_first_sec
->output_offset
12030 + htab
->toc_first_sec
->output_section
->vma
);
12031 off
= addr
- elf_gp (info
->output_bfd
) + TOC_BASE_OFF
;
12032 elf_gp (isec
->owner
) = off
;
12037 /* Called via elf_link_hash_traverse to merge GOT entries for global
12041 merge_global_got (struct elf_link_hash_entry
*h
, void *inf ATTRIBUTE_UNUSED
)
12043 if (h
->root
.type
== bfd_link_hash_indirect
)
12046 merge_got_entries (&h
->got
.glist
);
12051 /* Called via elf_link_hash_traverse to allocate GOT entries for global
12055 reallocate_got (struct elf_link_hash_entry
*h
, void *inf
)
12057 struct got_entry
*gent
;
12059 if (h
->root
.type
== bfd_link_hash_indirect
)
12062 for (gent
= h
->got
.glist
; gent
!= NULL
; gent
= gent
->next
)
12063 if (!gent
->is_indirect
)
12064 allocate_got (h
, (struct bfd_link_info
*) inf
, gent
);
12068 /* Called on the first multitoc pass after the last call to
12069 ppc64_elf_next_toc_section. This function removes duplicate GOT
12073 ppc64_elf_layout_multitoc (struct bfd_link_info
*info
)
12075 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12076 struct bfd
*ibfd
, *ibfd2
;
12077 bfd_boolean done_something
;
12079 htab
->multi_toc_needed
= htab
->toc_curr
!= elf_gp (info
->output_bfd
);
12081 if (!htab
->do_multi_toc
)
12084 /* Merge global sym got entries within a toc group. */
12085 elf_link_hash_traverse (&htab
->elf
, merge_global_got
, info
);
12087 /* And tlsld_got. */
12088 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12090 struct got_entry
*ent
, *ent2
;
12092 if (!is_ppc64_elf (ibfd
))
12095 ent
= ppc64_tlsld_got (ibfd
);
12096 if (!ent
->is_indirect
12097 && ent
->got
.offset
!= (bfd_vma
) -1)
12099 for (ibfd2
= ibfd
->link
.next
; ibfd2
!= NULL
; ibfd2
= ibfd2
->link
.next
)
12101 if (!is_ppc64_elf (ibfd2
))
12104 ent2
= ppc64_tlsld_got (ibfd2
);
12105 if (!ent2
->is_indirect
12106 && ent2
->got
.offset
!= (bfd_vma
) -1
12107 && elf_gp (ibfd2
) == elf_gp (ibfd
))
12109 ent2
->is_indirect
= TRUE
;
12110 ent2
->got
.ent
= ent
;
12116 /* Zap sizes of got sections. */
12117 htab
->elf
.irelplt
->rawsize
= htab
->elf
.irelplt
->size
;
12118 htab
->elf
.irelplt
->size
-= htab
->got_reli_size
;
12119 htab
->got_reli_size
= 0;
12121 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12123 asection
*got
, *relgot
;
12125 if (!is_ppc64_elf (ibfd
))
12128 got
= ppc64_elf_tdata (ibfd
)->got
;
12131 got
->rawsize
= got
->size
;
12133 relgot
= ppc64_elf_tdata (ibfd
)->relgot
;
12134 relgot
->rawsize
= relgot
->size
;
12139 /* Now reallocate the got, local syms first. We don't need to
12140 allocate section contents again since we never increase size. */
12141 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12143 struct got_entry
**lgot_ents
;
12144 struct got_entry
**end_lgot_ents
;
12145 struct plt_entry
**local_plt
;
12146 struct plt_entry
**end_local_plt
;
12147 unsigned char *lgot_masks
;
12148 bfd_size_type locsymcount
;
12149 Elf_Internal_Shdr
*symtab_hdr
;
12152 if (!is_ppc64_elf (ibfd
))
12155 lgot_ents
= elf_local_got_ents (ibfd
);
12159 symtab_hdr
= &elf_symtab_hdr (ibfd
);
12160 locsymcount
= symtab_hdr
->sh_info
;
12161 end_lgot_ents
= lgot_ents
+ locsymcount
;
12162 local_plt
= (struct plt_entry
**) end_lgot_ents
;
12163 end_local_plt
= local_plt
+ locsymcount
;
12164 lgot_masks
= (unsigned char *) end_local_plt
;
12165 s
= ppc64_elf_tdata (ibfd
)->got
;
12166 for (; lgot_ents
< end_lgot_ents
; ++lgot_ents
, ++lgot_masks
)
12168 struct got_entry
*ent
;
12170 for (ent
= *lgot_ents
; ent
!= NULL
; ent
= ent
->next
)
12172 unsigned int ent_size
= 8;
12173 unsigned int rel_size
= sizeof (Elf64_External_Rela
);
12175 ent
->got
.offset
= s
->size
;
12176 if ((ent
->tls_type
& *lgot_masks
& TLS_GD
) != 0)
12181 s
->size
+= ent_size
;
12182 if ((*lgot_masks
& (TLS_TLS
| PLT_IFUNC
)) == PLT_IFUNC
)
12184 htab
->elf
.irelplt
->size
+= rel_size
;
12185 htab
->got_reli_size
+= rel_size
;
12187 else if (bfd_link_pic (info
)
12188 && !((ent
->tls_type
& TLS_TPREL
) != 0
12189 && bfd_link_executable (info
)))
12191 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
12192 srel
->size
+= rel_size
;
12198 elf_link_hash_traverse (&htab
->elf
, reallocate_got
, info
);
12200 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12202 struct got_entry
*ent
;
12204 if (!is_ppc64_elf (ibfd
))
12207 ent
= ppc64_tlsld_got (ibfd
);
12208 if (!ent
->is_indirect
12209 && ent
->got
.offset
!= (bfd_vma
) -1)
12211 asection
*s
= ppc64_elf_tdata (ibfd
)->got
;
12212 ent
->got
.offset
= s
->size
;
12214 if (bfd_link_pic (info
))
12216 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
12217 srel
->size
+= sizeof (Elf64_External_Rela
);
12222 done_something
= htab
->elf
.irelplt
->rawsize
!= htab
->elf
.irelplt
->size
;
12223 if (!done_something
)
12224 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12228 if (!is_ppc64_elf (ibfd
))
12231 got
= ppc64_elf_tdata (ibfd
)->got
;
12234 done_something
= got
->rawsize
!= got
->size
;
12235 if (done_something
)
12240 if (done_something
)
12241 (*htab
->params
->layout_sections_again
) ();
12243 /* Set up for second pass over toc sections to recalculate elf_gp
12244 on input sections. */
12245 htab
->toc_bfd
= NULL
;
12246 htab
->toc_first_sec
= NULL
;
12247 htab
->second_toc_pass
= TRUE
;
12248 return done_something
;
12251 /* Called after second pass of multitoc partitioning. */
12254 ppc64_elf_finish_multitoc_partition (struct bfd_link_info
*info
)
12256 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12258 /* After the second pass, toc_curr tracks the TOC offset used
12259 for code sections below in ppc64_elf_next_input_section. */
12260 htab
->toc_curr
= TOC_BASE_OFF
;
12263 /* No toc references were found in ISEC. If the code in ISEC makes no
12264 calls, then there's no need to use toc adjusting stubs when branching
12265 into ISEC. Actually, indirect calls from ISEC are OK as they will
12266 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
12267 needed, and 2 if a cyclical call-graph was found but no other reason
12268 for a stub was detected. If called from the top level, a return of
12269 2 means the same as a return of 0. */
12272 toc_adjusting_stub_needed (struct bfd_link_info
*info
, asection
*isec
)
12276 /* Mark this section as checked. */
12277 isec
->call_check_done
= 1;
12279 /* We know none of our code bearing sections will need toc stubs. */
12280 if ((isec
->flags
& SEC_LINKER_CREATED
) != 0)
12283 if (isec
->size
== 0)
12286 if (isec
->output_section
== NULL
)
12290 if (isec
->reloc_count
!= 0)
12292 Elf_Internal_Rela
*relstart
, *rel
;
12293 Elf_Internal_Sym
*local_syms
;
12294 struct ppc_link_hash_table
*htab
;
12296 relstart
= _bfd_elf_link_read_relocs (isec
->owner
, isec
, NULL
, NULL
,
12297 info
->keep_memory
);
12298 if (relstart
== NULL
)
12301 /* Look for branches to outside of this section. */
12303 htab
= ppc_hash_table (info
);
12307 for (rel
= relstart
; rel
< relstart
+ isec
->reloc_count
; ++rel
)
12309 enum elf_ppc64_reloc_type r_type
;
12310 unsigned long r_symndx
;
12311 struct elf_link_hash_entry
*h
;
12312 struct ppc_link_hash_entry
*eh
;
12313 Elf_Internal_Sym
*sym
;
12315 struct _opd_sec_data
*opd
;
12319 r_type
= ELF64_R_TYPE (rel
->r_info
);
12320 if (r_type
!= R_PPC64_REL24
12321 && r_type
!= R_PPC64_REL24_NOTOC
12322 && r_type
!= R_PPC64_REL14
12323 && r_type
!= R_PPC64_REL14_BRTAKEN
12324 && r_type
!= R_PPC64_REL14_BRNTAKEN
12325 && r_type
!= R_PPC64_PLTCALL
12326 && r_type
!= R_PPC64_PLTCALL_NOTOC
)
12329 r_symndx
= ELF64_R_SYM (rel
->r_info
);
12330 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
, r_symndx
,
12337 /* Calls to dynamic lib functions go through a plt call stub
12339 eh
= (struct ppc_link_hash_entry
*) h
;
12341 && (eh
->elf
.plt
.plist
!= NULL
12343 && ppc_follow_link (eh
->oh
)->elf
.plt
.plist
!= NULL
)))
12349 if (sym_sec
== NULL
)
12350 /* Ignore other undefined symbols. */
12353 /* Assume branches to other sections not included in the
12354 link need stubs too, to cover -R and absolute syms. */
12355 if (sym_sec
->output_section
== NULL
)
12362 sym_value
= sym
->st_value
;
12365 if (h
->root
.type
!= bfd_link_hash_defined
12366 && h
->root
.type
!= bfd_link_hash_defweak
)
12368 sym_value
= h
->root
.u
.def
.value
;
12370 sym_value
+= rel
->r_addend
;
12372 /* If this branch reloc uses an opd sym, find the code section. */
12373 opd
= get_opd_info (sym_sec
);
12376 if (h
== NULL
&& opd
->adjust
!= NULL
)
12380 adjust
= opd
->adjust
[OPD_NDX (sym_value
)];
12382 /* Assume deleted functions won't ever be called. */
12384 sym_value
+= adjust
;
12387 dest
= opd_entry_value (sym_sec
, sym_value
,
12388 &sym_sec
, NULL
, FALSE
);
12389 if (dest
== (bfd_vma
) -1)
12394 + sym_sec
->output_offset
12395 + sym_sec
->output_section
->vma
);
12397 /* Ignore branch to self. */
12398 if (sym_sec
== isec
)
12401 /* If the called function uses the toc, we need a stub. */
12402 if (sym_sec
->has_toc_reloc
12403 || sym_sec
->makes_toc_func_call
)
12409 /* Assume any branch that needs a long branch stub might in fact
12410 need a plt_branch stub. A plt_branch stub uses r2. */
12411 else if (dest
- (isec
->output_offset
12412 + isec
->output_section
->vma
12413 + rel
->r_offset
) + (1 << 25)
12414 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
12422 /* If calling back to a section in the process of being
12423 tested, we can't say for sure that no toc adjusting stubs
12424 are needed, so don't return zero. */
12425 else if (sym_sec
->call_check_in_progress
)
12428 /* Branches to another section that itself doesn't have any TOC
12429 references are OK. Recursively call ourselves to check. */
12430 else if (!sym_sec
->call_check_done
)
12434 /* Mark current section as indeterminate, so that other
12435 sections that call back to current won't be marked as
12437 isec
->call_check_in_progress
= 1;
12438 recur
= toc_adjusting_stub_needed (info
, sym_sec
);
12439 isec
->call_check_in_progress
= 0;
12450 if (local_syms
!= NULL
12451 && (elf_symtab_hdr (isec
->owner
).contents
12452 != (unsigned char *) local_syms
))
12454 if (elf_section_data (isec
)->relocs
!= relstart
)
12459 && isec
->map_head
.s
!= NULL
12460 && (strcmp (isec
->output_section
->name
, ".init") == 0
12461 || strcmp (isec
->output_section
->name
, ".fini") == 0))
12463 if (isec
->map_head
.s
->has_toc_reloc
12464 || isec
->map_head
.s
->makes_toc_func_call
)
12466 else if (!isec
->map_head
.s
->call_check_done
)
12469 isec
->call_check_in_progress
= 1;
12470 recur
= toc_adjusting_stub_needed (info
, isec
->map_head
.s
);
12471 isec
->call_check_in_progress
= 0;
12478 isec
->makes_toc_func_call
= 1;
12483 /* The linker repeatedly calls this function for each input section,
12484 in the order that input sections are linked into output sections.
12485 Build lists of input sections to determine groupings between which
12486 we may insert linker stubs. */
12489 ppc64_elf_next_input_section (struct bfd_link_info
*info
, asection
*isec
)
12491 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12496 if ((isec
->output_section
->flags
& SEC_CODE
) != 0
12497 && isec
->output_section
->id
< htab
->sec_info_arr_size
)
12499 /* This happens to make the list in reverse order,
12500 which is what we want. */
12501 htab
->sec_info
[isec
->id
].u
.list
12502 = htab
->sec_info
[isec
->output_section
->id
].u
.list
;
12503 htab
->sec_info
[isec
->output_section
->id
].u
.list
= isec
;
12506 if (htab
->multi_toc_needed
)
12508 /* Analyse sections that aren't already flagged as needing a
12509 valid toc pointer. Exclude .fixup for the linux kernel.
12510 .fixup contains branches, but only back to the function that
12511 hit an exception. */
12512 if (!(isec
->has_toc_reloc
12513 || (isec
->flags
& SEC_CODE
) == 0
12514 || strcmp (isec
->name
, ".fixup") == 0
12515 || isec
->call_check_done
))
12517 if (toc_adjusting_stub_needed (info
, isec
) < 0)
12520 /* Make all sections use the TOC assigned for this object file.
12521 This will be wrong for pasted sections; We fix that in
12522 check_pasted_section(). */
12523 if (elf_gp (isec
->owner
) != 0)
12524 htab
->toc_curr
= elf_gp (isec
->owner
);
12527 htab
->sec_info
[isec
->id
].toc_off
= htab
->toc_curr
;
12531 /* Check that all .init and .fini sections use the same toc, if they
12532 have toc relocs. */
12535 check_pasted_section (struct bfd_link_info
*info
, const char *name
)
12537 asection
*o
= bfd_get_section_by_name (info
->output_bfd
, name
);
12541 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12542 bfd_vma toc_off
= 0;
12545 for (i
= o
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
12546 if (i
->has_toc_reloc
)
12549 toc_off
= htab
->sec_info
[i
->id
].toc_off
;
12550 else if (toc_off
!= htab
->sec_info
[i
->id
].toc_off
)
12555 for (i
= o
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
12556 if (i
->makes_toc_func_call
)
12558 toc_off
= htab
->sec_info
[i
->id
].toc_off
;
12562 /* Make sure the whole pasted function uses the same toc offset. */
12564 for (i
= o
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
12565 htab
->sec_info
[i
->id
].toc_off
= toc_off
;
12571 ppc64_elf_check_init_fini (struct bfd_link_info
*info
)
12573 return (check_pasted_section (info
, ".init")
12574 & check_pasted_section (info
, ".fini"));
12577 /* See whether we can group stub sections together. Grouping stub
12578 sections may result in fewer stubs. More importantly, we need to
12579 put all .init* and .fini* stubs at the beginning of the .init or
12580 .fini output sections respectively, because glibc splits the
12581 _init and _fini functions into multiple parts. Putting a stub in
12582 the middle of a function is not a good idea. */
12585 group_sections (struct bfd_link_info
*info
,
12586 bfd_size_type stub_group_size
,
12587 bfd_boolean stubs_always_before_branch
)
12589 struct ppc_link_hash_table
*htab
;
12591 bfd_boolean suppress_size_errors
;
12593 htab
= ppc_hash_table (info
);
12597 suppress_size_errors
= FALSE
;
12598 if (stub_group_size
== 1)
12600 /* Default values. */
12601 if (stubs_always_before_branch
)
12602 stub_group_size
= 0x1e00000;
12604 stub_group_size
= 0x1c00000;
12605 suppress_size_errors
= TRUE
;
12608 for (osec
= info
->output_bfd
->sections
; osec
!= NULL
; osec
= osec
->next
)
12612 if (osec
->id
>= htab
->sec_info_arr_size
)
12615 tail
= htab
->sec_info
[osec
->id
].u
.list
;
12616 while (tail
!= NULL
)
12620 bfd_size_type total
;
12621 bfd_boolean big_sec
;
12623 struct map_stub
*group
;
12624 bfd_size_type group_size
;
12627 total
= tail
->size
;
12628 group_size
= (ppc64_elf_section_data (tail
) != NULL
12629 && ppc64_elf_section_data (tail
)->has_14bit_branch
12630 ? stub_group_size
>> 10 : stub_group_size
);
12632 big_sec
= total
> group_size
;
12633 if (big_sec
&& !suppress_size_errors
)
12634 /* xgettext:c-format */
12635 _bfd_error_handler (_("%pB section %pA exceeds stub group size"),
12636 tail
->owner
, tail
);
12637 curr_toc
= htab
->sec_info
[tail
->id
].toc_off
;
12639 while ((prev
= htab
->sec_info
[curr
->id
].u
.list
) != NULL
12640 && ((total
+= curr
->output_offset
- prev
->output_offset
)
12641 < (ppc64_elf_section_data (prev
) != NULL
12642 && ppc64_elf_section_data (prev
)->has_14bit_branch
12643 ? (group_size
= stub_group_size
>> 10) : group_size
))
12644 && htab
->sec_info
[prev
->id
].toc_off
== curr_toc
)
12647 /* OK, the size from the start of CURR to the end is less
12648 than group_size and thus can be handled by one stub
12649 section. (or the tail section is itself larger than
12650 group_size, in which case we may be toast.) We should
12651 really be keeping track of the total size of stubs added
12652 here, as stubs contribute to the final output section
12653 size. That's a little tricky, and this way will only
12654 break if stubs added make the total size more than 2^25,
12655 ie. for the default stub_group_size, if stubs total more
12656 than 2097152 bytes, or nearly 75000 plt call stubs. */
12657 group
= bfd_alloc (curr
->owner
, sizeof (*group
));
12660 group
->link_sec
= curr
;
12661 group
->stub_sec
= NULL
;
12662 group
->needs_save_res
= 0;
12663 group
->lr_restore
= 0;
12664 group
->eh_size
= 0;
12665 group
->eh_base
= 0;
12666 group
->next
= htab
->group
;
12667 htab
->group
= group
;
12670 prev
= htab
->sec_info
[tail
->id
].u
.list
;
12671 /* Set up this stub group. */
12672 htab
->sec_info
[tail
->id
].u
.group
= group
;
12674 while (tail
!= curr
&& (tail
= prev
) != NULL
);
12676 /* But wait, there's more! Input sections up to group_size
12677 bytes before the stub section can be handled by it too.
12678 Don't do this if we have a really large section after the
12679 stubs, as adding more stubs increases the chance that
12680 branches may not reach into the stub section. */
12681 if (!stubs_always_before_branch
&& !big_sec
)
12684 while (prev
!= NULL
12685 && ((total
+= tail
->output_offset
- prev
->output_offset
)
12686 < (ppc64_elf_section_data (prev
) != NULL
12687 && ppc64_elf_section_data (prev
)->has_14bit_branch
12688 ? (group_size
= stub_group_size
>> 10)
12690 && htab
->sec_info
[prev
->id
].toc_off
== curr_toc
)
12693 prev
= htab
->sec_info
[tail
->id
].u
.list
;
12694 htab
->sec_info
[tail
->id
].u
.group
= group
;
12703 static const unsigned char glink_eh_frame_cie
[] =
12705 0, 0, 0, 16, /* length. */
12706 0, 0, 0, 0, /* id. */
12707 1, /* CIE version. */
12708 'z', 'R', 0, /* Augmentation string. */
12709 4, /* Code alignment. */
12710 0x78, /* Data alignment. */
12712 1, /* Augmentation size. */
12713 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding. */
12714 DW_CFA_def_cfa
, 1, 0 /* def_cfa: r1 offset 0. */
12717 /* Stripping output sections is normally done before dynamic section
12718 symbols have been allocated. This function is called later, and
12719 handles cases like htab->brlt which is mapped to its own output
12723 maybe_strip_output (struct bfd_link_info
*info
, asection
*isec
)
12725 if (isec
->size
== 0
12726 && isec
->output_section
->size
== 0
12727 && !(isec
->output_section
->flags
& SEC_KEEP
)
12728 && !bfd_section_removed_from_list (info
->output_bfd
,
12729 isec
->output_section
)
12730 && elf_section_data (isec
->output_section
)->dynindx
== 0)
12732 isec
->output_section
->flags
|= SEC_EXCLUDE
;
12733 bfd_section_list_remove (info
->output_bfd
, isec
->output_section
);
12734 info
->output_bfd
->section_count
--;
12738 /* Determine and set the size of the stub section for a final link.
12740 The basic idea here is to examine all the relocations looking for
12741 PC-relative calls to a target that is unreachable with a "bl"
12745 ppc64_elf_size_stubs (struct bfd_link_info
*info
)
12747 bfd_size_type stub_group_size
;
12748 bfd_boolean stubs_always_before_branch
;
12749 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12754 if (htab
->params
->plt_thread_safe
== -1 && !bfd_link_executable (info
))
12755 htab
->params
->plt_thread_safe
= 1;
12756 if (!htab
->opd_abi
)
12757 htab
->params
->plt_thread_safe
= 0;
12758 else if (htab
->params
->plt_thread_safe
== -1)
12760 static const char *const thread_starter
[] =
12764 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12766 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12767 "mq_notify", "create_timer",
12772 "GOMP_parallel_start",
12773 "GOMP_parallel_loop_static",
12774 "GOMP_parallel_loop_static_start",
12775 "GOMP_parallel_loop_dynamic",
12776 "GOMP_parallel_loop_dynamic_start",
12777 "GOMP_parallel_loop_guided",
12778 "GOMP_parallel_loop_guided_start",
12779 "GOMP_parallel_loop_runtime",
12780 "GOMP_parallel_loop_runtime_start",
12781 "GOMP_parallel_sections",
12782 "GOMP_parallel_sections_start",
12788 for (i
= 0; i
< ARRAY_SIZE (thread_starter
); i
++)
12790 struct elf_link_hash_entry
*h
;
12791 h
= elf_link_hash_lookup (&htab
->elf
, thread_starter
[i
],
12792 FALSE
, FALSE
, TRUE
);
12793 htab
->params
->plt_thread_safe
= h
!= NULL
&& h
->ref_regular
;
12794 if (htab
->params
->plt_thread_safe
)
12798 stubs_always_before_branch
= htab
->params
->group_size
< 0;
12799 if (htab
->params
->group_size
< 0)
12800 stub_group_size
= -htab
->params
->group_size
;
12802 stub_group_size
= htab
->params
->group_size
;
12804 if (!group_sections (info
, stub_group_size
, stubs_always_before_branch
))
12807 #define STUB_SHRINK_ITER 20
12808 /* Loop until no stubs added. After iteration 20 of this loop we may
12809 exit on a stub section shrinking. This is to break out of a
12810 pathological case where adding stubs on one iteration decreases
12811 section gaps (perhaps due to alignment), which then requires
12812 fewer or smaller stubs on the next iteration. */
12817 unsigned int bfd_indx
;
12818 struct map_stub
*group
;
12820 htab
->stub_iteration
+= 1;
12822 for (input_bfd
= info
->input_bfds
, bfd_indx
= 0;
12824 input_bfd
= input_bfd
->link
.next
, bfd_indx
++)
12826 Elf_Internal_Shdr
*symtab_hdr
;
12828 Elf_Internal_Sym
*local_syms
= NULL
;
12830 if (!is_ppc64_elf (input_bfd
))
12833 /* We'll need the symbol table in a second. */
12834 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
12835 if (symtab_hdr
->sh_info
== 0)
12838 /* Walk over each section attached to the input bfd. */
12839 for (section
= input_bfd
->sections
;
12841 section
= section
->next
)
12843 Elf_Internal_Rela
*internal_relocs
, *irelaend
, *irela
;
12845 /* If there aren't any relocs, then there's nothing more
12847 if ((section
->flags
& SEC_RELOC
) == 0
12848 || (section
->flags
& SEC_ALLOC
) == 0
12849 || (section
->flags
& SEC_LOAD
) == 0
12850 || (section
->flags
& SEC_CODE
) == 0
12851 || section
->reloc_count
== 0)
12854 /* If this section is a link-once section that will be
12855 discarded, then don't create any stubs. */
12856 if (section
->output_section
== NULL
12857 || section
->output_section
->owner
!= info
->output_bfd
)
12860 /* Get the relocs. */
12862 = _bfd_elf_link_read_relocs (input_bfd
, section
, NULL
, NULL
,
12863 info
->keep_memory
);
12864 if (internal_relocs
== NULL
)
12865 goto error_ret_free_local
;
12867 /* Now examine each relocation. */
12868 irela
= internal_relocs
;
12869 irelaend
= irela
+ section
->reloc_count
;
12870 for (; irela
< irelaend
; irela
++)
12872 enum elf_ppc64_reloc_type r_type
;
12873 unsigned int r_indx
;
12874 enum ppc_stub_type stub_type
;
12875 struct ppc_stub_hash_entry
*stub_entry
;
12876 asection
*sym_sec
, *code_sec
;
12877 bfd_vma sym_value
, code_value
;
12878 bfd_vma destination
;
12879 unsigned long local_off
;
12880 bfd_boolean ok_dest
;
12881 struct ppc_link_hash_entry
*hash
;
12882 struct ppc_link_hash_entry
*fdh
;
12883 struct elf_link_hash_entry
*h
;
12884 Elf_Internal_Sym
*sym
;
12886 const asection
*id_sec
;
12887 struct _opd_sec_data
*opd
;
12888 struct plt_entry
*plt_ent
;
12890 r_type
= ELF64_R_TYPE (irela
->r_info
);
12891 r_indx
= ELF64_R_SYM (irela
->r_info
);
12893 if (r_type
>= R_PPC64_max
)
12895 bfd_set_error (bfd_error_bad_value
);
12896 goto error_ret_free_internal
;
12899 /* Only look for stubs on branch instructions. */
12900 if (r_type
!= R_PPC64_REL24
12901 && r_type
!= R_PPC64_REL24_NOTOC
12902 && r_type
!= R_PPC64_REL14
12903 && r_type
!= R_PPC64_REL14_BRTAKEN
12904 && r_type
!= R_PPC64_REL14_BRNTAKEN
)
12907 /* Now determine the call target, its name, value,
12909 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
12910 r_indx
, input_bfd
))
12911 goto error_ret_free_internal
;
12912 hash
= (struct ppc_link_hash_entry
*) h
;
12919 sym_value
= sym
->st_value
;
12920 if (sym_sec
!= NULL
12921 && sym_sec
->output_section
!= NULL
)
12924 else if (hash
->elf
.root
.type
== bfd_link_hash_defined
12925 || hash
->elf
.root
.type
== bfd_link_hash_defweak
)
12927 sym_value
= hash
->elf
.root
.u
.def
.value
;
12928 if (sym_sec
->output_section
!= NULL
)
12931 else if (hash
->elf
.root
.type
== bfd_link_hash_undefweak
12932 || hash
->elf
.root
.type
== bfd_link_hash_undefined
)
12934 /* Recognise an old ABI func code entry sym, and
12935 use the func descriptor sym instead if it is
12937 if (hash
->elf
.root
.root
.string
[0] == '.'
12938 && hash
->oh
!= NULL
)
12940 fdh
= ppc_follow_link (hash
->oh
);
12941 if (fdh
->elf
.root
.type
== bfd_link_hash_defined
12942 || fdh
->elf
.root
.type
== bfd_link_hash_defweak
)
12944 sym_sec
= fdh
->elf
.root
.u
.def
.section
;
12945 sym_value
= fdh
->elf
.root
.u
.def
.value
;
12946 if (sym_sec
->output_section
!= NULL
)
12955 bfd_set_error (bfd_error_bad_value
);
12956 goto error_ret_free_internal
;
12963 sym_value
+= irela
->r_addend
;
12964 destination
= (sym_value
12965 + sym_sec
->output_offset
12966 + sym_sec
->output_section
->vma
);
12967 local_off
= PPC64_LOCAL_ENTRY_OFFSET (hash
12972 code_sec
= sym_sec
;
12973 code_value
= sym_value
;
12974 opd
= get_opd_info (sym_sec
);
12979 if (hash
== NULL
&& opd
->adjust
!= NULL
)
12981 long adjust
= opd
->adjust
[OPD_NDX (sym_value
)];
12984 code_value
+= adjust
;
12985 sym_value
+= adjust
;
12987 dest
= opd_entry_value (sym_sec
, sym_value
,
12988 &code_sec
, &code_value
, FALSE
);
12989 if (dest
!= (bfd_vma
) -1)
12991 destination
= dest
;
12994 /* Fixup old ABI sym to point at code
12996 hash
->elf
.root
.type
= bfd_link_hash_defweak
;
12997 hash
->elf
.root
.u
.def
.section
= code_sec
;
12998 hash
->elf
.root
.u
.def
.value
= code_value
;
13003 /* Determine what (if any) linker stub is needed. */
13005 stub_type
= ppc_type_of_stub (section
, irela
, &hash
,
13006 &plt_ent
, destination
,
13009 if (r_type
== R_PPC64_REL24_NOTOC
)
13011 if (stub_type
== ppc_stub_plt_call
)
13012 stub_type
= ppc_stub_plt_call_notoc
;
13013 else if (stub_type
== ppc_stub_long_branch
13014 || (code_sec
!= NULL
13015 && code_sec
->output_section
!= NULL
13016 && (((hash
? hash
->elf
.other
: sym
->st_other
)
13017 & STO_PPC64_LOCAL_MASK
)
13018 > 1 << STO_PPC64_LOCAL_BIT
)))
13019 stub_type
= ppc_stub_long_branch_notoc
;
13021 else if (stub_type
!= ppc_stub_plt_call
)
13023 /* Check whether we need a TOC adjusting stub.
13024 Since the linker pastes together pieces from
13025 different object files when creating the
13026 _init and _fini functions, it may be that a
13027 call to what looks like a local sym is in
13028 fact a call needing a TOC adjustment. */
13029 if ((code_sec
!= NULL
13030 && code_sec
->output_section
!= NULL
13031 && (htab
->sec_info
[code_sec
->id
].toc_off
13032 != htab
->sec_info
[section
->id
].toc_off
)
13033 && (code_sec
->has_toc_reloc
13034 || code_sec
->makes_toc_func_call
))
13035 || (((hash
? hash
->elf
.other
: sym
->st_other
)
13036 & STO_PPC64_LOCAL_MASK
)
13037 == 1 << STO_PPC64_LOCAL_BIT
))
13038 stub_type
= ppc_stub_long_branch_r2off
;
13041 if (stub_type
== ppc_stub_none
)
13044 /* __tls_get_addr calls might be eliminated. */
13045 if (stub_type
!= ppc_stub_plt_call
13046 && stub_type
!= ppc_stub_plt_call_notoc
13048 && (hash
== htab
->tls_get_addr
13049 || hash
== htab
->tls_get_addr_fd
)
13050 && section
->has_tls_reloc
13051 && irela
!= internal_relocs
)
13053 /* Get tls info. */
13054 unsigned char *tls_mask
;
13056 if (!get_tls_mask (&tls_mask
, NULL
, NULL
, &local_syms
,
13057 irela
- 1, input_bfd
))
13058 goto error_ret_free_internal
;
13059 if ((*tls_mask
& TLS_TLS
) != 0)
13063 if (stub_type
== ppc_stub_plt_call
)
13066 && htab
->params
->plt_localentry0
!= 0
13067 && is_elfv2_localentry0 (&hash
->elf
))
13068 htab
->has_plt_localentry0
= 1;
13069 else if (irela
+ 1 < irelaend
13070 && irela
[1].r_offset
== irela
->r_offset
+ 4
13071 && (ELF64_R_TYPE (irela
[1].r_info
)
13072 == R_PPC64_TOCSAVE
))
13074 if (!tocsave_find (htab
, INSERT
,
13075 &local_syms
, irela
+ 1, input_bfd
))
13076 goto error_ret_free_internal
;
13079 stub_type
= ppc_stub_plt_call_r2save
;
13082 /* Support for grouping stub sections. */
13083 id_sec
= htab
->sec_info
[section
->id
].u
.group
->link_sec
;
13085 /* Get the name of this stub. */
13086 stub_name
= ppc_stub_name (id_sec
, sym_sec
, hash
, irela
);
13088 goto error_ret_free_internal
;
13090 stub_entry
= ppc_stub_hash_lookup (&htab
->stub_hash_table
,
13091 stub_name
, FALSE
, FALSE
);
13092 if (stub_entry
!= NULL
)
13094 enum ppc_stub_type old_type
;
13095 /* A stub has already been created, but it may
13096 not be the required type. We shouldn't be
13097 transitioning from plt_call to long_branch
13098 stubs or vice versa, but we might be
13099 upgrading from plt_call to plt_call_r2save or
13100 from long_branch to long_branch_r2off. */
13102 old_type
= stub_entry
->stub_type
;
13108 case ppc_stub_save_res
:
13111 case ppc_stub_plt_call
:
13112 case ppc_stub_plt_call_r2save
:
13113 case ppc_stub_plt_call_notoc
:
13114 case ppc_stub_plt_call_both
:
13115 if (stub_type
== ppc_stub_plt_call
)
13117 else if (stub_type
== ppc_stub_plt_call_r2save
)
13119 if (old_type
== ppc_stub_plt_call_notoc
)
13120 stub_type
= ppc_stub_plt_call_both
;
13122 else if (stub_type
== ppc_stub_plt_call_notoc
)
13124 if (old_type
== ppc_stub_plt_call_r2save
)
13125 stub_type
= ppc_stub_plt_call_both
;
13131 case ppc_stub_plt_branch
:
13132 case ppc_stub_plt_branch_r2off
:
13133 case ppc_stub_plt_branch_notoc
:
13134 case ppc_stub_plt_branch_both
:
13135 old_type
+= (ppc_stub_long_branch
13136 - ppc_stub_plt_branch
);
13137 /* Fall through. */
13138 case ppc_stub_long_branch
:
13139 case ppc_stub_long_branch_r2off
:
13140 case ppc_stub_long_branch_notoc
:
13141 case ppc_stub_long_branch_both
:
13142 if (stub_type
== ppc_stub_long_branch
)
13144 else if (stub_type
== ppc_stub_long_branch_r2off
)
13146 if (old_type
== ppc_stub_long_branch_notoc
)
13147 stub_type
= ppc_stub_long_branch_both
;
13149 else if (stub_type
== ppc_stub_long_branch_notoc
)
13151 if (old_type
== ppc_stub_long_branch_r2off
)
13152 stub_type
= ppc_stub_long_branch_both
;
13158 if (old_type
< stub_type
)
13159 stub_entry
->stub_type
= stub_type
;
13163 stub_entry
= ppc_add_stub (stub_name
, section
, info
);
13164 if (stub_entry
== NULL
)
13167 error_ret_free_internal
:
13168 if (elf_section_data (section
)->relocs
== NULL
)
13169 free (internal_relocs
);
13170 error_ret_free_local
:
13171 if (local_syms
!= NULL
13172 && (symtab_hdr
->contents
13173 != (unsigned char *) local_syms
))
13178 stub_entry
->stub_type
= stub_type
;
13179 if (stub_type
>= ppc_stub_plt_call
13180 && stub_type
<= ppc_stub_plt_call_both
)
13182 stub_entry
->target_value
= sym_value
;
13183 stub_entry
->target_section
= sym_sec
;
13187 stub_entry
->target_value
= code_value
;
13188 stub_entry
->target_section
= code_sec
;
13190 stub_entry
->h
= hash
;
13191 stub_entry
->plt_ent
= plt_ent
;
13192 stub_entry
->symtype
13193 = hash
? hash
->elf
.type
: ELF_ST_TYPE (sym
->st_info
);
13194 stub_entry
->other
= hash
? hash
->elf
.other
: sym
->st_other
;
13197 && (hash
->elf
.root
.type
== bfd_link_hash_defined
13198 || hash
->elf
.root
.type
== bfd_link_hash_defweak
))
13199 htab
->stub_globals
+= 1;
13202 /* We're done with the internal relocs, free them. */
13203 if (elf_section_data (section
)->relocs
!= internal_relocs
)
13204 free (internal_relocs
);
13207 if (local_syms
!= NULL
13208 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
13210 if (!info
->keep_memory
)
13213 symtab_hdr
->contents
= (unsigned char *) local_syms
;
13217 /* We may have added some stubs. Find out the new size of the
13219 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13221 group
->lr_restore
= 0;
13222 group
->eh_size
= 0;
13223 if (group
->stub_sec
!= NULL
)
13225 asection
*stub_sec
= group
->stub_sec
;
13227 if (htab
->stub_iteration
<= STUB_SHRINK_ITER
13228 || stub_sec
->rawsize
< stub_sec
->size
)
13229 /* Past STUB_SHRINK_ITER, rawsize is the max size seen. */
13230 stub_sec
->rawsize
= stub_sec
->size
;
13231 stub_sec
->size
= 0;
13232 stub_sec
->reloc_count
= 0;
13233 stub_sec
->flags
&= ~SEC_RELOC
;
13237 if (htab
->stub_iteration
<= STUB_SHRINK_ITER
13238 || htab
->brlt
->rawsize
< htab
->brlt
->size
)
13239 htab
->brlt
->rawsize
= htab
->brlt
->size
;
13240 htab
->brlt
->size
= 0;
13241 htab
->brlt
->reloc_count
= 0;
13242 htab
->brlt
->flags
&= ~SEC_RELOC
;
13243 if (htab
->relbrlt
!= NULL
)
13244 htab
->relbrlt
->size
= 0;
13246 bfd_hash_traverse (&htab
->stub_hash_table
, ppc_size_one_stub
, info
);
13248 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13249 if (group
->needs_save_res
)
13250 group
->stub_sec
->size
+= htab
->sfpr
->size
;
13252 if (info
->emitrelocations
13253 && htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
13255 htab
->glink
->reloc_count
= 1;
13256 htab
->glink
->flags
|= SEC_RELOC
;
13259 if (htab
->glink_eh_frame
!= NULL
13260 && !bfd_is_abs_section (htab
->glink_eh_frame
->output_section
)
13261 && htab
->glink_eh_frame
->output_section
->size
> 8)
13263 size_t size
= 0, align
= 4;
13265 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13266 if (group
->eh_size
!= 0)
13267 size
+= (group
->eh_size
+ 17 + align
- 1) & -align
;
13268 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
13269 size
+= (24 + align
- 1) & -align
;
13271 size
+= (sizeof (glink_eh_frame_cie
) + align
- 1) & -align
;
13272 align
= 1ul << htab
->glink_eh_frame
->output_section
->alignment_power
;
13273 size
= (size
+ align
- 1) & -align
;
13274 htab
->glink_eh_frame
->rawsize
= htab
->glink_eh_frame
->size
;
13275 htab
->glink_eh_frame
->size
= size
;
13278 if (htab
->params
->plt_stub_align
!= 0)
13279 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13280 if (group
->stub_sec
!= NULL
)
13282 int align
= abs (htab
->params
->plt_stub_align
);
13283 group
->stub_sec
->size
13284 = (group
->stub_sec
->size
+ (1 << align
) - 1) & -(1 << align
);
13287 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13288 if (group
->stub_sec
!= NULL
13289 && group
->stub_sec
->rawsize
!= group
->stub_sec
->size
13290 && (htab
->stub_iteration
<= STUB_SHRINK_ITER
13291 || group
->stub_sec
->rawsize
< group
->stub_sec
->size
))
13295 && (htab
->brlt
->rawsize
== htab
->brlt
->size
13296 || (htab
->stub_iteration
> STUB_SHRINK_ITER
13297 && htab
->brlt
->rawsize
> htab
->brlt
->size
))
13298 && (htab
->glink_eh_frame
== NULL
13299 || htab
->glink_eh_frame
->rawsize
== htab
->glink_eh_frame
->size
))
13302 /* Ask the linker to do its stuff. */
13303 (*htab
->params
->layout_sections_again
) ();
13306 if (htab
->glink_eh_frame
!= NULL
13307 && htab
->glink_eh_frame
->size
!= 0)
13310 bfd_byte
*p
, *last_fde
;
13311 size_t last_fde_len
, size
, align
, pad
;
13312 struct map_stub
*group
;
13314 /* It is necessary to at least have a rough outline of the
13315 linker generated CIEs and FDEs written before
13316 bfd_elf_discard_info is run, in order for these FDEs to be
13317 indexed in .eh_frame_hdr. */
13318 p
= bfd_zalloc (htab
->glink_eh_frame
->owner
, htab
->glink_eh_frame
->size
);
13321 htab
->glink_eh_frame
->contents
= p
;
13325 memcpy (p
, glink_eh_frame_cie
, sizeof (glink_eh_frame_cie
));
13326 /* CIE length (rewrite in case little-endian). */
13327 last_fde_len
= ((sizeof (glink_eh_frame_cie
) + align
- 1) & -align
) - 4;
13328 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
, p
);
13329 p
+= last_fde_len
+ 4;
13331 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13332 if (group
->eh_size
!= 0)
13334 group
->eh_base
= p
- htab
->glink_eh_frame
->contents
;
13336 last_fde_len
= ((group
->eh_size
+ 17 + align
- 1) & -align
) - 4;
13338 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
, p
);
13341 val
= p
- htab
->glink_eh_frame
->contents
;
13342 bfd_put_32 (htab
->elf
.dynobj
, val
, p
);
13344 /* Offset to stub section, written later. */
13346 /* stub section size. */
13347 bfd_put_32 (htab
->elf
.dynobj
, group
->stub_sec
->size
, p
);
13349 /* Augmentation. */
13351 /* Make sure we don't have all nops. This is enough for
13352 elf-eh-frame.c to detect the last non-nop opcode. */
13353 p
[group
->eh_size
- 1] = DW_CFA_advance_loc
+ 1;
13354 p
= last_fde
+ last_fde_len
+ 4;
13356 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
13359 last_fde_len
= ((24 + align
- 1) & -align
) - 4;
13361 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
, p
);
13364 val
= p
- htab
->glink_eh_frame
->contents
;
13365 bfd_put_32 (htab
->elf
.dynobj
, val
, p
);
13367 /* Offset to .glink, written later. */
13370 bfd_put_32 (htab
->elf
.dynobj
, htab
->glink
->size
- 8, p
);
13372 /* Augmentation. */
13375 *p
++ = DW_CFA_advance_loc
+ 1;
13376 *p
++ = DW_CFA_register
;
13378 *p
++ = htab
->opd_abi
? 12 : 0;
13379 *p
++ = DW_CFA_advance_loc
+ (htab
->opd_abi
? 5 : 7);
13380 *p
++ = DW_CFA_restore_extended
;
13382 p
+= ((24 + align
- 1) & -align
) - 24;
13384 /* Subsume any padding into the last FDE if user .eh_frame
13385 sections are aligned more than glink_eh_frame. Otherwise any
13386 zero padding will be seen as a terminator. */
13387 align
= 1ul << htab
->glink_eh_frame
->output_section
->alignment_power
;
13388 size
= p
- htab
->glink_eh_frame
->contents
;
13389 pad
= ((size
+ align
- 1) & -align
) - size
;
13390 htab
->glink_eh_frame
->size
= size
+ pad
;
13391 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
+ pad
, last_fde
);
13394 maybe_strip_output (info
, htab
->brlt
);
13395 if (htab
->glink_eh_frame
!= NULL
)
13396 maybe_strip_output (info
, htab
->glink_eh_frame
);
13401 /* Called after we have determined section placement. If sections
13402 move, we'll be called again. Provide a value for TOCstart. */
13405 ppc64_elf_set_toc (struct bfd_link_info
*info
, bfd
*obfd
)
13408 bfd_vma TOCstart
, adjust
;
13412 struct elf_link_hash_entry
*h
;
13413 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
13415 if (is_elf_hash_table (htab
)
13416 && htab
->hgot
!= NULL
)
13420 h
= elf_link_hash_lookup (htab
, ".TOC.", FALSE
, FALSE
, TRUE
);
13421 if (is_elf_hash_table (htab
))
13425 && h
->root
.type
== bfd_link_hash_defined
13426 && !h
->root
.linker_def
13427 && (!is_elf_hash_table (htab
)
13428 || h
->def_regular
))
13430 TOCstart
= (h
->root
.u
.def
.value
- TOC_BASE_OFF
13431 + h
->root
.u
.def
.section
->output_offset
13432 + h
->root
.u
.def
.section
->output_section
->vma
);
13433 _bfd_set_gp_value (obfd
, TOCstart
);
13438 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
13439 order. The TOC starts where the first of these sections starts. */
13440 s
= bfd_get_section_by_name (obfd
, ".got");
13441 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13442 s
= bfd_get_section_by_name (obfd
, ".toc");
13443 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13444 s
= bfd_get_section_by_name (obfd
, ".tocbss");
13445 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13446 s
= bfd_get_section_by_name (obfd
, ".plt");
13447 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13449 /* This may happen for
13450 o references to TOC base (SYM@toc / TOC[tc0]) without a
13452 o bad linker script
13453 o --gc-sections and empty TOC sections
13455 FIXME: Warn user? */
13457 /* Look for a likely section. We probably won't even be
13459 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13460 if ((s
->flags
& (SEC_ALLOC
| SEC_SMALL_DATA
| SEC_READONLY
13462 == (SEC_ALLOC
| SEC_SMALL_DATA
))
13465 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13466 if ((s
->flags
& (SEC_ALLOC
| SEC_SMALL_DATA
| SEC_EXCLUDE
))
13467 == (SEC_ALLOC
| SEC_SMALL_DATA
))
13470 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13471 if ((s
->flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_EXCLUDE
))
13475 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13476 if ((s
->flags
& (SEC_ALLOC
| SEC_EXCLUDE
)) == SEC_ALLOC
)
13482 TOCstart
= s
->output_section
->vma
+ s
->output_offset
;
13484 /* Force alignment. */
13485 adjust
= TOCstart
& (TOC_BASE_ALIGN
- 1);
13486 TOCstart
-= adjust
;
13487 _bfd_set_gp_value (obfd
, TOCstart
);
13489 if (info
!= NULL
&& s
!= NULL
)
13491 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
13495 if (htab
->elf
.hgot
!= NULL
)
13497 htab
->elf
.hgot
->root
.u
.def
.value
= TOC_BASE_OFF
- adjust
;
13498 htab
->elf
.hgot
->root
.u
.def
.section
= s
;
13503 struct bfd_link_hash_entry
*bh
= NULL
;
13504 _bfd_generic_link_add_one_symbol (info
, obfd
, ".TOC.", BSF_GLOBAL
,
13505 s
, TOC_BASE_OFF
- adjust
,
13506 NULL
, FALSE
, FALSE
, &bh
);
13512 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
13513 write out any global entry stubs, and PLT relocations. */
13516 build_global_entry_stubs_and_plt (struct elf_link_hash_entry
*h
, void *inf
)
13518 struct bfd_link_info
*info
;
13519 struct ppc_link_hash_table
*htab
;
13520 struct plt_entry
*ent
;
13523 if (h
->root
.type
== bfd_link_hash_indirect
)
13527 htab
= ppc_hash_table (info
);
13531 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
13532 if (ent
->plt
.offset
!= (bfd_vma
) -1)
13534 /* This symbol has an entry in the procedure linkage
13535 table. Set it up. */
13536 Elf_Internal_Rela rela
;
13537 asection
*plt
, *relplt
;
13540 if (!htab
->elf
.dynamic_sections_created
13541 || h
->dynindx
== -1)
13543 if (!(h
->def_regular
13544 && (h
->root
.type
== bfd_link_hash_defined
13545 || h
->root
.type
== bfd_link_hash_defweak
)))
13547 if (h
->type
== STT_GNU_IFUNC
)
13549 plt
= htab
->elf
.iplt
;
13550 relplt
= htab
->elf
.irelplt
;
13551 htab
->local_ifunc_resolver
= 1;
13553 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_IREL
);
13555 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
13559 plt
= htab
->pltlocal
;
13560 if (bfd_link_pic (info
))
13562 relplt
= htab
->relpltlocal
;
13564 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_SLOT
);
13566 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
13571 rela
.r_addend
= (h
->root
.u
.def
.value
13572 + h
->root
.u
.def
.section
->output_offset
13573 + h
->root
.u
.def
.section
->output_section
->vma
13576 if (relplt
== NULL
)
13578 loc
= plt
->contents
+ ent
->plt
.offset
;
13579 bfd_put_64 (info
->output_bfd
, rela
.r_addend
, loc
);
13582 bfd_vma toc
= elf_gp (info
->output_bfd
);
13583 toc
+= htab
->sec_info
[h
->root
.u
.def
.section
->id
].toc_off
;
13584 bfd_put_64 (info
->output_bfd
, toc
, loc
+ 8);
13589 rela
.r_offset
= (plt
->output_section
->vma
13590 + plt
->output_offset
13591 + ent
->plt
.offset
);
13592 loc
= relplt
->contents
+ (relplt
->reloc_count
++
13593 * sizeof (Elf64_External_Rela
));
13594 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rela
, loc
);
13599 rela
.r_offset
= (htab
->elf
.splt
->output_section
->vma
13600 + htab
->elf
.splt
->output_offset
13601 + ent
->plt
.offset
);
13602 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_PPC64_JMP_SLOT
);
13603 rela
.r_addend
= ent
->addend
;
13604 loc
= (htab
->elf
.srelplt
->contents
13605 + ((ent
->plt
.offset
- PLT_INITIAL_ENTRY_SIZE (htab
))
13606 / PLT_ENTRY_SIZE (htab
) * sizeof (Elf64_External_Rela
)));
13607 if (h
->type
== STT_GNU_IFUNC
&& is_static_defined (h
))
13608 htab
->maybe_local_ifunc_resolver
= 1;
13609 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rela
, loc
);
13613 if (!h
->pointer_equality_needed
)
13616 if (h
->def_regular
)
13619 s
= htab
->global_entry
;
13620 if (s
== NULL
|| s
->size
== 0)
13623 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
13624 if (ent
->plt
.offset
!= (bfd_vma
) -1
13625 && ent
->addend
== 0)
13631 p
= s
->contents
+ h
->root
.u
.def
.value
;
13632 plt
= htab
->elf
.splt
;
13633 if (!htab
->elf
.dynamic_sections_created
13634 || h
->dynindx
== -1)
13636 if (h
->type
== STT_GNU_IFUNC
)
13637 plt
= htab
->elf
.iplt
;
13639 plt
= htab
->pltlocal
;
13641 off
= ent
->plt
.offset
+ plt
->output_offset
+ plt
->output_section
->vma
;
13642 off
-= h
->root
.u
.def
.value
+ s
->output_offset
+ s
->output_section
->vma
;
13644 if (off
+ 0x80008000 > 0xffffffff || (off
& 3) != 0)
13646 info
->callbacks
->einfo
13647 (_("%P: linkage table error against `%pT'\n"),
13648 h
->root
.root
.string
);
13649 bfd_set_error (bfd_error_bad_value
);
13650 htab
->stub_error
= TRUE
;
13653 htab
->stub_count
[ppc_stub_global_entry
- 1] += 1;
13654 if (htab
->params
->emit_stub_syms
)
13656 size_t len
= strlen (h
->root
.root
.string
);
13657 char *name
= bfd_malloc (sizeof "12345678.global_entry." + len
);
13662 sprintf (name
, "%08x.global_entry.%s", s
->id
, h
->root
.root
.string
);
13663 h
= elf_link_hash_lookup (&htab
->elf
, name
, TRUE
, FALSE
, FALSE
);
13666 if (h
->root
.type
== bfd_link_hash_new
)
13668 h
->root
.type
= bfd_link_hash_defined
;
13669 h
->root
.u
.def
.section
= s
;
13670 h
->root
.u
.def
.value
= p
- s
->contents
;
13671 h
->ref_regular
= 1;
13672 h
->def_regular
= 1;
13673 h
->ref_regular_nonweak
= 1;
13674 h
->forced_local
= 1;
13676 h
->root
.linker_def
= 1;
13680 if (PPC_HA (off
) != 0)
13682 bfd_put_32 (s
->owner
, ADDIS_R12_R12
| PPC_HA (off
), p
);
13685 bfd_put_32 (s
->owner
, LD_R12_0R12
| PPC_LO (off
), p
);
13687 bfd_put_32 (s
->owner
, MTCTR_R12
, p
);
13689 bfd_put_32 (s
->owner
, BCTR
, p
);
13695 /* Write PLT relocs for locals. */
13698 write_plt_relocs_for_local_syms (struct bfd_link_info
*info
)
13700 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
13703 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
13705 struct got_entry
**lgot_ents
, **end_lgot_ents
;
13706 struct plt_entry
**local_plt
, **lplt
, **end_local_plt
;
13707 Elf_Internal_Shdr
*symtab_hdr
;
13708 bfd_size_type locsymcount
;
13709 Elf_Internal_Sym
*local_syms
= NULL
;
13710 struct plt_entry
*ent
;
13712 if (!is_ppc64_elf (ibfd
))
13715 lgot_ents
= elf_local_got_ents (ibfd
);
13719 symtab_hdr
= &elf_symtab_hdr (ibfd
);
13720 locsymcount
= symtab_hdr
->sh_info
;
13721 end_lgot_ents
= lgot_ents
+ locsymcount
;
13722 local_plt
= (struct plt_entry
**) end_lgot_ents
;
13723 end_local_plt
= local_plt
+ locsymcount
;
13724 for (lplt
= local_plt
; lplt
< end_local_plt
; ++lplt
)
13725 for (ent
= *lplt
; ent
!= NULL
; ent
= ent
->next
)
13726 if (ent
->plt
.offset
!= (bfd_vma
) -1)
13728 Elf_Internal_Sym
*sym
;
13730 asection
*plt
, *relplt
;
13734 if (!get_sym_h (NULL
, &sym
, &sym_sec
, NULL
, &local_syms
,
13735 lplt
- local_plt
, ibfd
))
13737 if (local_syms
!= NULL
13738 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
13743 val
= sym
->st_value
+ ent
->addend
;
13744 if (ELF_ST_TYPE (sym
->st_info
) != STT_GNU_IFUNC
)
13745 val
+= PPC64_LOCAL_ENTRY_OFFSET (sym
->st_other
);
13746 if (sym_sec
!= NULL
&& sym_sec
->output_section
!= NULL
)
13747 val
+= sym_sec
->output_offset
+ sym_sec
->output_section
->vma
;
13749 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
13751 htab
->local_ifunc_resolver
= 1;
13752 plt
= htab
->elf
.iplt
;
13753 relplt
= htab
->elf
.irelplt
;
13757 plt
= htab
->pltlocal
;
13758 relplt
= bfd_link_pic (info
) ? htab
->relpltlocal
: NULL
;
13761 if (relplt
== NULL
)
13763 loc
= plt
->contents
+ ent
->plt
.offset
;
13764 bfd_put_64 (info
->output_bfd
, val
, loc
);
13767 bfd_vma toc
= elf_gp (ibfd
);
13768 bfd_put_64 (info
->output_bfd
, toc
, loc
+ 8);
13773 Elf_Internal_Rela rela
;
13774 rela
.r_offset
= (ent
->plt
.offset
13775 + plt
->output_offset
13776 + plt
->output_section
->vma
);
13777 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
13780 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_IREL
);
13782 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
13787 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_SLOT
);
13789 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
13791 rela
.r_addend
= val
;
13792 loc
= relplt
->contents
+ (relplt
->reloc_count
++
13793 * sizeof (Elf64_External_Rela
));
13794 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rela
, loc
);
13798 if (local_syms
!= NULL
13799 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
13801 if (!info
->keep_memory
)
13804 symtab_hdr
->contents
= (unsigned char *) local_syms
;
13810 /* Build all the stubs associated with the current output file.
13811 The stubs are kept in a hash table attached to the main linker
13812 hash table. This function is called via gldelf64ppc_finish. */
13815 ppc64_elf_build_stubs (struct bfd_link_info
*info
,
13818 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
13819 struct map_stub
*group
;
13820 asection
*stub_sec
;
13822 int stub_sec_count
= 0;
13827 /* Allocate memory to hold the linker stubs. */
13828 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13830 group
->eh_size
= 0;
13831 group
->lr_restore
= 0;
13832 if ((stub_sec
= group
->stub_sec
) != NULL
13833 && stub_sec
->size
!= 0)
13835 stub_sec
->contents
= bfd_zalloc (htab
->params
->stub_bfd
,
13837 if (stub_sec
->contents
== NULL
)
13839 stub_sec
->size
= 0;
13843 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
13848 /* Build the .glink plt call stub. */
13849 if (htab
->params
->emit_stub_syms
)
13851 struct elf_link_hash_entry
*h
;
13852 h
= elf_link_hash_lookup (&htab
->elf
, "__glink_PLTresolve",
13853 TRUE
, FALSE
, FALSE
);
13856 if (h
->root
.type
== bfd_link_hash_new
)
13858 h
->root
.type
= bfd_link_hash_defined
;
13859 h
->root
.u
.def
.section
= htab
->glink
;
13860 h
->root
.u
.def
.value
= 8;
13861 h
->ref_regular
= 1;
13862 h
->def_regular
= 1;
13863 h
->ref_regular_nonweak
= 1;
13864 h
->forced_local
= 1;
13866 h
->root
.linker_def
= 1;
13869 plt0
= (htab
->elf
.splt
->output_section
->vma
13870 + htab
->elf
.splt
->output_offset
13872 if (info
->emitrelocations
)
13874 Elf_Internal_Rela
*r
= get_relocs (htab
->glink
, 1);
13877 r
->r_offset
= (htab
->glink
->output_offset
13878 + htab
->glink
->output_section
->vma
);
13879 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL64
);
13880 r
->r_addend
= plt0
;
13882 p
= htab
->glink
->contents
;
13883 plt0
-= htab
->glink
->output_section
->vma
+ htab
->glink
->output_offset
;
13884 bfd_put_64 (htab
->glink
->owner
, plt0
, p
);
13888 bfd_put_32 (htab
->glink
->owner
, MFLR_R12
, p
);
13890 bfd_put_32 (htab
->glink
->owner
, BCL_20_31
, p
);
13892 bfd_put_32 (htab
->glink
->owner
, MFLR_R11
, p
);
13894 bfd_put_32 (htab
->glink
->owner
, LD_R2_0R11
| (-16 & 0xfffc), p
);
13896 bfd_put_32 (htab
->glink
->owner
, MTLR_R12
, p
);
13898 bfd_put_32 (htab
->glink
->owner
, ADD_R11_R2_R11
, p
);
13900 bfd_put_32 (htab
->glink
->owner
, LD_R12_0R11
, p
);
13902 bfd_put_32 (htab
->glink
->owner
, LD_R2_0R11
| 8, p
);
13904 bfd_put_32 (htab
->glink
->owner
, MTCTR_R12
, p
);
13906 bfd_put_32 (htab
->glink
->owner
, LD_R11_0R11
| 16, p
);
13911 bfd_put_32 (htab
->glink
->owner
, MFLR_R0
, p
);
13913 bfd_put_32 (htab
->glink
->owner
, BCL_20_31
, p
);
13915 bfd_put_32 (htab
->glink
->owner
, MFLR_R11
, p
);
13917 bfd_put_32 (htab
->glink
->owner
, STD_R2_0R1
+ 24, p
);
13919 bfd_put_32 (htab
->glink
->owner
, LD_R2_0R11
| (-16 & 0xfffc), p
);
13921 bfd_put_32 (htab
->glink
->owner
, MTLR_R0
, p
);
13923 bfd_put_32 (htab
->glink
->owner
, SUB_R12_R12_R11
, p
);
13925 bfd_put_32 (htab
->glink
->owner
, ADD_R11_R2_R11
, p
);
13927 bfd_put_32 (htab
->glink
->owner
, ADDI_R0_R12
| (-48 & 0xffff), p
);
13929 bfd_put_32 (htab
->glink
->owner
, LD_R12_0R11
, p
);
13931 bfd_put_32 (htab
->glink
->owner
, SRDI_R0_R0_2
, p
);
13933 bfd_put_32 (htab
->glink
->owner
, MTCTR_R12
, p
);
13935 bfd_put_32 (htab
->glink
->owner
, LD_R11_0R11
| 8, p
);
13938 bfd_put_32 (htab
->glink
->owner
, BCTR
, p
);
13940 BFD_ASSERT (p
== htab
->glink
->contents
+ GLINK_PLTRESOLVE_SIZE (htab
));
13942 /* Build the .glink lazy link call stubs. */
13944 while (p
< htab
->glink
->contents
+ htab
->glink
->size
)
13950 bfd_put_32 (htab
->glink
->owner
, LI_R0_0
| indx
, p
);
13955 bfd_put_32 (htab
->glink
->owner
, LIS_R0_0
| PPC_HI (indx
), p
);
13957 bfd_put_32 (htab
->glink
->owner
, ORI_R0_R0_0
| PPC_LO (indx
),
13962 bfd_put_32 (htab
->glink
->owner
,
13963 B_DOT
| ((htab
->glink
->contents
- p
+ 8) & 0x3fffffc), p
);
13969 /* Build .glink global entry stubs, and PLT relocs for globals. */
13970 elf_link_hash_traverse (&htab
->elf
, build_global_entry_stubs_and_plt
, info
);
13972 if (!write_plt_relocs_for_local_syms (info
))
13975 if (htab
->brlt
!= NULL
&& htab
->brlt
->size
!= 0)
13977 htab
->brlt
->contents
= bfd_zalloc (htab
->brlt
->owner
,
13979 if (htab
->brlt
->contents
== NULL
)
13982 if (htab
->relbrlt
!= NULL
&& htab
->relbrlt
->size
!= 0)
13984 htab
->relbrlt
->contents
= bfd_zalloc (htab
->relbrlt
->owner
,
13985 htab
->relbrlt
->size
);
13986 if (htab
->relbrlt
->contents
== NULL
)
13990 /* Build the stubs as directed by the stub hash table. */
13991 bfd_hash_traverse (&htab
->stub_hash_table
, ppc_build_one_stub
, info
);
13993 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13994 if (group
->needs_save_res
)
13995 group
->stub_sec
->size
+= htab
->sfpr
->size
;
13997 if (htab
->relbrlt
!= NULL
)
13998 htab
->relbrlt
->reloc_count
= 0;
14000 if (htab
->params
->plt_stub_align
!= 0)
14001 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14002 if ((stub_sec
= group
->stub_sec
) != NULL
)
14004 int align
= abs (htab
->params
->plt_stub_align
);
14005 stub_sec
->size
= (stub_sec
->size
+ (1 << align
) - 1) & -(1 << align
);
14008 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14009 if (group
->needs_save_res
)
14011 stub_sec
= group
->stub_sec
;
14012 memcpy (stub_sec
->contents
+ stub_sec
->size
- htab
->sfpr
->size
,
14013 htab
->sfpr
->contents
, htab
->sfpr
->size
);
14014 if (htab
->params
->emit_stub_syms
)
14018 for (i
= 0; i
< ARRAY_SIZE (save_res_funcs
); i
++)
14019 if (!sfpr_define (info
, &save_res_funcs
[i
], stub_sec
))
14024 if (htab
->glink_eh_frame
!= NULL
14025 && htab
->glink_eh_frame
->size
!= 0)
14030 p
= htab
->glink_eh_frame
->contents
;
14031 p
+= (sizeof (glink_eh_frame_cie
) + align
- 1) & -align
;
14033 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14034 if (group
->eh_size
!= 0)
14036 /* Offset to stub section. */
14037 val
= (group
->stub_sec
->output_section
->vma
14038 + group
->stub_sec
->output_offset
);
14039 val
-= (htab
->glink_eh_frame
->output_section
->vma
14040 + htab
->glink_eh_frame
->output_offset
14041 + (p
+ 8 - htab
->glink_eh_frame
->contents
));
14042 if (val
+ 0x80000000 > 0xffffffff)
14045 (_("%s offset too large for .eh_frame sdata4 encoding"),
14046 group
->stub_sec
->name
);
14049 bfd_put_32 (htab
->elf
.dynobj
, val
, p
+ 8);
14050 p
+= (group
->eh_size
+ 17 + 3) & -4;
14052 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
14054 /* Offset to .glink. */
14055 val
= (htab
->glink
->output_section
->vma
14056 + htab
->glink
->output_offset
14058 val
-= (htab
->glink_eh_frame
->output_section
->vma
14059 + htab
->glink_eh_frame
->output_offset
14060 + (p
+ 8 - htab
->glink_eh_frame
->contents
));
14061 if (val
+ 0x80000000 > 0xffffffff)
14064 (_("%s offset too large for .eh_frame sdata4 encoding"),
14065 htab
->glink
->name
);
14068 bfd_put_32 (htab
->elf
.dynobj
, val
, p
+ 8);
14069 p
+= (24 + align
- 1) & -align
;
14073 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14074 if ((stub_sec
= group
->stub_sec
) != NULL
)
14076 stub_sec_count
+= 1;
14077 if (stub_sec
->rawsize
!= stub_sec
->size
14078 && (htab
->stub_iteration
<= STUB_SHRINK_ITER
14079 || stub_sec
->rawsize
< stub_sec
->size
))
14085 htab
->stub_error
= TRUE
;
14086 _bfd_error_handler (_("stubs don't match calculated size"));
14089 if (htab
->stub_error
)
14095 *stats
= bfd_malloc (500);
14096 if (*stats
== NULL
)
14099 len
= sprintf (*stats
,
14100 ngettext ("linker stubs in %u group\n",
14101 "linker stubs in %u groups\n",
14104 sprintf (*stats
+ len
, _(" branch %lu\n"
14105 " branch toc adj %lu\n"
14106 " branch notoc %lu\n"
14107 " branch both %lu\n"
14108 " long branch %lu\n"
14109 " long toc adj %lu\n"
14110 " long notoc %lu\n"
14113 " plt call save %lu\n"
14114 " plt call notoc %lu\n"
14115 " plt call both %lu\n"
14116 " global entry %lu"),
14117 htab
->stub_count
[ppc_stub_long_branch
- 1],
14118 htab
->stub_count
[ppc_stub_long_branch_r2off
- 1],
14119 htab
->stub_count
[ppc_stub_long_branch_notoc
- 1],
14120 htab
->stub_count
[ppc_stub_long_branch_both
- 1],
14121 htab
->stub_count
[ppc_stub_plt_branch
- 1],
14122 htab
->stub_count
[ppc_stub_plt_branch_r2off
- 1],
14123 htab
->stub_count
[ppc_stub_plt_branch_notoc
- 1],
14124 htab
->stub_count
[ppc_stub_plt_branch_both
- 1],
14125 htab
->stub_count
[ppc_stub_plt_call
- 1],
14126 htab
->stub_count
[ppc_stub_plt_call_r2save
- 1],
14127 htab
->stub_count
[ppc_stub_plt_call_notoc
- 1],
14128 htab
->stub_count
[ppc_stub_plt_call_both
- 1],
14129 htab
->stub_count
[ppc_stub_global_entry
- 1]);
14134 /* What to do when ld finds relocations against symbols defined in
14135 discarded sections. */
14137 static unsigned int
14138 ppc64_elf_action_discarded (asection
*sec
)
14140 if (strcmp (".opd", sec
->name
) == 0)
14143 if (strcmp (".toc", sec
->name
) == 0)
14146 if (strcmp (".toc1", sec
->name
) == 0)
14149 return _bfd_elf_default_action_discarded (sec
);
14152 /* These are the dynamic relocations supported by glibc. */
14155 ppc64_glibc_dynamic_reloc (enum elf_ppc64_reloc_type r_type
)
14159 case R_PPC64_RELATIVE
:
14161 case R_PPC64_ADDR64
:
14162 case R_PPC64_GLOB_DAT
:
14163 case R_PPC64_IRELATIVE
:
14164 case R_PPC64_JMP_IREL
:
14165 case R_PPC64_JMP_SLOT
:
14166 case R_PPC64_DTPMOD64
:
14167 case R_PPC64_DTPREL64
:
14168 case R_PPC64_TPREL64
:
14169 case R_PPC64_TPREL16_LO_DS
:
14170 case R_PPC64_TPREL16_DS
:
14171 case R_PPC64_TPREL16
:
14172 case R_PPC64_TPREL16_LO
:
14173 case R_PPC64_TPREL16_HI
:
14174 case R_PPC64_TPREL16_HIGH
:
14175 case R_PPC64_TPREL16_HA
:
14176 case R_PPC64_TPREL16_HIGHA
:
14177 case R_PPC64_TPREL16_HIGHER
:
14178 case R_PPC64_TPREL16_HIGHEST
:
14179 case R_PPC64_TPREL16_HIGHERA
:
14180 case R_PPC64_TPREL16_HIGHESTA
:
14181 case R_PPC64_ADDR16_LO_DS
:
14182 case R_PPC64_ADDR16_LO
:
14183 case R_PPC64_ADDR16_HI
:
14184 case R_PPC64_ADDR16_HIGH
:
14185 case R_PPC64_ADDR16_HA
:
14186 case R_PPC64_ADDR16_HIGHA
:
14187 case R_PPC64_REL30
:
14189 case R_PPC64_UADDR64
:
14190 case R_PPC64_UADDR32
:
14191 case R_PPC64_ADDR32
:
14192 case R_PPC64_ADDR24
:
14193 case R_PPC64_ADDR16
:
14194 case R_PPC64_UADDR16
:
14195 case R_PPC64_ADDR16_DS
:
14196 case R_PPC64_ADDR16_HIGHER
:
14197 case R_PPC64_ADDR16_HIGHEST
:
14198 case R_PPC64_ADDR16_HIGHERA
:
14199 case R_PPC64_ADDR16_HIGHESTA
:
14200 case R_PPC64_ADDR14
:
14201 case R_PPC64_ADDR14_BRTAKEN
:
14202 case R_PPC64_ADDR14_BRNTAKEN
:
14203 case R_PPC64_REL32
:
14204 case R_PPC64_REL64
:
14212 /* The RELOCATE_SECTION function is called by the ELF backend linker
14213 to handle the relocations for a section.
14215 The relocs are always passed as Rela structures; if the section
14216 actually uses Rel structures, the r_addend field will always be
14219 This function is responsible for adjust the section contents as
14220 necessary, and (if using Rela relocs and generating a
14221 relocatable output file) adjusting the reloc addend as
14224 This function does not have to worry about setting the reloc
14225 address or the reloc symbol index.
14227 LOCAL_SYMS is a pointer to the swapped in local symbols.
14229 LOCAL_SECTIONS is an array giving the section in the input file
14230 corresponding to the st_shndx field of each local symbol.
14232 The global hash table entry for the global symbols can be found
14233 via elf_sym_hashes (input_bfd).
14235 When generating relocatable output, this function must handle
14236 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
14237 going to be the section symbol corresponding to the output
14238 section, which means that the addend must be adjusted
14242 ppc64_elf_relocate_section (bfd
*output_bfd
,
14243 struct bfd_link_info
*info
,
14245 asection
*input_section
,
14246 bfd_byte
*contents
,
14247 Elf_Internal_Rela
*relocs
,
14248 Elf_Internal_Sym
*local_syms
,
14249 asection
**local_sections
)
14251 struct ppc_link_hash_table
*htab
;
14252 Elf_Internal_Shdr
*symtab_hdr
;
14253 struct elf_link_hash_entry
**sym_hashes
;
14254 Elf_Internal_Rela
*rel
;
14255 Elf_Internal_Rela
*wrel
;
14256 Elf_Internal_Rela
*relend
;
14257 Elf_Internal_Rela outrel
;
14259 struct got_entry
**local_got_ents
;
14261 bfd_boolean ret
= TRUE
;
14262 bfd_boolean is_opd
;
14263 /* Assume 'at' branch hints. */
14264 bfd_boolean is_isa_v2
= TRUE
;
14265 bfd_boolean warned_dynamic
= FALSE
;
14266 bfd_vma d_offset
= (bfd_big_endian (input_bfd
) ? 2 : 0);
14268 /* Initialize howto table if needed. */
14269 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
14272 htab
= ppc_hash_table (info
);
14276 /* Don't relocate stub sections. */
14277 if (input_section
->owner
== htab
->params
->stub_bfd
)
14280 if (!is_ppc64_elf (input_bfd
))
14282 bfd_set_error (bfd_error_wrong_format
);
14286 local_got_ents
= elf_local_got_ents (input_bfd
);
14287 TOCstart
= elf_gp (output_bfd
);
14288 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
14289 sym_hashes
= elf_sym_hashes (input_bfd
);
14290 is_opd
= ppc64_elf_section_data (input_section
)->sec_type
== sec_opd
;
14292 rel
= wrel
= relocs
;
14293 relend
= relocs
+ input_section
->reloc_count
;
14294 for (; rel
< relend
; wrel
++, rel
++)
14296 enum elf_ppc64_reloc_type r_type
;
14298 bfd_reloc_status_type r
;
14299 Elf_Internal_Sym
*sym
;
14301 struct elf_link_hash_entry
*h_elf
;
14302 struct ppc_link_hash_entry
*h
;
14303 struct ppc_link_hash_entry
*fdh
;
14304 const char *sym_name
;
14305 unsigned long r_symndx
, toc_symndx
;
14306 bfd_vma toc_addend
;
14307 unsigned char tls_mask
, tls_gd
, tls_type
;
14308 unsigned char sym_type
;
14309 bfd_vma relocation
;
14310 bfd_boolean unresolved_reloc
, save_unresolved_reloc
;
14311 bfd_boolean warned
;
14312 enum { DEST_NORMAL
, DEST_OPD
, DEST_STUB
} reloc_dest
;
14315 struct ppc_stub_hash_entry
*stub_entry
;
14316 bfd_vma max_br_offset
;
14318 Elf_Internal_Rela orig_rel
;
14319 reloc_howto_type
*howto
;
14320 struct reloc_howto_struct alt_howto
;
14327 r_type
= ELF64_R_TYPE (rel
->r_info
);
14328 r_symndx
= ELF64_R_SYM (rel
->r_info
);
14330 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
14331 symbol of the previous ADDR64 reloc. The symbol gives us the
14332 proper TOC base to use. */
14333 if (rel
->r_info
== ELF64_R_INFO (0, R_PPC64_TOC
)
14335 && ELF64_R_TYPE (wrel
[-1].r_info
) == R_PPC64_ADDR64
14337 r_symndx
= ELF64_R_SYM (wrel
[-1].r_info
);
14343 unresolved_reloc
= FALSE
;
14346 if (r_symndx
< symtab_hdr
->sh_info
)
14348 /* It's a local symbol. */
14349 struct _opd_sec_data
*opd
;
14351 sym
= local_syms
+ r_symndx
;
14352 sec
= local_sections
[r_symndx
];
14353 sym_name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
, sec
);
14354 sym_type
= ELF64_ST_TYPE (sym
->st_info
);
14355 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
14356 opd
= get_opd_info (sec
);
14357 if (opd
!= NULL
&& opd
->adjust
!= NULL
)
14359 long adjust
= opd
->adjust
[OPD_NDX (sym
->st_value
14365 /* If this is a relocation against the opd section sym
14366 and we have edited .opd, adjust the reloc addend so
14367 that ld -r and ld --emit-relocs output is correct.
14368 If it is a reloc against some other .opd symbol,
14369 then the symbol value will be adjusted later. */
14370 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
14371 rel
->r_addend
+= adjust
;
14373 relocation
+= adjust
;
14379 bfd_boolean ignored
;
14381 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
14382 r_symndx
, symtab_hdr
, sym_hashes
,
14383 h_elf
, sec
, relocation
,
14384 unresolved_reloc
, warned
, ignored
);
14385 sym_name
= h_elf
->root
.root
.string
;
14386 sym_type
= h_elf
->type
;
14388 && sec
->owner
== output_bfd
14389 && strcmp (sec
->name
, ".opd") == 0)
14391 /* This is a symbol defined in a linker script. All
14392 such are defined in output sections, even those
14393 defined by simple assignment from a symbol defined in
14394 an input section. Transfer the symbol to an
14395 appropriate input .opd section, so that a branch to
14396 this symbol will be mapped to the location specified
14397 by the opd entry. */
14398 struct bfd_link_order
*lo
;
14399 for (lo
= sec
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
14400 if (lo
->type
== bfd_indirect_link_order
)
14402 asection
*isec
= lo
->u
.indirect
.section
;
14403 if (h_elf
->root
.u
.def
.value
>= isec
->output_offset
14404 && h_elf
->root
.u
.def
.value
< (isec
->output_offset
14407 h_elf
->root
.u
.def
.value
-= isec
->output_offset
;
14408 h_elf
->root
.u
.def
.section
= isec
;
14415 h
= (struct ppc_link_hash_entry
*) h_elf
;
14417 if (sec
!= NULL
&& discarded_section (sec
))
14419 _bfd_clear_contents (ppc64_elf_howto_table
[r_type
],
14420 input_bfd
, input_section
,
14421 contents
, rel
->r_offset
);
14422 wrel
->r_offset
= rel
->r_offset
;
14424 wrel
->r_addend
= 0;
14426 /* For ld -r, remove relocations in debug sections against
14427 symbols defined in discarded sections. Not done for
14428 non-debug to preserve relocs in .eh_frame which the
14429 eh_frame editing code expects to be present. */
14430 if (bfd_link_relocatable (info
)
14431 && (input_section
->flags
& SEC_DEBUGGING
))
14437 if (bfd_link_relocatable (info
))
14440 if (h
!= NULL
&& &h
->elf
== htab
->elf
.hgot
)
14442 relocation
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
14443 sec
= bfd_abs_section_ptr
;
14444 unresolved_reloc
= FALSE
;
14447 /* TLS optimizations. Replace instruction sequences and relocs
14448 based on information we collected in tls_optimize. We edit
14449 RELOCS so that --emit-relocs will output something sensible
14450 for the final instruction stream. */
14455 tls_mask
= h
->tls_mask
;
14456 else if (local_got_ents
!= NULL
)
14458 struct plt_entry
**local_plt
= (struct plt_entry
**)
14459 (local_got_ents
+ symtab_hdr
->sh_info
);
14460 unsigned char *lgot_masks
= (unsigned char *)
14461 (local_plt
+ symtab_hdr
->sh_info
);
14462 tls_mask
= lgot_masks
[r_symndx
];
14464 if (((tls_mask
& TLS_TLS
) == 0 || tls_mask
== (TLS_TLS
| TLS_MARK
))
14465 && (r_type
== R_PPC64_TLS
14466 || r_type
== R_PPC64_TLSGD
14467 || r_type
== R_PPC64_TLSLD
))
14469 /* Check for toc tls entries. */
14470 unsigned char *toc_tls
;
14472 if (!get_tls_mask (&toc_tls
, &toc_symndx
, &toc_addend
,
14473 &local_syms
, rel
, input_bfd
))
14477 tls_mask
= *toc_tls
;
14480 /* Check that tls relocs are used with tls syms, and non-tls
14481 relocs are used with non-tls syms. */
14482 if (r_symndx
!= STN_UNDEF
14483 && r_type
!= R_PPC64_NONE
14485 || h
->elf
.root
.type
== bfd_link_hash_defined
14486 || h
->elf
.root
.type
== bfd_link_hash_defweak
)
14487 && IS_PPC64_TLS_RELOC (r_type
) != (sym_type
== STT_TLS
))
14489 if ((tls_mask
& TLS_TLS
) != 0
14490 && (r_type
== R_PPC64_TLS
14491 || r_type
== R_PPC64_TLSGD
14492 || r_type
== R_PPC64_TLSLD
))
14493 /* R_PPC64_TLS is OK against a symbol in the TOC. */
14496 info
->callbacks
->einfo
14497 (!IS_PPC64_TLS_RELOC (r_type
)
14498 /* xgettext:c-format */
14499 ? _("%H: %s used with TLS symbol `%pT'\n")
14500 /* xgettext:c-format */
14501 : _("%H: %s used with non-TLS symbol `%pT'\n"),
14502 input_bfd
, input_section
, rel
->r_offset
,
14503 ppc64_elf_howto_table
[r_type
]->name
,
14507 /* Ensure reloc mapping code below stays sane. */
14508 if (R_PPC64_TOC16_LO_DS
!= R_PPC64_TOC16_DS
+ 1
14509 || R_PPC64_TOC16_LO
!= R_PPC64_TOC16
+ 1
14510 || (R_PPC64_GOT_TLSLD16
& 3) != (R_PPC64_GOT_TLSGD16
& 3)
14511 || (R_PPC64_GOT_TLSLD16_LO
& 3) != (R_PPC64_GOT_TLSGD16_LO
& 3)
14512 || (R_PPC64_GOT_TLSLD16_HI
& 3) != (R_PPC64_GOT_TLSGD16_HI
& 3)
14513 || (R_PPC64_GOT_TLSLD16_HA
& 3) != (R_PPC64_GOT_TLSGD16_HA
& 3)
14514 || (R_PPC64_GOT_TLSLD16
& 3) != (R_PPC64_GOT_TPREL16_DS
& 3)
14515 || (R_PPC64_GOT_TLSLD16_LO
& 3) != (R_PPC64_GOT_TPREL16_LO_DS
& 3)
14516 || (R_PPC64_GOT_TLSLD16_HI
& 3) != (R_PPC64_GOT_TPREL16_HI
& 3)
14517 || (R_PPC64_GOT_TLSLD16_HA
& 3) != (R_PPC64_GOT_TPREL16_HA
& 3))
14525 case R_PPC64_LO_DS_OPT
:
14526 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
- d_offset
);
14527 if ((insn
& (0x3f << 26)) != 58u << 26)
14529 insn
+= (14u << 26) - (58u << 26);
14530 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
- d_offset
);
14531 r_type
= R_PPC64_TOC16_LO
;
14532 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14535 case R_PPC64_TOC16
:
14536 case R_PPC64_TOC16_LO
:
14537 case R_PPC64_TOC16_DS
:
14538 case R_PPC64_TOC16_LO_DS
:
14540 /* Check for toc tls entries. */
14541 unsigned char *toc_tls
;
14544 retval
= get_tls_mask (&toc_tls
, &toc_symndx
, &toc_addend
,
14545 &local_syms
, rel
, input_bfd
);
14551 tls_mask
= *toc_tls
;
14552 if (r_type
== R_PPC64_TOC16_DS
14553 || r_type
== R_PPC64_TOC16_LO_DS
)
14555 if ((tls_mask
& TLS_TLS
) != 0
14556 && (tls_mask
& (TLS_DTPREL
| TLS_TPREL
)) == 0)
14561 /* If we found a GD reloc pair, then we might be
14562 doing a GD->IE transition. */
14566 if ((tls_mask
& TLS_TLS
) != 0
14567 && (tls_mask
& TLS_GD
) == 0)
14570 else if (retval
== 3)
14572 if ((tls_mask
& TLS_TLS
) != 0
14573 && (tls_mask
& TLS_LD
) == 0)
14581 case R_PPC64_GOT_TPREL16_HI
:
14582 case R_PPC64_GOT_TPREL16_HA
:
14583 if ((tls_mask
& TLS_TLS
) != 0
14584 && (tls_mask
& TLS_TPREL
) == 0)
14586 rel
->r_offset
-= d_offset
;
14587 bfd_put_32 (input_bfd
, NOP
, contents
+ rel
->r_offset
);
14588 r_type
= R_PPC64_NONE
;
14589 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14593 case R_PPC64_GOT_TPREL16_DS
:
14594 case R_PPC64_GOT_TPREL16_LO_DS
:
14595 if ((tls_mask
& TLS_TLS
) != 0
14596 && (tls_mask
& TLS_TPREL
) == 0)
14599 insn
= bfd_get_32 (input_bfd
,
14600 contents
+ rel
->r_offset
- d_offset
);
14602 insn
|= 0x3c0d0000; /* addis 0,13,0 */
14603 bfd_put_32 (input_bfd
, insn
,
14604 contents
+ rel
->r_offset
- d_offset
);
14605 r_type
= R_PPC64_TPREL16_HA
;
14606 if (toc_symndx
!= 0)
14608 rel
->r_info
= ELF64_R_INFO (toc_symndx
, r_type
);
14609 rel
->r_addend
= toc_addend
;
14610 /* We changed the symbol. Start over in order to
14611 get h, sym, sec etc. right. */
14615 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14619 case R_PPC64_GOT_TPREL34
:
14620 if ((tls_mask
& TLS_TLS
) != 0
14621 && (tls_mask
& TLS_TPREL
) == 0)
14623 /* pld ra,sym@got@tprel@pcrel -> paddi ra,r13,sym@tprel */
14624 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
14626 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
14627 pinsn
+= ((2ULL << 56) + (-1ULL << 52)
14628 + (14ULL << 26) - (57ULL << 26) + (13ULL << 16));
14629 bfd_put_32 (input_bfd
, pinsn
>> 32,
14630 contents
+ rel
->r_offset
);
14631 bfd_put_32 (input_bfd
, pinsn
& 0xffffffff,
14632 contents
+ rel
->r_offset
+ 4);
14633 r_type
= R_PPC64_TPREL34
;
14634 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14639 if ((tls_mask
& TLS_TLS
) != 0
14640 && (tls_mask
& TLS_TPREL
) == 0)
14642 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
14643 insn
= _bfd_elf_ppc_at_tls_transform (insn
, 13);
14646 if ((rel
->r_offset
& 3) == 0)
14648 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
14649 /* Was PPC64_TLS which sits on insn boundary, now
14650 PPC64_TPREL16_LO which is at low-order half-word. */
14651 rel
->r_offset
+= d_offset
;
14652 r_type
= R_PPC64_TPREL16_LO
;
14653 if (toc_symndx
!= 0)
14655 rel
->r_info
= ELF64_R_INFO (toc_symndx
, r_type
);
14656 rel
->r_addend
= toc_addend
;
14657 /* We changed the symbol. Start over in order to
14658 get h, sym, sec etc. right. */
14662 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14664 else if ((rel
->r_offset
& 3) == 1)
14666 /* For pcrel IE to LE we already have the full
14667 offset and thus don't need an addi here. A nop
14669 if ((insn
& (0x3f << 26)) == 14 << 26)
14671 /* Extract regs from addi rt,ra,si. */
14672 unsigned int rt
= (insn
>> 21) & 0x1f;
14673 unsigned int ra
= (insn
>> 16) & 0x1f;
14678 /* Build or ra,rs,rb with rb==rs, ie. mr ra,rs. */
14679 insn
= (rt
<< 16) | (ra
<< 21) | (ra
<< 11);
14680 insn
|= (31u << 26) | (444u << 1);
14683 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
- 1);
14688 case R_PPC64_GOT_TLSGD16_HI
:
14689 case R_PPC64_GOT_TLSGD16_HA
:
14691 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0)
14695 case R_PPC64_GOT_TLSLD16_HI
:
14696 case R_PPC64_GOT_TLSLD16_HA
:
14697 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0)
14700 if ((tls_mask
& tls_gd
) != 0)
14701 r_type
= (((r_type
- (R_PPC64_GOT_TLSGD16
& 3)) & 3)
14702 + R_PPC64_GOT_TPREL16_DS
);
14705 rel
->r_offset
-= d_offset
;
14706 bfd_put_32 (input_bfd
, NOP
, contents
+ rel
->r_offset
);
14707 r_type
= R_PPC64_NONE
;
14709 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14713 case R_PPC64_GOT_TLSGD16
:
14714 case R_PPC64_GOT_TLSGD16_LO
:
14716 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0)
14720 case R_PPC64_GOT_TLSLD16
:
14721 case R_PPC64_GOT_TLSLD16_LO
:
14722 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0)
14724 unsigned int insn1
, insn2
;
14727 offset
= (bfd_vma
) -1;
14728 /* If not using the newer R_PPC64_TLSGD/LD to mark
14729 __tls_get_addr calls, we must trust that the call
14730 stays with its arg setup insns, ie. that the next
14731 reloc is the __tls_get_addr call associated with
14732 the current reloc. Edit both insns. */
14733 if (input_section
->has_tls_get_addr_call
14734 && rel
+ 1 < relend
14735 && branch_reloc_hash_match (input_bfd
, rel
+ 1,
14736 htab
->tls_get_addr
,
14737 htab
->tls_get_addr_fd
))
14738 offset
= rel
[1].r_offset
;
14739 /* We read the low GOT_TLS (or TOC16) insn because we
14740 need to keep the destination reg. It may be
14741 something other than the usual r3, and moved to r3
14742 before the call by intervening code. */
14743 insn1
= bfd_get_32 (input_bfd
,
14744 contents
+ rel
->r_offset
- d_offset
);
14745 if ((tls_mask
& tls_gd
) != 0)
14748 insn1
&= (0x1f << 21) | (0x1f << 16);
14749 insn1
|= 58 << 26; /* ld */
14750 insn2
= 0x7c636a14; /* add 3,3,13 */
14751 if (offset
!= (bfd_vma
) -1)
14752 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
14753 if (r_type
== R_PPC64_TOC16
14754 || r_type
== R_PPC64_TOC16_LO
)
14755 r_type
+= R_PPC64_TOC16_DS
- R_PPC64_TOC16
;
14757 r_type
= (((r_type
- (R_PPC64_GOT_TLSGD16
& 1)) & 1)
14758 + R_PPC64_GOT_TPREL16_DS
);
14759 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14764 insn1
&= 0x1f << 21;
14765 insn1
|= 0x3c0d0000; /* addis r,13,0 */
14766 insn2
= 0x38630000; /* addi 3,3,0 */
14769 /* Was an LD reloc. */
14770 r_symndx
= STN_UNDEF
;
14771 rel
->r_addend
= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
14773 else if (toc_symndx
!= 0)
14775 r_symndx
= toc_symndx
;
14776 rel
->r_addend
= toc_addend
;
14778 r_type
= R_PPC64_TPREL16_HA
;
14779 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14780 if (offset
!= (bfd_vma
) -1)
14782 rel
[1].r_info
= ELF64_R_INFO (r_symndx
,
14783 R_PPC64_TPREL16_LO
);
14784 rel
[1].r_offset
= offset
+ d_offset
;
14785 rel
[1].r_addend
= rel
->r_addend
;
14788 bfd_put_32 (input_bfd
, insn1
,
14789 contents
+ rel
->r_offset
- d_offset
);
14790 if (offset
!= (bfd_vma
) -1)
14792 bfd_put_32 (input_bfd
, insn2
, contents
+ offset
);
14793 if (offset
+ 8 <= input_section
->size
)
14795 insn2
= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
14796 if (insn2
== LD_R2_0R1
+ STK_TOC (htab
))
14797 bfd_put_32 (input_bfd
, NOP
, contents
+ offset
+ 4);
14800 if ((tls_mask
& tls_gd
) == 0
14801 && (tls_gd
== 0 || toc_symndx
!= 0))
14803 /* We changed the symbol. Start over in order
14804 to get h, sym, sec etc. right. */
14810 case R_PPC64_GOT_TLSGD34
:
14811 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0)
14813 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
14815 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
14816 if ((tls_mask
& TLS_GDIE
) != 0)
14818 /* IE, pla -> pld */
14819 pinsn
+= (-2ULL << 56) + (57ULL << 26) - (14ULL << 26);
14820 r_type
= R_PPC64_GOT_TPREL34
;
14824 /* LE, pla pcrel -> paddi r13 */
14825 pinsn
+= (-1ULL << 52) + (13ULL << 16);
14826 r_type
= R_PPC64_TPREL34
;
14828 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14829 bfd_put_32 (input_bfd
, pinsn
>> 32,
14830 contents
+ rel
->r_offset
);
14831 bfd_put_32 (input_bfd
, pinsn
& 0xffffffff,
14832 contents
+ rel
->r_offset
+ 4);
14836 case R_PPC64_GOT_TLSLD34
:
14837 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0)
14839 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
14841 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
14842 pinsn
+= (-1ULL << 52) + (13ULL << 16);
14843 bfd_put_32 (input_bfd
, pinsn
>> 32,
14844 contents
+ rel
->r_offset
);
14845 bfd_put_32 (input_bfd
, pinsn
& 0xffffffff,
14846 contents
+ rel
->r_offset
+ 4);
14847 rel
->r_addend
= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
14848 r_symndx
= STN_UNDEF
;
14849 r_type
= R_PPC64_TPREL34
;
14850 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14855 case R_PPC64_TLSGD
:
14856 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0
14857 && rel
+ 1 < relend
)
14859 unsigned int insn2
;
14860 enum elf_ppc64_reloc_type r_type1
= ELF64_R_TYPE (rel
[1].r_info
);
14862 offset
= rel
->r_offset
;
14863 if (is_plt_seq_reloc (r_type1
))
14865 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
);
14866 if (r_type1
== R_PPC64_PLT_PCREL34
14867 || r_type1
== R_PPC64_PLT_PCREL34_NOTOC
)
14868 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
14869 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
14873 if (ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_PLTCALL
)
14874 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
14876 if ((tls_mask
& TLS_GDIE
) != 0)
14879 r_type
= R_PPC64_NONE
;
14880 insn2
= 0x7c636a14; /* add 3,3,13 */
14885 if (toc_symndx
!= 0)
14887 r_symndx
= toc_symndx
;
14888 rel
->r_addend
= toc_addend
;
14890 if (r_type1
== R_PPC64_REL24_NOTOC
14891 || r_type1
== R_PPC64_PLTCALL_NOTOC
)
14893 r_type
= R_PPC64_NONE
;
14898 rel
->r_offset
= offset
+ d_offset
;
14899 r_type
= R_PPC64_TPREL16_LO
;
14900 insn2
= 0x38630000; /* addi 3,3,0 */
14903 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14904 /* Zap the reloc on the _tls_get_addr call too. */
14905 BFD_ASSERT (offset
== rel
[1].r_offset
);
14906 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
14907 bfd_put_32 (input_bfd
, insn2
, contents
+ offset
);
14908 if ((tls_mask
& TLS_GDIE
) == 0
14910 && r_type
!= R_PPC64_NONE
)
14915 case R_PPC64_TLSLD
:
14916 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0
14917 && rel
+ 1 < relend
)
14919 unsigned int insn2
;
14920 enum elf_ppc64_reloc_type r_type1
= ELF64_R_TYPE (rel
[1].r_info
);
14922 offset
= rel
->r_offset
;
14923 if (is_plt_seq_reloc (r_type1
))
14925 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
);
14926 if (r_type1
== R_PPC64_PLT_PCREL34
14927 || r_type1
== R_PPC64_PLT_PCREL34_NOTOC
)
14928 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
14929 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
14933 if (ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_PLTCALL
)
14934 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
14936 if (r_type1
== R_PPC64_REL24_NOTOC
14937 || r_type1
== R_PPC64_PLTCALL_NOTOC
)
14939 r_type
= R_PPC64_NONE
;
14944 rel
->r_offset
= offset
+ d_offset
;
14945 r_symndx
= STN_UNDEF
;
14946 r_type
= R_PPC64_TPREL16_LO
;
14947 rel
->r_addend
= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
14948 insn2
= 0x38630000; /* addi 3,3,0 */
14950 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14951 /* Zap the reloc on the _tls_get_addr call too. */
14952 BFD_ASSERT (offset
== rel
[1].r_offset
);
14953 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
14954 bfd_put_32 (input_bfd
, insn2
, contents
+ offset
);
14955 if (r_type
!= R_PPC64_NONE
)
14960 case R_PPC64_DTPMOD64
:
14961 if (rel
+ 1 < relend
14962 && rel
[1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_DTPREL64
)
14963 && rel
[1].r_offset
== rel
->r_offset
+ 8)
14965 if ((tls_mask
& TLS_GD
) == 0)
14967 rel
[1].r_info
= ELF64_R_INFO (r_symndx
, R_PPC64_NONE
);
14968 if ((tls_mask
& TLS_GDIE
) != 0)
14969 r_type
= R_PPC64_TPREL64
;
14972 bfd_put_64 (output_bfd
, 1, contents
+ rel
->r_offset
);
14973 r_type
= R_PPC64_NONE
;
14975 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14980 if ((tls_mask
& TLS_LD
) == 0)
14982 bfd_put_64 (output_bfd
, 1, contents
+ rel
->r_offset
);
14983 r_type
= R_PPC64_NONE
;
14984 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14989 case R_PPC64_TPREL64
:
14990 if ((tls_mask
& TLS_TPREL
) == 0)
14992 r_type
= R_PPC64_NONE
;
14993 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14997 case R_PPC64_ENTRY
:
14998 relocation
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
14999 if (!bfd_link_pic (info
)
15000 && !info
->traditional_format
15001 && relocation
+ 0x80008000 <= 0xffffffff)
15003 unsigned int insn1
, insn2
;
15005 insn1
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15006 insn2
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15007 if ((insn1
& ~0xfffc) == LD_R2_0R12
15008 && insn2
== ADD_R2_R2_R12
)
15010 bfd_put_32 (input_bfd
,
15011 LIS_R2
+ PPC_HA (relocation
),
15012 contents
+ rel
->r_offset
);
15013 bfd_put_32 (input_bfd
,
15014 ADDI_R2_R2
+ PPC_LO (relocation
),
15015 contents
+ rel
->r_offset
+ 4);
15020 relocation
-= (rel
->r_offset
15021 + input_section
->output_offset
15022 + input_section
->output_section
->vma
);
15023 if (relocation
+ 0x80008000 <= 0xffffffff)
15025 unsigned int insn1
, insn2
;
15027 insn1
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15028 insn2
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15029 if ((insn1
& ~0xfffc) == LD_R2_0R12
15030 && insn2
== ADD_R2_R2_R12
)
15032 bfd_put_32 (input_bfd
,
15033 ADDIS_R2_R12
+ PPC_HA (relocation
),
15034 contents
+ rel
->r_offset
);
15035 bfd_put_32 (input_bfd
,
15036 ADDI_R2_R2
+ PPC_LO (relocation
),
15037 contents
+ rel
->r_offset
+ 4);
15043 case R_PPC64_REL16_HA
:
15044 /* If we are generating a non-PIC executable, edit
15045 . 0: addis 2,12,.TOC.-0b@ha
15046 . addi 2,2,.TOC.-0b@l
15047 used by ELFv2 global entry points to set up r2, to
15050 if .TOC. is in range. */
15051 if (!bfd_link_pic (info
)
15052 && !info
->traditional_format
15054 && rel
->r_addend
== d_offset
15055 && h
!= NULL
&& &h
->elf
== htab
->elf
.hgot
15056 && rel
+ 1 < relend
15057 && rel
[1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_REL16_LO
)
15058 && rel
[1].r_offset
== rel
->r_offset
+ 4
15059 && rel
[1].r_addend
== rel
->r_addend
+ 4
15060 && relocation
+ 0x80008000 <= 0xffffffff)
15062 unsigned int insn1
, insn2
;
15063 offset
= rel
->r_offset
- d_offset
;
15064 insn1
= bfd_get_32 (input_bfd
, contents
+ offset
);
15065 insn2
= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
15066 if ((insn1
& 0xffff0000) == ADDIS_R2_R12
15067 && (insn2
& 0xffff0000) == ADDI_R2_R2
)
15069 r_type
= R_PPC64_ADDR16_HA
;
15070 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15071 rel
->r_addend
-= d_offset
;
15072 rel
[1].r_info
= ELF64_R_INFO (r_symndx
, R_PPC64_ADDR16_LO
);
15073 rel
[1].r_addend
-= d_offset
+ 4;
15074 bfd_put_32 (input_bfd
, LIS_R2
, contents
+ offset
);
15080 /* Handle other relocations that tweak non-addend part of insn. */
15082 max_br_offset
= 1 << 25;
15083 addend
= rel
->r_addend
;
15084 reloc_dest
= DEST_NORMAL
;
15090 case R_PPC64_TOCSAVE
:
15091 if (relocation
+ addend
== (rel
->r_offset
15092 + input_section
->output_offset
15093 + input_section
->output_section
->vma
)
15094 && tocsave_find (htab
, NO_INSERT
,
15095 &local_syms
, rel
, input_bfd
))
15097 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15099 || insn
== CROR_151515
|| insn
== CROR_313131
)
15100 bfd_put_32 (input_bfd
,
15101 STD_R2_0R1
+ STK_TOC (htab
),
15102 contents
+ rel
->r_offset
);
15106 /* Branch taken prediction relocations. */
15107 case R_PPC64_ADDR14_BRTAKEN
:
15108 case R_PPC64_REL14_BRTAKEN
:
15109 insn
= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
15110 /* Fall through. */
15112 /* Branch not taken prediction relocations. */
15113 case R_PPC64_ADDR14_BRNTAKEN
:
15114 case R_PPC64_REL14_BRNTAKEN
:
15115 insn
|= bfd_get_32 (input_bfd
,
15116 contents
+ rel
->r_offset
) & ~(0x01 << 21);
15117 /* Fall through. */
15119 case R_PPC64_REL14
:
15120 max_br_offset
= 1 << 15;
15121 /* Fall through. */
15123 case R_PPC64_REL24
:
15124 case R_PPC64_REL24_NOTOC
:
15125 case R_PPC64_PLTCALL
:
15126 case R_PPC64_PLTCALL_NOTOC
:
15127 /* Calls to functions with a different TOC, such as calls to
15128 shared objects, need to alter the TOC pointer. This is
15129 done using a linkage stub. A REL24 branching to these
15130 linkage stubs needs to be followed by a nop, as the nop
15131 will be replaced with an instruction to restore the TOC
15136 && h
->oh
->is_func_descriptor
)
15137 fdh
= ppc_follow_link (h
->oh
);
15138 stub_entry
= ppc_get_stub_entry (input_section
, sec
, fdh
, &orig_rel
,
15140 if ((r_type
== R_PPC64_PLTCALL
15141 || r_type
== R_PPC64_PLTCALL_NOTOC
)
15142 && stub_entry
!= NULL
15143 && stub_entry
->stub_type
>= ppc_stub_plt_call
15144 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15147 if (stub_entry
!= NULL
15148 && ((stub_entry
->stub_type
>= ppc_stub_plt_call
15149 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15150 || stub_entry
->stub_type
== ppc_stub_plt_branch_r2off
15151 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
15152 || stub_entry
->stub_type
== ppc_stub_long_branch_r2off
15153 || stub_entry
->stub_type
== ppc_stub_long_branch_both
))
15155 bfd_boolean can_plt_call
= FALSE
;
15157 if (stub_entry
->stub_type
== ppc_stub_plt_call
15159 && htab
->params
->plt_localentry0
!= 0
15160 && is_elfv2_localentry0 (&h
->elf
))
15162 /* The function doesn't use or change r2. */
15163 can_plt_call
= TRUE
;
15165 else if (r_type
== R_PPC64_REL24_NOTOC
)
15167 /* NOTOC calls don't need to restore r2. */
15168 can_plt_call
= TRUE
;
15171 /* All of these stubs may modify r2, so there must be a
15172 branch and link followed by a nop. The nop is
15173 replaced by an insn to restore r2. */
15174 else if (rel
->r_offset
+ 8 <= input_section
->size
)
15178 br
= bfd_get_32 (input_bfd
,
15179 contents
+ rel
->r_offset
);
15184 nop
= bfd_get_32 (input_bfd
,
15185 contents
+ rel
->r_offset
+ 4);
15186 if (nop
== LD_R2_0R1
+ STK_TOC (htab
))
15187 can_plt_call
= TRUE
;
15188 else if (nop
== NOP
15189 || nop
== CROR_151515
15190 || nop
== CROR_313131
)
15193 && (h
== htab
->tls_get_addr_fd
15194 || h
== htab
->tls_get_addr
)
15195 && htab
->params
->tls_get_addr_opt
)
15197 /* Special stub used, leave nop alone. */
15200 bfd_put_32 (input_bfd
,
15201 LD_R2_0R1
+ STK_TOC (htab
),
15202 contents
+ rel
->r_offset
+ 4);
15203 can_plt_call
= TRUE
;
15208 if (!can_plt_call
&& h
!= NULL
)
15210 const char *name
= h
->elf
.root
.root
.string
;
15215 if (strncmp (name
, "__libc_start_main", 17) == 0
15216 && (name
[17] == 0 || name
[17] == '@'))
15218 /* Allow crt1 branch to go via a toc adjusting
15219 stub. Other calls that never return could do
15220 the same, if we could detect such. */
15221 can_plt_call
= TRUE
;
15227 /* g++ as of 20130507 emits self-calls without a
15228 following nop. This is arguably wrong since we
15229 have conflicting information. On the one hand a
15230 global symbol and on the other a local call
15231 sequence, but don't error for this special case.
15232 It isn't possible to cheaply verify we have
15233 exactly such a call. Allow all calls to the same
15235 asection
*code_sec
= sec
;
15237 if (get_opd_info (sec
) != NULL
)
15239 bfd_vma off
= (relocation
+ addend
15240 - sec
->output_section
->vma
15241 - sec
->output_offset
);
15243 opd_entry_value (sec
, off
, &code_sec
, NULL
, FALSE
);
15245 if (code_sec
== input_section
)
15246 can_plt_call
= TRUE
;
15251 if (stub_entry
->stub_type
>= ppc_stub_plt_call
15252 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15253 info
->callbacks
->einfo
15254 /* xgettext:c-format */
15255 (_("%H: call to `%pT' lacks nop, can't restore toc; "
15256 "(plt call stub)\n"),
15257 input_bfd
, input_section
, rel
->r_offset
, sym_name
);
15259 info
->callbacks
->einfo
15260 /* xgettext:c-format */
15261 (_("%H: call to `%pT' lacks nop, can't restore toc; "
15262 "(toc save/adjust stub)\n"),
15263 input_bfd
, input_section
, rel
->r_offset
, sym_name
);
15265 bfd_set_error (bfd_error_bad_value
);
15270 && stub_entry
->stub_type
>= ppc_stub_plt_call
15271 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15272 unresolved_reloc
= FALSE
;
15275 if ((stub_entry
== NULL
15276 || stub_entry
->stub_type
== ppc_stub_long_branch
15277 || stub_entry
->stub_type
== ppc_stub_plt_branch
)
15278 && get_opd_info (sec
) != NULL
)
15280 /* The branch destination is the value of the opd entry. */
15281 bfd_vma off
= (relocation
+ addend
15282 - sec
->output_section
->vma
15283 - sec
->output_offset
);
15284 bfd_vma dest
= opd_entry_value (sec
, off
, NULL
, NULL
, FALSE
);
15285 if (dest
!= (bfd_vma
) -1)
15289 reloc_dest
= DEST_OPD
;
15293 /* If the branch is out of reach we ought to have a long
15295 from
= (rel
->r_offset
15296 + input_section
->output_offset
15297 + input_section
->output_section
->vma
);
15299 relocation
+= PPC64_LOCAL_ENTRY_OFFSET (fdh
15303 if (stub_entry
!= NULL
15304 && (stub_entry
->stub_type
== ppc_stub_long_branch
15305 || stub_entry
->stub_type
== ppc_stub_plt_branch
)
15306 && (r_type
== R_PPC64_ADDR14_BRTAKEN
15307 || r_type
== R_PPC64_ADDR14_BRNTAKEN
15308 || (relocation
+ addend
- from
+ max_br_offset
15309 < 2 * max_br_offset
)))
15310 /* Don't use the stub if this branch is in range. */
15313 if (stub_entry
!= NULL
15314 && (stub_entry
->stub_type
== ppc_stub_long_branch_notoc
15315 || stub_entry
->stub_type
== ppc_stub_long_branch_both
15316 || stub_entry
->stub_type
== ppc_stub_plt_branch_notoc
15317 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
)
15318 && (r_type
!= R_PPC64_REL24_NOTOC
15319 || ((fdh
? fdh
->elf
.other
: sym
->st_other
)
15320 & STO_PPC64_LOCAL_MASK
) <= 1 << STO_PPC64_LOCAL_BIT
)
15321 && (relocation
+ addend
- from
+ max_br_offset
15322 < 2 * max_br_offset
))
15325 if (stub_entry
!= NULL
15326 && (stub_entry
->stub_type
== ppc_stub_long_branch_r2off
15327 || stub_entry
->stub_type
== ppc_stub_long_branch_both
15328 || stub_entry
->stub_type
== ppc_stub_plt_branch_r2off
15329 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
)
15330 && r_type
== R_PPC64_REL24_NOTOC
15331 && (relocation
+ addend
- from
+ max_br_offset
15332 < 2 * max_br_offset
))
15335 if (stub_entry
!= NULL
)
15337 /* Munge up the value and addend so that we call the stub
15338 rather than the procedure directly. */
15339 asection
*stub_sec
= stub_entry
->group
->stub_sec
;
15341 if (stub_entry
->stub_type
== ppc_stub_save_res
)
15342 relocation
+= (stub_sec
->output_offset
15343 + stub_sec
->output_section
->vma
15344 + stub_sec
->size
- htab
->sfpr
->size
15345 - htab
->sfpr
->output_offset
15346 - htab
->sfpr
->output_section
->vma
);
15348 relocation
= (stub_entry
->stub_offset
15349 + stub_sec
->output_offset
15350 + stub_sec
->output_section
->vma
);
15352 reloc_dest
= DEST_STUB
;
15354 if (((stub_entry
->stub_type
== ppc_stub_plt_call
15355 && ALWAYS_EMIT_R2SAVE
)
15356 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
15357 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
15359 && (h
== htab
->tls_get_addr_fd
15360 || h
== htab
->tls_get_addr
)
15361 && htab
->params
->tls_get_addr_opt
)
15362 && rel
+ 1 < relend
15363 && rel
[1].r_offset
== rel
->r_offset
+ 4
15364 && ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_TOCSAVE
)
15366 else if ((stub_entry
->stub_type
== ppc_stub_long_branch_both
15367 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
15368 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
15369 && r_type
== R_PPC64_REL24_NOTOC
)
15372 if (r_type
== R_PPC64_REL24_NOTOC
15373 && (stub_entry
->stub_type
== ppc_stub_plt_call_notoc
15374 || stub_entry
->stub_type
== ppc_stub_plt_call_both
))
15375 htab
->notoc_plt
= 1;
15382 /* Set 'a' bit. This is 0b00010 in BO field for branch
15383 on CR(BI) insns (BO == 001at or 011at), and 0b01000
15384 for branch on CTR insns (BO == 1a00t or 1a01t). */
15385 if ((insn
& (0x14 << 21)) == (0x04 << 21))
15386 insn
|= 0x02 << 21;
15387 else if ((insn
& (0x14 << 21)) == (0x10 << 21))
15388 insn
|= 0x08 << 21;
15394 /* Invert 'y' bit if not the default. */
15395 if ((bfd_signed_vma
) (relocation
+ addend
- from
) < 0)
15396 insn
^= 0x01 << 21;
15399 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
15402 /* NOP out calls to undefined weak functions.
15403 We can thus call a weak function without first
15404 checking whether the function is defined. */
15406 && h
->elf
.root
.type
== bfd_link_hash_undefweak
15407 && h
->elf
.dynindx
== -1
15408 && (r_type
== R_PPC64_REL24
15409 || r_type
== R_PPC64_REL24_NOTOC
)
15413 bfd_put_32 (input_bfd
, NOP
, contents
+ rel
->r_offset
);
15418 case R_PPC64_GOT16_DS
:
15419 from
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
15420 if (relocation
+ addend
- from
+ 0x8000 < 0x10000
15421 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15423 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
15424 if ((insn
& (0x3f << 26 | 0x3)) == 58u << 26 /* ld */)
15426 insn
+= (14u << 26) - (58u << 26);
15427 bfd_put_32 (input_bfd
, insn
, contents
+ (rel
->r_offset
& ~3));
15428 r_type
= R_PPC64_TOC16
;
15429 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15434 case R_PPC64_GOT16_LO_DS
:
15435 case R_PPC64_GOT16_HA
:
15436 from
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
15437 if (relocation
+ addend
- from
+ 0x80008000ULL
< 0x100000000ULL
15438 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15440 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
15441 if ((insn
& (0x3f << 26 | 0x3)) == 58u << 26 /* ld */)
15443 insn
+= (14u << 26) - (58u << 26);
15444 bfd_put_32 (input_bfd
, insn
, contents
+ (rel
->r_offset
& ~3));
15445 r_type
= R_PPC64_TOC16_LO
;
15446 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15448 else if ((insn
& (0x3f << 26)) == 15u << 26 /* addis */)
15450 r_type
= R_PPC64_TOC16_HA
;
15451 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15456 case R_PPC64_GOT_PCREL34
:
15457 from
= (rel
->r_offset
15458 + input_section
->output_section
->vma
15459 + input_section
->output_offset
);
15460 if (relocation
- from
+ (1ULL << 33) < 1ULL << 34
15461 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15463 offset
= rel
->r_offset
;
15464 pinsn
= bfd_get_32 (input_bfd
, contents
+ offset
);
15466 pinsn
|= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
15467 if ((pinsn
& ((-1ULL << 50) | (63ULL << 26)))
15468 == ((1ULL << 58) | (1ULL << 52) | (57ULL << 26) /* pld */))
15470 /* Replace with paddi. */
15471 pinsn
+= (2ULL << 56) + (14ULL << 26) - (57ULL << 26);
15472 r_type
= R_PPC64_PCREL34
;
15473 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15474 bfd_put_32 (input_bfd
, pinsn
>> 32, contents
+ offset
);
15475 bfd_put_32 (input_bfd
, pinsn
, contents
+ offset
+ 4);
15481 case R_PPC64_PCREL34
:
15482 if (SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15484 offset
= rel
->r_offset
;
15485 pinsn
= bfd_get_32 (input_bfd
, contents
+ offset
);
15487 pinsn
|= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
15488 if ((pinsn
& ((-1ULL << 50) | (63ULL << 26)))
15489 == ((1ULL << 58) | (2ULL << 56) | (1ULL << 52)
15490 | (14ULL << 26) /* paddi */))
15493 if (rel
+ 1 < relend
15494 && rel
[1].r_offset
== offset
15495 && rel
[1].r_info
== ELF64_R_INFO (0, R_PPC64_PCREL_OPT
))
15497 bfd_vma off2
= rel
[1].r_addend
;
15499 /* zero means next insn. */
15502 if (off2
+ 4 <= input_section
->size
)
15505 bfd_signed_vma addend_off
;
15506 pinsn2
= bfd_get_32 (input_bfd
, contents
+ off2
);
15508 if ((pinsn2
& (63ULL << 58)) == 1ULL << 58)
15510 if (off2
+ 8 > input_section
->size
)
15512 pinsn2
|= bfd_get_32 (input_bfd
,
15513 contents
+ off2
+ 4);
15515 if (xlate_pcrel_opt (&pinsn
, &pinsn2
, &addend_off
))
15517 addend
+= addend_off
;
15518 rel
->r_addend
= addend
;
15519 bfd_put_32 (input_bfd
, pinsn
>> 32,
15520 contents
+ offset
);
15521 bfd_put_32 (input_bfd
, pinsn
,
15522 contents
+ offset
+ 4);
15523 bfd_put_32 (input_bfd
, pinsn2
>> 32,
15525 if ((pinsn2
& (63ULL << 58)) == 1ULL << 58)
15526 bfd_put_32 (input_bfd
, pinsn2
,
15527 contents
+ off2
+ 4);
15537 save_unresolved_reloc
= unresolved_reloc
;
15541 /* xgettext:c-format */
15542 _bfd_error_handler (_("%pB: %s unsupported"),
15543 input_bfd
, ppc64_elf_howto_table
[r_type
]->name
);
15545 bfd_set_error (bfd_error_bad_value
);
15551 case R_PPC64_TLSGD
:
15552 case R_PPC64_TLSLD
:
15553 case R_PPC64_TOCSAVE
:
15554 case R_PPC64_GNU_VTINHERIT
:
15555 case R_PPC64_GNU_VTENTRY
:
15556 case R_PPC64_ENTRY
:
15557 case R_PPC64_PCREL_OPT
:
15560 /* GOT16 relocations. Like an ADDR16 using the symbol's
15561 address in the GOT as relocation value instead of the
15562 symbol's value itself. Also, create a GOT entry for the
15563 symbol and put the symbol value there. */
15564 case R_PPC64_GOT_TLSGD16
:
15565 case R_PPC64_GOT_TLSGD16_LO
:
15566 case R_PPC64_GOT_TLSGD16_HI
:
15567 case R_PPC64_GOT_TLSGD16_HA
:
15568 case R_PPC64_GOT_TLSGD34
:
15569 tls_type
= TLS_TLS
| TLS_GD
;
15572 case R_PPC64_GOT_TLSLD16
:
15573 case R_PPC64_GOT_TLSLD16_LO
:
15574 case R_PPC64_GOT_TLSLD16_HI
:
15575 case R_PPC64_GOT_TLSLD16_HA
:
15576 case R_PPC64_GOT_TLSLD34
:
15577 tls_type
= TLS_TLS
| TLS_LD
;
15580 case R_PPC64_GOT_TPREL16_DS
:
15581 case R_PPC64_GOT_TPREL16_LO_DS
:
15582 case R_PPC64_GOT_TPREL16_HI
:
15583 case R_PPC64_GOT_TPREL16_HA
:
15584 case R_PPC64_GOT_TPREL34
:
15585 tls_type
= TLS_TLS
| TLS_TPREL
;
15588 case R_PPC64_GOT_DTPREL16_DS
:
15589 case R_PPC64_GOT_DTPREL16_LO_DS
:
15590 case R_PPC64_GOT_DTPREL16_HI
:
15591 case R_PPC64_GOT_DTPREL16_HA
:
15592 case R_PPC64_GOT_DTPREL34
:
15593 tls_type
= TLS_TLS
| TLS_DTPREL
;
15596 case R_PPC64_GOT16
:
15597 case R_PPC64_GOT16_LO
:
15598 case R_PPC64_GOT16_HI
:
15599 case R_PPC64_GOT16_HA
:
15600 case R_PPC64_GOT16_DS
:
15601 case R_PPC64_GOT16_LO_DS
:
15602 case R_PPC64_GOT_PCREL34
:
15605 /* Relocation is to the entry for this symbol in the global
15610 unsigned long indx
= 0;
15611 struct got_entry
*ent
;
15613 if (tls_type
== (TLS_TLS
| TLS_LD
)
15615 || !h
->elf
.def_dynamic
))
15616 ent
= ppc64_tlsld_got (input_bfd
);
15621 if (!htab
->elf
.dynamic_sections_created
15622 || h
->elf
.dynindx
== -1
15623 || SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
)
15624 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, &h
->elf
))
15625 /* This is actually a static link, or it is a
15626 -Bsymbolic link and the symbol is defined
15627 locally, or the symbol was forced to be local
15628 because of a version file. */
15632 indx
= h
->elf
.dynindx
;
15633 unresolved_reloc
= FALSE
;
15635 ent
= h
->elf
.got
.glist
;
15639 if (local_got_ents
== NULL
)
15641 ent
= local_got_ents
[r_symndx
];
15644 for (; ent
!= NULL
; ent
= ent
->next
)
15645 if (ent
->addend
== orig_rel
.r_addend
15646 && ent
->owner
== input_bfd
15647 && ent
->tls_type
== tls_type
)
15653 if (ent
->is_indirect
)
15654 ent
= ent
->got
.ent
;
15655 offp
= &ent
->got
.offset
;
15656 got
= ppc64_elf_tdata (ent
->owner
)->got
;
15660 /* The offset must always be a multiple of 8. We use the
15661 least significant bit to record whether we have already
15662 processed this entry. */
15664 if ((off
& 1) != 0)
15668 /* Generate relocs for the dynamic linker, except in
15669 the case of TLSLD where we'll use one entry per
15677 ? h
->elf
.type
== STT_GNU_IFUNC
15678 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
);
15681 relgot
= htab
->elf
.irelplt
;
15683 htab
->local_ifunc_resolver
= 1;
15684 else if (is_static_defined (&h
->elf
))
15685 htab
->maybe_local_ifunc_resolver
= 1;
15688 || (bfd_link_pic (info
)
15690 || !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, &h
->elf
)
15691 || (tls_type
== (TLS_TLS
| TLS_LD
)
15692 && !h
->elf
.def_dynamic
))
15693 && !(tls_type
== (TLS_TLS
| TLS_TPREL
)
15694 && bfd_link_executable (info
)
15695 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))))
15696 relgot
= ppc64_elf_tdata (ent
->owner
)->relgot
;
15697 if (relgot
!= NULL
)
15699 outrel
.r_offset
= (got
->output_section
->vma
15700 + got
->output_offset
15702 outrel
.r_addend
= orig_rel
.r_addend
;
15703 if (tls_type
& (TLS_LD
| TLS_GD
))
15705 outrel
.r_addend
= 0;
15706 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_DTPMOD64
);
15707 if (tls_type
== (TLS_TLS
| TLS_GD
))
15709 loc
= relgot
->contents
;
15710 loc
+= (relgot
->reloc_count
++
15711 * sizeof (Elf64_External_Rela
));
15712 bfd_elf64_swap_reloca_out (output_bfd
,
15714 outrel
.r_offset
+= 8;
15715 outrel
.r_addend
= orig_rel
.r_addend
;
15717 = ELF64_R_INFO (indx
, R_PPC64_DTPREL64
);
15720 else if (tls_type
== (TLS_TLS
| TLS_DTPREL
))
15721 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_DTPREL64
);
15722 else if (tls_type
== (TLS_TLS
| TLS_TPREL
))
15723 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_TPREL64
);
15724 else if (indx
!= 0)
15725 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_GLOB_DAT
);
15729 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
15731 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
15733 /* Write the .got section contents for the sake
15735 loc
= got
->contents
+ off
;
15736 bfd_put_64 (output_bfd
, outrel
.r_addend
+ relocation
,
15740 if (indx
== 0 && tls_type
!= (TLS_TLS
| TLS_LD
))
15742 outrel
.r_addend
+= relocation
;
15743 if (tls_type
& (TLS_GD
| TLS_DTPREL
| TLS_TPREL
))
15745 if (htab
->elf
.tls_sec
== NULL
)
15746 outrel
.r_addend
= 0;
15748 outrel
.r_addend
-= htab
->elf
.tls_sec
->vma
;
15751 loc
= relgot
->contents
;
15752 loc
+= (relgot
->reloc_count
++
15753 * sizeof (Elf64_External_Rela
));
15754 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
15757 /* Init the .got section contents here if we're not
15758 emitting a reloc. */
15761 relocation
+= orig_rel
.r_addend
;
15764 if (htab
->elf
.tls_sec
== NULL
)
15768 if (tls_type
& TLS_LD
)
15771 relocation
-= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
15772 if (tls_type
& TLS_TPREL
)
15773 relocation
+= DTP_OFFSET
- TP_OFFSET
;
15776 if (tls_type
& (TLS_GD
| TLS_LD
))
15778 bfd_put_64 (output_bfd
, relocation
,
15779 got
->contents
+ off
+ 8);
15783 bfd_put_64 (output_bfd
, relocation
,
15784 got
->contents
+ off
);
15788 if (off
>= (bfd_vma
) -2)
15791 relocation
= got
->output_section
->vma
+ got
->output_offset
+ off
;
15793 if (!(r_type
== R_PPC64_GOT_PCREL34
15794 || r_type
== R_PPC64_GOT_TLSGD34
15795 || r_type
== R_PPC64_GOT_TLSLD34
15796 || r_type
== R_PPC64_GOT_TPREL34
15797 || r_type
== R_PPC64_GOT_DTPREL34
))
15798 addend
= -(TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
);
15802 case R_PPC64_PLT16_HA
:
15803 case R_PPC64_PLT16_HI
:
15804 case R_PPC64_PLT16_LO
:
15805 case R_PPC64_PLT16_LO_DS
:
15806 case R_PPC64_PLT_PCREL34
:
15807 case R_PPC64_PLT_PCREL34_NOTOC
:
15808 case R_PPC64_PLT32
:
15809 case R_PPC64_PLT64
:
15810 case R_PPC64_PLTSEQ
:
15811 case R_PPC64_PLTSEQ_NOTOC
:
15812 case R_PPC64_PLTCALL
:
15813 case R_PPC64_PLTCALL_NOTOC
:
15814 /* Relocation is to the entry for this symbol in the
15815 procedure linkage table. */
15816 unresolved_reloc
= TRUE
;
15818 struct plt_entry
**plt_list
= NULL
;
15820 plt_list
= &h
->elf
.plt
.plist
;
15821 else if (local_got_ents
!= NULL
)
15823 struct plt_entry
**local_plt
= (struct plt_entry
**)
15824 (local_got_ents
+ symtab_hdr
->sh_info
);
15825 plt_list
= local_plt
+ r_symndx
;
15829 struct plt_entry
*ent
;
15831 for (ent
= *plt_list
; ent
!= NULL
; ent
= ent
->next
)
15832 if (ent
->plt
.offset
!= (bfd_vma
) -1
15833 && ent
->addend
== orig_rel
.r_addend
)
15838 plt
= htab
->elf
.splt
;
15839 if (!htab
->elf
.dynamic_sections_created
15841 || h
->elf
.dynindx
== -1)
15844 ? h
->elf
.type
== STT_GNU_IFUNC
15845 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
15846 plt
= htab
->elf
.iplt
;
15848 plt
= htab
->pltlocal
;
15850 relocation
= (plt
->output_section
->vma
15851 + plt
->output_offset
15852 + ent
->plt
.offset
);
15853 if (r_type
== R_PPC64_PLT16_HA
15854 || r_type
== R_PPC64_PLT16_HI
15855 || r_type
== R_PPC64_PLT16_LO
15856 || r_type
== R_PPC64_PLT16_LO_DS
)
15858 got
= (elf_gp (output_bfd
)
15859 + htab
->sec_info
[input_section
->id
].toc_off
);
15863 unresolved_reloc
= FALSE
;
15871 /* Relocation value is TOC base. */
15872 relocation
= TOCstart
;
15873 if (r_symndx
== STN_UNDEF
)
15874 relocation
+= htab
->sec_info
[input_section
->id
].toc_off
;
15875 else if (unresolved_reloc
)
15877 else if (sec
!= NULL
&& sec
->id
< htab
->sec_info_arr_size
)
15878 relocation
+= htab
->sec_info
[sec
->id
].toc_off
;
15880 unresolved_reloc
= TRUE
;
15883 /* TOC16 relocs. We want the offset relative to the TOC base,
15884 which is the address of the start of the TOC plus 0x8000.
15885 The TOC consists of sections .got, .toc, .tocbss, and .plt,
15887 case R_PPC64_TOC16
:
15888 case R_PPC64_TOC16_LO
:
15889 case R_PPC64_TOC16_HI
:
15890 case R_PPC64_TOC16_DS
:
15891 case R_PPC64_TOC16_LO_DS
:
15892 case R_PPC64_TOC16_HA
:
15893 addend
-= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
15898 /* Relocate against the beginning of the section. */
15899 case R_PPC64_SECTOFF
:
15900 case R_PPC64_SECTOFF_LO
:
15901 case R_PPC64_SECTOFF_HI
:
15902 case R_PPC64_SECTOFF_DS
:
15903 case R_PPC64_SECTOFF_LO_DS
:
15904 case R_PPC64_SECTOFF_HA
:
15906 addend
-= sec
->output_section
->vma
;
15909 case R_PPC64_REL16
:
15910 case R_PPC64_REL16_LO
:
15911 case R_PPC64_REL16_HI
:
15912 case R_PPC64_REL16_HA
:
15913 case R_PPC64_REL16_HIGH
:
15914 case R_PPC64_REL16_HIGHA
:
15915 case R_PPC64_REL16_HIGHER
:
15916 case R_PPC64_REL16_HIGHERA
:
15917 case R_PPC64_REL16_HIGHEST
:
15918 case R_PPC64_REL16_HIGHESTA
:
15919 case R_PPC64_REL16_HIGHER34
:
15920 case R_PPC64_REL16_HIGHERA34
:
15921 case R_PPC64_REL16_HIGHEST34
:
15922 case R_PPC64_REL16_HIGHESTA34
:
15923 case R_PPC64_REL16DX_HA
:
15924 case R_PPC64_REL14
:
15925 case R_PPC64_REL14_BRNTAKEN
:
15926 case R_PPC64_REL14_BRTAKEN
:
15927 case R_PPC64_REL24
:
15928 case R_PPC64_REL24_NOTOC
:
15929 case R_PPC64_PCREL34
:
15930 case R_PPC64_PCREL28
:
15933 case R_PPC64_TPREL16
:
15934 case R_PPC64_TPREL16_LO
:
15935 case R_PPC64_TPREL16_HI
:
15936 case R_PPC64_TPREL16_HA
:
15937 case R_PPC64_TPREL16_DS
:
15938 case R_PPC64_TPREL16_LO_DS
:
15939 case R_PPC64_TPREL16_HIGH
:
15940 case R_PPC64_TPREL16_HIGHA
:
15941 case R_PPC64_TPREL16_HIGHER
:
15942 case R_PPC64_TPREL16_HIGHERA
:
15943 case R_PPC64_TPREL16_HIGHEST
:
15944 case R_PPC64_TPREL16_HIGHESTA
:
15945 case R_PPC64_TPREL34
:
15947 && h
->elf
.root
.type
== bfd_link_hash_undefweak
15948 && h
->elf
.dynindx
== -1)
15950 /* Make this relocation against an undefined weak symbol
15951 resolve to zero. This is really just a tweak, since
15952 code using weak externs ought to check that they are
15953 defined before using them. */
15954 bfd_byte
*p
= contents
+ rel
->r_offset
- d_offset
;
15956 insn
= bfd_get_32 (input_bfd
, p
);
15957 insn
= _bfd_elf_ppc_at_tprel_transform (insn
, 13);
15959 bfd_put_32 (input_bfd
, insn
, p
);
15962 if (htab
->elf
.tls_sec
!= NULL
)
15963 addend
-= htab
->elf
.tls_sec
->vma
+ TP_OFFSET
;
15964 /* The TPREL16 relocs shouldn't really be used in shared
15965 libs or with non-local symbols as that will result in
15966 DT_TEXTREL being set, but support them anyway. */
15969 case R_PPC64_DTPREL16
:
15970 case R_PPC64_DTPREL16_LO
:
15971 case R_PPC64_DTPREL16_HI
:
15972 case R_PPC64_DTPREL16_HA
:
15973 case R_PPC64_DTPREL16_DS
:
15974 case R_PPC64_DTPREL16_LO_DS
:
15975 case R_PPC64_DTPREL16_HIGH
:
15976 case R_PPC64_DTPREL16_HIGHA
:
15977 case R_PPC64_DTPREL16_HIGHER
:
15978 case R_PPC64_DTPREL16_HIGHERA
:
15979 case R_PPC64_DTPREL16_HIGHEST
:
15980 case R_PPC64_DTPREL16_HIGHESTA
:
15981 case R_PPC64_DTPREL34
:
15982 if (htab
->elf
.tls_sec
!= NULL
)
15983 addend
-= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
15986 case R_PPC64_ADDR64_LOCAL
:
15987 addend
+= PPC64_LOCAL_ENTRY_OFFSET (h
!= NULL
15992 case R_PPC64_DTPMOD64
:
15997 case R_PPC64_TPREL64
:
15998 if (htab
->elf
.tls_sec
!= NULL
)
15999 addend
-= htab
->elf
.tls_sec
->vma
+ TP_OFFSET
;
16002 case R_PPC64_DTPREL64
:
16003 if (htab
->elf
.tls_sec
!= NULL
)
16004 addend
-= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
16005 /* Fall through. */
16007 /* Relocations that may need to be propagated if this is a
16009 case R_PPC64_REL30
:
16010 case R_PPC64_REL32
:
16011 case R_PPC64_REL64
:
16012 case R_PPC64_ADDR14
:
16013 case R_PPC64_ADDR14_BRNTAKEN
:
16014 case R_PPC64_ADDR14_BRTAKEN
:
16015 case R_PPC64_ADDR16
:
16016 case R_PPC64_ADDR16_DS
:
16017 case R_PPC64_ADDR16_HA
:
16018 case R_PPC64_ADDR16_HI
:
16019 case R_PPC64_ADDR16_HIGH
:
16020 case R_PPC64_ADDR16_HIGHA
:
16021 case R_PPC64_ADDR16_HIGHER
:
16022 case R_PPC64_ADDR16_HIGHERA
:
16023 case R_PPC64_ADDR16_HIGHEST
:
16024 case R_PPC64_ADDR16_HIGHESTA
:
16025 case R_PPC64_ADDR16_LO
:
16026 case R_PPC64_ADDR16_LO_DS
:
16027 case R_PPC64_ADDR16_HIGHER34
:
16028 case R_PPC64_ADDR16_HIGHERA34
:
16029 case R_PPC64_ADDR16_HIGHEST34
:
16030 case R_PPC64_ADDR16_HIGHESTA34
:
16031 case R_PPC64_ADDR24
:
16032 case R_PPC64_ADDR32
:
16033 case R_PPC64_ADDR64
:
16034 case R_PPC64_UADDR16
:
16035 case R_PPC64_UADDR32
:
16036 case R_PPC64_UADDR64
:
16038 case R_PPC64_D34_LO
:
16039 case R_PPC64_D34_HI30
:
16040 case R_PPC64_D34_HA30
:
16043 if ((input_section
->flags
& SEC_ALLOC
) == 0)
16046 if (NO_OPD_RELOCS
&& is_opd
)
16049 if (bfd_link_pic (info
)
16051 || h
->dyn_relocs
!= NULL
)
16052 && ((h
!= NULL
&& pc_dynrelocs (h
))
16053 || must_be_dyn_reloc (info
, r_type
)))
16055 ? h
->dyn_relocs
!= NULL
16056 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
))
16058 bfd_boolean skip
, relocate
;
16063 /* When generating a dynamic object, these relocations
16064 are copied into the output file to be resolved at run
16070 out_off
= _bfd_elf_section_offset (output_bfd
, info
,
16071 input_section
, rel
->r_offset
);
16072 if (out_off
== (bfd_vma
) -1)
16074 else if (out_off
== (bfd_vma
) -2)
16075 skip
= TRUE
, relocate
= TRUE
;
16076 out_off
+= (input_section
->output_section
->vma
16077 + input_section
->output_offset
);
16078 outrel
.r_offset
= out_off
;
16079 outrel
.r_addend
= rel
->r_addend
;
16081 /* Optimize unaligned reloc use. */
16082 if ((r_type
== R_PPC64_ADDR64
&& (out_off
& 7) != 0)
16083 || (r_type
== R_PPC64_UADDR64
&& (out_off
& 7) == 0))
16084 r_type
^= R_PPC64_ADDR64
^ R_PPC64_UADDR64
;
16085 else if ((r_type
== R_PPC64_ADDR32
&& (out_off
& 3) != 0)
16086 || (r_type
== R_PPC64_UADDR32
&& (out_off
& 3) == 0))
16087 r_type
^= R_PPC64_ADDR32
^ R_PPC64_UADDR32
;
16088 else if ((r_type
== R_PPC64_ADDR16
&& (out_off
& 1) != 0)
16089 || (r_type
== R_PPC64_UADDR16
&& (out_off
& 1) == 0))
16090 r_type
^= R_PPC64_ADDR16
^ R_PPC64_UADDR16
;
16093 memset (&outrel
, 0, sizeof outrel
);
16094 else if (!SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
)
16096 && r_type
!= R_PPC64_TOC
)
16098 indx
= h
->elf
.dynindx
;
16099 BFD_ASSERT (indx
!= -1);
16100 outrel
.r_info
= ELF64_R_INFO (indx
, r_type
);
16104 /* This symbol is local, or marked to become local,
16105 or this is an opd section reloc which must point
16106 at a local function. */
16107 outrel
.r_addend
+= relocation
;
16108 if (r_type
== R_PPC64_ADDR64
|| r_type
== R_PPC64_TOC
)
16110 if (is_opd
&& h
!= NULL
)
16112 /* Lie about opd entries. This case occurs
16113 when building shared libraries and we
16114 reference a function in another shared
16115 lib. The same thing happens for a weak
16116 definition in an application that's
16117 overridden by a strong definition in a
16118 shared lib. (I believe this is a generic
16119 bug in binutils handling of weak syms.)
16120 In these cases we won't use the opd
16121 entry in this lib. */
16122 unresolved_reloc
= FALSE
;
16125 && r_type
== R_PPC64_ADDR64
16127 ? h
->elf
.type
== STT_GNU_IFUNC
16128 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
))
16129 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
16132 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
16134 /* We need to relocate .opd contents for ld.so.
16135 Prelink also wants simple and consistent rules
16136 for relocs. This make all RELATIVE relocs have
16137 *r_offset equal to r_addend. */
16144 ? h
->elf
.type
== STT_GNU_IFUNC
16145 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
16147 info
->callbacks
->einfo
16148 /* xgettext:c-format */
16149 (_("%H: %s for indirect "
16150 "function `%pT' unsupported\n"),
16151 input_bfd
, input_section
, rel
->r_offset
,
16152 ppc64_elf_howto_table
[r_type
]->name
,
16156 else if (r_symndx
== STN_UNDEF
|| bfd_is_abs_section (sec
))
16158 else if (sec
== NULL
|| sec
->owner
== NULL
)
16160 bfd_set_error (bfd_error_bad_value
);
16165 asection
*osec
= sec
->output_section
;
16167 if ((osec
->flags
& SEC_THREAD_LOCAL
) != 0)
16169 /* TLS symbol values are relative to the
16170 TLS segment. Dynamic relocations for
16171 local TLS symbols therefore can't be
16172 reduced to a relocation against their
16173 section symbol because it holds the
16174 address of the section, not a value
16175 relative to the TLS segment. We could
16176 change the .tdata dynamic section symbol
16177 to be zero value but STN_UNDEF works
16178 and is used elsewhere, eg. for TPREL64
16179 GOT relocs against local TLS symbols. */
16180 osec
= htab
->elf
.tls_sec
;
16185 indx
= elf_section_data (osec
)->dynindx
;
16188 if ((osec
->flags
& SEC_READONLY
) == 0
16189 && htab
->elf
.data_index_section
!= NULL
)
16190 osec
= htab
->elf
.data_index_section
;
16192 osec
= htab
->elf
.text_index_section
;
16193 indx
= elf_section_data (osec
)->dynindx
;
16195 BFD_ASSERT (indx
!= 0);
16198 /* We are turning this relocation into one
16199 against a section symbol, so subtract out
16200 the output section's address but not the
16201 offset of the input section in the output
16203 outrel
.r_addend
-= osec
->vma
;
16206 outrel
.r_info
= ELF64_R_INFO (indx
, r_type
);
16210 sreloc
= elf_section_data (input_section
)->sreloc
;
16212 ? h
->elf
.type
== STT_GNU_IFUNC
16213 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
16215 sreloc
= htab
->elf
.irelplt
;
16217 htab
->local_ifunc_resolver
= 1;
16218 else if (is_static_defined (&h
->elf
))
16219 htab
->maybe_local_ifunc_resolver
= 1;
16221 if (sreloc
== NULL
)
16224 if (sreloc
->reloc_count
* sizeof (Elf64_External_Rela
)
16227 loc
= sreloc
->contents
;
16228 loc
+= sreloc
->reloc_count
++ * sizeof (Elf64_External_Rela
);
16229 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
16231 if (!warned_dynamic
16232 && !ppc64_glibc_dynamic_reloc (ELF64_R_TYPE (outrel
.r_info
)))
16234 info
->callbacks
->einfo
16235 /* xgettext:c-format */
16236 (_("%X%P: %pB: %s against %pT "
16237 "is not supported by glibc as a dynamic relocation\n"),
16239 ppc64_elf_howto_table
[ELF64_R_TYPE (outrel
.r_info
)]->name
,
16241 warned_dynamic
= TRUE
;
16244 /* If this reloc is against an external symbol, it will
16245 be computed at runtime, so there's no need to do
16246 anything now. However, for the sake of prelink ensure
16247 that the section contents are a known value. */
16250 unresolved_reloc
= FALSE
;
16251 /* The value chosen here is quite arbitrary as ld.so
16252 ignores section contents except for the special
16253 case of .opd where the contents might be accessed
16254 before relocation. Choose zero, as that won't
16255 cause reloc overflow. */
16258 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
16259 to improve backward compatibility with older
16261 if (r_type
== R_PPC64_ADDR64
)
16262 addend
= outrel
.r_addend
;
16263 /* Adjust pc_relative relocs to have zero in *r_offset. */
16264 else if (ppc64_elf_howto_table
[r_type
]->pc_relative
)
16265 addend
= outrel
.r_offset
;
16271 case R_PPC64_GLOB_DAT
:
16272 case R_PPC64_JMP_SLOT
:
16273 case R_PPC64_JMP_IREL
:
16274 case R_PPC64_RELATIVE
:
16275 /* We shouldn't ever see these dynamic relocs in relocatable
16277 /* Fall through. */
16279 case R_PPC64_PLTGOT16
:
16280 case R_PPC64_PLTGOT16_DS
:
16281 case R_PPC64_PLTGOT16_HA
:
16282 case R_PPC64_PLTGOT16_HI
:
16283 case R_PPC64_PLTGOT16_LO
:
16284 case R_PPC64_PLTGOT16_LO_DS
:
16285 case R_PPC64_PLTREL32
:
16286 case R_PPC64_PLTREL64
:
16287 /* These ones haven't been implemented yet. */
16289 info
->callbacks
->einfo
16290 /* xgettext:c-format */
16291 (_("%P: %pB: %s is not supported for `%pT'\n"),
16293 ppc64_elf_howto_table
[r_type
]->name
, sym_name
);
16295 bfd_set_error (bfd_error_invalid_operation
);
16300 /* Multi-instruction sequences that access the TOC can be
16301 optimized, eg. addis ra,r2,0; addi rb,ra,x;
16302 to nop; addi rb,r2,x; */
16308 case R_PPC64_GOT_TLSLD16_HI
:
16309 case R_PPC64_GOT_TLSGD16_HI
:
16310 case R_PPC64_GOT_TPREL16_HI
:
16311 case R_PPC64_GOT_DTPREL16_HI
:
16312 case R_PPC64_GOT16_HI
:
16313 case R_PPC64_TOC16_HI
:
16314 /* These relocs would only be useful if building up an
16315 offset to later add to r2, perhaps in an indexed
16316 addressing mode instruction. Don't try to optimize.
16317 Unfortunately, the possibility of someone building up an
16318 offset like this or even with the HA relocs, means that
16319 we need to check the high insn when optimizing the low
16323 case R_PPC64_PLTCALL_NOTOC
:
16324 if (!unresolved_reloc
)
16325 htab
->notoc_plt
= 1;
16326 /* Fall through. */
16327 case R_PPC64_PLTCALL
:
16328 if (unresolved_reloc
)
16330 /* No plt entry. Make this into a direct call. */
16331 bfd_byte
*p
= contents
+ rel
->r_offset
;
16332 insn
= bfd_get_32 (input_bfd
, p
);
16334 bfd_put_32 (input_bfd
, B_DOT
| insn
, p
);
16335 if (r_type
== R_PPC64_PLTCALL
)
16336 bfd_put_32 (input_bfd
, NOP
, p
+ 4);
16337 unresolved_reloc
= save_unresolved_reloc
;
16338 r_type
= R_PPC64_REL24
;
16342 case R_PPC64_PLTSEQ_NOTOC
:
16343 case R_PPC64_PLTSEQ
:
16344 if (unresolved_reloc
)
16346 unresolved_reloc
= FALSE
;
16351 case R_PPC64_PLT_PCREL34_NOTOC
:
16352 if (!unresolved_reloc
)
16353 htab
->notoc_plt
= 1;
16354 /* Fall through. */
16355 case R_PPC64_PLT_PCREL34
:
16356 if (unresolved_reloc
)
16358 bfd_byte
*p
= contents
+ rel
->r_offset
;
16359 bfd_put_32 (input_bfd
, PNOP
>> 32, p
);
16360 bfd_put_32 (input_bfd
, PNOP
, p
+ 4);
16361 unresolved_reloc
= FALSE
;
16366 case R_PPC64_PLT16_HA
:
16367 if (unresolved_reloc
)
16369 unresolved_reloc
= FALSE
;
16372 /* Fall through. */
16373 case R_PPC64_GOT_TLSLD16_HA
:
16374 case R_PPC64_GOT_TLSGD16_HA
:
16375 case R_PPC64_GOT_TPREL16_HA
:
16376 case R_PPC64_GOT_DTPREL16_HA
:
16377 case R_PPC64_GOT16_HA
:
16378 case R_PPC64_TOC16_HA
:
16379 if (htab
->do_toc_opt
&& relocation
+ addend
+ 0x8000 < 0x10000
16380 && !ppc64_elf_tdata (input_bfd
)->unexpected_toc_insn
)
16384 p
= contents
+ (rel
->r_offset
& ~3);
16385 bfd_put_32 (input_bfd
, NOP
, p
);
16390 case R_PPC64_PLT16_LO
:
16391 case R_PPC64_PLT16_LO_DS
:
16392 if (unresolved_reloc
)
16394 unresolved_reloc
= FALSE
;
16397 /* Fall through. */
16398 case R_PPC64_GOT_TLSLD16_LO
:
16399 case R_PPC64_GOT_TLSGD16_LO
:
16400 case R_PPC64_GOT_TPREL16_LO_DS
:
16401 case R_PPC64_GOT_DTPREL16_LO_DS
:
16402 case R_PPC64_GOT16_LO
:
16403 case R_PPC64_GOT16_LO_DS
:
16404 case R_PPC64_TOC16_LO
:
16405 case R_PPC64_TOC16_LO_DS
:
16406 if (htab
->do_toc_opt
&& relocation
+ addend
+ 0x8000 < 0x10000
16407 && !ppc64_elf_tdata (input_bfd
)->unexpected_toc_insn
)
16409 bfd_byte
*p
= contents
+ (rel
->r_offset
& ~3);
16410 insn
= bfd_get_32 (input_bfd
, p
);
16411 if ((insn
& (0x3f << 26)) == 12u << 26 /* addic */)
16413 /* Transform addic to addi when we change reg. */
16414 insn
&= ~((0x3f << 26) | (0x1f << 16));
16415 insn
|= (14u << 26) | (2 << 16);
16419 insn
&= ~(0x1f << 16);
16422 bfd_put_32 (input_bfd
, insn
, p
);
16426 case R_PPC64_TPREL16_HA
:
16427 if (htab
->do_tls_opt
&& relocation
+ addend
+ 0x8000 < 0x10000)
16429 bfd_byte
*p
= contents
+ (rel
->r_offset
& ~3);
16430 insn
= bfd_get_32 (input_bfd
, p
);
16431 if ((insn
& ((0x3f << 26) | 0x1f << 16))
16432 != ((15u << 26) | (13 << 16)) /* addis rt,13,imm */)
16433 /* xgettext:c-format */
16434 info
->callbacks
->minfo
16435 (_("%H: warning: %s unexpected insn %#x.\n"),
16436 input_bfd
, input_section
, rel
->r_offset
,
16437 ppc64_elf_howto_table
[r_type
]->name
, insn
);
16440 bfd_put_32 (input_bfd
, NOP
, p
);
16446 case R_PPC64_TPREL16_LO
:
16447 case R_PPC64_TPREL16_LO_DS
:
16448 if (htab
->do_tls_opt
&& relocation
+ addend
+ 0x8000 < 0x10000)
16450 bfd_byte
*p
= contents
+ (rel
->r_offset
& ~3);
16451 insn
= bfd_get_32 (input_bfd
, p
);
16452 insn
&= ~(0x1f << 16);
16454 bfd_put_32 (input_bfd
, insn
, p
);
16459 /* Do any further special processing. */
16465 case R_PPC64_REL16_HA
:
16466 case R_PPC64_REL16_HIGHA
:
16467 case R_PPC64_REL16_HIGHERA
:
16468 case R_PPC64_REL16_HIGHESTA
:
16469 case R_PPC64_REL16DX_HA
:
16470 case R_PPC64_ADDR16_HA
:
16471 case R_PPC64_ADDR16_HIGHA
:
16472 case R_PPC64_ADDR16_HIGHERA
:
16473 case R_PPC64_ADDR16_HIGHESTA
:
16474 case R_PPC64_TOC16_HA
:
16475 case R_PPC64_SECTOFF_HA
:
16476 case R_PPC64_TPREL16_HA
:
16477 case R_PPC64_TPREL16_HIGHA
:
16478 case R_PPC64_TPREL16_HIGHERA
:
16479 case R_PPC64_TPREL16_HIGHESTA
:
16480 case R_PPC64_DTPREL16_HA
:
16481 case R_PPC64_DTPREL16_HIGHA
:
16482 case R_PPC64_DTPREL16_HIGHERA
:
16483 case R_PPC64_DTPREL16_HIGHESTA
:
16484 /* It's just possible that this symbol is a weak symbol
16485 that's not actually defined anywhere. In that case,
16486 'sec' would be NULL, and we should leave the symbol
16487 alone (it will be set to zero elsewhere in the link). */
16490 /* Fall through. */
16492 case R_PPC64_GOT16_HA
:
16493 case R_PPC64_PLTGOT16_HA
:
16494 case R_PPC64_PLT16_HA
:
16495 case R_PPC64_GOT_TLSGD16_HA
:
16496 case R_PPC64_GOT_TLSLD16_HA
:
16497 case R_PPC64_GOT_TPREL16_HA
:
16498 case R_PPC64_GOT_DTPREL16_HA
:
16499 /* Add 0x10000 if sign bit in 0:15 is set.
16500 Bits 0:15 are not used. */
16504 case R_PPC64_D34_HA30
:
16505 case R_PPC64_ADDR16_HIGHERA34
:
16506 case R_PPC64_ADDR16_HIGHESTA34
:
16507 case R_PPC64_REL16_HIGHERA34
:
16508 case R_PPC64_REL16_HIGHESTA34
:
16510 addend
+= 1ULL << 33;
16513 case R_PPC64_ADDR16_DS
:
16514 case R_PPC64_ADDR16_LO_DS
:
16515 case R_PPC64_GOT16_DS
:
16516 case R_PPC64_GOT16_LO_DS
:
16517 case R_PPC64_PLT16_LO_DS
:
16518 case R_PPC64_SECTOFF_DS
:
16519 case R_PPC64_SECTOFF_LO_DS
:
16520 case R_PPC64_TOC16_DS
:
16521 case R_PPC64_TOC16_LO_DS
:
16522 case R_PPC64_PLTGOT16_DS
:
16523 case R_PPC64_PLTGOT16_LO_DS
:
16524 case R_PPC64_GOT_TPREL16_DS
:
16525 case R_PPC64_GOT_TPREL16_LO_DS
:
16526 case R_PPC64_GOT_DTPREL16_DS
:
16527 case R_PPC64_GOT_DTPREL16_LO_DS
:
16528 case R_PPC64_TPREL16_DS
:
16529 case R_PPC64_TPREL16_LO_DS
:
16530 case R_PPC64_DTPREL16_DS
:
16531 case R_PPC64_DTPREL16_LO_DS
:
16532 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
16534 /* If this reloc is against an lq, lxv, or stxv insn, then
16535 the value must be a multiple of 16. This is somewhat of
16536 a hack, but the "correct" way to do this by defining _DQ
16537 forms of all the _DS relocs bloats all reloc switches in
16538 this file. It doesn't make much sense to use these
16539 relocs in data, so testing the insn should be safe. */
16540 if ((insn
& (0x3f << 26)) == (56u << 26)
16541 || ((insn
& (0x3f << 26)) == (61u << 26) && (insn
& 3) == 1))
16543 relocation
+= addend
;
16544 addend
= insn
& (mask
^ 3);
16545 if ((relocation
& mask
) != 0)
16547 relocation
^= relocation
& mask
;
16548 info
->callbacks
->einfo
16549 /* xgettext:c-format */
16550 (_("%H: error: %s not a multiple of %u\n"),
16551 input_bfd
, input_section
, rel
->r_offset
,
16552 ppc64_elf_howto_table
[r_type
]->name
,
16554 bfd_set_error (bfd_error_bad_value
);
16561 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
16562 because such sections are not SEC_ALLOC and thus ld.so will
16563 not process them. */
16564 howto
= ppc64_elf_howto_table
[(int) r_type
];
16565 if (unresolved_reloc
16566 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
16567 && h
->elf
.def_dynamic
)
16568 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
16569 rel
->r_offset
) != (bfd_vma
) -1)
16571 info
->callbacks
->einfo
16572 /* xgettext:c-format */
16573 (_("%H: unresolvable %s against `%pT'\n"),
16574 input_bfd
, input_section
, rel
->r_offset
,
16576 h
->elf
.root
.root
.string
);
16580 /* 16-bit fields in insns mostly have signed values, but a
16581 few insns have 16-bit unsigned values. Really, we should
16582 have different reloc types. */
16583 if (howto
->complain_on_overflow
!= complain_overflow_dont
16584 && howto
->dst_mask
== 0xffff
16585 && (input_section
->flags
& SEC_CODE
) != 0)
16587 enum complain_overflow complain
= complain_overflow_signed
;
16589 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
16590 if ((insn
& (0x3f << 26)) == 10u << 26 /* cmpli */)
16591 complain
= complain_overflow_bitfield
;
16592 else if (howto
->rightshift
== 0
16593 ? ((insn
& (0x3f << 26)) == 28u << 26 /* andi */
16594 || (insn
& (0x3f << 26)) == 24u << 26 /* ori */
16595 || (insn
& (0x3f << 26)) == 26u << 26 /* xori */)
16596 : ((insn
& (0x3f << 26)) == 29u << 26 /* andis */
16597 || (insn
& (0x3f << 26)) == 25u << 26 /* oris */
16598 || (insn
& (0x3f << 26)) == 27u << 26 /* xoris */))
16599 complain
= complain_overflow_unsigned
;
16600 if (howto
->complain_on_overflow
!= complain
)
16602 alt_howto
= *howto
;
16603 alt_howto
.complain_on_overflow
= complain
;
16604 howto
= &alt_howto
;
16610 /* Split field relocs aren't handled by _bfd_final_link_relocate. */
16612 case R_PPC64_D34_LO
:
16613 case R_PPC64_D34_HI30
:
16614 case R_PPC64_D34_HA30
:
16615 case R_PPC64_PCREL34
:
16616 case R_PPC64_GOT_PCREL34
:
16617 case R_PPC64_TPREL34
:
16618 case R_PPC64_DTPREL34
:
16619 case R_PPC64_GOT_TLSGD34
:
16620 case R_PPC64_GOT_TLSLD34
:
16621 case R_PPC64_GOT_TPREL34
:
16622 case R_PPC64_GOT_DTPREL34
:
16623 case R_PPC64_PLT_PCREL34
:
16624 case R_PPC64_PLT_PCREL34_NOTOC
:
16626 case R_PPC64_PCREL28
:
16627 if (rel
->r_offset
+ 8 > input_section
->size
)
16628 r
= bfd_reloc_outofrange
;
16631 relocation
+= addend
;
16632 if (howto
->pc_relative
)
16633 relocation
-= (rel
->r_offset
16634 + input_section
->output_offset
16635 + input_section
->output_section
->vma
);
16636 relocation
>>= howto
->rightshift
;
16638 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
16640 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
16642 pinsn
&= ~howto
->dst_mask
;
16643 pinsn
|= (((relocation
<< 16) | (relocation
& 0xffff))
16644 & howto
->dst_mask
);
16645 bfd_put_32 (input_bfd
, pinsn
>> 32, contents
+ rel
->r_offset
);
16646 bfd_put_32 (input_bfd
, pinsn
, contents
+ rel
->r_offset
+ 4);
16648 if (howto
->complain_on_overflow
== complain_overflow_signed
16649 && (relocation
+ (1ULL << (howto
->bitsize
- 1))
16650 >= 1ULL << howto
->bitsize
))
16651 r
= bfd_reloc_overflow
;
16655 case R_PPC64_REL16DX_HA
:
16656 if (rel
->r_offset
+ 4 > input_section
->size
)
16657 r
= bfd_reloc_outofrange
;
16660 relocation
+= addend
;
16661 relocation
-= (rel
->r_offset
16662 + input_section
->output_offset
16663 + input_section
->output_section
->vma
);
16664 relocation
= (bfd_signed_vma
) relocation
>> 16;
16665 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
16667 insn
|= (relocation
& 0xffc1) | ((relocation
& 0x3e) << 15);
16668 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
16670 if (relocation
+ 0x8000 > 0xffff)
16671 r
= bfd_reloc_overflow
;
16676 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
16677 contents
, rel
->r_offset
,
16678 relocation
, addend
);
16681 if (r
!= bfd_reloc_ok
)
16683 char *more_info
= NULL
;
16684 const char *reloc_name
= howto
->name
;
16686 if (reloc_dest
!= DEST_NORMAL
)
16688 more_info
= bfd_malloc (strlen (reloc_name
) + 8);
16689 if (more_info
!= NULL
)
16691 strcpy (more_info
, reloc_name
);
16692 strcat (more_info
, (reloc_dest
== DEST_OPD
16693 ? " (OPD)" : " (stub)"));
16694 reloc_name
= more_info
;
16698 if (r
== bfd_reloc_overflow
)
16700 /* On code like "if (foo) foo();" don't report overflow
16701 on a branch to zero when foo is undefined. */
16703 && (reloc_dest
== DEST_STUB
16705 && (h
->elf
.root
.type
== bfd_link_hash_undefweak
16706 || h
->elf
.root
.type
== bfd_link_hash_undefined
)
16707 && is_branch_reloc (r_type
))))
16708 info
->callbacks
->reloc_overflow (info
, &h
->elf
.root
,
16709 sym_name
, reloc_name
,
16711 input_bfd
, input_section
,
16716 info
->callbacks
->einfo
16717 /* xgettext:c-format */
16718 (_("%H: %s against `%pT': error %d\n"),
16719 input_bfd
, input_section
, rel
->r_offset
,
16720 reloc_name
, sym_name
, (int) r
);
16723 if (more_info
!= NULL
)
16733 Elf_Internal_Shdr
*rel_hdr
;
16734 size_t deleted
= rel
- wrel
;
16736 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
16737 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
16738 if (rel_hdr
->sh_size
== 0)
16740 /* It is too late to remove an empty reloc section. Leave
16742 ??? What is wrong with an empty section??? */
16743 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
16746 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
16747 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
16748 input_section
->reloc_count
-= deleted
;
16751 /* If we're emitting relocations, then shortly after this function
16752 returns, reloc offsets and addends for this section will be
16753 adjusted. Worse, reloc symbol indices will be for the output
16754 file rather than the input. Save a copy of the relocs for
16755 opd_entry_value. */
16756 if (is_opd
&& (info
->emitrelocations
|| bfd_link_relocatable (info
)))
16759 amt
= input_section
->reloc_count
* sizeof (Elf_Internal_Rela
);
16760 rel
= bfd_alloc (input_bfd
, amt
);
16761 BFD_ASSERT (ppc64_elf_tdata (input_bfd
)->opd
.relocs
== NULL
);
16762 ppc64_elf_tdata (input_bfd
)->opd
.relocs
= rel
;
16765 memcpy (rel
, relocs
, amt
);
16770 /* Adjust the value of any local symbols in opd sections. */
16773 ppc64_elf_output_symbol_hook (struct bfd_link_info
*info
,
16774 const char *name ATTRIBUTE_UNUSED
,
16775 Elf_Internal_Sym
*elfsym
,
16776 asection
*input_sec
,
16777 struct elf_link_hash_entry
*h
)
16779 struct _opd_sec_data
*opd
;
16786 opd
= get_opd_info (input_sec
);
16787 if (opd
== NULL
|| opd
->adjust
== NULL
)
16790 value
= elfsym
->st_value
- input_sec
->output_offset
;
16791 if (!bfd_link_relocatable (info
))
16792 value
-= input_sec
->output_section
->vma
;
16794 adjust
= opd
->adjust
[OPD_NDX (value
)];
16798 elfsym
->st_value
+= adjust
;
16802 /* Finish up dynamic symbol handling. We set the contents of various
16803 dynamic sections here. */
16806 ppc64_elf_finish_dynamic_symbol (bfd
*output_bfd
,
16807 struct bfd_link_info
*info
,
16808 struct elf_link_hash_entry
*h
,
16809 Elf_Internal_Sym
*sym
)
16811 struct ppc_link_hash_table
*htab
;
16812 struct plt_entry
*ent
;
16814 htab
= ppc_hash_table (info
);
16818 if (!htab
->opd_abi
&& !h
->def_regular
)
16819 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
16820 if (ent
->plt
.offset
!= (bfd_vma
) -1)
16822 /* Mark the symbol as undefined, rather than as
16823 defined in glink. Leave the value if there were
16824 any relocations where pointer equality matters
16825 (this is a clue for the dynamic linker, to make
16826 function pointer comparisons work between an
16827 application and shared library), otherwise set it
16829 sym
->st_shndx
= SHN_UNDEF
;
16830 if (!h
->pointer_equality_needed
)
16832 else if (!h
->ref_regular_nonweak
)
16834 /* This breaks function pointer comparisons, but
16835 that is better than breaking tests for a NULL
16836 function pointer. */
16843 && (h
->root
.type
== bfd_link_hash_defined
16844 || h
->root
.type
== bfd_link_hash_defweak
)
16845 && (h
->root
.u
.def
.section
== htab
->elf
.sdynbss
16846 || h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
))
16848 /* This symbol needs a copy reloc. Set it up. */
16849 Elf_Internal_Rela rela
;
16853 if (h
->dynindx
== -1)
16856 rela
.r_offset
= (h
->root
.u
.def
.value
16857 + h
->root
.u
.def
.section
->output_section
->vma
16858 + h
->root
.u
.def
.section
->output_offset
);
16859 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_PPC64_COPY
);
16861 if (h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
16862 srel
= htab
->elf
.sreldynrelro
;
16864 srel
= htab
->elf
.srelbss
;
16865 loc
= srel
->contents
;
16866 loc
+= srel
->reloc_count
++ * sizeof (Elf64_External_Rela
);
16867 bfd_elf64_swap_reloca_out (output_bfd
, &rela
, loc
);
16873 /* Used to decide how to sort relocs in an optimal manner for the
16874 dynamic linker, before writing them out. */
16876 static enum elf_reloc_type_class
16877 ppc64_elf_reloc_type_class (const struct bfd_link_info
*info
,
16878 const asection
*rel_sec
,
16879 const Elf_Internal_Rela
*rela
)
16881 enum elf_ppc64_reloc_type r_type
;
16882 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
16884 if (rel_sec
== htab
->elf
.irelplt
)
16885 return reloc_class_ifunc
;
16887 r_type
= ELF64_R_TYPE (rela
->r_info
);
16890 case R_PPC64_RELATIVE
:
16891 return reloc_class_relative
;
16892 case R_PPC64_JMP_SLOT
:
16893 return reloc_class_plt
;
16895 return reloc_class_copy
;
16897 return reloc_class_normal
;
16901 /* Finish up the dynamic sections. */
16904 ppc64_elf_finish_dynamic_sections (bfd
*output_bfd
,
16905 struct bfd_link_info
*info
)
16907 struct ppc_link_hash_table
*htab
;
16911 htab
= ppc_hash_table (info
);
16915 dynobj
= htab
->elf
.dynobj
;
16916 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
16918 if (htab
->elf
.dynamic_sections_created
)
16920 Elf64_External_Dyn
*dyncon
, *dynconend
;
16922 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
16925 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
16926 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
16927 for (; dyncon
< dynconend
; dyncon
++)
16929 Elf_Internal_Dyn dyn
;
16932 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
16939 case DT_PPC64_GLINK
:
16941 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
16942 /* We stupidly defined DT_PPC64_GLINK to be the start
16943 of glink rather than the first entry point, which is
16944 what ld.so needs, and now have a bigger stub to
16945 support automatic multiple TOCs. */
16946 dyn
.d_un
.d_ptr
+= GLINK_PLTRESOLVE_SIZE (htab
) - 8 * 4;
16950 s
= bfd_get_section_by_name (output_bfd
, ".opd");
16953 dyn
.d_un
.d_ptr
= s
->vma
;
16957 if ((htab
->do_multi_toc
&& htab
->multi_toc_needed
)
16958 || htab
->notoc_plt
)
16959 dyn
.d_un
.d_val
|= PPC64_OPT_MULTI_TOC
;
16960 if (htab
->has_plt_localentry0
)
16961 dyn
.d_un
.d_val
|= PPC64_OPT_LOCALENTRY
;
16964 case DT_PPC64_OPDSZ
:
16965 s
= bfd_get_section_by_name (output_bfd
, ".opd");
16968 dyn
.d_un
.d_val
= s
->size
;
16972 s
= htab
->elf
.splt
;
16973 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
16977 s
= htab
->elf
.srelplt
;
16978 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
16982 dyn
.d_un
.d_val
= htab
->elf
.srelplt
->size
;
16986 if (htab
->local_ifunc_resolver
)
16987 info
->callbacks
->einfo
16988 (_("%X%P: text relocations and GNU indirect "
16989 "functions will result in a segfault at runtime\n"));
16990 else if (htab
->maybe_local_ifunc_resolver
)
16991 info
->callbacks
->einfo
16992 (_("%P: warning: text relocations and GNU indirect "
16993 "functions may result in a segfault at runtime\n"));
16997 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
17001 if (htab
->elf
.sgot
!= NULL
&& htab
->elf
.sgot
->size
!= 0
17002 && htab
->elf
.sgot
->output_section
!= bfd_abs_section_ptr
)
17004 /* Fill in the first entry in the global offset table.
17005 We use it to hold the link-time TOCbase. */
17006 bfd_put_64 (output_bfd
,
17007 elf_gp (output_bfd
) + TOC_BASE_OFF
,
17008 htab
->elf
.sgot
->contents
);
17010 /* Set .got entry size. */
17011 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
17015 if (htab
->elf
.splt
!= NULL
&& htab
->elf
.splt
->size
!= 0
17016 && htab
->elf
.splt
->output_section
!= bfd_abs_section_ptr
)
17018 /* Set .plt entry size. */
17019 elf_section_data (htab
->elf
.splt
->output_section
)->this_hdr
.sh_entsize
17020 = PLT_ENTRY_SIZE (htab
);
17023 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
17024 brlt ourselves if emitrelocations. */
17025 if (htab
->brlt
!= NULL
17026 && htab
->brlt
->reloc_count
!= 0
17027 && !_bfd_elf_link_output_relocs (output_bfd
,
17029 elf_section_data (htab
->brlt
)->rela
.hdr
,
17030 elf_section_data (htab
->brlt
)->relocs
,
17034 if (htab
->glink
!= NULL
17035 && htab
->glink
->reloc_count
!= 0
17036 && !_bfd_elf_link_output_relocs (output_bfd
,
17038 elf_section_data (htab
->glink
)->rela
.hdr
,
17039 elf_section_data (htab
->glink
)->relocs
,
17044 if (htab
->glink_eh_frame
!= NULL
17045 && htab
->glink_eh_frame
->size
!= 0
17046 && htab
->glink_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
17047 && !_bfd_elf_write_section_eh_frame (output_bfd
, info
,
17048 htab
->glink_eh_frame
,
17049 htab
->glink_eh_frame
->contents
))
17052 /* We need to handle writing out multiple GOT sections ourselves,
17053 since we didn't add them to DYNOBJ. We know dynobj is the first
17055 while ((dynobj
= dynobj
->link
.next
) != NULL
)
17059 if (!is_ppc64_elf (dynobj
))
17062 s
= ppc64_elf_tdata (dynobj
)->got
;
17065 && s
->output_section
!= bfd_abs_section_ptr
17066 && !bfd_set_section_contents (output_bfd
, s
->output_section
,
17067 s
->contents
, s
->output_offset
,
17070 s
= ppc64_elf_tdata (dynobj
)->relgot
;
17073 && s
->output_section
!= bfd_abs_section_ptr
17074 && !bfd_set_section_contents (output_bfd
, s
->output_section
,
17075 s
->contents
, s
->output_offset
,
17083 #include "elf64-target.h"
17085 /* FreeBSD support */
17087 #undef TARGET_LITTLE_SYM
17088 #undef TARGET_LITTLE_NAME
17090 #undef TARGET_BIG_SYM
17091 #define TARGET_BIG_SYM powerpc_elf64_fbsd_vec
17092 #undef TARGET_BIG_NAME
17093 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
17096 #define ELF_OSABI ELFOSABI_FREEBSD
17099 #define elf64_bed elf64_powerpc_fbsd_bed
17101 #include "elf64-target.h"