1 /* PowerPC64-specific support for 64-bit ELF.
2 Copyright (C) 1999-2019 Free Software Foundation, Inc.
3 Written by Linus Nordberg, Swox AB <info@swox.com>,
4 based on elf32-ppc.c by Ian Lance Taylor.
5 Largely rewritten by Alan Modra.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License along
20 with this program; if not, write to the Free Software Foundation, Inc.,
21 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
24 /* The 64-bit PowerPC ELF ABI may be found at
25 http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
26 http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html */
34 #include "elf/ppc64.h"
35 #include "elf64-ppc.h"
38 /* 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
, long lo
, long hi
, unsigned int id
, bfd_vma value
)
2127 if (id
== (unsigned) -1)
2131 mid
= (lo
+ hi
) >> 1;
2132 if (syms
[mid
]->value
+ syms
[mid
]->section
->vma
< value
)
2134 else if (syms
[mid
]->value
+ syms
[mid
]->section
->vma
> value
)
2144 mid
= (lo
+ hi
) >> 1;
2145 if (syms
[mid
]->section
->id
< id
)
2147 else if (syms
[mid
]->section
->id
> id
)
2149 else if (syms
[mid
]->value
< value
)
2151 else if (syms
[mid
]->value
> value
)
2161 section_covers_vma (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*section
, void *ptr
)
2163 bfd_vma vma
= *(bfd_vma
*) ptr
;
2164 return ((section
->flags
& SEC_ALLOC
) != 0
2165 && section
->vma
<= vma
2166 && vma
< section
->vma
+ section
->size
);
2169 /* Create synthetic symbols, effectively restoring "dot-symbol" function
2170 entry syms. Also generate @plt symbols for the glink branch table.
2171 Returns count of synthetic symbols in RET or -1 on error. */
2174 ppc64_elf_get_synthetic_symtab (bfd
*abfd
,
2175 long static_count
, asymbol
**static_syms
,
2176 long dyn_count
, asymbol
**dyn_syms
,
2182 size_t symcount
, codesecsym
, codesecsymend
, secsymend
, opdsymend
;
2183 asection
*opd
= NULL
;
2184 bfd_boolean relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2186 int abi
= abiversion (abfd
);
2192 opd
= bfd_get_section_by_name (abfd
, ".opd");
2193 if (opd
== NULL
&& abi
== 1)
2205 symcount
= static_count
;
2207 symcount
+= dyn_count
;
2211 syms
= bfd_malloc ((symcount
+ 1) * sizeof (*syms
));
2215 if (!relocatable
&& static_count
!= 0 && dyn_count
!= 0)
2217 /* Use both symbol tables. */
2218 memcpy (syms
, static_syms
, static_count
* sizeof (*syms
));
2219 memcpy (syms
+ static_count
, dyn_syms
,
2220 (dyn_count
+ 1) * sizeof (*syms
));
2222 else if (!relocatable
&& static_count
== 0)
2223 memcpy (syms
, dyn_syms
, (symcount
+ 1) * sizeof (*syms
));
2225 memcpy (syms
, static_syms
, (symcount
+ 1) * sizeof (*syms
));
2227 /* Trim uninteresting symbols. Interesting symbols are section,
2228 function, and notype symbols. */
2229 for (i
= 0, j
= 0; i
< symcount
; ++i
)
2230 if ((syms
[i
]->flags
& (BSF_FILE
| BSF_OBJECT
| BSF_THREAD_LOCAL
2231 | BSF_RELC
| BSF_SRELC
)) == 0)
2232 syms
[j
++] = syms
[i
];
2235 synthetic_relocatable
= relocatable
;
2236 synthetic_opd
= opd
;
2237 qsort (syms
, symcount
, sizeof (*syms
), compare_symbols
);
2239 if (!relocatable
&& symcount
> 1)
2241 /* Trim duplicate syms, since we may have merged the normal
2242 and dynamic symbols. Actually, we only care about syms
2243 that have different values, so trim any with the same
2244 value. Don't consider ifunc and ifunc resolver symbols
2245 duplicates however, because GDB wants to know whether a
2246 text symbol is an ifunc resolver. */
2247 for (i
= 1, j
= 1; i
< symcount
; ++i
)
2249 const asymbol
*s0
= syms
[i
- 1];
2250 const asymbol
*s1
= syms
[i
];
2252 if ((s0
->value
+ s0
->section
->vma
2253 != s1
->value
+ s1
->section
->vma
)
2254 || ((s0
->flags
& BSF_GNU_INDIRECT_FUNCTION
)
2255 != (s1
->flags
& BSF_GNU_INDIRECT_FUNCTION
)))
2256 syms
[j
++] = syms
[i
];
2262 /* Note that here and in compare_symbols we can't compare opd and
2263 sym->section directly. With separate debug info files, the
2264 symbols will be extracted from the debug file while abfd passed
2265 to this function is the real binary. */
2266 if (strcmp (syms
[i
]->section
->name
, ".opd") == 0)
2270 for (; i
< symcount
; ++i
)
2271 if (((syms
[i
]->section
->flags
& (SEC_CODE
| SEC_ALLOC
2272 | SEC_THREAD_LOCAL
))
2273 != (SEC_CODE
| SEC_ALLOC
))
2274 || (syms
[i
]->flags
& BSF_SECTION_SYM
) == 0)
2278 for (; i
< symcount
; ++i
)
2279 if ((syms
[i
]->flags
& BSF_SECTION_SYM
) == 0)
2283 for (; i
< symcount
; ++i
)
2284 if (strcmp (syms
[i
]->section
->name
, ".opd") != 0)
2288 for (; i
< symcount
; ++i
)
2289 if (((syms
[i
]->section
->flags
2290 & (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
)))
2291 != (SEC_CODE
| SEC_ALLOC
))
2299 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
2304 if (opdsymend
== secsymend
)
2307 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
2308 relcount
= (opd
->flags
& SEC_RELOC
) ? opd
->reloc_count
: 0;
2312 if (!(*slurp_relocs
) (abfd
, opd
, static_syms
, FALSE
))
2319 for (i
= secsymend
, r
= opd
->relocation
; i
< opdsymend
; ++i
)
2323 while (r
< opd
->relocation
+ relcount
2324 && r
->address
< syms
[i
]->value
+ opd
->vma
)
2327 if (r
== opd
->relocation
+ relcount
)
2330 if (r
->address
!= syms
[i
]->value
+ opd
->vma
)
2333 if (r
->howto
->type
!= R_PPC64_ADDR64
)
2336 sym
= *r
->sym_ptr_ptr
;
2337 if (!sym_exists_at (syms
, opdsymend
, symcount
,
2338 sym
->section
->id
, sym
->value
+ r
->addend
))
2341 size
+= sizeof (asymbol
);
2342 size
+= strlen (syms
[i
]->name
) + 2;
2348 s
= *ret
= bfd_malloc (size
);
2355 names
= (char *) (s
+ count
);
2357 for (i
= secsymend
, r
= opd
->relocation
; i
< opdsymend
; ++i
)
2361 while (r
< opd
->relocation
+ relcount
2362 && r
->address
< syms
[i
]->value
+ opd
->vma
)
2365 if (r
== opd
->relocation
+ relcount
)
2368 if (r
->address
!= syms
[i
]->value
+ opd
->vma
)
2371 if (r
->howto
->type
!= R_PPC64_ADDR64
)
2374 sym
= *r
->sym_ptr_ptr
;
2375 if (!sym_exists_at (syms
, opdsymend
, symcount
,
2376 sym
->section
->id
, sym
->value
+ r
->addend
))
2381 s
->flags
|= BSF_SYNTHETIC
;
2382 s
->section
= sym
->section
;
2383 s
->value
= sym
->value
+ r
->addend
;
2386 len
= strlen (syms
[i
]->name
);
2387 memcpy (names
, syms
[i
]->name
, len
+ 1);
2389 /* Have udata.p point back to the original symbol this
2390 synthetic symbol was derived from. */
2391 s
->udata
.p
= syms
[i
];
2398 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
2399 bfd_byte
*contents
= NULL
;
2401 size_t plt_count
= 0;
2402 bfd_vma glink_vma
= 0, resolv_vma
= 0;
2403 asection
*dynamic
, *glink
= NULL
, *relplt
= NULL
;
2406 if (opd
!= NULL
&& !bfd_malloc_and_get_section (abfd
, opd
, &contents
))
2408 free_contents_and_exit_err
:
2410 free_contents_and_exit
:
2417 for (i
= secsymend
; i
< opdsymend
; ++i
)
2421 /* Ignore bogus symbols. */
2422 if (syms
[i
]->value
> opd
->size
- 8)
2425 ent
= bfd_get_64 (abfd
, contents
+ syms
[i
]->value
);
2426 if (!sym_exists_at (syms
, opdsymend
, symcount
, -1, ent
))
2429 size
+= sizeof (asymbol
);
2430 size
+= strlen (syms
[i
]->name
) + 2;
2434 /* Get start of .glink stubs from DT_PPC64_GLINK. */
2436 && (dynamic
= bfd_get_section_by_name (abfd
, ".dynamic")) != NULL
)
2438 bfd_byte
*dynbuf
, *extdyn
, *extdynend
;
2440 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
2442 if (!bfd_malloc_and_get_section (abfd
, dynamic
, &dynbuf
))
2443 goto free_contents_and_exit_err
;
2445 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
2446 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
2449 extdynend
= extdyn
+ dynamic
->size
;
2450 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
2452 Elf_Internal_Dyn dyn
;
2453 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
2455 if (dyn
.d_tag
== DT_NULL
)
2458 if (dyn
.d_tag
== DT_PPC64_GLINK
)
2460 /* The first glink stub starts at DT_PPC64_GLINK plus 32.
2461 See comment in ppc64_elf_finish_dynamic_sections. */
2462 glink_vma
= dyn
.d_un
.d_val
+ 8 * 4;
2463 /* The .glink section usually does not survive the final
2464 link; search for the section (usually .text) where the
2465 glink stubs now reside. */
2466 glink
= bfd_sections_find_if (abfd
, section_covers_vma
,
2477 /* Determine __glink trampoline by reading the relative branch
2478 from the first glink stub. */
2480 unsigned int off
= 0;
2482 while (bfd_get_section_contents (abfd
, glink
, buf
,
2483 glink_vma
+ off
- glink
->vma
, 4))
2485 unsigned int insn
= bfd_get_32 (abfd
, buf
);
2487 if ((insn
& ~0x3fffffc) == 0)
2490 = glink_vma
+ off
+ (insn
^ 0x2000000) - 0x2000000;
2499 size
+= sizeof (asymbol
) + sizeof ("__glink_PLTresolve");
2501 relplt
= bfd_get_section_by_name (abfd
, ".rela.plt");
2504 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
2505 if (!(*slurp_relocs
) (abfd
, relplt
, dyn_syms
, TRUE
))
2506 goto free_contents_and_exit_err
;
2508 plt_count
= relplt
->size
/ sizeof (Elf64_External_Rela
);
2509 size
+= plt_count
* sizeof (asymbol
);
2511 p
= relplt
->relocation
;
2512 for (i
= 0; i
< plt_count
; i
++, p
++)
2514 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
2516 size
+= sizeof ("+0x") - 1 + 16;
2522 goto free_contents_and_exit
;
2523 s
= *ret
= bfd_malloc (size
);
2525 goto free_contents_and_exit_err
;
2527 names
= (char *) (s
+ count
+ plt_count
+ (resolv_vma
!= 0));
2529 for (i
= secsymend
; i
< opdsymend
; ++i
)
2533 if (syms
[i
]->value
> opd
->size
- 8)
2536 ent
= bfd_get_64 (abfd
, contents
+ syms
[i
]->value
);
2537 if (!sym_exists_at (syms
, opdsymend
, symcount
, -1, ent
))
2541 asection
*sec
= abfd
->sections
;
2548 size_t mid
= (lo
+ hi
) >> 1;
2549 if (syms
[mid
]->section
->vma
< ent
)
2551 else if (syms
[mid
]->section
->vma
> ent
)
2555 sec
= syms
[mid
]->section
;
2560 if (lo
>= hi
&& lo
> codesecsym
)
2561 sec
= syms
[lo
- 1]->section
;
2563 for (; sec
!= NULL
; sec
= sec
->next
)
2567 /* SEC_LOAD may not be set if SEC is from a separate debug
2569 if ((sec
->flags
& SEC_ALLOC
) == 0)
2571 if ((sec
->flags
& SEC_CODE
) != 0)
2574 s
->flags
|= BSF_SYNTHETIC
;
2575 s
->value
= ent
- s
->section
->vma
;
2578 len
= strlen (syms
[i
]->name
);
2579 memcpy (names
, syms
[i
]->name
, len
+ 1);
2581 /* Have udata.p point back to the original symbol this
2582 synthetic symbol was derived from. */
2583 s
->udata
.p
= syms
[i
];
2589 if (glink
!= NULL
&& relplt
!= NULL
)
2593 /* Add a symbol for the main glink trampoline. */
2594 memset (s
, 0, sizeof *s
);
2596 s
->flags
= BSF_GLOBAL
| BSF_SYNTHETIC
;
2598 s
->value
= resolv_vma
- glink
->vma
;
2600 memcpy (names
, "__glink_PLTresolve",
2601 sizeof ("__glink_PLTresolve"));
2602 names
+= sizeof ("__glink_PLTresolve");
2607 /* FIXME: It would be very much nicer to put sym@plt on the
2608 stub rather than on the glink branch table entry. The
2609 objdump disassembler would then use a sensible symbol
2610 name on plt calls. The difficulty in doing so is
2611 a) finding the stubs, and,
2612 b) matching stubs against plt entries, and,
2613 c) there can be multiple stubs for a given plt entry.
2615 Solving (a) could be done by code scanning, but older
2616 ppc64 binaries used different stubs to current code.
2617 (b) is the tricky one since you need to known the toc
2618 pointer for at least one function that uses a pic stub to
2619 be able to calculate the plt address referenced.
2620 (c) means gdb would need to set multiple breakpoints (or
2621 find the glink branch itself) when setting breakpoints
2622 for pending shared library loads. */
2623 p
= relplt
->relocation
;
2624 for (i
= 0; i
< plt_count
; i
++, p
++)
2628 *s
= **p
->sym_ptr_ptr
;
2629 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
2630 we are defining a symbol, ensure one of them is set. */
2631 if ((s
->flags
& BSF_LOCAL
) == 0)
2632 s
->flags
|= BSF_GLOBAL
;
2633 s
->flags
|= BSF_SYNTHETIC
;
2635 s
->value
= glink_vma
- glink
->vma
;
2638 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
2639 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
2643 memcpy (names
, "+0x", sizeof ("+0x") - 1);
2644 names
+= sizeof ("+0x") - 1;
2645 bfd_sprintf_vma (abfd
, names
, p
->addend
);
2646 names
+= strlen (names
);
2648 memcpy (names
, "@plt", sizeof ("@plt"));
2649 names
+= sizeof ("@plt");
2669 /* The following functions are specific to the ELF linker, while
2670 functions above are used generally. Those named ppc64_elf_* are
2671 called by the main ELF linker code. They appear in this file more
2672 or less in the order in which they are called. eg.
2673 ppc64_elf_check_relocs is called early in the link process,
2674 ppc64_elf_finish_dynamic_sections is one of the last functions
2677 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
2678 functions have both a function code symbol and a function descriptor
2679 symbol. A call to foo in a relocatable object file looks like:
2686 The function definition in another object file might be:
2690 . .quad .TOC.@tocbase
2696 When the linker resolves the call during a static link, the branch
2697 unsurprisingly just goes to .foo and the .opd information is unused.
2698 If the function definition is in a shared library, things are a little
2699 different: The call goes via a plt call stub, the opd information gets
2700 copied to the plt, and the linker patches the nop.
2708 . std 2,40(1) # in practice, the call stub
2709 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
2710 . addi 11,11,Lfoo@toc@l # this is the general idea
2718 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
2720 The "reloc ()" notation is supposed to indicate that the linker emits
2721 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
2724 What are the difficulties here? Well, firstly, the relocations
2725 examined by the linker in check_relocs are against the function code
2726 sym .foo, while the dynamic relocation in the plt is emitted against
2727 the function descriptor symbol, foo. Somewhere along the line, we need
2728 to carefully copy dynamic link information from one symbol to the other.
2729 Secondly, the generic part of the elf linker will make .foo a dynamic
2730 symbol as is normal for most other backends. We need foo dynamic
2731 instead, at least for an application final link. However, when
2732 creating a shared library containing foo, we need to have both symbols
2733 dynamic so that references to .foo are satisfied during the early
2734 stages of linking. Otherwise the linker might decide to pull in a
2735 definition from some other object, eg. a static library.
2737 Update: As of August 2004, we support a new convention. Function
2738 calls may use the function descriptor symbol, ie. "bl foo". This
2739 behaves exactly as "bl .foo". */
2741 /* Of those relocs that might be copied as dynamic relocs, this
2742 function selects those that must be copied when linking a shared
2743 library or PIE, even when the symbol is local. */
2746 must_be_dyn_reloc (struct bfd_link_info
*info
,
2747 enum elf_ppc64_reloc_type r_type
)
2752 /* Only relative relocs can be resolved when the object load
2753 address isn't fixed. DTPREL64 is excluded because the
2754 dynamic linker needs to differentiate global dynamic from
2755 local dynamic __tls_index pairs when PPC64_OPT_TLS is set. */
2762 case R_PPC64_TOC16_DS
:
2763 case R_PPC64_TOC16_LO
:
2764 case R_PPC64_TOC16_HI
:
2765 case R_PPC64_TOC16_HA
:
2766 case R_PPC64_TOC16_LO_DS
:
2769 case R_PPC64_TPREL16
:
2770 case R_PPC64_TPREL16_LO
:
2771 case R_PPC64_TPREL16_HI
:
2772 case R_PPC64_TPREL16_HA
:
2773 case R_PPC64_TPREL16_DS
:
2774 case R_PPC64_TPREL16_LO_DS
:
2775 case R_PPC64_TPREL16_HIGH
:
2776 case R_PPC64_TPREL16_HIGHA
:
2777 case R_PPC64_TPREL16_HIGHER
:
2778 case R_PPC64_TPREL16_HIGHERA
:
2779 case R_PPC64_TPREL16_HIGHEST
:
2780 case R_PPC64_TPREL16_HIGHESTA
:
2781 case R_PPC64_TPREL64
:
2782 case R_PPC64_TPREL34
:
2783 /* These relocations are relative but in a shared library the
2784 linker doesn't know the thread pointer base. */
2785 return bfd_link_dll (info
);
2789 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
2790 copying dynamic variables from a shared lib into an app's dynbss
2791 section, and instead use a dynamic relocation to point into the
2792 shared lib. With code that gcc generates, it's vital that this be
2793 enabled; In the PowerPC64 ABI, the address of a function is actually
2794 the address of a function descriptor, which resides in the .opd
2795 section. gcc uses the descriptor directly rather than going via the
2796 GOT as some other ABI's do, which means that initialized function
2797 pointers must reference the descriptor. Thus, a function pointer
2798 initialized to the address of a function in a shared library will
2799 either require a copy reloc, or a dynamic reloc. Using a copy reloc
2800 redefines the function descriptor symbol to point to the copy. This
2801 presents a problem as a plt entry for that function is also
2802 initialized from the function descriptor symbol and the copy reloc
2803 may not be initialized first. */
2804 #define ELIMINATE_COPY_RELOCS 1
2806 /* Section name for stubs is the associated section name plus this
2808 #define STUB_SUFFIX ".stub"
2811 ppc_stub_long_branch:
2812 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
2813 destination, but a 24 bit branch in a stub section will reach.
2816 ppc_stub_plt_branch:
2817 Similar to the above, but a 24 bit branch in the stub section won't
2818 reach its destination.
2819 . addis %r11,%r2,xxx@toc@ha
2820 . ld %r12,xxx@toc@l(%r11)
2825 Used to call a function in a shared library. If it so happens that
2826 the plt entry referenced crosses a 64k boundary, then an extra
2827 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
2828 ppc_stub_plt_call_r2save starts with "std %r2,40(%r1)".
2829 . addis %r11,%r2,xxx@toc@ha
2830 . ld %r12,xxx+0@toc@l(%r11)
2832 . ld %r2,xxx+8@toc@l(%r11)
2833 . ld %r11,xxx+16@toc@l(%r11)
2836 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
2837 code to adjust the value and save r2 to support multiple toc sections.
2838 A ppc_stub_long_branch with an r2 offset looks like:
2840 . addis %r2,%r2,off@ha
2841 . addi %r2,%r2,off@l
2844 A ppc_stub_plt_branch with an r2 offset looks like:
2846 . addis %r11,%r2,xxx@toc@ha
2847 . ld %r12,xxx@toc@l(%r11)
2848 . addis %r2,%r2,off@ha
2849 . addi %r2,%r2,off@l
2853 All of the above stubs are shown as their ELFv1 variants. ELFv2
2854 variants exist too, simpler for plt calls since a new toc pointer
2855 and static chain are not loaded by the stub. In addition, ELFv2
2856 has some more complex stubs to handle calls marked with NOTOC
2857 relocs from functions where r2 is not a valid toc pointer. These
2858 come in two flavours, the ones shown below, and _both variants that
2859 start with "std %r2,24(%r1)" to save r2 in the unlikely event that
2860 one call is from a function where r2 is used as the toc pointer but
2861 needs a toc adjusting stub for small-model multi-toc, and another
2862 call is from a function where r2 is not valid.
2863 ppc_stub_long_branch_notoc:
2869 . addis %r12,%r11,dest-1b@ha
2870 . addi %r12,%r12,dest-1b@l
2873 ppc_stub_plt_branch_notoc:
2879 . lis %r12,xxx-1b@highest
2880 . ori %r12,%r12,xxx-1b@higher
2882 . oris %r12,%r12,xxx-1b@high
2883 . ori %r12,%r12,xxx-1b@l
2884 . add %r12,%r11,%r12
2888 ppc_stub_plt_call_notoc:
2894 . lis %r12,xxx-1b@highest
2895 . ori %r12,%r12,xxx-1b@higher
2897 . oris %r12,%r12,xxx-1b@high
2898 . ori %r12,%r12,xxx-1b@l
2899 . ldx %r12,%r11,%r12
2903 There are also ELFv1 powerxx variants of these stubs.
2904 ppc_stub_long_branch_notoc:
2905 . pla %r12,dest@pcrel
2907 ppc_stub_plt_branch_notoc:
2908 . lis %r11,(dest-1f)@highesta34
2909 . ori %r11,%r11,(dest-1f)@highera34
2911 . 1: pla %r12,dest@pcrel
2912 . add %r12,%r11,%r12
2915 ppc_stub_plt_call_notoc:
2916 . lis %r11,(xxx-1f)@highesta34
2917 . ori %r11,%r11,(xxx-1f)@highera34
2919 . 1: pla %r12,xxx@pcrel
2920 . ldx %r12,%r11,%r12
2924 In cases where the high instructions would add zero, they are
2925 omitted and following instructions modified in some cases.
2926 For example, a powerxx ppc_stub_plt_call_notoc might simplify down
2928 . pld %r12,xxx@pcrel
2932 For a given stub group (a set of sections all using the same toc
2933 pointer value) there will be just one stub type used for any
2934 particular function symbol. For example, if printf is called from
2935 code with the tocsave optimization (ie. r2 saved in function
2936 prologue) and therefore calls use a ppc_stub_plt_call linkage stub,
2937 and from other code without the tocsave optimization requiring a
2938 ppc_stub_plt_call_r2save linkage stub, a single stub of the latter
2939 type will be created. Calls with the tocsave optimization will
2940 enter this stub after the instruction saving r2. A similar
2941 situation exists when calls are marked with R_PPC64_REL24_NOTOC
2942 relocations. These require a ppc_stub_plt_call_notoc linkage stub
2943 to call an external function like printf. If other calls to printf
2944 require a ppc_stub_plt_call linkage stub then a single
2945 ppc_stub_plt_call_notoc linkage stub will be used for both types of
2946 call. If other calls to printf require a ppc_stub_plt_call_r2save
2947 linkage stub then a single ppc_stub_plt_call_both linkage stub will
2948 be created and calls not requiring r2 to be saved will enter the
2949 stub after the r2 save instruction. There is an analogous
2950 hierarchy of long branch and plt branch stubs for local call
2956 ppc_stub_long_branch
,
2957 ppc_stub_long_branch_r2off
,
2958 ppc_stub_long_branch_notoc
,
2959 ppc_stub_long_branch_both
, /* r2off and notoc variants both needed. */
2960 ppc_stub_plt_branch
,
2961 ppc_stub_plt_branch_r2off
,
2962 ppc_stub_plt_branch_notoc
,
2963 ppc_stub_plt_branch_both
,
2965 ppc_stub_plt_call_r2save
,
2966 ppc_stub_plt_call_notoc
,
2967 ppc_stub_plt_call_both
,
2968 ppc_stub_global_entry
,
2972 /* Information on stub grouping. */
2975 /* The stub section. */
2977 /* This is the section to which stubs in the group will be attached. */
2980 struct map_stub
*next
;
2981 /* Whether to emit a copy of register save/restore functions in this
2984 /* Current offset within stubs after the insn restoring lr in a
2985 _notoc or _both stub using bcl for pc-relative addressing, or
2986 after the insn restoring lr in a __tls_get_addr_opt plt stub. */
2987 unsigned int lr_restore
;
2988 /* Accumulated size of EH info emitted to describe return address
2989 if stubs modify lr. Does not include 17 byte FDE header. */
2990 unsigned int eh_size
;
2991 /* Offset in glink_eh_frame to the start of EH info for this group. */
2992 unsigned int eh_base
;
2995 struct ppc_stub_hash_entry
2997 /* Base hash table entry structure. */
2998 struct bfd_hash_entry root
;
3000 enum ppc_stub_type stub_type
;
3002 /* Group information. */
3003 struct map_stub
*group
;
3005 /* Offset within stub_sec of the beginning of this stub. */
3006 bfd_vma stub_offset
;
3008 /* Given the symbol's value and its section we can determine its final
3009 value when building the stubs (so the stub knows where to jump. */
3010 bfd_vma target_value
;
3011 asection
*target_section
;
3013 /* The symbol table entry, if any, that this was derived from. */
3014 struct ppc_link_hash_entry
*h
;
3015 struct plt_entry
*plt_ent
;
3018 unsigned char symtype
;
3020 /* Symbol st_other. */
3021 unsigned char other
;
3024 struct ppc_branch_hash_entry
3026 /* Base hash table entry structure. */
3027 struct bfd_hash_entry root
;
3029 /* Offset within branch lookup table. */
3030 unsigned int offset
;
3032 /* Generation marker. */
3036 /* Used to track dynamic relocations for local symbols. */
3037 struct ppc_dyn_relocs
3039 struct ppc_dyn_relocs
*next
;
3041 /* The input section of the reloc. */
3044 /* Total number of relocs copied for the input section. */
3045 unsigned int count
: 31;
3047 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3048 unsigned int ifunc
: 1;
3051 struct ppc_link_hash_entry
3053 struct elf_link_hash_entry elf
;
3057 /* A pointer to the most recently used stub hash entry against this
3059 struct ppc_stub_hash_entry
*stub_cache
;
3061 /* A pointer to the next symbol starting with a '.' */
3062 struct ppc_link_hash_entry
*next_dot_sym
;
3065 /* Track dynamic relocs copied for this symbol. */
3066 struct elf_dyn_relocs
*dyn_relocs
;
3068 /* Link between function code and descriptor symbols. */
3069 struct ppc_link_hash_entry
*oh
;
3071 /* Flag function code and descriptor symbols. */
3072 unsigned int is_func
:1;
3073 unsigned int is_func_descriptor
:1;
3074 unsigned int fake
:1;
3076 /* Whether global opd/toc sym has been adjusted or not.
3077 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3078 should be set for all globals defined in any opd/toc section. */
3079 unsigned int adjust_done
:1;
3081 /* Set if this is an out-of-line register save/restore function,
3082 with non-standard calling convention. */
3083 unsigned int save_res
:1;
3085 /* Set if a duplicate symbol with non-zero localentry is detected,
3086 even when the duplicate symbol does not provide a definition. */
3087 unsigned int non_zero_localentry
:1;
3089 /* Contexts in which symbol is used in the GOT (or TOC).
3090 Bits are or'd into the mask as the corresponding relocs are
3091 encountered during check_relocs, with TLS_TLS being set when any
3092 of the other TLS bits are set. tls_optimize clears bits when
3093 optimizing to indicate the corresponding GOT entry type is not
3094 needed. If set, TLS_TLS is never cleared. tls_optimize may also
3095 set TLS_GDIE when a GD reloc turns into an IE one.
3096 These flags are also kept for local symbols. */
3097 #define TLS_TLS 1 /* Any TLS reloc. */
3098 #define TLS_GD 2 /* GD reloc. */
3099 #define TLS_LD 4 /* LD reloc. */
3100 #define TLS_TPREL 8 /* TPREL reloc, => IE. */
3101 #define TLS_DTPREL 16 /* DTPREL reloc, => LD. */
3102 #define TLS_MARK 32 /* __tls_get_addr call marked. */
3103 #define TLS_GDIE 64 /* GOT TPREL reloc resulting from GD->IE. */
3104 #define TLS_EXPLICIT 256 /* TOC section TLS reloc, not stored. */
3105 unsigned char tls_mask
;
3107 /* The above field is also used to mark function symbols. In which
3108 case TLS_TLS will be 0. */
3109 #define PLT_IFUNC 2 /* STT_GNU_IFUNC. */
3110 #define PLT_KEEP 4 /* inline plt call requires plt entry. */
3111 #define NON_GOT 256 /* local symbol plt, not stored. */
3114 /* ppc64 ELF linker hash table. */
3116 struct ppc_link_hash_table
3118 struct elf_link_hash_table elf
;
3120 /* The stub hash table. */
3121 struct bfd_hash_table stub_hash_table
;
3123 /* Another hash table for plt_branch stubs. */
3124 struct bfd_hash_table branch_hash_table
;
3126 /* Hash table for function prologue tocsave. */
3127 htab_t tocsave_htab
;
3129 /* Various options and other info passed from the linker. */
3130 struct ppc64_elf_params
*params
;
3132 /* The size of sec_info below. */
3133 unsigned int sec_info_arr_size
;
3135 /* Per-section array of extra section info. Done this way rather
3136 than as part of ppc64_elf_section_data so we have the info for
3137 non-ppc64 sections. */
3140 /* Along with elf_gp, specifies the TOC pointer used by this section. */
3145 /* The section group that this section belongs to. */
3146 struct map_stub
*group
;
3147 /* A temp section list pointer. */
3152 /* Linked list of groups. */
3153 struct map_stub
*group
;
3155 /* Temp used when calculating TOC pointers. */
3158 asection
*toc_first_sec
;
3160 /* Used when adding symbols. */
3161 struct ppc_link_hash_entry
*dot_syms
;
3163 /* Shortcuts to get to dynamic linker sections. */
3165 asection
*global_entry
;
3168 asection
*relpltlocal
;
3171 asection
*glink_eh_frame
;
3173 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
3174 struct ppc_link_hash_entry
*tls_get_addr
;
3175 struct ppc_link_hash_entry
*tls_get_addr_fd
;
3177 /* The size of reliplt used by got entry relocs. */
3178 bfd_size_type got_reli_size
;
3181 unsigned long stub_count
[ppc_stub_global_entry
];
3183 /* Number of stubs against global syms. */
3184 unsigned long stub_globals
;
3186 /* Set if we're linking code with function descriptors. */
3187 unsigned int opd_abi
:1;
3189 /* Support for multiple toc sections. */
3190 unsigned int do_multi_toc
:1;
3191 unsigned int multi_toc_needed
:1;
3192 unsigned int second_toc_pass
:1;
3193 unsigned int do_toc_opt
:1;
3195 /* Set if tls optimization is enabled. */
3196 unsigned int do_tls_opt
:1;
3198 /* Set if inline plt calls should be converted to direct calls. */
3199 unsigned int can_convert_all_inline_plt
:1;
3202 unsigned int stub_error
:1;
3204 /* Whether func_desc_adjust needs to be run over symbols. */
3205 unsigned int need_func_desc_adj
:1;
3207 /* Whether there exist local gnu indirect function resolvers,
3208 referenced by dynamic relocations. */
3209 unsigned int local_ifunc_resolver
:1;
3210 unsigned int maybe_local_ifunc_resolver
:1;
3212 /* Whether plt calls for ELFv2 localentry:0 funcs have been optimized. */
3213 unsigned int has_plt_localentry0
:1;
3215 /* Whether calls are made via the PLT from NOTOC functions. */
3216 unsigned int notoc_plt
:1;
3218 /* Whether to use powerxx instructions in linkage stubs. */
3219 unsigned int powerxx_stubs
:1;
3221 /* Incremented every time we size stubs. */
3222 unsigned int stub_iteration
;
3224 /* Small local sym cache. */
3225 struct sym_cache sym_cache
;
3228 /* Rename some of the generic section flags to better document how they
3231 /* Nonzero if this section has TLS related relocations. */
3232 #define has_tls_reloc sec_flg0
3234 /* Nonzero if this section has a call to __tls_get_addr lacking marker
3236 #define nomark_tls_get_addr sec_flg1
3238 /* Nonzero if this section has any toc or got relocs. */
3239 #define has_toc_reloc sec_flg2
3241 /* Nonzero if this section has a call to another section that uses
3243 #define makes_toc_func_call sec_flg3
3245 /* Recursion protection when determining above flag. */
3246 #define call_check_in_progress sec_flg4
3247 #define call_check_done sec_flg5
3249 /* Get the ppc64 ELF linker hash table from a link_info structure. */
3251 #define ppc_hash_table(p) \
3252 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3253 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3255 #define ppc_stub_hash_lookup(table, string, create, copy) \
3256 ((struct ppc_stub_hash_entry *) \
3257 bfd_hash_lookup ((table), (string), (create), (copy)))
3259 #define ppc_branch_hash_lookup(table, string, create, copy) \
3260 ((struct ppc_branch_hash_entry *) \
3261 bfd_hash_lookup ((table), (string), (create), (copy)))
3263 /* Create an entry in the stub hash table. */
3265 static struct bfd_hash_entry
*
3266 stub_hash_newfunc (struct bfd_hash_entry
*entry
,
3267 struct bfd_hash_table
*table
,
3270 /* Allocate the structure if it has not already been allocated by a
3274 entry
= bfd_hash_allocate (table
, sizeof (struct ppc_stub_hash_entry
));
3279 /* Call the allocation method of the superclass. */
3280 entry
= bfd_hash_newfunc (entry
, table
, string
);
3283 struct ppc_stub_hash_entry
*eh
;
3285 /* Initialize the local fields. */
3286 eh
= (struct ppc_stub_hash_entry
*) entry
;
3287 eh
->stub_type
= ppc_stub_none
;
3289 eh
->stub_offset
= 0;
3290 eh
->target_value
= 0;
3291 eh
->target_section
= NULL
;
3300 /* Create an entry in the branch hash table. */
3302 static struct bfd_hash_entry
*
3303 branch_hash_newfunc (struct bfd_hash_entry
*entry
,
3304 struct bfd_hash_table
*table
,
3307 /* Allocate the structure if it has not already been allocated by a
3311 entry
= bfd_hash_allocate (table
, sizeof (struct ppc_branch_hash_entry
));
3316 /* Call the allocation method of the superclass. */
3317 entry
= bfd_hash_newfunc (entry
, table
, string
);
3320 struct ppc_branch_hash_entry
*eh
;
3322 /* Initialize the local fields. */
3323 eh
= (struct ppc_branch_hash_entry
*) entry
;
3331 /* Create an entry in a ppc64 ELF linker hash table. */
3333 static struct bfd_hash_entry
*
3334 link_hash_newfunc (struct bfd_hash_entry
*entry
,
3335 struct bfd_hash_table
*table
,
3338 /* Allocate the structure if it has not already been allocated by a
3342 entry
= bfd_hash_allocate (table
, sizeof (struct ppc_link_hash_entry
));
3347 /* Call the allocation method of the superclass. */
3348 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
3351 struct ppc_link_hash_entry
*eh
= (struct ppc_link_hash_entry
*) entry
;
3353 memset (&eh
->u
.stub_cache
, 0,
3354 (sizeof (struct ppc_link_hash_entry
)
3355 - offsetof (struct ppc_link_hash_entry
, u
.stub_cache
)));
3357 /* When making function calls, old ABI code references function entry
3358 points (dot symbols), while new ABI code references the function
3359 descriptor symbol. We need to make any combination of reference and
3360 definition work together, without breaking archive linking.
3362 For a defined function "foo" and an undefined call to "bar":
3363 An old object defines "foo" and ".foo", references ".bar" (possibly
3365 A new object defines "foo" and references "bar".
3367 A new object thus has no problem with its undefined symbols being
3368 satisfied by definitions in an old object. On the other hand, the
3369 old object won't have ".bar" satisfied by a new object.
3371 Keep a list of newly added dot-symbols. */
3373 if (string
[0] == '.')
3375 struct ppc_link_hash_table
*htab
;
3377 htab
= (struct ppc_link_hash_table
*) table
;
3378 eh
->u
.next_dot_sym
= htab
->dot_syms
;
3379 htab
->dot_syms
= eh
;
3386 struct tocsave_entry
3393 tocsave_htab_hash (const void *p
)
3395 const struct tocsave_entry
*e
= (const struct tocsave_entry
*) p
;
3396 return ((bfd_vma
) (intptr_t) e
->sec
^ e
->offset
) >> 3;
3400 tocsave_htab_eq (const void *p1
, const void *p2
)
3402 const struct tocsave_entry
*e1
= (const struct tocsave_entry
*) p1
;
3403 const struct tocsave_entry
*e2
= (const struct tocsave_entry
*) p2
;
3404 return e1
->sec
== e2
->sec
&& e1
->offset
== e2
->offset
;
3407 /* Destroy a ppc64 ELF linker hash table. */
3410 ppc64_elf_link_hash_table_free (bfd
*obfd
)
3412 struct ppc_link_hash_table
*htab
;
3414 htab
= (struct ppc_link_hash_table
*) obfd
->link
.hash
;
3415 if (htab
->tocsave_htab
)
3416 htab_delete (htab
->tocsave_htab
);
3417 bfd_hash_table_free (&htab
->branch_hash_table
);
3418 bfd_hash_table_free (&htab
->stub_hash_table
);
3419 _bfd_elf_link_hash_table_free (obfd
);
3422 /* Create a ppc64 ELF linker hash table. */
3424 static struct bfd_link_hash_table
*
3425 ppc64_elf_link_hash_table_create (bfd
*abfd
)
3427 struct ppc_link_hash_table
*htab
;
3428 bfd_size_type amt
= sizeof (struct ppc_link_hash_table
);
3430 htab
= bfd_zmalloc (amt
);
3434 if (!_bfd_elf_link_hash_table_init (&htab
->elf
, abfd
, link_hash_newfunc
,
3435 sizeof (struct ppc_link_hash_entry
),
3442 /* Init the stub hash table too. */
3443 if (!bfd_hash_table_init (&htab
->stub_hash_table
, stub_hash_newfunc
,
3444 sizeof (struct ppc_stub_hash_entry
)))
3446 _bfd_elf_link_hash_table_free (abfd
);
3450 /* And the branch hash table. */
3451 if (!bfd_hash_table_init (&htab
->branch_hash_table
, branch_hash_newfunc
,
3452 sizeof (struct ppc_branch_hash_entry
)))
3454 bfd_hash_table_free (&htab
->stub_hash_table
);
3455 _bfd_elf_link_hash_table_free (abfd
);
3459 htab
->tocsave_htab
= htab_try_create (1024,
3463 if (htab
->tocsave_htab
== NULL
)
3465 ppc64_elf_link_hash_table_free (abfd
);
3468 htab
->elf
.root
.hash_table_free
= ppc64_elf_link_hash_table_free
;
3470 /* Initializing two fields of the union is just cosmetic. We really
3471 only care about glist, but when compiled on a 32-bit host the
3472 bfd_vma fields are larger. Setting the bfd_vma to zero makes
3473 debugger inspection of these fields look nicer. */
3474 htab
->elf
.init_got_refcount
.refcount
= 0;
3475 htab
->elf
.init_got_refcount
.glist
= NULL
;
3476 htab
->elf
.init_plt_refcount
.refcount
= 0;
3477 htab
->elf
.init_plt_refcount
.glist
= NULL
;
3478 htab
->elf
.init_got_offset
.offset
= 0;
3479 htab
->elf
.init_got_offset
.glist
= NULL
;
3480 htab
->elf
.init_plt_offset
.offset
= 0;
3481 htab
->elf
.init_plt_offset
.glist
= NULL
;
3483 return &htab
->elf
.root
;
3486 /* Create sections for linker generated code. */
3489 create_linkage_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
3491 struct ppc_link_hash_table
*htab
;
3494 htab
= ppc_hash_table (info
);
3496 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_READONLY
3497 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3498 if (htab
->params
->save_restore_funcs
)
3500 /* Create .sfpr for code to save and restore fp regs. */
3501 htab
->sfpr
= bfd_make_section_anyway_with_flags (dynobj
, ".sfpr",
3503 if (htab
->sfpr
== NULL
3504 || !bfd_set_section_alignment (htab
->sfpr
, 2))
3508 if (bfd_link_relocatable (info
))
3511 /* Create .glink for lazy dynamic linking support. */
3512 htab
->glink
= bfd_make_section_anyway_with_flags (dynobj
, ".glink",
3514 if (htab
->glink
== NULL
3515 || !bfd_set_section_alignment (htab
->glink
, 3))
3518 /* The part of .glink used by global entry stubs, separate so that
3519 it can be aligned appropriately without affecting htab->glink. */
3520 htab
->global_entry
= bfd_make_section_anyway_with_flags (dynobj
, ".glink",
3522 if (htab
->global_entry
== NULL
3523 || !bfd_set_section_alignment (htab
->global_entry
, 2))
3526 if (!info
->no_ld_generated_unwind_info
)
3528 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_HAS_CONTENTS
3529 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3530 htab
->glink_eh_frame
= bfd_make_section_anyway_with_flags (dynobj
,
3533 if (htab
->glink_eh_frame
== NULL
3534 || !bfd_set_section_alignment (htab
->glink_eh_frame
, 2))
3538 flags
= SEC_ALLOC
| SEC_LINKER_CREATED
;
3539 htab
->elf
.iplt
= bfd_make_section_anyway_with_flags (dynobj
, ".iplt", flags
);
3540 if (htab
->elf
.iplt
== NULL
3541 || !bfd_set_section_alignment (htab
->elf
.iplt
, 3))
3544 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
3545 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3547 = bfd_make_section_anyway_with_flags (dynobj
, ".rela.iplt", flags
);
3548 if (htab
->elf
.irelplt
== NULL
3549 || !bfd_set_section_alignment (htab
->elf
.irelplt
, 3))
3552 /* Create branch lookup table for plt_branch stubs. */
3553 flags
= (SEC_ALLOC
| SEC_LOAD
3554 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3555 htab
->brlt
= bfd_make_section_anyway_with_flags (dynobj
, ".branch_lt",
3557 if (htab
->brlt
== NULL
3558 || !bfd_set_section_alignment (htab
->brlt
, 3))
3561 /* Local plt entries, put in .branch_lt but a separate section for
3563 htab
->pltlocal
= bfd_make_section_anyway_with_flags (dynobj
, ".branch_lt",
3565 if (htab
->pltlocal
== NULL
3566 || !bfd_set_section_alignment (htab
->pltlocal
, 3))
3569 if (!bfd_link_pic (info
))
3572 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
3573 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3575 = bfd_make_section_anyway_with_flags (dynobj
, ".rela.branch_lt", flags
);
3576 if (htab
->relbrlt
== NULL
3577 || !bfd_set_section_alignment (htab
->relbrlt
, 3))
3581 = bfd_make_section_anyway_with_flags (dynobj
, ".rela.branch_lt", flags
);
3582 if (htab
->relpltlocal
== NULL
3583 || !bfd_set_section_alignment (htab
->relpltlocal
, 3))
3589 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
3592 ppc64_elf_init_stub_bfd (struct bfd_link_info
*info
,
3593 struct ppc64_elf_params
*params
)
3595 struct ppc_link_hash_table
*htab
;
3597 elf_elfheader (params
->stub_bfd
)->e_ident
[EI_CLASS
] = ELFCLASS64
;
3599 /* Always hook our dynamic sections into the first bfd, which is the
3600 linker created stub bfd. This ensures that the GOT header is at
3601 the start of the output TOC section. */
3602 htab
= ppc_hash_table (info
);
3603 htab
->elf
.dynobj
= params
->stub_bfd
;
3604 htab
->params
= params
;
3606 return create_linkage_sections (htab
->elf
.dynobj
, info
);
3609 /* Build a name for an entry in the stub hash table. */
3612 ppc_stub_name (const asection
*input_section
,
3613 const asection
*sym_sec
,
3614 const struct ppc_link_hash_entry
*h
,
3615 const Elf_Internal_Rela
*rel
)
3620 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
3621 offsets from a sym as a branch target? In fact, we could
3622 probably assume the addend is always zero. */
3623 BFD_ASSERT (((int) rel
->r_addend
& 0xffffffff) == rel
->r_addend
);
3627 len
= 8 + 1 + strlen (h
->elf
.root
.root
.string
) + 1 + 8 + 1;
3628 stub_name
= bfd_malloc (len
);
3629 if (stub_name
== NULL
)
3632 len
= sprintf (stub_name
, "%08x.%s+%x",
3633 input_section
->id
& 0xffffffff,
3634 h
->elf
.root
.root
.string
,
3635 (int) rel
->r_addend
& 0xffffffff);
3639 len
= 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
3640 stub_name
= bfd_malloc (len
);
3641 if (stub_name
== NULL
)
3644 len
= sprintf (stub_name
, "%08x.%x:%x+%x",
3645 input_section
->id
& 0xffffffff,
3646 sym_sec
->id
& 0xffffffff,
3647 (int) ELF64_R_SYM (rel
->r_info
) & 0xffffffff,
3648 (int) rel
->r_addend
& 0xffffffff);
3650 if (len
> 2 && stub_name
[len
- 2] == '+' && stub_name
[len
- 1] == '0')
3651 stub_name
[len
- 2] = 0;
3655 /* Look up an entry in the stub hash. Stub entries are cached because
3656 creating the stub name takes a bit of time. */
3658 static struct ppc_stub_hash_entry
*
3659 ppc_get_stub_entry (const asection
*input_section
,
3660 const asection
*sym_sec
,
3661 struct ppc_link_hash_entry
*h
,
3662 const Elf_Internal_Rela
*rel
,
3663 struct ppc_link_hash_table
*htab
)
3665 struct ppc_stub_hash_entry
*stub_entry
;
3666 struct map_stub
*group
;
3668 /* If this input section is part of a group of sections sharing one
3669 stub section, then use the id of the first section in the group.
3670 Stub names need to include a section id, as there may well be
3671 more than one stub used to reach say, printf, and we need to
3672 distinguish between them. */
3673 group
= htab
->sec_info
[input_section
->id
].u
.group
;
3677 if (h
!= NULL
&& h
->u
.stub_cache
!= NULL
3678 && h
->u
.stub_cache
->h
== h
3679 && h
->u
.stub_cache
->group
== group
)
3681 stub_entry
= h
->u
.stub_cache
;
3687 stub_name
= ppc_stub_name (group
->link_sec
, sym_sec
, h
, rel
);
3688 if (stub_name
== NULL
)
3691 stub_entry
= ppc_stub_hash_lookup (&htab
->stub_hash_table
,
3692 stub_name
, FALSE
, FALSE
);
3694 h
->u
.stub_cache
= stub_entry
;
3702 /* Add a new stub entry to the stub hash. Not all fields of the new
3703 stub entry are initialised. */
3705 static struct ppc_stub_hash_entry
*
3706 ppc_add_stub (const char *stub_name
,
3708 struct bfd_link_info
*info
)
3710 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
3711 struct map_stub
*group
;
3714 struct ppc_stub_hash_entry
*stub_entry
;
3716 group
= htab
->sec_info
[section
->id
].u
.group
;
3717 link_sec
= group
->link_sec
;
3718 stub_sec
= group
->stub_sec
;
3719 if (stub_sec
== NULL
)
3725 namelen
= strlen (link_sec
->name
);
3726 len
= namelen
+ sizeof (STUB_SUFFIX
);
3727 s_name
= bfd_alloc (htab
->params
->stub_bfd
, len
);
3731 memcpy (s_name
, link_sec
->name
, namelen
);
3732 memcpy (s_name
+ namelen
, STUB_SUFFIX
, sizeof (STUB_SUFFIX
));
3733 stub_sec
= (*htab
->params
->add_stub_section
) (s_name
, link_sec
);
3734 if (stub_sec
== NULL
)
3736 group
->stub_sec
= stub_sec
;
3739 /* Enter this entry into the linker stub hash table. */
3740 stub_entry
= ppc_stub_hash_lookup (&htab
->stub_hash_table
, stub_name
,
3742 if (stub_entry
== NULL
)
3744 /* xgettext:c-format */
3745 _bfd_error_handler (_("%pB: cannot create stub entry %s"),
3746 section
->owner
, stub_name
);
3750 stub_entry
->group
= group
;
3751 stub_entry
->stub_offset
= 0;
3755 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
3756 not already done. */
3759 create_got_section (bfd
*abfd
, struct bfd_link_info
*info
)
3761 asection
*got
, *relgot
;
3763 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
3765 if (!is_ppc64_elf (abfd
))
3771 && !_bfd_elf_create_got_section (htab
->elf
.dynobj
, info
))
3774 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
3775 | SEC_LINKER_CREATED
);
3777 got
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
3779 || !bfd_set_section_alignment (got
, 3))
3782 relgot
= bfd_make_section_anyway_with_flags (abfd
, ".rela.got",
3783 flags
| SEC_READONLY
);
3785 || !bfd_set_section_alignment (relgot
, 3))
3788 ppc64_elf_tdata (abfd
)->got
= got
;
3789 ppc64_elf_tdata (abfd
)->relgot
= relgot
;
3793 /* Follow indirect and warning symbol links. */
3795 static inline struct bfd_link_hash_entry
*
3796 follow_link (struct bfd_link_hash_entry
*h
)
3798 while (h
->type
== bfd_link_hash_indirect
3799 || h
->type
== bfd_link_hash_warning
)
3804 static inline struct elf_link_hash_entry
*
3805 elf_follow_link (struct elf_link_hash_entry
*h
)
3807 return (struct elf_link_hash_entry
*) follow_link (&h
->root
);
3810 static inline struct ppc_link_hash_entry
*
3811 ppc_follow_link (struct ppc_link_hash_entry
*h
)
3813 return (struct ppc_link_hash_entry
*) follow_link (&h
->elf
.root
);
3816 /* Merge PLT info on FROM with that on TO. */
3819 move_plt_plist (struct ppc_link_hash_entry
*from
,
3820 struct ppc_link_hash_entry
*to
)
3822 if (from
->elf
.plt
.plist
!= NULL
)
3824 if (to
->elf
.plt
.plist
!= NULL
)
3826 struct plt_entry
**entp
;
3827 struct plt_entry
*ent
;
3829 for (entp
= &from
->elf
.plt
.plist
; (ent
= *entp
) != NULL
; )
3831 struct plt_entry
*dent
;
3833 for (dent
= to
->elf
.plt
.plist
; dent
!= NULL
; dent
= dent
->next
)
3834 if (dent
->addend
== ent
->addend
)
3836 dent
->plt
.refcount
+= ent
->plt
.refcount
;
3843 *entp
= to
->elf
.plt
.plist
;
3846 to
->elf
.plt
.plist
= from
->elf
.plt
.plist
;
3847 from
->elf
.plt
.plist
= NULL
;
3851 /* Copy the extra info we tack onto an elf_link_hash_entry. */
3854 ppc64_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
3855 struct elf_link_hash_entry
*dir
,
3856 struct elf_link_hash_entry
*ind
)
3858 struct ppc_link_hash_entry
*edir
, *eind
;
3860 edir
= (struct ppc_link_hash_entry
*) dir
;
3861 eind
= (struct ppc_link_hash_entry
*) ind
;
3863 edir
->is_func
|= eind
->is_func
;
3864 edir
->is_func_descriptor
|= eind
->is_func_descriptor
;
3865 edir
->tls_mask
|= eind
->tls_mask
;
3866 if (eind
->oh
!= NULL
)
3867 edir
->oh
= ppc_follow_link (eind
->oh
);
3869 if (edir
->elf
.versioned
!= versioned_hidden
)
3870 edir
->elf
.ref_dynamic
|= eind
->elf
.ref_dynamic
;
3871 edir
->elf
.ref_regular
|= eind
->elf
.ref_regular
;
3872 edir
->elf
.ref_regular_nonweak
|= eind
->elf
.ref_regular_nonweak
;
3873 edir
->elf
.non_got_ref
|= eind
->elf
.non_got_ref
;
3874 edir
->elf
.needs_plt
|= eind
->elf
.needs_plt
;
3875 edir
->elf
.pointer_equality_needed
|= eind
->elf
.pointer_equality_needed
;
3877 /* If we were called to copy over info for a weak sym, don't copy
3878 dyn_relocs, plt/got info, or dynindx. We used to copy dyn_relocs
3879 in order to simplify readonly_dynrelocs and save a field in the
3880 symbol hash entry, but that means dyn_relocs can't be used in any
3881 tests about a specific symbol, or affect other symbol flags which
3883 if (eind
->elf
.root
.type
!= bfd_link_hash_indirect
)
3886 /* Copy over any dynamic relocs we may have on the indirect sym. */
3887 if (eind
->dyn_relocs
!= NULL
)
3889 if (edir
->dyn_relocs
!= NULL
)
3891 struct elf_dyn_relocs
**pp
;
3892 struct elf_dyn_relocs
*p
;
3894 /* Add reloc counts against the indirect sym to the direct sym
3895 list. Merge any entries against the same section. */
3896 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
3898 struct elf_dyn_relocs
*q
;
3900 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
3901 if (q
->sec
== p
->sec
)
3903 q
->pc_count
+= p
->pc_count
;
3904 q
->count
+= p
->count
;
3911 *pp
= edir
->dyn_relocs
;
3914 edir
->dyn_relocs
= eind
->dyn_relocs
;
3915 eind
->dyn_relocs
= NULL
;
3918 /* Copy over got entries that we may have already seen to the
3919 symbol which just became indirect. */
3920 if (eind
->elf
.got
.glist
!= NULL
)
3922 if (edir
->elf
.got
.glist
!= NULL
)
3924 struct got_entry
**entp
;
3925 struct got_entry
*ent
;
3927 for (entp
= &eind
->elf
.got
.glist
; (ent
= *entp
) != NULL
; )
3929 struct got_entry
*dent
;
3931 for (dent
= edir
->elf
.got
.glist
; dent
!= NULL
; dent
= dent
->next
)
3932 if (dent
->addend
== ent
->addend
3933 && dent
->owner
== ent
->owner
3934 && dent
->tls_type
== ent
->tls_type
)
3936 dent
->got
.refcount
+= ent
->got
.refcount
;
3943 *entp
= edir
->elf
.got
.glist
;
3946 edir
->elf
.got
.glist
= eind
->elf
.got
.glist
;
3947 eind
->elf
.got
.glist
= NULL
;
3950 /* And plt entries. */
3951 move_plt_plist (eind
, edir
);
3953 if (eind
->elf
.dynindx
!= -1)
3955 if (edir
->elf
.dynindx
!= -1)
3956 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
3957 edir
->elf
.dynstr_index
);
3958 edir
->elf
.dynindx
= eind
->elf
.dynindx
;
3959 edir
->elf
.dynstr_index
= eind
->elf
.dynstr_index
;
3960 eind
->elf
.dynindx
= -1;
3961 eind
->elf
.dynstr_index
= 0;
3965 /* Find the function descriptor hash entry from the given function code
3966 hash entry FH. Link the entries via their OH fields. */
3968 static struct ppc_link_hash_entry
*
3969 lookup_fdh (struct ppc_link_hash_entry
*fh
, struct ppc_link_hash_table
*htab
)
3971 struct ppc_link_hash_entry
*fdh
= fh
->oh
;
3975 const char *fd_name
= fh
->elf
.root
.root
.string
+ 1;
3977 fdh
= (struct ppc_link_hash_entry
*)
3978 elf_link_hash_lookup (&htab
->elf
, fd_name
, FALSE
, FALSE
, FALSE
);
3982 fdh
->is_func_descriptor
= 1;
3988 fdh
= ppc_follow_link (fdh
);
3989 fdh
->is_func_descriptor
= 1;
3994 /* Make a fake function descriptor sym for the undefined code sym FH. */
3996 static struct ppc_link_hash_entry
*
3997 make_fdh (struct bfd_link_info
*info
,
3998 struct ppc_link_hash_entry
*fh
)
4000 bfd
*abfd
= fh
->elf
.root
.u
.undef
.abfd
;
4001 struct bfd_link_hash_entry
*bh
= NULL
;
4002 struct ppc_link_hash_entry
*fdh
;
4003 flagword flags
= (fh
->elf
.root
.type
== bfd_link_hash_undefweak
4007 if (!_bfd_generic_link_add_one_symbol (info
, abfd
,
4008 fh
->elf
.root
.root
.string
+ 1,
4009 flags
, bfd_und_section_ptr
, 0,
4010 NULL
, FALSE
, FALSE
, &bh
))
4013 fdh
= (struct ppc_link_hash_entry
*) bh
;
4014 fdh
->elf
.non_elf
= 0;
4016 fdh
->is_func_descriptor
= 1;
4023 /* Fix function descriptor symbols defined in .opd sections to be
4027 ppc64_elf_add_symbol_hook (bfd
*ibfd
,
4028 struct bfd_link_info
*info
,
4029 Elf_Internal_Sym
*isym
,
4031 flagword
*flags ATTRIBUTE_UNUSED
,
4036 && strcmp ((*sec
)->name
, ".opd") == 0)
4040 if (!(ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
4041 || ELF_ST_TYPE (isym
->st_info
) == STT_FUNC
))
4042 isym
->st_info
= ELF_ST_INFO (ELF_ST_BIND (isym
->st_info
), STT_FUNC
);
4044 /* If the symbol is a function defined in .opd, and the function
4045 code is in a discarded group, let it appear to be undefined. */
4046 if (!bfd_link_relocatable (info
)
4047 && (*sec
)->reloc_count
!= 0
4048 && opd_entry_value (*sec
, *value
, &code_sec
, NULL
,
4049 FALSE
) != (bfd_vma
) -1
4050 && discarded_section (code_sec
))
4052 *sec
= bfd_und_section_ptr
;
4053 isym
->st_shndx
= SHN_UNDEF
;
4056 else if (*sec
!= NULL
4057 && strcmp ((*sec
)->name
, ".toc") == 0
4058 && ELF_ST_TYPE (isym
->st_info
) == STT_OBJECT
)
4060 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
4062 htab
->params
->object_in_toc
= 1;
4065 if ((STO_PPC64_LOCAL_MASK
& isym
->st_other
) != 0)
4067 if (abiversion (ibfd
) == 0)
4068 set_abiversion (ibfd
, 2);
4069 else if (abiversion (ibfd
) == 1)
4071 _bfd_error_handler (_("symbol '%s' has invalid st_other"
4072 " for ABI version 1"), *name
);
4073 bfd_set_error (bfd_error_bad_value
);
4081 /* Merge non-visibility st_other attributes: local entry point. */
4084 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry
*h
,
4085 const Elf_Internal_Sym
*isym
,
4086 bfd_boolean definition
,
4087 bfd_boolean dynamic
)
4089 if (definition
&& (!dynamic
|| !h
->def_regular
))
4090 h
->other
= ((isym
->st_other
& ~ELF_ST_VISIBILITY (-1))
4091 | ELF_ST_VISIBILITY (h
->other
));
4094 /* Hook called on merging a symbol. We use this to clear "fake" since
4095 we now have a real symbol. */
4098 ppc64_elf_merge_symbol (struct elf_link_hash_entry
*h
,
4099 const Elf_Internal_Sym
*isym
,
4100 asection
**psec ATTRIBUTE_UNUSED
,
4101 bfd_boolean newdef ATTRIBUTE_UNUSED
,
4102 bfd_boolean olddef ATTRIBUTE_UNUSED
,
4103 bfd
*oldbfd ATTRIBUTE_UNUSED
,
4104 const asection
*oldsec ATTRIBUTE_UNUSED
)
4106 ((struct ppc_link_hash_entry
*) h
)->fake
= 0;
4107 if ((STO_PPC64_LOCAL_MASK
& isym
->st_other
) != 0)
4108 ((struct ppc_link_hash_entry
*) h
)->non_zero_localentry
= 1;
4112 /* This function makes an old ABI object reference to ".bar" cause the
4113 inclusion of a new ABI object archive that defines "bar".
4114 NAME is a symbol defined in an archive. Return a symbol in the hash
4115 table that might be satisfied by the archive symbols. */
4117 static struct elf_link_hash_entry
*
4118 ppc64_elf_archive_symbol_lookup (bfd
*abfd
,
4119 struct bfd_link_info
*info
,
4122 struct elf_link_hash_entry
*h
;
4126 h
= _bfd_elf_archive_symbol_lookup (abfd
, info
, name
);
4128 /* Don't return this sym if it is a fake function descriptor
4129 created by add_symbol_adjust. */
4130 && !((struct ppc_link_hash_entry
*) h
)->fake
)
4136 len
= strlen (name
);
4137 dot_name
= bfd_alloc (abfd
, len
+ 2);
4138 if (dot_name
== NULL
)
4139 return (struct elf_link_hash_entry
*) -1;
4141 memcpy (dot_name
+ 1, name
, len
+ 1);
4142 h
= _bfd_elf_archive_symbol_lookup (abfd
, info
, dot_name
);
4143 bfd_release (abfd
, dot_name
);
4147 /* This function satisfies all old ABI object references to ".bar" if a
4148 new ABI object defines "bar". Well, at least, undefined dot symbols
4149 are made weak. This stops later archive searches from including an
4150 object if we already have a function descriptor definition. It also
4151 prevents the linker complaining about undefined symbols.
4152 We also check and correct mismatched symbol visibility here. The
4153 most restrictive visibility of the function descriptor and the
4154 function entry symbol is used. */
4157 add_symbol_adjust (struct ppc_link_hash_entry
*eh
, struct bfd_link_info
*info
)
4159 struct ppc_link_hash_table
*htab
;
4160 struct ppc_link_hash_entry
*fdh
;
4162 if (eh
->elf
.root
.type
== bfd_link_hash_warning
)
4163 eh
= (struct ppc_link_hash_entry
*) eh
->elf
.root
.u
.i
.link
;
4165 if (eh
->elf
.root
.type
== bfd_link_hash_indirect
)
4168 if (eh
->elf
.root
.root
.string
[0] != '.')
4171 htab
= ppc_hash_table (info
);
4175 fdh
= lookup_fdh (eh
, htab
);
4177 && !bfd_link_relocatable (info
)
4178 && (eh
->elf
.root
.type
== bfd_link_hash_undefined
4179 || eh
->elf
.root
.type
== bfd_link_hash_undefweak
)
4180 && eh
->elf
.ref_regular
)
4182 /* Make an undefined function descriptor sym, in order to
4183 pull in an --as-needed shared lib. Archives are handled
4185 fdh
= make_fdh (info
, eh
);
4192 unsigned entry_vis
= ELF_ST_VISIBILITY (eh
->elf
.other
) - 1;
4193 unsigned descr_vis
= ELF_ST_VISIBILITY (fdh
->elf
.other
) - 1;
4195 /* Make both descriptor and entry symbol have the most
4196 constraining visibility of either symbol. */
4197 if (entry_vis
< descr_vis
)
4198 fdh
->elf
.other
+= entry_vis
- descr_vis
;
4199 else if (entry_vis
> descr_vis
)
4200 eh
->elf
.other
+= descr_vis
- entry_vis
;
4202 /* Propagate reference flags from entry symbol to function
4203 descriptor symbol. */
4204 fdh
->elf
.root
.non_ir_ref_regular
|= eh
->elf
.root
.non_ir_ref_regular
;
4205 fdh
->elf
.root
.non_ir_ref_dynamic
|= eh
->elf
.root
.non_ir_ref_dynamic
;
4206 fdh
->elf
.ref_regular
|= eh
->elf
.ref_regular
;
4207 fdh
->elf
.ref_regular_nonweak
|= eh
->elf
.ref_regular_nonweak
;
4209 if (!fdh
->elf
.forced_local
4210 && fdh
->elf
.dynindx
== -1
4211 && fdh
->elf
.versioned
!= versioned_hidden
4212 && (bfd_link_dll (info
)
4213 || fdh
->elf
.def_dynamic
4214 || fdh
->elf
.ref_dynamic
)
4215 && (eh
->elf
.ref_regular
4216 || eh
->elf
.def_regular
))
4218 if (!bfd_elf_link_record_dynamic_symbol (info
, &fdh
->elf
))
4226 /* Set up opd section info and abiversion for IBFD, and process list
4227 of dot-symbols we made in link_hash_newfunc. */
4230 ppc64_elf_before_check_relocs (bfd
*ibfd
, struct bfd_link_info
*info
)
4232 struct ppc_link_hash_table
*htab
;
4233 struct ppc_link_hash_entry
**p
, *eh
;
4234 asection
*opd
= bfd_get_section_by_name (ibfd
, ".opd");
4236 if (opd
!= NULL
&& opd
->size
!= 0)
4238 BFD_ASSERT (ppc64_elf_section_data (opd
)->sec_type
== sec_normal
);
4239 ppc64_elf_section_data (opd
)->sec_type
= sec_opd
;
4241 if (abiversion (ibfd
) == 0)
4242 set_abiversion (ibfd
, 1);
4243 else if (abiversion (ibfd
) >= 2)
4245 /* xgettext:c-format */
4246 _bfd_error_handler (_("%pB .opd not allowed in ABI version %d"),
4247 ibfd
, abiversion (ibfd
));
4248 bfd_set_error (bfd_error_bad_value
);
4253 if (is_ppc64_elf (info
->output_bfd
))
4255 /* For input files without an explicit abiversion in e_flags
4256 we should have flagged any with symbol st_other bits set
4257 as ELFv1 and above flagged those with .opd as ELFv2.
4258 Set the output abiversion if not yet set, and for any input
4259 still ambiguous, take its abiversion from the output.
4260 Differences in ABI are reported later. */
4261 if (abiversion (info
->output_bfd
) == 0)
4262 set_abiversion (info
->output_bfd
, abiversion (ibfd
));
4263 else if (abiversion (ibfd
) == 0)
4264 set_abiversion (ibfd
, abiversion (info
->output_bfd
));
4267 htab
= ppc_hash_table (info
);
4271 if (opd
!= NULL
&& opd
->size
!= 0
4272 && (ibfd
->flags
& DYNAMIC
) == 0
4273 && (opd
->flags
& SEC_RELOC
) != 0
4274 && opd
->reloc_count
!= 0
4275 && !bfd_is_abs_section (opd
->output_section
)
4276 && info
->gc_sections
)
4278 /* Garbage collection needs some extra help with .opd sections.
4279 We don't want to necessarily keep everything referenced by
4280 relocs in .opd, as that would keep all functions. Instead,
4281 if we reference an .opd symbol (a function descriptor), we
4282 want to keep the function code symbol's section. This is
4283 easy for global symbols, but for local syms we need to keep
4284 information about the associated function section. */
4286 asection
**opd_sym_map
;
4287 Elf_Internal_Shdr
*symtab_hdr
;
4288 Elf_Internal_Rela
*relocs
, *rel_end
, *rel
;
4290 amt
= OPD_NDX (opd
->size
) * sizeof (*opd_sym_map
);
4291 opd_sym_map
= bfd_zalloc (ibfd
, amt
);
4292 if (opd_sym_map
== NULL
)
4294 ppc64_elf_section_data (opd
)->u
.opd
.func_sec
= opd_sym_map
;
4295 relocs
= _bfd_elf_link_read_relocs (ibfd
, opd
, NULL
, NULL
,
4299 symtab_hdr
= &elf_symtab_hdr (ibfd
);
4300 rel_end
= relocs
+ opd
->reloc_count
- 1;
4301 for (rel
= relocs
; rel
< rel_end
; rel
++)
4303 enum elf_ppc64_reloc_type r_type
= ELF64_R_TYPE (rel
->r_info
);
4304 unsigned long r_symndx
= ELF64_R_SYM (rel
->r_info
);
4306 if (r_type
== R_PPC64_ADDR64
4307 && ELF64_R_TYPE ((rel
+ 1)->r_info
) == R_PPC64_TOC
4308 && r_symndx
< symtab_hdr
->sh_info
)
4310 Elf_Internal_Sym
*isym
;
4313 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
, ibfd
, r_symndx
);
4316 if (elf_section_data (opd
)->relocs
!= relocs
)
4321 s
= bfd_section_from_elf_index (ibfd
, isym
->st_shndx
);
4322 if (s
!= NULL
&& s
!= opd
)
4323 opd_sym_map
[OPD_NDX (rel
->r_offset
)] = s
;
4326 if (elf_section_data (opd
)->relocs
!= relocs
)
4330 p
= &htab
->dot_syms
;
4331 while ((eh
= *p
) != NULL
)
4334 if (&eh
->elf
== htab
->elf
.hgot
)
4336 else if (htab
->elf
.hgot
== NULL
4337 && strcmp (eh
->elf
.root
.root
.string
, ".TOC.") == 0)
4338 htab
->elf
.hgot
= &eh
->elf
;
4339 else if (abiversion (ibfd
) <= 1)
4341 htab
->need_func_desc_adj
= 1;
4342 if (!add_symbol_adjust (eh
, info
))
4345 p
= &eh
->u
.next_dot_sym
;
4350 /* Undo hash table changes when an --as-needed input file is determined
4351 not to be needed. */
4354 ppc64_elf_notice_as_needed (bfd
*ibfd
,
4355 struct bfd_link_info
*info
,
4356 enum notice_asneeded_action act
)
4358 if (act
== notice_not_needed
)
4360 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
4365 htab
->dot_syms
= NULL
;
4367 return _bfd_elf_notice_as_needed (ibfd
, info
, act
);
4370 /* If --just-symbols against a final linked binary, then assume we need
4371 toc adjusting stubs when calling functions defined there. */
4374 ppc64_elf_link_just_syms (asection
*sec
, struct bfd_link_info
*info
)
4376 if ((sec
->flags
& SEC_CODE
) != 0
4377 && (sec
->owner
->flags
& (EXEC_P
| DYNAMIC
)) != 0
4378 && is_ppc64_elf (sec
->owner
))
4380 if (abiversion (sec
->owner
) >= 2
4381 || bfd_get_section_by_name (sec
->owner
, ".opd") != NULL
)
4382 sec
->has_toc_reloc
= 1;
4384 _bfd_elf_link_just_syms (sec
, info
);
4387 static struct plt_entry
**
4388 update_local_sym_info (bfd
*abfd
, Elf_Internal_Shdr
*symtab_hdr
,
4389 unsigned long r_symndx
, bfd_vma r_addend
, int tls_type
)
4391 struct got_entry
**local_got_ents
= elf_local_got_ents (abfd
);
4392 struct plt_entry
**local_plt
;
4393 unsigned char *local_got_tls_masks
;
4395 if (local_got_ents
== NULL
)
4397 bfd_size_type size
= symtab_hdr
->sh_info
;
4399 size
*= (sizeof (*local_got_ents
)
4400 + sizeof (*local_plt
)
4401 + sizeof (*local_got_tls_masks
));
4402 local_got_ents
= bfd_zalloc (abfd
, size
);
4403 if (local_got_ents
== NULL
)
4405 elf_local_got_ents (abfd
) = local_got_ents
;
4408 if ((tls_type
& (NON_GOT
| TLS_EXPLICIT
)) == 0)
4410 struct got_entry
*ent
;
4412 for (ent
= local_got_ents
[r_symndx
]; ent
!= NULL
; ent
= ent
->next
)
4413 if (ent
->addend
== r_addend
4414 && ent
->owner
== abfd
4415 && ent
->tls_type
== tls_type
)
4419 bfd_size_type amt
= sizeof (*ent
);
4420 ent
= bfd_alloc (abfd
, amt
);
4423 ent
->next
= local_got_ents
[r_symndx
];
4424 ent
->addend
= r_addend
;
4426 ent
->tls_type
= tls_type
;
4427 ent
->is_indirect
= FALSE
;
4428 ent
->got
.refcount
= 0;
4429 local_got_ents
[r_symndx
] = ent
;
4431 ent
->got
.refcount
+= 1;
4434 local_plt
= (struct plt_entry
**) (local_got_ents
+ symtab_hdr
->sh_info
);
4435 local_got_tls_masks
= (unsigned char *) (local_plt
+ symtab_hdr
->sh_info
);
4436 local_got_tls_masks
[r_symndx
] |= tls_type
& 0xff;
4438 return local_plt
+ r_symndx
;
4442 update_plt_info (bfd
*abfd
, struct plt_entry
**plist
, bfd_vma addend
)
4444 struct plt_entry
*ent
;
4446 for (ent
= *plist
; ent
!= NULL
; ent
= ent
->next
)
4447 if (ent
->addend
== addend
)
4451 bfd_size_type amt
= sizeof (*ent
);
4452 ent
= bfd_alloc (abfd
, amt
);
4456 ent
->addend
= addend
;
4457 ent
->plt
.refcount
= 0;
4460 ent
->plt
.refcount
+= 1;
4465 is_branch_reloc (enum elf_ppc64_reloc_type r_type
)
4467 return (r_type
== R_PPC64_REL24
4468 || r_type
== R_PPC64_REL24_NOTOC
4469 || r_type
== R_PPC64_REL14
4470 || r_type
== R_PPC64_REL14_BRTAKEN
4471 || r_type
== R_PPC64_REL14_BRNTAKEN
4472 || r_type
== R_PPC64_ADDR24
4473 || r_type
== R_PPC64_ADDR14
4474 || r_type
== R_PPC64_ADDR14_BRTAKEN
4475 || r_type
== R_PPC64_ADDR14_BRNTAKEN
4476 || r_type
== R_PPC64_PLTCALL
4477 || r_type
== R_PPC64_PLTCALL_NOTOC
);
4480 /* Relocs on inline plt call sequence insns prior to the call. */
4483 is_plt_seq_reloc (enum elf_ppc64_reloc_type r_type
)
4485 return (r_type
== R_PPC64_PLT16_HA
4486 || r_type
== R_PPC64_PLT16_HI
4487 || r_type
== R_PPC64_PLT16_LO
4488 || r_type
== R_PPC64_PLT16_LO_DS
4489 || r_type
== R_PPC64_PLT_PCREL34
4490 || r_type
== R_PPC64_PLT_PCREL34_NOTOC
4491 || r_type
== R_PPC64_PLTSEQ
4492 || r_type
== R_PPC64_PLTSEQ_NOTOC
);
4495 /* Look through the relocs for a section during the first phase, and
4496 calculate needed space in the global offset table, procedure
4497 linkage table, and dynamic reloc sections. */
4500 ppc64_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
4501 asection
*sec
, const Elf_Internal_Rela
*relocs
)
4503 struct ppc_link_hash_table
*htab
;
4504 Elf_Internal_Shdr
*symtab_hdr
;
4505 struct elf_link_hash_entry
**sym_hashes
;
4506 const Elf_Internal_Rela
*rel
;
4507 const Elf_Internal_Rela
*rel_end
;
4509 struct elf_link_hash_entry
*tga
, *dottga
;
4512 if (bfd_link_relocatable (info
))
4515 /* Don't do anything special with non-loaded, non-alloced sections.
4516 In particular, any relocs in such sections should not affect GOT
4517 and PLT reference counting (ie. we don't allow them to create GOT
4518 or PLT entries), there's no possibility or desire to optimize TLS
4519 relocs, and there's not much point in propagating relocs to shared
4520 libs that the dynamic linker won't relocate. */
4521 if ((sec
->flags
& SEC_ALLOC
) == 0)
4524 BFD_ASSERT (is_ppc64_elf (abfd
));
4526 htab
= ppc_hash_table (info
);
4530 tga
= elf_link_hash_lookup (&htab
->elf
, "__tls_get_addr",
4531 FALSE
, FALSE
, TRUE
);
4532 dottga
= elf_link_hash_lookup (&htab
->elf
, ".__tls_get_addr",
4533 FALSE
, FALSE
, TRUE
);
4534 symtab_hdr
= &elf_symtab_hdr (abfd
);
4535 sym_hashes
= elf_sym_hashes (abfd
);
4537 is_opd
= ppc64_elf_section_data (sec
)->sec_type
== sec_opd
;
4538 rel_end
= relocs
+ sec
->reloc_count
;
4539 for (rel
= relocs
; rel
< rel_end
; rel
++)
4541 unsigned long r_symndx
;
4542 struct elf_link_hash_entry
*h
;
4543 enum elf_ppc64_reloc_type r_type
;
4545 struct _ppc64_elf_section_data
*ppc64_sec
;
4546 struct plt_entry
**ifunc
, **plt_list
;
4548 r_symndx
= ELF64_R_SYM (rel
->r_info
);
4549 if (r_symndx
< symtab_hdr
->sh_info
)
4553 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
4554 h
= elf_follow_link (h
);
4556 if (h
== htab
->elf
.hgot
)
4557 sec
->has_toc_reloc
= 1;
4560 r_type
= ELF64_R_TYPE (rel
->r_info
);
4564 case R_PPC64_D34_LO
:
4565 case R_PPC64_D34_HI30
:
4566 case R_PPC64_D34_HA30
:
4568 case R_PPC64_TPREL34
:
4569 case R_PPC64_DTPREL34
:
4570 case R_PPC64_PCREL34
:
4571 case R_PPC64_GOT_PCREL34
:
4572 case R_PPC64_GOT_TLSGD34
:
4573 case R_PPC64_GOT_TLSLD34
:
4574 case R_PPC64_GOT_TPREL34
:
4575 case R_PPC64_GOT_DTPREL34
:
4576 case R_PPC64_PLT_PCREL34
:
4577 case R_PPC64_PLT_PCREL34_NOTOC
:
4578 case R_PPC64_PCREL28
:
4579 htab
->powerxx_stubs
= 1;
4587 case R_PPC64_PLT16_HA
:
4588 case R_PPC64_GOT_TLSLD16_HA
:
4589 case R_PPC64_GOT_TLSGD16_HA
:
4590 case R_PPC64_GOT_TPREL16_HA
:
4591 case R_PPC64_GOT_DTPREL16_HA
:
4592 case R_PPC64_GOT16_HA
:
4593 case R_PPC64_TOC16_HA
:
4594 case R_PPC64_PLT16_LO
:
4595 case R_PPC64_PLT16_LO_DS
:
4596 case R_PPC64_GOT_TLSLD16_LO
:
4597 case R_PPC64_GOT_TLSGD16_LO
:
4598 case R_PPC64_GOT_TPREL16_LO_DS
:
4599 case R_PPC64_GOT_DTPREL16_LO_DS
:
4600 case R_PPC64_GOT16_LO
:
4601 case R_PPC64_GOT16_LO_DS
:
4602 case R_PPC64_TOC16_LO
:
4603 case R_PPC64_TOC16_LO_DS
:
4604 case R_PPC64_GOT_PCREL34
:
4605 ppc64_elf_tdata (abfd
)->has_optrel
= 1;
4606 ppc64_elf_section_data (sec
)->has_optrel
= 1;
4615 if (h
->type
== STT_GNU_IFUNC
)
4618 ifunc
= &h
->plt
.plist
;
4623 Elf_Internal_Sym
*isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
4628 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
4630 ifunc
= update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4632 NON_GOT
| PLT_IFUNC
);
4643 /* These special tls relocs tie a call to __tls_get_addr with
4644 its parameter symbol. */
4646 ((struct ppc_link_hash_entry
*) h
)->tls_mask
|= TLS_TLS
| TLS_MARK
;
4648 if (!update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4650 NON_GOT
| TLS_TLS
| TLS_MARK
))
4652 sec
->has_tls_reloc
= 1;
4655 case R_PPC64_GOT_TLSLD16
:
4656 case R_PPC64_GOT_TLSLD16_LO
:
4657 case R_PPC64_GOT_TLSLD16_HI
:
4658 case R_PPC64_GOT_TLSLD16_HA
:
4659 case R_PPC64_GOT_TLSLD34
:
4660 tls_type
= TLS_TLS
| TLS_LD
;
4663 case R_PPC64_GOT_TLSGD16
:
4664 case R_PPC64_GOT_TLSGD16_LO
:
4665 case R_PPC64_GOT_TLSGD16_HI
:
4666 case R_PPC64_GOT_TLSGD16_HA
:
4667 case R_PPC64_GOT_TLSGD34
:
4668 tls_type
= TLS_TLS
| TLS_GD
;
4671 case R_PPC64_GOT_TPREL16_DS
:
4672 case R_PPC64_GOT_TPREL16_LO_DS
:
4673 case R_PPC64_GOT_TPREL16_HI
:
4674 case R_PPC64_GOT_TPREL16_HA
:
4675 case R_PPC64_GOT_TPREL34
:
4676 if (bfd_link_dll (info
))
4677 info
->flags
|= DF_STATIC_TLS
;
4678 tls_type
= TLS_TLS
| TLS_TPREL
;
4681 case R_PPC64_GOT_DTPREL16_DS
:
4682 case R_PPC64_GOT_DTPREL16_LO_DS
:
4683 case R_PPC64_GOT_DTPREL16_HI
:
4684 case R_PPC64_GOT_DTPREL16_HA
:
4685 case R_PPC64_GOT_DTPREL34
:
4686 tls_type
= TLS_TLS
| TLS_DTPREL
;
4688 sec
->has_tls_reloc
= 1;
4692 case R_PPC64_GOT16_LO
:
4693 case R_PPC64_GOT16_HI
:
4694 case R_PPC64_GOT16_HA
:
4695 case R_PPC64_GOT16_DS
:
4696 case R_PPC64_GOT16_LO_DS
:
4697 case R_PPC64_GOT_PCREL34
:
4699 /* This symbol requires a global offset table entry. */
4700 sec
->has_toc_reloc
= 1;
4701 if (r_type
== R_PPC64_GOT_TLSLD16
4702 || r_type
== R_PPC64_GOT_TLSGD16
4703 || r_type
== R_PPC64_GOT_TPREL16_DS
4704 || r_type
== R_PPC64_GOT_DTPREL16_DS
4705 || r_type
== R_PPC64_GOT16
4706 || r_type
== R_PPC64_GOT16_DS
)
4708 htab
->do_multi_toc
= 1;
4709 ppc64_elf_tdata (abfd
)->has_small_toc_reloc
= 1;
4712 if (ppc64_elf_tdata (abfd
)->got
== NULL
4713 && !create_got_section (abfd
, info
))
4718 struct ppc_link_hash_entry
*eh
;
4719 struct got_entry
*ent
;
4721 eh
= (struct ppc_link_hash_entry
*) h
;
4722 for (ent
= eh
->elf
.got
.glist
; ent
!= NULL
; ent
= ent
->next
)
4723 if (ent
->addend
== rel
->r_addend
4724 && ent
->owner
== abfd
4725 && ent
->tls_type
== tls_type
)
4729 bfd_size_type amt
= sizeof (*ent
);
4730 ent
= bfd_alloc (abfd
, amt
);
4733 ent
->next
= eh
->elf
.got
.glist
;
4734 ent
->addend
= rel
->r_addend
;
4736 ent
->tls_type
= tls_type
;
4737 ent
->is_indirect
= FALSE
;
4738 ent
->got
.refcount
= 0;
4739 eh
->elf
.got
.glist
= ent
;
4741 ent
->got
.refcount
+= 1;
4742 eh
->tls_mask
|= tls_type
;
4745 /* This is a global offset table entry for a local symbol. */
4746 if (!update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4747 rel
->r_addend
, tls_type
))
4750 /* We may also need a plt entry if the symbol turns out to be
4752 if (h
!= NULL
&& !bfd_link_pic (info
) && abiversion (abfd
) != 1)
4754 if (!update_plt_info (abfd
, &h
->plt
.plist
, rel
->r_addend
))
4759 case R_PPC64_PLT16_HA
:
4760 case R_PPC64_PLT16_HI
:
4761 case R_PPC64_PLT16_LO
:
4762 case R_PPC64_PLT16_LO_DS
:
4763 case R_PPC64_PLT_PCREL34
:
4764 case R_PPC64_PLT_PCREL34_NOTOC
:
4767 /* This symbol requires a procedure linkage table entry. */
4772 if (h
->root
.root
.string
[0] == '.'
4773 && h
->root
.root
.string
[1] != '\0')
4774 ((struct ppc_link_hash_entry
*) h
)->is_func
= 1;
4775 ((struct ppc_link_hash_entry
*) h
)->tls_mask
|= PLT_KEEP
;
4776 plt_list
= &h
->plt
.plist
;
4778 if (plt_list
== NULL
)
4779 plt_list
= update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4781 NON_GOT
| PLT_KEEP
);
4782 if (!update_plt_info (abfd
, plt_list
, rel
->r_addend
))
4786 /* The following relocations don't need to propagate the
4787 relocation if linking a shared object since they are
4788 section relative. */
4789 case R_PPC64_SECTOFF
:
4790 case R_PPC64_SECTOFF_LO
:
4791 case R_PPC64_SECTOFF_HI
:
4792 case R_PPC64_SECTOFF_HA
:
4793 case R_PPC64_SECTOFF_DS
:
4794 case R_PPC64_SECTOFF_LO_DS
:
4795 case R_PPC64_DTPREL16
:
4796 case R_PPC64_DTPREL16_LO
:
4797 case R_PPC64_DTPREL16_HI
:
4798 case R_PPC64_DTPREL16_HA
:
4799 case R_PPC64_DTPREL16_DS
:
4800 case R_PPC64_DTPREL16_LO_DS
:
4801 case R_PPC64_DTPREL16_HIGH
:
4802 case R_PPC64_DTPREL16_HIGHA
:
4803 case R_PPC64_DTPREL16_HIGHER
:
4804 case R_PPC64_DTPREL16_HIGHERA
:
4805 case R_PPC64_DTPREL16_HIGHEST
:
4806 case R_PPC64_DTPREL16_HIGHESTA
:
4811 case R_PPC64_REL16_LO
:
4812 case R_PPC64_REL16_HI
:
4813 case R_PPC64_REL16_HA
:
4814 case R_PPC64_REL16_HIGH
:
4815 case R_PPC64_REL16_HIGHA
:
4816 case R_PPC64_REL16_HIGHER
:
4817 case R_PPC64_REL16_HIGHERA
:
4818 case R_PPC64_REL16_HIGHEST
:
4819 case R_PPC64_REL16_HIGHESTA
:
4820 case R_PPC64_REL16_HIGHER34
:
4821 case R_PPC64_REL16_HIGHERA34
:
4822 case R_PPC64_REL16_HIGHEST34
:
4823 case R_PPC64_REL16_HIGHESTA34
:
4824 case R_PPC64_REL16DX_HA
:
4827 /* Not supported as a dynamic relocation. */
4828 case R_PPC64_ADDR64_LOCAL
:
4829 if (bfd_link_pic (info
))
4831 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
4833 /* xgettext:c-format */
4834 info
->callbacks
->einfo (_("%H: %s reloc unsupported "
4835 "in shared libraries and PIEs\n"),
4836 abfd
, sec
, rel
->r_offset
,
4837 ppc64_elf_howto_table
[r_type
]->name
);
4838 bfd_set_error (bfd_error_bad_value
);
4844 case R_PPC64_TOC16_DS
:
4845 htab
->do_multi_toc
= 1;
4846 ppc64_elf_tdata (abfd
)->has_small_toc_reloc
= 1;
4848 case R_PPC64_TOC16_LO
:
4849 case R_PPC64_TOC16_HI
:
4850 case R_PPC64_TOC16_HA
:
4851 case R_PPC64_TOC16_LO_DS
:
4852 sec
->has_toc_reloc
= 1;
4853 if (h
!= NULL
&& bfd_link_executable (info
))
4855 /* We may need a copy reloc. */
4857 /* Strongly prefer a copy reloc over a dynamic reloc.
4858 glibc ld.so as of 2019-08 will error out if one of
4859 these relocations is emitted. */
4869 /* This relocation describes the C++ object vtable hierarchy.
4870 Reconstruct it for later use during GC. */
4871 case R_PPC64_GNU_VTINHERIT
:
4872 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
4876 /* This relocation describes which C++ vtable entries are actually
4877 used. Record for later use during GC. */
4878 case R_PPC64_GNU_VTENTRY
:
4879 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
4884 case R_PPC64_REL14_BRTAKEN
:
4885 case R_PPC64_REL14_BRNTAKEN
:
4887 asection
*dest
= NULL
;
4889 /* Heuristic: If jumping outside our section, chances are
4890 we are going to need a stub. */
4893 /* If the sym is weak it may be overridden later, so
4894 don't assume we know where a weak sym lives. */
4895 if (h
->root
.type
== bfd_link_hash_defined
)
4896 dest
= h
->root
.u
.def
.section
;
4900 Elf_Internal_Sym
*isym
;
4902 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
4907 dest
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
4911 ppc64_elf_section_data (sec
)->has_14bit_branch
= 1;
4915 case R_PPC64_PLTCALL
:
4916 case R_PPC64_PLTCALL_NOTOC
:
4917 ppc64_elf_section_data (sec
)->has_pltcall
= 1;
4921 case R_PPC64_REL24_NOTOC
:
4927 if (h
->root
.root
.string
[0] == '.'
4928 && h
->root
.root
.string
[1] != '\0')
4929 ((struct ppc_link_hash_entry
*) h
)->is_func
= 1;
4931 if (h
== tga
|| h
== dottga
)
4933 sec
->has_tls_reloc
= 1;
4935 && (ELF64_R_TYPE (rel
[-1].r_info
) == R_PPC64_TLSGD
4936 || ELF64_R_TYPE (rel
[-1].r_info
) == R_PPC64_TLSLD
))
4937 /* We have a new-style __tls_get_addr call with
4941 /* Mark this section as having an old-style call. */
4942 sec
->nomark_tls_get_addr
= 1;
4944 plt_list
= &h
->plt
.plist
;
4947 /* We may need a .plt entry if the function this reloc
4948 refers to is in a shared lib. */
4950 && !update_plt_info (abfd
, plt_list
, rel
->r_addend
))
4954 case R_PPC64_ADDR14
:
4955 case R_PPC64_ADDR14_BRNTAKEN
:
4956 case R_PPC64_ADDR14_BRTAKEN
:
4957 case R_PPC64_ADDR24
:
4960 case R_PPC64_TPREL64
:
4961 tls_type
= TLS_EXPLICIT
| TLS_TLS
| TLS_TPREL
;
4962 if (bfd_link_dll (info
))
4963 info
->flags
|= DF_STATIC_TLS
;
4966 case R_PPC64_DTPMOD64
:
4967 if (rel
+ 1 < rel_end
4968 && rel
[1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_DTPREL64
)
4969 && rel
[1].r_offset
== rel
->r_offset
+ 8)
4970 tls_type
= TLS_EXPLICIT
| TLS_TLS
| TLS_GD
;
4972 tls_type
= TLS_EXPLICIT
| TLS_TLS
| TLS_LD
;
4975 case R_PPC64_DTPREL64
:
4976 tls_type
= TLS_EXPLICIT
| TLS_TLS
| TLS_DTPREL
;
4978 && rel
[-1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_DTPMOD64
)
4979 && rel
[-1].r_offset
== rel
->r_offset
- 8)
4980 /* This is the second reloc of a dtpmod, dtprel pair.
4981 Don't mark with TLS_DTPREL. */
4985 sec
->has_tls_reloc
= 1;
4988 struct ppc_link_hash_entry
*eh
;
4989 eh
= (struct ppc_link_hash_entry
*) h
;
4990 eh
->tls_mask
|= tls_type
& 0xff;
4993 if (!update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4994 rel
->r_addend
, tls_type
))
4997 ppc64_sec
= ppc64_elf_section_data (sec
);
4998 if (ppc64_sec
->sec_type
!= sec_toc
)
5002 /* One extra to simplify get_tls_mask. */
5003 amt
= sec
->size
* sizeof (unsigned) / 8 + sizeof (unsigned);
5004 ppc64_sec
->u
.toc
.symndx
= bfd_zalloc (abfd
, amt
);
5005 if (ppc64_sec
->u
.toc
.symndx
== NULL
)
5007 amt
= sec
->size
* sizeof (bfd_vma
) / 8;
5008 ppc64_sec
->u
.toc
.add
= bfd_zalloc (abfd
, amt
);
5009 if (ppc64_sec
->u
.toc
.add
== NULL
)
5011 BFD_ASSERT (ppc64_sec
->sec_type
== sec_normal
);
5012 ppc64_sec
->sec_type
= sec_toc
;
5014 BFD_ASSERT (rel
->r_offset
% 8 == 0);
5015 ppc64_sec
->u
.toc
.symndx
[rel
->r_offset
/ 8] = r_symndx
;
5016 ppc64_sec
->u
.toc
.add
[rel
->r_offset
/ 8] = rel
->r_addend
;
5018 /* Mark the second slot of a GD or LD entry.
5019 -1 to indicate GD and -2 to indicate LD. */
5020 if (tls_type
== (TLS_EXPLICIT
| TLS_TLS
| TLS_GD
))
5021 ppc64_sec
->u
.toc
.symndx
[rel
->r_offset
/ 8 + 1] = -1;
5022 else if (tls_type
== (TLS_EXPLICIT
| TLS_TLS
| TLS_LD
))
5023 ppc64_sec
->u
.toc
.symndx
[rel
->r_offset
/ 8 + 1] = -2;
5026 case R_PPC64_TPREL16
:
5027 case R_PPC64_TPREL16_LO
:
5028 case R_PPC64_TPREL16_HI
:
5029 case R_PPC64_TPREL16_HA
:
5030 case R_PPC64_TPREL16_DS
:
5031 case R_PPC64_TPREL16_LO_DS
:
5032 case R_PPC64_TPREL16_HIGH
:
5033 case R_PPC64_TPREL16_HIGHA
:
5034 case R_PPC64_TPREL16_HIGHER
:
5035 case R_PPC64_TPREL16_HIGHERA
:
5036 case R_PPC64_TPREL16_HIGHEST
:
5037 case R_PPC64_TPREL16_HIGHESTA
:
5038 case R_PPC64_TPREL34
:
5039 if (bfd_link_dll (info
))
5040 info
->flags
|= DF_STATIC_TLS
;
5043 case R_PPC64_ADDR64
:
5045 && rel
+ 1 < rel_end
5046 && ELF64_R_TYPE ((rel
+ 1)->r_info
) == R_PPC64_TOC
)
5049 ((struct ppc_link_hash_entry
*) h
)->is_func
= 1;
5053 case R_PPC64_ADDR16
:
5054 case R_PPC64_ADDR16_DS
:
5055 case R_PPC64_ADDR16_HA
:
5056 case R_PPC64_ADDR16_HI
:
5057 case R_PPC64_ADDR16_HIGH
:
5058 case R_PPC64_ADDR16_HIGHA
:
5059 case R_PPC64_ADDR16_HIGHER
:
5060 case R_PPC64_ADDR16_HIGHERA
:
5061 case R_PPC64_ADDR16_HIGHEST
:
5062 case R_PPC64_ADDR16_HIGHESTA
:
5063 case R_PPC64_ADDR16_LO
:
5064 case R_PPC64_ADDR16_LO_DS
:
5066 case R_PPC64_D34_LO
:
5067 case R_PPC64_D34_HI30
:
5068 case R_PPC64_D34_HA30
:
5069 case R_PPC64_ADDR16_HIGHER34
:
5070 case R_PPC64_ADDR16_HIGHERA34
:
5071 case R_PPC64_ADDR16_HIGHEST34
:
5072 case R_PPC64_ADDR16_HIGHESTA34
:
5074 if (h
!= NULL
&& !bfd_link_pic (info
) && abiversion (abfd
) != 1
5075 && rel
->r_addend
== 0)
5077 /* We may need a .plt entry if this reloc refers to a
5078 function in a shared lib. */
5079 if (!update_plt_info (abfd
, &h
->plt
.plist
, 0))
5081 h
->pointer_equality_needed
= 1;
5088 case R_PPC64_ADDR32
:
5089 case R_PPC64_UADDR16
:
5090 case R_PPC64_UADDR32
:
5091 case R_PPC64_UADDR64
:
5093 if (h
!= NULL
&& bfd_link_executable (info
))
5094 /* We may need a copy reloc. */
5097 /* Don't propagate .opd relocs. */
5098 if (NO_OPD_RELOCS
&& is_opd
)
5101 /* If we are creating a shared library, and this is a reloc
5102 against a global symbol, or a non PC relative reloc
5103 against a local symbol, then we need to copy the reloc
5104 into the shared library. However, if we are linking with
5105 -Bsymbolic, we do not need to copy a reloc against a
5106 global symbol which is defined in an object we are
5107 including in the link (i.e., DEF_REGULAR is set). At
5108 this point we have not seen all the input files, so it is
5109 possible that DEF_REGULAR is not set now but will be set
5110 later (it is never cleared). In case of a weak definition,
5111 DEF_REGULAR may be cleared later by a strong definition in
5112 a shared library. We account for that possibility below by
5113 storing information in the dyn_relocs field of the hash
5114 table entry. A similar situation occurs when creating
5115 shared libraries and symbol visibility changes render the
5118 If on the other hand, we are creating an executable, we
5119 may need to keep relocations for symbols satisfied by a
5120 dynamic library if we manage to avoid copy relocs for the
5124 && (h
->root
.type
== bfd_link_hash_defweak
5125 || !h
->def_regular
))
5127 && !bfd_link_executable (info
)
5128 && !SYMBOLIC_BIND (info
, h
))
5129 || (bfd_link_pic (info
)
5130 && must_be_dyn_reloc (info
, r_type
))
5131 || (!bfd_link_pic (info
)
5134 /* We must copy these reloc types into the output file.
5135 Create a reloc section in dynobj and make room for
5139 sreloc
= _bfd_elf_make_dynamic_reloc_section
5140 (sec
, htab
->elf
.dynobj
, 3, abfd
, /*rela?*/ TRUE
);
5146 /* If this is a global symbol, we count the number of
5147 relocations we need for this symbol. */
5150 struct elf_dyn_relocs
*p
;
5151 struct elf_dyn_relocs
**head
;
5153 head
= &((struct ppc_link_hash_entry
*) h
)->dyn_relocs
;
5155 if (p
== NULL
|| p
->sec
!= sec
)
5157 p
= bfd_alloc (htab
->elf
.dynobj
, sizeof *p
);
5167 if (!must_be_dyn_reloc (info
, r_type
))
5172 /* Track dynamic relocs needed for local syms too.
5173 We really need local syms available to do this
5175 struct ppc_dyn_relocs
*p
;
5176 struct ppc_dyn_relocs
**head
;
5177 bfd_boolean is_ifunc
;
5180 Elf_Internal_Sym
*isym
;
5182 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
5187 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
5191 vpp
= &elf_section_data (s
)->local_dynrel
;
5192 head
= (struct ppc_dyn_relocs
**) vpp
;
5193 is_ifunc
= ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
;
5195 if (p
!= NULL
&& p
->sec
== sec
&& p
->ifunc
!= is_ifunc
)
5197 if (p
== NULL
|| p
->sec
!= sec
|| p
->ifunc
!= is_ifunc
)
5199 p
= bfd_alloc (htab
->elf
.dynobj
, sizeof *p
);
5205 p
->ifunc
= is_ifunc
;
5221 /* Merge backend specific data from an object file to the output
5222 object file when linking. */
5225 ppc64_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
5227 bfd
*obfd
= info
->output_bfd
;
5228 unsigned long iflags
, oflags
;
5230 if ((ibfd
->flags
& BFD_LINKER_CREATED
) != 0)
5233 if (!is_ppc64_elf (ibfd
) || !is_ppc64_elf (obfd
))
5236 if (!_bfd_generic_verify_endian_match (ibfd
, info
))
5239 iflags
= elf_elfheader (ibfd
)->e_flags
;
5240 oflags
= elf_elfheader (obfd
)->e_flags
;
5242 if (iflags
& ~EF_PPC64_ABI
)
5245 /* xgettext:c-format */
5246 (_("%pB uses unknown e_flags 0x%lx"), ibfd
, iflags
);
5247 bfd_set_error (bfd_error_bad_value
);
5250 else if (iflags
!= oflags
&& iflags
!= 0)
5253 /* xgettext:c-format */
5254 (_("%pB: ABI version %ld is not compatible with ABI version %ld output"),
5255 ibfd
, iflags
, oflags
);
5256 bfd_set_error (bfd_error_bad_value
);
5260 if (!_bfd_elf_ppc_merge_fp_attributes (ibfd
, info
))
5263 /* Merge Tag_compatibility attributes and any common GNU ones. */
5264 return _bfd_elf_merge_object_attributes (ibfd
, info
);
5268 ppc64_elf_print_private_bfd_data (bfd
*abfd
, void *ptr
)
5270 /* Print normal ELF private data. */
5271 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
5273 if (elf_elfheader (abfd
)->e_flags
!= 0)
5277 fprintf (file
, _("private flags = 0x%lx:"),
5278 elf_elfheader (abfd
)->e_flags
);
5280 if ((elf_elfheader (abfd
)->e_flags
& EF_PPC64_ABI
) != 0)
5281 fprintf (file
, _(" [abiv%ld]"),
5282 elf_elfheader (abfd
)->e_flags
& EF_PPC64_ABI
);
5289 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
5290 of the code entry point, and its section, which must be in the same
5291 object as OPD_SEC. Returns (bfd_vma) -1 on error. */
5294 opd_entry_value (asection
*opd_sec
,
5296 asection
**code_sec
,
5298 bfd_boolean in_code_sec
)
5300 bfd
*opd_bfd
= opd_sec
->owner
;
5301 Elf_Internal_Rela
*relocs
;
5302 Elf_Internal_Rela
*lo
, *hi
, *look
;
5305 /* No relocs implies we are linking a --just-symbols object, or looking
5306 at a final linked executable with addr2line or somesuch. */
5307 if (opd_sec
->reloc_count
== 0)
5309 bfd_byte
*contents
= ppc64_elf_tdata (opd_bfd
)->opd
.contents
;
5311 if (contents
== NULL
)
5313 if (!bfd_malloc_and_get_section (opd_bfd
, opd_sec
, &contents
))
5314 return (bfd_vma
) -1;
5315 ppc64_elf_tdata (opd_bfd
)->opd
.contents
= contents
;
5318 /* PR 17512: file: 64b9dfbb. */
5319 if (offset
+ 7 >= opd_sec
->size
|| offset
+ 7 < offset
)
5320 return (bfd_vma
) -1;
5322 val
= bfd_get_64 (opd_bfd
, contents
+ offset
);
5323 if (code_sec
!= NULL
)
5325 asection
*sec
, *likely
= NULL
;
5331 && val
< sec
->vma
+ sec
->size
)
5337 for (sec
= opd_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
5339 && (sec
->flags
& SEC_LOAD
) != 0
5340 && (sec
->flags
& SEC_ALLOC
) != 0)
5345 if (code_off
!= NULL
)
5346 *code_off
= val
- likely
->vma
;
5352 BFD_ASSERT (is_ppc64_elf (opd_bfd
));
5354 relocs
= ppc64_elf_tdata (opd_bfd
)->opd
.relocs
;
5356 relocs
= _bfd_elf_link_read_relocs (opd_bfd
, opd_sec
, NULL
, NULL
, TRUE
);
5357 /* PR 17512: file: df8e1fd6. */
5359 return (bfd_vma
) -1;
5361 /* Go find the opd reloc at the sym address. */
5363 hi
= lo
+ opd_sec
->reloc_count
- 1; /* ignore last reloc */
5367 look
= lo
+ (hi
- lo
) / 2;
5368 if (look
->r_offset
< offset
)
5370 else if (look
->r_offset
> offset
)
5374 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (opd_bfd
);
5376 if (ELF64_R_TYPE (look
->r_info
) == R_PPC64_ADDR64
5377 && ELF64_R_TYPE ((look
+ 1)->r_info
) == R_PPC64_TOC
)
5379 unsigned long symndx
= ELF64_R_SYM (look
->r_info
);
5380 asection
*sec
= NULL
;
5382 if (symndx
>= symtab_hdr
->sh_info
5383 && elf_sym_hashes (opd_bfd
) != NULL
)
5385 struct elf_link_hash_entry
**sym_hashes
;
5386 struct elf_link_hash_entry
*rh
;
5388 sym_hashes
= elf_sym_hashes (opd_bfd
);
5389 rh
= sym_hashes
[symndx
- symtab_hdr
->sh_info
];
5392 rh
= elf_follow_link (rh
);
5393 if (rh
->root
.type
!= bfd_link_hash_defined
5394 && rh
->root
.type
!= bfd_link_hash_defweak
)
5396 if (rh
->root
.u
.def
.section
->owner
== opd_bfd
)
5398 val
= rh
->root
.u
.def
.value
;
5399 sec
= rh
->root
.u
.def
.section
;
5406 Elf_Internal_Sym
*sym
;
5408 if (symndx
< symtab_hdr
->sh_info
)
5410 sym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
5413 size_t symcnt
= symtab_hdr
->sh_info
;
5414 sym
= bfd_elf_get_elf_syms (opd_bfd
, symtab_hdr
,
5419 symtab_hdr
->contents
= (bfd_byte
*) sym
;
5425 sym
= bfd_elf_get_elf_syms (opd_bfd
, symtab_hdr
,
5431 sec
= bfd_section_from_elf_index (opd_bfd
, sym
->st_shndx
);
5434 BFD_ASSERT ((sec
->flags
& SEC_MERGE
) == 0);
5435 val
= sym
->st_value
;
5438 val
+= look
->r_addend
;
5439 if (code_off
!= NULL
)
5441 if (code_sec
!= NULL
)
5443 if (in_code_sec
&& *code_sec
!= sec
)
5448 if (sec
->output_section
!= NULL
)
5449 val
+= sec
->output_section
->vma
+ sec
->output_offset
;
5458 /* If the ELF symbol SYM might be a function in SEC, return the
5459 function size and set *CODE_OFF to the function's entry point,
5460 otherwise return zero. */
5462 static bfd_size_type
5463 ppc64_elf_maybe_function_sym (const asymbol
*sym
, asection
*sec
,
5468 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_FILE
| BSF_OBJECT
5469 | BSF_THREAD_LOCAL
| BSF_RELC
| BSF_SRELC
)) != 0)
5473 if (!(sym
->flags
& BSF_SYNTHETIC
))
5474 size
= ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
5476 if (strcmp (sym
->section
->name
, ".opd") == 0)
5478 struct _opd_sec_data
*opd
= get_opd_info (sym
->section
);
5479 bfd_vma symval
= sym
->value
;
5482 && opd
->adjust
!= NULL
5483 && elf_section_data (sym
->section
)->relocs
!= NULL
)
5485 /* opd_entry_value will use cached relocs that have been
5486 adjusted, but with raw symbols. That means both local
5487 and global symbols need adjusting. */
5488 long adjust
= opd
->adjust
[OPD_NDX (symval
)];
5494 if (opd_entry_value (sym
->section
, symval
,
5495 &sec
, code_off
, TRUE
) == (bfd_vma
) -1)
5497 /* An old ABI binary with dot-syms has a size of 24 on the .opd
5498 symbol. This size has nothing to do with the code size of the
5499 function, which is what we're supposed to return, but the
5500 code size isn't available without looking up the dot-sym.
5501 However, doing that would be a waste of time particularly
5502 since elf_find_function will look at the dot-sym anyway.
5503 Now, elf_find_function will keep the largest size of any
5504 function sym found at the code address of interest, so return
5505 1 here to avoid it incorrectly caching a larger function size
5506 for a small function. This does mean we return the wrong
5507 size for a new-ABI function of size 24, but all that does is
5508 disable caching for such functions. */
5514 if (sym
->section
!= sec
)
5516 *code_off
= sym
->value
;
5523 /* Return true if symbol is a strong function defined in an ELFv2
5524 object with st_other localentry bits of zero, ie. its local entry
5525 point coincides with its global entry point. */
5528 is_elfv2_localentry0 (struct elf_link_hash_entry
*h
)
5531 && h
->type
== STT_FUNC
5532 && h
->root
.type
== bfd_link_hash_defined
5533 && (STO_PPC64_LOCAL_MASK
& h
->other
) == 0
5534 && !((struct ppc_link_hash_entry
*) h
)->non_zero_localentry
5535 && is_ppc64_elf (h
->root
.u
.def
.section
->owner
)
5536 && abiversion (h
->root
.u
.def
.section
->owner
) >= 2);
5539 /* Return true if symbol is defined in a regular object file. */
5542 is_static_defined (struct elf_link_hash_entry
*h
)
5544 return ((h
->root
.type
== bfd_link_hash_defined
5545 || h
->root
.type
== bfd_link_hash_defweak
)
5546 && h
->root
.u
.def
.section
!= NULL
5547 && h
->root
.u
.def
.section
->output_section
!= NULL
);
5550 /* If FDH is a function descriptor symbol, return the associated code
5551 entry symbol if it is defined. Return NULL otherwise. */
5553 static struct ppc_link_hash_entry
*
5554 defined_code_entry (struct ppc_link_hash_entry
*fdh
)
5556 if (fdh
->is_func_descriptor
)
5558 struct ppc_link_hash_entry
*fh
= ppc_follow_link (fdh
->oh
);
5559 if (fh
->elf
.root
.type
== bfd_link_hash_defined
5560 || fh
->elf
.root
.type
== bfd_link_hash_defweak
)
5566 /* If FH is a function code entry symbol, return the associated
5567 function descriptor symbol if it is defined. Return NULL otherwise. */
5569 static struct ppc_link_hash_entry
*
5570 defined_func_desc (struct ppc_link_hash_entry
*fh
)
5573 && fh
->oh
->is_func_descriptor
)
5575 struct ppc_link_hash_entry
*fdh
= ppc_follow_link (fh
->oh
);
5576 if (fdh
->elf
.root
.type
== bfd_link_hash_defined
5577 || fdh
->elf
.root
.type
== bfd_link_hash_defweak
)
5583 static bfd_boolean
func_desc_adjust (struct elf_link_hash_entry
*, void *);
5585 /* Garbage collect sections, after first dealing with dot-symbols. */
5588 ppc64_elf_gc_sections (bfd
*abfd
, struct bfd_link_info
*info
)
5590 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
5592 if (htab
!= NULL
&& htab
->need_func_desc_adj
)
5594 elf_link_hash_traverse (&htab
->elf
, func_desc_adjust
, info
);
5595 htab
->need_func_desc_adj
= 0;
5597 return bfd_elf_gc_sections (abfd
, info
);
5600 /* Mark all our entry sym sections, both opd and code section. */
5603 ppc64_elf_gc_keep (struct bfd_link_info
*info
)
5605 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
5606 struct bfd_sym_chain
*sym
;
5611 for (sym
= info
->gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
5613 struct ppc_link_hash_entry
*eh
, *fh
;
5616 eh
= (struct ppc_link_hash_entry
*)
5617 elf_link_hash_lookup (&htab
->elf
, sym
->name
, FALSE
, FALSE
, TRUE
);
5620 if (eh
->elf
.root
.type
!= bfd_link_hash_defined
5621 && eh
->elf
.root
.type
!= bfd_link_hash_defweak
)
5624 fh
= defined_code_entry (eh
);
5627 sec
= fh
->elf
.root
.u
.def
.section
;
5628 sec
->flags
|= SEC_KEEP
;
5630 else if (get_opd_info (eh
->elf
.root
.u
.def
.section
) != NULL
5631 && opd_entry_value (eh
->elf
.root
.u
.def
.section
,
5632 eh
->elf
.root
.u
.def
.value
,
5633 &sec
, NULL
, FALSE
) != (bfd_vma
) -1)
5634 sec
->flags
|= SEC_KEEP
;
5636 sec
= eh
->elf
.root
.u
.def
.section
;
5637 sec
->flags
|= SEC_KEEP
;
5641 /* Mark sections containing dynamically referenced symbols. When
5642 building shared libraries, we must assume that any visible symbol is
5646 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry
*h
, void *inf
)
5648 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
5649 struct ppc_link_hash_entry
*eh
= (struct ppc_link_hash_entry
*) h
;
5650 struct ppc_link_hash_entry
*fdh
;
5651 struct bfd_elf_dynamic_list
*d
= info
->dynamic_list
;
5653 /* Dynamic linking info is on the func descriptor sym. */
5654 fdh
= defined_func_desc (eh
);
5658 if ((eh
->elf
.root
.type
== bfd_link_hash_defined
5659 || eh
->elf
.root
.type
== bfd_link_hash_defweak
)
5660 && ((eh
->elf
.ref_dynamic
&& !eh
->elf
.forced_local
)
5661 || ((eh
->elf
.def_regular
|| ELF_COMMON_DEF_P (&eh
->elf
))
5662 && ELF_ST_VISIBILITY (eh
->elf
.other
) != STV_INTERNAL
5663 && ELF_ST_VISIBILITY (eh
->elf
.other
) != STV_HIDDEN
5664 && (!bfd_link_executable (info
)
5665 || info
->gc_keep_exported
5666 || info
->export_dynamic
5669 && (*d
->match
) (&d
->head
, NULL
,
5670 eh
->elf
.root
.root
.string
)))
5671 && (eh
->elf
.versioned
>= versioned
5672 || !bfd_hide_sym_by_version (info
->version_info
,
5673 eh
->elf
.root
.root
.string
)))))
5676 struct ppc_link_hash_entry
*fh
;
5678 eh
->elf
.root
.u
.def
.section
->flags
|= SEC_KEEP
;
5680 /* Function descriptor syms cause the associated
5681 function code sym section to be marked. */
5682 fh
= defined_code_entry (eh
);
5685 code_sec
= fh
->elf
.root
.u
.def
.section
;
5686 code_sec
->flags
|= SEC_KEEP
;
5688 else if (get_opd_info (eh
->elf
.root
.u
.def
.section
) != NULL
5689 && opd_entry_value (eh
->elf
.root
.u
.def
.section
,
5690 eh
->elf
.root
.u
.def
.value
,
5691 &code_sec
, NULL
, FALSE
) != (bfd_vma
) -1)
5692 code_sec
->flags
|= SEC_KEEP
;
5698 /* Return the section that should be marked against GC for a given
5702 ppc64_elf_gc_mark_hook (asection
*sec
,
5703 struct bfd_link_info
*info
,
5704 Elf_Internal_Rela
*rel
,
5705 struct elf_link_hash_entry
*h
,
5706 Elf_Internal_Sym
*sym
)
5710 /* Syms return NULL if we're marking .opd, so we avoid marking all
5711 function sections, as all functions are referenced in .opd. */
5713 if (get_opd_info (sec
) != NULL
)
5718 enum elf_ppc64_reloc_type r_type
;
5719 struct ppc_link_hash_entry
*eh
, *fh
, *fdh
;
5721 r_type
= ELF64_R_TYPE (rel
->r_info
);
5724 case R_PPC64_GNU_VTINHERIT
:
5725 case R_PPC64_GNU_VTENTRY
:
5729 switch (h
->root
.type
)
5731 case bfd_link_hash_defined
:
5732 case bfd_link_hash_defweak
:
5733 eh
= (struct ppc_link_hash_entry
*) h
;
5734 fdh
= defined_func_desc (eh
);
5737 /* -mcall-aixdesc code references the dot-symbol on
5738 a call reloc. Mark the function descriptor too
5739 against garbage collection. */
5741 if (fdh
->elf
.is_weakalias
)
5742 weakdef (&fdh
->elf
)->mark
= 1;
5746 /* Function descriptor syms cause the associated
5747 function code sym section to be marked. */
5748 fh
= defined_code_entry (eh
);
5751 /* They also mark their opd section. */
5752 eh
->elf
.root
.u
.def
.section
->gc_mark
= 1;
5754 rsec
= fh
->elf
.root
.u
.def
.section
;
5756 else if (get_opd_info (eh
->elf
.root
.u
.def
.section
) != NULL
5757 && opd_entry_value (eh
->elf
.root
.u
.def
.section
,
5758 eh
->elf
.root
.u
.def
.value
,
5759 &rsec
, NULL
, FALSE
) != (bfd_vma
) -1)
5760 eh
->elf
.root
.u
.def
.section
->gc_mark
= 1;
5762 rsec
= h
->root
.u
.def
.section
;
5765 case bfd_link_hash_common
:
5766 rsec
= h
->root
.u
.c
.p
->section
;
5770 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
5776 struct _opd_sec_data
*opd
;
5778 rsec
= bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
5779 opd
= get_opd_info (rsec
);
5780 if (opd
!= NULL
&& opd
->func_sec
!= NULL
)
5784 rsec
= opd
->func_sec
[OPD_NDX (sym
->st_value
+ rel
->r_addend
)];
5791 /* The maximum size of .sfpr. */
5792 #define SFPR_MAX (218*4)
5794 struct sfpr_def_parms
5796 const char name
[12];
5797 unsigned char lo
, hi
;
5798 bfd_byte
*(*write_ent
) (bfd
*, bfd_byte
*, int);
5799 bfd_byte
*(*write_tail
) (bfd
*, bfd_byte
*, int);
5802 /* Auto-generate _save*, _rest* functions in .sfpr.
5803 If STUB_SEC is non-null, define alias symbols in STUB_SEC
5807 sfpr_define (struct bfd_link_info
*info
,
5808 const struct sfpr_def_parms
*parm
,
5811 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
5813 size_t len
= strlen (parm
->name
);
5814 bfd_boolean writing
= FALSE
;
5820 memcpy (sym
, parm
->name
, len
);
5823 for (i
= parm
->lo
; i
<= parm
->hi
; i
++)
5825 struct ppc_link_hash_entry
*h
;
5827 sym
[len
+ 0] = i
/ 10 + '0';
5828 sym
[len
+ 1] = i
% 10 + '0';
5829 h
= (struct ppc_link_hash_entry
*)
5830 elf_link_hash_lookup (&htab
->elf
, sym
, writing
, TRUE
, TRUE
);
5831 if (stub_sec
!= NULL
)
5834 && h
->elf
.root
.type
== bfd_link_hash_defined
5835 && h
->elf
.root
.u
.def
.section
== htab
->sfpr
)
5837 struct elf_link_hash_entry
*s
;
5839 sprintf (buf
, "%08x.%s", stub_sec
->id
& 0xffffffff, sym
);
5840 s
= elf_link_hash_lookup (&htab
->elf
, buf
, TRUE
, TRUE
, FALSE
);
5843 if (s
->root
.type
== bfd_link_hash_new
)
5845 s
->root
.type
= bfd_link_hash_defined
;
5846 s
->root
.u
.def
.section
= stub_sec
;
5847 s
->root
.u
.def
.value
= (stub_sec
->size
- htab
->sfpr
->size
5848 + h
->elf
.root
.u
.def
.value
);
5851 s
->ref_regular_nonweak
= 1;
5852 s
->forced_local
= 1;
5854 s
->root
.linker_def
= 1;
5862 if (!h
->elf
.def_regular
)
5864 h
->elf
.root
.type
= bfd_link_hash_defined
;
5865 h
->elf
.root
.u
.def
.section
= htab
->sfpr
;
5866 h
->elf
.root
.u
.def
.value
= htab
->sfpr
->size
;
5867 h
->elf
.type
= STT_FUNC
;
5868 h
->elf
.def_regular
= 1;
5870 _bfd_elf_link_hash_hide_symbol (info
, &h
->elf
, TRUE
);
5872 if (htab
->sfpr
->contents
== NULL
)
5874 htab
->sfpr
->contents
5875 = bfd_alloc (htab
->elf
.dynobj
, SFPR_MAX
);
5876 if (htab
->sfpr
->contents
== NULL
)
5883 bfd_byte
*p
= htab
->sfpr
->contents
+ htab
->sfpr
->size
;
5885 p
= (*parm
->write_ent
) (htab
->elf
.dynobj
, p
, i
);
5887 p
= (*parm
->write_tail
) (htab
->elf
.dynobj
, p
, i
);
5888 htab
->sfpr
->size
= p
- htab
->sfpr
->contents
;
5896 savegpr0 (bfd
*abfd
, bfd_byte
*p
, int r
)
5898 bfd_put_32 (abfd
, STD_R0_0R1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5903 savegpr0_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5905 p
= savegpr0 (abfd
, p
, r
);
5906 bfd_put_32 (abfd
, STD_R0_0R1
+ STK_LR
, p
);
5908 bfd_put_32 (abfd
, BLR
, p
);
5913 restgpr0 (bfd
*abfd
, bfd_byte
*p
, int r
)
5915 bfd_put_32 (abfd
, LD_R0_0R1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5920 restgpr0_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5922 bfd_put_32 (abfd
, LD_R0_0R1
+ STK_LR
, p
);
5924 p
= restgpr0 (abfd
, p
, r
);
5925 bfd_put_32 (abfd
, MTLR_R0
, p
);
5929 p
= restgpr0 (abfd
, p
, 30);
5930 p
= restgpr0 (abfd
, p
, 31);
5932 bfd_put_32 (abfd
, BLR
, p
);
5937 savegpr1 (bfd
*abfd
, bfd_byte
*p
, int r
)
5939 bfd_put_32 (abfd
, STD_R0_0R12
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5944 savegpr1_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5946 p
= savegpr1 (abfd
, p
, r
);
5947 bfd_put_32 (abfd
, BLR
, p
);
5952 restgpr1 (bfd
*abfd
, bfd_byte
*p
, int r
)
5954 bfd_put_32 (abfd
, LD_R0_0R12
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5959 restgpr1_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5961 p
= restgpr1 (abfd
, p
, r
);
5962 bfd_put_32 (abfd
, BLR
, p
);
5967 savefpr (bfd
*abfd
, bfd_byte
*p
, int r
)
5969 bfd_put_32 (abfd
, STFD_FR0_0R1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5974 savefpr0_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5976 p
= savefpr (abfd
, p
, r
);
5977 bfd_put_32 (abfd
, STD_R0_0R1
+ STK_LR
, p
);
5979 bfd_put_32 (abfd
, BLR
, p
);
5984 restfpr (bfd
*abfd
, bfd_byte
*p
, int r
)
5986 bfd_put_32 (abfd
, LFD_FR0_0R1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5991 restfpr0_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5993 bfd_put_32 (abfd
, LD_R0_0R1
+ STK_LR
, p
);
5995 p
= restfpr (abfd
, p
, r
);
5996 bfd_put_32 (abfd
, MTLR_R0
, p
);
6000 p
= restfpr (abfd
, p
, 30);
6001 p
= restfpr (abfd
, p
, 31);
6003 bfd_put_32 (abfd
, BLR
, p
);
6008 savefpr1_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6010 p
= savefpr (abfd
, p
, r
);
6011 bfd_put_32 (abfd
, BLR
, p
);
6016 restfpr1_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6018 p
= restfpr (abfd
, p
, r
);
6019 bfd_put_32 (abfd
, BLR
, p
);
6024 savevr (bfd
*abfd
, bfd_byte
*p
, int r
)
6026 bfd_put_32 (abfd
, LI_R12_0
+ (1 << 16) - (32 - r
) * 16, p
);
6028 bfd_put_32 (abfd
, STVX_VR0_R12_R0
+ (r
<< 21), p
);
6033 savevr_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6035 p
= savevr (abfd
, p
, r
);
6036 bfd_put_32 (abfd
, BLR
, p
);
6041 restvr (bfd
*abfd
, bfd_byte
*p
, int r
)
6043 bfd_put_32 (abfd
, LI_R12_0
+ (1 << 16) - (32 - r
) * 16, p
);
6045 bfd_put_32 (abfd
, LVX_VR0_R12_R0
+ (r
<< 21), p
);
6050 restvr_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6052 p
= restvr (abfd
, p
, r
);
6053 bfd_put_32 (abfd
, BLR
, p
);
6057 /* Called via elf_link_hash_traverse to transfer dynamic linking
6058 information on function code symbol entries to their corresponding
6059 function descriptor symbol entries. */
6062 func_desc_adjust (struct elf_link_hash_entry
*h
, void *inf
)
6064 struct bfd_link_info
*info
;
6065 struct ppc_link_hash_table
*htab
;
6066 struct ppc_link_hash_entry
*fh
;
6067 struct ppc_link_hash_entry
*fdh
;
6068 bfd_boolean force_local
;
6070 fh
= (struct ppc_link_hash_entry
*) h
;
6071 if (fh
->elf
.root
.type
== bfd_link_hash_indirect
)
6077 if (fh
->elf
.root
.root
.string
[0] != '.'
6078 || fh
->elf
.root
.root
.string
[1] == '\0')
6082 htab
= ppc_hash_table (info
);
6086 /* Find the corresponding function descriptor symbol. */
6087 fdh
= lookup_fdh (fh
, htab
);
6089 /* Resolve undefined references to dot-symbols as the value
6090 in the function descriptor, if we have one in a regular object.
6091 This is to satisfy cases like ".quad .foo". Calls to functions
6092 in dynamic objects are handled elsewhere. */
6093 if ((fh
->elf
.root
.type
== bfd_link_hash_undefined
6094 || fh
->elf
.root
.type
== bfd_link_hash_undefweak
)
6095 && (fdh
->elf
.root
.type
== bfd_link_hash_defined
6096 || fdh
->elf
.root
.type
== bfd_link_hash_defweak
)
6097 && get_opd_info (fdh
->elf
.root
.u
.def
.section
) != NULL
6098 && opd_entry_value (fdh
->elf
.root
.u
.def
.section
,
6099 fdh
->elf
.root
.u
.def
.value
,
6100 &fh
->elf
.root
.u
.def
.section
,
6101 &fh
->elf
.root
.u
.def
.value
, FALSE
) != (bfd_vma
) -1)
6103 fh
->elf
.root
.type
= fdh
->elf
.root
.type
;
6104 fh
->elf
.forced_local
= 1;
6105 fh
->elf
.def_regular
= fdh
->elf
.def_regular
;
6106 fh
->elf
.def_dynamic
= fdh
->elf
.def_dynamic
;
6109 if (!fh
->elf
.dynamic
)
6111 struct plt_entry
*ent
;
6113 for (ent
= fh
->elf
.plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
6114 if (ent
->plt
.refcount
> 0)
6120 /* Create a descriptor as undefined if necessary. */
6122 && !bfd_link_executable (info
)
6123 && (fh
->elf
.root
.type
== bfd_link_hash_undefined
6124 || fh
->elf
.root
.type
== bfd_link_hash_undefweak
))
6126 fdh
= make_fdh (info
, fh
);
6131 /* We can't support overriding of symbols on a fake descriptor. */
6134 && (fh
->elf
.root
.type
== bfd_link_hash_defined
6135 || fh
->elf
.root
.type
== bfd_link_hash_defweak
))
6136 _bfd_elf_link_hash_hide_symbol (info
, &fdh
->elf
, TRUE
);
6138 /* Transfer dynamic linking information to the function descriptor. */
6141 fdh
->elf
.ref_regular
|= fh
->elf
.ref_regular
;
6142 fdh
->elf
.ref_dynamic
|= fh
->elf
.ref_dynamic
;
6143 fdh
->elf
.ref_regular_nonweak
|= fh
->elf
.ref_regular_nonweak
;
6144 fdh
->elf
.non_got_ref
|= fh
->elf
.non_got_ref
;
6145 fdh
->elf
.dynamic
|= fh
->elf
.dynamic
;
6146 fdh
->elf
.needs_plt
|= (fh
->elf
.needs_plt
6147 || fh
->elf
.type
== STT_FUNC
6148 || fh
->elf
.type
== STT_GNU_IFUNC
);
6149 move_plt_plist (fh
, fdh
);
6151 if (!fdh
->elf
.forced_local
6152 && fh
->elf
.dynindx
!= -1)
6153 if (!bfd_elf_link_record_dynamic_symbol (info
, &fdh
->elf
))
6157 /* Now that the info is on the function descriptor, clear the
6158 function code sym info. Any function code syms for which we
6159 don't have a definition in a regular file, we force local.
6160 This prevents a shared library from exporting syms that have
6161 been imported from another library. Function code syms that
6162 are really in the library we must leave global to prevent the
6163 linker dragging in a definition from a static library. */
6164 force_local
= (!fh
->elf
.def_regular
6166 || !fdh
->elf
.def_regular
6167 || fdh
->elf
.forced_local
);
6168 _bfd_elf_link_hash_hide_symbol (info
, &fh
->elf
, force_local
);
6173 static const struct sfpr_def_parms save_res_funcs
[] =
6175 { "_savegpr0_", 14, 31, savegpr0
, savegpr0_tail
},
6176 { "_restgpr0_", 14, 29, restgpr0
, restgpr0_tail
},
6177 { "_restgpr0_", 30, 31, restgpr0
, restgpr0_tail
},
6178 { "_savegpr1_", 14, 31, savegpr1
, savegpr1_tail
},
6179 { "_restgpr1_", 14, 31, restgpr1
, restgpr1_tail
},
6180 { "_savefpr_", 14, 31, savefpr
, savefpr0_tail
},
6181 { "_restfpr_", 14, 29, restfpr
, restfpr0_tail
},
6182 { "_restfpr_", 30, 31, restfpr
, restfpr0_tail
},
6183 { "._savef", 14, 31, savefpr
, savefpr1_tail
},
6184 { "._restf", 14, 31, restfpr
, restfpr1_tail
},
6185 { "_savevr_", 20, 31, savevr
, savevr_tail
},
6186 { "_restvr_", 20, 31, restvr
, restvr_tail
}
6189 /* Called near the start of bfd_elf_size_dynamic_sections. We use
6190 this hook to a) provide some gcc support functions, and b) transfer
6191 dynamic linking information gathered so far on function code symbol
6192 entries, to their corresponding function descriptor symbol entries. */
6195 ppc64_elf_func_desc_adjust (bfd
*obfd ATTRIBUTE_UNUSED
,
6196 struct bfd_link_info
*info
)
6198 struct ppc_link_hash_table
*htab
;
6200 htab
= ppc_hash_table (info
);
6204 /* Provide any missing _save* and _rest* functions. */
6205 if (htab
->sfpr
!= NULL
)
6209 htab
->sfpr
->size
= 0;
6210 for (i
= 0; i
< ARRAY_SIZE (save_res_funcs
); i
++)
6211 if (!sfpr_define (info
, &save_res_funcs
[i
], NULL
))
6213 if (htab
->sfpr
->size
== 0)
6214 htab
->sfpr
->flags
|= SEC_EXCLUDE
;
6217 if (bfd_link_relocatable (info
))
6220 if (htab
->elf
.hgot
!= NULL
)
6222 _bfd_elf_link_hash_hide_symbol (info
, htab
->elf
.hgot
, TRUE
);
6223 /* Make .TOC. defined so as to prevent it being made dynamic.
6224 The wrong value here is fixed later in ppc64_elf_set_toc. */
6225 if (!htab
->elf
.hgot
->def_regular
6226 || htab
->elf
.hgot
->root
.type
!= bfd_link_hash_defined
)
6228 htab
->elf
.hgot
->root
.type
= bfd_link_hash_defined
;
6229 htab
->elf
.hgot
->root
.u
.def
.value
= 0;
6230 htab
->elf
.hgot
->root
.u
.def
.section
= bfd_abs_section_ptr
;
6231 htab
->elf
.hgot
->def_regular
= 1;
6232 htab
->elf
.hgot
->root
.linker_def
= 1;
6234 htab
->elf
.hgot
->type
= STT_OBJECT
;
6235 htab
->elf
.hgot
->other
6236 = (htab
->elf
.hgot
->other
& ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN
;
6239 if (htab
->need_func_desc_adj
)
6241 elf_link_hash_traverse (&htab
->elf
, func_desc_adjust
, info
);
6242 htab
->need_func_desc_adj
= 0;
6248 /* Find dynamic relocs for H that apply to read-only sections. */
6251 readonly_dynrelocs (struct elf_link_hash_entry
*h
)
6253 struct ppc_link_hash_entry
*eh
;
6254 struct elf_dyn_relocs
*p
;
6256 eh
= (struct ppc_link_hash_entry
*) h
;
6257 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
6259 asection
*s
= p
->sec
->output_section
;
6261 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
6267 /* Return true if we have dynamic relocs against H or any of its weak
6268 aliases, that apply to read-only sections. Cannot be used after
6269 size_dynamic_sections. */
6272 alias_readonly_dynrelocs (struct elf_link_hash_entry
*h
)
6274 struct ppc_link_hash_entry
*eh
;
6276 eh
= (struct ppc_link_hash_entry
*) h
;
6279 if (readonly_dynrelocs (&eh
->elf
))
6281 eh
= (struct ppc_link_hash_entry
*) eh
->elf
.u
.alias
;
6283 while (eh
!= NULL
&& &eh
->elf
!= h
);
6288 /* Return whether EH has pc-relative dynamic relocs. */
6291 pc_dynrelocs (struct ppc_link_hash_entry
*eh
)
6293 struct elf_dyn_relocs
*p
;
6295 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
6296 if (p
->pc_count
!= 0)
6301 /* Return true if a global entry stub will be created for H. Valid
6302 for ELFv2 before plt entries have been allocated. */
6305 global_entry_stub (struct elf_link_hash_entry
*h
)
6307 struct plt_entry
*pent
;
6309 if (!h
->pointer_equality_needed
6313 for (pent
= h
->plt
.plist
; pent
!= NULL
; pent
= pent
->next
)
6314 if (pent
->plt
.refcount
> 0
6315 && pent
->addend
== 0)
6321 /* Adjust a symbol defined by a dynamic object and referenced by a
6322 regular object. The current definition is in some section of the
6323 dynamic object, but we're not including those sections. We have to
6324 change the definition to something the rest of the link can
6328 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
6329 struct elf_link_hash_entry
*h
)
6331 struct ppc_link_hash_table
*htab
;
6334 htab
= ppc_hash_table (info
);
6338 /* Deal with function syms. */
6339 if (h
->type
== STT_FUNC
6340 || h
->type
== STT_GNU_IFUNC
6343 bfd_boolean local
= (((struct ppc_link_hash_entry
*) h
)->save_res
6344 || SYMBOL_CALLS_LOCAL (info
, h
)
6345 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
));
6346 /* Discard dyn_relocs when non-pic if we've decided that a
6347 function symbol is local and not an ifunc. We keep dynamic
6348 relocs for ifuncs when local rather than always emitting a
6349 plt call stub for them and defining the symbol on the call
6350 stub. We can't do that for ELFv1 anyway (a function symbol
6351 is defined on a descriptor, not code) and it can be faster at
6352 run-time due to not needing to bounce through a stub. The
6353 dyn_relocs for ifuncs will be applied even in a static
6355 if (!bfd_link_pic (info
)
6356 && h
->type
!= STT_GNU_IFUNC
6358 ((struct ppc_link_hash_entry
*) h
)->dyn_relocs
= NULL
;
6360 /* Clear procedure linkage table information for any symbol that
6361 won't need a .plt entry. */
6362 struct plt_entry
*ent
;
6363 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
6364 if (ent
->plt
.refcount
> 0)
6367 || (h
->type
!= STT_GNU_IFUNC
6369 && (htab
->can_convert_all_inline_plt
6370 || (((struct ppc_link_hash_entry
*) h
)->tls_mask
6371 & (TLS_TLS
| PLT_KEEP
)) != PLT_KEEP
)))
6373 h
->plt
.plist
= NULL
;
6375 h
->pointer_equality_needed
= 0;
6377 else if (abiversion (info
->output_bfd
) >= 2)
6379 /* Taking a function's address in a read/write section
6380 doesn't require us to define the function symbol in the
6381 executable on a global entry stub. A dynamic reloc can
6382 be used instead. The reason we prefer a few more dynamic
6383 relocs is that calling via a global entry stub costs a
6384 few more instructions, and pointer_equality_needed causes
6385 extra work in ld.so when resolving these symbols. */
6386 if (global_entry_stub (h
))
6388 if (!readonly_dynrelocs (h
))
6390 h
->pointer_equality_needed
= 0;
6391 /* If we haven't seen a branch reloc and the symbol
6392 isn't an ifunc then we don't need a plt entry. */
6394 h
->plt
.plist
= NULL
;
6396 else if (!bfd_link_pic (info
))
6397 /* We are going to be defining the function symbol on the
6398 plt stub, so no dyn_relocs needed when non-pic. */
6399 ((struct ppc_link_hash_entry
*) h
)->dyn_relocs
= NULL
;
6402 /* ELFv2 function symbols can't have copy relocs. */
6405 else if (!h
->needs_plt
6406 && !readonly_dynrelocs (h
))
6408 /* If we haven't seen a branch reloc and the symbol isn't an
6409 ifunc then we don't need a plt entry. */
6410 h
->plt
.plist
= NULL
;
6411 h
->pointer_equality_needed
= 0;
6416 h
->plt
.plist
= NULL
;
6418 /* If this is a weak symbol, and there is a real definition, the
6419 processor independent code will have arranged for us to see the
6420 real definition first, and we can just use the same value. */
6421 if (h
->is_weakalias
)
6423 struct elf_link_hash_entry
*def
= weakdef (h
);
6424 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
6425 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
6426 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
6427 if (def
->root
.u
.def
.section
== htab
->elf
.sdynbss
6428 || def
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
6429 ((struct ppc_link_hash_entry
*) h
)->dyn_relocs
= NULL
;
6433 /* If we are creating a shared library, we must presume that the
6434 only references to the symbol are via the global offset table.
6435 For such cases we need not do anything here; the relocations will
6436 be handled correctly by relocate_section. */
6437 if (!bfd_link_executable (info
))
6440 /* If there are no references to this symbol that do not use the
6441 GOT, we don't need to generate a copy reloc. */
6442 if (!h
->non_got_ref
)
6445 /* Don't generate a copy reloc for symbols defined in the executable. */
6446 if (!h
->def_dynamic
|| !h
->ref_regular
|| h
->def_regular
6448 /* If -z nocopyreloc was given, don't generate them either. */
6449 || info
->nocopyreloc
6451 /* If we don't find any dynamic relocs in read-only sections, then
6452 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
6453 || (ELIMINATE_COPY_RELOCS
6455 && !alias_readonly_dynrelocs (h
))
6457 /* Protected variables do not work with .dynbss. The copy in
6458 .dynbss won't be used by the shared library with the protected
6459 definition for the variable. Text relocations are preferable
6460 to an incorrect program. */
6461 || h
->protected_def
)
6464 if (h
->plt
.plist
!= NULL
)
6466 /* We should never get here, but unfortunately there are versions
6467 of gcc out there that improperly (for this ABI) put initialized
6468 function pointers, vtable refs and suchlike in read-only
6469 sections. Allow them to proceed, but warn that this might
6470 break at runtime. */
6471 info
->callbacks
->einfo
6472 (_("%P: copy reloc against `%pT' requires lazy plt linking; "
6473 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
6474 h
->root
.root
.string
);
6477 /* This is a reference to a symbol defined by a dynamic object which
6478 is not a function. */
6480 /* We must allocate the symbol in our .dynbss section, which will
6481 become part of the .bss section of the executable. There will be
6482 an entry for this symbol in the .dynsym section. The dynamic
6483 object will contain position independent code, so all references
6484 from the dynamic object to this symbol will go through the global
6485 offset table. The dynamic linker will use the .dynsym entry to
6486 determine the address it must put in the global offset table, so
6487 both the dynamic object and the regular object will refer to the
6488 same memory location for the variable. */
6489 if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
6491 s
= htab
->elf
.sdynrelro
;
6492 srel
= htab
->elf
.sreldynrelro
;
6496 s
= htab
->elf
.sdynbss
;
6497 srel
= htab
->elf
.srelbss
;
6499 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
6501 /* We must generate a R_PPC64_COPY reloc to tell the dynamic
6502 linker to copy the initial value out of the dynamic object
6503 and into the runtime process image. */
6504 srel
->size
+= sizeof (Elf64_External_Rela
);
6508 /* We no longer want dyn_relocs. */
6509 ((struct ppc_link_hash_entry
*) h
)->dyn_relocs
= NULL
;
6510 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
6513 /* If given a function descriptor symbol, hide both the function code
6514 sym and the descriptor. */
6516 ppc64_elf_hide_symbol (struct bfd_link_info
*info
,
6517 struct elf_link_hash_entry
*h
,
6518 bfd_boolean force_local
)
6520 struct ppc_link_hash_entry
*eh
;
6521 _bfd_elf_link_hash_hide_symbol (info
, h
, force_local
);
6523 if (ppc_hash_table (info
) == NULL
)
6526 eh
= (struct ppc_link_hash_entry
*) h
;
6527 if (eh
->is_func_descriptor
)
6529 struct ppc_link_hash_entry
*fh
= eh
->oh
;
6534 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
6537 /* We aren't supposed to use alloca in BFD because on
6538 systems which do not have alloca the version in libiberty
6539 calls xmalloc, which might cause the program to crash
6540 when it runs out of memory. This function doesn't have a
6541 return status, so there's no way to gracefully return an
6542 error. So cheat. We know that string[-1] can be safely
6543 accessed; It's either a string in an ELF string table,
6544 or allocated in an objalloc structure. */
6546 p
= eh
->elf
.root
.root
.string
- 1;
6549 fh
= (struct ppc_link_hash_entry
*)
6550 elf_link_hash_lookup (htab
, p
, FALSE
, FALSE
, FALSE
);
6553 /* Unfortunately, if it so happens that the string we were
6554 looking for was allocated immediately before this string,
6555 then we overwrote the string terminator. That's the only
6556 reason the lookup should fail. */
6559 q
= eh
->elf
.root
.root
.string
+ strlen (eh
->elf
.root
.root
.string
);
6560 while (q
>= eh
->elf
.root
.root
.string
&& *q
== *p
)
6562 if (q
< eh
->elf
.root
.root
.string
&& *p
== '.')
6563 fh
= (struct ppc_link_hash_entry
*)
6564 elf_link_hash_lookup (htab
, p
, FALSE
, FALSE
, FALSE
);
6573 _bfd_elf_link_hash_hide_symbol (info
, &fh
->elf
, force_local
);
6578 get_sym_h (struct elf_link_hash_entry
**hp
,
6579 Elf_Internal_Sym
**symp
,
6581 unsigned char **tls_maskp
,
6582 Elf_Internal_Sym
**locsymsp
,
6583 unsigned long r_symndx
,
6586 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (ibfd
);
6588 if (r_symndx
>= symtab_hdr
->sh_info
)
6590 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (ibfd
);
6591 struct elf_link_hash_entry
*h
;
6593 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
6594 h
= elf_follow_link (h
);
6602 if (symsecp
!= NULL
)
6604 asection
*symsec
= NULL
;
6605 if (h
->root
.type
== bfd_link_hash_defined
6606 || h
->root
.type
== bfd_link_hash_defweak
)
6607 symsec
= h
->root
.u
.def
.section
;
6611 if (tls_maskp
!= NULL
)
6613 struct ppc_link_hash_entry
*eh
;
6615 eh
= (struct ppc_link_hash_entry
*) h
;
6616 *tls_maskp
= &eh
->tls_mask
;
6621 Elf_Internal_Sym
*sym
;
6622 Elf_Internal_Sym
*locsyms
= *locsymsp
;
6624 if (locsyms
== NULL
)
6626 locsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
6627 if (locsyms
== NULL
)
6628 locsyms
= bfd_elf_get_elf_syms (ibfd
, symtab_hdr
,
6629 symtab_hdr
->sh_info
,
6630 0, NULL
, NULL
, NULL
);
6631 if (locsyms
== NULL
)
6633 *locsymsp
= locsyms
;
6635 sym
= locsyms
+ r_symndx
;
6643 if (symsecp
!= NULL
)
6644 *symsecp
= bfd_section_from_elf_index (ibfd
, sym
->st_shndx
);
6646 if (tls_maskp
!= NULL
)
6648 struct got_entry
**lgot_ents
;
6649 unsigned char *tls_mask
;
6652 lgot_ents
= elf_local_got_ents (ibfd
);
6653 if (lgot_ents
!= NULL
)
6655 struct plt_entry
**local_plt
= (struct plt_entry
**)
6656 (lgot_ents
+ symtab_hdr
->sh_info
);
6657 unsigned char *lgot_masks
= (unsigned char *)
6658 (local_plt
+ symtab_hdr
->sh_info
);
6659 tls_mask
= &lgot_masks
[r_symndx
];
6661 *tls_maskp
= tls_mask
;
6667 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
6668 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
6669 type suitable for optimization, and 1 otherwise. */
6672 get_tls_mask (unsigned char **tls_maskp
,
6673 unsigned long *toc_symndx
,
6674 bfd_vma
*toc_addend
,
6675 Elf_Internal_Sym
**locsymsp
,
6676 const Elf_Internal_Rela
*rel
,
6679 unsigned long r_symndx
;
6681 struct elf_link_hash_entry
*h
;
6682 Elf_Internal_Sym
*sym
;
6686 r_symndx
= ELF64_R_SYM (rel
->r_info
);
6687 if (!get_sym_h (&h
, &sym
, &sec
, tls_maskp
, locsymsp
, r_symndx
, ibfd
))
6690 if ((*tls_maskp
!= NULL
6691 && (**tls_maskp
& TLS_TLS
) != 0
6692 && **tls_maskp
!= (TLS_TLS
| TLS_MARK
))
6694 || ppc64_elf_section_data (sec
) == NULL
6695 || ppc64_elf_section_data (sec
)->sec_type
!= sec_toc
)
6698 /* Look inside a TOC section too. */
6701 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
);
6702 off
= h
->root
.u
.def
.value
;
6705 off
= sym
->st_value
;
6706 off
+= rel
->r_addend
;
6707 BFD_ASSERT (off
% 8 == 0);
6708 r_symndx
= ppc64_elf_section_data (sec
)->u
.toc
.symndx
[off
/ 8];
6709 next_r
= ppc64_elf_section_data (sec
)->u
.toc
.symndx
[off
/ 8 + 1];
6710 if (toc_symndx
!= NULL
)
6711 *toc_symndx
= r_symndx
;
6712 if (toc_addend
!= NULL
)
6713 *toc_addend
= ppc64_elf_section_data (sec
)->u
.toc
.add
[off
/ 8];
6714 if (!get_sym_h (&h
, &sym
, &sec
, tls_maskp
, locsymsp
, r_symndx
, ibfd
))
6716 if ((h
== NULL
|| is_static_defined (h
))
6717 && (next_r
== -1 || next_r
== -2))
6722 /* Find (or create) an entry in the tocsave hash table. */
6724 static struct tocsave_entry
*
6725 tocsave_find (struct ppc_link_hash_table
*htab
,
6726 enum insert_option insert
,
6727 Elf_Internal_Sym
**local_syms
,
6728 const Elf_Internal_Rela
*irela
,
6731 unsigned long r_indx
;
6732 struct elf_link_hash_entry
*h
;
6733 Elf_Internal_Sym
*sym
;
6734 struct tocsave_entry ent
, *p
;
6736 struct tocsave_entry
**slot
;
6738 r_indx
= ELF64_R_SYM (irela
->r_info
);
6739 if (!get_sym_h (&h
, &sym
, &ent
.sec
, NULL
, local_syms
, r_indx
, ibfd
))
6741 if (ent
.sec
== NULL
|| ent
.sec
->output_section
== NULL
)
6744 (_("%pB: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd
);
6749 ent
.offset
= h
->root
.u
.def
.value
;
6751 ent
.offset
= sym
->st_value
;
6752 ent
.offset
+= irela
->r_addend
;
6754 hash
= tocsave_htab_hash (&ent
);
6755 slot
= ((struct tocsave_entry
**)
6756 htab_find_slot_with_hash (htab
->tocsave_htab
, &ent
, hash
, insert
));
6762 p
= (struct tocsave_entry
*) bfd_alloc (ibfd
, sizeof (*p
));
6771 /* Adjust all global syms defined in opd sections. In gcc generated
6772 code for the old ABI, these will already have been done. */
6775 adjust_opd_syms (struct elf_link_hash_entry
*h
, void *inf ATTRIBUTE_UNUSED
)
6777 struct ppc_link_hash_entry
*eh
;
6779 struct _opd_sec_data
*opd
;
6781 if (h
->root
.type
== bfd_link_hash_indirect
)
6784 if (h
->root
.type
!= bfd_link_hash_defined
6785 && h
->root
.type
!= bfd_link_hash_defweak
)
6788 eh
= (struct ppc_link_hash_entry
*) h
;
6789 if (eh
->adjust_done
)
6792 sym_sec
= eh
->elf
.root
.u
.def
.section
;
6793 opd
= get_opd_info (sym_sec
);
6794 if (opd
!= NULL
&& opd
->adjust
!= NULL
)
6796 long adjust
= opd
->adjust
[OPD_NDX (eh
->elf
.root
.u
.def
.value
)];
6799 /* This entry has been deleted. */
6800 asection
*dsec
= ppc64_elf_tdata (sym_sec
->owner
)->deleted_section
;
6803 for (dsec
= sym_sec
->owner
->sections
; dsec
; dsec
= dsec
->next
)
6804 if (discarded_section (dsec
))
6806 ppc64_elf_tdata (sym_sec
->owner
)->deleted_section
= dsec
;
6810 eh
->elf
.root
.u
.def
.value
= 0;
6811 eh
->elf
.root
.u
.def
.section
= dsec
;
6814 eh
->elf
.root
.u
.def
.value
+= adjust
;
6815 eh
->adjust_done
= 1;
6820 /* Handles decrementing dynamic reloc counts for the reloc specified by
6821 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
6822 have already been determined. */
6825 dec_dynrel_count (bfd_vma r_info
,
6827 struct bfd_link_info
*info
,
6828 Elf_Internal_Sym
**local_syms
,
6829 struct elf_link_hash_entry
*h
,
6830 Elf_Internal_Sym
*sym
)
6832 enum elf_ppc64_reloc_type r_type
;
6833 asection
*sym_sec
= NULL
;
6835 /* Can this reloc be dynamic? This switch, and later tests here
6836 should be kept in sync with the code in check_relocs. */
6837 r_type
= ELF64_R_TYPE (r_info
);
6844 case R_PPC64_TOC16_DS
:
6845 case R_PPC64_TOC16_LO
:
6846 case R_PPC64_TOC16_HI
:
6847 case R_PPC64_TOC16_HA
:
6848 case R_PPC64_TOC16_LO_DS
:
6853 case R_PPC64_TPREL16
:
6854 case R_PPC64_TPREL16_LO
:
6855 case R_PPC64_TPREL16_HI
:
6856 case R_PPC64_TPREL16_HA
:
6857 case R_PPC64_TPREL16_DS
:
6858 case R_PPC64_TPREL16_LO_DS
:
6859 case R_PPC64_TPREL16_HIGH
:
6860 case R_PPC64_TPREL16_HIGHA
:
6861 case R_PPC64_TPREL16_HIGHER
:
6862 case R_PPC64_TPREL16_HIGHERA
:
6863 case R_PPC64_TPREL16_HIGHEST
:
6864 case R_PPC64_TPREL16_HIGHESTA
:
6865 case R_PPC64_TPREL64
:
6866 case R_PPC64_TPREL34
:
6867 case R_PPC64_DTPMOD64
:
6868 case R_PPC64_DTPREL64
:
6869 case R_PPC64_ADDR64
:
6873 case R_PPC64_ADDR14
:
6874 case R_PPC64_ADDR14_BRNTAKEN
:
6875 case R_PPC64_ADDR14_BRTAKEN
:
6876 case R_PPC64_ADDR16
:
6877 case R_PPC64_ADDR16_DS
:
6878 case R_PPC64_ADDR16_HA
:
6879 case R_PPC64_ADDR16_HI
:
6880 case R_PPC64_ADDR16_HIGH
:
6881 case R_PPC64_ADDR16_HIGHA
:
6882 case R_PPC64_ADDR16_HIGHER
:
6883 case R_PPC64_ADDR16_HIGHERA
:
6884 case R_PPC64_ADDR16_HIGHEST
:
6885 case R_PPC64_ADDR16_HIGHESTA
:
6886 case R_PPC64_ADDR16_LO
:
6887 case R_PPC64_ADDR16_LO_DS
:
6888 case R_PPC64_ADDR24
:
6889 case R_PPC64_ADDR32
:
6890 case R_PPC64_UADDR16
:
6891 case R_PPC64_UADDR32
:
6892 case R_PPC64_UADDR64
:
6895 case R_PPC64_D34_LO
:
6896 case R_PPC64_D34_HI30
:
6897 case R_PPC64_D34_HA30
:
6898 case R_PPC64_ADDR16_HIGHER34
:
6899 case R_PPC64_ADDR16_HIGHERA34
:
6900 case R_PPC64_ADDR16_HIGHEST34
:
6901 case R_PPC64_ADDR16_HIGHESTA34
:
6906 if (local_syms
!= NULL
)
6908 unsigned long r_symndx
;
6909 bfd
*ibfd
= sec
->owner
;
6911 r_symndx
= ELF64_R_SYM (r_info
);
6912 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, local_syms
, r_symndx
, ibfd
))
6917 && (h
->root
.type
== bfd_link_hash_defweak
6918 || !h
->def_regular
))
6920 && !bfd_link_executable (info
)
6921 && !SYMBOLIC_BIND (info
, h
))
6922 || (bfd_link_pic (info
)
6923 && must_be_dyn_reloc (info
, r_type
))
6924 || (!bfd_link_pic (info
)
6926 ? h
->type
== STT_GNU_IFUNC
6927 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)))
6934 struct elf_dyn_relocs
*p
;
6935 struct elf_dyn_relocs
**pp
;
6936 pp
= &((struct ppc_link_hash_entry
*) h
)->dyn_relocs
;
6938 /* elf_gc_sweep may have already removed all dyn relocs associated
6939 with local syms for a given section. Also, symbol flags are
6940 changed by elf_gc_sweep_symbol, confusing the test above. Don't
6941 report a dynreloc miscount. */
6942 if (*pp
== NULL
&& info
->gc_sections
)
6945 while ((p
= *pp
) != NULL
)
6949 if (!must_be_dyn_reloc (info
, r_type
))
6961 struct ppc_dyn_relocs
*p
;
6962 struct ppc_dyn_relocs
**pp
;
6964 bfd_boolean is_ifunc
;
6966 if (local_syms
== NULL
)
6967 sym_sec
= bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
6968 if (sym_sec
== NULL
)
6971 vpp
= &elf_section_data (sym_sec
)->local_dynrel
;
6972 pp
= (struct ppc_dyn_relocs
**) vpp
;
6974 if (*pp
== NULL
&& info
->gc_sections
)
6977 is_ifunc
= ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
;
6978 while ((p
= *pp
) != NULL
)
6980 if (p
->sec
== sec
&& p
->ifunc
== is_ifunc
)
6991 /* xgettext:c-format */
6992 _bfd_error_handler (_("dynreloc miscount for %pB, section %pA"),
6994 bfd_set_error (bfd_error_bad_value
);
6998 /* Remove unused Official Procedure Descriptor entries. Currently we
6999 only remove those associated with functions in discarded link-once
7000 sections, or weakly defined functions that have been overridden. It
7001 would be possible to remove many more entries for statically linked
7005 ppc64_elf_edit_opd (struct bfd_link_info
*info
)
7008 bfd_boolean some_edited
= FALSE
;
7009 asection
*need_pad
= NULL
;
7010 struct ppc_link_hash_table
*htab
;
7012 htab
= ppc_hash_table (info
);
7016 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
7019 Elf_Internal_Rela
*relstart
, *rel
, *relend
;
7020 Elf_Internal_Shdr
*symtab_hdr
;
7021 Elf_Internal_Sym
*local_syms
;
7022 struct _opd_sec_data
*opd
;
7023 bfd_boolean need_edit
, add_aux_fields
, broken
;
7024 bfd_size_type cnt_16b
= 0;
7026 if (!is_ppc64_elf (ibfd
))
7029 sec
= bfd_get_section_by_name (ibfd
, ".opd");
7030 if (sec
== NULL
|| sec
->size
== 0)
7033 if (sec
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
7036 if (sec
->output_section
== bfd_abs_section_ptr
)
7039 /* Look through the section relocs. */
7040 if ((sec
->flags
& SEC_RELOC
) == 0 || sec
->reloc_count
== 0)
7044 symtab_hdr
= &elf_symtab_hdr (ibfd
);
7046 /* Read the relocations. */
7047 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
7049 if (relstart
== NULL
)
7052 /* First run through the relocs to check they are sane, and to
7053 determine whether we need to edit this opd section. */
7057 relend
= relstart
+ sec
->reloc_count
;
7058 for (rel
= relstart
; rel
< relend
; )
7060 enum elf_ppc64_reloc_type r_type
;
7061 unsigned long r_symndx
;
7063 struct elf_link_hash_entry
*h
;
7064 Elf_Internal_Sym
*sym
;
7067 /* .opd contains an array of 16 or 24 byte entries. We're
7068 only interested in the reloc pointing to a function entry
7070 offset
= rel
->r_offset
;
7071 if (rel
+ 1 == relend
7072 || rel
[1].r_offset
!= offset
+ 8)
7074 /* If someone messes with .opd alignment then after a
7075 "ld -r" we might have padding in the middle of .opd.
7076 Also, there's nothing to prevent someone putting
7077 something silly in .opd with the assembler. No .opd
7078 optimization for them! */
7081 (_("%pB: .opd is not a regular array of opd entries"), ibfd
);
7086 if ((r_type
= ELF64_R_TYPE (rel
->r_info
)) != R_PPC64_ADDR64
7087 || (r_type
= ELF64_R_TYPE ((rel
+ 1)->r_info
)) != R_PPC64_TOC
)
7090 /* xgettext:c-format */
7091 (_("%pB: unexpected reloc type %u in .opd section"),
7097 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7098 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
7102 if (sym_sec
== NULL
|| sym_sec
->owner
== NULL
)
7104 const char *sym_name
;
7106 sym_name
= h
->root
.root
.string
;
7108 sym_name
= bfd_elf_sym_name (ibfd
, symtab_hdr
, sym
,
7112 /* xgettext:c-format */
7113 (_("%pB: undefined sym `%s' in .opd section"),
7119 /* opd entries are always for functions defined in the
7120 current input bfd. If the symbol isn't defined in the
7121 input bfd, then we won't be using the function in this
7122 bfd; It must be defined in a linkonce section in another
7123 bfd, or is weak. It's also possible that we are
7124 discarding the function due to a linker script /DISCARD/,
7125 which we test for via the output_section. */
7126 if (sym_sec
->owner
!= ibfd
7127 || sym_sec
->output_section
== bfd_abs_section_ptr
)
7131 if (rel
+ 1 == relend
7132 || (rel
+ 2 < relend
7133 && ELF64_R_TYPE (rel
[2].r_info
) == R_PPC64_TOC
))
7138 if (sec
->size
== offset
+ 24)
7143 if (sec
->size
== offset
+ 16)
7150 else if (rel
+ 1 < relend
7151 && ELF64_R_TYPE (rel
[0].r_info
) == R_PPC64_ADDR64
7152 && ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_TOC
)
7154 if (rel
[0].r_offset
== offset
+ 16)
7156 else if (rel
[0].r_offset
!= offset
+ 24)
7163 add_aux_fields
= htab
->params
->non_overlapping_opd
&& cnt_16b
> 0;
7165 if (!broken
&& (need_edit
|| add_aux_fields
))
7167 Elf_Internal_Rela
*write_rel
;
7168 Elf_Internal_Shdr
*rel_hdr
;
7169 bfd_byte
*rptr
, *wptr
;
7170 bfd_byte
*new_contents
;
7173 new_contents
= NULL
;
7174 amt
= OPD_NDX (sec
->size
) * sizeof (long);
7175 opd
= &ppc64_elf_section_data (sec
)->u
.opd
;
7176 opd
->adjust
= bfd_zalloc (sec
->owner
, amt
);
7177 if (opd
->adjust
== NULL
)
7180 /* This seems a waste of time as input .opd sections are all
7181 zeros as generated by gcc, but I suppose there's no reason
7182 this will always be so. We might start putting something in
7183 the third word of .opd entries. */
7184 if ((sec
->flags
& SEC_IN_MEMORY
) == 0)
7187 if (!bfd_malloc_and_get_section (ibfd
, sec
, &loc
))
7192 if (local_syms
!= NULL
7193 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
7195 if (elf_section_data (sec
)->relocs
!= relstart
)
7199 sec
->contents
= loc
;
7200 sec
->flags
|= (SEC_IN_MEMORY
| SEC_HAS_CONTENTS
);
7203 elf_section_data (sec
)->relocs
= relstart
;
7205 new_contents
= sec
->contents
;
7208 new_contents
= bfd_malloc (sec
->size
+ cnt_16b
* 8);
7209 if (new_contents
== NULL
)
7213 wptr
= new_contents
;
7214 rptr
= sec
->contents
;
7215 write_rel
= relstart
;
7216 for (rel
= relstart
; rel
< relend
; )
7218 unsigned long r_symndx
;
7220 struct elf_link_hash_entry
*h
;
7221 struct ppc_link_hash_entry
*fdh
= NULL
;
7222 Elf_Internal_Sym
*sym
;
7224 Elf_Internal_Rela
*next_rel
;
7227 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7228 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
7233 if (next_rel
+ 1 == relend
7234 || (next_rel
+ 2 < relend
7235 && ELF64_R_TYPE (next_rel
[2].r_info
) == R_PPC64_TOC
))
7238 /* See if the .opd entry is full 24 byte or
7239 16 byte (with fd_aux entry overlapped with next
7242 if (next_rel
== relend
)
7244 if (sec
->size
== rel
->r_offset
+ 16)
7247 else if (next_rel
->r_offset
== rel
->r_offset
+ 16)
7251 && h
->root
.root
.string
[0] == '.')
7253 fdh
= ((struct ppc_link_hash_entry
*) h
)->oh
;
7256 fdh
= ppc_follow_link (fdh
);
7257 if (fdh
->elf
.root
.type
!= bfd_link_hash_defined
7258 && fdh
->elf
.root
.type
!= bfd_link_hash_defweak
)
7263 skip
= (sym_sec
->owner
!= ibfd
7264 || sym_sec
->output_section
== bfd_abs_section_ptr
);
7267 if (fdh
!= NULL
&& sym_sec
->owner
== ibfd
)
7269 /* Arrange for the function descriptor sym
7271 fdh
->elf
.root
.u
.def
.value
= 0;
7272 fdh
->elf
.root
.u
.def
.section
= sym_sec
;
7274 opd
->adjust
[OPD_NDX (rel
->r_offset
)] = -1;
7276 if (NO_OPD_RELOCS
|| bfd_link_relocatable (info
))
7281 if (!dec_dynrel_count (rel
->r_info
, sec
, info
,
7285 if (++rel
== next_rel
)
7288 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7289 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
7296 /* We'll be keeping this opd entry. */
7301 /* Redefine the function descriptor symbol to
7302 this location in the opd section. It is
7303 necessary to update the value here rather
7304 than using an array of adjustments as we do
7305 for local symbols, because various places
7306 in the generic ELF code use the value
7307 stored in u.def.value. */
7308 fdh
->elf
.root
.u
.def
.value
= wptr
- new_contents
;
7309 fdh
->adjust_done
= 1;
7312 /* Local syms are a bit tricky. We could
7313 tweak them as they can be cached, but
7314 we'd need to look through the local syms
7315 for the function descriptor sym which we
7316 don't have at the moment. So keep an
7317 array of adjustments. */
7318 adjust
= (wptr
- new_contents
) - (rptr
- sec
->contents
);
7319 opd
->adjust
[OPD_NDX (rel
->r_offset
)] = adjust
;
7322 memcpy (wptr
, rptr
, opd_ent_size
);
7323 wptr
+= opd_ent_size
;
7324 if (add_aux_fields
&& opd_ent_size
== 16)
7326 memset (wptr
, '\0', 8);
7330 /* We need to adjust any reloc offsets to point to the
7332 for ( ; rel
!= next_rel
; ++rel
)
7334 rel
->r_offset
+= adjust
;
7335 if (write_rel
!= rel
)
7336 memcpy (write_rel
, rel
, sizeof (*rel
));
7341 rptr
+= opd_ent_size
;
7344 sec
->size
= wptr
- new_contents
;
7345 sec
->reloc_count
= write_rel
- relstart
;
7348 free (sec
->contents
);
7349 sec
->contents
= new_contents
;
7352 /* Fudge the header size too, as this is used later in
7353 elf_bfd_final_link if we are emitting relocs. */
7354 rel_hdr
= _bfd_elf_single_rel_hdr (sec
);
7355 rel_hdr
->sh_size
= sec
->reloc_count
* rel_hdr
->sh_entsize
;
7358 else if (elf_section_data (sec
)->relocs
!= relstart
)
7361 if (local_syms
!= NULL
7362 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
7364 if (!info
->keep_memory
)
7367 symtab_hdr
->contents
= (unsigned char *) local_syms
;
7372 elf_link_hash_traverse (elf_hash_table (info
), adjust_opd_syms
, NULL
);
7374 /* If we are doing a final link and the last .opd entry is just 16 byte
7375 long, add a 8 byte padding after it. */
7376 if (need_pad
!= NULL
&& !bfd_link_relocatable (info
))
7380 if ((need_pad
->flags
& SEC_IN_MEMORY
) == 0)
7382 BFD_ASSERT (need_pad
->size
> 0);
7384 p
= bfd_malloc (need_pad
->size
+ 8);
7388 if (!bfd_get_section_contents (need_pad
->owner
, need_pad
,
7389 p
, 0, need_pad
->size
))
7392 need_pad
->contents
= p
;
7393 need_pad
->flags
|= (SEC_IN_MEMORY
| SEC_HAS_CONTENTS
);
7397 p
= bfd_realloc (need_pad
->contents
, need_pad
->size
+ 8);
7401 need_pad
->contents
= p
;
7404 memset (need_pad
->contents
+ need_pad
->size
, 0, 8);
7405 need_pad
->size
+= 8;
7411 /* Analyze inline PLT call relocations to see whether calls to locally
7412 defined functions can be converted to direct calls. */
7415 ppc64_elf_inline_plt (struct bfd_link_info
*info
)
7417 struct ppc_link_hash_table
*htab
;
7420 bfd_vma low_vma
, high_vma
, limit
;
7422 htab
= ppc_hash_table (info
);
7426 /* A bl insn can reach -0x2000000 to 0x1fffffc. The limit is
7427 reduced somewhat to cater for possible stubs that might be added
7428 between the call and its destination. */
7429 if (htab
->params
->group_size
< 0)
7431 limit
= -htab
->params
->group_size
;
7437 limit
= htab
->params
->group_size
;
7444 for (sec
= info
->output_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7445 if ((sec
->flags
& (SEC_ALLOC
| SEC_CODE
)) == (SEC_ALLOC
| SEC_CODE
))
7447 if (low_vma
> sec
->vma
)
7449 if (high_vma
< sec
->vma
+ sec
->size
)
7450 high_vma
= sec
->vma
+ sec
->size
;
7453 /* If a "bl" can reach anywhere in local code sections, then we can
7454 convert all inline PLT sequences to direct calls when the symbol
7456 if (high_vma
- low_vma
< limit
)
7458 htab
->can_convert_all_inline_plt
= 1;
7462 /* Otherwise, go looking through relocs for cases where a direct
7463 call won't reach. Mark the symbol on any such reloc to disable
7464 the optimization and keep the PLT entry as it seems likely that
7465 this will be better than creating trampolines. Note that this
7466 will disable the optimization for all inline PLT calls to a
7467 particular symbol, not just those that won't reach. The
7468 difficulty in doing a more precise optimization is that the
7469 linker needs to make a decision depending on whether a
7470 particular R_PPC64_PLTCALL insn can be turned into a direct
7471 call, for each of the R_PPC64_PLTSEQ and R_PPC64_PLT16* insns in
7472 the sequence, and there is nothing that ties those relocs
7473 together except their symbol. */
7475 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
7477 Elf_Internal_Shdr
*symtab_hdr
;
7478 Elf_Internal_Sym
*local_syms
;
7480 if (!is_ppc64_elf (ibfd
))
7484 symtab_hdr
= &elf_symtab_hdr (ibfd
);
7486 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7487 if (ppc64_elf_section_data (sec
)->has_pltcall
7488 && !bfd_is_abs_section (sec
->output_section
))
7490 Elf_Internal_Rela
*relstart
, *rel
, *relend
;
7492 /* Read the relocations. */
7493 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
7495 if (relstart
== NULL
)
7498 relend
= relstart
+ sec
->reloc_count
;
7499 for (rel
= relstart
; rel
< relend
; )
7501 enum elf_ppc64_reloc_type r_type
;
7502 unsigned long r_symndx
;
7504 struct elf_link_hash_entry
*h
;
7505 Elf_Internal_Sym
*sym
;
7506 unsigned char *tls_maskp
;
7508 r_type
= ELF64_R_TYPE (rel
->r_info
);
7509 if (r_type
!= R_PPC64_PLTCALL
7510 && r_type
!= R_PPC64_PLTCALL_NOTOC
)
7513 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7514 if (!get_sym_h (&h
, &sym
, &sym_sec
, &tls_maskp
, &local_syms
,
7517 if (elf_section_data (sec
)->relocs
!= relstart
)
7519 if (local_syms
!= NULL
7520 && symtab_hdr
->contents
!= (bfd_byte
*) local_syms
)
7525 if (sym_sec
!= NULL
&& sym_sec
->output_section
!= NULL
)
7529 to
= h
->root
.u
.def
.value
;
7532 to
+= (rel
->r_addend
7533 + sym_sec
->output_offset
7534 + sym_sec
->output_section
->vma
);
7535 from
= (rel
->r_offset
7536 + sec
->output_offset
7537 + sec
->output_section
->vma
);
7538 if (to
- from
+ limit
< 2 * limit
7539 && !(r_type
== R_PPC64_PLTCALL_NOTOC
7540 && (((h
? h
->other
: sym
->st_other
)
7541 & STO_PPC64_LOCAL_MASK
)
7542 > 1 << STO_PPC64_LOCAL_BIT
)))
7543 *tls_maskp
&= ~PLT_KEEP
;
7546 if (elf_section_data (sec
)->relocs
!= relstart
)
7550 if (local_syms
!= NULL
7551 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
7553 if (!info
->keep_memory
)
7556 symtab_hdr
->contents
= (unsigned char *) local_syms
;
7563 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
7566 ppc64_elf_tls_setup (struct bfd_link_info
*info
)
7568 struct ppc_link_hash_table
*htab
;
7570 htab
= ppc_hash_table (info
);
7574 if (abiversion (info
->output_bfd
) == 1)
7577 if (htab
->params
->no_multi_toc
)
7578 htab
->do_multi_toc
= 0;
7579 else if (!htab
->do_multi_toc
)
7580 htab
->params
->no_multi_toc
= 1;
7582 /* Default to --no-plt-localentry, as this option can cause problems
7583 with symbol interposition. For example, glibc libpthread.so and
7584 libc.so duplicate many pthread symbols, with a fallback
7585 implementation in libc.so. In some cases the fallback does more
7586 work than the pthread implementation. __pthread_condattr_destroy
7587 is one such symbol: the libpthread.so implementation is
7588 localentry:0 while the libc.so implementation is localentry:8.
7589 An app that "cleverly" uses dlopen to only load necessary
7590 libraries at runtime may omit loading libpthread.so when not
7591 running multi-threaded, which then results in the libc.so
7592 fallback symbols being used and ld.so complaining. Now there
7593 are workarounds in ld (see non_zero_localentry) to detect the
7594 pthread situation, but that may not be the only case where
7595 --plt-localentry can cause trouble. */
7596 if (htab
->params
->plt_localentry0
< 0)
7597 htab
->params
->plt_localentry0
= 0;
7598 if (htab
->params
->plt_localentry0
7599 && elf_link_hash_lookup (&htab
->elf
, "GLIBC_2.26",
7600 FALSE
, FALSE
, FALSE
) == NULL
)
7602 (_("warning: --plt-localentry is especially dangerous without "
7603 "ld.so support to detect ABI violations"));
7605 htab
->tls_get_addr
= ((struct ppc_link_hash_entry
*)
7606 elf_link_hash_lookup (&htab
->elf
, ".__tls_get_addr",
7607 FALSE
, FALSE
, TRUE
));
7608 /* Move dynamic linking info to the function descriptor sym. */
7609 if (htab
->tls_get_addr
!= NULL
)
7610 func_desc_adjust (&htab
->tls_get_addr
->elf
, info
);
7611 htab
->tls_get_addr_fd
= ((struct ppc_link_hash_entry
*)
7612 elf_link_hash_lookup (&htab
->elf
, "__tls_get_addr",
7613 FALSE
, FALSE
, TRUE
));
7614 if (htab
->params
->tls_get_addr_opt
)
7616 struct elf_link_hash_entry
*opt
, *opt_fd
, *tga
, *tga_fd
;
7618 opt
= elf_link_hash_lookup (&htab
->elf
, ".__tls_get_addr_opt",
7619 FALSE
, FALSE
, TRUE
);
7621 func_desc_adjust (opt
, info
);
7622 opt_fd
= elf_link_hash_lookup (&htab
->elf
, "__tls_get_addr_opt",
7623 FALSE
, FALSE
, TRUE
);
7625 && (opt_fd
->root
.type
== bfd_link_hash_defined
7626 || opt_fd
->root
.type
== bfd_link_hash_defweak
))
7628 /* If glibc supports an optimized __tls_get_addr call stub,
7629 signalled by the presence of __tls_get_addr_opt, and we'll
7630 be calling __tls_get_addr via a plt call stub, then
7631 make __tls_get_addr point to __tls_get_addr_opt. */
7632 tga_fd
= &htab
->tls_get_addr_fd
->elf
;
7633 if (htab
->elf
.dynamic_sections_created
7635 && (tga_fd
->type
== STT_FUNC
7636 || tga_fd
->needs_plt
)
7637 && !(SYMBOL_CALLS_LOCAL (info
, tga_fd
)
7638 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, tga_fd
)))
7640 struct plt_entry
*ent
;
7642 for (ent
= tga_fd
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
7643 if (ent
->plt
.refcount
> 0)
7647 tga_fd
->root
.type
= bfd_link_hash_indirect
;
7648 tga_fd
->root
.u
.i
.link
= &opt_fd
->root
;
7649 ppc64_elf_copy_indirect_symbol (info
, opt_fd
, tga_fd
);
7651 if (opt_fd
->dynindx
!= -1)
7653 /* Use __tls_get_addr_opt in dynamic relocations. */
7654 opt_fd
->dynindx
= -1;
7655 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
7656 opt_fd
->dynstr_index
);
7657 if (!bfd_elf_link_record_dynamic_symbol (info
, opt_fd
))
7660 htab
->tls_get_addr_fd
7661 = (struct ppc_link_hash_entry
*) opt_fd
;
7662 tga
= &htab
->tls_get_addr
->elf
;
7663 if (opt
!= NULL
&& tga
!= NULL
)
7665 tga
->root
.type
= bfd_link_hash_indirect
;
7666 tga
->root
.u
.i
.link
= &opt
->root
;
7667 ppc64_elf_copy_indirect_symbol (info
, opt
, tga
);
7669 _bfd_elf_link_hash_hide_symbol (info
, opt
,
7671 htab
->tls_get_addr
= (struct ppc_link_hash_entry
*) opt
;
7673 htab
->tls_get_addr_fd
->oh
= htab
->tls_get_addr
;
7674 htab
->tls_get_addr_fd
->is_func_descriptor
= 1;
7675 if (htab
->tls_get_addr
!= NULL
)
7677 htab
->tls_get_addr
->oh
= htab
->tls_get_addr_fd
;
7678 htab
->tls_get_addr
->is_func
= 1;
7683 else if (htab
->params
->tls_get_addr_opt
< 0)
7684 htab
->params
->tls_get_addr_opt
= 0;
7686 return _bfd_elf_tls_setup (info
->output_bfd
, info
);
7689 /* Return TRUE iff REL is a branch reloc with a global symbol matching
7693 branch_reloc_hash_match (const bfd
*ibfd
,
7694 const Elf_Internal_Rela
*rel
,
7695 const struct ppc_link_hash_entry
*hash1
,
7696 const struct ppc_link_hash_entry
*hash2
)
7698 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (ibfd
);
7699 enum elf_ppc64_reloc_type r_type
= ELF64_R_TYPE (rel
->r_info
);
7700 unsigned int r_symndx
= ELF64_R_SYM (rel
->r_info
);
7702 if (r_symndx
>= symtab_hdr
->sh_info
&& is_branch_reloc (r_type
))
7704 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (ibfd
);
7705 struct elf_link_hash_entry
*h
;
7707 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
7708 h
= elf_follow_link (h
);
7709 if (h
== &hash1
->elf
|| h
== &hash2
->elf
)
7715 /* Run through all the TLS relocs looking for optimization
7716 opportunities. The linker has been hacked (see ppc64elf.em) to do
7717 a preliminary section layout so that we know the TLS segment
7718 offsets. We can't optimize earlier because some optimizations need
7719 to know the tp offset, and we need to optimize before allocating
7720 dynamic relocations. */
7723 ppc64_elf_tls_optimize (struct bfd_link_info
*info
)
7727 struct ppc_link_hash_table
*htab
;
7728 unsigned char *toc_ref
;
7731 if (!bfd_link_executable (info
))
7734 htab
= ppc_hash_table (info
);
7738 /* Make two passes over the relocs. On the first pass, mark toc
7739 entries involved with tls relocs, and check that tls relocs
7740 involved in setting up a tls_get_addr call are indeed followed by
7741 such a call. If they are not, we can't do any tls optimization.
7742 On the second pass twiddle tls_mask flags to notify
7743 relocate_section that optimization can be done, and adjust got
7744 and plt refcounts. */
7746 for (pass
= 0; pass
< 2; ++pass
)
7747 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
7749 Elf_Internal_Sym
*locsyms
= NULL
;
7750 asection
*toc
= bfd_get_section_by_name (ibfd
, ".toc");
7752 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7753 if (sec
->has_tls_reloc
&& !bfd_is_abs_section (sec
->output_section
))
7755 Elf_Internal_Rela
*relstart
, *rel
, *relend
;
7756 bfd_boolean found_tls_get_addr_arg
= 0;
7758 /* Read the relocations. */
7759 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
7761 if (relstart
== NULL
)
7767 relend
= relstart
+ sec
->reloc_count
;
7768 for (rel
= relstart
; rel
< relend
; rel
++)
7770 enum elf_ppc64_reloc_type r_type
;
7771 unsigned long r_symndx
;
7772 struct elf_link_hash_entry
*h
;
7773 Elf_Internal_Sym
*sym
;
7775 unsigned char *tls_mask
;
7776 unsigned int tls_set
, tls_clear
, tls_type
= 0;
7778 bfd_boolean ok_tprel
, is_local
;
7779 long toc_ref_index
= 0;
7780 int expecting_tls_get_addr
= 0;
7781 bfd_boolean ret
= FALSE
;
7783 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7784 if (!get_sym_h (&h
, &sym
, &sym_sec
, &tls_mask
, &locsyms
,
7788 if (elf_section_data (sec
)->relocs
!= relstart
)
7790 if (toc_ref
!= NULL
)
7793 && (elf_symtab_hdr (ibfd
).contents
7794 != (unsigned char *) locsyms
))
7801 if (h
->root
.type
== bfd_link_hash_defined
7802 || h
->root
.type
== bfd_link_hash_defweak
)
7803 value
= h
->root
.u
.def
.value
;
7804 else if (h
->root
.type
== bfd_link_hash_undefweak
)
7808 found_tls_get_addr_arg
= 0;
7813 /* Symbols referenced by TLS relocs must be of type
7814 STT_TLS. So no need for .opd local sym adjust. */
7815 value
= sym
->st_value
;
7818 is_local
= SYMBOL_REFERENCES_LOCAL (info
, h
);
7822 && h
->root
.type
== bfd_link_hash_undefweak
)
7824 else if (sym_sec
!= NULL
7825 && sym_sec
->output_section
!= NULL
)
7827 value
+= sym_sec
->output_offset
;
7828 value
+= sym_sec
->output_section
->vma
;
7829 value
-= htab
->elf
.tls_sec
->vma
+ TP_OFFSET
;
7830 /* Note that even though the prefix insns
7831 allow a 1<<33 offset we use the same test
7832 as for addis;addi. There may be a mix of
7833 pcrel and non-pcrel code and the decision
7834 to optimise is per symbol, not per TLS
7836 ok_tprel
= value
+ 0x80008000ULL
< 1ULL << 32;
7840 r_type
= ELF64_R_TYPE (rel
->r_info
);
7841 /* If this section has old-style __tls_get_addr calls
7842 without marker relocs, then check that each
7843 __tls_get_addr call reloc is preceded by a reloc
7844 that conceivably belongs to the __tls_get_addr arg
7845 setup insn. If we don't find matching arg setup
7846 relocs, don't do any tls optimization. */
7848 && sec
->nomark_tls_get_addr
7850 && (h
== &htab
->tls_get_addr
->elf
7851 || h
== &htab
->tls_get_addr_fd
->elf
)
7852 && !found_tls_get_addr_arg
7853 && is_branch_reloc (r_type
))
7855 info
->callbacks
->minfo (_("%H __tls_get_addr lost arg, "
7856 "TLS optimization disabled\n"),
7857 ibfd
, sec
, rel
->r_offset
);
7862 found_tls_get_addr_arg
= 0;
7865 case R_PPC64_GOT_TLSLD16
:
7866 case R_PPC64_GOT_TLSLD16_LO
:
7867 case R_PPC64_GOT_TLSLD34
:
7868 expecting_tls_get_addr
= 1;
7869 found_tls_get_addr_arg
= 1;
7872 case R_PPC64_GOT_TLSLD16_HI
:
7873 case R_PPC64_GOT_TLSLD16_HA
:
7874 /* These relocs should never be against a symbol
7875 defined in a shared lib. Leave them alone if
7876 that turns out to be the case. */
7883 tls_type
= TLS_TLS
| TLS_LD
;
7886 case R_PPC64_GOT_TLSGD16
:
7887 case R_PPC64_GOT_TLSGD16_LO
:
7888 case R_PPC64_GOT_TLSGD34
:
7889 expecting_tls_get_addr
= 1;
7890 found_tls_get_addr_arg
= 1;
7893 case R_PPC64_GOT_TLSGD16_HI
:
7894 case R_PPC64_GOT_TLSGD16_HA
:
7900 tls_set
= TLS_TLS
| TLS_GDIE
;
7902 tls_type
= TLS_TLS
| TLS_GD
;
7905 case R_PPC64_GOT_TPREL34
:
7906 case R_PPC64_GOT_TPREL16_DS
:
7907 case R_PPC64_GOT_TPREL16_LO_DS
:
7908 case R_PPC64_GOT_TPREL16_HI
:
7909 case R_PPC64_GOT_TPREL16_HA
:
7914 tls_clear
= TLS_TPREL
;
7915 tls_type
= TLS_TLS
| TLS_TPREL
;
7925 if (rel
+ 1 < relend
7926 && is_plt_seq_reloc (ELF64_R_TYPE (rel
[1].r_info
)))
7929 && (ELF64_R_TYPE (rel
[1].r_info
)
7931 && (ELF64_R_TYPE (rel
[1].r_info
)
7932 != R_PPC64_PLTSEQ_NOTOC
))
7934 r_symndx
= ELF64_R_SYM (rel
[1].r_info
);
7935 if (!get_sym_h (&h
, NULL
, NULL
, NULL
, &locsyms
,
7940 struct plt_entry
*ent
= NULL
;
7942 for (ent
= h
->plt
.plist
;
7945 if (ent
->addend
== rel
[1].r_addend
)
7949 && ent
->plt
.refcount
> 0)
7950 ent
->plt
.refcount
-= 1;
7955 found_tls_get_addr_arg
= 1;
7960 case R_PPC64_TOC16_LO
:
7961 if (sym_sec
== NULL
|| sym_sec
!= toc
)
7964 /* Mark this toc entry as referenced by a TLS
7965 code sequence. We can do that now in the
7966 case of R_PPC64_TLS, and after checking for
7967 tls_get_addr for the TOC16 relocs. */
7968 if (toc_ref
== NULL
)
7970 = bfd_zmalloc (toc
->output_section
->rawsize
/ 8);
7971 if (toc_ref
== NULL
)
7975 value
= h
->root
.u
.def
.value
;
7977 value
= sym
->st_value
;
7978 value
+= rel
->r_addend
;
7981 BFD_ASSERT (value
< toc
->size
7982 && toc
->output_offset
% 8 == 0);
7983 toc_ref_index
= (value
+ toc
->output_offset
) / 8;
7984 if (r_type
== R_PPC64_TLS
7985 || r_type
== R_PPC64_TLSGD
7986 || r_type
== R_PPC64_TLSLD
)
7988 toc_ref
[toc_ref_index
] = 1;
7992 if (pass
!= 0 && toc_ref
[toc_ref_index
] == 0)
7997 expecting_tls_get_addr
= 2;
8000 case R_PPC64_TPREL64
:
8004 || !toc_ref
[(rel
->r_offset
+ toc
->output_offset
) / 8])
8009 tls_set
= TLS_EXPLICIT
;
8010 tls_clear
= TLS_TPREL
;
8015 case R_PPC64_DTPMOD64
:
8019 || !toc_ref
[(rel
->r_offset
+ toc
->output_offset
) / 8])
8021 if (rel
+ 1 < relend
8023 == ELF64_R_INFO (r_symndx
, R_PPC64_DTPREL64
))
8024 && rel
[1].r_offset
== rel
->r_offset
+ 8)
8028 tls_set
= TLS_EXPLICIT
| TLS_GD
;
8031 tls_set
= TLS_EXPLICIT
| TLS_GD
| TLS_GDIE
;
8040 tls_set
= TLS_EXPLICIT
;
8051 if (!expecting_tls_get_addr
8052 || !sec
->nomark_tls_get_addr
)
8055 if (rel
+ 1 < relend
8056 && branch_reloc_hash_match (ibfd
, rel
+ 1,
8058 htab
->tls_get_addr_fd
))
8060 if (expecting_tls_get_addr
== 2)
8062 /* Check for toc tls entries. */
8063 unsigned char *toc_tls
;
8066 retval
= get_tls_mask (&toc_tls
, NULL
, NULL
,
8071 if (toc_tls
!= NULL
)
8073 if ((*toc_tls
& TLS_TLS
) != 0
8074 && ((*toc_tls
& (TLS_GD
| TLS_LD
)) != 0))
8075 found_tls_get_addr_arg
= 1;
8077 toc_ref
[toc_ref_index
] = 1;
8083 /* Uh oh, we didn't find the expected call. We
8084 could just mark this symbol to exclude it
8085 from tls optimization but it's safer to skip
8086 the entire optimization. */
8087 /* xgettext:c-format */
8088 info
->callbacks
->minfo (_("%H arg lost __tls_get_addr, "
8089 "TLS optimization disabled\n"),
8090 ibfd
, sec
, rel
->r_offset
);
8095 /* If we don't have old-style __tls_get_addr calls
8096 without TLSGD/TLSLD marker relocs, and we haven't
8097 found a new-style __tls_get_addr call with a
8098 marker for this symbol, then we either have a
8099 broken object file or an -mlongcall style
8100 indirect call to __tls_get_addr without a marker.
8101 Disable optimization in this case. */
8102 if ((tls_clear
& (TLS_GD
| TLS_LD
)) != 0
8103 && (tls_set
& TLS_EXPLICIT
) == 0
8104 && !sec
->nomark_tls_get_addr
8105 && ((*tls_mask
& (TLS_TLS
| TLS_MARK
))
8106 != (TLS_TLS
| TLS_MARK
)))
8109 if (expecting_tls_get_addr
== 1 + !sec
->nomark_tls_get_addr
)
8111 struct plt_entry
*ent
= NULL
;
8113 if (htab
->tls_get_addr
!= NULL
)
8114 for (ent
= htab
->tls_get_addr
->elf
.plt
.plist
;
8117 if (ent
->addend
== 0)
8120 if (ent
== NULL
&& htab
->tls_get_addr_fd
!= NULL
)
8121 for (ent
= htab
->tls_get_addr_fd
->elf
.plt
.plist
;
8124 if (ent
->addend
== 0)
8128 && ent
->plt
.refcount
> 0)
8129 ent
->plt
.refcount
-= 1;
8135 if ((tls_set
& TLS_EXPLICIT
) == 0)
8137 struct got_entry
*ent
;
8139 /* Adjust got entry for this reloc. */
8143 ent
= elf_local_got_ents (ibfd
)[r_symndx
];
8145 for (; ent
!= NULL
; ent
= ent
->next
)
8146 if (ent
->addend
== rel
->r_addend
8147 && ent
->owner
== ibfd
8148 && ent
->tls_type
== tls_type
)
8155 /* We managed to get rid of a got entry. */
8156 if (ent
->got
.refcount
> 0)
8157 ent
->got
.refcount
-= 1;
8162 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8163 we'll lose one or two dyn relocs. */
8164 if (!dec_dynrel_count (rel
->r_info
, sec
, info
,
8168 if (tls_set
== (TLS_EXPLICIT
| TLS_GD
))
8170 if (!dec_dynrel_count ((rel
+ 1)->r_info
, sec
, info
,
8176 *tls_mask
|= tls_set
& 0xff;
8177 *tls_mask
&= ~tls_clear
;
8180 if (elf_section_data (sec
)->relocs
!= relstart
)
8185 && (elf_symtab_hdr (ibfd
).contents
!= (unsigned char *) locsyms
))
8187 if (!info
->keep_memory
)
8190 elf_symtab_hdr (ibfd
).contents
= (unsigned char *) locsyms
;
8194 if (toc_ref
!= NULL
)
8196 htab
->do_tls_opt
= 1;
8200 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8201 the values of any global symbols in a toc section that has been
8202 edited. Globals in toc sections should be a rarity, so this function
8203 sets a flag if any are found in toc sections other than the one just
8204 edited, so that further hash table traversals can be avoided. */
8206 struct adjust_toc_info
8209 unsigned long *skip
;
8210 bfd_boolean global_toc_syms
;
8213 enum toc_skip_enum
{ ref_from_discarded
= 1, can_optimize
= 2 };
8216 adjust_toc_syms (struct elf_link_hash_entry
*h
, void *inf
)
8218 struct ppc_link_hash_entry
*eh
;
8219 struct adjust_toc_info
*toc_inf
= (struct adjust_toc_info
*) inf
;
8222 if (h
->root
.type
!= bfd_link_hash_defined
8223 && h
->root
.type
!= bfd_link_hash_defweak
)
8226 eh
= (struct ppc_link_hash_entry
*) h
;
8227 if (eh
->adjust_done
)
8230 if (eh
->elf
.root
.u
.def
.section
== toc_inf
->toc
)
8232 if (eh
->elf
.root
.u
.def
.value
> toc_inf
->toc
->rawsize
)
8233 i
= toc_inf
->toc
->rawsize
>> 3;
8235 i
= eh
->elf
.root
.u
.def
.value
>> 3;
8237 if ((toc_inf
->skip
[i
] & (ref_from_discarded
| can_optimize
)) != 0)
8240 (_("%s defined on removed toc entry"), eh
->elf
.root
.root
.string
);
8243 while ((toc_inf
->skip
[i
] & (ref_from_discarded
| can_optimize
)) != 0);
8244 eh
->elf
.root
.u
.def
.value
= (bfd_vma
) i
<< 3;
8247 eh
->elf
.root
.u
.def
.value
-= toc_inf
->skip
[i
];
8248 eh
->adjust_done
= 1;
8250 else if (strcmp (eh
->elf
.root
.u
.def
.section
->name
, ".toc") == 0)
8251 toc_inf
->global_toc_syms
= TRUE
;
8256 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
8257 on a _LO variety toc/got reloc. */
8260 ok_lo_toc_insn (unsigned int insn
, enum elf_ppc64_reloc_type r_type
)
8262 return ((insn
& (0x3f << 26)) == 12u << 26 /* addic */
8263 || (insn
& (0x3f << 26)) == 14u << 26 /* addi */
8264 || (insn
& (0x3f << 26)) == 32u << 26 /* lwz */
8265 || (insn
& (0x3f << 26)) == 34u << 26 /* lbz */
8266 || (insn
& (0x3f << 26)) == 36u << 26 /* stw */
8267 || (insn
& (0x3f << 26)) == 38u << 26 /* stb */
8268 || (insn
& (0x3f << 26)) == 40u << 26 /* lhz */
8269 || (insn
& (0x3f << 26)) == 42u << 26 /* lha */
8270 || (insn
& (0x3f << 26)) == 44u << 26 /* sth */
8271 || (insn
& (0x3f << 26)) == 46u << 26 /* lmw */
8272 || (insn
& (0x3f << 26)) == 47u << 26 /* stmw */
8273 || (insn
& (0x3f << 26)) == 48u << 26 /* lfs */
8274 || (insn
& (0x3f << 26)) == 50u << 26 /* lfd */
8275 || (insn
& (0x3f << 26)) == 52u << 26 /* stfs */
8276 || (insn
& (0x3f << 26)) == 54u << 26 /* stfd */
8277 || (insn
& (0x3f << 26)) == 56u << 26 /* lq,lfq */
8278 || ((insn
& (0x3f << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
8279 /* Exclude lfqu by testing reloc. If relocs are ever
8280 defined for the reduced D field in psq_lu then those
8281 will need testing too. */
8282 && r_type
!= R_PPC64_TOC16_LO
&& r_type
!= R_PPC64_GOT16_LO
)
8283 || ((insn
& (0x3f << 26)) == 58u << 26 /* ld,lwa */
8285 || (insn
& (0x3f << 26)) == 60u << 26 /* stfq */
8286 || ((insn
& (0x3f << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
8287 /* Exclude stfqu. psq_stu as above for psq_lu. */
8288 && r_type
!= R_PPC64_TOC16_LO
&& r_type
!= R_PPC64_GOT16_LO
)
8289 || ((insn
& (0x3f << 26)) == 62u << 26 /* std,stq */
8290 && (insn
& 1) == 0));
8293 /* PCREL_OPT in one instance flags to the linker that a pair of insns:
8294 pld ra,symbol@got@pcrel
8295 load/store rt,off(ra)
8298 load/store rt,off(ra)
8299 may be translated to
8300 pload/pstore rt,symbol+off@pcrel
8302 This function returns true if the optimization is possible, placing
8303 the prefix insn in *PINSN1, a NOP in *PINSN2 and the offset in *POFF.
8305 On entry to this function, the linker has already determined that
8306 the pld can be replaced with pla: *PINSN1 is that pla insn,
8307 while *PINSN2 is the second instruction. */
8310 xlate_pcrel_opt (uint64_t *pinsn1
, uint64_t *pinsn2
, bfd_signed_vma
*poff
)
8312 uint64_t insn1
= *pinsn1
;
8313 uint64_t insn2
= *pinsn2
;
8316 if ((insn2
& (63ULL << 58)) == 1ULL << 58)
8318 /* Check that regs match. */
8319 if (((insn2
>> 16) & 31) != ((insn1
>> 21) & 31))
8322 /* P8LS or PMLS form, non-pcrel. */
8323 if ((insn2
& (-1ULL << 50) & ~(1ULL << 56)) != (1ULL << 58))
8326 *pinsn1
= (insn2
& ~(31 << 16) & ~0x3ffff0000ffffULL
) | (1ULL << 52);
8328 off
= ((insn2
>> 16) & 0x3ffff0000ULL
) | (insn2
& 0xffff);
8329 *poff
= (off
^ 0x200000000ULL
) - 0x200000000ULL
;
8335 /* Check that regs match. */
8336 if (((insn2
>> 16) & 31) != ((insn1
>> 21) & 31))
8339 switch ((insn2
>> 26) & 63)
8355 /* These are the PMLS cases, where we just need to tack a prefix
8357 insn1
= ((1ULL << 58) | (2ULL << 56) | (1ULL << 52)
8358 | (insn2
& ((63ULL << 26) | (31ULL << 21))));
8359 off
= insn2
& 0xffff;
8362 case 58: /* lwa, ld */
8363 if ((insn2
& 1) != 0)
8365 insn1
= ((1ULL << 58) | (1ULL << 52)
8366 | (insn2
& 2 ? 41ULL << 26 : 57ULL << 26)
8367 | (insn2
& (31ULL << 21)));
8368 off
= insn2
& 0xfffc;
8371 case 57: /* lxsd, lxssp */
8372 if ((insn2
& 3) < 2)
8374 insn1
= ((1ULL << 58) | (1ULL << 52)
8375 | ((40ULL | (insn2
& 3)) << 26)
8376 | (insn2
& (31ULL << 21)));
8377 off
= insn2
& 0xfffc;
8380 case 61: /* stxsd, stxssp, lxv, stxv */
8381 if ((insn2
& 3) == 0)
8383 else if ((insn2
& 3) >= 2)
8385 insn1
= ((1ULL << 58) | (1ULL << 52)
8386 | ((44ULL | (insn2
& 3)) << 26)
8387 | (insn2
& (31ULL << 21)));
8388 off
= insn2
& 0xfffc;
8392 insn1
= ((1ULL << 58) | (1ULL << 52)
8393 | ((50ULL | (insn2
& 4) | ((insn2
& 8) >> 3)) << 26)
8394 | (insn2
& (31ULL << 21)));
8395 off
= insn2
& 0xfff0;
8400 insn1
= ((1ULL << 58) | (1ULL << 52)
8401 | (insn2
& ((63ULL << 26) | (31ULL << 21))));
8402 off
= insn2
& 0xffff;
8405 case 62: /* std, stq */
8406 if ((insn2
& 1) != 0)
8408 insn1
= ((1ULL << 58) | (1ULL << 52)
8409 | ((insn2
& 2) == 0 ? 61ULL << 26 : 60ULL << 26)
8410 | (insn2
& (31ULL << 21)));
8411 off
= insn2
& 0xfffc;
8416 *pinsn2
= (uint64_t) NOP
<< 32;
8417 *poff
= (off
^ 0x8000) - 0x8000;
8421 /* Examine all relocs referencing .toc sections in order to remove
8422 unused .toc entries. */
8425 ppc64_elf_edit_toc (struct bfd_link_info
*info
)
8428 struct adjust_toc_info toc_inf
;
8429 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
8431 htab
->do_toc_opt
= 1;
8432 toc_inf
.global_toc_syms
= TRUE
;
8433 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
8435 asection
*toc
, *sec
;
8436 Elf_Internal_Shdr
*symtab_hdr
;
8437 Elf_Internal_Sym
*local_syms
;
8438 Elf_Internal_Rela
*relstart
, *rel
, *toc_relocs
;
8439 unsigned long *skip
, *drop
;
8440 unsigned char *used
;
8441 unsigned char *keep
, last
, some_unused
;
8443 if (!is_ppc64_elf (ibfd
))
8446 toc
= bfd_get_section_by_name (ibfd
, ".toc");
8449 || toc
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
8450 || discarded_section (toc
))
8455 symtab_hdr
= &elf_symtab_hdr (ibfd
);
8457 /* Look at sections dropped from the final link. */
8460 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
8462 if (sec
->reloc_count
== 0
8463 || !discarded_section (sec
)
8464 || get_opd_info (sec
)
8465 || (sec
->flags
& SEC_ALLOC
) == 0
8466 || (sec
->flags
& SEC_DEBUGGING
) != 0)
8469 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
, FALSE
);
8470 if (relstart
== NULL
)
8473 /* Run through the relocs to see which toc entries might be
8475 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
8477 enum elf_ppc64_reloc_type r_type
;
8478 unsigned long r_symndx
;
8480 struct elf_link_hash_entry
*h
;
8481 Elf_Internal_Sym
*sym
;
8484 r_type
= ELF64_R_TYPE (rel
->r_info
);
8491 case R_PPC64_TOC16_LO
:
8492 case R_PPC64_TOC16_HI
:
8493 case R_PPC64_TOC16_HA
:
8494 case R_PPC64_TOC16_DS
:
8495 case R_PPC64_TOC16_LO_DS
:
8499 r_symndx
= ELF64_R_SYM (rel
->r_info
);
8500 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
8508 val
= h
->root
.u
.def
.value
;
8510 val
= sym
->st_value
;
8511 val
+= rel
->r_addend
;
8513 if (val
>= toc
->size
)
8516 /* Anything in the toc ought to be aligned to 8 bytes.
8517 If not, don't mark as unused. */
8523 skip
= bfd_zmalloc (sizeof (*skip
) * (toc
->size
+ 15) / 8);
8528 skip
[val
>> 3] = ref_from_discarded
;
8531 if (elf_section_data (sec
)->relocs
!= relstart
)
8535 /* For largetoc loads of address constants, we can convert
8536 . addis rx,2,addr@got@ha
8537 . ld ry,addr@got@l(rx)
8539 . addis rx,2,addr@toc@ha
8540 . addi ry,rx,addr@toc@l
8541 when addr is within 2G of the toc pointer. This then means
8542 that the word storing "addr" in the toc is no longer needed. */
8544 if (!ppc64_elf_tdata (ibfd
)->has_small_toc_reloc
8545 && toc
->output_section
->rawsize
< (bfd_vma
) 1 << 31
8546 && toc
->reloc_count
!= 0)
8548 /* Read toc relocs. */
8549 toc_relocs
= _bfd_elf_link_read_relocs (ibfd
, toc
, NULL
, NULL
,
8551 if (toc_relocs
== NULL
)
8554 for (rel
= toc_relocs
; rel
< toc_relocs
+ toc
->reloc_count
; ++rel
)
8556 enum elf_ppc64_reloc_type r_type
;
8557 unsigned long r_symndx
;
8559 struct elf_link_hash_entry
*h
;
8560 Elf_Internal_Sym
*sym
;
8563 r_type
= ELF64_R_TYPE (rel
->r_info
);
8564 if (r_type
!= R_PPC64_ADDR64
)
8567 r_symndx
= ELF64_R_SYM (rel
->r_info
);
8568 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
8573 || sym_sec
->output_section
== NULL
8574 || discarded_section (sym_sec
))
8577 if (!SYMBOL_REFERENCES_LOCAL (info
, h
))
8582 if (h
->type
== STT_GNU_IFUNC
)
8584 val
= h
->root
.u
.def
.value
;
8588 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
8590 val
= sym
->st_value
;
8592 val
+= rel
->r_addend
;
8593 val
+= sym_sec
->output_section
->vma
+ sym_sec
->output_offset
;
8595 /* We don't yet know the exact toc pointer value, but we
8596 know it will be somewhere in the toc section. Don't
8597 optimize if the difference from any possible toc
8598 pointer is outside [ff..f80008000, 7fff7fff]. */
8599 addr
= toc
->output_section
->vma
+ TOC_BASE_OFF
;
8600 if (val
- addr
+ (bfd_vma
) 0x80008000 >= (bfd_vma
) 1 << 32)
8603 addr
= toc
->output_section
->vma
+ toc
->output_section
->rawsize
;
8604 if (val
- addr
+ (bfd_vma
) 0x80008000 >= (bfd_vma
) 1 << 32)
8609 skip
= bfd_zmalloc (sizeof (*skip
) * (toc
->size
+ 15) / 8);
8614 skip
[rel
->r_offset
>> 3]
8615 |= can_optimize
| ((rel
- toc_relocs
) << 2);
8622 used
= bfd_zmalloc (sizeof (*used
) * (toc
->size
+ 7) / 8);
8626 if (local_syms
!= NULL
8627 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
8631 && elf_section_data (sec
)->relocs
!= relstart
)
8633 if (toc_relocs
!= NULL
8634 && elf_section_data (toc
)->relocs
!= toc_relocs
)
8641 /* Now check all kept sections that might reference the toc.
8642 Check the toc itself last. */
8643 for (sec
= (ibfd
->sections
== toc
&& toc
->next
? toc
->next
8646 sec
= (sec
== toc
? NULL
8647 : sec
->next
== NULL
? toc
8648 : sec
->next
== toc
&& toc
->next
? toc
->next
8653 if (sec
->reloc_count
== 0
8654 || discarded_section (sec
)
8655 || get_opd_info (sec
)
8656 || (sec
->flags
& SEC_ALLOC
) == 0
8657 || (sec
->flags
& SEC_DEBUGGING
) != 0)
8660 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
8662 if (relstart
== NULL
)
8668 /* Mark toc entries referenced as used. */
8672 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
8674 enum elf_ppc64_reloc_type r_type
;
8675 unsigned long r_symndx
;
8677 struct elf_link_hash_entry
*h
;
8678 Elf_Internal_Sym
*sym
;
8681 r_type
= ELF64_R_TYPE (rel
->r_info
);
8685 case R_PPC64_TOC16_LO
:
8686 case R_PPC64_TOC16_HI
:
8687 case R_PPC64_TOC16_HA
:
8688 case R_PPC64_TOC16_DS
:
8689 case R_PPC64_TOC16_LO_DS
:
8690 /* In case we're taking addresses of toc entries. */
8691 case R_PPC64_ADDR64
:
8698 r_symndx
= ELF64_R_SYM (rel
->r_info
);
8699 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
8710 val
= h
->root
.u
.def
.value
;
8712 val
= sym
->st_value
;
8713 val
+= rel
->r_addend
;
8715 if (val
>= toc
->size
)
8718 if ((skip
[val
>> 3] & can_optimize
) != 0)
8725 case R_PPC64_TOC16_HA
:
8728 case R_PPC64_TOC16_LO_DS
:
8729 off
= rel
->r_offset
;
8730 off
+= (bfd_big_endian (ibfd
) ? -2 : 3);
8731 if (!bfd_get_section_contents (ibfd
, sec
, &opc
,
8737 if ((opc
& (0x3f << 2)) == (58u << 2))
8742 /* Wrong sort of reloc, or not a ld. We may
8743 as well clear ref_from_discarded too. */
8750 /* For the toc section, we only mark as used if this
8751 entry itself isn't unused. */
8752 else if ((used
[rel
->r_offset
>> 3]
8753 || !(skip
[rel
->r_offset
>> 3] & ref_from_discarded
))
8756 /* Do all the relocs again, to catch reference
8765 if (elf_section_data (sec
)->relocs
!= relstart
)
8769 /* Merge the used and skip arrays. Assume that TOC
8770 doublewords not appearing as either used or unused belong
8771 to an entry more than one doubleword in size. */
8772 for (drop
= skip
, keep
= used
, last
= 0, some_unused
= 0;
8773 drop
< skip
+ (toc
->size
+ 7) / 8;
8778 *drop
&= ~ref_from_discarded
;
8779 if ((*drop
& can_optimize
) != 0)
8783 else if ((*drop
& ref_from_discarded
) != 0)
8786 last
= ref_from_discarded
;
8796 bfd_byte
*contents
, *src
;
8798 Elf_Internal_Sym
*sym
;
8799 bfd_boolean local_toc_syms
= FALSE
;
8801 /* Shuffle the toc contents, and at the same time convert the
8802 skip array from booleans into offsets. */
8803 if (!bfd_malloc_and_get_section (ibfd
, toc
, &contents
))
8806 elf_section_data (toc
)->this_hdr
.contents
= contents
;
8808 for (src
= contents
, off
= 0, drop
= skip
;
8809 src
< contents
+ toc
->size
;
8812 if ((*drop
& (can_optimize
| ref_from_discarded
)) != 0)
8817 memcpy (src
- off
, src
, 8);
8821 toc
->rawsize
= toc
->size
;
8822 toc
->size
= src
- contents
- off
;
8824 /* Adjust addends for relocs against the toc section sym,
8825 and optimize any accesses we can. */
8826 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
8828 if (sec
->reloc_count
== 0
8829 || discarded_section (sec
))
8832 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
8834 if (relstart
== NULL
)
8837 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
8839 enum elf_ppc64_reloc_type r_type
;
8840 unsigned long r_symndx
;
8842 struct elf_link_hash_entry
*h
;
8845 r_type
= ELF64_R_TYPE (rel
->r_info
);
8852 case R_PPC64_TOC16_LO
:
8853 case R_PPC64_TOC16_HI
:
8854 case R_PPC64_TOC16_HA
:
8855 case R_PPC64_TOC16_DS
:
8856 case R_PPC64_TOC16_LO_DS
:
8857 case R_PPC64_ADDR64
:
8861 r_symndx
= ELF64_R_SYM (rel
->r_info
);
8862 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
8870 val
= h
->root
.u
.def
.value
;
8873 val
= sym
->st_value
;
8875 local_toc_syms
= TRUE
;
8878 val
+= rel
->r_addend
;
8880 if (val
> toc
->rawsize
)
8882 else if ((skip
[val
>> 3] & ref_from_discarded
) != 0)
8884 else if ((skip
[val
>> 3] & can_optimize
) != 0)
8886 Elf_Internal_Rela
*tocrel
8887 = toc_relocs
+ (skip
[val
>> 3] >> 2);
8888 unsigned long tsym
= ELF64_R_SYM (tocrel
->r_info
);
8892 case R_PPC64_TOC16_HA
:
8893 rel
->r_info
= ELF64_R_INFO (tsym
, R_PPC64_TOC16_HA
);
8896 case R_PPC64_TOC16_LO_DS
:
8897 rel
->r_info
= ELF64_R_INFO (tsym
, R_PPC64_LO_DS_OPT
);
8901 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
8903 info
->callbacks
->einfo
8904 /* xgettext:c-format */
8905 (_("%H: %s references "
8906 "optimized away TOC entry\n"),
8907 ibfd
, sec
, rel
->r_offset
,
8908 ppc64_elf_howto_table
[r_type
]->name
);
8909 bfd_set_error (bfd_error_bad_value
);
8912 rel
->r_addend
= tocrel
->r_addend
;
8913 elf_section_data (sec
)->relocs
= relstart
;
8917 if (h
!= NULL
|| sym
->st_value
!= 0)
8920 rel
->r_addend
-= skip
[val
>> 3];
8921 elf_section_data (sec
)->relocs
= relstart
;
8924 if (elf_section_data (sec
)->relocs
!= relstart
)
8928 /* We shouldn't have local or global symbols defined in the TOC,
8929 but handle them anyway. */
8930 if (local_syms
!= NULL
)
8931 for (sym
= local_syms
;
8932 sym
< local_syms
+ symtab_hdr
->sh_info
;
8934 if (sym
->st_value
!= 0
8935 && bfd_section_from_elf_index (ibfd
, sym
->st_shndx
) == toc
)
8939 if (sym
->st_value
> toc
->rawsize
)
8940 i
= toc
->rawsize
>> 3;
8942 i
= sym
->st_value
>> 3;
8944 if ((skip
[i
] & (ref_from_discarded
| can_optimize
)) != 0)
8948 (_("%s defined on removed toc entry"),
8949 bfd_elf_sym_name (ibfd
, symtab_hdr
, sym
, NULL
));
8952 while ((skip
[i
] & (ref_from_discarded
| can_optimize
)));
8953 sym
->st_value
= (bfd_vma
) i
<< 3;
8956 sym
->st_value
-= skip
[i
];
8957 symtab_hdr
->contents
= (unsigned char *) local_syms
;
8960 /* Adjust any global syms defined in this toc input section. */
8961 if (toc_inf
.global_toc_syms
)
8964 toc_inf
.skip
= skip
;
8965 toc_inf
.global_toc_syms
= FALSE
;
8966 elf_link_hash_traverse (elf_hash_table (info
), adjust_toc_syms
,
8970 if (toc
->reloc_count
!= 0)
8972 Elf_Internal_Shdr
*rel_hdr
;
8973 Elf_Internal_Rela
*wrel
;
8976 /* Remove unused toc relocs, and adjust those we keep. */
8977 if (toc_relocs
== NULL
)
8978 toc_relocs
= _bfd_elf_link_read_relocs (ibfd
, toc
, NULL
, NULL
,
8980 if (toc_relocs
== NULL
)
8984 for (rel
= toc_relocs
; rel
< toc_relocs
+ toc
->reloc_count
; ++rel
)
8985 if ((skip
[rel
->r_offset
>> 3]
8986 & (ref_from_discarded
| can_optimize
)) == 0)
8988 wrel
->r_offset
= rel
->r_offset
- skip
[rel
->r_offset
>> 3];
8989 wrel
->r_info
= rel
->r_info
;
8990 wrel
->r_addend
= rel
->r_addend
;
8993 else if (!dec_dynrel_count (rel
->r_info
, toc
, info
,
8994 &local_syms
, NULL
, NULL
))
8997 elf_section_data (toc
)->relocs
= toc_relocs
;
8998 toc
->reloc_count
= wrel
- toc_relocs
;
8999 rel_hdr
= _bfd_elf_single_rel_hdr (toc
);
9000 sz
= rel_hdr
->sh_entsize
;
9001 rel_hdr
->sh_size
= toc
->reloc_count
* sz
;
9004 else if (toc_relocs
!= NULL
9005 && elf_section_data (toc
)->relocs
!= toc_relocs
)
9008 if (local_syms
!= NULL
9009 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
9011 if (!info
->keep_memory
)
9014 symtab_hdr
->contents
= (unsigned char *) local_syms
;
9019 /* Look for cases where we can change an indirect GOT access to
9020 a GOT relative or PC relative access, possibly reducing the
9021 number of GOT entries. */
9022 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
9025 Elf_Internal_Shdr
*symtab_hdr
;
9026 Elf_Internal_Sym
*local_syms
;
9027 Elf_Internal_Rela
*relstart
, *rel
;
9030 if (!is_ppc64_elf (ibfd
))
9033 if (!ppc64_elf_tdata (ibfd
)->has_optrel
)
9036 sec
= ppc64_elf_tdata (ibfd
)->got
;
9039 got
= sec
->output_section
->vma
+ sec
->output_offset
+ 0x8000;
9042 symtab_hdr
= &elf_symtab_hdr (ibfd
);
9044 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
9046 if (sec
->reloc_count
== 0
9047 || !ppc64_elf_section_data (sec
)->has_optrel
9048 || discarded_section (sec
))
9051 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
9053 if (relstart
== NULL
)
9056 if (local_syms
!= NULL
9057 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
9061 && elf_section_data (sec
)->relocs
!= relstart
)
9066 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
9068 enum elf_ppc64_reloc_type r_type
;
9069 unsigned long r_symndx
;
9070 Elf_Internal_Sym
*sym
;
9072 struct elf_link_hash_entry
*h
;
9073 struct got_entry
*ent
;
9075 unsigned char buf
[8];
9077 enum {no_check
, check_lo
, check_ha
} insn_check
;
9079 r_type
= ELF64_R_TYPE (rel
->r_info
);
9083 insn_check
= no_check
;
9086 case R_PPC64_PLT16_HA
:
9087 case R_PPC64_GOT_TLSLD16_HA
:
9088 case R_PPC64_GOT_TLSGD16_HA
:
9089 case R_PPC64_GOT_TPREL16_HA
:
9090 case R_PPC64_GOT_DTPREL16_HA
:
9091 case R_PPC64_GOT16_HA
:
9092 case R_PPC64_TOC16_HA
:
9093 insn_check
= check_ha
;
9096 case R_PPC64_PLT16_LO
:
9097 case R_PPC64_PLT16_LO_DS
:
9098 case R_PPC64_GOT_TLSLD16_LO
:
9099 case R_PPC64_GOT_TLSGD16_LO
:
9100 case R_PPC64_GOT_TPREL16_LO_DS
:
9101 case R_PPC64_GOT_DTPREL16_LO_DS
:
9102 case R_PPC64_GOT16_LO
:
9103 case R_PPC64_GOT16_LO_DS
:
9104 case R_PPC64_TOC16_LO
:
9105 case R_PPC64_TOC16_LO_DS
:
9106 insn_check
= check_lo
;
9110 if (insn_check
!= no_check
)
9112 bfd_vma off
= rel
->r_offset
& ~3;
9114 if (!bfd_get_section_contents (ibfd
, sec
, buf
, off
, 4))
9117 insn
= bfd_get_32 (ibfd
, buf
);
9118 if (insn_check
== check_lo
9119 ? !ok_lo_toc_insn (insn
, r_type
)
9120 : ((insn
& ((0x3f << 26) | 0x1f << 16))
9121 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9125 ppc64_elf_tdata (ibfd
)->unexpected_toc_insn
= 1;
9126 sprintf (str
, "%#08x", insn
);
9127 info
->callbacks
->einfo
9128 /* xgettext:c-format */
9129 (_("%H: got/toc optimization is not supported for"
9130 " %s instruction\n"),
9131 ibfd
, sec
, rel
->r_offset
& ~3, str
);
9138 /* Note that we don't delete GOT entries for
9139 R_PPC64_GOT16_DS since we'd need a lot more
9140 analysis. For starters, the preliminary layout is
9141 before the GOT, PLT, dynamic sections and stubs are
9142 laid out. Then we'd need to allow for changes in
9143 distance between sections caused by alignment. */
9147 case R_PPC64_GOT16_HA
:
9148 case R_PPC64_GOT16_LO_DS
:
9149 case R_PPC64_GOT_PCREL34
:
9153 r_symndx
= ELF64_R_SYM (rel
->r_info
);
9154 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
9159 || sym_sec
->output_section
== NULL
9160 || discarded_section (sym_sec
))
9163 if (!SYMBOL_REFERENCES_LOCAL (info
, h
))
9167 val
= h
->root
.u
.def
.value
;
9169 val
= sym
->st_value
;
9170 val
+= rel
->r_addend
;
9171 val
+= sym_sec
->output_section
->vma
+ sym_sec
->output_offset
;
9173 /* Fudge factor to allow for the fact that the preliminary layout
9174 isn't exact. Reduce limits by this factor. */
9175 #define LIMIT_ADJUST(LIMIT) ((LIMIT) - (LIMIT) / 16)
9182 case R_PPC64_GOT16_HA
:
9183 if (val
- got
+ LIMIT_ADJUST (0x80008000ULL
)
9184 >= LIMIT_ADJUST (0x100000000ULL
))
9187 if (!bfd_get_section_contents (ibfd
, sec
, buf
,
9188 rel
->r_offset
& ~3, 4))
9190 insn
= bfd_get_32 (ibfd
, buf
);
9191 if (((insn
& ((0x3f << 26) | 0x1f << 16))
9192 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9196 case R_PPC64_GOT16_LO_DS
:
9197 if (val
- got
+ LIMIT_ADJUST (0x80008000ULL
)
9198 >= LIMIT_ADJUST (0x100000000ULL
))
9200 if (!bfd_get_section_contents (ibfd
, sec
, buf
,
9201 rel
->r_offset
& ~3, 4))
9203 insn
= bfd_get_32 (ibfd
, buf
);
9204 if ((insn
& (0x3f << 26 | 0x3)) != 58u << 26 /* ld */)
9208 case R_PPC64_GOT_PCREL34
:
9210 pc
+= sec
->output_section
->vma
+ sec
->output_offset
;
9211 if (val
- pc
+ LIMIT_ADJUST (1ULL << 33)
9212 >= LIMIT_ADJUST (1ULL << 34))
9214 if (!bfd_get_section_contents (ibfd
, sec
, buf
,
9215 rel
->r_offset
& ~3, 8))
9217 insn
= bfd_get_32 (ibfd
, buf
);
9218 if ((insn
& (-1u << 18)) != ((1u << 26) | (1u << 20)))
9220 insn
= bfd_get_32 (ibfd
, buf
+ 4);
9221 if ((insn
& (0x3f << 26)) != 57u << 26)
9231 struct got_entry
**local_got_ents
= elf_local_got_ents (ibfd
);
9232 ent
= local_got_ents
[r_symndx
];
9234 for (; ent
!= NULL
; ent
= ent
->next
)
9235 if (ent
->addend
== rel
->r_addend
9236 && ent
->owner
== ibfd
9237 && ent
->tls_type
== 0)
9239 BFD_ASSERT (ent
&& ent
->got
.refcount
> 0);
9240 ent
->got
.refcount
-= 1;
9243 if (elf_section_data (sec
)->relocs
!= relstart
)
9247 if (local_syms
!= NULL
9248 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
9250 if (!info
->keep_memory
)
9253 symtab_hdr
->contents
= (unsigned char *) local_syms
;
9260 /* Return true iff input section I references the TOC using
9261 instructions limited to +/-32k offsets. */
9264 ppc64_elf_has_small_toc_reloc (asection
*i
)
9266 return (is_ppc64_elf (i
->owner
)
9267 && ppc64_elf_tdata (i
->owner
)->has_small_toc_reloc
);
9270 /* Allocate space for one GOT entry. */
9273 allocate_got (struct elf_link_hash_entry
*h
,
9274 struct bfd_link_info
*info
,
9275 struct got_entry
*gent
)
9277 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
9278 struct ppc_link_hash_entry
*eh
= (struct ppc_link_hash_entry
*) h
;
9279 int entsize
= (gent
->tls_type
& eh
->tls_mask
& (TLS_GD
| TLS_LD
)
9281 int rentsize
= (gent
->tls_type
& eh
->tls_mask
& TLS_GD
9282 ? 2 : 1) * sizeof (Elf64_External_Rela
);
9283 asection
*got
= ppc64_elf_tdata (gent
->owner
)->got
;
9285 gent
->got
.offset
= got
->size
;
9286 got
->size
+= entsize
;
9288 if (h
->type
== STT_GNU_IFUNC
)
9290 htab
->elf
.irelplt
->size
+= rentsize
;
9291 htab
->got_reli_size
+= rentsize
;
9293 else if (((bfd_link_pic (info
)
9294 && !(gent
->tls_type
!= 0
9295 && bfd_link_executable (info
)
9296 && SYMBOL_REFERENCES_LOCAL (info
, h
)))
9297 || (htab
->elf
.dynamic_sections_created
9299 && !SYMBOL_REFERENCES_LOCAL (info
, h
)))
9300 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
9302 asection
*relgot
= ppc64_elf_tdata (gent
->owner
)->relgot
;
9303 relgot
->size
+= rentsize
;
9307 /* This function merges got entries in the same toc group. */
9310 merge_got_entries (struct got_entry
**pent
)
9312 struct got_entry
*ent
, *ent2
;
9314 for (ent
= *pent
; ent
!= NULL
; ent
= ent
->next
)
9315 if (!ent
->is_indirect
)
9316 for (ent2
= ent
->next
; ent2
!= NULL
; ent2
= ent2
->next
)
9317 if (!ent2
->is_indirect
9318 && ent2
->addend
== ent
->addend
9319 && ent2
->tls_type
== ent
->tls_type
9320 && elf_gp (ent2
->owner
) == elf_gp (ent
->owner
))
9322 ent2
->is_indirect
= TRUE
;
9323 ent2
->got
.ent
= ent
;
9327 /* If H is undefined, make it dynamic if that makes sense. */
9330 ensure_undef_dynamic (struct bfd_link_info
*info
,
9331 struct elf_link_hash_entry
*h
)
9333 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
9335 if (htab
->dynamic_sections_created
9336 && ((info
->dynamic_undefined_weak
!= 0
9337 && h
->root
.type
== bfd_link_hash_undefweak
)
9338 || h
->root
.type
== bfd_link_hash_undefined
)
9341 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
9342 return bfd_elf_link_record_dynamic_symbol (info
, h
);
9346 /* Allocate space in .plt, .got and associated reloc sections for
9350 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
9352 struct bfd_link_info
*info
;
9353 struct ppc_link_hash_table
*htab
;
9355 struct ppc_link_hash_entry
*eh
;
9356 struct got_entry
**pgent
, *gent
;
9358 if (h
->root
.type
== bfd_link_hash_indirect
)
9361 info
= (struct bfd_link_info
*) inf
;
9362 htab
= ppc_hash_table (info
);
9366 eh
= (struct ppc_link_hash_entry
*) h
;
9367 /* Run through the TLS GD got entries first if we're changing them
9369 if ((eh
->tls_mask
& (TLS_TLS
| TLS_GDIE
)) == (TLS_TLS
| TLS_GDIE
))
9370 for (gent
= h
->got
.glist
; gent
!= NULL
; gent
= gent
->next
)
9371 if (gent
->got
.refcount
> 0
9372 && (gent
->tls_type
& TLS_GD
) != 0)
9374 /* This was a GD entry that has been converted to TPREL. If
9375 there happens to be a TPREL entry we can use that one. */
9376 struct got_entry
*ent
;
9377 for (ent
= h
->got
.glist
; ent
!= NULL
; ent
= ent
->next
)
9378 if (ent
->got
.refcount
> 0
9379 && (ent
->tls_type
& TLS_TPREL
) != 0
9380 && ent
->addend
== gent
->addend
9381 && ent
->owner
== gent
->owner
)
9383 gent
->got
.refcount
= 0;
9387 /* If not, then we'll be using our own TPREL entry. */
9388 if (gent
->got
.refcount
!= 0)
9389 gent
->tls_type
= TLS_TLS
| TLS_TPREL
;
9392 /* Remove any list entry that won't generate a word in the GOT before
9393 we call merge_got_entries. Otherwise we risk merging to empty
9395 pgent
= &h
->got
.glist
;
9396 while ((gent
= *pgent
) != NULL
)
9397 if (gent
->got
.refcount
> 0)
9399 if ((gent
->tls_type
& TLS_LD
) != 0
9400 && SYMBOL_REFERENCES_LOCAL (info
, h
))
9402 ppc64_tlsld_got (gent
->owner
)->got
.refcount
+= 1;
9403 *pgent
= gent
->next
;
9406 pgent
= &gent
->next
;
9409 *pgent
= gent
->next
;
9411 if (!htab
->do_multi_toc
)
9412 merge_got_entries (&h
->got
.glist
);
9414 for (gent
= h
->got
.glist
; gent
!= NULL
; gent
= gent
->next
)
9415 if (!gent
->is_indirect
)
9417 /* Ensure we catch all the cases where this symbol should
9419 if (!ensure_undef_dynamic (info
, h
))
9422 if (!is_ppc64_elf (gent
->owner
))
9425 allocate_got (h
, info
, gent
);
9428 /* If no dynamic sections we can't have dynamic relocs, except for
9429 IFUNCs which are handled even in static executables. */
9430 if (!htab
->elf
.dynamic_sections_created
9431 && h
->type
!= STT_GNU_IFUNC
)
9432 eh
->dyn_relocs
= NULL
;
9434 /* Discard relocs on undefined symbols that must be local. */
9435 else if (h
->root
.type
== bfd_link_hash_undefined
9436 && ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
9437 eh
->dyn_relocs
= NULL
;
9439 /* Also discard relocs on undefined weak syms with non-default
9440 visibility, or when dynamic_undefined_weak says so. */
9441 else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
9442 eh
->dyn_relocs
= NULL
;
9444 if (eh
->dyn_relocs
!= NULL
)
9446 struct elf_dyn_relocs
*p
, **pp
;
9448 /* In the shared -Bsymbolic case, discard space allocated for
9449 dynamic pc-relative relocs against symbols which turn out to
9450 be defined in regular objects. For the normal shared case,
9451 discard space for relocs that have become local due to symbol
9452 visibility changes. */
9453 if (bfd_link_pic (info
))
9455 /* Relocs that use pc_count are those that appear on a call
9456 insn, or certain REL relocs (see must_be_dyn_reloc) that
9457 can be generated via assembly. We want calls to
9458 protected symbols to resolve directly to the function
9459 rather than going via the plt. If people want function
9460 pointer comparisons to work as expected then they should
9461 avoid writing weird assembly. */
9462 if (SYMBOL_CALLS_LOCAL (info
, h
))
9464 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
9466 p
->count
-= p
->pc_count
;
9475 if (eh
->dyn_relocs
!= NULL
)
9477 /* Ensure we catch all the cases where this symbol
9478 should be made dynamic. */
9479 if (!ensure_undef_dynamic (info
, h
))
9484 /* For a fixed position executable, discard space for
9485 relocs against symbols which are not dynamic. */
9486 else if (h
->type
!= STT_GNU_IFUNC
)
9488 if (h
->dynamic_adjusted
9490 && !ELF_COMMON_DEF_P (h
))
9492 /* Ensure we catch all the cases where this symbol
9493 should be made dynamic. */
9494 if (!ensure_undef_dynamic (info
, h
))
9497 /* But if that didn't work out, discard dynamic relocs. */
9498 if (h
->dynindx
== -1)
9499 eh
->dyn_relocs
= NULL
;
9502 eh
->dyn_relocs
= NULL
;
9505 /* Finally, allocate space. */
9506 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
9508 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
9509 if (eh
->elf
.type
== STT_GNU_IFUNC
)
9510 sreloc
= htab
->elf
.irelplt
;
9511 sreloc
->size
+= p
->count
* sizeof (Elf64_External_Rela
);
9515 /* We might need a PLT entry when the symbol
9518 c) has plt16 relocs and has been processed by adjust_dynamic_symbol, or
9519 d) has plt16 relocs and we are linking statically. */
9520 if ((htab
->elf
.dynamic_sections_created
&& h
->dynindx
!= -1)
9521 || h
->type
== STT_GNU_IFUNC
9522 || (h
->needs_plt
&& h
->dynamic_adjusted
)
9525 && !htab
->elf
.dynamic_sections_created
9526 && !htab
->can_convert_all_inline_plt
9527 && (((struct ppc_link_hash_entry
*) h
)->tls_mask
9528 & (TLS_TLS
| PLT_KEEP
)) == PLT_KEEP
))
9530 struct plt_entry
*pent
;
9531 bfd_boolean doneone
= FALSE
;
9532 for (pent
= h
->plt
.plist
; pent
!= NULL
; pent
= pent
->next
)
9533 if (pent
->plt
.refcount
> 0)
9535 if (!htab
->elf
.dynamic_sections_created
9536 || h
->dynindx
== -1)
9538 if (h
->type
== STT_GNU_IFUNC
)
9541 pent
->plt
.offset
= s
->size
;
9542 s
->size
+= PLT_ENTRY_SIZE (htab
);
9543 s
= htab
->elf
.irelplt
;
9548 pent
->plt
.offset
= s
->size
;
9549 s
->size
+= LOCAL_PLT_ENTRY_SIZE (htab
);
9550 s
= bfd_link_pic (info
) ? htab
->relpltlocal
: NULL
;
9555 /* If this is the first .plt entry, make room for the special
9559 s
->size
+= PLT_INITIAL_ENTRY_SIZE (htab
);
9561 pent
->plt
.offset
= s
->size
;
9563 /* Make room for this entry. */
9564 s
->size
+= PLT_ENTRY_SIZE (htab
);
9566 /* Make room for the .glink code. */
9569 s
->size
+= GLINK_PLTRESOLVE_SIZE (htab
);
9572 /* We need bigger stubs past index 32767. */
9573 if (s
->size
>= GLINK_PLTRESOLVE_SIZE (htab
) + 32768*2*4)
9580 /* We also need to make an entry in the .rela.plt section. */
9581 s
= htab
->elf
.srelplt
;
9584 s
->size
+= sizeof (Elf64_External_Rela
);
9588 pent
->plt
.offset
= (bfd_vma
) -1;
9591 h
->plt
.plist
= NULL
;
9597 h
->plt
.plist
= NULL
;
9604 #define PPC_LO(v) ((v) & 0xffff)
9605 #define PPC_HI(v) (((v) >> 16) & 0xffff)
9606 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
9608 ((((v) & 0x3ffff0000ULL) << 16) | (v & 0xffff))
9609 #define HA34(v) ((v + (1ULL << 33)) >> 34)
9611 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9612 to set up space for global entry stubs. These are put in glink,
9613 after the branch table. */
9616 size_global_entry_stubs (struct elf_link_hash_entry
*h
, void *inf
)
9618 struct bfd_link_info
*info
;
9619 struct ppc_link_hash_table
*htab
;
9620 struct plt_entry
*pent
;
9623 if (h
->root
.type
== bfd_link_hash_indirect
)
9626 if (!h
->pointer_equality_needed
)
9633 htab
= ppc_hash_table (info
);
9637 s
= htab
->global_entry
;
9638 plt
= htab
->elf
.splt
;
9639 for (pent
= h
->plt
.plist
; pent
!= NULL
; pent
= pent
->next
)
9640 if (pent
->plt
.offset
!= (bfd_vma
) -1
9641 && pent
->addend
== 0)
9643 /* For ELFv2, if this symbol is not defined in a regular file
9644 and we are not generating a shared library or pie, then we
9645 need to define the symbol in the executable on a call stub.
9646 This is to avoid text relocations. */
9647 bfd_vma off
, stub_align
, stub_off
, stub_size
;
9648 unsigned int align_power
;
9652 if (htab
->params
->plt_stub_align
>= 0)
9653 align_power
= htab
->params
->plt_stub_align
;
9655 align_power
= -htab
->params
->plt_stub_align
;
9656 /* Setting section alignment is delayed until we know it is
9657 non-empty. Otherwise the .text output section will be
9658 aligned at least to plt_stub_align even when no global
9659 entry stubs are needed. */
9660 if (s
->alignment_power
< align_power
)
9661 s
->alignment_power
= align_power
;
9662 stub_align
= (bfd_vma
) 1 << align_power
;
9663 if (htab
->params
->plt_stub_align
>= 0
9664 || ((((stub_off
+ stub_size
- 1) & -stub_align
)
9665 - (stub_off
& -stub_align
))
9666 > ((stub_size
- 1) & -stub_align
)))
9667 stub_off
= (stub_off
+ stub_align
- 1) & -stub_align
;
9668 off
= pent
->plt
.offset
+ plt
->output_offset
+ plt
->output_section
->vma
;
9669 off
-= stub_off
+ s
->output_offset
+ s
->output_section
->vma
;
9670 /* Note that for --plt-stub-align negative we have a possible
9671 dependency between stub offset and size. Break that
9672 dependency by assuming the max stub size when calculating
9674 if (PPC_HA (off
) == 0)
9676 h
->root
.type
= bfd_link_hash_defined
;
9677 h
->root
.u
.def
.section
= s
;
9678 h
->root
.u
.def
.value
= stub_off
;
9679 s
->size
= stub_off
+ stub_size
;
9685 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9686 read-only sections. */
9689 maybe_set_textrel (struct elf_link_hash_entry
*h
, void *inf
)
9693 if (h
->root
.type
== bfd_link_hash_indirect
)
9696 sec
= readonly_dynrelocs (h
);
9699 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
9701 info
->flags
|= DF_TEXTREL
;
9702 info
->callbacks
->minfo (_("%pB: dynamic relocation against `%pT'"
9703 " in read-only section `%pA'\n"),
9704 sec
->owner
, h
->root
.root
.string
, sec
);
9706 /* Not an error, just cut short the traversal. */
9712 /* Set the sizes of the dynamic sections. */
9715 ppc64_elf_size_dynamic_sections (bfd
*output_bfd
,
9716 struct bfd_link_info
*info
)
9718 struct ppc_link_hash_table
*htab
;
9723 struct got_entry
*first_tlsld
;
9725 htab
= ppc_hash_table (info
);
9729 dynobj
= htab
->elf
.dynobj
;
9733 if (htab
->elf
.dynamic_sections_created
)
9735 /* Set the contents of the .interp section to the interpreter. */
9736 if (bfd_link_executable (info
) && !info
->nointerp
)
9738 s
= bfd_get_linker_section (dynobj
, ".interp");
9741 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
9742 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
9746 /* Set up .got offsets for local syms, and space for local dynamic
9748 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
9750 struct got_entry
**lgot_ents
;
9751 struct got_entry
**end_lgot_ents
;
9752 struct plt_entry
**local_plt
;
9753 struct plt_entry
**end_local_plt
;
9754 unsigned char *lgot_masks
;
9755 bfd_size_type locsymcount
;
9756 Elf_Internal_Shdr
*symtab_hdr
;
9758 if (!is_ppc64_elf (ibfd
))
9761 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
9763 struct ppc_dyn_relocs
*p
;
9765 for (p
= elf_section_data (s
)->local_dynrel
; p
!= NULL
; p
= p
->next
)
9767 if (!bfd_is_abs_section (p
->sec
)
9768 && bfd_is_abs_section (p
->sec
->output_section
))
9770 /* Input section has been discarded, either because
9771 it is a copy of a linkonce section or due to
9772 linker script /DISCARD/, so we'll be discarding
9775 else if (p
->count
!= 0)
9777 asection
*srel
= elf_section_data (p
->sec
)->sreloc
;
9779 srel
= htab
->elf
.irelplt
;
9780 srel
->size
+= p
->count
* sizeof (Elf64_External_Rela
);
9781 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
9782 info
->flags
|= DF_TEXTREL
;
9787 lgot_ents
= elf_local_got_ents (ibfd
);
9791 symtab_hdr
= &elf_symtab_hdr (ibfd
);
9792 locsymcount
= symtab_hdr
->sh_info
;
9793 end_lgot_ents
= lgot_ents
+ locsymcount
;
9794 local_plt
= (struct plt_entry
**) end_lgot_ents
;
9795 end_local_plt
= local_plt
+ locsymcount
;
9796 lgot_masks
= (unsigned char *) end_local_plt
;
9797 s
= ppc64_elf_tdata (ibfd
)->got
;
9798 for (; lgot_ents
< end_lgot_ents
; ++lgot_ents
, ++lgot_masks
)
9800 struct got_entry
**pent
, *ent
;
9803 while ((ent
= *pent
) != NULL
)
9804 if (ent
->got
.refcount
> 0)
9806 if ((ent
->tls_type
& *lgot_masks
& TLS_LD
) != 0)
9808 ppc64_tlsld_got (ibfd
)->got
.refcount
+= 1;
9813 unsigned int ent_size
= 8;
9814 unsigned int rel_size
= sizeof (Elf64_External_Rela
);
9816 ent
->got
.offset
= s
->size
;
9817 if ((ent
->tls_type
& *lgot_masks
& TLS_GD
) != 0)
9822 s
->size
+= ent_size
;
9823 if ((*lgot_masks
& (TLS_TLS
| PLT_IFUNC
)) == PLT_IFUNC
)
9825 htab
->elf
.irelplt
->size
+= rel_size
;
9826 htab
->got_reli_size
+= rel_size
;
9828 else if (bfd_link_pic (info
)
9829 && !(ent
->tls_type
!= 0
9830 && bfd_link_executable (info
)))
9832 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
9833 srel
->size
+= rel_size
;
9842 /* Allocate space for plt calls to local syms. */
9843 lgot_masks
= (unsigned char *) end_local_plt
;
9844 for (; local_plt
< end_local_plt
; ++local_plt
, ++lgot_masks
)
9846 struct plt_entry
*ent
;
9848 for (ent
= *local_plt
; ent
!= NULL
; ent
= ent
->next
)
9849 if (ent
->plt
.refcount
> 0)
9851 if ((*lgot_masks
& (TLS_TLS
| PLT_IFUNC
)) == PLT_IFUNC
)
9854 ent
->plt
.offset
= s
->size
;
9855 s
->size
+= PLT_ENTRY_SIZE (htab
);
9856 htab
->elf
.irelplt
->size
+= sizeof (Elf64_External_Rela
);
9858 else if (htab
->can_convert_all_inline_plt
9859 || (*lgot_masks
& (TLS_TLS
| PLT_KEEP
)) != PLT_KEEP
)
9860 ent
->plt
.offset
= (bfd_vma
) -1;
9864 ent
->plt
.offset
= s
->size
;
9865 s
->size
+= LOCAL_PLT_ENTRY_SIZE (htab
);
9866 if (bfd_link_pic (info
))
9867 htab
->relpltlocal
->size
+= sizeof (Elf64_External_Rela
);
9871 ent
->plt
.offset
= (bfd_vma
) -1;
9875 /* Allocate global sym .plt and .got entries, and space for global
9876 sym dynamic relocs. */
9877 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, info
);
9879 if (!htab
->opd_abi
&& !bfd_link_pic (info
))
9880 elf_link_hash_traverse (&htab
->elf
, size_global_entry_stubs
, info
);
9883 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
9885 struct got_entry
*ent
;
9887 if (!is_ppc64_elf (ibfd
))
9890 ent
= ppc64_tlsld_got (ibfd
);
9891 if (ent
->got
.refcount
> 0)
9893 if (!htab
->do_multi_toc
&& first_tlsld
!= NULL
)
9895 ent
->is_indirect
= TRUE
;
9896 ent
->got
.ent
= first_tlsld
;
9900 if (first_tlsld
== NULL
)
9902 s
= ppc64_elf_tdata (ibfd
)->got
;
9903 ent
->got
.offset
= s
->size
;
9906 if (bfd_link_dll (info
))
9908 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
9909 srel
->size
+= sizeof (Elf64_External_Rela
);
9914 ent
->got
.offset
= (bfd_vma
) -1;
9917 /* We now have determined the sizes of the various dynamic sections.
9918 Allocate memory for them. */
9920 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
9922 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
9925 if (s
== htab
->brlt
|| s
== htab
->relbrlt
)
9926 /* These haven't been allocated yet; don't strip. */
9928 else if (s
== htab
->elf
.sgot
9929 || s
== htab
->elf
.splt
9930 || s
== htab
->elf
.iplt
9931 || s
== htab
->pltlocal
9933 || s
== htab
->global_entry
9934 || s
== htab
->elf
.sdynbss
9935 || s
== htab
->elf
.sdynrelro
)
9937 /* Strip this section if we don't need it; see the
9940 else if (s
== htab
->glink_eh_frame
)
9942 if (!bfd_is_abs_section (s
->output_section
))
9943 /* Not sized yet. */
9946 else if (CONST_STRNEQ (s
->name
, ".rela"))
9950 if (s
!= htab
->elf
.srelplt
)
9953 /* We use the reloc_count field as a counter if we need
9954 to copy relocs into the output file. */
9960 /* It's not one of our sections, so don't allocate space. */
9966 /* If we don't need this section, strip it from the
9967 output file. This is mostly to handle .rela.bss and
9968 .rela.plt. We must create both sections in
9969 create_dynamic_sections, because they must be created
9970 before the linker maps input sections to output
9971 sections. The linker does that before
9972 adjust_dynamic_symbol is called, and it is that
9973 function which decides whether anything needs to go
9974 into these sections. */
9975 s
->flags
|= SEC_EXCLUDE
;
9979 if (bfd_is_abs_section (s
->output_section
))
9980 _bfd_error_handler (_("warning: discarding dynamic section %s"),
9983 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
9986 /* Allocate memory for the section contents. We use bfd_zalloc
9987 here in case unused entries are not reclaimed before the
9988 section's contents are written out. This should not happen,
9989 but this way if it does we get a R_PPC64_NONE reloc in .rela
9990 sections instead of garbage.
9991 We also rely on the section contents being zero when writing
9992 the GOT and .dynrelro. */
9993 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
9994 if (s
->contents
== NULL
)
9998 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
10000 if (!is_ppc64_elf (ibfd
))
10003 s
= ppc64_elf_tdata (ibfd
)->got
;
10004 if (s
!= NULL
&& s
!= htab
->elf
.sgot
)
10007 s
->flags
|= SEC_EXCLUDE
;
10010 s
->contents
= bfd_zalloc (ibfd
, s
->size
);
10011 if (s
->contents
== NULL
)
10015 s
= ppc64_elf_tdata (ibfd
)->relgot
;
10019 s
->flags
|= SEC_EXCLUDE
;
10022 s
->contents
= bfd_zalloc (ibfd
, s
->size
);
10023 if (s
->contents
== NULL
)
10026 s
->reloc_count
= 0;
10031 if (htab
->elf
.dynamic_sections_created
)
10033 bfd_boolean tls_opt
;
10035 /* Add some entries to the .dynamic section. We fill in the
10036 values later, in ppc64_elf_finish_dynamic_sections, but we
10037 must add the entries now so that we get the correct size for
10038 the .dynamic section. The DT_DEBUG entry is filled in by the
10039 dynamic linker and used by the debugger. */
10040 #define add_dynamic_entry(TAG, VAL) \
10041 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10043 if (bfd_link_executable (info
))
10045 if (!add_dynamic_entry (DT_DEBUG
, 0))
10049 if (htab
->elf
.splt
!= NULL
&& htab
->elf
.splt
->size
!= 0)
10051 if (!add_dynamic_entry (DT_PLTGOT
, 0)
10052 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
10053 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
10054 || !add_dynamic_entry (DT_JMPREL
, 0)
10055 || !add_dynamic_entry (DT_PPC64_GLINK
, 0))
10059 if (NO_OPD_RELOCS
&& abiversion (output_bfd
) <= 1)
10061 if (!add_dynamic_entry (DT_PPC64_OPD
, 0)
10062 || !add_dynamic_entry (DT_PPC64_OPDSZ
, 0))
10066 tls_opt
= (htab
->params
->tls_get_addr_opt
10067 && htab
->tls_get_addr_fd
!= NULL
10068 && htab
->tls_get_addr_fd
->elf
.plt
.plist
!= NULL
);
10069 if (tls_opt
|| !htab
->opd_abi
)
10071 if (!add_dynamic_entry (DT_PPC64_OPT
, tls_opt
? PPC64_OPT_TLS
: 0))
10077 if (!add_dynamic_entry (DT_RELA
, 0)
10078 || !add_dynamic_entry (DT_RELASZ
, 0)
10079 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf64_External_Rela
)))
10082 /* If any dynamic relocs apply to a read-only section,
10083 then we need a DT_TEXTREL entry. */
10084 if ((info
->flags
& DF_TEXTREL
) == 0)
10085 elf_link_hash_traverse (&htab
->elf
, maybe_set_textrel
, info
);
10087 if ((info
->flags
& DF_TEXTREL
) != 0)
10089 if (!add_dynamic_entry (DT_TEXTREL
, 0))
10094 #undef add_dynamic_entry
10099 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
10102 ppc64_elf_hash_symbol (struct elf_link_hash_entry
*h
)
10104 if (h
->plt
.plist
!= NULL
10106 && !h
->pointer_equality_needed
)
10109 return _bfd_elf_hash_symbol (h
);
10112 /* Determine the type of stub needed, if any, for a call. */
10114 static inline enum ppc_stub_type
10115 ppc_type_of_stub (asection
*input_sec
,
10116 const Elf_Internal_Rela
*rel
,
10117 struct ppc_link_hash_entry
**hash
,
10118 struct plt_entry
**plt_ent
,
10119 bfd_vma destination
,
10120 unsigned long local_off
)
10122 struct ppc_link_hash_entry
*h
= *hash
;
10124 bfd_vma branch_offset
;
10125 bfd_vma max_branch_offset
;
10126 enum elf_ppc64_reloc_type r_type
;
10130 struct plt_entry
*ent
;
10131 struct ppc_link_hash_entry
*fdh
= h
;
10133 && h
->oh
->is_func_descriptor
)
10135 fdh
= ppc_follow_link (h
->oh
);
10139 for (ent
= fdh
->elf
.plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
10140 if (ent
->addend
== rel
->r_addend
10141 && ent
->plt
.offset
!= (bfd_vma
) -1)
10144 return ppc_stub_plt_call
;
10147 /* Here, we know we don't have a plt entry. If we don't have a
10148 either a defined function descriptor or a defined entry symbol
10149 in a regular object file, then it is pointless trying to make
10150 any other type of stub. */
10151 if (!is_static_defined (&fdh
->elf
)
10152 && !is_static_defined (&h
->elf
))
10153 return ppc_stub_none
;
10155 else if (elf_local_got_ents (input_sec
->owner
) != NULL
)
10157 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (input_sec
->owner
);
10158 struct plt_entry
**local_plt
= (struct plt_entry
**)
10159 elf_local_got_ents (input_sec
->owner
) + symtab_hdr
->sh_info
;
10160 unsigned long r_symndx
= ELF64_R_SYM (rel
->r_info
);
10162 if (local_plt
[r_symndx
] != NULL
)
10164 struct plt_entry
*ent
;
10166 for (ent
= local_plt
[r_symndx
]; ent
!= NULL
; ent
= ent
->next
)
10167 if (ent
->addend
== rel
->r_addend
10168 && ent
->plt
.offset
!= (bfd_vma
) -1)
10171 return ppc_stub_plt_call
;
10176 /* Determine where the call point is. */
10177 location
= (input_sec
->output_offset
10178 + input_sec
->output_section
->vma
10181 branch_offset
= destination
- location
;
10182 r_type
= ELF64_R_TYPE (rel
->r_info
);
10184 /* Determine if a long branch stub is needed. */
10185 max_branch_offset
= 1 << 25;
10186 if (r_type
== R_PPC64_REL14
10187 || r_type
== R_PPC64_REL14_BRTAKEN
10188 || r_type
== R_PPC64_REL14_BRNTAKEN
)
10189 max_branch_offset
= 1 << 15;
10191 if (branch_offset
+ max_branch_offset
>= 2 * max_branch_offset
- local_off
)
10192 /* We need a stub. Figure out whether a long_branch or plt_branch
10193 is needed later. */
10194 return ppc_stub_long_branch
;
10196 return ppc_stub_none
;
10199 /* Gets the address of a label (1:) in r11 and builds an offset in r12,
10200 then adds it to r11 (LOAD false) or loads r12 from r11+r12 (LOAD true).
10205 . lis %r12,xxx-1b@highest
10206 . ori %r12,%r12,xxx-1b@higher
10207 . sldi %r12,%r12,32
10208 . oris %r12,%r12,xxx-1b@high
10209 . ori %r12,%r12,xxx-1b@l
10210 . add/ldx %r12,%r11,%r12 */
10213 build_offset (bfd
*abfd
, bfd_byte
*p
, bfd_vma off
, bfd_boolean load
)
10215 bfd_put_32 (abfd
, MFLR_R12
, p
);
10217 bfd_put_32 (abfd
, BCL_20_31
, p
);
10219 bfd_put_32 (abfd
, MFLR_R11
, p
);
10221 bfd_put_32 (abfd
, MTLR_R12
, p
);
10223 if (off
+ 0x8000 < 0x10000)
10226 bfd_put_32 (abfd
, LD_R12_0R11
+ PPC_LO (off
), p
);
10228 bfd_put_32 (abfd
, ADDI_R12_R11
+ PPC_LO (off
), p
);
10231 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10233 bfd_put_32 (abfd
, ADDIS_R12_R11
+ PPC_HA (off
), p
);
10236 bfd_put_32 (abfd
, LD_R12_0R12
+ PPC_LO (off
), p
);
10238 bfd_put_32 (abfd
, ADDI_R12_R12
+ PPC_LO (off
), p
);
10243 if (off
+ 0x800000000000ULL
< 0x1000000000000ULL
)
10245 bfd_put_32 (abfd
, LI_R12_0
+ ((off
>> 32) & 0xffff), p
);
10250 bfd_put_32 (abfd
, LIS_R12
+ ((off
>> 48) & 0xffff), p
);
10252 if (((off
>> 32) & 0xffff) != 0)
10254 bfd_put_32 (abfd
, ORI_R12_R12_0
+ ((off
>> 32) & 0xffff), p
);
10258 if (((off
>> 32) & 0xffffffffULL
) != 0)
10260 bfd_put_32 (abfd
, SLDI_R12_R12_32
, p
);
10263 if (PPC_HI (off
) != 0)
10265 bfd_put_32 (abfd
, ORIS_R12_R12_0
+ PPC_HI (off
), p
);
10268 if (PPC_LO (off
) != 0)
10270 bfd_put_32 (abfd
, ORI_R12_R12_0
+ PPC_LO (off
), p
);
10274 bfd_put_32 (abfd
, LDX_R12_R11_R12
, p
);
10276 bfd_put_32 (abfd
, ADD_R12_R11_R12
, p
);
10282 static unsigned int
10283 size_offset (bfd_vma off
)
10286 if (off
+ 0x8000 < 0x10000)
10288 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10292 if (off
+ 0x800000000000ULL
< 0x1000000000000ULL
)
10297 if (((off
>> 32) & 0xffff) != 0)
10300 if (((off
>> 32) & 0xffffffffULL
) != 0)
10302 if (PPC_HI (off
) != 0)
10304 if (PPC_LO (off
) != 0)
10311 static unsigned int
10312 num_relocs_for_offset (bfd_vma off
)
10314 unsigned int num_rel
;
10315 if (off
+ 0x8000 < 0x10000)
10317 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10322 if (off
+ 0x800000000000ULL
>= 0x1000000000000ULL
10323 && ((off
>> 32) & 0xffff) != 0)
10325 if (PPC_HI (off
) != 0)
10327 if (PPC_LO (off
) != 0)
10333 static Elf_Internal_Rela
*
10334 emit_relocs_for_offset (struct bfd_link_info
*info
, Elf_Internal_Rela
*r
,
10335 bfd_vma roff
, bfd_vma targ
, bfd_vma off
)
10337 bfd_vma relative_targ
= targ
- (roff
- 8);
10338 if (bfd_big_endian (info
->output_bfd
))
10340 r
->r_offset
= roff
;
10341 r
->r_addend
= relative_targ
+ roff
;
10342 if (off
+ 0x8000 < 0x10000)
10343 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16
);
10344 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10346 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HA
);
10349 r
->r_offset
= roff
;
10350 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_LO
);
10351 r
->r_addend
= relative_targ
+ roff
;
10355 if (off
+ 0x800000000000ULL
< 0x1000000000000ULL
)
10356 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHER
);
10359 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHEST
);
10360 if (((off
>> 32) & 0xffff) != 0)
10364 r
->r_offset
= roff
;
10365 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHER
);
10366 r
->r_addend
= relative_targ
+ roff
;
10369 if (((off
>> 32) & 0xffffffffULL
) != 0)
10371 if (PPC_HI (off
) != 0)
10375 r
->r_offset
= roff
;
10376 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGH
);
10377 r
->r_addend
= relative_targ
+ roff
;
10379 if (PPC_LO (off
) != 0)
10383 r
->r_offset
= roff
;
10384 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_LO
);
10385 r
->r_addend
= relative_targ
+ roff
;
10392 build_powerxx_offset (bfd
*abfd
, bfd_byte
*p
, bfd_vma off
, int odd
,
10396 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10401 bfd_put_32 (abfd
, NOP
, p
);
10407 insn
= PADDI_R12_PC
;
10409 bfd_put_32 (abfd
, insn
>> 32, p
);
10411 bfd_put_32 (abfd
, insn
, p
);
10413 /* The minimum value for paddi is -0x200000000. The minimum value
10414 for li is -0x8000, which when shifted by 34 and added gives a
10415 minimum value of -0x2000200000000. The maximum value is
10416 0x1ffffffff+0x7fff<<34 which is 0x2000200000000-1. */
10417 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10420 bfd_put_32 (abfd
, LI_R11_0
| (HA34 (off
) & 0xffff), p
);
10424 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10427 insn
= PADDI_R12_PC
| D34 (off
);
10428 bfd_put_32 (abfd
, insn
>> 32, p
);
10430 bfd_put_32 (abfd
, insn
, p
);
10434 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10438 bfd_put_32 (abfd
, LDX_R12_R11_R12
, p
);
10440 bfd_put_32 (abfd
, ADD_R12_R11_R12
, p
);
10445 bfd_put_32 (abfd
, LIS_R11
| ((HA34 (off
) >> 16) & 0x3fff), p
);
10447 bfd_put_32 (abfd
, ORI_R11_R11_0
| (HA34 (off
) & 0xffff), p
);
10451 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10454 insn
= PADDI_R12_PC
| D34 (off
);
10455 bfd_put_32 (abfd
, insn
>> 32, p
);
10457 bfd_put_32 (abfd
, insn
, p
);
10461 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10465 bfd_put_32 (abfd
, LDX_R12_R11_R12
, p
);
10467 bfd_put_32 (abfd
, ADD_R12_R11_R12
, p
);
10473 static unsigned int
10474 size_powerxx_offset (bfd_vma off
, int odd
)
10476 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10478 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10484 static unsigned int
10485 num_relocs_for_powerxx_offset (bfd_vma off
, int odd
)
10487 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10489 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10495 static Elf_Internal_Rela
*
10496 emit_relocs_for_powerxx_offset (struct bfd_link_info
*info
,
10497 Elf_Internal_Rela
*r
, bfd_vma roff
,
10498 bfd_vma targ
, bfd_vma off
, int odd
)
10500 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10502 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10504 int d_offset
= bfd_big_endian (info
->output_bfd
) ? 2 : 0;
10505 r
->r_offset
= roff
+ d_offset
;
10506 r
->r_addend
= targ
+ 8 - odd
- d_offset
;
10507 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHERA34
);
10513 int d_offset
= bfd_big_endian (info
->output_bfd
) ? 2 : 0;
10514 r
->r_offset
= roff
+ d_offset
;
10515 r
->r_addend
= targ
+ 8 + odd
- d_offset
;
10516 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHESTA34
);
10519 r
->r_offset
= roff
+ d_offset
;
10520 r
->r_addend
= targ
+ 4 + odd
- d_offset
;
10521 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHERA34
);
10525 r
->r_offset
= roff
;
10526 r
->r_addend
= targ
;
10527 r
->r_info
= ELF64_R_INFO (0, R_PPC64_PCREL34
);
10531 /* Emit .eh_frame opcode to advance pc by DELTA. */
10534 eh_advance (bfd
*abfd
, bfd_byte
*eh
, unsigned int delta
)
10538 *eh
++ = DW_CFA_advance_loc
+ delta
;
10539 else if (delta
< 256)
10541 *eh
++ = DW_CFA_advance_loc1
;
10544 else if (delta
< 65536)
10546 *eh
++ = DW_CFA_advance_loc2
;
10547 bfd_put_16 (abfd
, delta
, eh
);
10552 *eh
++ = DW_CFA_advance_loc4
;
10553 bfd_put_32 (abfd
, delta
, eh
);
10559 /* Size of required .eh_frame opcode to advance pc by DELTA. */
10561 static unsigned int
10562 eh_advance_size (unsigned int delta
)
10564 if (delta
< 64 * 4)
10565 /* DW_CFA_advance_loc+[1..63]. */
10567 if (delta
< 256 * 4)
10568 /* DW_CFA_advance_loc1, byte. */
10570 if (delta
< 65536 * 4)
10571 /* DW_CFA_advance_loc2, 2 bytes. */
10573 /* DW_CFA_advance_loc4, 4 bytes. */
10577 /* With power7 weakly ordered memory model, it is possible for ld.so
10578 to update a plt entry in one thread and have another thread see a
10579 stale zero toc entry. To avoid this we need some sort of acquire
10580 barrier in the call stub. One solution is to make the load of the
10581 toc word seem to appear to depend on the load of the function entry
10582 word. Another solution is to test for r2 being zero, and branch to
10583 the appropriate glink entry if so.
10585 . fake dep barrier compare
10586 . ld 12,xxx(2) ld 12,xxx(2)
10587 . mtctr 12 mtctr 12
10588 . xor 11,12,12 ld 2,xxx+8(2)
10589 . add 2,2,11 cmpldi 2,0
10590 . ld 2,xxx+8(2) bnectr+
10591 . bctr b <glink_entry>
10593 The solution involving the compare turns out to be faster, so
10594 that's what we use unless the branch won't reach. */
10596 #define ALWAYS_USE_FAKE_DEP 0
10597 #define ALWAYS_EMIT_R2SAVE 0
10599 static inline unsigned int
10600 plt_stub_size (struct ppc_link_hash_table
*htab
,
10601 struct ppc_stub_hash_entry
*stub_entry
,
10606 if (stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
)
10608 if (htab
->powerxx_stubs
)
10610 bfd_vma start
= (stub_entry
->stub_offset
10611 + stub_entry
->group
->stub_sec
->output_offset
10612 + stub_entry
->group
->stub_sec
->output_section
->vma
);
10613 if (stub_entry
->stub_type
> ppc_stub_plt_call_notoc
)
10615 size
= 8 + size_powerxx_offset (off
, start
& 4);
10618 size
= 8 + size_offset (off
- 8);
10619 if (stub_entry
->stub_type
> ppc_stub_plt_call_notoc
)
10625 if (ALWAYS_EMIT_R2SAVE
10626 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10628 if (PPC_HA (off
) != 0)
10633 if (htab
->params
->plt_static_chain
)
10635 if (htab
->params
->plt_thread_safe
10636 && htab
->elf
.dynamic_sections_created
10637 && stub_entry
->h
!= NULL
10638 && stub_entry
->h
->elf
.dynindx
!= -1)
10640 if (PPC_HA (off
+ 8 + 8 * htab
->params
->plt_static_chain
) != PPC_HA (off
))
10643 if (stub_entry
->h
!= NULL
10644 && (stub_entry
->h
== htab
->tls_get_addr_fd
10645 || stub_entry
->h
== htab
->tls_get_addr
)
10646 && htab
->params
->tls_get_addr_opt
)
10649 if (stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10655 /* Depending on the sign of plt_stub_align:
10656 If positive, return the padding to align to a 2**plt_stub_align
10658 If negative, if this stub would cross fewer 2**plt_stub_align
10659 boundaries if we align, then return the padding needed to do so. */
10661 static inline unsigned int
10662 plt_stub_pad (struct ppc_link_hash_table
*htab
,
10663 struct ppc_stub_hash_entry
*stub_entry
,
10667 unsigned stub_size
;
10668 bfd_vma stub_off
= stub_entry
->group
->stub_sec
->size
;
10670 if (htab
->params
->plt_stub_align
>= 0)
10672 stub_align
= 1 << htab
->params
->plt_stub_align
;
10673 if ((stub_off
& (stub_align
- 1)) != 0)
10674 return stub_align
- (stub_off
& (stub_align
- 1));
10678 stub_align
= 1 << -htab
->params
->plt_stub_align
;
10679 stub_size
= plt_stub_size (htab
, stub_entry
, plt_off
);
10680 if (((stub_off
+ stub_size
- 1) & -stub_align
) - (stub_off
& -stub_align
)
10681 > ((stub_size
- 1) & -stub_align
))
10682 return stub_align
- (stub_off
& (stub_align
- 1));
10686 /* Build a .plt call stub. */
10688 static inline bfd_byte
*
10689 build_plt_stub (struct ppc_link_hash_table
*htab
,
10690 struct ppc_stub_hash_entry
*stub_entry
,
10691 bfd_byte
*p
, bfd_vma offset
, Elf_Internal_Rela
*r
)
10693 bfd
*obfd
= htab
->params
->stub_bfd
;
10694 bfd_boolean plt_load_toc
= htab
->opd_abi
;
10695 bfd_boolean plt_static_chain
= htab
->params
->plt_static_chain
;
10696 bfd_boolean plt_thread_safe
= (htab
->params
->plt_thread_safe
10697 && htab
->elf
.dynamic_sections_created
10698 && stub_entry
->h
!= NULL
10699 && stub_entry
->h
->elf
.dynindx
!= -1);
10700 bfd_boolean use_fake_dep
= plt_thread_safe
;
10701 bfd_vma cmp_branch_off
= 0;
10703 if (!ALWAYS_USE_FAKE_DEP
10706 && !((stub_entry
->h
== htab
->tls_get_addr_fd
10707 || stub_entry
->h
== htab
->tls_get_addr
)
10708 && htab
->params
->tls_get_addr_opt
))
10710 bfd_vma pltoff
= stub_entry
->plt_ent
->plt
.offset
& ~1;
10711 bfd_vma pltindex
= ((pltoff
- PLT_INITIAL_ENTRY_SIZE (htab
))
10712 / PLT_ENTRY_SIZE (htab
));
10713 bfd_vma glinkoff
= GLINK_PLTRESOLVE_SIZE (htab
) + pltindex
* 8;
10716 if (pltindex
> 32768)
10717 glinkoff
+= (pltindex
- 32768) * 4;
10719 + htab
->glink
->output_offset
10720 + htab
->glink
->output_section
->vma
);
10721 from
= (p
- stub_entry
->group
->stub_sec
->contents
10722 + 4 * (ALWAYS_EMIT_R2SAVE
10723 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10724 + 4 * (PPC_HA (offset
) != 0)
10725 + 4 * (PPC_HA (offset
+ 8 + 8 * plt_static_chain
)
10726 != PPC_HA (offset
))
10727 + 4 * (plt_static_chain
!= 0)
10729 + stub_entry
->group
->stub_sec
->output_offset
10730 + stub_entry
->group
->stub_sec
->output_section
->vma
);
10731 cmp_branch_off
= to
- from
;
10732 use_fake_dep
= cmp_branch_off
+ (1 << 25) >= (1 << 26);
10735 if (PPC_HA (offset
) != 0)
10739 if (ALWAYS_EMIT_R2SAVE
10740 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10741 r
[0].r_offset
+= 4;
10742 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_HA
);
10743 r
[1].r_offset
= r
[0].r_offset
+ 4;
10744 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
10745 r
[1].r_addend
= r
[0].r_addend
;
10748 if (PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
10750 r
[2].r_offset
= r
[1].r_offset
+ 4;
10751 r
[2].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO
);
10752 r
[2].r_addend
= r
[0].r_addend
;
10756 r
[2].r_offset
= r
[1].r_offset
+ 8 + 8 * use_fake_dep
;
10757 r
[2].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
10758 r
[2].r_addend
= r
[0].r_addend
+ 8;
10759 if (plt_static_chain
)
10761 r
[3].r_offset
= r
[2].r_offset
+ 4;
10762 r
[3].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
10763 r
[3].r_addend
= r
[0].r_addend
+ 16;
10768 if (ALWAYS_EMIT_R2SAVE
10769 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10770 bfd_put_32 (obfd
, STD_R2_0R1
+ STK_TOC (htab
), p
), p
+= 4;
10773 bfd_put_32 (obfd
, ADDIS_R11_R2
| PPC_HA (offset
), p
), p
+= 4;
10774 bfd_put_32 (obfd
, LD_R12_0R11
| PPC_LO (offset
), p
), p
+= 4;
10778 bfd_put_32 (obfd
, ADDIS_R12_R2
| PPC_HA (offset
), p
), p
+= 4;
10779 bfd_put_32 (obfd
, LD_R12_0R12
| PPC_LO (offset
), p
), p
+= 4;
10782 && PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
10784 bfd_put_32 (obfd
, ADDI_R11_R11
| PPC_LO (offset
), p
), p
+= 4;
10787 bfd_put_32 (obfd
, MTCTR_R12
, p
), p
+= 4;
10792 bfd_put_32 (obfd
, XOR_R2_R12_R12
, p
), p
+= 4;
10793 bfd_put_32 (obfd
, ADD_R11_R11_R2
, p
), p
+= 4;
10795 bfd_put_32 (obfd
, LD_R2_0R11
| PPC_LO (offset
+ 8), p
), p
+= 4;
10796 if (plt_static_chain
)
10797 bfd_put_32 (obfd
, LD_R11_0R11
| PPC_LO (offset
+ 16), p
), p
+= 4;
10804 if (ALWAYS_EMIT_R2SAVE
10805 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10806 r
[0].r_offset
+= 4;
10807 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
10810 if (PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
10812 r
[1].r_offset
= r
[0].r_offset
+ 4;
10813 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16
);
10814 r
[1].r_addend
= r
[0].r_addend
;
10818 r
[1].r_offset
= r
[0].r_offset
+ 8 + 8 * use_fake_dep
;
10819 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
10820 r
[1].r_addend
= r
[0].r_addend
+ 8 + 8 * plt_static_chain
;
10821 if (plt_static_chain
)
10823 r
[2].r_offset
= r
[1].r_offset
+ 4;
10824 r
[2].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
10825 r
[2].r_addend
= r
[0].r_addend
+ 8;
10830 if (ALWAYS_EMIT_R2SAVE
10831 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10832 bfd_put_32 (obfd
, STD_R2_0R1
+ STK_TOC (htab
), p
), p
+= 4;
10833 bfd_put_32 (obfd
, LD_R12_0R2
| PPC_LO (offset
), p
), p
+= 4;
10835 && PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
10837 bfd_put_32 (obfd
, ADDI_R2_R2
| PPC_LO (offset
), p
), p
+= 4;
10840 bfd_put_32 (obfd
, MTCTR_R12
, p
), p
+= 4;
10845 bfd_put_32 (obfd
, XOR_R11_R12_R12
, p
), p
+= 4;
10846 bfd_put_32 (obfd
, ADD_R2_R2_R11
, p
), p
+= 4;
10848 if (plt_static_chain
)
10849 bfd_put_32 (obfd
, LD_R11_0R2
| PPC_LO (offset
+ 16), p
), p
+= 4;
10850 bfd_put_32 (obfd
, LD_R2_0R2
| PPC_LO (offset
+ 8), p
), p
+= 4;
10853 if (plt_load_toc
&& plt_thread_safe
&& !use_fake_dep
)
10855 bfd_put_32 (obfd
, CMPLDI_R2_0
, p
), p
+= 4;
10856 bfd_put_32 (obfd
, BNECTR_P4
, p
), p
+= 4;
10857 bfd_put_32 (obfd
, B_DOT
| (cmp_branch_off
& 0x3fffffc), p
), p
+= 4;
10860 bfd_put_32 (obfd
, BCTR
, p
), p
+= 4;
10864 /* Build a special .plt call stub for __tls_get_addr. */
10866 #define LD_R11_0R3 0xe9630000
10867 #define LD_R12_0R3 0xe9830000
10868 #define MR_R0_R3 0x7c601b78
10869 #define CMPDI_R11_0 0x2c2b0000
10870 #define ADD_R3_R12_R13 0x7c6c6a14
10871 #define BEQLR 0x4d820020
10872 #define MR_R3_R0 0x7c030378
10873 #define STD_R11_0R1 0xf9610000
10874 #define BCTRL 0x4e800421
10875 #define LD_R11_0R1 0xe9610000
10876 #define MTLR_R11 0x7d6803a6
10878 static inline bfd_byte
*
10879 build_tls_get_addr_stub (struct ppc_link_hash_table
*htab
,
10880 struct ppc_stub_hash_entry
*stub_entry
,
10881 bfd_byte
*p
, bfd_vma offset
, Elf_Internal_Rela
*r
)
10883 bfd
*obfd
= htab
->params
->stub_bfd
;
10886 bfd_put_32 (obfd
, LD_R11_0R3
+ 0, p
), p
+= 4;
10887 bfd_put_32 (obfd
, LD_R12_0R3
+ 8, p
), p
+= 4;
10888 bfd_put_32 (obfd
, MR_R0_R3
, p
), p
+= 4;
10889 bfd_put_32 (obfd
, CMPDI_R11_0
, p
), p
+= 4;
10890 bfd_put_32 (obfd
, ADD_R3_R12_R13
, p
), p
+= 4;
10891 bfd_put_32 (obfd
, BEQLR
, p
), p
+= 4;
10892 bfd_put_32 (obfd
, MR_R3_R0
, p
), p
+= 4;
10894 r
[0].r_offset
+= 7 * 4;
10895 if (stub_entry
->stub_type
!= ppc_stub_plt_call_r2save
)
10896 return build_plt_stub (htab
, stub_entry
, p
, offset
, r
);
10898 bfd_put_32 (obfd
, MFLR_R11
, p
), p
+= 4;
10899 bfd_put_32 (obfd
, STD_R11_0R1
+ STK_LINKER (htab
), p
), p
+= 4;
10902 r
[0].r_offset
+= 2 * 4;
10903 p
= build_plt_stub (htab
, stub_entry
, p
, offset
, r
);
10904 bfd_put_32 (obfd
, BCTRL
, p
- 4);
10906 bfd_put_32 (obfd
, LD_R2_0R1
+ STK_TOC (htab
), p
), p
+= 4;
10907 bfd_put_32 (obfd
, LD_R11_0R1
+ STK_LINKER (htab
), p
), p
+= 4;
10908 bfd_put_32 (obfd
, MTLR_R11
, p
), p
+= 4;
10909 bfd_put_32 (obfd
, BLR
, p
), p
+= 4;
10911 if (htab
->glink_eh_frame
!= NULL
10912 && htab
->glink_eh_frame
->size
!= 0)
10914 bfd_byte
*base
, *eh
;
10915 unsigned int lr_used
, delta
;
10917 base
= htab
->glink_eh_frame
->contents
+ stub_entry
->group
->eh_base
+ 17;
10918 eh
= base
+ stub_entry
->group
->eh_size
;
10919 lr_used
= stub_entry
->stub_offset
+ (p
- 20 - loc
);
10920 delta
= lr_used
- stub_entry
->group
->lr_restore
;
10921 stub_entry
->group
->lr_restore
= lr_used
+ 16;
10922 eh
= eh_advance (htab
->elf
.dynobj
, eh
, delta
);
10923 *eh
++ = DW_CFA_offset_extended_sf
;
10925 *eh
++ = -(STK_LINKER (htab
) / 8) & 0x7f;
10926 *eh
++ = DW_CFA_advance_loc
+ 4;
10927 *eh
++ = DW_CFA_restore_extended
;
10929 stub_entry
->group
->eh_size
= eh
- base
;
10934 static Elf_Internal_Rela
*
10935 get_relocs (asection
*sec
, int count
)
10937 Elf_Internal_Rela
*relocs
;
10938 struct bfd_elf_section_data
*elfsec_data
;
10940 elfsec_data
= elf_section_data (sec
);
10941 relocs
= elfsec_data
->relocs
;
10942 if (relocs
== NULL
)
10944 bfd_size_type relsize
;
10945 relsize
= sec
->reloc_count
* sizeof (*relocs
);
10946 relocs
= bfd_alloc (sec
->owner
, relsize
);
10947 if (relocs
== NULL
)
10949 elfsec_data
->relocs
= relocs
;
10950 elfsec_data
->rela
.hdr
= bfd_zalloc (sec
->owner
,
10951 sizeof (Elf_Internal_Shdr
));
10952 if (elfsec_data
->rela
.hdr
== NULL
)
10954 elfsec_data
->rela
.hdr
->sh_size
= (sec
->reloc_count
10955 * sizeof (Elf64_External_Rela
));
10956 elfsec_data
->rela
.hdr
->sh_entsize
= sizeof (Elf64_External_Rela
);
10957 sec
->reloc_count
= 0;
10959 relocs
+= sec
->reloc_count
;
10960 sec
->reloc_count
+= count
;
10964 /* Convert the relocs R[0] thru R[-NUM_REL+1], which are all no-symbol
10965 forms, to the equivalent relocs against the global symbol given by
10969 use_global_in_relocs (struct ppc_link_hash_table
*htab
,
10970 struct ppc_stub_hash_entry
*stub_entry
,
10971 Elf_Internal_Rela
*r
, unsigned int num_rel
)
10973 struct elf_link_hash_entry
**hashes
;
10974 unsigned long symndx
;
10975 struct ppc_link_hash_entry
*h
;
10978 /* Relocs are always against symbols in their own object file. Fake
10979 up global sym hashes for the stub bfd (which has no symbols). */
10980 hashes
= elf_sym_hashes (htab
->params
->stub_bfd
);
10981 if (hashes
== NULL
)
10983 bfd_size_type hsize
;
10985 /* When called the first time, stub_globals will contain the
10986 total number of symbols seen during stub sizing. After
10987 allocating, stub_globals is used as an index to fill the
10989 hsize
= (htab
->stub_globals
+ 1) * sizeof (*hashes
);
10990 hashes
= bfd_zalloc (htab
->params
->stub_bfd
, hsize
);
10991 if (hashes
== NULL
)
10993 elf_sym_hashes (htab
->params
->stub_bfd
) = hashes
;
10994 htab
->stub_globals
= 1;
10996 symndx
= htab
->stub_globals
++;
10998 hashes
[symndx
] = &h
->elf
;
10999 if (h
->oh
!= NULL
&& h
->oh
->is_func
)
11000 h
= ppc_follow_link (h
->oh
);
11001 BFD_ASSERT (h
->elf
.root
.type
== bfd_link_hash_defined
11002 || h
->elf
.root
.type
== bfd_link_hash_defweak
);
11003 symval
= (h
->elf
.root
.u
.def
.value
11004 + h
->elf
.root
.u
.def
.section
->output_offset
11005 + h
->elf
.root
.u
.def
.section
->output_section
->vma
);
11006 while (num_rel
-- != 0)
11008 r
->r_info
= ELF64_R_INFO (symndx
, ELF64_R_TYPE (r
->r_info
));
11009 if (h
->elf
.root
.u
.def
.section
!= stub_entry
->target_section
)
11011 /* H is an opd symbol. The addend must be zero, and the
11012 branch reloc is the only one we can convert. */
11017 r
->r_addend
-= symval
;
11024 get_r2off (struct bfd_link_info
*info
,
11025 struct ppc_stub_hash_entry
*stub_entry
)
11027 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
11028 bfd_vma r2off
= htab
->sec_info
[stub_entry
->target_section
->id
].toc_off
;
11032 /* Support linking -R objects. Get the toc pointer from the
11035 if (!htab
->opd_abi
)
11037 asection
*opd
= stub_entry
->h
->elf
.root
.u
.def
.section
;
11038 bfd_vma opd_off
= stub_entry
->h
->elf
.root
.u
.def
.value
;
11040 if (strcmp (opd
->name
, ".opd") != 0
11041 || opd
->reloc_count
!= 0)
11043 info
->callbacks
->einfo
11044 (_("%P: cannot find opd entry toc for `%pT'\n"),
11045 stub_entry
->h
->elf
.root
.root
.string
);
11046 bfd_set_error (bfd_error_bad_value
);
11047 return (bfd_vma
) -1;
11049 if (!bfd_get_section_contents (opd
->owner
, opd
, buf
, opd_off
+ 8, 8))
11050 return (bfd_vma
) -1;
11051 r2off
= bfd_get_64 (opd
->owner
, buf
);
11052 r2off
-= elf_gp (info
->output_bfd
);
11054 r2off
-= htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
;
11059 ppc_build_one_stub (struct bfd_hash_entry
*gen_entry
, void *in_arg
)
11061 struct ppc_stub_hash_entry
*stub_entry
;
11062 struct ppc_branch_hash_entry
*br_entry
;
11063 struct bfd_link_info
*info
;
11064 struct ppc_link_hash_table
*htab
;
11066 bfd_byte
*p
, *relp
;
11068 Elf_Internal_Rela
*r
;
11073 /* Massage our args to the form they really have. */
11074 stub_entry
= (struct ppc_stub_hash_entry
*) gen_entry
;
11077 htab
= ppc_hash_table (info
);
11081 BFD_ASSERT (stub_entry
->stub_offset
>= stub_entry
->group
->stub_sec
->size
);
11082 loc
= stub_entry
->group
->stub_sec
->contents
+ stub_entry
->stub_offset
;
11084 htab
->stub_count
[stub_entry
->stub_type
- 1] += 1;
11085 switch (stub_entry
->stub_type
)
11087 case ppc_stub_long_branch
:
11088 case ppc_stub_long_branch_r2off
:
11089 /* Branches are relative. This is where we are going to. */
11090 targ
= (stub_entry
->target_value
11091 + stub_entry
->target_section
->output_offset
11092 + stub_entry
->target_section
->output_section
->vma
);
11093 targ
+= PPC64_LOCAL_ENTRY_OFFSET (stub_entry
->other
);
11095 /* And this is where we are coming from. */
11096 off
= (stub_entry
->stub_offset
11097 + stub_entry
->group
->stub_sec
->output_offset
11098 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11102 if (stub_entry
->stub_type
== ppc_stub_long_branch_r2off
)
11104 bfd_vma r2off
= get_r2off (info
, stub_entry
);
11106 if (r2off
== (bfd_vma
) -1)
11108 htab
->stub_error
= TRUE
;
11111 bfd_put_32 (htab
->params
->stub_bfd
, STD_R2_0R1
+ STK_TOC (htab
), p
);
11113 if (PPC_HA (r2off
) != 0)
11115 bfd_put_32 (htab
->params
->stub_bfd
,
11116 ADDIS_R2_R2
| PPC_HA (r2off
), p
);
11119 if (PPC_LO (r2off
) != 0)
11121 bfd_put_32 (htab
->params
->stub_bfd
,
11122 ADDI_R2_R2
| PPC_LO (r2off
), p
);
11127 bfd_put_32 (htab
->params
->stub_bfd
, B_DOT
| (off
& 0x3fffffc), p
);
11130 if (off
+ (1 << 25) >= (bfd_vma
) (1 << 26))
11133 (_("long branch stub `%s' offset overflow"),
11134 stub_entry
->root
.string
);
11135 htab
->stub_error
= TRUE
;
11139 if (info
->emitrelocations
)
11141 r
= get_relocs (stub_entry
->group
->stub_sec
, 1);
11144 r
->r_offset
= p
- 4 - stub_entry
->group
->stub_sec
->contents
;
11145 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL24
);
11146 r
->r_addend
= targ
;
11147 if (stub_entry
->h
!= NULL
11148 && !use_global_in_relocs (htab
, stub_entry
, r
, 1))
11153 case ppc_stub_plt_branch
:
11154 case ppc_stub_plt_branch_r2off
:
11155 br_entry
= ppc_branch_hash_lookup (&htab
->branch_hash_table
,
11156 stub_entry
->root
.string
+ 9,
11158 if (br_entry
== NULL
)
11160 _bfd_error_handler (_("can't find branch stub `%s'"),
11161 stub_entry
->root
.string
);
11162 htab
->stub_error
= TRUE
;
11166 targ
= (stub_entry
->target_value
11167 + stub_entry
->target_section
->output_offset
11168 + stub_entry
->target_section
->output_section
->vma
);
11169 if (stub_entry
->stub_type
!= ppc_stub_plt_branch_r2off
)
11170 targ
+= PPC64_LOCAL_ENTRY_OFFSET (stub_entry
->other
);
11172 bfd_put_64 (htab
->brlt
->owner
, targ
,
11173 htab
->brlt
->contents
+ br_entry
->offset
);
11175 if (br_entry
->iter
== htab
->stub_iteration
)
11177 br_entry
->iter
= 0;
11179 if (htab
->relbrlt
!= NULL
)
11181 /* Create a reloc for the branch lookup table entry. */
11182 Elf_Internal_Rela rela
;
11185 rela
.r_offset
= (br_entry
->offset
11186 + htab
->brlt
->output_offset
11187 + htab
->brlt
->output_section
->vma
);
11188 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
11189 rela
.r_addend
= targ
;
11191 rl
= htab
->relbrlt
->contents
;
11192 rl
+= (htab
->relbrlt
->reloc_count
++
11193 * sizeof (Elf64_External_Rela
));
11194 bfd_elf64_swap_reloca_out (htab
->relbrlt
->owner
, &rela
, rl
);
11196 else if (info
->emitrelocations
)
11198 r
= get_relocs (htab
->brlt
, 1);
11201 /* brlt, being SEC_LINKER_CREATED does not go through the
11202 normal reloc processing. Symbols and offsets are not
11203 translated from input file to output file form, so
11204 set up the offset per the output file. */
11205 r
->r_offset
= (br_entry
->offset
11206 + htab
->brlt
->output_offset
11207 + htab
->brlt
->output_section
->vma
);
11208 r
->r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
11209 r
->r_addend
= targ
;
11213 targ
= (br_entry
->offset
11214 + htab
->brlt
->output_offset
11215 + htab
->brlt
->output_section
->vma
);
11217 off
= (elf_gp (info
->output_bfd
)
11218 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
11221 if (off
+ 0x80008000 > 0xffffffff || (off
& 7) != 0)
11223 info
->callbacks
->einfo
11224 (_("%P: linkage table error against `%pT'\n"),
11225 stub_entry
->root
.string
);
11226 bfd_set_error (bfd_error_bad_value
);
11227 htab
->stub_error
= TRUE
;
11231 if (info
->emitrelocations
)
11233 r
= get_relocs (stub_entry
->group
->stub_sec
, 1 + (PPC_HA (off
) != 0));
11236 r
[0].r_offset
= loc
- stub_entry
->group
->stub_sec
->contents
;
11237 if (bfd_big_endian (info
->output_bfd
))
11238 r
[0].r_offset
+= 2;
11239 if (stub_entry
->stub_type
== ppc_stub_plt_branch_r2off
)
11240 r
[0].r_offset
+= 4;
11241 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
11242 r
[0].r_addend
= targ
;
11243 if (PPC_HA (off
) != 0)
11245 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_HA
);
11246 r
[1].r_offset
= r
[0].r_offset
+ 4;
11247 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
11248 r
[1].r_addend
= r
[0].r_addend
;
11253 if (stub_entry
->stub_type
!= ppc_stub_plt_branch_r2off
)
11255 if (PPC_HA (off
) != 0)
11257 bfd_put_32 (htab
->params
->stub_bfd
,
11258 ADDIS_R12_R2
| PPC_HA (off
), p
);
11260 bfd_put_32 (htab
->params
->stub_bfd
,
11261 LD_R12_0R12
| PPC_LO (off
), p
);
11264 bfd_put_32 (htab
->params
->stub_bfd
,
11265 LD_R12_0R2
| PPC_LO (off
), p
);
11269 bfd_vma r2off
= get_r2off (info
, stub_entry
);
11271 if (r2off
== (bfd_vma
) -1)
11273 htab
->stub_error
= TRUE
;
11277 bfd_put_32 (htab
->params
->stub_bfd
, STD_R2_0R1
+ STK_TOC (htab
), p
);
11279 if (PPC_HA (off
) != 0)
11281 bfd_put_32 (htab
->params
->stub_bfd
,
11282 ADDIS_R12_R2
| PPC_HA (off
), p
);
11284 bfd_put_32 (htab
->params
->stub_bfd
,
11285 LD_R12_0R12
| PPC_LO (off
), p
);
11288 bfd_put_32 (htab
->params
->stub_bfd
, LD_R12_0R2
| PPC_LO (off
), p
);
11290 if (PPC_HA (r2off
) != 0)
11293 bfd_put_32 (htab
->params
->stub_bfd
,
11294 ADDIS_R2_R2
| PPC_HA (r2off
), p
);
11296 if (PPC_LO (r2off
) != 0)
11299 bfd_put_32 (htab
->params
->stub_bfd
,
11300 ADDI_R2_R2
| PPC_LO (r2off
), p
);
11304 bfd_put_32 (htab
->params
->stub_bfd
, MTCTR_R12
, p
);
11306 bfd_put_32 (htab
->params
->stub_bfd
, BCTR
, p
);
11310 case ppc_stub_long_branch_notoc
:
11311 case ppc_stub_long_branch_both
:
11312 case ppc_stub_plt_branch_notoc
:
11313 case ppc_stub_plt_branch_both
:
11314 case ppc_stub_plt_call_notoc
:
11315 case ppc_stub_plt_call_both
:
11317 off
= (stub_entry
->stub_offset
11318 + stub_entry
->group
->stub_sec
->output_offset
11319 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11320 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
11321 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
11322 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
11325 bfd_put_32 (htab
->params
->stub_bfd
, STD_R2_0R1
+ STK_TOC (htab
), p
);
11328 if (stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
)
11330 targ
= stub_entry
->plt_ent
->plt
.offset
& ~1;
11331 if (targ
>= (bfd_vma
) -2)
11334 plt
= htab
->elf
.splt
;
11335 if (!htab
->elf
.dynamic_sections_created
11336 || stub_entry
->h
== NULL
11337 || stub_entry
->h
->elf
.dynindx
== -1)
11339 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
11340 plt
= htab
->elf
.iplt
;
11342 plt
= htab
->pltlocal
;
11344 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
11347 targ
= (stub_entry
->target_value
11348 + stub_entry
->target_section
->output_offset
11349 + stub_entry
->target_section
->output_section
->vma
);
11355 if (htab
->powerxx_stubs
)
11357 bfd_boolean load
= stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
;
11358 p
= build_powerxx_offset (htab
->params
->stub_bfd
, p
, off
, odd
, load
);
11362 /* The notoc stubs calculate their target (either a PLT entry or
11363 the global entry point of a function) relative to the PC
11364 returned by the "bcl" two instructions past the start of the
11365 sequence emitted by build_offset. The offset is therefore 8
11366 less than calculated from the start of the sequence. */
11368 p
= build_offset (htab
->params
->stub_bfd
, p
, off
,
11369 stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
);
11372 if (stub_entry
->stub_type
<= ppc_stub_long_branch_both
)
11376 from
= (stub_entry
->stub_offset
11377 + stub_entry
->group
->stub_sec
->output_offset
11378 + stub_entry
->group
->stub_sec
->output_section
->vma
11380 bfd_put_32 (htab
->params
->stub_bfd
,
11381 B_DOT
| ((targ
- from
) & 0x3fffffc), p
);
11385 bfd_put_32 (htab
->params
->stub_bfd
, MTCTR_R12
, p
);
11387 bfd_put_32 (htab
->params
->stub_bfd
, BCTR
, p
);
11391 if (info
->emitrelocations
)
11393 bfd_vma roff
= relp
- stub_entry
->group
->stub_sec
->contents
;
11394 if (htab
->powerxx_stubs
)
11395 num_rel
+= num_relocs_for_powerxx_offset (off
, odd
);
11398 num_rel
+= num_relocs_for_offset (off
);
11401 r
= get_relocs (stub_entry
->group
->stub_sec
, num_rel
);
11404 if (htab
->powerxx_stubs
)
11405 r
= emit_relocs_for_powerxx_offset (info
, r
, roff
, targ
, off
, odd
);
11407 r
= emit_relocs_for_offset (info
, r
, roff
, targ
, off
);
11408 if (stub_entry
->stub_type
== ppc_stub_long_branch_notoc
11409 || stub_entry
->stub_type
== ppc_stub_long_branch_both
)
11412 roff
= p
- 4 - stub_entry
->group
->stub_sec
->contents
;
11413 r
->r_offset
= roff
;
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
, num_rel
))
11422 if (!htab
->powerxx_stubs
11423 && htab
->glink_eh_frame
!= NULL
11424 && htab
->glink_eh_frame
->size
!= 0)
11426 bfd_byte
*base
, *eh
;
11427 unsigned int lr_used
, delta
;
11429 base
= (htab
->glink_eh_frame
->contents
11430 + stub_entry
->group
->eh_base
+ 17);
11431 eh
= base
+ stub_entry
->group
->eh_size
;
11432 lr_used
= stub_entry
->stub_offset
+ 8;
11433 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
11434 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
11435 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
11437 delta
= lr_used
- stub_entry
->group
->lr_restore
;
11438 stub_entry
->group
->lr_restore
= lr_used
+ 8;
11439 eh
= eh_advance (htab
->elf
.dynobj
, eh
, delta
);
11440 *eh
++ = DW_CFA_register
;
11443 *eh
++ = DW_CFA_advance_loc
+ 2;
11444 *eh
++ = DW_CFA_restore_extended
;
11446 stub_entry
->group
->eh_size
= eh
- base
;
11450 case ppc_stub_plt_call
:
11451 case ppc_stub_plt_call_r2save
:
11452 if (stub_entry
->h
!= NULL
11453 && stub_entry
->h
->is_func_descriptor
11454 && stub_entry
->h
->oh
!= NULL
)
11456 struct ppc_link_hash_entry
*fh
= ppc_follow_link (stub_entry
->h
->oh
);
11458 /* If the old-ABI "dot-symbol" is undefined make it weak so
11459 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL. */
11460 if (fh
->elf
.root
.type
== bfd_link_hash_undefined
11461 && (stub_entry
->h
->elf
.root
.type
== bfd_link_hash_defined
11462 || stub_entry
->h
->elf
.root
.type
== bfd_link_hash_defweak
))
11463 fh
->elf
.root
.type
= bfd_link_hash_undefweak
;
11466 /* Now build the stub. */
11467 targ
= stub_entry
->plt_ent
->plt
.offset
& ~1;
11468 if (targ
>= (bfd_vma
) -2)
11471 plt
= htab
->elf
.splt
;
11472 if (!htab
->elf
.dynamic_sections_created
11473 || stub_entry
->h
== NULL
11474 || stub_entry
->h
->elf
.dynindx
== -1)
11476 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
11477 plt
= htab
->elf
.iplt
;
11479 plt
= htab
->pltlocal
;
11481 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
11483 off
= (elf_gp (info
->output_bfd
)
11484 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
11487 if (off
+ 0x80008000 > 0xffffffff || (off
& 7) != 0)
11489 info
->callbacks
->einfo
11490 /* xgettext:c-format */
11491 (_("%P: linkage table error against `%pT'\n"),
11492 stub_entry
->h
!= NULL
11493 ? stub_entry
->h
->elf
.root
.root
.string
11495 bfd_set_error (bfd_error_bad_value
);
11496 htab
->stub_error
= TRUE
;
11501 if (info
->emitrelocations
)
11503 r
= get_relocs (stub_entry
->group
->stub_sec
,
11504 ((PPC_HA (off
) != 0)
11506 ? 2 + (htab
->params
->plt_static_chain
11507 && PPC_HA (off
+ 16) == PPC_HA (off
))
11511 r
[0].r_offset
= loc
- stub_entry
->group
->stub_sec
->contents
;
11512 if (bfd_big_endian (info
->output_bfd
))
11513 r
[0].r_offset
+= 2;
11514 r
[0].r_addend
= targ
;
11516 if (stub_entry
->h
!= NULL
11517 && (stub_entry
->h
== htab
->tls_get_addr_fd
11518 || stub_entry
->h
== htab
->tls_get_addr
)
11519 && htab
->params
->tls_get_addr_opt
)
11520 p
= build_tls_get_addr_stub (htab
, stub_entry
, loc
, off
, r
);
11522 p
= build_plt_stub (htab
, stub_entry
, loc
, off
, r
);
11525 case ppc_stub_save_res
:
11533 stub_entry
->group
->stub_sec
->size
= stub_entry
->stub_offset
+ (p
- loc
);
11535 if (htab
->params
->emit_stub_syms
)
11537 struct elf_link_hash_entry
*h
;
11540 const char *const stub_str
[] = { "long_branch",
11553 len1
= strlen (stub_str
[stub_entry
->stub_type
- 1]);
11554 len2
= strlen (stub_entry
->root
.string
);
11555 name
= bfd_malloc (len1
+ len2
+ 2);
11558 memcpy (name
, stub_entry
->root
.string
, 9);
11559 memcpy (name
+ 9, stub_str
[stub_entry
->stub_type
- 1], len1
);
11560 memcpy (name
+ len1
+ 9, stub_entry
->root
.string
+ 8, len2
- 8 + 1);
11561 h
= elf_link_hash_lookup (&htab
->elf
, name
, TRUE
, FALSE
, FALSE
);
11564 if (h
->root
.type
== bfd_link_hash_new
)
11566 h
->root
.type
= bfd_link_hash_defined
;
11567 h
->root
.u
.def
.section
= stub_entry
->group
->stub_sec
;
11568 h
->root
.u
.def
.value
= stub_entry
->stub_offset
;
11569 h
->ref_regular
= 1;
11570 h
->def_regular
= 1;
11571 h
->ref_regular_nonweak
= 1;
11572 h
->forced_local
= 1;
11574 h
->root
.linker_def
= 1;
11581 /* As above, but don't actually build the stub. Just bump offset so
11582 we know stub section sizes, and select plt_branch stubs where
11583 long_branch stubs won't do. */
11586 ppc_size_one_stub (struct bfd_hash_entry
*gen_entry
, void *in_arg
)
11588 struct ppc_stub_hash_entry
*stub_entry
;
11589 struct bfd_link_info
*info
;
11590 struct ppc_link_hash_table
*htab
;
11592 bfd_vma targ
, off
, r2off
;
11593 unsigned int size
, extra
, lr_used
, delta
, odd
;
11595 /* Massage our args to the form they really have. */
11596 stub_entry
= (struct ppc_stub_hash_entry
*) gen_entry
;
11599 htab
= ppc_hash_table (info
);
11603 /* Make a note of the offset within the stubs for this entry. */
11604 stub_entry
->stub_offset
= stub_entry
->group
->stub_sec
->size
;
11606 if (stub_entry
->h
!= NULL
11607 && stub_entry
->h
->save_res
11608 && stub_entry
->h
->elf
.root
.type
== bfd_link_hash_defined
11609 && stub_entry
->h
->elf
.root
.u
.def
.section
== htab
->sfpr
)
11611 /* Don't make stubs to out-of-line register save/restore
11612 functions. Instead, emit copies of the functions. */
11613 stub_entry
->group
->needs_save_res
= 1;
11614 stub_entry
->stub_type
= ppc_stub_save_res
;
11618 switch (stub_entry
->stub_type
)
11620 case ppc_stub_plt_branch
:
11621 case ppc_stub_plt_branch_r2off
:
11622 /* Reset the stub type from the plt branch variant in case we now
11623 can reach with a shorter stub. */
11624 stub_entry
->stub_type
+= ppc_stub_long_branch
- ppc_stub_plt_branch
;
11625 /* Fall through. */
11626 case ppc_stub_long_branch
:
11627 case ppc_stub_long_branch_r2off
:
11628 targ
= (stub_entry
->target_value
11629 + stub_entry
->target_section
->output_offset
11630 + stub_entry
->target_section
->output_section
->vma
);
11631 targ
+= PPC64_LOCAL_ENTRY_OFFSET (stub_entry
->other
);
11632 off
= (stub_entry
->stub_offset
11633 + stub_entry
->group
->stub_sec
->output_offset
11634 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11638 if (stub_entry
->stub_type
== ppc_stub_long_branch_r2off
)
11640 r2off
= get_r2off (info
, stub_entry
);
11641 if (r2off
== (bfd_vma
) -1)
11643 htab
->stub_error
= TRUE
;
11647 if (PPC_HA (r2off
) != 0)
11649 if (PPC_LO (r2off
) != 0)
11655 /* If the branch offset is too big, use a ppc_stub_plt_branch.
11656 Do the same for -R objects without function descriptors. */
11657 if ((stub_entry
->stub_type
== ppc_stub_long_branch_r2off
11659 && htab
->sec_info
[stub_entry
->target_section
->id
].toc_off
== 0)
11660 || off
+ (1 << 25) >= (bfd_vma
) (1 << 26))
11662 struct ppc_branch_hash_entry
*br_entry
;
11664 br_entry
= ppc_branch_hash_lookup (&htab
->branch_hash_table
,
11665 stub_entry
->root
.string
+ 9,
11667 if (br_entry
== NULL
)
11669 _bfd_error_handler (_("can't build branch stub `%s'"),
11670 stub_entry
->root
.string
);
11671 htab
->stub_error
= TRUE
;
11675 if (br_entry
->iter
!= htab
->stub_iteration
)
11677 br_entry
->iter
= htab
->stub_iteration
;
11678 br_entry
->offset
= htab
->brlt
->size
;
11679 htab
->brlt
->size
+= 8;
11681 if (htab
->relbrlt
!= NULL
)
11682 htab
->relbrlt
->size
+= sizeof (Elf64_External_Rela
);
11683 else if (info
->emitrelocations
)
11685 htab
->brlt
->reloc_count
+= 1;
11686 htab
->brlt
->flags
|= SEC_RELOC
;
11690 targ
= (br_entry
->offset
11691 + htab
->brlt
->output_offset
11692 + htab
->brlt
->output_section
->vma
);
11693 off
= (elf_gp (info
->output_bfd
)
11694 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
11697 if (info
->emitrelocations
)
11699 stub_entry
->group
->stub_sec
->reloc_count
11700 += 1 + (PPC_HA (off
) != 0);
11701 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
11704 stub_entry
->stub_type
+= ppc_stub_plt_branch
- ppc_stub_long_branch
;
11705 if (stub_entry
->stub_type
!= ppc_stub_plt_branch_r2off
)
11708 if (PPC_HA (off
) != 0)
11714 if (PPC_HA (off
) != 0)
11717 if (PPC_HA (r2off
) != 0)
11719 if (PPC_LO (r2off
) != 0)
11723 else if (info
->emitrelocations
)
11725 stub_entry
->group
->stub_sec
->reloc_count
+= 1;
11726 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
11730 case ppc_stub_plt_branch_notoc
:
11731 case ppc_stub_plt_branch_both
:
11732 stub_entry
->stub_type
+= ppc_stub_long_branch
- ppc_stub_plt_branch
;
11733 /* Fall through. */
11734 case ppc_stub_long_branch_notoc
:
11735 case ppc_stub_long_branch_both
:
11736 off
= (stub_entry
->stub_offset
11737 + stub_entry
->group
->stub_sec
->output_offset
11738 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11740 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
)
11743 targ
= (stub_entry
->target_value
11744 + stub_entry
->target_section
->output_offset
11745 + stub_entry
->target_section
->output_section
->vma
);
11749 if (info
->emitrelocations
)
11751 unsigned int num_rel
;
11752 if (htab
->powerxx_stubs
)
11753 num_rel
= num_relocs_for_powerxx_offset (off
, odd
);
11755 num_rel
= num_relocs_for_offset (off
- 8);
11756 stub_entry
->group
->stub_sec
->reloc_count
+= num_rel
;
11757 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
11760 if (htab
->powerxx_stubs
)
11761 extra
= size_powerxx_offset (off
, odd
);
11763 extra
= size_offset (off
- 8);
11764 /* Include branch insn plus those in the offset sequence. */
11766 /* The branch insn is at the end, or "extra" bytes along. So
11767 its offset will be "extra" bytes less that that already
11771 if (!htab
->powerxx_stubs
)
11773 /* After the bcl, lr has been modified so we need to emit
11774 .eh_frame info saying the return address is in r12. */
11775 lr_used
= stub_entry
->stub_offset
+ 8;
11776 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
)
11778 /* The eh_frame info will consist of a DW_CFA_advance_loc or
11779 variant, DW_CFA_register, 65, 12, DW_CFA_advance_loc+2,
11780 DW_CFA_restore_extended 65. */
11781 delta
= lr_used
- stub_entry
->group
->lr_restore
;
11782 stub_entry
->group
->eh_size
+= eh_advance_size (delta
) + 6;
11783 stub_entry
->group
->lr_restore
= lr_used
+ 8;
11786 /* If the branch can't reach, use a plt_branch. */
11787 if (off
+ (1 << 25) >= (bfd_vma
) (1 << 26))
11789 stub_entry
->stub_type
+= (ppc_stub_plt_branch_notoc
11790 - ppc_stub_long_branch_notoc
);
11793 else if (info
->emitrelocations
)
11794 stub_entry
->group
->stub_sec
->reloc_count
+=1;
11797 case ppc_stub_plt_call_notoc
:
11798 case ppc_stub_plt_call_both
:
11799 off
= (stub_entry
->stub_offset
11800 + stub_entry
->group
->stub_sec
->output_offset
11801 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11802 if (stub_entry
->stub_type
== ppc_stub_plt_call_both
)
11804 targ
= stub_entry
->plt_ent
->plt
.offset
& ~1;
11805 if (targ
>= (bfd_vma
) -2)
11808 plt
= htab
->elf
.splt
;
11809 if (!htab
->elf
.dynamic_sections_created
11810 || stub_entry
->h
== NULL
11811 || stub_entry
->h
->elf
.dynindx
== -1)
11813 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
11814 plt
= htab
->elf
.iplt
;
11816 plt
= htab
->pltlocal
;
11818 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
11822 if (htab
->params
->plt_stub_align
!= 0)
11824 unsigned pad
= plt_stub_pad (htab
, stub_entry
, off
);
11826 stub_entry
->group
->stub_sec
->size
+= pad
;
11827 stub_entry
->stub_offset
= stub_entry
->group
->stub_sec
->size
;
11831 if (info
->emitrelocations
)
11833 unsigned int num_rel
;
11834 if (htab
->powerxx_stubs
)
11835 num_rel
= num_relocs_for_powerxx_offset (off
, odd
);
11837 num_rel
= num_relocs_for_offset (off
- 8);
11838 stub_entry
->group
->stub_sec
->reloc_count
+= num_rel
;
11839 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
11842 size
= plt_stub_size (htab
, stub_entry
, off
);
11844 if (!htab
->powerxx_stubs
)
11846 /* After the bcl, lr has been modified so we need to emit
11847 .eh_frame info saying the return address is in r12. */
11848 lr_used
= stub_entry
->stub_offset
+ 8;
11849 if (stub_entry
->stub_type
== ppc_stub_plt_call_both
)
11851 /* The eh_frame info will consist of a DW_CFA_advance_loc or
11852 variant, DW_CFA_register, 65, 12, DW_CFA_advance_loc+2,
11853 DW_CFA_restore_extended 65. */
11854 delta
= lr_used
- stub_entry
->group
->lr_restore
;
11855 stub_entry
->group
->eh_size
+= eh_advance_size (delta
) + 6;
11856 stub_entry
->group
->lr_restore
= lr_used
+ 8;
11860 case ppc_stub_plt_call
:
11861 case ppc_stub_plt_call_r2save
:
11862 targ
= stub_entry
->plt_ent
->plt
.offset
& ~(bfd_vma
) 1;
11863 if (targ
>= (bfd_vma
) -2)
11865 plt
= htab
->elf
.splt
;
11866 if (!htab
->elf
.dynamic_sections_created
11867 || stub_entry
->h
== NULL
11868 || stub_entry
->h
->elf
.dynindx
== -1)
11870 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
11871 plt
= htab
->elf
.iplt
;
11873 plt
= htab
->pltlocal
;
11875 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
11877 off
= (elf_gp (info
->output_bfd
)
11878 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
11881 if (htab
->params
->plt_stub_align
!= 0)
11883 unsigned pad
= plt_stub_pad (htab
, stub_entry
, off
);
11885 stub_entry
->group
->stub_sec
->size
+= pad
;
11886 stub_entry
->stub_offset
= stub_entry
->group
->stub_sec
->size
;
11889 if (info
->emitrelocations
)
11891 stub_entry
->group
->stub_sec
->reloc_count
11892 += ((PPC_HA (off
) != 0)
11894 ? 2 + (htab
->params
->plt_static_chain
11895 && PPC_HA (off
+ 16) == PPC_HA (off
))
11897 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
11900 size
= plt_stub_size (htab
, stub_entry
, off
);
11902 if (stub_entry
->h
!= NULL
11903 && (stub_entry
->h
== htab
->tls_get_addr_fd
11904 || stub_entry
->h
== htab
->tls_get_addr
)
11905 && htab
->params
->tls_get_addr_opt
11906 && stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
11908 /* After the bctrl, lr has been modified so we need to
11909 emit .eh_frame info saying the return address is
11910 on the stack. In fact we put the EH info specifying
11911 that the return address is on the stack *at* the
11912 call rather than after it, because the EH info for a
11913 call needs to be specified by that point.
11914 See libgcc/unwind-dw2.c execute_cfa_program. */
11915 lr_used
= stub_entry
->stub_offset
+ size
- 20;
11916 /* The eh_frame info will consist of a DW_CFA_advance_loc
11917 or variant, DW_CFA_offset_externed_sf, 65, -stackoff,
11918 DW_CFA_advance_loc+4, DW_CFA_restore_extended, 65. */
11919 delta
= lr_used
- stub_entry
->group
->lr_restore
;
11920 stub_entry
->group
->eh_size
+= eh_advance_size (delta
) + 6;
11921 stub_entry
->group
->lr_restore
= size
- 4;
11930 stub_entry
->group
->stub_sec
->size
+= size
;
11934 /* Set up various things so that we can make a list of input sections
11935 for each output section included in the link. Returns -1 on error,
11936 0 when no stubs will be needed, and 1 on success. */
11939 ppc64_elf_setup_section_lists (struct bfd_link_info
*info
)
11943 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
11948 htab
->sec_info_arr_size
= _bfd_section_id
;
11949 amt
= sizeof (*htab
->sec_info
) * (htab
->sec_info_arr_size
);
11950 htab
->sec_info
= bfd_zmalloc (amt
);
11951 if (htab
->sec_info
== NULL
)
11954 /* Set toc_off for com, und, abs and ind sections. */
11955 for (id
= 0; id
< 3; id
++)
11956 htab
->sec_info
[id
].toc_off
= TOC_BASE_OFF
;
11961 /* Set up for first pass at multitoc partitioning. */
11964 ppc64_elf_start_multitoc_partition (struct bfd_link_info
*info
)
11966 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
11968 htab
->toc_curr
= ppc64_elf_set_toc (info
, info
->output_bfd
);
11969 htab
->toc_bfd
= NULL
;
11970 htab
->toc_first_sec
= NULL
;
11973 /* The linker repeatedly calls this function for each TOC input section
11974 and linker generated GOT section. Group input bfds such that the toc
11975 within a group is less than 64k in size. */
11978 ppc64_elf_next_toc_section (struct bfd_link_info
*info
, asection
*isec
)
11980 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
11981 bfd_vma addr
, off
, limit
;
11986 if (!htab
->second_toc_pass
)
11988 /* Keep track of the first .toc or .got section for this input bfd. */
11989 bfd_boolean new_bfd
= htab
->toc_bfd
!= isec
->owner
;
11993 htab
->toc_bfd
= isec
->owner
;
11994 htab
->toc_first_sec
= isec
;
11997 addr
= isec
->output_offset
+ isec
->output_section
->vma
;
11998 off
= addr
- htab
->toc_curr
;
11999 limit
= 0x80008000;
12000 if (ppc64_elf_tdata (isec
->owner
)->has_small_toc_reloc
)
12002 if (off
+ isec
->size
> limit
)
12004 addr
= (htab
->toc_first_sec
->output_offset
12005 + htab
->toc_first_sec
->output_section
->vma
);
12006 htab
->toc_curr
= addr
;
12007 htab
->toc_curr
&= -TOC_BASE_ALIGN
;
12010 /* toc_curr is the base address of this toc group. Set elf_gp
12011 for the input section to be the offset relative to the
12012 output toc base plus 0x8000. Making the input elf_gp an
12013 offset allows us to move the toc as a whole without
12014 recalculating input elf_gp. */
12015 off
= htab
->toc_curr
- elf_gp (info
->output_bfd
);
12016 off
+= TOC_BASE_OFF
;
12018 /* Die if someone uses a linker script that doesn't keep input
12019 file .toc and .got together. */
12021 && elf_gp (isec
->owner
) != 0
12022 && elf_gp (isec
->owner
) != off
)
12025 elf_gp (isec
->owner
) = off
;
12029 /* During the second pass toc_first_sec points to the start of
12030 a toc group, and toc_curr is used to track the old elf_gp.
12031 We use toc_bfd to ensure we only look at each bfd once. */
12032 if (htab
->toc_bfd
== isec
->owner
)
12034 htab
->toc_bfd
= isec
->owner
;
12036 if (htab
->toc_first_sec
== NULL
12037 || htab
->toc_curr
!= elf_gp (isec
->owner
))
12039 htab
->toc_curr
= elf_gp (isec
->owner
);
12040 htab
->toc_first_sec
= isec
;
12042 addr
= (htab
->toc_first_sec
->output_offset
12043 + htab
->toc_first_sec
->output_section
->vma
);
12044 off
= addr
- elf_gp (info
->output_bfd
) + TOC_BASE_OFF
;
12045 elf_gp (isec
->owner
) = off
;
12050 /* Called via elf_link_hash_traverse to merge GOT entries for global
12054 merge_global_got (struct elf_link_hash_entry
*h
, void *inf ATTRIBUTE_UNUSED
)
12056 if (h
->root
.type
== bfd_link_hash_indirect
)
12059 merge_got_entries (&h
->got
.glist
);
12064 /* Called via elf_link_hash_traverse to allocate GOT entries for global
12068 reallocate_got (struct elf_link_hash_entry
*h
, void *inf
)
12070 struct got_entry
*gent
;
12072 if (h
->root
.type
== bfd_link_hash_indirect
)
12075 for (gent
= h
->got
.glist
; gent
!= NULL
; gent
= gent
->next
)
12076 if (!gent
->is_indirect
)
12077 allocate_got (h
, (struct bfd_link_info
*) inf
, gent
);
12081 /* Called on the first multitoc pass after the last call to
12082 ppc64_elf_next_toc_section. This function removes duplicate GOT
12086 ppc64_elf_layout_multitoc (struct bfd_link_info
*info
)
12088 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12089 struct bfd
*ibfd
, *ibfd2
;
12090 bfd_boolean done_something
;
12092 htab
->multi_toc_needed
= htab
->toc_curr
!= elf_gp (info
->output_bfd
);
12094 if (!htab
->do_multi_toc
)
12097 /* Merge global sym got entries within a toc group. */
12098 elf_link_hash_traverse (&htab
->elf
, merge_global_got
, info
);
12100 /* And tlsld_got. */
12101 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12103 struct got_entry
*ent
, *ent2
;
12105 if (!is_ppc64_elf (ibfd
))
12108 ent
= ppc64_tlsld_got (ibfd
);
12109 if (!ent
->is_indirect
12110 && ent
->got
.offset
!= (bfd_vma
) -1)
12112 for (ibfd2
= ibfd
->link
.next
; ibfd2
!= NULL
; ibfd2
= ibfd2
->link
.next
)
12114 if (!is_ppc64_elf (ibfd2
))
12117 ent2
= ppc64_tlsld_got (ibfd2
);
12118 if (!ent2
->is_indirect
12119 && ent2
->got
.offset
!= (bfd_vma
) -1
12120 && elf_gp (ibfd2
) == elf_gp (ibfd
))
12122 ent2
->is_indirect
= TRUE
;
12123 ent2
->got
.ent
= ent
;
12129 /* Zap sizes of got sections. */
12130 htab
->elf
.irelplt
->rawsize
= htab
->elf
.irelplt
->size
;
12131 htab
->elf
.irelplt
->size
-= htab
->got_reli_size
;
12132 htab
->got_reli_size
= 0;
12134 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12136 asection
*got
, *relgot
;
12138 if (!is_ppc64_elf (ibfd
))
12141 got
= ppc64_elf_tdata (ibfd
)->got
;
12144 got
->rawsize
= got
->size
;
12146 relgot
= ppc64_elf_tdata (ibfd
)->relgot
;
12147 relgot
->rawsize
= relgot
->size
;
12152 /* Now reallocate the got, local syms first. We don't need to
12153 allocate section contents again since we never increase size. */
12154 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12156 struct got_entry
**lgot_ents
;
12157 struct got_entry
**end_lgot_ents
;
12158 struct plt_entry
**local_plt
;
12159 struct plt_entry
**end_local_plt
;
12160 unsigned char *lgot_masks
;
12161 bfd_size_type locsymcount
;
12162 Elf_Internal_Shdr
*symtab_hdr
;
12165 if (!is_ppc64_elf (ibfd
))
12168 lgot_ents
= elf_local_got_ents (ibfd
);
12172 symtab_hdr
= &elf_symtab_hdr (ibfd
);
12173 locsymcount
= symtab_hdr
->sh_info
;
12174 end_lgot_ents
= lgot_ents
+ locsymcount
;
12175 local_plt
= (struct plt_entry
**) end_lgot_ents
;
12176 end_local_plt
= local_plt
+ locsymcount
;
12177 lgot_masks
= (unsigned char *) end_local_plt
;
12178 s
= ppc64_elf_tdata (ibfd
)->got
;
12179 for (; lgot_ents
< end_lgot_ents
; ++lgot_ents
, ++lgot_masks
)
12181 struct got_entry
*ent
;
12183 for (ent
= *lgot_ents
; ent
!= NULL
; ent
= ent
->next
)
12185 unsigned int ent_size
= 8;
12186 unsigned int rel_size
= sizeof (Elf64_External_Rela
);
12188 ent
->got
.offset
= s
->size
;
12189 if ((ent
->tls_type
& *lgot_masks
& TLS_GD
) != 0)
12194 s
->size
+= ent_size
;
12195 if ((*lgot_masks
& (TLS_TLS
| PLT_IFUNC
)) == PLT_IFUNC
)
12197 htab
->elf
.irelplt
->size
+= rel_size
;
12198 htab
->got_reli_size
+= rel_size
;
12200 else if (bfd_link_pic (info
)
12201 && !(ent
->tls_type
!= 0
12202 && bfd_link_executable (info
)))
12204 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
12205 srel
->size
+= rel_size
;
12211 elf_link_hash_traverse (&htab
->elf
, reallocate_got
, info
);
12213 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12215 struct got_entry
*ent
;
12217 if (!is_ppc64_elf (ibfd
))
12220 ent
= ppc64_tlsld_got (ibfd
);
12221 if (!ent
->is_indirect
12222 && ent
->got
.offset
!= (bfd_vma
) -1)
12224 asection
*s
= ppc64_elf_tdata (ibfd
)->got
;
12225 ent
->got
.offset
= s
->size
;
12227 if (bfd_link_dll (info
))
12229 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
12230 srel
->size
+= sizeof (Elf64_External_Rela
);
12235 done_something
= htab
->elf
.irelplt
->rawsize
!= htab
->elf
.irelplt
->size
;
12236 if (!done_something
)
12237 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12241 if (!is_ppc64_elf (ibfd
))
12244 got
= ppc64_elf_tdata (ibfd
)->got
;
12247 done_something
= got
->rawsize
!= got
->size
;
12248 if (done_something
)
12253 if (done_something
)
12254 (*htab
->params
->layout_sections_again
) ();
12256 /* Set up for second pass over toc sections to recalculate elf_gp
12257 on input sections. */
12258 htab
->toc_bfd
= NULL
;
12259 htab
->toc_first_sec
= NULL
;
12260 htab
->second_toc_pass
= TRUE
;
12261 return done_something
;
12264 /* Called after second pass of multitoc partitioning. */
12267 ppc64_elf_finish_multitoc_partition (struct bfd_link_info
*info
)
12269 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12271 /* After the second pass, toc_curr tracks the TOC offset used
12272 for code sections below in ppc64_elf_next_input_section. */
12273 htab
->toc_curr
= TOC_BASE_OFF
;
12276 /* No toc references were found in ISEC. If the code in ISEC makes no
12277 calls, then there's no need to use toc adjusting stubs when branching
12278 into ISEC. Actually, indirect calls from ISEC are OK as they will
12279 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
12280 needed, and 2 if a cyclical call-graph was found but no other reason
12281 for a stub was detected. If called from the top level, a return of
12282 2 means the same as a return of 0. */
12285 toc_adjusting_stub_needed (struct bfd_link_info
*info
, asection
*isec
)
12289 /* Mark this section as checked. */
12290 isec
->call_check_done
= 1;
12292 /* We know none of our code bearing sections will need toc stubs. */
12293 if ((isec
->flags
& SEC_LINKER_CREATED
) != 0)
12296 if (isec
->size
== 0)
12299 if (isec
->output_section
== NULL
)
12303 if (isec
->reloc_count
!= 0)
12305 Elf_Internal_Rela
*relstart
, *rel
;
12306 Elf_Internal_Sym
*local_syms
;
12307 struct ppc_link_hash_table
*htab
;
12309 relstart
= _bfd_elf_link_read_relocs (isec
->owner
, isec
, NULL
, NULL
,
12310 info
->keep_memory
);
12311 if (relstart
== NULL
)
12314 /* Look for branches to outside of this section. */
12316 htab
= ppc_hash_table (info
);
12320 for (rel
= relstart
; rel
< relstart
+ isec
->reloc_count
; ++rel
)
12322 enum elf_ppc64_reloc_type r_type
;
12323 unsigned long r_symndx
;
12324 struct elf_link_hash_entry
*h
;
12325 struct ppc_link_hash_entry
*eh
;
12326 Elf_Internal_Sym
*sym
;
12328 struct _opd_sec_data
*opd
;
12332 r_type
= ELF64_R_TYPE (rel
->r_info
);
12333 if (r_type
!= R_PPC64_REL24
12334 && r_type
!= R_PPC64_REL24_NOTOC
12335 && r_type
!= R_PPC64_REL14
12336 && r_type
!= R_PPC64_REL14_BRTAKEN
12337 && r_type
!= R_PPC64_REL14_BRNTAKEN
12338 && r_type
!= R_PPC64_PLTCALL
12339 && r_type
!= R_PPC64_PLTCALL_NOTOC
)
12342 r_symndx
= ELF64_R_SYM (rel
->r_info
);
12343 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
, r_symndx
,
12350 /* Calls to dynamic lib functions go through a plt call stub
12352 eh
= (struct ppc_link_hash_entry
*) h
;
12354 && (eh
->elf
.plt
.plist
!= NULL
12356 && ppc_follow_link (eh
->oh
)->elf
.plt
.plist
!= NULL
)))
12362 if (sym_sec
== NULL
)
12363 /* Ignore other undefined symbols. */
12366 /* Assume branches to other sections not included in the
12367 link need stubs too, to cover -R and absolute syms. */
12368 if (sym_sec
->output_section
== NULL
)
12375 sym_value
= sym
->st_value
;
12378 if (h
->root
.type
!= bfd_link_hash_defined
12379 && h
->root
.type
!= bfd_link_hash_defweak
)
12381 sym_value
= h
->root
.u
.def
.value
;
12383 sym_value
+= rel
->r_addend
;
12385 /* If this branch reloc uses an opd sym, find the code section. */
12386 opd
= get_opd_info (sym_sec
);
12389 if (h
== NULL
&& opd
->adjust
!= NULL
)
12393 adjust
= opd
->adjust
[OPD_NDX (sym_value
)];
12395 /* Assume deleted functions won't ever be called. */
12397 sym_value
+= adjust
;
12400 dest
= opd_entry_value (sym_sec
, sym_value
,
12401 &sym_sec
, NULL
, FALSE
);
12402 if (dest
== (bfd_vma
) -1)
12407 + sym_sec
->output_offset
12408 + sym_sec
->output_section
->vma
);
12410 /* Ignore branch to self. */
12411 if (sym_sec
== isec
)
12414 /* If the called function uses the toc, we need a stub. */
12415 if (sym_sec
->has_toc_reloc
12416 || sym_sec
->makes_toc_func_call
)
12422 /* Assume any branch that needs a long branch stub might in fact
12423 need a plt_branch stub. A plt_branch stub uses r2. */
12424 else if (dest
- (isec
->output_offset
12425 + isec
->output_section
->vma
12426 + rel
->r_offset
) + (1 << 25)
12427 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
12435 /* If calling back to a section in the process of being
12436 tested, we can't say for sure that no toc adjusting stubs
12437 are needed, so don't return zero. */
12438 else if (sym_sec
->call_check_in_progress
)
12441 /* Branches to another section that itself doesn't have any TOC
12442 references are OK. Recursively call ourselves to check. */
12443 else if (!sym_sec
->call_check_done
)
12447 /* Mark current section as indeterminate, so that other
12448 sections that call back to current won't be marked as
12450 isec
->call_check_in_progress
= 1;
12451 recur
= toc_adjusting_stub_needed (info
, sym_sec
);
12452 isec
->call_check_in_progress
= 0;
12463 if (local_syms
!= NULL
12464 && (elf_symtab_hdr (isec
->owner
).contents
12465 != (unsigned char *) local_syms
))
12467 if (elf_section_data (isec
)->relocs
!= relstart
)
12472 && isec
->map_head
.s
!= NULL
12473 && (strcmp (isec
->output_section
->name
, ".init") == 0
12474 || strcmp (isec
->output_section
->name
, ".fini") == 0))
12476 if (isec
->map_head
.s
->has_toc_reloc
12477 || isec
->map_head
.s
->makes_toc_func_call
)
12479 else if (!isec
->map_head
.s
->call_check_done
)
12482 isec
->call_check_in_progress
= 1;
12483 recur
= toc_adjusting_stub_needed (info
, isec
->map_head
.s
);
12484 isec
->call_check_in_progress
= 0;
12491 isec
->makes_toc_func_call
= 1;
12496 /* The linker repeatedly calls this function for each input section,
12497 in the order that input sections are linked into output sections.
12498 Build lists of input sections to determine groupings between which
12499 we may insert linker stubs. */
12502 ppc64_elf_next_input_section (struct bfd_link_info
*info
, asection
*isec
)
12504 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12509 if ((isec
->output_section
->flags
& SEC_CODE
) != 0
12510 && isec
->output_section
->id
< htab
->sec_info_arr_size
)
12512 /* This happens to make the list in reverse order,
12513 which is what we want. */
12514 htab
->sec_info
[isec
->id
].u
.list
12515 = htab
->sec_info
[isec
->output_section
->id
].u
.list
;
12516 htab
->sec_info
[isec
->output_section
->id
].u
.list
= isec
;
12519 if (htab
->multi_toc_needed
)
12521 /* Analyse sections that aren't already flagged as needing a
12522 valid toc pointer. Exclude .fixup for the linux kernel.
12523 .fixup contains branches, but only back to the function that
12524 hit an exception. */
12525 if (!(isec
->has_toc_reloc
12526 || (isec
->flags
& SEC_CODE
) == 0
12527 || strcmp (isec
->name
, ".fixup") == 0
12528 || isec
->call_check_done
))
12530 if (toc_adjusting_stub_needed (info
, isec
) < 0)
12533 /* Make all sections use the TOC assigned for this object file.
12534 This will be wrong for pasted sections; We fix that in
12535 check_pasted_section(). */
12536 if (elf_gp (isec
->owner
) != 0)
12537 htab
->toc_curr
= elf_gp (isec
->owner
);
12540 htab
->sec_info
[isec
->id
].toc_off
= htab
->toc_curr
;
12544 /* Check that all .init and .fini sections use the same toc, if they
12545 have toc relocs. */
12548 check_pasted_section (struct bfd_link_info
*info
, const char *name
)
12550 asection
*o
= bfd_get_section_by_name (info
->output_bfd
, name
);
12554 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12555 bfd_vma toc_off
= 0;
12558 for (i
= o
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
12559 if (i
->has_toc_reloc
)
12562 toc_off
= htab
->sec_info
[i
->id
].toc_off
;
12563 else if (toc_off
!= htab
->sec_info
[i
->id
].toc_off
)
12568 for (i
= o
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
12569 if (i
->makes_toc_func_call
)
12571 toc_off
= htab
->sec_info
[i
->id
].toc_off
;
12575 /* Make sure the whole pasted function uses the same toc offset. */
12577 for (i
= o
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
12578 htab
->sec_info
[i
->id
].toc_off
= toc_off
;
12584 ppc64_elf_check_init_fini (struct bfd_link_info
*info
)
12586 return (check_pasted_section (info
, ".init")
12587 & check_pasted_section (info
, ".fini"));
12590 /* See whether we can group stub sections together. Grouping stub
12591 sections may result in fewer stubs. More importantly, we need to
12592 put all .init* and .fini* stubs at the beginning of the .init or
12593 .fini output sections respectively, because glibc splits the
12594 _init and _fini functions into multiple parts. Putting a stub in
12595 the middle of a function is not a good idea. */
12598 group_sections (struct bfd_link_info
*info
,
12599 bfd_size_type stub_group_size
,
12600 bfd_boolean stubs_always_before_branch
)
12602 struct ppc_link_hash_table
*htab
;
12604 bfd_boolean suppress_size_errors
;
12606 htab
= ppc_hash_table (info
);
12610 suppress_size_errors
= FALSE
;
12611 if (stub_group_size
== 1)
12613 /* Default values. */
12614 if (stubs_always_before_branch
)
12615 stub_group_size
= 0x1e00000;
12617 stub_group_size
= 0x1c00000;
12618 suppress_size_errors
= TRUE
;
12621 for (osec
= info
->output_bfd
->sections
; osec
!= NULL
; osec
= osec
->next
)
12625 if (osec
->id
>= htab
->sec_info_arr_size
)
12628 tail
= htab
->sec_info
[osec
->id
].u
.list
;
12629 while (tail
!= NULL
)
12633 bfd_size_type total
;
12634 bfd_boolean big_sec
;
12636 struct map_stub
*group
;
12637 bfd_size_type group_size
;
12640 total
= tail
->size
;
12641 group_size
= (ppc64_elf_section_data (tail
) != NULL
12642 && ppc64_elf_section_data (tail
)->has_14bit_branch
12643 ? stub_group_size
>> 10 : stub_group_size
);
12645 big_sec
= total
> group_size
;
12646 if (big_sec
&& !suppress_size_errors
)
12647 /* xgettext:c-format */
12648 _bfd_error_handler (_("%pB section %pA exceeds stub group size"),
12649 tail
->owner
, tail
);
12650 curr_toc
= htab
->sec_info
[tail
->id
].toc_off
;
12652 while ((prev
= htab
->sec_info
[curr
->id
].u
.list
) != NULL
12653 && ((total
+= curr
->output_offset
- prev
->output_offset
)
12654 < (ppc64_elf_section_data (prev
) != NULL
12655 && ppc64_elf_section_data (prev
)->has_14bit_branch
12656 ? (group_size
= stub_group_size
>> 10) : group_size
))
12657 && htab
->sec_info
[prev
->id
].toc_off
== curr_toc
)
12660 /* OK, the size from the start of CURR to the end is less
12661 than group_size and thus can be handled by one stub
12662 section. (or the tail section is itself larger than
12663 group_size, in which case we may be toast.) We should
12664 really be keeping track of the total size of stubs added
12665 here, as stubs contribute to the final output section
12666 size. That's a little tricky, and this way will only
12667 break if stubs added make the total size more than 2^25,
12668 ie. for the default stub_group_size, if stubs total more
12669 than 2097152 bytes, or nearly 75000 plt call stubs. */
12670 group
= bfd_alloc (curr
->owner
, sizeof (*group
));
12673 group
->link_sec
= curr
;
12674 group
->stub_sec
= NULL
;
12675 group
->needs_save_res
= 0;
12676 group
->lr_restore
= 0;
12677 group
->eh_size
= 0;
12678 group
->eh_base
= 0;
12679 group
->next
= htab
->group
;
12680 htab
->group
= group
;
12683 prev
= htab
->sec_info
[tail
->id
].u
.list
;
12684 /* Set up this stub group. */
12685 htab
->sec_info
[tail
->id
].u
.group
= group
;
12687 while (tail
!= curr
&& (tail
= prev
) != NULL
);
12689 /* But wait, there's more! Input sections up to group_size
12690 bytes before the stub section can be handled by it too.
12691 Don't do this if we have a really large section after the
12692 stubs, as adding more stubs increases the chance that
12693 branches may not reach into the stub section. */
12694 if (!stubs_always_before_branch
&& !big_sec
)
12697 while (prev
!= NULL
12698 && ((total
+= tail
->output_offset
- prev
->output_offset
)
12699 < (ppc64_elf_section_data (prev
) != NULL
12700 && ppc64_elf_section_data (prev
)->has_14bit_branch
12701 ? (group_size
= stub_group_size
>> 10)
12703 && htab
->sec_info
[prev
->id
].toc_off
== curr_toc
)
12706 prev
= htab
->sec_info
[tail
->id
].u
.list
;
12707 htab
->sec_info
[tail
->id
].u
.group
= group
;
12716 static const unsigned char glink_eh_frame_cie
[] =
12718 0, 0, 0, 16, /* length. */
12719 0, 0, 0, 0, /* id. */
12720 1, /* CIE version. */
12721 'z', 'R', 0, /* Augmentation string. */
12722 4, /* Code alignment. */
12723 0x78, /* Data alignment. */
12725 1, /* Augmentation size. */
12726 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding. */
12727 DW_CFA_def_cfa
, 1, 0 /* def_cfa: r1 offset 0. */
12730 /* Stripping output sections is normally done before dynamic section
12731 symbols have been allocated. This function is called later, and
12732 handles cases like htab->brlt which is mapped to its own output
12736 maybe_strip_output (struct bfd_link_info
*info
, asection
*isec
)
12738 if (isec
->size
== 0
12739 && isec
->output_section
->size
== 0
12740 && !(isec
->output_section
->flags
& SEC_KEEP
)
12741 && !bfd_section_removed_from_list (info
->output_bfd
,
12742 isec
->output_section
)
12743 && elf_section_data (isec
->output_section
)->dynindx
== 0)
12745 isec
->output_section
->flags
|= SEC_EXCLUDE
;
12746 bfd_section_list_remove (info
->output_bfd
, isec
->output_section
);
12747 info
->output_bfd
->section_count
--;
12751 /* Determine and set the size of the stub section for a final link.
12753 The basic idea here is to examine all the relocations looking for
12754 PC-relative calls to a target that is unreachable with a "bl"
12758 ppc64_elf_size_stubs (struct bfd_link_info
*info
)
12760 bfd_size_type stub_group_size
;
12761 bfd_boolean stubs_always_before_branch
;
12762 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12767 if (htab
->params
->plt_thread_safe
== -1 && !bfd_link_executable (info
))
12768 htab
->params
->plt_thread_safe
= 1;
12769 if (!htab
->opd_abi
)
12770 htab
->params
->plt_thread_safe
= 0;
12771 else if (htab
->params
->plt_thread_safe
== -1)
12773 static const char *const thread_starter
[] =
12777 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12779 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12780 "mq_notify", "create_timer",
12785 "GOMP_parallel_start",
12786 "GOMP_parallel_loop_static",
12787 "GOMP_parallel_loop_static_start",
12788 "GOMP_parallel_loop_dynamic",
12789 "GOMP_parallel_loop_dynamic_start",
12790 "GOMP_parallel_loop_guided",
12791 "GOMP_parallel_loop_guided_start",
12792 "GOMP_parallel_loop_runtime",
12793 "GOMP_parallel_loop_runtime_start",
12794 "GOMP_parallel_sections",
12795 "GOMP_parallel_sections_start",
12801 for (i
= 0; i
< ARRAY_SIZE (thread_starter
); i
++)
12803 struct elf_link_hash_entry
*h
;
12804 h
= elf_link_hash_lookup (&htab
->elf
, thread_starter
[i
],
12805 FALSE
, FALSE
, TRUE
);
12806 htab
->params
->plt_thread_safe
= h
!= NULL
&& h
->ref_regular
;
12807 if (htab
->params
->plt_thread_safe
)
12811 stubs_always_before_branch
= htab
->params
->group_size
< 0;
12812 if (htab
->params
->group_size
< 0)
12813 stub_group_size
= -htab
->params
->group_size
;
12815 stub_group_size
= htab
->params
->group_size
;
12817 if (!group_sections (info
, stub_group_size
, stubs_always_before_branch
))
12820 #define STUB_SHRINK_ITER 20
12821 /* Loop until no stubs added. After iteration 20 of this loop we may
12822 exit on a stub section shrinking. This is to break out of a
12823 pathological case where adding stubs on one iteration decreases
12824 section gaps (perhaps due to alignment), which then requires
12825 fewer or smaller stubs on the next iteration. */
12830 unsigned int bfd_indx
;
12831 struct map_stub
*group
;
12833 htab
->stub_iteration
+= 1;
12835 for (input_bfd
= info
->input_bfds
, bfd_indx
= 0;
12837 input_bfd
= input_bfd
->link
.next
, bfd_indx
++)
12839 Elf_Internal_Shdr
*symtab_hdr
;
12841 Elf_Internal_Sym
*local_syms
= NULL
;
12843 if (!is_ppc64_elf (input_bfd
))
12846 /* We'll need the symbol table in a second. */
12847 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
12848 if (symtab_hdr
->sh_info
== 0)
12851 /* Walk over each section attached to the input bfd. */
12852 for (section
= input_bfd
->sections
;
12854 section
= section
->next
)
12856 Elf_Internal_Rela
*internal_relocs
, *irelaend
, *irela
;
12858 /* If there aren't any relocs, then there's nothing more
12860 if ((section
->flags
& SEC_RELOC
) == 0
12861 || (section
->flags
& SEC_ALLOC
) == 0
12862 || (section
->flags
& SEC_LOAD
) == 0
12863 || (section
->flags
& SEC_CODE
) == 0
12864 || section
->reloc_count
== 0)
12867 /* If this section is a link-once section that will be
12868 discarded, then don't create any stubs. */
12869 if (section
->output_section
== NULL
12870 || section
->output_section
->owner
!= info
->output_bfd
)
12873 /* Get the relocs. */
12875 = _bfd_elf_link_read_relocs (input_bfd
, section
, NULL
, NULL
,
12876 info
->keep_memory
);
12877 if (internal_relocs
== NULL
)
12878 goto error_ret_free_local
;
12880 /* Now examine each relocation. */
12881 irela
= internal_relocs
;
12882 irelaend
= irela
+ section
->reloc_count
;
12883 for (; irela
< irelaend
; irela
++)
12885 enum elf_ppc64_reloc_type r_type
;
12886 unsigned int r_indx
;
12887 enum ppc_stub_type stub_type
;
12888 struct ppc_stub_hash_entry
*stub_entry
;
12889 asection
*sym_sec
, *code_sec
;
12890 bfd_vma sym_value
, code_value
;
12891 bfd_vma destination
;
12892 unsigned long local_off
;
12893 bfd_boolean ok_dest
;
12894 struct ppc_link_hash_entry
*hash
;
12895 struct ppc_link_hash_entry
*fdh
;
12896 struct elf_link_hash_entry
*h
;
12897 Elf_Internal_Sym
*sym
;
12899 const asection
*id_sec
;
12900 struct _opd_sec_data
*opd
;
12901 struct plt_entry
*plt_ent
;
12903 r_type
= ELF64_R_TYPE (irela
->r_info
);
12904 r_indx
= ELF64_R_SYM (irela
->r_info
);
12906 if (r_type
>= R_PPC64_max
)
12908 bfd_set_error (bfd_error_bad_value
);
12909 goto error_ret_free_internal
;
12912 /* Only look for stubs on branch instructions. */
12913 if (r_type
!= R_PPC64_REL24
12914 && r_type
!= R_PPC64_REL24_NOTOC
12915 && r_type
!= R_PPC64_REL14
12916 && r_type
!= R_PPC64_REL14_BRTAKEN
12917 && r_type
!= R_PPC64_REL14_BRNTAKEN
)
12920 /* Now determine the call target, its name, value,
12922 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
12923 r_indx
, input_bfd
))
12924 goto error_ret_free_internal
;
12925 hash
= (struct ppc_link_hash_entry
*) h
;
12932 sym_value
= sym
->st_value
;
12933 if (sym_sec
!= NULL
12934 && sym_sec
->output_section
!= NULL
)
12937 else if (hash
->elf
.root
.type
== bfd_link_hash_defined
12938 || hash
->elf
.root
.type
== bfd_link_hash_defweak
)
12940 sym_value
= hash
->elf
.root
.u
.def
.value
;
12941 if (sym_sec
->output_section
!= NULL
)
12944 else if (hash
->elf
.root
.type
== bfd_link_hash_undefweak
12945 || hash
->elf
.root
.type
== bfd_link_hash_undefined
)
12947 /* Recognise an old ABI func code entry sym, and
12948 use the func descriptor sym instead if it is
12950 if (hash
->elf
.root
.root
.string
[0] == '.'
12951 && hash
->oh
!= NULL
)
12953 fdh
= ppc_follow_link (hash
->oh
);
12954 if (fdh
->elf
.root
.type
== bfd_link_hash_defined
12955 || fdh
->elf
.root
.type
== bfd_link_hash_defweak
)
12957 sym_sec
= fdh
->elf
.root
.u
.def
.section
;
12958 sym_value
= fdh
->elf
.root
.u
.def
.value
;
12959 if (sym_sec
->output_section
!= NULL
)
12968 bfd_set_error (bfd_error_bad_value
);
12969 goto error_ret_free_internal
;
12976 sym_value
+= irela
->r_addend
;
12977 destination
= (sym_value
12978 + sym_sec
->output_offset
12979 + sym_sec
->output_section
->vma
);
12980 local_off
= PPC64_LOCAL_ENTRY_OFFSET (hash
12985 code_sec
= sym_sec
;
12986 code_value
= sym_value
;
12987 opd
= get_opd_info (sym_sec
);
12992 if (hash
== NULL
&& opd
->adjust
!= NULL
)
12994 long adjust
= opd
->adjust
[OPD_NDX (sym_value
)];
12997 code_value
+= adjust
;
12998 sym_value
+= adjust
;
13000 dest
= opd_entry_value (sym_sec
, sym_value
,
13001 &code_sec
, &code_value
, FALSE
);
13002 if (dest
!= (bfd_vma
) -1)
13004 destination
= dest
;
13007 /* Fixup old ABI sym to point at code
13009 hash
->elf
.root
.type
= bfd_link_hash_defweak
;
13010 hash
->elf
.root
.u
.def
.section
= code_sec
;
13011 hash
->elf
.root
.u
.def
.value
= code_value
;
13016 /* Determine what (if any) linker stub is needed. */
13018 stub_type
= ppc_type_of_stub (section
, irela
, &hash
,
13019 &plt_ent
, destination
,
13022 if (r_type
== R_PPC64_REL24_NOTOC
)
13024 if (stub_type
== ppc_stub_plt_call
)
13025 stub_type
= ppc_stub_plt_call_notoc
;
13026 else if (stub_type
== ppc_stub_long_branch
13027 || (code_sec
!= NULL
13028 && code_sec
->output_section
!= NULL
13029 && (((hash
? hash
->elf
.other
: sym
->st_other
)
13030 & STO_PPC64_LOCAL_MASK
)
13031 > 1 << STO_PPC64_LOCAL_BIT
)))
13032 stub_type
= ppc_stub_long_branch_notoc
;
13034 else if (stub_type
!= ppc_stub_plt_call
)
13036 /* Check whether we need a TOC adjusting stub.
13037 Since the linker pastes together pieces from
13038 different object files when creating the
13039 _init and _fini functions, it may be that a
13040 call to what looks like a local sym is in
13041 fact a call needing a TOC adjustment. */
13042 if ((code_sec
!= NULL
13043 && code_sec
->output_section
!= NULL
13044 && (htab
->sec_info
[code_sec
->id
].toc_off
13045 != htab
->sec_info
[section
->id
].toc_off
)
13046 && (code_sec
->has_toc_reloc
13047 || code_sec
->makes_toc_func_call
))
13048 || (((hash
? hash
->elf
.other
: sym
->st_other
)
13049 & STO_PPC64_LOCAL_MASK
)
13050 == 1 << STO_PPC64_LOCAL_BIT
))
13051 stub_type
= ppc_stub_long_branch_r2off
;
13054 if (stub_type
== ppc_stub_none
)
13057 /* __tls_get_addr calls might be eliminated. */
13058 if (stub_type
!= ppc_stub_plt_call
13059 && stub_type
!= ppc_stub_plt_call_notoc
13061 && (hash
== htab
->tls_get_addr
13062 || hash
== htab
->tls_get_addr_fd
)
13063 && section
->has_tls_reloc
13064 && irela
!= internal_relocs
)
13066 /* Get tls info. */
13067 unsigned char *tls_mask
;
13069 if (!get_tls_mask (&tls_mask
, NULL
, NULL
, &local_syms
,
13070 irela
- 1, input_bfd
))
13071 goto error_ret_free_internal
;
13072 if ((*tls_mask
& TLS_TLS
) != 0)
13076 if (stub_type
== ppc_stub_plt_call
)
13079 && htab
->params
->plt_localentry0
!= 0
13080 && is_elfv2_localentry0 (&hash
->elf
))
13081 htab
->has_plt_localentry0
= 1;
13082 else if (irela
+ 1 < irelaend
13083 && irela
[1].r_offset
== irela
->r_offset
+ 4
13084 && (ELF64_R_TYPE (irela
[1].r_info
)
13085 == R_PPC64_TOCSAVE
))
13087 if (!tocsave_find (htab
, INSERT
,
13088 &local_syms
, irela
+ 1, input_bfd
))
13089 goto error_ret_free_internal
;
13092 stub_type
= ppc_stub_plt_call_r2save
;
13095 /* Support for grouping stub sections. */
13096 id_sec
= htab
->sec_info
[section
->id
].u
.group
->link_sec
;
13098 /* Get the name of this stub. */
13099 stub_name
= ppc_stub_name (id_sec
, sym_sec
, hash
, irela
);
13101 goto error_ret_free_internal
;
13103 stub_entry
= ppc_stub_hash_lookup (&htab
->stub_hash_table
,
13104 stub_name
, FALSE
, FALSE
);
13105 if (stub_entry
!= NULL
)
13107 enum ppc_stub_type old_type
;
13108 /* A stub has already been created, but it may
13109 not be the required type. We shouldn't be
13110 transitioning from plt_call to long_branch
13111 stubs or vice versa, but we might be
13112 upgrading from plt_call to plt_call_r2save or
13113 from long_branch to long_branch_r2off. */
13115 old_type
= stub_entry
->stub_type
;
13121 case ppc_stub_save_res
:
13124 case ppc_stub_plt_call
:
13125 case ppc_stub_plt_call_r2save
:
13126 case ppc_stub_plt_call_notoc
:
13127 case ppc_stub_plt_call_both
:
13128 if (stub_type
== ppc_stub_plt_call
)
13130 else if (stub_type
== ppc_stub_plt_call_r2save
)
13132 if (old_type
== ppc_stub_plt_call_notoc
)
13133 stub_type
= ppc_stub_plt_call_both
;
13135 else if (stub_type
== ppc_stub_plt_call_notoc
)
13137 if (old_type
== ppc_stub_plt_call_r2save
)
13138 stub_type
= ppc_stub_plt_call_both
;
13144 case ppc_stub_plt_branch
:
13145 case ppc_stub_plt_branch_r2off
:
13146 case ppc_stub_plt_branch_notoc
:
13147 case ppc_stub_plt_branch_both
:
13148 old_type
+= (ppc_stub_long_branch
13149 - ppc_stub_plt_branch
);
13150 /* Fall through. */
13151 case ppc_stub_long_branch
:
13152 case ppc_stub_long_branch_r2off
:
13153 case ppc_stub_long_branch_notoc
:
13154 case ppc_stub_long_branch_both
:
13155 if (stub_type
== ppc_stub_long_branch
)
13157 else if (stub_type
== ppc_stub_long_branch_r2off
)
13159 if (old_type
== ppc_stub_long_branch_notoc
)
13160 stub_type
= ppc_stub_long_branch_both
;
13162 else if (stub_type
== ppc_stub_long_branch_notoc
)
13164 if (old_type
== ppc_stub_long_branch_r2off
)
13165 stub_type
= ppc_stub_long_branch_both
;
13171 if (old_type
< stub_type
)
13172 stub_entry
->stub_type
= stub_type
;
13176 stub_entry
= ppc_add_stub (stub_name
, section
, info
);
13177 if (stub_entry
== NULL
)
13180 error_ret_free_internal
:
13181 if (elf_section_data (section
)->relocs
== NULL
)
13182 free (internal_relocs
);
13183 error_ret_free_local
:
13184 if (local_syms
!= NULL
13185 && (symtab_hdr
->contents
13186 != (unsigned char *) local_syms
))
13191 stub_entry
->stub_type
= stub_type
;
13192 if (stub_type
>= ppc_stub_plt_call
13193 && stub_type
<= ppc_stub_plt_call_both
)
13195 stub_entry
->target_value
= sym_value
;
13196 stub_entry
->target_section
= sym_sec
;
13200 stub_entry
->target_value
= code_value
;
13201 stub_entry
->target_section
= code_sec
;
13203 stub_entry
->h
= hash
;
13204 stub_entry
->plt_ent
= plt_ent
;
13205 stub_entry
->symtype
13206 = hash
? hash
->elf
.type
: ELF_ST_TYPE (sym
->st_info
);
13207 stub_entry
->other
= hash
? hash
->elf
.other
: sym
->st_other
;
13210 && (hash
->elf
.root
.type
== bfd_link_hash_defined
13211 || hash
->elf
.root
.type
== bfd_link_hash_defweak
))
13212 htab
->stub_globals
+= 1;
13215 /* We're done with the internal relocs, free them. */
13216 if (elf_section_data (section
)->relocs
!= internal_relocs
)
13217 free (internal_relocs
);
13220 if (local_syms
!= NULL
13221 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
13223 if (!info
->keep_memory
)
13226 symtab_hdr
->contents
= (unsigned char *) local_syms
;
13230 /* We may have added some stubs. Find out the new size of the
13232 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13234 group
->lr_restore
= 0;
13235 group
->eh_size
= 0;
13236 if (group
->stub_sec
!= NULL
)
13238 asection
*stub_sec
= group
->stub_sec
;
13240 if (htab
->stub_iteration
<= STUB_SHRINK_ITER
13241 || stub_sec
->rawsize
< stub_sec
->size
)
13242 /* Past STUB_SHRINK_ITER, rawsize is the max size seen. */
13243 stub_sec
->rawsize
= stub_sec
->size
;
13244 stub_sec
->size
= 0;
13245 stub_sec
->reloc_count
= 0;
13246 stub_sec
->flags
&= ~SEC_RELOC
;
13250 if (htab
->stub_iteration
<= STUB_SHRINK_ITER
13251 || htab
->brlt
->rawsize
< htab
->brlt
->size
)
13252 htab
->brlt
->rawsize
= htab
->brlt
->size
;
13253 htab
->brlt
->size
= 0;
13254 htab
->brlt
->reloc_count
= 0;
13255 htab
->brlt
->flags
&= ~SEC_RELOC
;
13256 if (htab
->relbrlt
!= NULL
)
13257 htab
->relbrlt
->size
= 0;
13259 bfd_hash_traverse (&htab
->stub_hash_table
, ppc_size_one_stub
, info
);
13261 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13262 if (group
->needs_save_res
)
13263 group
->stub_sec
->size
+= htab
->sfpr
->size
;
13265 if (info
->emitrelocations
13266 && htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
13268 htab
->glink
->reloc_count
= 1;
13269 htab
->glink
->flags
|= SEC_RELOC
;
13272 if (htab
->glink_eh_frame
!= NULL
13273 && !bfd_is_abs_section (htab
->glink_eh_frame
->output_section
)
13274 && htab
->glink_eh_frame
->output_section
->size
> 8)
13276 size_t size
= 0, align
= 4;
13278 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13279 if (group
->eh_size
!= 0)
13280 size
+= (group
->eh_size
+ 17 + align
- 1) & -align
;
13281 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
13282 size
+= (24 + align
- 1) & -align
;
13284 size
+= (sizeof (glink_eh_frame_cie
) + align
- 1) & -align
;
13285 align
= 1ul << htab
->glink_eh_frame
->output_section
->alignment_power
;
13286 size
= (size
+ align
- 1) & -align
;
13287 htab
->glink_eh_frame
->rawsize
= htab
->glink_eh_frame
->size
;
13288 htab
->glink_eh_frame
->size
= size
;
13291 if (htab
->params
->plt_stub_align
!= 0)
13292 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13293 if (group
->stub_sec
!= NULL
)
13295 int align
= abs (htab
->params
->plt_stub_align
);
13296 group
->stub_sec
->size
13297 = (group
->stub_sec
->size
+ (1 << align
) - 1) & -(1 << align
);
13300 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13301 if (group
->stub_sec
!= NULL
13302 && group
->stub_sec
->rawsize
!= group
->stub_sec
->size
13303 && (htab
->stub_iteration
<= STUB_SHRINK_ITER
13304 || group
->stub_sec
->rawsize
< group
->stub_sec
->size
))
13308 && (htab
->brlt
->rawsize
== htab
->brlt
->size
13309 || (htab
->stub_iteration
> STUB_SHRINK_ITER
13310 && htab
->brlt
->rawsize
> htab
->brlt
->size
))
13311 && (htab
->glink_eh_frame
== NULL
13312 || htab
->glink_eh_frame
->rawsize
== htab
->glink_eh_frame
->size
))
13315 /* Ask the linker to do its stuff. */
13316 (*htab
->params
->layout_sections_again
) ();
13319 if (htab
->glink_eh_frame
!= NULL
13320 && htab
->glink_eh_frame
->size
!= 0)
13323 bfd_byte
*p
, *last_fde
;
13324 size_t last_fde_len
, size
, align
, pad
;
13325 struct map_stub
*group
;
13327 /* It is necessary to at least have a rough outline of the
13328 linker generated CIEs and FDEs written before
13329 bfd_elf_discard_info is run, in order for these FDEs to be
13330 indexed in .eh_frame_hdr. */
13331 p
= bfd_zalloc (htab
->glink_eh_frame
->owner
, htab
->glink_eh_frame
->size
);
13334 htab
->glink_eh_frame
->contents
= p
;
13338 memcpy (p
, glink_eh_frame_cie
, sizeof (glink_eh_frame_cie
));
13339 /* CIE length (rewrite in case little-endian). */
13340 last_fde_len
= ((sizeof (glink_eh_frame_cie
) + align
- 1) & -align
) - 4;
13341 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
, p
);
13342 p
+= last_fde_len
+ 4;
13344 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13345 if (group
->eh_size
!= 0)
13347 group
->eh_base
= p
- htab
->glink_eh_frame
->contents
;
13349 last_fde_len
= ((group
->eh_size
+ 17 + align
- 1) & -align
) - 4;
13351 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
, p
);
13354 val
= p
- htab
->glink_eh_frame
->contents
;
13355 bfd_put_32 (htab
->elf
.dynobj
, val
, p
);
13357 /* Offset to stub section, written later. */
13359 /* stub section size. */
13360 bfd_put_32 (htab
->elf
.dynobj
, group
->stub_sec
->size
, p
);
13362 /* Augmentation. */
13364 /* Make sure we don't have all nops. This is enough for
13365 elf-eh-frame.c to detect the last non-nop opcode. */
13366 p
[group
->eh_size
- 1] = DW_CFA_advance_loc
+ 1;
13367 p
= last_fde
+ last_fde_len
+ 4;
13369 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
13372 last_fde_len
= ((24 + align
- 1) & -align
) - 4;
13374 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
, p
);
13377 val
= p
- htab
->glink_eh_frame
->contents
;
13378 bfd_put_32 (htab
->elf
.dynobj
, val
, p
);
13380 /* Offset to .glink, written later. */
13383 bfd_put_32 (htab
->elf
.dynobj
, htab
->glink
->size
- 8, p
);
13385 /* Augmentation. */
13388 *p
++ = DW_CFA_advance_loc
+ 1;
13389 *p
++ = DW_CFA_register
;
13391 *p
++ = htab
->opd_abi
? 12 : 0;
13392 *p
++ = DW_CFA_advance_loc
+ (htab
->opd_abi
? 5 : 7);
13393 *p
++ = DW_CFA_restore_extended
;
13395 p
+= ((24 + align
- 1) & -align
) - 24;
13397 /* Subsume any padding into the last FDE if user .eh_frame
13398 sections are aligned more than glink_eh_frame. Otherwise any
13399 zero padding will be seen as a terminator. */
13400 align
= 1ul << htab
->glink_eh_frame
->output_section
->alignment_power
;
13401 size
= p
- htab
->glink_eh_frame
->contents
;
13402 pad
= ((size
+ align
- 1) & -align
) - size
;
13403 htab
->glink_eh_frame
->size
= size
+ pad
;
13404 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
+ pad
, last_fde
);
13407 maybe_strip_output (info
, htab
->brlt
);
13408 if (htab
->glink_eh_frame
!= NULL
)
13409 maybe_strip_output (info
, htab
->glink_eh_frame
);
13414 /* Called after we have determined section placement. If sections
13415 move, we'll be called again. Provide a value for TOCstart. */
13418 ppc64_elf_set_toc (struct bfd_link_info
*info
, bfd
*obfd
)
13421 bfd_vma TOCstart
, adjust
;
13425 struct elf_link_hash_entry
*h
;
13426 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
13428 if (is_elf_hash_table (htab
)
13429 && htab
->hgot
!= NULL
)
13433 h
= elf_link_hash_lookup (htab
, ".TOC.", FALSE
, FALSE
, TRUE
);
13434 if (is_elf_hash_table (htab
))
13438 && h
->root
.type
== bfd_link_hash_defined
13439 && !h
->root
.linker_def
13440 && (!is_elf_hash_table (htab
)
13441 || h
->def_regular
))
13443 TOCstart
= (h
->root
.u
.def
.value
- TOC_BASE_OFF
13444 + h
->root
.u
.def
.section
->output_offset
13445 + h
->root
.u
.def
.section
->output_section
->vma
);
13446 _bfd_set_gp_value (obfd
, TOCstart
);
13451 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
13452 order. The TOC starts where the first of these sections starts. */
13453 s
= bfd_get_section_by_name (obfd
, ".got");
13454 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13455 s
= bfd_get_section_by_name (obfd
, ".toc");
13456 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13457 s
= bfd_get_section_by_name (obfd
, ".tocbss");
13458 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13459 s
= bfd_get_section_by_name (obfd
, ".plt");
13460 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13462 /* This may happen for
13463 o references to TOC base (SYM@toc / TOC[tc0]) without a
13465 o bad linker script
13466 o --gc-sections and empty TOC sections
13468 FIXME: Warn user? */
13470 /* Look for a likely section. We probably won't even be
13472 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13473 if ((s
->flags
& (SEC_ALLOC
| SEC_SMALL_DATA
| SEC_READONLY
13475 == (SEC_ALLOC
| SEC_SMALL_DATA
))
13478 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13479 if ((s
->flags
& (SEC_ALLOC
| SEC_SMALL_DATA
| SEC_EXCLUDE
))
13480 == (SEC_ALLOC
| SEC_SMALL_DATA
))
13483 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13484 if ((s
->flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_EXCLUDE
))
13488 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13489 if ((s
->flags
& (SEC_ALLOC
| SEC_EXCLUDE
)) == SEC_ALLOC
)
13495 TOCstart
= s
->output_section
->vma
+ s
->output_offset
;
13497 /* Force alignment. */
13498 adjust
= TOCstart
& (TOC_BASE_ALIGN
- 1);
13499 TOCstart
-= adjust
;
13500 _bfd_set_gp_value (obfd
, TOCstart
);
13502 if (info
!= NULL
&& s
!= NULL
)
13504 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
13508 if (htab
->elf
.hgot
!= NULL
)
13510 htab
->elf
.hgot
->root
.u
.def
.value
= TOC_BASE_OFF
- adjust
;
13511 htab
->elf
.hgot
->root
.u
.def
.section
= s
;
13516 struct bfd_link_hash_entry
*bh
= NULL
;
13517 _bfd_generic_link_add_one_symbol (info
, obfd
, ".TOC.", BSF_GLOBAL
,
13518 s
, TOC_BASE_OFF
- adjust
,
13519 NULL
, FALSE
, FALSE
, &bh
);
13525 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
13526 write out any global entry stubs, and PLT relocations. */
13529 build_global_entry_stubs_and_plt (struct elf_link_hash_entry
*h
, void *inf
)
13531 struct bfd_link_info
*info
;
13532 struct ppc_link_hash_table
*htab
;
13533 struct plt_entry
*ent
;
13536 if (h
->root
.type
== bfd_link_hash_indirect
)
13540 htab
= ppc_hash_table (info
);
13544 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
13545 if (ent
->plt
.offset
!= (bfd_vma
) -1)
13547 /* This symbol has an entry in the procedure linkage
13548 table. Set it up. */
13549 Elf_Internal_Rela rela
;
13550 asection
*plt
, *relplt
;
13553 if (!htab
->elf
.dynamic_sections_created
13554 || h
->dynindx
== -1)
13556 if (!(h
->def_regular
13557 && (h
->root
.type
== bfd_link_hash_defined
13558 || h
->root
.type
== bfd_link_hash_defweak
)))
13560 if (h
->type
== STT_GNU_IFUNC
)
13562 plt
= htab
->elf
.iplt
;
13563 relplt
= htab
->elf
.irelplt
;
13564 htab
->local_ifunc_resolver
= 1;
13566 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_IREL
);
13568 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
13572 plt
= htab
->pltlocal
;
13573 if (bfd_link_pic (info
))
13575 relplt
= htab
->relpltlocal
;
13577 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_SLOT
);
13579 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
13584 rela
.r_addend
= (h
->root
.u
.def
.value
13585 + h
->root
.u
.def
.section
->output_offset
13586 + h
->root
.u
.def
.section
->output_section
->vma
13589 if (relplt
== NULL
)
13591 loc
= plt
->contents
+ ent
->plt
.offset
;
13592 bfd_put_64 (info
->output_bfd
, rela
.r_addend
, loc
);
13595 bfd_vma toc
= elf_gp (info
->output_bfd
);
13596 toc
+= htab
->sec_info
[h
->root
.u
.def
.section
->id
].toc_off
;
13597 bfd_put_64 (info
->output_bfd
, toc
, loc
+ 8);
13602 rela
.r_offset
= (plt
->output_section
->vma
13603 + plt
->output_offset
13604 + ent
->plt
.offset
);
13605 loc
= relplt
->contents
+ (relplt
->reloc_count
++
13606 * sizeof (Elf64_External_Rela
));
13607 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rela
, loc
);
13612 rela
.r_offset
= (htab
->elf
.splt
->output_section
->vma
13613 + htab
->elf
.splt
->output_offset
13614 + ent
->plt
.offset
);
13615 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_PPC64_JMP_SLOT
);
13616 rela
.r_addend
= ent
->addend
;
13617 loc
= (htab
->elf
.srelplt
->contents
13618 + ((ent
->plt
.offset
- PLT_INITIAL_ENTRY_SIZE (htab
))
13619 / PLT_ENTRY_SIZE (htab
) * sizeof (Elf64_External_Rela
)));
13620 if (h
->type
== STT_GNU_IFUNC
&& is_static_defined (h
))
13621 htab
->maybe_local_ifunc_resolver
= 1;
13622 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rela
, loc
);
13626 if (!h
->pointer_equality_needed
)
13629 if (h
->def_regular
)
13632 s
= htab
->global_entry
;
13633 if (s
== NULL
|| s
->size
== 0)
13636 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
13637 if (ent
->plt
.offset
!= (bfd_vma
) -1
13638 && ent
->addend
== 0)
13644 p
= s
->contents
+ h
->root
.u
.def
.value
;
13645 plt
= htab
->elf
.splt
;
13646 if (!htab
->elf
.dynamic_sections_created
13647 || h
->dynindx
== -1)
13649 if (h
->type
== STT_GNU_IFUNC
)
13650 plt
= htab
->elf
.iplt
;
13652 plt
= htab
->pltlocal
;
13654 off
= ent
->plt
.offset
+ plt
->output_offset
+ plt
->output_section
->vma
;
13655 off
-= h
->root
.u
.def
.value
+ s
->output_offset
+ s
->output_section
->vma
;
13657 if (off
+ 0x80008000 > 0xffffffff || (off
& 3) != 0)
13659 info
->callbacks
->einfo
13660 (_("%P: linkage table error against `%pT'\n"),
13661 h
->root
.root
.string
);
13662 bfd_set_error (bfd_error_bad_value
);
13663 htab
->stub_error
= TRUE
;
13666 htab
->stub_count
[ppc_stub_global_entry
- 1] += 1;
13667 if (htab
->params
->emit_stub_syms
)
13669 size_t len
= strlen (h
->root
.root
.string
);
13670 char *name
= bfd_malloc (sizeof "12345678.global_entry." + len
);
13675 sprintf (name
, "%08x.global_entry.%s", s
->id
, h
->root
.root
.string
);
13676 h
= elf_link_hash_lookup (&htab
->elf
, name
, TRUE
, FALSE
, FALSE
);
13679 if (h
->root
.type
== bfd_link_hash_new
)
13681 h
->root
.type
= bfd_link_hash_defined
;
13682 h
->root
.u
.def
.section
= s
;
13683 h
->root
.u
.def
.value
= p
- s
->contents
;
13684 h
->ref_regular
= 1;
13685 h
->def_regular
= 1;
13686 h
->ref_regular_nonweak
= 1;
13687 h
->forced_local
= 1;
13689 h
->root
.linker_def
= 1;
13693 if (PPC_HA (off
) != 0)
13695 bfd_put_32 (s
->owner
, ADDIS_R12_R12
| PPC_HA (off
), p
);
13698 bfd_put_32 (s
->owner
, LD_R12_0R12
| PPC_LO (off
), p
);
13700 bfd_put_32 (s
->owner
, MTCTR_R12
, p
);
13702 bfd_put_32 (s
->owner
, BCTR
, p
);
13708 /* Write PLT relocs for locals. */
13711 write_plt_relocs_for_local_syms (struct bfd_link_info
*info
)
13713 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
13716 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
13718 struct got_entry
**lgot_ents
, **end_lgot_ents
;
13719 struct plt_entry
**local_plt
, **lplt
, **end_local_plt
;
13720 Elf_Internal_Shdr
*symtab_hdr
;
13721 bfd_size_type locsymcount
;
13722 Elf_Internal_Sym
*local_syms
= NULL
;
13723 struct plt_entry
*ent
;
13725 if (!is_ppc64_elf (ibfd
))
13728 lgot_ents
= elf_local_got_ents (ibfd
);
13732 symtab_hdr
= &elf_symtab_hdr (ibfd
);
13733 locsymcount
= symtab_hdr
->sh_info
;
13734 end_lgot_ents
= lgot_ents
+ locsymcount
;
13735 local_plt
= (struct plt_entry
**) end_lgot_ents
;
13736 end_local_plt
= local_plt
+ locsymcount
;
13737 for (lplt
= local_plt
; lplt
< end_local_plt
; ++lplt
)
13738 for (ent
= *lplt
; ent
!= NULL
; ent
= ent
->next
)
13739 if (ent
->plt
.offset
!= (bfd_vma
) -1)
13741 Elf_Internal_Sym
*sym
;
13743 asection
*plt
, *relplt
;
13747 if (!get_sym_h (NULL
, &sym
, &sym_sec
, NULL
, &local_syms
,
13748 lplt
- local_plt
, ibfd
))
13750 if (local_syms
!= NULL
13751 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
13756 val
= sym
->st_value
+ ent
->addend
;
13757 if (ELF_ST_TYPE (sym
->st_info
) != STT_GNU_IFUNC
)
13758 val
+= PPC64_LOCAL_ENTRY_OFFSET (sym
->st_other
);
13759 if (sym_sec
!= NULL
&& sym_sec
->output_section
!= NULL
)
13760 val
+= sym_sec
->output_offset
+ sym_sec
->output_section
->vma
;
13762 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
13764 htab
->local_ifunc_resolver
= 1;
13765 plt
= htab
->elf
.iplt
;
13766 relplt
= htab
->elf
.irelplt
;
13770 plt
= htab
->pltlocal
;
13771 relplt
= bfd_link_pic (info
) ? htab
->relpltlocal
: NULL
;
13774 if (relplt
== NULL
)
13776 loc
= plt
->contents
+ ent
->plt
.offset
;
13777 bfd_put_64 (info
->output_bfd
, val
, loc
);
13780 bfd_vma toc
= elf_gp (ibfd
);
13781 bfd_put_64 (info
->output_bfd
, toc
, loc
+ 8);
13786 Elf_Internal_Rela rela
;
13787 rela
.r_offset
= (ent
->plt
.offset
13788 + plt
->output_offset
13789 + plt
->output_section
->vma
);
13790 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
13793 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_IREL
);
13795 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
13800 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_SLOT
);
13802 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
13804 rela
.r_addend
= val
;
13805 loc
= relplt
->contents
+ (relplt
->reloc_count
++
13806 * sizeof (Elf64_External_Rela
));
13807 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rela
, loc
);
13811 if (local_syms
!= NULL
13812 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
13814 if (!info
->keep_memory
)
13817 symtab_hdr
->contents
= (unsigned char *) local_syms
;
13823 /* Build all the stubs associated with the current output file.
13824 The stubs are kept in a hash table attached to the main linker
13825 hash table. This function is called via gldelf64ppc_finish. */
13828 ppc64_elf_build_stubs (struct bfd_link_info
*info
,
13831 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
13832 struct map_stub
*group
;
13833 asection
*stub_sec
;
13835 int stub_sec_count
= 0;
13840 /* Allocate memory to hold the linker stubs. */
13841 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13843 group
->eh_size
= 0;
13844 group
->lr_restore
= 0;
13845 if ((stub_sec
= group
->stub_sec
) != NULL
13846 && stub_sec
->size
!= 0)
13848 stub_sec
->contents
= bfd_zalloc (htab
->params
->stub_bfd
,
13850 if (stub_sec
->contents
== NULL
)
13852 stub_sec
->size
= 0;
13856 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
13861 /* Build the .glink plt call stub. */
13862 if (htab
->params
->emit_stub_syms
)
13864 struct elf_link_hash_entry
*h
;
13865 h
= elf_link_hash_lookup (&htab
->elf
, "__glink_PLTresolve",
13866 TRUE
, FALSE
, FALSE
);
13869 if (h
->root
.type
== bfd_link_hash_new
)
13871 h
->root
.type
= bfd_link_hash_defined
;
13872 h
->root
.u
.def
.section
= htab
->glink
;
13873 h
->root
.u
.def
.value
= 8;
13874 h
->ref_regular
= 1;
13875 h
->def_regular
= 1;
13876 h
->ref_regular_nonweak
= 1;
13877 h
->forced_local
= 1;
13879 h
->root
.linker_def
= 1;
13882 plt0
= (htab
->elf
.splt
->output_section
->vma
13883 + htab
->elf
.splt
->output_offset
13885 if (info
->emitrelocations
)
13887 Elf_Internal_Rela
*r
= get_relocs (htab
->glink
, 1);
13890 r
->r_offset
= (htab
->glink
->output_offset
13891 + htab
->glink
->output_section
->vma
);
13892 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL64
);
13893 r
->r_addend
= plt0
;
13895 p
= htab
->glink
->contents
;
13896 plt0
-= htab
->glink
->output_section
->vma
+ htab
->glink
->output_offset
;
13897 bfd_put_64 (htab
->glink
->owner
, plt0
, p
);
13901 bfd_put_32 (htab
->glink
->owner
, MFLR_R12
, p
);
13903 bfd_put_32 (htab
->glink
->owner
, BCL_20_31
, p
);
13905 bfd_put_32 (htab
->glink
->owner
, MFLR_R11
, p
);
13907 bfd_put_32 (htab
->glink
->owner
, LD_R2_0R11
| (-16 & 0xfffc), p
);
13909 bfd_put_32 (htab
->glink
->owner
, MTLR_R12
, p
);
13911 bfd_put_32 (htab
->glink
->owner
, ADD_R11_R2_R11
, p
);
13913 bfd_put_32 (htab
->glink
->owner
, LD_R12_0R11
, p
);
13915 bfd_put_32 (htab
->glink
->owner
, LD_R2_0R11
| 8, p
);
13917 bfd_put_32 (htab
->glink
->owner
, MTCTR_R12
, p
);
13919 bfd_put_32 (htab
->glink
->owner
, LD_R11_0R11
| 16, p
);
13924 bfd_put_32 (htab
->glink
->owner
, MFLR_R0
, p
);
13926 bfd_put_32 (htab
->glink
->owner
, BCL_20_31
, p
);
13928 bfd_put_32 (htab
->glink
->owner
, MFLR_R11
, p
);
13930 bfd_put_32 (htab
->glink
->owner
, STD_R2_0R1
+ 24, p
);
13932 bfd_put_32 (htab
->glink
->owner
, LD_R2_0R11
| (-16 & 0xfffc), p
);
13934 bfd_put_32 (htab
->glink
->owner
, MTLR_R0
, p
);
13936 bfd_put_32 (htab
->glink
->owner
, SUB_R12_R12_R11
, p
);
13938 bfd_put_32 (htab
->glink
->owner
, ADD_R11_R2_R11
, p
);
13940 bfd_put_32 (htab
->glink
->owner
, ADDI_R0_R12
| (-48 & 0xffff), p
);
13942 bfd_put_32 (htab
->glink
->owner
, LD_R12_0R11
, p
);
13944 bfd_put_32 (htab
->glink
->owner
, SRDI_R0_R0_2
, p
);
13946 bfd_put_32 (htab
->glink
->owner
, MTCTR_R12
, p
);
13948 bfd_put_32 (htab
->glink
->owner
, LD_R11_0R11
| 8, p
);
13951 bfd_put_32 (htab
->glink
->owner
, BCTR
, p
);
13953 BFD_ASSERT (p
== htab
->glink
->contents
+ GLINK_PLTRESOLVE_SIZE (htab
));
13955 /* Build the .glink lazy link call stubs. */
13957 while (p
< htab
->glink
->contents
+ htab
->glink
->size
)
13963 bfd_put_32 (htab
->glink
->owner
, LI_R0_0
| indx
, p
);
13968 bfd_put_32 (htab
->glink
->owner
, LIS_R0_0
| PPC_HI (indx
), p
);
13970 bfd_put_32 (htab
->glink
->owner
, ORI_R0_R0_0
| PPC_LO (indx
),
13975 bfd_put_32 (htab
->glink
->owner
,
13976 B_DOT
| ((htab
->glink
->contents
- p
+ 8) & 0x3fffffc), p
);
13982 /* Build .glink global entry stubs, and PLT relocs for globals. */
13983 elf_link_hash_traverse (&htab
->elf
, build_global_entry_stubs_and_plt
, info
);
13985 if (!write_plt_relocs_for_local_syms (info
))
13988 if (htab
->brlt
!= NULL
&& htab
->brlt
->size
!= 0)
13990 htab
->brlt
->contents
= bfd_zalloc (htab
->brlt
->owner
,
13992 if (htab
->brlt
->contents
== NULL
)
13995 if (htab
->relbrlt
!= NULL
&& htab
->relbrlt
->size
!= 0)
13997 htab
->relbrlt
->contents
= bfd_zalloc (htab
->relbrlt
->owner
,
13998 htab
->relbrlt
->size
);
13999 if (htab
->relbrlt
->contents
== NULL
)
14003 /* Build the stubs as directed by the stub hash table. */
14004 bfd_hash_traverse (&htab
->stub_hash_table
, ppc_build_one_stub
, info
);
14006 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14007 if (group
->needs_save_res
)
14008 group
->stub_sec
->size
+= htab
->sfpr
->size
;
14010 if (htab
->relbrlt
!= NULL
)
14011 htab
->relbrlt
->reloc_count
= 0;
14013 if (htab
->params
->plt_stub_align
!= 0)
14014 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14015 if ((stub_sec
= group
->stub_sec
) != NULL
)
14017 int align
= abs (htab
->params
->plt_stub_align
);
14018 stub_sec
->size
= (stub_sec
->size
+ (1 << align
) - 1) & -(1 << align
);
14021 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14022 if (group
->needs_save_res
)
14024 stub_sec
= group
->stub_sec
;
14025 memcpy (stub_sec
->contents
+ stub_sec
->size
- htab
->sfpr
->size
,
14026 htab
->sfpr
->contents
, htab
->sfpr
->size
);
14027 if (htab
->params
->emit_stub_syms
)
14031 for (i
= 0; i
< ARRAY_SIZE (save_res_funcs
); i
++)
14032 if (!sfpr_define (info
, &save_res_funcs
[i
], stub_sec
))
14037 if (htab
->glink_eh_frame
!= NULL
14038 && htab
->glink_eh_frame
->size
!= 0)
14043 p
= htab
->glink_eh_frame
->contents
;
14044 p
+= (sizeof (glink_eh_frame_cie
) + align
- 1) & -align
;
14046 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14047 if (group
->eh_size
!= 0)
14049 /* Offset to stub section. */
14050 val
= (group
->stub_sec
->output_section
->vma
14051 + group
->stub_sec
->output_offset
);
14052 val
-= (htab
->glink_eh_frame
->output_section
->vma
14053 + htab
->glink_eh_frame
->output_offset
14054 + (p
+ 8 - htab
->glink_eh_frame
->contents
));
14055 if (val
+ 0x80000000 > 0xffffffff)
14058 (_("%s offset too large for .eh_frame sdata4 encoding"),
14059 group
->stub_sec
->name
);
14062 bfd_put_32 (htab
->elf
.dynobj
, val
, p
+ 8);
14063 p
+= (group
->eh_size
+ 17 + 3) & -4;
14065 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
14067 /* Offset to .glink. */
14068 val
= (htab
->glink
->output_section
->vma
14069 + htab
->glink
->output_offset
14071 val
-= (htab
->glink_eh_frame
->output_section
->vma
14072 + htab
->glink_eh_frame
->output_offset
14073 + (p
+ 8 - htab
->glink_eh_frame
->contents
));
14074 if (val
+ 0x80000000 > 0xffffffff)
14077 (_("%s offset too large for .eh_frame sdata4 encoding"),
14078 htab
->glink
->name
);
14081 bfd_put_32 (htab
->elf
.dynobj
, val
, p
+ 8);
14082 p
+= (24 + align
- 1) & -align
;
14086 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14087 if ((stub_sec
= group
->stub_sec
) != NULL
)
14089 stub_sec_count
+= 1;
14090 if (stub_sec
->rawsize
!= stub_sec
->size
14091 && (htab
->stub_iteration
<= STUB_SHRINK_ITER
14092 || stub_sec
->rawsize
< stub_sec
->size
))
14098 htab
->stub_error
= TRUE
;
14099 _bfd_error_handler (_("stubs don't match calculated size"));
14102 if (htab
->stub_error
)
14108 *stats
= bfd_malloc (500);
14109 if (*stats
== NULL
)
14112 len
= sprintf (*stats
,
14113 ngettext ("linker stubs in %u group\n",
14114 "linker stubs in %u groups\n",
14117 sprintf (*stats
+ len
, _(" branch %lu\n"
14118 " branch toc adj %lu\n"
14119 " branch notoc %lu\n"
14120 " branch both %lu\n"
14121 " long branch %lu\n"
14122 " long toc adj %lu\n"
14123 " long notoc %lu\n"
14126 " plt call save %lu\n"
14127 " plt call notoc %lu\n"
14128 " plt call both %lu\n"
14129 " global entry %lu"),
14130 htab
->stub_count
[ppc_stub_long_branch
- 1],
14131 htab
->stub_count
[ppc_stub_long_branch_r2off
- 1],
14132 htab
->stub_count
[ppc_stub_long_branch_notoc
- 1],
14133 htab
->stub_count
[ppc_stub_long_branch_both
- 1],
14134 htab
->stub_count
[ppc_stub_plt_branch
- 1],
14135 htab
->stub_count
[ppc_stub_plt_branch_r2off
- 1],
14136 htab
->stub_count
[ppc_stub_plt_branch_notoc
- 1],
14137 htab
->stub_count
[ppc_stub_plt_branch_both
- 1],
14138 htab
->stub_count
[ppc_stub_plt_call
- 1],
14139 htab
->stub_count
[ppc_stub_plt_call_r2save
- 1],
14140 htab
->stub_count
[ppc_stub_plt_call_notoc
- 1],
14141 htab
->stub_count
[ppc_stub_plt_call_both
- 1],
14142 htab
->stub_count
[ppc_stub_global_entry
- 1]);
14147 /* What to do when ld finds relocations against symbols defined in
14148 discarded sections. */
14150 static unsigned int
14151 ppc64_elf_action_discarded (asection
*sec
)
14153 if (strcmp (".opd", sec
->name
) == 0)
14156 if (strcmp (".toc", sec
->name
) == 0)
14159 if (strcmp (".toc1", sec
->name
) == 0)
14162 return _bfd_elf_default_action_discarded (sec
);
14165 /* These are the dynamic relocations supported by glibc. */
14168 ppc64_glibc_dynamic_reloc (enum elf_ppc64_reloc_type r_type
)
14172 case R_PPC64_RELATIVE
:
14174 case R_PPC64_ADDR64
:
14175 case R_PPC64_GLOB_DAT
:
14176 case R_PPC64_IRELATIVE
:
14177 case R_PPC64_JMP_IREL
:
14178 case R_PPC64_JMP_SLOT
:
14179 case R_PPC64_DTPMOD64
:
14180 case R_PPC64_DTPREL64
:
14181 case R_PPC64_TPREL64
:
14182 case R_PPC64_TPREL16_LO_DS
:
14183 case R_PPC64_TPREL16_DS
:
14184 case R_PPC64_TPREL16
:
14185 case R_PPC64_TPREL16_LO
:
14186 case R_PPC64_TPREL16_HI
:
14187 case R_PPC64_TPREL16_HIGH
:
14188 case R_PPC64_TPREL16_HA
:
14189 case R_PPC64_TPREL16_HIGHA
:
14190 case R_PPC64_TPREL16_HIGHER
:
14191 case R_PPC64_TPREL16_HIGHEST
:
14192 case R_PPC64_TPREL16_HIGHERA
:
14193 case R_PPC64_TPREL16_HIGHESTA
:
14194 case R_PPC64_ADDR16_LO_DS
:
14195 case R_PPC64_ADDR16_LO
:
14196 case R_PPC64_ADDR16_HI
:
14197 case R_PPC64_ADDR16_HIGH
:
14198 case R_PPC64_ADDR16_HA
:
14199 case R_PPC64_ADDR16_HIGHA
:
14200 case R_PPC64_REL30
:
14202 case R_PPC64_UADDR64
:
14203 case R_PPC64_UADDR32
:
14204 case R_PPC64_ADDR32
:
14205 case R_PPC64_ADDR24
:
14206 case R_PPC64_ADDR16
:
14207 case R_PPC64_UADDR16
:
14208 case R_PPC64_ADDR16_DS
:
14209 case R_PPC64_ADDR16_HIGHER
:
14210 case R_PPC64_ADDR16_HIGHEST
:
14211 case R_PPC64_ADDR16_HIGHERA
:
14212 case R_PPC64_ADDR16_HIGHESTA
:
14213 case R_PPC64_ADDR14
:
14214 case R_PPC64_ADDR14_BRTAKEN
:
14215 case R_PPC64_ADDR14_BRNTAKEN
:
14216 case R_PPC64_REL32
:
14217 case R_PPC64_REL64
:
14225 /* The RELOCATE_SECTION function is called by the ELF backend linker
14226 to handle the relocations for a section.
14228 The relocs are always passed as Rela structures; if the section
14229 actually uses Rel structures, the r_addend field will always be
14232 This function is responsible for adjust the section contents as
14233 necessary, and (if using Rela relocs and generating a
14234 relocatable output file) adjusting the reloc addend as
14237 This function does not have to worry about setting the reloc
14238 address or the reloc symbol index.
14240 LOCAL_SYMS is a pointer to the swapped in local symbols.
14242 LOCAL_SECTIONS is an array giving the section in the input file
14243 corresponding to the st_shndx field of each local symbol.
14245 The global hash table entry for the global symbols can be found
14246 via elf_sym_hashes (input_bfd).
14248 When generating relocatable output, this function must handle
14249 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
14250 going to be the section symbol corresponding to the output
14251 section, which means that the addend must be adjusted
14255 ppc64_elf_relocate_section (bfd
*output_bfd
,
14256 struct bfd_link_info
*info
,
14258 asection
*input_section
,
14259 bfd_byte
*contents
,
14260 Elf_Internal_Rela
*relocs
,
14261 Elf_Internal_Sym
*local_syms
,
14262 asection
**local_sections
)
14264 struct ppc_link_hash_table
*htab
;
14265 Elf_Internal_Shdr
*symtab_hdr
;
14266 struct elf_link_hash_entry
**sym_hashes
;
14267 Elf_Internal_Rela
*rel
;
14268 Elf_Internal_Rela
*wrel
;
14269 Elf_Internal_Rela
*relend
;
14270 Elf_Internal_Rela outrel
;
14272 struct got_entry
**local_got_ents
;
14274 bfd_boolean ret
= TRUE
;
14275 bfd_boolean is_opd
;
14276 /* Assume 'at' branch hints. */
14277 bfd_boolean is_isa_v2
= TRUE
;
14278 bfd_boolean warned_dynamic
= FALSE
;
14279 bfd_vma d_offset
= (bfd_big_endian (input_bfd
) ? 2 : 0);
14281 /* Initialize howto table if needed. */
14282 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
14285 htab
= ppc_hash_table (info
);
14289 /* Don't relocate stub sections. */
14290 if (input_section
->owner
== htab
->params
->stub_bfd
)
14293 if (!is_ppc64_elf (input_bfd
))
14295 bfd_set_error (bfd_error_wrong_format
);
14299 local_got_ents
= elf_local_got_ents (input_bfd
);
14300 TOCstart
= elf_gp (output_bfd
);
14301 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
14302 sym_hashes
= elf_sym_hashes (input_bfd
);
14303 is_opd
= ppc64_elf_section_data (input_section
)->sec_type
== sec_opd
;
14305 rel
= wrel
= relocs
;
14306 relend
= relocs
+ input_section
->reloc_count
;
14307 for (; rel
< relend
; wrel
++, rel
++)
14309 enum elf_ppc64_reloc_type r_type
;
14311 bfd_reloc_status_type r
;
14312 Elf_Internal_Sym
*sym
;
14314 struct elf_link_hash_entry
*h_elf
;
14315 struct ppc_link_hash_entry
*h
;
14316 struct ppc_link_hash_entry
*fdh
;
14317 const char *sym_name
;
14318 unsigned long r_symndx
, toc_symndx
;
14319 bfd_vma toc_addend
;
14320 unsigned char tls_mask
, tls_gd
, tls_type
;
14321 unsigned char sym_type
;
14322 bfd_vma relocation
;
14323 bfd_boolean unresolved_reloc
, save_unresolved_reloc
;
14324 bfd_boolean warned
;
14325 enum { DEST_NORMAL
, DEST_OPD
, DEST_STUB
} reloc_dest
;
14328 struct ppc_stub_hash_entry
*stub_entry
;
14329 bfd_vma max_br_offset
;
14331 Elf_Internal_Rela orig_rel
;
14332 reloc_howto_type
*howto
;
14333 struct reloc_howto_struct alt_howto
;
14340 r_type
= ELF64_R_TYPE (rel
->r_info
);
14341 r_symndx
= ELF64_R_SYM (rel
->r_info
);
14343 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
14344 symbol of the previous ADDR64 reloc. The symbol gives us the
14345 proper TOC base to use. */
14346 if (rel
->r_info
== ELF64_R_INFO (0, R_PPC64_TOC
)
14348 && ELF64_R_TYPE (wrel
[-1].r_info
) == R_PPC64_ADDR64
14350 r_symndx
= ELF64_R_SYM (wrel
[-1].r_info
);
14356 unresolved_reloc
= FALSE
;
14359 if (r_symndx
< symtab_hdr
->sh_info
)
14361 /* It's a local symbol. */
14362 struct _opd_sec_data
*opd
;
14364 sym
= local_syms
+ r_symndx
;
14365 sec
= local_sections
[r_symndx
];
14366 sym_name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
, sec
);
14367 sym_type
= ELF64_ST_TYPE (sym
->st_info
);
14368 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
14369 opd
= get_opd_info (sec
);
14370 if (opd
!= NULL
&& opd
->adjust
!= NULL
)
14372 long adjust
= opd
->adjust
[OPD_NDX (sym
->st_value
14378 /* If this is a relocation against the opd section sym
14379 and we have edited .opd, adjust the reloc addend so
14380 that ld -r and ld --emit-relocs output is correct.
14381 If it is a reloc against some other .opd symbol,
14382 then the symbol value will be adjusted later. */
14383 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
14384 rel
->r_addend
+= adjust
;
14386 relocation
+= adjust
;
14392 bfd_boolean ignored
;
14394 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
14395 r_symndx
, symtab_hdr
, sym_hashes
,
14396 h_elf
, sec
, relocation
,
14397 unresolved_reloc
, warned
, ignored
);
14398 sym_name
= h_elf
->root
.root
.string
;
14399 sym_type
= h_elf
->type
;
14401 && sec
->owner
== output_bfd
14402 && strcmp (sec
->name
, ".opd") == 0)
14404 /* This is a symbol defined in a linker script. All
14405 such are defined in output sections, even those
14406 defined by simple assignment from a symbol defined in
14407 an input section. Transfer the symbol to an
14408 appropriate input .opd section, so that a branch to
14409 this symbol will be mapped to the location specified
14410 by the opd entry. */
14411 struct bfd_link_order
*lo
;
14412 for (lo
= sec
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
14413 if (lo
->type
== bfd_indirect_link_order
)
14415 asection
*isec
= lo
->u
.indirect
.section
;
14416 if (h_elf
->root
.u
.def
.value
>= isec
->output_offset
14417 && h_elf
->root
.u
.def
.value
< (isec
->output_offset
14420 h_elf
->root
.u
.def
.value
-= isec
->output_offset
;
14421 h_elf
->root
.u
.def
.section
= isec
;
14428 h
= (struct ppc_link_hash_entry
*) h_elf
;
14430 if (sec
!= NULL
&& discarded_section (sec
))
14432 _bfd_clear_contents (ppc64_elf_howto_table
[r_type
],
14433 input_bfd
, input_section
,
14434 contents
, rel
->r_offset
);
14435 wrel
->r_offset
= rel
->r_offset
;
14437 wrel
->r_addend
= 0;
14439 /* For ld -r, remove relocations in debug sections against
14440 symbols defined in discarded sections. Not done for
14441 non-debug to preserve relocs in .eh_frame which the
14442 eh_frame editing code expects to be present. */
14443 if (bfd_link_relocatable (info
)
14444 && (input_section
->flags
& SEC_DEBUGGING
))
14450 if (bfd_link_relocatable (info
))
14453 if (h
!= NULL
&& &h
->elf
== htab
->elf
.hgot
)
14455 relocation
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
14456 sec
= bfd_abs_section_ptr
;
14457 unresolved_reloc
= FALSE
;
14460 /* TLS optimizations. Replace instruction sequences and relocs
14461 based on information we collected in tls_optimize. We edit
14462 RELOCS so that --emit-relocs will output something sensible
14463 for the final instruction stream. */
14468 tls_mask
= h
->tls_mask
;
14469 else if (local_got_ents
!= NULL
)
14471 struct plt_entry
**local_plt
= (struct plt_entry
**)
14472 (local_got_ents
+ symtab_hdr
->sh_info
);
14473 unsigned char *lgot_masks
= (unsigned char *)
14474 (local_plt
+ symtab_hdr
->sh_info
);
14475 tls_mask
= lgot_masks
[r_symndx
];
14477 if (((tls_mask
& TLS_TLS
) == 0 || tls_mask
== (TLS_TLS
| TLS_MARK
))
14478 && (r_type
== R_PPC64_TLS
14479 || r_type
== R_PPC64_TLSGD
14480 || r_type
== R_PPC64_TLSLD
))
14482 /* Check for toc tls entries. */
14483 unsigned char *toc_tls
;
14485 if (!get_tls_mask (&toc_tls
, &toc_symndx
, &toc_addend
,
14486 &local_syms
, rel
, input_bfd
))
14490 tls_mask
= *toc_tls
;
14493 /* Check that tls relocs are used with tls syms, and non-tls
14494 relocs are used with non-tls syms. */
14495 if (r_symndx
!= STN_UNDEF
14496 && r_type
!= R_PPC64_NONE
14498 || h
->elf
.root
.type
== bfd_link_hash_defined
14499 || h
->elf
.root
.type
== bfd_link_hash_defweak
)
14500 && IS_PPC64_TLS_RELOC (r_type
) != (sym_type
== STT_TLS
))
14502 if ((tls_mask
& TLS_TLS
) != 0
14503 && (r_type
== R_PPC64_TLS
14504 || r_type
== R_PPC64_TLSGD
14505 || r_type
== R_PPC64_TLSLD
))
14506 /* R_PPC64_TLS is OK against a symbol in the TOC. */
14509 info
->callbacks
->einfo
14510 (!IS_PPC64_TLS_RELOC (r_type
)
14511 /* xgettext:c-format */
14512 ? _("%H: %s used with TLS symbol `%pT'\n")
14513 /* xgettext:c-format */
14514 : _("%H: %s used with non-TLS symbol `%pT'\n"),
14515 input_bfd
, input_section
, rel
->r_offset
,
14516 ppc64_elf_howto_table
[r_type
]->name
,
14520 /* Ensure reloc mapping code below stays sane. */
14521 if (R_PPC64_TOC16_LO_DS
!= R_PPC64_TOC16_DS
+ 1
14522 || R_PPC64_TOC16_LO
!= R_PPC64_TOC16
+ 1
14523 || (R_PPC64_GOT_TLSLD16
& 3) != (R_PPC64_GOT_TLSGD16
& 3)
14524 || (R_PPC64_GOT_TLSLD16_LO
& 3) != (R_PPC64_GOT_TLSGD16_LO
& 3)
14525 || (R_PPC64_GOT_TLSLD16_HI
& 3) != (R_PPC64_GOT_TLSGD16_HI
& 3)
14526 || (R_PPC64_GOT_TLSLD16_HA
& 3) != (R_PPC64_GOT_TLSGD16_HA
& 3)
14527 || (R_PPC64_GOT_TLSLD16
& 3) != (R_PPC64_GOT_TPREL16_DS
& 3)
14528 || (R_PPC64_GOT_TLSLD16_LO
& 3) != (R_PPC64_GOT_TPREL16_LO_DS
& 3)
14529 || (R_PPC64_GOT_TLSLD16_HI
& 3) != (R_PPC64_GOT_TPREL16_HI
& 3)
14530 || (R_PPC64_GOT_TLSLD16_HA
& 3) != (R_PPC64_GOT_TPREL16_HA
& 3))
14538 case R_PPC64_LO_DS_OPT
:
14539 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
- d_offset
);
14540 if ((insn
& (0x3f << 26)) != 58u << 26)
14542 insn
+= (14u << 26) - (58u << 26);
14543 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
- d_offset
);
14544 r_type
= R_PPC64_TOC16_LO
;
14545 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14548 case R_PPC64_TOC16
:
14549 case R_PPC64_TOC16_LO
:
14550 case R_PPC64_TOC16_DS
:
14551 case R_PPC64_TOC16_LO_DS
:
14553 /* Check for toc tls entries. */
14554 unsigned char *toc_tls
;
14557 retval
= get_tls_mask (&toc_tls
, &toc_symndx
, &toc_addend
,
14558 &local_syms
, rel
, input_bfd
);
14564 tls_mask
= *toc_tls
;
14565 if (r_type
== R_PPC64_TOC16_DS
14566 || r_type
== R_PPC64_TOC16_LO_DS
)
14568 if ((tls_mask
& TLS_TLS
) != 0
14569 && (tls_mask
& (TLS_DTPREL
| TLS_TPREL
)) == 0)
14574 /* If we found a GD reloc pair, then we might be
14575 doing a GD->IE transition. */
14579 if ((tls_mask
& TLS_TLS
) != 0
14580 && (tls_mask
& TLS_GD
) == 0)
14583 else if (retval
== 3)
14585 if ((tls_mask
& TLS_TLS
) != 0
14586 && (tls_mask
& TLS_LD
) == 0)
14594 case R_PPC64_GOT_TPREL16_HI
:
14595 case R_PPC64_GOT_TPREL16_HA
:
14596 if ((tls_mask
& TLS_TLS
) != 0
14597 && (tls_mask
& TLS_TPREL
) == 0)
14599 rel
->r_offset
-= d_offset
;
14600 bfd_put_32 (input_bfd
, NOP
, contents
+ rel
->r_offset
);
14601 r_type
= R_PPC64_NONE
;
14602 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14606 case R_PPC64_GOT_TPREL16_DS
:
14607 case R_PPC64_GOT_TPREL16_LO_DS
:
14608 if ((tls_mask
& TLS_TLS
) != 0
14609 && (tls_mask
& TLS_TPREL
) == 0)
14612 insn
= bfd_get_32 (input_bfd
,
14613 contents
+ rel
->r_offset
- d_offset
);
14615 insn
|= 0x3c0d0000; /* addis 0,13,0 */
14616 bfd_put_32 (input_bfd
, insn
,
14617 contents
+ rel
->r_offset
- d_offset
);
14618 r_type
= R_PPC64_TPREL16_HA
;
14619 if (toc_symndx
!= 0)
14621 rel
->r_info
= ELF64_R_INFO (toc_symndx
, r_type
);
14622 rel
->r_addend
= toc_addend
;
14623 /* We changed the symbol. Start over in order to
14624 get h, sym, sec etc. right. */
14628 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14632 case R_PPC64_GOT_TPREL34
:
14633 if ((tls_mask
& TLS_TLS
) != 0
14634 && (tls_mask
& TLS_TPREL
) == 0)
14636 /* pld ra,sym@got@tprel@pcrel -> paddi ra,r13,sym@tprel */
14637 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
14639 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
14640 pinsn
+= ((2ULL << 56) + (-1ULL << 52)
14641 + (14ULL << 26) - (57ULL << 26) + (13ULL << 16));
14642 bfd_put_32 (input_bfd
, pinsn
>> 32,
14643 contents
+ rel
->r_offset
);
14644 bfd_put_32 (input_bfd
, pinsn
& 0xffffffff,
14645 contents
+ rel
->r_offset
+ 4);
14646 r_type
= R_PPC64_TPREL34
;
14647 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14652 if ((tls_mask
& TLS_TLS
) != 0
14653 && (tls_mask
& TLS_TPREL
) == 0)
14655 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
14656 insn
= _bfd_elf_ppc_at_tls_transform (insn
, 13);
14659 if ((rel
->r_offset
& 3) == 0)
14661 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
14662 /* Was PPC64_TLS which sits on insn boundary, now
14663 PPC64_TPREL16_LO which is at low-order half-word. */
14664 rel
->r_offset
+= d_offset
;
14665 r_type
= R_PPC64_TPREL16_LO
;
14666 if (toc_symndx
!= 0)
14668 rel
->r_info
= ELF64_R_INFO (toc_symndx
, r_type
);
14669 rel
->r_addend
= toc_addend
;
14670 /* We changed the symbol. Start over in order to
14671 get h, sym, sec etc. right. */
14675 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14677 else if ((rel
->r_offset
& 3) == 1)
14679 /* For pcrel IE to LE we already have the full
14680 offset and thus don't need an addi here. A nop
14682 if ((insn
& (0x3f << 26)) == 14 << 26)
14684 /* Extract regs from addi rt,ra,si. */
14685 unsigned int rt
= (insn
>> 21) & 0x1f;
14686 unsigned int ra
= (insn
>> 16) & 0x1f;
14691 /* Build or ra,rs,rb with rb==rs, ie. mr ra,rs. */
14692 insn
= (rt
<< 16) | (ra
<< 21) | (ra
<< 11);
14693 insn
|= (31u << 26) | (444u << 1);
14696 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
- 1);
14701 case R_PPC64_GOT_TLSGD16_HI
:
14702 case R_PPC64_GOT_TLSGD16_HA
:
14704 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0)
14708 case R_PPC64_GOT_TLSLD16_HI
:
14709 case R_PPC64_GOT_TLSLD16_HA
:
14710 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0)
14713 if ((tls_mask
& tls_gd
) != 0)
14714 r_type
= (((r_type
- (R_PPC64_GOT_TLSGD16
& 3)) & 3)
14715 + R_PPC64_GOT_TPREL16_DS
);
14718 rel
->r_offset
-= d_offset
;
14719 bfd_put_32 (input_bfd
, NOP
, contents
+ rel
->r_offset
);
14720 r_type
= R_PPC64_NONE
;
14722 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14726 case R_PPC64_GOT_TLSGD16
:
14727 case R_PPC64_GOT_TLSGD16_LO
:
14729 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0)
14733 case R_PPC64_GOT_TLSLD16
:
14734 case R_PPC64_GOT_TLSLD16_LO
:
14735 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0)
14737 unsigned int insn1
, insn2
;
14740 offset
= (bfd_vma
) -1;
14741 /* If not using the newer R_PPC64_TLSGD/LD to mark
14742 __tls_get_addr calls, we must trust that the call
14743 stays with its arg setup insns, ie. that the next
14744 reloc is the __tls_get_addr call associated with
14745 the current reloc. Edit both insns. */
14746 if (input_section
->nomark_tls_get_addr
14747 && rel
+ 1 < relend
14748 && branch_reloc_hash_match (input_bfd
, rel
+ 1,
14749 htab
->tls_get_addr
,
14750 htab
->tls_get_addr_fd
))
14751 offset
= rel
[1].r_offset
;
14752 /* We read the low GOT_TLS (or TOC16) insn because we
14753 need to keep the destination reg. It may be
14754 something other than the usual r3, and moved to r3
14755 before the call by intervening code. */
14756 insn1
= bfd_get_32 (input_bfd
,
14757 contents
+ rel
->r_offset
- d_offset
);
14758 if ((tls_mask
& tls_gd
) != 0)
14761 insn1
&= (0x1f << 21) | (0x1f << 16);
14762 insn1
|= 58 << 26; /* ld */
14763 insn2
= 0x7c636a14; /* add 3,3,13 */
14764 if (offset
!= (bfd_vma
) -1)
14765 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
14766 if (r_type
== R_PPC64_TOC16
14767 || r_type
== R_PPC64_TOC16_LO
)
14768 r_type
+= R_PPC64_TOC16_DS
- R_PPC64_TOC16
;
14770 r_type
= (((r_type
- (R_PPC64_GOT_TLSGD16
& 1)) & 1)
14771 + R_PPC64_GOT_TPREL16_DS
);
14772 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14777 insn1
&= 0x1f << 21;
14778 insn1
|= 0x3c0d0000; /* addis r,13,0 */
14779 insn2
= 0x38630000; /* addi 3,3,0 */
14782 /* Was an LD reloc. */
14783 r_symndx
= STN_UNDEF
;
14784 rel
->r_addend
= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
14786 else if (toc_symndx
!= 0)
14788 r_symndx
= toc_symndx
;
14789 rel
->r_addend
= toc_addend
;
14791 r_type
= R_PPC64_TPREL16_HA
;
14792 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14793 if (offset
!= (bfd_vma
) -1)
14795 rel
[1].r_info
= ELF64_R_INFO (r_symndx
,
14796 R_PPC64_TPREL16_LO
);
14797 rel
[1].r_offset
= offset
+ d_offset
;
14798 rel
[1].r_addend
= rel
->r_addend
;
14801 bfd_put_32 (input_bfd
, insn1
,
14802 contents
+ rel
->r_offset
- d_offset
);
14803 if (offset
!= (bfd_vma
) -1)
14805 bfd_put_32 (input_bfd
, insn2
, contents
+ offset
);
14806 if (offset
+ 8 <= input_section
->size
)
14808 insn2
= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
14809 if (insn2
== LD_R2_0R1
+ STK_TOC (htab
))
14810 bfd_put_32 (input_bfd
, NOP
, contents
+ offset
+ 4);
14813 if ((tls_mask
& tls_gd
) == 0
14814 && (tls_gd
== 0 || toc_symndx
!= 0))
14816 /* We changed the symbol. Start over in order
14817 to get h, sym, sec etc. right. */
14823 case R_PPC64_GOT_TLSGD34
:
14824 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0)
14826 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
14828 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
14829 if ((tls_mask
& TLS_GDIE
) != 0)
14831 /* IE, pla -> pld */
14832 pinsn
+= (-2ULL << 56) + (57ULL << 26) - (14ULL << 26);
14833 r_type
= R_PPC64_GOT_TPREL34
;
14837 /* LE, pla pcrel -> paddi r13 */
14838 pinsn
+= (-1ULL << 52) + (13ULL << 16);
14839 r_type
= R_PPC64_TPREL34
;
14841 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14842 bfd_put_32 (input_bfd
, pinsn
>> 32,
14843 contents
+ rel
->r_offset
);
14844 bfd_put_32 (input_bfd
, pinsn
& 0xffffffff,
14845 contents
+ rel
->r_offset
+ 4);
14849 case R_PPC64_GOT_TLSLD34
:
14850 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0)
14852 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
14854 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
14855 pinsn
+= (-1ULL << 52) + (13ULL << 16);
14856 bfd_put_32 (input_bfd
, pinsn
>> 32,
14857 contents
+ rel
->r_offset
);
14858 bfd_put_32 (input_bfd
, pinsn
& 0xffffffff,
14859 contents
+ rel
->r_offset
+ 4);
14860 rel
->r_addend
= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
14861 r_symndx
= STN_UNDEF
;
14862 r_type
= R_PPC64_TPREL34
;
14863 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14868 case R_PPC64_TLSGD
:
14869 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0
14870 && rel
+ 1 < relend
)
14872 unsigned int insn2
;
14873 enum elf_ppc64_reloc_type r_type1
= ELF64_R_TYPE (rel
[1].r_info
);
14875 offset
= rel
->r_offset
;
14876 if (is_plt_seq_reloc (r_type1
))
14878 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
);
14879 if (r_type1
== R_PPC64_PLT_PCREL34
14880 || r_type1
== R_PPC64_PLT_PCREL34_NOTOC
)
14881 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
14882 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
14886 if (ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_PLTCALL
)
14887 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
14889 if ((tls_mask
& TLS_GDIE
) != 0)
14892 r_type
= R_PPC64_NONE
;
14893 insn2
= 0x7c636a14; /* add 3,3,13 */
14898 if (toc_symndx
!= 0)
14900 r_symndx
= toc_symndx
;
14901 rel
->r_addend
= toc_addend
;
14903 if (r_type1
== R_PPC64_REL24_NOTOC
14904 || r_type1
== R_PPC64_PLTCALL_NOTOC
)
14906 r_type
= R_PPC64_NONE
;
14911 rel
->r_offset
= offset
+ d_offset
;
14912 r_type
= R_PPC64_TPREL16_LO
;
14913 insn2
= 0x38630000; /* addi 3,3,0 */
14916 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14917 /* Zap the reloc on the _tls_get_addr call too. */
14918 BFD_ASSERT (offset
== rel
[1].r_offset
);
14919 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
14920 bfd_put_32 (input_bfd
, insn2
, contents
+ offset
);
14921 if ((tls_mask
& TLS_GDIE
) == 0
14923 && r_type
!= R_PPC64_NONE
)
14928 case R_PPC64_TLSLD
:
14929 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0
14930 && rel
+ 1 < relend
)
14932 unsigned int insn2
;
14933 enum elf_ppc64_reloc_type r_type1
= ELF64_R_TYPE (rel
[1].r_info
);
14935 offset
= rel
->r_offset
;
14936 if (is_plt_seq_reloc (r_type1
))
14938 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
);
14939 if (r_type1
== R_PPC64_PLT_PCREL34
14940 || r_type1
== R_PPC64_PLT_PCREL34_NOTOC
)
14941 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
14942 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
14946 if (ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_PLTCALL
)
14947 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
14949 if (r_type1
== R_PPC64_REL24_NOTOC
14950 || r_type1
== R_PPC64_PLTCALL_NOTOC
)
14952 r_type
= R_PPC64_NONE
;
14957 rel
->r_offset
= offset
+ d_offset
;
14958 r_symndx
= STN_UNDEF
;
14959 r_type
= R_PPC64_TPREL16_LO
;
14960 rel
->r_addend
= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
14961 insn2
= 0x38630000; /* addi 3,3,0 */
14963 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14964 /* Zap the reloc on the _tls_get_addr call too. */
14965 BFD_ASSERT (offset
== rel
[1].r_offset
);
14966 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
14967 bfd_put_32 (input_bfd
, insn2
, contents
+ offset
);
14968 if (r_type
!= R_PPC64_NONE
)
14973 case R_PPC64_DTPMOD64
:
14974 if (rel
+ 1 < relend
14975 && rel
[1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_DTPREL64
)
14976 && rel
[1].r_offset
== rel
->r_offset
+ 8)
14978 if ((tls_mask
& TLS_GD
) == 0)
14980 rel
[1].r_info
= ELF64_R_INFO (r_symndx
, R_PPC64_NONE
);
14981 if ((tls_mask
& TLS_GDIE
) != 0)
14982 r_type
= R_PPC64_TPREL64
;
14985 bfd_put_64 (output_bfd
, 1, contents
+ rel
->r_offset
);
14986 r_type
= R_PPC64_NONE
;
14988 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14993 if ((tls_mask
& TLS_LD
) == 0)
14995 bfd_put_64 (output_bfd
, 1, contents
+ rel
->r_offset
);
14996 r_type
= R_PPC64_NONE
;
14997 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15002 case R_PPC64_TPREL64
:
15003 if ((tls_mask
& TLS_TPREL
) == 0)
15005 r_type
= R_PPC64_NONE
;
15006 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15010 case R_PPC64_ENTRY
:
15011 relocation
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
15012 if (!bfd_link_pic (info
)
15013 && !info
->traditional_format
15014 && relocation
+ 0x80008000 <= 0xffffffff)
15016 unsigned int insn1
, insn2
;
15018 insn1
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15019 insn2
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15020 if ((insn1
& ~0xfffc) == LD_R2_0R12
15021 && insn2
== ADD_R2_R2_R12
)
15023 bfd_put_32 (input_bfd
,
15024 LIS_R2
+ PPC_HA (relocation
),
15025 contents
+ rel
->r_offset
);
15026 bfd_put_32 (input_bfd
,
15027 ADDI_R2_R2
+ PPC_LO (relocation
),
15028 contents
+ rel
->r_offset
+ 4);
15033 relocation
-= (rel
->r_offset
15034 + input_section
->output_offset
15035 + input_section
->output_section
->vma
);
15036 if (relocation
+ 0x80008000 <= 0xffffffff)
15038 unsigned int insn1
, insn2
;
15040 insn1
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15041 insn2
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15042 if ((insn1
& ~0xfffc) == LD_R2_0R12
15043 && insn2
== ADD_R2_R2_R12
)
15045 bfd_put_32 (input_bfd
,
15046 ADDIS_R2_R12
+ PPC_HA (relocation
),
15047 contents
+ rel
->r_offset
);
15048 bfd_put_32 (input_bfd
,
15049 ADDI_R2_R2
+ PPC_LO (relocation
),
15050 contents
+ rel
->r_offset
+ 4);
15056 case R_PPC64_REL16_HA
:
15057 /* If we are generating a non-PIC executable, edit
15058 . 0: addis 2,12,.TOC.-0b@ha
15059 . addi 2,2,.TOC.-0b@l
15060 used by ELFv2 global entry points to set up r2, to
15063 if .TOC. is in range. */
15064 if (!bfd_link_pic (info
)
15065 && !info
->traditional_format
15067 && rel
->r_addend
== d_offset
15068 && h
!= NULL
&& &h
->elf
== htab
->elf
.hgot
15069 && rel
+ 1 < relend
15070 && rel
[1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_REL16_LO
)
15071 && rel
[1].r_offset
== rel
->r_offset
+ 4
15072 && rel
[1].r_addend
== rel
->r_addend
+ 4
15073 && relocation
+ 0x80008000 <= 0xffffffff)
15075 unsigned int insn1
, insn2
;
15076 offset
= rel
->r_offset
- d_offset
;
15077 insn1
= bfd_get_32 (input_bfd
, contents
+ offset
);
15078 insn2
= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
15079 if ((insn1
& 0xffff0000) == ADDIS_R2_R12
15080 && (insn2
& 0xffff0000) == ADDI_R2_R2
)
15082 r_type
= R_PPC64_ADDR16_HA
;
15083 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15084 rel
->r_addend
-= d_offset
;
15085 rel
[1].r_info
= ELF64_R_INFO (r_symndx
, R_PPC64_ADDR16_LO
);
15086 rel
[1].r_addend
-= d_offset
+ 4;
15087 bfd_put_32 (input_bfd
, LIS_R2
, contents
+ offset
);
15093 /* Handle other relocations that tweak non-addend part of insn. */
15095 max_br_offset
= 1 << 25;
15096 addend
= rel
->r_addend
;
15097 reloc_dest
= DEST_NORMAL
;
15103 case R_PPC64_TOCSAVE
:
15104 if (relocation
+ addend
== (rel
->r_offset
15105 + input_section
->output_offset
15106 + input_section
->output_section
->vma
)
15107 && tocsave_find (htab
, NO_INSERT
,
15108 &local_syms
, rel
, input_bfd
))
15110 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15112 || insn
== CROR_151515
|| insn
== CROR_313131
)
15113 bfd_put_32 (input_bfd
,
15114 STD_R2_0R1
+ STK_TOC (htab
),
15115 contents
+ rel
->r_offset
);
15119 /* Branch taken prediction relocations. */
15120 case R_PPC64_ADDR14_BRTAKEN
:
15121 case R_PPC64_REL14_BRTAKEN
:
15122 insn
= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
15123 /* Fall through. */
15125 /* Branch not taken prediction relocations. */
15126 case R_PPC64_ADDR14_BRNTAKEN
:
15127 case R_PPC64_REL14_BRNTAKEN
:
15128 insn
|= bfd_get_32 (input_bfd
,
15129 contents
+ rel
->r_offset
) & ~(0x01 << 21);
15130 /* Fall through. */
15132 case R_PPC64_REL14
:
15133 max_br_offset
= 1 << 15;
15134 /* Fall through. */
15136 case R_PPC64_REL24
:
15137 case R_PPC64_REL24_NOTOC
:
15138 case R_PPC64_PLTCALL
:
15139 case R_PPC64_PLTCALL_NOTOC
:
15140 /* Calls to functions with a different TOC, such as calls to
15141 shared objects, need to alter the TOC pointer. This is
15142 done using a linkage stub. A REL24 branching to these
15143 linkage stubs needs to be followed by a nop, as the nop
15144 will be replaced with an instruction to restore the TOC
15149 && h
->oh
->is_func_descriptor
)
15150 fdh
= ppc_follow_link (h
->oh
);
15151 stub_entry
= ppc_get_stub_entry (input_section
, sec
, fdh
, &orig_rel
,
15153 if ((r_type
== R_PPC64_PLTCALL
15154 || r_type
== R_PPC64_PLTCALL_NOTOC
)
15155 && stub_entry
!= NULL
15156 && stub_entry
->stub_type
>= ppc_stub_plt_call
15157 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15160 if (stub_entry
!= NULL
15161 && ((stub_entry
->stub_type
>= ppc_stub_plt_call
15162 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15163 || stub_entry
->stub_type
== ppc_stub_plt_branch_r2off
15164 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
15165 || stub_entry
->stub_type
== ppc_stub_long_branch_r2off
15166 || stub_entry
->stub_type
== ppc_stub_long_branch_both
))
15168 bfd_boolean can_plt_call
= FALSE
;
15170 if (stub_entry
->stub_type
== ppc_stub_plt_call
15172 && htab
->params
->plt_localentry0
!= 0
15173 && is_elfv2_localentry0 (&h
->elf
))
15175 /* The function doesn't use or change r2. */
15176 can_plt_call
= TRUE
;
15178 else if (r_type
== R_PPC64_REL24_NOTOC
)
15180 /* NOTOC calls don't need to restore r2. */
15181 can_plt_call
= TRUE
;
15184 /* All of these stubs may modify r2, so there must be a
15185 branch and link followed by a nop. The nop is
15186 replaced by an insn to restore r2. */
15187 else if (rel
->r_offset
+ 8 <= input_section
->size
)
15191 br
= bfd_get_32 (input_bfd
,
15192 contents
+ rel
->r_offset
);
15197 nop
= bfd_get_32 (input_bfd
,
15198 contents
+ rel
->r_offset
+ 4);
15199 if (nop
== LD_R2_0R1
+ STK_TOC (htab
))
15200 can_plt_call
= TRUE
;
15201 else if (nop
== NOP
15202 || nop
== CROR_151515
15203 || nop
== CROR_313131
)
15206 && (h
== htab
->tls_get_addr_fd
15207 || h
== htab
->tls_get_addr
)
15208 && htab
->params
->tls_get_addr_opt
)
15210 /* Special stub used, leave nop alone. */
15213 bfd_put_32 (input_bfd
,
15214 LD_R2_0R1
+ STK_TOC (htab
),
15215 contents
+ rel
->r_offset
+ 4);
15216 can_plt_call
= TRUE
;
15221 if (!can_plt_call
&& h
!= NULL
)
15223 const char *name
= h
->elf
.root
.root
.string
;
15228 if (strncmp (name
, "__libc_start_main", 17) == 0
15229 && (name
[17] == 0 || name
[17] == '@'))
15231 /* Allow crt1 branch to go via a toc adjusting
15232 stub. Other calls that never return could do
15233 the same, if we could detect such. */
15234 can_plt_call
= TRUE
;
15240 /* g++ as of 20130507 emits self-calls without a
15241 following nop. This is arguably wrong since we
15242 have conflicting information. On the one hand a
15243 global symbol and on the other a local call
15244 sequence, but don't error for this special case.
15245 It isn't possible to cheaply verify we have
15246 exactly such a call. Allow all calls to the same
15248 asection
*code_sec
= sec
;
15250 if (get_opd_info (sec
) != NULL
)
15252 bfd_vma off
= (relocation
+ addend
15253 - sec
->output_section
->vma
15254 - sec
->output_offset
);
15256 opd_entry_value (sec
, off
, &code_sec
, NULL
, FALSE
);
15258 if (code_sec
== input_section
)
15259 can_plt_call
= TRUE
;
15264 if (stub_entry
->stub_type
>= ppc_stub_plt_call
15265 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15266 info
->callbacks
->einfo
15267 /* xgettext:c-format */
15268 (_("%H: call to `%pT' lacks nop, can't restore toc; "
15269 "(plt call stub)\n"),
15270 input_bfd
, input_section
, rel
->r_offset
, sym_name
);
15272 info
->callbacks
->einfo
15273 /* xgettext:c-format */
15274 (_("%H: call to `%pT' lacks nop, can't restore toc; "
15275 "(toc save/adjust stub)\n"),
15276 input_bfd
, input_section
, rel
->r_offset
, sym_name
);
15278 bfd_set_error (bfd_error_bad_value
);
15283 && stub_entry
->stub_type
>= ppc_stub_plt_call
15284 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15285 unresolved_reloc
= FALSE
;
15288 if ((stub_entry
== NULL
15289 || stub_entry
->stub_type
== ppc_stub_long_branch
15290 || stub_entry
->stub_type
== ppc_stub_plt_branch
)
15291 && get_opd_info (sec
) != NULL
)
15293 /* The branch destination is the value of the opd entry. */
15294 bfd_vma off
= (relocation
+ addend
15295 - sec
->output_section
->vma
15296 - sec
->output_offset
);
15297 bfd_vma dest
= opd_entry_value (sec
, off
, NULL
, NULL
, FALSE
);
15298 if (dest
!= (bfd_vma
) -1)
15302 reloc_dest
= DEST_OPD
;
15306 /* If the branch is out of reach we ought to have a long
15308 from
= (rel
->r_offset
15309 + input_section
->output_offset
15310 + input_section
->output_section
->vma
);
15312 relocation
+= PPC64_LOCAL_ENTRY_OFFSET (fdh
15316 if (stub_entry
!= NULL
15317 && (stub_entry
->stub_type
== ppc_stub_long_branch
15318 || stub_entry
->stub_type
== ppc_stub_plt_branch
)
15319 && (r_type
== R_PPC64_ADDR14_BRTAKEN
15320 || r_type
== R_PPC64_ADDR14_BRNTAKEN
15321 || (relocation
+ addend
- from
+ max_br_offset
15322 < 2 * max_br_offset
)))
15323 /* Don't use the stub if this branch is in range. */
15326 if (stub_entry
!= NULL
15327 && (stub_entry
->stub_type
== ppc_stub_long_branch_notoc
15328 || stub_entry
->stub_type
== ppc_stub_long_branch_both
15329 || stub_entry
->stub_type
== ppc_stub_plt_branch_notoc
15330 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
)
15331 && (r_type
!= R_PPC64_REL24_NOTOC
15332 || ((fdh
? fdh
->elf
.other
: sym
->st_other
)
15333 & STO_PPC64_LOCAL_MASK
) <= 1 << STO_PPC64_LOCAL_BIT
)
15334 && (relocation
+ addend
- from
+ max_br_offset
15335 < 2 * max_br_offset
))
15338 if (stub_entry
!= NULL
15339 && (stub_entry
->stub_type
== ppc_stub_long_branch_r2off
15340 || stub_entry
->stub_type
== ppc_stub_long_branch_both
15341 || stub_entry
->stub_type
== ppc_stub_plt_branch_r2off
15342 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
)
15343 && r_type
== R_PPC64_REL24_NOTOC
15344 && (relocation
+ addend
- from
+ max_br_offset
15345 < 2 * max_br_offset
))
15348 if (stub_entry
!= NULL
)
15350 /* Munge up the value and addend so that we call the stub
15351 rather than the procedure directly. */
15352 asection
*stub_sec
= stub_entry
->group
->stub_sec
;
15354 if (stub_entry
->stub_type
== ppc_stub_save_res
)
15355 relocation
+= (stub_sec
->output_offset
15356 + stub_sec
->output_section
->vma
15357 + stub_sec
->size
- htab
->sfpr
->size
15358 - htab
->sfpr
->output_offset
15359 - htab
->sfpr
->output_section
->vma
);
15361 relocation
= (stub_entry
->stub_offset
15362 + stub_sec
->output_offset
15363 + stub_sec
->output_section
->vma
);
15365 reloc_dest
= DEST_STUB
;
15367 if (((stub_entry
->stub_type
== ppc_stub_plt_call
15368 && ALWAYS_EMIT_R2SAVE
)
15369 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
15370 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
15372 && (h
== htab
->tls_get_addr_fd
15373 || h
== htab
->tls_get_addr
)
15374 && htab
->params
->tls_get_addr_opt
)
15375 && rel
+ 1 < relend
15376 && rel
[1].r_offset
== rel
->r_offset
+ 4
15377 && ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_TOCSAVE
)
15379 else if ((stub_entry
->stub_type
== ppc_stub_long_branch_both
15380 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
15381 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
15382 && r_type
== R_PPC64_REL24_NOTOC
)
15385 if (r_type
== R_PPC64_REL24_NOTOC
15386 && (stub_entry
->stub_type
== ppc_stub_plt_call_notoc
15387 || stub_entry
->stub_type
== ppc_stub_plt_call_both
))
15388 htab
->notoc_plt
= 1;
15395 /* Set 'a' bit. This is 0b00010 in BO field for branch
15396 on CR(BI) insns (BO == 001at or 011at), and 0b01000
15397 for branch on CTR insns (BO == 1a00t or 1a01t). */
15398 if ((insn
& (0x14 << 21)) == (0x04 << 21))
15399 insn
|= 0x02 << 21;
15400 else if ((insn
& (0x14 << 21)) == (0x10 << 21))
15401 insn
|= 0x08 << 21;
15407 /* Invert 'y' bit if not the default. */
15408 if ((bfd_signed_vma
) (relocation
+ addend
- from
) < 0)
15409 insn
^= 0x01 << 21;
15412 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
15415 /* NOP out calls to undefined weak functions.
15416 We can thus call a weak function without first
15417 checking whether the function is defined. */
15419 && h
->elf
.root
.type
== bfd_link_hash_undefweak
15420 && h
->elf
.dynindx
== -1
15421 && (r_type
== R_PPC64_REL24
15422 || r_type
== R_PPC64_REL24_NOTOC
)
15426 bfd_put_32 (input_bfd
, NOP
, contents
+ rel
->r_offset
);
15431 case R_PPC64_GOT16_DS
:
15432 from
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
15433 if (relocation
+ addend
- from
+ 0x8000 < 0x10000
15434 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15436 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
15437 if ((insn
& (0x3f << 26 | 0x3)) == 58u << 26 /* ld */)
15439 insn
+= (14u << 26) - (58u << 26);
15440 bfd_put_32 (input_bfd
, insn
, contents
+ (rel
->r_offset
& ~3));
15441 r_type
= R_PPC64_TOC16
;
15442 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15447 case R_PPC64_GOT16_LO_DS
:
15448 case R_PPC64_GOT16_HA
:
15449 from
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
15450 if (relocation
+ addend
- from
+ 0x80008000ULL
< 0x100000000ULL
15451 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15453 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
15454 if ((insn
& (0x3f << 26 | 0x3)) == 58u << 26 /* ld */)
15456 insn
+= (14u << 26) - (58u << 26);
15457 bfd_put_32 (input_bfd
, insn
, contents
+ (rel
->r_offset
& ~3));
15458 r_type
= R_PPC64_TOC16_LO
;
15459 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15461 else if ((insn
& (0x3f << 26)) == 15u << 26 /* addis */)
15463 r_type
= R_PPC64_TOC16_HA
;
15464 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15469 case R_PPC64_GOT_PCREL34
:
15470 from
= (rel
->r_offset
15471 + input_section
->output_section
->vma
15472 + input_section
->output_offset
);
15473 if (relocation
- from
+ (1ULL << 33) < 1ULL << 34
15474 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15476 offset
= rel
->r_offset
;
15477 pinsn
= bfd_get_32 (input_bfd
, contents
+ offset
);
15479 pinsn
|= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
15480 if ((pinsn
& ((-1ULL << 50) | (63ULL << 26)))
15481 == ((1ULL << 58) | (1ULL << 52) | (57ULL << 26) /* pld */))
15483 /* Replace with paddi. */
15484 pinsn
+= (2ULL << 56) + (14ULL << 26) - (57ULL << 26);
15485 r_type
= R_PPC64_PCREL34
;
15486 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15487 bfd_put_32 (input_bfd
, pinsn
>> 32, contents
+ offset
);
15488 bfd_put_32 (input_bfd
, pinsn
, contents
+ offset
+ 4);
15494 case R_PPC64_PCREL34
:
15495 if (SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15497 offset
= rel
->r_offset
;
15498 pinsn
= bfd_get_32 (input_bfd
, contents
+ offset
);
15500 pinsn
|= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
15501 if ((pinsn
& ((-1ULL << 50) | (63ULL << 26)))
15502 == ((1ULL << 58) | (2ULL << 56) | (1ULL << 52)
15503 | (14ULL << 26) /* paddi */))
15506 if (rel
+ 1 < relend
15507 && rel
[1].r_offset
== offset
15508 && rel
[1].r_info
== ELF64_R_INFO (0, R_PPC64_PCREL_OPT
))
15510 bfd_vma off2
= rel
[1].r_addend
;
15512 /* zero means next insn. */
15515 if (off2
+ 4 <= input_section
->size
)
15518 bfd_signed_vma addend_off
;
15519 pinsn2
= bfd_get_32 (input_bfd
, contents
+ off2
);
15521 if ((pinsn2
& (63ULL << 58)) == 1ULL << 58)
15523 if (off2
+ 8 > input_section
->size
)
15525 pinsn2
|= bfd_get_32 (input_bfd
,
15526 contents
+ off2
+ 4);
15528 if (xlate_pcrel_opt (&pinsn
, &pinsn2
, &addend_off
))
15530 addend
+= addend_off
;
15531 rel
->r_addend
= addend
;
15532 bfd_put_32 (input_bfd
, pinsn
>> 32,
15533 contents
+ offset
);
15534 bfd_put_32 (input_bfd
, pinsn
,
15535 contents
+ offset
+ 4);
15536 bfd_put_32 (input_bfd
, pinsn2
>> 32,
15538 if ((pinsn2
& (63ULL << 58)) == 1ULL << 58)
15539 bfd_put_32 (input_bfd
, pinsn2
,
15540 contents
+ off2
+ 4);
15550 save_unresolved_reloc
= unresolved_reloc
;
15554 /* xgettext:c-format */
15555 _bfd_error_handler (_("%pB: %s unsupported"),
15556 input_bfd
, ppc64_elf_howto_table
[r_type
]->name
);
15558 bfd_set_error (bfd_error_bad_value
);
15564 case R_PPC64_TLSGD
:
15565 case R_PPC64_TLSLD
:
15566 case R_PPC64_TOCSAVE
:
15567 case R_PPC64_GNU_VTINHERIT
:
15568 case R_PPC64_GNU_VTENTRY
:
15569 case R_PPC64_ENTRY
:
15570 case R_PPC64_PCREL_OPT
:
15573 /* GOT16 relocations. Like an ADDR16 using the symbol's
15574 address in the GOT as relocation value instead of the
15575 symbol's value itself. Also, create a GOT entry for the
15576 symbol and put the symbol value there. */
15577 case R_PPC64_GOT_TLSGD16
:
15578 case R_PPC64_GOT_TLSGD16_LO
:
15579 case R_PPC64_GOT_TLSGD16_HI
:
15580 case R_PPC64_GOT_TLSGD16_HA
:
15581 case R_PPC64_GOT_TLSGD34
:
15582 tls_type
= TLS_TLS
| TLS_GD
;
15585 case R_PPC64_GOT_TLSLD16
:
15586 case R_PPC64_GOT_TLSLD16_LO
:
15587 case R_PPC64_GOT_TLSLD16_HI
:
15588 case R_PPC64_GOT_TLSLD16_HA
:
15589 case R_PPC64_GOT_TLSLD34
:
15590 tls_type
= TLS_TLS
| TLS_LD
;
15593 case R_PPC64_GOT_TPREL16_DS
:
15594 case R_PPC64_GOT_TPREL16_LO_DS
:
15595 case R_PPC64_GOT_TPREL16_HI
:
15596 case R_PPC64_GOT_TPREL16_HA
:
15597 case R_PPC64_GOT_TPREL34
:
15598 tls_type
= TLS_TLS
| TLS_TPREL
;
15601 case R_PPC64_GOT_DTPREL16_DS
:
15602 case R_PPC64_GOT_DTPREL16_LO_DS
:
15603 case R_PPC64_GOT_DTPREL16_HI
:
15604 case R_PPC64_GOT_DTPREL16_HA
:
15605 case R_PPC64_GOT_DTPREL34
:
15606 tls_type
= TLS_TLS
| TLS_DTPREL
;
15609 case R_PPC64_GOT16
:
15610 case R_PPC64_GOT16_LO
:
15611 case R_PPC64_GOT16_HI
:
15612 case R_PPC64_GOT16_HA
:
15613 case R_PPC64_GOT16_DS
:
15614 case R_PPC64_GOT16_LO_DS
:
15615 case R_PPC64_GOT_PCREL34
:
15618 /* Relocation is to the entry for this symbol in the global
15623 unsigned long indx
= 0;
15624 struct got_entry
*ent
;
15626 if (tls_type
== (TLS_TLS
| TLS_LD
)
15627 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15628 ent
= ppc64_tlsld_got (input_bfd
);
15633 if (!htab
->elf
.dynamic_sections_created
15634 || h
->elf
.dynindx
== -1
15635 || SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
)
15636 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, &h
->elf
))
15637 /* This is actually a static link, or it is a
15638 -Bsymbolic link and the symbol is defined
15639 locally, or the symbol was forced to be local
15640 because of a version file. */
15644 indx
= h
->elf
.dynindx
;
15645 unresolved_reloc
= FALSE
;
15647 ent
= h
->elf
.got
.glist
;
15651 if (local_got_ents
== NULL
)
15653 ent
= local_got_ents
[r_symndx
];
15656 for (; ent
!= NULL
; ent
= ent
->next
)
15657 if (ent
->addend
== orig_rel
.r_addend
15658 && ent
->owner
== input_bfd
15659 && ent
->tls_type
== tls_type
)
15665 if (ent
->is_indirect
)
15666 ent
= ent
->got
.ent
;
15667 offp
= &ent
->got
.offset
;
15668 got
= ppc64_elf_tdata (ent
->owner
)->got
;
15672 /* The offset must always be a multiple of 8. We use the
15673 least significant bit to record whether we have already
15674 processed this entry. */
15676 if ((off
& 1) != 0)
15680 /* Generate relocs for the dynamic linker, except in
15681 the case of TLSLD where we'll use one entry per
15689 ? h
->elf
.type
== STT_GNU_IFUNC
15690 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
);
15693 relgot
= htab
->elf
.irelplt
;
15695 htab
->local_ifunc_resolver
= 1;
15696 else if (is_static_defined (&h
->elf
))
15697 htab
->maybe_local_ifunc_resolver
= 1;
15700 || (bfd_link_pic (info
)
15702 || !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, &h
->elf
))
15704 && bfd_link_executable (info
)
15705 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))))
15706 relgot
= ppc64_elf_tdata (ent
->owner
)->relgot
;
15707 if (relgot
!= NULL
)
15709 outrel
.r_offset
= (got
->output_section
->vma
15710 + got
->output_offset
15712 outrel
.r_addend
= orig_rel
.r_addend
;
15713 if (tls_type
& (TLS_LD
| TLS_GD
))
15715 outrel
.r_addend
= 0;
15716 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_DTPMOD64
);
15717 if (tls_type
== (TLS_TLS
| TLS_GD
))
15719 loc
= relgot
->contents
;
15720 loc
+= (relgot
->reloc_count
++
15721 * sizeof (Elf64_External_Rela
));
15722 bfd_elf64_swap_reloca_out (output_bfd
,
15724 outrel
.r_offset
+= 8;
15725 outrel
.r_addend
= orig_rel
.r_addend
;
15727 = ELF64_R_INFO (indx
, R_PPC64_DTPREL64
);
15730 else if (tls_type
== (TLS_TLS
| TLS_DTPREL
))
15731 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_DTPREL64
);
15732 else if (tls_type
== (TLS_TLS
| TLS_TPREL
))
15733 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_TPREL64
);
15734 else if (indx
!= 0)
15735 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_GLOB_DAT
);
15739 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
15741 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
15743 /* Write the .got section contents for the sake
15745 loc
= got
->contents
+ off
;
15746 bfd_put_64 (output_bfd
, outrel
.r_addend
+ relocation
,
15750 if (indx
== 0 && tls_type
!= (TLS_TLS
| TLS_LD
))
15752 outrel
.r_addend
+= relocation
;
15753 if (tls_type
& (TLS_GD
| TLS_DTPREL
| TLS_TPREL
))
15755 if (htab
->elf
.tls_sec
== NULL
)
15756 outrel
.r_addend
= 0;
15758 outrel
.r_addend
-= htab
->elf
.tls_sec
->vma
;
15761 loc
= relgot
->contents
;
15762 loc
+= (relgot
->reloc_count
++
15763 * sizeof (Elf64_External_Rela
));
15764 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
15767 /* Init the .got section contents here if we're not
15768 emitting a reloc. */
15771 relocation
+= orig_rel
.r_addend
;
15774 if (htab
->elf
.tls_sec
== NULL
)
15778 if (tls_type
& TLS_LD
)
15781 relocation
-= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
15782 if (tls_type
& TLS_TPREL
)
15783 relocation
+= DTP_OFFSET
- TP_OFFSET
;
15786 if (tls_type
& (TLS_GD
| TLS_LD
))
15788 bfd_put_64 (output_bfd
, relocation
,
15789 got
->contents
+ off
+ 8);
15793 bfd_put_64 (output_bfd
, relocation
,
15794 got
->contents
+ off
);
15798 if (off
>= (bfd_vma
) -2)
15801 relocation
= got
->output_section
->vma
+ got
->output_offset
+ off
;
15803 if (!(r_type
== R_PPC64_GOT_PCREL34
15804 || r_type
== R_PPC64_GOT_TLSGD34
15805 || r_type
== R_PPC64_GOT_TLSLD34
15806 || r_type
== R_PPC64_GOT_TPREL34
15807 || r_type
== R_PPC64_GOT_DTPREL34
))
15808 addend
= -(TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
);
15812 case R_PPC64_PLT16_HA
:
15813 case R_PPC64_PLT16_HI
:
15814 case R_PPC64_PLT16_LO
:
15815 case R_PPC64_PLT16_LO_DS
:
15816 case R_PPC64_PLT_PCREL34
:
15817 case R_PPC64_PLT_PCREL34_NOTOC
:
15818 case R_PPC64_PLT32
:
15819 case R_PPC64_PLT64
:
15820 case R_PPC64_PLTSEQ
:
15821 case R_PPC64_PLTSEQ_NOTOC
:
15822 case R_PPC64_PLTCALL
:
15823 case R_PPC64_PLTCALL_NOTOC
:
15824 /* Relocation is to the entry for this symbol in the
15825 procedure linkage table. */
15826 unresolved_reloc
= TRUE
;
15828 struct plt_entry
**plt_list
= NULL
;
15830 plt_list
= &h
->elf
.plt
.plist
;
15831 else if (local_got_ents
!= NULL
)
15833 struct plt_entry
**local_plt
= (struct plt_entry
**)
15834 (local_got_ents
+ symtab_hdr
->sh_info
);
15835 plt_list
= local_plt
+ r_symndx
;
15839 struct plt_entry
*ent
;
15841 for (ent
= *plt_list
; ent
!= NULL
; ent
= ent
->next
)
15842 if (ent
->plt
.offset
!= (bfd_vma
) -1
15843 && ent
->addend
== orig_rel
.r_addend
)
15848 plt
= htab
->elf
.splt
;
15849 if (!htab
->elf
.dynamic_sections_created
15851 || h
->elf
.dynindx
== -1)
15854 ? h
->elf
.type
== STT_GNU_IFUNC
15855 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
15856 plt
= htab
->elf
.iplt
;
15858 plt
= htab
->pltlocal
;
15860 relocation
= (plt
->output_section
->vma
15861 + plt
->output_offset
15862 + ent
->plt
.offset
);
15863 if (r_type
== R_PPC64_PLT16_HA
15864 || r_type
== R_PPC64_PLT16_HI
15865 || r_type
== R_PPC64_PLT16_LO
15866 || r_type
== R_PPC64_PLT16_LO_DS
)
15868 got
= (elf_gp (output_bfd
)
15869 + htab
->sec_info
[input_section
->id
].toc_off
);
15873 unresolved_reloc
= FALSE
;
15881 /* Relocation value is TOC base. */
15882 relocation
= TOCstart
;
15883 if (r_symndx
== STN_UNDEF
)
15884 relocation
+= htab
->sec_info
[input_section
->id
].toc_off
;
15885 else if (unresolved_reloc
)
15887 else if (sec
!= NULL
&& sec
->id
< htab
->sec_info_arr_size
)
15888 relocation
+= htab
->sec_info
[sec
->id
].toc_off
;
15890 unresolved_reloc
= TRUE
;
15893 /* TOC16 relocs. We want the offset relative to the TOC base,
15894 which is the address of the start of the TOC plus 0x8000.
15895 The TOC consists of sections .got, .toc, .tocbss, and .plt,
15897 case R_PPC64_TOC16
:
15898 case R_PPC64_TOC16_LO
:
15899 case R_PPC64_TOC16_HI
:
15900 case R_PPC64_TOC16_DS
:
15901 case R_PPC64_TOC16_LO_DS
:
15902 case R_PPC64_TOC16_HA
:
15903 addend
-= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
15908 /* Relocate against the beginning of the section. */
15909 case R_PPC64_SECTOFF
:
15910 case R_PPC64_SECTOFF_LO
:
15911 case R_PPC64_SECTOFF_HI
:
15912 case R_PPC64_SECTOFF_DS
:
15913 case R_PPC64_SECTOFF_LO_DS
:
15914 case R_PPC64_SECTOFF_HA
:
15916 addend
-= sec
->output_section
->vma
;
15919 case R_PPC64_REL16
:
15920 case R_PPC64_REL16_LO
:
15921 case R_PPC64_REL16_HI
:
15922 case R_PPC64_REL16_HA
:
15923 case R_PPC64_REL16_HIGH
:
15924 case R_PPC64_REL16_HIGHA
:
15925 case R_PPC64_REL16_HIGHER
:
15926 case R_PPC64_REL16_HIGHERA
:
15927 case R_PPC64_REL16_HIGHEST
:
15928 case R_PPC64_REL16_HIGHESTA
:
15929 case R_PPC64_REL16_HIGHER34
:
15930 case R_PPC64_REL16_HIGHERA34
:
15931 case R_PPC64_REL16_HIGHEST34
:
15932 case R_PPC64_REL16_HIGHESTA34
:
15933 case R_PPC64_REL16DX_HA
:
15934 case R_PPC64_REL14
:
15935 case R_PPC64_REL14_BRNTAKEN
:
15936 case R_PPC64_REL14_BRTAKEN
:
15937 case R_PPC64_REL24
:
15938 case R_PPC64_REL24_NOTOC
:
15939 case R_PPC64_PCREL34
:
15940 case R_PPC64_PCREL28
:
15943 case R_PPC64_TPREL16
:
15944 case R_PPC64_TPREL16_LO
:
15945 case R_PPC64_TPREL16_HI
:
15946 case R_PPC64_TPREL16_HA
:
15947 case R_PPC64_TPREL16_DS
:
15948 case R_PPC64_TPREL16_LO_DS
:
15949 case R_PPC64_TPREL16_HIGH
:
15950 case R_PPC64_TPREL16_HIGHA
:
15951 case R_PPC64_TPREL16_HIGHER
:
15952 case R_PPC64_TPREL16_HIGHERA
:
15953 case R_PPC64_TPREL16_HIGHEST
:
15954 case R_PPC64_TPREL16_HIGHESTA
:
15955 case R_PPC64_TPREL34
:
15957 && h
->elf
.root
.type
== bfd_link_hash_undefweak
15958 && h
->elf
.dynindx
== -1)
15960 /* Make this relocation against an undefined weak symbol
15961 resolve to zero. This is really just a tweak, since
15962 code using weak externs ought to check that they are
15963 defined before using them. */
15964 bfd_byte
*p
= contents
+ rel
->r_offset
- d_offset
;
15966 insn
= bfd_get_32 (input_bfd
, p
);
15967 insn
= _bfd_elf_ppc_at_tprel_transform (insn
, 13);
15969 bfd_put_32 (input_bfd
, insn
, p
);
15972 if (htab
->elf
.tls_sec
!= NULL
)
15973 addend
-= htab
->elf
.tls_sec
->vma
+ TP_OFFSET
;
15974 /* The TPREL16 relocs shouldn't really be used in shared
15975 libs or with non-local symbols as that will result in
15976 DT_TEXTREL being set, but support them anyway. */
15979 case R_PPC64_DTPREL16
:
15980 case R_PPC64_DTPREL16_LO
:
15981 case R_PPC64_DTPREL16_HI
:
15982 case R_PPC64_DTPREL16_HA
:
15983 case R_PPC64_DTPREL16_DS
:
15984 case R_PPC64_DTPREL16_LO_DS
:
15985 case R_PPC64_DTPREL16_HIGH
:
15986 case R_PPC64_DTPREL16_HIGHA
:
15987 case R_PPC64_DTPREL16_HIGHER
:
15988 case R_PPC64_DTPREL16_HIGHERA
:
15989 case R_PPC64_DTPREL16_HIGHEST
:
15990 case R_PPC64_DTPREL16_HIGHESTA
:
15991 case R_PPC64_DTPREL34
:
15992 if (htab
->elf
.tls_sec
!= NULL
)
15993 addend
-= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
15996 case R_PPC64_ADDR64_LOCAL
:
15997 addend
+= PPC64_LOCAL_ENTRY_OFFSET (h
!= NULL
16002 case R_PPC64_DTPMOD64
:
16007 case R_PPC64_TPREL64
:
16008 if (htab
->elf
.tls_sec
!= NULL
)
16009 addend
-= htab
->elf
.tls_sec
->vma
+ TP_OFFSET
;
16012 case R_PPC64_DTPREL64
:
16013 if (htab
->elf
.tls_sec
!= NULL
)
16014 addend
-= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
16015 /* Fall through. */
16017 /* Relocations that may need to be propagated if this is a
16019 case R_PPC64_REL30
:
16020 case R_PPC64_REL32
:
16021 case R_PPC64_REL64
:
16022 case R_PPC64_ADDR14
:
16023 case R_PPC64_ADDR14_BRNTAKEN
:
16024 case R_PPC64_ADDR14_BRTAKEN
:
16025 case R_PPC64_ADDR16
:
16026 case R_PPC64_ADDR16_DS
:
16027 case R_PPC64_ADDR16_HA
:
16028 case R_PPC64_ADDR16_HI
:
16029 case R_PPC64_ADDR16_HIGH
:
16030 case R_PPC64_ADDR16_HIGHA
:
16031 case R_PPC64_ADDR16_HIGHER
:
16032 case R_PPC64_ADDR16_HIGHERA
:
16033 case R_PPC64_ADDR16_HIGHEST
:
16034 case R_PPC64_ADDR16_HIGHESTA
:
16035 case R_PPC64_ADDR16_LO
:
16036 case R_PPC64_ADDR16_LO_DS
:
16037 case R_PPC64_ADDR16_HIGHER34
:
16038 case R_PPC64_ADDR16_HIGHERA34
:
16039 case R_PPC64_ADDR16_HIGHEST34
:
16040 case R_PPC64_ADDR16_HIGHESTA34
:
16041 case R_PPC64_ADDR24
:
16042 case R_PPC64_ADDR32
:
16043 case R_PPC64_ADDR64
:
16044 case R_PPC64_UADDR16
:
16045 case R_PPC64_UADDR32
:
16046 case R_PPC64_UADDR64
:
16048 case R_PPC64_D34_LO
:
16049 case R_PPC64_D34_HI30
:
16050 case R_PPC64_D34_HA30
:
16053 if ((input_section
->flags
& SEC_ALLOC
) == 0)
16056 if (NO_OPD_RELOCS
&& is_opd
)
16059 if (bfd_link_pic (info
)
16061 || h
->dyn_relocs
!= NULL
)
16062 && ((h
!= NULL
&& pc_dynrelocs (h
))
16063 || must_be_dyn_reloc (info
, r_type
)))
16065 ? h
->dyn_relocs
!= NULL
16066 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
))
16068 bfd_boolean skip
, relocate
;
16073 /* When generating a dynamic object, these relocations
16074 are copied into the output file to be resolved at run
16080 out_off
= _bfd_elf_section_offset (output_bfd
, info
,
16081 input_section
, rel
->r_offset
);
16082 if (out_off
== (bfd_vma
) -1)
16084 else if (out_off
== (bfd_vma
) -2)
16085 skip
= TRUE
, relocate
= TRUE
;
16086 out_off
+= (input_section
->output_section
->vma
16087 + input_section
->output_offset
);
16088 outrel
.r_offset
= out_off
;
16089 outrel
.r_addend
= rel
->r_addend
;
16091 /* Optimize unaligned reloc use. */
16092 if ((r_type
== R_PPC64_ADDR64
&& (out_off
& 7) != 0)
16093 || (r_type
== R_PPC64_UADDR64
&& (out_off
& 7) == 0))
16094 r_type
^= R_PPC64_ADDR64
^ R_PPC64_UADDR64
;
16095 else if ((r_type
== R_PPC64_ADDR32
&& (out_off
& 3) != 0)
16096 || (r_type
== R_PPC64_UADDR32
&& (out_off
& 3) == 0))
16097 r_type
^= R_PPC64_ADDR32
^ R_PPC64_UADDR32
;
16098 else if ((r_type
== R_PPC64_ADDR16
&& (out_off
& 1) != 0)
16099 || (r_type
== R_PPC64_UADDR16
&& (out_off
& 1) == 0))
16100 r_type
^= R_PPC64_ADDR16
^ R_PPC64_UADDR16
;
16103 memset (&outrel
, 0, sizeof outrel
);
16104 else if (!SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
)
16106 && r_type
!= R_PPC64_TOC
)
16108 indx
= h
->elf
.dynindx
;
16109 BFD_ASSERT (indx
!= -1);
16110 outrel
.r_info
= ELF64_R_INFO (indx
, r_type
);
16114 /* This symbol is local, or marked to become local,
16115 or this is an opd section reloc which must point
16116 at a local function. */
16117 outrel
.r_addend
+= relocation
;
16118 if (r_type
== R_PPC64_ADDR64
|| r_type
== R_PPC64_TOC
)
16120 if (is_opd
&& h
!= NULL
)
16122 /* Lie about opd entries. This case occurs
16123 when building shared libraries and we
16124 reference a function in another shared
16125 lib. The same thing happens for a weak
16126 definition in an application that's
16127 overridden by a strong definition in a
16128 shared lib. (I believe this is a generic
16129 bug in binutils handling of weak syms.)
16130 In these cases we won't use the opd
16131 entry in this lib. */
16132 unresolved_reloc
= FALSE
;
16135 && r_type
== R_PPC64_ADDR64
16137 ? h
->elf
.type
== STT_GNU_IFUNC
16138 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
))
16139 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
16142 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
16144 /* We need to relocate .opd contents for ld.so.
16145 Prelink also wants simple and consistent rules
16146 for relocs. This make all RELATIVE relocs have
16147 *r_offset equal to r_addend. */
16154 ? h
->elf
.type
== STT_GNU_IFUNC
16155 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
16157 info
->callbacks
->einfo
16158 /* xgettext:c-format */
16159 (_("%H: %s for indirect "
16160 "function `%pT' unsupported\n"),
16161 input_bfd
, input_section
, rel
->r_offset
,
16162 ppc64_elf_howto_table
[r_type
]->name
,
16166 else if (r_symndx
== STN_UNDEF
|| bfd_is_abs_section (sec
))
16168 else if (sec
== NULL
|| sec
->owner
== NULL
)
16170 bfd_set_error (bfd_error_bad_value
);
16175 asection
*osec
= sec
->output_section
;
16177 if ((osec
->flags
& SEC_THREAD_LOCAL
) != 0)
16179 /* TLS symbol values are relative to the
16180 TLS segment. Dynamic relocations for
16181 local TLS symbols therefore can't be
16182 reduced to a relocation against their
16183 section symbol because it holds the
16184 address of the section, not a value
16185 relative to the TLS segment. We could
16186 change the .tdata dynamic section symbol
16187 to be zero value but STN_UNDEF works
16188 and is used elsewhere, eg. for TPREL64
16189 GOT relocs against local TLS symbols. */
16190 osec
= htab
->elf
.tls_sec
;
16195 indx
= elf_section_data (osec
)->dynindx
;
16198 if ((osec
->flags
& SEC_READONLY
) == 0
16199 && htab
->elf
.data_index_section
!= NULL
)
16200 osec
= htab
->elf
.data_index_section
;
16202 osec
= htab
->elf
.text_index_section
;
16203 indx
= elf_section_data (osec
)->dynindx
;
16205 BFD_ASSERT (indx
!= 0);
16208 /* We are turning this relocation into one
16209 against a section symbol, so subtract out
16210 the output section's address but not the
16211 offset of the input section in the output
16213 outrel
.r_addend
-= osec
->vma
;
16216 outrel
.r_info
= ELF64_R_INFO (indx
, r_type
);
16220 sreloc
= elf_section_data (input_section
)->sreloc
;
16222 ? h
->elf
.type
== STT_GNU_IFUNC
16223 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
16225 sreloc
= htab
->elf
.irelplt
;
16227 htab
->local_ifunc_resolver
= 1;
16228 else if (is_static_defined (&h
->elf
))
16229 htab
->maybe_local_ifunc_resolver
= 1;
16231 if (sreloc
== NULL
)
16234 if (sreloc
->reloc_count
* sizeof (Elf64_External_Rela
)
16237 loc
= sreloc
->contents
;
16238 loc
+= sreloc
->reloc_count
++ * sizeof (Elf64_External_Rela
);
16239 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
16241 if (!warned_dynamic
16242 && !ppc64_glibc_dynamic_reloc (ELF64_R_TYPE (outrel
.r_info
)))
16244 info
->callbacks
->einfo
16245 /* xgettext:c-format */
16246 (_("%X%P: %pB: %s against %pT "
16247 "is not supported by glibc as a dynamic relocation\n"),
16249 ppc64_elf_howto_table
[ELF64_R_TYPE (outrel
.r_info
)]->name
,
16251 warned_dynamic
= TRUE
;
16254 /* If this reloc is against an external symbol, it will
16255 be computed at runtime, so there's no need to do
16256 anything now. However, for the sake of prelink ensure
16257 that the section contents are a known value. */
16260 unresolved_reloc
= FALSE
;
16261 /* The value chosen here is quite arbitrary as ld.so
16262 ignores section contents except for the special
16263 case of .opd where the contents might be accessed
16264 before relocation. Choose zero, as that won't
16265 cause reloc overflow. */
16268 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
16269 to improve backward compatibility with older
16271 if (r_type
== R_PPC64_ADDR64
)
16272 addend
= outrel
.r_addend
;
16273 /* Adjust pc_relative relocs to have zero in *r_offset. */
16274 else if (ppc64_elf_howto_table
[r_type
]->pc_relative
)
16275 addend
= outrel
.r_offset
;
16281 case R_PPC64_GLOB_DAT
:
16282 case R_PPC64_JMP_SLOT
:
16283 case R_PPC64_JMP_IREL
:
16284 case R_PPC64_RELATIVE
:
16285 /* We shouldn't ever see these dynamic relocs in relocatable
16287 /* Fall through. */
16289 case R_PPC64_PLTGOT16
:
16290 case R_PPC64_PLTGOT16_DS
:
16291 case R_PPC64_PLTGOT16_HA
:
16292 case R_PPC64_PLTGOT16_HI
:
16293 case R_PPC64_PLTGOT16_LO
:
16294 case R_PPC64_PLTGOT16_LO_DS
:
16295 case R_PPC64_PLTREL32
:
16296 case R_PPC64_PLTREL64
:
16297 /* These ones haven't been implemented yet. */
16299 info
->callbacks
->einfo
16300 /* xgettext:c-format */
16301 (_("%P: %pB: %s is not supported for `%pT'\n"),
16303 ppc64_elf_howto_table
[r_type
]->name
, sym_name
);
16305 bfd_set_error (bfd_error_invalid_operation
);
16310 /* Multi-instruction sequences that access the TOC can be
16311 optimized, eg. addis ra,r2,0; addi rb,ra,x;
16312 to nop; addi rb,r2,x; */
16318 case R_PPC64_GOT_TLSLD16_HI
:
16319 case R_PPC64_GOT_TLSGD16_HI
:
16320 case R_PPC64_GOT_TPREL16_HI
:
16321 case R_PPC64_GOT_DTPREL16_HI
:
16322 case R_PPC64_GOT16_HI
:
16323 case R_PPC64_TOC16_HI
:
16324 /* These relocs would only be useful if building up an
16325 offset to later add to r2, perhaps in an indexed
16326 addressing mode instruction. Don't try to optimize.
16327 Unfortunately, the possibility of someone building up an
16328 offset like this or even with the HA relocs, means that
16329 we need to check the high insn when optimizing the low
16333 case R_PPC64_PLTCALL_NOTOC
:
16334 if (!unresolved_reloc
)
16335 htab
->notoc_plt
= 1;
16336 /* Fall through. */
16337 case R_PPC64_PLTCALL
:
16338 if (unresolved_reloc
)
16340 /* No plt entry. Make this into a direct call. */
16341 bfd_byte
*p
= contents
+ rel
->r_offset
;
16342 insn
= bfd_get_32 (input_bfd
, p
);
16344 bfd_put_32 (input_bfd
, B_DOT
| insn
, p
);
16345 if (r_type
== R_PPC64_PLTCALL
)
16346 bfd_put_32 (input_bfd
, NOP
, p
+ 4);
16347 unresolved_reloc
= save_unresolved_reloc
;
16348 r_type
= R_PPC64_REL24
;
16352 case R_PPC64_PLTSEQ_NOTOC
:
16353 case R_PPC64_PLTSEQ
:
16354 if (unresolved_reloc
)
16356 unresolved_reloc
= FALSE
;
16361 case R_PPC64_PLT_PCREL34_NOTOC
:
16362 if (!unresolved_reloc
)
16363 htab
->notoc_plt
= 1;
16364 /* Fall through. */
16365 case R_PPC64_PLT_PCREL34
:
16366 if (unresolved_reloc
)
16368 bfd_byte
*p
= contents
+ rel
->r_offset
;
16369 bfd_put_32 (input_bfd
, PNOP
>> 32, p
);
16370 bfd_put_32 (input_bfd
, PNOP
, p
+ 4);
16371 unresolved_reloc
= FALSE
;
16376 case R_PPC64_PLT16_HA
:
16377 if (unresolved_reloc
)
16379 unresolved_reloc
= FALSE
;
16382 /* Fall through. */
16383 case R_PPC64_GOT_TLSLD16_HA
:
16384 case R_PPC64_GOT_TLSGD16_HA
:
16385 case R_PPC64_GOT_TPREL16_HA
:
16386 case R_PPC64_GOT_DTPREL16_HA
:
16387 case R_PPC64_GOT16_HA
:
16388 case R_PPC64_TOC16_HA
:
16389 if (htab
->do_toc_opt
&& relocation
+ addend
+ 0x8000 < 0x10000
16390 && !ppc64_elf_tdata (input_bfd
)->unexpected_toc_insn
)
16394 p
= contents
+ (rel
->r_offset
& ~3);
16395 bfd_put_32 (input_bfd
, NOP
, p
);
16400 case R_PPC64_PLT16_LO
:
16401 case R_PPC64_PLT16_LO_DS
:
16402 if (unresolved_reloc
)
16404 unresolved_reloc
= FALSE
;
16407 /* Fall through. */
16408 case R_PPC64_GOT_TLSLD16_LO
:
16409 case R_PPC64_GOT_TLSGD16_LO
:
16410 case R_PPC64_GOT_TPREL16_LO_DS
:
16411 case R_PPC64_GOT_DTPREL16_LO_DS
:
16412 case R_PPC64_GOT16_LO
:
16413 case R_PPC64_GOT16_LO_DS
:
16414 case R_PPC64_TOC16_LO
:
16415 case R_PPC64_TOC16_LO_DS
:
16416 if (htab
->do_toc_opt
&& relocation
+ addend
+ 0x8000 < 0x10000
16417 && !ppc64_elf_tdata (input_bfd
)->unexpected_toc_insn
)
16419 bfd_byte
*p
= contents
+ (rel
->r_offset
& ~3);
16420 insn
= bfd_get_32 (input_bfd
, p
);
16421 if ((insn
& (0x3f << 26)) == 12u << 26 /* addic */)
16423 /* Transform addic to addi when we change reg. */
16424 insn
&= ~((0x3f << 26) | (0x1f << 16));
16425 insn
|= (14u << 26) | (2 << 16);
16429 insn
&= ~(0x1f << 16);
16432 bfd_put_32 (input_bfd
, insn
, p
);
16436 case R_PPC64_TPREL16_HA
:
16437 if (htab
->do_tls_opt
&& relocation
+ addend
+ 0x8000 < 0x10000)
16439 bfd_byte
*p
= contents
+ (rel
->r_offset
& ~3);
16440 insn
= bfd_get_32 (input_bfd
, p
);
16441 if ((insn
& ((0x3f << 26) | 0x1f << 16))
16442 != ((15u << 26) | (13 << 16)) /* addis rt,13,imm */)
16443 /* xgettext:c-format */
16444 info
->callbacks
->minfo
16445 (_("%H: warning: %s unexpected insn %#x.\n"),
16446 input_bfd
, input_section
, rel
->r_offset
,
16447 ppc64_elf_howto_table
[r_type
]->name
, insn
);
16450 bfd_put_32 (input_bfd
, NOP
, p
);
16456 case R_PPC64_TPREL16_LO
:
16457 case R_PPC64_TPREL16_LO_DS
:
16458 if (htab
->do_tls_opt
&& relocation
+ addend
+ 0x8000 < 0x10000)
16460 bfd_byte
*p
= contents
+ (rel
->r_offset
& ~3);
16461 insn
= bfd_get_32 (input_bfd
, p
);
16462 insn
&= ~(0x1f << 16);
16464 bfd_put_32 (input_bfd
, insn
, p
);
16469 /* Do any further special processing. */
16475 case R_PPC64_REL16_HA
:
16476 case R_PPC64_REL16_HIGHA
:
16477 case R_PPC64_REL16_HIGHERA
:
16478 case R_PPC64_REL16_HIGHESTA
:
16479 case R_PPC64_REL16DX_HA
:
16480 case R_PPC64_ADDR16_HA
:
16481 case R_PPC64_ADDR16_HIGHA
:
16482 case R_PPC64_ADDR16_HIGHERA
:
16483 case R_PPC64_ADDR16_HIGHESTA
:
16484 case R_PPC64_TOC16_HA
:
16485 case R_PPC64_SECTOFF_HA
:
16486 case R_PPC64_TPREL16_HA
:
16487 case R_PPC64_TPREL16_HIGHA
:
16488 case R_PPC64_TPREL16_HIGHERA
:
16489 case R_PPC64_TPREL16_HIGHESTA
:
16490 case R_PPC64_DTPREL16_HA
:
16491 case R_PPC64_DTPREL16_HIGHA
:
16492 case R_PPC64_DTPREL16_HIGHERA
:
16493 case R_PPC64_DTPREL16_HIGHESTA
:
16494 /* It's just possible that this symbol is a weak symbol
16495 that's not actually defined anywhere. In that case,
16496 'sec' would be NULL, and we should leave the symbol
16497 alone (it will be set to zero elsewhere in the link). */
16500 /* Fall through. */
16502 case R_PPC64_GOT16_HA
:
16503 case R_PPC64_PLTGOT16_HA
:
16504 case R_PPC64_PLT16_HA
:
16505 case R_PPC64_GOT_TLSGD16_HA
:
16506 case R_PPC64_GOT_TLSLD16_HA
:
16507 case R_PPC64_GOT_TPREL16_HA
:
16508 case R_PPC64_GOT_DTPREL16_HA
:
16509 /* Add 0x10000 if sign bit in 0:15 is set.
16510 Bits 0:15 are not used. */
16514 case R_PPC64_D34_HA30
:
16515 case R_PPC64_ADDR16_HIGHERA34
:
16516 case R_PPC64_ADDR16_HIGHESTA34
:
16517 case R_PPC64_REL16_HIGHERA34
:
16518 case R_PPC64_REL16_HIGHESTA34
:
16520 addend
+= 1ULL << 33;
16523 case R_PPC64_ADDR16_DS
:
16524 case R_PPC64_ADDR16_LO_DS
:
16525 case R_PPC64_GOT16_DS
:
16526 case R_PPC64_GOT16_LO_DS
:
16527 case R_PPC64_PLT16_LO_DS
:
16528 case R_PPC64_SECTOFF_DS
:
16529 case R_PPC64_SECTOFF_LO_DS
:
16530 case R_PPC64_TOC16_DS
:
16531 case R_PPC64_TOC16_LO_DS
:
16532 case R_PPC64_PLTGOT16_DS
:
16533 case R_PPC64_PLTGOT16_LO_DS
:
16534 case R_PPC64_GOT_TPREL16_DS
:
16535 case R_PPC64_GOT_TPREL16_LO_DS
:
16536 case R_PPC64_GOT_DTPREL16_DS
:
16537 case R_PPC64_GOT_DTPREL16_LO_DS
:
16538 case R_PPC64_TPREL16_DS
:
16539 case R_PPC64_TPREL16_LO_DS
:
16540 case R_PPC64_DTPREL16_DS
:
16541 case R_PPC64_DTPREL16_LO_DS
:
16542 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
16544 /* If this reloc is against an lq, lxv, or stxv insn, then
16545 the value must be a multiple of 16. This is somewhat of
16546 a hack, but the "correct" way to do this by defining _DQ
16547 forms of all the _DS relocs bloats all reloc switches in
16548 this file. It doesn't make much sense to use these
16549 relocs in data, so testing the insn should be safe. */
16550 if ((insn
& (0x3f << 26)) == (56u << 26)
16551 || ((insn
& (0x3f << 26)) == (61u << 26) && (insn
& 3) == 1))
16553 relocation
+= addend
;
16554 addend
= insn
& (mask
^ 3);
16555 if ((relocation
& mask
) != 0)
16557 relocation
^= relocation
& mask
;
16558 info
->callbacks
->einfo
16559 /* xgettext:c-format */
16560 (_("%H: error: %s not a multiple of %u\n"),
16561 input_bfd
, input_section
, rel
->r_offset
,
16562 ppc64_elf_howto_table
[r_type
]->name
,
16564 bfd_set_error (bfd_error_bad_value
);
16571 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
16572 because such sections are not SEC_ALLOC and thus ld.so will
16573 not process them. */
16574 howto
= ppc64_elf_howto_table
[(int) r_type
];
16575 if (unresolved_reloc
16576 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
16577 && h
->elf
.def_dynamic
)
16578 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
16579 rel
->r_offset
) != (bfd_vma
) -1)
16581 info
->callbacks
->einfo
16582 /* xgettext:c-format */
16583 (_("%H: unresolvable %s against `%pT'\n"),
16584 input_bfd
, input_section
, rel
->r_offset
,
16586 h
->elf
.root
.root
.string
);
16590 /* 16-bit fields in insns mostly have signed values, but a
16591 few insns have 16-bit unsigned values. Really, we should
16592 have different reloc types. */
16593 if (howto
->complain_on_overflow
!= complain_overflow_dont
16594 && howto
->dst_mask
== 0xffff
16595 && (input_section
->flags
& SEC_CODE
) != 0)
16597 enum complain_overflow complain
= complain_overflow_signed
;
16599 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
16600 if ((insn
& (0x3f << 26)) == 10u << 26 /* cmpli */)
16601 complain
= complain_overflow_bitfield
;
16602 else if (howto
->rightshift
== 0
16603 ? ((insn
& (0x3f << 26)) == 28u << 26 /* andi */
16604 || (insn
& (0x3f << 26)) == 24u << 26 /* ori */
16605 || (insn
& (0x3f << 26)) == 26u << 26 /* xori */)
16606 : ((insn
& (0x3f << 26)) == 29u << 26 /* andis */
16607 || (insn
& (0x3f << 26)) == 25u << 26 /* oris */
16608 || (insn
& (0x3f << 26)) == 27u << 26 /* xoris */))
16609 complain
= complain_overflow_unsigned
;
16610 if (howto
->complain_on_overflow
!= complain
)
16612 alt_howto
= *howto
;
16613 alt_howto
.complain_on_overflow
= complain
;
16614 howto
= &alt_howto
;
16620 /* Split field relocs aren't handled by _bfd_final_link_relocate. */
16622 case R_PPC64_D34_LO
:
16623 case R_PPC64_D34_HI30
:
16624 case R_PPC64_D34_HA30
:
16625 case R_PPC64_PCREL34
:
16626 case R_PPC64_GOT_PCREL34
:
16627 case R_PPC64_TPREL34
:
16628 case R_PPC64_DTPREL34
:
16629 case R_PPC64_GOT_TLSGD34
:
16630 case R_PPC64_GOT_TLSLD34
:
16631 case R_PPC64_GOT_TPREL34
:
16632 case R_PPC64_GOT_DTPREL34
:
16633 case R_PPC64_PLT_PCREL34
:
16634 case R_PPC64_PLT_PCREL34_NOTOC
:
16636 case R_PPC64_PCREL28
:
16637 if (rel
->r_offset
+ 8 > input_section
->size
)
16638 r
= bfd_reloc_outofrange
;
16641 relocation
+= addend
;
16642 if (howto
->pc_relative
)
16643 relocation
-= (rel
->r_offset
16644 + input_section
->output_offset
16645 + input_section
->output_section
->vma
);
16646 relocation
>>= howto
->rightshift
;
16648 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
16650 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
16652 pinsn
&= ~howto
->dst_mask
;
16653 pinsn
|= (((relocation
<< 16) | (relocation
& 0xffff))
16654 & howto
->dst_mask
);
16655 bfd_put_32 (input_bfd
, pinsn
>> 32, contents
+ rel
->r_offset
);
16656 bfd_put_32 (input_bfd
, pinsn
, contents
+ rel
->r_offset
+ 4);
16658 if (howto
->complain_on_overflow
== complain_overflow_signed
16659 && (relocation
+ (1ULL << (howto
->bitsize
- 1))
16660 >= 1ULL << howto
->bitsize
))
16661 r
= bfd_reloc_overflow
;
16665 case R_PPC64_REL16DX_HA
:
16666 if (rel
->r_offset
+ 4 > input_section
->size
)
16667 r
= bfd_reloc_outofrange
;
16670 relocation
+= addend
;
16671 relocation
-= (rel
->r_offset
16672 + input_section
->output_offset
16673 + input_section
->output_section
->vma
);
16674 relocation
= (bfd_signed_vma
) relocation
>> 16;
16675 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
16677 insn
|= (relocation
& 0xffc1) | ((relocation
& 0x3e) << 15);
16678 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
16680 if (relocation
+ 0x8000 > 0xffff)
16681 r
= bfd_reloc_overflow
;
16686 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
16687 contents
, rel
->r_offset
,
16688 relocation
, addend
);
16691 if (r
!= bfd_reloc_ok
)
16693 char *more_info
= NULL
;
16694 const char *reloc_name
= howto
->name
;
16696 if (reloc_dest
!= DEST_NORMAL
)
16698 more_info
= bfd_malloc (strlen (reloc_name
) + 8);
16699 if (more_info
!= NULL
)
16701 strcpy (more_info
, reloc_name
);
16702 strcat (more_info
, (reloc_dest
== DEST_OPD
16703 ? " (OPD)" : " (stub)"));
16704 reloc_name
= more_info
;
16708 if (r
== bfd_reloc_overflow
)
16710 /* On code like "if (foo) foo();" don't report overflow
16711 on a branch to zero when foo is undefined. */
16713 && (reloc_dest
== DEST_STUB
16715 && (h
->elf
.root
.type
== bfd_link_hash_undefweak
16716 || h
->elf
.root
.type
== bfd_link_hash_undefined
)
16717 && is_branch_reloc (r_type
))))
16718 info
->callbacks
->reloc_overflow (info
, &h
->elf
.root
,
16719 sym_name
, reloc_name
,
16721 input_bfd
, input_section
,
16726 info
->callbacks
->einfo
16727 /* xgettext:c-format */
16728 (_("%H: %s against `%pT': error %d\n"),
16729 input_bfd
, input_section
, rel
->r_offset
,
16730 reloc_name
, sym_name
, (int) r
);
16733 if (more_info
!= NULL
)
16743 Elf_Internal_Shdr
*rel_hdr
;
16744 size_t deleted
= rel
- wrel
;
16746 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
16747 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
16748 if (rel_hdr
->sh_size
== 0)
16750 /* It is too late to remove an empty reloc section. Leave
16752 ??? What is wrong with an empty section??? */
16753 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
16756 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
16757 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
16758 input_section
->reloc_count
-= deleted
;
16761 /* If we're emitting relocations, then shortly after this function
16762 returns, reloc offsets and addends for this section will be
16763 adjusted. Worse, reloc symbol indices will be for the output
16764 file rather than the input. Save a copy of the relocs for
16765 opd_entry_value. */
16766 if (is_opd
&& (info
->emitrelocations
|| bfd_link_relocatable (info
)))
16769 amt
= input_section
->reloc_count
* sizeof (Elf_Internal_Rela
);
16770 rel
= bfd_alloc (input_bfd
, amt
);
16771 BFD_ASSERT (ppc64_elf_tdata (input_bfd
)->opd
.relocs
== NULL
);
16772 ppc64_elf_tdata (input_bfd
)->opd
.relocs
= rel
;
16775 memcpy (rel
, relocs
, amt
);
16780 /* Adjust the value of any local symbols in opd sections. */
16783 ppc64_elf_output_symbol_hook (struct bfd_link_info
*info
,
16784 const char *name ATTRIBUTE_UNUSED
,
16785 Elf_Internal_Sym
*elfsym
,
16786 asection
*input_sec
,
16787 struct elf_link_hash_entry
*h
)
16789 struct _opd_sec_data
*opd
;
16796 opd
= get_opd_info (input_sec
);
16797 if (opd
== NULL
|| opd
->adjust
== NULL
)
16800 value
= elfsym
->st_value
- input_sec
->output_offset
;
16801 if (!bfd_link_relocatable (info
))
16802 value
-= input_sec
->output_section
->vma
;
16804 adjust
= opd
->adjust
[OPD_NDX (value
)];
16808 elfsym
->st_value
+= adjust
;
16812 /* Finish up dynamic symbol handling. We set the contents of various
16813 dynamic sections here. */
16816 ppc64_elf_finish_dynamic_symbol (bfd
*output_bfd
,
16817 struct bfd_link_info
*info
,
16818 struct elf_link_hash_entry
*h
,
16819 Elf_Internal_Sym
*sym
)
16821 struct ppc_link_hash_table
*htab
;
16822 struct plt_entry
*ent
;
16824 htab
= ppc_hash_table (info
);
16828 if (!htab
->opd_abi
&& !h
->def_regular
)
16829 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
16830 if (ent
->plt
.offset
!= (bfd_vma
) -1)
16832 /* Mark the symbol as undefined, rather than as
16833 defined in glink. Leave the value if there were
16834 any relocations where pointer equality matters
16835 (this is a clue for the dynamic linker, to make
16836 function pointer comparisons work between an
16837 application and shared library), otherwise set it
16839 sym
->st_shndx
= SHN_UNDEF
;
16840 if (!h
->pointer_equality_needed
)
16842 else if (!h
->ref_regular_nonweak
)
16844 /* This breaks function pointer comparisons, but
16845 that is better than breaking tests for a NULL
16846 function pointer. */
16853 && (h
->root
.type
== bfd_link_hash_defined
16854 || h
->root
.type
== bfd_link_hash_defweak
)
16855 && (h
->root
.u
.def
.section
== htab
->elf
.sdynbss
16856 || h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
))
16858 /* This symbol needs a copy reloc. Set it up. */
16859 Elf_Internal_Rela rela
;
16863 if (h
->dynindx
== -1)
16866 rela
.r_offset
= (h
->root
.u
.def
.value
16867 + h
->root
.u
.def
.section
->output_section
->vma
16868 + h
->root
.u
.def
.section
->output_offset
);
16869 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_PPC64_COPY
);
16871 if (h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
16872 srel
= htab
->elf
.sreldynrelro
;
16874 srel
= htab
->elf
.srelbss
;
16875 loc
= srel
->contents
;
16876 loc
+= srel
->reloc_count
++ * sizeof (Elf64_External_Rela
);
16877 bfd_elf64_swap_reloca_out (output_bfd
, &rela
, loc
);
16883 /* Used to decide how to sort relocs in an optimal manner for the
16884 dynamic linker, before writing them out. */
16886 static enum elf_reloc_type_class
16887 ppc64_elf_reloc_type_class (const struct bfd_link_info
*info
,
16888 const asection
*rel_sec
,
16889 const Elf_Internal_Rela
*rela
)
16891 enum elf_ppc64_reloc_type r_type
;
16892 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
16894 if (rel_sec
== htab
->elf
.irelplt
)
16895 return reloc_class_ifunc
;
16897 r_type
= ELF64_R_TYPE (rela
->r_info
);
16900 case R_PPC64_RELATIVE
:
16901 return reloc_class_relative
;
16902 case R_PPC64_JMP_SLOT
:
16903 return reloc_class_plt
;
16905 return reloc_class_copy
;
16907 return reloc_class_normal
;
16911 /* Finish up the dynamic sections. */
16914 ppc64_elf_finish_dynamic_sections (bfd
*output_bfd
,
16915 struct bfd_link_info
*info
)
16917 struct ppc_link_hash_table
*htab
;
16921 htab
= ppc_hash_table (info
);
16925 dynobj
= htab
->elf
.dynobj
;
16926 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
16928 if (htab
->elf
.dynamic_sections_created
)
16930 Elf64_External_Dyn
*dyncon
, *dynconend
;
16932 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
16935 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
16936 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
16937 for (; dyncon
< dynconend
; dyncon
++)
16939 Elf_Internal_Dyn dyn
;
16942 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
16949 case DT_PPC64_GLINK
:
16951 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
16952 /* We stupidly defined DT_PPC64_GLINK to be the start
16953 of glink rather than the first entry point, which is
16954 what ld.so needs, and now have a bigger stub to
16955 support automatic multiple TOCs. */
16956 dyn
.d_un
.d_ptr
+= GLINK_PLTRESOLVE_SIZE (htab
) - 8 * 4;
16960 s
= bfd_get_section_by_name (output_bfd
, ".opd");
16963 dyn
.d_un
.d_ptr
= s
->vma
;
16967 if ((htab
->do_multi_toc
&& htab
->multi_toc_needed
)
16968 || htab
->notoc_plt
)
16969 dyn
.d_un
.d_val
|= PPC64_OPT_MULTI_TOC
;
16970 if (htab
->has_plt_localentry0
)
16971 dyn
.d_un
.d_val
|= PPC64_OPT_LOCALENTRY
;
16974 case DT_PPC64_OPDSZ
:
16975 s
= bfd_get_section_by_name (output_bfd
, ".opd");
16978 dyn
.d_un
.d_val
= s
->size
;
16982 s
= htab
->elf
.splt
;
16983 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
16987 s
= htab
->elf
.srelplt
;
16988 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
16992 dyn
.d_un
.d_val
= htab
->elf
.srelplt
->size
;
16996 if (htab
->local_ifunc_resolver
)
16997 info
->callbacks
->einfo
16998 (_("%X%P: text relocations and GNU indirect "
16999 "functions will result in a segfault at runtime\n"));
17000 else if (htab
->maybe_local_ifunc_resolver
)
17001 info
->callbacks
->einfo
17002 (_("%P: warning: text relocations and GNU indirect "
17003 "functions may result in a segfault at runtime\n"));
17007 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
17011 if (htab
->elf
.sgot
!= NULL
&& htab
->elf
.sgot
->size
!= 0
17012 && htab
->elf
.sgot
->output_section
!= bfd_abs_section_ptr
)
17014 /* Fill in the first entry in the global offset table.
17015 We use it to hold the link-time TOCbase. */
17016 bfd_put_64 (output_bfd
,
17017 elf_gp (output_bfd
) + TOC_BASE_OFF
,
17018 htab
->elf
.sgot
->contents
);
17020 /* Set .got entry size. */
17021 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
17025 if (htab
->elf
.splt
!= NULL
&& htab
->elf
.splt
->size
!= 0
17026 && htab
->elf
.splt
->output_section
!= bfd_abs_section_ptr
)
17028 /* Set .plt entry size. */
17029 elf_section_data (htab
->elf
.splt
->output_section
)->this_hdr
.sh_entsize
17030 = PLT_ENTRY_SIZE (htab
);
17033 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
17034 brlt ourselves if emitrelocations. */
17035 if (htab
->brlt
!= NULL
17036 && htab
->brlt
->reloc_count
!= 0
17037 && !_bfd_elf_link_output_relocs (output_bfd
,
17039 elf_section_data (htab
->brlt
)->rela
.hdr
,
17040 elf_section_data (htab
->brlt
)->relocs
,
17044 if (htab
->glink
!= NULL
17045 && htab
->glink
->reloc_count
!= 0
17046 && !_bfd_elf_link_output_relocs (output_bfd
,
17048 elf_section_data (htab
->glink
)->rela
.hdr
,
17049 elf_section_data (htab
->glink
)->relocs
,
17054 if (htab
->glink_eh_frame
!= NULL
17055 && htab
->glink_eh_frame
->size
!= 0
17056 && htab
->glink_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
17057 && !_bfd_elf_write_section_eh_frame (output_bfd
, info
,
17058 htab
->glink_eh_frame
,
17059 htab
->glink_eh_frame
->contents
))
17062 /* We need to handle writing out multiple GOT sections ourselves,
17063 since we didn't add them to DYNOBJ. We know dynobj is the first
17065 while ((dynobj
= dynobj
->link
.next
) != NULL
)
17069 if (!is_ppc64_elf (dynobj
))
17072 s
= ppc64_elf_tdata (dynobj
)->got
;
17075 && s
->output_section
!= bfd_abs_section_ptr
17076 && !bfd_set_section_contents (output_bfd
, s
->output_section
,
17077 s
->contents
, s
->output_offset
,
17080 s
= ppc64_elf_tdata (dynobj
)->relgot
;
17083 && s
->output_section
!= bfd_abs_section_ptr
17084 && !bfd_set_section_contents (output_bfd
, s
->output_section
,
17085 s
->contents
, s
->output_offset
,
17093 #include "elf64-target.h"
17095 /* FreeBSD support */
17097 #undef TARGET_LITTLE_SYM
17098 #undef TARGET_LITTLE_NAME
17100 #undef TARGET_BIG_SYM
17101 #define TARGET_BIG_SYM powerpc_elf64_fbsd_vec
17102 #undef TARGET_BIG_NAME
17103 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
17106 #define ELF_OSABI ELFOSABI_FREEBSD
17109 #define elf64_bed elf64_powerpc_fbsd_bed
17111 #include "elf64-target.h"