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_section_flags ppc64_elf_section_flags
129 #define elf_backend_merge_symbol_attribute ppc64_elf_merge_symbol_attribute
130 #define elf_backend_merge_symbol ppc64_elf_merge_symbol
131 #define elf_backend_get_reloc_section bfd_get_section_by_name
133 /* The name of the dynamic interpreter. This is put in the .interp
135 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
137 /* The size in bytes of an entry in the procedure linkage table. */
138 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
139 #define LOCAL_PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 16 : 8)
141 /* The initial size of the plt reserved for the dynamic linker. */
142 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
144 /* Offsets to some stack save slots. */
146 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
147 /* This one is dodgy. ELFv2 does not have a linker word, so use the
148 CR save slot. Used only by optimised __tls_get_addr call stub,
149 relying on __tls_get_addr_opt not saving CR.. */
150 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
152 /* TOC base pointers offset from start of TOC. */
153 #define TOC_BASE_OFF 0x8000
154 /* TOC base alignment. */
155 #define TOC_BASE_ALIGN 256
157 /* Offset of tp and dtp pointers from start of TLS block. */
158 #define TP_OFFSET 0x7000
159 #define DTP_OFFSET 0x8000
161 /* .plt call stub instructions. The normal stub is like this, but
162 sometimes the .plt entry crosses a 64k boundary and we need to
163 insert an addi to adjust r11. */
164 #define STD_R2_0R1 0xf8410000 /* std %r2,0+40(%r1) */
165 #define ADDIS_R11_R2 0x3d620000 /* addis %r11,%r2,xxx@ha */
166 #define LD_R12_0R11 0xe98b0000 /* ld %r12,xxx+0@l(%r11) */
167 #define MTCTR_R12 0x7d8903a6 /* mtctr %r12 */
168 #define LD_R2_0R11 0xe84b0000 /* ld %r2,xxx+8@l(%r11) */
169 #define LD_R11_0R11 0xe96b0000 /* ld %r11,xxx+16@l(%r11) */
170 #define BCTR 0x4e800420 /* bctr */
172 #define ADDI_R11_R11 0x396b0000 /* addi %r11,%r11,off@l */
173 #define ADDI_R12_R11 0x398b0000 /* addi %r12,%r11,off@l */
174 #define ADDI_R12_R12 0x398c0000 /* addi %r12,%r12,off@l */
175 #define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
176 #define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
178 #define XOR_R2_R12_R12 0x7d826278 /* xor %r2,%r12,%r12 */
179 #define ADD_R11_R11_R2 0x7d6b1214 /* add %r11,%r11,%r2 */
180 #define XOR_R11_R12_R12 0x7d8b6278 /* xor %r11,%r12,%r12 */
181 #define ADD_R2_R2_R11 0x7c425a14 /* add %r2,%r2,%r11 */
182 #define CMPLDI_R2_0 0x28220000 /* cmpldi %r2,0 */
183 #define BNECTR 0x4ca20420 /* bnectr+ */
184 #define BNECTR_P4 0x4ce20420 /* bnectr+ */
186 #define LD_R12_0R2 0xe9820000 /* ld %r12,xxx+0(%r2) */
187 #define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
188 #define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
190 #define LD_R2_0R1 0xe8410000 /* ld %r2,0(%r1) */
191 #define LD_R2_0R12 0xe84c0000 /* ld %r2,0(%r12) */
192 #define ADD_R2_R2_R12 0x7c426214 /* add %r2,%r2,%r12 */
194 #define LI_R11_0 0x39600000 /* li %r11,0 */
195 #define LIS_R2 0x3c400000 /* lis %r2,xxx@ha */
196 #define LIS_R11 0x3d600000 /* lis %r11,xxx@ha */
197 #define LIS_R12 0x3d800000 /* lis %r12,xxx@ha */
198 #define ADDIS_R2_R12 0x3c4c0000 /* addis %r2,%r12,xxx@ha */
199 #define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
200 #define ADDIS_R12_R11 0x3d8b0000 /* addis %r12,%r11,xxx@ha */
201 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,xxx@ha */
202 #define ORIS_R12_R12_0 0x658c0000 /* oris %r12,%r12,xxx@hi */
203 #define ORI_R11_R11_0 0x616b0000 /* ori %r11,%r11,xxx@l */
204 #define ORI_R12_R12_0 0x618c0000 /* ori %r12,%r12,xxx@l */
205 #define LD_R12_0R12 0xe98c0000 /* ld %r12,xxx@l(%r12) */
206 #define SLDI_R11_R11_34 0x796b1746 /* sldi %r11,%r11,34 */
207 #define SLDI_R12_R12_32 0x799c07c6 /* sldi %r12,%r12,32 */
208 #define LDX_R12_R11_R12 0x7d8b602a /* ldx %r12,%r11,%r12 */
209 #define ADD_R12_R11_R12 0x7d8b6214 /* add %r12,%r11,%r12 */
210 #define PADDI_R12_PC 0x0610000039800000ULL
211 #define PLD_R12_PC 0x04100000e5800000ULL
212 #define PNOP 0x0700000000000000ULL
214 /* __glink_PLTresolve stub instructions. We enter with the index in R0. */
215 #define GLINK_PLTRESOLVE_SIZE(htab) \
216 (8u + (htab->opd_abi ? 11 * 4 : 14 * 4))
220 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
221 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
223 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
224 /* ld %2,(0b-1b)(%11) */
225 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
226 #define ADD_R11_R2_R11 0x7d625a14 /* add %11,%2,%11 */
232 #define MFLR_R0 0x7c0802a6 /* mflr %r0 */
233 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
234 #define SUB_R12_R12_R11 0x7d8b6050 /* subf %r12,%r11,%r12 */
235 #define ADDI_R0_R12 0x380c0000 /* addi %r0,%r12,0 */
236 #define SRDI_R0_R0_2 0x7800f082 /* rldicl %r0,%r0,62,2 */
239 #define NOP 0x60000000
241 /* Some other nops. */
242 #define CROR_151515 0x4def7b82
243 #define CROR_313131 0x4ffffb82
245 /* .glink entries for the first 32k functions are two instructions. */
246 #define LI_R0_0 0x38000000 /* li %r0,0 */
247 #define B_DOT 0x48000000 /* b . */
249 /* After that, we need two instructions to load the index, followed by
251 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
252 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
254 /* Instructions used by the save and restore reg functions. */
255 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
256 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
257 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
258 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
259 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
260 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
261 #define LI_R12_0 0x39800000 /* li %r12,0 */
262 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
263 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
264 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
265 #define BLR 0x4e800020 /* blr */
267 /* Since .opd is an array of descriptors and each entry will end up
268 with identical R_PPC64_RELATIVE relocs, there is really no need to
269 propagate .opd relocs; The dynamic linker should be taught to
270 relocate .opd without reloc entries. */
271 #ifndef NO_OPD_RELOCS
272 #define NO_OPD_RELOCS 0
276 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
280 abiversion (bfd
*abfd
)
282 return elf_elfheader (abfd
)->e_flags
& EF_PPC64_ABI
;
286 set_abiversion (bfd
*abfd
, int ver
)
288 elf_elfheader (abfd
)->e_flags
&= ~EF_PPC64_ABI
;
289 elf_elfheader (abfd
)->e_flags
|= ver
& EF_PPC64_ABI
;
292 /* Relocation HOWTO's. */
293 /* Like other ELF RELA targets that don't apply multiple
294 field-altering relocations to the same localation, src_mask is
295 always zero and pcrel_offset is the same as pc_relative.
296 PowerPC can always use a zero bitpos, even when the field is not at
297 the LSB. For example, a REL24 could use rightshift=2, bisize=24
298 and bitpos=2 which matches the ABI description, or as we do here,
299 rightshift=0, bitsize=26 and bitpos=0. */
300 #define HOW(type, size, bitsize, mask, rightshift, pc_relative, \
301 complain, special_func) \
302 HOWTO (type, rightshift, size, bitsize, pc_relative, 0, \
303 complain_overflow_ ## complain, special_func, \
304 #type, FALSE, 0, mask, pc_relative)
306 static reloc_howto_type
*ppc64_elf_howto_table
[(int) R_PPC64_max
];
308 static reloc_howto_type ppc64_elf_howto_raw
[] =
310 /* This reloc does nothing. */
311 HOW (R_PPC64_NONE
, 3, 0, 0, 0, FALSE
, dont
,
312 bfd_elf_generic_reloc
),
314 /* A standard 32 bit relocation. */
315 HOW (R_PPC64_ADDR32
, 2, 32, 0xffffffff, 0, FALSE
, bitfield
,
316 bfd_elf_generic_reloc
),
318 /* An absolute 26 bit branch; the lower two bits must be zero.
319 FIXME: we don't check that, we just clear them. */
320 HOW (R_PPC64_ADDR24
, 2, 26, 0x03fffffc, 0, FALSE
, bitfield
,
321 bfd_elf_generic_reloc
),
323 /* A standard 16 bit relocation. */
324 HOW (R_PPC64_ADDR16
, 1, 16, 0xffff, 0, FALSE
, bitfield
,
325 bfd_elf_generic_reloc
),
327 /* A 16 bit relocation without overflow. */
328 HOW (R_PPC64_ADDR16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
329 bfd_elf_generic_reloc
),
331 /* Bits 16-31 of an address. */
332 HOW (R_PPC64_ADDR16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
333 bfd_elf_generic_reloc
),
335 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
336 bits, treated as a signed number, is negative. */
337 HOW (R_PPC64_ADDR16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
340 /* An absolute 16 bit branch; the lower two bits must be zero.
341 FIXME: we don't check that, we just clear them. */
342 HOW (R_PPC64_ADDR14
, 2, 16, 0x0000fffc, 0, FALSE
, signed,
343 ppc64_elf_branch_reloc
),
345 /* An absolute 16 bit branch, for which bit 10 should be set to
346 indicate that the branch is expected to be taken. The lower two
347 bits must be zero. */
348 HOW (R_PPC64_ADDR14_BRTAKEN
, 2, 16, 0x0000fffc, 0, FALSE
, signed,
349 ppc64_elf_brtaken_reloc
),
351 /* An absolute 16 bit branch, for which bit 10 should be set to
352 indicate that the branch is not expected to be taken. The lower
353 two bits must be zero. */
354 HOW (R_PPC64_ADDR14_BRNTAKEN
, 2, 16, 0x0000fffc, 0, FALSE
, signed,
355 ppc64_elf_brtaken_reloc
),
357 /* A relative 26 bit branch; the lower two bits must be zero. */
358 HOW (R_PPC64_REL24
, 2, 26, 0x03fffffc, 0, TRUE
, signed,
359 ppc64_elf_branch_reloc
),
361 /* A variant of R_PPC64_REL24, used when r2 is not the toc pointer. */
362 HOW (R_PPC64_REL24_NOTOC
, 2, 26, 0x03fffffc, 0, TRUE
, signed,
363 ppc64_elf_branch_reloc
),
365 /* A relative 16 bit branch; the lower two bits must be zero. */
366 HOW (R_PPC64_REL14
, 2, 16, 0x0000fffc, 0, TRUE
, signed,
367 ppc64_elf_branch_reloc
),
369 /* A relative 16 bit branch. Bit 10 should be set to indicate that
370 the branch is expected to be taken. The lower two bits must be
372 HOW (R_PPC64_REL14_BRTAKEN
, 2, 16, 0x0000fffc, 0, TRUE
, signed,
373 ppc64_elf_brtaken_reloc
),
375 /* A relative 16 bit branch. Bit 10 should be set to indicate that
376 the branch is not expected to be taken. The lower two bits must
378 HOW (R_PPC64_REL14_BRNTAKEN
, 2, 16, 0x0000fffc, 0, TRUE
, signed,
379 ppc64_elf_brtaken_reloc
),
381 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
383 HOW (R_PPC64_GOT16
, 1, 16, 0xffff, 0, FALSE
, signed,
384 ppc64_elf_unhandled_reloc
),
386 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
388 HOW (R_PPC64_GOT16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
389 ppc64_elf_unhandled_reloc
),
391 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
393 HOW (R_PPC64_GOT16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
394 ppc64_elf_unhandled_reloc
),
396 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
398 HOW (R_PPC64_GOT16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
399 ppc64_elf_unhandled_reloc
),
401 /* This is used only by the dynamic linker. The symbol should exist
402 both in the object being run and in some shared library. The
403 dynamic linker copies the data addressed by the symbol from the
404 shared library into the object, because the object being
405 run has to have the data at some particular address. */
406 HOW (R_PPC64_COPY
, 0, 0, 0, 0, FALSE
, dont
,
407 ppc64_elf_unhandled_reloc
),
409 /* Like R_PPC64_ADDR64, but used when setting global offset table
411 HOW (R_PPC64_GLOB_DAT
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
412 ppc64_elf_unhandled_reloc
),
414 /* Created by the link editor. Marks a procedure linkage table
415 entry for a symbol. */
416 HOW (R_PPC64_JMP_SLOT
, 0, 0, 0, 0, FALSE
, dont
,
417 ppc64_elf_unhandled_reloc
),
419 /* Used only by the dynamic linker. When the object is run, this
420 doubleword64 is set to the load address of the object, plus the
422 HOW (R_PPC64_RELATIVE
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
423 bfd_elf_generic_reloc
),
425 /* Like R_PPC64_ADDR32, but may be unaligned. */
426 HOW (R_PPC64_UADDR32
, 2, 32, 0xffffffff, 0, FALSE
, bitfield
,
427 bfd_elf_generic_reloc
),
429 /* Like R_PPC64_ADDR16, but may be unaligned. */
430 HOW (R_PPC64_UADDR16
, 1, 16, 0xffff, 0, FALSE
, bitfield
,
431 bfd_elf_generic_reloc
),
433 /* 32-bit PC relative. */
434 HOW (R_PPC64_REL32
, 2, 32, 0xffffffff, 0, TRUE
, signed,
435 bfd_elf_generic_reloc
),
437 /* 32-bit relocation to the symbol's procedure linkage table. */
438 HOW (R_PPC64_PLT32
, 2, 32, 0xffffffff, 0, FALSE
, bitfield
,
439 ppc64_elf_unhandled_reloc
),
441 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
442 FIXME: R_PPC64_PLTREL32 not supported. */
443 HOW (R_PPC64_PLTREL32
, 2, 32, 0xffffffff, 0, TRUE
, signed,
444 ppc64_elf_unhandled_reloc
),
446 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
448 HOW (R_PPC64_PLT16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
449 ppc64_elf_unhandled_reloc
),
451 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
453 HOW (R_PPC64_PLT16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
454 ppc64_elf_unhandled_reloc
),
456 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
458 HOW (R_PPC64_PLT16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
459 ppc64_elf_unhandled_reloc
),
461 /* 16-bit section relative relocation. */
462 HOW (R_PPC64_SECTOFF
, 1, 16, 0xffff, 0, FALSE
, signed,
463 ppc64_elf_sectoff_reloc
),
465 /* Like R_PPC64_SECTOFF, but no overflow warning. */
466 HOW (R_PPC64_SECTOFF_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
467 ppc64_elf_sectoff_reloc
),
469 /* 16-bit upper half section relative relocation. */
470 HOW (R_PPC64_SECTOFF_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
471 ppc64_elf_sectoff_reloc
),
473 /* 16-bit upper half adjusted section relative relocation. */
474 HOW (R_PPC64_SECTOFF_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
475 ppc64_elf_sectoff_ha_reloc
),
477 /* Like R_PPC64_REL24 without touching the two least significant bits. */
478 HOW (R_PPC64_REL30
, 2, 30, 0xfffffffc, 2, TRUE
, dont
,
479 bfd_elf_generic_reloc
),
481 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
483 /* A standard 64-bit relocation. */
484 HOW (R_PPC64_ADDR64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
485 bfd_elf_generic_reloc
),
487 /* The bits 32-47 of an address. */
488 HOW (R_PPC64_ADDR16_HIGHER
, 1, 16, 0xffff, 32, FALSE
, dont
,
489 bfd_elf_generic_reloc
),
491 /* The bits 32-47 of an address, plus 1 if the contents of the low
492 16 bits, treated as a signed number, is negative. */
493 HOW (R_PPC64_ADDR16_HIGHERA
, 1, 16, 0xffff, 32, FALSE
, dont
,
496 /* The bits 48-63 of an address. */
497 HOW (R_PPC64_ADDR16_HIGHEST
, 1, 16, 0xffff, 48, FALSE
, dont
,
498 bfd_elf_generic_reloc
),
500 /* The bits 48-63 of an address, plus 1 if the contents of the low
501 16 bits, treated as a signed number, is negative. */
502 HOW (R_PPC64_ADDR16_HIGHESTA
, 1, 16, 0xffff, 48, FALSE
, dont
,
505 /* Like ADDR64, but may be unaligned. */
506 HOW (R_PPC64_UADDR64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
507 bfd_elf_generic_reloc
),
509 /* 64-bit relative relocation. */
510 HOW (R_PPC64_REL64
, 4, 64, 0xffffffffffffffffULL
, 0, TRUE
, dont
,
511 bfd_elf_generic_reloc
),
513 /* 64-bit relocation to the symbol's procedure linkage table. */
514 HOW (R_PPC64_PLT64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
515 ppc64_elf_unhandled_reloc
),
517 /* 64-bit PC relative relocation to the symbol's procedure linkage
519 /* FIXME: R_PPC64_PLTREL64 not supported. */
520 HOW (R_PPC64_PLTREL64
, 4, 64, 0xffffffffffffffffULL
, 0, TRUE
, dont
,
521 ppc64_elf_unhandled_reloc
),
523 /* 16 bit TOC-relative relocation. */
524 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
525 HOW (R_PPC64_TOC16
, 1, 16, 0xffff, 0, FALSE
, signed,
526 ppc64_elf_toc_reloc
),
528 /* 16 bit TOC-relative relocation without overflow. */
529 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
530 HOW (R_PPC64_TOC16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
531 ppc64_elf_toc_reloc
),
533 /* 16 bit TOC-relative relocation, high 16 bits. */
534 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
535 HOW (R_PPC64_TOC16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
536 ppc64_elf_toc_reloc
),
538 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
539 contents of the low 16 bits, treated as a signed number, is
541 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
542 HOW (R_PPC64_TOC16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
543 ppc64_elf_toc_ha_reloc
),
545 /* 64-bit relocation; insert value of TOC base (.TOC.). */
546 /* R_PPC64_TOC 51 doubleword64 .TOC. */
547 HOW (R_PPC64_TOC
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
548 ppc64_elf_toc64_reloc
),
550 /* Like R_PPC64_GOT16, but also informs the link editor that the
551 value to relocate may (!) refer to a PLT entry which the link
552 editor (a) may replace with the symbol value. If the link editor
553 is unable to fully resolve the symbol, it may (b) create a PLT
554 entry and store the address to the new PLT entry in the GOT.
555 This permits lazy resolution of function symbols at run time.
556 The link editor may also skip all of this and just (c) emit a
557 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
558 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
559 HOW (R_PPC64_PLTGOT16
, 1, 16, 0xffff, 0, FALSE
,signed,
560 ppc64_elf_unhandled_reloc
),
562 /* Like R_PPC64_PLTGOT16, but without overflow. */
563 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
564 HOW (R_PPC64_PLTGOT16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
565 ppc64_elf_unhandled_reloc
),
567 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
568 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
569 HOW (R_PPC64_PLTGOT16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
570 ppc64_elf_unhandled_reloc
),
572 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
573 1 if the contents of the low 16 bits, treated as a signed number,
575 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
576 HOW (R_PPC64_PLTGOT16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
577 ppc64_elf_unhandled_reloc
),
579 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
580 HOW (R_PPC64_ADDR16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
581 bfd_elf_generic_reloc
),
583 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
584 HOW (R_PPC64_ADDR16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
585 bfd_elf_generic_reloc
),
587 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
588 HOW (R_PPC64_GOT16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
589 ppc64_elf_unhandled_reloc
),
591 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
592 HOW (R_PPC64_GOT16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
593 ppc64_elf_unhandled_reloc
),
595 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
596 HOW (R_PPC64_PLT16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
597 ppc64_elf_unhandled_reloc
),
599 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
600 HOW (R_PPC64_SECTOFF_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
601 ppc64_elf_sectoff_reloc
),
603 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
604 HOW (R_PPC64_SECTOFF_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
605 ppc64_elf_sectoff_reloc
),
607 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
608 HOW (R_PPC64_TOC16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
609 ppc64_elf_toc_reloc
),
611 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
612 HOW (R_PPC64_TOC16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
613 ppc64_elf_toc_reloc
),
615 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
616 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
617 HOW (R_PPC64_PLTGOT16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
618 ppc64_elf_unhandled_reloc
),
620 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
621 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
622 HOW (R_PPC64_PLTGOT16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
623 ppc64_elf_unhandled_reloc
),
625 /* Marker relocs for TLS. */
626 HOW (R_PPC64_TLS
, 2, 32, 0, 0, FALSE
, dont
,
627 bfd_elf_generic_reloc
),
629 HOW (R_PPC64_TLSGD
, 2, 32, 0, 0, FALSE
, dont
,
630 bfd_elf_generic_reloc
),
632 HOW (R_PPC64_TLSLD
, 2, 32, 0, 0, FALSE
, dont
,
633 bfd_elf_generic_reloc
),
635 /* Marker reloc for optimizing r2 save in prologue rather than on
636 each plt call stub. */
637 HOW (R_PPC64_TOCSAVE
, 2, 32, 0, 0, FALSE
, dont
,
638 bfd_elf_generic_reloc
),
640 /* Marker relocs on inline plt call instructions. */
641 HOW (R_PPC64_PLTSEQ
, 2, 32, 0, 0, FALSE
, dont
,
642 bfd_elf_generic_reloc
),
644 HOW (R_PPC64_PLTCALL
, 2, 32, 0, 0, FALSE
, dont
,
645 bfd_elf_generic_reloc
),
647 /* Computes the load module index of the load module that contains the
648 definition of its TLS sym. */
649 HOW (R_PPC64_DTPMOD64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
650 ppc64_elf_unhandled_reloc
),
652 /* Computes a dtv-relative displacement, the difference between the value
653 of sym+add and the base address of the thread-local storage block that
654 contains the definition of sym, minus 0x8000. */
655 HOW (R_PPC64_DTPREL64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
656 ppc64_elf_unhandled_reloc
),
658 /* A 16 bit dtprel reloc. */
659 HOW (R_PPC64_DTPREL16
, 1, 16, 0xffff, 0, FALSE
, signed,
660 ppc64_elf_unhandled_reloc
),
662 /* Like DTPREL16, but no overflow. */
663 HOW (R_PPC64_DTPREL16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
664 ppc64_elf_unhandled_reloc
),
666 /* Like DTPREL16_LO, but next higher group of 16 bits. */
667 HOW (R_PPC64_DTPREL16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
668 ppc64_elf_unhandled_reloc
),
670 /* Like DTPREL16_HI, but adjust for low 16 bits. */
671 HOW (R_PPC64_DTPREL16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
672 ppc64_elf_unhandled_reloc
),
674 /* Like DTPREL16_HI, but next higher group of 16 bits. */
675 HOW (R_PPC64_DTPREL16_HIGHER
, 1, 16, 0xffff, 32, FALSE
, dont
,
676 ppc64_elf_unhandled_reloc
),
678 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
679 HOW (R_PPC64_DTPREL16_HIGHERA
, 1, 16, 0xffff, 32, FALSE
, dont
,
680 ppc64_elf_unhandled_reloc
),
682 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
683 HOW (R_PPC64_DTPREL16_HIGHEST
, 1, 16, 0xffff, 48, FALSE
, dont
,
684 ppc64_elf_unhandled_reloc
),
686 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
687 HOW (R_PPC64_DTPREL16_HIGHESTA
, 1, 16, 0xffff, 48, FALSE
, dont
,
688 ppc64_elf_unhandled_reloc
),
690 /* Like DTPREL16, but for insns with a DS field. */
691 HOW (R_PPC64_DTPREL16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
692 ppc64_elf_unhandled_reloc
),
694 /* Like DTPREL16_DS, but no overflow. */
695 HOW (R_PPC64_DTPREL16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
696 ppc64_elf_unhandled_reloc
),
698 /* Computes a tp-relative displacement, the difference between the value of
699 sym+add and the value of the thread pointer (r13). */
700 HOW (R_PPC64_TPREL64
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
701 ppc64_elf_unhandled_reloc
),
703 /* A 16 bit tprel reloc. */
704 HOW (R_PPC64_TPREL16
, 1, 16, 0xffff, 0, FALSE
, signed,
705 ppc64_elf_unhandled_reloc
),
707 /* Like TPREL16, but no overflow. */
708 HOW (R_PPC64_TPREL16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
709 ppc64_elf_unhandled_reloc
),
711 /* Like TPREL16_LO, but next higher group of 16 bits. */
712 HOW (R_PPC64_TPREL16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
713 ppc64_elf_unhandled_reloc
),
715 /* Like TPREL16_HI, but adjust for low 16 bits. */
716 HOW (R_PPC64_TPREL16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
717 ppc64_elf_unhandled_reloc
),
719 /* Like TPREL16_HI, but next higher group of 16 bits. */
720 HOW (R_PPC64_TPREL16_HIGHER
, 1, 16, 0xffff, 32, FALSE
, dont
,
721 ppc64_elf_unhandled_reloc
),
723 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
724 HOW (R_PPC64_TPREL16_HIGHERA
, 1, 16, 0xffff, 32, FALSE
, dont
,
725 ppc64_elf_unhandled_reloc
),
727 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
728 HOW (R_PPC64_TPREL16_HIGHEST
, 1, 16, 0xffff, 48, FALSE
, dont
,
729 ppc64_elf_unhandled_reloc
),
731 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
732 HOW (R_PPC64_TPREL16_HIGHESTA
, 1, 16, 0xffff, 48, FALSE
, dont
,
733 ppc64_elf_unhandled_reloc
),
735 /* Like TPREL16, but for insns with a DS field. */
736 HOW (R_PPC64_TPREL16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
737 ppc64_elf_unhandled_reloc
),
739 /* Like TPREL16_DS, but no overflow. */
740 HOW (R_PPC64_TPREL16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
741 ppc64_elf_unhandled_reloc
),
743 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
744 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
745 to the first entry relative to the TOC base (r2). */
746 HOW (R_PPC64_GOT_TLSGD16
, 1, 16, 0xffff, 0, FALSE
, signed,
747 ppc64_elf_unhandled_reloc
),
749 /* Like GOT_TLSGD16, but no overflow. */
750 HOW (R_PPC64_GOT_TLSGD16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
751 ppc64_elf_unhandled_reloc
),
753 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
754 HOW (R_PPC64_GOT_TLSGD16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
755 ppc64_elf_unhandled_reloc
),
757 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
758 HOW (R_PPC64_GOT_TLSGD16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
759 ppc64_elf_unhandled_reloc
),
761 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
762 with values (sym+add)@dtpmod and zero, and computes the offset to the
763 first entry relative to the TOC base (r2). */
764 HOW (R_PPC64_GOT_TLSLD16
, 1, 16, 0xffff, 0, FALSE
, signed,
765 ppc64_elf_unhandled_reloc
),
767 /* Like GOT_TLSLD16, but no overflow. */
768 HOW (R_PPC64_GOT_TLSLD16_LO
, 1, 16, 0xffff, 0, FALSE
, dont
,
769 ppc64_elf_unhandled_reloc
),
771 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
772 HOW (R_PPC64_GOT_TLSLD16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
773 ppc64_elf_unhandled_reloc
),
775 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
776 HOW (R_PPC64_GOT_TLSLD16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
777 ppc64_elf_unhandled_reloc
),
779 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
780 the offset to the entry relative to the TOC base (r2). */
781 HOW (R_PPC64_GOT_DTPREL16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
782 ppc64_elf_unhandled_reloc
),
784 /* Like GOT_DTPREL16_DS, but no overflow. */
785 HOW (R_PPC64_GOT_DTPREL16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
786 ppc64_elf_unhandled_reloc
),
788 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
789 HOW (R_PPC64_GOT_DTPREL16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
790 ppc64_elf_unhandled_reloc
),
792 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
793 HOW (R_PPC64_GOT_DTPREL16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
794 ppc64_elf_unhandled_reloc
),
796 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
797 offset to the entry relative to the TOC base (r2). */
798 HOW (R_PPC64_GOT_TPREL16_DS
, 1, 16, 0xfffc, 0, FALSE
, signed,
799 ppc64_elf_unhandled_reloc
),
801 /* Like GOT_TPREL16_DS, but no overflow. */
802 HOW (R_PPC64_GOT_TPREL16_LO_DS
, 1, 16, 0xfffc, 0, FALSE
, dont
,
803 ppc64_elf_unhandled_reloc
),
805 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
806 HOW (R_PPC64_GOT_TPREL16_HI
, 1, 16, 0xffff, 16, FALSE
, signed,
807 ppc64_elf_unhandled_reloc
),
809 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
810 HOW (R_PPC64_GOT_TPREL16_HA
, 1, 16, 0xffff, 16, FALSE
, signed,
811 ppc64_elf_unhandled_reloc
),
813 HOW (R_PPC64_JMP_IREL
, 0, 0, 0, 0, FALSE
, dont
,
814 ppc64_elf_unhandled_reloc
),
816 HOW (R_PPC64_IRELATIVE
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
817 bfd_elf_generic_reloc
),
819 /* A 16 bit relative relocation. */
820 HOW (R_PPC64_REL16
, 1, 16, 0xffff, 0, TRUE
, signed,
821 bfd_elf_generic_reloc
),
823 /* A 16 bit relative relocation without overflow. */
824 HOW (R_PPC64_REL16_LO
, 1, 16, 0xffff, 0, TRUE
, dont
,
825 bfd_elf_generic_reloc
),
827 /* The high order 16 bits of a relative address. */
828 HOW (R_PPC64_REL16_HI
, 1, 16, 0xffff, 16, TRUE
, signed,
829 bfd_elf_generic_reloc
),
831 /* The high order 16 bits of a relative address, plus 1 if the contents of
832 the low 16 bits, treated as a signed number, is negative. */
833 HOW (R_PPC64_REL16_HA
, 1, 16, 0xffff, 16, TRUE
, signed,
836 HOW (R_PPC64_REL16_HIGH
, 1, 16, 0xffff, 16, TRUE
, dont
,
837 bfd_elf_generic_reloc
),
839 HOW (R_PPC64_REL16_HIGHA
, 1, 16, 0xffff, 16, TRUE
, dont
,
842 HOW (R_PPC64_REL16_HIGHER
, 1, 16, 0xffff, 32, TRUE
, dont
,
843 bfd_elf_generic_reloc
),
845 HOW (R_PPC64_REL16_HIGHERA
, 1, 16, 0xffff, 32, TRUE
, dont
,
848 HOW (R_PPC64_REL16_HIGHEST
, 1, 16, 0xffff, 48, TRUE
, dont
,
849 bfd_elf_generic_reloc
),
851 HOW (R_PPC64_REL16_HIGHESTA
, 1, 16, 0xffff, 48, TRUE
, dont
,
854 /* Like R_PPC64_REL16_HA but for split field in addpcis. */
855 HOW (R_PPC64_REL16DX_HA
, 2, 16, 0x1fffc1, 16, TRUE
, signed,
858 /* A split-field reloc for addpcis, non-relative (gas internal use only). */
859 HOW (R_PPC64_16DX_HA
, 2, 16, 0x1fffc1, 16, FALSE
, signed,
862 /* Like R_PPC64_ADDR16_HI, but no overflow. */
863 HOW (R_PPC64_ADDR16_HIGH
, 1, 16, 0xffff, 16, FALSE
, dont
,
864 bfd_elf_generic_reloc
),
866 /* Like R_PPC64_ADDR16_HA, but no overflow. */
867 HOW (R_PPC64_ADDR16_HIGHA
, 1, 16, 0xffff, 16, FALSE
, dont
,
870 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
871 HOW (R_PPC64_DTPREL16_HIGH
, 1, 16, 0xffff, 16, FALSE
, dont
,
872 ppc64_elf_unhandled_reloc
),
874 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
875 HOW (R_PPC64_DTPREL16_HIGHA
, 1, 16, 0xffff, 16, FALSE
, dont
,
876 ppc64_elf_unhandled_reloc
),
878 /* Like R_PPC64_TPREL16_HI, but no overflow. */
879 HOW (R_PPC64_TPREL16_HIGH
, 1, 16, 0xffff, 16, FALSE
, dont
,
880 ppc64_elf_unhandled_reloc
),
882 /* Like R_PPC64_TPREL16_HA, but no overflow. */
883 HOW (R_PPC64_TPREL16_HIGHA
, 1, 16, 0xffff, 16, FALSE
, dont
,
884 ppc64_elf_unhandled_reloc
),
886 /* Marker reloc on ELFv2 large-model function entry. */
887 HOW (R_PPC64_ENTRY
, 2, 32, 0, 0, FALSE
, dont
,
888 bfd_elf_generic_reloc
),
890 /* Like ADDR64, but use local entry point of function. */
891 HOW (R_PPC64_ADDR64_LOCAL
, 4, 64, 0xffffffffffffffffULL
, 0, FALSE
, dont
,
892 bfd_elf_generic_reloc
),
894 HOW (R_PPC64_PLTSEQ_NOTOC
, 2, 32, 0, 0, FALSE
, dont
,
895 bfd_elf_generic_reloc
),
897 HOW (R_PPC64_PLTCALL_NOTOC
, 2, 32, 0, 0, FALSE
, dont
,
898 bfd_elf_generic_reloc
),
900 HOW (R_PPC64_PCREL_OPT
, 2, 32, 0, 0, FALSE
, dont
,
901 bfd_elf_generic_reloc
),
903 HOW (R_PPC64_D34
, 4, 34, 0x3ffff0000ffffULL
, 0, FALSE
, signed,
904 ppc64_elf_prefix_reloc
),
906 HOW (R_PPC64_D34_LO
, 4, 34, 0x3ffff0000ffffULL
, 0, FALSE
, dont
,
907 ppc64_elf_prefix_reloc
),
909 HOW (R_PPC64_D34_HI30
, 4, 34, 0x3ffff0000ffffULL
, 34, FALSE
, dont
,
910 ppc64_elf_prefix_reloc
),
912 HOW (R_PPC64_D34_HA30
, 4, 34, 0x3ffff0000ffffULL
, 34, FALSE
, dont
,
913 ppc64_elf_prefix_reloc
),
915 HOW (R_PPC64_PCREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
916 ppc64_elf_prefix_reloc
),
918 HOW (R_PPC64_GOT_PCREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
919 ppc64_elf_unhandled_reloc
),
921 HOW (R_PPC64_PLT_PCREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
922 ppc64_elf_unhandled_reloc
),
924 HOW (R_PPC64_PLT_PCREL34_NOTOC
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
925 ppc64_elf_unhandled_reloc
),
927 HOW (R_PPC64_TPREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, FALSE
, signed,
928 ppc64_elf_unhandled_reloc
),
930 HOW (R_PPC64_DTPREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, FALSE
, signed,
931 ppc64_elf_unhandled_reloc
),
933 HOW (R_PPC64_GOT_TLSGD34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
934 ppc64_elf_unhandled_reloc
),
936 HOW (R_PPC64_GOT_TLSLD34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
937 ppc64_elf_unhandled_reloc
),
939 HOW (R_PPC64_GOT_TPREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
940 ppc64_elf_unhandled_reloc
),
942 HOW (R_PPC64_GOT_DTPREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
943 ppc64_elf_unhandled_reloc
),
945 HOW (R_PPC64_ADDR16_HIGHER34
, 1, 16, 0xffff, 34, FALSE
, dont
,
946 bfd_elf_generic_reloc
),
948 HOW (R_PPC64_ADDR16_HIGHERA34
, 1, 16, 0xffff, 34, FALSE
, dont
,
951 HOW (R_PPC64_ADDR16_HIGHEST34
, 1, 16, 0xffff, 50, FALSE
, dont
,
952 bfd_elf_generic_reloc
),
954 HOW (R_PPC64_ADDR16_HIGHESTA34
, 1, 16, 0xffff, 50, FALSE
, dont
,
957 HOW (R_PPC64_REL16_HIGHER34
, 1, 16, 0xffff, 34, TRUE
, dont
,
958 bfd_elf_generic_reloc
),
960 HOW (R_PPC64_REL16_HIGHERA34
, 1, 16, 0xffff, 34, TRUE
, dont
,
963 HOW (R_PPC64_REL16_HIGHEST34
, 1, 16, 0xffff, 50, TRUE
, dont
,
964 bfd_elf_generic_reloc
),
966 HOW (R_PPC64_REL16_HIGHESTA34
, 1, 16, 0xffff, 50, TRUE
, dont
,
969 HOW (R_PPC64_D28
, 4, 28, 0xfff0000ffffULL
, 0, FALSE
, signed,
970 ppc64_elf_prefix_reloc
),
972 HOW (R_PPC64_PCREL28
, 4, 28, 0xfff0000ffffULL
, 0, TRUE
, signed,
973 ppc64_elf_prefix_reloc
),
975 /* GNU extension to record C++ vtable hierarchy. */
976 HOW (R_PPC64_GNU_VTINHERIT
, 0, 0, 0, 0, FALSE
, dont
,
979 /* GNU extension to record C++ vtable member usage. */
980 HOW (R_PPC64_GNU_VTENTRY
, 0, 0, 0, 0, FALSE
, dont
,
985 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
989 ppc_howto_init (void)
991 unsigned int i
, type
;
993 for (i
= 0; i
< ARRAY_SIZE (ppc64_elf_howto_raw
); i
++)
995 type
= ppc64_elf_howto_raw
[i
].type
;
996 BFD_ASSERT (type
< ARRAY_SIZE (ppc64_elf_howto_table
));
997 ppc64_elf_howto_table
[type
] = &ppc64_elf_howto_raw
[i
];
1001 static reloc_howto_type
*
1002 ppc64_elf_reloc_type_lookup (bfd
*abfd
,
1003 bfd_reloc_code_real_type code
)
1005 enum elf_ppc64_reloc_type r
= R_PPC64_NONE
;
1007 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
1008 /* Initialize howto table if needed. */
1014 /* xgettext:c-format */
1015 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd
,
1017 bfd_set_error (bfd_error_bad_value
);
1020 case BFD_RELOC_NONE
: r
= R_PPC64_NONE
;
1022 case BFD_RELOC_32
: r
= R_PPC64_ADDR32
;
1024 case BFD_RELOC_PPC_BA26
: r
= R_PPC64_ADDR24
;
1026 case BFD_RELOC_16
: r
= R_PPC64_ADDR16
;
1028 case BFD_RELOC_LO16
: r
= R_PPC64_ADDR16_LO
;
1030 case BFD_RELOC_HI16
: r
= R_PPC64_ADDR16_HI
;
1032 case BFD_RELOC_PPC64_ADDR16_HIGH
: r
= R_PPC64_ADDR16_HIGH
;
1034 case BFD_RELOC_HI16_S
: r
= R_PPC64_ADDR16_HA
;
1036 case BFD_RELOC_PPC64_ADDR16_HIGHA
: r
= R_PPC64_ADDR16_HIGHA
;
1038 case BFD_RELOC_PPC_BA16
: r
= R_PPC64_ADDR14
;
1040 case BFD_RELOC_PPC_BA16_BRTAKEN
: r
= R_PPC64_ADDR14_BRTAKEN
;
1042 case BFD_RELOC_PPC_BA16_BRNTAKEN
: r
= R_PPC64_ADDR14_BRNTAKEN
;
1044 case BFD_RELOC_PPC_B26
: r
= R_PPC64_REL24
;
1046 case BFD_RELOC_PPC64_REL24_NOTOC
: r
= R_PPC64_REL24_NOTOC
;
1048 case BFD_RELOC_PPC_B16
: r
= R_PPC64_REL14
;
1050 case BFD_RELOC_PPC_B16_BRTAKEN
: r
= R_PPC64_REL14_BRTAKEN
;
1052 case BFD_RELOC_PPC_B16_BRNTAKEN
: r
= R_PPC64_REL14_BRNTAKEN
;
1054 case BFD_RELOC_16_GOTOFF
: r
= R_PPC64_GOT16
;
1056 case BFD_RELOC_LO16_GOTOFF
: r
= R_PPC64_GOT16_LO
;
1058 case BFD_RELOC_HI16_GOTOFF
: r
= R_PPC64_GOT16_HI
;
1060 case BFD_RELOC_HI16_S_GOTOFF
: r
= R_PPC64_GOT16_HA
;
1062 case BFD_RELOC_PPC_COPY
: r
= R_PPC64_COPY
;
1064 case BFD_RELOC_PPC_GLOB_DAT
: r
= R_PPC64_GLOB_DAT
;
1066 case BFD_RELOC_32_PCREL
: r
= R_PPC64_REL32
;
1068 case BFD_RELOC_32_PLTOFF
: r
= R_PPC64_PLT32
;
1070 case BFD_RELOC_32_PLT_PCREL
: r
= R_PPC64_PLTREL32
;
1072 case BFD_RELOC_LO16_PLTOFF
: r
= R_PPC64_PLT16_LO
;
1074 case BFD_RELOC_HI16_PLTOFF
: r
= R_PPC64_PLT16_HI
;
1076 case BFD_RELOC_HI16_S_PLTOFF
: r
= R_PPC64_PLT16_HA
;
1078 case BFD_RELOC_16_BASEREL
: r
= R_PPC64_SECTOFF
;
1080 case BFD_RELOC_LO16_BASEREL
: r
= R_PPC64_SECTOFF_LO
;
1082 case BFD_RELOC_HI16_BASEREL
: r
= R_PPC64_SECTOFF_HI
;
1084 case BFD_RELOC_HI16_S_BASEREL
: r
= R_PPC64_SECTOFF_HA
;
1086 case BFD_RELOC_CTOR
: r
= R_PPC64_ADDR64
;
1088 case BFD_RELOC_64
: r
= R_PPC64_ADDR64
;
1090 case BFD_RELOC_PPC64_HIGHER
: r
= R_PPC64_ADDR16_HIGHER
;
1092 case BFD_RELOC_PPC64_HIGHER_S
: r
= R_PPC64_ADDR16_HIGHERA
;
1094 case BFD_RELOC_PPC64_HIGHEST
: r
= R_PPC64_ADDR16_HIGHEST
;
1096 case BFD_RELOC_PPC64_HIGHEST_S
: r
= R_PPC64_ADDR16_HIGHESTA
;
1098 case BFD_RELOC_64_PCREL
: r
= R_PPC64_REL64
;
1100 case BFD_RELOC_64_PLTOFF
: r
= R_PPC64_PLT64
;
1102 case BFD_RELOC_64_PLT_PCREL
: r
= R_PPC64_PLTREL64
;
1104 case BFD_RELOC_PPC_TOC16
: r
= R_PPC64_TOC16
;
1106 case BFD_RELOC_PPC64_TOC16_LO
: r
= R_PPC64_TOC16_LO
;
1108 case BFD_RELOC_PPC64_TOC16_HI
: r
= R_PPC64_TOC16_HI
;
1110 case BFD_RELOC_PPC64_TOC16_HA
: r
= R_PPC64_TOC16_HA
;
1112 case BFD_RELOC_PPC64_TOC
: r
= R_PPC64_TOC
;
1114 case BFD_RELOC_PPC64_PLTGOT16
: r
= R_PPC64_PLTGOT16
;
1116 case BFD_RELOC_PPC64_PLTGOT16_LO
: r
= R_PPC64_PLTGOT16_LO
;
1118 case BFD_RELOC_PPC64_PLTGOT16_HI
: r
= R_PPC64_PLTGOT16_HI
;
1120 case BFD_RELOC_PPC64_PLTGOT16_HA
: r
= R_PPC64_PLTGOT16_HA
;
1122 case BFD_RELOC_PPC64_ADDR16_DS
: r
= R_PPC64_ADDR16_DS
;
1124 case BFD_RELOC_PPC64_ADDR16_LO_DS
: r
= R_PPC64_ADDR16_LO_DS
;
1126 case BFD_RELOC_PPC64_GOT16_DS
: r
= R_PPC64_GOT16_DS
;
1128 case BFD_RELOC_PPC64_GOT16_LO_DS
: r
= R_PPC64_GOT16_LO_DS
;
1130 case BFD_RELOC_PPC64_PLT16_LO_DS
: r
= R_PPC64_PLT16_LO_DS
;
1132 case BFD_RELOC_PPC64_SECTOFF_DS
: r
= R_PPC64_SECTOFF_DS
;
1134 case BFD_RELOC_PPC64_SECTOFF_LO_DS
: r
= R_PPC64_SECTOFF_LO_DS
;
1136 case BFD_RELOC_PPC64_TOC16_DS
: r
= R_PPC64_TOC16_DS
;
1138 case BFD_RELOC_PPC64_TOC16_LO_DS
: r
= R_PPC64_TOC16_LO_DS
;
1140 case BFD_RELOC_PPC64_PLTGOT16_DS
: r
= R_PPC64_PLTGOT16_DS
;
1142 case BFD_RELOC_PPC64_PLTGOT16_LO_DS
: r
= R_PPC64_PLTGOT16_LO_DS
;
1144 case BFD_RELOC_PPC64_TLS_PCREL
:
1145 case BFD_RELOC_PPC_TLS
: r
= R_PPC64_TLS
;
1147 case BFD_RELOC_PPC_TLSGD
: r
= R_PPC64_TLSGD
;
1149 case BFD_RELOC_PPC_TLSLD
: r
= R_PPC64_TLSLD
;
1151 case BFD_RELOC_PPC_DTPMOD
: r
= R_PPC64_DTPMOD64
;
1153 case BFD_RELOC_PPC_TPREL16
: r
= R_PPC64_TPREL16
;
1155 case BFD_RELOC_PPC_TPREL16_LO
: r
= R_PPC64_TPREL16_LO
;
1157 case BFD_RELOC_PPC_TPREL16_HI
: r
= R_PPC64_TPREL16_HI
;
1159 case BFD_RELOC_PPC64_TPREL16_HIGH
: r
= R_PPC64_TPREL16_HIGH
;
1161 case BFD_RELOC_PPC_TPREL16_HA
: r
= R_PPC64_TPREL16_HA
;
1163 case BFD_RELOC_PPC64_TPREL16_HIGHA
: r
= R_PPC64_TPREL16_HIGHA
;
1165 case BFD_RELOC_PPC_TPREL
: r
= R_PPC64_TPREL64
;
1167 case BFD_RELOC_PPC_DTPREL16
: r
= R_PPC64_DTPREL16
;
1169 case BFD_RELOC_PPC_DTPREL16_LO
: r
= R_PPC64_DTPREL16_LO
;
1171 case BFD_RELOC_PPC_DTPREL16_HI
: r
= R_PPC64_DTPREL16_HI
;
1173 case BFD_RELOC_PPC64_DTPREL16_HIGH
: r
= R_PPC64_DTPREL16_HIGH
;
1175 case BFD_RELOC_PPC_DTPREL16_HA
: r
= R_PPC64_DTPREL16_HA
;
1177 case BFD_RELOC_PPC64_DTPREL16_HIGHA
: r
= R_PPC64_DTPREL16_HIGHA
;
1179 case BFD_RELOC_PPC_DTPREL
: r
= R_PPC64_DTPREL64
;
1181 case BFD_RELOC_PPC_GOT_TLSGD16
: r
= R_PPC64_GOT_TLSGD16
;
1183 case BFD_RELOC_PPC_GOT_TLSGD16_LO
: r
= R_PPC64_GOT_TLSGD16_LO
;
1185 case BFD_RELOC_PPC_GOT_TLSGD16_HI
: r
= R_PPC64_GOT_TLSGD16_HI
;
1187 case BFD_RELOC_PPC_GOT_TLSGD16_HA
: r
= R_PPC64_GOT_TLSGD16_HA
;
1189 case BFD_RELOC_PPC_GOT_TLSLD16
: r
= R_PPC64_GOT_TLSLD16
;
1191 case BFD_RELOC_PPC_GOT_TLSLD16_LO
: r
= R_PPC64_GOT_TLSLD16_LO
;
1193 case BFD_RELOC_PPC_GOT_TLSLD16_HI
: r
= R_PPC64_GOT_TLSLD16_HI
;
1195 case BFD_RELOC_PPC_GOT_TLSLD16_HA
: r
= R_PPC64_GOT_TLSLD16_HA
;
1197 case BFD_RELOC_PPC_GOT_TPREL16
: r
= R_PPC64_GOT_TPREL16_DS
;
1199 case BFD_RELOC_PPC_GOT_TPREL16_LO
: r
= R_PPC64_GOT_TPREL16_LO_DS
;
1201 case BFD_RELOC_PPC_GOT_TPREL16_HI
: r
= R_PPC64_GOT_TPREL16_HI
;
1203 case BFD_RELOC_PPC_GOT_TPREL16_HA
: r
= R_PPC64_GOT_TPREL16_HA
;
1205 case BFD_RELOC_PPC_GOT_DTPREL16
: r
= R_PPC64_GOT_DTPREL16_DS
;
1207 case BFD_RELOC_PPC_GOT_DTPREL16_LO
: r
= R_PPC64_GOT_DTPREL16_LO_DS
;
1209 case BFD_RELOC_PPC_GOT_DTPREL16_HI
: r
= R_PPC64_GOT_DTPREL16_HI
;
1211 case BFD_RELOC_PPC_GOT_DTPREL16_HA
: r
= R_PPC64_GOT_DTPREL16_HA
;
1213 case BFD_RELOC_PPC64_TPREL16_DS
: r
= R_PPC64_TPREL16_DS
;
1215 case BFD_RELOC_PPC64_TPREL16_LO_DS
: r
= R_PPC64_TPREL16_LO_DS
;
1217 case BFD_RELOC_PPC64_TPREL16_HIGHER
: r
= R_PPC64_TPREL16_HIGHER
;
1219 case BFD_RELOC_PPC64_TPREL16_HIGHERA
: r
= R_PPC64_TPREL16_HIGHERA
;
1221 case BFD_RELOC_PPC64_TPREL16_HIGHEST
: r
= R_PPC64_TPREL16_HIGHEST
;
1223 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
: r
= R_PPC64_TPREL16_HIGHESTA
;
1225 case BFD_RELOC_PPC64_DTPREL16_DS
: r
= R_PPC64_DTPREL16_DS
;
1227 case BFD_RELOC_PPC64_DTPREL16_LO_DS
: r
= R_PPC64_DTPREL16_LO_DS
;
1229 case BFD_RELOC_PPC64_DTPREL16_HIGHER
: r
= R_PPC64_DTPREL16_HIGHER
;
1231 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
: r
= R_PPC64_DTPREL16_HIGHERA
;
1233 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
: r
= R_PPC64_DTPREL16_HIGHEST
;
1235 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
: r
= R_PPC64_DTPREL16_HIGHESTA
;
1237 case BFD_RELOC_16_PCREL
: r
= R_PPC64_REL16
;
1239 case BFD_RELOC_LO16_PCREL
: r
= R_PPC64_REL16_LO
;
1241 case BFD_RELOC_HI16_PCREL
: r
= R_PPC64_REL16_HI
;
1243 case BFD_RELOC_HI16_S_PCREL
: r
= R_PPC64_REL16_HA
;
1245 case BFD_RELOC_PPC64_REL16_HIGH
: r
= R_PPC64_REL16_HIGH
;
1247 case BFD_RELOC_PPC64_REL16_HIGHA
: r
= R_PPC64_REL16_HIGHA
;
1249 case BFD_RELOC_PPC64_REL16_HIGHER
: r
= R_PPC64_REL16_HIGHER
;
1251 case BFD_RELOC_PPC64_REL16_HIGHERA
: r
= R_PPC64_REL16_HIGHERA
;
1253 case BFD_RELOC_PPC64_REL16_HIGHEST
: r
= R_PPC64_REL16_HIGHEST
;
1255 case BFD_RELOC_PPC64_REL16_HIGHESTA
: r
= R_PPC64_REL16_HIGHESTA
;
1257 case BFD_RELOC_PPC_16DX_HA
: r
= R_PPC64_16DX_HA
;
1259 case BFD_RELOC_PPC_REL16DX_HA
: r
= R_PPC64_REL16DX_HA
;
1261 case BFD_RELOC_PPC64_ENTRY
: r
= R_PPC64_ENTRY
;
1263 case BFD_RELOC_PPC64_ADDR64_LOCAL
: r
= R_PPC64_ADDR64_LOCAL
;
1265 case BFD_RELOC_PPC64_D34
: r
= R_PPC64_D34
;
1267 case BFD_RELOC_PPC64_D34_LO
: r
= R_PPC64_D34_LO
;
1269 case BFD_RELOC_PPC64_D34_HI30
: r
= R_PPC64_D34_HI30
;
1271 case BFD_RELOC_PPC64_D34_HA30
: r
= R_PPC64_D34_HA30
;
1273 case BFD_RELOC_PPC64_PCREL34
: r
= R_PPC64_PCREL34
;
1275 case BFD_RELOC_PPC64_GOT_PCREL34
: r
= R_PPC64_GOT_PCREL34
;
1277 case BFD_RELOC_PPC64_PLT_PCREL34
: r
= R_PPC64_PLT_PCREL34
;
1279 case BFD_RELOC_PPC64_TPREL34
: r
= R_PPC64_TPREL34
;
1281 case BFD_RELOC_PPC64_DTPREL34
: r
= R_PPC64_DTPREL34
;
1283 case BFD_RELOC_PPC64_GOT_TLSGD34
: r
= R_PPC64_GOT_TLSGD34
;
1285 case BFD_RELOC_PPC64_GOT_TLSLD34
: r
= R_PPC64_GOT_TLSLD34
;
1287 case BFD_RELOC_PPC64_GOT_TPREL34
: r
= R_PPC64_GOT_TPREL34
;
1289 case BFD_RELOC_PPC64_GOT_DTPREL34
: r
= R_PPC64_GOT_DTPREL34
;
1291 case BFD_RELOC_PPC64_ADDR16_HIGHER34
: r
= R_PPC64_ADDR16_HIGHER34
;
1293 case BFD_RELOC_PPC64_ADDR16_HIGHERA34
: r
= R_PPC64_ADDR16_HIGHERA34
;
1295 case BFD_RELOC_PPC64_ADDR16_HIGHEST34
: r
= R_PPC64_ADDR16_HIGHEST34
;
1297 case BFD_RELOC_PPC64_ADDR16_HIGHESTA34
: r
= R_PPC64_ADDR16_HIGHESTA34
;
1299 case BFD_RELOC_PPC64_REL16_HIGHER34
: r
= R_PPC64_REL16_HIGHER34
;
1301 case BFD_RELOC_PPC64_REL16_HIGHERA34
: r
= R_PPC64_REL16_HIGHERA34
;
1303 case BFD_RELOC_PPC64_REL16_HIGHEST34
: r
= R_PPC64_REL16_HIGHEST34
;
1305 case BFD_RELOC_PPC64_REL16_HIGHESTA34
: r
= R_PPC64_REL16_HIGHESTA34
;
1307 case BFD_RELOC_PPC64_D28
: r
= R_PPC64_D28
;
1309 case BFD_RELOC_PPC64_PCREL28
: r
= R_PPC64_PCREL28
;
1311 case BFD_RELOC_VTABLE_INHERIT
: r
= R_PPC64_GNU_VTINHERIT
;
1313 case BFD_RELOC_VTABLE_ENTRY
: r
= R_PPC64_GNU_VTENTRY
;
1317 return ppc64_elf_howto_table
[r
];
1320 static reloc_howto_type
*
1321 ppc64_elf_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
1326 for (i
= 0; i
< ARRAY_SIZE (ppc64_elf_howto_raw
); i
++)
1327 if (ppc64_elf_howto_raw
[i
].name
!= NULL
1328 && strcasecmp (ppc64_elf_howto_raw
[i
].name
, r_name
) == 0)
1329 return &ppc64_elf_howto_raw
[i
];
1334 /* Set the howto pointer for a PowerPC ELF reloc. */
1337 ppc64_elf_info_to_howto (bfd
*abfd
, arelent
*cache_ptr
,
1338 Elf_Internal_Rela
*dst
)
1342 /* Initialize howto table if needed. */
1343 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
1346 type
= ELF64_R_TYPE (dst
->r_info
);
1347 if (type
>= ARRAY_SIZE (ppc64_elf_howto_table
))
1349 /* xgettext:c-format */
1350 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
1352 bfd_set_error (bfd_error_bad_value
);
1355 cache_ptr
->howto
= ppc64_elf_howto_table
[type
];
1356 if (cache_ptr
->howto
== NULL
|| cache_ptr
->howto
->name
== NULL
)
1358 /* xgettext:c-format */
1359 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
1361 bfd_set_error (bfd_error_bad_value
);
1368 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
1370 static bfd_reloc_status_type
1371 ppc64_elf_ha_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1372 void *data
, asection
*input_section
,
1373 bfd
*output_bfd
, char **error_message
)
1375 enum elf_ppc64_reloc_type r_type
;
1377 bfd_size_type octets
;
1380 /* If this is a relocatable link (output_bfd test tells us), just
1381 call the generic function. Any adjustment will be done at final
1383 if (output_bfd
!= NULL
)
1384 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1385 input_section
, output_bfd
, error_message
);
1387 /* Adjust the addend for sign extension of the low 16 (or 34) bits.
1388 We won't actually be using the low bits, so trashing them
1390 r_type
= reloc_entry
->howto
->type
;
1391 if (r_type
== R_PPC64_ADDR16_HIGHERA34
1392 || r_type
== R_PPC64_ADDR16_HIGHESTA34
1393 || r_type
== R_PPC64_REL16_HIGHERA34
1394 || r_type
== R_PPC64_REL16_HIGHESTA34
)
1395 reloc_entry
->addend
+= 1ULL << 33;
1397 reloc_entry
->addend
+= 1U << 15;
1398 if (r_type
!= R_PPC64_REL16DX_HA
)
1399 return bfd_reloc_continue
;
1402 if (!bfd_is_com_section (symbol
->section
))
1403 value
= symbol
->value
;
1404 value
+= (reloc_entry
->addend
1405 + symbol
->section
->output_offset
1406 + symbol
->section
->output_section
->vma
);
1407 value
-= (reloc_entry
->address
1408 + input_section
->output_offset
1409 + input_section
->output_section
->vma
);
1410 value
= (bfd_signed_vma
) value
>> 16;
1412 octets
= reloc_entry
->address
* OCTETS_PER_BYTE (abfd
, input_section
);
1413 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ octets
);
1415 insn
|= (value
& 0xffc1) | ((value
& 0x3e) << 15);
1416 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ octets
);
1417 if (value
+ 0x8000 > 0xffff)
1418 return bfd_reloc_overflow
;
1419 return bfd_reloc_ok
;
1422 static bfd_reloc_status_type
1423 ppc64_elf_branch_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1424 void *data
, asection
*input_section
,
1425 bfd
*output_bfd
, char **error_message
)
1427 if (output_bfd
!= NULL
)
1428 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1429 input_section
, output_bfd
, error_message
);
1431 if (strcmp (symbol
->section
->name
, ".opd") == 0
1432 && (symbol
->section
->owner
->flags
& DYNAMIC
) == 0)
1434 bfd_vma dest
= opd_entry_value (symbol
->section
,
1435 symbol
->value
+ reloc_entry
->addend
,
1437 if (dest
!= (bfd_vma
) -1)
1438 reloc_entry
->addend
= dest
- (symbol
->value
1439 + symbol
->section
->output_section
->vma
1440 + symbol
->section
->output_offset
);
1444 elf_symbol_type
*elfsym
= (elf_symbol_type
*) symbol
;
1446 if (symbol
->section
->owner
!= abfd
1447 && symbol
->section
->owner
!= NULL
1448 && abiversion (symbol
->section
->owner
) >= 2)
1452 for (i
= 0; i
< symbol
->section
->owner
->symcount
; ++i
)
1454 asymbol
*symdef
= symbol
->section
->owner
->outsymbols
[i
];
1456 if (strcmp (symdef
->name
, symbol
->name
) == 0)
1458 elfsym
= (elf_symbol_type
*) symdef
;
1464 += PPC64_LOCAL_ENTRY_OFFSET (elfsym
->internal_elf_sym
.st_other
);
1466 return bfd_reloc_continue
;
1469 static bfd_reloc_status_type
1470 ppc64_elf_brtaken_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1471 void *data
, asection
*input_section
,
1472 bfd
*output_bfd
, char **error_message
)
1475 enum elf_ppc64_reloc_type r_type
;
1476 bfd_size_type octets
;
1477 /* Assume 'at' branch hints. */
1478 bfd_boolean is_isa_v2
= TRUE
;
1480 /* If this is a relocatable link (output_bfd test tells us), just
1481 call the generic function. Any adjustment will be done at final
1483 if (output_bfd
!= NULL
)
1484 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1485 input_section
, output_bfd
, error_message
);
1487 octets
= reloc_entry
->address
* OCTETS_PER_BYTE (abfd
, input_section
);
1488 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ octets
);
1489 insn
&= ~(0x01 << 21);
1490 r_type
= reloc_entry
->howto
->type
;
1491 if (r_type
== R_PPC64_ADDR14_BRTAKEN
1492 || r_type
== R_PPC64_REL14_BRTAKEN
)
1493 insn
|= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
1497 /* Set 'a' bit. This is 0b00010 in BO field for branch
1498 on CR(BI) insns (BO == 001at or 011at), and 0b01000
1499 for branch on CTR insns (BO == 1a00t or 1a01t). */
1500 if ((insn
& (0x14 << 21)) == (0x04 << 21))
1502 else if ((insn
& (0x14 << 21)) == (0x10 << 21))
1512 if (!bfd_is_com_section (symbol
->section
))
1513 target
= symbol
->value
;
1514 target
+= symbol
->section
->output_section
->vma
;
1515 target
+= symbol
->section
->output_offset
;
1516 target
+= reloc_entry
->addend
;
1518 from
= (reloc_entry
->address
1519 + input_section
->output_offset
1520 + input_section
->output_section
->vma
);
1522 /* Invert 'y' bit if not the default. */
1523 if ((bfd_signed_vma
) (target
- from
) < 0)
1526 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ octets
);
1528 return ppc64_elf_branch_reloc (abfd
, reloc_entry
, symbol
, data
,
1529 input_section
, output_bfd
, error_message
);
1532 static bfd_reloc_status_type
1533 ppc64_elf_sectoff_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1534 void *data
, asection
*input_section
,
1535 bfd
*output_bfd
, char **error_message
)
1537 /* If this is a relocatable link (output_bfd test tells us), just
1538 call the generic function. Any adjustment will be done at final
1540 if (output_bfd
!= NULL
)
1541 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1542 input_section
, output_bfd
, error_message
);
1544 /* Subtract the symbol section base address. */
1545 reloc_entry
->addend
-= symbol
->section
->output_section
->vma
;
1546 return bfd_reloc_continue
;
1549 static bfd_reloc_status_type
1550 ppc64_elf_sectoff_ha_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1551 void *data
, asection
*input_section
,
1552 bfd
*output_bfd
, char **error_message
)
1554 /* If this is a relocatable link (output_bfd test tells us), just
1555 call the generic function. Any adjustment will be done at final
1557 if (output_bfd
!= NULL
)
1558 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1559 input_section
, output_bfd
, error_message
);
1561 /* Subtract the symbol section base address. */
1562 reloc_entry
->addend
-= symbol
->section
->output_section
->vma
;
1564 /* Adjust the addend for sign extension of the low 16 bits. */
1565 reloc_entry
->addend
+= 0x8000;
1566 return bfd_reloc_continue
;
1569 static bfd_reloc_status_type
1570 ppc64_elf_toc_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1571 void *data
, asection
*input_section
,
1572 bfd
*output_bfd
, char **error_message
)
1576 /* If this is a relocatable link (output_bfd test tells us), just
1577 call the generic function. Any adjustment will be done at final
1579 if (output_bfd
!= NULL
)
1580 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1581 input_section
, output_bfd
, error_message
);
1583 TOCstart
= _bfd_get_gp_value (input_section
->output_section
->owner
);
1585 TOCstart
= ppc64_elf_set_toc (NULL
, input_section
->output_section
->owner
);
1587 /* Subtract the TOC base address. */
1588 reloc_entry
->addend
-= TOCstart
+ TOC_BASE_OFF
;
1589 return bfd_reloc_continue
;
1592 static bfd_reloc_status_type
1593 ppc64_elf_toc_ha_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1594 void *data
, asection
*input_section
,
1595 bfd
*output_bfd
, char **error_message
)
1599 /* If this is a relocatable link (output_bfd test tells us), just
1600 call the generic function. Any adjustment will be done at final
1602 if (output_bfd
!= NULL
)
1603 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1604 input_section
, output_bfd
, error_message
);
1606 TOCstart
= _bfd_get_gp_value (input_section
->output_section
->owner
);
1608 TOCstart
= ppc64_elf_set_toc (NULL
, input_section
->output_section
->owner
);
1610 /* Subtract the TOC base address. */
1611 reloc_entry
->addend
-= TOCstart
+ TOC_BASE_OFF
;
1613 /* Adjust the addend for sign extension of the low 16 bits. */
1614 reloc_entry
->addend
+= 0x8000;
1615 return bfd_reloc_continue
;
1618 static bfd_reloc_status_type
1619 ppc64_elf_toc64_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1620 void *data
, asection
*input_section
,
1621 bfd
*output_bfd
, char **error_message
)
1624 bfd_size_type octets
;
1626 /* If this is a relocatable link (output_bfd test tells us), just
1627 call the generic function. Any adjustment will be done at final
1629 if (output_bfd
!= NULL
)
1630 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1631 input_section
, output_bfd
, error_message
);
1633 TOCstart
= _bfd_get_gp_value (input_section
->output_section
->owner
);
1635 TOCstart
= ppc64_elf_set_toc (NULL
, input_section
->output_section
->owner
);
1637 octets
= reloc_entry
->address
* OCTETS_PER_BYTE (abfd
, input_section
);
1638 bfd_put_64 (abfd
, TOCstart
+ TOC_BASE_OFF
, (bfd_byte
*) data
+ octets
);
1639 return bfd_reloc_ok
;
1642 static bfd_reloc_status_type
1643 ppc64_elf_prefix_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1644 void *data
, asection
*input_section
,
1645 bfd
*output_bfd
, char **error_message
)
1650 if (output_bfd
!= NULL
)
1651 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1652 input_section
, output_bfd
, error_message
);
1654 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1656 insn
|= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
+ 4);
1658 targ
= (symbol
->section
->output_section
->vma
1659 + symbol
->section
->output_offset
1660 + reloc_entry
->addend
);
1661 if (!bfd_is_com_section (symbol
->section
))
1662 targ
+= symbol
->value
;
1663 if (reloc_entry
->howto
->type
== R_PPC64_D34_HA30
)
1665 if (reloc_entry
->howto
->pc_relative
)
1667 bfd_vma from
= (reloc_entry
->address
1668 + input_section
->output_offset
1669 + input_section
->output_section
->vma
);
1672 targ
>>= reloc_entry
->howto
->rightshift
;
1673 insn
&= ~reloc_entry
->howto
->dst_mask
;
1674 insn
|= ((targ
<< 16) | (targ
& 0xffff)) & reloc_entry
->howto
->dst_mask
;
1675 bfd_put_32 (abfd
, insn
>> 32, (bfd_byte
*) data
+ reloc_entry
->address
);
1676 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ reloc_entry
->address
+ 4);
1677 if (reloc_entry
->howto
->complain_on_overflow
== complain_overflow_signed
1678 && (targ
+ (1ULL << (reloc_entry
->howto
->bitsize
- 1))
1679 >= 1ULL << reloc_entry
->howto
->bitsize
))
1680 return bfd_reloc_overflow
;
1681 return bfd_reloc_ok
;
1684 static bfd_reloc_status_type
1685 ppc64_elf_unhandled_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1686 void *data
, asection
*input_section
,
1687 bfd
*output_bfd
, char **error_message
)
1689 /* If this is a relocatable link (output_bfd test tells us), just
1690 call the generic function. Any adjustment will be done at final
1692 if (output_bfd
!= NULL
)
1693 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1694 input_section
, output_bfd
, error_message
);
1696 if (error_message
!= NULL
)
1698 static char buf
[60];
1699 sprintf (buf
, "generic linker can't handle %s",
1700 reloc_entry
->howto
->name
);
1701 *error_message
= buf
;
1703 return bfd_reloc_dangerous
;
1706 /* Track GOT entries needed for a given symbol. We might need more
1707 than one got entry per symbol. */
1710 struct got_entry
*next
;
1712 /* The symbol addend that we'll be placing in the GOT. */
1715 /* Unlike other ELF targets, we use separate GOT entries for the same
1716 symbol referenced from different input files. This is to support
1717 automatic multiple TOC/GOT sections, where the TOC base can vary
1718 from one input file to another. After partitioning into TOC groups
1719 we merge entries within the group.
1721 Point to the BFD owning this GOT entry. */
1724 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
1725 TLS_TPREL or TLS_DTPREL for tls entries. */
1726 unsigned char tls_type
;
1728 /* Non-zero if got.ent points to real entry. */
1729 unsigned char is_indirect
;
1731 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
1734 bfd_signed_vma refcount
;
1736 struct got_entry
*ent
;
1740 /* The same for PLT. */
1743 struct plt_entry
*next
;
1749 bfd_signed_vma refcount
;
1754 struct ppc64_elf_obj_tdata
1756 struct elf_obj_tdata elf
;
1758 /* Shortcuts to dynamic linker sections. */
1762 /* Used during garbage collection. We attach global symbols defined
1763 on removed .opd entries to this section so that the sym is removed. */
1764 asection
*deleted_section
;
1766 /* TLS local dynamic got entry handling. Support for multiple GOT
1767 sections means we potentially need one of these for each input bfd. */
1768 struct got_entry tlsld_got
;
1772 /* A copy of relocs before they are modified for --emit-relocs. */
1773 Elf_Internal_Rela
*relocs
;
1775 /* Section contents. */
1779 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
1780 the reloc to be in the range -32768 to 32767. */
1781 unsigned int has_small_toc_reloc
: 1;
1783 /* Set if toc/got ha relocs detected not using r2, or lo reloc
1784 instruction not one we handle. */
1785 unsigned int unexpected_toc_insn
: 1;
1787 /* Set if PLT/GOT/TOC relocs that can be optimised are present in
1789 unsigned int has_optrel
: 1;
1792 #define ppc64_elf_tdata(bfd) \
1793 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
1795 #define ppc64_tlsld_got(bfd) \
1796 (&ppc64_elf_tdata (bfd)->tlsld_got)
1798 #define is_ppc64_elf(bfd) \
1799 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
1800 && elf_object_id (bfd) == PPC64_ELF_DATA)
1802 /* Override the generic function because we store some extras. */
1805 ppc64_elf_mkobject (bfd
*abfd
)
1807 return bfd_elf_allocate_object (abfd
, sizeof (struct ppc64_elf_obj_tdata
),
1811 /* Fix bad default arch selected for a 64 bit input bfd when the
1812 default is 32 bit. Also select arch based on apuinfo. */
1815 ppc64_elf_object_p (bfd
*abfd
)
1817 if (!abfd
->arch_info
->the_default
)
1820 if (abfd
->arch_info
->bits_per_word
== 32)
1822 Elf_Internal_Ehdr
*i_ehdr
= elf_elfheader (abfd
);
1824 if (i_ehdr
->e_ident
[EI_CLASS
] == ELFCLASS64
)
1826 /* Relies on arch after 32 bit default being 64 bit default. */
1827 abfd
->arch_info
= abfd
->arch_info
->next
;
1828 BFD_ASSERT (abfd
->arch_info
->bits_per_word
== 64);
1831 return _bfd_elf_ppc_set_arch (abfd
);
1834 /* Support for core dump NOTE sections. */
1837 ppc64_elf_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
1839 size_t offset
, size
;
1841 if (note
->descsz
!= 504)
1845 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
1848 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 32);
1854 /* Make a ".reg/999" section. */
1855 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
1856 size
, note
->descpos
+ offset
);
1860 ppc64_elf_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
1862 if (note
->descsz
!= 136)
1865 elf_tdata (abfd
)->core
->pid
1866 = bfd_get_32 (abfd
, note
->descdata
+ 24);
1867 elf_tdata (abfd
)->core
->program
1868 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 40, 16);
1869 elf_tdata (abfd
)->core
->command
1870 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 56, 80);
1876 ppc64_elf_write_core_note (bfd
*abfd
, char *buf
, int *bufsiz
, int note_type
,
1886 char data
[136] ATTRIBUTE_NONSTRING
;
1889 va_start (ap
, note_type
);
1890 memset (data
, 0, sizeof (data
));
1891 strncpy (data
+ 40, va_arg (ap
, const char *), 16);
1892 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
1894 /* GCC 8.0 and 8.1 warn about 80 equals destination size with
1895 -Wstringop-truncation:
1896 https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85643
1898 DIAGNOSTIC_IGNORE_STRINGOP_TRUNCATION
;
1900 strncpy (data
+ 56, va_arg (ap
, const char *), 80);
1901 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
1905 return elfcore_write_note (abfd
, buf
, bufsiz
,
1906 "CORE", note_type
, data
, sizeof (data
));
1917 va_start (ap
, note_type
);
1918 memset (data
, 0, 112);
1919 pid
= va_arg (ap
, long);
1920 bfd_put_32 (abfd
, pid
, data
+ 32);
1921 cursig
= va_arg (ap
, int);
1922 bfd_put_16 (abfd
, cursig
, data
+ 12);
1923 greg
= va_arg (ap
, const void *);
1924 memcpy (data
+ 112, greg
, 384);
1925 memset (data
+ 496, 0, 8);
1927 return elfcore_write_note (abfd
, buf
, bufsiz
,
1928 "CORE", note_type
, data
, sizeof (data
));
1933 /* Add extra PPC sections. */
1935 static const struct bfd_elf_special_section ppc64_elf_special_sections
[] =
1937 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS
, 0 },
1938 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
1939 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
1940 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
1941 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
1942 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
1943 { NULL
, 0, 0, 0, 0 }
1946 enum _ppc64_sec_type
{
1952 struct _ppc64_elf_section_data
1954 struct bfd_elf_section_data elf
;
1958 /* An array with one entry for each opd function descriptor,
1959 and some spares since opd entries may be either 16 or 24 bytes. */
1960 #define OPD_NDX(OFF) ((OFF) >> 4)
1961 struct _opd_sec_data
1963 /* Points to the function code section for local opd entries. */
1964 asection
**func_sec
;
1966 /* After editing .opd, adjust references to opd local syms. */
1970 /* An array for toc sections, indexed by offset/8. */
1971 struct _toc_sec_data
1973 /* Specifies the relocation symbol index used at a given toc offset. */
1976 /* And the relocation addend. */
1981 enum _ppc64_sec_type sec_type
:2;
1983 /* Flag set when small branches are detected. Used to
1984 select suitable defaults for the stub group size. */
1985 unsigned int has_14bit_branch
:1;
1987 /* Flag set when PLTCALL relocs are detected. */
1988 unsigned int has_pltcall
:1;
1990 /* Flag set when section has PLT/GOT/TOC relocations that can be
1992 unsigned int has_optrel
:1;
1995 #define ppc64_elf_section_data(sec) \
1996 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
1999 ppc64_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
2001 if (!sec
->used_by_bfd
)
2003 struct _ppc64_elf_section_data
*sdata
;
2004 size_t amt
= sizeof (*sdata
);
2006 sdata
= bfd_zalloc (abfd
, amt
);
2009 sec
->used_by_bfd
= sdata
;
2012 return _bfd_elf_new_section_hook (abfd
, sec
);
2016 ppc64_elf_section_flags (const Elf_Internal_Shdr
*hdr
)
2018 const char *name
= hdr
->bfd_section
->name
;
2020 if (strncmp (name
, ".sbss", 5) == 0
2021 || strncmp (name
, ".sdata", 6) == 0)
2022 hdr
->bfd_section
->flags
|= SEC_SMALL_DATA
;
2027 static struct _opd_sec_data
*
2028 get_opd_info (asection
* sec
)
2031 && ppc64_elf_section_data (sec
) != NULL
2032 && ppc64_elf_section_data (sec
)->sec_type
== sec_opd
)
2033 return &ppc64_elf_section_data (sec
)->u
.opd
;
2037 /* Parameters for the qsort hook. */
2038 static bfd_boolean synthetic_relocatable
;
2039 static asection
*synthetic_opd
;
2041 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
2044 compare_symbols (const void *ap
, const void *bp
)
2046 const asymbol
*a
= *(const asymbol
**) ap
;
2047 const asymbol
*b
= *(const asymbol
**) bp
;
2049 /* Section symbols first. */
2050 if ((a
->flags
& BSF_SECTION_SYM
) && !(b
->flags
& BSF_SECTION_SYM
))
2052 if (!(a
->flags
& BSF_SECTION_SYM
) && (b
->flags
& BSF_SECTION_SYM
))
2055 /* then .opd symbols. */
2056 if (synthetic_opd
!= NULL
)
2058 if (strcmp (a
->section
->name
, ".opd") == 0
2059 && strcmp (b
->section
->name
, ".opd") != 0)
2061 if (strcmp (a
->section
->name
, ".opd") != 0
2062 && strcmp (b
->section
->name
, ".opd") == 0)
2066 /* then other code symbols. */
2067 if (((a
->section
->flags
& (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
))
2068 == (SEC_CODE
| SEC_ALLOC
))
2069 && ((b
->section
->flags
& (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
))
2070 != (SEC_CODE
| SEC_ALLOC
)))
2073 if (((a
->section
->flags
& (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
))
2074 != (SEC_CODE
| SEC_ALLOC
))
2075 && ((b
->section
->flags
& (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
))
2076 == (SEC_CODE
| SEC_ALLOC
)))
2079 if (synthetic_relocatable
)
2081 if (a
->section
->id
< b
->section
->id
)
2084 if (a
->section
->id
> b
->section
->id
)
2088 if (a
->value
+ a
->section
->vma
< b
->value
+ b
->section
->vma
)
2091 if (a
->value
+ a
->section
->vma
> b
->value
+ b
->section
->vma
)
2094 /* For syms with the same value, prefer strong dynamic global function
2095 syms over other syms. */
2096 if ((a
->flags
& BSF_GLOBAL
) != 0 && (b
->flags
& BSF_GLOBAL
) == 0)
2099 if ((a
->flags
& BSF_GLOBAL
) == 0 && (b
->flags
& BSF_GLOBAL
) != 0)
2102 if ((a
->flags
& BSF_FUNCTION
) != 0 && (b
->flags
& BSF_FUNCTION
) == 0)
2105 if ((a
->flags
& BSF_FUNCTION
) == 0 && (b
->flags
& BSF_FUNCTION
) != 0)
2108 if ((a
->flags
& BSF_WEAK
) == 0 && (b
->flags
& BSF_WEAK
) != 0)
2111 if ((a
->flags
& BSF_WEAK
) != 0 && (b
->flags
& BSF_WEAK
) == 0)
2114 if ((a
->flags
& BSF_DYNAMIC
) != 0 && (b
->flags
& BSF_DYNAMIC
) == 0)
2117 if ((a
->flags
& BSF_DYNAMIC
) == 0 && (b
->flags
& BSF_DYNAMIC
) != 0)
2120 /* Finally, sort on where the symbol is in memory. The symbols will
2121 be in at most two malloc'd blocks, one for static syms, one for
2122 dynamic syms, and we distinguish the two blocks above by testing
2123 BSF_DYNAMIC. Since we are sorting the symbol pointers which were
2124 originally in the same order as the symbols (and we're not
2125 sorting the symbols themselves), this ensures a stable sort. */
2133 /* Search SYMS for a symbol of the given VALUE. */
2136 sym_exists_at (asymbol
**syms
, size_t lo
, size_t hi
, unsigned int id
,
2141 if (id
== (unsigned) -1)
2145 mid
= (lo
+ hi
) >> 1;
2146 if (syms
[mid
]->value
+ syms
[mid
]->section
->vma
< value
)
2148 else if (syms
[mid
]->value
+ syms
[mid
]->section
->vma
> value
)
2158 mid
= (lo
+ hi
) >> 1;
2159 if (syms
[mid
]->section
->id
< id
)
2161 else if (syms
[mid
]->section
->id
> id
)
2163 else if (syms
[mid
]->value
< value
)
2165 else if (syms
[mid
]->value
> value
)
2175 section_covers_vma (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*section
, void *ptr
)
2177 bfd_vma vma
= *(bfd_vma
*) ptr
;
2178 return ((section
->flags
& SEC_ALLOC
) != 0
2179 && section
->vma
<= vma
2180 && vma
< section
->vma
+ section
->size
);
2183 /* Create synthetic symbols, effectively restoring "dot-symbol" function
2184 entry syms. Also generate @plt symbols for the glink branch table.
2185 Returns count of synthetic symbols in RET or -1 on error. */
2188 ppc64_elf_get_synthetic_symtab (bfd
*abfd
,
2189 long static_count
, asymbol
**static_syms
,
2190 long dyn_count
, asymbol
**dyn_syms
,
2196 size_t symcount
, codesecsym
, codesecsymend
, secsymend
, opdsymend
;
2197 asection
*opd
= NULL
;
2198 bfd_boolean relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2200 int abi
= abiversion (abfd
);
2206 opd
= bfd_get_section_by_name (abfd
, ".opd");
2207 if (opd
== NULL
&& abi
== 1)
2219 symcount
= static_count
;
2221 symcount
+= dyn_count
;
2225 syms
= bfd_malloc ((symcount
+ 1) * sizeof (*syms
));
2229 if (!relocatable
&& static_count
!= 0 && dyn_count
!= 0)
2231 /* Use both symbol tables. */
2232 memcpy (syms
, static_syms
, static_count
* sizeof (*syms
));
2233 memcpy (syms
+ static_count
, dyn_syms
,
2234 (dyn_count
+ 1) * sizeof (*syms
));
2236 else if (!relocatable
&& static_count
== 0)
2237 memcpy (syms
, dyn_syms
, (symcount
+ 1) * sizeof (*syms
));
2239 memcpy (syms
, static_syms
, (symcount
+ 1) * sizeof (*syms
));
2241 /* Trim uninteresting symbols. Interesting symbols are section,
2242 function, and notype symbols. */
2243 for (i
= 0, j
= 0; i
< symcount
; ++i
)
2244 if ((syms
[i
]->flags
& (BSF_FILE
| BSF_OBJECT
| BSF_THREAD_LOCAL
2245 | BSF_RELC
| BSF_SRELC
)) == 0)
2246 syms
[j
++] = syms
[i
];
2249 synthetic_relocatable
= relocatable
;
2250 synthetic_opd
= opd
;
2251 qsort (syms
, symcount
, sizeof (*syms
), compare_symbols
);
2253 if (!relocatable
&& symcount
> 1)
2255 /* Trim duplicate syms, since we may have merged the normal
2256 and dynamic symbols. Actually, we only care about syms
2257 that have different values, so trim any with the same
2258 value. Don't consider ifunc and ifunc resolver symbols
2259 duplicates however, because GDB wants to know whether a
2260 text symbol is an ifunc resolver. */
2261 for (i
= 1, j
= 1; i
< symcount
; ++i
)
2263 const asymbol
*s0
= syms
[i
- 1];
2264 const asymbol
*s1
= syms
[i
];
2266 if ((s0
->value
+ s0
->section
->vma
2267 != s1
->value
+ s1
->section
->vma
)
2268 || ((s0
->flags
& BSF_GNU_INDIRECT_FUNCTION
)
2269 != (s1
->flags
& BSF_GNU_INDIRECT_FUNCTION
)))
2270 syms
[j
++] = syms
[i
];
2276 /* Note that here and in compare_symbols we can't compare opd and
2277 sym->section directly. With separate debug info files, the
2278 symbols will be extracted from the debug file while abfd passed
2279 to this function is the real binary. */
2280 if (strcmp (syms
[i
]->section
->name
, ".opd") == 0)
2284 for (; i
< symcount
; ++i
)
2285 if (((syms
[i
]->section
->flags
& (SEC_CODE
| SEC_ALLOC
2286 | SEC_THREAD_LOCAL
))
2287 != (SEC_CODE
| SEC_ALLOC
))
2288 || (syms
[i
]->flags
& BSF_SECTION_SYM
) == 0)
2292 for (; i
< symcount
; ++i
)
2293 if ((syms
[i
]->flags
& BSF_SECTION_SYM
) == 0)
2297 for (; i
< symcount
; ++i
)
2298 if (strcmp (syms
[i
]->section
->name
, ".opd") != 0)
2302 for (; i
< symcount
; ++i
)
2303 if (((syms
[i
]->section
->flags
2304 & (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
)))
2305 != (SEC_CODE
| SEC_ALLOC
))
2313 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
2318 if (opdsymend
== secsymend
)
2321 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
2322 relcount
= (opd
->flags
& SEC_RELOC
) ? opd
->reloc_count
: 0;
2326 if (!(*slurp_relocs
) (abfd
, opd
, static_syms
, FALSE
))
2333 for (i
= secsymend
, r
= opd
->relocation
; i
< opdsymend
; ++i
)
2337 while (r
< opd
->relocation
+ relcount
2338 && r
->address
< syms
[i
]->value
+ opd
->vma
)
2341 if (r
== opd
->relocation
+ relcount
)
2344 if (r
->address
!= syms
[i
]->value
+ opd
->vma
)
2347 if (r
->howto
->type
!= R_PPC64_ADDR64
)
2350 sym
= *r
->sym_ptr_ptr
;
2351 if (!sym_exists_at (syms
, opdsymend
, symcount
,
2352 sym
->section
->id
, sym
->value
+ r
->addend
))
2355 size
+= sizeof (asymbol
);
2356 size
+= strlen (syms
[i
]->name
) + 2;
2362 s
= *ret
= bfd_malloc (size
);
2369 names
= (char *) (s
+ count
);
2371 for (i
= secsymend
, r
= opd
->relocation
; i
< opdsymend
; ++i
)
2375 while (r
< opd
->relocation
+ relcount
2376 && r
->address
< syms
[i
]->value
+ opd
->vma
)
2379 if (r
== opd
->relocation
+ relcount
)
2382 if (r
->address
!= syms
[i
]->value
+ opd
->vma
)
2385 if (r
->howto
->type
!= R_PPC64_ADDR64
)
2388 sym
= *r
->sym_ptr_ptr
;
2389 if (!sym_exists_at (syms
, opdsymend
, symcount
,
2390 sym
->section
->id
, sym
->value
+ r
->addend
))
2395 s
->flags
|= BSF_SYNTHETIC
;
2396 s
->section
= sym
->section
;
2397 s
->value
= sym
->value
+ r
->addend
;
2400 len
= strlen (syms
[i
]->name
);
2401 memcpy (names
, syms
[i
]->name
, len
+ 1);
2403 /* Have udata.p point back to the original symbol this
2404 synthetic symbol was derived from. */
2405 s
->udata
.p
= syms
[i
];
2412 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
2413 bfd_byte
*contents
= NULL
;
2415 size_t plt_count
= 0;
2416 bfd_vma glink_vma
= 0, resolv_vma
= 0;
2417 asection
*dynamic
, *glink
= NULL
, *relplt
= NULL
;
2420 if (opd
!= NULL
&& !bfd_malloc_and_get_section (abfd
, opd
, &contents
))
2422 free_contents_and_exit_err
:
2424 free_contents_and_exit
:
2431 for (i
= secsymend
; i
< opdsymend
; ++i
)
2435 /* Ignore bogus symbols. */
2436 if (syms
[i
]->value
> opd
->size
- 8)
2439 ent
= bfd_get_64 (abfd
, contents
+ syms
[i
]->value
);
2440 if (!sym_exists_at (syms
, opdsymend
, symcount
, -1, ent
))
2443 size
+= sizeof (asymbol
);
2444 size
+= strlen (syms
[i
]->name
) + 2;
2448 /* Get start of .glink stubs from DT_PPC64_GLINK. */
2450 && (dynamic
= bfd_get_section_by_name (abfd
, ".dynamic")) != NULL
)
2452 bfd_byte
*dynbuf
, *extdyn
, *extdynend
;
2454 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
2456 if (!bfd_malloc_and_get_section (abfd
, dynamic
, &dynbuf
))
2457 goto free_contents_and_exit_err
;
2459 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
2460 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
2463 extdynend
= extdyn
+ dynamic
->size
;
2464 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
2466 Elf_Internal_Dyn dyn
;
2467 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
2469 if (dyn
.d_tag
== DT_NULL
)
2472 if (dyn
.d_tag
== DT_PPC64_GLINK
)
2474 /* The first glink stub starts at DT_PPC64_GLINK plus 32.
2475 See comment in ppc64_elf_finish_dynamic_sections. */
2476 glink_vma
= dyn
.d_un
.d_val
+ 8 * 4;
2477 /* The .glink section usually does not survive the final
2478 link; search for the section (usually .text) where the
2479 glink stubs now reside. */
2480 glink
= bfd_sections_find_if (abfd
, section_covers_vma
,
2491 /* Determine __glink trampoline by reading the relative branch
2492 from the first glink stub. */
2494 unsigned int off
= 0;
2496 while (bfd_get_section_contents (abfd
, glink
, buf
,
2497 glink_vma
+ off
- glink
->vma
, 4))
2499 unsigned int insn
= bfd_get_32 (abfd
, buf
);
2501 if ((insn
& ~0x3fffffc) == 0)
2504 = glink_vma
+ off
+ (insn
^ 0x2000000) - 0x2000000;
2513 size
+= sizeof (asymbol
) + sizeof ("__glink_PLTresolve");
2515 relplt
= bfd_get_section_by_name (abfd
, ".rela.plt");
2518 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
2519 if (!(*slurp_relocs
) (abfd
, relplt
, dyn_syms
, TRUE
))
2520 goto free_contents_and_exit_err
;
2522 plt_count
= relplt
->size
/ sizeof (Elf64_External_Rela
);
2523 size
+= plt_count
* sizeof (asymbol
);
2525 p
= relplt
->relocation
;
2526 for (i
= 0; i
< plt_count
; i
++, p
++)
2528 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
2530 size
+= sizeof ("+0x") - 1 + 16;
2536 goto free_contents_and_exit
;
2537 s
= *ret
= bfd_malloc (size
);
2539 goto free_contents_and_exit_err
;
2541 names
= (char *) (s
+ count
+ plt_count
+ (resolv_vma
!= 0));
2543 for (i
= secsymend
; i
< opdsymend
; ++i
)
2547 if (syms
[i
]->value
> opd
->size
- 8)
2550 ent
= bfd_get_64 (abfd
, contents
+ syms
[i
]->value
);
2551 if (!sym_exists_at (syms
, opdsymend
, symcount
, -1, ent
))
2555 asection
*sec
= abfd
->sections
;
2562 size_t mid
= (lo
+ hi
) >> 1;
2563 if (syms
[mid
]->section
->vma
< ent
)
2565 else if (syms
[mid
]->section
->vma
> ent
)
2569 sec
= syms
[mid
]->section
;
2574 if (lo
>= hi
&& lo
> codesecsym
)
2575 sec
= syms
[lo
- 1]->section
;
2577 for (; sec
!= NULL
; sec
= sec
->next
)
2581 /* SEC_LOAD may not be set if SEC is from a separate debug
2583 if ((sec
->flags
& SEC_ALLOC
) == 0)
2585 if ((sec
->flags
& SEC_CODE
) != 0)
2588 s
->flags
|= BSF_SYNTHETIC
;
2589 s
->value
= ent
- s
->section
->vma
;
2592 len
= strlen (syms
[i
]->name
);
2593 memcpy (names
, syms
[i
]->name
, len
+ 1);
2595 /* Have udata.p point back to the original symbol this
2596 synthetic symbol was derived from. */
2597 s
->udata
.p
= syms
[i
];
2603 if (glink
!= NULL
&& relplt
!= NULL
)
2607 /* Add a symbol for the main glink trampoline. */
2608 memset (s
, 0, sizeof *s
);
2610 s
->flags
= BSF_GLOBAL
| BSF_SYNTHETIC
;
2612 s
->value
= resolv_vma
- glink
->vma
;
2614 memcpy (names
, "__glink_PLTresolve",
2615 sizeof ("__glink_PLTresolve"));
2616 names
+= sizeof ("__glink_PLTresolve");
2621 /* FIXME: It would be very much nicer to put sym@plt on the
2622 stub rather than on the glink branch table entry. The
2623 objdump disassembler would then use a sensible symbol
2624 name on plt calls. The difficulty in doing so is
2625 a) finding the stubs, and,
2626 b) matching stubs against plt entries, and,
2627 c) there can be multiple stubs for a given plt entry.
2629 Solving (a) could be done by code scanning, but older
2630 ppc64 binaries used different stubs to current code.
2631 (b) is the tricky one since you need to known the toc
2632 pointer for at least one function that uses a pic stub to
2633 be able to calculate the plt address referenced.
2634 (c) means gdb would need to set multiple breakpoints (or
2635 find the glink branch itself) when setting breakpoints
2636 for pending shared library loads. */
2637 p
= relplt
->relocation
;
2638 for (i
= 0; i
< plt_count
; i
++, p
++)
2642 *s
= **p
->sym_ptr_ptr
;
2643 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
2644 we are defining a symbol, ensure one of them is set. */
2645 if ((s
->flags
& BSF_LOCAL
) == 0)
2646 s
->flags
|= BSF_GLOBAL
;
2647 s
->flags
|= BSF_SYNTHETIC
;
2649 s
->value
= glink_vma
- glink
->vma
;
2652 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
2653 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
2657 memcpy (names
, "+0x", sizeof ("+0x") - 1);
2658 names
+= sizeof ("+0x") - 1;
2659 bfd_sprintf_vma (abfd
, names
, p
->addend
);
2660 names
+= strlen (names
);
2662 memcpy (names
, "@plt", sizeof ("@plt"));
2663 names
+= sizeof ("@plt");
2683 /* The following functions are specific to the ELF linker, while
2684 functions above are used generally. Those named ppc64_elf_* are
2685 called by the main ELF linker code. They appear in this file more
2686 or less in the order in which they are called. eg.
2687 ppc64_elf_check_relocs is called early in the link process,
2688 ppc64_elf_finish_dynamic_sections is one of the last functions
2691 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
2692 functions have both a function code symbol and a function descriptor
2693 symbol. A call to foo in a relocatable object file looks like:
2700 The function definition in another object file might be:
2704 . .quad .TOC.@tocbase
2710 When the linker resolves the call during a static link, the branch
2711 unsurprisingly just goes to .foo and the .opd information is unused.
2712 If the function definition is in a shared library, things are a little
2713 different: The call goes via a plt call stub, the opd information gets
2714 copied to the plt, and the linker patches the nop.
2722 . std 2,40(1) # in practice, the call stub
2723 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
2724 . addi 11,11,Lfoo@toc@l # this is the general idea
2732 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
2734 The "reloc ()" notation is supposed to indicate that the linker emits
2735 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
2738 What are the difficulties here? Well, firstly, the relocations
2739 examined by the linker in check_relocs are against the function code
2740 sym .foo, while the dynamic relocation in the plt is emitted against
2741 the function descriptor symbol, foo. Somewhere along the line, we need
2742 to carefully copy dynamic link information from one symbol to the other.
2743 Secondly, the generic part of the elf linker will make .foo a dynamic
2744 symbol as is normal for most other backends. We need foo dynamic
2745 instead, at least for an application final link. However, when
2746 creating a shared library containing foo, we need to have both symbols
2747 dynamic so that references to .foo are satisfied during the early
2748 stages of linking. Otherwise the linker might decide to pull in a
2749 definition from some other object, eg. a static library.
2751 Update: As of August 2004, we support a new convention. Function
2752 calls may use the function descriptor symbol, ie. "bl foo". This
2753 behaves exactly as "bl .foo". */
2755 /* Of those relocs that might be copied as dynamic relocs, this
2756 function selects those that must be copied when linking a shared
2757 library or PIE, even when the symbol is local. */
2760 must_be_dyn_reloc (struct bfd_link_info
*info
,
2761 enum elf_ppc64_reloc_type r_type
)
2766 /* Only relative relocs can be resolved when the object load
2767 address isn't fixed. DTPREL64 is excluded because the
2768 dynamic linker needs to differentiate global dynamic from
2769 local dynamic __tls_index pairs when PPC64_OPT_TLS is set. */
2776 case R_PPC64_TOC16_DS
:
2777 case R_PPC64_TOC16_LO
:
2778 case R_PPC64_TOC16_HI
:
2779 case R_PPC64_TOC16_HA
:
2780 case R_PPC64_TOC16_LO_DS
:
2783 case R_PPC64_TPREL16
:
2784 case R_PPC64_TPREL16_LO
:
2785 case R_PPC64_TPREL16_HI
:
2786 case R_PPC64_TPREL16_HA
:
2787 case R_PPC64_TPREL16_DS
:
2788 case R_PPC64_TPREL16_LO_DS
:
2789 case R_PPC64_TPREL16_HIGH
:
2790 case R_PPC64_TPREL16_HIGHA
:
2791 case R_PPC64_TPREL16_HIGHER
:
2792 case R_PPC64_TPREL16_HIGHERA
:
2793 case R_PPC64_TPREL16_HIGHEST
:
2794 case R_PPC64_TPREL16_HIGHESTA
:
2795 case R_PPC64_TPREL64
:
2796 case R_PPC64_TPREL34
:
2797 /* These relocations are relative but in a shared library the
2798 linker doesn't know the thread pointer base. */
2799 return bfd_link_dll (info
);
2803 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
2804 copying dynamic variables from a shared lib into an app's .dynbss
2805 section, and instead use a dynamic relocation to point into the
2806 shared lib. With code that gcc generates it is vital that this be
2807 enabled; In the PowerPC64 ELFv1 ABI the address of a function is
2808 actually the address of a function descriptor which resides in the
2809 .opd section. gcc uses the descriptor directly rather than going
2810 via the GOT as some other ABIs do, which means that initialized
2811 function pointers reference the descriptor. Thus, a function
2812 pointer initialized to the address of a function in a shared
2813 library will either require a .dynbss copy and a copy reloc, or a
2814 dynamic reloc. Using a .dynbss copy redefines the function
2815 descriptor symbol to point to the copy. This presents a problem as
2816 a PLT entry for that function is also initialized from the function
2817 descriptor symbol and the copy may not be initialized first. */
2818 #define ELIMINATE_COPY_RELOCS 1
2820 /* Section name for stubs is the associated section name plus this
2822 #define STUB_SUFFIX ".stub"
2825 ppc_stub_long_branch:
2826 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
2827 destination, but a 24 bit branch in a stub section will reach.
2830 ppc_stub_plt_branch:
2831 Similar to the above, but a 24 bit branch in the stub section won't
2832 reach its destination.
2833 . addis %r12,%r2,xxx@toc@ha
2834 . ld %r12,xxx@toc@l(%r12)
2839 Used to call a function in a shared library. If it so happens that
2840 the plt entry referenced crosses a 64k boundary, then an extra
2841 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
2842 ppc_stub_plt_call_r2save starts with "std %r2,40(%r1)".
2843 . addis %r11,%r2,xxx@toc@ha
2844 . ld %r12,xxx+0@toc@l(%r11)
2846 . ld %r2,xxx+8@toc@l(%r11)
2847 . ld %r11,xxx+16@toc@l(%r11)
2850 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
2851 code to adjust the value and save r2 to support multiple toc sections.
2852 A ppc_stub_long_branch with an r2 offset looks like:
2854 . addis %r2,%r2,off@ha
2855 . addi %r2,%r2,off@l
2858 A ppc_stub_plt_branch with an r2 offset looks like:
2860 . addis %r12,%r2,xxx@toc@ha
2861 . ld %r12,xxx@toc@l(%r12)
2862 . addis %r2,%r2,off@ha
2863 . addi %r2,%r2,off@l
2867 All of the above stubs are shown as their ELFv1 variants. ELFv2
2868 variants exist too, simpler for plt calls since a new toc pointer
2869 and static chain are not loaded by the stub. In addition, ELFv2
2870 has some more complex stubs to handle calls marked with NOTOC
2871 relocs from functions where r2 is not a valid toc pointer. These
2872 come in two flavours, the ones shown below, and _both variants that
2873 start with "std %r2,24(%r1)" to save r2 in the unlikely event that
2874 one call is from a function where r2 is used as the toc pointer but
2875 needs a toc adjusting stub for small-model multi-toc, and another
2876 call is from a function where r2 is not valid.
2877 ppc_stub_long_branch_notoc:
2883 . addis %r12,%r11,dest-1b@ha
2884 . addi %r12,%r12,dest-1b@l
2887 ppc_stub_plt_branch_notoc:
2893 . lis %r12,xxx-1b@highest
2894 . ori %r12,%r12,xxx-1b@higher
2896 . oris %r12,%r12,xxx-1b@high
2897 . ori %r12,%r12,xxx-1b@l
2898 . add %r12,%r11,%r12
2902 ppc_stub_plt_call_notoc:
2908 . lis %r12,xxx-1b@highest
2909 . ori %r12,%r12,xxx-1b@higher
2911 . oris %r12,%r12,xxx-1b@high
2912 . ori %r12,%r12,xxx-1b@l
2913 . ldx %r12,%r11,%r12
2917 There are also ELFv1 power10 variants of these stubs.
2918 ppc_stub_long_branch_notoc:
2919 . pla %r12,dest@pcrel
2921 ppc_stub_plt_branch_notoc:
2922 . lis %r11,(dest-1f)@highesta34
2923 . ori %r11,%r11,(dest-1f)@highera34
2925 . 1: pla %r12,dest@pcrel
2926 . add %r12,%r11,%r12
2929 ppc_stub_plt_call_notoc:
2930 . lis %r11,(xxx-1f)@highesta34
2931 . ori %r11,%r11,(xxx-1f)@highera34
2933 . 1: pla %r12,xxx@pcrel
2934 . ldx %r12,%r11,%r12
2938 In cases where the high instructions would add zero, they are
2939 omitted and following instructions modified in some cases.
2940 For example, a power10 ppc_stub_plt_call_notoc might simplify down
2942 . pld %r12,xxx@pcrel
2946 For a given stub group (a set of sections all using the same toc
2947 pointer value) there will be just one stub type used for any
2948 particular function symbol. For example, if printf is called from
2949 code with the tocsave optimization (ie. r2 saved in function
2950 prologue) and therefore calls use a ppc_stub_plt_call linkage stub,
2951 and from other code without the tocsave optimization requiring a
2952 ppc_stub_plt_call_r2save linkage stub, a single stub of the latter
2953 type will be created. Calls with the tocsave optimization will
2954 enter this stub after the instruction saving r2. A similar
2955 situation exists when calls are marked with R_PPC64_REL24_NOTOC
2956 relocations. These require a ppc_stub_plt_call_notoc linkage stub
2957 to call an external function like printf. If other calls to printf
2958 require a ppc_stub_plt_call linkage stub then a single
2959 ppc_stub_plt_call_notoc linkage stub will be used for both types of
2960 call. If other calls to printf require a ppc_stub_plt_call_r2save
2961 linkage stub then a single ppc_stub_plt_call_both linkage stub will
2962 be created and calls not requiring r2 to be saved will enter the
2963 stub after the r2 save instruction. There is an analogous
2964 hierarchy of long branch and plt branch stubs for local call
2970 ppc_stub_long_branch
,
2971 ppc_stub_long_branch_r2off
,
2972 ppc_stub_long_branch_notoc
,
2973 ppc_stub_long_branch_both
, /* r2off and notoc variants both needed. */
2974 ppc_stub_plt_branch
,
2975 ppc_stub_plt_branch_r2off
,
2976 ppc_stub_plt_branch_notoc
,
2977 ppc_stub_plt_branch_both
,
2979 ppc_stub_plt_call_r2save
,
2980 ppc_stub_plt_call_notoc
,
2981 ppc_stub_plt_call_both
,
2982 ppc_stub_global_entry
,
2986 /* Information on stub grouping. */
2989 /* The stub section. */
2991 /* This is the section to which stubs in the group will be attached. */
2994 struct map_stub
*next
;
2995 /* Whether to emit a copy of register save/restore functions in this
2998 /* Current offset within stubs after the insn restoring lr in a
2999 _notoc or _both stub using bcl for pc-relative addressing, or
3000 after the insn restoring lr in a __tls_get_addr_opt plt stub. */
3001 unsigned int lr_restore
;
3002 /* Accumulated size of EH info emitted to describe return address
3003 if stubs modify lr. Does not include 17 byte FDE header. */
3004 unsigned int eh_size
;
3005 /* Offset in glink_eh_frame to the start of EH info for this group. */
3006 unsigned int eh_base
;
3009 struct ppc_stub_hash_entry
3011 /* Base hash table entry structure. */
3012 struct bfd_hash_entry root
;
3014 enum ppc_stub_type stub_type
;
3016 /* Group information. */
3017 struct map_stub
*group
;
3019 /* Offset within stub_sec of the beginning of this stub. */
3020 bfd_vma stub_offset
;
3022 /* Given the symbol's value and its section we can determine its final
3023 value when building the stubs (so the stub knows where to jump. */
3024 bfd_vma target_value
;
3025 asection
*target_section
;
3027 /* The symbol table entry, if any, that this was derived from. */
3028 struct ppc_link_hash_entry
*h
;
3029 struct plt_entry
*plt_ent
;
3032 unsigned char symtype
;
3034 /* Symbol st_other. */
3035 unsigned char other
;
3038 struct ppc_branch_hash_entry
3040 /* Base hash table entry structure. */
3041 struct bfd_hash_entry root
;
3043 /* Offset within branch lookup table. */
3044 unsigned int offset
;
3046 /* Generation marker. */
3050 /* Used to track dynamic relocations for local symbols. */
3051 struct ppc_dyn_relocs
3053 struct ppc_dyn_relocs
*next
;
3055 /* The input section of the reloc. */
3058 /* Total number of relocs copied for the input section. */
3059 unsigned int count
: 31;
3061 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3062 unsigned int ifunc
: 1;
3065 struct ppc_link_hash_entry
3067 struct elf_link_hash_entry elf
;
3071 /* A pointer to the most recently used stub hash entry against this
3073 struct ppc_stub_hash_entry
*stub_cache
;
3075 /* A pointer to the next symbol starting with a '.' */
3076 struct ppc_link_hash_entry
*next_dot_sym
;
3079 /* Track dynamic relocs copied for this symbol. */
3080 struct elf_dyn_relocs
*dyn_relocs
;
3082 /* Link between function code and descriptor symbols. */
3083 struct ppc_link_hash_entry
*oh
;
3085 /* Flag function code and descriptor symbols. */
3086 unsigned int is_func
:1;
3087 unsigned int is_func_descriptor
:1;
3088 unsigned int fake
:1;
3090 /* Whether global opd/toc sym has been adjusted or not.
3091 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3092 should be set for all globals defined in any opd/toc section. */
3093 unsigned int adjust_done
:1;
3095 /* Set if this is an out-of-line register save/restore function,
3096 with non-standard calling convention. */
3097 unsigned int save_res
:1;
3099 /* Set if a duplicate symbol with non-zero localentry is detected,
3100 even when the duplicate symbol does not provide a definition. */
3101 unsigned int non_zero_localentry
:1;
3103 /* Contexts in which symbol is used in the GOT (or TOC).
3104 Bits are or'd into the mask as the corresponding relocs are
3105 encountered during check_relocs, with TLS_TLS being set when any
3106 of the other TLS bits are set. tls_optimize clears bits when
3107 optimizing to indicate the corresponding GOT entry type is not
3108 needed. If set, TLS_TLS is never cleared. tls_optimize may also
3109 set TLS_GDIE when a GD reloc turns into an IE one.
3110 These flags are also kept for local symbols. */
3111 #define TLS_TLS 1 /* Any TLS reloc. */
3112 #define TLS_GD 2 /* GD reloc. */
3113 #define TLS_LD 4 /* LD reloc. */
3114 #define TLS_TPREL 8 /* TPREL reloc, => IE. */
3115 #define TLS_DTPREL 16 /* DTPREL reloc, => LD. */
3116 #define TLS_MARK 32 /* __tls_get_addr call marked. */
3117 #define TLS_GDIE 64 /* GOT TPREL reloc resulting from GD->IE. */
3118 #define TLS_EXPLICIT 256 /* TOC section TLS reloc, not stored. */
3119 unsigned char tls_mask
;
3121 /* The above field is also used to mark function symbols. In which
3122 case TLS_TLS will be 0. */
3123 #define PLT_IFUNC 2 /* STT_GNU_IFUNC. */
3124 #define PLT_KEEP 4 /* inline plt call requires plt entry. */
3125 #define NON_GOT 256 /* local symbol plt, not stored. */
3128 static inline struct ppc_link_hash_entry
*
3129 ppc_elf_hash_entry (struct elf_link_hash_entry
*ent
)
3131 return (struct ppc_link_hash_entry
*) ent
;
3134 /* ppc64 ELF linker hash table. */
3136 struct ppc_link_hash_table
3138 struct elf_link_hash_table elf
;
3140 /* The stub hash table. */
3141 struct bfd_hash_table stub_hash_table
;
3143 /* Another hash table for plt_branch stubs. */
3144 struct bfd_hash_table branch_hash_table
;
3146 /* Hash table for function prologue tocsave. */
3147 htab_t tocsave_htab
;
3149 /* Various options and other info passed from the linker. */
3150 struct ppc64_elf_params
*params
;
3152 /* The size of sec_info below. */
3153 unsigned int sec_info_arr_size
;
3155 /* Per-section array of extra section info. Done this way rather
3156 than as part of ppc64_elf_section_data so we have the info for
3157 non-ppc64 sections. */
3160 /* Along with elf_gp, specifies the TOC pointer used by this section. */
3165 /* The section group that this section belongs to. */
3166 struct map_stub
*group
;
3167 /* A temp section list pointer. */
3172 /* Linked list of groups. */
3173 struct map_stub
*group
;
3175 /* Temp used when calculating TOC pointers. */
3178 asection
*toc_first_sec
;
3180 /* Used when adding symbols. */
3181 struct ppc_link_hash_entry
*dot_syms
;
3183 /* Shortcuts to get to dynamic linker sections. */
3185 asection
*global_entry
;
3188 asection
*relpltlocal
;
3191 asection
*glink_eh_frame
;
3193 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
3194 struct ppc_link_hash_entry
*tls_get_addr
;
3195 struct ppc_link_hash_entry
*tls_get_addr_fd
;
3196 struct ppc_link_hash_entry
*tga_desc
;
3197 struct ppc_link_hash_entry
*tga_desc_fd
;
3198 struct map_stub
*tga_group
;
3200 /* The size of reliplt used by got entry relocs. */
3201 bfd_size_type got_reli_size
;
3204 unsigned long stub_count
[ppc_stub_global_entry
];
3206 /* Number of stubs against global syms. */
3207 unsigned long stub_globals
;
3209 /* Set if we're linking code with function descriptors. */
3210 unsigned int opd_abi
:1;
3212 /* Support for multiple toc sections. */
3213 unsigned int do_multi_toc
:1;
3214 unsigned int multi_toc_needed
:1;
3215 unsigned int second_toc_pass
:1;
3216 unsigned int do_toc_opt
:1;
3218 /* Set if tls optimization is enabled. */
3219 unsigned int do_tls_opt
:1;
3221 /* Set if inline plt calls should be converted to direct calls. */
3222 unsigned int can_convert_all_inline_plt
:1;
3225 unsigned int stub_error
:1;
3227 /* Whether func_desc_adjust needs to be run over symbols. */
3228 unsigned int need_func_desc_adj
:1;
3230 /* Whether there exist local gnu indirect function resolvers,
3231 referenced by dynamic relocations. */
3232 unsigned int local_ifunc_resolver
:1;
3233 unsigned int maybe_local_ifunc_resolver
:1;
3235 /* Whether plt calls for ELFv2 localentry:0 funcs have been optimized. */
3236 unsigned int has_plt_localentry0
:1;
3238 /* Whether calls are made via the PLT from NOTOC functions. */
3239 unsigned int notoc_plt
:1;
3241 /* Whether to use power10 instructions in linkage stubs. */
3242 unsigned int power10_stubs
:1;
3244 /* Incremented every time we size stubs. */
3245 unsigned int stub_iteration
;
3247 /* Small local sym cache. */
3248 struct sym_cache sym_cache
;
3251 /* Rename some of the generic section flags to better document how they
3254 /* Nonzero if this section has TLS related relocations. */
3255 #define has_tls_reloc sec_flg0
3257 /* Nonzero if this section has a call to __tls_get_addr lacking marker
3259 #define nomark_tls_get_addr sec_flg1
3261 /* Nonzero if this section has any toc or got relocs. */
3262 #define has_toc_reloc sec_flg2
3264 /* Nonzero if this section has a call to another section that uses
3266 #define makes_toc_func_call sec_flg3
3268 /* Recursion protection when determining above flag. */
3269 #define call_check_in_progress sec_flg4
3270 #define call_check_done sec_flg5
3272 /* Get the ppc64 ELF linker hash table from a link_info structure. */
3274 #define ppc_hash_table(p) \
3275 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3276 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3278 #define ppc_stub_hash_lookup(table, string, create, copy) \
3279 ((struct ppc_stub_hash_entry *) \
3280 bfd_hash_lookup ((table), (string), (create), (copy)))
3282 #define ppc_branch_hash_lookup(table, string, create, copy) \
3283 ((struct ppc_branch_hash_entry *) \
3284 bfd_hash_lookup ((table), (string), (create), (copy)))
3286 /* Create an entry in the stub hash table. */
3288 static struct bfd_hash_entry
*
3289 stub_hash_newfunc (struct bfd_hash_entry
*entry
,
3290 struct bfd_hash_table
*table
,
3293 /* Allocate the structure if it has not already been allocated by a
3297 entry
= bfd_hash_allocate (table
, sizeof (struct ppc_stub_hash_entry
));
3302 /* Call the allocation method of the superclass. */
3303 entry
= bfd_hash_newfunc (entry
, table
, string
);
3306 struct ppc_stub_hash_entry
*eh
;
3308 /* Initialize the local fields. */
3309 eh
= (struct ppc_stub_hash_entry
*) entry
;
3310 eh
->stub_type
= ppc_stub_none
;
3312 eh
->stub_offset
= 0;
3313 eh
->target_value
= 0;
3314 eh
->target_section
= NULL
;
3323 /* Create an entry in the branch hash table. */
3325 static struct bfd_hash_entry
*
3326 branch_hash_newfunc (struct bfd_hash_entry
*entry
,
3327 struct bfd_hash_table
*table
,
3330 /* Allocate the structure if it has not already been allocated by a
3334 entry
= bfd_hash_allocate (table
, sizeof (struct ppc_branch_hash_entry
));
3339 /* Call the allocation method of the superclass. */
3340 entry
= bfd_hash_newfunc (entry
, table
, string
);
3343 struct ppc_branch_hash_entry
*eh
;
3345 /* Initialize the local fields. */
3346 eh
= (struct ppc_branch_hash_entry
*) entry
;
3354 /* Create an entry in a ppc64 ELF linker hash table. */
3356 static struct bfd_hash_entry
*
3357 link_hash_newfunc (struct bfd_hash_entry
*entry
,
3358 struct bfd_hash_table
*table
,
3361 /* Allocate the structure if it has not already been allocated by a
3365 entry
= bfd_hash_allocate (table
, sizeof (struct ppc_link_hash_entry
));
3370 /* Call the allocation method of the superclass. */
3371 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
3374 struct ppc_link_hash_entry
*eh
= (struct ppc_link_hash_entry
*) entry
;
3376 memset (&eh
->u
.stub_cache
, 0,
3377 (sizeof (struct ppc_link_hash_entry
)
3378 - offsetof (struct ppc_link_hash_entry
, u
.stub_cache
)));
3380 /* When making function calls, old ABI code references function entry
3381 points (dot symbols), while new ABI code references the function
3382 descriptor symbol. We need to make any combination of reference and
3383 definition work together, without breaking archive linking.
3385 For a defined function "foo" and an undefined call to "bar":
3386 An old object defines "foo" and ".foo", references ".bar" (possibly
3388 A new object defines "foo" and references "bar".
3390 A new object thus has no problem with its undefined symbols being
3391 satisfied by definitions in an old object. On the other hand, the
3392 old object won't have ".bar" satisfied by a new object.
3394 Keep a list of newly added dot-symbols. */
3396 if (string
[0] == '.')
3398 struct ppc_link_hash_table
*htab
;
3400 htab
= (struct ppc_link_hash_table
*) table
;
3401 eh
->u
.next_dot_sym
= htab
->dot_syms
;
3402 htab
->dot_syms
= eh
;
3409 struct tocsave_entry
3416 tocsave_htab_hash (const void *p
)
3418 const struct tocsave_entry
*e
= (const struct tocsave_entry
*) p
;
3419 return ((bfd_vma
) (intptr_t) e
->sec
^ e
->offset
) >> 3;
3423 tocsave_htab_eq (const void *p1
, const void *p2
)
3425 const struct tocsave_entry
*e1
= (const struct tocsave_entry
*) p1
;
3426 const struct tocsave_entry
*e2
= (const struct tocsave_entry
*) p2
;
3427 return e1
->sec
== e2
->sec
&& e1
->offset
== e2
->offset
;
3430 /* Destroy a ppc64 ELF linker hash table. */
3433 ppc64_elf_link_hash_table_free (bfd
*obfd
)
3435 struct ppc_link_hash_table
*htab
;
3437 htab
= (struct ppc_link_hash_table
*) obfd
->link
.hash
;
3438 if (htab
->tocsave_htab
)
3439 htab_delete (htab
->tocsave_htab
);
3440 bfd_hash_table_free (&htab
->branch_hash_table
);
3441 bfd_hash_table_free (&htab
->stub_hash_table
);
3442 _bfd_elf_link_hash_table_free (obfd
);
3445 /* Create a ppc64 ELF linker hash table. */
3447 static struct bfd_link_hash_table
*
3448 ppc64_elf_link_hash_table_create (bfd
*abfd
)
3450 struct ppc_link_hash_table
*htab
;
3451 size_t amt
= sizeof (struct ppc_link_hash_table
);
3453 htab
= bfd_zmalloc (amt
);
3457 if (!_bfd_elf_link_hash_table_init (&htab
->elf
, abfd
, link_hash_newfunc
,
3458 sizeof (struct ppc_link_hash_entry
),
3465 /* Init the stub hash table too. */
3466 if (!bfd_hash_table_init (&htab
->stub_hash_table
, stub_hash_newfunc
,
3467 sizeof (struct ppc_stub_hash_entry
)))
3469 _bfd_elf_link_hash_table_free (abfd
);
3473 /* And the branch hash table. */
3474 if (!bfd_hash_table_init (&htab
->branch_hash_table
, branch_hash_newfunc
,
3475 sizeof (struct ppc_branch_hash_entry
)))
3477 bfd_hash_table_free (&htab
->stub_hash_table
);
3478 _bfd_elf_link_hash_table_free (abfd
);
3482 htab
->tocsave_htab
= htab_try_create (1024,
3486 if (htab
->tocsave_htab
== NULL
)
3488 ppc64_elf_link_hash_table_free (abfd
);
3491 htab
->elf
.root
.hash_table_free
= ppc64_elf_link_hash_table_free
;
3493 /* Initializing two fields of the union is just cosmetic. We really
3494 only care about glist, but when compiled on a 32-bit host the
3495 bfd_vma fields are larger. Setting the bfd_vma to zero makes
3496 debugger inspection of these fields look nicer. */
3497 htab
->elf
.init_got_refcount
.refcount
= 0;
3498 htab
->elf
.init_got_refcount
.glist
= NULL
;
3499 htab
->elf
.init_plt_refcount
.refcount
= 0;
3500 htab
->elf
.init_plt_refcount
.glist
= NULL
;
3501 htab
->elf
.init_got_offset
.offset
= 0;
3502 htab
->elf
.init_got_offset
.glist
= NULL
;
3503 htab
->elf
.init_plt_offset
.offset
= 0;
3504 htab
->elf
.init_plt_offset
.glist
= NULL
;
3506 return &htab
->elf
.root
;
3509 /* Create sections for linker generated code. */
3512 create_linkage_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
3514 struct ppc_link_hash_table
*htab
;
3517 htab
= ppc_hash_table (info
);
3519 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_READONLY
3520 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3521 if (htab
->params
->save_restore_funcs
)
3523 /* Create .sfpr for code to save and restore fp regs. */
3524 htab
->sfpr
= bfd_make_section_anyway_with_flags (dynobj
, ".sfpr",
3526 if (htab
->sfpr
== NULL
3527 || !bfd_set_section_alignment (htab
->sfpr
, 2))
3531 if (bfd_link_relocatable (info
))
3534 /* Create .glink for lazy dynamic linking support. */
3535 htab
->glink
= bfd_make_section_anyway_with_flags (dynobj
, ".glink",
3537 if (htab
->glink
== NULL
3538 || !bfd_set_section_alignment (htab
->glink
, 3))
3541 /* The part of .glink used by global entry stubs, separate so that
3542 it can be aligned appropriately without affecting htab->glink. */
3543 htab
->global_entry
= bfd_make_section_anyway_with_flags (dynobj
, ".glink",
3545 if (htab
->global_entry
== NULL
3546 || !bfd_set_section_alignment (htab
->global_entry
, 2))
3549 if (!info
->no_ld_generated_unwind_info
)
3551 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_HAS_CONTENTS
3552 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3553 htab
->glink_eh_frame
= bfd_make_section_anyway_with_flags (dynobj
,
3556 if (htab
->glink_eh_frame
== NULL
3557 || !bfd_set_section_alignment (htab
->glink_eh_frame
, 2))
3561 flags
= SEC_ALLOC
| SEC_LINKER_CREATED
;
3562 htab
->elf
.iplt
= bfd_make_section_anyway_with_flags (dynobj
, ".iplt", flags
);
3563 if (htab
->elf
.iplt
== NULL
3564 || !bfd_set_section_alignment (htab
->elf
.iplt
, 3))
3567 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
3568 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3570 = bfd_make_section_anyway_with_flags (dynobj
, ".rela.iplt", flags
);
3571 if (htab
->elf
.irelplt
== NULL
3572 || !bfd_set_section_alignment (htab
->elf
.irelplt
, 3))
3575 /* Create branch lookup table for plt_branch stubs. */
3576 flags
= (SEC_ALLOC
| SEC_LOAD
3577 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3578 htab
->brlt
= bfd_make_section_anyway_with_flags (dynobj
, ".branch_lt",
3580 if (htab
->brlt
== NULL
3581 || !bfd_set_section_alignment (htab
->brlt
, 3))
3584 /* Local plt entries, put in .branch_lt but a separate section for
3586 htab
->pltlocal
= bfd_make_section_anyway_with_flags (dynobj
, ".branch_lt",
3588 if (htab
->pltlocal
== NULL
3589 || !bfd_set_section_alignment (htab
->pltlocal
, 3))
3592 if (!bfd_link_pic (info
))
3595 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
3596 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3598 = bfd_make_section_anyway_with_flags (dynobj
, ".rela.branch_lt", flags
);
3599 if (htab
->relbrlt
== NULL
3600 || !bfd_set_section_alignment (htab
->relbrlt
, 3))
3604 = bfd_make_section_anyway_with_flags (dynobj
, ".rela.branch_lt", flags
);
3605 if (htab
->relpltlocal
== NULL
3606 || !bfd_set_section_alignment (htab
->relpltlocal
, 3))
3612 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
3615 ppc64_elf_init_stub_bfd (struct bfd_link_info
*info
,
3616 struct ppc64_elf_params
*params
)
3618 struct ppc_link_hash_table
*htab
;
3620 elf_elfheader (params
->stub_bfd
)->e_ident
[EI_CLASS
] = ELFCLASS64
;
3622 /* Always hook our dynamic sections into the first bfd, which is the
3623 linker created stub bfd. This ensures that the GOT header is at
3624 the start of the output TOC section. */
3625 htab
= ppc_hash_table (info
);
3626 htab
->elf
.dynobj
= params
->stub_bfd
;
3627 htab
->params
= params
;
3629 return create_linkage_sections (htab
->elf
.dynobj
, info
);
3632 /* Build a name for an entry in the stub hash table. */
3635 ppc_stub_name (const asection
*input_section
,
3636 const asection
*sym_sec
,
3637 const struct ppc_link_hash_entry
*h
,
3638 const Elf_Internal_Rela
*rel
)
3643 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
3644 offsets from a sym as a branch target? In fact, we could
3645 probably assume the addend is always zero. */
3646 BFD_ASSERT (((int) rel
->r_addend
& 0xffffffff) == rel
->r_addend
);
3650 len
= 8 + 1 + strlen (h
->elf
.root
.root
.string
) + 1 + 8 + 1;
3651 stub_name
= bfd_malloc (len
);
3652 if (stub_name
== NULL
)
3655 len
= sprintf (stub_name
, "%08x.%s+%x",
3656 input_section
->id
& 0xffffffff,
3657 h
->elf
.root
.root
.string
,
3658 (int) rel
->r_addend
& 0xffffffff);
3662 len
= 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
3663 stub_name
= bfd_malloc (len
);
3664 if (stub_name
== NULL
)
3667 len
= sprintf (stub_name
, "%08x.%x:%x+%x",
3668 input_section
->id
& 0xffffffff,
3669 sym_sec
->id
& 0xffffffff,
3670 (int) ELF64_R_SYM (rel
->r_info
) & 0xffffffff,
3671 (int) rel
->r_addend
& 0xffffffff);
3673 if (len
> 2 && stub_name
[len
- 2] == '+' && stub_name
[len
- 1] == '0')
3674 stub_name
[len
- 2] = 0;
3678 /* Look up an entry in the stub hash. Stub entries are cached because
3679 creating the stub name takes a bit of time. */
3681 static struct ppc_stub_hash_entry
*
3682 ppc_get_stub_entry (const asection
*input_section
,
3683 const asection
*sym_sec
,
3684 struct ppc_link_hash_entry
*h
,
3685 const Elf_Internal_Rela
*rel
,
3686 struct ppc_link_hash_table
*htab
)
3688 struct ppc_stub_hash_entry
*stub_entry
;
3689 struct map_stub
*group
;
3691 /* If this input section is part of a group of sections sharing one
3692 stub section, then use the id of the first section in the group.
3693 Stub names need to include a section id, as there may well be
3694 more than one stub used to reach say, printf, and we need to
3695 distinguish between them. */
3696 group
= htab
->sec_info
[input_section
->id
].u
.group
;
3700 if (h
!= NULL
&& h
->u
.stub_cache
!= NULL
3701 && h
->u
.stub_cache
->h
== h
3702 && h
->u
.stub_cache
->group
== group
)
3704 stub_entry
= h
->u
.stub_cache
;
3710 stub_name
= ppc_stub_name (group
->link_sec
, sym_sec
, h
, rel
);
3711 if (stub_name
== NULL
)
3714 stub_entry
= ppc_stub_hash_lookup (&htab
->stub_hash_table
,
3715 stub_name
, FALSE
, FALSE
);
3717 h
->u
.stub_cache
= stub_entry
;
3725 /* Add a new stub entry to the stub hash. Not all fields of the new
3726 stub entry are initialised. */
3728 static struct ppc_stub_hash_entry
*
3729 ppc_add_stub (const char *stub_name
,
3731 struct bfd_link_info
*info
)
3733 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
3734 struct map_stub
*group
;
3737 struct ppc_stub_hash_entry
*stub_entry
;
3739 group
= htab
->sec_info
[section
->id
].u
.group
;
3740 link_sec
= group
->link_sec
;
3741 stub_sec
= group
->stub_sec
;
3742 if (stub_sec
== NULL
)
3748 namelen
= strlen (link_sec
->name
);
3749 len
= namelen
+ sizeof (STUB_SUFFIX
);
3750 s_name
= bfd_alloc (htab
->params
->stub_bfd
, len
);
3754 memcpy (s_name
, link_sec
->name
, namelen
);
3755 memcpy (s_name
+ namelen
, STUB_SUFFIX
, sizeof (STUB_SUFFIX
));
3756 stub_sec
= (*htab
->params
->add_stub_section
) (s_name
, link_sec
);
3757 if (stub_sec
== NULL
)
3759 group
->stub_sec
= stub_sec
;
3762 /* Enter this entry into the linker stub hash table. */
3763 stub_entry
= ppc_stub_hash_lookup (&htab
->stub_hash_table
, stub_name
,
3765 if (stub_entry
== NULL
)
3767 /* xgettext:c-format */
3768 _bfd_error_handler (_("%pB: cannot create stub entry %s"),
3769 section
->owner
, stub_name
);
3773 stub_entry
->group
= group
;
3774 stub_entry
->stub_offset
= 0;
3778 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
3779 not already done. */
3782 create_got_section (bfd
*abfd
, struct bfd_link_info
*info
)
3784 asection
*got
, *relgot
;
3786 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
3788 if (!is_ppc64_elf (abfd
))
3794 && !_bfd_elf_create_got_section (htab
->elf
.dynobj
, info
))
3797 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
3798 | SEC_LINKER_CREATED
);
3800 got
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
3802 || !bfd_set_section_alignment (got
, 3))
3805 relgot
= bfd_make_section_anyway_with_flags (abfd
, ".rela.got",
3806 flags
| SEC_READONLY
);
3808 || !bfd_set_section_alignment (relgot
, 3))
3811 ppc64_elf_tdata (abfd
)->got
= got
;
3812 ppc64_elf_tdata (abfd
)->relgot
= relgot
;
3816 /* Follow indirect and warning symbol links. */
3818 static inline struct bfd_link_hash_entry
*
3819 follow_link (struct bfd_link_hash_entry
*h
)
3821 while (h
->type
== bfd_link_hash_indirect
3822 || h
->type
== bfd_link_hash_warning
)
3827 static inline struct elf_link_hash_entry
*
3828 elf_follow_link (struct elf_link_hash_entry
*h
)
3830 return (struct elf_link_hash_entry
*) follow_link (&h
->root
);
3833 static inline struct ppc_link_hash_entry
*
3834 ppc_follow_link (struct ppc_link_hash_entry
*h
)
3836 return ppc_elf_hash_entry (elf_follow_link (&h
->elf
));
3839 /* Merge PLT info on FROM with that on TO. */
3842 move_plt_plist (struct ppc_link_hash_entry
*from
,
3843 struct ppc_link_hash_entry
*to
)
3845 if (from
->elf
.plt
.plist
!= NULL
)
3847 if (to
->elf
.plt
.plist
!= NULL
)
3849 struct plt_entry
**entp
;
3850 struct plt_entry
*ent
;
3852 for (entp
= &from
->elf
.plt
.plist
; (ent
= *entp
) != NULL
; )
3854 struct plt_entry
*dent
;
3856 for (dent
= to
->elf
.plt
.plist
; dent
!= NULL
; dent
= dent
->next
)
3857 if (dent
->addend
== ent
->addend
)
3859 dent
->plt
.refcount
+= ent
->plt
.refcount
;
3866 *entp
= to
->elf
.plt
.plist
;
3869 to
->elf
.plt
.plist
= from
->elf
.plt
.plist
;
3870 from
->elf
.plt
.plist
= NULL
;
3874 /* Copy the extra info we tack onto an elf_link_hash_entry. */
3877 ppc64_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
3878 struct elf_link_hash_entry
*dir
,
3879 struct elf_link_hash_entry
*ind
)
3881 struct ppc_link_hash_entry
*edir
, *eind
;
3883 edir
= ppc_elf_hash_entry (dir
);
3884 eind
= ppc_elf_hash_entry (ind
);
3886 edir
->is_func
|= eind
->is_func
;
3887 edir
->is_func_descriptor
|= eind
->is_func_descriptor
;
3888 edir
->tls_mask
|= eind
->tls_mask
;
3889 if (eind
->oh
!= NULL
)
3890 edir
->oh
= ppc_follow_link (eind
->oh
);
3892 if (edir
->elf
.versioned
!= versioned_hidden
)
3893 edir
->elf
.ref_dynamic
|= eind
->elf
.ref_dynamic
;
3894 edir
->elf
.ref_regular
|= eind
->elf
.ref_regular
;
3895 edir
->elf
.ref_regular_nonweak
|= eind
->elf
.ref_regular_nonweak
;
3896 edir
->elf
.non_got_ref
|= eind
->elf
.non_got_ref
;
3897 edir
->elf
.needs_plt
|= eind
->elf
.needs_plt
;
3898 edir
->elf
.pointer_equality_needed
|= eind
->elf
.pointer_equality_needed
;
3900 /* If we were called to copy over info for a weak sym, don't copy
3901 dyn_relocs, plt/got info, or dynindx. We used to copy dyn_relocs
3902 in order to simplify readonly_dynrelocs and save a field in the
3903 symbol hash entry, but that means dyn_relocs can't be used in any
3904 tests about a specific symbol, or affect other symbol flags which
3906 if (eind
->elf
.root
.type
!= bfd_link_hash_indirect
)
3909 /* Copy over any dynamic relocs we may have on the indirect sym. */
3910 if (eind
->dyn_relocs
!= NULL
)
3912 if (edir
->dyn_relocs
!= NULL
)
3914 struct elf_dyn_relocs
**pp
;
3915 struct elf_dyn_relocs
*p
;
3917 /* Add reloc counts against the indirect sym to the direct sym
3918 list. Merge any entries against the same section. */
3919 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
3921 struct elf_dyn_relocs
*q
;
3923 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
3924 if (q
->sec
== p
->sec
)
3926 q
->pc_count
+= p
->pc_count
;
3927 q
->count
+= p
->count
;
3934 *pp
= edir
->dyn_relocs
;
3937 edir
->dyn_relocs
= eind
->dyn_relocs
;
3938 eind
->dyn_relocs
= NULL
;
3941 /* Copy over got entries that we may have already seen to the
3942 symbol which just became indirect. */
3943 if (eind
->elf
.got
.glist
!= NULL
)
3945 if (edir
->elf
.got
.glist
!= NULL
)
3947 struct got_entry
**entp
;
3948 struct got_entry
*ent
;
3950 for (entp
= &eind
->elf
.got
.glist
; (ent
= *entp
) != NULL
; )
3952 struct got_entry
*dent
;
3954 for (dent
= edir
->elf
.got
.glist
; dent
!= NULL
; dent
= dent
->next
)
3955 if (dent
->addend
== ent
->addend
3956 && dent
->owner
== ent
->owner
3957 && dent
->tls_type
== ent
->tls_type
)
3959 dent
->got
.refcount
+= ent
->got
.refcount
;
3966 *entp
= edir
->elf
.got
.glist
;
3969 edir
->elf
.got
.glist
= eind
->elf
.got
.glist
;
3970 eind
->elf
.got
.glist
= NULL
;
3973 /* And plt entries. */
3974 move_plt_plist (eind
, edir
);
3976 if (eind
->elf
.dynindx
!= -1)
3978 if (edir
->elf
.dynindx
!= -1)
3979 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
3980 edir
->elf
.dynstr_index
);
3981 edir
->elf
.dynindx
= eind
->elf
.dynindx
;
3982 edir
->elf
.dynstr_index
= eind
->elf
.dynstr_index
;
3983 eind
->elf
.dynindx
= -1;
3984 eind
->elf
.dynstr_index
= 0;
3988 /* Find the function descriptor hash entry from the given function code
3989 hash entry FH. Link the entries via their OH fields. */
3991 static struct ppc_link_hash_entry
*
3992 lookup_fdh (struct ppc_link_hash_entry
*fh
, struct ppc_link_hash_table
*htab
)
3994 struct ppc_link_hash_entry
*fdh
= fh
->oh
;
3998 const char *fd_name
= fh
->elf
.root
.root
.string
+ 1;
4000 fdh
= ppc_elf_hash_entry (elf_link_hash_lookup (&htab
->elf
, fd_name
,
4001 FALSE
, FALSE
, FALSE
));
4005 fdh
->is_func_descriptor
= 1;
4011 fdh
= ppc_follow_link (fdh
);
4012 fdh
->is_func_descriptor
= 1;
4017 /* Make a fake function descriptor sym for the undefined code sym FH. */
4019 static struct ppc_link_hash_entry
*
4020 make_fdh (struct bfd_link_info
*info
,
4021 struct ppc_link_hash_entry
*fh
)
4023 bfd
*abfd
= fh
->elf
.root
.u
.undef
.abfd
;
4024 struct bfd_link_hash_entry
*bh
= NULL
;
4025 struct ppc_link_hash_entry
*fdh
;
4026 flagword flags
= (fh
->elf
.root
.type
== bfd_link_hash_undefweak
4030 if (!_bfd_generic_link_add_one_symbol (info
, abfd
,
4031 fh
->elf
.root
.root
.string
+ 1,
4032 flags
, bfd_und_section_ptr
, 0,
4033 NULL
, FALSE
, FALSE
, &bh
))
4036 fdh
= (struct ppc_link_hash_entry
*) bh
;
4037 fdh
->elf
.non_elf
= 0;
4039 fdh
->is_func_descriptor
= 1;
4046 /* Fix function descriptor symbols defined in .opd sections to be
4050 ppc64_elf_add_symbol_hook (bfd
*ibfd
,
4051 struct bfd_link_info
*info
,
4052 Elf_Internal_Sym
*isym
,
4054 flagword
*flags ATTRIBUTE_UNUSED
,
4059 && strcmp ((*sec
)->name
, ".opd") == 0)
4063 if (!(ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
4064 || ELF_ST_TYPE (isym
->st_info
) == STT_FUNC
))
4065 isym
->st_info
= ELF_ST_INFO (ELF_ST_BIND (isym
->st_info
), STT_FUNC
);
4067 /* If the symbol is a function defined in .opd, and the function
4068 code is in a discarded group, let it appear to be undefined. */
4069 if (!bfd_link_relocatable (info
)
4070 && (*sec
)->reloc_count
!= 0
4071 && opd_entry_value (*sec
, *value
, &code_sec
, NULL
,
4072 FALSE
) != (bfd_vma
) -1
4073 && discarded_section (code_sec
))
4075 *sec
= bfd_und_section_ptr
;
4076 isym
->st_shndx
= SHN_UNDEF
;
4079 else if (*sec
!= NULL
4080 && strcmp ((*sec
)->name
, ".toc") == 0
4081 && ELF_ST_TYPE (isym
->st_info
) == STT_OBJECT
)
4083 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
4085 htab
->params
->object_in_toc
= 1;
4088 if ((STO_PPC64_LOCAL_MASK
& isym
->st_other
) != 0)
4090 if (abiversion (ibfd
) == 0)
4091 set_abiversion (ibfd
, 2);
4092 else if (abiversion (ibfd
) == 1)
4094 _bfd_error_handler (_("symbol '%s' has invalid st_other"
4095 " for ABI version 1"), *name
);
4096 bfd_set_error (bfd_error_bad_value
);
4104 /* Merge non-visibility st_other attributes: local entry point. */
4107 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry
*h
,
4108 const Elf_Internal_Sym
*isym
,
4109 bfd_boolean definition
,
4110 bfd_boolean dynamic
)
4112 if (definition
&& (!dynamic
|| !h
->def_regular
))
4113 h
->other
= ((isym
->st_other
& ~ELF_ST_VISIBILITY (-1))
4114 | ELF_ST_VISIBILITY (h
->other
));
4117 /* Hook called on merging a symbol. We use this to clear "fake" since
4118 we now have a real symbol. */
4121 ppc64_elf_merge_symbol (struct elf_link_hash_entry
*h
,
4122 const Elf_Internal_Sym
*isym
,
4123 asection
**psec ATTRIBUTE_UNUSED
,
4124 bfd_boolean newdef ATTRIBUTE_UNUSED
,
4125 bfd_boolean olddef ATTRIBUTE_UNUSED
,
4126 bfd
*oldbfd ATTRIBUTE_UNUSED
,
4127 const asection
*oldsec ATTRIBUTE_UNUSED
)
4129 ppc_elf_hash_entry (h
)->fake
= 0;
4130 if ((STO_PPC64_LOCAL_MASK
& isym
->st_other
) != 0)
4131 ppc_elf_hash_entry (h
)->non_zero_localentry
= 1;
4135 /* This function makes an old ABI object reference to ".bar" cause the
4136 inclusion of a new ABI object archive that defines "bar".
4137 NAME is a symbol defined in an archive. Return a symbol in the hash
4138 table that might be satisfied by the archive symbols. */
4140 static struct elf_link_hash_entry
*
4141 ppc64_elf_archive_symbol_lookup (bfd
*abfd
,
4142 struct bfd_link_info
*info
,
4145 struct elf_link_hash_entry
*h
;
4149 h
= _bfd_elf_archive_symbol_lookup (abfd
, info
, name
);
4151 /* Don't return this sym if it is a fake function descriptor
4152 created by add_symbol_adjust. */
4153 && !ppc_elf_hash_entry (h
)->fake
)
4159 len
= strlen (name
);
4160 dot_name
= bfd_alloc (abfd
, len
+ 2);
4161 if (dot_name
== NULL
)
4162 return (struct elf_link_hash_entry
*) -1;
4164 memcpy (dot_name
+ 1, name
, len
+ 1);
4165 h
= _bfd_elf_archive_symbol_lookup (abfd
, info
, dot_name
);
4166 bfd_release (abfd
, dot_name
);
4170 if (strcmp (name
, "__tls_get_addr_opt") == 0)
4171 h
= _bfd_elf_archive_symbol_lookup (abfd
, info
, "__tls_get_addr_desc");
4175 /* This function satisfies all old ABI object references to ".bar" if a
4176 new ABI object defines "bar". Well, at least, undefined dot symbols
4177 are made weak. This stops later archive searches from including an
4178 object if we already have a function descriptor definition. It also
4179 prevents the linker complaining about undefined symbols.
4180 We also check and correct mismatched symbol visibility here. The
4181 most restrictive visibility of the function descriptor and the
4182 function entry symbol is used. */
4185 add_symbol_adjust (struct ppc_link_hash_entry
*eh
, struct bfd_link_info
*info
)
4187 struct ppc_link_hash_table
*htab
;
4188 struct ppc_link_hash_entry
*fdh
;
4190 if (eh
->elf
.root
.type
== bfd_link_hash_warning
)
4191 eh
= (struct ppc_link_hash_entry
*) eh
->elf
.root
.u
.i
.link
;
4193 if (eh
->elf
.root
.type
== bfd_link_hash_indirect
)
4196 if (eh
->elf
.root
.root
.string
[0] != '.')
4199 htab
= ppc_hash_table (info
);
4203 fdh
= lookup_fdh (eh
, htab
);
4205 && !bfd_link_relocatable (info
)
4206 && (eh
->elf
.root
.type
== bfd_link_hash_undefined
4207 || eh
->elf
.root
.type
== bfd_link_hash_undefweak
)
4208 && eh
->elf
.ref_regular
)
4210 /* Make an undefined function descriptor sym, in order to
4211 pull in an --as-needed shared lib. Archives are handled
4213 fdh
= make_fdh (info
, eh
);
4220 unsigned entry_vis
= ELF_ST_VISIBILITY (eh
->elf
.other
) - 1;
4221 unsigned descr_vis
= ELF_ST_VISIBILITY (fdh
->elf
.other
) - 1;
4223 /* Make both descriptor and entry symbol have the most
4224 constraining visibility of either symbol. */
4225 if (entry_vis
< descr_vis
)
4226 fdh
->elf
.other
+= entry_vis
- descr_vis
;
4227 else if (entry_vis
> descr_vis
)
4228 eh
->elf
.other
+= descr_vis
- entry_vis
;
4230 /* Propagate reference flags from entry symbol to function
4231 descriptor symbol. */
4232 fdh
->elf
.root
.non_ir_ref_regular
|= eh
->elf
.root
.non_ir_ref_regular
;
4233 fdh
->elf
.root
.non_ir_ref_dynamic
|= eh
->elf
.root
.non_ir_ref_dynamic
;
4234 fdh
->elf
.ref_regular
|= eh
->elf
.ref_regular
;
4235 fdh
->elf
.ref_regular_nonweak
|= eh
->elf
.ref_regular_nonweak
;
4237 if (!fdh
->elf
.forced_local
4238 && fdh
->elf
.dynindx
== -1
4239 && fdh
->elf
.versioned
!= versioned_hidden
4240 && (bfd_link_dll (info
)
4241 || fdh
->elf
.def_dynamic
4242 || fdh
->elf
.ref_dynamic
)
4243 && (eh
->elf
.ref_regular
4244 || eh
->elf
.def_regular
))
4246 if (!bfd_elf_link_record_dynamic_symbol (info
, &fdh
->elf
))
4254 /* Set up opd section info and abiversion for IBFD, and process list
4255 of dot-symbols we made in link_hash_newfunc. */
4258 ppc64_elf_before_check_relocs (bfd
*ibfd
, struct bfd_link_info
*info
)
4260 struct ppc_link_hash_table
*htab
;
4261 struct ppc_link_hash_entry
**p
, *eh
;
4262 asection
*opd
= bfd_get_section_by_name (ibfd
, ".opd");
4264 if (opd
!= NULL
&& opd
->size
!= 0)
4266 BFD_ASSERT (ppc64_elf_section_data (opd
)->sec_type
== sec_normal
);
4267 ppc64_elf_section_data (opd
)->sec_type
= sec_opd
;
4269 if (abiversion (ibfd
) == 0)
4270 set_abiversion (ibfd
, 1);
4271 else if (abiversion (ibfd
) >= 2)
4273 /* xgettext:c-format */
4274 _bfd_error_handler (_("%pB .opd not allowed in ABI version %d"),
4275 ibfd
, abiversion (ibfd
));
4276 bfd_set_error (bfd_error_bad_value
);
4281 if (is_ppc64_elf (info
->output_bfd
))
4283 /* For input files without an explicit abiversion in e_flags
4284 we should have flagged any with symbol st_other bits set
4285 as ELFv1 and above flagged those with .opd as ELFv2.
4286 Set the output abiversion if not yet set, and for any input
4287 still ambiguous, take its abiversion from the output.
4288 Differences in ABI are reported later. */
4289 if (abiversion (info
->output_bfd
) == 0)
4290 set_abiversion (info
->output_bfd
, abiversion (ibfd
));
4291 else if (abiversion (ibfd
) == 0)
4292 set_abiversion (ibfd
, abiversion (info
->output_bfd
));
4295 htab
= ppc_hash_table (info
);
4299 if (opd
!= NULL
&& opd
->size
!= 0
4300 && (ibfd
->flags
& DYNAMIC
) == 0
4301 && (opd
->flags
& SEC_RELOC
) != 0
4302 && opd
->reloc_count
!= 0
4303 && !bfd_is_abs_section (opd
->output_section
)
4304 && info
->gc_sections
)
4306 /* Garbage collection needs some extra help with .opd sections.
4307 We don't want to necessarily keep everything referenced by
4308 relocs in .opd, as that would keep all functions. Instead,
4309 if we reference an .opd symbol (a function descriptor), we
4310 want to keep the function code symbol's section. This is
4311 easy for global symbols, but for local syms we need to keep
4312 information about the associated function section. */
4314 asection
**opd_sym_map
;
4315 Elf_Internal_Shdr
*symtab_hdr
;
4316 Elf_Internal_Rela
*relocs
, *rel_end
, *rel
;
4318 amt
= OPD_NDX (opd
->size
) * sizeof (*opd_sym_map
);
4319 opd_sym_map
= bfd_zalloc (ibfd
, amt
);
4320 if (opd_sym_map
== NULL
)
4322 ppc64_elf_section_data (opd
)->u
.opd
.func_sec
= opd_sym_map
;
4323 relocs
= _bfd_elf_link_read_relocs (ibfd
, opd
, NULL
, NULL
,
4327 symtab_hdr
= &elf_symtab_hdr (ibfd
);
4328 rel_end
= relocs
+ opd
->reloc_count
- 1;
4329 for (rel
= relocs
; rel
< rel_end
; rel
++)
4331 enum elf_ppc64_reloc_type r_type
= ELF64_R_TYPE (rel
->r_info
);
4332 unsigned long r_symndx
= ELF64_R_SYM (rel
->r_info
);
4334 if (r_type
== R_PPC64_ADDR64
4335 && ELF64_R_TYPE ((rel
+ 1)->r_info
) == R_PPC64_TOC
4336 && r_symndx
< symtab_hdr
->sh_info
)
4338 Elf_Internal_Sym
*isym
;
4341 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
, ibfd
, r_symndx
);
4344 if (elf_section_data (opd
)->relocs
!= relocs
)
4349 s
= bfd_section_from_elf_index (ibfd
, isym
->st_shndx
);
4350 if (s
!= NULL
&& s
!= opd
)
4351 opd_sym_map
[OPD_NDX (rel
->r_offset
)] = s
;
4354 if (elf_section_data (opd
)->relocs
!= relocs
)
4358 p
= &htab
->dot_syms
;
4359 while ((eh
= *p
) != NULL
)
4362 if (&eh
->elf
== htab
->elf
.hgot
)
4364 else if (htab
->elf
.hgot
== NULL
4365 && strcmp (eh
->elf
.root
.root
.string
, ".TOC.") == 0)
4366 htab
->elf
.hgot
= &eh
->elf
;
4367 else if (abiversion (ibfd
) <= 1)
4369 htab
->need_func_desc_adj
= 1;
4370 if (!add_symbol_adjust (eh
, info
))
4373 p
= &eh
->u
.next_dot_sym
;
4378 /* Undo hash table changes when an --as-needed input file is determined
4379 not to be needed. */
4382 ppc64_elf_notice_as_needed (bfd
*ibfd
,
4383 struct bfd_link_info
*info
,
4384 enum notice_asneeded_action act
)
4386 if (act
== notice_not_needed
)
4388 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
4393 htab
->dot_syms
= NULL
;
4395 return _bfd_elf_notice_as_needed (ibfd
, info
, act
);
4398 /* If --just-symbols against a final linked binary, then assume we need
4399 toc adjusting stubs when calling functions defined there. */
4402 ppc64_elf_link_just_syms (asection
*sec
, struct bfd_link_info
*info
)
4404 if ((sec
->flags
& SEC_CODE
) != 0
4405 && (sec
->owner
->flags
& (EXEC_P
| DYNAMIC
)) != 0
4406 && is_ppc64_elf (sec
->owner
))
4408 if (abiversion (sec
->owner
) >= 2
4409 || bfd_get_section_by_name (sec
->owner
, ".opd") != NULL
)
4410 sec
->has_toc_reloc
= 1;
4412 _bfd_elf_link_just_syms (sec
, info
);
4415 static struct plt_entry
**
4416 update_local_sym_info (bfd
*abfd
, Elf_Internal_Shdr
*symtab_hdr
,
4417 unsigned long r_symndx
, bfd_vma r_addend
, int tls_type
)
4419 struct got_entry
**local_got_ents
= elf_local_got_ents (abfd
);
4420 struct plt_entry
**local_plt
;
4421 unsigned char *local_got_tls_masks
;
4423 if (local_got_ents
== NULL
)
4425 bfd_size_type size
= symtab_hdr
->sh_info
;
4427 size
*= (sizeof (*local_got_ents
)
4428 + sizeof (*local_plt
)
4429 + sizeof (*local_got_tls_masks
));
4430 local_got_ents
= bfd_zalloc (abfd
, size
);
4431 if (local_got_ents
== NULL
)
4433 elf_local_got_ents (abfd
) = local_got_ents
;
4436 if ((tls_type
& (NON_GOT
| TLS_EXPLICIT
)) == 0)
4438 struct got_entry
*ent
;
4440 for (ent
= local_got_ents
[r_symndx
]; ent
!= NULL
; ent
= ent
->next
)
4441 if (ent
->addend
== r_addend
4442 && ent
->owner
== abfd
4443 && ent
->tls_type
== tls_type
)
4447 size_t amt
= sizeof (*ent
);
4448 ent
= bfd_alloc (abfd
, amt
);
4451 ent
->next
= local_got_ents
[r_symndx
];
4452 ent
->addend
= r_addend
;
4454 ent
->tls_type
= tls_type
;
4455 ent
->is_indirect
= FALSE
;
4456 ent
->got
.refcount
= 0;
4457 local_got_ents
[r_symndx
] = ent
;
4459 ent
->got
.refcount
+= 1;
4462 local_plt
= (struct plt_entry
**) (local_got_ents
+ symtab_hdr
->sh_info
);
4463 local_got_tls_masks
= (unsigned char *) (local_plt
+ symtab_hdr
->sh_info
);
4464 local_got_tls_masks
[r_symndx
] |= tls_type
& 0xff;
4466 return local_plt
+ r_symndx
;
4470 update_plt_info (bfd
*abfd
, struct plt_entry
**plist
, bfd_vma addend
)
4472 struct plt_entry
*ent
;
4474 for (ent
= *plist
; ent
!= NULL
; ent
= ent
->next
)
4475 if (ent
->addend
== addend
)
4479 size_t amt
= sizeof (*ent
);
4480 ent
= bfd_alloc (abfd
, amt
);
4484 ent
->addend
= addend
;
4485 ent
->plt
.refcount
= 0;
4488 ent
->plt
.refcount
+= 1;
4493 is_branch_reloc (enum elf_ppc64_reloc_type r_type
)
4495 return (r_type
== R_PPC64_REL24
4496 || r_type
== R_PPC64_REL24_NOTOC
4497 || r_type
== R_PPC64_REL14
4498 || r_type
== R_PPC64_REL14_BRTAKEN
4499 || r_type
== R_PPC64_REL14_BRNTAKEN
4500 || r_type
== R_PPC64_ADDR24
4501 || r_type
== R_PPC64_ADDR14
4502 || r_type
== R_PPC64_ADDR14_BRTAKEN
4503 || r_type
== R_PPC64_ADDR14_BRNTAKEN
4504 || r_type
== R_PPC64_PLTCALL
4505 || r_type
== R_PPC64_PLTCALL_NOTOC
);
4508 /* Relocs on inline plt call sequence insns prior to the call. */
4511 is_plt_seq_reloc (enum elf_ppc64_reloc_type r_type
)
4513 return (r_type
== R_PPC64_PLT16_HA
4514 || r_type
== R_PPC64_PLT16_HI
4515 || r_type
== R_PPC64_PLT16_LO
4516 || r_type
== R_PPC64_PLT16_LO_DS
4517 || r_type
== R_PPC64_PLT_PCREL34
4518 || r_type
== R_PPC64_PLT_PCREL34_NOTOC
4519 || r_type
== R_PPC64_PLTSEQ
4520 || r_type
== R_PPC64_PLTSEQ_NOTOC
);
4523 /* Look through the relocs for a section during the first phase, and
4524 calculate needed space in the global offset table, procedure
4525 linkage table, and dynamic reloc sections. */
4528 ppc64_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
4529 asection
*sec
, const Elf_Internal_Rela
*relocs
)
4531 struct ppc_link_hash_table
*htab
;
4532 Elf_Internal_Shdr
*symtab_hdr
;
4533 struct elf_link_hash_entry
**sym_hashes
;
4534 const Elf_Internal_Rela
*rel
;
4535 const Elf_Internal_Rela
*rel_end
;
4537 struct elf_link_hash_entry
*tga
, *dottga
;
4540 if (bfd_link_relocatable (info
))
4543 /* Don't do anything special with non-loaded, non-alloced sections.
4544 In particular, any relocs in such sections should not affect GOT
4545 and PLT reference counting (ie. we don't allow them to create GOT
4546 or PLT entries), there's no possibility or desire to optimize TLS
4547 relocs, and there's not much point in propagating relocs to shared
4548 libs that the dynamic linker won't relocate. */
4549 if ((sec
->flags
& SEC_ALLOC
) == 0)
4552 BFD_ASSERT (is_ppc64_elf (abfd
));
4554 htab
= ppc_hash_table (info
);
4558 tga
= elf_link_hash_lookup (&htab
->elf
, "__tls_get_addr",
4559 FALSE
, FALSE
, TRUE
);
4560 dottga
= elf_link_hash_lookup (&htab
->elf
, ".__tls_get_addr",
4561 FALSE
, FALSE
, TRUE
);
4562 symtab_hdr
= &elf_symtab_hdr (abfd
);
4563 sym_hashes
= elf_sym_hashes (abfd
);
4565 is_opd
= ppc64_elf_section_data (sec
)->sec_type
== sec_opd
;
4566 rel_end
= relocs
+ sec
->reloc_count
;
4567 for (rel
= relocs
; rel
< rel_end
; rel
++)
4569 unsigned long r_symndx
;
4570 struct elf_link_hash_entry
*h
;
4571 enum elf_ppc64_reloc_type r_type
;
4573 struct _ppc64_elf_section_data
*ppc64_sec
;
4574 struct plt_entry
**ifunc
, **plt_list
;
4576 r_symndx
= ELF64_R_SYM (rel
->r_info
);
4577 if (r_symndx
< symtab_hdr
->sh_info
)
4581 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
4582 h
= elf_follow_link (h
);
4584 if (h
== htab
->elf
.hgot
)
4585 sec
->has_toc_reloc
= 1;
4588 r_type
= ELF64_R_TYPE (rel
->r_info
);
4592 case R_PPC64_D34_LO
:
4593 case R_PPC64_D34_HI30
:
4594 case R_PPC64_D34_HA30
:
4596 case R_PPC64_TPREL34
:
4597 case R_PPC64_DTPREL34
:
4598 case R_PPC64_PCREL34
:
4599 case R_PPC64_GOT_PCREL34
:
4600 case R_PPC64_GOT_TLSGD34
:
4601 case R_PPC64_GOT_TLSLD34
:
4602 case R_PPC64_GOT_TPREL34
:
4603 case R_PPC64_GOT_DTPREL34
:
4604 case R_PPC64_PLT_PCREL34
:
4605 case R_PPC64_PLT_PCREL34_NOTOC
:
4606 case R_PPC64_PCREL28
:
4607 htab
->power10_stubs
= 1;
4615 case R_PPC64_PLT16_HA
:
4616 case R_PPC64_GOT_TLSLD16_HA
:
4617 case R_PPC64_GOT_TLSGD16_HA
:
4618 case R_PPC64_GOT_TPREL16_HA
:
4619 case R_PPC64_GOT_DTPREL16_HA
:
4620 case R_PPC64_GOT16_HA
:
4621 case R_PPC64_TOC16_HA
:
4622 case R_PPC64_PLT16_LO
:
4623 case R_PPC64_PLT16_LO_DS
:
4624 case R_PPC64_GOT_TLSLD16_LO
:
4625 case R_PPC64_GOT_TLSGD16_LO
:
4626 case R_PPC64_GOT_TPREL16_LO_DS
:
4627 case R_PPC64_GOT_DTPREL16_LO_DS
:
4628 case R_PPC64_GOT16_LO
:
4629 case R_PPC64_GOT16_LO_DS
:
4630 case R_PPC64_TOC16_LO
:
4631 case R_PPC64_TOC16_LO_DS
:
4632 case R_PPC64_GOT_PCREL34
:
4633 ppc64_elf_tdata (abfd
)->has_optrel
= 1;
4634 ppc64_elf_section_data (sec
)->has_optrel
= 1;
4643 if (h
->type
== STT_GNU_IFUNC
)
4646 ifunc
= &h
->plt
.plist
;
4651 Elf_Internal_Sym
*isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
4656 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
4658 ifunc
= update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4660 NON_GOT
| PLT_IFUNC
);
4671 /* These special tls relocs tie a call to __tls_get_addr with
4672 its parameter symbol. */
4674 ppc_elf_hash_entry (h
)->tls_mask
|= TLS_TLS
| TLS_MARK
;
4676 if (!update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4678 NON_GOT
| TLS_TLS
| TLS_MARK
))
4680 sec
->has_tls_reloc
= 1;
4683 case R_PPC64_GOT_TLSLD16
:
4684 case R_PPC64_GOT_TLSLD16_LO
:
4685 case R_PPC64_GOT_TLSLD16_HI
:
4686 case R_PPC64_GOT_TLSLD16_HA
:
4687 case R_PPC64_GOT_TLSLD34
:
4688 tls_type
= TLS_TLS
| TLS_LD
;
4691 case R_PPC64_GOT_TLSGD16
:
4692 case R_PPC64_GOT_TLSGD16_LO
:
4693 case R_PPC64_GOT_TLSGD16_HI
:
4694 case R_PPC64_GOT_TLSGD16_HA
:
4695 case R_PPC64_GOT_TLSGD34
:
4696 tls_type
= TLS_TLS
| TLS_GD
;
4699 case R_PPC64_GOT_TPREL16_DS
:
4700 case R_PPC64_GOT_TPREL16_LO_DS
:
4701 case R_PPC64_GOT_TPREL16_HI
:
4702 case R_PPC64_GOT_TPREL16_HA
:
4703 case R_PPC64_GOT_TPREL34
:
4704 if (bfd_link_dll (info
))
4705 info
->flags
|= DF_STATIC_TLS
;
4706 tls_type
= TLS_TLS
| TLS_TPREL
;
4709 case R_PPC64_GOT_DTPREL16_DS
:
4710 case R_PPC64_GOT_DTPREL16_LO_DS
:
4711 case R_PPC64_GOT_DTPREL16_HI
:
4712 case R_PPC64_GOT_DTPREL16_HA
:
4713 case R_PPC64_GOT_DTPREL34
:
4714 tls_type
= TLS_TLS
| TLS_DTPREL
;
4716 sec
->has_tls_reloc
= 1;
4720 case R_PPC64_GOT16_LO
:
4721 case R_PPC64_GOT16_HI
:
4722 case R_PPC64_GOT16_HA
:
4723 case R_PPC64_GOT16_DS
:
4724 case R_PPC64_GOT16_LO_DS
:
4725 case R_PPC64_GOT_PCREL34
:
4727 /* This symbol requires a global offset table entry. */
4728 sec
->has_toc_reloc
= 1;
4729 if (r_type
== R_PPC64_GOT_TLSLD16
4730 || r_type
== R_PPC64_GOT_TLSGD16
4731 || r_type
== R_PPC64_GOT_TPREL16_DS
4732 || r_type
== R_PPC64_GOT_DTPREL16_DS
4733 || r_type
== R_PPC64_GOT16
4734 || r_type
== R_PPC64_GOT16_DS
)
4736 htab
->do_multi_toc
= 1;
4737 ppc64_elf_tdata (abfd
)->has_small_toc_reloc
= 1;
4740 if (ppc64_elf_tdata (abfd
)->got
== NULL
4741 && !create_got_section (abfd
, info
))
4746 struct ppc_link_hash_entry
*eh
;
4747 struct got_entry
*ent
;
4749 eh
= ppc_elf_hash_entry (h
);
4750 for (ent
= eh
->elf
.got
.glist
; ent
!= NULL
; ent
= ent
->next
)
4751 if (ent
->addend
== rel
->r_addend
4752 && ent
->owner
== abfd
4753 && ent
->tls_type
== tls_type
)
4757 size_t amt
= sizeof (*ent
);
4758 ent
= bfd_alloc (abfd
, amt
);
4761 ent
->next
= eh
->elf
.got
.glist
;
4762 ent
->addend
= rel
->r_addend
;
4764 ent
->tls_type
= tls_type
;
4765 ent
->is_indirect
= FALSE
;
4766 ent
->got
.refcount
= 0;
4767 eh
->elf
.got
.glist
= ent
;
4769 ent
->got
.refcount
+= 1;
4770 eh
->tls_mask
|= tls_type
;
4773 /* This is a global offset table entry for a local symbol. */
4774 if (!update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4775 rel
->r_addend
, tls_type
))
4779 case R_PPC64_PLT16_HA
:
4780 case R_PPC64_PLT16_HI
:
4781 case R_PPC64_PLT16_LO
:
4782 case R_PPC64_PLT16_LO_DS
:
4783 case R_PPC64_PLT_PCREL34
:
4784 case R_PPC64_PLT_PCREL34_NOTOC
:
4787 /* This symbol requires a procedure linkage table entry. */
4792 if (h
->root
.root
.string
[0] == '.'
4793 && h
->root
.root
.string
[1] != '\0')
4794 ppc_elf_hash_entry (h
)->is_func
= 1;
4795 ppc_elf_hash_entry (h
)->tls_mask
|= PLT_KEEP
;
4796 plt_list
= &h
->plt
.plist
;
4798 if (plt_list
== NULL
)
4799 plt_list
= update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4801 NON_GOT
| PLT_KEEP
);
4802 if (!update_plt_info (abfd
, plt_list
, rel
->r_addend
))
4806 /* The following relocations don't need to propagate the
4807 relocation if linking a shared object since they are
4808 section relative. */
4809 case R_PPC64_SECTOFF
:
4810 case R_PPC64_SECTOFF_LO
:
4811 case R_PPC64_SECTOFF_HI
:
4812 case R_PPC64_SECTOFF_HA
:
4813 case R_PPC64_SECTOFF_DS
:
4814 case R_PPC64_SECTOFF_LO_DS
:
4815 case R_PPC64_DTPREL16
:
4816 case R_PPC64_DTPREL16_LO
:
4817 case R_PPC64_DTPREL16_HI
:
4818 case R_PPC64_DTPREL16_HA
:
4819 case R_PPC64_DTPREL16_DS
:
4820 case R_PPC64_DTPREL16_LO_DS
:
4821 case R_PPC64_DTPREL16_HIGH
:
4822 case R_PPC64_DTPREL16_HIGHA
:
4823 case R_PPC64_DTPREL16_HIGHER
:
4824 case R_PPC64_DTPREL16_HIGHERA
:
4825 case R_PPC64_DTPREL16_HIGHEST
:
4826 case R_PPC64_DTPREL16_HIGHESTA
:
4831 case R_PPC64_REL16_LO
:
4832 case R_PPC64_REL16_HI
:
4833 case R_PPC64_REL16_HA
:
4834 case R_PPC64_REL16_HIGH
:
4835 case R_PPC64_REL16_HIGHA
:
4836 case R_PPC64_REL16_HIGHER
:
4837 case R_PPC64_REL16_HIGHERA
:
4838 case R_PPC64_REL16_HIGHEST
:
4839 case R_PPC64_REL16_HIGHESTA
:
4840 case R_PPC64_REL16_HIGHER34
:
4841 case R_PPC64_REL16_HIGHERA34
:
4842 case R_PPC64_REL16_HIGHEST34
:
4843 case R_PPC64_REL16_HIGHESTA34
:
4844 case R_PPC64_REL16DX_HA
:
4847 /* Not supported as a dynamic relocation. */
4848 case R_PPC64_ADDR64_LOCAL
:
4849 if (bfd_link_pic (info
))
4851 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
4853 /* xgettext:c-format */
4854 info
->callbacks
->einfo (_("%H: %s reloc unsupported "
4855 "in shared libraries and PIEs\n"),
4856 abfd
, sec
, rel
->r_offset
,
4857 ppc64_elf_howto_table
[r_type
]->name
);
4858 bfd_set_error (bfd_error_bad_value
);
4864 case R_PPC64_TOC16_DS
:
4865 htab
->do_multi_toc
= 1;
4866 ppc64_elf_tdata (abfd
)->has_small_toc_reloc
= 1;
4868 case R_PPC64_TOC16_LO
:
4869 case R_PPC64_TOC16_HI
:
4870 case R_PPC64_TOC16_HA
:
4871 case R_PPC64_TOC16_LO_DS
:
4872 sec
->has_toc_reloc
= 1;
4873 if (h
!= NULL
&& bfd_link_executable (info
))
4875 /* We may need a copy reloc. */
4877 /* Strongly prefer a copy reloc over a dynamic reloc.
4878 glibc ld.so as of 2019-08 will error out if one of
4879 these relocations is emitted. */
4889 /* This relocation describes the C++ object vtable hierarchy.
4890 Reconstruct it for later use during GC. */
4891 case R_PPC64_GNU_VTINHERIT
:
4892 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
4896 /* This relocation describes which C++ vtable entries are actually
4897 used. Record for later use during GC. */
4898 case R_PPC64_GNU_VTENTRY
:
4899 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
4904 case R_PPC64_REL14_BRTAKEN
:
4905 case R_PPC64_REL14_BRNTAKEN
:
4907 asection
*dest
= NULL
;
4909 /* Heuristic: If jumping outside our section, chances are
4910 we are going to need a stub. */
4913 /* If the sym is weak it may be overridden later, so
4914 don't assume we know where a weak sym lives. */
4915 if (h
->root
.type
== bfd_link_hash_defined
)
4916 dest
= h
->root
.u
.def
.section
;
4920 Elf_Internal_Sym
*isym
;
4922 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
4927 dest
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
4931 ppc64_elf_section_data (sec
)->has_14bit_branch
= 1;
4935 case R_PPC64_PLTCALL
:
4936 case R_PPC64_PLTCALL_NOTOC
:
4937 ppc64_elf_section_data (sec
)->has_pltcall
= 1;
4941 case R_PPC64_REL24_NOTOC
:
4947 if (h
->root
.root
.string
[0] == '.'
4948 && h
->root
.root
.string
[1] != '\0')
4949 ppc_elf_hash_entry (h
)->is_func
= 1;
4951 if (h
== tga
|| h
== dottga
)
4953 sec
->has_tls_reloc
= 1;
4955 && (ELF64_R_TYPE (rel
[-1].r_info
) == R_PPC64_TLSGD
4956 || ELF64_R_TYPE (rel
[-1].r_info
) == R_PPC64_TLSLD
))
4957 /* We have a new-style __tls_get_addr call with
4961 /* Mark this section as having an old-style call. */
4962 sec
->nomark_tls_get_addr
= 1;
4964 plt_list
= &h
->plt
.plist
;
4967 /* We may need a .plt entry if the function this reloc
4968 refers to is in a shared lib. */
4970 && !update_plt_info (abfd
, plt_list
, rel
->r_addend
))
4974 case R_PPC64_ADDR14
:
4975 case R_PPC64_ADDR14_BRNTAKEN
:
4976 case R_PPC64_ADDR14_BRTAKEN
:
4977 case R_PPC64_ADDR24
:
4980 case R_PPC64_TPREL64
:
4981 tls_type
= TLS_EXPLICIT
| TLS_TLS
| TLS_TPREL
;
4982 if (bfd_link_dll (info
))
4983 info
->flags
|= DF_STATIC_TLS
;
4986 case R_PPC64_DTPMOD64
:
4987 if (rel
+ 1 < rel_end
4988 && rel
[1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_DTPREL64
)
4989 && rel
[1].r_offset
== rel
->r_offset
+ 8)
4990 tls_type
= TLS_EXPLICIT
| TLS_TLS
| TLS_GD
;
4992 tls_type
= TLS_EXPLICIT
| TLS_TLS
| TLS_LD
;
4995 case R_PPC64_DTPREL64
:
4996 tls_type
= TLS_EXPLICIT
| TLS_TLS
| TLS_DTPREL
;
4998 && rel
[-1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_DTPMOD64
)
4999 && rel
[-1].r_offset
== rel
->r_offset
- 8)
5000 /* This is the second reloc of a dtpmod, dtprel pair.
5001 Don't mark with TLS_DTPREL. */
5005 sec
->has_tls_reloc
= 1;
5007 ppc_elf_hash_entry (h
)->tls_mask
|= tls_type
& 0xff;
5009 if (!update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
5010 rel
->r_addend
, tls_type
))
5013 ppc64_sec
= ppc64_elf_section_data (sec
);
5014 if (ppc64_sec
->sec_type
!= sec_toc
)
5018 /* One extra to simplify get_tls_mask. */
5019 amt
= sec
->size
* sizeof (unsigned) / 8 + sizeof (unsigned);
5020 ppc64_sec
->u
.toc
.symndx
= bfd_zalloc (abfd
, amt
);
5021 if (ppc64_sec
->u
.toc
.symndx
== NULL
)
5023 amt
= sec
->size
* sizeof (bfd_vma
) / 8;
5024 ppc64_sec
->u
.toc
.add
= bfd_zalloc (abfd
, amt
);
5025 if (ppc64_sec
->u
.toc
.add
== NULL
)
5027 BFD_ASSERT (ppc64_sec
->sec_type
== sec_normal
);
5028 ppc64_sec
->sec_type
= sec_toc
;
5030 BFD_ASSERT (rel
->r_offset
% 8 == 0);
5031 ppc64_sec
->u
.toc
.symndx
[rel
->r_offset
/ 8] = r_symndx
;
5032 ppc64_sec
->u
.toc
.add
[rel
->r_offset
/ 8] = rel
->r_addend
;
5034 /* Mark the second slot of a GD or LD entry.
5035 -1 to indicate GD and -2 to indicate LD. */
5036 if (tls_type
== (TLS_EXPLICIT
| TLS_TLS
| TLS_GD
))
5037 ppc64_sec
->u
.toc
.symndx
[rel
->r_offset
/ 8 + 1] = -1;
5038 else if (tls_type
== (TLS_EXPLICIT
| TLS_TLS
| TLS_LD
))
5039 ppc64_sec
->u
.toc
.symndx
[rel
->r_offset
/ 8 + 1] = -2;
5042 case R_PPC64_TPREL16
:
5043 case R_PPC64_TPREL16_LO
:
5044 case R_PPC64_TPREL16_HI
:
5045 case R_PPC64_TPREL16_HA
:
5046 case R_PPC64_TPREL16_DS
:
5047 case R_PPC64_TPREL16_LO_DS
:
5048 case R_PPC64_TPREL16_HIGH
:
5049 case R_PPC64_TPREL16_HIGHA
:
5050 case R_PPC64_TPREL16_HIGHER
:
5051 case R_PPC64_TPREL16_HIGHERA
:
5052 case R_PPC64_TPREL16_HIGHEST
:
5053 case R_PPC64_TPREL16_HIGHESTA
:
5054 case R_PPC64_TPREL34
:
5055 if (bfd_link_dll (info
))
5056 info
->flags
|= DF_STATIC_TLS
;
5059 case R_PPC64_ADDR64
:
5061 && rel
+ 1 < rel_end
5062 && ELF64_R_TYPE ((rel
+ 1)->r_info
) == R_PPC64_TOC
)
5065 ppc_elf_hash_entry (h
)->is_func
= 1;
5069 case R_PPC64_ADDR16
:
5070 case R_PPC64_ADDR16_DS
:
5071 case R_PPC64_ADDR16_HA
:
5072 case R_PPC64_ADDR16_HI
:
5073 case R_PPC64_ADDR16_HIGH
:
5074 case R_PPC64_ADDR16_HIGHA
:
5075 case R_PPC64_ADDR16_HIGHER
:
5076 case R_PPC64_ADDR16_HIGHERA
:
5077 case R_PPC64_ADDR16_HIGHEST
:
5078 case R_PPC64_ADDR16_HIGHESTA
:
5079 case R_PPC64_ADDR16_LO
:
5080 case R_PPC64_ADDR16_LO_DS
:
5082 case R_PPC64_D34_LO
:
5083 case R_PPC64_D34_HI30
:
5084 case R_PPC64_D34_HA30
:
5085 case R_PPC64_ADDR16_HIGHER34
:
5086 case R_PPC64_ADDR16_HIGHERA34
:
5087 case R_PPC64_ADDR16_HIGHEST34
:
5088 case R_PPC64_ADDR16_HIGHESTA34
:
5090 if (h
!= NULL
&& !bfd_link_pic (info
) && abiversion (abfd
) != 1
5091 && rel
->r_addend
== 0)
5093 /* We may need a .plt entry if this reloc refers to a
5094 function in a shared lib. */
5095 if (!update_plt_info (abfd
, &h
->plt
.plist
, 0))
5097 h
->pointer_equality_needed
= 1;
5104 case R_PPC64_ADDR32
:
5105 case R_PPC64_UADDR16
:
5106 case R_PPC64_UADDR32
:
5107 case R_PPC64_UADDR64
:
5109 if (h
!= NULL
&& bfd_link_executable (info
))
5110 /* We may need a copy reloc. */
5113 /* Don't propagate .opd relocs. */
5114 if (NO_OPD_RELOCS
&& is_opd
)
5117 /* If we are creating a shared library, and this is a reloc
5118 against a global symbol, or a non PC relative reloc
5119 against a local symbol, then we need to copy the reloc
5120 into the shared library. However, if we are linking with
5121 -Bsymbolic, we do not need to copy a reloc against a
5122 global symbol which is defined in an object we are
5123 including in the link (i.e., DEF_REGULAR is set). At
5124 this point we have not seen all the input files, so it is
5125 possible that DEF_REGULAR is not set now but will be set
5126 later (it is never cleared). In case of a weak definition,
5127 DEF_REGULAR may be cleared later by a strong definition in
5128 a shared library. We account for that possibility below by
5129 storing information in the dyn_relocs field of the hash
5130 table entry. A similar situation occurs when creating
5131 shared libraries and symbol visibility changes render the
5134 If on the other hand, we are creating an executable, we
5135 may need to keep relocations for symbols satisfied by a
5136 dynamic library if we manage to avoid copy relocs for the
5140 && (h
->root
.type
== bfd_link_hash_defweak
5141 || !h
->def_regular
))
5143 && !bfd_link_executable (info
)
5144 && !SYMBOLIC_BIND (info
, h
))
5145 || (bfd_link_pic (info
)
5146 && must_be_dyn_reloc (info
, r_type
))
5147 || (!bfd_link_pic (info
)
5150 /* We must copy these reloc types into the output file.
5151 Create a reloc section in dynobj and make room for
5155 sreloc
= _bfd_elf_make_dynamic_reloc_section
5156 (sec
, htab
->elf
.dynobj
, 3, abfd
, /*rela?*/ TRUE
);
5162 /* If this is a global symbol, we count the number of
5163 relocations we need for this symbol. */
5166 struct elf_dyn_relocs
*p
;
5167 struct elf_dyn_relocs
**head
;
5169 head
= &ppc_elf_hash_entry (h
)->dyn_relocs
;
5171 if (p
== NULL
|| p
->sec
!= sec
)
5173 p
= bfd_alloc (htab
->elf
.dynobj
, sizeof *p
);
5183 if (!must_be_dyn_reloc (info
, r_type
))
5188 /* Track dynamic relocs needed for local syms too.
5189 We really need local syms available to do this
5191 struct ppc_dyn_relocs
*p
;
5192 struct ppc_dyn_relocs
**head
;
5193 bfd_boolean is_ifunc
;
5196 Elf_Internal_Sym
*isym
;
5198 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
5203 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
5207 vpp
= &elf_section_data (s
)->local_dynrel
;
5208 head
= (struct ppc_dyn_relocs
**) vpp
;
5209 is_ifunc
= ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
;
5211 if (p
!= NULL
&& p
->sec
== sec
&& p
->ifunc
!= is_ifunc
)
5213 if (p
== NULL
|| p
->sec
!= sec
|| p
->ifunc
!= is_ifunc
)
5215 p
= bfd_alloc (htab
->elf
.dynobj
, sizeof *p
);
5221 p
->ifunc
= is_ifunc
;
5237 /* Merge backend specific data from an object file to the output
5238 object file when linking. */
5241 ppc64_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
5243 bfd
*obfd
= info
->output_bfd
;
5244 unsigned long iflags
, oflags
;
5246 if ((ibfd
->flags
& BFD_LINKER_CREATED
) != 0)
5249 if (!is_ppc64_elf (ibfd
) || !is_ppc64_elf (obfd
))
5252 if (!_bfd_generic_verify_endian_match (ibfd
, info
))
5255 iflags
= elf_elfheader (ibfd
)->e_flags
;
5256 oflags
= elf_elfheader (obfd
)->e_flags
;
5258 if (iflags
& ~EF_PPC64_ABI
)
5261 /* xgettext:c-format */
5262 (_("%pB uses unknown e_flags 0x%lx"), ibfd
, iflags
);
5263 bfd_set_error (bfd_error_bad_value
);
5266 else if (iflags
!= oflags
&& iflags
!= 0)
5269 /* xgettext:c-format */
5270 (_("%pB: ABI version %ld is not compatible with ABI version %ld output"),
5271 ibfd
, iflags
, oflags
);
5272 bfd_set_error (bfd_error_bad_value
);
5276 if (!_bfd_elf_ppc_merge_fp_attributes (ibfd
, info
))
5279 /* Merge Tag_compatibility attributes and any common GNU ones. */
5280 return _bfd_elf_merge_object_attributes (ibfd
, info
);
5284 ppc64_elf_print_private_bfd_data (bfd
*abfd
, void *ptr
)
5286 /* Print normal ELF private data. */
5287 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
5289 if (elf_elfheader (abfd
)->e_flags
!= 0)
5293 fprintf (file
, _("private flags = 0x%lx:"),
5294 elf_elfheader (abfd
)->e_flags
);
5296 if ((elf_elfheader (abfd
)->e_flags
& EF_PPC64_ABI
) != 0)
5297 fprintf (file
, _(" [abiv%ld]"),
5298 elf_elfheader (abfd
)->e_flags
& EF_PPC64_ABI
);
5305 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
5306 of the code entry point, and its section, which must be in the same
5307 object as OPD_SEC. Returns (bfd_vma) -1 on error. */
5310 opd_entry_value (asection
*opd_sec
,
5312 asection
**code_sec
,
5314 bfd_boolean in_code_sec
)
5316 bfd
*opd_bfd
= opd_sec
->owner
;
5317 Elf_Internal_Rela
*relocs
;
5318 Elf_Internal_Rela
*lo
, *hi
, *look
;
5321 /* No relocs implies we are linking a --just-symbols object, or looking
5322 at a final linked executable with addr2line or somesuch. */
5323 if (opd_sec
->reloc_count
== 0)
5325 bfd_byte
*contents
= ppc64_elf_tdata (opd_bfd
)->opd
.contents
;
5327 if (contents
== NULL
)
5329 if (!bfd_malloc_and_get_section (opd_bfd
, opd_sec
, &contents
))
5330 return (bfd_vma
) -1;
5331 ppc64_elf_tdata (opd_bfd
)->opd
.contents
= contents
;
5334 /* PR 17512: file: 64b9dfbb. */
5335 if (offset
+ 7 >= opd_sec
->size
|| offset
+ 7 < offset
)
5336 return (bfd_vma
) -1;
5338 val
= bfd_get_64 (opd_bfd
, contents
+ offset
);
5339 if (code_sec
!= NULL
)
5341 asection
*sec
, *likely
= NULL
;
5347 && val
< sec
->vma
+ sec
->size
)
5353 for (sec
= opd_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
5355 && (sec
->flags
& SEC_LOAD
) != 0
5356 && (sec
->flags
& SEC_ALLOC
) != 0)
5361 if (code_off
!= NULL
)
5362 *code_off
= val
- likely
->vma
;
5368 BFD_ASSERT (is_ppc64_elf (opd_bfd
));
5370 relocs
= ppc64_elf_tdata (opd_bfd
)->opd
.relocs
;
5372 relocs
= _bfd_elf_link_read_relocs (opd_bfd
, opd_sec
, NULL
, NULL
, TRUE
);
5373 /* PR 17512: file: df8e1fd6. */
5375 return (bfd_vma
) -1;
5377 /* Go find the opd reloc at the sym address. */
5379 hi
= lo
+ opd_sec
->reloc_count
- 1; /* ignore last reloc */
5383 look
= lo
+ (hi
- lo
) / 2;
5384 if (look
->r_offset
< offset
)
5386 else if (look
->r_offset
> offset
)
5390 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (opd_bfd
);
5392 if (ELF64_R_TYPE (look
->r_info
) == R_PPC64_ADDR64
5393 && ELF64_R_TYPE ((look
+ 1)->r_info
) == R_PPC64_TOC
)
5395 unsigned long symndx
= ELF64_R_SYM (look
->r_info
);
5396 asection
*sec
= NULL
;
5398 if (symndx
>= symtab_hdr
->sh_info
5399 && elf_sym_hashes (opd_bfd
) != NULL
)
5401 struct elf_link_hash_entry
**sym_hashes
;
5402 struct elf_link_hash_entry
*rh
;
5404 sym_hashes
= elf_sym_hashes (opd_bfd
);
5405 rh
= sym_hashes
[symndx
- symtab_hdr
->sh_info
];
5408 rh
= elf_follow_link (rh
);
5409 if (rh
->root
.type
!= bfd_link_hash_defined
5410 && rh
->root
.type
!= bfd_link_hash_defweak
)
5412 if (rh
->root
.u
.def
.section
->owner
== opd_bfd
)
5414 val
= rh
->root
.u
.def
.value
;
5415 sec
= rh
->root
.u
.def
.section
;
5422 Elf_Internal_Sym
*sym
;
5424 if (symndx
< symtab_hdr
->sh_info
)
5426 sym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
5429 size_t symcnt
= symtab_hdr
->sh_info
;
5430 sym
= bfd_elf_get_elf_syms (opd_bfd
, symtab_hdr
,
5435 symtab_hdr
->contents
= (bfd_byte
*) sym
;
5441 sym
= bfd_elf_get_elf_syms (opd_bfd
, symtab_hdr
,
5447 sec
= bfd_section_from_elf_index (opd_bfd
, sym
->st_shndx
);
5450 BFD_ASSERT ((sec
->flags
& SEC_MERGE
) == 0);
5451 val
= sym
->st_value
;
5454 val
+= look
->r_addend
;
5455 if (code_off
!= NULL
)
5457 if (code_sec
!= NULL
)
5459 if (in_code_sec
&& *code_sec
!= sec
)
5464 if (sec
->output_section
!= NULL
)
5465 val
+= sec
->output_section
->vma
+ sec
->output_offset
;
5474 /* If the ELF symbol SYM might be a function in SEC, return the
5475 function size and set *CODE_OFF to the function's entry point,
5476 otherwise return zero. */
5478 static bfd_size_type
5479 ppc64_elf_maybe_function_sym (const asymbol
*sym
, asection
*sec
,
5484 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_FILE
| BSF_OBJECT
5485 | BSF_THREAD_LOCAL
| BSF_RELC
| BSF_SRELC
)) != 0)
5489 if (!(sym
->flags
& BSF_SYNTHETIC
))
5490 size
= ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
5492 if (strcmp (sym
->section
->name
, ".opd") == 0)
5494 struct _opd_sec_data
*opd
= get_opd_info (sym
->section
);
5495 bfd_vma symval
= sym
->value
;
5498 && opd
->adjust
!= NULL
5499 && elf_section_data (sym
->section
)->relocs
!= NULL
)
5501 /* opd_entry_value will use cached relocs that have been
5502 adjusted, but with raw symbols. That means both local
5503 and global symbols need adjusting. */
5504 long adjust
= opd
->adjust
[OPD_NDX (symval
)];
5510 if (opd_entry_value (sym
->section
, symval
,
5511 &sec
, code_off
, TRUE
) == (bfd_vma
) -1)
5513 /* An old ABI binary with dot-syms has a size of 24 on the .opd
5514 symbol. This size has nothing to do with the code size of the
5515 function, which is what we're supposed to return, but the
5516 code size isn't available without looking up the dot-sym.
5517 However, doing that would be a waste of time particularly
5518 since elf_find_function will look at the dot-sym anyway.
5519 Now, elf_find_function will keep the largest size of any
5520 function sym found at the code address of interest, so return
5521 1 here to avoid it incorrectly caching a larger function size
5522 for a small function. This does mean we return the wrong
5523 size for a new-ABI function of size 24, but all that does is
5524 disable caching for such functions. */
5530 if (sym
->section
!= sec
)
5532 *code_off
= sym
->value
;
5539 /* Return true if symbol is a strong function defined in an ELFv2
5540 object with st_other localentry bits of zero, ie. its local entry
5541 point coincides with its global entry point. */
5544 is_elfv2_localentry0 (struct elf_link_hash_entry
*h
)
5547 && h
->type
== STT_FUNC
5548 && h
->root
.type
== bfd_link_hash_defined
5549 && (STO_PPC64_LOCAL_MASK
& h
->other
) == 0
5550 && !ppc_elf_hash_entry (h
)->non_zero_localentry
5551 && is_ppc64_elf (h
->root
.u
.def
.section
->owner
)
5552 && abiversion (h
->root
.u
.def
.section
->owner
) >= 2);
5555 /* Return true if symbol is defined in a regular object file. */
5558 is_static_defined (struct elf_link_hash_entry
*h
)
5560 return ((h
->root
.type
== bfd_link_hash_defined
5561 || h
->root
.type
== bfd_link_hash_defweak
)
5562 && h
->root
.u
.def
.section
!= NULL
5563 && h
->root
.u
.def
.section
->output_section
!= NULL
);
5566 /* If FDH is a function descriptor symbol, return the associated code
5567 entry symbol if it is defined. Return NULL otherwise. */
5569 static struct ppc_link_hash_entry
*
5570 defined_code_entry (struct ppc_link_hash_entry
*fdh
)
5572 if (fdh
->is_func_descriptor
)
5574 struct ppc_link_hash_entry
*fh
= ppc_follow_link (fdh
->oh
);
5575 if (fh
->elf
.root
.type
== bfd_link_hash_defined
5576 || fh
->elf
.root
.type
== bfd_link_hash_defweak
)
5582 /* If FH is a function code entry symbol, return the associated
5583 function descriptor symbol if it is defined. Return NULL otherwise. */
5585 static struct ppc_link_hash_entry
*
5586 defined_func_desc (struct ppc_link_hash_entry
*fh
)
5589 && fh
->oh
->is_func_descriptor
)
5591 struct ppc_link_hash_entry
*fdh
= ppc_follow_link (fh
->oh
);
5592 if (fdh
->elf
.root
.type
== bfd_link_hash_defined
5593 || fdh
->elf
.root
.type
== bfd_link_hash_defweak
)
5599 /* Given H is a symbol that satisfies is_static_defined, return the
5600 value in the output file. */
5603 defined_sym_val (struct elf_link_hash_entry
*h
)
5605 return (h
->root
.u
.def
.section
->output_section
->vma
5606 + h
->root
.u
.def
.section
->output_offset
5607 + h
->root
.u
.def
.value
);
5610 /* Return true if H matches __tls_get_addr or one of its variants. */
5613 is_tls_get_addr (struct elf_link_hash_entry
*h
,
5614 struct ppc_link_hash_table
*htab
)
5616 return (h
== &htab
->tls_get_addr_fd
->elf
|| h
== &htab
->tga_desc_fd
->elf
5617 || h
== &htab
->tls_get_addr
->elf
|| h
== &htab
->tga_desc
->elf
);
5620 static bfd_boolean
func_desc_adjust (struct elf_link_hash_entry
*, void *);
5622 /* Garbage collect sections, after first dealing with dot-symbols. */
5625 ppc64_elf_gc_sections (bfd
*abfd
, struct bfd_link_info
*info
)
5627 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
5629 if (htab
!= NULL
&& htab
->need_func_desc_adj
)
5631 elf_link_hash_traverse (&htab
->elf
, func_desc_adjust
, info
);
5632 htab
->need_func_desc_adj
= 0;
5634 return bfd_elf_gc_sections (abfd
, info
);
5637 /* Mark all our entry sym sections, both opd and code section. */
5640 ppc64_elf_gc_keep (struct bfd_link_info
*info
)
5642 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
5643 struct bfd_sym_chain
*sym
;
5648 for (sym
= info
->gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
5650 struct ppc_link_hash_entry
*eh
, *fh
;
5653 eh
= ppc_elf_hash_entry (elf_link_hash_lookup (&htab
->elf
, sym
->name
,
5654 FALSE
, FALSE
, TRUE
));
5657 if (eh
->elf
.root
.type
!= bfd_link_hash_defined
5658 && eh
->elf
.root
.type
!= bfd_link_hash_defweak
)
5661 fh
= defined_code_entry (eh
);
5664 sec
= fh
->elf
.root
.u
.def
.section
;
5665 sec
->flags
|= SEC_KEEP
;
5667 else if (get_opd_info (eh
->elf
.root
.u
.def
.section
) != NULL
5668 && opd_entry_value (eh
->elf
.root
.u
.def
.section
,
5669 eh
->elf
.root
.u
.def
.value
,
5670 &sec
, NULL
, FALSE
) != (bfd_vma
) -1)
5671 sec
->flags
|= SEC_KEEP
;
5673 sec
= eh
->elf
.root
.u
.def
.section
;
5674 sec
->flags
|= SEC_KEEP
;
5678 /* Mark sections containing dynamically referenced symbols. When
5679 building shared libraries, we must assume that any visible symbol is
5683 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry
*h
, void *inf
)
5685 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
5686 struct ppc_link_hash_entry
*eh
= ppc_elf_hash_entry (h
);
5687 struct ppc_link_hash_entry
*fdh
;
5688 struct bfd_elf_dynamic_list
*d
= info
->dynamic_list
;
5690 /* Dynamic linking info is on the func descriptor sym. */
5691 fdh
= defined_func_desc (eh
);
5695 if ((eh
->elf
.root
.type
== bfd_link_hash_defined
5696 || eh
->elf
.root
.type
== bfd_link_hash_defweak
)
5697 && ((eh
->elf
.ref_dynamic
&& !eh
->elf
.forced_local
)
5698 || ((eh
->elf
.def_regular
|| ELF_COMMON_DEF_P (&eh
->elf
))
5699 && ELF_ST_VISIBILITY (eh
->elf
.other
) != STV_INTERNAL
5700 && ELF_ST_VISIBILITY (eh
->elf
.other
) != STV_HIDDEN
5701 && (!bfd_link_executable (info
)
5702 || info
->gc_keep_exported
5703 || info
->export_dynamic
5706 && (*d
->match
) (&d
->head
, NULL
,
5707 eh
->elf
.root
.root
.string
)))
5708 && (eh
->elf
.versioned
>= versioned
5709 || !bfd_hide_sym_by_version (info
->version_info
,
5710 eh
->elf
.root
.root
.string
)))))
5713 struct ppc_link_hash_entry
*fh
;
5715 eh
->elf
.root
.u
.def
.section
->flags
|= SEC_KEEP
;
5717 /* Function descriptor syms cause the associated
5718 function code sym section to be marked. */
5719 fh
= defined_code_entry (eh
);
5722 code_sec
= fh
->elf
.root
.u
.def
.section
;
5723 code_sec
->flags
|= SEC_KEEP
;
5725 else if (get_opd_info (eh
->elf
.root
.u
.def
.section
) != NULL
5726 && opd_entry_value (eh
->elf
.root
.u
.def
.section
,
5727 eh
->elf
.root
.u
.def
.value
,
5728 &code_sec
, NULL
, FALSE
) != (bfd_vma
) -1)
5729 code_sec
->flags
|= SEC_KEEP
;
5735 /* Return the section that should be marked against GC for a given
5739 ppc64_elf_gc_mark_hook (asection
*sec
,
5740 struct bfd_link_info
*info
,
5741 Elf_Internal_Rela
*rel
,
5742 struct elf_link_hash_entry
*h
,
5743 Elf_Internal_Sym
*sym
)
5747 /* Syms return NULL if we're marking .opd, so we avoid marking all
5748 function sections, as all functions are referenced in .opd. */
5750 if (get_opd_info (sec
) != NULL
)
5755 enum elf_ppc64_reloc_type r_type
;
5756 struct ppc_link_hash_entry
*eh
, *fh
, *fdh
;
5758 r_type
= ELF64_R_TYPE (rel
->r_info
);
5761 case R_PPC64_GNU_VTINHERIT
:
5762 case R_PPC64_GNU_VTENTRY
:
5766 switch (h
->root
.type
)
5768 case bfd_link_hash_defined
:
5769 case bfd_link_hash_defweak
:
5770 eh
= ppc_elf_hash_entry (h
);
5771 fdh
= defined_func_desc (eh
);
5774 /* -mcall-aixdesc code references the dot-symbol on
5775 a call reloc. Mark the function descriptor too
5776 against garbage collection. */
5778 if (fdh
->elf
.is_weakalias
)
5779 weakdef (&fdh
->elf
)->mark
= 1;
5783 /* Function descriptor syms cause the associated
5784 function code sym section to be marked. */
5785 fh
= defined_code_entry (eh
);
5788 /* They also mark their opd section. */
5789 eh
->elf
.root
.u
.def
.section
->gc_mark
= 1;
5791 rsec
= fh
->elf
.root
.u
.def
.section
;
5793 else if (get_opd_info (eh
->elf
.root
.u
.def
.section
) != NULL
5794 && opd_entry_value (eh
->elf
.root
.u
.def
.section
,
5795 eh
->elf
.root
.u
.def
.value
,
5796 &rsec
, NULL
, FALSE
) != (bfd_vma
) -1)
5797 eh
->elf
.root
.u
.def
.section
->gc_mark
= 1;
5799 rsec
= h
->root
.u
.def
.section
;
5802 case bfd_link_hash_common
:
5803 rsec
= h
->root
.u
.c
.p
->section
;
5807 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
5813 struct _opd_sec_data
*opd
;
5815 rsec
= bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
5816 opd
= get_opd_info (rsec
);
5817 if (opd
!= NULL
&& opd
->func_sec
!= NULL
)
5821 rsec
= opd
->func_sec
[OPD_NDX (sym
->st_value
+ rel
->r_addend
)];
5828 /* The maximum size of .sfpr. */
5829 #define SFPR_MAX (218*4)
5831 struct sfpr_def_parms
5833 const char name
[12];
5834 unsigned char lo
, hi
;
5835 bfd_byte
*(*write_ent
) (bfd
*, bfd_byte
*, int);
5836 bfd_byte
*(*write_tail
) (bfd
*, bfd_byte
*, int);
5839 /* Auto-generate _save*, _rest* functions in .sfpr.
5840 If STUB_SEC is non-null, define alias symbols in STUB_SEC
5844 sfpr_define (struct bfd_link_info
*info
,
5845 const struct sfpr_def_parms
*parm
,
5848 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
5850 size_t len
= strlen (parm
->name
);
5851 bfd_boolean writing
= FALSE
;
5857 memcpy (sym
, parm
->name
, len
);
5860 for (i
= parm
->lo
; i
<= parm
->hi
; i
++)
5862 struct ppc_link_hash_entry
*h
;
5864 sym
[len
+ 0] = i
/ 10 + '0';
5865 sym
[len
+ 1] = i
% 10 + '0';
5866 h
= ppc_elf_hash_entry (elf_link_hash_lookup (&htab
->elf
, sym
,
5867 writing
, TRUE
, TRUE
));
5868 if (stub_sec
!= NULL
)
5871 && h
->elf
.root
.type
== bfd_link_hash_defined
5872 && h
->elf
.root
.u
.def
.section
== htab
->sfpr
)
5874 struct elf_link_hash_entry
*s
;
5876 sprintf (buf
, "%08x.%s", stub_sec
->id
& 0xffffffff, sym
);
5877 s
= elf_link_hash_lookup (&htab
->elf
, buf
, TRUE
, TRUE
, FALSE
);
5880 if (s
->root
.type
== bfd_link_hash_new
)
5882 s
->root
.type
= bfd_link_hash_defined
;
5883 s
->root
.u
.def
.section
= stub_sec
;
5884 s
->root
.u
.def
.value
= (stub_sec
->size
- htab
->sfpr
->size
5885 + h
->elf
.root
.u
.def
.value
);
5888 s
->ref_regular_nonweak
= 1;
5889 s
->forced_local
= 1;
5891 s
->root
.linker_def
= 1;
5899 if (!h
->elf
.def_regular
)
5901 h
->elf
.root
.type
= bfd_link_hash_defined
;
5902 h
->elf
.root
.u
.def
.section
= htab
->sfpr
;
5903 h
->elf
.root
.u
.def
.value
= htab
->sfpr
->size
;
5904 h
->elf
.type
= STT_FUNC
;
5905 h
->elf
.def_regular
= 1;
5907 _bfd_elf_link_hash_hide_symbol (info
, &h
->elf
, TRUE
);
5909 if (htab
->sfpr
->contents
== NULL
)
5911 htab
->sfpr
->contents
5912 = bfd_alloc (htab
->elf
.dynobj
, SFPR_MAX
);
5913 if (htab
->sfpr
->contents
== NULL
)
5920 bfd_byte
*p
= htab
->sfpr
->contents
+ htab
->sfpr
->size
;
5922 p
= (*parm
->write_ent
) (htab
->elf
.dynobj
, p
, i
);
5924 p
= (*parm
->write_tail
) (htab
->elf
.dynobj
, p
, i
);
5925 htab
->sfpr
->size
= p
- htab
->sfpr
->contents
;
5933 savegpr0 (bfd
*abfd
, bfd_byte
*p
, int r
)
5935 bfd_put_32 (abfd
, STD_R0_0R1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5940 savegpr0_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5942 p
= savegpr0 (abfd
, p
, r
);
5943 bfd_put_32 (abfd
, STD_R0_0R1
+ STK_LR
, p
);
5945 bfd_put_32 (abfd
, BLR
, p
);
5950 restgpr0 (bfd
*abfd
, bfd_byte
*p
, int r
)
5952 bfd_put_32 (abfd
, LD_R0_0R1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5957 restgpr0_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5959 bfd_put_32 (abfd
, LD_R0_0R1
+ STK_LR
, p
);
5961 p
= restgpr0 (abfd
, p
, r
);
5962 bfd_put_32 (abfd
, MTLR_R0
, p
);
5966 p
= restgpr0 (abfd
, p
, 30);
5967 p
= restgpr0 (abfd
, p
, 31);
5969 bfd_put_32 (abfd
, BLR
, p
);
5974 savegpr1 (bfd
*abfd
, bfd_byte
*p
, int r
)
5976 bfd_put_32 (abfd
, STD_R0_0R12
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5981 savegpr1_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5983 p
= savegpr1 (abfd
, p
, r
);
5984 bfd_put_32 (abfd
, BLR
, p
);
5989 restgpr1 (bfd
*abfd
, bfd_byte
*p
, int r
)
5991 bfd_put_32 (abfd
, LD_R0_0R12
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5996 restgpr1_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5998 p
= restgpr1 (abfd
, p
, r
);
5999 bfd_put_32 (abfd
, BLR
, p
);
6004 savefpr (bfd
*abfd
, bfd_byte
*p
, int r
)
6006 bfd_put_32 (abfd
, STFD_FR0_0R1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
6011 savefpr0_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6013 p
= savefpr (abfd
, p
, r
);
6014 bfd_put_32 (abfd
, STD_R0_0R1
+ STK_LR
, p
);
6016 bfd_put_32 (abfd
, BLR
, p
);
6021 restfpr (bfd
*abfd
, bfd_byte
*p
, int r
)
6023 bfd_put_32 (abfd
, LFD_FR0_0R1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
6028 restfpr0_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6030 bfd_put_32 (abfd
, LD_R0_0R1
+ STK_LR
, p
);
6032 p
= restfpr (abfd
, p
, r
);
6033 bfd_put_32 (abfd
, MTLR_R0
, p
);
6037 p
= restfpr (abfd
, p
, 30);
6038 p
= restfpr (abfd
, p
, 31);
6040 bfd_put_32 (abfd
, BLR
, p
);
6045 savefpr1_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6047 p
= savefpr (abfd
, p
, r
);
6048 bfd_put_32 (abfd
, BLR
, p
);
6053 restfpr1_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6055 p
= restfpr (abfd
, p
, r
);
6056 bfd_put_32 (abfd
, BLR
, p
);
6061 savevr (bfd
*abfd
, bfd_byte
*p
, int r
)
6063 bfd_put_32 (abfd
, LI_R12_0
+ (1 << 16) - (32 - r
) * 16, p
);
6065 bfd_put_32 (abfd
, STVX_VR0_R12_R0
+ (r
<< 21), p
);
6070 savevr_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6072 p
= savevr (abfd
, p
, r
);
6073 bfd_put_32 (abfd
, BLR
, p
);
6078 restvr (bfd
*abfd
, bfd_byte
*p
, int r
)
6080 bfd_put_32 (abfd
, LI_R12_0
+ (1 << 16) - (32 - r
) * 16, p
);
6082 bfd_put_32 (abfd
, LVX_VR0_R12_R0
+ (r
<< 21), p
);
6087 restvr_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6089 p
= restvr (abfd
, p
, r
);
6090 bfd_put_32 (abfd
, BLR
, p
);
6094 #define STDU_R1_0R1 0xf8210001
6095 #define ADDI_R1_R1 0x38210000
6097 /* Emit prologue of wrapper preserving regs around a call to
6098 __tls_get_addr_opt. */
6101 tls_get_addr_prologue (bfd
*obfd
, bfd_byte
*p
, struct ppc_link_hash_table
*htab
)
6105 bfd_put_32 (obfd
, MFLR_R0
, p
);
6107 bfd_put_32 (obfd
, STD_R0_0R1
+ 16, p
);
6112 for (i
= 4; i
< 12; i
++)
6115 STD_R0_0R1
| i
<< 21 | (-(13 - i
) * 8 & 0xffff), p
);
6118 bfd_put_32 (obfd
, STDU_R1_0R1
| (-128 & 0xffff), p
);
6123 for (i
= 4; i
< 12; i
++)
6126 STD_R0_0R1
| i
<< 21 | (-(12 - i
) * 8 & 0xffff), p
);
6129 bfd_put_32 (obfd
, STDU_R1_0R1
| (-96 & 0xffff), p
);
6135 /* Emit epilogue of wrapper preserving regs around a call to
6136 __tls_get_addr_opt. */
6139 tls_get_addr_epilogue (bfd
*obfd
, bfd_byte
*p
, struct ppc_link_hash_table
*htab
)
6145 for (i
= 4; i
< 12; i
++)
6147 bfd_put_32 (obfd
, LD_R0_0R1
| i
<< 21 | (128 - (13 - i
) * 8), p
);
6150 bfd_put_32 (obfd
, ADDI_R1_R1
| 128, p
);
6155 for (i
= 4; i
< 12; i
++)
6157 bfd_put_32 (obfd
, LD_R0_0R1
| i
<< 21 | (96 - (12 - i
) * 8), p
);
6160 bfd_put_32 (obfd
, ADDI_R1_R1
| 96, p
);
6163 bfd_put_32 (obfd
, LD_R0_0R1
| 16, p
);
6165 bfd_put_32 (obfd
, MTLR_R0
, p
);
6167 bfd_put_32 (obfd
, BLR
, p
);
6172 /* Called via elf_link_hash_traverse to transfer dynamic linking
6173 information on function code symbol entries to their corresponding
6174 function descriptor symbol entries. */
6177 func_desc_adjust (struct elf_link_hash_entry
*h
, void *inf
)
6179 struct bfd_link_info
*info
;
6180 struct ppc_link_hash_table
*htab
;
6181 struct ppc_link_hash_entry
*fh
;
6182 struct ppc_link_hash_entry
*fdh
;
6183 bfd_boolean force_local
;
6185 fh
= ppc_elf_hash_entry (h
);
6186 if (fh
->elf
.root
.type
== bfd_link_hash_indirect
)
6192 if (fh
->elf
.root
.root
.string
[0] != '.'
6193 || fh
->elf
.root
.root
.string
[1] == '\0')
6197 htab
= ppc_hash_table (info
);
6201 /* Find the corresponding function descriptor symbol. */
6202 fdh
= lookup_fdh (fh
, htab
);
6204 /* Resolve undefined references to dot-symbols as the value
6205 in the function descriptor, if we have one in a regular object.
6206 This is to satisfy cases like ".quad .foo". Calls to functions
6207 in dynamic objects are handled elsewhere. */
6208 if ((fh
->elf
.root
.type
== bfd_link_hash_undefined
6209 || fh
->elf
.root
.type
== bfd_link_hash_undefweak
)
6210 && (fdh
->elf
.root
.type
== bfd_link_hash_defined
6211 || fdh
->elf
.root
.type
== bfd_link_hash_defweak
)
6212 && get_opd_info (fdh
->elf
.root
.u
.def
.section
) != NULL
6213 && opd_entry_value (fdh
->elf
.root
.u
.def
.section
,
6214 fdh
->elf
.root
.u
.def
.value
,
6215 &fh
->elf
.root
.u
.def
.section
,
6216 &fh
->elf
.root
.u
.def
.value
, FALSE
) != (bfd_vma
) -1)
6218 fh
->elf
.root
.type
= fdh
->elf
.root
.type
;
6219 fh
->elf
.forced_local
= 1;
6220 fh
->elf
.def_regular
= fdh
->elf
.def_regular
;
6221 fh
->elf
.def_dynamic
= fdh
->elf
.def_dynamic
;
6224 if (!fh
->elf
.dynamic
)
6226 struct plt_entry
*ent
;
6228 for (ent
= fh
->elf
.plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
6229 if (ent
->plt
.refcount
> 0)
6235 /* Create a descriptor as undefined if necessary. */
6237 && !bfd_link_executable (info
)
6238 && (fh
->elf
.root
.type
== bfd_link_hash_undefined
6239 || fh
->elf
.root
.type
== bfd_link_hash_undefweak
))
6241 fdh
= make_fdh (info
, fh
);
6246 /* We can't support overriding of symbols on a fake descriptor. */
6249 && (fh
->elf
.root
.type
== bfd_link_hash_defined
6250 || fh
->elf
.root
.type
== bfd_link_hash_defweak
))
6251 _bfd_elf_link_hash_hide_symbol (info
, &fdh
->elf
, TRUE
);
6253 /* Transfer dynamic linking information to the function descriptor. */
6256 fdh
->elf
.ref_regular
|= fh
->elf
.ref_regular
;
6257 fdh
->elf
.ref_dynamic
|= fh
->elf
.ref_dynamic
;
6258 fdh
->elf
.ref_regular_nonweak
|= fh
->elf
.ref_regular_nonweak
;
6259 fdh
->elf
.non_got_ref
|= fh
->elf
.non_got_ref
;
6260 fdh
->elf
.dynamic
|= fh
->elf
.dynamic
;
6261 fdh
->elf
.needs_plt
|= (fh
->elf
.needs_plt
6262 || fh
->elf
.type
== STT_FUNC
6263 || fh
->elf
.type
== STT_GNU_IFUNC
);
6264 move_plt_plist (fh
, fdh
);
6266 if (!fdh
->elf
.forced_local
6267 && fh
->elf
.dynindx
!= -1)
6268 if (!bfd_elf_link_record_dynamic_symbol (info
, &fdh
->elf
))
6272 /* Now that the info is on the function descriptor, clear the
6273 function code sym info. Any function code syms for which we
6274 don't have a definition in a regular file, we force local.
6275 This prevents a shared library from exporting syms that have
6276 been imported from another library. Function code syms that
6277 are really in the library we must leave global to prevent the
6278 linker dragging in a definition from a static library. */
6279 force_local
= (!fh
->elf
.def_regular
6281 || !fdh
->elf
.def_regular
6282 || fdh
->elf
.forced_local
);
6283 _bfd_elf_link_hash_hide_symbol (info
, &fh
->elf
, force_local
);
6288 static const struct sfpr_def_parms save_res_funcs
[] =
6290 { "_savegpr0_", 14, 31, savegpr0
, savegpr0_tail
},
6291 { "_restgpr0_", 14, 29, restgpr0
, restgpr0_tail
},
6292 { "_restgpr0_", 30, 31, restgpr0
, restgpr0_tail
},
6293 { "_savegpr1_", 14, 31, savegpr1
, savegpr1_tail
},
6294 { "_restgpr1_", 14, 31, restgpr1
, restgpr1_tail
},
6295 { "_savefpr_", 14, 31, savefpr
, savefpr0_tail
},
6296 { "_restfpr_", 14, 29, restfpr
, restfpr0_tail
},
6297 { "_restfpr_", 30, 31, restfpr
, restfpr0_tail
},
6298 { "._savef", 14, 31, savefpr
, savefpr1_tail
},
6299 { "._restf", 14, 31, restfpr
, restfpr1_tail
},
6300 { "_savevr_", 20, 31, savevr
, savevr_tail
},
6301 { "_restvr_", 20, 31, restvr
, restvr_tail
}
6304 /* Called near the start of bfd_elf_size_dynamic_sections. We use
6305 this hook to a) provide some gcc support functions, and b) transfer
6306 dynamic linking information gathered so far on function code symbol
6307 entries, to their corresponding function descriptor symbol entries. */
6310 ppc64_elf_func_desc_adjust (bfd
*obfd ATTRIBUTE_UNUSED
,
6311 struct bfd_link_info
*info
)
6313 struct ppc_link_hash_table
*htab
;
6315 htab
= ppc_hash_table (info
);
6319 /* Provide any missing _save* and _rest* functions. */
6320 if (htab
->sfpr
!= NULL
)
6324 htab
->sfpr
->size
= 0;
6325 for (i
= 0; i
< ARRAY_SIZE (save_res_funcs
); i
++)
6326 if (!sfpr_define (info
, &save_res_funcs
[i
], NULL
))
6328 if (htab
->sfpr
->size
== 0)
6329 htab
->sfpr
->flags
|= SEC_EXCLUDE
;
6332 if (bfd_link_relocatable (info
))
6335 if (htab
->elf
.hgot
!= NULL
)
6337 _bfd_elf_link_hash_hide_symbol (info
, htab
->elf
.hgot
, TRUE
);
6338 /* Make .TOC. defined so as to prevent it being made dynamic.
6339 The wrong value here is fixed later in ppc64_elf_set_toc. */
6340 if (!htab
->elf
.hgot
->def_regular
6341 || htab
->elf
.hgot
->root
.type
!= bfd_link_hash_defined
)
6343 htab
->elf
.hgot
->root
.type
= bfd_link_hash_defined
;
6344 htab
->elf
.hgot
->root
.u
.def
.value
= 0;
6345 htab
->elf
.hgot
->root
.u
.def
.section
= bfd_abs_section_ptr
;
6346 htab
->elf
.hgot
->def_regular
= 1;
6347 htab
->elf
.hgot
->root
.linker_def
= 1;
6349 htab
->elf
.hgot
->type
= STT_OBJECT
;
6350 htab
->elf
.hgot
->other
6351 = (htab
->elf
.hgot
->other
& ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN
;
6354 if (htab
->need_func_desc_adj
)
6356 elf_link_hash_traverse (&htab
->elf
, func_desc_adjust
, info
);
6357 htab
->need_func_desc_adj
= 0;
6363 /* Find dynamic relocs for H that apply to read-only sections. */
6366 readonly_dynrelocs (struct elf_link_hash_entry
*h
)
6368 struct ppc_link_hash_entry
*eh
= ppc_elf_hash_entry (h
);
6369 struct elf_dyn_relocs
*p
;
6371 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
6373 asection
*s
= p
->sec
->output_section
;
6375 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
6381 /* Return true if we have dynamic relocs against H or any of its weak
6382 aliases, that apply to read-only sections. Cannot be used after
6383 size_dynamic_sections. */
6386 alias_readonly_dynrelocs (struct elf_link_hash_entry
*h
)
6388 struct ppc_link_hash_entry
*eh
= ppc_elf_hash_entry (h
);
6391 if (readonly_dynrelocs (&eh
->elf
))
6393 eh
= ppc_elf_hash_entry (eh
->elf
.u
.alias
);
6395 while (eh
!= NULL
&& &eh
->elf
!= h
);
6400 /* Return whether EH has pc-relative dynamic relocs. */
6403 pc_dynrelocs (struct ppc_link_hash_entry
*eh
)
6405 struct elf_dyn_relocs
*p
;
6407 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
6408 if (p
->pc_count
!= 0)
6413 /* Return true if a global entry stub will be created for H. Valid
6414 for ELFv2 before plt entries have been allocated. */
6417 global_entry_stub (struct elf_link_hash_entry
*h
)
6419 struct plt_entry
*pent
;
6421 if (!h
->pointer_equality_needed
6425 for (pent
= h
->plt
.plist
; pent
!= NULL
; pent
= pent
->next
)
6426 if (pent
->plt
.refcount
> 0
6427 && pent
->addend
== 0)
6433 /* Adjust a symbol defined by a dynamic object and referenced by a
6434 regular object. The current definition is in some section of the
6435 dynamic object, but we're not including those sections. We have to
6436 change the definition to something the rest of the link can
6440 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
6441 struct elf_link_hash_entry
*h
)
6443 struct ppc_link_hash_table
*htab
;
6446 htab
= ppc_hash_table (info
);
6450 /* Deal with function syms. */
6451 if (h
->type
== STT_FUNC
6452 || h
->type
== STT_GNU_IFUNC
6455 bfd_boolean local
= (ppc_elf_hash_entry (h
)->save_res
6456 || SYMBOL_CALLS_LOCAL (info
, h
)
6457 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
));
6458 /* Discard dyn_relocs when non-pic if we've decided that a
6459 function symbol is local and not an ifunc. We keep dynamic
6460 relocs for ifuncs when local rather than always emitting a
6461 plt call stub for them and defining the symbol on the call
6462 stub. We can't do that for ELFv1 anyway (a function symbol
6463 is defined on a descriptor, not code) and it can be faster at
6464 run-time due to not needing to bounce through a stub. The
6465 dyn_relocs for ifuncs will be applied even in a static
6467 if (!bfd_link_pic (info
)
6468 && h
->type
!= STT_GNU_IFUNC
6470 ppc_elf_hash_entry (h
)->dyn_relocs
= NULL
;
6472 /* Clear procedure linkage table information for any symbol that
6473 won't need a .plt entry. */
6474 struct plt_entry
*ent
;
6475 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
6476 if (ent
->plt
.refcount
> 0)
6479 || (h
->type
!= STT_GNU_IFUNC
6481 && (htab
->can_convert_all_inline_plt
6482 || (ppc_elf_hash_entry (h
)->tls_mask
6483 & (TLS_TLS
| PLT_KEEP
)) != PLT_KEEP
)))
6485 h
->plt
.plist
= NULL
;
6487 h
->pointer_equality_needed
= 0;
6489 else if (abiversion (info
->output_bfd
) >= 2)
6491 /* Taking a function's address in a read/write section
6492 doesn't require us to define the function symbol in the
6493 executable on a global entry stub. A dynamic reloc can
6494 be used instead. The reason we prefer a few more dynamic
6495 relocs is that calling via a global entry stub costs a
6496 few more instructions, and pointer_equality_needed causes
6497 extra work in ld.so when resolving these symbols. */
6498 if (global_entry_stub (h
))
6500 if (!readonly_dynrelocs (h
))
6502 h
->pointer_equality_needed
= 0;
6503 /* If we haven't seen a branch reloc and the symbol
6504 isn't an ifunc then we don't need a plt entry. */
6506 h
->plt
.plist
= NULL
;
6508 else if (!bfd_link_pic (info
))
6509 /* We are going to be defining the function symbol on the
6510 plt stub, so no dyn_relocs needed when non-pic. */
6511 ppc_elf_hash_entry (h
)->dyn_relocs
= NULL
;
6514 /* ELFv2 function symbols can't have copy relocs. */
6517 else if (!h
->needs_plt
6518 && !readonly_dynrelocs (h
))
6520 /* If we haven't seen a branch reloc and the symbol isn't an
6521 ifunc then we don't need a plt entry. */
6522 h
->plt
.plist
= NULL
;
6523 h
->pointer_equality_needed
= 0;
6528 h
->plt
.plist
= NULL
;
6530 /* If this is a weak symbol, and there is a real definition, the
6531 processor independent code will have arranged for us to see the
6532 real definition first, and we can just use the same value. */
6533 if (h
->is_weakalias
)
6535 struct elf_link_hash_entry
*def
= weakdef (h
);
6536 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
6537 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
6538 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
6539 if (def
->root
.u
.def
.section
== htab
->elf
.sdynbss
6540 || def
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
6541 ppc_elf_hash_entry (h
)->dyn_relocs
= NULL
;
6545 /* If we are creating a shared library, we must presume that the
6546 only references to the symbol are via the global offset table.
6547 For such cases we need not do anything here; the relocations will
6548 be handled correctly by relocate_section. */
6549 if (!bfd_link_executable (info
))
6552 /* If there are no references to this symbol that do not use the
6553 GOT, we don't need to generate a copy reloc. */
6554 if (!h
->non_got_ref
)
6557 /* Don't generate a copy reloc for symbols defined in the executable. */
6558 if (!h
->def_dynamic
|| !h
->ref_regular
|| h
->def_regular
6560 /* If -z nocopyreloc was given, don't generate them either. */
6561 || info
->nocopyreloc
6563 /* If we don't find any dynamic relocs in read-only sections, then
6564 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
6565 || (ELIMINATE_COPY_RELOCS
6567 && !alias_readonly_dynrelocs (h
))
6569 /* Protected variables do not work with .dynbss. The copy in
6570 .dynbss won't be used by the shared library with the protected
6571 definition for the variable. Text relocations are preferable
6572 to an incorrect program. */
6573 || h
->protected_def
)
6576 if (h
->type
== STT_FUNC
6577 || h
->type
== STT_GNU_IFUNC
)
6579 /* .dynbss copies of function symbols only work if we have
6580 ELFv1 dot-symbols. ELFv1 compilers since 2004 default to not
6581 use dot-symbols and set the function symbol size to the text
6582 size of the function rather than the size of the descriptor.
6583 That's wrong for copying a descriptor. */
6584 if (ppc_elf_hash_entry (h
)->oh
== NULL
6585 || !(h
->size
== 24 || h
->size
== 16))
6588 /* We should never get here, but unfortunately there are old
6589 versions of gcc (circa gcc-3.2) that improperly for the
6590 ELFv1 ABI put initialized function pointers, vtable refs and
6591 suchlike in read-only sections. Allow them to proceed, but
6592 warn that this might break at runtime. */
6593 info
->callbacks
->einfo
6594 (_("%P: copy reloc against `%pT' requires lazy plt linking; "
6595 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
6596 h
->root
.root
.string
);
6599 /* This is a reference to a symbol defined by a dynamic object which
6600 is not a function. */
6602 /* We must allocate the symbol in our .dynbss section, which will
6603 become part of the .bss section of the executable. There will be
6604 an entry for this symbol in the .dynsym section. The dynamic
6605 object will contain position independent code, so all references
6606 from the dynamic object to this symbol will go through the global
6607 offset table. The dynamic linker will use the .dynsym entry to
6608 determine the address it must put in the global offset table, so
6609 both the dynamic object and the regular object will refer to the
6610 same memory location for the variable. */
6611 if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
6613 s
= htab
->elf
.sdynrelro
;
6614 srel
= htab
->elf
.sreldynrelro
;
6618 s
= htab
->elf
.sdynbss
;
6619 srel
= htab
->elf
.srelbss
;
6621 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
6623 /* We must generate a R_PPC64_COPY reloc to tell the dynamic
6624 linker to copy the initial value out of the dynamic object
6625 and into the runtime process image. */
6626 srel
->size
+= sizeof (Elf64_External_Rela
);
6630 /* We no longer want dyn_relocs. */
6631 ppc_elf_hash_entry (h
)->dyn_relocs
= NULL
;
6632 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
6635 /* If given a function descriptor symbol, hide both the function code
6636 sym and the descriptor. */
6638 ppc64_elf_hide_symbol (struct bfd_link_info
*info
,
6639 struct elf_link_hash_entry
*h
,
6640 bfd_boolean force_local
)
6642 struct ppc_link_hash_entry
*eh
;
6643 _bfd_elf_link_hash_hide_symbol (info
, h
, force_local
);
6645 if (ppc_hash_table (info
) == NULL
)
6648 eh
= ppc_elf_hash_entry (h
);
6649 if (eh
->is_func_descriptor
)
6651 struct ppc_link_hash_entry
*fh
= eh
->oh
;
6656 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
6659 /* We aren't supposed to use alloca in BFD because on
6660 systems which do not have alloca the version in libiberty
6661 calls xmalloc, which might cause the program to crash
6662 when it runs out of memory. This function doesn't have a
6663 return status, so there's no way to gracefully return an
6664 error. So cheat. We know that string[-1] can be safely
6665 accessed; It's either a string in an ELF string table,
6666 or allocated in an objalloc structure. */
6668 p
= eh
->elf
.root
.root
.string
- 1;
6671 fh
= ppc_elf_hash_entry (elf_link_hash_lookup (htab
, p
, FALSE
,
6675 /* Unfortunately, if it so happens that the string we were
6676 looking for was allocated immediately before this string,
6677 then we overwrote the string terminator. That's the only
6678 reason the lookup should fail. */
6681 q
= eh
->elf
.root
.root
.string
+ strlen (eh
->elf
.root
.root
.string
);
6682 while (q
>= eh
->elf
.root
.root
.string
&& *q
== *p
)
6684 if (q
< eh
->elf
.root
.root
.string
&& *p
== '.')
6685 fh
= ppc_elf_hash_entry (elf_link_hash_lookup (htab
, p
, FALSE
,
6695 _bfd_elf_link_hash_hide_symbol (info
, &fh
->elf
, force_local
);
6700 get_sym_h (struct elf_link_hash_entry
**hp
,
6701 Elf_Internal_Sym
**symp
,
6703 unsigned char **tls_maskp
,
6704 Elf_Internal_Sym
**locsymsp
,
6705 unsigned long r_symndx
,
6708 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (ibfd
);
6710 if (r_symndx
>= symtab_hdr
->sh_info
)
6712 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (ibfd
);
6713 struct elf_link_hash_entry
*h
;
6715 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
6716 h
= elf_follow_link (h
);
6724 if (symsecp
!= NULL
)
6726 asection
*symsec
= NULL
;
6727 if (h
->root
.type
== bfd_link_hash_defined
6728 || h
->root
.type
== bfd_link_hash_defweak
)
6729 symsec
= h
->root
.u
.def
.section
;
6733 if (tls_maskp
!= NULL
)
6734 *tls_maskp
= &ppc_elf_hash_entry (h
)->tls_mask
;
6738 Elf_Internal_Sym
*sym
;
6739 Elf_Internal_Sym
*locsyms
= *locsymsp
;
6741 if (locsyms
== NULL
)
6743 locsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
6744 if (locsyms
== NULL
)
6745 locsyms
= bfd_elf_get_elf_syms (ibfd
, symtab_hdr
,
6746 symtab_hdr
->sh_info
,
6747 0, NULL
, NULL
, NULL
);
6748 if (locsyms
== NULL
)
6750 *locsymsp
= locsyms
;
6752 sym
= locsyms
+ r_symndx
;
6760 if (symsecp
!= NULL
)
6761 *symsecp
= bfd_section_from_elf_index (ibfd
, sym
->st_shndx
);
6763 if (tls_maskp
!= NULL
)
6765 struct got_entry
**lgot_ents
;
6766 unsigned char *tls_mask
;
6769 lgot_ents
= elf_local_got_ents (ibfd
);
6770 if (lgot_ents
!= NULL
)
6772 struct plt_entry
**local_plt
= (struct plt_entry
**)
6773 (lgot_ents
+ symtab_hdr
->sh_info
);
6774 unsigned char *lgot_masks
= (unsigned char *)
6775 (local_plt
+ symtab_hdr
->sh_info
);
6776 tls_mask
= &lgot_masks
[r_symndx
];
6778 *tls_maskp
= tls_mask
;
6784 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
6785 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
6786 type suitable for optimization, and 1 otherwise. */
6789 get_tls_mask (unsigned char **tls_maskp
,
6790 unsigned long *toc_symndx
,
6791 bfd_vma
*toc_addend
,
6792 Elf_Internal_Sym
**locsymsp
,
6793 const Elf_Internal_Rela
*rel
,
6796 unsigned long r_symndx
;
6798 struct elf_link_hash_entry
*h
;
6799 Elf_Internal_Sym
*sym
;
6803 r_symndx
= ELF64_R_SYM (rel
->r_info
);
6804 if (!get_sym_h (&h
, &sym
, &sec
, tls_maskp
, locsymsp
, r_symndx
, ibfd
))
6807 if ((*tls_maskp
!= NULL
6808 && (**tls_maskp
& TLS_TLS
) != 0
6809 && **tls_maskp
!= (TLS_TLS
| TLS_MARK
))
6811 || ppc64_elf_section_data (sec
) == NULL
6812 || ppc64_elf_section_data (sec
)->sec_type
!= sec_toc
)
6815 /* Look inside a TOC section too. */
6818 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
);
6819 off
= h
->root
.u
.def
.value
;
6822 off
= sym
->st_value
;
6823 off
+= rel
->r_addend
;
6824 BFD_ASSERT (off
% 8 == 0);
6825 r_symndx
= ppc64_elf_section_data (sec
)->u
.toc
.symndx
[off
/ 8];
6826 next_r
= ppc64_elf_section_data (sec
)->u
.toc
.symndx
[off
/ 8 + 1];
6827 if (toc_symndx
!= NULL
)
6828 *toc_symndx
= r_symndx
;
6829 if (toc_addend
!= NULL
)
6830 *toc_addend
= ppc64_elf_section_data (sec
)->u
.toc
.add
[off
/ 8];
6831 if (!get_sym_h (&h
, &sym
, &sec
, tls_maskp
, locsymsp
, r_symndx
, ibfd
))
6833 if ((h
== NULL
|| is_static_defined (h
))
6834 && (next_r
== -1 || next_r
== -2))
6839 /* Find (or create) an entry in the tocsave hash table. */
6841 static struct tocsave_entry
*
6842 tocsave_find (struct ppc_link_hash_table
*htab
,
6843 enum insert_option insert
,
6844 Elf_Internal_Sym
**local_syms
,
6845 const Elf_Internal_Rela
*irela
,
6848 unsigned long r_indx
;
6849 struct elf_link_hash_entry
*h
;
6850 Elf_Internal_Sym
*sym
;
6851 struct tocsave_entry ent
, *p
;
6853 struct tocsave_entry
**slot
;
6855 r_indx
= ELF64_R_SYM (irela
->r_info
);
6856 if (!get_sym_h (&h
, &sym
, &ent
.sec
, NULL
, local_syms
, r_indx
, ibfd
))
6858 if (ent
.sec
== NULL
|| ent
.sec
->output_section
== NULL
)
6861 (_("%pB: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd
);
6866 ent
.offset
= h
->root
.u
.def
.value
;
6868 ent
.offset
= sym
->st_value
;
6869 ent
.offset
+= irela
->r_addend
;
6871 hash
= tocsave_htab_hash (&ent
);
6872 slot
= ((struct tocsave_entry
**)
6873 htab_find_slot_with_hash (htab
->tocsave_htab
, &ent
, hash
, insert
));
6879 p
= (struct tocsave_entry
*) bfd_alloc (ibfd
, sizeof (*p
));
6888 /* Adjust all global syms defined in opd sections. In gcc generated
6889 code for the old ABI, these will already have been done. */
6892 adjust_opd_syms (struct elf_link_hash_entry
*h
, void *inf ATTRIBUTE_UNUSED
)
6894 struct ppc_link_hash_entry
*eh
;
6896 struct _opd_sec_data
*opd
;
6898 if (h
->root
.type
== bfd_link_hash_indirect
)
6901 if (h
->root
.type
!= bfd_link_hash_defined
6902 && h
->root
.type
!= bfd_link_hash_defweak
)
6905 eh
= ppc_elf_hash_entry (h
);
6906 if (eh
->adjust_done
)
6909 sym_sec
= eh
->elf
.root
.u
.def
.section
;
6910 opd
= get_opd_info (sym_sec
);
6911 if (opd
!= NULL
&& opd
->adjust
!= NULL
)
6913 long adjust
= opd
->adjust
[OPD_NDX (eh
->elf
.root
.u
.def
.value
)];
6916 /* This entry has been deleted. */
6917 asection
*dsec
= ppc64_elf_tdata (sym_sec
->owner
)->deleted_section
;
6920 for (dsec
= sym_sec
->owner
->sections
; dsec
; dsec
= dsec
->next
)
6921 if (discarded_section (dsec
))
6923 ppc64_elf_tdata (sym_sec
->owner
)->deleted_section
= dsec
;
6927 eh
->elf
.root
.u
.def
.value
= 0;
6928 eh
->elf
.root
.u
.def
.section
= dsec
;
6931 eh
->elf
.root
.u
.def
.value
+= adjust
;
6932 eh
->adjust_done
= 1;
6937 /* Handles decrementing dynamic reloc counts for the reloc specified by
6938 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
6939 have already been determined. */
6942 dec_dynrel_count (bfd_vma r_info
,
6944 struct bfd_link_info
*info
,
6945 Elf_Internal_Sym
**local_syms
,
6946 struct elf_link_hash_entry
*h
,
6947 Elf_Internal_Sym
*sym
)
6949 enum elf_ppc64_reloc_type r_type
;
6950 asection
*sym_sec
= NULL
;
6952 /* Can this reloc be dynamic? This switch, and later tests here
6953 should be kept in sync with the code in check_relocs. */
6954 r_type
= ELF64_R_TYPE (r_info
);
6961 case R_PPC64_TOC16_DS
:
6962 case R_PPC64_TOC16_LO
:
6963 case R_PPC64_TOC16_HI
:
6964 case R_PPC64_TOC16_HA
:
6965 case R_PPC64_TOC16_LO_DS
:
6970 case R_PPC64_TPREL16
:
6971 case R_PPC64_TPREL16_LO
:
6972 case R_PPC64_TPREL16_HI
:
6973 case R_PPC64_TPREL16_HA
:
6974 case R_PPC64_TPREL16_DS
:
6975 case R_PPC64_TPREL16_LO_DS
:
6976 case R_PPC64_TPREL16_HIGH
:
6977 case R_PPC64_TPREL16_HIGHA
:
6978 case R_PPC64_TPREL16_HIGHER
:
6979 case R_PPC64_TPREL16_HIGHERA
:
6980 case R_PPC64_TPREL16_HIGHEST
:
6981 case R_PPC64_TPREL16_HIGHESTA
:
6982 case R_PPC64_TPREL64
:
6983 case R_PPC64_TPREL34
:
6984 case R_PPC64_DTPMOD64
:
6985 case R_PPC64_DTPREL64
:
6986 case R_PPC64_ADDR64
:
6990 case R_PPC64_ADDR14
:
6991 case R_PPC64_ADDR14_BRNTAKEN
:
6992 case R_PPC64_ADDR14_BRTAKEN
:
6993 case R_PPC64_ADDR16
:
6994 case R_PPC64_ADDR16_DS
:
6995 case R_PPC64_ADDR16_HA
:
6996 case R_PPC64_ADDR16_HI
:
6997 case R_PPC64_ADDR16_HIGH
:
6998 case R_PPC64_ADDR16_HIGHA
:
6999 case R_PPC64_ADDR16_HIGHER
:
7000 case R_PPC64_ADDR16_HIGHERA
:
7001 case R_PPC64_ADDR16_HIGHEST
:
7002 case R_PPC64_ADDR16_HIGHESTA
:
7003 case R_PPC64_ADDR16_LO
:
7004 case R_PPC64_ADDR16_LO_DS
:
7005 case R_PPC64_ADDR24
:
7006 case R_PPC64_ADDR32
:
7007 case R_PPC64_UADDR16
:
7008 case R_PPC64_UADDR32
:
7009 case R_PPC64_UADDR64
:
7012 case R_PPC64_D34_LO
:
7013 case R_PPC64_D34_HI30
:
7014 case R_PPC64_D34_HA30
:
7015 case R_PPC64_ADDR16_HIGHER34
:
7016 case R_PPC64_ADDR16_HIGHERA34
:
7017 case R_PPC64_ADDR16_HIGHEST34
:
7018 case R_PPC64_ADDR16_HIGHESTA34
:
7023 if (local_syms
!= NULL
)
7025 unsigned long r_symndx
;
7026 bfd
*ibfd
= sec
->owner
;
7028 r_symndx
= ELF64_R_SYM (r_info
);
7029 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, local_syms
, r_symndx
, ibfd
))
7034 && (h
->root
.type
== bfd_link_hash_defweak
7035 || !h
->def_regular
))
7037 && !bfd_link_executable (info
)
7038 && !SYMBOLIC_BIND (info
, h
))
7039 || (bfd_link_pic (info
)
7040 && must_be_dyn_reloc (info
, r_type
))
7041 || (!bfd_link_pic (info
)
7043 ? h
->type
== STT_GNU_IFUNC
7044 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)))
7051 struct elf_dyn_relocs
*p
;
7052 struct elf_dyn_relocs
**pp
;
7053 pp
= &ppc_elf_hash_entry (h
)->dyn_relocs
;
7055 /* elf_gc_sweep may have already removed all dyn relocs associated
7056 with local syms for a given section. Also, symbol flags are
7057 changed by elf_gc_sweep_symbol, confusing the test above. Don't
7058 report a dynreloc miscount. */
7059 if (*pp
== NULL
&& info
->gc_sections
)
7062 while ((p
= *pp
) != NULL
)
7066 if (!must_be_dyn_reloc (info
, r_type
))
7078 struct ppc_dyn_relocs
*p
;
7079 struct ppc_dyn_relocs
**pp
;
7081 bfd_boolean is_ifunc
;
7083 if (local_syms
== NULL
)
7084 sym_sec
= bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
7085 if (sym_sec
== NULL
)
7088 vpp
= &elf_section_data (sym_sec
)->local_dynrel
;
7089 pp
= (struct ppc_dyn_relocs
**) vpp
;
7091 if (*pp
== NULL
&& info
->gc_sections
)
7094 is_ifunc
= ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
;
7095 while ((p
= *pp
) != NULL
)
7097 if (p
->sec
== sec
&& p
->ifunc
== is_ifunc
)
7108 /* xgettext:c-format */
7109 _bfd_error_handler (_("dynreloc miscount for %pB, section %pA"),
7111 bfd_set_error (bfd_error_bad_value
);
7115 /* Remove unused Official Procedure Descriptor entries. Currently we
7116 only remove those associated with functions in discarded link-once
7117 sections, or weakly defined functions that have been overridden. It
7118 would be possible to remove many more entries for statically linked
7122 ppc64_elf_edit_opd (struct bfd_link_info
*info
)
7125 bfd_boolean some_edited
= FALSE
;
7126 asection
*need_pad
= NULL
;
7127 struct ppc_link_hash_table
*htab
;
7129 htab
= ppc_hash_table (info
);
7133 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
7136 Elf_Internal_Rela
*relstart
, *rel
, *relend
;
7137 Elf_Internal_Shdr
*symtab_hdr
;
7138 Elf_Internal_Sym
*local_syms
;
7139 struct _opd_sec_data
*opd
;
7140 bfd_boolean need_edit
, add_aux_fields
, broken
;
7141 bfd_size_type cnt_16b
= 0;
7143 if (!is_ppc64_elf (ibfd
))
7146 sec
= bfd_get_section_by_name (ibfd
, ".opd");
7147 if (sec
== NULL
|| sec
->size
== 0)
7150 if (sec
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
7153 if (sec
->output_section
== bfd_abs_section_ptr
)
7156 /* Look through the section relocs. */
7157 if ((sec
->flags
& SEC_RELOC
) == 0 || sec
->reloc_count
== 0)
7161 symtab_hdr
= &elf_symtab_hdr (ibfd
);
7163 /* Read the relocations. */
7164 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
7166 if (relstart
== NULL
)
7169 /* First run through the relocs to check they are sane, and to
7170 determine whether we need to edit this opd section. */
7174 relend
= relstart
+ sec
->reloc_count
;
7175 for (rel
= relstart
; rel
< relend
; )
7177 enum elf_ppc64_reloc_type r_type
;
7178 unsigned long r_symndx
;
7180 struct elf_link_hash_entry
*h
;
7181 Elf_Internal_Sym
*sym
;
7184 /* .opd contains an array of 16 or 24 byte entries. We're
7185 only interested in the reloc pointing to a function entry
7187 offset
= rel
->r_offset
;
7188 if (rel
+ 1 == relend
7189 || rel
[1].r_offset
!= offset
+ 8)
7191 /* If someone messes with .opd alignment then after a
7192 "ld -r" we might have padding in the middle of .opd.
7193 Also, there's nothing to prevent someone putting
7194 something silly in .opd with the assembler. No .opd
7195 optimization for them! */
7198 (_("%pB: .opd is not a regular array of opd entries"), ibfd
);
7203 if ((r_type
= ELF64_R_TYPE (rel
->r_info
)) != R_PPC64_ADDR64
7204 || (r_type
= ELF64_R_TYPE ((rel
+ 1)->r_info
)) != R_PPC64_TOC
)
7207 /* xgettext:c-format */
7208 (_("%pB: unexpected reloc type %u in .opd section"),
7214 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7215 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
7219 if (sym_sec
== NULL
|| sym_sec
->owner
== NULL
)
7221 const char *sym_name
;
7223 sym_name
= h
->root
.root
.string
;
7225 sym_name
= bfd_elf_sym_name (ibfd
, symtab_hdr
, sym
,
7229 /* xgettext:c-format */
7230 (_("%pB: undefined sym `%s' in .opd section"),
7236 /* opd entries are always for functions defined in the
7237 current input bfd. If the symbol isn't defined in the
7238 input bfd, then we won't be using the function in this
7239 bfd; It must be defined in a linkonce section in another
7240 bfd, or is weak. It's also possible that we are
7241 discarding the function due to a linker script /DISCARD/,
7242 which we test for via the output_section. */
7243 if (sym_sec
->owner
!= ibfd
7244 || sym_sec
->output_section
== bfd_abs_section_ptr
)
7248 if (rel
+ 1 == relend
7249 || (rel
+ 2 < relend
7250 && ELF64_R_TYPE (rel
[2].r_info
) == R_PPC64_TOC
))
7255 if (sec
->size
== offset
+ 24)
7260 if (sec
->size
== offset
+ 16)
7267 else if (rel
+ 1 < relend
7268 && ELF64_R_TYPE (rel
[0].r_info
) == R_PPC64_ADDR64
7269 && ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_TOC
)
7271 if (rel
[0].r_offset
== offset
+ 16)
7273 else if (rel
[0].r_offset
!= offset
+ 24)
7280 add_aux_fields
= htab
->params
->non_overlapping_opd
&& cnt_16b
> 0;
7282 if (!broken
&& (need_edit
|| add_aux_fields
))
7284 Elf_Internal_Rela
*write_rel
;
7285 Elf_Internal_Shdr
*rel_hdr
;
7286 bfd_byte
*rptr
, *wptr
;
7287 bfd_byte
*new_contents
;
7290 new_contents
= NULL
;
7291 amt
= OPD_NDX (sec
->size
) * sizeof (long);
7292 opd
= &ppc64_elf_section_data (sec
)->u
.opd
;
7293 opd
->adjust
= bfd_zalloc (sec
->owner
, amt
);
7294 if (opd
->adjust
== NULL
)
7297 /* This seems a waste of time as input .opd sections are all
7298 zeros as generated by gcc, but I suppose there's no reason
7299 this will always be so. We might start putting something in
7300 the third word of .opd entries. */
7301 if ((sec
->flags
& SEC_IN_MEMORY
) == 0)
7304 if (!bfd_malloc_and_get_section (ibfd
, sec
, &loc
))
7309 if (local_syms
!= NULL
7310 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
7312 if (elf_section_data (sec
)->relocs
!= relstart
)
7316 sec
->contents
= loc
;
7317 sec
->flags
|= (SEC_IN_MEMORY
| SEC_HAS_CONTENTS
);
7320 elf_section_data (sec
)->relocs
= relstart
;
7322 new_contents
= sec
->contents
;
7325 new_contents
= bfd_malloc (sec
->size
+ cnt_16b
* 8);
7326 if (new_contents
== NULL
)
7330 wptr
= new_contents
;
7331 rptr
= sec
->contents
;
7332 write_rel
= relstart
;
7333 for (rel
= relstart
; rel
< relend
; )
7335 unsigned long r_symndx
;
7337 struct elf_link_hash_entry
*h
;
7338 struct ppc_link_hash_entry
*fdh
= NULL
;
7339 Elf_Internal_Sym
*sym
;
7341 Elf_Internal_Rela
*next_rel
;
7344 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7345 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
7350 if (next_rel
+ 1 == relend
7351 || (next_rel
+ 2 < relend
7352 && ELF64_R_TYPE (next_rel
[2].r_info
) == R_PPC64_TOC
))
7355 /* See if the .opd entry is full 24 byte or
7356 16 byte (with fd_aux entry overlapped with next
7359 if (next_rel
== relend
)
7361 if (sec
->size
== rel
->r_offset
+ 16)
7364 else if (next_rel
->r_offset
== rel
->r_offset
+ 16)
7368 && h
->root
.root
.string
[0] == '.')
7370 fdh
= ppc_elf_hash_entry (h
)->oh
;
7373 fdh
= ppc_follow_link (fdh
);
7374 if (fdh
->elf
.root
.type
!= bfd_link_hash_defined
7375 && fdh
->elf
.root
.type
!= bfd_link_hash_defweak
)
7380 skip
= (sym_sec
->owner
!= ibfd
7381 || sym_sec
->output_section
== bfd_abs_section_ptr
);
7384 if (fdh
!= NULL
&& sym_sec
->owner
== ibfd
)
7386 /* Arrange for the function descriptor sym
7388 fdh
->elf
.root
.u
.def
.value
= 0;
7389 fdh
->elf
.root
.u
.def
.section
= sym_sec
;
7391 opd
->adjust
[OPD_NDX (rel
->r_offset
)] = -1;
7393 if (NO_OPD_RELOCS
|| bfd_link_relocatable (info
))
7398 if (!dec_dynrel_count (rel
->r_info
, sec
, info
,
7402 if (++rel
== next_rel
)
7405 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7406 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
7413 /* We'll be keeping this opd entry. */
7418 /* Redefine the function descriptor symbol to
7419 this location in the opd section. It is
7420 necessary to update the value here rather
7421 than using an array of adjustments as we do
7422 for local symbols, because various places
7423 in the generic ELF code use the value
7424 stored in u.def.value. */
7425 fdh
->elf
.root
.u
.def
.value
= wptr
- new_contents
;
7426 fdh
->adjust_done
= 1;
7429 /* Local syms are a bit tricky. We could
7430 tweak them as they can be cached, but
7431 we'd need to look through the local syms
7432 for the function descriptor sym which we
7433 don't have at the moment. So keep an
7434 array of adjustments. */
7435 adjust
= (wptr
- new_contents
) - (rptr
- sec
->contents
);
7436 opd
->adjust
[OPD_NDX (rel
->r_offset
)] = adjust
;
7439 memcpy (wptr
, rptr
, opd_ent_size
);
7440 wptr
+= opd_ent_size
;
7441 if (add_aux_fields
&& opd_ent_size
== 16)
7443 memset (wptr
, '\0', 8);
7447 /* We need to adjust any reloc offsets to point to the
7449 for ( ; rel
!= next_rel
; ++rel
)
7451 rel
->r_offset
+= adjust
;
7452 if (write_rel
!= rel
)
7453 memcpy (write_rel
, rel
, sizeof (*rel
));
7458 rptr
+= opd_ent_size
;
7461 sec
->size
= wptr
- new_contents
;
7462 sec
->reloc_count
= write_rel
- relstart
;
7465 free (sec
->contents
);
7466 sec
->contents
= new_contents
;
7469 /* Fudge the header size too, as this is used later in
7470 elf_bfd_final_link if we are emitting relocs. */
7471 rel_hdr
= _bfd_elf_single_rel_hdr (sec
);
7472 rel_hdr
->sh_size
= sec
->reloc_count
* rel_hdr
->sh_entsize
;
7475 else if (elf_section_data (sec
)->relocs
!= relstart
)
7478 if (local_syms
!= NULL
7479 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
7481 if (!info
->keep_memory
)
7484 symtab_hdr
->contents
= (unsigned char *) local_syms
;
7489 elf_link_hash_traverse (elf_hash_table (info
), adjust_opd_syms
, NULL
);
7491 /* If we are doing a final link and the last .opd entry is just 16 byte
7492 long, add a 8 byte padding after it. */
7493 if (need_pad
!= NULL
&& !bfd_link_relocatable (info
))
7497 if ((need_pad
->flags
& SEC_IN_MEMORY
) == 0)
7499 BFD_ASSERT (need_pad
->size
> 0);
7501 p
= bfd_malloc (need_pad
->size
+ 8);
7505 if (!bfd_get_section_contents (need_pad
->owner
, need_pad
,
7506 p
, 0, need_pad
->size
))
7509 need_pad
->contents
= p
;
7510 need_pad
->flags
|= (SEC_IN_MEMORY
| SEC_HAS_CONTENTS
);
7514 p
= bfd_realloc (need_pad
->contents
, need_pad
->size
+ 8);
7518 need_pad
->contents
= p
;
7521 memset (need_pad
->contents
+ need_pad
->size
, 0, 8);
7522 need_pad
->size
+= 8;
7528 /* Analyze inline PLT call relocations to see whether calls to locally
7529 defined functions can be converted to direct calls. */
7532 ppc64_elf_inline_plt (struct bfd_link_info
*info
)
7534 struct ppc_link_hash_table
*htab
;
7537 bfd_vma low_vma
, high_vma
, limit
;
7539 htab
= ppc_hash_table (info
);
7543 /* A bl insn can reach -0x2000000 to 0x1fffffc. The limit is
7544 reduced somewhat to cater for possible stubs that might be added
7545 between the call and its destination. */
7546 if (htab
->params
->group_size
< 0)
7548 limit
= -htab
->params
->group_size
;
7554 limit
= htab
->params
->group_size
;
7561 for (sec
= info
->output_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7562 if ((sec
->flags
& (SEC_ALLOC
| SEC_CODE
)) == (SEC_ALLOC
| SEC_CODE
))
7564 if (low_vma
> sec
->vma
)
7566 if (high_vma
< sec
->vma
+ sec
->size
)
7567 high_vma
= sec
->vma
+ sec
->size
;
7570 /* If a "bl" can reach anywhere in local code sections, then we can
7571 convert all inline PLT sequences to direct calls when the symbol
7573 if (high_vma
- low_vma
< limit
)
7575 htab
->can_convert_all_inline_plt
= 1;
7579 /* Otherwise, go looking through relocs for cases where a direct
7580 call won't reach. Mark the symbol on any such reloc to disable
7581 the optimization and keep the PLT entry as it seems likely that
7582 this will be better than creating trampolines. Note that this
7583 will disable the optimization for all inline PLT calls to a
7584 particular symbol, not just those that won't reach. The
7585 difficulty in doing a more precise optimization is that the
7586 linker needs to make a decision depending on whether a
7587 particular R_PPC64_PLTCALL insn can be turned into a direct
7588 call, for each of the R_PPC64_PLTSEQ and R_PPC64_PLT16* insns in
7589 the sequence, and there is nothing that ties those relocs
7590 together except their symbol. */
7592 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
7594 Elf_Internal_Shdr
*symtab_hdr
;
7595 Elf_Internal_Sym
*local_syms
;
7597 if (!is_ppc64_elf (ibfd
))
7601 symtab_hdr
= &elf_symtab_hdr (ibfd
);
7603 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7604 if (ppc64_elf_section_data (sec
)->has_pltcall
7605 && !bfd_is_abs_section (sec
->output_section
))
7607 Elf_Internal_Rela
*relstart
, *rel
, *relend
;
7609 /* Read the relocations. */
7610 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
7612 if (relstart
== NULL
)
7615 relend
= relstart
+ sec
->reloc_count
;
7616 for (rel
= relstart
; rel
< relend
; rel
++)
7618 enum elf_ppc64_reloc_type r_type
;
7619 unsigned long r_symndx
;
7621 struct elf_link_hash_entry
*h
;
7622 Elf_Internal_Sym
*sym
;
7623 unsigned char *tls_maskp
;
7625 r_type
= ELF64_R_TYPE (rel
->r_info
);
7626 if (r_type
!= R_PPC64_PLTCALL
7627 && r_type
!= R_PPC64_PLTCALL_NOTOC
)
7630 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7631 if (!get_sym_h (&h
, &sym
, &sym_sec
, &tls_maskp
, &local_syms
,
7634 if (elf_section_data (sec
)->relocs
!= relstart
)
7636 if (local_syms
!= NULL
7637 && symtab_hdr
->contents
!= (bfd_byte
*) local_syms
)
7642 if (sym_sec
!= NULL
&& sym_sec
->output_section
!= NULL
)
7646 to
= h
->root
.u
.def
.value
;
7649 to
+= (rel
->r_addend
7650 + sym_sec
->output_offset
7651 + sym_sec
->output_section
->vma
);
7652 from
= (rel
->r_offset
7653 + sec
->output_offset
7654 + sec
->output_section
->vma
);
7655 if (to
- from
+ limit
< 2 * limit
7656 && !(r_type
== R_PPC64_PLTCALL_NOTOC
7657 && (((h
? h
->other
: sym
->st_other
)
7658 & STO_PPC64_LOCAL_MASK
)
7659 > 1 << STO_PPC64_LOCAL_BIT
)))
7660 *tls_maskp
&= ~PLT_KEEP
;
7663 if (elf_section_data (sec
)->relocs
!= relstart
)
7667 if (local_syms
!= NULL
7668 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
7670 if (!info
->keep_memory
)
7673 symtab_hdr
->contents
= (unsigned char *) local_syms
;
7680 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
7683 ppc64_elf_tls_setup (struct bfd_link_info
*info
)
7685 struct ppc_link_hash_table
*htab
;
7686 struct elf_link_hash_entry
*tga
, *tga_fd
, *desc
, *desc_fd
;
7688 htab
= ppc_hash_table (info
);
7692 if (abiversion (info
->output_bfd
) == 1)
7695 if (htab
->params
->no_multi_toc
)
7696 htab
->do_multi_toc
= 0;
7697 else if (!htab
->do_multi_toc
)
7698 htab
->params
->no_multi_toc
= 1;
7700 /* Default to --no-plt-localentry, as this option can cause problems
7701 with symbol interposition. For example, glibc libpthread.so and
7702 libc.so duplicate many pthread symbols, with a fallback
7703 implementation in libc.so. In some cases the fallback does more
7704 work than the pthread implementation. __pthread_condattr_destroy
7705 is one such symbol: the libpthread.so implementation is
7706 localentry:0 while the libc.so implementation is localentry:8.
7707 An app that "cleverly" uses dlopen to only load necessary
7708 libraries at runtime may omit loading libpthread.so when not
7709 running multi-threaded, which then results in the libc.so
7710 fallback symbols being used and ld.so complaining. Now there
7711 are workarounds in ld (see non_zero_localentry) to detect the
7712 pthread situation, but that may not be the only case where
7713 --plt-localentry can cause trouble. */
7714 if (htab
->params
->plt_localentry0
< 0)
7715 htab
->params
->plt_localentry0
= 0;
7716 if (htab
->params
->plt_localentry0
7717 && elf_link_hash_lookup (&htab
->elf
, "GLIBC_2.26",
7718 FALSE
, FALSE
, FALSE
) == NULL
)
7720 (_("warning: --plt-localentry is especially dangerous without "
7721 "ld.so support to detect ABI violations"));
7723 tga
= elf_link_hash_lookup (&htab
->elf
, ".__tls_get_addr",
7724 FALSE
, FALSE
, TRUE
);
7725 htab
->tls_get_addr
= ppc_elf_hash_entry (tga
);
7727 /* Move dynamic linking info to the function descriptor sym. */
7729 func_desc_adjust (tga
, info
);
7730 tga_fd
= elf_link_hash_lookup (&htab
->elf
, "__tls_get_addr",
7731 FALSE
, FALSE
, TRUE
);
7732 htab
->tls_get_addr_fd
= ppc_elf_hash_entry (tga_fd
);
7734 desc
= elf_link_hash_lookup (&htab
->elf
, ".__tls_get_addr_desc",
7735 FALSE
, FALSE
, TRUE
);
7736 htab
->tga_desc
= ppc_elf_hash_entry (desc
);
7738 func_desc_adjust (desc
, info
);
7739 desc_fd
= elf_link_hash_lookup (&htab
->elf
, "__tls_get_addr_desc",
7740 FALSE
, FALSE
, TRUE
);
7741 htab
->tga_desc_fd
= ppc_elf_hash_entry (desc_fd
);
7743 if (htab
->params
->tls_get_addr_opt
)
7745 struct elf_link_hash_entry
*opt
, *opt_fd
;
7747 opt
= elf_link_hash_lookup (&htab
->elf
, ".__tls_get_addr_opt",
7748 FALSE
, FALSE
, TRUE
);
7750 func_desc_adjust (opt
, info
);
7751 opt_fd
= elf_link_hash_lookup (&htab
->elf
, "__tls_get_addr_opt",
7752 FALSE
, FALSE
, TRUE
);
7754 && (opt_fd
->root
.type
== bfd_link_hash_defined
7755 || opt_fd
->root
.type
== bfd_link_hash_defweak
))
7757 /* If glibc supports an optimized __tls_get_addr call stub,
7758 signalled by the presence of __tls_get_addr_opt, and we'll
7759 be calling __tls_get_addr via a plt call stub, then
7760 make __tls_get_addr point to __tls_get_addr_opt. */
7761 if (!(htab
->elf
.dynamic_sections_created
7763 && (tga_fd
->type
== STT_FUNC
7764 || tga_fd
->needs_plt
)
7765 && !(SYMBOL_CALLS_LOCAL (info
, tga_fd
)
7766 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, tga_fd
))))
7768 if (!(htab
->elf
.dynamic_sections_created
7770 && (desc_fd
->type
== STT_FUNC
7771 || desc_fd
->needs_plt
)
7772 && !(SYMBOL_CALLS_LOCAL (info
, desc_fd
)
7773 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, desc_fd
))))
7776 if (tga_fd
!= NULL
|| desc_fd
!= NULL
)
7778 struct plt_entry
*ent
= NULL
;
7781 for (ent
= tga_fd
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
7782 if (ent
->plt
.refcount
> 0)
7784 if (ent
== NULL
&& desc_fd
!= NULL
)
7785 for (ent
= desc_fd
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
7786 if (ent
->plt
.refcount
> 0)
7792 tga_fd
->root
.type
= bfd_link_hash_indirect
;
7793 tga_fd
->root
.u
.i
.link
= &opt_fd
->root
;
7794 tga_fd
->root
.u
.i
.warning
= NULL
;
7795 ppc64_elf_copy_indirect_symbol (info
, opt_fd
, tga_fd
);
7797 if (desc_fd
!= NULL
)
7799 desc_fd
->root
.type
= bfd_link_hash_indirect
;
7800 desc_fd
->root
.u
.i
.link
= &opt_fd
->root
;
7801 desc_fd
->root
.u
.i
.warning
= NULL
;
7802 ppc64_elf_copy_indirect_symbol (info
, opt_fd
, desc_fd
);
7805 if (opt_fd
->dynindx
!= -1)
7807 /* Use __tls_get_addr_opt in dynamic relocations. */
7808 opt_fd
->dynindx
= -1;
7809 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
7810 opt_fd
->dynstr_index
);
7811 if (!bfd_elf_link_record_dynamic_symbol (info
, opt_fd
))
7816 htab
->tls_get_addr_fd
= ppc_elf_hash_entry (opt_fd
);
7817 tga
= &htab
->tls_get_addr
->elf
;
7818 if (opt
!= NULL
&& tga
!= NULL
)
7820 tga
->root
.type
= bfd_link_hash_indirect
;
7821 tga
->root
.u
.i
.link
= &opt
->root
;
7822 tga
->root
.u
.i
.warning
= NULL
;
7823 ppc64_elf_copy_indirect_symbol (info
, opt
, tga
);
7825 _bfd_elf_link_hash_hide_symbol (info
, opt
,
7827 htab
->tls_get_addr
= ppc_elf_hash_entry (opt
);
7829 htab
->tls_get_addr_fd
->oh
= htab
->tls_get_addr
;
7830 htab
->tls_get_addr_fd
->is_func_descriptor
= 1;
7831 if (htab
->tls_get_addr
!= NULL
)
7833 htab
->tls_get_addr
->oh
= htab
->tls_get_addr_fd
;
7834 htab
->tls_get_addr
->is_func
= 1;
7837 if (desc_fd
!= NULL
)
7839 htab
->tga_desc_fd
= ppc_elf_hash_entry (opt_fd
);
7840 if (opt
!= NULL
&& desc
!= NULL
)
7842 desc
->root
.type
= bfd_link_hash_indirect
;
7843 desc
->root
.u
.i
.link
= &opt
->root
;
7844 desc
->root
.u
.i
.warning
= NULL
;
7845 ppc64_elf_copy_indirect_symbol (info
, opt
, desc
);
7847 _bfd_elf_link_hash_hide_symbol (info
, opt
,
7848 desc
->forced_local
);
7849 htab
->tga_desc
= ppc_elf_hash_entry (opt
);
7851 htab
->tga_desc_fd
->oh
= htab
->tga_desc
;
7852 htab
->tga_desc_fd
->is_func_descriptor
= 1;
7853 if (htab
->tga_desc
!= NULL
)
7855 htab
->tga_desc
->oh
= htab
->tga_desc_fd
;
7856 htab
->tga_desc
->is_func
= 1;
7862 else if (htab
->params
->tls_get_addr_opt
< 0)
7863 htab
->params
->tls_get_addr_opt
= 0;
7866 if (htab
->tga_desc_fd
!= NULL
7867 && htab
->params
->tls_get_addr_opt
7868 && htab
->params
->no_tls_get_addr_regsave
== -1)
7869 htab
->params
->no_tls_get_addr_regsave
= 0;
7871 return _bfd_elf_tls_setup (info
->output_bfd
, info
);
7874 /* Return TRUE iff REL is a branch reloc with a global symbol matching
7875 any of HASH1, HASH2, HASH3, or HASH4. */
7878 branch_reloc_hash_match (const bfd
*ibfd
,
7879 const Elf_Internal_Rela
*rel
,
7880 const struct ppc_link_hash_entry
*hash1
,
7881 const struct ppc_link_hash_entry
*hash2
,
7882 const struct ppc_link_hash_entry
*hash3
,
7883 const struct ppc_link_hash_entry
*hash4
)
7885 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (ibfd
);
7886 enum elf_ppc64_reloc_type r_type
= ELF64_R_TYPE (rel
->r_info
);
7887 unsigned int r_symndx
= ELF64_R_SYM (rel
->r_info
);
7889 if (r_symndx
>= symtab_hdr
->sh_info
&& is_branch_reloc (r_type
))
7891 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (ibfd
);
7892 struct elf_link_hash_entry
*h
;
7894 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
7895 h
= elf_follow_link (h
);
7896 if (h
== &hash1
->elf
|| h
== &hash2
->elf
7897 || h
== &hash3
->elf
|| h
== &hash4
->elf
)
7903 /* Run through all the TLS relocs looking for optimization
7904 opportunities. The linker has been hacked (see ppc64elf.em) to do
7905 a preliminary section layout so that we know the TLS segment
7906 offsets. We can't optimize earlier because some optimizations need
7907 to know the tp offset, and we need to optimize before allocating
7908 dynamic relocations. */
7911 ppc64_elf_tls_optimize (struct bfd_link_info
*info
)
7915 struct ppc_link_hash_table
*htab
;
7916 unsigned char *toc_ref
;
7919 if (!bfd_link_executable (info
))
7922 htab
= ppc_hash_table (info
);
7926 /* Make two passes over the relocs. On the first pass, mark toc
7927 entries involved with tls relocs, and check that tls relocs
7928 involved in setting up a tls_get_addr call are indeed followed by
7929 such a call. If they are not, we can't do any tls optimization.
7930 On the second pass twiddle tls_mask flags to notify
7931 relocate_section that optimization can be done, and adjust got
7932 and plt refcounts. */
7934 for (pass
= 0; pass
< 2; ++pass
)
7935 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
7937 Elf_Internal_Sym
*locsyms
= NULL
;
7938 asection
*toc
= bfd_get_section_by_name (ibfd
, ".toc");
7940 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7941 if (sec
->has_tls_reloc
&& !bfd_is_abs_section (sec
->output_section
))
7943 Elf_Internal_Rela
*relstart
, *rel
, *relend
;
7944 bfd_boolean found_tls_get_addr_arg
= 0;
7946 /* Read the relocations. */
7947 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
7949 if (relstart
== NULL
)
7955 relend
= relstart
+ sec
->reloc_count
;
7956 for (rel
= relstart
; rel
< relend
; rel
++)
7958 enum elf_ppc64_reloc_type r_type
;
7959 unsigned long r_symndx
;
7960 struct elf_link_hash_entry
*h
;
7961 Elf_Internal_Sym
*sym
;
7963 unsigned char *tls_mask
;
7964 unsigned int tls_set
, tls_clear
, tls_type
= 0;
7966 bfd_boolean ok_tprel
, is_local
;
7967 long toc_ref_index
= 0;
7968 int expecting_tls_get_addr
= 0;
7969 bfd_boolean ret
= FALSE
;
7971 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7972 if (!get_sym_h (&h
, &sym
, &sym_sec
, &tls_mask
, &locsyms
,
7976 if (elf_section_data (sec
)->relocs
!= relstart
)
7978 if (toc_ref
!= NULL
)
7981 && (elf_symtab_hdr (ibfd
).contents
7982 != (unsigned char *) locsyms
))
7989 if (h
->root
.type
== bfd_link_hash_defined
7990 || h
->root
.type
== bfd_link_hash_defweak
)
7991 value
= h
->root
.u
.def
.value
;
7992 else if (h
->root
.type
== bfd_link_hash_undefweak
)
7996 found_tls_get_addr_arg
= 0;
8001 /* Symbols referenced by TLS relocs must be of type
8002 STT_TLS. So no need for .opd local sym adjust. */
8003 value
= sym
->st_value
;
8006 is_local
= SYMBOL_REFERENCES_LOCAL (info
, h
);
8010 && h
->root
.type
== bfd_link_hash_undefweak
)
8012 else if (sym_sec
!= NULL
8013 && sym_sec
->output_section
!= NULL
)
8015 value
+= sym_sec
->output_offset
;
8016 value
+= sym_sec
->output_section
->vma
;
8017 value
-= htab
->elf
.tls_sec
->vma
+ TP_OFFSET
;
8018 /* Note that even though the prefix insns
8019 allow a 1<<33 offset we use the same test
8020 as for addis;addi. There may be a mix of
8021 pcrel and non-pcrel code and the decision
8022 to optimise is per symbol, not per TLS
8024 ok_tprel
= value
+ 0x80008000ULL
< 1ULL << 32;
8028 r_type
= ELF64_R_TYPE (rel
->r_info
);
8029 /* If this section has old-style __tls_get_addr calls
8030 without marker relocs, then check that each
8031 __tls_get_addr call reloc is preceded by a reloc
8032 that conceivably belongs to the __tls_get_addr arg
8033 setup insn. If we don't find matching arg setup
8034 relocs, don't do any tls optimization. */
8036 && sec
->nomark_tls_get_addr
8038 && is_tls_get_addr (h
, htab
)
8039 && !found_tls_get_addr_arg
8040 && is_branch_reloc (r_type
))
8042 info
->callbacks
->minfo (_("%H __tls_get_addr lost arg, "
8043 "TLS optimization disabled\n"),
8044 ibfd
, sec
, rel
->r_offset
);
8049 found_tls_get_addr_arg
= 0;
8052 case R_PPC64_GOT_TLSLD16
:
8053 case R_PPC64_GOT_TLSLD16_LO
:
8054 case R_PPC64_GOT_TLSLD34
:
8055 expecting_tls_get_addr
= 1;
8056 found_tls_get_addr_arg
= 1;
8059 case R_PPC64_GOT_TLSLD16_HI
:
8060 case R_PPC64_GOT_TLSLD16_HA
:
8061 /* These relocs should never be against a symbol
8062 defined in a shared lib. Leave them alone if
8063 that turns out to be the case. */
8070 tls_type
= TLS_TLS
| TLS_LD
;
8073 case R_PPC64_GOT_TLSGD16
:
8074 case R_PPC64_GOT_TLSGD16_LO
:
8075 case R_PPC64_GOT_TLSGD34
:
8076 expecting_tls_get_addr
= 1;
8077 found_tls_get_addr_arg
= 1;
8080 case R_PPC64_GOT_TLSGD16_HI
:
8081 case R_PPC64_GOT_TLSGD16_HA
:
8087 tls_set
= TLS_TLS
| TLS_GDIE
;
8089 tls_type
= TLS_TLS
| TLS_GD
;
8092 case R_PPC64_GOT_TPREL34
:
8093 case R_PPC64_GOT_TPREL16_DS
:
8094 case R_PPC64_GOT_TPREL16_LO_DS
:
8095 case R_PPC64_GOT_TPREL16_HI
:
8096 case R_PPC64_GOT_TPREL16_HA
:
8101 tls_clear
= TLS_TPREL
;
8102 tls_type
= TLS_TLS
| TLS_TPREL
;
8112 if (rel
+ 1 < relend
8113 && is_plt_seq_reloc (ELF64_R_TYPE (rel
[1].r_info
)))
8116 && (ELF64_R_TYPE (rel
[1].r_info
)
8118 && (ELF64_R_TYPE (rel
[1].r_info
)
8119 != R_PPC64_PLTSEQ_NOTOC
))
8121 r_symndx
= ELF64_R_SYM (rel
[1].r_info
);
8122 if (!get_sym_h (&h
, NULL
, NULL
, NULL
, &locsyms
,
8127 struct plt_entry
*ent
= NULL
;
8129 for (ent
= h
->plt
.plist
;
8132 if (ent
->addend
== rel
[1].r_addend
)
8136 && ent
->plt
.refcount
> 0)
8137 ent
->plt
.refcount
-= 1;
8142 found_tls_get_addr_arg
= 1;
8147 case R_PPC64_TOC16_LO
:
8148 if (sym_sec
== NULL
|| sym_sec
!= toc
)
8151 /* Mark this toc entry as referenced by a TLS
8152 code sequence. We can do that now in the
8153 case of R_PPC64_TLS, and after checking for
8154 tls_get_addr for the TOC16 relocs. */
8155 if (toc_ref
== NULL
)
8157 = bfd_zmalloc (toc
->output_section
->rawsize
/ 8);
8158 if (toc_ref
== NULL
)
8162 value
= h
->root
.u
.def
.value
;
8164 value
= sym
->st_value
;
8165 value
+= rel
->r_addend
;
8168 BFD_ASSERT (value
< toc
->size
8169 && toc
->output_offset
% 8 == 0);
8170 toc_ref_index
= (value
+ toc
->output_offset
) / 8;
8171 if (r_type
== R_PPC64_TLS
8172 || r_type
== R_PPC64_TLSGD
8173 || r_type
== R_PPC64_TLSLD
)
8175 toc_ref
[toc_ref_index
] = 1;
8179 if (pass
!= 0 && toc_ref
[toc_ref_index
] == 0)
8184 expecting_tls_get_addr
= 2;
8187 case R_PPC64_TPREL64
:
8191 || !toc_ref
[(rel
->r_offset
+ toc
->output_offset
) / 8])
8196 tls_set
= TLS_EXPLICIT
;
8197 tls_clear
= TLS_TPREL
;
8202 case R_PPC64_DTPMOD64
:
8206 || !toc_ref
[(rel
->r_offset
+ toc
->output_offset
) / 8])
8208 if (rel
+ 1 < relend
8210 == ELF64_R_INFO (r_symndx
, R_PPC64_DTPREL64
))
8211 && rel
[1].r_offset
== rel
->r_offset
+ 8)
8215 tls_set
= TLS_EXPLICIT
| TLS_GD
;
8218 tls_set
= TLS_EXPLICIT
| TLS_GD
| TLS_GDIE
;
8227 tls_set
= TLS_EXPLICIT
;
8238 if (!expecting_tls_get_addr
8239 || !sec
->nomark_tls_get_addr
)
8242 if (rel
+ 1 < relend
8243 && branch_reloc_hash_match (ibfd
, rel
+ 1,
8244 htab
->tls_get_addr_fd
,
8249 if (expecting_tls_get_addr
== 2)
8251 /* Check for toc tls entries. */
8252 unsigned char *toc_tls
;
8255 retval
= get_tls_mask (&toc_tls
, NULL
, NULL
,
8260 if (toc_tls
!= NULL
)
8262 if ((*toc_tls
& TLS_TLS
) != 0
8263 && ((*toc_tls
& (TLS_GD
| TLS_LD
)) != 0))
8264 found_tls_get_addr_arg
= 1;
8266 toc_ref
[toc_ref_index
] = 1;
8272 /* Uh oh, we didn't find the expected call. We
8273 could just mark this symbol to exclude it
8274 from tls optimization but it's safer to skip
8275 the entire optimization. */
8276 /* xgettext:c-format */
8277 info
->callbacks
->minfo (_("%H arg lost __tls_get_addr, "
8278 "TLS optimization disabled\n"),
8279 ibfd
, sec
, rel
->r_offset
);
8284 /* If we don't have old-style __tls_get_addr calls
8285 without TLSGD/TLSLD marker relocs, and we haven't
8286 found a new-style __tls_get_addr call with a
8287 marker for this symbol, then we either have a
8288 broken object file or an -mlongcall style
8289 indirect call to __tls_get_addr without a marker.
8290 Disable optimization in this case. */
8291 if ((tls_clear
& (TLS_GD
| TLS_LD
)) != 0
8292 && (tls_set
& TLS_EXPLICIT
) == 0
8293 && !sec
->nomark_tls_get_addr
8294 && ((*tls_mask
& (TLS_TLS
| TLS_MARK
))
8295 != (TLS_TLS
| TLS_MARK
)))
8298 if (expecting_tls_get_addr
== 1 + !sec
->nomark_tls_get_addr
)
8300 struct plt_entry
*ent
= NULL
;
8302 if (htab
->tls_get_addr_fd
!= NULL
)
8303 for (ent
= htab
->tls_get_addr_fd
->elf
.plt
.plist
;
8306 if (ent
->addend
== 0)
8309 if (ent
== NULL
&& htab
->tga_desc_fd
!= NULL
)
8310 for (ent
= htab
->tga_desc_fd
->elf
.plt
.plist
;
8313 if (ent
->addend
== 0)
8316 if (ent
== NULL
&& htab
->tls_get_addr
!= NULL
)
8317 for (ent
= htab
->tls_get_addr
->elf
.plt
.plist
;
8320 if (ent
->addend
== 0)
8323 if (ent
== NULL
&& htab
->tga_desc
!= NULL
)
8324 for (ent
= htab
->tga_desc
->elf
.plt
.plist
;
8327 if (ent
->addend
== 0)
8331 && ent
->plt
.refcount
> 0)
8332 ent
->plt
.refcount
-= 1;
8338 if ((tls_set
& TLS_EXPLICIT
) == 0)
8340 struct got_entry
*ent
;
8342 /* Adjust got entry for this reloc. */
8346 ent
= elf_local_got_ents (ibfd
)[r_symndx
];
8348 for (; ent
!= NULL
; ent
= ent
->next
)
8349 if (ent
->addend
== rel
->r_addend
8350 && ent
->owner
== ibfd
8351 && ent
->tls_type
== tls_type
)
8358 /* We managed to get rid of a got entry. */
8359 if (ent
->got
.refcount
> 0)
8360 ent
->got
.refcount
-= 1;
8365 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8366 we'll lose one or two dyn relocs. */
8367 if (!dec_dynrel_count (rel
->r_info
, sec
, info
,
8371 if (tls_set
== (TLS_EXPLICIT
| TLS_GD
))
8373 if (!dec_dynrel_count ((rel
+ 1)->r_info
, sec
, info
,
8379 *tls_mask
|= tls_set
& 0xff;
8380 *tls_mask
&= ~tls_clear
;
8383 if (elf_section_data (sec
)->relocs
!= relstart
)
8388 && (elf_symtab_hdr (ibfd
).contents
!= (unsigned char *) locsyms
))
8390 if (!info
->keep_memory
)
8393 elf_symtab_hdr (ibfd
).contents
= (unsigned char *) locsyms
;
8397 if (toc_ref
!= NULL
)
8399 htab
->do_tls_opt
= 1;
8403 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8404 the values of any global symbols in a toc section that has been
8405 edited. Globals in toc sections should be a rarity, so this function
8406 sets a flag if any are found in toc sections other than the one just
8407 edited, so that further hash table traversals can be avoided. */
8409 struct adjust_toc_info
8412 unsigned long *skip
;
8413 bfd_boolean global_toc_syms
;
8416 enum toc_skip_enum
{ ref_from_discarded
= 1, can_optimize
= 2 };
8419 adjust_toc_syms (struct elf_link_hash_entry
*h
, void *inf
)
8421 struct ppc_link_hash_entry
*eh
;
8422 struct adjust_toc_info
*toc_inf
= (struct adjust_toc_info
*) inf
;
8425 if (h
->root
.type
!= bfd_link_hash_defined
8426 && h
->root
.type
!= bfd_link_hash_defweak
)
8429 eh
= ppc_elf_hash_entry (h
);
8430 if (eh
->adjust_done
)
8433 if (eh
->elf
.root
.u
.def
.section
== toc_inf
->toc
)
8435 if (eh
->elf
.root
.u
.def
.value
> toc_inf
->toc
->rawsize
)
8436 i
= toc_inf
->toc
->rawsize
>> 3;
8438 i
= eh
->elf
.root
.u
.def
.value
>> 3;
8440 if ((toc_inf
->skip
[i
] & (ref_from_discarded
| can_optimize
)) != 0)
8443 (_("%s defined on removed toc entry"), eh
->elf
.root
.root
.string
);
8446 while ((toc_inf
->skip
[i
] & (ref_from_discarded
| can_optimize
)) != 0);
8447 eh
->elf
.root
.u
.def
.value
= (bfd_vma
) i
<< 3;
8450 eh
->elf
.root
.u
.def
.value
-= toc_inf
->skip
[i
];
8451 eh
->adjust_done
= 1;
8453 else if (strcmp (eh
->elf
.root
.u
.def
.section
->name
, ".toc") == 0)
8454 toc_inf
->global_toc_syms
= TRUE
;
8459 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
8460 on a _LO variety toc/got reloc. */
8463 ok_lo_toc_insn (unsigned int insn
, enum elf_ppc64_reloc_type r_type
)
8465 return ((insn
& (0x3fu
<< 26)) == 12u << 26 /* addic */
8466 || (insn
& (0x3fu
<< 26)) == 14u << 26 /* addi */
8467 || (insn
& (0x3fu
<< 26)) == 32u << 26 /* lwz */
8468 || (insn
& (0x3fu
<< 26)) == 34u << 26 /* lbz */
8469 || (insn
& (0x3fu
<< 26)) == 36u << 26 /* stw */
8470 || (insn
& (0x3fu
<< 26)) == 38u << 26 /* stb */
8471 || (insn
& (0x3fu
<< 26)) == 40u << 26 /* lhz */
8472 || (insn
& (0x3fu
<< 26)) == 42u << 26 /* lha */
8473 || (insn
& (0x3fu
<< 26)) == 44u << 26 /* sth */
8474 || (insn
& (0x3fu
<< 26)) == 46u << 26 /* lmw */
8475 || (insn
& (0x3fu
<< 26)) == 47u << 26 /* stmw */
8476 || (insn
& (0x3fu
<< 26)) == 48u << 26 /* lfs */
8477 || (insn
& (0x3fu
<< 26)) == 50u << 26 /* lfd */
8478 || (insn
& (0x3fu
<< 26)) == 52u << 26 /* stfs */
8479 || (insn
& (0x3fu
<< 26)) == 54u << 26 /* stfd */
8480 || (insn
& (0x3fu
<< 26)) == 56u << 26 /* lq,lfq */
8481 || ((insn
& (0x3fu
<< 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
8482 /* Exclude lfqu by testing reloc. If relocs are ever
8483 defined for the reduced D field in psq_lu then those
8484 will need testing too. */
8485 && r_type
!= R_PPC64_TOC16_LO
&& r_type
!= R_PPC64_GOT16_LO
)
8486 || ((insn
& (0x3fu
<< 26)) == 58u << 26 /* ld,lwa */
8488 || (insn
& (0x3fu
<< 26)) == 60u << 26 /* stfq */
8489 || ((insn
& (0x3fu
<< 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
8490 /* Exclude stfqu. psq_stu as above for psq_lu. */
8491 && r_type
!= R_PPC64_TOC16_LO
&& r_type
!= R_PPC64_GOT16_LO
)
8492 || ((insn
& (0x3fu
<< 26)) == 62u << 26 /* std,stq */
8493 && (insn
& 1) == 0));
8496 /* PCREL_OPT in one instance flags to the linker that a pair of insns:
8497 pld ra,symbol@got@pcrel
8498 load/store rt,off(ra)
8501 load/store rt,off(ra)
8502 may be translated to
8503 pload/pstore rt,symbol+off@pcrel
8505 This function returns true if the optimization is possible, placing
8506 the prefix insn in *PINSN1, a NOP in *PINSN2 and the offset in *POFF.
8508 On entry to this function, the linker has already determined that
8509 the pld can be replaced with pla: *PINSN1 is that pla insn,
8510 while *PINSN2 is the second instruction. */
8513 xlate_pcrel_opt (uint64_t *pinsn1
, uint64_t *pinsn2
, bfd_signed_vma
*poff
)
8515 uint64_t insn1
= *pinsn1
;
8516 uint64_t insn2
= *pinsn2
;
8519 if ((insn2
& (63ULL << 58)) == 1ULL << 58)
8521 /* Check that regs match. */
8522 if (((insn2
>> 16) & 31) != ((insn1
>> 21) & 31))
8525 /* P8LS or PMLS form, non-pcrel. */
8526 if ((insn2
& (-1ULL << 50) & ~(1ULL << 56)) != (1ULL << 58))
8529 *pinsn1
= (insn2
& ~(31 << 16) & ~0x3ffff0000ffffULL
) | (1ULL << 52);
8531 off
= ((insn2
>> 16) & 0x3ffff0000ULL
) | (insn2
& 0xffff);
8532 *poff
= (off
^ 0x200000000ULL
) - 0x200000000ULL
;
8538 /* Check that regs match. */
8539 if (((insn2
>> 16) & 31) != ((insn1
>> 21) & 31))
8542 switch ((insn2
>> 26) & 63)
8558 /* These are the PMLS cases, where we just need to tack a prefix
8560 insn1
= ((1ULL << 58) | (2ULL << 56) | (1ULL << 52)
8561 | (insn2
& ((63ULL << 26) | (31ULL << 21))));
8562 off
= insn2
& 0xffff;
8565 case 58: /* lwa, ld */
8566 if ((insn2
& 1) != 0)
8568 insn1
= ((1ULL << 58) | (1ULL << 52)
8569 | (insn2
& 2 ? 41ULL << 26 : 57ULL << 26)
8570 | (insn2
& (31ULL << 21)));
8571 off
= insn2
& 0xfffc;
8574 case 57: /* lxsd, lxssp */
8575 if ((insn2
& 3) < 2)
8577 insn1
= ((1ULL << 58) | (1ULL << 52)
8578 | ((40ULL | (insn2
& 3)) << 26)
8579 | (insn2
& (31ULL << 21)));
8580 off
= insn2
& 0xfffc;
8583 case 61: /* stxsd, stxssp, lxv, stxv */
8584 if ((insn2
& 3) == 0)
8586 else if ((insn2
& 3) >= 2)
8588 insn1
= ((1ULL << 58) | (1ULL << 52)
8589 | ((44ULL | (insn2
& 3)) << 26)
8590 | (insn2
& (31ULL << 21)));
8591 off
= insn2
& 0xfffc;
8595 insn1
= ((1ULL << 58) | (1ULL << 52)
8596 | ((50ULL | (insn2
& 4) | ((insn2
& 8) >> 3)) << 26)
8597 | (insn2
& (31ULL << 21)));
8598 off
= insn2
& 0xfff0;
8603 insn1
= ((1ULL << 58) | (1ULL << 52)
8604 | (insn2
& ((63ULL << 26) | (31ULL << 21))));
8605 off
= insn2
& 0xffff;
8608 case 6: /* lxvp, stxvp */
8609 if ((insn2
& 0xe) != 0)
8611 insn1
= ((1ULL << 58) | (1ULL << 52)
8612 | ((insn2
& 1) == 0 ? 58ULL << 26 : 62ULL << 26)
8613 | (insn2
& (31ULL << 21)));
8614 off
= insn2
& 0xfff0;
8617 case 62: /* std, stq */
8618 if ((insn2
& 1) != 0)
8620 insn1
= ((1ULL << 58) | (1ULL << 52)
8621 | ((insn2
& 2) == 0 ? 61ULL << 26 : 60ULL << 26)
8622 | (insn2
& (31ULL << 21)));
8623 off
= insn2
& 0xfffc;
8628 *pinsn2
= (uint64_t) NOP
<< 32;
8629 *poff
= (off
^ 0x8000) - 0x8000;
8633 /* Examine all relocs referencing .toc sections in order to remove
8634 unused .toc entries. */
8637 ppc64_elf_edit_toc (struct bfd_link_info
*info
)
8640 struct adjust_toc_info toc_inf
;
8641 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
8643 htab
->do_toc_opt
= 1;
8644 toc_inf
.global_toc_syms
= TRUE
;
8645 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
8647 asection
*toc
, *sec
;
8648 Elf_Internal_Shdr
*symtab_hdr
;
8649 Elf_Internal_Sym
*local_syms
;
8650 Elf_Internal_Rela
*relstart
, *rel
, *toc_relocs
;
8651 unsigned long *skip
, *drop
;
8652 unsigned char *used
;
8653 unsigned char *keep
, last
, some_unused
;
8655 if (!is_ppc64_elf (ibfd
))
8658 toc
= bfd_get_section_by_name (ibfd
, ".toc");
8661 || toc
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
8662 || discarded_section (toc
))
8667 symtab_hdr
= &elf_symtab_hdr (ibfd
);
8669 /* Look at sections dropped from the final link. */
8672 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
8674 if (sec
->reloc_count
== 0
8675 || !discarded_section (sec
)
8676 || get_opd_info (sec
)
8677 || (sec
->flags
& SEC_ALLOC
) == 0
8678 || (sec
->flags
& SEC_DEBUGGING
) != 0)
8681 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
, FALSE
);
8682 if (relstart
== NULL
)
8685 /* Run through the relocs to see which toc entries might be
8687 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
8689 enum elf_ppc64_reloc_type r_type
;
8690 unsigned long r_symndx
;
8692 struct elf_link_hash_entry
*h
;
8693 Elf_Internal_Sym
*sym
;
8696 r_type
= ELF64_R_TYPE (rel
->r_info
);
8703 case R_PPC64_TOC16_LO
:
8704 case R_PPC64_TOC16_HI
:
8705 case R_PPC64_TOC16_HA
:
8706 case R_PPC64_TOC16_DS
:
8707 case R_PPC64_TOC16_LO_DS
:
8711 r_symndx
= ELF64_R_SYM (rel
->r_info
);
8712 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
8720 val
= h
->root
.u
.def
.value
;
8722 val
= sym
->st_value
;
8723 val
+= rel
->r_addend
;
8725 if (val
>= toc
->size
)
8728 /* Anything in the toc ought to be aligned to 8 bytes.
8729 If not, don't mark as unused. */
8735 skip
= bfd_zmalloc (sizeof (*skip
) * (toc
->size
+ 15) / 8);
8740 skip
[val
>> 3] = ref_from_discarded
;
8743 if (elf_section_data (sec
)->relocs
!= relstart
)
8747 /* For largetoc loads of address constants, we can convert
8748 . addis rx,2,addr@got@ha
8749 . ld ry,addr@got@l(rx)
8751 . addis rx,2,addr@toc@ha
8752 . addi ry,rx,addr@toc@l
8753 when addr is within 2G of the toc pointer. This then means
8754 that the word storing "addr" in the toc is no longer needed. */
8756 if (!ppc64_elf_tdata (ibfd
)->has_small_toc_reloc
8757 && toc
->output_section
->rawsize
< (bfd_vma
) 1 << 31
8758 && toc
->reloc_count
!= 0)
8760 /* Read toc relocs. */
8761 toc_relocs
= _bfd_elf_link_read_relocs (ibfd
, toc
, NULL
, NULL
,
8763 if (toc_relocs
== NULL
)
8766 for (rel
= toc_relocs
; rel
< toc_relocs
+ toc
->reloc_count
; ++rel
)
8768 enum elf_ppc64_reloc_type r_type
;
8769 unsigned long r_symndx
;
8771 struct elf_link_hash_entry
*h
;
8772 Elf_Internal_Sym
*sym
;
8775 r_type
= ELF64_R_TYPE (rel
->r_info
);
8776 if (r_type
!= R_PPC64_ADDR64
)
8779 r_symndx
= ELF64_R_SYM (rel
->r_info
);
8780 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
8785 || sym_sec
->output_section
== NULL
8786 || discarded_section (sym_sec
))
8789 if (!SYMBOL_REFERENCES_LOCAL (info
, h
))
8794 if (h
->type
== STT_GNU_IFUNC
)
8796 val
= h
->root
.u
.def
.value
;
8800 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
8802 val
= sym
->st_value
;
8804 val
+= rel
->r_addend
;
8805 val
+= sym_sec
->output_section
->vma
+ sym_sec
->output_offset
;
8807 /* We don't yet know the exact toc pointer value, but we
8808 know it will be somewhere in the toc section. Don't
8809 optimize if the difference from any possible toc
8810 pointer is outside [ff..f80008000, 7fff7fff]. */
8811 addr
= toc
->output_section
->vma
+ TOC_BASE_OFF
;
8812 if (val
- addr
+ (bfd_vma
) 0x80008000 >= (bfd_vma
) 1 << 32)
8815 addr
= toc
->output_section
->vma
+ toc
->output_section
->rawsize
;
8816 if (val
- addr
+ (bfd_vma
) 0x80008000 >= (bfd_vma
) 1 << 32)
8821 skip
= bfd_zmalloc (sizeof (*skip
) * (toc
->size
+ 15) / 8);
8826 skip
[rel
->r_offset
>> 3]
8827 |= can_optimize
| ((rel
- toc_relocs
) << 2);
8834 used
= bfd_zmalloc (sizeof (*used
) * (toc
->size
+ 7) / 8);
8838 if (local_syms
!= NULL
8839 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
8843 && elf_section_data (sec
)->relocs
!= relstart
)
8845 if (toc_relocs
!= NULL
8846 && elf_section_data (toc
)->relocs
!= toc_relocs
)
8853 /* Now check all kept sections that might reference the toc.
8854 Check the toc itself last. */
8855 for (sec
= (ibfd
->sections
== toc
&& toc
->next
? toc
->next
8858 sec
= (sec
== toc
? NULL
8859 : sec
->next
== NULL
? toc
8860 : sec
->next
== toc
&& toc
->next
? toc
->next
8865 if (sec
->reloc_count
== 0
8866 || discarded_section (sec
)
8867 || get_opd_info (sec
)
8868 || (sec
->flags
& SEC_ALLOC
) == 0
8869 || (sec
->flags
& SEC_DEBUGGING
) != 0)
8872 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
8874 if (relstart
== NULL
)
8880 /* Mark toc entries referenced as used. */
8884 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
8886 enum elf_ppc64_reloc_type r_type
;
8887 unsigned long r_symndx
;
8889 struct elf_link_hash_entry
*h
;
8890 Elf_Internal_Sym
*sym
;
8893 r_type
= ELF64_R_TYPE (rel
->r_info
);
8897 case R_PPC64_TOC16_LO
:
8898 case R_PPC64_TOC16_HI
:
8899 case R_PPC64_TOC16_HA
:
8900 case R_PPC64_TOC16_DS
:
8901 case R_PPC64_TOC16_LO_DS
:
8902 /* In case we're taking addresses of toc entries. */
8903 case R_PPC64_ADDR64
:
8910 r_symndx
= ELF64_R_SYM (rel
->r_info
);
8911 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
8922 val
= h
->root
.u
.def
.value
;
8924 val
= sym
->st_value
;
8925 val
+= rel
->r_addend
;
8927 if (val
>= toc
->size
)
8930 if ((skip
[val
>> 3] & can_optimize
) != 0)
8937 case R_PPC64_TOC16_HA
:
8940 case R_PPC64_TOC16_LO_DS
:
8941 off
= rel
->r_offset
;
8942 off
+= (bfd_big_endian (ibfd
) ? -2 : 3);
8943 if (!bfd_get_section_contents (ibfd
, sec
, &opc
,
8949 if ((opc
& (0x3f << 2)) == (58u << 2))
8954 /* Wrong sort of reloc, or not a ld. We may
8955 as well clear ref_from_discarded too. */
8962 /* For the toc section, we only mark as used if this
8963 entry itself isn't unused. */
8964 else if ((used
[rel
->r_offset
>> 3]
8965 || !(skip
[rel
->r_offset
>> 3] & ref_from_discarded
))
8968 /* Do all the relocs again, to catch reference
8977 if (elf_section_data (sec
)->relocs
!= relstart
)
8981 /* Merge the used and skip arrays. Assume that TOC
8982 doublewords not appearing as either used or unused belong
8983 to an entry more than one doubleword in size. */
8984 for (drop
= skip
, keep
= used
, last
= 0, some_unused
= 0;
8985 drop
< skip
+ (toc
->size
+ 7) / 8;
8990 *drop
&= ~ref_from_discarded
;
8991 if ((*drop
& can_optimize
) != 0)
8995 else if ((*drop
& ref_from_discarded
) != 0)
8998 last
= ref_from_discarded
;
9008 bfd_byte
*contents
, *src
;
9010 Elf_Internal_Sym
*sym
;
9011 bfd_boolean local_toc_syms
= FALSE
;
9013 /* Shuffle the toc contents, and at the same time convert the
9014 skip array from booleans into offsets. */
9015 if (!bfd_malloc_and_get_section (ibfd
, toc
, &contents
))
9018 elf_section_data (toc
)->this_hdr
.contents
= contents
;
9020 for (src
= contents
, off
= 0, drop
= skip
;
9021 src
< contents
+ toc
->size
;
9024 if ((*drop
& (can_optimize
| ref_from_discarded
)) != 0)
9029 memcpy (src
- off
, src
, 8);
9033 toc
->rawsize
= toc
->size
;
9034 toc
->size
= src
- contents
- off
;
9036 /* Adjust addends for relocs against the toc section sym,
9037 and optimize any accesses we can. */
9038 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
9040 if (sec
->reloc_count
== 0
9041 || discarded_section (sec
))
9044 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
9046 if (relstart
== NULL
)
9049 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
9051 enum elf_ppc64_reloc_type r_type
;
9052 unsigned long r_symndx
;
9054 struct elf_link_hash_entry
*h
;
9057 r_type
= ELF64_R_TYPE (rel
->r_info
);
9064 case R_PPC64_TOC16_LO
:
9065 case R_PPC64_TOC16_HI
:
9066 case R_PPC64_TOC16_HA
:
9067 case R_PPC64_TOC16_DS
:
9068 case R_PPC64_TOC16_LO_DS
:
9069 case R_PPC64_ADDR64
:
9073 r_symndx
= ELF64_R_SYM (rel
->r_info
);
9074 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
9082 val
= h
->root
.u
.def
.value
;
9085 val
= sym
->st_value
;
9087 local_toc_syms
= TRUE
;
9090 val
+= rel
->r_addend
;
9092 if (val
> toc
->rawsize
)
9094 else if ((skip
[val
>> 3] & ref_from_discarded
) != 0)
9096 else if ((skip
[val
>> 3] & can_optimize
) != 0)
9098 Elf_Internal_Rela
*tocrel
9099 = toc_relocs
+ (skip
[val
>> 3] >> 2);
9100 unsigned long tsym
= ELF64_R_SYM (tocrel
->r_info
);
9104 case R_PPC64_TOC16_HA
:
9105 rel
->r_info
= ELF64_R_INFO (tsym
, R_PPC64_TOC16_HA
);
9108 case R_PPC64_TOC16_LO_DS
:
9109 rel
->r_info
= ELF64_R_INFO (tsym
, R_PPC64_LO_DS_OPT
);
9113 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
9115 info
->callbacks
->einfo
9116 /* xgettext:c-format */
9117 (_("%H: %s references "
9118 "optimized away TOC entry\n"),
9119 ibfd
, sec
, rel
->r_offset
,
9120 ppc64_elf_howto_table
[r_type
]->name
);
9121 bfd_set_error (bfd_error_bad_value
);
9124 rel
->r_addend
= tocrel
->r_addend
;
9125 elf_section_data (sec
)->relocs
= relstart
;
9129 if (h
!= NULL
|| sym
->st_value
!= 0)
9132 rel
->r_addend
-= skip
[val
>> 3];
9133 elf_section_data (sec
)->relocs
= relstart
;
9136 if (elf_section_data (sec
)->relocs
!= relstart
)
9140 /* We shouldn't have local or global symbols defined in the TOC,
9141 but handle them anyway. */
9142 if (local_syms
!= NULL
)
9143 for (sym
= local_syms
;
9144 sym
< local_syms
+ symtab_hdr
->sh_info
;
9146 if (sym
->st_value
!= 0
9147 && bfd_section_from_elf_index (ibfd
, sym
->st_shndx
) == toc
)
9151 if (sym
->st_value
> toc
->rawsize
)
9152 i
= toc
->rawsize
>> 3;
9154 i
= sym
->st_value
>> 3;
9156 if ((skip
[i
] & (ref_from_discarded
| can_optimize
)) != 0)
9160 (_("%s defined on removed toc entry"),
9161 bfd_elf_sym_name (ibfd
, symtab_hdr
, sym
, NULL
));
9164 while ((skip
[i
] & (ref_from_discarded
| can_optimize
)));
9165 sym
->st_value
= (bfd_vma
) i
<< 3;
9168 sym
->st_value
-= skip
[i
];
9169 symtab_hdr
->contents
= (unsigned char *) local_syms
;
9172 /* Adjust any global syms defined in this toc input section. */
9173 if (toc_inf
.global_toc_syms
)
9176 toc_inf
.skip
= skip
;
9177 toc_inf
.global_toc_syms
= FALSE
;
9178 elf_link_hash_traverse (elf_hash_table (info
), adjust_toc_syms
,
9182 if (toc
->reloc_count
!= 0)
9184 Elf_Internal_Shdr
*rel_hdr
;
9185 Elf_Internal_Rela
*wrel
;
9188 /* Remove unused toc relocs, and adjust those we keep. */
9189 if (toc_relocs
== NULL
)
9190 toc_relocs
= _bfd_elf_link_read_relocs (ibfd
, toc
, NULL
, NULL
,
9192 if (toc_relocs
== NULL
)
9196 for (rel
= toc_relocs
; rel
< toc_relocs
+ toc
->reloc_count
; ++rel
)
9197 if ((skip
[rel
->r_offset
>> 3]
9198 & (ref_from_discarded
| can_optimize
)) == 0)
9200 wrel
->r_offset
= rel
->r_offset
- skip
[rel
->r_offset
>> 3];
9201 wrel
->r_info
= rel
->r_info
;
9202 wrel
->r_addend
= rel
->r_addend
;
9205 else if (!dec_dynrel_count (rel
->r_info
, toc
, info
,
9206 &local_syms
, NULL
, NULL
))
9209 elf_section_data (toc
)->relocs
= toc_relocs
;
9210 toc
->reloc_count
= wrel
- toc_relocs
;
9211 rel_hdr
= _bfd_elf_single_rel_hdr (toc
);
9212 sz
= rel_hdr
->sh_entsize
;
9213 rel_hdr
->sh_size
= toc
->reloc_count
* sz
;
9216 else if (toc_relocs
!= NULL
9217 && elf_section_data (toc
)->relocs
!= toc_relocs
)
9220 if (local_syms
!= NULL
9221 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
9223 if (!info
->keep_memory
)
9226 symtab_hdr
->contents
= (unsigned char *) local_syms
;
9231 /* Look for cases where we can change an indirect GOT access to
9232 a GOT relative or PC relative access, possibly reducing the
9233 number of GOT entries. */
9234 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
9237 Elf_Internal_Shdr
*symtab_hdr
;
9238 Elf_Internal_Sym
*local_syms
;
9239 Elf_Internal_Rela
*relstart
, *rel
;
9242 if (!is_ppc64_elf (ibfd
))
9245 if (!ppc64_elf_tdata (ibfd
)->has_optrel
)
9248 sec
= ppc64_elf_tdata (ibfd
)->got
;
9251 got
= sec
->output_section
->vma
+ sec
->output_offset
+ 0x8000;
9254 symtab_hdr
= &elf_symtab_hdr (ibfd
);
9256 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
9258 if (sec
->reloc_count
== 0
9259 || !ppc64_elf_section_data (sec
)->has_optrel
9260 || discarded_section (sec
))
9263 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
9265 if (relstart
== NULL
)
9268 if (local_syms
!= NULL
9269 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
9273 && elf_section_data (sec
)->relocs
!= relstart
)
9278 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
9280 enum elf_ppc64_reloc_type r_type
;
9281 unsigned long r_symndx
;
9282 Elf_Internal_Sym
*sym
;
9284 struct elf_link_hash_entry
*h
;
9285 struct got_entry
*ent
;
9287 unsigned char buf
[8];
9289 enum {no_check
, check_lo
, check_ha
} insn_check
;
9291 r_type
= ELF64_R_TYPE (rel
->r_info
);
9295 insn_check
= no_check
;
9298 case R_PPC64_PLT16_HA
:
9299 case R_PPC64_GOT_TLSLD16_HA
:
9300 case R_PPC64_GOT_TLSGD16_HA
:
9301 case R_PPC64_GOT_TPREL16_HA
:
9302 case R_PPC64_GOT_DTPREL16_HA
:
9303 case R_PPC64_GOT16_HA
:
9304 case R_PPC64_TOC16_HA
:
9305 insn_check
= check_ha
;
9308 case R_PPC64_PLT16_LO
:
9309 case R_PPC64_PLT16_LO_DS
:
9310 case R_PPC64_GOT_TLSLD16_LO
:
9311 case R_PPC64_GOT_TLSGD16_LO
:
9312 case R_PPC64_GOT_TPREL16_LO_DS
:
9313 case R_PPC64_GOT_DTPREL16_LO_DS
:
9314 case R_PPC64_GOT16_LO
:
9315 case R_PPC64_GOT16_LO_DS
:
9316 case R_PPC64_TOC16_LO
:
9317 case R_PPC64_TOC16_LO_DS
:
9318 insn_check
= check_lo
;
9322 if (insn_check
!= no_check
)
9324 bfd_vma off
= rel
->r_offset
& ~3;
9326 if (!bfd_get_section_contents (ibfd
, sec
, buf
, off
, 4))
9329 insn
= bfd_get_32 (ibfd
, buf
);
9330 if (insn_check
== check_lo
9331 ? !ok_lo_toc_insn (insn
, r_type
)
9332 : ((insn
& ((0x3fu
<< 26) | 0x1f << 16))
9333 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9337 ppc64_elf_tdata (ibfd
)->unexpected_toc_insn
= 1;
9338 sprintf (str
, "%#08x", insn
);
9339 info
->callbacks
->einfo
9340 /* xgettext:c-format */
9341 (_("%H: got/toc optimization is not supported for"
9342 " %s instruction\n"),
9343 ibfd
, sec
, rel
->r_offset
& ~3, str
);
9350 /* Note that we don't delete GOT entries for
9351 R_PPC64_GOT16_DS since we'd need a lot more
9352 analysis. For starters, the preliminary layout is
9353 before the GOT, PLT, dynamic sections and stubs are
9354 laid out. Then we'd need to allow for changes in
9355 distance between sections caused by alignment. */
9359 case R_PPC64_GOT16_HA
:
9360 case R_PPC64_GOT16_LO_DS
:
9361 case R_PPC64_GOT_PCREL34
:
9365 r_symndx
= ELF64_R_SYM (rel
->r_info
);
9366 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
9371 || sym_sec
->output_section
== NULL
9372 || discarded_section (sym_sec
))
9375 if ((h
? h
->type
: ELF_ST_TYPE (sym
->st_info
)) == STT_GNU_IFUNC
)
9378 if (!SYMBOL_REFERENCES_LOCAL (info
, h
))
9382 val
= h
->root
.u
.def
.value
;
9384 val
= sym
->st_value
;
9385 val
+= rel
->r_addend
;
9386 val
+= sym_sec
->output_section
->vma
+ sym_sec
->output_offset
;
9388 /* Fudge factor to allow for the fact that the preliminary layout
9389 isn't exact. Reduce limits by this factor. */
9390 #define LIMIT_ADJUST(LIMIT) ((LIMIT) - (LIMIT) / 16)
9397 case R_PPC64_GOT16_HA
:
9398 if (val
- got
+ LIMIT_ADJUST (0x80008000ULL
)
9399 >= LIMIT_ADJUST (0x100000000ULL
))
9402 if (!bfd_get_section_contents (ibfd
, sec
, buf
,
9403 rel
->r_offset
& ~3, 4))
9405 insn
= bfd_get_32 (ibfd
, buf
);
9406 if (((insn
& ((0x3fu
<< 26) | 0x1f << 16))
9407 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9411 case R_PPC64_GOT16_LO_DS
:
9412 if (val
- got
+ LIMIT_ADJUST (0x80008000ULL
)
9413 >= LIMIT_ADJUST (0x100000000ULL
))
9415 if (!bfd_get_section_contents (ibfd
, sec
, buf
,
9416 rel
->r_offset
& ~3, 4))
9418 insn
= bfd_get_32 (ibfd
, buf
);
9419 if ((insn
& (0x3fu
<< 26 | 0x3)) != 58u << 26 /* ld */)
9423 case R_PPC64_GOT_PCREL34
:
9425 pc
+= sec
->output_section
->vma
+ sec
->output_offset
;
9426 if (val
- pc
+ LIMIT_ADJUST (1ULL << 33)
9427 >= LIMIT_ADJUST (1ULL << 34))
9429 if (!bfd_get_section_contents (ibfd
, sec
, buf
,
9430 rel
->r_offset
& ~3, 8))
9432 insn
= bfd_get_32 (ibfd
, buf
);
9433 if ((insn
& (-1u << 18)) != ((1u << 26) | (1u << 20)))
9435 insn
= bfd_get_32 (ibfd
, buf
+ 4);
9436 if ((insn
& (0x3fu
<< 26)) != 57u << 26)
9446 struct got_entry
**local_got_ents
= elf_local_got_ents (ibfd
);
9447 ent
= local_got_ents
[r_symndx
];
9449 for (; ent
!= NULL
; ent
= ent
->next
)
9450 if (ent
->addend
== rel
->r_addend
9451 && ent
->owner
== ibfd
9452 && ent
->tls_type
== 0)
9454 BFD_ASSERT (ent
&& ent
->got
.refcount
> 0);
9455 ent
->got
.refcount
-= 1;
9458 if (elf_section_data (sec
)->relocs
!= relstart
)
9462 if (local_syms
!= NULL
9463 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
9465 if (!info
->keep_memory
)
9468 symtab_hdr
->contents
= (unsigned char *) local_syms
;
9475 /* Return true iff input section I references the TOC using
9476 instructions limited to +/-32k offsets. */
9479 ppc64_elf_has_small_toc_reloc (asection
*i
)
9481 return (is_ppc64_elf (i
->owner
)
9482 && ppc64_elf_tdata (i
->owner
)->has_small_toc_reloc
);
9485 /* Allocate space for one GOT entry. */
9488 allocate_got (struct elf_link_hash_entry
*h
,
9489 struct bfd_link_info
*info
,
9490 struct got_entry
*gent
)
9492 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
9493 struct ppc_link_hash_entry
*eh
= ppc_elf_hash_entry (h
);
9494 int entsize
= (gent
->tls_type
& eh
->tls_mask
& (TLS_GD
| TLS_LD
)
9496 int rentsize
= (gent
->tls_type
& eh
->tls_mask
& TLS_GD
9497 ? 2 : 1) * sizeof (Elf64_External_Rela
);
9498 asection
*got
= ppc64_elf_tdata (gent
->owner
)->got
;
9500 gent
->got
.offset
= got
->size
;
9501 got
->size
+= entsize
;
9503 if (h
->type
== STT_GNU_IFUNC
)
9505 htab
->elf
.irelplt
->size
+= rentsize
;
9506 htab
->got_reli_size
+= rentsize
;
9508 else if (((bfd_link_pic (info
)
9509 && !(gent
->tls_type
!= 0
9510 && bfd_link_executable (info
)
9511 && SYMBOL_REFERENCES_LOCAL (info
, h
)))
9512 || (htab
->elf
.dynamic_sections_created
9514 && !SYMBOL_REFERENCES_LOCAL (info
, h
)))
9515 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
9517 asection
*relgot
= ppc64_elf_tdata (gent
->owner
)->relgot
;
9518 relgot
->size
+= rentsize
;
9522 /* This function merges got entries in the same toc group. */
9525 merge_got_entries (struct got_entry
**pent
)
9527 struct got_entry
*ent
, *ent2
;
9529 for (ent
= *pent
; ent
!= NULL
; ent
= ent
->next
)
9530 if (!ent
->is_indirect
)
9531 for (ent2
= ent
->next
; ent2
!= NULL
; ent2
= ent2
->next
)
9532 if (!ent2
->is_indirect
9533 && ent2
->addend
== ent
->addend
9534 && ent2
->tls_type
== ent
->tls_type
9535 && elf_gp (ent2
->owner
) == elf_gp (ent
->owner
))
9537 ent2
->is_indirect
= TRUE
;
9538 ent2
->got
.ent
= ent
;
9542 /* If H is undefined, make it dynamic if that makes sense. */
9545 ensure_undef_dynamic (struct bfd_link_info
*info
,
9546 struct elf_link_hash_entry
*h
)
9548 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
9550 if (htab
->dynamic_sections_created
9551 && ((info
->dynamic_undefined_weak
!= 0
9552 && h
->root
.type
== bfd_link_hash_undefweak
)
9553 || h
->root
.type
== bfd_link_hash_undefined
)
9556 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
9557 return bfd_elf_link_record_dynamic_symbol (info
, h
);
9561 /* Allocate space in .plt, .got and associated reloc sections for
9565 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
9567 struct bfd_link_info
*info
;
9568 struct ppc_link_hash_table
*htab
;
9570 struct ppc_link_hash_entry
*eh
;
9571 struct got_entry
**pgent
, *gent
;
9573 if (h
->root
.type
== bfd_link_hash_indirect
)
9576 info
= (struct bfd_link_info
*) inf
;
9577 htab
= ppc_hash_table (info
);
9581 eh
= ppc_elf_hash_entry (h
);
9582 /* Run through the TLS GD got entries first if we're changing them
9584 if ((eh
->tls_mask
& (TLS_TLS
| TLS_GDIE
)) == (TLS_TLS
| TLS_GDIE
))
9585 for (gent
= h
->got
.glist
; gent
!= NULL
; gent
= gent
->next
)
9586 if (gent
->got
.refcount
> 0
9587 && (gent
->tls_type
& TLS_GD
) != 0)
9589 /* This was a GD entry that has been converted to TPREL. If
9590 there happens to be a TPREL entry we can use that one. */
9591 struct got_entry
*ent
;
9592 for (ent
= h
->got
.glist
; ent
!= NULL
; ent
= ent
->next
)
9593 if (ent
->got
.refcount
> 0
9594 && (ent
->tls_type
& TLS_TPREL
) != 0
9595 && ent
->addend
== gent
->addend
9596 && ent
->owner
== gent
->owner
)
9598 gent
->got
.refcount
= 0;
9602 /* If not, then we'll be using our own TPREL entry. */
9603 if (gent
->got
.refcount
!= 0)
9604 gent
->tls_type
= TLS_TLS
| TLS_TPREL
;
9607 /* Remove any list entry that won't generate a word in the GOT before
9608 we call merge_got_entries. Otherwise we risk merging to empty
9610 pgent
= &h
->got
.glist
;
9611 while ((gent
= *pgent
) != NULL
)
9612 if (gent
->got
.refcount
> 0)
9614 if ((gent
->tls_type
& TLS_LD
) != 0
9615 && SYMBOL_REFERENCES_LOCAL (info
, h
))
9617 ppc64_tlsld_got (gent
->owner
)->got
.refcount
+= 1;
9618 *pgent
= gent
->next
;
9621 pgent
= &gent
->next
;
9624 *pgent
= gent
->next
;
9626 if (!htab
->do_multi_toc
)
9627 merge_got_entries (&h
->got
.glist
);
9629 for (gent
= h
->got
.glist
; gent
!= NULL
; gent
= gent
->next
)
9630 if (!gent
->is_indirect
)
9632 /* Ensure we catch all the cases where this symbol should
9634 if (!ensure_undef_dynamic (info
, h
))
9637 if (!is_ppc64_elf (gent
->owner
))
9640 allocate_got (h
, info
, gent
);
9643 /* If no dynamic sections we can't have dynamic relocs, except for
9644 IFUNCs which are handled even in static executables. */
9645 if (!htab
->elf
.dynamic_sections_created
9646 && h
->type
!= STT_GNU_IFUNC
)
9647 eh
->dyn_relocs
= NULL
;
9649 /* Discard relocs on undefined symbols that must be local. */
9650 else if (h
->root
.type
== bfd_link_hash_undefined
9651 && ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
9652 eh
->dyn_relocs
= NULL
;
9654 /* Also discard relocs on undefined weak syms with non-default
9655 visibility, or when dynamic_undefined_weak says so. */
9656 else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
9657 eh
->dyn_relocs
= NULL
;
9659 if (eh
->dyn_relocs
!= NULL
)
9661 struct elf_dyn_relocs
*p
, **pp
;
9663 /* In the shared -Bsymbolic case, discard space allocated for
9664 dynamic pc-relative relocs against symbols which turn out to
9665 be defined in regular objects. For the normal shared case,
9666 discard space for relocs that have become local due to symbol
9667 visibility changes. */
9668 if (bfd_link_pic (info
))
9670 /* Relocs that use pc_count are those that appear on a call
9671 insn, or certain REL relocs (see must_be_dyn_reloc) that
9672 can be generated via assembly. We want calls to
9673 protected symbols to resolve directly to the function
9674 rather than going via the plt. If people want function
9675 pointer comparisons to work as expected then they should
9676 avoid writing weird assembly. */
9677 if (SYMBOL_CALLS_LOCAL (info
, h
))
9679 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
9681 p
->count
-= p
->pc_count
;
9690 if (eh
->dyn_relocs
!= NULL
)
9692 /* Ensure we catch all the cases where this symbol
9693 should be made dynamic. */
9694 if (!ensure_undef_dynamic (info
, h
))
9699 /* For a fixed position executable, discard space for
9700 relocs against symbols which are not dynamic. */
9701 else if (h
->type
!= STT_GNU_IFUNC
)
9703 if (h
->dynamic_adjusted
9705 && !ELF_COMMON_DEF_P (h
))
9707 /* Ensure we catch all the cases where this symbol
9708 should be made dynamic. */
9709 if (!ensure_undef_dynamic (info
, h
))
9712 /* But if that didn't work out, discard dynamic relocs. */
9713 if (h
->dynindx
== -1)
9714 eh
->dyn_relocs
= NULL
;
9717 eh
->dyn_relocs
= NULL
;
9720 /* Finally, allocate space. */
9721 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
9723 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
9724 if (eh
->elf
.type
== STT_GNU_IFUNC
)
9725 sreloc
= htab
->elf
.irelplt
;
9726 sreloc
->size
+= p
->count
* sizeof (Elf64_External_Rela
);
9730 /* We might need a PLT entry when the symbol
9733 c) has plt16 relocs and has been processed by adjust_dynamic_symbol, or
9734 d) has plt16 relocs and we are linking statically. */
9735 if ((htab
->elf
.dynamic_sections_created
&& h
->dynindx
!= -1)
9736 || h
->type
== STT_GNU_IFUNC
9737 || (h
->needs_plt
&& h
->dynamic_adjusted
)
9740 && !htab
->elf
.dynamic_sections_created
9741 && !htab
->can_convert_all_inline_plt
9742 && (ppc_elf_hash_entry (h
)->tls_mask
9743 & (TLS_TLS
| PLT_KEEP
)) == PLT_KEEP
))
9745 struct plt_entry
*pent
;
9746 bfd_boolean doneone
= FALSE
;
9747 for (pent
= h
->plt
.plist
; pent
!= NULL
; pent
= pent
->next
)
9748 if (pent
->plt
.refcount
> 0)
9750 if (!htab
->elf
.dynamic_sections_created
9751 || h
->dynindx
== -1)
9753 if (h
->type
== STT_GNU_IFUNC
)
9756 pent
->plt
.offset
= s
->size
;
9757 s
->size
+= PLT_ENTRY_SIZE (htab
);
9758 s
= htab
->elf
.irelplt
;
9763 pent
->plt
.offset
= s
->size
;
9764 s
->size
+= LOCAL_PLT_ENTRY_SIZE (htab
);
9765 s
= bfd_link_pic (info
) ? htab
->relpltlocal
: NULL
;
9770 /* If this is the first .plt entry, make room for the special
9774 s
->size
+= PLT_INITIAL_ENTRY_SIZE (htab
);
9776 pent
->plt
.offset
= s
->size
;
9778 /* Make room for this entry. */
9779 s
->size
+= PLT_ENTRY_SIZE (htab
);
9781 /* Make room for the .glink code. */
9784 s
->size
+= GLINK_PLTRESOLVE_SIZE (htab
);
9787 /* We need bigger stubs past index 32767. */
9788 if (s
->size
>= GLINK_PLTRESOLVE_SIZE (htab
) + 32768*2*4)
9795 /* We also need to make an entry in the .rela.plt section. */
9796 s
= htab
->elf
.srelplt
;
9799 s
->size
+= sizeof (Elf64_External_Rela
);
9803 pent
->plt
.offset
= (bfd_vma
) -1;
9806 h
->plt
.plist
= NULL
;
9812 h
->plt
.plist
= NULL
;
9819 #define PPC_LO(v) ((v) & 0xffff)
9820 #define PPC_HI(v) (((v) >> 16) & 0xffff)
9821 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
9823 ((((v) & 0x3ffff0000ULL) << 16) | (v & 0xffff))
9824 #define HA34(v) ((v + (1ULL << 33)) >> 34)
9826 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9827 to set up space for global entry stubs. These are put in glink,
9828 after the branch table. */
9831 size_global_entry_stubs (struct elf_link_hash_entry
*h
, void *inf
)
9833 struct bfd_link_info
*info
;
9834 struct ppc_link_hash_table
*htab
;
9835 struct plt_entry
*pent
;
9838 if (h
->root
.type
== bfd_link_hash_indirect
)
9841 if (!h
->pointer_equality_needed
)
9848 htab
= ppc_hash_table (info
);
9852 s
= htab
->global_entry
;
9853 plt
= htab
->elf
.splt
;
9854 for (pent
= h
->plt
.plist
; pent
!= NULL
; pent
= pent
->next
)
9855 if (pent
->plt
.offset
!= (bfd_vma
) -1
9856 && pent
->addend
== 0)
9858 /* For ELFv2, if this symbol is not defined in a regular file
9859 and we are not generating a shared library or pie, then we
9860 need to define the symbol in the executable on a call stub.
9861 This is to avoid text relocations. */
9862 bfd_vma off
, stub_align
, stub_off
, stub_size
;
9863 unsigned int align_power
;
9867 if (htab
->params
->plt_stub_align
>= 0)
9868 align_power
= htab
->params
->plt_stub_align
;
9870 align_power
= -htab
->params
->plt_stub_align
;
9871 /* Setting section alignment is delayed until we know it is
9872 non-empty. Otherwise the .text output section will be
9873 aligned at least to plt_stub_align even when no global
9874 entry stubs are needed. */
9875 if (s
->alignment_power
< align_power
)
9876 s
->alignment_power
= align_power
;
9877 stub_align
= (bfd_vma
) 1 << align_power
;
9878 if (htab
->params
->plt_stub_align
>= 0
9879 || ((((stub_off
+ stub_size
- 1) & -stub_align
)
9880 - (stub_off
& -stub_align
))
9881 > ((stub_size
- 1) & -stub_align
)))
9882 stub_off
= (stub_off
+ stub_align
- 1) & -stub_align
;
9883 off
= pent
->plt
.offset
+ plt
->output_offset
+ plt
->output_section
->vma
;
9884 off
-= stub_off
+ s
->output_offset
+ s
->output_section
->vma
;
9885 /* Note that for --plt-stub-align negative we have a possible
9886 dependency between stub offset and size. Break that
9887 dependency by assuming the max stub size when calculating
9889 if (PPC_HA (off
) == 0)
9891 h
->root
.type
= bfd_link_hash_defined
;
9892 h
->root
.u
.def
.section
= s
;
9893 h
->root
.u
.def
.value
= stub_off
;
9894 s
->size
= stub_off
+ stub_size
;
9900 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9901 read-only sections. */
9904 maybe_set_textrel (struct elf_link_hash_entry
*h
, void *inf
)
9908 if (h
->root
.type
== bfd_link_hash_indirect
)
9911 sec
= readonly_dynrelocs (h
);
9914 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
9916 info
->flags
|= DF_TEXTREL
;
9917 info
->callbacks
->minfo (_("%pB: dynamic relocation against `%pT'"
9918 " in read-only section `%pA'\n"),
9919 sec
->owner
, h
->root
.root
.string
, sec
);
9921 /* Not an error, just cut short the traversal. */
9927 /* Set the sizes of the dynamic sections. */
9930 ppc64_elf_size_dynamic_sections (bfd
*output_bfd
,
9931 struct bfd_link_info
*info
)
9933 struct ppc_link_hash_table
*htab
;
9938 struct got_entry
*first_tlsld
;
9940 htab
= ppc_hash_table (info
);
9944 dynobj
= htab
->elf
.dynobj
;
9948 if (htab
->elf
.dynamic_sections_created
)
9950 /* Set the contents of the .interp section to the interpreter. */
9951 if (bfd_link_executable (info
) && !info
->nointerp
)
9953 s
= bfd_get_linker_section (dynobj
, ".interp");
9956 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
9957 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
9961 /* Set up .got offsets for local syms, and space for local dynamic
9963 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
9965 struct got_entry
**lgot_ents
;
9966 struct got_entry
**end_lgot_ents
;
9967 struct plt_entry
**local_plt
;
9968 struct plt_entry
**end_local_plt
;
9969 unsigned char *lgot_masks
;
9970 bfd_size_type locsymcount
;
9971 Elf_Internal_Shdr
*symtab_hdr
;
9973 if (!is_ppc64_elf (ibfd
))
9976 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
9978 struct ppc_dyn_relocs
*p
;
9980 for (p
= elf_section_data (s
)->local_dynrel
; p
!= NULL
; p
= p
->next
)
9982 if (!bfd_is_abs_section (p
->sec
)
9983 && bfd_is_abs_section (p
->sec
->output_section
))
9985 /* Input section has been discarded, either because
9986 it is a copy of a linkonce section or due to
9987 linker script /DISCARD/, so we'll be discarding
9990 else if (p
->count
!= 0)
9992 asection
*srel
= elf_section_data (p
->sec
)->sreloc
;
9994 srel
= htab
->elf
.irelplt
;
9995 srel
->size
+= p
->count
* sizeof (Elf64_External_Rela
);
9996 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
9997 info
->flags
|= DF_TEXTREL
;
10002 lgot_ents
= elf_local_got_ents (ibfd
);
10006 symtab_hdr
= &elf_symtab_hdr (ibfd
);
10007 locsymcount
= symtab_hdr
->sh_info
;
10008 end_lgot_ents
= lgot_ents
+ locsymcount
;
10009 local_plt
= (struct plt_entry
**) end_lgot_ents
;
10010 end_local_plt
= local_plt
+ locsymcount
;
10011 lgot_masks
= (unsigned char *) end_local_plt
;
10012 s
= ppc64_elf_tdata (ibfd
)->got
;
10013 for (; lgot_ents
< end_lgot_ents
; ++lgot_ents
, ++lgot_masks
)
10015 struct got_entry
**pent
, *ent
;
10018 while ((ent
= *pent
) != NULL
)
10019 if (ent
->got
.refcount
> 0)
10021 if ((ent
->tls_type
& *lgot_masks
& TLS_LD
) != 0)
10023 ppc64_tlsld_got (ibfd
)->got
.refcount
+= 1;
10028 unsigned int ent_size
= 8;
10029 unsigned int rel_size
= sizeof (Elf64_External_Rela
);
10031 ent
->got
.offset
= s
->size
;
10032 if ((ent
->tls_type
& *lgot_masks
& TLS_GD
) != 0)
10037 s
->size
+= ent_size
;
10038 if ((*lgot_masks
& (TLS_TLS
| PLT_IFUNC
)) == PLT_IFUNC
)
10040 htab
->elf
.irelplt
->size
+= rel_size
;
10041 htab
->got_reli_size
+= rel_size
;
10043 else if (bfd_link_pic (info
)
10044 && !(ent
->tls_type
!= 0
10045 && bfd_link_executable (info
)))
10047 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
10048 srel
->size
+= rel_size
;
10057 /* Allocate space for plt calls to local syms. */
10058 lgot_masks
= (unsigned char *) end_local_plt
;
10059 for (; local_plt
< end_local_plt
; ++local_plt
, ++lgot_masks
)
10061 struct plt_entry
*ent
;
10063 for (ent
= *local_plt
; ent
!= NULL
; ent
= ent
->next
)
10064 if (ent
->plt
.refcount
> 0)
10066 if ((*lgot_masks
& (TLS_TLS
| PLT_IFUNC
)) == PLT_IFUNC
)
10068 s
= htab
->elf
.iplt
;
10069 ent
->plt
.offset
= s
->size
;
10070 s
->size
+= PLT_ENTRY_SIZE (htab
);
10071 htab
->elf
.irelplt
->size
+= sizeof (Elf64_External_Rela
);
10073 else if (htab
->can_convert_all_inline_plt
10074 || (*lgot_masks
& (TLS_TLS
| PLT_KEEP
)) != PLT_KEEP
)
10075 ent
->plt
.offset
= (bfd_vma
) -1;
10078 s
= htab
->pltlocal
;
10079 ent
->plt
.offset
= s
->size
;
10080 s
->size
+= LOCAL_PLT_ENTRY_SIZE (htab
);
10081 if (bfd_link_pic (info
))
10082 htab
->relpltlocal
->size
+= sizeof (Elf64_External_Rela
);
10086 ent
->plt
.offset
= (bfd_vma
) -1;
10090 /* Allocate global sym .plt and .got entries, and space for global
10091 sym dynamic relocs. */
10092 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, info
);
10094 if (!htab
->opd_abi
&& !bfd_link_pic (info
))
10095 elf_link_hash_traverse (&htab
->elf
, size_global_entry_stubs
, info
);
10097 first_tlsld
= NULL
;
10098 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
10100 struct got_entry
*ent
;
10102 if (!is_ppc64_elf (ibfd
))
10105 ent
= ppc64_tlsld_got (ibfd
);
10106 if (ent
->got
.refcount
> 0)
10108 if (!htab
->do_multi_toc
&& first_tlsld
!= NULL
)
10110 ent
->is_indirect
= TRUE
;
10111 ent
->got
.ent
= first_tlsld
;
10115 if (first_tlsld
== NULL
)
10117 s
= ppc64_elf_tdata (ibfd
)->got
;
10118 ent
->got
.offset
= s
->size
;
10121 if (bfd_link_dll (info
))
10123 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
10124 srel
->size
+= sizeof (Elf64_External_Rela
);
10129 ent
->got
.offset
= (bfd_vma
) -1;
10132 /* We now have determined the sizes of the various dynamic sections.
10133 Allocate memory for them. */
10135 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
10137 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
10140 if (s
== htab
->brlt
|| s
== htab
->relbrlt
)
10141 /* These haven't been allocated yet; don't strip. */
10143 else if (s
== htab
->elf
.sgot
10144 || s
== htab
->elf
.splt
10145 || s
== htab
->elf
.iplt
10146 || s
== htab
->pltlocal
10147 || s
== htab
->glink
10148 || s
== htab
->global_entry
10149 || s
== htab
->elf
.sdynbss
10150 || s
== htab
->elf
.sdynrelro
)
10152 /* Strip this section if we don't need it; see the
10155 else if (s
== htab
->glink_eh_frame
)
10157 if (!bfd_is_abs_section (s
->output_section
))
10158 /* Not sized yet. */
10161 else if (CONST_STRNEQ (s
->name
, ".rela"))
10165 if (s
!= htab
->elf
.srelplt
)
10168 /* We use the reloc_count field as a counter if we need
10169 to copy relocs into the output file. */
10170 s
->reloc_count
= 0;
10175 /* It's not one of our sections, so don't allocate space. */
10181 /* If we don't need this section, strip it from the
10182 output file. This is mostly to handle .rela.bss and
10183 .rela.plt. We must create both sections in
10184 create_dynamic_sections, because they must be created
10185 before the linker maps input sections to output
10186 sections. The linker does that before
10187 adjust_dynamic_symbol is called, and it is that
10188 function which decides whether anything needs to go
10189 into these sections. */
10190 s
->flags
|= SEC_EXCLUDE
;
10194 if (bfd_is_abs_section (s
->output_section
))
10195 _bfd_error_handler (_("warning: discarding dynamic section %s"),
10198 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
10201 /* Allocate memory for the section contents. We use bfd_zalloc
10202 here in case unused entries are not reclaimed before the
10203 section's contents are written out. This should not happen,
10204 but this way if it does we get a R_PPC64_NONE reloc in .rela
10205 sections instead of garbage.
10206 We also rely on the section contents being zero when writing
10207 the GOT and .dynrelro. */
10208 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
10209 if (s
->contents
== NULL
)
10213 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
10215 if (!is_ppc64_elf (ibfd
))
10218 s
= ppc64_elf_tdata (ibfd
)->got
;
10219 if (s
!= NULL
&& s
!= htab
->elf
.sgot
)
10222 s
->flags
|= SEC_EXCLUDE
;
10225 s
->contents
= bfd_zalloc (ibfd
, s
->size
);
10226 if (s
->contents
== NULL
)
10230 s
= ppc64_elf_tdata (ibfd
)->relgot
;
10234 s
->flags
|= SEC_EXCLUDE
;
10237 s
->contents
= bfd_zalloc (ibfd
, s
->size
);
10238 if (s
->contents
== NULL
)
10241 s
->reloc_count
= 0;
10246 if (htab
->elf
.dynamic_sections_created
)
10248 bfd_boolean tls_opt
;
10250 /* Add some entries to the .dynamic section. We fill in the
10251 values later, in ppc64_elf_finish_dynamic_sections, but we
10252 must add the entries now so that we get the correct size for
10253 the .dynamic section. The DT_DEBUG entry is filled in by the
10254 dynamic linker and used by the debugger. */
10255 #define add_dynamic_entry(TAG, VAL) \
10256 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10258 if (bfd_link_executable (info
))
10260 if (!add_dynamic_entry (DT_DEBUG
, 0))
10264 if (htab
->elf
.splt
!= NULL
&& htab
->elf
.splt
->size
!= 0)
10266 if (!add_dynamic_entry (DT_PLTGOT
, 0)
10267 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
10268 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
10269 || !add_dynamic_entry (DT_JMPREL
, 0)
10270 || !add_dynamic_entry (DT_PPC64_GLINK
, 0))
10274 if (NO_OPD_RELOCS
&& abiversion (output_bfd
) <= 1)
10276 if (!add_dynamic_entry (DT_PPC64_OPD
, 0)
10277 || !add_dynamic_entry (DT_PPC64_OPDSZ
, 0))
10281 tls_opt
= (htab
->params
->tls_get_addr_opt
10282 && ((htab
->tls_get_addr_fd
!= NULL
10283 && htab
->tls_get_addr_fd
->elf
.plt
.plist
!= NULL
)
10284 || (htab
->tga_desc_fd
!= NULL
10285 && htab
->tga_desc_fd
->elf
.plt
.plist
!= NULL
)));
10286 if (tls_opt
|| !htab
->opd_abi
)
10288 if (!add_dynamic_entry (DT_PPC64_OPT
, tls_opt
? PPC64_OPT_TLS
: 0))
10294 if (!add_dynamic_entry (DT_RELA
, 0)
10295 || !add_dynamic_entry (DT_RELASZ
, 0)
10296 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf64_External_Rela
)))
10299 /* If any dynamic relocs apply to a read-only section,
10300 then we need a DT_TEXTREL entry. */
10301 if ((info
->flags
& DF_TEXTREL
) == 0)
10302 elf_link_hash_traverse (&htab
->elf
, maybe_set_textrel
, info
);
10304 if ((info
->flags
& DF_TEXTREL
) != 0)
10306 if (!add_dynamic_entry (DT_TEXTREL
, 0))
10311 #undef add_dynamic_entry
10316 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
10319 ppc64_elf_hash_symbol (struct elf_link_hash_entry
*h
)
10321 if (h
->plt
.plist
!= NULL
10323 && !h
->pointer_equality_needed
)
10326 return _bfd_elf_hash_symbol (h
);
10329 /* Determine the type of stub needed, if any, for a call. */
10331 static inline enum ppc_stub_type
10332 ppc_type_of_stub (asection
*input_sec
,
10333 const Elf_Internal_Rela
*rel
,
10334 struct ppc_link_hash_entry
**hash
,
10335 struct plt_entry
**plt_ent
,
10336 bfd_vma destination
,
10337 unsigned long local_off
)
10339 struct ppc_link_hash_entry
*h
= *hash
;
10341 bfd_vma branch_offset
;
10342 bfd_vma max_branch_offset
;
10343 enum elf_ppc64_reloc_type r_type
;
10347 struct plt_entry
*ent
;
10348 struct ppc_link_hash_entry
*fdh
= h
;
10350 && h
->oh
->is_func_descriptor
)
10352 fdh
= ppc_follow_link (h
->oh
);
10356 for (ent
= fdh
->elf
.plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
10357 if (ent
->addend
== rel
->r_addend
10358 && ent
->plt
.offset
!= (bfd_vma
) -1)
10361 return ppc_stub_plt_call
;
10364 /* Here, we know we don't have a plt entry. If we don't have a
10365 either a defined function descriptor or a defined entry symbol
10366 in a regular object file, then it is pointless trying to make
10367 any other type of stub. */
10368 if (!is_static_defined (&fdh
->elf
)
10369 && !is_static_defined (&h
->elf
))
10370 return ppc_stub_none
;
10372 else if (elf_local_got_ents (input_sec
->owner
) != NULL
)
10374 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (input_sec
->owner
);
10375 struct plt_entry
**local_plt
= (struct plt_entry
**)
10376 elf_local_got_ents (input_sec
->owner
) + symtab_hdr
->sh_info
;
10377 unsigned long r_symndx
= ELF64_R_SYM (rel
->r_info
);
10379 if (local_plt
[r_symndx
] != NULL
)
10381 struct plt_entry
*ent
;
10383 for (ent
= local_plt
[r_symndx
]; ent
!= NULL
; ent
= ent
->next
)
10384 if (ent
->addend
== rel
->r_addend
10385 && ent
->plt
.offset
!= (bfd_vma
) -1)
10388 return ppc_stub_plt_call
;
10393 /* Determine where the call point is. */
10394 location
= (input_sec
->output_offset
10395 + input_sec
->output_section
->vma
10398 branch_offset
= destination
- location
;
10399 r_type
= ELF64_R_TYPE (rel
->r_info
);
10401 /* Determine if a long branch stub is needed. */
10402 max_branch_offset
= 1 << 25;
10403 if (r_type
== R_PPC64_REL14
10404 || r_type
== R_PPC64_REL14_BRTAKEN
10405 || r_type
== R_PPC64_REL14_BRNTAKEN
)
10406 max_branch_offset
= 1 << 15;
10408 if (branch_offset
+ max_branch_offset
>= 2 * max_branch_offset
- local_off
)
10409 /* We need a stub. Figure out whether a long_branch or plt_branch
10410 is needed later. */
10411 return ppc_stub_long_branch
;
10413 return ppc_stub_none
;
10416 /* Gets the address of a label (1:) in r11 and builds an offset in r12,
10417 then adds it to r11 (LOAD false) or loads r12 from r11+r12 (LOAD true).
10422 . lis %r12,xxx-1b@highest
10423 . ori %r12,%r12,xxx-1b@higher
10424 . sldi %r12,%r12,32
10425 . oris %r12,%r12,xxx-1b@high
10426 . ori %r12,%r12,xxx-1b@l
10427 . add/ldx %r12,%r11,%r12 */
10430 build_offset (bfd
*abfd
, bfd_byte
*p
, bfd_vma off
, bfd_boolean load
)
10432 bfd_put_32 (abfd
, MFLR_R12
, p
);
10434 bfd_put_32 (abfd
, BCL_20_31
, p
);
10436 bfd_put_32 (abfd
, MFLR_R11
, p
);
10438 bfd_put_32 (abfd
, MTLR_R12
, p
);
10440 if (off
+ 0x8000 < 0x10000)
10443 bfd_put_32 (abfd
, LD_R12_0R11
+ PPC_LO (off
), p
);
10445 bfd_put_32 (abfd
, ADDI_R12_R11
+ PPC_LO (off
), p
);
10448 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10450 bfd_put_32 (abfd
, ADDIS_R12_R11
+ PPC_HA (off
), p
);
10453 bfd_put_32 (abfd
, LD_R12_0R12
+ PPC_LO (off
), p
);
10455 bfd_put_32 (abfd
, ADDI_R12_R12
+ PPC_LO (off
), p
);
10460 if (off
+ 0x800000000000ULL
< 0x1000000000000ULL
)
10462 bfd_put_32 (abfd
, LI_R12_0
+ ((off
>> 32) & 0xffff), p
);
10467 bfd_put_32 (abfd
, LIS_R12
+ ((off
>> 48) & 0xffff), p
);
10469 if (((off
>> 32) & 0xffff) != 0)
10471 bfd_put_32 (abfd
, ORI_R12_R12_0
+ ((off
>> 32) & 0xffff), p
);
10475 if (((off
>> 32) & 0xffffffffULL
) != 0)
10477 bfd_put_32 (abfd
, SLDI_R12_R12_32
, p
);
10480 if (PPC_HI (off
) != 0)
10482 bfd_put_32 (abfd
, ORIS_R12_R12_0
+ PPC_HI (off
), p
);
10485 if (PPC_LO (off
) != 0)
10487 bfd_put_32 (abfd
, ORI_R12_R12_0
+ PPC_LO (off
), p
);
10491 bfd_put_32 (abfd
, LDX_R12_R11_R12
, p
);
10493 bfd_put_32 (abfd
, ADD_R12_R11_R12
, p
);
10499 static unsigned int
10500 size_offset (bfd_vma off
)
10503 if (off
+ 0x8000 < 0x10000)
10505 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10509 if (off
+ 0x800000000000ULL
< 0x1000000000000ULL
)
10514 if (((off
>> 32) & 0xffff) != 0)
10517 if (((off
>> 32) & 0xffffffffULL
) != 0)
10519 if (PPC_HI (off
) != 0)
10521 if (PPC_LO (off
) != 0)
10528 static unsigned int
10529 num_relocs_for_offset (bfd_vma off
)
10531 unsigned int num_rel
;
10532 if (off
+ 0x8000 < 0x10000)
10534 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10539 if (off
+ 0x800000000000ULL
>= 0x1000000000000ULL
10540 && ((off
>> 32) & 0xffff) != 0)
10542 if (PPC_HI (off
) != 0)
10544 if (PPC_LO (off
) != 0)
10550 static Elf_Internal_Rela
*
10551 emit_relocs_for_offset (struct bfd_link_info
*info
, Elf_Internal_Rela
*r
,
10552 bfd_vma roff
, bfd_vma targ
, bfd_vma off
)
10554 bfd_vma relative_targ
= targ
- (roff
- 8);
10555 if (bfd_big_endian (info
->output_bfd
))
10557 r
->r_offset
= roff
;
10558 r
->r_addend
= relative_targ
+ roff
;
10559 if (off
+ 0x8000 < 0x10000)
10560 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16
);
10561 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10563 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HA
);
10566 r
->r_offset
= roff
;
10567 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_LO
);
10568 r
->r_addend
= relative_targ
+ roff
;
10572 if (off
+ 0x800000000000ULL
< 0x1000000000000ULL
)
10573 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHER
);
10576 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHEST
);
10577 if (((off
>> 32) & 0xffff) != 0)
10581 r
->r_offset
= roff
;
10582 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHER
);
10583 r
->r_addend
= relative_targ
+ roff
;
10586 if (((off
>> 32) & 0xffffffffULL
) != 0)
10588 if (PPC_HI (off
) != 0)
10592 r
->r_offset
= roff
;
10593 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGH
);
10594 r
->r_addend
= relative_targ
+ roff
;
10596 if (PPC_LO (off
) != 0)
10600 r
->r_offset
= roff
;
10601 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_LO
);
10602 r
->r_addend
= relative_targ
+ roff
;
10609 build_power10_offset (bfd
*abfd
, bfd_byte
*p
, bfd_vma off
, int odd
,
10613 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10618 bfd_put_32 (abfd
, NOP
, p
);
10624 insn
= PADDI_R12_PC
;
10626 bfd_put_32 (abfd
, insn
>> 32, p
);
10628 bfd_put_32 (abfd
, insn
, p
);
10630 /* The minimum value for paddi is -0x200000000. The minimum value
10631 for li is -0x8000, which when shifted by 34 and added gives a
10632 minimum value of -0x2000200000000. The maximum value is
10633 0x1ffffffff+0x7fff<<34 which is 0x2000200000000-1. */
10634 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10637 bfd_put_32 (abfd
, LI_R11_0
| (HA34 (off
) & 0xffff), p
);
10641 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10644 insn
= PADDI_R12_PC
| D34 (off
);
10645 bfd_put_32 (abfd
, insn
>> 32, p
);
10647 bfd_put_32 (abfd
, insn
, p
);
10651 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10655 bfd_put_32 (abfd
, LDX_R12_R11_R12
, p
);
10657 bfd_put_32 (abfd
, ADD_R12_R11_R12
, p
);
10662 bfd_put_32 (abfd
, LIS_R11
| ((HA34 (off
) >> 16) & 0x3fff), p
);
10664 bfd_put_32 (abfd
, ORI_R11_R11_0
| (HA34 (off
) & 0xffff), p
);
10668 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10671 insn
= PADDI_R12_PC
| D34 (off
);
10672 bfd_put_32 (abfd
, insn
>> 32, p
);
10674 bfd_put_32 (abfd
, insn
, p
);
10678 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10682 bfd_put_32 (abfd
, LDX_R12_R11_R12
, p
);
10684 bfd_put_32 (abfd
, ADD_R12_R11_R12
, p
);
10690 static unsigned int
10691 size_power10_offset (bfd_vma off
, int odd
)
10693 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10695 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10701 static unsigned int
10702 num_relocs_for_power10_offset (bfd_vma off
, int odd
)
10704 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10706 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10712 static Elf_Internal_Rela
*
10713 emit_relocs_for_power10_offset (struct bfd_link_info
*info
,
10714 Elf_Internal_Rela
*r
, bfd_vma roff
,
10715 bfd_vma targ
, bfd_vma off
, int odd
)
10717 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10719 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10721 int d_offset
= bfd_big_endian (info
->output_bfd
) ? 2 : 0;
10722 r
->r_offset
= roff
+ d_offset
;
10723 r
->r_addend
= targ
+ 8 - odd
- d_offset
;
10724 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHERA34
);
10730 int d_offset
= bfd_big_endian (info
->output_bfd
) ? 2 : 0;
10731 r
->r_offset
= roff
+ d_offset
;
10732 r
->r_addend
= targ
+ 8 + odd
- d_offset
;
10733 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHESTA34
);
10736 r
->r_offset
= roff
+ d_offset
;
10737 r
->r_addend
= targ
+ 4 + odd
- d_offset
;
10738 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHERA34
);
10742 r
->r_offset
= roff
;
10743 r
->r_addend
= targ
;
10744 r
->r_info
= ELF64_R_INFO (0, R_PPC64_PCREL34
);
10748 /* Emit .eh_frame opcode to advance pc by DELTA. */
10751 eh_advance (bfd
*abfd
, bfd_byte
*eh
, unsigned int delta
)
10755 *eh
++ = DW_CFA_advance_loc
+ delta
;
10756 else if (delta
< 256)
10758 *eh
++ = DW_CFA_advance_loc1
;
10761 else if (delta
< 65536)
10763 *eh
++ = DW_CFA_advance_loc2
;
10764 bfd_put_16 (abfd
, delta
, eh
);
10769 *eh
++ = DW_CFA_advance_loc4
;
10770 bfd_put_32 (abfd
, delta
, eh
);
10776 /* Size of required .eh_frame opcode to advance pc by DELTA. */
10778 static unsigned int
10779 eh_advance_size (unsigned int delta
)
10781 if (delta
< 64 * 4)
10782 /* DW_CFA_advance_loc+[1..63]. */
10784 if (delta
< 256 * 4)
10785 /* DW_CFA_advance_loc1, byte. */
10787 if (delta
< 65536 * 4)
10788 /* DW_CFA_advance_loc2, 2 bytes. */
10790 /* DW_CFA_advance_loc4, 4 bytes. */
10794 /* With power7 weakly ordered memory model, it is possible for ld.so
10795 to update a plt entry in one thread and have another thread see a
10796 stale zero toc entry. To avoid this we need some sort of acquire
10797 barrier in the call stub. One solution is to make the load of the
10798 toc word seem to appear to depend on the load of the function entry
10799 word. Another solution is to test for r2 being zero, and branch to
10800 the appropriate glink entry if so.
10802 . fake dep barrier compare
10803 . ld 12,xxx(2) ld 12,xxx(2)
10804 . mtctr 12 mtctr 12
10805 . xor 11,12,12 ld 2,xxx+8(2)
10806 . add 2,2,11 cmpldi 2,0
10807 . ld 2,xxx+8(2) bnectr+
10808 . bctr b <glink_entry>
10810 The solution involving the compare turns out to be faster, so
10811 that's what we use unless the branch won't reach. */
10813 #define ALWAYS_USE_FAKE_DEP 0
10814 #define ALWAYS_EMIT_R2SAVE 0
10816 static inline unsigned int
10817 plt_stub_size (struct ppc_link_hash_table
*htab
,
10818 struct ppc_stub_hash_entry
*stub_entry
,
10823 if (stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
)
10825 if (htab
->power10_stubs
)
10827 bfd_vma start
= (stub_entry
->stub_offset
10828 + stub_entry
->group
->stub_sec
->output_offset
10829 + stub_entry
->group
->stub_sec
->output_section
->vma
);
10830 if (stub_entry
->stub_type
> ppc_stub_plt_call_notoc
)
10832 size
= 8 + size_power10_offset (off
, start
& 4);
10835 size
= 8 + size_offset (off
- 8);
10836 if (stub_entry
->stub_type
> ppc_stub_plt_call_notoc
)
10842 if (ALWAYS_EMIT_R2SAVE
10843 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10845 if (PPC_HA (off
) != 0)
10850 if (htab
->params
->plt_static_chain
)
10852 if (htab
->params
->plt_thread_safe
10853 && htab
->elf
.dynamic_sections_created
10854 && stub_entry
->h
!= NULL
10855 && stub_entry
->h
->elf
.dynindx
!= -1)
10857 if (PPC_HA (off
+ 8 + 8 * htab
->params
->plt_static_chain
) != PPC_HA (off
))
10860 if (stub_entry
->h
!= NULL
10861 && is_tls_get_addr (&stub_entry
->h
->elf
, htab
)
10862 && htab
->params
->tls_get_addr_opt
)
10864 if (htab
->params
->no_tls_get_addr_regsave
)
10867 if (stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10873 if (stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10880 /* Depending on the sign of plt_stub_align:
10881 If positive, return the padding to align to a 2**plt_stub_align
10883 If negative, if this stub would cross fewer 2**plt_stub_align
10884 boundaries if we align, then return the padding needed to do so. */
10886 static inline unsigned int
10887 plt_stub_pad (struct ppc_link_hash_table
*htab
,
10888 struct ppc_stub_hash_entry
*stub_entry
,
10892 unsigned stub_size
;
10893 bfd_vma stub_off
= stub_entry
->group
->stub_sec
->size
;
10895 if (htab
->params
->plt_stub_align
>= 0)
10897 stub_align
= 1 << htab
->params
->plt_stub_align
;
10898 if ((stub_off
& (stub_align
- 1)) != 0)
10899 return stub_align
- (stub_off
& (stub_align
- 1));
10903 stub_align
= 1 << -htab
->params
->plt_stub_align
;
10904 stub_size
= plt_stub_size (htab
, stub_entry
, plt_off
);
10905 if (((stub_off
+ stub_size
- 1) & -stub_align
) - (stub_off
& -stub_align
)
10906 > ((stub_size
- 1) & -stub_align
))
10907 return stub_align
- (stub_off
& (stub_align
- 1));
10911 /* Build a .plt call stub. */
10913 static inline bfd_byte
*
10914 build_plt_stub (struct ppc_link_hash_table
*htab
,
10915 struct ppc_stub_hash_entry
*stub_entry
,
10916 bfd_byte
*p
, bfd_vma offset
, Elf_Internal_Rela
*r
)
10918 bfd
*obfd
= htab
->params
->stub_bfd
;
10919 bfd_boolean plt_load_toc
= htab
->opd_abi
;
10920 bfd_boolean plt_static_chain
= htab
->params
->plt_static_chain
;
10921 bfd_boolean plt_thread_safe
= (htab
->params
->plt_thread_safe
10922 && htab
->elf
.dynamic_sections_created
10923 && stub_entry
->h
!= NULL
10924 && stub_entry
->h
->elf
.dynindx
!= -1);
10925 bfd_boolean use_fake_dep
= plt_thread_safe
;
10926 bfd_vma cmp_branch_off
= 0;
10928 if (!ALWAYS_USE_FAKE_DEP
10931 && !(is_tls_get_addr (&stub_entry
->h
->elf
, htab
)
10932 && htab
->params
->tls_get_addr_opt
))
10934 bfd_vma pltoff
= stub_entry
->plt_ent
->plt
.offset
& ~1;
10935 bfd_vma pltindex
= ((pltoff
- PLT_INITIAL_ENTRY_SIZE (htab
))
10936 / PLT_ENTRY_SIZE (htab
));
10937 bfd_vma glinkoff
= GLINK_PLTRESOLVE_SIZE (htab
) + pltindex
* 8;
10940 if (pltindex
> 32768)
10941 glinkoff
+= (pltindex
- 32768) * 4;
10943 + htab
->glink
->output_offset
10944 + htab
->glink
->output_section
->vma
);
10945 from
= (p
- stub_entry
->group
->stub_sec
->contents
10946 + 4 * (ALWAYS_EMIT_R2SAVE
10947 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10948 + 4 * (PPC_HA (offset
) != 0)
10949 + 4 * (PPC_HA (offset
+ 8 + 8 * plt_static_chain
)
10950 != PPC_HA (offset
))
10951 + 4 * (plt_static_chain
!= 0)
10953 + stub_entry
->group
->stub_sec
->output_offset
10954 + stub_entry
->group
->stub_sec
->output_section
->vma
);
10955 cmp_branch_off
= to
- from
;
10956 use_fake_dep
= cmp_branch_off
+ (1 << 25) >= (1 << 26);
10959 if (PPC_HA (offset
) != 0)
10963 if (ALWAYS_EMIT_R2SAVE
10964 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10965 r
[0].r_offset
+= 4;
10966 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_HA
);
10967 r
[1].r_offset
= r
[0].r_offset
+ 4;
10968 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
10969 r
[1].r_addend
= r
[0].r_addend
;
10972 if (PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
10974 r
[2].r_offset
= r
[1].r_offset
+ 4;
10975 r
[2].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO
);
10976 r
[2].r_addend
= r
[0].r_addend
;
10980 r
[2].r_offset
= r
[1].r_offset
+ 8 + 8 * use_fake_dep
;
10981 r
[2].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
10982 r
[2].r_addend
= r
[0].r_addend
+ 8;
10983 if (plt_static_chain
)
10985 r
[3].r_offset
= r
[2].r_offset
+ 4;
10986 r
[3].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
10987 r
[3].r_addend
= r
[0].r_addend
+ 16;
10992 if (ALWAYS_EMIT_R2SAVE
10993 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10994 bfd_put_32 (obfd
, STD_R2_0R1
+ STK_TOC (htab
), p
), p
+= 4;
10997 bfd_put_32 (obfd
, ADDIS_R11_R2
| PPC_HA (offset
), p
), p
+= 4;
10998 bfd_put_32 (obfd
, LD_R12_0R11
| PPC_LO (offset
), p
), p
+= 4;
11002 bfd_put_32 (obfd
, ADDIS_R12_R2
| PPC_HA (offset
), p
), p
+= 4;
11003 bfd_put_32 (obfd
, LD_R12_0R12
| PPC_LO (offset
), p
), p
+= 4;
11006 && PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
11008 bfd_put_32 (obfd
, ADDI_R11_R11
| PPC_LO (offset
), p
), p
+= 4;
11011 bfd_put_32 (obfd
, MTCTR_R12
, p
), p
+= 4;
11016 bfd_put_32 (obfd
, XOR_R2_R12_R12
, p
), p
+= 4;
11017 bfd_put_32 (obfd
, ADD_R11_R11_R2
, p
), p
+= 4;
11019 bfd_put_32 (obfd
, LD_R2_0R11
| PPC_LO (offset
+ 8), p
), p
+= 4;
11020 if (plt_static_chain
)
11021 bfd_put_32 (obfd
, LD_R11_0R11
| PPC_LO (offset
+ 16), p
), p
+= 4;
11028 if (ALWAYS_EMIT_R2SAVE
11029 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
11030 r
[0].r_offset
+= 4;
11031 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
11034 if (PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
11036 r
[1].r_offset
= r
[0].r_offset
+ 4;
11037 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16
);
11038 r
[1].r_addend
= r
[0].r_addend
;
11042 r
[1].r_offset
= r
[0].r_offset
+ 8 + 8 * use_fake_dep
;
11043 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
11044 r
[1].r_addend
= r
[0].r_addend
+ 8 + 8 * plt_static_chain
;
11045 if (plt_static_chain
)
11047 r
[2].r_offset
= r
[1].r_offset
+ 4;
11048 r
[2].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
11049 r
[2].r_addend
= r
[0].r_addend
+ 8;
11054 if (ALWAYS_EMIT_R2SAVE
11055 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
11056 bfd_put_32 (obfd
, STD_R2_0R1
+ STK_TOC (htab
), p
), p
+= 4;
11057 bfd_put_32 (obfd
, LD_R12_0R2
| PPC_LO (offset
), p
), p
+= 4;
11059 && PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
11061 bfd_put_32 (obfd
, ADDI_R2_R2
| PPC_LO (offset
), p
), p
+= 4;
11064 bfd_put_32 (obfd
, MTCTR_R12
, p
), p
+= 4;
11069 bfd_put_32 (obfd
, XOR_R11_R12_R12
, p
), p
+= 4;
11070 bfd_put_32 (obfd
, ADD_R2_R2_R11
, p
), p
+= 4;
11072 if (plt_static_chain
)
11073 bfd_put_32 (obfd
, LD_R11_0R2
| PPC_LO (offset
+ 16), p
), p
+= 4;
11074 bfd_put_32 (obfd
, LD_R2_0R2
| PPC_LO (offset
+ 8), p
), p
+= 4;
11077 if (plt_load_toc
&& plt_thread_safe
&& !use_fake_dep
)
11079 bfd_put_32 (obfd
, CMPLDI_R2_0
, p
), p
+= 4;
11080 bfd_put_32 (obfd
, BNECTR_P4
, p
), p
+= 4;
11081 bfd_put_32 (obfd
, B_DOT
| (cmp_branch_off
& 0x3fffffc), p
), p
+= 4;
11084 bfd_put_32 (obfd
, BCTR
, p
), p
+= 4;
11088 /* Build a special .plt call stub for __tls_get_addr. */
11090 #define LD_R0_0R3 0xe8030000
11091 #define LD_R12_0R3 0xe9830000
11092 #define MR_R0_R3 0x7c601b78
11093 #define CMPDI_R0_0 0x2c200000
11094 #define ADD_R3_R12_R13 0x7c6c6a14
11095 #define BEQLR 0x4d820020
11096 #define MR_R3_R0 0x7c030378
11097 #define BCTRL 0x4e800421
11099 static inline bfd_byte
*
11100 build_tls_get_addr_stub (struct ppc_link_hash_table
*htab
,
11101 struct ppc_stub_hash_entry
*stub_entry
,
11102 bfd_byte
*p
, bfd_vma offset
, Elf_Internal_Rela
*r
)
11104 bfd
*obfd
= htab
->params
->stub_bfd
;
11108 bfd_put_32 (obfd
, LD_R0_0R3
+ 0, p
), p
+= 4;
11109 bfd_put_32 (obfd
, LD_R12_0R3
+ 8, p
), p
+= 4;
11110 bfd_put_32 (obfd
, CMPDI_R0_0
, p
), p
+= 4;
11111 bfd_put_32 (obfd
, MR_R0_R3
, p
), p
+= 4;
11112 bfd_put_32 (obfd
, ADD_R3_R12_R13
, p
), p
+= 4;
11113 bfd_put_32 (obfd
, BEQLR
, p
), p
+= 4;
11114 bfd_put_32 (obfd
, MR_R3_R0
, p
), p
+= 4;
11115 if (htab
->params
->no_tls_get_addr_regsave
)
11118 r
[0].r_offset
+= 7 * 4;
11119 if (stub_entry
->stub_type
!= ppc_stub_plt_call_r2save
)
11120 return build_plt_stub (htab
, stub_entry
, p
, offset
, r
);
11122 bfd_put_32 (obfd
, MFLR_R0
, p
);
11124 bfd_put_32 (obfd
, STD_R0_0R1
+ STK_LINKER (htab
), p
);
11128 r
[0].r_offset
+= 2 * 4;
11129 p
= build_plt_stub (htab
, stub_entry
, p
, offset
, r
);
11130 bfd_put_32 (obfd
, BCTRL
, p
- 4);
11132 bfd_put_32 (obfd
, LD_R2_0R1
+ STK_TOC (htab
), p
);
11134 bfd_put_32 (obfd
, LD_R0_0R1
+ STK_LINKER (htab
), p
);
11136 bfd_put_32 (obfd
, MTLR_R0
, p
);
11138 bfd_put_32 (obfd
, BLR
, p
);
11143 p
= tls_get_addr_prologue (obfd
, p
, htab
);
11146 r
[0].r_offset
+= 18 * 4;
11148 p
= build_plt_stub (htab
, stub_entry
, p
, offset
, r
);
11149 bfd_put_32 (obfd
, BCTRL
, p
- 4);
11151 if (stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
11153 bfd_put_32 (obfd
, LD_R2_0R1
+ STK_TOC (htab
), p
);
11157 p
= tls_get_addr_epilogue (obfd
, p
, htab
);
11160 if (htab
->glink_eh_frame
!= NULL
11161 && htab
->glink_eh_frame
->size
!= 0)
11163 bfd_byte
*base
, *eh
;
11165 base
= htab
->glink_eh_frame
->contents
+ stub_entry
->group
->eh_base
+ 17;
11166 eh
= base
+ stub_entry
->group
->eh_size
;
11167 if (htab
->params
->no_tls_get_addr_regsave
)
11169 unsigned int lr_used
, delta
;
11170 lr_used
= stub_entry
->stub_offset
+ (p
- 20 - loc
);
11171 delta
= lr_used
- stub_entry
->group
->lr_restore
;
11172 stub_entry
->group
->lr_restore
= lr_used
+ 16;
11173 eh
= eh_advance (htab
->elf
.dynobj
, eh
, delta
);
11174 *eh
++ = DW_CFA_offset_extended_sf
;
11176 *eh
++ = -(STK_LINKER (htab
) / 8) & 0x7f;
11177 *eh
++ = DW_CFA_advance_loc
+ 4;
11181 unsigned int cfa_updt
, delta
;
11182 /* After the bctrl, lr has been modified so we need to emit
11183 .eh_frame info saying the return address is on the stack. In
11184 fact we must put the EH info at or before the call rather
11185 than after it, because the EH info for a call needs to be
11186 specified by that point.
11187 See libgcc/unwind-dw2.c execute_cfa_program.
11188 Any stack pointer update must be described immediately after
11189 the instruction making the change, and since the stdu occurs
11190 after saving regs we put all the reg saves and the cfa
11192 cfa_updt
= stub_entry
->stub_offset
+ 18 * 4;
11193 delta
= cfa_updt
- stub_entry
->group
->lr_restore
;
11194 stub_entry
->group
->lr_restore
11195 = stub_entry
->stub_offset
+ (p
- loc
) - 4;
11196 eh
= eh_advance (htab
->elf
.dynobj
, eh
, delta
);
11197 *eh
++ = DW_CFA_def_cfa_offset
;
11205 *eh
++ = DW_CFA_offset_extended_sf
;
11207 *eh
++ = (-16 / 8) & 0x7f;
11208 for (i
= 4; i
< 12; i
++)
11210 *eh
++ = DW_CFA_offset
+ i
;
11211 *eh
++ = (htab
->opd_abi
? 13 : 12) - i
;
11213 *eh
++ = (DW_CFA_advance_loc
11214 + (stub_entry
->group
->lr_restore
- 8 - cfa_updt
) / 4);
11215 *eh
++ = DW_CFA_def_cfa_offset
;
11217 for (i
= 4; i
< 12; i
++)
11218 *eh
++ = DW_CFA_restore
+ i
;
11219 *eh
++ = DW_CFA_advance_loc
+ 2;
11221 *eh
++ = DW_CFA_restore_extended
;
11223 stub_entry
->group
->eh_size
= eh
- base
;
11228 static Elf_Internal_Rela
*
11229 get_relocs (asection
*sec
, int count
)
11231 Elf_Internal_Rela
*relocs
;
11232 struct bfd_elf_section_data
*elfsec_data
;
11234 elfsec_data
= elf_section_data (sec
);
11235 relocs
= elfsec_data
->relocs
;
11236 if (relocs
== NULL
)
11238 bfd_size_type relsize
;
11239 relsize
= sec
->reloc_count
* sizeof (*relocs
);
11240 relocs
= bfd_alloc (sec
->owner
, relsize
);
11241 if (relocs
== NULL
)
11243 elfsec_data
->relocs
= relocs
;
11244 elfsec_data
->rela
.hdr
= bfd_zalloc (sec
->owner
,
11245 sizeof (Elf_Internal_Shdr
));
11246 if (elfsec_data
->rela
.hdr
== NULL
)
11248 elfsec_data
->rela
.hdr
->sh_size
= (sec
->reloc_count
11249 * sizeof (Elf64_External_Rela
));
11250 elfsec_data
->rela
.hdr
->sh_entsize
= sizeof (Elf64_External_Rela
);
11251 sec
->reloc_count
= 0;
11253 relocs
+= sec
->reloc_count
;
11254 sec
->reloc_count
+= count
;
11258 /* Convert the relocs R[0] thru R[-NUM_REL+1], which are all no-symbol
11259 forms, to the equivalent relocs against the global symbol given by
11263 use_global_in_relocs (struct ppc_link_hash_table
*htab
,
11264 struct ppc_stub_hash_entry
*stub_entry
,
11265 Elf_Internal_Rela
*r
, unsigned int num_rel
)
11267 struct elf_link_hash_entry
**hashes
;
11268 unsigned long symndx
;
11269 struct ppc_link_hash_entry
*h
;
11272 /* Relocs are always against symbols in their own object file. Fake
11273 up global sym hashes for the stub bfd (which has no symbols). */
11274 hashes
= elf_sym_hashes (htab
->params
->stub_bfd
);
11275 if (hashes
== NULL
)
11277 bfd_size_type hsize
;
11279 /* When called the first time, stub_globals will contain the
11280 total number of symbols seen during stub sizing. After
11281 allocating, stub_globals is used as an index to fill the
11283 hsize
= (htab
->stub_globals
+ 1) * sizeof (*hashes
);
11284 hashes
= bfd_zalloc (htab
->params
->stub_bfd
, hsize
);
11285 if (hashes
== NULL
)
11287 elf_sym_hashes (htab
->params
->stub_bfd
) = hashes
;
11288 htab
->stub_globals
= 1;
11290 symndx
= htab
->stub_globals
++;
11292 hashes
[symndx
] = &h
->elf
;
11293 if (h
->oh
!= NULL
&& h
->oh
->is_func
)
11294 h
= ppc_follow_link (h
->oh
);
11295 BFD_ASSERT (h
->elf
.root
.type
== bfd_link_hash_defined
11296 || h
->elf
.root
.type
== bfd_link_hash_defweak
);
11297 symval
= defined_sym_val (&h
->elf
);
11298 while (num_rel
-- != 0)
11300 r
->r_info
= ELF64_R_INFO (symndx
, ELF64_R_TYPE (r
->r_info
));
11301 if (h
->elf
.root
.u
.def
.section
!= stub_entry
->target_section
)
11303 /* H is an opd symbol. The addend must be zero, and the
11304 branch reloc is the only one we can convert. */
11309 r
->r_addend
-= symval
;
11316 get_r2off (struct bfd_link_info
*info
,
11317 struct ppc_stub_hash_entry
*stub_entry
)
11319 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
11320 bfd_vma r2off
= htab
->sec_info
[stub_entry
->target_section
->id
].toc_off
;
11324 /* Support linking -R objects. Get the toc pointer from the
11327 if (!htab
->opd_abi
)
11329 asection
*opd
= stub_entry
->h
->elf
.root
.u
.def
.section
;
11330 bfd_vma opd_off
= stub_entry
->h
->elf
.root
.u
.def
.value
;
11332 if (strcmp (opd
->name
, ".opd") != 0
11333 || opd
->reloc_count
!= 0)
11335 info
->callbacks
->einfo
11336 (_("%P: cannot find opd entry toc for `%pT'\n"),
11337 stub_entry
->h
->elf
.root
.root
.string
);
11338 bfd_set_error (bfd_error_bad_value
);
11339 return (bfd_vma
) -1;
11341 if (!bfd_get_section_contents (opd
->owner
, opd
, buf
, opd_off
+ 8, 8))
11342 return (bfd_vma
) -1;
11343 r2off
= bfd_get_64 (opd
->owner
, buf
);
11344 r2off
-= elf_gp (info
->output_bfd
);
11346 r2off
-= htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
;
11351 ppc_build_one_stub (struct bfd_hash_entry
*gen_entry
, void *in_arg
)
11353 struct ppc_stub_hash_entry
*stub_entry
;
11354 struct ppc_branch_hash_entry
*br_entry
;
11355 struct bfd_link_info
*info
;
11356 struct ppc_link_hash_table
*htab
;
11358 bfd_byte
*p
, *relp
;
11360 Elf_Internal_Rela
*r
;
11365 /* Massage our args to the form they really have. */
11366 stub_entry
= (struct ppc_stub_hash_entry
*) gen_entry
;
11369 /* Fail if the target section could not be assigned to an output
11370 section. The user should fix his linker script. */
11371 if (stub_entry
->target_section
!= NULL
11372 && stub_entry
->target_section
->output_section
== NULL
11373 && info
->non_contiguous_regions
)
11374 info
->callbacks
->einfo (_("%F%P: Could not assign '%pA' to an output section. "
11375 "Retry without --enable-non-contiguous-regions.\n"),
11376 stub_entry
->target_section
);
11378 /* Same for the group. */
11379 if (stub_entry
->group
->stub_sec
!= NULL
11380 && stub_entry
->group
->stub_sec
->output_section
== NULL
11381 && info
->non_contiguous_regions
)
11382 info
->callbacks
->einfo (_("%F%P: Could not assign group %pA target %pA to an "
11383 "output section. Retry without "
11384 "--enable-non-contiguous-regions.\n"),
11385 stub_entry
->group
->stub_sec
,
11386 stub_entry
->target_section
);
11388 htab
= ppc_hash_table (info
);
11392 BFD_ASSERT (stub_entry
->stub_offset
>= stub_entry
->group
->stub_sec
->size
);
11393 loc
= stub_entry
->group
->stub_sec
->contents
+ stub_entry
->stub_offset
;
11395 htab
->stub_count
[stub_entry
->stub_type
- 1] += 1;
11396 switch (stub_entry
->stub_type
)
11398 case ppc_stub_long_branch
:
11399 case ppc_stub_long_branch_r2off
:
11400 /* Branches are relative. This is where we are going to. */
11401 targ
= (stub_entry
->target_value
11402 + stub_entry
->target_section
->output_offset
11403 + stub_entry
->target_section
->output_section
->vma
);
11404 targ
+= PPC64_LOCAL_ENTRY_OFFSET (stub_entry
->other
);
11406 /* And this is where we are coming from. */
11407 off
= (stub_entry
->stub_offset
11408 + stub_entry
->group
->stub_sec
->output_offset
11409 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11413 if (stub_entry
->stub_type
== ppc_stub_long_branch_r2off
)
11415 bfd_vma r2off
= get_r2off (info
, stub_entry
);
11417 if (r2off
== (bfd_vma
) -1)
11419 htab
->stub_error
= TRUE
;
11422 bfd_put_32 (htab
->params
->stub_bfd
, STD_R2_0R1
+ STK_TOC (htab
), p
);
11424 if (PPC_HA (r2off
) != 0)
11426 bfd_put_32 (htab
->params
->stub_bfd
,
11427 ADDIS_R2_R2
| PPC_HA (r2off
), p
);
11430 if (PPC_LO (r2off
) != 0)
11432 bfd_put_32 (htab
->params
->stub_bfd
,
11433 ADDI_R2_R2
| PPC_LO (r2off
), p
);
11438 bfd_put_32 (htab
->params
->stub_bfd
, B_DOT
| (off
& 0x3fffffc), p
);
11441 if (off
+ (1 << 25) >= (bfd_vma
) (1 << 26))
11444 (_("long branch stub `%s' offset overflow"),
11445 stub_entry
->root
.string
);
11446 htab
->stub_error
= TRUE
;
11450 if (info
->emitrelocations
)
11452 r
= get_relocs (stub_entry
->group
->stub_sec
, 1);
11455 r
->r_offset
= p
- 4 - stub_entry
->group
->stub_sec
->contents
;
11456 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL24
);
11457 r
->r_addend
= targ
;
11458 if (stub_entry
->h
!= NULL
11459 && !use_global_in_relocs (htab
, stub_entry
, r
, 1))
11464 case ppc_stub_plt_branch
:
11465 case ppc_stub_plt_branch_r2off
:
11466 br_entry
= ppc_branch_hash_lookup (&htab
->branch_hash_table
,
11467 stub_entry
->root
.string
+ 9,
11469 if (br_entry
== NULL
)
11471 _bfd_error_handler (_("can't find branch stub `%s'"),
11472 stub_entry
->root
.string
);
11473 htab
->stub_error
= TRUE
;
11477 targ
= (stub_entry
->target_value
11478 + stub_entry
->target_section
->output_offset
11479 + stub_entry
->target_section
->output_section
->vma
);
11480 if (stub_entry
->stub_type
!= ppc_stub_plt_branch_r2off
)
11481 targ
+= PPC64_LOCAL_ENTRY_OFFSET (stub_entry
->other
);
11483 bfd_put_64 (htab
->brlt
->owner
, targ
,
11484 htab
->brlt
->contents
+ br_entry
->offset
);
11486 if (br_entry
->iter
== htab
->stub_iteration
)
11488 br_entry
->iter
= 0;
11490 if (htab
->relbrlt
!= NULL
)
11492 /* Create a reloc for the branch lookup table entry. */
11493 Elf_Internal_Rela rela
;
11496 rela
.r_offset
= (br_entry
->offset
11497 + htab
->brlt
->output_offset
11498 + htab
->brlt
->output_section
->vma
);
11499 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
11500 rela
.r_addend
= targ
;
11502 rl
= htab
->relbrlt
->contents
;
11503 rl
+= (htab
->relbrlt
->reloc_count
++
11504 * sizeof (Elf64_External_Rela
));
11505 bfd_elf64_swap_reloca_out (htab
->relbrlt
->owner
, &rela
, rl
);
11507 else if (info
->emitrelocations
)
11509 r
= get_relocs (htab
->brlt
, 1);
11512 /* brlt, being SEC_LINKER_CREATED does not go through the
11513 normal reloc processing. Symbols and offsets are not
11514 translated from input file to output file form, so
11515 set up the offset per the output file. */
11516 r
->r_offset
= (br_entry
->offset
11517 + htab
->brlt
->output_offset
11518 + htab
->brlt
->output_section
->vma
);
11519 r
->r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
11520 r
->r_addend
= targ
;
11524 targ
= (br_entry
->offset
11525 + htab
->brlt
->output_offset
11526 + htab
->brlt
->output_section
->vma
);
11528 off
= (elf_gp (info
->output_bfd
)
11529 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
11532 if (off
+ 0x80008000 > 0xffffffff || (off
& 7) != 0)
11534 info
->callbacks
->einfo
11535 (_("%P: linkage table error against `%pT'\n"),
11536 stub_entry
->root
.string
);
11537 bfd_set_error (bfd_error_bad_value
);
11538 htab
->stub_error
= TRUE
;
11542 if (info
->emitrelocations
)
11544 r
= get_relocs (stub_entry
->group
->stub_sec
, 1 + (PPC_HA (off
) != 0));
11547 r
[0].r_offset
= loc
- stub_entry
->group
->stub_sec
->contents
;
11548 if (bfd_big_endian (info
->output_bfd
))
11549 r
[0].r_offset
+= 2;
11550 if (stub_entry
->stub_type
== ppc_stub_plt_branch_r2off
)
11551 r
[0].r_offset
+= 4;
11552 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
11553 r
[0].r_addend
= targ
;
11554 if (PPC_HA (off
) != 0)
11556 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_HA
);
11557 r
[1].r_offset
= r
[0].r_offset
+ 4;
11558 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
11559 r
[1].r_addend
= r
[0].r_addend
;
11564 if (stub_entry
->stub_type
!= ppc_stub_plt_branch_r2off
)
11566 if (PPC_HA (off
) != 0)
11568 bfd_put_32 (htab
->params
->stub_bfd
,
11569 ADDIS_R12_R2
| PPC_HA (off
), p
);
11571 bfd_put_32 (htab
->params
->stub_bfd
,
11572 LD_R12_0R12
| PPC_LO (off
), p
);
11575 bfd_put_32 (htab
->params
->stub_bfd
,
11576 LD_R12_0R2
| PPC_LO (off
), p
);
11580 bfd_vma r2off
= get_r2off (info
, stub_entry
);
11582 if (r2off
== (bfd_vma
) -1)
11584 htab
->stub_error
= TRUE
;
11588 bfd_put_32 (htab
->params
->stub_bfd
, STD_R2_0R1
+ STK_TOC (htab
), p
);
11590 if (PPC_HA (off
) != 0)
11592 bfd_put_32 (htab
->params
->stub_bfd
,
11593 ADDIS_R12_R2
| PPC_HA (off
), p
);
11595 bfd_put_32 (htab
->params
->stub_bfd
,
11596 LD_R12_0R12
| PPC_LO (off
), p
);
11599 bfd_put_32 (htab
->params
->stub_bfd
, LD_R12_0R2
| PPC_LO (off
), p
);
11601 if (PPC_HA (r2off
) != 0)
11604 bfd_put_32 (htab
->params
->stub_bfd
,
11605 ADDIS_R2_R2
| PPC_HA (r2off
), p
);
11607 if (PPC_LO (r2off
) != 0)
11610 bfd_put_32 (htab
->params
->stub_bfd
,
11611 ADDI_R2_R2
| PPC_LO (r2off
), p
);
11615 bfd_put_32 (htab
->params
->stub_bfd
, MTCTR_R12
, p
);
11617 bfd_put_32 (htab
->params
->stub_bfd
, BCTR
, p
);
11621 case ppc_stub_long_branch_notoc
:
11622 case ppc_stub_long_branch_both
:
11623 case ppc_stub_plt_branch_notoc
:
11624 case ppc_stub_plt_branch_both
:
11625 case ppc_stub_plt_call_notoc
:
11626 case ppc_stub_plt_call_both
:
11628 off
= (stub_entry
->stub_offset
11629 + stub_entry
->group
->stub_sec
->output_offset
11630 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11631 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
11632 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
11633 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
11636 bfd_put_32 (htab
->params
->stub_bfd
, STD_R2_0R1
+ STK_TOC (htab
), p
);
11639 if (stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
)
11641 targ
= stub_entry
->plt_ent
->plt
.offset
& ~1;
11642 if (targ
>= (bfd_vma
) -2)
11645 plt
= htab
->elf
.splt
;
11646 if (!htab
->elf
.dynamic_sections_created
11647 || stub_entry
->h
== NULL
11648 || stub_entry
->h
->elf
.dynindx
== -1)
11650 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
11651 plt
= htab
->elf
.iplt
;
11653 plt
= htab
->pltlocal
;
11655 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
11658 targ
= (stub_entry
->target_value
11659 + stub_entry
->target_section
->output_offset
11660 + stub_entry
->target_section
->output_section
->vma
);
11666 if (htab
->power10_stubs
)
11668 bfd_boolean load
= stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
;
11669 p
= build_power10_offset (htab
->params
->stub_bfd
, p
, off
, odd
, load
);
11673 /* The notoc stubs calculate their target (either a PLT entry or
11674 the global entry point of a function) relative to the PC
11675 returned by the "bcl" two instructions past the start of the
11676 sequence emitted by build_offset. The offset is therefore 8
11677 less than calculated from the start of the sequence. */
11679 p
= build_offset (htab
->params
->stub_bfd
, p
, off
,
11680 stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
);
11683 if (stub_entry
->stub_type
<= ppc_stub_long_branch_both
)
11687 from
= (stub_entry
->stub_offset
11688 + stub_entry
->group
->stub_sec
->output_offset
11689 + stub_entry
->group
->stub_sec
->output_section
->vma
11691 bfd_put_32 (htab
->params
->stub_bfd
,
11692 B_DOT
| ((targ
- from
) & 0x3fffffc), p
);
11696 bfd_put_32 (htab
->params
->stub_bfd
, MTCTR_R12
, p
);
11698 bfd_put_32 (htab
->params
->stub_bfd
, BCTR
, p
);
11702 if (info
->emitrelocations
)
11704 bfd_vma roff
= relp
- stub_entry
->group
->stub_sec
->contents
;
11705 if (htab
->power10_stubs
)
11706 num_rel
+= num_relocs_for_power10_offset (off
, odd
);
11709 num_rel
+= num_relocs_for_offset (off
);
11712 r
= get_relocs (stub_entry
->group
->stub_sec
, num_rel
);
11715 if (htab
->power10_stubs
)
11716 r
= emit_relocs_for_power10_offset (info
, r
, roff
, targ
, off
, odd
);
11718 r
= emit_relocs_for_offset (info
, r
, roff
, targ
, off
);
11719 if (stub_entry
->stub_type
== ppc_stub_long_branch_notoc
11720 || stub_entry
->stub_type
== ppc_stub_long_branch_both
)
11723 roff
= p
- 4 - stub_entry
->group
->stub_sec
->contents
;
11724 r
->r_offset
= roff
;
11725 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL24
);
11726 r
->r_addend
= targ
;
11727 if (stub_entry
->h
!= NULL
11728 && !use_global_in_relocs (htab
, stub_entry
, r
, num_rel
))
11733 if (!htab
->power10_stubs
11734 && htab
->glink_eh_frame
!= NULL
11735 && htab
->glink_eh_frame
->size
!= 0)
11737 bfd_byte
*base
, *eh
;
11738 unsigned int lr_used
, delta
;
11740 base
= (htab
->glink_eh_frame
->contents
11741 + stub_entry
->group
->eh_base
+ 17);
11742 eh
= base
+ stub_entry
->group
->eh_size
;
11743 lr_used
= stub_entry
->stub_offset
+ 8;
11744 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
11745 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
11746 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
11748 delta
= lr_used
- stub_entry
->group
->lr_restore
;
11749 stub_entry
->group
->lr_restore
= lr_used
+ 8;
11750 eh
= eh_advance (htab
->elf
.dynobj
, eh
, delta
);
11751 *eh
++ = DW_CFA_register
;
11754 *eh
++ = DW_CFA_advance_loc
+ 2;
11755 *eh
++ = DW_CFA_restore_extended
;
11757 stub_entry
->group
->eh_size
= eh
- base
;
11761 case ppc_stub_plt_call
:
11762 case ppc_stub_plt_call_r2save
:
11763 if (stub_entry
->h
!= NULL
11764 && stub_entry
->h
->is_func_descriptor
11765 && stub_entry
->h
->oh
!= NULL
)
11767 struct ppc_link_hash_entry
*fh
= ppc_follow_link (stub_entry
->h
->oh
);
11769 /* If the old-ABI "dot-symbol" is undefined make it weak so
11770 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL. */
11771 if (fh
->elf
.root
.type
== bfd_link_hash_undefined
11772 && (stub_entry
->h
->elf
.root
.type
== bfd_link_hash_defined
11773 || stub_entry
->h
->elf
.root
.type
== bfd_link_hash_defweak
))
11774 fh
->elf
.root
.type
= bfd_link_hash_undefweak
;
11777 /* Now build the stub. */
11778 targ
= stub_entry
->plt_ent
->plt
.offset
& ~1;
11779 if (targ
>= (bfd_vma
) -2)
11782 plt
= htab
->elf
.splt
;
11783 if (!htab
->elf
.dynamic_sections_created
11784 || stub_entry
->h
== NULL
11785 || stub_entry
->h
->elf
.dynindx
== -1)
11787 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
11788 plt
= htab
->elf
.iplt
;
11790 plt
= htab
->pltlocal
;
11792 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
11794 off
= (elf_gp (info
->output_bfd
)
11795 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
11798 if (off
+ 0x80008000 > 0xffffffff || (off
& 7) != 0)
11800 info
->callbacks
->einfo
11801 /* xgettext:c-format */
11802 (_("%P: linkage table error against `%pT'\n"),
11803 stub_entry
->h
!= NULL
11804 ? stub_entry
->h
->elf
.root
.root
.string
11806 bfd_set_error (bfd_error_bad_value
);
11807 htab
->stub_error
= TRUE
;
11812 if (info
->emitrelocations
)
11814 r
= get_relocs (stub_entry
->group
->stub_sec
,
11815 ((PPC_HA (off
) != 0)
11817 ? 2 + (htab
->params
->plt_static_chain
11818 && PPC_HA (off
+ 16) == PPC_HA (off
))
11822 r
[0].r_offset
= loc
- stub_entry
->group
->stub_sec
->contents
;
11823 if (bfd_big_endian (info
->output_bfd
))
11824 r
[0].r_offset
+= 2;
11825 r
[0].r_addend
= targ
;
11827 if (stub_entry
->h
!= NULL
11828 && is_tls_get_addr (&stub_entry
->h
->elf
, htab
)
11829 && htab
->params
->tls_get_addr_opt
)
11830 p
= build_tls_get_addr_stub (htab
, stub_entry
, loc
, off
, r
);
11832 p
= build_plt_stub (htab
, stub_entry
, loc
, off
, r
);
11835 case ppc_stub_save_res
:
11843 stub_entry
->group
->stub_sec
->size
= stub_entry
->stub_offset
+ (p
- loc
);
11845 if (htab
->params
->emit_stub_syms
)
11847 struct elf_link_hash_entry
*h
;
11850 const char *const stub_str
[] = { "long_branch",
11863 len1
= strlen (stub_str
[stub_entry
->stub_type
- 1]);
11864 len2
= strlen (stub_entry
->root
.string
);
11865 name
= bfd_malloc (len1
+ len2
+ 2);
11868 memcpy (name
, stub_entry
->root
.string
, 9);
11869 memcpy (name
+ 9, stub_str
[stub_entry
->stub_type
- 1], len1
);
11870 memcpy (name
+ len1
+ 9, stub_entry
->root
.string
+ 8, len2
- 8 + 1);
11871 h
= elf_link_hash_lookup (&htab
->elf
, name
, TRUE
, FALSE
, FALSE
);
11874 if (h
->root
.type
== bfd_link_hash_new
)
11876 h
->root
.type
= bfd_link_hash_defined
;
11877 h
->root
.u
.def
.section
= stub_entry
->group
->stub_sec
;
11878 h
->root
.u
.def
.value
= stub_entry
->stub_offset
;
11879 h
->ref_regular
= 1;
11880 h
->def_regular
= 1;
11881 h
->ref_regular_nonweak
= 1;
11882 h
->forced_local
= 1;
11884 h
->root
.linker_def
= 1;
11891 /* As above, but don't actually build the stub. Just bump offset so
11892 we know stub section sizes, and select plt_branch stubs where
11893 long_branch stubs won't do. */
11896 ppc_size_one_stub (struct bfd_hash_entry
*gen_entry
, void *in_arg
)
11898 struct ppc_stub_hash_entry
*stub_entry
;
11899 struct bfd_link_info
*info
;
11900 struct ppc_link_hash_table
*htab
;
11902 bfd_vma targ
, off
, r2off
;
11903 unsigned int size
, extra
, lr_used
, delta
, odd
;
11905 /* Massage our args to the form they really have. */
11906 stub_entry
= (struct ppc_stub_hash_entry
*) gen_entry
;
11909 htab
= ppc_hash_table (info
);
11913 /* Fail if the target section could not be assigned to an output
11914 section. The user should fix his linker script. */
11915 if (stub_entry
->target_section
!= NULL
11916 && stub_entry
->target_section
->output_section
== NULL
11917 && info
->non_contiguous_regions
)
11918 info
->callbacks
->einfo (_("%F%P: Could not assign %pA to an output section. "
11919 "Retry without --enable-non-contiguous-regions.\n"),
11920 stub_entry
->target_section
);
11922 /* Same for the group. */
11923 if (stub_entry
->group
->stub_sec
!= NULL
11924 && stub_entry
->group
->stub_sec
->output_section
== NULL
11925 && info
->non_contiguous_regions
)
11926 info
->callbacks
->einfo (_("%F%P: Could not assign group %pA target %pA to an "
11927 "output section. Retry without "
11928 "--enable-non-contiguous-regions.\n"),
11929 stub_entry
->group
->stub_sec
,
11930 stub_entry
->target_section
);
11932 /* Make a note of the offset within the stubs for this entry. */
11933 stub_entry
->stub_offset
= stub_entry
->group
->stub_sec
->size
;
11935 if (stub_entry
->h
!= NULL
11936 && stub_entry
->h
->save_res
11937 && stub_entry
->h
->elf
.root
.type
== bfd_link_hash_defined
11938 && stub_entry
->h
->elf
.root
.u
.def
.section
== htab
->sfpr
)
11940 /* Don't make stubs to out-of-line register save/restore
11941 functions. Instead, emit copies of the functions. */
11942 stub_entry
->group
->needs_save_res
= 1;
11943 stub_entry
->stub_type
= ppc_stub_save_res
;
11947 switch (stub_entry
->stub_type
)
11949 case ppc_stub_plt_branch
:
11950 case ppc_stub_plt_branch_r2off
:
11951 /* Reset the stub type from the plt branch variant in case we now
11952 can reach with a shorter stub. */
11953 stub_entry
->stub_type
+= ppc_stub_long_branch
- ppc_stub_plt_branch
;
11954 /* Fall through. */
11955 case ppc_stub_long_branch
:
11956 case ppc_stub_long_branch_r2off
:
11957 targ
= (stub_entry
->target_value
11958 + stub_entry
->target_section
->output_offset
11959 + stub_entry
->target_section
->output_section
->vma
);
11960 targ
+= PPC64_LOCAL_ENTRY_OFFSET (stub_entry
->other
);
11961 off
= (stub_entry
->stub_offset
11962 + stub_entry
->group
->stub_sec
->output_offset
11963 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11967 if (stub_entry
->stub_type
== ppc_stub_long_branch_r2off
)
11969 r2off
= get_r2off (info
, stub_entry
);
11970 if (r2off
== (bfd_vma
) -1)
11972 htab
->stub_error
= TRUE
;
11976 if (PPC_HA (r2off
) != 0)
11978 if (PPC_LO (r2off
) != 0)
11984 /* If the branch offset is too big, use a ppc_stub_plt_branch.
11985 Do the same for -R objects without function descriptors. */
11986 if ((stub_entry
->stub_type
== ppc_stub_long_branch_r2off
11988 && htab
->sec_info
[stub_entry
->target_section
->id
].toc_off
== 0)
11989 || off
+ (1 << 25) >= (bfd_vma
) (1 << 26))
11991 struct ppc_branch_hash_entry
*br_entry
;
11993 br_entry
= ppc_branch_hash_lookup (&htab
->branch_hash_table
,
11994 stub_entry
->root
.string
+ 9,
11996 if (br_entry
== NULL
)
11998 _bfd_error_handler (_("can't build branch stub `%s'"),
11999 stub_entry
->root
.string
);
12000 htab
->stub_error
= TRUE
;
12004 if (br_entry
->iter
!= htab
->stub_iteration
)
12006 br_entry
->iter
= htab
->stub_iteration
;
12007 br_entry
->offset
= htab
->brlt
->size
;
12008 htab
->brlt
->size
+= 8;
12010 if (htab
->relbrlt
!= NULL
)
12011 htab
->relbrlt
->size
+= sizeof (Elf64_External_Rela
);
12012 else if (info
->emitrelocations
)
12014 htab
->brlt
->reloc_count
+= 1;
12015 htab
->brlt
->flags
|= SEC_RELOC
;
12019 targ
= (br_entry
->offset
12020 + htab
->brlt
->output_offset
12021 + htab
->brlt
->output_section
->vma
);
12022 off
= (elf_gp (info
->output_bfd
)
12023 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
12026 if (info
->emitrelocations
)
12028 stub_entry
->group
->stub_sec
->reloc_count
12029 += 1 + (PPC_HA (off
) != 0);
12030 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
12033 stub_entry
->stub_type
+= ppc_stub_plt_branch
- ppc_stub_long_branch
;
12034 if (stub_entry
->stub_type
!= ppc_stub_plt_branch_r2off
)
12037 if (PPC_HA (off
) != 0)
12043 if (PPC_HA (off
) != 0)
12046 if (PPC_HA (r2off
) != 0)
12048 if (PPC_LO (r2off
) != 0)
12052 else if (info
->emitrelocations
)
12054 stub_entry
->group
->stub_sec
->reloc_count
+= 1;
12055 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
12059 case ppc_stub_plt_branch_notoc
:
12060 case ppc_stub_plt_branch_both
:
12061 stub_entry
->stub_type
+= ppc_stub_long_branch
- ppc_stub_plt_branch
;
12062 /* Fall through. */
12063 case ppc_stub_long_branch_notoc
:
12064 case ppc_stub_long_branch_both
:
12065 off
= (stub_entry
->stub_offset
12066 + stub_entry
->group
->stub_sec
->output_offset
12067 + stub_entry
->group
->stub_sec
->output_section
->vma
);
12069 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
)
12072 targ
= (stub_entry
->target_value
12073 + stub_entry
->target_section
->output_offset
12074 + stub_entry
->target_section
->output_section
->vma
);
12078 if (info
->emitrelocations
)
12080 unsigned int num_rel
;
12081 if (htab
->power10_stubs
)
12082 num_rel
= num_relocs_for_power10_offset (off
, odd
);
12084 num_rel
= num_relocs_for_offset (off
- 8);
12085 stub_entry
->group
->stub_sec
->reloc_count
+= num_rel
;
12086 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
12089 if (htab
->power10_stubs
)
12090 extra
= size_power10_offset (off
, odd
);
12092 extra
= size_offset (off
- 8);
12093 /* Include branch insn plus those in the offset sequence. */
12095 /* The branch insn is at the end, or "extra" bytes along. So
12096 its offset will be "extra" bytes less that that already
12100 if (!htab
->power10_stubs
)
12102 /* After the bcl, lr has been modified so we need to emit
12103 .eh_frame info saying the return address is in r12. */
12104 lr_used
= stub_entry
->stub_offset
+ 8;
12105 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
)
12107 /* The eh_frame info will consist of a DW_CFA_advance_loc or
12108 variant, DW_CFA_register, 65, 12, DW_CFA_advance_loc+2,
12109 DW_CFA_restore_extended 65. */
12110 delta
= lr_used
- stub_entry
->group
->lr_restore
;
12111 stub_entry
->group
->eh_size
+= eh_advance_size (delta
) + 6;
12112 stub_entry
->group
->lr_restore
= lr_used
+ 8;
12115 /* If the branch can't reach, use a plt_branch. */
12116 if (off
+ (1 << 25) >= (bfd_vma
) (1 << 26))
12118 stub_entry
->stub_type
+= (ppc_stub_plt_branch_notoc
12119 - ppc_stub_long_branch_notoc
);
12122 else if (info
->emitrelocations
)
12123 stub_entry
->group
->stub_sec
->reloc_count
+=1;
12126 case ppc_stub_plt_call_notoc
:
12127 case ppc_stub_plt_call_both
:
12128 off
= (stub_entry
->stub_offset
12129 + stub_entry
->group
->stub_sec
->output_offset
12130 + stub_entry
->group
->stub_sec
->output_section
->vma
);
12131 if (stub_entry
->stub_type
== ppc_stub_plt_call_both
)
12133 targ
= stub_entry
->plt_ent
->plt
.offset
& ~1;
12134 if (targ
>= (bfd_vma
) -2)
12137 plt
= htab
->elf
.splt
;
12138 if (!htab
->elf
.dynamic_sections_created
12139 || stub_entry
->h
== NULL
12140 || stub_entry
->h
->elf
.dynindx
== -1)
12142 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
12143 plt
= htab
->elf
.iplt
;
12145 plt
= htab
->pltlocal
;
12147 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
12151 if (htab
->params
->plt_stub_align
!= 0)
12153 unsigned pad
= plt_stub_pad (htab
, stub_entry
, off
);
12155 stub_entry
->group
->stub_sec
->size
+= pad
;
12156 stub_entry
->stub_offset
= stub_entry
->group
->stub_sec
->size
;
12160 if (info
->emitrelocations
)
12162 unsigned int num_rel
;
12163 if (htab
->power10_stubs
)
12164 num_rel
= num_relocs_for_power10_offset (off
, odd
);
12166 num_rel
= num_relocs_for_offset (off
- 8);
12167 stub_entry
->group
->stub_sec
->reloc_count
+= num_rel
;
12168 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
12171 size
= plt_stub_size (htab
, stub_entry
, off
);
12173 if (!htab
->power10_stubs
)
12175 /* After the bcl, lr has been modified so we need to emit
12176 .eh_frame info saying the return address is in r12. */
12177 lr_used
= stub_entry
->stub_offset
+ 8;
12178 if (stub_entry
->stub_type
== ppc_stub_plt_call_both
)
12180 /* The eh_frame info will consist of a DW_CFA_advance_loc or
12181 variant, DW_CFA_register, 65, 12, DW_CFA_advance_loc+2,
12182 DW_CFA_restore_extended 65. */
12183 delta
= lr_used
- stub_entry
->group
->lr_restore
;
12184 stub_entry
->group
->eh_size
+= eh_advance_size (delta
) + 6;
12185 stub_entry
->group
->lr_restore
= lr_used
+ 8;
12189 case ppc_stub_plt_call
:
12190 case ppc_stub_plt_call_r2save
:
12191 targ
= stub_entry
->plt_ent
->plt
.offset
& ~(bfd_vma
) 1;
12192 if (targ
>= (bfd_vma
) -2)
12194 plt
= htab
->elf
.splt
;
12195 if (!htab
->elf
.dynamic_sections_created
12196 || stub_entry
->h
== NULL
12197 || stub_entry
->h
->elf
.dynindx
== -1)
12199 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
12200 plt
= htab
->elf
.iplt
;
12202 plt
= htab
->pltlocal
;
12204 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
12206 off
= (elf_gp (info
->output_bfd
)
12207 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
12210 if (htab
->params
->plt_stub_align
!= 0)
12212 unsigned pad
= plt_stub_pad (htab
, stub_entry
, off
);
12214 stub_entry
->group
->stub_sec
->size
+= pad
;
12215 stub_entry
->stub_offset
= stub_entry
->group
->stub_sec
->size
;
12218 if (info
->emitrelocations
)
12220 stub_entry
->group
->stub_sec
->reloc_count
12221 += ((PPC_HA (off
) != 0)
12223 ? 2 + (htab
->params
->plt_static_chain
12224 && PPC_HA (off
+ 16) == PPC_HA (off
))
12226 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
12229 size
= plt_stub_size (htab
, stub_entry
, off
);
12231 if (stub_entry
->h
!= NULL
12232 && is_tls_get_addr (&stub_entry
->h
->elf
, htab
)
12233 && htab
->params
->tls_get_addr_opt
12234 && stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
12236 if (htab
->params
->no_tls_get_addr_regsave
)
12238 lr_used
= stub_entry
->stub_offset
+ size
- 20;
12239 /* The eh_frame info will consist of a DW_CFA_advance_loc
12240 or variant, DW_CFA_offset_externed_sf, 65, -stackoff,
12241 DW_CFA_advance_loc+4, DW_CFA_restore_extended, 65. */
12242 delta
= lr_used
- stub_entry
->group
->lr_restore
;
12243 stub_entry
->group
->eh_size
+= eh_advance_size (delta
) + 6;
12247 /* Adjustments to r1 need to be described. */
12248 unsigned int cfa_updt
= stub_entry
->stub_offset
+ 18 * 4;
12249 delta
= cfa_updt
- stub_entry
->group
->lr_restore
;
12250 stub_entry
->group
->eh_size
+= eh_advance_size (delta
);
12251 stub_entry
->group
->eh_size
+= htab
->opd_abi
? 36 : 35;
12253 stub_entry
->group
->lr_restore
= size
- 4;
12262 stub_entry
->group
->stub_sec
->size
+= size
;
12266 /* Set up various things so that we can make a list of input sections
12267 for each output section included in the link. Returns -1 on error,
12268 0 when no stubs will be needed, and 1 on success. */
12271 ppc64_elf_setup_section_lists (struct bfd_link_info
*info
)
12275 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12280 htab
->sec_info_arr_size
= _bfd_section_id
;
12281 amt
= sizeof (*htab
->sec_info
) * (htab
->sec_info_arr_size
);
12282 htab
->sec_info
= bfd_zmalloc (amt
);
12283 if (htab
->sec_info
== NULL
)
12286 /* Set toc_off for com, und, abs and ind sections. */
12287 for (id
= 0; id
< 3; id
++)
12288 htab
->sec_info
[id
].toc_off
= TOC_BASE_OFF
;
12293 /* Set up for first pass at multitoc partitioning. */
12296 ppc64_elf_start_multitoc_partition (struct bfd_link_info
*info
)
12298 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12300 htab
->toc_curr
= ppc64_elf_set_toc (info
, info
->output_bfd
);
12301 htab
->toc_bfd
= NULL
;
12302 htab
->toc_first_sec
= NULL
;
12305 /* The linker repeatedly calls this function for each TOC input section
12306 and linker generated GOT section. Group input bfds such that the toc
12307 within a group is less than 64k in size. */
12310 ppc64_elf_next_toc_section (struct bfd_link_info
*info
, asection
*isec
)
12312 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12313 bfd_vma addr
, off
, limit
;
12318 if (!htab
->second_toc_pass
)
12320 /* Keep track of the first .toc or .got section for this input bfd. */
12321 bfd_boolean new_bfd
= htab
->toc_bfd
!= isec
->owner
;
12325 htab
->toc_bfd
= isec
->owner
;
12326 htab
->toc_first_sec
= isec
;
12329 addr
= isec
->output_offset
+ isec
->output_section
->vma
;
12330 off
= addr
- htab
->toc_curr
;
12331 limit
= 0x80008000;
12332 if (ppc64_elf_tdata (isec
->owner
)->has_small_toc_reloc
)
12334 if (off
+ isec
->size
> limit
)
12336 addr
= (htab
->toc_first_sec
->output_offset
12337 + htab
->toc_first_sec
->output_section
->vma
);
12338 htab
->toc_curr
= addr
;
12339 htab
->toc_curr
&= -TOC_BASE_ALIGN
;
12342 /* toc_curr is the base address of this toc group. Set elf_gp
12343 for the input section to be the offset relative to the
12344 output toc base plus 0x8000. Making the input elf_gp an
12345 offset allows us to move the toc as a whole without
12346 recalculating input elf_gp. */
12347 off
= htab
->toc_curr
- elf_gp (info
->output_bfd
);
12348 off
+= TOC_BASE_OFF
;
12350 /* Die if someone uses a linker script that doesn't keep input
12351 file .toc and .got together. */
12353 && elf_gp (isec
->owner
) != 0
12354 && elf_gp (isec
->owner
) != off
)
12357 elf_gp (isec
->owner
) = off
;
12361 /* During the second pass toc_first_sec points to the start of
12362 a toc group, and toc_curr is used to track the old elf_gp.
12363 We use toc_bfd to ensure we only look at each bfd once. */
12364 if (htab
->toc_bfd
== isec
->owner
)
12366 htab
->toc_bfd
= isec
->owner
;
12368 if (htab
->toc_first_sec
== NULL
12369 || htab
->toc_curr
!= elf_gp (isec
->owner
))
12371 htab
->toc_curr
= elf_gp (isec
->owner
);
12372 htab
->toc_first_sec
= isec
;
12374 addr
= (htab
->toc_first_sec
->output_offset
12375 + htab
->toc_first_sec
->output_section
->vma
);
12376 off
= addr
- elf_gp (info
->output_bfd
) + TOC_BASE_OFF
;
12377 elf_gp (isec
->owner
) = off
;
12382 /* Called via elf_link_hash_traverse to merge GOT entries for global
12386 merge_global_got (struct elf_link_hash_entry
*h
, void *inf ATTRIBUTE_UNUSED
)
12388 if (h
->root
.type
== bfd_link_hash_indirect
)
12391 merge_got_entries (&h
->got
.glist
);
12396 /* Called via elf_link_hash_traverse to allocate GOT entries for global
12400 reallocate_got (struct elf_link_hash_entry
*h
, void *inf
)
12402 struct got_entry
*gent
;
12404 if (h
->root
.type
== bfd_link_hash_indirect
)
12407 for (gent
= h
->got
.glist
; gent
!= NULL
; gent
= gent
->next
)
12408 if (!gent
->is_indirect
)
12409 allocate_got (h
, (struct bfd_link_info
*) inf
, gent
);
12413 /* Called on the first multitoc pass after the last call to
12414 ppc64_elf_next_toc_section. This function removes duplicate GOT
12418 ppc64_elf_layout_multitoc (struct bfd_link_info
*info
)
12420 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12421 struct bfd
*ibfd
, *ibfd2
;
12422 bfd_boolean done_something
;
12424 htab
->multi_toc_needed
= htab
->toc_curr
!= elf_gp (info
->output_bfd
);
12426 if (!htab
->do_multi_toc
)
12429 /* Merge global sym got entries within a toc group. */
12430 elf_link_hash_traverse (&htab
->elf
, merge_global_got
, info
);
12432 /* And tlsld_got. */
12433 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12435 struct got_entry
*ent
, *ent2
;
12437 if (!is_ppc64_elf (ibfd
))
12440 ent
= ppc64_tlsld_got (ibfd
);
12441 if (!ent
->is_indirect
12442 && ent
->got
.offset
!= (bfd_vma
) -1)
12444 for (ibfd2
= ibfd
->link
.next
; ibfd2
!= NULL
; ibfd2
= ibfd2
->link
.next
)
12446 if (!is_ppc64_elf (ibfd2
))
12449 ent2
= ppc64_tlsld_got (ibfd2
);
12450 if (!ent2
->is_indirect
12451 && ent2
->got
.offset
!= (bfd_vma
) -1
12452 && elf_gp (ibfd2
) == elf_gp (ibfd
))
12454 ent2
->is_indirect
= TRUE
;
12455 ent2
->got
.ent
= ent
;
12461 /* Zap sizes of got sections. */
12462 htab
->elf
.irelplt
->rawsize
= htab
->elf
.irelplt
->size
;
12463 htab
->elf
.irelplt
->size
-= htab
->got_reli_size
;
12464 htab
->got_reli_size
= 0;
12466 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12468 asection
*got
, *relgot
;
12470 if (!is_ppc64_elf (ibfd
))
12473 got
= ppc64_elf_tdata (ibfd
)->got
;
12476 got
->rawsize
= got
->size
;
12478 relgot
= ppc64_elf_tdata (ibfd
)->relgot
;
12479 relgot
->rawsize
= relgot
->size
;
12484 /* Now reallocate the got, local syms first. We don't need to
12485 allocate section contents again since we never increase size. */
12486 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12488 struct got_entry
**lgot_ents
;
12489 struct got_entry
**end_lgot_ents
;
12490 struct plt_entry
**local_plt
;
12491 struct plt_entry
**end_local_plt
;
12492 unsigned char *lgot_masks
;
12493 bfd_size_type locsymcount
;
12494 Elf_Internal_Shdr
*symtab_hdr
;
12497 if (!is_ppc64_elf (ibfd
))
12500 lgot_ents
= elf_local_got_ents (ibfd
);
12504 symtab_hdr
= &elf_symtab_hdr (ibfd
);
12505 locsymcount
= symtab_hdr
->sh_info
;
12506 end_lgot_ents
= lgot_ents
+ locsymcount
;
12507 local_plt
= (struct plt_entry
**) end_lgot_ents
;
12508 end_local_plt
= local_plt
+ locsymcount
;
12509 lgot_masks
= (unsigned char *) end_local_plt
;
12510 s
= ppc64_elf_tdata (ibfd
)->got
;
12511 for (; lgot_ents
< end_lgot_ents
; ++lgot_ents
, ++lgot_masks
)
12513 struct got_entry
*ent
;
12515 for (ent
= *lgot_ents
; ent
!= NULL
; ent
= ent
->next
)
12517 unsigned int ent_size
= 8;
12518 unsigned int rel_size
= sizeof (Elf64_External_Rela
);
12520 ent
->got
.offset
= s
->size
;
12521 if ((ent
->tls_type
& *lgot_masks
& TLS_GD
) != 0)
12526 s
->size
+= ent_size
;
12527 if ((*lgot_masks
& (TLS_TLS
| PLT_IFUNC
)) == PLT_IFUNC
)
12529 htab
->elf
.irelplt
->size
+= rel_size
;
12530 htab
->got_reli_size
+= rel_size
;
12532 else if (bfd_link_pic (info
)
12533 && !(ent
->tls_type
!= 0
12534 && bfd_link_executable (info
)))
12536 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
12537 srel
->size
+= rel_size
;
12543 elf_link_hash_traverse (&htab
->elf
, reallocate_got
, info
);
12545 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12547 struct got_entry
*ent
;
12549 if (!is_ppc64_elf (ibfd
))
12552 ent
= ppc64_tlsld_got (ibfd
);
12553 if (!ent
->is_indirect
12554 && ent
->got
.offset
!= (bfd_vma
) -1)
12556 asection
*s
= ppc64_elf_tdata (ibfd
)->got
;
12557 ent
->got
.offset
= s
->size
;
12559 if (bfd_link_dll (info
))
12561 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
12562 srel
->size
+= sizeof (Elf64_External_Rela
);
12567 done_something
= htab
->elf
.irelplt
->rawsize
!= htab
->elf
.irelplt
->size
;
12568 if (!done_something
)
12569 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12573 if (!is_ppc64_elf (ibfd
))
12576 got
= ppc64_elf_tdata (ibfd
)->got
;
12579 done_something
= got
->rawsize
!= got
->size
;
12580 if (done_something
)
12585 if (done_something
)
12586 (*htab
->params
->layout_sections_again
) ();
12588 /* Set up for second pass over toc sections to recalculate elf_gp
12589 on input sections. */
12590 htab
->toc_bfd
= NULL
;
12591 htab
->toc_first_sec
= NULL
;
12592 htab
->second_toc_pass
= TRUE
;
12593 return done_something
;
12596 /* Called after second pass of multitoc partitioning. */
12599 ppc64_elf_finish_multitoc_partition (struct bfd_link_info
*info
)
12601 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12603 /* After the second pass, toc_curr tracks the TOC offset used
12604 for code sections below in ppc64_elf_next_input_section. */
12605 htab
->toc_curr
= TOC_BASE_OFF
;
12608 /* No toc references were found in ISEC. If the code in ISEC makes no
12609 calls, then there's no need to use toc adjusting stubs when branching
12610 into ISEC. Actually, indirect calls from ISEC are OK as they will
12611 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
12612 needed, and 2 if a cyclical call-graph was found but no other reason
12613 for a stub was detected. If called from the top level, a return of
12614 2 means the same as a return of 0. */
12617 toc_adjusting_stub_needed (struct bfd_link_info
*info
, asection
*isec
)
12621 /* Mark this section as checked. */
12622 isec
->call_check_done
= 1;
12624 /* We know none of our code bearing sections will need toc stubs. */
12625 if ((isec
->flags
& SEC_LINKER_CREATED
) != 0)
12628 if (isec
->size
== 0)
12631 if (isec
->output_section
== NULL
)
12635 if (isec
->reloc_count
!= 0)
12637 Elf_Internal_Rela
*relstart
, *rel
;
12638 Elf_Internal_Sym
*local_syms
;
12639 struct ppc_link_hash_table
*htab
;
12641 relstart
= _bfd_elf_link_read_relocs (isec
->owner
, isec
, NULL
, NULL
,
12642 info
->keep_memory
);
12643 if (relstart
== NULL
)
12646 /* Look for branches to outside of this section. */
12648 htab
= ppc_hash_table (info
);
12652 for (rel
= relstart
; rel
< relstart
+ isec
->reloc_count
; ++rel
)
12654 enum elf_ppc64_reloc_type r_type
;
12655 unsigned long r_symndx
;
12656 struct elf_link_hash_entry
*h
;
12657 struct ppc_link_hash_entry
*eh
;
12658 Elf_Internal_Sym
*sym
;
12660 struct _opd_sec_data
*opd
;
12664 r_type
= ELF64_R_TYPE (rel
->r_info
);
12665 if (r_type
!= R_PPC64_REL24
12666 && r_type
!= R_PPC64_REL24_NOTOC
12667 && r_type
!= R_PPC64_REL14
12668 && r_type
!= R_PPC64_REL14_BRTAKEN
12669 && r_type
!= R_PPC64_REL14_BRNTAKEN
12670 && r_type
!= R_PPC64_PLTCALL
12671 && r_type
!= R_PPC64_PLTCALL_NOTOC
)
12674 r_symndx
= ELF64_R_SYM (rel
->r_info
);
12675 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
, r_symndx
,
12682 /* Calls to dynamic lib functions go through a plt call stub
12684 eh
= ppc_elf_hash_entry (h
);
12686 && (eh
->elf
.plt
.plist
!= NULL
12688 && ppc_follow_link (eh
->oh
)->elf
.plt
.plist
!= NULL
)))
12694 if (sym_sec
== NULL
)
12695 /* Ignore other undefined symbols. */
12698 /* Assume branches to other sections not included in the
12699 link need stubs too, to cover -R and absolute syms. */
12700 if (sym_sec
->output_section
== NULL
)
12707 sym_value
= sym
->st_value
;
12710 if (h
->root
.type
!= bfd_link_hash_defined
12711 && h
->root
.type
!= bfd_link_hash_defweak
)
12713 sym_value
= h
->root
.u
.def
.value
;
12715 sym_value
+= rel
->r_addend
;
12717 /* If this branch reloc uses an opd sym, find the code section. */
12718 opd
= get_opd_info (sym_sec
);
12721 if (h
== NULL
&& opd
->adjust
!= NULL
)
12725 adjust
= opd
->adjust
[OPD_NDX (sym_value
)];
12727 /* Assume deleted functions won't ever be called. */
12729 sym_value
+= adjust
;
12732 dest
= opd_entry_value (sym_sec
, sym_value
,
12733 &sym_sec
, NULL
, FALSE
);
12734 if (dest
== (bfd_vma
) -1)
12739 + sym_sec
->output_offset
12740 + sym_sec
->output_section
->vma
);
12742 /* Ignore branch to self. */
12743 if (sym_sec
== isec
)
12746 /* If the called function uses the toc, we need a stub. */
12747 if (sym_sec
->has_toc_reloc
12748 || sym_sec
->makes_toc_func_call
)
12754 /* Assume any branch that needs a long branch stub might in fact
12755 need a plt_branch stub. A plt_branch stub uses r2. */
12756 else if (dest
- (isec
->output_offset
12757 + isec
->output_section
->vma
12758 + rel
->r_offset
) + (1 << 25)
12759 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
12767 /* If calling back to a section in the process of being
12768 tested, we can't say for sure that no toc adjusting stubs
12769 are needed, so don't return zero. */
12770 else if (sym_sec
->call_check_in_progress
)
12773 /* Branches to another section that itself doesn't have any TOC
12774 references are OK. Recursively call ourselves to check. */
12775 else if (!sym_sec
->call_check_done
)
12779 /* Mark current section as indeterminate, so that other
12780 sections that call back to current won't be marked as
12782 isec
->call_check_in_progress
= 1;
12783 recur
= toc_adjusting_stub_needed (info
, sym_sec
);
12784 isec
->call_check_in_progress
= 0;
12795 if (local_syms
!= NULL
12796 && (elf_symtab_hdr (isec
->owner
).contents
12797 != (unsigned char *) local_syms
))
12799 if (elf_section_data (isec
)->relocs
!= relstart
)
12804 && isec
->map_head
.s
!= NULL
12805 && (strcmp (isec
->output_section
->name
, ".init") == 0
12806 || strcmp (isec
->output_section
->name
, ".fini") == 0))
12808 if (isec
->map_head
.s
->has_toc_reloc
12809 || isec
->map_head
.s
->makes_toc_func_call
)
12811 else if (!isec
->map_head
.s
->call_check_done
)
12814 isec
->call_check_in_progress
= 1;
12815 recur
= toc_adjusting_stub_needed (info
, isec
->map_head
.s
);
12816 isec
->call_check_in_progress
= 0;
12823 isec
->makes_toc_func_call
= 1;
12828 /* The linker repeatedly calls this function for each input section,
12829 in the order that input sections are linked into output sections.
12830 Build lists of input sections to determine groupings between which
12831 we may insert linker stubs. */
12834 ppc64_elf_next_input_section (struct bfd_link_info
*info
, asection
*isec
)
12836 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12841 if ((isec
->output_section
->flags
& SEC_CODE
) != 0
12842 && isec
->output_section
->id
< htab
->sec_info_arr_size
)
12844 /* This happens to make the list in reverse order,
12845 which is what we want. */
12846 htab
->sec_info
[isec
->id
].u
.list
12847 = htab
->sec_info
[isec
->output_section
->id
].u
.list
;
12848 htab
->sec_info
[isec
->output_section
->id
].u
.list
= isec
;
12851 if (htab
->multi_toc_needed
)
12853 /* Analyse sections that aren't already flagged as needing a
12854 valid toc pointer. Exclude .fixup for the linux kernel.
12855 .fixup contains branches, but only back to the function that
12856 hit an exception. */
12857 if (!(isec
->has_toc_reloc
12858 || (isec
->flags
& SEC_CODE
) == 0
12859 || strcmp (isec
->name
, ".fixup") == 0
12860 || isec
->call_check_done
))
12862 if (toc_adjusting_stub_needed (info
, isec
) < 0)
12865 /* Make all sections use the TOC assigned for this object file.
12866 This will be wrong for pasted sections; We fix that in
12867 check_pasted_section(). */
12868 if (elf_gp (isec
->owner
) != 0)
12869 htab
->toc_curr
= elf_gp (isec
->owner
);
12872 htab
->sec_info
[isec
->id
].toc_off
= htab
->toc_curr
;
12876 /* Check that all .init and .fini sections use the same toc, if they
12877 have toc relocs. */
12880 check_pasted_section (struct bfd_link_info
*info
, const char *name
)
12882 asection
*o
= bfd_get_section_by_name (info
->output_bfd
, name
);
12886 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12887 bfd_vma toc_off
= 0;
12890 for (i
= o
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
12891 if (i
->has_toc_reloc
)
12894 toc_off
= htab
->sec_info
[i
->id
].toc_off
;
12895 else if (toc_off
!= htab
->sec_info
[i
->id
].toc_off
)
12900 for (i
= o
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
12901 if (i
->makes_toc_func_call
)
12903 toc_off
= htab
->sec_info
[i
->id
].toc_off
;
12907 /* Make sure the whole pasted function uses the same toc offset. */
12909 for (i
= o
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
12910 htab
->sec_info
[i
->id
].toc_off
= toc_off
;
12916 ppc64_elf_check_init_fini (struct bfd_link_info
*info
)
12918 return (check_pasted_section (info
, ".init")
12919 & check_pasted_section (info
, ".fini"));
12922 /* See whether we can group stub sections together. Grouping stub
12923 sections may result in fewer stubs. More importantly, we need to
12924 put all .init* and .fini* stubs at the beginning of the .init or
12925 .fini output sections respectively, because glibc splits the
12926 _init and _fini functions into multiple parts. Putting a stub in
12927 the middle of a function is not a good idea. */
12930 group_sections (struct bfd_link_info
*info
,
12931 bfd_size_type stub_group_size
,
12932 bfd_boolean stubs_always_before_branch
)
12934 struct ppc_link_hash_table
*htab
;
12936 bfd_boolean suppress_size_errors
;
12938 htab
= ppc_hash_table (info
);
12942 suppress_size_errors
= FALSE
;
12943 if (stub_group_size
== 1)
12945 /* Default values. */
12946 if (stubs_always_before_branch
)
12947 stub_group_size
= 0x1e00000;
12949 stub_group_size
= 0x1c00000;
12950 suppress_size_errors
= TRUE
;
12953 for (osec
= info
->output_bfd
->sections
; osec
!= NULL
; osec
= osec
->next
)
12957 if (osec
->id
>= htab
->sec_info_arr_size
)
12960 tail
= htab
->sec_info
[osec
->id
].u
.list
;
12961 while (tail
!= NULL
)
12965 bfd_size_type total
;
12966 bfd_boolean big_sec
;
12968 struct map_stub
*group
;
12969 bfd_size_type group_size
;
12972 total
= tail
->size
;
12973 group_size
= (ppc64_elf_section_data (tail
) != NULL
12974 && ppc64_elf_section_data (tail
)->has_14bit_branch
12975 ? stub_group_size
>> 10 : stub_group_size
);
12977 big_sec
= total
> group_size
;
12978 if (big_sec
&& !suppress_size_errors
)
12979 /* xgettext:c-format */
12980 _bfd_error_handler (_("%pB section %pA exceeds stub group size"),
12981 tail
->owner
, tail
);
12982 curr_toc
= htab
->sec_info
[tail
->id
].toc_off
;
12984 while ((prev
= htab
->sec_info
[curr
->id
].u
.list
) != NULL
12985 && ((total
+= curr
->output_offset
- prev
->output_offset
)
12986 < (ppc64_elf_section_data (prev
) != NULL
12987 && ppc64_elf_section_data (prev
)->has_14bit_branch
12988 ? (group_size
= stub_group_size
>> 10) : group_size
))
12989 && htab
->sec_info
[prev
->id
].toc_off
== curr_toc
)
12992 /* OK, the size from the start of CURR to the end is less
12993 than group_size and thus can be handled by one stub
12994 section. (or the tail section is itself larger than
12995 group_size, in which case we may be toast.) We should
12996 really be keeping track of the total size of stubs added
12997 here, as stubs contribute to the final output section
12998 size. That's a little tricky, and this way will only
12999 break if stubs added make the total size more than 2^25,
13000 ie. for the default stub_group_size, if stubs total more
13001 than 2097152 bytes, or nearly 75000 plt call stubs. */
13002 group
= bfd_alloc (curr
->owner
, sizeof (*group
));
13005 group
->link_sec
= curr
;
13006 group
->stub_sec
= NULL
;
13007 group
->needs_save_res
= 0;
13008 group
->lr_restore
= 0;
13009 group
->eh_size
= 0;
13010 group
->eh_base
= 0;
13011 group
->next
= htab
->group
;
13012 htab
->group
= group
;
13015 prev
= htab
->sec_info
[tail
->id
].u
.list
;
13016 /* Set up this stub group. */
13017 htab
->sec_info
[tail
->id
].u
.group
= group
;
13019 while (tail
!= curr
&& (tail
= prev
) != NULL
);
13021 /* But wait, there's more! Input sections up to group_size
13022 bytes before the stub section can be handled by it too.
13023 Don't do this if we have a really large section after the
13024 stubs, as adding more stubs increases the chance that
13025 branches may not reach into the stub section. */
13026 if (!stubs_always_before_branch
&& !big_sec
)
13029 while (prev
!= NULL
13030 && ((total
+= tail
->output_offset
- prev
->output_offset
)
13031 < (ppc64_elf_section_data (prev
) != NULL
13032 && ppc64_elf_section_data (prev
)->has_14bit_branch
13033 ? (group_size
= stub_group_size
>> 10)
13035 && htab
->sec_info
[prev
->id
].toc_off
== curr_toc
)
13038 prev
= htab
->sec_info
[tail
->id
].u
.list
;
13039 htab
->sec_info
[tail
->id
].u
.group
= group
;
13048 static const unsigned char glink_eh_frame_cie
[] =
13050 0, 0, 0, 16, /* length. */
13051 0, 0, 0, 0, /* id. */
13052 1, /* CIE version. */
13053 'z', 'R', 0, /* Augmentation string. */
13054 4, /* Code alignment. */
13055 0x78, /* Data alignment. */
13057 1, /* Augmentation size. */
13058 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding. */
13059 DW_CFA_def_cfa
, 1, 0 /* def_cfa: r1 offset 0. */
13062 /* Stripping output sections is normally done before dynamic section
13063 symbols have been allocated. This function is called later, and
13064 handles cases like htab->brlt which is mapped to its own output
13068 maybe_strip_output (struct bfd_link_info
*info
, asection
*isec
)
13070 if (isec
->size
== 0
13071 && isec
->output_section
->size
== 0
13072 && !(isec
->output_section
->flags
& SEC_KEEP
)
13073 && !bfd_section_removed_from_list (info
->output_bfd
,
13074 isec
->output_section
)
13075 && elf_section_data (isec
->output_section
)->dynindx
== 0)
13077 isec
->output_section
->flags
|= SEC_EXCLUDE
;
13078 bfd_section_list_remove (info
->output_bfd
, isec
->output_section
);
13079 info
->output_bfd
->section_count
--;
13083 /* Determine and set the size of the stub section for a final link.
13085 The basic idea here is to examine all the relocations looking for
13086 PC-relative calls to a target that is unreachable with a "bl"
13090 ppc64_elf_size_stubs (struct bfd_link_info
*info
)
13092 bfd_size_type stub_group_size
;
13093 bfd_boolean stubs_always_before_branch
;
13094 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
13099 if (htab
->params
->plt_thread_safe
== -1 && !bfd_link_executable (info
))
13100 htab
->params
->plt_thread_safe
= 1;
13101 if (!htab
->opd_abi
)
13102 htab
->params
->plt_thread_safe
= 0;
13103 else if (htab
->params
->plt_thread_safe
== -1)
13105 static const char *const thread_starter
[] =
13109 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
13111 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
13112 "mq_notify", "create_timer",
13117 "GOMP_parallel_start",
13118 "GOMP_parallel_loop_static",
13119 "GOMP_parallel_loop_static_start",
13120 "GOMP_parallel_loop_dynamic",
13121 "GOMP_parallel_loop_dynamic_start",
13122 "GOMP_parallel_loop_guided",
13123 "GOMP_parallel_loop_guided_start",
13124 "GOMP_parallel_loop_runtime",
13125 "GOMP_parallel_loop_runtime_start",
13126 "GOMP_parallel_sections",
13127 "GOMP_parallel_sections_start",
13133 for (i
= 0; i
< ARRAY_SIZE (thread_starter
); i
++)
13135 struct elf_link_hash_entry
*h
;
13136 h
= elf_link_hash_lookup (&htab
->elf
, thread_starter
[i
],
13137 FALSE
, FALSE
, TRUE
);
13138 htab
->params
->plt_thread_safe
= h
!= NULL
&& h
->ref_regular
;
13139 if (htab
->params
->plt_thread_safe
)
13143 stubs_always_before_branch
= htab
->params
->group_size
< 0;
13144 if (htab
->params
->group_size
< 0)
13145 stub_group_size
= -htab
->params
->group_size
;
13147 stub_group_size
= htab
->params
->group_size
;
13149 if (!group_sections (info
, stub_group_size
, stubs_always_before_branch
))
13152 htab
->tga_group
= NULL
;
13153 if (!htab
->params
->no_tls_get_addr_regsave
13154 && htab
->tga_desc_fd
!= NULL
13155 && (htab
->tga_desc_fd
->elf
.root
.type
== bfd_link_hash_undefined
13156 || htab
->tga_desc_fd
->elf
.root
.type
== bfd_link_hash_undefweak
)
13157 && htab
->tls_get_addr_fd
!= NULL
13158 && is_static_defined (&htab
->tls_get_addr_fd
->elf
))
13160 asection
*sym_sec
, *code_sec
, *stub_sec
;
13162 struct _opd_sec_data
*opd
;
13164 sym_sec
= htab
->tls_get_addr_fd
->elf
.root
.u
.def
.section
;
13165 sym_value
= defined_sym_val (&htab
->tls_get_addr_fd
->elf
);
13166 code_sec
= sym_sec
;
13167 opd
= get_opd_info (sym_sec
);
13169 opd_entry_value (sym_sec
, sym_value
, &code_sec
, NULL
, FALSE
);
13170 htab
->tga_group
= htab
->sec_info
[code_sec
->id
].u
.group
;
13171 stub_sec
= (*htab
->params
->add_stub_section
) (".tga_desc.stub",
13172 htab
->tga_group
->link_sec
);
13173 if (stub_sec
== NULL
)
13175 htab
->tga_group
->stub_sec
= stub_sec
;
13177 htab
->tga_desc_fd
->elf
.root
.type
= bfd_link_hash_defined
;
13178 htab
->tga_desc_fd
->elf
.root
.u
.def
.section
= stub_sec
;
13179 htab
->tga_desc_fd
->elf
.root
.u
.def
.value
= 0;
13180 htab
->tga_desc_fd
->elf
.type
= STT_FUNC
;
13181 htab
->tga_desc_fd
->elf
.def_regular
= 1;
13182 htab
->tga_desc_fd
->elf
.non_elf
= 0;
13183 _bfd_elf_link_hash_hide_symbol (info
, &htab
->tga_desc_fd
->elf
, TRUE
);
13186 #define STUB_SHRINK_ITER 20
13187 /* Loop until no stubs added. After iteration 20 of this loop we may
13188 exit on a stub section shrinking. This is to break out of a
13189 pathological case where adding stubs on one iteration decreases
13190 section gaps (perhaps due to alignment), which then requires
13191 fewer or smaller stubs on the next iteration. */
13196 unsigned int bfd_indx
;
13197 struct map_stub
*group
;
13199 htab
->stub_iteration
+= 1;
13201 for (input_bfd
= info
->input_bfds
, bfd_indx
= 0;
13203 input_bfd
= input_bfd
->link
.next
, bfd_indx
++)
13205 Elf_Internal_Shdr
*symtab_hdr
;
13207 Elf_Internal_Sym
*local_syms
= NULL
;
13209 if (!is_ppc64_elf (input_bfd
))
13212 /* We'll need the symbol table in a second. */
13213 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
13214 if (symtab_hdr
->sh_info
== 0)
13217 /* Walk over each section attached to the input bfd. */
13218 for (section
= input_bfd
->sections
;
13220 section
= section
->next
)
13222 Elf_Internal_Rela
*internal_relocs
, *irelaend
, *irela
;
13224 /* If there aren't any relocs, then there's nothing more
13226 if ((section
->flags
& SEC_RELOC
) == 0
13227 || (section
->flags
& SEC_ALLOC
) == 0
13228 || (section
->flags
& SEC_LOAD
) == 0
13229 || (section
->flags
& SEC_CODE
) == 0
13230 || section
->reloc_count
== 0)
13233 /* If this section is a link-once section that will be
13234 discarded, then don't create any stubs. */
13235 if (section
->output_section
== NULL
13236 || section
->output_section
->owner
!= info
->output_bfd
)
13239 /* Get the relocs. */
13241 = _bfd_elf_link_read_relocs (input_bfd
, section
, NULL
, NULL
,
13242 info
->keep_memory
);
13243 if (internal_relocs
== NULL
)
13244 goto error_ret_free_local
;
13246 /* Now examine each relocation. */
13247 irela
= internal_relocs
;
13248 irelaend
= irela
+ section
->reloc_count
;
13249 for (; irela
< irelaend
; irela
++)
13251 enum elf_ppc64_reloc_type r_type
;
13252 unsigned int r_indx
;
13253 enum ppc_stub_type stub_type
;
13254 struct ppc_stub_hash_entry
*stub_entry
;
13255 asection
*sym_sec
, *code_sec
;
13256 bfd_vma sym_value
, code_value
;
13257 bfd_vma destination
;
13258 unsigned long local_off
;
13259 bfd_boolean ok_dest
;
13260 struct ppc_link_hash_entry
*hash
;
13261 struct ppc_link_hash_entry
*fdh
;
13262 struct elf_link_hash_entry
*h
;
13263 Elf_Internal_Sym
*sym
;
13265 const asection
*id_sec
;
13266 struct _opd_sec_data
*opd
;
13267 struct plt_entry
*plt_ent
;
13269 r_type
= ELF64_R_TYPE (irela
->r_info
);
13270 r_indx
= ELF64_R_SYM (irela
->r_info
);
13272 if (r_type
>= R_PPC64_max
)
13274 bfd_set_error (bfd_error_bad_value
);
13275 goto error_ret_free_internal
;
13278 /* Only look for stubs on branch instructions. */
13279 if (r_type
!= R_PPC64_REL24
13280 && r_type
!= R_PPC64_REL24_NOTOC
13281 && r_type
!= R_PPC64_REL14
13282 && r_type
!= R_PPC64_REL14_BRTAKEN
13283 && r_type
!= R_PPC64_REL14_BRNTAKEN
)
13286 /* Now determine the call target, its name, value,
13288 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
13289 r_indx
, input_bfd
))
13290 goto error_ret_free_internal
;
13291 hash
= ppc_elf_hash_entry (h
);
13298 sym_value
= sym
->st_value
;
13299 if (sym_sec
!= NULL
13300 && sym_sec
->output_section
!= NULL
)
13303 else if (hash
->elf
.root
.type
== bfd_link_hash_defined
13304 || hash
->elf
.root
.type
== bfd_link_hash_defweak
)
13306 sym_value
= hash
->elf
.root
.u
.def
.value
;
13307 if (sym_sec
->output_section
!= NULL
)
13310 else if (hash
->elf
.root
.type
== bfd_link_hash_undefweak
13311 || hash
->elf
.root
.type
== bfd_link_hash_undefined
)
13313 /* Recognise an old ABI func code entry sym, and
13314 use the func descriptor sym instead if it is
13316 if (hash
->elf
.root
.root
.string
[0] == '.'
13317 && hash
->oh
!= NULL
)
13319 fdh
= ppc_follow_link (hash
->oh
);
13320 if (fdh
->elf
.root
.type
== bfd_link_hash_defined
13321 || fdh
->elf
.root
.type
== bfd_link_hash_defweak
)
13323 sym_sec
= fdh
->elf
.root
.u
.def
.section
;
13324 sym_value
= fdh
->elf
.root
.u
.def
.value
;
13325 if (sym_sec
->output_section
!= NULL
)
13334 bfd_set_error (bfd_error_bad_value
);
13335 goto error_ret_free_internal
;
13342 sym_value
+= irela
->r_addend
;
13343 destination
= (sym_value
13344 + sym_sec
->output_offset
13345 + sym_sec
->output_section
->vma
);
13346 local_off
= PPC64_LOCAL_ENTRY_OFFSET (hash
13351 code_sec
= sym_sec
;
13352 code_value
= sym_value
;
13353 opd
= get_opd_info (sym_sec
);
13358 if (hash
== NULL
&& opd
->adjust
!= NULL
)
13360 long adjust
= opd
->adjust
[OPD_NDX (sym_value
)];
13363 code_value
+= adjust
;
13364 sym_value
+= adjust
;
13366 dest
= opd_entry_value (sym_sec
, sym_value
,
13367 &code_sec
, &code_value
, FALSE
);
13368 if (dest
!= (bfd_vma
) -1)
13370 destination
= dest
;
13373 /* Fixup old ABI sym to point at code
13375 hash
->elf
.root
.type
= bfd_link_hash_defweak
;
13376 hash
->elf
.root
.u
.def
.section
= code_sec
;
13377 hash
->elf
.root
.u
.def
.value
= code_value
;
13382 /* Determine what (if any) linker stub is needed. */
13384 stub_type
= ppc_type_of_stub (section
, irela
, &hash
,
13385 &plt_ent
, destination
,
13388 if (r_type
== R_PPC64_REL24_NOTOC
)
13390 if (stub_type
== ppc_stub_plt_call
)
13391 stub_type
= ppc_stub_plt_call_notoc
;
13392 else if (stub_type
== ppc_stub_long_branch
13393 || (code_sec
!= NULL
13394 && code_sec
->output_section
!= NULL
13395 && (((hash
? hash
->elf
.other
: sym
->st_other
)
13396 & STO_PPC64_LOCAL_MASK
)
13397 > 1 << STO_PPC64_LOCAL_BIT
)))
13398 stub_type
= ppc_stub_long_branch_notoc
;
13400 else if (stub_type
!= ppc_stub_plt_call
)
13402 /* Check whether we need a TOC adjusting stub.
13403 Since the linker pastes together pieces from
13404 different object files when creating the
13405 _init and _fini functions, it may be that a
13406 call to what looks like a local sym is in
13407 fact a call needing a TOC adjustment. */
13408 if ((code_sec
!= NULL
13409 && code_sec
->output_section
!= NULL
13410 && (htab
->sec_info
[code_sec
->id
].toc_off
13411 != htab
->sec_info
[section
->id
].toc_off
)
13412 && (code_sec
->has_toc_reloc
13413 || code_sec
->makes_toc_func_call
))
13414 || (((hash
? hash
->elf
.other
: sym
->st_other
)
13415 & STO_PPC64_LOCAL_MASK
)
13416 == 1 << STO_PPC64_LOCAL_BIT
))
13417 stub_type
= ppc_stub_long_branch_r2off
;
13420 if (stub_type
== ppc_stub_none
)
13423 /* __tls_get_addr calls might be eliminated. */
13424 if (stub_type
!= ppc_stub_plt_call
13425 && stub_type
!= ppc_stub_plt_call_notoc
13427 && is_tls_get_addr (&hash
->elf
, htab
)
13428 && section
->has_tls_reloc
13429 && irela
!= internal_relocs
)
13431 /* Get tls info. */
13432 unsigned char *tls_mask
;
13434 if (!get_tls_mask (&tls_mask
, NULL
, NULL
, &local_syms
,
13435 irela
- 1, input_bfd
))
13436 goto error_ret_free_internal
;
13437 if ((*tls_mask
& TLS_TLS
) != 0
13438 && (*tls_mask
& (TLS_GD
| TLS_LD
)) == 0)
13442 if (stub_type
== ppc_stub_plt_call
)
13445 && htab
->params
->plt_localentry0
!= 0
13446 && is_elfv2_localentry0 (&hash
->elf
))
13447 htab
->has_plt_localentry0
= 1;
13448 else if (irela
+ 1 < irelaend
13449 && irela
[1].r_offset
== irela
->r_offset
+ 4
13450 && (ELF64_R_TYPE (irela
[1].r_info
)
13451 == R_PPC64_TOCSAVE
))
13453 if (!tocsave_find (htab
, INSERT
,
13454 &local_syms
, irela
+ 1, input_bfd
))
13455 goto error_ret_free_internal
;
13458 stub_type
= ppc_stub_plt_call_r2save
;
13461 /* Support for grouping stub sections. */
13462 id_sec
= htab
->sec_info
[section
->id
].u
.group
->link_sec
;
13464 /* Get the name of this stub. */
13465 stub_name
= ppc_stub_name (id_sec
, sym_sec
, hash
, irela
);
13467 goto error_ret_free_internal
;
13469 stub_entry
= ppc_stub_hash_lookup (&htab
->stub_hash_table
,
13470 stub_name
, FALSE
, FALSE
);
13471 if (stub_entry
!= NULL
)
13473 enum ppc_stub_type old_type
;
13474 /* A stub has already been created, but it may
13475 not be the required type. We shouldn't be
13476 transitioning from plt_call to long_branch
13477 stubs or vice versa, but we might be
13478 upgrading from plt_call to plt_call_r2save or
13479 from long_branch to long_branch_r2off. */
13481 old_type
= stub_entry
->stub_type
;
13487 case ppc_stub_save_res
:
13490 case ppc_stub_plt_call
:
13491 case ppc_stub_plt_call_r2save
:
13492 case ppc_stub_plt_call_notoc
:
13493 case ppc_stub_plt_call_both
:
13494 if (stub_type
== ppc_stub_plt_call
)
13496 else if (stub_type
== ppc_stub_plt_call_r2save
)
13498 if (old_type
== ppc_stub_plt_call_notoc
)
13499 stub_type
= ppc_stub_plt_call_both
;
13501 else if (stub_type
== ppc_stub_plt_call_notoc
)
13503 if (old_type
== ppc_stub_plt_call_r2save
)
13504 stub_type
= ppc_stub_plt_call_both
;
13510 case ppc_stub_plt_branch
:
13511 case ppc_stub_plt_branch_r2off
:
13512 case ppc_stub_plt_branch_notoc
:
13513 case ppc_stub_plt_branch_both
:
13514 old_type
+= (ppc_stub_long_branch
13515 - ppc_stub_plt_branch
);
13516 /* Fall through. */
13517 case ppc_stub_long_branch
:
13518 case ppc_stub_long_branch_r2off
:
13519 case ppc_stub_long_branch_notoc
:
13520 case ppc_stub_long_branch_both
:
13521 if (stub_type
== ppc_stub_long_branch
)
13523 else if (stub_type
== ppc_stub_long_branch_r2off
)
13525 if (old_type
== ppc_stub_long_branch_notoc
)
13526 stub_type
= ppc_stub_long_branch_both
;
13528 else if (stub_type
== ppc_stub_long_branch_notoc
)
13530 if (old_type
== ppc_stub_long_branch_r2off
)
13531 stub_type
= ppc_stub_long_branch_both
;
13537 if (old_type
< stub_type
)
13538 stub_entry
->stub_type
= stub_type
;
13542 stub_entry
= ppc_add_stub (stub_name
, section
, info
);
13543 if (stub_entry
== NULL
)
13546 error_ret_free_internal
:
13547 if (elf_section_data (section
)->relocs
== NULL
)
13548 free (internal_relocs
);
13549 error_ret_free_local
:
13550 if (local_syms
!= NULL
13551 && (symtab_hdr
->contents
13552 != (unsigned char *) local_syms
))
13557 stub_entry
->stub_type
= stub_type
;
13558 if (stub_type
>= ppc_stub_plt_call
13559 && stub_type
<= ppc_stub_plt_call_both
)
13561 stub_entry
->target_value
= sym_value
;
13562 stub_entry
->target_section
= sym_sec
;
13566 stub_entry
->target_value
= code_value
;
13567 stub_entry
->target_section
= code_sec
;
13569 stub_entry
->h
= hash
;
13570 stub_entry
->plt_ent
= plt_ent
;
13571 stub_entry
->symtype
13572 = hash
? hash
->elf
.type
: ELF_ST_TYPE (sym
->st_info
);
13573 stub_entry
->other
= hash
? hash
->elf
.other
: sym
->st_other
;
13576 && (hash
->elf
.root
.type
== bfd_link_hash_defined
13577 || hash
->elf
.root
.type
== bfd_link_hash_defweak
))
13578 htab
->stub_globals
+= 1;
13581 /* We're done with the internal relocs, free them. */
13582 if (elf_section_data (section
)->relocs
!= internal_relocs
)
13583 free (internal_relocs
);
13586 if (local_syms
!= NULL
13587 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
13589 if (!info
->keep_memory
)
13592 symtab_hdr
->contents
= (unsigned char *) local_syms
;
13596 /* We may have added some stubs. Find out the new size of the
13598 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13600 group
->lr_restore
= 0;
13601 group
->eh_size
= 0;
13602 if (group
->stub_sec
!= NULL
)
13604 asection
*stub_sec
= group
->stub_sec
;
13606 if (htab
->stub_iteration
<= STUB_SHRINK_ITER
13607 || stub_sec
->rawsize
< stub_sec
->size
)
13608 /* Past STUB_SHRINK_ITER, rawsize is the max size seen. */
13609 stub_sec
->rawsize
= stub_sec
->size
;
13610 stub_sec
->size
= 0;
13611 stub_sec
->reloc_count
= 0;
13612 stub_sec
->flags
&= ~SEC_RELOC
;
13615 if (htab
->tga_group
!= NULL
)
13617 /* See emit_tga_desc and emit_tga_desc_eh_frame. */
13618 htab
->tga_group
->eh_size
13619 = 1 + 2 + (htab
->opd_abi
!= 0) + 3 + 8 * 2 + 3 + 8 + 3;
13620 htab
->tga_group
->lr_restore
= 23 * 4;
13621 htab
->tga_group
->stub_sec
->size
= 24 * 4;
13624 if (htab
->stub_iteration
<= STUB_SHRINK_ITER
13625 || htab
->brlt
->rawsize
< htab
->brlt
->size
)
13626 htab
->brlt
->rawsize
= htab
->brlt
->size
;
13627 htab
->brlt
->size
= 0;
13628 htab
->brlt
->reloc_count
= 0;
13629 htab
->brlt
->flags
&= ~SEC_RELOC
;
13630 if (htab
->relbrlt
!= NULL
)
13631 htab
->relbrlt
->size
= 0;
13633 bfd_hash_traverse (&htab
->stub_hash_table
, ppc_size_one_stub
, info
);
13635 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13636 if (group
->needs_save_res
)
13637 group
->stub_sec
->size
+= htab
->sfpr
->size
;
13639 if (info
->emitrelocations
13640 && htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
13642 htab
->glink
->reloc_count
= 1;
13643 htab
->glink
->flags
|= SEC_RELOC
;
13646 if (htab
->glink_eh_frame
!= NULL
13647 && !bfd_is_abs_section (htab
->glink_eh_frame
->output_section
)
13648 && htab
->glink_eh_frame
->output_section
->size
> 8)
13650 size_t size
= 0, align
= 4;
13652 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13653 if (group
->eh_size
!= 0)
13654 size
+= (group
->eh_size
+ 17 + align
- 1) & -align
;
13655 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
13656 size
+= (24 + align
- 1) & -align
;
13658 size
+= (sizeof (glink_eh_frame_cie
) + align
- 1) & -align
;
13659 align
= 1ul << htab
->glink_eh_frame
->output_section
->alignment_power
;
13660 size
= (size
+ align
- 1) & -align
;
13661 htab
->glink_eh_frame
->rawsize
= htab
->glink_eh_frame
->size
;
13662 htab
->glink_eh_frame
->size
= size
;
13665 if (htab
->params
->plt_stub_align
!= 0)
13666 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13667 if (group
->stub_sec
!= NULL
)
13669 int align
= abs (htab
->params
->plt_stub_align
);
13670 group
->stub_sec
->size
13671 = (group
->stub_sec
->size
+ (1 << align
) - 1) & -(1 << align
);
13674 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13675 if (group
->stub_sec
!= NULL
13676 && group
->stub_sec
->rawsize
!= group
->stub_sec
->size
13677 && (htab
->stub_iteration
<= STUB_SHRINK_ITER
13678 || group
->stub_sec
->rawsize
< group
->stub_sec
->size
))
13682 && (htab
->brlt
->rawsize
== htab
->brlt
->size
13683 || (htab
->stub_iteration
> STUB_SHRINK_ITER
13684 && htab
->brlt
->rawsize
> htab
->brlt
->size
))
13685 && (htab
->glink_eh_frame
== NULL
13686 || htab
->glink_eh_frame
->rawsize
== htab
->glink_eh_frame
->size
)
13687 && (htab
->tga_group
== NULL
13688 || htab
->stub_iteration
> 1))
13691 /* Ask the linker to do its stuff. */
13692 (*htab
->params
->layout_sections_again
) ();
13695 if (htab
->glink_eh_frame
!= NULL
13696 && htab
->glink_eh_frame
->size
!= 0)
13699 bfd_byte
*p
, *last_fde
;
13700 size_t last_fde_len
, size
, align
, pad
;
13701 struct map_stub
*group
;
13703 /* It is necessary to at least have a rough outline of the
13704 linker generated CIEs and FDEs written before
13705 bfd_elf_discard_info is run, in order for these FDEs to be
13706 indexed in .eh_frame_hdr. */
13707 p
= bfd_zalloc (htab
->glink_eh_frame
->owner
, htab
->glink_eh_frame
->size
);
13710 htab
->glink_eh_frame
->contents
= p
;
13714 memcpy (p
, glink_eh_frame_cie
, sizeof (glink_eh_frame_cie
));
13715 /* CIE length (rewrite in case little-endian). */
13716 last_fde_len
= ((sizeof (glink_eh_frame_cie
) + align
- 1) & -align
) - 4;
13717 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
, p
);
13718 p
+= last_fde_len
+ 4;
13720 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13721 if (group
->eh_size
!= 0)
13723 group
->eh_base
= p
- htab
->glink_eh_frame
->contents
;
13725 last_fde_len
= ((group
->eh_size
+ 17 + align
- 1) & -align
) - 4;
13727 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
, p
);
13730 val
= p
- htab
->glink_eh_frame
->contents
;
13731 bfd_put_32 (htab
->elf
.dynobj
, val
, p
);
13733 /* Offset to stub section, written later. */
13735 /* stub section size. */
13736 bfd_put_32 (htab
->elf
.dynobj
, group
->stub_sec
->size
, p
);
13738 /* Augmentation. */
13740 /* Make sure we don't have all nops. This is enough for
13741 elf-eh-frame.c to detect the last non-nop opcode. */
13742 p
[group
->eh_size
- 1] = DW_CFA_advance_loc
+ 1;
13743 p
= last_fde
+ last_fde_len
+ 4;
13745 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
13748 last_fde_len
= ((24 + align
- 1) & -align
) - 4;
13750 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
, p
);
13753 val
= p
- htab
->glink_eh_frame
->contents
;
13754 bfd_put_32 (htab
->elf
.dynobj
, val
, p
);
13756 /* Offset to .glink, written later. */
13759 bfd_put_32 (htab
->elf
.dynobj
, htab
->glink
->size
- 8, p
);
13761 /* Augmentation. */
13764 *p
++ = DW_CFA_advance_loc
+ 1;
13765 *p
++ = DW_CFA_register
;
13767 *p
++ = htab
->opd_abi
? 12 : 0;
13768 *p
++ = DW_CFA_advance_loc
+ (htab
->opd_abi
? 5 : 7);
13769 *p
++ = DW_CFA_restore_extended
;
13771 p
+= ((24 + align
- 1) & -align
) - 24;
13773 /* Subsume any padding into the last FDE if user .eh_frame
13774 sections are aligned more than glink_eh_frame. Otherwise any
13775 zero padding will be seen as a terminator. */
13776 align
= 1ul << htab
->glink_eh_frame
->output_section
->alignment_power
;
13777 size
= p
- htab
->glink_eh_frame
->contents
;
13778 pad
= ((size
+ align
- 1) & -align
) - size
;
13779 htab
->glink_eh_frame
->size
= size
+ pad
;
13780 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
+ pad
, last_fde
);
13783 maybe_strip_output (info
, htab
->brlt
);
13784 if (htab
->relbrlt
!= NULL
)
13785 maybe_strip_output (info
, htab
->relbrlt
);
13786 if (htab
->glink_eh_frame
!= NULL
)
13787 maybe_strip_output (info
, htab
->glink_eh_frame
);
13792 /* Called after we have determined section placement. If sections
13793 move, we'll be called again. Provide a value for TOCstart. */
13796 ppc64_elf_set_toc (struct bfd_link_info
*info
, bfd
*obfd
)
13799 bfd_vma TOCstart
, adjust
;
13803 struct elf_link_hash_entry
*h
;
13804 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
13806 if (is_elf_hash_table (htab
)
13807 && htab
->hgot
!= NULL
)
13811 h
= elf_link_hash_lookup (htab
, ".TOC.", FALSE
, FALSE
, TRUE
);
13812 if (is_elf_hash_table (htab
))
13816 && h
->root
.type
== bfd_link_hash_defined
13817 && !h
->root
.linker_def
13818 && (!is_elf_hash_table (htab
)
13819 || h
->def_regular
))
13821 TOCstart
= defined_sym_val (h
) - TOC_BASE_OFF
;
13822 _bfd_set_gp_value (obfd
, TOCstart
);
13827 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
13828 order. The TOC starts where the first of these sections starts. */
13829 s
= bfd_get_section_by_name (obfd
, ".got");
13830 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13831 s
= bfd_get_section_by_name (obfd
, ".toc");
13832 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13833 s
= bfd_get_section_by_name (obfd
, ".tocbss");
13834 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13835 s
= bfd_get_section_by_name (obfd
, ".plt");
13836 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13838 /* This may happen for
13839 o references to TOC base (SYM@toc / TOC[tc0]) without a
13841 o bad linker script
13842 o --gc-sections and empty TOC sections
13844 FIXME: Warn user? */
13846 /* Look for a likely section. We probably won't even be
13848 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13849 if ((s
->flags
& (SEC_ALLOC
| SEC_SMALL_DATA
| SEC_READONLY
13851 == (SEC_ALLOC
| SEC_SMALL_DATA
))
13854 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13855 if ((s
->flags
& (SEC_ALLOC
| SEC_SMALL_DATA
| SEC_EXCLUDE
))
13856 == (SEC_ALLOC
| SEC_SMALL_DATA
))
13859 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13860 if ((s
->flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_EXCLUDE
))
13864 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13865 if ((s
->flags
& (SEC_ALLOC
| SEC_EXCLUDE
)) == SEC_ALLOC
)
13871 TOCstart
= s
->output_section
->vma
+ s
->output_offset
;
13873 /* Force alignment. */
13874 adjust
= TOCstart
& (TOC_BASE_ALIGN
- 1);
13875 TOCstart
-= adjust
;
13876 _bfd_set_gp_value (obfd
, TOCstart
);
13878 if (info
!= NULL
&& s
!= NULL
)
13880 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
13884 if (htab
->elf
.hgot
!= NULL
)
13886 htab
->elf
.hgot
->root
.u
.def
.value
= TOC_BASE_OFF
- adjust
;
13887 htab
->elf
.hgot
->root
.u
.def
.section
= s
;
13892 struct bfd_link_hash_entry
*bh
= NULL
;
13893 _bfd_generic_link_add_one_symbol (info
, obfd
, ".TOC.", BSF_GLOBAL
,
13894 s
, TOC_BASE_OFF
- adjust
,
13895 NULL
, FALSE
, FALSE
, &bh
);
13901 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
13902 write out any global entry stubs, and PLT relocations. */
13905 build_global_entry_stubs_and_plt (struct elf_link_hash_entry
*h
, void *inf
)
13907 struct bfd_link_info
*info
;
13908 struct ppc_link_hash_table
*htab
;
13909 struct plt_entry
*ent
;
13912 if (h
->root
.type
== bfd_link_hash_indirect
)
13916 htab
= ppc_hash_table (info
);
13920 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
13921 if (ent
->plt
.offset
!= (bfd_vma
) -1)
13923 /* This symbol has an entry in the procedure linkage
13924 table. Set it up. */
13925 Elf_Internal_Rela rela
;
13926 asection
*plt
, *relplt
;
13929 if (!htab
->elf
.dynamic_sections_created
13930 || h
->dynindx
== -1)
13932 if (!(h
->def_regular
13933 && (h
->root
.type
== bfd_link_hash_defined
13934 || h
->root
.type
== bfd_link_hash_defweak
)))
13936 if (h
->type
== STT_GNU_IFUNC
)
13938 plt
= htab
->elf
.iplt
;
13939 relplt
= htab
->elf
.irelplt
;
13940 htab
->local_ifunc_resolver
= 1;
13942 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_IREL
);
13944 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
13948 plt
= htab
->pltlocal
;
13949 if (bfd_link_pic (info
))
13951 relplt
= htab
->relpltlocal
;
13953 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_SLOT
);
13955 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
13960 rela
.r_addend
= defined_sym_val (h
) + ent
->addend
;
13962 if (relplt
== NULL
)
13964 loc
= plt
->contents
+ ent
->plt
.offset
;
13965 bfd_put_64 (info
->output_bfd
, rela
.r_addend
, loc
);
13968 bfd_vma toc
= elf_gp (info
->output_bfd
);
13969 toc
+= htab
->sec_info
[h
->root
.u
.def
.section
->id
].toc_off
;
13970 bfd_put_64 (info
->output_bfd
, toc
, loc
+ 8);
13975 rela
.r_offset
= (plt
->output_section
->vma
13976 + plt
->output_offset
13977 + ent
->plt
.offset
);
13978 loc
= relplt
->contents
+ (relplt
->reloc_count
++
13979 * sizeof (Elf64_External_Rela
));
13980 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rela
, loc
);
13985 rela
.r_offset
= (htab
->elf
.splt
->output_section
->vma
13986 + htab
->elf
.splt
->output_offset
13987 + ent
->plt
.offset
);
13988 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_PPC64_JMP_SLOT
);
13989 rela
.r_addend
= ent
->addend
;
13990 loc
= (htab
->elf
.srelplt
->contents
13991 + ((ent
->plt
.offset
- PLT_INITIAL_ENTRY_SIZE (htab
))
13992 / PLT_ENTRY_SIZE (htab
) * sizeof (Elf64_External_Rela
)));
13993 if (h
->type
== STT_GNU_IFUNC
&& is_static_defined (h
))
13994 htab
->maybe_local_ifunc_resolver
= 1;
13995 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rela
, loc
);
13999 if (!h
->pointer_equality_needed
)
14002 if (h
->def_regular
)
14005 s
= htab
->global_entry
;
14006 if (s
== NULL
|| s
->size
== 0)
14009 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
14010 if (ent
->plt
.offset
!= (bfd_vma
) -1
14011 && ent
->addend
== 0)
14017 p
= s
->contents
+ h
->root
.u
.def
.value
;
14018 plt
= htab
->elf
.splt
;
14019 if (!htab
->elf
.dynamic_sections_created
14020 || h
->dynindx
== -1)
14022 if (h
->type
== STT_GNU_IFUNC
)
14023 plt
= htab
->elf
.iplt
;
14025 plt
= htab
->pltlocal
;
14027 off
= ent
->plt
.offset
+ plt
->output_offset
+ plt
->output_section
->vma
;
14028 off
-= h
->root
.u
.def
.value
+ s
->output_offset
+ s
->output_section
->vma
;
14030 if (off
+ 0x80008000 > 0xffffffff || (off
& 3) != 0)
14032 info
->callbacks
->einfo
14033 (_("%P: linkage table error against `%pT'\n"),
14034 h
->root
.root
.string
);
14035 bfd_set_error (bfd_error_bad_value
);
14036 htab
->stub_error
= TRUE
;
14039 htab
->stub_count
[ppc_stub_global_entry
- 1] += 1;
14040 if (htab
->params
->emit_stub_syms
)
14042 size_t len
= strlen (h
->root
.root
.string
);
14043 char *name
= bfd_malloc (sizeof "12345678.global_entry." + len
);
14048 sprintf (name
, "%08x.global_entry.%s", s
->id
, h
->root
.root
.string
);
14049 h
= elf_link_hash_lookup (&htab
->elf
, name
, TRUE
, FALSE
, FALSE
);
14052 if (h
->root
.type
== bfd_link_hash_new
)
14054 h
->root
.type
= bfd_link_hash_defined
;
14055 h
->root
.u
.def
.section
= s
;
14056 h
->root
.u
.def
.value
= p
- s
->contents
;
14057 h
->ref_regular
= 1;
14058 h
->def_regular
= 1;
14059 h
->ref_regular_nonweak
= 1;
14060 h
->forced_local
= 1;
14062 h
->root
.linker_def
= 1;
14066 if (PPC_HA (off
) != 0)
14068 bfd_put_32 (s
->owner
, ADDIS_R12_R12
| PPC_HA (off
), p
);
14071 bfd_put_32 (s
->owner
, LD_R12_0R12
| PPC_LO (off
), p
);
14073 bfd_put_32 (s
->owner
, MTCTR_R12
, p
);
14075 bfd_put_32 (s
->owner
, BCTR
, p
);
14081 /* Write PLT relocs for locals. */
14084 write_plt_relocs_for_local_syms (struct bfd_link_info
*info
)
14086 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
14089 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
14091 struct got_entry
**lgot_ents
, **end_lgot_ents
;
14092 struct plt_entry
**local_plt
, **lplt
, **end_local_plt
;
14093 Elf_Internal_Shdr
*symtab_hdr
;
14094 bfd_size_type locsymcount
;
14095 Elf_Internal_Sym
*local_syms
= NULL
;
14096 struct plt_entry
*ent
;
14098 if (!is_ppc64_elf (ibfd
))
14101 lgot_ents
= elf_local_got_ents (ibfd
);
14105 symtab_hdr
= &elf_symtab_hdr (ibfd
);
14106 locsymcount
= symtab_hdr
->sh_info
;
14107 end_lgot_ents
= lgot_ents
+ locsymcount
;
14108 local_plt
= (struct plt_entry
**) end_lgot_ents
;
14109 end_local_plt
= local_plt
+ locsymcount
;
14110 for (lplt
= local_plt
; lplt
< end_local_plt
; ++lplt
)
14111 for (ent
= *lplt
; ent
!= NULL
; ent
= ent
->next
)
14112 if (ent
->plt
.offset
!= (bfd_vma
) -1)
14114 Elf_Internal_Sym
*sym
;
14116 asection
*plt
, *relplt
;
14120 if (!get_sym_h (NULL
, &sym
, &sym_sec
, NULL
, &local_syms
,
14121 lplt
- local_plt
, ibfd
))
14123 if (local_syms
!= NULL
14124 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
14129 val
= sym
->st_value
+ ent
->addend
;
14130 if (ELF_ST_TYPE (sym
->st_info
) != STT_GNU_IFUNC
)
14131 val
+= PPC64_LOCAL_ENTRY_OFFSET (sym
->st_other
);
14132 if (sym_sec
!= NULL
&& sym_sec
->output_section
!= NULL
)
14133 val
+= sym_sec
->output_offset
+ sym_sec
->output_section
->vma
;
14135 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
14137 htab
->local_ifunc_resolver
= 1;
14138 plt
= htab
->elf
.iplt
;
14139 relplt
= htab
->elf
.irelplt
;
14143 plt
= htab
->pltlocal
;
14144 relplt
= bfd_link_pic (info
) ? htab
->relpltlocal
: NULL
;
14147 if (relplt
== NULL
)
14149 loc
= plt
->contents
+ ent
->plt
.offset
;
14150 bfd_put_64 (info
->output_bfd
, val
, loc
);
14153 bfd_vma toc
= elf_gp (ibfd
);
14154 bfd_put_64 (info
->output_bfd
, toc
, loc
+ 8);
14159 Elf_Internal_Rela rela
;
14160 rela
.r_offset
= (ent
->plt
.offset
14161 + plt
->output_offset
14162 + plt
->output_section
->vma
);
14163 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
14166 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_IREL
);
14168 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
14173 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_SLOT
);
14175 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
14177 rela
.r_addend
= val
;
14178 loc
= relplt
->contents
+ (relplt
->reloc_count
++
14179 * sizeof (Elf64_External_Rela
));
14180 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rela
, loc
);
14184 if (local_syms
!= NULL
14185 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
14187 if (!info
->keep_memory
)
14190 symtab_hdr
->contents
= (unsigned char *) local_syms
;
14196 /* Emit the static wrapper function preserving registers around a
14197 __tls_get_addr_opt call. */
14200 emit_tga_desc (struct ppc_link_hash_table
*htab
)
14202 asection
*stub_sec
= htab
->tga_group
->stub_sec
;
14203 unsigned int cfa_updt
= 11 * 4;
14205 bfd_vma to
, from
, delta
;
14207 BFD_ASSERT (htab
->tga_desc_fd
->elf
.root
.type
== bfd_link_hash_defined
14208 && htab
->tga_desc_fd
->elf
.root
.u
.def
.section
== stub_sec
14209 && htab
->tga_desc_fd
->elf
.root
.u
.def
.value
== 0);
14210 to
= defined_sym_val (&htab
->tls_get_addr_fd
->elf
);
14211 from
= defined_sym_val (&htab
->tga_desc_fd
->elf
) + cfa_updt
;
14213 if (delta
+ (1 << 25) >= 1 << 26)
14215 _bfd_error_handler (_("__tls_get_addr call offset overflow"));
14216 htab
->stub_error
= TRUE
;
14220 p
= stub_sec
->contents
;
14221 p
= tls_get_addr_prologue (htab
->elf
.dynobj
, p
, htab
);
14222 bfd_put_32 (stub_sec
->owner
, B_DOT
| 1 | (delta
& 0x3fffffc), p
);
14224 p
= tls_get_addr_epilogue (htab
->elf
.dynobj
, p
, htab
);
14225 return stub_sec
->size
== (bfd_size_type
) (p
- stub_sec
->contents
);
14228 /* Emit eh_frame describing the static wrapper function. */
14231 emit_tga_desc_eh_frame (struct ppc_link_hash_table
*htab
, bfd_byte
*p
)
14233 unsigned int cfa_updt
= 11 * 4;
14236 *p
++ = DW_CFA_advance_loc
+ cfa_updt
/ 4;
14237 *p
++ = DW_CFA_def_cfa_offset
;
14245 *p
++ = DW_CFA_offset_extended_sf
;
14247 *p
++ = (-16 / 8) & 0x7f;
14248 for (i
= 4; i
< 12; i
++)
14250 *p
++ = DW_CFA_offset
+ i
;
14251 *p
++ = (htab
->opd_abi
? 13 : 12) - i
;
14253 *p
++ = DW_CFA_advance_loc
+ 10;
14254 *p
++ = DW_CFA_def_cfa_offset
;
14256 for (i
= 4; i
< 12; i
++)
14257 *p
++ = DW_CFA_restore
+ i
;
14258 *p
++ = DW_CFA_advance_loc
+ 2;
14259 *p
++ = DW_CFA_restore_extended
;
14264 /* Build all the stubs associated with the current output file.
14265 The stubs are kept in a hash table attached to the main linker
14266 hash table. This function is called via gldelf64ppc_finish. */
14269 ppc64_elf_build_stubs (struct bfd_link_info
*info
,
14272 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
14273 struct map_stub
*group
;
14274 asection
*stub_sec
;
14276 int stub_sec_count
= 0;
14281 /* Allocate memory to hold the linker stubs. */
14282 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14284 group
->eh_size
= 0;
14285 group
->lr_restore
= 0;
14286 if ((stub_sec
= group
->stub_sec
) != NULL
14287 && stub_sec
->size
!= 0)
14289 stub_sec
->contents
= bfd_zalloc (htab
->params
->stub_bfd
,
14291 if (stub_sec
->contents
== NULL
)
14293 stub_sec
->size
= 0;
14297 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
14302 /* Build the .glink plt call stub. */
14303 if (htab
->params
->emit_stub_syms
)
14305 struct elf_link_hash_entry
*h
;
14306 h
= elf_link_hash_lookup (&htab
->elf
, "__glink_PLTresolve",
14307 TRUE
, FALSE
, FALSE
);
14310 if (h
->root
.type
== bfd_link_hash_new
)
14312 h
->root
.type
= bfd_link_hash_defined
;
14313 h
->root
.u
.def
.section
= htab
->glink
;
14314 h
->root
.u
.def
.value
= 8;
14315 h
->ref_regular
= 1;
14316 h
->def_regular
= 1;
14317 h
->ref_regular_nonweak
= 1;
14318 h
->forced_local
= 1;
14320 h
->root
.linker_def
= 1;
14323 plt0
= (htab
->elf
.splt
->output_section
->vma
14324 + htab
->elf
.splt
->output_offset
14326 if (info
->emitrelocations
)
14328 Elf_Internal_Rela
*r
= get_relocs (htab
->glink
, 1);
14331 r
->r_offset
= (htab
->glink
->output_offset
14332 + htab
->glink
->output_section
->vma
);
14333 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL64
);
14334 r
->r_addend
= plt0
;
14336 p
= htab
->glink
->contents
;
14337 plt0
-= htab
->glink
->output_section
->vma
+ htab
->glink
->output_offset
;
14338 bfd_put_64 (htab
->glink
->owner
, plt0
, p
);
14342 bfd_put_32 (htab
->glink
->owner
, MFLR_R12
, p
);
14344 bfd_put_32 (htab
->glink
->owner
, BCL_20_31
, p
);
14346 bfd_put_32 (htab
->glink
->owner
, MFLR_R11
, p
);
14348 bfd_put_32 (htab
->glink
->owner
, LD_R2_0R11
| (-16 & 0xfffc), p
);
14350 bfd_put_32 (htab
->glink
->owner
, MTLR_R12
, p
);
14352 bfd_put_32 (htab
->glink
->owner
, ADD_R11_R2_R11
, p
);
14354 bfd_put_32 (htab
->glink
->owner
, LD_R12_0R11
, p
);
14356 bfd_put_32 (htab
->glink
->owner
, LD_R2_0R11
| 8, p
);
14358 bfd_put_32 (htab
->glink
->owner
, MTCTR_R12
, p
);
14360 bfd_put_32 (htab
->glink
->owner
, LD_R11_0R11
| 16, p
);
14365 bfd_put_32 (htab
->glink
->owner
, MFLR_R0
, p
);
14367 bfd_put_32 (htab
->glink
->owner
, BCL_20_31
, p
);
14369 bfd_put_32 (htab
->glink
->owner
, MFLR_R11
, p
);
14371 bfd_put_32 (htab
->glink
->owner
, STD_R2_0R1
+ 24, p
);
14373 bfd_put_32 (htab
->glink
->owner
, LD_R2_0R11
| (-16 & 0xfffc), p
);
14375 bfd_put_32 (htab
->glink
->owner
, MTLR_R0
, p
);
14377 bfd_put_32 (htab
->glink
->owner
, SUB_R12_R12_R11
, p
);
14379 bfd_put_32 (htab
->glink
->owner
, ADD_R11_R2_R11
, p
);
14381 bfd_put_32 (htab
->glink
->owner
, ADDI_R0_R12
| (-48 & 0xffff), p
);
14383 bfd_put_32 (htab
->glink
->owner
, LD_R12_0R11
, p
);
14385 bfd_put_32 (htab
->glink
->owner
, SRDI_R0_R0_2
, p
);
14387 bfd_put_32 (htab
->glink
->owner
, MTCTR_R12
, p
);
14389 bfd_put_32 (htab
->glink
->owner
, LD_R11_0R11
| 8, p
);
14392 bfd_put_32 (htab
->glink
->owner
, BCTR
, p
);
14394 BFD_ASSERT (p
== htab
->glink
->contents
+ GLINK_PLTRESOLVE_SIZE (htab
));
14396 /* Build the .glink lazy link call stubs. */
14398 while (p
< htab
->glink
->contents
+ htab
->glink
->size
)
14404 bfd_put_32 (htab
->glink
->owner
, LI_R0_0
| indx
, p
);
14409 bfd_put_32 (htab
->glink
->owner
, LIS_R0_0
| PPC_HI (indx
), p
);
14411 bfd_put_32 (htab
->glink
->owner
, ORI_R0_R0_0
| PPC_LO (indx
),
14416 bfd_put_32 (htab
->glink
->owner
,
14417 B_DOT
| ((htab
->glink
->contents
- p
+ 8) & 0x3fffffc), p
);
14423 if (htab
->tga_group
!= NULL
)
14425 htab
->tga_group
->lr_restore
= 23 * 4;
14426 htab
->tga_group
->stub_sec
->size
= 24 * 4;
14427 if (!emit_tga_desc (htab
))
14429 if (htab
->glink_eh_frame
!= NULL
14430 && htab
->glink_eh_frame
->size
!= 0)
14434 p
= htab
->glink_eh_frame
->contents
;
14435 p
+= (sizeof (glink_eh_frame_cie
) + align
- 1) & -align
;
14437 htab
->tga_group
->eh_size
= emit_tga_desc_eh_frame (htab
, p
) - p
;
14441 /* Build .glink global entry stubs, and PLT relocs for globals. */
14442 elf_link_hash_traverse (&htab
->elf
, build_global_entry_stubs_and_plt
, info
);
14444 if (!write_plt_relocs_for_local_syms (info
))
14447 if (htab
->brlt
!= NULL
&& htab
->brlt
->size
!= 0)
14449 htab
->brlt
->contents
= bfd_zalloc (htab
->brlt
->owner
,
14451 if (htab
->brlt
->contents
== NULL
)
14454 if (htab
->relbrlt
!= NULL
&& htab
->relbrlt
->size
!= 0)
14456 htab
->relbrlt
->contents
= bfd_zalloc (htab
->relbrlt
->owner
,
14457 htab
->relbrlt
->size
);
14458 if (htab
->relbrlt
->contents
== NULL
)
14462 /* Build the stubs as directed by the stub hash table. */
14463 bfd_hash_traverse (&htab
->stub_hash_table
, ppc_build_one_stub
, info
);
14465 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14466 if (group
->needs_save_res
)
14467 group
->stub_sec
->size
+= htab
->sfpr
->size
;
14469 if (htab
->relbrlt
!= NULL
)
14470 htab
->relbrlt
->reloc_count
= 0;
14472 if (htab
->params
->plt_stub_align
!= 0)
14473 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14474 if ((stub_sec
= group
->stub_sec
) != NULL
)
14476 int align
= abs (htab
->params
->plt_stub_align
);
14477 stub_sec
->size
= (stub_sec
->size
+ (1 << align
) - 1) & -(1 << align
);
14480 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14481 if (group
->needs_save_res
)
14483 stub_sec
= group
->stub_sec
;
14484 memcpy (stub_sec
->contents
+ stub_sec
->size
- htab
->sfpr
->size
,
14485 htab
->sfpr
->contents
, htab
->sfpr
->size
);
14486 if (htab
->params
->emit_stub_syms
)
14490 for (i
= 0; i
< ARRAY_SIZE (save_res_funcs
); i
++)
14491 if (!sfpr_define (info
, &save_res_funcs
[i
], stub_sec
))
14496 if (htab
->glink_eh_frame
!= NULL
14497 && htab
->glink_eh_frame
->size
!= 0)
14502 p
= htab
->glink_eh_frame
->contents
;
14503 p
+= (sizeof (glink_eh_frame_cie
) + align
- 1) & -align
;
14505 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14506 if (group
->eh_size
!= 0)
14508 /* Offset to stub section. */
14509 val
= (group
->stub_sec
->output_section
->vma
14510 + group
->stub_sec
->output_offset
);
14511 val
-= (htab
->glink_eh_frame
->output_section
->vma
14512 + htab
->glink_eh_frame
->output_offset
14513 + (p
+ 8 - htab
->glink_eh_frame
->contents
));
14514 if (val
+ 0x80000000 > 0xffffffff)
14517 (_("%s offset too large for .eh_frame sdata4 encoding"),
14518 group
->stub_sec
->name
);
14521 bfd_put_32 (htab
->elf
.dynobj
, val
, p
+ 8);
14522 p
+= (group
->eh_size
+ 17 + 3) & -4;
14524 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
14526 /* Offset to .glink. */
14527 val
= (htab
->glink
->output_section
->vma
14528 + htab
->glink
->output_offset
14530 val
-= (htab
->glink_eh_frame
->output_section
->vma
14531 + htab
->glink_eh_frame
->output_offset
14532 + (p
+ 8 - htab
->glink_eh_frame
->contents
));
14533 if (val
+ 0x80000000 > 0xffffffff)
14536 (_("%s offset too large for .eh_frame sdata4 encoding"),
14537 htab
->glink
->name
);
14540 bfd_put_32 (htab
->elf
.dynobj
, val
, p
+ 8);
14541 p
+= (24 + align
- 1) & -align
;
14545 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14546 if ((stub_sec
= group
->stub_sec
) != NULL
)
14548 stub_sec_count
+= 1;
14549 if (stub_sec
->rawsize
!= stub_sec
->size
14550 && (htab
->stub_iteration
<= STUB_SHRINK_ITER
14551 || stub_sec
->rawsize
< stub_sec
->size
))
14557 htab
->stub_error
= TRUE
;
14558 _bfd_error_handler (_("stubs don't match calculated size"));
14561 if (htab
->stub_error
)
14567 if (asprintf (&groupmsg
,
14568 ngettext ("linker stubs in %u group\n",
14569 "linker stubs in %u groups\n",
14571 stub_sec_count
) < 0)
14575 if (asprintf (stats
, _("%s"
14577 " branch toc adj %lu\n"
14578 " branch notoc %lu\n"
14579 " branch both %lu\n"
14580 " long branch %lu\n"
14581 " long toc adj %lu\n"
14582 " long notoc %lu\n"
14585 " plt call save %lu\n"
14586 " plt call notoc %lu\n"
14587 " plt call both %lu\n"
14588 " global entry %lu"),
14590 htab
->stub_count
[ppc_stub_long_branch
- 1],
14591 htab
->stub_count
[ppc_stub_long_branch_r2off
- 1],
14592 htab
->stub_count
[ppc_stub_long_branch_notoc
- 1],
14593 htab
->stub_count
[ppc_stub_long_branch_both
- 1],
14594 htab
->stub_count
[ppc_stub_plt_branch
- 1],
14595 htab
->stub_count
[ppc_stub_plt_branch_r2off
- 1],
14596 htab
->stub_count
[ppc_stub_plt_branch_notoc
- 1],
14597 htab
->stub_count
[ppc_stub_plt_branch_both
- 1],
14598 htab
->stub_count
[ppc_stub_plt_call
- 1],
14599 htab
->stub_count
[ppc_stub_plt_call_r2save
- 1],
14600 htab
->stub_count
[ppc_stub_plt_call_notoc
- 1],
14601 htab
->stub_count
[ppc_stub_plt_call_both
- 1],
14602 htab
->stub_count
[ppc_stub_global_entry
- 1]) < 0)
14610 /* What to do when ld finds relocations against symbols defined in
14611 discarded sections. */
14613 static unsigned int
14614 ppc64_elf_action_discarded (asection
*sec
)
14616 if (strcmp (".opd", sec
->name
) == 0)
14619 if (strcmp (".toc", sec
->name
) == 0)
14622 if (strcmp (".toc1", sec
->name
) == 0)
14625 return _bfd_elf_default_action_discarded (sec
);
14628 /* These are the dynamic relocations supported by glibc. */
14631 ppc64_glibc_dynamic_reloc (enum elf_ppc64_reloc_type r_type
)
14635 case R_PPC64_RELATIVE
:
14637 case R_PPC64_ADDR64
:
14638 case R_PPC64_GLOB_DAT
:
14639 case R_PPC64_IRELATIVE
:
14640 case R_PPC64_JMP_IREL
:
14641 case R_PPC64_JMP_SLOT
:
14642 case R_PPC64_DTPMOD64
:
14643 case R_PPC64_DTPREL64
:
14644 case R_PPC64_TPREL64
:
14645 case R_PPC64_TPREL16_LO_DS
:
14646 case R_PPC64_TPREL16_DS
:
14647 case R_PPC64_TPREL16
:
14648 case R_PPC64_TPREL16_LO
:
14649 case R_PPC64_TPREL16_HI
:
14650 case R_PPC64_TPREL16_HIGH
:
14651 case R_PPC64_TPREL16_HA
:
14652 case R_PPC64_TPREL16_HIGHA
:
14653 case R_PPC64_TPREL16_HIGHER
:
14654 case R_PPC64_TPREL16_HIGHEST
:
14655 case R_PPC64_TPREL16_HIGHERA
:
14656 case R_PPC64_TPREL16_HIGHESTA
:
14657 case R_PPC64_ADDR16_LO_DS
:
14658 case R_PPC64_ADDR16_LO
:
14659 case R_PPC64_ADDR16_HI
:
14660 case R_PPC64_ADDR16_HIGH
:
14661 case R_PPC64_ADDR16_HA
:
14662 case R_PPC64_ADDR16_HIGHA
:
14663 case R_PPC64_REL30
:
14665 case R_PPC64_UADDR64
:
14666 case R_PPC64_UADDR32
:
14667 case R_PPC64_ADDR32
:
14668 case R_PPC64_ADDR24
:
14669 case R_PPC64_ADDR16
:
14670 case R_PPC64_UADDR16
:
14671 case R_PPC64_ADDR16_DS
:
14672 case R_PPC64_ADDR16_HIGHER
:
14673 case R_PPC64_ADDR16_HIGHEST
:
14674 case R_PPC64_ADDR16_HIGHERA
:
14675 case R_PPC64_ADDR16_HIGHESTA
:
14676 case R_PPC64_ADDR14
:
14677 case R_PPC64_ADDR14_BRTAKEN
:
14678 case R_PPC64_ADDR14_BRNTAKEN
:
14679 case R_PPC64_REL32
:
14680 case R_PPC64_REL64
:
14688 /* The RELOCATE_SECTION function is called by the ELF backend linker
14689 to handle the relocations for a section.
14691 The relocs are always passed as Rela structures; if the section
14692 actually uses Rel structures, the r_addend field will always be
14695 This function is responsible for adjust the section contents as
14696 necessary, and (if using Rela relocs and generating a
14697 relocatable output file) adjusting the reloc addend as
14700 This function does not have to worry about setting the reloc
14701 address or the reloc symbol index.
14703 LOCAL_SYMS is a pointer to the swapped in local symbols.
14705 LOCAL_SECTIONS is an array giving the section in the input file
14706 corresponding to the st_shndx field of each local symbol.
14708 The global hash table entry for the global symbols can be found
14709 via elf_sym_hashes (input_bfd).
14711 When generating relocatable output, this function must handle
14712 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
14713 going to be the section symbol corresponding to the output
14714 section, which means that the addend must be adjusted
14718 ppc64_elf_relocate_section (bfd
*output_bfd
,
14719 struct bfd_link_info
*info
,
14721 asection
*input_section
,
14722 bfd_byte
*contents
,
14723 Elf_Internal_Rela
*relocs
,
14724 Elf_Internal_Sym
*local_syms
,
14725 asection
**local_sections
)
14727 struct ppc_link_hash_table
*htab
;
14728 Elf_Internal_Shdr
*symtab_hdr
;
14729 struct elf_link_hash_entry
**sym_hashes
;
14730 Elf_Internal_Rela
*rel
;
14731 Elf_Internal_Rela
*wrel
;
14732 Elf_Internal_Rela
*relend
;
14733 Elf_Internal_Rela outrel
;
14735 struct got_entry
**local_got_ents
;
14737 bfd_boolean ret
= TRUE
;
14738 bfd_boolean is_opd
;
14739 /* Assume 'at' branch hints. */
14740 bfd_boolean is_isa_v2
= TRUE
;
14741 bfd_boolean warned_dynamic
= FALSE
;
14742 bfd_vma d_offset
= (bfd_big_endian (input_bfd
) ? 2 : 0);
14744 /* Initialize howto table if needed. */
14745 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
14748 htab
= ppc_hash_table (info
);
14752 /* Don't relocate stub sections. */
14753 if (input_section
->owner
== htab
->params
->stub_bfd
)
14756 if (!is_ppc64_elf (input_bfd
))
14758 bfd_set_error (bfd_error_wrong_format
);
14762 local_got_ents
= elf_local_got_ents (input_bfd
);
14763 TOCstart
= elf_gp (output_bfd
);
14764 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
14765 sym_hashes
= elf_sym_hashes (input_bfd
);
14766 is_opd
= ppc64_elf_section_data (input_section
)->sec_type
== sec_opd
;
14768 rel
= wrel
= relocs
;
14769 relend
= relocs
+ input_section
->reloc_count
;
14770 for (; rel
< relend
; wrel
++, rel
++)
14772 enum elf_ppc64_reloc_type r_type
;
14774 bfd_reloc_status_type r
;
14775 Elf_Internal_Sym
*sym
;
14777 struct elf_link_hash_entry
*h_elf
;
14778 struct ppc_link_hash_entry
*h
;
14779 struct ppc_link_hash_entry
*fdh
;
14780 const char *sym_name
;
14781 unsigned long r_symndx
, toc_symndx
;
14782 bfd_vma toc_addend
;
14783 unsigned char tls_mask
, tls_gd
, tls_type
;
14784 unsigned char sym_type
;
14785 bfd_vma relocation
;
14786 bfd_boolean unresolved_reloc
, save_unresolved_reloc
;
14787 bfd_boolean warned
;
14788 enum { DEST_NORMAL
, DEST_OPD
, DEST_STUB
} reloc_dest
;
14791 struct ppc_stub_hash_entry
*stub_entry
;
14792 bfd_vma max_br_offset
;
14794 Elf_Internal_Rela orig_rel
;
14795 reloc_howto_type
*howto
;
14796 struct reloc_howto_struct alt_howto
;
14803 r_type
= ELF64_R_TYPE (rel
->r_info
);
14804 r_symndx
= ELF64_R_SYM (rel
->r_info
);
14806 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
14807 symbol of the previous ADDR64 reloc. The symbol gives us the
14808 proper TOC base to use. */
14809 if (rel
->r_info
== ELF64_R_INFO (0, R_PPC64_TOC
)
14811 && ELF64_R_TYPE (wrel
[-1].r_info
) == R_PPC64_ADDR64
14813 r_symndx
= ELF64_R_SYM (wrel
[-1].r_info
);
14819 unresolved_reloc
= FALSE
;
14822 if (r_symndx
< symtab_hdr
->sh_info
)
14824 /* It's a local symbol. */
14825 struct _opd_sec_data
*opd
;
14827 sym
= local_syms
+ r_symndx
;
14828 sec
= local_sections
[r_symndx
];
14829 sym_name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
, sec
);
14830 sym_type
= ELF64_ST_TYPE (sym
->st_info
);
14831 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
14832 opd
= get_opd_info (sec
);
14833 if (opd
!= NULL
&& opd
->adjust
!= NULL
)
14835 long adjust
= opd
->adjust
[OPD_NDX (sym
->st_value
14841 /* If this is a relocation against the opd section sym
14842 and we have edited .opd, adjust the reloc addend so
14843 that ld -r and ld --emit-relocs output is correct.
14844 If it is a reloc against some other .opd symbol,
14845 then the symbol value will be adjusted later. */
14846 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
14847 rel
->r_addend
+= adjust
;
14849 relocation
+= adjust
;
14855 bfd_boolean ignored
;
14857 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
14858 r_symndx
, symtab_hdr
, sym_hashes
,
14859 h_elf
, sec
, relocation
,
14860 unresolved_reloc
, warned
, ignored
);
14861 sym_name
= h_elf
->root
.root
.string
;
14862 sym_type
= h_elf
->type
;
14864 && sec
->owner
== output_bfd
14865 && strcmp (sec
->name
, ".opd") == 0)
14867 /* This is a symbol defined in a linker script. All
14868 such are defined in output sections, even those
14869 defined by simple assignment from a symbol defined in
14870 an input section. Transfer the symbol to an
14871 appropriate input .opd section, so that a branch to
14872 this symbol will be mapped to the location specified
14873 by the opd entry. */
14874 struct bfd_link_order
*lo
;
14875 for (lo
= sec
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
14876 if (lo
->type
== bfd_indirect_link_order
)
14878 asection
*isec
= lo
->u
.indirect
.section
;
14879 if (h_elf
->root
.u
.def
.value
>= isec
->output_offset
14880 && h_elf
->root
.u
.def
.value
< (isec
->output_offset
14883 h_elf
->root
.u
.def
.value
-= isec
->output_offset
;
14884 h_elf
->root
.u
.def
.section
= isec
;
14891 h
= ppc_elf_hash_entry (h_elf
);
14893 if (sec
!= NULL
&& discarded_section (sec
))
14895 _bfd_clear_contents (ppc64_elf_howto_table
[r_type
],
14896 input_bfd
, input_section
,
14897 contents
, rel
->r_offset
);
14898 wrel
->r_offset
= rel
->r_offset
;
14900 wrel
->r_addend
= 0;
14902 /* For ld -r, remove relocations in debug sections against
14903 symbols defined in discarded sections. Not done for
14904 non-debug to preserve relocs in .eh_frame which the
14905 eh_frame editing code expects to be present. */
14906 if (bfd_link_relocatable (info
)
14907 && (input_section
->flags
& SEC_DEBUGGING
))
14913 if (bfd_link_relocatable (info
))
14916 if (h
!= NULL
&& &h
->elf
== htab
->elf
.hgot
)
14918 relocation
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
14919 sec
= bfd_abs_section_ptr
;
14920 unresolved_reloc
= FALSE
;
14923 /* TLS optimizations. Replace instruction sequences and relocs
14924 based on information we collected in tls_optimize. We edit
14925 RELOCS so that --emit-relocs will output something sensible
14926 for the final instruction stream. */
14931 tls_mask
= h
->tls_mask
;
14932 else if (local_got_ents
!= NULL
)
14934 struct plt_entry
**local_plt
= (struct plt_entry
**)
14935 (local_got_ents
+ symtab_hdr
->sh_info
);
14936 unsigned char *lgot_masks
= (unsigned char *)
14937 (local_plt
+ symtab_hdr
->sh_info
);
14938 tls_mask
= lgot_masks
[r_symndx
];
14940 if (((tls_mask
& TLS_TLS
) == 0 || tls_mask
== (TLS_TLS
| TLS_MARK
))
14941 && (r_type
== R_PPC64_TLS
14942 || r_type
== R_PPC64_TLSGD
14943 || r_type
== R_PPC64_TLSLD
))
14945 /* Check for toc tls entries. */
14946 unsigned char *toc_tls
;
14948 if (!get_tls_mask (&toc_tls
, &toc_symndx
, &toc_addend
,
14949 &local_syms
, rel
, input_bfd
))
14953 tls_mask
= *toc_tls
;
14956 /* Check that tls relocs are used with tls syms, and non-tls
14957 relocs are used with non-tls syms. */
14958 if (r_symndx
!= STN_UNDEF
14959 && r_type
!= R_PPC64_NONE
14961 || h
->elf
.root
.type
== bfd_link_hash_defined
14962 || h
->elf
.root
.type
== bfd_link_hash_defweak
)
14963 && IS_PPC64_TLS_RELOC (r_type
) != (sym_type
== STT_TLS
))
14965 if ((tls_mask
& TLS_TLS
) != 0
14966 && (r_type
== R_PPC64_TLS
14967 || r_type
== R_PPC64_TLSGD
14968 || r_type
== R_PPC64_TLSLD
))
14969 /* R_PPC64_TLS is OK against a symbol in the TOC. */
14972 info
->callbacks
->einfo
14973 (!IS_PPC64_TLS_RELOC (r_type
)
14974 /* xgettext:c-format */
14975 ? _("%H: %s used with TLS symbol `%pT'\n")
14976 /* xgettext:c-format */
14977 : _("%H: %s used with non-TLS symbol `%pT'\n"),
14978 input_bfd
, input_section
, rel
->r_offset
,
14979 ppc64_elf_howto_table
[r_type
]->name
,
14983 /* Ensure reloc mapping code below stays sane. */
14984 if (R_PPC64_TOC16_LO_DS
!= R_PPC64_TOC16_DS
+ 1
14985 || R_PPC64_TOC16_LO
!= R_PPC64_TOC16
+ 1
14986 || (R_PPC64_GOT_TLSLD16
& 3) != (R_PPC64_GOT_TLSGD16
& 3)
14987 || (R_PPC64_GOT_TLSLD16_LO
& 3) != (R_PPC64_GOT_TLSGD16_LO
& 3)
14988 || (R_PPC64_GOT_TLSLD16_HI
& 3) != (R_PPC64_GOT_TLSGD16_HI
& 3)
14989 || (R_PPC64_GOT_TLSLD16_HA
& 3) != (R_PPC64_GOT_TLSGD16_HA
& 3)
14990 || (R_PPC64_GOT_TLSLD16
& 3) != (R_PPC64_GOT_TPREL16_DS
& 3)
14991 || (R_PPC64_GOT_TLSLD16_LO
& 3) != (R_PPC64_GOT_TPREL16_LO_DS
& 3)
14992 || (R_PPC64_GOT_TLSLD16_HI
& 3) != (R_PPC64_GOT_TPREL16_HI
& 3)
14993 || (R_PPC64_GOT_TLSLD16_HA
& 3) != (R_PPC64_GOT_TPREL16_HA
& 3))
15001 case R_PPC64_LO_DS_OPT
:
15002 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
- d_offset
);
15003 if ((insn
& (0x3fu
<< 26)) != 58u << 26)
15005 insn
+= (14u << 26) - (58u << 26);
15006 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
- d_offset
);
15007 r_type
= R_PPC64_TOC16_LO
;
15008 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15011 case R_PPC64_TOC16
:
15012 case R_PPC64_TOC16_LO
:
15013 case R_PPC64_TOC16_DS
:
15014 case R_PPC64_TOC16_LO_DS
:
15016 /* Check for toc tls entries. */
15017 unsigned char *toc_tls
;
15020 retval
= get_tls_mask (&toc_tls
, &toc_symndx
, &toc_addend
,
15021 &local_syms
, rel
, input_bfd
);
15027 tls_mask
= *toc_tls
;
15028 if (r_type
== R_PPC64_TOC16_DS
15029 || r_type
== R_PPC64_TOC16_LO_DS
)
15031 if ((tls_mask
& TLS_TLS
) != 0
15032 && (tls_mask
& (TLS_DTPREL
| TLS_TPREL
)) == 0)
15037 /* If we found a GD reloc pair, then we might be
15038 doing a GD->IE transition. */
15042 if ((tls_mask
& TLS_TLS
) != 0
15043 && (tls_mask
& TLS_GD
) == 0)
15046 else if (retval
== 3)
15048 if ((tls_mask
& TLS_TLS
) != 0
15049 && (tls_mask
& TLS_LD
) == 0)
15057 case R_PPC64_GOT_TPREL16_HI
:
15058 case R_PPC64_GOT_TPREL16_HA
:
15059 if ((tls_mask
& TLS_TLS
) != 0
15060 && (tls_mask
& TLS_TPREL
) == 0)
15062 rel
->r_offset
-= d_offset
;
15063 bfd_put_32 (input_bfd
, NOP
, contents
+ rel
->r_offset
);
15064 r_type
= R_PPC64_NONE
;
15065 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15069 case R_PPC64_GOT_TPREL16_DS
:
15070 case R_PPC64_GOT_TPREL16_LO_DS
:
15071 if ((tls_mask
& TLS_TLS
) != 0
15072 && (tls_mask
& TLS_TPREL
) == 0)
15075 insn
= bfd_get_32 (input_bfd
,
15076 contents
+ rel
->r_offset
- d_offset
);
15078 insn
|= 0x3c0d0000; /* addis 0,13,0 */
15079 bfd_put_32 (input_bfd
, insn
,
15080 contents
+ rel
->r_offset
- d_offset
);
15081 r_type
= R_PPC64_TPREL16_HA
;
15082 if (toc_symndx
!= 0)
15084 rel
->r_info
= ELF64_R_INFO (toc_symndx
, r_type
);
15085 rel
->r_addend
= toc_addend
;
15086 /* We changed the symbol. Start over in order to
15087 get h, sym, sec etc. right. */
15091 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15095 case R_PPC64_GOT_TPREL34
:
15096 if ((tls_mask
& TLS_TLS
) != 0
15097 && (tls_mask
& TLS_TPREL
) == 0)
15099 /* pld ra,sym@got@tprel@pcrel -> paddi ra,r13,sym@tprel */
15100 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15102 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15103 pinsn
+= ((2ULL << 56) + (-1ULL << 52)
15104 + (14ULL << 26) - (57ULL << 26) + (13ULL << 16));
15105 bfd_put_32 (input_bfd
, pinsn
>> 32,
15106 contents
+ rel
->r_offset
);
15107 bfd_put_32 (input_bfd
, pinsn
& 0xffffffff,
15108 contents
+ rel
->r_offset
+ 4);
15109 r_type
= R_PPC64_TPREL34
;
15110 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15115 if ((tls_mask
& TLS_TLS
) != 0
15116 && (tls_mask
& TLS_TPREL
) == 0)
15118 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
15119 insn
= _bfd_elf_ppc_at_tls_transform (insn
, 13);
15122 if ((rel
->r_offset
& 3) == 0)
15124 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
15125 /* Was PPC64_TLS which sits on insn boundary, now
15126 PPC64_TPREL16_LO which is at low-order half-word. */
15127 rel
->r_offset
+= d_offset
;
15128 r_type
= R_PPC64_TPREL16_LO
;
15129 if (toc_symndx
!= 0)
15131 rel
->r_info
= ELF64_R_INFO (toc_symndx
, r_type
);
15132 rel
->r_addend
= toc_addend
;
15133 /* We changed the symbol. Start over in order to
15134 get h, sym, sec etc. right. */
15138 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15140 else if ((rel
->r_offset
& 3) == 1)
15142 /* For pcrel IE to LE we already have the full
15143 offset and thus don't need an addi here. A nop
15145 if ((insn
& (0x3fu
<< 26)) == 14 << 26)
15147 /* Extract regs from addi rt,ra,si. */
15148 unsigned int rt
= (insn
>> 21) & 0x1f;
15149 unsigned int ra
= (insn
>> 16) & 0x1f;
15154 /* Build or ra,rs,rb with rb==rs, ie. mr ra,rs. */
15155 insn
= (rt
<< 16) | (ra
<< 21) | (ra
<< 11);
15156 insn
|= (31u << 26) | (444u << 1);
15159 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
- 1);
15164 case R_PPC64_GOT_TLSGD16_HI
:
15165 case R_PPC64_GOT_TLSGD16_HA
:
15167 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0)
15171 case R_PPC64_GOT_TLSLD16_HI
:
15172 case R_PPC64_GOT_TLSLD16_HA
:
15173 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0)
15176 if ((tls_mask
& tls_gd
) != 0)
15177 r_type
= (((r_type
- (R_PPC64_GOT_TLSGD16
& 3)) & 3)
15178 + R_PPC64_GOT_TPREL16_DS
);
15181 rel
->r_offset
-= d_offset
;
15182 bfd_put_32 (input_bfd
, NOP
, contents
+ rel
->r_offset
);
15183 r_type
= R_PPC64_NONE
;
15185 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15189 case R_PPC64_GOT_TLSGD16
:
15190 case R_PPC64_GOT_TLSGD16_LO
:
15192 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0)
15196 case R_PPC64_GOT_TLSLD16
:
15197 case R_PPC64_GOT_TLSLD16_LO
:
15198 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0)
15200 unsigned int insn1
, insn2
;
15203 offset
= (bfd_vma
) -1;
15204 /* If not using the newer R_PPC64_TLSGD/LD to mark
15205 __tls_get_addr calls, we must trust that the call
15206 stays with its arg setup insns, ie. that the next
15207 reloc is the __tls_get_addr call associated with
15208 the current reloc. Edit both insns. */
15209 if (input_section
->nomark_tls_get_addr
15210 && rel
+ 1 < relend
15211 && branch_reloc_hash_match (input_bfd
, rel
+ 1,
15212 htab
->tls_get_addr_fd
,
15214 htab
->tls_get_addr
,
15216 offset
= rel
[1].r_offset
;
15217 /* We read the low GOT_TLS (or TOC16) insn because we
15218 need to keep the destination reg. It may be
15219 something other than the usual r3, and moved to r3
15220 before the call by intervening code. */
15221 insn1
= bfd_get_32 (input_bfd
,
15222 contents
+ rel
->r_offset
- d_offset
);
15223 if ((tls_mask
& tls_gd
) != 0)
15226 insn1
&= (0x1f << 21) | (0x1f << 16);
15227 insn1
|= 58u << 26; /* ld */
15228 insn2
= 0x7c636a14; /* add 3,3,13 */
15229 if (offset
!= (bfd_vma
) -1)
15230 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
15231 if (r_type
== R_PPC64_TOC16
15232 || r_type
== R_PPC64_TOC16_LO
)
15233 r_type
+= R_PPC64_TOC16_DS
- R_PPC64_TOC16
;
15235 r_type
= (((r_type
- (R_PPC64_GOT_TLSGD16
& 1)) & 1)
15236 + R_PPC64_GOT_TPREL16_DS
);
15237 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15242 insn1
&= 0x1f << 21;
15243 insn1
|= 0x3c0d0000; /* addis r,13,0 */
15244 insn2
= 0x38630000; /* addi 3,3,0 */
15247 /* Was an LD reloc. */
15248 r_symndx
= STN_UNDEF
;
15249 rel
->r_addend
= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
15251 else if (toc_symndx
!= 0)
15253 r_symndx
= toc_symndx
;
15254 rel
->r_addend
= toc_addend
;
15256 r_type
= R_PPC64_TPREL16_HA
;
15257 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15258 if (offset
!= (bfd_vma
) -1)
15260 rel
[1].r_info
= ELF64_R_INFO (r_symndx
,
15261 R_PPC64_TPREL16_LO
);
15262 rel
[1].r_offset
= offset
+ d_offset
;
15263 rel
[1].r_addend
= rel
->r_addend
;
15266 bfd_put_32 (input_bfd
, insn1
,
15267 contents
+ rel
->r_offset
- d_offset
);
15268 if (offset
!= (bfd_vma
) -1)
15270 bfd_put_32 (input_bfd
, insn2
, contents
+ offset
);
15271 if (offset
+ 8 <= input_section
->size
)
15273 insn2
= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
15274 if (insn2
== LD_R2_0R1
+ STK_TOC (htab
))
15275 bfd_put_32 (input_bfd
, NOP
, contents
+ offset
+ 4);
15278 if ((tls_mask
& tls_gd
) == 0
15279 && (tls_gd
== 0 || toc_symndx
!= 0))
15281 /* We changed the symbol. Start over in order
15282 to get h, sym, sec etc. right. */
15288 case R_PPC64_GOT_TLSGD34
:
15289 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0)
15291 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15293 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15294 if ((tls_mask
& TLS_GDIE
) != 0)
15296 /* IE, pla -> pld */
15297 pinsn
+= (-2ULL << 56) + (57ULL << 26) - (14ULL << 26);
15298 r_type
= R_PPC64_GOT_TPREL34
;
15302 /* LE, pla pcrel -> paddi r13 */
15303 pinsn
+= (-1ULL << 52) + (13ULL << 16);
15304 r_type
= R_PPC64_TPREL34
;
15306 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15307 bfd_put_32 (input_bfd
, pinsn
>> 32,
15308 contents
+ rel
->r_offset
);
15309 bfd_put_32 (input_bfd
, pinsn
& 0xffffffff,
15310 contents
+ rel
->r_offset
+ 4);
15314 case R_PPC64_GOT_TLSLD34
:
15315 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0)
15317 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15319 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15320 pinsn
+= (-1ULL << 52) + (13ULL << 16);
15321 bfd_put_32 (input_bfd
, pinsn
>> 32,
15322 contents
+ rel
->r_offset
);
15323 bfd_put_32 (input_bfd
, pinsn
& 0xffffffff,
15324 contents
+ rel
->r_offset
+ 4);
15325 rel
->r_addend
= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
15326 r_symndx
= STN_UNDEF
;
15327 r_type
= R_PPC64_TPREL34
;
15328 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15333 case R_PPC64_TLSGD
:
15334 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0
15335 && rel
+ 1 < relend
)
15337 unsigned int insn2
;
15338 enum elf_ppc64_reloc_type r_type1
= ELF64_R_TYPE (rel
[1].r_info
);
15340 offset
= rel
->r_offset
;
15341 if (is_plt_seq_reloc (r_type1
))
15343 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
);
15344 if (r_type1
== R_PPC64_PLT_PCREL34
15345 || r_type1
== R_PPC64_PLT_PCREL34_NOTOC
)
15346 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
15347 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
15351 if (ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_PLTCALL
)
15352 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
15354 if ((tls_mask
& TLS_GDIE
) != 0)
15357 r_type
= R_PPC64_NONE
;
15358 insn2
= 0x7c636a14; /* add 3,3,13 */
15363 if (toc_symndx
!= 0)
15365 r_symndx
= toc_symndx
;
15366 rel
->r_addend
= toc_addend
;
15368 if (r_type1
== R_PPC64_REL24_NOTOC
15369 || r_type1
== R_PPC64_PLTCALL_NOTOC
)
15371 r_type
= R_PPC64_NONE
;
15376 rel
->r_offset
= offset
+ d_offset
;
15377 r_type
= R_PPC64_TPREL16_LO
;
15378 insn2
= 0x38630000; /* addi 3,3,0 */
15381 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15382 /* Zap the reloc on the _tls_get_addr call too. */
15383 BFD_ASSERT (offset
== rel
[1].r_offset
);
15384 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
15385 bfd_put_32 (input_bfd
, insn2
, contents
+ offset
);
15386 if ((tls_mask
& TLS_GDIE
) == 0
15388 && r_type
!= R_PPC64_NONE
)
15393 case R_PPC64_TLSLD
:
15394 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0
15395 && rel
+ 1 < relend
)
15397 unsigned int insn2
;
15398 enum elf_ppc64_reloc_type r_type1
= ELF64_R_TYPE (rel
[1].r_info
);
15400 offset
= rel
->r_offset
;
15401 if (is_plt_seq_reloc (r_type1
))
15403 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
);
15404 if (r_type1
== R_PPC64_PLT_PCREL34
15405 || r_type1
== R_PPC64_PLT_PCREL34_NOTOC
)
15406 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
15407 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
15411 if (ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_PLTCALL
)
15412 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
15414 if (r_type1
== R_PPC64_REL24_NOTOC
15415 || r_type1
== R_PPC64_PLTCALL_NOTOC
)
15417 r_type
= R_PPC64_NONE
;
15422 rel
->r_offset
= offset
+ d_offset
;
15423 r_symndx
= STN_UNDEF
;
15424 r_type
= R_PPC64_TPREL16_LO
;
15425 rel
->r_addend
= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
15426 insn2
= 0x38630000; /* addi 3,3,0 */
15428 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15429 /* Zap the reloc on the _tls_get_addr call too. */
15430 BFD_ASSERT (offset
== rel
[1].r_offset
);
15431 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
15432 bfd_put_32 (input_bfd
, insn2
, contents
+ offset
);
15433 if (r_type
!= R_PPC64_NONE
)
15438 case R_PPC64_DTPMOD64
:
15439 if (rel
+ 1 < relend
15440 && rel
[1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_DTPREL64
)
15441 && rel
[1].r_offset
== rel
->r_offset
+ 8)
15443 if ((tls_mask
& TLS_GD
) == 0)
15445 rel
[1].r_info
= ELF64_R_INFO (r_symndx
, R_PPC64_NONE
);
15446 if ((tls_mask
& TLS_GDIE
) != 0)
15447 r_type
= R_PPC64_TPREL64
;
15450 bfd_put_64 (output_bfd
, 1, contents
+ rel
->r_offset
);
15451 r_type
= R_PPC64_NONE
;
15453 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15458 if ((tls_mask
& TLS_LD
) == 0)
15460 bfd_put_64 (output_bfd
, 1, contents
+ rel
->r_offset
);
15461 r_type
= R_PPC64_NONE
;
15462 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15467 case R_PPC64_TPREL64
:
15468 if ((tls_mask
& TLS_TPREL
) == 0)
15470 r_type
= R_PPC64_NONE
;
15471 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15475 case R_PPC64_ENTRY
:
15476 relocation
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
15477 if (!bfd_link_pic (info
)
15478 && !info
->traditional_format
15479 && relocation
+ 0x80008000 <= 0xffffffff)
15481 unsigned int insn1
, insn2
;
15483 insn1
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15484 insn2
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15485 if ((insn1
& ~0xfffc) == LD_R2_0R12
15486 && insn2
== ADD_R2_R2_R12
)
15488 bfd_put_32 (input_bfd
,
15489 LIS_R2
+ PPC_HA (relocation
),
15490 contents
+ rel
->r_offset
);
15491 bfd_put_32 (input_bfd
,
15492 ADDI_R2_R2
+ PPC_LO (relocation
),
15493 contents
+ rel
->r_offset
+ 4);
15498 relocation
-= (rel
->r_offset
15499 + input_section
->output_offset
15500 + input_section
->output_section
->vma
);
15501 if (relocation
+ 0x80008000 <= 0xffffffff)
15503 unsigned int insn1
, insn2
;
15505 insn1
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15506 insn2
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15507 if ((insn1
& ~0xfffc) == LD_R2_0R12
15508 && insn2
== ADD_R2_R2_R12
)
15510 bfd_put_32 (input_bfd
,
15511 ADDIS_R2_R12
+ PPC_HA (relocation
),
15512 contents
+ rel
->r_offset
);
15513 bfd_put_32 (input_bfd
,
15514 ADDI_R2_R2
+ PPC_LO (relocation
),
15515 contents
+ rel
->r_offset
+ 4);
15521 case R_PPC64_REL16_HA
:
15522 /* If we are generating a non-PIC executable, edit
15523 . 0: addis 2,12,.TOC.-0b@ha
15524 . addi 2,2,.TOC.-0b@l
15525 used by ELFv2 global entry points to set up r2, to
15528 if .TOC. is in range. */
15529 if (!bfd_link_pic (info
)
15530 && !info
->traditional_format
15532 && rel
->r_addend
== d_offset
15533 && h
!= NULL
&& &h
->elf
== htab
->elf
.hgot
15534 && rel
+ 1 < relend
15535 && rel
[1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_REL16_LO
)
15536 && rel
[1].r_offset
== rel
->r_offset
+ 4
15537 && rel
[1].r_addend
== rel
->r_addend
+ 4
15538 && relocation
+ 0x80008000 <= 0xffffffff)
15540 unsigned int insn1
, insn2
;
15541 offset
= rel
->r_offset
- d_offset
;
15542 insn1
= bfd_get_32 (input_bfd
, contents
+ offset
);
15543 insn2
= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
15544 if ((insn1
& 0xffff0000) == ADDIS_R2_R12
15545 && (insn2
& 0xffff0000) == ADDI_R2_R2
)
15547 r_type
= R_PPC64_ADDR16_HA
;
15548 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15549 rel
->r_addend
-= d_offset
;
15550 rel
[1].r_info
= ELF64_R_INFO (r_symndx
, R_PPC64_ADDR16_LO
);
15551 rel
[1].r_addend
-= d_offset
+ 4;
15552 bfd_put_32 (input_bfd
, LIS_R2
, contents
+ offset
);
15558 /* Handle other relocations that tweak non-addend part of insn. */
15560 max_br_offset
= 1 << 25;
15561 addend
= rel
->r_addend
;
15562 reloc_dest
= DEST_NORMAL
;
15568 case R_PPC64_TOCSAVE
:
15569 if (relocation
+ addend
== (rel
->r_offset
15570 + input_section
->output_offset
15571 + input_section
->output_section
->vma
)
15572 && tocsave_find (htab
, NO_INSERT
,
15573 &local_syms
, rel
, input_bfd
))
15575 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15577 || insn
== CROR_151515
|| insn
== CROR_313131
)
15578 bfd_put_32 (input_bfd
,
15579 STD_R2_0R1
+ STK_TOC (htab
),
15580 contents
+ rel
->r_offset
);
15584 /* Branch taken prediction relocations. */
15585 case R_PPC64_ADDR14_BRTAKEN
:
15586 case R_PPC64_REL14_BRTAKEN
:
15587 insn
= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
15588 /* Fall through. */
15590 /* Branch not taken prediction relocations. */
15591 case R_PPC64_ADDR14_BRNTAKEN
:
15592 case R_PPC64_REL14_BRNTAKEN
:
15593 insn
|= bfd_get_32 (input_bfd
,
15594 contents
+ rel
->r_offset
) & ~(0x01 << 21);
15595 /* Fall through. */
15597 case R_PPC64_REL14
:
15598 max_br_offset
= 1 << 15;
15599 /* Fall through. */
15601 case R_PPC64_REL24
:
15602 case R_PPC64_REL24_NOTOC
:
15603 case R_PPC64_PLTCALL
:
15604 case R_PPC64_PLTCALL_NOTOC
:
15605 /* Calls to functions with a different TOC, such as calls to
15606 shared objects, need to alter the TOC pointer. This is
15607 done using a linkage stub. A REL24 branching to these
15608 linkage stubs needs to be followed by a nop, as the nop
15609 will be replaced with an instruction to restore the TOC
15614 && h
->oh
->is_func_descriptor
)
15615 fdh
= ppc_follow_link (h
->oh
);
15616 stub_entry
= ppc_get_stub_entry (input_section
, sec
, fdh
, &orig_rel
,
15618 if ((r_type
== R_PPC64_PLTCALL
15619 || r_type
== R_PPC64_PLTCALL_NOTOC
)
15620 && stub_entry
!= NULL
15621 && stub_entry
->stub_type
>= ppc_stub_plt_call
15622 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15625 if (stub_entry
!= NULL
15626 && ((stub_entry
->stub_type
>= ppc_stub_plt_call
15627 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15628 || stub_entry
->stub_type
== ppc_stub_plt_branch_r2off
15629 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
15630 || stub_entry
->stub_type
== ppc_stub_long_branch_r2off
15631 || stub_entry
->stub_type
== ppc_stub_long_branch_both
))
15633 bfd_boolean can_plt_call
= FALSE
;
15635 if (stub_entry
->stub_type
== ppc_stub_plt_call
15637 && htab
->params
->plt_localentry0
!= 0
15638 && is_elfv2_localentry0 (&h
->elf
))
15640 /* The function doesn't use or change r2. */
15641 can_plt_call
= TRUE
;
15643 else if (r_type
== R_PPC64_REL24_NOTOC
)
15645 /* NOTOC calls don't need to restore r2. */
15646 can_plt_call
= TRUE
;
15649 /* All of these stubs may modify r2, so there must be a
15650 branch and link followed by a nop. The nop is
15651 replaced by an insn to restore r2. */
15652 else if (rel
->r_offset
+ 8 <= input_section
->size
)
15656 br
= bfd_get_32 (input_bfd
,
15657 contents
+ rel
->r_offset
);
15662 nop
= bfd_get_32 (input_bfd
,
15663 contents
+ rel
->r_offset
+ 4);
15664 if (nop
== LD_R2_0R1
+ STK_TOC (htab
))
15665 can_plt_call
= TRUE
;
15666 else if (nop
== NOP
15667 || nop
== CROR_151515
15668 || nop
== CROR_313131
)
15671 && is_tls_get_addr (&h
->elf
, htab
)
15672 && htab
->params
->tls_get_addr_opt
)
15674 /* Special stub used, leave nop alone. */
15677 bfd_put_32 (input_bfd
,
15678 LD_R2_0R1
+ STK_TOC (htab
),
15679 contents
+ rel
->r_offset
+ 4);
15680 can_plt_call
= TRUE
;
15685 if (!can_plt_call
&& h
!= NULL
)
15687 const char *name
= h
->elf
.root
.root
.string
;
15692 if (strncmp (name
, "__libc_start_main", 17) == 0
15693 && (name
[17] == 0 || name
[17] == '@'))
15695 /* Allow crt1 branch to go via a toc adjusting
15696 stub. Other calls that never return could do
15697 the same, if we could detect such. */
15698 can_plt_call
= TRUE
;
15704 /* g++ as of 20130507 emits self-calls without a
15705 following nop. This is arguably wrong since we
15706 have conflicting information. On the one hand a
15707 global symbol and on the other a local call
15708 sequence, but don't error for this special case.
15709 It isn't possible to cheaply verify we have
15710 exactly such a call. Allow all calls to the same
15712 asection
*code_sec
= sec
;
15714 if (get_opd_info (sec
) != NULL
)
15716 bfd_vma off
= (relocation
+ addend
15717 - sec
->output_section
->vma
15718 - sec
->output_offset
);
15720 opd_entry_value (sec
, off
, &code_sec
, NULL
, FALSE
);
15722 if (code_sec
== input_section
)
15723 can_plt_call
= TRUE
;
15728 if (stub_entry
->stub_type
>= ppc_stub_plt_call
15729 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15730 info
->callbacks
->einfo
15731 /* xgettext:c-format */
15732 (_("%H: call to `%pT' lacks nop, can't restore toc; "
15733 "(plt call stub)\n"),
15734 input_bfd
, input_section
, rel
->r_offset
, sym_name
);
15736 info
->callbacks
->einfo
15737 /* xgettext:c-format */
15738 (_("%H: call to `%pT' lacks nop, can't restore toc; "
15739 "(toc save/adjust stub)\n"),
15740 input_bfd
, input_section
, rel
->r_offset
, sym_name
);
15742 bfd_set_error (bfd_error_bad_value
);
15747 && stub_entry
->stub_type
>= ppc_stub_plt_call
15748 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15749 unresolved_reloc
= FALSE
;
15752 if ((stub_entry
== NULL
15753 || stub_entry
->stub_type
== ppc_stub_long_branch
15754 || stub_entry
->stub_type
== ppc_stub_plt_branch
)
15755 && get_opd_info (sec
) != NULL
)
15757 /* The branch destination is the value of the opd entry. */
15758 bfd_vma off
= (relocation
+ addend
15759 - sec
->output_section
->vma
15760 - sec
->output_offset
);
15761 bfd_vma dest
= opd_entry_value (sec
, off
, NULL
, NULL
, FALSE
);
15762 if (dest
!= (bfd_vma
) -1)
15766 reloc_dest
= DEST_OPD
;
15770 /* If the branch is out of reach we ought to have a long
15772 from
= (rel
->r_offset
15773 + input_section
->output_offset
15774 + input_section
->output_section
->vma
);
15776 relocation
+= PPC64_LOCAL_ENTRY_OFFSET (fdh
15780 if (stub_entry
!= NULL
15781 && (stub_entry
->stub_type
== ppc_stub_long_branch
15782 || stub_entry
->stub_type
== ppc_stub_plt_branch
)
15783 && (r_type
== R_PPC64_ADDR14_BRTAKEN
15784 || r_type
== R_PPC64_ADDR14_BRNTAKEN
15785 || (relocation
+ addend
- from
+ max_br_offset
15786 < 2 * max_br_offset
)))
15787 /* Don't use the stub if this branch is in range. */
15790 if (stub_entry
!= NULL
15791 && (stub_entry
->stub_type
== ppc_stub_long_branch_notoc
15792 || stub_entry
->stub_type
== ppc_stub_long_branch_both
15793 || stub_entry
->stub_type
== ppc_stub_plt_branch_notoc
15794 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
)
15795 && (r_type
!= R_PPC64_REL24_NOTOC
15796 || ((fdh
? fdh
->elf
.other
: sym
->st_other
)
15797 & STO_PPC64_LOCAL_MASK
) <= 1 << STO_PPC64_LOCAL_BIT
)
15798 && (relocation
+ addend
- from
+ max_br_offset
15799 < 2 * max_br_offset
))
15802 if (stub_entry
!= NULL
15803 && (stub_entry
->stub_type
== ppc_stub_long_branch_r2off
15804 || stub_entry
->stub_type
== ppc_stub_long_branch_both
15805 || stub_entry
->stub_type
== ppc_stub_plt_branch_r2off
15806 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
)
15807 && r_type
== R_PPC64_REL24_NOTOC
15808 && (relocation
+ addend
- from
+ max_br_offset
15809 < 2 * max_br_offset
))
15812 if (stub_entry
!= NULL
)
15814 /* Munge up the value and addend so that we call the stub
15815 rather than the procedure directly. */
15816 asection
*stub_sec
= stub_entry
->group
->stub_sec
;
15818 if (stub_entry
->stub_type
== ppc_stub_save_res
)
15819 relocation
+= (stub_sec
->output_offset
15820 + stub_sec
->output_section
->vma
15821 + stub_sec
->size
- htab
->sfpr
->size
15822 - htab
->sfpr
->output_offset
15823 - htab
->sfpr
->output_section
->vma
);
15825 relocation
= (stub_entry
->stub_offset
15826 + stub_sec
->output_offset
15827 + stub_sec
->output_section
->vma
);
15829 reloc_dest
= DEST_STUB
;
15831 if (((stub_entry
->stub_type
== ppc_stub_plt_call
15832 && ALWAYS_EMIT_R2SAVE
)
15833 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
15834 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
15836 && is_tls_get_addr (&h
->elf
, htab
)
15837 && htab
->params
->tls_get_addr_opt
)
15838 && rel
+ 1 < relend
15839 && rel
[1].r_offset
== rel
->r_offset
+ 4
15840 && ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_TOCSAVE
)
15842 else if ((stub_entry
->stub_type
== ppc_stub_long_branch_both
15843 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
15844 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
15845 && r_type
== R_PPC64_REL24_NOTOC
)
15848 if (r_type
== R_PPC64_REL24_NOTOC
15849 && (stub_entry
->stub_type
== ppc_stub_plt_call_notoc
15850 || stub_entry
->stub_type
== ppc_stub_plt_call_both
))
15851 htab
->notoc_plt
= 1;
15858 /* Set 'a' bit. This is 0b00010 in BO field for branch
15859 on CR(BI) insns (BO == 001at or 011at), and 0b01000
15860 for branch on CTR insns (BO == 1a00t or 1a01t). */
15861 if ((insn
& (0x14 << 21)) == (0x04 << 21))
15862 insn
|= 0x02 << 21;
15863 else if ((insn
& (0x14 << 21)) == (0x10 << 21))
15864 insn
|= 0x08 << 21;
15870 /* Invert 'y' bit if not the default. */
15871 if ((bfd_signed_vma
) (relocation
+ addend
- from
) < 0)
15872 insn
^= 0x01 << 21;
15875 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
15878 /* NOP out calls to undefined weak functions.
15879 We can thus call a weak function without first
15880 checking whether the function is defined. */
15882 && h
->elf
.root
.type
== bfd_link_hash_undefweak
15883 && h
->elf
.dynindx
== -1
15884 && (r_type
== R_PPC64_REL24
15885 || r_type
== R_PPC64_REL24_NOTOC
)
15889 bfd_put_32 (input_bfd
, NOP
, contents
+ rel
->r_offset
);
15894 case R_PPC64_GOT16_DS
:
15895 if ((h
? h
->elf
.type
: ELF_ST_TYPE (sym
->st_info
)) == STT_GNU_IFUNC
)
15897 from
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
15898 if (relocation
+ addend
- from
+ 0x8000 < 0x10000
15899 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15901 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
15902 if ((insn
& (0x3fu
<< 26 | 0x3)) == 58u << 26 /* ld */)
15904 insn
+= (14u << 26) - (58u << 26);
15905 bfd_put_32 (input_bfd
, insn
, contents
+ (rel
->r_offset
& ~3));
15906 r_type
= R_PPC64_TOC16
;
15907 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15912 case R_PPC64_GOT16_LO_DS
:
15913 case R_PPC64_GOT16_HA
:
15914 if ((h
? h
->elf
.type
: ELF_ST_TYPE (sym
->st_info
)) == STT_GNU_IFUNC
)
15916 from
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
15917 if (relocation
+ addend
- from
+ 0x80008000ULL
< 0x100000000ULL
15918 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15920 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
15921 if ((insn
& (0x3fu
<< 26 | 0x3)) == 58u << 26 /* ld */)
15923 insn
+= (14u << 26) - (58u << 26);
15924 bfd_put_32 (input_bfd
, insn
, contents
+ (rel
->r_offset
& ~3));
15925 r_type
= R_PPC64_TOC16_LO
;
15926 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15928 else if ((insn
& (0x3fu
<< 26)) == 15u << 26 /* addis */)
15930 r_type
= R_PPC64_TOC16_HA
;
15931 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15936 case R_PPC64_GOT_PCREL34
:
15937 if ((h
? h
->elf
.type
: ELF_ST_TYPE (sym
->st_info
)) == STT_GNU_IFUNC
)
15939 from
= (rel
->r_offset
15940 + input_section
->output_section
->vma
15941 + input_section
->output_offset
);
15942 if (relocation
- from
+ (1ULL << 33) < 1ULL << 34
15943 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15945 offset
= rel
->r_offset
;
15946 pinsn
= bfd_get_32 (input_bfd
, contents
+ offset
);
15948 pinsn
|= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
15949 if ((pinsn
& ((-1ULL << 50) | (63ULL << 26)))
15950 == ((1ULL << 58) | (1ULL << 52) | (57ULL << 26) /* pld */))
15952 /* Replace with paddi. */
15953 pinsn
+= (2ULL << 56) + (14ULL << 26) - (57ULL << 26);
15954 r_type
= R_PPC64_PCREL34
;
15955 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15956 bfd_put_32 (input_bfd
, pinsn
>> 32, contents
+ offset
);
15957 bfd_put_32 (input_bfd
, pinsn
, contents
+ offset
+ 4);
15963 case R_PPC64_PCREL34
:
15964 if (SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15966 offset
= rel
->r_offset
;
15967 pinsn
= bfd_get_32 (input_bfd
, contents
+ offset
);
15969 pinsn
|= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
15970 if ((pinsn
& ((-1ULL << 50) | (63ULL << 26)))
15971 == ((1ULL << 58) | (2ULL << 56) | (1ULL << 52)
15972 | (14ULL << 26) /* paddi */))
15975 if (rel
+ 1 < relend
15976 && rel
[1].r_offset
== offset
15977 && rel
[1].r_info
== ELF64_R_INFO (0, R_PPC64_PCREL_OPT
))
15979 bfd_vma off2
= rel
[1].r_addend
;
15981 /* zero means next insn. */
15984 if (off2
+ 4 <= input_section
->size
)
15987 bfd_signed_vma addend_off
;
15988 pinsn2
= bfd_get_32 (input_bfd
, contents
+ off2
);
15990 if ((pinsn2
& (63ULL << 58)) == 1ULL << 58)
15992 if (off2
+ 8 > input_section
->size
)
15994 pinsn2
|= bfd_get_32 (input_bfd
,
15995 contents
+ off2
+ 4);
15997 if (xlate_pcrel_opt (&pinsn
, &pinsn2
, &addend_off
))
15999 addend
+= addend_off
;
16000 rel
->r_addend
= addend
;
16001 bfd_put_32 (input_bfd
, pinsn
>> 32,
16002 contents
+ offset
);
16003 bfd_put_32 (input_bfd
, pinsn
,
16004 contents
+ offset
+ 4);
16005 bfd_put_32 (input_bfd
, pinsn2
>> 32,
16007 if ((pinsn2
& (63ULL << 58)) == 1ULL << 58)
16008 bfd_put_32 (input_bfd
, pinsn2
,
16009 contents
+ off2
+ 4);
16019 save_unresolved_reloc
= unresolved_reloc
;
16023 /* xgettext:c-format */
16024 _bfd_error_handler (_("%pB: %s unsupported"),
16025 input_bfd
, ppc64_elf_howto_table
[r_type
]->name
);
16027 bfd_set_error (bfd_error_bad_value
);
16033 case R_PPC64_TLSGD
:
16034 case R_PPC64_TLSLD
:
16035 case R_PPC64_TOCSAVE
:
16036 case R_PPC64_GNU_VTINHERIT
:
16037 case R_PPC64_GNU_VTENTRY
:
16038 case R_PPC64_ENTRY
:
16039 case R_PPC64_PCREL_OPT
:
16042 /* GOT16 relocations. Like an ADDR16 using the symbol's
16043 address in the GOT as relocation value instead of the
16044 symbol's value itself. Also, create a GOT entry for the
16045 symbol and put the symbol value there. */
16046 case R_PPC64_GOT_TLSGD16
:
16047 case R_PPC64_GOT_TLSGD16_LO
:
16048 case R_PPC64_GOT_TLSGD16_HI
:
16049 case R_PPC64_GOT_TLSGD16_HA
:
16050 case R_PPC64_GOT_TLSGD34
:
16051 tls_type
= TLS_TLS
| TLS_GD
;
16054 case R_PPC64_GOT_TLSLD16
:
16055 case R_PPC64_GOT_TLSLD16_LO
:
16056 case R_PPC64_GOT_TLSLD16_HI
:
16057 case R_PPC64_GOT_TLSLD16_HA
:
16058 case R_PPC64_GOT_TLSLD34
:
16059 tls_type
= TLS_TLS
| TLS_LD
;
16062 case R_PPC64_GOT_TPREL16_DS
:
16063 case R_PPC64_GOT_TPREL16_LO_DS
:
16064 case R_PPC64_GOT_TPREL16_HI
:
16065 case R_PPC64_GOT_TPREL16_HA
:
16066 case R_PPC64_GOT_TPREL34
:
16067 tls_type
= TLS_TLS
| TLS_TPREL
;
16070 case R_PPC64_GOT_DTPREL16_DS
:
16071 case R_PPC64_GOT_DTPREL16_LO_DS
:
16072 case R_PPC64_GOT_DTPREL16_HI
:
16073 case R_PPC64_GOT_DTPREL16_HA
:
16074 case R_PPC64_GOT_DTPREL34
:
16075 tls_type
= TLS_TLS
| TLS_DTPREL
;
16078 case R_PPC64_GOT16
:
16079 case R_PPC64_GOT16_LO
:
16080 case R_PPC64_GOT16_HI
:
16081 case R_PPC64_GOT16_HA
:
16082 case R_PPC64_GOT16_DS
:
16083 case R_PPC64_GOT16_LO_DS
:
16084 case R_PPC64_GOT_PCREL34
:
16087 /* Relocation is to the entry for this symbol in the global
16092 unsigned long indx
= 0;
16093 struct got_entry
*ent
;
16095 if (tls_type
== (TLS_TLS
| TLS_LD
)
16096 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
16097 ent
= ppc64_tlsld_got (input_bfd
);
16102 if (!htab
->elf
.dynamic_sections_created
16103 || h
->elf
.dynindx
== -1
16104 || SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
)
16105 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, &h
->elf
))
16106 /* This is actually a static link, or it is a
16107 -Bsymbolic link and the symbol is defined
16108 locally, or the symbol was forced to be local
16109 because of a version file. */
16113 indx
= h
->elf
.dynindx
;
16114 unresolved_reloc
= FALSE
;
16116 ent
= h
->elf
.got
.glist
;
16120 if (local_got_ents
== NULL
)
16122 ent
= local_got_ents
[r_symndx
];
16125 for (; ent
!= NULL
; ent
= ent
->next
)
16126 if (ent
->addend
== orig_rel
.r_addend
16127 && ent
->owner
== input_bfd
16128 && ent
->tls_type
== tls_type
)
16134 if (ent
->is_indirect
)
16135 ent
= ent
->got
.ent
;
16136 offp
= &ent
->got
.offset
;
16137 got
= ppc64_elf_tdata (ent
->owner
)->got
;
16141 /* The offset must always be a multiple of 8. We use the
16142 least significant bit to record whether we have already
16143 processed this entry. */
16145 if ((off
& 1) != 0)
16149 /* Generate relocs for the dynamic linker, except in
16150 the case of TLSLD where we'll use one entry per
16158 ? h
->elf
.type
== STT_GNU_IFUNC
16159 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
);
16162 relgot
= htab
->elf
.irelplt
;
16164 htab
->local_ifunc_resolver
= 1;
16165 else if (is_static_defined (&h
->elf
))
16166 htab
->maybe_local_ifunc_resolver
= 1;
16169 || (bfd_link_pic (info
)
16171 || !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, &h
->elf
))
16173 && bfd_link_executable (info
)
16174 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))))
16175 relgot
= ppc64_elf_tdata (ent
->owner
)->relgot
;
16176 if (relgot
!= NULL
)
16178 outrel
.r_offset
= (got
->output_section
->vma
16179 + got
->output_offset
16181 outrel
.r_addend
= orig_rel
.r_addend
;
16182 if (tls_type
& (TLS_LD
| TLS_GD
))
16184 outrel
.r_addend
= 0;
16185 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_DTPMOD64
);
16186 if (tls_type
== (TLS_TLS
| TLS_GD
))
16188 loc
= relgot
->contents
;
16189 loc
+= (relgot
->reloc_count
++
16190 * sizeof (Elf64_External_Rela
));
16191 bfd_elf64_swap_reloca_out (output_bfd
,
16193 outrel
.r_offset
+= 8;
16194 outrel
.r_addend
= orig_rel
.r_addend
;
16196 = ELF64_R_INFO (indx
, R_PPC64_DTPREL64
);
16199 else if (tls_type
== (TLS_TLS
| TLS_DTPREL
))
16200 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_DTPREL64
);
16201 else if (tls_type
== (TLS_TLS
| TLS_TPREL
))
16202 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_TPREL64
);
16203 else if (indx
!= 0)
16204 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_GLOB_DAT
);
16208 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
16210 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
16212 /* Write the .got section contents for the sake
16214 loc
= got
->contents
+ off
;
16215 bfd_put_64 (output_bfd
, outrel
.r_addend
+ relocation
,
16219 if (indx
== 0 && tls_type
!= (TLS_TLS
| TLS_LD
))
16221 outrel
.r_addend
+= relocation
;
16222 if (tls_type
& (TLS_GD
| TLS_DTPREL
| TLS_TPREL
))
16224 if (htab
->elf
.tls_sec
== NULL
)
16225 outrel
.r_addend
= 0;
16227 outrel
.r_addend
-= htab
->elf
.tls_sec
->vma
;
16230 loc
= relgot
->contents
;
16231 loc
+= (relgot
->reloc_count
++
16232 * sizeof (Elf64_External_Rela
));
16233 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
16236 /* Init the .got section contents here if we're not
16237 emitting a reloc. */
16240 relocation
+= orig_rel
.r_addend
;
16243 if (htab
->elf
.tls_sec
== NULL
)
16247 if (tls_type
& TLS_LD
)
16250 relocation
-= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
16251 if (tls_type
& TLS_TPREL
)
16252 relocation
+= DTP_OFFSET
- TP_OFFSET
;
16255 if (tls_type
& (TLS_GD
| TLS_LD
))
16257 bfd_put_64 (output_bfd
, relocation
,
16258 got
->contents
+ off
+ 8);
16262 bfd_put_64 (output_bfd
, relocation
,
16263 got
->contents
+ off
);
16267 if (off
>= (bfd_vma
) -2)
16270 relocation
= got
->output_section
->vma
+ got
->output_offset
+ off
;
16272 if (!(r_type
== R_PPC64_GOT_PCREL34
16273 || r_type
== R_PPC64_GOT_TLSGD34
16274 || r_type
== R_PPC64_GOT_TLSLD34
16275 || r_type
== R_PPC64_GOT_TPREL34
16276 || r_type
== R_PPC64_GOT_DTPREL34
))
16277 addend
= -(TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
);
16281 case R_PPC64_PLT16_HA
:
16282 case R_PPC64_PLT16_HI
:
16283 case R_PPC64_PLT16_LO
:
16284 case R_PPC64_PLT16_LO_DS
:
16285 case R_PPC64_PLT_PCREL34
:
16286 case R_PPC64_PLT_PCREL34_NOTOC
:
16287 case R_PPC64_PLT32
:
16288 case R_PPC64_PLT64
:
16289 case R_PPC64_PLTSEQ
:
16290 case R_PPC64_PLTSEQ_NOTOC
:
16291 case R_PPC64_PLTCALL
:
16292 case R_PPC64_PLTCALL_NOTOC
:
16293 /* Relocation is to the entry for this symbol in the
16294 procedure linkage table. */
16295 unresolved_reloc
= TRUE
;
16297 struct plt_entry
**plt_list
= NULL
;
16299 plt_list
= &h
->elf
.plt
.plist
;
16300 else if (local_got_ents
!= NULL
)
16302 struct plt_entry
**local_plt
= (struct plt_entry
**)
16303 (local_got_ents
+ symtab_hdr
->sh_info
);
16304 plt_list
= local_plt
+ r_symndx
;
16308 struct plt_entry
*ent
;
16310 for (ent
= *plt_list
; ent
!= NULL
; ent
= ent
->next
)
16311 if (ent
->plt
.offset
!= (bfd_vma
) -1
16312 && ent
->addend
== orig_rel
.r_addend
)
16317 plt
= htab
->elf
.splt
;
16318 if (!htab
->elf
.dynamic_sections_created
16320 || h
->elf
.dynindx
== -1)
16323 ? h
->elf
.type
== STT_GNU_IFUNC
16324 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
16325 plt
= htab
->elf
.iplt
;
16327 plt
= htab
->pltlocal
;
16329 relocation
= (plt
->output_section
->vma
16330 + plt
->output_offset
16331 + ent
->plt
.offset
);
16332 if (r_type
== R_PPC64_PLT16_HA
16333 || r_type
== R_PPC64_PLT16_HI
16334 || r_type
== R_PPC64_PLT16_LO
16335 || r_type
== R_PPC64_PLT16_LO_DS
)
16337 got
= (elf_gp (output_bfd
)
16338 + htab
->sec_info
[input_section
->id
].toc_off
);
16342 unresolved_reloc
= FALSE
;
16350 /* Relocation value is TOC base. */
16351 relocation
= TOCstart
;
16352 if (r_symndx
== STN_UNDEF
)
16353 relocation
+= htab
->sec_info
[input_section
->id
].toc_off
;
16354 else if (unresolved_reloc
)
16356 else if (sec
!= NULL
&& sec
->id
< htab
->sec_info_arr_size
)
16357 relocation
+= htab
->sec_info
[sec
->id
].toc_off
;
16359 unresolved_reloc
= TRUE
;
16362 /* TOC16 relocs. We want the offset relative to the TOC base,
16363 which is the address of the start of the TOC plus 0x8000.
16364 The TOC consists of sections .got, .toc, .tocbss, and .plt,
16366 case R_PPC64_TOC16
:
16367 case R_PPC64_TOC16_LO
:
16368 case R_PPC64_TOC16_HI
:
16369 case R_PPC64_TOC16_DS
:
16370 case R_PPC64_TOC16_LO_DS
:
16371 case R_PPC64_TOC16_HA
:
16372 addend
-= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
16377 /* Relocate against the beginning of the section. */
16378 case R_PPC64_SECTOFF
:
16379 case R_PPC64_SECTOFF_LO
:
16380 case R_PPC64_SECTOFF_HI
:
16381 case R_PPC64_SECTOFF_DS
:
16382 case R_PPC64_SECTOFF_LO_DS
:
16383 case R_PPC64_SECTOFF_HA
:
16385 addend
-= sec
->output_section
->vma
;
16388 case R_PPC64_REL16
:
16389 case R_PPC64_REL16_LO
:
16390 case R_PPC64_REL16_HI
:
16391 case R_PPC64_REL16_HA
:
16392 case R_PPC64_REL16_HIGH
:
16393 case R_PPC64_REL16_HIGHA
:
16394 case R_PPC64_REL16_HIGHER
:
16395 case R_PPC64_REL16_HIGHERA
:
16396 case R_PPC64_REL16_HIGHEST
:
16397 case R_PPC64_REL16_HIGHESTA
:
16398 case R_PPC64_REL16_HIGHER34
:
16399 case R_PPC64_REL16_HIGHERA34
:
16400 case R_PPC64_REL16_HIGHEST34
:
16401 case R_PPC64_REL16_HIGHESTA34
:
16402 case R_PPC64_REL16DX_HA
:
16403 case R_PPC64_REL14
:
16404 case R_PPC64_REL14_BRNTAKEN
:
16405 case R_PPC64_REL14_BRTAKEN
:
16406 case R_PPC64_REL24
:
16407 case R_PPC64_REL24_NOTOC
:
16408 case R_PPC64_PCREL34
:
16409 case R_PPC64_PCREL28
:
16412 case R_PPC64_TPREL16
:
16413 case R_PPC64_TPREL16_LO
:
16414 case R_PPC64_TPREL16_HI
:
16415 case R_PPC64_TPREL16_HA
:
16416 case R_PPC64_TPREL16_DS
:
16417 case R_PPC64_TPREL16_LO_DS
:
16418 case R_PPC64_TPREL16_HIGH
:
16419 case R_PPC64_TPREL16_HIGHA
:
16420 case R_PPC64_TPREL16_HIGHER
:
16421 case R_PPC64_TPREL16_HIGHERA
:
16422 case R_PPC64_TPREL16_HIGHEST
:
16423 case R_PPC64_TPREL16_HIGHESTA
:
16424 case R_PPC64_TPREL34
:
16426 && h
->elf
.root
.type
== bfd_link_hash_undefweak
16427 && h
->elf
.dynindx
== -1)
16429 /* Make this relocation against an undefined weak symbol
16430 resolve to zero. This is really just a tweak, since
16431 code using weak externs ought to check that they are
16432 defined before using them. */
16433 bfd_byte
*p
= contents
+ rel
->r_offset
- d_offset
;
16435 insn
= bfd_get_32 (input_bfd
, p
);
16436 insn
= _bfd_elf_ppc_at_tprel_transform (insn
, 13);
16438 bfd_put_32 (input_bfd
, insn
, p
);
16441 if (htab
->elf
.tls_sec
!= NULL
)
16442 addend
-= htab
->elf
.tls_sec
->vma
+ TP_OFFSET
;
16443 /* The TPREL16 relocs shouldn't really be used in shared
16444 libs or with non-local symbols as that will result in
16445 DT_TEXTREL being set, but support them anyway. */
16448 case R_PPC64_DTPREL16
:
16449 case R_PPC64_DTPREL16_LO
:
16450 case R_PPC64_DTPREL16_HI
:
16451 case R_PPC64_DTPREL16_HA
:
16452 case R_PPC64_DTPREL16_DS
:
16453 case R_PPC64_DTPREL16_LO_DS
:
16454 case R_PPC64_DTPREL16_HIGH
:
16455 case R_PPC64_DTPREL16_HIGHA
:
16456 case R_PPC64_DTPREL16_HIGHER
:
16457 case R_PPC64_DTPREL16_HIGHERA
:
16458 case R_PPC64_DTPREL16_HIGHEST
:
16459 case R_PPC64_DTPREL16_HIGHESTA
:
16460 case R_PPC64_DTPREL34
:
16461 if (htab
->elf
.tls_sec
!= NULL
)
16462 addend
-= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
16465 case R_PPC64_ADDR64_LOCAL
:
16466 addend
+= PPC64_LOCAL_ENTRY_OFFSET (h
!= NULL
16471 case R_PPC64_DTPMOD64
:
16476 case R_PPC64_TPREL64
:
16477 if (htab
->elf
.tls_sec
!= NULL
)
16478 addend
-= htab
->elf
.tls_sec
->vma
+ TP_OFFSET
;
16481 case R_PPC64_DTPREL64
:
16482 if (htab
->elf
.tls_sec
!= NULL
)
16483 addend
-= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
16484 /* Fall through. */
16486 /* Relocations that may need to be propagated if this is a
16488 case R_PPC64_REL30
:
16489 case R_PPC64_REL32
:
16490 case R_PPC64_REL64
:
16491 case R_PPC64_ADDR14
:
16492 case R_PPC64_ADDR14_BRNTAKEN
:
16493 case R_PPC64_ADDR14_BRTAKEN
:
16494 case R_PPC64_ADDR16
:
16495 case R_PPC64_ADDR16_DS
:
16496 case R_PPC64_ADDR16_HA
:
16497 case R_PPC64_ADDR16_HI
:
16498 case R_PPC64_ADDR16_HIGH
:
16499 case R_PPC64_ADDR16_HIGHA
:
16500 case R_PPC64_ADDR16_HIGHER
:
16501 case R_PPC64_ADDR16_HIGHERA
:
16502 case R_PPC64_ADDR16_HIGHEST
:
16503 case R_PPC64_ADDR16_HIGHESTA
:
16504 case R_PPC64_ADDR16_LO
:
16505 case R_PPC64_ADDR16_LO_DS
:
16506 case R_PPC64_ADDR16_HIGHER34
:
16507 case R_PPC64_ADDR16_HIGHERA34
:
16508 case R_PPC64_ADDR16_HIGHEST34
:
16509 case R_PPC64_ADDR16_HIGHESTA34
:
16510 case R_PPC64_ADDR24
:
16511 case R_PPC64_ADDR32
:
16512 case R_PPC64_ADDR64
:
16513 case R_PPC64_UADDR16
:
16514 case R_PPC64_UADDR32
:
16515 case R_PPC64_UADDR64
:
16517 case R_PPC64_D34_LO
:
16518 case R_PPC64_D34_HI30
:
16519 case R_PPC64_D34_HA30
:
16522 if ((input_section
->flags
& SEC_ALLOC
) == 0)
16525 if (NO_OPD_RELOCS
&& is_opd
)
16528 if (bfd_link_pic (info
)
16530 || h
->dyn_relocs
!= NULL
)
16531 && ((h
!= NULL
&& pc_dynrelocs (h
))
16532 || must_be_dyn_reloc (info
, r_type
)))
16534 ? h
->dyn_relocs
!= NULL
16535 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
))
16537 bfd_boolean skip
, relocate
;
16542 /* When generating a dynamic object, these relocations
16543 are copied into the output file to be resolved at run
16549 out_off
= _bfd_elf_section_offset (output_bfd
, info
,
16550 input_section
, rel
->r_offset
);
16551 if (out_off
== (bfd_vma
) -1)
16553 else if (out_off
== (bfd_vma
) -2)
16554 skip
= TRUE
, relocate
= TRUE
;
16555 out_off
+= (input_section
->output_section
->vma
16556 + input_section
->output_offset
);
16557 outrel
.r_offset
= out_off
;
16558 outrel
.r_addend
= rel
->r_addend
;
16560 /* Optimize unaligned reloc use. */
16561 if ((r_type
== R_PPC64_ADDR64
&& (out_off
& 7) != 0)
16562 || (r_type
== R_PPC64_UADDR64
&& (out_off
& 7) == 0))
16563 r_type
^= R_PPC64_ADDR64
^ R_PPC64_UADDR64
;
16564 else if ((r_type
== R_PPC64_ADDR32
&& (out_off
& 3) != 0)
16565 || (r_type
== R_PPC64_UADDR32
&& (out_off
& 3) == 0))
16566 r_type
^= R_PPC64_ADDR32
^ R_PPC64_UADDR32
;
16567 else if ((r_type
== R_PPC64_ADDR16
&& (out_off
& 1) != 0)
16568 || (r_type
== R_PPC64_UADDR16
&& (out_off
& 1) == 0))
16569 r_type
^= R_PPC64_ADDR16
^ R_PPC64_UADDR16
;
16572 memset (&outrel
, 0, sizeof outrel
);
16573 else if (!SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
)
16575 && r_type
!= R_PPC64_TOC
)
16577 indx
= h
->elf
.dynindx
;
16578 BFD_ASSERT (indx
!= -1);
16579 outrel
.r_info
= ELF64_R_INFO (indx
, r_type
);
16583 /* This symbol is local, or marked to become local,
16584 or this is an opd section reloc which must point
16585 at a local function. */
16586 outrel
.r_addend
+= relocation
;
16587 if (r_type
== R_PPC64_ADDR64
|| r_type
== R_PPC64_TOC
)
16589 if (is_opd
&& h
!= NULL
)
16591 /* Lie about opd entries. This case occurs
16592 when building shared libraries and we
16593 reference a function in another shared
16594 lib. The same thing happens for a weak
16595 definition in an application that's
16596 overridden by a strong definition in a
16597 shared lib. (I believe this is a generic
16598 bug in binutils handling of weak syms.)
16599 In these cases we won't use the opd
16600 entry in this lib. */
16601 unresolved_reloc
= FALSE
;
16604 && r_type
== R_PPC64_ADDR64
16606 ? h
->elf
.type
== STT_GNU_IFUNC
16607 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
))
16608 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
16611 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
16613 /* We need to relocate .opd contents for ld.so.
16614 Prelink also wants simple and consistent rules
16615 for relocs. This make all RELATIVE relocs have
16616 *r_offset equal to r_addend. */
16623 ? h
->elf
.type
== STT_GNU_IFUNC
16624 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
16626 info
->callbacks
->einfo
16627 /* xgettext:c-format */
16628 (_("%H: %s for indirect "
16629 "function `%pT' unsupported\n"),
16630 input_bfd
, input_section
, rel
->r_offset
,
16631 ppc64_elf_howto_table
[r_type
]->name
,
16635 else if (r_symndx
== STN_UNDEF
|| bfd_is_abs_section (sec
))
16637 else if (sec
== NULL
|| sec
->owner
== NULL
)
16639 bfd_set_error (bfd_error_bad_value
);
16644 asection
*osec
= sec
->output_section
;
16646 if ((osec
->flags
& SEC_THREAD_LOCAL
) != 0)
16648 /* TLS symbol values are relative to the
16649 TLS segment. Dynamic relocations for
16650 local TLS symbols therefore can't be
16651 reduced to a relocation against their
16652 section symbol because it holds the
16653 address of the section, not a value
16654 relative to the TLS segment. We could
16655 change the .tdata dynamic section symbol
16656 to be zero value but STN_UNDEF works
16657 and is used elsewhere, eg. for TPREL64
16658 GOT relocs against local TLS symbols. */
16659 osec
= htab
->elf
.tls_sec
;
16664 indx
= elf_section_data (osec
)->dynindx
;
16667 if ((osec
->flags
& SEC_READONLY
) == 0
16668 && htab
->elf
.data_index_section
!= NULL
)
16669 osec
= htab
->elf
.data_index_section
;
16671 osec
= htab
->elf
.text_index_section
;
16672 indx
= elf_section_data (osec
)->dynindx
;
16674 BFD_ASSERT (indx
!= 0);
16677 /* We are turning this relocation into one
16678 against a section symbol, so subtract out
16679 the output section's address but not the
16680 offset of the input section in the output
16682 outrel
.r_addend
-= osec
->vma
;
16685 outrel
.r_info
= ELF64_R_INFO (indx
, r_type
);
16689 sreloc
= elf_section_data (input_section
)->sreloc
;
16691 ? h
->elf
.type
== STT_GNU_IFUNC
16692 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
16694 sreloc
= htab
->elf
.irelplt
;
16696 htab
->local_ifunc_resolver
= 1;
16697 else if (is_static_defined (&h
->elf
))
16698 htab
->maybe_local_ifunc_resolver
= 1;
16700 if (sreloc
== NULL
)
16703 if (sreloc
->reloc_count
* sizeof (Elf64_External_Rela
)
16706 loc
= sreloc
->contents
;
16707 loc
+= sreloc
->reloc_count
++ * sizeof (Elf64_External_Rela
);
16708 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
16710 if (!warned_dynamic
16711 && !ppc64_glibc_dynamic_reloc (ELF64_R_TYPE (outrel
.r_info
)))
16713 info
->callbacks
->einfo
16714 /* xgettext:c-format */
16715 (_("%X%P: %pB: %s against %pT "
16716 "is not supported by glibc as a dynamic relocation\n"),
16718 ppc64_elf_howto_table
[ELF64_R_TYPE (outrel
.r_info
)]->name
,
16720 warned_dynamic
= TRUE
;
16723 /* If this reloc is against an external symbol, it will
16724 be computed at runtime, so there's no need to do
16725 anything now. However, for the sake of prelink ensure
16726 that the section contents are a known value. */
16729 unresolved_reloc
= FALSE
;
16730 /* The value chosen here is quite arbitrary as ld.so
16731 ignores section contents except for the special
16732 case of .opd where the contents might be accessed
16733 before relocation. Choose zero, as that won't
16734 cause reloc overflow. */
16737 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
16738 to improve backward compatibility with older
16740 if (r_type
== R_PPC64_ADDR64
)
16741 addend
= outrel
.r_addend
;
16742 /* Adjust pc_relative relocs to have zero in *r_offset. */
16743 else if (ppc64_elf_howto_table
[r_type
]->pc_relative
)
16744 addend
= outrel
.r_offset
;
16750 case R_PPC64_GLOB_DAT
:
16751 case R_PPC64_JMP_SLOT
:
16752 case R_PPC64_JMP_IREL
:
16753 case R_PPC64_RELATIVE
:
16754 /* We shouldn't ever see these dynamic relocs in relocatable
16756 /* Fall through. */
16758 case R_PPC64_PLTGOT16
:
16759 case R_PPC64_PLTGOT16_DS
:
16760 case R_PPC64_PLTGOT16_HA
:
16761 case R_PPC64_PLTGOT16_HI
:
16762 case R_PPC64_PLTGOT16_LO
:
16763 case R_PPC64_PLTGOT16_LO_DS
:
16764 case R_PPC64_PLTREL32
:
16765 case R_PPC64_PLTREL64
:
16766 /* These ones haven't been implemented yet. */
16768 info
->callbacks
->einfo
16769 /* xgettext:c-format */
16770 (_("%P: %pB: %s is not supported for `%pT'\n"),
16772 ppc64_elf_howto_table
[r_type
]->name
, sym_name
);
16774 bfd_set_error (bfd_error_invalid_operation
);
16779 /* Multi-instruction sequences that access the TOC can be
16780 optimized, eg. addis ra,r2,0; addi rb,ra,x;
16781 to nop; addi rb,r2,x; */
16787 case R_PPC64_GOT_TLSLD16_HI
:
16788 case R_PPC64_GOT_TLSGD16_HI
:
16789 case R_PPC64_GOT_TPREL16_HI
:
16790 case R_PPC64_GOT_DTPREL16_HI
:
16791 case R_PPC64_GOT16_HI
:
16792 case R_PPC64_TOC16_HI
:
16793 /* These relocs would only be useful if building up an
16794 offset to later add to r2, perhaps in an indexed
16795 addressing mode instruction. Don't try to optimize.
16796 Unfortunately, the possibility of someone building up an
16797 offset like this or even with the HA relocs, means that
16798 we need to check the high insn when optimizing the low
16802 case R_PPC64_PLTCALL_NOTOC
:
16803 if (!unresolved_reloc
)
16804 htab
->notoc_plt
= 1;
16805 /* Fall through. */
16806 case R_PPC64_PLTCALL
:
16807 if (unresolved_reloc
)
16809 /* No plt entry. Make this into a direct call. */
16810 bfd_byte
*p
= contents
+ rel
->r_offset
;
16811 insn
= bfd_get_32 (input_bfd
, p
);
16813 bfd_put_32 (input_bfd
, B_DOT
| insn
, p
);
16814 if (r_type
== R_PPC64_PLTCALL
)
16815 bfd_put_32 (input_bfd
, NOP
, p
+ 4);
16816 unresolved_reloc
= save_unresolved_reloc
;
16817 r_type
= R_PPC64_REL24
;
16821 case R_PPC64_PLTSEQ_NOTOC
:
16822 case R_PPC64_PLTSEQ
:
16823 if (unresolved_reloc
)
16825 unresolved_reloc
= FALSE
;
16830 case R_PPC64_PLT_PCREL34_NOTOC
:
16831 if (!unresolved_reloc
)
16832 htab
->notoc_plt
= 1;
16833 /* Fall through. */
16834 case R_PPC64_PLT_PCREL34
:
16835 if (unresolved_reloc
)
16837 bfd_byte
*p
= contents
+ rel
->r_offset
;
16838 bfd_put_32 (input_bfd
, PNOP
>> 32, p
);
16839 bfd_put_32 (input_bfd
, PNOP
, p
+ 4);
16840 unresolved_reloc
= FALSE
;
16845 case R_PPC64_PLT16_HA
:
16846 if (unresolved_reloc
)
16848 unresolved_reloc
= FALSE
;
16851 /* Fall through. */
16852 case R_PPC64_GOT_TLSLD16_HA
:
16853 case R_PPC64_GOT_TLSGD16_HA
:
16854 case R_PPC64_GOT_TPREL16_HA
:
16855 case R_PPC64_GOT_DTPREL16_HA
:
16856 case R_PPC64_GOT16_HA
:
16857 case R_PPC64_TOC16_HA
:
16858 if (htab
->do_toc_opt
&& relocation
+ addend
+ 0x8000 < 0x10000
16859 && !ppc64_elf_tdata (input_bfd
)->unexpected_toc_insn
)
16863 p
= contents
+ (rel
->r_offset
& ~3);
16864 bfd_put_32 (input_bfd
, NOP
, p
);
16869 case R_PPC64_PLT16_LO
:
16870 case R_PPC64_PLT16_LO_DS
:
16871 if (unresolved_reloc
)
16873 unresolved_reloc
= FALSE
;
16876 /* Fall through. */
16877 case R_PPC64_GOT_TLSLD16_LO
:
16878 case R_PPC64_GOT_TLSGD16_LO
:
16879 case R_PPC64_GOT_TPREL16_LO_DS
:
16880 case R_PPC64_GOT_DTPREL16_LO_DS
:
16881 case R_PPC64_GOT16_LO
:
16882 case R_PPC64_GOT16_LO_DS
:
16883 case R_PPC64_TOC16_LO
:
16884 case R_PPC64_TOC16_LO_DS
:
16885 if (htab
->do_toc_opt
&& relocation
+ addend
+ 0x8000 < 0x10000
16886 && !ppc64_elf_tdata (input_bfd
)->unexpected_toc_insn
)
16888 bfd_byte
*p
= contents
+ (rel
->r_offset
& ~3);
16889 insn
= bfd_get_32 (input_bfd
, p
);
16890 if ((insn
& (0x3fu
<< 26)) == 12u << 26 /* addic */)
16892 /* Transform addic to addi when we change reg. */
16893 insn
&= ~((0x3fu
<< 26) | (0x1f << 16));
16894 insn
|= (14u << 26) | (2 << 16);
16898 insn
&= ~(0x1f << 16);
16901 bfd_put_32 (input_bfd
, insn
, p
);
16905 case R_PPC64_TPREL16_HA
:
16906 if (htab
->do_tls_opt
&& relocation
+ addend
+ 0x8000 < 0x10000)
16908 bfd_byte
*p
= contents
+ (rel
->r_offset
& ~3);
16909 insn
= bfd_get_32 (input_bfd
, p
);
16910 if ((insn
& ((0x3fu
<< 26) | 0x1f << 16))
16911 != ((15u << 26) | (13 << 16)) /* addis rt,13,imm */)
16912 /* xgettext:c-format */
16913 info
->callbacks
->minfo
16914 (_("%H: warning: %s unexpected insn %#x.\n"),
16915 input_bfd
, input_section
, rel
->r_offset
,
16916 ppc64_elf_howto_table
[r_type
]->name
, insn
);
16919 bfd_put_32 (input_bfd
, NOP
, p
);
16925 case R_PPC64_TPREL16_LO
:
16926 case R_PPC64_TPREL16_LO_DS
:
16927 if (htab
->do_tls_opt
&& relocation
+ addend
+ 0x8000 < 0x10000)
16929 bfd_byte
*p
= contents
+ (rel
->r_offset
& ~3);
16930 insn
= bfd_get_32 (input_bfd
, p
);
16931 insn
&= ~(0x1f << 16);
16933 bfd_put_32 (input_bfd
, insn
, p
);
16938 /* Do any further special processing. */
16944 case R_PPC64_REL16_HA
:
16945 case R_PPC64_REL16_HIGHA
:
16946 case R_PPC64_REL16_HIGHERA
:
16947 case R_PPC64_REL16_HIGHESTA
:
16948 case R_PPC64_REL16DX_HA
:
16949 case R_PPC64_ADDR16_HA
:
16950 case R_PPC64_ADDR16_HIGHA
:
16951 case R_PPC64_ADDR16_HIGHERA
:
16952 case R_PPC64_ADDR16_HIGHESTA
:
16953 case R_PPC64_TOC16_HA
:
16954 case R_PPC64_SECTOFF_HA
:
16955 case R_PPC64_TPREL16_HA
:
16956 case R_PPC64_TPREL16_HIGHA
:
16957 case R_PPC64_TPREL16_HIGHERA
:
16958 case R_PPC64_TPREL16_HIGHESTA
:
16959 case R_PPC64_DTPREL16_HA
:
16960 case R_PPC64_DTPREL16_HIGHA
:
16961 case R_PPC64_DTPREL16_HIGHERA
:
16962 case R_PPC64_DTPREL16_HIGHESTA
:
16963 /* It's just possible that this symbol is a weak symbol
16964 that's not actually defined anywhere. In that case,
16965 'sec' would be NULL, and we should leave the symbol
16966 alone (it will be set to zero elsewhere in the link). */
16969 /* Fall through. */
16971 case R_PPC64_GOT16_HA
:
16972 case R_PPC64_PLTGOT16_HA
:
16973 case R_PPC64_PLT16_HA
:
16974 case R_PPC64_GOT_TLSGD16_HA
:
16975 case R_PPC64_GOT_TLSLD16_HA
:
16976 case R_PPC64_GOT_TPREL16_HA
:
16977 case R_PPC64_GOT_DTPREL16_HA
:
16978 /* Add 0x10000 if sign bit in 0:15 is set.
16979 Bits 0:15 are not used. */
16983 case R_PPC64_D34_HA30
:
16984 case R_PPC64_ADDR16_HIGHERA34
:
16985 case R_PPC64_ADDR16_HIGHESTA34
:
16986 case R_PPC64_REL16_HIGHERA34
:
16987 case R_PPC64_REL16_HIGHESTA34
:
16989 addend
+= 1ULL << 33;
16992 case R_PPC64_ADDR16_DS
:
16993 case R_PPC64_ADDR16_LO_DS
:
16994 case R_PPC64_GOT16_DS
:
16995 case R_PPC64_GOT16_LO_DS
:
16996 case R_PPC64_PLT16_LO_DS
:
16997 case R_PPC64_SECTOFF_DS
:
16998 case R_PPC64_SECTOFF_LO_DS
:
16999 case R_PPC64_TOC16_DS
:
17000 case R_PPC64_TOC16_LO_DS
:
17001 case R_PPC64_PLTGOT16_DS
:
17002 case R_PPC64_PLTGOT16_LO_DS
:
17003 case R_PPC64_GOT_TPREL16_DS
:
17004 case R_PPC64_GOT_TPREL16_LO_DS
:
17005 case R_PPC64_GOT_DTPREL16_DS
:
17006 case R_PPC64_GOT_DTPREL16_LO_DS
:
17007 case R_PPC64_TPREL16_DS
:
17008 case R_PPC64_TPREL16_LO_DS
:
17009 case R_PPC64_DTPREL16_DS
:
17010 case R_PPC64_DTPREL16_LO_DS
:
17011 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
17013 /* If this reloc is against an lq, lxv, or stxv insn, then
17014 the value must be a multiple of 16. This is somewhat of
17015 a hack, but the "correct" way to do this by defining _DQ
17016 forms of all the _DS relocs bloats all reloc switches in
17017 this file. It doesn't make much sense to use these
17018 relocs in data, so testing the insn should be safe. */
17019 if ((insn
& (0x3fu
<< 26)) == (56u << 26)
17020 || ((insn
& (0x3fu
<< 26)) == (61u << 26) && (insn
& 3) == 1))
17022 relocation
+= addend
;
17023 addend
= insn
& (mask
^ 3);
17024 if ((relocation
& mask
) != 0)
17026 relocation
^= relocation
& mask
;
17027 info
->callbacks
->einfo
17028 /* xgettext:c-format */
17029 (_("%H: error: %s not a multiple of %u\n"),
17030 input_bfd
, input_section
, rel
->r_offset
,
17031 ppc64_elf_howto_table
[r_type
]->name
,
17033 bfd_set_error (bfd_error_bad_value
);
17040 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
17041 because such sections are not SEC_ALLOC and thus ld.so will
17042 not process them. */
17043 howto
= ppc64_elf_howto_table
[(int) r_type
];
17044 if (unresolved_reloc
17045 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
17046 && h
->elf
.def_dynamic
)
17047 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
17048 rel
->r_offset
) != (bfd_vma
) -1)
17050 info
->callbacks
->einfo
17051 /* xgettext:c-format */
17052 (_("%H: unresolvable %s against `%pT'\n"),
17053 input_bfd
, input_section
, rel
->r_offset
,
17055 h
->elf
.root
.root
.string
);
17059 /* 16-bit fields in insns mostly have signed values, but a
17060 few insns have 16-bit unsigned values. Really, we should
17061 have different reloc types. */
17062 if (howto
->complain_on_overflow
!= complain_overflow_dont
17063 && howto
->dst_mask
== 0xffff
17064 && (input_section
->flags
& SEC_CODE
) != 0)
17066 enum complain_overflow complain
= complain_overflow_signed
;
17068 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
17069 if ((insn
& (0x3fu
<< 26)) == 10u << 26 /* cmpli */)
17070 complain
= complain_overflow_bitfield
;
17071 else if (howto
->rightshift
== 0
17072 ? ((insn
& (0x3fu
<< 26)) == 28u << 26 /* andi */
17073 || (insn
& (0x3fu
<< 26)) == 24u << 26 /* ori */
17074 || (insn
& (0x3fu
<< 26)) == 26u << 26 /* xori */)
17075 : ((insn
& (0x3fu
<< 26)) == 29u << 26 /* andis */
17076 || (insn
& (0x3fu
<< 26)) == 25u << 26 /* oris */
17077 || (insn
& (0x3fu
<< 26)) == 27u << 26 /* xoris */))
17078 complain
= complain_overflow_unsigned
;
17079 if (howto
->complain_on_overflow
!= complain
)
17081 alt_howto
= *howto
;
17082 alt_howto
.complain_on_overflow
= complain
;
17083 howto
= &alt_howto
;
17089 /* Split field relocs aren't handled by _bfd_final_link_relocate. */
17091 case R_PPC64_D34_LO
:
17092 case R_PPC64_D34_HI30
:
17093 case R_PPC64_D34_HA30
:
17094 case R_PPC64_PCREL34
:
17095 case R_PPC64_GOT_PCREL34
:
17096 case R_PPC64_TPREL34
:
17097 case R_PPC64_DTPREL34
:
17098 case R_PPC64_GOT_TLSGD34
:
17099 case R_PPC64_GOT_TLSLD34
:
17100 case R_PPC64_GOT_TPREL34
:
17101 case R_PPC64_GOT_DTPREL34
:
17102 case R_PPC64_PLT_PCREL34
:
17103 case R_PPC64_PLT_PCREL34_NOTOC
:
17105 case R_PPC64_PCREL28
:
17106 if (rel
->r_offset
+ 8 > input_section
->size
)
17107 r
= bfd_reloc_outofrange
;
17110 relocation
+= addend
;
17111 if (howto
->pc_relative
)
17112 relocation
-= (rel
->r_offset
17113 + input_section
->output_offset
17114 + input_section
->output_section
->vma
);
17115 relocation
>>= howto
->rightshift
;
17117 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
17119 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
17121 pinsn
&= ~howto
->dst_mask
;
17122 pinsn
|= (((relocation
<< 16) | (relocation
& 0xffff))
17123 & howto
->dst_mask
);
17124 bfd_put_32 (input_bfd
, pinsn
>> 32, contents
+ rel
->r_offset
);
17125 bfd_put_32 (input_bfd
, pinsn
, contents
+ rel
->r_offset
+ 4);
17127 if (howto
->complain_on_overflow
== complain_overflow_signed
17128 && (relocation
+ (1ULL << (howto
->bitsize
- 1))
17129 >= 1ULL << howto
->bitsize
))
17130 r
= bfd_reloc_overflow
;
17134 case R_PPC64_REL16DX_HA
:
17135 if (rel
->r_offset
+ 4 > input_section
->size
)
17136 r
= bfd_reloc_outofrange
;
17139 relocation
+= addend
;
17140 relocation
-= (rel
->r_offset
17141 + input_section
->output_offset
17142 + input_section
->output_section
->vma
);
17143 relocation
= (bfd_signed_vma
) relocation
>> 16;
17144 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
17146 insn
|= (relocation
& 0xffc1) | ((relocation
& 0x3e) << 15);
17147 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
17149 if (relocation
+ 0x8000 > 0xffff)
17150 r
= bfd_reloc_overflow
;
17155 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
17156 contents
, rel
->r_offset
,
17157 relocation
, addend
);
17160 if (r
!= bfd_reloc_ok
)
17162 char *more_info
= NULL
;
17163 const char *reloc_name
= howto
->name
;
17165 if (reloc_dest
!= DEST_NORMAL
)
17167 more_info
= bfd_malloc (strlen (reloc_name
) + 8);
17168 if (more_info
!= NULL
)
17170 strcpy (more_info
, reloc_name
);
17171 strcat (more_info
, (reloc_dest
== DEST_OPD
17172 ? " (OPD)" : " (stub)"));
17173 reloc_name
= more_info
;
17177 if (r
== bfd_reloc_overflow
)
17179 /* On code like "if (foo) foo();" don't report overflow
17180 on a branch to zero when foo is undefined. */
17182 && (reloc_dest
== DEST_STUB
17184 && (h
->elf
.root
.type
== bfd_link_hash_undefweak
17185 || h
->elf
.root
.type
== bfd_link_hash_undefined
)
17186 && is_branch_reloc (r_type
))))
17187 info
->callbacks
->reloc_overflow (info
, &h
->elf
.root
,
17188 sym_name
, reloc_name
,
17190 input_bfd
, input_section
,
17195 info
->callbacks
->einfo
17196 /* xgettext:c-format */
17197 (_("%H: %s against `%pT': error %d\n"),
17198 input_bfd
, input_section
, rel
->r_offset
,
17199 reloc_name
, sym_name
, (int) r
);
17202 if (more_info
!= NULL
)
17212 Elf_Internal_Shdr
*rel_hdr
;
17213 size_t deleted
= rel
- wrel
;
17215 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
17216 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
17217 if (rel_hdr
->sh_size
== 0)
17219 /* It is too late to remove an empty reloc section. Leave
17221 ??? What is wrong with an empty section??? */
17222 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
17225 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
17226 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
17227 input_section
->reloc_count
-= deleted
;
17230 /* If we're emitting relocations, then shortly after this function
17231 returns, reloc offsets and addends for this section will be
17232 adjusted. Worse, reloc symbol indices will be for the output
17233 file rather than the input. Save a copy of the relocs for
17234 opd_entry_value. */
17235 if (is_opd
&& (info
->emitrelocations
|| bfd_link_relocatable (info
)))
17238 amt
= input_section
->reloc_count
* sizeof (Elf_Internal_Rela
);
17239 rel
= bfd_alloc (input_bfd
, amt
);
17240 BFD_ASSERT (ppc64_elf_tdata (input_bfd
)->opd
.relocs
== NULL
);
17241 ppc64_elf_tdata (input_bfd
)->opd
.relocs
= rel
;
17244 memcpy (rel
, relocs
, amt
);
17249 /* Adjust the value of any local symbols in opd sections. */
17252 ppc64_elf_output_symbol_hook (struct bfd_link_info
*info
,
17253 const char *name ATTRIBUTE_UNUSED
,
17254 Elf_Internal_Sym
*elfsym
,
17255 asection
*input_sec
,
17256 struct elf_link_hash_entry
*h
)
17258 struct _opd_sec_data
*opd
;
17265 opd
= get_opd_info (input_sec
);
17266 if (opd
== NULL
|| opd
->adjust
== NULL
)
17269 value
= elfsym
->st_value
- input_sec
->output_offset
;
17270 if (!bfd_link_relocatable (info
))
17271 value
-= input_sec
->output_section
->vma
;
17273 adjust
= opd
->adjust
[OPD_NDX (value
)];
17277 elfsym
->st_value
+= adjust
;
17281 /* Finish up dynamic symbol handling. We set the contents of various
17282 dynamic sections here. */
17285 ppc64_elf_finish_dynamic_symbol (bfd
*output_bfd
,
17286 struct bfd_link_info
*info
,
17287 struct elf_link_hash_entry
*h
,
17288 Elf_Internal_Sym
*sym
)
17290 struct ppc_link_hash_table
*htab
;
17291 struct plt_entry
*ent
;
17293 htab
= ppc_hash_table (info
);
17297 if (!htab
->opd_abi
&& !h
->def_regular
)
17298 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
17299 if (ent
->plt
.offset
!= (bfd_vma
) -1)
17301 /* Mark the symbol as undefined, rather than as
17302 defined in glink. Leave the value if there were
17303 any relocations where pointer equality matters
17304 (this is a clue for the dynamic linker, to make
17305 function pointer comparisons work between an
17306 application and shared library), otherwise set it
17308 sym
->st_shndx
= SHN_UNDEF
;
17309 if (!h
->pointer_equality_needed
)
17311 else if (!h
->ref_regular_nonweak
)
17313 /* This breaks function pointer comparisons, but
17314 that is better than breaking tests for a NULL
17315 function pointer. */
17322 && (h
->root
.type
== bfd_link_hash_defined
17323 || h
->root
.type
== bfd_link_hash_defweak
)
17324 && (h
->root
.u
.def
.section
== htab
->elf
.sdynbss
17325 || h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
))
17327 /* This symbol needs a copy reloc. Set it up. */
17328 Elf_Internal_Rela rela
;
17332 if (h
->dynindx
== -1)
17335 rela
.r_offset
= defined_sym_val (h
);
17336 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_PPC64_COPY
);
17338 if (h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
17339 srel
= htab
->elf
.sreldynrelro
;
17341 srel
= htab
->elf
.srelbss
;
17342 loc
= srel
->contents
;
17343 loc
+= srel
->reloc_count
++ * sizeof (Elf64_External_Rela
);
17344 bfd_elf64_swap_reloca_out (output_bfd
, &rela
, loc
);
17350 /* Used to decide how to sort relocs in an optimal manner for the
17351 dynamic linker, before writing them out. */
17353 static enum elf_reloc_type_class
17354 ppc64_elf_reloc_type_class (const struct bfd_link_info
*info
,
17355 const asection
*rel_sec
,
17356 const Elf_Internal_Rela
*rela
)
17358 enum elf_ppc64_reloc_type r_type
;
17359 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
17361 if (rel_sec
== htab
->elf
.irelplt
)
17362 return reloc_class_ifunc
;
17364 r_type
= ELF64_R_TYPE (rela
->r_info
);
17367 case R_PPC64_RELATIVE
:
17368 return reloc_class_relative
;
17369 case R_PPC64_JMP_SLOT
:
17370 return reloc_class_plt
;
17372 return reloc_class_copy
;
17374 return reloc_class_normal
;
17378 /* Finish up the dynamic sections. */
17381 ppc64_elf_finish_dynamic_sections (bfd
*output_bfd
,
17382 struct bfd_link_info
*info
)
17384 struct ppc_link_hash_table
*htab
;
17388 htab
= ppc_hash_table (info
);
17392 dynobj
= htab
->elf
.dynobj
;
17393 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
17395 if (htab
->elf
.dynamic_sections_created
)
17397 Elf64_External_Dyn
*dyncon
, *dynconend
;
17399 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
17402 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
17403 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
17404 for (; dyncon
< dynconend
; dyncon
++)
17406 Elf_Internal_Dyn dyn
;
17409 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
17416 case DT_PPC64_GLINK
:
17418 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
17419 /* We stupidly defined DT_PPC64_GLINK to be the start
17420 of glink rather than the first entry point, which is
17421 what ld.so needs, and now have a bigger stub to
17422 support automatic multiple TOCs. */
17423 dyn
.d_un
.d_ptr
+= GLINK_PLTRESOLVE_SIZE (htab
) - 8 * 4;
17427 s
= bfd_get_section_by_name (output_bfd
, ".opd");
17430 dyn
.d_un
.d_ptr
= s
->vma
;
17434 if ((htab
->do_multi_toc
&& htab
->multi_toc_needed
)
17435 || htab
->notoc_plt
)
17436 dyn
.d_un
.d_val
|= PPC64_OPT_MULTI_TOC
;
17437 if (htab
->has_plt_localentry0
)
17438 dyn
.d_un
.d_val
|= PPC64_OPT_LOCALENTRY
;
17441 case DT_PPC64_OPDSZ
:
17442 s
= bfd_get_section_by_name (output_bfd
, ".opd");
17445 dyn
.d_un
.d_val
= s
->size
;
17449 s
= htab
->elf
.splt
;
17450 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
17454 s
= htab
->elf
.srelplt
;
17455 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
17459 dyn
.d_un
.d_val
= htab
->elf
.srelplt
->size
;
17463 if (htab
->local_ifunc_resolver
)
17464 info
->callbacks
->einfo
17465 (_("%X%P: text relocations and GNU indirect "
17466 "functions will result in a segfault at runtime\n"));
17467 else if (htab
->maybe_local_ifunc_resolver
)
17468 info
->callbacks
->einfo
17469 (_("%P: warning: text relocations and GNU indirect "
17470 "functions may result in a segfault at runtime\n"));
17474 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
17478 if (htab
->elf
.sgot
!= NULL
&& htab
->elf
.sgot
->size
!= 0
17479 && htab
->elf
.sgot
->output_section
!= bfd_abs_section_ptr
)
17481 /* Fill in the first entry in the global offset table.
17482 We use it to hold the link-time TOCbase. */
17483 bfd_put_64 (output_bfd
,
17484 elf_gp (output_bfd
) + TOC_BASE_OFF
,
17485 htab
->elf
.sgot
->contents
);
17487 /* Set .got entry size. */
17488 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
17492 if (htab
->elf
.splt
!= NULL
&& htab
->elf
.splt
->size
!= 0
17493 && htab
->elf
.splt
->output_section
!= bfd_abs_section_ptr
)
17495 /* Set .plt entry size. */
17496 elf_section_data (htab
->elf
.splt
->output_section
)->this_hdr
.sh_entsize
17497 = PLT_ENTRY_SIZE (htab
);
17500 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
17501 brlt ourselves if emitrelocations. */
17502 if (htab
->brlt
!= NULL
17503 && htab
->brlt
->reloc_count
!= 0
17504 && !_bfd_elf_link_output_relocs (output_bfd
,
17506 elf_section_data (htab
->brlt
)->rela
.hdr
,
17507 elf_section_data (htab
->brlt
)->relocs
,
17511 if (htab
->glink
!= NULL
17512 && htab
->glink
->reloc_count
!= 0
17513 && !_bfd_elf_link_output_relocs (output_bfd
,
17515 elf_section_data (htab
->glink
)->rela
.hdr
,
17516 elf_section_data (htab
->glink
)->relocs
,
17521 if (htab
->glink_eh_frame
!= NULL
17522 && htab
->glink_eh_frame
->size
!= 0
17523 && htab
->glink_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
17524 && !_bfd_elf_write_section_eh_frame (output_bfd
, info
,
17525 htab
->glink_eh_frame
,
17526 htab
->glink_eh_frame
->contents
))
17529 /* We need to handle writing out multiple GOT sections ourselves,
17530 since we didn't add them to DYNOBJ. We know dynobj is the first
17532 while ((dynobj
= dynobj
->link
.next
) != NULL
)
17536 if (!is_ppc64_elf (dynobj
))
17539 s
= ppc64_elf_tdata (dynobj
)->got
;
17542 && s
->output_section
!= bfd_abs_section_ptr
17543 && !bfd_set_section_contents (output_bfd
, s
->output_section
,
17544 s
->contents
, s
->output_offset
,
17547 s
= ppc64_elf_tdata (dynobj
)->relgot
;
17550 && s
->output_section
!= bfd_abs_section_ptr
17551 && !bfd_set_section_contents (output_bfd
, s
->output_section
,
17552 s
->contents
, s
->output_offset
,
17560 #include "elf64-target.h"
17562 /* FreeBSD support */
17564 #undef TARGET_LITTLE_SYM
17565 #undef TARGET_LITTLE_NAME
17567 #undef TARGET_BIG_SYM
17568 #define TARGET_BIG_SYM powerpc_elf64_fbsd_vec
17569 #undef TARGET_BIG_NAME
17570 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
17573 #define ELF_OSABI ELFOSABI_FREEBSD
17576 #define elf64_bed elf64_powerpc_fbsd_bed
17578 #include "elf64-target.h"