1 /* PowerPC64-specific support for 64-bit ELF.
2 Copyright (C) 1999-2020 Free Software Foundation, Inc.
3 Written by Linus Nordberg, Swox AB <info@swox.com>,
4 based on elf32-ppc.c by Ian Lance Taylor.
5 Largely rewritten by Alan Modra.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License along
20 with this program; if not, write to the Free Software Foundation, Inc.,
21 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
24 /* The 64-bit PowerPC ELF ABI may be found at
25 http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
26 http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html */
34 #include "elf/ppc64.h"
35 #include "elf64-ppc.h"
38 /* All users of this file have bfd_octets_per_byte (abfd, sec) == 1. */
39 #define OCTETS_PER_BYTE(ABFD, SEC) 1
41 static bfd_reloc_status_type ppc64_elf_ha_reloc
42 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
43 static bfd_reloc_status_type ppc64_elf_branch_reloc
44 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
45 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
46 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
47 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
48 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
49 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
50 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
51 static bfd_reloc_status_type ppc64_elf_toc_reloc
52 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
53 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
54 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
55 static bfd_reloc_status_type ppc64_elf_toc64_reloc
56 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
57 static bfd_reloc_status_type ppc64_elf_prefix_reloc
58 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
59 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
60 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
61 static bfd_vma opd_entry_value
62 (asection
*, bfd_vma
, asection
**, bfd_vma
*, bfd_boolean
);
64 #define TARGET_LITTLE_SYM powerpc_elf64_le_vec
65 #define TARGET_LITTLE_NAME "elf64-powerpcle"
66 #define TARGET_BIG_SYM powerpc_elf64_vec
67 #define TARGET_BIG_NAME "elf64-powerpc"
68 #define ELF_ARCH bfd_arch_powerpc
69 #define ELF_TARGET_ID PPC64_ELF_DATA
70 #define ELF_MACHINE_CODE EM_PPC64
71 #define ELF_MAXPAGESIZE 0x10000
72 #define ELF_COMMONPAGESIZE 0x1000
73 #define ELF_RELROPAGESIZE ELF_MAXPAGESIZE
74 #define elf_info_to_howto ppc64_elf_info_to_howto
76 #define elf_backend_want_got_sym 0
77 #define elf_backend_want_plt_sym 0
78 #define elf_backend_plt_alignment 3
79 #define elf_backend_plt_not_loaded 1
80 #define elf_backend_got_header_size 8
81 #define elf_backend_want_dynrelro 1
82 #define elf_backend_can_gc_sections 1
83 #define elf_backend_can_refcount 1
84 #define elf_backend_rela_normal 1
85 #define elf_backend_dtrel_excludes_plt 1
86 #define elf_backend_default_execstack 0
88 #define bfd_elf64_mkobject ppc64_elf_mkobject
89 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
90 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
91 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
92 #define bfd_elf64_bfd_print_private_bfd_data ppc64_elf_print_private_bfd_data
93 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
94 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
95 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
96 #define bfd_elf64_bfd_link_just_syms ppc64_elf_link_just_syms
97 #define bfd_elf64_bfd_gc_sections ppc64_elf_gc_sections
99 #define elf_backend_object_p ppc64_elf_object_p
100 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
101 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
102 #define elf_backend_write_core_note ppc64_elf_write_core_note
103 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
104 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
105 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
106 #define elf_backend_check_directives ppc64_elf_before_check_relocs
107 #define elf_backend_notice_as_needed ppc64_elf_notice_as_needed
108 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
109 #define elf_backend_check_relocs ppc64_elf_check_relocs
110 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
111 #define elf_backend_gc_keep ppc64_elf_gc_keep
112 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
113 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
114 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
115 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
116 #define elf_backend_maybe_function_sym ppc64_elf_maybe_function_sym
117 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
118 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
119 #define elf_backend_hash_symbol ppc64_elf_hash_symbol
120 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
121 #define elf_backend_action_discarded ppc64_elf_action_discarded
122 #define elf_backend_relocate_section ppc64_elf_relocate_section
123 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
124 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
125 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
126 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
127 #define elf_backend_special_sections ppc64_elf_special_sections
128 #define elf_backend_merge_symbol_attribute ppc64_elf_merge_symbol_attribute
129 #define elf_backend_merge_symbol ppc64_elf_merge_symbol
130 #define elf_backend_get_reloc_section bfd_get_section_by_name
132 /* The name of the dynamic interpreter. This is put in the .interp
134 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
136 /* The size in bytes of an entry in the procedure linkage table. */
137 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
138 #define LOCAL_PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 16 : 8)
140 /* The initial size of the plt reserved for the dynamic linker. */
141 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
143 /* Offsets to some stack save slots. */
145 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
146 /* This one is dodgy. ELFv2 does not have a linker word, so use the
147 CR save slot. Used only by optimised __tls_get_addr call stub,
148 relying on __tls_get_addr_opt not saving CR.. */
149 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
151 /* TOC base pointers offset from start of TOC. */
152 #define TOC_BASE_OFF 0x8000
153 /* TOC base alignment. */
154 #define TOC_BASE_ALIGN 256
156 /* Offset of tp and dtp pointers from start of TLS block. */
157 #define TP_OFFSET 0x7000
158 #define DTP_OFFSET 0x8000
160 /* .plt call stub instructions. The normal stub is like this, but
161 sometimes the .plt entry crosses a 64k boundary and we need to
162 insert an addi to adjust r11. */
163 #define STD_R2_0R1 0xf8410000 /* std %r2,0+40(%r1) */
164 #define ADDIS_R11_R2 0x3d620000 /* addis %r11,%r2,xxx@ha */
165 #define LD_R12_0R11 0xe98b0000 /* ld %r12,xxx+0@l(%r11) */
166 #define MTCTR_R12 0x7d8903a6 /* mtctr %r12 */
167 #define LD_R2_0R11 0xe84b0000 /* ld %r2,xxx+8@l(%r11) */
168 #define LD_R11_0R11 0xe96b0000 /* ld %r11,xxx+16@l(%r11) */
169 #define BCTR 0x4e800420 /* bctr */
171 #define ADDI_R11_R11 0x396b0000 /* addi %r11,%r11,off@l */
172 #define ADDI_R12_R11 0x398b0000 /* addi %r12,%r11,off@l */
173 #define ADDI_R12_R12 0x398c0000 /* addi %r12,%r12,off@l */
174 #define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
175 #define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
177 #define XOR_R2_R12_R12 0x7d826278 /* xor %r2,%r12,%r12 */
178 #define ADD_R11_R11_R2 0x7d6b1214 /* add %r11,%r11,%r2 */
179 #define XOR_R11_R12_R12 0x7d8b6278 /* xor %r11,%r12,%r12 */
180 #define ADD_R2_R2_R11 0x7c425a14 /* add %r2,%r2,%r11 */
181 #define CMPLDI_R2_0 0x28220000 /* cmpldi %r2,0 */
182 #define BNECTR 0x4ca20420 /* bnectr+ */
183 #define BNECTR_P4 0x4ce20420 /* bnectr+ */
185 #define LD_R12_0R2 0xe9820000 /* ld %r12,xxx+0(%r2) */
186 #define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
187 #define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
189 #define LD_R2_0R1 0xe8410000 /* ld %r2,0(%r1) */
190 #define LD_R2_0R12 0xe84c0000 /* ld %r2,0(%r12) */
191 #define ADD_R2_R2_R12 0x7c426214 /* add %r2,%r2,%r12 */
193 #define LI_R11_0 0x39600000 /* li %r11,0 */
194 #define LIS_R2 0x3c400000 /* lis %r2,xxx@ha */
195 #define LIS_R11 0x3d600000 /* lis %r11,xxx@ha */
196 #define LIS_R12 0x3d800000 /* lis %r12,xxx@ha */
197 #define ADDIS_R2_R12 0x3c4c0000 /* addis %r2,%r12,xxx@ha */
198 #define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
199 #define ADDIS_R12_R11 0x3d8b0000 /* addis %r12,%r11,xxx@ha */
200 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,xxx@ha */
201 #define ORIS_R12_R12_0 0x658c0000 /* oris %r12,%r12,xxx@hi */
202 #define ORI_R11_R11_0 0x616b0000 /* ori %r11,%r11,xxx@l */
203 #define ORI_R12_R12_0 0x618c0000 /* ori %r12,%r12,xxx@l */
204 #define LD_R12_0R12 0xe98c0000 /* ld %r12,xxx@l(%r12) */
205 #define SLDI_R11_R11_34 0x796b1746 /* sldi %r11,%r11,34 */
206 #define SLDI_R12_R12_32 0x799c07c6 /* sldi %r12,%r12,32 */
207 #define LDX_R12_R11_R12 0x7d8b602a /* ldx %r12,%r11,%r12 */
208 #define ADD_R12_R11_R12 0x7d8b6214 /* add %r12,%r11,%r12 */
209 #define PADDI_R12_PC 0x0610000039800000ULL
210 #define PLD_R12_PC 0x04100000e5800000ULL
211 #define PNOP 0x0700000000000000ULL
213 /* __glink_PLTresolve stub instructions. We enter with the index in R0. */
214 #define GLINK_PLTRESOLVE_SIZE(htab) \
215 (8u + (htab->opd_abi ? 11 * 4 : 14 * 4))
219 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
220 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
222 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
223 /* ld %2,(0b-1b)(%11) */
224 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
225 #define ADD_R11_R2_R11 0x7d625a14 /* add %11,%2,%11 */
231 #define MFLR_R0 0x7c0802a6 /* mflr %r0 */
232 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
233 #define SUB_R12_R12_R11 0x7d8b6050 /* subf %r12,%r11,%r12 */
234 #define ADDI_R0_R12 0x380c0000 /* addi %r0,%r12,0 */
235 #define SRDI_R0_R0_2 0x7800f082 /* rldicl %r0,%r0,62,2 */
238 #define NOP 0x60000000
240 /* Some other nops. */
241 #define CROR_151515 0x4def7b82
242 #define CROR_313131 0x4ffffb82
244 /* .glink entries for the first 32k functions are two instructions. */
245 #define LI_R0_0 0x38000000 /* li %r0,0 */
246 #define B_DOT 0x48000000 /* b . */
248 /* After that, we need two instructions to load the index, followed by
250 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
251 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
253 /* Instructions used by the save and restore reg functions. */
254 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
255 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
256 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
257 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
258 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
259 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
260 #define LI_R12_0 0x39800000 /* li %r12,0 */
261 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
262 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
263 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
264 #define BLR 0x4e800020 /* blr */
266 /* Since .opd is an array of descriptors and each entry will end up
267 with identical R_PPC64_RELATIVE relocs, there is really no need to
268 propagate .opd relocs; The dynamic linker should be taught to
269 relocate .opd without reloc entries. */
270 #ifndef NO_OPD_RELOCS
271 #define NO_OPD_RELOCS 0
275 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
279 abiversion (bfd
*abfd
)
281 return elf_elfheader (abfd
)->e_flags
& EF_PPC64_ABI
;
285 set_abiversion (bfd
*abfd
, int ver
)
287 elf_elfheader (abfd
)->e_flags
&= ~EF_PPC64_ABI
;
288 elf_elfheader (abfd
)->e_flags
|= ver
& EF_PPC64_ABI
;
291 /* Relocation HOWTO's. */
292 /* Like other ELF RELA targets that don't apply multiple
293 field-altering relocations to the same localation, src_mask is
294 always zero and pcrel_offset is the same as pc_relative.
295 PowerPC can always use a zero bitpos, even when the field is not at
296 the LSB. For example, a REL24 could use rightshift=2, bisize=24
297 and bitpos=2 which matches the ABI description, or as we do here,
298 rightshift=0, bitsize=26 and bitpos=0. */
299 #define HOW(type, size, bitsize, mask, rightshift, pc_relative, \
300 complain, special_func) \
301 HOWTO (type, rightshift, size, bitsize, pc_relative, 0, \
302 complain_overflow_ ## complain, special_func, \
303 #type, FALSE, 0, mask, pc_relative)
305 static reloc_howto_type
*ppc64_elf_howto_table
[(int) R_PPC64_max
];
307 static reloc_howto_type ppc64_elf_howto_raw
[] =
309 /* This reloc does nothing. */
310 HOW (R_PPC64_NONE
, 3, 0, 0, 0, FALSE
, dont
,
311 bfd_elf_generic_reloc
),
313 /* A standard 32 bit relocation. */
314 HOW (R_PPC64_ADDR32
, 2, 32, 0xffffffff, 0, FALSE
, bitfield
,
315 bfd_elf_generic_reloc
),
317 /* An absolute 26 bit branch; the lower two bits must be zero.
318 FIXME: we don't check that, we just clear them. */
319 HOW (R_PPC64_ADDR24
, 2, 26, 0x03fffffc, 0, FALSE
, bitfield
,
320 bfd_elf_generic_reloc
),
322 /* A standard 16 bit relocation. */
323 HOW (R_PPC64_ADDR16
, 1, 16, 0xffff, 0, FALSE
, bitfield
,
324 bfd_elf_generic_reloc
),
326 /* A 16 bit relocation without overflow. */
327 HOW (R_PPC64_ADDR16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
328 bfd_elf_generic_reloc
),
330 /* Bits 16-31 of an address. */
331 HOW (R_PPC64_ADDR16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
332 bfd_elf_generic_reloc
),
334 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
335 bits, treated as a signed number, is negative. */
336 HOW (R_PPC64_ADDR16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
339 /* An absolute 16 bit branch; the lower two bits must be zero.
340 FIXME: we don't check that, we just clear them. */
341 HOW (R_PPC64_ADDR14
, 2, 16, 0x0000fffc, 0, FALSE
, signed,
342 ppc64_elf_branch_reloc
),
344 /* An absolute 16 bit branch, for which bit 10 should be set to
345 indicate that the branch is expected to be taken. The lower two
346 bits must be zero. */
347 HOW (R_PPC64_ADDR14_BRTAKEN
, 2, 16, 0x0000fffc, 0, FALSE
, signed,
348 ppc64_elf_brtaken_reloc
),
350 /* An absolute 16 bit branch, for which bit 10 should be set to
351 indicate that the branch is not expected to be taken. The lower
352 two bits must be zero. */
353 HOW (R_PPC64_ADDR14_BRNTAKEN
, 2, 16, 0x0000fffc, 0, FALSE
, signed,
354 ppc64_elf_brtaken_reloc
),
356 /* A relative 26 bit branch; the lower two bits must be zero. */
357 HOW (R_PPC64_REL24
, 2, 26, 0x03fffffc, 0, TRUE
, signed,
358 ppc64_elf_branch_reloc
),
360 /* A variant of R_PPC64_REL24, used when r2 is not the toc pointer. */
361 HOW (R_PPC64_REL24_NOTOC
, 2, 26, 0x03fffffc, 0, TRUE
, signed,
362 ppc64_elf_branch_reloc
),
364 /* A relative 16 bit branch; the lower two bits must be zero. */
365 HOW (R_PPC64_REL14
, 2, 16, 0x0000fffc, 0, TRUE
, signed,
366 ppc64_elf_branch_reloc
),
368 /* A relative 16 bit branch. Bit 10 should be set to indicate that
369 the branch is expected to be taken. The lower two bits must be
371 HOW (R_PPC64_REL14_BRTAKEN
, 2, 16, 0x0000fffc, 0, TRUE
, signed,
372 ppc64_elf_brtaken_reloc
),
374 /* A relative 16 bit branch. Bit 10 should be set to indicate that
375 the branch is not expected to be taken. The lower two bits must
377 HOW (R_PPC64_REL14_BRNTAKEN
, 2, 16, 0x0000fffc, 0, TRUE
, signed,
378 ppc64_elf_brtaken_reloc
),
380 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
382 HOW (R_PPC64_GOT16
, 1, 16, 0xffff, 0, FALSE
, signed,
383 ppc64_elf_unhandled_reloc
),
385 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
387 HOW (R_PPC64_GOT16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
388 ppc64_elf_unhandled_reloc
),
390 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
392 HOW (R_PPC64_GOT16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
393 ppc64_elf_unhandled_reloc
),
395 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
397 HOW (R_PPC64_GOT16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
398 ppc64_elf_unhandled_reloc
),
400 /* This is used only by the dynamic linker. The symbol should exist
401 both in the object being run and in some shared library. The
402 dynamic linker copies the data addressed by the symbol from the
403 shared library into the object, because the object being
404 run has to have the data at some particular address. */
405 HOW (R_PPC64_COPY
, 0, 0, 0, 0, FALSE
, dont
,
406 ppc64_elf_unhandled_reloc
),
408 /* Like R_PPC64_ADDR64, but used when setting global offset table
410 HOW (R_PPC64_GLOB_DAT
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
411 ppc64_elf_unhandled_reloc
),
413 /* Created by the link editor. Marks a procedure linkage table
414 entry for a symbol. */
415 HOW (R_PPC64_JMP_SLOT
, 0, 0, 0, 0, FALSE
, dont
,
416 ppc64_elf_unhandled_reloc
),
418 /* Used only by the dynamic linker. When the object is run, this
419 doubleword64 is set to the load address of the object, plus the
421 HOW (R_PPC64_RELATIVE
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
422 bfd_elf_generic_reloc
),
424 /* Like R_PPC64_ADDR32, but may be unaligned. */
425 HOW (R_PPC64_UADDR32
, 2, 32, 0xffffffff, 0, FALSE
, bitfield
,
426 bfd_elf_generic_reloc
),
428 /* Like R_PPC64_ADDR16, but may be unaligned. */
429 HOW (R_PPC64_UADDR16
, 1, 16, 0xffff, 0, FALSE
, bitfield
,
430 bfd_elf_generic_reloc
),
432 /* 32-bit PC relative. */
433 HOW (R_PPC64_REL32
, 2, 32, 0xffffffff, 0, TRUE
, signed,
434 bfd_elf_generic_reloc
),
436 /* 32-bit relocation to the symbol's procedure linkage table. */
437 HOW (R_PPC64_PLT32
, 2, 32, 0xffffffff, 0, FALSE
, bitfield
,
438 ppc64_elf_unhandled_reloc
),
440 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
441 FIXME: R_PPC64_PLTREL32 not supported. */
442 HOW (R_PPC64_PLTREL32
, 2, 32, 0xffffffff, 0, TRUE
, signed,
443 ppc64_elf_unhandled_reloc
),
445 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
447 HOW (R_PPC64_PLT16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
448 ppc64_elf_unhandled_reloc
),
450 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
452 HOW (R_PPC64_PLT16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
453 ppc64_elf_unhandled_reloc
),
455 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
457 HOW (R_PPC64_PLT16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
458 ppc64_elf_unhandled_reloc
),
460 /* 16-bit section relative relocation. */
461 HOW (R_PPC64_SECTOFF
, 1, 16, 0xffff, 0, FALSE
, signed,
462 ppc64_elf_sectoff_reloc
),
464 /* Like R_PPC64_SECTOFF, but no overflow warning. */
465 HOW (R_PPC64_SECTOFF_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
466 ppc64_elf_sectoff_reloc
),
468 /* 16-bit upper half section relative relocation. */
469 HOW (R_PPC64_SECTOFF_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
470 ppc64_elf_sectoff_reloc
),
472 /* 16-bit upper half adjusted section relative relocation. */
473 HOW (R_PPC64_SECTOFF_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
474 ppc64_elf_sectoff_ha_reloc
),
476 /* Like R_PPC64_REL24 without touching the two least significant bits. */
477 HOW (R_PPC64_REL30
, 2, 30, 0xfffffffc, 2, TRUE
, dont
,
478 bfd_elf_generic_reloc
),
480 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
482 /* A standard 64-bit relocation. */
483 HOW (R_PPC64_ADDR64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
484 bfd_elf_generic_reloc
),
486 /* The bits 32-47 of an address. */
487 HOW (R_PPC64_ADDR16_HIGHER
, 1, 16, 0xffff, 32, FALSE
, dont
,
488 bfd_elf_generic_reloc
),
490 /* The bits 32-47 of an address, plus 1 if the contents of the low
491 16 bits, treated as a signed number, is negative. */
492 HOW (R_PPC64_ADDR16_HIGHERA
, 1, 16, 0xffff, 32, FALSE
, dont
,
495 /* The bits 48-63 of an address. */
496 HOW (R_PPC64_ADDR16_HIGHEST
, 1, 16, 0xffff, 48, FALSE
, dont
,
497 bfd_elf_generic_reloc
),
499 /* The bits 48-63 of an address, plus 1 if the contents of the low
500 16 bits, treated as a signed number, is negative. */
501 HOW (R_PPC64_ADDR16_HIGHESTA
, 1, 16, 0xffff, 48, FALSE
, dont
,
504 /* Like ADDR64, but may be unaligned. */
505 HOW (R_PPC64_UADDR64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
506 bfd_elf_generic_reloc
),
508 /* 64-bit relative relocation. */
509 HOW (R_PPC64_REL64
, 4, 64, 0xffffffffffffffffULL
, 0, TRUE
, dont
,
510 bfd_elf_generic_reloc
),
512 /* 64-bit relocation to the symbol's procedure linkage table. */
513 HOW (R_PPC64_PLT64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
514 ppc64_elf_unhandled_reloc
),
516 /* 64-bit PC relative relocation to the symbol's procedure linkage
518 /* FIXME: R_PPC64_PLTREL64 not supported. */
519 HOW (R_PPC64_PLTREL64
, 4, 64, 0xffffffffffffffffULL
, 0, TRUE
, dont
,
520 ppc64_elf_unhandled_reloc
),
522 /* 16 bit TOC-relative relocation. */
523 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
524 HOW (R_PPC64_TOC16
, 1, 16, 0xffff, 0, FALSE
, signed,
525 ppc64_elf_toc_reloc
),
527 /* 16 bit TOC-relative relocation without overflow. */
528 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
529 HOW (R_PPC64_TOC16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
530 ppc64_elf_toc_reloc
),
532 /* 16 bit TOC-relative relocation, high 16 bits. */
533 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
534 HOW (R_PPC64_TOC16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
535 ppc64_elf_toc_reloc
),
537 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
538 contents of the low 16 bits, treated as a signed number, is
540 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
541 HOW (R_PPC64_TOC16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
542 ppc64_elf_toc_ha_reloc
),
544 /* 64-bit relocation; insert value of TOC base (.TOC.). */
545 /* R_PPC64_TOC 51 doubleword64 .TOC. */
546 HOW (R_PPC64_TOC
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
547 ppc64_elf_toc64_reloc
),
549 /* Like R_PPC64_GOT16, but also informs the link editor that the
550 value to relocate may (!) refer to a PLT entry which the link
551 editor (a) may replace with the symbol value. If the link editor
552 is unable to fully resolve the symbol, it may (b) create a PLT
553 entry and store the address to the new PLT entry in the GOT.
554 This permits lazy resolution of function symbols at run time.
555 The link editor may also skip all of this and just (c) emit a
556 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
557 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
558 HOW (R_PPC64_PLTGOT16
, 1, 16, 0xffff, 0, FALSE
,signed,
559 ppc64_elf_unhandled_reloc
),
561 /* Like R_PPC64_PLTGOT16, but without overflow. */
562 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
563 HOW (R_PPC64_PLTGOT16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
564 ppc64_elf_unhandled_reloc
),
566 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
567 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
568 HOW (R_PPC64_PLTGOT16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
569 ppc64_elf_unhandled_reloc
),
571 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
572 1 if the contents of the low 16 bits, treated as a signed number,
574 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
575 HOW (R_PPC64_PLTGOT16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
576 ppc64_elf_unhandled_reloc
),
578 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
579 HOW (R_PPC64_ADDR16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
580 bfd_elf_generic_reloc
),
582 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
583 HOW (R_PPC64_ADDR16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
584 bfd_elf_generic_reloc
),
586 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
587 HOW (R_PPC64_GOT16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
588 ppc64_elf_unhandled_reloc
),
590 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
591 HOW (R_PPC64_GOT16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
592 ppc64_elf_unhandled_reloc
),
594 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
595 HOW (R_PPC64_PLT16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
596 ppc64_elf_unhandled_reloc
),
598 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
599 HOW (R_PPC64_SECTOFF_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
600 ppc64_elf_sectoff_reloc
),
602 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
603 HOW (R_PPC64_SECTOFF_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
604 ppc64_elf_sectoff_reloc
),
606 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
607 HOW (R_PPC64_TOC16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
608 ppc64_elf_toc_reloc
),
610 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
611 HOW (R_PPC64_TOC16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
612 ppc64_elf_toc_reloc
),
614 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
615 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
616 HOW (R_PPC64_PLTGOT16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
617 ppc64_elf_unhandled_reloc
),
619 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
620 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
621 HOW (R_PPC64_PLTGOT16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
622 ppc64_elf_unhandled_reloc
),
624 /* Marker relocs for TLS. */
625 HOW (R_PPC64_TLS
, 2, 32, 0, 0, FALSE
, dont
,
626 bfd_elf_generic_reloc
),
628 HOW (R_PPC64_TLSGD
, 2, 32, 0, 0, FALSE
, dont
,
629 bfd_elf_generic_reloc
),
631 HOW (R_PPC64_TLSLD
, 2, 32, 0, 0, FALSE
, dont
,
632 bfd_elf_generic_reloc
),
634 /* Marker reloc for optimizing r2 save in prologue rather than on
635 each plt call stub. */
636 HOW (R_PPC64_TOCSAVE
, 2, 32, 0, 0, FALSE
, dont
,
637 bfd_elf_generic_reloc
),
639 /* Marker relocs on inline plt call instructions. */
640 HOW (R_PPC64_PLTSEQ
, 2, 32, 0, 0, FALSE
, dont
,
641 bfd_elf_generic_reloc
),
643 HOW (R_PPC64_PLTCALL
, 2, 32, 0, 0, FALSE
, dont
,
644 bfd_elf_generic_reloc
),
646 /* Computes the load module index of the load module that contains the
647 definition of its TLS sym. */
648 HOW (R_PPC64_DTPMOD64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
649 ppc64_elf_unhandled_reloc
),
651 /* Computes a dtv-relative displacement, the difference between the value
652 of sym+add and the base address of the thread-local storage block that
653 contains the definition of sym, minus 0x8000. */
654 HOW (R_PPC64_DTPREL64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
655 ppc64_elf_unhandled_reloc
),
657 /* A 16 bit dtprel reloc. */
658 HOW (R_PPC64_DTPREL16
, 1, 16, 0xffff, 0, FALSE
, signed,
659 ppc64_elf_unhandled_reloc
),
661 /* Like DTPREL16, but no overflow. */
662 HOW (R_PPC64_DTPREL16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
663 ppc64_elf_unhandled_reloc
),
665 /* Like DTPREL16_LO, but next higher group of 16 bits. */
666 HOW (R_PPC64_DTPREL16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
667 ppc64_elf_unhandled_reloc
),
669 /* Like DTPREL16_HI, but adjust for low 16 bits. */
670 HOW (R_PPC64_DTPREL16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
671 ppc64_elf_unhandled_reloc
),
673 /* Like DTPREL16_HI, but next higher group of 16 bits. */
674 HOW (R_PPC64_DTPREL16_HIGHER
, 1, 16, 0xffff, 32, FALSE
, dont
,
675 ppc64_elf_unhandled_reloc
),
677 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
678 HOW (R_PPC64_DTPREL16_HIGHERA
, 1, 16, 0xffff, 32, FALSE
, dont
,
679 ppc64_elf_unhandled_reloc
),
681 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
682 HOW (R_PPC64_DTPREL16_HIGHEST
, 1, 16, 0xffff, 48, FALSE
, dont
,
683 ppc64_elf_unhandled_reloc
),
685 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
686 HOW (R_PPC64_DTPREL16_HIGHESTA
, 1, 16, 0xffff, 48, FALSE
, dont
,
687 ppc64_elf_unhandled_reloc
),
689 /* Like DTPREL16, but for insns with a DS field. */
690 HOW (R_PPC64_DTPREL16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
691 ppc64_elf_unhandled_reloc
),
693 /* Like DTPREL16_DS, but no overflow. */
694 HOW (R_PPC64_DTPREL16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
695 ppc64_elf_unhandled_reloc
),
697 /* Computes a tp-relative displacement, the difference between the value of
698 sym+add and the value of the thread pointer (r13). */
699 HOW (R_PPC64_TPREL64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
700 ppc64_elf_unhandled_reloc
),
702 /* A 16 bit tprel reloc. */
703 HOW (R_PPC64_TPREL16
, 1, 16, 0xffff, 0, FALSE
, signed,
704 ppc64_elf_unhandled_reloc
),
706 /* Like TPREL16, but no overflow. */
707 HOW (R_PPC64_TPREL16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
708 ppc64_elf_unhandled_reloc
),
710 /* Like TPREL16_LO, but next higher group of 16 bits. */
711 HOW (R_PPC64_TPREL16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
712 ppc64_elf_unhandled_reloc
),
714 /* Like TPREL16_HI, but adjust for low 16 bits. */
715 HOW (R_PPC64_TPREL16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
716 ppc64_elf_unhandled_reloc
),
718 /* Like TPREL16_HI, but next higher group of 16 bits. */
719 HOW (R_PPC64_TPREL16_HIGHER
, 1, 16, 0xffff, 32, FALSE
, dont
,
720 ppc64_elf_unhandled_reloc
),
722 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
723 HOW (R_PPC64_TPREL16_HIGHERA
, 1, 16, 0xffff, 32, FALSE
, dont
,
724 ppc64_elf_unhandled_reloc
),
726 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
727 HOW (R_PPC64_TPREL16_HIGHEST
, 1, 16, 0xffff, 48, FALSE
, dont
,
728 ppc64_elf_unhandled_reloc
),
730 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
731 HOW (R_PPC64_TPREL16_HIGHESTA
, 1, 16, 0xffff, 48, FALSE
, dont
,
732 ppc64_elf_unhandled_reloc
),
734 /* Like TPREL16, but for insns with a DS field. */
735 HOW (R_PPC64_TPREL16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
736 ppc64_elf_unhandled_reloc
),
738 /* Like TPREL16_DS, but no overflow. */
739 HOW (R_PPC64_TPREL16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
740 ppc64_elf_unhandled_reloc
),
742 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
743 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
744 to the first entry relative to the TOC base (r2). */
745 HOW (R_PPC64_GOT_TLSGD16
, 1, 16, 0xffff, 0, FALSE
, signed,
746 ppc64_elf_unhandled_reloc
),
748 /* Like GOT_TLSGD16, but no overflow. */
749 HOW (R_PPC64_GOT_TLSGD16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
750 ppc64_elf_unhandled_reloc
),
752 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
753 HOW (R_PPC64_GOT_TLSGD16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
754 ppc64_elf_unhandled_reloc
),
756 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
757 HOW (R_PPC64_GOT_TLSGD16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
758 ppc64_elf_unhandled_reloc
),
760 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
761 with values (sym+add)@dtpmod and zero, and computes the offset to the
762 first entry relative to the TOC base (r2). */
763 HOW (R_PPC64_GOT_TLSLD16
, 1, 16, 0xffff, 0, FALSE
, signed,
764 ppc64_elf_unhandled_reloc
),
766 /* Like GOT_TLSLD16, but no overflow. */
767 HOW (R_PPC64_GOT_TLSLD16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
768 ppc64_elf_unhandled_reloc
),
770 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
771 HOW (R_PPC64_GOT_TLSLD16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
772 ppc64_elf_unhandled_reloc
),
774 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
775 HOW (R_PPC64_GOT_TLSLD16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
776 ppc64_elf_unhandled_reloc
),
778 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
779 the offset to the entry relative to the TOC base (r2). */
780 HOW (R_PPC64_GOT_DTPREL16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
781 ppc64_elf_unhandled_reloc
),
783 /* Like GOT_DTPREL16_DS, but no overflow. */
784 HOW (R_PPC64_GOT_DTPREL16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
785 ppc64_elf_unhandled_reloc
),
787 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
788 HOW (R_PPC64_GOT_DTPREL16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
789 ppc64_elf_unhandled_reloc
),
791 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
792 HOW (R_PPC64_GOT_DTPREL16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
793 ppc64_elf_unhandled_reloc
),
795 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
796 offset to the entry relative to the TOC base (r2). */
797 HOW (R_PPC64_GOT_TPREL16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
798 ppc64_elf_unhandled_reloc
),
800 /* Like GOT_TPREL16_DS, but no overflow. */
801 HOW (R_PPC64_GOT_TPREL16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
802 ppc64_elf_unhandled_reloc
),
804 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
805 HOW (R_PPC64_GOT_TPREL16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
806 ppc64_elf_unhandled_reloc
),
808 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
809 HOW (R_PPC64_GOT_TPREL16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
810 ppc64_elf_unhandled_reloc
),
812 HOW (R_PPC64_JMP_IREL
, 0, 0, 0, 0, FALSE
, dont
,
813 ppc64_elf_unhandled_reloc
),
815 HOW (R_PPC64_IRELATIVE
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
816 bfd_elf_generic_reloc
),
818 /* A 16 bit relative relocation. */
819 HOW (R_PPC64_REL16
, 1, 16, 0xffff, 0, TRUE
, signed,
820 bfd_elf_generic_reloc
),
822 /* A 16 bit relative relocation without overflow. */
823 HOW (R_PPC64_REL16_LO
, 1, 16, 0xffff, 0, TRUE
, dont
,
824 bfd_elf_generic_reloc
),
826 /* The high order 16 bits of a relative address. */
827 HOW (R_PPC64_REL16_HI
, 1, 16, 0xffff, 16, TRUE
, signed,
828 bfd_elf_generic_reloc
),
830 /* The high order 16 bits of a relative address, plus 1 if the contents of
831 the low 16 bits, treated as a signed number, is negative. */
832 HOW (R_PPC64_REL16_HA
, 1, 16, 0xffff, 16, TRUE
, signed,
835 HOW (R_PPC64_REL16_HIGH
, 1, 16, 0xffff, 16, TRUE
, dont
,
836 bfd_elf_generic_reloc
),
838 HOW (R_PPC64_REL16_HIGHA
, 1, 16, 0xffff, 16, TRUE
, dont
,
841 HOW (R_PPC64_REL16_HIGHER
, 1, 16, 0xffff, 32, TRUE
, dont
,
842 bfd_elf_generic_reloc
),
844 HOW (R_PPC64_REL16_HIGHERA
, 1, 16, 0xffff, 32, TRUE
, dont
,
847 HOW (R_PPC64_REL16_HIGHEST
, 1, 16, 0xffff, 48, TRUE
, dont
,
848 bfd_elf_generic_reloc
),
850 HOW (R_PPC64_REL16_HIGHESTA
, 1, 16, 0xffff, 48, TRUE
, dont
,
853 /* Like R_PPC64_REL16_HA but for split field in addpcis. */
854 HOW (R_PPC64_REL16DX_HA
, 2, 16, 0x1fffc1, 16, TRUE
, signed,
857 /* A split-field reloc for addpcis, non-relative (gas internal use only). */
858 HOW (R_PPC64_16DX_HA
, 2, 16, 0x1fffc1, 16, FALSE
, signed,
861 /* Like R_PPC64_ADDR16_HI, but no overflow. */
862 HOW (R_PPC64_ADDR16_HIGH
, 1, 16, 0xffff, 16, FALSE
, dont
,
863 bfd_elf_generic_reloc
),
865 /* Like R_PPC64_ADDR16_HA, but no overflow. */
866 HOW (R_PPC64_ADDR16_HIGHA
, 1, 16, 0xffff, 16, FALSE
, dont
,
869 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
870 HOW (R_PPC64_DTPREL16_HIGH
, 1, 16, 0xffff, 16, FALSE
, dont
,
871 ppc64_elf_unhandled_reloc
),
873 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
874 HOW (R_PPC64_DTPREL16_HIGHA
, 1, 16, 0xffff, 16, FALSE
, dont
,
875 ppc64_elf_unhandled_reloc
),
877 /* Like R_PPC64_TPREL16_HI, but no overflow. */
878 HOW (R_PPC64_TPREL16_HIGH
, 1, 16, 0xffff, 16, FALSE
, dont
,
879 ppc64_elf_unhandled_reloc
),
881 /* Like R_PPC64_TPREL16_HA, but no overflow. */
882 HOW (R_PPC64_TPREL16_HIGHA
, 1, 16, 0xffff, 16, FALSE
, dont
,
883 ppc64_elf_unhandled_reloc
),
885 /* Marker reloc on ELFv2 large-model function entry. */
886 HOW (R_PPC64_ENTRY
, 2, 32, 0, 0, FALSE
, dont
,
887 bfd_elf_generic_reloc
),
889 /* Like ADDR64, but use local entry point of function. */
890 HOW (R_PPC64_ADDR64_LOCAL
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
891 bfd_elf_generic_reloc
),
893 HOW (R_PPC64_PLTSEQ_NOTOC
, 2, 32, 0, 0, FALSE
, dont
,
894 bfd_elf_generic_reloc
),
896 HOW (R_PPC64_PLTCALL_NOTOC
, 2, 32, 0, 0, FALSE
, dont
,
897 bfd_elf_generic_reloc
),
899 HOW (R_PPC64_PCREL_OPT
, 2, 32, 0, 0, FALSE
, dont
,
900 bfd_elf_generic_reloc
),
902 HOW (R_PPC64_D34
, 4, 34, 0x3ffff0000ffffULL
, 0, FALSE
, signed,
903 ppc64_elf_prefix_reloc
),
905 HOW (R_PPC64_D34_LO
, 4, 34, 0x3ffff0000ffffULL
, 0, FALSE
, dont
,
906 ppc64_elf_prefix_reloc
),
908 HOW (R_PPC64_D34_HI30
, 4, 34, 0x3ffff0000ffffULL
, 34, FALSE
, dont
,
909 ppc64_elf_prefix_reloc
),
911 HOW (R_PPC64_D34_HA30
, 4, 34, 0x3ffff0000ffffULL
, 34, FALSE
, dont
,
912 ppc64_elf_prefix_reloc
),
914 HOW (R_PPC64_PCREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
915 ppc64_elf_prefix_reloc
),
917 HOW (R_PPC64_GOT_PCREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
918 ppc64_elf_unhandled_reloc
),
920 HOW (R_PPC64_PLT_PCREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
921 ppc64_elf_unhandled_reloc
),
923 HOW (R_PPC64_PLT_PCREL34_NOTOC
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
924 ppc64_elf_unhandled_reloc
),
926 HOW (R_PPC64_TPREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, FALSE
, signed,
927 ppc64_elf_unhandled_reloc
),
929 HOW (R_PPC64_DTPREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, FALSE
, signed,
930 ppc64_elf_unhandled_reloc
),
932 HOW (R_PPC64_GOT_TLSGD34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
933 ppc64_elf_unhandled_reloc
),
935 HOW (R_PPC64_GOT_TLSLD34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
936 ppc64_elf_unhandled_reloc
),
938 HOW (R_PPC64_GOT_TPREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
939 ppc64_elf_unhandled_reloc
),
941 HOW (R_PPC64_GOT_DTPREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
942 ppc64_elf_unhandled_reloc
),
944 HOW (R_PPC64_ADDR16_HIGHER34
, 1, 16, 0xffff, 34, FALSE
, dont
,
945 bfd_elf_generic_reloc
),
947 HOW (R_PPC64_ADDR16_HIGHERA34
, 1, 16, 0xffff, 34, FALSE
, dont
,
950 HOW (R_PPC64_ADDR16_HIGHEST34
, 1, 16, 0xffff, 50, FALSE
, dont
,
951 bfd_elf_generic_reloc
),
953 HOW (R_PPC64_ADDR16_HIGHESTA34
, 1, 16, 0xffff, 50, FALSE
, dont
,
956 HOW (R_PPC64_REL16_HIGHER34
, 1, 16, 0xffff, 34, TRUE
, dont
,
957 bfd_elf_generic_reloc
),
959 HOW (R_PPC64_REL16_HIGHERA34
, 1, 16, 0xffff, 34, TRUE
, dont
,
962 HOW (R_PPC64_REL16_HIGHEST34
, 1, 16, 0xffff, 50, TRUE
, dont
,
963 bfd_elf_generic_reloc
),
965 HOW (R_PPC64_REL16_HIGHESTA34
, 1, 16, 0xffff, 50, TRUE
, dont
,
968 HOW (R_PPC64_D28
, 4, 28, 0xfff0000ffffULL
, 0, FALSE
, signed,
969 ppc64_elf_prefix_reloc
),
971 HOW (R_PPC64_PCREL28
, 4, 28, 0xfff0000ffffULL
, 0, TRUE
, signed,
972 ppc64_elf_prefix_reloc
),
974 /* GNU extension to record C++ vtable hierarchy. */
975 HOW (R_PPC64_GNU_VTINHERIT
, 0, 0, 0, 0, FALSE
, dont
,
978 /* GNU extension to record C++ vtable member usage. */
979 HOW (R_PPC64_GNU_VTENTRY
, 0, 0, 0, 0, FALSE
, dont
,
984 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
988 ppc_howto_init (void)
990 unsigned int i
, type
;
992 for (i
= 0; i
< ARRAY_SIZE (ppc64_elf_howto_raw
); i
++)
994 type
= ppc64_elf_howto_raw
[i
].type
;
995 BFD_ASSERT (type
< ARRAY_SIZE (ppc64_elf_howto_table
));
996 ppc64_elf_howto_table
[type
] = &ppc64_elf_howto_raw
[i
];
1000 static reloc_howto_type
*
1001 ppc64_elf_reloc_type_lookup (bfd
*abfd
,
1002 bfd_reloc_code_real_type code
)
1004 enum elf_ppc64_reloc_type r
= R_PPC64_NONE
;
1006 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
1007 /* Initialize howto table if needed. */
1013 /* xgettext:c-format */
1014 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd
,
1016 bfd_set_error (bfd_error_bad_value
);
1019 case BFD_RELOC_NONE
: r
= R_PPC64_NONE
;
1021 case BFD_RELOC_32
: r
= R_PPC64_ADDR32
;
1023 case BFD_RELOC_PPC_BA26
: r
= R_PPC64_ADDR24
;
1025 case BFD_RELOC_16
: r
= R_PPC64_ADDR16
;
1027 case BFD_RELOC_LO16
: r
= R_PPC64_ADDR16_LO
;
1029 case BFD_RELOC_HI16
: r
= R_PPC64_ADDR16_HI
;
1031 case BFD_RELOC_PPC64_ADDR16_HIGH
: r
= R_PPC64_ADDR16_HIGH
;
1033 case BFD_RELOC_HI16_S
: r
= R_PPC64_ADDR16_HA
;
1035 case BFD_RELOC_PPC64_ADDR16_HIGHA
: r
= R_PPC64_ADDR16_HIGHA
;
1037 case BFD_RELOC_PPC_BA16
: r
= R_PPC64_ADDR14
;
1039 case BFD_RELOC_PPC_BA16_BRTAKEN
: r
= R_PPC64_ADDR14_BRTAKEN
;
1041 case BFD_RELOC_PPC_BA16_BRNTAKEN
: r
= R_PPC64_ADDR14_BRNTAKEN
;
1043 case BFD_RELOC_PPC_B26
: r
= R_PPC64_REL24
;
1045 case BFD_RELOC_PPC64_REL24_NOTOC
: r
= R_PPC64_REL24_NOTOC
;
1047 case BFD_RELOC_PPC_B16
: r
= R_PPC64_REL14
;
1049 case BFD_RELOC_PPC_B16_BRTAKEN
: r
= R_PPC64_REL14_BRTAKEN
;
1051 case BFD_RELOC_PPC_B16_BRNTAKEN
: r
= R_PPC64_REL14_BRNTAKEN
;
1053 case BFD_RELOC_16_GOTOFF
: r
= R_PPC64_GOT16
;
1055 case BFD_RELOC_LO16_GOTOFF
: r
= R_PPC64_GOT16_LO
;
1057 case BFD_RELOC_HI16_GOTOFF
: r
= R_PPC64_GOT16_HI
;
1059 case BFD_RELOC_HI16_S_GOTOFF
: r
= R_PPC64_GOT16_HA
;
1061 case BFD_RELOC_PPC_COPY
: r
= R_PPC64_COPY
;
1063 case BFD_RELOC_PPC_GLOB_DAT
: r
= R_PPC64_GLOB_DAT
;
1065 case BFD_RELOC_32_PCREL
: r
= R_PPC64_REL32
;
1067 case BFD_RELOC_32_PLTOFF
: r
= R_PPC64_PLT32
;
1069 case BFD_RELOC_32_PLT_PCREL
: r
= R_PPC64_PLTREL32
;
1071 case BFD_RELOC_LO16_PLTOFF
: r
= R_PPC64_PLT16_LO
;
1073 case BFD_RELOC_HI16_PLTOFF
: r
= R_PPC64_PLT16_HI
;
1075 case BFD_RELOC_HI16_S_PLTOFF
: r
= R_PPC64_PLT16_HA
;
1077 case BFD_RELOC_16_BASEREL
: r
= R_PPC64_SECTOFF
;
1079 case BFD_RELOC_LO16_BASEREL
: r
= R_PPC64_SECTOFF_LO
;
1081 case BFD_RELOC_HI16_BASEREL
: r
= R_PPC64_SECTOFF_HI
;
1083 case BFD_RELOC_HI16_S_BASEREL
: r
= R_PPC64_SECTOFF_HA
;
1085 case BFD_RELOC_CTOR
: r
= R_PPC64_ADDR64
;
1087 case BFD_RELOC_64
: r
= R_PPC64_ADDR64
;
1089 case BFD_RELOC_PPC64_HIGHER
: r
= R_PPC64_ADDR16_HIGHER
;
1091 case BFD_RELOC_PPC64_HIGHER_S
: r
= R_PPC64_ADDR16_HIGHERA
;
1093 case BFD_RELOC_PPC64_HIGHEST
: r
= R_PPC64_ADDR16_HIGHEST
;
1095 case BFD_RELOC_PPC64_HIGHEST_S
: r
= R_PPC64_ADDR16_HIGHESTA
;
1097 case BFD_RELOC_64_PCREL
: r
= R_PPC64_REL64
;
1099 case BFD_RELOC_64_PLTOFF
: r
= R_PPC64_PLT64
;
1101 case BFD_RELOC_64_PLT_PCREL
: r
= R_PPC64_PLTREL64
;
1103 case BFD_RELOC_PPC_TOC16
: r
= R_PPC64_TOC16
;
1105 case BFD_RELOC_PPC64_TOC16_LO
: r
= R_PPC64_TOC16_LO
;
1107 case BFD_RELOC_PPC64_TOC16_HI
: r
= R_PPC64_TOC16_HI
;
1109 case BFD_RELOC_PPC64_TOC16_HA
: r
= R_PPC64_TOC16_HA
;
1111 case BFD_RELOC_PPC64_TOC
: r
= R_PPC64_TOC
;
1113 case BFD_RELOC_PPC64_PLTGOT16
: r
= R_PPC64_PLTGOT16
;
1115 case BFD_RELOC_PPC64_PLTGOT16_LO
: r
= R_PPC64_PLTGOT16_LO
;
1117 case BFD_RELOC_PPC64_PLTGOT16_HI
: r
= R_PPC64_PLTGOT16_HI
;
1119 case BFD_RELOC_PPC64_PLTGOT16_HA
: r
= R_PPC64_PLTGOT16_HA
;
1121 case BFD_RELOC_PPC64_ADDR16_DS
: r
= R_PPC64_ADDR16_DS
;
1123 case BFD_RELOC_PPC64_ADDR16_LO_DS
: r
= R_PPC64_ADDR16_LO_DS
;
1125 case BFD_RELOC_PPC64_GOT16_DS
: r
= R_PPC64_GOT16_DS
;
1127 case BFD_RELOC_PPC64_GOT16_LO_DS
: r
= R_PPC64_GOT16_LO_DS
;
1129 case BFD_RELOC_PPC64_PLT16_LO_DS
: r
= R_PPC64_PLT16_LO_DS
;
1131 case BFD_RELOC_PPC64_SECTOFF_DS
: r
= R_PPC64_SECTOFF_DS
;
1133 case BFD_RELOC_PPC64_SECTOFF_LO_DS
: r
= R_PPC64_SECTOFF_LO_DS
;
1135 case BFD_RELOC_PPC64_TOC16_DS
: r
= R_PPC64_TOC16_DS
;
1137 case BFD_RELOC_PPC64_TOC16_LO_DS
: r
= R_PPC64_TOC16_LO_DS
;
1139 case BFD_RELOC_PPC64_PLTGOT16_DS
: r
= R_PPC64_PLTGOT16_DS
;
1141 case BFD_RELOC_PPC64_PLTGOT16_LO_DS
: r
= R_PPC64_PLTGOT16_LO_DS
;
1143 case BFD_RELOC_PPC64_TLS_PCREL
:
1144 case BFD_RELOC_PPC_TLS
: r
= R_PPC64_TLS
;
1146 case BFD_RELOC_PPC_TLSGD
: r
= R_PPC64_TLSGD
;
1148 case BFD_RELOC_PPC_TLSLD
: r
= R_PPC64_TLSLD
;
1150 case BFD_RELOC_PPC_DTPMOD
: r
= R_PPC64_DTPMOD64
;
1152 case BFD_RELOC_PPC_TPREL16
: r
= R_PPC64_TPREL16
;
1154 case BFD_RELOC_PPC_TPREL16_LO
: r
= R_PPC64_TPREL16_LO
;
1156 case BFD_RELOC_PPC_TPREL16_HI
: r
= R_PPC64_TPREL16_HI
;
1158 case BFD_RELOC_PPC64_TPREL16_HIGH
: r
= R_PPC64_TPREL16_HIGH
;
1160 case BFD_RELOC_PPC_TPREL16_HA
: r
= R_PPC64_TPREL16_HA
;
1162 case BFD_RELOC_PPC64_TPREL16_HIGHA
: r
= R_PPC64_TPREL16_HIGHA
;
1164 case BFD_RELOC_PPC_TPREL
: r
= R_PPC64_TPREL64
;
1166 case BFD_RELOC_PPC_DTPREL16
: r
= R_PPC64_DTPREL16
;
1168 case BFD_RELOC_PPC_DTPREL16_LO
: r
= R_PPC64_DTPREL16_LO
;
1170 case BFD_RELOC_PPC_DTPREL16_HI
: r
= R_PPC64_DTPREL16_HI
;
1172 case BFD_RELOC_PPC64_DTPREL16_HIGH
: r
= R_PPC64_DTPREL16_HIGH
;
1174 case BFD_RELOC_PPC_DTPREL16_HA
: r
= R_PPC64_DTPREL16_HA
;
1176 case BFD_RELOC_PPC64_DTPREL16_HIGHA
: r
= R_PPC64_DTPREL16_HIGHA
;
1178 case BFD_RELOC_PPC_DTPREL
: r
= R_PPC64_DTPREL64
;
1180 case BFD_RELOC_PPC_GOT_TLSGD16
: r
= R_PPC64_GOT_TLSGD16
;
1182 case BFD_RELOC_PPC_GOT_TLSGD16_LO
: r
= R_PPC64_GOT_TLSGD16_LO
;
1184 case BFD_RELOC_PPC_GOT_TLSGD16_HI
: r
= R_PPC64_GOT_TLSGD16_HI
;
1186 case BFD_RELOC_PPC_GOT_TLSGD16_HA
: r
= R_PPC64_GOT_TLSGD16_HA
;
1188 case BFD_RELOC_PPC_GOT_TLSLD16
: r
= R_PPC64_GOT_TLSLD16
;
1190 case BFD_RELOC_PPC_GOT_TLSLD16_LO
: r
= R_PPC64_GOT_TLSLD16_LO
;
1192 case BFD_RELOC_PPC_GOT_TLSLD16_HI
: r
= R_PPC64_GOT_TLSLD16_HI
;
1194 case BFD_RELOC_PPC_GOT_TLSLD16_HA
: r
= R_PPC64_GOT_TLSLD16_HA
;
1196 case BFD_RELOC_PPC_GOT_TPREL16
: r
= R_PPC64_GOT_TPREL16_DS
;
1198 case BFD_RELOC_PPC_GOT_TPREL16_LO
: r
= R_PPC64_GOT_TPREL16_LO_DS
;
1200 case BFD_RELOC_PPC_GOT_TPREL16_HI
: r
= R_PPC64_GOT_TPREL16_HI
;
1202 case BFD_RELOC_PPC_GOT_TPREL16_HA
: r
= R_PPC64_GOT_TPREL16_HA
;
1204 case BFD_RELOC_PPC_GOT_DTPREL16
: r
= R_PPC64_GOT_DTPREL16_DS
;
1206 case BFD_RELOC_PPC_GOT_DTPREL16_LO
: r
= R_PPC64_GOT_DTPREL16_LO_DS
;
1208 case BFD_RELOC_PPC_GOT_DTPREL16_HI
: r
= R_PPC64_GOT_DTPREL16_HI
;
1210 case BFD_RELOC_PPC_GOT_DTPREL16_HA
: r
= R_PPC64_GOT_DTPREL16_HA
;
1212 case BFD_RELOC_PPC64_TPREL16_DS
: r
= R_PPC64_TPREL16_DS
;
1214 case BFD_RELOC_PPC64_TPREL16_LO_DS
: r
= R_PPC64_TPREL16_LO_DS
;
1216 case BFD_RELOC_PPC64_TPREL16_HIGHER
: r
= R_PPC64_TPREL16_HIGHER
;
1218 case BFD_RELOC_PPC64_TPREL16_HIGHERA
: r
= R_PPC64_TPREL16_HIGHERA
;
1220 case BFD_RELOC_PPC64_TPREL16_HIGHEST
: r
= R_PPC64_TPREL16_HIGHEST
;
1222 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
: r
= R_PPC64_TPREL16_HIGHESTA
;
1224 case BFD_RELOC_PPC64_DTPREL16_DS
: r
= R_PPC64_DTPREL16_DS
;
1226 case BFD_RELOC_PPC64_DTPREL16_LO_DS
: r
= R_PPC64_DTPREL16_LO_DS
;
1228 case BFD_RELOC_PPC64_DTPREL16_HIGHER
: r
= R_PPC64_DTPREL16_HIGHER
;
1230 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
: r
= R_PPC64_DTPREL16_HIGHERA
;
1232 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
: r
= R_PPC64_DTPREL16_HIGHEST
;
1234 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
: r
= R_PPC64_DTPREL16_HIGHESTA
;
1236 case BFD_RELOC_16_PCREL
: r
= R_PPC64_REL16
;
1238 case BFD_RELOC_LO16_PCREL
: r
= R_PPC64_REL16_LO
;
1240 case BFD_RELOC_HI16_PCREL
: r
= R_PPC64_REL16_HI
;
1242 case BFD_RELOC_HI16_S_PCREL
: r
= R_PPC64_REL16_HA
;
1244 case BFD_RELOC_PPC64_REL16_HIGH
: r
= R_PPC64_REL16_HIGH
;
1246 case BFD_RELOC_PPC64_REL16_HIGHA
: r
= R_PPC64_REL16_HIGHA
;
1248 case BFD_RELOC_PPC64_REL16_HIGHER
: r
= R_PPC64_REL16_HIGHER
;
1250 case BFD_RELOC_PPC64_REL16_HIGHERA
: r
= R_PPC64_REL16_HIGHERA
;
1252 case BFD_RELOC_PPC64_REL16_HIGHEST
: r
= R_PPC64_REL16_HIGHEST
;
1254 case BFD_RELOC_PPC64_REL16_HIGHESTA
: r
= R_PPC64_REL16_HIGHESTA
;
1256 case BFD_RELOC_PPC_16DX_HA
: r
= R_PPC64_16DX_HA
;
1258 case BFD_RELOC_PPC_REL16DX_HA
: r
= R_PPC64_REL16DX_HA
;
1260 case BFD_RELOC_PPC64_ENTRY
: r
= R_PPC64_ENTRY
;
1262 case BFD_RELOC_PPC64_ADDR64_LOCAL
: r
= R_PPC64_ADDR64_LOCAL
;
1264 case BFD_RELOC_PPC64_D34
: r
= R_PPC64_D34
;
1266 case BFD_RELOC_PPC64_D34_LO
: r
= R_PPC64_D34_LO
;
1268 case BFD_RELOC_PPC64_D34_HI30
: r
= R_PPC64_D34_HI30
;
1270 case BFD_RELOC_PPC64_D34_HA30
: r
= R_PPC64_D34_HA30
;
1272 case BFD_RELOC_PPC64_PCREL34
: r
= R_PPC64_PCREL34
;
1274 case BFD_RELOC_PPC64_GOT_PCREL34
: r
= R_PPC64_GOT_PCREL34
;
1276 case BFD_RELOC_PPC64_PLT_PCREL34
: r
= R_PPC64_PLT_PCREL34
;
1278 case BFD_RELOC_PPC64_TPREL34
: r
= R_PPC64_TPREL34
;
1280 case BFD_RELOC_PPC64_DTPREL34
: r
= R_PPC64_DTPREL34
;
1282 case BFD_RELOC_PPC64_GOT_TLSGD34
: r
= R_PPC64_GOT_TLSGD34
;
1284 case BFD_RELOC_PPC64_GOT_TLSLD34
: r
= R_PPC64_GOT_TLSLD34
;
1286 case BFD_RELOC_PPC64_GOT_TPREL34
: r
= R_PPC64_GOT_TPREL34
;
1288 case BFD_RELOC_PPC64_GOT_DTPREL34
: r
= R_PPC64_GOT_DTPREL34
;
1290 case BFD_RELOC_PPC64_ADDR16_HIGHER34
: r
= R_PPC64_ADDR16_HIGHER34
;
1292 case BFD_RELOC_PPC64_ADDR16_HIGHERA34
: r
= R_PPC64_ADDR16_HIGHERA34
;
1294 case BFD_RELOC_PPC64_ADDR16_HIGHEST34
: r
= R_PPC64_ADDR16_HIGHEST34
;
1296 case BFD_RELOC_PPC64_ADDR16_HIGHESTA34
: r
= R_PPC64_ADDR16_HIGHESTA34
;
1298 case BFD_RELOC_PPC64_REL16_HIGHER34
: r
= R_PPC64_REL16_HIGHER34
;
1300 case BFD_RELOC_PPC64_REL16_HIGHERA34
: r
= R_PPC64_REL16_HIGHERA34
;
1302 case BFD_RELOC_PPC64_REL16_HIGHEST34
: r
= R_PPC64_REL16_HIGHEST34
;
1304 case BFD_RELOC_PPC64_REL16_HIGHESTA34
: r
= R_PPC64_REL16_HIGHESTA34
;
1306 case BFD_RELOC_PPC64_D28
: r
= R_PPC64_D28
;
1308 case BFD_RELOC_PPC64_PCREL28
: r
= R_PPC64_PCREL28
;
1310 case BFD_RELOC_VTABLE_INHERIT
: r
= R_PPC64_GNU_VTINHERIT
;
1312 case BFD_RELOC_VTABLE_ENTRY
: r
= R_PPC64_GNU_VTENTRY
;
1316 return ppc64_elf_howto_table
[r
];
1319 static reloc_howto_type
*
1320 ppc64_elf_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
1325 for (i
= 0; i
< ARRAY_SIZE (ppc64_elf_howto_raw
); i
++)
1326 if (ppc64_elf_howto_raw
[i
].name
!= NULL
1327 && strcasecmp (ppc64_elf_howto_raw
[i
].name
, r_name
) == 0)
1328 return &ppc64_elf_howto_raw
[i
];
1333 /* Set the howto pointer for a PowerPC ELF reloc. */
1336 ppc64_elf_info_to_howto (bfd
*abfd
, arelent
*cache_ptr
,
1337 Elf_Internal_Rela
*dst
)
1341 /* Initialize howto table if needed. */
1342 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
1345 type
= ELF64_R_TYPE (dst
->r_info
);
1346 if (type
>= ARRAY_SIZE (ppc64_elf_howto_table
))
1348 /* xgettext:c-format */
1349 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
1351 bfd_set_error (bfd_error_bad_value
);
1354 cache_ptr
->howto
= ppc64_elf_howto_table
[type
];
1355 if (cache_ptr
->howto
== NULL
|| cache_ptr
->howto
->name
== NULL
)
1357 /* xgettext:c-format */
1358 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
1360 bfd_set_error (bfd_error_bad_value
);
1367 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
1369 static bfd_reloc_status_type
1370 ppc64_elf_ha_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1371 void *data
, asection
*input_section
,
1372 bfd
*output_bfd
, char **error_message
)
1374 enum elf_ppc64_reloc_type r_type
;
1376 bfd_size_type octets
;
1379 /* If this is a relocatable link (output_bfd test tells us), just
1380 call the generic function. Any adjustment will be done at final
1382 if (output_bfd
!= NULL
)
1383 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1384 input_section
, output_bfd
, error_message
);
1386 /* Adjust the addend for sign extension of the low 16 (or 34) bits.
1387 We won't actually be using the low bits, so trashing them
1389 r_type
= reloc_entry
->howto
->type
;
1390 if (r_type
== R_PPC64_ADDR16_HIGHERA34
1391 || r_type
== R_PPC64_ADDR16_HIGHESTA34
1392 || r_type
== R_PPC64_REL16_HIGHERA34
1393 || r_type
== R_PPC64_REL16_HIGHESTA34
)
1394 reloc_entry
->addend
+= 1ULL << 33;
1396 reloc_entry
->addend
+= 1U << 15;
1397 if (r_type
!= R_PPC64_REL16DX_HA
)
1398 return bfd_reloc_continue
;
1401 if (!bfd_is_com_section (symbol
->section
))
1402 value
= symbol
->value
;
1403 value
+= (reloc_entry
->addend
1404 + symbol
->section
->output_offset
1405 + symbol
->section
->output_section
->vma
);
1406 value
-= (reloc_entry
->address
1407 + input_section
->output_offset
1408 + input_section
->output_section
->vma
);
1409 value
= (bfd_signed_vma
) value
>> 16;
1411 octets
= reloc_entry
->address
* OCTETS_PER_BYTE (abfd
, input_section
);
1412 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ octets
);
1414 insn
|= (value
& 0xffc1) | ((value
& 0x3e) << 15);
1415 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ octets
);
1416 if (value
+ 0x8000 > 0xffff)
1417 return bfd_reloc_overflow
;
1418 return bfd_reloc_ok
;
1421 static bfd_reloc_status_type
1422 ppc64_elf_branch_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1423 void *data
, asection
*input_section
,
1424 bfd
*output_bfd
, char **error_message
)
1426 if (output_bfd
!= NULL
)
1427 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1428 input_section
, output_bfd
, error_message
);
1430 if (strcmp (symbol
->section
->name
, ".opd") == 0
1431 && (symbol
->section
->owner
->flags
& DYNAMIC
) == 0)
1433 bfd_vma dest
= opd_entry_value (symbol
->section
,
1434 symbol
->value
+ reloc_entry
->addend
,
1436 if (dest
!= (bfd_vma
) -1)
1437 reloc_entry
->addend
= dest
- (symbol
->value
1438 + symbol
->section
->output_section
->vma
1439 + symbol
->section
->output_offset
);
1443 elf_symbol_type
*elfsym
= (elf_symbol_type
*) symbol
;
1445 if (symbol
->section
->owner
!= abfd
1446 && symbol
->section
->owner
!= NULL
1447 && abiversion (symbol
->section
->owner
) >= 2)
1451 for (i
= 0; i
< symbol
->section
->owner
->symcount
; ++i
)
1453 asymbol
*symdef
= symbol
->section
->owner
->outsymbols
[i
];
1455 if (strcmp (symdef
->name
, symbol
->name
) == 0)
1457 elfsym
= (elf_symbol_type
*) symdef
;
1463 += PPC64_LOCAL_ENTRY_OFFSET (elfsym
->internal_elf_sym
.st_other
);
1465 return bfd_reloc_continue
;
1468 static bfd_reloc_status_type
1469 ppc64_elf_brtaken_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1470 void *data
, asection
*input_section
,
1471 bfd
*output_bfd
, char **error_message
)
1474 enum elf_ppc64_reloc_type r_type
;
1475 bfd_size_type octets
;
1476 /* Assume 'at' branch hints. */
1477 bfd_boolean is_isa_v2
= TRUE
;
1479 /* If this is a relocatable link (output_bfd test tells us), just
1480 call the generic function. Any adjustment will be done at final
1482 if (output_bfd
!= NULL
)
1483 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1484 input_section
, output_bfd
, error_message
);
1486 octets
= reloc_entry
->address
* OCTETS_PER_BYTE (abfd
, input_section
);
1487 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ octets
);
1488 insn
&= ~(0x01 << 21);
1489 r_type
= reloc_entry
->howto
->type
;
1490 if (r_type
== R_PPC64_ADDR14_BRTAKEN
1491 || r_type
== R_PPC64_REL14_BRTAKEN
)
1492 insn
|= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
1496 /* Set 'a' bit. This is 0b00010 in BO field for branch
1497 on CR(BI) insns (BO == 001at or 011at), and 0b01000
1498 for branch on CTR insns (BO == 1a00t or 1a01t). */
1499 if ((insn
& (0x14 << 21)) == (0x04 << 21))
1501 else if ((insn
& (0x14 << 21)) == (0x10 << 21))
1511 if (!bfd_is_com_section (symbol
->section
))
1512 target
= symbol
->value
;
1513 target
+= symbol
->section
->output_section
->vma
;
1514 target
+= symbol
->section
->output_offset
;
1515 target
+= reloc_entry
->addend
;
1517 from
= (reloc_entry
->address
1518 + input_section
->output_offset
1519 + input_section
->output_section
->vma
);
1521 /* Invert 'y' bit if not the default. */
1522 if ((bfd_signed_vma
) (target
- from
) < 0)
1525 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ octets
);
1527 return ppc64_elf_branch_reloc (abfd
, reloc_entry
, symbol
, data
,
1528 input_section
, output_bfd
, error_message
);
1531 static bfd_reloc_status_type
1532 ppc64_elf_sectoff_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1533 void *data
, asection
*input_section
,
1534 bfd
*output_bfd
, char **error_message
)
1536 /* If this is a relocatable link (output_bfd test tells us), just
1537 call the generic function. Any adjustment will be done at final
1539 if (output_bfd
!= NULL
)
1540 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1541 input_section
, output_bfd
, error_message
);
1543 /* Subtract the symbol section base address. */
1544 reloc_entry
->addend
-= symbol
->section
->output_section
->vma
;
1545 return bfd_reloc_continue
;
1548 static bfd_reloc_status_type
1549 ppc64_elf_sectoff_ha_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1550 void *data
, asection
*input_section
,
1551 bfd
*output_bfd
, char **error_message
)
1553 /* If this is a relocatable link (output_bfd test tells us), just
1554 call the generic function. Any adjustment will be done at final
1556 if (output_bfd
!= NULL
)
1557 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1558 input_section
, output_bfd
, error_message
);
1560 /* Subtract the symbol section base address. */
1561 reloc_entry
->addend
-= symbol
->section
->output_section
->vma
;
1563 /* Adjust the addend for sign extension of the low 16 bits. */
1564 reloc_entry
->addend
+= 0x8000;
1565 return bfd_reloc_continue
;
1568 static bfd_reloc_status_type
1569 ppc64_elf_toc_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1570 void *data
, asection
*input_section
,
1571 bfd
*output_bfd
, char **error_message
)
1575 /* If this is a relocatable link (output_bfd test tells us), just
1576 call the generic function. Any adjustment will be done at final
1578 if (output_bfd
!= NULL
)
1579 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1580 input_section
, output_bfd
, error_message
);
1582 TOCstart
= _bfd_get_gp_value (input_section
->output_section
->owner
);
1584 TOCstart
= ppc64_elf_set_toc (NULL
, input_section
->output_section
->owner
);
1586 /* Subtract the TOC base address. */
1587 reloc_entry
->addend
-= TOCstart
+ TOC_BASE_OFF
;
1588 return bfd_reloc_continue
;
1591 static bfd_reloc_status_type
1592 ppc64_elf_toc_ha_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1593 void *data
, asection
*input_section
,
1594 bfd
*output_bfd
, char **error_message
)
1598 /* If this is a relocatable link (output_bfd test tells us), just
1599 call the generic function. Any adjustment will be done at final
1601 if (output_bfd
!= NULL
)
1602 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1603 input_section
, output_bfd
, error_message
);
1605 TOCstart
= _bfd_get_gp_value (input_section
->output_section
->owner
);
1607 TOCstart
= ppc64_elf_set_toc (NULL
, input_section
->output_section
->owner
);
1609 /* Subtract the TOC base address. */
1610 reloc_entry
->addend
-= TOCstart
+ TOC_BASE_OFF
;
1612 /* Adjust the addend for sign extension of the low 16 bits. */
1613 reloc_entry
->addend
+= 0x8000;
1614 return bfd_reloc_continue
;
1617 static bfd_reloc_status_type
1618 ppc64_elf_toc64_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1619 void *data
, asection
*input_section
,
1620 bfd
*output_bfd
, char **error_message
)
1623 bfd_size_type octets
;
1625 /* If this is a relocatable link (output_bfd test tells us), just
1626 call the generic function. Any adjustment will be done at final
1628 if (output_bfd
!= NULL
)
1629 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1630 input_section
, output_bfd
, error_message
);
1632 TOCstart
= _bfd_get_gp_value (input_section
->output_section
->owner
);
1634 TOCstart
= ppc64_elf_set_toc (NULL
, input_section
->output_section
->owner
);
1636 octets
= reloc_entry
->address
* OCTETS_PER_BYTE (abfd
, input_section
);
1637 bfd_put_64 (abfd
, TOCstart
+ TOC_BASE_OFF
, (bfd_byte
*) data
+ octets
);
1638 return bfd_reloc_ok
;
1641 static bfd_reloc_status_type
1642 ppc64_elf_prefix_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1643 void *data
, asection
*input_section
,
1644 bfd
*output_bfd
, char **error_message
)
1649 if (output_bfd
!= NULL
)
1650 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1651 input_section
, output_bfd
, error_message
);
1653 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1655 insn
|= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
+ 4);
1657 targ
= (symbol
->section
->output_section
->vma
1658 + symbol
->section
->output_offset
1659 + reloc_entry
->addend
);
1660 if (!bfd_is_com_section (symbol
->section
))
1661 targ
+= symbol
->value
;
1662 if (reloc_entry
->howto
->type
== R_PPC64_D34_HA30
)
1664 if (reloc_entry
->howto
->pc_relative
)
1666 bfd_vma from
= (reloc_entry
->address
1667 + input_section
->output_offset
1668 + input_section
->output_section
->vma
);
1671 targ
>>= reloc_entry
->howto
->rightshift
;
1672 insn
&= ~reloc_entry
->howto
->dst_mask
;
1673 insn
|= ((targ
<< 16) | (targ
& 0xffff)) & reloc_entry
->howto
->dst_mask
;
1674 bfd_put_32 (abfd
, insn
>> 32, (bfd_byte
*) data
+ reloc_entry
->address
);
1675 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ reloc_entry
->address
+ 4);
1676 if (reloc_entry
->howto
->complain_on_overflow
== complain_overflow_signed
1677 && (targ
+ (1ULL << (reloc_entry
->howto
->bitsize
- 1))
1678 >= 1ULL << reloc_entry
->howto
->bitsize
))
1679 return bfd_reloc_overflow
;
1680 return bfd_reloc_ok
;
1683 static bfd_reloc_status_type
1684 ppc64_elf_unhandled_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1685 void *data
, asection
*input_section
,
1686 bfd
*output_bfd
, char **error_message
)
1688 /* If this is a relocatable link (output_bfd test tells us), just
1689 call the generic function. Any adjustment will be done at final
1691 if (output_bfd
!= NULL
)
1692 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1693 input_section
, output_bfd
, error_message
);
1695 if (error_message
!= NULL
)
1697 static char buf
[60];
1698 sprintf (buf
, "generic linker can't handle %s",
1699 reloc_entry
->howto
->name
);
1700 *error_message
= buf
;
1702 return bfd_reloc_dangerous
;
1705 /* Track GOT entries needed for a given symbol. We might need more
1706 than one got entry per symbol. */
1709 struct got_entry
*next
;
1711 /* The symbol addend that we'll be placing in the GOT. */
1714 /* Unlike other ELF targets, we use separate GOT entries for the same
1715 symbol referenced from different input files. This is to support
1716 automatic multiple TOC/GOT sections, where the TOC base can vary
1717 from one input file to another. After partitioning into TOC groups
1718 we merge entries within the group.
1720 Point to the BFD owning this GOT entry. */
1723 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
1724 TLS_TPREL or TLS_DTPREL for tls entries. */
1725 unsigned char tls_type
;
1727 /* Non-zero if got.ent points to real entry. */
1728 unsigned char is_indirect
;
1730 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
1733 bfd_signed_vma refcount
;
1735 struct got_entry
*ent
;
1739 /* The same for PLT. */
1742 struct plt_entry
*next
;
1748 bfd_signed_vma refcount
;
1753 struct ppc64_elf_obj_tdata
1755 struct elf_obj_tdata elf
;
1757 /* Shortcuts to dynamic linker sections. */
1761 /* Used during garbage collection. We attach global symbols defined
1762 on removed .opd entries to this section so that the sym is removed. */
1763 asection
*deleted_section
;
1765 /* TLS local dynamic got entry handling. Support for multiple GOT
1766 sections means we potentially need one of these for each input bfd. */
1767 struct got_entry tlsld_got
;
1771 /* A copy of relocs before they are modified for --emit-relocs. */
1772 Elf_Internal_Rela
*relocs
;
1774 /* Section contents. */
1778 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
1779 the reloc to be in the range -32768 to 32767. */
1780 unsigned int has_small_toc_reloc
: 1;
1782 /* Set if toc/got ha relocs detected not using r2, or lo reloc
1783 instruction not one we handle. */
1784 unsigned int unexpected_toc_insn
: 1;
1786 /* Set if PLT/GOT/TOC relocs that can be optimised are present in
1788 unsigned int has_optrel
: 1;
1791 #define ppc64_elf_tdata(bfd) \
1792 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
1794 #define ppc64_tlsld_got(bfd) \
1795 (&ppc64_elf_tdata (bfd)->tlsld_got)
1797 #define is_ppc64_elf(bfd) \
1798 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
1799 && elf_object_id (bfd) == PPC64_ELF_DATA)
1801 /* Override the generic function because we store some extras. */
1804 ppc64_elf_mkobject (bfd
*abfd
)
1806 return bfd_elf_allocate_object (abfd
, sizeof (struct ppc64_elf_obj_tdata
),
1810 /* Fix bad default arch selected for a 64 bit input bfd when the
1811 default is 32 bit. Also select arch based on apuinfo. */
1814 ppc64_elf_object_p (bfd
*abfd
)
1816 if (!abfd
->arch_info
->the_default
)
1819 if (abfd
->arch_info
->bits_per_word
== 32)
1821 Elf_Internal_Ehdr
*i_ehdr
= elf_elfheader (abfd
);
1823 if (i_ehdr
->e_ident
[EI_CLASS
] == ELFCLASS64
)
1825 /* Relies on arch after 32 bit default being 64 bit default. */
1826 abfd
->arch_info
= abfd
->arch_info
->next
;
1827 BFD_ASSERT (abfd
->arch_info
->bits_per_word
== 64);
1830 return _bfd_elf_ppc_set_arch (abfd
);
1833 /* Support for core dump NOTE sections. */
1836 ppc64_elf_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
1838 size_t offset
, size
;
1840 if (note
->descsz
!= 504)
1844 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
1847 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 32);
1853 /* Make a ".reg/999" section. */
1854 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
1855 size
, note
->descpos
+ offset
);
1859 ppc64_elf_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
1861 if (note
->descsz
!= 136)
1864 elf_tdata (abfd
)->core
->pid
1865 = bfd_get_32 (abfd
, note
->descdata
+ 24);
1866 elf_tdata (abfd
)->core
->program
1867 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 40, 16);
1868 elf_tdata (abfd
)->core
->command
1869 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 56, 80);
1875 ppc64_elf_write_core_note (bfd
*abfd
, char *buf
, int *bufsiz
, int note_type
,
1885 char data
[136] ATTRIBUTE_NONSTRING
;
1888 va_start (ap
, note_type
);
1889 memset (data
, 0, sizeof (data
));
1890 strncpy (data
+ 40, va_arg (ap
, const char *), 16);
1891 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
1893 /* GCC 8.0 and 8.1 warn about 80 equals destination size with
1894 -Wstringop-truncation:
1895 https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85643
1897 DIAGNOSTIC_IGNORE_STRINGOP_TRUNCATION
;
1899 strncpy (data
+ 56, va_arg (ap
, const char *), 80);
1900 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
1904 return elfcore_write_note (abfd
, buf
, bufsiz
,
1905 "CORE", note_type
, data
, sizeof (data
));
1916 va_start (ap
, note_type
);
1917 memset (data
, 0, 112);
1918 pid
= va_arg (ap
, long);
1919 bfd_put_32 (abfd
, pid
, data
+ 32);
1920 cursig
= va_arg (ap
, int);
1921 bfd_put_16 (abfd
, cursig
, data
+ 12);
1922 greg
= va_arg (ap
, const void *);
1923 memcpy (data
+ 112, greg
, 384);
1924 memset (data
+ 496, 0, 8);
1926 return elfcore_write_note (abfd
, buf
, bufsiz
,
1927 "CORE", note_type
, data
, sizeof (data
));
1932 /* Add extra PPC sections. */
1934 static const struct bfd_elf_special_section ppc64_elf_special_sections
[] =
1936 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS
, 0 },
1937 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
1938 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
1939 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
1940 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
1941 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
1942 { NULL
, 0, 0, 0, 0 }
1945 enum _ppc64_sec_type
{
1951 struct _ppc64_elf_section_data
1953 struct bfd_elf_section_data elf
;
1957 /* An array with one entry for each opd function descriptor,
1958 and some spares since opd entries may be either 16 or 24 bytes. */
1959 #define OPD_NDX(OFF) ((OFF) >> 4)
1960 struct _opd_sec_data
1962 /* Points to the function code section for local opd entries. */
1963 asection
**func_sec
;
1965 /* After editing .opd, adjust references to opd local syms. */
1969 /* An array for toc sections, indexed by offset/8. */
1970 struct _toc_sec_data
1972 /* Specifies the relocation symbol index used at a given toc offset. */
1975 /* And the relocation addend. */
1980 enum _ppc64_sec_type sec_type
:2;
1982 /* Flag set when small branches are detected. Used to
1983 select suitable defaults for the stub group size. */
1984 unsigned int has_14bit_branch
:1;
1986 /* Flag set when PLTCALL relocs are detected. */
1987 unsigned int has_pltcall
:1;
1989 /* Flag set when section has PLT/GOT/TOC relocations that can be
1991 unsigned int has_optrel
:1;
1994 #define ppc64_elf_section_data(sec) \
1995 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
1998 ppc64_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
2000 if (!sec
->used_by_bfd
)
2002 struct _ppc64_elf_section_data
*sdata
;
2003 bfd_size_type amt
= sizeof (*sdata
);
2005 sdata
= bfd_zalloc (abfd
, amt
);
2008 sec
->used_by_bfd
= sdata
;
2011 return _bfd_elf_new_section_hook (abfd
, sec
);
2014 static struct _opd_sec_data
*
2015 get_opd_info (asection
* sec
)
2018 && ppc64_elf_section_data (sec
) != NULL
2019 && ppc64_elf_section_data (sec
)->sec_type
== sec_opd
)
2020 return &ppc64_elf_section_data (sec
)->u
.opd
;
2024 /* Parameters for the qsort hook. */
2025 static bfd_boolean synthetic_relocatable
;
2026 static asection
*synthetic_opd
;
2028 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
2031 compare_symbols (const void *ap
, const void *bp
)
2033 const asymbol
*a
= *(const asymbol
**) ap
;
2034 const asymbol
*b
= *(const asymbol
**) bp
;
2036 /* Section symbols first. */
2037 if ((a
->flags
& BSF_SECTION_SYM
) && !(b
->flags
& BSF_SECTION_SYM
))
2039 if (!(a
->flags
& BSF_SECTION_SYM
) && (b
->flags
& BSF_SECTION_SYM
))
2042 /* then .opd symbols. */
2043 if (synthetic_opd
!= NULL
)
2045 if (strcmp (a
->section
->name
, ".opd") == 0
2046 && strcmp (b
->section
->name
, ".opd") != 0)
2048 if (strcmp (a
->section
->name
, ".opd") != 0
2049 && strcmp (b
->section
->name
, ".opd") == 0)
2053 /* then other code symbols. */
2054 if (((a
->section
->flags
& (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
))
2055 == (SEC_CODE
| SEC_ALLOC
))
2056 && ((b
->section
->flags
& (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
))
2057 != (SEC_CODE
| SEC_ALLOC
)))
2060 if (((a
->section
->flags
& (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
))
2061 != (SEC_CODE
| SEC_ALLOC
))
2062 && ((b
->section
->flags
& (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
))
2063 == (SEC_CODE
| SEC_ALLOC
)))
2066 if (synthetic_relocatable
)
2068 if (a
->section
->id
< b
->section
->id
)
2071 if (a
->section
->id
> b
->section
->id
)
2075 if (a
->value
+ a
->section
->vma
< b
->value
+ b
->section
->vma
)
2078 if (a
->value
+ a
->section
->vma
> b
->value
+ b
->section
->vma
)
2081 /* For syms with the same value, prefer strong dynamic global function
2082 syms over other syms. */
2083 if ((a
->flags
& BSF_GLOBAL
) != 0 && (b
->flags
& BSF_GLOBAL
) == 0)
2086 if ((a
->flags
& BSF_GLOBAL
) == 0 && (b
->flags
& BSF_GLOBAL
) != 0)
2089 if ((a
->flags
& BSF_FUNCTION
) != 0 && (b
->flags
& BSF_FUNCTION
) == 0)
2092 if ((a
->flags
& BSF_FUNCTION
) == 0 && (b
->flags
& BSF_FUNCTION
) != 0)
2095 if ((a
->flags
& BSF_WEAK
) == 0 && (b
->flags
& BSF_WEAK
) != 0)
2098 if ((a
->flags
& BSF_WEAK
) != 0 && (b
->flags
& BSF_WEAK
) == 0)
2101 if ((a
->flags
& BSF_DYNAMIC
) != 0 && (b
->flags
& BSF_DYNAMIC
) == 0)
2104 if ((a
->flags
& BSF_DYNAMIC
) == 0 && (b
->flags
& BSF_DYNAMIC
) != 0)
2107 /* Finally, sort on where the symbol is in memory. The symbols will
2108 be in at most two malloc'd blocks, one for static syms, one for
2109 dynamic syms, and we distinguish the two blocks above by testing
2110 BSF_DYNAMIC. Since we are sorting the symbol pointers which were
2111 originally in the same order as the symbols (and we're not
2112 sorting the symbols themselves), this ensures a stable sort. */
2120 /* Search SYMS for a symbol of the given VALUE. */
2123 sym_exists_at (asymbol
**syms
, size_t lo
, size_t hi
, unsigned int id
,
2128 if (id
== (unsigned) -1)
2132 mid
= (lo
+ hi
) >> 1;
2133 if (syms
[mid
]->value
+ syms
[mid
]->section
->vma
< value
)
2135 else if (syms
[mid
]->value
+ syms
[mid
]->section
->vma
> value
)
2145 mid
= (lo
+ hi
) >> 1;
2146 if (syms
[mid
]->section
->id
< id
)
2148 else if (syms
[mid
]->section
->id
> id
)
2150 else if (syms
[mid
]->value
< value
)
2152 else if (syms
[mid
]->value
> value
)
2162 section_covers_vma (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*section
, void *ptr
)
2164 bfd_vma vma
= *(bfd_vma
*) ptr
;
2165 return ((section
->flags
& SEC_ALLOC
) != 0
2166 && section
->vma
<= vma
2167 && vma
< section
->vma
+ section
->size
);
2170 /* Create synthetic symbols, effectively restoring "dot-symbol" function
2171 entry syms. Also generate @plt symbols for the glink branch table.
2172 Returns count of synthetic symbols in RET or -1 on error. */
2175 ppc64_elf_get_synthetic_symtab (bfd
*abfd
,
2176 long static_count
, asymbol
**static_syms
,
2177 long dyn_count
, asymbol
**dyn_syms
,
2183 size_t symcount
, codesecsym
, codesecsymend
, secsymend
, opdsymend
;
2184 asection
*opd
= NULL
;
2185 bfd_boolean relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2187 int abi
= abiversion (abfd
);
2193 opd
= bfd_get_section_by_name (abfd
, ".opd");
2194 if (opd
== NULL
&& abi
== 1)
2206 symcount
= static_count
;
2208 symcount
+= dyn_count
;
2212 syms
= bfd_malloc ((symcount
+ 1) * sizeof (*syms
));
2216 if (!relocatable
&& static_count
!= 0 && dyn_count
!= 0)
2218 /* Use both symbol tables. */
2219 memcpy (syms
, static_syms
, static_count
* sizeof (*syms
));
2220 memcpy (syms
+ static_count
, dyn_syms
,
2221 (dyn_count
+ 1) * sizeof (*syms
));
2223 else if (!relocatable
&& static_count
== 0)
2224 memcpy (syms
, dyn_syms
, (symcount
+ 1) * sizeof (*syms
));
2226 memcpy (syms
, static_syms
, (symcount
+ 1) * sizeof (*syms
));
2228 /* Trim uninteresting symbols. Interesting symbols are section,
2229 function, and notype symbols. */
2230 for (i
= 0, j
= 0; i
< symcount
; ++i
)
2231 if ((syms
[i
]->flags
& (BSF_FILE
| BSF_OBJECT
| BSF_THREAD_LOCAL
2232 | BSF_RELC
| BSF_SRELC
)) == 0)
2233 syms
[j
++] = syms
[i
];
2236 synthetic_relocatable
= relocatable
;
2237 synthetic_opd
= opd
;
2238 qsort (syms
, symcount
, sizeof (*syms
), compare_symbols
);
2240 if (!relocatable
&& symcount
> 1)
2242 /* Trim duplicate syms, since we may have merged the normal
2243 and dynamic symbols. Actually, we only care about syms
2244 that have different values, so trim any with the same
2245 value. Don't consider ifunc and ifunc resolver symbols
2246 duplicates however, because GDB wants to know whether a
2247 text symbol is an ifunc resolver. */
2248 for (i
= 1, j
= 1; i
< symcount
; ++i
)
2250 const asymbol
*s0
= syms
[i
- 1];
2251 const asymbol
*s1
= syms
[i
];
2253 if ((s0
->value
+ s0
->section
->vma
2254 != s1
->value
+ s1
->section
->vma
)
2255 || ((s0
->flags
& BSF_GNU_INDIRECT_FUNCTION
)
2256 != (s1
->flags
& BSF_GNU_INDIRECT_FUNCTION
)))
2257 syms
[j
++] = syms
[i
];
2263 /* Note that here and in compare_symbols we can't compare opd and
2264 sym->section directly. With separate debug info files, the
2265 symbols will be extracted from the debug file while abfd passed
2266 to this function is the real binary. */
2267 if (strcmp (syms
[i
]->section
->name
, ".opd") == 0)
2271 for (; i
< symcount
; ++i
)
2272 if (((syms
[i
]->section
->flags
& (SEC_CODE
| SEC_ALLOC
2273 | SEC_THREAD_LOCAL
))
2274 != (SEC_CODE
| SEC_ALLOC
))
2275 || (syms
[i
]->flags
& BSF_SECTION_SYM
) == 0)
2279 for (; i
< symcount
; ++i
)
2280 if ((syms
[i
]->flags
& BSF_SECTION_SYM
) == 0)
2284 for (; i
< symcount
; ++i
)
2285 if (strcmp (syms
[i
]->section
->name
, ".opd") != 0)
2289 for (; i
< symcount
; ++i
)
2290 if (((syms
[i
]->section
->flags
2291 & (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
)))
2292 != (SEC_CODE
| SEC_ALLOC
))
2300 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
2305 if (opdsymend
== secsymend
)
2308 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
2309 relcount
= (opd
->flags
& SEC_RELOC
) ? opd
->reloc_count
: 0;
2313 if (!(*slurp_relocs
) (abfd
, opd
, static_syms
, FALSE
))
2320 for (i
= secsymend
, r
= opd
->relocation
; i
< opdsymend
; ++i
)
2324 while (r
< opd
->relocation
+ relcount
2325 && r
->address
< syms
[i
]->value
+ opd
->vma
)
2328 if (r
== opd
->relocation
+ relcount
)
2331 if (r
->address
!= syms
[i
]->value
+ opd
->vma
)
2334 if (r
->howto
->type
!= R_PPC64_ADDR64
)
2337 sym
= *r
->sym_ptr_ptr
;
2338 if (!sym_exists_at (syms
, opdsymend
, symcount
,
2339 sym
->section
->id
, sym
->value
+ r
->addend
))
2342 size
+= sizeof (asymbol
);
2343 size
+= strlen (syms
[i
]->name
) + 2;
2349 s
= *ret
= bfd_malloc (size
);
2356 names
= (char *) (s
+ count
);
2358 for (i
= secsymend
, r
= opd
->relocation
; i
< opdsymend
; ++i
)
2362 while (r
< opd
->relocation
+ relcount
2363 && r
->address
< syms
[i
]->value
+ opd
->vma
)
2366 if (r
== opd
->relocation
+ relcount
)
2369 if (r
->address
!= syms
[i
]->value
+ opd
->vma
)
2372 if (r
->howto
->type
!= R_PPC64_ADDR64
)
2375 sym
= *r
->sym_ptr_ptr
;
2376 if (!sym_exists_at (syms
, opdsymend
, symcount
,
2377 sym
->section
->id
, sym
->value
+ r
->addend
))
2382 s
->flags
|= BSF_SYNTHETIC
;
2383 s
->section
= sym
->section
;
2384 s
->value
= sym
->value
+ r
->addend
;
2387 len
= strlen (syms
[i
]->name
);
2388 memcpy (names
, syms
[i
]->name
, len
+ 1);
2390 /* Have udata.p point back to the original symbol this
2391 synthetic symbol was derived from. */
2392 s
->udata
.p
= syms
[i
];
2399 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
2400 bfd_byte
*contents
= NULL
;
2402 size_t plt_count
= 0;
2403 bfd_vma glink_vma
= 0, resolv_vma
= 0;
2404 asection
*dynamic
, *glink
= NULL
, *relplt
= NULL
;
2407 if (opd
!= NULL
&& !bfd_malloc_and_get_section (abfd
, opd
, &contents
))
2409 free_contents_and_exit_err
:
2411 free_contents_and_exit
:
2418 for (i
= secsymend
; i
< opdsymend
; ++i
)
2422 /* Ignore bogus symbols. */
2423 if (syms
[i
]->value
> opd
->size
- 8)
2426 ent
= bfd_get_64 (abfd
, contents
+ syms
[i
]->value
);
2427 if (!sym_exists_at (syms
, opdsymend
, symcount
, -1, ent
))
2430 size
+= sizeof (asymbol
);
2431 size
+= strlen (syms
[i
]->name
) + 2;
2435 /* Get start of .glink stubs from DT_PPC64_GLINK. */
2437 && (dynamic
= bfd_get_section_by_name (abfd
, ".dynamic")) != NULL
)
2439 bfd_byte
*dynbuf
, *extdyn
, *extdynend
;
2441 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
2443 if (!bfd_malloc_and_get_section (abfd
, dynamic
, &dynbuf
))
2444 goto free_contents_and_exit_err
;
2446 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
2447 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
2450 extdynend
= extdyn
+ dynamic
->size
;
2451 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
2453 Elf_Internal_Dyn dyn
;
2454 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
2456 if (dyn
.d_tag
== DT_NULL
)
2459 if (dyn
.d_tag
== DT_PPC64_GLINK
)
2461 /* The first glink stub starts at DT_PPC64_GLINK plus 32.
2462 See comment in ppc64_elf_finish_dynamic_sections. */
2463 glink_vma
= dyn
.d_un
.d_val
+ 8 * 4;
2464 /* The .glink section usually does not survive the final
2465 link; search for the section (usually .text) where the
2466 glink stubs now reside. */
2467 glink
= bfd_sections_find_if (abfd
, section_covers_vma
,
2478 /* Determine __glink trampoline by reading the relative branch
2479 from the first glink stub. */
2481 unsigned int off
= 0;
2483 while (bfd_get_section_contents (abfd
, glink
, buf
,
2484 glink_vma
+ off
- glink
->vma
, 4))
2486 unsigned int insn
= bfd_get_32 (abfd
, buf
);
2488 if ((insn
& ~0x3fffffc) == 0)
2491 = glink_vma
+ off
+ (insn
^ 0x2000000) - 0x2000000;
2500 size
+= sizeof (asymbol
) + sizeof ("__glink_PLTresolve");
2502 relplt
= bfd_get_section_by_name (abfd
, ".rela.plt");
2505 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
2506 if (!(*slurp_relocs
) (abfd
, relplt
, dyn_syms
, TRUE
))
2507 goto free_contents_and_exit_err
;
2509 plt_count
= relplt
->size
/ sizeof (Elf64_External_Rela
);
2510 size
+= plt_count
* sizeof (asymbol
);
2512 p
= relplt
->relocation
;
2513 for (i
= 0; i
< plt_count
; i
++, p
++)
2515 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
2517 size
+= sizeof ("+0x") - 1 + 16;
2523 goto free_contents_and_exit
;
2524 s
= *ret
= bfd_malloc (size
);
2526 goto free_contents_and_exit_err
;
2528 names
= (char *) (s
+ count
+ plt_count
+ (resolv_vma
!= 0));
2530 for (i
= secsymend
; i
< opdsymend
; ++i
)
2534 if (syms
[i
]->value
> opd
->size
- 8)
2537 ent
= bfd_get_64 (abfd
, contents
+ syms
[i
]->value
);
2538 if (!sym_exists_at (syms
, opdsymend
, symcount
, -1, ent
))
2542 asection
*sec
= abfd
->sections
;
2549 size_t mid
= (lo
+ hi
) >> 1;
2550 if (syms
[mid
]->section
->vma
< ent
)
2552 else if (syms
[mid
]->section
->vma
> ent
)
2556 sec
= syms
[mid
]->section
;
2561 if (lo
>= hi
&& lo
> codesecsym
)
2562 sec
= syms
[lo
- 1]->section
;
2564 for (; sec
!= NULL
; sec
= sec
->next
)
2568 /* SEC_LOAD may not be set if SEC is from a separate debug
2570 if ((sec
->flags
& SEC_ALLOC
) == 0)
2572 if ((sec
->flags
& SEC_CODE
) != 0)
2575 s
->flags
|= BSF_SYNTHETIC
;
2576 s
->value
= ent
- s
->section
->vma
;
2579 len
= strlen (syms
[i
]->name
);
2580 memcpy (names
, syms
[i
]->name
, len
+ 1);
2582 /* Have udata.p point back to the original symbol this
2583 synthetic symbol was derived from. */
2584 s
->udata
.p
= syms
[i
];
2590 if (glink
!= NULL
&& relplt
!= NULL
)
2594 /* Add a symbol for the main glink trampoline. */
2595 memset (s
, 0, sizeof *s
);
2597 s
->flags
= BSF_GLOBAL
| BSF_SYNTHETIC
;
2599 s
->value
= resolv_vma
- glink
->vma
;
2601 memcpy (names
, "__glink_PLTresolve",
2602 sizeof ("__glink_PLTresolve"));
2603 names
+= sizeof ("__glink_PLTresolve");
2608 /* FIXME: It would be very much nicer to put sym@plt on the
2609 stub rather than on the glink branch table entry. The
2610 objdump disassembler would then use a sensible symbol
2611 name on plt calls. The difficulty in doing so is
2612 a) finding the stubs, and,
2613 b) matching stubs against plt entries, and,
2614 c) there can be multiple stubs for a given plt entry.
2616 Solving (a) could be done by code scanning, but older
2617 ppc64 binaries used different stubs to current code.
2618 (b) is the tricky one since you need to known the toc
2619 pointer for at least one function that uses a pic stub to
2620 be able to calculate the plt address referenced.
2621 (c) means gdb would need to set multiple breakpoints (or
2622 find the glink branch itself) when setting breakpoints
2623 for pending shared library loads. */
2624 p
= relplt
->relocation
;
2625 for (i
= 0; i
< plt_count
; i
++, p
++)
2629 *s
= **p
->sym_ptr_ptr
;
2630 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
2631 we are defining a symbol, ensure one of them is set. */
2632 if ((s
->flags
& BSF_LOCAL
) == 0)
2633 s
->flags
|= BSF_GLOBAL
;
2634 s
->flags
|= BSF_SYNTHETIC
;
2636 s
->value
= glink_vma
- glink
->vma
;
2639 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
2640 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
2644 memcpy (names
, "+0x", sizeof ("+0x") - 1);
2645 names
+= sizeof ("+0x") - 1;
2646 bfd_sprintf_vma (abfd
, names
, p
->addend
);
2647 names
+= strlen (names
);
2649 memcpy (names
, "@plt", sizeof ("@plt"));
2650 names
+= sizeof ("@plt");
2670 /* The following functions are specific to the ELF linker, while
2671 functions above are used generally. Those named ppc64_elf_* are
2672 called by the main ELF linker code. They appear in this file more
2673 or less in the order in which they are called. eg.
2674 ppc64_elf_check_relocs is called early in the link process,
2675 ppc64_elf_finish_dynamic_sections is one of the last functions
2678 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
2679 functions have both a function code symbol and a function descriptor
2680 symbol. A call to foo in a relocatable object file looks like:
2687 The function definition in another object file might be:
2691 . .quad .TOC.@tocbase
2697 When the linker resolves the call during a static link, the branch
2698 unsurprisingly just goes to .foo and the .opd information is unused.
2699 If the function definition is in a shared library, things are a little
2700 different: The call goes via a plt call stub, the opd information gets
2701 copied to the plt, and the linker patches the nop.
2709 . std 2,40(1) # in practice, the call stub
2710 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
2711 . addi 11,11,Lfoo@toc@l # this is the general idea
2719 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
2721 The "reloc ()" notation is supposed to indicate that the linker emits
2722 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
2725 What are the difficulties here? Well, firstly, the relocations
2726 examined by the linker in check_relocs are against the function code
2727 sym .foo, while the dynamic relocation in the plt is emitted against
2728 the function descriptor symbol, foo. Somewhere along the line, we need
2729 to carefully copy dynamic link information from one symbol to the other.
2730 Secondly, the generic part of the elf linker will make .foo a dynamic
2731 symbol as is normal for most other backends. We need foo dynamic
2732 instead, at least for an application final link. However, when
2733 creating a shared library containing foo, we need to have both symbols
2734 dynamic so that references to .foo are satisfied during the early
2735 stages of linking. Otherwise the linker might decide to pull in a
2736 definition from some other object, eg. a static library.
2738 Update: As of August 2004, we support a new convention. Function
2739 calls may use the function descriptor symbol, ie. "bl foo". This
2740 behaves exactly as "bl .foo". */
2742 /* Of those relocs that might be copied as dynamic relocs, this
2743 function selects those that must be copied when linking a shared
2744 library or PIE, even when the symbol is local. */
2747 must_be_dyn_reloc (struct bfd_link_info
*info
,
2748 enum elf_ppc64_reloc_type r_type
)
2753 /* Only relative relocs can be resolved when the object load
2754 address isn't fixed. DTPREL64 is excluded because the
2755 dynamic linker needs to differentiate global dynamic from
2756 local dynamic __tls_index pairs when PPC64_OPT_TLS is set. */
2763 case R_PPC64_TOC16_DS
:
2764 case R_PPC64_TOC16_LO
:
2765 case R_PPC64_TOC16_HI
:
2766 case R_PPC64_TOC16_HA
:
2767 case R_PPC64_TOC16_LO_DS
:
2770 case R_PPC64_TPREL16
:
2771 case R_PPC64_TPREL16_LO
:
2772 case R_PPC64_TPREL16_HI
:
2773 case R_PPC64_TPREL16_HA
:
2774 case R_PPC64_TPREL16_DS
:
2775 case R_PPC64_TPREL16_LO_DS
:
2776 case R_PPC64_TPREL16_HIGH
:
2777 case R_PPC64_TPREL16_HIGHA
:
2778 case R_PPC64_TPREL16_HIGHER
:
2779 case R_PPC64_TPREL16_HIGHERA
:
2780 case R_PPC64_TPREL16_HIGHEST
:
2781 case R_PPC64_TPREL16_HIGHESTA
:
2782 case R_PPC64_TPREL64
:
2783 case R_PPC64_TPREL34
:
2784 /* These relocations are relative but in a shared library the
2785 linker doesn't know the thread pointer base. */
2786 return bfd_link_dll (info
);
2790 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
2791 copying dynamic variables from a shared lib into an app's .dynbss
2792 section, and instead use a dynamic relocation to point into the
2793 shared lib. With code that gcc generates it is vital that this be
2794 enabled; In the PowerPC64 ELFv1 ABI the address of a function is
2795 actually the address of a function descriptor which resides in the
2796 .opd section. gcc uses the descriptor directly rather than going
2797 via the GOT as some other ABIs do, which means that initialized
2798 function pointers reference the descriptor. Thus, a function
2799 pointer initialized to the address of a function in a shared
2800 library will either require a .dynbss copy and a copy reloc, or a
2801 dynamic reloc. Using a .dynbss copy redefines the function
2802 descriptor symbol to point to the copy. This presents a problem as
2803 a PLT entry for that function is also initialized from the function
2804 descriptor symbol and the copy may not be initialized first. */
2805 #define ELIMINATE_COPY_RELOCS 1
2807 /* Section name for stubs is the associated section name plus this
2809 #define STUB_SUFFIX ".stub"
2812 ppc_stub_long_branch:
2813 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
2814 destination, but a 24 bit branch in a stub section will reach.
2817 ppc_stub_plt_branch:
2818 Similar to the above, but a 24 bit branch in the stub section won't
2819 reach its destination.
2820 . addis %r11,%r2,xxx@toc@ha
2821 . ld %r12,xxx@toc@l(%r11)
2826 Used to call a function in a shared library. If it so happens that
2827 the plt entry referenced crosses a 64k boundary, then an extra
2828 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
2829 ppc_stub_plt_call_r2save starts with "std %r2,40(%r1)".
2830 . addis %r11,%r2,xxx@toc@ha
2831 . ld %r12,xxx+0@toc@l(%r11)
2833 . ld %r2,xxx+8@toc@l(%r11)
2834 . ld %r11,xxx+16@toc@l(%r11)
2837 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
2838 code to adjust the value and save r2 to support multiple toc sections.
2839 A ppc_stub_long_branch with an r2 offset looks like:
2841 . addis %r2,%r2,off@ha
2842 . addi %r2,%r2,off@l
2845 A ppc_stub_plt_branch with an r2 offset looks like:
2847 . addis %r11,%r2,xxx@toc@ha
2848 . ld %r12,xxx@toc@l(%r11)
2849 . addis %r2,%r2,off@ha
2850 . addi %r2,%r2,off@l
2854 All of the above stubs are shown as their ELFv1 variants. ELFv2
2855 variants exist too, simpler for plt calls since a new toc pointer
2856 and static chain are not loaded by the stub. In addition, ELFv2
2857 has some more complex stubs to handle calls marked with NOTOC
2858 relocs from functions where r2 is not a valid toc pointer. These
2859 come in two flavours, the ones shown below, and _both variants that
2860 start with "std %r2,24(%r1)" to save r2 in the unlikely event that
2861 one call is from a function where r2 is used as the toc pointer but
2862 needs a toc adjusting stub for small-model multi-toc, and another
2863 call is from a function where r2 is not valid.
2864 ppc_stub_long_branch_notoc:
2870 . addis %r12,%r11,dest-1b@ha
2871 . addi %r12,%r12,dest-1b@l
2874 ppc_stub_plt_branch_notoc:
2880 . lis %r12,xxx-1b@highest
2881 . ori %r12,%r12,xxx-1b@higher
2883 . oris %r12,%r12,xxx-1b@high
2884 . ori %r12,%r12,xxx-1b@l
2885 . add %r12,%r11,%r12
2889 ppc_stub_plt_call_notoc:
2895 . lis %r12,xxx-1b@highest
2896 . ori %r12,%r12,xxx-1b@higher
2898 . oris %r12,%r12,xxx-1b@high
2899 . ori %r12,%r12,xxx-1b@l
2900 . ldx %r12,%r11,%r12
2904 There are also ELFv1 powerxx variants of these stubs.
2905 ppc_stub_long_branch_notoc:
2906 . pla %r12,dest@pcrel
2908 ppc_stub_plt_branch_notoc:
2909 . lis %r11,(dest-1f)@highesta34
2910 . ori %r11,%r11,(dest-1f)@highera34
2912 . 1: pla %r12,dest@pcrel
2913 . add %r12,%r11,%r12
2916 ppc_stub_plt_call_notoc:
2917 . lis %r11,(xxx-1f)@highesta34
2918 . ori %r11,%r11,(xxx-1f)@highera34
2920 . 1: pla %r12,xxx@pcrel
2921 . ldx %r12,%r11,%r12
2925 In cases where the high instructions would add zero, they are
2926 omitted and following instructions modified in some cases.
2927 For example, a powerxx ppc_stub_plt_call_notoc might simplify down
2929 . pld %r12,xxx@pcrel
2933 For a given stub group (a set of sections all using the same toc
2934 pointer value) there will be just one stub type used for any
2935 particular function symbol. For example, if printf is called from
2936 code with the tocsave optimization (ie. r2 saved in function
2937 prologue) and therefore calls use a ppc_stub_plt_call linkage stub,
2938 and from other code without the tocsave optimization requiring a
2939 ppc_stub_plt_call_r2save linkage stub, a single stub of the latter
2940 type will be created. Calls with the tocsave optimization will
2941 enter this stub after the instruction saving r2. A similar
2942 situation exists when calls are marked with R_PPC64_REL24_NOTOC
2943 relocations. These require a ppc_stub_plt_call_notoc linkage stub
2944 to call an external function like printf. If other calls to printf
2945 require a ppc_stub_plt_call linkage stub then a single
2946 ppc_stub_plt_call_notoc linkage stub will be used for both types of
2947 call. If other calls to printf require a ppc_stub_plt_call_r2save
2948 linkage stub then a single ppc_stub_plt_call_both linkage stub will
2949 be created and calls not requiring r2 to be saved will enter the
2950 stub after the r2 save instruction. There is an analogous
2951 hierarchy of long branch and plt branch stubs for local call
2957 ppc_stub_long_branch
,
2958 ppc_stub_long_branch_r2off
,
2959 ppc_stub_long_branch_notoc
,
2960 ppc_stub_long_branch_both
, /* r2off and notoc variants both needed. */
2961 ppc_stub_plt_branch
,
2962 ppc_stub_plt_branch_r2off
,
2963 ppc_stub_plt_branch_notoc
,
2964 ppc_stub_plt_branch_both
,
2966 ppc_stub_plt_call_r2save
,
2967 ppc_stub_plt_call_notoc
,
2968 ppc_stub_plt_call_both
,
2969 ppc_stub_global_entry
,
2973 /* Information on stub grouping. */
2976 /* The stub section. */
2978 /* This is the section to which stubs in the group will be attached. */
2981 struct map_stub
*next
;
2982 /* Whether to emit a copy of register save/restore functions in this
2985 /* Current offset within stubs after the insn restoring lr in a
2986 _notoc or _both stub using bcl for pc-relative addressing, or
2987 after the insn restoring lr in a __tls_get_addr_opt plt stub. */
2988 unsigned int lr_restore
;
2989 /* Accumulated size of EH info emitted to describe return address
2990 if stubs modify lr. Does not include 17 byte FDE header. */
2991 unsigned int eh_size
;
2992 /* Offset in glink_eh_frame to the start of EH info for this group. */
2993 unsigned int eh_base
;
2996 struct ppc_stub_hash_entry
2998 /* Base hash table entry structure. */
2999 struct bfd_hash_entry root
;
3001 enum ppc_stub_type stub_type
;
3003 /* Group information. */
3004 struct map_stub
*group
;
3006 /* Offset within stub_sec of the beginning of this stub. */
3007 bfd_vma stub_offset
;
3009 /* Given the symbol's value and its section we can determine its final
3010 value when building the stubs (so the stub knows where to jump. */
3011 bfd_vma target_value
;
3012 asection
*target_section
;
3014 /* The symbol table entry, if any, that this was derived from. */
3015 struct ppc_link_hash_entry
*h
;
3016 struct plt_entry
*plt_ent
;
3019 unsigned char symtype
;
3021 /* Symbol st_other. */
3022 unsigned char other
;
3025 struct ppc_branch_hash_entry
3027 /* Base hash table entry structure. */
3028 struct bfd_hash_entry root
;
3030 /* Offset within branch lookup table. */
3031 unsigned int offset
;
3033 /* Generation marker. */
3037 /* Used to track dynamic relocations for local symbols. */
3038 struct ppc_dyn_relocs
3040 struct ppc_dyn_relocs
*next
;
3042 /* The input section of the reloc. */
3045 /* Total number of relocs copied for the input section. */
3046 unsigned int count
: 31;
3048 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3049 unsigned int ifunc
: 1;
3052 struct ppc_link_hash_entry
3054 struct elf_link_hash_entry elf
;
3058 /* A pointer to the most recently used stub hash entry against this
3060 struct ppc_stub_hash_entry
*stub_cache
;
3062 /* A pointer to the next symbol starting with a '.' */
3063 struct ppc_link_hash_entry
*next_dot_sym
;
3066 /* Track dynamic relocs copied for this symbol. */
3067 struct elf_dyn_relocs
*dyn_relocs
;
3069 /* Link between function code and descriptor symbols. */
3070 struct ppc_link_hash_entry
*oh
;
3072 /* Flag function code and descriptor symbols. */
3073 unsigned int is_func
:1;
3074 unsigned int is_func_descriptor
:1;
3075 unsigned int fake
:1;
3077 /* Whether global opd/toc sym has been adjusted or not.
3078 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3079 should be set for all globals defined in any opd/toc section. */
3080 unsigned int adjust_done
:1;
3082 /* Set if this is an out-of-line register save/restore function,
3083 with non-standard calling convention. */
3084 unsigned int save_res
:1;
3086 /* Set if a duplicate symbol with non-zero localentry is detected,
3087 even when the duplicate symbol does not provide a definition. */
3088 unsigned int non_zero_localentry
:1;
3090 /* Contexts in which symbol is used in the GOT (or TOC).
3091 Bits are or'd into the mask as the corresponding relocs are
3092 encountered during check_relocs, with TLS_TLS being set when any
3093 of the other TLS bits are set. tls_optimize clears bits when
3094 optimizing to indicate the corresponding GOT entry type is not
3095 needed. If set, TLS_TLS is never cleared. tls_optimize may also
3096 set TLS_GDIE when a GD reloc turns into an IE one.
3097 These flags are also kept for local symbols. */
3098 #define TLS_TLS 1 /* Any TLS reloc. */
3099 #define TLS_GD 2 /* GD reloc. */
3100 #define TLS_LD 4 /* LD reloc. */
3101 #define TLS_TPREL 8 /* TPREL reloc, => IE. */
3102 #define TLS_DTPREL 16 /* DTPREL reloc, => LD. */
3103 #define TLS_MARK 32 /* __tls_get_addr call marked. */
3104 #define TLS_GDIE 64 /* GOT TPREL reloc resulting from GD->IE. */
3105 #define TLS_EXPLICIT 256 /* TOC section TLS reloc, not stored. */
3106 unsigned char tls_mask
;
3108 /* The above field is also used to mark function symbols. In which
3109 case TLS_TLS will be 0. */
3110 #define PLT_IFUNC 2 /* STT_GNU_IFUNC. */
3111 #define PLT_KEEP 4 /* inline plt call requires plt entry. */
3112 #define NON_GOT 256 /* local symbol plt, not stored. */
3115 /* ppc64 ELF linker hash table. */
3117 struct ppc_link_hash_table
3119 struct elf_link_hash_table elf
;
3121 /* The stub hash table. */
3122 struct bfd_hash_table stub_hash_table
;
3124 /* Another hash table for plt_branch stubs. */
3125 struct bfd_hash_table branch_hash_table
;
3127 /* Hash table for function prologue tocsave. */
3128 htab_t tocsave_htab
;
3130 /* Various options and other info passed from the linker. */
3131 struct ppc64_elf_params
*params
;
3133 /* The size of sec_info below. */
3134 unsigned int sec_info_arr_size
;
3136 /* Per-section array of extra section info. Done this way rather
3137 than as part of ppc64_elf_section_data so we have the info for
3138 non-ppc64 sections. */
3141 /* Along with elf_gp, specifies the TOC pointer used by this section. */
3146 /* The section group that this section belongs to. */
3147 struct map_stub
*group
;
3148 /* A temp section list pointer. */
3153 /* Linked list of groups. */
3154 struct map_stub
*group
;
3156 /* Temp used when calculating TOC pointers. */
3159 asection
*toc_first_sec
;
3161 /* Used when adding symbols. */
3162 struct ppc_link_hash_entry
*dot_syms
;
3164 /* Shortcuts to get to dynamic linker sections. */
3166 asection
*global_entry
;
3169 asection
*relpltlocal
;
3172 asection
*glink_eh_frame
;
3174 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
3175 struct ppc_link_hash_entry
*tls_get_addr
;
3176 struct ppc_link_hash_entry
*tls_get_addr_fd
;
3178 /* The size of reliplt used by got entry relocs. */
3179 bfd_size_type got_reli_size
;
3182 unsigned long stub_count
[ppc_stub_global_entry
];
3184 /* Number of stubs against global syms. */
3185 unsigned long stub_globals
;
3187 /* Set if we're linking code with function descriptors. */
3188 unsigned int opd_abi
:1;
3190 /* Support for multiple toc sections. */
3191 unsigned int do_multi_toc
:1;
3192 unsigned int multi_toc_needed
:1;
3193 unsigned int second_toc_pass
:1;
3194 unsigned int do_toc_opt
:1;
3196 /* Set if tls optimization is enabled. */
3197 unsigned int do_tls_opt
:1;
3199 /* Set if inline plt calls should be converted to direct calls. */
3200 unsigned int can_convert_all_inline_plt
:1;
3203 unsigned int stub_error
:1;
3205 /* Whether func_desc_adjust needs to be run over symbols. */
3206 unsigned int need_func_desc_adj
:1;
3208 /* Whether there exist local gnu indirect function resolvers,
3209 referenced by dynamic relocations. */
3210 unsigned int local_ifunc_resolver
:1;
3211 unsigned int maybe_local_ifunc_resolver
:1;
3213 /* Whether plt calls for ELFv2 localentry:0 funcs have been optimized. */
3214 unsigned int has_plt_localentry0
:1;
3216 /* Whether calls are made via the PLT from NOTOC functions. */
3217 unsigned int notoc_plt
:1;
3219 /* Whether to use powerxx instructions in linkage stubs. */
3220 unsigned int powerxx_stubs
:1;
3222 /* Incremented every time we size stubs. */
3223 unsigned int stub_iteration
;
3225 /* Small local sym cache. */
3226 struct sym_cache sym_cache
;
3229 /* Rename some of the generic section flags to better document how they
3232 /* Nonzero if this section has TLS related relocations. */
3233 #define has_tls_reloc sec_flg0
3235 /* Nonzero if this section has a call to __tls_get_addr lacking marker
3237 #define nomark_tls_get_addr sec_flg1
3239 /* Nonzero if this section has any toc or got relocs. */
3240 #define has_toc_reloc sec_flg2
3242 /* Nonzero if this section has a call to another section that uses
3244 #define makes_toc_func_call sec_flg3
3246 /* Recursion protection when determining above flag. */
3247 #define call_check_in_progress sec_flg4
3248 #define call_check_done sec_flg5
3250 /* Get the ppc64 ELF linker hash table from a link_info structure. */
3252 #define ppc_hash_table(p) \
3253 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3254 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3256 #define ppc_stub_hash_lookup(table, string, create, copy) \
3257 ((struct ppc_stub_hash_entry *) \
3258 bfd_hash_lookup ((table), (string), (create), (copy)))
3260 #define ppc_branch_hash_lookup(table, string, create, copy) \
3261 ((struct ppc_branch_hash_entry *) \
3262 bfd_hash_lookup ((table), (string), (create), (copy)))
3264 /* Create an entry in the stub hash table. */
3266 static struct bfd_hash_entry
*
3267 stub_hash_newfunc (struct bfd_hash_entry
*entry
,
3268 struct bfd_hash_table
*table
,
3271 /* Allocate the structure if it has not already been allocated by a
3275 entry
= bfd_hash_allocate (table
, sizeof (struct ppc_stub_hash_entry
));
3280 /* Call the allocation method of the superclass. */
3281 entry
= bfd_hash_newfunc (entry
, table
, string
);
3284 struct ppc_stub_hash_entry
*eh
;
3286 /* Initialize the local fields. */
3287 eh
= (struct ppc_stub_hash_entry
*) entry
;
3288 eh
->stub_type
= ppc_stub_none
;
3290 eh
->stub_offset
= 0;
3291 eh
->target_value
= 0;
3292 eh
->target_section
= NULL
;
3301 /* Create an entry in the branch hash table. */
3303 static struct bfd_hash_entry
*
3304 branch_hash_newfunc (struct bfd_hash_entry
*entry
,
3305 struct bfd_hash_table
*table
,
3308 /* Allocate the structure if it has not already been allocated by a
3312 entry
= bfd_hash_allocate (table
, sizeof (struct ppc_branch_hash_entry
));
3317 /* Call the allocation method of the superclass. */
3318 entry
= bfd_hash_newfunc (entry
, table
, string
);
3321 struct ppc_branch_hash_entry
*eh
;
3323 /* Initialize the local fields. */
3324 eh
= (struct ppc_branch_hash_entry
*) entry
;
3332 /* Create an entry in a ppc64 ELF linker hash table. */
3334 static struct bfd_hash_entry
*
3335 link_hash_newfunc (struct bfd_hash_entry
*entry
,
3336 struct bfd_hash_table
*table
,
3339 /* Allocate the structure if it has not already been allocated by a
3343 entry
= bfd_hash_allocate (table
, sizeof (struct ppc_link_hash_entry
));
3348 /* Call the allocation method of the superclass. */
3349 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
3352 struct ppc_link_hash_entry
*eh
= (struct ppc_link_hash_entry
*) entry
;
3354 memset (&eh
->u
.stub_cache
, 0,
3355 (sizeof (struct ppc_link_hash_entry
)
3356 - offsetof (struct ppc_link_hash_entry
, u
.stub_cache
)));
3358 /* When making function calls, old ABI code references function entry
3359 points (dot symbols), while new ABI code references the function
3360 descriptor symbol. We need to make any combination of reference and
3361 definition work together, without breaking archive linking.
3363 For a defined function "foo" and an undefined call to "bar":
3364 An old object defines "foo" and ".foo", references ".bar" (possibly
3366 A new object defines "foo" and references "bar".
3368 A new object thus has no problem with its undefined symbols being
3369 satisfied by definitions in an old object. On the other hand, the
3370 old object won't have ".bar" satisfied by a new object.
3372 Keep a list of newly added dot-symbols. */
3374 if (string
[0] == '.')
3376 struct ppc_link_hash_table
*htab
;
3378 htab
= (struct ppc_link_hash_table
*) table
;
3379 eh
->u
.next_dot_sym
= htab
->dot_syms
;
3380 htab
->dot_syms
= eh
;
3387 struct tocsave_entry
3394 tocsave_htab_hash (const void *p
)
3396 const struct tocsave_entry
*e
= (const struct tocsave_entry
*) p
;
3397 return ((bfd_vma
) (intptr_t) e
->sec
^ e
->offset
) >> 3;
3401 tocsave_htab_eq (const void *p1
, const void *p2
)
3403 const struct tocsave_entry
*e1
= (const struct tocsave_entry
*) p1
;
3404 const struct tocsave_entry
*e2
= (const struct tocsave_entry
*) p2
;
3405 return e1
->sec
== e2
->sec
&& e1
->offset
== e2
->offset
;
3408 /* Destroy a ppc64 ELF linker hash table. */
3411 ppc64_elf_link_hash_table_free (bfd
*obfd
)
3413 struct ppc_link_hash_table
*htab
;
3415 htab
= (struct ppc_link_hash_table
*) obfd
->link
.hash
;
3416 if (htab
->tocsave_htab
)
3417 htab_delete (htab
->tocsave_htab
);
3418 bfd_hash_table_free (&htab
->branch_hash_table
);
3419 bfd_hash_table_free (&htab
->stub_hash_table
);
3420 _bfd_elf_link_hash_table_free (obfd
);
3423 /* Create a ppc64 ELF linker hash table. */
3425 static struct bfd_link_hash_table
*
3426 ppc64_elf_link_hash_table_create (bfd
*abfd
)
3428 struct ppc_link_hash_table
*htab
;
3429 bfd_size_type amt
= sizeof (struct ppc_link_hash_table
);
3431 htab
= bfd_zmalloc (amt
);
3435 if (!_bfd_elf_link_hash_table_init (&htab
->elf
, abfd
, link_hash_newfunc
,
3436 sizeof (struct ppc_link_hash_entry
),
3443 /* Init the stub hash table too. */
3444 if (!bfd_hash_table_init (&htab
->stub_hash_table
, stub_hash_newfunc
,
3445 sizeof (struct ppc_stub_hash_entry
)))
3447 _bfd_elf_link_hash_table_free (abfd
);
3451 /* And the branch hash table. */
3452 if (!bfd_hash_table_init (&htab
->branch_hash_table
, branch_hash_newfunc
,
3453 sizeof (struct ppc_branch_hash_entry
)))
3455 bfd_hash_table_free (&htab
->stub_hash_table
);
3456 _bfd_elf_link_hash_table_free (abfd
);
3460 htab
->tocsave_htab
= htab_try_create (1024,
3464 if (htab
->tocsave_htab
== NULL
)
3466 ppc64_elf_link_hash_table_free (abfd
);
3469 htab
->elf
.root
.hash_table_free
= ppc64_elf_link_hash_table_free
;
3471 /* Initializing two fields of the union is just cosmetic. We really
3472 only care about glist, but when compiled on a 32-bit host the
3473 bfd_vma fields are larger. Setting the bfd_vma to zero makes
3474 debugger inspection of these fields look nicer. */
3475 htab
->elf
.init_got_refcount
.refcount
= 0;
3476 htab
->elf
.init_got_refcount
.glist
= NULL
;
3477 htab
->elf
.init_plt_refcount
.refcount
= 0;
3478 htab
->elf
.init_plt_refcount
.glist
= NULL
;
3479 htab
->elf
.init_got_offset
.offset
= 0;
3480 htab
->elf
.init_got_offset
.glist
= NULL
;
3481 htab
->elf
.init_plt_offset
.offset
= 0;
3482 htab
->elf
.init_plt_offset
.glist
= NULL
;
3484 return &htab
->elf
.root
;
3487 /* Create sections for linker generated code. */
3490 create_linkage_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
3492 struct ppc_link_hash_table
*htab
;
3495 htab
= ppc_hash_table (info
);
3497 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_READONLY
3498 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3499 if (htab
->params
->save_restore_funcs
)
3501 /* Create .sfpr for code to save and restore fp regs. */
3502 htab
->sfpr
= bfd_make_section_anyway_with_flags (dynobj
, ".sfpr",
3504 if (htab
->sfpr
== NULL
3505 || !bfd_set_section_alignment (htab
->sfpr
, 2))
3509 if (bfd_link_relocatable (info
))
3512 /* Create .glink for lazy dynamic linking support. */
3513 htab
->glink
= bfd_make_section_anyway_with_flags (dynobj
, ".glink",
3515 if (htab
->glink
== NULL
3516 || !bfd_set_section_alignment (htab
->glink
, 3))
3519 /* The part of .glink used by global entry stubs, separate so that
3520 it can be aligned appropriately without affecting htab->glink. */
3521 htab
->global_entry
= bfd_make_section_anyway_with_flags (dynobj
, ".glink",
3523 if (htab
->global_entry
== NULL
3524 || !bfd_set_section_alignment (htab
->global_entry
, 2))
3527 if (!info
->no_ld_generated_unwind_info
)
3529 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_HAS_CONTENTS
3530 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3531 htab
->glink_eh_frame
= bfd_make_section_anyway_with_flags (dynobj
,
3534 if (htab
->glink_eh_frame
== NULL
3535 || !bfd_set_section_alignment (htab
->glink_eh_frame
, 2))
3539 flags
= SEC_ALLOC
| SEC_LINKER_CREATED
;
3540 htab
->elf
.iplt
= bfd_make_section_anyway_with_flags (dynobj
, ".iplt", flags
);
3541 if (htab
->elf
.iplt
== NULL
3542 || !bfd_set_section_alignment (htab
->elf
.iplt
, 3))
3545 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
3546 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3548 = bfd_make_section_anyway_with_flags (dynobj
, ".rela.iplt", flags
);
3549 if (htab
->elf
.irelplt
== NULL
3550 || !bfd_set_section_alignment (htab
->elf
.irelplt
, 3))
3553 /* Create branch lookup table for plt_branch stubs. */
3554 flags
= (SEC_ALLOC
| SEC_LOAD
3555 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3556 htab
->brlt
= bfd_make_section_anyway_with_flags (dynobj
, ".branch_lt",
3558 if (htab
->brlt
== NULL
3559 || !bfd_set_section_alignment (htab
->brlt
, 3))
3562 /* Local plt entries, put in .branch_lt but a separate section for
3564 htab
->pltlocal
= bfd_make_section_anyway_with_flags (dynobj
, ".branch_lt",
3566 if (htab
->pltlocal
== NULL
3567 || !bfd_set_section_alignment (htab
->pltlocal
, 3))
3570 if (!bfd_link_pic (info
))
3573 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
3574 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3576 = bfd_make_section_anyway_with_flags (dynobj
, ".rela.branch_lt", flags
);
3577 if (htab
->relbrlt
== NULL
3578 || !bfd_set_section_alignment (htab
->relbrlt
, 3))
3582 = bfd_make_section_anyway_with_flags (dynobj
, ".rela.branch_lt", flags
);
3583 if (htab
->relpltlocal
== NULL
3584 || !bfd_set_section_alignment (htab
->relpltlocal
, 3))
3590 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
3593 ppc64_elf_init_stub_bfd (struct bfd_link_info
*info
,
3594 struct ppc64_elf_params
*params
)
3596 struct ppc_link_hash_table
*htab
;
3598 elf_elfheader (params
->stub_bfd
)->e_ident
[EI_CLASS
] = ELFCLASS64
;
3600 /* Always hook our dynamic sections into the first bfd, which is the
3601 linker created stub bfd. This ensures that the GOT header is at
3602 the start of the output TOC section. */
3603 htab
= ppc_hash_table (info
);
3604 htab
->elf
.dynobj
= params
->stub_bfd
;
3605 htab
->params
= params
;
3607 return create_linkage_sections (htab
->elf
.dynobj
, info
);
3610 /* Build a name for an entry in the stub hash table. */
3613 ppc_stub_name (const asection
*input_section
,
3614 const asection
*sym_sec
,
3615 const struct ppc_link_hash_entry
*h
,
3616 const Elf_Internal_Rela
*rel
)
3621 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
3622 offsets from a sym as a branch target? In fact, we could
3623 probably assume the addend is always zero. */
3624 BFD_ASSERT (((int) rel
->r_addend
& 0xffffffff) == rel
->r_addend
);
3628 len
= 8 + 1 + strlen (h
->elf
.root
.root
.string
) + 1 + 8 + 1;
3629 stub_name
= bfd_malloc (len
);
3630 if (stub_name
== NULL
)
3633 len
= sprintf (stub_name
, "%08x.%s+%x",
3634 input_section
->id
& 0xffffffff,
3635 h
->elf
.root
.root
.string
,
3636 (int) rel
->r_addend
& 0xffffffff);
3640 len
= 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
3641 stub_name
= bfd_malloc (len
);
3642 if (stub_name
== NULL
)
3645 len
= sprintf (stub_name
, "%08x.%x:%x+%x",
3646 input_section
->id
& 0xffffffff,
3647 sym_sec
->id
& 0xffffffff,
3648 (int) ELF64_R_SYM (rel
->r_info
) & 0xffffffff,
3649 (int) rel
->r_addend
& 0xffffffff);
3651 if (len
> 2 && stub_name
[len
- 2] == '+' && stub_name
[len
- 1] == '0')
3652 stub_name
[len
- 2] = 0;
3656 /* Look up an entry in the stub hash. Stub entries are cached because
3657 creating the stub name takes a bit of time. */
3659 static struct ppc_stub_hash_entry
*
3660 ppc_get_stub_entry (const asection
*input_section
,
3661 const asection
*sym_sec
,
3662 struct ppc_link_hash_entry
*h
,
3663 const Elf_Internal_Rela
*rel
,
3664 struct ppc_link_hash_table
*htab
)
3666 struct ppc_stub_hash_entry
*stub_entry
;
3667 struct map_stub
*group
;
3669 /* If this input section is part of a group of sections sharing one
3670 stub section, then use the id of the first section in the group.
3671 Stub names need to include a section id, as there may well be
3672 more than one stub used to reach say, printf, and we need to
3673 distinguish between them. */
3674 group
= htab
->sec_info
[input_section
->id
].u
.group
;
3678 if (h
!= NULL
&& h
->u
.stub_cache
!= NULL
3679 && h
->u
.stub_cache
->h
== h
3680 && h
->u
.stub_cache
->group
== group
)
3682 stub_entry
= h
->u
.stub_cache
;
3688 stub_name
= ppc_stub_name (group
->link_sec
, sym_sec
, h
, rel
);
3689 if (stub_name
== NULL
)
3692 stub_entry
= ppc_stub_hash_lookup (&htab
->stub_hash_table
,
3693 stub_name
, FALSE
, FALSE
);
3695 h
->u
.stub_cache
= stub_entry
;
3703 /* Add a new stub entry to the stub hash. Not all fields of the new
3704 stub entry are initialised. */
3706 static struct ppc_stub_hash_entry
*
3707 ppc_add_stub (const char *stub_name
,
3709 struct bfd_link_info
*info
)
3711 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
3712 struct map_stub
*group
;
3715 struct ppc_stub_hash_entry
*stub_entry
;
3717 group
= htab
->sec_info
[section
->id
].u
.group
;
3718 link_sec
= group
->link_sec
;
3719 stub_sec
= group
->stub_sec
;
3720 if (stub_sec
== NULL
)
3726 namelen
= strlen (link_sec
->name
);
3727 len
= namelen
+ sizeof (STUB_SUFFIX
);
3728 s_name
= bfd_alloc (htab
->params
->stub_bfd
, len
);
3732 memcpy (s_name
, link_sec
->name
, namelen
);
3733 memcpy (s_name
+ namelen
, STUB_SUFFIX
, sizeof (STUB_SUFFIX
));
3734 stub_sec
= (*htab
->params
->add_stub_section
) (s_name
, link_sec
);
3735 if (stub_sec
== NULL
)
3737 group
->stub_sec
= stub_sec
;
3740 /* Enter this entry into the linker stub hash table. */
3741 stub_entry
= ppc_stub_hash_lookup (&htab
->stub_hash_table
, stub_name
,
3743 if (stub_entry
== NULL
)
3745 /* xgettext:c-format */
3746 _bfd_error_handler (_("%pB: cannot create stub entry %s"),
3747 section
->owner
, stub_name
);
3751 stub_entry
->group
= group
;
3752 stub_entry
->stub_offset
= 0;
3756 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
3757 not already done. */
3760 create_got_section (bfd
*abfd
, struct bfd_link_info
*info
)
3762 asection
*got
, *relgot
;
3764 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
3766 if (!is_ppc64_elf (abfd
))
3772 && !_bfd_elf_create_got_section (htab
->elf
.dynobj
, info
))
3775 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
3776 | SEC_LINKER_CREATED
);
3778 got
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
3780 || !bfd_set_section_alignment (got
, 3))
3783 relgot
= bfd_make_section_anyway_with_flags (abfd
, ".rela.got",
3784 flags
| SEC_READONLY
);
3786 || !bfd_set_section_alignment (relgot
, 3))
3789 ppc64_elf_tdata (abfd
)->got
= got
;
3790 ppc64_elf_tdata (abfd
)->relgot
= relgot
;
3794 /* Follow indirect and warning symbol links. */
3796 static inline struct bfd_link_hash_entry
*
3797 follow_link (struct bfd_link_hash_entry
*h
)
3799 while (h
->type
== bfd_link_hash_indirect
3800 || h
->type
== bfd_link_hash_warning
)
3805 static inline struct elf_link_hash_entry
*
3806 elf_follow_link (struct elf_link_hash_entry
*h
)
3808 return (struct elf_link_hash_entry
*) follow_link (&h
->root
);
3811 static inline struct ppc_link_hash_entry
*
3812 ppc_follow_link (struct ppc_link_hash_entry
*h
)
3814 return (struct ppc_link_hash_entry
*) follow_link (&h
->elf
.root
);
3817 /* Merge PLT info on FROM with that on TO. */
3820 move_plt_plist (struct ppc_link_hash_entry
*from
,
3821 struct ppc_link_hash_entry
*to
)
3823 if (from
->elf
.plt
.plist
!= NULL
)
3825 if (to
->elf
.plt
.plist
!= NULL
)
3827 struct plt_entry
**entp
;
3828 struct plt_entry
*ent
;
3830 for (entp
= &from
->elf
.plt
.plist
; (ent
= *entp
) != NULL
; )
3832 struct plt_entry
*dent
;
3834 for (dent
= to
->elf
.plt
.plist
; dent
!= NULL
; dent
= dent
->next
)
3835 if (dent
->addend
== ent
->addend
)
3837 dent
->plt
.refcount
+= ent
->plt
.refcount
;
3844 *entp
= to
->elf
.plt
.plist
;
3847 to
->elf
.plt
.plist
= from
->elf
.plt
.plist
;
3848 from
->elf
.plt
.plist
= NULL
;
3852 /* Copy the extra info we tack onto an elf_link_hash_entry. */
3855 ppc64_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
3856 struct elf_link_hash_entry
*dir
,
3857 struct elf_link_hash_entry
*ind
)
3859 struct ppc_link_hash_entry
*edir
, *eind
;
3861 edir
= (struct ppc_link_hash_entry
*) dir
;
3862 eind
= (struct ppc_link_hash_entry
*) ind
;
3864 edir
->is_func
|= eind
->is_func
;
3865 edir
->is_func_descriptor
|= eind
->is_func_descriptor
;
3866 edir
->tls_mask
|= eind
->tls_mask
;
3867 if (eind
->oh
!= NULL
)
3868 edir
->oh
= ppc_follow_link (eind
->oh
);
3870 if (edir
->elf
.versioned
!= versioned_hidden
)
3871 edir
->elf
.ref_dynamic
|= eind
->elf
.ref_dynamic
;
3872 edir
->elf
.ref_regular
|= eind
->elf
.ref_regular
;
3873 edir
->elf
.ref_regular_nonweak
|= eind
->elf
.ref_regular_nonweak
;
3874 edir
->elf
.non_got_ref
|= eind
->elf
.non_got_ref
;
3875 edir
->elf
.needs_plt
|= eind
->elf
.needs_plt
;
3876 edir
->elf
.pointer_equality_needed
|= eind
->elf
.pointer_equality_needed
;
3878 /* If we were called to copy over info for a weak sym, don't copy
3879 dyn_relocs, plt/got info, or dynindx. We used to copy dyn_relocs
3880 in order to simplify readonly_dynrelocs and save a field in the
3881 symbol hash entry, but that means dyn_relocs can't be used in any
3882 tests about a specific symbol, or affect other symbol flags which
3884 if (eind
->elf
.root
.type
!= bfd_link_hash_indirect
)
3887 /* Copy over any dynamic relocs we may have on the indirect sym. */
3888 if (eind
->dyn_relocs
!= NULL
)
3890 if (edir
->dyn_relocs
!= NULL
)
3892 struct elf_dyn_relocs
**pp
;
3893 struct elf_dyn_relocs
*p
;
3895 /* Add reloc counts against the indirect sym to the direct sym
3896 list. Merge any entries against the same section. */
3897 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
3899 struct elf_dyn_relocs
*q
;
3901 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
3902 if (q
->sec
== p
->sec
)
3904 q
->pc_count
+= p
->pc_count
;
3905 q
->count
+= p
->count
;
3912 *pp
= edir
->dyn_relocs
;
3915 edir
->dyn_relocs
= eind
->dyn_relocs
;
3916 eind
->dyn_relocs
= NULL
;
3919 /* Copy over got entries that we may have already seen to the
3920 symbol which just became indirect. */
3921 if (eind
->elf
.got
.glist
!= NULL
)
3923 if (edir
->elf
.got
.glist
!= NULL
)
3925 struct got_entry
**entp
;
3926 struct got_entry
*ent
;
3928 for (entp
= &eind
->elf
.got
.glist
; (ent
= *entp
) != NULL
; )
3930 struct got_entry
*dent
;
3932 for (dent
= edir
->elf
.got
.glist
; dent
!= NULL
; dent
= dent
->next
)
3933 if (dent
->addend
== ent
->addend
3934 && dent
->owner
== ent
->owner
3935 && dent
->tls_type
== ent
->tls_type
)
3937 dent
->got
.refcount
+= ent
->got
.refcount
;
3944 *entp
= edir
->elf
.got
.glist
;
3947 edir
->elf
.got
.glist
= eind
->elf
.got
.glist
;
3948 eind
->elf
.got
.glist
= NULL
;
3951 /* And plt entries. */
3952 move_plt_plist (eind
, edir
);
3954 if (eind
->elf
.dynindx
!= -1)
3956 if (edir
->elf
.dynindx
!= -1)
3957 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
3958 edir
->elf
.dynstr_index
);
3959 edir
->elf
.dynindx
= eind
->elf
.dynindx
;
3960 edir
->elf
.dynstr_index
= eind
->elf
.dynstr_index
;
3961 eind
->elf
.dynindx
= -1;
3962 eind
->elf
.dynstr_index
= 0;
3966 /* Find the function descriptor hash entry from the given function code
3967 hash entry FH. Link the entries via their OH fields. */
3969 static struct ppc_link_hash_entry
*
3970 lookup_fdh (struct ppc_link_hash_entry
*fh
, struct ppc_link_hash_table
*htab
)
3972 struct ppc_link_hash_entry
*fdh
= fh
->oh
;
3976 const char *fd_name
= fh
->elf
.root
.root
.string
+ 1;
3978 fdh
= (struct ppc_link_hash_entry
*)
3979 elf_link_hash_lookup (&htab
->elf
, fd_name
, FALSE
, FALSE
, FALSE
);
3983 fdh
->is_func_descriptor
= 1;
3989 fdh
= ppc_follow_link (fdh
);
3990 fdh
->is_func_descriptor
= 1;
3995 /* Make a fake function descriptor sym for the undefined code sym FH. */
3997 static struct ppc_link_hash_entry
*
3998 make_fdh (struct bfd_link_info
*info
,
3999 struct ppc_link_hash_entry
*fh
)
4001 bfd
*abfd
= fh
->elf
.root
.u
.undef
.abfd
;
4002 struct bfd_link_hash_entry
*bh
= NULL
;
4003 struct ppc_link_hash_entry
*fdh
;
4004 flagword flags
= (fh
->elf
.root
.type
== bfd_link_hash_undefweak
4008 if (!_bfd_generic_link_add_one_symbol (info
, abfd
,
4009 fh
->elf
.root
.root
.string
+ 1,
4010 flags
, bfd_und_section_ptr
, 0,
4011 NULL
, FALSE
, FALSE
, &bh
))
4014 fdh
= (struct ppc_link_hash_entry
*) bh
;
4015 fdh
->elf
.non_elf
= 0;
4017 fdh
->is_func_descriptor
= 1;
4024 /* Fix function descriptor symbols defined in .opd sections to be
4028 ppc64_elf_add_symbol_hook (bfd
*ibfd
,
4029 struct bfd_link_info
*info
,
4030 Elf_Internal_Sym
*isym
,
4032 flagword
*flags ATTRIBUTE_UNUSED
,
4037 && strcmp ((*sec
)->name
, ".opd") == 0)
4041 if (!(ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
4042 || ELF_ST_TYPE (isym
->st_info
) == STT_FUNC
))
4043 isym
->st_info
= ELF_ST_INFO (ELF_ST_BIND (isym
->st_info
), STT_FUNC
);
4045 /* If the symbol is a function defined in .opd, and the function
4046 code is in a discarded group, let it appear to be undefined. */
4047 if (!bfd_link_relocatable (info
)
4048 && (*sec
)->reloc_count
!= 0
4049 && opd_entry_value (*sec
, *value
, &code_sec
, NULL
,
4050 FALSE
) != (bfd_vma
) -1
4051 && discarded_section (code_sec
))
4053 *sec
= bfd_und_section_ptr
;
4054 isym
->st_shndx
= SHN_UNDEF
;
4057 else if (*sec
!= NULL
4058 && strcmp ((*sec
)->name
, ".toc") == 0
4059 && ELF_ST_TYPE (isym
->st_info
) == STT_OBJECT
)
4061 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
4063 htab
->params
->object_in_toc
= 1;
4066 if ((STO_PPC64_LOCAL_MASK
& isym
->st_other
) != 0)
4068 if (abiversion (ibfd
) == 0)
4069 set_abiversion (ibfd
, 2);
4070 else if (abiversion (ibfd
) == 1)
4072 _bfd_error_handler (_("symbol '%s' has invalid st_other"
4073 " for ABI version 1"), *name
);
4074 bfd_set_error (bfd_error_bad_value
);
4082 /* Merge non-visibility st_other attributes: local entry point. */
4085 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry
*h
,
4086 const Elf_Internal_Sym
*isym
,
4087 bfd_boolean definition
,
4088 bfd_boolean dynamic
)
4090 if (definition
&& (!dynamic
|| !h
->def_regular
))
4091 h
->other
= ((isym
->st_other
& ~ELF_ST_VISIBILITY (-1))
4092 | ELF_ST_VISIBILITY (h
->other
));
4095 /* Hook called on merging a symbol. We use this to clear "fake" since
4096 we now have a real symbol. */
4099 ppc64_elf_merge_symbol (struct elf_link_hash_entry
*h
,
4100 const Elf_Internal_Sym
*isym
,
4101 asection
**psec ATTRIBUTE_UNUSED
,
4102 bfd_boolean newdef ATTRIBUTE_UNUSED
,
4103 bfd_boolean olddef ATTRIBUTE_UNUSED
,
4104 bfd
*oldbfd ATTRIBUTE_UNUSED
,
4105 const asection
*oldsec ATTRIBUTE_UNUSED
)
4107 ((struct ppc_link_hash_entry
*) h
)->fake
= 0;
4108 if ((STO_PPC64_LOCAL_MASK
& isym
->st_other
) != 0)
4109 ((struct ppc_link_hash_entry
*) h
)->non_zero_localentry
= 1;
4113 /* This function makes an old ABI object reference to ".bar" cause the
4114 inclusion of a new ABI object archive that defines "bar".
4115 NAME is a symbol defined in an archive. Return a symbol in the hash
4116 table that might be satisfied by the archive symbols. */
4118 static struct elf_link_hash_entry
*
4119 ppc64_elf_archive_symbol_lookup (bfd
*abfd
,
4120 struct bfd_link_info
*info
,
4123 struct elf_link_hash_entry
*h
;
4127 h
= _bfd_elf_archive_symbol_lookup (abfd
, info
, name
);
4129 /* Don't return this sym if it is a fake function descriptor
4130 created by add_symbol_adjust. */
4131 && !((struct ppc_link_hash_entry
*) h
)->fake
)
4137 len
= strlen (name
);
4138 dot_name
= bfd_alloc (abfd
, len
+ 2);
4139 if (dot_name
== NULL
)
4140 return (struct elf_link_hash_entry
*) -1;
4142 memcpy (dot_name
+ 1, name
, len
+ 1);
4143 h
= _bfd_elf_archive_symbol_lookup (abfd
, info
, dot_name
);
4144 bfd_release (abfd
, dot_name
);
4148 /* This function satisfies all old ABI object references to ".bar" if a
4149 new ABI object defines "bar". Well, at least, undefined dot symbols
4150 are made weak. This stops later archive searches from including an
4151 object if we already have a function descriptor definition. It also
4152 prevents the linker complaining about undefined symbols.
4153 We also check and correct mismatched symbol visibility here. The
4154 most restrictive visibility of the function descriptor and the
4155 function entry symbol is used. */
4158 add_symbol_adjust (struct ppc_link_hash_entry
*eh
, struct bfd_link_info
*info
)
4160 struct ppc_link_hash_table
*htab
;
4161 struct ppc_link_hash_entry
*fdh
;
4163 if (eh
->elf
.root
.type
== bfd_link_hash_warning
)
4164 eh
= (struct ppc_link_hash_entry
*) eh
->elf
.root
.u
.i
.link
;
4166 if (eh
->elf
.root
.type
== bfd_link_hash_indirect
)
4169 if (eh
->elf
.root
.root
.string
[0] != '.')
4172 htab
= ppc_hash_table (info
);
4176 fdh
= lookup_fdh (eh
, htab
);
4178 && !bfd_link_relocatable (info
)
4179 && (eh
->elf
.root
.type
== bfd_link_hash_undefined
4180 || eh
->elf
.root
.type
== bfd_link_hash_undefweak
)
4181 && eh
->elf
.ref_regular
)
4183 /* Make an undefined function descriptor sym, in order to
4184 pull in an --as-needed shared lib. Archives are handled
4186 fdh
= make_fdh (info
, eh
);
4193 unsigned entry_vis
= ELF_ST_VISIBILITY (eh
->elf
.other
) - 1;
4194 unsigned descr_vis
= ELF_ST_VISIBILITY (fdh
->elf
.other
) - 1;
4196 /* Make both descriptor and entry symbol have the most
4197 constraining visibility of either symbol. */
4198 if (entry_vis
< descr_vis
)
4199 fdh
->elf
.other
+= entry_vis
- descr_vis
;
4200 else if (entry_vis
> descr_vis
)
4201 eh
->elf
.other
+= descr_vis
- entry_vis
;
4203 /* Propagate reference flags from entry symbol to function
4204 descriptor symbol. */
4205 fdh
->elf
.root
.non_ir_ref_regular
|= eh
->elf
.root
.non_ir_ref_regular
;
4206 fdh
->elf
.root
.non_ir_ref_dynamic
|= eh
->elf
.root
.non_ir_ref_dynamic
;
4207 fdh
->elf
.ref_regular
|= eh
->elf
.ref_regular
;
4208 fdh
->elf
.ref_regular_nonweak
|= eh
->elf
.ref_regular_nonweak
;
4210 if (!fdh
->elf
.forced_local
4211 && fdh
->elf
.dynindx
== -1
4212 && fdh
->elf
.versioned
!= versioned_hidden
4213 && (bfd_link_dll (info
)
4214 || fdh
->elf
.def_dynamic
4215 || fdh
->elf
.ref_dynamic
)
4216 && (eh
->elf
.ref_regular
4217 || eh
->elf
.def_regular
))
4219 if (!bfd_elf_link_record_dynamic_symbol (info
, &fdh
->elf
))
4227 /* Set up opd section info and abiversion for IBFD, and process list
4228 of dot-symbols we made in link_hash_newfunc. */
4231 ppc64_elf_before_check_relocs (bfd
*ibfd
, struct bfd_link_info
*info
)
4233 struct ppc_link_hash_table
*htab
;
4234 struct ppc_link_hash_entry
**p
, *eh
;
4235 asection
*opd
= bfd_get_section_by_name (ibfd
, ".opd");
4237 if (opd
!= NULL
&& opd
->size
!= 0)
4239 BFD_ASSERT (ppc64_elf_section_data (opd
)->sec_type
== sec_normal
);
4240 ppc64_elf_section_data (opd
)->sec_type
= sec_opd
;
4242 if (abiversion (ibfd
) == 0)
4243 set_abiversion (ibfd
, 1);
4244 else if (abiversion (ibfd
) >= 2)
4246 /* xgettext:c-format */
4247 _bfd_error_handler (_("%pB .opd not allowed in ABI version %d"),
4248 ibfd
, abiversion (ibfd
));
4249 bfd_set_error (bfd_error_bad_value
);
4254 if (is_ppc64_elf (info
->output_bfd
))
4256 /* For input files without an explicit abiversion in e_flags
4257 we should have flagged any with symbol st_other bits set
4258 as ELFv1 and above flagged those with .opd as ELFv2.
4259 Set the output abiversion if not yet set, and for any input
4260 still ambiguous, take its abiversion from the output.
4261 Differences in ABI are reported later. */
4262 if (abiversion (info
->output_bfd
) == 0)
4263 set_abiversion (info
->output_bfd
, abiversion (ibfd
));
4264 else if (abiversion (ibfd
) == 0)
4265 set_abiversion (ibfd
, abiversion (info
->output_bfd
));
4268 htab
= ppc_hash_table (info
);
4272 if (opd
!= NULL
&& opd
->size
!= 0
4273 && (ibfd
->flags
& DYNAMIC
) == 0
4274 && (opd
->flags
& SEC_RELOC
) != 0
4275 && opd
->reloc_count
!= 0
4276 && !bfd_is_abs_section (opd
->output_section
)
4277 && info
->gc_sections
)
4279 /* Garbage collection needs some extra help with .opd sections.
4280 We don't want to necessarily keep everything referenced by
4281 relocs in .opd, as that would keep all functions. Instead,
4282 if we reference an .opd symbol (a function descriptor), we
4283 want to keep the function code symbol's section. This is
4284 easy for global symbols, but for local syms we need to keep
4285 information about the associated function section. */
4287 asection
**opd_sym_map
;
4288 Elf_Internal_Shdr
*symtab_hdr
;
4289 Elf_Internal_Rela
*relocs
, *rel_end
, *rel
;
4291 amt
= OPD_NDX (opd
->size
) * sizeof (*opd_sym_map
);
4292 opd_sym_map
= bfd_zalloc (ibfd
, amt
);
4293 if (opd_sym_map
== NULL
)
4295 ppc64_elf_section_data (opd
)->u
.opd
.func_sec
= opd_sym_map
;
4296 relocs
= _bfd_elf_link_read_relocs (ibfd
, opd
, NULL
, NULL
,
4300 symtab_hdr
= &elf_symtab_hdr (ibfd
);
4301 rel_end
= relocs
+ opd
->reloc_count
- 1;
4302 for (rel
= relocs
; rel
< rel_end
; rel
++)
4304 enum elf_ppc64_reloc_type r_type
= ELF64_R_TYPE (rel
->r_info
);
4305 unsigned long r_symndx
= ELF64_R_SYM (rel
->r_info
);
4307 if (r_type
== R_PPC64_ADDR64
4308 && ELF64_R_TYPE ((rel
+ 1)->r_info
) == R_PPC64_TOC
4309 && r_symndx
< symtab_hdr
->sh_info
)
4311 Elf_Internal_Sym
*isym
;
4314 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
, ibfd
, r_symndx
);
4317 if (elf_section_data (opd
)->relocs
!= relocs
)
4322 s
= bfd_section_from_elf_index (ibfd
, isym
->st_shndx
);
4323 if (s
!= NULL
&& s
!= opd
)
4324 opd_sym_map
[OPD_NDX (rel
->r_offset
)] = s
;
4327 if (elf_section_data (opd
)->relocs
!= relocs
)
4331 p
= &htab
->dot_syms
;
4332 while ((eh
= *p
) != NULL
)
4335 if (&eh
->elf
== htab
->elf
.hgot
)
4337 else if (htab
->elf
.hgot
== NULL
4338 && strcmp (eh
->elf
.root
.root
.string
, ".TOC.") == 0)
4339 htab
->elf
.hgot
= &eh
->elf
;
4340 else if (abiversion (ibfd
) <= 1)
4342 htab
->need_func_desc_adj
= 1;
4343 if (!add_symbol_adjust (eh
, info
))
4346 p
= &eh
->u
.next_dot_sym
;
4351 /* Undo hash table changes when an --as-needed input file is determined
4352 not to be needed. */
4355 ppc64_elf_notice_as_needed (bfd
*ibfd
,
4356 struct bfd_link_info
*info
,
4357 enum notice_asneeded_action act
)
4359 if (act
== notice_not_needed
)
4361 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
4366 htab
->dot_syms
= NULL
;
4368 return _bfd_elf_notice_as_needed (ibfd
, info
, act
);
4371 /* If --just-symbols against a final linked binary, then assume we need
4372 toc adjusting stubs when calling functions defined there. */
4375 ppc64_elf_link_just_syms (asection
*sec
, struct bfd_link_info
*info
)
4377 if ((sec
->flags
& SEC_CODE
) != 0
4378 && (sec
->owner
->flags
& (EXEC_P
| DYNAMIC
)) != 0
4379 && is_ppc64_elf (sec
->owner
))
4381 if (abiversion (sec
->owner
) >= 2
4382 || bfd_get_section_by_name (sec
->owner
, ".opd") != NULL
)
4383 sec
->has_toc_reloc
= 1;
4385 _bfd_elf_link_just_syms (sec
, info
);
4388 static struct plt_entry
**
4389 update_local_sym_info (bfd
*abfd
, Elf_Internal_Shdr
*symtab_hdr
,
4390 unsigned long r_symndx
, bfd_vma r_addend
, int tls_type
)
4392 struct got_entry
**local_got_ents
= elf_local_got_ents (abfd
);
4393 struct plt_entry
**local_plt
;
4394 unsigned char *local_got_tls_masks
;
4396 if (local_got_ents
== NULL
)
4398 bfd_size_type size
= symtab_hdr
->sh_info
;
4400 size
*= (sizeof (*local_got_ents
)
4401 + sizeof (*local_plt
)
4402 + sizeof (*local_got_tls_masks
));
4403 local_got_ents
= bfd_zalloc (abfd
, size
);
4404 if (local_got_ents
== NULL
)
4406 elf_local_got_ents (abfd
) = local_got_ents
;
4409 if ((tls_type
& (NON_GOT
| TLS_EXPLICIT
)) == 0)
4411 struct got_entry
*ent
;
4413 for (ent
= local_got_ents
[r_symndx
]; ent
!= NULL
; ent
= ent
->next
)
4414 if (ent
->addend
== r_addend
4415 && ent
->owner
== abfd
4416 && ent
->tls_type
== tls_type
)
4420 bfd_size_type amt
= sizeof (*ent
);
4421 ent
= bfd_alloc (abfd
, amt
);
4424 ent
->next
= local_got_ents
[r_symndx
];
4425 ent
->addend
= r_addend
;
4427 ent
->tls_type
= tls_type
;
4428 ent
->is_indirect
= FALSE
;
4429 ent
->got
.refcount
= 0;
4430 local_got_ents
[r_symndx
] = ent
;
4432 ent
->got
.refcount
+= 1;
4435 local_plt
= (struct plt_entry
**) (local_got_ents
+ symtab_hdr
->sh_info
);
4436 local_got_tls_masks
= (unsigned char *) (local_plt
+ symtab_hdr
->sh_info
);
4437 local_got_tls_masks
[r_symndx
] |= tls_type
& 0xff;
4439 return local_plt
+ r_symndx
;
4443 update_plt_info (bfd
*abfd
, struct plt_entry
**plist
, bfd_vma addend
)
4445 struct plt_entry
*ent
;
4447 for (ent
= *plist
; ent
!= NULL
; ent
= ent
->next
)
4448 if (ent
->addend
== addend
)
4452 bfd_size_type amt
= sizeof (*ent
);
4453 ent
= bfd_alloc (abfd
, amt
);
4457 ent
->addend
= addend
;
4458 ent
->plt
.refcount
= 0;
4461 ent
->plt
.refcount
+= 1;
4466 is_branch_reloc (enum elf_ppc64_reloc_type r_type
)
4468 return (r_type
== R_PPC64_REL24
4469 || r_type
== R_PPC64_REL24_NOTOC
4470 || r_type
== R_PPC64_REL14
4471 || r_type
== R_PPC64_REL14_BRTAKEN
4472 || r_type
== R_PPC64_REL14_BRNTAKEN
4473 || r_type
== R_PPC64_ADDR24
4474 || r_type
== R_PPC64_ADDR14
4475 || r_type
== R_PPC64_ADDR14_BRTAKEN
4476 || r_type
== R_PPC64_ADDR14_BRNTAKEN
4477 || r_type
== R_PPC64_PLTCALL
4478 || r_type
== R_PPC64_PLTCALL_NOTOC
);
4481 /* Relocs on inline plt call sequence insns prior to the call. */
4484 is_plt_seq_reloc (enum elf_ppc64_reloc_type r_type
)
4486 return (r_type
== R_PPC64_PLT16_HA
4487 || r_type
== R_PPC64_PLT16_HI
4488 || r_type
== R_PPC64_PLT16_LO
4489 || r_type
== R_PPC64_PLT16_LO_DS
4490 || r_type
== R_PPC64_PLT_PCREL34
4491 || r_type
== R_PPC64_PLT_PCREL34_NOTOC
4492 || r_type
== R_PPC64_PLTSEQ
4493 || r_type
== R_PPC64_PLTSEQ_NOTOC
);
4496 /* Look through the relocs for a section during the first phase, and
4497 calculate needed space in the global offset table, procedure
4498 linkage table, and dynamic reloc sections. */
4501 ppc64_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
4502 asection
*sec
, const Elf_Internal_Rela
*relocs
)
4504 struct ppc_link_hash_table
*htab
;
4505 Elf_Internal_Shdr
*symtab_hdr
;
4506 struct elf_link_hash_entry
**sym_hashes
;
4507 const Elf_Internal_Rela
*rel
;
4508 const Elf_Internal_Rela
*rel_end
;
4510 struct elf_link_hash_entry
*tga
, *dottga
;
4513 if (bfd_link_relocatable (info
))
4516 /* Don't do anything special with non-loaded, non-alloced sections.
4517 In particular, any relocs in such sections should not affect GOT
4518 and PLT reference counting (ie. we don't allow them to create GOT
4519 or PLT entries), there's no possibility or desire to optimize TLS
4520 relocs, and there's not much point in propagating relocs to shared
4521 libs that the dynamic linker won't relocate. */
4522 if ((sec
->flags
& SEC_ALLOC
) == 0)
4525 BFD_ASSERT (is_ppc64_elf (abfd
));
4527 htab
= ppc_hash_table (info
);
4531 tga
= elf_link_hash_lookup (&htab
->elf
, "__tls_get_addr",
4532 FALSE
, FALSE
, TRUE
);
4533 dottga
= elf_link_hash_lookup (&htab
->elf
, ".__tls_get_addr",
4534 FALSE
, FALSE
, TRUE
);
4535 symtab_hdr
= &elf_symtab_hdr (abfd
);
4536 sym_hashes
= elf_sym_hashes (abfd
);
4538 is_opd
= ppc64_elf_section_data (sec
)->sec_type
== sec_opd
;
4539 rel_end
= relocs
+ sec
->reloc_count
;
4540 for (rel
= relocs
; rel
< rel_end
; rel
++)
4542 unsigned long r_symndx
;
4543 struct elf_link_hash_entry
*h
;
4544 enum elf_ppc64_reloc_type r_type
;
4546 struct _ppc64_elf_section_data
*ppc64_sec
;
4547 struct plt_entry
**ifunc
, **plt_list
;
4549 r_symndx
= ELF64_R_SYM (rel
->r_info
);
4550 if (r_symndx
< symtab_hdr
->sh_info
)
4554 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
4555 h
= elf_follow_link (h
);
4557 if (h
== htab
->elf
.hgot
)
4558 sec
->has_toc_reloc
= 1;
4561 r_type
= ELF64_R_TYPE (rel
->r_info
);
4565 case R_PPC64_D34_LO
:
4566 case R_PPC64_D34_HI30
:
4567 case R_PPC64_D34_HA30
:
4569 case R_PPC64_TPREL34
:
4570 case R_PPC64_DTPREL34
:
4571 case R_PPC64_PCREL34
:
4572 case R_PPC64_GOT_PCREL34
:
4573 case R_PPC64_GOT_TLSGD34
:
4574 case R_PPC64_GOT_TLSLD34
:
4575 case R_PPC64_GOT_TPREL34
:
4576 case R_PPC64_GOT_DTPREL34
:
4577 case R_PPC64_PLT_PCREL34
:
4578 case R_PPC64_PLT_PCREL34_NOTOC
:
4579 case R_PPC64_PCREL28
:
4580 htab
->powerxx_stubs
= 1;
4588 case R_PPC64_PLT16_HA
:
4589 case R_PPC64_GOT_TLSLD16_HA
:
4590 case R_PPC64_GOT_TLSGD16_HA
:
4591 case R_PPC64_GOT_TPREL16_HA
:
4592 case R_PPC64_GOT_DTPREL16_HA
:
4593 case R_PPC64_GOT16_HA
:
4594 case R_PPC64_TOC16_HA
:
4595 case R_PPC64_PLT16_LO
:
4596 case R_PPC64_PLT16_LO_DS
:
4597 case R_PPC64_GOT_TLSLD16_LO
:
4598 case R_PPC64_GOT_TLSGD16_LO
:
4599 case R_PPC64_GOT_TPREL16_LO_DS
:
4600 case R_PPC64_GOT_DTPREL16_LO_DS
:
4601 case R_PPC64_GOT16_LO
:
4602 case R_PPC64_GOT16_LO_DS
:
4603 case R_PPC64_TOC16_LO
:
4604 case R_PPC64_TOC16_LO_DS
:
4605 case R_PPC64_GOT_PCREL34
:
4606 ppc64_elf_tdata (abfd
)->has_optrel
= 1;
4607 ppc64_elf_section_data (sec
)->has_optrel
= 1;
4616 if (h
->type
== STT_GNU_IFUNC
)
4619 ifunc
= &h
->plt
.plist
;
4624 Elf_Internal_Sym
*isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
4629 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
4631 ifunc
= update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4633 NON_GOT
| PLT_IFUNC
);
4644 /* These special tls relocs tie a call to __tls_get_addr with
4645 its parameter symbol. */
4647 ((struct ppc_link_hash_entry
*) h
)->tls_mask
|= TLS_TLS
| TLS_MARK
;
4649 if (!update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4651 NON_GOT
| TLS_TLS
| TLS_MARK
))
4653 sec
->has_tls_reloc
= 1;
4656 case R_PPC64_GOT_TLSLD16
:
4657 case R_PPC64_GOT_TLSLD16_LO
:
4658 case R_PPC64_GOT_TLSLD16_HI
:
4659 case R_PPC64_GOT_TLSLD16_HA
:
4660 case R_PPC64_GOT_TLSLD34
:
4661 tls_type
= TLS_TLS
| TLS_LD
;
4664 case R_PPC64_GOT_TLSGD16
:
4665 case R_PPC64_GOT_TLSGD16_LO
:
4666 case R_PPC64_GOT_TLSGD16_HI
:
4667 case R_PPC64_GOT_TLSGD16_HA
:
4668 case R_PPC64_GOT_TLSGD34
:
4669 tls_type
= TLS_TLS
| TLS_GD
;
4672 case R_PPC64_GOT_TPREL16_DS
:
4673 case R_PPC64_GOT_TPREL16_LO_DS
:
4674 case R_PPC64_GOT_TPREL16_HI
:
4675 case R_PPC64_GOT_TPREL16_HA
:
4676 case R_PPC64_GOT_TPREL34
:
4677 if (bfd_link_dll (info
))
4678 info
->flags
|= DF_STATIC_TLS
;
4679 tls_type
= TLS_TLS
| TLS_TPREL
;
4682 case R_PPC64_GOT_DTPREL16_DS
:
4683 case R_PPC64_GOT_DTPREL16_LO_DS
:
4684 case R_PPC64_GOT_DTPREL16_HI
:
4685 case R_PPC64_GOT_DTPREL16_HA
:
4686 case R_PPC64_GOT_DTPREL34
:
4687 tls_type
= TLS_TLS
| TLS_DTPREL
;
4689 sec
->has_tls_reloc
= 1;
4693 case R_PPC64_GOT16_LO
:
4694 case R_PPC64_GOT16_HI
:
4695 case R_PPC64_GOT16_HA
:
4696 case R_PPC64_GOT16_DS
:
4697 case R_PPC64_GOT16_LO_DS
:
4698 case R_PPC64_GOT_PCREL34
:
4700 /* This symbol requires a global offset table entry. */
4701 sec
->has_toc_reloc
= 1;
4702 if (r_type
== R_PPC64_GOT_TLSLD16
4703 || r_type
== R_PPC64_GOT_TLSGD16
4704 || r_type
== R_PPC64_GOT_TPREL16_DS
4705 || r_type
== R_PPC64_GOT_DTPREL16_DS
4706 || r_type
== R_PPC64_GOT16
4707 || r_type
== R_PPC64_GOT16_DS
)
4709 htab
->do_multi_toc
= 1;
4710 ppc64_elf_tdata (abfd
)->has_small_toc_reloc
= 1;
4713 if (ppc64_elf_tdata (abfd
)->got
== NULL
4714 && !create_got_section (abfd
, info
))
4719 struct ppc_link_hash_entry
*eh
;
4720 struct got_entry
*ent
;
4722 eh
= (struct ppc_link_hash_entry
*) h
;
4723 for (ent
= eh
->elf
.got
.glist
; ent
!= NULL
; ent
= ent
->next
)
4724 if (ent
->addend
== rel
->r_addend
4725 && ent
->owner
== abfd
4726 && ent
->tls_type
== tls_type
)
4730 bfd_size_type amt
= sizeof (*ent
);
4731 ent
= bfd_alloc (abfd
, amt
);
4734 ent
->next
= eh
->elf
.got
.glist
;
4735 ent
->addend
= rel
->r_addend
;
4737 ent
->tls_type
= tls_type
;
4738 ent
->is_indirect
= FALSE
;
4739 ent
->got
.refcount
= 0;
4740 eh
->elf
.got
.glist
= ent
;
4742 ent
->got
.refcount
+= 1;
4743 eh
->tls_mask
|= tls_type
;
4746 /* This is a global offset table entry for a local symbol. */
4747 if (!update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4748 rel
->r_addend
, tls_type
))
4751 /* We may also need a plt entry if the symbol turns out to be
4753 if (h
!= NULL
&& !bfd_link_pic (info
) && abiversion (abfd
) != 1)
4755 if (!update_plt_info (abfd
, &h
->plt
.plist
, rel
->r_addend
))
4760 case R_PPC64_PLT16_HA
:
4761 case R_PPC64_PLT16_HI
:
4762 case R_PPC64_PLT16_LO
:
4763 case R_PPC64_PLT16_LO_DS
:
4764 case R_PPC64_PLT_PCREL34
:
4765 case R_PPC64_PLT_PCREL34_NOTOC
:
4768 /* This symbol requires a procedure linkage table entry. */
4773 if (h
->root
.root
.string
[0] == '.'
4774 && h
->root
.root
.string
[1] != '\0')
4775 ((struct ppc_link_hash_entry
*) h
)->is_func
= 1;
4776 ((struct ppc_link_hash_entry
*) h
)->tls_mask
|= PLT_KEEP
;
4777 plt_list
= &h
->plt
.plist
;
4779 if (plt_list
== NULL
)
4780 plt_list
= update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4782 NON_GOT
| PLT_KEEP
);
4783 if (!update_plt_info (abfd
, plt_list
, rel
->r_addend
))
4787 /* The following relocations don't need to propagate the
4788 relocation if linking a shared object since they are
4789 section relative. */
4790 case R_PPC64_SECTOFF
:
4791 case R_PPC64_SECTOFF_LO
:
4792 case R_PPC64_SECTOFF_HI
:
4793 case R_PPC64_SECTOFF_HA
:
4794 case R_PPC64_SECTOFF_DS
:
4795 case R_PPC64_SECTOFF_LO_DS
:
4796 case R_PPC64_DTPREL16
:
4797 case R_PPC64_DTPREL16_LO
:
4798 case R_PPC64_DTPREL16_HI
:
4799 case R_PPC64_DTPREL16_HA
:
4800 case R_PPC64_DTPREL16_DS
:
4801 case R_PPC64_DTPREL16_LO_DS
:
4802 case R_PPC64_DTPREL16_HIGH
:
4803 case R_PPC64_DTPREL16_HIGHA
:
4804 case R_PPC64_DTPREL16_HIGHER
:
4805 case R_PPC64_DTPREL16_HIGHERA
:
4806 case R_PPC64_DTPREL16_HIGHEST
:
4807 case R_PPC64_DTPREL16_HIGHESTA
:
4812 case R_PPC64_REL16_LO
:
4813 case R_PPC64_REL16_HI
:
4814 case R_PPC64_REL16_HA
:
4815 case R_PPC64_REL16_HIGH
:
4816 case R_PPC64_REL16_HIGHA
:
4817 case R_PPC64_REL16_HIGHER
:
4818 case R_PPC64_REL16_HIGHERA
:
4819 case R_PPC64_REL16_HIGHEST
:
4820 case R_PPC64_REL16_HIGHESTA
:
4821 case R_PPC64_REL16_HIGHER34
:
4822 case R_PPC64_REL16_HIGHERA34
:
4823 case R_PPC64_REL16_HIGHEST34
:
4824 case R_PPC64_REL16_HIGHESTA34
:
4825 case R_PPC64_REL16DX_HA
:
4828 /* Not supported as a dynamic relocation. */
4829 case R_PPC64_ADDR64_LOCAL
:
4830 if (bfd_link_pic (info
))
4832 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
4834 /* xgettext:c-format */
4835 info
->callbacks
->einfo (_("%H: %s reloc unsupported "
4836 "in shared libraries and PIEs\n"),
4837 abfd
, sec
, rel
->r_offset
,
4838 ppc64_elf_howto_table
[r_type
]->name
);
4839 bfd_set_error (bfd_error_bad_value
);
4845 case R_PPC64_TOC16_DS
:
4846 htab
->do_multi_toc
= 1;
4847 ppc64_elf_tdata (abfd
)->has_small_toc_reloc
= 1;
4849 case R_PPC64_TOC16_LO
:
4850 case R_PPC64_TOC16_HI
:
4851 case R_PPC64_TOC16_HA
:
4852 case R_PPC64_TOC16_LO_DS
:
4853 sec
->has_toc_reloc
= 1;
4854 if (h
!= NULL
&& bfd_link_executable (info
))
4856 /* We may need a copy reloc. */
4858 /* Strongly prefer a copy reloc over a dynamic reloc.
4859 glibc ld.so as of 2019-08 will error out if one of
4860 these relocations is emitted. */
4870 /* This relocation describes the C++ object vtable hierarchy.
4871 Reconstruct it for later use during GC. */
4872 case R_PPC64_GNU_VTINHERIT
:
4873 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
4877 /* This relocation describes which C++ vtable entries are actually
4878 used. Record for later use during GC. */
4879 case R_PPC64_GNU_VTENTRY
:
4880 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
4885 case R_PPC64_REL14_BRTAKEN
:
4886 case R_PPC64_REL14_BRNTAKEN
:
4888 asection
*dest
= NULL
;
4890 /* Heuristic: If jumping outside our section, chances are
4891 we are going to need a stub. */
4894 /* If the sym is weak it may be overridden later, so
4895 don't assume we know where a weak sym lives. */
4896 if (h
->root
.type
== bfd_link_hash_defined
)
4897 dest
= h
->root
.u
.def
.section
;
4901 Elf_Internal_Sym
*isym
;
4903 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
4908 dest
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
4912 ppc64_elf_section_data (sec
)->has_14bit_branch
= 1;
4916 case R_PPC64_PLTCALL
:
4917 case R_PPC64_PLTCALL_NOTOC
:
4918 ppc64_elf_section_data (sec
)->has_pltcall
= 1;
4922 case R_PPC64_REL24_NOTOC
:
4928 if (h
->root
.root
.string
[0] == '.'
4929 && h
->root
.root
.string
[1] != '\0')
4930 ((struct ppc_link_hash_entry
*) h
)->is_func
= 1;
4932 if (h
== tga
|| h
== dottga
)
4934 sec
->has_tls_reloc
= 1;
4936 && (ELF64_R_TYPE (rel
[-1].r_info
) == R_PPC64_TLSGD
4937 || ELF64_R_TYPE (rel
[-1].r_info
) == R_PPC64_TLSLD
))
4938 /* We have a new-style __tls_get_addr call with
4942 /* Mark this section as having an old-style call. */
4943 sec
->nomark_tls_get_addr
= 1;
4945 plt_list
= &h
->plt
.plist
;
4948 /* We may need a .plt entry if the function this reloc
4949 refers to is in a shared lib. */
4951 && !update_plt_info (abfd
, plt_list
, rel
->r_addend
))
4955 case R_PPC64_ADDR14
:
4956 case R_PPC64_ADDR14_BRNTAKEN
:
4957 case R_PPC64_ADDR14_BRTAKEN
:
4958 case R_PPC64_ADDR24
:
4961 case R_PPC64_TPREL64
:
4962 tls_type
= TLS_EXPLICIT
| TLS_TLS
| TLS_TPREL
;
4963 if (bfd_link_dll (info
))
4964 info
->flags
|= DF_STATIC_TLS
;
4967 case R_PPC64_DTPMOD64
:
4968 if (rel
+ 1 < rel_end
4969 && rel
[1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_DTPREL64
)
4970 && rel
[1].r_offset
== rel
->r_offset
+ 8)
4971 tls_type
= TLS_EXPLICIT
| TLS_TLS
| TLS_GD
;
4973 tls_type
= TLS_EXPLICIT
| TLS_TLS
| TLS_LD
;
4976 case R_PPC64_DTPREL64
:
4977 tls_type
= TLS_EXPLICIT
| TLS_TLS
| TLS_DTPREL
;
4979 && rel
[-1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_DTPMOD64
)
4980 && rel
[-1].r_offset
== rel
->r_offset
- 8)
4981 /* This is the second reloc of a dtpmod, dtprel pair.
4982 Don't mark with TLS_DTPREL. */
4986 sec
->has_tls_reloc
= 1;
4989 struct ppc_link_hash_entry
*eh
;
4990 eh
= (struct ppc_link_hash_entry
*) h
;
4991 eh
->tls_mask
|= tls_type
& 0xff;
4994 if (!update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4995 rel
->r_addend
, tls_type
))
4998 ppc64_sec
= ppc64_elf_section_data (sec
);
4999 if (ppc64_sec
->sec_type
!= sec_toc
)
5003 /* One extra to simplify get_tls_mask. */
5004 amt
= sec
->size
* sizeof (unsigned) / 8 + sizeof (unsigned);
5005 ppc64_sec
->u
.toc
.symndx
= bfd_zalloc (abfd
, amt
);
5006 if (ppc64_sec
->u
.toc
.symndx
== NULL
)
5008 amt
= sec
->size
* sizeof (bfd_vma
) / 8;
5009 ppc64_sec
->u
.toc
.add
= bfd_zalloc (abfd
, amt
);
5010 if (ppc64_sec
->u
.toc
.add
== NULL
)
5012 BFD_ASSERT (ppc64_sec
->sec_type
== sec_normal
);
5013 ppc64_sec
->sec_type
= sec_toc
;
5015 BFD_ASSERT (rel
->r_offset
% 8 == 0);
5016 ppc64_sec
->u
.toc
.symndx
[rel
->r_offset
/ 8] = r_symndx
;
5017 ppc64_sec
->u
.toc
.add
[rel
->r_offset
/ 8] = rel
->r_addend
;
5019 /* Mark the second slot of a GD or LD entry.
5020 -1 to indicate GD and -2 to indicate LD. */
5021 if (tls_type
== (TLS_EXPLICIT
| TLS_TLS
| TLS_GD
))
5022 ppc64_sec
->u
.toc
.symndx
[rel
->r_offset
/ 8 + 1] = -1;
5023 else if (tls_type
== (TLS_EXPLICIT
| TLS_TLS
| TLS_LD
))
5024 ppc64_sec
->u
.toc
.symndx
[rel
->r_offset
/ 8 + 1] = -2;
5027 case R_PPC64_TPREL16
:
5028 case R_PPC64_TPREL16_LO
:
5029 case R_PPC64_TPREL16_HI
:
5030 case R_PPC64_TPREL16_HA
:
5031 case R_PPC64_TPREL16_DS
:
5032 case R_PPC64_TPREL16_LO_DS
:
5033 case R_PPC64_TPREL16_HIGH
:
5034 case R_PPC64_TPREL16_HIGHA
:
5035 case R_PPC64_TPREL16_HIGHER
:
5036 case R_PPC64_TPREL16_HIGHERA
:
5037 case R_PPC64_TPREL16_HIGHEST
:
5038 case R_PPC64_TPREL16_HIGHESTA
:
5039 case R_PPC64_TPREL34
:
5040 if (bfd_link_dll (info
))
5041 info
->flags
|= DF_STATIC_TLS
;
5044 case R_PPC64_ADDR64
:
5046 && rel
+ 1 < rel_end
5047 && ELF64_R_TYPE ((rel
+ 1)->r_info
) == R_PPC64_TOC
)
5050 ((struct ppc_link_hash_entry
*) h
)->is_func
= 1;
5054 case R_PPC64_ADDR16
:
5055 case R_PPC64_ADDR16_DS
:
5056 case R_PPC64_ADDR16_HA
:
5057 case R_PPC64_ADDR16_HI
:
5058 case R_PPC64_ADDR16_HIGH
:
5059 case R_PPC64_ADDR16_HIGHA
:
5060 case R_PPC64_ADDR16_HIGHER
:
5061 case R_PPC64_ADDR16_HIGHERA
:
5062 case R_PPC64_ADDR16_HIGHEST
:
5063 case R_PPC64_ADDR16_HIGHESTA
:
5064 case R_PPC64_ADDR16_LO
:
5065 case R_PPC64_ADDR16_LO_DS
:
5067 case R_PPC64_D34_LO
:
5068 case R_PPC64_D34_HI30
:
5069 case R_PPC64_D34_HA30
:
5070 case R_PPC64_ADDR16_HIGHER34
:
5071 case R_PPC64_ADDR16_HIGHERA34
:
5072 case R_PPC64_ADDR16_HIGHEST34
:
5073 case R_PPC64_ADDR16_HIGHESTA34
:
5075 if (h
!= NULL
&& !bfd_link_pic (info
) && abiversion (abfd
) != 1
5076 && rel
->r_addend
== 0)
5078 /* We may need a .plt entry if this reloc refers to a
5079 function in a shared lib. */
5080 if (!update_plt_info (abfd
, &h
->plt
.plist
, 0))
5082 h
->pointer_equality_needed
= 1;
5089 case R_PPC64_ADDR32
:
5090 case R_PPC64_UADDR16
:
5091 case R_PPC64_UADDR32
:
5092 case R_PPC64_UADDR64
:
5094 if (h
!= NULL
&& bfd_link_executable (info
))
5095 /* We may need a copy reloc. */
5098 /* Don't propagate .opd relocs. */
5099 if (NO_OPD_RELOCS
&& is_opd
)
5102 /* If we are creating a shared library, and this is a reloc
5103 against a global symbol, or a non PC relative reloc
5104 against a local symbol, then we need to copy the reloc
5105 into the shared library. However, if we are linking with
5106 -Bsymbolic, we do not need to copy a reloc against a
5107 global symbol which is defined in an object we are
5108 including in the link (i.e., DEF_REGULAR is set). At
5109 this point we have not seen all the input files, so it is
5110 possible that DEF_REGULAR is not set now but will be set
5111 later (it is never cleared). In case of a weak definition,
5112 DEF_REGULAR may be cleared later by a strong definition in
5113 a shared library. We account for that possibility below by
5114 storing information in the dyn_relocs field of the hash
5115 table entry. A similar situation occurs when creating
5116 shared libraries and symbol visibility changes render the
5119 If on the other hand, we are creating an executable, we
5120 may need to keep relocations for symbols satisfied by a
5121 dynamic library if we manage to avoid copy relocs for the
5125 && (h
->root
.type
== bfd_link_hash_defweak
5126 || !h
->def_regular
))
5128 && !bfd_link_executable (info
)
5129 && !SYMBOLIC_BIND (info
, h
))
5130 || (bfd_link_pic (info
)
5131 && must_be_dyn_reloc (info
, r_type
))
5132 || (!bfd_link_pic (info
)
5135 /* We must copy these reloc types into the output file.
5136 Create a reloc section in dynobj and make room for
5140 sreloc
= _bfd_elf_make_dynamic_reloc_section
5141 (sec
, htab
->elf
.dynobj
, 3, abfd
, /*rela?*/ TRUE
);
5147 /* If this is a global symbol, we count the number of
5148 relocations we need for this symbol. */
5151 struct elf_dyn_relocs
*p
;
5152 struct elf_dyn_relocs
**head
;
5154 head
= &((struct ppc_link_hash_entry
*) h
)->dyn_relocs
;
5156 if (p
== NULL
|| p
->sec
!= sec
)
5158 p
= bfd_alloc (htab
->elf
.dynobj
, sizeof *p
);
5168 if (!must_be_dyn_reloc (info
, r_type
))
5173 /* Track dynamic relocs needed for local syms too.
5174 We really need local syms available to do this
5176 struct ppc_dyn_relocs
*p
;
5177 struct ppc_dyn_relocs
**head
;
5178 bfd_boolean is_ifunc
;
5181 Elf_Internal_Sym
*isym
;
5183 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
5188 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
5192 vpp
= &elf_section_data (s
)->local_dynrel
;
5193 head
= (struct ppc_dyn_relocs
**) vpp
;
5194 is_ifunc
= ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
;
5196 if (p
!= NULL
&& p
->sec
== sec
&& p
->ifunc
!= is_ifunc
)
5198 if (p
== NULL
|| p
->sec
!= sec
|| p
->ifunc
!= is_ifunc
)
5200 p
= bfd_alloc (htab
->elf
.dynobj
, sizeof *p
);
5206 p
->ifunc
= is_ifunc
;
5222 /* Merge backend specific data from an object file to the output
5223 object file when linking. */
5226 ppc64_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
5228 bfd
*obfd
= info
->output_bfd
;
5229 unsigned long iflags
, oflags
;
5231 if ((ibfd
->flags
& BFD_LINKER_CREATED
) != 0)
5234 if (!is_ppc64_elf (ibfd
) || !is_ppc64_elf (obfd
))
5237 if (!_bfd_generic_verify_endian_match (ibfd
, info
))
5240 iflags
= elf_elfheader (ibfd
)->e_flags
;
5241 oflags
= elf_elfheader (obfd
)->e_flags
;
5243 if (iflags
& ~EF_PPC64_ABI
)
5246 /* xgettext:c-format */
5247 (_("%pB uses unknown e_flags 0x%lx"), ibfd
, iflags
);
5248 bfd_set_error (bfd_error_bad_value
);
5251 else if (iflags
!= oflags
&& iflags
!= 0)
5254 /* xgettext:c-format */
5255 (_("%pB: ABI version %ld is not compatible with ABI version %ld output"),
5256 ibfd
, iflags
, oflags
);
5257 bfd_set_error (bfd_error_bad_value
);
5261 if (!_bfd_elf_ppc_merge_fp_attributes (ibfd
, info
))
5264 /* Merge Tag_compatibility attributes and any common GNU ones. */
5265 return _bfd_elf_merge_object_attributes (ibfd
, info
);
5269 ppc64_elf_print_private_bfd_data (bfd
*abfd
, void *ptr
)
5271 /* Print normal ELF private data. */
5272 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
5274 if (elf_elfheader (abfd
)->e_flags
!= 0)
5278 fprintf (file
, _("private flags = 0x%lx:"),
5279 elf_elfheader (abfd
)->e_flags
);
5281 if ((elf_elfheader (abfd
)->e_flags
& EF_PPC64_ABI
) != 0)
5282 fprintf (file
, _(" [abiv%ld]"),
5283 elf_elfheader (abfd
)->e_flags
& EF_PPC64_ABI
);
5290 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
5291 of the code entry point, and its section, which must be in the same
5292 object as OPD_SEC. Returns (bfd_vma) -1 on error. */
5295 opd_entry_value (asection
*opd_sec
,
5297 asection
**code_sec
,
5299 bfd_boolean in_code_sec
)
5301 bfd
*opd_bfd
= opd_sec
->owner
;
5302 Elf_Internal_Rela
*relocs
;
5303 Elf_Internal_Rela
*lo
, *hi
, *look
;
5306 /* No relocs implies we are linking a --just-symbols object, or looking
5307 at a final linked executable with addr2line or somesuch. */
5308 if (opd_sec
->reloc_count
== 0)
5310 bfd_byte
*contents
= ppc64_elf_tdata (opd_bfd
)->opd
.contents
;
5312 if (contents
== NULL
)
5314 if (!bfd_malloc_and_get_section (opd_bfd
, opd_sec
, &contents
))
5315 return (bfd_vma
) -1;
5316 ppc64_elf_tdata (opd_bfd
)->opd
.contents
= contents
;
5319 /* PR 17512: file: 64b9dfbb. */
5320 if (offset
+ 7 >= opd_sec
->size
|| offset
+ 7 < offset
)
5321 return (bfd_vma
) -1;
5323 val
= bfd_get_64 (opd_bfd
, contents
+ offset
);
5324 if (code_sec
!= NULL
)
5326 asection
*sec
, *likely
= NULL
;
5332 && val
< sec
->vma
+ sec
->size
)
5338 for (sec
= opd_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
5340 && (sec
->flags
& SEC_LOAD
) != 0
5341 && (sec
->flags
& SEC_ALLOC
) != 0)
5346 if (code_off
!= NULL
)
5347 *code_off
= val
- likely
->vma
;
5353 BFD_ASSERT (is_ppc64_elf (opd_bfd
));
5355 relocs
= ppc64_elf_tdata (opd_bfd
)->opd
.relocs
;
5357 relocs
= _bfd_elf_link_read_relocs (opd_bfd
, opd_sec
, NULL
, NULL
, TRUE
);
5358 /* PR 17512: file: df8e1fd6. */
5360 return (bfd_vma
) -1;
5362 /* Go find the opd reloc at the sym address. */
5364 hi
= lo
+ opd_sec
->reloc_count
- 1; /* ignore last reloc */
5368 look
= lo
+ (hi
- lo
) / 2;
5369 if (look
->r_offset
< offset
)
5371 else if (look
->r_offset
> offset
)
5375 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (opd_bfd
);
5377 if (ELF64_R_TYPE (look
->r_info
) == R_PPC64_ADDR64
5378 && ELF64_R_TYPE ((look
+ 1)->r_info
) == R_PPC64_TOC
)
5380 unsigned long symndx
= ELF64_R_SYM (look
->r_info
);
5381 asection
*sec
= NULL
;
5383 if (symndx
>= symtab_hdr
->sh_info
5384 && elf_sym_hashes (opd_bfd
) != NULL
)
5386 struct elf_link_hash_entry
**sym_hashes
;
5387 struct elf_link_hash_entry
*rh
;
5389 sym_hashes
= elf_sym_hashes (opd_bfd
);
5390 rh
= sym_hashes
[symndx
- symtab_hdr
->sh_info
];
5393 rh
= elf_follow_link (rh
);
5394 if (rh
->root
.type
!= bfd_link_hash_defined
5395 && rh
->root
.type
!= bfd_link_hash_defweak
)
5397 if (rh
->root
.u
.def
.section
->owner
== opd_bfd
)
5399 val
= rh
->root
.u
.def
.value
;
5400 sec
= rh
->root
.u
.def
.section
;
5407 Elf_Internal_Sym
*sym
;
5409 if (symndx
< symtab_hdr
->sh_info
)
5411 sym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
5414 size_t symcnt
= symtab_hdr
->sh_info
;
5415 sym
= bfd_elf_get_elf_syms (opd_bfd
, symtab_hdr
,
5420 symtab_hdr
->contents
= (bfd_byte
*) sym
;
5426 sym
= bfd_elf_get_elf_syms (opd_bfd
, symtab_hdr
,
5432 sec
= bfd_section_from_elf_index (opd_bfd
, sym
->st_shndx
);
5435 BFD_ASSERT ((sec
->flags
& SEC_MERGE
) == 0);
5436 val
= sym
->st_value
;
5439 val
+= look
->r_addend
;
5440 if (code_off
!= NULL
)
5442 if (code_sec
!= NULL
)
5444 if (in_code_sec
&& *code_sec
!= sec
)
5449 if (sec
->output_section
!= NULL
)
5450 val
+= sec
->output_section
->vma
+ sec
->output_offset
;
5459 /* If the ELF symbol SYM might be a function in SEC, return the
5460 function size and set *CODE_OFF to the function's entry point,
5461 otherwise return zero. */
5463 static bfd_size_type
5464 ppc64_elf_maybe_function_sym (const asymbol
*sym
, asection
*sec
,
5469 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_FILE
| BSF_OBJECT
5470 | BSF_THREAD_LOCAL
| BSF_RELC
| BSF_SRELC
)) != 0)
5474 if (!(sym
->flags
& BSF_SYNTHETIC
))
5475 size
= ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
5477 if (strcmp (sym
->section
->name
, ".opd") == 0)
5479 struct _opd_sec_data
*opd
= get_opd_info (sym
->section
);
5480 bfd_vma symval
= sym
->value
;
5483 && opd
->adjust
!= NULL
5484 && elf_section_data (sym
->section
)->relocs
!= NULL
)
5486 /* opd_entry_value will use cached relocs that have been
5487 adjusted, but with raw symbols. That means both local
5488 and global symbols need adjusting. */
5489 long adjust
= opd
->adjust
[OPD_NDX (symval
)];
5495 if (opd_entry_value (sym
->section
, symval
,
5496 &sec
, code_off
, TRUE
) == (bfd_vma
) -1)
5498 /* An old ABI binary with dot-syms has a size of 24 on the .opd
5499 symbol. This size has nothing to do with the code size of the
5500 function, which is what we're supposed to return, but the
5501 code size isn't available without looking up the dot-sym.
5502 However, doing that would be a waste of time particularly
5503 since elf_find_function will look at the dot-sym anyway.
5504 Now, elf_find_function will keep the largest size of any
5505 function sym found at the code address of interest, so return
5506 1 here to avoid it incorrectly caching a larger function size
5507 for a small function. This does mean we return the wrong
5508 size for a new-ABI function of size 24, but all that does is
5509 disable caching for such functions. */
5515 if (sym
->section
!= sec
)
5517 *code_off
= sym
->value
;
5524 /* Return true if symbol is a strong function defined in an ELFv2
5525 object with st_other localentry bits of zero, ie. its local entry
5526 point coincides with its global entry point. */
5529 is_elfv2_localentry0 (struct elf_link_hash_entry
*h
)
5532 && h
->type
== STT_FUNC
5533 && h
->root
.type
== bfd_link_hash_defined
5534 && (STO_PPC64_LOCAL_MASK
& h
->other
) == 0
5535 && !((struct ppc_link_hash_entry
*) h
)->non_zero_localentry
5536 && is_ppc64_elf (h
->root
.u
.def
.section
->owner
)
5537 && abiversion (h
->root
.u
.def
.section
->owner
) >= 2);
5540 /* Return true if symbol is defined in a regular object file. */
5543 is_static_defined (struct elf_link_hash_entry
*h
)
5545 return ((h
->root
.type
== bfd_link_hash_defined
5546 || h
->root
.type
== bfd_link_hash_defweak
)
5547 && h
->root
.u
.def
.section
!= NULL
5548 && h
->root
.u
.def
.section
->output_section
!= NULL
);
5551 /* If FDH is a function descriptor symbol, return the associated code
5552 entry symbol if it is defined. Return NULL otherwise. */
5554 static struct ppc_link_hash_entry
*
5555 defined_code_entry (struct ppc_link_hash_entry
*fdh
)
5557 if (fdh
->is_func_descriptor
)
5559 struct ppc_link_hash_entry
*fh
= ppc_follow_link (fdh
->oh
);
5560 if (fh
->elf
.root
.type
== bfd_link_hash_defined
5561 || fh
->elf
.root
.type
== bfd_link_hash_defweak
)
5567 /* If FH is a function code entry symbol, return the associated
5568 function descriptor symbol if it is defined. Return NULL otherwise. */
5570 static struct ppc_link_hash_entry
*
5571 defined_func_desc (struct ppc_link_hash_entry
*fh
)
5574 && fh
->oh
->is_func_descriptor
)
5576 struct ppc_link_hash_entry
*fdh
= ppc_follow_link (fh
->oh
);
5577 if (fdh
->elf
.root
.type
== bfd_link_hash_defined
5578 || fdh
->elf
.root
.type
== bfd_link_hash_defweak
)
5584 static bfd_boolean
func_desc_adjust (struct elf_link_hash_entry
*, void *);
5586 /* Garbage collect sections, after first dealing with dot-symbols. */
5589 ppc64_elf_gc_sections (bfd
*abfd
, struct bfd_link_info
*info
)
5591 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
5593 if (htab
!= NULL
&& htab
->need_func_desc_adj
)
5595 elf_link_hash_traverse (&htab
->elf
, func_desc_adjust
, info
);
5596 htab
->need_func_desc_adj
= 0;
5598 return bfd_elf_gc_sections (abfd
, info
);
5601 /* Mark all our entry sym sections, both opd and code section. */
5604 ppc64_elf_gc_keep (struct bfd_link_info
*info
)
5606 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
5607 struct bfd_sym_chain
*sym
;
5612 for (sym
= info
->gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
5614 struct ppc_link_hash_entry
*eh
, *fh
;
5617 eh
= (struct ppc_link_hash_entry
*)
5618 elf_link_hash_lookup (&htab
->elf
, sym
->name
, FALSE
, FALSE
, TRUE
);
5621 if (eh
->elf
.root
.type
!= bfd_link_hash_defined
5622 && eh
->elf
.root
.type
!= bfd_link_hash_defweak
)
5625 fh
= defined_code_entry (eh
);
5628 sec
= fh
->elf
.root
.u
.def
.section
;
5629 sec
->flags
|= SEC_KEEP
;
5631 else if (get_opd_info (eh
->elf
.root
.u
.def
.section
) != NULL
5632 && opd_entry_value (eh
->elf
.root
.u
.def
.section
,
5633 eh
->elf
.root
.u
.def
.value
,
5634 &sec
, NULL
, FALSE
) != (bfd_vma
) -1)
5635 sec
->flags
|= SEC_KEEP
;
5637 sec
= eh
->elf
.root
.u
.def
.section
;
5638 sec
->flags
|= SEC_KEEP
;
5642 /* Mark sections containing dynamically referenced symbols. When
5643 building shared libraries, we must assume that any visible symbol is
5647 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry
*h
, void *inf
)
5649 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
5650 struct ppc_link_hash_entry
*eh
= (struct ppc_link_hash_entry
*) h
;
5651 struct ppc_link_hash_entry
*fdh
;
5652 struct bfd_elf_dynamic_list
*d
= info
->dynamic_list
;
5654 /* Dynamic linking info is on the func descriptor sym. */
5655 fdh
= defined_func_desc (eh
);
5659 if ((eh
->elf
.root
.type
== bfd_link_hash_defined
5660 || eh
->elf
.root
.type
== bfd_link_hash_defweak
)
5661 && ((eh
->elf
.ref_dynamic
&& !eh
->elf
.forced_local
)
5662 || ((eh
->elf
.def_regular
|| ELF_COMMON_DEF_P (&eh
->elf
))
5663 && ELF_ST_VISIBILITY (eh
->elf
.other
) != STV_INTERNAL
5664 && ELF_ST_VISIBILITY (eh
->elf
.other
) != STV_HIDDEN
5665 && (!bfd_link_executable (info
)
5666 || info
->gc_keep_exported
5667 || info
->export_dynamic
5670 && (*d
->match
) (&d
->head
, NULL
,
5671 eh
->elf
.root
.root
.string
)))
5672 && (eh
->elf
.versioned
>= versioned
5673 || !bfd_hide_sym_by_version (info
->version_info
,
5674 eh
->elf
.root
.root
.string
)))))
5677 struct ppc_link_hash_entry
*fh
;
5679 eh
->elf
.root
.u
.def
.section
->flags
|= SEC_KEEP
;
5681 /* Function descriptor syms cause the associated
5682 function code sym section to be marked. */
5683 fh
= defined_code_entry (eh
);
5686 code_sec
= fh
->elf
.root
.u
.def
.section
;
5687 code_sec
->flags
|= SEC_KEEP
;
5689 else if (get_opd_info (eh
->elf
.root
.u
.def
.section
) != NULL
5690 && opd_entry_value (eh
->elf
.root
.u
.def
.section
,
5691 eh
->elf
.root
.u
.def
.value
,
5692 &code_sec
, NULL
, FALSE
) != (bfd_vma
) -1)
5693 code_sec
->flags
|= SEC_KEEP
;
5699 /* Return the section that should be marked against GC for a given
5703 ppc64_elf_gc_mark_hook (asection
*sec
,
5704 struct bfd_link_info
*info
,
5705 Elf_Internal_Rela
*rel
,
5706 struct elf_link_hash_entry
*h
,
5707 Elf_Internal_Sym
*sym
)
5711 /* Syms return NULL if we're marking .opd, so we avoid marking all
5712 function sections, as all functions are referenced in .opd. */
5714 if (get_opd_info (sec
) != NULL
)
5719 enum elf_ppc64_reloc_type r_type
;
5720 struct ppc_link_hash_entry
*eh
, *fh
, *fdh
;
5722 r_type
= ELF64_R_TYPE (rel
->r_info
);
5725 case R_PPC64_GNU_VTINHERIT
:
5726 case R_PPC64_GNU_VTENTRY
:
5730 switch (h
->root
.type
)
5732 case bfd_link_hash_defined
:
5733 case bfd_link_hash_defweak
:
5734 eh
= (struct ppc_link_hash_entry
*) h
;
5735 fdh
= defined_func_desc (eh
);
5738 /* -mcall-aixdesc code references the dot-symbol on
5739 a call reloc. Mark the function descriptor too
5740 against garbage collection. */
5742 if (fdh
->elf
.is_weakalias
)
5743 weakdef (&fdh
->elf
)->mark
= 1;
5747 /* Function descriptor syms cause the associated
5748 function code sym section to be marked. */
5749 fh
= defined_code_entry (eh
);
5752 /* They also mark their opd section. */
5753 eh
->elf
.root
.u
.def
.section
->gc_mark
= 1;
5755 rsec
= fh
->elf
.root
.u
.def
.section
;
5757 else if (get_opd_info (eh
->elf
.root
.u
.def
.section
) != NULL
5758 && opd_entry_value (eh
->elf
.root
.u
.def
.section
,
5759 eh
->elf
.root
.u
.def
.value
,
5760 &rsec
, NULL
, FALSE
) != (bfd_vma
) -1)
5761 eh
->elf
.root
.u
.def
.section
->gc_mark
= 1;
5763 rsec
= h
->root
.u
.def
.section
;
5766 case bfd_link_hash_common
:
5767 rsec
= h
->root
.u
.c
.p
->section
;
5771 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
5777 struct _opd_sec_data
*opd
;
5779 rsec
= bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
5780 opd
= get_opd_info (rsec
);
5781 if (opd
!= NULL
&& opd
->func_sec
!= NULL
)
5785 rsec
= opd
->func_sec
[OPD_NDX (sym
->st_value
+ rel
->r_addend
)];
5792 /* The maximum size of .sfpr. */
5793 #define SFPR_MAX (218*4)
5795 struct sfpr_def_parms
5797 const char name
[12];
5798 unsigned char lo
, hi
;
5799 bfd_byte
*(*write_ent
) (bfd
*, bfd_byte
*, int);
5800 bfd_byte
*(*write_tail
) (bfd
*, bfd_byte
*, int);
5803 /* Auto-generate _save*, _rest* functions in .sfpr.
5804 If STUB_SEC is non-null, define alias symbols in STUB_SEC
5808 sfpr_define (struct bfd_link_info
*info
,
5809 const struct sfpr_def_parms
*parm
,
5812 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
5814 size_t len
= strlen (parm
->name
);
5815 bfd_boolean writing
= FALSE
;
5821 memcpy (sym
, parm
->name
, len
);
5824 for (i
= parm
->lo
; i
<= parm
->hi
; i
++)
5826 struct ppc_link_hash_entry
*h
;
5828 sym
[len
+ 0] = i
/ 10 + '0';
5829 sym
[len
+ 1] = i
% 10 + '0';
5830 h
= (struct ppc_link_hash_entry
*)
5831 elf_link_hash_lookup (&htab
->elf
, sym
, writing
, TRUE
, TRUE
);
5832 if (stub_sec
!= NULL
)
5835 && h
->elf
.root
.type
== bfd_link_hash_defined
5836 && h
->elf
.root
.u
.def
.section
== htab
->sfpr
)
5838 struct elf_link_hash_entry
*s
;
5840 sprintf (buf
, "%08x.%s", stub_sec
->id
& 0xffffffff, sym
);
5841 s
= elf_link_hash_lookup (&htab
->elf
, buf
, TRUE
, TRUE
, FALSE
);
5844 if (s
->root
.type
== bfd_link_hash_new
)
5846 s
->root
.type
= bfd_link_hash_defined
;
5847 s
->root
.u
.def
.section
= stub_sec
;
5848 s
->root
.u
.def
.value
= (stub_sec
->size
- htab
->sfpr
->size
5849 + h
->elf
.root
.u
.def
.value
);
5852 s
->ref_regular_nonweak
= 1;
5853 s
->forced_local
= 1;
5855 s
->root
.linker_def
= 1;
5863 if (!h
->elf
.def_regular
)
5865 h
->elf
.root
.type
= bfd_link_hash_defined
;
5866 h
->elf
.root
.u
.def
.section
= htab
->sfpr
;
5867 h
->elf
.root
.u
.def
.value
= htab
->sfpr
->size
;
5868 h
->elf
.type
= STT_FUNC
;
5869 h
->elf
.def_regular
= 1;
5871 _bfd_elf_link_hash_hide_symbol (info
, &h
->elf
, TRUE
);
5873 if (htab
->sfpr
->contents
== NULL
)
5875 htab
->sfpr
->contents
5876 = bfd_alloc (htab
->elf
.dynobj
, SFPR_MAX
);
5877 if (htab
->sfpr
->contents
== NULL
)
5884 bfd_byte
*p
= htab
->sfpr
->contents
+ htab
->sfpr
->size
;
5886 p
= (*parm
->write_ent
) (htab
->elf
.dynobj
, p
, i
);
5888 p
= (*parm
->write_tail
) (htab
->elf
.dynobj
, p
, i
);
5889 htab
->sfpr
->size
= p
- htab
->sfpr
->contents
;
5897 savegpr0 (bfd
*abfd
, bfd_byte
*p
, int r
)
5899 bfd_put_32 (abfd
, STD_R0_0R1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5904 savegpr0_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5906 p
= savegpr0 (abfd
, p
, r
);
5907 bfd_put_32 (abfd
, STD_R0_0R1
+ STK_LR
, p
);
5909 bfd_put_32 (abfd
, BLR
, p
);
5914 restgpr0 (bfd
*abfd
, bfd_byte
*p
, int r
)
5916 bfd_put_32 (abfd
, LD_R0_0R1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5921 restgpr0_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5923 bfd_put_32 (abfd
, LD_R0_0R1
+ STK_LR
, p
);
5925 p
= restgpr0 (abfd
, p
, r
);
5926 bfd_put_32 (abfd
, MTLR_R0
, p
);
5930 p
= restgpr0 (abfd
, p
, 30);
5931 p
= restgpr0 (abfd
, p
, 31);
5933 bfd_put_32 (abfd
, BLR
, p
);
5938 savegpr1 (bfd
*abfd
, bfd_byte
*p
, int r
)
5940 bfd_put_32 (abfd
, STD_R0_0R12
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5945 savegpr1_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5947 p
= savegpr1 (abfd
, p
, r
);
5948 bfd_put_32 (abfd
, BLR
, p
);
5953 restgpr1 (bfd
*abfd
, bfd_byte
*p
, int r
)
5955 bfd_put_32 (abfd
, LD_R0_0R12
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5960 restgpr1_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5962 p
= restgpr1 (abfd
, p
, r
);
5963 bfd_put_32 (abfd
, BLR
, p
);
5968 savefpr (bfd
*abfd
, bfd_byte
*p
, int r
)
5970 bfd_put_32 (abfd
, STFD_FR0_0R1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5975 savefpr0_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5977 p
= savefpr (abfd
, p
, r
);
5978 bfd_put_32 (abfd
, STD_R0_0R1
+ STK_LR
, p
);
5980 bfd_put_32 (abfd
, BLR
, p
);
5985 restfpr (bfd
*abfd
, bfd_byte
*p
, int r
)
5987 bfd_put_32 (abfd
, LFD_FR0_0R1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5992 restfpr0_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5994 bfd_put_32 (abfd
, LD_R0_0R1
+ STK_LR
, p
);
5996 p
= restfpr (abfd
, p
, r
);
5997 bfd_put_32 (abfd
, MTLR_R0
, p
);
6001 p
= restfpr (abfd
, p
, 30);
6002 p
= restfpr (abfd
, p
, 31);
6004 bfd_put_32 (abfd
, BLR
, p
);
6009 savefpr1_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6011 p
= savefpr (abfd
, p
, r
);
6012 bfd_put_32 (abfd
, BLR
, p
);
6017 restfpr1_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6019 p
= restfpr (abfd
, p
, r
);
6020 bfd_put_32 (abfd
, BLR
, p
);
6025 savevr (bfd
*abfd
, bfd_byte
*p
, int r
)
6027 bfd_put_32 (abfd
, LI_R12_0
+ (1 << 16) - (32 - r
) * 16, p
);
6029 bfd_put_32 (abfd
, STVX_VR0_R12_R0
+ (r
<< 21), p
);
6034 savevr_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6036 p
= savevr (abfd
, p
, r
);
6037 bfd_put_32 (abfd
, BLR
, p
);
6042 restvr (bfd
*abfd
, bfd_byte
*p
, int r
)
6044 bfd_put_32 (abfd
, LI_R12_0
+ (1 << 16) - (32 - r
) * 16, p
);
6046 bfd_put_32 (abfd
, LVX_VR0_R12_R0
+ (r
<< 21), p
);
6051 restvr_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6053 p
= restvr (abfd
, p
, r
);
6054 bfd_put_32 (abfd
, BLR
, p
);
6058 /* Called via elf_link_hash_traverse to transfer dynamic linking
6059 information on function code symbol entries to their corresponding
6060 function descriptor symbol entries. */
6063 func_desc_adjust (struct elf_link_hash_entry
*h
, void *inf
)
6065 struct bfd_link_info
*info
;
6066 struct ppc_link_hash_table
*htab
;
6067 struct ppc_link_hash_entry
*fh
;
6068 struct ppc_link_hash_entry
*fdh
;
6069 bfd_boolean force_local
;
6071 fh
= (struct ppc_link_hash_entry
*) h
;
6072 if (fh
->elf
.root
.type
== bfd_link_hash_indirect
)
6078 if (fh
->elf
.root
.root
.string
[0] != '.'
6079 || fh
->elf
.root
.root
.string
[1] == '\0')
6083 htab
= ppc_hash_table (info
);
6087 /* Find the corresponding function descriptor symbol. */
6088 fdh
= lookup_fdh (fh
, htab
);
6090 /* Resolve undefined references to dot-symbols as the value
6091 in the function descriptor, if we have one in a regular object.
6092 This is to satisfy cases like ".quad .foo". Calls to functions
6093 in dynamic objects are handled elsewhere. */
6094 if ((fh
->elf
.root
.type
== bfd_link_hash_undefined
6095 || fh
->elf
.root
.type
== bfd_link_hash_undefweak
)
6096 && (fdh
->elf
.root
.type
== bfd_link_hash_defined
6097 || fdh
->elf
.root
.type
== bfd_link_hash_defweak
)
6098 && get_opd_info (fdh
->elf
.root
.u
.def
.section
) != NULL
6099 && opd_entry_value (fdh
->elf
.root
.u
.def
.section
,
6100 fdh
->elf
.root
.u
.def
.value
,
6101 &fh
->elf
.root
.u
.def
.section
,
6102 &fh
->elf
.root
.u
.def
.value
, FALSE
) != (bfd_vma
) -1)
6104 fh
->elf
.root
.type
= fdh
->elf
.root
.type
;
6105 fh
->elf
.forced_local
= 1;
6106 fh
->elf
.def_regular
= fdh
->elf
.def_regular
;
6107 fh
->elf
.def_dynamic
= fdh
->elf
.def_dynamic
;
6110 if (!fh
->elf
.dynamic
)
6112 struct plt_entry
*ent
;
6114 for (ent
= fh
->elf
.plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
6115 if (ent
->plt
.refcount
> 0)
6121 /* Create a descriptor as undefined if necessary. */
6123 && !bfd_link_executable (info
)
6124 && (fh
->elf
.root
.type
== bfd_link_hash_undefined
6125 || fh
->elf
.root
.type
== bfd_link_hash_undefweak
))
6127 fdh
= make_fdh (info
, fh
);
6132 /* We can't support overriding of symbols on a fake descriptor. */
6135 && (fh
->elf
.root
.type
== bfd_link_hash_defined
6136 || fh
->elf
.root
.type
== bfd_link_hash_defweak
))
6137 _bfd_elf_link_hash_hide_symbol (info
, &fdh
->elf
, TRUE
);
6139 /* Transfer dynamic linking information to the function descriptor. */
6142 fdh
->elf
.ref_regular
|= fh
->elf
.ref_regular
;
6143 fdh
->elf
.ref_dynamic
|= fh
->elf
.ref_dynamic
;
6144 fdh
->elf
.ref_regular_nonweak
|= fh
->elf
.ref_regular_nonweak
;
6145 fdh
->elf
.non_got_ref
|= fh
->elf
.non_got_ref
;
6146 fdh
->elf
.dynamic
|= fh
->elf
.dynamic
;
6147 fdh
->elf
.needs_plt
|= (fh
->elf
.needs_plt
6148 || fh
->elf
.type
== STT_FUNC
6149 || fh
->elf
.type
== STT_GNU_IFUNC
);
6150 move_plt_plist (fh
, fdh
);
6152 if (!fdh
->elf
.forced_local
6153 && fh
->elf
.dynindx
!= -1)
6154 if (!bfd_elf_link_record_dynamic_symbol (info
, &fdh
->elf
))
6158 /* Now that the info is on the function descriptor, clear the
6159 function code sym info. Any function code syms for which we
6160 don't have a definition in a regular file, we force local.
6161 This prevents a shared library from exporting syms that have
6162 been imported from another library. Function code syms that
6163 are really in the library we must leave global to prevent the
6164 linker dragging in a definition from a static library. */
6165 force_local
= (!fh
->elf
.def_regular
6167 || !fdh
->elf
.def_regular
6168 || fdh
->elf
.forced_local
);
6169 _bfd_elf_link_hash_hide_symbol (info
, &fh
->elf
, force_local
);
6174 static const struct sfpr_def_parms save_res_funcs
[] =
6176 { "_savegpr0_", 14, 31, savegpr0
, savegpr0_tail
},
6177 { "_restgpr0_", 14, 29, restgpr0
, restgpr0_tail
},
6178 { "_restgpr0_", 30, 31, restgpr0
, restgpr0_tail
},
6179 { "_savegpr1_", 14, 31, savegpr1
, savegpr1_tail
},
6180 { "_restgpr1_", 14, 31, restgpr1
, restgpr1_tail
},
6181 { "_savefpr_", 14, 31, savefpr
, savefpr0_tail
},
6182 { "_restfpr_", 14, 29, restfpr
, restfpr0_tail
},
6183 { "_restfpr_", 30, 31, restfpr
, restfpr0_tail
},
6184 { "._savef", 14, 31, savefpr
, savefpr1_tail
},
6185 { "._restf", 14, 31, restfpr
, restfpr1_tail
},
6186 { "_savevr_", 20, 31, savevr
, savevr_tail
},
6187 { "_restvr_", 20, 31, restvr
, restvr_tail
}
6190 /* Called near the start of bfd_elf_size_dynamic_sections. We use
6191 this hook to a) provide some gcc support functions, and b) transfer
6192 dynamic linking information gathered so far on function code symbol
6193 entries, to their corresponding function descriptor symbol entries. */
6196 ppc64_elf_func_desc_adjust (bfd
*obfd ATTRIBUTE_UNUSED
,
6197 struct bfd_link_info
*info
)
6199 struct ppc_link_hash_table
*htab
;
6201 htab
= ppc_hash_table (info
);
6205 /* Provide any missing _save* and _rest* functions. */
6206 if (htab
->sfpr
!= NULL
)
6210 htab
->sfpr
->size
= 0;
6211 for (i
= 0; i
< ARRAY_SIZE (save_res_funcs
); i
++)
6212 if (!sfpr_define (info
, &save_res_funcs
[i
], NULL
))
6214 if (htab
->sfpr
->size
== 0)
6215 htab
->sfpr
->flags
|= SEC_EXCLUDE
;
6218 if (bfd_link_relocatable (info
))
6221 if (htab
->elf
.hgot
!= NULL
)
6223 _bfd_elf_link_hash_hide_symbol (info
, htab
->elf
.hgot
, TRUE
);
6224 /* Make .TOC. defined so as to prevent it being made dynamic.
6225 The wrong value here is fixed later in ppc64_elf_set_toc. */
6226 if (!htab
->elf
.hgot
->def_regular
6227 || htab
->elf
.hgot
->root
.type
!= bfd_link_hash_defined
)
6229 htab
->elf
.hgot
->root
.type
= bfd_link_hash_defined
;
6230 htab
->elf
.hgot
->root
.u
.def
.value
= 0;
6231 htab
->elf
.hgot
->root
.u
.def
.section
= bfd_abs_section_ptr
;
6232 htab
->elf
.hgot
->def_regular
= 1;
6233 htab
->elf
.hgot
->root
.linker_def
= 1;
6235 htab
->elf
.hgot
->type
= STT_OBJECT
;
6236 htab
->elf
.hgot
->other
6237 = (htab
->elf
.hgot
->other
& ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN
;
6240 if (htab
->need_func_desc_adj
)
6242 elf_link_hash_traverse (&htab
->elf
, func_desc_adjust
, info
);
6243 htab
->need_func_desc_adj
= 0;
6249 /* Find dynamic relocs for H that apply to read-only sections. */
6252 readonly_dynrelocs (struct elf_link_hash_entry
*h
)
6254 struct ppc_link_hash_entry
*eh
;
6255 struct elf_dyn_relocs
*p
;
6257 eh
= (struct ppc_link_hash_entry
*) h
;
6258 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
6260 asection
*s
= p
->sec
->output_section
;
6262 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
6268 /* Return true if we have dynamic relocs against H or any of its weak
6269 aliases, that apply to read-only sections. Cannot be used after
6270 size_dynamic_sections. */
6273 alias_readonly_dynrelocs (struct elf_link_hash_entry
*h
)
6275 struct ppc_link_hash_entry
*eh
;
6277 eh
= (struct ppc_link_hash_entry
*) h
;
6280 if (readonly_dynrelocs (&eh
->elf
))
6282 eh
= (struct ppc_link_hash_entry
*) eh
->elf
.u
.alias
;
6284 while (eh
!= NULL
&& &eh
->elf
!= h
);
6289 /* Return whether EH has pc-relative dynamic relocs. */
6292 pc_dynrelocs (struct ppc_link_hash_entry
*eh
)
6294 struct elf_dyn_relocs
*p
;
6296 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
6297 if (p
->pc_count
!= 0)
6302 /* Return true if a global entry stub will be created for H. Valid
6303 for ELFv2 before plt entries have been allocated. */
6306 global_entry_stub (struct elf_link_hash_entry
*h
)
6308 struct plt_entry
*pent
;
6310 if (!h
->pointer_equality_needed
6314 for (pent
= h
->plt
.plist
; pent
!= NULL
; pent
= pent
->next
)
6315 if (pent
->plt
.refcount
> 0
6316 && pent
->addend
== 0)
6322 /* Adjust a symbol defined by a dynamic object and referenced by a
6323 regular object. The current definition is in some section of the
6324 dynamic object, but we're not including those sections. We have to
6325 change the definition to something the rest of the link can
6329 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
6330 struct elf_link_hash_entry
*h
)
6332 struct ppc_link_hash_table
*htab
;
6335 htab
= ppc_hash_table (info
);
6339 /* Deal with function syms. */
6340 if (h
->type
== STT_FUNC
6341 || h
->type
== STT_GNU_IFUNC
6344 bfd_boolean local
= (((struct ppc_link_hash_entry
*) h
)->save_res
6345 || SYMBOL_CALLS_LOCAL (info
, h
)
6346 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
));
6347 /* Discard dyn_relocs when non-pic if we've decided that a
6348 function symbol is local and not an ifunc. We keep dynamic
6349 relocs for ifuncs when local rather than always emitting a
6350 plt call stub for them and defining the symbol on the call
6351 stub. We can't do that for ELFv1 anyway (a function symbol
6352 is defined on a descriptor, not code) and it can be faster at
6353 run-time due to not needing to bounce through a stub. The
6354 dyn_relocs for ifuncs will be applied even in a static
6356 if (!bfd_link_pic (info
)
6357 && h
->type
!= STT_GNU_IFUNC
6359 ((struct ppc_link_hash_entry
*) h
)->dyn_relocs
= NULL
;
6361 /* Clear procedure linkage table information for any symbol that
6362 won't need a .plt entry. */
6363 struct plt_entry
*ent
;
6364 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
6365 if (ent
->plt
.refcount
> 0)
6368 || (h
->type
!= STT_GNU_IFUNC
6370 && (htab
->can_convert_all_inline_plt
6371 || (((struct ppc_link_hash_entry
*) h
)->tls_mask
6372 & (TLS_TLS
| PLT_KEEP
)) != PLT_KEEP
)))
6374 h
->plt
.plist
= NULL
;
6376 h
->pointer_equality_needed
= 0;
6378 else if (abiversion (info
->output_bfd
) >= 2)
6380 /* Taking a function's address in a read/write section
6381 doesn't require us to define the function symbol in the
6382 executable on a global entry stub. A dynamic reloc can
6383 be used instead. The reason we prefer a few more dynamic
6384 relocs is that calling via a global entry stub costs a
6385 few more instructions, and pointer_equality_needed causes
6386 extra work in ld.so when resolving these symbols. */
6387 if (global_entry_stub (h
))
6389 if (!readonly_dynrelocs (h
))
6391 h
->pointer_equality_needed
= 0;
6392 /* If we haven't seen a branch reloc and the symbol
6393 isn't an ifunc then we don't need a plt entry. */
6395 h
->plt
.plist
= NULL
;
6397 else if (!bfd_link_pic (info
))
6398 /* We are going to be defining the function symbol on the
6399 plt stub, so no dyn_relocs needed when non-pic. */
6400 ((struct ppc_link_hash_entry
*) h
)->dyn_relocs
= NULL
;
6403 /* ELFv2 function symbols can't have copy relocs. */
6406 else if (!h
->needs_plt
6407 && !readonly_dynrelocs (h
))
6409 /* If we haven't seen a branch reloc and the symbol isn't an
6410 ifunc then we don't need a plt entry. */
6411 h
->plt
.plist
= NULL
;
6412 h
->pointer_equality_needed
= 0;
6417 h
->plt
.plist
= NULL
;
6419 /* If this is a weak symbol, and there is a real definition, the
6420 processor independent code will have arranged for us to see the
6421 real definition first, and we can just use the same value. */
6422 if (h
->is_weakalias
)
6424 struct elf_link_hash_entry
*def
= weakdef (h
);
6425 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
6426 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
6427 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
6428 if (def
->root
.u
.def
.section
== htab
->elf
.sdynbss
6429 || def
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
6430 ((struct ppc_link_hash_entry
*) h
)->dyn_relocs
= NULL
;
6434 /* If we are creating a shared library, we must presume that the
6435 only references to the symbol are via the global offset table.
6436 For such cases we need not do anything here; the relocations will
6437 be handled correctly by relocate_section. */
6438 if (!bfd_link_executable (info
))
6441 /* If there are no references to this symbol that do not use the
6442 GOT, we don't need to generate a copy reloc. */
6443 if (!h
->non_got_ref
)
6446 /* Don't generate a copy reloc for symbols defined in the executable. */
6447 if (!h
->def_dynamic
|| !h
->ref_regular
|| h
->def_regular
6449 /* If -z nocopyreloc was given, don't generate them either. */
6450 || info
->nocopyreloc
6452 /* If we don't find any dynamic relocs in read-only sections, then
6453 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
6454 || (ELIMINATE_COPY_RELOCS
6456 && !alias_readonly_dynrelocs (h
))
6458 /* Protected variables do not work with .dynbss. The copy in
6459 .dynbss won't be used by the shared library with the protected
6460 definition for the variable. Text relocations are preferable
6461 to an incorrect program. */
6462 || h
->protected_def
)
6465 if (h
->type
== STT_FUNC
6466 || h
->type
== STT_GNU_IFUNC
)
6468 /* .dynbss copies of function symbols only work if we have
6469 ELFv1 dot-symbols. ELFv1 compilers since 2004 default to not
6470 use dot-symbols and set the function symbol size to the text
6471 size of the function rather than the size of the descriptor.
6472 That's wrong for copying a descriptor. */
6473 if (((struct ppc_link_hash_entry
*) h
)->oh
== NULL
6474 || !(h
->size
== 24 || h
->size
== 16))
6477 /* We should never get here, but unfortunately there are old
6478 versions of gcc (circa gcc-3.2) that improperly for the
6479 ELFv1 ABI put initialized function pointers, vtable refs and
6480 suchlike in read-only sections. Allow them to proceed, but
6481 warn that this might break at runtime. */
6482 info
->callbacks
->einfo
6483 (_("%P: copy reloc against `%pT' requires lazy plt linking; "
6484 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
6485 h
->root
.root
.string
);
6488 /* This is a reference to a symbol defined by a dynamic object which
6489 is not a function. */
6491 /* We must allocate the symbol in our .dynbss section, which will
6492 become part of the .bss section of the executable. There will be
6493 an entry for this symbol in the .dynsym section. The dynamic
6494 object will contain position independent code, so all references
6495 from the dynamic object to this symbol will go through the global
6496 offset table. The dynamic linker will use the .dynsym entry to
6497 determine the address it must put in the global offset table, so
6498 both the dynamic object and the regular object will refer to the
6499 same memory location for the variable. */
6500 if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
6502 s
= htab
->elf
.sdynrelro
;
6503 srel
= htab
->elf
.sreldynrelro
;
6507 s
= htab
->elf
.sdynbss
;
6508 srel
= htab
->elf
.srelbss
;
6510 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
6512 /* We must generate a R_PPC64_COPY reloc to tell the dynamic
6513 linker to copy the initial value out of the dynamic object
6514 and into the runtime process image. */
6515 srel
->size
+= sizeof (Elf64_External_Rela
);
6519 /* We no longer want dyn_relocs. */
6520 ((struct ppc_link_hash_entry
*) h
)->dyn_relocs
= NULL
;
6521 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
6524 /* If given a function descriptor symbol, hide both the function code
6525 sym and the descriptor. */
6527 ppc64_elf_hide_symbol (struct bfd_link_info
*info
,
6528 struct elf_link_hash_entry
*h
,
6529 bfd_boolean force_local
)
6531 struct ppc_link_hash_entry
*eh
;
6532 _bfd_elf_link_hash_hide_symbol (info
, h
, force_local
);
6534 if (ppc_hash_table (info
) == NULL
)
6537 eh
= (struct ppc_link_hash_entry
*) h
;
6538 if (eh
->is_func_descriptor
)
6540 struct ppc_link_hash_entry
*fh
= eh
->oh
;
6545 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
6548 /* We aren't supposed to use alloca in BFD because on
6549 systems which do not have alloca the version in libiberty
6550 calls xmalloc, which might cause the program to crash
6551 when it runs out of memory. This function doesn't have a
6552 return status, so there's no way to gracefully return an
6553 error. So cheat. We know that string[-1] can be safely
6554 accessed; It's either a string in an ELF string table,
6555 or allocated in an objalloc structure. */
6557 p
= eh
->elf
.root
.root
.string
- 1;
6560 fh
= (struct ppc_link_hash_entry
*)
6561 elf_link_hash_lookup (htab
, p
, FALSE
, FALSE
, FALSE
);
6564 /* Unfortunately, if it so happens that the string we were
6565 looking for was allocated immediately before this string,
6566 then we overwrote the string terminator. That's the only
6567 reason the lookup should fail. */
6570 q
= eh
->elf
.root
.root
.string
+ strlen (eh
->elf
.root
.root
.string
);
6571 while (q
>= eh
->elf
.root
.root
.string
&& *q
== *p
)
6573 if (q
< eh
->elf
.root
.root
.string
&& *p
== '.')
6574 fh
= (struct ppc_link_hash_entry
*)
6575 elf_link_hash_lookup (htab
, p
, FALSE
, FALSE
, FALSE
);
6584 _bfd_elf_link_hash_hide_symbol (info
, &fh
->elf
, force_local
);
6589 get_sym_h (struct elf_link_hash_entry
**hp
,
6590 Elf_Internal_Sym
**symp
,
6592 unsigned char **tls_maskp
,
6593 Elf_Internal_Sym
**locsymsp
,
6594 unsigned long r_symndx
,
6597 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (ibfd
);
6599 if (r_symndx
>= symtab_hdr
->sh_info
)
6601 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (ibfd
);
6602 struct elf_link_hash_entry
*h
;
6604 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
6605 h
= elf_follow_link (h
);
6613 if (symsecp
!= NULL
)
6615 asection
*symsec
= NULL
;
6616 if (h
->root
.type
== bfd_link_hash_defined
6617 || h
->root
.type
== bfd_link_hash_defweak
)
6618 symsec
= h
->root
.u
.def
.section
;
6622 if (tls_maskp
!= NULL
)
6624 struct ppc_link_hash_entry
*eh
;
6626 eh
= (struct ppc_link_hash_entry
*) h
;
6627 *tls_maskp
= &eh
->tls_mask
;
6632 Elf_Internal_Sym
*sym
;
6633 Elf_Internal_Sym
*locsyms
= *locsymsp
;
6635 if (locsyms
== NULL
)
6637 locsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
6638 if (locsyms
== NULL
)
6639 locsyms
= bfd_elf_get_elf_syms (ibfd
, symtab_hdr
,
6640 symtab_hdr
->sh_info
,
6641 0, NULL
, NULL
, NULL
);
6642 if (locsyms
== NULL
)
6644 *locsymsp
= locsyms
;
6646 sym
= locsyms
+ r_symndx
;
6654 if (symsecp
!= NULL
)
6655 *symsecp
= bfd_section_from_elf_index (ibfd
, sym
->st_shndx
);
6657 if (tls_maskp
!= NULL
)
6659 struct got_entry
**lgot_ents
;
6660 unsigned char *tls_mask
;
6663 lgot_ents
= elf_local_got_ents (ibfd
);
6664 if (lgot_ents
!= NULL
)
6666 struct plt_entry
**local_plt
= (struct plt_entry
**)
6667 (lgot_ents
+ symtab_hdr
->sh_info
);
6668 unsigned char *lgot_masks
= (unsigned char *)
6669 (local_plt
+ symtab_hdr
->sh_info
);
6670 tls_mask
= &lgot_masks
[r_symndx
];
6672 *tls_maskp
= tls_mask
;
6678 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
6679 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
6680 type suitable for optimization, and 1 otherwise. */
6683 get_tls_mask (unsigned char **tls_maskp
,
6684 unsigned long *toc_symndx
,
6685 bfd_vma
*toc_addend
,
6686 Elf_Internal_Sym
**locsymsp
,
6687 const Elf_Internal_Rela
*rel
,
6690 unsigned long r_symndx
;
6692 struct elf_link_hash_entry
*h
;
6693 Elf_Internal_Sym
*sym
;
6697 r_symndx
= ELF64_R_SYM (rel
->r_info
);
6698 if (!get_sym_h (&h
, &sym
, &sec
, tls_maskp
, locsymsp
, r_symndx
, ibfd
))
6701 if ((*tls_maskp
!= NULL
6702 && (**tls_maskp
& TLS_TLS
) != 0
6703 && **tls_maskp
!= (TLS_TLS
| TLS_MARK
))
6705 || ppc64_elf_section_data (sec
) == NULL
6706 || ppc64_elf_section_data (sec
)->sec_type
!= sec_toc
)
6709 /* Look inside a TOC section too. */
6712 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
);
6713 off
= h
->root
.u
.def
.value
;
6716 off
= sym
->st_value
;
6717 off
+= rel
->r_addend
;
6718 BFD_ASSERT (off
% 8 == 0);
6719 r_symndx
= ppc64_elf_section_data (sec
)->u
.toc
.symndx
[off
/ 8];
6720 next_r
= ppc64_elf_section_data (sec
)->u
.toc
.symndx
[off
/ 8 + 1];
6721 if (toc_symndx
!= NULL
)
6722 *toc_symndx
= r_symndx
;
6723 if (toc_addend
!= NULL
)
6724 *toc_addend
= ppc64_elf_section_data (sec
)->u
.toc
.add
[off
/ 8];
6725 if (!get_sym_h (&h
, &sym
, &sec
, tls_maskp
, locsymsp
, r_symndx
, ibfd
))
6727 if ((h
== NULL
|| is_static_defined (h
))
6728 && (next_r
== -1 || next_r
== -2))
6733 /* Find (or create) an entry in the tocsave hash table. */
6735 static struct tocsave_entry
*
6736 tocsave_find (struct ppc_link_hash_table
*htab
,
6737 enum insert_option insert
,
6738 Elf_Internal_Sym
**local_syms
,
6739 const Elf_Internal_Rela
*irela
,
6742 unsigned long r_indx
;
6743 struct elf_link_hash_entry
*h
;
6744 Elf_Internal_Sym
*sym
;
6745 struct tocsave_entry ent
, *p
;
6747 struct tocsave_entry
**slot
;
6749 r_indx
= ELF64_R_SYM (irela
->r_info
);
6750 if (!get_sym_h (&h
, &sym
, &ent
.sec
, NULL
, local_syms
, r_indx
, ibfd
))
6752 if (ent
.sec
== NULL
|| ent
.sec
->output_section
== NULL
)
6755 (_("%pB: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd
);
6760 ent
.offset
= h
->root
.u
.def
.value
;
6762 ent
.offset
= sym
->st_value
;
6763 ent
.offset
+= irela
->r_addend
;
6765 hash
= tocsave_htab_hash (&ent
);
6766 slot
= ((struct tocsave_entry
**)
6767 htab_find_slot_with_hash (htab
->tocsave_htab
, &ent
, hash
, insert
));
6773 p
= (struct tocsave_entry
*) bfd_alloc (ibfd
, sizeof (*p
));
6782 /* Adjust all global syms defined in opd sections. In gcc generated
6783 code for the old ABI, these will already have been done. */
6786 adjust_opd_syms (struct elf_link_hash_entry
*h
, void *inf ATTRIBUTE_UNUSED
)
6788 struct ppc_link_hash_entry
*eh
;
6790 struct _opd_sec_data
*opd
;
6792 if (h
->root
.type
== bfd_link_hash_indirect
)
6795 if (h
->root
.type
!= bfd_link_hash_defined
6796 && h
->root
.type
!= bfd_link_hash_defweak
)
6799 eh
= (struct ppc_link_hash_entry
*) h
;
6800 if (eh
->adjust_done
)
6803 sym_sec
= eh
->elf
.root
.u
.def
.section
;
6804 opd
= get_opd_info (sym_sec
);
6805 if (opd
!= NULL
&& opd
->adjust
!= NULL
)
6807 long adjust
= opd
->adjust
[OPD_NDX (eh
->elf
.root
.u
.def
.value
)];
6810 /* This entry has been deleted. */
6811 asection
*dsec
= ppc64_elf_tdata (sym_sec
->owner
)->deleted_section
;
6814 for (dsec
= sym_sec
->owner
->sections
; dsec
; dsec
= dsec
->next
)
6815 if (discarded_section (dsec
))
6817 ppc64_elf_tdata (sym_sec
->owner
)->deleted_section
= dsec
;
6821 eh
->elf
.root
.u
.def
.value
= 0;
6822 eh
->elf
.root
.u
.def
.section
= dsec
;
6825 eh
->elf
.root
.u
.def
.value
+= adjust
;
6826 eh
->adjust_done
= 1;
6831 /* Handles decrementing dynamic reloc counts for the reloc specified by
6832 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
6833 have already been determined. */
6836 dec_dynrel_count (bfd_vma r_info
,
6838 struct bfd_link_info
*info
,
6839 Elf_Internal_Sym
**local_syms
,
6840 struct elf_link_hash_entry
*h
,
6841 Elf_Internal_Sym
*sym
)
6843 enum elf_ppc64_reloc_type r_type
;
6844 asection
*sym_sec
= NULL
;
6846 /* Can this reloc be dynamic? This switch, and later tests here
6847 should be kept in sync with the code in check_relocs. */
6848 r_type
= ELF64_R_TYPE (r_info
);
6855 case R_PPC64_TOC16_DS
:
6856 case R_PPC64_TOC16_LO
:
6857 case R_PPC64_TOC16_HI
:
6858 case R_PPC64_TOC16_HA
:
6859 case R_PPC64_TOC16_LO_DS
:
6864 case R_PPC64_TPREL16
:
6865 case R_PPC64_TPREL16_LO
:
6866 case R_PPC64_TPREL16_HI
:
6867 case R_PPC64_TPREL16_HA
:
6868 case R_PPC64_TPREL16_DS
:
6869 case R_PPC64_TPREL16_LO_DS
:
6870 case R_PPC64_TPREL16_HIGH
:
6871 case R_PPC64_TPREL16_HIGHA
:
6872 case R_PPC64_TPREL16_HIGHER
:
6873 case R_PPC64_TPREL16_HIGHERA
:
6874 case R_PPC64_TPREL16_HIGHEST
:
6875 case R_PPC64_TPREL16_HIGHESTA
:
6876 case R_PPC64_TPREL64
:
6877 case R_PPC64_TPREL34
:
6878 case R_PPC64_DTPMOD64
:
6879 case R_PPC64_DTPREL64
:
6880 case R_PPC64_ADDR64
:
6884 case R_PPC64_ADDR14
:
6885 case R_PPC64_ADDR14_BRNTAKEN
:
6886 case R_PPC64_ADDR14_BRTAKEN
:
6887 case R_PPC64_ADDR16
:
6888 case R_PPC64_ADDR16_DS
:
6889 case R_PPC64_ADDR16_HA
:
6890 case R_PPC64_ADDR16_HI
:
6891 case R_PPC64_ADDR16_HIGH
:
6892 case R_PPC64_ADDR16_HIGHA
:
6893 case R_PPC64_ADDR16_HIGHER
:
6894 case R_PPC64_ADDR16_HIGHERA
:
6895 case R_PPC64_ADDR16_HIGHEST
:
6896 case R_PPC64_ADDR16_HIGHESTA
:
6897 case R_PPC64_ADDR16_LO
:
6898 case R_PPC64_ADDR16_LO_DS
:
6899 case R_PPC64_ADDR24
:
6900 case R_PPC64_ADDR32
:
6901 case R_PPC64_UADDR16
:
6902 case R_PPC64_UADDR32
:
6903 case R_PPC64_UADDR64
:
6906 case R_PPC64_D34_LO
:
6907 case R_PPC64_D34_HI30
:
6908 case R_PPC64_D34_HA30
:
6909 case R_PPC64_ADDR16_HIGHER34
:
6910 case R_PPC64_ADDR16_HIGHERA34
:
6911 case R_PPC64_ADDR16_HIGHEST34
:
6912 case R_PPC64_ADDR16_HIGHESTA34
:
6917 if (local_syms
!= NULL
)
6919 unsigned long r_symndx
;
6920 bfd
*ibfd
= sec
->owner
;
6922 r_symndx
= ELF64_R_SYM (r_info
);
6923 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, local_syms
, r_symndx
, ibfd
))
6928 && (h
->root
.type
== bfd_link_hash_defweak
6929 || !h
->def_regular
))
6931 && !bfd_link_executable (info
)
6932 && !SYMBOLIC_BIND (info
, h
))
6933 || (bfd_link_pic (info
)
6934 && must_be_dyn_reloc (info
, r_type
))
6935 || (!bfd_link_pic (info
)
6937 ? h
->type
== STT_GNU_IFUNC
6938 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)))
6945 struct elf_dyn_relocs
*p
;
6946 struct elf_dyn_relocs
**pp
;
6947 pp
= &((struct ppc_link_hash_entry
*) h
)->dyn_relocs
;
6949 /* elf_gc_sweep may have already removed all dyn relocs associated
6950 with local syms for a given section. Also, symbol flags are
6951 changed by elf_gc_sweep_symbol, confusing the test above. Don't
6952 report a dynreloc miscount. */
6953 if (*pp
== NULL
&& info
->gc_sections
)
6956 while ((p
= *pp
) != NULL
)
6960 if (!must_be_dyn_reloc (info
, r_type
))
6972 struct ppc_dyn_relocs
*p
;
6973 struct ppc_dyn_relocs
**pp
;
6975 bfd_boolean is_ifunc
;
6977 if (local_syms
== NULL
)
6978 sym_sec
= bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
6979 if (sym_sec
== NULL
)
6982 vpp
= &elf_section_data (sym_sec
)->local_dynrel
;
6983 pp
= (struct ppc_dyn_relocs
**) vpp
;
6985 if (*pp
== NULL
&& info
->gc_sections
)
6988 is_ifunc
= ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
;
6989 while ((p
= *pp
) != NULL
)
6991 if (p
->sec
== sec
&& p
->ifunc
== is_ifunc
)
7002 /* xgettext:c-format */
7003 _bfd_error_handler (_("dynreloc miscount for %pB, section %pA"),
7005 bfd_set_error (bfd_error_bad_value
);
7009 /* Remove unused Official Procedure Descriptor entries. Currently we
7010 only remove those associated with functions in discarded link-once
7011 sections, or weakly defined functions that have been overridden. It
7012 would be possible to remove many more entries for statically linked
7016 ppc64_elf_edit_opd (struct bfd_link_info
*info
)
7019 bfd_boolean some_edited
= FALSE
;
7020 asection
*need_pad
= NULL
;
7021 struct ppc_link_hash_table
*htab
;
7023 htab
= ppc_hash_table (info
);
7027 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
7030 Elf_Internal_Rela
*relstart
, *rel
, *relend
;
7031 Elf_Internal_Shdr
*symtab_hdr
;
7032 Elf_Internal_Sym
*local_syms
;
7033 struct _opd_sec_data
*opd
;
7034 bfd_boolean need_edit
, add_aux_fields
, broken
;
7035 bfd_size_type cnt_16b
= 0;
7037 if (!is_ppc64_elf (ibfd
))
7040 sec
= bfd_get_section_by_name (ibfd
, ".opd");
7041 if (sec
== NULL
|| sec
->size
== 0)
7044 if (sec
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
7047 if (sec
->output_section
== bfd_abs_section_ptr
)
7050 /* Look through the section relocs. */
7051 if ((sec
->flags
& SEC_RELOC
) == 0 || sec
->reloc_count
== 0)
7055 symtab_hdr
= &elf_symtab_hdr (ibfd
);
7057 /* Read the relocations. */
7058 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
7060 if (relstart
== NULL
)
7063 /* First run through the relocs to check they are sane, and to
7064 determine whether we need to edit this opd section. */
7068 relend
= relstart
+ sec
->reloc_count
;
7069 for (rel
= relstart
; rel
< relend
; )
7071 enum elf_ppc64_reloc_type r_type
;
7072 unsigned long r_symndx
;
7074 struct elf_link_hash_entry
*h
;
7075 Elf_Internal_Sym
*sym
;
7078 /* .opd contains an array of 16 or 24 byte entries. We're
7079 only interested in the reloc pointing to a function entry
7081 offset
= rel
->r_offset
;
7082 if (rel
+ 1 == relend
7083 || rel
[1].r_offset
!= offset
+ 8)
7085 /* If someone messes with .opd alignment then after a
7086 "ld -r" we might have padding in the middle of .opd.
7087 Also, there's nothing to prevent someone putting
7088 something silly in .opd with the assembler. No .opd
7089 optimization for them! */
7092 (_("%pB: .opd is not a regular array of opd entries"), ibfd
);
7097 if ((r_type
= ELF64_R_TYPE (rel
->r_info
)) != R_PPC64_ADDR64
7098 || (r_type
= ELF64_R_TYPE ((rel
+ 1)->r_info
)) != R_PPC64_TOC
)
7101 /* xgettext:c-format */
7102 (_("%pB: unexpected reloc type %u in .opd section"),
7108 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7109 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
7113 if (sym_sec
== NULL
|| sym_sec
->owner
== NULL
)
7115 const char *sym_name
;
7117 sym_name
= h
->root
.root
.string
;
7119 sym_name
= bfd_elf_sym_name (ibfd
, symtab_hdr
, sym
,
7123 /* xgettext:c-format */
7124 (_("%pB: undefined sym `%s' in .opd section"),
7130 /* opd entries are always for functions defined in the
7131 current input bfd. If the symbol isn't defined in the
7132 input bfd, then we won't be using the function in this
7133 bfd; It must be defined in a linkonce section in another
7134 bfd, or is weak. It's also possible that we are
7135 discarding the function due to a linker script /DISCARD/,
7136 which we test for via the output_section. */
7137 if (sym_sec
->owner
!= ibfd
7138 || sym_sec
->output_section
== bfd_abs_section_ptr
)
7142 if (rel
+ 1 == relend
7143 || (rel
+ 2 < relend
7144 && ELF64_R_TYPE (rel
[2].r_info
) == R_PPC64_TOC
))
7149 if (sec
->size
== offset
+ 24)
7154 if (sec
->size
== offset
+ 16)
7161 else if (rel
+ 1 < relend
7162 && ELF64_R_TYPE (rel
[0].r_info
) == R_PPC64_ADDR64
7163 && ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_TOC
)
7165 if (rel
[0].r_offset
== offset
+ 16)
7167 else if (rel
[0].r_offset
!= offset
+ 24)
7174 add_aux_fields
= htab
->params
->non_overlapping_opd
&& cnt_16b
> 0;
7176 if (!broken
&& (need_edit
|| add_aux_fields
))
7178 Elf_Internal_Rela
*write_rel
;
7179 Elf_Internal_Shdr
*rel_hdr
;
7180 bfd_byte
*rptr
, *wptr
;
7181 bfd_byte
*new_contents
;
7184 new_contents
= NULL
;
7185 amt
= OPD_NDX (sec
->size
) * sizeof (long);
7186 opd
= &ppc64_elf_section_data (sec
)->u
.opd
;
7187 opd
->adjust
= bfd_zalloc (sec
->owner
, amt
);
7188 if (opd
->adjust
== NULL
)
7191 /* This seems a waste of time as input .opd sections are all
7192 zeros as generated by gcc, but I suppose there's no reason
7193 this will always be so. We might start putting something in
7194 the third word of .opd entries. */
7195 if ((sec
->flags
& SEC_IN_MEMORY
) == 0)
7198 if (!bfd_malloc_and_get_section (ibfd
, sec
, &loc
))
7203 if (local_syms
!= NULL
7204 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
7206 if (elf_section_data (sec
)->relocs
!= relstart
)
7210 sec
->contents
= loc
;
7211 sec
->flags
|= (SEC_IN_MEMORY
| SEC_HAS_CONTENTS
);
7214 elf_section_data (sec
)->relocs
= relstart
;
7216 new_contents
= sec
->contents
;
7219 new_contents
= bfd_malloc (sec
->size
+ cnt_16b
* 8);
7220 if (new_contents
== NULL
)
7224 wptr
= new_contents
;
7225 rptr
= sec
->contents
;
7226 write_rel
= relstart
;
7227 for (rel
= relstart
; rel
< relend
; )
7229 unsigned long r_symndx
;
7231 struct elf_link_hash_entry
*h
;
7232 struct ppc_link_hash_entry
*fdh
= NULL
;
7233 Elf_Internal_Sym
*sym
;
7235 Elf_Internal_Rela
*next_rel
;
7238 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7239 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
7244 if (next_rel
+ 1 == relend
7245 || (next_rel
+ 2 < relend
7246 && ELF64_R_TYPE (next_rel
[2].r_info
) == R_PPC64_TOC
))
7249 /* See if the .opd entry is full 24 byte or
7250 16 byte (with fd_aux entry overlapped with next
7253 if (next_rel
== relend
)
7255 if (sec
->size
== rel
->r_offset
+ 16)
7258 else if (next_rel
->r_offset
== rel
->r_offset
+ 16)
7262 && h
->root
.root
.string
[0] == '.')
7264 fdh
= ((struct ppc_link_hash_entry
*) h
)->oh
;
7267 fdh
= ppc_follow_link (fdh
);
7268 if (fdh
->elf
.root
.type
!= bfd_link_hash_defined
7269 && fdh
->elf
.root
.type
!= bfd_link_hash_defweak
)
7274 skip
= (sym_sec
->owner
!= ibfd
7275 || sym_sec
->output_section
== bfd_abs_section_ptr
);
7278 if (fdh
!= NULL
&& sym_sec
->owner
== ibfd
)
7280 /* Arrange for the function descriptor sym
7282 fdh
->elf
.root
.u
.def
.value
= 0;
7283 fdh
->elf
.root
.u
.def
.section
= sym_sec
;
7285 opd
->adjust
[OPD_NDX (rel
->r_offset
)] = -1;
7287 if (NO_OPD_RELOCS
|| bfd_link_relocatable (info
))
7292 if (!dec_dynrel_count (rel
->r_info
, sec
, info
,
7296 if (++rel
== next_rel
)
7299 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7300 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
7307 /* We'll be keeping this opd entry. */
7312 /* Redefine the function descriptor symbol to
7313 this location in the opd section. It is
7314 necessary to update the value here rather
7315 than using an array of adjustments as we do
7316 for local symbols, because various places
7317 in the generic ELF code use the value
7318 stored in u.def.value. */
7319 fdh
->elf
.root
.u
.def
.value
= wptr
- new_contents
;
7320 fdh
->adjust_done
= 1;
7323 /* Local syms are a bit tricky. We could
7324 tweak them as they can be cached, but
7325 we'd need to look through the local syms
7326 for the function descriptor sym which we
7327 don't have at the moment. So keep an
7328 array of adjustments. */
7329 adjust
= (wptr
- new_contents
) - (rptr
- sec
->contents
);
7330 opd
->adjust
[OPD_NDX (rel
->r_offset
)] = adjust
;
7333 memcpy (wptr
, rptr
, opd_ent_size
);
7334 wptr
+= opd_ent_size
;
7335 if (add_aux_fields
&& opd_ent_size
== 16)
7337 memset (wptr
, '\0', 8);
7341 /* We need to adjust any reloc offsets to point to the
7343 for ( ; rel
!= next_rel
; ++rel
)
7345 rel
->r_offset
+= adjust
;
7346 if (write_rel
!= rel
)
7347 memcpy (write_rel
, rel
, sizeof (*rel
));
7352 rptr
+= opd_ent_size
;
7355 sec
->size
= wptr
- new_contents
;
7356 sec
->reloc_count
= write_rel
- relstart
;
7359 free (sec
->contents
);
7360 sec
->contents
= new_contents
;
7363 /* Fudge the header size too, as this is used later in
7364 elf_bfd_final_link if we are emitting relocs. */
7365 rel_hdr
= _bfd_elf_single_rel_hdr (sec
);
7366 rel_hdr
->sh_size
= sec
->reloc_count
* rel_hdr
->sh_entsize
;
7369 else if (elf_section_data (sec
)->relocs
!= relstart
)
7372 if (local_syms
!= NULL
7373 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
7375 if (!info
->keep_memory
)
7378 symtab_hdr
->contents
= (unsigned char *) local_syms
;
7383 elf_link_hash_traverse (elf_hash_table (info
), adjust_opd_syms
, NULL
);
7385 /* If we are doing a final link and the last .opd entry is just 16 byte
7386 long, add a 8 byte padding after it. */
7387 if (need_pad
!= NULL
&& !bfd_link_relocatable (info
))
7391 if ((need_pad
->flags
& SEC_IN_MEMORY
) == 0)
7393 BFD_ASSERT (need_pad
->size
> 0);
7395 p
= bfd_malloc (need_pad
->size
+ 8);
7399 if (!bfd_get_section_contents (need_pad
->owner
, need_pad
,
7400 p
, 0, need_pad
->size
))
7403 need_pad
->contents
= p
;
7404 need_pad
->flags
|= (SEC_IN_MEMORY
| SEC_HAS_CONTENTS
);
7408 p
= bfd_realloc (need_pad
->contents
, need_pad
->size
+ 8);
7412 need_pad
->contents
= p
;
7415 memset (need_pad
->contents
+ need_pad
->size
, 0, 8);
7416 need_pad
->size
+= 8;
7422 /* Analyze inline PLT call relocations to see whether calls to locally
7423 defined functions can be converted to direct calls. */
7426 ppc64_elf_inline_plt (struct bfd_link_info
*info
)
7428 struct ppc_link_hash_table
*htab
;
7431 bfd_vma low_vma
, high_vma
, limit
;
7433 htab
= ppc_hash_table (info
);
7437 /* A bl insn can reach -0x2000000 to 0x1fffffc. The limit is
7438 reduced somewhat to cater for possible stubs that might be added
7439 between the call and its destination. */
7440 if (htab
->params
->group_size
< 0)
7442 limit
= -htab
->params
->group_size
;
7448 limit
= htab
->params
->group_size
;
7455 for (sec
= info
->output_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7456 if ((sec
->flags
& (SEC_ALLOC
| SEC_CODE
)) == (SEC_ALLOC
| SEC_CODE
))
7458 if (low_vma
> sec
->vma
)
7460 if (high_vma
< sec
->vma
+ sec
->size
)
7461 high_vma
= sec
->vma
+ sec
->size
;
7464 /* If a "bl" can reach anywhere in local code sections, then we can
7465 convert all inline PLT sequences to direct calls when the symbol
7467 if (high_vma
- low_vma
< limit
)
7469 htab
->can_convert_all_inline_plt
= 1;
7473 /* Otherwise, go looking through relocs for cases where a direct
7474 call won't reach. Mark the symbol on any such reloc to disable
7475 the optimization and keep the PLT entry as it seems likely that
7476 this will be better than creating trampolines. Note that this
7477 will disable the optimization for all inline PLT calls to a
7478 particular symbol, not just those that won't reach. The
7479 difficulty in doing a more precise optimization is that the
7480 linker needs to make a decision depending on whether a
7481 particular R_PPC64_PLTCALL insn can be turned into a direct
7482 call, for each of the R_PPC64_PLTSEQ and R_PPC64_PLT16* insns in
7483 the sequence, and there is nothing that ties those relocs
7484 together except their symbol. */
7486 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
7488 Elf_Internal_Shdr
*symtab_hdr
;
7489 Elf_Internal_Sym
*local_syms
;
7491 if (!is_ppc64_elf (ibfd
))
7495 symtab_hdr
= &elf_symtab_hdr (ibfd
);
7497 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7498 if (ppc64_elf_section_data (sec
)->has_pltcall
7499 && !bfd_is_abs_section (sec
->output_section
))
7501 Elf_Internal_Rela
*relstart
, *rel
, *relend
;
7503 /* Read the relocations. */
7504 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
7506 if (relstart
== NULL
)
7509 relend
= relstart
+ sec
->reloc_count
;
7510 for (rel
= relstart
; rel
< relend
; )
7512 enum elf_ppc64_reloc_type r_type
;
7513 unsigned long r_symndx
;
7515 struct elf_link_hash_entry
*h
;
7516 Elf_Internal_Sym
*sym
;
7517 unsigned char *tls_maskp
;
7519 r_type
= ELF64_R_TYPE (rel
->r_info
);
7520 if (r_type
!= R_PPC64_PLTCALL
7521 && r_type
!= R_PPC64_PLTCALL_NOTOC
)
7524 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7525 if (!get_sym_h (&h
, &sym
, &sym_sec
, &tls_maskp
, &local_syms
,
7528 if (elf_section_data (sec
)->relocs
!= relstart
)
7530 if (local_syms
!= NULL
7531 && symtab_hdr
->contents
!= (bfd_byte
*) local_syms
)
7536 if (sym_sec
!= NULL
&& sym_sec
->output_section
!= NULL
)
7540 to
= h
->root
.u
.def
.value
;
7543 to
+= (rel
->r_addend
7544 + sym_sec
->output_offset
7545 + sym_sec
->output_section
->vma
);
7546 from
= (rel
->r_offset
7547 + sec
->output_offset
7548 + sec
->output_section
->vma
);
7549 if (to
- from
+ limit
< 2 * limit
7550 && !(r_type
== R_PPC64_PLTCALL_NOTOC
7551 && (((h
? h
->other
: sym
->st_other
)
7552 & STO_PPC64_LOCAL_MASK
)
7553 > 1 << STO_PPC64_LOCAL_BIT
)))
7554 *tls_maskp
&= ~PLT_KEEP
;
7557 if (elf_section_data (sec
)->relocs
!= relstart
)
7561 if (local_syms
!= NULL
7562 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
7564 if (!info
->keep_memory
)
7567 symtab_hdr
->contents
= (unsigned char *) local_syms
;
7574 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
7577 ppc64_elf_tls_setup (struct bfd_link_info
*info
)
7579 struct ppc_link_hash_table
*htab
;
7581 htab
= ppc_hash_table (info
);
7585 if (abiversion (info
->output_bfd
) == 1)
7588 if (htab
->params
->no_multi_toc
)
7589 htab
->do_multi_toc
= 0;
7590 else if (!htab
->do_multi_toc
)
7591 htab
->params
->no_multi_toc
= 1;
7593 /* Default to --no-plt-localentry, as this option can cause problems
7594 with symbol interposition. For example, glibc libpthread.so and
7595 libc.so duplicate many pthread symbols, with a fallback
7596 implementation in libc.so. In some cases the fallback does more
7597 work than the pthread implementation. __pthread_condattr_destroy
7598 is one such symbol: the libpthread.so implementation is
7599 localentry:0 while the libc.so implementation is localentry:8.
7600 An app that "cleverly" uses dlopen to only load necessary
7601 libraries at runtime may omit loading libpthread.so when not
7602 running multi-threaded, which then results in the libc.so
7603 fallback symbols being used and ld.so complaining. Now there
7604 are workarounds in ld (see non_zero_localentry) to detect the
7605 pthread situation, but that may not be the only case where
7606 --plt-localentry can cause trouble. */
7607 if (htab
->params
->plt_localentry0
< 0)
7608 htab
->params
->plt_localentry0
= 0;
7609 if (htab
->params
->plt_localentry0
7610 && elf_link_hash_lookup (&htab
->elf
, "GLIBC_2.26",
7611 FALSE
, FALSE
, FALSE
) == NULL
)
7613 (_("warning: --plt-localentry is especially dangerous without "
7614 "ld.so support to detect ABI violations"));
7616 htab
->tls_get_addr
= ((struct ppc_link_hash_entry
*)
7617 elf_link_hash_lookup (&htab
->elf
, ".__tls_get_addr",
7618 FALSE
, FALSE
, TRUE
));
7619 /* Move dynamic linking info to the function descriptor sym. */
7620 if (htab
->tls_get_addr
!= NULL
)
7621 func_desc_adjust (&htab
->tls_get_addr
->elf
, info
);
7622 htab
->tls_get_addr_fd
= ((struct ppc_link_hash_entry
*)
7623 elf_link_hash_lookup (&htab
->elf
, "__tls_get_addr",
7624 FALSE
, FALSE
, TRUE
));
7625 if (htab
->params
->tls_get_addr_opt
)
7627 struct elf_link_hash_entry
*opt
, *opt_fd
, *tga
, *tga_fd
;
7629 opt
= elf_link_hash_lookup (&htab
->elf
, ".__tls_get_addr_opt",
7630 FALSE
, FALSE
, TRUE
);
7632 func_desc_adjust (opt
, info
);
7633 opt_fd
= elf_link_hash_lookup (&htab
->elf
, "__tls_get_addr_opt",
7634 FALSE
, FALSE
, TRUE
);
7636 && (opt_fd
->root
.type
== bfd_link_hash_defined
7637 || opt_fd
->root
.type
== bfd_link_hash_defweak
))
7639 /* If glibc supports an optimized __tls_get_addr call stub,
7640 signalled by the presence of __tls_get_addr_opt, and we'll
7641 be calling __tls_get_addr via a plt call stub, then
7642 make __tls_get_addr point to __tls_get_addr_opt. */
7643 tga_fd
= &htab
->tls_get_addr_fd
->elf
;
7644 if (htab
->elf
.dynamic_sections_created
7646 && (tga_fd
->type
== STT_FUNC
7647 || tga_fd
->needs_plt
)
7648 && !(SYMBOL_CALLS_LOCAL (info
, tga_fd
)
7649 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, tga_fd
)))
7651 struct plt_entry
*ent
;
7653 for (ent
= tga_fd
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
7654 if (ent
->plt
.refcount
> 0)
7658 tga_fd
->root
.type
= bfd_link_hash_indirect
;
7659 tga_fd
->root
.u
.i
.link
= &opt_fd
->root
;
7660 ppc64_elf_copy_indirect_symbol (info
, opt_fd
, tga_fd
);
7662 if (opt_fd
->dynindx
!= -1)
7664 /* Use __tls_get_addr_opt in dynamic relocations. */
7665 opt_fd
->dynindx
= -1;
7666 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
7667 opt_fd
->dynstr_index
);
7668 if (!bfd_elf_link_record_dynamic_symbol (info
, opt_fd
))
7671 htab
->tls_get_addr_fd
7672 = (struct ppc_link_hash_entry
*) opt_fd
;
7673 tga
= &htab
->tls_get_addr
->elf
;
7674 if (opt
!= NULL
&& tga
!= NULL
)
7676 tga
->root
.type
= bfd_link_hash_indirect
;
7677 tga
->root
.u
.i
.link
= &opt
->root
;
7678 ppc64_elf_copy_indirect_symbol (info
, opt
, tga
);
7680 _bfd_elf_link_hash_hide_symbol (info
, opt
,
7682 htab
->tls_get_addr
= (struct ppc_link_hash_entry
*) opt
;
7684 htab
->tls_get_addr_fd
->oh
= htab
->tls_get_addr
;
7685 htab
->tls_get_addr_fd
->is_func_descriptor
= 1;
7686 if (htab
->tls_get_addr
!= NULL
)
7688 htab
->tls_get_addr
->oh
= htab
->tls_get_addr_fd
;
7689 htab
->tls_get_addr
->is_func
= 1;
7694 else if (htab
->params
->tls_get_addr_opt
< 0)
7695 htab
->params
->tls_get_addr_opt
= 0;
7697 return _bfd_elf_tls_setup (info
->output_bfd
, info
);
7700 /* Return TRUE iff REL is a branch reloc with a global symbol matching
7704 branch_reloc_hash_match (const bfd
*ibfd
,
7705 const Elf_Internal_Rela
*rel
,
7706 const struct ppc_link_hash_entry
*hash1
,
7707 const struct ppc_link_hash_entry
*hash2
)
7709 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (ibfd
);
7710 enum elf_ppc64_reloc_type r_type
= ELF64_R_TYPE (rel
->r_info
);
7711 unsigned int r_symndx
= ELF64_R_SYM (rel
->r_info
);
7713 if (r_symndx
>= symtab_hdr
->sh_info
&& is_branch_reloc (r_type
))
7715 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (ibfd
);
7716 struct elf_link_hash_entry
*h
;
7718 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
7719 h
= elf_follow_link (h
);
7720 if (h
== &hash1
->elf
|| h
== &hash2
->elf
)
7726 /* Run through all the TLS relocs looking for optimization
7727 opportunities. The linker has been hacked (see ppc64elf.em) to do
7728 a preliminary section layout so that we know the TLS segment
7729 offsets. We can't optimize earlier because some optimizations need
7730 to know the tp offset, and we need to optimize before allocating
7731 dynamic relocations. */
7734 ppc64_elf_tls_optimize (struct bfd_link_info
*info
)
7738 struct ppc_link_hash_table
*htab
;
7739 unsigned char *toc_ref
;
7742 if (!bfd_link_executable (info
))
7745 htab
= ppc_hash_table (info
);
7749 /* Make two passes over the relocs. On the first pass, mark toc
7750 entries involved with tls relocs, and check that tls relocs
7751 involved in setting up a tls_get_addr call are indeed followed by
7752 such a call. If they are not, we can't do any tls optimization.
7753 On the second pass twiddle tls_mask flags to notify
7754 relocate_section that optimization can be done, and adjust got
7755 and plt refcounts. */
7757 for (pass
= 0; pass
< 2; ++pass
)
7758 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
7760 Elf_Internal_Sym
*locsyms
= NULL
;
7761 asection
*toc
= bfd_get_section_by_name (ibfd
, ".toc");
7763 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7764 if (sec
->has_tls_reloc
&& !bfd_is_abs_section (sec
->output_section
))
7766 Elf_Internal_Rela
*relstart
, *rel
, *relend
;
7767 bfd_boolean found_tls_get_addr_arg
= 0;
7769 /* Read the relocations. */
7770 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
7772 if (relstart
== NULL
)
7778 relend
= relstart
+ sec
->reloc_count
;
7779 for (rel
= relstart
; rel
< relend
; rel
++)
7781 enum elf_ppc64_reloc_type r_type
;
7782 unsigned long r_symndx
;
7783 struct elf_link_hash_entry
*h
;
7784 Elf_Internal_Sym
*sym
;
7786 unsigned char *tls_mask
;
7787 unsigned int tls_set
, tls_clear
, tls_type
= 0;
7789 bfd_boolean ok_tprel
, is_local
;
7790 long toc_ref_index
= 0;
7791 int expecting_tls_get_addr
= 0;
7792 bfd_boolean ret
= FALSE
;
7794 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7795 if (!get_sym_h (&h
, &sym
, &sym_sec
, &tls_mask
, &locsyms
,
7799 if (elf_section_data (sec
)->relocs
!= relstart
)
7801 if (toc_ref
!= NULL
)
7804 && (elf_symtab_hdr (ibfd
).contents
7805 != (unsigned char *) locsyms
))
7812 if (h
->root
.type
== bfd_link_hash_defined
7813 || h
->root
.type
== bfd_link_hash_defweak
)
7814 value
= h
->root
.u
.def
.value
;
7815 else if (h
->root
.type
== bfd_link_hash_undefweak
)
7819 found_tls_get_addr_arg
= 0;
7824 /* Symbols referenced by TLS relocs must be of type
7825 STT_TLS. So no need for .opd local sym adjust. */
7826 value
= sym
->st_value
;
7829 is_local
= SYMBOL_REFERENCES_LOCAL (info
, h
);
7833 && h
->root
.type
== bfd_link_hash_undefweak
)
7835 else if (sym_sec
!= NULL
7836 && sym_sec
->output_section
!= NULL
)
7838 value
+= sym_sec
->output_offset
;
7839 value
+= sym_sec
->output_section
->vma
;
7840 value
-= htab
->elf
.tls_sec
->vma
+ TP_OFFSET
;
7841 /* Note that even though the prefix insns
7842 allow a 1<<33 offset we use the same test
7843 as for addis;addi. There may be a mix of
7844 pcrel and non-pcrel code and the decision
7845 to optimise is per symbol, not per TLS
7847 ok_tprel
= value
+ 0x80008000ULL
< 1ULL << 32;
7851 r_type
= ELF64_R_TYPE (rel
->r_info
);
7852 /* If this section has old-style __tls_get_addr calls
7853 without marker relocs, then check that each
7854 __tls_get_addr call reloc is preceded by a reloc
7855 that conceivably belongs to the __tls_get_addr arg
7856 setup insn. If we don't find matching arg setup
7857 relocs, don't do any tls optimization. */
7859 && sec
->nomark_tls_get_addr
7861 && (h
== &htab
->tls_get_addr
->elf
7862 || h
== &htab
->tls_get_addr_fd
->elf
)
7863 && !found_tls_get_addr_arg
7864 && is_branch_reloc (r_type
))
7866 info
->callbacks
->minfo (_("%H __tls_get_addr lost arg, "
7867 "TLS optimization disabled\n"),
7868 ibfd
, sec
, rel
->r_offset
);
7873 found_tls_get_addr_arg
= 0;
7876 case R_PPC64_GOT_TLSLD16
:
7877 case R_PPC64_GOT_TLSLD16_LO
:
7878 case R_PPC64_GOT_TLSLD34
:
7879 expecting_tls_get_addr
= 1;
7880 found_tls_get_addr_arg
= 1;
7883 case R_PPC64_GOT_TLSLD16_HI
:
7884 case R_PPC64_GOT_TLSLD16_HA
:
7885 /* These relocs should never be against a symbol
7886 defined in a shared lib. Leave them alone if
7887 that turns out to be the case. */
7894 tls_type
= TLS_TLS
| TLS_LD
;
7897 case R_PPC64_GOT_TLSGD16
:
7898 case R_PPC64_GOT_TLSGD16_LO
:
7899 case R_PPC64_GOT_TLSGD34
:
7900 expecting_tls_get_addr
= 1;
7901 found_tls_get_addr_arg
= 1;
7904 case R_PPC64_GOT_TLSGD16_HI
:
7905 case R_PPC64_GOT_TLSGD16_HA
:
7911 tls_set
= TLS_TLS
| TLS_GDIE
;
7913 tls_type
= TLS_TLS
| TLS_GD
;
7916 case R_PPC64_GOT_TPREL34
:
7917 case R_PPC64_GOT_TPREL16_DS
:
7918 case R_PPC64_GOT_TPREL16_LO_DS
:
7919 case R_PPC64_GOT_TPREL16_HI
:
7920 case R_PPC64_GOT_TPREL16_HA
:
7925 tls_clear
= TLS_TPREL
;
7926 tls_type
= TLS_TLS
| TLS_TPREL
;
7936 if (rel
+ 1 < relend
7937 && is_plt_seq_reloc (ELF64_R_TYPE (rel
[1].r_info
)))
7940 && (ELF64_R_TYPE (rel
[1].r_info
)
7942 && (ELF64_R_TYPE (rel
[1].r_info
)
7943 != R_PPC64_PLTSEQ_NOTOC
))
7945 r_symndx
= ELF64_R_SYM (rel
[1].r_info
);
7946 if (!get_sym_h (&h
, NULL
, NULL
, NULL
, &locsyms
,
7951 struct plt_entry
*ent
= NULL
;
7953 for (ent
= h
->plt
.plist
;
7956 if (ent
->addend
== rel
[1].r_addend
)
7960 && ent
->plt
.refcount
> 0)
7961 ent
->plt
.refcount
-= 1;
7966 found_tls_get_addr_arg
= 1;
7971 case R_PPC64_TOC16_LO
:
7972 if (sym_sec
== NULL
|| sym_sec
!= toc
)
7975 /* Mark this toc entry as referenced by a TLS
7976 code sequence. We can do that now in the
7977 case of R_PPC64_TLS, and after checking for
7978 tls_get_addr for the TOC16 relocs. */
7979 if (toc_ref
== NULL
)
7981 = bfd_zmalloc (toc
->output_section
->rawsize
/ 8);
7982 if (toc_ref
== NULL
)
7986 value
= h
->root
.u
.def
.value
;
7988 value
= sym
->st_value
;
7989 value
+= rel
->r_addend
;
7992 BFD_ASSERT (value
< toc
->size
7993 && toc
->output_offset
% 8 == 0);
7994 toc_ref_index
= (value
+ toc
->output_offset
) / 8;
7995 if (r_type
== R_PPC64_TLS
7996 || r_type
== R_PPC64_TLSGD
7997 || r_type
== R_PPC64_TLSLD
)
7999 toc_ref
[toc_ref_index
] = 1;
8003 if (pass
!= 0 && toc_ref
[toc_ref_index
] == 0)
8008 expecting_tls_get_addr
= 2;
8011 case R_PPC64_TPREL64
:
8015 || !toc_ref
[(rel
->r_offset
+ toc
->output_offset
) / 8])
8020 tls_set
= TLS_EXPLICIT
;
8021 tls_clear
= TLS_TPREL
;
8026 case R_PPC64_DTPMOD64
:
8030 || !toc_ref
[(rel
->r_offset
+ toc
->output_offset
) / 8])
8032 if (rel
+ 1 < relend
8034 == ELF64_R_INFO (r_symndx
, R_PPC64_DTPREL64
))
8035 && rel
[1].r_offset
== rel
->r_offset
+ 8)
8039 tls_set
= TLS_EXPLICIT
| TLS_GD
;
8042 tls_set
= TLS_EXPLICIT
| TLS_GD
| TLS_GDIE
;
8051 tls_set
= TLS_EXPLICIT
;
8062 if (!expecting_tls_get_addr
8063 || !sec
->nomark_tls_get_addr
)
8066 if (rel
+ 1 < relend
8067 && branch_reloc_hash_match (ibfd
, rel
+ 1,
8069 htab
->tls_get_addr_fd
))
8071 if (expecting_tls_get_addr
== 2)
8073 /* Check for toc tls entries. */
8074 unsigned char *toc_tls
;
8077 retval
= get_tls_mask (&toc_tls
, NULL
, NULL
,
8082 if (toc_tls
!= NULL
)
8084 if ((*toc_tls
& TLS_TLS
) != 0
8085 && ((*toc_tls
& (TLS_GD
| TLS_LD
)) != 0))
8086 found_tls_get_addr_arg
= 1;
8088 toc_ref
[toc_ref_index
] = 1;
8094 /* Uh oh, we didn't find the expected call. We
8095 could just mark this symbol to exclude it
8096 from tls optimization but it's safer to skip
8097 the entire optimization. */
8098 /* xgettext:c-format */
8099 info
->callbacks
->minfo (_("%H arg lost __tls_get_addr, "
8100 "TLS optimization disabled\n"),
8101 ibfd
, sec
, rel
->r_offset
);
8106 /* If we don't have old-style __tls_get_addr calls
8107 without TLSGD/TLSLD marker relocs, and we haven't
8108 found a new-style __tls_get_addr call with a
8109 marker for this symbol, then we either have a
8110 broken object file or an -mlongcall style
8111 indirect call to __tls_get_addr without a marker.
8112 Disable optimization in this case. */
8113 if ((tls_clear
& (TLS_GD
| TLS_LD
)) != 0
8114 && (tls_set
& TLS_EXPLICIT
) == 0
8115 && !sec
->nomark_tls_get_addr
8116 && ((*tls_mask
& (TLS_TLS
| TLS_MARK
))
8117 != (TLS_TLS
| TLS_MARK
)))
8120 if (expecting_tls_get_addr
== 1 + !sec
->nomark_tls_get_addr
)
8122 struct plt_entry
*ent
= NULL
;
8124 if (htab
->tls_get_addr
!= NULL
)
8125 for (ent
= htab
->tls_get_addr
->elf
.plt
.plist
;
8128 if (ent
->addend
== 0)
8131 if (ent
== NULL
&& htab
->tls_get_addr_fd
!= NULL
)
8132 for (ent
= htab
->tls_get_addr_fd
->elf
.plt
.plist
;
8135 if (ent
->addend
== 0)
8139 && ent
->plt
.refcount
> 0)
8140 ent
->plt
.refcount
-= 1;
8146 if ((tls_set
& TLS_EXPLICIT
) == 0)
8148 struct got_entry
*ent
;
8150 /* Adjust got entry for this reloc. */
8154 ent
= elf_local_got_ents (ibfd
)[r_symndx
];
8156 for (; ent
!= NULL
; ent
= ent
->next
)
8157 if (ent
->addend
== rel
->r_addend
8158 && ent
->owner
== ibfd
8159 && ent
->tls_type
== tls_type
)
8166 /* We managed to get rid of a got entry. */
8167 if (ent
->got
.refcount
> 0)
8168 ent
->got
.refcount
-= 1;
8173 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8174 we'll lose one or two dyn relocs. */
8175 if (!dec_dynrel_count (rel
->r_info
, sec
, info
,
8179 if (tls_set
== (TLS_EXPLICIT
| TLS_GD
))
8181 if (!dec_dynrel_count ((rel
+ 1)->r_info
, sec
, info
,
8187 *tls_mask
|= tls_set
& 0xff;
8188 *tls_mask
&= ~tls_clear
;
8191 if (elf_section_data (sec
)->relocs
!= relstart
)
8196 && (elf_symtab_hdr (ibfd
).contents
!= (unsigned char *) locsyms
))
8198 if (!info
->keep_memory
)
8201 elf_symtab_hdr (ibfd
).contents
= (unsigned char *) locsyms
;
8205 if (toc_ref
!= NULL
)
8207 htab
->do_tls_opt
= 1;
8211 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8212 the values of any global symbols in a toc section that has been
8213 edited. Globals in toc sections should be a rarity, so this function
8214 sets a flag if any are found in toc sections other than the one just
8215 edited, so that further hash table traversals can be avoided. */
8217 struct adjust_toc_info
8220 unsigned long *skip
;
8221 bfd_boolean global_toc_syms
;
8224 enum toc_skip_enum
{ ref_from_discarded
= 1, can_optimize
= 2 };
8227 adjust_toc_syms (struct elf_link_hash_entry
*h
, void *inf
)
8229 struct ppc_link_hash_entry
*eh
;
8230 struct adjust_toc_info
*toc_inf
= (struct adjust_toc_info
*) inf
;
8233 if (h
->root
.type
!= bfd_link_hash_defined
8234 && h
->root
.type
!= bfd_link_hash_defweak
)
8237 eh
= (struct ppc_link_hash_entry
*) h
;
8238 if (eh
->adjust_done
)
8241 if (eh
->elf
.root
.u
.def
.section
== toc_inf
->toc
)
8243 if (eh
->elf
.root
.u
.def
.value
> toc_inf
->toc
->rawsize
)
8244 i
= toc_inf
->toc
->rawsize
>> 3;
8246 i
= eh
->elf
.root
.u
.def
.value
>> 3;
8248 if ((toc_inf
->skip
[i
] & (ref_from_discarded
| can_optimize
)) != 0)
8251 (_("%s defined on removed toc entry"), eh
->elf
.root
.root
.string
);
8254 while ((toc_inf
->skip
[i
] & (ref_from_discarded
| can_optimize
)) != 0);
8255 eh
->elf
.root
.u
.def
.value
= (bfd_vma
) i
<< 3;
8258 eh
->elf
.root
.u
.def
.value
-= toc_inf
->skip
[i
];
8259 eh
->adjust_done
= 1;
8261 else if (strcmp (eh
->elf
.root
.u
.def
.section
->name
, ".toc") == 0)
8262 toc_inf
->global_toc_syms
= TRUE
;
8267 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
8268 on a _LO variety toc/got reloc. */
8271 ok_lo_toc_insn (unsigned int insn
, enum elf_ppc64_reloc_type r_type
)
8273 return ((insn
& (0x3fu
<< 26)) == 12u << 26 /* addic */
8274 || (insn
& (0x3fu
<< 26)) == 14u << 26 /* addi */
8275 || (insn
& (0x3fu
<< 26)) == 32u << 26 /* lwz */
8276 || (insn
& (0x3fu
<< 26)) == 34u << 26 /* lbz */
8277 || (insn
& (0x3fu
<< 26)) == 36u << 26 /* stw */
8278 || (insn
& (0x3fu
<< 26)) == 38u << 26 /* stb */
8279 || (insn
& (0x3fu
<< 26)) == 40u << 26 /* lhz */
8280 || (insn
& (0x3fu
<< 26)) == 42u << 26 /* lha */
8281 || (insn
& (0x3fu
<< 26)) == 44u << 26 /* sth */
8282 || (insn
& (0x3fu
<< 26)) == 46u << 26 /* lmw */
8283 || (insn
& (0x3fu
<< 26)) == 47u << 26 /* stmw */
8284 || (insn
& (0x3fu
<< 26)) == 48u << 26 /* lfs */
8285 || (insn
& (0x3fu
<< 26)) == 50u << 26 /* lfd */
8286 || (insn
& (0x3fu
<< 26)) == 52u << 26 /* stfs */
8287 || (insn
& (0x3fu
<< 26)) == 54u << 26 /* stfd */
8288 || (insn
& (0x3fu
<< 26)) == 56u << 26 /* lq,lfq */
8289 || ((insn
& (0x3fu
<< 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
8290 /* Exclude lfqu by testing reloc. If relocs are ever
8291 defined for the reduced D field in psq_lu then those
8292 will need testing too. */
8293 && r_type
!= R_PPC64_TOC16_LO
&& r_type
!= R_PPC64_GOT16_LO
)
8294 || ((insn
& (0x3fu
<< 26)) == 58u << 26 /* ld,lwa */
8296 || (insn
& (0x3fu
<< 26)) == 60u << 26 /* stfq */
8297 || ((insn
& (0x3fu
<< 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
8298 /* Exclude stfqu. psq_stu as above for psq_lu. */
8299 && r_type
!= R_PPC64_TOC16_LO
&& r_type
!= R_PPC64_GOT16_LO
)
8300 || ((insn
& (0x3fu
<< 26)) == 62u << 26 /* std,stq */
8301 && (insn
& 1) == 0));
8304 /* PCREL_OPT in one instance flags to the linker that a pair of insns:
8305 pld ra,symbol@got@pcrel
8306 load/store rt,off(ra)
8309 load/store rt,off(ra)
8310 may be translated to
8311 pload/pstore rt,symbol+off@pcrel
8313 This function returns true if the optimization is possible, placing
8314 the prefix insn in *PINSN1, a NOP in *PINSN2 and the offset in *POFF.
8316 On entry to this function, the linker has already determined that
8317 the pld can be replaced with pla: *PINSN1 is that pla insn,
8318 while *PINSN2 is the second instruction. */
8321 xlate_pcrel_opt (uint64_t *pinsn1
, uint64_t *pinsn2
, bfd_signed_vma
*poff
)
8323 uint64_t insn1
= *pinsn1
;
8324 uint64_t insn2
= *pinsn2
;
8327 if ((insn2
& (63ULL << 58)) == 1ULL << 58)
8329 /* Check that regs match. */
8330 if (((insn2
>> 16) & 31) != ((insn1
>> 21) & 31))
8333 /* P8LS or PMLS form, non-pcrel. */
8334 if ((insn2
& (-1ULL << 50) & ~(1ULL << 56)) != (1ULL << 58))
8337 *pinsn1
= (insn2
& ~(31 << 16) & ~0x3ffff0000ffffULL
) | (1ULL << 52);
8339 off
= ((insn2
>> 16) & 0x3ffff0000ULL
) | (insn2
& 0xffff);
8340 *poff
= (off
^ 0x200000000ULL
) - 0x200000000ULL
;
8346 /* Check that regs match. */
8347 if (((insn2
>> 16) & 31) != ((insn1
>> 21) & 31))
8350 switch ((insn2
>> 26) & 63)
8366 /* These are the PMLS cases, where we just need to tack a prefix
8368 insn1
= ((1ULL << 58) | (2ULL << 56) | (1ULL << 52)
8369 | (insn2
& ((63ULL << 26) | (31ULL << 21))));
8370 off
= insn2
& 0xffff;
8373 case 58: /* lwa, ld */
8374 if ((insn2
& 1) != 0)
8376 insn1
= ((1ULL << 58) | (1ULL << 52)
8377 | (insn2
& 2 ? 41ULL << 26 : 57ULL << 26)
8378 | (insn2
& (31ULL << 21)));
8379 off
= insn2
& 0xfffc;
8382 case 57: /* lxsd, lxssp */
8383 if ((insn2
& 3) < 2)
8385 insn1
= ((1ULL << 58) | (1ULL << 52)
8386 | ((40ULL | (insn2
& 3)) << 26)
8387 | (insn2
& (31ULL << 21)));
8388 off
= insn2
& 0xfffc;
8391 case 61: /* stxsd, stxssp, lxv, stxv */
8392 if ((insn2
& 3) == 0)
8394 else if ((insn2
& 3) >= 2)
8396 insn1
= ((1ULL << 58) | (1ULL << 52)
8397 | ((44ULL | (insn2
& 3)) << 26)
8398 | (insn2
& (31ULL << 21)));
8399 off
= insn2
& 0xfffc;
8403 insn1
= ((1ULL << 58) | (1ULL << 52)
8404 | ((50ULL | (insn2
& 4) | ((insn2
& 8) >> 3)) << 26)
8405 | (insn2
& (31ULL << 21)));
8406 off
= insn2
& 0xfff0;
8411 insn1
= ((1ULL << 58) | (1ULL << 52)
8412 | (insn2
& ((63ULL << 26) | (31ULL << 21))));
8413 off
= insn2
& 0xffff;
8416 case 62: /* std, stq */
8417 if ((insn2
& 1) != 0)
8419 insn1
= ((1ULL << 58) | (1ULL << 52)
8420 | ((insn2
& 2) == 0 ? 61ULL << 26 : 60ULL << 26)
8421 | (insn2
& (31ULL << 21)));
8422 off
= insn2
& 0xfffc;
8427 *pinsn2
= (uint64_t) NOP
<< 32;
8428 *poff
= (off
^ 0x8000) - 0x8000;
8432 /* Examine all relocs referencing .toc sections in order to remove
8433 unused .toc entries. */
8436 ppc64_elf_edit_toc (struct bfd_link_info
*info
)
8439 struct adjust_toc_info toc_inf
;
8440 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
8442 htab
->do_toc_opt
= 1;
8443 toc_inf
.global_toc_syms
= TRUE
;
8444 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
8446 asection
*toc
, *sec
;
8447 Elf_Internal_Shdr
*symtab_hdr
;
8448 Elf_Internal_Sym
*local_syms
;
8449 Elf_Internal_Rela
*relstart
, *rel
, *toc_relocs
;
8450 unsigned long *skip
, *drop
;
8451 unsigned char *used
;
8452 unsigned char *keep
, last
, some_unused
;
8454 if (!is_ppc64_elf (ibfd
))
8457 toc
= bfd_get_section_by_name (ibfd
, ".toc");
8460 || toc
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
8461 || discarded_section (toc
))
8466 symtab_hdr
= &elf_symtab_hdr (ibfd
);
8468 /* Look at sections dropped from the final link. */
8471 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
8473 if (sec
->reloc_count
== 0
8474 || !discarded_section (sec
)
8475 || get_opd_info (sec
)
8476 || (sec
->flags
& SEC_ALLOC
) == 0
8477 || (sec
->flags
& SEC_DEBUGGING
) != 0)
8480 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
, FALSE
);
8481 if (relstart
== NULL
)
8484 /* Run through the relocs to see which toc entries might be
8486 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
8488 enum elf_ppc64_reloc_type r_type
;
8489 unsigned long r_symndx
;
8491 struct elf_link_hash_entry
*h
;
8492 Elf_Internal_Sym
*sym
;
8495 r_type
= ELF64_R_TYPE (rel
->r_info
);
8502 case R_PPC64_TOC16_LO
:
8503 case R_PPC64_TOC16_HI
:
8504 case R_PPC64_TOC16_HA
:
8505 case R_PPC64_TOC16_DS
:
8506 case R_PPC64_TOC16_LO_DS
:
8510 r_symndx
= ELF64_R_SYM (rel
->r_info
);
8511 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
8519 val
= h
->root
.u
.def
.value
;
8521 val
= sym
->st_value
;
8522 val
+= rel
->r_addend
;
8524 if (val
>= toc
->size
)
8527 /* Anything in the toc ought to be aligned to 8 bytes.
8528 If not, don't mark as unused. */
8534 skip
= bfd_zmalloc (sizeof (*skip
) * (toc
->size
+ 15) / 8);
8539 skip
[val
>> 3] = ref_from_discarded
;
8542 if (elf_section_data (sec
)->relocs
!= relstart
)
8546 /* For largetoc loads of address constants, we can convert
8547 . addis rx,2,addr@got@ha
8548 . ld ry,addr@got@l(rx)
8550 . addis rx,2,addr@toc@ha
8551 . addi ry,rx,addr@toc@l
8552 when addr is within 2G of the toc pointer. This then means
8553 that the word storing "addr" in the toc is no longer needed. */
8555 if (!ppc64_elf_tdata (ibfd
)->has_small_toc_reloc
8556 && toc
->output_section
->rawsize
< (bfd_vma
) 1 << 31
8557 && toc
->reloc_count
!= 0)
8559 /* Read toc relocs. */
8560 toc_relocs
= _bfd_elf_link_read_relocs (ibfd
, toc
, NULL
, NULL
,
8562 if (toc_relocs
== NULL
)
8565 for (rel
= toc_relocs
; rel
< toc_relocs
+ toc
->reloc_count
; ++rel
)
8567 enum elf_ppc64_reloc_type r_type
;
8568 unsigned long r_symndx
;
8570 struct elf_link_hash_entry
*h
;
8571 Elf_Internal_Sym
*sym
;
8574 r_type
= ELF64_R_TYPE (rel
->r_info
);
8575 if (r_type
!= R_PPC64_ADDR64
)
8578 r_symndx
= ELF64_R_SYM (rel
->r_info
);
8579 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
8584 || sym_sec
->output_section
== NULL
8585 || discarded_section (sym_sec
))
8588 if (!SYMBOL_REFERENCES_LOCAL (info
, h
))
8593 if (h
->type
== STT_GNU_IFUNC
)
8595 val
= h
->root
.u
.def
.value
;
8599 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
8601 val
= sym
->st_value
;
8603 val
+= rel
->r_addend
;
8604 val
+= sym_sec
->output_section
->vma
+ sym_sec
->output_offset
;
8606 /* We don't yet know the exact toc pointer value, but we
8607 know it will be somewhere in the toc section. Don't
8608 optimize if the difference from any possible toc
8609 pointer is outside [ff..f80008000, 7fff7fff]. */
8610 addr
= toc
->output_section
->vma
+ TOC_BASE_OFF
;
8611 if (val
- addr
+ (bfd_vma
) 0x80008000 >= (bfd_vma
) 1 << 32)
8614 addr
= toc
->output_section
->vma
+ toc
->output_section
->rawsize
;
8615 if (val
- addr
+ (bfd_vma
) 0x80008000 >= (bfd_vma
) 1 << 32)
8620 skip
= bfd_zmalloc (sizeof (*skip
) * (toc
->size
+ 15) / 8);
8625 skip
[rel
->r_offset
>> 3]
8626 |= can_optimize
| ((rel
- toc_relocs
) << 2);
8633 used
= bfd_zmalloc (sizeof (*used
) * (toc
->size
+ 7) / 8);
8637 if (local_syms
!= NULL
8638 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
8642 && elf_section_data (sec
)->relocs
!= relstart
)
8644 if (toc_relocs
!= NULL
8645 && elf_section_data (toc
)->relocs
!= toc_relocs
)
8652 /* Now check all kept sections that might reference the toc.
8653 Check the toc itself last. */
8654 for (sec
= (ibfd
->sections
== toc
&& toc
->next
? toc
->next
8657 sec
= (sec
== toc
? NULL
8658 : sec
->next
== NULL
? toc
8659 : sec
->next
== toc
&& toc
->next
? toc
->next
8664 if (sec
->reloc_count
== 0
8665 || discarded_section (sec
)
8666 || get_opd_info (sec
)
8667 || (sec
->flags
& SEC_ALLOC
) == 0
8668 || (sec
->flags
& SEC_DEBUGGING
) != 0)
8671 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
8673 if (relstart
== NULL
)
8679 /* Mark toc entries referenced as used. */
8683 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
8685 enum elf_ppc64_reloc_type r_type
;
8686 unsigned long r_symndx
;
8688 struct elf_link_hash_entry
*h
;
8689 Elf_Internal_Sym
*sym
;
8692 r_type
= ELF64_R_TYPE (rel
->r_info
);
8696 case R_PPC64_TOC16_LO
:
8697 case R_PPC64_TOC16_HI
:
8698 case R_PPC64_TOC16_HA
:
8699 case R_PPC64_TOC16_DS
:
8700 case R_PPC64_TOC16_LO_DS
:
8701 /* In case we're taking addresses of toc entries. */
8702 case R_PPC64_ADDR64
:
8709 r_symndx
= ELF64_R_SYM (rel
->r_info
);
8710 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
8721 val
= h
->root
.u
.def
.value
;
8723 val
= sym
->st_value
;
8724 val
+= rel
->r_addend
;
8726 if (val
>= toc
->size
)
8729 if ((skip
[val
>> 3] & can_optimize
) != 0)
8736 case R_PPC64_TOC16_HA
:
8739 case R_PPC64_TOC16_LO_DS
:
8740 off
= rel
->r_offset
;
8741 off
+= (bfd_big_endian (ibfd
) ? -2 : 3);
8742 if (!bfd_get_section_contents (ibfd
, sec
, &opc
,
8748 if ((opc
& (0x3f << 2)) == (58u << 2))
8753 /* Wrong sort of reloc, or not a ld. We may
8754 as well clear ref_from_discarded too. */
8761 /* For the toc section, we only mark as used if this
8762 entry itself isn't unused. */
8763 else if ((used
[rel
->r_offset
>> 3]
8764 || !(skip
[rel
->r_offset
>> 3] & ref_from_discarded
))
8767 /* Do all the relocs again, to catch reference
8776 if (elf_section_data (sec
)->relocs
!= relstart
)
8780 /* Merge the used and skip arrays. Assume that TOC
8781 doublewords not appearing as either used or unused belong
8782 to an entry more than one doubleword in size. */
8783 for (drop
= skip
, keep
= used
, last
= 0, some_unused
= 0;
8784 drop
< skip
+ (toc
->size
+ 7) / 8;
8789 *drop
&= ~ref_from_discarded
;
8790 if ((*drop
& can_optimize
) != 0)
8794 else if ((*drop
& ref_from_discarded
) != 0)
8797 last
= ref_from_discarded
;
8807 bfd_byte
*contents
, *src
;
8809 Elf_Internal_Sym
*sym
;
8810 bfd_boolean local_toc_syms
= FALSE
;
8812 /* Shuffle the toc contents, and at the same time convert the
8813 skip array from booleans into offsets. */
8814 if (!bfd_malloc_and_get_section (ibfd
, toc
, &contents
))
8817 elf_section_data (toc
)->this_hdr
.contents
= contents
;
8819 for (src
= contents
, off
= 0, drop
= skip
;
8820 src
< contents
+ toc
->size
;
8823 if ((*drop
& (can_optimize
| ref_from_discarded
)) != 0)
8828 memcpy (src
- off
, src
, 8);
8832 toc
->rawsize
= toc
->size
;
8833 toc
->size
= src
- contents
- off
;
8835 /* Adjust addends for relocs against the toc section sym,
8836 and optimize any accesses we can. */
8837 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
8839 if (sec
->reloc_count
== 0
8840 || discarded_section (sec
))
8843 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
8845 if (relstart
== NULL
)
8848 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
8850 enum elf_ppc64_reloc_type r_type
;
8851 unsigned long r_symndx
;
8853 struct elf_link_hash_entry
*h
;
8856 r_type
= ELF64_R_TYPE (rel
->r_info
);
8863 case R_PPC64_TOC16_LO
:
8864 case R_PPC64_TOC16_HI
:
8865 case R_PPC64_TOC16_HA
:
8866 case R_PPC64_TOC16_DS
:
8867 case R_PPC64_TOC16_LO_DS
:
8868 case R_PPC64_ADDR64
:
8872 r_symndx
= ELF64_R_SYM (rel
->r_info
);
8873 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
8881 val
= h
->root
.u
.def
.value
;
8884 val
= sym
->st_value
;
8886 local_toc_syms
= TRUE
;
8889 val
+= rel
->r_addend
;
8891 if (val
> toc
->rawsize
)
8893 else if ((skip
[val
>> 3] & ref_from_discarded
) != 0)
8895 else if ((skip
[val
>> 3] & can_optimize
) != 0)
8897 Elf_Internal_Rela
*tocrel
8898 = toc_relocs
+ (skip
[val
>> 3] >> 2);
8899 unsigned long tsym
= ELF64_R_SYM (tocrel
->r_info
);
8903 case R_PPC64_TOC16_HA
:
8904 rel
->r_info
= ELF64_R_INFO (tsym
, R_PPC64_TOC16_HA
);
8907 case R_PPC64_TOC16_LO_DS
:
8908 rel
->r_info
= ELF64_R_INFO (tsym
, R_PPC64_LO_DS_OPT
);
8912 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
8914 info
->callbacks
->einfo
8915 /* xgettext:c-format */
8916 (_("%H: %s references "
8917 "optimized away TOC entry\n"),
8918 ibfd
, sec
, rel
->r_offset
,
8919 ppc64_elf_howto_table
[r_type
]->name
);
8920 bfd_set_error (bfd_error_bad_value
);
8923 rel
->r_addend
= tocrel
->r_addend
;
8924 elf_section_data (sec
)->relocs
= relstart
;
8928 if (h
!= NULL
|| sym
->st_value
!= 0)
8931 rel
->r_addend
-= skip
[val
>> 3];
8932 elf_section_data (sec
)->relocs
= relstart
;
8935 if (elf_section_data (sec
)->relocs
!= relstart
)
8939 /* We shouldn't have local or global symbols defined in the TOC,
8940 but handle them anyway. */
8941 if (local_syms
!= NULL
)
8942 for (sym
= local_syms
;
8943 sym
< local_syms
+ symtab_hdr
->sh_info
;
8945 if (sym
->st_value
!= 0
8946 && bfd_section_from_elf_index (ibfd
, sym
->st_shndx
) == toc
)
8950 if (sym
->st_value
> toc
->rawsize
)
8951 i
= toc
->rawsize
>> 3;
8953 i
= sym
->st_value
>> 3;
8955 if ((skip
[i
] & (ref_from_discarded
| can_optimize
)) != 0)
8959 (_("%s defined on removed toc entry"),
8960 bfd_elf_sym_name (ibfd
, symtab_hdr
, sym
, NULL
));
8963 while ((skip
[i
] & (ref_from_discarded
| can_optimize
)));
8964 sym
->st_value
= (bfd_vma
) i
<< 3;
8967 sym
->st_value
-= skip
[i
];
8968 symtab_hdr
->contents
= (unsigned char *) local_syms
;
8971 /* Adjust any global syms defined in this toc input section. */
8972 if (toc_inf
.global_toc_syms
)
8975 toc_inf
.skip
= skip
;
8976 toc_inf
.global_toc_syms
= FALSE
;
8977 elf_link_hash_traverse (elf_hash_table (info
), adjust_toc_syms
,
8981 if (toc
->reloc_count
!= 0)
8983 Elf_Internal_Shdr
*rel_hdr
;
8984 Elf_Internal_Rela
*wrel
;
8987 /* Remove unused toc relocs, and adjust those we keep. */
8988 if (toc_relocs
== NULL
)
8989 toc_relocs
= _bfd_elf_link_read_relocs (ibfd
, toc
, NULL
, NULL
,
8991 if (toc_relocs
== NULL
)
8995 for (rel
= toc_relocs
; rel
< toc_relocs
+ toc
->reloc_count
; ++rel
)
8996 if ((skip
[rel
->r_offset
>> 3]
8997 & (ref_from_discarded
| can_optimize
)) == 0)
8999 wrel
->r_offset
= rel
->r_offset
- skip
[rel
->r_offset
>> 3];
9000 wrel
->r_info
= rel
->r_info
;
9001 wrel
->r_addend
= rel
->r_addend
;
9004 else if (!dec_dynrel_count (rel
->r_info
, toc
, info
,
9005 &local_syms
, NULL
, NULL
))
9008 elf_section_data (toc
)->relocs
= toc_relocs
;
9009 toc
->reloc_count
= wrel
- toc_relocs
;
9010 rel_hdr
= _bfd_elf_single_rel_hdr (toc
);
9011 sz
= rel_hdr
->sh_entsize
;
9012 rel_hdr
->sh_size
= toc
->reloc_count
* sz
;
9015 else if (toc_relocs
!= NULL
9016 && elf_section_data (toc
)->relocs
!= toc_relocs
)
9019 if (local_syms
!= NULL
9020 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
9022 if (!info
->keep_memory
)
9025 symtab_hdr
->contents
= (unsigned char *) local_syms
;
9030 /* Look for cases where we can change an indirect GOT access to
9031 a GOT relative or PC relative access, possibly reducing the
9032 number of GOT entries. */
9033 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
9036 Elf_Internal_Shdr
*symtab_hdr
;
9037 Elf_Internal_Sym
*local_syms
;
9038 Elf_Internal_Rela
*relstart
, *rel
;
9041 if (!is_ppc64_elf (ibfd
))
9044 if (!ppc64_elf_tdata (ibfd
)->has_optrel
)
9047 sec
= ppc64_elf_tdata (ibfd
)->got
;
9050 got
= sec
->output_section
->vma
+ sec
->output_offset
+ 0x8000;
9053 symtab_hdr
= &elf_symtab_hdr (ibfd
);
9055 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
9057 if (sec
->reloc_count
== 0
9058 || !ppc64_elf_section_data (sec
)->has_optrel
9059 || discarded_section (sec
))
9062 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
9064 if (relstart
== NULL
)
9067 if (local_syms
!= NULL
9068 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
9072 && elf_section_data (sec
)->relocs
!= relstart
)
9077 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
9079 enum elf_ppc64_reloc_type r_type
;
9080 unsigned long r_symndx
;
9081 Elf_Internal_Sym
*sym
;
9083 struct elf_link_hash_entry
*h
;
9084 struct got_entry
*ent
;
9086 unsigned char buf
[8];
9088 enum {no_check
, check_lo
, check_ha
} insn_check
;
9090 r_type
= ELF64_R_TYPE (rel
->r_info
);
9094 insn_check
= no_check
;
9097 case R_PPC64_PLT16_HA
:
9098 case R_PPC64_GOT_TLSLD16_HA
:
9099 case R_PPC64_GOT_TLSGD16_HA
:
9100 case R_PPC64_GOT_TPREL16_HA
:
9101 case R_PPC64_GOT_DTPREL16_HA
:
9102 case R_PPC64_GOT16_HA
:
9103 case R_PPC64_TOC16_HA
:
9104 insn_check
= check_ha
;
9107 case R_PPC64_PLT16_LO
:
9108 case R_PPC64_PLT16_LO_DS
:
9109 case R_PPC64_GOT_TLSLD16_LO
:
9110 case R_PPC64_GOT_TLSGD16_LO
:
9111 case R_PPC64_GOT_TPREL16_LO_DS
:
9112 case R_PPC64_GOT_DTPREL16_LO_DS
:
9113 case R_PPC64_GOT16_LO
:
9114 case R_PPC64_GOT16_LO_DS
:
9115 case R_PPC64_TOC16_LO
:
9116 case R_PPC64_TOC16_LO_DS
:
9117 insn_check
= check_lo
;
9121 if (insn_check
!= no_check
)
9123 bfd_vma off
= rel
->r_offset
& ~3;
9125 if (!bfd_get_section_contents (ibfd
, sec
, buf
, off
, 4))
9128 insn
= bfd_get_32 (ibfd
, buf
);
9129 if (insn_check
== check_lo
9130 ? !ok_lo_toc_insn (insn
, r_type
)
9131 : ((insn
& ((0x3fu
<< 26) | 0x1f << 16))
9132 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9136 ppc64_elf_tdata (ibfd
)->unexpected_toc_insn
= 1;
9137 sprintf (str
, "%#08x", insn
);
9138 info
->callbacks
->einfo
9139 /* xgettext:c-format */
9140 (_("%H: got/toc optimization is not supported for"
9141 " %s instruction\n"),
9142 ibfd
, sec
, rel
->r_offset
& ~3, str
);
9149 /* Note that we don't delete GOT entries for
9150 R_PPC64_GOT16_DS since we'd need a lot more
9151 analysis. For starters, the preliminary layout is
9152 before the GOT, PLT, dynamic sections and stubs are
9153 laid out. Then we'd need to allow for changes in
9154 distance between sections caused by alignment. */
9158 case R_PPC64_GOT16_HA
:
9159 case R_PPC64_GOT16_LO_DS
:
9160 case R_PPC64_GOT_PCREL34
:
9164 r_symndx
= ELF64_R_SYM (rel
->r_info
);
9165 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
9170 || sym_sec
->output_section
== NULL
9171 || discarded_section (sym_sec
))
9174 if (!SYMBOL_REFERENCES_LOCAL (info
, h
))
9178 val
= h
->root
.u
.def
.value
;
9180 val
= sym
->st_value
;
9181 val
+= rel
->r_addend
;
9182 val
+= sym_sec
->output_section
->vma
+ sym_sec
->output_offset
;
9184 /* Fudge factor to allow for the fact that the preliminary layout
9185 isn't exact. Reduce limits by this factor. */
9186 #define LIMIT_ADJUST(LIMIT) ((LIMIT) - (LIMIT) / 16)
9193 case R_PPC64_GOT16_HA
:
9194 if (val
- got
+ LIMIT_ADJUST (0x80008000ULL
)
9195 >= LIMIT_ADJUST (0x100000000ULL
))
9198 if (!bfd_get_section_contents (ibfd
, sec
, buf
,
9199 rel
->r_offset
& ~3, 4))
9201 insn
= bfd_get_32 (ibfd
, buf
);
9202 if (((insn
& ((0x3fu
<< 26) | 0x1f << 16))
9203 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9207 case R_PPC64_GOT16_LO_DS
:
9208 if (val
- got
+ LIMIT_ADJUST (0x80008000ULL
)
9209 >= LIMIT_ADJUST (0x100000000ULL
))
9211 if (!bfd_get_section_contents (ibfd
, sec
, buf
,
9212 rel
->r_offset
& ~3, 4))
9214 insn
= bfd_get_32 (ibfd
, buf
);
9215 if ((insn
& (0x3fu
<< 26 | 0x3)) != 58u << 26 /* ld */)
9219 case R_PPC64_GOT_PCREL34
:
9221 pc
+= sec
->output_section
->vma
+ sec
->output_offset
;
9222 if (val
- pc
+ LIMIT_ADJUST (1ULL << 33)
9223 >= LIMIT_ADJUST (1ULL << 34))
9225 if (!bfd_get_section_contents (ibfd
, sec
, buf
,
9226 rel
->r_offset
& ~3, 8))
9228 insn
= bfd_get_32 (ibfd
, buf
);
9229 if ((insn
& (-1u << 18)) != ((1u << 26) | (1u << 20)))
9231 insn
= bfd_get_32 (ibfd
, buf
+ 4);
9232 if ((insn
& (0x3fu
<< 26)) != 57u << 26)
9242 struct got_entry
**local_got_ents
= elf_local_got_ents (ibfd
);
9243 ent
= local_got_ents
[r_symndx
];
9245 for (; ent
!= NULL
; ent
= ent
->next
)
9246 if (ent
->addend
== rel
->r_addend
9247 && ent
->owner
== ibfd
9248 && ent
->tls_type
== 0)
9250 BFD_ASSERT (ent
&& ent
->got
.refcount
> 0);
9251 ent
->got
.refcount
-= 1;
9254 if (elf_section_data (sec
)->relocs
!= relstart
)
9258 if (local_syms
!= NULL
9259 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
9261 if (!info
->keep_memory
)
9264 symtab_hdr
->contents
= (unsigned char *) local_syms
;
9271 /* Return true iff input section I references the TOC using
9272 instructions limited to +/-32k offsets. */
9275 ppc64_elf_has_small_toc_reloc (asection
*i
)
9277 return (is_ppc64_elf (i
->owner
)
9278 && ppc64_elf_tdata (i
->owner
)->has_small_toc_reloc
);
9281 /* Allocate space for one GOT entry. */
9284 allocate_got (struct elf_link_hash_entry
*h
,
9285 struct bfd_link_info
*info
,
9286 struct got_entry
*gent
)
9288 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
9289 struct ppc_link_hash_entry
*eh
= (struct ppc_link_hash_entry
*) h
;
9290 int entsize
= (gent
->tls_type
& eh
->tls_mask
& (TLS_GD
| TLS_LD
)
9292 int rentsize
= (gent
->tls_type
& eh
->tls_mask
& TLS_GD
9293 ? 2 : 1) * sizeof (Elf64_External_Rela
);
9294 asection
*got
= ppc64_elf_tdata (gent
->owner
)->got
;
9296 gent
->got
.offset
= got
->size
;
9297 got
->size
+= entsize
;
9299 if (h
->type
== STT_GNU_IFUNC
)
9301 htab
->elf
.irelplt
->size
+= rentsize
;
9302 htab
->got_reli_size
+= rentsize
;
9304 else if (((bfd_link_pic (info
)
9305 && !(gent
->tls_type
!= 0
9306 && bfd_link_executable (info
)
9307 && SYMBOL_REFERENCES_LOCAL (info
, h
)))
9308 || (htab
->elf
.dynamic_sections_created
9310 && !SYMBOL_REFERENCES_LOCAL (info
, h
)))
9311 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
9313 asection
*relgot
= ppc64_elf_tdata (gent
->owner
)->relgot
;
9314 relgot
->size
+= rentsize
;
9318 /* This function merges got entries in the same toc group. */
9321 merge_got_entries (struct got_entry
**pent
)
9323 struct got_entry
*ent
, *ent2
;
9325 for (ent
= *pent
; ent
!= NULL
; ent
= ent
->next
)
9326 if (!ent
->is_indirect
)
9327 for (ent2
= ent
->next
; ent2
!= NULL
; ent2
= ent2
->next
)
9328 if (!ent2
->is_indirect
9329 && ent2
->addend
== ent
->addend
9330 && ent2
->tls_type
== ent
->tls_type
9331 && elf_gp (ent2
->owner
) == elf_gp (ent
->owner
))
9333 ent2
->is_indirect
= TRUE
;
9334 ent2
->got
.ent
= ent
;
9338 /* If H is undefined, make it dynamic if that makes sense. */
9341 ensure_undef_dynamic (struct bfd_link_info
*info
,
9342 struct elf_link_hash_entry
*h
)
9344 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
9346 if (htab
->dynamic_sections_created
9347 && ((info
->dynamic_undefined_weak
!= 0
9348 && h
->root
.type
== bfd_link_hash_undefweak
)
9349 || h
->root
.type
== bfd_link_hash_undefined
)
9352 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
9353 return bfd_elf_link_record_dynamic_symbol (info
, h
);
9357 /* Allocate space in .plt, .got and associated reloc sections for
9361 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
9363 struct bfd_link_info
*info
;
9364 struct ppc_link_hash_table
*htab
;
9366 struct ppc_link_hash_entry
*eh
;
9367 struct got_entry
**pgent
, *gent
;
9369 if (h
->root
.type
== bfd_link_hash_indirect
)
9372 info
= (struct bfd_link_info
*) inf
;
9373 htab
= ppc_hash_table (info
);
9377 eh
= (struct ppc_link_hash_entry
*) h
;
9378 /* Run through the TLS GD got entries first if we're changing them
9380 if ((eh
->tls_mask
& (TLS_TLS
| TLS_GDIE
)) == (TLS_TLS
| TLS_GDIE
))
9381 for (gent
= h
->got
.glist
; gent
!= NULL
; gent
= gent
->next
)
9382 if (gent
->got
.refcount
> 0
9383 && (gent
->tls_type
& TLS_GD
) != 0)
9385 /* This was a GD entry that has been converted to TPREL. If
9386 there happens to be a TPREL entry we can use that one. */
9387 struct got_entry
*ent
;
9388 for (ent
= h
->got
.glist
; ent
!= NULL
; ent
= ent
->next
)
9389 if (ent
->got
.refcount
> 0
9390 && (ent
->tls_type
& TLS_TPREL
) != 0
9391 && ent
->addend
== gent
->addend
9392 && ent
->owner
== gent
->owner
)
9394 gent
->got
.refcount
= 0;
9398 /* If not, then we'll be using our own TPREL entry. */
9399 if (gent
->got
.refcount
!= 0)
9400 gent
->tls_type
= TLS_TLS
| TLS_TPREL
;
9403 /* Remove any list entry that won't generate a word in the GOT before
9404 we call merge_got_entries. Otherwise we risk merging to empty
9406 pgent
= &h
->got
.glist
;
9407 while ((gent
= *pgent
) != NULL
)
9408 if (gent
->got
.refcount
> 0)
9410 if ((gent
->tls_type
& TLS_LD
) != 0
9411 && SYMBOL_REFERENCES_LOCAL (info
, h
))
9413 ppc64_tlsld_got (gent
->owner
)->got
.refcount
+= 1;
9414 *pgent
= gent
->next
;
9417 pgent
= &gent
->next
;
9420 *pgent
= gent
->next
;
9422 if (!htab
->do_multi_toc
)
9423 merge_got_entries (&h
->got
.glist
);
9425 for (gent
= h
->got
.glist
; gent
!= NULL
; gent
= gent
->next
)
9426 if (!gent
->is_indirect
)
9428 /* Ensure we catch all the cases where this symbol should
9430 if (!ensure_undef_dynamic (info
, h
))
9433 if (!is_ppc64_elf (gent
->owner
))
9436 allocate_got (h
, info
, gent
);
9439 /* If no dynamic sections we can't have dynamic relocs, except for
9440 IFUNCs which are handled even in static executables. */
9441 if (!htab
->elf
.dynamic_sections_created
9442 && h
->type
!= STT_GNU_IFUNC
)
9443 eh
->dyn_relocs
= NULL
;
9445 /* Discard relocs on undefined symbols that must be local. */
9446 else if (h
->root
.type
== bfd_link_hash_undefined
9447 && ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
9448 eh
->dyn_relocs
= NULL
;
9450 /* Also discard relocs on undefined weak syms with non-default
9451 visibility, or when dynamic_undefined_weak says so. */
9452 else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
9453 eh
->dyn_relocs
= NULL
;
9455 if (eh
->dyn_relocs
!= NULL
)
9457 struct elf_dyn_relocs
*p
, **pp
;
9459 /* In the shared -Bsymbolic case, discard space allocated for
9460 dynamic pc-relative relocs against symbols which turn out to
9461 be defined in regular objects. For the normal shared case,
9462 discard space for relocs that have become local due to symbol
9463 visibility changes. */
9464 if (bfd_link_pic (info
))
9466 /* Relocs that use pc_count are those that appear on a call
9467 insn, or certain REL relocs (see must_be_dyn_reloc) that
9468 can be generated via assembly. We want calls to
9469 protected symbols to resolve directly to the function
9470 rather than going via the plt. If people want function
9471 pointer comparisons to work as expected then they should
9472 avoid writing weird assembly. */
9473 if (SYMBOL_CALLS_LOCAL (info
, h
))
9475 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
9477 p
->count
-= p
->pc_count
;
9486 if (eh
->dyn_relocs
!= NULL
)
9488 /* Ensure we catch all the cases where this symbol
9489 should be made dynamic. */
9490 if (!ensure_undef_dynamic (info
, h
))
9495 /* For a fixed position executable, discard space for
9496 relocs against symbols which are not dynamic. */
9497 else if (h
->type
!= STT_GNU_IFUNC
)
9499 if (h
->dynamic_adjusted
9501 && !ELF_COMMON_DEF_P (h
))
9503 /* Ensure we catch all the cases where this symbol
9504 should be made dynamic. */
9505 if (!ensure_undef_dynamic (info
, h
))
9508 /* But if that didn't work out, discard dynamic relocs. */
9509 if (h
->dynindx
== -1)
9510 eh
->dyn_relocs
= NULL
;
9513 eh
->dyn_relocs
= NULL
;
9516 /* Finally, allocate space. */
9517 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
9519 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
9520 if (eh
->elf
.type
== STT_GNU_IFUNC
)
9521 sreloc
= htab
->elf
.irelplt
;
9522 sreloc
->size
+= p
->count
* sizeof (Elf64_External_Rela
);
9526 /* We might need a PLT entry when the symbol
9529 c) has plt16 relocs and has been processed by adjust_dynamic_symbol, or
9530 d) has plt16 relocs and we are linking statically. */
9531 if ((htab
->elf
.dynamic_sections_created
&& h
->dynindx
!= -1)
9532 || h
->type
== STT_GNU_IFUNC
9533 || (h
->needs_plt
&& h
->dynamic_adjusted
)
9536 && !htab
->elf
.dynamic_sections_created
9537 && !htab
->can_convert_all_inline_plt
9538 && (((struct ppc_link_hash_entry
*) h
)->tls_mask
9539 & (TLS_TLS
| PLT_KEEP
)) == PLT_KEEP
))
9541 struct plt_entry
*pent
;
9542 bfd_boolean doneone
= FALSE
;
9543 for (pent
= h
->plt
.plist
; pent
!= NULL
; pent
= pent
->next
)
9544 if (pent
->plt
.refcount
> 0)
9546 if (!htab
->elf
.dynamic_sections_created
9547 || h
->dynindx
== -1)
9549 if (h
->type
== STT_GNU_IFUNC
)
9552 pent
->plt
.offset
= s
->size
;
9553 s
->size
+= PLT_ENTRY_SIZE (htab
);
9554 s
= htab
->elf
.irelplt
;
9559 pent
->plt
.offset
= s
->size
;
9560 s
->size
+= LOCAL_PLT_ENTRY_SIZE (htab
);
9561 s
= bfd_link_pic (info
) ? htab
->relpltlocal
: NULL
;
9566 /* If this is the first .plt entry, make room for the special
9570 s
->size
+= PLT_INITIAL_ENTRY_SIZE (htab
);
9572 pent
->plt
.offset
= s
->size
;
9574 /* Make room for this entry. */
9575 s
->size
+= PLT_ENTRY_SIZE (htab
);
9577 /* Make room for the .glink code. */
9580 s
->size
+= GLINK_PLTRESOLVE_SIZE (htab
);
9583 /* We need bigger stubs past index 32767. */
9584 if (s
->size
>= GLINK_PLTRESOLVE_SIZE (htab
) + 32768*2*4)
9591 /* We also need to make an entry in the .rela.plt section. */
9592 s
= htab
->elf
.srelplt
;
9595 s
->size
+= sizeof (Elf64_External_Rela
);
9599 pent
->plt
.offset
= (bfd_vma
) -1;
9602 h
->plt
.plist
= NULL
;
9608 h
->plt
.plist
= NULL
;
9615 #define PPC_LO(v) ((v) & 0xffff)
9616 #define PPC_HI(v) (((v) >> 16) & 0xffff)
9617 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
9619 ((((v) & 0x3ffff0000ULL) << 16) | (v & 0xffff))
9620 #define HA34(v) ((v + (1ULL << 33)) >> 34)
9622 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9623 to set up space for global entry stubs. These are put in glink,
9624 after the branch table. */
9627 size_global_entry_stubs (struct elf_link_hash_entry
*h
, void *inf
)
9629 struct bfd_link_info
*info
;
9630 struct ppc_link_hash_table
*htab
;
9631 struct plt_entry
*pent
;
9634 if (h
->root
.type
== bfd_link_hash_indirect
)
9637 if (!h
->pointer_equality_needed
)
9644 htab
= ppc_hash_table (info
);
9648 s
= htab
->global_entry
;
9649 plt
= htab
->elf
.splt
;
9650 for (pent
= h
->plt
.plist
; pent
!= NULL
; pent
= pent
->next
)
9651 if (pent
->plt
.offset
!= (bfd_vma
) -1
9652 && pent
->addend
== 0)
9654 /* For ELFv2, if this symbol is not defined in a regular file
9655 and we are not generating a shared library or pie, then we
9656 need to define the symbol in the executable on a call stub.
9657 This is to avoid text relocations. */
9658 bfd_vma off
, stub_align
, stub_off
, stub_size
;
9659 unsigned int align_power
;
9663 if (htab
->params
->plt_stub_align
>= 0)
9664 align_power
= htab
->params
->plt_stub_align
;
9666 align_power
= -htab
->params
->plt_stub_align
;
9667 /* Setting section alignment is delayed until we know it is
9668 non-empty. Otherwise the .text output section will be
9669 aligned at least to plt_stub_align even when no global
9670 entry stubs are needed. */
9671 if (s
->alignment_power
< align_power
)
9672 s
->alignment_power
= align_power
;
9673 stub_align
= (bfd_vma
) 1 << align_power
;
9674 if (htab
->params
->plt_stub_align
>= 0
9675 || ((((stub_off
+ stub_size
- 1) & -stub_align
)
9676 - (stub_off
& -stub_align
))
9677 > ((stub_size
- 1) & -stub_align
)))
9678 stub_off
= (stub_off
+ stub_align
- 1) & -stub_align
;
9679 off
= pent
->plt
.offset
+ plt
->output_offset
+ plt
->output_section
->vma
;
9680 off
-= stub_off
+ s
->output_offset
+ s
->output_section
->vma
;
9681 /* Note that for --plt-stub-align negative we have a possible
9682 dependency between stub offset and size. Break that
9683 dependency by assuming the max stub size when calculating
9685 if (PPC_HA (off
) == 0)
9687 h
->root
.type
= bfd_link_hash_defined
;
9688 h
->root
.u
.def
.section
= s
;
9689 h
->root
.u
.def
.value
= stub_off
;
9690 s
->size
= stub_off
+ stub_size
;
9696 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9697 read-only sections. */
9700 maybe_set_textrel (struct elf_link_hash_entry
*h
, void *inf
)
9704 if (h
->root
.type
== bfd_link_hash_indirect
)
9707 sec
= readonly_dynrelocs (h
);
9710 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
9712 info
->flags
|= DF_TEXTREL
;
9713 info
->callbacks
->minfo (_("%pB: dynamic relocation against `%pT'"
9714 " in read-only section `%pA'\n"),
9715 sec
->owner
, h
->root
.root
.string
, sec
);
9717 /* Not an error, just cut short the traversal. */
9723 /* Set the sizes of the dynamic sections. */
9726 ppc64_elf_size_dynamic_sections (bfd
*output_bfd
,
9727 struct bfd_link_info
*info
)
9729 struct ppc_link_hash_table
*htab
;
9734 struct got_entry
*first_tlsld
;
9736 htab
= ppc_hash_table (info
);
9740 dynobj
= htab
->elf
.dynobj
;
9744 if (htab
->elf
.dynamic_sections_created
)
9746 /* Set the contents of the .interp section to the interpreter. */
9747 if (bfd_link_executable (info
) && !info
->nointerp
)
9749 s
= bfd_get_linker_section (dynobj
, ".interp");
9752 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
9753 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
9757 /* Set up .got offsets for local syms, and space for local dynamic
9759 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
9761 struct got_entry
**lgot_ents
;
9762 struct got_entry
**end_lgot_ents
;
9763 struct plt_entry
**local_plt
;
9764 struct plt_entry
**end_local_plt
;
9765 unsigned char *lgot_masks
;
9766 bfd_size_type locsymcount
;
9767 Elf_Internal_Shdr
*symtab_hdr
;
9769 if (!is_ppc64_elf (ibfd
))
9772 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
9774 struct ppc_dyn_relocs
*p
;
9776 for (p
= elf_section_data (s
)->local_dynrel
; p
!= NULL
; p
= p
->next
)
9778 if (!bfd_is_abs_section (p
->sec
)
9779 && bfd_is_abs_section (p
->sec
->output_section
))
9781 /* Input section has been discarded, either because
9782 it is a copy of a linkonce section or due to
9783 linker script /DISCARD/, so we'll be discarding
9786 else if (p
->count
!= 0)
9788 asection
*srel
= elf_section_data (p
->sec
)->sreloc
;
9790 srel
= htab
->elf
.irelplt
;
9791 srel
->size
+= p
->count
* sizeof (Elf64_External_Rela
);
9792 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
9793 info
->flags
|= DF_TEXTREL
;
9798 lgot_ents
= elf_local_got_ents (ibfd
);
9802 symtab_hdr
= &elf_symtab_hdr (ibfd
);
9803 locsymcount
= symtab_hdr
->sh_info
;
9804 end_lgot_ents
= lgot_ents
+ locsymcount
;
9805 local_plt
= (struct plt_entry
**) end_lgot_ents
;
9806 end_local_plt
= local_plt
+ locsymcount
;
9807 lgot_masks
= (unsigned char *) end_local_plt
;
9808 s
= ppc64_elf_tdata (ibfd
)->got
;
9809 for (; lgot_ents
< end_lgot_ents
; ++lgot_ents
, ++lgot_masks
)
9811 struct got_entry
**pent
, *ent
;
9814 while ((ent
= *pent
) != NULL
)
9815 if (ent
->got
.refcount
> 0)
9817 if ((ent
->tls_type
& *lgot_masks
& TLS_LD
) != 0)
9819 ppc64_tlsld_got (ibfd
)->got
.refcount
+= 1;
9824 unsigned int ent_size
= 8;
9825 unsigned int rel_size
= sizeof (Elf64_External_Rela
);
9827 ent
->got
.offset
= s
->size
;
9828 if ((ent
->tls_type
& *lgot_masks
& TLS_GD
) != 0)
9833 s
->size
+= ent_size
;
9834 if ((*lgot_masks
& (TLS_TLS
| PLT_IFUNC
)) == PLT_IFUNC
)
9836 htab
->elf
.irelplt
->size
+= rel_size
;
9837 htab
->got_reli_size
+= rel_size
;
9839 else if (bfd_link_pic (info
)
9840 && !(ent
->tls_type
!= 0
9841 && bfd_link_executable (info
)))
9843 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
9844 srel
->size
+= rel_size
;
9853 /* Allocate space for plt calls to local syms. */
9854 lgot_masks
= (unsigned char *) end_local_plt
;
9855 for (; local_plt
< end_local_plt
; ++local_plt
, ++lgot_masks
)
9857 struct plt_entry
*ent
;
9859 for (ent
= *local_plt
; ent
!= NULL
; ent
= ent
->next
)
9860 if (ent
->plt
.refcount
> 0)
9862 if ((*lgot_masks
& (TLS_TLS
| PLT_IFUNC
)) == PLT_IFUNC
)
9865 ent
->plt
.offset
= s
->size
;
9866 s
->size
+= PLT_ENTRY_SIZE (htab
);
9867 htab
->elf
.irelplt
->size
+= sizeof (Elf64_External_Rela
);
9869 else if (htab
->can_convert_all_inline_plt
9870 || (*lgot_masks
& (TLS_TLS
| PLT_KEEP
)) != PLT_KEEP
)
9871 ent
->plt
.offset
= (bfd_vma
) -1;
9875 ent
->plt
.offset
= s
->size
;
9876 s
->size
+= LOCAL_PLT_ENTRY_SIZE (htab
);
9877 if (bfd_link_pic (info
))
9878 htab
->relpltlocal
->size
+= sizeof (Elf64_External_Rela
);
9882 ent
->plt
.offset
= (bfd_vma
) -1;
9886 /* Allocate global sym .plt and .got entries, and space for global
9887 sym dynamic relocs. */
9888 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, info
);
9890 if (!htab
->opd_abi
&& !bfd_link_pic (info
))
9891 elf_link_hash_traverse (&htab
->elf
, size_global_entry_stubs
, info
);
9894 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
9896 struct got_entry
*ent
;
9898 if (!is_ppc64_elf (ibfd
))
9901 ent
= ppc64_tlsld_got (ibfd
);
9902 if (ent
->got
.refcount
> 0)
9904 if (!htab
->do_multi_toc
&& first_tlsld
!= NULL
)
9906 ent
->is_indirect
= TRUE
;
9907 ent
->got
.ent
= first_tlsld
;
9911 if (first_tlsld
== NULL
)
9913 s
= ppc64_elf_tdata (ibfd
)->got
;
9914 ent
->got
.offset
= s
->size
;
9917 if (bfd_link_dll (info
))
9919 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
9920 srel
->size
+= sizeof (Elf64_External_Rela
);
9925 ent
->got
.offset
= (bfd_vma
) -1;
9928 /* We now have determined the sizes of the various dynamic sections.
9929 Allocate memory for them. */
9931 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
9933 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
9936 if (s
== htab
->brlt
|| s
== htab
->relbrlt
)
9937 /* These haven't been allocated yet; don't strip. */
9939 else if (s
== htab
->elf
.sgot
9940 || s
== htab
->elf
.splt
9941 || s
== htab
->elf
.iplt
9942 || s
== htab
->pltlocal
9944 || s
== htab
->global_entry
9945 || s
== htab
->elf
.sdynbss
9946 || s
== htab
->elf
.sdynrelro
)
9948 /* Strip this section if we don't need it; see the
9951 else if (s
== htab
->glink_eh_frame
)
9953 if (!bfd_is_abs_section (s
->output_section
))
9954 /* Not sized yet. */
9957 else if (CONST_STRNEQ (s
->name
, ".rela"))
9961 if (s
!= htab
->elf
.srelplt
)
9964 /* We use the reloc_count field as a counter if we need
9965 to copy relocs into the output file. */
9971 /* It's not one of our sections, so don't allocate space. */
9977 /* If we don't need this section, strip it from the
9978 output file. This is mostly to handle .rela.bss and
9979 .rela.plt. We must create both sections in
9980 create_dynamic_sections, because they must be created
9981 before the linker maps input sections to output
9982 sections. The linker does that before
9983 adjust_dynamic_symbol is called, and it is that
9984 function which decides whether anything needs to go
9985 into these sections. */
9986 s
->flags
|= SEC_EXCLUDE
;
9990 if (bfd_is_abs_section (s
->output_section
))
9991 _bfd_error_handler (_("warning: discarding dynamic section %s"),
9994 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
9997 /* Allocate memory for the section contents. We use bfd_zalloc
9998 here in case unused entries are not reclaimed before the
9999 section's contents are written out. This should not happen,
10000 but this way if it does we get a R_PPC64_NONE reloc in .rela
10001 sections instead of garbage.
10002 We also rely on the section contents being zero when writing
10003 the GOT and .dynrelro. */
10004 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
10005 if (s
->contents
== NULL
)
10009 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
10011 if (!is_ppc64_elf (ibfd
))
10014 s
= ppc64_elf_tdata (ibfd
)->got
;
10015 if (s
!= NULL
&& s
!= htab
->elf
.sgot
)
10018 s
->flags
|= SEC_EXCLUDE
;
10021 s
->contents
= bfd_zalloc (ibfd
, s
->size
);
10022 if (s
->contents
== NULL
)
10026 s
= ppc64_elf_tdata (ibfd
)->relgot
;
10030 s
->flags
|= SEC_EXCLUDE
;
10033 s
->contents
= bfd_zalloc (ibfd
, s
->size
);
10034 if (s
->contents
== NULL
)
10037 s
->reloc_count
= 0;
10042 if (htab
->elf
.dynamic_sections_created
)
10044 bfd_boolean tls_opt
;
10046 /* Add some entries to the .dynamic section. We fill in the
10047 values later, in ppc64_elf_finish_dynamic_sections, but we
10048 must add the entries now so that we get the correct size for
10049 the .dynamic section. The DT_DEBUG entry is filled in by the
10050 dynamic linker and used by the debugger. */
10051 #define add_dynamic_entry(TAG, VAL) \
10052 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10054 if (bfd_link_executable (info
))
10056 if (!add_dynamic_entry (DT_DEBUG
, 0))
10060 if (htab
->elf
.splt
!= NULL
&& htab
->elf
.splt
->size
!= 0)
10062 if (!add_dynamic_entry (DT_PLTGOT
, 0)
10063 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
10064 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
10065 || !add_dynamic_entry (DT_JMPREL
, 0)
10066 || !add_dynamic_entry (DT_PPC64_GLINK
, 0))
10070 if (NO_OPD_RELOCS
&& abiversion (output_bfd
) <= 1)
10072 if (!add_dynamic_entry (DT_PPC64_OPD
, 0)
10073 || !add_dynamic_entry (DT_PPC64_OPDSZ
, 0))
10077 tls_opt
= (htab
->params
->tls_get_addr_opt
10078 && htab
->tls_get_addr_fd
!= NULL
10079 && htab
->tls_get_addr_fd
->elf
.plt
.plist
!= NULL
);
10080 if (tls_opt
|| !htab
->opd_abi
)
10082 if (!add_dynamic_entry (DT_PPC64_OPT
, tls_opt
? PPC64_OPT_TLS
: 0))
10088 if (!add_dynamic_entry (DT_RELA
, 0)
10089 || !add_dynamic_entry (DT_RELASZ
, 0)
10090 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf64_External_Rela
)))
10093 /* If any dynamic relocs apply to a read-only section,
10094 then we need a DT_TEXTREL entry. */
10095 if ((info
->flags
& DF_TEXTREL
) == 0)
10096 elf_link_hash_traverse (&htab
->elf
, maybe_set_textrel
, info
);
10098 if ((info
->flags
& DF_TEXTREL
) != 0)
10100 if (!add_dynamic_entry (DT_TEXTREL
, 0))
10105 #undef add_dynamic_entry
10110 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
10113 ppc64_elf_hash_symbol (struct elf_link_hash_entry
*h
)
10115 if (h
->plt
.plist
!= NULL
10117 && !h
->pointer_equality_needed
)
10120 return _bfd_elf_hash_symbol (h
);
10123 /* Determine the type of stub needed, if any, for a call. */
10125 static inline enum ppc_stub_type
10126 ppc_type_of_stub (asection
*input_sec
,
10127 const Elf_Internal_Rela
*rel
,
10128 struct ppc_link_hash_entry
**hash
,
10129 struct plt_entry
**plt_ent
,
10130 bfd_vma destination
,
10131 unsigned long local_off
)
10133 struct ppc_link_hash_entry
*h
= *hash
;
10135 bfd_vma branch_offset
;
10136 bfd_vma max_branch_offset
;
10137 enum elf_ppc64_reloc_type r_type
;
10141 struct plt_entry
*ent
;
10142 struct ppc_link_hash_entry
*fdh
= h
;
10144 && h
->oh
->is_func_descriptor
)
10146 fdh
= ppc_follow_link (h
->oh
);
10150 for (ent
= fdh
->elf
.plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
10151 if (ent
->addend
== rel
->r_addend
10152 && ent
->plt
.offset
!= (bfd_vma
) -1)
10155 return ppc_stub_plt_call
;
10158 /* Here, we know we don't have a plt entry. If we don't have a
10159 either a defined function descriptor or a defined entry symbol
10160 in a regular object file, then it is pointless trying to make
10161 any other type of stub. */
10162 if (!is_static_defined (&fdh
->elf
)
10163 && !is_static_defined (&h
->elf
))
10164 return ppc_stub_none
;
10166 else if (elf_local_got_ents (input_sec
->owner
) != NULL
)
10168 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (input_sec
->owner
);
10169 struct plt_entry
**local_plt
= (struct plt_entry
**)
10170 elf_local_got_ents (input_sec
->owner
) + symtab_hdr
->sh_info
;
10171 unsigned long r_symndx
= ELF64_R_SYM (rel
->r_info
);
10173 if (local_plt
[r_symndx
] != NULL
)
10175 struct plt_entry
*ent
;
10177 for (ent
= local_plt
[r_symndx
]; ent
!= NULL
; ent
= ent
->next
)
10178 if (ent
->addend
== rel
->r_addend
10179 && ent
->plt
.offset
!= (bfd_vma
) -1)
10182 return ppc_stub_plt_call
;
10187 /* Determine where the call point is. */
10188 location
= (input_sec
->output_offset
10189 + input_sec
->output_section
->vma
10192 branch_offset
= destination
- location
;
10193 r_type
= ELF64_R_TYPE (rel
->r_info
);
10195 /* Determine if a long branch stub is needed. */
10196 max_branch_offset
= 1 << 25;
10197 if (r_type
== R_PPC64_REL14
10198 || r_type
== R_PPC64_REL14_BRTAKEN
10199 || r_type
== R_PPC64_REL14_BRNTAKEN
)
10200 max_branch_offset
= 1 << 15;
10202 if (branch_offset
+ max_branch_offset
>= 2 * max_branch_offset
- local_off
)
10203 /* We need a stub. Figure out whether a long_branch or plt_branch
10204 is needed later. */
10205 return ppc_stub_long_branch
;
10207 return ppc_stub_none
;
10210 /* Gets the address of a label (1:) in r11 and builds an offset in r12,
10211 then adds it to r11 (LOAD false) or loads r12 from r11+r12 (LOAD true).
10216 . lis %r12,xxx-1b@highest
10217 . ori %r12,%r12,xxx-1b@higher
10218 . sldi %r12,%r12,32
10219 . oris %r12,%r12,xxx-1b@high
10220 . ori %r12,%r12,xxx-1b@l
10221 . add/ldx %r12,%r11,%r12 */
10224 build_offset (bfd
*abfd
, bfd_byte
*p
, bfd_vma off
, bfd_boolean load
)
10226 bfd_put_32 (abfd
, MFLR_R12
, p
);
10228 bfd_put_32 (abfd
, BCL_20_31
, p
);
10230 bfd_put_32 (abfd
, MFLR_R11
, p
);
10232 bfd_put_32 (abfd
, MTLR_R12
, p
);
10234 if (off
+ 0x8000 < 0x10000)
10237 bfd_put_32 (abfd
, LD_R12_0R11
+ PPC_LO (off
), p
);
10239 bfd_put_32 (abfd
, ADDI_R12_R11
+ PPC_LO (off
), p
);
10242 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10244 bfd_put_32 (abfd
, ADDIS_R12_R11
+ PPC_HA (off
), p
);
10247 bfd_put_32 (abfd
, LD_R12_0R12
+ PPC_LO (off
), p
);
10249 bfd_put_32 (abfd
, ADDI_R12_R12
+ PPC_LO (off
), p
);
10254 if (off
+ 0x800000000000ULL
< 0x1000000000000ULL
)
10256 bfd_put_32 (abfd
, LI_R12_0
+ ((off
>> 32) & 0xffff), p
);
10261 bfd_put_32 (abfd
, LIS_R12
+ ((off
>> 48) & 0xffff), p
);
10263 if (((off
>> 32) & 0xffff) != 0)
10265 bfd_put_32 (abfd
, ORI_R12_R12_0
+ ((off
>> 32) & 0xffff), p
);
10269 if (((off
>> 32) & 0xffffffffULL
) != 0)
10271 bfd_put_32 (abfd
, SLDI_R12_R12_32
, p
);
10274 if (PPC_HI (off
) != 0)
10276 bfd_put_32 (abfd
, ORIS_R12_R12_0
+ PPC_HI (off
), p
);
10279 if (PPC_LO (off
) != 0)
10281 bfd_put_32 (abfd
, ORI_R12_R12_0
+ PPC_LO (off
), p
);
10285 bfd_put_32 (abfd
, LDX_R12_R11_R12
, p
);
10287 bfd_put_32 (abfd
, ADD_R12_R11_R12
, p
);
10293 static unsigned int
10294 size_offset (bfd_vma off
)
10297 if (off
+ 0x8000 < 0x10000)
10299 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10303 if (off
+ 0x800000000000ULL
< 0x1000000000000ULL
)
10308 if (((off
>> 32) & 0xffff) != 0)
10311 if (((off
>> 32) & 0xffffffffULL
) != 0)
10313 if (PPC_HI (off
) != 0)
10315 if (PPC_LO (off
) != 0)
10322 static unsigned int
10323 num_relocs_for_offset (bfd_vma off
)
10325 unsigned int num_rel
;
10326 if (off
+ 0x8000 < 0x10000)
10328 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10333 if (off
+ 0x800000000000ULL
>= 0x1000000000000ULL
10334 && ((off
>> 32) & 0xffff) != 0)
10336 if (PPC_HI (off
) != 0)
10338 if (PPC_LO (off
) != 0)
10344 static Elf_Internal_Rela
*
10345 emit_relocs_for_offset (struct bfd_link_info
*info
, Elf_Internal_Rela
*r
,
10346 bfd_vma roff
, bfd_vma targ
, bfd_vma off
)
10348 bfd_vma relative_targ
= targ
- (roff
- 8);
10349 if (bfd_big_endian (info
->output_bfd
))
10351 r
->r_offset
= roff
;
10352 r
->r_addend
= relative_targ
+ roff
;
10353 if (off
+ 0x8000 < 0x10000)
10354 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16
);
10355 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10357 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HA
);
10360 r
->r_offset
= roff
;
10361 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_LO
);
10362 r
->r_addend
= relative_targ
+ roff
;
10366 if (off
+ 0x800000000000ULL
< 0x1000000000000ULL
)
10367 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHER
);
10370 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHEST
);
10371 if (((off
>> 32) & 0xffff) != 0)
10375 r
->r_offset
= roff
;
10376 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHER
);
10377 r
->r_addend
= relative_targ
+ roff
;
10380 if (((off
>> 32) & 0xffffffffULL
) != 0)
10382 if (PPC_HI (off
) != 0)
10386 r
->r_offset
= roff
;
10387 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGH
);
10388 r
->r_addend
= relative_targ
+ roff
;
10390 if (PPC_LO (off
) != 0)
10394 r
->r_offset
= roff
;
10395 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_LO
);
10396 r
->r_addend
= relative_targ
+ roff
;
10403 build_powerxx_offset (bfd
*abfd
, bfd_byte
*p
, bfd_vma off
, int odd
,
10407 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10412 bfd_put_32 (abfd
, NOP
, p
);
10418 insn
= PADDI_R12_PC
;
10420 bfd_put_32 (abfd
, insn
>> 32, p
);
10422 bfd_put_32 (abfd
, insn
, p
);
10424 /* The minimum value for paddi is -0x200000000. The minimum value
10425 for li is -0x8000, which when shifted by 34 and added gives a
10426 minimum value of -0x2000200000000. The maximum value is
10427 0x1ffffffff+0x7fff<<34 which is 0x2000200000000-1. */
10428 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10431 bfd_put_32 (abfd
, LI_R11_0
| (HA34 (off
) & 0xffff), p
);
10435 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10438 insn
= PADDI_R12_PC
| D34 (off
);
10439 bfd_put_32 (abfd
, insn
>> 32, p
);
10441 bfd_put_32 (abfd
, insn
, p
);
10445 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10449 bfd_put_32 (abfd
, LDX_R12_R11_R12
, p
);
10451 bfd_put_32 (abfd
, ADD_R12_R11_R12
, p
);
10456 bfd_put_32 (abfd
, LIS_R11
| ((HA34 (off
) >> 16) & 0x3fff), p
);
10458 bfd_put_32 (abfd
, ORI_R11_R11_0
| (HA34 (off
) & 0xffff), p
);
10462 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10465 insn
= PADDI_R12_PC
| D34 (off
);
10466 bfd_put_32 (abfd
, insn
>> 32, p
);
10468 bfd_put_32 (abfd
, insn
, p
);
10472 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10476 bfd_put_32 (abfd
, LDX_R12_R11_R12
, p
);
10478 bfd_put_32 (abfd
, ADD_R12_R11_R12
, p
);
10484 static unsigned int
10485 size_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 unsigned int
10496 num_relocs_for_powerxx_offset (bfd_vma off
, int odd
)
10498 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10500 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10506 static Elf_Internal_Rela
*
10507 emit_relocs_for_powerxx_offset (struct bfd_link_info
*info
,
10508 Elf_Internal_Rela
*r
, bfd_vma roff
,
10509 bfd_vma targ
, bfd_vma off
, int odd
)
10511 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10513 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10515 int d_offset
= bfd_big_endian (info
->output_bfd
) ? 2 : 0;
10516 r
->r_offset
= roff
+ d_offset
;
10517 r
->r_addend
= targ
+ 8 - odd
- d_offset
;
10518 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHERA34
);
10524 int d_offset
= bfd_big_endian (info
->output_bfd
) ? 2 : 0;
10525 r
->r_offset
= roff
+ d_offset
;
10526 r
->r_addend
= targ
+ 8 + odd
- d_offset
;
10527 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHESTA34
);
10530 r
->r_offset
= roff
+ d_offset
;
10531 r
->r_addend
= targ
+ 4 + odd
- d_offset
;
10532 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHERA34
);
10536 r
->r_offset
= roff
;
10537 r
->r_addend
= targ
;
10538 r
->r_info
= ELF64_R_INFO (0, R_PPC64_PCREL34
);
10542 /* Emit .eh_frame opcode to advance pc by DELTA. */
10545 eh_advance (bfd
*abfd
, bfd_byte
*eh
, unsigned int delta
)
10549 *eh
++ = DW_CFA_advance_loc
+ delta
;
10550 else if (delta
< 256)
10552 *eh
++ = DW_CFA_advance_loc1
;
10555 else if (delta
< 65536)
10557 *eh
++ = DW_CFA_advance_loc2
;
10558 bfd_put_16 (abfd
, delta
, eh
);
10563 *eh
++ = DW_CFA_advance_loc4
;
10564 bfd_put_32 (abfd
, delta
, eh
);
10570 /* Size of required .eh_frame opcode to advance pc by DELTA. */
10572 static unsigned int
10573 eh_advance_size (unsigned int delta
)
10575 if (delta
< 64 * 4)
10576 /* DW_CFA_advance_loc+[1..63]. */
10578 if (delta
< 256 * 4)
10579 /* DW_CFA_advance_loc1, byte. */
10581 if (delta
< 65536 * 4)
10582 /* DW_CFA_advance_loc2, 2 bytes. */
10584 /* DW_CFA_advance_loc4, 4 bytes. */
10588 /* With power7 weakly ordered memory model, it is possible for ld.so
10589 to update a plt entry in one thread and have another thread see a
10590 stale zero toc entry. To avoid this we need some sort of acquire
10591 barrier in the call stub. One solution is to make the load of the
10592 toc word seem to appear to depend on the load of the function entry
10593 word. Another solution is to test for r2 being zero, and branch to
10594 the appropriate glink entry if so.
10596 . fake dep barrier compare
10597 . ld 12,xxx(2) ld 12,xxx(2)
10598 . mtctr 12 mtctr 12
10599 . xor 11,12,12 ld 2,xxx+8(2)
10600 . add 2,2,11 cmpldi 2,0
10601 . ld 2,xxx+8(2) bnectr+
10602 . bctr b <glink_entry>
10604 The solution involving the compare turns out to be faster, so
10605 that's what we use unless the branch won't reach. */
10607 #define ALWAYS_USE_FAKE_DEP 0
10608 #define ALWAYS_EMIT_R2SAVE 0
10610 static inline unsigned int
10611 plt_stub_size (struct ppc_link_hash_table
*htab
,
10612 struct ppc_stub_hash_entry
*stub_entry
,
10617 if (stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
)
10619 if (htab
->powerxx_stubs
)
10621 bfd_vma start
= (stub_entry
->stub_offset
10622 + stub_entry
->group
->stub_sec
->output_offset
10623 + stub_entry
->group
->stub_sec
->output_section
->vma
);
10624 if (stub_entry
->stub_type
> ppc_stub_plt_call_notoc
)
10626 size
= 8 + size_powerxx_offset (off
, start
& 4);
10629 size
= 8 + size_offset (off
- 8);
10630 if (stub_entry
->stub_type
> ppc_stub_plt_call_notoc
)
10636 if (ALWAYS_EMIT_R2SAVE
10637 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10639 if (PPC_HA (off
) != 0)
10644 if (htab
->params
->plt_static_chain
)
10646 if (htab
->params
->plt_thread_safe
10647 && htab
->elf
.dynamic_sections_created
10648 && stub_entry
->h
!= NULL
10649 && stub_entry
->h
->elf
.dynindx
!= -1)
10651 if (PPC_HA (off
+ 8 + 8 * htab
->params
->plt_static_chain
) != PPC_HA (off
))
10654 if (stub_entry
->h
!= NULL
10655 && (stub_entry
->h
== htab
->tls_get_addr_fd
10656 || stub_entry
->h
== htab
->tls_get_addr
)
10657 && htab
->params
->tls_get_addr_opt
)
10660 if (stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10666 /* Depending on the sign of plt_stub_align:
10667 If positive, return the padding to align to a 2**plt_stub_align
10669 If negative, if this stub would cross fewer 2**plt_stub_align
10670 boundaries if we align, then return the padding needed to do so. */
10672 static inline unsigned int
10673 plt_stub_pad (struct ppc_link_hash_table
*htab
,
10674 struct ppc_stub_hash_entry
*stub_entry
,
10678 unsigned stub_size
;
10679 bfd_vma stub_off
= stub_entry
->group
->stub_sec
->size
;
10681 if (htab
->params
->plt_stub_align
>= 0)
10683 stub_align
= 1 << htab
->params
->plt_stub_align
;
10684 if ((stub_off
& (stub_align
- 1)) != 0)
10685 return stub_align
- (stub_off
& (stub_align
- 1));
10689 stub_align
= 1 << -htab
->params
->plt_stub_align
;
10690 stub_size
= plt_stub_size (htab
, stub_entry
, plt_off
);
10691 if (((stub_off
+ stub_size
- 1) & -stub_align
) - (stub_off
& -stub_align
)
10692 > ((stub_size
- 1) & -stub_align
))
10693 return stub_align
- (stub_off
& (stub_align
- 1));
10697 /* Build a .plt call stub. */
10699 static inline bfd_byte
*
10700 build_plt_stub (struct ppc_link_hash_table
*htab
,
10701 struct ppc_stub_hash_entry
*stub_entry
,
10702 bfd_byte
*p
, bfd_vma offset
, Elf_Internal_Rela
*r
)
10704 bfd
*obfd
= htab
->params
->stub_bfd
;
10705 bfd_boolean plt_load_toc
= htab
->opd_abi
;
10706 bfd_boolean plt_static_chain
= htab
->params
->plt_static_chain
;
10707 bfd_boolean plt_thread_safe
= (htab
->params
->plt_thread_safe
10708 && htab
->elf
.dynamic_sections_created
10709 && stub_entry
->h
!= NULL
10710 && stub_entry
->h
->elf
.dynindx
!= -1);
10711 bfd_boolean use_fake_dep
= plt_thread_safe
;
10712 bfd_vma cmp_branch_off
= 0;
10714 if (!ALWAYS_USE_FAKE_DEP
10717 && !((stub_entry
->h
== htab
->tls_get_addr_fd
10718 || stub_entry
->h
== htab
->tls_get_addr
)
10719 && htab
->params
->tls_get_addr_opt
))
10721 bfd_vma pltoff
= stub_entry
->plt_ent
->plt
.offset
& ~1;
10722 bfd_vma pltindex
= ((pltoff
- PLT_INITIAL_ENTRY_SIZE (htab
))
10723 / PLT_ENTRY_SIZE (htab
));
10724 bfd_vma glinkoff
= GLINK_PLTRESOLVE_SIZE (htab
) + pltindex
* 8;
10727 if (pltindex
> 32768)
10728 glinkoff
+= (pltindex
- 32768) * 4;
10730 + htab
->glink
->output_offset
10731 + htab
->glink
->output_section
->vma
);
10732 from
= (p
- stub_entry
->group
->stub_sec
->contents
10733 + 4 * (ALWAYS_EMIT_R2SAVE
10734 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10735 + 4 * (PPC_HA (offset
) != 0)
10736 + 4 * (PPC_HA (offset
+ 8 + 8 * plt_static_chain
)
10737 != PPC_HA (offset
))
10738 + 4 * (plt_static_chain
!= 0)
10740 + stub_entry
->group
->stub_sec
->output_offset
10741 + stub_entry
->group
->stub_sec
->output_section
->vma
);
10742 cmp_branch_off
= to
- from
;
10743 use_fake_dep
= cmp_branch_off
+ (1 << 25) >= (1 << 26);
10746 if (PPC_HA (offset
) != 0)
10750 if (ALWAYS_EMIT_R2SAVE
10751 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10752 r
[0].r_offset
+= 4;
10753 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_HA
);
10754 r
[1].r_offset
= r
[0].r_offset
+ 4;
10755 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
10756 r
[1].r_addend
= r
[0].r_addend
;
10759 if (PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
10761 r
[2].r_offset
= r
[1].r_offset
+ 4;
10762 r
[2].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO
);
10763 r
[2].r_addend
= r
[0].r_addend
;
10767 r
[2].r_offset
= r
[1].r_offset
+ 8 + 8 * use_fake_dep
;
10768 r
[2].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
10769 r
[2].r_addend
= r
[0].r_addend
+ 8;
10770 if (plt_static_chain
)
10772 r
[3].r_offset
= r
[2].r_offset
+ 4;
10773 r
[3].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
10774 r
[3].r_addend
= r
[0].r_addend
+ 16;
10779 if (ALWAYS_EMIT_R2SAVE
10780 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10781 bfd_put_32 (obfd
, STD_R2_0R1
+ STK_TOC (htab
), p
), p
+= 4;
10784 bfd_put_32 (obfd
, ADDIS_R11_R2
| PPC_HA (offset
), p
), p
+= 4;
10785 bfd_put_32 (obfd
, LD_R12_0R11
| PPC_LO (offset
), p
), p
+= 4;
10789 bfd_put_32 (obfd
, ADDIS_R12_R2
| PPC_HA (offset
), p
), p
+= 4;
10790 bfd_put_32 (obfd
, LD_R12_0R12
| PPC_LO (offset
), p
), p
+= 4;
10793 && PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
10795 bfd_put_32 (obfd
, ADDI_R11_R11
| PPC_LO (offset
), p
), p
+= 4;
10798 bfd_put_32 (obfd
, MTCTR_R12
, p
), p
+= 4;
10803 bfd_put_32 (obfd
, XOR_R2_R12_R12
, p
), p
+= 4;
10804 bfd_put_32 (obfd
, ADD_R11_R11_R2
, p
), p
+= 4;
10806 bfd_put_32 (obfd
, LD_R2_0R11
| PPC_LO (offset
+ 8), p
), p
+= 4;
10807 if (plt_static_chain
)
10808 bfd_put_32 (obfd
, LD_R11_0R11
| PPC_LO (offset
+ 16), p
), p
+= 4;
10815 if (ALWAYS_EMIT_R2SAVE
10816 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10817 r
[0].r_offset
+= 4;
10818 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
10821 if (PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
10823 r
[1].r_offset
= r
[0].r_offset
+ 4;
10824 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16
);
10825 r
[1].r_addend
= r
[0].r_addend
;
10829 r
[1].r_offset
= r
[0].r_offset
+ 8 + 8 * use_fake_dep
;
10830 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
10831 r
[1].r_addend
= r
[0].r_addend
+ 8 + 8 * plt_static_chain
;
10832 if (plt_static_chain
)
10834 r
[2].r_offset
= r
[1].r_offset
+ 4;
10835 r
[2].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
10836 r
[2].r_addend
= r
[0].r_addend
+ 8;
10841 if (ALWAYS_EMIT_R2SAVE
10842 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10843 bfd_put_32 (obfd
, STD_R2_0R1
+ STK_TOC (htab
), p
), p
+= 4;
10844 bfd_put_32 (obfd
, LD_R12_0R2
| PPC_LO (offset
), p
), p
+= 4;
10846 && PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
10848 bfd_put_32 (obfd
, ADDI_R2_R2
| PPC_LO (offset
), p
), p
+= 4;
10851 bfd_put_32 (obfd
, MTCTR_R12
, p
), p
+= 4;
10856 bfd_put_32 (obfd
, XOR_R11_R12_R12
, p
), p
+= 4;
10857 bfd_put_32 (obfd
, ADD_R2_R2_R11
, p
), p
+= 4;
10859 if (plt_static_chain
)
10860 bfd_put_32 (obfd
, LD_R11_0R2
| PPC_LO (offset
+ 16), p
), p
+= 4;
10861 bfd_put_32 (obfd
, LD_R2_0R2
| PPC_LO (offset
+ 8), p
), p
+= 4;
10864 if (plt_load_toc
&& plt_thread_safe
&& !use_fake_dep
)
10866 bfd_put_32 (obfd
, CMPLDI_R2_0
, p
), p
+= 4;
10867 bfd_put_32 (obfd
, BNECTR_P4
, p
), p
+= 4;
10868 bfd_put_32 (obfd
, B_DOT
| (cmp_branch_off
& 0x3fffffc), p
), p
+= 4;
10871 bfd_put_32 (obfd
, BCTR
, p
), p
+= 4;
10875 /* Build a special .plt call stub for __tls_get_addr. */
10877 #define LD_R11_0R3 0xe9630000
10878 #define LD_R12_0R3 0xe9830000
10879 #define MR_R0_R3 0x7c601b78
10880 #define CMPDI_R11_0 0x2c2b0000
10881 #define ADD_R3_R12_R13 0x7c6c6a14
10882 #define BEQLR 0x4d820020
10883 #define MR_R3_R0 0x7c030378
10884 #define STD_R11_0R1 0xf9610000
10885 #define BCTRL 0x4e800421
10886 #define LD_R11_0R1 0xe9610000
10887 #define MTLR_R11 0x7d6803a6
10889 static inline bfd_byte
*
10890 build_tls_get_addr_stub (struct ppc_link_hash_table
*htab
,
10891 struct ppc_stub_hash_entry
*stub_entry
,
10892 bfd_byte
*p
, bfd_vma offset
, Elf_Internal_Rela
*r
)
10894 bfd
*obfd
= htab
->params
->stub_bfd
;
10897 bfd_put_32 (obfd
, LD_R11_0R3
+ 0, p
), p
+= 4;
10898 bfd_put_32 (obfd
, LD_R12_0R3
+ 8, p
), p
+= 4;
10899 bfd_put_32 (obfd
, MR_R0_R3
, p
), p
+= 4;
10900 bfd_put_32 (obfd
, CMPDI_R11_0
, p
), p
+= 4;
10901 bfd_put_32 (obfd
, ADD_R3_R12_R13
, p
), p
+= 4;
10902 bfd_put_32 (obfd
, BEQLR
, p
), p
+= 4;
10903 bfd_put_32 (obfd
, MR_R3_R0
, p
), p
+= 4;
10905 r
[0].r_offset
+= 7 * 4;
10906 if (stub_entry
->stub_type
!= ppc_stub_plt_call_r2save
)
10907 return build_plt_stub (htab
, stub_entry
, p
, offset
, r
);
10909 bfd_put_32 (obfd
, MFLR_R11
, p
), p
+= 4;
10910 bfd_put_32 (obfd
, STD_R11_0R1
+ STK_LINKER (htab
), p
), p
+= 4;
10913 r
[0].r_offset
+= 2 * 4;
10914 p
= build_plt_stub (htab
, stub_entry
, p
, offset
, r
);
10915 bfd_put_32 (obfd
, BCTRL
, p
- 4);
10917 bfd_put_32 (obfd
, LD_R2_0R1
+ STK_TOC (htab
), p
), p
+= 4;
10918 bfd_put_32 (obfd
, LD_R11_0R1
+ STK_LINKER (htab
), p
), p
+= 4;
10919 bfd_put_32 (obfd
, MTLR_R11
, p
), p
+= 4;
10920 bfd_put_32 (obfd
, BLR
, p
), p
+= 4;
10922 if (htab
->glink_eh_frame
!= NULL
10923 && htab
->glink_eh_frame
->size
!= 0)
10925 bfd_byte
*base
, *eh
;
10926 unsigned int lr_used
, delta
;
10928 base
= htab
->glink_eh_frame
->contents
+ stub_entry
->group
->eh_base
+ 17;
10929 eh
= base
+ stub_entry
->group
->eh_size
;
10930 lr_used
= stub_entry
->stub_offset
+ (p
- 20 - loc
);
10931 delta
= lr_used
- stub_entry
->group
->lr_restore
;
10932 stub_entry
->group
->lr_restore
= lr_used
+ 16;
10933 eh
= eh_advance (htab
->elf
.dynobj
, eh
, delta
);
10934 *eh
++ = DW_CFA_offset_extended_sf
;
10936 *eh
++ = -(STK_LINKER (htab
) / 8) & 0x7f;
10937 *eh
++ = DW_CFA_advance_loc
+ 4;
10938 *eh
++ = DW_CFA_restore_extended
;
10940 stub_entry
->group
->eh_size
= eh
- base
;
10945 static Elf_Internal_Rela
*
10946 get_relocs (asection
*sec
, int count
)
10948 Elf_Internal_Rela
*relocs
;
10949 struct bfd_elf_section_data
*elfsec_data
;
10951 elfsec_data
= elf_section_data (sec
);
10952 relocs
= elfsec_data
->relocs
;
10953 if (relocs
== NULL
)
10955 bfd_size_type relsize
;
10956 relsize
= sec
->reloc_count
* sizeof (*relocs
);
10957 relocs
= bfd_alloc (sec
->owner
, relsize
);
10958 if (relocs
== NULL
)
10960 elfsec_data
->relocs
= relocs
;
10961 elfsec_data
->rela
.hdr
= bfd_zalloc (sec
->owner
,
10962 sizeof (Elf_Internal_Shdr
));
10963 if (elfsec_data
->rela
.hdr
== NULL
)
10965 elfsec_data
->rela
.hdr
->sh_size
= (sec
->reloc_count
10966 * sizeof (Elf64_External_Rela
));
10967 elfsec_data
->rela
.hdr
->sh_entsize
= sizeof (Elf64_External_Rela
);
10968 sec
->reloc_count
= 0;
10970 relocs
+= sec
->reloc_count
;
10971 sec
->reloc_count
+= count
;
10975 /* Convert the relocs R[0] thru R[-NUM_REL+1], which are all no-symbol
10976 forms, to the equivalent relocs against the global symbol given by
10980 use_global_in_relocs (struct ppc_link_hash_table
*htab
,
10981 struct ppc_stub_hash_entry
*stub_entry
,
10982 Elf_Internal_Rela
*r
, unsigned int num_rel
)
10984 struct elf_link_hash_entry
**hashes
;
10985 unsigned long symndx
;
10986 struct ppc_link_hash_entry
*h
;
10989 /* Relocs are always against symbols in their own object file. Fake
10990 up global sym hashes for the stub bfd (which has no symbols). */
10991 hashes
= elf_sym_hashes (htab
->params
->stub_bfd
);
10992 if (hashes
== NULL
)
10994 bfd_size_type hsize
;
10996 /* When called the first time, stub_globals will contain the
10997 total number of symbols seen during stub sizing. After
10998 allocating, stub_globals is used as an index to fill the
11000 hsize
= (htab
->stub_globals
+ 1) * sizeof (*hashes
);
11001 hashes
= bfd_zalloc (htab
->params
->stub_bfd
, hsize
);
11002 if (hashes
== NULL
)
11004 elf_sym_hashes (htab
->params
->stub_bfd
) = hashes
;
11005 htab
->stub_globals
= 1;
11007 symndx
= htab
->stub_globals
++;
11009 hashes
[symndx
] = &h
->elf
;
11010 if (h
->oh
!= NULL
&& h
->oh
->is_func
)
11011 h
= ppc_follow_link (h
->oh
);
11012 BFD_ASSERT (h
->elf
.root
.type
== bfd_link_hash_defined
11013 || h
->elf
.root
.type
== bfd_link_hash_defweak
);
11014 symval
= (h
->elf
.root
.u
.def
.value
11015 + h
->elf
.root
.u
.def
.section
->output_offset
11016 + h
->elf
.root
.u
.def
.section
->output_section
->vma
);
11017 while (num_rel
-- != 0)
11019 r
->r_info
= ELF64_R_INFO (symndx
, ELF64_R_TYPE (r
->r_info
));
11020 if (h
->elf
.root
.u
.def
.section
!= stub_entry
->target_section
)
11022 /* H is an opd symbol. The addend must be zero, and the
11023 branch reloc is the only one we can convert. */
11028 r
->r_addend
-= symval
;
11035 get_r2off (struct bfd_link_info
*info
,
11036 struct ppc_stub_hash_entry
*stub_entry
)
11038 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
11039 bfd_vma r2off
= htab
->sec_info
[stub_entry
->target_section
->id
].toc_off
;
11043 /* Support linking -R objects. Get the toc pointer from the
11046 if (!htab
->opd_abi
)
11048 asection
*opd
= stub_entry
->h
->elf
.root
.u
.def
.section
;
11049 bfd_vma opd_off
= stub_entry
->h
->elf
.root
.u
.def
.value
;
11051 if (strcmp (opd
->name
, ".opd") != 0
11052 || opd
->reloc_count
!= 0)
11054 info
->callbacks
->einfo
11055 (_("%P: cannot find opd entry toc for `%pT'\n"),
11056 stub_entry
->h
->elf
.root
.root
.string
);
11057 bfd_set_error (bfd_error_bad_value
);
11058 return (bfd_vma
) -1;
11060 if (!bfd_get_section_contents (opd
->owner
, opd
, buf
, opd_off
+ 8, 8))
11061 return (bfd_vma
) -1;
11062 r2off
= bfd_get_64 (opd
->owner
, buf
);
11063 r2off
-= elf_gp (info
->output_bfd
);
11065 r2off
-= htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
;
11070 ppc_build_one_stub (struct bfd_hash_entry
*gen_entry
, void *in_arg
)
11072 struct ppc_stub_hash_entry
*stub_entry
;
11073 struct ppc_branch_hash_entry
*br_entry
;
11074 struct bfd_link_info
*info
;
11075 struct ppc_link_hash_table
*htab
;
11077 bfd_byte
*p
, *relp
;
11079 Elf_Internal_Rela
*r
;
11084 /* Massage our args to the form they really have. */
11085 stub_entry
= (struct ppc_stub_hash_entry
*) gen_entry
;
11088 htab
= ppc_hash_table (info
);
11092 BFD_ASSERT (stub_entry
->stub_offset
>= stub_entry
->group
->stub_sec
->size
);
11093 loc
= stub_entry
->group
->stub_sec
->contents
+ stub_entry
->stub_offset
;
11095 htab
->stub_count
[stub_entry
->stub_type
- 1] += 1;
11096 switch (stub_entry
->stub_type
)
11098 case ppc_stub_long_branch
:
11099 case ppc_stub_long_branch_r2off
:
11100 /* Branches are relative. This is where we are going to. */
11101 targ
= (stub_entry
->target_value
11102 + stub_entry
->target_section
->output_offset
11103 + stub_entry
->target_section
->output_section
->vma
);
11104 targ
+= PPC64_LOCAL_ENTRY_OFFSET (stub_entry
->other
);
11106 /* And this is where we are coming from. */
11107 off
= (stub_entry
->stub_offset
11108 + stub_entry
->group
->stub_sec
->output_offset
11109 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11113 if (stub_entry
->stub_type
== ppc_stub_long_branch_r2off
)
11115 bfd_vma r2off
= get_r2off (info
, stub_entry
);
11117 if (r2off
== (bfd_vma
) -1)
11119 htab
->stub_error
= TRUE
;
11122 bfd_put_32 (htab
->params
->stub_bfd
, STD_R2_0R1
+ STK_TOC (htab
), p
);
11124 if (PPC_HA (r2off
) != 0)
11126 bfd_put_32 (htab
->params
->stub_bfd
,
11127 ADDIS_R2_R2
| PPC_HA (r2off
), p
);
11130 if (PPC_LO (r2off
) != 0)
11132 bfd_put_32 (htab
->params
->stub_bfd
,
11133 ADDI_R2_R2
| PPC_LO (r2off
), p
);
11138 bfd_put_32 (htab
->params
->stub_bfd
, B_DOT
| (off
& 0x3fffffc), p
);
11141 if (off
+ (1 << 25) >= (bfd_vma
) (1 << 26))
11144 (_("long branch stub `%s' offset overflow"),
11145 stub_entry
->root
.string
);
11146 htab
->stub_error
= TRUE
;
11150 if (info
->emitrelocations
)
11152 r
= get_relocs (stub_entry
->group
->stub_sec
, 1);
11155 r
->r_offset
= p
- 4 - stub_entry
->group
->stub_sec
->contents
;
11156 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL24
);
11157 r
->r_addend
= targ
;
11158 if (stub_entry
->h
!= NULL
11159 && !use_global_in_relocs (htab
, stub_entry
, r
, 1))
11164 case ppc_stub_plt_branch
:
11165 case ppc_stub_plt_branch_r2off
:
11166 br_entry
= ppc_branch_hash_lookup (&htab
->branch_hash_table
,
11167 stub_entry
->root
.string
+ 9,
11169 if (br_entry
== NULL
)
11171 _bfd_error_handler (_("can't find branch stub `%s'"),
11172 stub_entry
->root
.string
);
11173 htab
->stub_error
= TRUE
;
11177 targ
= (stub_entry
->target_value
11178 + stub_entry
->target_section
->output_offset
11179 + stub_entry
->target_section
->output_section
->vma
);
11180 if (stub_entry
->stub_type
!= ppc_stub_plt_branch_r2off
)
11181 targ
+= PPC64_LOCAL_ENTRY_OFFSET (stub_entry
->other
);
11183 bfd_put_64 (htab
->brlt
->owner
, targ
,
11184 htab
->brlt
->contents
+ br_entry
->offset
);
11186 if (br_entry
->iter
== htab
->stub_iteration
)
11188 br_entry
->iter
= 0;
11190 if (htab
->relbrlt
!= NULL
)
11192 /* Create a reloc for the branch lookup table entry. */
11193 Elf_Internal_Rela rela
;
11196 rela
.r_offset
= (br_entry
->offset
11197 + htab
->brlt
->output_offset
11198 + htab
->brlt
->output_section
->vma
);
11199 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
11200 rela
.r_addend
= targ
;
11202 rl
= htab
->relbrlt
->contents
;
11203 rl
+= (htab
->relbrlt
->reloc_count
++
11204 * sizeof (Elf64_External_Rela
));
11205 bfd_elf64_swap_reloca_out (htab
->relbrlt
->owner
, &rela
, rl
);
11207 else if (info
->emitrelocations
)
11209 r
= get_relocs (htab
->brlt
, 1);
11212 /* brlt, being SEC_LINKER_CREATED does not go through the
11213 normal reloc processing. Symbols and offsets are not
11214 translated from input file to output file form, so
11215 set up the offset per the output file. */
11216 r
->r_offset
= (br_entry
->offset
11217 + htab
->brlt
->output_offset
11218 + htab
->brlt
->output_section
->vma
);
11219 r
->r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
11220 r
->r_addend
= targ
;
11224 targ
= (br_entry
->offset
11225 + htab
->brlt
->output_offset
11226 + htab
->brlt
->output_section
->vma
);
11228 off
= (elf_gp (info
->output_bfd
)
11229 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
11232 if (off
+ 0x80008000 > 0xffffffff || (off
& 7) != 0)
11234 info
->callbacks
->einfo
11235 (_("%P: linkage table error against `%pT'\n"),
11236 stub_entry
->root
.string
);
11237 bfd_set_error (bfd_error_bad_value
);
11238 htab
->stub_error
= TRUE
;
11242 if (info
->emitrelocations
)
11244 r
= get_relocs (stub_entry
->group
->stub_sec
, 1 + (PPC_HA (off
) != 0));
11247 r
[0].r_offset
= loc
- stub_entry
->group
->stub_sec
->contents
;
11248 if (bfd_big_endian (info
->output_bfd
))
11249 r
[0].r_offset
+= 2;
11250 if (stub_entry
->stub_type
== ppc_stub_plt_branch_r2off
)
11251 r
[0].r_offset
+= 4;
11252 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
11253 r
[0].r_addend
= targ
;
11254 if (PPC_HA (off
) != 0)
11256 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_HA
);
11257 r
[1].r_offset
= r
[0].r_offset
+ 4;
11258 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
11259 r
[1].r_addend
= r
[0].r_addend
;
11264 if (stub_entry
->stub_type
!= ppc_stub_plt_branch_r2off
)
11266 if (PPC_HA (off
) != 0)
11268 bfd_put_32 (htab
->params
->stub_bfd
,
11269 ADDIS_R12_R2
| PPC_HA (off
), p
);
11271 bfd_put_32 (htab
->params
->stub_bfd
,
11272 LD_R12_0R12
| PPC_LO (off
), p
);
11275 bfd_put_32 (htab
->params
->stub_bfd
,
11276 LD_R12_0R2
| PPC_LO (off
), p
);
11280 bfd_vma r2off
= get_r2off (info
, stub_entry
);
11282 if (r2off
== (bfd_vma
) -1)
11284 htab
->stub_error
= TRUE
;
11288 bfd_put_32 (htab
->params
->stub_bfd
, STD_R2_0R1
+ STK_TOC (htab
), p
);
11290 if (PPC_HA (off
) != 0)
11292 bfd_put_32 (htab
->params
->stub_bfd
,
11293 ADDIS_R12_R2
| PPC_HA (off
), p
);
11295 bfd_put_32 (htab
->params
->stub_bfd
,
11296 LD_R12_0R12
| PPC_LO (off
), p
);
11299 bfd_put_32 (htab
->params
->stub_bfd
, LD_R12_0R2
| PPC_LO (off
), p
);
11301 if (PPC_HA (r2off
) != 0)
11304 bfd_put_32 (htab
->params
->stub_bfd
,
11305 ADDIS_R2_R2
| PPC_HA (r2off
), p
);
11307 if (PPC_LO (r2off
) != 0)
11310 bfd_put_32 (htab
->params
->stub_bfd
,
11311 ADDI_R2_R2
| PPC_LO (r2off
), p
);
11315 bfd_put_32 (htab
->params
->stub_bfd
, MTCTR_R12
, p
);
11317 bfd_put_32 (htab
->params
->stub_bfd
, BCTR
, p
);
11321 case ppc_stub_long_branch_notoc
:
11322 case ppc_stub_long_branch_both
:
11323 case ppc_stub_plt_branch_notoc
:
11324 case ppc_stub_plt_branch_both
:
11325 case ppc_stub_plt_call_notoc
:
11326 case ppc_stub_plt_call_both
:
11328 off
= (stub_entry
->stub_offset
11329 + stub_entry
->group
->stub_sec
->output_offset
11330 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11331 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
11332 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
11333 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
11336 bfd_put_32 (htab
->params
->stub_bfd
, STD_R2_0R1
+ STK_TOC (htab
), p
);
11339 if (stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
)
11341 targ
= stub_entry
->plt_ent
->plt
.offset
& ~1;
11342 if (targ
>= (bfd_vma
) -2)
11345 plt
= htab
->elf
.splt
;
11346 if (!htab
->elf
.dynamic_sections_created
11347 || stub_entry
->h
== NULL
11348 || stub_entry
->h
->elf
.dynindx
== -1)
11350 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
11351 plt
= htab
->elf
.iplt
;
11353 plt
= htab
->pltlocal
;
11355 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
11358 targ
= (stub_entry
->target_value
11359 + stub_entry
->target_section
->output_offset
11360 + stub_entry
->target_section
->output_section
->vma
);
11366 if (htab
->powerxx_stubs
)
11368 bfd_boolean load
= stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
;
11369 p
= build_powerxx_offset (htab
->params
->stub_bfd
, p
, off
, odd
, load
);
11373 /* The notoc stubs calculate their target (either a PLT entry or
11374 the global entry point of a function) relative to the PC
11375 returned by the "bcl" two instructions past the start of the
11376 sequence emitted by build_offset. The offset is therefore 8
11377 less than calculated from the start of the sequence. */
11379 p
= build_offset (htab
->params
->stub_bfd
, p
, off
,
11380 stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
);
11383 if (stub_entry
->stub_type
<= ppc_stub_long_branch_both
)
11387 from
= (stub_entry
->stub_offset
11388 + stub_entry
->group
->stub_sec
->output_offset
11389 + stub_entry
->group
->stub_sec
->output_section
->vma
11391 bfd_put_32 (htab
->params
->stub_bfd
,
11392 B_DOT
| ((targ
- from
) & 0x3fffffc), p
);
11396 bfd_put_32 (htab
->params
->stub_bfd
, MTCTR_R12
, p
);
11398 bfd_put_32 (htab
->params
->stub_bfd
, BCTR
, p
);
11402 if (info
->emitrelocations
)
11404 bfd_vma roff
= relp
- stub_entry
->group
->stub_sec
->contents
;
11405 if (htab
->powerxx_stubs
)
11406 num_rel
+= num_relocs_for_powerxx_offset (off
, odd
);
11409 num_rel
+= num_relocs_for_offset (off
);
11412 r
= get_relocs (stub_entry
->group
->stub_sec
, num_rel
);
11415 if (htab
->powerxx_stubs
)
11416 r
= emit_relocs_for_powerxx_offset (info
, r
, roff
, targ
, off
, odd
);
11418 r
= emit_relocs_for_offset (info
, r
, roff
, targ
, off
);
11419 if (stub_entry
->stub_type
== ppc_stub_long_branch_notoc
11420 || stub_entry
->stub_type
== ppc_stub_long_branch_both
)
11423 roff
= p
- 4 - stub_entry
->group
->stub_sec
->contents
;
11424 r
->r_offset
= roff
;
11425 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL24
);
11426 r
->r_addend
= targ
;
11427 if (stub_entry
->h
!= NULL
11428 && !use_global_in_relocs (htab
, stub_entry
, r
, num_rel
))
11433 if (!htab
->powerxx_stubs
11434 && htab
->glink_eh_frame
!= NULL
11435 && htab
->glink_eh_frame
->size
!= 0)
11437 bfd_byte
*base
, *eh
;
11438 unsigned int lr_used
, delta
;
11440 base
= (htab
->glink_eh_frame
->contents
11441 + stub_entry
->group
->eh_base
+ 17);
11442 eh
= base
+ stub_entry
->group
->eh_size
;
11443 lr_used
= stub_entry
->stub_offset
+ 8;
11444 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
11445 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
11446 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
11448 delta
= lr_used
- stub_entry
->group
->lr_restore
;
11449 stub_entry
->group
->lr_restore
= lr_used
+ 8;
11450 eh
= eh_advance (htab
->elf
.dynobj
, eh
, delta
);
11451 *eh
++ = DW_CFA_register
;
11454 *eh
++ = DW_CFA_advance_loc
+ 2;
11455 *eh
++ = DW_CFA_restore_extended
;
11457 stub_entry
->group
->eh_size
= eh
- base
;
11461 case ppc_stub_plt_call
:
11462 case ppc_stub_plt_call_r2save
:
11463 if (stub_entry
->h
!= NULL
11464 && stub_entry
->h
->is_func_descriptor
11465 && stub_entry
->h
->oh
!= NULL
)
11467 struct ppc_link_hash_entry
*fh
= ppc_follow_link (stub_entry
->h
->oh
);
11469 /* If the old-ABI "dot-symbol" is undefined make it weak so
11470 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL. */
11471 if (fh
->elf
.root
.type
== bfd_link_hash_undefined
11472 && (stub_entry
->h
->elf
.root
.type
== bfd_link_hash_defined
11473 || stub_entry
->h
->elf
.root
.type
== bfd_link_hash_defweak
))
11474 fh
->elf
.root
.type
= bfd_link_hash_undefweak
;
11477 /* Now build the stub. */
11478 targ
= stub_entry
->plt_ent
->plt
.offset
& ~1;
11479 if (targ
>= (bfd_vma
) -2)
11482 plt
= htab
->elf
.splt
;
11483 if (!htab
->elf
.dynamic_sections_created
11484 || stub_entry
->h
== NULL
11485 || stub_entry
->h
->elf
.dynindx
== -1)
11487 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
11488 plt
= htab
->elf
.iplt
;
11490 plt
= htab
->pltlocal
;
11492 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
11494 off
= (elf_gp (info
->output_bfd
)
11495 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
11498 if (off
+ 0x80008000 > 0xffffffff || (off
& 7) != 0)
11500 info
->callbacks
->einfo
11501 /* xgettext:c-format */
11502 (_("%P: linkage table error against `%pT'\n"),
11503 stub_entry
->h
!= NULL
11504 ? stub_entry
->h
->elf
.root
.root
.string
11506 bfd_set_error (bfd_error_bad_value
);
11507 htab
->stub_error
= TRUE
;
11512 if (info
->emitrelocations
)
11514 r
= get_relocs (stub_entry
->group
->stub_sec
,
11515 ((PPC_HA (off
) != 0)
11517 ? 2 + (htab
->params
->plt_static_chain
11518 && PPC_HA (off
+ 16) == PPC_HA (off
))
11522 r
[0].r_offset
= loc
- stub_entry
->group
->stub_sec
->contents
;
11523 if (bfd_big_endian (info
->output_bfd
))
11524 r
[0].r_offset
+= 2;
11525 r
[0].r_addend
= targ
;
11527 if (stub_entry
->h
!= NULL
11528 && (stub_entry
->h
== htab
->tls_get_addr_fd
11529 || stub_entry
->h
== htab
->tls_get_addr
)
11530 && htab
->params
->tls_get_addr_opt
)
11531 p
= build_tls_get_addr_stub (htab
, stub_entry
, loc
, off
, r
);
11533 p
= build_plt_stub (htab
, stub_entry
, loc
, off
, r
);
11536 case ppc_stub_save_res
:
11544 stub_entry
->group
->stub_sec
->size
= stub_entry
->stub_offset
+ (p
- loc
);
11546 if (htab
->params
->emit_stub_syms
)
11548 struct elf_link_hash_entry
*h
;
11551 const char *const stub_str
[] = { "long_branch",
11564 len1
= strlen (stub_str
[stub_entry
->stub_type
- 1]);
11565 len2
= strlen (stub_entry
->root
.string
);
11566 name
= bfd_malloc (len1
+ len2
+ 2);
11569 memcpy (name
, stub_entry
->root
.string
, 9);
11570 memcpy (name
+ 9, stub_str
[stub_entry
->stub_type
- 1], len1
);
11571 memcpy (name
+ len1
+ 9, stub_entry
->root
.string
+ 8, len2
- 8 + 1);
11572 h
= elf_link_hash_lookup (&htab
->elf
, name
, TRUE
, FALSE
, FALSE
);
11575 if (h
->root
.type
== bfd_link_hash_new
)
11577 h
->root
.type
= bfd_link_hash_defined
;
11578 h
->root
.u
.def
.section
= stub_entry
->group
->stub_sec
;
11579 h
->root
.u
.def
.value
= stub_entry
->stub_offset
;
11580 h
->ref_regular
= 1;
11581 h
->def_regular
= 1;
11582 h
->ref_regular_nonweak
= 1;
11583 h
->forced_local
= 1;
11585 h
->root
.linker_def
= 1;
11592 /* As above, but don't actually build the stub. Just bump offset so
11593 we know stub section sizes, and select plt_branch stubs where
11594 long_branch stubs won't do. */
11597 ppc_size_one_stub (struct bfd_hash_entry
*gen_entry
, void *in_arg
)
11599 struct ppc_stub_hash_entry
*stub_entry
;
11600 struct bfd_link_info
*info
;
11601 struct ppc_link_hash_table
*htab
;
11603 bfd_vma targ
, off
, r2off
;
11604 unsigned int size
, extra
, lr_used
, delta
, odd
;
11606 /* Massage our args to the form they really have. */
11607 stub_entry
= (struct ppc_stub_hash_entry
*) gen_entry
;
11610 htab
= ppc_hash_table (info
);
11614 /* Make a note of the offset within the stubs for this entry. */
11615 stub_entry
->stub_offset
= stub_entry
->group
->stub_sec
->size
;
11617 if (stub_entry
->h
!= NULL
11618 && stub_entry
->h
->save_res
11619 && stub_entry
->h
->elf
.root
.type
== bfd_link_hash_defined
11620 && stub_entry
->h
->elf
.root
.u
.def
.section
== htab
->sfpr
)
11622 /* Don't make stubs to out-of-line register save/restore
11623 functions. Instead, emit copies of the functions. */
11624 stub_entry
->group
->needs_save_res
= 1;
11625 stub_entry
->stub_type
= ppc_stub_save_res
;
11629 switch (stub_entry
->stub_type
)
11631 case ppc_stub_plt_branch
:
11632 case ppc_stub_plt_branch_r2off
:
11633 /* Reset the stub type from the plt branch variant in case we now
11634 can reach with a shorter stub. */
11635 stub_entry
->stub_type
+= ppc_stub_long_branch
- ppc_stub_plt_branch
;
11636 /* Fall through. */
11637 case ppc_stub_long_branch
:
11638 case ppc_stub_long_branch_r2off
:
11639 targ
= (stub_entry
->target_value
11640 + stub_entry
->target_section
->output_offset
11641 + stub_entry
->target_section
->output_section
->vma
);
11642 targ
+= PPC64_LOCAL_ENTRY_OFFSET (stub_entry
->other
);
11643 off
= (stub_entry
->stub_offset
11644 + stub_entry
->group
->stub_sec
->output_offset
11645 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11649 if (stub_entry
->stub_type
== ppc_stub_long_branch_r2off
)
11651 r2off
= get_r2off (info
, stub_entry
);
11652 if (r2off
== (bfd_vma
) -1)
11654 htab
->stub_error
= TRUE
;
11658 if (PPC_HA (r2off
) != 0)
11660 if (PPC_LO (r2off
) != 0)
11666 /* If the branch offset is too big, use a ppc_stub_plt_branch.
11667 Do the same for -R objects without function descriptors. */
11668 if ((stub_entry
->stub_type
== ppc_stub_long_branch_r2off
11670 && htab
->sec_info
[stub_entry
->target_section
->id
].toc_off
== 0)
11671 || off
+ (1 << 25) >= (bfd_vma
) (1 << 26))
11673 struct ppc_branch_hash_entry
*br_entry
;
11675 br_entry
= ppc_branch_hash_lookup (&htab
->branch_hash_table
,
11676 stub_entry
->root
.string
+ 9,
11678 if (br_entry
== NULL
)
11680 _bfd_error_handler (_("can't build branch stub `%s'"),
11681 stub_entry
->root
.string
);
11682 htab
->stub_error
= TRUE
;
11686 if (br_entry
->iter
!= htab
->stub_iteration
)
11688 br_entry
->iter
= htab
->stub_iteration
;
11689 br_entry
->offset
= htab
->brlt
->size
;
11690 htab
->brlt
->size
+= 8;
11692 if (htab
->relbrlt
!= NULL
)
11693 htab
->relbrlt
->size
+= sizeof (Elf64_External_Rela
);
11694 else if (info
->emitrelocations
)
11696 htab
->brlt
->reloc_count
+= 1;
11697 htab
->brlt
->flags
|= SEC_RELOC
;
11701 targ
= (br_entry
->offset
11702 + htab
->brlt
->output_offset
11703 + htab
->brlt
->output_section
->vma
);
11704 off
= (elf_gp (info
->output_bfd
)
11705 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
11708 if (info
->emitrelocations
)
11710 stub_entry
->group
->stub_sec
->reloc_count
11711 += 1 + (PPC_HA (off
) != 0);
11712 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
11715 stub_entry
->stub_type
+= ppc_stub_plt_branch
- ppc_stub_long_branch
;
11716 if (stub_entry
->stub_type
!= ppc_stub_plt_branch_r2off
)
11719 if (PPC_HA (off
) != 0)
11725 if (PPC_HA (off
) != 0)
11728 if (PPC_HA (r2off
) != 0)
11730 if (PPC_LO (r2off
) != 0)
11734 else if (info
->emitrelocations
)
11736 stub_entry
->group
->stub_sec
->reloc_count
+= 1;
11737 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
11741 case ppc_stub_plt_branch_notoc
:
11742 case ppc_stub_plt_branch_both
:
11743 stub_entry
->stub_type
+= ppc_stub_long_branch
- ppc_stub_plt_branch
;
11744 /* Fall through. */
11745 case ppc_stub_long_branch_notoc
:
11746 case ppc_stub_long_branch_both
:
11747 off
= (stub_entry
->stub_offset
11748 + stub_entry
->group
->stub_sec
->output_offset
11749 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11751 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
)
11754 targ
= (stub_entry
->target_value
11755 + stub_entry
->target_section
->output_offset
11756 + stub_entry
->target_section
->output_section
->vma
);
11760 if (info
->emitrelocations
)
11762 unsigned int num_rel
;
11763 if (htab
->powerxx_stubs
)
11764 num_rel
= num_relocs_for_powerxx_offset (off
, odd
);
11766 num_rel
= num_relocs_for_offset (off
- 8);
11767 stub_entry
->group
->stub_sec
->reloc_count
+= num_rel
;
11768 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
11771 if (htab
->powerxx_stubs
)
11772 extra
= size_powerxx_offset (off
, odd
);
11774 extra
= size_offset (off
- 8);
11775 /* Include branch insn plus those in the offset sequence. */
11777 /* The branch insn is at the end, or "extra" bytes along. So
11778 its offset will be "extra" bytes less that that already
11782 if (!htab
->powerxx_stubs
)
11784 /* After the bcl, lr has been modified so we need to emit
11785 .eh_frame info saying the return address is in r12. */
11786 lr_used
= stub_entry
->stub_offset
+ 8;
11787 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
)
11789 /* The eh_frame info will consist of a DW_CFA_advance_loc or
11790 variant, DW_CFA_register, 65, 12, DW_CFA_advance_loc+2,
11791 DW_CFA_restore_extended 65. */
11792 delta
= lr_used
- stub_entry
->group
->lr_restore
;
11793 stub_entry
->group
->eh_size
+= eh_advance_size (delta
) + 6;
11794 stub_entry
->group
->lr_restore
= lr_used
+ 8;
11797 /* If the branch can't reach, use a plt_branch. */
11798 if (off
+ (1 << 25) >= (bfd_vma
) (1 << 26))
11800 stub_entry
->stub_type
+= (ppc_stub_plt_branch_notoc
11801 - ppc_stub_long_branch_notoc
);
11804 else if (info
->emitrelocations
)
11805 stub_entry
->group
->stub_sec
->reloc_count
+=1;
11808 case ppc_stub_plt_call_notoc
:
11809 case ppc_stub_plt_call_both
:
11810 off
= (stub_entry
->stub_offset
11811 + stub_entry
->group
->stub_sec
->output_offset
11812 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11813 if (stub_entry
->stub_type
== ppc_stub_plt_call_both
)
11815 targ
= stub_entry
->plt_ent
->plt
.offset
& ~1;
11816 if (targ
>= (bfd_vma
) -2)
11819 plt
= htab
->elf
.splt
;
11820 if (!htab
->elf
.dynamic_sections_created
11821 || stub_entry
->h
== NULL
11822 || stub_entry
->h
->elf
.dynindx
== -1)
11824 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
11825 plt
= htab
->elf
.iplt
;
11827 plt
= htab
->pltlocal
;
11829 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
11833 if (htab
->params
->plt_stub_align
!= 0)
11835 unsigned pad
= plt_stub_pad (htab
, stub_entry
, off
);
11837 stub_entry
->group
->stub_sec
->size
+= pad
;
11838 stub_entry
->stub_offset
= stub_entry
->group
->stub_sec
->size
;
11842 if (info
->emitrelocations
)
11844 unsigned int num_rel
;
11845 if (htab
->powerxx_stubs
)
11846 num_rel
= num_relocs_for_powerxx_offset (off
, odd
);
11848 num_rel
= num_relocs_for_offset (off
- 8);
11849 stub_entry
->group
->stub_sec
->reloc_count
+= num_rel
;
11850 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
11853 size
= plt_stub_size (htab
, stub_entry
, off
);
11855 if (!htab
->powerxx_stubs
)
11857 /* After the bcl, lr has been modified so we need to emit
11858 .eh_frame info saying the return address is in r12. */
11859 lr_used
= stub_entry
->stub_offset
+ 8;
11860 if (stub_entry
->stub_type
== ppc_stub_plt_call_both
)
11862 /* The eh_frame info will consist of a DW_CFA_advance_loc or
11863 variant, DW_CFA_register, 65, 12, DW_CFA_advance_loc+2,
11864 DW_CFA_restore_extended 65. */
11865 delta
= lr_used
- stub_entry
->group
->lr_restore
;
11866 stub_entry
->group
->eh_size
+= eh_advance_size (delta
) + 6;
11867 stub_entry
->group
->lr_restore
= lr_used
+ 8;
11871 case ppc_stub_plt_call
:
11872 case ppc_stub_plt_call_r2save
:
11873 targ
= stub_entry
->plt_ent
->plt
.offset
& ~(bfd_vma
) 1;
11874 if (targ
>= (bfd_vma
) -2)
11876 plt
= htab
->elf
.splt
;
11877 if (!htab
->elf
.dynamic_sections_created
11878 || stub_entry
->h
== NULL
11879 || stub_entry
->h
->elf
.dynindx
== -1)
11881 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
11882 plt
= htab
->elf
.iplt
;
11884 plt
= htab
->pltlocal
;
11886 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
11888 off
= (elf_gp (info
->output_bfd
)
11889 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
11892 if (htab
->params
->plt_stub_align
!= 0)
11894 unsigned pad
= plt_stub_pad (htab
, stub_entry
, off
);
11896 stub_entry
->group
->stub_sec
->size
+= pad
;
11897 stub_entry
->stub_offset
= stub_entry
->group
->stub_sec
->size
;
11900 if (info
->emitrelocations
)
11902 stub_entry
->group
->stub_sec
->reloc_count
11903 += ((PPC_HA (off
) != 0)
11905 ? 2 + (htab
->params
->plt_static_chain
11906 && PPC_HA (off
+ 16) == PPC_HA (off
))
11908 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
11911 size
= plt_stub_size (htab
, stub_entry
, off
);
11913 if (stub_entry
->h
!= NULL
11914 && (stub_entry
->h
== htab
->tls_get_addr_fd
11915 || stub_entry
->h
== htab
->tls_get_addr
)
11916 && htab
->params
->tls_get_addr_opt
11917 && stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
11919 /* After the bctrl, lr has been modified so we need to
11920 emit .eh_frame info saying the return address is
11921 on the stack. In fact we put the EH info specifying
11922 that the return address is on the stack *at* the
11923 call rather than after it, because the EH info for a
11924 call needs to be specified by that point.
11925 See libgcc/unwind-dw2.c execute_cfa_program. */
11926 lr_used
= stub_entry
->stub_offset
+ size
- 20;
11927 /* The eh_frame info will consist of a DW_CFA_advance_loc
11928 or variant, DW_CFA_offset_externed_sf, 65, -stackoff,
11929 DW_CFA_advance_loc+4, DW_CFA_restore_extended, 65. */
11930 delta
= lr_used
- stub_entry
->group
->lr_restore
;
11931 stub_entry
->group
->eh_size
+= eh_advance_size (delta
) + 6;
11932 stub_entry
->group
->lr_restore
= size
- 4;
11941 stub_entry
->group
->stub_sec
->size
+= size
;
11945 /* Set up various things so that we can make a list of input sections
11946 for each output section included in the link. Returns -1 on error,
11947 0 when no stubs will be needed, and 1 on success. */
11950 ppc64_elf_setup_section_lists (struct bfd_link_info
*info
)
11954 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
11959 htab
->sec_info_arr_size
= _bfd_section_id
;
11960 amt
= sizeof (*htab
->sec_info
) * (htab
->sec_info_arr_size
);
11961 htab
->sec_info
= bfd_zmalloc (amt
);
11962 if (htab
->sec_info
== NULL
)
11965 /* Set toc_off for com, und, abs and ind sections. */
11966 for (id
= 0; id
< 3; id
++)
11967 htab
->sec_info
[id
].toc_off
= TOC_BASE_OFF
;
11972 /* Set up for first pass at multitoc partitioning. */
11975 ppc64_elf_start_multitoc_partition (struct bfd_link_info
*info
)
11977 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
11979 htab
->toc_curr
= ppc64_elf_set_toc (info
, info
->output_bfd
);
11980 htab
->toc_bfd
= NULL
;
11981 htab
->toc_first_sec
= NULL
;
11984 /* The linker repeatedly calls this function for each TOC input section
11985 and linker generated GOT section. Group input bfds such that the toc
11986 within a group is less than 64k in size. */
11989 ppc64_elf_next_toc_section (struct bfd_link_info
*info
, asection
*isec
)
11991 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
11992 bfd_vma addr
, off
, limit
;
11997 if (!htab
->second_toc_pass
)
11999 /* Keep track of the first .toc or .got section for this input bfd. */
12000 bfd_boolean new_bfd
= htab
->toc_bfd
!= isec
->owner
;
12004 htab
->toc_bfd
= isec
->owner
;
12005 htab
->toc_first_sec
= isec
;
12008 addr
= isec
->output_offset
+ isec
->output_section
->vma
;
12009 off
= addr
- htab
->toc_curr
;
12010 limit
= 0x80008000;
12011 if (ppc64_elf_tdata (isec
->owner
)->has_small_toc_reloc
)
12013 if (off
+ isec
->size
> limit
)
12015 addr
= (htab
->toc_first_sec
->output_offset
12016 + htab
->toc_first_sec
->output_section
->vma
);
12017 htab
->toc_curr
= addr
;
12018 htab
->toc_curr
&= -TOC_BASE_ALIGN
;
12021 /* toc_curr is the base address of this toc group. Set elf_gp
12022 for the input section to be the offset relative to the
12023 output toc base plus 0x8000. Making the input elf_gp an
12024 offset allows us to move the toc as a whole without
12025 recalculating input elf_gp. */
12026 off
= htab
->toc_curr
- elf_gp (info
->output_bfd
);
12027 off
+= TOC_BASE_OFF
;
12029 /* Die if someone uses a linker script that doesn't keep input
12030 file .toc and .got together. */
12032 && elf_gp (isec
->owner
) != 0
12033 && elf_gp (isec
->owner
) != off
)
12036 elf_gp (isec
->owner
) = off
;
12040 /* During the second pass toc_first_sec points to the start of
12041 a toc group, and toc_curr is used to track the old elf_gp.
12042 We use toc_bfd to ensure we only look at each bfd once. */
12043 if (htab
->toc_bfd
== isec
->owner
)
12045 htab
->toc_bfd
= isec
->owner
;
12047 if (htab
->toc_first_sec
== NULL
12048 || htab
->toc_curr
!= elf_gp (isec
->owner
))
12050 htab
->toc_curr
= elf_gp (isec
->owner
);
12051 htab
->toc_first_sec
= isec
;
12053 addr
= (htab
->toc_first_sec
->output_offset
12054 + htab
->toc_first_sec
->output_section
->vma
);
12055 off
= addr
- elf_gp (info
->output_bfd
) + TOC_BASE_OFF
;
12056 elf_gp (isec
->owner
) = off
;
12061 /* Called via elf_link_hash_traverse to merge GOT entries for global
12065 merge_global_got (struct elf_link_hash_entry
*h
, void *inf ATTRIBUTE_UNUSED
)
12067 if (h
->root
.type
== bfd_link_hash_indirect
)
12070 merge_got_entries (&h
->got
.glist
);
12075 /* Called via elf_link_hash_traverse to allocate GOT entries for global
12079 reallocate_got (struct elf_link_hash_entry
*h
, void *inf
)
12081 struct got_entry
*gent
;
12083 if (h
->root
.type
== bfd_link_hash_indirect
)
12086 for (gent
= h
->got
.glist
; gent
!= NULL
; gent
= gent
->next
)
12087 if (!gent
->is_indirect
)
12088 allocate_got (h
, (struct bfd_link_info
*) inf
, gent
);
12092 /* Called on the first multitoc pass after the last call to
12093 ppc64_elf_next_toc_section. This function removes duplicate GOT
12097 ppc64_elf_layout_multitoc (struct bfd_link_info
*info
)
12099 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12100 struct bfd
*ibfd
, *ibfd2
;
12101 bfd_boolean done_something
;
12103 htab
->multi_toc_needed
= htab
->toc_curr
!= elf_gp (info
->output_bfd
);
12105 if (!htab
->do_multi_toc
)
12108 /* Merge global sym got entries within a toc group. */
12109 elf_link_hash_traverse (&htab
->elf
, merge_global_got
, info
);
12111 /* And tlsld_got. */
12112 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12114 struct got_entry
*ent
, *ent2
;
12116 if (!is_ppc64_elf (ibfd
))
12119 ent
= ppc64_tlsld_got (ibfd
);
12120 if (!ent
->is_indirect
12121 && ent
->got
.offset
!= (bfd_vma
) -1)
12123 for (ibfd2
= ibfd
->link
.next
; ibfd2
!= NULL
; ibfd2
= ibfd2
->link
.next
)
12125 if (!is_ppc64_elf (ibfd2
))
12128 ent2
= ppc64_tlsld_got (ibfd2
);
12129 if (!ent2
->is_indirect
12130 && ent2
->got
.offset
!= (bfd_vma
) -1
12131 && elf_gp (ibfd2
) == elf_gp (ibfd
))
12133 ent2
->is_indirect
= TRUE
;
12134 ent2
->got
.ent
= ent
;
12140 /* Zap sizes of got sections. */
12141 htab
->elf
.irelplt
->rawsize
= htab
->elf
.irelplt
->size
;
12142 htab
->elf
.irelplt
->size
-= htab
->got_reli_size
;
12143 htab
->got_reli_size
= 0;
12145 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12147 asection
*got
, *relgot
;
12149 if (!is_ppc64_elf (ibfd
))
12152 got
= ppc64_elf_tdata (ibfd
)->got
;
12155 got
->rawsize
= got
->size
;
12157 relgot
= ppc64_elf_tdata (ibfd
)->relgot
;
12158 relgot
->rawsize
= relgot
->size
;
12163 /* Now reallocate the got, local syms first. We don't need to
12164 allocate section contents again since we never increase size. */
12165 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12167 struct got_entry
**lgot_ents
;
12168 struct got_entry
**end_lgot_ents
;
12169 struct plt_entry
**local_plt
;
12170 struct plt_entry
**end_local_plt
;
12171 unsigned char *lgot_masks
;
12172 bfd_size_type locsymcount
;
12173 Elf_Internal_Shdr
*symtab_hdr
;
12176 if (!is_ppc64_elf (ibfd
))
12179 lgot_ents
= elf_local_got_ents (ibfd
);
12183 symtab_hdr
= &elf_symtab_hdr (ibfd
);
12184 locsymcount
= symtab_hdr
->sh_info
;
12185 end_lgot_ents
= lgot_ents
+ locsymcount
;
12186 local_plt
= (struct plt_entry
**) end_lgot_ents
;
12187 end_local_plt
= local_plt
+ locsymcount
;
12188 lgot_masks
= (unsigned char *) end_local_plt
;
12189 s
= ppc64_elf_tdata (ibfd
)->got
;
12190 for (; lgot_ents
< end_lgot_ents
; ++lgot_ents
, ++lgot_masks
)
12192 struct got_entry
*ent
;
12194 for (ent
= *lgot_ents
; ent
!= NULL
; ent
= ent
->next
)
12196 unsigned int ent_size
= 8;
12197 unsigned int rel_size
= sizeof (Elf64_External_Rela
);
12199 ent
->got
.offset
= s
->size
;
12200 if ((ent
->tls_type
& *lgot_masks
& TLS_GD
) != 0)
12205 s
->size
+= ent_size
;
12206 if ((*lgot_masks
& (TLS_TLS
| PLT_IFUNC
)) == PLT_IFUNC
)
12208 htab
->elf
.irelplt
->size
+= rel_size
;
12209 htab
->got_reli_size
+= rel_size
;
12211 else if (bfd_link_pic (info
)
12212 && !(ent
->tls_type
!= 0
12213 && bfd_link_executable (info
)))
12215 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
12216 srel
->size
+= rel_size
;
12222 elf_link_hash_traverse (&htab
->elf
, reallocate_got
, info
);
12224 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12226 struct got_entry
*ent
;
12228 if (!is_ppc64_elf (ibfd
))
12231 ent
= ppc64_tlsld_got (ibfd
);
12232 if (!ent
->is_indirect
12233 && ent
->got
.offset
!= (bfd_vma
) -1)
12235 asection
*s
= ppc64_elf_tdata (ibfd
)->got
;
12236 ent
->got
.offset
= s
->size
;
12238 if (bfd_link_dll (info
))
12240 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
12241 srel
->size
+= sizeof (Elf64_External_Rela
);
12246 done_something
= htab
->elf
.irelplt
->rawsize
!= htab
->elf
.irelplt
->size
;
12247 if (!done_something
)
12248 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12252 if (!is_ppc64_elf (ibfd
))
12255 got
= ppc64_elf_tdata (ibfd
)->got
;
12258 done_something
= got
->rawsize
!= got
->size
;
12259 if (done_something
)
12264 if (done_something
)
12265 (*htab
->params
->layout_sections_again
) ();
12267 /* Set up for second pass over toc sections to recalculate elf_gp
12268 on input sections. */
12269 htab
->toc_bfd
= NULL
;
12270 htab
->toc_first_sec
= NULL
;
12271 htab
->second_toc_pass
= TRUE
;
12272 return done_something
;
12275 /* Called after second pass of multitoc partitioning. */
12278 ppc64_elf_finish_multitoc_partition (struct bfd_link_info
*info
)
12280 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12282 /* After the second pass, toc_curr tracks the TOC offset used
12283 for code sections below in ppc64_elf_next_input_section. */
12284 htab
->toc_curr
= TOC_BASE_OFF
;
12287 /* No toc references were found in ISEC. If the code in ISEC makes no
12288 calls, then there's no need to use toc adjusting stubs when branching
12289 into ISEC. Actually, indirect calls from ISEC are OK as they will
12290 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
12291 needed, and 2 if a cyclical call-graph was found but no other reason
12292 for a stub was detected. If called from the top level, a return of
12293 2 means the same as a return of 0. */
12296 toc_adjusting_stub_needed (struct bfd_link_info
*info
, asection
*isec
)
12300 /* Mark this section as checked. */
12301 isec
->call_check_done
= 1;
12303 /* We know none of our code bearing sections will need toc stubs. */
12304 if ((isec
->flags
& SEC_LINKER_CREATED
) != 0)
12307 if (isec
->size
== 0)
12310 if (isec
->output_section
== NULL
)
12314 if (isec
->reloc_count
!= 0)
12316 Elf_Internal_Rela
*relstart
, *rel
;
12317 Elf_Internal_Sym
*local_syms
;
12318 struct ppc_link_hash_table
*htab
;
12320 relstart
= _bfd_elf_link_read_relocs (isec
->owner
, isec
, NULL
, NULL
,
12321 info
->keep_memory
);
12322 if (relstart
== NULL
)
12325 /* Look for branches to outside of this section. */
12327 htab
= ppc_hash_table (info
);
12331 for (rel
= relstart
; rel
< relstart
+ isec
->reloc_count
; ++rel
)
12333 enum elf_ppc64_reloc_type r_type
;
12334 unsigned long r_symndx
;
12335 struct elf_link_hash_entry
*h
;
12336 struct ppc_link_hash_entry
*eh
;
12337 Elf_Internal_Sym
*sym
;
12339 struct _opd_sec_data
*opd
;
12343 r_type
= ELF64_R_TYPE (rel
->r_info
);
12344 if (r_type
!= R_PPC64_REL24
12345 && r_type
!= R_PPC64_REL24_NOTOC
12346 && r_type
!= R_PPC64_REL14
12347 && r_type
!= R_PPC64_REL14_BRTAKEN
12348 && r_type
!= R_PPC64_REL14_BRNTAKEN
12349 && r_type
!= R_PPC64_PLTCALL
12350 && r_type
!= R_PPC64_PLTCALL_NOTOC
)
12353 r_symndx
= ELF64_R_SYM (rel
->r_info
);
12354 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
, r_symndx
,
12361 /* Calls to dynamic lib functions go through a plt call stub
12363 eh
= (struct ppc_link_hash_entry
*) h
;
12365 && (eh
->elf
.plt
.plist
!= NULL
12367 && ppc_follow_link (eh
->oh
)->elf
.plt
.plist
!= NULL
)))
12373 if (sym_sec
== NULL
)
12374 /* Ignore other undefined symbols. */
12377 /* Assume branches to other sections not included in the
12378 link need stubs too, to cover -R and absolute syms. */
12379 if (sym_sec
->output_section
== NULL
)
12386 sym_value
= sym
->st_value
;
12389 if (h
->root
.type
!= bfd_link_hash_defined
12390 && h
->root
.type
!= bfd_link_hash_defweak
)
12392 sym_value
= h
->root
.u
.def
.value
;
12394 sym_value
+= rel
->r_addend
;
12396 /* If this branch reloc uses an opd sym, find the code section. */
12397 opd
= get_opd_info (sym_sec
);
12400 if (h
== NULL
&& opd
->adjust
!= NULL
)
12404 adjust
= opd
->adjust
[OPD_NDX (sym_value
)];
12406 /* Assume deleted functions won't ever be called. */
12408 sym_value
+= adjust
;
12411 dest
= opd_entry_value (sym_sec
, sym_value
,
12412 &sym_sec
, NULL
, FALSE
);
12413 if (dest
== (bfd_vma
) -1)
12418 + sym_sec
->output_offset
12419 + sym_sec
->output_section
->vma
);
12421 /* Ignore branch to self. */
12422 if (sym_sec
== isec
)
12425 /* If the called function uses the toc, we need a stub. */
12426 if (sym_sec
->has_toc_reloc
12427 || sym_sec
->makes_toc_func_call
)
12433 /* Assume any branch that needs a long branch stub might in fact
12434 need a plt_branch stub. A plt_branch stub uses r2. */
12435 else if (dest
- (isec
->output_offset
12436 + isec
->output_section
->vma
12437 + rel
->r_offset
) + (1 << 25)
12438 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
12446 /* If calling back to a section in the process of being
12447 tested, we can't say for sure that no toc adjusting stubs
12448 are needed, so don't return zero. */
12449 else if (sym_sec
->call_check_in_progress
)
12452 /* Branches to another section that itself doesn't have any TOC
12453 references are OK. Recursively call ourselves to check. */
12454 else if (!sym_sec
->call_check_done
)
12458 /* Mark current section as indeterminate, so that other
12459 sections that call back to current won't be marked as
12461 isec
->call_check_in_progress
= 1;
12462 recur
= toc_adjusting_stub_needed (info
, sym_sec
);
12463 isec
->call_check_in_progress
= 0;
12474 if (local_syms
!= NULL
12475 && (elf_symtab_hdr (isec
->owner
).contents
12476 != (unsigned char *) local_syms
))
12478 if (elf_section_data (isec
)->relocs
!= relstart
)
12483 && isec
->map_head
.s
!= NULL
12484 && (strcmp (isec
->output_section
->name
, ".init") == 0
12485 || strcmp (isec
->output_section
->name
, ".fini") == 0))
12487 if (isec
->map_head
.s
->has_toc_reloc
12488 || isec
->map_head
.s
->makes_toc_func_call
)
12490 else if (!isec
->map_head
.s
->call_check_done
)
12493 isec
->call_check_in_progress
= 1;
12494 recur
= toc_adjusting_stub_needed (info
, isec
->map_head
.s
);
12495 isec
->call_check_in_progress
= 0;
12502 isec
->makes_toc_func_call
= 1;
12507 /* The linker repeatedly calls this function for each input section,
12508 in the order that input sections are linked into output sections.
12509 Build lists of input sections to determine groupings between which
12510 we may insert linker stubs. */
12513 ppc64_elf_next_input_section (struct bfd_link_info
*info
, asection
*isec
)
12515 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12520 if ((isec
->output_section
->flags
& SEC_CODE
) != 0
12521 && isec
->output_section
->id
< htab
->sec_info_arr_size
)
12523 /* This happens to make the list in reverse order,
12524 which is what we want. */
12525 htab
->sec_info
[isec
->id
].u
.list
12526 = htab
->sec_info
[isec
->output_section
->id
].u
.list
;
12527 htab
->sec_info
[isec
->output_section
->id
].u
.list
= isec
;
12530 if (htab
->multi_toc_needed
)
12532 /* Analyse sections that aren't already flagged as needing a
12533 valid toc pointer. Exclude .fixup for the linux kernel.
12534 .fixup contains branches, but only back to the function that
12535 hit an exception. */
12536 if (!(isec
->has_toc_reloc
12537 || (isec
->flags
& SEC_CODE
) == 0
12538 || strcmp (isec
->name
, ".fixup") == 0
12539 || isec
->call_check_done
))
12541 if (toc_adjusting_stub_needed (info
, isec
) < 0)
12544 /* Make all sections use the TOC assigned for this object file.
12545 This will be wrong for pasted sections; We fix that in
12546 check_pasted_section(). */
12547 if (elf_gp (isec
->owner
) != 0)
12548 htab
->toc_curr
= elf_gp (isec
->owner
);
12551 htab
->sec_info
[isec
->id
].toc_off
= htab
->toc_curr
;
12555 /* Check that all .init and .fini sections use the same toc, if they
12556 have toc relocs. */
12559 check_pasted_section (struct bfd_link_info
*info
, const char *name
)
12561 asection
*o
= bfd_get_section_by_name (info
->output_bfd
, name
);
12565 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12566 bfd_vma toc_off
= 0;
12569 for (i
= o
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
12570 if (i
->has_toc_reloc
)
12573 toc_off
= htab
->sec_info
[i
->id
].toc_off
;
12574 else if (toc_off
!= htab
->sec_info
[i
->id
].toc_off
)
12579 for (i
= o
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
12580 if (i
->makes_toc_func_call
)
12582 toc_off
= htab
->sec_info
[i
->id
].toc_off
;
12586 /* Make sure the whole pasted function uses the same toc offset. */
12588 for (i
= o
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
12589 htab
->sec_info
[i
->id
].toc_off
= toc_off
;
12595 ppc64_elf_check_init_fini (struct bfd_link_info
*info
)
12597 return (check_pasted_section (info
, ".init")
12598 & check_pasted_section (info
, ".fini"));
12601 /* See whether we can group stub sections together. Grouping stub
12602 sections may result in fewer stubs. More importantly, we need to
12603 put all .init* and .fini* stubs at the beginning of the .init or
12604 .fini output sections respectively, because glibc splits the
12605 _init and _fini functions into multiple parts. Putting a stub in
12606 the middle of a function is not a good idea. */
12609 group_sections (struct bfd_link_info
*info
,
12610 bfd_size_type stub_group_size
,
12611 bfd_boolean stubs_always_before_branch
)
12613 struct ppc_link_hash_table
*htab
;
12615 bfd_boolean suppress_size_errors
;
12617 htab
= ppc_hash_table (info
);
12621 suppress_size_errors
= FALSE
;
12622 if (stub_group_size
== 1)
12624 /* Default values. */
12625 if (stubs_always_before_branch
)
12626 stub_group_size
= 0x1e00000;
12628 stub_group_size
= 0x1c00000;
12629 suppress_size_errors
= TRUE
;
12632 for (osec
= info
->output_bfd
->sections
; osec
!= NULL
; osec
= osec
->next
)
12636 if (osec
->id
>= htab
->sec_info_arr_size
)
12639 tail
= htab
->sec_info
[osec
->id
].u
.list
;
12640 while (tail
!= NULL
)
12644 bfd_size_type total
;
12645 bfd_boolean big_sec
;
12647 struct map_stub
*group
;
12648 bfd_size_type group_size
;
12651 total
= tail
->size
;
12652 group_size
= (ppc64_elf_section_data (tail
) != NULL
12653 && ppc64_elf_section_data (tail
)->has_14bit_branch
12654 ? stub_group_size
>> 10 : stub_group_size
);
12656 big_sec
= total
> group_size
;
12657 if (big_sec
&& !suppress_size_errors
)
12658 /* xgettext:c-format */
12659 _bfd_error_handler (_("%pB section %pA exceeds stub group size"),
12660 tail
->owner
, tail
);
12661 curr_toc
= htab
->sec_info
[tail
->id
].toc_off
;
12663 while ((prev
= htab
->sec_info
[curr
->id
].u
.list
) != NULL
12664 && ((total
+= curr
->output_offset
- prev
->output_offset
)
12665 < (ppc64_elf_section_data (prev
) != NULL
12666 && ppc64_elf_section_data (prev
)->has_14bit_branch
12667 ? (group_size
= stub_group_size
>> 10) : group_size
))
12668 && htab
->sec_info
[prev
->id
].toc_off
== curr_toc
)
12671 /* OK, the size from the start of CURR to the end is less
12672 than group_size and thus can be handled by one stub
12673 section. (or the tail section is itself larger than
12674 group_size, in which case we may be toast.) We should
12675 really be keeping track of the total size of stubs added
12676 here, as stubs contribute to the final output section
12677 size. That's a little tricky, and this way will only
12678 break if stubs added make the total size more than 2^25,
12679 ie. for the default stub_group_size, if stubs total more
12680 than 2097152 bytes, or nearly 75000 plt call stubs. */
12681 group
= bfd_alloc (curr
->owner
, sizeof (*group
));
12684 group
->link_sec
= curr
;
12685 group
->stub_sec
= NULL
;
12686 group
->needs_save_res
= 0;
12687 group
->lr_restore
= 0;
12688 group
->eh_size
= 0;
12689 group
->eh_base
= 0;
12690 group
->next
= htab
->group
;
12691 htab
->group
= group
;
12694 prev
= htab
->sec_info
[tail
->id
].u
.list
;
12695 /* Set up this stub group. */
12696 htab
->sec_info
[tail
->id
].u
.group
= group
;
12698 while (tail
!= curr
&& (tail
= prev
) != NULL
);
12700 /* But wait, there's more! Input sections up to group_size
12701 bytes before the stub section can be handled by it too.
12702 Don't do this if we have a really large section after the
12703 stubs, as adding more stubs increases the chance that
12704 branches may not reach into the stub section. */
12705 if (!stubs_always_before_branch
&& !big_sec
)
12708 while (prev
!= NULL
12709 && ((total
+= tail
->output_offset
- prev
->output_offset
)
12710 < (ppc64_elf_section_data (prev
) != NULL
12711 && ppc64_elf_section_data (prev
)->has_14bit_branch
12712 ? (group_size
= stub_group_size
>> 10)
12714 && htab
->sec_info
[prev
->id
].toc_off
== curr_toc
)
12717 prev
= htab
->sec_info
[tail
->id
].u
.list
;
12718 htab
->sec_info
[tail
->id
].u
.group
= group
;
12727 static const unsigned char glink_eh_frame_cie
[] =
12729 0, 0, 0, 16, /* length. */
12730 0, 0, 0, 0, /* id. */
12731 1, /* CIE version. */
12732 'z', 'R', 0, /* Augmentation string. */
12733 4, /* Code alignment. */
12734 0x78, /* Data alignment. */
12736 1, /* Augmentation size. */
12737 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding. */
12738 DW_CFA_def_cfa
, 1, 0 /* def_cfa: r1 offset 0. */
12741 /* Stripping output sections is normally done before dynamic section
12742 symbols have been allocated. This function is called later, and
12743 handles cases like htab->brlt which is mapped to its own output
12747 maybe_strip_output (struct bfd_link_info
*info
, asection
*isec
)
12749 if (isec
->size
== 0
12750 && isec
->output_section
->size
== 0
12751 && !(isec
->output_section
->flags
& SEC_KEEP
)
12752 && !bfd_section_removed_from_list (info
->output_bfd
,
12753 isec
->output_section
)
12754 && elf_section_data (isec
->output_section
)->dynindx
== 0)
12756 isec
->output_section
->flags
|= SEC_EXCLUDE
;
12757 bfd_section_list_remove (info
->output_bfd
, isec
->output_section
);
12758 info
->output_bfd
->section_count
--;
12762 /* Determine and set the size of the stub section for a final link.
12764 The basic idea here is to examine all the relocations looking for
12765 PC-relative calls to a target that is unreachable with a "bl"
12769 ppc64_elf_size_stubs (struct bfd_link_info
*info
)
12771 bfd_size_type stub_group_size
;
12772 bfd_boolean stubs_always_before_branch
;
12773 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12778 if (htab
->params
->plt_thread_safe
== -1 && !bfd_link_executable (info
))
12779 htab
->params
->plt_thread_safe
= 1;
12780 if (!htab
->opd_abi
)
12781 htab
->params
->plt_thread_safe
= 0;
12782 else if (htab
->params
->plt_thread_safe
== -1)
12784 static const char *const thread_starter
[] =
12788 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12790 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12791 "mq_notify", "create_timer",
12796 "GOMP_parallel_start",
12797 "GOMP_parallel_loop_static",
12798 "GOMP_parallel_loop_static_start",
12799 "GOMP_parallel_loop_dynamic",
12800 "GOMP_parallel_loop_dynamic_start",
12801 "GOMP_parallel_loop_guided",
12802 "GOMP_parallel_loop_guided_start",
12803 "GOMP_parallel_loop_runtime",
12804 "GOMP_parallel_loop_runtime_start",
12805 "GOMP_parallel_sections",
12806 "GOMP_parallel_sections_start",
12812 for (i
= 0; i
< ARRAY_SIZE (thread_starter
); i
++)
12814 struct elf_link_hash_entry
*h
;
12815 h
= elf_link_hash_lookup (&htab
->elf
, thread_starter
[i
],
12816 FALSE
, FALSE
, TRUE
);
12817 htab
->params
->plt_thread_safe
= h
!= NULL
&& h
->ref_regular
;
12818 if (htab
->params
->plt_thread_safe
)
12822 stubs_always_before_branch
= htab
->params
->group_size
< 0;
12823 if (htab
->params
->group_size
< 0)
12824 stub_group_size
= -htab
->params
->group_size
;
12826 stub_group_size
= htab
->params
->group_size
;
12828 if (!group_sections (info
, stub_group_size
, stubs_always_before_branch
))
12831 #define STUB_SHRINK_ITER 20
12832 /* Loop until no stubs added. After iteration 20 of this loop we may
12833 exit on a stub section shrinking. This is to break out of a
12834 pathological case where adding stubs on one iteration decreases
12835 section gaps (perhaps due to alignment), which then requires
12836 fewer or smaller stubs on the next iteration. */
12841 unsigned int bfd_indx
;
12842 struct map_stub
*group
;
12844 htab
->stub_iteration
+= 1;
12846 for (input_bfd
= info
->input_bfds
, bfd_indx
= 0;
12848 input_bfd
= input_bfd
->link
.next
, bfd_indx
++)
12850 Elf_Internal_Shdr
*symtab_hdr
;
12852 Elf_Internal_Sym
*local_syms
= NULL
;
12854 if (!is_ppc64_elf (input_bfd
))
12857 /* We'll need the symbol table in a second. */
12858 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
12859 if (symtab_hdr
->sh_info
== 0)
12862 /* Walk over each section attached to the input bfd. */
12863 for (section
= input_bfd
->sections
;
12865 section
= section
->next
)
12867 Elf_Internal_Rela
*internal_relocs
, *irelaend
, *irela
;
12869 /* If there aren't any relocs, then there's nothing more
12871 if ((section
->flags
& SEC_RELOC
) == 0
12872 || (section
->flags
& SEC_ALLOC
) == 0
12873 || (section
->flags
& SEC_LOAD
) == 0
12874 || (section
->flags
& SEC_CODE
) == 0
12875 || section
->reloc_count
== 0)
12878 /* If this section is a link-once section that will be
12879 discarded, then don't create any stubs. */
12880 if (section
->output_section
== NULL
12881 || section
->output_section
->owner
!= info
->output_bfd
)
12884 /* Get the relocs. */
12886 = _bfd_elf_link_read_relocs (input_bfd
, section
, NULL
, NULL
,
12887 info
->keep_memory
);
12888 if (internal_relocs
== NULL
)
12889 goto error_ret_free_local
;
12891 /* Now examine each relocation. */
12892 irela
= internal_relocs
;
12893 irelaend
= irela
+ section
->reloc_count
;
12894 for (; irela
< irelaend
; irela
++)
12896 enum elf_ppc64_reloc_type r_type
;
12897 unsigned int r_indx
;
12898 enum ppc_stub_type stub_type
;
12899 struct ppc_stub_hash_entry
*stub_entry
;
12900 asection
*sym_sec
, *code_sec
;
12901 bfd_vma sym_value
, code_value
;
12902 bfd_vma destination
;
12903 unsigned long local_off
;
12904 bfd_boolean ok_dest
;
12905 struct ppc_link_hash_entry
*hash
;
12906 struct ppc_link_hash_entry
*fdh
;
12907 struct elf_link_hash_entry
*h
;
12908 Elf_Internal_Sym
*sym
;
12910 const asection
*id_sec
;
12911 struct _opd_sec_data
*opd
;
12912 struct plt_entry
*plt_ent
;
12914 r_type
= ELF64_R_TYPE (irela
->r_info
);
12915 r_indx
= ELF64_R_SYM (irela
->r_info
);
12917 if (r_type
>= R_PPC64_max
)
12919 bfd_set_error (bfd_error_bad_value
);
12920 goto error_ret_free_internal
;
12923 /* Only look for stubs on branch instructions. */
12924 if (r_type
!= R_PPC64_REL24
12925 && r_type
!= R_PPC64_REL24_NOTOC
12926 && r_type
!= R_PPC64_REL14
12927 && r_type
!= R_PPC64_REL14_BRTAKEN
12928 && r_type
!= R_PPC64_REL14_BRNTAKEN
)
12931 /* Now determine the call target, its name, value,
12933 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
12934 r_indx
, input_bfd
))
12935 goto error_ret_free_internal
;
12936 hash
= (struct ppc_link_hash_entry
*) h
;
12943 sym_value
= sym
->st_value
;
12944 if (sym_sec
!= NULL
12945 && sym_sec
->output_section
!= NULL
)
12948 else if (hash
->elf
.root
.type
== bfd_link_hash_defined
12949 || hash
->elf
.root
.type
== bfd_link_hash_defweak
)
12951 sym_value
= hash
->elf
.root
.u
.def
.value
;
12952 if (sym_sec
->output_section
!= NULL
)
12955 else if (hash
->elf
.root
.type
== bfd_link_hash_undefweak
12956 || hash
->elf
.root
.type
== bfd_link_hash_undefined
)
12958 /* Recognise an old ABI func code entry sym, and
12959 use the func descriptor sym instead if it is
12961 if (hash
->elf
.root
.root
.string
[0] == '.'
12962 && hash
->oh
!= NULL
)
12964 fdh
= ppc_follow_link (hash
->oh
);
12965 if (fdh
->elf
.root
.type
== bfd_link_hash_defined
12966 || fdh
->elf
.root
.type
== bfd_link_hash_defweak
)
12968 sym_sec
= fdh
->elf
.root
.u
.def
.section
;
12969 sym_value
= fdh
->elf
.root
.u
.def
.value
;
12970 if (sym_sec
->output_section
!= NULL
)
12979 bfd_set_error (bfd_error_bad_value
);
12980 goto error_ret_free_internal
;
12987 sym_value
+= irela
->r_addend
;
12988 destination
= (sym_value
12989 + sym_sec
->output_offset
12990 + sym_sec
->output_section
->vma
);
12991 local_off
= PPC64_LOCAL_ENTRY_OFFSET (hash
12996 code_sec
= sym_sec
;
12997 code_value
= sym_value
;
12998 opd
= get_opd_info (sym_sec
);
13003 if (hash
== NULL
&& opd
->adjust
!= NULL
)
13005 long adjust
= opd
->adjust
[OPD_NDX (sym_value
)];
13008 code_value
+= adjust
;
13009 sym_value
+= adjust
;
13011 dest
= opd_entry_value (sym_sec
, sym_value
,
13012 &code_sec
, &code_value
, FALSE
);
13013 if (dest
!= (bfd_vma
) -1)
13015 destination
= dest
;
13018 /* Fixup old ABI sym to point at code
13020 hash
->elf
.root
.type
= bfd_link_hash_defweak
;
13021 hash
->elf
.root
.u
.def
.section
= code_sec
;
13022 hash
->elf
.root
.u
.def
.value
= code_value
;
13027 /* Determine what (if any) linker stub is needed. */
13029 stub_type
= ppc_type_of_stub (section
, irela
, &hash
,
13030 &plt_ent
, destination
,
13033 if (r_type
== R_PPC64_REL24_NOTOC
)
13035 if (stub_type
== ppc_stub_plt_call
)
13036 stub_type
= ppc_stub_plt_call_notoc
;
13037 else if (stub_type
== ppc_stub_long_branch
13038 || (code_sec
!= NULL
13039 && code_sec
->output_section
!= NULL
13040 && (((hash
? hash
->elf
.other
: sym
->st_other
)
13041 & STO_PPC64_LOCAL_MASK
)
13042 > 1 << STO_PPC64_LOCAL_BIT
)))
13043 stub_type
= ppc_stub_long_branch_notoc
;
13045 else if (stub_type
!= ppc_stub_plt_call
)
13047 /* Check whether we need a TOC adjusting stub.
13048 Since the linker pastes together pieces from
13049 different object files when creating the
13050 _init and _fini functions, it may be that a
13051 call to what looks like a local sym is in
13052 fact a call needing a TOC adjustment. */
13053 if ((code_sec
!= NULL
13054 && code_sec
->output_section
!= NULL
13055 && (htab
->sec_info
[code_sec
->id
].toc_off
13056 != htab
->sec_info
[section
->id
].toc_off
)
13057 && (code_sec
->has_toc_reloc
13058 || code_sec
->makes_toc_func_call
))
13059 || (((hash
? hash
->elf
.other
: sym
->st_other
)
13060 & STO_PPC64_LOCAL_MASK
)
13061 == 1 << STO_PPC64_LOCAL_BIT
))
13062 stub_type
= ppc_stub_long_branch_r2off
;
13065 if (stub_type
== ppc_stub_none
)
13068 /* __tls_get_addr calls might be eliminated. */
13069 if (stub_type
!= ppc_stub_plt_call
13070 && stub_type
!= ppc_stub_plt_call_notoc
13072 && (hash
== htab
->tls_get_addr
13073 || hash
== htab
->tls_get_addr_fd
)
13074 && section
->has_tls_reloc
13075 && irela
!= internal_relocs
)
13077 /* Get tls info. */
13078 unsigned char *tls_mask
;
13080 if (!get_tls_mask (&tls_mask
, NULL
, NULL
, &local_syms
,
13081 irela
- 1, input_bfd
))
13082 goto error_ret_free_internal
;
13083 if ((*tls_mask
& TLS_TLS
) != 0)
13087 if (stub_type
== ppc_stub_plt_call
)
13090 && htab
->params
->plt_localentry0
!= 0
13091 && is_elfv2_localentry0 (&hash
->elf
))
13092 htab
->has_plt_localentry0
= 1;
13093 else if (irela
+ 1 < irelaend
13094 && irela
[1].r_offset
== irela
->r_offset
+ 4
13095 && (ELF64_R_TYPE (irela
[1].r_info
)
13096 == R_PPC64_TOCSAVE
))
13098 if (!tocsave_find (htab
, INSERT
,
13099 &local_syms
, irela
+ 1, input_bfd
))
13100 goto error_ret_free_internal
;
13103 stub_type
= ppc_stub_plt_call_r2save
;
13106 /* Support for grouping stub sections. */
13107 id_sec
= htab
->sec_info
[section
->id
].u
.group
->link_sec
;
13109 /* Get the name of this stub. */
13110 stub_name
= ppc_stub_name (id_sec
, sym_sec
, hash
, irela
);
13112 goto error_ret_free_internal
;
13114 stub_entry
= ppc_stub_hash_lookup (&htab
->stub_hash_table
,
13115 stub_name
, FALSE
, FALSE
);
13116 if (stub_entry
!= NULL
)
13118 enum ppc_stub_type old_type
;
13119 /* A stub has already been created, but it may
13120 not be the required type. We shouldn't be
13121 transitioning from plt_call to long_branch
13122 stubs or vice versa, but we might be
13123 upgrading from plt_call to plt_call_r2save or
13124 from long_branch to long_branch_r2off. */
13126 old_type
= stub_entry
->stub_type
;
13132 case ppc_stub_save_res
:
13135 case ppc_stub_plt_call
:
13136 case ppc_stub_plt_call_r2save
:
13137 case ppc_stub_plt_call_notoc
:
13138 case ppc_stub_plt_call_both
:
13139 if (stub_type
== ppc_stub_plt_call
)
13141 else if (stub_type
== ppc_stub_plt_call_r2save
)
13143 if (old_type
== ppc_stub_plt_call_notoc
)
13144 stub_type
= ppc_stub_plt_call_both
;
13146 else if (stub_type
== ppc_stub_plt_call_notoc
)
13148 if (old_type
== ppc_stub_plt_call_r2save
)
13149 stub_type
= ppc_stub_plt_call_both
;
13155 case ppc_stub_plt_branch
:
13156 case ppc_stub_plt_branch_r2off
:
13157 case ppc_stub_plt_branch_notoc
:
13158 case ppc_stub_plt_branch_both
:
13159 old_type
+= (ppc_stub_long_branch
13160 - ppc_stub_plt_branch
);
13161 /* Fall through. */
13162 case ppc_stub_long_branch
:
13163 case ppc_stub_long_branch_r2off
:
13164 case ppc_stub_long_branch_notoc
:
13165 case ppc_stub_long_branch_both
:
13166 if (stub_type
== ppc_stub_long_branch
)
13168 else if (stub_type
== ppc_stub_long_branch_r2off
)
13170 if (old_type
== ppc_stub_long_branch_notoc
)
13171 stub_type
= ppc_stub_long_branch_both
;
13173 else if (stub_type
== ppc_stub_long_branch_notoc
)
13175 if (old_type
== ppc_stub_long_branch_r2off
)
13176 stub_type
= ppc_stub_long_branch_both
;
13182 if (old_type
< stub_type
)
13183 stub_entry
->stub_type
= stub_type
;
13187 stub_entry
= ppc_add_stub (stub_name
, section
, info
);
13188 if (stub_entry
== NULL
)
13191 error_ret_free_internal
:
13192 if (elf_section_data (section
)->relocs
== NULL
)
13193 free (internal_relocs
);
13194 error_ret_free_local
:
13195 if (local_syms
!= NULL
13196 && (symtab_hdr
->contents
13197 != (unsigned char *) local_syms
))
13202 stub_entry
->stub_type
= stub_type
;
13203 if (stub_type
>= ppc_stub_plt_call
13204 && stub_type
<= ppc_stub_plt_call_both
)
13206 stub_entry
->target_value
= sym_value
;
13207 stub_entry
->target_section
= sym_sec
;
13211 stub_entry
->target_value
= code_value
;
13212 stub_entry
->target_section
= code_sec
;
13214 stub_entry
->h
= hash
;
13215 stub_entry
->plt_ent
= plt_ent
;
13216 stub_entry
->symtype
13217 = hash
? hash
->elf
.type
: ELF_ST_TYPE (sym
->st_info
);
13218 stub_entry
->other
= hash
? hash
->elf
.other
: sym
->st_other
;
13221 && (hash
->elf
.root
.type
== bfd_link_hash_defined
13222 || hash
->elf
.root
.type
== bfd_link_hash_defweak
))
13223 htab
->stub_globals
+= 1;
13226 /* We're done with the internal relocs, free them. */
13227 if (elf_section_data (section
)->relocs
!= internal_relocs
)
13228 free (internal_relocs
);
13231 if (local_syms
!= NULL
13232 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
13234 if (!info
->keep_memory
)
13237 symtab_hdr
->contents
= (unsigned char *) local_syms
;
13241 /* We may have added some stubs. Find out the new size of the
13243 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13245 group
->lr_restore
= 0;
13246 group
->eh_size
= 0;
13247 if (group
->stub_sec
!= NULL
)
13249 asection
*stub_sec
= group
->stub_sec
;
13251 if (htab
->stub_iteration
<= STUB_SHRINK_ITER
13252 || stub_sec
->rawsize
< stub_sec
->size
)
13253 /* Past STUB_SHRINK_ITER, rawsize is the max size seen. */
13254 stub_sec
->rawsize
= stub_sec
->size
;
13255 stub_sec
->size
= 0;
13256 stub_sec
->reloc_count
= 0;
13257 stub_sec
->flags
&= ~SEC_RELOC
;
13261 if (htab
->stub_iteration
<= STUB_SHRINK_ITER
13262 || htab
->brlt
->rawsize
< htab
->brlt
->size
)
13263 htab
->brlt
->rawsize
= htab
->brlt
->size
;
13264 htab
->brlt
->size
= 0;
13265 htab
->brlt
->reloc_count
= 0;
13266 htab
->brlt
->flags
&= ~SEC_RELOC
;
13267 if (htab
->relbrlt
!= NULL
)
13268 htab
->relbrlt
->size
= 0;
13270 bfd_hash_traverse (&htab
->stub_hash_table
, ppc_size_one_stub
, info
);
13272 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13273 if (group
->needs_save_res
)
13274 group
->stub_sec
->size
+= htab
->sfpr
->size
;
13276 if (info
->emitrelocations
13277 && htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
13279 htab
->glink
->reloc_count
= 1;
13280 htab
->glink
->flags
|= SEC_RELOC
;
13283 if (htab
->glink_eh_frame
!= NULL
13284 && !bfd_is_abs_section (htab
->glink_eh_frame
->output_section
)
13285 && htab
->glink_eh_frame
->output_section
->size
> 8)
13287 size_t size
= 0, align
= 4;
13289 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13290 if (group
->eh_size
!= 0)
13291 size
+= (group
->eh_size
+ 17 + align
- 1) & -align
;
13292 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
13293 size
+= (24 + align
- 1) & -align
;
13295 size
+= (sizeof (glink_eh_frame_cie
) + align
- 1) & -align
;
13296 align
= 1ul << htab
->glink_eh_frame
->output_section
->alignment_power
;
13297 size
= (size
+ align
- 1) & -align
;
13298 htab
->glink_eh_frame
->rawsize
= htab
->glink_eh_frame
->size
;
13299 htab
->glink_eh_frame
->size
= size
;
13302 if (htab
->params
->plt_stub_align
!= 0)
13303 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13304 if (group
->stub_sec
!= NULL
)
13306 int align
= abs (htab
->params
->plt_stub_align
);
13307 group
->stub_sec
->size
13308 = (group
->stub_sec
->size
+ (1 << align
) - 1) & -(1 << align
);
13311 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13312 if (group
->stub_sec
!= NULL
13313 && group
->stub_sec
->rawsize
!= group
->stub_sec
->size
13314 && (htab
->stub_iteration
<= STUB_SHRINK_ITER
13315 || group
->stub_sec
->rawsize
< group
->stub_sec
->size
))
13319 && (htab
->brlt
->rawsize
== htab
->brlt
->size
13320 || (htab
->stub_iteration
> STUB_SHRINK_ITER
13321 && htab
->brlt
->rawsize
> htab
->brlt
->size
))
13322 && (htab
->glink_eh_frame
== NULL
13323 || htab
->glink_eh_frame
->rawsize
== htab
->glink_eh_frame
->size
))
13326 /* Ask the linker to do its stuff. */
13327 (*htab
->params
->layout_sections_again
) ();
13330 if (htab
->glink_eh_frame
!= NULL
13331 && htab
->glink_eh_frame
->size
!= 0)
13334 bfd_byte
*p
, *last_fde
;
13335 size_t last_fde_len
, size
, align
, pad
;
13336 struct map_stub
*group
;
13338 /* It is necessary to at least have a rough outline of the
13339 linker generated CIEs and FDEs written before
13340 bfd_elf_discard_info is run, in order for these FDEs to be
13341 indexed in .eh_frame_hdr. */
13342 p
= bfd_zalloc (htab
->glink_eh_frame
->owner
, htab
->glink_eh_frame
->size
);
13345 htab
->glink_eh_frame
->contents
= p
;
13349 memcpy (p
, glink_eh_frame_cie
, sizeof (glink_eh_frame_cie
));
13350 /* CIE length (rewrite in case little-endian). */
13351 last_fde_len
= ((sizeof (glink_eh_frame_cie
) + align
- 1) & -align
) - 4;
13352 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
, p
);
13353 p
+= last_fde_len
+ 4;
13355 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13356 if (group
->eh_size
!= 0)
13358 group
->eh_base
= p
- htab
->glink_eh_frame
->contents
;
13360 last_fde_len
= ((group
->eh_size
+ 17 + align
- 1) & -align
) - 4;
13362 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
, p
);
13365 val
= p
- htab
->glink_eh_frame
->contents
;
13366 bfd_put_32 (htab
->elf
.dynobj
, val
, p
);
13368 /* Offset to stub section, written later. */
13370 /* stub section size. */
13371 bfd_put_32 (htab
->elf
.dynobj
, group
->stub_sec
->size
, p
);
13373 /* Augmentation. */
13375 /* Make sure we don't have all nops. This is enough for
13376 elf-eh-frame.c to detect the last non-nop opcode. */
13377 p
[group
->eh_size
- 1] = DW_CFA_advance_loc
+ 1;
13378 p
= last_fde
+ last_fde_len
+ 4;
13380 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
13383 last_fde_len
= ((24 + align
- 1) & -align
) - 4;
13385 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
, p
);
13388 val
= p
- htab
->glink_eh_frame
->contents
;
13389 bfd_put_32 (htab
->elf
.dynobj
, val
, p
);
13391 /* Offset to .glink, written later. */
13394 bfd_put_32 (htab
->elf
.dynobj
, htab
->glink
->size
- 8, p
);
13396 /* Augmentation. */
13399 *p
++ = DW_CFA_advance_loc
+ 1;
13400 *p
++ = DW_CFA_register
;
13402 *p
++ = htab
->opd_abi
? 12 : 0;
13403 *p
++ = DW_CFA_advance_loc
+ (htab
->opd_abi
? 5 : 7);
13404 *p
++ = DW_CFA_restore_extended
;
13406 p
+= ((24 + align
- 1) & -align
) - 24;
13408 /* Subsume any padding into the last FDE if user .eh_frame
13409 sections are aligned more than glink_eh_frame. Otherwise any
13410 zero padding will be seen as a terminator. */
13411 align
= 1ul << htab
->glink_eh_frame
->output_section
->alignment_power
;
13412 size
= p
- htab
->glink_eh_frame
->contents
;
13413 pad
= ((size
+ align
- 1) & -align
) - size
;
13414 htab
->glink_eh_frame
->size
= size
+ pad
;
13415 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
+ pad
, last_fde
);
13418 maybe_strip_output (info
, htab
->brlt
);
13419 if (htab
->glink_eh_frame
!= NULL
)
13420 maybe_strip_output (info
, htab
->glink_eh_frame
);
13425 /* Called after we have determined section placement. If sections
13426 move, we'll be called again. Provide a value for TOCstart. */
13429 ppc64_elf_set_toc (struct bfd_link_info
*info
, bfd
*obfd
)
13432 bfd_vma TOCstart
, adjust
;
13436 struct elf_link_hash_entry
*h
;
13437 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
13439 if (is_elf_hash_table (htab
)
13440 && htab
->hgot
!= NULL
)
13444 h
= elf_link_hash_lookup (htab
, ".TOC.", FALSE
, FALSE
, TRUE
);
13445 if (is_elf_hash_table (htab
))
13449 && h
->root
.type
== bfd_link_hash_defined
13450 && !h
->root
.linker_def
13451 && (!is_elf_hash_table (htab
)
13452 || h
->def_regular
))
13454 TOCstart
= (h
->root
.u
.def
.value
- TOC_BASE_OFF
13455 + h
->root
.u
.def
.section
->output_offset
13456 + h
->root
.u
.def
.section
->output_section
->vma
);
13457 _bfd_set_gp_value (obfd
, TOCstart
);
13462 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
13463 order. The TOC starts where the first of these sections starts. */
13464 s
= bfd_get_section_by_name (obfd
, ".got");
13465 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13466 s
= bfd_get_section_by_name (obfd
, ".toc");
13467 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13468 s
= bfd_get_section_by_name (obfd
, ".tocbss");
13469 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13470 s
= bfd_get_section_by_name (obfd
, ".plt");
13471 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13473 /* This may happen for
13474 o references to TOC base (SYM@toc / TOC[tc0]) without a
13476 o bad linker script
13477 o --gc-sections and empty TOC sections
13479 FIXME: Warn user? */
13481 /* Look for a likely section. We probably won't even be
13483 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13484 if ((s
->flags
& (SEC_ALLOC
| SEC_SMALL_DATA
| SEC_READONLY
13486 == (SEC_ALLOC
| SEC_SMALL_DATA
))
13489 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13490 if ((s
->flags
& (SEC_ALLOC
| SEC_SMALL_DATA
| SEC_EXCLUDE
))
13491 == (SEC_ALLOC
| SEC_SMALL_DATA
))
13494 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13495 if ((s
->flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_EXCLUDE
))
13499 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13500 if ((s
->flags
& (SEC_ALLOC
| SEC_EXCLUDE
)) == SEC_ALLOC
)
13506 TOCstart
= s
->output_section
->vma
+ s
->output_offset
;
13508 /* Force alignment. */
13509 adjust
= TOCstart
& (TOC_BASE_ALIGN
- 1);
13510 TOCstart
-= adjust
;
13511 _bfd_set_gp_value (obfd
, TOCstart
);
13513 if (info
!= NULL
&& s
!= NULL
)
13515 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
13519 if (htab
->elf
.hgot
!= NULL
)
13521 htab
->elf
.hgot
->root
.u
.def
.value
= TOC_BASE_OFF
- adjust
;
13522 htab
->elf
.hgot
->root
.u
.def
.section
= s
;
13527 struct bfd_link_hash_entry
*bh
= NULL
;
13528 _bfd_generic_link_add_one_symbol (info
, obfd
, ".TOC.", BSF_GLOBAL
,
13529 s
, TOC_BASE_OFF
- adjust
,
13530 NULL
, FALSE
, FALSE
, &bh
);
13536 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
13537 write out any global entry stubs, and PLT relocations. */
13540 build_global_entry_stubs_and_plt (struct elf_link_hash_entry
*h
, void *inf
)
13542 struct bfd_link_info
*info
;
13543 struct ppc_link_hash_table
*htab
;
13544 struct plt_entry
*ent
;
13547 if (h
->root
.type
== bfd_link_hash_indirect
)
13551 htab
= ppc_hash_table (info
);
13555 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
13556 if (ent
->plt
.offset
!= (bfd_vma
) -1)
13558 /* This symbol has an entry in the procedure linkage
13559 table. Set it up. */
13560 Elf_Internal_Rela rela
;
13561 asection
*plt
, *relplt
;
13564 if (!htab
->elf
.dynamic_sections_created
13565 || h
->dynindx
== -1)
13567 if (!(h
->def_regular
13568 && (h
->root
.type
== bfd_link_hash_defined
13569 || h
->root
.type
== bfd_link_hash_defweak
)))
13571 if (h
->type
== STT_GNU_IFUNC
)
13573 plt
= htab
->elf
.iplt
;
13574 relplt
= htab
->elf
.irelplt
;
13575 htab
->local_ifunc_resolver
= 1;
13577 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_IREL
);
13579 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
13583 plt
= htab
->pltlocal
;
13584 if (bfd_link_pic (info
))
13586 relplt
= htab
->relpltlocal
;
13588 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_SLOT
);
13590 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
13595 rela
.r_addend
= (h
->root
.u
.def
.value
13596 + h
->root
.u
.def
.section
->output_offset
13597 + h
->root
.u
.def
.section
->output_section
->vma
13600 if (relplt
== NULL
)
13602 loc
= plt
->contents
+ ent
->plt
.offset
;
13603 bfd_put_64 (info
->output_bfd
, rela
.r_addend
, loc
);
13606 bfd_vma toc
= elf_gp (info
->output_bfd
);
13607 toc
+= htab
->sec_info
[h
->root
.u
.def
.section
->id
].toc_off
;
13608 bfd_put_64 (info
->output_bfd
, toc
, loc
+ 8);
13613 rela
.r_offset
= (plt
->output_section
->vma
13614 + plt
->output_offset
13615 + ent
->plt
.offset
);
13616 loc
= relplt
->contents
+ (relplt
->reloc_count
++
13617 * sizeof (Elf64_External_Rela
));
13618 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rela
, loc
);
13623 rela
.r_offset
= (htab
->elf
.splt
->output_section
->vma
13624 + htab
->elf
.splt
->output_offset
13625 + ent
->plt
.offset
);
13626 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_PPC64_JMP_SLOT
);
13627 rela
.r_addend
= ent
->addend
;
13628 loc
= (htab
->elf
.srelplt
->contents
13629 + ((ent
->plt
.offset
- PLT_INITIAL_ENTRY_SIZE (htab
))
13630 / PLT_ENTRY_SIZE (htab
) * sizeof (Elf64_External_Rela
)));
13631 if (h
->type
== STT_GNU_IFUNC
&& is_static_defined (h
))
13632 htab
->maybe_local_ifunc_resolver
= 1;
13633 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rela
, loc
);
13637 if (!h
->pointer_equality_needed
)
13640 if (h
->def_regular
)
13643 s
= htab
->global_entry
;
13644 if (s
== NULL
|| s
->size
== 0)
13647 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
13648 if (ent
->plt
.offset
!= (bfd_vma
) -1
13649 && ent
->addend
== 0)
13655 p
= s
->contents
+ h
->root
.u
.def
.value
;
13656 plt
= htab
->elf
.splt
;
13657 if (!htab
->elf
.dynamic_sections_created
13658 || h
->dynindx
== -1)
13660 if (h
->type
== STT_GNU_IFUNC
)
13661 plt
= htab
->elf
.iplt
;
13663 plt
= htab
->pltlocal
;
13665 off
= ent
->plt
.offset
+ plt
->output_offset
+ plt
->output_section
->vma
;
13666 off
-= h
->root
.u
.def
.value
+ s
->output_offset
+ s
->output_section
->vma
;
13668 if (off
+ 0x80008000 > 0xffffffff || (off
& 3) != 0)
13670 info
->callbacks
->einfo
13671 (_("%P: linkage table error against `%pT'\n"),
13672 h
->root
.root
.string
);
13673 bfd_set_error (bfd_error_bad_value
);
13674 htab
->stub_error
= TRUE
;
13677 htab
->stub_count
[ppc_stub_global_entry
- 1] += 1;
13678 if (htab
->params
->emit_stub_syms
)
13680 size_t len
= strlen (h
->root
.root
.string
);
13681 char *name
= bfd_malloc (sizeof "12345678.global_entry." + len
);
13686 sprintf (name
, "%08x.global_entry.%s", s
->id
, h
->root
.root
.string
);
13687 h
= elf_link_hash_lookup (&htab
->elf
, name
, TRUE
, FALSE
, FALSE
);
13690 if (h
->root
.type
== bfd_link_hash_new
)
13692 h
->root
.type
= bfd_link_hash_defined
;
13693 h
->root
.u
.def
.section
= s
;
13694 h
->root
.u
.def
.value
= p
- s
->contents
;
13695 h
->ref_regular
= 1;
13696 h
->def_regular
= 1;
13697 h
->ref_regular_nonweak
= 1;
13698 h
->forced_local
= 1;
13700 h
->root
.linker_def
= 1;
13704 if (PPC_HA (off
) != 0)
13706 bfd_put_32 (s
->owner
, ADDIS_R12_R12
| PPC_HA (off
), p
);
13709 bfd_put_32 (s
->owner
, LD_R12_0R12
| PPC_LO (off
), p
);
13711 bfd_put_32 (s
->owner
, MTCTR_R12
, p
);
13713 bfd_put_32 (s
->owner
, BCTR
, p
);
13719 /* Write PLT relocs for locals. */
13722 write_plt_relocs_for_local_syms (struct bfd_link_info
*info
)
13724 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
13727 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
13729 struct got_entry
**lgot_ents
, **end_lgot_ents
;
13730 struct plt_entry
**local_plt
, **lplt
, **end_local_plt
;
13731 Elf_Internal_Shdr
*symtab_hdr
;
13732 bfd_size_type locsymcount
;
13733 Elf_Internal_Sym
*local_syms
= NULL
;
13734 struct plt_entry
*ent
;
13736 if (!is_ppc64_elf (ibfd
))
13739 lgot_ents
= elf_local_got_ents (ibfd
);
13743 symtab_hdr
= &elf_symtab_hdr (ibfd
);
13744 locsymcount
= symtab_hdr
->sh_info
;
13745 end_lgot_ents
= lgot_ents
+ locsymcount
;
13746 local_plt
= (struct plt_entry
**) end_lgot_ents
;
13747 end_local_plt
= local_plt
+ locsymcount
;
13748 for (lplt
= local_plt
; lplt
< end_local_plt
; ++lplt
)
13749 for (ent
= *lplt
; ent
!= NULL
; ent
= ent
->next
)
13750 if (ent
->plt
.offset
!= (bfd_vma
) -1)
13752 Elf_Internal_Sym
*sym
;
13754 asection
*plt
, *relplt
;
13758 if (!get_sym_h (NULL
, &sym
, &sym_sec
, NULL
, &local_syms
,
13759 lplt
- local_plt
, ibfd
))
13761 if (local_syms
!= NULL
13762 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
13767 val
= sym
->st_value
+ ent
->addend
;
13768 if (ELF_ST_TYPE (sym
->st_info
) != STT_GNU_IFUNC
)
13769 val
+= PPC64_LOCAL_ENTRY_OFFSET (sym
->st_other
);
13770 if (sym_sec
!= NULL
&& sym_sec
->output_section
!= NULL
)
13771 val
+= sym_sec
->output_offset
+ sym_sec
->output_section
->vma
;
13773 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
13775 htab
->local_ifunc_resolver
= 1;
13776 plt
= htab
->elf
.iplt
;
13777 relplt
= htab
->elf
.irelplt
;
13781 plt
= htab
->pltlocal
;
13782 relplt
= bfd_link_pic (info
) ? htab
->relpltlocal
: NULL
;
13785 if (relplt
== NULL
)
13787 loc
= plt
->contents
+ ent
->plt
.offset
;
13788 bfd_put_64 (info
->output_bfd
, val
, loc
);
13791 bfd_vma toc
= elf_gp (ibfd
);
13792 bfd_put_64 (info
->output_bfd
, toc
, loc
+ 8);
13797 Elf_Internal_Rela rela
;
13798 rela
.r_offset
= (ent
->plt
.offset
13799 + plt
->output_offset
13800 + plt
->output_section
->vma
);
13801 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
13804 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_IREL
);
13806 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
13811 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_SLOT
);
13813 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
13815 rela
.r_addend
= val
;
13816 loc
= relplt
->contents
+ (relplt
->reloc_count
++
13817 * sizeof (Elf64_External_Rela
));
13818 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rela
, loc
);
13822 if (local_syms
!= NULL
13823 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
13825 if (!info
->keep_memory
)
13828 symtab_hdr
->contents
= (unsigned char *) local_syms
;
13834 /* Build all the stubs associated with the current output file.
13835 The stubs are kept in a hash table attached to the main linker
13836 hash table. This function is called via gldelf64ppc_finish. */
13839 ppc64_elf_build_stubs (struct bfd_link_info
*info
,
13842 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
13843 struct map_stub
*group
;
13844 asection
*stub_sec
;
13846 int stub_sec_count
= 0;
13851 /* Allocate memory to hold the linker stubs. */
13852 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13854 group
->eh_size
= 0;
13855 group
->lr_restore
= 0;
13856 if ((stub_sec
= group
->stub_sec
) != NULL
13857 && stub_sec
->size
!= 0)
13859 stub_sec
->contents
= bfd_zalloc (htab
->params
->stub_bfd
,
13861 if (stub_sec
->contents
== NULL
)
13863 stub_sec
->size
= 0;
13867 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
13872 /* Build the .glink plt call stub. */
13873 if (htab
->params
->emit_stub_syms
)
13875 struct elf_link_hash_entry
*h
;
13876 h
= elf_link_hash_lookup (&htab
->elf
, "__glink_PLTresolve",
13877 TRUE
, FALSE
, FALSE
);
13880 if (h
->root
.type
== bfd_link_hash_new
)
13882 h
->root
.type
= bfd_link_hash_defined
;
13883 h
->root
.u
.def
.section
= htab
->glink
;
13884 h
->root
.u
.def
.value
= 8;
13885 h
->ref_regular
= 1;
13886 h
->def_regular
= 1;
13887 h
->ref_regular_nonweak
= 1;
13888 h
->forced_local
= 1;
13890 h
->root
.linker_def
= 1;
13893 plt0
= (htab
->elf
.splt
->output_section
->vma
13894 + htab
->elf
.splt
->output_offset
13896 if (info
->emitrelocations
)
13898 Elf_Internal_Rela
*r
= get_relocs (htab
->glink
, 1);
13901 r
->r_offset
= (htab
->glink
->output_offset
13902 + htab
->glink
->output_section
->vma
);
13903 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL64
);
13904 r
->r_addend
= plt0
;
13906 p
= htab
->glink
->contents
;
13907 plt0
-= htab
->glink
->output_section
->vma
+ htab
->glink
->output_offset
;
13908 bfd_put_64 (htab
->glink
->owner
, plt0
, p
);
13912 bfd_put_32 (htab
->glink
->owner
, MFLR_R12
, p
);
13914 bfd_put_32 (htab
->glink
->owner
, BCL_20_31
, p
);
13916 bfd_put_32 (htab
->glink
->owner
, MFLR_R11
, p
);
13918 bfd_put_32 (htab
->glink
->owner
, LD_R2_0R11
| (-16 & 0xfffc), p
);
13920 bfd_put_32 (htab
->glink
->owner
, MTLR_R12
, p
);
13922 bfd_put_32 (htab
->glink
->owner
, ADD_R11_R2_R11
, p
);
13924 bfd_put_32 (htab
->glink
->owner
, LD_R12_0R11
, p
);
13926 bfd_put_32 (htab
->glink
->owner
, LD_R2_0R11
| 8, p
);
13928 bfd_put_32 (htab
->glink
->owner
, MTCTR_R12
, p
);
13930 bfd_put_32 (htab
->glink
->owner
, LD_R11_0R11
| 16, p
);
13935 bfd_put_32 (htab
->glink
->owner
, MFLR_R0
, p
);
13937 bfd_put_32 (htab
->glink
->owner
, BCL_20_31
, p
);
13939 bfd_put_32 (htab
->glink
->owner
, MFLR_R11
, p
);
13941 bfd_put_32 (htab
->glink
->owner
, STD_R2_0R1
+ 24, p
);
13943 bfd_put_32 (htab
->glink
->owner
, LD_R2_0R11
| (-16 & 0xfffc), p
);
13945 bfd_put_32 (htab
->glink
->owner
, MTLR_R0
, p
);
13947 bfd_put_32 (htab
->glink
->owner
, SUB_R12_R12_R11
, p
);
13949 bfd_put_32 (htab
->glink
->owner
, ADD_R11_R2_R11
, p
);
13951 bfd_put_32 (htab
->glink
->owner
, ADDI_R0_R12
| (-48 & 0xffff), p
);
13953 bfd_put_32 (htab
->glink
->owner
, LD_R12_0R11
, p
);
13955 bfd_put_32 (htab
->glink
->owner
, SRDI_R0_R0_2
, p
);
13957 bfd_put_32 (htab
->glink
->owner
, MTCTR_R12
, p
);
13959 bfd_put_32 (htab
->glink
->owner
, LD_R11_0R11
| 8, p
);
13962 bfd_put_32 (htab
->glink
->owner
, BCTR
, p
);
13964 BFD_ASSERT (p
== htab
->glink
->contents
+ GLINK_PLTRESOLVE_SIZE (htab
));
13966 /* Build the .glink lazy link call stubs. */
13968 while (p
< htab
->glink
->contents
+ htab
->glink
->size
)
13974 bfd_put_32 (htab
->glink
->owner
, LI_R0_0
| indx
, p
);
13979 bfd_put_32 (htab
->glink
->owner
, LIS_R0_0
| PPC_HI (indx
), p
);
13981 bfd_put_32 (htab
->glink
->owner
, ORI_R0_R0_0
| PPC_LO (indx
),
13986 bfd_put_32 (htab
->glink
->owner
,
13987 B_DOT
| ((htab
->glink
->contents
- p
+ 8) & 0x3fffffc), p
);
13993 /* Build .glink global entry stubs, and PLT relocs for globals. */
13994 elf_link_hash_traverse (&htab
->elf
, build_global_entry_stubs_and_plt
, info
);
13996 if (!write_plt_relocs_for_local_syms (info
))
13999 if (htab
->brlt
!= NULL
&& htab
->brlt
->size
!= 0)
14001 htab
->brlt
->contents
= bfd_zalloc (htab
->brlt
->owner
,
14003 if (htab
->brlt
->contents
== NULL
)
14006 if (htab
->relbrlt
!= NULL
&& htab
->relbrlt
->size
!= 0)
14008 htab
->relbrlt
->contents
= bfd_zalloc (htab
->relbrlt
->owner
,
14009 htab
->relbrlt
->size
);
14010 if (htab
->relbrlt
->contents
== NULL
)
14014 /* Build the stubs as directed by the stub hash table. */
14015 bfd_hash_traverse (&htab
->stub_hash_table
, ppc_build_one_stub
, info
);
14017 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14018 if (group
->needs_save_res
)
14019 group
->stub_sec
->size
+= htab
->sfpr
->size
;
14021 if (htab
->relbrlt
!= NULL
)
14022 htab
->relbrlt
->reloc_count
= 0;
14024 if (htab
->params
->plt_stub_align
!= 0)
14025 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14026 if ((stub_sec
= group
->stub_sec
) != NULL
)
14028 int align
= abs (htab
->params
->plt_stub_align
);
14029 stub_sec
->size
= (stub_sec
->size
+ (1 << align
) - 1) & -(1 << align
);
14032 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14033 if (group
->needs_save_res
)
14035 stub_sec
= group
->stub_sec
;
14036 memcpy (stub_sec
->contents
+ stub_sec
->size
- htab
->sfpr
->size
,
14037 htab
->sfpr
->contents
, htab
->sfpr
->size
);
14038 if (htab
->params
->emit_stub_syms
)
14042 for (i
= 0; i
< ARRAY_SIZE (save_res_funcs
); i
++)
14043 if (!sfpr_define (info
, &save_res_funcs
[i
], stub_sec
))
14048 if (htab
->glink_eh_frame
!= NULL
14049 && htab
->glink_eh_frame
->size
!= 0)
14054 p
= htab
->glink_eh_frame
->contents
;
14055 p
+= (sizeof (glink_eh_frame_cie
) + align
- 1) & -align
;
14057 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14058 if (group
->eh_size
!= 0)
14060 /* Offset to stub section. */
14061 val
= (group
->stub_sec
->output_section
->vma
14062 + group
->stub_sec
->output_offset
);
14063 val
-= (htab
->glink_eh_frame
->output_section
->vma
14064 + htab
->glink_eh_frame
->output_offset
14065 + (p
+ 8 - htab
->glink_eh_frame
->contents
));
14066 if (val
+ 0x80000000 > 0xffffffff)
14069 (_("%s offset too large for .eh_frame sdata4 encoding"),
14070 group
->stub_sec
->name
);
14073 bfd_put_32 (htab
->elf
.dynobj
, val
, p
+ 8);
14074 p
+= (group
->eh_size
+ 17 + 3) & -4;
14076 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
14078 /* Offset to .glink. */
14079 val
= (htab
->glink
->output_section
->vma
14080 + htab
->glink
->output_offset
14082 val
-= (htab
->glink_eh_frame
->output_section
->vma
14083 + htab
->glink_eh_frame
->output_offset
14084 + (p
+ 8 - htab
->glink_eh_frame
->contents
));
14085 if (val
+ 0x80000000 > 0xffffffff)
14088 (_("%s offset too large for .eh_frame sdata4 encoding"),
14089 htab
->glink
->name
);
14092 bfd_put_32 (htab
->elf
.dynobj
, val
, p
+ 8);
14093 p
+= (24 + align
- 1) & -align
;
14097 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14098 if ((stub_sec
= group
->stub_sec
) != NULL
)
14100 stub_sec_count
+= 1;
14101 if (stub_sec
->rawsize
!= stub_sec
->size
14102 && (htab
->stub_iteration
<= STUB_SHRINK_ITER
14103 || stub_sec
->rawsize
< stub_sec
->size
))
14109 htab
->stub_error
= TRUE
;
14110 _bfd_error_handler (_("stubs don't match calculated size"));
14113 if (htab
->stub_error
)
14119 *stats
= bfd_malloc (500);
14120 if (*stats
== NULL
)
14123 len
= sprintf (*stats
,
14124 ngettext ("linker stubs in %u group\n",
14125 "linker stubs in %u groups\n",
14128 sprintf (*stats
+ len
, _(" branch %lu\n"
14129 " branch toc adj %lu\n"
14130 " branch notoc %lu\n"
14131 " branch both %lu\n"
14132 " long branch %lu\n"
14133 " long toc adj %lu\n"
14134 " long notoc %lu\n"
14137 " plt call save %lu\n"
14138 " plt call notoc %lu\n"
14139 " plt call both %lu\n"
14140 " global entry %lu"),
14141 htab
->stub_count
[ppc_stub_long_branch
- 1],
14142 htab
->stub_count
[ppc_stub_long_branch_r2off
- 1],
14143 htab
->stub_count
[ppc_stub_long_branch_notoc
- 1],
14144 htab
->stub_count
[ppc_stub_long_branch_both
- 1],
14145 htab
->stub_count
[ppc_stub_plt_branch
- 1],
14146 htab
->stub_count
[ppc_stub_plt_branch_r2off
- 1],
14147 htab
->stub_count
[ppc_stub_plt_branch_notoc
- 1],
14148 htab
->stub_count
[ppc_stub_plt_branch_both
- 1],
14149 htab
->stub_count
[ppc_stub_plt_call
- 1],
14150 htab
->stub_count
[ppc_stub_plt_call_r2save
- 1],
14151 htab
->stub_count
[ppc_stub_plt_call_notoc
- 1],
14152 htab
->stub_count
[ppc_stub_plt_call_both
- 1],
14153 htab
->stub_count
[ppc_stub_global_entry
- 1]);
14158 /* What to do when ld finds relocations against symbols defined in
14159 discarded sections. */
14161 static unsigned int
14162 ppc64_elf_action_discarded (asection
*sec
)
14164 if (strcmp (".opd", sec
->name
) == 0)
14167 if (strcmp (".toc", sec
->name
) == 0)
14170 if (strcmp (".toc1", sec
->name
) == 0)
14173 return _bfd_elf_default_action_discarded (sec
);
14176 /* These are the dynamic relocations supported by glibc. */
14179 ppc64_glibc_dynamic_reloc (enum elf_ppc64_reloc_type r_type
)
14183 case R_PPC64_RELATIVE
:
14185 case R_PPC64_ADDR64
:
14186 case R_PPC64_GLOB_DAT
:
14187 case R_PPC64_IRELATIVE
:
14188 case R_PPC64_JMP_IREL
:
14189 case R_PPC64_JMP_SLOT
:
14190 case R_PPC64_DTPMOD64
:
14191 case R_PPC64_DTPREL64
:
14192 case R_PPC64_TPREL64
:
14193 case R_PPC64_TPREL16_LO_DS
:
14194 case R_PPC64_TPREL16_DS
:
14195 case R_PPC64_TPREL16
:
14196 case R_PPC64_TPREL16_LO
:
14197 case R_PPC64_TPREL16_HI
:
14198 case R_PPC64_TPREL16_HIGH
:
14199 case R_PPC64_TPREL16_HA
:
14200 case R_PPC64_TPREL16_HIGHA
:
14201 case R_PPC64_TPREL16_HIGHER
:
14202 case R_PPC64_TPREL16_HIGHEST
:
14203 case R_PPC64_TPREL16_HIGHERA
:
14204 case R_PPC64_TPREL16_HIGHESTA
:
14205 case R_PPC64_ADDR16_LO_DS
:
14206 case R_PPC64_ADDR16_LO
:
14207 case R_PPC64_ADDR16_HI
:
14208 case R_PPC64_ADDR16_HIGH
:
14209 case R_PPC64_ADDR16_HA
:
14210 case R_PPC64_ADDR16_HIGHA
:
14211 case R_PPC64_REL30
:
14213 case R_PPC64_UADDR64
:
14214 case R_PPC64_UADDR32
:
14215 case R_PPC64_ADDR32
:
14216 case R_PPC64_ADDR24
:
14217 case R_PPC64_ADDR16
:
14218 case R_PPC64_UADDR16
:
14219 case R_PPC64_ADDR16_DS
:
14220 case R_PPC64_ADDR16_HIGHER
:
14221 case R_PPC64_ADDR16_HIGHEST
:
14222 case R_PPC64_ADDR16_HIGHERA
:
14223 case R_PPC64_ADDR16_HIGHESTA
:
14224 case R_PPC64_ADDR14
:
14225 case R_PPC64_ADDR14_BRTAKEN
:
14226 case R_PPC64_ADDR14_BRNTAKEN
:
14227 case R_PPC64_REL32
:
14228 case R_PPC64_REL64
:
14236 /* The RELOCATE_SECTION function is called by the ELF backend linker
14237 to handle the relocations for a section.
14239 The relocs are always passed as Rela structures; if the section
14240 actually uses Rel structures, the r_addend field will always be
14243 This function is responsible for adjust the section contents as
14244 necessary, and (if using Rela relocs and generating a
14245 relocatable output file) adjusting the reloc addend as
14248 This function does not have to worry about setting the reloc
14249 address or the reloc symbol index.
14251 LOCAL_SYMS is a pointer to the swapped in local symbols.
14253 LOCAL_SECTIONS is an array giving the section in the input file
14254 corresponding to the st_shndx field of each local symbol.
14256 The global hash table entry for the global symbols can be found
14257 via elf_sym_hashes (input_bfd).
14259 When generating relocatable output, this function must handle
14260 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
14261 going to be the section symbol corresponding to the output
14262 section, which means that the addend must be adjusted
14266 ppc64_elf_relocate_section (bfd
*output_bfd
,
14267 struct bfd_link_info
*info
,
14269 asection
*input_section
,
14270 bfd_byte
*contents
,
14271 Elf_Internal_Rela
*relocs
,
14272 Elf_Internal_Sym
*local_syms
,
14273 asection
**local_sections
)
14275 struct ppc_link_hash_table
*htab
;
14276 Elf_Internal_Shdr
*symtab_hdr
;
14277 struct elf_link_hash_entry
**sym_hashes
;
14278 Elf_Internal_Rela
*rel
;
14279 Elf_Internal_Rela
*wrel
;
14280 Elf_Internal_Rela
*relend
;
14281 Elf_Internal_Rela outrel
;
14283 struct got_entry
**local_got_ents
;
14285 bfd_boolean ret
= TRUE
;
14286 bfd_boolean is_opd
;
14287 /* Assume 'at' branch hints. */
14288 bfd_boolean is_isa_v2
= TRUE
;
14289 bfd_boolean warned_dynamic
= FALSE
;
14290 bfd_vma d_offset
= (bfd_big_endian (input_bfd
) ? 2 : 0);
14292 /* Initialize howto table if needed. */
14293 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
14296 htab
= ppc_hash_table (info
);
14300 /* Don't relocate stub sections. */
14301 if (input_section
->owner
== htab
->params
->stub_bfd
)
14304 if (!is_ppc64_elf (input_bfd
))
14306 bfd_set_error (bfd_error_wrong_format
);
14310 local_got_ents
= elf_local_got_ents (input_bfd
);
14311 TOCstart
= elf_gp (output_bfd
);
14312 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
14313 sym_hashes
= elf_sym_hashes (input_bfd
);
14314 is_opd
= ppc64_elf_section_data (input_section
)->sec_type
== sec_opd
;
14316 rel
= wrel
= relocs
;
14317 relend
= relocs
+ input_section
->reloc_count
;
14318 for (; rel
< relend
; wrel
++, rel
++)
14320 enum elf_ppc64_reloc_type r_type
;
14322 bfd_reloc_status_type r
;
14323 Elf_Internal_Sym
*sym
;
14325 struct elf_link_hash_entry
*h_elf
;
14326 struct ppc_link_hash_entry
*h
;
14327 struct ppc_link_hash_entry
*fdh
;
14328 const char *sym_name
;
14329 unsigned long r_symndx
, toc_symndx
;
14330 bfd_vma toc_addend
;
14331 unsigned char tls_mask
, tls_gd
, tls_type
;
14332 unsigned char sym_type
;
14333 bfd_vma relocation
;
14334 bfd_boolean unresolved_reloc
, save_unresolved_reloc
;
14335 bfd_boolean warned
;
14336 enum { DEST_NORMAL
, DEST_OPD
, DEST_STUB
} reloc_dest
;
14339 struct ppc_stub_hash_entry
*stub_entry
;
14340 bfd_vma max_br_offset
;
14342 Elf_Internal_Rela orig_rel
;
14343 reloc_howto_type
*howto
;
14344 struct reloc_howto_struct alt_howto
;
14351 r_type
= ELF64_R_TYPE (rel
->r_info
);
14352 r_symndx
= ELF64_R_SYM (rel
->r_info
);
14354 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
14355 symbol of the previous ADDR64 reloc. The symbol gives us the
14356 proper TOC base to use. */
14357 if (rel
->r_info
== ELF64_R_INFO (0, R_PPC64_TOC
)
14359 && ELF64_R_TYPE (wrel
[-1].r_info
) == R_PPC64_ADDR64
14361 r_symndx
= ELF64_R_SYM (wrel
[-1].r_info
);
14367 unresolved_reloc
= FALSE
;
14370 if (r_symndx
< symtab_hdr
->sh_info
)
14372 /* It's a local symbol. */
14373 struct _opd_sec_data
*opd
;
14375 sym
= local_syms
+ r_symndx
;
14376 sec
= local_sections
[r_symndx
];
14377 sym_name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
, sec
);
14378 sym_type
= ELF64_ST_TYPE (sym
->st_info
);
14379 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
14380 opd
= get_opd_info (sec
);
14381 if (opd
!= NULL
&& opd
->adjust
!= NULL
)
14383 long adjust
= opd
->adjust
[OPD_NDX (sym
->st_value
14389 /* If this is a relocation against the opd section sym
14390 and we have edited .opd, adjust the reloc addend so
14391 that ld -r and ld --emit-relocs output is correct.
14392 If it is a reloc against some other .opd symbol,
14393 then the symbol value will be adjusted later. */
14394 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
14395 rel
->r_addend
+= adjust
;
14397 relocation
+= adjust
;
14403 bfd_boolean ignored
;
14405 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
14406 r_symndx
, symtab_hdr
, sym_hashes
,
14407 h_elf
, sec
, relocation
,
14408 unresolved_reloc
, warned
, ignored
);
14409 sym_name
= h_elf
->root
.root
.string
;
14410 sym_type
= h_elf
->type
;
14412 && sec
->owner
== output_bfd
14413 && strcmp (sec
->name
, ".opd") == 0)
14415 /* This is a symbol defined in a linker script. All
14416 such are defined in output sections, even those
14417 defined by simple assignment from a symbol defined in
14418 an input section. Transfer the symbol to an
14419 appropriate input .opd section, so that a branch to
14420 this symbol will be mapped to the location specified
14421 by the opd entry. */
14422 struct bfd_link_order
*lo
;
14423 for (lo
= sec
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
14424 if (lo
->type
== bfd_indirect_link_order
)
14426 asection
*isec
= lo
->u
.indirect
.section
;
14427 if (h_elf
->root
.u
.def
.value
>= isec
->output_offset
14428 && h_elf
->root
.u
.def
.value
< (isec
->output_offset
14431 h_elf
->root
.u
.def
.value
-= isec
->output_offset
;
14432 h_elf
->root
.u
.def
.section
= isec
;
14439 h
= (struct ppc_link_hash_entry
*) h_elf
;
14441 if (sec
!= NULL
&& discarded_section (sec
))
14443 _bfd_clear_contents (ppc64_elf_howto_table
[r_type
],
14444 input_bfd
, input_section
,
14445 contents
, rel
->r_offset
);
14446 wrel
->r_offset
= rel
->r_offset
;
14448 wrel
->r_addend
= 0;
14450 /* For ld -r, remove relocations in debug sections against
14451 symbols defined in discarded sections. Not done for
14452 non-debug to preserve relocs in .eh_frame which the
14453 eh_frame editing code expects to be present. */
14454 if (bfd_link_relocatable (info
)
14455 && (input_section
->flags
& SEC_DEBUGGING
))
14461 if (bfd_link_relocatable (info
))
14464 if (h
!= NULL
&& &h
->elf
== htab
->elf
.hgot
)
14466 relocation
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
14467 sec
= bfd_abs_section_ptr
;
14468 unresolved_reloc
= FALSE
;
14471 /* TLS optimizations. Replace instruction sequences and relocs
14472 based on information we collected in tls_optimize. We edit
14473 RELOCS so that --emit-relocs will output something sensible
14474 for the final instruction stream. */
14479 tls_mask
= h
->tls_mask
;
14480 else if (local_got_ents
!= NULL
)
14482 struct plt_entry
**local_plt
= (struct plt_entry
**)
14483 (local_got_ents
+ symtab_hdr
->sh_info
);
14484 unsigned char *lgot_masks
= (unsigned char *)
14485 (local_plt
+ symtab_hdr
->sh_info
);
14486 tls_mask
= lgot_masks
[r_symndx
];
14488 if (((tls_mask
& TLS_TLS
) == 0 || tls_mask
== (TLS_TLS
| TLS_MARK
))
14489 && (r_type
== R_PPC64_TLS
14490 || r_type
== R_PPC64_TLSGD
14491 || r_type
== R_PPC64_TLSLD
))
14493 /* Check for toc tls entries. */
14494 unsigned char *toc_tls
;
14496 if (!get_tls_mask (&toc_tls
, &toc_symndx
, &toc_addend
,
14497 &local_syms
, rel
, input_bfd
))
14501 tls_mask
= *toc_tls
;
14504 /* Check that tls relocs are used with tls syms, and non-tls
14505 relocs are used with non-tls syms. */
14506 if (r_symndx
!= STN_UNDEF
14507 && r_type
!= R_PPC64_NONE
14509 || h
->elf
.root
.type
== bfd_link_hash_defined
14510 || h
->elf
.root
.type
== bfd_link_hash_defweak
)
14511 && IS_PPC64_TLS_RELOC (r_type
) != (sym_type
== STT_TLS
))
14513 if ((tls_mask
& TLS_TLS
) != 0
14514 && (r_type
== R_PPC64_TLS
14515 || r_type
== R_PPC64_TLSGD
14516 || r_type
== R_PPC64_TLSLD
))
14517 /* R_PPC64_TLS is OK against a symbol in the TOC. */
14520 info
->callbacks
->einfo
14521 (!IS_PPC64_TLS_RELOC (r_type
)
14522 /* xgettext:c-format */
14523 ? _("%H: %s used with TLS symbol `%pT'\n")
14524 /* xgettext:c-format */
14525 : _("%H: %s used with non-TLS symbol `%pT'\n"),
14526 input_bfd
, input_section
, rel
->r_offset
,
14527 ppc64_elf_howto_table
[r_type
]->name
,
14531 /* Ensure reloc mapping code below stays sane. */
14532 if (R_PPC64_TOC16_LO_DS
!= R_PPC64_TOC16_DS
+ 1
14533 || R_PPC64_TOC16_LO
!= R_PPC64_TOC16
+ 1
14534 || (R_PPC64_GOT_TLSLD16
& 3) != (R_PPC64_GOT_TLSGD16
& 3)
14535 || (R_PPC64_GOT_TLSLD16_LO
& 3) != (R_PPC64_GOT_TLSGD16_LO
& 3)
14536 || (R_PPC64_GOT_TLSLD16_HI
& 3) != (R_PPC64_GOT_TLSGD16_HI
& 3)
14537 || (R_PPC64_GOT_TLSLD16_HA
& 3) != (R_PPC64_GOT_TLSGD16_HA
& 3)
14538 || (R_PPC64_GOT_TLSLD16
& 3) != (R_PPC64_GOT_TPREL16_DS
& 3)
14539 || (R_PPC64_GOT_TLSLD16_LO
& 3) != (R_PPC64_GOT_TPREL16_LO_DS
& 3)
14540 || (R_PPC64_GOT_TLSLD16_HI
& 3) != (R_PPC64_GOT_TPREL16_HI
& 3)
14541 || (R_PPC64_GOT_TLSLD16_HA
& 3) != (R_PPC64_GOT_TPREL16_HA
& 3))
14549 case R_PPC64_LO_DS_OPT
:
14550 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
- d_offset
);
14551 if ((insn
& (0x3fu
<< 26)) != 58u << 26)
14553 insn
+= (14u << 26) - (58u << 26);
14554 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
- d_offset
);
14555 r_type
= R_PPC64_TOC16_LO
;
14556 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14559 case R_PPC64_TOC16
:
14560 case R_PPC64_TOC16_LO
:
14561 case R_PPC64_TOC16_DS
:
14562 case R_PPC64_TOC16_LO_DS
:
14564 /* Check for toc tls entries. */
14565 unsigned char *toc_tls
;
14568 retval
= get_tls_mask (&toc_tls
, &toc_symndx
, &toc_addend
,
14569 &local_syms
, rel
, input_bfd
);
14575 tls_mask
= *toc_tls
;
14576 if (r_type
== R_PPC64_TOC16_DS
14577 || r_type
== R_PPC64_TOC16_LO_DS
)
14579 if ((tls_mask
& TLS_TLS
) != 0
14580 && (tls_mask
& (TLS_DTPREL
| TLS_TPREL
)) == 0)
14585 /* If we found a GD reloc pair, then we might be
14586 doing a GD->IE transition. */
14590 if ((tls_mask
& TLS_TLS
) != 0
14591 && (tls_mask
& TLS_GD
) == 0)
14594 else if (retval
== 3)
14596 if ((tls_mask
& TLS_TLS
) != 0
14597 && (tls_mask
& TLS_LD
) == 0)
14605 case R_PPC64_GOT_TPREL16_HI
:
14606 case R_PPC64_GOT_TPREL16_HA
:
14607 if ((tls_mask
& TLS_TLS
) != 0
14608 && (tls_mask
& TLS_TPREL
) == 0)
14610 rel
->r_offset
-= d_offset
;
14611 bfd_put_32 (input_bfd
, NOP
, contents
+ rel
->r_offset
);
14612 r_type
= R_PPC64_NONE
;
14613 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14617 case R_PPC64_GOT_TPREL16_DS
:
14618 case R_PPC64_GOT_TPREL16_LO_DS
:
14619 if ((tls_mask
& TLS_TLS
) != 0
14620 && (tls_mask
& TLS_TPREL
) == 0)
14623 insn
= bfd_get_32 (input_bfd
,
14624 contents
+ rel
->r_offset
- d_offset
);
14626 insn
|= 0x3c0d0000; /* addis 0,13,0 */
14627 bfd_put_32 (input_bfd
, insn
,
14628 contents
+ rel
->r_offset
- d_offset
);
14629 r_type
= R_PPC64_TPREL16_HA
;
14630 if (toc_symndx
!= 0)
14632 rel
->r_info
= ELF64_R_INFO (toc_symndx
, r_type
);
14633 rel
->r_addend
= toc_addend
;
14634 /* We changed the symbol. Start over in order to
14635 get h, sym, sec etc. right. */
14639 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14643 case R_PPC64_GOT_TPREL34
:
14644 if ((tls_mask
& TLS_TLS
) != 0
14645 && (tls_mask
& TLS_TPREL
) == 0)
14647 /* pld ra,sym@got@tprel@pcrel -> paddi ra,r13,sym@tprel */
14648 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
14650 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
14651 pinsn
+= ((2ULL << 56) + (-1ULL << 52)
14652 + (14ULL << 26) - (57ULL << 26) + (13ULL << 16));
14653 bfd_put_32 (input_bfd
, pinsn
>> 32,
14654 contents
+ rel
->r_offset
);
14655 bfd_put_32 (input_bfd
, pinsn
& 0xffffffff,
14656 contents
+ rel
->r_offset
+ 4);
14657 r_type
= R_PPC64_TPREL34
;
14658 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14663 if ((tls_mask
& TLS_TLS
) != 0
14664 && (tls_mask
& TLS_TPREL
) == 0)
14666 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
14667 insn
= _bfd_elf_ppc_at_tls_transform (insn
, 13);
14670 if ((rel
->r_offset
& 3) == 0)
14672 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
14673 /* Was PPC64_TLS which sits on insn boundary, now
14674 PPC64_TPREL16_LO which is at low-order half-word. */
14675 rel
->r_offset
+= d_offset
;
14676 r_type
= R_PPC64_TPREL16_LO
;
14677 if (toc_symndx
!= 0)
14679 rel
->r_info
= ELF64_R_INFO (toc_symndx
, r_type
);
14680 rel
->r_addend
= toc_addend
;
14681 /* We changed the symbol. Start over in order to
14682 get h, sym, sec etc. right. */
14686 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14688 else if ((rel
->r_offset
& 3) == 1)
14690 /* For pcrel IE to LE we already have the full
14691 offset and thus don't need an addi here. A nop
14693 if ((insn
& (0x3fu
<< 26)) == 14 << 26)
14695 /* Extract regs from addi rt,ra,si. */
14696 unsigned int rt
= (insn
>> 21) & 0x1f;
14697 unsigned int ra
= (insn
>> 16) & 0x1f;
14702 /* Build or ra,rs,rb with rb==rs, ie. mr ra,rs. */
14703 insn
= (rt
<< 16) | (ra
<< 21) | (ra
<< 11);
14704 insn
|= (31u << 26) | (444u << 1);
14707 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
- 1);
14712 case R_PPC64_GOT_TLSGD16_HI
:
14713 case R_PPC64_GOT_TLSGD16_HA
:
14715 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0)
14719 case R_PPC64_GOT_TLSLD16_HI
:
14720 case R_PPC64_GOT_TLSLD16_HA
:
14721 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0)
14724 if ((tls_mask
& tls_gd
) != 0)
14725 r_type
= (((r_type
- (R_PPC64_GOT_TLSGD16
& 3)) & 3)
14726 + R_PPC64_GOT_TPREL16_DS
);
14729 rel
->r_offset
-= d_offset
;
14730 bfd_put_32 (input_bfd
, NOP
, contents
+ rel
->r_offset
);
14731 r_type
= R_PPC64_NONE
;
14733 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14737 case R_PPC64_GOT_TLSGD16
:
14738 case R_PPC64_GOT_TLSGD16_LO
:
14740 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0)
14744 case R_PPC64_GOT_TLSLD16
:
14745 case R_PPC64_GOT_TLSLD16_LO
:
14746 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0)
14748 unsigned int insn1
, insn2
;
14751 offset
= (bfd_vma
) -1;
14752 /* If not using the newer R_PPC64_TLSGD/LD to mark
14753 __tls_get_addr calls, we must trust that the call
14754 stays with its arg setup insns, ie. that the next
14755 reloc is the __tls_get_addr call associated with
14756 the current reloc. Edit both insns. */
14757 if (input_section
->nomark_tls_get_addr
14758 && rel
+ 1 < relend
14759 && branch_reloc_hash_match (input_bfd
, rel
+ 1,
14760 htab
->tls_get_addr
,
14761 htab
->tls_get_addr_fd
))
14762 offset
= rel
[1].r_offset
;
14763 /* We read the low GOT_TLS (or TOC16) insn because we
14764 need to keep the destination reg. It may be
14765 something other than the usual r3, and moved to r3
14766 before the call by intervening code. */
14767 insn1
= bfd_get_32 (input_bfd
,
14768 contents
+ rel
->r_offset
- d_offset
);
14769 if ((tls_mask
& tls_gd
) != 0)
14772 insn1
&= (0x1f << 21) | (0x1f << 16);
14773 insn1
|= 58u << 26; /* ld */
14774 insn2
= 0x7c636a14; /* add 3,3,13 */
14775 if (offset
!= (bfd_vma
) -1)
14776 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
14777 if (r_type
== R_PPC64_TOC16
14778 || r_type
== R_PPC64_TOC16_LO
)
14779 r_type
+= R_PPC64_TOC16_DS
- R_PPC64_TOC16
;
14781 r_type
= (((r_type
- (R_PPC64_GOT_TLSGD16
& 1)) & 1)
14782 + R_PPC64_GOT_TPREL16_DS
);
14783 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14788 insn1
&= 0x1f << 21;
14789 insn1
|= 0x3c0d0000; /* addis r,13,0 */
14790 insn2
= 0x38630000; /* addi 3,3,0 */
14793 /* Was an LD reloc. */
14794 r_symndx
= STN_UNDEF
;
14795 rel
->r_addend
= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
14797 else if (toc_symndx
!= 0)
14799 r_symndx
= toc_symndx
;
14800 rel
->r_addend
= toc_addend
;
14802 r_type
= R_PPC64_TPREL16_HA
;
14803 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14804 if (offset
!= (bfd_vma
) -1)
14806 rel
[1].r_info
= ELF64_R_INFO (r_symndx
,
14807 R_PPC64_TPREL16_LO
);
14808 rel
[1].r_offset
= offset
+ d_offset
;
14809 rel
[1].r_addend
= rel
->r_addend
;
14812 bfd_put_32 (input_bfd
, insn1
,
14813 contents
+ rel
->r_offset
- d_offset
);
14814 if (offset
!= (bfd_vma
) -1)
14816 bfd_put_32 (input_bfd
, insn2
, contents
+ offset
);
14817 if (offset
+ 8 <= input_section
->size
)
14819 insn2
= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
14820 if (insn2
== LD_R2_0R1
+ STK_TOC (htab
))
14821 bfd_put_32 (input_bfd
, NOP
, contents
+ offset
+ 4);
14824 if ((tls_mask
& tls_gd
) == 0
14825 && (tls_gd
== 0 || toc_symndx
!= 0))
14827 /* We changed the symbol. Start over in order
14828 to get h, sym, sec etc. right. */
14834 case R_PPC64_GOT_TLSGD34
:
14835 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0)
14837 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
14839 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
14840 if ((tls_mask
& TLS_GDIE
) != 0)
14842 /* IE, pla -> pld */
14843 pinsn
+= (-2ULL << 56) + (57ULL << 26) - (14ULL << 26);
14844 r_type
= R_PPC64_GOT_TPREL34
;
14848 /* LE, pla pcrel -> paddi r13 */
14849 pinsn
+= (-1ULL << 52) + (13ULL << 16);
14850 r_type
= R_PPC64_TPREL34
;
14852 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14853 bfd_put_32 (input_bfd
, pinsn
>> 32,
14854 contents
+ rel
->r_offset
);
14855 bfd_put_32 (input_bfd
, pinsn
& 0xffffffff,
14856 contents
+ rel
->r_offset
+ 4);
14860 case R_PPC64_GOT_TLSLD34
:
14861 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0)
14863 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
14865 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
14866 pinsn
+= (-1ULL << 52) + (13ULL << 16);
14867 bfd_put_32 (input_bfd
, pinsn
>> 32,
14868 contents
+ rel
->r_offset
);
14869 bfd_put_32 (input_bfd
, pinsn
& 0xffffffff,
14870 contents
+ rel
->r_offset
+ 4);
14871 rel
->r_addend
= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
14872 r_symndx
= STN_UNDEF
;
14873 r_type
= R_PPC64_TPREL34
;
14874 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14879 case R_PPC64_TLSGD
:
14880 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0
14881 && rel
+ 1 < relend
)
14883 unsigned int insn2
;
14884 enum elf_ppc64_reloc_type r_type1
= ELF64_R_TYPE (rel
[1].r_info
);
14886 offset
= rel
->r_offset
;
14887 if (is_plt_seq_reloc (r_type1
))
14889 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
);
14890 if (r_type1
== R_PPC64_PLT_PCREL34
14891 || r_type1
== R_PPC64_PLT_PCREL34_NOTOC
)
14892 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
14893 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
14897 if (ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_PLTCALL
)
14898 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
14900 if ((tls_mask
& TLS_GDIE
) != 0)
14903 r_type
= R_PPC64_NONE
;
14904 insn2
= 0x7c636a14; /* add 3,3,13 */
14909 if (toc_symndx
!= 0)
14911 r_symndx
= toc_symndx
;
14912 rel
->r_addend
= toc_addend
;
14914 if (r_type1
== R_PPC64_REL24_NOTOC
14915 || r_type1
== R_PPC64_PLTCALL_NOTOC
)
14917 r_type
= R_PPC64_NONE
;
14922 rel
->r_offset
= offset
+ d_offset
;
14923 r_type
= R_PPC64_TPREL16_LO
;
14924 insn2
= 0x38630000; /* addi 3,3,0 */
14927 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14928 /* Zap the reloc on the _tls_get_addr call too. */
14929 BFD_ASSERT (offset
== rel
[1].r_offset
);
14930 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
14931 bfd_put_32 (input_bfd
, insn2
, contents
+ offset
);
14932 if ((tls_mask
& TLS_GDIE
) == 0
14934 && r_type
!= R_PPC64_NONE
)
14939 case R_PPC64_TLSLD
:
14940 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0
14941 && rel
+ 1 < relend
)
14943 unsigned int insn2
;
14944 enum elf_ppc64_reloc_type r_type1
= ELF64_R_TYPE (rel
[1].r_info
);
14946 offset
= rel
->r_offset
;
14947 if (is_plt_seq_reloc (r_type1
))
14949 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
);
14950 if (r_type1
== R_PPC64_PLT_PCREL34
14951 || r_type1
== R_PPC64_PLT_PCREL34_NOTOC
)
14952 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
14953 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
14957 if (ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_PLTCALL
)
14958 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
14960 if (r_type1
== R_PPC64_REL24_NOTOC
14961 || r_type1
== R_PPC64_PLTCALL_NOTOC
)
14963 r_type
= R_PPC64_NONE
;
14968 rel
->r_offset
= offset
+ d_offset
;
14969 r_symndx
= STN_UNDEF
;
14970 r_type
= R_PPC64_TPREL16_LO
;
14971 rel
->r_addend
= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
14972 insn2
= 0x38630000; /* addi 3,3,0 */
14974 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14975 /* Zap the reloc on the _tls_get_addr call too. */
14976 BFD_ASSERT (offset
== rel
[1].r_offset
);
14977 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
14978 bfd_put_32 (input_bfd
, insn2
, contents
+ offset
);
14979 if (r_type
!= R_PPC64_NONE
)
14984 case R_PPC64_DTPMOD64
:
14985 if (rel
+ 1 < relend
14986 && rel
[1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_DTPREL64
)
14987 && rel
[1].r_offset
== rel
->r_offset
+ 8)
14989 if ((tls_mask
& TLS_GD
) == 0)
14991 rel
[1].r_info
= ELF64_R_INFO (r_symndx
, R_PPC64_NONE
);
14992 if ((tls_mask
& TLS_GDIE
) != 0)
14993 r_type
= R_PPC64_TPREL64
;
14996 bfd_put_64 (output_bfd
, 1, contents
+ rel
->r_offset
);
14997 r_type
= R_PPC64_NONE
;
14999 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15004 if ((tls_mask
& TLS_LD
) == 0)
15006 bfd_put_64 (output_bfd
, 1, contents
+ rel
->r_offset
);
15007 r_type
= R_PPC64_NONE
;
15008 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15013 case R_PPC64_TPREL64
:
15014 if ((tls_mask
& TLS_TPREL
) == 0)
15016 r_type
= R_PPC64_NONE
;
15017 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15021 case R_PPC64_ENTRY
:
15022 relocation
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
15023 if (!bfd_link_pic (info
)
15024 && !info
->traditional_format
15025 && relocation
+ 0x80008000 <= 0xffffffff)
15027 unsigned int insn1
, insn2
;
15029 insn1
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15030 insn2
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15031 if ((insn1
& ~0xfffc) == LD_R2_0R12
15032 && insn2
== ADD_R2_R2_R12
)
15034 bfd_put_32 (input_bfd
,
15035 LIS_R2
+ PPC_HA (relocation
),
15036 contents
+ rel
->r_offset
);
15037 bfd_put_32 (input_bfd
,
15038 ADDI_R2_R2
+ PPC_LO (relocation
),
15039 contents
+ rel
->r_offset
+ 4);
15044 relocation
-= (rel
->r_offset
15045 + input_section
->output_offset
15046 + input_section
->output_section
->vma
);
15047 if (relocation
+ 0x80008000 <= 0xffffffff)
15049 unsigned int insn1
, insn2
;
15051 insn1
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15052 insn2
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15053 if ((insn1
& ~0xfffc) == LD_R2_0R12
15054 && insn2
== ADD_R2_R2_R12
)
15056 bfd_put_32 (input_bfd
,
15057 ADDIS_R2_R12
+ PPC_HA (relocation
),
15058 contents
+ rel
->r_offset
);
15059 bfd_put_32 (input_bfd
,
15060 ADDI_R2_R2
+ PPC_LO (relocation
),
15061 contents
+ rel
->r_offset
+ 4);
15067 case R_PPC64_REL16_HA
:
15068 /* If we are generating a non-PIC executable, edit
15069 . 0: addis 2,12,.TOC.-0b@ha
15070 . addi 2,2,.TOC.-0b@l
15071 used by ELFv2 global entry points to set up r2, to
15074 if .TOC. is in range. */
15075 if (!bfd_link_pic (info
)
15076 && !info
->traditional_format
15078 && rel
->r_addend
== d_offset
15079 && h
!= NULL
&& &h
->elf
== htab
->elf
.hgot
15080 && rel
+ 1 < relend
15081 && rel
[1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_REL16_LO
)
15082 && rel
[1].r_offset
== rel
->r_offset
+ 4
15083 && rel
[1].r_addend
== rel
->r_addend
+ 4
15084 && relocation
+ 0x80008000 <= 0xffffffff)
15086 unsigned int insn1
, insn2
;
15087 offset
= rel
->r_offset
- d_offset
;
15088 insn1
= bfd_get_32 (input_bfd
, contents
+ offset
);
15089 insn2
= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
15090 if ((insn1
& 0xffff0000) == ADDIS_R2_R12
15091 && (insn2
& 0xffff0000) == ADDI_R2_R2
)
15093 r_type
= R_PPC64_ADDR16_HA
;
15094 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15095 rel
->r_addend
-= d_offset
;
15096 rel
[1].r_info
= ELF64_R_INFO (r_symndx
, R_PPC64_ADDR16_LO
);
15097 rel
[1].r_addend
-= d_offset
+ 4;
15098 bfd_put_32 (input_bfd
, LIS_R2
, contents
+ offset
);
15104 /* Handle other relocations that tweak non-addend part of insn. */
15106 max_br_offset
= 1 << 25;
15107 addend
= rel
->r_addend
;
15108 reloc_dest
= DEST_NORMAL
;
15114 case R_PPC64_TOCSAVE
:
15115 if (relocation
+ addend
== (rel
->r_offset
15116 + input_section
->output_offset
15117 + input_section
->output_section
->vma
)
15118 && tocsave_find (htab
, NO_INSERT
,
15119 &local_syms
, rel
, input_bfd
))
15121 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15123 || insn
== CROR_151515
|| insn
== CROR_313131
)
15124 bfd_put_32 (input_bfd
,
15125 STD_R2_0R1
+ STK_TOC (htab
),
15126 contents
+ rel
->r_offset
);
15130 /* Branch taken prediction relocations. */
15131 case R_PPC64_ADDR14_BRTAKEN
:
15132 case R_PPC64_REL14_BRTAKEN
:
15133 insn
= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
15134 /* Fall through. */
15136 /* Branch not taken prediction relocations. */
15137 case R_PPC64_ADDR14_BRNTAKEN
:
15138 case R_PPC64_REL14_BRNTAKEN
:
15139 insn
|= bfd_get_32 (input_bfd
,
15140 contents
+ rel
->r_offset
) & ~(0x01 << 21);
15141 /* Fall through. */
15143 case R_PPC64_REL14
:
15144 max_br_offset
= 1 << 15;
15145 /* Fall through. */
15147 case R_PPC64_REL24
:
15148 case R_PPC64_REL24_NOTOC
:
15149 case R_PPC64_PLTCALL
:
15150 case R_PPC64_PLTCALL_NOTOC
:
15151 /* Calls to functions with a different TOC, such as calls to
15152 shared objects, need to alter the TOC pointer. This is
15153 done using a linkage stub. A REL24 branching to these
15154 linkage stubs needs to be followed by a nop, as the nop
15155 will be replaced with an instruction to restore the TOC
15160 && h
->oh
->is_func_descriptor
)
15161 fdh
= ppc_follow_link (h
->oh
);
15162 stub_entry
= ppc_get_stub_entry (input_section
, sec
, fdh
, &orig_rel
,
15164 if ((r_type
== R_PPC64_PLTCALL
15165 || r_type
== R_PPC64_PLTCALL_NOTOC
)
15166 && stub_entry
!= NULL
15167 && stub_entry
->stub_type
>= ppc_stub_plt_call
15168 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15171 if (stub_entry
!= NULL
15172 && ((stub_entry
->stub_type
>= ppc_stub_plt_call
15173 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15174 || stub_entry
->stub_type
== ppc_stub_plt_branch_r2off
15175 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
15176 || stub_entry
->stub_type
== ppc_stub_long_branch_r2off
15177 || stub_entry
->stub_type
== ppc_stub_long_branch_both
))
15179 bfd_boolean can_plt_call
= FALSE
;
15181 if (stub_entry
->stub_type
== ppc_stub_plt_call
15183 && htab
->params
->plt_localentry0
!= 0
15184 && is_elfv2_localentry0 (&h
->elf
))
15186 /* The function doesn't use or change r2. */
15187 can_plt_call
= TRUE
;
15189 else if (r_type
== R_PPC64_REL24_NOTOC
)
15191 /* NOTOC calls don't need to restore r2. */
15192 can_plt_call
= TRUE
;
15195 /* All of these stubs may modify r2, so there must be a
15196 branch and link followed by a nop. The nop is
15197 replaced by an insn to restore r2. */
15198 else if (rel
->r_offset
+ 8 <= input_section
->size
)
15202 br
= bfd_get_32 (input_bfd
,
15203 contents
+ rel
->r_offset
);
15208 nop
= bfd_get_32 (input_bfd
,
15209 contents
+ rel
->r_offset
+ 4);
15210 if (nop
== LD_R2_0R1
+ STK_TOC (htab
))
15211 can_plt_call
= TRUE
;
15212 else if (nop
== NOP
15213 || nop
== CROR_151515
15214 || nop
== CROR_313131
)
15217 && (h
== htab
->tls_get_addr_fd
15218 || h
== htab
->tls_get_addr
)
15219 && htab
->params
->tls_get_addr_opt
)
15221 /* Special stub used, leave nop alone. */
15224 bfd_put_32 (input_bfd
,
15225 LD_R2_0R1
+ STK_TOC (htab
),
15226 contents
+ rel
->r_offset
+ 4);
15227 can_plt_call
= TRUE
;
15232 if (!can_plt_call
&& h
!= NULL
)
15234 const char *name
= h
->elf
.root
.root
.string
;
15239 if (strncmp (name
, "__libc_start_main", 17) == 0
15240 && (name
[17] == 0 || name
[17] == '@'))
15242 /* Allow crt1 branch to go via a toc adjusting
15243 stub. Other calls that never return could do
15244 the same, if we could detect such. */
15245 can_plt_call
= TRUE
;
15251 /* g++ as of 20130507 emits self-calls without a
15252 following nop. This is arguably wrong since we
15253 have conflicting information. On the one hand a
15254 global symbol and on the other a local call
15255 sequence, but don't error for this special case.
15256 It isn't possible to cheaply verify we have
15257 exactly such a call. Allow all calls to the same
15259 asection
*code_sec
= sec
;
15261 if (get_opd_info (sec
) != NULL
)
15263 bfd_vma off
= (relocation
+ addend
15264 - sec
->output_section
->vma
15265 - sec
->output_offset
);
15267 opd_entry_value (sec
, off
, &code_sec
, NULL
, FALSE
);
15269 if (code_sec
== input_section
)
15270 can_plt_call
= TRUE
;
15275 if (stub_entry
->stub_type
>= ppc_stub_plt_call
15276 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15277 info
->callbacks
->einfo
15278 /* xgettext:c-format */
15279 (_("%H: call to `%pT' lacks nop, can't restore toc; "
15280 "(plt call stub)\n"),
15281 input_bfd
, input_section
, rel
->r_offset
, sym_name
);
15283 info
->callbacks
->einfo
15284 /* xgettext:c-format */
15285 (_("%H: call to `%pT' lacks nop, can't restore toc; "
15286 "(toc save/adjust stub)\n"),
15287 input_bfd
, input_section
, rel
->r_offset
, sym_name
);
15289 bfd_set_error (bfd_error_bad_value
);
15294 && stub_entry
->stub_type
>= ppc_stub_plt_call
15295 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15296 unresolved_reloc
= FALSE
;
15299 if ((stub_entry
== NULL
15300 || stub_entry
->stub_type
== ppc_stub_long_branch
15301 || stub_entry
->stub_type
== ppc_stub_plt_branch
)
15302 && get_opd_info (sec
) != NULL
)
15304 /* The branch destination is the value of the opd entry. */
15305 bfd_vma off
= (relocation
+ addend
15306 - sec
->output_section
->vma
15307 - sec
->output_offset
);
15308 bfd_vma dest
= opd_entry_value (sec
, off
, NULL
, NULL
, FALSE
);
15309 if (dest
!= (bfd_vma
) -1)
15313 reloc_dest
= DEST_OPD
;
15317 /* If the branch is out of reach we ought to have a long
15319 from
= (rel
->r_offset
15320 + input_section
->output_offset
15321 + input_section
->output_section
->vma
);
15323 relocation
+= PPC64_LOCAL_ENTRY_OFFSET (fdh
15327 if (stub_entry
!= NULL
15328 && (stub_entry
->stub_type
== ppc_stub_long_branch
15329 || stub_entry
->stub_type
== ppc_stub_plt_branch
)
15330 && (r_type
== R_PPC64_ADDR14_BRTAKEN
15331 || r_type
== R_PPC64_ADDR14_BRNTAKEN
15332 || (relocation
+ addend
- from
+ max_br_offset
15333 < 2 * max_br_offset
)))
15334 /* Don't use the stub if this branch is in range. */
15337 if (stub_entry
!= NULL
15338 && (stub_entry
->stub_type
== ppc_stub_long_branch_notoc
15339 || stub_entry
->stub_type
== ppc_stub_long_branch_both
15340 || stub_entry
->stub_type
== ppc_stub_plt_branch_notoc
15341 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
)
15342 && (r_type
!= R_PPC64_REL24_NOTOC
15343 || ((fdh
? fdh
->elf
.other
: sym
->st_other
)
15344 & STO_PPC64_LOCAL_MASK
) <= 1 << STO_PPC64_LOCAL_BIT
)
15345 && (relocation
+ addend
- from
+ max_br_offset
15346 < 2 * max_br_offset
))
15349 if (stub_entry
!= NULL
15350 && (stub_entry
->stub_type
== ppc_stub_long_branch_r2off
15351 || stub_entry
->stub_type
== ppc_stub_long_branch_both
15352 || stub_entry
->stub_type
== ppc_stub_plt_branch_r2off
15353 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
)
15354 && r_type
== R_PPC64_REL24_NOTOC
15355 && (relocation
+ addend
- from
+ max_br_offset
15356 < 2 * max_br_offset
))
15359 if (stub_entry
!= NULL
)
15361 /* Munge up the value and addend so that we call the stub
15362 rather than the procedure directly. */
15363 asection
*stub_sec
= stub_entry
->group
->stub_sec
;
15365 if (stub_entry
->stub_type
== ppc_stub_save_res
)
15366 relocation
+= (stub_sec
->output_offset
15367 + stub_sec
->output_section
->vma
15368 + stub_sec
->size
- htab
->sfpr
->size
15369 - htab
->sfpr
->output_offset
15370 - htab
->sfpr
->output_section
->vma
);
15372 relocation
= (stub_entry
->stub_offset
15373 + stub_sec
->output_offset
15374 + stub_sec
->output_section
->vma
);
15376 reloc_dest
= DEST_STUB
;
15378 if (((stub_entry
->stub_type
== ppc_stub_plt_call
15379 && ALWAYS_EMIT_R2SAVE
)
15380 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
15381 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
15383 && (h
== htab
->tls_get_addr_fd
15384 || h
== htab
->tls_get_addr
)
15385 && htab
->params
->tls_get_addr_opt
)
15386 && rel
+ 1 < relend
15387 && rel
[1].r_offset
== rel
->r_offset
+ 4
15388 && ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_TOCSAVE
)
15390 else if ((stub_entry
->stub_type
== ppc_stub_long_branch_both
15391 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
15392 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
15393 && r_type
== R_PPC64_REL24_NOTOC
)
15396 if (r_type
== R_PPC64_REL24_NOTOC
15397 && (stub_entry
->stub_type
== ppc_stub_plt_call_notoc
15398 || stub_entry
->stub_type
== ppc_stub_plt_call_both
))
15399 htab
->notoc_plt
= 1;
15406 /* Set 'a' bit. This is 0b00010 in BO field for branch
15407 on CR(BI) insns (BO == 001at or 011at), and 0b01000
15408 for branch on CTR insns (BO == 1a00t or 1a01t). */
15409 if ((insn
& (0x14 << 21)) == (0x04 << 21))
15410 insn
|= 0x02 << 21;
15411 else if ((insn
& (0x14 << 21)) == (0x10 << 21))
15412 insn
|= 0x08 << 21;
15418 /* Invert 'y' bit if not the default. */
15419 if ((bfd_signed_vma
) (relocation
+ addend
- from
) < 0)
15420 insn
^= 0x01 << 21;
15423 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
15426 /* NOP out calls to undefined weak functions.
15427 We can thus call a weak function without first
15428 checking whether the function is defined. */
15430 && h
->elf
.root
.type
== bfd_link_hash_undefweak
15431 && h
->elf
.dynindx
== -1
15432 && (r_type
== R_PPC64_REL24
15433 || r_type
== R_PPC64_REL24_NOTOC
)
15437 bfd_put_32 (input_bfd
, NOP
, contents
+ rel
->r_offset
);
15442 case R_PPC64_GOT16_DS
:
15443 from
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
15444 if (relocation
+ addend
- from
+ 0x8000 < 0x10000
15445 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15447 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
15448 if ((insn
& (0x3fu
<< 26 | 0x3)) == 58u << 26 /* ld */)
15450 insn
+= (14u << 26) - (58u << 26);
15451 bfd_put_32 (input_bfd
, insn
, contents
+ (rel
->r_offset
& ~3));
15452 r_type
= R_PPC64_TOC16
;
15453 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15458 case R_PPC64_GOT16_LO_DS
:
15459 case R_PPC64_GOT16_HA
:
15460 from
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
15461 if (relocation
+ addend
- from
+ 0x80008000ULL
< 0x100000000ULL
15462 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15464 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
15465 if ((insn
& (0x3fu
<< 26 | 0x3)) == 58u << 26 /* ld */)
15467 insn
+= (14u << 26) - (58u << 26);
15468 bfd_put_32 (input_bfd
, insn
, contents
+ (rel
->r_offset
& ~3));
15469 r_type
= R_PPC64_TOC16_LO
;
15470 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15472 else if ((insn
& (0x3fu
<< 26)) == 15u << 26 /* addis */)
15474 r_type
= R_PPC64_TOC16_HA
;
15475 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15480 case R_PPC64_GOT_PCREL34
:
15481 from
= (rel
->r_offset
15482 + input_section
->output_section
->vma
15483 + input_section
->output_offset
);
15484 if (relocation
- from
+ (1ULL << 33) < 1ULL << 34
15485 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15487 offset
= rel
->r_offset
;
15488 pinsn
= bfd_get_32 (input_bfd
, contents
+ offset
);
15490 pinsn
|= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
15491 if ((pinsn
& ((-1ULL << 50) | (63ULL << 26)))
15492 == ((1ULL << 58) | (1ULL << 52) | (57ULL << 26) /* pld */))
15494 /* Replace with paddi. */
15495 pinsn
+= (2ULL << 56) + (14ULL << 26) - (57ULL << 26);
15496 r_type
= R_PPC64_PCREL34
;
15497 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15498 bfd_put_32 (input_bfd
, pinsn
>> 32, contents
+ offset
);
15499 bfd_put_32 (input_bfd
, pinsn
, contents
+ offset
+ 4);
15505 case R_PPC64_PCREL34
:
15506 if (SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15508 offset
= rel
->r_offset
;
15509 pinsn
= bfd_get_32 (input_bfd
, contents
+ offset
);
15511 pinsn
|= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
15512 if ((pinsn
& ((-1ULL << 50) | (63ULL << 26)))
15513 == ((1ULL << 58) | (2ULL << 56) | (1ULL << 52)
15514 | (14ULL << 26) /* paddi */))
15517 if (rel
+ 1 < relend
15518 && rel
[1].r_offset
== offset
15519 && rel
[1].r_info
== ELF64_R_INFO (0, R_PPC64_PCREL_OPT
))
15521 bfd_vma off2
= rel
[1].r_addend
;
15523 /* zero means next insn. */
15526 if (off2
+ 4 <= input_section
->size
)
15529 bfd_signed_vma addend_off
;
15530 pinsn2
= bfd_get_32 (input_bfd
, contents
+ off2
);
15532 if ((pinsn2
& (63ULL << 58)) == 1ULL << 58)
15534 if (off2
+ 8 > input_section
->size
)
15536 pinsn2
|= bfd_get_32 (input_bfd
,
15537 contents
+ off2
+ 4);
15539 if (xlate_pcrel_opt (&pinsn
, &pinsn2
, &addend_off
))
15541 addend
+= addend_off
;
15542 rel
->r_addend
= addend
;
15543 bfd_put_32 (input_bfd
, pinsn
>> 32,
15544 contents
+ offset
);
15545 bfd_put_32 (input_bfd
, pinsn
,
15546 contents
+ offset
+ 4);
15547 bfd_put_32 (input_bfd
, pinsn2
>> 32,
15549 if ((pinsn2
& (63ULL << 58)) == 1ULL << 58)
15550 bfd_put_32 (input_bfd
, pinsn2
,
15551 contents
+ off2
+ 4);
15561 save_unresolved_reloc
= unresolved_reloc
;
15565 /* xgettext:c-format */
15566 _bfd_error_handler (_("%pB: %s unsupported"),
15567 input_bfd
, ppc64_elf_howto_table
[r_type
]->name
);
15569 bfd_set_error (bfd_error_bad_value
);
15575 case R_PPC64_TLSGD
:
15576 case R_PPC64_TLSLD
:
15577 case R_PPC64_TOCSAVE
:
15578 case R_PPC64_GNU_VTINHERIT
:
15579 case R_PPC64_GNU_VTENTRY
:
15580 case R_PPC64_ENTRY
:
15581 case R_PPC64_PCREL_OPT
:
15584 /* GOT16 relocations. Like an ADDR16 using the symbol's
15585 address in the GOT as relocation value instead of the
15586 symbol's value itself. Also, create a GOT entry for the
15587 symbol and put the symbol value there. */
15588 case R_PPC64_GOT_TLSGD16
:
15589 case R_PPC64_GOT_TLSGD16_LO
:
15590 case R_PPC64_GOT_TLSGD16_HI
:
15591 case R_PPC64_GOT_TLSGD16_HA
:
15592 case R_PPC64_GOT_TLSGD34
:
15593 tls_type
= TLS_TLS
| TLS_GD
;
15596 case R_PPC64_GOT_TLSLD16
:
15597 case R_PPC64_GOT_TLSLD16_LO
:
15598 case R_PPC64_GOT_TLSLD16_HI
:
15599 case R_PPC64_GOT_TLSLD16_HA
:
15600 case R_PPC64_GOT_TLSLD34
:
15601 tls_type
= TLS_TLS
| TLS_LD
;
15604 case R_PPC64_GOT_TPREL16_DS
:
15605 case R_PPC64_GOT_TPREL16_LO_DS
:
15606 case R_PPC64_GOT_TPREL16_HI
:
15607 case R_PPC64_GOT_TPREL16_HA
:
15608 case R_PPC64_GOT_TPREL34
:
15609 tls_type
= TLS_TLS
| TLS_TPREL
;
15612 case R_PPC64_GOT_DTPREL16_DS
:
15613 case R_PPC64_GOT_DTPREL16_LO_DS
:
15614 case R_PPC64_GOT_DTPREL16_HI
:
15615 case R_PPC64_GOT_DTPREL16_HA
:
15616 case R_PPC64_GOT_DTPREL34
:
15617 tls_type
= TLS_TLS
| TLS_DTPREL
;
15620 case R_PPC64_GOT16
:
15621 case R_PPC64_GOT16_LO
:
15622 case R_PPC64_GOT16_HI
:
15623 case R_PPC64_GOT16_HA
:
15624 case R_PPC64_GOT16_DS
:
15625 case R_PPC64_GOT16_LO_DS
:
15626 case R_PPC64_GOT_PCREL34
:
15629 /* Relocation is to the entry for this symbol in the global
15634 unsigned long indx
= 0;
15635 struct got_entry
*ent
;
15637 if (tls_type
== (TLS_TLS
| TLS_LD
)
15638 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15639 ent
= ppc64_tlsld_got (input_bfd
);
15644 if (!htab
->elf
.dynamic_sections_created
15645 || h
->elf
.dynindx
== -1
15646 || SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
)
15647 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, &h
->elf
))
15648 /* This is actually a static link, or it is a
15649 -Bsymbolic link and the symbol is defined
15650 locally, or the symbol was forced to be local
15651 because of a version file. */
15655 indx
= h
->elf
.dynindx
;
15656 unresolved_reloc
= FALSE
;
15658 ent
= h
->elf
.got
.glist
;
15662 if (local_got_ents
== NULL
)
15664 ent
= local_got_ents
[r_symndx
];
15667 for (; ent
!= NULL
; ent
= ent
->next
)
15668 if (ent
->addend
== orig_rel
.r_addend
15669 && ent
->owner
== input_bfd
15670 && ent
->tls_type
== tls_type
)
15676 if (ent
->is_indirect
)
15677 ent
= ent
->got
.ent
;
15678 offp
= &ent
->got
.offset
;
15679 got
= ppc64_elf_tdata (ent
->owner
)->got
;
15683 /* The offset must always be a multiple of 8. We use the
15684 least significant bit to record whether we have already
15685 processed this entry. */
15687 if ((off
& 1) != 0)
15691 /* Generate relocs for the dynamic linker, except in
15692 the case of TLSLD where we'll use one entry per
15700 ? h
->elf
.type
== STT_GNU_IFUNC
15701 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
);
15704 relgot
= htab
->elf
.irelplt
;
15706 htab
->local_ifunc_resolver
= 1;
15707 else if (is_static_defined (&h
->elf
))
15708 htab
->maybe_local_ifunc_resolver
= 1;
15711 || (bfd_link_pic (info
)
15713 || !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, &h
->elf
))
15715 && bfd_link_executable (info
)
15716 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))))
15717 relgot
= ppc64_elf_tdata (ent
->owner
)->relgot
;
15718 if (relgot
!= NULL
)
15720 outrel
.r_offset
= (got
->output_section
->vma
15721 + got
->output_offset
15723 outrel
.r_addend
= orig_rel
.r_addend
;
15724 if (tls_type
& (TLS_LD
| TLS_GD
))
15726 outrel
.r_addend
= 0;
15727 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_DTPMOD64
);
15728 if (tls_type
== (TLS_TLS
| TLS_GD
))
15730 loc
= relgot
->contents
;
15731 loc
+= (relgot
->reloc_count
++
15732 * sizeof (Elf64_External_Rela
));
15733 bfd_elf64_swap_reloca_out (output_bfd
,
15735 outrel
.r_offset
+= 8;
15736 outrel
.r_addend
= orig_rel
.r_addend
;
15738 = ELF64_R_INFO (indx
, R_PPC64_DTPREL64
);
15741 else if (tls_type
== (TLS_TLS
| TLS_DTPREL
))
15742 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_DTPREL64
);
15743 else if (tls_type
== (TLS_TLS
| TLS_TPREL
))
15744 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_TPREL64
);
15745 else if (indx
!= 0)
15746 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_GLOB_DAT
);
15750 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
15752 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
15754 /* Write the .got section contents for the sake
15756 loc
= got
->contents
+ off
;
15757 bfd_put_64 (output_bfd
, outrel
.r_addend
+ relocation
,
15761 if (indx
== 0 && tls_type
!= (TLS_TLS
| TLS_LD
))
15763 outrel
.r_addend
+= relocation
;
15764 if (tls_type
& (TLS_GD
| TLS_DTPREL
| TLS_TPREL
))
15766 if (htab
->elf
.tls_sec
== NULL
)
15767 outrel
.r_addend
= 0;
15769 outrel
.r_addend
-= htab
->elf
.tls_sec
->vma
;
15772 loc
= relgot
->contents
;
15773 loc
+= (relgot
->reloc_count
++
15774 * sizeof (Elf64_External_Rela
));
15775 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
15778 /* Init the .got section contents here if we're not
15779 emitting a reloc. */
15782 relocation
+= orig_rel
.r_addend
;
15785 if (htab
->elf
.tls_sec
== NULL
)
15789 if (tls_type
& TLS_LD
)
15792 relocation
-= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
15793 if (tls_type
& TLS_TPREL
)
15794 relocation
+= DTP_OFFSET
- TP_OFFSET
;
15797 if (tls_type
& (TLS_GD
| TLS_LD
))
15799 bfd_put_64 (output_bfd
, relocation
,
15800 got
->contents
+ off
+ 8);
15804 bfd_put_64 (output_bfd
, relocation
,
15805 got
->contents
+ off
);
15809 if (off
>= (bfd_vma
) -2)
15812 relocation
= got
->output_section
->vma
+ got
->output_offset
+ off
;
15814 if (!(r_type
== R_PPC64_GOT_PCREL34
15815 || r_type
== R_PPC64_GOT_TLSGD34
15816 || r_type
== R_PPC64_GOT_TLSLD34
15817 || r_type
== R_PPC64_GOT_TPREL34
15818 || r_type
== R_PPC64_GOT_DTPREL34
))
15819 addend
= -(TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
);
15823 case R_PPC64_PLT16_HA
:
15824 case R_PPC64_PLT16_HI
:
15825 case R_PPC64_PLT16_LO
:
15826 case R_PPC64_PLT16_LO_DS
:
15827 case R_PPC64_PLT_PCREL34
:
15828 case R_PPC64_PLT_PCREL34_NOTOC
:
15829 case R_PPC64_PLT32
:
15830 case R_PPC64_PLT64
:
15831 case R_PPC64_PLTSEQ
:
15832 case R_PPC64_PLTSEQ_NOTOC
:
15833 case R_PPC64_PLTCALL
:
15834 case R_PPC64_PLTCALL_NOTOC
:
15835 /* Relocation is to the entry for this symbol in the
15836 procedure linkage table. */
15837 unresolved_reloc
= TRUE
;
15839 struct plt_entry
**plt_list
= NULL
;
15841 plt_list
= &h
->elf
.plt
.plist
;
15842 else if (local_got_ents
!= NULL
)
15844 struct plt_entry
**local_plt
= (struct plt_entry
**)
15845 (local_got_ents
+ symtab_hdr
->sh_info
);
15846 plt_list
= local_plt
+ r_symndx
;
15850 struct plt_entry
*ent
;
15852 for (ent
= *plt_list
; ent
!= NULL
; ent
= ent
->next
)
15853 if (ent
->plt
.offset
!= (bfd_vma
) -1
15854 && ent
->addend
== orig_rel
.r_addend
)
15859 plt
= htab
->elf
.splt
;
15860 if (!htab
->elf
.dynamic_sections_created
15862 || h
->elf
.dynindx
== -1)
15865 ? h
->elf
.type
== STT_GNU_IFUNC
15866 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
15867 plt
= htab
->elf
.iplt
;
15869 plt
= htab
->pltlocal
;
15871 relocation
= (plt
->output_section
->vma
15872 + plt
->output_offset
15873 + ent
->plt
.offset
);
15874 if (r_type
== R_PPC64_PLT16_HA
15875 || r_type
== R_PPC64_PLT16_HI
15876 || r_type
== R_PPC64_PLT16_LO
15877 || r_type
== R_PPC64_PLT16_LO_DS
)
15879 got
= (elf_gp (output_bfd
)
15880 + htab
->sec_info
[input_section
->id
].toc_off
);
15884 unresolved_reloc
= FALSE
;
15892 /* Relocation value is TOC base. */
15893 relocation
= TOCstart
;
15894 if (r_symndx
== STN_UNDEF
)
15895 relocation
+= htab
->sec_info
[input_section
->id
].toc_off
;
15896 else if (unresolved_reloc
)
15898 else if (sec
!= NULL
&& sec
->id
< htab
->sec_info_arr_size
)
15899 relocation
+= htab
->sec_info
[sec
->id
].toc_off
;
15901 unresolved_reloc
= TRUE
;
15904 /* TOC16 relocs. We want the offset relative to the TOC base,
15905 which is the address of the start of the TOC plus 0x8000.
15906 The TOC consists of sections .got, .toc, .tocbss, and .plt,
15908 case R_PPC64_TOC16
:
15909 case R_PPC64_TOC16_LO
:
15910 case R_PPC64_TOC16_HI
:
15911 case R_PPC64_TOC16_DS
:
15912 case R_PPC64_TOC16_LO_DS
:
15913 case R_PPC64_TOC16_HA
:
15914 addend
-= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
15919 /* Relocate against the beginning of the section. */
15920 case R_PPC64_SECTOFF
:
15921 case R_PPC64_SECTOFF_LO
:
15922 case R_PPC64_SECTOFF_HI
:
15923 case R_PPC64_SECTOFF_DS
:
15924 case R_PPC64_SECTOFF_LO_DS
:
15925 case R_PPC64_SECTOFF_HA
:
15927 addend
-= sec
->output_section
->vma
;
15930 case R_PPC64_REL16
:
15931 case R_PPC64_REL16_LO
:
15932 case R_PPC64_REL16_HI
:
15933 case R_PPC64_REL16_HA
:
15934 case R_PPC64_REL16_HIGH
:
15935 case R_PPC64_REL16_HIGHA
:
15936 case R_PPC64_REL16_HIGHER
:
15937 case R_PPC64_REL16_HIGHERA
:
15938 case R_PPC64_REL16_HIGHEST
:
15939 case R_PPC64_REL16_HIGHESTA
:
15940 case R_PPC64_REL16_HIGHER34
:
15941 case R_PPC64_REL16_HIGHERA34
:
15942 case R_PPC64_REL16_HIGHEST34
:
15943 case R_PPC64_REL16_HIGHESTA34
:
15944 case R_PPC64_REL16DX_HA
:
15945 case R_PPC64_REL14
:
15946 case R_PPC64_REL14_BRNTAKEN
:
15947 case R_PPC64_REL14_BRTAKEN
:
15948 case R_PPC64_REL24
:
15949 case R_PPC64_REL24_NOTOC
:
15950 case R_PPC64_PCREL34
:
15951 case R_PPC64_PCREL28
:
15954 case R_PPC64_TPREL16
:
15955 case R_PPC64_TPREL16_LO
:
15956 case R_PPC64_TPREL16_HI
:
15957 case R_PPC64_TPREL16_HA
:
15958 case R_PPC64_TPREL16_DS
:
15959 case R_PPC64_TPREL16_LO_DS
:
15960 case R_PPC64_TPREL16_HIGH
:
15961 case R_PPC64_TPREL16_HIGHA
:
15962 case R_PPC64_TPREL16_HIGHER
:
15963 case R_PPC64_TPREL16_HIGHERA
:
15964 case R_PPC64_TPREL16_HIGHEST
:
15965 case R_PPC64_TPREL16_HIGHESTA
:
15966 case R_PPC64_TPREL34
:
15968 && h
->elf
.root
.type
== bfd_link_hash_undefweak
15969 && h
->elf
.dynindx
== -1)
15971 /* Make this relocation against an undefined weak symbol
15972 resolve to zero. This is really just a tweak, since
15973 code using weak externs ought to check that they are
15974 defined before using them. */
15975 bfd_byte
*p
= contents
+ rel
->r_offset
- d_offset
;
15977 insn
= bfd_get_32 (input_bfd
, p
);
15978 insn
= _bfd_elf_ppc_at_tprel_transform (insn
, 13);
15980 bfd_put_32 (input_bfd
, insn
, p
);
15983 if (htab
->elf
.tls_sec
!= NULL
)
15984 addend
-= htab
->elf
.tls_sec
->vma
+ TP_OFFSET
;
15985 /* The TPREL16 relocs shouldn't really be used in shared
15986 libs or with non-local symbols as that will result in
15987 DT_TEXTREL being set, but support them anyway. */
15990 case R_PPC64_DTPREL16
:
15991 case R_PPC64_DTPREL16_LO
:
15992 case R_PPC64_DTPREL16_HI
:
15993 case R_PPC64_DTPREL16_HA
:
15994 case R_PPC64_DTPREL16_DS
:
15995 case R_PPC64_DTPREL16_LO_DS
:
15996 case R_PPC64_DTPREL16_HIGH
:
15997 case R_PPC64_DTPREL16_HIGHA
:
15998 case R_PPC64_DTPREL16_HIGHER
:
15999 case R_PPC64_DTPREL16_HIGHERA
:
16000 case R_PPC64_DTPREL16_HIGHEST
:
16001 case R_PPC64_DTPREL16_HIGHESTA
:
16002 case R_PPC64_DTPREL34
:
16003 if (htab
->elf
.tls_sec
!= NULL
)
16004 addend
-= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
16007 case R_PPC64_ADDR64_LOCAL
:
16008 addend
+= PPC64_LOCAL_ENTRY_OFFSET (h
!= NULL
16013 case R_PPC64_DTPMOD64
:
16018 case R_PPC64_TPREL64
:
16019 if (htab
->elf
.tls_sec
!= NULL
)
16020 addend
-= htab
->elf
.tls_sec
->vma
+ TP_OFFSET
;
16023 case R_PPC64_DTPREL64
:
16024 if (htab
->elf
.tls_sec
!= NULL
)
16025 addend
-= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
16026 /* Fall through. */
16028 /* Relocations that may need to be propagated if this is a
16030 case R_PPC64_REL30
:
16031 case R_PPC64_REL32
:
16032 case R_PPC64_REL64
:
16033 case R_PPC64_ADDR14
:
16034 case R_PPC64_ADDR14_BRNTAKEN
:
16035 case R_PPC64_ADDR14_BRTAKEN
:
16036 case R_PPC64_ADDR16
:
16037 case R_PPC64_ADDR16_DS
:
16038 case R_PPC64_ADDR16_HA
:
16039 case R_PPC64_ADDR16_HI
:
16040 case R_PPC64_ADDR16_HIGH
:
16041 case R_PPC64_ADDR16_HIGHA
:
16042 case R_PPC64_ADDR16_HIGHER
:
16043 case R_PPC64_ADDR16_HIGHERA
:
16044 case R_PPC64_ADDR16_HIGHEST
:
16045 case R_PPC64_ADDR16_HIGHESTA
:
16046 case R_PPC64_ADDR16_LO
:
16047 case R_PPC64_ADDR16_LO_DS
:
16048 case R_PPC64_ADDR16_HIGHER34
:
16049 case R_PPC64_ADDR16_HIGHERA34
:
16050 case R_PPC64_ADDR16_HIGHEST34
:
16051 case R_PPC64_ADDR16_HIGHESTA34
:
16052 case R_PPC64_ADDR24
:
16053 case R_PPC64_ADDR32
:
16054 case R_PPC64_ADDR64
:
16055 case R_PPC64_UADDR16
:
16056 case R_PPC64_UADDR32
:
16057 case R_PPC64_UADDR64
:
16059 case R_PPC64_D34_LO
:
16060 case R_PPC64_D34_HI30
:
16061 case R_PPC64_D34_HA30
:
16064 if ((input_section
->flags
& SEC_ALLOC
) == 0)
16067 if (NO_OPD_RELOCS
&& is_opd
)
16070 if (bfd_link_pic (info
)
16072 || h
->dyn_relocs
!= NULL
)
16073 && ((h
!= NULL
&& pc_dynrelocs (h
))
16074 || must_be_dyn_reloc (info
, r_type
)))
16076 ? h
->dyn_relocs
!= NULL
16077 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
))
16079 bfd_boolean skip
, relocate
;
16084 /* When generating a dynamic object, these relocations
16085 are copied into the output file to be resolved at run
16091 out_off
= _bfd_elf_section_offset (output_bfd
, info
,
16092 input_section
, rel
->r_offset
);
16093 if (out_off
== (bfd_vma
) -1)
16095 else if (out_off
== (bfd_vma
) -2)
16096 skip
= TRUE
, relocate
= TRUE
;
16097 out_off
+= (input_section
->output_section
->vma
16098 + input_section
->output_offset
);
16099 outrel
.r_offset
= out_off
;
16100 outrel
.r_addend
= rel
->r_addend
;
16102 /* Optimize unaligned reloc use. */
16103 if ((r_type
== R_PPC64_ADDR64
&& (out_off
& 7) != 0)
16104 || (r_type
== R_PPC64_UADDR64
&& (out_off
& 7) == 0))
16105 r_type
^= R_PPC64_ADDR64
^ R_PPC64_UADDR64
;
16106 else if ((r_type
== R_PPC64_ADDR32
&& (out_off
& 3) != 0)
16107 || (r_type
== R_PPC64_UADDR32
&& (out_off
& 3) == 0))
16108 r_type
^= R_PPC64_ADDR32
^ R_PPC64_UADDR32
;
16109 else if ((r_type
== R_PPC64_ADDR16
&& (out_off
& 1) != 0)
16110 || (r_type
== R_PPC64_UADDR16
&& (out_off
& 1) == 0))
16111 r_type
^= R_PPC64_ADDR16
^ R_PPC64_UADDR16
;
16114 memset (&outrel
, 0, sizeof outrel
);
16115 else if (!SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
)
16117 && r_type
!= R_PPC64_TOC
)
16119 indx
= h
->elf
.dynindx
;
16120 BFD_ASSERT (indx
!= -1);
16121 outrel
.r_info
= ELF64_R_INFO (indx
, r_type
);
16125 /* This symbol is local, or marked to become local,
16126 or this is an opd section reloc which must point
16127 at a local function. */
16128 outrel
.r_addend
+= relocation
;
16129 if (r_type
== R_PPC64_ADDR64
|| r_type
== R_PPC64_TOC
)
16131 if (is_opd
&& h
!= NULL
)
16133 /* Lie about opd entries. This case occurs
16134 when building shared libraries and we
16135 reference a function in another shared
16136 lib. The same thing happens for a weak
16137 definition in an application that's
16138 overridden by a strong definition in a
16139 shared lib. (I believe this is a generic
16140 bug in binutils handling of weak syms.)
16141 In these cases we won't use the opd
16142 entry in this lib. */
16143 unresolved_reloc
= FALSE
;
16146 && r_type
== R_PPC64_ADDR64
16148 ? h
->elf
.type
== STT_GNU_IFUNC
16149 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
))
16150 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
16153 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
16155 /* We need to relocate .opd contents for ld.so.
16156 Prelink also wants simple and consistent rules
16157 for relocs. This make all RELATIVE relocs have
16158 *r_offset equal to r_addend. */
16165 ? h
->elf
.type
== STT_GNU_IFUNC
16166 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
16168 info
->callbacks
->einfo
16169 /* xgettext:c-format */
16170 (_("%H: %s for indirect "
16171 "function `%pT' unsupported\n"),
16172 input_bfd
, input_section
, rel
->r_offset
,
16173 ppc64_elf_howto_table
[r_type
]->name
,
16177 else if (r_symndx
== STN_UNDEF
|| bfd_is_abs_section (sec
))
16179 else if (sec
== NULL
|| sec
->owner
== NULL
)
16181 bfd_set_error (bfd_error_bad_value
);
16186 asection
*osec
= sec
->output_section
;
16188 if ((osec
->flags
& SEC_THREAD_LOCAL
) != 0)
16190 /* TLS symbol values are relative to the
16191 TLS segment. Dynamic relocations for
16192 local TLS symbols therefore can't be
16193 reduced to a relocation against their
16194 section symbol because it holds the
16195 address of the section, not a value
16196 relative to the TLS segment. We could
16197 change the .tdata dynamic section symbol
16198 to be zero value but STN_UNDEF works
16199 and is used elsewhere, eg. for TPREL64
16200 GOT relocs against local TLS symbols. */
16201 osec
= htab
->elf
.tls_sec
;
16206 indx
= elf_section_data (osec
)->dynindx
;
16209 if ((osec
->flags
& SEC_READONLY
) == 0
16210 && htab
->elf
.data_index_section
!= NULL
)
16211 osec
= htab
->elf
.data_index_section
;
16213 osec
= htab
->elf
.text_index_section
;
16214 indx
= elf_section_data (osec
)->dynindx
;
16216 BFD_ASSERT (indx
!= 0);
16219 /* We are turning this relocation into one
16220 against a section symbol, so subtract out
16221 the output section's address but not the
16222 offset of the input section in the output
16224 outrel
.r_addend
-= osec
->vma
;
16227 outrel
.r_info
= ELF64_R_INFO (indx
, r_type
);
16231 sreloc
= elf_section_data (input_section
)->sreloc
;
16233 ? h
->elf
.type
== STT_GNU_IFUNC
16234 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
16236 sreloc
= htab
->elf
.irelplt
;
16238 htab
->local_ifunc_resolver
= 1;
16239 else if (is_static_defined (&h
->elf
))
16240 htab
->maybe_local_ifunc_resolver
= 1;
16242 if (sreloc
== NULL
)
16245 if (sreloc
->reloc_count
* sizeof (Elf64_External_Rela
)
16248 loc
= sreloc
->contents
;
16249 loc
+= sreloc
->reloc_count
++ * sizeof (Elf64_External_Rela
);
16250 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
16252 if (!warned_dynamic
16253 && !ppc64_glibc_dynamic_reloc (ELF64_R_TYPE (outrel
.r_info
)))
16255 info
->callbacks
->einfo
16256 /* xgettext:c-format */
16257 (_("%X%P: %pB: %s against %pT "
16258 "is not supported by glibc as a dynamic relocation\n"),
16260 ppc64_elf_howto_table
[ELF64_R_TYPE (outrel
.r_info
)]->name
,
16262 warned_dynamic
= TRUE
;
16265 /* If this reloc is against an external symbol, it will
16266 be computed at runtime, so there's no need to do
16267 anything now. However, for the sake of prelink ensure
16268 that the section contents are a known value. */
16271 unresolved_reloc
= FALSE
;
16272 /* The value chosen here is quite arbitrary as ld.so
16273 ignores section contents except for the special
16274 case of .opd where the contents might be accessed
16275 before relocation. Choose zero, as that won't
16276 cause reloc overflow. */
16279 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
16280 to improve backward compatibility with older
16282 if (r_type
== R_PPC64_ADDR64
)
16283 addend
= outrel
.r_addend
;
16284 /* Adjust pc_relative relocs to have zero in *r_offset. */
16285 else if (ppc64_elf_howto_table
[r_type
]->pc_relative
)
16286 addend
= outrel
.r_offset
;
16292 case R_PPC64_GLOB_DAT
:
16293 case R_PPC64_JMP_SLOT
:
16294 case R_PPC64_JMP_IREL
:
16295 case R_PPC64_RELATIVE
:
16296 /* We shouldn't ever see these dynamic relocs in relocatable
16298 /* Fall through. */
16300 case R_PPC64_PLTGOT16
:
16301 case R_PPC64_PLTGOT16_DS
:
16302 case R_PPC64_PLTGOT16_HA
:
16303 case R_PPC64_PLTGOT16_HI
:
16304 case R_PPC64_PLTGOT16_LO
:
16305 case R_PPC64_PLTGOT16_LO_DS
:
16306 case R_PPC64_PLTREL32
:
16307 case R_PPC64_PLTREL64
:
16308 /* These ones haven't been implemented yet. */
16310 info
->callbacks
->einfo
16311 /* xgettext:c-format */
16312 (_("%P: %pB: %s is not supported for `%pT'\n"),
16314 ppc64_elf_howto_table
[r_type
]->name
, sym_name
);
16316 bfd_set_error (bfd_error_invalid_operation
);
16321 /* Multi-instruction sequences that access the TOC can be
16322 optimized, eg. addis ra,r2,0; addi rb,ra,x;
16323 to nop; addi rb,r2,x; */
16329 case R_PPC64_GOT_TLSLD16_HI
:
16330 case R_PPC64_GOT_TLSGD16_HI
:
16331 case R_PPC64_GOT_TPREL16_HI
:
16332 case R_PPC64_GOT_DTPREL16_HI
:
16333 case R_PPC64_GOT16_HI
:
16334 case R_PPC64_TOC16_HI
:
16335 /* These relocs would only be useful if building up an
16336 offset to later add to r2, perhaps in an indexed
16337 addressing mode instruction. Don't try to optimize.
16338 Unfortunately, the possibility of someone building up an
16339 offset like this or even with the HA relocs, means that
16340 we need to check the high insn when optimizing the low
16344 case R_PPC64_PLTCALL_NOTOC
:
16345 if (!unresolved_reloc
)
16346 htab
->notoc_plt
= 1;
16347 /* Fall through. */
16348 case R_PPC64_PLTCALL
:
16349 if (unresolved_reloc
)
16351 /* No plt entry. Make this into a direct call. */
16352 bfd_byte
*p
= contents
+ rel
->r_offset
;
16353 insn
= bfd_get_32 (input_bfd
, p
);
16355 bfd_put_32 (input_bfd
, B_DOT
| insn
, p
);
16356 if (r_type
== R_PPC64_PLTCALL
)
16357 bfd_put_32 (input_bfd
, NOP
, p
+ 4);
16358 unresolved_reloc
= save_unresolved_reloc
;
16359 r_type
= R_PPC64_REL24
;
16363 case R_PPC64_PLTSEQ_NOTOC
:
16364 case R_PPC64_PLTSEQ
:
16365 if (unresolved_reloc
)
16367 unresolved_reloc
= FALSE
;
16372 case R_PPC64_PLT_PCREL34_NOTOC
:
16373 if (!unresolved_reloc
)
16374 htab
->notoc_plt
= 1;
16375 /* Fall through. */
16376 case R_PPC64_PLT_PCREL34
:
16377 if (unresolved_reloc
)
16379 bfd_byte
*p
= contents
+ rel
->r_offset
;
16380 bfd_put_32 (input_bfd
, PNOP
>> 32, p
);
16381 bfd_put_32 (input_bfd
, PNOP
, p
+ 4);
16382 unresolved_reloc
= FALSE
;
16387 case R_PPC64_PLT16_HA
:
16388 if (unresolved_reloc
)
16390 unresolved_reloc
= FALSE
;
16393 /* Fall through. */
16394 case R_PPC64_GOT_TLSLD16_HA
:
16395 case R_PPC64_GOT_TLSGD16_HA
:
16396 case R_PPC64_GOT_TPREL16_HA
:
16397 case R_PPC64_GOT_DTPREL16_HA
:
16398 case R_PPC64_GOT16_HA
:
16399 case R_PPC64_TOC16_HA
:
16400 if (htab
->do_toc_opt
&& relocation
+ addend
+ 0x8000 < 0x10000
16401 && !ppc64_elf_tdata (input_bfd
)->unexpected_toc_insn
)
16405 p
= contents
+ (rel
->r_offset
& ~3);
16406 bfd_put_32 (input_bfd
, NOP
, p
);
16411 case R_PPC64_PLT16_LO
:
16412 case R_PPC64_PLT16_LO_DS
:
16413 if (unresolved_reloc
)
16415 unresolved_reloc
= FALSE
;
16418 /* Fall through. */
16419 case R_PPC64_GOT_TLSLD16_LO
:
16420 case R_PPC64_GOT_TLSGD16_LO
:
16421 case R_PPC64_GOT_TPREL16_LO_DS
:
16422 case R_PPC64_GOT_DTPREL16_LO_DS
:
16423 case R_PPC64_GOT16_LO
:
16424 case R_PPC64_GOT16_LO_DS
:
16425 case R_PPC64_TOC16_LO
:
16426 case R_PPC64_TOC16_LO_DS
:
16427 if (htab
->do_toc_opt
&& relocation
+ addend
+ 0x8000 < 0x10000
16428 && !ppc64_elf_tdata (input_bfd
)->unexpected_toc_insn
)
16430 bfd_byte
*p
= contents
+ (rel
->r_offset
& ~3);
16431 insn
= bfd_get_32 (input_bfd
, p
);
16432 if ((insn
& (0x3fu
<< 26)) == 12u << 26 /* addic */)
16434 /* Transform addic to addi when we change reg. */
16435 insn
&= ~((0x3fu
<< 26) | (0x1f << 16));
16436 insn
|= (14u << 26) | (2 << 16);
16440 insn
&= ~(0x1f << 16);
16443 bfd_put_32 (input_bfd
, insn
, p
);
16447 case R_PPC64_TPREL16_HA
:
16448 if (htab
->do_tls_opt
&& relocation
+ addend
+ 0x8000 < 0x10000)
16450 bfd_byte
*p
= contents
+ (rel
->r_offset
& ~3);
16451 insn
= bfd_get_32 (input_bfd
, p
);
16452 if ((insn
& ((0x3fu
<< 26) | 0x1f << 16))
16453 != ((15u << 26) | (13 << 16)) /* addis rt,13,imm */)
16454 /* xgettext:c-format */
16455 info
->callbacks
->minfo
16456 (_("%H: warning: %s unexpected insn %#x.\n"),
16457 input_bfd
, input_section
, rel
->r_offset
,
16458 ppc64_elf_howto_table
[r_type
]->name
, insn
);
16461 bfd_put_32 (input_bfd
, NOP
, p
);
16467 case R_PPC64_TPREL16_LO
:
16468 case R_PPC64_TPREL16_LO_DS
:
16469 if (htab
->do_tls_opt
&& relocation
+ addend
+ 0x8000 < 0x10000)
16471 bfd_byte
*p
= contents
+ (rel
->r_offset
& ~3);
16472 insn
= bfd_get_32 (input_bfd
, p
);
16473 insn
&= ~(0x1f << 16);
16475 bfd_put_32 (input_bfd
, insn
, p
);
16480 /* Do any further special processing. */
16486 case R_PPC64_REL16_HA
:
16487 case R_PPC64_REL16_HIGHA
:
16488 case R_PPC64_REL16_HIGHERA
:
16489 case R_PPC64_REL16_HIGHESTA
:
16490 case R_PPC64_REL16DX_HA
:
16491 case R_PPC64_ADDR16_HA
:
16492 case R_PPC64_ADDR16_HIGHA
:
16493 case R_PPC64_ADDR16_HIGHERA
:
16494 case R_PPC64_ADDR16_HIGHESTA
:
16495 case R_PPC64_TOC16_HA
:
16496 case R_PPC64_SECTOFF_HA
:
16497 case R_PPC64_TPREL16_HA
:
16498 case R_PPC64_TPREL16_HIGHA
:
16499 case R_PPC64_TPREL16_HIGHERA
:
16500 case R_PPC64_TPREL16_HIGHESTA
:
16501 case R_PPC64_DTPREL16_HA
:
16502 case R_PPC64_DTPREL16_HIGHA
:
16503 case R_PPC64_DTPREL16_HIGHERA
:
16504 case R_PPC64_DTPREL16_HIGHESTA
:
16505 /* It's just possible that this symbol is a weak symbol
16506 that's not actually defined anywhere. In that case,
16507 'sec' would be NULL, and we should leave the symbol
16508 alone (it will be set to zero elsewhere in the link). */
16511 /* Fall through. */
16513 case R_PPC64_GOT16_HA
:
16514 case R_PPC64_PLTGOT16_HA
:
16515 case R_PPC64_PLT16_HA
:
16516 case R_PPC64_GOT_TLSGD16_HA
:
16517 case R_PPC64_GOT_TLSLD16_HA
:
16518 case R_PPC64_GOT_TPREL16_HA
:
16519 case R_PPC64_GOT_DTPREL16_HA
:
16520 /* Add 0x10000 if sign bit in 0:15 is set.
16521 Bits 0:15 are not used. */
16525 case R_PPC64_D34_HA30
:
16526 case R_PPC64_ADDR16_HIGHERA34
:
16527 case R_PPC64_ADDR16_HIGHESTA34
:
16528 case R_PPC64_REL16_HIGHERA34
:
16529 case R_PPC64_REL16_HIGHESTA34
:
16531 addend
+= 1ULL << 33;
16534 case R_PPC64_ADDR16_DS
:
16535 case R_PPC64_ADDR16_LO_DS
:
16536 case R_PPC64_GOT16_DS
:
16537 case R_PPC64_GOT16_LO_DS
:
16538 case R_PPC64_PLT16_LO_DS
:
16539 case R_PPC64_SECTOFF_DS
:
16540 case R_PPC64_SECTOFF_LO_DS
:
16541 case R_PPC64_TOC16_DS
:
16542 case R_PPC64_TOC16_LO_DS
:
16543 case R_PPC64_PLTGOT16_DS
:
16544 case R_PPC64_PLTGOT16_LO_DS
:
16545 case R_PPC64_GOT_TPREL16_DS
:
16546 case R_PPC64_GOT_TPREL16_LO_DS
:
16547 case R_PPC64_GOT_DTPREL16_DS
:
16548 case R_PPC64_GOT_DTPREL16_LO_DS
:
16549 case R_PPC64_TPREL16_DS
:
16550 case R_PPC64_TPREL16_LO_DS
:
16551 case R_PPC64_DTPREL16_DS
:
16552 case R_PPC64_DTPREL16_LO_DS
:
16553 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
16555 /* If this reloc is against an lq, lxv, or stxv insn, then
16556 the value must be a multiple of 16. This is somewhat of
16557 a hack, but the "correct" way to do this by defining _DQ
16558 forms of all the _DS relocs bloats all reloc switches in
16559 this file. It doesn't make much sense to use these
16560 relocs in data, so testing the insn should be safe. */
16561 if ((insn
& (0x3fu
<< 26)) == (56u << 26)
16562 || ((insn
& (0x3fu
<< 26)) == (61u << 26) && (insn
& 3) == 1))
16564 relocation
+= addend
;
16565 addend
= insn
& (mask
^ 3);
16566 if ((relocation
& mask
) != 0)
16568 relocation
^= relocation
& mask
;
16569 info
->callbacks
->einfo
16570 /* xgettext:c-format */
16571 (_("%H: error: %s not a multiple of %u\n"),
16572 input_bfd
, input_section
, rel
->r_offset
,
16573 ppc64_elf_howto_table
[r_type
]->name
,
16575 bfd_set_error (bfd_error_bad_value
);
16582 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
16583 because such sections are not SEC_ALLOC and thus ld.so will
16584 not process them. */
16585 howto
= ppc64_elf_howto_table
[(int) r_type
];
16586 if (unresolved_reloc
16587 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
16588 && h
->elf
.def_dynamic
)
16589 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
16590 rel
->r_offset
) != (bfd_vma
) -1)
16592 info
->callbacks
->einfo
16593 /* xgettext:c-format */
16594 (_("%H: unresolvable %s against `%pT'\n"),
16595 input_bfd
, input_section
, rel
->r_offset
,
16597 h
->elf
.root
.root
.string
);
16601 /* 16-bit fields in insns mostly have signed values, but a
16602 few insns have 16-bit unsigned values. Really, we should
16603 have different reloc types. */
16604 if (howto
->complain_on_overflow
!= complain_overflow_dont
16605 && howto
->dst_mask
== 0xffff
16606 && (input_section
->flags
& SEC_CODE
) != 0)
16608 enum complain_overflow complain
= complain_overflow_signed
;
16610 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
16611 if ((insn
& (0x3fu
<< 26)) == 10u << 26 /* cmpli */)
16612 complain
= complain_overflow_bitfield
;
16613 else if (howto
->rightshift
== 0
16614 ? ((insn
& (0x3fu
<< 26)) == 28u << 26 /* andi */
16615 || (insn
& (0x3fu
<< 26)) == 24u << 26 /* ori */
16616 || (insn
& (0x3fu
<< 26)) == 26u << 26 /* xori */)
16617 : ((insn
& (0x3fu
<< 26)) == 29u << 26 /* andis */
16618 || (insn
& (0x3fu
<< 26)) == 25u << 26 /* oris */
16619 || (insn
& (0x3fu
<< 26)) == 27u << 26 /* xoris */))
16620 complain
= complain_overflow_unsigned
;
16621 if (howto
->complain_on_overflow
!= complain
)
16623 alt_howto
= *howto
;
16624 alt_howto
.complain_on_overflow
= complain
;
16625 howto
= &alt_howto
;
16631 /* Split field relocs aren't handled by _bfd_final_link_relocate. */
16633 case R_PPC64_D34_LO
:
16634 case R_PPC64_D34_HI30
:
16635 case R_PPC64_D34_HA30
:
16636 case R_PPC64_PCREL34
:
16637 case R_PPC64_GOT_PCREL34
:
16638 case R_PPC64_TPREL34
:
16639 case R_PPC64_DTPREL34
:
16640 case R_PPC64_GOT_TLSGD34
:
16641 case R_PPC64_GOT_TLSLD34
:
16642 case R_PPC64_GOT_TPREL34
:
16643 case R_PPC64_GOT_DTPREL34
:
16644 case R_PPC64_PLT_PCREL34
:
16645 case R_PPC64_PLT_PCREL34_NOTOC
:
16647 case R_PPC64_PCREL28
:
16648 if (rel
->r_offset
+ 8 > input_section
->size
)
16649 r
= bfd_reloc_outofrange
;
16652 relocation
+= addend
;
16653 if (howto
->pc_relative
)
16654 relocation
-= (rel
->r_offset
16655 + input_section
->output_offset
16656 + input_section
->output_section
->vma
);
16657 relocation
>>= howto
->rightshift
;
16659 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
16661 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
16663 pinsn
&= ~howto
->dst_mask
;
16664 pinsn
|= (((relocation
<< 16) | (relocation
& 0xffff))
16665 & howto
->dst_mask
);
16666 bfd_put_32 (input_bfd
, pinsn
>> 32, contents
+ rel
->r_offset
);
16667 bfd_put_32 (input_bfd
, pinsn
, contents
+ rel
->r_offset
+ 4);
16669 if (howto
->complain_on_overflow
== complain_overflow_signed
16670 && (relocation
+ (1ULL << (howto
->bitsize
- 1))
16671 >= 1ULL << howto
->bitsize
))
16672 r
= bfd_reloc_overflow
;
16676 case R_PPC64_REL16DX_HA
:
16677 if (rel
->r_offset
+ 4 > input_section
->size
)
16678 r
= bfd_reloc_outofrange
;
16681 relocation
+= addend
;
16682 relocation
-= (rel
->r_offset
16683 + input_section
->output_offset
16684 + input_section
->output_section
->vma
);
16685 relocation
= (bfd_signed_vma
) relocation
>> 16;
16686 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
16688 insn
|= (relocation
& 0xffc1) | ((relocation
& 0x3e) << 15);
16689 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
16691 if (relocation
+ 0x8000 > 0xffff)
16692 r
= bfd_reloc_overflow
;
16697 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
16698 contents
, rel
->r_offset
,
16699 relocation
, addend
);
16702 if (r
!= bfd_reloc_ok
)
16704 char *more_info
= NULL
;
16705 const char *reloc_name
= howto
->name
;
16707 if (reloc_dest
!= DEST_NORMAL
)
16709 more_info
= bfd_malloc (strlen (reloc_name
) + 8);
16710 if (more_info
!= NULL
)
16712 strcpy (more_info
, reloc_name
);
16713 strcat (more_info
, (reloc_dest
== DEST_OPD
16714 ? " (OPD)" : " (stub)"));
16715 reloc_name
= more_info
;
16719 if (r
== bfd_reloc_overflow
)
16721 /* On code like "if (foo) foo();" don't report overflow
16722 on a branch to zero when foo is undefined. */
16724 && (reloc_dest
== DEST_STUB
16726 && (h
->elf
.root
.type
== bfd_link_hash_undefweak
16727 || h
->elf
.root
.type
== bfd_link_hash_undefined
)
16728 && is_branch_reloc (r_type
))))
16729 info
->callbacks
->reloc_overflow (info
, &h
->elf
.root
,
16730 sym_name
, reloc_name
,
16732 input_bfd
, input_section
,
16737 info
->callbacks
->einfo
16738 /* xgettext:c-format */
16739 (_("%H: %s against `%pT': error %d\n"),
16740 input_bfd
, input_section
, rel
->r_offset
,
16741 reloc_name
, sym_name
, (int) r
);
16744 if (more_info
!= NULL
)
16754 Elf_Internal_Shdr
*rel_hdr
;
16755 size_t deleted
= rel
- wrel
;
16757 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
16758 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
16759 if (rel_hdr
->sh_size
== 0)
16761 /* It is too late to remove an empty reloc section. Leave
16763 ??? What is wrong with an empty section??? */
16764 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
16767 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
16768 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
16769 input_section
->reloc_count
-= deleted
;
16772 /* If we're emitting relocations, then shortly after this function
16773 returns, reloc offsets and addends for this section will be
16774 adjusted. Worse, reloc symbol indices will be for the output
16775 file rather than the input. Save a copy of the relocs for
16776 opd_entry_value. */
16777 if (is_opd
&& (info
->emitrelocations
|| bfd_link_relocatable (info
)))
16780 amt
= input_section
->reloc_count
* sizeof (Elf_Internal_Rela
);
16781 rel
= bfd_alloc (input_bfd
, amt
);
16782 BFD_ASSERT (ppc64_elf_tdata (input_bfd
)->opd
.relocs
== NULL
);
16783 ppc64_elf_tdata (input_bfd
)->opd
.relocs
= rel
;
16786 memcpy (rel
, relocs
, amt
);
16791 /* Adjust the value of any local symbols in opd sections. */
16794 ppc64_elf_output_symbol_hook (struct bfd_link_info
*info
,
16795 const char *name ATTRIBUTE_UNUSED
,
16796 Elf_Internal_Sym
*elfsym
,
16797 asection
*input_sec
,
16798 struct elf_link_hash_entry
*h
)
16800 struct _opd_sec_data
*opd
;
16807 opd
= get_opd_info (input_sec
);
16808 if (opd
== NULL
|| opd
->adjust
== NULL
)
16811 value
= elfsym
->st_value
- input_sec
->output_offset
;
16812 if (!bfd_link_relocatable (info
))
16813 value
-= input_sec
->output_section
->vma
;
16815 adjust
= opd
->adjust
[OPD_NDX (value
)];
16819 elfsym
->st_value
+= adjust
;
16823 /* Finish up dynamic symbol handling. We set the contents of various
16824 dynamic sections here. */
16827 ppc64_elf_finish_dynamic_symbol (bfd
*output_bfd
,
16828 struct bfd_link_info
*info
,
16829 struct elf_link_hash_entry
*h
,
16830 Elf_Internal_Sym
*sym
)
16832 struct ppc_link_hash_table
*htab
;
16833 struct plt_entry
*ent
;
16835 htab
= ppc_hash_table (info
);
16839 if (!htab
->opd_abi
&& !h
->def_regular
)
16840 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
16841 if (ent
->plt
.offset
!= (bfd_vma
) -1)
16843 /* Mark the symbol as undefined, rather than as
16844 defined in glink. Leave the value if there were
16845 any relocations where pointer equality matters
16846 (this is a clue for the dynamic linker, to make
16847 function pointer comparisons work between an
16848 application and shared library), otherwise set it
16850 sym
->st_shndx
= SHN_UNDEF
;
16851 if (!h
->pointer_equality_needed
)
16853 else if (!h
->ref_regular_nonweak
)
16855 /* This breaks function pointer comparisons, but
16856 that is better than breaking tests for a NULL
16857 function pointer. */
16864 && (h
->root
.type
== bfd_link_hash_defined
16865 || h
->root
.type
== bfd_link_hash_defweak
)
16866 && (h
->root
.u
.def
.section
== htab
->elf
.sdynbss
16867 || h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
))
16869 /* This symbol needs a copy reloc. Set it up. */
16870 Elf_Internal_Rela rela
;
16874 if (h
->dynindx
== -1)
16877 rela
.r_offset
= (h
->root
.u
.def
.value
16878 + h
->root
.u
.def
.section
->output_section
->vma
16879 + h
->root
.u
.def
.section
->output_offset
);
16880 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_PPC64_COPY
);
16882 if (h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
16883 srel
= htab
->elf
.sreldynrelro
;
16885 srel
= htab
->elf
.srelbss
;
16886 loc
= srel
->contents
;
16887 loc
+= srel
->reloc_count
++ * sizeof (Elf64_External_Rela
);
16888 bfd_elf64_swap_reloca_out (output_bfd
, &rela
, loc
);
16894 /* Used to decide how to sort relocs in an optimal manner for the
16895 dynamic linker, before writing them out. */
16897 static enum elf_reloc_type_class
16898 ppc64_elf_reloc_type_class (const struct bfd_link_info
*info
,
16899 const asection
*rel_sec
,
16900 const Elf_Internal_Rela
*rela
)
16902 enum elf_ppc64_reloc_type r_type
;
16903 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
16905 if (rel_sec
== htab
->elf
.irelplt
)
16906 return reloc_class_ifunc
;
16908 r_type
= ELF64_R_TYPE (rela
->r_info
);
16911 case R_PPC64_RELATIVE
:
16912 return reloc_class_relative
;
16913 case R_PPC64_JMP_SLOT
:
16914 return reloc_class_plt
;
16916 return reloc_class_copy
;
16918 return reloc_class_normal
;
16922 /* Finish up the dynamic sections. */
16925 ppc64_elf_finish_dynamic_sections (bfd
*output_bfd
,
16926 struct bfd_link_info
*info
)
16928 struct ppc_link_hash_table
*htab
;
16932 htab
= ppc_hash_table (info
);
16936 dynobj
= htab
->elf
.dynobj
;
16937 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
16939 if (htab
->elf
.dynamic_sections_created
)
16941 Elf64_External_Dyn
*dyncon
, *dynconend
;
16943 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
16946 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
16947 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
16948 for (; dyncon
< dynconend
; dyncon
++)
16950 Elf_Internal_Dyn dyn
;
16953 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
16960 case DT_PPC64_GLINK
:
16962 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
16963 /* We stupidly defined DT_PPC64_GLINK to be the start
16964 of glink rather than the first entry point, which is
16965 what ld.so needs, and now have a bigger stub to
16966 support automatic multiple TOCs. */
16967 dyn
.d_un
.d_ptr
+= GLINK_PLTRESOLVE_SIZE (htab
) - 8 * 4;
16971 s
= bfd_get_section_by_name (output_bfd
, ".opd");
16974 dyn
.d_un
.d_ptr
= s
->vma
;
16978 if ((htab
->do_multi_toc
&& htab
->multi_toc_needed
)
16979 || htab
->notoc_plt
)
16980 dyn
.d_un
.d_val
|= PPC64_OPT_MULTI_TOC
;
16981 if (htab
->has_plt_localentry0
)
16982 dyn
.d_un
.d_val
|= PPC64_OPT_LOCALENTRY
;
16985 case DT_PPC64_OPDSZ
:
16986 s
= bfd_get_section_by_name (output_bfd
, ".opd");
16989 dyn
.d_un
.d_val
= s
->size
;
16993 s
= htab
->elf
.splt
;
16994 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
16998 s
= htab
->elf
.srelplt
;
16999 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
17003 dyn
.d_un
.d_val
= htab
->elf
.srelplt
->size
;
17007 if (htab
->local_ifunc_resolver
)
17008 info
->callbacks
->einfo
17009 (_("%X%P: text relocations and GNU indirect "
17010 "functions will result in a segfault at runtime\n"));
17011 else if (htab
->maybe_local_ifunc_resolver
)
17012 info
->callbacks
->einfo
17013 (_("%P: warning: text relocations and GNU indirect "
17014 "functions may result in a segfault at runtime\n"));
17018 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
17022 if (htab
->elf
.sgot
!= NULL
&& htab
->elf
.sgot
->size
!= 0
17023 && htab
->elf
.sgot
->output_section
!= bfd_abs_section_ptr
)
17025 /* Fill in the first entry in the global offset table.
17026 We use it to hold the link-time TOCbase. */
17027 bfd_put_64 (output_bfd
,
17028 elf_gp (output_bfd
) + TOC_BASE_OFF
,
17029 htab
->elf
.sgot
->contents
);
17031 /* Set .got entry size. */
17032 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
17036 if (htab
->elf
.splt
!= NULL
&& htab
->elf
.splt
->size
!= 0
17037 && htab
->elf
.splt
->output_section
!= bfd_abs_section_ptr
)
17039 /* Set .plt entry size. */
17040 elf_section_data (htab
->elf
.splt
->output_section
)->this_hdr
.sh_entsize
17041 = PLT_ENTRY_SIZE (htab
);
17044 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
17045 brlt ourselves if emitrelocations. */
17046 if (htab
->brlt
!= NULL
17047 && htab
->brlt
->reloc_count
!= 0
17048 && !_bfd_elf_link_output_relocs (output_bfd
,
17050 elf_section_data (htab
->brlt
)->rela
.hdr
,
17051 elf_section_data (htab
->brlt
)->relocs
,
17055 if (htab
->glink
!= NULL
17056 && htab
->glink
->reloc_count
!= 0
17057 && !_bfd_elf_link_output_relocs (output_bfd
,
17059 elf_section_data (htab
->glink
)->rela
.hdr
,
17060 elf_section_data (htab
->glink
)->relocs
,
17065 if (htab
->glink_eh_frame
!= NULL
17066 && htab
->glink_eh_frame
->size
!= 0
17067 && htab
->glink_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
17068 && !_bfd_elf_write_section_eh_frame (output_bfd
, info
,
17069 htab
->glink_eh_frame
,
17070 htab
->glink_eh_frame
->contents
))
17073 /* We need to handle writing out multiple GOT sections ourselves,
17074 since we didn't add them to DYNOBJ. We know dynobj is the first
17076 while ((dynobj
= dynobj
->link
.next
) != NULL
)
17080 if (!is_ppc64_elf (dynobj
))
17083 s
= ppc64_elf_tdata (dynobj
)->got
;
17086 && s
->output_section
!= bfd_abs_section_ptr
17087 && !bfd_set_section_contents (output_bfd
, s
->output_section
,
17088 s
->contents
, s
->output_offset
,
17091 s
= ppc64_elf_tdata (dynobj
)->relgot
;
17094 && s
->output_section
!= bfd_abs_section_ptr
17095 && !bfd_set_section_contents (output_bfd
, s
->output_section
,
17096 s
->contents
, s
->output_offset
,
17104 #include "elf64-target.h"
17106 /* FreeBSD support */
17108 #undef TARGET_LITTLE_SYM
17109 #undef TARGET_LITTLE_NAME
17111 #undef TARGET_BIG_SYM
17112 #define TARGET_BIG_SYM powerpc_elf64_fbsd_vec
17113 #undef TARGET_BIG_NAME
17114 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
17117 #define ELF_OSABI ELFOSABI_FREEBSD
17120 #define elf64_bed elf64_powerpc_fbsd_bed
17122 #include "elf64-target.h"