1 /* PowerPC64-specific support for 64-bit ELF.
2 Copyright (C) 1999-2019 Free Software Foundation, Inc.
3 Written by Linus Nordberg, Swox AB <info@swox.com>,
4 based on elf32-ppc.c by Ian Lance Taylor.
5 Largely rewritten by Alan Modra.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License along
20 with this program; if not, write to the Free Software Foundation, Inc.,
21 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
24 /* The 64-bit PowerPC ELF ABI may be found at
25 http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
26 http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html */
34 #include "elf/ppc64.h"
35 #include "elf64-ppc.h"
38 static bfd_reloc_status_type ppc64_elf_ha_reloc
39 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
40 static bfd_reloc_status_type ppc64_elf_branch_reloc
41 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
43 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
45 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
47 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
48 static bfd_reloc_status_type ppc64_elf_toc_reloc
49 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
51 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
53 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
54 static bfd_reloc_status_type ppc64_elf_prefix_reloc
55 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
56 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
57 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
58 static bfd_vma opd_entry_value
59 (asection
*, bfd_vma
, asection
**, bfd_vma
*, bfd_boolean
);
61 #define TARGET_LITTLE_SYM powerpc_elf64_le_vec
62 #define TARGET_LITTLE_NAME "elf64-powerpcle"
63 #define TARGET_BIG_SYM powerpc_elf64_vec
64 #define TARGET_BIG_NAME "elf64-powerpc"
65 #define ELF_ARCH bfd_arch_powerpc
66 #define ELF_TARGET_ID PPC64_ELF_DATA
67 #define ELF_MACHINE_CODE EM_PPC64
68 #define ELF_MAXPAGESIZE 0x10000
69 #define ELF_COMMONPAGESIZE 0x1000
70 #define ELF_RELROPAGESIZE ELF_MAXPAGESIZE
71 #define elf_info_to_howto ppc64_elf_info_to_howto
73 #define elf_backend_want_got_sym 0
74 #define elf_backend_want_plt_sym 0
75 #define elf_backend_plt_alignment 3
76 #define elf_backend_plt_not_loaded 1
77 #define elf_backend_got_header_size 8
78 #define elf_backend_want_dynrelro 1
79 #define elf_backend_can_gc_sections 1
80 #define elf_backend_can_refcount 1
81 #define elf_backend_rela_normal 1
82 #define elf_backend_dtrel_excludes_plt 1
83 #define elf_backend_default_execstack 0
85 #define bfd_elf64_mkobject ppc64_elf_mkobject
86 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
87 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
88 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
89 #define bfd_elf64_bfd_print_private_bfd_data ppc64_elf_print_private_bfd_data
90 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
91 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
92 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
93 #define bfd_elf64_bfd_link_just_syms ppc64_elf_link_just_syms
94 #define bfd_elf64_bfd_gc_sections ppc64_elf_gc_sections
96 #define elf_backend_object_p ppc64_elf_object_p
97 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
98 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
99 #define elf_backend_write_core_note ppc64_elf_write_core_note
100 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
101 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
102 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
103 #define elf_backend_check_directives ppc64_elf_before_check_relocs
104 #define elf_backend_notice_as_needed ppc64_elf_notice_as_needed
105 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
106 #define elf_backend_check_relocs ppc64_elf_check_relocs
107 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
108 #define elf_backend_gc_keep ppc64_elf_gc_keep
109 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
110 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
111 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
112 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
113 #define elf_backend_maybe_function_sym ppc64_elf_maybe_function_sym
114 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
115 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
116 #define elf_backend_hash_symbol ppc64_elf_hash_symbol
117 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
118 #define elf_backend_action_discarded ppc64_elf_action_discarded
119 #define elf_backend_relocate_section ppc64_elf_relocate_section
120 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
121 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
122 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
123 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
124 #define elf_backend_special_sections ppc64_elf_special_sections
125 #define elf_backend_merge_symbol_attribute ppc64_elf_merge_symbol_attribute
126 #define elf_backend_merge_symbol ppc64_elf_merge_symbol
127 #define elf_backend_get_reloc_section bfd_get_section_by_name
129 /* The name of the dynamic interpreter. This is put in the .interp
131 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
133 /* The size in bytes of an entry in the procedure linkage table. */
134 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
135 #define LOCAL_PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 16 : 8)
137 /* The initial size of the plt reserved for the dynamic linker. */
138 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
140 /* Offsets to some stack save slots. */
142 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
143 /* This one is dodgy. ELFv2 does not have a linker word, so use the
144 CR save slot. Used only by optimised __tls_get_addr call stub,
145 relying on __tls_get_addr_opt not saving CR.. */
146 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
148 /* TOC base pointers offset from start of TOC. */
149 #define TOC_BASE_OFF 0x8000
150 /* TOC base alignment. */
151 #define TOC_BASE_ALIGN 256
153 /* Offset of tp and dtp pointers from start of TLS block. */
154 #define TP_OFFSET 0x7000
155 #define DTP_OFFSET 0x8000
157 /* .plt call stub instructions. The normal stub is like this, but
158 sometimes the .plt entry crosses a 64k boundary and we need to
159 insert an addi to adjust r11. */
160 #define STD_R2_0R1 0xf8410000 /* std %r2,0+40(%r1) */
161 #define ADDIS_R11_R2 0x3d620000 /* addis %r11,%r2,xxx@ha */
162 #define LD_R12_0R11 0xe98b0000 /* ld %r12,xxx+0@l(%r11) */
163 #define MTCTR_R12 0x7d8903a6 /* mtctr %r12 */
164 #define LD_R2_0R11 0xe84b0000 /* ld %r2,xxx+8@l(%r11) */
165 #define LD_R11_0R11 0xe96b0000 /* ld %r11,xxx+16@l(%r11) */
166 #define BCTR 0x4e800420 /* bctr */
168 #define ADDI_R11_R11 0x396b0000 /* addi %r11,%r11,off@l */
169 #define ADDI_R12_R11 0x398b0000 /* addi %r12,%r11,off@l */
170 #define ADDI_R12_R12 0x398c0000 /* addi %r12,%r12,off@l */
171 #define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
172 #define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
174 #define XOR_R2_R12_R12 0x7d826278 /* xor %r2,%r12,%r12 */
175 #define ADD_R11_R11_R2 0x7d6b1214 /* add %r11,%r11,%r2 */
176 #define XOR_R11_R12_R12 0x7d8b6278 /* xor %r11,%r12,%r12 */
177 #define ADD_R2_R2_R11 0x7c425a14 /* add %r2,%r2,%r11 */
178 #define CMPLDI_R2_0 0x28220000 /* cmpldi %r2,0 */
179 #define BNECTR 0x4ca20420 /* bnectr+ */
180 #define BNECTR_P4 0x4ce20420 /* bnectr+ */
182 #define LD_R12_0R2 0xe9820000 /* ld %r12,xxx+0(%r2) */
183 #define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
184 #define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
186 #define LD_R2_0R1 0xe8410000 /* ld %r2,0(%r1) */
187 #define LD_R2_0R12 0xe84c0000 /* ld %r2,0(%r12) */
188 #define ADD_R2_R2_R12 0x7c426214 /* add %r2,%r2,%r12 */
190 #define LI_R11_0 0x39600000 /* li %r11,0 */
191 #define LIS_R2 0x3c400000 /* lis %r2,xxx@ha */
192 #define LIS_R11 0x3d600000 /* lis %r11,xxx@ha */
193 #define LIS_R12 0x3d800000 /* lis %r12,xxx@ha */
194 #define ADDIS_R2_R12 0x3c4c0000 /* addis %r2,%r12,xxx@ha */
195 #define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
196 #define ADDIS_R12_R11 0x3d8b0000 /* addis %r12,%r11,xxx@ha */
197 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,xxx@ha */
198 #define ORIS_R12_R12_0 0x658c0000 /* oris %r12,%r12,xxx@hi */
199 #define ORI_R11_R11_0 0x616b0000 /* ori %r11,%r11,xxx@l */
200 #define ORI_R12_R12_0 0x618c0000 /* ori %r12,%r12,xxx@l */
201 #define LD_R12_0R12 0xe98c0000 /* ld %r12,xxx@l(%r12) */
202 #define SLDI_R11_R11_34 0x796b1746 /* sldi %r11,%r11,34 */
203 #define SLDI_R12_R12_32 0x799c07c6 /* sldi %r12,%r12,32 */
204 #define LDX_R12_R11_R12 0x7d8b602a /* ldx %r12,%r11,%r12 */
205 #define ADD_R12_R11_R12 0x7d8b6214 /* add %r12,%r11,%r12 */
206 #define PADDI_R12_PC 0x0610000039800000ULL
207 #define PLD_R12_PC 0x04100000e5800000ULL
208 #define PNOP 0x0700000000000000ULL
210 /* __glink_PLTresolve stub instructions. We enter with the index in R0. */
211 #define GLINK_PLTRESOLVE_SIZE(htab) \
212 (8u + (htab->opd_abi ? 11 * 4 : 14 * 4))
216 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
217 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
219 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
220 /* ld %2,(0b-1b)(%11) */
221 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
222 #define ADD_R11_R2_R11 0x7d625a14 /* add %11,%2,%11 */
228 #define MFLR_R0 0x7c0802a6 /* mflr %r0 */
229 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
230 #define SUB_R12_R12_R11 0x7d8b6050 /* subf %r12,%r11,%r12 */
231 #define ADDI_R0_R12 0x380c0000 /* addi %r0,%r12,0 */
232 #define SRDI_R0_R0_2 0x7800f082 /* rldicl %r0,%r0,62,2 */
235 #define NOP 0x60000000
237 /* Some other nops. */
238 #define CROR_151515 0x4def7b82
239 #define CROR_313131 0x4ffffb82
241 /* .glink entries for the first 32k functions are two instructions. */
242 #define LI_R0_0 0x38000000 /* li %r0,0 */
243 #define B_DOT 0x48000000 /* b . */
245 /* After that, we need two instructions to load the index, followed by
247 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
248 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
250 /* Instructions used by the save and restore reg functions. */
251 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
252 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
253 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
254 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
255 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
256 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
257 #define LI_R12_0 0x39800000 /* li %r12,0 */
258 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
259 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
260 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
261 #define BLR 0x4e800020 /* blr */
263 /* Since .opd is an array of descriptors and each entry will end up
264 with identical R_PPC64_RELATIVE relocs, there is really no need to
265 propagate .opd relocs; The dynamic linker should be taught to
266 relocate .opd without reloc entries. */
267 #ifndef NO_OPD_RELOCS
268 #define NO_OPD_RELOCS 0
272 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
276 abiversion (bfd
*abfd
)
278 return elf_elfheader (abfd
)->e_flags
& EF_PPC64_ABI
;
282 set_abiversion (bfd
*abfd
, int ver
)
284 elf_elfheader (abfd
)->e_flags
&= ~EF_PPC64_ABI
;
285 elf_elfheader (abfd
)->e_flags
|= ver
& EF_PPC64_ABI
;
288 /* Relocation HOWTO's. */
289 /* Like other ELF RELA targets that don't apply multiple
290 field-altering relocations to the same localation, src_mask is
291 always zero and pcrel_offset is the same as pc_relative.
292 PowerPC can always use a zero bitpos, even when the field is not at
293 the LSB. For example, a REL24 could use rightshift=2, bisize=24
294 and bitpos=2 which matches the ABI description, or as we do here,
295 rightshift=0, bitsize=26 and bitpos=0. */
296 #define HOW(type, size, bitsize, mask, rightshift, pc_relative, \
297 complain, special_func) \
298 HOWTO (type, rightshift, size, bitsize, pc_relative, 0, \
299 complain_overflow_ ## complain, special_func, \
300 #type, FALSE, 0, mask, pc_relative)
302 static reloc_howto_type
*ppc64_elf_howto_table
[(int) R_PPC64_max
];
304 static reloc_howto_type ppc64_elf_howto_raw
[] =
306 /* This reloc does nothing. */
307 HOW (R_PPC64_NONE
, 3, 0, 0, 0, FALSE
, dont
,
308 bfd_elf_generic_reloc
),
310 /* A standard 32 bit relocation. */
311 HOW (R_PPC64_ADDR32
, 2, 32, 0xffffffff, 0, FALSE
, bitfield
,
312 bfd_elf_generic_reloc
),
314 /* An absolute 26 bit branch; the lower two bits must be zero.
315 FIXME: we don't check that, we just clear them. */
316 HOW (R_PPC64_ADDR24
, 2, 26, 0x03fffffc, 0, FALSE
, bitfield
,
317 bfd_elf_generic_reloc
),
319 /* A standard 16 bit relocation. */
320 HOW (R_PPC64_ADDR16
, 1, 16, 0xffff, 0, FALSE
, bitfield
,
321 bfd_elf_generic_reloc
),
323 /* A 16 bit relocation without overflow. */
324 HOW (R_PPC64_ADDR16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
325 bfd_elf_generic_reloc
),
327 /* Bits 16-31 of an address. */
328 HOW (R_PPC64_ADDR16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
329 bfd_elf_generic_reloc
),
331 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
332 bits, treated as a signed number, is negative. */
333 HOW (R_PPC64_ADDR16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
336 /* An absolute 16 bit branch; the lower two bits must be zero.
337 FIXME: we don't check that, we just clear them. */
338 HOW (R_PPC64_ADDR14
, 2, 16, 0x0000fffc, 0, FALSE
, signed,
339 ppc64_elf_branch_reloc
),
341 /* An absolute 16 bit branch, for which bit 10 should be set to
342 indicate that the branch is expected to be taken. The lower two
343 bits must be zero. */
344 HOW (R_PPC64_ADDR14_BRTAKEN
, 2, 16, 0x0000fffc, 0, FALSE
, signed,
345 ppc64_elf_brtaken_reloc
),
347 /* An absolute 16 bit branch, for which bit 10 should be set to
348 indicate that the branch is not expected to be taken. The lower
349 two bits must be zero. */
350 HOW (R_PPC64_ADDR14_BRNTAKEN
, 2, 16, 0x0000fffc, 0, FALSE
, signed,
351 ppc64_elf_brtaken_reloc
),
353 /* A relative 26 bit branch; the lower two bits must be zero. */
354 HOW (R_PPC64_REL24
, 2, 26, 0x03fffffc, 0, TRUE
, signed,
355 ppc64_elf_branch_reloc
),
357 /* A variant of R_PPC64_REL24, used when r2 is not the toc pointer. */
358 HOW (R_PPC64_REL24_NOTOC
, 2, 26, 0x03fffffc, 0, TRUE
, signed,
359 ppc64_elf_branch_reloc
),
361 /* A relative 16 bit branch; the lower two bits must be zero. */
362 HOW (R_PPC64_REL14
, 2, 16, 0x0000fffc, 0, TRUE
, signed,
363 ppc64_elf_branch_reloc
),
365 /* A relative 16 bit branch. Bit 10 should be set to indicate that
366 the branch is expected to be taken. The lower two bits must be
368 HOW (R_PPC64_REL14_BRTAKEN
, 2, 16, 0x0000fffc, 0, TRUE
, signed,
369 ppc64_elf_brtaken_reloc
),
371 /* A relative 16 bit branch. Bit 10 should be set to indicate that
372 the branch is not expected to be taken. The lower two bits must
374 HOW (R_PPC64_REL14_BRNTAKEN
, 2, 16, 0x0000fffc, 0, TRUE
, signed,
375 ppc64_elf_brtaken_reloc
),
377 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
379 HOW (R_PPC64_GOT16
, 1, 16, 0xffff, 0, FALSE
, signed,
380 ppc64_elf_unhandled_reloc
),
382 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
384 HOW (R_PPC64_GOT16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
385 ppc64_elf_unhandled_reloc
),
387 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
389 HOW (R_PPC64_GOT16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
390 ppc64_elf_unhandled_reloc
),
392 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
394 HOW (R_PPC64_GOT16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
395 ppc64_elf_unhandled_reloc
),
397 /* This is used only by the dynamic linker. The symbol should exist
398 both in the object being run and in some shared library. The
399 dynamic linker copies the data addressed by the symbol from the
400 shared library into the object, because the object being
401 run has to have the data at some particular address. */
402 HOW (R_PPC64_COPY
, 0, 0, 0, 0, FALSE
, dont
,
403 ppc64_elf_unhandled_reloc
),
405 /* Like R_PPC64_ADDR64, but used when setting global offset table
407 HOW (R_PPC64_GLOB_DAT
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
408 ppc64_elf_unhandled_reloc
),
410 /* Created by the link editor. Marks a procedure linkage table
411 entry for a symbol. */
412 HOW (R_PPC64_JMP_SLOT
, 0, 0, 0, 0, FALSE
, dont
,
413 ppc64_elf_unhandled_reloc
),
415 /* Used only by the dynamic linker. When the object is run, this
416 doubleword64 is set to the load address of the object, plus the
418 HOW (R_PPC64_RELATIVE
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
419 bfd_elf_generic_reloc
),
421 /* Like R_PPC64_ADDR32, but may be unaligned. */
422 HOW (R_PPC64_UADDR32
, 2, 32, 0xffffffff, 0, FALSE
, bitfield
,
423 bfd_elf_generic_reloc
),
425 /* Like R_PPC64_ADDR16, but may be unaligned. */
426 HOW (R_PPC64_UADDR16
, 1, 16, 0xffff, 0, FALSE
, bitfield
,
427 bfd_elf_generic_reloc
),
429 /* 32-bit PC relative. */
430 HOW (R_PPC64_REL32
, 2, 32, 0xffffffff, 0, TRUE
, signed,
431 bfd_elf_generic_reloc
),
433 /* 32-bit relocation to the symbol's procedure linkage table. */
434 HOW (R_PPC64_PLT32
, 2, 32, 0xffffffff, 0, FALSE
, bitfield
,
435 ppc64_elf_unhandled_reloc
),
437 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
438 FIXME: R_PPC64_PLTREL32 not supported. */
439 HOW (R_PPC64_PLTREL32
, 2, 32, 0xffffffff, 0, TRUE
, signed,
440 ppc64_elf_unhandled_reloc
),
442 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
444 HOW (R_PPC64_PLT16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
445 ppc64_elf_unhandled_reloc
),
447 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
449 HOW (R_PPC64_PLT16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
450 ppc64_elf_unhandled_reloc
),
452 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
454 HOW (R_PPC64_PLT16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
455 ppc64_elf_unhandled_reloc
),
457 /* 16-bit section relative relocation. */
458 HOW (R_PPC64_SECTOFF
, 1, 16, 0xffff, 0, FALSE
, signed,
459 ppc64_elf_sectoff_reloc
),
461 /* Like R_PPC64_SECTOFF, but no overflow warning. */
462 HOW (R_PPC64_SECTOFF_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
463 ppc64_elf_sectoff_reloc
),
465 /* 16-bit upper half section relative relocation. */
466 HOW (R_PPC64_SECTOFF_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
467 ppc64_elf_sectoff_reloc
),
469 /* 16-bit upper half adjusted section relative relocation. */
470 HOW (R_PPC64_SECTOFF_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
471 ppc64_elf_sectoff_ha_reloc
),
473 /* Like R_PPC64_REL24 without touching the two least significant bits. */
474 HOW (R_PPC64_REL30
, 2, 30, 0xfffffffc, 2, TRUE
, dont
,
475 bfd_elf_generic_reloc
),
477 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
479 /* A standard 64-bit relocation. */
480 HOW (R_PPC64_ADDR64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
481 bfd_elf_generic_reloc
),
483 /* The bits 32-47 of an address. */
484 HOW (R_PPC64_ADDR16_HIGHER
, 1, 16, 0xffff, 32, FALSE
, dont
,
485 bfd_elf_generic_reloc
),
487 /* The bits 32-47 of an address, plus 1 if the contents of the low
488 16 bits, treated as a signed number, is negative. */
489 HOW (R_PPC64_ADDR16_HIGHERA
, 1, 16, 0xffff, 32, FALSE
, dont
,
492 /* The bits 48-63 of an address. */
493 HOW (R_PPC64_ADDR16_HIGHEST
, 1, 16, 0xffff, 48, FALSE
, dont
,
494 bfd_elf_generic_reloc
),
496 /* The bits 48-63 of an address, plus 1 if the contents of the low
497 16 bits, treated as a signed number, is negative. */
498 HOW (R_PPC64_ADDR16_HIGHESTA
, 1, 16, 0xffff, 48, FALSE
, dont
,
501 /* Like ADDR64, but may be unaligned. */
502 HOW (R_PPC64_UADDR64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
503 bfd_elf_generic_reloc
),
505 /* 64-bit relative relocation. */
506 HOW (R_PPC64_REL64
, 4, 64, 0xffffffffffffffffULL
, 0, TRUE
, dont
,
507 bfd_elf_generic_reloc
),
509 /* 64-bit relocation to the symbol's procedure linkage table. */
510 HOW (R_PPC64_PLT64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
511 ppc64_elf_unhandled_reloc
),
513 /* 64-bit PC relative relocation to the symbol's procedure linkage
515 /* FIXME: R_PPC64_PLTREL64 not supported. */
516 HOW (R_PPC64_PLTREL64
, 4, 64, 0xffffffffffffffffULL
, 0, TRUE
, dont
,
517 ppc64_elf_unhandled_reloc
),
519 /* 16 bit TOC-relative relocation. */
520 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
521 HOW (R_PPC64_TOC16
, 1, 16, 0xffff, 0, FALSE
, signed,
522 ppc64_elf_toc_reloc
),
524 /* 16 bit TOC-relative relocation without overflow. */
525 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
526 HOW (R_PPC64_TOC16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
527 ppc64_elf_toc_reloc
),
529 /* 16 bit TOC-relative relocation, high 16 bits. */
530 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
531 HOW (R_PPC64_TOC16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
532 ppc64_elf_toc_reloc
),
534 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
535 contents of the low 16 bits, treated as a signed number, is
537 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
538 HOW (R_PPC64_TOC16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
539 ppc64_elf_toc_ha_reloc
),
541 /* 64-bit relocation; insert value of TOC base (.TOC.). */
542 /* R_PPC64_TOC 51 doubleword64 .TOC. */
543 HOW (R_PPC64_TOC
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
544 ppc64_elf_toc64_reloc
),
546 /* Like R_PPC64_GOT16, but also informs the link editor that the
547 value to relocate may (!) refer to a PLT entry which the link
548 editor (a) may replace with the symbol value. If the link editor
549 is unable to fully resolve the symbol, it may (b) create a PLT
550 entry and store the address to the new PLT entry in the GOT.
551 This permits lazy resolution of function symbols at run time.
552 The link editor may also skip all of this and just (c) emit a
553 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
554 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
555 HOW (R_PPC64_PLTGOT16
, 1, 16, 0xffff, 0, FALSE
,signed,
556 ppc64_elf_unhandled_reloc
),
558 /* Like R_PPC64_PLTGOT16, but without overflow. */
559 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
560 HOW (R_PPC64_PLTGOT16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
561 ppc64_elf_unhandled_reloc
),
563 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
564 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
565 HOW (R_PPC64_PLTGOT16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
566 ppc64_elf_unhandled_reloc
),
568 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
569 1 if the contents of the low 16 bits, treated as a signed number,
571 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
572 HOW (R_PPC64_PLTGOT16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
573 ppc64_elf_unhandled_reloc
),
575 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
576 HOW (R_PPC64_ADDR16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
577 bfd_elf_generic_reloc
),
579 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
580 HOW (R_PPC64_ADDR16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
581 bfd_elf_generic_reloc
),
583 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
584 HOW (R_PPC64_GOT16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
585 ppc64_elf_unhandled_reloc
),
587 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
588 HOW (R_PPC64_GOT16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
589 ppc64_elf_unhandled_reloc
),
591 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
592 HOW (R_PPC64_PLT16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
593 ppc64_elf_unhandled_reloc
),
595 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
596 HOW (R_PPC64_SECTOFF_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
597 ppc64_elf_sectoff_reloc
),
599 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
600 HOW (R_PPC64_SECTOFF_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
601 ppc64_elf_sectoff_reloc
),
603 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
604 HOW (R_PPC64_TOC16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
605 ppc64_elf_toc_reloc
),
607 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
608 HOW (R_PPC64_TOC16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
609 ppc64_elf_toc_reloc
),
611 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
612 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
613 HOW (R_PPC64_PLTGOT16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
614 ppc64_elf_unhandled_reloc
),
616 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
617 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
618 HOW (R_PPC64_PLTGOT16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
619 ppc64_elf_unhandled_reloc
),
621 /* Marker relocs for TLS. */
622 HOW (R_PPC64_TLS
, 2, 32, 0, 0, FALSE
, dont
,
623 bfd_elf_generic_reloc
),
625 HOW (R_PPC64_TLSGD
, 2, 32, 0, 0, FALSE
, dont
,
626 bfd_elf_generic_reloc
),
628 HOW (R_PPC64_TLSLD
, 2, 32, 0, 0, FALSE
, dont
,
629 bfd_elf_generic_reloc
),
631 /* Marker reloc for optimizing r2 save in prologue rather than on
632 each plt call stub. */
633 HOW (R_PPC64_TOCSAVE
, 2, 32, 0, 0, FALSE
, dont
,
634 bfd_elf_generic_reloc
),
636 /* Marker relocs on inline plt call instructions. */
637 HOW (R_PPC64_PLTSEQ
, 2, 32, 0, 0, FALSE
, dont
,
638 bfd_elf_generic_reloc
),
640 HOW (R_PPC64_PLTCALL
, 2, 32, 0, 0, FALSE
, dont
,
641 bfd_elf_generic_reloc
),
643 /* Computes the load module index of the load module that contains the
644 definition of its TLS sym. */
645 HOW (R_PPC64_DTPMOD64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
646 ppc64_elf_unhandled_reloc
),
648 /* Computes a dtv-relative displacement, the difference between the value
649 of sym+add and the base address of the thread-local storage block that
650 contains the definition of sym, minus 0x8000. */
651 HOW (R_PPC64_DTPREL64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
652 ppc64_elf_unhandled_reloc
),
654 /* A 16 bit dtprel reloc. */
655 HOW (R_PPC64_DTPREL16
, 1, 16, 0xffff, 0, FALSE
, signed,
656 ppc64_elf_unhandled_reloc
),
658 /* Like DTPREL16, but no overflow. */
659 HOW (R_PPC64_DTPREL16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
660 ppc64_elf_unhandled_reloc
),
662 /* Like DTPREL16_LO, but next higher group of 16 bits. */
663 HOW (R_PPC64_DTPREL16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
664 ppc64_elf_unhandled_reloc
),
666 /* Like DTPREL16_HI, but adjust for low 16 bits. */
667 HOW (R_PPC64_DTPREL16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
668 ppc64_elf_unhandled_reloc
),
670 /* Like DTPREL16_HI, but next higher group of 16 bits. */
671 HOW (R_PPC64_DTPREL16_HIGHER
, 1, 16, 0xffff, 32, FALSE
, dont
,
672 ppc64_elf_unhandled_reloc
),
674 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
675 HOW (R_PPC64_DTPREL16_HIGHERA
, 1, 16, 0xffff, 32, FALSE
, dont
,
676 ppc64_elf_unhandled_reloc
),
678 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
679 HOW (R_PPC64_DTPREL16_HIGHEST
, 1, 16, 0xffff, 48, FALSE
, dont
,
680 ppc64_elf_unhandled_reloc
),
682 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
683 HOW (R_PPC64_DTPREL16_HIGHESTA
, 1, 16, 0xffff, 48, FALSE
, dont
,
684 ppc64_elf_unhandled_reloc
),
686 /* Like DTPREL16, but for insns with a DS field. */
687 HOW (R_PPC64_DTPREL16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
688 ppc64_elf_unhandled_reloc
),
690 /* Like DTPREL16_DS, but no overflow. */
691 HOW (R_PPC64_DTPREL16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
692 ppc64_elf_unhandled_reloc
),
694 /* Computes a tp-relative displacement, the difference between the value of
695 sym+add and the value of the thread pointer (r13). */
696 HOW (R_PPC64_TPREL64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
697 ppc64_elf_unhandled_reloc
),
699 /* A 16 bit tprel reloc. */
700 HOW (R_PPC64_TPREL16
, 1, 16, 0xffff, 0, FALSE
, signed,
701 ppc64_elf_unhandled_reloc
),
703 /* Like TPREL16, but no overflow. */
704 HOW (R_PPC64_TPREL16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
705 ppc64_elf_unhandled_reloc
),
707 /* Like TPREL16_LO, but next higher group of 16 bits. */
708 HOW (R_PPC64_TPREL16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
709 ppc64_elf_unhandled_reloc
),
711 /* Like TPREL16_HI, but adjust for low 16 bits. */
712 HOW (R_PPC64_TPREL16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
713 ppc64_elf_unhandled_reloc
),
715 /* Like TPREL16_HI, but next higher group of 16 bits. */
716 HOW (R_PPC64_TPREL16_HIGHER
, 1, 16, 0xffff, 32, FALSE
, dont
,
717 ppc64_elf_unhandled_reloc
),
719 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
720 HOW (R_PPC64_TPREL16_HIGHERA
, 1, 16, 0xffff, 32, FALSE
, dont
,
721 ppc64_elf_unhandled_reloc
),
723 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
724 HOW (R_PPC64_TPREL16_HIGHEST
, 1, 16, 0xffff, 48, FALSE
, dont
,
725 ppc64_elf_unhandled_reloc
),
727 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
728 HOW (R_PPC64_TPREL16_HIGHESTA
, 1, 16, 0xffff, 48, FALSE
, dont
,
729 ppc64_elf_unhandled_reloc
),
731 /* Like TPREL16, but for insns with a DS field. */
732 HOW (R_PPC64_TPREL16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
733 ppc64_elf_unhandled_reloc
),
735 /* Like TPREL16_DS, but no overflow. */
736 HOW (R_PPC64_TPREL16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
737 ppc64_elf_unhandled_reloc
),
739 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
740 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
741 to the first entry relative to the TOC base (r2). */
742 HOW (R_PPC64_GOT_TLSGD16
, 1, 16, 0xffff, 0, FALSE
, signed,
743 ppc64_elf_unhandled_reloc
),
745 /* Like GOT_TLSGD16, but no overflow. */
746 HOW (R_PPC64_GOT_TLSGD16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
747 ppc64_elf_unhandled_reloc
),
749 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
750 HOW (R_PPC64_GOT_TLSGD16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
751 ppc64_elf_unhandled_reloc
),
753 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
754 HOW (R_PPC64_GOT_TLSGD16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
755 ppc64_elf_unhandled_reloc
),
757 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
758 with values (sym+add)@dtpmod and zero, and computes the offset to the
759 first entry relative to the TOC base (r2). */
760 HOW (R_PPC64_GOT_TLSLD16
, 1, 16, 0xffff, 0, FALSE
, signed,
761 ppc64_elf_unhandled_reloc
),
763 /* Like GOT_TLSLD16, but no overflow. */
764 HOW (R_PPC64_GOT_TLSLD16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
765 ppc64_elf_unhandled_reloc
),
767 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
768 HOW (R_PPC64_GOT_TLSLD16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
769 ppc64_elf_unhandled_reloc
),
771 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
772 HOW (R_PPC64_GOT_TLSLD16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
773 ppc64_elf_unhandled_reloc
),
775 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
776 the offset to the entry relative to the TOC base (r2). */
777 HOW (R_PPC64_GOT_DTPREL16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
778 ppc64_elf_unhandled_reloc
),
780 /* Like GOT_DTPREL16_DS, but no overflow. */
781 HOW (R_PPC64_GOT_DTPREL16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
782 ppc64_elf_unhandled_reloc
),
784 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
785 HOW (R_PPC64_GOT_DTPREL16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
786 ppc64_elf_unhandled_reloc
),
788 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
789 HOW (R_PPC64_GOT_DTPREL16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
790 ppc64_elf_unhandled_reloc
),
792 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
793 offset to the entry relative to the TOC base (r2). */
794 HOW (R_PPC64_GOT_TPREL16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
795 ppc64_elf_unhandled_reloc
),
797 /* Like GOT_TPREL16_DS, but no overflow. */
798 HOW (R_PPC64_GOT_TPREL16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
799 ppc64_elf_unhandled_reloc
),
801 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
802 HOW (R_PPC64_GOT_TPREL16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
803 ppc64_elf_unhandled_reloc
),
805 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
806 HOW (R_PPC64_GOT_TPREL16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
807 ppc64_elf_unhandled_reloc
),
809 HOW (R_PPC64_JMP_IREL
, 0, 0, 0, 0, FALSE
, dont
,
810 ppc64_elf_unhandled_reloc
),
812 HOW (R_PPC64_IRELATIVE
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
813 bfd_elf_generic_reloc
),
815 /* A 16 bit relative relocation. */
816 HOW (R_PPC64_REL16
, 1, 16, 0xffff, 0, TRUE
, signed,
817 bfd_elf_generic_reloc
),
819 /* A 16 bit relative relocation without overflow. */
820 HOW (R_PPC64_REL16_LO
, 1, 16, 0xffff, 0, TRUE
, dont
,
821 bfd_elf_generic_reloc
),
823 /* The high order 16 bits of a relative address. */
824 HOW (R_PPC64_REL16_HI
, 1, 16, 0xffff, 16, TRUE
, signed,
825 bfd_elf_generic_reloc
),
827 /* The high order 16 bits of a relative address, plus 1 if the contents of
828 the low 16 bits, treated as a signed number, is negative. */
829 HOW (R_PPC64_REL16_HA
, 1, 16, 0xffff, 16, TRUE
, signed,
832 HOW (R_PPC64_REL16_HIGH
, 1, 16, 0xffff, 16, TRUE
, dont
,
833 bfd_elf_generic_reloc
),
835 HOW (R_PPC64_REL16_HIGHA
, 1, 16, 0xffff, 16, TRUE
, dont
,
838 HOW (R_PPC64_REL16_HIGHER
, 1, 16, 0xffff, 32, TRUE
, dont
,
839 bfd_elf_generic_reloc
),
841 HOW (R_PPC64_REL16_HIGHERA
, 1, 16, 0xffff, 32, TRUE
, dont
,
844 HOW (R_PPC64_REL16_HIGHEST
, 1, 16, 0xffff, 48, TRUE
, dont
,
845 bfd_elf_generic_reloc
),
847 HOW (R_PPC64_REL16_HIGHESTA
, 1, 16, 0xffff, 48, TRUE
, dont
,
850 /* Like R_PPC64_REL16_HA but for split field in addpcis. */
851 HOW (R_PPC64_REL16DX_HA
, 2, 16, 0x1fffc1, 16, TRUE
, signed,
854 /* A split-field reloc for addpcis, non-relative (gas internal use only). */
855 HOW (R_PPC64_16DX_HA
, 2, 16, 0x1fffc1, 16, FALSE
, signed,
858 /* Like R_PPC64_ADDR16_HI, but no overflow. */
859 HOW (R_PPC64_ADDR16_HIGH
, 1, 16, 0xffff, 16, FALSE
, dont
,
860 bfd_elf_generic_reloc
),
862 /* Like R_PPC64_ADDR16_HA, but no overflow. */
863 HOW (R_PPC64_ADDR16_HIGHA
, 1, 16, 0xffff, 16, FALSE
, dont
,
866 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
867 HOW (R_PPC64_DTPREL16_HIGH
, 1, 16, 0xffff, 16, FALSE
, dont
,
868 ppc64_elf_unhandled_reloc
),
870 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
871 HOW (R_PPC64_DTPREL16_HIGHA
, 1, 16, 0xffff, 16, FALSE
, dont
,
872 ppc64_elf_unhandled_reloc
),
874 /* Like R_PPC64_TPREL16_HI, but no overflow. */
875 HOW (R_PPC64_TPREL16_HIGH
, 1, 16, 0xffff, 16, FALSE
, dont
,
876 ppc64_elf_unhandled_reloc
),
878 /* Like R_PPC64_TPREL16_HA, but no overflow. */
879 HOW (R_PPC64_TPREL16_HIGHA
, 1, 16, 0xffff, 16, FALSE
, dont
,
880 ppc64_elf_unhandled_reloc
),
882 /* Marker reloc on ELFv2 large-model function entry. */
883 HOW (R_PPC64_ENTRY
, 2, 32, 0, 0, FALSE
, dont
,
884 bfd_elf_generic_reloc
),
886 /* Like ADDR64, but use local entry point of function. */
887 HOW (R_PPC64_ADDR64_LOCAL
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
888 bfd_elf_generic_reloc
),
890 HOW (R_PPC64_PLTSEQ_NOTOC
, 2, 32, 0, 0, FALSE
, dont
,
891 bfd_elf_generic_reloc
),
893 HOW (R_PPC64_PLTCALL_NOTOC
, 2, 32, 0, 0, FALSE
, dont
,
894 bfd_elf_generic_reloc
),
896 HOW (R_PPC64_PCREL_OPT
, 2, 32, 0, 0, FALSE
, dont
,
897 bfd_elf_generic_reloc
),
899 HOW (R_PPC64_D34
, 4, 34, 0x3ffff0000ffffULL
, 0, FALSE
, signed,
900 ppc64_elf_prefix_reloc
),
902 HOW (R_PPC64_D34_LO
, 4, 34, 0x3ffff0000ffffULL
, 0, FALSE
, dont
,
903 ppc64_elf_prefix_reloc
),
905 HOW (R_PPC64_D34_HI30
, 4, 34, 0x3ffff0000ffffULL
, 34, FALSE
, dont
,
906 ppc64_elf_prefix_reloc
),
908 HOW (R_PPC64_D34_HA30
, 4, 34, 0x3ffff0000ffffULL
, 34, FALSE
, dont
,
909 ppc64_elf_prefix_reloc
),
911 HOW (R_PPC64_PCREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
912 ppc64_elf_prefix_reloc
),
914 HOW (R_PPC64_GOT_PCREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
915 ppc64_elf_unhandled_reloc
),
917 HOW (R_PPC64_PLT_PCREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
918 ppc64_elf_unhandled_reloc
),
920 HOW (R_PPC64_PLT_PCREL34_NOTOC
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
921 ppc64_elf_unhandled_reloc
),
923 HOW (R_PPC64_TPREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, FALSE
, signed,
924 ppc64_elf_unhandled_reloc
),
926 HOW (R_PPC64_DTPREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, FALSE
, signed,
927 ppc64_elf_unhandled_reloc
),
929 HOW (R_PPC64_GOT_TLSGD34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
930 ppc64_elf_unhandled_reloc
),
932 HOW (R_PPC64_GOT_TLSLD34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
933 ppc64_elf_unhandled_reloc
),
935 HOW (R_PPC64_GOT_TPREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
936 ppc64_elf_unhandled_reloc
),
938 HOW (R_PPC64_GOT_DTPREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
939 ppc64_elf_unhandled_reloc
),
941 HOW (R_PPC64_ADDR16_HIGHER34
, 1, 16, 0xffff, 34, FALSE
, dont
,
942 bfd_elf_generic_reloc
),
944 HOW (R_PPC64_ADDR16_HIGHERA34
, 1, 16, 0xffff, 34, FALSE
, dont
,
947 HOW (R_PPC64_ADDR16_HIGHEST34
, 1, 16, 0xffff, 50, FALSE
, dont
,
948 bfd_elf_generic_reloc
),
950 HOW (R_PPC64_ADDR16_HIGHESTA34
, 1, 16, 0xffff, 50, FALSE
, dont
,
953 HOW (R_PPC64_REL16_HIGHER34
, 1, 16, 0xffff, 34, TRUE
, dont
,
954 bfd_elf_generic_reloc
),
956 HOW (R_PPC64_REL16_HIGHERA34
, 1, 16, 0xffff, 34, TRUE
, dont
,
959 HOW (R_PPC64_REL16_HIGHEST34
, 1, 16, 0xffff, 50, TRUE
, dont
,
960 bfd_elf_generic_reloc
),
962 HOW (R_PPC64_REL16_HIGHESTA34
, 1, 16, 0xffff, 50, TRUE
, dont
,
965 HOW (R_PPC64_D28
, 4, 28, 0xfff0000ffffULL
, 0, FALSE
, signed,
966 ppc64_elf_prefix_reloc
),
968 HOW (R_PPC64_PCREL28
, 4, 28, 0xfff0000ffffULL
, 0, TRUE
, signed,
969 ppc64_elf_prefix_reloc
),
971 /* GNU extension to record C++ vtable hierarchy. */
972 HOW (R_PPC64_GNU_VTINHERIT
, 0, 0, 0, 0, FALSE
, dont
,
975 /* GNU extension to record C++ vtable member usage. */
976 HOW (R_PPC64_GNU_VTENTRY
, 0, 0, 0, 0, FALSE
, dont
,
981 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
985 ppc_howto_init (void)
987 unsigned int i
, type
;
989 for (i
= 0; i
< ARRAY_SIZE (ppc64_elf_howto_raw
); i
++)
991 type
= ppc64_elf_howto_raw
[i
].type
;
992 BFD_ASSERT (type
< ARRAY_SIZE (ppc64_elf_howto_table
));
993 ppc64_elf_howto_table
[type
] = &ppc64_elf_howto_raw
[i
];
997 static reloc_howto_type
*
998 ppc64_elf_reloc_type_lookup (bfd
*abfd
,
999 bfd_reloc_code_real_type code
)
1001 enum elf_ppc64_reloc_type r
= R_PPC64_NONE
;
1003 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
1004 /* Initialize howto table if needed. */
1010 /* xgettext:c-format */
1011 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd
,
1013 bfd_set_error (bfd_error_bad_value
);
1016 case BFD_RELOC_NONE
: r
= R_PPC64_NONE
;
1018 case BFD_RELOC_32
: r
= R_PPC64_ADDR32
;
1020 case BFD_RELOC_PPC_BA26
: r
= R_PPC64_ADDR24
;
1022 case BFD_RELOC_16
: r
= R_PPC64_ADDR16
;
1024 case BFD_RELOC_LO16
: r
= R_PPC64_ADDR16_LO
;
1026 case BFD_RELOC_HI16
: r
= R_PPC64_ADDR16_HI
;
1028 case BFD_RELOC_PPC64_ADDR16_HIGH
: r
= R_PPC64_ADDR16_HIGH
;
1030 case BFD_RELOC_HI16_S
: r
= R_PPC64_ADDR16_HA
;
1032 case BFD_RELOC_PPC64_ADDR16_HIGHA
: r
= R_PPC64_ADDR16_HIGHA
;
1034 case BFD_RELOC_PPC_BA16
: r
= R_PPC64_ADDR14
;
1036 case BFD_RELOC_PPC_BA16_BRTAKEN
: r
= R_PPC64_ADDR14_BRTAKEN
;
1038 case BFD_RELOC_PPC_BA16_BRNTAKEN
: r
= R_PPC64_ADDR14_BRNTAKEN
;
1040 case BFD_RELOC_PPC_B26
: r
= R_PPC64_REL24
;
1042 case BFD_RELOC_PPC64_REL24_NOTOC
: r
= R_PPC64_REL24_NOTOC
;
1044 case BFD_RELOC_PPC_B16
: r
= R_PPC64_REL14
;
1046 case BFD_RELOC_PPC_B16_BRTAKEN
: r
= R_PPC64_REL14_BRTAKEN
;
1048 case BFD_RELOC_PPC_B16_BRNTAKEN
: r
= R_PPC64_REL14_BRNTAKEN
;
1050 case BFD_RELOC_16_GOTOFF
: r
= R_PPC64_GOT16
;
1052 case BFD_RELOC_LO16_GOTOFF
: r
= R_PPC64_GOT16_LO
;
1054 case BFD_RELOC_HI16_GOTOFF
: r
= R_PPC64_GOT16_HI
;
1056 case BFD_RELOC_HI16_S_GOTOFF
: r
= R_PPC64_GOT16_HA
;
1058 case BFD_RELOC_PPC_COPY
: r
= R_PPC64_COPY
;
1060 case BFD_RELOC_PPC_GLOB_DAT
: r
= R_PPC64_GLOB_DAT
;
1062 case BFD_RELOC_32_PCREL
: r
= R_PPC64_REL32
;
1064 case BFD_RELOC_32_PLTOFF
: r
= R_PPC64_PLT32
;
1066 case BFD_RELOC_32_PLT_PCREL
: r
= R_PPC64_PLTREL32
;
1068 case BFD_RELOC_LO16_PLTOFF
: r
= R_PPC64_PLT16_LO
;
1070 case BFD_RELOC_HI16_PLTOFF
: r
= R_PPC64_PLT16_HI
;
1072 case BFD_RELOC_HI16_S_PLTOFF
: r
= R_PPC64_PLT16_HA
;
1074 case BFD_RELOC_16_BASEREL
: r
= R_PPC64_SECTOFF
;
1076 case BFD_RELOC_LO16_BASEREL
: r
= R_PPC64_SECTOFF_LO
;
1078 case BFD_RELOC_HI16_BASEREL
: r
= R_PPC64_SECTOFF_HI
;
1080 case BFD_RELOC_HI16_S_BASEREL
: r
= R_PPC64_SECTOFF_HA
;
1082 case BFD_RELOC_CTOR
: r
= R_PPC64_ADDR64
;
1084 case BFD_RELOC_64
: r
= R_PPC64_ADDR64
;
1086 case BFD_RELOC_PPC64_HIGHER
: r
= R_PPC64_ADDR16_HIGHER
;
1088 case BFD_RELOC_PPC64_HIGHER_S
: r
= R_PPC64_ADDR16_HIGHERA
;
1090 case BFD_RELOC_PPC64_HIGHEST
: r
= R_PPC64_ADDR16_HIGHEST
;
1092 case BFD_RELOC_PPC64_HIGHEST_S
: r
= R_PPC64_ADDR16_HIGHESTA
;
1094 case BFD_RELOC_64_PCREL
: r
= R_PPC64_REL64
;
1096 case BFD_RELOC_64_PLTOFF
: r
= R_PPC64_PLT64
;
1098 case BFD_RELOC_64_PLT_PCREL
: r
= R_PPC64_PLTREL64
;
1100 case BFD_RELOC_PPC_TOC16
: r
= R_PPC64_TOC16
;
1102 case BFD_RELOC_PPC64_TOC16_LO
: r
= R_PPC64_TOC16_LO
;
1104 case BFD_RELOC_PPC64_TOC16_HI
: r
= R_PPC64_TOC16_HI
;
1106 case BFD_RELOC_PPC64_TOC16_HA
: r
= R_PPC64_TOC16_HA
;
1108 case BFD_RELOC_PPC64_TOC
: r
= R_PPC64_TOC
;
1110 case BFD_RELOC_PPC64_PLTGOT16
: r
= R_PPC64_PLTGOT16
;
1112 case BFD_RELOC_PPC64_PLTGOT16_LO
: r
= R_PPC64_PLTGOT16_LO
;
1114 case BFD_RELOC_PPC64_PLTGOT16_HI
: r
= R_PPC64_PLTGOT16_HI
;
1116 case BFD_RELOC_PPC64_PLTGOT16_HA
: r
= R_PPC64_PLTGOT16_HA
;
1118 case BFD_RELOC_PPC64_ADDR16_DS
: r
= R_PPC64_ADDR16_DS
;
1120 case BFD_RELOC_PPC64_ADDR16_LO_DS
: r
= R_PPC64_ADDR16_LO_DS
;
1122 case BFD_RELOC_PPC64_GOT16_DS
: r
= R_PPC64_GOT16_DS
;
1124 case BFD_RELOC_PPC64_GOT16_LO_DS
: r
= R_PPC64_GOT16_LO_DS
;
1126 case BFD_RELOC_PPC64_PLT16_LO_DS
: r
= R_PPC64_PLT16_LO_DS
;
1128 case BFD_RELOC_PPC64_SECTOFF_DS
: r
= R_PPC64_SECTOFF_DS
;
1130 case BFD_RELOC_PPC64_SECTOFF_LO_DS
: r
= R_PPC64_SECTOFF_LO_DS
;
1132 case BFD_RELOC_PPC64_TOC16_DS
: r
= R_PPC64_TOC16_DS
;
1134 case BFD_RELOC_PPC64_TOC16_LO_DS
: r
= R_PPC64_TOC16_LO_DS
;
1136 case BFD_RELOC_PPC64_PLTGOT16_DS
: r
= R_PPC64_PLTGOT16_DS
;
1138 case BFD_RELOC_PPC64_PLTGOT16_LO_DS
: r
= R_PPC64_PLTGOT16_LO_DS
;
1140 case BFD_RELOC_PPC64_TLS_PCREL
:
1141 case BFD_RELOC_PPC_TLS
: r
= R_PPC64_TLS
;
1143 case BFD_RELOC_PPC_TLSGD
: r
= R_PPC64_TLSGD
;
1145 case BFD_RELOC_PPC_TLSLD
: r
= R_PPC64_TLSLD
;
1147 case BFD_RELOC_PPC_DTPMOD
: r
= R_PPC64_DTPMOD64
;
1149 case BFD_RELOC_PPC_TPREL16
: r
= R_PPC64_TPREL16
;
1151 case BFD_RELOC_PPC_TPREL16_LO
: r
= R_PPC64_TPREL16_LO
;
1153 case BFD_RELOC_PPC_TPREL16_HI
: r
= R_PPC64_TPREL16_HI
;
1155 case BFD_RELOC_PPC64_TPREL16_HIGH
: r
= R_PPC64_TPREL16_HIGH
;
1157 case BFD_RELOC_PPC_TPREL16_HA
: r
= R_PPC64_TPREL16_HA
;
1159 case BFD_RELOC_PPC64_TPREL16_HIGHA
: r
= R_PPC64_TPREL16_HIGHA
;
1161 case BFD_RELOC_PPC_TPREL
: r
= R_PPC64_TPREL64
;
1163 case BFD_RELOC_PPC_DTPREL16
: r
= R_PPC64_DTPREL16
;
1165 case BFD_RELOC_PPC_DTPREL16_LO
: r
= R_PPC64_DTPREL16_LO
;
1167 case BFD_RELOC_PPC_DTPREL16_HI
: r
= R_PPC64_DTPREL16_HI
;
1169 case BFD_RELOC_PPC64_DTPREL16_HIGH
: r
= R_PPC64_DTPREL16_HIGH
;
1171 case BFD_RELOC_PPC_DTPREL16_HA
: r
= R_PPC64_DTPREL16_HA
;
1173 case BFD_RELOC_PPC64_DTPREL16_HIGHA
: r
= R_PPC64_DTPREL16_HIGHA
;
1175 case BFD_RELOC_PPC_DTPREL
: r
= R_PPC64_DTPREL64
;
1177 case BFD_RELOC_PPC_GOT_TLSGD16
: r
= R_PPC64_GOT_TLSGD16
;
1179 case BFD_RELOC_PPC_GOT_TLSGD16_LO
: r
= R_PPC64_GOT_TLSGD16_LO
;
1181 case BFD_RELOC_PPC_GOT_TLSGD16_HI
: r
= R_PPC64_GOT_TLSGD16_HI
;
1183 case BFD_RELOC_PPC_GOT_TLSGD16_HA
: r
= R_PPC64_GOT_TLSGD16_HA
;
1185 case BFD_RELOC_PPC_GOT_TLSLD16
: r
= R_PPC64_GOT_TLSLD16
;
1187 case BFD_RELOC_PPC_GOT_TLSLD16_LO
: r
= R_PPC64_GOT_TLSLD16_LO
;
1189 case BFD_RELOC_PPC_GOT_TLSLD16_HI
: r
= R_PPC64_GOT_TLSLD16_HI
;
1191 case BFD_RELOC_PPC_GOT_TLSLD16_HA
: r
= R_PPC64_GOT_TLSLD16_HA
;
1193 case BFD_RELOC_PPC_GOT_TPREL16
: r
= R_PPC64_GOT_TPREL16_DS
;
1195 case BFD_RELOC_PPC_GOT_TPREL16_LO
: r
= R_PPC64_GOT_TPREL16_LO_DS
;
1197 case BFD_RELOC_PPC_GOT_TPREL16_HI
: r
= R_PPC64_GOT_TPREL16_HI
;
1199 case BFD_RELOC_PPC_GOT_TPREL16_HA
: r
= R_PPC64_GOT_TPREL16_HA
;
1201 case BFD_RELOC_PPC_GOT_DTPREL16
: r
= R_PPC64_GOT_DTPREL16_DS
;
1203 case BFD_RELOC_PPC_GOT_DTPREL16_LO
: r
= R_PPC64_GOT_DTPREL16_LO_DS
;
1205 case BFD_RELOC_PPC_GOT_DTPREL16_HI
: r
= R_PPC64_GOT_DTPREL16_HI
;
1207 case BFD_RELOC_PPC_GOT_DTPREL16_HA
: r
= R_PPC64_GOT_DTPREL16_HA
;
1209 case BFD_RELOC_PPC64_TPREL16_DS
: r
= R_PPC64_TPREL16_DS
;
1211 case BFD_RELOC_PPC64_TPREL16_LO_DS
: r
= R_PPC64_TPREL16_LO_DS
;
1213 case BFD_RELOC_PPC64_TPREL16_HIGHER
: r
= R_PPC64_TPREL16_HIGHER
;
1215 case BFD_RELOC_PPC64_TPREL16_HIGHERA
: r
= R_PPC64_TPREL16_HIGHERA
;
1217 case BFD_RELOC_PPC64_TPREL16_HIGHEST
: r
= R_PPC64_TPREL16_HIGHEST
;
1219 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
: r
= R_PPC64_TPREL16_HIGHESTA
;
1221 case BFD_RELOC_PPC64_DTPREL16_DS
: r
= R_PPC64_DTPREL16_DS
;
1223 case BFD_RELOC_PPC64_DTPREL16_LO_DS
: r
= R_PPC64_DTPREL16_LO_DS
;
1225 case BFD_RELOC_PPC64_DTPREL16_HIGHER
: r
= R_PPC64_DTPREL16_HIGHER
;
1227 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
: r
= R_PPC64_DTPREL16_HIGHERA
;
1229 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
: r
= R_PPC64_DTPREL16_HIGHEST
;
1231 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
: r
= R_PPC64_DTPREL16_HIGHESTA
;
1233 case BFD_RELOC_16_PCREL
: r
= R_PPC64_REL16
;
1235 case BFD_RELOC_LO16_PCREL
: r
= R_PPC64_REL16_LO
;
1237 case BFD_RELOC_HI16_PCREL
: r
= R_PPC64_REL16_HI
;
1239 case BFD_RELOC_HI16_S_PCREL
: r
= R_PPC64_REL16_HA
;
1241 case BFD_RELOC_PPC64_REL16_HIGH
: r
= R_PPC64_REL16_HIGH
;
1243 case BFD_RELOC_PPC64_REL16_HIGHA
: r
= R_PPC64_REL16_HIGHA
;
1245 case BFD_RELOC_PPC64_REL16_HIGHER
: r
= R_PPC64_REL16_HIGHER
;
1247 case BFD_RELOC_PPC64_REL16_HIGHERA
: r
= R_PPC64_REL16_HIGHERA
;
1249 case BFD_RELOC_PPC64_REL16_HIGHEST
: r
= R_PPC64_REL16_HIGHEST
;
1251 case BFD_RELOC_PPC64_REL16_HIGHESTA
: r
= R_PPC64_REL16_HIGHESTA
;
1253 case BFD_RELOC_PPC_16DX_HA
: r
= R_PPC64_16DX_HA
;
1255 case BFD_RELOC_PPC_REL16DX_HA
: r
= R_PPC64_REL16DX_HA
;
1257 case BFD_RELOC_PPC64_ENTRY
: r
= R_PPC64_ENTRY
;
1259 case BFD_RELOC_PPC64_ADDR64_LOCAL
: r
= R_PPC64_ADDR64_LOCAL
;
1261 case BFD_RELOC_PPC64_D34
: r
= R_PPC64_D34
;
1263 case BFD_RELOC_PPC64_D34_LO
: r
= R_PPC64_D34_LO
;
1265 case BFD_RELOC_PPC64_D34_HI30
: r
= R_PPC64_D34_HI30
;
1267 case BFD_RELOC_PPC64_D34_HA30
: r
= R_PPC64_D34_HA30
;
1269 case BFD_RELOC_PPC64_PCREL34
: r
= R_PPC64_PCREL34
;
1271 case BFD_RELOC_PPC64_GOT_PCREL34
: r
= R_PPC64_GOT_PCREL34
;
1273 case BFD_RELOC_PPC64_PLT_PCREL34
: r
= R_PPC64_PLT_PCREL34
;
1275 case BFD_RELOC_PPC64_TPREL34
: r
= R_PPC64_TPREL34
;
1277 case BFD_RELOC_PPC64_DTPREL34
: r
= R_PPC64_DTPREL34
;
1279 case BFD_RELOC_PPC64_GOT_TLSGD34
: r
= R_PPC64_GOT_TLSGD34
;
1281 case BFD_RELOC_PPC64_GOT_TLSLD34
: r
= R_PPC64_GOT_TLSLD34
;
1283 case BFD_RELOC_PPC64_GOT_TPREL34
: r
= R_PPC64_GOT_TPREL34
;
1285 case BFD_RELOC_PPC64_GOT_DTPREL34
: r
= R_PPC64_GOT_DTPREL34
;
1287 case BFD_RELOC_PPC64_ADDR16_HIGHER34
: r
= R_PPC64_ADDR16_HIGHER34
;
1289 case BFD_RELOC_PPC64_ADDR16_HIGHERA34
: r
= R_PPC64_ADDR16_HIGHERA34
;
1291 case BFD_RELOC_PPC64_ADDR16_HIGHEST34
: r
= R_PPC64_ADDR16_HIGHEST34
;
1293 case BFD_RELOC_PPC64_ADDR16_HIGHESTA34
: r
= R_PPC64_ADDR16_HIGHESTA34
;
1295 case BFD_RELOC_PPC64_REL16_HIGHER34
: r
= R_PPC64_REL16_HIGHER34
;
1297 case BFD_RELOC_PPC64_REL16_HIGHERA34
: r
= R_PPC64_REL16_HIGHERA34
;
1299 case BFD_RELOC_PPC64_REL16_HIGHEST34
: r
= R_PPC64_REL16_HIGHEST34
;
1301 case BFD_RELOC_PPC64_REL16_HIGHESTA34
: r
= R_PPC64_REL16_HIGHESTA34
;
1303 case BFD_RELOC_PPC64_D28
: r
= R_PPC64_D28
;
1305 case BFD_RELOC_PPC64_PCREL28
: r
= R_PPC64_PCREL28
;
1307 case BFD_RELOC_VTABLE_INHERIT
: r
= R_PPC64_GNU_VTINHERIT
;
1309 case BFD_RELOC_VTABLE_ENTRY
: r
= R_PPC64_GNU_VTENTRY
;
1313 return ppc64_elf_howto_table
[r
];
1316 static reloc_howto_type
*
1317 ppc64_elf_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
1322 for (i
= 0; i
< ARRAY_SIZE (ppc64_elf_howto_raw
); i
++)
1323 if (ppc64_elf_howto_raw
[i
].name
!= NULL
1324 && strcasecmp (ppc64_elf_howto_raw
[i
].name
, r_name
) == 0)
1325 return &ppc64_elf_howto_raw
[i
];
1330 /* Set the howto pointer for a PowerPC ELF reloc. */
1333 ppc64_elf_info_to_howto (bfd
*abfd
, arelent
*cache_ptr
,
1334 Elf_Internal_Rela
*dst
)
1338 /* Initialize howto table if needed. */
1339 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
1342 type
= ELF64_R_TYPE (dst
->r_info
);
1343 if (type
>= ARRAY_SIZE (ppc64_elf_howto_table
))
1345 /* xgettext:c-format */
1346 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
1348 bfd_set_error (bfd_error_bad_value
);
1351 cache_ptr
->howto
= ppc64_elf_howto_table
[type
];
1352 if (cache_ptr
->howto
== NULL
|| cache_ptr
->howto
->name
== NULL
)
1354 /* xgettext:c-format */
1355 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
1357 bfd_set_error (bfd_error_bad_value
);
1364 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
1366 static bfd_reloc_status_type
1367 ppc64_elf_ha_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1368 void *data
, asection
*input_section
,
1369 bfd
*output_bfd
, char **error_message
)
1371 enum elf_ppc64_reloc_type r_type
;
1373 bfd_size_type octets
;
1376 /* If this is a relocatable link (output_bfd test tells us), just
1377 call the generic function. Any adjustment will be done at final
1379 if (output_bfd
!= NULL
)
1380 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1381 input_section
, output_bfd
, error_message
);
1383 /* Adjust the addend for sign extension of the low 16 (or 34) bits.
1384 We won't actually be using the low bits, so trashing them
1386 r_type
= reloc_entry
->howto
->type
;
1387 if (r_type
== R_PPC64_ADDR16_HIGHERA34
1388 || r_type
== R_PPC64_ADDR16_HIGHESTA34
1389 || r_type
== R_PPC64_REL16_HIGHERA34
1390 || r_type
== R_PPC64_REL16_HIGHESTA34
)
1391 reloc_entry
->addend
+= 1ULL << 33;
1393 reloc_entry
->addend
+= 1U << 15;
1394 if (r_type
!= R_PPC64_REL16DX_HA
)
1395 return bfd_reloc_continue
;
1398 if (!bfd_is_com_section (symbol
->section
))
1399 value
= symbol
->value
;
1400 value
+= (reloc_entry
->addend
1401 + symbol
->section
->output_offset
1402 + symbol
->section
->output_section
->vma
);
1403 value
-= (reloc_entry
->address
1404 + input_section
->output_offset
1405 + input_section
->output_section
->vma
);
1406 value
= (bfd_signed_vma
) value
>> 16;
1408 octets
= reloc_entry
->address
* bfd_octets_per_byte (abfd
);
1409 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ octets
);
1411 insn
|= (value
& 0xffc1) | ((value
& 0x3e) << 15);
1412 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ octets
);
1413 if (value
+ 0x8000 > 0xffff)
1414 return bfd_reloc_overflow
;
1415 return bfd_reloc_ok
;
1418 static bfd_reloc_status_type
1419 ppc64_elf_branch_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1420 void *data
, asection
*input_section
,
1421 bfd
*output_bfd
, char **error_message
)
1423 if (output_bfd
!= NULL
)
1424 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1425 input_section
, output_bfd
, error_message
);
1427 if (strcmp (symbol
->section
->name
, ".opd") == 0
1428 && (symbol
->section
->owner
->flags
& DYNAMIC
) == 0)
1430 bfd_vma dest
= opd_entry_value (symbol
->section
,
1431 symbol
->value
+ reloc_entry
->addend
,
1433 if (dest
!= (bfd_vma
) -1)
1434 reloc_entry
->addend
= dest
- (symbol
->value
1435 + symbol
->section
->output_section
->vma
1436 + symbol
->section
->output_offset
);
1440 elf_symbol_type
*elfsym
= (elf_symbol_type
*) symbol
;
1442 if (symbol
->section
->owner
!= abfd
1443 && symbol
->section
->owner
!= NULL
1444 && abiversion (symbol
->section
->owner
) >= 2)
1448 for (i
= 0; i
< symbol
->section
->owner
->symcount
; ++i
)
1450 asymbol
*symdef
= symbol
->section
->owner
->outsymbols
[i
];
1452 if (strcmp (symdef
->name
, symbol
->name
) == 0)
1454 elfsym
= (elf_symbol_type
*) symdef
;
1460 += PPC64_LOCAL_ENTRY_OFFSET (elfsym
->internal_elf_sym
.st_other
);
1462 return bfd_reloc_continue
;
1465 static bfd_reloc_status_type
1466 ppc64_elf_brtaken_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1467 void *data
, asection
*input_section
,
1468 bfd
*output_bfd
, char **error_message
)
1471 enum elf_ppc64_reloc_type r_type
;
1472 bfd_size_type octets
;
1473 /* Assume 'at' branch hints. */
1474 bfd_boolean is_isa_v2
= TRUE
;
1476 /* If this is a relocatable link (output_bfd test tells us), just
1477 call the generic function. Any adjustment will be done at final
1479 if (output_bfd
!= NULL
)
1480 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1481 input_section
, output_bfd
, error_message
);
1483 octets
= reloc_entry
->address
* bfd_octets_per_byte (abfd
);
1484 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ octets
);
1485 insn
&= ~(0x01 << 21);
1486 r_type
= reloc_entry
->howto
->type
;
1487 if (r_type
== R_PPC64_ADDR14_BRTAKEN
1488 || r_type
== R_PPC64_REL14_BRTAKEN
)
1489 insn
|= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
1493 /* Set 'a' bit. This is 0b00010 in BO field for branch
1494 on CR(BI) insns (BO == 001at or 011at), and 0b01000
1495 for branch on CTR insns (BO == 1a00t or 1a01t). */
1496 if ((insn
& (0x14 << 21)) == (0x04 << 21))
1498 else if ((insn
& (0x14 << 21)) == (0x10 << 21))
1508 if (!bfd_is_com_section (symbol
->section
))
1509 target
= symbol
->value
;
1510 target
+= symbol
->section
->output_section
->vma
;
1511 target
+= symbol
->section
->output_offset
;
1512 target
+= reloc_entry
->addend
;
1514 from
= (reloc_entry
->address
1515 + input_section
->output_offset
1516 + input_section
->output_section
->vma
);
1518 /* Invert 'y' bit if not the default. */
1519 if ((bfd_signed_vma
) (target
- from
) < 0)
1522 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ octets
);
1524 return ppc64_elf_branch_reloc (abfd
, reloc_entry
, symbol
, data
,
1525 input_section
, output_bfd
, error_message
);
1528 static bfd_reloc_status_type
1529 ppc64_elf_sectoff_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1530 void *data
, asection
*input_section
,
1531 bfd
*output_bfd
, char **error_message
)
1533 /* If this is a relocatable link (output_bfd test tells us), just
1534 call the generic function. Any adjustment will be done at final
1536 if (output_bfd
!= NULL
)
1537 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1538 input_section
, output_bfd
, error_message
);
1540 /* Subtract the symbol section base address. */
1541 reloc_entry
->addend
-= symbol
->section
->output_section
->vma
;
1542 return bfd_reloc_continue
;
1545 static bfd_reloc_status_type
1546 ppc64_elf_sectoff_ha_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1547 void *data
, asection
*input_section
,
1548 bfd
*output_bfd
, char **error_message
)
1550 /* If this is a relocatable link (output_bfd test tells us), just
1551 call the generic function. Any adjustment will be done at final
1553 if (output_bfd
!= NULL
)
1554 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1555 input_section
, output_bfd
, error_message
);
1557 /* Subtract the symbol section base address. */
1558 reloc_entry
->addend
-= symbol
->section
->output_section
->vma
;
1560 /* Adjust the addend for sign extension of the low 16 bits. */
1561 reloc_entry
->addend
+= 0x8000;
1562 return bfd_reloc_continue
;
1565 static bfd_reloc_status_type
1566 ppc64_elf_toc_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1567 void *data
, asection
*input_section
,
1568 bfd
*output_bfd
, char **error_message
)
1572 /* If this is a relocatable link (output_bfd test tells us), just
1573 call the generic function. Any adjustment will be done at final
1575 if (output_bfd
!= NULL
)
1576 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1577 input_section
, output_bfd
, error_message
);
1579 TOCstart
= _bfd_get_gp_value (input_section
->output_section
->owner
);
1581 TOCstart
= ppc64_elf_set_toc (NULL
, input_section
->output_section
->owner
);
1583 /* Subtract the TOC base address. */
1584 reloc_entry
->addend
-= TOCstart
+ TOC_BASE_OFF
;
1585 return bfd_reloc_continue
;
1588 static bfd_reloc_status_type
1589 ppc64_elf_toc_ha_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1590 void *data
, asection
*input_section
,
1591 bfd
*output_bfd
, char **error_message
)
1595 /* If this is a relocatable link (output_bfd test tells us), just
1596 call the generic function. Any adjustment will be done at final
1598 if (output_bfd
!= NULL
)
1599 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1600 input_section
, output_bfd
, error_message
);
1602 TOCstart
= _bfd_get_gp_value (input_section
->output_section
->owner
);
1604 TOCstart
= ppc64_elf_set_toc (NULL
, input_section
->output_section
->owner
);
1606 /* Subtract the TOC base address. */
1607 reloc_entry
->addend
-= TOCstart
+ TOC_BASE_OFF
;
1609 /* Adjust the addend for sign extension of the low 16 bits. */
1610 reloc_entry
->addend
+= 0x8000;
1611 return bfd_reloc_continue
;
1614 static bfd_reloc_status_type
1615 ppc64_elf_toc64_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1616 void *data
, asection
*input_section
,
1617 bfd
*output_bfd
, char **error_message
)
1620 bfd_size_type octets
;
1622 /* If this is a relocatable link (output_bfd test tells us), just
1623 call the generic function. Any adjustment will be done at final
1625 if (output_bfd
!= NULL
)
1626 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1627 input_section
, output_bfd
, error_message
);
1629 TOCstart
= _bfd_get_gp_value (input_section
->output_section
->owner
);
1631 TOCstart
= ppc64_elf_set_toc (NULL
, input_section
->output_section
->owner
);
1633 octets
= reloc_entry
->address
* bfd_octets_per_byte (abfd
);
1634 bfd_put_64 (abfd
, TOCstart
+ TOC_BASE_OFF
, (bfd_byte
*) data
+ octets
);
1635 return bfd_reloc_ok
;
1638 static bfd_reloc_status_type
1639 ppc64_elf_prefix_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1640 void *data
, asection
*input_section
,
1641 bfd
*output_bfd
, char **error_message
)
1646 if (output_bfd
!= NULL
)
1647 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1648 input_section
, output_bfd
, error_message
);
1650 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1652 insn
|= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
+ 4);
1654 targ
= (symbol
->section
->output_section
->vma
1655 + symbol
->section
->output_offset
1656 + reloc_entry
->addend
);
1657 if (!bfd_is_com_section (symbol
->section
))
1658 targ
+= symbol
->value
;
1659 if (reloc_entry
->howto
->type
== R_PPC64_D34_HA30
)
1661 if (reloc_entry
->howto
->pc_relative
)
1663 bfd_vma from
= (reloc_entry
->address
1664 + input_section
->output_offset
1665 + input_section
->output_section
->vma
);
1668 targ
>>= reloc_entry
->howto
->rightshift
;
1669 insn
&= ~reloc_entry
->howto
->dst_mask
;
1670 insn
|= ((targ
<< 16) | (targ
& 0xffff)) & reloc_entry
->howto
->dst_mask
;
1671 bfd_put_32 (abfd
, insn
>> 32, (bfd_byte
*) data
+ reloc_entry
->address
);
1672 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ reloc_entry
->address
+ 4);
1673 if (reloc_entry
->howto
->complain_on_overflow
== complain_overflow_signed
1674 && (targ
+ (1ULL << (reloc_entry
->howto
->bitsize
- 1))
1675 >= 1ULL << reloc_entry
->howto
->bitsize
))
1676 return bfd_reloc_overflow
;
1677 return bfd_reloc_ok
;
1680 static bfd_reloc_status_type
1681 ppc64_elf_unhandled_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1682 void *data
, asection
*input_section
,
1683 bfd
*output_bfd
, char **error_message
)
1685 /* If this is a relocatable link (output_bfd test tells us), just
1686 call the generic function. Any adjustment will be done at final
1688 if (output_bfd
!= NULL
)
1689 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1690 input_section
, output_bfd
, error_message
);
1692 if (error_message
!= NULL
)
1694 static char buf
[60];
1695 sprintf (buf
, "generic linker can't handle %s",
1696 reloc_entry
->howto
->name
);
1697 *error_message
= buf
;
1699 return bfd_reloc_dangerous
;
1702 /* Track GOT entries needed for a given symbol. We might need more
1703 than one got entry per symbol. */
1706 struct got_entry
*next
;
1708 /* The symbol addend that we'll be placing in the GOT. */
1711 /* Unlike other ELF targets, we use separate GOT entries for the same
1712 symbol referenced from different input files. This is to support
1713 automatic multiple TOC/GOT sections, where the TOC base can vary
1714 from one input file to another. After partitioning into TOC groups
1715 we merge entries within the group.
1717 Point to the BFD owning this GOT entry. */
1720 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
1721 TLS_TPREL or TLS_DTPREL for tls entries. */
1722 unsigned char tls_type
;
1724 /* Non-zero if got.ent points to real entry. */
1725 unsigned char is_indirect
;
1727 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
1730 bfd_signed_vma refcount
;
1732 struct got_entry
*ent
;
1736 /* The same for PLT. */
1739 struct plt_entry
*next
;
1745 bfd_signed_vma refcount
;
1750 struct ppc64_elf_obj_tdata
1752 struct elf_obj_tdata elf
;
1754 /* Shortcuts to dynamic linker sections. */
1758 /* Used during garbage collection. We attach global symbols defined
1759 on removed .opd entries to this section so that the sym is removed. */
1760 asection
*deleted_section
;
1762 /* TLS local dynamic got entry handling. Support for multiple GOT
1763 sections means we potentially need one of these for each input bfd. */
1764 struct got_entry tlsld_got
;
1768 /* A copy of relocs before they are modified for --emit-relocs. */
1769 Elf_Internal_Rela
*relocs
;
1771 /* Section contents. */
1775 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
1776 the reloc to be in the range -32768 to 32767. */
1777 unsigned int has_small_toc_reloc
: 1;
1779 /* Set if toc/got ha relocs detected not using r2, or lo reloc
1780 instruction not one we handle. */
1781 unsigned int unexpected_toc_insn
: 1;
1783 /* Set if PLT/GOT/TOC relocs that can be optimised are present in
1785 unsigned int has_optrel
: 1;
1788 #define ppc64_elf_tdata(bfd) \
1789 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
1791 #define ppc64_tlsld_got(bfd) \
1792 (&ppc64_elf_tdata (bfd)->tlsld_got)
1794 #define is_ppc64_elf(bfd) \
1795 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
1796 && elf_object_id (bfd) == PPC64_ELF_DATA)
1798 /* Override the generic function because we store some extras. */
1801 ppc64_elf_mkobject (bfd
*abfd
)
1803 return bfd_elf_allocate_object (abfd
, sizeof (struct ppc64_elf_obj_tdata
),
1807 /* Fix bad default arch selected for a 64 bit input bfd when the
1808 default is 32 bit. Also select arch based on apuinfo. */
1811 ppc64_elf_object_p (bfd
*abfd
)
1813 if (!abfd
->arch_info
->the_default
)
1816 if (abfd
->arch_info
->bits_per_word
== 32)
1818 Elf_Internal_Ehdr
*i_ehdr
= elf_elfheader (abfd
);
1820 if (i_ehdr
->e_ident
[EI_CLASS
] == ELFCLASS64
)
1822 /* Relies on arch after 32 bit default being 64 bit default. */
1823 abfd
->arch_info
= abfd
->arch_info
->next
;
1824 BFD_ASSERT (abfd
->arch_info
->bits_per_word
== 64);
1827 return _bfd_elf_ppc_set_arch (abfd
);
1830 /* Support for core dump NOTE sections. */
1833 ppc64_elf_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
1835 size_t offset
, size
;
1837 if (note
->descsz
!= 504)
1841 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
1844 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 32);
1850 /* Make a ".reg/999" section. */
1851 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
1852 size
, note
->descpos
+ offset
);
1856 ppc64_elf_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
1858 if (note
->descsz
!= 136)
1861 elf_tdata (abfd
)->core
->pid
1862 = bfd_get_32 (abfd
, note
->descdata
+ 24);
1863 elf_tdata (abfd
)->core
->program
1864 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 40, 16);
1865 elf_tdata (abfd
)->core
->command
1866 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 56, 80);
1872 ppc64_elf_write_core_note (bfd
*abfd
, char *buf
, int *bufsiz
, int note_type
,
1882 char data
[136] ATTRIBUTE_NONSTRING
;
1885 va_start (ap
, note_type
);
1886 memset (data
, 0, sizeof (data
));
1887 strncpy (data
+ 40, va_arg (ap
, const char *), 16);
1888 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
1890 /* GCC 8.0 and 8.1 warn about 80 equals destination size with
1891 -Wstringop-truncation:
1892 https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85643
1894 DIAGNOSTIC_IGNORE_STRINGOP_TRUNCATION
;
1896 strncpy (data
+ 56, va_arg (ap
, const char *), 80);
1897 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
1901 return elfcore_write_note (abfd
, buf
, bufsiz
,
1902 "CORE", note_type
, data
, sizeof (data
));
1913 va_start (ap
, note_type
);
1914 memset (data
, 0, 112);
1915 pid
= va_arg (ap
, long);
1916 bfd_put_32 (abfd
, pid
, data
+ 32);
1917 cursig
= va_arg (ap
, int);
1918 bfd_put_16 (abfd
, cursig
, data
+ 12);
1919 greg
= va_arg (ap
, const void *);
1920 memcpy (data
+ 112, greg
, 384);
1921 memset (data
+ 496, 0, 8);
1923 return elfcore_write_note (abfd
, buf
, bufsiz
,
1924 "CORE", note_type
, data
, sizeof (data
));
1929 /* Add extra PPC sections. */
1931 static const struct bfd_elf_special_section ppc64_elf_special_sections
[] =
1933 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS
, 0 },
1934 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
1935 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
1936 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
1937 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
1938 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
1939 { NULL
, 0, 0, 0, 0 }
1942 enum _ppc64_sec_type
{
1948 struct _ppc64_elf_section_data
1950 struct bfd_elf_section_data elf
;
1954 /* An array with one entry for each opd function descriptor,
1955 and some spares since opd entries may be either 16 or 24 bytes. */
1956 #define OPD_NDX(OFF) ((OFF) >> 4)
1957 struct _opd_sec_data
1959 /* Points to the function code section for local opd entries. */
1960 asection
**func_sec
;
1962 /* After editing .opd, adjust references to opd local syms. */
1966 /* An array for toc sections, indexed by offset/8. */
1967 struct _toc_sec_data
1969 /* Specifies the relocation symbol index used at a given toc offset. */
1972 /* And the relocation addend. */
1977 enum _ppc64_sec_type sec_type
:2;
1979 /* Flag set when small branches are detected. Used to
1980 select suitable defaults for the stub group size. */
1981 unsigned int has_14bit_branch
:1;
1983 /* Flag set when PLTCALL relocs are detected. */
1984 unsigned int has_pltcall
:1;
1986 /* Flag set when section has PLT/GOT/TOC relocations that can be
1988 unsigned int has_optrel
:1;
1991 #define ppc64_elf_section_data(sec) \
1992 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
1995 ppc64_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
1997 if (!sec
->used_by_bfd
)
1999 struct _ppc64_elf_section_data
*sdata
;
2000 bfd_size_type amt
= sizeof (*sdata
);
2002 sdata
= bfd_zalloc (abfd
, amt
);
2005 sec
->used_by_bfd
= sdata
;
2008 return _bfd_elf_new_section_hook (abfd
, sec
);
2011 static struct _opd_sec_data
*
2012 get_opd_info (asection
* sec
)
2015 && ppc64_elf_section_data (sec
) != NULL
2016 && ppc64_elf_section_data (sec
)->sec_type
== sec_opd
)
2017 return &ppc64_elf_section_data (sec
)->u
.opd
;
2021 /* Parameters for the qsort hook. */
2022 static bfd_boolean synthetic_relocatable
;
2023 static asection
*synthetic_opd
;
2025 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
2028 compare_symbols (const void *ap
, const void *bp
)
2030 const asymbol
*a
= *(const asymbol
**) ap
;
2031 const asymbol
*b
= *(const asymbol
**) bp
;
2033 /* Section symbols first. */
2034 if ((a
->flags
& BSF_SECTION_SYM
) && !(b
->flags
& BSF_SECTION_SYM
))
2036 if (!(a
->flags
& BSF_SECTION_SYM
) && (b
->flags
& BSF_SECTION_SYM
))
2039 /* then .opd symbols. */
2040 if (synthetic_opd
!= NULL
)
2042 if (strcmp (a
->section
->name
, ".opd") == 0
2043 && strcmp (b
->section
->name
, ".opd") != 0)
2045 if (strcmp (a
->section
->name
, ".opd") != 0
2046 && strcmp (b
->section
->name
, ".opd") == 0)
2050 /* then other code symbols. */
2051 if (((a
->section
->flags
& (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
))
2052 == (SEC_CODE
| SEC_ALLOC
))
2053 && ((b
->section
->flags
& (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
))
2054 != (SEC_CODE
| SEC_ALLOC
)))
2057 if (((a
->section
->flags
& (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
))
2058 != (SEC_CODE
| SEC_ALLOC
))
2059 && ((b
->section
->flags
& (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
))
2060 == (SEC_CODE
| SEC_ALLOC
)))
2063 if (synthetic_relocatable
)
2065 if (a
->section
->id
< b
->section
->id
)
2068 if (a
->section
->id
> b
->section
->id
)
2072 if (a
->value
+ a
->section
->vma
< b
->value
+ b
->section
->vma
)
2075 if (a
->value
+ a
->section
->vma
> b
->value
+ b
->section
->vma
)
2078 /* For syms with the same value, prefer strong dynamic global function
2079 syms over other syms. */
2080 if ((a
->flags
& BSF_GLOBAL
) != 0 && (b
->flags
& BSF_GLOBAL
) == 0)
2083 if ((a
->flags
& BSF_GLOBAL
) == 0 && (b
->flags
& BSF_GLOBAL
) != 0)
2086 if ((a
->flags
& BSF_FUNCTION
) != 0 && (b
->flags
& BSF_FUNCTION
) == 0)
2089 if ((a
->flags
& BSF_FUNCTION
) == 0 && (b
->flags
& BSF_FUNCTION
) != 0)
2092 if ((a
->flags
& BSF_WEAK
) == 0 && (b
->flags
& BSF_WEAK
) != 0)
2095 if ((a
->flags
& BSF_WEAK
) != 0 && (b
->flags
& BSF_WEAK
) == 0)
2098 if ((a
->flags
& BSF_DYNAMIC
) != 0 && (b
->flags
& BSF_DYNAMIC
) == 0)
2101 if ((a
->flags
& BSF_DYNAMIC
) == 0 && (b
->flags
& BSF_DYNAMIC
) != 0)
2107 /* Search SYMS for a symbol of the given VALUE. */
2110 sym_exists_at (asymbol
**syms
, long lo
, long hi
, unsigned int id
, bfd_vma value
)
2114 if (id
== (unsigned) -1)
2118 mid
= (lo
+ hi
) >> 1;
2119 if (syms
[mid
]->value
+ syms
[mid
]->section
->vma
< value
)
2121 else if (syms
[mid
]->value
+ syms
[mid
]->section
->vma
> value
)
2131 mid
= (lo
+ hi
) >> 1;
2132 if (syms
[mid
]->section
->id
< id
)
2134 else if (syms
[mid
]->section
->id
> id
)
2136 else if (syms
[mid
]->value
< value
)
2138 else if (syms
[mid
]->value
> value
)
2148 section_covers_vma (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*section
, void *ptr
)
2150 bfd_vma vma
= *(bfd_vma
*) ptr
;
2151 return ((section
->flags
& SEC_ALLOC
) != 0
2152 && section
->vma
<= vma
2153 && vma
< section
->vma
+ section
->size
);
2156 /* Create synthetic symbols, effectively restoring "dot-symbol" function
2157 entry syms. Also generate @plt symbols for the glink branch table.
2158 Returns count of synthetic symbols in RET or -1 on error. */
2161 ppc64_elf_get_synthetic_symtab (bfd
*abfd
,
2162 long static_count
, asymbol
**static_syms
,
2163 long dyn_count
, asymbol
**dyn_syms
,
2169 size_t symcount
, codesecsym
, codesecsymend
, secsymend
, opdsymend
;
2170 asection
*opd
= NULL
;
2171 bfd_boolean relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2173 int abi
= abiversion (abfd
);
2179 opd
= bfd_get_section_by_name (abfd
, ".opd");
2180 if (opd
== NULL
&& abi
== 1)
2192 symcount
= static_count
;
2194 symcount
+= dyn_count
;
2198 syms
= bfd_malloc ((symcount
+ 1) * sizeof (*syms
));
2202 if (!relocatable
&& static_count
!= 0 && dyn_count
!= 0)
2204 /* Use both symbol tables. */
2205 memcpy (syms
, static_syms
, static_count
* sizeof (*syms
));
2206 memcpy (syms
+ static_count
, dyn_syms
,
2207 (dyn_count
+ 1) * sizeof (*syms
));
2209 else if (!relocatable
&& static_count
== 0)
2210 memcpy (syms
, dyn_syms
, (symcount
+ 1) * sizeof (*syms
));
2212 memcpy (syms
, static_syms
, (symcount
+ 1) * sizeof (*syms
));
2214 /* Trim uninteresting symbols. Interesting symbols are section,
2215 function, and notype symbols. */
2216 for (i
= 0, j
= 0; i
< symcount
; ++i
)
2217 if ((syms
[i
]->flags
& (BSF_FILE
| BSF_OBJECT
| BSF_THREAD_LOCAL
2218 | BSF_RELC
| BSF_SRELC
)) == 0)
2219 syms
[j
++] = syms
[i
];
2222 synthetic_relocatable
= relocatable
;
2223 synthetic_opd
= opd
;
2224 qsort (syms
, symcount
, sizeof (*syms
), compare_symbols
);
2226 if (!relocatable
&& symcount
> 1)
2228 /* Trim duplicate syms, since we may have merged the normal
2229 and dynamic symbols. Actually, we only care about syms
2230 that have different values, so trim any with the same
2231 value. Don't consider ifunc and ifunc resolver symbols
2232 duplicates however, because GDB wants to know whether a
2233 text symbol is an ifunc resolver. */
2234 for (i
= 1, j
= 1; i
< symcount
; ++i
)
2236 const asymbol
*s0
= syms
[i
- 1];
2237 const asymbol
*s1
= syms
[i
];
2239 if ((s0
->value
+ s0
->section
->vma
2240 != s1
->value
+ s1
->section
->vma
)
2241 || ((s0
->flags
& BSF_GNU_INDIRECT_FUNCTION
)
2242 != (s1
->flags
& BSF_GNU_INDIRECT_FUNCTION
)))
2243 syms
[j
++] = syms
[i
];
2249 /* Note that here and in compare_symbols we can't compare opd and
2250 sym->section directly. With separate debug info files, the
2251 symbols will be extracted from the debug file while abfd passed
2252 to this function is the real binary. */
2253 if (strcmp (syms
[i
]->section
->name
, ".opd") == 0)
2257 for (; i
< symcount
; ++i
)
2258 if (((syms
[i
]->section
->flags
& (SEC_CODE
| SEC_ALLOC
2259 | SEC_THREAD_LOCAL
))
2260 != (SEC_CODE
| SEC_ALLOC
))
2261 || (syms
[i
]->flags
& BSF_SECTION_SYM
) == 0)
2265 for (; i
< symcount
; ++i
)
2266 if ((syms
[i
]->flags
& BSF_SECTION_SYM
) == 0)
2270 for (; i
< symcount
; ++i
)
2271 if (strcmp (syms
[i
]->section
->name
, ".opd") != 0)
2275 for (; i
< symcount
; ++i
)
2276 if (((syms
[i
]->section
->flags
2277 & (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
)))
2278 != (SEC_CODE
| SEC_ALLOC
))
2286 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
2291 if (opdsymend
== secsymend
)
2294 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
2295 relcount
= (opd
->flags
& SEC_RELOC
) ? opd
->reloc_count
: 0;
2299 if (!(*slurp_relocs
) (abfd
, opd
, static_syms
, FALSE
))
2306 for (i
= secsymend
, r
= opd
->relocation
; i
< opdsymend
; ++i
)
2310 while (r
< opd
->relocation
+ relcount
2311 && r
->address
< syms
[i
]->value
+ opd
->vma
)
2314 if (r
== opd
->relocation
+ relcount
)
2317 if (r
->address
!= syms
[i
]->value
+ opd
->vma
)
2320 if (r
->howto
->type
!= R_PPC64_ADDR64
)
2323 sym
= *r
->sym_ptr_ptr
;
2324 if (!sym_exists_at (syms
, opdsymend
, symcount
,
2325 sym
->section
->id
, sym
->value
+ r
->addend
))
2328 size
+= sizeof (asymbol
);
2329 size
+= strlen (syms
[i
]->name
) + 2;
2335 s
= *ret
= bfd_malloc (size
);
2342 names
= (char *) (s
+ count
);
2344 for (i
= secsymend
, r
= opd
->relocation
; i
< opdsymend
; ++i
)
2348 while (r
< opd
->relocation
+ relcount
2349 && r
->address
< syms
[i
]->value
+ opd
->vma
)
2352 if (r
== opd
->relocation
+ relcount
)
2355 if (r
->address
!= syms
[i
]->value
+ opd
->vma
)
2358 if (r
->howto
->type
!= R_PPC64_ADDR64
)
2361 sym
= *r
->sym_ptr_ptr
;
2362 if (!sym_exists_at (syms
, opdsymend
, symcount
,
2363 sym
->section
->id
, sym
->value
+ r
->addend
))
2368 s
->flags
|= BSF_SYNTHETIC
;
2369 s
->section
= sym
->section
;
2370 s
->value
= sym
->value
+ r
->addend
;
2373 len
= strlen (syms
[i
]->name
);
2374 memcpy (names
, syms
[i
]->name
, len
+ 1);
2376 /* Have udata.p point back to the original symbol this
2377 synthetic symbol was derived from. */
2378 s
->udata
.p
= syms
[i
];
2385 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
2386 bfd_byte
*contents
= NULL
;
2388 size_t plt_count
= 0;
2389 bfd_vma glink_vma
= 0, resolv_vma
= 0;
2390 asection
*dynamic
, *glink
= NULL
, *relplt
= NULL
;
2393 if (opd
!= NULL
&& !bfd_malloc_and_get_section (abfd
, opd
, &contents
))
2395 free_contents_and_exit_err
:
2397 free_contents_and_exit
:
2404 for (i
= secsymend
; i
< opdsymend
; ++i
)
2408 /* Ignore bogus symbols. */
2409 if (syms
[i
]->value
> opd
->size
- 8)
2412 ent
= bfd_get_64 (abfd
, contents
+ syms
[i
]->value
);
2413 if (!sym_exists_at (syms
, opdsymend
, symcount
, -1, ent
))
2416 size
+= sizeof (asymbol
);
2417 size
+= strlen (syms
[i
]->name
) + 2;
2421 /* Get start of .glink stubs from DT_PPC64_GLINK. */
2423 && (dynamic
= bfd_get_section_by_name (abfd
, ".dynamic")) != NULL
)
2425 bfd_byte
*dynbuf
, *extdyn
, *extdynend
;
2427 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
2429 if (!bfd_malloc_and_get_section (abfd
, dynamic
, &dynbuf
))
2430 goto free_contents_and_exit_err
;
2432 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
2433 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
2436 extdynend
= extdyn
+ dynamic
->size
;
2437 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
2439 Elf_Internal_Dyn dyn
;
2440 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
2442 if (dyn
.d_tag
== DT_NULL
)
2445 if (dyn
.d_tag
== DT_PPC64_GLINK
)
2447 /* The first glink stub starts at DT_PPC64_GLINK plus 32.
2448 See comment in ppc64_elf_finish_dynamic_sections. */
2449 glink_vma
= dyn
.d_un
.d_val
+ 8 * 4;
2450 /* The .glink section usually does not survive the final
2451 link; search for the section (usually .text) where the
2452 glink stubs now reside. */
2453 glink
= bfd_sections_find_if (abfd
, section_covers_vma
,
2464 /* Determine __glink trampoline by reading the relative branch
2465 from the first glink stub. */
2467 unsigned int off
= 0;
2469 while (bfd_get_section_contents (abfd
, glink
, buf
,
2470 glink_vma
+ off
- glink
->vma
, 4))
2472 unsigned int insn
= bfd_get_32 (abfd
, buf
);
2474 if ((insn
& ~0x3fffffc) == 0)
2477 = glink_vma
+ off
+ (insn
^ 0x2000000) - 0x2000000;
2486 size
+= sizeof (asymbol
) + sizeof ("__glink_PLTresolve");
2488 relplt
= bfd_get_section_by_name (abfd
, ".rela.plt");
2491 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
2492 if (!(*slurp_relocs
) (abfd
, relplt
, dyn_syms
, TRUE
))
2493 goto free_contents_and_exit_err
;
2495 plt_count
= relplt
->size
/ sizeof (Elf64_External_Rela
);
2496 size
+= plt_count
* sizeof (asymbol
);
2498 p
= relplt
->relocation
;
2499 for (i
= 0; i
< plt_count
; i
++, p
++)
2501 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
2503 size
+= sizeof ("+0x") - 1 + 16;
2509 goto free_contents_and_exit
;
2510 s
= *ret
= bfd_malloc (size
);
2512 goto free_contents_and_exit_err
;
2514 names
= (char *) (s
+ count
+ plt_count
+ (resolv_vma
!= 0));
2516 for (i
= secsymend
; i
< opdsymend
; ++i
)
2520 if (syms
[i
]->value
> opd
->size
- 8)
2523 ent
= bfd_get_64 (abfd
, contents
+ syms
[i
]->value
);
2524 if (!sym_exists_at (syms
, opdsymend
, symcount
, -1, ent
))
2528 asection
*sec
= abfd
->sections
;
2535 size_t mid
= (lo
+ hi
) >> 1;
2536 if (syms
[mid
]->section
->vma
< ent
)
2538 else if (syms
[mid
]->section
->vma
> ent
)
2542 sec
= syms
[mid
]->section
;
2547 if (lo
>= hi
&& lo
> codesecsym
)
2548 sec
= syms
[lo
- 1]->section
;
2550 for (; sec
!= NULL
; sec
= sec
->next
)
2554 /* SEC_LOAD may not be set if SEC is from a separate debug
2556 if ((sec
->flags
& SEC_ALLOC
) == 0)
2558 if ((sec
->flags
& SEC_CODE
) != 0)
2561 s
->flags
|= BSF_SYNTHETIC
;
2562 s
->value
= ent
- s
->section
->vma
;
2565 len
= strlen (syms
[i
]->name
);
2566 memcpy (names
, syms
[i
]->name
, len
+ 1);
2568 /* Have udata.p point back to the original symbol this
2569 synthetic symbol was derived from. */
2570 s
->udata
.p
= syms
[i
];
2576 if (glink
!= NULL
&& relplt
!= NULL
)
2580 /* Add a symbol for the main glink trampoline. */
2581 memset (s
, 0, sizeof *s
);
2583 s
->flags
= BSF_GLOBAL
| BSF_SYNTHETIC
;
2585 s
->value
= resolv_vma
- glink
->vma
;
2587 memcpy (names
, "__glink_PLTresolve",
2588 sizeof ("__glink_PLTresolve"));
2589 names
+= sizeof ("__glink_PLTresolve");
2594 /* FIXME: It would be very much nicer to put sym@plt on the
2595 stub rather than on the glink branch table entry. The
2596 objdump disassembler would then use a sensible symbol
2597 name on plt calls. The difficulty in doing so is
2598 a) finding the stubs, and,
2599 b) matching stubs against plt entries, and,
2600 c) there can be multiple stubs for a given plt entry.
2602 Solving (a) could be done by code scanning, but older
2603 ppc64 binaries used different stubs to current code.
2604 (b) is the tricky one since you need to known the toc
2605 pointer for at least one function that uses a pic stub to
2606 be able to calculate the plt address referenced.
2607 (c) means gdb would need to set multiple breakpoints (or
2608 find the glink branch itself) when setting breakpoints
2609 for pending shared library loads. */
2610 p
= relplt
->relocation
;
2611 for (i
= 0; i
< plt_count
; i
++, p
++)
2615 *s
= **p
->sym_ptr_ptr
;
2616 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
2617 we are defining a symbol, ensure one of them is set. */
2618 if ((s
->flags
& BSF_LOCAL
) == 0)
2619 s
->flags
|= BSF_GLOBAL
;
2620 s
->flags
|= BSF_SYNTHETIC
;
2622 s
->value
= glink_vma
- glink
->vma
;
2625 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
2626 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
2630 memcpy (names
, "+0x", sizeof ("+0x") - 1);
2631 names
+= sizeof ("+0x") - 1;
2632 bfd_sprintf_vma (abfd
, names
, p
->addend
);
2633 names
+= strlen (names
);
2635 memcpy (names
, "@plt", sizeof ("@plt"));
2636 names
+= sizeof ("@plt");
2656 /* The following functions are specific to the ELF linker, while
2657 functions above are used generally. Those named ppc64_elf_* are
2658 called by the main ELF linker code. They appear in this file more
2659 or less in the order in which they are called. eg.
2660 ppc64_elf_check_relocs is called early in the link process,
2661 ppc64_elf_finish_dynamic_sections is one of the last functions
2664 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
2665 functions have both a function code symbol and a function descriptor
2666 symbol. A call to foo in a relocatable object file looks like:
2673 The function definition in another object file might be:
2677 . .quad .TOC.@tocbase
2683 When the linker resolves the call during a static link, the branch
2684 unsurprisingly just goes to .foo and the .opd information is unused.
2685 If the function definition is in a shared library, things are a little
2686 different: The call goes via a plt call stub, the opd information gets
2687 copied to the plt, and the linker patches the nop.
2695 . std 2,40(1) # in practice, the call stub
2696 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
2697 . addi 11,11,Lfoo@toc@l # this is the general idea
2705 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
2707 The "reloc ()" notation is supposed to indicate that the linker emits
2708 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
2711 What are the difficulties here? Well, firstly, the relocations
2712 examined by the linker in check_relocs are against the function code
2713 sym .foo, while the dynamic relocation in the plt is emitted against
2714 the function descriptor symbol, foo. Somewhere along the line, we need
2715 to carefully copy dynamic link information from one symbol to the other.
2716 Secondly, the generic part of the elf linker will make .foo a dynamic
2717 symbol as is normal for most other backends. We need foo dynamic
2718 instead, at least for an application final link. However, when
2719 creating a shared library containing foo, we need to have both symbols
2720 dynamic so that references to .foo are satisfied during the early
2721 stages of linking. Otherwise the linker might decide to pull in a
2722 definition from some other object, eg. a static library.
2724 Update: As of August 2004, we support a new convention. Function
2725 calls may use the function descriptor symbol, ie. "bl foo". This
2726 behaves exactly as "bl .foo". */
2728 /* Of those relocs that might be copied as dynamic relocs, this
2729 function selects those that must be copied when linking a shared
2730 library or PIE, even when the symbol is local. */
2733 must_be_dyn_reloc (struct bfd_link_info
*info
,
2734 enum elf_ppc64_reloc_type r_type
)
2739 /* Only relative relocs can be resolved when the object load
2740 address isn't fixed. DTPREL64 is excluded because the
2741 dynamic linker needs to differentiate global dynamic from
2742 local dynamic __tls_index pairs when PPC64_OPT_TLS is set. */
2750 case R_PPC64_TPREL16
:
2751 case R_PPC64_TPREL16_LO
:
2752 case R_PPC64_TPREL16_HI
:
2753 case R_PPC64_TPREL16_HA
:
2754 case R_PPC64_TPREL16_DS
:
2755 case R_PPC64_TPREL16_LO_DS
:
2756 case R_PPC64_TPREL16_HIGH
:
2757 case R_PPC64_TPREL16_HIGHA
:
2758 case R_PPC64_TPREL16_HIGHER
:
2759 case R_PPC64_TPREL16_HIGHERA
:
2760 case R_PPC64_TPREL16_HIGHEST
:
2761 case R_PPC64_TPREL16_HIGHESTA
:
2762 case R_PPC64_TPREL64
:
2763 case R_PPC64_TPREL34
:
2764 /* These relocations are relative but in a shared library the
2765 linker doesn't know the thread pointer base. */
2766 return bfd_link_dll (info
);
2770 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
2771 copying dynamic variables from a shared lib into an app's dynbss
2772 section, and instead use a dynamic relocation to point into the
2773 shared lib. With code that gcc generates, it's vital that this be
2774 enabled; In the PowerPC64 ABI, the address of a function is actually
2775 the address of a function descriptor, which resides in the .opd
2776 section. gcc uses the descriptor directly rather than going via the
2777 GOT as some other ABI's do, which means that initialized function
2778 pointers must reference the descriptor. Thus, a function pointer
2779 initialized to the address of a function in a shared library will
2780 either require a copy reloc, or a dynamic reloc. Using a copy reloc
2781 redefines the function descriptor symbol to point to the copy. This
2782 presents a problem as a plt entry for that function is also
2783 initialized from the function descriptor symbol and the copy reloc
2784 may not be initialized first. */
2785 #define ELIMINATE_COPY_RELOCS 1
2787 /* Section name for stubs is the associated section name plus this
2789 #define STUB_SUFFIX ".stub"
2792 ppc_stub_long_branch:
2793 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
2794 destination, but a 24 bit branch in a stub section will reach.
2797 ppc_stub_plt_branch:
2798 Similar to the above, but a 24 bit branch in the stub section won't
2799 reach its destination.
2800 . addis %r11,%r2,xxx@toc@ha
2801 . ld %r12,xxx@toc@l(%r11)
2806 Used to call a function in a shared library. If it so happens that
2807 the plt entry referenced crosses a 64k boundary, then an extra
2808 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
2809 ppc_stub_plt_call_r2save starts with "std %r2,40(%r1)".
2810 . addis %r11,%r2,xxx@toc@ha
2811 . ld %r12,xxx+0@toc@l(%r11)
2813 . ld %r2,xxx+8@toc@l(%r11)
2814 . ld %r11,xxx+16@toc@l(%r11)
2817 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
2818 code to adjust the value and save r2 to support multiple toc sections.
2819 A ppc_stub_long_branch with an r2 offset looks like:
2821 . addis %r2,%r2,off@ha
2822 . addi %r2,%r2,off@l
2825 A ppc_stub_plt_branch with an r2 offset looks like:
2827 . addis %r11,%r2,xxx@toc@ha
2828 . ld %r12,xxx@toc@l(%r11)
2829 . addis %r2,%r2,off@ha
2830 . addi %r2,%r2,off@l
2834 All of the above stubs are shown as their ELFv1 variants. ELFv2
2835 variants exist too, simpler for plt calls since a new toc pointer
2836 and static chain are not loaded by the stub. In addition, ELFv2
2837 has some more complex stubs to handle calls marked with NOTOC
2838 relocs from functions where r2 is not a valid toc pointer. These
2839 come in two flavours, the ones shown below, and _both variants that
2840 start with "std %r2,24(%r1)" to save r2 in the unlikely event that
2841 one call is from a function where r2 is used as the toc pointer but
2842 needs a toc adjusting stub for small-model multi-toc, and another
2843 call is from a function where r2 is not valid.
2844 ppc_stub_long_branch_notoc:
2850 . addis %r12,%r11,dest-1b@ha
2851 . addi %r12,%r12,dest-1b@l
2854 ppc_stub_plt_branch_notoc:
2860 . lis %r12,xxx-1b@highest
2861 . ori %r12,%r12,xxx-1b@higher
2863 . oris %r12,%r12,xxx-1b@high
2864 . ori %r12,%r12,xxx-1b@l
2865 . add %r12,%r11,%r12
2869 ppc_stub_plt_call_notoc:
2875 . lis %r12,xxx-1b@highest
2876 . ori %r12,%r12,xxx-1b@higher
2878 . oris %r12,%r12,xxx-1b@high
2879 . ori %r12,%r12,xxx-1b@l
2880 . ldx %r12,%r11,%r12
2884 There are also ELFv1 powerxx variants of these stubs.
2885 ppc_stub_long_branch_notoc:
2886 . pla %r12,dest@pcrel
2888 ppc_stub_plt_branch_notoc:
2889 . lis %r11,(dest-1f)@highesta34
2890 . ori %r11,%r11,(dest-1f)@highera34
2892 . 1: pla %r12,dest@pcrel
2893 . add %r12,%r11,%r12
2896 ppc_stub_plt_call_notoc:
2897 . lis %r11,(xxx-1f)@highesta34
2898 . ori %r11,%r11,(xxx-1f)@highera34
2900 . 1: pla %r12,xxx@pcrel
2901 . ldx %r12,%r11,%r12
2905 In cases where the high instructions would add zero, they are
2906 omitted and following instructions modified in some cases.
2907 For example, a powerxx ppc_stub_plt_call_notoc might simplify down
2909 . pld %r12,xxx@pcrel
2913 For a given stub group (a set of sections all using the same toc
2914 pointer value) there will be just one stub type used for any
2915 particular function symbol. For example, if printf is called from
2916 code with the tocsave optimization (ie. r2 saved in function
2917 prologue) and therefore calls use a ppc_stub_plt_call linkage stub,
2918 and from other code without the tocsave optimization requiring a
2919 ppc_stub_plt_call_r2save linkage stub, a single stub of the latter
2920 type will be created. Calls with the tocsave optimization will
2921 enter this stub after the instruction saving r2. A similar
2922 situation exists when calls are marked with R_PPC64_REL24_NOTOC
2923 relocations. These require a ppc_stub_plt_call_notoc linkage stub
2924 to call an external function like printf. If other calls to printf
2925 require a ppc_stub_plt_call linkage stub then a single
2926 ppc_stub_plt_call_notoc linkage stub will be used for both types of
2927 call. If other calls to printf require a ppc_stub_plt_call_r2save
2928 linkage stub then a single ppc_stub_plt_call_both linkage stub will
2929 be created and calls not requiring r2 to be saved will enter the
2930 stub after the r2 save instruction. There is an analogous
2931 hierarchy of long branch and plt branch stubs for local call
2937 ppc_stub_long_branch
,
2938 ppc_stub_long_branch_r2off
,
2939 ppc_stub_long_branch_notoc
,
2940 ppc_stub_long_branch_both
, /* r2off and notoc variants both needed. */
2941 ppc_stub_plt_branch
,
2942 ppc_stub_plt_branch_r2off
,
2943 ppc_stub_plt_branch_notoc
,
2944 ppc_stub_plt_branch_both
,
2946 ppc_stub_plt_call_r2save
,
2947 ppc_stub_plt_call_notoc
,
2948 ppc_stub_plt_call_both
,
2949 ppc_stub_global_entry
,
2953 /* Information on stub grouping. */
2956 /* The stub section. */
2958 /* This is the section to which stubs in the group will be attached. */
2961 struct map_stub
*next
;
2962 /* Whether to emit a copy of register save/restore functions in this
2965 /* Current offset within stubs after the insn restoring lr in a
2966 _notoc or _both stub using bcl for pc-relative addressing, or
2967 after the insn restoring lr in a __tls_get_addr_opt plt stub. */
2968 unsigned int lr_restore
;
2969 /* Accumulated size of EH info emitted to describe return address
2970 if stubs modify lr. Does not include 17 byte FDE header. */
2971 unsigned int eh_size
;
2972 /* Offset in glink_eh_frame to the start of EH info for this group. */
2973 unsigned int eh_base
;
2976 struct ppc_stub_hash_entry
2978 /* Base hash table entry structure. */
2979 struct bfd_hash_entry root
;
2981 enum ppc_stub_type stub_type
;
2983 /* Group information. */
2984 struct map_stub
*group
;
2986 /* Offset within stub_sec of the beginning of this stub. */
2987 bfd_vma stub_offset
;
2989 /* Given the symbol's value and its section we can determine its final
2990 value when building the stubs (so the stub knows where to jump. */
2991 bfd_vma target_value
;
2992 asection
*target_section
;
2994 /* The symbol table entry, if any, that this was derived from. */
2995 struct ppc_link_hash_entry
*h
;
2996 struct plt_entry
*plt_ent
;
2999 unsigned char symtype
;
3001 /* Symbol st_other. */
3002 unsigned char other
;
3005 struct ppc_branch_hash_entry
3007 /* Base hash table entry structure. */
3008 struct bfd_hash_entry root
;
3010 /* Offset within branch lookup table. */
3011 unsigned int offset
;
3013 /* Generation marker. */
3017 /* Used to track dynamic relocations for local symbols. */
3018 struct ppc_dyn_relocs
3020 struct ppc_dyn_relocs
*next
;
3022 /* The input section of the reloc. */
3025 /* Total number of relocs copied for the input section. */
3026 unsigned int count
: 31;
3028 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3029 unsigned int ifunc
: 1;
3032 struct ppc_link_hash_entry
3034 struct elf_link_hash_entry elf
;
3038 /* A pointer to the most recently used stub hash entry against this
3040 struct ppc_stub_hash_entry
*stub_cache
;
3042 /* A pointer to the next symbol starting with a '.' */
3043 struct ppc_link_hash_entry
*next_dot_sym
;
3046 /* Track dynamic relocs copied for this symbol. */
3047 struct elf_dyn_relocs
*dyn_relocs
;
3049 /* Link between function code and descriptor symbols. */
3050 struct ppc_link_hash_entry
*oh
;
3052 /* Flag function code and descriptor symbols. */
3053 unsigned int is_func
:1;
3054 unsigned int is_func_descriptor
:1;
3055 unsigned int fake
:1;
3057 /* Whether global opd/toc sym has been adjusted or not.
3058 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3059 should be set for all globals defined in any opd/toc section. */
3060 unsigned int adjust_done
:1;
3062 /* Set if this is an out-of-line register save/restore function,
3063 with non-standard calling convention. */
3064 unsigned int save_res
:1;
3066 /* Set if a duplicate symbol with non-zero localentry is detected,
3067 even when the duplicate symbol does not provide a definition. */
3068 unsigned int non_zero_localentry
:1;
3070 /* Contexts in which symbol is used in the GOT (or TOC).
3071 Bits are or'd into the mask as the corresponding relocs are
3072 encountered during check_relocs, with TLS_TLS being set when any
3073 of the other TLS bits are set. tls_optimize clears bits when
3074 optimizing to indicate the corresponding GOT entry type is not
3075 needed. If set, TLS_TLS is never cleared. tls_optimize may also
3076 set TLS_GDIE when a GD reloc turns into an IE one.
3077 These flags are also kept for local symbols. */
3078 #define TLS_TLS 1 /* Any TLS reloc. */
3079 #define TLS_GD 2 /* GD reloc. */
3080 #define TLS_LD 4 /* LD reloc. */
3081 #define TLS_TPREL 8 /* TPREL reloc, => IE. */
3082 #define TLS_DTPREL 16 /* DTPREL reloc, => LD. */
3083 #define TLS_MARK 32 /* __tls_get_addr call marked. */
3084 #define TLS_GDIE 64 /* GOT TPREL reloc resulting from GD->IE. */
3085 #define TLS_EXPLICIT 256 /* TOC section TLS reloc, not stored. */
3086 unsigned char tls_mask
;
3088 /* The above field is also used to mark function symbols. In which
3089 case TLS_TLS will be 0. */
3090 #define PLT_IFUNC 2 /* STT_GNU_IFUNC. */
3091 #define PLT_KEEP 4 /* inline plt call requires plt entry. */
3092 #define NON_GOT 256 /* local symbol plt, not stored. */
3095 /* ppc64 ELF linker hash table. */
3097 struct ppc_link_hash_table
3099 struct elf_link_hash_table elf
;
3101 /* The stub hash table. */
3102 struct bfd_hash_table stub_hash_table
;
3104 /* Another hash table for plt_branch stubs. */
3105 struct bfd_hash_table branch_hash_table
;
3107 /* Hash table for function prologue tocsave. */
3108 htab_t tocsave_htab
;
3110 /* Various options and other info passed from the linker. */
3111 struct ppc64_elf_params
*params
;
3113 /* The size of sec_info below. */
3114 unsigned int sec_info_arr_size
;
3116 /* Per-section array of extra section info. Done this way rather
3117 than as part of ppc64_elf_section_data so we have the info for
3118 non-ppc64 sections. */
3121 /* Along with elf_gp, specifies the TOC pointer used by this section. */
3126 /* The section group that this section belongs to. */
3127 struct map_stub
*group
;
3128 /* A temp section list pointer. */
3133 /* Linked list of groups. */
3134 struct map_stub
*group
;
3136 /* Temp used when calculating TOC pointers. */
3139 asection
*toc_first_sec
;
3141 /* Used when adding symbols. */
3142 struct ppc_link_hash_entry
*dot_syms
;
3144 /* Shortcuts to get to dynamic linker sections. */
3146 asection
*global_entry
;
3149 asection
*relpltlocal
;
3152 asection
*glink_eh_frame
;
3154 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
3155 struct ppc_link_hash_entry
*tls_get_addr
;
3156 struct ppc_link_hash_entry
*tls_get_addr_fd
;
3158 /* The size of reliplt used by got entry relocs. */
3159 bfd_size_type got_reli_size
;
3162 unsigned long stub_count
[ppc_stub_global_entry
];
3164 /* Number of stubs against global syms. */
3165 unsigned long stub_globals
;
3167 /* Set if we're linking code with function descriptors. */
3168 unsigned int opd_abi
:1;
3170 /* Support for multiple toc sections. */
3171 unsigned int do_multi_toc
:1;
3172 unsigned int multi_toc_needed
:1;
3173 unsigned int second_toc_pass
:1;
3174 unsigned int do_toc_opt
:1;
3176 /* Set if tls optimization is enabled. */
3177 unsigned int do_tls_opt
:1;
3179 /* Set if inline plt calls should be converted to direct calls. */
3180 unsigned int can_convert_all_inline_plt
:1;
3183 unsigned int stub_error
:1;
3185 /* Whether func_desc_adjust needs to be run over symbols. */
3186 unsigned int need_func_desc_adj
:1;
3188 /* Whether there exist local gnu indirect function resolvers,
3189 referenced by dynamic relocations. */
3190 unsigned int local_ifunc_resolver
:1;
3191 unsigned int maybe_local_ifunc_resolver
:1;
3193 /* Whether plt calls for ELFv2 localentry:0 funcs have been optimized. */
3194 unsigned int has_plt_localentry0
:1;
3196 /* Whether calls are made via the PLT from NOTOC functions. */
3197 unsigned int notoc_plt
:1;
3199 /* Whether to use powerxx instructions in linkage stubs. */
3200 unsigned int powerxx_stubs
:1;
3202 /* Incremented every time we size stubs. */
3203 unsigned int stub_iteration
;
3205 /* Small local sym cache. */
3206 struct sym_cache sym_cache
;
3209 /* Rename some of the generic section flags to better document how they
3212 /* Nonzero if this section has TLS related relocations. */
3213 #define has_tls_reloc sec_flg0
3215 /* Nonzero if this section has an old-style call to __tls_get_addr. */
3216 #define has_tls_get_addr_call sec_flg1
3218 /* Nonzero if this section has any toc or got relocs. */
3219 #define has_toc_reloc sec_flg2
3221 /* Nonzero if this section has a call to another section that uses
3223 #define makes_toc_func_call sec_flg3
3225 /* Recursion protection when determining above flag. */
3226 #define call_check_in_progress sec_flg4
3227 #define call_check_done sec_flg5
3229 /* Get the ppc64 ELF linker hash table from a link_info structure. */
3231 #define ppc_hash_table(p) \
3232 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3233 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3235 #define ppc_stub_hash_lookup(table, string, create, copy) \
3236 ((struct ppc_stub_hash_entry *) \
3237 bfd_hash_lookup ((table), (string), (create), (copy)))
3239 #define ppc_branch_hash_lookup(table, string, create, copy) \
3240 ((struct ppc_branch_hash_entry *) \
3241 bfd_hash_lookup ((table), (string), (create), (copy)))
3243 /* Create an entry in the stub hash table. */
3245 static struct bfd_hash_entry
*
3246 stub_hash_newfunc (struct bfd_hash_entry
*entry
,
3247 struct bfd_hash_table
*table
,
3250 /* Allocate the structure if it has not already been allocated by a
3254 entry
= bfd_hash_allocate (table
, sizeof (struct ppc_stub_hash_entry
));
3259 /* Call the allocation method of the superclass. */
3260 entry
= bfd_hash_newfunc (entry
, table
, string
);
3263 struct ppc_stub_hash_entry
*eh
;
3265 /* Initialize the local fields. */
3266 eh
= (struct ppc_stub_hash_entry
*) entry
;
3267 eh
->stub_type
= ppc_stub_none
;
3269 eh
->stub_offset
= 0;
3270 eh
->target_value
= 0;
3271 eh
->target_section
= NULL
;
3280 /* Create an entry in the branch hash table. */
3282 static struct bfd_hash_entry
*
3283 branch_hash_newfunc (struct bfd_hash_entry
*entry
,
3284 struct bfd_hash_table
*table
,
3287 /* Allocate the structure if it has not already been allocated by a
3291 entry
= bfd_hash_allocate (table
, sizeof (struct ppc_branch_hash_entry
));
3296 /* Call the allocation method of the superclass. */
3297 entry
= bfd_hash_newfunc (entry
, table
, string
);
3300 struct ppc_branch_hash_entry
*eh
;
3302 /* Initialize the local fields. */
3303 eh
= (struct ppc_branch_hash_entry
*) entry
;
3311 /* Create an entry in a ppc64 ELF linker hash table. */
3313 static struct bfd_hash_entry
*
3314 link_hash_newfunc (struct bfd_hash_entry
*entry
,
3315 struct bfd_hash_table
*table
,
3318 /* Allocate the structure if it has not already been allocated by a
3322 entry
= bfd_hash_allocate (table
, sizeof (struct ppc_link_hash_entry
));
3327 /* Call the allocation method of the superclass. */
3328 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
3331 struct ppc_link_hash_entry
*eh
= (struct ppc_link_hash_entry
*) entry
;
3333 memset (&eh
->u
.stub_cache
, 0,
3334 (sizeof (struct ppc_link_hash_entry
)
3335 - offsetof (struct ppc_link_hash_entry
, u
.stub_cache
)));
3337 /* When making function calls, old ABI code references function entry
3338 points (dot symbols), while new ABI code references the function
3339 descriptor symbol. We need to make any combination of reference and
3340 definition work together, without breaking archive linking.
3342 For a defined function "foo" and an undefined call to "bar":
3343 An old object defines "foo" and ".foo", references ".bar" (possibly
3345 A new object defines "foo" and references "bar".
3347 A new object thus has no problem with its undefined symbols being
3348 satisfied by definitions in an old object. On the other hand, the
3349 old object won't have ".bar" satisfied by a new object.
3351 Keep a list of newly added dot-symbols. */
3353 if (string
[0] == '.')
3355 struct ppc_link_hash_table
*htab
;
3357 htab
= (struct ppc_link_hash_table
*) table
;
3358 eh
->u
.next_dot_sym
= htab
->dot_syms
;
3359 htab
->dot_syms
= eh
;
3366 struct tocsave_entry
3373 tocsave_htab_hash (const void *p
)
3375 const struct tocsave_entry
*e
= (const struct tocsave_entry
*) p
;
3376 return ((bfd_vma
) (intptr_t) e
->sec
^ e
->offset
) >> 3;
3380 tocsave_htab_eq (const void *p1
, const void *p2
)
3382 const struct tocsave_entry
*e1
= (const struct tocsave_entry
*) p1
;
3383 const struct tocsave_entry
*e2
= (const struct tocsave_entry
*) p2
;
3384 return e1
->sec
== e2
->sec
&& e1
->offset
== e2
->offset
;
3387 /* Destroy a ppc64 ELF linker hash table. */
3390 ppc64_elf_link_hash_table_free (bfd
*obfd
)
3392 struct ppc_link_hash_table
*htab
;
3394 htab
= (struct ppc_link_hash_table
*) obfd
->link
.hash
;
3395 if (htab
->tocsave_htab
)
3396 htab_delete (htab
->tocsave_htab
);
3397 bfd_hash_table_free (&htab
->branch_hash_table
);
3398 bfd_hash_table_free (&htab
->stub_hash_table
);
3399 _bfd_elf_link_hash_table_free (obfd
);
3402 /* Create a ppc64 ELF linker hash table. */
3404 static struct bfd_link_hash_table
*
3405 ppc64_elf_link_hash_table_create (bfd
*abfd
)
3407 struct ppc_link_hash_table
*htab
;
3408 bfd_size_type amt
= sizeof (struct ppc_link_hash_table
);
3410 htab
= bfd_zmalloc (amt
);
3414 if (!_bfd_elf_link_hash_table_init (&htab
->elf
, abfd
, link_hash_newfunc
,
3415 sizeof (struct ppc_link_hash_entry
),
3422 /* Init the stub hash table too. */
3423 if (!bfd_hash_table_init (&htab
->stub_hash_table
, stub_hash_newfunc
,
3424 sizeof (struct ppc_stub_hash_entry
)))
3426 _bfd_elf_link_hash_table_free (abfd
);
3430 /* And the branch hash table. */
3431 if (!bfd_hash_table_init (&htab
->branch_hash_table
, branch_hash_newfunc
,
3432 sizeof (struct ppc_branch_hash_entry
)))
3434 bfd_hash_table_free (&htab
->stub_hash_table
);
3435 _bfd_elf_link_hash_table_free (abfd
);
3439 htab
->tocsave_htab
= htab_try_create (1024,
3443 if (htab
->tocsave_htab
== NULL
)
3445 ppc64_elf_link_hash_table_free (abfd
);
3448 htab
->elf
.root
.hash_table_free
= ppc64_elf_link_hash_table_free
;
3450 /* Initializing two fields of the union is just cosmetic. We really
3451 only care about glist, but when compiled on a 32-bit host the
3452 bfd_vma fields are larger. Setting the bfd_vma to zero makes
3453 debugger inspection of these fields look nicer. */
3454 htab
->elf
.init_got_refcount
.refcount
= 0;
3455 htab
->elf
.init_got_refcount
.glist
= NULL
;
3456 htab
->elf
.init_plt_refcount
.refcount
= 0;
3457 htab
->elf
.init_plt_refcount
.glist
= NULL
;
3458 htab
->elf
.init_got_offset
.offset
= 0;
3459 htab
->elf
.init_got_offset
.glist
= NULL
;
3460 htab
->elf
.init_plt_offset
.offset
= 0;
3461 htab
->elf
.init_plt_offset
.glist
= NULL
;
3463 return &htab
->elf
.root
;
3466 /* Create sections for linker generated code. */
3469 create_linkage_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
3471 struct ppc_link_hash_table
*htab
;
3474 htab
= ppc_hash_table (info
);
3476 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_READONLY
3477 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3478 if (htab
->params
->save_restore_funcs
)
3480 /* Create .sfpr for code to save and restore fp regs. */
3481 htab
->sfpr
= bfd_make_section_anyway_with_flags (dynobj
, ".sfpr",
3483 if (htab
->sfpr
== NULL
3484 || !bfd_set_section_alignment (dynobj
, htab
->sfpr
, 2))
3488 if (bfd_link_relocatable (info
))
3491 /* Create .glink for lazy dynamic linking support. */
3492 htab
->glink
= bfd_make_section_anyway_with_flags (dynobj
, ".glink",
3494 if (htab
->glink
== NULL
3495 || !bfd_set_section_alignment (dynobj
, htab
->glink
, 3))
3498 /* The part of .glink used by global entry stubs, separate so that
3499 it can be aligned appropriately without affecting htab->glink. */
3500 htab
->global_entry
= bfd_make_section_anyway_with_flags (dynobj
, ".glink",
3502 if (htab
->global_entry
== NULL
3503 || !bfd_set_section_alignment (dynobj
, htab
->global_entry
, 2))
3506 if (!info
->no_ld_generated_unwind_info
)
3508 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_HAS_CONTENTS
3509 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3510 htab
->glink_eh_frame
= bfd_make_section_anyway_with_flags (dynobj
,
3513 if (htab
->glink_eh_frame
== NULL
3514 || !bfd_set_section_alignment (dynobj
, htab
->glink_eh_frame
, 2))
3518 flags
= SEC_ALLOC
| SEC_LINKER_CREATED
;
3519 htab
->elf
.iplt
= bfd_make_section_anyway_with_flags (dynobj
, ".iplt", flags
);
3520 if (htab
->elf
.iplt
== NULL
3521 || !bfd_set_section_alignment (dynobj
, htab
->elf
.iplt
, 3))
3524 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
3525 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3527 = bfd_make_section_anyway_with_flags (dynobj
, ".rela.iplt", flags
);
3528 if (htab
->elf
.irelplt
== NULL
3529 || !bfd_set_section_alignment (dynobj
, htab
->elf
.irelplt
, 3))
3532 /* Create branch lookup table for plt_branch stubs. */
3533 flags
= (SEC_ALLOC
| SEC_LOAD
3534 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3535 htab
->brlt
= bfd_make_section_anyway_with_flags (dynobj
, ".branch_lt",
3537 if (htab
->brlt
== NULL
3538 || !bfd_set_section_alignment (dynobj
, htab
->brlt
, 3))
3541 /* Local plt entries, put in .branch_lt but a separate section for
3543 htab
->pltlocal
= bfd_make_section_anyway_with_flags (dynobj
, ".branch_lt",
3545 if (htab
->pltlocal
== NULL
3546 || !bfd_set_section_alignment (dynobj
, htab
->pltlocal
, 3))
3549 if (!bfd_link_pic (info
))
3552 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
3553 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3555 = bfd_make_section_anyway_with_flags (dynobj
, ".rela.branch_lt", flags
);
3556 if (htab
->relbrlt
== NULL
3557 || !bfd_set_section_alignment (dynobj
, htab
->relbrlt
, 3))
3561 = bfd_make_section_anyway_with_flags (dynobj
, ".rela.branch_lt", flags
);
3562 if (htab
->relpltlocal
== NULL
3563 || !bfd_set_section_alignment (dynobj
, htab
->relpltlocal
, 3))
3569 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
3572 ppc64_elf_init_stub_bfd (struct bfd_link_info
*info
,
3573 struct ppc64_elf_params
*params
)
3575 struct ppc_link_hash_table
*htab
;
3577 elf_elfheader (params
->stub_bfd
)->e_ident
[EI_CLASS
] = ELFCLASS64
;
3579 /* Always hook our dynamic sections into the first bfd, which is the
3580 linker created stub bfd. This ensures that the GOT header is at
3581 the start of the output TOC section. */
3582 htab
= ppc_hash_table (info
);
3583 htab
->elf
.dynobj
= params
->stub_bfd
;
3584 htab
->params
= params
;
3586 return create_linkage_sections (htab
->elf
.dynobj
, info
);
3589 /* Build a name for an entry in the stub hash table. */
3592 ppc_stub_name (const asection
*input_section
,
3593 const asection
*sym_sec
,
3594 const struct ppc_link_hash_entry
*h
,
3595 const Elf_Internal_Rela
*rel
)
3600 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
3601 offsets from a sym as a branch target? In fact, we could
3602 probably assume the addend is always zero. */
3603 BFD_ASSERT (((int) rel
->r_addend
& 0xffffffff) == rel
->r_addend
);
3607 len
= 8 + 1 + strlen (h
->elf
.root
.root
.string
) + 1 + 8 + 1;
3608 stub_name
= bfd_malloc (len
);
3609 if (stub_name
== NULL
)
3612 len
= sprintf (stub_name
, "%08x.%s+%x",
3613 input_section
->id
& 0xffffffff,
3614 h
->elf
.root
.root
.string
,
3615 (int) rel
->r_addend
& 0xffffffff);
3619 len
= 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
3620 stub_name
= bfd_malloc (len
);
3621 if (stub_name
== NULL
)
3624 len
= sprintf (stub_name
, "%08x.%x:%x+%x",
3625 input_section
->id
& 0xffffffff,
3626 sym_sec
->id
& 0xffffffff,
3627 (int) ELF64_R_SYM (rel
->r_info
) & 0xffffffff,
3628 (int) rel
->r_addend
& 0xffffffff);
3630 if (len
> 2 && stub_name
[len
- 2] == '+' && stub_name
[len
- 1] == '0')
3631 stub_name
[len
- 2] = 0;
3635 /* Look up an entry in the stub hash. Stub entries are cached because
3636 creating the stub name takes a bit of time. */
3638 static struct ppc_stub_hash_entry
*
3639 ppc_get_stub_entry (const asection
*input_section
,
3640 const asection
*sym_sec
,
3641 struct ppc_link_hash_entry
*h
,
3642 const Elf_Internal_Rela
*rel
,
3643 struct ppc_link_hash_table
*htab
)
3645 struct ppc_stub_hash_entry
*stub_entry
;
3646 struct map_stub
*group
;
3648 /* If this input section is part of a group of sections sharing one
3649 stub section, then use the id of the first section in the group.
3650 Stub names need to include a section id, as there may well be
3651 more than one stub used to reach say, printf, and we need to
3652 distinguish between them. */
3653 group
= htab
->sec_info
[input_section
->id
].u
.group
;
3657 if (h
!= NULL
&& h
->u
.stub_cache
!= NULL
3658 && h
->u
.stub_cache
->h
== h
3659 && h
->u
.stub_cache
->group
== group
)
3661 stub_entry
= h
->u
.stub_cache
;
3667 stub_name
= ppc_stub_name (group
->link_sec
, sym_sec
, h
, rel
);
3668 if (stub_name
== NULL
)
3671 stub_entry
= ppc_stub_hash_lookup (&htab
->stub_hash_table
,
3672 stub_name
, FALSE
, FALSE
);
3674 h
->u
.stub_cache
= stub_entry
;
3682 /* Add a new stub entry to the stub hash. Not all fields of the new
3683 stub entry are initialised. */
3685 static struct ppc_stub_hash_entry
*
3686 ppc_add_stub (const char *stub_name
,
3688 struct bfd_link_info
*info
)
3690 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
3691 struct map_stub
*group
;
3694 struct ppc_stub_hash_entry
*stub_entry
;
3696 group
= htab
->sec_info
[section
->id
].u
.group
;
3697 link_sec
= group
->link_sec
;
3698 stub_sec
= group
->stub_sec
;
3699 if (stub_sec
== NULL
)
3705 namelen
= strlen (link_sec
->name
);
3706 len
= namelen
+ sizeof (STUB_SUFFIX
);
3707 s_name
= bfd_alloc (htab
->params
->stub_bfd
, len
);
3711 memcpy (s_name
, link_sec
->name
, namelen
);
3712 memcpy (s_name
+ namelen
, STUB_SUFFIX
, sizeof (STUB_SUFFIX
));
3713 stub_sec
= (*htab
->params
->add_stub_section
) (s_name
, link_sec
);
3714 if (stub_sec
== NULL
)
3716 group
->stub_sec
= stub_sec
;
3719 /* Enter this entry into the linker stub hash table. */
3720 stub_entry
= ppc_stub_hash_lookup (&htab
->stub_hash_table
, stub_name
,
3722 if (stub_entry
== NULL
)
3724 /* xgettext:c-format */
3725 _bfd_error_handler (_("%pB: cannot create stub entry %s"),
3726 section
->owner
, stub_name
);
3730 stub_entry
->group
= group
;
3731 stub_entry
->stub_offset
= 0;
3735 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
3736 not already done. */
3739 create_got_section (bfd
*abfd
, struct bfd_link_info
*info
)
3741 asection
*got
, *relgot
;
3743 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
3745 if (!is_ppc64_elf (abfd
))
3751 && !_bfd_elf_create_got_section (htab
->elf
.dynobj
, info
))
3754 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
3755 | SEC_LINKER_CREATED
);
3757 got
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
3759 || !bfd_set_section_alignment (abfd
, got
, 3))
3762 relgot
= bfd_make_section_anyway_with_flags (abfd
, ".rela.got",
3763 flags
| SEC_READONLY
);
3765 || !bfd_set_section_alignment (abfd
, relgot
, 3))
3768 ppc64_elf_tdata (abfd
)->got
= got
;
3769 ppc64_elf_tdata (abfd
)->relgot
= relgot
;
3773 /* Follow indirect and warning symbol links. */
3775 static inline struct bfd_link_hash_entry
*
3776 follow_link (struct bfd_link_hash_entry
*h
)
3778 while (h
->type
== bfd_link_hash_indirect
3779 || h
->type
== bfd_link_hash_warning
)
3784 static inline struct elf_link_hash_entry
*
3785 elf_follow_link (struct elf_link_hash_entry
*h
)
3787 return (struct elf_link_hash_entry
*) follow_link (&h
->root
);
3790 static inline struct ppc_link_hash_entry
*
3791 ppc_follow_link (struct ppc_link_hash_entry
*h
)
3793 return (struct ppc_link_hash_entry
*) follow_link (&h
->elf
.root
);
3796 /* Merge PLT info on FROM with that on TO. */
3799 move_plt_plist (struct ppc_link_hash_entry
*from
,
3800 struct ppc_link_hash_entry
*to
)
3802 if (from
->elf
.plt
.plist
!= NULL
)
3804 if (to
->elf
.plt
.plist
!= NULL
)
3806 struct plt_entry
**entp
;
3807 struct plt_entry
*ent
;
3809 for (entp
= &from
->elf
.plt
.plist
; (ent
= *entp
) != NULL
; )
3811 struct plt_entry
*dent
;
3813 for (dent
= to
->elf
.plt
.plist
; dent
!= NULL
; dent
= dent
->next
)
3814 if (dent
->addend
== ent
->addend
)
3816 dent
->plt
.refcount
+= ent
->plt
.refcount
;
3823 *entp
= to
->elf
.plt
.plist
;
3826 to
->elf
.plt
.plist
= from
->elf
.plt
.plist
;
3827 from
->elf
.plt
.plist
= NULL
;
3831 /* Copy the extra info we tack onto an elf_link_hash_entry. */
3834 ppc64_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
3835 struct elf_link_hash_entry
*dir
,
3836 struct elf_link_hash_entry
*ind
)
3838 struct ppc_link_hash_entry
*edir
, *eind
;
3840 edir
= (struct ppc_link_hash_entry
*) dir
;
3841 eind
= (struct ppc_link_hash_entry
*) ind
;
3843 edir
->is_func
|= eind
->is_func
;
3844 edir
->is_func_descriptor
|= eind
->is_func_descriptor
;
3845 edir
->tls_mask
|= eind
->tls_mask
;
3846 if (eind
->oh
!= NULL
)
3847 edir
->oh
= ppc_follow_link (eind
->oh
);
3849 if (edir
->elf
.versioned
!= versioned_hidden
)
3850 edir
->elf
.ref_dynamic
|= eind
->elf
.ref_dynamic
;
3851 edir
->elf
.ref_regular
|= eind
->elf
.ref_regular
;
3852 edir
->elf
.ref_regular_nonweak
|= eind
->elf
.ref_regular_nonweak
;
3853 edir
->elf
.non_got_ref
|= eind
->elf
.non_got_ref
;
3854 edir
->elf
.needs_plt
|= eind
->elf
.needs_plt
;
3855 edir
->elf
.pointer_equality_needed
|= eind
->elf
.pointer_equality_needed
;
3857 /* If we were called to copy over info for a weak sym, don't copy
3858 dyn_relocs, plt/got info, or dynindx. We used to copy dyn_relocs
3859 in order to simplify readonly_dynrelocs and save a field in the
3860 symbol hash entry, but that means dyn_relocs can't be used in any
3861 tests about a specific symbol, or affect other symbol flags which
3863 if (eind
->elf
.root
.type
!= bfd_link_hash_indirect
)
3866 /* Copy over any dynamic relocs we may have on the indirect sym. */
3867 if (eind
->dyn_relocs
!= NULL
)
3869 if (edir
->dyn_relocs
!= NULL
)
3871 struct elf_dyn_relocs
**pp
;
3872 struct elf_dyn_relocs
*p
;
3874 /* Add reloc counts against the indirect sym to the direct sym
3875 list. Merge any entries against the same section. */
3876 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
3878 struct elf_dyn_relocs
*q
;
3880 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
3881 if (q
->sec
== p
->sec
)
3883 q
->pc_count
+= p
->pc_count
;
3884 q
->count
+= p
->count
;
3891 *pp
= edir
->dyn_relocs
;
3894 edir
->dyn_relocs
= eind
->dyn_relocs
;
3895 eind
->dyn_relocs
= NULL
;
3898 /* Copy over got entries that we may have already seen to the
3899 symbol which just became indirect. */
3900 if (eind
->elf
.got
.glist
!= NULL
)
3902 if (edir
->elf
.got
.glist
!= NULL
)
3904 struct got_entry
**entp
;
3905 struct got_entry
*ent
;
3907 for (entp
= &eind
->elf
.got
.glist
; (ent
= *entp
) != NULL
; )
3909 struct got_entry
*dent
;
3911 for (dent
= edir
->elf
.got
.glist
; dent
!= NULL
; dent
= dent
->next
)
3912 if (dent
->addend
== ent
->addend
3913 && dent
->owner
== ent
->owner
3914 && dent
->tls_type
== ent
->tls_type
)
3916 dent
->got
.refcount
+= ent
->got
.refcount
;
3923 *entp
= edir
->elf
.got
.glist
;
3926 edir
->elf
.got
.glist
= eind
->elf
.got
.glist
;
3927 eind
->elf
.got
.glist
= NULL
;
3930 /* And plt entries. */
3931 move_plt_plist (eind
, edir
);
3933 if (eind
->elf
.dynindx
!= -1)
3935 if (edir
->elf
.dynindx
!= -1)
3936 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
3937 edir
->elf
.dynstr_index
);
3938 edir
->elf
.dynindx
= eind
->elf
.dynindx
;
3939 edir
->elf
.dynstr_index
= eind
->elf
.dynstr_index
;
3940 eind
->elf
.dynindx
= -1;
3941 eind
->elf
.dynstr_index
= 0;
3945 /* Find the function descriptor hash entry from the given function code
3946 hash entry FH. Link the entries via their OH fields. */
3948 static struct ppc_link_hash_entry
*
3949 lookup_fdh (struct ppc_link_hash_entry
*fh
, struct ppc_link_hash_table
*htab
)
3951 struct ppc_link_hash_entry
*fdh
= fh
->oh
;
3955 const char *fd_name
= fh
->elf
.root
.root
.string
+ 1;
3957 fdh
= (struct ppc_link_hash_entry
*)
3958 elf_link_hash_lookup (&htab
->elf
, fd_name
, FALSE
, FALSE
, FALSE
);
3962 fdh
->is_func_descriptor
= 1;
3968 fdh
= ppc_follow_link (fdh
);
3969 fdh
->is_func_descriptor
= 1;
3974 /* Make a fake function descriptor sym for the undefined code sym FH. */
3976 static struct ppc_link_hash_entry
*
3977 make_fdh (struct bfd_link_info
*info
,
3978 struct ppc_link_hash_entry
*fh
)
3980 bfd
*abfd
= fh
->elf
.root
.u
.undef
.abfd
;
3981 struct bfd_link_hash_entry
*bh
= NULL
;
3982 struct ppc_link_hash_entry
*fdh
;
3983 flagword flags
= (fh
->elf
.root
.type
== bfd_link_hash_undefweak
3987 if (!_bfd_generic_link_add_one_symbol (info
, abfd
,
3988 fh
->elf
.root
.root
.string
+ 1,
3989 flags
, bfd_und_section_ptr
, 0,
3990 NULL
, FALSE
, FALSE
, &bh
))
3993 fdh
= (struct ppc_link_hash_entry
*) bh
;
3994 fdh
->elf
.non_elf
= 0;
3996 fdh
->is_func_descriptor
= 1;
4003 /* Fix function descriptor symbols defined in .opd sections to be
4007 ppc64_elf_add_symbol_hook (bfd
*ibfd
,
4008 struct bfd_link_info
*info
,
4009 Elf_Internal_Sym
*isym
,
4011 flagword
*flags ATTRIBUTE_UNUSED
,
4016 && strcmp ((*sec
)->name
, ".opd") == 0)
4020 if (!(ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
4021 || ELF_ST_TYPE (isym
->st_info
) == STT_FUNC
))
4022 isym
->st_info
= ELF_ST_INFO (ELF_ST_BIND (isym
->st_info
), STT_FUNC
);
4024 /* If the symbol is a function defined in .opd, and the function
4025 code is in a discarded group, let it appear to be undefined. */
4026 if (!bfd_link_relocatable (info
)
4027 && (*sec
)->reloc_count
!= 0
4028 && opd_entry_value (*sec
, *value
, &code_sec
, NULL
,
4029 FALSE
) != (bfd_vma
) -1
4030 && discarded_section (code_sec
))
4032 *sec
= bfd_und_section_ptr
;
4033 isym
->st_shndx
= SHN_UNDEF
;
4036 else if (*sec
!= NULL
4037 && strcmp ((*sec
)->name
, ".toc") == 0
4038 && ELF_ST_TYPE (isym
->st_info
) == STT_OBJECT
)
4040 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
4042 htab
->params
->object_in_toc
= 1;
4045 if ((STO_PPC64_LOCAL_MASK
& isym
->st_other
) != 0)
4047 if (abiversion (ibfd
) == 0)
4048 set_abiversion (ibfd
, 2);
4049 else if (abiversion (ibfd
) == 1)
4051 _bfd_error_handler (_("symbol '%s' has invalid st_other"
4052 " for ABI version 1"), *name
);
4053 bfd_set_error (bfd_error_bad_value
);
4061 /* Merge non-visibility st_other attributes: local entry point. */
4064 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry
*h
,
4065 const Elf_Internal_Sym
*isym
,
4066 bfd_boolean definition
,
4067 bfd_boolean dynamic
)
4069 if (definition
&& (!dynamic
|| !h
->def_regular
))
4070 h
->other
= ((isym
->st_other
& ~ELF_ST_VISIBILITY (-1))
4071 | ELF_ST_VISIBILITY (h
->other
));
4074 /* Hook called on merging a symbol. We use this to clear "fake" since
4075 we now have a real symbol. */
4078 ppc64_elf_merge_symbol (struct elf_link_hash_entry
*h
,
4079 const Elf_Internal_Sym
*isym
,
4080 asection
**psec ATTRIBUTE_UNUSED
,
4081 bfd_boolean newdef ATTRIBUTE_UNUSED
,
4082 bfd_boolean olddef ATTRIBUTE_UNUSED
,
4083 bfd
*oldbfd ATTRIBUTE_UNUSED
,
4084 const asection
*oldsec ATTRIBUTE_UNUSED
)
4086 ((struct ppc_link_hash_entry
*) h
)->fake
= 0;
4087 if ((STO_PPC64_LOCAL_MASK
& isym
->st_other
) != 0)
4088 ((struct ppc_link_hash_entry
*) h
)->non_zero_localentry
= 1;
4092 /* This function makes an old ABI object reference to ".bar" cause the
4093 inclusion of a new ABI object archive that defines "bar".
4094 NAME is a symbol defined in an archive. Return a symbol in the hash
4095 table that might be satisfied by the archive symbols. */
4097 static struct elf_link_hash_entry
*
4098 ppc64_elf_archive_symbol_lookup (bfd
*abfd
,
4099 struct bfd_link_info
*info
,
4102 struct elf_link_hash_entry
*h
;
4106 h
= _bfd_elf_archive_symbol_lookup (abfd
, info
, name
);
4108 /* Don't return this sym if it is a fake function descriptor
4109 created by add_symbol_adjust. */
4110 && !((struct ppc_link_hash_entry
*) h
)->fake
)
4116 len
= strlen (name
);
4117 dot_name
= bfd_alloc (abfd
, len
+ 2);
4118 if (dot_name
== NULL
)
4119 return (struct elf_link_hash_entry
*) -1;
4121 memcpy (dot_name
+ 1, name
, len
+ 1);
4122 h
= _bfd_elf_archive_symbol_lookup (abfd
, info
, dot_name
);
4123 bfd_release (abfd
, dot_name
);
4127 /* This function satisfies all old ABI object references to ".bar" if a
4128 new ABI object defines "bar". Well, at least, undefined dot symbols
4129 are made weak. This stops later archive searches from including an
4130 object if we already have a function descriptor definition. It also
4131 prevents the linker complaining about undefined symbols.
4132 We also check and correct mismatched symbol visibility here. The
4133 most restrictive visibility of the function descriptor and the
4134 function entry symbol is used. */
4137 add_symbol_adjust (struct ppc_link_hash_entry
*eh
, struct bfd_link_info
*info
)
4139 struct ppc_link_hash_table
*htab
;
4140 struct ppc_link_hash_entry
*fdh
;
4142 if (eh
->elf
.root
.type
== bfd_link_hash_warning
)
4143 eh
= (struct ppc_link_hash_entry
*) eh
->elf
.root
.u
.i
.link
;
4145 if (eh
->elf
.root
.type
== bfd_link_hash_indirect
)
4148 if (eh
->elf
.root
.root
.string
[0] != '.')
4151 htab
= ppc_hash_table (info
);
4155 fdh
= lookup_fdh (eh
, htab
);
4157 && !bfd_link_relocatable (info
)
4158 && (eh
->elf
.root
.type
== bfd_link_hash_undefined
4159 || eh
->elf
.root
.type
== bfd_link_hash_undefweak
)
4160 && eh
->elf
.ref_regular
)
4162 /* Make an undefined function descriptor sym, in order to
4163 pull in an --as-needed shared lib. Archives are handled
4165 fdh
= make_fdh (info
, eh
);
4172 unsigned entry_vis
= ELF_ST_VISIBILITY (eh
->elf
.other
) - 1;
4173 unsigned descr_vis
= ELF_ST_VISIBILITY (fdh
->elf
.other
) - 1;
4175 /* Make both descriptor and entry symbol have the most
4176 constraining visibility of either symbol. */
4177 if (entry_vis
< descr_vis
)
4178 fdh
->elf
.other
+= entry_vis
- descr_vis
;
4179 else if (entry_vis
> descr_vis
)
4180 eh
->elf
.other
+= descr_vis
- entry_vis
;
4182 /* Propagate reference flags from entry symbol to function
4183 descriptor symbol. */
4184 fdh
->elf
.root
.non_ir_ref_regular
|= eh
->elf
.root
.non_ir_ref_regular
;
4185 fdh
->elf
.root
.non_ir_ref_dynamic
|= eh
->elf
.root
.non_ir_ref_dynamic
;
4186 fdh
->elf
.ref_regular
|= eh
->elf
.ref_regular
;
4187 fdh
->elf
.ref_regular_nonweak
|= eh
->elf
.ref_regular_nonweak
;
4189 if (!fdh
->elf
.forced_local
4190 && fdh
->elf
.dynindx
== -1
4191 && fdh
->elf
.versioned
!= versioned_hidden
4192 && (bfd_link_dll (info
)
4193 || fdh
->elf
.def_dynamic
4194 || fdh
->elf
.ref_dynamic
)
4195 && (eh
->elf
.ref_regular
4196 || eh
->elf
.def_regular
))
4198 if (!bfd_elf_link_record_dynamic_symbol (info
, &fdh
->elf
))
4206 /* Set up opd section info and abiversion for IBFD, and process list
4207 of dot-symbols we made in link_hash_newfunc. */
4210 ppc64_elf_before_check_relocs (bfd
*ibfd
, struct bfd_link_info
*info
)
4212 struct ppc_link_hash_table
*htab
;
4213 struct ppc_link_hash_entry
**p
, *eh
;
4214 asection
*opd
= bfd_get_section_by_name (ibfd
, ".opd");
4216 if (opd
!= NULL
&& opd
->size
!= 0)
4218 BFD_ASSERT (ppc64_elf_section_data (opd
)->sec_type
== sec_normal
);
4219 ppc64_elf_section_data (opd
)->sec_type
= sec_opd
;
4221 if (abiversion (ibfd
) == 0)
4222 set_abiversion (ibfd
, 1);
4223 else if (abiversion (ibfd
) >= 2)
4225 /* xgettext:c-format */
4226 _bfd_error_handler (_("%pB .opd not allowed in ABI version %d"),
4227 ibfd
, abiversion (ibfd
));
4228 bfd_set_error (bfd_error_bad_value
);
4233 if (is_ppc64_elf (info
->output_bfd
))
4235 /* For input files without an explicit abiversion in e_flags
4236 we should have flagged any with symbol st_other bits set
4237 as ELFv1 and above flagged those with .opd as ELFv2.
4238 Set the output abiversion if not yet set, and for any input
4239 still ambiguous, take its abiversion from the output.
4240 Differences in ABI are reported later. */
4241 if (abiversion (info
->output_bfd
) == 0)
4242 set_abiversion (info
->output_bfd
, abiversion (ibfd
));
4243 else if (abiversion (ibfd
) == 0)
4244 set_abiversion (ibfd
, abiversion (info
->output_bfd
));
4247 htab
= ppc_hash_table (info
);
4251 if (opd
!= NULL
&& opd
->size
!= 0
4252 && (ibfd
->flags
& DYNAMIC
) == 0
4253 && (opd
->flags
& SEC_RELOC
) != 0
4254 && opd
->reloc_count
!= 0
4255 && !bfd_is_abs_section (opd
->output_section
)
4256 && info
->gc_sections
)
4258 /* Garbage collection needs some extra help with .opd sections.
4259 We don't want to necessarily keep everything referenced by
4260 relocs in .opd, as that would keep all functions. Instead,
4261 if we reference an .opd symbol (a function descriptor), we
4262 want to keep the function code symbol's section. This is
4263 easy for global symbols, but for local syms we need to keep
4264 information about the associated function section. */
4266 asection
**opd_sym_map
;
4267 Elf_Internal_Shdr
*symtab_hdr
;
4268 Elf_Internal_Rela
*relocs
, *rel_end
, *rel
;
4270 amt
= OPD_NDX (opd
->size
) * sizeof (*opd_sym_map
);
4271 opd_sym_map
= bfd_zalloc (ibfd
, amt
);
4272 if (opd_sym_map
== NULL
)
4274 ppc64_elf_section_data (opd
)->u
.opd
.func_sec
= opd_sym_map
;
4275 relocs
= _bfd_elf_link_read_relocs (ibfd
, opd
, NULL
, NULL
,
4279 symtab_hdr
= &elf_symtab_hdr (ibfd
);
4280 rel_end
= relocs
+ opd
->reloc_count
- 1;
4281 for (rel
= relocs
; rel
< rel_end
; rel
++)
4283 enum elf_ppc64_reloc_type r_type
= ELF64_R_TYPE (rel
->r_info
);
4284 unsigned long r_symndx
= ELF64_R_SYM (rel
->r_info
);
4286 if (r_type
== R_PPC64_ADDR64
4287 && ELF64_R_TYPE ((rel
+ 1)->r_info
) == R_PPC64_TOC
4288 && r_symndx
< symtab_hdr
->sh_info
)
4290 Elf_Internal_Sym
*isym
;
4293 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
, ibfd
, r_symndx
);
4296 if (elf_section_data (opd
)->relocs
!= relocs
)
4301 s
= bfd_section_from_elf_index (ibfd
, isym
->st_shndx
);
4302 if (s
!= NULL
&& s
!= opd
)
4303 opd_sym_map
[OPD_NDX (rel
->r_offset
)] = s
;
4306 if (elf_section_data (opd
)->relocs
!= relocs
)
4310 p
= &htab
->dot_syms
;
4311 while ((eh
= *p
) != NULL
)
4314 if (&eh
->elf
== htab
->elf
.hgot
)
4316 else if (htab
->elf
.hgot
== NULL
4317 && strcmp (eh
->elf
.root
.root
.string
, ".TOC.") == 0)
4318 htab
->elf
.hgot
= &eh
->elf
;
4319 else if (abiversion (ibfd
) <= 1)
4321 htab
->need_func_desc_adj
= 1;
4322 if (!add_symbol_adjust (eh
, info
))
4325 p
= &eh
->u
.next_dot_sym
;
4330 /* Undo hash table changes when an --as-needed input file is determined
4331 not to be needed. */
4334 ppc64_elf_notice_as_needed (bfd
*ibfd
,
4335 struct bfd_link_info
*info
,
4336 enum notice_asneeded_action act
)
4338 if (act
== notice_not_needed
)
4340 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
4345 htab
->dot_syms
= NULL
;
4347 return _bfd_elf_notice_as_needed (ibfd
, info
, act
);
4350 /* If --just-symbols against a final linked binary, then assume we need
4351 toc adjusting stubs when calling functions defined there. */
4354 ppc64_elf_link_just_syms (asection
*sec
, struct bfd_link_info
*info
)
4356 if ((sec
->flags
& SEC_CODE
) != 0
4357 && (sec
->owner
->flags
& (EXEC_P
| DYNAMIC
)) != 0
4358 && is_ppc64_elf (sec
->owner
))
4360 if (abiversion (sec
->owner
) >= 2
4361 || bfd_get_section_by_name (sec
->owner
, ".opd") != NULL
)
4362 sec
->has_toc_reloc
= 1;
4364 _bfd_elf_link_just_syms (sec
, info
);
4367 static struct plt_entry
**
4368 update_local_sym_info (bfd
*abfd
, Elf_Internal_Shdr
*symtab_hdr
,
4369 unsigned long r_symndx
, bfd_vma r_addend
, int tls_type
)
4371 struct got_entry
**local_got_ents
= elf_local_got_ents (abfd
);
4372 struct plt_entry
**local_plt
;
4373 unsigned char *local_got_tls_masks
;
4375 if (local_got_ents
== NULL
)
4377 bfd_size_type size
= symtab_hdr
->sh_info
;
4379 size
*= (sizeof (*local_got_ents
)
4380 + sizeof (*local_plt
)
4381 + sizeof (*local_got_tls_masks
));
4382 local_got_ents
= bfd_zalloc (abfd
, size
);
4383 if (local_got_ents
== NULL
)
4385 elf_local_got_ents (abfd
) = local_got_ents
;
4388 if ((tls_type
& (NON_GOT
| TLS_EXPLICIT
)) == 0)
4390 struct got_entry
*ent
;
4392 for (ent
= local_got_ents
[r_symndx
]; ent
!= NULL
; ent
= ent
->next
)
4393 if (ent
->addend
== r_addend
4394 && ent
->owner
== abfd
4395 && ent
->tls_type
== tls_type
)
4399 bfd_size_type amt
= sizeof (*ent
);
4400 ent
= bfd_alloc (abfd
, amt
);
4403 ent
->next
= local_got_ents
[r_symndx
];
4404 ent
->addend
= r_addend
;
4406 ent
->tls_type
= tls_type
;
4407 ent
->is_indirect
= FALSE
;
4408 ent
->got
.refcount
= 0;
4409 local_got_ents
[r_symndx
] = ent
;
4411 ent
->got
.refcount
+= 1;
4414 local_plt
= (struct plt_entry
**) (local_got_ents
+ symtab_hdr
->sh_info
);
4415 local_got_tls_masks
= (unsigned char *) (local_plt
+ symtab_hdr
->sh_info
);
4416 local_got_tls_masks
[r_symndx
] |= tls_type
& 0xff;
4418 return local_plt
+ r_symndx
;
4422 update_plt_info (bfd
*abfd
, struct plt_entry
**plist
, bfd_vma addend
)
4424 struct plt_entry
*ent
;
4426 for (ent
= *plist
; ent
!= NULL
; ent
= ent
->next
)
4427 if (ent
->addend
== addend
)
4431 bfd_size_type amt
= sizeof (*ent
);
4432 ent
= bfd_alloc (abfd
, amt
);
4436 ent
->addend
= addend
;
4437 ent
->plt
.refcount
= 0;
4440 ent
->plt
.refcount
+= 1;
4445 is_branch_reloc (enum elf_ppc64_reloc_type r_type
)
4447 return (r_type
== R_PPC64_REL24
4448 || r_type
== R_PPC64_REL24_NOTOC
4449 || r_type
== R_PPC64_REL14
4450 || r_type
== R_PPC64_REL14_BRTAKEN
4451 || r_type
== R_PPC64_REL14_BRNTAKEN
4452 || r_type
== R_PPC64_ADDR24
4453 || r_type
== R_PPC64_ADDR14
4454 || r_type
== R_PPC64_ADDR14_BRTAKEN
4455 || r_type
== R_PPC64_ADDR14_BRNTAKEN
4456 || r_type
== R_PPC64_PLTCALL
4457 || r_type
== R_PPC64_PLTCALL_NOTOC
);
4460 /* Relocs on inline plt call sequence insns prior to the call. */
4463 is_plt_seq_reloc (enum elf_ppc64_reloc_type r_type
)
4465 return (r_type
== R_PPC64_PLT16_HA
4466 || r_type
== R_PPC64_PLT16_HI
4467 || r_type
== R_PPC64_PLT16_LO
4468 || r_type
== R_PPC64_PLT16_LO_DS
4469 || r_type
== R_PPC64_PLT_PCREL34
4470 || r_type
== R_PPC64_PLT_PCREL34_NOTOC
4471 || r_type
== R_PPC64_PLTSEQ
4472 || r_type
== R_PPC64_PLTSEQ_NOTOC
);
4475 /* Look through the relocs for a section during the first phase, and
4476 calculate needed space in the global offset table, procedure
4477 linkage table, and dynamic reloc sections. */
4480 ppc64_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
4481 asection
*sec
, const Elf_Internal_Rela
*relocs
)
4483 struct ppc_link_hash_table
*htab
;
4484 Elf_Internal_Shdr
*symtab_hdr
;
4485 struct elf_link_hash_entry
**sym_hashes
;
4486 const Elf_Internal_Rela
*rel
;
4487 const Elf_Internal_Rela
*rel_end
;
4489 struct elf_link_hash_entry
*tga
, *dottga
;
4492 if (bfd_link_relocatable (info
))
4495 /* Don't do anything special with non-loaded, non-alloced sections.
4496 In particular, any relocs in such sections should not affect GOT
4497 and PLT reference counting (ie. we don't allow them to create GOT
4498 or PLT entries), there's no possibility or desire to optimize TLS
4499 relocs, and there's not much point in propagating relocs to shared
4500 libs that the dynamic linker won't relocate. */
4501 if ((sec
->flags
& SEC_ALLOC
) == 0)
4504 BFD_ASSERT (is_ppc64_elf (abfd
));
4506 htab
= ppc_hash_table (info
);
4510 tga
= elf_link_hash_lookup (&htab
->elf
, "__tls_get_addr",
4511 FALSE
, FALSE
, TRUE
);
4512 dottga
= elf_link_hash_lookup (&htab
->elf
, ".__tls_get_addr",
4513 FALSE
, FALSE
, TRUE
);
4514 symtab_hdr
= &elf_symtab_hdr (abfd
);
4515 sym_hashes
= elf_sym_hashes (abfd
);
4517 is_opd
= ppc64_elf_section_data (sec
)->sec_type
== sec_opd
;
4518 rel_end
= relocs
+ sec
->reloc_count
;
4519 for (rel
= relocs
; rel
< rel_end
; rel
++)
4521 unsigned long r_symndx
;
4522 struct elf_link_hash_entry
*h
;
4523 enum elf_ppc64_reloc_type r_type
;
4525 struct _ppc64_elf_section_data
*ppc64_sec
;
4526 struct plt_entry
**ifunc
, **plt_list
;
4529 r_symndx
= ELF64_R_SYM (rel
->r_info
);
4530 if (r_symndx
< symtab_hdr
->sh_info
)
4534 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
4535 h
= elf_follow_link (h
);
4537 if (h
== htab
->elf
.hgot
)
4538 sec
->has_toc_reloc
= 1;
4543 r_type
= ELF64_R_TYPE (rel
->r_info
);
4547 case R_PPC64_D34_LO
:
4548 case R_PPC64_D34_HI30
:
4549 case R_PPC64_D34_HA30
:
4551 case R_PPC64_TPREL34
:
4552 case R_PPC64_DTPREL34
:
4553 htab
->powerxx_stubs
= 1;
4556 /* Somewhat foolishly, because the ABIs don't specifically
4557 allow it, ppc64 gas and ld support GOT and PLT relocs
4558 with non-zero addends where the addend results in
4559 sym+addend being stored in the GOT or PLT entry. This
4560 can't be supported for pcrel relocs because the addend is
4561 used to specify the pcrel offset. */
4562 sym_addend
= rel
->r_addend
;
4565 case R_PPC64_PCREL34
:
4566 case R_PPC64_GOT_PCREL34
:
4567 case R_PPC64_GOT_TLSGD34
:
4568 case R_PPC64_GOT_TLSLD34
:
4569 case R_PPC64_GOT_TPREL34
:
4570 case R_PPC64_GOT_DTPREL34
:
4571 case R_PPC64_PLT_PCREL34
:
4572 case R_PPC64_PLT_PCREL34_NOTOC
:
4573 case R_PPC64_PCREL28
:
4574 htab
->powerxx_stubs
= 1;
4581 case R_PPC64_PLT16_HA
:
4582 case R_PPC64_GOT_TLSLD16_HA
:
4583 case R_PPC64_GOT_TLSGD16_HA
:
4584 case R_PPC64_GOT_TPREL16_HA
:
4585 case R_PPC64_GOT_DTPREL16_HA
:
4586 case R_PPC64_GOT16_HA
:
4587 case R_PPC64_TOC16_HA
:
4588 case R_PPC64_PLT16_LO
:
4589 case R_PPC64_PLT16_LO_DS
:
4590 case R_PPC64_GOT_TLSLD16_LO
:
4591 case R_PPC64_GOT_TLSGD16_LO
:
4592 case R_PPC64_GOT_TPREL16_LO_DS
:
4593 case R_PPC64_GOT_DTPREL16_LO_DS
:
4594 case R_PPC64_GOT16_LO
:
4595 case R_PPC64_GOT16_LO_DS
:
4596 case R_PPC64_TOC16_LO
:
4597 case R_PPC64_TOC16_LO_DS
:
4598 case R_PPC64_GOT_PCREL34
:
4599 ppc64_elf_tdata (abfd
)->has_optrel
= 1;
4600 ppc64_elf_section_data (sec
)->has_optrel
= 1;
4608 if (h
->type
== STT_GNU_IFUNC
)
4611 ifunc
= &h
->plt
.plist
;
4616 Elf_Internal_Sym
*isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
4621 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
4623 ifunc
= update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4625 NON_GOT
| PLT_IFUNC
);
4635 /* These special tls relocs tie a call to __tls_get_addr with
4636 its parameter symbol. */
4638 ((struct ppc_link_hash_entry
*) h
)->tls_mask
|= TLS_TLS
| TLS_MARK
;
4640 if (!update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4642 NON_GOT
| TLS_TLS
| TLS_MARK
))
4644 sec
->has_tls_reloc
= 1;
4647 case R_PPC64_GOT_TLSLD16
:
4648 case R_PPC64_GOT_TLSLD16_LO
:
4649 case R_PPC64_GOT_TLSLD16_HI
:
4650 case R_PPC64_GOT_TLSLD16_HA
:
4651 case R_PPC64_GOT_TLSLD34
:
4652 tls_type
= TLS_TLS
| TLS_LD
;
4655 case R_PPC64_GOT_TLSGD16
:
4656 case R_PPC64_GOT_TLSGD16_LO
:
4657 case R_PPC64_GOT_TLSGD16_HI
:
4658 case R_PPC64_GOT_TLSGD16_HA
:
4659 case R_PPC64_GOT_TLSGD34
:
4660 tls_type
= TLS_TLS
| TLS_GD
;
4663 case R_PPC64_GOT_TPREL16_DS
:
4664 case R_PPC64_GOT_TPREL16_LO_DS
:
4665 case R_PPC64_GOT_TPREL16_HI
:
4666 case R_PPC64_GOT_TPREL16_HA
:
4667 case R_PPC64_GOT_TPREL34
:
4668 if (bfd_link_dll (info
))
4669 info
->flags
|= DF_STATIC_TLS
;
4670 tls_type
= TLS_TLS
| TLS_TPREL
;
4673 case R_PPC64_GOT_DTPREL16_DS
:
4674 case R_PPC64_GOT_DTPREL16_LO_DS
:
4675 case R_PPC64_GOT_DTPREL16_HI
:
4676 case R_PPC64_GOT_DTPREL16_HA
:
4677 case R_PPC64_GOT_DTPREL34
:
4678 tls_type
= TLS_TLS
| TLS_DTPREL
;
4680 sec
->has_tls_reloc
= 1;
4684 case R_PPC64_GOT16_LO
:
4685 case R_PPC64_GOT16_HI
:
4686 case R_PPC64_GOT16_HA
:
4687 case R_PPC64_GOT16_DS
:
4688 case R_PPC64_GOT16_LO_DS
:
4689 case R_PPC64_GOT_PCREL34
:
4691 /* This symbol requires a global offset table entry. */
4692 sec
->has_toc_reloc
= 1;
4693 if (r_type
== R_PPC64_GOT_TLSLD16
4694 || r_type
== R_PPC64_GOT_TLSGD16
4695 || r_type
== R_PPC64_GOT_TPREL16_DS
4696 || r_type
== R_PPC64_GOT_DTPREL16_DS
4697 || r_type
== R_PPC64_GOT16
4698 || r_type
== R_PPC64_GOT16_DS
)
4700 htab
->do_multi_toc
= 1;
4701 ppc64_elf_tdata (abfd
)->has_small_toc_reloc
= 1;
4704 if (ppc64_elf_tdata (abfd
)->got
== NULL
4705 && !create_got_section (abfd
, info
))
4710 struct ppc_link_hash_entry
*eh
;
4711 struct got_entry
*ent
;
4713 eh
= (struct ppc_link_hash_entry
*) h
;
4714 for (ent
= eh
->elf
.got
.glist
; ent
!= NULL
; ent
= ent
->next
)
4715 if (ent
->addend
== sym_addend
4716 && ent
->owner
== abfd
4717 && ent
->tls_type
== tls_type
)
4721 bfd_size_type amt
= sizeof (*ent
);
4722 ent
= bfd_alloc (abfd
, amt
);
4725 ent
->next
= eh
->elf
.got
.glist
;
4726 ent
->addend
= sym_addend
;
4728 ent
->tls_type
= tls_type
;
4729 ent
->is_indirect
= FALSE
;
4730 ent
->got
.refcount
= 0;
4731 eh
->elf
.got
.glist
= ent
;
4733 ent
->got
.refcount
+= 1;
4734 eh
->tls_mask
|= tls_type
;
4737 /* This is a global offset table entry for a local symbol. */
4738 if (!update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4739 sym_addend
, tls_type
))
4742 /* We may also need a plt entry if the symbol turns out to be
4744 if (h
!= NULL
&& !bfd_link_pic (info
) && abiversion (abfd
) != 1)
4746 if (!update_plt_info (abfd
, &h
->plt
.plist
, sym_addend
))
4751 case R_PPC64_PLT16_HA
:
4752 case R_PPC64_PLT16_HI
:
4753 case R_PPC64_PLT16_LO
:
4754 case R_PPC64_PLT16_LO_DS
:
4755 case R_PPC64_PLT_PCREL34
:
4756 case R_PPC64_PLT_PCREL34_NOTOC
:
4759 /* This symbol requires a procedure linkage table entry. */
4764 if (h
->root
.root
.string
[0] == '.'
4765 && h
->root
.root
.string
[1] != '\0')
4766 ((struct ppc_link_hash_entry
*) h
)->is_func
= 1;
4767 ((struct ppc_link_hash_entry
*) h
)->tls_mask
|= PLT_KEEP
;
4768 plt_list
= &h
->plt
.plist
;
4770 if (plt_list
== NULL
)
4771 plt_list
= update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4773 NON_GOT
| PLT_KEEP
);
4774 if (!update_plt_info (abfd
, plt_list
, sym_addend
))
4778 /* The following relocations don't need to propagate the
4779 relocation if linking a shared object since they are
4780 section relative. */
4781 case R_PPC64_SECTOFF
:
4782 case R_PPC64_SECTOFF_LO
:
4783 case R_PPC64_SECTOFF_HI
:
4784 case R_PPC64_SECTOFF_HA
:
4785 case R_PPC64_SECTOFF_DS
:
4786 case R_PPC64_SECTOFF_LO_DS
:
4787 case R_PPC64_DTPREL16
:
4788 case R_PPC64_DTPREL16_LO
:
4789 case R_PPC64_DTPREL16_HI
:
4790 case R_PPC64_DTPREL16_HA
:
4791 case R_PPC64_DTPREL16_DS
:
4792 case R_PPC64_DTPREL16_LO_DS
:
4793 case R_PPC64_DTPREL16_HIGH
:
4794 case R_PPC64_DTPREL16_HIGHA
:
4795 case R_PPC64_DTPREL16_HIGHER
:
4796 case R_PPC64_DTPREL16_HIGHERA
:
4797 case R_PPC64_DTPREL16_HIGHEST
:
4798 case R_PPC64_DTPREL16_HIGHESTA
:
4803 case R_PPC64_REL16_LO
:
4804 case R_PPC64_REL16_HI
:
4805 case R_PPC64_REL16_HA
:
4806 case R_PPC64_REL16_HIGH
:
4807 case R_PPC64_REL16_HIGHA
:
4808 case R_PPC64_REL16_HIGHER
:
4809 case R_PPC64_REL16_HIGHERA
:
4810 case R_PPC64_REL16_HIGHEST
:
4811 case R_PPC64_REL16_HIGHESTA
:
4812 case R_PPC64_REL16_HIGHER34
:
4813 case R_PPC64_REL16_HIGHERA34
:
4814 case R_PPC64_REL16_HIGHEST34
:
4815 case R_PPC64_REL16_HIGHESTA34
:
4816 case R_PPC64_REL16DX_HA
:
4819 /* Not supported as a dynamic relocation. */
4820 case R_PPC64_ADDR64_LOCAL
:
4821 if (bfd_link_pic (info
))
4823 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
4825 /* xgettext:c-format */
4826 info
->callbacks
->einfo (_("%H: %s reloc unsupported "
4827 "in shared libraries and PIEs\n"),
4828 abfd
, sec
, rel
->r_offset
,
4829 ppc64_elf_howto_table
[r_type
]->name
);
4830 bfd_set_error (bfd_error_bad_value
);
4836 case R_PPC64_TOC16_DS
:
4837 htab
->do_multi_toc
= 1;
4838 ppc64_elf_tdata (abfd
)->has_small_toc_reloc
= 1;
4840 case R_PPC64_TOC16_LO
:
4841 case R_PPC64_TOC16_HI
:
4842 case R_PPC64_TOC16_HA
:
4843 case R_PPC64_TOC16_LO_DS
:
4844 sec
->has_toc_reloc
= 1;
4851 /* This relocation describes the C++ object vtable hierarchy.
4852 Reconstruct it for later use during GC. */
4853 case R_PPC64_GNU_VTINHERIT
:
4854 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
4858 /* This relocation describes which C++ vtable entries are actually
4859 used. Record for later use during GC. */
4860 case R_PPC64_GNU_VTENTRY
:
4861 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
4866 case R_PPC64_REL14_BRTAKEN
:
4867 case R_PPC64_REL14_BRNTAKEN
:
4869 asection
*dest
= NULL
;
4871 /* Heuristic: If jumping outside our section, chances are
4872 we are going to need a stub. */
4875 /* If the sym is weak it may be overridden later, so
4876 don't assume we know where a weak sym lives. */
4877 if (h
->root
.type
== bfd_link_hash_defined
)
4878 dest
= h
->root
.u
.def
.section
;
4882 Elf_Internal_Sym
*isym
;
4884 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
4889 dest
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
4893 ppc64_elf_section_data (sec
)->has_14bit_branch
= 1;
4897 case R_PPC64_PLTCALL
:
4898 case R_PPC64_PLTCALL_NOTOC
:
4899 ppc64_elf_section_data (sec
)->has_pltcall
= 1;
4903 case R_PPC64_REL24_NOTOC
:
4909 if (h
->root
.root
.string
[0] == '.'
4910 && h
->root
.root
.string
[1] != '\0')
4911 ((struct ppc_link_hash_entry
*) h
)->is_func
= 1;
4913 if (h
== tga
|| h
== dottga
)
4915 sec
->has_tls_reloc
= 1;
4917 && (ELF64_R_TYPE (rel
[-1].r_info
) == R_PPC64_TLSGD
4918 || ELF64_R_TYPE (rel
[-1].r_info
) == R_PPC64_TLSLD
))
4919 /* We have a new-style __tls_get_addr call with
4923 /* Mark this section as having an old-style call. */
4924 sec
->has_tls_get_addr_call
= 1;
4926 plt_list
= &h
->plt
.plist
;
4929 /* We may need a .plt entry if the function this reloc
4930 refers to is in a shared lib. */
4932 && !update_plt_info (abfd
, plt_list
, sym_addend
))
4936 case R_PPC64_ADDR14
:
4937 case R_PPC64_ADDR14_BRNTAKEN
:
4938 case R_PPC64_ADDR14_BRTAKEN
:
4939 case R_PPC64_ADDR24
:
4942 case R_PPC64_TPREL64
:
4943 tls_type
= TLS_EXPLICIT
| TLS_TLS
| TLS_TPREL
;
4944 if (bfd_link_dll (info
))
4945 info
->flags
|= DF_STATIC_TLS
;
4948 case R_PPC64_DTPMOD64
:
4949 if (rel
+ 1 < rel_end
4950 && rel
[1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_DTPREL64
)
4951 && rel
[1].r_offset
== rel
->r_offset
+ 8)
4952 tls_type
= TLS_EXPLICIT
| TLS_TLS
| TLS_GD
;
4954 tls_type
= TLS_EXPLICIT
| TLS_TLS
| TLS_LD
;
4957 case R_PPC64_DTPREL64
:
4958 tls_type
= TLS_EXPLICIT
| TLS_TLS
| TLS_DTPREL
;
4960 && rel
[-1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_DTPMOD64
)
4961 && rel
[-1].r_offset
== rel
->r_offset
- 8)
4962 /* This is the second reloc of a dtpmod, dtprel pair.
4963 Don't mark with TLS_DTPREL. */
4967 sec
->has_tls_reloc
= 1;
4970 struct ppc_link_hash_entry
*eh
;
4971 eh
= (struct ppc_link_hash_entry
*) h
;
4972 eh
->tls_mask
|= tls_type
& 0xff;
4975 if (!update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4976 sym_addend
, tls_type
))
4979 ppc64_sec
= ppc64_elf_section_data (sec
);
4980 if (ppc64_sec
->sec_type
!= sec_toc
)
4984 /* One extra to simplify get_tls_mask. */
4985 amt
= sec
->size
* sizeof (unsigned) / 8 + sizeof (unsigned);
4986 ppc64_sec
->u
.toc
.symndx
= bfd_zalloc (abfd
, amt
);
4987 if (ppc64_sec
->u
.toc
.symndx
== NULL
)
4989 amt
= sec
->size
* sizeof (bfd_vma
) / 8;
4990 ppc64_sec
->u
.toc
.add
= bfd_zalloc (abfd
, amt
);
4991 if (ppc64_sec
->u
.toc
.add
== NULL
)
4993 BFD_ASSERT (ppc64_sec
->sec_type
== sec_normal
);
4994 ppc64_sec
->sec_type
= sec_toc
;
4996 BFD_ASSERT (rel
->r_offset
% 8 == 0);
4997 ppc64_sec
->u
.toc
.symndx
[rel
->r_offset
/ 8] = r_symndx
;
4998 ppc64_sec
->u
.toc
.add
[rel
->r_offset
/ 8] = sym_addend
;
5000 /* Mark the second slot of a GD or LD entry.
5001 -1 to indicate GD and -2 to indicate LD. */
5002 if (tls_type
== (TLS_EXPLICIT
| TLS_TLS
| TLS_GD
))
5003 ppc64_sec
->u
.toc
.symndx
[rel
->r_offset
/ 8 + 1] = -1;
5004 else if (tls_type
== (TLS_EXPLICIT
| TLS_TLS
| TLS_LD
))
5005 ppc64_sec
->u
.toc
.symndx
[rel
->r_offset
/ 8 + 1] = -2;
5008 case R_PPC64_TPREL16
:
5009 case R_PPC64_TPREL16_LO
:
5010 case R_PPC64_TPREL16_HI
:
5011 case R_PPC64_TPREL16_HA
:
5012 case R_PPC64_TPREL16_DS
:
5013 case R_PPC64_TPREL16_LO_DS
:
5014 case R_PPC64_TPREL16_HIGH
:
5015 case R_PPC64_TPREL16_HIGHA
:
5016 case R_PPC64_TPREL16_HIGHER
:
5017 case R_PPC64_TPREL16_HIGHERA
:
5018 case R_PPC64_TPREL16_HIGHEST
:
5019 case R_PPC64_TPREL16_HIGHESTA
:
5020 case R_PPC64_TPREL34
:
5021 if (bfd_link_dll (info
))
5022 info
->flags
|= DF_STATIC_TLS
;
5025 case R_PPC64_ADDR64
:
5027 && rel
+ 1 < rel_end
5028 && ELF64_R_TYPE ((rel
+ 1)->r_info
) == R_PPC64_TOC
)
5031 ((struct ppc_link_hash_entry
*) h
)->is_func
= 1;
5035 case R_PPC64_ADDR16
:
5036 case R_PPC64_ADDR16_DS
:
5037 case R_PPC64_ADDR16_HA
:
5038 case R_PPC64_ADDR16_HI
:
5039 case R_PPC64_ADDR16_HIGH
:
5040 case R_PPC64_ADDR16_HIGHA
:
5041 case R_PPC64_ADDR16_HIGHER
:
5042 case R_PPC64_ADDR16_HIGHERA
:
5043 case R_PPC64_ADDR16_HIGHEST
:
5044 case R_PPC64_ADDR16_HIGHESTA
:
5045 case R_PPC64_ADDR16_LO
:
5046 case R_PPC64_ADDR16_LO_DS
:
5048 case R_PPC64_D34_LO
:
5049 case R_PPC64_D34_HI30
:
5050 case R_PPC64_D34_HA30
:
5051 case R_PPC64_ADDR16_HIGHER34
:
5052 case R_PPC64_ADDR16_HIGHERA34
:
5053 case R_PPC64_ADDR16_HIGHEST34
:
5054 case R_PPC64_ADDR16_HIGHESTA34
:
5056 if (h
!= NULL
&& !bfd_link_pic (info
) && abiversion (abfd
) != 1
5057 && rel
->r_addend
== 0)
5059 /* We may need a .plt entry if this reloc refers to a
5060 function in a shared lib. */
5061 if (!update_plt_info (abfd
, &h
->plt
.plist
, 0))
5063 h
->pointer_equality_needed
= 1;
5070 case R_PPC64_ADDR32
:
5071 case R_PPC64_UADDR16
:
5072 case R_PPC64_UADDR32
:
5073 case R_PPC64_UADDR64
:
5075 if (h
!= NULL
&& !bfd_link_pic (info
))
5076 /* We may need a copy reloc. */
5079 /* Don't propagate .opd relocs. */
5080 if (NO_OPD_RELOCS
&& is_opd
)
5083 /* If we are creating a shared library, and this is a reloc
5084 against a global symbol, or a non PC relative reloc
5085 against a local symbol, then we need to copy the reloc
5086 into the shared library. However, if we are linking with
5087 -Bsymbolic, we do not need to copy a reloc against a
5088 global symbol which is defined in an object we are
5089 including in the link (i.e., DEF_REGULAR is set). At
5090 this point we have not seen all the input files, so it is
5091 possible that DEF_REGULAR is not set now but will be set
5092 later (it is never cleared). In case of a weak definition,
5093 DEF_REGULAR may be cleared later by a strong definition in
5094 a shared library. We account for that possibility below by
5095 storing information in the dyn_relocs field of the hash
5096 table entry. A similar situation occurs when creating
5097 shared libraries and symbol visibility changes render the
5100 If on the other hand, we are creating an executable, we
5101 may need to keep relocations for symbols satisfied by a
5102 dynamic library if we manage to avoid copy relocs for the
5105 if ((bfd_link_pic (info
)
5106 && (must_be_dyn_reloc (info
, r_type
)
5108 && (!SYMBOLIC_BIND (info
, h
)
5109 || h
->root
.type
== bfd_link_hash_defweak
5110 || !h
->def_regular
))))
5111 || (ELIMINATE_COPY_RELOCS
5112 && !bfd_link_pic (info
)
5114 && (h
->root
.type
== bfd_link_hash_defweak
5115 || !h
->def_regular
))
5116 || (!bfd_link_pic (info
)
5119 /* We must copy these reloc types into the output file.
5120 Create a reloc section in dynobj and make room for
5124 sreloc
= _bfd_elf_make_dynamic_reloc_section
5125 (sec
, htab
->elf
.dynobj
, 3, abfd
, /*rela?*/ TRUE
);
5131 /* If this is a global symbol, we count the number of
5132 relocations we need for this symbol. */
5135 struct elf_dyn_relocs
*p
;
5136 struct elf_dyn_relocs
**head
;
5138 head
= &((struct ppc_link_hash_entry
*) h
)->dyn_relocs
;
5140 if (p
== NULL
|| p
->sec
!= sec
)
5142 p
= bfd_alloc (htab
->elf
.dynobj
, sizeof *p
);
5152 if (!must_be_dyn_reloc (info
, r_type
))
5157 /* Track dynamic relocs needed for local syms too.
5158 We really need local syms available to do this
5160 struct ppc_dyn_relocs
*p
;
5161 struct ppc_dyn_relocs
**head
;
5162 bfd_boolean is_ifunc
;
5165 Elf_Internal_Sym
*isym
;
5167 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
5172 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
5176 vpp
= &elf_section_data (s
)->local_dynrel
;
5177 head
= (struct ppc_dyn_relocs
**) vpp
;
5178 is_ifunc
= ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
;
5180 if (p
!= NULL
&& p
->sec
== sec
&& p
->ifunc
!= is_ifunc
)
5182 if (p
== NULL
|| p
->sec
!= sec
|| p
->ifunc
!= is_ifunc
)
5184 p
= bfd_alloc (htab
->elf
.dynobj
, sizeof *p
);
5190 p
->ifunc
= is_ifunc
;
5206 /* Merge backend specific data from an object file to the output
5207 object file when linking. */
5210 ppc64_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
5212 bfd
*obfd
= info
->output_bfd
;
5213 unsigned long iflags
, oflags
;
5215 if ((ibfd
->flags
& BFD_LINKER_CREATED
) != 0)
5218 if (!is_ppc64_elf (ibfd
) || !is_ppc64_elf (obfd
))
5221 if (!_bfd_generic_verify_endian_match (ibfd
, info
))
5224 iflags
= elf_elfheader (ibfd
)->e_flags
;
5225 oflags
= elf_elfheader (obfd
)->e_flags
;
5227 if (iflags
& ~EF_PPC64_ABI
)
5230 /* xgettext:c-format */
5231 (_("%pB uses unknown e_flags 0x%lx"), ibfd
, iflags
);
5232 bfd_set_error (bfd_error_bad_value
);
5235 else if (iflags
!= oflags
&& iflags
!= 0)
5238 /* xgettext:c-format */
5239 (_("%pB: ABI version %ld is not compatible with ABI version %ld output"),
5240 ibfd
, iflags
, oflags
);
5241 bfd_set_error (bfd_error_bad_value
);
5245 if (!_bfd_elf_ppc_merge_fp_attributes (ibfd
, info
))
5248 /* Merge Tag_compatibility attributes and any common GNU ones. */
5249 return _bfd_elf_merge_object_attributes (ibfd
, info
);
5253 ppc64_elf_print_private_bfd_data (bfd
*abfd
, void *ptr
)
5255 /* Print normal ELF private data. */
5256 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
5258 if (elf_elfheader (abfd
)->e_flags
!= 0)
5262 fprintf (file
, _("private flags = 0x%lx:"),
5263 elf_elfheader (abfd
)->e_flags
);
5265 if ((elf_elfheader (abfd
)->e_flags
& EF_PPC64_ABI
) != 0)
5266 fprintf (file
, _(" [abiv%ld]"),
5267 elf_elfheader (abfd
)->e_flags
& EF_PPC64_ABI
);
5274 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
5275 of the code entry point, and its section, which must be in the same
5276 object as OPD_SEC. Returns (bfd_vma) -1 on error. */
5279 opd_entry_value (asection
*opd_sec
,
5281 asection
**code_sec
,
5283 bfd_boolean in_code_sec
)
5285 bfd
*opd_bfd
= opd_sec
->owner
;
5286 Elf_Internal_Rela
*relocs
;
5287 Elf_Internal_Rela
*lo
, *hi
, *look
;
5290 /* No relocs implies we are linking a --just-symbols object, or looking
5291 at a final linked executable with addr2line or somesuch. */
5292 if (opd_sec
->reloc_count
== 0)
5294 bfd_byte
*contents
= ppc64_elf_tdata (opd_bfd
)->opd
.contents
;
5296 if (contents
== NULL
)
5298 if (!bfd_malloc_and_get_section (opd_bfd
, opd_sec
, &contents
))
5299 return (bfd_vma
) -1;
5300 ppc64_elf_tdata (opd_bfd
)->opd
.contents
= contents
;
5303 /* PR 17512: file: 64b9dfbb. */
5304 if (offset
+ 7 >= opd_sec
->size
|| offset
+ 7 < offset
)
5305 return (bfd_vma
) -1;
5307 val
= bfd_get_64 (opd_bfd
, contents
+ offset
);
5308 if (code_sec
!= NULL
)
5310 asection
*sec
, *likely
= NULL
;
5316 && val
< sec
->vma
+ sec
->size
)
5322 for (sec
= opd_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
5324 && (sec
->flags
& SEC_LOAD
) != 0
5325 && (sec
->flags
& SEC_ALLOC
) != 0)
5330 if (code_off
!= NULL
)
5331 *code_off
= val
- likely
->vma
;
5337 BFD_ASSERT (is_ppc64_elf (opd_bfd
));
5339 relocs
= ppc64_elf_tdata (opd_bfd
)->opd
.relocs
;
5341 relocs
= _bfd_elf_link_read_relocs (opd_bfd
, opd_sec
, NULL
, NULL
, TRUE
);
5342 /* PR 17512: file: df8e1fd6. */
5344 return (bfd_vma
) -1;
5346 /* Go find the opd reloc at the sym address. */
5348 hi
= lo
+ opd_sec
->reloc_count
- 1; /* ignore last reloc */
5352 look
= lo
+ (hi
- lo
) / 2;
5353 if (look
->r_offset
< offset
)
5355 else if (look
->r_offset
> offset
)
5359 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (opd_bfd
);
5361 if (ELF64_R_TYPE (look
->r_info
) == R_PPC64_ADDR64
5362 && ELF64_R_TYPE ((look
+ 1)->r_info
) == R_PPC64_TOC
)
5364 unsigned long symndx
= ELF64_R_SYM (look
->r_info
);
5365 asection
*sec
= NULL
;
5367 if (symndx
>= symtab_hdr
->sh_info
5368 && elf_sym_hashes (opd_bfd
) != NULL
)
5370 struct elf_link_hash_entry
**sym_hashes
;
5371 struct elf_link_hash_entry
*rh
;
5373 sym_hashes
= elf_sym_hashes (opd_bfd
);
5374 rh
= sym_hashes
[symndx
- symtab_hdr
->sh_info
];
5377 rh
= elf_follow_link (rh
);
5378 if (rh
->root
.type
!= bfd_link_hash_defined
5379 && rh
->root
.type
!= bfd_link_hash_defweak
)
5381 if (rh
->root
.u
.def
.section
->owner
== opd_bfd
)
5383 val
= rh
->root
.u
.def
.value
;
5384 sec
= rh
->root
.u
.def
.section
;
5391 Elf_Internal_Sym
*sym
;
5393 if (symndx
< symtab_hdr
->sh_info
)
5395 sym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
5398 size_t symcnt
= symtab_hdr
->sh_info
;
5399 sym
= bfd_elf_get_elf_syms (opd_bfd
, symtab_hdr
,
5404 symtab_hdr
->contents
= (bfd_byte
*) sym
;
5410 sym
= bfd_elf_get_elf_syms (opd_bfd
, symtab_hdr
,
5416 sec
= bfd_section_from_elf_index (opd_bfd
, sym
->st_shndx
);
5419 BFD_ASSERT ((sec
->flags
& SEC_MERGE
) == 0);
5420 val
= sym
->st_value
;
5423 val
+= look
->r_addend
;
5424 if (code_off
!= NULL
)
5426 if (code_sec
!= NULL
)
5428 if (in_code_sec
&& *code_sec
!= sec
)
5433 if (sec
->output_section
!= NULL
)
5434 val
+= sec
->output_section
->vma
+ sec
->output_offset
;
5443 /* If the ELF symbol SYM might be a function in SEC, return the
5444 function size and set *CODE_OFF to the function's entry point,
5445 otherwise return zero. */
5447 static bfd_size_type
5448 ppc64_elf_maybe_function_sym (const asymbol
*sym
, asection
*sec
,
5453 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_FILE
| BSF_OBJECT
5454 | BSF_THREAD_LOCAL
| BSF_RELC
| BSF_SRELC
)) != 0)
5458 if (!(sym
->flags
& BSF_SYNTHETIC
))
5459 size
= ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
5461 if (strcmp (sym
->section
->name
, ".opd") == 0)
5463 struct _opd_sec_data
*opd
= get_opd_info (sym
->section
);
5464 bfd_vma symval
= sym
->value
;
5467 && opd
->adjust
!= NULL
5468 && elf_section_data (sym
->section
)->relocs
!= NULL
)
5470 /* opd_entry_value will use cached relocs that have been
5471 adjusted, but with raw symbols. That means both local
5472 and global symbols need adjusting. */
5473 long adjust
= opd
->adjust
[OPD_NDX (symval
)];
5479 if (opd_entry_value (sym
->section
, symval
,
5480 &sec
, code_off
, TRUE
) == (bfd_vma
) -1)
5482 /* An old ABI binary with dot-syms has a size of 24 on the .opd
5483 symbol. This size has nothing to do with the code size of the
5484 function, which is what we're supposed to return, but the
5485 code size isn't available without looking up the dot-sym.
5486 However, doing that would be a waste of time particularly
5487 since elf_find_function will look at the dot-sym anyway.
5488 Now, elf_find_function will keep the largest size of any
5489 function sym found at the code address of interest, so return
5490 1 here to avoid it incorrectly caching a larger function size
5491 for a small function. This does mean we return the wrong
5492 size for a new-ABI function of size 24, but all that does is
5493 disable caching for such functions. */
5499 if (sym
->section
!= sec
)
5501 *code_off
= sym
->value
;
5508 /* Return true if symbol is a strong function defined in an ELFv2
5509 object with st_other localentry bits of zero, ie. its local entry
5510 point coincides with its global entry point. */
5513 is_elfv2_localentry0 (struct elf_link_hash_entry
*h
)
5516 && h
->type
== STT_FUNC
5517 && h
->root
.type
== bfd_link_hash_defined
5518 && (STO_PPC64_LOCAL_MASK
& h
->other
) == 0
5519 && !((struct ppc_link_hash_entry
*) h
)->non_zero_localentry
5520 && is_ppc64_elf (h
->root
.u
.def
.section
->owner
)
5521 && abiversion (h
->root
.u
.def
.section
->owner
) >= 2);
5524 /* Return true if symbol is defined in a regular object file. */
5527 is_static_defined (struct elf_link_hash_entry
*h
)
5529 return ((h
->root
.type
== bfd_link_hash_defined
5530 || h
->root
.type
== bfd_link_hash_defweak
)
5531 && h
->root
.u
.def
.section
!= NULL
5532 && h
->root
.u
.def
.section
->output_section
!= NULL
);
5535 /* If FDH is a function descriptor symbol, return the associated code
5536 entry symbol if it is defined. Return NULL otherwise. */
5538 static struct ppc_link_hash_entry
*
5539 defined_code_entry (struct ppc_link_hash_entry
*fdh
)
5541 if (fdh
->is_func_descriptor
)
5543 struct ppc_link_hash_entry
*fh
= ppc_follow_link (fdh
->oh
);
5544 if (fh
->elf
.root
.type
== bfd_link_hash_defined
5545 || fh
->elf
.root
.type
== bfd_link_hash_defweak
)
5551 /* If FH is a function code entry symbol, return the associated
5552 function descriptor symbol if it is defined. Return NULL otherwise. */
5554 static struct ppc_link_hash_entry
*
5555 defined_func_desc (struct ppc_link_hash_entry
*fh
)
5558 && fh
->oh
->is_func_descriptor
)
5560 struct ppc_link_hash_entry
*fdh
= ppc_follow_link (fh
->oh
);
5561 if (fdh
->elf
.root
.type
== bfd_link_hash_defined
5562 || fdh
->elf
.root
.type
== bfd_link_hash_defweak
)
5568 static bfd_boolean
func_desc_adjust (struct elf_link_hash_entry
*, void *);
5570 /* Garbage collect sections, after first dealing with dot-symbols. */
5573 ppc64_elf_gc_sections (bfd
*abfd
, struct bfd_link_info
*info
)
5575 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
5577 if (htab
!= NULL
&& htab
->need_func_desc_adj
)
5579 elf_link_hash_traverse (&htab
->elf
, func_desc_adjust
, info
);
5580 htab
->need_func_desc_adj
= 0;
5582 return bfd_elf_gc_sections (abfd
, info
);
5585 /* Mark all our entry sym sections, both opd and code section. */
5588 ppc64_elf_gc_keep (struct bfd_link_info
*info
)
5590 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
5591 struct bfd_sym_chain
*sym
;
5596 for (sym
= info
->gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
5598 struct ppc_link_hash_entry
*eh
, *fh
;
5601 eh
= (struct ppc_link_hash_entry
*)
5602 elf_link_hash_lookup (&htab
->elf
, sym
->name
, FALSE
, FALSE
, TRUE
);
5605 if (eh
->elf
.root
.type
!= bfd_link_hash_defined
5606 && eh
->elf
.root
.type
!= bfd_link_hash_defweak
)
5609 fh
= defined_code_entry (eh
);
5612 sec
= fh
->elf
.root
.u
.def
.section
;
5613 sec
->flags
|= SEC_KEEP
;
5615 else if (get_opd_info (eh
->elf
.root
.u
.def
.section
) != NULL
5616 && opd_entry_value (eh
->elf
.root
.u
.def
.section
,
5617 eh
->elf
.root
.u
.def
.value
,
5618 &sec
, NULL
, FALSE
) != (bfd_vma
) -1)
5619 sec
->flags
|= SEC_KEEP
;
5621 sec
= eh
->elf
.root
.u
.def
.section
;
5622 sec
->flags
|= SEC_KEEP
;
5626 /* Mark sections containing dynamically referenced symbols. When
5627 building shared libraries, we must assume that any visible symbol is
5631 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry
*h
, void *inf
)
5633 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
5634 struct ppc_link_hash_entry
*eh
= (struct ppc_link_hash_entry
*) h
;
5635 struct ppc_link_hash_entry
*fdh
;
5636 struct bfd_elf_dynamic_list
*d
= info
->dynamic_list
;
5638 /* Dynamic linking info is on the func descriptor sym. */
5639 fdh
= defined_func_desc (eh
);
5643 if ((eh
->elf
.root
.type
== bfd_link_hash_defined
5644 || eh
->elf
.root
.type
== bfd_link_hash_defweak
)
5645 && ((eh
->elf
.ref_dynamic
&& !eh
->elf
.forced_local
)
5646 || ((eh
->elf
.def_regular
|| ELF_COMMON_DEF_P (&eh
->elf
))
5647 && ELF_ST_VISIBILITY (eh
->elf
.other
) != STV_INTERNAL
5648 && ELF_ST_VISIBILITY (eh
->elf
.other
) != STV_HIDDEN
5649 && (!bfd_link_executable (info
)
5650 || info
->gc_keep_exported
5651 || info
->export_dynamic
5654 && (*d
->match
) (&d
->head
, NULL
,
5655 eh
->elf
.root
.root
.string
)))
5656 && (eh
->elf
.versioned
>= versioned
5657 || !bfd_hide_sym_by_version (info
->version_info
,
5658 eh
->elf
.root
.root
.string
)))))
5661 struct ppc_link_hash_entry
*fh
;
5663 eh
->elf
.root
.u
.def
.section
->flags
|= SEC_KEEP
;
5665 /* Function descriptor syms cause the associated
5666 function code sym section to be marked. */
5667 fh
= defined_code_entry (eh
);
5670 code_sec
= fh
->elf
.root
.u
.def
.section
;
5671 code_sec
->flags
|= SEC_KEEP
;
5673 else if (get_opd_info (eh
->elf
.root
.u
.def
.section
) != NULL
5674 && opd_entry_value (eh
->elf
.root
.u
.def
.section
,
5675 eh
->elf
.root
.u
.def
.value
,
5676 &code_sec
, NULL
, FALSE
) != (bfd_vma
) -1)
5677 code_sec
->flags
|= SEC_KEEP
;
5683 /* Return the section that should be marked against GC for a given
5687 ppc64_elf_gc_mark_hook (asection
*sec
,
5688 struct bfd_link_info
*info
,
5689 Elf_Internal_Rela
*rel
,
5690 struct elf_link_hash_entry
*h
,
5691 Elf_Internal_Sym
*sym
)
5695 /* Syms return NULL if we're marking .opd, so we avoid marking all
5696 function sections, as all functions are referenced in .opd. */
5698 if (get_opd_info (sec
) != NULL
)
5703 enum elf_ppc64_reloc_type r_type
;
5704 struct ppc_link_hash_entry
*eh
, *fh
, *fdh
;
5706 r_type
= ELF64_R_TYPE (rel
->r_info
);
5709 case R_PPC64_GNU_VTINHERIT
:
5710 case R_PPC64_GNU_VTENTRY
:
5714 switch (h
->root
.type
)
5716 case bfd_link_hash_defined
:
5717 case bfd_link_hash_defweak
:
5718 eh
= (struct ppc_link_hash_entry
*) h
;
5719 fdh
= defined_func_desc (eh
);
5722 /* -mcall-aixdesc code references the dot-symbol on
5723 a call reloc. Mark the function descriptor too
5724 against garbage collection. */
5726 if (fdh
->elf
.is_weakalias
)
5727 weakdef (&fdh
->elf
)->mark
= 1;
5731 /* Function descriptor syms cause the associated
5732 function code sym section to be marked. */
5733 fh
= defined_code_entry (eh
);
5736 /* They also mark their opd section. */
5737 eh
->elf
.root
.u
.def
.section
->gc_mark
= 1;
5739 rsec
= fh
->elf
.root
.u
.def
.section
;
5741 else if (get_opd_info (eh
->elf
.root
.u
.def
.section
) != NULL
5742 && opd_entry_value (eh
->elf
.root
.u
.def
.section
,
5743 eh
->elf
.root
.u
.def
.value
,
5744 &rsec
, NULL
, FALSE
) != (bfd_vma
) -1)
5745 eh
->elf
.root
.u
.def
.section
->gc_mark
= 1;
5747 rsec
= h
->root
.u
.def
.section
;
5750 case bfd_link_hash_common
:
5751 rsec
= h
->root
.u
.c
.p
->section
;
5755 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
5761 struct _opd_sec_data
*opd
;
5763 rsec
= bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
5764 opd
= get_opd_info (rsec
);
5765 if (opd
!= NULL
&& opd
->func_sec
!= NULL
)
5769 rsec
= opd
->func_sec
[OPD_NDX (sym
->st_value
+ rel
->r_addend
)];
5776 /* The maximum size of .sfpr. */
5777 #define SFPR_MAX (218*4)
5779 struct sfpr_def_parms
5781 const char name
[12];
5782 unsigned char lo
, hi
;
5783 bfd_byte
*(*write_ent
) (bfd
*, bfd_byte
*, int);
5784 bfd_byte
*(*write_tail
) (bfd
*, bfd_byte
*, int);
5787 /* Auto-generate _save*, _rest* functions in .sfpr.
5788 If STUB_SEC is non-null, define alias symbols in STUB_SEC
5792 sfpr_define (struct bfd_link_info
*info
,
5793 const struct sfpr_def_parms
*parm
,
5796 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
5798 size_t len
= strlen (parm
->name
);
5799 bfd_boolean writing
= FALSE
;
5805 memcpy (sym
, parm
->name
, len
);
5808 for (i
= parm
->lo
; i
<= parm
->hi
; i
++)
5810 struct ppc_link_hash_entry
*h
;
5812 sym
[len
+ 0] = i
/ 10 + '0';
5813 sym
[len
+ 1] = i
% 10 + '0';
5814 h
= (struct ppc_link_hash_entry
*)
5815 elf_link_hash_lookup (&htab
->elf
, sym
, writing
, TRUE
, TRUE
);
5816 if (stub_sec
!= NULL
)
5819 && h
->elf
.root
.type
== bfd_link_hash_defined
5820 && h
->elf
.root
.u
.def
.section
== htab
->sfpr
)
5822 struct elf_link_hash_entry
*s
;
5824 sprintf (buf
, "%08x.%s", stub_sec
->id
& 0xffffffff, sym
);
5825 s
= elf_link_hash_lookup (&htab
->elf
, buf
, TRUE
, TRUE
, FALSE
);
5828 if (s
->root
.type
== bfd_link_hash_new
5829 || (s
->root
.type
= bfd_link_hash_defined
5830 && s
->root
.u
.def
.section
== stub_sec
))
5832 s
->root
.type
= bfd_link_hash_defined
;
5833 s
->root
.u
.def
.section
= stub_sec
;
5834 s
->root
.u
.def
.value
= (stub_sec
->size
- htab
->sfpr
->size
5835 + h
->elf
.root
.u
.def
.value
);
5838 s
->ref_regular_nonweak
= 1;
5839 s
->forced_local
= 1;
5841 s
->root
.linker_def
= 1;
5849 if (!h
->elf
.def_regular
)
5851 h
->elf
.root
.type
= bfd_link_hash_defined
;
5852 h
->elf
.root
.u
.def
.section
= htab
->sfpr
;
5853 h
->elf
.root
.u
.def
.value
= htab
->sfpr
->size
;
5854 h
->elf
.type
= STT_FUNC
;
5855 h
->elf
.def_regular
= 1;
5857 _bfd_elf_link_hash_hide_symbol (info
, &h
->elf
, TRUE
);
5859 if (htab
->sfpr
->contents
== NULL
)
5861 htab
->sfpr
->contents
5862 = bfd_alloc (htab
->elf
.dynobj
, SFPR_MAX
);
5863 if (htab
->sfpr
->contents
== NULL
)
5870 bfd_byte
*p
= htab
->sfpr
->contents
+ htab
->sfpr
->size
;
5872 p
= (*parm
->write_ent
) (htab
->elf
.dynobj
, p
, i
);
5874 p
= (*parm
->write_tail
) (htab
->elf
.dynobj
, p
, i
);
5875 htab
->sfpr
->size
= p
- htab
->sfpr
->contents
;
5883 savegpr0 (bfd
*abfd
, bfd_byte
*p
, int r
)
5885 bfd_put_32 (abfd
, STD_R0_0R1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5890 savegpr0_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5892 p
= savegpr0 (abfd
, p
, r
);
5893 bfd_put_32 (abfd
, STD_R0_0R1
+ STK_LR
, p
);
5895 bfd_put_32 (abfd
, BLR
, p
);
5900 restgpr0 (bfd
*abfd
, bfd_byte
*p
, int r
)
5902 bfd_put_32 (abfd
, LD_R0_0R1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5907 restgpr0_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5909 bfd_put_32 (abfd
, LD_R0_0R1
+ STK_LR
, p
);
5911 p
= restgpr0 (abfd
, p
, r
);
5912 bfd_put_32 (abfd
, MTLR_R0
, p
);
5916 p
= restgpr0 (abfd
, p
, 30);
5917 p
= restgpr0 (abfd
, p
, 31);
5919 bfd_put_32 (abfd
, BLR
, p
);
5924 savegpr1 (bfd
*abfd
, bfd_byte
*p
, int r
)
5926 bfd_put_32 (abfd
, STD_R0_0R12
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5931 savegpr1_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5933 p
= savegpr1 (abfd
, p
, r
);
5934 bfd_put_32 (abfd
, BLR
, p
);
5939 restgpr1 (bfd
*abfd
, bfd_byte
*p
, int r
)
5941 bfd_put_32 (abfd
, LD_R0_0R12
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5946 restgpr1_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5948 p
= restgpr1 (abfd
, p
, r
);
5949 bfd_put_32 (abfd
, BLR
, p
);
5954 savefpr (bfd
*abfd
, bfd_byte
*p
, int r
)
5956 bfd_put_32 (abfd
, STFD_FR0_0R1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5961 savefpr0_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5963 p
= savefpr (abfd
, p
, r
);
5964 bfd_put_32 (abfd
, STD_R0_0R1
+ STK_LR
, p
);
5966 bfd_put_32 (abfd
, BLR
, p
);
5971 restfpr (bfd
*abfd
, bfd_byte
*p
, int r
)
5973 bfd_put_32 (abfd
, LFD_FR0_0R1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5978 restfpr0_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5980 bfd_put_32 (abfd
, LD_R0_0R1
+ STK_LR
, p
);
5982 p
= restfpr (abfd
, p
, r
);
5983 bfd_put_32 (abfd
, MTLR_R0
, p
);
5987 p
= restfpr (abfd
, p
, 30);
5988 p
= restfpr (abfd
, p
, 31);
5990 bfd_put_32 (abfd
, BLR
, p
);
5995 savefpr1_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5997 p
= savefpr (abfd
, p
, r
);
5998 bfd_put_32 (abfd
, BLR
, p
);
6003 restfpr1_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6005 p
= restfpr (abfd
, p
, r
);
6006 bfd_put_32 (abfd
, BLR
, p
);
6011 savevr (bfd
*abfd
, bfd_byte
*p
, int r
)
6013 bfd_put_32 (abfd
, LI_R12_0
+ (1 << 16) - (32 - r
) * 16, p
);
6015 bfd_put_32 (abfd
, STVX_VR0_R12_R0
+ (r
<< 21), p
);
6020 savevr_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6022 p
= savevr (abfd
, p
, r
);
6023 bfd_put_32 (abfd
, BLR
, p
);
6028 restvr (bfd
*abfd
, bfd_byte
*p
, int r
)
6030 bfd_put_32 (abfd
, LI_R12_0
+ (1 << 16) - (32 - r
) * 16, p
);
6032 bfd_put_32 (abfd
, LVX_VR0_R12_R0
+ (r
<< 21), p
);
6037 restvr_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6039 p
= restvr (abfd
, p
, r
);
6040 bfd_put_32 (abfd
, BLR
, p
);
6044 /* Called via elf_link_hash_traverse to transfer dynamic linking
6045 information on function code symbol entries to their corresponding
6046 function descriptor symbol entries. */
6049 func_desc_adjust (struct elf_link_hash_entry
*h
, void *inf
)
6051 struct bfd_link_info
*info
;
6052 struct ppc_link_hash_table
*htab
;
6053 struct ppc_link_hash_entry
*fh
;
6054 struct ppc_link_hash_entry
*fdh
;
6055 bfd_boolean force_local
;
6057 fh
= (struct ppc_link_hash_entry
*) h
;
6058 if (fh
->elf
.root
.type
== bfd_link_hash_indirect
)
6064 if (fh
->elf
.root
.root
.string
[0] != '.'
6065 || fh
->elf
.root
.root
.string
[1] == '\0')
6069 htab
= ppc_hash_table (info
);
6073 /* Find the corresponding function descriptor symbol. */
6074 fdh
= lookup_fdh (fh
, htab
);
6076 /* Resolve undefined references to dot-symbols as the value
6077 in the function descriptor, if we have one in a regular object.
6078 This is to satisfy cases like ".quad .foo". Calls to functions
6079 in dynamic objects are handled elsewhere. */
6080 if ((fh
->elf
.root
.type
== bfd_link_hash_undefined
6081 || fh
->elf
.root
.type
== bfd_link_hash_undefweak
)
6082 && (fdh
->elf
.root
.type
== bfd_link_hash_defined
6083 || fdh
->elf
.root
.type
== bfd_link_hash_defweak
)
6084 && get_opd_info (fdh
->elf
.root
.u
.def
.section
) != NULL
6085 && opd_entry_value (fdh
->elf
.root
.u
.def
.section
,
6086 fdh
->elf
.root
.u
.def
.value
,
6087 &fh
->elf
.root
.u
.def
.section
,
6088 &fh
->elf
.root
.u
.def
.value
, FALSE
) != (bfd_vma
) -1)
6090 fh
->elf
.root
.type
= fdh
->elf
.root
.type
;
6091 fh
->elf
.forced_local
= 1;
6092 fh
->elf
.def_regular
= fdh
->elf
.def_regular
;
6093 fh
->elf
.def_dynamic
= fdh
->elf
.def_dynamic
;
6096 if (!fh
->elf
.dynamic
)
6098 struct plt_entry
*ent
;
6100 for (ent
= fh
->elf
.plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
6101 if (ent
->plt
.refcount
> 0)
6107 /* Create a descriptor as undefined if necessary. */
6109 && !bfd_link_executable (info
)
6110 && (fh
->elf
.root
.type
== bfd_link_hash_undefined
6111 || fh
->elf
.root
.type
== bfd_link_hash_undefweak
))
6113 fdh
= make_fdh (info
, fh
);
6118 /* We can't support overriding of symbols on a fake descriptor. */
6121 && (fh
->elf
.root
.type
== bfd_link_hash_defined
6122 || fh
->elf
.root
.type
== bfd_link_hash_defweak
))
6123 _bfd_elf_link_hash_hide_symbol (info
, &fdh
->elf
, TRUE
);
6125 /* Transfer dynamic linking information to the function descriptor. */
6128 fdh
->elf
.ref_regular
|= fh
->elf
.ref_regular
;
6129 fdh
->elf
.ref_dynamic
|= fh
->elf
.ref_dynamic
;
6130 fdh
->elf
.ref_regular_nonweak
|= fh
->elf
.ref_regular_nonweak
;
6131 fdh
->elf
.non_got_ref
|= fh
->elf
.non_got_ref
;
6132 fdh
->elf
.dynamic
|= fh
->elf
.dynamic
;
6133 fdh
->elf
.needs_plt
|= (fh
->elf
.needs_plt
6134 || fh
->elf
.type
== STT_FUNC
6135 || fh
->elf
.type
== STT_GNU_IFUNC
);
6136 move_plt_plist (fh
, fdh
);
6138 if (!fdh
->elf
.forced_local
6139 && fh
->elf
.dynindx
!= -1)
6140 if (!bfd_elf_link_record_dynamic_symbol (info
, &fdh
->elf
))
6144 /* Now that the info is on the function descriptor, clear the
6145 function code sym info. Any function code syms for which we
6146 don't have a definition in a regular file, we force local.
6147 This prevents a shared library from exporting syms that have
6148 been imported from another library. Function code syms that
6149 are really in the library we must leave global to prevent the
6150 linker dragging in a definition from a static library. */
6151 force_local
= (!fh
->elf
.def_regular
6153 || !fdh
->elf
.def_regular
6154 || fdh
->elf
.forced_local
);
6155 _bfd_elf_link_hash_hide_symbol (info
, &fh
->elf
, force_local
);
6160 static const struct sfpr_def_parms save_res_funcs
[] =
6162 { "_savegpr0_", 14, 31, savegpr0
, savegpr0_tail
},
6163 { "_restgpr0_", 14, 29, restgpr0
, restgpr0_tail
},
6164 { "_restgpr0_", 30, 31, restgpr0
, restgpr0_tail
},
6165 { "_savegpr1_", 14, 31, savegpr1
, savegpr1_tail
},
6166 { "_restgpr1_", 14, 31, restgpr1
, restgpr1_tail
},
6167 { "_savefpr_", 14, 31, savefpr
, savefpr0_tail
},
6168 { "_restfpr_", 14, 29, restfpr
, restfpr0_tail
},
6169 { "_restfpr_", 30, 31, restfpr
, restfpr0_tail
},
6170 { "._savef", 14, 31, savefpr
, savefpr1_tail
},
6171 { "._restf", 14, 31, restfpr
, restfpr1_tail
},
6172 { "_savevr_", 20, 31, savevr
, savevr_tail
},
6173 { "_restvr_", 20, 31, restvr
, restvr_tail
}
6176 /* Called near the start of bfd_elf_size_dynamic_sections. We use
6177 this hook to a) provide some gcc support functions, and b) transfer
6178 dynamic linking information gathered so far on function code symbol
6179 entries, to their corresponding function descriptor symbol entries. */
6182 ppc64_elf_func_desc_adjust (bfd
*obfd ATTRIBUTE_UNUSED
,
6183 struct bfd_link_info
*info
)
6185 struct ppc_link_hash_table
*htab
;
6187 htab
= ppc_hash_table (info
);
6191 /* Provide any missing _save* and _rest* functions. */
6192 if (htab
->sfpr
!= NULL
)
6196 htab
->sfpr
->size
= 0;
6197 for (i
= 0; i
< ARRAY_SIZE (save_res_funcs
); i
++)
6198 if (!sfpr_define (info
, &save_res_funcs
[i
], NULL
))
6200 if (htab
->sfpr
->size
== 0)
6201 htab
->sfpr
->flags
|= SEC_EXCLUDE
;
6204 if (bfd_link_relocatable (info
))
6207 if (htab
->elf
.hgot
!= NULL
)
6209 _bfd_elf_link_hash_hide_symbol (info
, htab
->elf
.hgot
, TRUE
);
6210 /* Make .TOC. defined so as to prevent it being made dynamic.
6211 The wrong value here is fixed later in ppc64_elf_set_toc. */
6212 if (!htab
->elf
.hgot
->def_regular
6213 || htab
->elf
.hgot
->root
.type
!= bfd_link_hash_defined
)
6215 htab
->elf
.hgot
->root
.type
= bfd_link_hash_defined
;
6216 htab
->elf
.hgot
->root
.u
.def
.value
= 0;
6217 htab
->elf
.hgot
->root
.u
.def
.section
= bfd_abs_section_ptr
;
6218 htab
->elf
.hgot
->def_regular
= 1;
6219 htab
->elf
.hgot
->root
.linker_def
= 1;
6221 htab
->elf
.hgot
->type
= STT_OBJECT
;
6222 htab
->elf
.hgot
->other
6223 = (htab
->elf
.hgot
->other
& ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN
;
6226 if (htab
->need_func_desc_adj
)
6228 elf_link_hash_traverse (&htab
->elf
, func_desc_adjust
, info
);
6229 htab
->need_func_desc_adj
= 0;
6235 /* Find dynamic relocs for H that apply to read-only sections. */
6238 readonly_dynrelocs (struct elf_link_hash_entry
*h
)
6240 struct ppc_link_hash_entry
*eh
;
6241 struct elf_dyn_relocs
*p
;
6243 eh
= (struct ppc_link_hash_entry
*) h
;
6244 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
6246 asection
*s
= p
->sec
->output_section
;
6248 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
6254 /* Return true if we have dynamic relocs against H or any of its weak
6255 aliases, that apply to read-only sections. Cannot be used after
6256 size_dynamic_sections. */
6259 alias_readonly_dynrelocs (struct elf_link_hash_entry
*h
)
6261 struct ppc_link_hash_entry
*eh
;
6263 eh
= (struct ppc_link_hash_entry
*) h
;
6266 if (readonly_dynrelocs (&eh
->elf
))
6268 eh
= (struct ppc_link_hash_entry
*) eh
->elf
.u
.alias
;
6270 while (eh
!= NULL
&& &eh
->elf
!= h
);
6275 /* Return whether EH has pc-relative dynamic relocs. */
6278 pc_dynrelocs (struct ppc_link_hash_entry
*eh
)
6280 struct elf_dyn_relocs
*p
;
6282 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
6283 if (p
->pc_count
!= 0)
6288 /* Return true if a global entry stub will be created for H. Valid
6289 for ELFv2 before plt entries have been allocated. */
6292 global_entry_stub (struct elf_link_hash_entry
*h
)
6294 struct plt_entry
*pent
;
6296 if (!h
->pointer_equality_needed
6300 for (pent
= h
->plt
.plist
; pent
!= NULL
; pent
= pent
->next
)
6301 if (pent
->plt
.refcount
> 0
6302 && pent
->addend
== 0)
6308 /* Adjust a symbol defined by a dynamic object and referenced by a
6309 regular object. The current definition is in some section of the
6310 dynamic object, but we're not including those sections. We have to
6311 change the definition to something the rest of the link can
6315 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
6316 struct elf_link_hash_entry
*h
)
6318 struct ppc_link_hash_table
*htab
;
6321 htab
= ppc_hash_table (info
);
6325 /* Deal with function syms. */
6326 if (h
->type
== STT_FUNC
6327 || h
->type
== STT_GNU_IFUNC
6330 bfd_boolean local
= (((struct ppc_link_hash_entry
*) h
)->save_res
6331 || SYMBOL_CALLS_LOCAL (info
, h
)
6332 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
));
6333 /* Discard dyn_relocs when non-pic if we've decided that a
6334 function symbol is local and not an ifunc. We keep dynamic
6335 relocs for ifuncs when local rather than always emitting a
6336 plt call stub for them and defining the symbol on the call
6337 stub. We can't do that for ELFv1 anyway (a function symbol
6338 is defined on a descriptor, not code) and it can be faster at
6339 run-time due to not needing to bounce through a stub. The
6340 dyn_relocs for ifuncs will be applied even in a static
6342 if (!bfd_link_pic (info
)
6343 && h
->type
!= STT_GNU_IFUNC
6345 ((struct ppc_link_hash_entry
*) h
)->dyn_relocs
= NULL
;
6347 /* Clear procedure linkage table information for any symbol that
6348 won't need a .plt entry. */
6349 struct plt_entry
*ent
;
6350 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
6351 if (ent
->plt
.refcount
> 0)
6354 || (h
->type
!= STT_GNU_IFUNC
6356 && (htab
->can_convert_all_inline_plt
6357 || (((struct ppc_link_hash_entry
*) h
)->tls_mask
6358 & (TLS_TLS
| PLT_KEEP
)) != PLT_KEEP
)))
6360 h
->plt
.plist
= NULL
;
6362 h
->pointer_equality_needed
= 0;
6364 else if (abiversion (info
->output_bfd
) >= 2)
6366 /* Taking a function's address in a read/write section
6367 doesn't require us to define the function symbol in the
6368 executable on a global entry stub. A dynamic reloc can
6369 be used instead. The reason we prefer a few more dynamic
6370 relocs is that calling via a global entry stub costs a
6371 few more instructions, and pointer_equality_needed causes
6372 extra work in ld.so when resolving these symbols. */
6373 if (global_entry_stub (h
))
6375 if (!readonly_dynrelocs (h
))
6377 h
->pointer_equality_needed
= 0;
6378 /* If we haven't seen a branch reloc and the symbol
6379 isn't an ifunc then we don't need a plt entry. */
6381 h
->plt
.plist
= NULL
;
6383 else if (!bfd_link_pic (info
))
6384 /* We are going to be defining the function symbol on the
6385 plt stub, so no dyn_relocs needed when non-pic. */
6386 ((struct ppc_link_hash_entry
*) h
)->dyn_relocs
= NULL
;
6389 /* ELFv2 function symbols can't have copy relocs. */
6392 else if (!h
->needs_plt
6393 && !readonly_dynrelocs (h
))
6395 /* If we haven't seen a branch reloc and the symbol isn't an
6396 ifunc then we don't need a plt entry. */
6397 h
->plt
.plist
= NULL
;
6398 h
->pointer_equality_needed
= 0;
6403 h
->plt
.plist
= NULL
;
6405 /* If this is a weak symbol, and there is a real definition, the
6406 processor independent code will have arranged for us to see the
6407 real definition first, and we can just use the same value. */
6408 if (h
->is_weakalias
)
6410 struct elf_link_hash_entry
*def
= weakdef (h
);
6411 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
6412 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
6413 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
6414 if (def
->root
.u
.def
.section
== htab
->elf
.sdynbss
6415 || def
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
6416 ((struct ppc_link_hash_entry
*) h
)->dyn_relocs
= NULL
;
6420 /* If we are creating a shared library, we must presume that the
6421 only references to the symbol are via the global offset table.
6422 For such cases we need not do anything here; the relocations will
6423 be handled correctly by relocate_section. */
6424 if (bfd_link_pic (info
))
6427 /* If there are no references to this symbol that do not use the
6428 GOT, we don't need to generate a copy reloc. */
6429 if (!h
->non_got_ref
)
6432 /* Don't generate a copy reloc for symbols defined in the executable. */
6433 if (!h
->def_dynamic
|| !h
->ref_regular
|| h
->def_regular
6435 /* If -z nocopyreloc was given, don't generate them either. */
6436 || info
->nocopyreloc
6438 /* If we don't find any dynamic relocs in read-only sections, then
6439 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
6440 || (ELIMINATE_COPY_RELOCS
&& !alias_readonly_dynrelocs (h
))
6442 /* Protected variables do not work with .dynbss. The copy in
6443 .dynbss won't be used by the shared library with the protected
6444 definition for the variable. Text relocations are preferable
6445 to an incorrect program. */
6446 || h
->protected_def
)
6449 if (h
->plt
.plist
!= NULL
)
6451 /* We should never get here, but unfortunately there are versions
6452 of gcc out there that improperly (for this ABI) put initialized
6453 function pointers, vtable refs and suchlike in read-only
6454 sections. Allow them to proceed, but warn that this might
6455 break at runtime. */
6456 info
->callbacks
->einfo
6457 (_("%P: copy reloc against `%pT' requires lazy plt linking; "
6458 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
6459 h
->root
.root
.string
);
6462 /* This is a reference to a symbol defined by a dynamic object which
6463 is not a function. */
6465 /* We must allocate the symbol in our .dynbss section, which will
6466 become part of the .bss section of the executable. There will be
6467 an entry for this symbol in the .dynsym section. The dynamic
6468 object will contain position independent code, so all references
6469 from the dynamic object to this symbol will go through the global
6470 offset table. The dynamic linker will use the .dynsym entry to
6471 determine the address it must put in the global offset table, so
6472 both the dynamic object and the regular object will refer to the
6473 same memory location for the variable. */
6474 if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
6476 s
= htab
->elf
.sdynrelro
;
6477 srel
= htab
->elf
.sreldynrelro
;
6481 s
= htab
->elf
.sdynbss
;
6482 srel
= htab
->elf
.srelbss
;
6484 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
6486 /* We must generate a R_PPC64_COPY reloc to tell the dynamic
6487 linker to copy the initial value out of the dynamic object
6488 and into the runtime process image. */
6489 srel
->size
+= sizeof (Elf64_External_Rela
);
6493 /* We no longer want dyn_relocs. */
6494 ((struct ppc_link_hash_entry
*) h
)->dyn_relocs
= NULL
;
6495 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
6498 /* If given a function descriptor symbol, hide both the function code
6499 sym and the descriptor. */
6501 ppc64_elf_hide_symbol (struct bfd_link_info
*info
,
6502 struct elf_link_hash_entry
*h
,
6503 bfd_boolean force_local
)
6505 struct ppc_link_hash_entry
*eh
;
6506 _bfd_elf_link_hash_hide_symbol (info
, h
, force_local
);
6508 if (ppc_hash_table (info
) == NULL
)
6511 eh
= (struct ppc_link_hash_entry
*) h
;
6512 if (eh
->is_func_descriptor
)
6514 struct ppc_link_hash_entry
*fh
= eh
->oh
;
6519 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
6522 /* We aren't supposed to use alloca in BFD because on
6523 systems which do not have alloca the version in libiberty
6524 calls xmalloc, which might cause the program to crash
6525 when it runs out of memory. This function doesn't have a
6526 return status, so there's no way to gracefully return an
6527 error. So cheat. We know that string[-1] can be safely
6528 accessed; It's either a string in an ELF string table,
6529 or allocated in an objalloc structure. */
6531 p
= eh
->elf
.root
.root
.string
- 1;
6534 fh
= (struct ppc_link_hash_entry
*)
6535 elf_link_hash_lookup (htab
, p
, FALSE
, FALSE
, FALSE
);
6538 /* Unfortunately, if it so happens that the string we were
6539 looking for was allocated immediately before this string,
6540 then we overwrote the string terminator. That's the only
6541 reason the lookup should fail. */
6544 q
= eh
->elf
.root
.root
.string
+ strlen (eh
->elf
.root
.root
.string
);
6545 while (q
>= eh
->elf
.root
.root
.string
&& *q
== *p
)
6547 if (q
< eh
->elf
.root
.root
.string
&& *p
== '.')
6548 fh
= (struct ppc_link_hash_entry
*)
6549 elf_link_hash_lookup (htab
, p
, FALSE
, FALSE
, FALSE
);
6558 _bfd_elf_link_hash_hide_symbol (info
, &fh
->elf
, force_local
);
6563 get_sym_h (struct elf_link_hash_entry
**hp
,
6564 Elf_Internal_Sym
**symp
,
6566 unsigned char **tls_maskp
,
6567 Elf_Internal_Sym
**locsymsp
,
6568 unsigned long r_symndx
,
6571 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (ibfd
);
6573 if (r_symndx
>= symtab_hdr
->sh_info
)
6575 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (ibfd
);
6576 struct elf_link_hash_entry
*h
;
6578 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
6579 h
= elf_follow_link (h
);
6587 if (symsecp
!= NULL
)
6589 asection
*symsec
= NULL
;
6590 if (h
->root
.type
== bfd_link_hash_defined
6591 || h
->root
.type
== bfd_link_hash_defweak
)
6592 symsec
= h
->root
.u
.def
.section
;
6596 if (tls_maskp
!= NULL
)
6598 struct ppc_link_hash_entry
*eh
;
6600 eh
= (struct ppc_link_hash_entry
*) h
;
6601 *tls_maskp
= &eh
->tls_mask
;
6606 Elf_Internal_Sym
*sym
;
6607 Elf_Internal_Sym
*locsyms
= *locsymsp
;
6609 if (locsyms
== NULL
)
6611 locsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
6612 if (locsyms
== NULL
)
6613 locsyms
= bfd_elf_get_elf_syms (ibfd
, symtab_hdr
,
6614 symtab_hdr
->sh_info
,
6615 0, NULL
, NULL
, NULL
);
6616 if (locsyms
== NULL
)
6618 *locsymsp
= locsyms
;
6620 sym
= locsyms
+ r_symndx
;
6628 if (symsecp
!= NULL
)
6629 *symsecp
= bfd_section_from_elf_index (ibfd
, sym
->st_shndx
);
6631 if (tls_maskp
!= NULL
)
6633 struct got_entry
**lgot_ents
;
6634 unsigned char *tls_mask
;
6637 lgot_ents
= elf_local_got_ents (ibfd
);
6638 if (lgot_ents
!= NULL
)
6640 struct plt_entry
**local_plt
= (struct plt_entry
**)
6641 (lgot_ents
+ symtab_hdr
->sh_info
);
6642 unsigned char *lgot_masks
= (unsigned char *)
6643 (local_plt
+ symtab_hdr
->sh_info
);
6644 tls_mask
= &lgot_masks
[r_symndx
];
6646 *tls_maskp
= tls_mask
;
6652 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
6653 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
6654 type suitable for optimization, and 1 otherwise. */
6657 get_tls_mask (unsigned char **tls_maskp
,
6658 unsigned long *toc_symndx
,
6659 bfd_vma
*toc_addend
,
6660 Elf_Internal_Sym
**locsymsp
,
6661 const Elf_Internal_Rela
*rel
,
6664 unsigned long r_symndx
;
6666 struct elf_link_hash_entry
*h
;
6667 Elf_Internal_Sym
*sym
;
6671 r_symndx
= ELF64_R_SYM (rel
->r_info
);
6672 if (!get_sym_h (&h
, &sym
, &sec
, tls_maskp
, locsymsp
, r_symndx
, ibfd
))
6675 if ((*tls_maskp
!= NULL
6676 && (**tls_maskp
& TLS_TLS
) != 0
6677 && **tls_maskp
!= (TLS_TLS
| TLS_MARK
))
6679 || ppc64_elf_section_data (sec
) == NULL
6680 || ppc64_elf_section_data (sec
)->sec_type
!= sec_toc
)
6683 /* Look inside a TOC section too. */
6686 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
);
6687 off
= h
->root
.u
.def
.value
;
6690 off
= sym
->st_value
;
6691 off
+= rel
->r_addend
;
6692 BFD_ASSERT (off
% 8 == 0);
6693 r_symndx
= ppc64_elf_section_data (sec
)->u
.toc
.symndx
[off
/ 8];
6694 next_r
= ppc64_elf_section_data (sec
)->u
.toc
.symndx
[off
/ 8 + 1];
6695 if (toc_symndx
!= NULL
)
6696 *toc_symndx
= r_symndx
;
6697 if (toc_addend
!= NULL
)
6698 *toc_addend
= ppc64_elf_section_data (sec
)->u
.toc
.add
[off
/ 8];
6699 if (!get_sym_h (&h
, &sym
, &sec
, tls_maskp
, locsymsp
, r_symndx
, ibfd
))
6701 if ((h
== NULL
|| is_static_defined (h
))
6702 && (next_r
== -1 || next_r
== -2))
6707 /* Find (or create) an entry in the tocsave hash table. */
6709 static struct tocsave_entry
*
6710 tocsave_find (struct ppc_link_hash_table
*htab
,
6711 enum insert_option insert
,
6712 Elf_Internal_Sym
**local_syms
,
6713 const Elf_Internal_Rela
*irela
,
6716 unsigned long r_indx
;
6717 struct elf_link_hash_entry
*h
;
6718 Elf_Internal_Sym
*sym
;
6719 struct tocsave_entry ent
, *p
;
6721 struct tocsave_entry
**slot
;
6723 r_indx
= ELF64_R_SYM (irela
->r_info
);
6724 if (!get_sym_h (&h
, &sym
, &ent
.sec
, NULL
, local_syms
, r_indx
, ibfd
))
6726 if (ent
.sec
== NULL
|| ent
.sec
->output_section
== NULL
)
6729 (_("%pB: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd
);
6734 ent
.offset
= h
->root
.u
.def
.value
;
6736 ent
.offset
= sym
->st_value
;
6737 ent
.offset
+= irela
->r_addend
;
6739 hash
= tocsave_htab_hash (&ent
);
6740 slot
= ((struct tocsave_entry
**)
6741 htab_find_slot_with_hash (htab
->tocsave_htab
, &ent
, hash
, insert
));
6747 p
= (struct tocsave_entry
*) bfd_alloc (ibfd
, sizeof (*p
));
6756 /* Adjust all global syms defined in opd sections. In gcc generated
6757 code for the old ABI, these will already have been done. */
6760 adjust_opd_syms (struct elf_link_hash_entry
*h
, void *inf ATTRIBUTE_UNUSED
)
6762 struct ppc_link_hash_entry
*eh
;
6764 struct _opd_sec_data
*opd
;
6766 if (h
->root
.type
== bfd_link_hash_indirect
)
6769 if (h
->root
.type
!= bfd_link_hash_defined
6770 && h
->root
.type
!= bfd_link_hash_defweak
)
6773 eh
= (struct ppc_link_hash_entry
*) h
;
6774 if (eh
->adjust_done
)
6777 sym_sec
= eh
->elf
.root
.u
.def
.section
;
6778 opd
= get_opd_info (sym_sec
);
6779 if (opd
!= NULL
&& opd
->adjust
!= NULL
)
6781 long adjust
= opd
->adjust
[OPD_NDX (eh
->elf
.root
.u
.def
.value
)];
6784 /* This entry has been deleted. */
6785 asection
*dsec
= ppc64_elf_tdata (sym_sec
->owner
)->deleted_section
;
6788 for (dsec
= sym_sec
->owner
->sections
; dsec
; dsec
= dsec
->next
)
6789 if (discarded_section (dsec
))
6791 ppc64_elf_tdata (sym_sec
->owner
)->deleted_section
= dsec
;
6795 eh
->elf
.root
.u
.def
.value
= 0;
6796 eh
->elf
.root
.u
.def
.section
= dsec
;
6799 eh
->elf
.root
.u
.def
.value
+= adjust
;
6800 eh
->adjust_done
= 1;
6805 /* Handles decrementing dynamic reloc counts for the reloc specified by
6806 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
6807 have already been determined. */
6810 dec_dynrel_count (bfd_vma r_info
,
6812 struct bfd_link_info
*info
,
6813 Elf_Internal_Sym
**local_syms
,
6814 struct elf_link_hash_entry
*h
,
6815 Elf_Internal_Sym
*sym
)
6817 enum elf_ppc64_reloc_type r_type
;
6818 asection
*sym_sec
= NULL
;
6820 /* Can this reloc be dynamic? This switch, and later tests here
6821 should be kept in sync with the code in check_relocs. */
6822 r_type
= ELF64_R_TYPE (r_info
);
6828 case R_PPC64_TPREL16
:
6829 case R_PPC64_TPREL16_LO
:
6830 case R_PPC64_TPREL16_HI
:
6831 case R_PPC64_TPREL16_HA
:
6832 case R_PPC64_TPREL16_DS
:
6833 case R_PPC64_TPREL16_LO_DS
:
6834 case R_PPC64_TPREL16_HIGH
:
6835 case R_PPC64_TPREL16_HIGHA
:
6836 case R_PPC64_TPREL16_HIGHER
:
6837 case R_PPC64_TPREL16_HIGHERA
:
6838 case R_PPC64_TPREL16_HIGHEST
:
6839 case R_PPC64_TPREL16_HIGHESTA
:
6840 case R_PPC64_TPREL64
:
6841 case R_PPC64_TPREL34
:
6842 case R_PPC64_DTPMOD64
:
6843 case R_PPC64_DTPREL64
:
6844 case R_PPC64_ADDR64
:
6848 case R_PPC64_ADDR14
:
6849 case R_PPC64_ADDR14_BRNTAKEN
:
6850 case R_PPC64_ADDR14_BRTAKEN
:
6851 case R_PPC64_ADDR16
:
6852 case R_PPC64_ADDR16_DS
:
6853 case R_PPC64_ADDR16_HA
:
6854 case R_PPC64_ADDR16_HI
:
6855 case R_PPC64_ADDR16_HIGH
:
6856 case R_PPC64_ADDR16_HIGHA
:
6857 case R_PPC64_ADDR16_HIGHER
:
6858 case R_PPC64_ADDR16_HIGHERA
:
6859 case R_PPC64_ADDR16_HIGHEST
:
6860 case R_PPC64_ADDR16_HIGHESTA
:
6861 case R_PPC64_ADDR16_LO
:
6862 case R_PPC64_ADDR16_LO_DS
:
6863 case R_PPC64_ADDR24
:
6864 case R_PPC64_ADDR32
:
6865 case R_PPC64_UADDR16
:
6866 case R_PPC64_UADDR32
:
6867 case R_PPC64_UADDR64
:
6870 case R_PPC64_D34_LO
:
6871 case R_PPC64_D34_HI30
:
6872 case R_PPC64_D34_HA30
:
6873 case R_PPC64_ADDR16_HIGHER34
:
6874 case R_PPC64_ADDR16_HIGHERA34
:
6875 case R_PPC64_ADDR16_HIGHEST34
:
6876 case R_PPC64_ADDR16_HIGHESTA34
:
6881 if (local_syms
!= NULL
)
6883 unsigned long r_symndx
;
6884 bfd
*ibfd
= sec
->owner
;
6886 r_symndx
= ELF64_R_SYM (r_info
);
6887 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, local_syms
, r_symndx
, ibfd
))
6891 if ((bfd_link_pic (info
)
6892 && (must_be_dyn_reloc (info
, r_type
)
6894 && (!SYMBOLIC_BIND (info
, h
)
6895 || h
->root
.type
== bfd_link_hash_defweak
6896 || !h
->def_regular
))))
6897 || (ELIMINATE_COPY_RELOCS
6898 && !bfd_link_pic (info
)
6900 && (h
->root
.type
== bfd_link_hash_defweak
6901 || !h
->def_regular
)))
6908 struct elf_dyn_relocs
*p
;
6909 struct elf_dyn_relocs
**pp
;
6910 pp
= &((struct ppc_link_hash_entry
*) h
)->dyn_relocs
;
6912 /* elf_gc_sweep may have already removed all dyn relocs associated
6913 with local syms for a given section. Also, symbol flags are
6914 changed by elf_gc_sweep_symbol, confusing the test above. Don't
6915 report a dynreloc miscount. */
6916 if (*pp
== NULL
&& info
->gc_sections
)
6919 while ((p
= *pp
) != NULL
)
6923 if (!must_be_dyn_reloc (info
, r_type
))
6935 struct ppc_dyn_relocs
*p
;
6936 struct ppc_dyn_relocs
**pp
;
6938 bfd_boolean is_ifunc
;
6940 if (local_syms
== NULL
)
6941 sym_sec
= bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
6942 if (sym_sec
== NULL
)
6945 vpp
= &elf_section_data (sym_sec
)->local_dynrel
;
6946 pp
= (struct ppc_dyn_relocs
**) vpp
;
6948 if (*pp
== NULL
&& info
->gc_sections
)
6951 is_ifunc
= ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
;
6952 while ((p
= *pp
) != NULL
)
6954 if (p
->sec
== sec
&& p
->ifunc
== is_ifunc
)
6965 /* xgettext:c-format */
6966 _bfd_error_handler (_("dynreloc miscount for %pB, section %pA"),
6968 bfd_set_error (bfd_error_bad_value
);
6972 /* Remove unused Official Procedure Descriptor entries. Currently we
6973 only remove those associated with functions in discarded link-once
6974 sections, or weakly defined functions that have been overridden. It
6975 would be possible to remove many more entries for statically linked
6979 ppc64_elf_edit_opd (struct bfd_link_info
*info
)
6982 bfd_boolean some_edited
= FALSE
;
6983 asection
*need_pad
= NULL
;
6984 struct ppc_link_hash_table
*htab
;
6986 htab
= ppc_hash_table (info
);
6990 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
6993 Elf_Internal_Rela
*relstart
, *rel
, *relend
;
6994 Elf_Internal_Shdr
*symtab_hdr
;
6995 Elf_Internal_Sym
*local_syms
;
6996 struct _opd_sec_data
*opd
;
6997 bfd_boolean need_edit
, add_aux_fields
, broken
;
6998 bfd_size_type cnt_16b
= 0;
7000 if (!is_ppc64_elf (ibfd
))
7003 sec
= bfd_get_section_by_name (ibfd
, ".opd");
7004 if (sec
== NULL
|| sec
->size
== 0)
7007 if (sec
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
7010 if (sec
->output_section
== bfd_abs_section_ptr
)
7013 /* Look through the section relocs. */
7014 if ((sec
->flags
& SEC_RELOC
) == 0 || sec
->reloc_count
== 0)
7018 symtab_hdr
= &elf_symtab_hdr (ibfd
);
7020 /* Read the relocations. */
7021 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
7023 if (relstart
== NULL
)
7026 /* First run through the relocs to check they are sane, and to
7027 determine whether we need to edit this opd section. */
7031 relend
= relstart
+ sec
->reloc_count
;
7032 for (rel
= relstart
; rel
< relend
; )
7034 enum elf_ppc64_reloc_type r_type
;
7035 unsigned long r_symndx
;
7037 struct elf_link_hash_entry
*h
;
7038 Elf_Internal_Sym
*sym
;
7041 /* .opd contains an array of 16 or 24 byte entries. We're
7042 only interested in the reloc pointing to a function entry
7044 offset
= rel
->r_offset
;
7045 if (rel
+ 1 == relend
7046 || rel
[1].r_offset
!= offset
+ 8)
7048 /* If someone messes with .opd alignment then after a
7049 "ld -r" we might have padding in the middle of .opd.
7050 Also, there's nothing to prevent someone putting
7051 something silly in .opd with the assembler. No .opd
7052 optimization for them! */
7055 (_("%pB: .opd is not a regular array of opd entries"), ibfd
);
7060 if ((r_type
= ELF64_R_TYPE (rel
->r_info
)) != R_PPC64_ADDR64
7061 || (r_type
= ELF64_R_TYPE ((rel
+ 1)->r_info
)) != R_PPC64_TOC
)
7064 /* xgettext:c-format */
7065 (_("%pB: unexpected reloc type %u in .opd section"),
7071 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7072 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
7076 if (sym_sec
== NULL
|| sym_sec
->owner
== NULL
)
7078 const char *sym_name
;
7080 sym_name
= h
->root
.root
.string
;
7082 sym_name
= bfd_elf_sym_name (ibfd
, symtab_hdr
, sym
,
7086 /* xgettext:c-format */
7087 (_("%pB: undefined sym `%s' in .opd section"),
7093 /* opd entries are always for functions defined in the
7094 current input bfd. If the symbol isn't defined in the
7095 input bfd, then we won't be using the function in this
7096 bfd; It must be defined in a linkonce section in another
7097 bfd, or is weak. It's also possible that we are
7098 discarding the function due to a linker script /DISCARD/,
7099 which we test for via the output_section. */
7100 if (sym_sec
->owner
!= ibfd
7101 || sym_sec
->output_section
== bfd_abs_section_ptr
)
7105 if (rel
+ 1 == relend
7106 || (rel
+ 2 < relend
7107 && ELF64_R_TYPE (rel
[2].r_info
) == R_PPC64_TOC
))
7112 if (sec
->size
== offset
+ 24)
7117 if (sec
->size
== offset
+ 16)
7124 else if (rel
+ 1 < relend
7125 && ELF64_R_TYPE (rel
[0].r_info
) == R_PPC64_ADDR64
7126 && ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_TOC
)
7128 if (rel
[0].r_offset
== offset
+ 16)
7130 else if (rel
[0].r_offset
!= offset
+ 24)
7137 add_aux_fields
= htab
->params
->non_overlapping_opd
&& cnt_16b
> 0;
7139 if (!broken
&& (need_edit
|| add_aux_fields
))
7141 Elf_Internal_Rela
*write_rel
;
7142 Elf_Internal_Shdr
*rel_hdr
;
7143 bfd_byte
*rptr
, *wptr
;
7144 bfd_byte
*new_contents
;
7147 new_contents
= NULL
;
7148 amt
= OPD_NDX (sec
->size
) * sizeof (long);
7149 opd
= &ppc64_elf_section_data (sec
)->u
.opd
;
7150 opd
->adjust
= bfd_zalloc (sec
->owner
, amt
);
7151 if (opd
->adjust
== NULL
)
7154 /* This seems a waste of time as input .opd sections are all
7155 zeros as generated by gcc, but I suppose there's no reason
7156 this will always be so. We might start putting something in
7157 the third word of .opd entries. */
7158 if ((sec
->flags
& SEC_IN_MEMORY
) == 0)
7161 if (!bfd_malloc_and_get_section (ibfd
, sec
, &loc
))
7166 if (local_syms
!= NULL
7167 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
7169 if (elf_section_data (sec
)->relocs
!= relstart
)
7173 sec
->contents
= loc
;
7174 sec
->flags
|= (SEC_IN_MEMORY
| SEC_HAS_CONTENTS
);
7177 elf_section_data (sec
)->relocs
= relstart
;
7179 new_contents
= sec
->contents
;
7182 new_contents
= bfd_malloc (sec
->size
+ cnt_16b
* 8);
7183 if (new_contents
== NULL
)
7187 wptr
= new_contents
;
7188 rptr
= sec
->contents
;
7189 write_rel
= relstart
;
7190 for (rel
= relstart
; rel
< relend
; )
7192 unsigned long r_symndx
;
7194 struct elf_link_hash_entry
*h
;
7195 struct ppc_link_hash_entry
*fdh
= NULL
;
7196 Elf_Internal_Sym
*sym
;
7198 Elf_Internal_Rela
*next_rel
;
7201 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7202 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
7207 if (next_rel
+ 1 == relend
7208 || (next_rel
+ 2 < relend
7209 && ELF64_R_TYPE (next_rel
[2].r_info
) == R_PPC64_TOC
))
7212 /* See if the .opd entry is full 24 byte or
7213 16 byte (with fd_aux entry overlapped with next
7216 if (next_rel
== relend
)
7218 if (sec
->size
== rel
->r_offset
+ 16)
7221 else if (next_rel
->r_offset
== rel
->r_offset
+ 16)
7225 && h
->root
.root
.string
[0] == '.')
7227 fdh
= ((struct ppc_link_hash_entry
*) h
)->oh
;
7230 fdh
= ppc_follow_link (fdh
);
7231 if (fdh
->elf
.root
.type
!= bfd_link_hash_defined
7232 && fdh
->elf
.root
.type
!= bfd_link_hash_defweak
)
7237 skip
= (sym_sec
->owner
!= ibfd
7238 || sym_sec
->output_section
== bfd_abs_section_ptr
);
7241 if (fdh
!= NULL
&& sym_sec
->owner
== ibfd
)
7243 /* Arrange for the function descriptor sym
7245 fdh
->elf
.root
.u
.def
.value
= 0;
7246 fdh
->elf
.root
.u
.def
.section
= sym_sec
;
7248 opd
->adjust
[OPD_NDX (rel
->r_offset
)] = -1;
7250 if (NO_OPD_RELOCS
|| bfd_link_relocatable (info
))
7255 if (!dec_dynrel_count (rel
->r_info
, sec
, info
,
7259 if (++rel
== next_rel
)
7262 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7263 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
7270 /* We'll be keeping this opd entry. */
7275 /* Redefine the function descriptor symbol to
7276 this location in the opd section. It is
7277 necessary to update the value here rather
7278 than using an array of adjustments as we do
7279 for local symbols, because various places
7280 in the generic ELF code use the value
7281 stored in u.def.value. */
7282 fdh
->elf
.root
.u
.def
.value
= wptr
- new_contents
;
7283 fdh
->adjust_done
= 1;
7286 /* Local syms are a bit tricky. We could
7287 tweak them as they can be cached, but
7288 we'd need to look through the local syms
7289 for the function descriptor sym which we
7290 don't have at the moment. So keep an
7291 array of adjustments. */
7292 adjust
= (wptr
- new_contents
) - (rptr
- sec
->contents
);
7293 opd
->adjust
[OPD_NDX (rel
->r_offset
)] = adjust
;
7296 memcpy (wptr
, rptr
, opd_ent_size
);
7297 wptr
+= opd_ent_size
;
7298 if (add_aux_fields
&& opd_ent_size
== 16)
7300 memset (wptr
, '\0', 8);
7304 /* We need to adjust any reloc offsets to point to the
7306 for ( ; rel
!= next_rel
; ++rel
)
7308 rel
->r_offset
+= adjust
;
7309 if (write_rel
!= rel
)
7310 memcpy (write_rel
, rel
, sizeof (*rel
));
7315 rptr
+= opd_ent_size
;
7318 sec
->size
= wptr
- new_contents
;
7319 sec
->reloc_count
= write_rel
- relstart
;
7322 free (sec
->contents
);
7323 sec
->contents
= new_contents
;
7326 /* Fudge the header size too, as this is used later in
7327 elf_bfd_final_link if we are emitting relocs. */
7328 rel_hdr
= _bfd_elf_single_rel_hdr (sec
);
7329 rel_hdr
->sh_size
= sec
->reloc_count
* rel_hdr
->sh_entsize
;
7332 else if (elf_section_data (sec
)->relocs
!= relstart
)
7335 if (local_syms
!= NULL
7336 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
7338 if (!info
->keep_memory
)
7341 symtab_hdr
->contents
= (unsigned char *) local_syms
;
7346 elf_link_hash_traverse (elf_hash_table (info
), adjust_opd_syms
, NULL
);
7348 /* If we are doing a final link and the last .opd entry is just 16 byte
7349 long, add a 8 byte padding after it. */
7350 if (need_pad
!= NULL
&& !bfd_link_relocatable (info
))
7354 if ((need_pad
->flags
& SEC_IN_MEMORY
) == 0)
7356 BFD_ASSERT (need_pad
->size
> 0);
7358 p
= bfd_malloc (need_pad
->size
+ 8);
7362 if (!bfd_get_section_contents (need_pad
->owner
, need_pad
,
7363 p
, 0, need_pad
->size
))
7366 need_pad
->contents
= p
;
7367 need_pad
->flags
|= (SEC_IN_MEMORY
| SEC_HAS_CONTENTS
);
7371 p
= bfd_realloc (need_pad
->contents
, need_pad
->size
+ 8);
7375 need_pad
->contents
= p
;
7378 memset (need_pad
->contents
+ need_pad
->size
, 0, 8);
7379 need_pad
->size
+= 8;
7385 /* Analyze inline PLT call relocations to see whether calls to locally
7386 defined functions can be converted to direct calls. */
7389 ppc64_elf_inline_plt (struct bfd_link_info
*info
)
7391 struct ppc_link_hash_table
*htab
;
7394 bfd_vma low_vma
, high_vma
, limit
;
7396 htab
= ppc_hash_table (info
);
7400 /* A bl insn can reach -0x2000000 to 0x1fffffc. The limit is
7401 reduced somewhat to cater for possible stubs that might be added
7402 between the call and its destination. */
7403 if (htab
->params
->group_size
< 0)
7405 limit
= -htab
->params
->group_size
;
7411 limit
= htab
->params
->group_size
;
7418 for (sec
= info
->output_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7419 if ((sec
->flags
& (SEC_ALLOC
| SEC_CODE
)) == (SEC_ALLOC
| SEC_CODE
))
7421 if (low_vma
> sec
->vma
)
7423 if (high_vma
< sec
->vma
+ sec
->size
)
7424 high_vma
= sec
->vma
+ sec
->size
;
7427 /* If a "bl" can reach anywhere in local code sections, then we can
7428 convert all inline PLT sequences to direct calls when the symbol
7430 if (high_vma
- low_vma
< limit
)
7432 htab
->can_convert_all_inline_plt
= 1;
7436 /* Otherwise, go looking through relocs for cases where a direct
7437 call won't reach. Mark the symbol on any such reloc to disable
7438 the optimization and keep the PLT entry as it seems likely that
7439 this will be better than creating trampolines. Note that this
7440 will disable the optimization for all inline PLT calls to a
7441 particular symbol, not just those that won't reach. The
7442 difficulty in doing a more precise optimization is that the
7443 linker needs to make a decision depending on whether a
7444 particular R_PPC64_PLTCALL insn can be turned into a direct
7445 call, for each of the R_PPC64_PLTSEQ and R_PPC64_PLT16* insns in
7446 the sequence, and there is nothing that ties those relocs
7447 together except their symbol. */
7449 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
7451 Elf_Internal_Shdr
*symtab_hdr
;
7452 Elf_Internal_Sym
*local_syms
;
7454 if (!is_ppc64_elf (ibfd
))
7458 symtab_hdr
= &elf_symtab_hdr (ibfd
);
7460 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7461 if (ppc64_elf_section_data (sec
)->has_pltcall
7462 && !bfd_is_abs_section (sec
->output_section
))
7464 Elf_Internal_Rela
*relstart
, *rel
, *relend
;
7466 /* Read the relocations. */
7467 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
7469 if (relstart
== NULL
)
7472 relend
= relstart
+ sec
->reloc_count
;
7473 for (rel
= relstart
; rel
< relend
; )
7475 enum elf_ppc64_reloc_type r_type
;
7476 unsigned long r_symndx
;
7478 struct elf_link_hash_entry
*h
;
7479 Elf_Internal_Sym
*sym
;
7480 unsigned char *tls_maskp
;
7482 r_type
= ELF64_R_TYPE (rel
->r_info
);
7483 if (r_type
!= R_PPC64_PLTCALL
7484 && r_type
!= R_PPC64_PLTCALL_NOTOC
)
7487 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7488 if (!get_sym_h (&h
, &sym
, &sym_sec
, &tls_maskp
, &local_syms
,
7491 if (elf_section_data (sec
)->relocs
!= relstart
)
7493 if (local_syms
!= NULL
7494 && symtab_hdr
->contents
!= (bfd_byte
*) local_syms
)
7499 if (sym_sec
!= NULL
&& sym_sec
->output_section
!= NULL
)
7503 to
= h
->root
.u
.def
.value
;
7506 to
+= (rel
->r_addend
7507 + sym_sec
->output_offset
7508 + sym_sec
->output_section
->vma
);
7509 from
= (rel
->r_offset
7510 + sec
->output_offset
7511 + sec
->output_section
->vma
);
7512 if (to
- from
+ limit
< 2 * limit
7513 && !(r_type
== R_PPC64_PLTCALL_NOTOC
7514 && (((h
? h
->other
: sym
->st_other
)
7515 & STO_PPC64_LOCAL_MASK
)
7516 > 1 << STO_PPC64_LOCAL_BIT
)))
7517 *tls_maskp
&= ~PLT_KEEP
;
7520 if (elf_section_data (sec
)->relocs
!= relstart
)
7524 if (local_syms
!= NULL
7525 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
7527 if (!info
->keep_memory
)
7530 symtab_hdr
->contents
= (unsigned char *) local_syms
;
7537 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
7540 ppc64_elf_tls_setup (struct bfd_link_info
*info
)
7542 struct ppc_link_hash_table
*htab
;
7544 htab
= ppc_hash_table (info
);
7548 if (abiversion (info
->output_bfd
) == 1)
7551 if (htab
->params
->no_multi_toc
)
7552 htab
->do_multi_toc
= 0;
7553 else if (!htab
->do_multi_toc
)
7554 htab
->params
->no_multi_toc
= 1;
7556 /* Default to --no-plt-localentry, as this option can cause problems
7557 with symbol interposition. For example, glibc libpthread.so and
7558 libc.so duplicate many pthread symbols, with a fallback
7559 implementation in libc.so. In some cases the fallback does more
7560 work than the pthread implementation. __pthread_condattr_destroy
7561 is one such symbol: the libpthread.so implementation is
7562 localentry:0 while the libc.so implementation is localentry:8.
7563 An app that "cleverly" uses dlopen to only load necessary
7564 libraries at runtime may omit loading libpthread.so when not
7565 running multi-threaded, which then results in the libc.so
7566 fallback symbols being used and ld.so complaining. Now there
7567 are workarounds in ld (see non_zero_localentry) to detect the
7568 pthread situation, but that may not be the only case where
7569 --plt-localentry can cause trouble. */
7570 if (htab
->params
->plt_localentry0
< 0)
7571 htab
->params
->plt_localentry0
= 0;
7572 if (htab
->params
->plt_localentry0
7573 && elf_link_hash_lookup (&htab
->elf
, "GLIBC_2.26",
7574 FALSE
, FALSE
, FALSE
) == NULL
)
7576 (_("warning: --plt-localentry is especially dangerous without "
7577 "ld.so support to detect ABI violations"));
7579 htab
->tls_get_addr
= ((struct ppc_link_hash_entry
*)
7580 elf_link_hash_lookup (&htab
->elf
, ".__tls_get_addr",
7581 FALSE
, FALSE
, TRUE
));
7582 /* Move dynamic linking info to the function descriptor sym. */
7583 if (htab
->tls_get_addr
!= NULL
)
7584 func_desc_adjust (&htab
->tls_get_addr
->elf
, info
);
7585 htab
->tls_get_addr_fd
= ((struct ppc_link_hash_entry
*)
7586 elf_link_hash_lookup (&htab
->elf
, "__tls_get_addr",
7587 FALSE
, FALSE
, TRUE
));
7588 if (htab
->params
->tls_get_addr_opt
)
7590 struct elf_link_hash_entry
*opt
, *opt_fd
, *tga
, *tga_fd
;
7592 opt
= elf_link_hash_lookup (&htab
->elf
, ".__tls_get_addr_opt",
7593 FALSE
, FALSE
, TRUE
);
7595 func_desc_adjust (opt
, info
);
7596 opt_fd
= elf_link_hash_lookup (&htab
->elf
, "__tls_get_addr_opt",
7597 FALSE
, FALSE
, TRUE
);
7599 && (opt_fd
->root
.type
== bfd_link_hash_defined
7600 || opt_fd
->root
.type
== bfd_link_hash_defweak
))
7602 /* If glibc supports an optimized __tls_get_addr call stub,
7603 signalled by the presence of __tls_get_addr_opt, and we'll
7604 be calling __tls_get_addr via a plt call stub, then
7605 make __tls_get_addr point to __tls_get_addr_opt. */
7606 tga_fd
= &htab
->tls_get_addr_fd
->elf
;
7607 if (htab
->elf
.dynamic_sections_created
7609 && (tga_fd
->type
== STT_FUNC
7610 || tga_fd
->needs_plt
)
7611 && !(SYMBOL_CALLS_LOCAL (info
, tga_fd
)
7612 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, tga_fd
)))
7614 struct plt_entry
*ent
;
7616 for (ent
= tga_fd
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
7617 if (ent
->plt
.refcount
> 0)
7621 tga_fd
->root
.type
= bfd_link_hash_indirect
;
7622 tga_fd
->root
.u
.i
.link
= &opt_fd
->root
;
7623 ppc64_elf_copy_indirect_symbol (info
, opt_fd
, tga_fd
);
7625 if (opt_fd
->dynindx
!= -1)
7627 /* Use __tls_get_addr_opt in dynamic relocations. */
7628 opt_fd
->dynindx
= -1;
7629 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
7630 opt_fd
->dynstr_index
);
7631 if (!bfd_elf_link_record_dynamic_symbol (info
, opt_fd
))
7634 htab
->tls_get_addr_fd
7635 = (struct ppc_link_hash_entry
*) opt_fd
;
7636 tga
= &htab
->tls_get_addr
->elf
;
7637 if (opt
!= NULL
&& tga
!= NULL
)
7639 tga
->root
.type
= bfd_link_hash_indirect
;
7640 tga
->root
.u
.i
.link
= &opt
->root
;
7641 ppc64_elf_copy_indirect_symbol (info
, opt
, tga
);
7643 _bfd_elf_link_hash_hide_symbol (info
, opt
,
7645 htab
->tls_get_addr
= (struct ppc_link_hash_entry
*) opt
;
7647 htab
->tls_get_addr_fd
->oh
= htab
->tls_get_addr
;
7648 htab
->tls_get_addr_fd
->is_func_descriptor
= 1;
7649 if (htab
->tls_get_addr
!= NULL
)
7651 htab
->tls_get_addr
->oh
= htab
->tls_get_addr_fd
;
7652 htab
->tls_get_addr
->is_func
= 1;
7657 else if (htab
->params
->tls_get_addr_opt
< 0)
7658 htab
->params
->tls_get_addr_opt
= 0;
7660 return _bfd_elf_tls_setup (info
->output_bfd
, info
);
7663 /* Return TRUE iff REL is a branch reloc with a global symbol matching
7667 branch_reloc_hash_match (const bfd
*ibfd
,
7668 const Elf_Internal_Rela
*rel
,
7669 const struct ppc_link_hash_entry
*hash1
,
7670 const struct ppc_link_hash_entry
*hash2
)
7672 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (ibfd
);
7673 enum elf_ppc64_reloc_type r_type
= ELF64_R_TYPE (rel
->r_info
);
7674 unsigned int r_symndx
= ELF64_R_SYM (rel
->r_info
);
7676 if (r_symndx
>= symtab_hdr
->sh_info
&& is_branch_reloc (r_type
))
7678 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (ibfd
);
7679 struct elf_link_hash_entry
*h
;
7681 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
7682 h
= elf_follow_link (h
);
7683 if (h
== &hash1
->elf
|| h
== &hash2
->elf
)
7689 /* Run through all the TLS relocs looking for optimization
7690 opportunities. The linker has been hacked (see ppc64elf.em) to do
7691 a preliminary section layout so that we know the TLS segment
7692 offsets. We can't optimize earlier because some optimizations need
7693 to know the tp offset, and we need to optimize before allocating
7694 dynamic relocations. */
7697 ppc64_elf_tls_optimize (struct bfd_link_info
*info
)
7701 struct ppc_link_hash_table
*htab
;
7702 unsigned char *toc_ref
;
7705 if (!bfd_link_executable (info
))
7708 htab
= ppc_hash_table (info
);
7712 /* Make two passes over the relocs. On the first pass, mark toc
7713 entries involved with tls relocs, and check that tls relocs
7714 involved in setting up a tls_get_addr call are indeed followed by
7715 such a call. If they are not, we can't do any tls optimization.
7716 On the second pass twiddle tls_mask flags to notify
7717 relocate_section that optimization can be done, and adjust got
7718 and plt refcounts. */
7720 for (pass
= 0; pass
< 2; ++pass
)
7721 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
7723 Elf_Internal_Sym
*locsyms
= NULL
;
7724 asection
*toc
= bfd_get_section_by_name (ibfd
, ".toc");
7726 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7727 if (sec
->has_tls_reloc
&& !bfd_is_abs_section (sec
->output_section
))
7729 Elf_Internal_Rela
*relstart
, *rel
, *relend
;
7730 bfd_boolean found_tls_get_addr_arg
= 0;
7732 /* Read the relocations. */
7733 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
7735 if (relstart
== NULL
)
7741 relend
= relstart
+ sec
->reloc_count
;
7742 for (rel
= relstart
; rel
< relend
; rel
++)
7744 enum elf_ppc64_reloc_type r_type
;
7745 unsigned long r_symndx
;
7746 struct elf_link_hash_entry
*h
;
7747 Elf_Internal_Sym
*sym
;
7749 unsigned char *tls_mask
;
7750 unsigned int tls_set
, tls_clear
, tls_type
= 0;
7752 bfd_boolean ok_tprel
, is_local
;
7753 long toc_ref_index
= 0;
7754 int expecting_tls_get_addr
= 0;
7755 bfd_boolean ret
= FALSE
;
7757 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7758 if (!get_sym_h (&h
, &sym
, &sym_sec
, &tls_mask
, &locsyms
,
7762 if (elf_section_data (sec
)->relocs
!= relstart
)
7764 if (toc_ref
!= NULL
)
7767 && (elf_symtab_hdr (ibfd
).contents
7768 != (unsigned char *) locsyms
))
7775 if (h
->root
.type
== bfd_link_hash_defined
7776 || h
->root
.type
== bfd_link_hash_defweak
)
7777 value
= h
->root
.u
.def
.value
;
7778 else if (h
->root
.type
== bfd_link_hash_undefweak
)
7782 found_tls_get_addr_arg
= 0;
7787 /* Symbols referenced by TLS relocs must be of type
7788 STT_TLS. So no need for .opd local sym adjust. */
7789 value
= sym
->st_value
;
7798 && h
->root
.type
== bfd_link_hash_undefweak
)
7800 else if (sym_sec
!= NULL
7801 && sym_sec
->output_section
!= NULL
)
7803 value
+= sym_sec
->output_offset
;
7804 value
+= sym_sec
->output_section
->vma
;
7805 value
-= htab
->elf
.tls_sec
->vma
+ TP_OFFSET
;
7806 /* Note that even though the prefix insns
7807 allow a 1<<33 offset we use the same test
7808 as for addis;addi. There may be a mix of
7809 pcrel and non-pcrel code and the decision
7810 to optimise is per symbol, not per TLS
7812 ok_tprel
= value
+ 0x80008000ULL
< 1ULL << 32;
7816 r_type
= ELF64_R_TYPE (rel
->r_info
);
7817 /* If this section has old-style __tls_get_addr calls
7818 without marker relocs, then check that each
7819 __tls_get_addr call reloc is preceded by a reloc
7820 that conceivably belongs to the __tls_get_addr arg
7821 setup insn. If we don't find matching arg setup
7822 relocs, don't do any tls optimization. */
7824 && sec
->has_tls_get_addr_call
7826 && (h
== &htab
->tls_get_addr
->elf
7827 || h
== &htab
->tls_get_addr_fd
->elf
)
7828 && !found_tls_get_addr_arg
7829 && is_branch_reloc (r_type
))
7831 info
->callbacks
->minfo (_("%H __tls_get_addr lost arg, "
7832 "TLS optimization disabled\n"),
7833 ibfd
, sec
, rel
->r_offset
);
7838 found_tls_get_addr_arg
= 0;
7841 case R_PPC64_GOT_TLSLD16
:
7842 case R_PPC64_GOT_TLSLD16_LO
:
7843 case R_PPC64_GOT_TLSLD34
:
7844 expecting_tls_get_addr
= 1;
7845 found_tls_get_addr_arg
= 1;
7848 case R_PPC64_GOT_TLSLD16_HI
:
7849 case R_PPC64_GOT_TLSLD16_HA
:
7850 /* These relocs should never be against a symbol
7851 defined in a shared lib. Leave them alone if
7852 that turns out to be the case. */
7859 tls_type
= TLS_TLS
| TLS_LD
;
7862 case R_PPC64_GOT_TLSGD16
:
7863 case R_PPC64_GOT_TLSGD16_LO
:
7864 case R_PPC64_GOT_TLSGD34
:
7865 expecting_tls_get_addr
= 1;
7866 found_tls_get_addr_arg
= 1;
7869 case R_PPC64_GOT_TLSGD16_HI
:
7870 case R_PPC64_GOT_TLSGD16_HA
:
7876 tls_set
= TLS_TLS
| TLS_GDIE
;
7878 tls_type
= TLS_TLS
| TLS_GD
;
7881 case R_PPC64_GOT_TPREL34
:
7882 case R_PPC64_GOT_TPREL16_DS
:
7883 case R_PPC64_GOT_TPREL16_LO_DS
:
7884 case R_PPC64_GOT_TPREL16_HI
:
7885 case R_PPC64_GOT_TPREL16_HA
:
7890 tls_clear
= TLS_TPREL
;
7891 tls_type
= TLS_TLS
| TLS_TPREL
;
7898 if (rel
+ 1 < relend
7899 && is_plt_seq_reloc (ELF64_R_TYPE (rel
[1].r_info
)))
7902 && (ELF64_R_TYPE (rel
[1].r_info
)
7904 && (ELF64_R_TYPE (rel
[1].r_info
)
7905 != R_PPC64_PLTSEQ_NOTOC
))
7907 r_symndx
= ELF64_R_SYM (rel
[1].r_info
);
7908 if (!get_sym_h (&h
, NULL
, NULL
, NULL
, &locsyms
,
7913 struct plt_entry
*ent
= NULL
;
7915 for (ent
= h
->plt
.plist
;
7918 if (ent
->addend
== rel
[1].r_addend
)
7922 && ent
->plt
.refcount
> 0)
7923 ent
->plt
.refcount
-= 1;
7928 found_tls_get_addr_arg
= 1;
7933 case R_PPC64_TOC16_LO
:
7934 if (sym_sec
== NULL
|| sym_sec
!= toc
)
7937 /* Mark this toc entry as referenced by a TLS
7938 code sequence. We can do that now in the
7939 case of R_PPC64_TLS, and after checking for
7940 tls_get_addr for the TOC16 relocs. */
7941 if (toc_ref
== NULL
)
7943 = bfd_zmalloc (toc
->output_section
->rawsize
/ 8);
7944 if (toc_ref
== NULL
)
7948 value
= h
->root
.u
.def
.value
;
7950 value
= sym
->st_value
;
7951 value
+= rel
->r_addend
;
7954 BFD_ASSERT (value
< toc
->size
7955 && toc
->output_offset
% 8 == 0);
7956 toc_ref_index
= (value
+ toc
->output_offset
) / 8;
7957 if (r_type
== R_PPC64_TLS
7958 || r_type
== R_PPC64_TLSGD
7959 || r_type
== R_PPC64_TLSLD
)
7961 toc_ref
[toc_ref_index
] = 1;
7965 if (pass
!= 0 && toc_ref
[toc_ref_index
] == 0)
7970 expecting_tls_get_addr
= 2;
7973 case R_PPC64_TPREL64
:
7977 || !toc_ref
[(rel
->r_offset
+ toc
->output_offset
) / 8])
7982 tls_set
= TLS_EXPLICIT
;
7983 tls_clear
= TLS_TPREL
;
7988 case R_PPC64_DTPMOD64
:
7992 || !toc_ref
[(rel
->r_offset
+ toc
->output_offset
) / 8])
7994 if (rel
+ 1 < relend
7996 == ELF64_R_INFO (r_symndx
, R_PPC64_DTPREL64
))
7997 && rel
[1].r_offset
== rel
->r_offset
+ 8)
8001 tls_set
= TLS_EXPLICIT
| TLS_GD
;
8004 tls_set
= TLS_EXPLICIT
| TLS_GD
| TLS_GDIE
;
8013 tls_set
= TLS_EXPLICIT
;
8024 if (!expecting_tls_get_addr
8025 || !sec
->has_tls_get_addr_call
)
8028 if (rel
+ 1 < relend
8029 && branch_reloc_hash_match (ibfd
, rel
+ 1,
8031 htab
->tls_get_addr_fd
))
8033 if (expecting_tls_get_addr
== 2)
8035 /* Check for toc tls entries. */
8036 unsigned char *toc_tls
;
8039 retval
= get_tls_mask (&toc_tls
, NULL
, NULL
,
8044 if (toc_tls
!= NULL
)
8046 if ((*toc_tls
& TLS_TLS
) != 0
8047 && ((*toc_tls
& (TLS_GD
| TLS_LD
)) != 0))
8048 found_tls_get_addr_arg
= 1;
8050 toc_ref
[toc_ref_index
] = 1;
8056 /* Uh oh, we didn't find the expected call. We
8057 could just mark this symbol to exclude it
8058 from tls optimization but it's safer to skip
8059 the entire optimization. */
8060 /* xgettext:c-format */
8061 info
->callbacks
->minfo (_("%H arg lost __tls_get_addr, "
8062 "TLS optimization disabled\n"),
8063 ibfd
, sec
, rel
->r_offset
);
8068 /* If we don't have old-style __tls_get_addr calls
8069 without TLSGD/TLSLD marker relocs, and we haven't
8070 found a new-style __tls_get_addr call with a
8071 marker for this symbol, then we either have a
8072 broken object file or an -mlongcall style
8073 indirect call to __tls_get_addr without a marker.
8074 Disable optimization in this case. */
8075 if ((tls_clear
& (TLS_GD
| TLS_LD
)) != 0
8076 && (tls_set
& TLS_EXPLICIT
) == 0
8077 && !sec
->has_tls_get_addr_call
8078 && ((*tls_mask
& (TLS_TLS
| TLS_MARK
))
8079 != (TLS_TLS
| TLS_MARK
)))
8082 if (expecting_tls_get_addr
)
8084 struct plt_entry
*ent
= NULL
;
8086 if (htab
->tls_get_addr
!= NULL
)
8087 for (ent
= htab
->tls_get_addr
->elf
.plt
.plist
;
8090 if (ent
->addend
== 0)
8093 if (ent
== NULL
&& htab
->tls_get_addr_fd
!= NULL
)
8094 for (ent
= htab
->tls_get_addr_fd
->elf
.plt
.plist
;
8097 if (ent
->addend
== 0)
8101 && ent
->plt
.refcount
> 0)
8102 ent
->plt
.refcount
-= 1;
8108 if ((tls_set
& TLS_EXPLICIT
) == 0)
8110 struct got_entry
*ent
;
8112 /* Adjust got entry for this reloc. */
8116 ent
= elf_local_got_ents (ibfd
)[r_symndx
];
8118 for (; ent
!= NULL
; ent
= ent
->next
)
8119 if (ent
->addend
== rel
->r_addend
8120 && ent
->owner
== ibfd
8121 && ent
->tls_type
== tls_type
)
8128 /* We managed to get rid of a got entry. */
8129 if (ent
->got
.refcount
> 0)
8130 ent
->got
.refcount
-= 1;
8135 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8136 we'll lose one or two dyn relocs. */
8137 if (!dec_dynrel_count (rel
->r_info
, sec
, info
,
8141 if (tls_set
== (TLS_EXPLICIT
| TLS_GD
))
8143 if (!dec_dynrel_count ((rel
+ 1)->r_info
, sec
, info
,
8149 *tls_mask
|= tls_set
& 0xff;
8150 *tls_mask
&= ~tls_clear
;
8153 if (elf_section_data (sec
)->relocs
!= relstart
)
8158 && (elf_symtab_hdr (ibfd
).contents
!= (unsigned char *) locsyms
))
8160 if (!info
->keep_memory
)
8163 elf_symtab_hdr (ibfd
).contents
= (unsigned char *) locsyms
;
8167 if (toc_ref
!= NULL
)
8169 htab
->do_tls_opt
= 1;
8173 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8174 the values of any global symbols in a toc section that has been
8175 edited. Globals in toc sections should be a rarity, so this function
8176 sets a flag if any are found in toc sections other than the one just
8177 edited, so that further hash table traversals can be avoided. */
8179 struct adjust_toc_info
8182 unsigned long *skip
;
8183 bfd_boolean global_toc_syms
;
8186 enum toc_skip_enum
{ ref_from_discarded
= 1, can_optimize
= 2 };
8189 adjust_toc_syms (struct elf_link_hash_entry
*h
, void *inf
)
8191 struct ppc_link_hash_entry
*eh
;
8192 struct adjust_toc_info
*toc_inf
= (struct adjust_toc_info
*) inf
;
8195 if (h
->root
.type
!= bfd_link_hash_defined
8196 && h
->root
.type
!= bfd_link_hash_defweak
)
8199 eh
= (struct ppc_link_hash_entry
*) h
;
8200 if (eh
->adjust_done
)
8203 if (eh
->elf
.root
.u
.def
.section
== toc_inf
->toc
)
8205 if (eh
->elf
.root
.u
.def
.value
> toc_inf
->toc
->rawsize
)
8206 i
= toc_inf
->toc
->rawsize
>> 3;
8208 i
= eh
->elf
.root
.u
.def
.value
>> 3;
8210 if ((toc_inf
->skip
[i
] & (ref_from_discarded
| can_optimize
)) != 0)
8213 (_("%s defined on removed toc entry"), eh
->elf
.root
.root
.string
);
8216 while ((toc_inf
->skip
[i
] & (ref_from_discarded
| can_optimize
)) != 0);
8217 eh
->elf
.root
.u
.def
.value
= (bfd_vma
) i
<< 3;
8220 eh
->elf
.root
.u
.def
.value
-= toc_inf
->skip
[i
];
8221 eh
->adjust_done
= 1;
8223 else if (strcmp (eh
->elf
.root
.u
.def
.section
->name
, ".toc") == 0)
8224 toc_inf
->global_toc_syms
= TRUE
;
8229 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
8230 on a _LO variety toc/got reloc. */
8233 ok_lo_toc_insn (unsigned int insn
, enum elf_ppc64_reloc_type r_type
)
8235 return ((insn
& (0x3f << 26)) == 12u << 26 /* addic */
8236 || (insn
& (0x3f << 26)) == 14u << 26 /* addi */
8237 || (insn
& (0x3f << 26)) == 32u << 26 /* lwz */
8238 || (insn
& (0x3f << 26)) == 34u << 26 /* lbz */
8239 || (insn
& (0x3f << 26)) == 36u << 26 /* stw */
8240 || (insn
& (0x3f << 26)) == 38u << 26 /* stb */
8241 || (insn
& (0x3f << 26)) == 40u << 26 /* lhz */
8242 || (insn
& (0x3f << 26)) == 42u << 26 /* lha */
8243 || (insn
& (0x3f << 26)) == 44u << 26 /* sth */
8244 || (insn
& (0x3f << 26)) == 46u << 26 /* lmw */
8245 || (insn
& (0x3f << 26)) == 47u << 26 /* stmw */
8246 || (insn
& (0x3f << 26)) == 48u << 26 /* lfs */
8247 || (insn
& (0x3f << 26)) == 50u << 26 /* lfd */
8248 || (insn
& (0x3f << 26)) == 52u << 26 /* stfs */
8249 || (insn
& (0x3f << 26)) == 54u << 26 /* stfd */
8250 || (insn
& (0x3f << 26)) == 56u << 26 /* lq,lfq */
8251 || ((insn
& (0x3f << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
8252 /* Exclude lfqu by testing reloc. If relocs are ever
8253 defined for the reduced D field in psq_lu then those
8254 will need testing too. */
8255 && r_type
!= R_PPC64_TOC16_LO
&& r_type
!= R_PPC64_GOT16_LO
)
8256 || ((insn
& (0x3f << 26)) == 58u << 26 /* ld,lwa */
8258 || (insn
& (0x3f << 26)) == 60u << 26 /* stfq */
8259 || ((insn
& (0x3f << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
8260 /* Exclude stfqu. psq_stu as above for psq_lu. */
8261 && r_type
!= R_PPC64_TOC16_LO
&& r_type
!= R_PPC64_GOT16_LO
)
8262 || ((insn
& (0x3f << 26)) == 62u << 26 /* std,stq */
8263 && (insn
& 1) == 0));
8266 /* PCREL_OPT in one instance flags to the linker that a pair of insns:
8267 pld ra,symbol@got@pcrel
8268 load/store rt,off(ra)
8271 load/store rt,off(ra)
8272 may be translated to
8273 pload/pstore rt,symbol+off@pcrel
8275 This function returns true if the optimization is possible, placing
8276 the prefix insn in *PINSN1, a NOP in *PINSN2 and the offset in *POFF.
8278 On entry to this function, the linker has already determined that
8279 the pld can be replaced with pla: *PINSN1 is that pla insn,
8280 while *PINSN2 is the second instruction. */
8283 xlate_pcrel_opt (uint64_t *pinsn1
, uint64_t *pinsn2
, bfd_signed_vma
*poff
)
8285 uint64_t insn1
= *pinsn1
;
8286 uint64_t insn2
= *pinsn2
;
8289 if ((insn2
& (63ULL << 58)) == 1ULL << 58)
8291 /* Check that regs match. */
8292 if (((insn2
>> 16) & 31) != ((insn1
>> 21) & 31))
8295 /* P8LS or PMLS form, non-pcrel. */
8296 if ((insn2
& (-1ULL << 50) & ~(1ULL << 56)) != (1ULL << 58))
8299 *pinsn1
= (insn2
& ~(31 << 16) & ~0x3ffff0000ffffULL
) | (1ULL << 52);
8301 off
= ((insn2
>> 16) & 0x3ffff0000ULL
) | (insn2
& 0xffff);
8302 *poff
= (off
^ 0x200000000ULL
) - 0x200000000ULL
;
8308 /* Check that regs match. */
8309 if (((insn2
>> 16) & 31) != ((insn1
>> 21) & 31))
8312 switch ((insn2
>> 26) & 63)
8328 /* These are the PMLS cases, where we just need to tack a prefix
8330 insn1
= ((1ULL << 58) | (2ULL << 56) | (1ULL << 52)
8331 | (insn2
& ((63ULL << 26) | (31ULL << 21))));
8332 off
= insn2
& 0xffff;
8335 case 58: /* lwa, ld */
8336 if ((insn2
& 1) != 0)
8338 insn1
= ((1ULL << 58) | (1ULL << 52)
8339 | (insn2
& 2 ? 41ULL << 26 : 57ULL << 26)
8340 | (insn2
& (31ULL << 21)));
8341 off
= insn2
& 0xfffc;
8344 case 57: /* lxsd, lxssp */
8345 if ((insn2
& 3) < 2)
8347 insn1
= ((1ULL << 58) | (1ULL << 52)
8348 | ((40ULL | (insn2
& 3)) << 26)
8349 | (insn2
& (31ULL << 21)));
8350 off
= insn2
& 0xfffc;
8353 case 61: /* stxsd, stxssp, lxv, stxv */
8354 if ((insn2
& 3) == 0)
8356 else if ((insn2
& 3) >= 2)
8358 insn1
= ((1ULL << 58) | (1ULL << 52)
8359 | ((44ULL | (insn2
& 3)) << 26)
8360 | (insn2
& (31ULL << 21)));
8361 off
= insn2
& 0xfffc;
8365 insn1
= ((1ULL << 58) | (1ULL << 52)
8366 | ((50ULL | (insn2
& 4) | ((insn2
& 8) >> 3)) << 26)
8367 | (insn2
& (31ULL << 21)));
8368 off
= insn2
& 0xfff0;
8373 insn1
= ((1ULL << 58) | (1ULL << 52)
8374 | (insn2
& ((63ULL << 26) | (31ULL << 21))));
8375 off
= insn2
& 0xffff;
8378 case 62: /* std, stq */
8379 if ((insn2
& 1) != 0)
8381 insn1
= ((1ULL << 58) | (1ULL << 52)
8382 | ((insn2
& 2) == 0 ? 61ULL << 26 : 60ULL << 26)
8383 | (insn2
& (31ULL << 21)));
8384 off
= insn2
& 0xfffc;
8389 *pinsn2
= (uint64_t) NOP
<< 32;
8390 *poff
= (off
^ 0x8000) - 0x8000;
8394 /* Examine all relocs referencing .toc sections in order to remove
8395 unused .toc entries. */
8398 ppc64_elf_edit_toc (struct bfd_link_info
*info
)
8401 struct adjust_toc_info toc_inf
;
8402 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
8404 htab
->do_toc_opt
= 1;
8405 toc_inf
.global_toc_syms
= TRUE
;
8406 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
8408 asection
*toc
, *sec
;
8409 Elf_Internal_Shdr
*symtab_hdr
;
8410 Elf_Internal_Sym
*local_syms
;
8411 Elf_Internal_Rela
*relstart
, *rel
, *toc_relocs
;
8412 unsigned long *skip
, *drop
;
8413 unsigned char *used
;
8414 unsigned char *keep
, last
, some_unused
;
8416 if (!is_ppc64_elf (ibfd
))
8419 toc
= bfd_get_section_by_name (ibfd
, ".toc");
8422 || toc
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
8423 || discarded_section (toc
))
8428 symtab_hdr
= &elf_symtab_hdr (ibfd
);
8430 /* Look at sections dropped from the final link. */
8433 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
8435 if (sec
->reloc_count
== 0
8436 || !discarded_section (sec
)
8437 || get_opd_info (sec
)
8438 || (sec
->flags
& SEC_ALLOC
) == 0
8439 || (sec
->flags
& SEC_DEBUGGING
) != 0)
8442 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
, FALSE
);
8443 if (relstart
== NULL
)
8446 /* Run through the relocs to see which toc entries might be
8448 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
8450 enum elf_ppc64_reloc_type r_type
;
8451 unsigned long r_symndx
;
8453 struct elf_link_hash_entry
*h
;
8454 Elf_Internal_Sym
*sym
;
8457 r_type
= ELF64_R_TYPE (rel
->r_info
);
8464 case R_PPC64_TOC16_LO
:
8465 case R_PPC64_TOC16_HI
:
8466 case R_PPC64_TOC16_HA
:
8467 case R_PPC64_TOC16_DS
:
8468 case R_PPC64_TOC16_LO_DS
:
8472 r_symndx
= ELF64_R_SYM (rel
->r_info
);
8473 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
8481 val
= h
->root
.u
.def
.value
;
8483 val
= sym
->st_value
;
8484 val
+= rel
->r_addend
;
8486 if (val
>= toc
->size
)
8489 /* Anything in the toc ought to be aligned to 8 bytes.
8490 If not, don't mark as unused. */
8496 skip
= bfd_zmalloc (sizeof (*skip
) * (toc
->size
+ 15) / 8);
8501 skip
[val
>> 3] = ref_from_discarded
;
8504 if (elf_section_data (sec
)->relocs
!= relstart
)
8508 /* For largetoc loads of address constants, we can convert
8509 . addis rx,2,addr@got@ha
8510 . ld ry,addr@got@l(rx)
8512 . addis rx,2,addr@toc@ha
8513 . addi ry,rx,addr@toc@l
8514 when addr is within 2G of the toc pointer. This then means
8515 that the word storing "addr" in the toc is no longer needed. */
8517 if (!ppc64_elf_tdata (ibfd
)->has_small_toc_reloc
8518 && toc
->output_section
->rawsize
< (bfd_vma
) 1 << 31
8519 && toc
->reloc_count
!= 0)
8521 /* Read toc relocs. */
8522 toc_relocs
= _bfd_elf_link_read_relocs (ibfd
, toc
, NULL
, NULL
,
8524 if (toc_relocs
== NULL
)
8527 for (rel
= toc_relocs
; rel
< toc_relocs
+ toc
->reloc_count
; ++rel
)
8529 enum elf_ppc64_reloc_type r_type
;
8530 unsigned long r_symndx
;
8532 struct elf_link_hash_entry
*h
;
8533 Elf_Internal_Sym
*sym
;
8536 r_type
= ELF64_R_TYPE (rel
->r_info
);
8537 if (r_type
!= R_PPC64_ADDR64
)
8540 r_symndx
= ELF64_R_SYM (rel
->r_info
);
8541 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
8546 || sym_sec
->output_section
== NULL
8547 || discarded_section (sym_sec
))
8550 if (!SYMBOL_REFERENCES_LOCAL (info
, h
))
8555 if (h
->type
== STT_GNU_IFUNC
)
8557 val
= h
->root
.u
.def
.value
;
8561 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
8563 val
= sym
->st_value
;
8565 val
+= rel
->r_addend
;
8566 val
+= sym_sec
->output_section
->vma
+ sym_sec
->output_offset
;
8568 /* We don't yet know the exact toc pointer value, but we
8569 know it will be somewhere in the toc section. Don't
8570 optimize if the difference from any possible toc
8571 pointer is outside [ff..f80008000, 7fff7fff]. */
8572 addr
= toc
->output_section
->vma
+ TOC_BASE_OFF
;
8573 if (val
- addr
+ (bfd_vma
) 0x80008000 >= (bfd_vma
) 1 << 32)
8576 addr
= toc
->output_section
->vma
+ toc
->output_section
->rawsize
;
8577 if (val
- addr
+ (bfd_vma
) 0x80008000 >= (bfd_vma
) 1 << 32)
8582 skip
= bfd_zmalloc (sizeof (*skip
) * (toc
->size
+ 15) / 8);
8587 skip
[rel
->r_offset
>> 3]
8588 |= can_optimize
| ((rel
- toc_relocs
) << 2);
8595 used
= bfd_zmalloc (sizeof (*used
) * (toc
->size
+ 7) / 8);
8599 if (local_syms
!= NULL
8600 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
8604 && elf_section_data (sec
)->relocs
!= relstart
)
8606 if (toc_relocs
!= NULL
8607 && elf_section_data (toc
)->relocs
!= toc_relocs
)
8614 /* Now check all kept sections that might reference the toc.
8615 Check the toc itself last. */
8616 for (sec
= (ibfd
->sections
== toc
&& toc
->next
? toc
->next
8619 sec
= (sec
== toc
? NULL
8620 : sec
->next
== NULL
? toc
8621 : sec
->next
== toc
&& toc
->next
? toc
->next
8626 if (sec
->reloc_count
== 0
8627 || discarded_section (sec
)
8628 || get_opd_info (sec
)
8629 || (sec
->flags
& SEC_ALLOC
) == 0
8630 || (sec
->flags
& SEC_DEBUGGING
) != 0)
8633 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
8635 if (relstart
== NULL
)
8641 /* Mark toc entries referenced as used. */
8645 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
8647 enum elf_ppc64_reloc_type r_type
;
8648 unsigned long r_symndx
;
8650 struct elf_link_hash_entry
*h
;
8651 Elf_Internal_Sym
*sym
;
8654 r_type
= ELF64_R_TYPE (rel
->r_info
);
8658 case R_PPC64_TOC16_LO
:
8659 case R_PPC64_TOC16_HI
:
8660 case R_PPC64_TOC16_HA
:
8661 case R_PPC64_TOC16_DS
:
8662 case R_PPC64_TOC16_LO_DS
:
8663 /* In case we're taking addresses of toc entries. */
8664 case R_PPC64_ADDR64
:
8671 r_symndx
= ELF64_R_SYM (rel
->r_info
);
8672 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
8683 val
= h
->root
.u
.def
.value
;
8685 val
= sym
->st_value
;
8686 val
+= rel
->r_addend
;
8688 if (val
>= toc
->size
)
8691 if ((skip
[val
>> 3] & can_optimize
) != 0)
8698 case R_PPC64_TOC16_HA
:
8701 case R_PPC64_TOC16_LO_DS
:
8702 off
= rel
->r_offset
;
8703 off
+= (bfd_big_endian (ibfd
) ? -2 : 3);
8704 if (!bfd_get_section_contents (ibfd
, sec
, &opc
,
8710 if ((opc
& (0x3f << 2)) == (58u << 2))
8715 /* Wrong sort of reloc, or not a ld. We may
8716 as well clear ref_from_discarded too. */
8723 /* For the toc section, we only mark as used if this
8724 entry itself isn't unused. */
8725 else if ((used
[rel
->r_offset
>> 3]
8726 || !(skip
[rel
->r_offset
>> 3] & ref_from_discarded
))
8729 /* Do all the relocs again, to catch reference
8738 if (elf_section_data (sec
)->relocs
!= relstart
)
8742 /* Merge the used and skip arrays. Assume that TOC
8743 doublewords not appearing as either used or unused belong
8744 to an entry more than one doubleword in size. */
8745 for (drop
= skip
, keep
= used
, last
= 0, some_unused
= 0;
8746 drop
< skip
+ (toc
->size
+ 7) / 8;
8751 *drop
&= ~ref_from_discarded
;
8752 if ((*drop
& can_optimize
) != 0)
8756 else if ((*drop
& ref_from_discarded
) != 0)
8759 last
= ref_from_discarded
;
8769 bfd_byte
*contents
, *src
;
8771 Elf_Internal_Sym
*sym
;
8772 bfd_boolean local_toc_syms
= FALSE
;
8774 /* Shuffle the toc contents, and at the same time convert the
8775 skip array from booleans into offsets. */
8776 if (!bfd_malloc_and_get_section (ibfd
, toc
, &contents
))
8779 elf_section_data (toc
)->this_hdr
.contents
= contents
;
8781 for (src
= contents
, off
= 0, drop
= skip
;
8782 src
< contents
+ toc
->size
;
8785 if ((*drop
& (can_optimize
| ref_from_discarded
)) != 0)
8790 memcpy (src
- off
, src
, 8);
8794 toc
->rawsize
= toc
->size
;
8795 toc
->size
= src
- contents
- off
;
8797 /* Adjust addends for relocs against the toc section sym,
8798 and optimize any accesses we can. */
8799 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
8801 if (sec
->reloc_count
== 0
8802 || discarded_section (sec
))
8805 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
8807 if (relstart
== NULL
)
8810 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
8812 enum elf_ppc64_reloc_type r_type
;
8813 unsigned long r_symndx
;
8815 struct elf_link_hash_entry
*h
;
8818 r_type
= ELF64_R_TYPE (rel
->r_info
);
8825 case R_PPC64_TOC16_LO
:
8826 case R_PPC64_TOC16_HI
:
8827 case R_PPC64_TOC16_HA
:
8828 case R_PPC64_TOC16_DS
:
8829 case R_PPC64_TOC16_LO_DS
:
8830 case R_PPC64_ADDR64
:
8834 r_symndx
= ELF64_R_SYM (rel
->r_info
);
8835 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
8843 val
= h
->root
.u
.def
.value
;
8846 val
= sym
->st_value
;
8848 local_toc_syms
= TRUE
;
8851 val
+= rel
->r_addend
;
8853 if (val
> toc
->rawsize
)
8855 else if ((skip
[val
>> 3] & ref_from_discarded
) != 0)
8857 else if ((skip
[val
>> 3] & can_optimize
) != 0)
8859 Elf_Internal_Rela
*tocrel
8860 = toc_relocs
+ (skip
[val
>> 3] >> 2);
8861 unsigned long tsym
= ELF64_R_SYM (tocrel
->r_info
);
8865 case R_PPC64_TOC16_HA
:
8866 rel
->r_info
= ELF64_R_INFO (tsym
, R_PPC64_TOC16_HA
);
8869 case R_PPC64_TOC16_LO_DS
:
8870 rel
->r_info
= ELF64_R_INFO (tsym
, R_PPC64_LO_DS_OPT
);
8874 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
8876 info
->callbacks
->einfo
8877 /* xgettext:c-format */
8878 (_("%H: %s references "
8879 "optimized away TOC entry\n"),
8880 ibfd
, sec
, rel
->r_offset
,
8881 ppc64_elf_howto_table
[r_type
]->name
);
8882 bfd_set_error (bfd_error_bad_value
);
8885 rel
->r_addend
= tocrel
->r_addend
;
8886 elf_section_data (sec
)->relocs
= relstart
;
8890 if (h
!= NULL
|| sym
->st_value
!= 0)
8893 rel
->r_addend
-= skip
[val
>> 3];
8894 elf_section_data (sec
)->relocs
= relstart
;
8897 if (elf_section_data (sec
)->relocs
!= relstart
)
8901 /* We shouldn't have local or global symbols defined in the TOC,
8902 but handle them anyway. */
8903 if (local_syms
!= NULL
)
8904 for (sym
= local_syms
;
8905 sym
< local_syms
+ symtab_hdr
->sh_info
;
8907 if (sym
->st_value
!= 0
8908 && bfd_section_from_elf_index (ibfd
, sym
->st_shndx
) == toc
)
8912 if (sym
->st_value
> toc
->rawsize
)
8913 i
= toc
->rawsize
>> 3;
8915 i
= sym
->st_value
>> 3;
8917 if ((skip
[i
] & (ref_from_discarded
| can_optimize
)) != 0)
8921 (_("%s defined on removed toc entry"),
8922 bfd_elf_sym_name (ibfd
, symtab_hdr
, sym
, NULL
));
8925 while ((skip
[i
] & (ref_from_discarded
| can_optimize
)));
8926 sym
->st_value
= (bfd_vma
) i
<< 3;
8929 sym
->st_value
-= skip
[i
];
8930 symtab_hdr
->contents
= (unsigned char *) local_syms
;
8933 /* Adjust any global syms defined in this toc input section. */
8934 if (toc_inf
.global_toc_syms
)
8937 toc_inf
.skip
= skip
;
8938 toc_inf
.global_toc_syms
= FALSE
;
8939 elf_link_hash_traverse (elf_hash_table (info
), adjust_toc_syms
,
8943 if (toc
->reloc_count
!= 0)
8945 Elf_Internal_Shdr
*rel_hdr
;
8946 Elf_Internal_Rela
*wrel
;
8949 /* Remove unused toc relocs, and adjust those we keep. */
8950 if (toc_relocs
== NULL
)
8951 toc_relocs
= _bfd_elf_link_read_relocs (ibfd
, toc
, NULL
, NULL
,
8953 if (toc_relocs
== NULL
)
8957 for (rel
= toc_relocs
; rel
< toc_relocs
+ toc
->reloc_count
; ++rel
)
8958 if ((skip
[rel
->r_offset
>> 3]
8959 & (ref_from_discarded
| can_optimize
)) == 0)
8961 wrel
->r_offset
= rel
->r_offset
- skip
[rel
->r_offset
>> 3];
8962 wrel
->r_info
= rel
->r_info
;
8963 wrel
->r_addend
= rel
->r_addend
;
8966 else if (!dec_dynrel_count (rel
->r_info
, toc
, info
,
8967 &local_syms
, NULL
, NULL
))
8970 elf_section_data (toc
)->relocs
= toc_relocs
;
8971 toc
->reloc_count
= wrel
- toc_relocs
;
8972 rel_hdr
= _bfd_elf_single_rel_hdr (toc
);
8973 sz
= rel_hdr
->sh_entsize
;
8974 rel_hdr
->sh_size
= toc
->reloc_count
* sz
;
8977 else if (toc_relocs
!= NULL
8978 && elf_section_data (toc
)->relocs
!= toc_relocs
)
8981 if (local_syms
!= NULL
8982 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
8984 if (!info
->keep_memory
)
8987 symtab_hdr
->contents
= (unsigned char *) local_syms
;
8992 /* Look for cases where we can change an indirect GOT access to
8993 a GOT relative or PC relative access, possibly reducing the
8994 number of GOT entries. */
8995 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
8998 Elf_Internal_Shdr
*symtab_hdr
;
8999 Elf_Internal_Sym
*local_syms
;
9000 Elf_Internal_Rela
*relstart
, *rel
;
9003 if (!is_ppc64_elf (ibfd
))
9006 if (!ppc64_elf_tdata (ibfd
)->has_optrel
)
9009 sec
= ppc64_elf_tdata (ibfd
)->got
;
9012 got
= sec
->output_section
->vma
+ sec
->output_offset
+ 0x8000;
9015 symtab_hdr
= &elf_symtab_hdr (ibfd
);
9017 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
9019 if (sec
->reloc_count
== 0
9020 || !ppc64_elf_section_data (sec
)->has_optrel
9021 || discarded_section (sec
))
9024 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
9026 if (relstart
== NULL
)
9029 if (local_syms
!= NULL
9030 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
9034 && elf_section_data (sec
)->relocs
!= relstart
)
9039 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
9041 enum elf_ppc64_reloc_type r_type
;
9042 unsigned long r_symndx
;
9043 Elf_Internal_Sym
*sym
;
9045 struct elf_link_hash_entry
*h
;
9046 struct got_entry
*ent
;
9047 bfd_vma sym_addend
, val
, pc
;
9048 unsigned char buf
[8];
9050 enum {no_check
, check_lo
, check_ha
} insn_check
;
9052 r_type
= ELF64_R_TYPE (rel
->r_info
);
9056 insn_check
= no_check
;
9059 case R_PPC64_PLT16_HA
:
9060 case R_PPC64_GOT_TLSLD16_HA
:
9061 case R_PPC64_GOT_TLSGD16_HA
:
9062 case R_PPC64_GOT_TPREL16_HA
:
9063 case R_PPC64_GOT_DTPREL16_HA
:
9064 case R_PPC64_GOT16_HA
:
9065 case R_PPC64_TOC16_HA
:
9066 insn_check
= check_ha
;
9069 case R_PPC64_PLT16_LO
:
9070 case R_PPC64_PLT16_LO_DS
:
9071 case R_PPC64_GOT_TLSLD16_LO
:
9072 case R_PPC64_GOT_TLSGD16_LO
:
9073 case R_PPC64_GOT_TPREL16_LO_DS
:
9074 case R_PPC64_GOT_DTPREL16_LO_DS
:
9075 case R_PPC64_GOT16_LO
:
9076 case R_PPC64_GOT16_LO_DS
:
9077 case R_PPC64_TOC16_LO
:
9078 case R_PPC64_TOC16_LO_DS
:
9079 insn_check
= check_lo
;
9083 if (insn_check
!= no_check
)
9085 bfd_vma off
= rel
->r_offset
& ~3;
9087 if (!bfd_get_section_contents (ibfd
, sec
, buf
, off
, 4))
9090 insn
= bfd_get_32 (ibfd
, buf
);
9091 if (insn_check
== check_lo
9092 ? !ok_lo_toc_insn (insn
, r_type
)
9093 : ((insn
& ((0x3f << 26) | 0x1f << 16))
9094 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9098 ppc64_elf_tdata (ibfd
)->unexpected_toc_insn
= 1;
9099 sprintf (str
, "%#08x", insn
);
9100 info
->callbacks
->einfo
9101 /* xgettext:c-format */
9102 (_("%H: got/toc optimization is not supported for"
9103 " %s instruction\n"),
9104 ibfd
, sec
, rel
->r_offset
& ~3, str
);
9111 /* Note that we don't delete GOT entries for
9112 R_PPC64_GOT16_DS since we'd need a lot more
9113 analysis. For starters, the preliminary layout is
9114 before the GOT, PLT, dynamic sections and stubs are
9115 laid out. Then we'd need to allow for changes in
9116 distance between sections caused by alignment. */
9120 case R_PPC64_GOT16_HA
:
9121 case R_PPC64_GOT16_LO_DS
:
9122 sym_addend
= rel
->r_addend
;
9125 case R_PPC64_GOT_PCREL34
:
9130 r_symndx
= ELF64_R_SYM (rel
->r_info
);
9131 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
9136 || sym_sec
->output_section
== NULL
9137 || discarded_section (sym_sec
))
9140 if (!SYMBOL_REFERENCES_LOCAL (info
, h
))
9144 val
= h
->root
.u
.def
.value
;
9146 val
= sym
->st_value
;
9148 val
+= sym_sec
->output_section
->vma
+ sym_sec
->output_offset
;
9150 /* Fudge factor to allow for the fact that the preliminary layout
9151 isn't exact. Reduce limits by this factor. */
9152 #define LIMIT_ADJUST(LIMIT) ((LIMIT) - (LIMIT) / 16)
9159 case R_PPC64_GOT16_HA
:
9160 if (val
- got
+ LIMIT_ADJUST (0x80008000ULL
)
9161 >= LIMIT_ADJUST (0x100000000ULL
))
9164 if (!bfd_get_section_contents (ibfd
, sec
, buf
,
9165 rel
->r_offset
& ~3, 4))
9167 insn
= bfd_get_32 (ibfd
, buf
);
9168 if (((insn
& ((0x3f << 26) | 0x1f << 16))
9169 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9173 case R_PPC64_GOT16_LO_DS
:
9174 if (val
- got
+ LIMIT_ADJUST (0x80008000ULL
)
9175 >= LIMIT_ADJUST (0x100000000ULL
))
9177 if (!bfd_get_section_contents (ibfd
, sec
, buf
,
9178 rel
->r_offset
& ~3, 4))
9180 insn
= bfd_get_32 (ibfd
, buf
);
9181 if ((insn
& (0x3f << 26 | 0x3)) != 58u << 26 /* ld */)
9185 case R_PPC64_GOT_PCREL34
:
9187 pc
+= sec
->output_section
->vma
+ sec
->output_offset
;
9188 if (val
- pc
+ LIMIT_ADJUST (1ULL << 33)
9189 >= LIMIT_ADJUST (1ULL << 34))
9191 if (!bfd_get_section_contents (ibfd
, sec
, buf
,
9192 rel
->r_offset
& ~3, 8))
9194 insn
= bfd_get_32 (ibfd
, buf
);
9195 if ((insn
& (-1u << 18)) != ((1u << 26) | (1u << 20)))
9197 insn
= bfd_get_32 (ibfd
, buf
+ 4);
9198 if ((insn
& (0x3f << 26)) != 57u << 26)
9208 struct got_entry
**local_got_ents
= elf_local_got_ents (ibfd
);
9209 ent
= local_got_ents
[r_symndx
];
9211 for (; ent
!= NULL
; ent
= ent
->next
)
9212 if (ent
->addend
== sym_addend
9213 && ent
->owner
== ibfd
9214 && ent
->tls_type
== 0)
9216 BFD_ASSERT (ent
&& ent
->got
.refcount
> 0);
9217 ent
->got
.refcount
-= 1;
9220 if (elf_section_data (sec
)->relocs
!= relstart
)
9224 if (local_syms
!= NULL
9225 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
9227 if (!info
->keep_memory
)
9230 symtab_hdr
->contents
= (unsigned char *) local_syms
;
9237 /* Return true iff input section I references the TOC using
9238 instructions limited to +/-32k offsets. */
9241 ppc64_elf_has_small_toc_reloc (asection
*i
)
9243 return (is_ppc64_elf (i
->owner
)
9244 && ppc64_elf_tdata (i
->owner
)->has_small_toc_reloc
);
9247 /* Allocate space for one GOT entry. */
9250 allocate_got (struct elf_link_hash_entry
*h
,
9251 struct bfd_link_info
*info
,
9252 struct got_entry
*gent
)
9254 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
9255 struct ppc_link_hash_entry
*eh
= (struct ppc_link_hash_entry
*) h
;
9256 int entsize
= (gent
->tls_type
& eh
->tls_mask
& (TLS_GD
| TLS_LD
)
9258 int rentsize
= (gent
->tls_type
& eh
->tls_mask
& TLS_GD
9259 ? 2 : 1) * sizeof (Elf64_External_Rela
);
9260 asection
*got
= ppc64_elf_tdata (gent
->owner
)->got
;
9262 gent
->got
.offset
= got
->size
;
9263 got
->size
+= entsize
;
9265 if (h
->type
== STT_GNU_IFUNC
)
9267 htab
->elf
.irelplt
->size
+= rentsize
;
9268 htab
->got_reli_size
+= rentsize
;
9270 else if (((bfd_link_pic (info
)
9271 && !((gent
->tls_type
& TLS_TPREL
) != 0
9272 && bfd_link_executable (info
)
9273 && SYMBOL_REFERENCES_LOCAL (info
, h
)))
9274 || (htab
->elf
.dynamic_sections_created
9276 && !SYMBOL_REFERENCES_LOCAL (info
, h
)))
9277 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
9279 asection
*relgot
= ppc64_elf_tdata (gent
->owner
)->relgot
;
9280 relgot
->size
+= rentsize
;
9284 /* This function merges got entries in the same toc group. */
9287 merge_got_entries (struct got_entry
**pent
)
9289 struct got_entry
*ent
, *ent2
;
9291 for (ent
= *pent
; ent
!= NULL
; ent
= ent
->next
)
9292 if (!ent
->is_indirect
)
9293 for (ent2
= ent
->next
; ent2
!= NULL
; ent2
= ent2
->next
)
9294 if (!ent2
->is_indirect
9295 && ent2
->addend
== ent
->addend
9296 && ent2
->tls_type
== ent
->tls_type
9297 && elf_gp (ent2
->owner
) == elf_gp (ent
->owner
))
9299 ent2
->is_indirect
= TRUE
;
9300 ent2
->got
.ent
= ent
;
9304 /* If H is undefined, make it dynamic if that makes sense. */
9307 ensure_undef_dynamic (struct bfd_link_info
*info
,
9308 struct elf_link_hash_entry
*h
)
9310 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
9312 if (htab
->dynamic_sections_created
9313 && ((info
->dynamic_undefined_weak
!= 0
9314 && h
->root
.type
== bfd_link_hash_undefweak
)
9315 || h
->root
.type
== bfd_link_hash_undefined
)
9318 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
9319 return bfd_elf_link_record_dynamic_symbol (info
, h
);
9323 /* Allocate space in .plt, .got and associated reloc sections for
9327 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
9329 struct bfd_link_info
*info
;
9330 struct ppc_link_hash_table
*htab
;
9332 struct ppc_link_hash_entry
*eh
;
9333 struct got_entry
**pgent
, *gent
;
9335 if (h
->root
.type
== bfd_link_hash_indirect
)
9338 info
= (struct bfd_link_info
*) inf
;
9339 htab
= ppc_hash_table (info
);
9343 eh
= (struct ppc_link_hash_entry
*) h
;
9344 /* Run through the TLS GD got entries first if we're changing them
9346 if ((eh
->tls_mask
& (TLS_TLS
| TLS_GDIE
)) == (TLS_TLS
| TLS_GDIE
))
9347 for (gent
= h
->got
.glist
; gent
!= NULL
; gent
= gent
->next
)
9348 if (gent
->got
.refcount
> 0
9349 && (gent
->tls_type
& TLS_GD
) != 0)
9351 /* This was a GD entry that has been converted to TPREL. If
9352 there happens to be a TPREL entry we can use that one. */
9353 struct got_entry
*ent
;
9354 for (ent
= h
->got
.glist
; ent
!= NULL
; ent
= ent
->next
)
9355 if (ent
->got
.refcount
> 0
9356 && (ent
->tls_type
& TLS_TPREL
) != 0
9357 && ent
->addend
== gent
->addend
9358 && ent
->owner
== gent
->owner
)
9360 gent
->got
.refcount
= 0;
9364 /* If not, then we'll be using our own TPREL entry. */
9365 if (gent
->got
.refcount
!= 0)
9366 gent
->tls_type
= TLS_TLS
| TLS_TPREL
;
9369 /* Remove any list entry that won't generate a word in the GOT before
9370 we call merge_got_entries. Otherwise we risk merging to empty
9372 pgent
= &h
->got
.glist
;
9373 while ((gent
= *pgent
) != NULL
)
9374 if (gent
->got
.refcount
> 0)
9376 if ((gent
->tls_type
& TLS_LD
) != 0
9379 ppc64_tlsld_got (gent
->owner
)->got
.refcount
+= 1;
9380 *pgent
= gent
->next
;
9383 pgent
= &gent
->next
;
9386 *pgent
= gent
->next
;
9388 if (!htab
->do_multi_toc
)
9389 merge_got_entries (&h
->got
.glist
);
9391 for (gent
= h
->got
.glist
; gent
!= NULL
; gent
= gent
->next
)
9392 if (!gent
->is_indirect
)
9394 /* Make sure this symbol is output as a dynamic symbol. */
9395 if (!ensure_undef_dynamic (info
, h
))
9398 if (!is_ppc64_elf (gent
->owner
))
9401 allocate_got (h
, info
, gent
);
9404 /* If no dynamic sections we can't have dynamic relocs, except for
9405 IFUNCs which are handled even in static executables. */
9406 if (!htab
->elf
.dynamic_sections_created
9407 && h
->type
!= STT_GNU_IFUNC
)
9408 eh
->dyn_relocs
= NULL
;
9410 /* Discard relocs on undefined symbols that must be local. */
9411 else if (h
->root
.type
== bfd_link_hash_undefined
9412 && ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
9413 eh
->dyn_relocs
= NULL
;
9415 /* Also discard relocs on undefined weak syms with non-default
9416 visibility, or when dynamic_undefined_weak says so. */
9417 else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
9418 eh
->dyn_relocs
= NULL
;
9420 if (eh
->dyn_relocs
!= NULL
)
9422 struct elf_dyn_relocs
*p
, **pp
;
9424 /* In the shared -Bsymbolic case, discard space allocated for
9425 dynamic pc-relative relocs against symbols which turn out to
9426 be defined in regular objects. For the normal shared case,
9427 discard space for relocs that have become local due to symbol
9428 visibility changes. */
9430 if (bfd_link_pic (info
))
9432 /* Relocs that use pc_count are those that appear on a call
9433 insn, or certain REL relocs (see must_be_dyn_reloc) that
9434 can be generated via assembly. We want calls to
9435 protected symbols to resolve directly to the function
9436 rather than going via the plt. If people want function
9437 pointer comparisons to work as expected then they should
9438 avoid writing weird assembly. */
9439 if (SYMBOL_CALLS_LOCAL (info
, h
))
9441 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
9443 p
->count
-= p
->pc_count
;
9452 if (eh
->dyn_relocs
!= NULL
)
9454 /* Make sure this symbol is output as a dynamic symbol. */
9455 if (!ensure_undef_dynamic (info
, h
))
9459 else if (ELIMINATE_COPY_RELOCS
&& h
->type
!= STT_GNU_IFUNC
)
9461 /* For the non-pic case, discard space for relocs against
9462 symbols which turn out to need copy relocs or are not
9464 if (h
->dynamic_adjusted
9466 && !ELF_COMMON_DEF_P (h
))
9468 /* Make sure this symbol is output as a dynamic symbol. */
9469 if (!ensure_undef_dynamic (info
, h
))
9472 if (h
->dynindx
== -1)
9473 eh
->dyn_relocs
= NULL
;
9476 eh
->dyn_relocs
= NULL
;
9479 /* Finally, allocate space. */
9480 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
9482 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
9483 if (eh
->elf
.type
== STT_GNU_IFUNC
)
9484 sreloc
= htab
->elf
.irelplt
;
9485 sreloc
->size
+= p
->count
* sizeof (Elf64_External_Rela
);
9489 /* We might need a PLT entry when the symbol
9492 c) has plt16 relocs and has been processed by adjust_dynamic_symbol, or
9493 d) has plt16 relocs and we are linking statically. */
9494 if ((htab
->elf
.dynamic_sections_created
&& h
->dynindx
!= -1)
9495 || h
->type
== STT_GNU_IFUNC
9496 || (h
->needs_plt
&& h
->dynamic_adjusted
)
9499 && !htab
->elf
.dynamic_sections_created
9500 && !htab
->can_convert_all_inline_plt
9501 && (((struct ppc_link_hash_entry
*) h
)->tls_mask
9502 & (TLS_TLS
| PLT_KEEP
)) == PLT_KEEP
))
9504 struct plt_entry
*pent
;
9505 bfd_boolean doneone
= FALSE
;
9506 for (pent
= h
->plt
.plist
; pent
!= NULL
; pent
= pent
->next
)
9507 if (pent
->plt
.refcount
> 0)
9509 if (!htab
->elf
.dynamic_sections_created
9510 || h
->dynindx
== -1)
9512 if (h
->type
== STT_GNU_IFUNC
)
9515 pent
->plt
.offset
= s
->size
;
9516 s
->size
+= PLT_ENTRY_SIZE (htab
);
9517 s
= htab
->elf
.irelplt
;
9522 pent
->plt
.offset
= s
->size
;
9523 s
->size
+= LOCAL_PLT_ENTRY_SIZE (htab
);
9524 s
= bfd_link_pic (info
) ? htab
->relpltlocal
: NULL
;
9529 /* If this is the first .plt entry, make room for the special
9533 s
->size
+= PLT_INITIAL_ENTRY_SIZE (htab
);
9535 pent
->plt
.offset
= s
->size
;
9537 /* Make room for this entry. */
9538 s
->size
+= PLT_ENTRY_SIZE (htab
);
9540 /* Make room for the .glink code. */
9543 s
->size
+= GLINK_PLTRESOLVE_SIZE (htab
);
9546 /* We need bigger stubs past index 32767. */
9547 if (s
->size
>= GLINK_PLTRESOLVE_SIZE (htab
) + 32768*2*4)
9554 /* We also need to make an entry in the .rela.plt section. */
9555 s
= htab
->elf
.srelplt
;
9558 s
->size
+= sizeof (Elf64_External_Rela
);
9562 pent
->plt
.offset
= (bfd_vma
) -1;
9565 h
->plt
.plist
= NULL
;
9571 h
->plt
.plist
= NULL
;
9578 #define PPC_LO(v) ((v) & 0xffff)
9579 #define PPC_HI(v) (((v) >> 16) & 0xffff)
9580 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
9582 ((((v) & 0x3ffff0000ULL) << 16) | (v & 0xffff))
9583 #define HA34(v) ((v + (1ULL << 33)) >> 34)
9585 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9586 to set up space for global entry stubs. These are put in glink,
9587 after the branch table. */
9590 size_global_entry_stubs (struct elf_link_hash_entry
*h
, void *inf
)
9592 struct bfd_link_info
*info
;
9593 struct ppc_link_hash_table
*htab
;
9594 struct plt_entry
*pent
;
9597 if (h
->root
.type
== bfd_link_hash_indirect
)
9600 if (!h
->pointer_equality_needed
)
9607 htab
= ppc_hash_table (info
);
9611 s
= htab
->global_entry
;
9612 plt
= htab
->elf
.splt
;
9613 for (pent
= h
->plt
.plist
; pent
!= NULL
; pent
= pent
->next
)
9614 if (pent
->plt
.offset
!= (bfd_vma
) -1
9615 && pent
->addend
== 0)
9617 /* For ELFv2, if this symbol is not defined in a regular file
9618 and we are not generating a shared library or pie, then we
9619 need to define the symbol in the executable on a call stub.
9620 This is to avoid text relocations. */
9621 bfd_vma off
, stub_align
, stub_off
, stub_size
;
9622 unsigned int align_power
;
9626 if (htab
->params
->plt_stub_align
>= 0)
9627 align_power
= htab
->params
->plt_stub_align
;
9629 align_power
= -htab
->params
->plt_stub_align
;
9630 /* Setting section alignment is delayed until we know it is
9631 non-empty. Otherwise the .text output section will be
9632 aligned at least to plt_stub_align even when no global
9633 entry stubs are needed. */
9634 if (s
->alignment_power
< align_power
)
9635 s
->alignment_power
= align_power
;
9636 stub_align
= (bfd_vma
) 1 << align_power
;
9637 if (htab
->params
->plt_stub_align
>= 0
9638 || ((((stub_off
+ stub_size
- 1) & -stub_align
)
9639 - (stub_off
& -stub_align
))
9640 > ((stub_size
- 1) & -stub_align
)))
9641 stub_off
= (stub_off
+ stub_align
- 1) & -stub_align
;
9642 off
= pent
->plt
.offset
+ plt
->output_offset
+ plt
->output_section
->vma
;
9643 off
-= stub_off
+ s
->output_offset
+ s
->output_section
->vma
;
9644 /* Note that for --plt-stub-align negative we have a possible
9645 dependency between stub offset and size. Break that
9646 dependency by assuming the max stub size when calculating
9648 if (PPC_HA (off
) == 0)
9650 h
->root
.type
= bfd_link_hash_defined
;
9651 h
->root
.u
.def
.section
= s
;
9652 h
->root
.u
.def
.value
= stub_off
;
9653 s
->size
= stub_off
+ stub_size
;
9659 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9660 read-only sections. */
9663 maybe_set_textrel (struct elf_link_hash_entry
*h
, void *inf
)
9667 if (h
->root
.type
== bfd_link_hash_indirect
)
9670 sec
= readonly_dynrelocs (h
);
9673 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
9675 info
->flags
|= DF_TEXTREL
;
9676 info
->callbacks
->minfo (_("%pB: dynamic relocation against `%pT'"
9677 " in read-only section `%pA'\n"),
9678 sec
->owner
, h
->root
.root
.string
, sec
);
9680 /* Not an error, just cut short the traversal. */
9686 /* Set the sizes of the dynamic sections. */
9689 ppc64_elf_size_dynamic_sections (bfd
*output_bfd
,
9690 struct bfd_link_info
*info
)
9692 struct ppc_link_hash_table
*htab
;
9697 struct got_entry
*first_tlsld
;
9699 htab
= ppc_hash_table (info
);
9703 dynobj
= htab
->elf
.dynobj
;
9707 if (htab
->elf
.dynamic_sections_created
)
9709 /* Set the contents of the .interp section to the interpreter. */
9710 if (bfd_link_executable (info
) && !info
->nointerp
)
9712 s
= bfd_get_linker_section (dynobj
, ".interp");
9715 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
9716 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
9720 /* Set up .got offsets for local syms, and space for local dynamic
9722 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
9724 struct got_entry
**lgot_ents
;
9725 struct got_entry
**end_lgot_ents
;
9726 struct plt_entry
**local_plt
;
9727 struct plt_entry
**end_local_plt
;
9728 unsigned char *lgot_masks
;
9729 bfd_size_type locsymcount
;
9730 Elf_Internal_Shdr
*symtab_hdr
;
9732 if (!is_ppc64_elf (ibfd
))
9735 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
9737 struct ppc_dyn_relocs
*p
;
9739 for (p
= elf_section_data (s
)->local_dynrel
; p
!= NULL
; p
= p
->next
)
9741 if (!bfd_is_abs_section (p
->sec
)
9742 && bfd_is_abs_section (p
->sec
->output_section
))
9744 /* Input section has been discarded, either because
9745 it is a copy of a linkonce section or due to
9746 linker script /DISCARD/, so we'll be discarding
9749 else if (p
->count
!= 0)
9751 asection
*srel
= elf_section_data (p
->sec
)->sreloc
;
9753 srel
= htab
->elf
.irelplt
;
9754 srel
->size
+= p
->count
* sizeof (Elf64_External_Rela
);
9755 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
9756 info
->flags
|= DF_TEXTREL
;
9761 lgot_ents
= elf_local_got_ents (ibfd
);
9765 symtab_hdr
= &elf_symtab_hdr (ibfd
);
9766 locsymcount
= symtab_hdr
->sh_info
;
9767 end_lgot_ents
= lgot_ents
+ locsymcount
;
9768 local_plt
= (struct plt_entry
**) end_lgot_ents
;
9769 end_local_plt
= local_plt
+ locsymcount
;
9770 lgot_masks
= (unsigned char *) end_local_plt
;
9771 s
= ppc64_elf_tdata (ibfd
)->got
;
9772 for (; lgot_ents
< end_lgot_ents
; ++lgot_ents
, ++lgot_masks
)
9774 struct got_entry
**pent
, *ent
;
9777 while ((ent
= *pent
) != NULL
)
9778 if (ent
->got
.refcount
> 0)
9780 if ((ent
->tls_type
& *lgot_masks
& TLS_LD
) != 0)
9782 ppc64_tlsld_got (ibfd
)->got
.refcount
+= 1;
9787 unsigned int ent_size
= 8;
9788 unsigned int rel_size
= sizeof (Elf64_External_Rela
);
9790 ent
->got
.offset
= s
->size
;
9791 if ((ent
->tls_type
& *lgot_masks
& TLS_GD
) != 0)
9796 s
->size
+= ent_size
;
9797 if ((*lgot_masks
& (TLS_TLS
| PLT_IFUNC
)) == PLT_IFUNC
)
9799 htab
->elf
.irelplt
->size
+= rel_size
;
9800 htab
->got_reli_size
+= rel_size
;
9802 else if (bfd_link_pic (info
)
9803 && !((ent
->tls_type
& TLS_TPREL
) != 0
9804 && bfd_link_executable (info
)))
9806 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
9807 srel
->size
+= rel_size
;
9816 /* Allocate space for plt calls to local syms. */
9817 lgot_masks
= (unsigned char *) end_local_plt
;
9818 for (; local_plt
< end_local_plt
; ++local_plt
, ++lgot_masks
)
9820 struct plt_entry
*ent
;
9822 for (ent
= *local_plt
; ent
!= NULL
; ent
= ent
->next
)
9823 if (ent
->plt
.refcount
> 0)
9825 if ((*lgot_masks
& (TLS_TLS
| PLT_IFUNC
)) == PLT_IFUNC
)
9828 ent
->plt
.offset
= s
->size
;
9829 s
->size
+= PLT_ENTRY_SIZE (htab
);
9830 htab
->elf
.irelplt
->size
+= sizeof (Elf64_External_Rela
);
9832 else if (htab
->can_convert_all_inline_plt
9833 || (*lgot_masks
& (TLS_TLS
| PLT_KEEP
)) != PLT_KEEP
)
9834 ent
->plt
.offset
= (bfd_vma
) -1;
9838 ent
->plt
.offset
= s
->size
;
9839 s
->size
+= LOCAL_PLT_ENTRY_SIZE (htab
);
9840 if (bfd_link_pic (info
))
9841 htab
->relpltlocal
->size
+= sizeof (Elf64_External_Rela
);
9845 ent
->plt
.offset
= (bfd_vma
) -1;
9849 /* Allocate global sym .plt and .got entries, and space for global
9850 sym dynamic relocs. */
9851 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, info
);
9853 if (!htab
->opd_abi
&& !bfd_link_pic (info
))
9854 elf_link_hash_traverse (&htab
->elf
, size_global_entry_stubs
, info
);
9857 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
9859 struct got_entry
*ent
;
9861 if (!is_ppc64_elf (ibfd
))
9864 ent
= ppc64_tlsld_got (ibfd
);
9865 if (ent
->got
.refcount
> 0)
9867 if (!htab
->do_multi_toc
&& first_tlsld
!= NULL
)
9869 ent
->is_indirect
= TRUE
;
9870 ent
->got
.ent
= first_tlsld
;
9874 if (first_tlsld
== NULL
)
9876 s
= ppc64_elf_tdata (ibfd
)->got
;
9877 ent
->got
.offset
= s
->size
;
9880 if (bfd_link_pic (info
))
9882 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
9883 srel
->size
+= sizeof (Elf64_External_Rela
);
9888 ent
->got
.offset
= (bfd_vma
) -1;
9891 /* We now have determined the sizes of the various dynamic sections.
9892 Allocate memory for them. */
9894 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
9896 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
9899 if (s
== htab
->brlt
|| s
== htab
->relbrlt
)
9900 /* These haven't been allocated yet; don't strip. */
9902 else if (s
== htab
->elf
.sgot
9903 || s
== htab
->elf
.splt
9904 || s
== htab
->elf
.iplt
9905 || s
== htab
->pltlocal
9907 || s
== htab
->global_entry
9908 || s
== htab
->elf
.sdynbss
9909 || s
== htab
->elf
.sdynrelro
)
9911 /* Strip this section if we don't need it; see the
9914 else if (s
== htab
->glink_eh_frame
)
9916 if (!bfd_is_abs_section (s
->output_section
))
9917 /* Not sized yet. */
9920 else if (CONST_STRNEQ (s
->name
, ".rela"))
9924 if (s
!= htab
->elf
.srelplt
)
9927 /* We use the reloc_count field as a counter if we need
9928 to copy relocs into the output file. */
9934 /* It's not one of our sections, so don't allocate space. */
9940 /* If we don't need this section, strip it from the
9941 output file. This is mostly to handle .rela.bss and
9942 .rela.plt. We must create both sections in
9943 create_dynamic_sections, because they must be created
9944 before the linker maps input sections to output
9945 sections. The linker does that before
9946 adjust_dynamic_symbol is called, and it is that
9947 function which decides whether anything needs to go
9948 into these sections. */
9949 s
->flags
|= SEC_EXCLUDE
;
9953 if (bfd_is_abs_section (s
->output_section
))
9954 _bfd_error_handler (_("warning: discarding dynamic section %s"),
9957 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
9960 /* Allocate memory for the section contents. We use bfd_zalloc
9961 here in case unused entries are not reclaimed before the
9962 section's contents are written out. This should not happen,
9963 but this way if it does we get a R_PPC64_NONE reloc in .rela
9964 sections instead of garbage.
9965 We also rely on the section contents being zero when writing
9966 the GOT and .dynrelro. */
9967 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
9968 if (s
->contents
== NULL
)
9972 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
9974 if (!is_ppc64_elf (ibfd
))
9977 s
= ppc64_elf_tdata (ibfd
)->got
;
9978 if (s
!= NULL
&& s
!= htab
->elf
.sgot
)
9981 s
->flags
|= SEC_EXCLUDE
;
9984 s
->contents
= bfd_zalloc (ibfd
, s
->size
);
9985 if (s
->contents
== NULL
)
9989 s
= ppc64_elf_tdata (ibfd
)->relgot
;
9993 s
->flags
|= SEC_EXCLUDE
;
9996 s
->contents
= bfd_zalloc (ibfd
, s
->size
);
9997 if (s
->contents
== NULL
)
10000 s
->reloc_count
= 0;
10005 if (htab
->elf
.dynamic_sections_created
)
10007 bfd_boolean tls_opt
;
10009 /* Add some entries to the .dynamic section. We fill in the
10010 values later, in ppc64_elf_finish_dynamic_sections, but we
10011 must add the entries now so that we get the correct size for
10012 the .dynamic section. The DT_DEBUG entry is filled in by the
10013 dynamic linker and used by the debugger. */
10014 #define add_dynamic_entry(TAG, VAL) \
10015 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10017 if (bfd_link_executable (info
))
10019 if (!add_dynamic_entry (DT_DEBUG
, 0))
10023 if (htab
->elf
.splt
!= NULL
&& htab
->elf
.splt
->size
!= 0)
10025 if (!add_dynamic_entry (DT_PLTGOT
, 0)
10026 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
10027 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
10028 || !add_dynamic_entry (DT_JMPREL
, 0)
10029 || !add_dynamic_entry (DT_PPC64_GLINK
, 0))
10033 if (NO_OPD_RELOCS
&& abiversion (output_bfd
) <= 1)
10035 if (!add_dynamic_entry (DT_PPC64_OPD
, 0)
10036 || !add_dynamic_entry (DT_PPC64_OPDSZ
, 0))
10040 tls_opt
= (htab
->params
->tls_get_addr_opt
10041 && htab
->tls_get_addr_fd
!= NULL
10042 && htab
->tls_get_addr_fd
->elf
.plt
.plist
!= NULL
);
10043 if (tls_opt
|| !htab
->opd_abi
)
10045 if (!add_dynamic_entry (DT_PPC64_OPT
, tls_opt
? PPC64_OPT_TLS
: 0))
10051 if (!add_dynamic_entry (DT_RELA
, 0)
10052 || !add_dynamic_entry (DT_RELASZ
, 0)
10053 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf64_External_Rela
)))
10056 /* If any dynamic relocs apply to a read-only section,
10057 then we need a DT_TEXTREL entry. */
10058 if ((info
->flags
& DF_TEXTREL
) == 0)
10059 elf_link_hash_traverse (&htab
->elf
, maybe_set_textrel
, info
);
10061 if ((info
->flags
& DF_TEXTREL
) != 0)
10063 if (!add_dynamic_entry (DT_TEXTREL
, 0))
10068 #undef add_dynamic_entry
10073 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
10076 ppc64_elf_hash_symbol (struct elf_link_hash_entry
*h
)
10078 if (h
->plt
.plist
!= NULL
10080 && !h
->pointer_equality_needed
)
10083 return _bfd_elf_hash_symbol (h
);
10086 /* Determine the type of stub needed, if any, for a call. */
10088 static inline enum ppc_stub_type
10089 ppc_type_of_stub (asection
*input_sec
,
10090 const Elf_Internal_Rela
*rel
,
10091 struct ppc_link_hash_entry
**hash
,
10092 struct plt_entry
**plt_ent
,
10093 bfd_vma destination
,
10094 unsigned long local_off
)
10096 struct ppc_link_hash_entry
*h
= *hash
;
10098 bfd_vma branch_offset
;
10099 bfd_vma max_branch_offset
;
10100 enum elf_ppc64_reloc_type r_type
;
10104 struct plt_entry
*ent
;
10105 struct ppc_link_hash_entry
*fdh
= h
;
10107 && h
->oh
->is_func_descriptor
)
10109 fdh
= ppc_follow_link (h
->oh
);
10113 for (ent
= fdh
->elf
.plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
10114 if (ent
->addend
== rel
->r_addend
10115 && ent
->plt
.offset
!= (bfd_vma
) -1)
10118 return ppc_stub_plt_call
;
10121 /* Here, we know we don't have a plt entry. If we don't have a
10122 either a defined function descriptor or a defined entry symbol
10123 in a regular object file, then it is pointless trying to make
10124 any other type of stub. */
10125 if (!is_static_defined (&fdh
->elf
)
10126 && !is_static_defined (&h
->elf
))
10127 return ppc_stub_none
;
10129 else if (elf_local_got_ents (input_sec
->owner
) != NULL
)
10131 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (input_sec
->owner
);
10132 struct plt_entry
**local_plt
= (struct plt_entry
**)
10133 elf_local_got_ents (input_sec
->owner
) + symtab_hdr
->sh_info
;
10134 unsigned long r_symndx
= ELF64_R_SYM (rel
->r_info
);
10136 if (local_plt
[r_symndx
] != NULL
)
10138 struct plt_entry
*ent
;
10140 for (ent
= local_plt
[r_symndx
]; ent
!= NULL
; ent
= ent
->next
)
10141 if (ent
->addend
== rel
->r_addend
10142 && ent
->plt
.offset
!= (bfd_vma
) -1)
10145 return ppc_stub_plt_call
;
10150 /* Determine where the call point is. */
10151 location
= (input_sec
->output_offset
10152 + input_sec
->output_section
->vma
10155 branch_offset
= destination
- location
;
10156 r_type
= ELF64_R_TYPE (rel
->r_info
);
10158 /* Determine if a long branch stub is needed. */
10159 max_branch_offset
= 1 << 25;
10160 if (r_type
== R_PPC64_REL14
10161 || r_type
== R_PPC64_REL14_BRTAKEN
10162 || r_type
== R_PPC64_REL14_BRNTAKEN
)
10163 max_branch_offset
= 1 << 15;
10165 if (branch_offset
+ max_branch_offset
>= 2 * max_branch_offset
- local_off
)
10166 /* We need a stub. Figure out whether a long_branch or plt_branch
10167 is needed later. */
10168 return ppc_stub_long_branch
;
10170 return ppc_stub_none
;
10173 /* Gets the address of a label (1:) in r11 and builds an offset in r12,
10174 then adds it to r11 (LOAD false) or loads r12 from r11+r12 (LOAD true).
10179 . lis %r12,xxx-1b@highest
10180 . ori %r12,%r12,xxx-1b@higher
10181 . sldi %r12,%r12,32
10182 . oris %r12,%r12,xxx-1b@high
10183 . ori %r12,%r12,xxx-1b@l
10184 . add/ldx %r12,%r11,%r12 */
10187 build_offset (bfd
*abfd
, bfd_byte
*p
, bfd_vma off
, bfd_boolean load
)
10189 bfd_put_32 (abfd
, MFLR_R12
, p
);
10191 bfd_put_32 (abfd
, BCL_20_31
, p
);
10193 bfd_put_32 (abfd
, MFLR_R11
, p
);
10195 bfd_put_32 (abfd
, MTLR_R12
, p
);
10197 if (off
+ 0x8000 < 0x10000)
10200 bfd_put_32 (abfd
, LD_R12_0R11
+ PPC_LO (off
), p
);
10202 bfd_put_32 (abfd
, ADDI_R12_R11
+ PPC_LO (off
), p
);
10205 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10207 bfd_put_32 (abfd
, ADDIS_R12_R11
+ PPC_HA (off
), p
);
10210 bfd_put_32 (abfd
, LD_R12_0R12
+ PPC_LO (off
), p
);
10212 bfd_put_32 (abfd
, ADDI_R12_R12
+ PPC_LO (off
), p
);
10217 if (off
+ 0x800000000000ULL
< 0x1000000000000ULL
)
10219 bfd_put_32 (abfd
, LI_R12_0
+ ((off
>> 32) & 0xffff), p
);
10224 bfd_put_32 (abfd
, LIS_R12
+ ((off
>> 48) & 0xffff), p
);
10226 if (((off
>> 32) & 0xffff) != 0)
10228 bfd_put_32 (abfd
, ORI_R12_R12_0
+ ((off
>> 32) & 0xffff), p
);
10232 if (((off
>> 32) & 0xffffffffULL
) != 0)
10234 bfd_put_32 (abfd
, SLDI_R12_R12_32
, p
);
10237 if (PPC_HI (off
) != 0)
10239 bfd_put_32 (abfd
, ORIS_R12_R12_0
+ PPC_HI (off
), p
);
10242 if (PPC_LO (off
) != 0)
10244 bfd_put_32 (abfd
, ORI_R12_R12_0
+ PPC_LO (off
), p
);
10248 bfd_put_32 (abfd
, LDX_R12_R11_R12
, p
);
10250 bfd_put_32 (abfd
, ADD_R12_R11_R12
, p
);
10256 static unsigned int
10257 size_offset (bfd_vma off
)
10260 if (off
+ 0x8000 < 0x10000)
10262 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10266 if (off
+ 0x800000000000ULL
< 0x1000000000000ULL
)
10271 if (((off
>> 32) & 0xffff) != 0)
10274 if (((off
>> 32) & 0xffffffffULL
) != 0)
10276 if (PPC_HI (off
) != 0)
10278 if (PPC_LO (off
) != 0)
10285 static unsigned int
10286 num_relocs_for_offset (bfd_vma off
)
10288 unsigned int num_rel
;
10289 if (off
+ 0x8000 < 0x10000)
10291 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10296 if (off
+ 0x800000000000ULL
>= 0x1000000000000ULL
10297 && ((off
>> 32) & 0xffff) != 0)
10299 if (PPC_HI (off
) != 0)
10301 if (PPC_LO (off
) != 0)
10307 static Elf_Internal_Rela
*
10308 emit_relocs_for_offset (struct bfd_link_info
*info
, Elf_Internal_Rela
*r
,
10309 bfd_vma roff
, bfd_vma targ
, bfd_vma off
)
10311 bfd_vma relative_targ
= targ
- (roff
- 8);
10312 if (bfd_big_endian (info
->output_bfd
))
10314 r
->r_offset
= roff
;
10315 r
->r_addend
= relative_targ
+ roff
;
10316 if (off
+ 0x8000 < 0x10000)
10317 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16
);
10318 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10320 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HA
);
10323 r
->r_offset
= roff
;
10324 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_LO
);
10325 r
->r_addend
= relative_targ
+ roff
;
10329 if (off
+ 0x800000000000ULL
< 0x1000000000000ULL
)
10330 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHER
);
10333 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHEST
);
10334 if (((off
>> 32) & 0xffff) != 0)
10338 r
->r_offset
= roff
;
10339 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHER
);
10340 r
->r_addend
= relative_targ
+ roff
;
10343 if (((off
>> 32) & 0xffffffffULL
) != 0)
10345 if (PPC_HI (off
) != 0)
10349 r
->r_offset
= roff
;
10350 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGH
);
10351 r
->r_addend
= relative_targ
+ roff
;
10353 if (PPC_LO (off
) != 0)
10357 r
->r_offset
= roff
;
10358 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_LO
);
10359 r
->r_addend
= relative_targ
+ roff
;
10366 build_powerxx_offset (bfd
*abfd
, bfd_byte
*p
, bfd_vma off
, int odd
,
10370 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10375 bfd_put_32 (abfd
, NOP
, p
);
10381 insn
= PADDI_R12_PC
;
10383 bfd_put_32 (abfd
, insn
>> 32, p
);
10385 bfd_put_32 (abfd
, insn
, p
);
10387 /* The minimum value for paddi is -0x200000000. The minimum value
10388 for li is -0x8000, which when shifted by 34 and added gives a
10389 minimum value of -0x2000200000000. The maximum value is
10390 0x1ffffffff+0x7fff<<34 which is 0x2000200000000-1. */
10391 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10394 bfd_put_32 (abfd
, LI_R11_0
| (HA34 (off
) & 0xffff), p
);
10398 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10401 insn
= PADDI_R12_PC
| D34 (off
);
10402 bfd_put_32 (abfd
, insn
>> 32, p
);
10404 bfd_put_32 (abfd
, insn
, p
);
10408 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10412 bfd_put_32 (abfd
, LDX_R12_R11_R12
, p
);
10414 bfd_put_32 (abfd
, ADD_R12_R11_R12
, p
);
10419 bfd_put_32 (abfd
, LIS_R11
| ((HA34 (off
) >> 16) & 0x3fff), p
);
10421 bfd_put_32 (abfd
, ORI_R11_R11_0
| (HA34 (off
) & 0xffff), p
);
10425 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10428 insn
= PADDI_R12_PC
| D34 (off
);
10429 bfd_put_32 (abfd
, insn
>> 32, p
);
10431 bfd_put_32 (abfd
, insn
, p
);
10435 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10439 bfd_put_32 (abfd
, LDX_R12_R11_R12
, p
);
10441 bfd_put_32 (abfd
, ADD_R12_R11_R12
, p
);
10447 static unsigned int
10448 size_powerxx_offset (bfd_vma off
, int odd
)
10450 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10452 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10458 static unsigned int
10459 num_relocs_for_powerxx_offset (bfd_vma off
, int odd
)
10461 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10463 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10469 static Elf_Internal_Rela
*
10470 emit_relocs_for_powerxx_offset (struct bfd_link_info
*info
,
10471 Elf_Internal_Rela
*r
, bfd_vma roff
,
10472 bfd_vma targ
, bfd_vma off
, int odd
)
10474 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10476 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10478 int d_offset
= bfd_big_endian (info
->output_bfd
) ? 2 : 0;
10479 r
->r_offset
= roff
+ d_offset
;
10480 r
->r_addend
= targ
+ 8 - odd
- d_offset
;
10481 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHERA34
);
10487 int d_offset
= bfd_big_endian (info
->output_bfd
) ? 2 : 0;
10488 r
->r_offset
= roff
+ d_offset
;
10489 r
->r_addend
= targ
+ 8 + odd
- d_offset
;
10490 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHESTA34
);
10493 r
->r_offset
= roff
+ d_offset
;
10494 r
->r_addend
= targ
+ 4 + odd
- d_offset
;
10495 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHERA34
);
10499 r
->r_offset
= roff
;
10500 r
->r_addend
= targ
;
10501 r
->r_info
= ELF64_R_INFO (0, R_PPC64_PCREL34
);
10505 /* Emit .eh_frame opcode to advance pc by DELTA. */
10508 eh_advance (bfd
*abfd
, bfd_byte
*eh
, unsigned int delta
)
10512 *eh
++ = DW_CFA_advance_loc
+ delta
;
10513 else if (delta
< 256)
10515 *eh
++ = DW_CFA_advance_loc1
;
10518 else if (delta
< 65536)
10520 *eh
++ = DW_CFA_advance_loc2
;
10521 bfd_put_16 (abfd
, delta
, eh
);
10526 *eh
++ = DW_CFA_advance_loc4
;
10527 bfd_put_32 (abfd
, delta
, eh
);
10533 /* Size of required .eh_frame opcode to advance pc by DELTA. */
10535 static unsigned int
10536 eh_advance_size (unsigned int delta
)
10538 if (delta
< 64 * 4)
10539 /* DW_CFA_advance_loc+[1..63]. */
10541 if (delta
< 256 * 4)
10542 /* DW_CFA_advance_loc1, byte. */
10544 if (delta
< 65536 * 4)
10545 /* DW_CFA_advance_loc2, 2 bytes. */
10547 /* DW_CFA_advance_loc4, 4 bytes. */
10551 /* With power7 weakly ordered memory model, it is possible for ld.so
10552 to update a plt entry in one thread and have another thread see a
10553 stale zero toc entry. To avoid this we need some sort of acquire
10554 barrier in the call stub. One solution is to make the load of the
10555 toc word seem to appear to depend on the load of the function entry
10556 word. Another solution is to test for r2 being zero, and branch to
10557 the appropriate glink entry if so.
10559 . fake dep barrier compare
10560 . ld 12,xxx(2) ld 12,xxx(2)
10561 . mtctr 12 mtctr 12
10562 . xor 11,12,12 ld 2,xxx+8(2)
10563 . add 2,2,11 cmpldi 2,0
10564 . ld 2,xxx+8(2) bnectr+
10565 . bctr b <glink_entry>
10567 The solution involving the compare turns out to be faster, so
10568 that's what we use unless the branch won't reach. */
10570 #define ALWAYS_USE_FAKE_DEP 0
10571 #define ALWAYS_EMIT_R2SAVE 0
10573 static inline unsigned int
10574 plt_stub_size (struct ppc_link_hash_table
*htab
,
10575 struct ppc_stub_hash_entry
*stub_entry
,
10580 if (stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
)
10582 if (htab
->powerxx_stubs
)
10584 bfd_vma start
= (stub_entry
->stub_offset
10585 + stub_entry
->group
->stub_sec
->output_offset
10586 + stub_entry
->group
->stub_sec
->output_section
->vma
);
10587 if (stub_entry
->stub_type
> ppc_stub_plt_call_notoc
)
10589 size
= 8 + size_powerxx_offset (off
, start
& 4);
10592 size
= 8 + size_offset (off
- 8);
10593 if (stub_entry
->stub_type
> ppc_stub_plt_call_notoc
)
10599 if (ALWAYS_EMIT_R2SAVE
10600 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10602 if (PPC_HA (off
) != 0)
10607 if (htab
->params
->plt_static_chain
)
10609 if (htab
->params
->plt_thread_safe
10610 && htab
->elf
.dynamic_sections_created
10611 && stub_entry
->h
!= NULL
10612 && stub_entry
->h
->elf
.dynindx
!= -1)
10614 if (PPC_HA (off
+ 8 + 8 * htab
->params
->plt_static_chain
) != PPC_HA (off
))
10617 if (stub_entry
->h
!= NULL
10618 && (stub_entry
->h
== htab
->tls_get_addr_fd
10619 || stub_entry
->h
== htab
->tls_get_addr
)
10620 && htab
->params
->tls_get_addr_opt
)
10623 if (stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10629 /* Depending on the sign of plt_stub_align:
10630 If positive, return the padding to align to a 2**plt_stub_align
10632 If negative, if this stub would cross fewer 2**plt_stub_align
10633 boundaries if we align, then return the padding needed to do so. */
10635 static inline unsigned int
10636 plt_stub_pad (struct ppc_link_hash_table
*htab
,
10637 struct ppc_stub_hash_entry
*stub_entry
,
10641 unsigned stub_size
;
10642 bfd_vma stub_off
= stub_entry
->group
->stub_sec
->size
;
10644 if (htab
->params
->plt_stub_align
>= 0)
10646 stub_align
= 1 << htab
->params
->plt_stub_align
;
10647 if ((stub_off
& (stub_align
- 1)) != 0)
10648 return stub_align
- (stub_off
& (stub_align
- 1));
10652 stub_align
= 1 << -htab
->params
->plt_stub_align
;
10653 stub_size
= plt_stub_size (htab
, stub_entry
, plt_off
);
10654 if (((stub_off
+ stub_size
- 1) & -stub_align
) - (stub_off
& -stub_align
)
10655 > ((stub_size
- 1) & -stub_align
))
10656 return stub_align
- (stub_off
& (stub_align
- 1));
10660 /* Build a .plt call stub. */
10662 static inline bfd_byte
*
10663 build_plt_stub (struct ppc_link_hash_table
*htab
,
10664 struct ppc_stub_hash_entry
*stub_entry
,
10665 bfd_byte
*p
, bfd_vma offset
, Elf_Internal_Rela
*r
)
10667 bfd
*obfd
= htab
->params
->stub_bfd
;
10668 bfd_boolean plt_load_toc
= htab
->opd_abi
;
10669 bfd_boolean plt_static_chain
= htab
->params
->plt_static_chain
;
10670 bfd_boolean plt_thread_safe
= (htab
->params
->plt_thread_safe
10671 && htab
->elf
.dynamic_sections_created
10672 && stub_entry
->h
!= NULL
10673 && stub_entry
->h
->elf
.dynindx
!= -1);
10674 bfd_boolean use_fake_dep
= plt_thread_safe
;
10675 bfd_vma cmp_branch_off
= 0;
10677 if (!ALWAYS_USE_FAKE_DEP
10680 && !((stub_entry
->h
== htab
->tls_get_addr_fd
10681 || stub_entry
->h
== htab
->tls_get_addr
)
10682 && htab
->params
->tls_get_addr_opt
))
10684 bfd_vma pltoff
= stub_entry
->plt_ent
->plt
.offset
& ~1;
10685 bfd_vma pltindex
= ((pltoff
- PLT_INITIAL_ENTRY_SIZE (htab
))
10686 / PLT_ENTRY_SIZE (htab
));
10687 bfd_vma glinkoff
= GLINK_PLTRESOLVE_SIZE (htab
) + pltindex
* 8;
10690 if (pltindex
> 32768)
10691 glinkoff
+= (pltindex
- 32768) * 4;
10693 + htab
->glink
->output_offset
10694 + htab
->glink
->output_section
->vma
);
10695 from
= (p
- stub_entry
->group
->stub_sec
->contents
10696 + 4 * (ALWAYS_EMIT_R2SAVE
10697 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10698 + 4 * (PPC_HA (offset
) != 0)
10699 + 4 * (PPC_HA (offset
+ 8 + 8 * plt_static_chain
)
10700 != PPC_HA (offset
))
10701 + 4 * (plt_static_chain
!= 0)
10703 + stub_entry
->group
->stub_sec
->output_offset
10704 + stub_entry
->group
->stub_sec
->output_section
->vma
);
10705 cmp_branch_off
= to
- from
;
10706 use_fake_dep
= cmp_branch_off
+ (1 << 25) >= (1 << 26);
10709 if (PPC_HA (offset
) != 0)
10713 if (ALWAYS_EMIT_R2SAVE
10714 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10715 r
[0].r_offset
+= 4;
10716 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_HA
);
10717 r
[1].r_offset
= r
[0].r_offset
+ 4;
10718 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
10719 r
[1].r_addend
= r
[0].r_addend
;
10722 if (PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
10724 r
[2].r_offset
= r
[1].r_offset
+ 4;
10725 r
[2].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO
);
10726 r
[2].r_addend
= r
[0].r_addend
;
10730 r
[2].r_offset
= r
[1].r_offset
+ 8 + 8 * use_fake_dep
;
10731 r
[2].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
10732 r
[2].r_addend
= r
[0].r_addend
+ 8;
10733 if (plt_static_chain
)
10735 r
[3].r_offset
= r
[2].r_offset
+ 4;
10736 r
[3].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
10737 r
[3].r_addend
= r
[0].r_addend
+ 16;
10742 if (ALWAYS_EMIT_R2SAVE
10743 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10744 bfd_put_32 (obfd
, STD_R2_0R1
+ STK_TOC (htab
), p
), p
+= 4;
10747 bfd_put_32 (obfd
, ADDIS_R11_R2
| PPC_HA (offset
), p
), p
+= 4;
10748 bfd_put_32 (obfd
, LD_R12_0R11
| PPC_LO (offset
), p
), p
+= 4;
10752 bfd_put_32 (obfd
, ADDIS_R12_R2
| PPC_HA (offset
), p
), p
+= 4;
10753 bfd_put_32 (obfd
, LD_R12_0R12
| PPC_LO (offset
), p
), p
+= 4;
10756 && PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
10758 bfd_put_32 (obfd
, ADDI_R11_R11
| PPC_LO (offset
), p
), p
+= 4;
10761 bfd_put_32 (obfd
, MTCTR_R12
, p
), p
+= 4;
10766 bfd_put_32 (obfd
, XOR_R2_R12_R12
, p
), p
+= 4;
10767 bfd_put_32 (obfd
, ADD_R11_R11_R2
, p
), p
+= 4;
10769 bfd_put_32 (obfd
, LD_R2_0R11
| PPC_LO (offset
+ 8), p
), p
+= 4;
10770 if (plt_static_chain
)
10771 bfd_put_32 (obfd
, LD_R11_0R11
| PPC_LO (offset
+ 16), p
), p
+= 4;
10778 if (ALWAYS_EMIT_R2SAVE
10779 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10780 r
[0].r_offset
+= 4;
10781 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
10784 if (PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
10786 r
[1].r_offset
= r
[0].r_offset
+ 4;
10787 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16
);
10788 r
[1].r_addend
= r
[0].r_addend
;
10792 r
[1].r_offset
= r
[0].r_offset
+ 8 + 8 * use_fake_dep
;
10793 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
10794 r
[1].r_addend
= r
[0].r_addend
+ 8 + 8 * plt_static_chain
;
10795 if (plt_static_chain
)
10797 r
[2].r_offset
= r
[1].r_offset
+ 4;
10798 r
[2].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
10799 r
[2].r_addend
= r
[0].r_addend
+ 8;
10804 if (ALWAYS_EMIT_R2SAVE
10805 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10806 bfd_put_32 (obfd
, STD_R2_0R1
+ STK_TOC (htab
), p
), p
+= 4;
10807 bfd_put_32 (obfd
, LD_R12_0R2
| PPC_LO (offset
), p
), p
+= 4;
10809 && PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
10811 bfd_put_32 (obfd
, ADDI_R2_R2
| PPC_LO (offset
), p
), p
+= 4;
10814 bfd_put_32 (obfd
, MTCTR_R12
, p
), p
+= 4;
10819 bfd_put_32 (obfd
, XOR_R11_R12_R12
, p
), p
+= 4;
10820 bfd_put_32 (obfd
, ADD_R2_R2_R11
, p
), p
+= 4;
10822 if (plt_static_chain
)
10823 bfd_put_32 (obfd
, LD_R11_0R2
| PPC_LO (offset
+ 16), p
), p
+= 4;
10824 bfd_put_32 (obfd
, LD_R2_0R2
| PPC_LO (offset
+ 8), p
), p
+= 4;
10827 if (plt_load_toc
&& plt_thread_safe
&& !use_fake_dep
)
10829 bfd_put_32 (obfd
, CMPLDI_R2_0
, p
), p
+= 4;
10830 bfd_put_32 (obfd
, BNECTR_P4
, p
), p
+= 4;
10831 bfd_put_32 (obfd
, B_DOT
| (cmp_branch_off
& 0x3fffffc), p
), p
+= 4;
10834 bfd_put_32 (obfd
, BCTR
, p
), p
+= 4;
10838 /* Build a special .plt call stub for __tls_get_addr. */
10840 #define LD_R11_0R3 0xe9630000
10841 #define LD_R12_0R3 0xe9830000
10842 #define MR_R0_R3 0x7c601b78
10843 #define CMPDI_R11_0 0x2c2b0000
10844 #define ADD_R3_R12_R13 0x7c6c6a14
10845 #define BEQLR 0x4d820020
10846 #define MR_R3_R0 0x7c030378
10847 #define STD_R11_0R1 0xf9610000
10848 #define BCTRL 0x4e800421
10849 #define LD_R11_0R1 0xe9610000
10850 #define MTLR_R11 0x7d6803a6
10852 static inline bfd_byte
*
10853 build_tls_get_addr_stub (struct ppc_link_hash_table
*htab
,
10854 struct ppc_stub_hash_entry
*stub_entry
,
10855 bfd_byte
*p
, bfd_vma offset
, Elf_Internal_Rela
*r
)
10857 bfd
*obfd
= htab
->params
->stub_bfd
;
10860 bfd_put_32 (obfd
, LD_R11_0R3
+ 0, p
), p
+= 4;
10861 bfd_put_32 (obfd
, LD_R12_0R3
+ 8, p
), p
+= 4;
10862 bfd_put_32 (obfd
, MR_R0_R3
, p
), p
+= 4;
10863 bfd_put_32 (obfd
, CMPDI_R11_0
, p
), p
+= 4;
10864 bfd_put_32 (obfd
, ADD_R3_R12_R13
, p
), p
+= 4;
10865 bfd_put_32 (obfd
, BEQLR
, p
), p
+= 4;
10866 bfd_put_32 (obfd
, MR_R3_R0
, p
), p
+= 4;
10868 r
[0].r_offset
+= 7 * 4;
10869 if (stub_entry
->stub_type
!= ppc_stub_plt_call_r2save
)
10870 return build_plt_stub (htab
, stub_entry
, p
, offset
, r
);
10872 bfd_put_32 (obfd
, MFLR_R11
, p
), p
+= 4;
10873 bfd_put_32 (obfd
, STD_R11_0R1
+ STK_LINKER (htab
), p
), p
+= 4;
10876 r
[0].r_offset
+= 2 * 4;
10877 p
= build_plt_stub (htab
, stub_entry
, p
, offset
, r
);
10878 bfd_put_32 (obfd
, BCTRL
, p
- 4);
10880 bfd_put_32 (obfd
, LD_R2_0R1
+ STK_TOC (htab
), p
), p
+= 4;
10881 bfd_put_32 (obfd
, LD_R11_0R1
+ STK_LINKER (htab
), p
), p
+= 4;
10882 bfd_put_32 (obfd
, MTLR_R11
, p
), p
+= 4;
10883 bfd_put_32 (obfd
, BLR
, p
), p
+= 4;
10885 if (htab
->glink_eh_frame
!= NULL
10886 && htab
->glink_eh_frame
->size
!= 0)
10888 bfd_byte
*base
, *eh
;
10889 unsigned int lr_used
, delta
;
10891 base
= htab
->glink_eh_frame
->contents
+ stub_entry
->group
->eh_base
+ 17;
10892 eh
= base
+ stub_entry
->group
->eh_size
;
10893 lr_used
= stub_entry
->stub_offset
+ (p
- 20 - loc
);
10894 delta
= lr_used
- stub_entry
->group
->lr_restore
;
10895 stub_entry
->group
->lr_restore
= lr_used
+ 16;
10896 eh
= eh_advance (htab
->elf
.dynobj
, eh
, delta
);
10897 *eh
++ = DW_CFA_offset_extended_sf
;
10899 *eh
++ = -(STK_LINKER (htab
) / 8) & 0x7f;
10900 *eh
++ = DW_CFA_advance_loc
+ 4;
10901 *eh
++ = DW_CFA_restore_extended
;
10903 stub_entry
->group
->eh_size
= eh
- base
;
10908 static Elf_Internal_Rela
*
10909 get_relocs (asection
*sec
, int count
)
10911 Elf_Internal_Rela
*relocs
;
10912 struct bfd_elf_section_data
*elfsec_data
;
10914 elfsec_data
= elf_section_data (sec
);
10915 relocs
= elfsec_data
->relocs
;
10916 if (relocs
== NULL
)
10918 bfd_size_type relsize
;
10919 relsize
= sec
->reloc_count
* sizeof (*relocs
);
10920 relocs
= bfd_alloc (sec
->owner
, relsize
);
10921 if (relocs
== NULL
)
10923 elfsec_data
->relocs
= relocs
;
10924 elfsec_data
->rela
.hdr
= bfd_zalloc (sec
->owner
,
10925 sizeof (Elf_Internal_Shdr
));
10926 if (elfsec_data
->rela
.hdr
== NULL
)
10928 elfsec_data
->rela
.hdr
->sh_size
= (sec
->reloc_count
10929 * sizeof (Elf64_External_Rela
));
10930 elfsec_data
->rela
.hdr
->sh_entsize
= sizeof (Elf64_External_Rela
);
10931 sec
->reloc_count
= 0;
10933 relocs
+= sec
->reloc_count
;
10934 sec
->reloc_count
+= count
;
10938 /* Convert the relocs R[0] thru R[-NUM_REL+1], which are all no-symbol
10939 forms, to the equivalent relocs against the global symbol given by
10943 use_global_in_relocs (struct ppc_link_hash_table
*htab
,
10944 struct ppc_stub_hash_entry
*stub_entry
,
10945 Elf_Internal_Rela
*r
, unsigned int num_rel
)
10947 struct elf_link_hash_entry
**hashes
;
10948 unsigned long symndx
;
10949 struct ppc_link_hash_entry
*h
;
10952 /* Relocs are always against symbols in their own object file. Fake
10953 up global sym hashes for the stub bfd (which has no symbols). */
10954 hashes
= elf_sym_hashes (htab
->params
->stub_bfd
);
10955 if (hashes
== NULL
)
10957 bfd_size_type hsize
;
10959 /* When called the first time, stub_globals will contain the
10960 total number of symbols seen during stub sizing. After
10961 allocating, stub_globals is used as an index to fill the
10963 hsize
= (htab
->stub_globals
+ 1) * sizeof (*hashes
);
10964 hashes
= bfd_zalloc (htab
->params
->stub_bfd
, hsize
);
10965 if (hashes
== NULL
)
10967 elf_sym_hashes (htab
->params
->stub_bfd
) = hashes
;
10968 htab
->stub_globals
= 1;
10970 symndx
= htab
->stub_globals
++;
10972 hashes
[symndx
] = &h
->elf
;
10973 if (h
->oh
!= NULL
&& h
->oh
->is_func
)
10974 h
= ppc_follow_link (h
->oh
);
10975 BFD_ASSERT (h
->elf
.root
.type
== bfd_link_hash_defined
10976 || h
->elf
.root
.type
== bfd_link_hash_defweak
);
10977 symval
= (h
->elf
.root
.u
.def
.value
10978 + h
->elf
.root
.u
.def
.section
->output_offset
10979 + h
->elf
.root
.u
.def
.section
->output_section
->vma
);
10980 while (num_rel
-- != 0)
10982 r
->r_info
= ELF64_R_INFO (symndx
, ELF64_R_TYPE (r
->r_info
));
10983 if (h
->elf
.root
.u
.def
.section
!= stub_entry
->target_section
)
10985 /* H is an opd symbol. The addend must be zero, and the
10986 branch reloc is the only one we can convert. */
10991 r
->r_addend
-= symval
;
10998 get_r2off (struct bfd_link_info
*info
,
10999 struct ppc_stub_hash_entry
*stub_entry
)
11001 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
11002 bfd_vma r2off
= htab
->sec_info
[stub_entry
->target_section
->id
].toc_off
;
11006 /* Support linking -R objects. Get the toc pointer from the
11009 if (!htab
->opd_abi
)
11011 asection
*opd
= stub_entry
->h
->elf
.root
.u
.def
.section
;
11012 bfd_vma opd_off
= stub_entry
->h
->elf
.root
.u
.def
.value
;
11014 if (strcmp (opd
->name
, ".opd") != 0
11015 || opd
->reloc_count
!= 0)
11017 info
->callbacks
->einfo
11018 (_("%P: cannot find opd entry toc for `%pT'\n"),
11019 stub_entry
->h
->elf
.root
.root
.string
);
11020 bfd_set_error (bfd_error_bad_value
);
11021 return (bfd_vma
) -1;
11023 if (!bfd_get_section_contents (opd
->owner
, opd
, buf
, opd_off
+ 8, 8))
11024 return (bfd_vma
) -1;
11025 r2off
= bfd_get_64 (opd
->owner
, buf
);
11026 r2off
-= elf_gp (info
->output_bfd
);
11028 r2off
-= htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
;
11033 ppc_build_one_stub (struct bfd_hash_entry
*gen_entry
, void *in_arg
)
11035 struct ppc_stub_hash_entry
*stub_entry
;
11036 struct ppc_branch_hash_entry
*br_entry
;
11037 struct bfd_link_info
*info
;
11038 struct ppc_link_hash_table
*htab
;
11040 bfd_byte
*p
, *relp
;
11042 Elf_Internal_Rela
*r
;
11047 /* Massage our args to the form they really have. */
11048 stub_entry
= (struct ppc_stub_hash_entry
*) gen_entry
;
11051 htab
= ppc_hash_table (info
);
11055 BFD_ASSERT (stub_entry
->stub_offset
>= stub_entry
->group
->stub_sec
->size
);
11056 loc
= stub_entry
->group
->stub_sec
->contents
+ stub_entry
->stub_offset
;
11058 htab
->stub_count
[stub_entry
->stub_type
- 1] += 1;
11059 switch (stub_entry
->stub_type
)
11061 case ppc_stub_long_branch
:
11062 case ppc_stub_long_branch_r2off
:
11063 /* Branches are relative. This is where we are going to. */
11064 targ
= (stub_entry
->target_value
11065 + stub_entry
->target_section
->output_offset
11066 + stub_entry
->target_section
->output_section
->vma
);
11067 targ
+= PPC64_LOCAL_ENTRY_OFFSET (stub_entry
->other
);
11069 /* And this is where we are coming from. */
11070 off
= (stub_entry
->stub_offset
11071 + stub_entry
->group
->stub_sec
->output_offset
11072 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11076 if (stub_entry
->stub_type
== ppc_stub_long_branch_r2off
)
11078 bfd_vma r2off
= get_r2off (info
, stub_entry
);
11080 if (r2off
== (bfd_vma
) -1)
11082 htab
->stub_error
= TRUE
;
11085 bfd_put_32 (htab
->params
->stub_bfd
, STD_R2_0R1
+ STK_TOC (htab
), p
);
11087 if (PPC_HA (r2off
) != 0)
11089 bfd_put_32 (htab
->params
->stub_bfd
,
11090 ADDIS_R2_R2
| PPC_HA (r2off
), p
);
11093 if (PPC_LO (r2off
) != 0)
11095 bfd_put_32 (htab
->params
->stub_bfd
,
11096 ADDI_R2_R2
| PPC_LO (r2off
), p
);
11101 bfd_put_32 (htab
->params
->stub_bfd
, B_DOT
| (off
& 0x3fffffc), p
);
11104 if (off
+ (1 << 25) >= (bfd_vma
) (1 << 26))
11107 (_("long branch stub `%s' offset overflow"),
11108 stub_entry
->root
.string
);
11109 htab
->stub_error
= TRUE
;
11113 if (info
->emitrelocations
)
11115 r
= get_relocs (stub_entry
->group
->stub_sec
, 1);
11118 r
->r_offset
= p
- 4 - stub_entry
->group
->stub_sec
->contents
;
11119 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL24
);
11120 r
->r_addend
= targ
;
11121 if (stub_entry
->h
!= NULL
11122 && !use_global_in_relocs (htab
, stub_entry
, r
, 1))
11127 case ppc_stub_plt_branch
:
11128 case ppc_stub_plt_branch_r2off
:
11129 br_entry
= ppc_branch_hash_lookup (&htab
->branch_hash_table
,
11130 stub_entry
->root
.string
+ 9,
11132 if (br_entry
== NULL
)
11134 _bfd_error_handler (_("can't find branch stub `%s'"),
11135 stub_entry
->root
.string
);
11136 htab
->stub_error
= TRUE
;
11140 targ
= (stub_entry
->target_value
11141 + stub_entry
->target_section
->output_offset
11142 + stub_entry
->target_section
->output_section
->vma
);
11143 if (stub_entry
->stub_type
!= ppc_stub_plt_branch_r2off
)
11144 targ
+= PPC64_LOCAL_ENTRY_OFFSET (stub_entry
->other
);
11146 bfd_put_64 (htab
->brlt
->owner
, targ
,
11147 htab
->brlt
->contents
+ br_entry
->offset
);
11149 if (br_entry
->iter
== htab
->stub_iteration
)
11151 br_entry
->iter
= 0;
11153 if (htab
->relbrlt
!= NULL
)
11155 /* Create a reloc for the branch lookup table entry. */
11156 Elf_Internal_Rela rela
;
11159 rela
.r_offset
= (br_entry
->offset
11160 + htab
->brlt
->output_offset
11161 + htab
->brlt
->output_section
->vma
);
11162 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
11163 rela
.r_addend
= targ
;
11165 rl
= htab
->relbrlt
->contents
;
11166 rl
+= (htab
->relbrlt
->reloc_count
++
11167 * sizeof (Elf64_External_Rela
));
11168 bfd_elf64_swap_reloca_out (htab
->relbrlt
->owner
, &rela
, rl
);
11170 else if (info
->emitrelocations
)
11172 r
= get_relocs (htab
->brlt
, 1);
11175 /* brlt, being SEC_LINKER_CREATED does not go through the
11176 normal reloc processing. Symbols and offsets are not
11177 translated from input file to output file form, so
11178 set up the offset per the output file. */
11179 r
->r_offset
= (br_entry
->offset
11180 + htab
->brlt
->output_offset
11181 + htab
->brlt
->output_section
->vma
);
11182 r
->r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
11183 r
->r_addend
= targ
;
11187 targ
= (br_entry
->offset
11188 + htab
->brlt
->output_offset
11189 + htab
->brlt
->output_section
->vma
);
11191 off
= (elf_gp (info
->output_bfd
)
11192 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
11195 if (off
+ 0x80008000 > 0xffffffff || (off
& 7) != 0)
11197 info
->callbacks
->einfo
11198 (_("%P: linkage table error against `%pT'\n"),
11199 stub_entry
->root
.string
);
11200 bfd_set_error (bfd_error_bad_value
);
11201 htab
->stub_error
= TRUE
;
11205 if (info
->emitrelocations
)
11207 r
= get_relocs (stub_entry
->group
->stub_sec
, 1 + (PPC_HA (off
) != 0));
11210 r
[0].r_offset
= loc
- stub_entry
->group
->stub_sec
->contents
;
11211 if (bfd_big_endian (info
->output_bfd
))
11212 r
[0].r_offset
+= 2;
11213 if (stub_entry
->stub_type
== ppc_stub_plt_branch_r2off
)
11214 r
[0].r_offset
+= 4;
11215 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
11216 r
[0].r_addend
= targ
;
11217 if (PPC_HA (off
) != 0)
11219 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_HA
);
11220 r
[1].r_offset
= r
[0].r_offset
+ 4;
11221 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
11222 r
[1].r_addend
= r
[0].r_addend
;
11227 if (stub_entry
->stub_type
!= ppc_stub_plt_branch_r2off
)
11229 if (PPC_HA (off
) != 0)
11231 bfd_put_32 (htab
->params
->stub_bfd
,
11232 ADDIS_R12_R2
| PPC_HA (off
), p
);
11234 bfd_put_32 (htab
->params
->stub_bfd
,
11235 LD_R12_0R12
| PPC_LO (off
), p
);
11238 bfd_put_32 (htab
->params
->stub_bfd
,
11239 LD_R12_0R2
| PPC_LO (off
), p
);
11243 bfd_vma r2off
= get_r2off (info
, stub_entry
);
11245 if (r2off
== (bfd_vma
) -1)
11247 htab
->stub_error
= TRUE
;
11251 bfd_put_32 (htab
->params
->stub_bfd
, STD_R2_0R1
+ STK_TOC (htab
), p
);
11253 if (PPC_HA (off
) != 0)
11255 bfd_put_32 (htab
->params
->stub_bfd
,
11256 ADDIS_R12_R2
| PPC_HA (off
), p
);
11258 bfd_put_32 (htab
->params
->stub_bfd
,
11259 LD_R12_0R12
| PPC_LO (off
), p
);
11262 bfd_put_32 (htab
->params
->stub_bfd
, LD_R12_0R2
| PPC_LO (off
), p
);
11264 if (PPC_HA (r2off
) != 0)
11267 bfd_put_32 (htab
->params
->stub_bfd
,
11268 ADDIS_R2_R2
| PPC_HA (r2off
), p
);
11270 if (PPC_LO (r2off
) != 0)
11273 bfd_put_32 (htab
->params
->stub_bfd
,
11274 ADDI_R2_R2
| PPC_LO (r2off
), p
);
11278 bfd_put_32 (htab
->params
->stub_bfd
, MTCTR_R12
, p
);
11280 bfd_put_32 (htab
->params
->stub_bfd
, BCTR
, p
);
11284 case ppc_stub_long_branch_notoc
:
11285 case ppc_stub_long_branch_both
:
11286 case ppc_stub_plt_branch_notoc
:
11287 case ppc_stub_plt_branch_both
:
11288 case ppc_stub_plt_call_notoc
:
11289 case ppc_stub_plt_call_both
:
11291 off
= (stub_entry
->stub_offset
11292 + stub_entry
->group
->stub_sec
->output_offset
11293 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11294 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
11295 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
11296 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
11299 bfd_put_32 (htab
->params
->stub_bfd
, STD_R2_0R1
+ STK_TOC (htab
), p
);
11302 if (stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
)
11304 targ
= stub_entry
->plt_ent
->plt
.offset
& ~1;
11305 if (targ
>= (bfd_vma
) -2)
11308 plt
= htab
->elf
.splt
;
11309 if (!htab
->elf
.dynamic_sections_created
11310 || stub_entry
->h
== NULL
11311 || stub_entry
->h
->elf
.dynindx
== -1)
11313 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
11314 plt
= htab
->elf
.iplt
;
11316 plt
= htab
->pltlocal
;
11318 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
11321 targ
= (stub_entry
->target_value
11322 + stub_entry
->target_section
->output_offset
11323 + stub_entry
->target_section
->output_section
->vma
);
11329 if (htab
->powerxx_stubs
)
11331 bfd_boolean load
= stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
;
11332 p
= build_powerxx_offset (htab
->params
->stub_bfd
, p
, off
, odd
, load
);
11336 /* The notoc stubs calculate their target (either a PLT entry or
11337 the global entry point of a function) relative to the PC
11338 returned by the "bcl" two instructions past the start of the
11339 sequence emitted by build_offset. The offset is therefore 8
11340 less than calculated from the start of the sequence. */
11342 p
= build_offset (htab
->params
->stub_bfd
, p
, off
,
11343 stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
);
11346 if (stub_entry
->stub_type
<= ppc_stub_long_branch_both
)
11350 from
= (stub_entry
->stub_offset
11351 + stub_entry
->group
->stub_sec
->output_offset
11352 + stub_entry
->group
->stub_sec
->output_section
->vma
11354 bfd_put_32 (htab
->params
->stub_bfd
,
11355 B_DOT
| ((targ
- from
) & 0x3fffffc), p
);
11359 bfd_put_32 (htab
->params
->stub_bfd
, MTCTR_R12
, p
);
11361 bfd_put_32 (htab
->params
->stub_bfd
, BCTR
, p
);
11365 if (info
->emitrelocations
)
11367 bfd_vma roff
= relp
- stub_entry
->group
->stub_sec
->contents
;
11368 if (htab
->powerxx_stubs
)
11369 num_rel
+= num_relocs_for_powerxx_offset (off
, odd
);
11372 num_rel
+= num_relocs_for_offset (off
);
11375 r
= get_relocs (stub_entry
->group
->stub_sec
, num_rel
);
11378 if (htab
->powerxx_stubs
)
11379 r
= emit_relocs_for_powerxx_offset (info
, r
, roff
, targ
, off
, odd
);
11381 r
= emit_relocs_for_offset (info
, r
, roff
, targ
, off
);
11382 if (stub_entry
->stub_type
== ppc_stub_long_branch_notoc
11383 || stub_entry
->stub_type
== ppc_stub_long_branch_both
)
11386 roff
= p
- 4 - stub_entry
->group
->stub_sec
->contents
;
11387 r
->r_offset
= roff
;
11388 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL24
);
11389 r
->r_addend
= targ
;
11390 if (stub_entry
->h
!= NULL
11391 && !use_global_in_relocs (htab
, stub_entry
, r
, num_rel
))
11396 if (!htab
->powerxx_stubs
11397 && htab
->glink_eh_frame
!= NULL
11398 && htab
->glink_eh_frame
->size
!= 0)
11400 bfd_byte
*base
, *eh
;
11401 unsigned int lr_used
, delta
;
11403 base
= (htab
->glink_eh_frame
->contents
11404 + stub_entry
->group
->eh_base
+ 17);
11405 eh
= base
+ stub_entry
->group
->eh_size
;
11406 lr_used
= stub_entry
->stub_offset
+ 8;
11407 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
11408 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
11409 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
11411 delta
= lr_used
- stub_entry
->group
->lr_restore
;
11412 stub_entry
->group
->lr_restore
= lr_used
+ 8;
11413 eh
= eh_advance (htab
->elf
.dynobj
, eh
, delta
);
11414 *eh
++ = DW_CFA_register
;
11417 *eh
++ = DW_CFA_advance_loc
+ 2;
11418 *eh
++ = DW_CFA_restore_extended
;
11420 stub_entry
->group
->eh_size
= eh
- base
;
11424 case ppc_stub_plt_call
:
11425 case ppc_stub_plt_call_r2save
:
11426 if (stub_entry
->h
!= NULL
11427 && stub_entry
->h
->is_func_descriptor
11428 && stub_entry
->h
->oh
!= NULL
)
11430 struct ppc_link_hash_entry
*fh
= ppc_follow_link (stub_entry
->h
->oh
);
11432 /* If the old-ABI "dot-symbol" is undefined make it weak so
11433 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL. */
11434 if (fh
->elf
.root
.type
== bfd_link_hash_undefined
11435 && (stub_entry
->h
->elf
.root
.type
== bfd_link_hash_defined
11436 || stub_entry
->h
->elf
.root
.type
== bfd_link_hash_defweak
))
11437 fh
->elf
.root
.type
= bfd_link_hash_undefweak
;
11440 /* Now build the stub. */
11441 targ
= stub_entry
->plt_ent
->plt
.offset
& ~1;
11442 if (targ
>= (bfd_vma
) -2)
11445 plt
= htab
->elf
.splt
;
11446 if (!htab
->elf
.dynamic_sections_created
11447 || stub_entry
->h
== NULL
11448 || stub_entry
->h
->elf
.dynindx
== -1)
11450 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
11451 plt
= htab
->elf
.iplt
;
11453 plt
= htab
->pltlocal
;
11455 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
11457 off
= (elf_gp (info
->output_bfd
)
11458 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
11461 if (off
+ 0x80008000 > 0xffffffff || (off
& 7) != 0)
11463 info
->callbacks
->einfo
11464 /* xgettext:c-format */
11465 (_("%P: linkage table error against `%pT'\n"),
11466 stub_entry
->h
!= NULL
11467 ? stub_entry
->h
->elf
.root
.root
.string
11469 bfd_set_error (bfd_error_bad_value
);
11470 htab
->stub_error
= TRUE
;
11475 if (info
->emitrelocations
)
11477 r
= get_relocs (stub_entry
->group
->stub_sec
,
11478 ((PPC_HA (off
) != 0)
11480 ? 2 + (htab
->params
->plt_static_chain
11481 && PPC_HA (off
+ 16) == PPC_HA (off
))
11485 r
[0].r_offset
= loc
- stub_entry
->group
->stub_sec
->contents
;
11486 if (bfd_big_endian (info
->output_bfd
))
11487 r
[0].r_offset
+= 2;
11488 r
[0].r_addend
= targ
;
11490 if (stub_entry
->h
!= NULL
11491 && (stub_entry
->h
== htab
->tls_get_addr_fd
11492 || stub_entry
->h
== htab
->tls_get_addr
)
11493 && htab
->params
->tls_get_addr_opt
)
11494 p
= build_tls_get_addr_stub (htab
, stub_entry
, loc
, off
, r
);
11496 p
= build_plt_stub (htab
, stub_entry
, loc
, off
, r
);
11499 case ppc_stub_save_res
:
11507 stub_entry
->group
->stub_sec
->size
= stub_entry
->stub_offset
+ (p
- loc
);
11509 if (htab
->params
->emit_stub_syms
)
11511 struct elf_link_hash_entry
*h
;
11514 const char *const stub_str
[] = { "long_branch",
11527 len1
= strlen (stub_str
[stub_entry
->stub_type
- 1]);
11528 len2
= strlen (stub_entry
->root
.string
);
11529 name
= bfd_malloc (len1
+ len2
+ 2);
11532 memcpy (name
, stub_entry
->root
.string
, 9);
11533 memcpy (name
+ 9, stub_str
[stub_entry
->stub_type
- 1], len1
);
11534 memcpy (name
+ len1
+ 9, stub_entry
->root
.string
+ 8, len2
- 8 + 1);
11535 h
= elf_link_hash_lookup (&htab
->elf
, name
, TRUE
, FALSE
, FALSE
);
11538 if (h
->root
.type
== bfd_link_hash_new
)
11540 h
->root
.type
= bfd_link_hash_defined
;
11541 h
->root
.u
.def
.section
= stub_entry
->group
->stub_sec
;
11542 h
->root
.u
.def
.value
= stub_entry
->stub_offset
;
11543 h
->ref_regular
= 1;
11544 h
->def_regular
= 1;
11545 h
->ref_regular_nonweak
= 1;
11546 h
->forced_local
= 1;
11548 h
->root
.linker_def
= 1;
11555 /* As above, but don't actually build the stub. Just bump offset so
11556 we know stub section sizes, and select plt_branch stubs where
11557 long_branch stubs won't do. */
11560 ppc_size_one_stub (struct bfd_hash_entry
*gen_entry
, void *in_arg
)
11562 struct ppc_stub_hash_entry
*stub_entry
;
11563 struct bfd_link_info
*info
;
11564 struct ppc_link_hash_table
*htab
;
11566 bfd_vma targ
, off
, r2off
;
11567 unsigned int size
, extra
, lr_used
, delta
, odd
;
11569 /* Massage our args to the form they really have. */
11570 stub_entry
= (struct ppc_stub_hash_entry
*) gen_entry
;
11573 htab
= ppc_hash_table (info
);
11577 /* Make a note of the offset within the stubs for this entry. */
11578 stub_entry
->stub_offset
= stub_entry
->group
->stub_sec
->size
;
11580 if (stub_entry
->h
!= NULL
11581 && stub_entry
->h
->save_res
11582 && stub_entry
->h
->elf
.root
.type
== bfd_link_hash_defined
11583 && stub_entry
->h
->elf
.root
.u
.def
.section
== htab
->sfpr
)
11585 /* Don't make stubs to out-of-line register save/restore
11586 functions. Instead, emit copies of the functions. */
11587 stub_entry
->group
->needs_save_res
= 1;
11588 stub_entry
->stub_type
= ppc_stub_save_res
;
11592 switch (stub_entry
->stub_type
)
11594 case ppc_stub_plt_branch
:
11595 case ppc_stub_plt_branch_r2off
:
11596 /* Reset the stub type from the plt branch variant in case we now
11597 can reach with a shorter stub. */
11598 stub_entry
->stub_type
+= ppc_stub_long_branch
- ppc_stub_plt_branch
;
11599 /* Fall through. */
11600 case ppc_stub_long_branch
:
11601 case ppc_stub_long_branch_r2off
:
11602 targ
= (stub_entry
->target_value
11603 + stub_entry
->target_section
->output_offset
11604 + stub_entry
->target_section
->output_section
->vma
);
11605 targ
+= PPC64_LOCAL_ENTRY_OFFSET (stub_entry
->other
);
11606 off
= (stub_entry
->stub_offset
11607 + stub_entry
->group
->stub_sec
->output_offset
11608 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11612 if (stub_entry
->stub_type
== ppc_stub_long_branch_r2off
)
11614 r2off
= get_r2off (info
, stub_entry
);
11615 if (r2off
== (bfd_vma
) -1)
11617 htab
->stub_error
= TRUE
;
11621 if (PPC_HA (r2off
) != 0)
11623 if (PPC_LO (r2off
) != 0)
11629 /* If the branch offset is too big, use a ppc_stub_plt_branch.
11630 Do the same for -R objects without function descriptors. */
11631 if ((stub_entry
->stub_type
== ppc_stub_long_branch_r2off
11633 && htab
->sec_info
[stub_entry
->target_section
->id
].toc_off
== 0)
11634 || off
+ (1 << 25) >= (bfd_vma
) (1 << 26))
11636 struct ppc_branch_hash_entry
*br_entry
;
11638 br_entry
= ppc_branch_hash_lookup (&htab
->branch_hash_table
,
11639 stub_entry
->root
.string
+ 9,
11641 if (br_entry
== NULL
)
11643 _bfd_error_handler (_("can't build branch stub `%s'"),
11644 stub_entry
->root
.string
);
11645 htab
->stub_error
= TRUE
;
11649 if (br_entry
->iter
!= htab
->stub_iteration
)
11651 br_entry
->iter
= htab
->stub_iteration
;
11652 br_entry
->offset
= htab
->brlt
->size
;
11653 htab
->brlt
->size
+= 8;
11655 if (htab
->relbrlt
!= NULL
)
11656 htab
->relbrlt
->size
+= sizeof (Elf64_External_Rela
);
11657 else if (info
->emitrelocations
)
11659 htab
->brlt
->reloc_count
+= 1;
11660 htab
->brlt
->flags
|= SEC_RELOC
;
11664 targ
= (br_entry
->offset
11665 + htab
->brlt
->output_offset
11666 + htab
->brlt
->output_section
->vma
);
11667 off
= (elf_gp (info
->output_bfd
)
11668 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
11671 if (info
->emitrelocations
)
11673 stub_entry
->group
->stub_sec
->reloc_count
11674 += 1 + (PPC_HA (off
) != 0);
11675 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
11678 stub_entry
->stub_type
+= ppc_stub_plt_branch
- ppc_stub_long_branch
;
11679 if (stub_entry
->stub_type
!= ppc_stub_plt_branch_r2off
)
11682 if (PPC_HA (off
) != 0)
11688 if (PPC_HA (off
) != 0)
11691 if (PPC_HA (r2off
) != 0)
11693 if (PPC_LO (r2off
) != 0)
11697 else if (info
->emitrelocations
)
11699 stub_entry
->group
->stub_sec
->reloc_count
+= 1;
11700 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
11704 case ppc_stub_plt_branch_notoc
:
11705 case ppc_stub_plt_branch_both
:
11706 stub_entry
->stub_type
+= ppc_stub_long_branch
- ppc_stub_plt_branch
;
11707 /* Fall through. */
11708 case ppc_stub_long_branch_notoc
:
11709 case ppc_stub_long_branch_both
:
11710 off
= (stub_entry
->stub_offset
11711 + stub_entry
->group
->stub_sec
->output_offset
11712 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11714 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
)
11717 targ
= (stub_entry
->target_value
11718 + stub_entry
->target_section
->output_offset
11719 + stub_entry
->target_section
->output_section
->vma
);
11723 if (info
->emitrelocations
)
11725 unsigned int num_rel
;
11726 if (htab
->powerxx_stubs
)
11727 num_rel
= num_relocs_for_powerxx_offset (off
, odd
);
11729 num_rel
= num_relocs_for_offset (off
- 8);
11730 stub_entry
->group
->stub_sec
->reloc_count
+= num_rel
;
11731 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
11734 if (htab
->powerxx_stubs
)
11735 extra
= size_powerxx_offset (off
, odd
);
11737 extra
= size_offset (off
- 8);
11738 /* Include branch insn plus those in the offset sequence. */
11740 /* The branch insn is at the end, or "extra" bytes along. So
11741 its offset will be "extra" bytes less that that already
11745 if (!htab
->powerxx_stubs
)
11747 /* After the bcl, lr has been modified so we need to emit
11748 .eh_frame info saying the return address is in r12. */
11749 lr_used
= stub_entry
->stub_offset
+ 8;
11750 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
)
11752 /* The eh_frame info will consist of a DW_CFA_advance_loc or
11753 variant, DW_CFA_register, 65, 12, DW_CFA_advance_loc+2,
11754 DW_CFA_restore_extended 65. */
11755 delta
= lr_used
- stub_entry
->group
->lr_restore
;
11756 stub_entry
->group
->eh_size
+= eh_advance_size (delta
) + 6;
11757 stub_entry
->group
->lr_restore
= lr_used
+ 8;
11760 /* If the branch can't reach, use a plt_branch. */
11761 if (off
+ (1 << 25) >= (bfd_vma
) (1 << 26))
11763 stub_entry
->stub_type
+= (ppc_stub_plt_branch_notoc
11764 - ppc_stub_long_branch_notoc
);
11767 else if (info
->emitrelocations
)
11768 stub_entry
->group
->stub_sec
->reloc_count
+=1;
11771 case ppc_stub_plt_call_notoc
:
11772 case ppc_stub_plt_call_both
:
11773 off
= (stub_entry
->stub_offset
11774 + stub_entry
->group
->stub_sec
->output_offset
11775 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11776 if (stub_entry
->stub_type
== ppc_stub_plt_call_both
)
11778 targ
= stub_entry
->plt_ent
->plt
.offset
& ~1;
11779 if (targ
>= (bfd_vma
) -2)
11782 plt
= htab
->elf
.splt
;
11783 if (!htab
->elf
.dynamic_sections_created
11784 || stub_entry
->h
== NULL
11785 || stub_entry
->h
->elf
.dynindx
== -1)
11787 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
11788 plt
= htab
->elf
.iplt
;
11790 plt
= htab
->pltlocal
;
11792 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
11796 if (htab
->params
->plt_stub_align
!= 0)
11798 unsigned pad
= plt_stub_pad (htab
, stub_entry
, off
);
11800 stub_entry
->group
->stub_sec
->size
+= pad
;
11801 stub_entry
->stub_offset
= stub_entry
->group
->stub_sec
->size
;
11805 if (info
->emitrelocations
)
11807 unsigned int num_rel
;
11808 if (htab
->powerxx_stubs
)
11809 num_rel
= num_relocs_for_powerxx_offset (off
, odd
);
11811 num_rel
= num_relocs_for_offset (off
- 8);
11812 stub_entry
->group
->stub_sec
->reloc_count
+= num_rel
;
11813 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
11816 size
= plt_stub_size (htab
, stub_entry
, off
);
11818 if (!htab
->powerxx_stubs
)
11820 /* After the bcl, lr has been modified so we need to emit
11821 .eh_frame info saying the return address is in r12. */
11822 lr_used
= stub_entry
->stub_offset
+ 8;
11823 if (stub_entry
->stub_type
== ppc_stub_plt_call_both
)
11825 /* The eh_frame info will consist of a DW_CFA_advance_loc or
11826 variant, DW_CFA_register, 65, 12, DW_CFA_advance_loc+2,
11827 DW_CFA_restore_extended 65. */
11828 delta
= lr_used
- stub_entry
->group
->lr_restore
;
11829 stub_entry
->group
->eh_size
+= eh_advance_size (delta
) + 6;
11830 stub_entry
->group
->lr_restore
= lr_used
+ 8;
11834 case ppc_stub_plt_call
:
11835 case ppc_stub_plt_call_r2save
:
11836 targ
= stub_entry
->plt_ent
->plt
.offset
& ~(bfd_vma
) 1;
11837 if (targ
>= (bfd_vma
) -2)
11839 plt
= htab
->elf
.splt
;
11840 if (!htab
->elf
.dynamic_sections_created
11841 || stub_entry
->h
== NULL
11842 || stub_entry
->h
->elf
.dynindx
== -1)
11844 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
11845 plt
= htab
->elf
.iplt
;
11847 plt
= htab
->pltlocal
;
11849 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
11851 off
= (elf_gp (info
->output_bfd
)
11852 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
11855 if (htab
->params
->plt_stub_align
!= 0)
11857 unsigned pad
= plt_stub_pad (htab
, stub_entry
, off
);
11859 stub_entry
->group
->stub_sec
->size
+= pad
;
11860 stub_entry
->stub_offset
= stub_entry
->group
->stub_sec
->size
;
11863 if (info
->emitrelocations
)
11865 stub_entry
->group
->stub_sec
->reloc_count
11866 += ((PPC_HA (off
) != 0)
11868 ? 2 + (htab
->params
->plt_static_chain
11869 && PPC_HA (off
+ 16) == PPC_HA (off
))
11871 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
11874 size
= plt_stub_size (htab
, stub_entry
, off
);
11876 if (stub_entry
->h
!= NULL
11877 && (stub_entry
->h
== htab
->tls_get_addr_fd
11878 || stub_entry
->h
== htab
->tls_get_addr
)
11879 && htab
->params
->tls_get_addr_opt
11880 && stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
11882 /* After the bctrl, lr has been modified so we need to
11883 emit .eh_frame info saying the return address is
11884 on the stack. In fact we put the EH info specifying
11885 that the return address is on the stack *at* the
11886 call rather than after it, because the EH info for a
11887 call needs to be specified by that point.
11888 See libgcc/unwind-dw2.c execute_cfa_program. */
11889 lr_used
= stub_entry
->stub_offset
+ size
- 20;
11890 /* The eh_frame info will consist of a DW_CFA_advance_loc
11891 or variant, DW_CFA_offset_externed_sf, 65, -stackoff,
11892 DW_CFA_advance_loc+4, DW_CFA_restore_extended, 65. */
11893 delta
= lr_used
- stub_entry
->group
->lr_restore
;
11894 stub_entry
->group
->eh_size
+= eh_advance_size (delta
) + 6;
11895 stub_entry
->group
->lr_restore
= size
- 4;
11904 stub_entry
->group
->stub_sec
->size
+= size
;
11908 /* Set up various things so that we can make a list of input sections
11909 for each output section included in the link. Returns -1 on error,
11910 0 when no stubs will be needed, and 1 on success. */
11913 ppc64_elf_setup_section_lists (struct bfd_link_info
*info
)
11917 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
11922 htab
->sec_info_arr_size
= _bfd_section_id
;
11923 amt
= sizeof (*htab
->sec_info
) * (htab
->sec_info_arr_size
);
11924 htab
->sec_info
= bfd_zmalloc (amt
);
11925 if (htab
->sec_info
== NULL
)
11928 /* Set toc_off for com, und, abs and ind sections. */
11929 for (id
= 0; id
< 3; id
++)
11930 htab
->sec_info
[id
].toc_off
= TOC_BASE_OFF
;
11935 /* Set up for first pass at multitoc partitioning. */
11938 ppc64_elf_start_multitoc_partition (struct bfd_link_info
*info
)
11940 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
11942 htab
->toc_curr
= ppc64_elf_set_toc (info
, info
->output_bfd
);
11943 htab
->toc_bfd
= NULL
;
11944 htab
->toc_first_sec
= NULL
;
11947 /* The linker repeatedly calls this function for each TOC input section
11948 and linker generated GOT section. Group input bfds such that the toc
11949 within a group is less than 64k in size. */
11952 ppc64_elf_next_toc_section (struct bfd_link_info
*info
, asection
*isec
)
11954 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
11955 bfd_vma addr
, off
, limit
;
11960 if (!htab
->second_toc_pass
)
11962 /* Keep track of the first .toc or .got section for this input bfd. */
11963 bfd_boolean new_bfd
= htab
->toc_bfd
!= isec
->owner
;
11967 htab
->toc_bfd
= isec
->owner
;
11968 htab
->toc_first_sec
= isec
;
11971 addr
= isec
->output_offset
+ isec
->output_section
->vma
;
11972 off
= addr
- htab
->toc_curr
;
11973 limit
= 0x80008000;
11974 if (ppc64_elf_tdata (isec
->owner
)->has_small_toc_reloc
)
11976 if (off
+ isec
->size
> limit
)
11978 addr
= (htab
->toc_first_sec
->output_offset
11979 + htab
->toc_first_sec
->output_section
->vma
);
11980 htab
->toc_curr
= addr
;
11981 htab
->toc_curr
&= -TOC_BASE_ALIGN
;
11984 /* toc_curr is the base address of this toc group. Set elf_gp
11985 for the input section to be the offset relative to the
11986 output toc base plus 0x8000. Making the input elf_gp an
11987 offset allows us to move the toc as a whole without
11988 recalculating input elf_gp. */
11989 off
= htab
->toc_curr
- elf_gp (info
->output_bfd
);
11990 off
+= TOC_BASE_OFF
;
11992 /* Die if someone uses a linker script that doesn't keep input
11993 file .toc and .got together. */
11995 && elf_gp (isec
->owner
) != 0
11996 && elf_gp (isec
->owner
) != off
)
11999 elf_gp (isec
->owner
) = off
;
12003 /* During the second pass toc_first_sec points to the start of
12004 a toc group, and toc_curr is used to track the old elf_gp.
12005 We use toc_bfd to ensure we only look at each bfd once. */
12006 if (htab
->toc_bfd
== isec
->owner
)
12008 htab
->toc_bfd
= isec
->owner
;
12010 if (htab
->toc_first_sec
== NULL
12011 || htab
->toc_curr
!= elf_gp (isec
->owner
))
12013 htab
->toc_curr
= elf_gp (isec
->owner
);
12014 htab
->toc_first_sec
= isec
;
12016 addr
= (htab
->toc_first_sec
->output_offset
12017 + htab
->toc_first_sec
->output_section
->vma
);
12018 off
= addr
- elf_gp (info
->output_bfd
) + TOC_BASE_OFF
;
12019 elf_gp (isec
->owner
) = off
;
12024 /* Called via elf_link_hash_traverse to merge GOT entries for global
12028 merge_global_got (struct elf_link_hash_entry
*h
, void *inf ATTRIBUTE_UNUSED
)
12030 if (h
->root
.type
== bfd_link_hash_indirect
)
12033 merge_got_entries (&h
->got
.glist
);
12038 /* Called via elf_link_hash_traverse to allocate GOT entries for global
12042 reallocate_got (struct elf_link_hash_entry
*h
, void *inf
)
12044 struct got_entry
*gent
;
12046 if (h
->root
.type
== bfd_link_hash_indirect
)
12049 for (gent
= h
->got
.glist
; gent
!= NULL
; gent
= gent
->next
)
12050 if (!gent
->is_indirect
)
12051 allocate_got (h
, (struct bfd_link_info
*) inf
, gent
);
12055 /* Called on the first multitoc pass after the last call to
12056 ppc64_elf_next_toc_section. This function removes duplicate GOT
12060 ppc64_elf_layout_multitoc (struct bfd_link_info
*info
)
12062 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12063 struct bfd
*ibfd
, *ibfd2
;
12064 bfd_boolean done_something
;
12066 htab
->multi_toc_needed
= htab
->toc_curr
!= elf_gp (info
->output_bfd
);
12068 if (!htab
->do_multi_toc
)
12071 /* Merge global sym got entries within a toc group. */
12072 elf_link_hash_traverse (&htab
->elf
, merge_global_got
, info
);
12074 /* And tlsld_got. */
12075 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12077 struct got_entry
*ent
, *ent2
;
12079 if (!is_ppc64_elf (ibfd
))
12082 ent
= ppc64_tlsld_got (ibfd
);
12083 if (!ent
->is_indirect
12084 && ent
->got
.offset
!= (bfd_vma
) -1)
12086 for (ibfd2
= ibfd
->link
.next
; ibfd2
!= NULL
; ibfd2
= ibfd2
->link
.next
)
12088 if (!is_ppc64_elf (ibfd2
))
12091 ent2
= ppc64_tlsld_got (ibfd2
);
12092 if (!ent2
->is_indirect
12093 && ent2
->got
.offset
!= (bfd_vma
) -1
12094 && elf_gp (ibfd2
) == elf_gp (ibfd
))
12096 ent2
->is_indirect
= TRUE
;
12097 ent2
->got
.ent
= ent
;
12103 /* Zap sizes of got sections. */
12104 htab
->elf
.irelplt
->rawsize
= htab
->elf
.irelplt
->size
;
12105 htab
->elf
.irelplt
->size
-= htab
->got_reli_size
;
12106 htab
->got_reli_size
= 0;
12108 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12110 asection
*got
, *relgot
;
12112 if (!is_ppc64_elf (ibfd
))
12115 got
= ppc64_elf_tdata (ibfd
)->got
;
12118 got
->rawsize
= got
->size
;
12120 relgot
= ppc64_elf_tdata (ibfd
)->relgot
;
12121 relgot
->rawsize
= relgot
->size
;
12126 /* Now reallocate the got, local syms first. We don't need to
12127 allocate section contents again since we never increase size. */
12128 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12130 struct got_entry
**lgot_ents
;
12131 struct got_entry
**end_lgot_ents
;
12132 struct plt_entry
**local_plt
;
12133 struct plt_entry
**end_local_plt
;
12134 unsigned char *lgot_masks
;
12135 bfd_size_type locsymcount
;
12136 Elf_Internal_Shdr
*symtab_hdr
;
12139 if (!is_ppc64_elf (ibfd
))
12142 lgot_ents
= elf_local_got_ents (ibfd
);
12146 symtab_hdr
= &elf_symtab_hdr (ibfd
);
12147 locsymcount
= symtab_hdr
->sh_info
;
12148 end_lgot_ents
= lgot_ents
+ locsymcount
;
12149 local_plt
= (struct plt_entry
**) end_lgot_ents
;
12150 end_local_plt
= local_plt
+ locsymcount
;
12151 lgot_masks
= (unsigned char *) end_local_plt
;
12152 s
= ppc64_elf_tdata (ibfd
)->got
;
12153 for (; lgot_ents
< end_lgot_ents
; ++lgot_ents
, ++lgot_masks
)
12155 struct got_entry
*ent
;
12157 for (ent
= *lgot_ents
; ent
!= NULL
; ent
= ent
->next
)
12159 unsigned int ent_size
= 8;
12160 unsigned int rel_size
= sizeof (Elf64_External_Rela
);
12162 ent
->got
.offset
= s
->size
;
12163 if ((ent
->tls_type
& *lgot_masks
& TLS_GD
) != 0)
12168 s
->size
+= ent_size
;
12169 if ((*lgot_masks
& (TLS_TLS
| PLT_IFUNC
)) == PLT_IFUNC
)
12171 htab
->elf
.irelplt
->size
+= rel_size
;
12172 htab
->got_reli_size
+= rel_size
;
12174 else if (bfd_link_pic (info
)
12175 && !((ent
->tls_type
& TLS_TPREL
) != 0
12176 && bfd_link_executable (info
)))
12178 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
12179 srel
->size
+= rel_size
;
12185 elf_link_hash_traverse (&htab
->elf
, reallocate_got
, info
);
12187 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12189 struct got_entry
*ent
;
12191 if (!is_ppc64_elf (ibfd
))
12194 ent
= ppc64_tlsld_got (ibfd
);
12195 if (!ent
->is_indirect
12196 && ent
->got
.offset
!= (bfd_vma
) -1)
12198 asection
*s
= ppc64_elf_tdata (ibfd
)->got
;
12199 ent
->got
.offset
= s
->size
;
12201 if (bfd_link_pic (info
))
12203 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
12204 srel
->size
+= sizeof (Elf64_External_Rela
);
12209 done_something
= htab
->elf
.irelplt
->rawsize
!= htab
->elf
.irelplt
->size
;
12210 if (!done_something
)
12211 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12215 if (!is_ppc64_elf (ibfd
))
12218 got
= ppc64_elf_tdata (ibfd
)->got
;
12221 done_something
= got
->rawsize
!= got
->size
;
12222 if (done_something
)
12227 if (done_something
)
12228 (*htab
->params
->layout_sections_again
) ();
12230 /* Set up for second pass over toc sections to recalculate elf_gp
12231 on input sections. */
12232 htab
->toc_bfd
= NULL
;
12233 htab
->toc_first_sec
= NULL
;
12234 htab
->second_toc_pass
= TRUE
;
12235 return done_something
;
12238 /* Called after second pass of multitoc partitioning. */
12241 ppc64_elf_finish_multitoc_partition (struct bfd_link_info
*info
)
12243 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12245 /* After the second pass, toc_curr tracks the TOC offset used
12246 for code sections below in ppc64_elf_next_input_section. */
12247 htab
->toc_curr
= TOC_BASE_OFF
;
12250 /* No toc references were found in ISEC. If the code in ISEC makes no
12251 calls, then there's no need to use toc adjusting stubs when branching
12252 into ISEC. Actually, indirect calls from ISEC are OK as they will
12253 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
12254 needed, and 2 if a cyclical call-graph was found but no other reason
12255 for a stub was detected. If called from the top level, a return of
12256 2 means the same as a return of 0. */
12259 toc_adjusting_stub_needed (struct bfd_link_info
*info
, asection
*isec
)
12263 /* Mark this section as checked. */
12264 isec
->call_check_done
= 1;
12266 /* We know none of our code bearing sections will need toc stubs. */
12267 if ((isec
->flags
& SEC_LINKER_CREATED
) != 0)
12270 if (isec
->size
== 0)
12273 if (isec
->output_section
== NULL
)
12277 if (isec
->reloc_count
!= 0)
12279 Elf_Internal_Rela
*relstart
, *rel
;
12280 Elf_Internal_Sym
*local_syms
;
12281 struct ppc_link_hash_table
*htab
;
12283 relstart
= _bfd_elf_link_read_relocs (isec
->owner
, isec
, NULL
, NULL
,
12284 info
->keep_memory
);
12285 if (relstart
== NULL
)
12288 /* Look for branches to outside of this section. */
12290 htab
= ppc_hash_table (info
);
12294 for (rel
= relstart
; rel
< relstart
+ isec
->reloc_count
; ++rel
)
12296 enum elf_ppc64_reloc_type r_type
;
12297 unsigned long r_symndx
;
12298 struct elf_link_hash_entry
*h
;
12299 struct ppc_link_hash_entry
*eh
;
12300 Elf_Internal_Sym
*sym
;
12302 struct _opd_sec_data
*opd
;
12306 r_type
= ELF64_R_TYPE (rel
->r_info
);
12307 if (r_type
!= R_PPC64_REL24
12308 && r_type
!= R_PPC64_REL24_NOTOC
12309 && r_type
!= R_PPC64_REL14
12310 && r_type
!= R_PPC64_REL14_BRTAKEN
12311 && r_type
!= R_PPC64_REL14_BRNTAKEN
12312 && r_type
!= R_PPC64_PLTCALL
12313 && r_type
!= R_PPC64_PLTCALL_NOTOC
)
12316 r_symndx
= ELF64_R_SYM (rel
->r_info
);
12317 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
, r_symndx
,
12324 /* Calls to dynamic lib functions go through a plt call stub
12326 eh
= (struct ppc_link_hash_entry
*) h
;
12328 && (eh
->elf
.plt
.plist
!= NULL
12330 && ppc_follow_link (eh
->oh
)->elf
.plt
.plist
!= NULL
)))
12336 if (sym_sec
== NULL
)
12337 /* Ignore other undefined symbols. */
12340 /* Assume branches to other sections not included in the
12341 link need stubs too, to cover -R and absolute syms. */
12342 if (sym_sec
->output_section
== NULL
)
12349 sym_value
= sym
->st_value
;
12352 if (h
->root
.type
!= bfd_link_hash_defined
12353 && h
->root
.type
!= bfd_link_hash_defweak
)
12355 sym_value
= h
->root
.u
.def
.value
;
12357 sym_value
+= rel
->r_addend
;
12359 /* If this branch reloc uses an opd sym, find the code section. */
12360 opd
= get_opd_info (sym_sec
);
12363 if (h
== NULL
&& opd
->adjust
!= NULL
)
12367 adjust
= opd
->adjust
[OPD_NDX (sym_value
)];
12369 /* Assume deleted functions won't ever be called. */
12371 sym_value
+= adjust
;
12374 dest
= opd_entry_value (sym_sec
, sym_value
,
12375 &sym_sec
, NULL
, FALSE
);
12376 if (dest
== (bfd_vma
) -1)
12381 + sym_sec
->output_offset
12382 + sym_sec
->output_section
->vma
);
12384 /* Ignore branch to self. */
12385 if (sym_sec
== isec
)
12388 /* If the called function uses the toc, we need a stub. */
12389 if (sym_sec
->has_toc_reloc
12390 || sym_sec
->makes_toc_func_call
)
12396 /* Assume any branch that needs a long branch stub might in fact
12397 need a plt_branch stub. A plt_branch stub uses r2. */
12398 else if (dest
- (isec
->output_offset
12399 + isec
->output_section
->vma
12400 + rel
->r_offset
) + (1 << 25)
12401 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
12409 /* If calling back to a section in the process of being
12410 tested, we can't say for sure that no toc adjusting stubs
12411 are needed, so don't return zero. */
12412 else if (sym_sec
->call_check_in_progress
)
12415 /* Branches to another section that itself doesn't have any TOC
12416 references are OK. Recursively call ourselves to check. */
12417 else if (!sym_sec
->call_check_done
)
12421 /* Mark current section as indeterminate, so that other
12422 sections that call back to current won't be marked as
12424 isec
->call_check_in_progress
= 1;
12425 recur
= toc_adjusting_stub_needed (info
, sym_sec
);
12426 isec
->call_check_in_progress
= 0;
12437 if (local_syms
!= NULL
12438 && (elf_symtab_hdr (isec
->owner
).contents
12439 != (unsigned char *) local_syms
))
12441 if (elf_section_data (isec
)->relocs
!= relstart
)
12446 && isec
->map_head
.s
!= NULL
12447 && (strcmp (isec
->output_section
->name
, ".init") == 0
12448 || strcmp (isec
->output_section
->name
, ".fini") == 0))
12450 if (isec
->map_head
.s
->has_toc_reloc
12451 || isec
->map_head
.s
->makes_toc_func_call
)
12453 else if (!isec
->map_head
.s
->call_check_done
)
12456 isec
->call_check_in_progress
= 1;
12457 recur
= toc_adjusting_stub_needed (info
, isec
->map_head
.s
);
12458 isec
->call_check_in_progress
= 0;
12465 isec
->makes_toc_func_call
= 1;
12470 /* The linker repeatedly calls this function for each input section,
12471 in the order that input sections are linked into output sections.
12472 Build lists of input sections to determine groupings between which
12473 we may insert linker stubs. */
12476 ppc64_elf_next_input_section (struct bfd_link_info
*info
, asection
*isec
)
12478 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12483 if ((isec
->output_section
->flags
& SEC_CODE
) != 0
12484 && isec
->output_section
->id
< htab
->sec_info_arr_size
)
12486 /* This happens to make the list in reverse order,
12487 which is what we want. */
12488 htab
->sec_info
[isec
->id
].u
.list
12489 = htab
->sec_info
[isec
->output_section
->id
].u
.list
;
12490 htab
->sec_info
[isec
->output_section
->id
].u
.list
= isec
;
12493 if (htab
->multi_toc_needed
)
12495 /* Analyse sections that aren't already flagged as needing a
12496 valid toc pointer. Exclude .fixup for the linux kernel.
12497 .fixup contains branches, but only back to the function that
12498 hit an exception. */
12499 if (!(isec
->has_toc_reloc
12500 || (isec
->flags
& SEC_CODE
) == 0
12501 || strcmp (isec
->name
, ".fixup") == 0
12502 || isec
->call_check_done
))
12504 if (toc_adjusting_stub_needed (info
, isec
) < 0)
12507 /* Make all sections use the TOC assigned for this object file.
12508 This will be wrong for pasted sections; We fix that in
12509 check_pasted_section(). */
12510 if (elf_gp (isec
->owner
) != 0)
12511 htab
->toc_curr
= elf_gp (isec
->owner
);
12514 htab
->sec_info
[isec
->id
].toc_off
= htab
->toc_curr
;
12518 /* Check that all .init and .fini sections use the same toc, if they
12519 have toc relocs. */
12522 check_pasted_section (struct bfd_link_info
*info
, const char *name
)
12524 asection
*o
= bfd_get_section_by_name (info
->output_bfd
, name
);
12528 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12529 bfd_vma toc_off
= 0;
12532 for (i
= o
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
12533 if (i
->has_toc_reloc
)
12536 toc_off
= htab
->sec_info
[i
->id
].toc_off
;
12537 else if (toc_off
!= htab
->sec_info
[i
->id
].toc_off
)
12542 for (i
= o
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
12543 if (i
->makes_toc_func_call
)
12545 toc_off
= htab
->sec_info
[i
->id
].toc_off
;
12549 /* Make sure the whole pasted function uses the same toc offset. */
12551 for (i
= o
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
12552 htab
->sec_info
[i
->id
].toc_off
= toc_off
;
12558 ppc64_elf_check_init_fini (struct bfd_link_info
*info
)
12560 return (check_pasted_section (info
, ".init")
12561 & check_pasted_section (info
, ".fini"));
12564 /* See whether we can group stub sections together. Grouping stub
12565 sections may result in fewer stubs. More importantly, we need to
12566 put all .init* and .fini* stubs at the beginning of the .init or
12567 .fini output sections respectively, because glibc splits the
12568 _init and _fini functions into multiple parts. Putting a stub in
12569 the middle of a function is not a good idea. */
12572 group_sections (struct bfd_link_info
*info
,
12573 bfd_size_type stub_group_size
,
12574 bfd_boolean stubs_always_before_branch
)
12576 struct ppc_link_hash_table
*htab
;
12578 bfd_boolean suppress_size_errors
;
12580 htab
= ppc_hash_table (info
);
12584 suppress_size_errors
= FALSE
;
12585 if (stub_group_size
== 1)
12587 /* Default values. */
12588 if (stubs_always_before_branch
)
12589 stub_group_size
= 0x1e00000;
12591 stub_group_size
= 0x1c00000;
12592 suppress_size_errors
= TRUE
;
12595 for (osec
= info
->output_bfd
->sections
; osec
!= NULL
; osec
= osec
->next
)
12599 if (osec
->id
>= htab
->sec_info_arr_size
)
12602 tail
= htab
->sec_info
[osec
->id
].u
.list
;
12603 while (tail
!= NULL
)
12607 bfd_size_type total
;
12608 bfd_boolean big_sec
;
12610 struct map_stub
*group
;
12611 bfd_size_type group_size
;
12614 total
= tail
->size
;
12615 group_size
= (ppc64_elf_section_data (tail
) != NULL
12616 && ppc64_elf_section_data (tail
)->has_14bit_branch
12617 ? stub_group_size
>> 10 : stub_group_size
);
12619 big_sec
= total
> group_size
;
12620 if (big_sec
&& !suppress_size_errors
)
12621 /* xgettext:c-format */
12622 _bfd_error_handler (_("%pB section %pA exceeds stub group size"),
12623 tail
->owner
, tail
);
12624 curr_toc
= htab
->sec_info
[tail
->id
].toc_off
;
12626 while ((prev
= htab
->sec_info
[curr
->id
].u
.list
) != NULL
12627 && ((total
+= curr
->output_offset
- prev
->output_offset
)
12628 < (ppc64_elf_section_data (prev
) != NULL
12629 && ppc64_elf_section_data (prev
)->has_14bit_branch
12630 ? (group_size
= stub_group_size
>> 10) : group_size
))
12631 && htab
->sec_info
[prev
->id
].toc_off
== curr_toc
)
12634 /* OK, the size from the start of CURR to the end is less
12635 than group_size and thus can be handled by one stub
12636 section. (or the tail section is itself larger than
12637 group_size, in which case we may be toast.) We should
12638 really be keeping track of the total size of stubs added
12639 here, as stubs contribute to the final output section
12640 size. That's a little tricky, and this way will only
12641 break if stubs added make the total size more than 2^25,
12642 ie. for the default stub_group_size, if stubs total more
12643 than 2097152 bytes, or nearly 75000 plt call stubs. */
12644 group
= bfd_alloc (curr
->owner
, sizeof (*group
));
12647 group
->link_sec
= curr
;
12648 group
->stub_sec
= NULL
;
12649 group
->needs_save_res
= 0;
12650 group
->lr_restore
= 0;
12651 group
->eh_size
= 0;
12652 group
->eh_base
= 0;
12653 group
->next
= htab
->group
;
12654 htab
->group
= group
;
12657 prev
= htab
->sec_info
[tail
->id
].u
.list
;
12658 /* Set up this stub group. */
12659 htab
->sec_info
[tail
->id
].u
.group
= group
;
12661 while (tail
!= curr
&& (tail
= prev
) != NULL
);
12663 /* But wait, there's more! Input sections up to group_size
12664 bytes before the stub section can be handled by it too.
12665 Don't do this if we have a really large section after the
12666 stubs, as adding more stubs increases the chance that
12667 branches may not reach into the stub section. */
12668 if (!stubs_always_before_branch
&& !big_sec
)
12671 while (prev
!= NULL
12672 && ((total
+= tail
->output_offset
- prev
->output_offset
)
12673 < (ppc64_elf_section_data (prev
) != NULL
12674 && ppc64_elf_section_data (prev
)->has_14bit_branch
12675 ? (group_size
= stub_group_size
>> 10)
12677 && htab
->sec_info
[prev
->id
].toc_off
== curr_toc
)
12680 prev
= htab
->sec_info
[tail
->id
].u
.list
;
12681 htab
->sec_info
[tail
->id
].u
.group
= group
;
12690 static const unsigned char glink_eh_frame_cie
[] =
12692 0, 0, 0, 16, /* length. */
12693 0, 0, 0, 0, /* id. */
12694 1, /* CIE version. */
12695 'z', 'R', 0, /* Augmentation string. */
12696 4, /* Code alignment. */
12697 0x78, /* Data alignment. */
12699 1, /* Augmentation size. */
12700 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding. */
12701 DW_CFA_def_cfa
, 1, 0 /* def_cfa: r1 offset 0. */
12704 /* Stripping output sections is normally done before dynamic section
12705 symbols have been allocated. This function is called later, and
12706 handles cases like htab->brlt which is mapped to its own output
12710 maybe_strip_output (struct bfd_link_info
*info
, asection
*isec
)
12712 if (isec
->size
== 0
12713 && isec
->output_section
->size
== 0
12714 && !(isec
->output_section
->flags
& SEC_KEEP
)
12715 && !bfd_section_removed_from_list (info
->output_bfd
,
12716 isec
->output_section
)
12717 && elf_section_data (isec
->output_section
)->dynindx
== 0)
12719 isec
->output_section
->flags
|= SEC_EXCLUDE
;
12720 bfd_section_list_remove (info
->output_bfd
, isec
->output_section
);
12721 info
->output_bfd
->section_count
--;
12725 /* Determine and set the size of the stub section for a final link.
12727 The basic idea here is to examine all the relocations looking for
12728 PC-relative calls to a target that is unreachable with a "bl"
12732 ppc64_elf_size_stubs (struct bfd_link_info
*info
)
12734 bfd_size_type stub_group_size
;
12735 bfd_boolean stubs_always_before_branch
;
12736 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12741 if (htab
->params
->plt_thread_safe
== -1 && !bfd_link_executable (info
))
12742 htab
->params
->plt_thread_safe
= 1;
12743 if (!htab
->opd_abi
)
12744 htab
->params
->plt_thread_safe
= 0;
12745 else if (htab
->params
->plt_thread_safe
== -1)
12747 static const char *const thread_starter
[] =
12751 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12753 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12754 "mq_notify", "create_timer",
12759 "GOMP_parallel_start",
12760 "GOMP_parallel_loop_static",
12761 "GOMP_parallel_loop_static_start",
12762 "GOMP_parallel_loop_dynamic",
12763 "GOMP_parallel_loop_dynamic_start",
12764 "GOMP_parallel_loop_guided",
12765 "GOMP_parallel_loop_guided_start",
12766 "GOMP_parallel_loop_runtime",
12767 "GOMP_parallel_loop_runtime_start",
12768 "GOMP_parallel_sections",
12769 "GOMP_parallel_sections_start",
12775 for (i
= 0; i
< ARRAY_SIZE (thread_starter
); i
++)
12777 struct elf_link_hash_entry
*h
;
12778 h
= elf_link_hash_lookup (&htab
->elf
, thread_starter
[i
],
12779 FALSE
, FALSE
, TRUE
);
12780 htab
->params
->plt_thread_safe
= h
!= NULL
&& h
->ref_regular
;
12781 if (htab
->params
->plt_thread_safe
)
12785 stubs_always_before_branch
= htab
->params
->group_size
< 0;
12786 if (htab
->params
->group_size
< 0)
12787 stub_group_size
= -htab
->params
->group_size
;
12789 stub_group_size
= htab
->params
->group_size
;
12791 if (!group_sections (info
, stub_group_size
, stubs_always_before_branch
))
12794 #define STUB_SHRINK_ITER 20
12795 /* Loop until no stubs added. After iteration 20 of this loop we may
12796 exit on a stub section shrinking. This is to break out of a
12797 pathological case where adding stubs on one iteration decreases
12798 section gaps (perhaps due to alignment), which then requires
12799 fewer or smaller stubs on the next iteration. */
12804 unsigned int bfd_indx
;
12805 struct map_stub
*group
;
12807 htab
->stub_iteration
+= 1;
12809 for (input_bfd
= info
->input_bfds
, bfd_indx
= 0;
12811 input_bfd
= input_bfd
->link
.next
, bfd_indx
++)
12813 Elf_Internal_Shdr
*symtab_hdr
;
12815 Elf_Internal_Sym
*local_syms
= NULL
;
12817 if (!is_ppc64_elf (input_bfd
))
12820 /* We'll need the symbol table in a second. */
12821 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
12822 if (symtab_hdr
->sh_info
== 0)
12825 /* Walk over each section attached to the input bfd. */
12826 for (section
= input_bfd
->sections
;
12828 section
= section
->next
)
12830 Elf_Internal_Rela
*internal_relocs
, *irelaend
, *irela
;
12832 /* If there aren't any relocs, then there's nothing more
12834 if ((section
->flags
& SEC_RELOC
) == 0
12835 || (section
->flags
& SEC_ALLOC
) == 0
12836 || (section
->flags
& SEC_LOAD
) == 0
12837 || (section
->flags
& SEC_CODE
) == 0
12838 || section
->reloc_count
== 0)
12841 /* If this section is a link-once section that will be
12842 discarded, then don't create any stubs. */
12843 if (section
->output_section
== NULL
12844 || section
->output_section
->owner
!= info
->output_bfd
)
12847 /* Get the relocs. */
12849 = _bfd_elf_link_read_relocs (input_bfd
, section
, NULL
, NULL
,
12850 info
->keep_memory
);
12851 if (internal_relocs
== NULL
)
12852 goto error_ret_free_local
;
12854 /* Now examine each relocation. */
12855 irela
= internal_relocs
;
12856 irelaend
= irela
+ section
->reloc_count
;
12857 for (; irela
< irelaend
; irela
++)
12859 enum elf_ppc64_reloc_type r_type
;
12860 unsigned int r_indx
;
12861 enum ppc_stub_type stub_type
;
12862 struct ppc_stub_hash_entry
*stub_entry
;
12863 asection
*sym_sec
, *code_sec
;
12864 bfd_vma sym_value
, code_value
;
12865 bfd_vma destination
;
12866 unsigned long local_off
;
12867 bfd_boolean ok_dest
;
12868 struct ppc_link_hash_entry
*hash
;
12869 struct ppc_link_hash_entry
*fdh
;
12870 struct elf_link_hash_entry
*h
;
12871 Elf_Internal_Sym
*sym
;
12873 const asection
*id_sec
;
12874 struct _opd_sec_data
*opd
;
12875 struct plt_entry
*plt_ent
;
12877 r_type
= ELF64_R_TYPE (irela
->r_info
);
12878 r_indx
= ELF64_R_SYM (irela
->r_info
);
12880 if (r_type
>= R_PPC64_max
)
12882 bfd_set_error (bfd_error_bad_value
);
12883 goto error_ret_free_internal
;
12886 /* Only look for stubs on branch instructions. */
12887 if (r_type
!= R_PPC64_REL24
12888 && r_type
!= R_PPC64_REL24_NOTOC
12889 && r_type
!= R_PPC64_REL14
12890 && r_type
!= R_PPC64_REL14_BRTAKEN
12891 && r_type
!= R_PPC64_REL14_BRNTAKEN
)
12894 /* Now determine the call target, its name, value,
12896 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
12897 r_indx
, input_bfd
))
12898 goto error_ret_free_internal
;
12899 hash
= (struct ppc_link_hash_entry
*) h
;
12906 sym_value
= sym
->st_value
;
12907 if (sym_sec
!= NULL
12908 && sym_sec
->output_section
!= NULL
)
12911 else if (hash
->elf
.root
.type
== bfd_link_hash_defined
12912 || hash
->elf
.root
.type
== bfd_link_hash_defweak
)
12914 sym_value
= hash
->elf
.root
.u
.def
.value
;
12915 if (sym_sec
->output_section
!= NULL
)
12918 else if (hash
->elf
.root
.type
== bfd_link_hash_undefweak
12919 || hash
->elf
.root
.type
== bfd_link_hash_undefined
)
12921 /* Recognise an old ABI func code entry sym, and
12922 use the func descriptor sym instead if it is
12924 if (hash
->elf
.root
.root
.string
[0] == '.'
12925 && hash
->oh
!= NULL
)
12927 fdh
= ppc_follow_link (hash
->oh
);
12928 if (fdh
->elf
.root
.type
== bfd_link_hash_defined
12929 || fdh
->elf
.root
.type
== bfd_link_hash_defweak
)
12931 sym_sec
= fdh
->elf
.root
.u
.def
.section
;
12932 sym_value
= fdh
->elf
.root
.u
.def
.value
;
12933 if (sym_sec
->output_section
!= NULL
)
12942 bfd_set_error (bfd_error_bad_value
);
12943 goto error_ret_free_internal
;
12950 sym_value
+= irela
->r_addend
;
12951 destination
= (sym_value
12952 + sym_sec
->output_offset
12953 + sym_sec
->output_section
->vma
);
12954 local_off
= PPC64_LOCAL_ENTRY_OFFSET (hash
12959 code_sec
= sym_sec
;
12960 code_value
= sym_value
;
12961 opd
= get_opd_info (sym_sec
);
12966 if (hash
== NULL
&& opd
->adjust
!= NULL
)
12968 long adjust
= opd
->adjust
[OPD_NDX (sym_value
)];
12971 code_value
+= adjust
;
12972 sym_value
+= adjust
;
12974 dest
= opd_entry_value (sym_sec
, sym_value
,
12975 &code_sec
, &code_value
, FALSE
);
12976 if (dest
!= (bfd_vma
) -1)
12978 destination
= dest
;
12981 /* Fixup old ABI sym to point at code
12983 hash
->elf
.root
.type
= bfd_link_hash_defweak
;
12984 hash
->elf
.root
.u
.def
.section
= code_sec
;
12985 hash
->elf
.root
.u
.def
.value
= code_value
;
12990 /* Determine what (if any) linker stub is needed. */
12992 stub_type
= ppc_type_of_stub (section
, irela
, &hash
,
12993 &plt_ent
, destination
,
12996 if (r_type
== R_PPC64_REL24_NOTOC
)
12998 if (stub_type
== ppc_stub_plt_call
)
12999 stub_type
= ppc_stub_plt_call_notoc
;
13000 else if (stub_type
== ppc_stub_long_branch
13001 || (code_sec
!= NULL
13002 && code_sec
->output_section
!= NULL
13003 && (((hash
? hash
->elf
.other
: sym
->st_other
)
13004 & STO_PPC64_LOCAL_MASK
)
13005 > 1 << STO_PPC64_LOCAL_BIT
)))
13006 stub_type
= ppc_stub_long_branch_notoc
;
13008 else if (stub_type
!= ppc_stub_plt_call
)
13010 /* Check whether we need a TOC adjusting stub.
13011 Since the linker pastes together pieces from
13012 different object files when creating the
13013 _init and _fini functions, it may be that a
13014 call to what looks like a local sym is in
13015 fact a call needing a TOC adjustment. */
13016 if ((code_sec
!= NULL
13017 && code_sec
->output_section
!= NULL
13018 && (htab
->sec_info
[code_sec
->id
].toc_off
13019 != htab
->sec_info
[section
->id
].toc_off
)
13020 && (code_sec
->has_toc_reloc
13021 || code_sec
->makes_toc_func_call
))
13022 || (((hash
? hash
->elf
.other
: sym
->st_other
)
13023 & STO_PPC64_LOCAL_MASK
)
13024 == 1 << STO_PPC64_LOCAL_BIT
))
13025 stub_type
= ppc_stub_long_branch_r2off
;
13028 if (stub_type
== ppc_stub_none
)
13031 /* __tls_get_addr calls might be eliminated. */
13032 if (stub_type
!= ppc_stub_plt_call
13033 && stub_type
!= ppc_stub_plt_call_notoc
13035 && (hash
== htab
->tls_get_addr
13036 || hash
== htab
->tls_get_addr_fd
)
13037 && section
->has_tls_reloc
13038 && irela
!= internal_relocs
)
13040 /* Get tls info. */
13041 unsigned char *tls_mask
;
13043 if (!get_tls_mask (&tls_mask
, NULL
, NULL
, &local_syms
,
13044 irela
- 1, input_bfd
))
13045 goto error_ret_free_internal
;
13046 if ((*tls_mask
& TLS_TLS
) != 0)
13050 if (stub_type
== ppc_stub_plt_call
)
13053 && htab
->params
->plt_localentry0
!= 0
13054 && is_elfv2_localentry0 (&hash
->elf
))
13055 htab
->has_plt_localentry0
= 1;
13056 else if (irela
+ 1 < irelaend
13057 && irela
[1].r_offset
== irela
->r_offset
+ 4
13058 && (ELF64_R_TYPE (irela
[1].r_info
)
13059 == R_PPC64_TOCSAVE
))
13061 if (!tocsave_find (htab
, INSERT
,
13062 &local_syms
, irela
+ 1, input_bfd
))
13063 goto error_ret_free_internal
;
13066 stub_type
= ppc_stub_plt_call_r2save
;
13069 /* Support for grouping stub sections. */
13070 id_sec
= htab
->sec_info
[section
->id
].u
.group
->link_sec
;
13072 /* Get the name of this stub. */
13073 stub_name
= ppc_stub_name (id_sec
, sym_sec
, hash
, irela
);
13075 goto error_ret_free_internal
;
13077 stub_entry
= ppc_stub_hash_lookup (&htab
->stub_hash_table
,
13078 stub_name
, FALSE
, FALSE
);
13079 if (stub_entry
!= NULL
)
13081 enum ppc_stub_type old_type
;
13082 /* A stub has already been created, but it may
13083 not be the required type. We shouldn't be
13084 transitioning from plt_call to long_branch
13085 stubs or vice versa, but we might be
13086 upgrading from plt_call to plt_call_r2save or
13087 from long_branch to long_branch_r2off. */
13089 old_type
= stub_entry
->stub_type
;
13095 case ppc_stub_save_res
:
13098 case ppc_stub_plt_call
:
13099 case ppc_stub_plt_call_r2save
:
13100 case ppc_stub_plt_call_notoc
:
13101 case ppc_stub_plt_call_both
:
13102 if (stub_type
== ppc_stub_plt_call
)
13104 else if (stub_type
== ppc_stub_plt_call_r2save
)
13106 if (old_type
== ppc_stub_plt_call_notoc
)
13107 stub_type
= ppc_stub_plt_call_both
;
13109 else if (stub_type
== ppc_stub_plt_call_notoc
)
13111 if (old_type
== ppc_stub_plt_call_r2save
)
13112 stub_type
= ppc_stub_plt_call_both
;
13118 case ppc_stub_plt_branch
:
13119 case ppc_stub_plt_branch_r2off
:
13120 case ppc_stub_plt_branch_notoc
:
13121 case ppc_stub_plt_branch_both
:
13122 old_type
+= (ppc_stub_long_branch
13123 - ppc_stub_plt_branch
);
13124 /* Fall through. */
13125 case ppc_stub_long_branch
:
13126 case ppc_stub_long_branch_r2off
:
13127 case ppc_stub_long_branch_notoc
:
13128 case ppc_stub_long_branch_both
:
13129 if (stub_type
== ppc_stub_long_branch
)
13131 else if (stub_type
== ppc_stub_long_branch_r2off
)
13133 if (old_type
== ppc_stub_long_branch_notoc
)
13134 stub_type
= ppc_stub_long_branch_both
;
13136 else if (stub_type
== ppc_stub_long_branch_notoc
)
13138 if (old_type
== ppc_stub_long_branch_r2off
)
13139 stub_type
= ppc_stub_long_branch_both
;
13145 if (old_type
< stub_type
)
13146 stub_entry
->stub_type
= stub_type
;
13150 stub_entry
= ppc_add_stub (stub_name
, section
, info
);
13151 if (stub_entry
== NULL
)
13154 error_ret_free_internal
:
13155 if (elf_section_data (section
)->relocs
== NULL
)
13156 free (internal_relocs
);
13157 error_ret_free_local
:
13158 if (local_syms
!= NULL
13159 && (symtab_hdr
->contents
13160 != (unsigned char *) local_syms
))
13165 stub_entry
->stub_type
= stub_type
;
13166 if (stub_type
>= ppc_stub_plt_call
13167 && stub_type
<= ppc_stub_plt_call_both
)
13169 stub_entry
->target_value
= sym_value
;
13170 stub_entry
->target_section
= sym_sec
;
13174 stub_entry
->target_value
= code_value
;
13175 stub_entry
->target_section
= code_sec
;
13177 stub_entry
->h
= hash
;
13178 stub_entry
->plt_ent
= plt_ent
;
13179 stub_entry
->symtype
13180 = hash
? hash
->elf
.type
: ELF_ST_TYPE (sym
->st_info
);
13181 stub_entry
->other
= hash
? hash
->elf
.other
: sym
->st_other
;
13184 && (hash
->elf
.root
.type
== bfd_link_hash_defined
13185 || hash
->elf
.root
.type
== bfd_link_hash_defweak
))
13186 htab
->stub_globals
+= 1;
13189 /* We're done with the internal relocs, free them. */
13190 if (elf_section_data (section
)->relocs
!= internal_relocs
)
13191 free (internal_relocs
);
13194 if (local_syms
!= NULL
13195 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
13197 if (!info
->keep_memory
)
13200 symtab_hdr
->contents
= (unsigned char *) local_syms
;
13204 /* We may have added some stubs. Find out the new size of the
13206 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13208 group
->lr_restore
= 0;
13209 group
->eh_size
= 0;
13210 if (group
->stub_sec
!= NULL
)
13212 asection
*stub_sec
= group
->stub_sec
;
13214 if (htab
->stub_iteration
<= STUB_SHRINK_ITER
13215 || stub_sec
->rawsize
< stub_sec
->size
)
13216 /* Past STUB_SHRINK_ITER, rawsize is the max size seen. */
13217 stub_sec
->rawsize
= stub_sec
->size
;
13218 stub_sec
->size
= 0;
13219 stub_sec
->reloc_count
= 0;
13220 stub_sec
->flags
&= ~SEC_RELOC
;
13224 if (htab
->stub_iteration
<= STUB_SHRINK_ITER
13225 || htab
->brlt
->rawsize
< htab
->brlt
->size
)
13226 htab
->brlt
->rawsize
= htab
->brlt
->size
;
13227 htab
->brlt
->size
= 0;
13228 htab
->brlt
->reloc_count
= 0;
13229 htab
->brlt
->flags
&= ~SEC_RELOC
;
13230 if (htab
->relbrlt
!= NULL
)
13231 htab
->relbrlt
->size
= 0;
13233 bfd_hash_traverse (&htab
->stub_hash_table
, ppc_size_one_stub
, info
);
13235 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13236 if (group
->needs_save_res
)
13237 group
->stub_sec
->size
+= htab
->sfpr
->size
;
13239 if (info
->emitrelocations
13240 && htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
13242 htab
->glink
->reloc_count
= 1;
13243 htab
->glink
->flags
|= SEC_RELOC
;
13246 if (htab
->glink_eh_frame
!= NULL
13247 && !bfd_is_abs_section (htab
->glink_eh_frame
->output_section
)
13248 && htab
->glink_eh_frame
->output_section
->size
> 8)
13250 size_t size
= 0, align
= 4;
13252 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13253 if (group
->eh_size
!= 0)
13254 size
+= (group
->eh_size
+ 17 + align
- 1) & -align
;
13255 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
13256 size
+= (24 + align
- 1) & -align
;
13258 size
+= (sizeof (glink_eh_frame_cie
) + align
- 1) & -align
;
13259 align
= 1ul << htab
->glink_eh_frame
->output_section
->alignment_power
;
13260 size
= (size
+ align
- 1) & -align
;
13261 htab
->glink_eh_frame
->rawsize
= htab
->glink_eh_frame
->size
;
13262 htab
->glink_eh_frame
->size
= size
;
13265 if (htab
->params
->plt_stub_align
!= 0)
13266 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13267 if (group
->stub_sec
!= NULL
)
13269 int align
= abs (htab
->params
->plt_stub_align
);
13270 group
->stub_sec
->size
13271 = (group
->stub_sec
->size
+ (1 << align
) - 1) & -(1 << align
);
13274 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13275 if (group
->stub_sec
!= NULL
13276 && group
->stub_sec
->rawsize
!= group
->stub_sec
->size
13277 && (htab
->stub_iteration
<= STUB_SHRINK_ITER
13278 || group
->stub_sec
->rawsize
< group
->stub_sec
->size
))
13282 && (htab
->brlt
->rawsize
== htab
->brlt
->size
13283 || (htab
->stub_iteration
> STUB_SHRINK_ITER
13284 && htab
->brlt
->rawsize
> htab
->brlt
->size
))
13285 && (htab
->glink_eh_frame
== NULL
13286 || htab
->glink_eh_frame
->rawsize
== htab
->glink_eh_frame
->size
))
13289 /* Ask the linker to do its stuff. */
13290 (*htab
->params
->layout_sections_again
) ();
13293 if (htab
->glink_eh_frame
!= NULL
13294 && htab
->glink_eh_frame
->size
!= 0)
13297 bfd_byte
*p
, *last_fde
;
13298 size_t last_fde_len
, size
, align
, pad
;
13299 struct map_stub
*group
;
13301 /* It is necessary to at least have a rough outline of the
13302 linker generated CIEs and FDEs written before
13303 bfd_elf_discard_info is run, in order for these FDEs to be
13304 indexed in .eh_frame_hdr. */
13305 p
= bfd_zalloc (htab
->glink_eh_frame
->owner
, htab
->glink_eh_frame
->size
);
13308 htab
->glink_eh_frame
->contents
= p
;
13312 memcpy (p
, glink_eh_frame_cie
, sizeof (glink_eh_frame_cie
));
13313 /* CIE length (rewrite in case little-endian). */
13314 last_fde_len
= ((sizeof (glink_eh_frame_cie
) + align
- 1) & -align
) - 4;
13315 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
, p
);
13316 p
+= last_fde_len
+ 4;
13318 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13319 if (group
->eh_size
!= 0)
13321 group
->eh_base
= p
- htab
->glink_eh_frame
->contents
;
13323 last_fde_len
= ((group
->eh_size
+ 17 + align
- 1) & -align
) - 4;
13325 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
, p
);
13328 val
= p
- htab
->glink_eh_frame
->contents
;
13329 bfd_put_32 (htab
->elf
.dynobj
, val
, p
);
13331 /* Offset to stub section, written later. */
13333 /* stub section size. */
13334 bfd_put_32 (htab
->elf
.dynobj
, group
->stub_sec
->size
, p
);
13336 /* Augmentation. */
13338 /* Make sure we don't have all nops. This is enough for
13339 elf-eh-frame.c to detect the last non-nop opcode. */
13340 p
[group
->eh_size
- 1] = DW_CFA_advance_loc
+ 1;
13341 p
= last_fde
+ last_fde_len
+ 4;
13343 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
13346 last_fde_len
= ((24 + align
- 1) & -align
) - 4;
13348 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
, p
);
13351 val
= p
- htab
->glink_eh_frame
->contents
;
13352 bfd_put_32 (htab
->elf
.dynobj
, val
, p
);
13354 /* Offset to .glink, written later. */
13357 bfd_put_32 (htab
->elf
.dynobj
, htab
->glink
->size
- 8, p
);
13359 /* Augmentation. */
13362 *p
++ = DW_CFA_advance_loc
+ 1;
13363 *p
++ = DW_CFA_register
;
13365 *p
++ = htab
->opd_abi
? 12 : 0;
13366 *p
++ = DW_CFA_advance_loc
+ (htab
->opd_abi
? 5 : 7);
13367 *p
++ = DW_CFA_restore_extended
;
13369 p
+= ((24 + align
- 1) & -align
) - 24;
13371 /* Subsume any padding into the last FDE if user .eh_frame
13372 sections are aligned more than glink_eh_frame. Otherwise any
13373 zero padding will be seen as a terminator. */
13374 align
= 1ul << htab
->glink_eh_frame
->output_section
->alignment_power
;
13375 size
= p
- htab
->glink_eh_frame
->contents
;
13376 pad
= ((size
+ align
- 1) & -align
) - size
;
13377 htab
->glink_eh_frame
->size
= size
+ pad
;
13378 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
+ pad
, last_fde
);
13381 maybe_strip_output (info
, htab
->brlt
);
13382 if (htab
->glink_eh_frame
!= NULL
)
13383 maybe_strip_output (info
, htab
->glink_eh_frame
);
13388 /* Called after we have determined section placement. If sections
13389 move, we'll be called again. Provide a value for TOCstart. */
13392 ppc64_elf_set_toc (struct bfd_link_info
*info
, bfd
*obfd
)
13395 bfd_vma TOCstart
, adjust
;
13399 struct elf_link_hash_entry
*h
;
13400 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
13402 if (is_elf_hash_table (htab
)
13403 && htab
->hgot
!= NULL
)
13407 h
= elf_link_hash_lookup (htab
, ".TOC.", FALSE
, FALSE
, TRUE
);
13408 if (is_elf_hash_table (htab
))
13412 && h
->root
.type
== bfd_link_hash_defined
13413 && !h
->root
.linker_def
13414 && (!is_elf_hash_table (htab
)
13415 || h
->def_regular
))
13417 TOCstart
= (h
->root
.u
.def
.value
- TOC_BASE_OFF
13418 + h
->root
.u
.def
.section
->output_offset
13419 + h
->root
.u
.def
.section
->output_section
->vma
);
13420 _bfd_set_gp_value (obfd
, TOCstart
);
13425 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
13426 order. The TOC starts where the first of these sections starts. */
13427 s
= bfd_get_section_by_name (obfd
, ".got");
13428 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13429 s
= bfd_get_section_by_name (obfd
, ".toc");
13430 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13431 s
= bfd_get_section_by_name (obfd
, ".tocbss");
13432 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13433 s
= bfd_get_section_by_name (obfd
, ".plt");
13434 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13436 /* This may happen for
13437 o references to TOC base (SYM@toc / TOC[tc0]) without a
13439 o bad linker script
13440 o --gc-sections and empty TOC sections
13442 FIXME: Warn user? */
13444 /* Look for a likely section. We probably won't even be
13446 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13447 if ((s
->flags
& (SEC_ALLOC
| SEC_SMALL_DATA
| SEC_READONLY
13449 == (SEC_ALLOC
| SEC_SMALL_DATA
))
13452 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13453 if ((s
->flags
& (SEC_ALLOC
| SEC_SMALL_DATA
| SEC_EXCLUDE
))
13454 == (SEC_ALLOC
| SEC_SMALL_DATA
))
13457 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13458 if ((s
->flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_EXCLUDE
))
13462 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13463 if ((s
->flags
& (SEC_ALLOC
| SEC_EXCLUDE
)) == SEC_ALLOC
)
13469 TOCstart
= s
->output_section
->vma
+ s
->output_offset
;
13471 /* Force alignment. */
13472 adjust
= TOCstart
& (TOC_BASE_ALIGN
- 1);
13473 TOCstart
-= adjust
;
13474 _bfd_set_gp_value (obfd
, TOCstart
);
13476 if (info
!= NULL
&& s
!= NULL
)
13478 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
13482 if (htab
->elf
.hgot
!= NULL
)
13484 htab
->elf
.hgot
->root
.u
.def
.value
= TOC_BASE_OFF
- adjust
;
13485 htab
->elf
.hgot
->root
.u
.def
.section
= s
;
13490 struct bfd_link_hash_entry
*bh
= NULL
;
13491 _bfd_generic_link_add_one_symbol (info
, obfd
, ".TOC.", BSF_GLOBAL
,
13492 s
, TOC_BASE_OFF
- adjust
,
13493 NULL
, FALSE
, FALSE
, &bh
);
13499 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
13500 write out any global entry stubs, and PLT relocations. */
13503 build_global_entry_stubs_and_plt (struct elf_link_hash_entry
*h
, void *inf
)
13505 struct bfd_link_info
*info
;
13506 struct ppc_link_hash_table
*htab
;
13507 struct plt_entry
*ent
;
13510 if (h
->root
.type
== bfd_link_hash_indirect
)
13514 htab
= ppc_hash_table (info
);
13518 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
13519 if (ent
->plt
.offset
!= (bfd_vma
) -1)
13521 /* This symbol has an entry in the procedure linkage
13522 table. Set it up. */
13523 Elf_Internal_Rela rela
;
13524 asection
*plt
, *relplt
;
13527 if (!htab
->elf
.dynamic_sections_created
13528 || h
->dynindx
== -1)
13530 if (!(h
->def_regular
13531 && (h
->root
.type
== bfd_link_hash_defined
13532 || h
->root
.type
== bfd_link_hash_defweak
)))
13534 if (h
->type
== STT_GNU_IFUNC
)
13536 plt
= htab
->elf
.iplt
;
13537 relplt
= htab
->elf
.irelplt
;
13538 htab
->local_ifunc_resolver
= 1;
13540 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_IREL
);
13542 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
13546 plt
= htab
->pltlocal
;
13547 if (bfd_link_pic (info
))
13549 relplt
= htab
->relpltlocal
;
13551 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_SLOT
);
13553 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
13558 rela
.r_addend
= (h
->root
.u
.def
.value
13559 + h
->root
.u
.def
.section
->output_offset
13560 + h
->root
.u
.def
.section
->output_section
->vma
13563 if (relplt
== NULL
)
13565 loc
= plt
->contents
+ ent
->plt
.offset
;
13566 bfd_put_64 (info
->output_bfd
, rela
.r_addend
, loc
);
13569 bfd_vma toc
= elf_gp (info
->output_bfd
);
13570 toc
+= htab
->sec_info
[h
->root
.u
.def
.section
->id
].toc_off
;
13571 bfd_put_64 (info
->output_bfd
, toc
, loc
+ 8);
13576 rela
.r_offset
= (plt
->output_section
->vma
13577 + plt
->output_offset
13578 + ent
->plt
.offset
);
13579 loc
= relplt
->contents
+ (relplt
->reloc_count
++
13580 * sizeof (Elf64_External_Rela
));
13581 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rela
, loc
);
13586 rela
.r_offset
= (htab
->elf
.splt
->output_section
->vma
13587 + htab
->elf
.splt
->output_offset
13588 + ent
->plt
.offset
);
13589 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_PPC64_JMP_SLOT
);
13590 rela
.r_addend
= ent
->addend
;
13591 loc
= (htab
->elf
.srelplt
->contents
13592 + ((ent
->plt
.offset
- PLT_INITIAL_ENTRY_SIZE (htab
))
13593 / PLT_ENTRY_SIZE (htab
) * sizeof (Elf64_External_Rela
)));
13594 if (h
->type
== STT_GNU_IFUNC
&& is_static_defined (h
))
13595 htab
->maybe_local_ifunc_resolver
= 1;
13596 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rela
, loc
);
13600 if (!h
->pointer_equality_needed
)
13603 if (h
->def_regular
)
13606 s
= htab
->global_entry
;
13607 if (s
== NULL
|| s
->size
== 0)
13610 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
13611 if (ent
->plt
.offset
!= (bfd_vma
) -1
13612 && ent
->addend
== 0)
13618 p
= s
->contents
+ h
->root
.u
.def
.value
;
13619 plt
= htab
->elf
.splt
;
13620 if (!htab
->elf
.dynamic_sections_created
13621 || h
->dynindx
== -1)
13623 if (h
->type
== STT_GNU_IFUNC
)
13624 plt
= htab
->elf
.iplt
;
13626 plt
= htab
->pltlocal
;
13628 off
= ent
->plt
.offset
+ plt
->output_offset
+ plt
->output_section
->vma
;
13629 off
-= h
->root
.u
.def
.value
+ s
->output_offset
+ s
->output_section
->vma
;
13631 if (off
+ 0x80008000 > 0xffffffff || (off
& 3) != 0)
13633 info
->callbacks
->einfo
13634 (_("%P: linkage table error against `%pT'\n"),
13635 h
->root
.root
.string
);
13636 bfd_set_error (bfd_error_bad_value
);
13637 htab
->stub_error
= TRUE
;
13640 htab
->stub_count
[ppc_stub_global_entry
- 1] += 1;
13641 if (htab
->params
->emit_stub_syms
)
13643 size_t len
= strlen (h
->root
.root
.string
);
13644 char *name
= bfd_malloc (sizeof "12345678.global_entry." + len
);
13649 sprintf (name
, "%08x.global_entry.%s", s
->id
, h
->root
.root
.string
);
13650 h
= elf_link_hash_lookup (&htab
->elf
, name
, TRUE
, FALSE
, FALSE
);
13653 if (h
->root
.type
== bfd_link_hash_new
)
13655 h
->root
.type
= bfd_link_hash_defined
;
13656 h
->root
.u
.def
.section
= s
;
13657 h
->root
.u
.def
.value
= p
- s
->contents
;
13658 h
->ref_regular
= 1;
13659 h
->def_regular
= 1;
13660 h
->ref_regular_nonweak
= 1;
13661 h
->forced_local
= 1;
13663 h
->root
.linker_def
= 1;
13667 if (PPC_HA (off
) != 0)
13669 bfd_put_32 (s
->owner
, ADDIS_R12_R12
| PPC_HA (off
), p
);
13672 bfd_put_32 (s
->owner
, LD_R12_0R12
| PPC_LO (off
), p
);
13674 bfd_put_32 (s
->owner
, MTCTR_R12
, p
);
13676 bfd_put_32 (s
->owner
, BCTR
, p
);
13682 /* Write PLT relocs for locals. */
13685 write_plt_relocs_for_local_syms (struct bfd_link_info
*info
)
13687 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
13690 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
13692 struct got_entry
**lgot_ents
, **end_lgot_ents
;
13693 struct plt_entry
**local_plt
, **lplt
, **end_local_plt
;
13694 Elf_Internal_Shdr
*symtab_hdr
;
13695 bfd_size_type locsymcount
;
13696 Elf_Internal_Sym
*local_syms
= NULL
;
13697 struct plt_entry
*ent
;
13699 if (!is_ppc64_elf (ibfd
))
13702 lgot_ents
= elf_local_got_ents (ibfd
);
13706 symtab_hdr
= &elf_symtab_hdr (ibfd
);
13707 locsymcount
= symtab_hdr
->sh_info
;
13708 end_lgot_ents
= lgot_ents
+ locsymcount
;
13709 local_plt
= (struct plt_entry
**) end_lgot_ents
;
13710 end_local_plt
= local_plt
+ locsymcount
;
13711 for (lplt
= local_plt
; lplt
< end_local_plt
; ++lplt
)
13712 for (ent
= *lplt
; ent
!= NULL
; ent
= ent
->next
)
13713 if (ent
->plt
.offset
!= (bfd_vma
) -1)
13715 Elf_Internal_Sym
*sym
;
13717 asection
*plt
, *relplt
;
13721 if (!get_sym_h (NULL
, &sym
, &sym_sec
, NULL
, &local_syms
,
13722 lplt
- local_plt
, ibfd
))
13724 if (local_syms
!= NULL
13725 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
13730 val
= sym
->st_value
+ ent
->addend
;
13731 if (ELF_ST_TYPE (sym
->st_info
) != STT_GNU_IFUNC
)
13732 val
+= PPC64_LOCAL_ENTRY_OFFSET (sym
->st_other
);
13733 if (sym_sec
!= NULL
&& sym_sec
->output_section
!= NULL
)
13734 val
+= sym_sec
->output_offset
+ sym_sec
->output_section
->vma
;
13736 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
13738 htab
->local_ifunc_resolver
= 1;
13739 plt
= htab
->elf
.iplt
;
13740 relplt
= htab
->elf
.irelplt
;
13744 plt
= htab
->pltlocal
;
13745 relplt
= bfd_link_pic (info
) ? htab
->relpltlocal
: NULL
;
13748 if (relplt
== NULL
)
13750 loc
= plt
->contents
+ ent
->plt
.offset
;
13751 bfd_put_64 (info
->output_bfd
, val
, loc
);
13754 bfd_vma toc
= elf_gp (ibfd
);
13755 bfd_put_64 (info
->output_bfd
, toc
, loc
+ 8);
13760 Elf_Internal_Rela rela
;
13761 rela
.r_offset
= (ent
->plt
.offset
13762 + plt
->output_offset
13763 + plt
->output_section
->vma
);
13764 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
13767 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_IREL
);
13769 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
13774 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_SLOT
);
13776 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
13778 rela
.r_addend
= val
;
13779 loc
= relplt
->contents
+ (relplt
->reloc_count
++
13780 * sizeof (Elf64_External_Rela
));
13781 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rela
, loc
);
13785 if (local_syms
!= NULL
13786 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
13788 if (!info
->keep_memory
)
13791 symtab_hdr
->contents
= (unsigned char *) local_syms
;
13797 /* Build all the stubs associated with the current output file.
13798 The stubs are kept in a hash table attached to the main linker
13799 hash table. This function is called via gldelf64ppc_finish. */
13802 ppc64_elf_build_stubs (struct bfd_link_info
*info
,
13805 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
13806 struct map_stub
*group
;
13807 asection
*stub_sec
;
13809 int stub_sec_count
= 0;
13814 /* Allocate memory to hold the linker stubs. */
13815 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13817 group
->eh_size
= 0;
13818 group
->lr_restore
= 0;
13819 if ((stub_sec
= group
->stub_sec
) != NULL
13820 && stub_sec
->size
!= 0)
13822 stub_sec
->contents
= bfd_zalloc (htab
->params
->stub_bfd
,
13824 if (stub_sec
->contents
== NULL
)
13826 stub_sec
->size
= 0;
13830 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
13835 /* Build the .glink plt call stub. */
13836 if (htab
->params
->emit_stub_syms
)
13838 struct elf_link_hash_entry
*h
;
13839 h
= elf_link_hash_lookup (&htab
->elf
, "__glink_PLTresolve",
13840 TRUE
, FALSE
, FALSE
);
13843 if (h
->root
.type
== bfd_link_hash_new
)
13845 h
->root
.type
= bfd_link_hash_defined
;
13846 h
->root
.u
.def
.section
= htab
->glink
;
13847 h
->root
.u
.def
.value
= 8;
13848 h
->ref_regular
= 1;
13849 h
->def_regular
= 1;
13850 h
->ref_regular_nonweak
= 1;
13851 h
->forced_local
= 1;
13853 h
->root
.linker_def
= 1;
13856 plt0
= (htab
->elf
.splt
->output_section
->vma
13857 + htab
->elf
.splt
->output_offset
13859 if (info
->emitrelocations
)
13861 Elf_Internal_Rela
*r
= get_relocs (htab
->glink
, 1);
13864 r
->r_offset
= (htab
->glink
->output_offset
13865 + htab
->glink
->output_section
->vma
);
13866 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL64
);
13867 r
->r_addend
= plt0
;
13869 p
= htab
->glink
->contents
;
13870 plt0
-= htab
->glink
->output_section
->vma
+ htab
->glink
->output_offset
;
13871 bfd_put_64 (htab
->glink
->owner
, plt0
, p
);
13875 bfd_put_32 (htab
->glink
->owner
, MFLR_R12
, p
);
13877 bfd_put_32 (htab
->glink
->owner
, BCL_20_31
, p
);
13879 bfd_put_32 (htab
->glink
->owner
, MFLR_R11
, p
);
13881 bfd_put_32 (htab
->glink
->owner
, LD_R2_0R11
| (-16 & 0xfffc), p
);
13883 bfd_put_32 (htab
->glink
->owner
, MTLR_R12
, p
);
13885 bfd_put_32 (htab
->glink
->owner
, ADD_R11_R2_R11
, p
);
13887 bfd_put_32 (htab
->glink
->owner
, LD_R12_0R11
, p
);
13889 bfd_put_32 (htab
->glink
->owner
, LD_R2_0R11
| 8, p
);
13891 bfd_put_32 (htab
->glink
->owner
, MTCTR_R12
, p
);
13893 bfd_put_32 (htab
->glink
->owner
, LD_R11_0R11
| 16, p
);
13898 bfd_put_32 (htab
->glink
->owner
, MFLR_R0
, p
);
13900 bfd_put_32 (htab
->glink
->owner
, BCL_20_31
, p
);
13902 bfd_put_32 (htab
->glink
->owner
, MFLR_R11
, p
);
13904 bfd_put_32 (htab
->glink
->owner
, STD_R2_0R1
+ 24, p
);
13906 bfd_put_32 (htab
->glink
->owner
, LD_R2_0R11
| (-16 & 0xfffc), p
);
13908 bfd_put_32 (htab
->glink
->owner
, MTLR_R0
, p
);
13910 bfd_put_32 (htab
->glink
->owner
, SUB_R12_R12_R11
, p
);
13912 bfd_put_32 (htab
->glink
->owner
, ADD_R11_R2_R11
, p
);
13914 bfd_put_32 (htab
->glink
->owner
, ADDI_R0_R12
| (-48 & 0xffff), p
);
13916 bfd_put_32 (htab
->glink
->owner
, LD_R12_0R11
, p
);
13918 bfd_put_32 (htab
->glink
->owner
, SRDI_R0_R0_2
, p
);
13920 bfd_put_32 (htab
->glink
->owner
, MTCTR_R12
, p
);
13922 bfd_put_32 (htab
->glink
->owner
, LD_R11_0R11
| 8, p
);
13925 bfd_put_32 (htab
->glink
->owner
, BCTR
, p
);
13927 BFD_ASSERT (p
== htab
->glink
->contents
+ GLINK_PLTRESOLVE_SIZE (htab
));
13929 /* Build the .glink lazy link call stubs. */
13931 while (p
< htab
->glink
->contents
+ htab
->glink
->size
)
13937 bfd_put_32 (htab
->glink
->owner
, LI_R0_0
| indx
, p
);
13942 bfd_put_32 (htab
->glink
->owner
, LIS_R0_0
| PPC_HI (indx
), p
);
13944 bfd_put_32 (htab
->glink
->owner
, ORI_R0_R0_0
| PPC_LO (indx
),
13949 bfd_put_32 (htab
->glink
->owner
,
13950 B_DOT
| ((htab
->glink
->contents
- p
+ 8) & 0x3fffffc), p
);
13956 /* Build .glink global entry stubs, and PLT relocs for globals. */
13957 elf_link_hash_traverse (&htab
->elf
, build_global_entry_stubs_and_plt
, info
);
13959 if (!write_plt_relocs_for_local_syms (info
))
13962 if (htab
->brlt
!= NULL
&& htab
->brlt
->size
!= 0)
13964 htab
->brlt
->contents
= bfd_zalloc (htab
->brlt
->owner
,
13966 if (htab
->brlt
->contents
== NULL
)
13969 if (htab
->relbrlt
!= NULL
&& htab
->relbrlt
->size
!= 0)
13971 htab
->relbrlt
->contents
= bfd_zalloc (htab
->relbrlt
->owner
,
13972 htab
->relbrlt
->size
);
13973 if (htab
->relbrlt
->contents
== NULL
)
13977 /* Build the stubs as directed by the stub hash table. */
13978 bfd_hash_traverse (&htab
->stub_hash_table
, ppc_build_one_stub
, info
);
13980 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13981 if (group
->needs_save_res
)
13982 group
->stub_sec
->size
+= htab
->sfpr
->size
;
13984 if (htab
->relbrlt
!= NULL
)
13985 htab
->relbrlt
->reloc_count
= 0;
13987 if (htab
->params
->plt_stub_align
!= 0)
13988 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13989 if ((stub_sec
= group
->stub_sec
) != NULL
)
13991 int align
= abs (htab
->params
->plt_stub_align
);
13992 stub_sec
->size
= (stub_sec
->size
+ (1 << align
) - 1) & -(1 << align
);
13995 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13996 if (group
->needs_save_res
)
13998 stub_sec
= group
->stub_sec
;
13999 memcpy (stub_sec
->contents
+ stub_sec
->size
- htab
->sfpr
->size
,
14000 htab
->sfpr
->contents
, htab
->sfpr
->size
);
14001 if (htab
->params
->emit_stub_syms
)
14005 for (i
= 0; i
< ARRAY_SIZE (save_res_funcs
); i
++)
14006 if (!sfpr_define (info
, &save_res_funcs
[i
], stub_sec
))
14011 if (htab
->glink_eh_frame
!= NULL
14012 && htab
->glink_eh_frame
->size
!= 0)
14017 p
= htab
->glink_eh_frame
->contents
;
14018 p
+= (sizeof (glink_eh_frame_cie
) + align
- 1) & -align
;
14020 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14021 if (group
->eh_size
!= 0)
14023 /* Offset to stub section. */
14024 val
= (group
->stub_sec
->output_section
->vma
14025 + group
->stub_sec
->output_offset
);
14026 val
-= (htab
->glink_eh_frame
->output_section
->vma
14027 + htab
->glink_eh_frame
->output_offset
14028 + (p
+ 8 - htab
->glink_eh_frame
->contents
));
14029 if (val
+ 0x80000000 > 0xffffffff)
14032 (_("%s offset too large for .eh_frame sdata4 encoding"),
14033 group
->stub_sec
->name
);
14036 bfd_put_32 (htab
->elf
.dynobj
, val
, p
+ 8);
14037 p
+= (group
->eh_size
+ 17 + 3) & -4;
14039 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
14041 /* Offset to .glink. */
14042 val
= (htab
->glink
->output_section
->vma
14043 + htab
->glink
->output_offset
14045 val
-= (htab
->glink_eh_frame
->output_section
->vma
14046 + htab
->glink_eh_frame
->output_offset
14047 + (p
+ 8 - htab
->glink_eh_frame
->contents
));
14048 if (val
+ 0x80000000 > 0xffffffff)
14051 (_("%s offset too large for .eh_frame sdata4 encoding"),
14052 htab
->glink
->name
);
14055 bfd_put_32 (htab
->elf
.dynobj
, val
, p
+ 8);
14056 p
+= (24 + align
- 1) & -align
;
14060 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14061 if ((stub_sec
= group
->stub_sec
) != NULL
)
14063 stub_sec_count
+= 1;
14064 if (stub_sec
->rawsize
!= stub_sec
->size
14065 && (htab
->stub_iteration
<= STUB_SHRINK_ITER
14066 || stub_sec
->rawsize
< stub_sec
->size
))
14072 htab
->stub_error
= TRUE
;
14073 _bfd_error_handler (_("stubs don't match calculated size"));
14076 if (htab
->stub_error
)
14082 *stats
= bfd_malloc (500);
14083 if (*stats
== NULL
)
14086 len
= sprintf (*stats
,
14087 ngettext ("linker stubs in %u group\n",
14088 "linker stubs in %u groups\n",
14091 sprintf (*stats
+ len
, _(" branch %lu\n"
14092 " branch toc adj %lu\n"
14093 " branch notoc %lu\n"
14094 " branch both %lu\n"
14095 " long branch %lu\n"
14096 " long toc adj %lu\n"
14097 " long notoc %lu\n"
14100 " plt call save %lu\n"
14101 " plt call notoc %lu\n"
14102 " plt call both %lu\n"
14103 " global entry %lu"),
14104 htab
->stub_count
[ppc_stub_long_branch
- 1],
14105 htab
->stub_count
[ppc_stub_long_branch_r2off
- 1],
14106 htab
->stub_count
[ppc_stub_long_branch_notoc
- 1],
14107 htab
->stub_count
[ppc_stub_long_branch_both
- 1],
14108 htab
->stub_count
[ppc_stub_plt_branch
- 1],
14109 htab
->stub_count
[ppc_stub_plt_branch_r2off
- 1],
14110 htab
->stub_count
[ppc_stub_plt_branch_notoc
- 1],
14111 htab
->stub_count
[ppc_stub_plt_branch_both
- 1],
14112 htab
->stub_count
[ppc_stub_plt_call
- 1],
14113 htab
->stub_count
[ppc_stub_plt_call_r2save
- 1],
14114 htab
->stub_count
[ppc_stub_plt_call_notoc
- 1],
14115 htab
->stub_count
[ppc_stub_plt_call_both
- 1],
14116 htab
->stub_count
[ppc_stub_global_entry
- 1]);
14121 /* What to do when ld finds relocations against symbols defined in
14122 discarded sections. */
14124 static unsigned int
14125 ppc64_elf_action_discarded (asection
*sec
)
14127 if (strcmp (".opd", sec
->name
) == 0)
14130 if (strcmp (".toc", sec
->name
) == 0)
14133 if (strcmp (".toc1", sec
->name
) == 0)
14136 return _bfd_elf_default_action_discarded (sec
);
14139 /* The RELOCATE_SECTION function is called by the ELF backend linker
14140 to handle the relocations for a section.
14142 The relocs are always passed as Rela structures; if the section
14143 actually uses Rel structures, the r_addend field will always be
14146 This function is responsible for adjust the section contents as
14147 necessary, and (if using Rela relocs and generating a
14148 relocatable output file) adjusting the reloc addend as
14151 This function does not have to worry about setting the reloc
14152 address or the reloc symbol index.
14154 LOCAL_SYMS is a pointer to the swapped in local symbols.
14156 LOCAL_SECTIONS is an array giving the section in the input file
14157 corresponding to the st_shndx field of each local symbol.
14159 The global hash table entry for the global symbols can be found
14160 via elf_sym_hashes (input_bfd).
14162 When generating relocatable output, this function must handle
14163 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
14164 going to be the section symbol corresponding to the output
14165 section, which means that the addend must be adjusted
14169 ppc64_elf_relocate_section (bfd
*output_bfd
,
14170 struct bfd_link_info
*info
,
14172 asection
*input_section
,
14173 bfd_byte
*contents
,
14174 Elf_Internal_Rela
*relocs
,
14175 Elf_Internal_Sym
*local_syms
,
14176 asection
**local_sections
)
14178 struct ppc_link_hash_table
*htab
;
14179 Elf_Internal_Shdr
*symtab_hdr
;
14180 struct elf_link_hash_entry
**sym_hashes
;
14181 Elf_Internal_Rela
*rel
;
14182 Elf_Internal_Rela
*wrel
;
14183 Elf_Internal_Rela
*relend
;
14184 Elf_Internal_Rela outrel
;
14186 struct got_entry
**local_got_ents
;
14188 bfd_boolean ret
= TRUE
;
14189 bfd_boolean is_opd
;
14190 /* Assume 'at' branch hints. */
14191 bfd_boolean is_isa_v2
= TRUE
;
14192 bfd_vma d_offset
= (bfd_big_endian (input_bfd
) ? 2 : 0);
14194 /* Initialize howto table if needed. */
14195 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
14198 htab
= ppc_hash_table (info
);
14202 /* Don't relocate stub sections. */
14203 if (input_section
->owner
== htab
->params
->stub_bfd
)
14206 if (!is_ppc64_elf (input_bfd
))
14208 bfd_set_error (bfd_error_wrong_format
);
14212 local_got_ents
= elf_local_got_ents (input_bfd
);
14213 TOCstart
= elf_gp (output_bfd
);
14214 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
14215 sym_hashes
= elf_sym_hashes (input_bfd
);
14216 is_opd
= ppc64_elf_section_data (input_section
)->sec_type
== sec_opd
;
14218 rel
= wrel
= relocs
;
14219 relend
= relocs
+ input_section
->reloc_count
;
14220 for (; rel
< relend
; wrel
++, rel
++)
14222 enum elf_ppc64_reloc_type r_type
;
14224 bfd_reloc_status_type r
;
14225 Elf_Internal_Sym
*sym
;
14227 struct elf_link_hash_entry
*h_elf
;
14228 struct ppc_link_hash_entry
*h
;
14229 struct ppc_link_hash_entry
*fdh
;
14230 const char *sym_name
;
14231 unsigned long r_symndx
, toc_symndx
;
14232 bfd_vma toc_addend
;
14233 unsigned char tls_mask
, tls_gd
, tls_type
;
14234 unsigned char sym_type
;
14235 bfd_vma relocation
;
14236 bfd_boolean unresolved_reloc
, save_unresolved_reloc
;
14237 bfd_boolean warned
;
14238 enum { DEST_NORMAL
, DEST_OPD
, DEST_STUB
} reloc_dest
;
14241 struct ppc_stub_hash_entry
*stub_entry
;
14242 bfd_vma max_br_offset
;
14244 Elf_Internal_Rela orig_rel
;
14245 reloc_howto_type
*howto
;
14246 struct reloc_howto_struct alt_howto
;
14253 r_type
= ELF64_R_TYPE (rel
->r_info
);
14254 r_symndx
= ELF64_R_SYM (rel
->r_info
);
14256 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
14257 symbol of the previous ADDR64 reloc. The symbol gives us the
14258 proper TOC base to use. */
14259 if (rel
->r_info
== ELF64_R_INFO (0, R_PPC64_TOC
)
14261 && ELF64_R_TYPE (wrel
[-1].r_info
) == R_PPC64_ADDR64
14263 r_symndx
= ELF64_R_SYM (wrel
[-1].r_info
);
14269 unresolved_reloc
= FALSE
;
14272 if (r_symndx
< symtab_hdr
->sh_info
)
14274 /* It's a local symbol. */
14275 struct _opd_sec_data
*opd
;
14277 sym
= local_syms
+ r_symndx
;
14278 sec
= local_sections
[r_symndx
];
14279 sym_name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
, sec
);
14280 sym_type
= ELF64_ST_TYPE (sym
->st_info
);
14281 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
14282 opd
= get_opd_info (sec
);
14283 if (opd
!= NULL
&& opd
->adjust
!= NULL
)
14285 long adjust
= opd
->adjust
[OPD_NDX (sym
->st_value
14291 /* If this is a relocation against the opd section sym
14292 and we have edited .opd, adjust the reloc addend so
14293 that ld -r and ld --emit-relocs output is correct.
14294 If it is a reloc against some other .opd symbol,
14295 then the symbol value will be adjusted later. */
14296 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
14297 rel
->r_addend
+= adjust
;
14299 relocation
+= adjust
;
14305 bfd_boolean ignored
;
14307 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
14308 r_symndx
, symtab_hdr
, sym_hashes
,
14309 h_elf
, sec
, relocation
,
14310 unresolved_reloc
, warned
, ignored
);
14311 sym_name
= h_elf
->root
.root
.string
;
14312 sym_type
= h_elf
->type
;
14314 && sec
->owner
== output_bfd
14315 && strcmp (sec
->name
, ".opd") == 0)
14317 /* This is a symbol defined in a linker script. All
14318 such are defined in output sections, even those
14319 defined by simple assignment from a symbol defined in
14320 an input section. Transfer the symbol to an
14321 appropriate input .opd section, so that a branch to
14322 this symbol will be mapped to the location specified
14323 by the opd entry. */
14324 struct bfd_link_order
*lo
;
14325 for (lo
= sec
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
14326 if (lo
->type
== bfd_indirect_link_order
)
14328 asection
*isec
= lo
->u
.indirect
.section
;
14329 if (h_elf
->root
.u
.def
.value
>= isec
->output_offset
14330 && h_elf
->root
.u
.def
.value
< (isec
->output_offset
14333 h_elf
->root
.u
.def
.value
-= isec
->output_offset
;
14334 h_elf
->root
.u
.def
.section
= isec
;
14341 h
= (struct ppc_link_hash_entry
*) h_elf
;
14343 if (sec
!= NULL
&& discarded_section (sec
))
14345 _bfd_clear_contents (ppc64_elf_howto_table
[r_type
],
14346 input_bfd
, input_section
,
14347 contents
, rel
->r_offset
);
14348 wrel
->r_offset
= rel
->r_offset
;
14350 wrel
->r_addend
= 0;
14352 /* For ld -r, remove relocations in debug sections against
14353 symbols defined in discarded sections. Not done for
14354 non-debug to preserve relocs in .eh_frame which the
14355 eh_frame editing code expects to be present. */
14356 if (bfd_link_relocatable (info
)
14357 && (input_section
->flags
& SEC_DEBUGGING
))
14363 if (bfd_link_relocatable (info
))
14366 if (h
!= NULL
&& &h
->elf
== htab
->elf
.hgot
)
14368 relocation
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
14369 sec
= bfd_abs_section_ptr
;
14370 unresolved_reloc
= FALSE
;
14373 /* TLS optimizations. Replace instruction sequences and relocs
14374 based on information we collected in tls_optimize. We edit
14375 RELOCS so that --emit-relocs will output something sensible
14376 for the final instruction stream. */
14381 tls_mask
= h
->tls_mask
;
14382 else if (local_got_ents
!= NULL
)
14384 struct plt_entry
**local_plt
= (struct plt_entry
**)
14385 (local_got_ents
+ symtab_hdr
->sh_info
);
14386 unsigned char *lgot_masks
= (unsigned char *)
14387 (local_plt
+ symtab_hdr
->sh_info
);
14388 tls_mask
= lgot_masks
[r_symndx
];
14390 if (((tls_mask
& TLS_TLS
) == 0 || tls_mask
== (TLS_TLS
| TLS_MARK
))
14391 && (r_type
== R_PPC64_TLS
14392 || r_type
== R_PPC64_TLSGD
14393 || r_type
== R_PPC64_TLSLD
))
14395 /* Check for toc tls entries. */
14396 unsigned char *toc_tls
;
14398 if (!get_tls_mask (&toc_tls
, &toc_symndx
, &toc_addend
,
14399 &local_syms
, rel
, input_bfd
))
14403 tls_mask
= *toc_tls
;
14406 /* Check that tls relocs are used with tls syms, and non-tls
14407 relocs are used with non-tls syms. */
14408 if (r_symndx
!= STN_UNDEF
14409 && r_type
!= R_PPC64_NONE
14411 || h
->elf
.root
.type
== bfd_link_hash_defined
14412 || h
->elf
.root
.type
== bfd_link_hash_defweak
)
14413 && IS_PPC64_TLS_RELOC (r_type
) != (sym_type
== STT_TLS
))
14415 if ((tls_mask
& TLS_TLS
) != 0
14416 && (r_type
== R_PPC64_TLS
14417 || r_type
== R_PPC64_TLSGD
14418 || r_type
== R_PPC64_TLSLD
))
14419 /* R_PPC64_TLS is OK against a symbol in the TOC. */
14422 info
->callbacks
->einfo
14423 (!IS_PPC64_TLS_RELOC (r_type
)
14424 /* xgettext:c-format */
14425 ? _("%H: %s used with TLS symbol `%pT'\n")
14426 /* xgettext:c-format */
14427 : _("%H: %s used with non-TLS symbol `%pT'\n"),
14428 input_bfd
, input_section
, rel
->r_offset
,
14429 ppc64_elf_howto_table
[r_type
]->name
,
14433 /* Ensure reloc mapping code below stays sane. */
14434 if (R_PPC64_TOC16_LO_DS
!= R_PPC64_TOC16_DS
+ 1
14435 || R_PPC64_TOC16_LO
!= R_PPC64_TOC16
+ 1
14436 || (R_PPC64_GOT_TLSLD16
& 3) != (R_PPC64_GOT_TLSGD16
& 3)
14437 || (R_PPC64_GOT_TLSLD16_LO
& 3) != (R_PPC64_GOT_TLSGD16_LO
& 3)
14438 || (R_PPC64_GOT_TLSLD16_HI
& 3) != (R_PPC64_GOT_TLSGD16_HI
& 3)
14439 || (R_PPC64_GOT_TLSLD16_HA
& 3) != (R_PPC64_GOT_TLSGD16_HA
& 3)
14440 || (R_PPC64_GOT_TLSLD16
& 3) != (R_PPC64_GOT_TPREL16_DS
& 3)
14441 || (R_PPC64_GOT_TLSLD16_LO
& 3) != (R_PPC64_GOT_TPREL16_LO_DS
& 3)
14442 || (R_PPC64_GOT_TLSLD16_HI
& 3) != (R_PPC64_GOT_TPREL16_HI
& 3)
14443 || (R_PPC64_GOT_TLSLD16_HA
& 3) != (R_PPC64_GOT_TPREL16_HA
& 3))
14451 case R_PPC64_LO_DS_OPT
:
14452 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
- d_offset
);
14453 if ((insn
& (0x3f << 26)) != 58u << 26)
14455 insn
+= (14u << 26) - (58u << 26);
14456 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
- d_offset
);
14457 r_type
= R_PPC64_TOC16_LO
;
14458 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14461 case R_PPC64_TOC16
:
14462 case R_PPC64_TOC16_LO
:
14463 case R_PPC64_TOC16_DS
:
14464 case R_PPC64_TOC16_LO_DS
:
14466 /* Check for toc tls entries. */
14467 unsigned char *toc_tls
;
14470 retval
= get_tls_mask (&toc_tls
, &toc_symndx
, &toc_addend
,
14471 &local_syms
, rel
, input_bfd
);
14477 tls_mask
= *toc_tls
;
14478 if (r_type
== R_PPC64_TOC16_DS
14479 || r_type
== R_PPC64_TOC16_LO_DS
)
14481 if ((tls_mask
& TLS_TLS
) != 0
14482 && (tls_mask
& (TLS_DTPREL
| TLS_TPREL
)) == 0)
14487 /* If we found a GD reloc pair, then we might be
14488 doing a GD->IE transition. */
14492 if ((tls_mask
& TLS_TLS
) != 0
14493 && (tls_mask
& TLS_GD
) == 0)
14496 else if (retval
== 3)
14498 if ((tls_mask
& TLS_TLS
) != 0
14499 && (tls_mask
& TLS_LD
) == 0)
14507 case R_PPC64_GOT_TPREL16_HI
:
14508 case R_PPC64_GOT_TPREL16_HA
:
14509 if ((tls_mask
& TLS_TLS
) != 0
14510 && (tls_mask
& TLS_TPREL
) == 0)
14512 rel
->r_offset
-= d_offset
;
14513 bfd_put_32 (input_bfd
, NOP
, contents
+ rel
->r_offset
);
14514 r_type
= R_PPC64_NONE
;
14515 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14519 case R_PPC64_GOT_TPREL16_DS
:
14520 case R_PPC64_GOT_TPREL16_LO_DS
:
14521 if ((tls_mask
& TLS_TLS
) != 0
14522 && (tls_mask
& TLS_TPREL
) == 0)
14525 insn
= bfd_get_32 (input_bfd
,
14526 contents
+ rel
->r_offset
- d_offset
);
14528 insn
|= 0x3c0d0000; /* addis 0,13,0 */
14529 bfd_put_32 (input_bfd
, insn
,
14530 contents
+ rel
->r_offset
- d_offset
);
14531 r_type
= R_PPC64_TPREL16_HA
;
14532 if (toc_symndx
!= 0)
14534 rel
->r_info
= ELF64_R_INFO (toc_symndx
, r_type
);
14535 rel
->r_addend
= toc_addend
;
14536 /* We changed the symbol. Start over in order to
14537 get h, sym, sec etc. right. */
14541 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14545 case R_PPC64_GOT_TPREL34
:
14546 if ((tls_mask
& TLS_TLS
) != 0
14547 && (tls_mask
& TLS_TPREL
) == 0)
14549 /* pld ra,sym@got@tprel@pcrel -> paddi ra,r13,sym@tprel */
14550 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
14552 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
14553 pinsn
+= ((2ULL << 56) + (-1ULL << 52)
14554 + (14ULL << 26) - (57ULL << 26) + (13ULL << 16));
14555 bfd_put_32 (input_bfd
, pinsn
>> 32,
14556 contents
+ rel
->r_offset
);
14557 bfd_put_32 (input_bfd
, pinsn
& 0xffffffff,
14558 contents
+ rel
->r_offset
+ 4);
14559 r_type
= R_PPC64_TPREL34
;
14560 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14565 if ((tls_mask
& TLS_TLS
) != 0
14566 && (tls_mask
& TLS_TPREL
) == 0)
14568 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
14569 insn
= _bfd_elf_ppc_at_tls_transform (insn
, 13);
14572 if ((rel
->r_offset
& 3) == 0)
14574 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
14575 /* Was PPC64_TLS which sits on insn boundary, now
14576 PPC64_TPREL16_LO which is at low-order half-word. */
14577 rel
->r_offset
+= d_offset
;
14578 r_type
= R_PPC64_TPREL16_LO
;
14579 if (toc_symndx
!= 0)
14581 rel
->r_info
= ELF64_R_INFO (toc_symndx
, r_type
);
14582 rel
->r_addend
= toc_addend
;
14583 /* We changed the symbol. Start over in order to
14584 get h, sym, sec etc. right. */
14588 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14590 else if ((rel
->r_offset
& 3) == 1)
14592 /* For pcrel IE to LE we already have the full
14593 offset and thus don't need an addi here. A nop
14595 if ((insn
& (0x3f << 26)) == 14 << 26)
14597 /* Extract regs from addi rt,ra,si. */
14598 unsigned int rt
= (insn
>> 21) & 0x1f;
14599 unsigned int ra
= (insn
>> 16) & 0x1f;
14604 /* Build or ra,rs,rb with rb==rs, ie. mr ra,rs. */
14605 insn
= (rt
<< 16) | (ra
<< 21) | (ra
<< 11);
14606 insn
|= (31u << 26) | (444u << 1);
14609 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
- 1);
14614 case R_PPC64_GOT_TLSGD16_HI
:
14615 case R_PPC64_GOT_TLSGD16_HA
:
14617 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0)
14621 case R_PPC64_GOT_TLSLD16_HI
:
14622 case R_PPC64_GOT_TLSLD16_HA
:
14623 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0)
14626 if ((tls_mask
& tls_gd
) != 0)
14627 r_type
= (((r_type
- (R_PPC64_GOT_TLSGD16
& 3)) & 3)
14628 + R_PPC64_GOT_TPREL16_DS
);
14631 rel
->r_offset
-= d_offset
;
14632 bfd_put_32 (input_bfd
, NOP
, contents
+ rel
->r_offset
);
14633 r_type
= R_PPC64_NONE
;
14635 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14639 case R_PPC64_GOT_TLSGD16
:
14640 case R_PPC64_GOT_TLSGD16_LO
:
14642 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0)
14646 case R_PPC64_GOT_TLSLD16
:
14647 case R_PPC64_GOT_TLSLD16_LO
:
14648 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0)
14650 unsigned int insn1
, insn2
;
14653 offset
= (bfd_vma
) -1;
14654 /* If not using the newer R_PPC64_TLSGD/LD to mark
14655 __tls_get_addr calls, we must trust that the call
14656 stays with its arg setup insns, ie. that the next
14657 reloc is the __tls_get_addr call associated with
14658 the current reloc. Edit both insns. */
14659 if (input_section
->has_tls_get_addr_call
14660 && rel
+ 1 < relend
14661 && branch_reloc_hash_match (input_bfd
, rel
+ 1,
14662 htab
->tls_get_addr
,
14663 htab
->tls_get_addr_fd
))
14664 offset
= rel
[1].r_offset
;
14665 /* We read the low GOT_TLS (or TOC16) insn because we
14666 need to keep the destination reg. It may be
14667 something other than the usual r3, and moved to r3
14668 before the call by intervening code. */
14669 insn1
= bfd_get_32 (input_bfd
,
14670 contents
+ rel
->r_offset
- d_offset
);
14671 if ((tls_mask
& tls_gd
) != 0)
14674 insn1
&= (0x1f << 21) | (0x1f << 16);
14675 insn1
|= 58 << 26; /* ld */
14676 insn2
= 0x7c636a14; /* add 3,3,13 */
14677 if (offset
!= (bfd_vma
) -1)
14678 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
14679 if (r_type
== R_PPC64_TOC16
14680 || r_type
== R_PPC64_TOC16_LO
)
14681 r_type
+= R_PPC64_TOC16_DS
- R_PPC64_TOC16
;
14683 r_type
= (((r_type
- (R_PPC64_GOT_TLSGD16
& 1)) & 1)
14684 + R_PPC64_GOT_TPREL16_DS
);
14685 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14690 insn1
&= 0x1f << 21;
14691 insn1
|= 0x3c0d0000; /* addis r,13,0 */
14692 insn2
= 0x38630000; /* addi 3,3,0 */
14695 /* Was an LD reloc. */
14696 r_symndx
= STN_UNDEF
;
14697 rel
->r_addend
= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
14699 else if (toc_symndx
!= 0)
14701 r_symndx
= toc_symndx
;
14702 rel
->r_addend
= toc_addend
;
14704 r_type
= R_PPC64_TPREL16_HA
;
14705 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14706 if (offset
!= (bfd_vma
) -1)
14708 rel
[1].r_info
= ELF64_R_INFO (r_symndx
,
14709 R_PPC64_TPREL16_LO
);
14710 rel
[1].r_offset
= offset
+ d_offset
;
14711 rel
[1].r_addend
= rel
->r_addend
;
14714 bfd_put_32 (input_bfd
, insn1
,
14715 contents
+ rel
->r_offset
- d_offset
);
14716 if (offset
!= (bfd_vma
) -1)
14718 bfd_put_32 (input_bfd
, insn2
, contents
+ offset
);
14719 if (offset
+ 8 <= input_section
->size
)
14721 insn2
= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
14722 if (insn2
== LD_R2_0R1
+ STK_TOC (htab
))
14723 bfd_put_32 (input_bfd
, NOP
, contents
+ offset
+ 4);
14726 if ((tls_mask
& tls_gd
) == 0
14727 && (tls_gd
== 0 || toc_symndx
!= 0))
14729 /* We changed the symbol. Start over in order
14730 to get h, sym, sec etc. right. */
14736 case R_PPC64_GOT_TLSGD34
:
14737 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0)
14739 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
14741 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
14742 if ((tls_mask
& TLS_GDIE
) != 0)
14744 /* IE, pla -> pld */
14745 pinsn
+= (-2ULL << 56) + (57ULL << 26) - (14ULL << 26);
14746 r_type
= R_PPC64_GOT_TPREL34
;
14750 /* LE, pla pcrel -> paddi r13 */
14751 pinsn
+= (-1ULL << 52) + (13ULL << 16);
14752 r_type
= R_PPC64_TPREL34
;
14754 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14755 bfd_put_32 (input_bfd
, pinsn
>> 32,
14756 contents
+ rel
->r_offset
);
14757 bfd_put_32 (input_bfd
, pinsn
& 0xffffffff,
14758 contents
+ rel
->r_offset
+ 4);
14762 case R_PPC64_GOT_TLSLD34
:
14763 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0)
14765 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
14767 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
14768 pinsn
+= (-1ULL << 52) + (13ULL << 16);
14769 bfd_put_32 (input_bfd
, pinsn
>> 32,
14770 contents
+ rel
->r_offset
);
14771 bfd_put_32 (input_bfd
, pinsn
& 0xffffffff,
14772 contents
+ rel
->r_offset
+ 4);
14773 rel
->r_addend
= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
14774 r_symndx
= STN_UNDEF
;
14775 r_type
= R_PPC64_TPREL34
;
14776 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14781 case R_PPC64_TLSGD
:
14782 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0
14783 && rel
+ 1 < relend
)
14785 unsigned int insn2
;
14786 enum elf_ppc64_reloc_type r_type1
= ELF64_R_TYPE (rel
[1].r_info
);
14788 offset
= rel
->r_offset
;
14789 if (is_plt_seq_reloc (r_type1
))
14791 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
);
14792 if (r_type1
== R_PPC64_PLT_PCREL34
14793 || r_type1
== R_PPC64_PLT_PCREL34_NOTOC
)
14794 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
14795 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
14799 if (ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_PLTCALL
)
14800 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
14802 if ((tls_mask
& TLS_GDIE
) != 0)
14805 r_type
= R_PPC64_NONE
;
14806 insn2
= 0x7c636a14; /* add 3,3,13 */
14811 if (toc_symndx
!= 0)
14813 r_symndx
= toc_symndx
;
14814 rel
->r_addend
= toc_addend
;
14816 if (r_type1
== R_PPC64_REL24_NOTOC
14817 || r_type1
== R_PPC64_PLTCALL_NOTOC
)
14819 r_type
= R_PPC64_NONE
;
14824 rel
->r_offset
= offset
+ d_offset
;
14825 r_type
= R_PPC64_TPREL16_LO
;
14826 insn2
= 0x38630000; /* addi 3,3,0 */
14829 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14830 /* Zap the reloc on the _tls_get_addr call too. */
14831 BFD_ASSERT (offset
== rel
[1].r_offset
);
14832 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
14833 bfd_put_32 (input_bfd
, insn2
, contents
+ offset
);
14834 if ((tls_mask
& TLS_GDIE
) == 0
14836 && r_type
!= R_PPC64_NONE
)
14841 case R_PPC64_TLSLD
:
14842 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0
14843 && rel
+ 1 < relend
)
14845 unsigned int insn2
;
14846 enum elf_ppc64_reloc_type r_type1
= ELF64_R_TYPE (rel
[1].r_info
);
14848 offset
= rel
->r_offset
;
14849 if (is_plt_seq_reloc (r_type1
))
14851 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
);
14852 if (r_type1
== R_PPC64_PLT_PCREL34
14853 || r_type1
== R_PPC64_PLT_PCREL34_NOTOC
)
14854 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
14855 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
14859 if (ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_PLTCALL
)
14860 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
14862 if (r_type1
== R_PPC64_REL24_NOTOC
14863 || r_type1
== R_PPC64_PLTCALL_NOTOC
)
14865 r_type
= R_PPC64_NONE
;
14870 rel
->r_offset
= offset
+ d_offset
;
14871 r_symndx
= STN_UNDEF
;
14872 r_type
= R_PPC64_TPREL16_LO
;
14873 rel
->r_addend
= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
14874 insn2
= 0x38630000; /* addi 3,3,0 */
14876 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14877 /* Zap the reloc on the _tls_get_addr call too. */
14878 BFD_ASSERT (offset
== rel
[1].r_offset
);
14879 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
14880 bfd_put_32 (input_bfd
, insn2
, contents
+ offset
);
14881 if (r_type
!= R_PPC64_NONE
)
14886 case R_PPC64_DTPMOD64
:
14887 if (rel
+ 1 < relend
14888 && rel
[1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_DTPREL64
)
14889 && rel
[1].r_offset
== rel
->r_offset
+ 8)
14891 if ((tls_mask
& TLS_GD
) == 0)
14893 rel
[1].r_info
= ELF64_R_INFO (r_symndx
, R_PPC64_NONE
);
14894 if ((tls_mask
& TLS_GDIE
) != 0)
14895 r_type
= R_PPC64_TPREL64
;
14898 bfd_put_64 (output_bfd
, 1, contents
+ rel
->r_offset
);
14899 r_type
= R_PPC64_NONE
;
14901 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14906 if ((tls_mask
& TLS_LD
) == 0)
14908 bfd_put_64 (output_bfd
, 1, contents
+ rel
->r_offset
);
14909 r_type
= R_PPC64_NONE
;
14910 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14915 case R_PPC64_TPREL64
:
14916 if ((tls_mask
& TLS_TPREL
) == 0)
14918 r_type
= R_PPC64_NONE
;
14919 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14923 case R_PPC64_ENTRY
:
14924 relocation
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
14925 if (!bfd_link_pic (info
)
14926 && !info
->traditional_format
14927 && relocation
+ 0x80008000 <= 0xffffffff)
14929 unsigned int insn1
, insn2
;
14931 insn1
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
14932 insn2
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
14933 if ((insn1
& ~0xfffc) == LD_R2_0R12
14934 && insn2
== ADD_R2_R2_R12
)
14936 bfd_put_32 (input_bfd
,
14937 LIS_R2
+ PPC_HA (relocation
),
14938 contents
+ rel
->r_offset
);
14939 bfd_put_32 (input_bfd
,
14940 ADDI_R2_R2
+ PPC_LO (relocation
),
14941 contents
+ rel
->r_offset
+ 4);
14946 relocation
-= (rel
->r_offset
14947 + input_section
->output_offset
14948 + input_section
->output_section
->vma
);
14949 if (relocation
+ 0x80008000 <= 0xffffffff)
14951 unsigned int insn1
, insn2
;
14953 insn1
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
14954 insn2
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
14955 if ((insn1
& ~0xfffc) == LD_R2_0R12
14956 && insn2
== ADD_R2_R2_R12
)
14958 bfd_put_32 (input_bfd
,
14959 ADDIS_R2_R12
+ PPC_HA (relocation
),
14960 contents
+ rel
->r_offset
);
14961 bfd_put_32 (input_bfd
,
14962 ADDI_R2_R2
+ PPC_LO (relocation
),
14963 contents
+ rel
->r_offset
+ 4);
14969 case R_PPC64_REL16_HA
:
14970 /* If we are generating a non-PIC executable, edit
14971 . 0: addis 2,12,.TOC.-0b@ha
14972 . addi 2,2,.TOC.-0b@l
14973 used by ELFv2 global entry points to set up r2, to
14976 if .TOC. is in range. */
14977 if (!bfd_link_pic (info
)
14978 && !info
->traditional_format
14980 && rel
->r_addend
== d_offset
14981 && h
!= NULL
&& &h
->elf
== htab
->elf
.hgot
14982 && rel
+ 1 < relend
14983 && rel
[1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_REL16_LO
)
14984 && rel
[1].r_offset
== rel
->r_offset
+ 4
14985 && rel
[1].r_addend
== rel
->r_addend
+ 4
14986 && relocation
+ 0x80008000 <= 0xffffffff)
14988 unsigned int insn1
, insn2
;
14989 offset
= rel
->r_offset
- d_offset
;
14990 insn1
= bfd_get_32 (input_bfd
, contents
+ offset
);
14991 insn2
= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
14992 if ((insn1
& 0xffff0000) == ADDIS_R2_R12
14993 && (insn2
& 0xffff0000) == ADDI_R2_R2
)
14995 r_type
= R_PPC64_ADDR16_HA
;
14996 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14997 rel
->r_addend
-= d_offset
;
14998 rel
[1].r_info
= ELF64_R_INFO (r_symndx
, R_PPC64_ADDR16_LO
);
14999 rel
[1].r_addend
-= d_offset
+ 4;
15000 bfd_put_32 (input_bfd
, LIS_R2
, contents
+ offset
);
15006 /* Handle other relocations that tweak non-addend part of insn. */
15008 max_br_offset
= 1 << 25;
15009 addend
= rel
->r_addend
;
15010 reloc_dest
= DEST_NORMAL
;
15016 case R_PPC64_TOCSAVE
:
15017 if (relocation
+ addend
== (rel
->r_offset
15018 + input_section
->output_offset
15019 + input_section
->output_section
->vma
)
15020 && tocsave_find (htab
, NO_INSERT
,
15021 &local_syms
, rel
, input_bfd
))
15023 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15025 || insn
== CROR_151515
|| insn
== CROR_313131
)
15026 bfd_put_32 (input_bfd
,
15027 STD_R2_0R1
+ STK_TOC (htab
),
15028 contents
+ rel
->r_offset
);
15032 /* Branch taken prediction relocations. */
15033 case R_PPC64_ADDR14_BRTAKEN
:
15034 case R_PPC64_REL14_BRTAKEN
:
15035 insn
= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
15036 /* Fall through. */
15038 /* Branch not taken prediction relocations. */
15039 case R_PPC64_ADDR14_BRNTAKEN
:
15040 case R_PPC64_REL14_BRNTAKEN
:
15041 insn
|= bfd_get_32 (input_bfd
,
15042 contents
+ rel
->r_offset
) & ~(0x01 << 21);
15043 /* Fall through. */
15045 case R_PPC64_REL14
:
15046 max_br_offset
= 1 << 15;
15047 /* Fall through. */
15049 case R_PPC64_REL24
:
15050 case R_PPC64_REL24_NOTOC
:
15051 case R_PPC64_PLTCALL
:
15052 case R_PPC64_PLTCALL_NOTOC
:
15053 /* Calls to functions with a different TOC, such as calls to
15054 shared objects, need to alter the TOC pointer. This is
15055 done using a linkage stub. A REL24 branching to these
15056 linkage stubs needs to be followed by a nop, as the nop
15057 will be replaced with an instruction to restore the TOC
15062 && h
->oh
->is_func_descriptor
)
15063 fdh
= ppc_follow_link (h
->oh
);
15064 stub_entry
= ppc_get_stub_entry (input_section
, sec
, fdh
, &orig_rel
,
15066 if ((r_type
== R_PPC64_PLTCALL
15067 || r_type
== R_PPC64_PLTCALL_NOTOC
)
15068 && stub_entry
!= NULL
15069 && stub_entry
->stub_type
>= ppc_stub_plt_call
15070 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15073 if (stub_entry
!= NULL
15074 && ((stub_entry
->stub_type
>= ppc_stub_plt_call
15075 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15076 || stub_entry
->stub_type
== ppc_stub_plt_branch_r2off
15077 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
15078 || stub_entry
->stub_type
== ppc_stub_long_branch_r2off
15079 || stub_entry
->stub_type
== ppc_stub_long_branch_both
))
15081 bfd_boolean can_plt_call
= FALSE
;
15083 if (stub_entry
->stub_type
== ppc_stub_plt_call
15085 && htab
->params
->plt_localentry0
!= 0
15086 && is_elfv2_localentry0 (&h
->elf
))
15088 /* The function doesn't use or change r2. */
15089 can_plt_call
= TRUE
;
15091 else if (r_type
== R_PPC64_REL24_NOTOC
)
15093 /* NOTOC calls don't need to restore r2. */
15094 can_plt_call
= TRUE
;
15097 /* All of these stubs may modify r2, so there must be a
15098 branch and link followed by a nop. The nop is
15099 replaced by an insn to restore r2. */
15100 else if (rel
->r_offset
+ 8 <= input_section
->size
)
15104 br
= bfd_get_32 (input_bfd
,
15105 contents
+ rel
->r_offset
);
15110 nop
= bfd_get_32 (input_bfd
,
15111 contents
+ rel
->r_offset
+ 4);
15112 if (nop
== LD_R2_0R1
+ STK_TOC (htab
))
15113 can_plt_call
= TRUE
;
15114 else if (nop
== NOP
15115 || nop
== CROR_151515
15116 || nop
== CROR_313131
)
15119 && (h
== htab
->tls_get_addr_fd
15120 || h
== htab
->tls_get_addr
)
15121 && htab
->params
->tls_get_addr_opt
)
15123 /* Special stub used, leave nop alone. */
15126 bfd_put_32 (input_bfd
,
15127 LD_R2_0R1
+ STK_TOC (htab
),
15128 contents
+ rel
->r_offset
+ 4);
15129 can_plt_call
= TRUE
;
15134 if (!can_plt_call
&& h
!= NULL
)
15136 const char *name
= h
->elf
.root
.root
.string
;
15141 if (strncmp (name
, "__libc_start_main", 17) == 0
15142 && (name
[17] == 0 || name
[17] == '@'))
15144 /* Allow crt1 branch to go via a toc adjusting
15145 stub. Other calls that never return could do
15146 the same, if we could detect such. */
15147 can_plt_call
= TRUE
;
15153 /* g++ as of 20130507 emits self-calls without a
15154 following nop. This is arguably wrong since we
15155 have conflicting information. On the one hand a
15156 global symbol and on the other a local call
15157 sequence, but don't error for this special case.
15158 It isn't possible to cheaply verify we have
15159 exactly such a call. Allow all calls to the same
15161 asection
*code_sec
= sec
;
15163 if (get_opd_info (sec
) != NULL
)
15165 bfd_vma off
= (relocation
+ addend
15166 - sec
->output_section
->vma
15167 - sec
->output_offset
);
15169 opd_entry_value (sec
, off
, &code_sec
, NULL
, FALSE
);
15171 if (code_sec
== input_section
)
15172 can_plt_call
= TRUE
;
15177 if (stub_entry
->stub_type
>= ppc_stub_plt_call
15178 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15179 info
->callbacks
->einfo
15180 /* xgettext:c-format */
15181 (_("%H: call to `%pT' lacks nop, can't restore toc; "
15182 "(plt call stub)\n"),
15183 input_bfd
, input_section
, rel
->r_offset
, sym_name
);
15185 info
->callbacks
->einfo
15186 /* xgettext:c-format */
15187 (_("%H: call to `%pT' lacks nop, can't restore toc; "
15188 "(toc save/adjust stub)\n"),
15189 input_bfd
, input_section
, rel
->r_offset
, sym_name
);
15191 bfd_set_error (bfd_error_bad_value
);
15196 && stub_entry
->stub_type
>= ppc_stub_plt_call
15197 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15198 unresolved_reloc
= FALSE
;
15201 if ((stub_entry
== NULL
15202 || stub_entry
->stub_type
== ppc_stub_long_branch
15203 || stub_entry
->stub_type
== ppc_stub_plt_branch
)
15204 && get_opd_info (sec
) != NULL
)
15206 /* The branch destination is the value of the opd entry. */
15207 bfd_vma off
= (relocation
+ addend
15208 - sec
->output_section
->vma
15209 - sec
->output_offset
);
15210 bfd_vma dest
= opd_entry_value (sec
, off
, NULL
, NULL
, FALSE
);
15211 if (dest
!= (bfd_vma
) -1)
15215 reloc_dest
= DEST_OPD
;
15219 /* If the branch is out of reach we ought to have a long
15221 from
= (rel
->r_offset
15222 + input_section
->output_offset
15223 + input_section
->output_section
->vma
);
15225 relocation
+= PPC64_LOCAL_ENTRY_OFFSET (fdh
15229 if (stub_entry
!= NULL
15230 && (stub_entry
->stub_type
== ppc_stub_long_branch
15231 || stub_entry
->stub_type
== ppc_stub_plt_branch
)
15232 && (r_type
== R_PPC64_ADDR14_BRTAKEN
15233 || r_type
== R_PPC64_ADDR14_BRNTAKEN
15234 || (relocation
+ addend
- from
+ max_br_offset
15235 < 2 * max_br_offset
)))
15236 /* Don't use the stub if this branch is in range. */
15239 if (stub_entry
!= NULL
15240 && (stub_entry
->stub_type
== ppc_stub_long_branch_notoc
15241 || stub_entry
->stub_type
== ppc_stub_long_branch_both
15242 || stub_entry
->stub_type
== ppc_stub_plt_branch_notoc
15243 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
)
15244 && (r_type
!= R_PPC64_REL24_NOTOC
15245 || ((fdh
? fdh
->elf
.other
: sym
->st_other
)
15246 & STO_PPC64_LOCAL_MASK
) <= 1 << STO_PPC64_LOCAL_BIT
)
15247 && (relocation
+ addend
- from
+ max_br_offset
15248 < 2 * max_br_offset
))
15251 if (stub_entry
!= NULL
15252 && (stub_entry
->stub_type
== ppc_stub_long_branch_r2off
15253 || stub_entry
->stub_type
== ppc_stub_long_branch_both
15254 || stub_entry
->stub_type
== ppc_stub_plt_branch_r2off
15255 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
)
15256 && r_type
== R_PPC64_REL24_NOTOC
15257 && (relocation
+ addend
- from
+ max_br_offset
15258 < 2 * max_br_offset
))
15261 if (stub_entry
!= NULL
)
15263 /* Munge up the value and addend so that we call the stub
15264 rather than the procedure directly. */
15265 asection
*stub_sec
= stub_entry
->group
->stub_sec
;
15267 if (stub_entry
->stub_type
== ppc_stub_save_res
)
15268 relocation
+= (stub_sec
->output_offset
15269 + stub_sec
->output_section
->vma
15270 + stub_sec
->size
- htab
->sfpr
->size
15271 - htab
->sfpr
->output_offset
15272 - htab
->sfpr
->output_section
->vma
);
15274 relocation
= (stub_entry
->stub_offset
15275 + stub_sec
->output_offset
15276 + stub_sec
->output_section
->vma
);
15278 reloc_dest
= DEST_STUB
;
15280 if (((stub_entry
->stub_type
== ppc_stub_plt_call
15281 && ALWAYS_EMIT_R2SAVE
)
15282 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
15283 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
15285 && (h
== htab
->tls_get_addr_fd
15286 || h
== htab
->tls_get_addr
)
15287 && htab
->params
->tls_get_addr_opt
)
15288 && rel
+ 1 < relend
15289 && rel
[1].r_offset
== rel
->r_offset
+ 4
15290 && ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_TOCSAVE
)
15292 else if ((stub_entry
->stub_type
== ppc_stub_long_branch_both
15293 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
15294 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
15295 && r_type
== R_PPC64_REL24_NOTOC
)
15298 if (r_type
== R_PPC64_REL24_NOTOC
15299 && (stub_entry
->stub_type
== ppc_stub_plt_call_notoc
15300 || stub_entry
->stub_type
== ppc_stub_plt_call_both
))
15301 htab
->notoc_plt
= 1;
15308 /* Set 'a' bit. This is 0b00010 in BO field for branch
15309 on CR(BI) insns (BO == 001at or 011at), and 0b01000
15310 for branch on CTR insns (BO == 1a00t or 1a01t). */
15311 if ((insn
& (0x14 << 21)) == (0x04 << 21))
15312 insn
|= 0x02 << 21;
15313 else if ((insn
& (0x14 << 21)) == (0x10 << 21))
15314 insn
|= 0x08 << 21;
15320 /* Invert 'y' bit if not the default. */
15321 if ((bfd_signed_vma
) (relocation
+ addend
- from
) < 0)
15322 insn
^= 0x01 << 21;
15325 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
15328 /* NOP out calls to undefined weak functions.
15329 We can thus call a weak function without first
15330 checking whether the function is defined. */
15332 && h
->elf
.root
.type
== bfd_link_hash_undefweak
15333 && h
->elf
.dynindx
== -1
15334 && (r_type
== R_PPC64_REL24
15335 || r_type
== R_PPC64_REL24_NOTOC
)
15339 bfd_put_32 (input_bfd
, NOP
, contents
+ rel
->r_offset
);
15344 case R_PPC64_GOT16_DS
:
15345 from
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
15346 if (relocation
+ addend
- from
+ 0x8000 < 0x10000
15347 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15349 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
15350 if ((insn
& (0x3f << 26 | 0x3)) == 58u << 26 /* ld */)
15352 insn
+= (14u << 26) - (58u << 26);
15353 bfd_put_32 (input_bfd
, insn
, contents
+ (rel
->r_offset
& ~3));
15354 r_type
= R_PPC64_TOC16
;
15355 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15360 case R_PPC64_GOT16_LO_DS
:
15361 case R_PPC64_GOT16_HA
:
15362 from
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
15363 if (relocation
+ addend
- from
+ 0x80008000ULL
< 0x100000000ULL
15364 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15366 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
15367 if ((insn
& (0x3f << 26 | 0x3)) == 58u << 26 /* ld */)
15369 insn
+= (14u << 26) - (58u << 26);
15370 bfd_put_32 (input_bfd
, insn
, contents
+ (rel
->r_offset
& ~3));
15371 r_type
= R_PPC64_TOC16_LO
;
15372 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15374 else if ((insn
& (0x3f << 26)) == 15u << 26 /* addis */)
15376 r_type
= R_PPC64_TOC16_HA
;
15377 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15382 case R_PPC64_GOT_PCREL34
:
15383 from
= (rel
->r_offset
15384 + input_section
->output_section
->vma
15385 + input_section
->output_offset
);
15386 if (relocation
- from
+ (1ULL << 33) < 1ULL << 34
15387 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15389 offset
= rel
->r_offset
;
15390 pinsn
= bfd_get_32 (input_bfd
, contents
+ offset
);
15392 pinsn
|= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
15393 if ((pinsn
& ((-1ULL << 50) | (63ULL << 26)))
15394 == ((1ULL << 58) | (1ULL << 52) | (57ULL << 26) /* pld */))
15396 /* Replace with paddi. */
15397 pinsn
+= (2ULL << 56) + (14ULL << 26) - (57ULL << 26);
15398 r_type
= R_PPC64_PCREL34
;
15399 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15400 bfd_put_32 (input_bfd
, pinsn
>> 32, contents
+ offset
);
15401 bfd_put_32 (input_bfd
, pinsn
, contents
+ offset
+ 4);
15407 case R_PPC64_PCREL34
:
15408 if (SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15410 offset
= rel
->r_offset
;
15411 pinsn
= bfd_get_32 (input_bfd
, contents
+ offset
);
15413 pinsn
|= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
15414 if ((pinsn
& ((-1ULL << 50) | (63ULL << 26)))
15415 == ((1ULL << 58) | (2ULL << 56) | (1ULL << 52)
15416 | (14ULL << 26) /* paddi */))
15419 if (rel
+ 1 < relend
15420 && rel
[1].r_offset
== offset
15421 && rel
[1].r_info
== ELF64_R_INFO (0, R_PPC64_PCREL_OPT
))
15423 bfd_vma off2
= rel
[1].r_addend
;
15425 /* zero means next insn. */
15428 if (off2
+ 4 <= input_section
->size
)
15431 bfd_signed_vma addend_off
;
15432 pinsn2
= bfd_get_32 (input_bfd
, contents
+ off2
);
15434 if ((pinsn2
& (63ULL << 58)) == 1ULL << 58)
15436 if (off2
+ 8 > input_section
->size
)
15438 pinsn2
|= bfd_get_32 (input_bfd
,
15439 contents
+ off2
+ 4);
15441 if (xlate_pcrel_opt (&pinsn
, &pinsn2
, &addend_off
))
15443 addend
+= addend_off
;
15444 rel
->r_addend
= addend
;
15445 bfd_put_32 (input_bfd
, pinsn
>> 32,
15446 contents
+ offset
);
15447 bfd_put_32 (input_bfd
, pinsn
,
15448 contents
+ offset
+ 4);
15449 bfd_put_32 (input_bfd
, pinsn2
>> 32,
15451 if ((pinsn2
& (63ULL << 58)) == 1ULL << 58)
15452 bfd_put_32 (input_bfd
, pinsn2
,
15453 contents
+ off2
+ 4);
15463 save_unresolved_reloc
= unresolved_reloc
;
15467 /* xgettext:c-format */
15468 _bfd_error_handler (_("%pB: %s unsupported"),
15469 input_bfd
, ppc64_elf_howto_table
[r_type
]->name
);
15471 bfd_set_error (bfd_error_bad_value
);
15477 case R_PPC64_TLSGD
:
15478 case R_PPC64_TLSLD
:
15479 case R_PPC64_TOCSAVE
:
15480 case R_PPC64_GNU_VTINHERIT
:
15481 case R_PPC64_GNU_VTENTRY
:
15482 case R_PPC64_ENTRY
:
15483 case R_PPC64_PCREL_OPT
:
15486 /* GOT16 relocations. Like an ADDR16 using the symbol's
15487 address in the GOT as relocation value instead of the
15488 symbol's value itself. Also, create a GOT entry for the
15489 symbol and put the symbol value there. */
15490 case R_PPC64_GOT_TLSGD16
:
15491 case R_PPC64_GOT_TLSGD16_LO
:
15492 case R_PPC64_GOT_TLSGD16_HI
:
15493 case R_PPC64_GOT_TLSGD16_HA
:
15494 case R_PPC64_GOT_TLSGD34
:
15495 tls_type
= TLS_TLS
| TLS_GD
;
15498 case R_PPC64_GOT_TLSLD16
:
15499 case R_PPC64_GOT_TLSLD16_LO
:
15500 case R_PPC64_GOT_TLSLD16_HI
:
15501 case R_PPC64_GOT_TLSLD16_HA
:
15502 case R_PPC64_GOT_TLSLD34
:
15503 tls_type
= TLS_TLS
| TLS_LD
;
15506 case R_PPC64_GOT_TPREL16_DS
:
15507 case R_PPC64_GOT_TPREL16_LO_DS
:
15508 case R_PPC64_GOT_TPREL16_HI
:
15509 case R_PPC64_GOT_TPREL16_HA
:
15510 case R_PPC64_GOT_TPREL34
:
15511 tls_type
= TLS_TLS
| TLS_TPREL
;
15514 case R_PPC64_GOT_DTPREL16_DS
:
15515 case R_PPC64_GOT_DTPREL16_LO_DS
:
15516 case R_PPC64_GOT_DTPREL16_HI
:
15517 case R_PPC64_GOT_DTPREL16_HA
:
15518 case R_PPC64_GOT_DTPREL34
:
15519 tls_type
= TLS_TLS
| TLS_DTPREL
;
15522 case R_PPC64_GOT16
:
15523 case R_PPC64_GOT16_LO
:
15524 case R_PPC64_GOT16_HI
:
15525 case R_PPC64_GOT16_HA
:
15526 case R_PPC64_GOT16_DS
:
15527 case R_PPC64_GOT16_LO_DS
:
15528 case R_PPC64_GOT_PCREL34
:
15531 /* Relocation is to the entry for this symbol in the global
15536 unsigned long indx
= 0;
15537 struct got_entry
*ent
;
15538 bfd_vma sym_addend
= orig_rel
.r_addend
;
15540 if (r_type
== R_PPC64_GOT_PCREL34
15541 || r_type
== R_PPC64_GOT_TLSGD34
15542 || r_type
== R_PPC64_GOT_TLSLD34
15543 || r_type
== R_PPC64_GOT_TPREL34
15544 || r_type
== R_PPC64_GOT_DTPREL34
)
15547 if (tls_type
== (TLS_TLS
| TLS_LD
)
15549 || !h
->elf
.def_dynamic
))
15550 ent
= ppc64_tlsld_got (input_bfd
);
15555 if (!htab
->elf
.dynamic_sections_created
15556 || h
->elf
.dynindx
== -1
15557 || SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
)
15558 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, &h
->elf
))
15559 /* This is actually a static link, or it is a
15560 -Bsymbolic link and the symbol is defined
15561 locally, or the symbol was forced to be local
15562 because of a version file. */
15566 indx
= h
->elf
.dynindx
;
15567 unresolved_reloc
= FALSE
;
15569 ent
= h
->elf
.got
.glist
;
15573 if (local_got_ents
== NULL
)
15575 ent
= local_got_ents
[r_symndx
];
15578 for (; ent
!= NULL
; ent
= ent
->next
)
15579 if (ent
->addend
== sym_addend
15580 && ent
->owner
== input_bfd
15581 && ent
->tls_type
== tls_type
)
15587 if (ent
->is_indirect
)
15588 ent
= ent
->got
.ent
;
15589 offp
= &ent
->got
.offset
;
15590 got
= ppc64_elf_tdata (ent
->owner
)->got
;
15594 /* The offset must always be a multiple of 8. We use the
15595 least significant bit to record whether we have already
15596 processed this entry. */
15598 if ((off
& 1) != 0)
15602 /* Generate relocs for the dynamic linker, except in
15603 the case of TLSLD where we'll use one entry per
15611 ? h
->elf
.type
== STT_GNU_IFUNC
15612 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
);
15615 relgot
= htab
->elf
.irelplt
;
15617 htab
->local_ifunc_resolver
= 1;
15618 else if (is_static_defined (&h
->elf
))
15619 htab
->maybe_local_ifunc_resolver
= 1;
15622 || (bfd_link_pic (info
)
15624 || !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, &h
->elf
)
15625 || (tls_type
== (TLS_TLS
| TLS_LD
)
15626 && !h
->elf
.def_dynamic
))
15627 && !(tls_type
== (TLS_TLS
| TLS_TPREL
)
15628 && bfd_link_executable (info
)
15629 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))))
15630 relgot
= ppc64_elf_tdata (ent
->owner
)->relgot
;
15631 if (relgot
!= NULL
)
15633 outrel
.r_offset
= (got
->output_section
->vma
15634 + got
->output_offset
15636 outrel
.r_addend
= sym_addend
;
15637 if (tls_type
& (TLS_LD
| TLS_GD
))
15639 outrel
.r_addend
= 0;
15640 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_DTPMOD64
);
15641 if (tls_type
== (TLS_TLS
| TLS_GD
))
15643 loc
= relgot
->contents
;
15644 loc
+= (relgot
->reloc_count
++
15645 * sizeof (Elf64_External_Rela
));
15646 bfd_elf64_swap_reloca_out (output_bfd
,
15648 outrel
.r_offset
+= 8;
15649 outrel
.r_addend
= sym_addend
;
15651 = ELF64_R_INFO (indx
, R_PPC64_DTPREL64
);
15654 else if (tls_type
== (TLS_TLS
| TLS_DTPREL
))
15655 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_DTPREL64
);
15656 else if (tls_type
== (TLS_TLS
| TLS_TPREL
))
15657 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_TPREL64
);
15658 else if (indx
!= 0)
15659 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_GLOB_DAT
);
15663 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
15665 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
15667 /* Write the .got section contents for the sake
15669 loc
= got
->contents
+ off
;
15670 bfd_put_64 (output_bfd
, outrel
.r_addend
+ relocation
,
15674 if (indx
== 0 && tls_type
!= (TLS_TLS
| TLS_LD
))
15676 outrel
.r_addend
+= relocation
;
15677 if (tls_type
& (TLS_GD
| TLS_DTPREL
| TLS_TPREL
))
15679 if (htab
->elf
.tls_sec
== NULL
)
15680 outrel
.r_addend
= 0;
15682 outrel
.r_addend
-= htab
->elf
.tls_sec
->vma
;
15685 loc
= relgot
->contents
;
15686 loc
+= (relgot
->reloc_count
++
15687 * sizeof (Elf64_External_Rela
));
15688 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
15691 /* Init the .got section contents here if we're not
15692 emitting a reloc. */
15695 relocation
+= sym_addend
;
15698 if (htab
->elf
.tls_sec
== NULL
)
15702 if (tls_type
& TLS_LD
)
15705 relocation
-= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
15706 if (tls_type
& TLS_TPREL
)
15707 relocation
+= DTP_OFFSET
- TP_OFFSET
;
15710 if (tls_type
& (TLS_GD
| TLS_LD
))
15712 bfd_put_64 (output_bfd
, relocation
,
15713 got
->contents
+ off
+ 8);
15717 bfd_put_64 (output_bfd
, relocation
,
15718 got
->contents
+ off
);
15722 if (off
>= (bfd_vma
) -2)
15725 relocation
= got
->output_section
->vma
+ got
->output_offset
+ off
;
15726 if (!(r_type
== R_PPC64_GOT_PCREL34
15727 || r_type
== R_PPC64_GOT_TLSGD34
15728 || r_type
== R_PPC64_GOT_TLSLD34
15729 || r_type
== R_PPC64_GOT_TPREL34
15730 || r_type
== R_PPC64_GOT_DTPREL34
))
15731 addend
= -(TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
);
15735 case R_PPC64_PLT16_HA
:
15736 case R_PPC64_PLT16_HI
:
15737 case R_PPC64_PLT16_LO
:
15738 case R_PPC64_PLT16_LO_DS
:
15739 case R_PPC64_PLT_PCREL34
:
15740 case R_PPC64_PLT_PCREL34_NOTOC
:
15741 case R_PPC64_PLT32
:
15742 case R_PPC64_PLT64
:
15743 case R_PPC64_PLTSEQ
:
15744 case R_PPC64_PLTSEQ_NOTOC
:
15745 case R_PPC64_PLTCALL
:
15746 case R_PPC64_PLTCALL_NOTOC
:
15747 /* Relocation is to the entry for this symbol in the
15748 procedure linkage table. */
15749 unresolved_reloc
= TRUE
;
15751 struct plt_entry
**plt_list
= NULL
;
15753 plt_list
= &h
->elf
.plt
.plist
;
15754 else if (local_got_ents
!= NULL
)
15756 struct plt_entry
**local_plt
= (struct plt_entry
**)
15757 (local_got_ents
+ symtab_hdr
->sh_info
);
15758 plt_list
= local_plt
+ r_symndx
;
15762 struct plt_entry
*ent
;
15763 bfd_vma sym_addend
= orig_rel
.r_addend
;
15765 if (r_type
== R_PPC64_PLT_PCREL34
15766 || r_type
== R_PPC64_PLT_PCREL34_NOTOC
)
15769 for (ent
= *plt_list
; ent
!= NULL
; ent
= ent
->next
)
15770 if (ent
->plt
.offset
!= (bfd_vma
) -1
15771 && ent
->addend
== sym_addend
)
15776 plt
= htab
->elf
.splt
;
15777 if (!htab
->elf
.dynamic_sections_created
15779 || h
->elf
.dynindx
== -1)
15782 ? h
->elf
.type
== STT_GNU_IFUNC
15783 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
15784 plt
= htab
->elf
.iplt
;
15786 plt
= htab
->pltlocal
;
15788 relocation
= (plt
->output_section
->vma
15789 + plt
->output_offset
15790 + ent
->plt
.offset
);
15791 if (r_type
== R_PPC64_PLT16_HA
15792 || r_type
== R_PPC64_PLT16_HI
15793 || r_type
== R_PPC64_PLT16_LO
15794 || r_type
== R_PPC64_PLT16_LO_DS
)
15796 got
= (elf_gp (output_bfd
)
15797 + htab
->sec_info
[input_section
->id
].toc_off
);
15800 if (r_type
!= R_PPC64_PLT_PCREL34
15801 && r_type
!= R_PPC64_PLT_PCREL34_NOTOC
)
15803 unresolved_reloc
= FALSE
;
15811 /* Relocation value is TOC base. */
15812 relocation
= TOCstart
;
15813 if (r_symndx
== STN_UNDEF
)
15814 relocation
+= htab
->sec_info
[input_section
->id
].toc_off
;
15815 else if (unresolved_reloc
)
15817 else if (sec
!= NULL
&& sec
->id
< htab
->sec_info_arr_size
)
15818 relocation
+= htab
->sec_info
[sec
->id
].toc_off
;
15820 unresolved_reloc
= TRUE
;
15823 /* TOC16 relocs. We want the offset relative to the TOC base,
15824 which is the address of the start of the TOC plus 0x8000.
15825 The TOC consists of sections .got, .toc, .tocbss, and .plt,
15827 case R_PPC64_TOC16
:
15828 case R_PPC64_TOC16_LO
:
15829 case R_PPC64_TOC16_HI
:
15830 case R_PPC64_TOC16_DS
:
15831 case R_PPC64_TOC16_LO_DS
:
15832 case R_PPC64_TOC16_HA
:
15833 addend
-= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
15836 /* Relocate against the beginning of the section. */
15837 case R_PPC64_SECTOFF
:
15838 case R_PPC64_SECTOFF_LO
:
15839 case R_PPC64_SECTOFF_HI
:
15840 case R_PPC64_SECTOFF_DS
:
15841 case R_PPC64_SECTOFF_LO_DS
:
15842 case R_PPC64_SECTOFF_HA
:
15844 addend
-= sec
->output_section
->vma
;
15847 case R_PPC64_REL16
:
15848 case R_PPC64_REL16_LO
:
15849 case R_PPC64_REL16_HI
:
15850 case R_PPC64_REL16_HA
:
15851 case R_PPC64_REL16_HIGH
:
15852 case R_PPC64_REL16_HIGHA
:
15853 case R_PPC64_REL16_HIGHER
:
15854 case R_PPC64_REL16_HIGHERA
:
15855 case R_PPC64_REL16_HIGHEST
:
15856 case R_PPC64_REL16_HIGHESTA
:
15857 case R_PPC64_REL16_HIGHER34
:
15858 case R_PPC64_REL16_HIGHERA34
:
15859 case R_PPC64_REL16_HIGHEST34
:
15860 case R_PPC64_REL16_HIGHESTA34
:
15861 case R_PPC64_REL16DX_HA
:
15862 case R_PPC64_REL14
:
15863 case R_PPC64_REL14_BRNTAKEN
:
15864 case R_PPC64_REL14_BRTAKEN
:
15865 case R_PPC64_REL24
:
15866 case R_PPC64_REL24_NOTOC
:
15867 case R_PPC64_PCREL34
:
15868 case R_PPC64_PCREL28
:
15871 case R_PPC64_TPREL16
:
15872 case R_PPC64_TPREL16_LO
:
15873 case R_PPC64_TPREL16_HI
:
15874 case R_PPC64_TPREL16_HA
:
15875 case R_PPC64_TPREL16_DS
:
15876 case R_PPC64_TPREL16_LO_DS
:
15877 case R_PPC64_TPREL16_HIGH
:
15878 case R_PPC64_TPREL16_HIGHA
:
15879 case R_PPC64_TPREL16_HIGHER
:
15880 case R_PPC64_TPREL16_HIGHERA
:
15881 case R_PPC64_TPREL16_HIGHEST
:
15882 case R_PPC64_TPREL16_HIGHESTA
:
15883 case R_PPC64_TPREL34
:
15885 && h
->elf
.root
.type
== bfd_link_hash_undefweak
15886 && h
->elf
.dynindx
== -1)
15888 /* Make this relocation against an undefined weak symbol
15889 resolve to zero. This is really just a tweak, since
15890 code using weak externs ought to check that they are
15891 defined before using them. */
15892 bfd_byte
*p
= contents
+ rel
->r_offset
- d_offset
;
15894 insn
= bfd_get_32 (input_bfd
, p
);
15895 insn
= _bfd_elf_ppc_at_tprel_transform (insn
, 13);
15897 bfd_put_32 (input_bfd
, insn
, p
);
15900 if (htab
->elf
.tls_sec
!= NULL
)
15901 addend
-= htab
->elf
.tls_sec
->vma
+ TP_OFFSET
;
15902 /* The TPREL16 relocs shouldn't really be used in shared
15903 libs or with non-local symbols as that will result in
15904 DT_TEXTREL being set, but support them anyway. */
15907 case R_PPC64_DTPREL16
:
15908 case R_PPC64_DTPREL16_LO
:
15909 case R_PPC64_DTPREL16_HI
:
15910 case R_PPC64_DTPREL16_HA
:
15911 case R_PPC64_DTPREL16_DS
:
15912 case R_PPC64_DTPREL16_LO_DS
:
15913 case R_PPC64_DTPREL16_HIGH
:
15914 case R_PPC64_DTPREL16_HIGHA
:
15915 case R_PPC64_DTPREL16_HIGHER
:
15916 case R_PPC64_DTPREL16_HIGHERA
:
15917 case R_PPC64_DTPREL16_HIGHEST
:
15918 case R_PPC64_DTPREL16_HIGHESTA
:
15919 case R_PPC64_DTPREL34
:
15920 if (htab
->elf
.tls_sec
!= NULL
)
15921 addend
-= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
15924 case R_PPC64_ADDR64_LOCAL
:
15925 addend
+= PPC64_LOCAL_ENTRY_OFFSET (h
!= NULL
15930 case R_PPC64_DTPMOD64
:
15935 case R_PPC64_TPREL64
:
15936 if (htab
->elf
.tls_sec
!= NULL
)
15937 addend
-= htab
->elf
.tls_sec
->vma
+ TP_OFFSET
;
15940 case R_PPC64_DTPREL64
:
15941 if (htab
->elf
.tls_sec
!= NULL
)
15942 addend
-= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
15943 /* Fall through. */
15945 /* Relocations that may need to be propagated if this is a
15947 case R_PPC64_REL30
:
15948 case R_PPC64_REL32
:
15949 case R_PPC64_REL64
:
15950 case R_PPC64_ADDR14
:
15951 case R_PPC64_ADDR14_BRNTAKEN
:
15952 case R_PPC64_ADDR14_BRTAKEN
:
15953 case R_PPC64_ADDR16
:
15954 case R_PPC64_ADDR16_DS
:
15955 case R_PPC64_ADDR16_HA
:
15956 case R_PPC64_ADDR16_HI
:
15957 case R_PPC64_ADDR16_HIGH
:
15958 case R_PPC64_ADDR16_HIGHA
:
15959 case R_PPC64_ADDR16_HIGHER
:
15960 case R_PPC64_ADDR16_HIGHERA
:
15961 case R_PPC64_ADDR16_HIGHEST
:
15962 case R_PPC64_ADDR16_HIGHESTA
:
15963 case R_PPC64_ADDR16_LO
:
15964 case R_PPC64_ADDR16_LO_DS
:
15965 case R_PPC64_ADDR16_HIGHER34
:
15966 case R_PPC64_ADDR16_HIGHERA34
:
15967 case R_PPC64_ADDR16_HIGHEST34
:
15968 case R_PPC64_ADDR16_HIGHESTA34
:
15969 case R_PPC64_ADDR24
:
15970 case R_PPC64_ADDR32
:
15971 case R_PPC64_ADDR64
:
15972 case R_PPC64_UADDR16
:
15973 case R_PPC64_UADDR32
:
15974 case R_PPC64_UADDR64
:
15976 case R_PPC64_D34_LO
:
15977 case R_PPC64_D34_HI30
:
15978 case R_PPC64_D34_HA30
:
15981 if ((input_section
->flags
& SEC_ALLOC
) == 0)
15984 if (NO_OPD_RELOCS
&& is_opd
)
15987 if (bfd_link_pic (info
)
15989 || h
->dyn_relocs
!= NULL
)
15990 && ((h
!= NULL
&& pc_dynrelocs (h
))
15991 || must_be_dyn_reloc (info
, r_type
)))
15993 ? h
->dyn_relocs
!= NULL
15994 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
))
15996 bfd_boolean skip
, relocate
;
16001 /* When generating a dynamic object, these relocations
16002 are copied into the output file to be resolved at run
16008 out_off
= _bfd_elf_section_offset (output_bfd
, info
,
16009 input_section
, rel
->r_offset
);
16010 if (out_off
== (bfd_vma
) -1)
16012 else if (out_off
== (bfd_vma
) -2)
16013 skip
= TRUE
, relocate
= TRUE
;
16014 out_off
+= (input_section
->output_section
->vma
16015 + input_section
->output_offset
);
16016 outrel
.r_offset
= out_off
;
16017 outrel
.r_addend
= rel
->r_addend
;
16019 /* Optimize unaligned reloc use. */
16020 if ((r_type
== R_PPC64_ADDR64
&& (out_off
& 7) != 0)
16021 || (r_type
== R_PPC64_UADDR64
&& (out_off
& 7) == 0))
16022 r_type
^= R_PPC64_ADDR64
^ R_PPC64_UADDR64
;
16023 else if ((r_type
== R_PPC64_ADDR32
&& (out_off
& 3) != 0)
16024 || (r_type
== R_PPC64_UADDR32
&& (out_off
& 3) == 0))
16025 r_type
^= R_PPC64_ADDR32
^ R_PPC64_UADDR32
;
16026 else if ((r_type
== R_PPC64_ADDR16
&& (out_off
& 1) != 0)
16027 || (r_type
== R_PPC64_UADDR16
&& (out_off
& 1) == 0))
16028 r_type
^= R_PPC64_ADDR16
^ R_PPC64_UADDR16
;
16031 memset (&outrel
, 0, sizeof outrel
);
16032 else if (!SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
)
16034 && r_type
!= R_PPC64_TOC
)
16036 indx
= h
->elf
.dynindx
;
16037 BFD_ASSERT (indx
!= -1);
16038 outrel
.r_info
= ELF64_R_INFO (indx
, r_type
);
16042 /* This symbol is local, or marked to become local,
16043 or this is an opd section reloc which must point
16044 at a local function. */
16045 outrel
.r_addend
+= relocation
;
16046 if (r_type
== R_PPC64_ADDR64
|| r_type
== R_PPC64_TOC
)
16048 if (is_opd
&& h
!= NULL
)
16050 /* Lie about opd entries. This case occurs
16051 when building shared libraries and we
16052 reference a function in another shared
16053 lib. The same thing happens for a weak
16054 definition in an application that's
16055 overridden by a strong definition in a
16056 shared lib. (I believe this is a generic
16057 bug in binutils handling of weak syms.)
16058 In these cases we won't use the opd
16059 entry in this lib. */
16060 unresolved_reloc
= FALSE
;
16063 && r_type
== R_PPC64_ADDR64
16065 ? h
->elf
.type
== STT_GNU_IFUNC
16066 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
))
16067 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
16070 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
16072 /* We need to relocate .opd contents for ld.so.
16073 Prelink also wants simple and consistent rules
16074 for relocs. This make all RELATIVE relocs have
16075 *r_offset equal to r_addend. */
16082 ? h
->elf
.type
== STT_GNU_IFUNC
16083 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
16085 info
->callbacks
->einfo
16086 /* xgettext:c-format */
16087 (_("%H: %s for indirect "
16088 "function `%pT' unsupported\n"),
16089 input_bfd
, input_section
, rel
->r_offset
,
16090 ppc64_elf_howto_table
[r_type
]->name
,
16094 else if (r_symndx
== STN_UNDEF
|| bfd_is_abs_section (sec
))
16096 else if (sec
== NULL
|| sec
->owner
== NULL
)
16098 bfd_set_error (bfd_error_bad_value
);
16103 asection
*osec
= sec
->output_section
;
16105 if ((osec
->flags
& SEC_THREAD_LOCAL
) != 0)
16107 /* TLS symbol values are relative to the
16108 TLS segment. Dynamic relocations for
16109 local TLS symbols therefore can't be
16110 reduced to a relocation against their
16111 section symbol because it holds the
16112 address of the section, not a value
16113 relative to the TLS segment. We could
16114 change the .tdata dynamic section symbol
16115 to be zero value but STN_UNDEF works
16116 and is used elsewhere, eg. for TPREL64
16117 GOT relocs against local TLS symbols. */
16118 osec
= htab
->elf
.tls_sec
;
16123 indx
= elf_section_data (osec
)->dynindx
;
16126 if ((osec
->flags
& SEC_READONLY
) == 0
16127 && htab
->elf
.data_index_section
!= NULL
)
16128 osec
= htab
->elf
.data_index_section
;
16130 osec
= htab
->elf
.text_index_section
;
16131 indx
= elf_section_data (osec
)->dynindx
;
16133 BFD_ASSERT (indx
!= 0);
16136 /* We are turning this relocation into one
16137 against a section symbol, so subtract out
16138 the output section's address but not the
16139 offset of the input section in the output
16141 outrel
.r_addend
-= osec
->vma
;
16144 outrel
.r_info
= ELF64_R_INFO (indx
, r_type
);
16148 sreloc
= elf_section_data (input_section
)->sreloc
;
16150 ? h
->elf
.type
== STT_GNU_IFUNC
16151 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
16153 sreloc
= htab
->elf
.irelplt
;
16155 htab
->local_ifunc_resolver
= 1;
16156 else if (is_static_defined (&h
->elf
))
16157 htab
->maybe_local_ifunc_resolver
= 1;
16159 if (sreloc
== NULL
)
16162 if (sreloc
->reloc_count
* sizeof (Elf64_External_Rela
)
16165 loc
= sreloc
->contents
;
16166 loc
+= sreloc
->reloc_count
++ * sizeof (Elf64_External_Rela
);
16167 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
16169 /* If this reloc is against an external symbol, it will
16170 be computed at runtime, so there's no need to do
16171 anything now. However, for the sake of prelink ensure
16172 that the section contents are a known value. */
16175 unresolved_reloc
= FALSE
;
16176 /* The value chosen here is quite arbitrary as ld.so
16177 ignores section contents except for the special
16178 case of .opd where the contents might be accessed
16179 before relocation. Choose zero, as that won't
16180 cause reloc overflow. */
16183 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
16184 to improve backward compatibility with older
16186 if (r_type
== R_PPC64_ADDR64
)
16187 addend
= outrel
.r_addend
;
16188 /* Adjust pc_relative relocs to have zero in *r_offset. */
16189 else if (ppc64_elf_howto_table
[r_type
]->pc_relative
)
16190 addend
= outrel
.r_offset
;
16196 case R_PPC64_GLOB_DAT
:
16197 case R_PPC64_JMP_SLOT
:
16198 case R_PPC64_JMP_IREL
:
16199 case R_PPC64_RELATIVE
:
16200 /* We shouldn't ever see these dynamic relocs in relocatable
16202 /* Fall through. */
16204 case R_PPC64_PLTGOT16
:
16205 case R_PPC64_PLTGOT16_DS
:
16206 case R_PPC64_PLTGOT16_HA
:
16207 case R_PPC64_PLTGOT16_HI
:
16208 case R_PPC64_PLTGOT16_LO
:
16209 case R_PPC64_PLTGOT16_LO_DS
:
16210 case R_PPC64_PLTREL32
:
16211 case R_PPC64_PLTREL64
:
16212 /* These ones haven't been implemented yet. */
16214 info
->callbacks
->einfo
16215 /* xgettext:c-format */
16216 (_("%P: %pB: %s is not supported for `%pT'\n"),
16218 ppc64_elf_howto_table
[r_type
]->name
, sym_name
);
16220 bfd_set_error (bfd_error_invalid_operation
);
16225 /* Multi-instruction sequences that access the TOC can be
16226 optimized, eg. addis ra,r2,0; addi rb,ra,x;
16227 to nop; addi rb,r2,x; */
16233 case R_PPC64_GOT_TLSLD16_HI
:
16234 case R_PPC64_GOT_TLSGD16_HI
:
16235 case R_PPC64_GOT_TPREL16_HI
:
16236 case R_PPC64_GOT_DTPREL16_HI
:
16237 case R_PPC64_GOT16_HI
:
16238 case R_PPC64_TOC16_HI
:
16239 /* These relocs would only be useful if building up an
16240 offset to later add to r2, perhaps in an indexed
16241 addressing mode instruction. Don't try to optimize.
16242 Unfortunately, the possibility of someone building up an
16243 offset like this or even with the HA relocs, means that
16244 we need to check the high insn when optimizing the low
16248 case R_PPC64_PLTCALL_NOTOC
:
16249 if (!unresolved_reloc
)
16250 htab
->notoc_plt
= 1;
16251 /* Fall through. */
16252 case R_PPC64_PLTCALL
:
16253 if (unresolved_reloc
)
16255 /* No plt entry. Make this into a direct call. */
16256 bfd_byte
*p
= contents
+ rel
->r_offset
;
16257 insn
= bfd_get_32 (input_bfd
, p
);
16259 bfd_put_32 (input_bfd
, B_DOT
| insn
, p
);
16260 if (r_type
== R_PPC64_PLTCALL
)
16261 bfd_put_32 (input_bfd
, NOP
, p
+ 4);
16262 unresolved_reloc
= save_unresolved_reloc
;
16263 r_type
= R_PPC64_REL24
;
16267 case R_PPC64_PLTSEQ_NOTOC
:
16268 case R_PPC64_PLTSEQ
:
16269 if (unresolved_reloc
)
16271 unresolved_reloc
= FALSE
;
16276 case R_PPC64_PLT_PCREL34_NOTOC
:
16277 if (!unresolved_reloc
)
16278 htab
->notoc_plt
= 1;
16279 /* Fall through. */
16280 case R_PPC64_PLT_PCREL34
:
16281 if (unresolved_reloc
)
16283 bfd_byte
*p
= contents
+ rel
->r_offset
;
16284 bfd_put_32 (input_bfd
, PNOP
>> 32, p
);
16285 bfd_put_32 (input_bfd
, PNOP
, p
+ 4);
16286 unresolved_reloc
= FALSE
;
16291 case R_PPC64_PLT16_HA
:
16292 if (unresolved_reloc
)
16294 unresolved_reloc
= FALSE
;
16297 /* Fall through. */
16298 case R_PPC64_GOT_TLSLD16_HA
:
16299 case R_PPC64_GOT_TLSGD16_HA
:
16300 case R_PPC64_GOT_TPREL16_HA
:
16301 case R_PPC64_GOT_DTPREL16_HA
:
16302 case R_PPC64_GOT16_HA
:
16303 case R_PPC64_TOC16_HA
:
16304 if (htab
->do_toc_opt
&& relocation
+ addend
+ 0x8000 < 0x10000
16305 && !ppc64_elf_tdata (input_bfd
)->unexpected_toc_insn
)
16309 p
= contents
+ (rel
->r_offset
& ~3);
16310 bfd_put_32 (input_bfd
, NOP
, p
);
16315 case R_PPC64_PLT16_LO
:
16316 case R_PPC64_PLT16_LO_DS
:
16317 if (unresolved_reloc
)
16319 unresolved_reloc
= FALSE
;
16322 /* Fall through. */
16323 case R_PPC64_GOT_TLSLD16_LO
:
16324 case R_PPC64_GOT_TLSGD16_LO
:
16325 case R_PPC64_GOT_TPREL16_LO_DS
:
16326 case R_PPC64_GOT_DTPREL16_LO_DS
:
16327 case R_PPC64_GOT16_LO
:
16328 case R_PPC64_GOT16_LO_DS
:
16329 case R_PPC64_TOC16_LO
:
16330 case R_PPC64_TOC16_LO_DS
:
16331 if (htab
->do_toc_opt
&& relocation
+ addend
+ 0x8000 < 0x10000
16332 && !ppc64_elf_tdata (input_bfd
)->unexpected_toc_insn
)
16334 bfd_byte
*p
= contents
+ (rel
->r_offset
& ~3);
16335 insn
= bfd_get_32 (input_bfd
, p
);
16336 if ((insn
& (0x3f << 26)) == 12u << 26 /* addic */)
16338 /* Transform addic to addi when we change reg. */
16339 insn
&= ~((0x3f << 26) | (0x1f << 16));
16340 insn
|= (14u << 26) | (2 << 16);
16344 insn
&= ~(0x1f << 16);
16347 bfd_put_32 (input_bfd
, insn
, p
);
16351 case R_PPC64_TPREL16_HA
:
16352 if (htab
->do_tls_opt
&& relocation
+ addend
+ 0x8000 < 0x10000)
16354 bfd_byte
*p
= contents
+ (rel
->r_offset
& ~3);
16355 insn
= bfd_get_32 (input_bfd
, p
);
16356 if ((insn
& ((0x3f << 26) | 0x1f << 16))
16357 != ((15u << 26) | (13 << 16)) /* addis rt,13,imm */)
16358 /* xgettext:c-format */
16359 info
->callbacks
->minfo
16360 (_("%H: warning: %s unexpected insn %#x.\n"),
16361 input_bfd
, input_section
, rel
->r_offset
,
16362 ppc64_elf_howto_table
[r_type
]->name
, insn
);
16365 bfd_put_32 (input_bfd
, NOP
, p
);
16371 case R_PPC64_TPREL16_LO
:
16372 case R_PPC64_TPREL16_LO_DS
:
16373 if (htab
->do_tls_opt
&& relocation
+ addend
+ 0x8000 < 0x10000)
16375 bfd_byte
*p
= contents
+ (rel
->r_offset
& ~3);
16376 insn
= bfd_get_32 (input_bfd
, p
);
16377 insn
&= ~(0x1f << 16);
16379 bfd_put_32 (input_bfd
, insn
, p
);
16384 /* Do any further special processing. */
16390 case R_PPC64_REL16_HA
:
16391 case R_PPC64_REL16_HIGHA
:
16392 case R_PPC64_REL16_HIGHERA
:
16393 case R_PPC64_REL16_HIGHESTA
:
16394 case R_PPC64_REL16DX_HA
:
16395 case R_PPC64_ADDR16_HA
:
16396 case R_PPC64_ADDR16_HIGHA
:
16397 case R_PPC64_ADDR16_HIGHERA
:
16398 case R_PPC64_ADDR16_HIGHESTA
:
16399 case R_PPC64_TOC16_HA
:
16400 case R_PPC64_SECTOFF_HA
:
16401 case R_PPC64_TPREL16_HA
:
16402 case R_PPC64_TPREL16_HIGHA
:
16403 case R_PPC64_TPREL16_HIGHERA
:
16404 case R_PPC64_TPREL16_HIGHESTA
:
16405 case R_PPC64_DTPREL16_HA
:
16406 case R_PPC64_DTPREL16_HIGHA
:
16407 case R_PPC64_DTPREL16_HIGHERA
:
16408 case R_PPC64_DTPREL16_HIGHESTA
:
16409 /* It's just possible that this symbol is a weak symbol
16410 that's not actually defined anywhere. In that case,
16411 'sec' would be NULL, and we should leave the symbol
16412 alone (it will be set to zero elsewhere in the link). */
16415 /* Fall through. */
16417 case R_PPC64_GOT16_HA
:
16418 case R_PPC64_PLTGOT16_HA
:
16419 case R_PPC64_PLT16_HA
:
16420 case R_PPC64_GOT_TLSGD16_HA
:
16421 case R_PPC64_GOT_TLSLD16_HA
:
16422 case R_PPC64_GOT_TPREL16_HA
:
16423 case R_PPC64_GOT_DTPREL16_HA
:
16424 /* Add 0x10000 if sign bit in 0:15 is set.
16425 Bits 0:15 are not used. */
16429 case R_PPC64_D34_HA30
:
16430 case R_PPC64_ADDR16_HIGHERA34
:
16431 case R_PPC64_ADDR16_HIGHESTA34
:
16432 case R_PPC64_REL16_HIGHERA34
:
16433 case R_PPC64_REL16_HIGHESTA34
:
16435 addend
+= 1ULL << 33;
16438 case R_PPC64_ADDR16_DS
:
16439 case R_PPC64_ADDR16_LO_DS
:
16440 case R_PPC64_GOT16_DS
:
16441 case R_PPC64_GOT16_LO_DS
:
16442 case R_PPC64_PLT16_LO_DS
:
16443 case R_PPC64_SECTOFF_DS
:
16444 case R_PPC64_SECTOFF_LO_DS
:
16445 case R_PPC64_TOC16_DS
:
16446 case R_PPC64_TOC16_LO_DS
:
16447 case R_PPC64_PLTGOT16_DS
:
16448 case R_PPC64_PLTGOT16_LO_DS
:
16449 case R_PPC64_GOT_TPREL16_DS
:
16450 case R_PPC64_GOT_TPREL16_LO_DS
:
16451 case R_PPC64_GOT_DTPREL16_DS
:
16452 case R_PPC64_GOT_DTPREL16_LO_DS
:
16453 case R_PPC64_TPREL16_DS
:
16454 case R_PPC64_TPREL16_LO_DS
:
16455 case R_PPC64_DTPREL16_DS
:
16456 case R_PPC64_DTPREL16_LO_DS
:
16457 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
16459 /* If this reloc is against an lq, lxv, or stxv insn, then
16460 the value must be a multiple of 16. This is somewhat of
16461 a hack, but the "correct" way to do this by defining _DQ
16462 forms of all the _DS relocs bloats all reloc switches in
16463 this file. It doesn't make much sense to use these
16464 relocs in data, so testing the insn should be safe. */
16465 if ((insn
& (0x3f << 26)) == (56u << 26)
16466 || ((insn
& (0x3f << 26)) == (61u << 26) && (insn
& 3) == 1))
16468 relocation
+= addend
;
16469 addend
= insn
& (mask
^ 3);
16470 if ((relocation
& mask
) != 0)
16472 relocation
^= relocation
& mask
;
16473 info
->callbacks
->einfo
16474 /* xgettext:c-format */
16475 (_("%H: error: %s not a multiple of %u\n"),
16476 input_bfd
, input_section
, rel
->r_offset
,
16477 ppc64_elf_howto_table
[r_type
]->name
,
16479 bfd_set_error (bfd_error_bad_value
);
16486 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
16487 because such sections are not SEC_ALLOC and thus ld.so will
16488 not process them. */
16489 howto
= ppc64_elf_howto_table
[(int) r_type
];
16490 if (unresolved_reloc
16491 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
16492 && h
->elf
.def_dynamic
)
16493 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
16494 rel
->r_offset
) != (bfd_vma
) -1)
16496 info
->callbacks
->einfo
16497 /* xgettext:c-format */
16498 (_("%H: unresolvable %s against `%pT'\n"),
16499 input_bfd
, input_section
, rel
->r_offset
,
16501 h
->elf
.root
.root
.string
);
16505 /* 16-bit fields in insns mostly have signed values, but a
16506 few insns have 16-bit unsigned values. Really, we should
16507 have different reloc types. */
16508 if (howto
->complain_on_overflow
!= complain_overflow_dont
16509 && howto
->dst_mask
== 0xffff
16510 && (input_section
->flags
& SEC_CODE
) != 0)
16512 enum complain_overflow complain
= complain_overflow_signed
;
16514 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
16515 if ((insn
& (0x3f << 26)) == 10u << 26 /* cmpli */)
16516 complain
= complain_overflow_bitfield
;
16517 else if (howto
->rightshift
== 0
16518 ? ((insn
& (0x3f << 26)) == 28u << 26 /* andi */
16519 || (insn
& (0x3f << 26)) == 24u << 26 /* ori */
16520 || (insn
& (0x3f << 26)) == 26u << 26 /* xori */)
16521 : ((insn
& (0x3f << 26)) == 29u << 26 /* andis */
16522 || (insn
& (0x3f << 26)) == 25u << 26 /* oris */
16523 || (insn
& (0x3f << 26)) == 27u << 26 /* xoris */))
16524 complain
= complain_overflow_unsigned
;
16525 if (howto
->complain_on_overflow
!= complain
)
16527 alt_howto
= *howto
;
16528 alt_howto
.complain_on_overflow
= complain
;
16529 howto
= &alt_howto
;
16535 /* Split field relocs aren't handled by _bfd_final_link_relocate. */
16537 case R_PPC64_D34_LO
:
16538 case R_PPC64_D34_HI30
:
16539 case R_PPC64_D34_HA30
:
16540 case R_PPC64_PCREL34
:
16541 case R_PPC64_GOT_PCREL34
:
16542 case R_PPC64_TPREL34
:
16543 case R_PPC64_DTPREL34
:
16544 case R_PPC64_GOT_TLSGD34
:
16545 case R_PPC64_GOT_TLSLD34
:
16546 case R_PPC64_GOT_TPREL34
:
16547 case R_PPC64_GOT_DTPREL34
:
16548 case R_PPC64_PLT_PCREL34
:
16549 case R_PPC64_PLT_PCREL34_NOTOC
:
16551 case R_PPC64_PCREL28
:
16552 if (rel
->r_offset
+ 8 > input_section
->size
)
16553 r
= bfd_reloc_outofrange
;
16556 relocation
+= addend
;
16557 if (howto
->pc_relative
)
16558 relocation
-= (rel
->r_offset
16559 + input_section
->output_offset
16560 + input_section
->output_section
->vma
);
16561 relocation
>>= howto
->rightshift
;
16563 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
16565 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
16567 pinsn
&= ~howto
->dst_mask
;
16568 pinsn
|= (((relocation
<< 16) | (relocation
& 0xffff))
16569 & howto
->dst_mask
);
16570 bfd_put_32 (input_bfd
, pinsn
>> 32, contents
+ rel
->r_offset
);
16571 bfd_put_32 (input_bfd
, pinsn
, contents
+ rel
->r_offset
+ 4);
16573 if (howto
->complain_on_overflow
== complain_overflow_signed
16574 && (relocation
+ (1ULL << (howto
->bitsize
- 1))
16575 >= 1ULL << howto
->bitsize
))
16576 r
= bfd_reloc_overflow
;
16580 case R_PPC64_REL16DX_HA
:
16581 if (rel
->r_offset
+ 4 > input_section
->size
)
16582 r
= bfd_reloc_outofrange
;
16585 relocation
+= addend
;
16586 relocation
-= (rel
->r_offset
16587 + input_section
->output_offset
16588 + input_section
->output_section
->vma
);
16589 relocation
= (bfd_signed_vma
) relocation
>> 16;
16590 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
16592 insn
|= (relocation
& 0xffc1) | ((relocation
& 0x3e) << 15);
16593 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
16595 if (relocation
+ 0x8000 > 0xffff)
16596 r
= bfd_reloc_overflow
;
16601 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
16602 contents
, rel
->r_offset
,
16603 relocation
, addend
);
16606 if (r
!= bfd_reloc_ok
)
16608 char *more_info
= NULL
;
16609 const char *reloc_name
= howto
->name
;
16611 if (reloc_dest
!= DEST_NORMAL
)
16613 more_info
= bfd_malloc (strlen (reloc_name
) + 8);
16614 if (more_info
!= NULL
)
16616 strcpy (more_info
, reloc_name
);
16617 strcat (more_info
, (reloc_dest
== DEST_OPD
16618 ? " (OPD)" : " (stub)"));
16619 reloc_name
= more_info
;
16623 if (r
== bfd_reloc_overflow
)
16625 /* On code like "if (foo) foo();" don't report overflow
16626 on a branch to zero when foo is undefined. */
16628 && (reloc_dest
== DEST_STUB
16630 && (h
->elf
.root
.type
== bfd_link_hash_undefweak
16631 || h
->elf
.root
.type
== bfd_link_hash_undefined
)
16632 && is_branch_reloc (r_type
))))
16633 info
->callbacks
->reloc_overflow (info
, &h
->elf
.root
,
16634 sym_name
, reloc_name
,
16636 input_bfd
, input_section
,
16641 info
->callbacks
->einfo
16642 /* xgettext:c-format */
16643 (_("%H: %s against `%pT': error %d\n"),
16644 input_bfd
, input_section
, rel
->r_offset
,
16645 reloc_name
, sym_name
, (int) r
);
16648 if (more_info
!= NULL
)
16658 Elf_Internal_Shdr
*rel_hdr
;
16659 size_t deleted
= rel
- wrel
;
16661 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
16662 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
16663 if (rel_hdr
->sh_size
== 0)
16665 /* It is too late to remove an empty reloc section. Leave
16667 ??? What is wrong with an empty section??? */
16668 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
16671 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
16672 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
16673 input_section
->reloc_count
-= deleted
;
16676 /* If we're emitting relocations, then shortly after this function
16677 returns, reloc offsets and addends for this section will be
16678 adjusted. Worse, reloc symbol indices will be for the output
16679 file rather than the input. Save a copy of the relocs for
16680 opd_entry_value. */
16681 if (is_opd
&& (info
->emitrelocations
|| bfd_link_relocatable (info
)))
16684 amt
= input_section
->reloc_count
* sizeof (Elf_Internal_Rela
);
16685 rel
= bfd_alloc (input_bfd
, amt
);
16686 BFD_ASSERT (ppc64_elf_tdata (input_bfd
)->opd
.relocs
== NULL
);
16687 ppc64_elf_tdata (input_bfd
)->opd
.relocs
= rel
;
16690 memcpy (rel
, relocs
, amt
);
16695 /* Adjust the value of any local symbols in opd sections. */
16698 ppc64_elf_output_symbol_hook (struct bfd_link_info
*info
,
16699 const char *name ATTRIBUTE_UNUSED
,
16700 Elf_Internal_Sym
*elfsym
,
16701 asection
*input_sec
,
16702 struct elf_link_hash_entry
*h
)
16704 struct _opd_sec_data
*opd
;
16711 opd
= get_opd_info (input_sec
);
16712 if (opd
== NULL
|| opd
->adjust
== NULL
)
16715 value
= elfsym
->st_value
- input_sec
->output_offset
;
16716 if (!bfd_link_relocatable (info
))
16717 value
-= input_sec
->output_section
->vma
;
16719 adjust
= opd
->adjust
[OPD_NDX (value
)];
16723 elfsym
->st_value
+= adjust
;
16727 /* Finish up dynamic symbol handling. We set the contents of various
16728 dynamic sections here. */
16731 ppc64_elf_finish_dynamic_symbol (bfd
*output_bfd
,
16732 struct bfd_link_info
*info
,
16733 struct elf_link_hash_entry
*h
,
16734 Elf_Internal_Sym
*sym
)
16736 struct ppc_link_hash_table
*htab
;
16737 struct plt_entry
*ent
;
16739 htab
= ppc_hash_table (info
);
16743 if (!htab
->opd_abi
&& !h
->def_regular
)
16744 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
16745 if (ent
->plt
.offset
!= (bfd_vma
) -1)
16747 /* Mark the symbol as undefined, rather than as
16748 defined in glink. Leave the value if there were
16749 any relocations where pointer equality matters
16750 (this is a clue for the dynamic linker, to make
16751 function pointer comparisons work between an
16752 application and shared library), otherwise set it
16754 sym
->st_shndx
= SHN_UNDEF
;
16755 if (!h
->pointer_equality_needed
)
16757 else if (!h
->ref_regular_nonweak
)
16759 /* This breaks function pointer comparisons, but
16760 that is better than breaking tests for a NULL
16761 function pointer. */
16769 /* This symbol needs a copy reloc. Set it up. */
16770 Elf_Internal_Rela rela
;
16774 if (h
->dynindx
== -1
16775 || (h
->root
.type
!= bfd_link_hash_defined
16776 && h
->root
.type
!= bfd_link_hash_defweak
)
16777 || htab
->elf
.srelbss
== NULL
16778 || htab
->elf
.sreldynrelro
== NULL
)
16781 rela
.r_offset
= (h
->root
.u
.def
.value
16782 + h
->root
.u
.def
.section
->output_section
->vma
16783 + h
->root
.u
.def
.section
->output_offset
);
16784 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_PPC64_COPY
);
16786 if (h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
16787 srel
= htab
->elf
.sreldynrelro
;
16789 srel
= htab
->elf
.srelbss
;
16790 loc
= srel
->contents
;
16791 loc
+= srel
->reloc_count
++ * sizeof (Elf64_External_Rela
);
16792 bfd_elf64_swap_reloca_out (output_bfd
, &rela
, loc
);
16798 /* Used to decide how to sort relocs in an optimal manner for the
16799 dynamic linker, before writing them out. */
16801 static enum elf_reloc_type_class
16802 ppc64_elf_reloc_type_class (const struct bfd_link_info
*info
,
16803 const asection
*rel_sec
,
16804 const Elf_Internal_Rela
*rela
)
16806 enum elf_ppc64_reloc_type r_type
;
16807 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
16809 if (rel_sec
== htab
->elf
.irelplt
)
16810 return reloc_class_ifunc
;
16812 r_type
= ELF64_R_TYPE (rela
->r_info
);
16815 case R_PPC64_RELATIVE
:
16816 return reloc_class_relative
;
16817 case R_PPC64_JMP_SLOT
:
16818 return reloc_class_plt
;
16820 return reloc_class_copy
;
16822 return reloc_class_normal
;
16826 /* Finish up the dynamic sections. */
16829 ppc64_elf_finish_dynamic_sections (bfd
*output_bfd
,
16830 struct bfd_link_info
*info
)
16832 struct ppc_link_hash_table
*htab
;
16836 htab
= ppc_hash_table (info
);
16840 dynobj
= htab
->elf
.dynobj
;
16841 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
16843 if (htab
->elf
.dynamic_sections_created
)
16845 Elf64_External_Dyn
*dyncon
, *dynconend
;
16847 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
16850 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
16851 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
16852 for (; dyncon
< dynconend
; dyncon
++)
16854 Elf_Internal_Dyn dyn
;
16857 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
16864 case DT_PPC64_GLINK
:
16866 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
16867 /* We stupidly defined DT_PPC64_GLINK to be the start
16868 of glink rather than the first entry point, which is
16869 what ld.so needs, and now have a bigger stub to
16870 support automatic multiple TOCs. */
16871 dyn
.d_un
.d_ptr
+= GLINK_PLTRESOLVE_SIZE (htab
) - 8 * 4;
16875 s
= bfd_get_section_by_name (output_bfd
, ".opd");
16878 dyn
.d_un
.d_ptr
= s
->vma
;
16882 if ((htab
->do_multi_toc
&& htab
->multi_toc_needed
)
16883 || htab
->notoc_plt
)
16884 dyn
.d_un
.d_val
|= PPC64_OPT_MULTI_TOC
;
16885 if (htab
->has_plt_localentry0
)
16886 dyn
.d_un
.d_val
|= PPC64_OPT_LOCALENTRY
;
16889 case DT_PPC64_OPDSZ
:
16890 s
= bfd_get_section_by_name (output_bfd
, ".opd");
16893 dyn
.d_un
.d_val
= s
->size
;
16897 s
= htab
->elf
.splt
;
16898 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
16902 s
= htab
->elf
.srelplt
;
16903 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
16907 dyn
.d_un
.d_val
= htab
->elf
.srelplt
->size
;
16911 if (htab
->local_ifunc_resolver
)
16912 info
->callbacks
->einfo
16913 (_("%X%P: text relocations and GNU indirect "
16914 "functions will result in a segfault at runtime\n"));
16915 else if (htab
->maybe_local_ifunc_resolver
)
16916 info
->callbacks
->einfo
16917 (_("%P: warning: text relocations and GNU indirect "
16918 "functions may result in a segfault at runtime\n"));
16922 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
16926 if (htab
->elf
.sgot
!= NULL
&& htab
->elf
.sgot
->size
!= 0
16927 && htab
->elf
.sgot
->output_section
!= bfd_abs_section_ptr
)
16929 /* Fill in the first entry in the global offset table.
16930 We use it to hold the link-time TOCbase. */
16931 bfd_put_64 (output_bfd
,
16932 elf_gp (output_bfd
) + TOC_BASE_OFF
,
16933 htab
->elf
.sgot
->contents
);
16935 /* Set .got entry size. */
16936 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
16940 if (htab
->elf
.splt
!= NULL
&& htab
->elf
.splt
->size
!= 0
16941 && htab
->elf
.splt
->output_section
!= bfd_abs_section_ptr
)
16943 /* Set .plt entry size. */
16944 elf_section_data (htab
->elf
.splt
->output_section
)->this_hdr
.sh_entsize
16945 = PLT_ENTRY_SIZE (htab
);
16948 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
16949 brlt ourselves if emitrelocations. */
16950 if (htab
->brlt
!= NULL
16951 && htab
->brlt
->reloc_count
!= 0
16952 && !_bfd_elf_link_output_relocs (output_bfd
,
16954 elf_section_data (htab
->brlt
)->rela
.hdr
,
16955 elf_section_data (htab
->brlt
)->relocs
,
16959 if (htab
->glink
!= NULL
16960 && htab
->glink
->reloc_count
!= 0
16961 && !_bfd_elf_link_output_relocs (output_bfd
,
16963 elf_section_data (htab
->glink
)->rela
.hdr
,
16964 elf_section_data (htab
->glink
)->relocs
,
16969 if (htab
->glink_eh_frame
!= NULL
16970 && htab
->glink_eh_frame
->size
!= 0
16971 && htab
->glink_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
16972 && !_bfd_elf_write_section_eh_frame (output_bfd
, info
,
16973 htab
->glink_eh_frame
,
16974 htab
->glink_eh_frame
->contents
))
16977 /* We need to handle writing out multiple GOT sections ourselves,
16978 since we didn't add them to DYNOBJ. We know dynobj is the first
16980 while ((dynobj
= dynobj
->link
.next
) != NULL
)
16984 if (!is_ppc64_elf (dynobj
))
16987 s
= ppc64_elf_tdata (dynobj
)->got
;
16990 && s
->output_section
!= bfd_abs_section_ptr
16991 && !bfd_set_section_contents (output_bfd
, s
->output_section
,
16992 s
->contents
, s
->output_offset
,
16995 s
= ppc64_elf_tdata (dynobj
)->relgot
;
16998 && s
->output_section
!= bfd_abs_section_ptr
16999 && !bfd_set_section_contents (output_bfd
, s
->output_section
,
17000 s
->contents
, s
->output_offset
,
17008 #include "elf64-target.h"
17010 /* FreeBSD support */
17012 #undef TARGET_LITTLE_SYM
17013 #undef TARGET_LITTLE_NAME
17015 #undef TARGET_BIG_SYM
17016 #define TARGET_BIG_SYM powerpc_elf64_fbsd_vec
17017 #undef TARGET_BIG_NAME
17018 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
17021 #define ELF_OSABI ELFOSABI_FREEBSD
17024 #define elf64_bed elf64_powerpc_fbsd_bed
17026 #include "elf64-target.h"