1 /* PowerPC64-specific support for 64-bit ELF.
2 Copyright (C) 1999-2020 Free Software Foundation, Inc.
3 Written by Linus Nordberg, Swox AB <info@swox.com>,
4 based on elf32-ppc.c by Ian Lance Taylor.
5 Largely rewritten by Alan Modra.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License along
20 with this program; if not, write to the Free Software Foundation, Inc.,
21 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
24 /* The 64-bit PowerPC ELF ABI may be found at
25 http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
26 http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html */
34 #include "elf/ppc64.h"
35 #include "elf64-ppc.h"
38 /* All users of this file have bfd_octets_per_byte (abfd, sec) == 1. */
39 #define OCTETS_PER_BYTE(ABFD, SEC) 1
41 static bfd_reloc_status_type ppc64_elf_ha_reloc
42 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
43 static bfd_reloc_status_type ppc64_elf_branch_reloc
44 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
45 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
46 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
47 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
48 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
49 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
50 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
51 static bfd_reloc_status_type ppc64_elf_toc_reloc
52 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
53 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
54 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
55 static bfd_reloc_status_type ppc64_elf_toc64_reloc
56 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
57 static bfd_reloc_status_type ppc64_elf_prefix_reloc
58 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
59 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
60 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
61 static bfd_vma opd_entry_value
62 (asection
*, bfd_vma
, asection
**, bfd_vma
*, bfd_boolean
);
64 #define TARGET_LITTLE_SYM powerpc_elf64_le_vec
65 #define TARGET_LITTLE_NAME "elf64-powerpcle"
66 #define TARGET_BIG_SYM powerpc_elf64_vec
67 #define TARGET_BIG_NAME "elf64-powerpc"
68 #define ELF_ARCH bfd_arch_powerpc
69 #define ELF_TARGET_ID PPC64_ELF_DATA
70 #define ELF_MACHINE_CODE EM_PPC64
71 #define ELF_MAXPAGESIZE 0x10000
72 #define ELF_COMMONPAGESIZE 0x1000
73 #define ELF_RELROPAGESIZE ELF_MAXPAGESIZE
74 #define elf_info_to_howto ppc64_elf_info_to_howto
76 #define elf_backend_want_got_sym 0
77 #define elf_backend_want_plt_sym 0
78 #define elf_backend_plt_alignment 3
79 #define elf_backend_plt_not_loaded 1
80 #define elf_backend_got_header_size 8
81 #define elf_backend_want_dynrelro 1
82 #define elf_backend_can_gc_sections 1
83 #define elf_backend_can_refcount 1
84 #define elf_backend_rela_normal 1
85 #define elf_backend_dtrel_excludes_plt 1
86 #define elf_backend_default_execstack 0
88 #define bfd_elf64_mkobject ppc64_elf_mkobject
89 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
90 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
91 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
92 #define bfd_elf64_bfd_print_private_bfd_data ppc64_elf_print_private_bfd_data
93 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
94 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
95 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
96 #define bfd_elf64_bfd_link_just_syms ppc64_elf_link_just_syms
97 #define bfd_elf64_bfd_gc_sections ppc64_elf_gc_sections
99 #define elf_backend_object_p ppc64_elf_object_p
100 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
101 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
102 #define elf_backend_write_core_note ppc64_elf_write_core_note
103 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
104 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
105 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
106 #define elf_backend_check_directives ppc64_elf_before_check_relocs
107 #define elf_backend_notice_as_needed ppc64_elf_notice_as_needed
108 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
109 #define elf_backend_check_relocs ppc64_elf_check_relocs
110 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
111 #define elf_backend_gc_keep ppc64_elf_gc_keep
112 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
113 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
114 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
115 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
116 #define elf_backend_maybe_function_sym ppc64_elf_maybe_function_sym
117 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
118 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
119 #define elf_backend_hash_symbol ppc64_elf_hash_symbol
120 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
121 #define elf_backend_action_discarded ppc64_elf_action_discarded
122 #define elf_backend_relocate_section ppc64_elf_relocate_section
123 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
124 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
125 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
126 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
127 #define elf_backend_special_sections ppc64_elf_special_sections
128 #define elf_backend_merge_symbol_attribute ppc64_elf_merge_symbol_attribute
129 #define elf_backend_merge_symbol ppc64_elf_merge_symbol
130 #define elf_backend_get_reloc_section bfd_get_section_by_name
132 /* The name of the dynamic interpreter. This is put in the .interp
134 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
136 /* The size in bytes of an entry in the procedure linkage table. */
137 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
138 #define LOCAL_PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 16 : 8)
140 /* The initial size of the plt reserved for the dynamic linker. */
141 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
143 /* Offsets to some stack save slots. */
145 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
146 /* This one is dodgy. ELFv2 does not have a linker word, so use the
147 CR save slot. Used only by optimised __tls_get_addr call stub,
148 relying on __tls_get_addr_opt not saving CR.. */
149 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
151 /* TOC base pointers offset from start of TOC. */
152 #define TOC_BASE_OFF 0x8000
153 /* TOC base alignment. */
154 #define TOC_BASE_ALIGN 256
156 /* Offset of tp and dtp pointers from start of TLS block. */
157 #define TP_OFFSET 0x7000
158 #define DTP_OFFSET 0x8000
160 /* .plt call stub instructions. The normal stub is like this, but
161 sometimes the .plt entry crosses a 64k boundary and we need to
162 insert an addi to adjust r11. */
163 #define STD_R2_0R1 0xf8410000 /* std %r2,0+40(%r1) */
164 #define ADDIS_R11_R2 0x3d620000 /* addis %r11,%r2,xxx@ha */
165 #define LD_R12_0R11 0xe98b0000 /* ld %r12,xxx+0@l(%r11) */
166 #define MTCTR_R12 0x7d8903a6 /* mtctr %r12 */
167 #define LD_R2_0R11 0xe84b0000 /* ld %r2,xxx+8@l(%r11) */
168 #define LD_R11_0R11 0xe96b0000 /* ld %r11,xxx+16@l(%r11) */
169 #define BCTR 0x4e800420 /* bctr */
171 #define ADDI_R11_R11 0x396b0000 /* addi %r11,%r11,off@l */
172 #define ADDI_R12_R11 0x398b0000 /* addi %r12,%r11,off@l */
173 #define ADDI_R12_R12 0x398c0000 /* addi %r12,%r12,off@l */
174 #define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
175 #define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
177 #define XOR_R2_R12_R12 0x7d826278 /* xor %r2,%r12,%r12 */
178 #define ADD_R11_R11_R2 0x7d6b1214 /* add %r11,%r11,%r2 */
179 #define XOR_R11_R12_R12 0x7d8b6278 /* xor %r11,%r12,%r12 */
180 #define ADD_R2_R2_R11 0x7c425a14 /* add %r2,%r2,%r11 */
181 #define CMPLDI_R2_0 0x28220000 /* cmpldi %r2,0 */
182 #define BNECTR 0x4ca20420 /* bnectr+ */
183 #define BNECTR_P4 0x4ce20420 /* bnectr+ */
185 #define LD_R12_0R2 0xe9820000 /* ld %r12,xxx+0(%r2) */
186 #define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
187 #define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
189 #define LD_R2_0R1 0xe8410000 /* ld %r2,0(%r1) */
190 #define LD_R2_0R12 0xe84c0000 /* ld %r2,0(%r12) */
191 #define ADD_R2_R2_R12 0x7c426214 /* add %r2,%r2,%r12 */
193 #define LI_R11_0 0x39600000 /* li %r11,0 */
194 #define LIS_R2 0x3c400000 /* lis %r2,xxx@ha */
195 #define LIS_R11 0x3d600000 /* lis %r11,xxx@ha */
196 #define LIS_R12 0x3d800000 /* lis %r12,xxx@ha */
197 #define ADDIS_R2_R12 0x3c4c0000 /* addis %r2,%r12,xxx@ha */
198 #define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
199 #define ADDIS_R12_R11 0x3d8b0000 /* addis %r12,%r11,xxx@ha */
200 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,xxx@ha */
201 #define ORIS_R12_R12_0 0x658c0000 /* oris %r12,%r12,xxx@hi */
202 #define ORI_R11_R11_0 0x616b0000 /* ori %r11,%r11,xxx@l */
203 #define ORI_R12_R12_0 0x618c0000 /* ori %r12,%r12,xxx@l */
204 #define LD_R12_0R12 0xe98c0000 /* ld %r12,xxx@l(%r12) */
205 #define SLDI_R11_R11_34 0x796b1746 /* sldi %r11,%r11,34 */
206 #define SLDI_R12_R12_32 0x799c07c6 /* sldi %r12,%r12,32 */
207 #define LDX_R12_R11_R12 0x7d8b602a /* ldx %r12,%r11,%r12 */
208 #define ADD_R12_R11_R12 0x7d8b6214 /* add %r12,%r11,%r12 */
209 #define PADDI_R12_PC 0x0610000039800000ULL
210 #define PLD_R12_PC 0x04100000e5800000ULL
211 #define PNOP 0x0700000000000000ULL
213 /* __glink_PLTresolve stub instructions. We enter with the index in R0. */
214 #define GLINK_PLTRESOLVE_SIZE(htab) \
215 (8u + (htab->opd_abi ? 11 * 4 : 14 * 4))
219 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
220 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
222 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
223 /* ld %2,(0b-1b)(%11) */
224 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
225 #define ADD_R11_R2_R11 0x7d625a14 /* add %11,%2,%11 */
231 #define MFLR_R0 0x7c0802a6 /* mflr %r0 */
232 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
233 #define SUB_R12_R12_R11 0x7d8b6050 /* subf %r12,%r11,%r12 */
234 #define ADDI_R0_R12 0x380c0000 /* addi %r0,%r12,0 */
235 #define SRDI_R0_R0_2 0x7800f082 /* rldicl %r0,%r0,62,2 */
238 #define NOP 0x60000000
240 /* Some other nops. */
241 #define CROR_151515 0x4def7b82
242 #define CROR_313131 0x4ffffb82
244 /* .glink entries for the first 32k functions are two instructions. */
245 #define LI_R0_0 0x38000000 /* li %r0,0 */
246 #define B_DOT 0x48000000 /* b . */
248 /* After that, we need two instructions to load the index, followed by
250 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
251 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
253 /* Instructions used by the save and restore reg functions. */
254 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
255 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
256 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
257 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
258 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
259 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
260 #define LI_R12_0 0x39800000 /* li %r12,0 */
261 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
262 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
263 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
264 #define BLR 0x4e800020 /* blr */
266 /* Since .opd is an array of descriptors and each entry will end up
267 with identical R_PPC64_RELATIVE relocs, there is really no need to
268 propagate .opd relocs; The dynamic linker should be taught to
269 relocate .opd without reloc entries. */
270 #ifndef NO_OPD_RELOCS
271 #define NO_OPD_RELOCS 0
275 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
279 abiversion (bfd
*abfd
)
281 return elf_elfheader (abfd
)->e_flags
& EF_PPC64_ABI
;
285 set_abiversion (bfd
*abfd
, int ver
)
287 elf_elfheader (abfd
)->e_flags
&= ~EF_PPC64_ABI
;
288 elf_elfheader (abfd
)->e_flags
|= ver
& EF_PPC64_ABI
;
291 /* Relocation HOWTO's. */
292 /* Like other ELF RELA targets that don't apply multiple
293 field-altering relocations to the same localation, src_mask is
294 always zero and pcrel_offset is the same as pc_relative.
295 PowerPC can always use a zero bitpos, even when the field is not at
296 the LSB. For example, a REL24 could use rightshift=2, bisize=24
297 and bitpos=2 which matches the ABI description, or as we do here,
298 rightshift=0, bitsize=26 and bitpos=0. */
299 #define HOW(type, size, bitsize, mask, rightshift, pc_relative, \
300 complain, special_func) \
301 HOWTO (type, rightshift, size, bitsize, pc_relative, 0, \
302 complain_overflow_ ## complain, special_func, \
303 #type, FALSE, 0, mask, pc_relative)
305 static reloc_howto_type
*ppc64_elf_howto_table
[(int) R_PPC64_max
];
307 static reloc_howto_type ppc64_elf_howto_raw
[] =
309 /* This reloc does nothing. */
310 HOW (R_PPC64_NONE
, 3, 0, 0, 0, FALSE
, dont
,
311 bfd_elf_generic_reloc
),
313 /* A standard 32 bit relocation. */
314 HOW (R_PPC64_ADDR32
, 2, 32, 0xffffffff, 0, FALSE
, bitfield
,
315 bfd_elf_generic_reloc
),
317 /* An absolute 26 bit branch; the lower two bits must be zero.
318 FIXME: we don't check that, we just clear them. */
319 HOW (R_PPC64_ADDR24
, 2, 26, 0x03fffffc, 0, FALSE
, bitfield
,
320 bfd_elf_generic_reloc
),
322 /* A standard 16 bit relocation. */
323 HOW (R_PPC64_ADDR16
, 1, 16, 0xffff, 0, FALSE
, bitfield
,
324 bfd_elf_generic_reloc
),
326 /* A 16 bit relocation without overflow. */
327 HOW (R_PPC64_ADDR16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
328 bfd_elf_generic_reloc
),
330 /* Bits 16-31 of an address. */
331 HOW (R_PPC64_ADDR16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
332 bfd_elf_generic_reloc
),
334 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
335 bits, treated as a signed number, is negative. */
336 HOW (R_PPC64_ADDR16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
339 /* An absolute 16 bit branch; the lower two bits must be zero.
340 FIXME: we don't check that, we just clear them. */
341 HOW (R_PPC64_ADDR14
, 2, 16, 0x0000fffc, 0, FALSE
, signed,
342 ppc64_elf_branch_reloc
),
344 /* An absolute 16 bit branch, for which bit 10 should be set to
345 indicate that the branch is expected to be taken. The lower two
346 bits must be zero. */
347 HOW (R_PPC64_ADDR14_BRTAKEN
, 2, 16, 0x0000fffc, 0, FALSE
, signed,
348 ppc64_elf_brtaken_reloc
),
350 /* An absolute 16 bit branch, for which bit 10 should be set to
351 indicate that the branch is not expected to be taken. The lower
352 two bits must be zero. */
353 HOW (R_PPC64_ADDR14_BRNTAKEN
, 2, 16, 0x0000fffc, 0, FALSE
, signed,
354 ppc64_elf_brtaken_reloc
),
356 /* A relative 26 bit branch; the lower two bits must be zero. */
357 HOW (R_PPC64_REL24
, 2, 26, 0x03fffffc, 0, TRUE
, signed,
358 ppc64_elf_branch_reloc
),
360 /* A variant of R_PPC64_REL24, used when r2 is not the toc pointer. */
361 HOW (R_PPC64_REL24_NOTOC
, 2, 26, 0x03fffffc, 0, TRUE
, signed,
362 ppc64_elf_branch_reloc
),
364 /* A relative 16 bit branch; the lower two bits must be zero. */
365 HOW (R_PPC64_REL14
, 2, 16, 0x0000fffc, 0, TRUE
, signed,
366 ppc64_elf_branch_reloc
),
368 /* A relative 16 bit branch. Bit 10 should be set to indicate that
369 the branch is expected to be taken. The lower two bits must be
371 HOW (R_PPC64_REL14_BRTAKEN
, 2, 16, 0x0000fffc, 0, TRUE
, signed,
372 ppc64_elf_brtaken_reloc
),
374 /* A relative 16 bit branch. Bit 10 should be set to indicate that
375 the branch is not expected to be taken. The lower two bits must
377 HOW (R_PPC64_REL14_BRNTAKEN
, 2, 16, 0x0000fffc, 0, TRUE
, signed,
378 ppc64_elf_brtaken_reloc
),
380 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
382 HOW (R_PPC64_GOT16
, 1, 16, 0xffff, 0, FALSE
, signed,
383 ppc64_elf_unhandled_reloc
),
385 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
387 HOW (R_PPC64_GOT16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
388 ppc64_elf_unhandled_reloc
),
390 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
392 HOW (R_PPC64_GOT16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
393 ppc64_elf_unhandled_reloc
),
395 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
397 HOW (R_PPC64_GOT16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
398 ppc64_elf_unhandled_reloc
),
400 /* This is used only by the dynamic linker. The symbol should exist
401 both in the object being run and in some shared library. The
402 dynamic linker copies the data addressed by the symbol from the
403 shared library into the object, because the object being
404 run has to have the data at some particular address. */
405 HOW (R_PPC64_COPY
, 0, 0, 0, 0, FALSE
, dont
,
406 ppc64_elf_unhandled_reloc
),
408 /* Like R_PPC64_ADDR64, but used when setting global offset table
410 HOW (R_PPC64_GLOB_DAT
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
411 ppc64_elf_unhandled_reloc
),
413 /* Created by the link editor. Marks a procedure linkage table
414 entry for a symbol. */
415 HOW (R_PPC64_JMP_SLOT
, 0, 0, 0, 0, FALSE
, dont
,
416 ppc64_elf_unhandled_reloc
),
418 /* Used only by the dynamic linker. When the object is run, this
419 doubleword64 is set to the load address of the object, plus the
421 HOW (R_PPC64_RELATIVE
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
422 bfd_elf_generic_reloc
),
424 /* Like R_PPC64_ADDR32, but may be unaligned. */
425 HOW (R_PPC64_UADDR32
, 2, 32, 0xffffffff, 0, FALSE
, bitfield
,
426 bfd_elf_generic_reloc
),
428 /* Like R_PPC64_ADDR16, but may be unaligned. */
429 HOW (R_PPC64_UADDR16
, 1, 16, 0xffff, 0, FALSE
, bitfield
,
430 bfd_elf_generic_reloc
),
432 /* 32-bit PC relative. */
433 HOW (R_PPC64_REL32
, 2, 32, 0xffffffff, 0, TRUE
, signed,
434 bfd_elf_generic_reloc
),
436 /* 32-bit relocation to the symbol's procedure linkage table. */
437 HOW (R_PPC64_PLT32
, 2, 32, 0xffffffff, 0, FALSE
, bitfield
,
438 ppc64_elf_unhandled_reloc
),
440 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
441 FIXME: R_PPC64_PLTREL32 not supported. */
442 HOW (R_PPC64_PLTREL32
, 2, 32, 0xffffffff, 0, TRUE
, signed,
443 ppc64_elf_unhandled_reloc
),
445 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
447 HOW (R_PPC64_PLT16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
448 ppc64_elf_unhandled_reloc
),
450 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
452 HOW (R_PPC64_PLT16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
453 ppc64_elf_unhandled_reloc
),
455 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
457 HOW (R_PPC64_PLT16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
458 ppc64_elf_unhandled_reloc
),
460 /* 16-bit section relative relocation. */
461 HOW (R_PPC64_SECTOFF
, 1, 16, 0xffff, 0, FALSE
, signed,
462 ppc64_elf_sectoff_reloc
),
464 /* Like R_PPC64_SECTOFF, but no overflow warning. */
465 HOW (R_PPC64_SECTOFF_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
466 ppc64_elf_sectoff_reloc
),
468 /* 16-bit upper half section relative relocation. */
469 HOW (R_PPC64_SECTOFF_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
470 ppc64_elf_sectoff_reloc
),
472 /* 16-bit upper half adjusted section relative relocation. */
473 HOW (R_PPC64_SECTOFF_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
474 ppc64_elf_sectoff_ha_reloc
),
476 /* Like R_PPC64_REL24 without touching the two least significant bits. */
477 HOW (R_PPC64_REL30
, 2, 30, 0xfffffffc, 2, TRUE
, dont
,
478 bfd_elf_generic_reloc
),
480 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
482 /* A standard 64-bit relocation. */
483 HOW (R_PPC64_ADDR64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
484 bfd_elf_generic_reloc
),
486 /* The bits 32-47 of an address. */
487 HOW (R_PPC64_ADDR16_HIGHER
, 1, 16, 0xffff, 32, FALSE
, dont
,
488 bfd_elf_generic_reloc
),
490 /* The bits 32-47 of an address, plus 1 if the contents of the low
491 16 bits, treated as a signed number, is negative. */
492 HOW (R_PPC64_ADDR16_HIGHERA
, 1, 16, 0xffff, 32, FALSE
, dont
,
495 /* The bits 48-63 of an address. */
496 HOW (R_PPC64_ADDR16_HIGHEST
, 1, 16, 0xffff, 48, FALSE
, dont
,
497 bfd_elf_generic_reloc
),
499 /* The bits 48-63 of an address, plus 1 if the contents of the low
500 16 bits, treated as a signed number, is negative. */
501 HOW (R_PPC64_ADDR16_HIGHESTA
, 1, 16, 0xffff, 48, FALSE
, dont
,
504 /* Like ADDR64, but may be unaligned. */
505 HOW (R_PPC64_UADDR64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
506 bfd_elf_generic_reloc
),
508 /* 64-bit relative relocation. */
509 HOW (R_PPC64_REL64
, 4, 64, 0xffffffffffffffffULL
, 0, TRUE
, dont
,
510 bfd_elf_generic_reloc
),
512 /* 64-bit relocation to the symbol's procedure linkage table. */
513 HOW (R_PPC64_PLT64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
514 ppc64_elf_unhandled_reloc
),
516 /* 64-bit PC relative relocation to the symbol's procedure linkage
518 /* FIXME: R_PPC64_PLTREL64 not supported. */
519 HOW (R_PPC64_PLTREL64
, 4, 64, 0xffffffffffffffffULL
, 0, TRUE
, dont
,
520 ppc64_elf_unhandled_reloc
),
522 /* 16 bit TOC-relative relocation. */
523 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
524 HOW (R_PPC64_TOC16
, 1, 16, 0xffff, 0, FALSE
, signed,
525 ppc64_elf_toc_reloc
),
527 /* 16 bit TOC-relative relocation without overflow. */
528 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
529 HOW (R_PPC64_TOC16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
530 ppc64_elf_toc_reloc
),
532 /* 16 bit TOC-relative relocation, high 16 bits. */
533 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
534 HOW (R_PPC64_TOC16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
535 ppc64_elf_toc_reloc
),
537 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
538 contents of the low 16 bits, treated as a signed number, is
540 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
541 HOW (R_PPC64_TOC16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
542 ppc64_elf_toc_ha_reloc
),
544 /* 64-bit relocation; insert value of TOC base (.TOC.). */
545 /* R_PPC64_TOC 51 doubleword64 .TOC. */
546 HOW (R_PPC64_TOC
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
547 ppc64_elf_toc64_reloc
),
549 /* Like R_PPC64_GOT16, but also informs the link editor that the
550 value to relocate may (!) refer to a PLT entry which the link
551 editor (a) may replace with the symbol value. If the link editor
552 is unable to fully resolve the symbol, it may (b) create a PLT
553 entry and store the address to the new PLT entry in the GOT.
554 This permits lazy resolution of function symbols at run time.
555 The link editor may also skip all of this and just (c) emit a
556 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
557 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
558 HOW (R_PPC64_PLTGOT16
, 1, 16, 0xffff, 0, FALSE
,signed,
559 ppc64_elf_unhandled_reloc
),
561 /* Like R_PPC64_PLTGOT16, but without overflow. */
562 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
563 HOW (R_PPC64_PLTGOT16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
564 ppc64_elf_unhandled_reloc
),
566 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
567 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
568 HOW (R_PPC64_PLTGOT16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
569 ppc64_elf_unhandled_reloc
),
571 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
572 1 if the contents of the low 16 bits, treated as a signed number,
574 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
575 HOW (R_PPC64_PLTGOT16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
576 ppc64_elf_unhandled_reloc
),
578 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
579 HOW (R_PPC64_ADDR16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
580 bfd_elf_generic_reloc
),
582 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
583 HOW (R_PPC64_ADDR16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
584 bfd_elf_generic_reloc
),
586 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
587 HOW (R_PPC64_GOT16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
588 ppc64_elf_unhandled_reloc
),
590 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
591 HOW (R_PPC64_GOT16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
592 ppc64_elf_unhandled_reloc
),
594 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
595 HOW (R_PPC64_PLT16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
596 ppc64_elf_unhandled_reloc
),
598 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
599 HOW (R_PPC64_SECTOFF_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
600 ppc64_elf_sectoff_reloc
),
602 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
603 HOW (R_PPC64_SECTOFF_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
604 ppc64_elf_sectoff_reloc
),
606 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
607 HOW (R_PPC64_TOC16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
608 ppc64_elf_toc_reloc
),
610 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
611 HOW (R_PPC64_TOC16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
612 ppc64_elf_toc_reloc
),
614 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
615 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
616 HOW (R_PPC64_PLTGOT16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
617 ppc64_elf_unhandled_reloc
),
619 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
620 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
621 HOW (R_PPC64_PLTGOT16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
622 ppc64_elf_unhandled_reloc
),
624 /* Marker relocs for TLS. */
625 HOW (R_PPC64_TLS
, 2, 32, 0, 0, FALSE
, dont
,
626 bfd_elf_generic_reloc
),
628 HOW (R_PPC64_TLSGD
, 2, 32, 0, 0, FALSE
, dont
,
629 bfd_elf_generic_reloc
),
631 HOW (R_PPC64_TLSLD
, 2, 32, 0, 0, FALSE
, dont
,
632 bfd_elf_generic_reloc
),
634 /* Marker reloc for optimizing r2 save in prologue rather than on
635 each plt call stub. */
636 HOW (R_PPC64_TOCSAVE
, 2, 32, 0, 0, FALSE
, dont
,
637 bfd_elf_generic_reloc
),
639 /* Marker relocs on inline plt call instructions. */
640 HOW (R_PPC64_PLTSEQ
, 2, 32, 0, 0, FALSE
, dont
,
641 bfd_elf_generic_reloc
),
643 HOW (R_PPC64_PLTCALL
, 2, 32, 0, 0, FALSE
, dont
,
644 bfd_elf_generic_reloc
),
646 /* Computes the load module index of the load module that contains the
647 definition of its TLS sym. */
648 HOW (R_PPC64_DTPMOD64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
649 ppc64_elf_unhandled_reloc
),
651 /* Computes a dtv-relative displacement, the difference between the value
652 of sym+add and the base address of the thread-local storage block that
653 contains the definition of sym, minus 0x8000. */
654 HOW (R_PPC64_DTPREL64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
655 ppc64_elf_unhandled_reloc
),
657 /* A 16 bit dtprel reloc. */
658 HOW (R_PPC64_DTPREL16
, 1, 16, 0xffff, 0, FALSE
, signed,
659 ppc64_elf_unhandled_reloc
),
661 /* Like DTPREL16, but no overflow. */
662 HOW (R_PPC64_DTPREL16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
663 ppc64_elf_unhandled_reloc
),
665 /* Like DTPREL16_LO, but next higher group of 16 bits. */
666 HOW (R_PPC64_DTPREL16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
667 ppc64_elf_unhandled_reloc
),
669 /* Like DTPREL16_HI, but adjust for low 16 bits. */
670 HOW (R_PPC64_DTPREL16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
671 ppc64_elf_unhandled_reloc
),
673 /* Like DTPREL16_HI, but next higher group of 16 bits. */
674 HOW (R_PPC64_DTPREL16_HIGHER
, 1, 16, 0xffff, 32, FALSE
, dont
,
675 ppc64_elf_unhandled_reloc
),
677 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
678 HOW (R_PPC64_DTPREL16_HIGHERA
, 1, 16, 0xffff, 32, FALSE
, dont
,
679 ppc64_elf_unhandled_reloc
),
681 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
682 HOW (R_PPC64_DTPREL16_HIGHEST
, 1, 16, 0xffff, 48, FALSE
, dont
,
683 ppc64_elf_unhandled_reloc
),
685 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
686 HOW (R_PPC64_DTPREL16_HIGHESTA
, 1, 16, 0xffff, 48, FALSE
, dont
,
687 ppc64_elf_unhandled_reloc
),
689 /* Like DTPREL16, but for insns with a DS field. */
690 HOW (R_PPC64_DTPREL16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
691 ppc64_elf_unhandled_reloc
),
693 /* Like DTPREL16_DS, but no overflow. */
694 HOW (R_PPC64_DTPREL16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
695 ppc64_elf_unhandled_reloc
),
697 /* Computes a tp-relative displacement, the difference between the value of
698 sym+add and the value of the thread pointer (r13). */
699 HOW (R_PPC64_TPREL64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
700 ppc64_elf_unhandled_reloc
),
702 /* A 16 bit tprel reloc. */
703 HOW (R_PPC64_TPREL16
, 1, 16, 0xffff, 0, FALSE
, signed,
704 ppc64_elf_unhandled_reloc
),
706 /* Like TPREL16, but no overflow. */
707 HOW (R_PPC64_TPREL16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
708 ppc64_elf_unhandled_reloc
),
710 /* Like TPREL16_LO, but next higher group of 16 bits. */
711 HOW (R_PPC64_TPREL16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
712 ppc64_elf_unhandled_reloc
),
714 /* Like TPREL16_HI, but adjust for low 16 bits. */
715 HOW (R_PPC64_TPREL16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
716 ppc64_elf_unhandled_reloc
),
718 /* Like TPREL16_HI, but next higher group of 16 bits. */
719 HOW (R_PPC64_TPREL16_HIGHER
, 1, 16, 0xffff, 32, FALSE
, dont
,
720 ppc64_elf_unhandled_reloc
),
722 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
723 HOW (R_PPC64_TPREL16_HIGHERA
, 1, 16, 0xffff, 32, FALSE
, dont
,
724 ppc64_elf_unhandled_reloc
),
726 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
727 HOW (R_PPC64_TPREL16_HIGHEST
, 1, 16, 0xffff, 48, FALSE
, dont
,
728 ppc64_elf_unhandled_reloc
),
730 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
731 HOW (R_PPC64_TPREL16_HIGHESTA
, 1, 16, 0xffff, 48, FALSE
, dont
,
732 ppc64_elf_unhandled_reloc
),
734 /* Like TPREL16, but for insns with a DS field. */
735 HOW (R_PPC64_TPREL16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
736 ppc64_elf_unhandled_reloc
),
738 /* Like TPREL16_DS, but no overflow. */
739 HOW (R_PPC64_TPREL16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
740 ppc64_elf_unhandled_reloc
),
742 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
743 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
744 to the first entry relative to the TOC base (r2). */
745 HOW (R_PPC64_GOT_TLSGD16
, 1, 16, 0xffff, 0, FALSE
, signed,
746 ppc64_elf_unhandled_reloc
),
748 /* Like GOT_TLSGD16, but no overflow. */
749 HOW (R_PPC64_GOT_TLSGD16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
750 ppc64_elf_unhandled_reloc
),
752 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
753 HOW (R_PPC64_GOT_TLSGD16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
754 ppc64_elf_unhandled_reloc
),
756 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
757 HOW (R_PPC64_GOT_TLSGD16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
758 ppc64_elf_unhandled_reloc
),
760 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
761 with values (sym+add)@dtpmod and zero, and computes the offset to the
762 first entry relative to the TOC base (r2). */
763 HOW (R_PPC64_GOT_TLSLD16
, 1, 16, 0xffff, 0, FALSE
, signed,
764 ppc64_elf_unhandled_reloc
),
766 /* Like GOT_TLSLD16, but no overflow. */
767 HOW (R_PPC64_GOT_TLSLD16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
768 ppc64_elf_unhandled_reloc
),
770 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
771 HOW (R_PPC64_GOT_TLSLD16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
772 ppc64_elf_unhandled_reloc
),
774 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
775 HOW (R_PPC64_GOT_TLSLD16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
776 ppc64_elf_unhandled_reloc
),
778 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
779 the offset to the entry relative to the TOC base (r2). */
780 HOW (R_PPC64_GOT_DTPREL16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
781 ppc64_elf_unhandled_reloc
),
783 /* Like GOT_DTPREL16_DS, but no overflow. */
784 HOW (R_PPC64_GOT_DTPREL16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
785 ppc64_elf_unhandled_reloc
),
787 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
788 HOW (R_PPC64_GOT_DTPREL16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
789 ppc64_elf_unhandled_reloc
),
791 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
792 HOW (R_PPC64_GOT_DTPREL16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
793 ppc64_elf_unhandled_reloc
),
795 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
796 offset to the entry relative to the TOC base (r2). */
797 HOW (R_PPC64_GOT_TPREL16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
798 ppc64_elf_unhandled_reloc
),
800 /* Like GOT_TPREL16_DS, but no overflow. */
801 HOW (R_PPC64_GOT_TPREL16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
802 ppc64_elf_unhandled_reloc
),
804 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
805 HOW (R_PPC64_GOT_TPREL16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
806 ppc64_elf_unhandled_reloc
),
808 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
809 HOW (R_PPC64_GOT_TPREL16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
810 ppc64_elf_unhandled_reloc
),
812 HOW (R_PPC64_JMP_IREL
, 0, 0, 0, 0, FALSE
, dont
,
813 ppc64_elf_unhandled_reloc
),
815 HOW (R_PPC64_IRELATIVE
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
816 bfd_elf_generic_reloc
),
818 /* A 16 bit relative relocation. */
819 HOW (R_PPC64_REL16
, 1, 16, 0xffff, 0, TRUE
, signed,
820 bfd_elf_generic_reloc
),
822 /* A 16 bit relative relocation without overflow. */
823 HOW (R_PPC64_REL16_LO
, 1, 16, 0xffff, 0, TRUE
, dont
,
824 bfd_elf_generic_reloc
),
826 /* The high order 16 bits of a relative address. */
827 HOW (R_PPC64_REL16_HI
, 1, 16, 0xffff, 16, TRUE
, signed,
828 bfd_elf_generic_reloc
),
830 /* The high order 16 bits of a relative address, plus 1 if the contents of
831 the low 16 bits, treated as a signed number, is negative. */
832 HOW (R_PPC64_REL16_HA
, 1, 16, 0xffff, 16, TRUE
, signed,
835 HOW (R_PPC64_REL16_HIGH
, 1, 16, 0xffff, 16, TRUE
, dont
,
836 bfd_elf_generic_reloc
),
838 HOW (R_PPC64_REL16_HIGHA
, 1, 16, 0xffff, 16, TRUE
, dont
,
841 HOW (R_PPC64_REL16_HIGHER
, 1, 16, 0xffff, 32, TRUE
, dont
,
842 bfd_elf_generic_reloc
),
844 HOW (R_PPC64_REL16_HIGHERA
, 1, 16, 0xffff, 32, TRUE
, dont
,
847 HOW (R_PPC64_REL16_HIGHEST
, 1, 16, 0xffff, 48, TRUE
, dont
,
848 bfd_elf_generic_reloc
),
850 HOW (R_PPC64_REL16_HIGHESTA
, 1, 16, 0xffff, 48, TRUE
, dont
,
853 /* Like R_PPC64_REL16_HA but for split field in addpcis. */
854 HOW (R_PPC64_REL16DX_HA
, 2, 16, 0x1fffc1, 16, TRUE
, signed,
857 /* A split-field reloc for addpcis, non-relative (gas internal use only). */
858 HOW (R_PPC64_16DX_HA
, 2, 16, 0x1fffc1, 16, FALSE
, signed,
861 /* Like R_PPC64_ADDR16_HI, but no overflow. */
862 HOW (R_PPC64_ADDR16_HIGH
, 1, 16, 0xffff, 16, FALSE
, dont
,
863 bfd_elf_generic_reloc
),
865 /* Like R_PPC64_ADDR16_HA, but no overflow. */
866 HOW (R_PPC64_ADDR16_HIGHA
, 1, 16, 0xffff, 16, FALSE
, dont
,
869 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
870 HOW (R_PPC64_DTPREL16_HIGH
, 1, 16, 0xffff, 16, FALSE
, dont
,
871 ppc64_elf_unhandled_reloc
),
873 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
874 HOW (R_PPC64_DTPREL16_HIGHA
, 1, 16, 0xffff, 16, FALSE
, dont
,
875 ppc64_elf_unhandled_reloc
),
877 /* Like R_PPC64_TPREL16_HI, but no overflow. */
878 HOW (R_PPC64_TPREL16_HIGH
, 1, 16, 0xffff, 16, FALSE
, dont
,
879 ppc64_elf_unhandled_reloc
),
881 /* Like R_PPC64_TPREL16_HA, but no overflow. */
882 HOW (R_PPC64_TPREL16_HIGHA
, 1, 16, 0xffff, 16, FALSE
, dont
,
883 ppc64_elf_unhandled_reloc
),
885 /* Marker reloc on ELFv2 large-model function entry. */
886 HOW (R_PPC64_ENTRY
, 2, 32, 0, 0, FALSE
, dont
,
887 bfd_elf_generic_reloc
),
889 /* Like ADDR64, but use local entry point of function. */
890 HOW (R_PPC64_ADDR64_LOCAL
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
891 bfd_elf_generic_reloc
),
893 HOW (R_PPC64_PLTSEQ_NOTOC
, 2, 32, 0, 0, FALSE
, dont
,
894 bfd_elf_generic_reloc
),
896 HOW (R_PPC64_PLTCALL_NOTOC
, 2, 32, 0, 0, FALSE
, dont
,
897 bfd_elf_generic_reloc
),
899 HOW (R_PPC64_PCREL_OPT
, 2, 32, 0, 0, FALSE
, dont
,
900 bfd_elf_generic_reloc
),
902 HOW (R_PPC64_D34
, 4, 34, 0x3ffff0000ffffULL
, 0, FALSE
, signed,
903 ppc64_elf_prefix_reloc
),
905 HOW (R_PPC64_D34_LO
, 4, 34, 0x3ffff0000ffffULL
, 0, FALSE
, dont
,
906 ppc64_elf_prefix_reloc
),
908 HOW (R_PPC64_D34_HI30
, 4, 34, 0x3ffff0000ffffULL
, 34, FALSE
, dont
,
909 ppc64_elf_prefix_reloc
),
911 HOW (R_PPC64_D34_HA30
, 4, 34, 0x3ffff0000ffffULL
, 34, FALSE
, dont
,
912 ppc64_elf_prefix_reloc
),
914 HOW (R_PPC64_PCREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
915 ppc64_elf_prefix_reloc
),
917 HOW (R_PPC64_GOT_PCREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
918 ppc64_elf_unhandled_reloc
),
920 HOW (R_PPC64_PLT_PCREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
921 ppc64_elf_unhandled_reloc
),
923 HOW (R_PPC64_PLT_PCREL34_NOTOC
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
924 ppc64_elf_unhandled_reloc
),
926 HOW (R_PPC64_TPREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, FALSE
, signed,
927 ppc64_elf_unhandled_reloc
),
929 HOW (R_PPC64_DTPREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, FALSE
, signed,
930 ppc64_elf_unhandled_reloc
),
932 HOW (R_PPC64_GOT_TLSGD34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
933 ppc64_elf_unhandled_reloc
),
935 HOW (R_PPC64_GOT_TLSLD34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
936 ppc64_elf_unhandled_reloc
),
938 HOW (R_PPC64_GOT_TPREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
939 ppc64_elf_unhandled_reloc
),
941 HOW (R_PPC64_GOT_DTPREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
942 ppc64_elf_unhandled_reloc
),
944 HOW (R_PPC64_ADDR16_HIGHER34
, 1, 16, 0xffff, 34, FALSE
, dont
,
945 bfd_elf_generic_reloc
),
947 HOW (R_PPC64_ADDR16_HIGHERA34
, 1, 16, 0xffff, 34, FALSE
, dont
,
950 HOW (R_PPC64_ADDR16_HIGHEST34
, 1, 16, 0xffff, 50, FALSE
, dont
,
951 bfd_elf_generic_reloc
),
953 HOW (R_PPC64_ADDR16_HIGHESTA34
, 1, 16, 0xffff, 50, FALSE
, dont
,
956 HOW (R_PPC64_REL16_HIGHER34
, 1, 16, 0xffff, 34, TRUE
, dont
,
957 bfd_elf_generic_reloc
),
959 HOW (R_PPC64_REL16_HIGHERA34
, 1, 16, 0xffff, 34, TRUE
, dont
,
962 HOW (R_PPC64_REL16_HIGHEST34
, 1, 16, 0xffff, 50, TRUE
, dont
,
963 bfd_elf_generic_reloc
),
965 HOW (R_PPC64_REL16_HIGHESTA34
, 1, 16, 0xffff, 50, TRUE
, dont
,
968 HOW (R_PPC64_D28
, 4, 28, 0xfff0000ffffULL
, 0, FALSE
, signed,
969 ppc64_elf_prefix_reloc
),
971 HOW (R_PPC64_PCREL28
, 4, 28, 0xfff0000ffffULL
, 0, TRUE
, signed,
972 ppc64_elf_prefix_reloc
),
974 /* GNU extension to record C++ vtable hierarchy. */
975 HOW (R_PPC64_GNU_VTINHERIT
, 0, 0, 0, 0, FALSE
, dont
,
978 /* GNU extension to record C++ vtable member usage. */
979 HOW (R_PPC64_GNU_VTENTRY
, 0, 0, 0, 0, FALSE
, dont
,
984 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
988 ppc_howto_init (void)
990 unsigned int i
, type
;
992 for (i
= 0; i
< ARRAY_SIZE (ppc64_elf_howto_raw
); i
++)
994 type
= ppc64_elf_howto_raw
[i
].type
;
995 BFD_ASSERT (type
< ARRAY_SIZE (ppc64_elf_howto_table
));
996 ppc64_elf_howto_table
[type
] = &ppc64_elf_howto_raw
[i
];
1000 static reloc_howto_type
*
1001 ppc64_elf_reloc_type_lookup (bfd
*abfd
,
1002 bfd_reloc_code_real_type code
)
1004 enum elf_ppc64_reloc_type r
= R_PPC64_NONE
;
1006 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
1007 /* Initialize howto table if needed. */
1013 /* xgettext:c-format */
1014 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd
,
1016 bfd_set_error (bfd_error_bad_value
);
1019 case BFD_RELOC_NONE
: r
= R_PPC64_NONE
;
1021 case BFD_RELOC_32
: r
= R_PPC64_ADDR32
;
1023 case BFD_RELOC_PPC_BA26
: r
= R_PPC64_ADDR24
;
1025 case BFD_RELOC_16
: r
= R_PPC64_ADDR16
;
1027 case BFD_RELOC_LO16
: r
= R_PPC64_ADDR16_LO
;
1029 case BFD_RELOC_HI16
: r
= R_PPC64_ADDR16_HI
;
1031 case BFD_RELOC_PPC64_ADDR16_HIGH
: r
= R_PPC64_ADDR16_HIGH
;
1033 case BFD_RELOC_HI16_S
: r
= R_PPC64_ADDR16_HA
;
1035 case BFD_RELOC_PPC64_ADDR16_HIGHA
: r
= R_PPC64_ADDR16_HIGHA
;
1037 case BFD_RELOC_PPC_BA16
: r
= R_PPC64_ADDR14
;
1039 case BFD_RELOC_PPC_BA16_BRTAKEN
: r
= R_PPC64_ADDR14_BRTAKEN
;
1041 case BFD_RELOC_PPC_BA16_BRNTAKEN
: r
= R_PPC64_ADDR14_BRNTAKEN
;
1043 case BFD_RELOC_PPC_B26
: r
= R_PPC64_REL24
;
1045 case BFD_RELOC_PPC64_REL24_NOTOC
: r
= R_PPC64_REL24_NOTOC
;
1047 case BFD_RELOC_PPC_B16
: r
= R_PPC64_REL14
;
1049 case BFD_RELOC_PPC_B16_BRTAKEN
: r
= R_PPC64_REL14_BRTAKEN
;
1051 case BFD_RELOC_PPC_B16_BRNTAKEN
: r
= R_PPC64_REL14_BRNTAKEN
;
1053 case BFD_RELOC_16_GOTOFF
: r
= R_PPC64_GOT16
;
1055 case BFD_RELOC_LO16_GOTOFF
: r
= R_PPC64_GOT16_LO
;
1057 case BFD_RELOC_HI16_GOTOFF
: r
= R_PPC64_GOT16_HI
;
1059 case BFD_RELOC_HI16_S_GOTOFF
: r
= R_PPC64_GOT16_HA
;
1061 case BFD_RELOC_PPC_COPY
: r
= R_PPC64_COPY
;
1063 case BFD_RELOC_PPC_GLOB_DAT
: r
= R_PPC64_GLOB_DAT
;
1065 case BFD_RELOC_32_PCREL
: r
= R_PPC64_REL32
;
1067 case BFD_RELOC_32_PLTOFF
: r
= R_PPC64_PLT32
;
1069 case BFD_RELOC_32_PLT_PCREL
: r
= R_PPC64_PLTREL32
;
1071 case BFD_RELOC_LO16_PLTOFF
: r
= R_PPC64_PLT16_LO
;
1073 case BFD_RELOC_HI16_PLTOFF
: r
= R_PPC64_PLT16_HI
;
1075 case BFD_RELOC_HI16_S_PLTOFF
: r
= R_PPC64_PLT16_HA
;
1077 case BFD_RELOC_16_BASEREL
: r
= R_PPC64_SECTOFF
;
1079 case BFD_RELOC_LO16_BASEREL
: r
= R_PPC64_SECTOFF_LO
;
1081 case BFD_RELOC_HI16_BASEREL
: r
= R_PPC64_SECTOFF_HI
;
1083 case BFD_RELOC_HI16_S_BASEREL
: r
= R_PPC64_SECTOFF_HA
;
1085 case BFD_RELOC_CTOR
: r
= R_PPC64_ADDR64
;
1087 case BFD_RELOC_64
: r
= R_PPC64_ADDR64
;
1089 case BFD_RELOC_PPC64_HIGHER
: r
= R_PPC64_ADDR16_HIGHER
;
1091 case BFD_RELOC_PPC64_HIGHER_S
: r
= R_PPC64_ADDR16_HIGHERA
;
1093 case BFD_RELOC_PPC64_HIGHEST
: r
= R_PPC64_ADDR16_HIGHEST
;
1095 case BFD_RELOC_PPC64_HIGHEST_S
: r
= R_PPC64_ADDR16_HIGHESTA
;
1097 case BFD_RELOC_64_PCREL
: r
= R_PPC64_REL64
;
1099 case BFD_RELOC_64_PLTOFF
: r
= R_PPC64_PLT64
;
1101 case BFD_RELOC_64_PLT_PCREL
: r
= R_PPC64_PLTREL64
;
1103 case BFD_RELOC_PPC_TOC16
: r
= R_PPC64_TOC16
;
1105 case BFD_RELOC_PPC64_TOC16_LO
: r
= R_PPC64_TOC16_LO
;
1107 case BFD_RELOC_PPC64_TOC16_HI
: r
= R_PPC64_TOC16_HI
;
1109 case BFD_RELOC_PPC64_TOC16_HA
: r
= R_PPC64_TOC16_HA
;
1111 case BFD_RELOC_PPC64_TOC
: r
= R_PPC64_TOC
;
1113 case BFD_RELOC_PPC64_PLTGOT16
: r
= R_PPC64_PLTGOT16
;
1115 case BFD_RELOC_PPC64_PLTGOT16_LO
: r
= R_PPC64_PLTGOT16_LO
;
1117 case BFD_RELOC_PPC64_PLTGOT16_HI
: r
= R_PPC64_PLTGOT16_HI
;
1119 case BFD_RELOC_PPC64_PLTGOT16_HA
: r
= R_PPC64_PLTGOT16_HA
;
1121 case BFD_RELOC_PPC64_ADDR16_DS
: r
= R_PPC64_ADDR16_DS
;
1123 case BFD_RELOC_PPC64_ADDR16_LO_DS
: r
= R_PPC64_ADDR16_LO_DS
;
1125 case BFD_RELOC_PPC64_GOT16_DS
: r
= R_PPC64_GOT16_DS
;
1127 case BFD_RELOC_PPC64_GOT16_LO_DS
: r
= R_PPC64_GOT16_LO_DS
;
1129 case BFD_RELOC_PPC64_PLT16_LO_DS
: r
= R_PPC64_PLT16_LO_DS
;
1131 case BFD_RELOC_PPC64_SECTOFF_DS
: r
= R_PPC64_SECTOFF_DS
;
1133 case BFD_RELOC_PPC64_SECTOFF_LO_DS
: r
= R_PPC64_SECTOFF_LO_DS
;
1135 case BFD_RELOC_PPC64_TOC16_DS
: r
= R_PPC64_TOC16_DS
;
1137 case BFD_RELOC_PPC64_TOC16_LO_DS
: r
= R_PPC64_TOC16_LO_DS
;
1139 case BFD_RELOC_PPC64_PLTGOT16_DS
: r
= R_PPC64_PLTGOT16_DS
;
1141 case BFD_RELOC_PPC64_PLTGOT16_LO_DS
: r
= R_PPC64_PLTGOT16_LO_DS
;
1143 case BFD_RELOC_PPC64_TLS_PCREL
:
1144 case BFD_RELOC_PPC_TLS
: r
= R_PPC64_TLS
;
1146 case BFD_RELOC_PPC_TLSGD
: r
= R_PPC64_TLSGD
;
1148 case BFD_RELOC_PPC_TLSLD
: r
= R_PPC64_TLSLD
;
1150 case BFD_RELOC_PPC_DTPMOD
: r
= R_PPC64_DTPMOD64
;
1152 case BFD_RELOC_PPC_TPREL16
: r
= R_PPC64_TPREL16
;
1154 case BFD_RELOC_PPC_TPREL16_LO
: r
= R_PPC64_TPREL16_LO
;
1156 case BFD_RELOC_PPC_TPREL16_HI
: r
= R_PPC64_TPREL16_HI
;
1158 case BFD_RELOC_PPC64_TPREL16_HIGH
: r
= R_PPC64_TPREL16_HIGH
;
1160 case BFD_RELOC_PPC_TPREL16_HA
: r
= R_PPC64_TPREL16_HA
;
1162 case BFD_RELOC_PPC64_TPREL16_HIGHA
: r
= R_PPC64_TPREL16_HIGHA
;
1164 case BFD_RELOC_PPC_TPREL
: r
= R_PPC64_TPREL64
;
1166 case BFD_RELOC_PPC_DTPREL16
: r
= R_PPC64_DTPREL16
;
1168 case BFD_RELOC_PPC_DTPREL16_LO
: r
= R_PPC64_DTPREL16_LO
;
1170 case BFD_RELOC_PPC_DTPREL16_HI
: r
= R_PPC64_DTPREL16_HI
;
1172 case BFD_RELOC_PPC64_DTPREL16_HIGH
: r
= R_PPC64_DTPREL16_HIGH
;
1174 case BFD_RELOC_PPC_DTPREL16_HA
: r
= R_PPC64_DTPREL16_HA
;
1176 case BFD_RELOC_PPC64_DTPREL16_HIGHA
: r
= R_PPC64_DTPREL16_HIGHA
;
1178 case BFD_RELOC_PPC_DTPREL
: r
= R_PPC64_DTPREL64
;
1180 case BFD_RELOC_PPC_GOT_TLSGD16
: r
= R_PPC64_GOT_TLSGD16
;
1182 case BFD_RELOC_PPC_GOT_TLSGD16_LO
: r
= R_PPC64_GOT_TLSGD16_LO
;
1184 case BFD_RELOC_PPC_GOT_TLSGD16_HI
: r
= R_PPC64_GOT_TLSGD16_HI
;
1186 case BFD_RELOC_PPC_GOT_TLSGD16_HA
: r
= R_PPC64_GOT_TLSGD16_HA
;
1188 case BFD_RELOC_PPC_GOT_TLSLD16
: r
= R_PPC64_GOT_TLSLD16
;
1190 case BFD_RELOC_PPC_GOT_TLSLD16_LO
: r
= R_PPC64_GOT_TLSLD16_LO
;
1192 case BFD_RELOC_PPC_GOT_TLSLD16_HI
: r
= R_PPC64_GOT_TLSLD16_HI
;
1194 case BFD_RELOC_PPC_GOT_TLSLD16_HA
: r
= R_PPC64_GOT_TLSLD16_HA
;
1196 case BFD_RELOC_PPC_GOT_TPREL16
: r
= R_PPC64_GOT_TPREL16_DS
;
1198 case BFD_RELOC_PPC_GOT_TPREL16_LO
: r
= R_PPC64_GOT_TPREL16_LO_DS
;
1200 case BFD_RELOC_PPC_GOT_TPREL16_HI
: r
= R_PPC64_GOT_TPREL16_HI
;
1202 case BFD_RELOC_PPC_GOT_TPREL16_HA
: r
= R_PPC64_GOT_TPREL16_HA
;
1204 case BFD_RELOC_PPC_GOT_DTPREL16
: r
= R_PPC64_GOT_DTPREL16_DS
;
1206 case BFD_RELOC_PPC_GOT_DTPREL16_LO
: r
= R_PPC64_GOT_DTPREL16_LO_DS
;
1208 case BFD_RELOC_PPC_GOT_DTPREL16_HI
: r
= R_PPC64_GOT_DTPREL16_HI
;
1210 case BFD_RELOC_PPC_GOT_DTPREL16_HA
: r
= R_PPC64_GOT_DTPREL16_HA
;
1212 case BFD_RELOC_PPC64_TPREL16_DS
: r
= R_PPC64_TPREL16_DS
;
1214 case BFD_RELOC_PPC64_TPREL16_LO_DS
: r
= R_PPC64_TPREL16_LO_DS
;
1216 case BFD_RELOC_PPC64_TPREL16_HIGHER
: r
= R_PPC64_TPREL16_HIGHER
;
1218 case BFD_RELOC_PPC64_TPREL16_HIGHERA
: r
= R_PPC64_TPREL16_HIGHERA
;
1220 case BFD_RELOC_PPC64_TPREL16_HIGHEST
: r
= R_PPC64_TPREL16_HIGHEST
;
1222 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
: r
= R_PPC64_TPREL16_HIGHESTA
;
1224 case BFD_RELOC_PPC64_DTPREL16_DS
: r
= R_PPC64_DTPREL16_DS
;
1226 case BFD_RELOC_PPC64_DTPREL16_LO_DS
: r
= R_PPC64_DTPREL16_LO_DS
;
1228 case BFD_RELOC_PPC64_DTPREL16_HIGHER
: r
= R_PPC64_DTPREL16_HIGHER
;
1230 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
: r
= R_PPC64_DTPREL16_HIGHERA
;
1232 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
: r
= R_PPC64_DTPREL16_HIGHEST
;
1234 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
: r
= R_PPC64_DTPREL16_HIGHESTA
;
1236 case BFD_RELOC_16_PCREL
: r
= R_PPC64_REL16
;
1238 case BFD_RELOC_LO16_PCREL
: r
= R_PPC64_REL16_LO
;
1240 case BFD_RELOC_HI16_PCREL
: r
= R_PPC64_REL16_HI
;
1242 case BFD_RELOC_HI16_S_PCREL
: r
= R_PPC64_REL16_HA
;
1244 case BFD_RELOC_PPC64_REL16_HIGH
: r
= R_PPC64_REL16_HIGH
;
1246 case BFD_RELOC_PPC64_REL16_HIGHA
: r
= R_PPC64_REL16_HIGHA
;
1248 case BFD_RELOC_PPC64_REL16_HIGHER
: r
= R_PPC64_REL16_HIGHER
;
1250 case BFD_RELOC_PPC64_REL16_HIGHERA
: r
= R_PPC64_REL16_HIGHERA
;
1252 case BFD_RELOC_PPC64_REL16_HIGHEST
: r
= R_PPC64_REL16_HIGHEST
;
1254 case BFD_RELOC_PPC64_REL16_HIGHESTA
: r
= R_PPC64_REL16_HIGHESTA
;
1256 case BFD_RELOC_PPC_16DX_HA
: r
= R_PPC64_16DX_HA
;
1258 case BFD_RELOC_PPC_REL16DX_HA
: r
= R_PPC64_REL16DX_HA
;
1260 case BFD_RELOC_PPC64_ENTRY
: r
= R_PPC64_ENTRY
;
1262 case BFD_RELOC_PPC64_ADDR64_LOCAL
: r
= R_PPC64_ADDR64_LOCAL
;
1264 case BFD_RELOC_PPC64_D34
: r
= R_PPC64_D34
;
1266 case BFD_RELOC_PPC64_D34_LO
: r
= R_PPC64_D34_LO
;
1268 case BFD_RELOC_PPC64_D34_HI30
: r
= R_PPC64_D34_HI30
;
1270 case BFD_RELOC_PPC64_D34_HA30
: r
= R_PPC64_D34_HA30
;
1272 case BFD_RELOC_PPC64_PCREL34
: r
= R_PPC64_PCREL34
;
1274 case BFD_RELOC_PPC64_GOT_PCREL34
: r
= R_PPC64_GOT_PCREL34
;
1276 case BFD_RELOC_PPC64_PLT_PCREL34
: r
= R_PPC64_PLT_PCREL34
;
1278 case BFD_RELOC_PPC64_TPREL34
: r
= R_PPC64_TPREL34
;
1280 case BFD_RELOC_PPC64_DTPREL34
: r
= R_PPC64_DTPREL34
;
1282 case BFD_RELOC_PPC64_GOT_TLSGD34
: r
= R_PPC64_GOT_TLSGD34
;
1284 case BFD_RELOC_PPC64_GOT_TLSLD34
: r
= R_PPC64_GOT_TLSLD34
;
1286 case BFD_RELOC_PPC64_GOT_TPREL34
: r
= R_PPC64_GOT_TPREL34
;
1288 case BFD_RELOC_PPC64_GOT_DTPREL34
: r
= R_PPC64_GOT_DTPREL34
;
1290 case BFD_RELOC_PPC64_ADDR16_HIGHER34
: r
= R_PPC64_ADDR16_HIGHER34
;
1292 case BFD_RELOC_PPC64_ADDR16_HIGHERA34
: r
= R_PPC64_ADDR16_HIGHERA34
;
1294 case BFD_RELOC_PPC64_ADDR16_HIGHEST34
: r
= R_PPC64_ADDR16_HIGHEST34
;
1296 case BFD_RELOC_PPC64_ADDR16_HIGHESTA34
: r
= R_PPC64_ADDR16_HIGHESTA34
;
1298 case BFD_RELOC_PPC64_REL16_HIGHER34
: r
= R_PPC64_REL16_HIGHER34
;
1300 case BFD_RELOC_PPC64_REL16_HIGHERA34
: r
= R_PPC64_REL16_HIGHERA34
;
1302 case BFD_RELOC_PPC64_REL16_HIGHEST34
: r
= R_PPC64_REL16_HIGHEST34
;
1304 case BFD_RELOC_PPC64_REL16_HIGHESTA34
: r
= R_PPC64_REL16_HIGHESTA34
;
1306 case BFD_RELOC_PPC64_D28
: r
= R_PPC64_D28
;
1308 case BFD_RELOC_PPC64_PCREL28
: r
= R_PPC64_PCREL28
;
1310 case BFD_RELOC_VTABLE_INHERIT
: r
= R_PPC64_GNU_VTINHERIT
;
1312 case BFD_RELOC_VTABLE_ENTRY
: r
= R_PPC64_GNU_VTENTRY
;
1316 return ppc64_elf_howto_table
[r
];
1319 static reloc_howto_type
*
1320 ppc64_elf_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
1325 for (i
= 0; i
< ARRAY_SIZE (ppc64_elf_howto_raw
); i
++)
1326 if (ppc64_elf_howto_raw
[i
].name
!= NULL
1327 && strcasecmp (ppc64_elf_howto_raw
[i
].name
, r_name
) == 0)
1328 return &ppc64_elf_howto_raw
[i
];
1333 /* Set the howto pointer for a PowerPC ELF reloc. */
1336 ppc64_elf_info_to_howto (bfd
*abfd
, arelent
*cache_ptr
,
1337 Elf_Internal_Rela
*dst
)
1341 /* Initialize howto table if needed. */
1342 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
1345 type
= ELF64_R_TYPE (dst
->r_info
);
1346 if (type
>= ARRAY_SIZE (ppc64_elf_howto_table
))
1348 /* xgettext:c-format */
1349 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
1351 bfd_set_error (bfd_error_bad_value
);
1354 cache_ptr
->howto
= ppc64_elf_howto_table
[type
];
1355 if (cache_ptr
->howto
== NULL
|| cache_ptr
->howto
->name
== NULL
)
1357 /* xgettext:c-format */
1358 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
1360 bfd_set_error (bfd_error_bad_value
);
1367 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
1369 static bfd_reloc_status_type
1370 ppc64_elf_ha_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1371 void *data
, asection
*input_section
,
1372 bfd
*output_bfd
, char **error_message
)
1374 enum elf_ppc64_reloc_type r_type
;
1376 bfd_size_type octets
;
1379 /* If this is a relocatable link (output_bfd test tells us), just
1380 call the generic function. Any adjustment will be done at final
1382 if (output_bfd
!= NULL
)
1383 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1384 input_section
, output_bfd
, error_message
);
1386 /* Adjust the addend for sign extension of the low 16 (or 34) bits.
1387 We won't actually be using the low bits, so trashing them
1389 r_type
= reloc_entry
->howto
->type
;
1390 if (r_type
== R_PPC64_ADDR16_HIGHERA34
1391 || r_type
== R_PPC64_ADDR16_HIGHESTA34
1392 || r_type
== R_PPC64_REL16_HIGHERA34
1393 || r_type
== R_PPC64_REL16_HIGHESTA34
)
1394 reloc_entry
->addend
+= 1ULL << 33;
1396 reloc_entry
->addend
+= 1U << 15;
1397 if (r_type
!= R_PPC64_REL16DX_HA
)
1398 return bfd_reloc_continue
;
1401 if (!bfd_is_com_section (symbol
->section
))
1402 value
= symbol
->value
;
1403 value
+= (reloc_entry
->addend
1404 + symbol
->section
->output_offset
1405 + symbol
->section
->output_section
->vma
);
1406 value
-= (reloc_entry
->address
1407 + input_section
->output_offset
1408 + input_section
->output_section
->vma
);
1409 value
= (bfd_signed_vma
) value
>> 16;
1411 octets
= reloc_entry
->address
* OCTETS_PER_BYTE (abfd
, input_section
);
1412 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ octets
);
1414 insn
|= (value
& 0xffc1) | ((value
& 0x3e) << 15);
1415 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ octets
);
1416 if (value
+ 0x8000 > 0xffff)
1417 return bfd_reloc_overflow
;
1418 return bfd_reloc_ok
;
1421 static bfd_reloc_status_type
1422 ppc64_elf_branch_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1423 void *data
, asection
*input_section
,
1424 bfd
*output_bfd
, char **error_message
)
1426 if (output_bfd
!= NULL
)
1427 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1428 input_section
, output_bfd
, error_message
);
1430 if (strcmp (symbol
->section
->name
, ".opd") == 0
1431 && (symbol
->section
->owner
->flags
& DYNAMIC
) == 0)
1433 bfd_vma dest
= opd_entry_value (symbol
->section
,
1434 symbol
->value
+ reloc_entry
->addend
,
1436 if (dest
!= (bfd_vma
) -1)
1437 reloc_entry
->addend
= dest
- (symbol
->value
1438 + symbol
->section
->output_section
->vma
1439 + symbol
->section
->output_offset
);
1443 elf_symbol_type
*elfsym
= (elf_symbol_type
*) symbol
;
1445 if (symbol
->section
->owner
!= abfd
1446 && symbol
->section
->owner
!= NULL
1447 && abiversion (symbol
->section
->owner
) >= 2)
1451 for (i
= 0; i
< symbol
->section
->owner
->symcount
; ++i
)
1453 asymbol
*symdef
= symbol
->section
->owner
->outsymbols
[i
];
1455 if (strcmp (symdef
->name
, symbol
->name
) == 0)
1457 elfsym
= (elf_symbol_type
*) symdef
;
1463 += PPC64_LOCAL_ENTRY_OFFSET (elfsym
->internal_elf_sym
.st_other
);
1465 return bfd_reloc_continue
;
1468 static bfd_reloc_status_type
1469 ppc64_elf_brtaken_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1470 void *data
, asection
*input_section
,
1471 bfd
*output_bfd
, char **error_message
)
1474 enum elf_ppc64_reloc_type r_type
;
1475 bfd_size_type octets
;
1476 /* Assume 'at' branch hints. */
1477 bfd_boolean is_isa_v2
= TRUE
;
1479 /* If this is a relocatable link (output_bfd test tells us), just
1480 call the generic function. Any adjustment will be done at final
1482 if (output_bfd
!= NULL
)
1483 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1484 input_section
, output_bfd
, error_message
);
1486 octets
= reloc_entry
->address
* OCTETS_PER_BYTE (abfd
, input_section
);
1487 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ octets
);
1488 insn
&= ~(0x01 << 21);
1489 r_type
= reloc_entry
->howto
->type
;
1490 if (r_type
== R_PPC64_ADDR14_BRTAKEN
1491 || r_type
== R_PPC64_REL14_BRTAKEN
)
1492 insn
|= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
1496 /* Set 'a' bit. This is 0b00010 in BO field for branch
1497 on CR(BI) insns (BO == 001at or 011at), and 0b01000
1498 for branch on CTR insns (BO == 1a00t or 1a01t). */
1499 if ((insn
& (0x14 << 21)) == (0x04 << 21))
1501 else if ((insn
& (0x14 << 21)) == (0x10 << 21))
1511 if (!bfd_is_com_section (symbol
->section
))
1512 target
= symbol
->value
;
1513 target
+= symbol
->section
->output_section
->vma
;
1514 target
+= symbol
->section
->output_offset
;
1515 target
+= reloc_entry
->addend
;
1517 from
= (reloc_entry
->address
1518 + input_section
->output_offset
1519 + input_section
->output_section
->vma
);
1521 /* Invert 'y' bit if not the default. */
1522 if ((bfd_signed_vma
) (target
- from
) < 0)
1525 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ octets
);
1527 return ppc64_elf_branch_reloc (abfd
, reloc_entry
, symbol
, data
,
1528 input_section
, output_bfd
, error_message
);
1531 static bfd_reloc_status_type
1532 ppc64_elf_sectoff_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1533 void *data
, asection
*input_section
,
1534 bfd
*output_bfd
, char **error_message
)
1536 /* If this is a relocatable link (output_bfd test tells us), just
1537 call the generic function. Any adjustment will be done at final
1539 if (output_bfd
!= NULL
)
1540 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1541 input_section
, output_bfd
, error_message
);
1543 /* Subtract the symbol section base address. */
1544 reloc_entry
->addend
-= symbol
->section
->output_section
->vma
;
1545 return bfd_reloc_continue
;
1548 static bfd_reloc_status_type
1549 ppc64_elf_sectoff_ha_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1550 void *data
, asection
*input_section
,
1551 bfd
*output_bfd
, char **error_message
)
1553 /* If this is a relocatable link (output_bfd test tells us), just
1554 call the generic function. Any adjustment will be done at final
1556 if (output_bfd
!= NULL
)
1557 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1558 input_section
, output_bfd
, error_message
);
1560 /* Subtract the symbol section base address. */
1561 reloc_entry
->addend
-= symbol
->section
->output_section
->vma
;
1563 /* Adjust the addend for sign extension of the low 16 bits. */
1564 reloc_entry
->addend
+= 0x8000;
1565 return bfd_reloc_continue
;
1568 static bfd_reloc_status_type
1569 ppc64_elf_toc_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1570 void *data
, asection
*input_section
,
1571 bfd
*output_bfd
, char **error_message
)
1575 /* If this is a relocatable link (output_bfd test tells us), just
1576 call the generic function. Any adjustment will be done at final
1578 if (output_bfd
!= NULL
)
1579 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1580 input_section
, output_bfd
, error_message
);
1582 TOCstart
= _bfd_get_gp_value (input_section
->output_section
->owner
);
1584 TOCstart
= ppc64_elf_set_toc (NULL
, input_section
->output_section
->owner
);
1586 /* Subtract the TOC base address. */
1587 reloc_entry
->addend
-= TOCstart
+ TOC_BASE_OFF
;
1588 return bfd_reloc_continue
;
1591 static bfd_reloc_status_type
1592 ppc64_elf_toc_ha_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1593 void *data
, asection
*input_section
,
1594 bfd
*output_bfd
, char **error_message
)
1598 /* If this is a relocatable link (output_bfd test tells us), just
1599 call the generic function. Any adjustment will be done at final
1601 if (output_bfd
!= NULL
)
1602 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1603 input_section
, output_bfd
, error_message
);
1605 TOCstart
= _bfd_get_gp_value (input_section
->output_section
->owner
);
1607 TOCstart
= ppc64_elf_set_toc (NULL
, input_section
->output_section
->owner
);
1609 /* Subtract the TOC base address. */
1610 reloc_entry
->addend
-= TOCstart
+ TOC_BASE_OFF
;
1612 /* Adjust the addend for sign extension of the low 16 bits. */
1613 reloc_entry
->addend
+= 0x8000;
1614 return bfd_reloc_continue
;
1617 static bfd_reloc_status_type
1618 ppc64_elf_toc64_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1619 void *data
, asection
*input_section
,
1620 bfd
*output_bfd
, char **error_message
)
1623 bfd_size_type octets
;
1625 /* If this is a relocatable link (output_bfd test tells us), just
1626 call the generic function. Any adjustment will be done at final
1628 if (output_bfd
!= NULL
)
1629 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1630 input_section
, output_bfd
, error_message
);
1632 TOCstart
= _bfd_get_gp_value (input_section
->output_section
->owner
);
1634 TOCstart
= ppc64_elf_set_toc (NULL
, input_section
->output_section
->owner
);
1636 octets
= reloc_entry
->address
* OCTETS_PER_BYTE (abfd
, input_section
);
1637 bfd_put_64 (abfd
, TOCstart
+ TOC_BASE_OFF
, (bfd_byte
*) data
+ octets
);
1638 return bfd_reloc_ok
;
1641 static bfd_reloc_status_type
1642 ppc64_elf_prefix_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1643 void *data
, asection
*input_section
,
1644 bfd
*output_bfd
, char **error_message
)
1649 if (output_bfd
!= NULL
)
1650 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1651 input_section
, output_bfd
, error_message
);
1653 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1655 insn
|= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
+ 4);
1657 targ
= (symbol
->section
->output_section
->vma
1658 + symbol
->section
->output_offset
1659 + reloc_entry
->addend
);
1660 if (!bfd_is_com_section (symbol
->section
))
1661 targ
+= symbol
->value
;
1662 if (reloc_entry
->howto
->type
== R_PPC64_D34_HA30
)
1664 if (reloc_entry
->howto
->pc_relative
)
1666 bfd_vma from
= (reloc_entry
->address
1667 + input_section
->output_offset
1668 + input_section
->output_section
->vma
);
1671 targ
>>= reloc_entry
->howto
->rightshift
;
1672 insn
&= ~reloc_entry
->howto
->dst_mask
;
1673 insn
|= ((targ
<< 16) | (targ
& 0xffff)) & reloc_entry
->howto
->dst_mask
;
1674 bfd_put_32 (abfd
, insn
>> 32, (bfd_byte
*) data
+ reloc_entry
->address
);
1675 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ reloc_entry
->address
+ 4);
1676 if (reloc_entry
->howto
->complain_on_overflow
== complain_overflow_signed
1677 && (targ
+ (1ULL << (reloc_entry
->howto
->bitsize
- 1))
1678 >= 1ULL << reloc_entry
->howto
->bitsize
))
1679 return bfd_reloc_overflow
;
1680 return bfd_reloc_ok
;
1683 static bfd_reloc_status_type
1684 ppc64_elf_unhandled_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1685 void *data
, asection
*input_section
,
1686 bfd
*output_bfd
, char **error_message
)
1688 /* If this is a relocatable link (output_bfd test tells us), just
1689 call the generic function. Any adjustment will be done at final
1691 if (output_bfd
!= NULL
)
1692 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1693 input_section
, output_bfd
, error_message
);
1695 if (error_message
!= NULL
)
1697 static char buf
[60];
1698 sprintf (buf
, "generic linker can't handle %s",
1699 reloc_entry
->howto
->name
);
1700 *error_message
= buf
;
1702 return bfd_reloc_dangerous
;
1705 /* Track GOT entries needed for a given symbol. We might need more
1706 than one got entry per symbol. */
1709 struct got_entry
*next
;
1711 /* The symbol addend that we'll be placing in the GOT. */
1714 /* Unlike other ELF targets, we use separate GOT entries for the same
1715 symbol referenced from different input files. This is to support
1716 automatic multiple TOC/GOT sections, where the TOC base can vary
1717 from one input file to another. After partitioning into TOC groups
1718 we merge entries within the group.
1720 Point to the BFD owning this GOT entry. */
1723 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
1724 TLS_TPREL or TLS_DTPREL for tls entries. */
1725 unsigned char tls_type
;
1727 /* Non-zero if got.ent points to real entry. */
1728 unsigned char is_indirect
;
1730 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
1733 bfd_signed_vma refcount
;
1735 struct got_entry
*ent
;
1739 /* The same for PLT. */
1742 struct plt_entry
*next
;
1748 bfd_signed_vma refcount
;
1753 struct ppc64_elf_obj_tdata
1755 struct elf_obj_tdata elf
;
1757 /* Shortcuts to dynamic linker sections. */
1761 /* Used during garbage collection. We attach global symbols defined
1762 on removed .opd entries to this section so that the sym is removed. */
1763 asection
*deleted_section
;
1765 /* TLS local dynamic got entry handling. Support for multiple GOT
1766 sections means we potentially need one of these for each input bfd. */
1767 struct got_entry tlsld_got
;
1771 /* A copy of relocs before they are modified for --emit-relocs. */
1772 Elf_Internal_Rela
*relocs
;
1774 /* Section contents. */
1778 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
1779 the reloc to be in the range -32768 to 32767. */
1780 unsigned int has_small_toc_reloc
: 1;
1782 /* Set if toc/got ha relocs detected not using r2, or lo reloc
1783 instruction not one we handle. */
1784 unsigned int unexpected_toc_insn
: 1;
1786 /* Set if PLT/GOT/TOC relocs that can be optimised are present in
1788 unsigned int has_optrel
: 1;
1791 #define ppc64_elf_tdata(bfd) \
1792 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
1794 #define ppc64_tlsld_got(bfd) \
1795 (&ppc64_elf_tdata (bfd)->tlsld_got)
1797 #define is_ppc64_elf(bfd) \
1798 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
1799 && elf_object_id (bfd) == PPC64_ELF_DATA)
1801 /* Override the generic function because we store some extras. */
1804 ppc64_elf_mkobject (bfd
*abfd
)
1806 return bfd_elf_allocate_object (abfd
, sizeof (struct ppc64_elf_obj_tdata
),
1810 /* Fix bad default arch selected for a 64 bit input bfd when the
1811 default is 32 bit. Also select arch based on apuinfo. */
1814 ppc64_elf_object_p (bfd
*abfd
)
1816 if (!abfd
->arch_info
->the_default
)
1819 if (abfd
->arch_info
->bits_per_word
== 32)
1821 Elf_Internal_Ehdr
*i_ehdr
= elf_elfheader (abfd
);
1823 if (i_ehdr
->e_ident
[EI_CLASS
] == ELFCLASS64
)
1825 /* Relies on arch after 32 bit default being 64 bit default. */
1826 abfd
->arch_info
= abfd
->arch_info
->next
;
1827 BFD_ASSERT (abfd
->arch_info
->bits_per_word
== 64);
1830 return _bfd_elf_ppc_set_arch (abfd
);
1833 /* Support for core dump NOTE sections. */
1836 ppc64_elf_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
1838 size_t offset
, size
;
1840 if (note
->descsz
!= 504)
1844 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
1847 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 32);
1853 /* Make a ".reg/999" section. */
1854 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
1855 size
, note
->descpos
+ offset
);
1859 ppc64_elf_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
1861 if (note
->descsz
!= 136)
1864 elf_tdata (abfd
)->core
->pid
1865 = bfd_get_32 (abfd
, note
->descdata
+ 24);
1866 elf_tdata (abfd
)->core
->program
1867 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 40, 16);
1868 elf_tdata (abfd
)->core
->command
1869 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 56, 80);
1875 ppc64_elf_write_core_note (bfd
*abfd
, char *buf
, int *bufsiz
, int note_type
,
1885 char data
[136] ATTRIBUTE_NONSTRING
;
1888 va_start (ap
, note_type
);
1889 memset (data
, 0, sizeof (data
));
1890 strncpy (data
+ 40, va_arg (ap
, const char *), 16);
1891 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
1893 /* GCC 8.0 and 8.1 warn about 80 equals destination size with
1894 -Wstringop-truncation:
1895 https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85643
1897 DIAGNOSTIC_IGNORE_STRINGOP_TRUNCATION
;
1899 strncpy (data
+ 56, va_arg (ap
, const char *), 80);
1900 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
1904 return elfcore_write_note (abfd
, buf
, bufsiz
,
1905 "CORE", note_type
, data
, sizeof (data
));
1916 va_start (ap
, note_type
);
1917 memset (data
, 0, 112);
1918 pid
= va_arg (ap
, long);
1919 bfd_put_32 (abfd
, pid
, data
+ 32);
1920 cursig
= va_arg (ap
, int);
1921 bfd_put_16 (abfd
, cursig
, data
+ 12);
1922 greg
= va_arg (ap
, const void *);
1923 memcpy (data
+ 112, greg
, 384);
1924 memset (data
+ 496, 0, 8);
1926 return elfcore_write_note (abfd
, buf
, bufsiz
,
1927 "CORE", note_type
, data
, sizeof (data
));
1932 /* Add extra PPC sections. */
1934 static const struct bfd_elf_special_section ppc64_elf_special_sections
[] =
1936 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS
, 0 },
1937 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
1938 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
1939 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
1940 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
1941 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
1942 { NULL
, 0, 0, 0, 0 }
1945 enum _ppc64_sec_type
{
1951 struct _ppc64_elf_section_data
1953 struct bfd_elf_section_data elf
;
1957 /* An array with one entry for each opd function descriptor,
1958 and some spares since opd entries may be either 16 or 24 bytes. */
1959 #define OPD_NDX(OFF) ((OFF) >> 4)
1960 struct _opd_sec_data
1962 /* Points to the function code section for local opd entries. */
1963 asection
**func_sec
;
1965 /* After editing .opd, adjust references to opd local syms. */
1969 /* An array for toc sections, indexed by offset/8. */
1970 struct _toc_sec_data
1972 /* Specifies the relocation symbol index used at a given toc offset. */
1975 /* And the relocation addend. */
1980 enum _ppc64_sec_type sec_type
:2;
1982 /* Flag set when small branches are detected. Used to
1983 select suitable defaults for the stub group size. */
1984 unsigned int has_14bit_branch
:1;
1986 /* Flag set when PLTCALL relocs are detected. */
1987 unsigned int has_pltcall
:1;
1989 /* Flag set when section has PLT/GOT/TOC relocations that can be
1991 unsigned int has_optrel
:1;
1994 #define ppc64_elf_section_data(sec) \
1995 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
1998 ppc64_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
2000 if (!sec
->used_by_bfd
)
2002 struct _ppc64_elf_section_data
*sdata
;
2003 bfd_size_type amt
= sizeof (*sdata
);
2005 sdata
= bfd_zalloc (abfd
, amt
);
2008 sec
->used_by_bfd
= sdata
;
2011 return _bfd_elf_new_section_hook (abfd
, sec
);
2014 static struct _opd_sec_data
*
2015 get_opd_info (asection
* sec
)
2018 && ppc64_elf_section_data (sec
) != NULL
2019 && ppc64_elf_section_data (sec
)->sec_type
== sec_opd
)
2020 return &ppc64_elf_section_data (sec
)->u
.opd
;
2024 /* Parameters for the qsort hook. */
2025 static bfd_boolean synthetic_relocatable
;
2026 static asection
*synthetic_opd
;
2028 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
2031 compare_symbols (const void *ap
, const void *bp
)
2033 const asymbol
*a
= *(const asymbol
**) ap
;
2034 const asymbol
*b
= *(const asymbol
**) bp
;
2036 /* Section symbols first. */
2037 if ((a
->flags
& BSF_SECTION_SYM
) && !(b
->flags
& BSF_SECTION_SYM
))
2039 if (!(a
->flags
& BSF_SECTION_SYM
) && (b
->flags
& BSF_SECTION_SYM
))
2042 /* then .opd symbols. */
2043 if (synthetic_opd
!= NULL
)
2045 if (strcmp (a
->section
->name
, ".opd") == 0
2046 && strcmp (b
->section
->name
, ".opd") != 0)
2048 if (strcmp (a
->section
->name
, ".opd") != 0
2049 && strcmp (b
->section
->name
, ".opd") == 0)
2053 /* then other code symbols. */
2054 if (((a
->section
->flags
& (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
))
2055 == (SEC_CODE
| SEC_ALLOC
))
2056 && ((b
->section
->flags
& (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
))
2057 != (SEC_CODE
| SEC_ALLOC
)))
2060 if (((a
->section
->flags
& (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
))
2061 != (SEC_CODE
| SEC_ALLOC
))
2062 && ((b
->section
->flags
& (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
))
2063 == (SEC_CODE
| SEC_ALLOC
)))
2066 if (synthetic_relocatable
)
2068 if (a
->section
->id
< b
->section
->id
)
2071 if (a
->section
->id
> b
->section
->id
)
2075 if (a
->value
+ a
->section
->vma
< b
->value
+ b
->section
->vma
)
2078 if (a
->value
+ a
->section
->vma
> b
->value
+ b
->section
->vma
)
2081 /* For syms with the same value, prefer strong dynamic global function
2082 syms over other syms. */
2083 if ((a
->flags
& BSF_GLOBAL
) != 0 && (b
->flags
& BSF_GLOBAL
) == 0)
2086 if ((a
->flags
& BSF_GLOBAL
) == 0 && (b
->flags
& BSF_GLOBAL
) != 0)
2089 if ((a
->flags
& BSF_FUNCTION
) != 0 && (b
->flags
& BSF_FUNCTION
) == 0)
2092 if ((a
->flags
& BSF_FUNCTION
) == 0 && (b
->flags
& BSF_FUNCTION
) != 0)
2095 if ((a
->flags
& BSF_WEAK
) == 0 && (b
->flags
& BSF_WEAK
) != 0)
2098 if ((a
->flags
& BSF_WEAK
) != 0 && (b
->flags
& BSF_WEAK
) == 0)
2101 if ((a
->flags
& BSF_DYNAMIC
) != 0 && (b
->flags
& BSF_DYNAMIC
) == 0)
2104 if ((a
->flags
& BSF_DYNAMIC
) == 0 && (b
->flags
& BSF_DYNAMIC
) != 0)
2107 /* Finally, sort on where the symbol is in memory. The symbols will
2108 be in at most two malloc'd blocks, one for static syms, one for
2109 dynamic syms, and we distinguish the two blocks above by testing
2110 BSF_DYNAMIC. Since we are sorting the symbol pointers which were
2111 originally in the same order as the symbols (and we're not
2112 sorting the symbols themselves), this ensures a stable sort. */
2120 /* Search SYMS for a symbol of the given VALUE. */
2123 sym_exists_at (asymbol
**syms
, size_t lo
, size_t hi
, unsigned int id
,
2128 if (id
== (unsigned) -1)
2132 mid
= (lo
+ hi
) >> 1;
2133 if (syms
[mid
]->value
+ syms
[mid
]->section
->vma
< value
)
2135 else if (syms
[mid
]->value
+ syms
[mid
]->section
->vma
> value
)
2145 mid
= (lo
+ hi
) >> 1;
2146 if (syms
[mid
]->section
->id
< id
)
2148 else if (syms
[mid
]->section
->id
> id
)
2150 else if (syms
[mid
]->value
< value
)
2152 else if (syms
[mid
]->value
> value
)
2162 section_covers_vma (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*section
, void *ptr
)
2164 bfd_vma vma
= *(bfd_vma
*) ptr
;
2165 return ((section
->flags
& SEC_ALLOC
) != 0
2166 && section
->vma
<= vma
2167 && vma
< section
->vma
+ section
->size
);
2170 /* Create synthetic symbols, effectively restoring "dot-symbol" function
2171 entry syms. Also generate @plt symbols for the glink branch table.
2172 Returns count of synthetic symbols in RET or -1 on error. */
2175 ppc64_elf_get_synthetic_symtab (bfd
*abfd
,
2176 long static_count
, asymbol
**static_syms
,
2177 long dyn_count
, asymbol
**dyn_syms
,
2183 size_t symcount
, codesecsym
, codesecsymend
, secsymend
, opdsymend
;
2184 asection
*opd
= NULL
;
2185 bfd_boolean relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2187 int abi
= abiversion (abfd
);
2193 opd
= bfd_get_section_by_name (abfd
, ".opd");
2194 if (opd
== NULL
&& abi
== 1)
2206 symcount
= static_count
;
2208 symcount
+= dyn_count
;
2212 syms
= bfd_malloc ((symcount
+ 1) * sizeof (*syms
));
2216 if (!relocatable
&& static_count
!= 0 && dyn_count
!= 0)
2218 /* Use both symbol tables. */
2219 memcpy (syms
, static_syms
, static_count
* sizeof (*syms
));
2220 memcpy (syms
+ static_count
, dyn_syms
,
2221 (dyn_count
+ 1) * sizeof (*syms
));
2223 else if (!relocatable
&& static_count
== 0)
2224 memcpy (syms
, dyn_syms
, (symcount
+ 1) * sizeof (*syms
));
2226 memcpy (syms
, static_syms
, (symcount
+ 1) * sizeof (*syms
));
2228 /* Trim uninteresting symbols. Interesting symbols are section,
2229 function, and notype symbols. */
2230 for (i
= 0, j
= 0; i
< symcount
; ++i
)
2231 if ((syms
[i
]->flags
& (BSF_FILE
| BSF_OBJECT
| BSF_THREAD_LOCAL
2232 | BSF_RELC
| BSF_SRELC
)) == 0)
2233 syms
[j
++] = syms
[i
];
2236 synthetic_relocatable
= relocatable
;
2237 synthetic_opd
= opd
;
2238 qsort (syms
, symcount
, sizeof (*syms
), compare_symbols
);
2240 if (!relocatable
&& symcount
> 1)
2242 /* Trim duplicate syms, since we may have merged the normal
2243 and dynamic symbols. Actually, we only care about syms
2244 that have different values, so trim any with the same
2245 value. Don't consider ifunc and ifunc resolver symbols
2246 duplicates however, because GDB wants to know whether a
2247 text symbol is an ifunc resolver. */
2248 for (i
= 1, j
= 1; i
< symcount
; ++i
)
2250 const asymbol
*s0
= syms
[i
- 1];
2251 const asymbol
*s1
= syms
[i
];
2253 if ((s0
->value
+ s0
->section
->vma
2254 != s1
->value
+ s1
->section
->vma
)
2255 || ((s0
->flags
& BSF_GNU_INDIRECT_FUNCTION
)
2256 != (s1
->flags
& BSF_GNU_INDIRECT_FUNCTION
)))
2257 syms
[j
++] = syms
[i
];
2263 /* Note that here and in compare_symbols we can't compare opd and
2264 sym->section directly. With separate debug info files, the
2265 symbols will be extracted from the debug file while abfd passed
2266 to this function is the real binary. */
2267 if (strcmp (syms
[i
]->section
->name
, ".opd") == 0)
2271 for (; i
< symcount
; ++i
)
2272 if (((syms
[i
]->section
->flags
& (SEC_CODE
| SEC_ALLOC
2273 | SEC_THREAD_LOCAL
))
2274 != (SEC_CODE
| SEC_ALLOC
))
2275 || (syms
[i
]->flags
& BSF_SECTION_SYM
) == 0)
2279 for (; i
< symcount
; ++i
)
2280 if ((syms
[i
]->flags
& BSF_SECTION_SYM
) == 0)
2284 for (; i
< symcount
; ++i
)
2285 if (strcmp (syms
[i
]->section
->name
, ".opd") != 0)
2289 for (; i
< symcount
; ++i
)
2290 if (((syms
[i
]->section
->flags
2291 & (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
)))
2292 != (SEC_CODE
| SEC_ALLOC
))
2300 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
2305 if (opdsymend
== secsymend
)
2308 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
2309 relcount
= (opd
->flags
& SEC_RELOC
) ? opd
->reloc_count
: 0;
2313 if (!(*slurp_relocs
) (abfd
, opd
, static_syms
, FALSE
))
2320 for (i
= secsymend
, r
= opd
->relocation
; i
< opdsymend
; ++i
)
2324 while (r
< opd
->relocation
+ relcount
2325 && r
->address
< syms
[i
]->value
+ opd
->vma
)
2328 if (r
== opd
->relocation
+ relcount
)
2331 if (r
->address
!= syms
[i
]->value
+ opd
->vma
)
2334 if (r
->howto
->type
!= R_PPC64_ADDR64
)
2337 sym
= *r
->sym_ptr_ptr
;
2338 if (!sym_exists_at (syms
, opdsymend
, symcount
,
2339 sym
->section
->id
, sym
->value
+ r
->addend
))
2342 size
+= sizeof (asymbol
);
2343 size
+= strlen (syms
[i
]->name
) + 2;
2349 s
= *ret
= bfd_malloc (size
);
2356 names
= (char *) (s
+ count
);
2358 for (i
= secsymend
, r
= opd
->relocation
; i
< opdsymend
; ++i
)
2362 while (r
< opd
->relocation
+ relcount
2363 && r
->address
< syms
[i
]->value
+ opd
->vma
)
2366 if (r
== opd
->relocation
+ relcount
)
2369 if (r
->address
!= syms
[i
]->value
+ opd
->vma
)
2372 if (r
->howto
->type
!= R_PPC64_ADDR64
)
2375 sym
= *r
->sym_ptr_ptr
;
2376 if (!sym_exists_at (syms
, opdsymend
, symcount
,
2377 sym
->section
->id
, sym
->value
+ r
->addend
))
2382 s
->flags
|= BSF_SYNTHETIC
;
2383 s
->section
= sym
->section
;
2384 s
->value
= sym
->value
+ r
->addend
;
2387 len
= strlen (syms
[i
]->name
);
2388 memcpy (names
, syms
[i
]->name
, len
+ 1);
2390 /* Have udata.p point back to the original symbol this
2391 synthetic symbol was derived from. */
2392 s
->udata
.p
= syms
[i
];
2399 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
2400 bfd_byte
*contents
= NULL
;
2402 size_t plt_count
= 0;
2403 bfd_vma glink_vma
= 0, resolv_vma
= 0;
2404 asection
*dynamic
, *glink
= NULL
, *relplt
= NULL
;
2407 if (opd
!= NULL
&& !bfd_malloc_and_get_section (abfd
, opd
, &contents
))
2409 free_contents_and_exit_err
:
2411 free_contents_and_exit
:
2418 for (i
= secsymend
; i
< opdsymend
; ++i
)
2422 /* Ignore bogus symbols. */
2423 if (syms
[i
]->value
> opd
->size
- 8)
2426 ent
= bfd_get_64 (abfd
, contents
+ syms
[i
]->value
);
2427 if (!sym_exists_at (syms
, opdsymend
, symcount
, -1, ent
))
2430 size
+= sizeof (asymbol
);
2431 size
+= strlen (syms
[i
]->name
) + 2;
2435 /* Get start of .glink stubs from DT_PPC64_GLINK. */
2437 && (dynamic
= bfd_get_section_by_name (abfd
, ".dynamic")) != NULL
)
2439 bfd_byte
*dynbuf
, *extdyn
, *extdynend
;
2441 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
2443 if (!bfd_malloc_and_get_section (abfd
, dynamic
, &dynbuf
))
2444 goto free_contents_and_exit_err
;
2446 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
2447 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
2450 extdynend
= extdyn
+ dynamic
->size
;
2451 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
2453 Elf_Internal_Dyn dyn
;
2454 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
2456 if (dyn
.d_tag
== DT_NULL
)
2459 if (dyn
.d_tag
== DT_PPC64_GLINK
)
2461 /* The first glink stub starts at DT_PPC64_GLINK plus 32.
2462 See comment in ppc64_elf_finish_dynamic_sections. */
2463 glink_vma
= dyn
.d_un
.d_val
+ 8 * 4;
2464 /* The .glink section usually does not survive the final
2465 link; search for the section (usually .text) where the
2466 glink stubs now reside. */
2467 glink
= bfd_sections_find_if (abfd
, section_covers_vma
,
2478 /* Determine __glink trampoline by reading the relative branch
2479 from the first glink stub. */
2481 unsigned int off
= 0;
2483 while (bfd_get_section_contents (abfd
, glink
, buf
,
2484 glink_vma
+ off
- glink
->vma
, 4))
2486 unsigned int insn
= bfd_get_32 (abfd
, buf
);
2488 if ((insn
& ~0x3fffffc) == 0)
2491 = glink_vma
+ off
+ (insn
^ 0x2000000) - 0x2000000;
2500 size
+= sizeof (asymbol
) + sizeof ("__glink_PLTresolve");
2502 relplt
= bfd_get_section_by_name (abfd
, ".rela.plt");
2505 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
2506 if (!(*slurp_relocs
) (abfd
, relplt
, dyn_syms
, TRUE
))
2507 goto free_contents_and_exit_err
;
2509 plt_count
= relplt
->size
/ sizeof (Elf64_External_Rela
);
2510 size
+= plt_count
* sizeof (asymbol
);
2512 p
= relplt
->relocation
;
2513 for (i
= 0; i
< plt_count
; i
++, p
++)
2515 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
2517 size
+= sizeof ("+0x") - 1 + 16;
2523 goto free_contents_and_exit
;
2524 s
= *ret
= bfd_malloc (size
);
2526 goto free_contents_and_exit_err
;
2528 names
= (char *) (s
+ count
+ plt_count
+ (resolv_vma
!= 0));
2530 for (i
= secsymend
; i
< opdsymend
; ++i
)
2534 if (syms
[i
]->value
> opd
->size
- 8)
2537 ent
= bfd_get_64 (abfd
, contents
+ syms
[i
]->value
);
2538 if (!sym_exists_at (syms
, opdsymend
, symcount
, -1, ent
))
2542 asection
*sec
= abfd
->sections
;
2549 size_t mid
= (lo
+ hi
) >> 1;
2550 if (syms
[mid
]->section
->vma
< ent
)
2552 else if (syms
[mid
]->section
->vma
> ent
)
2556 sec
= syms
[mid
]->section
;
2561 if (lo
>= hi
&& lo
> codesecsym
)
2562 sec
= syms
[lo
- 1]->section
;
2564 for (; sec
!= NULL
; sec
= sec
->next
)
2568 /* SEC_LOAD may not be set if SEC is from a separate debug
2570 if ((sec
->flags
& SEC_ALLOC
) == 0)
2572 if ((sec
->flags
& SEC_CODE
) != 0)
2575 s
->flags
|= BSF_SYNTHETIC
;
2576 s
->value
= ent
- s
->section
->vma
;
2579 len
= strlen (syms
[i
]->name
);
2580 memcpy (names
, syms
[i
]->name
, len
+ 1);
2582 /* Have udata.p point back to the original symbol this
2583 synthetic symbol was derived from. */
2584 s
->udata
.p
= syms
[i
];
2590 if (glink
!= NULL
&& relplt
!= NULL
)
2594 /* Add a symbol for the main glink trampoline. */
2595 memset (s
, 0, sizeof *s
);
2597 s
->flags
= BSF_GLOBAL
| BSF_SYNTHETIC
;
2599 s
->value
= resolv_vma
- glink
->vma
;
2601 memcpy (names
, "__glink_PLTresolve",
2602 sizeof ("__glink_PLTresolve"));
2603 names
+= sizeof ("__glink_PLTresolve");
2608 /* FIXME: It would be very much nicer to put sym@plt on the
2609 stub rather than on the glink branch table entry. The
2610 objdump disassembler would then use a sensible symbol
2611 name on plt calls. The difficulty in doing so is
2612 a) finding the stubs, and,
2613 b) matching stubs against plt entries, and,
2614 c) there can be multiple stubs for a given plt entry.
2616 Solving (a) could be done by code scanning, but older
2617 ppc64 binaries used different stubs to current code.
2618 (b) is the tricky one since you need to known the toc
2619 pointer for at least one function that uses a pic stub to
2620 be able to calculate the plt address referenced.
2621 (c) means gdb would need to set multiple breakpoints (or
2622 find the glink branch itself) when setting breakpoints
2623 for pending shared library loads. */
2624 p
= relplt
->relocation
;
2625 for (i
= 0; i
< plt_count
; i
++, p
++)
2629 *s
= **p
->sym_ptr_ptr
;
2630 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
2631 we are defining a symbol, ensure one of them is set. */
2632 if ((s
->flags
& BSF_LOCAL
) == 0)
2633 s
->flags
|= BSF_GLOBAL
;
2634 s
->flags
|= BSF_SYNTHETIC
;
2636 s
->value
= glink_vma
- glink
->vma
;
2639 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
2640 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
2644 memcpy (names
, "+0x", sizeof ("+0x") - 1);
2645 names
+= sizeof ("+0x") - 1;
2646 bfd_sprintf_vma (abfd
, names
, p
->addend
);
2647 names
+= strlen (names
);
2649 memcpy (names
, "@plt", sizeof ("@plt"));
2650 names
+= sizeof ("@plt");
2670 /* The following functions are specific to the ELF linker, while
2671 functions above are used generally. Those named ppc64_elf_* are
2672 called by the main ELF linker code. They appear in this file more
2673 or less in the order in which they are called. eg.
2674 ppc64_elf_check_relocs is called early in the link process,
2675 ppc64_elf_finish_dynamic_sections is one of the last functions
2678 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
2679 functions have both a function code symbol and a function descriptor
2680 symbol. A call to foo in a relocatable object file looks like:
2687 The function definition in another object file might be:
2691 . .quad .TOC.@tocbase
2697 When the linker resolves the call during a static link, the branch
2698 unsurprisingly just goes to .foo and the .opd information is unused.
2699 If the function definition is in a shared library, things are a little
2700 different: The call goes via a plt call stub, the opd information gets
2701 copied to the plt, and the linker patches the nop.
2709 . std 2,40(1) # in practice, the call stub
2710 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
2711 . addi 11,11,Lfoo@toc@l # this is the general idea
2719 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
2721 The "reloc ()" notation is supposed to indicate that the linker emits
2722 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
2725 What are the difficulties here? Well, firstly, the relocations
2726 examined by the linker in check_relocs are against the function code
2727 sym .foo, while the dynamic relocation in the plt is emitted against
2728 the function descriptor symbol, foo. Somewhere along the line, we need
2729 to carefully copy dynamic link information from one symbol to the other.
2730 Secondly, the generic part of the elf linker will make .foo a dynamic
2731 symbol as is normal for most other backends. We need foo dynamic
2732 instead, at least for an application final link. However, when
2733 creating a shared library containing foo, we need to have both symbols
2734 dynamic so that references to .foo are satisfied during the early
2735 stages of linking. Otherwise the linker might decide to pull in a
2736 definition from some other object, eg. a static library.
2738 Update: As of August 2004, we support a new convention. Function
2739 calls may use the function descriptor symbol, ie. "bl foo". This
2740 behaves exactly as "bl .foo". */
2742 /* Of those relocs that might be copied as dynamic relocs, this
2743 function selects those that must be copied when linking a shared
2744 library or PIE, even when the symbol is local. */
2747 must_be_dyn_reloc (struct bfd_link_info
*info
,
2748 enum elf_ppc64_reloc_type r_type
)
2753 /* Only relative relocs can be resolved when the object load
2754 address isn't fixed. DTPREL64 is excluded because the
2755 dynamic linker needs to differentiate global dynamic from
2756 local dynamic __tls_index pairs when PPC64_OPT_TLS is set. */
2763 case R_PPC64_TOC16_DS
:
2764 case R_PPC64_TOC16_LO
:
2765 case R_PPC64_TOC16_HI
:
2766 case R_PPC64_TOC16_HA
:
2767 case R_PPC64_TOC16_LO_DS
:
2770 case R_PPC64_TPREL16
:
2771 case R_PPC64_TPREL16_LO
:
2772 case R_PPC64_TPREL16_HI
:
2773 case R_PPC64_TPREL16_HA
:
2774 case R_PPC64_TPREL16_DS
:
2775 case R_PPC64_TPREL16_LO_DS
:
2776 case R_PPC64_TPREL16_HIGH
:
2777 case R_PPC64_TPREL16_HIGHA
:
2778 case R_PPC64_TPREL16_HIGHER
:
2779 case R_PPC64_TPREL16_HIGHERA
:
2780 case R_PPC64_TPREL16_HIGHEST
:
2781 case R_PPC64_TPREL16_HIGHESTA
:
2782 case R_PPC64_TPREL64
:
2783 case R_PPC64_TPREL34
:
2784 /* These relocations are relative but in a shared library the
2785 linker doesn't know the thread pointer base. */
2786 return bfd_link_dll (info
);
2790 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
2791 copying dynamic variables from a shared lib into an app's .dynbss
2792 section, and instead use a dynamic relocation to point into the
2793 shared lib. With code that gcc generates it is vital that this be
2794 enabled; In the PowerPC64 ELFv1 ABI the address of a function is
2795 actually the address of a function descriptor which resides in the
2796 .opd section. gcc uses the descriptor directly rather than going
2797 via the GOT as some other ABIs do, which means that initialized
2798 function pointers reference the descriptor. Thus, a function
2799 pointer initialized to the address of a function in a shared
2800 library will either require a .dynbss copy and a copy reloc, or a
2801 dynamic reloc. Using a .dynbss copy redefines the function
2802 descriptor symbol to point to the copy. This presents a problem as
2803 a PLT entry for that function is also initialized from the function
2804 descriptor symbol and the copy may not be initialized first. */
2805 #define ELIMINATE_COPY_RELOCS 1
2807 /* Section name for stubs is the associated section name plus this
2809 #define STUB_SUFFIX ".stub"
2812 ppc_stub_long_branch:
2813 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
2814 destination, but a 24 bit branch in a stub section will reach.
2817 ppc_stub_plt_branch:
2818 Similar to the above, but a 24 bit branch in the stub section won't
2819 reach its destination.
2820 . addis %r11,%r2,xxx@toc@ha
2821 . ld %r12,xxx@toc@l(%r11)
2826 Used to call a function in a shared library. If it so happens that
2827 the plt entry referenced crosses a 64k boundary, then an extra
2828 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
2829 ppc_stub_plt_call_r2save starts with "std %r2,40(%r1)".
2830 . addis %r11,%r2,xxx@toc@ha
2831 . ld %r12,xxx+0@toc@l(%r11)
2833 . ld %r2,xxx+8@toc@l(%r11)
2834 . ld %r11,xxx+16@toc@l(%r11)
2837 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
2838 code to adjust the value and save r2 to support multiple toc sections.
2839 A ppc_stub_long_branch with an r2 offset looks like:
2841 . addis %r2,%r2,off@ha
2842 . addi %r2,%r2,off@l
2845 A ppc_stub_plt_branch with an r2 offset looks like:
2847 . addis %r11,%r2,xxx@toc@ha
2848 . ld %r12,xxx@toc@l(%r11)
2849 . addis %r2,%r2,off@ha
2850 . addi %r2,%r2,off@l
2854 All of the above stubs are shown as their ELFv1 variants. ELFv2
2855 variants exist too, simpler for plt calls since a new toc pointer
2856 and static chain are not loaded by the stub. In addition, ELFv2
2857 has some more complex stubs to handle calls marked with NOTOC
2858 relocs from functions where r2 is not a valid toc pointer. These
2859 come in two flavours, the ones shown below, and _both variants that
2860 start with "std %r2,24(%r1)" to save r2 in the unlikely event that
2861 one call is from a function where r2 is used as the toc pointer but
2862 needs a toc adjusting stub for small-model multi-toc, and another
2863 call is from a function where r2 is not valid.
2864 ppc_stub_long_branch_notoc:
2870 . addis %r12,%r11,dest-1b@ha
2871 . addi %r12,%r12,dest-1b@l
2874 ppc_stub_plt_branch_notoc:
2880 . lis %r12,xxx-1b@highest
2881 . ori %r12,%r12,xxx-1b@higher
2883 . oris %r12,%r12,xxx-1b@high
2884 . ori %r12,%r12,xxx-1b@l
2885 . add %r12,%r11,%r12
2889 ppc_stub_plt_call_notoc:
2895 . lis %r12,xxx-1b@highest
2896 . ori %r12,%r12,xxx-1b@higher
2898 . oris %r12,%r12,xxx-1b@high
2899 . ori %r12,%r12,xxx-1b@l
2900 . ldx %r12,%r11,%r12
2904 There are also ELFv1 powerxx variants of these stubs.
2905 ppc_stub_long_branch_notoc:
2906 . pla %r12,dest@pcrel
2908 ppc_stub_plt_branch_notoc:
2909 . lis %r11,(dest-1f)@highesta34
2910 . ori %r11,%r11,(dest-1f)@highera34
2912 . 1: pla %r12,dest@pcrel
2913 . add %r12,%r11,%r12
2916 ppc_stub_plt_call_notoc:
2917 . lis %r11,(xxx-1f)@highesta34
2918 . ori %r11,%r11,(xxx-1f)@highera34
2920 . 1: pla %r12,xxx@pcrel
2921 . ldx %r12,%r11,%r12
2925 In cases where the high instructions would add zero, they are
2926 omitted and following instructions modified in some cases.
2927 For example, a powerxx ppc_stub_plt_call_notoc might simplify down
2929 . pld %r12,xxx@pcrel
2933 For a given stub group (a set of sections all using the same toc
2934 pointer value) there will be just one stub type used for any
2935 particular function symbol. For example, if printf is called from
2936 code with the tocsave optimization (ie. r2 saved in function
2937 prologue) and therefore calls use a ppc_stub_plt_call linkage stub,
2938 and from other code without the tocsave optimization requiring a
2939 ppc_stub_plt_call_r2save linkage stub, a single stub of the latter
2940 type will be created. Calls with the tocsave optimization will
2941 enter this stub after the instruction saving r2. A similar
2942 situation exists when calls are marked with R_PPC64_REL24_NOTOC
2943 relocations. These require a ppc_stub_plt_call_notoc linkage stub
2944 to call an external function like printf. If other calls to printf
2945 require a ppc_stub_plt_call linkage stub then a single
2946 ppc_stub_plt_call_notoc linkage stub will be used for both types of
2947 call. If other calls to printf require a ppc_stub_plt_call_r2save
2948 linkage stub then a single ppc_stub_plt_call_both linkage stub will
2949 be created and calls not requiring r2 to be saved will enter the
2950 stub after the r2 save instruction. There is an analogous
2951 hierarchy of long branch and plt branch stubs for local call
2957 ppc_stub_long_branch
,
2958 ppc_stub_long_branch_r2off
,
2959 ppc_stub_long_branch_notoc
,
2960 ppc_stub_long_branch_both
, /* r2off and notoc variants both needed. */
2961 ppc_stub_plt_branch
,
2962 ppc_stub_plt_branch_r2off
,
2963 ppc_stub_plt_branch_notoc
,
2964 ppc_stub_plt_branch_both
,
2966 ppc_stub_plt_call_r2save
,
2967 ppc_stub_plt_call_notoc
,
2968 ppc_stub_plt_call_both
,
2969 ppc_stub_global_entry
,
2973 /* Information on stub grouping. */
2976 /* The stub section. */
2978 /* This is the section to which stubs in the group will be attached. */
2981 struct map_stub
*next
;
2982 /* Whether to emit a copy of register save/restore functions in this
2985 /* Current offset within stubs after the insn restoring lr in a
2986 _notoc or _both stub using bcl for pc-relative addressing, or
2987 after the insn restoring lr in a __tls_get_addr_opt plt stub. */
2988 unsigned int lr_restore
;
2989 /* Accumulated size of EH info emitted to describe return address
2990 if stubs modify lr. Does not include 17 byte FDE header. */
2991 unsigned int eh_size
;
2992 /* Offset in glink_eh_frame to the start of EH info for this group. */
2993 unsigned int eh_base
;
2996 struct ppc_stub_hash_entry
2998 /* Base hash table entry structure. */
2999 struct bfd_hash_entry root
;
3001 enum ppc_stub_type stub_type
;
3003 /* Group information. */
3004 struct map_stub
*group
;
3006 /* Offset within stub_sec of the beginning of this stub. */
3007 bfd_vma stub_offset
;
3009 /* Given the symbol's value and its section we can determine its final
3010 value when building the stubs (so the stub knows where to jump. */
3011 bfd_vma target_value
;
3012 asection
*target_section
;
3014 /* The symbol table entry, if any, that this was derived from. */
3015 struct ppc_link_hash_entry
*h
;
3016 struct plt_entry
*plt_ent
;
3019 unsigned char symtype
;
3021 /* Symbol st_other. */
3022 unsigned char other
;
3025 struct ppc_branch_hash_entry
3027 /* Base hash table entry structure. */
3028 struct bfd_hash_entry root
;
3030 /* Offset within branch lookup table. */
3031 unsigned int offset
;
3033 /* Generation marker. */
3037 /* Used to track dynamic relocations for local symbols. */
3038 struct ppc_dyn_relocs
3040 struct ppc_dyn_relocs
*next
;
3042 /* The input section of the reloc. */
3045 /* Total number of relocs copied for the input section. */
3046 unsigned int count
: 31;
3048 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3049 unsigned int ifunc
: 1;
3052 struct ppc_link_hash_entry
3054 struct elf_link_hash_entry elf
;
3058 /* A pointer to the most recently used stub hash entry against this
3060 struct ppc_stub_hash_entry
*stub_cache
;
3062 /* A pointer to the next symbol starting with a '.' */
3063 struct ppc_link_hash_entry
*next_dot_sym
;
3066 /* Track dynamic relocs copied for this symbol. */
3067 struct elf_dyn_relocs
*dyn_relocs
;
3069 /* Link between function code and descriptor symbols. */
3070 struct ppc_link_hash_entry
*oh
;
3072 /* Flag function code and descriptor symbols. */
3073 unsigned int is_func
:1;
3074 unsigned int is_func_descriptor
:1;
3075 unsigned int fake
:1;
3077 /* Whether global opd/toc sym has been adjusted or not.
3078 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3079 should be set for all globals defined in any opd/toc section. */
3080 unsigned int adjust_done
:1;
3082 /* Set if this is an out-of-line register save/restore function,
3083 with non-standard calling convention. */
3084 unsigned int save_res
:1;
3086 /* Set if a duplicate symbol with non-zero localentry is detected,
3087 even when the duplicate symbol does not provide a definition. */
3088 unsigned int non_zero_localentry
:1;
3090 /* Contexts in which symbol is used in the GOT (or TOC).
3091 Bits are or'd into the mask as the corresponding relocs are
3092 encountered during check_relocs, with TLS_TLS being set when any
3093 of the other TLS bits are set. tls_optimize clears bits when
3094 optimizing to indicate the corresponding GOT entry type is not
3095 needed. If set, TLS_TLS is never cleared. tls_optimize may also
3096 set TLS_GDIE when a GD reloc turns into an IE one.
3097 These flags are also kept for local symbols. */
3098 #define TLS_TLS 1 /* Any TLS reloc. */
3099 #define TLS_GD 2 /* GD reloc. */
3100 #define TLS_LD 4 /* LD reloc. */
3101 #define TLS_TPREL 8 /* TPREL reloc, => IE. */
3102 #define TLS_DTPREL 16 /* DTPREL reloc, => LD. */
3103 #define TLS_MARK 32 /* __tls_get_addr call marked. */
3104 #define TLS_GDIE 64 /* GOT TPREL reloc resulting from GD->IE. */
3105 #define TLS_EXPLICIT 256 /* TOC section TLS reloc, not stored. */
3106 unsigned char tls_mask
;
3108 /* The above field is also used to mark function symbols. In which
3109 case TLS_TLS will be 0. */
3110 #define PLT_IFUNC 2 /* STT_GNU_IFUNC. */
3111 #define PLT_KEEP 4 /* inline plt call requires plt entry. */
3112 #define NON_GOT 256 /* local symbol plt, not stored. */
3115 static inline struct ppc_link_hash_entry
*
3116 ppc_elf_hash_entry (struct elf_link_hash_entry
*ent
)
3118 return (struct ppc_link_hash_entry
*) ent
;
3121 /* ppc64 ELF linker hash table. */
3123 struct ppc_link_hash_table
3125 struct elf_link_hash_table elf
;
3127 /* The stub hash table. */
3128 struct bfd_hash_table stub_hash_table
;
3130 /* Another hash table for plt_branch stubs. */
3131 struct bfd_hash_table branch_hash_table
;
3133 /* Hash table for function prologue tocsave. */
3134 htab_t tocsave_htab
;
3136 /* Various options and other info passed from the linker. */
3137 struct ppc64_elf_params
*params
;
3139 /* The size of sec_info below. */
3140 unsigned int sec_info_arr_size
;
3142 /* Per-section array of extra section info. Done this way rather
3143 than as part of ppc64_elf_section_data so we have the info for
3144 non-ppc64 sections. */
3147 /* Along with elf_gp, specifies the TOC pointer used by this section. */
3152 /* The section group that this section belongs to. */
3153 struct map_stub
*group
;
3154 /* A temp section list pointer. */
3159 /* Linked list of groups. */
3160 struct map_stub
*group
;
3162 /* Temp used when calculating TOC pointers. */
3165 asection
*toc_first_sec
;
3167 /* Used when adding symbols. */
3168 struct ppc_link_hash_entry
*dot_syms
;
3170 /* Shortcuts to get to dynamic linker sections. */
3172 asection
*global_entry
;
3175 asection
*relpltlocal
;
3178 asection
*glink_eh_frame
;
3180 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
3181 struct ppc_link_hash_entry
*tls_get_addr
;
3182 struct ppc_link_hash_entry
*tls_get_addr_fd
;
3183 struct ppc_link_hash_entry
*tga_desc
;
3184 struct ppc_link_hash_entry
*tga_desc_fd
;
3186 /* The size of reliplt used by got entry relocs. */
3187 bfd_size_type got_reli_size
;
3190 unsigned long stub_count
[ppc_stub_global_entry
];
3192 /* Number of stubs against global syms. */
3193 unsigned long stub_globals
;
3195 /* Set if we're linking code with function descriptors. */
3196 unsigned int opd_abi
:1;
3198 /* Support for multiple toc sections. */
3199 unsigned int do_multi_toc
:1;
3200 unsigned int multi_toc_needed
:1;
3201 unsigned int second_toc_pass
:1;
3202 unsigned int do_toc_opt
:1;
3204 /* Set if tls optimization is enabled. */
3205 unsigned int do_tls_opt
:1;
3207 /* Set if inline plt calls should be converted to direct calls. */
3208 unsigned int can_convert_all_inline_plt
:1;
3211 unsigned int stub_error
:1;
3213 /* Whether func_desc_adjust needs to be run over symbols. */
3214 unsigned int need_func_desc_adj
:1;
3216 /* Whether there exist local gnu indirect function resolvers,
3217 referenced by dynamic relocations. */
3218 unsigned int local_ifunc_resolver
:1;
3219 unsigned int maybe_local_ifunc_resolver
:1;
3221 /* Whether plt calls for ELFv2 localentry:0 funcs have been optimized. */
3222 unsigned int has_plt_localentry0
:1;
3224 /* Whether calls are made via the PLT from NOTOC functions. */
3225 unsigned int notoc_plt
:1;
3227 /* Whether to use powerxx instructions in linkage stubs. */
3228 unsigned int powerxx_stubs
:1;
3230 /* Incremented every time we size stubs. */
3231 unsigned int stub_iteration
;
3233 /* Small local sym cache. */
3234 struct sym_cache sym_cache
;
3237 /* Rename some of the generic section flags to better document how they
3240 /* Nonzero if this section has TLS related relocations. */
3241 #define has_tls_reloc sec_flg0
3243 /* Nonzero if this section has a call to __tls_get_addr lacking marker
3245 #define nomark_tls_get_addr sec_flg1
3247 /* Nonzero if this section has any toc or got relocs. */
3248 #define has_toc_reloc sec_flg2
3250 /* Nonzero if this section has a call to another section that uses
3252 #define makes_toc_func_call sec_flg3
3254 /* Recursion protection when determining above flag. */
3255 #define call_check_in_progress sec_flg4
3256 #define call_check_done sec_flg5
3258 /* Get the ppc64 ELF linker hash table from a link_info structure. */
3260 #define ppc_hash_table(p) \
3261 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3262 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3264 #define ppc_stub_hash_lookup(table, string, create, copy) \
3265 ((struct ppc_stub_hash_entry *) \
3266 bfd_hash_lookup ((table), (string), (create), (copy)))
3268 #define ppc_branch_hash_lookup(table, string, create, copy) \
3269 ((struct ppc_branch_hash_entry *) \
3270 bfd_hash_lookup ((table), (string), (create), (copy)))
3272 /* Create an entry in the stub hash table. */
3274 static struct bfd_hash_entry
*
3275 stub_hash_newfunc (struct bfd_hash_entry
*entry
,
3276 struct bfd_hash_table
*table
,
3279 /* Allocate the structure if it has not already been allocated by a
3283 entry
= bfd_hash_allocate (table
, sizeof (struct ppc_stub_hash_entry
));
3288 /* Call the allocation method of the superclass. */
3289 entry
= bfd_hash_newfunc (entry
, table
, string
);
3292 struct ppc_stub_hash_entry
*eh
;
3294 /* Initialize the local fields. */
3295 eh
= (struct ppc_stub_hash_entry
*) entry
;
3296 eh
->stub_type
= ppc_stub_none
;
3298 eh
->stub_offset
= 0;
3299 eh
->target_value
= 0;
3300 eh
->target_section
= NULL
;
3309 /* Create an entry in the branch hash table. */
3311 static struct bfd_hash_entry
*
3312 branch_hash_newfunc (struct bfd_hash_entry
*entry
,
3313 struct bfd_hash_table
*table
,
3316 /* Allocate the structure if it has not already been allocated by a
3320 entry
= bfd_hash_allocate (table
, sizeof (struct ppc_branch_hash_entry
));
3325 /* Call the allocation method of the superclass. */
3326 entry
= bfd_hash_newfunc (entry
, table
, string
);
3329 struct ppc_branch_hash_entry
*eh
;
3331 /* Initialize the local fields. */
3332 eh
= (struct ppc_branch_hash_entry
*) entry
;
3340 /* Create an entry in a ppc64 ELF linker hash table. */
3342 static struct bfd_hash_entry
*
3343 link_hash_newfunc (struct bfd_hash_entry
*entry
,
3344 struct bfd_hash_table
*table
,
3347 /* Allocate the structure if it has not already been allocated by a
3351 entry
= bfd_hash_allocate (table
, sizeof (struct ppc_link_hash_entry
));
3356 /* Call the allocation method of the superclass. */
3357 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
3360 struct ppc_link_hash_entry
*eh
= (struct ppc_link_hash_entry
*) entry
;
3362 memset (&eh
->u
.stub_cache
, 0,
3363 (sizeof (struct ppc_link_hash_entry
)
3364 - offsetof (struct ppc_link_hash_entry
, u
.stub_cache
)));
3366 /* When making function calls, old ABI code references function entry
3367 points (dot symbols), while new ABI code references the function
3368 descriptor symbol. We need to make any combination of reference and
3369 definition work together, without breaking archive linking.
3371 For a defined function "foo" and an undefined call to "bar":
3372 An old object defines "foo" and ".foo", references ".bar" (possibly
3374 A new object defines "foo" and references "bar".
3376 A new object thus has no problem with its undefined symbols being
3377 satisfied by definitions in an old object. On the other hand, the
3378 old object won't have ".bar" satisfied by a new object.
3380 Keep a list of newly added dot-symbols. */
3382 if (string
[0] == '.')
3384 struct ppc_link_hash_table
*htab
;
3386 htab
= (struct ppc_link_hash_table
*) table
;
3387 eh
->u
.next_dot_sym
= htab
->dot_syms
;
3388 htab
->dot_syms
= eh
;
3395 struct tocsave_entry
3402 tocsave_htab_hash (const void *p
)
3404 const struct tocsave_entry
*e
= (const struct tocsave_entry
*) p
;
3405 return ((bfd_vma
) (intptr_t) e
->sec
^ e
->offset
) >> 3;
3409 tocsave_htab_eq (const void *p1
, const void *p2
)
3411 const struct tocsave_entry
*e1
= (const struct tocsave_entry
*) p1
;
3412 const struct tocsave_entry
*e2
= (const struct tocsave_entry
*) p2
;
3413 return e1
->sec
== e2
->sec
&& e1
->offset
== e2
->offset
;
3416 /* Destroy a ppc64 ELF linker hash table. */
3419 ppc64_elf_link_hash_table_free (bfd
*obfd
)
3421 struct ppc_link_hash_table
*htab
;
3423 htab
= (struct ppc_link_hash_table
*) obfd
->link
.hash
;
3424 if (htab
->tocsave_htab
)
3425 htab_delete (htab
->tocsave_htab
);
3426 bfd_hash_table_free (&htab
->branch_hash_table
);
3427 bfd_hash_table_free (&htab
->stub_hash_table
);
3428 _bfd_elf_link_hash_table_free (obfd
);
3431 /* Create a ppc64 ELF linker hash table. */
3433 static struct bfd_link_hash_table
*
3434 ppc64_elf_link_hash_table_create (bfd
*abfd
)
3436 struct ppc_link_hash_table
*htab
;
3437 bfd_size_type amt
= sizeof (struct ppc_link_hash_table
);
3439 htab
= bfd_zmalloc (amt
);
3443 if (!_bfd_elf_link_hash_table_init (&htab
->elf
, abfd
, link_hash_newfunc
,
3444 sizeof (struct ppc_link_hash_entry
),
3451 /* Init the stub hash table too. */
3452 if (!bfd_hash_table_init (&htab
->stub_hash_table
, stub_hash_newfunc
,
3453 sizeof (struct ppc_stub_hash_entry
)))
3455 _bfd_elf_link_hash_table_free (abfd
);
3459 /* And the branch hash table. */
3460 if (!bfd_hash_table_init (&htab
->branch_hash_table
, branch_hash_newfunc
,
3461 sizeof (struct ppc_branch_hash_entry
)))
3463 bfd_hash_table_free (&htab
->stub_hash_table
);
3464 _bfd_elf_link_hash_table_free (abfd
);
3468 htab
->tocsave_htab
= htab_try_create (1024,
3472 if (htab
->tocsave_htab
== NULL
)
3474 ppc64_elf_link_hash_table_free (abfd
);
3477 htab
->elf
.root
.hash_table_free
= ppc64_elf_link_hash_table_free
;
3479 /* Initializing two fields of the union is just cosmetic. We really
3480 only care about glist, but when compiled on a 32-bit host the
3481 bfd_vma fields are larger. Setting the bfd_vma to zero makes
3482 debugger inspection of these fields look nicer. */
3483 htab
->elf
.init_got_refcount
.refcount
= 0;
3484 htab
->elf
.init_got_refcount
.glist
= NULL
;
3485 htab
->elf
.init_plt_refcount
.refcount
= 0;
3486 htab
->elf
.init_plt_refcount
.glist
= NULL
;
3487 htab
->elf
.init_got_offset
.offset
= 0;
3488 htab
->elf
.init_got_offset
.glist
= NULL
;
3489 htab
->elf
.init_plt_offset
.offset
= 0;
3490 htab
->elf
.init_plt_offset
.glist
= NULL
;
3492 return &htab
->elf
.root
;
3495 /* Create sections for linker generated code. */
3498 create_linkage_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
3500 struct ppc_link_hash_table
*htab
;
3503 htab
= ppc_hash_table (info
);
3505 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_READONLY
3506 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3507 if (htab
->params
->save_restore_funcs
)
3509 /* Create .sfpr for code to save and restore fp regs. */
3510 htab
->sfpr
= bfd_make_section_anyway_with_flags (dynobj
, ".sfpr",
3512 if (htab
->sfpr
== NULL
3513 || !bfd_set_section_alignment (htab
->sfpr
, 2))
3517 if (bfd_link_relocatable (info
))
3520 /* Create .glink for lazy dynamic linking support. */
3521 htab
->glink
= bfd_make_section_anyway_with_flags (dynobj
, ".glink",
3523 if (htab
->glink
== NULL
3524 || !bfd_set_section_alignment (htab
->glink
, 3))
3527 /* The part of .glink used by global entry stubs, separate so that
3528 it can be aligned appropriately without affecting htab->glink. */
3529 htab
->global_entry
= bfd_make_section_anyway_with_flags (dynobj
, ".glink",
3531 if (htab
->global_entry
== NULL
3532 || !bfd_set_section_alignment (htab
->global_entry
, 2))
3535 if (!info
->no_ld_generated_unwind_info
)
3537 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_HAS_CONTENTS
3538 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3539 htab
->glink_eh_frame
= bfd_make_section_anyway_with_flags (dynobj
,
3542 if (htab
->glink_eh_frame
== NULL
3543 || !bfd_set_section_alignment (htab
->glink_eh_frame
, 2))
3547 flags
= SEC_ALLOC
| SEC_LINKER_CREATED
;
3548 htab
->elf
.iplt
= bfd_make_section_anyway_with_flags (dynobj
, ".iplt", flags
);
3549 if (htab
->elf
.iplt
== NULL
3550 || !bfd_set_section_alignment (htab
->elf
.iplt
, 3))
3553 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
3554 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3556 = bfd_make_section_anyway_with_flags (dynobj
, ".rela.iplt", flags
);
3557 if (htab
->elf
.irelplt
== NULL
3558 || !bfd_set_section_alignment (htab
->elf
.irelplt
, 3))
3561 /* Create branch lookup table for plt_branch stubs. */
3562 flags
= (SEC_ALLOC
| SEC_LOAD
3563 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3564 htab
->brlt
= bfd_make_section_anyway_with_flags (dynobj
, ".branch_lt",
3566 if (htab
->brlt
== NULL
3567 || !bfd_set_section_alignment (htab
->brlt
, 3))
3570 /* Local plt entries, put in .branch_lt but a separate section for
3572 htab
->pltlocal
= bfd_make_section_anyway_with_flags (dynobj
, ".branch_lt",
3574 if (htab
->pltlocal
== NULL
3575 || !bfd_set_section_alignment (htab
->pltlocal
, 3))
3578 if (!bfd_link_pic (info
))
3581 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
3582 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3584 = bfd_make_section_anyway_with_flags (dynobj
, ".rela.branch_lt", flags
);
3585 if (htab
->relbrlt
== NULL
3586 || !bfd_set_section_alignment (htab
->relbrlt
, 3))
3590 = bfd_make_section_anyway_with_flags (dynobj
, ".rela.branch_lt", flags
);
3591 if (htab
->relpltlocal
== NULL
3592 || !bfd_set_section_alignment (htab
->relpltlocal
, 3))
3598 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
3601 ppc64_elf_init_stub_bfd (struct bfd_link_info
*info
,
3602 struct ppc64_elf_params
*params
)
3604 struct ppc_link_hash_table
*htab
;
3606 elf_elfheader (params
->stub_bfd
)->e_ident
[EI_CLASS
] = ELFCLASS64
;
3608 /* Always hook our dynamic sections into the first bfd, which is the
3609 linker created stub bfd. This ensures that the GOT header is at
3610 the start of the output TOC section. */
3611 htab
= ppc_hash_table (info
);
3612 htab
->elf
.dynobj
= params
->stub_bfd
;
3613 htab
->params
= params
;
3615 return create_linkage_sections (htab
->elf
.dynobj
, info
);
3618 /* Build a name for an entry in the stub hash table. */
3621 ppc_stub_name (const asection
*input_section
,
3622 const asection
*sym_sec
,
3623 const struct ppc_link_hash_entry
*h
,
3624 const Elf_Internal_Rela
*rel
)
3629 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
3630 offsets from a sym as a branch target? In fact, we could
3631 probably assume the addend is always zero. */
3632 BFD_ASSERT (((int) rel
->r_addend
& 0xffffffff) == rel
->r_addend
);
3636 len
= 8 + 1 + strlen (h
->elf
.root
.root
.string
) + 1 + 8 + 1;
3637 stub_name
= bfd_malloc (len
);
3638 if (stub_name
== NULL
)
3641 len
= sprintf (stub_name
, "%08x.%s+%x",
3642 input_section
->id
& 0xffffffff,
3643 h
->elf
.root
.root
.string
,
3644 (int) rel
->r_addend
& 0xffffffff);
3648 len
= 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
3649 stub_name
= bfd_malloc (len
);
3650 if (stub_name
== NULL
)
3653 len
= sprintf (stub_name
, "%08x.%x:%x+%x",
3654 input_section
->id
& 0xffffffff,
3655 sym_sec
->id
& 0xffffffff,
3656 (int) ELF64_R_SYM (rel
->r_info
) & 0xffffffff,
3657 (int) rel
->r_addend
& 0xffffffff);
3659 if (len
> 2 && stub_name
[len
- 2] == '+' && stub_name
[len
- 1] == '0')
3660 stub_name
[len
- 2] = 0;
3664 /* Look up an entry in the stub hash. Stub entries are cached because
3665 creating the stub name takes a bit of time. */
3667 static struct ppc_stub_hash_entry
*
3668 ppc_get_stub_entry (const asection
*input_section
,
3669 const asection
*sym_sec
,
3670 struct ppc_link_hash_entry
*h
,
3671 const Elf_Internal_Rela
*rel
,
3672 struct ppc_link_hash_table
*htab
)
3674 struct ppc_stub_hash_entry
*stub_entry
;
3675 struct map_stub
*group
;
3677 /* If this input section is part of a group of sections sharing one
3678 stub section, then use the id of the first section in the group.
3679 Stub names need to include a section id, as there may well be
3680 more than one stub used to reach say, printf, and we need to
3681 distinguish between them. */
3682 group
= htab
->sec_info
[input_section
->id
].u
.group
;
3686 if (h
!= NULL
&& h
->u
.stub_cache
!= NULL
3687 && h
->u
.stub_cache
->h
== h
3688 && h
->u
.stub_cache
->group
== group
)
3690 stub_entry
= h
->u
.stub_cache
;
3696 stub_name
= ppc_stub_name (group
->link_sec
, sym_sec
, h
, rel
);
3697 if (stub_name
== NULL
)
3700 stub_entry
= ppc_stub_hash_lookup (&htab
->stub_hash_table
,
3701 stub_name
, FALSE
, FALSE
);
3703 h
->u
.stub_cache
= stub_entry
;
3711 /* Add a new stub entry to the stub hash. Not all fields of the new
3712 stub entry are initialised. */
3714 static struct ppc_stub_hash_entry
*
3715 ppc_add_stub (const char *stub_name
,
3717 struct bfd_link_info
*info
)
3719 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
3720 struct map_stub
*group
;
3723 struct ppc_stub_hash_entry
*stub_entry
;
3725 group
= htab
->sec_info
[section
->id
].u
.group
;
3726 link_sec
= group
->link_sec
;
3727 stub_sec
= group
->stub_sec
;
3728 if (stub_sec
== NULL
)
3734 namelen
= strlen (link_sec
->name
);
3735 len
= namelen
+ sizeof (STUB_SUFFIX
);
3736 s_name
= bfd_alloc (htab
->params
->stub_bfd
, len
);
3740 memcpy (s_name
, link_sec
->name
, namelen
);
3741 memcpy (s_name
+ namelen
, STUB_SUFFIX
, sizeof (STUB_SUFFIX
));
3742 stub_sec
= (*htab
->params
->add_stub_section
) (s_name
, link_sec
);
3743 if (stub_sec
== NULL
)
3745 group
->stub_sec
= stub_sec
;
3748 /* Enter this entry into the linker stub hash table. */
3749 stub_entry
= ppc_stub_hash_lookup (&htab
->stub_hash_table
, stub_name
,
3751 if (stub_entry
== NULL
)
3753 /* xgettext:c-format */
3754 _bfd_error_handler (_("%pB: cannot create stub entry %s"),
3755 section
->owner
, stub_name
);
3759 stub_entry
->group
= group
;
3760 stub_entry
->stub_offset
= 0;
3764 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
3765 not already done. */
3768 create_got_section (bfd
*abfd
, struct bfd_link_info
*info
)
3770 asection
*got
, *relgot
;
3772 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
3774 if (!is_ppc64_elf (abfd
))
3780 && !_bfd_elf_create_got_section (htab
->elf
.dynobj
, info
))
3783 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
3784 | SEC_LINKER_CREATED
);
3786 got
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
3788 || !bfd_set_section_alignment (got
, 3))
3791 relgot
= bfd_make_section_anyway_with_flags (abfd
, ".rela.got",
3792 flags
| SEC_READONLY
);
3794 || !bfd_set_section_alignment (relgot
, 3))
3797 ppc64_elf_tdata (abfd
)->got
= got
;
3798 ppc64_elf_tdata (abfd
)->relgot
= relgot
;
3802 /* Follow indirect and warning symbol links. */
3804 static inline struct bfd_link_hash_entry
*
3805 follow_link (struct bfd_link_hash_entry
*h
)
3807 while (h
->type
== bfd_link_hash_indirect
3808 || h
->type
== bfd_link_hash_warning
)
3813 static inline struct elf_link_hash_entry
*
3814 elf_follow_link (struct elf_link_hash_entry
*h
)
3816 return (struct elf_link_hash_entry
*) follow_link (&h
->root
);
3819 static inline struct ppc_link_hash_entry
*
3820 ppc_follow_link (struct ppc_link_hash_entry
*h
)
3822 return ppc_elf_hash_entry (elf_follow_link (&h
->elf
));
3825 /* Merge PLT info on FROM with that on TO. */
3828 move_plt_plist (struct ppc_link_hash_entry
*from
,
3829 struct ppc_link_hash_entry
*to
)
3831 if (from
->elf
.plt
.plist
!= NULL
)
3833 if (to
->elf
.plt
.plist
!= NULL
)
3835 struct plt_entry
**entp
;
3836 struct plt_entry
*ent
;
3838 for (entp
= &from
->elf
.plt
.plist
; (ent
= *entp
) != NULL
; )
3840 struct plt_entry
*dent
;
3842 for (dent
= to
->elf
.plt
.plist
; dent
!= NULL
; dent
= dent
->next
)
3843 if (dent
->addend
== ent
->addend
)
3845 dent
->plt
.refcount
+= ent
->plt
.refcount
;
3852 *entp
= to
->elf
.plt
.plist
;
3855 to
->elf
.plt
.plist
= from
->elf
.plt
.plist
;
3856 from
->elf
.plt
.plist
= NULL
;
3860 /* Copy the extra info we tack onto an elf_link_hash_entry. */
3863 ppc64_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
3864 struct elf_link_hash_entry
*dir
,
3865 struct elf_link_hash_entry
*ind
)
3867 struct ppc_link_hash_entry
*edir
, *eind
;
3869 edir
= ppc_elf_hash_entry (dir
);
3870 eind
= ppc_elf_hash_entry (ind
);
3872 edir
->is_func
|= eind
->is_func
;
3873 edir
->is_func_descriptor
|= eind
->is_func_descriptor
;
3874 edir
->tls_mask
|= eind
->tls_mask
;
3875 if (eind
->oh
!= NULL
)
3876 edir
->oh
= ppc_follow_link (eind
->oh
);
3878 if (edir
->elf
.versioned
!= versioned_hidden
)
3879 edir
->elf
.ref_dynamic
|= eind
->elf
.ref_dynamic
;
3880 edir
->elf
.ref_regular
|= eind
->elf
.ref_regular
;
3881 edir
->elf
.ref_regular_nonweak
|= eind
->elf
.ref_regular_nonweak
;
3882 edir
->elf
.non_got_ref
|= eind
->elf
.non_got_ref
;
3883 edir
->elf
.needs_plt
|= eind
->elf
.needs_plt
;
3884 edir
->elf
.pointer_equality_needed
|= eind
->elf
.pointer_equality_needed
;
3886 /* If we were called to copy over info for a weak sym, don't copy
3887 dyn_relocs, plt/got info, or dynindx. We used to copy dyn_relocs
3888 in order to simplify readonly_dynrelocs and save a field in the
3889 symbol hash entry, but that means dyn_relocs can't be used in any
3890 tests about a specific symbol, or affect other symbol flags which
3892 if (eind
->elf
.root
.type
!= bfd_link_hash_indirect
)
3895 /* Copy over any dynamic relocs we may have on the indirect sym. */
3896 if (eind
->dyn_relocs
!= NULL
)
3898 if (edir
->dyn_relocs
!= NULL
)
3900 struct elf_dyn_relocs
**pp
;
3901 struct elf_dyn_relocs
*p
;
3903 /* Add reloc counts against the indirect sym to the direct sym
3904 list. Merge any entries against the same section. */
3905 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
3907 struct elf_dyn_relocs
*q
;
3909 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
3910 if (q
->sec
== p
->sec
)
3912 q
->pc_count
+= p
->pc_count
;
3913 q
->count
+= p
->count
;
3920 *pp
= edir
->dyn_relocs
;
3923 edir
->dyn_relocs
= eind
->dyn_relocs
;
3924 eind
->dyn_relocs
= NULL
;
3927 /* Copy over got entries that we may have already seen to the
3928 symbol which just became indirect. */
3929 if (eind
->elf
.got
.glist
!= NULL
)
3931 if (edir
->elf
.got
.glist
!= NULL
)
3933 struct got_entry
**entp
;
3934 struct got_entry
*ent
;
3936 for (entp
= &eind
->elf
.got
.glist
; (ent
= *entp
) != NULL
; )
3938 struct got_entry
*dent
;
3940 for (dent
= edir
->elf
.got
.glist
; dent
!= NULL
; dent
= dent
->next
)
3941 if (dent
->addend
== ent
->addend
3942 && dent
->owner
== ent
->owner
3943 && dent
->tls_type
== ent
->tls_type
)
3945 dent
->got
.refcount
+= ent
->got
.refcount
;
3952 *entp
= edir
->elf
.got
.glist
;
3955 edir
->elf
.got
.glist
= eind
->elf
.got
.glist
;
3956 eind
->elf
.got
.glist
= NULL
;
3959 /* And plt entries. */
3960 move_plt_plist (eind
, edir
);
3962 if (eind
->elf
.dynindx
!= -1)
3964 if (edir
->elf
.dynindx
!= -1)
3965 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
3966 edir
->elf
.dynstr_index
);
3967 edir
->elf
.dynindx
= eind
->elf
.dynindx
;
3968 edir
->elf
.dynstr_index
= eind
->elf
.dynstr_index
;
3969 eind
->elf
.dynindx
= -1;
3970 eind
->elf
.dynstr_index
= 0;
3974 /* Find the function descriptor hash entry from the given function code
3975 hash entry FH. Link the entries via their OH fields. */
3977 static struct ppc_link_hash_entry
*
3978 lookup_fdh (struct ppc_link_hash_entry
*fh
, struct ppc_link_hash_table
*htab
)
3980 struct ppc_link_hash_entry
*fdh
= fh
->oh
;
3984 const char *fd_name
= fh
->elf
.root
.root
.string
+ 1;
3986 fdh
= ppc_elf_hash_entry (elf_link_hash_lookup (&htab
->elf
, fd_name
,
3987 FALSE
, FALSE
, FALSE
));
3991 fdh
->is_func_descriptor
= 1;
3997 fdh
= ppc_follow_link (fdh
);
3998 fdh
->is_func_descriptor
= 1;
4003 /* Make a fake function descriptor sym for the undefined code sym FH. */
4005 static struct ppc_link_hash_entry
*
4006 make_fdh (struct bfd_link_info
*info
,
4007 struct ppc_link_hash_entry
*fh
)
4009 bfd
*abfd
= fh
->elf
.root
.u
.undef
.abfd
;
4010 struct bfd_link_hash_entry
*bh
= NULL
;
4011 struct ppc_link_hash_entry
*fdh
;
4012 flagword flags
= (fh
->elf
.root
.type
== bfd_link_hash_undefweak
4016 if (!_bfd_generic_link_add_one_symbol (info
, abfd
,
4017 fh
->elf
.root
.root
.string
+ 1,
4018 flags
, bfd_und_section_ptr
, 0,
4019 NULL
, FALSE
, FALSE
, &bh
))
4022 fdh
= (struct ppc_link_hash_entry
*) bh
;
4023 fdh
->elf
.non_elf
= 0;
4025 fdh
->is_func_descriptor
= 1;
4032 /* Fix function descriptor symbols defined in .opd sections to be
4036 ppc64_elf_add_symbol_hook (bfd
*ibfd
,
4037 struct bfd_link_info
*info
,
4038 Elf_Internal_Sym
*isym
,
4040 flagword
*flags ATTRIBUTE_UNUSED
,
4045 && strcmp ((*sec
)->name
, ".opd") == 0)
4049 if (!(ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
4050 || ELF_ST_TYPE (isym
->st_info
) == STT_FUNC
))
4051 isym
->st_info
= ELF_ST_INFO (ELF_ST_BIND (isym
->st_info
), STT_FUNC
);
4053 /* If the symbol is a function defined in .opd, and the function
4054 code is in a discarded group, let it appear to be undefined. */
4055 if (!bfd_link_relocatable (info
)
4056 && (*sec
)->reloc_count
!= 0
4057 && opd_entry_value (*sec
, *value
, &code_sec
, NULL
,
4058 FALSE
) != (bfd_vma
) -1
4059 && discarded_section (code_sec
))
4061 *sec
= bfd_und_section_ptr
;
4062 isym
->st_shndx
= SHN_UNDEF
;
4065 else if (*sec
!= NULL
4066 && strcmp ((*sec
)->name
, ".toc") == 0
4067 && ELF_ST_TYPE (isym
->st_info
) == STT_OBJECT
)
4069 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
4071 htab
->params
->object_in_toc
= 1;
4074 if ((STO_PPC64_LOCAL_MASK
& isym
->st_other
) != 0)
4076 if (abiversion (ibfd
) == 0)
4077 set_abiversion (ibfd
, 2);
4078 else if (abiversion (ibfd
) == 1)
4080 _bfd_error_handler (_("symbol '%s' has invalid st_other"
4081 " for ABI version 1"), *name
);
4082 bfd_set_error (bfd_error_bad_value
);
4090 /* Merge non-visibility st_other attributes: local entry point. */
4093 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry
*h
,
4094 const Elf_Internal_Sym
*isym
,
4095 bfd_boolean definition
,
4096 bfd_boolean dynamic
)
4098 if (definition
&& (!dynamic
|| !h
->def_regular
))
4099 h
->other
= ((isym
->st_other
& ~ELF_ST_VISIBILITY (-1))
4100 | ELF_ST_VISIBILITY (h
->other
));
4103 /* Hook called on merging a symbol. We use this to clear "fake" since
4104 we now have a real symbol. */
4107 ppc64_elf_merge_symbol (struct elf_link_hash_entry
*h
,
4108 const Elf_Internal_Sym
*isym
,
4109 asection
**psec ATTRIBUTE_UNUSED
,
4110 bfd_boolean newdef ATTRIBUTE_UNUSED
,
4111 bfd_boolean olddef ATTRIBUTE_UNUSED
,
4112 bfd
*oldbfd ATTRIBUTE_UNUSED
,
4113 const asection
*oldsec ATTRIBUTE_UNUSED
)
4115 ppc_elf_hash_entry (h
)->fake
= 0;
4116 if ((STO_PPC64_LOCAL_MASK
& isym
->st_other
) != 0)
4117 ppc_elf_hash_entry (h
)->non_zero_localentry
= 1;
4121 /* This function makes an old ABI object reference to ".bar" cause the
4122 inclusion of a new ABI object archive that defines "bar".
4123 NAME is a symbol defined in an archive. Return a symbol in the hash
4124 table that might be satisfied by the archive symbols. */
4126 static struct elf_link_hash_entry
*
4127 ppc64_elf_archive_symbol_lookup (bfd
*abfd
,
4128 struct bfd_link_info
*info
,
4131 struct elf_link_hash_entry
*h
;
4135 h
= _bfd_elf_archive_symbol_lookup (abfd
, info
, name
);
4137 /* Don't return this sym if it is a fake function descriptor
4138 created by add_symbol_adjust. */
4139 && !ppc_elf_hash_entry (h
)->fake
)
4145 len
= strlen (name
);
4146 dot_name
= bfd_alloc (abfd
, len
+ 2);
4147 if (dot_name
== NULL
)
4148 return (struct elf_link_hash_entry
*) -1;
4150 memcpy (dot_name
+ 1, name
, len
+ 1);
4151 h
= _bfd_elf_archive_symbol_lookup (abfd
, info
, dot_name
);
4152 bfd_release (abfd
, dot_name
);
4156 /* This function satisfies all old ABI object references to ".bar" if a
4157 new ABI object defines "bar". Well, at least, undefined dot symbols
4158 are made weak. This stops later archive searches from including an
4159 object if we already have a function descriptor definition. It also
4160 prevents the linker complaining about undefined symbols.
4161 We also check and correct mismatched symbol visibility here. The
4162 most restrictive visibility of the function descriptor and the
4163 function entry symbol is used. */
4166 add_symbol_adjust (struct ppc_link_hash_entry
*eh
, struct bfd_link_info
*info
)
4168 struct ppc_link_hash_table
*htab
;
4169 struct ppc_link_hash_entry
*fdh
;
4171 if (eh
->elf
.root
.type
== bfd_link_hash_warning
)
4172 eh
= (struct ppc_link_hash_entry
*) eh
->elf
.root
.u
.i
.link
;
4174 if (eh
->elf
.root
.type
== bfd_link_hash_indirect
)
4177 if (eh
->elf
.root
.root
.string
[0] != '.')
4180 htab
= ppc_hash_table (info
);
4184 fdh
= lookup_fdh (eh
, htab
);
4186 && !bfd_link_relocatable (info
)
4187 && (eh
->elf
.root
.type
== bfd_link_hash_undefined
4188 || eh
->elf
.root
.type
== bfd_link_hash_undefweak
)
4189 && eh
->elf
.ref_regular
)
4191 /* Make an undefined function descriptor sym, in order to
4192 pull in an --as-needed shared lib. Archives are handled
4194 fdh
= make_fdh (info
, eh
);
4201 unsigned entry_vis
= ELF_ST_VISIBILITY (eh
->elf
.other
) - 1;
4202 unsigned descr_vis
= ELF_ST_VISIBILITY (fdh
->elf
.other
) - 1;
4204 /* Make both descriptor and entry symbol have the most
4205 constraining visibility of either symbol. */
4206 if (entry_vis
< descr_vis
)
4207 fdh
->elf
.other
+= entry_vis
- descr_vis
;
4208 else if (entry_vis
> descr_vis
)
4209 eh
->elf
.other
+= descr_vis
- entry_vis
;
4211 /* Propagate reference flags from entry symbol to function
4212 descriptor symbol. */
4213 fdh
->elf
.root
.non_ir_ref_regular
|= eh
->elf
.root
.non_ir_ref_regular
;
4214 fdh
->elf
.root
.non_ir_ref_dynamic
|= eh
->elf
.root
.non_ir_ref_dynamic
;
4215 fdh
->elf
.ref_regular
|= eh
->elf
.ref_regular
;
4216 fdh
->elf
.ref_regular_nonweak
|= eh
->elf
.ref_regular_nonweak
;
4218 if (!fdh
->elf
.forced_local
4219 && fdh
->elf
.dynindx
== -1
4220 && fdh
->elf
.versioned
!= versioned_hidden
4221 && (bfd_link_dll (info
)
4222 || fdh
->elf
.def_dynamic
4223 || fdh
->elf
.ref_dynamic
)
4224 && (eh
->elf
.ref_regular
4225 || eh
->elf
.def_regular
))
4227 if (!bfd_elf_link_record_dynamic_symbol (info
, &fdh
->elf
))
4235 /* Set up opd section info and abiversion for IBFD, and process list
4236 of dot-symbols we made in link_hash_newfunc. */
4239 ppc64_elf_before_check_relocs (bfd
*ibfd
, struct bfd_link_info
*info
)
4241 struct ppc_link_hash_table
*htab
;
4242 struct ppc_link_hash_entry
**p
, *eh
;
4243 asection
*opd
= bfd_get_section_by_name (ibfd
, ".opd");
4245 if (opd
!= NULL
&& opd
->size
!= 0)
4247 BFD_ASSERT (ppc64_elf_section_data (opd
)->sec_type
== sec_normal
);
4248 ppc64_elf_section_data (opd
)->sec_type
= sec_opd
;
4250 if (abiversion (ibfd
) == 0)
4251 set_abiversion (ibfd
, 1);
4252 else if (abiversion (ibfd
) >= 2)
4254 /* xgettext:c-format */
4255 _bfd_error_handler (_("%pB .opd not allowed in ABI version %d"),
4256 ibfd
, abiversion (ibfd
));
4257 bfd_set_error (bfd_error_bad_value
);
4262 if (is_ppc64_elf (info
->output_bfd
))
4264 /* For input files without an explicit abiversion in e_flags
4265 we should have flagged any with symbol st_other bits set
4266 as ELFv1 and above flagged those with .opd as ELFv2.
4267 Set the output abiversion if not yet set, and for any input
4268 still ambiguous, take its abiversion from the output.
4269 Differences in ABI are reported later. */
4270 if (abiversion (info
->output_bfd
) == 0)
4271 set_abiversion (info
->output_bfd
, abiversion (ibfd
));
4272 else if (abiversion (ibfd
) == 0)
4273 set_abiversion (ibfd
, abiversion (info
->output_bfd
));
4276 htab
= ppc_hash_table (info
);
4280 if (opd
!= NULL
&& opd
->size
!= 0
4281 && (ibfd
->flags
& DYNAMIC
) == 0
4282 && (opd
->flags
& SEC_RELOC
) != 0
4283 && opd
->reloc_count
!= 0
4284 && !bfd_is_abs_section (opd
->output_section
)
4285 && info
->gc_sections
)
4287 /* Garbage collection needs some extra help with .opd sections.
4288 We don't want to necessarily keep everything referenced by
4289 relocs in .opd, as that would keep all functions. Instead,
4290 if we reference an .opd symbol (a function descriptor), we
4291 want to keep the function code symbol's section. This is
4292 easy for global symbols, but for local syms we need to keep
4293 information about the associated function section. */
4295 asection
**opd_sym_map
;
4296 Elf_Internal_Shdr
*symtab_hdr
;
4297 Elf_Internal_Rela
*relocs
, *rel_end
, *rel
;
4299 amt
= OPD_NDX (opd
->size
) * sizeof (*opd_sym_map
);
4300 opd_sym_map
= bfd_zalloc (ibfd
, amt
);
4301 if (opd_sym_map
== NULL
)
4303 ppc64_elf_section_data (opd
)->u
.opd
.func_sec
= opd_sym_map
;
4304 relocs
= _bfd_elf_link_read_relocs (ibfd
, opd
, NULL
, NULL
,
4308 symtab_hdr
= &elf_symtab_hdr (ibfd
);
4309 rel_end
= relocs
+ opd
->reloc_count
- 1;
4310 for (rel
= relocs
; rel
< rel_end
; rel
++)
4312 enum elf_ppc64_reloc_type r_type
= ELF64_R_TYPE (rel
->r_info
);
4313 unsigned long r_symndx
= ELF64_R_SYM (rel
->r_info
);
4315 if (r_type
== R_PPC64_ADDR64
4316 && ELF64_R_TYPE ((rel
+ 1)->r_info
) == R_PPC64_TOC
4317 && r_symndx
< symtab_hdr
->sh_info
)
4319 Elf_Internal_Sym
*isym
;
4322 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
, ibfd
, r_symndx
);
4325 if (elf_section_data (opd
)->relocs
!= relocs
)
4330 s
= bfd_section_from_elf_index (ibfd
, isym
->st_shndx
);
4331 if (s
!= NULL
&& s
!= opd
)
4332 opd_sym_map
[OPD_NDX (rel
->r_offset
)] = s
;
4335 if (elf_section_data (opd
)->relocs
!= relocs
)
4339 p
= &htab
->dot_syms
;
4340 while ((eh
= *p
) != NULL
)
4343 if (&eh
->elf
== htab
->elf
.hgot
)
4345 else if (htab
->elf
.hgot
== NULL
4346 && strcmp (eh
->elf
.root
.root
.string
, ".TOC.") == 0)
4347 htab
->elf
.hgot
= &eh
->elf
;
4348 else if (abiversion (ibfd
) <= 1)
4350 htab
->need_func_desc_adj
= 1;
4351 if (!add_symbol_adjust (eh
, info
))
4354 p
= &eh
->u
.next_dot_sym
;
4359 /* Undo hash table changes when an --as-needed input file is determined
4360 not to be needed. */
4363 ppc64_elf_notice_as_needed (bfd
*ibfd
,
4364 struct bfd_link_info
*info
,
4365 enum notice_asneeded_action act
)
4367 if (act
== notice_not_needed
)
4369 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
4374 htab
->dot_syms
= NULL
;
4376 return _bfd_elf_notice_as_needed (ibfd
, info
, act
);
4379 /* If --just-symbols against a final linked binary, then assume we need
4380 toc adjusting stubs when calling functions defined there. */
4383 ppc64_elf_link_just_syms (asection
*sec
, struct bfd_link_info
*info
)
4385 if ((sec
->flags
& SEC_CODE
) != 0
4386 && (sec
->owner
->flags
& (EXEC_P
| DYNAMIC
)) != 0
4387 && is_ppc64_elf (sec
->owner
))
4389 if (abiversion (sec
->owner
) >= 2
4390 || bfd_get_section_by_name (sec
->owner
, ".opd") != NULL
)
4391 sec
->has_toc_reloc
= 1;
4393 _bfd_elf_link_just_syms (sec
, info
);
4396 static struct plt_entry
**
4397 update_local_sym_info (bfd
*abfd
, Elf_Internal_Shdr
*symtab_hdr
,
4398 unsigned long r_symndx
, bfd_vma r_addend
, int tls_type
)
4400 struct got_entry
**local_got_ents
= elf_local_got_ents (abfd
);
4401 struct plt_entry
**local_plt
;
4402 unsigned char *local_got_tls_masks
;
4404 if (local_got_ents
== NULL
)
4406 bfd_size_type size
= symtab_hdr
->sh_info
;
4408 size
*= (sizeof (*local_got_ents
)
4409 + sizeof (*local_plt
)
4410 + sizeof (*local_got_tls_masks
));
4411 local_got_ents
= bfd_zalloc (abfd
, size
);
4412 if (local_got_ents
== NULL
)
4414 elf_local_got_ents (abfd
) = local_got_ents
;
4417 if ((tls_type
& (NON_GOT
| TLS_EXPLICIT
)) == 0)
4419 struct got_entry
*ent
;
4421 for (ent
= local_got_ents
[r_symndx
]; ent
!= NULL
; ent
= ent
->next
)
4422 if (ent
->addend
== r_addend
4423 && ent
->owner
== abfd
4424 && ent
->tls_type
== tls_type
)
4428 bfd_size_type amt
= sizeof (*ent
);
4429 ent
= bfd_alloc (abfd
, amt
);
4432 ent
->next
= local_got_ents
[r_symndx
];
4433 ent
->addend
= r_addend
;
4435 ent
->tls_type
= tls_type
;
4436 ent
->is_indirect
= FALSE
;
4437 ent
->got
.refcount
= 0;
4438 local_got_ents
[r_symndx
] = ent
;
4440 ent
->got
.refcount
+= 1;
4443 local_plt
= (struct plt_entry
**) (local_got_ents
+ symtab_hdr
->sh_info
);
4444 local_got_tls_masks
= (unsigned char *) (local_plt
+ symtab_hdr
->sh_info
);
4445 local_got_tls_masks
[r_symndx
] |= tls_type
& 0xff;
4447 return local_plt
+ r_symndx
;
4451 update_plt_info (bfd
*abfd
, struct plt_entry
**plist
, bfd_vma addend
)
4453 struct plt_entry
*ent
;
4455 for (ent
= *plist
; ent
!= NULL
; ent
= ent
->next
)
4456 if (ent
->addend
== addend
)
4460 bfd_size_type amt
= sizeof (*ent
);
4461 ent
= bfd_alloc (abfd
, amt
);
4465 ent
->addend
= addend
;
4466 ent
->plt
.refcount
= 0;
4469 ent
->plt
.refcount
+= 1;
4474 is_branch_reloc (enum elf_ppc64_reloc_type r_type
)
4476 return (r_type
== R_PPC64_REL24
4477 || r_type
== R_PPC64_REL24_NOTOC
4478 || r_type
== R_PPC64_REL14
4479 || r_type
== R_PPC64_REL14_BRTAKEN
4480 || r_type
== R_PPC64_REL14_BRNTAKEN
4481 || r_type
== R_PPC64_ADDR24
4482 || r_type
== R_PPC64_ADDR14
4483 || r_type
== R_PPC64_ADDR14_BRTAKEN
4484 || r_type
== R_PPC64_ADDR14_BRNTAKEN
4485 || r_type
== R_PPC64_PLTCALL
4486 || r_type
== R_PPC64_PLTCALL_NOTOC
);
4489 /* Relocs on inline plt call sequence insns prior to the call. */
4492 is_plt_seq_reloc (enum elf_ppc64_reloc_type r_type
)
4494 return (r_type
== R_PPC64_PLT16_HA
4495 || r_type
== R_PPC64_PLT16_HI
4496 || r_type
== R_PPC64_PLT16_LO
4497 || r_type
== R_PPC64_PLT16_LO_DS
4498 || r_type
== R_PPC64_PLT_PCREL34
4499 || r_type
== R_PPC64_PLT_PCREL34_NOTOC
4500 || r_type
== R_PPC64_PLTSEQ
4501 || r_type
== R_PPC64_PLTSEQ_NOTOC
);
4504 /* Look through the relocs for a section during the first phase, and
4505 calculate needed space in the global offset table, procedure
4506 linkage table, and dynamic reloc sections. */
4509 ppc64_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
4510 asection
*sec
, const Elf_Internal_Rela
*relocs
)
4512 struct ppc_link_hash_table
*htab
;
4513 Elf_Internal_Shdr
*symtab_hdr
;
4514 struct elf_link_hash_entry
**sym_hashes
;
4515 const Elf_Internal_Rela
*rel
;
4516 const Elf_Internal_Rela
*rel_end
;
4518 struct elf_link_hash_entry
*tga
, *dottga
;
4521 if (bfd_link_relocatable (info
))
4524 /* Don't do anything special with non-loaded, non-alloced sections.
4525 In particular, any relocs in such sections should not affect GOT
4526 and PLT reference counting (ie. we don't allow them to create GOT
4527 or PLT entries), there's no possibility or desire to optimize TLS
4528 relocs, and there's not much point in propagating relocs to shared
4529 libs that the dynamic linker won't relocate. */
4530 if ((sec
->flags
& SEC_ALLOC
) == 0)
4533 BFD_ASSERT (is_ppc64_elf (abfd
));
4535 htab
= ppc_hash_table (info
);
4539 tga
= elf_link_hash_lookup (&htab
->elf
, "__tls_get_addr",
4540 FALSE
, FALSE
, TRUE
);
4541 dottga
= elf_link_hash_lookup (&htab
->elf
, ".__tls_get_addr",
4542 FALSE
, FALSE
, TRUE
);
4543 symtab_hdr
= &elf_symtab_hdr (abfd
);
4544 sym_hashes
= elf_sym_hashes (abfd
);
4546 is_opd
= ppc64_elf_section_data (sec
)->sec_type
== sec_opd
;
4547 rel_end
= relocs
+ sec
->reloc_count
;
4548 for (rel
= relocs
; rel
< rel_end
; rel
++)
4550 unsigned long r_symndx
;
4551 struct elf_link_hash_entry
*h
;
4552 enum elf_ppc64_reloc_type r_type
;
4554 struct _ppc64_elf_section_data
*ppc64_sec
;
4555 struct plt_entry
**ifunc
, **plt_list
;
4557 r_symndx
= ELF64_R_SYM (rel
->r_info
);
4558 if (r_symndx
< symtab_hdr
->sh_info
)
4562 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
4563 h
= elf_follow_link (h
);
4565 if (h
== htab
->elf
.hgot
)
4566 sec
->has_toc_reloc
= 1;
4569 r_type
= ELF64_R_TYPE (rel
->r_info
);
4573 case R_PPC64_D34_LO
:
4574 case R_PPC64_D34_HI30
:
4575 case R_PPC64_D34_HA30
:
4577 case R_PPC64_TPREL34
:
4578 case R_PPC64_DTPREL34
:
4579 case R_PPC64_PCREL34
:
4580 case R_PPC64_GOT_PCREL34
:
4581 case R_PPC64_GOT_TLSGD34
:
4582 case R_PPC64_GOT_TLSLD34
:
4583 case R_PPC64_GOT_TPREL34
:
4584 case R_PPC64_GOT_DTPREL34
:
4585 case R_PPC64_PLT_PCREL34
:
4586 case R_PPC64_PLT_PCREL34_NOTOC
:
4587 case R_PPC64_PCREL28
:
4588 htab
->powerxx_stubs
= 1;
4596 case R_PPC64_PLT16_HA
:
4597 case R_PPC64_GOT_TLSLD16_HA
:
4598 case R_PPC64_GOT_TLSGD16_HA
:
4599 case R_PPC64_GOT_TPREL16_HA
:
4600 case R_PPC64_GOT_DTPREL16_HA
:
4601 case R_PPC64_GOT16_HA
:
4602 case R_PPC64_TOC16_HA
:
4603 case R_PPC64_PLT16_LO
:
4604 case R_PPC64_PLT16_LO_DS
:
4605 case R_PPC64_GOT_TLSLD16_LO
:
4606 case R_PPC64_GOT_TLSGD16_LO
:
4607 case R_PPC64_GOT_TPREL16_LO_DS
:
4608 case R_PPC64_GOT_DTPREL16_LO_DS
:
4609 case R_PPC64_GOT16_LO
:
4610 case R_PPC64_GOT16_LO_DS
:
4611 case R_PPC64_TOC16_LO
:
4612 case R_PPC64_TOC16_LO_DS
:
4613 case R_PPC64_GOT_PCREL34
:
4614 ppc64_elf_tdata (abfd
)->has_optrel
= 1;
4615 ppc64_elf_section_data (sec
)->has_optrel
= 1;
4624 if (h
->type
== STT_GNU_IFUNC
)
4627 ifunc
= &h
->plt
.plist
;
4632 Elf_Internal_Sym
*isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
4637 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
4639 ifunc
= update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4641 NON_GOT
| PLT_IFUNC
);
4652 /* These special tls relocs tie a call to __tls_get_addr with
4653 its parameter symbol. */
4655 ppc_elf_hash_entry (h
)->tls_mask
|= TLS_TLS
| TLS_MARK
;
4657 if (!update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4659 NON_GOT
| TLS_TLS
| TLS_MARK
))
4661 sec
->has_tls_reloc
= 1;
4664 case R_PPC64_GOT_TLSLD16
:
4665 case R_PPC64_GOT_TLSLD16_LO
:
4666 case R_PPC64_GOT_TLSLD16_HI
:
4667 case R_PPC64_GOT_TLSLD16_HA
:
4668 case R_PPC64_GOT_TLSLD34
:
4669 tls_type
= TLS_TLS
| TLS_LD
;
4672 case R_PPC64_GOT_TLSGD16
:
4673 case R_PPC64_GOT_TLSGD16_LO
:
4674 case R_PPC64_GOT_TLSGD16_HI
:
4675 case R_PPC64_GOT_TLSGD16_HA
:
4676 case R_PPC64_GOT_TLSGD34
:
4677 tls_type
= TLS_TLS
| TLS_GD
;
4680 case R_PPC64_GOT_TPREL16_DS
:
4681 case R_PPC64_GOT_TPREL16_LO_DS
:
4682 case R_PPC64_GOT_TPREL16_HI
:
4683 case R_PPC64_GOT_TPREL16_HA
:
4684 case R_PPC64_GOT_TPREL34
:
4685 if (bfd_link_dll (info
))
4686 info
->flags
|= DF_STATIC_TLS
;
4687 tls_type
= TLS_TLS
| TLS_TPREL
;
4690 case R_PPC64_GOT_DTPREL16_DS
:
4691 case R_PPC64_GOT_DTPREL16_LO_DS
:
4692 case R_PPC64_GOT_DTPREL16_HI
:
4693 case R_PPC64_GOT_DTPREL16_HA
:
4694 case R_PPC64_GOT_DTPREL34
:
4695 tls_type
= TLS_TLS
| TLS_DTPREL
;
4697 sec
->has_tls_reloc
= 1;
4701 case R_PPC64_GOT16_LO
:
4702 case R_PPC64_GOT16_HI
:
4703 case R_PPC64_GOT16_HA
:
4704 case R_PPC64_GOT16_DS
:
4705 case R_PPC64_GOT16_LO_DS
:
4706 case R_PPC64_GOT_PCREL34
:
4708 /* This symbol requires a global offset table entry. */
4709 sec
->has_toc_reloc
= 1;
4710 if (r_type
== R_PPC64_GOT_TLSLD16
4711 || r_type
== R_PPC64_GOT_TLSGD16
4712 || r_type
== R_PPC64_GOT_TPREL16_DS
4713 || r_type
== R_PPC64_GOT_DTPREL16_DS
4714 || r_type
== R_PPC64_GOT16
4715 || r_type
== R_PPC64_GOT16_DS
)
4717 htab
->do_multi_toc
= 1;
4718 ppc64_elf_tdata (abfd
)->has_small_toc_reloc
= 1;
4721 if (ppc64_elf_tdata (abfd
)->got
== NULL
4722 && !create_got_section (abfd
, info
))
4727 struct ppc_link_hash_entry
*eh
;
4728 struct got_entry
*ent
;
4730 eh
= ppc_elf_hash_entry (h
);
4731 for (ent
= eh
->elf
.got
.glist
; ent
!= NULL
; ent
= ent
->next
)
4732 if (ent
->addend
== rel
->r_addend
4733 && ent
->owner
== abfd
4734 && ent
->tls_type
== tls_type
)
4738 bfd_size_type amt
= sizeof (*ent
);
4739 ent
= bfd_alloc (abfd
, amt
);
4742 ent
->next
= eh
->elf
.got
.glist
;
4743 ent
->addend
= rel
->r_addend
;
4745 ent
->tls_type
= tls_type
;
4746 ent
->is_indirect
= FALSE
;
4747 ent
->got
.refcount
= 0;
4748 eh
->elf
.got
.glist
= ent
;
4750 ent
->got
.refcount
+= 1;
4751 eh
->tls_mask
|= tls_type
;
4754 /* This is a global offset table entry for a local symbol. */
4755 if (!update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4756 rel
->r_addend
, tls_type
))
4759 /* We may also need a plt entry if the symbol turns out to be
4761 if (h
!= NULL
&& !bfd_link_pic (info
) && abiversion (abfd
) != 1)
4763 if (!update_plt_info (abfd
, &h
->plt
.plist
, rel
->r_addend
))
4768 case R_PPC64_PLT16_HA
:
4769 case R_PPC64_PLT16_HI
:
4770 case R_PPC64_PLT16_LO
:
4771 case R_PPC64_PLT16_LO_DS
:
4772 case R_PPC64_PLT_PCREL34
:
4773 case R_PPC64_PLT_PCREL34_NOTOC
:
4776 /* This symbol requires a procedure linkage table entry. */
4781 if (h
->root
.root
.string
[0] == '.'
4782 && h
->root
.root
.string
[1] != '\0')
4783 ppc_elf_hash_entry (h
)->is_func
= 1;
4784 ppc_elf_hash_entry (h
)->tls_mask
|= PLT_KEEP
;
4785 plt_list
= &h
->plt
.plist
;
4787 if (plt_list
== NULL
)
4788 plt_list
= update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4790 NON_GOT
| PLT_KEEP
);
4791 if (!update_plt_info (abfd
, plt_list
, rel
->r_addend
))
4795 /* The following relocations don't need to propagate the
4796 relocation if linking a shared object since they are
4797 section relative. */
4798 case R_PPC64_SECTOFF
:
4799 case R_PPC64_SECTOFF_LO
:
4800 case R_PPC64_SECTOFF_HI
:
4801 case R_PPC64_SECTOFF_HA
:
4802 case R_PPC64_SECTOFF_DS
:
4803 case R_PPC64_SECTOFF_LO_DS
:
4804 case R_PPC64_DTPREL16
:
4805 case R_PPC64_DTPREL16_LO
:
4806 case R_PPC64_DTPREL16_HI
:
4807 case R_PPC64_DTPREL16_HA
:
4808 case R_PPC64_DTPREL16_DS
:
4809 case R_PPC64_DTPREL16_LO_DS
:
4810 case R_PPC64_DTPREL16_HIGH
:
4811 case R_PPC64_DTPREL16_HIGHA
:
4812 case R_PPC64_DTPREL16_HIGHER
:
4813 case R_PPC64_DTPREL16_HIGHERA
:
4814 case R_PPC64_DTPREL16_HIGHEST
:
4815 case R_PPC64_DTPREL16_HIGHESTA
:
4820 case R_PPC64_REL16_LO
:
4821 case R_PPC64_REL16_HI
:
4822 case R_PPC64_REL16_HA
:
4823 case R_PPC64_REL16_HIGH
:
4824 case R_PPC64_REL16_HIGHA
:
4825 case R_PPC64_REL16_HIGHER
:
4826 case R_PPC64_REL16_HIGHERA
:
4827 case R_PPC64_REL16_HIGHEST
:
4828 case R_PPC64_REL16_HIGHESTA
:
4829 case R_PPC64_REL16_HIGHER34
:
4830 case R_PPC64_REL16_HIGHERA34
:
4831 case R_PPC64_REL16_HIGHEST34
:
4832 case R_PPC64_REL16_HIGHESTA34
:
4833 case R_PPC64_REL16DX_HA
:
4836 /* Not supported as a dynamic relocation. */
4837 case R_PPC64_ADDR64_LOCAL
:
4838 if (bfd_link_pic (info
))
4840 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
4842 /* xgettext:c-format */
4843 info
->callbacks
->einfo (_("%H: %s reloc unsupported "
4844 "in shared libraries and PIEs\n"),
4845 abfd
, sec
, rel
->r_offset
,
4846 ppc64_elf_howto_table
[r_type
]->name
);
4847 bfd_set_error (bfd_error_bad_value
);
4853 case R_PPC64_TOC16_DS
:
4854 htab
->do_multi_toc
= 1;
4855 ppc64_elf_tdata (abfd
)->has_small_toc_reloc
= 1;
4857 case R_PPC64_TOC16_LO
:
4858 case R_PPC64_TOC16_HI
:
4859 case R_PPC64_TOC16_HA
:
4860 case R_PPC64_TOC16_LO_DS
:
4861 sec
->has_toc_reloc
= 1;
4862 if (h
!= NULL
&& bfd_link_executable (info
))
4864 /* We may need a copy reloc. */
4866 /* Strongly prefer a copy reloc over a dynamic reloc.
4867 glibc ld.so as of 2019-08 will error out if one of
4868 these relocations is emitted. */
4878 /* This relocation describes the C++ object vtable hierarchy.
4879 Reconstruct it for later use during GC. */
4880 case R_PPC64_GNU_VTINHERIT
:
4881 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
4885 /* This relocation describes which C++ vtable entries are actually
4886 used. Record for later use during GC. */
4887 case R_PPC64_GNU_VTENTRY
:
4888 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
4893 case R_PPC64_REL14_BRTAKEN
:
4894 case R_PPC64_REL14_BRNTAKEN
:
4896 asection
*dest
= NULL
;
4898 /* Heuristic: If jumping outside our section, chances are
4899 we are going to need a stub. */
4902 /* If the sym is weak it may be overridden later, so
4903 don't assume we know where a weak sym lives. */
4904 if (h
->root
.type
== bfd_link_hash_defined
)
4905 dest
= h
->root
.u
.def
.section
;
4909 Elf_Internal_Sym
*isym
;
4911 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
4916 dest
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
4920 ppc64_elf_section_data (sec
)->has_14bit_branch
= 1;
4924 case R_PPC64_PLTCALL
:
4925 case R_PPC64_PLTCALL_NOTOC
:
4926 ppc64_elf_section_data (sec
)->has_pltcall
= 1;
4930 case R_PPC64_REL24_NOTOC
:
4936 if (h
->root
.root
.string
[0] == '.'
4937 && h
->root
.root
.string
[1] != '\0')
4938 ppc_elf_hash_entry (h
)->is_func
= 1;
4940 if (h
== tga
|| h
== dottga
)
4942 sec
->has_tls_reloc
= 1;
4944 && (ELF64_R_TYPE (rel
[-1].r_info
) == R_PPC64_TLSGD
4945 || ELF64_R_TYPE (rel
[-1].r_info
) == R_PPC64_TLSLD
))
4946 /* We have a new-style __tls_get_addr call with
4950 /* Mark this section as having an old-style call. */
4951 sec
->nomark_tls_get_addr
= 1;
4953 plt_list
= &h
->plt
.plist
;
4956 /* We may need a .plt entry if the function this reloc
4957 refers to is in a shared lib. */
4959 && !update_plt_info (abfd
, plt_list
, rel
->r_addend
))
4963 case R_PPC64_ADDR14
:
4964 case R_PPC64_ADDR14_BRNTAKEN
:
4965 case R_PPC64_ADDR14_BRTAKEN
:
4966 case R_PPC64_ADDR24
:
4969 case R_PPC64_TPREL64
:
4970 tls_type
= TLS_EXPLICIT
| TLS_TLS
| TLS_TPREL
;
4971 if (bfd_link_dll (info
))
4972 info
->flags
|= DF_STATIC_TLS
;
4975 case R_PPC64_DTPMOD64
:
4976 if (rel
+ 1 < rel_end
4977 && rel
[1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_DTPREL64
)
4978 && rel
[1].r_offset
== rel
->r_offset
+ 8)
4979 tls_type
= TLS_EXPLICIT
| TLS_TLS
| TLS_GD
;
4981 tls_type
= TLS_EXPLICIT
| TLS_TLS
| TLS_LD
;
4984 case R_PPC64_DTPREL64
:
4985 tls_type
= TLS_EXPLICIT
| TLS_TLS
| TLS_DTPREL
;
4987 && rel
[-1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_DTPMOD64
)
4988 && rel
[-1].r_offset
== rel
->r_offset
- 8)
4989 /* This is the second reloc of a dtpmod, dtprel pair.
4990 Don't mark with TLS_DTPREL. */
4994 sec
->has_tls_reloc
= 1;
4996 ppc_elf_hash_entry (h
)->tls_mask
|= tls_type
& 0xff;
4998 if (!update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4999 rel
->r_addend
, tls_type
))
5002 ppc64_sec
= ppc64_elf_section_data (sec
);
5003 if (ppc64_sec
->sec_type
!= sec_toc
)
5007 /* One extra to simplify get_tls_mask. */
5008 amt
= sec
->size
* sizeof (unsigned) / 8 + sizeof (unsigned);
5009 ppc64_sec
->u
.toc
.symndx
= bfd_zalloc (abfd
, amt
);
5010 if (ppc64_sec
->u
.toc
.symndx
== NULL
)
5012 amt
= sec
->size
* sizeof (bfd_vma
) / 8;
5013 ppc64_sec
->u
.toc
.add
= bfd_zalloc (abfd
, amt
);
5014 if (ppc64_sec
->u
.toc
.add
== NULL
)
5016 BFD_ASSERT (ppc64_sec
->sec_type
== sec_normal
);
5017 ppc64_sec
->sec_type
= sec_toc
;
5019 BFD_ASSERT (rel
->r_offset
% 8 == 0);
5020 ppc64_sec
->u
.toc
.symndx
[rel
->r_offset
/ 8] = r_symndx
;
5021 ppc64_sec
->u
.toc
.add
[rel
->r_offset
/ 8] = rel
->r_addend
;
5023 /* Mark the second slot of a GD or LD entry.
5024 -1 to indicate GD and -2 to indicate LD. */
5025 if (tls_type
== (TLS_EXPLICIT
| TLS_TLS
| TLS_GD
))
5026 ppc64_sec
->u
.toc
.symndx
[rel
->r_offset
/ 8 + 1] = -1;
5027 else if (tls_type
== (TLS_EXPLICIT
| TLS_TLS
| TLS_LD
))
5028 ppc64_sec
->u
.toc
.symndx
[rel
->r_offset
/ 8 + 1] = -2;
5031 case R_PPC64_TPREL16
:
5032 case R_PPC64_TPREL16_LO
:
5033 case R_PPC64_TPREL16_HI
:
5034 case R_PPC64_TPREL16_HA
:
5035 case R_PPC64_TPREL16_DS
:
5036 case R_PPC64_TPREL16_LO_DS
:
5037 case R_PPC64_TPREL16_HIGH
:
5038 case R_PPC64_TPREL16_HIGHA
:
5039 case R_PPC64_TPREL16_HIGHER
:
5040 case R_PPC64_TPREL16_HIGHERA
:
5041 case R_PPC64_TPREL16_HIGHEST
:
5042 case R_PPC64_TPREL16_HIGHESTA
:
5043 case R_PPC64_TPREL34
:
5044 if (bfd_link_dll (info
))
5045 info
->flags
|= DF_STATIC_TLS
;
5048 case R_PPC64_ADDR64
:
5050 && rel
+ 1 < rel_end
5051 && ELF64_R_TYPE ((rel
+ 1)->r_info
) == R_PPC64_TOC
)
5054 ppc_elf_hash_entry (h
)->is_func
= 1;
5058 case R_PPC64_ADDR16
:
5059 case R_PPC64_ADDR16_DS
:
5060 case R_PPC64_ADDR16_HA
:
5061 case R_PPC64_ADDR16_HI
:
5062 case R_PPC64_ADDR16_HIGH
:
5063 case R_PPC64_ADDR16_HIGHA
:
5064 case R_PPC64_ADDR16_HIGHER
:
5065 case R_PPC64_ADDR16_HIGHERA
:
5066 case R_PPC64_ADDR16_HIGHEST
:
5067 case R_PPC64_ADDR16_HIGHESTA
:
5068 case R_PPC64_ADDR16_LO
:
5069 case R_PPC64_ADDR16_LO_DS
:
5071 case R_PPC64_D34_LO
:
5072 case R_PPC64_D34_HI30
:
5073 case R_PPC64_D34_HA30
:
5074 case R_PPC64_ADDR16_HIGHER34
:
5075 case R_PPC64_ADDR16_HIGHERA34
:
5076 case R_PPC64_ADDR16_HIGHEST34
:
5077 case R_PPC64_ADDR16_HIGHESTA34
:
5079 if (h
!= NULL
&& !bfd_link_pic (info
) && abiversion (abfd
) != 1
5080 && rel
->r_addend
== 0)
5082 /* We may need a .plt entry if this reloc refers to a
5083 function in a shared lib. */
5084 if (!update_plt_info (abfd
, &h
->plt
.plist
, 0))
5086 h
->pointer_equality_needed
= 1;
5093 case R_PPC64_ADDR32
:
5094 case R_PPC64_UADDR16
:
5095 case R_PPC64_UADDR32
:
5096 case R_PPC64_UADDR64
:
5098 if (h
!= NULL
&& bfd_link_executable (info
))
5099 /* We may need a copy reloc. */
5102 /* Don't propagate .opd relocs. */
5103 if (NO_OPD_RELOCS
&& is_opd
)
5106 /* If we are creating a shared library, and this is a reloc
5107 against a global symbol, or a non PC relative reloc
5108 against a local symbol, then we need to copy the reloc
5109 into the shared library. However, if we are linking with
5110 -Bsymbolic, we do not need to copy a reloc against a
5111 global symbol which is defined in an object we are
5112 including in the link (i.e., DEF_REGULAR is set). At
5113 this point we have not seen all the input files, so it is
5114 possible that DEF_REGULAR is not set now but will be set
5115 later (it is never cleared). In case of a weak definition,
5116 DEF_REGULAR may be cleared later by a strong definition in
5117 a shared library. We account for that possibility below by
5118 storing information in the dyn_relocs field of the hash
5119 table entry. A similar situation occurs when creating
5120 shared libraries and symbol visibility changes render the
5123 If on the other hand, we are creating an executable, we
5124 may need to keep relocations for symbols satisfied by a
5125 dynamic library if we manage to avoid copy relocs for the
5129 && (h
->root
.type
== bfd_link_hash_defweak
5130 || !h
->def_regular
))
5132 && !bfd_link_executable (info
)
5133 && !SYMBOLIC_BIND (info
, h
))
5134 || (bfd_link_pic (info
)
5135 && must_be_dyn_reloc (info
, r_type
))
5136 || (!bfd_link_pic (info
)
5139 /* We must copy these reloc types into the output file.
5140 Create a reloc section in dynobj and make room for
5144 sreloc
= _bfd_elf_make_dynamic_reloc_section
5145 (sec
, htab
->elf
.dynobj
, 3, abfd
, /*rela?*/ TRUE
);
5151 /* If this is a global symbol, we count the number of
5152 relocations we need for this symbol. */
5155 struct elf_dyn_relocs
*p
;
5156 struct elf_dyn_relocs
**head
;
5158 head
= &ppc_elf_hash_entry (h
)->dyn_relocs
;
5160 if (p
== NULL
|| p
->sec
!= sec
)
5162 p
= bfd_alloc (htab
->elf
.dynobj
, sizeof *p
);
5172 if (!must_be_dyn_reloc (info
, r_type
))
5177 /* Track dynamic relocs needed for local syms too.
5178 We really need local syms available to do this
5180 struct ppc_dyn_relocs
*p
;
5181 struct ppc_dyn_relocs
**head
;
5182 bfd_boolean is_ifunc
;
5185 Elf_Internal_Sym
*isym
;
5187 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
5192 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
5196 vpp
= &elf_section_data (s
)->local_dynrel
;
5197 head
= (struct ppc_dyn_relocs
**) vpp
;
5198 is_ifunc
= ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
;
5200 if (p
!= NULL
&& p
->sec
== sec
&& p
->ifunc
!= is_ifunc
)
5202 if (p
== NULL
|| p
->sec
!= sec
|| p
->ifunc
!= is_ifunc
)
5204 p
= bfd_alloc (htab
->elf
.dynobj
, sizeof *p
);
5210 p
->ifunc
= is_ifunc
;
5226 /* Merge backend specific data from an object file to the output
5227 object file when linking. */
5230 ppc64_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
5232 bfd
*obfd
= info
->output_bfd
;
5233 unsigned long iflags
, oflags
;
5235 if ((ibfd
->flags
& BFD_LINKER_CREATED
) != 0)
5238 if (!is_ppc64_elf (ibfd
) || !is_ppc64_elf (obfd
))
5241 if (!_bfd_generic_verify_endian_match (ibfd
, info
))
5244 iflags
= elf_elfheader (ibfd
)->e_flags
;
5245 oflags
= elf_elfheader (obfd
)->e_flags
;
5247 if (iflags
& ~EF_PPC64_ABI
)
5250 /* xgettext:c-format */
5251 (_("%pB uses unknown e_flags 0x%lx"), ibfd
, iflags
);
5252 bfd_set_error (bfd_error_bad_value
);
5255 else if (iflags
!= oflags
&& iflags
!= 0)
5258 /* xgettext:c-format */
5259 (_("%pB: ABI version %ld is not compatible with ABI version %ld output"),
5260 ibfd
, iflags
, oflags
);
5261 bfd_set_error (bfd_error_bad_value
);
5265 if (!_bfd_elf_ppc_merge_fp_attributes (ibfd
, info
))
5268 /* Merge Tag_compatibility attributes and any common GNU ones. */
5269 return _bfd_elf_merge_object_attributes (ibfd
, info
);
5273 ppc64_elf_print_private_bfd_data (bfd
*abfd
, void *ptr
)
5275 /* Print normal ELF private data. */
5276 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
5278 if (elf_elfheader (abfd
)->e_flags
!= 0)
5282 fprintf (file
, _("private flags = 0x%lx:"),
5283 elf_elfheader (abfd
)->e_flags
);
5285 if ((elf_elfheader (abfd
)->e_flags
& EF_PPC64_ABI
) != 0)
5286 fprintf (file
, _(" [abiv%ld]"),
5287 elf_elfheader (abfd
)->e_flags
& EF_PPC64_ABI
);
5294 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
5295 of the code entry point, and its section, which must be in the same
5296 object as OPD_SEC. Returns (bfd_vma) -1 on error. */
5299 opd_entry_value (asection
*opd_sec
,
5301 asection
**code_sec
,
5303 bfd_boolean in_code_sec
)
5305 bfd
*opd_bfd
= opd_sec
->owner
;
5306 Elf_Internal_Rela
*relocs
;
5307 Elf_Internal_Rela
*lo
, *hi
, *look
;
5310 /* No relocs implies we are linking a --just-symbols object, or looking
5311 at a final linked executable with addr2line or somesuch. */
5312 if (opd_sec
->reloc_count
== 0)
5314 bfd_byte
*contents
= ppc64_elf_tdata (opd_bfd
)->opd
.contents
;
5316 if (contents
== NULL
)
5318 if (!bfd_malloc_and_get_section (opd_bfd
, opd_sec
, &contents
))
5319 return (bfd_vma
) -1;
5320 ppc64_elf_tdata (opd_bfd
)->opd
.contents
= contents
;
5323 /* PR 17512: file: 64b9dfbb. */
5324 if (offset
+ 7 >= opd_sec
->size
|| offset
+ 7 < offset
)
5325 return (bfd_vma
) -1;
5327 val
= bfd_get_64 (opd_bfd
, contents
+ offset
);
5328 if (code_sec
!= NULL
)
5330 asection
*sec
, *likely
= NULL
;
5336 && val
< sec
->vma
+ sec
->size
)
5342 for (sec
= opd_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
5344 && (sec
->flags
& SEC_LOAD
) != 0
5345 && (sec
->flags
& SEC_ALLOC
) != 0)
5350 if (code_off
!= NULL
)
5351 *code_off
= val
- likely
->vma
;
5357 BFD_ASSERT (is_ppc64_elf (opd_bfd
));
5359 relocs
= ppc64_elf_tdata (opd_bfd
)->opd
.relocs
;
5361 relocs
= _bfd_elf_link_read_relocs (opd_bfd
, opd_sec
, NULL
, NULL
, TRUE
);
5362 /* PR 17512: file: df8e1fd6. */
5364 return (bfd_vma
) -1;
5366 /* Go find the opd reloc at the sym address. */
5368 hi
= lo
+ opd_sec
->reloc_count
- 1; /* ignore last reloc */
5372 look
= lo
+ (hi
- lo
) / 2;
5373 if (look
->r_offset
< offset
)
5375 else if (look
->r_offset
> offset
)
5379 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (opd_bfd
);
5381 if (ELF64_R_TYPE (look
->r_info
) == R_PPC64_ADDR64
5382 && ELF64_R_TYPE ((look
+ 1)->r_info
) == R_PPC64_TOC
)
5384 unsigned long symndx
= ELF64_R_SYM (look
->r_info
);
5385 asection
*sec
= NULL
;
5387 if (symndx
>= symtab_hdr
->sh_info
5388 && elf_sym_hashes (opd_bfd
) != NULL
)
5390 struct elf_link_hash_entry
**sym_hashes
;
5391 struct elf_link_hash_entry
*rh
;
5393 sym_hashes
= elf_sym_hashes (opd_bfd
);
5394 rh
= sym_hashes
[symndx
- symtab_hdr
->sh_info
];
5397 rh
= elf_follow_link (rh
);
5398 if (rh
->root
.type
!= bfd_link_hash_defined
5399 && rh
->root
.type
!= bfd_link_hash_defweak
)
5401 if (rh
->root
.u
.def
.section
->owner
== opd_bfd
)
5403 val
= rh
->root
.u
.def
.value
;
5404 sec
= rh
->root
.u
.def
.section
;
5411 Elf_Internal_Sym
*sym
;
5413 if (symndx
< symtab_hdr
->sh_info
)
5415 sym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
5418 size_t symcnt
= symtab_hdr
->sh_info
;
5419 sym
= bfd_elf_get_elf_syms (opd_bfd
, symtab_hdr
,
5424 symtab_hdr
->contents
= (bfd_byte
*) sym
;
5430 sym
= bfd_elf_get_elf_syms (opd_bfd
, symtab_hdr
,
5436 sec
= bfd_section_from_elf_index (opd_bfd
, sym
->st_shndx
);
5439 BFD_ASSERT ((sec
->flags
& SEC_MERGE
) == 0);
5440 val
= sym
->st_value
;
5443 val
+= look
->r_addend
;
5444 if (code_off
!= NULL
)
5446 if (code_sec
!= NULL
)
5448 if (in_code_sec
&& *code_sec
!= sec
)
5453 if (sec
->output_section
!= NULL
)
5454 val
+= sec
->output_section
->vma
+ sec
->output_offset
;
5463 /* If the ELF symbol SYM might be a function in SEC, return the
5464 function size and set *CODE_OFF to the function's entry point,
5465 otherwise return zero. */
5467 static bfd_size_type
5468 ppc64_elf_maybe_function_sym (const asymbol
*sym
, asection
*sec
,
5473 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_FILE
| BSF_OBJECT
5474 | BSF_THREAD_LOCAL
| BSF_RELC
| BSF_SRELC
)) != 0)
5478 if (!(sym
->flags
& BSF_SYNTHETIC
))
5479 size
= ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
5481 if (strcmp (sym
->section
->name
, ".opd") == 0)
5483 struct _opd_sec_data
*opd
= get_opd_info (sym
->section
);
5484 bfd_vma symval
= sym
->value
;
5487 && opd
->adjust
!= NULL
5488 && elf_section_data (sym
->section
)->relocs
!= NULL
)
5490 /* opd_entry_value will use cached relocs that have been
5491 adjusted, but with raw symbols. That means both local
5492 and global symbols need adjusting. */
5493 long adjust
= opd
->adjust
[OPD_NDX (symval
)];
5499 if (opd_entry_value (sym
->section
, symval
,
5500 &sec
, code_off
, TRUE
) == (bfd_vma
) -1)
5502 /* An old ABI binary with dot-syms has a size of 24 on the .opd
5503 symbol. This size has nothing to do with the code size of the
5504 function, which is what we're supposed to return, but the
5505 code size isn't available without looking up the dot-sym.
5506 However, doing that would be a waste of time particularly
5507 since elf_find_function will look at the dot-sym anyway.
5508 Now, elf_find_function will keep the largest size of any
5509 function sym found at the code address of interest, so return
5510 1 here to avoid it incorrectly caching a larger function size
5511 for a small function. This does mean we return the wrong
5512 size for a new-ABI function of size 24, but all that does is
5513 disable caching for such functions. */
5519 if (sym
->section
!= sec
)
5521 *code_off
= sym
->value
;
5528 /* Return true if symbol is a strong function defined in an ELFv2
5529 object with st_other localentry bits of zero, ie. its local entry
5530 point coincides with its global entry point. */
5533 is_elfv2_localentry0 (struct elf_link_hash_entry
*h
)
5536 && h
->type
== STT_FUNC
5537 && h
->root
.type
== bfd_link_hash_defined
5538 && (STO_PPC64_LOCAL_MASK
& h
->other
) == 0
5539 && !ppc_elf_hash_entry (h
)->non_zero_localentry
5540 && is_ppc64_elf (h
->root
.u
.def
.section
->owner
)
5541 && abiversion (h
->root
.u
.def
.section
->owner
) >= 2);
5544 /* Return true if symbol is defined in a regular object file. */
5547 is_static_defined (struct elf_link_hash_entry
*h
)
5549 return ((h
->root
.type
== bfd_link_hash_defined
5550 || h
->root
.type
== bfd_link_hash_defweak
)
5551 && h
->root
.u
.def
.section
!= NULL
5552 && h
->root
.u
.def
.section
->output_section
!= NULL
);
5555 /* If FDH is a function descriptor symbol, return the associated code
5556 entry symbol if it is defined. Return NULL otherwise. */
5558 static struct ppc_link_hash_entry
*
5559 defined_code_entry (struct ppc_link_hash_entry
*fdh
)
5561 if (fdh
->is_func_descriptor
)
5563 struct ppc_link_hash_entry
*fh
= ppc_follow_link (fdh
->oh
);
5564 if (fh
->elf
.root
.type
== bfd_link_hash_defined
5565 || fh
->elf
.root
.type
== bfd_link_hash_defweak
)
5571 /* If FH is a function code entry symbol, return the associated
5572 function descriptor symbol if it is defined. Return NULL otherwise. */
5574 static struct ppc_link_hash_entry
*
5575 defined_func_desc (struct ppc_link_hash_entry
*fh
)
5578 && fh
->oh
->is_func_descriptor
)
5580 struct ppc_link_hash_entry
*fdh
= ppc_follow_link (fh
->oh
);
5581 if (fdh
->elf
.root
.type
== bfd_link_hash_defined
5582 || fdh
->elf
.root
.type
== bfd_link_hash_defweak
)
5588 /* Given H is a symbol that satisfies is_static_defined, return the
5589 value in the output file. */
5592 defined_sym_val (struct elf_link_hash_entry
*h
)
5594 return (h
->root
.u
.def
.section
->output_section
->vma
5595 + h
->root
.u
.def
.section
->output_offset
5596 + h
->root
.u
.def
.value
);
5599 /* Return true if H matches __tls_get_addr or one of its variants. */
5602 is_tls_get_addr (struct elf_link_hash_entry
*h
,
5603 struct ppc_link_hash_table
*htab
)
5605 return (h
== &htab
->tls_get_addr_fd
->elf
|| h
== &htab
->tga_desc_fd
->elf
5606 || h
== &htab
->tls_get_addr
->elf
|| h
== &htab
->tga_desc
->elf
);
5609 static bfd_boolean
func_desc_adjust (struct elf_link_hash_entry
*, void *);
5611 /* Garbage collect sections, after first dealing with dot-symbols. */
5614 ppc64_elf_gc_sections (bfd
*abfd
, struct bfd_link_info
*info
)
5616 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
5618 if (htab
!= NULL
&& htab
->need_func_desc_adj
)
5620 elf_link_hash_traverse (&htab
->elf
, func_desc_adjust
, info
);
5621 htab
->need_func_desc_adj
= 0;
5623 return bfd_elf_gc_sections (abfd
, info
);
5626 /* Mark all our entry sym sections, both opd and code section. */
5629 ppc64_elf_gc_keep (struct bfd_link_info
*info
)
5631 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
5632 struct bfd_sym_chain
*sym
;
5637 for (sym
= info
->gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
5639 struct ppc_link_hash_entry
*eh
, *fh
;
5642 eh
= ppc_elf_hash_entry (elf_link_hash_lookup (&htab
->elf
, sym
->name
,
5643 FALSE
, FALSE
, TRUE
));
5646 if (eh
->elf
.root
.type
!= bfd_link_hash_defined
5647 && eh
->elf
.root
.type
!= bfd_link_hash_defweak
)
5650 fh
= defined_code_entry (eh
);
5653 sec
= fh
->elf
.root
.u
.def
.section
;
5654 sec
->flags
|= SEC_KEEP
;
5656 else if (get_opd_info (eh
->elf
.root
.u
.def
.section
) != NULL
5657 && opd_entry_value (eh
->elf
.root
.u
.def
.section
,
5658 eh
->elf
.root
.u
.def
.value
,
5659 &sec
, NULL
, FALSE
) != (bfd_vma
) -1)
5660 sec
->flags
|= SEC_KEEP
;
5662 sec
= eh
->elf
.root
.u
.def
.section
;
5663 sec
->flags
|= SEC_KEEP
;
5667 /* Mark sections containing dynamically referenced symbols. When
5668 building shared libraries, we must assume that any visible symbol is
5672 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry
*h
, void *inf
)
5674 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
5675 struct ppc_link_hash_entry
*eh
= ppc_elf_hash_entry (h
);
5676 struct ppc_link_hash_entry
*fdh
;
5677 struct bfd_elf_dynamic_list
*d
= info
->dynamic_list
;
5679 /* Dynamic linking info is on the func descriptor sym. */
5680 fdh
= defined_func_desc (eh
);
5684 if ((eh
->elf
.root
.type
== bfd_link_hash_defined
5685 || eh
->elf
.root
.type
== bfd_link_hash_defweak
)
5686 && ((eh
->elf
.ref_dynamic
&& !eh
->elf
.forced_local
)
5687 || ((eh
->elf
.def_regular
|| ELF_COMMON_DEF_P (&eh
->elf
))
5688 && ELF_ST_VISIBILITY (eh
->elf
.other
) != STV_INTERNAL
5689 && ELF_ST_VISIBILITY (eh
->elf
.other
) != STV_HIDDEN
5690 && (!bfd_link_executable (info
)
5691 || info
->gc_keep_exported
5692 || info
->export_dynamic
5695 && (*d
->match
) (&d
->head
, NULL
,
5696 eh
->elf
.root
.root
.string
)))
5697 && (eh
->elf
.versioned
>= versioned
5698 || !bfd_hide_sym_by_version (info
->version_info
,
5699 eh
->elf
.root
.root
.string
)))))
5702 struct ppc_link_hash_entry
*fh
;
5704 eh
->elf
.root
.u
.def
.section
->flags
|= SEC_KEEP
;
5706 /* Function descriptor syms cause the associated
5707 function code sym section to be marked. */
5708 fh
= defined_code_entry (eh
);
5711 code_sec
= fh
->elf
.root
.u
.def
.section
;
5712 code_sec
->flags
|= SEC_KEEP
;
5714 else if (get_opd_info (eh
->elf
.root
.u
.def
.section
) != NULL
5715 && opd_entry_value (eh
->elf
.root
.u
.def
.section
,
5716 eh
->elf
.root
.u
.def
.value
,
5717 &code_sec
, NULL
, FALSE
) != (bfd_vma
) -1)
5718 code_sec
->flags
|= SEC_KEEP
;
5724 /* Return the section that should be marked against GC for a given
5728 ppc64_elf_gc_mark_hook (asection
*sec
,
5729 struct bfd_link_info
*info
,
5730 Elf_Internal_Rela
*rel
,
5731 struct elf_link_hash_entry
*h
,
5732 Elf_Internal_Sym
*sym
)
5736 /* Syms return NULL if we're marking .opd, so we avoid marking all
5737 function sections, as all functions are referenced in .opd. */
5739 if (get_opd_info (sec
) != NULL
)
5744 enum elf_ppc64_reloc_type r_type
;
5745 struct ppc_link_hash_entry
*eh
, *fh
, *fdh
;
5747 r_type
= ELF64_R_TYPE (rel
->r_info
);
5750 case R_PPC64_GNU_VTINHERIT
:
5751 case R_PPC64_GNU_VTENTRY
:
5755 switch (h
->root
.type
)
5757 case bfd_link_hash_defined
:
5758 case bfd_link_hash_defweak
:
5759 eh
= ppc_elf_hash_entry (h
);
5760 fdh
= defined_func_desc (eh
);
5763 /* -mcall-aixdesc code references the dot-symbol on
5764 a call reloc. Mark the function descriptor too
5765 against garbage collection. */
5767 if (fdh
->elf
.is_weakalias
)
5768 weakdef (&fdh
->elf
)->mark
= 1;
5772 /* Function descriptor syms cause the associated
5773 function code sym section to be marked. */
5774 fh
= defined_code_entry (eh
);
5777 /* They also mark their opd section. */
5778 eh
->elf
.root
.u
.def
.section
->gc_mark
= 1;
5780 rsec
= fh
->elf
.root
.u
.def
.section
;
5782 else if (get_opd_info (eh
->elf
.root
.u
.def
.section
) != NULL
5783 && opd_entry_value (eh
->elf
.root
.u
.def
.section
,
5784 eh
->elf
.root
.u
.def
.value
,
5785 &rsec
, NULL
, FALSE
) != (bfd_vma
) -1)
5786 eh
->elf
.root
.u
.def
.section
->gc_mark
= 1;
5788 rsec
= h
->root
.u
.def
.section
;
5791 case bfd_link_hash_common
:
5792 rsec
= h
->root
.u
.c
.p
->section
;
5796 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
5802 struct _opd_sec_data
*opd
;
5804 rsec
= bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
5805 opd
= get_opd_info (rsec
);
5806 if (opd
!= NULL
&& opd
->func_sec
!= NULL
)
5810 rsec
= opd
->func_sec
[OPD_NDX (sym
->st_value
+ rel
->r_addend
)];
5817 /* The maximum size of .sfpr. */
5818 #define SFPR_MAX (218*4)
5820 struct sfpr_def_parms
5822 const char name
[12];
5823 unsigned char lo
, hi
;
5824 bfd_byte
*(*write_ent
) (bfd
*, bfd_byte
*, int);
5825 bfd_byte
*(*write_tail
) (bfd
*, bfd_byte
*, int);
5828 /* Auto-generate _save*, _rest* functions in .sfpr.
5829 If STUB_SEC is non-null, define alias symbols in STUB_SEC
5833 sfpr_define (struct bfd_link_info
*info
,
5834 const struct sfpr_def_parms
*parm
,
5837 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
5839 size_t len
= strlen (parm
->name
);
5840 bfd_boolean writing
= FALSE
;
5846 memcpy (sym
, parm
->name
, len
);
5849 for (i
= parm
->lo
; i
<= parm
->hi
; i
++)
5851 struct ppc_link_hash_entry
*h
;
5853 sym
[len
+ 0] = i
/ 10 + '0';
5854 sym
[len
+ 1] = i
% 10 + '0';
5855 h
= ppc_elf_hash_entry (elf_link_hash_lookup (&htab
->elf
, sym
,
5856 writing
, TRUE
, TRUE
));
5857 if (stub_sec
!= NULL
)
5860 && h
->elf
.root
.type
== bfd_link_hash_defined
5861 && h
->elf
.root
.u
.def
.section
== htab
->sfpr
)
5863 struct elf_link_hash_entry
*s
;
5865 sprintf (buf
, "%08x.%s", stub_sec
->id
& 0xffffffff, sym
);
5866 s
= elf_link_hash_lookup (&htab
->elf
, buf
, TRUE
, TRUE
, FALSE
);
5869 if (s
->root
.type
== bfd_link_hash_new
)
5871 s
->root
.type
= bfd_link_hash_defined
;
5872 s
->root
.u
.def
.section
= stub_sec
;
5873 s
->root
.u
.def
.value
= (stub_sec
->size
- htab
->sfpr
->size
5874 + h
->elf
.root
.u
.def
.value
);
5877 s
->ref_regular_nonweak
= 1;
5878 s
->forced_local
= 1;
5880 s
->root
.linker_def
= 1;
5888 if (!h
->elf
.def_regular
)
5890 h
->elf
.root
.type
= bfd_link_hash_defined
;
5891 h
->elf
.root
.u
.def
.section
= htab
->sfpr
;
5892 h
->elf
.root
.u
.def
.value
= htab
->sfpr
->size
;
5893 h
->elf
.type
= STT_FUNC
;
5894 h
->elf
.def_regular
= 1;
5896 _bfd_elf_link_hash_hide_symbol (info
, &h
->elf
, TRUE
);
5898 if (htab
->sfpr
->contents
== NULL
)
5900 htab
->sfpr
->contents
5901 = bfd_alloc (htab
->elf
.dynobj
, SFPR_MAX
);
5902 if (htab
->sfpr
->contents
== NULL
)
5909 bfd_byte
*p
= htab
->sfpr
->contents
+ htab
->sfpr
->size
;
5911 p
= (*parm
->write_ent
) (htab
->elf
.dynobj
, p
, i
);
5913 p
= (*parm
->write_tail
) (htab
->elf
.dynobj
, p
, i
);
5914 htab
->sfpr
->size
= p
- htab
->sfpr
->contents
;
5922 savegpr0 (bfd
*abfd
, bfd_byte
*p
, int r
)
5924 bfd_put_32 (abfd
, STD_R0_0R1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5929 savegpr0_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5931 p
= savegpr0 (abfd
, p
, r
);
5932 bfd_put_32 (abfd
, STD_R0_0R1
+ STK_LR
, p
);
5934 bfd_put_32 (abfd
, BLR
, p
);
5939 restgpr0 (bfd
*abfd
, bfd_byte
*p
, int r
)
5941 bfd_put_32 (abfd
, LD_R0_0R1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5946 restgpr0_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5948 bfd_put_32 (abfd
, LD_R0_0R1
+ STK_LR
, p
);
5950 p
= restgpr0 (abfd
, p
, r
);
5951 bfd_put_32 (abfd
, MTLR_R0
, p
);
5955 p
= restgpr0 (abfd
, p
, 30);
5956 p
= restgpr0 (abfd
, p
, 31);
5958 bfd_put_32 (abfd
, BLR
, p
);
5963 savegpr1 (bfd
*abfd
, bfd_byte
*p
, int r
)
5965 bfd_put_32 (abfd
, STD_R0_0R12
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5970 savegpr1_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5972 p
= savegpr1 (abfd
, p
, r
);
5973 bfd_put_32 (abfd
, BLR
, p
);
5978 restgpr1 (bfd
*abfd
, bfd_byte
*p
, int r
)
5980 bfd_put_32 (abfd
, LD_R0_0R12
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5985 restgpr1_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5987 p
= restgpr1 (abfd
, p
, r
);
5988 bfd_put_32 (abfd
, BLR
, p
);
5993 savefpr (bfd
*abfd
, bfd_byte
*p
, int r
)
5995 bfd_put_32 (abfd
, STFD_FR0_0R1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
6000 savefpr0_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6002 p
= savefpr (abfd
, p
, r
);
6003 bfd_put_32 (abfd
, STD_R0_0R1
+ STK_LR
, p
);
6005 bfd_put_32 (abfd
, BLR
, p
);
6010 restfpr (bfd
*abfd
, bfd_byte
*p
, int r
)
6012 bfd_put_32 (abfd
, LFD_FR0_0R1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
6017 restfpr0_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6019 bfd_put_32 (abfd
, LD_R0_0R1
+ STK_LR
, p
);
6021 p
= restfpr (abfd
, p
, r
);
6022 bfd_put_32 (abfd
, MTLR_R0
, p
);
6026 p
= restfpr (abfd
, p
, 30);
6027 p
= restfpr (abfd
, p
, 31);
6029 bfd_put_32 (abfd
, BLR
, p
);
6034 savefpr1_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6036 p
= savefpr (abfd
, p
, r
);
6037 bfd_put_32 (abfd
, BLR
, p
);
6042 restfpr1_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6044 p
= restfpr (abfd
, p
, r
);
6045 bfd_put_32 (abfd
, BLR
, p
);
6050 savevr (bfd
*abfd
, bfd_byte
*p
, int r
)
6052 bfd_put_32 (abfd
, LI_R12_0
+ (1 << 16) - (32 - r
) * 16, p
);
6054 bfd_put_32 (abfd
, STVX_VR0_R12_R0
+ (r
<< 21), p
);
6059 savevr_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6061 p
= savevr (abfd
, p
, r
);
6062 bfd_put_32 (abfd
, BLR
, p
);
6067 restvr (bfd
*abfd
, bfd_byte
*p
, int r
)
6069 bfd_put_32 (abfd
, LI_R12_0
+ (1 << 16) - (32 - r
) * 16, p
);
6071 bfd_put_32 (abfd
, LVX_VR0_R12_R0
+ (r
<< 21), p
);
6076 restvr_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6078 p
= restvr (abfd
, p
, r
);
6079 bfd_put_32 (abfd
, BLR
, p
);
6083 #define STDU_R1_0R1 0xf8210001
6084 #define ADDI_R1_R1 0x38210000
6086 /* Emit prologue of wrapper preserving regs around a call to
6087 __tls_get_addr_opt. */
6090 tls_get_addr_prologue (bfd
*obfd
, bfd_byte
*p
, struct ppc_link_hash_table
*htab
)
6094 bfd_put_32 (obfd
, MFLR_R0
, p
);
6096 bfd_put_32 (obfd
, STD_R0_0R1
+ 16, p
);
6101 for (i
= 4; i
< 12; i
++)
6104 STD_R0_0R1
| i
<< 21 | (-(13 - i
) * 8 & 0xffff), p
);
6107 bfd_put_32 (obfd
, STDU_R1_0R1
| (-128 & 0xffff), p
);
6112 for (i
= 4; i
< 12; i
++)
6115 STD_R0_0R1
| i
<< 21 | (-(12 - i
) * 8 & 0xffff), p
);
6118 bfd_put_32 (obfd
, STDU_R1_0R1
| (-96 & 0xffff), p
);
6124 /* Emit epilogue of wrapper preserving regs around a call to
6125 __tls_get_addr_opt. */
6128 tls_get_addr_epilogue (bfd
*obfd
, bfd_byte
*p
, struct ppc_link_hash_table
*htab
)
6134 for (i
= 4; i
< 12; i
++)
6136 bfd_put_32 (obfd
, LD_R0_0R1
| i
<< 21 | (128 - (13 - i
) * 8), p
);
6139 bfd_put_32 (obfd
, ADDI_R1_R1
| 128, p
);
6144 for (i
= 4; i
< 12; i
++)
6146 bfd_put_32 (obfd
, LD_R0_0R1
| i
<< 21 | (96 - (12 - i
) * 8), p
);
6149 bfd_put_32 (obfd
, ADDI_R1_R1
| 96, p
);
6152 bfd_put_32 (obfd
, LD_R0_0R1
| 16, p
);
6154 bfd_put_32 (obfd
, MTLR_R0
, p
);
6156 bfd_put_32 (obfd
, BLR
, p
);
6161 /* Called via elf_link_hash_traverse to transfer dynamic linking
6162 information on function code symbol entries to their corresponding
6163 function descriptor symbol entries. */
6166 func_desc_adjust (struct elf_link_hash_entry
*h
, void *inf
)
6168 struct bfd_link_info
*info
;
6169 struct ppc_link_hash_table
*htab
;
6170 struct ppc_link_hash_entry
*fh
;
6171 struct ppc_link_hash_entry
*fdh
;
6172 bfd_boolean force_local
;
6174 fh
= ppc_elf_hash_entry (h
);
6175 if (fh
->elf
.root
.type
== bfd_link_hash_indirect
)
6181 if (fh
->elf
.root
.root
.string
[0] != '.'
6182 || fh
->elf
.root
.root
.string
[1] == '\0')
6186 htab
= ppc_hash_table (info
);
6190 /* Find the corresponding function descriptor symbol. */
6191 fdh
= lookup_fdh (fh
, htab
);
6193 /* Resolve undefined references to dot-symbols as the value
6194 in the function descriptor, if we have one in a regular object.
6195 This is to satisfy cases like ".quad .foo". Calls to functions
6196 in dynamic objects are handled elsewhere. */
6197 if ((fh
->elf
.root
.type
== bfd_link_hash_undefined
6198 || fh
->elf
.root
.type
== bfd_link_hash_undefweak
)
6199 && (fdh
->elf
.root
.type
== bfd_link_hash_defined
6200 || fdh
->elf
.root
.type
== bfd_link_hash_defweak
)
6201 && get_opd_info (fdh
->elf
.root
.u
.def
.section
) != NULL
6202 && opd_entry_value (fdh
->elf
.root
.u
.def
.section
,
6203 fdh
->elf
.root
.u
.def
.value
,
6204 &fh
->elf
.root
.u
.def
.section
,
6205 &fh
->elf
.root
.u
.def
.value
, FALSE
) != (bfd_vma
) -1)
6207 fh
->elf
.root
.type
= fdh
->elf
.root
.type
;
6208 fh
->elf
.forced_local
= 1;
6209 fh
->elf
.def_regular
= fdh
->elf
.def_regular
;
6210 fh
->elf
.def_dynamic
= fdh
->elf
.def_dynamic
;
6213 if (!fh
->elf
.dynamic
)
6215 struct plt_entry
*ent
;
6217 for (ent
= fh
->elf
.plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
6218 if (ent
->plt
.refcount
> 0)
6224 /* Create a descriptor as undefined if necessary. */
6226 && !bfd_link_executable (info
)
6227 && (fh
->elf
.root
.type
== bfd_link_hash_undefined
6228 || fh
->elf
.root
.type
== bfd_link_hash_undefweak
))
6230 fdh
= make_fdh (info
, fh
);
6235 /* We can't support overriding of symbols on a fake descriptor. */
6238 && (fh
->elf
.root
.type
== bfd_link_hash_defined
6239 || fh
->elf
.root
.type
== bfd_link_hash_defweak
))
6240 _bfd_elf_link_hash_hide_symbol (info
, &fdh
->elf
, TRUE
);
6242 /* Transfer dynamic linking information to the function descriptor. */
6245 fdh
->elf
.ref_regular
|= fh
->elf
.ref_regular
;
6246 fdh
->elf
.ref_dynamic
|= fh
->elf
.ref_dynamic
;
6247 fdh
->elf
.ref_regular_nonweak
|= fh
->elf
.ref_regular_nonweak
;
6248 fdh
->elf
.non_got_ref
|= fh
->elf
.non_got_ref
;
6249 fdh
->elf
.dynamic
|= fh
->elf
.dynamic
;
6250 fdh
->elf
.needs_plt
|= (fh
->elf
.needs_plt
6251 || fh
->elf
.type
== STT_FUNC
6252 || fh
->elf
.type
== STT_GNU_IFUNC
);
6253 move_plt_plist (fh
, fdh
);
6255 if (!fdh
->elf
.forced_local
6256 && fh
->elf
.dynindx
!= -1)
6257 if (!bfd_elf_link_record_dynamic_symbol (info
, &fdh
->elf
))
6261 /* Now that the info is on the function descriptor, clear the
6262 function code sym info. Any function code syms for which we
6263 don't have a definition in a regular file, we force local.
6264 This prevents a shared library from exporting syms that have
6265 been imported from another library. Function code syms that
6266 are really in the library we must leave global to prevent the
6267 linker dragging in a definition from a static library. */
6268 force_local
= (!fh
->elf
.def_regular
6270 || !fdh
->elf
.def_regular
6271 || fdh
->elf
.forced_local
);
6272 _bfd_elf_link_hash_hide_symbol (info
, &fh
->elf
, force_local
);
6277 static const struct sfpr_def_parms save_res_funcs
[] =
6279 { "_savegpr0_", 14, 31, savegpr0
, savegpr0_tail
},
6280 { "_restgpr0_", 14, 29, restgpr0
, restgpr0_tail
},
6281 { "_restgpr0_", 30, 31, restgpr0
, restgpr0_tail
},
6282 { "_savegpr1_", 14, 31, savegpr1
, savegpr1_tail
},
6283 { "_restgpr1_", 14, 31, restgpr1
, restgpr1_tail
},
6284 { "_savefpr_", 14, 31, savefpr
, savefpr0_tail
},
6285 { "_restfpr_", 14, 29, restfpr
, restfpr0_tail
},
6286 { "_restfpr_", 30, 31, restfpr
, restfpr0_tail
},
6287 { "._savef", 14, 31, savefpr
, savefpr1_tail
},
6288 { "._restf", 14, 31, restfpr
, restfpr1_tail
},
6289 { "_savevr_", 20, 31, savevr
, savevr_tail
},
6290 { "_restvr_", 20, 31, restvr
, restvr_tail
}
6293 /* Called near the start of bfd_elf_size_dynamic_sections. We use
6294 this hook to a) provide some gcc support functions, and b) transfer
6295 dynamic linking information gathered so far on function code symbol
6296 entries, to their corresponding function descriptor symbol entries. */
6299 ppc64_elf_func_desc_adjust (bfd
*obfd ATTRIBUTE_UNUSED
,
6300 struct bfd_link_info
*info
)
6302 struct ppc_link_hash_table
*htab
;
6304 htab
= ppc_hash_table (info
);
6308 /* Provide any missing _save* and _rest* functions. */
6309 if (htab
->sfpr
!= NULL
)
6313 htab
->sfpr
->size
= 0;
6314 for (i
= 0; i
< ARRAY_SIZE (save_res_funcs
); i
++)
6315 if (!sfpr_define (info
, &save_res_funcs
[i
], NULL
))
6317 if (htab
->sfpr
->size
== 0)
6318 htab
->sfpr
->flags
|= SEC_EXCLUDE
;
6321 if (bfd_link_relocatable (info
))
6324 if (htab
->elf
.hgot
!= NULL
)
6326 _bfd_elf_link_hash_hide_symbol (info
, htab
->elf
.hgot
, TRUE
);
6327 /* Make .TOC. defined so as to prevent it being made dynamic.
6328 The wrong value here is fixed later in ppc64_elf_set_toc. */
6329 if (!htab
->elf
.hgot
->def_regular
6330 || htab
->elf
.hgot
->root
.type
!= bfd_link_hash_defined
)
6332 htab
->elf
.hgot
->root
.type
= bfd_link_hash_defined
;
6333 htab
->elf
.hgot
->root
.u
.def
.value
= 0;
6334 htab
->elf
.hgot
->root
.u
.def
.section
= bfd_abs_section_ptr
;
6335 htab
->elf
.hgot
->def_regular
= 1;
6336 htab
->elf
.hgot
->root
.linker_def
= 1;
6338 htab
->elf
.hgot
->type
= STT_OBJECT
;
6339 htab
->elf
.hgot
->other
6340 = (htab
->elf
.hgot
->other
& ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN
;
6343 if (htab
->need_func_desc_adj
)
6345 elf_link_hash_traverse (&htab
->elf
, func_desc_adjust
, info
);
6346 htab
->need_func_desc_adj
= 0;
6352 /* Find dynamic relocs for H that apply to read-only sections. */
6355 readonly_dynrelocs (struct elf_link_hash_entry
*h
)
6357 struct ppc_link_hash_entry
*eh
= ppc_elf_hash_entry (h
);
6358 struct elf_dyn_relocs
*p
;
6360 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
6362 asection
*s
= p
->sec
->output_section
;
6364 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
6370 /* Return true if we have dynamic relocs against H or any of its weak
6371 aliases, that apply to read-only sections. Cannot be used after
6372 size_dynamic_sections. */
6375 alias_readonly_dynrelocs (struct elf_link_hash_entry
*h
)
6377 struct ppc_link_hash_entry
*eh
= ppc_elf_hash_entry (h
);
6380 if (readonly_dynrelocs (&eh
->elf
))
6382 eh
= ppc_elf_hash_entry (eh
->elf
.u
.alias
);
6384 while (eh
!= NULL
&& &eh
->elf
!= h
);
6389 /* Return whether EH has pc-relative dynamic relocs. */
6392 pc_dynrelocs (struct ppc_link_hash_entry
*eh
)
6394 struct elf_dyn_relocs
*p
;
6396 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
6397 if (p
->pc_count
!= 0)
6402 /* Return true if a global entry stub will be created for H. Valid
6403 for ELFv2 before plt entries have been allocated. */
6406 global_entry_stub (struct elf_link_hash_entry
*h
)
6408 struct plt_entry
*pent
;
6410 if (!h
->pointer_equality_needed
6414 for (pent
= h
->plt
.plist
; pent
!= NULL
; pent
= pent
->next
)
6415 if (pent
->plt
.refcount
> 0
6416 && pent
->addend
== 0)
6422 /* Adjust a symbol defined by a dynamic object and referenced by a
6423 regular object. The current definition is in some section of the
6424 dynamic object, but we're not including those sections. We have to
6425 change the definition to something the rest of the link can
6429 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
6430 struct elf_link_hash_entry
*h
)
6432 struct ppc_link_hash_table
*htab
;
6435 htab
= ppc_hash_table (info
);
6439 /* Deal with function syms. */
6440 if (h
->type
== STT_FUNC
6441 || h
->type
== STT_GNU_IFUNC
6444 bfd_boolean local
= (ppc_elf_hash_entry (h
)->save_res
6445 || SYMBOL_CALLS_LOCAL (info
, h
)
6446 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
));
6447 /* Discard dyn_relocs when non-pic if we've decided that a
6448 function symbol is local and not an ifunc. We keep dynamic
6449 relocs for ifuncs when local rather than always emitting a
6450 plt call stub for them and defining the symbol on the call
6451 stub. We can't do that for ELFv1 anyway (a function symbol
6452 is defined on a descriptor, not code) and it can be faster at
6453 run-time due to not needing to bounce through a stub. The
6454 dyn_relocs for ifuncs will be applied even in a static
6456 if (!bfd_link_pic (info
)
6457 && h
->type
!= STT_GNU_IFUNC
6459 ppc_elf_hash_entry (h
)->dyn_relocs
= NULL
;
6461 /* Clear procedure linkage table information for any symbol that
6462 won't need a .plt entry. */
6463 struct plt_entry
*ent
;
6464 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
6465 if (ent
->plt
.refcount
> 0)
6468 || (h
->type
!= STT_GNU_IFUNC
6470 && (htab
->can_convert_all_inline_plt
6471 || (ppc_elf_hash_entry (h
)->tls_mask
6472 & (TLS_TLS
| PLT_KEEP
)) != PLT_KEEP
)))
6474 h
->plt
.plist
= NULL
;
6476 h
->pointer_equality_needed
= 0;
6478 else if (abiversion (info
->output_bfd
) >= 2)
6480 /* Taking a function's address in a read/write section
6481 doesn't require us to define the function symbol in the
6482 executable on a global entry stub. A dynamic reloc can
6483 be used instead. The reason we prefer a few more dynamic
6484 relocs is that calling via a global entry stub costs a
6485 few more instructions, and pointer_equality_needed causes
6486 extra work in ld.so when resolving these symbols. */
6487 if (global_entry_stub (h
))
6489 if (!readonly_dynrelocs (h
))
6491 h
->pointer_equality_needed
= 0;
6492 /* If we haven't seen a branch reloc and the symbol
6493 isn't an ifunc then we don't need a plt entry. */
6495 h
->plt
.plist
= NULL
;
6497 else if (!bfd_link_pic (info
))
6498 /* We are going to be defining the function symbol on the
6499 plt stub, so no dyn_relocs needed when non-pic. */
6500 ppc_elf_hash_entry (h
)->dyn_relocs
= NULL
;
6503 /* ELFv2 function symbols can't have copy relocs. */
6506 else if (!h
->needs_plt
6507 && !readonly_dynrelocs (h
))
6509 /* If we haven't seen a branch reloc and the symbol isn't an
6510 ifunc then we don't need a plt entry. */
6511 h
->plt
.plist
= NULL
;
6512 h
->pointer_equality_needed
= 0;
6517 h
->plt
.plist
= NULL
;
6519 /* If this is a weak symbol, and there is a real definition, the
6520 processor independent code will have arranged for us to see the
6521 real definition first, and we can just use the same value. */
6522 if (h
->is_weakalias
)
6524 struct elf_link_hash_entry
*def
= weakdef (h
);
6525 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
6526 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
6527 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
6528 if (def
->root
.u
.def
.section
== htab
->elf
.sdynbss
6529 || def
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
6530 ppc_elf_hash_entry (h
)->dyn_relocs
= NULL
;
6534 /* If we are creating a shared library, we must presume that the
6535 only references to the symbol are via the global offset table.
6536 For such cases we need not do anything here; the relocations will
6537 be handled correctly by relocate_section. */
6538 if (!bfd_link_executable (info
))
6541 /* If there are no references to this symbol that do not use the
6542 GOT, we don't need to generate a copy reloc. */
6543 if (!h
->non_got_ref
)
6546 /* Don't generate a copy reloc for symbols defined in the executable. */
6547 if (!h
->def_dynamic
|| !h
->ref_regular
|| h
->def_regular
6549 /* If -z nocopyreloc was given, don't generate them either. */
6550 || info
->nocopyreloc
6552 /* If we don't find any dynamic relocs in read-only sections, then
6553 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
6554 || (ELIMINATE_COPY_RELOCS
6556 && !alias_readonly_dynrelocs (h
))
6558 /* Protected variables do not work with .dynbss. The copy in
6559 .dynbss won't be used by the shared library with the protected
6560 definition for the variable. Text relocations are preferable
6561 to an incorrect program. */
6562 || h
->protected_def
)
6565 if (h
->type
== STT_FUNC
6566 || h
->type
== STT_GNU_IFUNC
)
6568 /* .dynbss copies of function symbols only work if we have
6569 ELFv1 dot-symbols. ELFv1 compilers since 2004 default to not
6570 use dot-symbols and set the function symbol size to the text
6571 size of the function rather than the size of the descriptor.
6572 That's wrong for copying a descriptor. */
6573 if (ppc_elf_hash_entry (h
)->oh
== NULL
6574 || !(h
->size
== 24 || h
->size
== 16))
6577 /* We should never get here, but unfortunately there are old
6578 versions of gcc (circa gcc-3.2) that improperly for the
6579 ELFv1 ABI put initialized function pointers, vtable refs and
6580 suchlike in read-only sections. Allow them to proceed, but
6581 warn that this might break at runtime. */
6582 info
->callbacks
->einfo
6583 (_("%P: copy reloc against `%pT' requires lazy plt linking; "
6584 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
6585 h
->root
.root
.string
);
6588 /* This is a reference to a symbol defined by a dynamic object which
6589 is not a function. */
6591 /* We must allocate the symbol in our .dynbss section, which will
6592 become part of the .bss section of the executable. There will be
6593 an entry for this symbol in the .dynsym section. The dynamic
6594 object will contain position independent code, so all references
6595 from the dynamic object to this symbol will go through the global
6596 offset table. The dynamic linker will use the .dynsym entry to
6597 determine the address it must put in the global offset table, so
6598 both the dynamic object and the regular object will refer to the
6599 same memory location for the variable. */
6600 if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
6602 s
= htab
->elf
.sdynrelro
;
6603 srel
= htab
->elf
.sreldynrelro
;
6607 s
= htab
->elf
.sdynbss
;
6608 srel
= htab
->elf
.srelbss
;
6610 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
6612 /* We must generate a R_PPC64_COPY reloc to tell the dynamic
6613 linker to copy the initial value out of the dynamic object
6614 and into the runtime process image. */
6615 srel
->size
+= sizeof (Elf64_External_Rela
);
6619 /* We no longer want dyn_relocs. */
6620 ppc_elf_hash_entry (h
)->dyn_relocs
= NULL
;
6621 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
6624 /* If given a function descriptor symbol, hide both the function code
6625 sym and the descriptor. */
6627 ppc64_elf_hide_symbol (struct bfd_link_info
*info
,
6628 struct elf_link_hash_entry
*h
,
6629 bfd_boolean force_local
)
6631 struct ppc_link_hash_entry
*eh
;
6632 _bfd_elf_link_hash_hide_symbol (info
, h
, force_local
);
6634 if (ppc_hash_table (info
) == NULL
)
6637 eh
= ppc_elf_hash_entry (h
);
6638 if (eh
->is_func_descriptor
)
6640 struct ppc_link_hash_entry
*fh
= eh
->oh
;
6645 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
6648 /* We aren't supposed to use alloca in BFD because on
6649 systems which do not have alloca the version in libiberty
6650 calls xmalloc, which might cause the program to crash
6651 when it runs out of memory. This function doesn't have a
6652 return status, so there's no way to gracefully return an
6653 error. So cheat. We know that string[-1] can be safely
6654 accessed; It's either a string in an ELF string table,
6655 or allocated in an objalloc structure. */
6657 p
= eh
->elf
.root
.root
.string
- 1;
6660 fh
= ppc_elf_hash_entry (elf_link_hash_lookup (htab
, p
, FALSE
,
6664 /* Unfortunately, if it so happens that the string we were
6665 looking for was allocated immediately before this string,
6666 then we overwrote the string terminator. That's the only
6667 reason the lookup should fail. */
6670 q
= eh
->elf
.root
.root
.string
+ strlen (eh
->elf
.root
.root
.string
);
6671 while (q
>= eh
->elf
.root
.root
.string
&& *q
== *p
)
6673 if (q
< eh
->elf
.root
.root
.string
&& *p
== '.')
6674 fh
= ppc_elf_hash_entry (elf_link_hash_lookup (htab
, p
, FALSE
,
6684 _bfd_elf_link_hash_hide_symbol (info
, &fh
->elf
, force_local
);
6689 get_sym_h (struct elf_link_hash_entry
**hp
,
6690 Elf_Internal_Sym
**symp
,
6692 unsigned char **tls_maskp
,
6693 Elf_Internal_Sym
**locsymsp
,
6694 unsigned long r_symndx
,
6697 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (ibfd
);
6699 if (r_symndx
>= symtab_hdr
->sh_info
)
6701 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (ibfd
);
6702 struct elf_link_hash_entry
*h
;
6704 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
6705 h
= elf_follow_link (h
);
6713 if (symsecp
!= NULL
)
6715 asection
*symsec
= NULL
;
6716 if (h
->root
.type
== bfd_link_hash_defined
6717 || h
->root
.type
== bfd_link_hash_defweak
)
6718 symsec
= h
->root
.u
.def
.section
;
6722 if (tls_maskp
!= NULL
)
6723 *tls_maskp
= &ppc_elf_hash_entry (h
)->tls_mask
;
6727 Elf_Internal_Sym
*sym
;
6728 Elf_Internal_Sym
*locsyms
= *locsymsp
;
6730 if (locsyms
== NULL
)
6732 locsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
6733 if (locsyms
== NULL
)
6734 locsyms
= bfd_elf_get_elf_syms (ibfd
, symtab_hdr
,
6735 symtab_hdr
->sh_info
,
6736 0, NULL
, NULL
, NULL
);
6737 if (locsyms
== NULL
)
6739 *locsymsp
= locsyms
;
6741 sym
= locsyms
+ r_symndx
;
6749 if (symsecp
!= NULL
)
6750 *symsecp
= bfd_section_from_elf_index (ibfd
, sym
->st_shndx
);
6752 if (tls_maskp
!= NULL
)
6754 struct got_entry
**lgot_ents
;
6755 unsigned char *tls_mask
;
6758 lgot_ents
= elf_local_got_ents (ibfd
);
6759 if (lgot_ents
!= NULL
)
6761 struct plt_entry
**local_plt
= (struct plt_entry
**)
6762 (lgot_ents
+ symtab_hdr
->sh_info
);
6763 unsigned char *lgot_masks
= (unsigned char *)
6764 (local_plt
+ symtab_hdr
->sh_info
);
6765 tls_mask
= &lgot_masks
[r_symndx
];
6767 *tls_maskp
= tls_mask
;
6773 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
6774 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
6775 type suitable for optimization, and 1 otherwise. */
6778 get_tls_mask (unsigned char **tls_maskp
,
6779 unsigned long *toc_symndx
,
6780 bfd_vma
*toc_addend
,
6781 Elf_Internal_Sym
**locsymsp
,
6782 const Elf_Internal_Rela
*rel
,
6785 unsigned long r_symndx
;
6787 struct elf_link_hash_entry
*h
;
6788 Elf_Internal_Sym
*sym
;
6792 r_symndx
= ELF64_R_SYM (rel
->r_info
);
6793 if (!get_sym_h (&h
, &sym
, &sec
, tls_maskp
, locsymsp
, r_symndx
, ibfd
))
6796 if ((*tls_maskp
!= NULL
6797 && (**tls_maskp
& TLS_TLS
) != 0
6798 && **tls_maskp
!= (TLS_TLS
| TLS_MARK
))
6800 || ppc64_elf_section_data (sec
) == NULL
6801 || ppc64_elf_section_data (sec
)->sec_type
!= sec_toc
)
6804 /* Look inside a TOC section too. */
6807 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
);
6808 off
= h
->root
.u
.def
.value
;
6811 off
= sym
->st_value
;
6812 off
+= rel
->r_addend
;
6813 BFD_ASSERT (off
% 8 == 0);
6814 r_symndx
= ppc64_elf_section_data (sec
)->u
.toc
.symndx
[off
/ 8];
6815 next_r
= ppc64_elf_section_data (sec
)->u
.toc
.symndx
[off
/ 8 + 1];
6816 if (toc_symndx
!= NULL
)
6817 *toc_symndx
= r_symndx
;
6818 if (toc_addend
!= NULL
)
6819 *toc_addend
= ppc64_elf_section_data (sec
)->u
.toc
.add
[off
/ 8];
6820 if (!get_sym_h (&h
, &sym
, &sec
, tls_maskp
, locsymsp
, r_symndx
, ibfd
))
6822 if ((h
== NULL
|| is_static_defined (h
))
6823 && (next_r
== -1 || next_r
== -2))
6828 /* Find (or create) an entry in the tocsave hash table. */
6830 static struct tocsave_entry
*
6831 tocsave_find (struct ppc_link_hash_table
*htab
,
6832 enum insert_option insert
,
6833 Elf_Internal_Sym
**local_syms
,
6834 const Elf_Internal_Rela
*irela
,
6837 unsigned long r_indx
;
6838 struct elf_link_hash_entry
*h
;
6839 Elf_Internal_Sym
*sym
;
6840 struct tocsave_entry ent
, *p
;
6842 struct tocsave_entry
**slot
;
6844 r_indx
= ELF64_R_SYM (irela
->r_info
);
6845 if (!get_sym_h (&h
, &sym
, &ent
.sec
, NULL
, local_syms
, r_indx
, ibfd
))
6847 if (ent
.sec
== NULL
|| ent
.sec
->output_section
== NULL
)
6850 (_("%pB: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd
);
6855 ent
.offset
= h
->root
.u
.def
.value
;
6857 ent
.offset
= sym
->st_value
;
6858 ent
.offset
+= irela
->r_addend
;
6860 hash
= tocsave_htab_hash (&ent
);
6861 slot
= ((struct tocsave_entry
**)
6862 htab_find_slot_with_hash (htab
->tocsave_htab
, &ent
, hash
, insert
));
6868 p
= (struct tocsave_entry
*) bfd_alloc (ibfd
, sizeof (*p
));
6877 /* Adjust all global syms defined in opd sections. In gcc generated
6878 code for the old ABI, these will already have been done. */
6881 adjust_opd_syms (struct elf_link_hash_entry
*h
, void *inf ATTRIBUTE_UNUSED
)
6883 struct ppc_link_hash_entry
*eh
;
6885 struct _opd_sec_data
*opd
;
6887 if (h
->root
.type
== bfd_link_hash_indirect
)
6890 if (h
->root
.type
!= bfd_link_hash_defined
6891 && h
->root
.type
!= bfd_link_hash_defweak
)
6894 eh
= ppc_elf_hash_entry (h
);
6895 if (eh
->adjust_done
)
6898 sym_sec
= eh
->elf
.root
.u
.def
.section
;
6899 opd
= get_opd_info (sym_sec
);
6900 if (opd
!= NULL
&& opd
->adjust
!= NULL
)
6902 long adjust
= opd
->adjust
[OPD_NDX (eh
->elf
.root
.u
.def
.value
)];
6905 /* This entry has been deleted. */
6906 asection
*dsec
= ppc64_elf_tdata (sym_sec
->owner
)->deleted_section
;
6909 for (dsec
= sym_sec
->owner
->sections
; dsec
; dsec
= dsec
->next
)
6910 if (discarded_section (dsec
))
6912 ppc64_elf_tdata (sym_sec
->owner
)->deleted_section
= dsec
;
6916 eh
->elf
.root
.u
.def
.value
= 0;
6917 eh
->elf
.root
.u
.def
.section
= dsec
;
6920 eh
->elf
.root
.u
.def
.value
+= adjust
;
6921 eh
->adjust_done
= 1;
6926 /* Handles decrementing dynamic reloc counts for the reloc specified by
6927 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
6928 have already been determined. */
6931 dec_dynrel_count (bfd_vma r_info
,
6933 struct bfd_link_info
*info
,
6934 Elf_Internal_Sym
**local_syms
,
6935 struct elf_link_hash_entry
*h
,
6936 Elf_Internal_Sym
*sym
)
6938 enum elf_ppc64_reloc_type r_type
;
6939 asection
*sym_sec
= NULL
;
6941 /* Can this reloc be dynamic? This switch, and later tests here
6942 should be kept in sync with the code in check_relocs. */
6943 r_type
= ELF64_R_TYPE (r_info
);
6950 case R_PPC64_TOC16_DS
:
6951 case R_PPC64_TOC16_LO
:
6952 case R_PPC64_TOC16_HI
:
6953 case R_PPC64_TOC16_HA
:
6954 case R_PPC64_TOC16_LO_DS
:
6959 case R_PPC64_TPREL16
:
6960 case R_PPC64_TPREL16_LO
:
6961 case R_PPC64_TPREL16_HI
:
6962 case R_PPC64_TPREL16_HA
:
6963 case R_PPC64_TPREL16_DS
:
6964 case R_PPC64_TPREL16_LO_DS
:
6965 case R_PPC64_TPREL16_HIGH
:
6966 case R_PPC64_TPREL16_HIGHA
:
6967 case R_PPC64_TPREL16_HIGHER
:
6968 case R_PPC64_TPREL16_HIGHERA
:
6969 case R_PPC64_TPREL16_HIGHEST
:
6970 case R_PPC64_TPREL16_HIGHESTA
:
6971 case R_PPC64_TPREL64
:
6972 case R_PPC64_TPREL34
:
6973 case R_PPC64_DTPMOD64
:
6974 case R_PPC64_DTPREL64
:
6975 case R_PPC64_ADDR64
:
6979 case R_PPC64_ADDR14
:
6980 case R_PPC64_ADDR14_BRNTAKEN
:
6981 case R_PPC64_ADDR14_BRTAKEN
:
6982 case R_PPC64_ADDR16
:
6983 case R_PPC64_ADDR16_DS
:
6984 case R_PPC64_ADDR16_HA
:
6985 case R_PPC64_ADDR16_HI
:
6986 case R_PPC64_ADDR16_HIGH
:
6987 case R_PPC64_ADDR16_HIGHA
:
6988 case R_PPC64_ADDR16_HIGHER
:
6989 case R_PPC64_ADDR16_HIGHERA
:
6990 case R_PPC64_ADDR16_HIGHEST
:
6991 case R_PPC64_ADDR16_HIGHESTA
:
6992 case R_PPC64_ADDR16_LO
:
6993 case R_PPC64_ADDR16_LO_DS
:
6994 case R_PPC64_ADDR24
:
6995 case R_PPC64_ADDR32
:
6996 case R_PPC64_UADDR16
:
6997 case R_PPC64_UADDR32
:
6998 case R_PPC64_UADDR64
:
7001 case R_PPC64_D34_LO
:
7002 case R_PPC64_D34_HI30
:
7003 case R_PPC64_D34_HA30
:
7004 case R_PPC64_ADDR16_HIGHER34
:
7005 case R_PPC64_ADDR16_HIGHERA34
:
7006 case R_PPC64_ADDR16_HIGHEST34
:
7007 case R_PPC64_ADDR16_HIGHESTA34
:
7012 if (local_syms
!= NULL
)
7014 unsigned long r_symndx
;
7015 bfd
*ibfd
= sec
->owner
;
7017 r_symndx
= ELF64_R_SYM (r_info
);
7018 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, local_syms
, r_symndx
, ibfd
))
7023 && (h
->root
.type
== bfd_link_hash_defweak
7024 || !h
->def_regular
))
7026 && !bfd_link_executable (info
)
7027 && !SYMBOLIC_BIND (info
, h
))
7028 || (bfd_link_pic (info
)
7029 && must_be_dyn_reloc (info
, r_type
))
7030 || (!bfd_link_pic (info
)
7032 ? h
->type
== STT_GNU_IFUNC
7033 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)))
7040 struct elf_dyn_relocs
*p
;
7041 struct elf_dyn_relocs
**pp
;
7042 pp
= &ppc_elf_hash_entry (h
)->dyn_relocs
;
7044 /* elf_gc_sweep may have already removed all dyn relocs associated
7045 with local syms for a given section. Also, symbol flags are
7046 changed by elf_gc_sweep_symbol, confusing the test above. Don't
7047 report a dynreloc miscount. */
7048 if (*pp
== NULL
&& info
->gc_sections
)
7051 while ((p
= *pp
) != NULL
)
7055 if (!must_be_dyn_reloc (info
, r_type
))
7067 struct ppc_dyn_relocs
*p
;
7068 struct ppc_dyn_relocs
**pp
;
7070 bfd_boolean is_ifunc
;
7072 if (local_syms
== NULL
)
7073 sym_sec
= bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
7074 if (sym_sec
== NULL
)
7077 vpp
= &elf_section_data (sym_sec
)->local_dynrel
;
7078 pp
= (struct ppc_dyn_relocs
**) vpp
;
7080 if (*pp
== NULL
&& info
->gc_sections
)
7083 is_ifunc
= ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
;
7084 while ((p
= *pp
) != NULL
)
7086 if (p
->sec
== sec
&& p
->ifunc
== is_ifunc
)
7097 /* xgettext:c-format */
7098 _bfd_error_handler (_("dynreloc miscount for %pB, section %pA"),
7100 bfd_set_error (bfd_error_bad_value
);
7104 /* Remove unused Official Procedure Descriptor entries. Currently we
7105 only remove those associated with functions in discarded link-once
7106 sections, or weakly defined functions that have been overridden. It
7107 would be possible to remove many more entries for statically linked
7111 ppc64_elf_edit_opd (struct bfd_link_info
*info
)
7114 bfd_boolean some_edited
= FALSE
;
7115 asection
*need_pad
= NULL
;
7116 struct ppc_link_hash_table
*htab
;
7118 htab
= ppc_hash_table (info
);
7122 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
7125 Elf_Internal_Rela
*relstart
, *rel
, *relend
;
7126 Elf_Internal_Shdr
*symtab_hdr
;
7127 Elf_Internal_Sym
*local_syms
;
7128 struct _opd_sec_data
*opd
;
7129 bfd_boolean need_edit
, add_aux_fields
, broken
;
7130 bfd_size_type cnt_16b
= 0;
7132 if (!is_ppc64_elf (ibfd
))
7135 sec
= bfd_get_section_by_name (ibfd
, ".opd");
7136 if (sec
== NULL
|| sec
->size
== 0)
7139 if (sec
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
7142 if (sec
->output_section
== bfd_abs_section_ptr
)
7145 /* Look through the section relocs. */
7146 if ((sec
->flags
& SEC_RELOC
) == 0 || sec
->reloc_count
== 0)
7150 symtab_hdr
= &elf_symtab_hdr (ibfd
);
7152 /* Read the relocations. */
7153 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
7155 if (relstart
== NULL
)
7158 /* First run through the relocs to check they are sane, and to
7159 determine whether we need to edit this opd section. */
7163 relend
= relstart
+ sec
->reloc_count
;
7164 for (rel
= relstart
; rel
< relend
; )
7166 enum elf_ppc64_reloc_type r_type
;
7167 unsigned long r_symndx
;
7169 struct elf_link_hash_entry
*h
;
7170 Elf_Internal_Sym
*sym
;
7173 /* .opd contains an array of 16 or 24 byte entries. We're
7174 only interested in the reloc pointing to a function entry
7176 offset
= rel
->r_offset
;
7177 if (rel
+ 1 == relend
7178 || rel
[1].r_offset
!= offset
+ 8)
7180 /* If someone messes with .opd alignment then after a
7181 "ld -r" we might have padding in the middle of .opd.
7182 Also, there's nothing to prevent someone putting
7183 something silly in .opd with the assembler. No .opd
7184 optimization for them! */
7187 (_("%pB: .opd is not a regular array of opd entries"), ibfd
);
7192 if ((r_type
= ELF64_R_TYPE (rel
->r_info
)) != R_PPC64_ADDR64
7193 || (r_type
= ELF64_R_TYPE ((rel
+ 1)->r_info
)) != R_PPC64_TOC
)
7196 /* xgettext:c-format */
7197 (_("%pB: unexpected reloc type %u in .opd section"),
7203 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7204 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
7208 if (sym_sec
== NULL
|| sym_sec
->owner
== NULL
)
7210 const char *sym_name
;
7212 sym_name
= h
->root
.root
.string
;
7214 sym_name
= bfd_elf_sym_name (ibfd
, symtab_hdr
, sym
,
7218 /* xgettext:c-format */
7219 (_("%pB: undefined sym `%s' in .opd section"),
7225 /* opd entries are always for functions defined in the
7226 current input bfd. If the symbol isn't defined in the
7227 input bfd, then we won't be using the function in this
7228 bfd; It must be defined in a linkonce section in another
7229 bfd, or is weak. It's also possible that we are
7230 discarding the function due to a linker script /DISCARD/,
7231 which we test for via the output_section. */
7232 if (sym_sec
->owner
!= ibfd
7233 || sym_sec
->output_section
== bfd_abs_section_ptr
)
7237 if (rel
+ 1 == relend
7238 || (rel
+ 2 < relend
7239 && ELF64_R_TYPE (rel
[2].r_info
) == R_PPC64_TOC
))
7244 if (sec
->size
== offset
+ 24)
7249 if (sec
->size
== offset
+ 16)
7256 else if (rel
+ 1 < relend
7257 && ELF64_R_TYPE (rel
[0].r_info
) == R_PPC64_ADDR64
7258 && ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_TOC
)
7260 if (rel
[0].r_offset
== offset
+ 16)
7262 else if (rel
[0].r_offset
!= offset
+ 24)
7269 add_aux_fields
= htab
->params
->non_overlapping_opd
&& cnt_16b
> 0;
7271 if (!broken
&& (need_edit
|| add_aux_fields
))
7273 Elf_Internal_Rela
*write_rel
;
7274 Elf_Internal_Shdr
*rel_hdr
;
7275 bfd_byte
*rptr
, *wptr
;
7276 bfd_byte
*new_contents
;
7279 new_contents
= NULL
;
7280 amt
= OPD_NDX (sec
->size
) * sizeof (long);
7281 opd
= &ppc64_elf_section_data (sec
)->u
.opd
;
7282 opd
->adjust
= bfd_zalloc (sec
->owner
, amt
);
7283 if (opd
->adjust
== NULL
)
7286 /* This seems a waste of time as input .opd sections are all
7287 zeros as generated by gcc, but I suppose there's no reason
7288 this will always be so. We might start putting something in
7289 the third word of .opd entries. */
7290 if ((sec
->flags
& SEC_IN_MEMORY
) == 0)
7293 if (!bfd_malloc_and_get_section (ibfd
, sec
, &loc
))
7298 if (local_syms
!= NULL
7299 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
7301 if (elf_section_data (sec
)->relocs
!= relstart
)
7305 sec
->contents
= loc
;
7306 sec
->flags
|= (SEC_IN_MEMORY
| SEC_HAS_CONTENTS
);
7309 elf_section_data (sec
)->relocs
= relstart
;
7311 new_contents
= sec
->contents
;
7314 new_contents
= bfd_malloc (sec
->size
+ cnt_16b
* 8);
7315 if (new_contents
== NULL
)
7319 wptr
= new_contents
;
7320 rptr
= sec
->contents
;
7321 write_rel
= relstart
;
7322 for (rel
= relstart
; rel
< relend
; )
7324 unsigned long r_symndx
;
7326 struct elf_link_hash_entry
*h
;
7327 struct ppc_link_hash_entry
*fdh
= NULL
;
7328 Elf_Internal_Sym
*sym
;
7330 Elf_Internal_Rela
*next_rel
;
7333 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7334 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
7339 if (next_rel
+ 1 == relend
7340 || (next_rel
+ 2 < relend
7341 && ELF64_R_TYPE (next_rel
[2].r_info
) == R_PPC64_TOC
))
7344 /* See if the .opd entry is full 24 byte or
7345 16 byte (with fd_aux entry overlapped with next
7348 if (next_rel
== relend
)
7350 if (sec
->size
== rel
->r_offset
+ 16)
7353 else if (next_rel
->r_offset
== rel
->r_offset
+ 16)
7357 && h
->root
.root
.string
[0] == '.')
7359 fdh
= ppc_elf_hash_entry (h
)->oh
;
7362 fdh
= ppc_follow_link (fdh
);
7363 if (fdh
->elf
.root
.type
!= bfd_link_hash_defined
7364 && fdh
->elf
.root
.type
!= bfd_link_hash_defweak
)
7369 skip
= (sym_sec
->owner
!= ibfd
7370 || sym_sec
->output_section
== bfd_abs_section_ptr
);
7373 if (fdh
!= NULL
&& sym_sec
->owner
== ibfd
)
7375 /* Arrange for the function descriptor sym
7377 fdh
->elf
.root
.u
.def
.value
= 0;
7378 fdh
->elf
.root
.u
.def
.section
= sym_sec
;
7380 opd
->adjust
[OPD_NDX (rel
->r_offset
)] = -1;
7382 if (NO_OPD_RELOCS
|| bfd_link_relocatable (info
))
7387 if (!dec_dynrel_count (rel
->r_info
, sec
, info
,
7391 if (++rel
== next_rel
)
7394 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7395 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
7402 /* We'll be keeping this opd entry. */
7407 /* Redefine the function descriptor symbol to
7408 this location in the opd section. It is
7409 necessary to update the value here rather
7410 than using an array of adjustments as we do
7411 for local symbols, because various places
7412 in the generic ELF code use the value
7413 stored in u.def.value. */
7414 fdh
->elf
.root
.u
.def
.value
= wptr
- new_contents
;
7415 fdh
->adjust_done
= 1;
7418 /* Local syms are a bit tricky. We could
7419 tweak them as they can be cached, but
7420 we'd need to look through the local syms
7421 for the function descriptor sym which we
7422 don't have at the moment. So keep an
7423 array of adjustments. */
7424 adjust
= (wptr
- new_contents
) - (rptr
- sec
->contents
);
7425 opd
->adjust
[OPD_NDX (rel
->r_offset
)] = adjust
;
7428 memcpy (wptr
, rptr
, opd_ent_size
);
7429 wptr
+= opd_ent_size
;
7430 if (add_aux_fields
&& opd_ent_size
== 16)
7432 memset (wptr
, '\0', 8);
7436 /* We need to adjust any reloc offsets to point to the
7438 for ( ; rel
!= next_rel
; ++rel
)
7440 rel
->r_offset
+= adjust
;
7441 if (write_rel
!= rel
)
7442 memcpy (write_rel
, rel
, sizeof (*rel
));
7447 rptr
+= opd_ent_size
;
7450 sec
->size
= wptr
- new_contents
;
7451 sec
->reloc_count
= write_rel
- relstart
;
7454 free (sec
->contents
);
7455 sec
->contents
= new_contents
;
7458 /* Fudge the header size too, as this is used later in
7459 elf_bfd_final_link if we are emitting relocs. */
7460 rel_hdr
= _bfd_elf_single_rel_hdr (sec
);
7461 rel_hdr
->sh_size
= sec
->reloc_count
* rel_hdr
->sh_entsize
;
7464 else if (elf_section_data (sec
)->relocs
!= relstart
)
7467 if (local_syms
!= NULL
7468 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
7470 if (!info
->keep_memory
)
7473 symtab_hdr
->contents
= (unsigned char *) local_syms
;
7478 elf_link_hash_traverse (elf_hash_table (info
), adjust_opd_syms
, NULL
);
7480 /* If we are doing a final link and the last .opd entry is just 16 byte
7481 long, add a 8 byte padding after it. */
7482 if (need_pad
!= NULL
&& !bfd_link_relocatable (info
))
7486 if ((need_pad
->flags
& SEC_IN_MEMORY
) == 0)
7488 BFD_ASSERT (need_pad
->size
> 0);
7490 p
= bfd_malloc (need_pad
->size
+ 8);
7494 if (!bfd_get_section_contents (need_pad
->owner
, need_pad
,
7495 p
, 0, need_pad
->size
))
7498 need_pad
->contents
= p
;
7499 need_pad
->flags
|= (SEC_IN_MEMORY
| SEC_HAS_CONTENTS
);
7503 p
= bfd_realloc (need_pad
->contents
, need_pad
->size
+ 8);
7507 need_pad
->contents
= p
;
7510 memset (need_pad
->contents
+ need_pad
->size
, 0, 8);
7511 need_pad
->size
+= 8;
7517 /* Analyze inline PLT call relocations to see whether calls to locally
7518 defined functions can be converted to direct calls. */
7521 ppc64_elf_inline_plt (struct bfd_link_info
*info
)
7523 struct ppc_link_hash_table
*htab
;
7526 bfd_vma low_vma
, high_vma
, limit
;
7528 htab
= ppc_hash_table (info
);
7532 /* A bl insn can reach -0x2000000 to 0x1fffffc. The limit is
7533 reduced somewhat to cater for possible stubs that might be added
7534 between the call and its destination. */
7535 if (htab
->params
->group_size
< 0)
7537 limit
= -htab
->params
->group_size
;
7543 limit
= htab
->params
->group_size
;
7550 for (sec
= info
->output_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7551 if ((sec
->flags
& (SEC_ALLOC
| SEC_CODE
)) == (SEC_ALLOC
| SEC_CODE
))
7553 if (low_vma
> sec
->vma
)
7555 if (high_vma
< sec
->vma
+ sec
->size
)
7556 high_vma
= sec
->vma
+ sec
->size
;
7559 /* If a "bl" can reach anywhere in local code sections, then we can
7560 convert all inline PLT sequences to direct calls when the symbol
7562 if (high_vma
- low_vma
< limit
)
7564 htab
->can_convert_all_inline_plt
= 1;
7568 /* Otherwise, go looking through relocs for cases where a direct
7569 call won't reach. Mark the symbol on any such reloc to disable
7570 the optimization and keep the PLT entry as it seems likely that
7571 this will be better than creating trampolines. Note that this
7572 will disable the optimization for all inline PLT calls to a
7573 particular symbol, not just those that won't reach. The
7574 difficulty in doing a more precise optimization is that the
7575 linker needs to make a decision depending on whether a
7576 particular R_PPC64_PLTCALL insn can be turned into a direct
7577 call, for each of the R_PPC64_PLTSEQ and R_PPC64_PLT16* insns in
7578 the sequence, and there is nothing that ties those relocs
7579 together except their symbol. */
7581 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
7583 Elf_Internal_Shdr
*symtab_hdr
;
7584 Elf_Internal_Sym
*local_syms
;
7586 if (!is_ppc64_elf (ibfd
))
7590 symtab_hdr
= &elf_symtab_hdr (ibfd
);
7592 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7593 if (ppc64_elf_section_data (sec
)->has_pltcall
7594 && !bfd_is_abs_section (sec
->output_section
))
7596 Elf_Internal_Rela
*relstart
, *rel
, *relend
;
7598 /* Read the relocations. */
7599 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
7601 if (relstart
== NULL
)
7604 relend
= relstart
+ sec
->reloc_count
;
7605 for (rel
= relstart
; rel
< relend
; )
7607 enum elf_ppc64_reloc_type r_type
;
7608 unsigned long r_symndx
;
7610 struct elf_link_hash_entry
*h
;
7611 Elf_Internal_Sym
*sym
;
7612 unsigned char *tls_maskp
;
7614 r_type
= ELF64_R_TYPE (rel
->r_info
);
7615 if (r_type
!= R_PPC64_PLTCALL
7616 && r_type
!= R_PPC64_PLTCALL_NOTOC
)
7619 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7620 if (!get_sym_h (&h
, &sym
, &sym_sec
, &tls_maskp
, &local_syms
,
7623 if (elf_section_data (sec
)->relocs
!= relstart
)
7625 if (local_syms
!= NULL
7626 && symtab_hdr
->contents
!= (bfd_byte
*) local_syms
)
7631 if (sym_sec
!= NULL
&& sym_sec
->output_section
!= NULL
)
7635 to
= h
->root
.u
.def
.value
;
7638 to
+= (rel
->r_addend
7639 + sym_sec
->output_offset
7640 + sym_sec
->output_section
->vma
);
7641 from
= (rel
->r_offset
7642 + sec
->output_offset
7643 + sec
->output_section
->vma
);
7644 if (to
- from
+ limit
< 2 * limit
7645 && !(r_type
== R_PPC64_PLTCALL_NOTOC
7646 && (((h
? h
->other
: sym
->st_other
)
7647 & STO_PPC64_LOCAL_MASK
)
7648 > 1 << STO_PPC64_LOCAL_BIT
)))
7649 *tls_maskp
&= ~PLT_KEEP
;
7652 if (elf_section_data (sec
)->relocs
!= relstart
)
7656 if (local_syms
!= NULL
7657 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
7659 if (!info
->keep_memory
)
7662 symtab_hdr
->contents
= (unsigned char *) local_syms
;
7669 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
7672 ppc64_elf_tls_setup (struct bfd_link_info
*info
)
7674 struct ppc_link_hash_table
*htab
;
7675 struct elf_link_hash_entry
*tga
, *tga_fd
, *desc
, *desc_fd
;
7677 htab
= ppc_hash_table (info
);
7681 if (abiversion (info
->output_bfd
) == 1)
7684 if (htab
->params
->no_multi_toc
)
7685 htab
->do_multi_toc
= 0;
7686 else if (!htab
->do_multi_toc
)
7687 htab
->params
->no_multi_toc
= 1;
7689 /* Default to --no-plt-localentry, as this option can cause problems
7690 with symbol interposition. For example, glibc libpthread.so and
7691 libc.so duplicate many pthread symbols, with a fallback
7692 implementation in libc.so. In some cases the fallback does more
7693 work than the pthread implementation. __pthread_condattr_destroy
7694 is one such symbol: the libpthread.so implementation is
7695 localentry:0 while the libc.so implementation is localentry:8.
7696 An app that "cleverly" uses dlopen to only load necessary
7697 libraries at runtime may omit loading libpthread.so when not
7698 running multi-threaded, which then results in the libc.so
7699 fallback symbols being used and ld.so complaining. Now there
7700 are workarounds in ld (see non_zero_localentry) to detect the
7701 pthread situation, but that may not be the only case where
7702 --plt-localentry can cause trouble. */
7703 if (htab
->params
->plt_localentry0
< 0)
7704 htab
->params
->plt_localentry0
= 0;
7705 if (htab
->params
->plt_localentry0
7706 && elf_link_hash_lookup (&htab
->elf
, "GLIBC_2.26",
7707 FALSE
, FALSE
, FALSE
) == NULL
)
7709 (_("warning: --plt-localentry is especially dangerous without "
7710 "ld.so support to detect ABI violations"));
7712 tga
= elf_link_hash_lookup (&htab
->elf
, ".__tls_get_addr",
7713 FALSE
, FALSE
, TRUE
);
7714 htab
->tls_get_addr
= ppc_elf_hash_entry (tga
);
7716 /* Move dynamic linking info to the function descriptor sym. */
7718 func_desc_adjust (tga
, info
);
7719 tga_fd
= elf_link_hash_lookup (&htab
->elf
, "__tls_get_addr",
7720 FALSE
, FALSE
, TRUE
);
7721 htab
->tls_get_addr_fd
= ppc_elf_hash_entry (tga_fd
);
7723 desc
= elf_link_hash_lookup (&htab
->elf
, ".__tls_get_addr_desc",
7724 FALSE
, FALSE
, TRUE
);
7725 htab
->tga_desc
= ppc_elf_hash_entry (desc
);
7727 func_desc_adjust (desc
, info
);
7728 desc_fd
= elf_link_hash_lookup (&htab
->elf
, "__tls_get_addr_desc",
7729 FALSE
, FALSE
, TRUE
);
7730 htab
->tga_desc_fd
= ppc_elf_hash_entry (desc_fd
);
7732 if (htab
->params
->tls_get_addr_opt
)
7734 struct elf_link_hash_entry
*opt
, *opt_fd
;
7736 opt
= elf_link_hash_lookup (&htab
->elf
, ".__tls_get_addr_opt",
7737 FALSE
, FALSE
, TRUE
);
7739 func_desc_adjust (opt
, info
);
7740 opt_fd
= elf_link_hash_lookup (&htab
->elf
, "__tls_get_addr_opt",
7741 FALSE
, FALSE
, TRUE
);
7743 && (opt_fd
->root
.type
== bfd_link_hash_defined
7744 || opt_fd
->root
.type
== bfd_link_hash_defweak
))
7746 /* If glibc supports an optimized __tls_get_addr call stub,
7747 signalled by the presence of __tls_get_addr_opt, and we'll
7748 be calling __tls_get_addr via a plt call stub, then
7749 make __tls_get_addr point to __tls_get_addr_opt. */
7750 if (!(htab
->elf
.dynamic_sections_created
7752 && (tga_fd
->type
== STT_FUNC
7753 || tga_fd
->needs_plt
)
7754 && !(SYMBOL_CALLS_LOCAL (info
, tga_fd
)
7755 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, tga_fd
))))
7757 if (!(htab
->elf
.dynamic_sections_created
7759 && (desc_fd
->type
== STT_FUNC
7760 || desc_fd
->needs_plt
)
7761 && !(SYMBOL_CALLS_LOCAL (info
, desc_fd
)
7762 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, desc_fd
))))
7765 if (tga_fd
!= NULL
|| desc_fd
!= NULL
)
7767 struct plt_entry
*ent
= NULL
;
7770 for (ent
= tga_fd
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
7771 if (ent
->plt
.refcount
> 0)
7773 if (ent
== NULL
&& desc_fd
!= NULL
)
7774 for (ent
= desc_fd
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
7775 if (ent
->plt
.refcount
> 0)
7781 tga_fd
->root
.type
= bfd_link_hash_indirect
;
7782 tga_fd
->root
.u
.i
.link
= &opt_fd
->root
;
7783 tga_fd
->root
.u
.i
.warning
= NULL
;
7784 ppc64_elf_copy_indirect_symbol (info
, opt_fd
, tga_fd
);
7786 if (desc_fd
!= NULL
)
7788 desc_fd
->root
.type
= bfd_link_hash_indirect
;
7789 desc_fd
->root
.u
.i
.link
= &opt_fd
->root
;
7790 desc_fd
->root
.u
.i
.warning
= NULL
;
7791 ppc64_elf_copy_indirect_symbol (info
, opt_fd
, desc_fd
);
7794 if (opt_fd
->dynindx
!= -1)
7796 /* Use __tls_get_addr_opt in dynamic relocations. */
7797 opt_fd
->dynindx
= -1;
7798 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
7799 opt_fd
->dynstr_index
);
7800 if (!bfd_elf_link_record_dynamic_symbol (info
, opt_fd
))
7805 htab
->tls_get_addr_fd
= ppc_elf_hash_entry (opt_fd
);
7806 tga
= &htab
->tls_get_addr
->elf
;
7807 if (opt
!= NULL
&& tga
!= NULL
)
7809 tga
->root
.type
= bfd_link_hash_indirect
;
7810 tga
->root
.u
.i
.link
= &opt
->root
;
7811 tga
->root
.u
.i
.warning
= NULL
;
7812 ppc64_elf_copy_indirect_symbol (info
, opt
, tga
);
7814 _bfd_elf_link_hash_hide_symbol (info
, opt
,
7816 htab
->tls_get_addr
= ppc_elf_hash_entry (opt
);
7818 htab
->tls_get_addr_fd
->oh
= htab
->tls_get_addr
;
7819 htab
->tls_get_addr_fd
->is_func_descriptor
= 1;
7820 if (htab
->tls_get_addr
!= NULL
)
7822 htab
->tls_get_addr
->oh
= htab
->tls_get_addr_fd
;
7823 htab
->tls_get_addr
->is_func
= 1;
7826 if (desc_fd
!= NULL
)
7828 htab
->tga_desc_fd
= ppc_elf_hash_entry (opt_fd
);
7829 if (opt
!= NULL
&& desc
!= NULL
)
7831 desc
->root
.type
= bfd_link_hash_indirect
;
7832 desc
->root
.u
.i
.link
= &opt
->root
;
7833 desc
->root
.u
.i
.warning
= NULL
;
7834 ppc64_elf_copy_indirect_symbol (info
, opt
, desc
);
7836 _bfd_elf_link_hash_hide_symbol (info
, opt
,
7837 desc
->forced_local
);
7838 htab
->tga_desc
= ppc_elf_hash_entry (opt
);
7840 htab
->tga_desc_fd
->oh
= htab
->tga_desc
;
7841 htab
->tga_desc_fd
->is_func_descriptor
= 1;
7842 if (htab
->tga_desc
!= NULL
)
7844 htab
->tga_desc
->oh
= htab
->tga_desc_fd
;
7845 htab
->tga_desc
->is_func
= 1;
7851 else if (htab
->params
->tls_get_addr_opt
< 0)
7852 htab
->params
->tls_get_addr_opt
= 0;
7855 if (htab
->tga_desc_fd
!= NULL
7856 && htab
->params
->tls_get_addr_opt
7857 && htab
->params
->no_tls_get_addr_regsave
== -1)
7858 htab
->params
->no_tls_get_addr_regsave
= 0;
7860 return _bfd_elf_tls_setup (info
->output_bfd
, info
);
7863 /* Return TRUE iff REL is a branch reloc with a global symbol matching
7864 any of HASH1, HASH2, HASH3, or HASH4. */
7867 branch_reloc_hash_match (const bfd
*ibfd
,
7868 const Elf_Internal_Rela
*rel
,
7869 const struct ppc_link_hash_entry
*hash1
,
7870 const struct ppc_link_hash_entry
*hash2
,
7871 const struct ppc_link_hash_entry
*hash3
,
7872 const struct ppc_link_hash_entry
*hash4
)
7874 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (ibfd
);
7875 enum elf_ppc64_reloc_type r_type
= ELF64_R_TYPE (rel
->r_info
);
7876 unsigned int r_symndx
= ELF64_R_SYM (rel
->r_info
);
7878 if (r_symndx
>= symtab_hdr
->sh_info
&& is_branch_reloc (r_type
))
7880 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (ibfd
);
7881 struct elf_link_hash_entry
*h
;
7883 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
7884 h
= elf_follow_link (h
);
7885 if (h
== &hash1
->elf
|| h
== &hash2
->elf
7886 || h
== &hash3
->elf
|| h
== &hash4
->elf
)
7892 /* Run through all the TLS relocs looking for optimization
7893 opportunities. The linker has been hacked (see ppc64elf.em) to do
7894 a preliminary section layout so that we know the TLS segment
7895 offsets. We can't optimize earlier because some optimizations need
7896 to know the tp offset, and we need to optimize before allocating
7897 dynamic relocations. */
7900 ppc64_elf_tls_optimize (struct bfd_link_info
*info
)
7904 struct ppc_link_hash_table
*htab
;
7905 unsigned char *toc_ref
;
7908 if (!bfd_link_executable (info
))
7911 htab
= ppc_hash_table (info
);
7915 /* Make two passes over the relocs. On the first pass, mark toc
7916 entries involved with tls relocs, and check that tls relocs
7917 involved in setting up a tls_get_addr call are indeed followed by
7918 such a call. If they are not, we can't do any tls optimization.
7919 On the second pass twiddle tls_mask flags to notify
7920 relocate_section that optimization can be done, and adjust got
7921 and plt refcounts. */
7923 for (pass
= 0; pass
< 2; ++pass
)
7924 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
7926 Elf_Internal_Sym
*locsyms
= NULL
;
7927 asection
*toc
= bfd_get_section_by_name (ibfd
, ".toc");
7929 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7930 if (sec
->has_tls_reloc
&& !bfd_is_abs_section (sec
->output_section
))
7932 Elf_Internal_Rela
*relstart
, *rel
, *relend
;
7933 bfd_boolean found_tls_get_addr_arg
= 0;
7935 /* Read the relocations. */
7936 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
7938 if (relstart
== NULL
)
7944 relend
= relstart
+ sec
->reloc_count
;
7945 for (rel
= relstart
; rel
< relend
; rel
++)
7947 enum elf_ppc64_reloc_type r_type
;
7948 unsigned long r_symndx
;
7949 struct elf_link_hash_entry
*h
;
7950 Elf_Internal_Sym
*sym
;
7952 unsigned char *tls_mask
;
7953 unsigned int tls_set
, tls_clear
, tls_type
= 0;
7955 bfd_boolean ok_tprel
, is_local
;
7956 long toc_ref_index
= 0;
7957 int expecting_tls_get_addr
= 0;
7958 bfd_boolean ret
= FALSE
;
7960 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7961 if (!get_sym_h (&h
, &sym
, &sym_sec
, &tls_mask
, &locsyms
,
7965 if (elf_section_data (sec
)->relocs
!= relstart
)
7967 if (toc_ref
!= NULL
)
7970 && (elf_symtab_hdr (ibfd
).contents
7971 != (unsigned char *) locsyms
))
7978 if (h
->root
.type
== bfd_link_hash_defined
7979 || h
->root
.type
== bfd_link_hash_defweak
)
7980 value
= h
->root
.u
.def
.value
;
7981 else if (h
->root
.type
== bfd_link_hash_undefweak
)
7985 found_tls_get_addr_arg
= 0;
7990 /* Symbols referenced by TLS relocs must be of type
7991 STT_TLS. So no need for .opd local sym adjust. */
7992 value
= sym
->st_value
;
7995 is_local
= SYMBOL_REFERENCES_LOCAL (info
, h
);
7999 && h
->root
.type
== bfd_link_hash_undefweak
)
8001 else if (sym_sec
!= NULL
8002 && sym_sec
->output_section
!= NULL
)
8004 value
+= sym_sec
->output_offset
;
8005 value
+= sym_sec
->output_section
->vma
;
8006 value
-= htab
->elf
.tls_sec
->vma
+ TP_OFFSET
;
8007 /* Note that even though the prefix insns
8008 allow a 1<<33 offset we use the same test
8009 as for addis;addi. There may be a mix of
8010 pcrel and non-pcrel code and the decision
8011 to optimise is per symbol, not per TLS
8013 ok_tprel
= value
+ 0x80008000ULL
< 1ULL << 32;
8017 r_type
= ELF64_R_TYPE (rel
->r_info
);
8018 /* If this section has old-style __tls_get_addr calls
8019 without marker relocs, then check that each
8020 __tls_get_addr call reloc is preceded by a reloc
8021 that conceivably belongs to the __tls_get_addr arg
8022 setup insn. If we don't find matching arg setup
8023 relocs, don't do any tls optimization. */
8025 && sec
->nomark_tls_get_addr
8027 && is_tls_get_addr (h
, htab
)
8028 && !found_tls_get_addr_arg
8029 && is_branch_reloc (r_type
))
8031 info
->callbacks
->minfo (_("%H __tls_get_addr lost arg, "
8032 "TLS optimization disabled\n"),
8033 ibfd
, sec
, rel
->r_offset
);
8038 found_tls_get_addr_arg
= 0;
8041 case R_PPC64_GOT_TLSLD16
:
8042 case R_PPC64_GOT_TLSLD16_LO
:
8043 case R_PPC64_GOT_TLSLD34
:
8044 expecting_tls_get_addr
= 1;
8045 found_tls_get_addr_arg
= 1;
8048 case R_PPC64_GOT_TLSLD16_HI
:
8049 case R_PPC64_GOT_TLSLD16_HA
:
8050 /* These relocs should never be against a symbol
8051 defined in a shared lib. Leave them alone if
8052 that turns out to be the case. */
8059 tls_type
= TLS_TLS
| TLS_LD
;
8062 case R_PPC64_GOT_TLSGD16
:
8063 case R_PPC64_GOT_TLSGD16_LO
:
8064 case R_PPC64_GOT_TLSGD34
:
8065 expecting_tls_get_addr
= 1;
8066 found_tls_get_addr_arg
= 1;
8069 case R_PPC64_GOT_TLSGD16_HI
:
8070 case R_PPC64_GOT_TLSGD16_HA
:
8076 tls_set
= TLS_TLS
| TLS_GDIE
;
8078 tls_type
= TLS_TLS
| TLS_GD
;
8081 case R_PPC64_GOT_TPREL34
:
8082 case R_PPC64_GOT_TPREL16_DS
:
8083 case R_PPC64_GOT_TPREL16_LO_DS
:
8084 case R_PPC64_GOT_TPREL16_HI
:
8085 case R_PPC64_GOT_TPREL16_HA
:
8090 tls_clear
= TLS_TPREL
;
8091 tls_type
= TLS_TLS
| TLS_TPREL
;
8101 if (rel
+ 1 < relend
8102 && is_plt_seq_reloc (ELF64_R_TYPE (rel
[1].r_info
)))
8105 && (ELF64_R_TYPE (rel
[1].r_info
)
8107 && (ELF64_R_TYPE (rel
[1].r_info
)
8108 != R_PPC64_PLTSEQ_NOTOC
))
8110 r_symndx
= ELF64_R_SYM (rel
[1].r_info
);
8111 if (!get_sym_h (&h
, NULL
, NULL
, NULL
, &locsyms
,
8116 struct plt_entry
*ent
= NULL
;
8118 for (ent
= h
->plt
.plist
;
8121 if (ent
->addend
== rel
[1].r_addend
)
8125 && ent
->plt
.refcount
> 0)
8126 ent
->plt
.refcount
-= 1;
8131 found_tls_get_addr_arg
= 1;
8136 case R_PPC64_TOC16_LO
:
8137 if (sym_sec
== NULL
|| sym_sec
!= toc
)
8140 /* Mark this toc entry as referenced by a TLS
8141 code sequence. We can do that now in the
8142 case of R_PPC64_TLS, and after checking for
8143 tls_get_addr for the TOC16 relocs. */
8144 if (toc_ref
== NULL
)
8146 = bfd_zmalloc (toc
->output_section
->rawsize
/ 8);
8147 if (toc_ref
== NULL
)
8151 value
= h
->root
.u
.def
.value
;
8153 value
= sym
->st_value
;
8154 value
+= rel
->r_addend
;
8157 BFD_ASSERT (value
< toc
->size
8158 && toc
->output_offset
% 8 == 0);
8159 toc_ref_index
= (value
+ toc
->output_offset
) / 8;
8160 if (r_type
== R_PPC64_TLS
8161 || r_type
== R_PPC64_TLSGD
8162 || r_type
== R_PPC64_TLSLD
)
8164 toc_ref
[toc_ref_index
] = 1;
8168 if (pass
!= 0 && toc_ref
[toc_ref_index
] == 0)
8173 expecting_tls_get_addr
= 2;
8176 case R_PPC64_TPREL64
:
8180 || !toc_ref
[(rel
->r_offset
+ toc
->output_offset
) / 8])
8185 tls_set
= TLS_EXPLICIT
;
8186 tls_clear
= TLS_TPREL
;
8191 case R_PPC64_DTPMOD64
:
8195 || !toc_ref
[(rel
->r_offset
+ toc
->output_offset
) / 8])
8197 if (rel
+ 1 < relend
8199 == ELF64_R_INFO (r_symndx
, R_PPC64_DTPREL64
))
8200 && rel
[1].r_offset
== rel
->r_offset
+ 8)
8204 tls_set
= TLS_EXPLICIT
| TLS_GD
;
8207 tls_set
= TLS_EXPLICIT
| TLS_GD
| TLS_GDIE
;
8216 tls_set
= TLS_EXPLICIT
;
8227 if (!expecting_tls_get_addr
8228 || !sec
->nomark_tls_get_addr
)
8231 if (rel
+ 1 < relend
8232 && branch_reloc_hash_match (ibfd
, rel
+ 1,
8233 htab
->tls_get_addr_fd
,
8238 if (expecting_tls_get_addr
== 2)
8240 /* Check for toc tls entries. */
8241 unsigned char *toc_tls
;
8244 retval
= get_tls_mask (&toc_tls
, NULL
, NULL
,
8249 if (toc_tls
!= NULL
)
8251 if ((*toc_tls
& TLS_TLS
) != 0
8252 && ((*toc_tls
& (TLS_GD
| TLS_LD
)) != 0))
8253 found_tls_get_addr_arg
= 1;
8255 toc_ref
[toc_ref_index
] = 1;
8261 /* Uh oh, we didn't find the expected call. We
8262 could just mark this symbol to exclude it
8263 from tls optimization but it's safer to skip
8264 the entire optimization. */
8265 /* xgettext:c-format */
8266 info
->callbacks
->minfo (_("%H arg lost __tls_get_addr, "
8267 "TLS optimization disabled\n"),
8268 ibfd
, sec
, rel
->r_offset
);
8273 /* If we don't have old-style __tls_get_addr calls
8274 without TLSGD/TLSLD marker relocs, and we haven't
8275 found a new-style __tls_get_addr call with a
8276 marker for this symbol, then we either have a
8277 broken object file or an -mlongcall style
8278 indirect call to __tls_get_addr without a marker.
8279 Disable optimization in this case. */
8280 if ((tls_clear
& (TLS_GD
| TLS_LD
)) != 0
8281 && (tls_set
& TLS_EXPLICIT
) == 0
8282 && !sec
->nomark_tls_get_addr
8283 && ((*tls_mask
& (TLS_TLS
| TLS_MARK
))
8284 != (TLS_TLS
| TLS_MARK
)))
8287 if (expecting_tls_get_addr
== 1 + !sec
->nomark_tls_get_addr
)
8289 struct plt_entry
*ent
= NULL
;
8291 if (htab
->tls_get_addr_fd
!= NULL
)
8292 for (ent
= htab
->tls_get_addr_fd
->elf
.plt
.plist
;
8295 if (ent
->addend
== 0)
8298 if (ent
== NULL
&& htab
->tga_desc_fd
!= NULL
)
8299 for (ent
= htab
->tga_desc_fd
->elf
.plt
.plist
;
8302 if (ent
->addend
== 0)
8305 if (ent
== NULL
&& htab
->tls_get_addr
!= NULL
)
8306 for (ent
= htab
->tls_get_addr
->elf
.plt
.plist
;
8309 if (ent
->addend
== 0)
8312 if (ent
== NULL
&& htab
->tga_desc
!= NULL
)
8313 for (ent
= htab
->tga_desc
->elf
.plt
.plist
;
8316 if (ent
->addend
== 0)
8320 && ent
->plt
.refcount
> 0)
8321 ent
->plt
.refcount
-= 1;
8327 if ((tls_set
& TLS_EXPLICIT
) == 0)
8329 struct got_entry
*ent
;
8331 /* Adjust got entry for this reloc. */
8335 ent
= elf_local_got_ents (ibfd
)[r_symndx
];
8337 for (; ent
!= NULL
; ent
= ent
->next
)
8338 if (ent
->addend
== rel
->r_addend
8339 && ent
->owner
== ibfd
8340 && ent
->tls_type
== tls_type
)
8347 /* We managed to get rid of a got entry. */
8348 if (ent
->got
.refcount
> 0)
8349 ent
->got
.refcount
-= 1;
8354 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8355 we'll lose one or two dyn relocs. */
8356 if (!dec_dynrel_count (rel
->r_info
, sec
, info
,
8360 if (tls_set
== (TLS_EXPLICIT
| TLS_GD
))
8362 if (!dec_dynrel_count ((rel
+ 1)->r_info
, sec
, info
,
8368 *tls_mask
|= tls_set
& 0xff;
8369 *tls_mask
&= ~tls_clear
;
8372 if (elf_section_data (sec
)->relocs
!= relstart
)
8377 && (elf_symtab_hdr (ibfd
).contents
!= (unsigned char *) locsyms
))
8379 if (!info
->keep_memory
)
8382 elf_symtab_hdr (ibfd
).contents
= (unsigned char *) locsyms
;
8386 if (toc_ref
!= NULL
)
8388 htab
->do_tls_opt
= 1;
8392 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8393 the values of any global symbols in a toc section that has been
8394 edited. Globals in toc sections should be a rarity, so this function
8395 sets a flag if any are found in toc sections other than the one just
8396 edited, so that further hash table traversals can be avoided. */
8398 struct adjust_toc_info
8401 unsigned long *skip
;
8402 bfd_boolean global_toc_syms
;
8405 enum toc_skip_enum
{ ref_from_discarded
= 1, can_optimize
= 2 };
8408 adjust_toc_syms (struct elf_link_hash_entry
*h
, void *inf
)
8410 struct ppc_link_hash_entry
*eh
;
8411 struct adjust_toc_info
*toc_inf
= (struct adjust_toc_info
*) inf
;
8414 if (h
->root
.type
!= bfd_link_hash_defined
8415 && h
->root
.type
!= bfd_link_hash_defweak
)
8418 eh
= ppc_elf_hash_entry (h
);
8419 if (eh
->adjust_done
)
8422 if (eh
->elf
.root
.u
.def
.section
== toc_inf
->toc
)
8424 if (eh
->elf
.root
.u
.def
.value
> toc_inf
->toc
->rawsize
)
8425 i
= toc_inf
->toc
->rawsize
>> 3;
8427 i
= eh
->elf
.root
.u
.def
.value
>> 3;
8429 if ((toc_inf
->skip
[i
] & (ref_from_discarded
| can_optimize
)) != 0)
8432 (_("%s defined on removed toc entry"), eh
->elf
.root
.root
.string
);
8435 while ((toc_inf
->skip
[i
] & (ref_from_discarded
| can_optimize
)) != 0);
8436 eh
->elf
.root
.u
.def
.value
= (bfd_vma
) i
<< 3;
8439 eh
->elf
.root
.u
.def
.value
-= toc_inf
->skip
[i
];
8440 eh
->adjust_done
= 1;
8442 else if (strcmp (eh
->elf
.root
.u
.def
.section
->name
, ".toc") == 0)
8443 toc_inf
->global_toc_syms
= TRUE
;
8448 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
8449 on a _LO variety toc/got reloc. */
8452 ok_lo_toc_insn (unsigned int insn
, enum elf_ppc64_reloc_type r_type
)
8454 return ((insn
& (0x3fu
<< 26)) == 12u << 26 /* addic */
8455 || (insn
& (0x3fu
<< 26)) == 14u << 26 /* addi */
8456 || (insn
& (0x3fu
<< 26)) == 32u << 26 /* lwz */
8457 || (insn
& (0x3fu
<< 26)) == 34u << 26 /* lbz */
8458 || (insn
& (0x3fu
<< 26)) == 36u << 26 /* stw */
8459 || (insn
& (0x3fu
<< 26)) == 38u << 26 /* stb */
8460 || (insn
& (0x3fu
<< 26)) == 40u << 26 /* lhz */
8461 || (insn
& (0x3fu
<< 26)) == 42u << 26 /* lha */
8462 || (insn
& (0x3fu
<< 26)) == 44u << 26 /* sth */
8463 || (insn
& (0x3fu
<< 26)) == 46u << 26 /* lmw */
8464 || (insn
& (0x3fu
<< 26)) == 47u << 26 /* stmw */
8465 || (insn
& (0x3fu
<< 26)) == 48u << 26 /* lfs */
8466 || (insn
& (0x3fu
<< 26)) == 50u << 26 /* lfd */
8467 || (insn
& (0x3fu
<< 26)) == 52u << 26 /* stfs */
8468 || (insn
& (0x3fu
<< 26)) == 54u << 26 /* stfd */
8469 || (insn
& (0x3fu
<< 26)) == 56u << 26 /* lq,lfq */
8470 || ((insn
& (0x3fu
<< 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
8471 /* Exclude lfqu by testing reloc. If relocs are ever
8472 defined for the reduced D field in psq_lu then those
8473 will need testing too. */
8474 && r_type
!= R_PPC64_TOC16_LO
&& r_type
!= R_PPC64_GOT16_LO
)
8475 || ((insn
& (0x3fu
<< 26)) == 58u << 26 /* ld,lwa */
8477 || (insn
& (0x3fu
<< 26)) == 60u << 26 /* stfq */
8478 || ((insn
& (0x3fu
<< 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
8479 /* Exclude stfqu. psq_stu as above for psq_lu. */
8480 && r_type
!= R_PPC64_TOC16_LO
&& r_type
!= R_PPC64_GOT16_LO
)
8481 || ((insn
& (0x3fu
<< 26)) == 62u << 26 /* std,stq */
8482 && (insn
& 1) == 0));
8485 /* PCREL_OPT in one instance flags to the linker that a pair of insns:
8486 pld ra,symbol@got@pcrel
8487 load/store rt,off(ra)
8490 load/store rt,off(ra)
8491 may be translated to
8492 pload/pstore rt,symbol+off@pcrel
8494 This function returns true if the optimization is possible, placing
8495 the prefix insn in *PINSN1, a NOP in *PINSN2 and the offset in *POFF.
8497 On entry to this function, the linker has already determined that
8498 the pld can be replaced with pla: *PINSN1 is that pla insn,
8499 while *PINSN2 is the second instruction. */
8502 xlate_pcrel_opt (uint64_t *pinsn1
, uint64_t *pinsn2
, bfd_signed_vma
*poff
)
8504 uint64_t insn1
= *pinsn1
;
8505 uint64_t insn2
= *pinsn2
;
8508 if ((insn2
& (63ULL << 58)) == 1ULL << 58)
8510 /* Check that regs match. */
8511 if (((insn2
>> 16) & 31) != ((insn1
>> 21) & 31))
8514 /* P8LS or PMLS form, non-pcrel. */
8515 if ((insn2
& (-1ULL << 50) & ~(1ULL << 56)) != (1ULL << 58))
8518 *pinsn1
= (insn2
& ~(31 << 16) & ~0x3ffff0000ffffULL
) | (1ULL << 52);
8520 off
= ((insn2
>> 16) & 0x3ffff0000ULL
) | (insn2
& 0xffff);
8521 *poff
= (off
^ 0x200000000ULL
) - 0x200000000ULL
;
8527 /* Check that regs match. */
8528 if (((insn2
>> 16) & 31) != ((insn1
>> 21) & 31))
8531 switch ((insn2
>> 26) & 63)
8547 /* These are the PMLS cases, where we just need to tack a prefix
8549 insn1
= ((1ULL << 58) | (2ULL << 56) | (1ULL << 52)
8550 | (insn2
& ((63ULL << 26) | (31ULL << 21))));
8551 off
= insn2
& 0xffff;
8554 case 58: /* lwa, ld */
8555 if ((insn2
& 1) != 0)
8557 insn1
= ((1ULL << 58) | (1ULL << 52)
8558 | (insn2
& 2 ? 41ULL << 26 : 57ULL << 26)
8559 | (insn2
& (31ULL << 21)));
8560 off
= insn2
& 0xfffc;
8563 case 57: /* lxsd, lxssp */
8564 if ((insn2
& 3) < 2)
8566 insn1
= ((1ULL << 58) | (1ULL << 52)
8567 | ((40ULL | (insn2
& 3)) << 26)
8568 | (insn2
& (31ULL << 21)));
8569 off
= insn2
& 0xfffc;
8572 case 61: /* stxsd, stxssp, lxv, stxv */
8573 if ((insn2
& 3) == 0)
8575 else if ((insn2
& 3) >= 2)
8577 insn1
= ((1ULL << 58) | (1ULL << 52)
8578 | ((44ULL | (insn2
& 3)) << 26)
8579 | (insn2
& (31ULL << 21)));
8580 off
= insn2
& 0xfffc;
8584 insn1
= ((1ULL << 58) | (1ULL << 52)
8585 | ((50ULL | (insn2
& 4) | ((insn2
& 8) >> 3)) << 26)
8586 | (insn2
& (31ULL << 21)));
8587 off
= insn2
& 0xfff0;
8592 insn1
= ((1ULL << 58) | (1ULL << 52)
8593 | (insn2
& ((63ULL << 26) | (31ULL << 21))));
8594 off
= insn2
& 0xffff;
8597 case 62: /* std, stq */
8598 if ((insn2
& 1) != 0)
8600 insn1
= ((1ULL << 58) | (1ULL << 52)
8601 | ((insn2
& 2) == 0 ? 61ULL << 26 : 60ULL << 26)
8602 | (insn2
& (31ULL << 21)));
8603 off
= insn2
& 0xfffc;
8608 *pinsn2
= (uint64_t) NOP
<< 32;
8609 *poff
= (off
^ 0x8000) - 0x8000;
8613 /* Examine all relocs referencing .toc sections in order to remove
8614 unused .toc entries. */
8617 ppc64_elf_edit_toc (struct bfd_link_info
*info
)
8620 struct adjust_toc_info toc_inf
;
8621 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
8623 htab
->do_toc_opt
= 1;
8624 toc_inf
.global_toc_syms
= TRUE
;
8625 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
8627 asection
*toc
, *sec
;
8628 Elf_Internal_Shdr
*symtab_hdr
;
8629 Elf_Internal_Sym
*local_syms
;
8630 Elf_Internal_Rela
*relstart
, *rel
, *toc_relocs
;
8631 unsigned long *skip
, *drop
;
8632 unsigned char *used
;
8633 unsigned char *keep
, last
, some_unused
;
8635 if (!is_ppc64_elf (ibfd
))
8638 toc
= bfd_get_section_by_name (ibfd
, ".toc");
8641 || toc
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
8642 || discarded_section (toc
))
8647 symtab_hdr
= &elf_symtab_hdr (ibfd
);
8649 /* Look at sections dropped from the final link. */
8652 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
8654 if (sec
->reloc_count
== 0
8655 || !discarded_section (sec
)
8656 || get_opd_info (sec
)
8657 || (sec
->flags
& SEC_ALLOC
) == 0
8658 || (sec
->flags
& SEC_DEBUGGING
) != 0)
8661 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
, FALSE
);
8662 if (relstart
== NULL
)
8665 /* Run through the relocs to see which toc entries might be
8667 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
8669 enum elf_ppc64_reloc_type r_type
;
8670 unsigned long r_symndx
;
8672 struct elf_link_hash_entry
*h
;
8673 Elf_Internal_Sym
*sym
;
8676 r_type
= ELF64_R_TYPE (rel
->r_info
);
8683 case R_PPC64_TOC16_LO
:
8684 case R_PPC64_TOC16_HI
:
8685 case R_PPC64_TOC16_HA
:
8686 case R_PPC64_TOC16_DS
:
8687 case R_PPC64_TOC16_LO_DS
:
8691 r_symndx
= ELF64_R_SYM (rel
->r_info
);
8692 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
8700 val
= h
->root
.u
.def
.value
;
8702 val
= sym
->st_value
;
8703 val
+= rel
->r_addend
;
8705 if (val
>= toc
->size
)
8708 /* Anything in the toc ought to be aligned to 8 bytes.
8709 If not, don't mark as unused. */
8715 skip
= bfd_zmalloc (sizeof (*skip
) * (toc
->size
+ 15) / 8);
8720 skip
[val
>> 3] = ref_from_discarded
;
8723 if (elf_section_data (sec
)->relocs
!= relstart
)
8727 /* For largetoc loads of address constants, we can convert
8728 . addis rx,2,addr@got@ha
8729 . ld ry,addr@got@l(rx)
8731 . addis rx,2,addr@toc@ha
8732 . addi ry,rx,addr@toc@l
8733 when addr is within 2G of the toc pointer. This then means
8734 that the word storing "addr" in the toc is no longer needed. */
8736 if (!ppc64_elf_tdata (ibfd
)->has_small_toc_reloc
8737 && toc
->output_section
->rawsize
< (bfd_vma
) 1 << 31
8738 && toc
->reloc_count
!= 0)
8740 /* Read toc relocs. */
8741 toc_relocs
= _bfd_elf_link_read_relocs (ibfd
, toc
, NULL
, NULL
,
8743 if (toc_relocs
== NULL
)
8746 for (rel
= toc_relocs
; rel
< toc_relocs
+ toc
->reloc_count
; ++rel
)
8748 enum elf_ppc64_reloc_type r_type
;
8749 unsigned long r_symndx
;
8751 struct elf_link_hash_entry
*h
;
8752 Elf_Internal_Sym
*sym
;
8755 r_type
= ELF64_R_TYPE (rel
->r_info
);
8756 if (r_type
!= R_PPC64_ADDR64
)
8759 r_symndx
= ELF64_R_SYM (rel
->r_info
);
8760 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
8765 || sym_sec
->output_section
== NULL
8766 || discarded_section (sym_sec
))
8769 if (!SYMBOL_REFERENCES_LOCAL (info
, h
))
8774 if (h
->type
== STT_GNU_IFUNC
)
8776 val
= h
->root
.u
.def
.value
;
8780 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
8782 val
= sym
->st_value
;
8784 val
+= rel
->r_addend
;
8785 val
+= sym_sec
->output_section
->vma
+ sym_sec
->output_offset
;
8787 /* We don't yet know the exact toc pointer value, but we
8788 know it will be somewhere in the toc section. Don't
8789 optimize if the difference from any possible toc
8790 pointer is outside [ff..f80008000, 7fff7fff]. */
8791 addr
= toc
->output_section
->vma
+ TOC_BASE_OFF
;
8792 if (val
- addr
+ (bfd_vma
) 0x80008000 >= (bfd_vma
) 1 << 32)
8795 addr
= toc
->output_section
->vma
+ toc
->output_section
->rawsize
;
8796 if (val
- addr
+ (bfd_vma
) 0x80008000 >= (bfd_vma
) 1 << 32)
8801 skip
= bfd_zmalloc (sizeof (*skip
) * (toc
->size
+ 15) / 8);
8806 skip
[rel
->r_offset
>> 3]
8807 |= can_optimize
| ((rel
- toc_relocs
) << 2);
8814 used
= bfd_zmalloc (sizeof (*used
) * (toc
->size
+ 7) / 8);
8818 if (local_syms
!= NULL
8819 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
8823 && elf_section_data (sec
)->relocs
!= relstart
)
8825 if (toc_relocs
!= NULL
8826 && elf_section_data (toc
)->relocs
!= toc_relocs
)
8833 /* Now check all kept sections that might reference the toc.
8834 Check the toc itself last. */
8835 for (sec
= (ibfd
->sections
== toc
&& toc
->next
? toc
->next
8838 sec
= (sec
== toc
? NULL
8839 : sec
->next
== NULL
? toc
8840 : sec
->next
== toc
&& toc
->next
? toc
->next
8845 if (sec
->reloc_count
== 0
8846 || discarded_section (sec
)
8847 || get_opd_info (sec
)
8848 || (sec
->flags
& SEC_ALLOC
) == 0
8849 || (sec
->flags
& SEC_DEBUGGING
) != 0)
8852 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
8854 if (relstart
== NULL
)
8860 /* Mark toc entries referenced as used. */
8864 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
8866 enum elf_ppc64_reloc_type r_type
;
8867 unsigned long r_symndx
;
8869 struct elf_link_hash_entry
*h
;
8870 Elf_Internal_Sym
*sym
;
8873 r_type
= ELF64_R_TYPE (rel
->r_info
);
8877 case R_PPC64_TOC16_LO
:
8878 case R_PPC64_TOC16_HI
:
8879 case R_PPC64_TOC16_HA
:
8880 case R_PPC64_TOC16_DS
:
8881 case R_PPC64_TOC16_LO_DS
:
8882 /* In case we're taking addresses of toc entries. */
8883 case R_PPC64_ADDR64
:
8890 r_symndx
= ELF64_R_SYM (rel
->r_info
);
8891 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
8902 val
= h
->root
.u
.def
.value
;
8904 val
= sym
->st_value
;
8905 val
+= rel
->r_addend
;
8907 if (val
>= toc
->size
)
8910 if ((skip
[val
>> 3] & can_optimize
) != 0)
8917 case R_PPC64_TOC16_HA
:
8920 case R_PPC64_TOC16_LO_DS
:
8921 off
= rel
->r_offset
;
8922 off
+= (bfd_big_endian (ibfd
) ? -2 : 3);
8923 if (!bfd_get_section_contents (ibfd
, sec
, &opc
,
8929 if ((opc
& (0x3f << 2)) == (58u << 2))
8934 /* Wrong sort of reloc, or not a ld. We may
8935 as well clear ref_from_discarded too. */
8942 /* For the toc section, we only mark as used if this
8943 entry itself isn't unused. */
8944 else if ((used
[rel
->r_offset
>> 3]
8945 || !(skip
[rel
->r_offset
>> 3] & ref_from_discarded
))
8948 /* Do all the relocs again, to catch reference
8957 if (elf_section_data (sec
)->relocs
!= relstart
)
8961 /* Merge the used and skip arrays. Assume that TOC
8962 doublewords not appearing as either used or unused belong
8963 to an entry more than one doubleword in size. */
8964 for (drop
= skip
, keep
= used
, last
= 0, some_unused
= 0;
8965 drop
< skip
+ (toc
->size
+ 7) / 8;
8970 *drop
&= ~ref_from_discarded
;
8971 if ((*drop
& can_optimize
) != 0)
8975 else if ((*drop
& ref_from_discarded
) != 0)
8978 last
= ref_from_discarded
;
8988 bfd_byte
*contents
, *src
;
8990 Elf_Internal_Sym
*sym
;
8991 bfd_boolean local_toc_syms
= FALSE
;
8993 /* Shuffle the toc contents, and at the same time convert the
8994 skip array from booleans into offsets. */
8995 if (!bfd_malloc_and_get_section (ibfd
, toc
, &contents
))
8998 elf_section_data (toc
)->this_hdr
.contents
= contents
;
9000 for (src
= contents
, off
= 0, drop
= skip
;
9001 src
< contents
+ toc
->size
;
9004 if ((*drop
& (can_optimize
| ref_from_discarded
)) != 0)
9009 memcpy (src
- off
, src
, 8);
9013 toc
->rawsize
= toc
->size
;
9014 toc
->size
= src
- contents
- off
;
9016 /* Adjust addends for relocs against the toc section sym,
9017 and optimize any accesses we can. */
9018 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
9020 if (sec
->reloc_count
== 0
9021 || discarded_section (sec
))
9024 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
9026 if (relstart
== NULL
)
9029 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
9031 enum elf_ppc64_reloc_type r_type
;
9032 unsigned long r_symndx
;
9034 struct elf_link_hash_entry
*h
;
9037 r_type
= ELF64_R_TYPE (rel
->r_info
);
9044 case R_PPC64_TOC16_LO
:
9045 case R_PPC64_TOC16_HI
:
9046 case R_PPC64_TOC16_HA
:
9047 case R_PPC64_TOC16_DS
:
9048 case R_PPC64_TOC16_LO_DS
:
9049 case R_PPC64_ADDR64
:
9053 r_symndx
= ELF64_R_SYM (rel
->r_info
);
9054 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
9062 val
= h
->root
.u
.def
.value
;
9065 val
= sym
->st_value
;
9067 local_toc_syms
= TRUE
;
9070 val
+= rel
->r_addend
;
9072 if (val
> toc
->rawsize
)
9074 else if ((skip
[val
>> 3] & ref_from_discarded
) != 0)
9076 else if ((skip
[val
>> 3] & can_optimize
) != 0)
9078 Elf_Internal_Rela
*tocrel
9079 = toc_relocs
+ (skip
[val
>> 3] >> 2);
9080 unsigned long tsym
= ELF64_R_SYM (tocrel
->r_info
);
9084 case R_PPC64_TOC16_HA
:
9085 rel
->r_info
= ELF64_R_INFO (tsym
, R_PPC64_TOC16_HA
);
9088 case R_PPC64_TOC16_LO_DS
:
9089 rel
->r_info
= ELF64_R_INFO (tsym
, R_PPC64_LO_DS_OPT
);
9093 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
9095 info
->callbacks
->einfo
9096 /* xgettext:c-format */
9097 (_("%H: %s references "
9098 "optimized away TOC entry\n"),
9099 ibfd
, sec
, rel
->r_offset
,
9100 ppc64_elf_howto_table
[r_type
]->name
);
9101 bfd_set_error (bfd_error_bad_value
);
9104 rel
->r_addend
= tocrel
->r_addend
;
9105 elf_section_data (sec
)->relocs
= relstart
;
9109 if (h
!= NULL
|| sym
->st_value
!= 0)
9112 rel
->r_addend
-= skip
[val
>> 3];
9113 elf_section_data (sec
)->relocs
= relstart
;
9116 if (elf_section_data (sec
)->relocs
!= relstart
)
9120 /* We shouldn't have local or global symbols defined in the TOC,
9121 but handle them anyway. */
9122 if (local_syms
!= NULL
)
9123 for (sym
= local_syms
;
9124 sym
< local_syms
+ symtab_hdr
->sh_info
;
9126 if (sym
->st_value
!= 0
9127 && bfd_section_from_elf_index (ibfd
, sym
->st_shndx
) == toc
)
9131 if (sym
->st_value
> toc
->rawsize
)
9132 i
= toc
->rawsize
>> 3;
9134 i
= sym
->st_value
>> 3;
9136 if ((skip
[i
] & (ref_from_discarded
| can_optimize
)) != 0)
9140 (_("%s defined on removed toc entry"),
9141 bfd_elf_sym_name (ibfd
, symtab_hdr
, sym
, NULL
));
9144 while ((skip
[i
] & (ref_from_discarded
| can_optimize
)));
9145 sym
->st_value
= (bfd_vma
) i
<< 3;
9148 sym
->st_value
-= skip
[i
];
9149 symtab_hdr
->contents
= (unsigned char *) local_syms
;
9152 /* Adjust any global syms defined in this toc input section. */
9153 if (toc_inf
.global_toc_syms
)
9156 toc_inf
.skip
= skip
;
9157 toc_inf
.global_toc_syms
= FALSE
;
9158 elf_link_hash_traverse (elf_hash_table (info
), adjust_toc_syms
,
9162 if (toc
->reloc_count
!= 0)
9164 Elf_Internal_Shdr
*rel_hdr
;
9165 Elf_Internal_Rela
*wrel
;
9168 /* Remove unused toc relocs, and adjust those we keep. */
9169 if (toc_relocs
== NULL
)
9170 toc_relocs
= _bfd_elf_link_read_relocs (ibfd
, toc
, NULL
, NULL
,
9172 if (toc_relocs
== NULL
)
9176 for (rel
= toc_relocs
; rel
< toc_relocs
+ toc
->reloc_count
; ++rel
)
9177 if ((skip
[rel
->r_offset
>> 3]
9178 & (ref_from_discarded
| can_optimize
)) == 0)
9180 wrel
->r_offset
= rel
->r_offset
- skip
[rel
->r_offset
>> 3];
9181 wrel
->r_info
= rel
->r_info
;
9182 wrel
->r_addend
= rel
->r_addend
;
9185 else if (!dec_dynrel_count (rel
->r_info
, toc
, info
,
9186 &local_syms
, NULL
, NULL
))
9189 elf_section_data (toc
)->relocs
= toc_relocs
;
9190 toc
->reloc_count
= wrel
- toc_relocs
;
9191 rel_hdr
= _bfd_elf_single_rel_hdr (toc
);
9192 sz
= rel_hdr
->sh_entsize
;
9193 rel_hdr
->sh_size
= toc
->reloc_count
* sz
;
9196 else if (toc_relocs
!= NULL
9197 && elf_section_data (toc
)->relocs
!= toc_relocs
)
9200 if (local_syms
!= NULL
9201 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
9203 if (!info
->keep_memory
)
9206 symtab_hdr
->contents
= (unsigned char *) local_syms
;
9211 /* Look for cases where we can change an indirect GOT access to
9212 a GOT relative or PC relative access, possibly reducing the
9213 number of GOT entries. */
9214 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
9217 Elf_Internal_Shdr
*symtab_hdr
;
9218 Elf_Internal_Sym
*local_syms
;
9219 Elf_Internal_Rela
*relstart
, *rel
;
9222 if (!is_ppc64_elf (ibfd
))
9225 if (!ppc64_elf_tdata (ibfd
)->has_optrel
)
9228 sec
= ppc64_elf_tdata (ibfd
)->got
;
9231 got
= sec
->output_section
->vma
+ sec
->output_offset
+ 0x8000;
9234 symtab_hdr
= &elf_symtab_hdr (ibfd
);
9236 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
9238 if (sec
->reloc_count
== 0
9239 || !ppc64_elf_section_data (sec
)->has_optrel
9240 || discarded_section (sec
))
9243 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
9245 if (relstart
== NULL
)
9248 if (local_syms
!= NULL
9249 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
9253 && elf_section_data (sec
)->relocs
!= relstart
)
9258 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
9260 enum elf_ppc64_reloc_type r_type
;
9261 unsigned long r_symndx
;
9262 Elf_Internal_Sym
*sym
;
9264 struct elf_link_hash_entry
*h
;
9265 struct got_entry
*ent
;
9267 unsigned char buf
[8];
9269 enum {no_check
, check_lo
, check_ha
} insn_check
;
9271 r_type
= ELF64_R_TYPE (rel
->r_info
);
9275 insn_check
= no_check
;
9278 case R_PPC64_PLT16_HA
:
9279 case R_PPC64_GOT_TLSLD16_HA
:
9280 case R_PPC64_GOT_TLSGD16_HA
:
9281 case R_PPC64_GOT_TPREL16_HA
:
9282 case R_PPC64_GOT_DTPREL16_HA
:
9283 case R_PPC64_GOT16_HA
:
9284 case R_PPC64_TOC16_HA
:
9285 insn_check
= check_ha
;
9288 case R_PPC64_PLT16_LO
:
9289 case R_PPC64_PLT16_LO_DS
:
9290 case R_PPC64_GOT_TLSLD16_LO
:
9291 case R_PPC64_GOT_TLSGD16_LO
:
9292 case R_PPC64_GOT_TPREL16_LO_DS
:
9293 case R_PPC64_GOT_DTPREL16_LO_DS
:
9294 case R_PPC64_GOT16_LO
:
9295 case R_PPC64_GOT16_LO_DS
:
9296 case R_PPC64_TOC16_LO
:
9297 case R_PPC64_TOC16_LO_DS
:
9298 insn_check
= check_lo
;
9302 if (insn_check
!= no_check
)
9304 bfd_vma off
= rel
->r_offset
& ~3;
9306 if (!bfd_get_section_contents (ibfd
, sec
, buf
, off
, 4))
9309 insn
= bfd_get_32 (ibfd
, buf
);
9310 if (insn_check
== check_lo
9311 ? !ok_lo_toc_insn (insn
, r_type
)
9312 : ((insn
& ((0x3fu
<< 26) | 0x1f << 16))
9313 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9317 ppc64_elf_tdata (ibfd
)->unexpected_toc_insn
= 1;
9318 sprintf (str
, "%#08x", insn
);
9319 info
->callbacks
->einfo
9320 /* xgettext:c-format */
9321 (_("%H: got/toc optimization is not supported for"
9322 " %s instruction\n"),
9323 ibfd
, sec
, rel
->r_offset
& ~3, str
);
9330 /* Note that we don't delete GOT entries for
9331 R_PPC64_GOT16_DS since we'd need a lot more
9332 analysis. For starters, the preliminary layout is
9333 before the GOT, PLT, dynamic sections and stubs are
9334 laid out. Then we'd need to allow for changes in
9335 distance between sections caused by alignment. */
9339 case R_PPC64_GOT16_HA
:
9340 case R_PPC64_GOT16_LO_DS
:
9341 case R_PPC64_GOT_PCREL34
:
9345 r_symndx
= ELF64_R_SYM (rel
->r_info
);
9346 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
9351 || sym_sec
->output_section
== NULL
9352 || discarded_section (sym_sec
))
9355 if (!SYMBOL_REFERENCES_LOCAL (info
, h
))
9359 val
= h
->root
.u
.def
.value
;
9361 val
= sym
->st_value
;
9362 val
+= rel
->r_addend
;
9363 val
+= sym_sec
->output_section
->vma
+ sym_sec
->output_offset
;
9365 /* Fudge factor to allow for the fact that the preliminary layout
9366 isn't exact. Reduce limits by this factor. */
9367 #define LIMIT_ADJUST(LIMIT) ((LIMIT) - (LIMIT) / 16)
9374 case R_PPC64_GOT16_HA
:
9375 if (val
- got
+ LIMIT_ADJUST (0x80008000ULL
)
9376 >= LIMIT_ADJUST (0x100000000ULL
))
9379 if (!bfd_get_section_contents (ibfd
, sec
, buf
,
9380 rel
->r_offset
& ~3, 4))
9382 insn
= bfd_get_32 (ibfd
, buf
);
9383 if (((insn
& ((0x3fu
<< 26) | 0x1f << 16))
9384 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9388 case R_PPC64_GOT16_LO_DS
:
9389 if (val
- got
+ LIMIT_ADJUST (0x80008000ULL
)
9390 >= LIMIT_ADJUST (0x100000000ULL
))
9392 if (!bfd_get_section_contents (ibfd
, sec
, buf
,
9393 rel
->r_offset
& ~3, 4))
9395 insn
= bfd_get_32 (ibfd
, buf
);
9396 if ((insn
& (0x3fu
<< 26 | 0x3)) != 58u << 26 /* ld */)
9400 case R_PPC64_GOT_PCREL34
:
9402 pc
+= sec
->output_section
->vma
+ sec
->output_offset
;
9403 if (val
- pc
+ LIMIT_ADJUST (1ULL << 33)
9404 >= LIMIT_ADJUST (1ULL << 34))
9406 if (!bfd_get_section_contents (ibfd
, sec
, buf
,
9407 rel
->r_offset
& ~3, 8))
9409 insn
= bfd_get_32 (ibfd
, buf
);
9410 if ((insn
& (-1u << 18)) != ((1u << 26) | (1u << 20)))
9412 insn
= bfd_get_32 (ibfd
, buf
+ 4);
9413 if ((insn
& (0x3fu
<< 26)) != 57u << 26)
9423 struct got_entry
**local_got_ents
= elf_local_got_ents (ibfd
);
9424 ent
= local_got_ents
[r_symndx
];
9426 for (; ent
!= NULL
; ent
= ent
->next
)
9427 if (ent
->addend
== rel
->r_addend
9428 && ent
->owner
== ibfd
9429 && ent
->tls_type
== 0)
9431 BFD_ASSERT (ent
&& ent
->got
.refcount
> 0);
9432 ent
->got
.refcount
-= 1;
9435 if (elf_section_data (sec
)->relocs
!= relstart
)
9439 if (local_syms
!= NULL
9440 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
9442 if (!info
->keep_memory
)
9445 symtab_hdr
->contents
= (unsigned char *) local_syms
;
9452 /* Return true iff input section I references the TOC using
9453 instructions limited to +/-32k offsets. */
9456 ppc64_elf_has_small_toc_reloc (asection
*i
)
9458 return (is_ppc64_elf (i
->owner
)
9459 && ppc64_elf_tdata (i
->owner
)->has_small_toc_reloc
);
9462 /* Allocate space for one GOT entry. */
9465 allocate_got (struct elf_link_hash_entry
*h
,
9466 struct bfd_link_info
*info
,
9467 struct got_entry
*gent
)
9469 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
9470 struct ppc_link_hash_entry
*eh
= ppc_elf_hash_entry (h
);
9471 int entsize
= (gent
->tls_type
& eh
->tls_mask
& (TLS_GD
| TLS_LD
)
9473 int rentsize
= (gent
->tls_type
& eh
->tls_mask
& TLS_GD
9474 ? 2 : 1) * sizeof (Elf64_External_Rela
);
9475 asection
*got
= ppc64_elf_tdata (gent
->owner
)->got
;
9477 gent
->got
.offset
= got
->size
;
9478 got
->size
+= entsize
;
9480 if (h
->type
== STT_GNU_IFUNC
)
9482 htab
->elf
.irelplt
->size
+= rentsize
;
9483 htab
->got_reli_size
+= rentsize
;
9485 else if (((bfd_link_pic (info
)
9486 && !(gent
->tls_type
!= 0
9487 && bfd_link_executable (info
)
9488 && SYMBOL_REFERENCES_LOCAL (info
, h
)))
9489 || (htab
->elf
.dynamic_sections_created
9491 && !SYMBOL_REFERENCES_LOCAL (info
, h
)))
9492 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
9494 asection
*relgot
= ppc64_elf_tdata (gent
->owner
)->relgot
;
9495 relgot
->size
+= rentsize
;
9499 /* This function merges got entries in the same toc group. */
9502 merge_got_entries (struct got_entry
**pent
)
9504 struct got_entry
*ent
, *ent2
;
9506 for (ent
= *pent
; ent
!= NULL
; ent
= ent
->next
)
9507 if (!ent
->is_indirect
)
9508 for (ent2
= ent
->next
; ent2
!= NULL
; ent2
= ent2
->next
)
9509 if (!ent2
->is_indirect
9510 && ent2
->addend
== ent
->addend
9511 && ent2
->tls_type
== ent
->tls_type
9512 && elf_gp (ent2
->owner
) == elf_gp (ent
->owner
))
9514 ent2
->is_indirect
= TRUE
;
9515 ent2
->got
.ent
= ent
;
9519 /* If H is undefined, make it dynamic if that makes sense. */
9522 ensure_undef_dynamic (struct bfd_link_info
*info
,
9523 struct elf_link_hash_entry
*h
)
9525 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
9527 if (htab
->dynamic_sections_created
9528 && ((info
->dynamic_undefined_weak
!= 0
9529 && h
->root
.type
== bfd_link_hash_undefweak
)
9530 || h
->root
.type
== bfd_link_hash_undefined
)
9533 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
9534 return bfd_elf_link_record_dynamic_symbol (info
, h
);
9538 /* Allocate space in .plt, .got and associated reloc sections for
9542 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
9544 struct bfd_link_info
*info
;
9545 struct ppc_link_hash_table
*htab
;
9547 struct ppc_link_hash_entry
*eh
;
9548 struct got_entry
**pgent
, *gent
;
9550 if (h
->root
.type
== bfd_link_hash_indirect
)
9553 info
= (struct bfd_link_info
*) inf
;
9554 htab
= ppc_hash_table (info
);
9558 eh
= ppc_elf_hash_entry (h
);
9559 /* Run through the TLS GD got entries first if we're changing them
9561 if ((eh
->tls_mask
& (TLS_TLS
| TLS_GDIE
)) == (TLS_TLS
| TLS_GDIE
))
9562 for (gent
= h
->got
.glist
; gent
!= NULL
; gent
= gent
->next
)
9563 if (gent
->got
.refcount
> 0
9564 && (gent
->tls_type
& TLS_GD
) != 0)
9566 /* This was a GD entry that has been converted to TPREL. If
9567 there happens to be a TPREL entry we can use that one. */
9568 struct got_entry
*ent
;
9569 for (ent
= h
->got
.glist
; ent
!= NULL
; ent
= ent
->next
)
9570 if (ent
->got
.refcount
> 0
9571 && (ent
->tls_type
& TLS_TPREL
) != 0
9572 && ent
->addend
== gent
->addend
9573 && ent
->owner
== gent
->owner
)
9575 gent
->got
.refcount
= 0;
9579 /* If not, then we'll be using our own TPREL entry. */
9580 if (gent
->got
.refcount
!= 0)
9581 gent
->tls_type
= TLS_TLS
| TLS_TPREL
;
9584 /* Remove any list entry that won't generate a word in the GOT before
9585 we call merge_got_entries. Otherwise we risk merging to empty
9587 pgent
= &h
->got
.glist
;
9588 while ((gent
= *pgent
) != NULL
)
9589 if (gent
->got
.refcount
> 0)
9591 if ((gent
->tls_type
& TLS_LD
) != 0
9592 && SYMBOL_REFERENCES_LOCAL (info
, h
))
9594 ppc64_tlsld_got (gent
->owner
)->got
.refcount
+= 1;
9595 *pgent
= gent
->next
;
9598 pgent
= &gent
->next
;
9601 *pgent
= gent
->next
;
9603 if (!htab
->do_multi_toc
)
9604 merge_got_entries (&h
->got
.glist
);
9606 for (gent
= h
->got
.glist
; gent
!= NULL
; gent
= gent
->next
)
9607 if (!gent
->is_indirect
)
9609 /* Ensure we catch all the cases where this symbol should
9611 if (!ensure_undef_dynamic (info
, h
))
9614 if (!is_ppc64_elf (gent
->owner
))
9617 allocate_got (h
, info
, gent
);
9620 /* If no dynamic sections we can't have dynamic relocs, except for
9621 IFUNCs which are handled even in static executables. */
9622 if (!htab
->elf
.dynamic_sections_created
9623 && h
->type
!= STT_GNU_IFUNC
)
9624 eh
->dyn_relocs
= NULL
;
9626 /* Discard relocs on undefined symbols that must be local. */
9627 else if (h
->root
.type
== bfd_link_hash_undefined
9628 && ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
9629 eh
->dyn_relocs
= NULL
;
9631 /* Also discard relocs on undefined weak syms with non-default
9632 visibility, or when dynamic_undefined_weak says so. */
9633 else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
9634 eh
->dyn_relocs
= NULL
;
9636 if (eh
->dyn_relocs
!= NULL
)
9638 struct elf_dyn_relocs
*p
, **pp
;
9640 /* In the shared -Bsymbolic case, discard space allocated for
9641 dynamic pc-relative relocs against symbols which turn out to
9642 be defined in regular objects. For the normal shared case,
9643 discard space for relocs that have become local due to symbol
9644 visibility changes. */
9645 if (bfd_link_pic (info
))
9647 /* Relocs that use pc_count are those that appear on a call
9648 insn, or certain REL relocs (see must_be_dyn_reloc) that
9649 can be generated via assembly. We want calls to
9650 protected symbols to resolve directly to the function
9651 rather than going via the plt. If people want function
9652 pointer comparisons to work as expected then they should
9653 avoid writing weird assembly. */
9654 if (SYMBOL_CALLS_LOCAL (info
, h
))
9656 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
9658 p
->count
-= p
->pc_count
;
9667 if (eh
->dyn_relocs
!= NULL
)
9669 /* Ensure we catch all the cases where this symbol
9670 should be made dynamic. */
9671 if (!ensure_undef_dynamic (info
, h
))
9676 /* For a fixed position executable, discard space for
9677 relocs against symbols which are not dynamic. */
9678 else if (h
->type
!= STT_GNU_IFUNC
)
9680 if (h
->dynamic_adjusted
9682 && !ELF_COMMON_DEF_P (h
))
9684 /* Ensure we catch all the cases where this symbol
9685 should be made dynamic. */
9686 if (!ensure_undef_dynamic (info
, h
))
9689 /* But if that didn't work out, discard dynamic relocs. */
9690 if (h
->dynindx
== -1)
9691 eh
->dyn_relocs
= NULL
;
9694 eh
->dyn_relocs
= NULL
;
9697 /* Finally, allocate space. */
9698 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
9700 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
9701 if (eh
->elf
.type
== STT_GNU_IFUNC
)
9702 sreloc
= htab
->elf
.irelplt
;
9703 sreloc
->size
+= p
->count
* sizeof (Elf64_External_Rela
);
9707 /* We might need a PLT entry when the symbol
9710 c) has plt16 relocs and has been processed by adjust_dynamic_symbol, or
9711 d) has plt16 relocs and we are linking statically. */
9712 if ((htab
->elf
.dynamic_sections_created
&& h
->dynindx
!= -1)
9713 || h
->type
== STT_GNU_IFUNC
9714 || (h
->needs_plt
&& h
->dynamic_adjusted
)
9717 && !htab
->elf
.dynamic_sections_created
9718 && !htab
->can_convert_all_inline_plt
9719 && (ppc_elf_hash_entry (h
)->tls_mask
9720 & (TLS_TLS
| PLT_KEEP
)) == PLT_KEEP
))
9722 struct plt_entry
*pent
;
9723 bfd_boolean doneone
= FALSE
;
9724 for (pent
= h
->plt
.plist
; pent
!= NULL
; pent
= pent
->next
)
9725 if (pent
->plt
.refcount
> 0)
9727 if (!htab
->elf
.dynamic_sections_created
9728 || h
->dynindx
== -1)
9730 if (h
->type
== STT_GNU_IFUNC
)
9733 pent
->plt
.offset
= s
->size
;
9734 s
->size
+= PLT_ENTRY_SIZE (htab
);
9735 s
= htab
->elf
.irelplt
;
9740 pent
->plt
.offset
= s
->size
;
9741 s
->size
+= LOCAL_PLT_ENTRY_SIZE (htab
);
9742 s
= bfd_link_pic (info
) ? htab
->relpltlocal
: NULL
;
9747 /* If this is the first .plt entry, make room for the special
9751 s
->size
+= PLT_INITIAL_ENTRY_SIZE (htab
);
9753 pent
->plt
.offset
= s
->size
;
9755 /* Make room for this entry. */
9756 s
->size
+= PLT_ENTRY_SIZE (htab
);
9758 /* Make room for the .glink code. */
9761 s
->size
+= GLINK_PLTRESOLVE_SIZE (htab
);
9764 /* We need bigger stubs past index 32767. */
9765 if (s
->size
>= GLINK_PLTRESOLVE_SIZE (htab
) + 32768*2*4)
9772 /* We also need to make an entry in the .rela.plt section. */
9773 s
= htab
->elf
.srelplt
;
9776 s
->size
+= sizeof (Elf64_External_Rela
);
9780 pent
->plt
.offset
= (bfd_vma
) -1;
9783 h
->plt
.plist
= NULL
;
9789 h
->plt
.plist
= NULL
;
9796 #define PPC_LO(v) ((v) & 0xffff)
9797 #define PPC_HI(v) (((v) >> 16) & 0xffff)
9798 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
9800 ((((v) & 0x3ffff0000ULL) << 16) | (v & 0xffff))
9801 #define HA34(v) ((v + (1ULL << 33)) >> 34)
9803 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9804 to set up space for global entry stubs. These are put in glink,
9805 after the branch table. */
9808 size_global_entry_stubs (struct elf_link_hash_entry
*h
, void *inf
)
9810 struct bfd_link_info
*info
;
9811 struct ppc_link_hash_table
*htab
;
9812 struct plt_entry
*pent
;
9815 if (h
->root
.type
== bfd_link_hash_indirect
)
9818 if (!h
->pointer_equality_needed
)
9825 htab
= ppc_hash_table (info
);
9829 s
= htab
->global_entry
;
9830 plt
= htab
->elf
.splt
;
9831 for (pent
= h
->plt
.plist
; pent
!= NULL
; pent
= pent
->next
)
9832 if (pent
->plt
.offset
!= (bfd_vma
) -1
9833 && pent
->addend
== 0)
9835 /* For ELFv2, if this symbol is not defined in a regular file
9836 and we are not generating a shared library or pie, then we
9837 need to define the symbol in the executable on a call stub.
9838 This is to avoid text relocations. */
9839 bfd_vma off
, stub_align
, stub_off
, stub_size
;
9840 unsigned int align_power
;
9844 if (htab
->params
->plt_stub_align
>= 0)
9845 align_power
= htab
->params
->plt_stub_align
;
9847 align_power
= -htab
->params
->plt_stub_align
;
9848 /* Setting section alignment is delayed until we know it is
9849 non-empty. Otherwise the .text output section will be
9850 aligned at least to plt_stub_align even when no global
9851 entry stubs are needed. */
9852 if (s
->alignment_power
< align_power
)
9853 s
->alignment_power
= align_power
;
9854 stub_align
= (bfd_vma
) 1 << align_power
;
9855 if (htab
->params
->plt_stub_align
>= 0
9856 || ((((stub_off
+ stub_size
- 1) & -stub_align
)
9857 - (stub_off
& -stub_align
))
9858 > ((stub_size
- 1) & -stub_align
)))
9859 stub_off
= (stub_off
+ stub_align
- 1) & -stub_align
;
9860 off
= pent
->plt
.offset
+ plt
->output_offset
+ plt
->output_section
->vma
;
9861 off
-= stub_off
+ s
->output_offset
+ s
->output_section
->vma
;
9862 /* Note that for --plt-stub-align negative we have a possible
9863 dependency between stub offset and size. Break that
9864 dependency by assuming the max stub size when calculating
9866 if (PPC_HA (off
) == 0)
9868 h
->root
.type
= bfd_link_hash_defined
;
9869 h
->root
.u
.def
.section
= s
;
9870 h
->root
.u
.def
.value
= stub_off
;
9871 s
->size
= stub_off
+ stub_size
;
9877 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9878 read-only sections. */
9881 maybe_set_textrel (struct elf_link_hash_entry
*h
, void *inf
)
9885 if (h
->root
.type
== bfd_link_hash_indirect
)
9888 sec
= readonly_dynrelocs (h
);
9891 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
9893 info
->flags
|= DF_TEXTREL
;
9894 info
->callbacks
->minfo (_("%pB: dynamic relocation against `%pT'"
9895 " in read-only section `%pA'\n"),
9896 sec
->owner
, h
->root
.root
.string
, sec
);
9898 /* Not an error, just cut short the traversal. */
9904 /* Set the sizes of the dynamic sections. */
9907 ppc64_elf_size_dynamic_sections (bfd
*output_bfd
,
9908 struct bfd_link_info
*info
)
9910 struct ppc_link_hash_table
*htab
;
9915 struct got_entry
*first_tlsld
;
9917 htab
= ppc_hash_table (info
);
9921 dynobj
= htab
->elf
.dynobj
;
9925 if (htab
->elf
.dynamic_sections_created
)
9927 /* Set the contents of the .interp section to the interpreter. */
9928 if (bfd_link_executable (info
) && !info
->nointerp
)
9930 s
= bfd_get_linker_section (dynobj
, ".interp");
9933 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
9934 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
9938 /* Set up .got offsets for local syms, and space for local dynamic
9940 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
9942 struct got_entry
**lgot_ents
;
9943 struct got_entry
**end_lgot_ents
;
9944 struct plt_entry
**local_plt
;
9945 struct plt_entry
**end_local_plt
;
9946 unsigned char *lgot_masks
;
9947 bfd_size_type locsymcount
;
9948 Elf_Internal_Shdr
*symtab_hdr
;
9950 if (!is_ppc64_elf (ibfd
))
9953 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
9955 struct ppc_dyn_relocs
*p
;
9957 for (p
= elf_section_data (s
)->local_dynrel
; p
!= NULL
; p
= p
->next
)
9959 if (!bfd_is_abs_section (p
->sec
)
9960 && bfd_is_abs_section (p
->sec
->output_section
))
9962 /* Input section has been discarded, either because
9963 it is a copy of a linkonce section or due to
9964 linker script /DISCARD/, so we'll be discarding
9967 else if (p
->count
!= 0)
9969 asection
*srel
= elf_section_data (p
->sec
)->sreloc
;
9971 srel
= htab
->elf
.irelplt
;
9972 srel
->size
+= p
->count
* sizeof (Elf64_External_Rela
);
9973 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
9974 info
->flags
|= DF_TEXTREL
;
9979 lgot_ents
= elf_local_got_ents (ibfd
);
9983 symtab_hdr
= &elf_symtab_hdr (ibfd
);
9984 locsymcount
= symtab_hdr
->sh_info
;
9985 end_lgot_ents
= lgot_ents
+ locsymcount
;
9986 local_plt
= (struct plt_entry
**) end_lgot_ents
;
9987 end_local_plt
= local_plt
+ locsymcount
;
9988 lgot_masks
= (unsigned char *) end_local_plt
;
9989 s
= ppc64_elf_tdata (ibfd
)->got
;
9990 for (; lgot_ents
< end_lgot_ents
; ++lgot_ents
, ++lgot_masks
)
9992 struct got_entry
**pent
, *ent
;
9995 while ((ent
= *pent
) != NULL
)
9996 if (ent
->got
.refcount
> 0)
9998 if ((ent
->tls_type
& *lgot_masks
& TLS_LD
) != 0)
10000 ppc64_tlsld_got (ibfd
)->got
.refcount
+= 1;
10005 unsigned int ent_size
= 8;
10006 unsigned int rel_size
= sizeof (Elf64_External_Rela
);
10008 ent
->got
.offset
= s
->size
;
10009 if ((ent
->tls_type
& *lgot_masks
& TLS_GD
) != 0)
10014 s
->size
+= ent_size
;
10015 if ((*lgot_masks
& (TLS_TLS
| PLT_IFUNC
)) == PLT_IFUNC
)
10017 htab
->elf
.irelplt
->size
+= rel_size
;
10018 htab
->got_reli_size
+= rel_size
;
10020 else if (bfd_link_pic (info
)
10021 && !(ent
->tls_type
!= 0
10022 && bfd_link_executable (info
)))
10024 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
10025 srel
->size
+= rel_size
;
10034 /* Allocate space for plt calls to local syms. */
10035 lgot_masks
= (unsigned char *) end_local_plt
;
10036 for (; local_plt
< end_local_plt
; ++local_plt
, ++lgot_masks
)
10038 struct plt_entry
*ent
;
10040 for (ent
= *local_plt
; ent
!= NULL
; ent
= ent
->next
)
10041 if (ent
->plt
.refcount
> 0)
10043 if ((*lgot_masks
& (TLS_TLS
| PLT_IFUNC
)) == PLT_IFUNC
)
10045 s
= htab
->elf
.iplt
;
10046 ent
->plt
.offset
= s
->size
;
10047 s
->size
+= PLT_ENTRY_SIZE (htab
);
10048 htab
->elf
.irelplt
->size
+= sizeof (Elf64_External_Rela
);
10050 else if (htab
->can_convert_all_inline_plt
10051 || (*lgot_masks
& (TLS_TLS
| PLT_KEEP
)) != PLT_KEEP
)
10052 ent
->plt
.offset
= (bfd_vma
) -1;
10055 s
= htab
->pltlocal
;
10056 ent
->plt
.offset
= s
->size
;
10057 s
->size
+= LOCAL_PLT_ENTRY_SIZE (htab
);
10058 if (bfd_link_pic (info
))
10059 htab
->relpltlocal
->size
+= sizeof (Elf64_External_Rela
);
10063 ent
->plt
.offset
= (bfd_vma
) -1;
10067 /* Allocate global sym .plt and .got entries, and space for global
10068 sym dynamic relocs. */
10069 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, info
);
10071 if (!htab
->opd_abi
&& !bfd_link_pic (info
))
10072 elf_link_hash_traverse (&htab
->elf
, size_global_entry_stubs
, info
);
10074 first_tlsld
= NULL
;
10075 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
10077 struct got_entry
*ent
;
10079 if (!is_ppc64_elf (ibfd
))
10082 ent
= ppc64_tlsld_got (ibfd
);
10083 if (ent
->got
.refcount
> 0)
10085 if (!htab
->do_multi_toc
&& first_tlsld
!= NULL
)
10087 ent
->is_indirect
= TRUE
;
10088 ent
->got
.ent
= first_tlsld
;
10092 if (first_tlsld
== NULL
)
10094 s
= ppc64_elf_tdata (ibfd
)->got
;
10095 ent
->got
.offset
= s
->size
;
10098 if (bfd_link_dll (info
))
10100 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
10101 srel
->size
+= sizeof (Elf64_External_Rela
);
10106 ent
->got
.offset
= (bfd_vma
) -1;
10109 /* We now have determined the sizes of the various dynamic sections.
10110 Allocate memory for them. */
10112 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
10114 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
10117 if (s
== htab
->brlt
|| s
== htab
->relbrlt
)
10118 /* These haven't been allocated yet; don't strip. */
10120 else if (s
== htab
->elf
.sgot
10121 || s
== htab
->elf
.splt
10122 || s
== htab
->elf
.iplt
10123 || s
== htab
->pltlocal
10124 || s
== htab
->glink
10125 || s
== htab
->global_entry
10126 || s
== htab
->elf
.sdynbss
10127 || s
== htab
->elf
.sdynrelro
)
10129 /* Strip this section if we don't need it; see the
10132 else if (s
== htab
->glink_eh_frame
)
10134 if (!bfd_is_abs_section (s
->output_section
))
10135 /* Not sized yet. */
10138 else if (CONST_STRNEQ (s
->name
, ".rela"))
10142 if (s
!= htab
->elf
.srelplt
)
10145 /* We use the reloc_count field as a counter if we need
10146 to copy relocs into the output file. */
10147 s
->reloc_count
= 0;
10152 /* It's not one of our sections, so don't allocate space. */
10158 /* If we don't need this section, strip it from the
10159 output file. This is mostly to handle .rela.bss and
10160 .rela.plt. We must create both sections in
10161 create_dynamic_sections, because they must be created
10162 before the linker maps input sections to output
10163 sections. The linker does that before
10164 adjust_dynamic_symbol is called, and it is that
10165 function which decides whether anything needs to go
10166 into these sections. */
10167 s
->flags
|= SEC_EXCLUDE
;
10171 if (bfd_is_abs_section (s
->output_section
))
10172 _bfd_error_handler (_("warning: discarding dynamic section %s"),
10175 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
10178 /* Allocate memory for the section contents. We use bfd_zalloc
10179 here in case unused entries are not reclaimed before the
10180 section's contents are written out. This should not happen,
10181 but this way if it does we get a R_PPC64_NONE reloc in .rela
10182 sections instead of garbage.
10183 We also rely on the section contents being zero when writing
10184 the GOT and .dynrelro. */
10185 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
10186 if (s
->contents
== NULL
)
10190 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
10192 if (!is_ppc64_elf (ibfd
))
10195 s
= ppc64_elf_tdata (ibfd
)->got
;
10196 if (s
!= NULL
&& s
!= htab
->elf
.sgot
)
10199 s
->flags
|= SEC_EXCLUDE
;
10202 s
->contents
= bfd_zalloc (ibfd
, s
->size
);
10203 if (s
->contents
== NULL
)
10207 s
= ppc64_elf_tdata (ibfd
)->relgot
;
10211 s
->flags
|= SEC_EXCLUDE
;
10214 s
->contents
= bfd_zalloc (ibfd
, s
->size
);
10215 if (s
->contents
== NULL
)
10218 s
->reloc_count
= 0;
10223 if (htab
->elf
.dynamic_sections_created
)
10225 bfd_boolean tls_opt
;
10227 /* Add some entries to the .dynamic section. We fill in the
10228 values later, in ppc64_elf_finish_dynamic_sections, but we
10229 must add the entries now so that we get the correct size for
10230 the .dynamic section. The DT_DEBUG entry is filled in by the
10231 dynamic linker and used by the debugger. */
10232 #define add_dynamic_entry(TAG, VAL) \
10233 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10235 if (bfd_link_executable (info
))
10237 if (!add_dynamic_entry (DT_DEBUG
, 0))
10241 if (htab
->elf
.splt
!= NULL
&& htab
->elf
.splt
->size
!= 0)
10243 if (!add_dynamic_entry (DT_PLTGOT
, 0)
10244 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
10245 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
10246 || !add_dynamic_entry (DT_JMPREL
, 0)
10247 || !add_dynamic_entry (DT_PPC64_GLINK
, 0))
10251 if (NO_OPD_RELOCS
&& abiversion (output_bfd
) <= 1)
10253 if (!add_dynamic_entry (DT_PPC64_OPD
, 0)
10254 || !add_dynamic_entry (DT_PPC64_OPDSZ
, 0))
10258 tls_opt
= (htab
->params
->tls_get_addr_opt
10259 && ((htab
->tls_get_addr_fd
!= NULL
10260 && htab
->tls_get_addr_fd
->elf
.plt
.plist
!= NULL
)
10261 || (htab
->tga_desc_fd
!= NULL
10262 && htab
->tga_desc_fd
->elf
.plt
.plist
!= NULL
)));
10263 if (tls_opt
|| !htab
->opd_abi
)
10265 if (!add_dynamic_entry (DT_PPC64_OPT
, tls_opt
? PPC64_OPT_TLS
: 0))
10271 if (!add_dynamic_entry (DT_RELA
, 0)
10272 || !add_dynamic_entry (DT_RELASZ
, 0)
10273 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf64_External_Rela
)))
10276 /* If any dynamic relocs apply to a read-only section,
10277 then we need a DT_TEXTREL entry. */
10278 if ((info
->flags
& DF_TEXTREL
) == 0)
10279 elf_link_hash_traverse (&htab
->elf
, maybe_set_textrel
, info
);
10281 if ((info
->flags
& DF_TEXTREL
) != 0)
10283 if (!add_dynamic_entry (DT_TEXTREL
, 0))
10288 #undef add_dynamic_entry
10293 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
10296 ppc64_elf_hash_symbol (struct elf_link_hash_entry
*h
)
10298 if (h
->plt
.plist
!= NULL
10300 && !h
->pointer_equality_needed
)
10303 return _bfd_elf_hash_symbol (h
);
10306 /* Determine the type of stub needed, if any, for a call. */
10308 static inline enum ppc_stub_type
10309 ppc_type_of_stub (asection
*input_sec
,
10310 const Elf_Internal_Rela
*rel
,
10311 struct ppc_link_hash_entry
**hash
,
10312 struct plt_entry
**plt_ent
,
10313 bfd_vma destination
,
10314 unsigned long local_off
)
10316 struct ppc_link_hash_entry
*h
= *hash
;
10318 bfd_vma branch_offset
;
10319 bfd_vma max_branch_offset
;
10320 enum elf_ppc64_reloc_type r_type
;
10324 struct plt_entry
*ent
;
10325 struct ppc_link_hash_entry
*fdh
= h
;
10327 && h
->oh
->is_func_descriptor
)
10329 fdh
= ppc_follow_link (h
->oh
);
10333 for (ent
= fdh
->elf
.plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
10334 if (ent
->addend
== rel
->r_addend
10335 && ent
->plt
.offset
!= (bfd_vma
) -1)
10338 return ppc_stub_plt_call
;
10341 /* Here, we know we don't have a plt entry. If we don't have a
10342 either a defined function descriptor or a defined entry symbol
10343 in a regular object file, then it is pointless trying to make
10344 any other type of stub. */
10345 if (!is_static_defined (&fdh
->elf
)
10346 && !is_static_defined (&h
->elf
))
10347 return ppc_stub_none
;
10349 else if (elf_local_got_ents (input_sec
->owner
) != NULL
)
10351 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (input_sec
->owner
);
10352 struct plt_entry
**local_plt
= (struct plt_entry
**)
10353 elf_local_got_ents (input_sec
->owner
) + symtab_hdr
->sh_info
;
10354 unsigned long r_symndx
= ELF64_R_SYM (rel
->r_info
);
10356 if (local_plt
[r_symndx
] != NULL
)
10358 struct plt_entry
*ent
;
10360 for (ent
= local_plt
[r_symndx
]; ent
!= NULL
; ent
= ent
->next
)
10361 if (ent
->addend
== rel
->r_addend
10362 && ent
->plt
.offset
!= (bfd_vma
) -1)
10365 return ppc_stub_plt_call
;
10370 /* Determine where the call point is. */
10371 location
= (input_sec
->output_offset
10372 + input_sec
->output_section
->vma
10375 branch_offset
= destination
- location
;
10376 r_type
= ELF64_R_TYPE (rel
->r_info
);
10378 /* Determine if a long branch stub is needed. */
10379 max_branch_offset
= 1 << 25;
10380 if (r_type
== R_PPC64_REL14
10381 || r_type
== R_PPC64_REL14_BRTAKEN
10382 || r_type
== R_PPC64_REL14_BRNTAKEN
)
10383 max_branch_offset
= 1 << 15;
10385 if (branch_offset
+ max_branch_offset
>= 2 * max_branch_offset
- local_off
)
10386 /* We need a stub. Figure out whether a long_branch or plt_branch
10387 is needed later. */
10388 return ppc_stub_long_branch
;
10390 return ppc_stub_none
;
10393 /* Gets the address of a label (1:) in r11 and builds an offset in r12,
10394 then adds it to r11 (LOAD false) or loads r12 from r11+r12 (LOAD true).
10399 . lis %r12,xxx-1b@highest
10400 . ori %r12,%r12,xxx-1b@higher
10401 . sldi %r12,%r12,32
10402 . oris %r12,%r12,xxx-1b@high
10403 . ori %r12,%r12,xxx-1b@l
10404 . add/ldx %r12,%r11,%r12 */
10407 build_offset (bfd
*abfd
, bfd_byte
*p
, bfd_vma off
, bfd_boolean load
)
10409 bfd_put_32 (abfd
, MFLR_R12
, p
);
10411 bfd_put_32 (abfd
, BCL_20_31
, p
);
10413 bfd_put_32 (abfd
, MFLR_R11
, p
);
10415 bfd_put_32 (abfd
, MTLR_R12
, p
);
10417 if (off
+ 0x8000 < 0x10000)
10420 bfd_put_32 (abfd
, LD_R12_0R11
+ PPC_LO (off
), p
);
10422 bfd_put_32 (abfd
, ADDI_R12_R11
+ PPC_LO (off
), p
);
10425 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10427 bfd_put_32 (abfd
, ADDIS_R12_R11
+ PPC_HA (off
), p
);
10430 bfd_put_32 (abfd
, LD_R12_0R12
+ PPC_LO (off
), p
);
10432 bfd_put_32 (abfd
, ADDI_R12_R12
+ PPC_LO (off
), p
);
10437 if (off
+ 0x800000000000ULL
< 0x1000000000000ULL
)
10439 bfd_put_32 (abfd
, LI_R12_0
+ ((off
>> 32) & 0xffff), p
);
10444 bfd_put_32 (abfd
, LIS_R12
+ ((off
>> 48) & 0xffff), p
);
10446 if (((off
>> 32) & 0xffff) != 0)
10448 bfd_put_32 (abfd
, ORI_R12_R12_0
+ ((off
>> 32) & 0xffff), p
);
10452 if (((off
>> 32) & 0xffffffffULL
) != 0)
10454 bfd_put_32 (abfd
, SLDI_R12_R12_32
, p
);
10457 if (PPC_HI (off
) != 0)
10459 bfd_put_32 (abfd
, ORIS_R12_R12_0
+ PPC_HI (off
), p
);
10462 if (PPC_LO (off
) != 0)
10464 bfd_put_32 (abfd
, ORI_R12_R12_0
+ PPC_LO (off
), p
);
10468 bfd_put_32 (abfd
, LDX_R12_R11_R12
, p
);
10470 bfd_put_32 (abfd
, ADD_R12_R11_R12
, p
);
10476 static unsigned int
10477 size_offset (bfd_vma off
)
10480 if (off
+ 0x8000 < 0x10000)
10482 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10486 if (off
+ 0x800000000000ULL
< 0x1000000000000ULL
)
10491 if (((off
>> 32) & 0xffff) != 0)
10494 if (((off
>> 32) & 0xffffffffULL
) != 0)
10496 if (PPC_HI (off
) != 0)
10498 if (PPC_LO (off
) != 0)
10505 static unsigned int
10506 num_relocs_for_offset (bfd_vma off
)
10508 unsigned int num_rel
;
10509 if (off
+ 0x8000 < 0x10000)
10511 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10516 if (off
+ 0x800000000000ULL
>= 0x1000000000000ULL
10517 && ((off
>> 32) & 0xffff) != 0)
10519 if (PPC_HI (off
) != 0)
10521 if (PPC_LO (off
) != 0)
10527 static Elf_Internal_Rela
*
10528 emit_relocs_for_offset (struct bfd_link_info
*info
, Elf_Internal_Rela
*r
,
10529 bfd_vma roff
, bfd_vma targ
, bfd_vma off
)
10531 bfd_vma relative_targ
= targ
- (roff
- 8);
10532 if (bfd_big_endian (info
->output_bfd
))
10534 r
->r_offset
= roff
;
10535 r
->r_addend
= relative_targ
+ roff
;
10536 if (off
+ 0x8000 < 0x10000)
10537 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16
);
10538 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10540 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HA
);
10543 r
->r_offset
= roff
;
10544 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_LO
);
10545 r
->r_addend
= relative_targ
+ roff
;
10549 if (off
+ 0x800000000000ULL
< 0x1000000000000ULL
)
10550 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHER
);
10553 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHEST
);
10554 if (((off
>> 32) & 0xffff) != 0)
10558 r
->r_offset
= roff
;
10559 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHER
);
10560 r
->r_addend
= relative_targ
+ roff
;
10563 if (((off
>> 32) & 0xffffffffULL
) != 0)
10565 if (PPC_HI (off
) != 0)
10569 r
->r_offset
= roff
;
10570 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGH
);
10571 r
->r_addend
= relative_targ
+ roff
;
10573 if (PPC_LO (off
) != 0)
10577 r
->r_offset
= roff
;
10578 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_LO
);
10579 r
->r_addend
= relative_targ
+ roff
;
10586 build_powerxx_offset (bfd
*abfd
, bfd_byte
*p
, bfd_vma off
, int odd
,
10590 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10595 bfd_put_32 (abfd
, NOP
, p
);
10601 insn
= PADDI_R12_PC
;
10603 bfd_put_32 (abfd
, insn
>> 32, p
);
10605 bfd_put_32 (abfd
, insn
, p
);
10607 /* The minimum value for paddi is -0x200000000. The minimum value
10608 for li is -0x8000, which when shifted by 34 and added gives a
10609 minimum value of -0x2000200000000. The maximum value is
10610 0x1ffffffff+0x7fff<<34 which is 0x2000200000000-1. */
10611 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10614 bfd_put_32 (abfd
, LI_R11_0
| (HA34 (off
) & 0xffff), p
);
10618 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10621 insn
= PADDI_R12_PC
| D34 (off
);
10622 bfd_put_32 (abfd
, insn
>> 32, p
);
10624 bfd_put_32 (abfd
, insn
, p
);
10628 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10632 bfd_put_32 (abfd
, LDX_R12_R11_R12
, p
);
10634 bfd_put_32 (abfd
, ADD_R12_R11_R12
, p
);
10639 bfd_put_32 (abfd
, LIS_R11
| ((HA34 (off
) >> 16) & 0x3fff), p
);
10641 bfd_put_32 (abfd
, ORI_R11_R11_0
| (HA34 (off
) & 0xffff), p
);
10645 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10648 insn
= PADDI_R12_PC
| D34 (off
);
10649 bfd_put_32 (abfd
, insn
>> 32, p
);
10651 bfd_put_32 (abfd
, insn
, p
);
10655 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10659 bfd_put_32 (abfd
, LDX_R12_R11_R12
, p
);
10661 bfd_put_32 (abfd
, ADD_R12_R11_R12
, p
);
10667 static unsigned int
10668 size_powerxx_offset (bfd_vma off
, int odd
)
10670 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10672 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10678 static unsigned int
10679 num_relocs_for_powerxx_offset (bfd_vma off
, int odd
)
10681 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10683 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10689 static Elf_Internal_Rela
*
10690 emit_relocs_for_powerxx_offset (struct bfd_link_info
*info
,
10691 Elf_Internal_Rela
*r
, bfd_vma roff
,
10692 bfd_vma targ
, bfd_vma off
, int odd
)
10694 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10696 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10698 int d_offset
= bfd_big_endian (info
->output_bfd
) ? 2 : 0;
10699 r
->r_offset
= roff
+ d_offset
;
10700 r
->r_addend
= targ
+ 8 - odd
- d_offset
;
10701 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHERA34
);
10707 int d_offset
= bfd_big_endian (info
->output_bfd
) ? 2 : 0;
10708 r
->r_offset
= roff
+ d_offset
;
10709 r
->r_addend
= targ
+ 8 + odd
- d_offset
;
10710 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHESTA34
);
10713 r
->r_offset
= roff
+ d_offset
;
10714 r
->r_addend
= targ
+ 4 + odd
- d_offset
;
10715 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHERA34
);
10719 r
->r_offset
= roff
;
10720 r
->r_addend
= targ
;
10721 r
->r_info
= ELF64_R_INFO (0, R_PPC64_PCREL34
);
10725 /* Emit .eh_frame opcode to advance pc by DELTA. */
10728 eh_advance (bfd
*abfd
, bfd_byte
*eh
, unsigned int delta
)
10732 *eh
++ = DW_CFA_advance_loc
+ delta
;
10733 else if (delta
< 256)
10735 *eh
++ = DW_CFA_advance_loc1
;
10738 else if (delta
< 65536)
10740 *eh
++ = DW_CFA_advance_loc2
;
10741 bfd_put_16 (abfd
, delta
, eh
);
10746 *eh
++ = DW_CFA_advance_loc4
;
10747 bfd_put_32 (abfd
, delta
, eh
);
10753 /* Size of required .eh_frame opcode to advance pc by DELTA. */
10755 static unsigned int
10756 eh_advance_size (unsigned int delta
)
10758 if (delta
< 64 * 4)
10759 /* DW_CFA_advance_loc+[1..63]. */
10761 if (delta
< 256 * 4)
10762 /* DW_CFA_advance_loc1, byte. */
10764 if (delta
< 65536 * 4)
10765 /* DW_CFA_advance_loc2, 2 bytes. */
10767 /* DW_CFA_advance_loc4, 4 bytes. */
10771 /* With power7 weakly ordered memory model, it is possible for ld.so
10772 to update a plt entry in one thread and have another thread see a
10773 stale zero toc entry. To avoid this we need some sort of acquire
10774 barrier in the call stub. One solution is to make the load of the
10775 toc word seem to appear to depend on the load of the function entry
10776 word. Another solution is to test for r2 being zero, and branch to
10777 the appropriate glink entry if so.
10779 . fake dep barrier compare
10780 . ld 12,xxx(2) ld 12,xxx(2)
10781 . mtctr 12 mtctr 12
10782 . xor 11,12,12 ld 2,xxx+8(2)
10783 . add 2,2,11 cmpldi 2,0
10784 . ld 2,xxx+8(2) bnectr+
10785 . bctr b <glink_entry>
10787 The solution involving the compare turns out to be faster, so
10788 that's what we use unless the branch won't reach. */
10790 #define ALWAYS_USE_FAKE_DEP 0
10791 #define ALWAYS_EMIT_R2SAVE 0
10793 static inline unsigned int
10794 plt_stub_size (struct ppc_link_hash_table
*htab
,
10795 struct ppc_stub_hash_entry
*stub_entry
,
10800 if (stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
)
10802 if (htab
->powerxx_stubs
)
10804 bfd_vma start
= (stub_entry
->stub_offset
10805 + stub_entry
->group
->stub_sec
->output_offset
10806 + stub_entry
->group
->stub_sec
->output_section
->vma
);
10807 if (stub_entry
->stub_type
> ppc_stub_plt_call_notoc
)
10809 size
= 8 + size_powerxx_offset (off
, start
& 4);
10812 size
= 8 + size_offset (off
- 8);
10813 if (stub_entry
->stub_type
> ppc_stub_plt_call_notoc
)
10819 if (ALWAYS_EMIT_R2SAVE
10820 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10822 if (PPC_HA (off
) != 0)
10827 if (htab
->params
->plt_static_chain
)
10829 if (htab
->params
->plt_thread_safe
10830 && htab
->elf
.dynamic_sections_created
10831 && stub_entry
->h
!= NULL
10832 && stub_entry
->h
->elf
.dynindx
!= -1)
10834 if (PPC_HA (off
+ 8 + 8 * htab
->params
->plt_static_chain
) != PPC_HA (off
))
10837 if (stub_entry
->h
!= NULL
10838 && is_tls_get_addr (&stub_entry
->h
->elf
, htab
)
10839 && htab
->params
->tls_get_addr_opt
)
10841 if (htab
->params
->no_tls_get_addr_regsave
)
10844 if (stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10850 if (stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10857 /* Depending on the sign of plt_stub_align:
10858 If positive, return the padding to align to a 2**plt_stub_align
10860 If negative, if this stub would cross fewer 2**plt_stub_align
10861 boundaries if we align, then return the padding needed to do so. */
10863 static inline unsigned int
10864 plt_stub_pad (struct ppc_link_hash_table
*htab
,
10865 struct ppc_stub_hash_entry
*stub_entry
,
10869 unsigned stub_size
;
10870 bfd_vma stub_off
= stub_entry
->group
->stub_sec
->size
;
10872 if (htab
->params
->plt_stub_align
>= 0)
10874 stub_align
= 1 << htab
->params
->plt_stub_align
;
10875 if ((stub_off
& (stub_align
- 1)) != 0)
10876 return stub_align
- (stub_off
& (stub_align
- 1));
10880 stub_align
= 1 << -htab
->params
->plt_stub_align
;
10881 stub_size
= plt_stub_size (htab
, stub_entry
, plt_off
);
10882 if (((stub_off
+ stub_size
- 1) & -stub_align
) - (stub_off
& -stub_align
)
10883 > ((stub_size
- 1) & -stub_align
))
10884 return stub_align
- (stub_off
& (stub_align
- 1));
10888 /* Build a .plt call stub. */
10890 static inline bfd_byte
*
10891 build_plt_stub (struct ppc_link_hash_table
*htab
,
10892 struct ppc_stub_hash_entry
*stub_entry
,
10893 bfd_byte
*p
, bfd_vma offset
, Elf_Internal_Rela
*r
)
10895 bfd
*obfd
= htab
->params
->stub_bfd
;
10896 bfd_boolean plt_load_toc
= htab
->opd_abi
;
10897 bfd_boolean plt_static_chain
= htab
->params
->plt_static_chain
;
10898 bfd_boolean plt_thread_safe
= (htab
->params
->plt_thread_safe
10899 && htab
->elf
.dynamic_sections_created
10900 && stub_entry
->h
!= NULL
10901 && stub_entry
->h
->elf
.dynindx
!= -1);
10902 bfd_boolean use_fake_dep
= plt_thread_safe
;
10903 bfd_vma cmp_branch_off
= 0;
10905 if (!ALWAYS_USE_FAKE_DEP
10908 && !(is_tls_get_addr (&stub_entry
->h
->elf
, htab
)
10909 && htab
->params
->tls_get_addr_opt
))
10911 bfd_vma pltoff
= stub_entry
->plt_ent
->plt
.offset
& ~1;
10912 bfd_vma pltindex
= ((pltoff
- PLT_INITIAL_ENTRY_SIZE (htab
))
10913 / PLT_ENTRY_SIZE (htab
));
10914 bfd_vma glinkoff
= GLINK_PLTRESOLVE_SIZE (htab
) + pltindex
* 8;
10917 if (pltindex
> 32768)
10918 glinkoff
+= (pltindex
- 32768) * 4;
10920 + htab
->glink
->output_offset
10921 + htab
->glink
->output_section
->vma
);
10922 from
= (p
- stub_entry
->group
->stub_sec
->contents
10923 + 4 * (ALWAYS_EMIT_R2SAVE
10924 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10925 + 4 * (PPC_HA (offset
) != 0)
10926 + 4 * (PPC_HA (offset
+ 8 + 8 * plt_static_chain
)
10927 != PPC_HA (offset
))
10928 + 4 * (plt_static_chain
!= 0)
10930 + stub_entry
->group
->stub_sec
->output_offset
10931 + stub_entry
->group
->stub_sec
->output_section
->vma
);
10932 cmp_branch_off
= to
- from
;
10933 use_fake_dep
= cmp_branch_off
+ (1 << 25) >= (1 << 26);
10936 if (PPC_HA (offset
) != 0)
10940 if (ALWAYS_EMIT_R2SAVE
10941 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10942 r
[0].r_offset
+= 4;
10943 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_HA
);
10944 r
[1].r_offset
= r
[0].r_offset
+ 4;
10945 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
10946 r
[1].r_addend
= r
[0].r_addend
;
10949 if (PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
10951 r
[2].r_offset
= r
[1].r_offset
+ 4;
10952 r
[2].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO
);
10953 r
[2].r_addend
= r
[0].r_addend
;
10957 r
[2].r_offset
= r
[1].r_offset
+ 8 + 8 * use_fake_dep
;
10958 r
[2].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
10959 r
[2].r_addend
= r
[0].r_addend
+ 8;
10960 if (plt_static_chain
)
10962 r
[3].r_offset
= r
[2].r_offset
+ 4;
10963 r
[3].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
10964 r
[3].r_addend
= r
[0].r_addend
+ 16;
10969 if (ALWAYS_EMIT_R2SAVE
10970 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10971 bfd_put_32 (obfd
, STD_R2_0R1
+ STK_TOC (htab
), p
), p
+= 4;
10974 bfd_put_32 (obfd
, ADDIS_R11_R2
| PPC_HA (offset
), p
), p
+= 4;
10975 bfd_put_32 (obfd
, LD_R12_0R11
| PPC_LO (offset
), p
), p
+= 4;
10979 bfd_put_32 (obfd
, ADDIS_R12_R2
| PPC_HA (offset
), p
), p
+= 4;
10980 bfd_put_32 (obfd
, LD_R12_0R12
| PPC_LO (offset
), p
), p
+= 4;
10983 && PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
10985 bfd_put_32 (obfd
, ADDI_R11_R11
| PPC_LO (offset
), p
), p
+= 4;
10988 bfd_put_32 (obfd
, MTCTR_R12
, p
), p
+= 4;
10993 bfd_put_32 (obfd
, XOR_R2_R12_R12
, p
), p
+= 4;
10994 bfd_put_32 (obfd
, ADD_R11_R11_R2
, p
), p
+= 4;
10996 bfd_put_32 (obfd
, LD_R2_0R11
| PPC_LO (offset
+ 8), p
), p
+= 4;
10997 if (plt_static_chain
)
10998 bfd_put_32 (obfd
, LD_R11_0R11
| PPC_LO (offset
+ 16), p
), p
+= 4;
11005 if (ALWAYS_EMIT_R2SAVE
11006 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
11007 r
[0].r_offset
+= 4;
11008 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
11011 if (PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
11013 r
[1].r_offset
= r
[0].r_offset
+ 4;
11014 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16
);
11015 r
[1].r_addend
= r
[0].r_addend
;
11019 r
[1].r_offset
= r
[0].r_offset
+ 8 + 8 * use_fake_dep
;
11020 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
11021 r
[1].r_addend
= r
[0].r_addend
+ 8 + 8 * plt_static_chain
;
11022 if (plt_static_chain
)
11024 r
[2].r_offset
= r
[1].r_offset
+ 4;
11025 r
[2].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
11026 r
[2].r_addend
= r
[0].r_addend
+ 8;
11031 if (ALWAYS_EMIT_R2SAVE
11032 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
11033 bfd_put_32 (obfd
, STD_R2_0R1
+ STK_TOC (htab
), p
), p
+= 4;
11034 bfd_put_32 (obfd
, LD_R12_0R2
| PPC_LO (offset
), p
), p
+= 4;
11036 && PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
11038 bfd_put_32 (obfd
, ADDI_R2_R2
| PPC_LO (offset
), p
), p
+= 4;
11041 bfd_put_32 (obfd
, MTCTR_R12
, p
), p
+= 4;
11046 bfd_put_32 (obfd
, XOR_R11_R12_R12
, p
), p
+= 4;
11047 bfd_put_32 (obfd
, ADD_R2_R2_R11
, p
), p
+= 4;
11049 if (plt_static_chain
)
11050 bfd_put_32 (obfd
, LD_R11_0R2
| PPC_LO (offset
+ 16), p
), p
+= 4;
11051 bfd_put_32 (obfd
, LD_R2_0R2
| PPC_LO (offset
+ 8), p
), p
+= 4;
11054 if (plt_load_toc
&& plt_thread_safe
&& !use_fake_dep
)
11056 bfd_put_32 (obfd
, CMPLDI_R2_0
, p
), p
+= 4;
11057 bfd_put_32 (obfd
, BNECTR_P4
, p
), p
+= 4;
11058 bfd_put_32 (obfd
, B_DOT
| (cmp_branch_off
& 0x3fffffc), p
), p
+= 4;
11061 bfd_put_32 (obfd
, BCTR
, p
), p
+= 4;
11065 /* Build a special .plt call stub for __tls_get_addr. */
11067 #define LD_R0_0R3 0xe8030000
11068 #define LD_R12_0R3 0xe9830000
11069 #define MR_R0_R3 0x7c601b78
11070 #define CMPDI_R0_0 0x2c200000
11071 #define ADD_R3_R12_R13 0x7c6c6a14
11072 #define BEQLR 0x4d820020
11073 #define MR_R3_R0 0x7c030378
11074 #define BCTRL 0x4e800421
11076 static inline bfd_byte
*
11077 build_tls_get_addr_stub (struct ppc_link_hash_table
*htab
,
11078 struct ppc_stub_hash_entry
*stub_entry
,
11079 bfd_byte
*p
, bfd_vma offset
, Elf_Internal_Rela
*r
)
11081 bfd
*obfd
= htab
->params
->stub_bfd
;
11085 bfd_put_32 (obfd
, LD_R0_0R3
+ 0, p
), p
+= 4;
11086 bfd_put_32 (obfd
, LD_R12_0R3
+ 8, p
), p
+= 4;
11087 bfd_put_32 (obfd
, CMPDI_R0_0
, p
), p
+= 4;
11088 bfd_put_32 (obfd
, MR_R0_R3
, p
), p
+= 4;
11089 bfd_put_32 (obfd
, ADD_R3_R12_R13
, p
), p
+= 4;
11090 bfd_put_32 (obfd
, BEQLR
, p
), p
+= 4;
11091 bfd_put_32 (obfd
, MR_R3_R0
, p
), p
+= 4;
11092 if (htab
->params
->no_tls_get_addr_regsave
)
11095 r
[0].r_offset
+= 7 * 4;
11096 if (stub_entry
->stub_type
!= ppc_stub_plt_call_r2save
)
11097 return build_plt_stub (htab
, stub_entry
, p
, offset
, r
);
11099 bfd_put_32 (obfd
, MFLR_R0
, p
);
11101 bfd_put_32 (obfd
, STD_R0_0R1
+ STK_LINKER (htab
), p
);
11105 r
[0].r_offset
+= 2 * 4;
11106 p
= build_plt_stub (htab
, stub_entry
, p
, offset
, r
);
11107 bfd_put_32 (obfd
, BCTRL
, p
- 4);
11109 bfd_put_32 (obfd
, LD_R2_0R1
+ STK_TOC (htab
), p
);
11111 bfd_put_32 (obfd
, LD_R0_0R1
+ STK_LINKER (htab
), p
);
11113 bfd_put_32 (obfd
, MTLR_R0
, p
);
11115 bfd_put_32 (obfd
, BLR
, p
);
11120 p
= tls_get_addr_prologue (obfd
, p
, htab
);
11123 r
[0].r_offset
+= 18 * 4;
11125 p
= build_plt_stub (htab
, stub_entry
, p
, offset
, r
);
11126 bfd_put_32 (obfd
, BCTRL
, p
- 4);
11128 if (stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
11130 bfd_put_32 (obfd
, LD_R2_0R1
+ STK_TOC (htab
), p
);
11134 p
= tls_get_addr_epilogue (obfd
, p
, htab
);
11137 if (htab
->glink_eh_frame
!= NULL
11138 && htab
->glink_eh_frame
->size
!= 0)
11140 bfd_byte
*base
, *eh
;
11142 base
= htab
->glink_eh_frame
->contents
+ stub_entry
->group
->eh_base
+ 17;
11143 eh
= base
+ stub_entry
->group
->eh_size
;
11144 if (htab
->params
->no_tls_get_addr_regsave
)
11146 unsigned int lr_used
, delta
;
11147 lr_used
= stub_entry
->stub_offset
+ (p
- 20 - loc
);
11148 delta
= lr_used
- stub_entry
->group
->lr_restore
;
11149 stub_entry
->group
->lr_restore
= lr_used
+ 16;
11150 eh
= eh_advance (htab
->elf
.dynobj
, eh
, delta
);
11151 *eh
++ = DW_CFA_offset_extended_sf
;
11153 *eh
++ = -(STK_LINKER (htab
) / 8) & 0x7f;
11154 *eh
++ = DW_CFA_advance_loc
+ 4;
11158 unsigned int cfa_updt
, delta
;
11159 /* After the bctrl, lr has been modified so we need to emit
11160 .eh_frame info saying the return address is on the stack. In
11161 fact we must put the EH info at or before the call rather
11162 than after it, because the EH info for a call needs to be
11163 specified by that point.
11164 See libgcc/unwind-dw2.c execute_cfa_program.
11165 Any stack pointer update must be described immediately after
11166 the instruction making the change, and since the stdu occurs
11167 after saving regs we put all the reg saves and the cfa
11169 cfa_updt
= stub_entry
->stub_offset
+ 18 * 4;
11170 delta
= cfa_updt
- stub_entry
->group
->lr_restore
;
11171 stub_entry
->group
->lr_restore
11172 = stub_entry
->stub_offset
+ (p
- loc
) - 4;
11173 eh
= eh_advance (htab
->elf
.dynobj
, eh
, delta
);
11174 *eh
++ = DW_CFA_def_cfa_offset
;
11182 *eh
++ = DW_CFA_offset_extended_sf
;
11184 *eh
++ = (-16 / 8) & 0x7f;
11185 for (i
= 4; i
< 12; i
++)
11187 *eh
++ = DW_CFA_offset
+ i
;
11188 *eh
++ = (htab
->opd_abi
? 13 : 12) - i
;
11190 *eh
++ = (DW_CFA_advance_loc
11191 + (stub_entry
->group
->lr_restore
- 8 - cfa_updt
) / 4);
11192 *eh
++ = DW_CFA_def_cfa_offset
;
11194 for (i
= 4; i
< 12; i
++)
11195 *eh
++ = DW_CFA_restore
+ i
;
11196 *eh
++ = DW_CFA_advance_loc
+ 2;
11198 *eh
++ = DW_CFA_restore_extended
;
11200 stub_entry
->group
->eh_size
= eh
- base
;
11205 static Elf_Internal_Rela
*
11206 get_relocs (asection
*sec
, int count
)
11208 Elf_Internal_Rela
*relocs
;
11209 struct bfd_elf_section_data
*elfsec_data
;
11211 elfsec_data
= elf_section_data (sec
);
11212 relocs
= elfsec_data
->relocs
;
11213 if (relocs
== NULL
)
11215 bfd_size_type relsize
;
11216 relsize
= sec
->reloc_count
* sizeof (*relocs
);
11217 relocs
= bfd_alloc (sec
->owner
, relsize
);
11218 if (relocs
== NULL
)
11220 elfsec_data
->relocs
= relocs
;
11221 elfsec_data
->rela
.hdr
= bfd_zalloc (sec
->owner
,
11222 sizeof (Elf_Internal_Shdr
));
11223 if (elfsec_data
->rela
.hdr
== NULL
)
11225 elfsec_data
->rela
.hdr
->sh_size
= (sec
->reloc_count
11226 * sizeof (Elf64_External_Rela
));
11227 elfsec_data
->rela
.hdr
->sh_entsize
= sizeof (Elf64_External_Rela
);
11228 sec
->reloc_count
= 0;
11230 relocs
+= sec
->reloc_count
;
11231 sec
->reloc_count
+= count
;
11235 /* Convert the relocs R[0] thru R[-NUM_REL+1], which are all no-symbol
11236 forms, to the equivalent relocs against the global symbol given by
11240 use_global_in_relocs (struct ppc_link_hash_table
*htab
,
11241 struct ppc_stub_hash_entry
*stub_entry
,
11242 Elf_Internal_Rela
*r
, unsigned int num_rel
)
11244 struct elf_link_hash_entry
**hashes
;
11245 unsigned long symndx
;
11246 struct ppc_link_hash_entry
*h
;
11249 /* Relocs are always against symbols in their own object file. Fake
11250 up global sym hashes for the stub bfd (which has no symbols). */
11251 hashes
= elf_sym_hashes (htab
->params
->stub_bfd
);
11252 if (hashes
== NULL
)
11254 bfd_size_type hsize
;
11256 /* When called the first time, stub_globals will contain the
11257 total number of symbols seen during stub sizing. After
11258 allocating, stub_globals is used as an index to fill the
11260 hsize
= (htab
->stub_globals
+ 1) * sizeof (*hashes
);
11261 hashes
= bfd_zalloc (htab
->params
->stub_bfd
, hsize
);
11262 if (hashes
== NULL
)
11264 elf_sym_hashes (htab
->params
->stub_bfd
) = hashes
;
11265 htab
->stub_globals
= 1;
11267 symndx
= htab
->stub_globals
++;
11269 hashes
[symndx
] = &h
->elf
;
11270 if (h
->oh
!= NULL
&& h
->oh
->is_func
)
11271 h
= ppc_follow_link (h
->oh
);
11272 BFD_ASSERT (h
->elf
.root
.type
== bfd_link_hash_defined
11273 || h
->elf
.root
.type
== bfd_link_hash_defweak
);
11274 symval
= defined_sym_val (&h
->elf
);
11275 while (num_rel
-- != 0)
11277 r
->r_info
= ELF64_R_INFO (symndx
, ELF64_R_TYPE (r
->r_info
));
11278 if (h
->elf
.root
.u
.def
.section
!= stub_entry
->target_section
)
11280 /* H is an opd symbol. The addend must be zero, and the
11281 branch reloc is the only one we can convert. */
11286 r
->r_addend
-= symval
;
11293 get_r2off (struct bfd_link_info
*info
,
11294 struct ppc_stub_hash_entry
*stub_entry
)
11296 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
11297 bfd_vma r2off
= htab
->sec_info
[stub_entry
->target_section
->id
].toc_off
;
11301 /* Support linking -R objects. Get the toc pointer from the
11304 if (!htab
->opd_abi
)
11306 asection
*opd
= stub_entry
->h
->elf
.root
.u
.def
.section
;
11307 bfd_vma opd_off
= stub_entry
->h
->elf
.root
.u
.def
.value
;
11309 if (strcmp (opd
->name
, ".opd") != 0
11310 || opd
->reloc_count
!= 0)
11312 info
->callbacks
->einfo
11313 (_("%P: cannot find opd entry toc for `%pT'\n"),
11314 stub_entry
->h
->elf
.root
.root
.string
);
11315 bfd_set_error (bfd_error_bad_value
);
11316 return (bfd_vma
) -1;
11318 if (!bfd_get_section_contents (opd
->owner
, opd
, buf
, opd_off
+ 8, 8))
11319 return (bfd_vma
) -1;
11320 r2off
= bfd_get_64 (opd
->owner
, buf
);
11321 r2off
-= elf_gp (info
->output_bfd
);
11323 r2off
-= htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
;
11328 ppc_build_one_stub (struct bfd_hash_entry
*gen_entry
, void *in_arg
)
11330 struct ppc_stub_hash_entry
*stub_entry
;
11331 struct ppc_branch_hash_entry
*br_entry
;
11332 struct bfd_link_info
*info
;
11333 struct ppc_link_hash_table
*htab
;
11335 bfd_byte
*p
, *relp
;
11337 Elf_Internal_Rela
*r
;
11342 /* Massage our args to the form they really have. */
11343 stub_entry
= (struct ppc_stub_hash_entry
*) gen_entry
;
11346 htab
= ppc_hash_table (info
);
11350 BFD_ASSERT (stub_entry
->stub_offset
>= stub_entry
->group
->stub_sec
->size
);
11351 loc
= stub_entry
->group
->stub_sec
->contents
+ stub_entry
->stub_offset
;
11353 htab
->stub_count
[stub_entry
->stub_type
- 1] += 1;
11354 switch (stub_entry
->stub_type
)
11356 case ppc_stub_long_branch
:
11357 case ppc_stub_long_branch_r2off
:
11358 /* Branches are relative. This is where we are going to. */
11359 targ
= (stub_entry
->target_value
11360 + stub_entry
->target_section
->output_offset
11361 + stub_entry
->target_section
->output_section
->vma
);
11362 targ
+= PPC64_LOCAL_ENTRY_OFFSET (stub_entry
->other
);
11364 /* And this is where we are coming from. */
11365 off
= (stub_entry
->stub_offset
11366 + stub_entry
->group
->stub_sec
->output_offset
11367 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11371 if (stub_entry
->stub_type
== ppc_stub_long_branch_r2off
)
11373 bfd_vma r2off
= get_r2off (info
, stub_entry
);
11375 if (r2off
== (bfd_vma
) -1)
11377 htab
->stub_error
= TRUE
;
11380 bfd_put_32 (htab
->params
->stub_bfd
, STD_R2_0R1
+ STK_TOC (htab
), p
);
11382 if (PPC_HA (r2off
) != 0)
11384 bfd_put_32 (htab
->params
->stub_bfd
,
11385 ADDIS_R2_R2
| PPC_HA (r2off
), p
);
11388 if (PPC_LO (r2off
) != 0)
11390 bfd_put_32 (htab
->params
->stub_bfd
,
11391 ADDI_R2_R2
| PPC_LO (r2off
), p
);
11396 bfd_put_32 (htab
->params
->stub_bfd
, B_DOT
| (off
& 0x3fffffc), p
);
11399 if (off
+ (1 << 25) >= (bfd_vma
) (1 << 26))
11402 (_("long branch stub `%s' offset overflow"),
11403 stub_entry
->root
.string
);
11404 htab
->stub_error
= TRUE
;
11408 if (info
->emitrelocations
)
11410 r
= get_relocs (stub_entry
->group
->stub_sec
, 1);
11413 r
->r_offset
= p
- 4 - stub_entry
->group
->stub_sec
->contents
;
11414 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL24
);
11415 r
->r_addend
= targ
;
11416 if (stub_entry
->h
!= NULL
11417 && !use_global_in_relocs (htab
, stub_entry
, r
, 1))
11422 case ppc_stub_plt_branch
:
11423 case ppc_stub_plt_branch_r2off
:
11424 br_entry
= ppc_branch_hash_lookup (&htab
->branch_hash_table
,
11425 stub_entry
->root
.string
+ 9,
11427 if (br_entry
== NULL
)
11429 _bfd_error_handler (_("can't find branch stub `%s'"),
11430 stub_entry
->root
.string
);
11431 htab
->stub_error
= TRUE
;
11435 targ
= (stub_entry
->target_value
11436 + stub_entry
->target_section
->output_offset
11437 + stub_entry
->target_section
->output_section
->vma
);
11438 if (stub_entry
->stub_type
!= ppc_stub_plt_branch_r2off
)
11439 targ
+= PPC64_LOCAL_ENTRY_OFFSET (stub_entry
->other
);
11441 bfd_put_64 (htab
->brlt
->owner
, targ
,
11442 htab
->brlt
->contents
+ br_entry
->offset
);
11444 if (br_entry
->iter
== htab
->stub_iteration
)
11446 br_entry
->iter
= 0;
11448 if (htab
->relbrlt
!= NULL
)
11450 /* Create a reloc for the branch lookup table entry. */
11451 Elf_Internal_Rela rela
;
11454 rela
.r_offset
= (br_entry
->offset
11455 + htab
->brlt
->output_offset
11456 + htab
->brlt
->output_section
->vma
);
11457 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
11458 rela
.r_addend
= targ
;
11460 rl
= htab
->relbrlt
->contents
;
11461 rl
+= (htab
->relbrlt
->reloc_count
++
11462 * sizeof (Elf64_External_Rela
));
11463 bfd_elf64_swap_reloca_out (htab
->relbrlt
->owner
, &rela
, rl
);
11465 else if (info
->emitrelocations
)
11467 r
= get_relocs (htab
->brlt
, 1);
11470 /* brlt, being SEC_LINKER_CREATED does not go through the
11471 normal reloc processing. Symbols and offsets are not
11472 translated from input file to output file form, so
11473 set up the offset per the output file. */
11474 r
->r_offset
= (br_entry
->offset
11475 + htab
->brlt
->output_offset
11476 + htab
->brlt
->output_section
->vma
);
11477 r
->r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
11478 r
->r_addend
= targ
;
11482 targ
= (br_entry
->offset
11483 + htab
->brlt
->output_offset
11484 + htab
->brlt
->output_section
->vma
);
11486 off
= (elf_gp (info
->output_bfd
)
11487 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
11490 if (off
+ 0x80008000 > 0xffffffff || (off
& 7) != 0)
11492 info
->callbacks
->einfo
11493 (_("%P: linkage table error against `%pT'\n"),
11494 stub_entry
->root
.string
);
11495 bfd_set_error (bfd_error_bad_value
);
11496 htab
->stub_error
= TRUE
;
11500 if (info
->emitrelocations
)
11502 r
= get_relocs (stub_entry
->group
->stub_sec
, 1 + (PPC_HA (off
) != 0));
11505 r
[0].r_offset
= loc
- stub_entry
->group
->stub_sec
->contents
;
11506 if (bfd_big_endian (info
->output_bfd
))
11507 r
[0].r_offset
+= 2;
11508 if (stub_entry
->stub_type
== ppc_stub_plt_branch_r2off
)
11509 r
[0].r_offset
+= 4;
11510 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
11511 r
[0].r_addend
= targ
;
11512 if (PPC_HA (off
) != 0)
11514 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_HA
);
11515 r
[1].r_offset
= r
[0].r_offset
+ 4;
11516 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
11517 r
[1].r_addend
= r
[0].r_addend
;
11522 if (stub_entry
->stub_type
!= ppc_stub_plt_branch_r2off
)
11524 if (PPC_HA (off
) != 0)
11526 bfd_put_32 (htab
->params
->stub_bfd
,
11527 ADDIS_R12_R2
| PPC_HA (off
), p
);
11529 bfd_put_32 (htab
->params
->stub_bfd
,
11530 LD_R12_0R12
| PPC_LO (off
), p
);
11533 bfd_put_32 (htab
->params
->stub_bfd
,
11534 LD_R12_0R2
| PPC_LO (off
), p
);
11538 bfd_vma r2off
= get_r2off (info
, stub_entry
);
11540 if (r2off
== (bfd_vma
) -1)
11542 htab
->stub_error
= TRUE
;
11546 bfd_put_32 (htab
->params
->stub_bfd
, STD_R2_0R1
+ STK_TOC (htab
), p
);
11548 if (PPC_HA (off
) != 0)
11550 bfd_put_32 (htab
->params
->stub_bfd
,
11551 ADDIS_R12_R2
| PPC_HA (off
), p
);
11553 bfd_put_32 (htab
->params
->stub_bfd
,
11554 LD_R12_0R12
| PPC_LO (off
), p
);
11557 bfd_put_32 (htab
->params
->stub_bfd
, LD_R12_0R2
| PPC_LO (off
), p
);
11559 if (PPC_HA (r2off
) != 0)
11562 bfd_put_32 (htab
->params
->stub_bfd
,
11563 ADDIS_R2_R2
| PPC_HA (r2off
), p
);
11565 if (PPC_LO (r2off
) != 0)
11568 bfd_put_32 (htab
->params
->stub_bfd
,
11569 ADDI_R2_R2
| PPC_LO (r2off
), p
);
11573 bfd_put_32 (htab
->params
->stub_bfd
, MTCTR_R12
, p
);
11575 bfd_put_32 (htab
->params
->stub_bfd
, BCTR
, p
);
11579 case ppc_stub_long_branch_notoc
:
11580 case ppc_stub_long_branch_both
:
11581 case ppc_stub_plt_branch_notoc
:
11582 case ppc_stub_plt_branch_both
:
11583 case ppc_stub_plt_call_notoc
:
11584 case ppc_stub_plt_call_both
:
11586 off
= (stub_entry
->stub_offset
11587 + stub_entry
->group
->stub_sec
->output_offset
11588 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11589 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
11590 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
11591 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
11594 bfd_put_32 (htab
->params
->stub_bfd
, STD_R2_0R1
+ STK_TOC (htab
), p
);
11597 if (stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
)
11599 targ
= stub_entry
->plt_ent
->plt
.offset
& ~1;
11600 if (targ
>= (bfd_vma
) -2)
11603 plt
= htab
->elf
.splt
;
11604 if (!htab
->elf
.dynamic_sections_created
11605 || stub_entry
->h
== NULL
11606 || stub_entry
->h
->elf
.dynindx
== -1)
11608 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
11609 plt
= htab
->elf
.iplt
;
11611 plt
= htab
->pltlocal
;
11613 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
11616 targ
= (stub_entry
->target_value
11617 + stub_entry
->target_section
->output_offset
11618 + stub_entry
->target_section
->output_section
->vma
);
11624 if (htab
->powerxx_stubs
)
11626 bfd_boolean load
= stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
;
11627 p
= build_powerxx_offset (htab
->params
->stub_bfd
, p
, off
, odd
, load
);
11631 /* The notoc stubs calculate their target (either a PLT entry or
11632 the global entry point of a function) relative to the PC
11633 returned by the "bcl" two instructions past the start of the
11634 sequence emitted by build_offset. The offset is therefore 8
11635 less than calculated from the start of the sequence. */
11637 p
= build_offset (htab
->params
->stub_bfd
, p
, off
,
11638 stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
);
11641 if (stub_entry
->stub_type
<= ppc_stub_long_branch_both
)
11645 from
= (stub_entry
->stub_offset
11646 + stub_entry
->group
->stub_sec
->output_offset
11647 + stub_entry
->group
->stub_sec
->output_section
->vma
11649 bfd_put_32 (htab
->params
->stub_bfd
,
11650 B_DOT
| ((targ
- from
) & 0x3fffffc), p
);
11654 bfd_put_32 (htab
->params
->stub_bfd
, MTCTR_R12
, p
);
11656 bfd_put_32 (htab
->params
->stub_bfd
, BCTR
, p
);
11660 if (info
->emitrelocations
)
11662 bfd_vma roff
= relp
- stub_entry
->group
->stub_sec
->contents
;
11663 if (htab
->powerxx_stubs
)
11664 num_rel
+= num_relocs_for_powerxx_offset (off
, odd
);
11667 num_rel
+= num_relocs_for_offset (off
);
11670 r
= get_relocs (stub_entry
->group
->stub_sec
, num_rel
);
11673 if (htab
->powerxx_stubs
)
11674 r
= emit_relocs_for_powerxx_offset (info
, r
, roff
, targ
, off
, odd
);
11676 r
= emit_relocs_for_offset (info
, r
, roff
, targ
, off
);
11677 if (stub_entry
->stub_type
== ppc_stub_long_branch_notoc
11678 || stub_entry
->stub_type
== ppc_stub_long_branch_both
)
11681 roff
= p
- 4 - stub_entry
->group
->stub_sec
->contents
;
11682 r
->r_offset
= roff
;
11683 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL24
);
11684 r
->r_addend
= targ
;
11685 if (stub_entry
->h
!= NULL
11686 && !use_global_in_relocs (htab
, stub_entry
, r
, num_rel
))
11691 if (!htab
->powerxx_stubs
11692 && htab
->glink_eh_frame
!= NULL
11693 && htab
->glink_eh_frame
->size
!= 0)
11695 bfd_byte
*base
, *eh
;
11696 unsigned int lr_used
, delta
;
11698 base
= (htab
->glink_eh_frame
->contents
11699 + stub_entry
->group
->eh_base
+ 17);
11700 eh
= base
+ stub_entry
->group
->eh_size
;
11701 lr_used
= stub_entry
->stub_offset
+ 8;
11702 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
11703 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
11704 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
11706 delta
= lr_used
- stub_entry
->group
->lr_restore
;
11707 stub_entry
->group
->lr_restore
= lr_used
+ 8;
11708 eh
= eh_advance (htab
->elf
.dynobj
, eh
, delta
);
11709 *eh
++ = DW_CFA_register
;
11712 *eh
++ = DW_CFA_advance_loc
+ 2;
11713 *eh
++ = DW_CFA_restore_extended
;
11715 stub_entry
->group
->eh_size
= eh
- base
;
11719 case ppc_stub_plt_call
:
11720 case ppc_stub_plt_call_r2save
:
11721 if (stub_entry
->h
!= NULL
11722 && stub_entry
->h
->is_func_descriptor
11723 && stub_entry
->h
->oh
!= NULL
)
11725 struct ppc_link_hash_entry
*fh
= ppc_follow_link (stub_entry
->h
->oh
);
11727 /* If the old-ABI "dot-symbol" is undefined make it weak so
11728 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL. */
11729 if (fh
->elf
.root
.type
== bfd_link_hash_undefined
11730 && (stub_entry
->h
->elf
.root
.type
== bfd_link_hash_defined
11731 || stub_entry
->h
->elf
.root
.type
== bfd_link_hash_defweak
))
11732 fh
->elf
.root
.type
= bfd_link_hash_undefweak
;
11735 /* Now build the stub. */
11736 targ
= stub_entry
->plt_ent
->plt
.offset
& ~1;
11737 if (targ
>= (bfd_vma
) -2)
11740 plt
= htab
->elf
.splt
;
11741 if (!htab
->elf
.dynamic_sections_created
11742 || stub_entry
->h
== NULL
11743 || stub_entry
->h
->elf
.dynindx
== -1)
11745 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
11746 plt
= htab
->elf
.iplt
;
11748 plt
= htab
->pltlocal
;
11750 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
11752 off
= (elf_gp (info
->output_bfd
)
11753 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
11756 if (off
+ 0x80008000 > 0xffffffff || (off
& 7) != 0)
11758 info
->callbacks
->einfo
11759 /* xgettext:c-format */
11760 (_("%P: linkage table error against `%pT'\n"),
11761 stub_entry
->h
!= NULL
11762 ? stub_entry
->h
->elf
.root
.root
.string
11764 bfd_set_error (bfd_error_bad_value
);
11765 htab
->stub_error
= TRUE
;
11770 if (info
->emitrelocations
)
11772 r
= get_relocs (stub_entry
->group
->stub_sec
,
11773 ((PPC_HA (off
) != 0)
11775 ? 2 + (htab
->params
->plt_static_chain
11776 && PPC_HA (off
+ 16) == PPC_HA (off
))
11780 r
[0].r_offset
= loc
- stub_entry
->group
->stub_sec
->contents
;
11781 if (bfd_big_endian (info
->output_bfd
))
11782 r
[0].r_offset
+= 2;
11783 r
[0].r_addend
= targ
;
11785 if (stub_entry
->h
!= NULL
11786 && is_tls_get_addr (&stub_entry
->h
->elf
, htab
)
11787 && htab
->params
->tls_get_addr_opt
)
11788 p
= build_tls_get_addr_stub (htab
, stub_entry
, loc
, off
, r
);
11790 p
= build_plt_stub (htab
, stub_entry
, loc
, off
, r
);
11793 case ppc_stub_save_res
:
11801 stub_entry
->group
->stub_sec
->size
= stub_entry
->stub_offset
+ (p
- loc
);
11803 if (htab
->params
->emit_stub_syms
)
11805 struct elf_link_hash_entry
*h
;
11808 const char *const stub_str
[] = { "long_branch",
11821 len1
= strlen (stub_str
[stub_entry
->stub_type
- 1]);
11822 len2
= strlen (stub_entry
->root
.string
);
11823 name
= bfd_malloc (len1
+ len2
+ 2);
11826 memcpy (name
, stub_entry
->root
.string
, 9);
11827 memcpy (name
+ 9, stub_str
[stub_entry
->stub_type
- 1], len1
);
11828 memcpy (name
+ len1
+ 9, stub_entry
->root
.string
+ 8, len2
- 8 + 1);
11829 h
= elf_link_hash_lookup (&htab
->elf
, name
, TRUE
, FALSE
, FALSE
);
11832 if (h
->root
.type
== bfd_link_hash_new
)
11834 h
->root
.type
= bfd_link_hash_defined
;
11835 h
->root
.u
.def
.section
= stub_entry
->group
->stub_sec
;
11836 h
->root
.u
.def
.value
= stub_entry
->stub_offset
;
11837 h
->ref_regular
= 1;
11838 h
->def_regular
= 1;
11839 h
->ref_regular_nonweak
= 1;
11840 h
->forced_local
= 1;
11842 h
->root
.linker_def
= 1;
11849 /* As above, but don't actually build the stub. Just bump offset so
11850 we know stub section sizes, and select plt_branch stubs where
11851 long_branch stubs won't do. */
11854 ppc_size_one_stub (struct bfd_hash_entry
*gen_entry
, void *in_arg
)
11856 struct ppc_stub_hash_entry
*stub_entry
;
11857 struct bfd_link_info
*info
;
11858 struct ppc_link_hash_table
*htab
;
11860 bfd_vma targ
, off
, r2off
;
11861 unsigned int size
, extra
, lr_used
, delta
, odd
;
11863 /* Massage our args to the form they really have. */
11864 stub_entry
= (struct ppc_stub_hash_entry
*) gen_entry
;
11867 htab
= ppc_hash_table (info
);
11871 /* Make a note of the offset within the stubs for this entry. */
11872 stub_entry
->stub_offset
= stub_entry
->group
->stub_sec
->size
;
11874 if (stub_entry
->h
!= NULL
11875 && stub_entry
->h
->save_res
11876 && stub_entry
->h
->elf
.root
.type
== bfd_link_hash_defined
11877 && stub_entry
->h
->elf
.root
.u
.def
.section
== htab
->sfpr
)
11879 /* Don't make stubs to out-of-line register save/restore
11880 functions. Instead, emit copies of the functions. */
11881 stub_entry
->group
->needs_save_res
= 1;
11882 stub_entry
->stub_type
= ppc_stub_save_res
;
11886 switch (stub_entry
->stub_type
)
11888 case ppc_stub_plt_branch
:
11889 case ppc_stub_plt_branch_r2off
:
11890 /* Reset the stub type from the plt branch variant in case we now
11891 can reach with a shorter stub. */
11892 stub_entry
->stub_type
+= ppc_stub_long_branch
- ppc_stub_plt_branch
;
11893 /* Fall through. */
11894 case ppc_stub_long_branch
:
11895 case ppc_stub_long_branch_r2off
:
11896 targ
= (stub_entry
->target_value
11897 + stub_entry
->target_section
->output_offset
11898 + stub_entry
->target_section
->output_section
->vma
);
11899 targ
+= PPC64_LOCAL_ENTRY_OFFSET (stub_entry
->other
);
11900 off
= (stub_entry
->stub_offset
11901 + stub_entry
->group
->stub_sec
->output_offset
11902 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11906 if (stub_entry
->stub_type
== ppc_stub_long_branch_r2off
)
11908 r2off
= get_r2off (info
, stub_entry
);
11909 if (r2off
== (bfd_vma
) -1)
11911 htab
->stub_error
= TRUE
;
11915 if (PPC_HA (r2off
) != 0)
11917 if (PPC_LO (r2off
) != 0)
11923 /* If the branch offset is too big, use a ppc_stub_plt_branch.
11924 Do the same for -R objects without function descriptors. */
11925 if ((stub_entry
->stub_type
== ppc_stub_long_branch_r2off
11927 && htab
->sec_info
[stub_entry
->target_section
->id
].toc_off
== 0)
11928 || off
+ (1 << 25) >= (bfd_vma
) (1 << 26))
11930 struct ppc_branch_hash_entry
*br_entry
;
11932 br_entry
= ppc_branch_hash_lookup (&htab
->branch_hash_table
,
11933 stub_entry
->root
.string
+ 9,
11935 if (br_entry
== NULL
)
11937 _bfd_error_handler (_("can't build branch stub `%s'"),
11938 stub_entry
->root
.string
);
11939 htab
->stub_error
= TRUE
;
11943 if (br_entry
->iter
!= htab
->stub_iteration
)
11945 br_entry
->iter
= htab
->stub_iteration
;
11946 br_entry
->offset
= htab
->brlt
->size
;
11947 htab
->brlt
->size
+= 8;
11949 if (htab
->relbrlt
!= NULL
)
11950 htab
->relbrlt
->size
+= sizeof (Elf64_External_Rela
);
11951 else if (info
->emitrelocations
)
11953 htab
->brlt
->reloc_count
+= 1;
11954 htab
->brlt
->flags
|= SEC_RELOC
;
11958 targ
= (br_entry
->offset
11959 + htab
->brlt
->output_offset
11960 + htab
->brlt
->output_section
->vma
);
11961 off
= (elf_gp (info
->output_bfd
)
11962 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
11965 if (info
->emitrelocations
)
11967 stub_entry
->group
->stub_sec
->reloc_count
11968 += 1 + (PPC_HA (off
) != 0);
11969 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
11972 stub_entry
->stub_type
+= ppc_stub_plt_branch
- ppc_stub_long_branch
;
11973 if (stub_entry
->stub_type
!= ppc_stub_plt_branch_r2off
)
11976 if (PPC_HA (off
) != 0)
11982 if (PPC_HA (off
) != 0)
11985 if (PPC_HA (r2off
) != 0)
11987 if (PPC_LO (r2off
) != 0)
11991 else if (info
->emitrelocations
)
11993 stub_entry
->group
->stub_sec
->reloc_count
+= 1;
11994 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
11998 case ppc_stub_plt_branch_notoc
:
11999 case ppc_stub_plt_branch_both
:
12000 stub_entry
->stub_type
+= ppc_stub_long_branch
- ppc_stub_plt_branch
;
12001 /* Fall through. */
12002 case ppc_stub_long_branch_notoc
:
12003 case ppc_stub_long_branch_both
:
12004 off
= (stub_entry
->stub_offset
12005 + stub_entry
->group
->stub_sec
->output_offset
12006 + stub_entry
->group
->stub_sec
->output_section
->vma
);
12008 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
)
12011 targ
= (stub_entry
->target_value
12012 + stub_entry
->target_section
->output_offset
12013 + stub_entry
->target_section
->output_section
->vma
);
12017 if (info
->emitrelocations
)
12019 unsigned int num_rel
;
12020 if (htab
->powerxx_stubs
)
12021 num_rel
= num_relocs_for_powerxx_offset (off
, odd
);
12023 num_rel
= num_relocs_for_offset (off
- 8);
12024 stub_entry
->group
->stub_sec
->reloc_count
+= num_rel
;
12025 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
12028 if (htab
->powerxx_stubs
)
12029 extra
= size_powerxx_offset (off
, odd
);
12031 extra
= size_offset (off
- 8);
12032 /* Include branch insn plus those in the offset sequence. */
12034 /* The branch insn is at the end, or "extra" bytes along. So
12035 its offset will be "extra" bytes less that that already
12039 if (!htab
->powerxx_stubs
)
12041 /* After the bcl, lr has been modified so we need to emit
12042 .eh_frame info saying the return address is in r12. */
12043 lr_used
= stub_entry
->stub_offset
+ 8;
12044 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
)
12046 /* The eh_frame info will consist of a DW_CFA_advance_loc or
12047 variant, DW_CFA_register, 65, 12, DW_CFA_advance_loc+2,
12048 DW_CFA_restore_extended 65. */
12049 delta
= lr_used
- stub_entry
->group
->lr_restore
;
12050 stub_entry
->group
->eh_size
+= eh_advance_size (delta
) + 6;
12051 stub_entry
->group
->lr_restore
= lr_used
+ 8;
12054 /* If the branch can't reach, use a plt_branch. */
12055 if (off
+ (1 << 25) >= (bfd_vma
) (1 << 26))
12057 stub_entry
->stub_type
+= (ppc_stub_plt_branch_notoc
12058 - ppc_stub_long_branch_notoc
);
12061 else if (info
->emitrelocations
)
12062 stub_entry
->group
->stub_sec
->reloc_count
+=1;
12065 case ppc_stub_plt_call_notoc
:
12066 case ppc_stub_plt_call_both
:
12067 off
= (stub_entry
->stub_offset
12068 + stub_entry
->group
->stub_sec
->output_offset
12069 + stub_entry
->group
->stub_sec
->output_section
->vma
);
12070 if (stub_entry
->stub_type
== ppc_stub_plt_call_both
)
12072 targ
= stub_entry
->plt_ent
->plt
.offset
& ~1;
12073 if (targ
>= (bfd_vma
) -2)
12076 plt
= htab
->elf
.splt
;
12077 if (!htab
->elf
.dynamic_sections_created
12078 || stub_entry
->h
== NULL
12079 || stub_entry
->h
->elf
.dynindx
== -1)
12081 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
12082 plt
= htab
->elf
.iplt
;
12084 plt
= htab
->pltlocal
;
12086 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
12090 if (htab
->params
->plt_stub_align
!= 0)
12092 unsigned pad
= plt_stub_pad (htab
, stub_entry
, off
);
12094 stub_entry
->group
->stub_sec
->size
+= pad
;
12095 stub_entry
->stub_offset
= stub_entry
->group
->stub_sec
->size
;
12099 if (info
->emitrelocations
)
12101 unsigned int num_rel
;
12102 if (htab
->powerxx_stubs
)
12103 num_rel
= num_relocs_for_powerxx_offset (off
, odd
);
12105 num_rel
= num_relocs_for_offset (off
- 8);
12106 stub_entry
->group
->stub_sec
->reloc_count
+= num_rel
;
12107 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
12110 size
= plt_stub_size (htab
, stub_entry
, off
);
12112 if (!htab
->powerxx_stubs
)
12114 /* After the bcl, lr has been modified so we need to emit
12115 .eh_frame info saying the return address is in r12. */
12116 lr_used
= stub_entry
->stub_offset
+ 8;
12117 if (stub_entry
->stub_type
== ppc_stub_plt_call_both
)
12119 /* The eh_frame info will consist of a DW_CFA_advance_loc or
12120 variant, DW_CFA_register, 65, 12, DW_CFA_advance_loc+2,
12121 DW_CFA_restore_extended 65. */
12122 delta
= lr_used
- stub_entry
->group
->lr_restore
;
12123 stub_entry
->group
->eh_size
+= eh_advance_size (delta
) + 6;
12124 stub_entry
->group
->lr_restore
= lr_used
+ 8;
12128 case ppc_stub_plt_call
:
12129 case ppc_stub_plt_call_r2save
:
12130 targ
= stub_entry
->plt_ent
->plt
.offset
& ~(bfd_vma
) 1;
12131 if (targ
>= (bfd_vma
) -2)
12133 plt
= htab
->elf
.splt
;
12134 if (!htab
->elf
.dynamic_sections_created
12135 || stub_entry
->h
== NULL
12136 || stub_entry
->h
->elf
.dynindx
== -1)
12138 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
12139 plt
= htab
->elf
.iplt
;
12141 plt
= htab
->pltlocal
;
12143 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
12145 off
= (elf_gp (info
->output_bfd
)
12146 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
12149 if (htab
->params
->plt_stub_align
!= 0)
12151 unsigned pad
= plt_stub_pad (htab
, stub_entry
, off
);
12153 stub_entry
->group
->stub_sec
->size
+= pad
;
12154 stub_entry
->stub_offset
= stub_entry
->group
->stub_sec
->size
;
12157 if (info
->emitrelocations
)
12159 stub_entry
->group
->stub_sec
->reloc_count
12160 += ((PPC_HA (off
) != 0)
12162 ? 2 + (htab
->params
->plt_static_chain
12163 && PPC_HA (off
+ 16) == PPC_HA (off
))
12165 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
12168 size
= plt_stub_size (htab
, stub_entry
, off
);
12170 if (stub_entry
->h
!= NULL
12171 && is_tls_get_addr (&stub_entry
->h
->elf
, htab
)
12172 && htab
->params
->tls_get_addr_opt
12173 && stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
12175 if (htab
->params
->no_tls_get_addr_regsave
)
12177 lr_used
= stub_entry
->stub_offset
+ size
- 20;
12178 /* The eh_frame info will consist of a DW_CFA_advance_loc
12179 or variant, DW_CFA_offset_externed_sf, 65, -stackoff,
12180 DW_CFA_advance_loc+4, DW_CFA_restore_extended, 65. */
12181 delta
= lr_used
- stub_entry
->group
->lr_restore
;
12182 stub_entry
->group
->eh_size
+= eh_advance_size (delta
) + 6;
12186 /* Adjustments to r1 need to be described. */
12187 unsigned int cfa_updt
= stub_entry
->stub_offset
+ 18 * 4;
12188 delta
= cfa_updt
- stub_entry
->group
->lr_restore
;
12189 stub_entry
->group
->eh_size
+= eh_advance_size (delta
);
12190 stub_entry
->group
->eh_size
+= htab
->opd_abi
? 36 : 35;
12192 stub_entry
->group
->lr_restore
= size
- 4;
12201 stub_entry
->group
->stub_sec
->size
+= size
;
12205 /* Set up various things so that we can make a list of input sections
12206 for each output section included in the link. Returns -1 on error,
12207 0 when no stubs will be needed, and 1 on success. */
12210 ppc64_elf_setup_section_lists (struct bfd_link_info
*info
)
12214 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12219 htab
->sec_info_arr_size
= _bfd_section_id
;
12220 amt
= sizeof (*htab
->sec_info
) * (htab
->sec_info_arr_size
);
12221 htab
->sec_info
= bfd_zmalloc (amt
);
12222 if (htab
->sec_info
== NULL
)
12225 /* Set toc_off for com, und, abs and ind sections. */
12226 for (id
= 0; id
< 3; id
++)
12227 htab
->sec_info
[id
].toc_off
= TOC_BASE_OFF
;
12232 /* Set up for first pass at multitoc partitioning. */
12235 ppc64_elf_start_multitoc_partition (struct bfd_link_info
*info
)
12237 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12239 htab
->toc_curr
= ppc64_elf_set_toc (info
, info
->output_bfd
);
12240 htab
->toc_bfd
= NULL
;
12241 htab
->toc_first_sec
= NULL
;
12244 /* The linker repeatedly calls this function for each TOC input section
12245 and linker generated GOT section. Group input bfds such that the toc
12246 within a group is less than 64k in size. */
12249 ppc64_elf_next_toc_section (struct bfd_link_info
*info
, asection
*isec
)
12251 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12252 bfd_vma addr
, off
, limit
;
12257 if (!htab
->second_toc_pass
)
12259 /* Keep track of the first .toc or .got section for this input bfd. */
12260 bfd_boolean new_bfd
= htab
->toc_bfd
!= isec
->owner
;
12264 htab
->toc_bfd
= isec
->owner
;
12265 htab
->toc_first_sec
= isec
;
12268 addr
= isec
->output_offset
+ isec
->output_section
->vma
;
12269 off
= addr
- htab
->toc_curr
;
12270 limit
= 0x80008000;
12271 if (ppc64_elf_tdata (isec
->owner
)->has_small_toc_reloc
)
12273 if (off
+ isec
->size
> limit
)
12275 addr
= (htab
->toc_first_sec
->output_offset
12276 + htab
->toc_first_sec
->output_section
->vma
);
12277 htab
->toc_curr
= addr
;
12278 htab
->toc_curr
&= -TOC_BASE_ALIGN
;
12281 /* toc_curr is the base address of this toc group. Set elf_gp
12282 for the input section to be the offset relative to the
12283 output toc base plus 0x8000. Making the input elf_gp an
12284 offset allows us to move the toc as a whole without
12285 recalculating input elf_gp. */
12286 off
= htab
->toc_curr
- elf_gp (info
->output_bfd
);
12287 off
+= TOC_BASE_OFF
;
12289 /* Die if someone uses a linker script that doesn't keep input
12290 file .toc and .got together. */
12292 && elf_gp (isec
->owner
) != 0
12293 && elf_gp (isec
->owner
) != off
)
12296 elf_gp (isec
->owner
) = off
;
12300 /* During the second pass toc_first_sec points to the start of
12301 a toc group, and toc_curr is used to track the old elf_gp.
12302 We use toc_bfd to ensure we only look at each bfd once. */
12303 if (htab
->toc_bfd
== isec
->owner
)
12305 htab
->toc_bfd
= isec
->owner
;
12307 if (htab
->toc_first_sec
== NULL
12308 || htab
->toc_curr
!= elf_gp (isec
->owner
))
12310 htab
->toc_curr
= elf_gp (isec
->owner
);
12311 htab
->toc_first_sec
= isec
;
12313 addr
= (htab
->toc_first_sec
->output_offset
12314 + htab
->toc_first_sec
->output_section
->vma
);
12315 off
= addr
- elf_gp (info
->output_bfd
) + TOC_BASE_OFF
;
12316 elf_gp (isec
->owner
) = off
;
12321 /* Called via elf_link_hash_traverse to merge GOT entries for global
12325 merge_global_got (struct elf_link_hash_entry
*h
, void *inf ATTRIBUTE_UNUSED
)
12327 if (h
->root
.type
== bfd_link_hash_indirect
)
12330 merge_got_entries (&h
->got
.glist
);
12335 /* Called via elf_link_hash_traverse to allocate GOT entries for global
12339 reallocate_got (struct elf_link_hash_entry
*h
, void *inf
)
12341 struct got_entry
*gent
;
12343 if (h
->root
.type
== bfd_link_hash_indirect
)
12346 for (gent
= h
->got
.glist
; gent
!= NULL
; gent
= gent
->next
)
12347 if (!gent
->is_indirect
)
12348 allocate_got (h
, (struct bfd_link_info
*) inf
, gent
);
12352 /* Called on the first multitoc pass after the last call to
12353 ppc64_elf_next_toc_section. This function removes duplicate GOT
12357 ppc64_elf_layout_multitoc (struct bfd_link_info
*info
)
12359 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12360 struct bfd
*ibfd
, *ibfd2
;
12361 bfd_boolean done_something
;
12363 htab
->multi_toc_needed
= htab
->toc_curr
!= elf_gp (info
->output_bfd
);
12365 if (!htab
->do_multi_toc
)
12368 /* Merge global sym got entries within a toc group. */
12369 elf_link_hash_traverse (&htab
->elf
, merge_global_got
, info
);
12371 /* And tlsld_got. */
12372 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12374 struct got_entry
*ent
, *ent2
;
12376 if (!is_ppc64_elf (ibfd
))
12379 ent
= ppc64_tlsld_got (ibfd
);
12380 if (!ent
->is_indirect
12381 && ent
->got
.offset
!= (bfd_vma
) -1)
12383 for (ibfd2
= ibfd
->link
.next
; ibfd2
!= NULL
; ibfd2
= ibfd2
->link
.next
)
12385 if (!is_ppc64_elf (ibfd2
))
12388 ent2
= ppc64_tlsld_got (ibfd2
);
12389 if (!ent2
->is_indirect
12390 && ent2
->got
.offset
!= (bfd_vma
) -1
12391 && elf_gp (ibfd2
) == elf_gp (ibfd
))
12393 ent2
->is_indirect
= TRUE
;
12394 ent2
->got
.ent
= ent
;
12400 /* Zap sizes of got sections. */
12401 htab
->elf
.irelplt
->rawsize
= htab
->elf
.irelplt
->size
;
12402 htab
->elf
.irelplt
->size
-= htab
->got_reli_size
;
12403 htab
->got_reli_size
= 0;
12405 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12407 asection
*got
, *relgot
;
12409 if (!is_ppc64_elf (ibfd
))
12412 got
= ppc64_elf_tdata (ibfd
)->got
;
12415 got
->rawsize
= got
->size
;
12417 relgot
= ppc64_elf_tdata (ibfd
)->relgot
;
12418 relgot
->rawsize
= relgot
->size
;
12423 /* Now reallocate the got, local syms first. We don't need to
12424 allocate section contents again since we never increase size. */
12425 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12427 struct got_entry
**lgot_ents
;
12428 struct got_entry
**end_lgot_ents
;
12429 struct plt_entry
**local_plt
;
12430 struct plt_entry
**end_local_plt
;
12431 unsigned char *lgot_masks
;
12432 bfd_size_type locsymcount
;
12433 Elf_Internal_Shdr
*symtab_hdr
;
12436 if (!is_ppc64_elf (ibfd
))
12439 lgot_ents
= elf_local_got_ents (ibfd
);
12443 symtab_hdr
= &elf_symtab_hdr (ibfd
);
12444 locsymcount
= symtab_hdr
->sh_info
;
12445 end_lgot_ents
= lgot_ents
+ locsymcount
;
12446 local_plt
= (struct plt_entry
**) end_lgot_ents
;
12447 end_local_plt
= local_plt
+ locsymcount
;
12448 lgot_masks
= (unsigned char *) end_local_plt
;
12449 s
= ppc64_elf_tdata (ibfd
)->got
;
12450 for (; lgot_ents
< end_lgot_ents
; ++lgot_ents
, ++lgot_masks
)
12452 struct got_entry
*ent
;
12454 for (ent
= *lgot_ents
; ent
!= NULL
; ent
= ent
->next
)
12456 unsigned int ent_size
= 8;
12457 unsigned int rel_size
= sizeof (Elf64_External_Rela
);
12459 ent
->got
.offset
= s
->size
;
12460 if ((ent
->tls_type
& *lgot_masks
& TLS_GD
) != 0)
12465 s
->size
+= ent_size
;
12466 if ((*lgot_masks
& (TLS_TLS
| PLT_IFUNC
)) == PLT_IFUNC
)
12468 htab
->elf
.irelplt
->size
+= rel_size
;
12469 htab
->got_reli_size
+= rel_size
;
12471 else if (bfd_link_pic (info
)
12472 && !(ent
->tls_type
!= 0
12473 && bfd_link_executable (info
)))
12475 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
12476 srel
->size
+= rel_size
;
12482 elf_link_hash_traverse (&htab
->elf
, reallocate_got
, info
);
12484 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12486 struct got_entry
*ent
;
12488 if (!is_ppc64_elf (ibfd
))
12491 ent
= ppc64_tlsld_got (ibfd
);
12492 if (!ent
->is_indirect
12493 && ent
->got
.offset
!= (bfd_vma
) -1)
12495 asection
*s
= ppc64_elf_tdata (ibfd
)->got
;
12496 ent
->got
.offset
= s
->size
;
12498 if (bfd_link_dll (info
))
12500 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
12501 srel
->size
+= sizeof (Elf64_External_Rela
);
12506 done_something
= htab
->elf
.irelplt
->rawsize
!= htab
->elf
.irelplt
->size
;
12507 if (!done_something
)
12508 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12512 if (!is_ppc64_elf (ibfd
))
12515 got
= ppc64_elf_tdata (ibfd
)->got
;
12518 done_something
= got
->rawsize
!= got
->size
;
12519 if (done_something
)
12524 if (done_something
)
12525 (*htab
->params
->layout_sections_again
) ();
12527 /* Set up for second pass over toc sections to recalculate elf_gp
12528 on input sections. */
12529 htab
->toc_bfd
= NULL
;
12530 htab
->toc_first_sec
= NULL
;
12531 htab
->second_toc_pass
= TRUE
;
12532 return done_something
;
12535 /* Called after second pass of multitoc partitioning. */
12538 ppc64_elf_finish_multitoc_partition (struct bfd_link_info
*info
)
12540 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12542 /* After the second pass, toc_curr tracks the TOC offset used
12543 for code sections below in ppc64_elf_next_input_section. */
12544 htab
->toc_curr
= TOC_BASE_OFF
;
12547 /* No toc references were found in ISEC. If the code in ISEC makes no
12548 calls, then there's no need to use toc adjusting stubs when branching
12549 into ISEC. Actually, indirect calls from ISEC are OK as they will
12550 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
12551 needed, and 2 if a cyclical call-graph was found but no other reason
12552 for a stub was detected. If called from the top level, a return of
12553 2 means the same as a return of 0. */
12556 toc_adjusting_stub_needed (struct bfd_link_info
*info
, asection
*isec
)
12560 /* Mark this section as checked. */
12561 isec
->call_check_done
= 1;
12563 /* We know none of our code bearing sections will need toc stubs. */
12564 if ((isec
->flags
& SEC_LINKER_CREATED
) != 0)
12567 if (isec
->size
== 0)
12570 if (isec
->output_section
== NULL
)
12574 if (isec
->reloc_count
!= 0)
12576 Elf_Internal_Rela
*relstart
, *rel
;
12577 Elf_Internal_Sym
*local_syms
;
12578 struct ppc_link_hash_table
*htab
;
12580 relstart
= _bfd_elf_link_read_relocs (isec
->owner
, isec
, NULL
, NULL
,
12581 info
->keep_memory
);
12582 if (relstart
== NULL
)
12585 /* Look for branches to outside of this section. */
12587 htab
= ppc_hash_table (info
);
12591 for (rel
= relstart
; rel
< relstart
+ isec
->reloc_count
; ++rel
)
12593 enum elf_ppc64_reloc_type r_type
;
12594 unsigned long r_symndx
;
12595 struct elf_link_hash_entry
*h
;
12596 struct ppc_link_hash_entry
*eh
;
12597 Elf_Internal_Sym
*sym
;
12599 struct _opd_sec_data
*opd
;
12603 r_type
= ELF64_R_TYPE (rel
->r_info
);
12604 if (r_type
!= R_PPC64_REL24
12605 && r_type
!= R_PPC64_REL24_NOTOC
12606 && r_type
!= R_PPC64_REL14
12607 && r_type
!= R_PPC64_REL14_BRTAKEN
12608 && r_type
!= R_PPC64_REL14_BRNTAKEN
12609 && r_type
!= R_PPC64_PLTCALL
12610 && r_type
!= R_PPC64_PLTCALL_NOTOC
)
12613 r_symndx
= ELF64_R_SYM (rel
->r_info
);
12614 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
, r_symndx
,
12621 /* Calls to dynamic lib functions go through a plt call stub
12623 eh
= ppc_elf_hash_entry (h
);
12625 && (eh
->elf
.plt
.plist
!= NULL
12627 && ppc_follow_link (eh
->oh
)->elf
.plt
.plist
!= NULL
)))
12633 if (sym_sec
== NULL
)
12634 /* Ignore other undefined symbols. */
12637 /* Assume branches to other sections not included in the
12638 link need stubs too, to cover -R and absolute syms. */
12639 if (sym_sec
->output_section
== NULL
)
12646 sym_value
= sym
->st_value
;
12649 if (h
->root
.type
!= bfd_link_hash_defined
12650 && h
->root
.type
!= bfd_link_hash_defweak
)
12652 sym_value
= h
->root
.u
.def
.value
;
12654 sym_value
+= rel
->r_addend
;
12656 /* If this branch reloc uses an opd sym, find the code section. */
12657 opd
= get_opd_info (sym_sec
);
12660 if (h
== NULL
&& opd
->adjust
!= NULL
)
12664 adjust
= opd
->adjust
[OPD_NDX (sym_value
)];
12666 /* Assume deleted functions won't ever be called. */
12668 sym_value
+= adjust
;
12671 dest
= opd_entry_value (sym_sec
, sym_value
,
12672 &sym_sec
, NULL
, FALSE
);
12673 if (dest
== (bfd_vma
) -1)
12678 + sym_sec
->output_offset
12679 + sym_sec
->output_section
->vma
);
12681 /* Ignore branch to self. */
12682 if (sym_sec
== isec
)
12685 /* If the called function uses the toc, we need a stub. */
12686 if (sym_sec
->has_toc_reloc
12687 || sym_sec
->makes_toc_func_call
)
12693 /* Assume any branch that needs a long branch stub might in fact
12694 need a plt_branch stub. A plt_branch stub uses r2. */
12695 else if (dest
- (isec
->output_offset
12696 + isec
->output_section
->vma
12697 + rel
->r_offset
) + (1 << 25)
12698 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
12706 /* If calling back to a section in the process of being
12707 tested, we can't say for sure that no toc adjusting stubs
12708 are needed, so don't return zero. */
12709 else if (sym_sec
->call_check_in_progress
)
12712 /* Branches to another section that itself doesn't have any TOC
12713 references are OK. Recursively call ourselves to check. */
12714 else if (!sym_sec
->call_check_done
)
12718 /* Mark current section as indeterminate, so that other
12719 sections that call back to current won't be marked as
12721 isec
->call_check_in_progress
= 1;
12722 recur
= toc_adjusting_stub_needed (info
, sym_sec
);
12723 isec
->call_check_in_progress
= 0;
12734 if (local_syms
!= NULL
12735 && (elf_symtab_hdr (isec
->owner
).contents
12736 != (unsigned char *) local_syms
))
12738 if (elf_section_data (isec
)->relocs
!= relstart
)
12743 && isec
->map_head
.s
!= NULL
12744 && (strcmp (isec
->output_section
->name
, ".init") == 0
12745 || strcmp (isec
->output_section
->name
, ".fini") == 0))
12747 if (isec
->map_head
.s
->has_toc_reloc
12748 || isec
->map_head
.s
->makes_toc_func_call
)
12750 else if (!isec
->map_head
.s
->call_check_done
)
12753 isec
->call_check_in_progress
= 1;
12754 recur
= toc_adjusting_stub_needed (info
, isec
->map_head
.s
);
12755 isec
->call_check_in_progress
= 0;
12762 isec
->makes_toc_func_call
= 1;
12767 /* The linker repeatedly calls this function for each input section,
12768 in the order that input sections are linked into output sections.
12769 Build lists of input sections to determine groupings between which
12770 we may insert linker stubs. */
12773 ppc64_elf_next_input_section (struct bfd_link_info
*info
, asection
*isec
)
12775 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12780 if ((isec
->output_section
->flags
& SEC_CODE
) != 0
12781 && isec
->output_section
->id
< htab
->sec_info_arr_size
)
12783 /* This happens to make the list in reverse order,
12784 which is what we want. */
12785 htab
->sec_info
[isec
->id
].u
.list
12786 = htab
->sec_info
[isec
->output_section
->id
].u
.list
;
12787 htab
->sec_info
[isec
->output_section
->id
].u
.list
= isec
;
12790 if (htab
->multi_toc_needed
)
12792 /* Analyse sections that aren't already flagged as needing a
12793 valid toc pointer. Exclude .fixup for the linux kernel.
12794 .fixup contains branches, but only back to the function that
12795 hit an exception. */
12796 if (!(isec
->has_toc_reloc
12797 || (isec
->flags
& SEC_CODE
) == 0
12798 || strcmp (isec
->name
, ".fixup") == 0
12799 || isec
->call_check_done
))
12801 if (toc_adjusting_stub_needed (info
, isec
) < 0)
12804 /* Make all sections use the TOC assigned for this object file.
12805 This will be wrong for pasted sections; We fix that in
12806 check_pasted_section(). */
12807 if (elf_gp (isec
->owner
) != 0)
12808 htab
->toc_curr
= elf_gp (isec
->owner
);
12811 htab
->sec_info
[isec
->id
].toc_off
= htab
->toc_curr
;
12815 /* Check that all .init and .fini sections use the same toc, if they
12816 have toc relocs. */
12819 check_pasted_section (struct bfd_link_info
*info
, const char *name
)
12821 asection
*o
= bfd_get_section_by_name (info
->output_bfd
, name
);
12825 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12826 bfd_vma toc_off
= 0;
12829 for (i
= o
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
12830 if (i
->has_toc_reloc
)
12833 toc_off
= htab
->sec_info
[i
->id
].toc_off
;
12834 else if (toc_off
!= htab
->sec_info
[i
->id
].toc_off
)
12839 for (i
= o
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
12840 if (i
->makes_toc_func_call
)
12842 toc_off
= htab
->sec_info
[i
->id
].toc_off
;
12846 /* Make sure the whole pasted function uses the same toc offset. */
12848 for (i
= o
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
12849 htab
->sec_info
[i
->id
].toc_off
= toc_off
;
12855 ppc64_elf_check_init_fini (struct bfd_link_info
*info
)
12857 return (check_pasted_section (info
, ".init")
12858 & check_pasted_section (info
, ".fini"));
12861 /* See whether we can group stub sections together. Grouping stub
12862 sections may result in fewer stubs. More importantly, we need to
12863 put all .init* and .fini* stubs at the beginning of the .init or
12864 .fini output sections respectively, because glibc splits the
12865 _init and _fini functions into multiple parts. Putting a stub in
12866 the middle of a function is not a good idea. */
12869 group_sections (struct bfd_link_info
*info
,
12870 bfd_size_type stub_group_size
,
12871 bfd_boolean stubs_always_before_branch
)
12873 struct ppc_link_hash_table
*htab
;
12875 bfd_boolean suppress_size_errors
;
12877 htab
= ppc_hash_table (info
);
12881 suppress_size_errors
= FALSE
;
12882 if (stub_group_size
== 1)
12884 /* Default values. */
12885 if (stubs_always_before_branch
)
12886 stub_group_size
= 0x1e00000;
12888 stub_group_size
= 0x1c00000;
12889 suppress_size_errors
= TRUE
;
12892 for (osec
= info
->output_bfd
->sections
; osec
!= NULL
; osec
= osec
->next
)
12896 if (osec
->id
>= htab
->sec_info_arr_size
)
12899 tail
= htab
->sec_info
[osec
->id
].u
.list
;
12900 while (tail
!= NULL
)
12904 bfd_size_type total
;
12905 bfd_boolean big_sec
;
12907 struct map_stub
*group
;
12908 bfd_size_type group_size
;
12911 total
= tail
->size
;
12912 group_size
= (ppc64_elf_section_data (tail
) != NULL
12913 && ppc64_elf_section_data (tail
)->has_14bit_branch
12914 ? stub_group_size
>> 10 : stub_group_size
);
12916 big_sec
= total
> group_size
;
12917 if (big_sec
&& !suppress_size_errors
)
12918 /* xgettext:c-format */
12919 _bfd_error_handler (_("%pB section %pA exceeds stub group size"),
12920 tail
->owner
, tail
);
12921 curr_toc
= htab
->sec_info
[tail
->id
].toc_off
;
12923 while ((prev
= htab
->sec_info
[curr
->id
].u
.list
) != NULL
12924 && ((total
+= curr
->output_offset
- prev
->output_offset
)
12925 < (ppc64_elf_section_data (prev
) != NULL
12926 && ppc64_elf_section_data (prev
)->has_14bit_branch
12927 ? (group_size
= stub_group_size
>> 10) : group_size
))
12928 && htab
->sec_info
[prev
->id
].toc_off
== curr_toc
)
12931 /* OK, the size from the start of CURR to the end is less
12932 than group_size and thus can be handled by one stub
12933 section. (or the tail section is itself larger than
12934 group_size, in which case we may be toast.) We should
12935 really be keeping track of the total size of stubs added
12936 here, as stubs contribute to the final output section
12937 size. That's a little tricky, and this way will only
12938 break if stubs added make the total size more than 2^25,
12939 ie. for the default stub_group_size, if stubs total more
12940 than 2097152 bytes, or nearly 75000 plt call stubs. */
12941 group
= bfd_alloc (curr
->owner
, sizeof (*group
));
12944 group
->link_sec
= curr
;
12945 group
->stub_sec
= NULL
;
12946 group
->needs_save_res
= 0;
12947 group
->lr_restore
= 0;
12948 group
->eh_size
= 0;
12949 group
->eh_base
= 0;
12950 group
->next
= htab
->group
;
12951 htab
->group
= group
;
12954 prev
= htab
->sec_info
[tail
->id
].u
.list
;
12955 /* Set up this stub group. */
12956 htab
->sec_info
[tail
->id
].u
.group
= group
;
12958 while (tail
!= curr
&& (tail
= prev
) != NULL
);
12960 /* But wait, there's more! Input sections up to group_size
12961 bytes before the stub section can be handled by it too.
12962 Don't do this if we have a really large section after the
12963 stubs, as adding more stubs increases the chance that
12964 branches may not reach into the stub section. */
12965 if (!stubs_always_before_branch
&& !big_sec
)
12968 while (prev
!= NULL
12969 && ((total
+= tail
->output_offset
- prev
->output_offset
)
12970 < (ppc64_elf_section_data (prev
) != NULL
12971 && ppc64_elf_section_data (prev
)->has_14bit_branch
12972 ? (group_size
= stub_group_size
>> 10)
12974 && htab
->sec_info
[prev
->id
].toc_off
== curr_toc
)
12977 prev
= htab
->sec_info
[tail
->id
].u
.list
;
12978 htab
->sec_info
[tail
->id
].u
.group
= group
;
12987 static const unsigned char glink_eh_frame_cie
[] =
12989 0, 0, 0, 16, /* length. */
12990 0, 0, 0, 0, /* id. */
12991 1, /* CIE version. */
12992 'z', 'R', 0, /* Augmentation string. */
12993 4, /* Code alignment. */
12994 0x78, /* Data alignment. */
12996 1, /* Augmentation size. */
12997 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding. */
12998 DW_CFA_def_cfa
, 1, 0 /* def_cfa: r1 offset 0. */
13001 /* Stripping output sections is normally done before dynamic section
13002 symbols have been allocated. This function is called later, and
13003 handles cases like htab->brlt which is mapped to its own output
13007 maybe_strip_output (struct bfd_link_info
*info
, asection
*isec
)
13009 if (isec
->size
== 0
13010 && isec
->output_section
->size
== 0
13011 && !(isec
->output_section
->flags
& SEC_KEEP
)
13012 && !bfd_section_removed_from_list (info
->output_bfd
,
13013 isec
->output_section
)
13014 && elf_section_data (isec
->output_section
)->dynindx
== 0)
13016 isec
->output_section
->flags
|= SEC_EXCLUDE
;
13017 bfd_section_list_remove (info
->output_bfd
, isec
->output_section
);
13018 info
->output_bfd
->section_count
--;
13022 /* Determine and set the size of the stub section for a final link.
13024 The basic idea here is to examine all the relocations looking for
13025 PC-relative calls to a target that is unreachable with a "bl"
13029 ppc64_elf_size_stubs (struct bfd_link_info
*info
)
13031 bfd_size_type stub_group_size
;
13032 bfd_boolean stubs_always_before_branch
;
13033 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
13038 if (htab
->params
->plt_thread_safe
== -1 && !bfd_link_executable (info
))
13039 htab
->params
->plt_thread_safe
= 1;
13040 if (!htab
->opd_abi
)
13041 htab
->params
->plt_thread_safe
= 0;
13042 else if (htab
->params
->plt_thread_safe
== -1)
13044 static const char *const thread_starter
[] =
13048 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
13050 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
13051 "mq_notify", "create_timer",
13056 "GOMP_parallel_start",
13057 "GOMP_parallel_loop_static",
13058 "GOMP_parallel_loop_static_start",
13059 "GOMP_parallel_loop_dynamic",
13060 "GOMP_parallel_loop_dynamic_start",
13061 "GOMP_parallel_loop_guided",
13062 "GOMP_parallel_loop_guided_start",
13063 "GOMP_parallel_loop_runtime",
13064 "GOMP_parallel_loop_runtime_start",
13065 "GOMP_parallel_sections",
13066 "GOMP_parallel_sections_start",
13072 for (i
= 0; i
< ARRAY_SIZE (thread_starter
); i
++)
13074 struct elf_link_hash_entry
*h
;
13075 h
= elf_link_hash_lookup (&htab
->elf
, thread_starter
[i
],
13076 FALSE
, FALSE
, TRUE
);
13077 htab
->params
->plt_thread_safe
= h
!= NULL
&& h
->ref_regular
;
13078 if (htab
->params
->plt_thread_safe
)
13082 stubs_always_before_branch
= htab
->params
->group_size
< 0;
13083 if (htab
->params
->group_size
< 0)
13084 stub_group_size
= -htab
->params
->group_size
;
13086 stub_group_size
= htab
->params
->group_size
;
13088 if (!group_sections (info
, stub_group_size
, stubs_always_before_branch
))
13091 #define STUB_SHRINK_ITER 20
13092 /* Loop until no stubs added. After iteration 20 of this loop we may
13093 exit on a stub section shrinking. This is to break out of a
13094 pathological case where adding stubs on one iteration decreases
13095 section gaps (perhaps due to alignment), which then requires
13096 fewer or smaller stubs on the next iteration. */
13101 unsigned int bfd_indx
;
13102 struct map_stub
*group
;
13104 htab
->stub_iteration
+= 1;
13106 for (input_bfd
= info
->input_bfds
, bfd_indx
= 0;
13108 input_bfd
= input_bfd
->link
.next
, bfd_indx
++)
13110 Elf_Internal_Shdr
*symtab_hdr
;
13112 Elf_Internal_Sym
*local_syms
= NULL
;
13114 if (!is_ppc64_elf (input_bfd
))
13117 /* We'll need the symbol table in a second. */
13118 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
13119 if (symtab_hdr
->sh_info
== 0)
13122 /* Walk over each section attached to the input bfd. */
13123 for (section
= input_bfd
->sections
;
13125 section
= section
->next
)
13127 Elf_Internal_Rela
*internal_relocs
, *irelaend
, *irela
;
13129 /* If there aren't any relocs, then there's nothing more
13131 if ((section
->flags
& SEC_RELOC
) == 0
13132 || (section
->flags
& SEC_ALLOC
) == 0
13133 || (section
->flags
& SEC_LOAD
) == 0
13134 || (section
->flags
& SEC_CODE
) == 0
13135 || section
->reloc_count
== 0)
13138 /* If this section is a link-once section that will be
13139 discarded, then don't create any stubs. */
13140 if (section
->output_section
== NULL
13141 || section
->output_section
->owner
!= info
->output_bfd
)
13144 /* Get the relocs. */
13146 = _bfd_elf_link_read_relocs (input_bfd
, section
, NULL
, NULL
,
13147 info
->keep_memory
);
13148 if (internal_relocs
== NULL
)
13149 goto error_ret_free_local
;
13151 /* Now examine each relocation. */
13152 irela
= internal_relocs
;
13153 irelaend
= irela
+ section
->reloc_count
;
13154 for (; irela
< irelaend
; irela
++)
13156 enum elf_ppc64_reloc_type r_type
;
13157 unsigned int r_indx
;
13158 enum ppc_stub_type stub_type
;
13159 struct ppc_stub_hash_entry
*stub_entry
;
13160 asection
*sym_sec
, *code_sec
;
13161 bfd_vma sym_value
, code_value
;
13162 bfd_vma destination
;
13163 unsigned long local_off
;
13164 bfd_boolean ok_dest
;
13165 struct ppc_link_hash_entry
*hash
;
13166 struct ppc_link_hash_entry
*fdh
;
13167 struct elf_link_hash_entry
*h
;
13168 Elf_Internal_Sym
*sym
;
13170 const asection
*id_sec
;
13171 struct _opd_sec_data
*opd
;
13172 struct plt_entry
*plt_ent
;
13174 r_type
= ELF64_R_TYPE (irela
->r_info
);
13175 r_indx
= ELF64_R_SYM (irela
->r_info
);
13177 if (r_type
>= R_PPC64_max
)
13179 bfd_set_error (bfd_error_bad_value
);
13180 goto error_ret_free_internal
;
13183 /* Only look for stubs on branch instructions. */
13184 if (r_type
!= R_PPC64_REL24
13185 && r_type
!= R_PPC64_REL24_NOTOC
13186 && r_type
!= R_PPC64_REL14
13187 && r_type
!= R_PPC64_REL14_BRTAKEN
13188 && r_type
!= R_PPC64_REL14_BRNTAKEN
)
13191 /* Now determine the call target, its name, value,
13193 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
13194 r_indx
, input_bfd
))
13195 goto error_ret_free_internal
;
13196 hash
= ppc_elf_hash_entry (h
);
13203 sym_value
= sym
->st_value
;
13204 if (sym_sec
!= NULL
13205 && sym_sec
->output_section
!= NULL
)
13208 else if (hash
->elf
.root
.type
== bfd_link_hash_defined
13209 || hash
->elf
.root
.type
== bfd_link_hash_defweak
)
13211 sym_value
= hash
->elf
.root
.u
.def
.value
;
13212 if (sym_sec
->output_section
!= NULL
)
13215 else if (hash
->elf
.root
.type
== bfd_link_hash_undefweak
13216 || hash
->elf
.root
.type
== bfd_link_hash_undefined
)
13218 /* Recognise an old ABI func code entry sym, and
13219 use the func descriptor sym instead if it is
13221 if (hash
->elf
.root
.root
.string
[0] == '.'
13222 && hash
->oh
!= NULL
)
13224 fdh
= ppc_follow_link (hash
->oh
);
13225 if (fdh
->elf
.root
.type
== bfd_link_hash_defined
13226 || fdh
->elf
.root
.type
== bfd_link_hash_defweak
)
13228 sym_sec
= fdh
->elf
.root
.u
.def
.section
;
13229 sym_value
= fdh
->elf
.root
.u
.def
.value
;
13230 if (sym_sec
->output_section
!= NULL
)
13239 bfd_set_error (bfd_error_bad_value
);
13240 goto error_ret_free_internal
;
13247 sym_value
+= irela
->r_addend
;
13248 destination
= (sym_value
13249 + sym_sec
->output_offset
13250 + sym_sec
->output_section
->vma
);
13251 local_off
= PPC64_LOCAL_ENTRY_OFFSET (hash
13256 code_sec
= sym_sec
;
13257 code_value
= sym_value
;
13258 opd
= get_opd_info (sym_sec
);
13263 if (hash
== NULL
&& opd
->adjust
!= NULL
)
13265 long adjust
= opd
->adjust
[OPD_NDX (sym_value
)];
13268 code_value
+= adjust
;
13269 sym_value
+= adjust
;
13271 dest
= opd_entry_value (sym_sec
, sym_value
,
13272 &code_sec
, &code_value
, FALSE
);
13273 if (dest
!= (bfd_vma
) -1)
13275 destination
= dest
;
13278 /* Fixup old ABI sym to point at code
13280 hash
->elf
.root
.type
= bfd_link_hash_defweak
;
13281 hash
->elf
.root
.u
.def
.section
= code_sec
;
13282 hash
->elf
.root
.u
.def
.value
= code_value
;
13287 /* Determine what (if any) linker stub is needed. */
13289 stub_type
= ppc_type_of_stub (section
, irela
, &hash
,
13290 &plt_ent
, destination
,
13293 if (r_type
== R_PPC64_REL24_NOTOC
)
13295 if (stub_type
== ppc_stub_plt_call
)
13296 stub_type
= ppc_stub_plt_call_notoc
;
13297 else if (stub_type
== ppc_stub_long_branch
13298 || (code_sec
!= NULL
13299 && code_sec
->output_section
!= NULL
13300 && (((hash
? hash
->elf
.other
: sym
->st_other
)
13301 & STO_PPC64_LOCAL_MASK
)
13302 > 1 << STO_PPC64_LOCAL_BIT
)))
13303 stub_type
= ppc_stub_long_branch_notoc
;
13305 else if (stub_type
!= ppc_stub_plt_call
)
13307 /* Check whether we need a TOC adjusting stub.
13308 Since the linker pastes together pieces from
13309 different object files when creating the
13310 _init and _fini functions, it may be that a
13311 call to what looks like a local sym is in
13312 fact a call needing a TOC adjustment. */
13313 if ((code_sec
!= NULL
13314 && code_sec
->output_section
!= NULL
13315 && (htab
->sec_info
[code_sec
->id
].toc_off
13316 != htab
->sec_info
[section
->id
].toc_off
)
13317 && (code_sec
->has_toc_reloc
13318 || code_sec
->makes_toc_func_call
))
13319 || (((hash
? hash
->elf
.other
: sym
->st_other
)
13320 & STO_PPC64_LOCAL_MASK
)
13321 == 1 << STO_PPC64_LOCAL_BIT
))
13322 stub_type
= ppc_stub_long_branch_r2off
;
13325 if (stub_type
== ppc_stub_none
)
13328 /* __tls_get_addr calls might be eliminated. */
13329 if (stub_type
!= ppc_stub_plt_call
13330 && stub_type
!= ppc_stub_plt_call_notoc
13332 && is_tls_get_addr (&hash
->elf
, htab
)
13333 && section
->has_tls_reloc
13334 && irela
!= internal_relocs
)
13336 /* Get tls info. */
13337 unsigned char *tls_mask
;
13339 if (!get_tls_mask (&tls_mask
, NULL
, NULL
, &local_syms
,
13340 irela
- 1, input_bfd
))
13341 goto error_ret_free_internal
;
13342 if ((*tls_mask
& TLS_TLS
) != 0
13343 && (*tls_mask
& (TLS_GD
| TLS_LD
)) == 0)
13347 if (stub_type
== ppc_stub_plt_call
)
13350 && htab
->params
->plt_localentry0
!= 0
13351 && is_elfv2_localentry0 (&hash
->elf
))
13352 htab
->has_plt_localentry0
= 1;
13353 else if (irela
+ 1 < irelaend
13354 && irela
[1].r_offset
== irela
->r_offset
+ 4
13355 && (ELF64_R_TYPE (irela
[1].r_info
)
13356 == R_PPC64_TOCSAVE
))
13358 if (!tocsave_find (htab
, INSERT
,
13359 &local_syms
, irela
+ 1, input_bfd
))
13360 goto error_ret_free_internal
;
13363 stub_type
= ppc_stub_plt_call_r2save
;
13366 /* Support for grouping stub sections. */
13367 id_sec
= htab
->sec_info
[section
->id
].u
.group
->link_sec
;
13369 /* Get the name of this stub. */
13370 stub_name
= ppc_stub_name (id_sec
, sym_sec
, hash
, irela
);
13372 goto error_ret_free_internal
;
13374 stub_entry
= ppc_stub_hash_lookup (&htab
->stub_hash_table
,
13375 stub_name
, FALSE
, FALSE
);
13376 if (stub_entry
!= NULL
)
13378 enum ppc_stub_type old_type
;
13379 /* A stub has already been created, but it may
13380 not be the required type. We shouldn't be
13381 transitioning from plt_call to long_branch
13382 stubs or vice versa, but we might be
13383 upgrading from plt_call to plt_call_r2save or
13384 from long_branch to long_branch_r2off. */
13386 old_type
= stub_entry
->stub_type
;
13392 case ppc_stub_save_res
:
13395 case ppc_stub_plt_call
:
13396 case ppc_stub_plt_call_r2save
:
13397 case ppc_stub_plt_call_notoc
:
13398 case ppc_stub_plt_call_both
:
13399 if (stub_type
== ppc_stub_plt_call
)
13401 else if (stub_type
== ppc_stub_plt_call_r2save
)
13403 if (old_type
== ppc_stub_plt_call_notoc
)
13404 stub_type
= ppc_stub_plt_call_both
;
13406 else if (stub_type
== ppc_stub_plt_call_notoc
)
13408 if (old_type
== ppc_stub_plt_call_r2save
)
13409 stub_type
= ppc_stub_plt_call_both
;
13415 case ppc_stub_plt_branch
:
13416 case ppc_stub_plt_branch_r2off
:
13417 case ppc_stub_plt_branch_notoc
:
13418 case ppc_stub_plt_branch_both
:
13419 old_type
+= (ppc_stub_long_branch
13420 - ppc_stub_plt_branch
);
13421 /* Fall through. */
13422 case ppc_stub_long_branch
:
13423 case ppc_stub_long_branch_r2off
:
13424 case ppc_stub_long_branch_notoc
:
13425 case ppc_stub_long_branch_both
:
13426 if (stub_type
== ppc_stub_long_branch
)
13428 else if (stub_type
== ppc_stub_long_branch_r2off
)
13430 if (old_type
== ppc_stub_long_branch_notoc
)
13431 stub_type
= ppc_stub_long_branch_both
;
13433 else if (stub_type
== ppc_stub_long_branch_notoc
)
13435 if (old_type
== ppc_stub_long_branch_r2off
)
13436 stub_type
= ppc_stub_long_branch_both
;
13442 if (old_type
< stub_type
)
13443 stub_entry
->stub_type
= stub_type
;
13447 stub_entry
= ppc_add_stub (stub_name
, section
, info
);
13448 if (stub_entry
== NULL
)
13451 error_ret_free_internal
:
13452 if (elf_section_data (section
)->relocs
== NULL
)
13453 free (internal_relocs
);
13454 error_ret_free_local
:
13455 if (local_syms
!= NULL
13456 && (symtab_hdr
->contents
13457 != (unsigned char *) local_syms
))
13462 stub_entry
->stub_type
= stub_type
;
13463 if (stub_type
>= ppc_stub_plt_call
13464 && stub_type
<= ppc_stub_plt_call_both
)
13466 stub_entry
->target_value
= sym_value
;
13467 stub_entry
->target_section
= sym_sec
;
13471 stub_entry
->target_value
= code_value
;
13472 stub_entry
->target_section
= code_sec
;
13474 stub_entry
->h
= hash
;
13475 stub_entry
->plt_ent
= plt_ent
;
13476 stub_entry
->symtype
13477 = hash
? hash
->elf
.type
: ELF_ST_TYPE (sym
->st_info
);
13478 stub_entry
->other
= hash
? hash
->elf
.other
: sym
->st_other
;
13481 && (hash
->elf
.root
.type
== bfd_link_hash_defined
13482 || hash
->elf
.root
.type
== bfd_link_hash_defweak
))
13483 htab
->stub_globals
+= 1;
13486 /* We're done with the internal relocs, free them. */
13487 if (elf_section_data (section
)->relocs
!= internal_relocs
)
13488 free (internal_relocs
);
13491 if (local_syms
!= NULL
13492 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
13494 if (!info
->keep_memory
)
13497 symtab_hdr
->contents
= (unsigned char *) local_syms
;
13501 /* We may have added some stubs. Find out the new size of the
13503 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13505 group
->lr_restore
= 0;
13506 group
->eh_size
= 0;
13507 if (group
->stub_sec
!= NULL
)
13509 asection
*stub_sec
= group
->stub_sec
;
13511 if (htab
->stub_iteration
<= STUB_SHRINK_ITER
13512 || stub_sec
->rawsize
< stub_sec
->size
)
13513 /* Past STUB_SHRINK_ITER, rawsize is the max size seen. */
13514 stub_sec
->rawsize
= stub_sec
->size
;
13515 stub_sec
->size
= 0;
13516 stub_sec
->reloc_count
= 0;
13517 stub_sec
->flags
&= ~SEC_RELOC
;
13521 if (htab
->stub_iteration
<= STUB_SHRINK_ITER
13522 || htab
->brlt
->rawsize
< htab
->brlt
->size
)
13523 htab
->brlt
->rawsize
= htab
->brlt
->size
;
13524 htab
->brlt
->size
= 0;
13525 htab
->brlt
->reloc_count
= 0;
13526 htab
->brlt
->flags
&= ~SEC_RELOC
;
13527 if (htab
->relbrlt
!= NULL
)
13528 htab
->relbrlt
->size
= 0;
13530 bfd_hash_traverse (&htab
->stub_hash_table
, ppc_size_one_stub
, info
);
13532 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13533 if (group
->needs_save_res
)
13534 group
->stub_sec
->size
+= htab
->sfpr
->size
;
13536 if (info
->emitrelocations
13537 && htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
13539 htab
->glink
->reloc_count
= 1;
13540 htab
->glink
->flags
|= SEC_RELOC
;
13543 if (htab
->glink_eh_frame
!= NULL
13544 && !bfd_is_abs_section (htab
->glink_eh_frame
->output_section
)
13545 && htab
->glink_eh_frame
->output_section
->size
> 8)
13547 size_t size
= 0, align
= 4;
13549 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13550 if (group
->eh_size
!= 0)
13551 size
+= (group
->eh_size
+ 17 + align
- 1) & -align
;
13552 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
13553 size
+= (24 + align
- 1) & -align
;
13555 size
+= (sizeof (glink_eh_frame_cie
) + align
- 1) & -align
;
13556 align
= 1ul << htab
->glink_eh_frame
->output_section
->alignment_power
;
13557 size
= (size
+ align
- 1) & -align
;
13558 htab
->glink_eh_frame
->rawsize
= htab
->glink_eh_frame
->size
;
13559 htab
->glink_eh_frame
->size
= size
;
13562 if (htab
->params
->plt_stub_align
!= 0)
13563 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13564 if (group
->stub_sec
!= NULL
)
13566 int align
= abs (htab
->params
->plt_stub_align
);
13567 group
->stub_sec
->size
13568 = (group
->stub_sec
->size
+ (1 << align
) - 1) & -(1 << align
);
13571 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13572 if (group
->stub_sec
!= NULL
13573 && group
->stub_sec
->rawsize
!= group
->stub_sec
->size
13574 && (htab
->stub_iteration
<= STUB_SHRINK_ITER
13575 || group
->stub_sec
->rawsize
< group
->stub_sec
->size
))
13579 && (htab
->brlt
->rawsize
== htab
->brlt
->size
13580 || (htab
->stub_iteration
> STUB_SHRINK_ITER
13581 && htab
->brlt
->rawsize
> htab
->brlt
->size
))
13582 && (htab
->glink_eh_frame
== NULL
13583 || htab
->glink_eh_frame
->rawsize
== htab
->glink_eh_frame
->size
))
13586 /* Ask the linker to do its stuff. */
13587 (*htab
->params
->layout_sections_again
) ();
13590 if (htab
->glink_eh_frame
!= NULL
13591 && htab
->glink_eh_frame
->size
!= 0)
13594 bfd_byte
*p
, *last_fde
;
13595 size_t last_fde_len
, size
, align
, pad
;
13596 struct map_stub
*group
;
13598 /* It is necessary to at least have a rough outline of the
13599 linker generated CIEs and FDEs written before
13600 bfd_elf_discard_info is run, in order for these FDEs to be
13601 indexed in .eh_frame_hdr. */
13602 p
= bfd_zalloc (htab
->glink_eh_frame
->owner
, htab
->glink_eh_frame
->size
);
13605 htab
->glink_eh_frame
->contents
= p
;
13609 memcpy (p
, glink_eh_frame_cie
, sizeof (glink_eh_frame_cie
));
13610 /* CIE length (rewrite in case little-endian). */
13611 last_fde_len
= ((sizeof (glink_eh_frame_cie
) + align
- 1) & -align
) - 4;
13612 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
, p
);
13613 p
+= last_fde_len
+ 4;
13615 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13616 if (group
->eh_size
!= 0)
13618 group
->eh_base
= p
- htab
->glink_eh_frame
->contents
;
13620 last_fde_len
= ((group
->eh_size
+ 17 + align
- 1) & -align
) - 4;
13622 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
, p
);
13625 val
= p
- htab
->glink_eh_frame
->contents
;
13626 bfd_put_32 (htab
->elf
.dynobj
, val
, p
);
13628 /* Offset to stub section, written later. */
13630 /* stub section size. */
13631 bfd_put_32 (htab
->elf
.dynobj
, group
->stub_sec
->size
, p
);
13633 /* Augmentation. */
13635 /* Make sure we don't have all nops. This is enough for
13636 elf-eh-frame.c to detect the last non-nop opcode. */
13637 p
[group
->eh_size
- 1] = DW_CFA_advance_loc
+ 1;
13638 p
= last_fde
+ last_fde_len
+ 4;
13640 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
13643 last_fde_len
= ((24 + align
- 1) & -align
) - 4;
13645 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
, p
);
13648 val
= p
- htab
->glink_eh_frame
->contents
;
13649 bfd_put_32 (htab
->elf
.dynobj
, val
, p
);
13651 /* Offset to .glink, written later. */
13654 bfd_put_32 (htab
->elf
.dynobj
, htab
->glink
->size
- 8, p
);
13656 /* Augmentation. */
13659 *p
++ = DW_CFA_advance_loc
+ 1;
13660 *p
++ = DW_CFA_register
;
13662 *p
++ = htab
->opd_abi
? 12 : 0;
13663 *p
++ = DW_CFA_advance_loc
+ (htab
->opd_abi
? 5 : 7);
13664 *p
++ = DW_CFA_restore_extended
;
13666 p
+= ((24 + align
- 1) & -align
) - 24;
13668 /* Subsume any padding into the last FDE if user .eh_frame
13669 sections are aligned more than glink_eh_frame. Otherwise any
13670 zero padding will be seen as a terminator. */
13671 align
= 1ul << htab
->glink_eh_frame
->output_section
->alignment_power
;
13672 size
= p
- htab
->glink_eh_frame
->contents
;
13673 pad
= ((size
+ align
- 1) & -align
) - size
;
13674 htab
->glink_eh_frame
->size
= size
+ pad
;
13675 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
+ pad
, last_fde
);
13678 maybe_strip_output (info
, htab
->brlt
);
13679 if (htab
->glink_eh_frame
!= NULL
)
13680 maybe_strip_output (info
, htab
->glink_eh_frame
);
13685 /* Called after we have determined section placement. If sections
13686 move, we'll be called again. Provide a value for TOCstart. */
13689 ppc64_elf_set_toc (struct bfd_link_info
*info
, bfd
*obfd
)
13692 bfd_vma TOCstart
, adjust
;
13696 struct elf_link_hash_entry
*h
;
13697 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
13699 if (is_elf_hash_table (htab
)
13700 && htab
->hgot
!= NULL
)
13704 h
= elf_link_hash_lookup (htab
, ".TOC.", FALSE
, FALSE
, TRUE
);
13705 if (is_elf_hash_table (htab
))
13709 && h
->root
.type
== bfd_link_hash_defined
13710 && !h
->root
.linker_def
13711 && (!is_elf_hash_table (htab
)
13712 || h
->def_regular
))
13714 TOCstart
= defined_sym_val (h
) - TOC_BASE_OFF
;
13715 _bfd_set_gp_value (obfd
, TOCstart
);
13720 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
13721 order. The TOC starts where the first of these sections starts. */
13722 s
= bfd_get_section_by_name (obfd
, ".got");
13723 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13724 s
= bfd_get_section_by_name (obfd
, ".toc");
13725 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13726 s
= bfd_get_section_by_name (obfd
, ".tocbss");
13727 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13728 s
= bfd_get_section_by_name (obfd
, ".plt");
13729 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13731 /* This may happen for
13732 o references to TOC base (SYM@toc / TOC[tc0]) without a
13734 o bad linker script
13735 o --gc-sections and empty TOC sections
13737 FIXME: Warn user? */
13739 /* Look for a likely section. We probably won't even be
13741 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13742 if ((s
->flags
& (SEC_ALLOC
| SEC_SMALL_DATA
| SEC_READONLY
13744 == (SEC_ALLOC
| SEC_SMALL_DATA
))
13747 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13748 if ((s
->flags
& (SEC_ALLOC
| SEC_SMALL_DATA
| SEC_EXCLUDE
))
13749 == (SEC_ALLOC
| SEC_SMALL_DATA
))
13752 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13753 if ((s
->flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_EXCLUDE
))
13757 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13758 if ((s
->flags
& (SEC_ALLOC
| SEC_EXCLUDE
)) == SEC_ALLOC
)
13764 TOCstart
= s
->output_section
->vma
+ s
->output_offset
;
13766 /* Force alignment. */
13767 adjust
= TOCstart
& (TOC_BASE_ALIGN
- 1);
13768 TOCstart
-= adjust
;
13769 _bfd_set_gp_value (obfd
, TOCstart
);
13771 if (info
!= NULL
&& s
!= NULL
)
13773 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
13777 if (htab
->elf
.hgot
!= NULL
)
13779 htab
->elf
.hgot
->root
.u
.def
.value
= TOC_BASE_OFF
- adjust
;
13780 htab
->elf
.hgot
->root
.u
.def
.section
= s
;
13785 struct bfd_link_hash_entry
*bh
= NULL
;
13786 _bfd_generic_link_add_one_symbol (info
, obfd
, ".TOC.", BSF_GLOBAL
,
13787 s
, TOC_BASE_OFF
- adjust
,
13788 NULL
, FALSE
, FALSE
, &bh
);
13794 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
13795 write out any global entry stubs, and PLT relocations. */
13798 build_global_entry_stubs_and_plt (struct elf_link_hash_entry
*h
, void *inf
)
13800 struct bfd_link_info
*info
;
13801 struct ppc_link_hash_table
*htab
;
13802 struct plt_entry
*ent
;
13805 if (h
->root
.type
== bfd_link_hash_indirect
)
13809 htab
= ppc_hash_table (info
);
13813 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
13814 if (ent
->plt
.offset
!= (bfd_vma
) -1)
13816 /* This symbol has an entry in the procedure linkage
13817 table. Set it up. */
13818 Elf_Internal_Rela rela
;
13819 asection
*plt
, *relplt
;
13822 if (!htab
->elf
.dynamic_sections_created
13823 || h
->dynindx
== -1)
13825 if (!(h
->def_regular
13826 && (h
->root
.type
== bfd_link_hash_defined
13827 || h
->root
.type
== bfd_link_hash_defweak
)))
13829 if (h
->type
== STT_GNU_IFUNC
)
13831 plt
= htab
->elf
.iplt
;
13832 relplt
= htab
->elf
.irelplt
;
13833 htab
->local_ifunc_resolver
= 1;
13835 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_IREL
);
13837 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
13841 plt
= htab
->pltlocal
;
13842 if (bfd_link_pic (info
))
13844 relplt
= htab
->relpltlocal
;
13846 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_SLOT
);
13848 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
13853 rela
.r_addend
= defined_sym_val (h
) + ent
->addend
;
13855 if (relplt
== NULL
)
13857 loc
= plt
->contents
+ ent
->plt
.offset
;
13858 bfd_put_64 (info
->output_bfd
, rela
.r_addend
, loc
);
13861 bfd_vma toc
= elf_gp (info
->output_bfd
);
13862 toc
+= htab
->sec_info
[h
->root
.u
.def
.section
->id
].toc_off
;
13863 bfd_put_64 (info
->output_bfd
, toc
, loc
+ 8);
13868 rela
.r_offset
= (plt
->output_section
->vma
13869 + plt
->output_offset
13870 + ent
->plt
.offset
);
13871 loc
= relplt
->contents
+ (relplt
->reloc_count
++
13872 * sizeof (Elf64_External_Rela
));
13873 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rela
, loc
);
13878 rela
.r_offset
= (htab
->elf
.splt
->output_section
->vma
13879 + htab
->elf
.splt
->output_offset
13880 + ent
->plt
.offset
);
13881 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_PPC64_JMP_SLOT
);
13882 rela
.r_addend
= ent
->addend
;
13883 loc
= (htab
->elf
.srelplt
->contents
13884 + ((ent
->plt
.offset
- PLT_INITIAL_ENTRY_SIZE (htab
))
13885 / PLT_ENTRY_SIZE (htab
) * sizeof (Elf64_External_Rela
)));
13886 if (h
->type
== STT_GNU_IFUNC
&& is_static_defined (h
))
13887 htab
->maybe_local_ifunc_resolver
= 1;
13888 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rela
, loc
);
13892 if (!h
->pointer_equality_needed
)
13895 if (h
->def_regular
)
13898 s
= htab
->global_entry
;
13899 if (s
== NULL
|| s
->size
== 0)
13902 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
13903 if (ent
->plt
.offset
!= (bfd_vma
) -1
13904 && ent
->addend
== 0)
13910 p
= s
->contents
+ h
->root
.u
.def
.value
;
13911 plt
= htab
->elf
.splt
;
13912 if (!htab
->elf
.dynamic_sections_created
13913 || h
->dynindx
== -1)
13915 if (h
->type
== STT_GNU_IFUNC
)
13916 plt
= htab
->elf
.iplt
;
13918 plt
= htab
->pltlocal
;
13920 off
= ent
->plt
.offset
+ plt
->output_offset
+ plt
->output_section
->vma
;
13921 off
-= h
->root
.u
.def
.value
+ s
->output_offset
+ s
->output_section
->vma
;
13923 if (off
+ 0x80008000 > 0xffffffff || (off
& 3) != 0)
13925 info
->callbacks
->einfo
13926 (_("%P: linkage table error against `%pT'\n"),
13927 h
->root
.root
.string
);
13928 bfd_set_error (bfd_error_bad_value
);
13929 htab
->stub_error
= TRUE
;
13932 htab
->stub_count
[ppc_stub_global_entry
- 1] += 1;
13933 if (htab
->params
->emit_stub_syms
)
13935 size_t len
= strlen (h
->root
.root
.string
);
13936 char *name
= bfd_malloc (sizeof "12345678.global_entry." + len
);
13941 sprintf (name
, "%08x.global_entry.%s", s
->id
, h
->root
.root
.string
);
13942 h
= elf_link_hash_lookup (&htab
->elf
, name
, TRUE
, FALSE
, FALSE
);
13945 if (h
->root
.type
== bfd_link_hash_new
)
13947 h
->root
.type
= bfd_link_hash_defined
;
13948 h
->root
.u
.def
.section
= s
;
13949 h
->root
.u
.def
.value
= p
- s
->contents
;
13950 h
->ref_regular
= 1;
13951 h
->def_regular
= 1;
13952 h
->ref_regular_nonweak
= 1;
13953 h
->forced_local
= 1;
13955 h
->root
.linker_def
= 1;
13959 if (PPC_HA (off
) != 0)
13961 bfd_put_32 (s
->owner
, ADDIS_R12_R12
| PPC_HA (off
), p
);
13964 bfd_put_32 (s
->owner
, LD_R12_0R12
| PPC_LO (off
), p
);
13966 bfd_put_32 (s
->owner
, MTCTR_R12
, p
);
13968 bfd_put_32 (s
->owner
, BCTR
, p
);
13974 /* Write PLT relocs for locals. */
13977 write_plt_relocs_for_local_syms (struct bfd_link_info
*info
)
13979 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
13982 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
13984 struct got_entry
**lgot_ents
, **end_lgot_ents
;
13985 struct plt_entry
**local_plt
, **lplt
, **end_local_plt
;
13986 Elf_Internal_Shdr
*symtab_hdr
;
13987 bfd_size_type locsymcount
;
13988 Elf_Internal_Sym
*local_syms
= NULL
;
13989 struct plt_entry
*ent
;
13991 if (!is_ppc64_elf (ibfd
))
13994 lgot_ents
= elf_local_got_ents (ibfd
);
13998 symtab_hdr
= &elf_symtab_hdr (ibfd
);
13999 locsymcount
= symtab_hdr
->sh_info
;
14000 end_lgot_ents
= lgot_ents
+ locsymcount
;
14001 local_plt
= (struct plt_entry
**) end_lgot_ents
;
14002 end_local_plt
= local_plt
+ locsymcount
;
14003 for (lplt
= local_plt
; lplt
< end_local_plt
; ++lplt
)
14004 for (ent
= *lplt
; ent
!= NULL
; ent
= ent
->next
)
14005 if (ent
->plt
.offset
!= (bfd_vma
) -1)
14007 Elf_Internal_Sym
*sym
;
14009 asection
*plt
, *relplt
;
14013 if (!get_sym_h (NULL
, &sym
, &sym_sec
, NULL
, &local_syms
,
14014 lplt
- local_plt
, ibfd
))
14016 if (local_syms
!= NULL
14017 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
14022 val
= sym
->st_value
+ ent
->addend
;
14023 if (ELF_ST_TYPE (sym
->st_info
) != STT_GNU_IFUNC
)
14024 val
+= PPC64_LOCAL_ENTRY_OFFSET (sym
->st_other
);
14025 if (sym_sec
!= NULL
&& sym_sec
->output_section
!= NULL
)
14026 val
+= sym_sec
->output_offset
+ sym_sec
->output_section
->vma
;
14028 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
14030 htab
->local_ifunc_resolver
= 1;
14031 plt
= htab
->elf
.iplt
;
14032 relplt
= htab
->elf
.irelplt
;
14036 plt
= htab
->pltlocal
;
14037 relplt
= bfd_link_pic (info
) ? htab
->relpltlocal
: NULL
;
14040 if (relplt
== NULL
)
14042 loc
= plt
->contents
+ ent
->plt
.offset
;
14043 bfd_put_64 (info
->output_bfd
, val
, loc
);
14046 bfd_vma toc
= elf_gp (ibfd
);
14047 bfd_put_64 (info
->output_bfd
, toc
, loc
+ 8);
14052 Elf_Internal_Rela rela
;
14053 rela
.r_offset
= (ent
->plt
.offset
14054 + plt
->output_offset
14055 + plt
->output_section
->vma
);
14056 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
14059 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_IREL
);
14061 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
14066 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_SLOT
);
14068 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
14070 rela
.r_addend
= val
;
14071 loc
= relplt
->contents
+ (relplt
->reloc_count
++
14072 * sizeof (Elf64_External_Rela
));
14073 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rela
, loc
);
14077 if (local_syms
!= NULL
14078 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
14080 if (!info
->keep_memory
)
14083 symtab_hdr
->contents
= (unsigned char *) local_syms
;
14089 /* Build all the stubs associated with the current output file.
14090 The stubs are kept in a hash table attached to the main linker
14091 hash table. This function is called via gldelf64ppc_finish. */
14094 ppc64_elf_build_stubs (struct bfd_link_info
*info
,
14097 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
14098 struct map_stub
*group
;
14099 asection
*stub_sec
;
14101 int stub_sec_count
= 0;
14106 /* Allocate memory to hold the linker stubs. */
14107 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14109 group
->eh_size
= 0;
14110 group
->lr_restore
= 0;
14111 if ((stub_sec
= group
->stub_sec
) != NULL
14112 && stub_sec
->size
!= 0)
14114 stub_sec
->contents
= bfd_zalloc (htab
->params
->stub_bfd
,
14116 if (stub_sec
->contents
== NULL
)
14118 stub_sec
->size
= 0;
14122 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
14127 /* Build the .glink plt call stub. */
14128 if (htab
->params
->emit_stub_syms
)
14130 struct elf_link_hash_entry
*h
;
14131 h
= elf_link_hash_lookup (&htab
->elf
, "__glink_PLTresolve",
14132 TRUE
, FALSE
, FALSE
);
14135 if (h
->root
.type
== bfd_link_hash_new
)
14137 h
->root
.type
= bfd_link_hash_defined
;
14138 h
->root
.u
.def
.section
= htab
->glink
;
14139 h
->root
.u
.def
.value
= 8;
14140 h
->ref_regular
= 1;
14141 h
->def_regular
= 1;
14142 h
->ref_regular_nonweak
= 1;
14143 h
->forced_local
= 1;
14145 h
->root
.linker_def
= 1;
14148 plt0
= (htab
->elf
.splt
->output_section
->vma
14149 + htab
->elf
.splt
->output_offset
14151 if (info
->emitrelocations
)
14153 Elf_Internal_Rela
*r
= get_relocs (htab
->glink
, 1);
14156 r
->r_offset
= (htab
->glink
->output_offset
14157 + htab
->glink
->output_section
->vma
);
14158 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL64
);
14159 r
->r_addend
= plt0
;
14161 p
= htab
->glink
->contents
;
14162 plt0
-= htab
->glink
->output_section
->vma
+ htab
->glink
->output_offset
;
14163 bfd_put_64 (htab
->glink
->owner
, plt0
, p
);
14167 bfd_put_32 (htab
->glink
->owner
, MFLR_R12
, p
);
14169 bfd_put_32 (htab
->glink
->owner
, BCL_20_31
, p
);
14171 bfd_put_32 (htab
->glink
->owner
, MFLR_R11
, p
);
14173 bfd_put_32 (htab
->glink
->owner
, LD_R2_0R11
| (-16 & 0xfffc), p
);
14175 bfd_put_32 (htab
->glink
->owner
, MTLR_R12
, p
);
14177 bfd_put_32 (htab
->glink
->owner
, ADD_R11_R2_R11
, p
);
14179 bfd_put_32 (htab
->glink
->owner
, LD_R12_0R11
, p
);
14181 bfd_put_32 (htab
->glink
->owner
, LD_R2_0R11
| 8, p
);
14183 bfd_put_32 (htab
->glink
->owner
, MTCTR_R12
, p
);
14185 bfd_put_32 (htab
->glink
->owner
, LD_R11_0R11
| 16, p
);
14190 bfd_put_32 (htab
->glink
->owner
, MFLR_R0
, p
);
14192 bfd_put_32 (htab
->glink
->owner
, BCL_20_31
, p
);
14194 bfd_put_32 (htab
->glink
->owner
, MFLR_R11
, p
);
14196 bfd_put_32 (htab
->glink
->owner
, STD_R2_0R1
+ 24, p
);
14198 bfd_put_32 (htab
->glink
->owner
, LD_R2_0R11
| (-16 & 0xfffc), p
);
14200 bfd_put_32 (htab
->glink
->owner
, MTLR_R0
, p
);
14202 bfd_put_32 (htab
->glink
->owner
, SUB_R12_R12_R11
, p
);
14204 bfd_put_32 (htab
->glink
->owner
, ADD_R11_R2_R11
, p
);
14206 bfd_put_32 (htab
->glink
->owner
, ADDI_R0_R12
| (-48 & 0xffff), p
);
14208 bfd_put_32 (htab
->glink
->owner
, LD_R12_0R11
, p
);
14210 bfd_put_32 (htab
->glink
->owner
, SRDI_R0_R0_2
, p
);
14212 bfd_put_32 (htab
->glink
->owner
, MTCTR_R12
, p
);
14214 bfd_put_32 (htab
->glink
->owner
, LD_R11_0R11
| 8, p
);
14217 bfd_put_32 (htab
->glink
->owner
, BCTR
, p
);
14219 BFD_ASSERT (p
== htab
->glink
->contents
+ GLINK_PLTRESOLVE_SIZE (htab
));
14221 /* Build the .glink lazy link call stubs. */
14223 while (p
< htab
->glink
->contents
+ htab
->glink
->size
)
14229 bfd_put_32 (htab
->glink
->owner
, LI_R0_0
| indx
, p
);
14234 bfd_put_32 (htab
->glink
->owner
, LIS_R0_0
| PPC_HI (indx
), p
);
14236 bfd_put_32 (htab
->glink
->owner
, ORI_R0_R0_0
| PPC_LO (indx
),
14241 bfd_put_32 (htab
->glink
->owner
,
14242 B_DOT
| ((htab
->glink
->contents
- p
+ 8) & 0x3fffffc), p
);
14248 /* Build .glink global entry stubs, and PLT relocs for globals. */
14249 elf_link_hash_traverse (&htab
->elf
, build_global_entry_stubs_and_plt
, info
);
14251 if (!write_plt_relocs_for_local_syms (info
))
14254 if (htab
->brlt
!= NULL
&& htab
->brlt
->size
!= 0)
14256 htab
->brlt
->contents
= bfd_zalloc (htab
->brlt
->owner
,
14258 if (htab
->brlt
->contents
== NULL
)
14261 if (htab
->relbrlt
!= NULL
&& htab
->relbrlt
->size
!= 0)
14263 htab
->relbrlt
->contents
= bfd_zalloc (htab
->relbrlt
->owner
,
14264 htab
->relbrlt
->size
);
14265 if (htab
->relbrlt
->contents
== NULL
)
14269 /* Build the stubs as directed by the stub hash table. */
14270 bfd_hash_traverse (&htab
->stub_hash_table
, ppc_build_one_stub
, info
);
14272 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14273 if (group
->needs_save_res
)
14274 group
->stub_sec
->size
+= htab
->sfpr
->size
;
14276 if (htab
->relbrlt
!= NULL
)
14277 htab
->relbrlt
->reloc_count
= 0;
14279 if (htab
->params
->plt_stub_align
!= 0)
14280 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14281 if ((stub_sec
= group
->stub_sec
) != NULL
)
14283 int align
= abs (htab
->params
->plt_stub_align
);
14284 stub_sec
->size
= (stub_sec
->size
+ (1 << align
) - 1) & -(1 << align
);
14287 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14288 if (group
->needs_save_res
)
14290 stub_sec
= group
->stub_sec
;
14291 memcpy (stub_sec
->contents
+ stub_sec
->size
- htab
->sfpr
->size
,
14292 htab
->sfpr
->contents
, htab
->sfpr
->size
);
14293 if (htab
->params
->emit_stub_syms
)
14297 for (i
= 0; i
< ARRAY_SIZE (save_res_funcs
); i
++)
14298 if (!sfpr_define (info
, &save_res_funcs
[i
], stub_sec
))
14303 if (htab
->glink_eh_frame
!= NULL
14304 && htab
->glink_eh_frame
->size
!= 0)
14309 p
= htab
->glink_eh_frame
->contents
;
14310 p
+= (sizeof (glink_eh_frame_cie
) + align
- 1) & -align
;
14312 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14313 if (group
->eh_size
!= 0)
14315 /* Offset to stub section. */
14316 val
= (group
->stub_sec
->output_section
->vma
14317 + group
->stub_sec
->output_offset
);
14318 val
-= (htab
->glink_eh_frame
->output_section
->vma
14319 + htab
->glink_eh_frame
->output_offset
14320 + (p
+ 8 - htab
->glink_eh_frame
->contents
));
14321 if (val
+ 0x80000000 > 0xffffffff)
14324 (_("%s offset too large for .eh_frame sdata4 encoding"),
14325 group
->stub_sec
->name
);
14328 bfd_put_32 (htab
->elf
.dynobj
, val
, p
+ 8);
14329 p
+= (group
->eh_size
+ 17 + 3) & -4;
14331 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
14333 /* Offset to .glink. */
14334 val
= (htab
->glink
->output_section
->vma
14335 + htab
->glink
->output_offset
14337 val
-= (htab
->glink_eh_frame
->output_section
->vma
14338 + htab
->glink_eh_frame
->output_offset
14339 + (p
+ 8 - htab
->glink_eh_frame
->contents
));
14340 if (val
+ 0x80000000 > 0xffffffff)
14343 (_("%s offset too large for .eh_frame sdata4 encoding"),
14344 htab
->glink
->name
);
14347 bfd_put_32 (htab
->elf
.dynobj
, val
, p
+ 8);
14348 p
+= (24 + align
- 1) & -align
;
14352 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14353 if ((stub_sec
= group
->stub_sec
) != NULL
)
14355 stub_sec_count
+= 1;
14356 if (stub_sec
->rawsize
!= stub_sec
->size
14357 && (htab
->stub_iteration
<= STUB_SHRINK_ITER
14358 || stub_sec
->rawsize
< stub_sec
->size
))
14364 htab
->stub_error
= TRUE
;
14365 _bfd_error_handler (_("stubs don't match calculated size"));
14368 if (htab
->stub_error
)
14374 *stats
= bfd_malloc (500);
14375 if (*stats
== NULL
)
14378 len
= sprintf (*stats
,
14379 ngettext ("linker stubs in %u group\n",
14380 "linker stubs in %u groups\n",
14383 sprintf (*stats
+ len
, _(" branch %lu\n"
14384 " branch toc adj %lu\n"
14385 " branch notoc %lu\n"
14386 " branch both %lu\n"
14387 " long branch %lu\n"
14388 " long toc adj %lu\n"
14389 " long notoc %lu\n"
14392 " plt call save %lu\n"
14393 " plt call notoc %lu\n"
14394 " plt call both %lu\n"
14395 " global entry %lu"),
14396 htab
->stub_count
[ppc_stub_long_branch
- 1],
14397 htab
->stub_count
[ppc_stub_long_branch_r2off
- 1],
14398 htab
->stub_count
[ppc_stub_long_branch_notoc
- 1],
14399 htab
->stub_count
[ppc_stub_long_branch_both
- 1],
14400 htab
->stub_count
[ppc_stub_plt_branch
- 1],
14401 htab
->stub_count
[ppc_stub_plt_branch_r2off
- 1],
14402 htab
->stub_count
[ppc_stub_plt_branch_notoc
- 1],
14403 htab
->stub_count
[ppc_stub_plt_branch_both
- 1],
14404 htab
->stub_count
[ppc_stub_plt_call
- 1],
14405 htab
->stub_count
[ppc_stub_plt_call_r2save
- 1],
14406 htab
->stub_count
[ppc_stub_plt_call_notoc
- 1],
14407 htab
->stub_count
[ppc_stub_plt_call_both
- 1],
14408 htab
->stub_count
[ppc_stub_global_entry
- 1]);
14413 /* What to do when ld finds relocations against symbols defined in
14414 discarded sections. */
14416 static unsigned int
14417 ppc64_elf_action_discarded (asection
*sec
)
14419 if (strcmp (".opd", sec
->name
) == 0)
14422 if (strcmp (".toc", sec
->name
) == 0)
14425 if (strcmp (".toc1", sec
->name
) == 0)
14428 return _bfd_elf_default_action_discarded (sec
);
14431 /* These are the dynamic relocations supported by glibc. */
14434 ppc64_glibc_dynamic_reloc (enum elf_ppc64_reloc_type r_type
)
14438 case R_PPC64_RELATIVE
:
14440 case R_PPC64_ADDR64
:
14441 case R_PPC64_GLOB_DAT
:
14442 case R_PPC64_IRELATIVE
:
14443 case R_PPC64_JMP_IREL
:
14444 case R_PPC64_JMP_SLOT
:
14445 case R_PPC64_DTPMOD64
:
14446 case R_PPC64_DTPREL64
:
14447 case R_PPC64_TPREL64
:
14448 case R_PPC64_TPREL16_LO_DS
:
14449 case R_PPC64_TPREL16_DS
:
14450 case R_PPC64_TPREL16
:
14451 case R_PPC64_TPREL16_LO
:
14452 case R_PPC64_TPREL16_HI
:
14453 case R_PPC64_TPREL16_HIGH
:
14454 case R_PPC64_TPREL16_HA
:
14455 case R_PPC64_TPREL16_HIGHA
:
14456 case R_PPC64_TPREL16_HIGHER
:
14457 case R_PPC64_TPREL16_HIGHEST
:
14458 case R_PPC64_TPREL16_HIGHERA
:
14459 case R_PPC64_TPREL16_HIGHESTA
:
14460 case R_PPC64_ADDR16_LO_DS
:
14461 case R_PPC64_ADDR16_LO
:
14462 case R_PPC64_ADDR16_HI
:
14463 case R_PPC64_ADDR16_HIGH
:
14464 case R_PPC64_ADDR16_HA
:
14465 case R_PPC64_ADDR16_HIGHA
:
14466 case R_PPC64_REL30
:
14468 case R_PPC64_UADDR64
:
14469 case R_PPC64_UADDR32
:
14470 case R_PPC64_ADDR32
:
14471 case R_PPC64_ADDR24
:
14472 case R_PPC64_ADDR16
:
14473 case R_PPC64_UADDR16
:
14474 case R_PPC64_ADDR16_DS
:
14475 case R_PPC64_ADDR16_HIGHER
:
14476 case R_PPC64_ADDR16_HIGHEST
:
14477 case R_PPC64_ADDR16_HIGHERA
:
14478 case R_PPC64_ADDR16_HIGHESTA
:
14479 case R_PPC64_ADDR14
:
14480 case R_PPC64_ADDR14_BRTAKEN
:
14481 case R_PPC64_ADDR14_BRNTAKEN
:
14482 case R_PPC64_REL32
:
14483 case R_PPC64_REL64
:
14491 /* The RELOCATE_SECTION function is called by the ELF backend linker
14492 to handle the relocations for a section.
14494 The relocs are always passed as Rela structures; if the section
14495 actually uses Rel structures, the r_addend field will always be
14498 This function is responsible for adjust the section contents as
14499 necessary, and (if using Rela relocs and generating a
14500 relocatable output file) adjusting the reloc addend as
14503 This function does not have to worry about setting the reloc
14504 address or the reloc symbol index.
14506 LOCAL_SYMS is a pointer to the swapped in local symbols.
14508 LOCAL_SECTIONS is an array giving the section in the input file
14509 corresponding to the st_shndx field of each local symbol.
14511 The global hash table entry for the global symbols can be found
14512 via elf_sym_hashes (input_bfd).
14514 When generating relocatable output, this function must handle
14515 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
14516 going to be the section symbol corresponding to the output
14517 section, which means that the addend must be adjusted
14521 ppc64_elf_relocate_section (bfd
*output_bfd
,
14522 struct bfd_link_info
*info
,
14524 asection
*input_section
,
14525 bfd_byte
*contents
,
14526 Elf_Internal_Rela
*relocs
,
14527 Elf_Internal_Sym
*local_syms
,
14528 asection
**local_sections
)
14530 struct ppc_link_hash_table
*htab
;
14531 Elf_Internal_Shdr
*symtab_hdr
;
14532 struct elf_link_hash_entry
**sym_hashes
;
14533 Elf_Internal_Rela
*rel
;
14534 Elf_Internal_Rela
*wrel
;
14535 Elf_Internal_Rela
*relend
;
14536 Elf_Internal_Rela outrel
;
14538 struct got_entry
**local_got_ents
;
14540 bfd_boolean ret
= TRUE
;
14541 bfd_boolean is_opd
;
14542 /* Assume 'at' branch hints. */
14543 bfd_boolean is_isa_v2
= TRUE
;
14544 bfd_boolean warned_dynamic
= FALSE
;
14545 bfd_vma d_offset
= (bfd_big_endian (input_bfd
) ? 2 : 0);
14547 /* Initialize howto table if needed. */
14548 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
14551 htab
= ppc_hash_table (info
);
14555 /* Don't relocate stub sections. */
14556 if (input_section
->owner
== htab
->params
->stub_bfd
)
14559 if (!is_ppc64_elf (input_bfd
))
14561 bfd_set_error (bfd_error_wrong_format
);
14565 local_got_ents
= elf_local_got_ents (input_bfd
);
14566 TOCstart
= elf_gp (output_bfd
);
14567 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
14568 sym_hashes
= elf_sym_hashes (input_bfd
);
14569 is_opd
= ppc64_elf_section_data (input_section
)->sec_type
== sec_opd
;
14571 rel
= wrel
= relocs
;
14572 relend
= relocs
+ input_section
->reloc_count
;
14573 for (; rel
< relend
; wrel
++, rel
++)
14575 enum elf_ppc64_reloc_type r_type
;
14577 bfd_reloc_status_type r
;
14578 Elf_Internal_Sym
*sym
;
14580 struct elf_link_hash_entry
*h_elf
;
14581 struct ppc_link_hash_entry
*h
;
14582 struct ppc_link_hash_entry
*fdh
;
14583 const char *sym_name
;
14584 unsigned long r_symndx
, toc_symndx
;
14585 bfd_vma toc_addend
;
14586 unsigned char tls_mask
, tls_gd
, tls_type
;
14587 unsigned char sym_type
;
14588 bfd_vma relocation
;
14589 bfd_boolean unresolved_reloc
, save_unresolved_reloc
;
14590 bfd_boolean warned
;
14591 enum { DEST_NORMAL
, DEST_OPD
, DEST_STUB
} reloc_dest
;
14594 struct ppc_stub_hash_entry
*stub_entry
;
14595 bfd_vma max_br_offset
;
14597 Elf_Internal_Rela orig_rel
;
14598 reloc_howto_type
*howto
;
14599 struct reloc_howto_struct alt_howto
;
14606 r_type
= ELF64_R_TYPE (rel
->r_info
);
14607 r_symndx
= ELF64_R_SYM (rel
->r_info
);
14609 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
14610 symbol of the previous ADDR64 reloc. The symbol gives us the
14611 proper TOC base to use. */
14612 if (rel
->r_info
== ELF64_R_INFO (0, R_PPC64_TOC
)
14614 && ELF64_R_TYPE (wrel
[-1].r_info
) == R_PPC64_ADDR64
14616 r_symndx
= ELF64_R_SYM (wrel
[-1].r_info
);
14622 unresolved_reloc
= FALSE
;
14625 if (r_symndx
< symtab_hdr
->sh_info
)
14627 /* It's a local symbol. */
14628 struct _opd_sec_data
*opd
;
14630 sym
= local_syms
+ r_symndx
;
14631 sec
= local_sections
[r_symndx
];
14632 sym_name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
, sec
);
14633 sym_type
= ELF64_ST_TYPE (sym
->st_info
);
14634 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
14635 opd
= get_opd_info (sec
);
14636 if (opd
!= NULL
&& opd
->adjust
!= NULL
)
14638 long adjust
= opd
->adjust
[OPD_NDX (sym
->st_value
14644 /* If this is a relocation against the opd section sym
14645 and we have edited .opd, adjust the reloc addend so
14646 that ld -r and ld --emit-relocs output is correct.
14647 If it is a reloc against some other .opd symbol,
14648 then the symbol value will be adjusted later. */
14649 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
14650 rel
->r_addend
+= adjust
;
14652 relocation
+= adjust
;
14658 bfd_boolean ignored
;
14660 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
14661 r_symndx
, symtab_hdr
, sym_hashes
,
14662 h_elf
, sec
, relocation
,
14663 unresolved_reloc
, warned
, ignored
);
14664 sym_name
= h_elf
->root
.root
.string
;
14665 sym_type
= h_elf
->type
;
14667 && sec
->owner
== output_bfd
14668 && strcmp (sec
->name
, ".opd") == 0)
14670 /* This is a symbol defined in a linker script. All
14671 such are defined in output sections, even those
14672 defined by simple assignment from a symbol defined in
14673 an input section. Transfer the symbol to an
14674 appropriate input .opd section, so that a branch to
14675 this symbol will be mapped to the location specified
14676 by the opd entry. */
14677 struct bfd_link_order
*lo
;
14678 for (lo
= sec
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
14679 if (lo
->type
== bfd_indirect_link_order
)
14681 asection
*isec
= lo
->u
.indirect
.section
;
14682 if (h_elf
->root
.u
.def
.value
>= isec
->output_offset
14683 && h_elf
->root
.u
.def
.value
< (isec
->output_offset
14686 h_elf
->root
.u
.def
.value
-= isec
->output_offset
;
14687 h_elf
->root
.u
.def
.section
= isec
;
14694 h
= ppc_elf_hash_entry (h_elf
);
14696 if (sec
!= NULL
&& discarded_section (sec
))
14698 _bfd_clear_contents (ppc64_elf_howto_table
[r_type
],
14699 input_bfd
, input_section
,
14700 contents
, rel
->r_offset
);
14701 wrel
->r_offset
= rel
->r_offset
;
14703 wrel
->r_addend
= 0;
14705 /* For ld -r, remove relocations in debug sections against
14706 symbols defined in discarded sections. Not done for
14707 non-debug to preserve relocs in .eh_frame which the
14708 eh_frame editing code expects to be present. */
14709 if (bfd_link_relocatable (info
)
14710 && (input_section
->flags
& SEC_DEBUGGING
))
14716 if (bfd_link_relocatable (info
))
14719 if (h
!= NULL
&& &h
->elf
== htab
->elf
.hgot
)
14721 relocation
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
14722 sec
= bfd_abs_section_ptr
;
14723 unresolved_reloc
= FALSE
;
14726 /* TLS optimizations. Replace instruction sequences and relocs
14727 based on information we collected in tls_optimize. We edit
14728 RELOCS so that --emit-relocs will output something sensible
14729 for the final instruction stream. */
14734 tls_mask
= h
->tls_mask
;
14735 else if (local_got_ents
!= NULL
)
14737 struct plt_entry
**local_plt
= (struct plt_entry
**)
14738 (local_got_ents
+ symtab_hdr
->sh_info
);
14739 unsigned char *lgot_masks
= (unsigned char *)
14740 (local_plt
+ symtab_hdr
->sh_info
);
14741 tls_mask
= lgot_masks
[r_symndx
];
14743 if (((tls_mask
& TLS_TLS
) == 0 || tls_mask
== (TLS_TLS
| TLS_MARK
))
14744 && (r_type
== R_PPC64_TLS
14745 || r_type
== R_PPC64_TLSGD
14746 || r_type
== R_PPC64_TLSLD
))
14748 /* Check for toc tls entries. */
14749 unsigned char *toc_tls
;
14751 if (!get_tls_mask (&toc_tls
, &toc_symndx
, &toc_addend
,
14752 &local_syms
, rel
, input_bfd
))
14756 tls_mask
= *toc_tls
;
14759 /* Check that tls relocs are used with tls syms, and non-tls
14760 relocs are used with non-tls syms. */
14761 if (r_symndx
!= STN_UNDEF
14762 && r_type
!= R_PPC64_NONE
14764 || h
->elf
.root
.type
== bfd_link_hash_defined
14765 || h
->elf
.root
.type
== bfd_link_hash_defweak
)
14766 && IS_PPC64_TLS_RELOC (r_type
) != (sym_type
== STT_TLS
))
14768 if ((tls_mask
& TLS_TLS
) != 0
14769 && (r_type
== R_PPC64_TLS
14770 || r_type
== R_PPC64_TLSGD
14771 || r_type
== R_PPC64_TLSLD
))
14772 /* R_PPC64_TLS is OK against a symbol in the TOC. */
14775 info
->callbacks
->einfo
14776 (!IS_PPC64_TLS_RELOC (r_type
)
14777 /* xgettext:c-format */
14778 ? _("%H: %s used with TLS symbol `%pT'\n")
14779 /* xgettext:c-format */
14780 : _("%H: %s used with non-TLS symbol `%pT'\n"),
14781 input_bfd
, input_section
, rel
->r_offset
,
14782 ppc64_elf_howto_table
[r_type
]->name
,
14786 /* Ensure reloc mapping code below stays sane. */
14787 if (R_PPC64_TOC16_LO_DS
!= R_PPC64_TOC16_DS
+ 1
14788 || R_PPC64_TOC16_LO
!= R_PPC64_TOC16
+ 1
14789 || (R_PPC64_GOT_TLSLD16
& 3) != (R_PPC64_GOT_TLSGD16
& 3)
14790 || (R_PPC64_GOT_TLSLD16_LO
& 3) != (R_PPC64_GOT_TLSGD16_LO
& 3)
14791 || (R_PPC64_GOT_TLSLD16_HI
& 3) != (R_PPC64_GOT_TLSGD16_HI
& 3)
14792 || (R_PPC64_GOT_TLSLD16_HA
& 3) != (R_PPC64_GOT_TLSGD16_HA
& 3)
14793 || (R_PPC64_GOT_TLSLD16
& 3) != (R_PPC64_GOT_TPREL16_DS
& 3)
14794 || (R_PPC64_GOT_TLSLD16_LO
& 3) != (R_PPC64_GOT_TPREL16_LO_DS
& 3)
14795 || (R_PPC64_GOT_TLSLD16_HI
& 3) != (R_PPC64_GOT_TPREL16_HI
& 3)
14796 || (R_PPC64_GOT_TLSLD16_HA
& 3) != (R_PPC64_GOT_TPREL16_HA
& 3))
14804 case R_PPC64_LO_DS_OPT
:
14805 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
- d_offset
);
14806 if ((insn
& (0x3fu
<< 26)) != 58u << 26)
14808 insn
+= (14u << 26) - (58u << 26);
14809 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
- d_offset
);
14810 r_type
= R_PPC64_TOC16_LO
;
14811 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14814 case R_PPC64_TOC16
:
14815 case R_PPC64_TOC16_LO
:
14816 case R_PPC64_TOC16_DS
:
14817 case R_PPC64_TOC16_LO_DS
:
14819 /* Check for toc tls entries. */
14820 unsigned char *toc_tls
;
14823 retval
= get_tls_mask (&toc_tls
, &toc_symndx
, &toc_addend
,
14824 &local_syms
, rel
, input_bfd
);
14830 tls_mask
= *toc_tls
;
14831 if (r_type
== R_PPC64_TOC16_DS
14832 || r_type
== R_PPC64_TOC16_LO_DS
)
14834 if ((tls_mask
& TLS_TLS
) != 0
14835 && (tls_mask
& (TLS_DTPREL
| TLS_TPREL
)) == 0)
14840 /* If we found a GD reloc pair, then we might be
14841 doing a GD->IE transition. */
14845 if ((tls_mask
& TLS_TLS
) != 0
14846 && (tls_mask
& TLS_GD
) == 0)
14849 else if (retval
== 3)
14851 if ((tls_mask
& TLS_TLS
) != 0
14852 && (tls_mask
& TLS_LD
) == 0)
14860 case R_PPC64_GOT_TPREL16_HI
:
14861 case R_PPC64_GOT_TPREL16_HA
:
14862 if ((tls_mask
& TLS_TLS
) != 0
14863 && (tls_mask
& TLS_TPREL
) == 0)
14865 rel
->r_offset
-= d_offset
;
14866 bfd_put_32 (input_bfd
, NOP
, contents
+ rel
->r_offset
);
14867 r_type
= R_PPC64_NONE
;
14868 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14872 case R_PPC64_GOT_TPREL16_DS
:
14873 case R_PPC64_GOT_TPREL16_LO_DS
:
14874 if ((tls_mask
& TLS_TLS
) != 0
14875 && (tls_mask
& TLS_TPREL
) == 0)
14878 insn
= bfd_get_32 (input_bfd
,
14879 contents
+ rel
->r_offset
- d_offset
);
14881 insn
|= 0x3c0d0000; /* addis 0,13,0 */
14882 bfd_put_32 (input_bfd
, insn
,
14883 contents
+ rel
->r_offset
- d_offset
);
14884 r_type
= R_PPC64_TPREL16_HA
;
14885 if (toc_symndx
!= 0)
14887 rel
->r_info
= ELF64_R_INFO (toc_symndx
, r_type
);
14888 rel
->r_addend
= toc_addend
;
14889 /* We changed the symbol. Start over in order to
14890 get h, sym, sec etc. right. */
14894 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14898 case R_PPC64_GOT_TPREL34
:
14899 if ((tls_mask
& TLS_TLS
) != 0
14900 && (tls_mask
& TLS_TPREL
) == 0)
14902 /* pld ra,sym@got@tprel@pcrel -> paddi ra,r13,sym@tprel */
14903 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
14905 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
14906 pinsn
+= ((2ULL << 56) + (-1ULL << 52)
14907 + (14ULL << 26) - (57ULL << 26) + (13ULL << 16));
14908 bfd_put_32 (input_bfd
, pinsn
>> 32,
14909 contents
+ rel
->r_offset
);
14910 bfd_put_32 (input_bfd
, pinsn
& 0xffffffff,
14911 contents
+ rel
->r_offset
+ 4);
14912 r_type
= R_PPC64_TPREL34
;
14913 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14918 if ((tls_mask
& TLS_TLS
) != 0
14919 && (tls_mask
& TLS_TPREL
) == 0)
14921 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
14922 insn
= _bfd_elf_ppc_at_tls_transform (insn
, 13);
14925 if ((rel
->r_offset
& 3) == 0)
14927 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
14928 /* Was PPC64_TLS which sits on insn boundary, now
14929 PPC64_TPREL16_LO which is at low-order half-word. */
14930 rel
->r_offset
+= d_offset
;
14931 r_type
= R_PPC64_TPREL16_LO
;
14932 if (toc_symndx
!= 0)
14934 rel
->r_info
= ELF64_R_INFO (toc_symndx
, r_type
);
14935 rel
->r_addend
= toc_addend
;
14936 /* We changed the symbol. Start over in order to
14937 get h, sym, sec etc. right. */
14941 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14943 else if ((rel
->r_offset
& 3) == 1)
14945 /* For pcrel IE to LE we already have the full
14946 offset and thus don't need an addi here. A nop
14948 if ((insn
& (0x3fu
<< 26)) == 14 << 26)
14950 /* Extract regs from addi rt,ra,si. */
14951 unsigned int rt
= (insn
>> 21) & 0x1f;
14952 unsigned int ra
= (insn
>> 16) & 0x1f;
14957 /* Build or ra,rs,rb with rb==rs, ie. mr ra,rs. */
14958 insn
= (rt
<< 16) | (ra
<< 21) | (ra
<< 11);
14959 insn
|= (31u << 26) | (444u << 1);
14962 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
- 1);
14967 case R_PPC64_GOT_TLSGD16_HI
:
14968 case R_PPC64_GOT_TLSGD16_HA
:
14970 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0)
14974 case R_PPC64_GOT_TLSLD16_HI
:
14975 case R_PPC64_GOT_TLSLD16_HA
:
14976 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0)
14979 if ((tls_mask
& tls_gd
) != 0)
14980 r_type
= (((r_type
- (R_PPC64_GOT_TLSGD16
& 3)) & 3)
14981 + R_PPC64_GOT_TPREL16_DS
);
14984 rel
->r_offset
-= d_offset
;
14985 bfd_put_32 (input_bfd
, NOP
, contents
+ rel
->r_offset
);
14986 r_type
= R_PPC64_NONE
;
14988 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14992 case R_PPC64_GOT_TLSGD16
:
14993 case R_PPC64_GOT_TLSGD16_LO
:
14995 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0)
14999 case R_PPC64_GOT_TLSLD16
:
15000 case R_PPC64_GOT_TLSLD16_LO
:
15001 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0)
15003 unsigned int insn1
, insn2
;
15006 offset
= (bfd_vma
) -1;
15007 /* If not using the newer R_PPC64_TLSGD/LD to mark
15008 __tls_get_addr calls, we must trust that the call
15009 stays with its arg setup insns, ie. that the next
15010 reloc is the __tls_get_addr call associated with
15011 the current reloc. Edit both insns. */
15012 if (input_section
->nomark_tls_get_addr
15013 && rel
+ 1 < relend
15014 && branch_reloc_hash_match (input_bfd
, rel
+ 1,
15015 htab
->tls_get_addr_fd
,
15017 htab
->tls_get_addr
,
15019 offset
= rel
[1].r_offset
;
15020 /* We read the low GOT_TLS (or TOC16) insn because we
15021 need to keep the destination reg. It may be
15022 something other than the usual r3, and moved to r3
15023 before the call by intervening code. */
15024 insn1
= bfd_get_32 (input_bfd
,
15025 contents
+ rel
->r_offset
- d_offset
);
15026 if ((tls_mask
& tls_gd
) != 0)
15029 insn1
&= (0x1f << 21) | (0x1f << 16);
15030 insn1
|= 58u << 26; /* ld */
15031 insn2
= 0x7c636a14; /* add 3,3,13 */
15032 if (offset
!= (bfd_vma
) -1)
15033 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
15034 if (r_type
== R_PPC64_TOC16
15035 || r_type
== R_PPC64_TOC16_LO
)
15036 r_type
+= R_PPC64_TOC16_DS
- R_PPC64_TOC16
;
15038 r_type
= (((r_type
- (R_PPC64_GOT_TLSGD16
& 1)) & 1)
15039 + R_PPC64_GOT_TPREL16_DS
);
15040 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15045 insn1
&= 0x1f << 21;
15046 insn1
|= 0x3c0d0000; /* addis r,13,0 */
15047 insn2
= 0x38630000; /* addi 3,3,0 */
15050 /* Was an LD reloc. */
15051 r_symndx
= STN_UNDEF
;
15052 rel
->r_addend
= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
15054 else if (toc_symndx
!= 0)
15056 r_symndx
= toc_symndx
;
15057 rel
->r_addend
= toc_addend
;
15059 r_type
= R_PPC64_TPREL16_HA
;
15060 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15061 if (offset
!= (bfd_vma
) -1)
15063 rel
[1].r_info
= ELF64_R_INFO (r_symndx
,
15064 R_PPC64_TPREL16_LO
);
15065 rel
[1].r_offset
= offset
+ d_offset
;
15066 rel
[1].r_addend
= rel
->r_addend
;
15069 bfd_put_32 (input_bfd
, insn1
,
15070 contents
+ rel
->r_offset
- d_offset
);
15071 if (offset
!= (bfd_vma
) -1)
15073 bfd_put_32 (input_bfd
, insn2
, contents
+ offset
);
15074 if (offset
+ 8 <= input_section
->size
)
15076 insn2
= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
15077 if (insn2
== LD_R2_0R1
+ STK_TOC (htab
))
15078 bfd_put_32 (input_bfd
, NOP
, contents
+ offset
+ 4);
15081 if ((tls_mask
& tls_gd
) == 0
15082 && (tls_gd
== 0 || toc_symndx
!= 0))
15084 /* We changed the symbol. Start over in order
15085 to get h, sym, sec etc. right. */
15091 case R_PPC64_GOT_TLSGD34
:
15092 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0)
15094 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15096 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15097 if ((tls_mask
& TLS_GDIE
) != 0)
15099 /* IE, pla -> pld */
15100 pinsn
+= (-2ULL << 56) + (57ULL << 26) - (14ULL << 26);
15101 r_type
= R_PPC64_GOT_TPREL34
;
15105 /* LE, pla pcrel -> paddi r13 */
15106 pinsn
+= (-1ULL << 52) + (13ULL << 16);
15107 r_type
= R_PPC64_TPREL34
;
15109 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15110 bfd_put_32 (input_bfd
, pinsn
>> 32,
15111 contents
+ rel
->r_offset
);
15112 bfd_put_32 (input_bfd
, pinsn
& 0xffffffff,
15113 contents
+ rel
->r_offset
+ 4);
15117 case R_PPC64_GOT_TLSLD34
:
15118 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0)
15120 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15122 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15123 pinsn
+= (-1ULL << 52) + (13ULL << 16);
15124 bfd_put_32 (input_bfd
, pinsn
>> 32,
15125 contents
+ rel
->r_offset
);
15126 bfd_put_32 (input_bfd
, pinsn
& 0xffffffff,
15127 contents
+ rel
->r_offset
+ 4);
15128 rel
->r_addend
= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
15129 r_symndx
= STN_UNDEF
;
15130 r_type
= R_PPC64_TPREL34
;
15131 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15136 case R_PPC64_TLSGD
:
15137 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0
15138 && rel
+ 1 < relend
)
15140 unsigned int insn2
;
15141 enum elf_ppc64_reloc_type r_type1
= ELF64_R_TYPE (rel
[1].r_info
);
15143 offset
= rel
->r_offset
;
15144 if (is_plt_seq_reloc (r_type1
))
15146 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
);
15147 if (r_type1
== R_PPC64_PLT_PCREL34
15148 || r_type1
== R_PPC64_PLT_PCREL34_NOTOC
)
15149 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
15150 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
15154 if (ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_PLTCALL
)
15155 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
15157 if ((tls_mask
& TLS_GDIE
) != 0)
15160 r_type
= R_PPC64_NONE
;
15161 insn2
= 0x7c636a14; /* add 3,3,13 */
15166 if (toc_symndx
!= 0)
15168 r_symndx
= toc_symndx
;
15169 rel
->r_addend
= toc_addend
;
15171 if (r_type1
== R_PPC64_REL24_NOTOC
15172 || r_type1
== R_PPC64_PLTCALL_NOTOC
)
15174 r_type
= R_PPC64_NONE
;
15179 rel
->r_offset
= offset
+ d_offset
;
15180 r_type
= R_PPC64_TPREL16_LO
;
15181 insn2
= 0x38630000; /* addi 3,3,0 */
15184 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15185 /* Zap the reloc on the _tls_get_addr call too. */
15186 BFD_ASSERT (offset
== rel
[1].r_offset
);
15187 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
15188 bfd_put_32 (input_bfd
, insn2
, contents
+ offset
);
15189 if ((tls_mask
& TLS_GDIE
) == 0
15191 && r_type
!= R_PPC64_NONE
)
15196 case R_PPC64_TLSLD
:
15197 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0
15198 && rel
+ 1 < relend
)
15200 unsigned int insn2
;
15201 enum elf_ppc64_reloc_type r_type1
= ELF64_R_TYPE (rel
[1].r_info
);
15203 offset
= rel
->r_offset
;
15204 if (is_plt_seq_reloc (r_type1
))
15206 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
);
15207 if (r_type1
== R_PPC64_PLT_PCREL34
15208 || r_type1
== R_PPC64_PLT_PCREL34_NOTOC
)
15209 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
15210 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
15214 if (ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_PLTCALL
)
15215 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
15217 if (r_type1
== R_PPC64_REL24_NOTOC
15218 || r_type1
== R_PPC64_PLTCALL_NOTOC
)
15220 r_type
= R_PPC64_NONE
;
15225 rel
->r_offset
= offset
+ d_offset
;
15226 r_symndx
= STN_UNDEF
;
15227 r_type
= R_PPC64_TPREL16_LO
;
15228 rel
->r_addend
= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
15229 insn2
= 0x38630000; /* addi 3,3,0 */
15231 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15232 /* Zap the reloc on the _tls_get_addr call too. */
15233 BFD_ASSERT (offset
== rel
[1].r_offset
);
15234 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
15235 bfd_put_32 (input_bfd
, insn2
, contents
+ offset
);
15236 if (r_type
!= R_PPC64_NONE
)
15241 case R_PPC64_DTPMOD64
:
15242 if (rel
+ 1 < relend
15243 && rel
[1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_DTPREL64
)
15244 && rel
[1].r_offset
== rel
->r_offset
+ 8)
15246 if ((tls_mask
& TLS_GD
) == 0)
15248 rel
[1].r_info
= ELF64_R_INFO (r_symndx
, R_PPC64_NONE
);
15249 if ((tls_mask
& TLS_GDIE
) != 0)
15250 r_type
= R_PPC64_TPREL64
;
15253 bfd_put_64 (output_bfd
, 1, contents
+ rel
->r_offset
);
15254 r_type
= R_PPC64_NONE
;
15256 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15261 if ((tls_mask
& TLS_LD
) == 0)
15263 bfd_put_64 (output_bfd
, 1, contents
+ rel
->r_offset
);
15264 r_type
= R_PPC64_NONE
;
15265 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15270 case R_PPC64_TPREL64
:
15271 if ((tls_mask
& TLS_TPREL
) == 0)
15273 r_type
= R_PPC64_NONE
;
15274 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15278 case R_PPC64_ENTRY
:
15279 relocation
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
15280 if (!bfd_link_pic (info
)
15281 && !info
->traditional_format
15282 && relocation
+ 0x80008000 <= 0xffffffff)
15284 unsigned int insn1
, insn2
;
15286 insn1
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15287 insn2
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15288 if ((insn1
& ~0xfffc) == LD_R2_0R12
15289 && insn2
== ADD_R2_R2_R12
)
15291 bfd_put_32 (input_bfd
,
15292 LIS_R2
+ PPC_HA (relocation
),
15293 contents
+ rel
->r_offset
);
15294 bfd_put_32 (input_bfd
,
15295 ADDI_R2_R2
+ PPC_LO (relocation
),
15296 contents
+ rel
->r_offset
+ 4);
15301 relocation
-= (rel
->r_offset
15302 + input_section
->output_offset
15303 + input_section
->output_section
->vma
);
15304 if (relocation
+ 0x80008000 <= 0xffffffff)
15306 unsigned int insn1
, insn2
;
15308 insn1
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15309 insn2
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15310 if ((insn1
& ~0xfffc) == LD_R2_0R12
15311 && insn2
== ADD_R2_R2_R12
)
15313 bfd_put_32 (input_bfd
,
15314 ADDIS_R2_R12
+ PPC_HA (relocation
),
15315 contents
+ rel
->r_offset
);
15316 bfd_put_32 (input_bfd
,
15317 ADDI_R2_R2
+ PPC_LO (relocation
),
15318 contents
+ rel
->r_offset
+ 4);
15324 case R_PPC64_REL16_HA
:
15325 /* If we are generating a non-PIC executable, edit
15326 . 0: addis 2,12,.TOC.-0b@ha
15327 . addi 2,2,.TOC.-0b@l
15328 used by ELFv2 global entry points to set up r2, to
15331 if .TOC. is in range. */
15332 if (!bfd_link_pic (info
)
15333 && !info
->traditional_format
15335 && rel
->r_addend
== d_offset
15336 && h
!= NULL
&& &h
->elf
== htab
->elf
.hgot
15337 && rel
+ 1 < relend
15338 && rel
[1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_REL16_LO
)
15339 && rel
[1].r_offset
== rel
->r_offset
+ 4
15340 && rel
[1].r_addend
== rel
->r_addend
+ 4
15341 && relocation
+ 0x80008000 <= 0xffffffff)
15343 unsigned int insn1
, insn2
;
15344 offset
= rel
->r_offset
- d_offset
;
15345 insn1
= bfd_get_32 (input_bfd
, contents
+ offset
);
15346 insn2
= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
15347 if ((insn1
& 0xffff0000) == ADDIS_R2_R12
15348 && (insn2
& 0xffff0000) == ADDI_R2_R2
)
15350 r_type
= R_PPC64_ADDR16_HA
;
15351 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15352 rel
->r_addend
-= d_offset
;
15353 rel
[1].r_info
= ELF64_R_INFO (r_symndx
, R_PPC64_ADDR16_LO
);
15354 rel
[1].r_addend
-= d_offset
+ 4;
15355 bfd_put_32 (input_bfd
, LIS_R2
, contents
+ offset
);
15361 /* Handle other relocations that tweak non-addend part of insn. */
15363 max_br_offset
= 1 << 25;
15364 addend
= rel
->r_addend
;
15365 reloc_dest
= DEST_NORMAL
;
15371 case R_PPC64_TOCSAVE
:
15372 if (relocation
+ addend
== (rel
->r_offset
15373 + input_section
->output_offset
15374 + input_section
->output_section
->vma
)
15375 && tocsave_find (htab
, NO_INSERT
,
15376 &local_syms
, rel
, input_bfd
))
15378 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15380 || insn
== CROR_151515
|| insn
== CROR_313131
)
15381 bfd_put_32 (input_bfd
,
15382 STD_R2_0R1
+ STK_TOC (htab
),
15383 contents
+ rel
->r_offset
);
15387 /* Branch taken prediction relocations. */
15388 case R_PPC64_ADDR14_BRTAKEN
:
15389 case R_PPC64_REL14_BRTAKEN
:
15390 insn
= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
15391 /* Fall through. */
15393 /* Branch not taken prediction relocations. */
15394 case R_PPC64_ADDR14_BRNTAKEN
:
15395 case R_PPC64_REL14_BRNTAKEN
:
15396 insn
|= bfd_get_32 (input_bfd
,
15397 contents
+ rel
->r_offset
) & ~(0x01 << 21);
15398 /* Fall through. */
15400 case R_PPC64_REL14
:
15401 max_br_offset
= 1 << 15;
15402 /* Fall through. */
15404 case R_PPC64_REL24
:
15405 case R_PPC64_REL24_NOTOC
:
15406 case R_PPC64_PLTCALL
:
15407 case R_PPC64_PLTCALL_NOTOC
:
15408 /* Calls to functions with a different TOC, such as calls to
15409 shared objects, need to alter the TOC pointer. This is
15410 done using a linkage stub. A REL24 branching to these
15411 linkage stubs needs to be followed by a nop, as the nop
15412 will be replaced with an instruction to restore the TOC
15417 && h
->oh
->is_func_descriptor
)
15418 fdh
= ppc_follow_link (h
->oh
);
15419 stub_entry
= ppc_get_stub_entry (input_section
, sec
, fdh
, &orig_rel
,
15421 if ((r_type
== R_PPC64_PLTCALL
15422 || r_type
== R_PPC64_PLTCALL_NOTOC
)
15423 && stub_entry
!= NULL
15424 && stub_entry
->stub_type
>= ppc_stub_plt_call
15425 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15428 if (stub_entry
!= NULL
15429 && ((stub_entry
->stub_type
>= ppc_stub_plt_call
15430 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15431 || stub_entry
->stub_type
== ppc_stub_plt_branch_r2off
15432 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
15433 || stub_entry
->stub_type
== ppc_stub_long_branch_r2off
15434 || stub_entry
->stub_type
== ppc_stub_long_branch_both
))
15436 bfd_boolean can_plt_call
= FALSE
;
15438 if (stub_entry
->stub_type
== ppc_stub_plt_call
15440 && htab
->params
->plt_localentry0
!= 0
15441 && is_elfv2_localentry0 (&h
->elf
))
15443 /* The function doesn't use or change r2. */
15444 can_plt_call
= TRUE
;
15446 else if (r_type
== R_PPC64_REL24_NOTOC
)
15448 /* NOTOC calls don't need to restore r2. */
15449 can_plt_call
= TRUE
;
15452 /* All of these stubs may modify r2, so there must be a
15453 branch and link followed by a nop. The nop is
15454 replaced by an insn to restore r2. */
15455 else if (rel
->r_offset
+ 8 <= input_section
->size
)
15459 br
= bfd_get_32 (input_bfd
,
15460 contents
+ rel
->r_offset
);
15465 nop
= bfd_get_32 (input_bfd
,
15466 contents
+ rel
->r_offset
+ 4);
15467 if (nop
== LD_R2_0R1
+ STK_TOC (htab
))
15468 can_plt_call
= TRUE
;
15469 else if (nop
== NOP
15470 || nop
== CROR_151515
15471 || nop
== CROR_313131
)
15474 && is_tls_get_addr (&h
->elf
, htab
)
15475 && htab
->params
->tls_get_addr_opt
)
15477 /* Special stub used, leave nop alone. */
15480 bfd_put_32 (input_bfd
,
15481 LD_R2_0R1
+ STK_TOC (htab
),
15482 contents
+ rel
->r_offset
+ 4);
15483 can_plt_call
= TRUE
;
15488 if (!can_plt_call
&& h
!= NULL
)
15490 const char *name
= h
->elf
.root
.root
.string
;
15495 if (strncmp (name
, "__libc_start_main", 17) == 0
15496 && (name
[17] == 0 || name
[17] == '@'))
15498 /* Allow crt1 branch to go via a toc adjusting
15499 stub. Other calls that never return could do
15500 the same, if we could detect such. */
15501 can_plt_call
= TRUE
;
15507 /* g++ as of 20130507 emits self-calls without a
15508 following nop. This is arguably wrong since we
15509 have conflicting information. On the one hand a
15510 global symbol and on the other a local call
15511 sequence, but don't error for this special case.
15512 It isn't possible to cheaply verify we have
15513 exactly such a call. Allow all calls to the same
15515 asection
*code_sec
= sec
;
15517 if (get_opd_info (sec
) != NULL
)
15519 bfd_vma off
= (relocation
+ addend
15520 - sec
->output_section
->vma
15521 - sec
->output_offset
);
15523 opd_entry_value (sec
, off
, &code_sec
, NULL
, FALSE
);
15525 if (code_sec
== input_section
)
15526 can_plt_call
= TRUE
;
15531 if (stub_entry
->stub_type
>= ppc_stub_plt_call
15532 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15533 info
->callbacks
->einfo
15534 /* xgettext:c-format */
15535 (_("%H: call to `%pT' lacks nop, can't restore toc; "
15536 "(plt call stub)\n"),
15537 input_bfd
, input_section
, rel
->r_offset
, sym_name
);
15539 info
->callbacks
->einfo
15540 /* xgettext:c-format */
15541 (_("%H: call to `%pT' lacks nop, can't restore toc; "
15542 "(toc save/adjust stub)\n"),
15543 input_bfd
, input_section
, rel
->r_offset
, sym_name
);
15545 bfd_set_error (bfd_error_bad_value
);
15550 && stub_entry
->stub_type
>= ppc_stub_plt_call
15551 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15552 unresolved_reloc
= FALSE
;
15555 if ((stub_entry
== NULL
15556 || stub_entry
->stub_type
== ppc_stub_long_branch
15557 || stub_entry
->stub_type
== ppc_stub_plt_branch
)
15558 && get_opd_info (sec
) != NULL
)
15560 /* The branch destination is the value of the opd entry. */
15561 bfd_vma off
= (relocation
+ addend
15562 - sec
->output_section
->vma
15563 - sec
->output_offset
);
15564 bfd_vma dest
= opd_entry_value (sec
, off
, NULL
, NULL
, FALSE
);
15565 if (dest
!= (bfd_vma
) -1)
15569 reloc_dest
= DEST_OPD
;
15573 /* If the branch is out of reach we ought to have a long
15575 from
= (rel
->r_offset
15576 + input_section
->output_offset
15577 + input_section
->output_section
->vma
);
15579 relocation
+= PPC64_LOCAL_ENTRY_OFFSET (fdh
15583 if (stub_entry
!= NULL
15584 && (stub_entry
->stub_type
== ppc_stub_long_branch
15585 || stub_entry
->stub_type
== ppc_stub_plt_branch
)
15586 && (r_type
== R_PPC64_ADDR14_BRTAKEN
15587 || r_type
== R_PPC64_ADDR14_BRNTAKEN
15588 || (relocation
+ addend
- from
+ max_br_offset
15589 < 2 * max_br_offset
)))
15590 /* Don't use the stub if this branch is in range. */
15593 if (stub_entry
!= NULL
15594 && (stub_entry
->stub_type
== ppc_stub_long_branch_notoc
15595 || stub_entry
->stub_type
== ppc_stub_long_branch_both
15596 || stub_entry
->stub_type
== ppc_stub_plt_branch_notoc
15597 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
)
15598 && (r_type
!= R_PPC64_REL24_NOTOC
15599 || ((fdh
? fdh
->elf
.other
: sym
->st_other
)
15600 & STO_PPC64_LOCAL_MASK
) <= 1 << STO_PPC64_LOCAL_BIT
)
15601 && (relocation
+ addend
- from
+ max_br_offset
15602 < 2 * max_br_offset
))
15605 if (stub_entry
!= NULL
15606 && (stub_entry
->stub_type
== ppc_stub_long_branch_r2off
15607 || stub_entry
->stub_type
== ppc_stub_long_branch_both
15608 || stub_entry
->stub_type
== ppc_stub_plt_branch_r2off
15609 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
)
15610 && r_type
== R_PPC64_REL24_NOTOC
15611 && (relocation
+ addend
- from
+ max_br_offset
15612 < 2 * max_br_offset
))
15615 if (stub_entry
!= NULL
)
15617 /* Munge up the value and addend so that we call the stub
15618 rather than the procedure directly. */
15619 asection
*stub_sec
= stub_entry
->group
->stub_sec
;
15621 if (stub_entry
->stub_type
== ppc_stub_save_res
)
15622 relocation
+= (stub_sec
->output_offset
15623 + stub_sec
->output_section
->vma
15624 + stub_sec
->size
- htab
->sfpr
->size
15625 - htab
->sfpr
->output_offset
15626 - htab
->sfpr
->output_section
->vma
);
15628 relocation
= (stub_entry
->stub_offset
15629 + stub_sec
->output_offset
15630 + stub_sec
->output_section
->vma
);
15632 reloc_dest
= DEST_STUB
;
15634 if (((stub_entry
->stub_type
== ppc_stub_plt_call
15635 && ALWAYS_EMIT_R2SAVE
)
15636 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
15637 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
15639 && is_tls_get_addr (&h
->elf
, htab
)
15640 && htab
->params
->tls_get_addr_opt
)
15641 && rel
+ 1 < relend
15642 && rel
[1].r_offset
== rel
->r_offset
+ 4
15643 && ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_TOCSAVE
)
15645 else if ((stub_entry
->stub_type
== ppc_stub_long_branch_both
15646 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
15647 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
15648 && r_type
== R_PPC64_REL24_NOTOC
)
15651 if (r_type
== R_PPC64_REL24_NOTOC
15652 && (stub_entry
->stub_type
== ppc_stub_plt_call_notoc
15653 || stub_entry
->stub_type
== ppc_stub_plt_call_both
))
15654 htab
->notoc_plt
= 1;
15661 /* Set 'a' bit. This is 0b00010 in BO field for branch
15662 on CR(BI) insns (BO == 001at or 011at), and 0b01000
15663 for branch on CTR insns (BO == 1a00t or 1a01t). */
15664 if ((insn
& (0x14 << 21)) == (0x04 << 21))
15665 insn
|= 0x02 << 21;
15666 else if ((insn
& (0x14 << 21)) == (0x10 << 21))
15667 insn
|= 0x08 << 21;
15673 /* Invert 'y' bit if not the default. */
15674 if ((bfd_signed_vma
) (relocation
+ addend
- from
) < 0)
15675 insn
^= 0x01 << 21;
15678 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
15681 /* NOP out calls to undefined weak functions.
15682 We can thus call a weak function without first
15683 checking whether the function is defined. */
15685 && h
->elf
.root
.type
== bfd_link_hash_undefweak
15686 && h
->elf
.dynindx
== -1
15687 && (r_type
== R_PPC64_REL24
15688 || r_type
== R_PPC64_REL24_NOTOC
)
15692 bfd_put_32 (input_bfd
, NOP
, contents
+ rel
->r_offset
);
15697 case R_PPC64_GOT16_DS
:
15698 from
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
15699 if (relocation
+ addend
- from
+ 0x8000 < 0x10000
15700 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15702 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
15703 if ((insn
& (0x3fu
<< 26 | 0x3)) == 58u << 26 /* ld */)
15705 insn
+= (14u << 26) - (58u << 26);
15706 bfd_put_32 (input_bfd
, insn
, contents
+ (rel
->r_offset
& ~3));
15707 r_type
= R_PPC64_TOC16
;
15708 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15713 case R_PPC64_GOT16_LO_DS
:
15714 case R_PPC64_GOT16_HA
:
15715 from
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
15716 if (relocation
+ addend
- from
+ 0x80008000ULL
< 0x100000000ULL
15717 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15719 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
15720 if ((insn
& (0x3fu
<< 26 | 0x3)) == 58u << 26 /* ld */)
15722 insn
+= (14u << 26) - (58u << 26);
15723 bfd_put_32 (input_bfd
, insn
, contents
+ (rel
->r_offset
& ~3));
15724 r_type
= R_PPC64_TOC16_LO
;
15725 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15727 else if ((insn
& (0x3fu
<< 26)) == 15u << 26 /* addis */)
15729 r_type
= R_PPC64_TOC16_HA
;
15730 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15735 case R_PPC64_GOT_PCREL34
:
15736 from
= (rel
->r_offset
15737 + input_section
->output_section
->vma
15738 + input_section
->output_offset
);
15739 if (relocation
- from
+ (1ULL << 33) < 1ULL << 34
15740 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15742 offset
= rel
->r_offset
;
15743 pinsn
= bfd_get_32 (input_bfd
, contents
+ offset
);
15745 pinsn
|= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
15746 if ((pinsn
& ((-1ULL << 50) | (63ULL << 26)))
15747 == ((1ULL << 58) | (1ULL << 52) | (57ULL << 26) /* pld */))
15749 /* Replace with paddi. */
15750 pinsn
+= (2ULL << 56) + (14ULL << 26) - (57ULL << 26);
15751 r_type
= R_PPC64_PCREL34
;
15752 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15753 bfd_put_32 (input_bfd
, pinsn
>> 32, contents
+ offset
);
15754 bfd_put_32 (input_bfd
, pinsn
, contents
+ offset
+ 4);
15760 case R_PPC64_PCREL34
:
15761 if (SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15763 offset
= rel
->r_offset
;
15764 pinsn
= bfd_get_32 (input_bfd
, contents
+ offset
);
15766 pinsn
|= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
15767 if ((pinsn
& ((-1ULL << 50) | (63ULL << 26)))
15768 == ((1ULL << 58) | (2ULL << 56) | (1ULL << 52)
15769 | (14ULL << 26) /* paddi */))
15772 if (rel
+ 1 < relend
15773 && rel
[1].r_offset
== offset
15774 && rel
[1].r_info
== ELF64_R_INFO (0, R_PPC64_PCREL_OPT
))
15776 bfd_vma off2
= rel
[1].r_addend
;
15778 /* zero means next insn. */
15781 if (off2
+ 4 <= input_section
->size
)
15784 bfd_signed_vma addend_off
;
15785 pinsn2
= bfd_get_32 (input_bfd
, contents
+ off2
);
15787 if ((pinsn2
& (63ULL << 58)) == 1ULL << 58)
15789 if (off2
+ 8 > input_section
->size
)
15791 pinsn2
|= bfd_get_32 (input_bfd
,
15792 contents
+ off2
+ 4);
15794 if (xlate_pcrel_opt (&pinsn
, &pinsn2
, &addend_off
))
15796 addend
+= addend_off
;
15797 rel
->r_addend
= addend
;
15798 bfd_put_32 (input_bfd
, pinsn
>> 32,
15799 contents
+ offset
);
15800 bfd_put_32 (input_bfd
, pinsn
,
15801 contents
+ offset
+ 4);
15802 bfd_put_32 (input_bfd
, pinsn2
>> 32,
15804 if ((pinsn2
& (63ULL << 58)) == 1ULL << 58)
15805 bfd_put_32 (input_bfd
, pinsn2
,
15806 contents
+ off2
+ 4);
15816 save_unresolved_reloc
= unresolved_reloc
;
15820 /* xgettext:c-format */
15821 _bfd_error_handler (_("%pB: %s unsupported"),
15822 input_bfd
, ppc64_elf_howto_table
[r_type
]->name
);
15824 bfd_set_error (bfd_error_bad_value
);
15830 case R_PPC64_TLSGD
:
15831 case R_PPC64_TLSLD
:
15832 case R_PPC64_TOCSAVE
:
15833 case R_PPC64_GNU_VTINHERIT
:
15834 case R_PPC64_GNU_VTENTRY
:
15835 case R_PPC64_ENTRY
:
15836 case R_PPC64_PCREL_OPT
:
15839 /* GOT16 relocations. Like an ADDR16 using the symbol's
15840 address in the GOT as relocation value instead of the
15841 symbol's value itself. Also, create a GOT entry for the
15842 symbol and put the symbol value there. */
15843 case R_PPC64_GOT_TLSGD16
:
15844 case R_PPC64_GOT_TLSGD16_LO
:
15845 case R_PPC64_GOT_TLSGD16_HI
:
15846 case R_PPC64_GOT_TLSGD16_HA
:
15847 case R_PPC64_GOT_TLSGD34
:
15848 tls_type
= TLS_TLS
| TLS_GD
;
15851 case R_PPC64_GOT_TLSLD16
:
15852 case R_PPC64_GOT_TLSLD16_LO
:
15853 case R_PPC64_GOT_TLSLD16_HI
:
15854 case R_PPC64_GOT_TLSLD16_HA
:
15855 case R_PPC64_GOT_TLSLD34
:
15856 tls_type
= TLS_TLS
| TLS_LD
;
15859 case R_PPC64_GOT_TPREL16_DS
:
15860 case R_PPC64_GOT_TPREL16_LO_DS
:
15861 case R_PPC64_GOT_TPREL16_HI
:
15862 case R_PPC64_GOT_TPREL16_HA
:
15863 case R_PPC64_GOT_TPREL34
:
15864 tls_type
= TLS_TLS
| TLS_TPREL
;
15867 case R_PPC64_GOT_DTPREL16_DS
:
15868 case R_PPC64_GOT_DTPREL16_LO_DS
:
15869 case R_PPC64_GOT_DTPREL16_HI
:
15870 case R_PPC64_GOT_DTPREL16_HA
:
15871 case R_PPC64_GOT_DTPREL34
:
15872 tls_type
= TLS_TLS
| TLS_DTPREL
;
15875 case R_PPC64_GOT16
:
15876 case R_PPC64_GOT16_LO
:
15877 case R_PPC64_GOT16_HI
:
15878 case R_PPC64_GOT16_HA
:
15879 case R_PPC64_GOT16_DS
:
15880 case R_PPC64_GOT16_LO_DS
:
15881 case R_PPC64_GOT_PCREL34
:
15884 /* Relocation is to the entry for this symbol in the global
15889 unsigned long indx
= 0;
15890 struct got_entry
*ent
;
15892 if (tls_type
== (TLS_TLS
| TLS_LD
)
15893 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15894 ent
= ppc64_tlsld_got (input_bfd
);
15899 if (!htab
->elf
.dynamic_sections_created
15900 || h
->elf
.dynindx
== -1
15901 || SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
)
15902 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, &h
->elf
))
15903 /* This is actually a static link, or it is a
15904 -Bsymbolic link and the symbol is defined
15905 locally, or the symbol was forced to be local
15906 because of a version file. */
15910 indx
= h
->elf
.dynindx
;
15911 unresolved_reloc
= FALSE
;
15913 ent
= h
->elf
.got
.glist
;
15917 if (local_got_ents
== NULL
)
15919 ent
= local_got_ents
[r_symndx
];
15922 for (; ent
!= NULL
; ent
= ent
->next
)
15923 if (ent
->addend
== orig_rel
.r_addend
15924 && ent
->owner
== input_bfd
15925 && ent
->tls_type
== tls_type
)
15931 if (ent
->is_indirect
)
15932 ent
= ent
->got
.ent
;
15933 offp
= &ent
->got
.offset
;
15934 got
= ppc64_elf_tdata (ent
->owner
)->got
;
15938 /* The offset must always be a multiple of 8. We use the
15939 least significant bit to record whether we have already
15940 processed this entry. */
15942 if ((off
& 1) != 0)
15946 /* Generate relocs for the dynamic linker, except in
15947 the case of TLSLD where we'll use one entry per
15955 ? h
->elf
.type
== STT_GNU_IFUNC
15956 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
);
15959 relgot
= htab
->elf
.irelplt
;
15961 htab
->local_ifunc_resolver
= 1;
15962 else if (is_static_defined (&h
->elf
))
15963 htab
->maybe_local_ifunc_resolver
= 1;
15966 || (bfd_link_pic (info
)
15968 || !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, &h
->elf
))
15970 && bfd_link_executable (info
)
15971 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))))
15972 relgot
= ppc64_elf_tdata (ent
->owner
)->relgot
;
15973 if (relgot
!= NULL
)
15975 outrel
.r_offset
= (got
->output_section
->vma
15976 + got
->output_offset
15978 outrel
.r_addend
= orig_rel
.r_addend
;
15979 if (tls_type
& (TLS_LD
| TLS_GD
))
15981 outrel
.r_addend
= 0;
15982 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_DTPMOD64
);
15983 if (tls_type
== (TLS_TLS
| TLS_GD
))
15985 loc
= relgot
->contents
;
15986 loc
+= (relgot
->reloc_count
++
15987 * sizeof (Elf64_External_Rela
));
15988 bfd_elf64_swap_reloca_out (output_bfd
,
15990 outrel
.r_offset
+= 8;
15991 outrel
.r_addend
= orig_rel
.r_addend
;
15993 = ELF64_R_INFO (indx
, R_PPC64_DTPREL64
);
15996 else if (tls_type
== (TLS_TLS
| TLS_DTPREL
))
15997 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_DTPREL64
);
15998 else if (tls_type
== (TLS_TLS
| TLS_TPREL
))
15999 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_TPREL64
);
16000 else if (indx
!= 0)
16001 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_GLOB_DAT
);
16005 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
16007 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
16009 /* Write the .got section contents for the sake
16011 loc
= got
->contents
+ off
;
16012 bfd_put_64 (output_bfd
, outrel
.r_addend
+ relocation
,
16016 if (indx
== 0 && tls_type
!= (TLS_TLS
| TLS_LD
))
16018 outrel
.r_addend
+= relocation
;
16019 if (tls_type
& (TLS_GD
| TLS_DTPREL
| TLS_TPREL
))
16021 if (htab
->elf
.tls_sec
== NULL
)
16022 outrel
.r_addend
= 0;
16024 outrel
.r_addend
-= htab
->elf
.tls_sec
->vma
;
16027 loc
= relgot
->contents
;
16028 loc
+= (relgot
->reloc_count
++
16029 * sizeof (Elf64_External_Rela
));
16030 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
16033 /* Init the .got section contents here if we're not
16034 emitting a reloc. */
16037 relocation
+= orig_rel
.r_addend
;
16040 if (htab
->elf
.tls_sec
== NULL
)
16044 if (tls_type
& TLS_LD
)
16047 relocation
-= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
16048 if (tls_type
& TLS_TPREL
)
16049 relocation
+= DTP_OFFSET
- TP_OFFSET
;
16052 if (tls_type
& (TLS_GD
| TLS_LD
))
16054 bfd_put_64 (output_bfd
, relocation
,
16055 got
->contents
+ off
+ 8);
16059 bfd_put_64 (output_bfd
, relocation
,
16060 got
->contents
+ off
);
16064 if (off
>= (bfd_vma
) -2)
16067 relocation
= got
->output_section
->vma
+ got
->output_offset
+ off
;
16069 if (!(r_type
== R_PPC64_GOT_PCREL34
16070 || r_type
== R_PPC64_GOT_TLSGD34
16071 || r_type
== R_PPC64_GOT_TLSLD34
16072 || r_type
== R_PPC64_GOT_TPREL34
16073 || r_type
== R_PPC64_GOT_DTPREL34
))
16074 addend
= -(TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
);
16078 case R_PPC64_PLT16_HA
:
16079 case R_PPC64_PLT16_HI
:
16080 case R_PPC64_PLT16_LO
:
16081 case R_PPC64_PLT16_LO_DS
:
16082 case R_PPC64_PLT_PCREL34
:
16083 case R_PPC64_PLT_PCREL34_NOTOC
:
16084 case R_PPC64_PLT32
:
16085 case R_PPC64_PLT64
:
16086 case R_PPC64_PLTSEQ
:
16087 case R_PPC64_PLTSEQ_NOTOC
:
16088 case R_PPC64_PLTCALL
:
16089 case R_PPC64_PLTCALL_NOTOC
:
16090 /* Relocation is to the entry for this symbol in the
16091 procedure linkage table. */
16092 unresolved_reloc
= TRUE
;
16094 struct plt_entry
**plt_list
= NULL
;
16096 plt_list
= &h
->elf
.plt
.plist
;
16097 else if (local_got_ents
!= NULL
)
16099 struct plt_entry
**local_plt
= (struct plt_entry
**)
16100 (local_got_ents
+ symtab_hdr
->sh_info
);
16101 plt_list
= local_plt
+ r_symndx
;
16105 struct plt_entry
*ent
;
16107 for (ent
= *plt_list
; ent
!= NULL
; ent
= ent
->next
)
16108 if (ent
->plt
.offset
!= (bfd_vma
) -1
16109 && ent
->addend
== orig_rel
.r_addend
)
16114 plt
= htab
->elf
.splt
;
16115 if (!htab
->elf
.dynamic_sections_created
16117 || h
->elf
.dynindx
== -1)
16120 ? h
->elf
.type
== STT_GNU_IFUNC
16121 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
16122 plt
= htab
->elf
.iplt
;
16124 plt
= htab
->pltlocal
;
16126 relocation
= (plt
->output_section
->vma
16127 + plt
->output_offset
16128 + ent
->plt
.offset
);
16129 if (r_type
== R_PPC64_PLT16_HA
16130 || r_type
== R_PPC64_PLT16_HI
16131 || r_type
== R_PPC64_PLT16_LO
16132 || r_type
== R_PPC64_PLT16_LO_DS
)
16134 got
= (elf_gp (output_bfd
)
16135 + htab
->sec_info
[input_section
->id
].toc_off
);
16139 unresolved_reloc
= FALSE
;
16147 /* Relocation value is TOC base. */
16148 relocation
= TOCstart
;
16149 if (r_symndx
== STN_UNDEF
)
16150 relocation
+= htab
->sec_info
[input_section
->id
].toc_off
;
16151 else if (unresolved_reloc
)
16153 else if (sec
!= NULL
&& sec
->id
< htab
->sec_info_arr_size
)
16154 relocation
+= htab
->sec_info
[sec
->id
].toc_off
;
16156 unresolved_reloc
= TRUE
;
16159 /* TOC16 relocs. We want the offset relative to the TOC base,
16160 which is the address of the start of the TOC plus 0x8000.
16161 The TOC consists of sections .got, .toc, .tocbss, and .plt,
16163 case R_PPC64_TOC16
:
16164 case R_PPC64_TOC16_LO
:
16165 case R_PPC64_TOC16_HI
:
16166 case R_PPC64_TOC16_DS
:
16167 case R_PPC64_TOC16_LO_DS
:
16168 case R_PPC64_TOC16_HA
:
16169 addend
-= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
16174 /* Relocate against the beginning of the section. */
16175 case R_PPC64_SECTOFF
:
16176 case R_PPC64_SECTOFF_LO
:
16177 case R_PPC64_SECTOFF_HI
:
16178 case R_PPC64_SECTOFF_DS
:
16179 case R_PPC64_SECTOFF_LO_DS
:
16180 case R_PPC64_SECTOFF_HA
:
16182 addend
-= sec
->output_section
->vma
;
16185 case R_PPC64_REL16
:
16186 case R_PPC64_REL16_LO
:
16187 case R_PPC64_REL16_HI
:
16188 case R_PPC64_REL16_HA
:
16189 case R_PPC64_REL16_HIGH
:
16190 case R_PPC64_REL16_HIGHA
:
16191 case R_PPC64_REL16_HIGHER
:
16192 case R_PPC64_REL16_HIGHERA
:
16193 case R_PPC64_REL16_HIGHEST
:
16194 case R_PPC64_REL16_HIGHESTA
:
16195 case R_PPC64_REL16_HIGHER34
:
16196 case R_PPC64_REL16_HIGHERA34
:
16197 case R_PPC64_REL16_HIGHEST34
:
16198 case R_PPC64_REL16_HIGHESTA34
:
16199 case R_PPC64_REL16DX_HA
:
16200 case R_PPC64_REL14
:
16201 case R_PPC64_REL14_BRNTAKEN
:
16202 case R_PPC64_REL14_BRTAKEN
:
16203 case R_PPC64_REL24
:
16204 case R_PPC64_REL24_NOTOC
:
16205 case R_PPC64_PCREL34
:
16206 case R_PPC64_PCREL28
:
16209 case R_PPC64_TPREL16
:
16210 case R_PPC64_TPREL16_LO
:
16211 case R_PPC64_TPREL16_HI
:
16212 case R_PPC64_TPREL16_HA
:
16213 case R_PPC64_TPREL16_DS
:
16214 case R_PPC64_TPREL16_LO_DS
:
16215 case R_PPC64_TPREL16_HIGH
:
16216 case R_PPC64_TPREL16_HIGHA
:
16217 case R_PPC64_TPREL16_HIGHER
:
16218 case R_PPC64_TPREL16_HIGHERA
:
16219 case R_PPC64_TPREL16_HIGHEST
:
16220 case R_PPC64_TPREL16_HIGHESTA
:
16221 case R_PPC64_TPREL34
:
16223 && h
->elf
.root
.type
== bfd_link_hash_undefweak
16224 && h
->elf
.dynindx
== -1)
16226 /* Make this relocation against an undefined weak symbol
16227 resolve to zero. This is really just a tweak, since
16228 code using weak externs ought to check that they are
16229 defined before using them. */
16230 bfd_byte
*p
= contents
+ rel
->r_offset
- d_offset
;
16232 insn
= bfd_get_32 (input_bfd
, p
);
16233 insn
= _bfd_elf_ppc_at_tprel_transform (insn
, 13);
16235 bfd_put_32 (input_bfd
, insn
, p
);
16238 if (htab
->elf
.tls_sec
!= NULL
)
16239 addend
-= htab
->elf
.tls_sec
->vma
+ TP_OFFSET
;
16240 /* The TPREL16 relocs shouldn't really be used in shared
16241 libs or with non-local symbols as that will result in
16242 DT_TEXTREL being set, but support them anyway. */
16245 case R_PPC64_DTPREL16
:
16246 case R_PPC64_DTPREL16_LO
:
16247 case R_PPC64_DTPREL16_HI
:
16248 case R_PPC64_DTPREL16_HA
:
16249 case R_PPC64_DTPREL16_DS
:
16250 case R_PPC64_DTPREL16_LO_DS
:
16251 case R_PPC64_DTPREL16_HIGH
:
16252 case R_PPC64_DTPREL16_HIGHA
:
16253 case R_PPC64_DTPREL16_HIGHER
:
16254 case R_PPC64_DTPREL16_HIGHERA
:
16255 case R_PPC64_DTPREL16_HIGHEST
:
16256 case R_PPC64_DTPREL16_HIGHESTA
:
16257 case R_PPC64_DTPREL34
:
16258 if (htab
->elf
.tls_sec
!= NULL
)
16259 addend
-= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
16262 case R_PPC64_ADDR64_LOCAL
:
16263 addend
+= PPC64_LOCAL_ENTRY_OFFSET (h
!= NULL
16268 case R_PPC64_DTPMOD64
:
16273 case R_PPC64_TPREL64
:
16274 if (htab
->elf
.tls_sec
!= NULL
)
16275 addend
-= htab
->elf
.tls_sec
->vma
+ TP_OFFSET
;
16278 case R_PPC64_DTPREL64
:
16279 if (htab
->elf
.tls_sec
!= NULL
)
16280 addend
-= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
16281 /* Fall through. */
16283 /* Relocations that may need to be propagated if this is a
16285 case R_PPC64_REL30
:
16286 case R_PPC64_REL32
:
16287 case R_PPC64_REL64
:
16288 case R_PPC64_ADDR14
:
16289 case R_PPC64_ADDR14_BRNTAKEN
:
16290 case R_PPC64_ADDR14_BRTAKEN
:
16291 case R_PPC64_ADDR16
:
16292 case R_PPC64_ADDR16_DS
:
16293 case R_PPC64_ADDR16_HA
:
16294 case R_PPC64_ADDR16_HI
:
16295 case R_PPC64_ADDR16_HIGH
:
16296 case R_PPC64_ADDR16_HIGHA
:
16297 case R_PPC64_ADDR16_HIGHER
:
16298 case R_PPC64_ADDR16_HIGHERA
:
16299 case R_PPC64_ADDR16_HIGHEST
:
16300 case R_PPC64_ADDR16_HIGHESTA
:
16301 case R_PPC64_ADDR16_LO
:
16302 case R_PPC64_ADDR16_LO_DS
:
16303 case R_PPC64_ADDR16_HIGHER34
:
16304 case R_PPC64_ADDR16_HIGHERA34
:
16305 case R_PPC64_ADDR16_HIGHEST34
:
16306 case R_PPC64_ADDR16_HIGHESTA34
:
16307 case R_PPC64_ADDR24
:
16308 case R_PPC64_ADDR32
:
16309 case R_PPC64_ADDR64
:
16310 case R_PPC64_UADDR16
:
16311 case R_PPC64_UADDR32
:
16312 case R_PPC64_UADDR64
:
16314 case R_PPC64_D34_LO
:
16315 case R_PPC64_D34_HI30
:
16316 case R_PPC64_D34_HA30
:
16319 if ((input_section
->flags
& SEC_ALLOC
) == 0)
16322 if (NO_OPD_RELOCS
&& is_opd
)
16325 if (bfd_link_pic (info
)
16327 || h
->dyn_relocs
!= NULL
)
16328 && ((h
!= NULL
&& pc_dynrelocs (h
))
16329 || must_be_dyn_reloc (info
, r_type
)))
16331 ? h
->dyn_relocs
!= NULL
16332 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
))
16334 bfd_boolean skip
, relocate
;
16339 /* When generating a dynamic object, these relocations
16340 are copied into the output file to be resolved at run
16346 out_off
= _bfd_elf_section_offset (output_bfd
, info
,
16347 input_section
, rel
->r_offset
);
16348 if (out_off
== (bfd_vma
) -1)
16350 else if (out_off
== (bfd_vma
) -2)
16351 skip
= TRUE
, relocate
= TRUE
;
16352 out_off
+= (input_section
->output_section
->vma
16353 + input_section
->output_offset
);
16354 outrel
.r_offset
= out_off
;
16355 outrel
.r_addend
= rel
->r_addend
;
16357 /* Optimize unaligned reloc use. */
16358 if ((r_type
== R_PPC64_ADDR64
&& (out_off
& 7) != 0)
16359 || (r_type
== R_PPC64_UADDR64
&& (out_off
& 7) == 0))
16360 r_type
^= R_PPC64_ADDR64
^ R_PPC64_UADDR64
;
16361 else if ((r_type
== R_PPC64_ADDR32
&& (out_off
& 3) != 0)
16362 || (r_type
== R_PPC64_UADDR32
&& (out_off
& 3) == 0))
16363 r_type
^= R_PPC64_ADDR32
^ R_PPC64_UADDR32
;
16364 else if ((r_type
== R_PPC64_ADDR16
&& (out_off
& 1) != 0)
16365 || (r_type
== R_PPC64_UADDR16
&& (out_off
& 1) == 0))
16366 r_type
^= R_PPC64_ADDR16
^ R_PPC64_UADDR16
;
16369 memset (&outrel
, 0, sizeof outrel
);
16370 else if (!SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
)
16372 && r_type
!= R_PPC64_TOC
)
16374 indx
= h
->elf
.dynindx
;
16375 BFD_ASSERT (indx
!= -1);
16376 outrel
.r_info
= ELF64_R_INFO (indx
, r_type
);
16380 /* This symbol is local, or marked to become local,
16381 or this is an opd section reloc which must point
16382 at a local function. */
16383 outrel
.r_addend
+= relocation
;
16384 if (r_type
== R_PPC64_ADDR64
|| r_type
== R_PPC64_TOC
)
16386 if (is_opd
&& h
!= NULL
)
16388 /* Lie about opd entries. This case occurs
16389 when building shared libraries and we
16390 reference a function in another shared
16391 lib. The same thing happens for a weak
16392 definition in an application that's
16393 overridden by a strong definition in a
16394 shared lib. (I believe this is a generic
16395 bug in binutils handling of weak syms.)
16396 In these cases we won't use the opd
16397 entry in this lib. */
16398 unresolved_reloc
= FALSE
;
16401 && r_type
== R_PPC64_ADDR64
16403 ? h
->elf
.type
== STT_GNU_IFUNC
16404 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
))
16405 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
16408 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
16410 /* We need to relocate .opd contents for ld.so.
16411 Prelink also wants simple and consistent rules
16412 for relocs. This make all RELATIVE relocs have
16413 *r_offset equal to r_addend. */
16420 ? h
->elf
.type
== STT_GNU_IFUNC
16421 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
16423 info
->callbacks
->einfo
16424 /* xgettext:c-format */
16425 (_("%H: %s for indirect "
16426 "function `%pT' unsupported\n"),
16427 input_bfd
, input_section
, rel
->r_offset
,
16428 ppc64_elf_howto_table
[r_type
]->name
,
16432 else if (r_symndx
== STN_UNDEF
|| bfd_is_abs_section (sec
))
16434 else if (sec
== NULL
|| sec
->owner
== NULL
)
16436 bfd_set_error (bfd_error_bad_value
);
16441 asection
*osec
= sec
->output_section
;
16443 if ((osec
->flags
& SEC_THREAD_LOCAL
) != 0)
16445 /* TLS symbol values are relative to the
16446 TLS segment. Dynamic relocations for
16447 local TLS symbols therefore can't be
16448 reduced to a relocation against their
16449 section symbol because it holds the
16450 address of the section, not a value
16451 relative to the TLS segment. We could
16452 change the .tdata dynamic section symbol
16453 to be zero value but STN_UNDEF works
16454 and is used elsewhere, eg. for TPREL64
16455 GOT relocs against local TLS symbols. */
16456 osec
= htab
->elf
.tls_sec
;
16461 indx
= elf_section_data (osec
)->dynindx
;
16464 if ((osec
->flags
& SEC_READONLY
) == 0
16465 && htab
->elf
.data_index_section
!= NULL
)
16466 osec
= htab
->elf
.data_index_section
;
16468 osec
= htab
->elf
.text_index_section
;
16469 indx
= elf_section_data (osec
)->dynindx
;
16471 BFD_ASSERT (indx
!= 0);
16474 /* We are turning this relocation into one
16475 against a section symbol, so subtract out
16476 the output section's address but not the
16477 offset of the input section in the output
16479 outrel
.r_addend
-= osec
->vma
;
16482 outrel
.r_info
= ELF64_R_INFO (indx
, r_type
);
16486 sreloc
= elf_section_data (input_section
)->sreloc
;
16488 ? h
->elf
.type
== STT_GNU_IFUNC
16489 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
16491 sreloc
= htab
->elf
.irelplt
;
16493 htab
->local_ifunc_resolver
= 1;
16494 else if (is_static_defined (&h
->elf
))
16495 htab
->maybe_local_ifunc_resolver
= 1;
16497 if (sreloc
== NULL
)
16500 if (sreloc
->reloc_count
* sizeof (Elf64_External_Rela
)
16503 loc
= sreloc
->contents
;
16504 loc
+= sreloc
->reloc_count
++ * sizeof (Elf64_External_Rela
);
16505 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
16507 if (!warned_dynamic
16508 && !ppc64_glibc_dynamic_reloc (ELF64_R_TYPE (outrel
.r_info
)))
16510 info
->callbacks
->einfo
16511 /* xgettext:c-format */
16512 (_("%X%P: %pB: %s against %pT "
16513 "is not supported by glibc as a dynamic relocation\n"),
16515 ppc64_elf_howto_table
[ELF64_R_TYPE (outrel
.r_info
)]->name
,
16517 warned_dynamic
= TRUE
;
16520 /* If this reloc is against an external symbol, it will
16521 be computed at runtime, so there's no need to do
16522 anything now. However, for the sake of prelink ensure
16523 that the section contents are a known value. */
16526 unresolved_reloc
= FALSE
;
16527 /* The value chosen here is quite arbitrary as ld.so
16528 ignores section contents except for the special
16529 case of .opd where the contents might be accessed
16530 before relocation. Choose zero, as that won't
16531 cause reloc overflow. */
16534 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
16535 to improve backward compatibility with older
16537 if (r_type
== R_PPC64_ADDR64
)
16538 addend
= outrel
.r_addend
;
16539 /* Adjust pc_relative relocs to have zero in *r_offset. */
16540 else if (ppc64_elf_howto_table
[r_type
]->pc_relative
)
16541 addend
= outrel
.r_offset
;
16547 case R_PPC64_GLOB_DAT
:
16548 case R_PPC64_JMP_SLOT
:
16549 case R_PPC64_JMP_IREL
:
16550 case R_PPC64_RELATIVE
:
16551 /* We shouldn't ever see these dynamic relocs in relocatable
16553 /* Fall through. */
16555 case R_PPC64_PLTGOT16
:
16556 case R_PPC64_PLTGOT16_DS
:
16557 case R_PPC64_PLTGOT16_HA
:
16558 case R_PPC64_PLTGOT16_HI
:
16559 case R_PPC64_PLTGOT16_LO
:
16560 case R_PPC64_PLTGOT16_LO_DS
:
16561 case R_PPC64_PLTREL32
:
16562 case R_PPC64_PLTREL64
:
16563 /* These ones haven't been implemented yet. */
16565 info
->callbacks
->einfo
16566 /* xgettext:c-format */
16567 (_("%P: %pB: %s is not supported for `%pT'\n"),
16569 ppc64_elf_howto_table
[r_type
]->name
, sym_name
);
16571 bfd_set_error (bfd_error_invalid_operation
);
16576 /* Multi-instruction sequences that access the TOC can be
16577 optimized, eg. addis ra,r2,0; addi rb,ra,x;
16578 to nop; addi rb,r2,x; */
16584 case R_PPC64_GOT_TLSLD16_HI
:
16585 case R_PPC64_GOT_TLSGD16_HI
:
16586 case R_PPC64_GOT_TPREL16_HI
:
16587 case R_PPC64_GOT_DTPREL16_HI
:
16588 case R_PPC64_GOT16_HI
:
16589 case R_PPC64_TOC16_HI
:
16590 /* These relocs would only be useful if building up an
16591 offset to later add to r2, perhaps in an indexed
16592 addressing mode instruction. Don't try to optimize.
16593 Unfortunately, the possibility of someone building up an
16594 offset like this or even with the HA relocs, means that
16595 we need to check the high insn when optimizing the low
16599 case R_PPC64_PLTCALL_NOTOC
:
16600 if (!unresolved_reloc
)
16601 htab
->notoc_plt
= 1;
16602 /* Fall through. */
16603 case R_PPC64_PLTCALL
:
16604 if (unresolved_reloc
)
16606 /* No plt entry. Make this into a direct call. */
16607 bfd_byte
*p
= contents
+ rel
->r_offset
;
16608 insn
= bfd_get_32 (input_bfd
, p
);
16610 bfd_put_32 (input_bfd
, B_DOT
| insn
, p
);
16611 if (r_type
== R_PPC64_PLTCALL
)
16612 bfd_put_32 (input_bfd
, NOP
, p
+ 4);
16613 unresolved_reloc
= save_unresolved_reloc
;
16614 r_type
= R_PPC64_REL24
;
16618 case R_PPC64_PLTSEQ_NOTOC
:
16619 case R_PPC64_PLTSEQ
:
16620 if (unresolved_reloc
)
16622 unresolved_reloc
= FALSE
;
16627 case R_PPC64_PLT_PCREL34_NOTOC
:
16628 if (!unresolved_reloc
)
16629 htab
->notoc_plt
= 1;
16630 /* Fall through. */
16631 case R_PPC64_PLT_PCREL34
:
16632 if (unresolved_reloc
)
16634 bfd_byte
*p
= contents
+ rel
->r_offset
;
16635 bfd_put_32 (input_bfd
, PNOP
>> 32, p
);
16636 bfd_put_32 (input_bfd
, PNOP
, p
+ 4);
16637 unresolved_reloc
= FALSE
;
16642 case R_PPC64_PLT16_HA
:
16643 if (unresolved_reloc
)
16645 unresolved_reloc
= FALSE
;
16648 /* Fall through. */
16649 case R_PPC64_GOT_TLSLD16_HA
:
16650 case R_PPC64_GOT_TLSGD16_HA
:
16651 case R_PPC64_GOT_TPREL16_HA
:
16652 case R_PPC64_GOT_DTPREL16_HA
:
16653 case R_PPC64_GOT16_HA
:
16654 case R_PPC64_TOC16_HA
:
16655 if (htab
->do_toc_opt
&& relocation
+ addend
+ 0x8000 < 0x10000
16656 && !ppc64_elf_tdata (input_bfd
)->unexpected_toc_insn
)
16660 p
= contents
+ (rel
->r_offset
& ~3);
16661 bfd_put_32 (input_bfd
, NOP
, p
);
16666 case R_PPC64_PLT16_LO
:
16667 case R_PPC64_PLT16_LO_DS
:
16668 if (unresolved_reloc
)
16670 unresolved_reloc
= FALSE
;
16673 /* Fall through. */
16674 case R_PPC64_GOT_TLSLD16_LO
:
16675 case R_PPC64_GOT_TLSGD16_LO
:
16676 case R_PPC64_GOT_TPREL16_LO_DS
:
16677 case R_PPC64_GOT_DTPREL16_LO_DS
:
16678 case R_PPC64_GOT16_LO
:
16679 case R_PPC64_GOT16_LO_DS
:
16680 case R_PPC64_TOC16_LO
:
16681 case R_PPC64_TOC16_LO_DS
:
16682 if (htab
->do_toc_opt
&& relocation
+ addend
+ 0x8000 < 0x10000
16683 && !ppc64_elf_tdata (input_bfd
)->unexpected_toc_insn
)
16685 bfd_byte
*p
= contents
+ (rel
->r_offset
& ~3);
16686 insn
= bfd_get_32 (input_bfd
, p
);
16687 if ((insn
& (0x3fu
<< 26)) == 12u << 26 /* addic */)
16689 /* Transform addic to addi when we change reg. */
16690 insn
&= ~((0x3fu
<< 26) | (0x1f << 16));
16691 insn
|= (14u << 26) | (2 << 16);
16695 insn
&= ~(0x1f << 16);
16698 bfd_put_32 (input_bfd
, insn
, p
);
16702 case R_PPC64_TPREL16_HA
:
16703 if (htab
->do_tls_opt
&& relocation
+ addend
+ 0x8000 < 0x10000)
16705 bfd_byte
*p
= contents
+ (rel
->r_offset
& ~3);
16706 insn
= bfd_get_32 (input_bfd
, p
);
16707 if ((insn
& ((0x3fu
<< 26) | 0x1f << 16))
16708 != ((15u << 26) | (13 << 16)) /* addis rt,13,imm */)
16709 /* xgettext:c-format */
16710 info
->callbacks
->minfo
16711 (_("%H: warning: %s unexpected insn %#x.\n"),
16712 input_bfd
, input_section
, rel
->r_offset
,
16713 ppc64_elf_howto_table
[r_type
]->name
, insn
);
16716 bfd_put_32 (input_bfd
, NOP
, p
);
16722 case R_PPC64_TPREL16_LO
:
16723 case R_PPC64_TPREL16_LO_DS
:
16724 if (htab
->do_tls_opt
&& relocation
+ addend
+ 0x8000 < 0x10000)
16726 bfd_byte
*p
= contents
+ (rel
->r_offset
& ~3);
16727 insn
= bfd_get_32 (input_bfd
, p
);
16728 insn
&= ~(0x1f << 16);
16730 bfd_put_32 (input_bfd
, insn
, p
);
16735 /* Do any further special processing. */
16741 case R_PPC64_REL16_HA
:
16742 case R_PPC64_REL16_HIGHA
:
16743 case R_PPC64_REL16_HIGHERA
:
16744 case R_PPC64_REL16_HIGHESTA
:
16745 case R_PPC64_REL16DX_HA
:
16746 case R_PPC64_ADDR16_HA
:
16747 case R_PPC64_ADDR16_HIGHA
:
16748 case R_PPC64_ADDR16_HIGHERA
:
16749 case R_PPC64_ADDR16_HIGHESTA
:
16750 case R_PPC64_TOC16_HA
:
16751 case R_PPC64_SECTOFF_HA
:
16752 case R_PPC64_TPREL16_HA
:
16753 case R_PPC64_TPREL16_HIGHA
:
16754 case R_PPC64_TPREL16_HIGHERA
:
16755 case R_PPC64_TPREL16_HIGHESTA
:
16756 case R_PPC64_DTPREL16_HA
:
16757 case R_PPC64_DTPREL16_HIGHA
:
16758 case R_PPC64_DTPREL16_HIGHERA
:
16759 case R_PPC64_DTPREL16_HIGHESTA
:
16760 /* It's just possible that this symbol is a weak symbol
16761 that's not actually defined anywhere. In that case,
16762 'sec' would be NULL, and we should leave the symbol
16763 alone (it will be set to zero elsewhere in the link). */
16766 /* Fall through. */
16768 case R_PPC64_GOT16_HA
:
16769 case R_PPC64_PLTGOT16_HA
:
16770 case R_PPC64_PLT16_HA
:
16771 case R_PPC64_GOT_TLSGD16_HA
:
16772 case R_PPC64_GOT_TLSLD16_HA
:
16773 case R_PPC64_GOT_TPREL16_HA
:
16774 case R_PPC64_GOT_DTPREL16_HA
:
16775 /* Add 0x10000 if sign bit in 0:15 is set.
16776 Bits 0:15 are not used. */
16780 case R_PPC64_D34_HA30
:
16781 case R_PPC64_ADDR16_HIGHERA34
:
16782 case R_PPC64_ADDR16_HIGHESTA34
:
16783 case R_PPC64_REL16_HIGHERA34
:
16784 case R_PPC64_REL16_HIGHESTA34
:
16786 addend
+= 1ULL << 33;
16789 case R_PPC64_ADDR16_DS
:
16790 case R_PPC64_ADDR16_LO_DS
:
16791 case R_PPC64_GOT16_DS
:
16792 case R_PPC64_GOT16_LO_DS
:
16793 case R_PPC64_PLT16_LO_DS
:
16794 case R_PPC64_SECTOFF_DS
:
16795 case R_PPC64_SECTOFF_LO_DS
:
16796 case R_PPC64_TOC16_DS
:
16797 case R_PPC64_TOC16_LO_DS
:
16798 case R_PPC64_PLTGOT16_DS
:
16799 case R_PPC64_PLTGOT16_LO_DS
:
16800 case R_PPC64_GOT_TPREL16_DS
:
16801 case R_PPC64_GOT_TPREL16_LO_DS
:
16802 case R_PPC64_GOT_DTPREL16_DS
:
16803 case R_PPC64_GOT_DTPREL16_LO_DS
:
16804 case R_PPC64_TPREL16_DS
:
16805 case R_PPC64_TPREL16_LO_DS
:
16806 case R_PPC64_DTPREL16_DS
:
16807 case R_PPC64_DTPREL16_LO_DS
:
16808 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
16810 /* If this reloc is against an lq, lxv, or stxv insn, then
16811 the value must be a multiple of 16. This is somewhat of
16812 a hack, but the "correct" way to do this by defining _DQ
16813 forms of all the _DS relocs bloats all reloc switches in
16814 this file. It doesn't make much sense to use these
16815 relocs in data, so testing the insn should be safe. */
16816 if ((insn
& (0x3fu
<< 26)) == (56u << 26)
16817 || ((insn
& (0x3fu
<< 26)) == (61u << 26) && (insn
& 3) == 1))
16819 relocation
+= addend
;
16820 addend
= insn
& (mask
^ 3);
16821 if ((relocation
& mask
) != 0)
16823 relocation
^= relocation
& mask
;
16824 info
->callbacks
->einfo
16825 /* xgettext:c-format */
16826 (_("%H: error: %s not a multiple of %u\n"),
16827 input_bfd
, input_section
, rel
->r_offset
,
16828 ppc64_elf_howto_table
[r_type
]->name
,
16830 bfd_set_error (bfd_error_bad_value
);
16837 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
16838 because such sections are not SEC_ALLOC and thus ld.so will
16839 not process them. */
16840 howto
= ppc64_elf_howto_table
[(int) r_type
];
16841 if (unresolved_reloc
16842 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
16843 && h
->elf
.def_dynamic
)
16844 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
16845 rel
->r_offset
) != (bfd_vma
) -1)
16847 info
->callbacks
->einfo
16848 /* xgettext:c-format */
16849 (_("%H: unresolvable %s against `%pT'\n"),
16850 input_bfd
, input_section
, rel
->r_offset
,
16852 h
->elf
.root
.root
.string
);
16856 /* 16-bit fields in insns mostly have signed values, but a
16857 few insns have 16-bit unsigned values. Really, we should
16858 have different reloc types. */
16859 if (howto
->complain_on_overflow
!= complain_overflow_dont
16860 && howto
->dst_mask
== 0xffff
16861 && (input_section
->flags
& SEC_CODE
) != 0)
16863 enum complain_overflow complain
= complain_overflow_signed
;
16865 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
16866 if ((insn
& (0x3fu
<< 26)) == 10u << 26 /* cmpli */)
16867 complain
= complain_overflow_bitfield
;
16868 else if (howto
->rightshift
== 0
16869 ? ((insn
& (0x3fu
<< 26)) == 28u << 26 /* andi */
16870 || (insn
& (0x3fu
<< 26)) == 24u << 26 /* ori */
16871 || (insn
& (0x3fu
<< 26)) == 26u << 26 /* xori */)
16872 : ((insn
& (0x3fu
<< 26)) == 29u << 26 /* andis */
16873 || (insn
& (0x3fu
<< 26)) == 25u << 26 /* oris */
16874 || (insn
& (0x3fu
<< 26)) == 27u << 26 /* xoris */))
16875 complain
= complain_overflow_unsigned
;
16876 if (howto
->complain_on_overflow
!= complain
)
16878 alt_howto
= *howto
;
16879 alt_howto
.complain_on_overflow
= complain
;
16880 howto
= &alt_howto
;
16886 /* Split field relocs aren't handled by _bfd_final_link_relocate. */
16888 case R_PPC64_D34_LO
:
16889 case R_PPC64_D34_HI30
:
16890 case R_PPC64_D34_HA30
:
16891 case R_PPC64_PCREL34
:
16892 case R_PPC64_GOT_PCREL34
:
16893 case R_PPC64_TPREL34
:
16894 case R_PPC64_DTPREL34
:
16895 case R_PPC64_GOT_TLSGD34
:
16896 case R_PPC64_GOT_TLSLD34
:
16897 case R_PPC64_GOT_TPREL34
:
16898 case R_PPC64_GOT_DTPREL34
:
16899 case R_PPC64_PLT_PCREL34
:
16900 case R_PPC64_PLT_PCREL34_NOTOC
:
16902 case R_PPC64_PCREL28
:
16903 if (rel
->r_offset
+ 8 > input_section
->size
)
16904 r
= bfd_reloc_outofrange
;
16907 relocation
+= addend
;
16908 if (howto
->pc_relative
)
16909 relocation
-= (rel
->r_offset
16910 + input_section
->output_offset
16911 + input_section
->output_section
->vma
);
16912 relocation
>>= howto
->rightshift
;
16914 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
16916 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
16918 pinsn
&= ~howto
->dst_mask
;
16919 pinsn
|= (((relocation
<< 16) | (relocation
& 0xffff))
16920 & howto
->dst_mask
);
16921 bfd_put_32 (input_bfd
, pinsn
>> 32, contents
+ rel
->r_offset
);
16922 bfd_put_32 (input_bfd
, pinsn
, contents
+ rel
->r_offset
+ 4);
16924 if (howto
->complain_on_overflow
== complain_overflow_signed
16925 && (relocation
+ (1ULL << (howto
->bitsize
- 1))
16926 >= 1ULL << howto
->bitsize
))
16927 r
= bfd_reloc_overflow
;
16931 case R_PPC64_REL16DX_HA
:
16932 if (rel
->r_offset
+ 4 > input_section
->size
)
16933 r
= bfd_reloc_outofrange
;
16936 relocation
+= addend
;
16937 relocation
-= (rel
->r_offset
16938 + input_section
->output_offset
16939 + input_section
->output_section
->vma
);
16940 relocation
= (bfd_signed_vma
) relocation
>> 16;
16941 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
16943 insn
|= (relocation
& 0xffc1) | ((relocation
& 0x3e) << 15);
16944 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
16946 if (relocation
+ 0x8000 > 0xffff)
16947 r
= bfd_reloc_overflow
;
16952 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
16953 contents
, rel
->r_offset
,
16954 relocation
, addend
);
16957 if (r
!= bfd_reloc_ok
)
16959 char *more_info
= NULL
;
16960 const char *reloc_name
= howto
->name
;
16962 if (reloc_dest
!= DEST_NORMAL
)
16964 more_info
= bfd_malloc (strlen (reloc_name
) + 8);
16965 if (more_info
!= NULL
)
16967 strcpy (more_info
, reloc_name
);
16968 strcat (more_info
, (reloc_dest
== DEST_OPD
16969 ? " (OPD)" : " (stub)"));
16970 reloc_name
= more_info
;
16974 if (r
== bfd_reloc_overflow
)
16976 /* On code like "if (foo) foo();" don't report overflow
16977 on a branch to zero when foo is undefined. */
16979 && (reloc_dest
== DEST_STUB
16981 && (h
->elf
.root
.type
== bfd_link_hash_undefweak
16982 || h
->elf
.root
.type
== bfd_link_hash_undefined
)
16983 && is_branch_reloc (r_type
))))
16984 info
->callbacks
->reloc_overflow (info
, &h
->elf
.root
,
16985 sym_name
, reloc_name
,
16987 input_bfd
, input_section
,
16992 info
->callbacks
->einfo
16993 /* xgettext:c-format */
16994 (_("%H: %s against `%pT': error %d\n"),
16995 input_bfd
, input_section
, rel
->r_offset
,
16996 reloc_name
, sym_name
, (int) r
);
16999 if (more_info
!= NULL
)
17009 Elf_Internal_Shdr
*rel_hdr
;
17010 size_t deleted
= rel
- wrel
;
17012 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
17013 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
17014 if (rel_hdr
->sh_size
== 0)
17016 /* It is too late to remove an empty reloc section. Leave
17018 ??? What is wrong with an empty section??? */
17019 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
17022 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
17023 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
17024 input_section
->reloc_count
-= deleted
;
17027 /* If we're emitting relocations, then shortly after this function
17028 returns, reloc offsets and addends for this section will be
17029 adjusted. Worse, reloc symbol indices will be for the output
17030 file rather than the input. Save a copy of the relocs for
17031 opd_entry_value. */
17032 if (is_opd
&& (info
->emitrelocations
|| bfd_link_relocatable (info
)))
17035 amt
= input_section
->reloc_count
* sizeof (Elf_Internal_Rela
);
17036 rel
= bfd_alloc (input_bfd
, amt
);
17037 BFD_ASSERT (ppc64_elf_tdata (input_bfd
)->opd
.relocs
== NULL
);
17038 ppc64_elf_tdata (input_bfd
)->opd
.relocs
= rel
;
17041 memcpy (rel
, relocs
, amt
);
17046 /* Adjust the value of any local symbols in opd sections. */
17049 ppc64_elf_output_symbol_hook (struct bfd_link_info
*info
,
17050 const char *name ATTRIBUTE_UNUSED
,
17051 Elf_Internal_Sym
*elfsym
,
17052 asection
*input_sec
,
17053 struct elf_link_hash_entry
*h
)
17055 struct _opd_sec_data
*opd
;
17062 opd
= get_opd_info (input_sec
);
17063 if (opd
== NULL
|| opd
->adjust
== NULL
)
17066 value
= elfsym
->st_value
- input_sec
->output_offset
;
17067 if (!bfd_link_relocatable (info
))
17068 value
-= input_sec
->output_section
->vma
;
17070 adjust
= opd
->adjust
[OPD_NDX (value
)];
17074 elfsym
->st_value
+= adjust
;
17078 /* Finish up dynamic symbol handling. We set the contents of various
17079 dynamic sections here. */
17082 ppc64_elf_finish_dynamic_symbol (bfd
*output_bfd
,
17083 struct bfd_link_info
*info
,
17084 struct elf_link_hash_entry
*h
,
17085 Elf_Internal_Sym
*sym
)
17087 struct ppc_link_hash_table
*htab
;
17088 struct plt_entry
*ent
;
17090 htab
= ppc_hash_table (info
);
17094 if (!htab
->opd_abi
&& !h
->def_regular
)
17095 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
17096 if (ent
->plt
.offset
!= (bfd_vma
) -1)
17098 /* Mark the symbol as undefined, rather than as
17099 defined in glink. Leave the value if there were
17100 any relocations where pointer equality matters
17101 (this is a clue for the dynamic linker, to make
17102 function pointer comparisons work between an
17103 application and shared library), otherwise set it
17105 sym
->st_shndx
= SHN_UNDEF
;
17106 if (!h
->pointer_equality_needed
)
17108 else if (!h
->ref_regular_nonweak
)
17110 /* This breaks function pointer comparisons, but
17111 that is better than breaking tests for a NULL
17112 function pointer. */
17119 && (h
->root
.type
== bfd_link_hash_defined
17120 || h
->root
.type
== bfd_link_hash_defweak
)
17121 && (h
->root
.u
.def
.section
== htab
->elf
.sdynbss
17122 || h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
))
17124 /* This symbol needs a copy reloc. Set it up. */
17125 Elf_Internal_Rela rela
;
17129 if (h
->dynindx
== -1)
17132 rela
.r_offset
= defined_sym_val (h
);
17133 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_PPC64_COPY
);
17135 if (h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
17136 srel
= htab
->elf
.sreldynrelro
;
17138 srel
= htab
->elf
.srelbss
;
17139 loc
= srel
->contents
;
17140 loc
+= srel
->reloc_count
++ * sizeof (Elf64_External_Rela
);
17141 bfd_elf64_swap_reloca_out (output_bfd
, &rela
, loc
);
17147 /* Used to decide how to sort relocs in an optimal manner for the
17148 dynamic linker, before writing them out. */
17150 static enum elf_reloc_type_class
17151 ppc64_elf_reloc_type_class (const struct bfd_link_info
*info
,
17152 const asection
*rel_sec
,
17153 const Elf_Internal_Rela
*rela
)
17155 enum elf_ppc64_reloc_type r_type
;
17156 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
17158 if (rel_sec
== htab
->elf
.irelplt
)
17159 return reloc_class_ifunc
;
17161 r_type
= ELF64_R_TYPE (rela
->r_info
);
17164 case R_PPC64_RELATIVE
:
17165 return reloc_class_relative
;
17166 case R_PPC64_JMP_SLOT
:
17167 return reloc_class_plt
;
17169 return reloc_class_copy
;
17171 return reloc_class_normal
;
17175 /* Finish up the dynamic sections. */
17178 ppc64_elf_finish_dynamic_sections (bfd
*output_bfd
,
17179 struct bfd_link_info
*info
)
17181 struct ppc_link_hash_table
*htab
;
17185 htab
= ppc_hash_table (info
);
17189 dynobj
= htab
->elf
.dynobj
;
17190 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
17192 if (htab
->elf
.dynamic_sections_created
)
17194 Elf64_External_Dyn
*dyncon
, *dynconend
;
17196 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
17199 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
17200 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
17201 for (; dyncon
< dynconend
; dyncon
++)
17203 Elf_Internal_Dyn dyn
;
17206 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
17213 case DT_PPC64_GLINK
:
17215 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
17216 /* We stupidly defined DT_PPC64_GLINK to be the start
17217 of glink rather than the first entry point, which is
17218 what ld.so needs, and now have a bigger stub to
17219 support automatic multiple TOCs. */
17220 dyn
.d_un
.d_ptr
+= GLINK_PLTRESOLVE_SIZE (htab
) - 8 * 4;
17224 s
= bfd_get_section_by_name (output_bfd
, ".opd");
17227 dyn
.d_un
.d_ptr
= s
->vma
;
17231 if ((htab
->do_multi_toc
&& htab
->multi_toc_needed
)
17232 || htab
->notoc_plt
)
17233 dyn
.d_un
.d_val
|= PPC64_OPT_MULTI_TOC
;
17234 if (htab
->has_plt_localentry0
)
17235 dyn
.d_un
.d_val
|= PPC64_OPT_LOCALENTRY
;
17238 case DT_PPC64_OPDSZ
:
17239 s
= bfd_get_section_by_name (output_bfd
, ".opd");
17242 dyn
.d_un
.d_val
= s
->size
;
17246 s
= htab
->elf
.splt
;
17247 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
17251 s
= htab
->elf
.srelplt
;
17252 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
17256 dyn
.d_un
.d_val
= htab
->elf
.srelplt
->size
;
17260 if (htab
->local_ifunc_resolver
)
17261 info
->callbacks
->einfo
17262 (_("%X%P: text relocations and GNU indirect "
17263 "functions will result in a segfault at runtime\n"));
17264 else if (htab
->maybe_local_ifunc_resolver
)
17265 info
->callbacks
->einfo
17266 (_("%P: warning: text relocations and GNU indirect "
17267 "functions may result in a segfault at runtime\n"));
17271 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
17275 if (htab
->elf
.sgot
!= NULL
&& htab
->elf
.sgot
->size
!= 0
17276 && htab
->elf
.sgot
->output_section
!= bfd_abs_section_ptr
)
17278 /* Fill in the first entry in the global offset table.
17279 We use it to hold the link-time TOCbase. */
17280 bfd_put_64 (output_bfd
,
17281 elf_gp (output_bfd
) + TOC_BASE_OFF
,
17282 htab
->elf
.sgot
->contents
);
17284 /* Set .got entry size. */
17285 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
17289 if (htab
->elf
.splt
!= NULL
&& htab
->elf
.splt
->size
!= 0
17290 && htab
->elf
.splt
->output_section
!= bfd_abs_section_ptr
)
17292 /* Set .plt entry size. */
17293 elf_section_data (htab
->elf
.splt
->output_section
)->this_hdr
.sh_entsize
17294 = PLT_ENTRY_SIZE (htab
);
17297 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
17298 brlt ourselves if emitrelocations. */
17299 if (htab
->brlt
!= NULL
17300 && htab
->brlt
->reloc_count
!= 0
17301 && !_bfd_elf_link_output_relocs (output_bfd
,
17303 elf_section_data (htab
->brlt
)->rela
.hdr
,
17304 elf_section_data (htab
->brlt
)->relocs
,
17308 if (htab
->glink
!= NULL
17309 && htab
->glink
->reloc_count
!= 0
17310 && !_bfd_elf_link_output_relocs (output_bfd
,
17312 elf_section_data (htab
->glink
)->rela
.hdr
,
17313 elf_section_data (htab
->glink
)->relocs
,
17318 if (htab
->glink_eh_frame
!= NULL
17319 && htab
->glink_eh_frame
->size
!= 0
17320 && htab
->glink_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
17321 && !_bfd_elf_write_section_eh_frame (output_bfd
, info
,
17322 htab
->glink_eh_frame
,
17323 htab
->glink_eh_frame
->contents
))
17326 /* We need to handle writing out multiple GOT sections ourselves,
17327 since we didn't add them to DYNOBJ. We know dynobj is the first
17329 while ((dynobj
= dynobj
->link
.next
) != NULL
)
17333 if (!is_ppc64_elf (dynobj
))
17336 s
= ppc64_elf_tdata (dynobj
)->got
;
17339 && s
->output_section
!= bfd_abs_section_ptr
17340 && !bfd_set_section_contents (output_bfd
, s
->output_section
,
17341 s
->contents
, s
->output_offset
,
17344 s
= ppc64_elf_tdata (dynobj
)->relgot
;
17347 && s
->output_section
!= bfd_abs_section_ptr
17348 && !bfd_set_section_contents (output_bfd
, s
->output_section
,
17349 s
->contents
, s
->output_offset
,
17357 #include "elf64-target.h"
17359 /* FreeBSD support */
17361 #undef TARGET_LITTLE_SYM
17362 #undef TARGET_LITTLE_NAME
17364 #undef TARGET_BIG_SYM
17365 #define TARGET_BIG_SYM powerpc_elf64_fbsd_vec
17366 #undef TARGET_BIG_NAME
17367 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
17370 #define ELF_OSABI ELFOSABI_FREEBSD
17373 #define elf64_bed elf64_powerpc_fbsd_bed
17375 #include "elf64-target.h"