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 powerxx 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 powerxx 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 powerxx instructions in linkage stubs. */
3242 unsigned int powerxx_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
->powerxx_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 62: /* std, stq */
8609 if ((insn2
& 1) != 0)
8611 insn1
= ((1ULL << 58) | (1ULL << 52)
8612 | ((insn2
& 2) == 0 ? 61ULL << 26 : 60ULL << 26)
8613 | (insn2
& (31ULL << 21)));
8614 off
= insn2
& 0xfffc;
8619 *pinsn2
= (uint64_t) NOP
<< 32;
8620 *poff
= (off
^ 0x8000) - 0x8000;
8624 /* Examine all relocs referencing .toc sections in order to remove
8625 unused .toc entries. */
8628 ppc64_elf_edit_toc (struct bfd_link_info
*info
)
8631 struct adjust_toc_info toc_inf
;
8632 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
8634 htab
->do_toc_opt
= 1;
8635 toc_inf
.global_toc_syms
= TRUE
;
8636 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
8638 asection
*toc
, *sec
;
8639 Elf_Internal_Shdr
*symtab_hdr
;
8640 Elf_Internal_Sym
*local_syms
;
8641 Elf_Internal_Rela
*relstart
, *rel
, *toc_relocs
;
8642 unsigned long *skip
, *drop
;
8643 unsigned char *used
;
8644 unsigned char *keep
, last
, some_unused
;
8646 if (!is_ppc64_elf (ibfd
))
8649 toc
= bfd_get_section_by_name (ibfd
, ".toc");
8652 || toc
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
8653 || discarded_section (toc
))
8658 symtab_hdr
= &elf_symtab_hdr (ibfd
);
8660 /* Look at sections dropped from the final link. */
8663 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
8665 if (sec
->reloc_count
== 0
8666 || !discarded_section (sec
)
8667 || get_opd_info (sec
)
8668 || (sec
->flags
& SEC_ALLOC
) == 0
8669 || (sec
->flags
& SEC_DEBUGGING
) != 0)
8672 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
, FALSE
);
8673 if (relstart
== NULL
)
8676 /* Run through the relocs to see which toc entries might be
8678 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
8680 enum elf_ppc64_reloc_type r_type
;
8681 unsigned long r_symndx
;
8683 struct elf_link_hash_entry
*h
;
8684 Elf_Internal_Sym
*sym
;
8687 r_type
= ELF64_R_TYPE (rel
->r_info
);
8694 case R_PPC64_TOC16_LO
:
8695 case R_PPC64_TOC16_HI
:
8696 case R_PPC64_TOC16_HA
:
8697 case R_PPC64_TOC16_DS
:
8698 case R_PPC64_TOC16_LO_DS
:
8702 r_symndx
= ELF64_R_SYM (rel
->r_info
);
8703 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
8711 val
= h
->root
.u
.def
.value
;
8713 val
= sym
->st_value
;
8714 val
+= rel
->r_addend
;
8716 if (val
>= toc
->size
)
8719 /* Anything in the toc ought to be aligned to 8 bytes.
8720 If not, don't mark as unused. */
8726 skip
= bfd_zmalloc (sizeof (*skip
) * (toc
->size
+ 15) / 8);
8731 skip
[val
>> 3] = ref_from_discarded
;
8734 if (elf_section_data (sec
)->relocs
!= relstart
)
8738 /* For largetoc loads of address constants, we can convert
8739 . addis rx,2,addr@got@ha
8740 . ld ry,addr@got@l(rx)
8742 . addis rx,2,addr@toc@ha
8743 . addi ry,rx,addr@toc@l
8744 when addr is within 2G of the toc pointer. This then means
8745 that the word storing "addr" in the toc is no longer needed. */
8747 if (!ppc64_elf_tdata (ibfd
)->has_small_toc_reloc
8748 && toc
->output_section
->rawsize
< (bfd_vma
) 1 << 31
8749 && toc
->reloc_count
!= 0)
8751 /* Read toc relocs. */
8752 toc_relocs
= _bfd_elf_link_read_relocs (ibfd
, toc
, NULL
, NULL
,
8754 if (toc_relocs
== NULL
)
8757 for (rel
= toc_relocs
; rel
< toc_relocs
+ toc
->reloc_count
; ++rel
)
8759 enum elf_ppc64_reloc_type r_type
;
8760 unsigned long r_symndx
;
8762 struct elf_link_hash_entry
*h
;
8763 Elf_Internal_Sym
*sym
;
8766 r_type
= ELF64_R_TYPE (rel
->r_info
);
8767 if (r_type
!= R_PPC64_ADDR64
)
8770 r_symndx
= ELF64_R_SYM (rel
->r_info
);
8771 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
8776 || sym_sec
->output_section
== NULL
8777 || discarded_section (sym_sec
))
8780 if (!SYMBOL_REFERENCES_LOCAL (info
, h
))
8785 if (h
->type
== STT_GNU_IFUNC
)
8787 val
= h
->root
.u
.def
.value
;
8791 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
8793 val
= sym
->st_value
;
8795 val
+= rel
->r_addend
;
8796 val
+= sym_sec
->output_section
->vma
+ sym_sec
->output_offset
;
8798 /* We don't yet know the exact toc pointer value, but we
8799 know it will be somewhere in the toc section. Don't
8800 optimize if the difference from any possible toc
8801 pointer is outside [ff..f80008000, 7fff7fff]. */
8802 addr
= toc
->output_section
->vma
+ TOC_BASE_OFF
;
8803 if (val
- addr
+ (bfd_vma
) 0x80008000 >= (bfd_vma
) 1 << 32)
8806 addr
= toc
->output_section
->vma
+ toc
->output_section
->rawsize
;
8807 if (val
- addr
+ (bfd_vma
) 0x80008000 >= (bfd_vma
) 1 << 32)
8812 skip
= bfd_zmalloc (sizeof (*skip
) * (toc
->size
+ 15) / 8);
8817 skip
[rel
->r_offset
>> 3]
8818 |= can_optimize
| ((rel
- toc_relocs
) << 2);
8825 used
= bfd_zmalloc (sizeof (*used
) * (toc
->size
+ 7) / 8);
8829 if (local_syms
!= NULL
8830 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
8834 && elf_section_data (sec
)->relocs
!= relstart
)
8836 if (toc_relocs
!= NULL
8837 && elf_section_data (toc
)->relocs
!= toc_relocs
)
8844 /* Now check all kept sections that might reference the toc.
8845 Check the toc itself last. */
8846 for (sec
= (ibfd
->sections
== toc
&& toc
->next
? toc
->next
8849 sec
= (sec
== toc
? NULL
8850 : sec
->next
== NULL
? toc
8851 : sec
->next
== toc
&& toc
->next
? toc
->next
8856 if (sec
->reloc_count
== 0
8857 || discarded_section (sec
)
8858 || get_opd_info (sec
)
8859 || (sec
->flags
& SEC_ALLOC
) == 0
8860 || (sec
->flags
& SEC_DEBUGGING
) != 0)
8863 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
8865 if (relstart
== NULL
)
8871 /* Mark toc entries referenced as used. */
8875 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
8877 enum elf_ppc64_reloc_type r_type
;
8878 unsigned long r_symndx
;
8880 struct elf_link_hash_entry
*h
;
8881 Elf_Internal_Sym
*sym
;
8884 r_type
= ELF64_R_TYPE (rel
->r_info
);
8888 case R_PPC64_TOC16_LO
:
8889 case R_PPC64_TOC16_HI
:
8890 case R_PPC64_TOC16_HA
:
8891 case R_PPC64_TOC16_DS
:
8892 case R_PPC64_TOC16_LO_DS
:
8893 /* In case we're taking addresses of toc entries. */
8894 case R_PPC64_ADDR64
:
8901 r_symndx
= ELF64_R_SYM (rel
->r_info
);
8902 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
8913 val
= h
->root
.u
.def
.value
;
8915 val
= sym
->st_value
;
8916 val
+= rel
->r_addend
;
8918 if (val
>= toc
->size
)
8921 if ((skip
[val
>> 3] & can_optimize
) != 0)
8928 case R_PPC64_TOC16_HA
:
8931 case R_PPC64_TOC16_LO_DS
:
8932 off
= rel
->r_offset
;
8933 off
+= (bfd_big_endian (ibfd
) ? -2 : 3);
8934 if (!bfd_get_section_contents (ibfd
, sec
, &opc
,
8940 if ((opc
& (0x3f << 2)) == (58u << 2))
8945 /* Wrong sort of reloc, or not a ld. We may
8946 as well clear ref_from_discarded too. */
8953 /* For the toc section, we only mark as used if this
8954 entry itself isn't unused. */
8955 else if ((used
[rel
->r_offset
>> 3]
8956 || !(skip
[rel
->r_offset
>> 3] & ref_from_discarded
))
8959 /* Do all the relocs again, to catch reference
8968 if (elf_section_data (sec
)->relocs
!= relstart
)
8972 /* Merge the used and skip arrays. Assume that TOC
8973 doublewords not appearing as either used or unused belong
8974 to an entry more than one doubleword in size. */
8975 for (drop
= skip
, keep
= used
, last
= 0, some_unused
= 0;
8976 drop
< skip
+ (toc
->size
+ 7) / 8;
8981 *drop
&= ~ref_from_discarded
;
8982 if ((*drop
& can_optimize
) != 0)
8986 else if ((*drop
& ref_from_discarded
) != 0)
8989 last
= ref_from_discarded
;
8999 bfd_byte
*contents
, *src
;
9001 Elf_Internal_Sym
*sym
;
9002 bfd_boolean local_toc_syms
= FALSE
;
9004 /* Shuffle the toc contents, and at the same time convert the
9005 skip array from booleans into offsets. */
9006 if (!bfd_malloc_and_get_section (ibfd
, toc
, &contents
))
9009 elf_section_data (toc
)->this_hdr
.contents
= contents
;
9011 for (src
= contents
, off
= 0, drop
= skip
;
9012 src
< contents
+ toc
->size
;
9015 if ((*drop
& (can_optimize
| ref_from_discarded
)) != 0)
9020 memcpy (src
- off
, src
, 8);
9024 toc
->rawsize
= toc
->size
;
9025 toc
->size
= src
- contents
- off
;
9027 /* Adjust addends for relocs against the toc section sym,
9028 and optimize any accesses we can. */
9029 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
9031 if (sec
->reloc_count
== 0
9032 || discarded_section (sec
))
9035 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
9037 if (relstart
== NULL
)
9040 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
9042 enum elf_ppc64_reloc_type r_type
;
9043 unsigned long r_symndx
;
9045 struct elf_link_hash_entry
*h
;
9048 r_type
= ELF64_R_TYPE (rel
->r_info
);
9055 case R_PPC64_TOC16_LO
:
9056 case R_PPC64_TOC16_HI
:
9057 case R_PPC64_TOC16_HA
:
9058 case R_PPC64_TOC16_DS
:
9059 case R_PPC64_TOC16_LO_DS
:
9060 case R_PPC64_ADDR64
:
9064 r_symndx
= ELF64_R_SYM (rel
->r_info
);
9065 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
9073 val
= h
->root
.u
.def
.value
;
9076 val
= sym
->st_value
;
9078 local_toc_syms
= TRUE
;
9081 val
+= rel
->r_addend
;
9083 if (val
> toc
->rawsize
)
9085 else if ((skip
[val
>> 3] & ref_from_discarded
) != 0)
9087 else if ((skip
[val
>> 3] & can_optimize
) != 0)
9089 Elf_Internal_Rela
*tocrel
9090 = toc_relocs
+ (skip
[val
>> 3] >> 2);
9091 unsigned long tsym
= ELF64_R_SYM (tocrel
->r_info
);
9095 case R_PPC64_TOC16_HA
:
9096 rel
->r_info
= ELF64_R_INFO (tsym
, R_PPC64_TOC16_HA
);
9099 case R_PPC64_TOC16_LO_DS
:
9100 rel
->r_info
= ELF64_R_INFO (tsym
, R_PPC64_LO_DS_OPT
);
9104 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
9106 info
->callbacks
->einfo
9107 /* xgettext:c-format */
9108 (_("%H: %s references "
9109 "optimized away TOC entry\n"),
9110 ibfd
, sec
, rel
->r_offset
,
9111 ppc64_elf_howto_table
[r_type
]->name
);
9112 bfd_set_error (bfd_error_bad_value
);
9115 rel
->r_addend
= tocrel
->r_addend
;
9116 elf_section_data (sec
)->relocs
= relstart
;
9120 if (h
!= NULL
|| sym
->st_value
!= 0)
9123 rel
->r_addend
-= skip
[val
>> 3];
9124 elf_section_data (sec
)->relocs
= relstart
;
9127 if (elf_section_data (sec
)->relocs
!= relstart
)
9131 /* We shouldn't have local or global symbols defined in the TOC,
9132 but handle them anyway. */
9133 if (local_syms
!= NULL
)
9134 for (sym
= local_syms
;
9135 sym
< local_syms
+ symtab_hdr
->sh_info
;
9137 if (sym
->st_value
!= 0
9138 && bfd_section_from_elf_index (ibfd
, sym
->st_shndx
) == toc
)
9142 if (sym
->st_value
> toc
->rawsize
)
9143 i
= toc
->rawsize
>> 3;
9145 i
= sym
->st_value
>> 3;
9147 if ((skip
[i
] & (ref_from_discarded
| can_optimize
)) != 0)
9151 (_("%s defined on removed toc entry"),
9152 bfd_elf_sym_name (ibfd
, symtab_hdr
, sym
, NULL
));
9155 while ((skip
[i
] & (ref_from_discarded
| can_optimize
)));
9156 sym
->st_value
= (bfd_vma
) i
<< 3;
9159 sym
->st_value
-= skip
[i
];
9160 symtab_hdr
->contents
= (unsigned char *) local_syms
;
9163 /* Adjust any global syms defined in this toc input section. */
9164 if (toc_inf
.global_toc_syms
)
9167 toc_inf
.skip
= skip
;
9168 toc_inf
.global_toc_syms
= FALSE
;
9169 elf_link_hash_traverse (elf_hash_table (info
), adjust_toc_syms
,
9173 if (toc
->reloc_count
!= 0)
9175 Elf_Internal_Shdr
*rel_hdr
;
9176 Elf_Internal_Rela
*wrel
;
9179 /* Remove unused toc relocs, and adjust those we keep. */
9180 if (toc_relocs
== NULL
)
9181 toc_relocs
= _bfd_elf_link_read_relocs (ibfd
, toc
, NULL
, NULL
,
9183 if (toc_relocs
== NULL
)
9187 for (rel
= toc_relocs
; rel
< toc_relocs
+ toc
->reloc_count
; ++rel
)
9188 if ((skip
[rel
->r_offset
>> 3]
9189 & (ref_from_discarded
| can_optimize
)) == 0)
9191 wrel
->r_offset
= rel
->r_offset
- skip
[rel
->r_offset
>> 3];
9192 wrel
->r_info
= rel
->r_info
;
9193 wrel
->r_addend
= rel
->r_addend
;
9196 else if (!dec_dynrel_count (rel
->r_info
, toc
, info
,
9197 &local_syms
, NULL
, NULL
))
9200 elf_section_data (toc
)->relocs
= toc_relocs
;
9201 toc
->reloc_count
= wrel
- toc_relocs
;
9202 rel_hdr
= _bfd_elf_single_rel_hdr (toc
);
9203 sz
= rel_hdr
->sh_entsize
;
9204 rel_hdr
->sh_size
= toc
->reloc_count
* sz
;
9207 else if (toc_relocs
!= NULL
9208 && elf_section_data (toc
)->relocs
!= toc_relocs
)
9211 if (local_syms
!= NULL
9212 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
9214 if (!info
->keep_memory
)
9217 symtab_hdr
->contents
= (unsigned char *) local_syms
;
9222 /* Look for cases where we can change an indirect GOT access to
9223 a GOT relative or PC relative access, possibly reducing the
9224 number of GOT entries. */
9225 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
9228 Elf_Internal_Shdr
*symtab_hdr
;
9229 Elf_Internal_Sym
*local_syms
;
9230 Elf_Internal_Rela
*relstart
, *rel
;
9233 if (!is_ppc64_elf (ibfd
))
9236 if (!ppc64_elf_tdata (ibfd
)->has_optrel
)
9239 sec
= ppc64_elf_tdata (ibfd
)->got
;
9242 got
= sec
->output_section
->vma
+ sec
->output_offset
+ 0x8000;
9245 symtab_hdr
= &elf_symtab_hdr (ibfd
);
9247 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
9249 if (sec
->reloc_count
== 0
9250 || !ppc64_elf_section_data (sec
)->has_optrel
9251 || discarded_section (sec
))
9254 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
9256 if (relstart
== NULL
)
9259 if (local_syms
!= NULL
9260 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
9264 && elf_section_data (sec
)->relocs
!= relstart
)
9269 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
9271 enum elf_ppc64_reloc_type r_type
;
9272 unsigned long r_symndx
;
9273 Elf_Internal_Sym
*sym
;
9275 struct elf_link_hash_entry
*h
;
9276 struct got_entry
*ent
;
9278 unsigned char buf
[8];
9280 enum {no_check
, check_lo
, check_ha
} insn_check
;
9282 r_type
= ELF64_R_TYPE (rel
->r_info
);
9286 insn_check
= no_check
;
9289 case R_PPC64_PLT16_HA
:
9290 case R_PPC64_GOT_TLSLD16_HA
:
9291 case R_PPC64_GOT_TLSGD16_HA
:
9292 case R_PPC64_GOT_TPREL16_HA
:
9293 case R_PPC64_GOT_DTPREL16_HA
:
9294 case R_PPC64_GOT16_HA
:
9295 case R_PPC64_TOC16_HA
:
9296 insn_check
= check_ha
;
9299 case R_PPC64_PLT16_LO
:
9300 case R_PPC64_PLT16_LO_DS
:
9301 case R_PPC64_GOT_TLSLD16_LO
:
9302 case R_PPC64_GOT_TLSGD16_LO
:
9303 case R_PPC64_GOT_TPREL16_LO_DS
:
9304 case R_PPC64_GOT_DTPREL16_LO_DS
:
9305 case R_PPC64_GOT16_LO
:
9306 case R_PPC64_GOT16_LO_DS
:
9307 case R_PPC64_TOC16_LO
:
9308 case R_PPC64_TOC16_LO_DS
:
9309 insn_check
= check_lo
;
9313 if (insn_check
!= no_check
)
9315 bfd_vma off
= rel
->r_offset
& ~3;
9317 if (!bfd_get_section_contents (ibfd
, sec
, buf
, off
, 4))
9320 insn
= bfd_get_32 (ibfd
, buf
);
9321 if (insn_check
== check_lo
9322 ? !ok_lo_toc_insn (insn
, r_type
)
9323 : ((insn
& ((0x3fu
<< 26) | 0x1f << 16))
9324 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9328 ppc64_elf_tdata (ibfd
)->unexpected_toc_insn
= 1;
9329 sprintf (str
, "%#08x", insn
);
9330 info
->callbacks
->einfo
9331 /* xgettext:c-format */
9332 (_("%H: got/toc optimization is not supported for"
9333 " %s instruction\n"),
9334 ibfd
, sec
, rel
->r_offset
& ~3, str
);
9341 /* Note that we don't delete GOT entries for
9342 R_PPC64_GOT16_DS since we'd need a lot more
9343 analysis. For starters, the preliminary layout is
9344 before the GOT, PLT, dynamic sections and stubs are
9345 laid out. Then we'd need to allow for changes in
9346 distance between sections caused by alignment. */
9350 case R_PPC64_GOT16_HA
:
9351 case R_PPC64_GOT16_LO_DS
:
9352 case R_PPC64_GOT_PCREL34
:
9356 r_symndx
= ELF64_R_SYM (rel
->r_info
);
9357 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
9362 || sym_sec
->output_section
== NULL
9363 || discarded_section (sym_sec
))
9366 if ((h
? h
->type
: ELF_ST_TYPE (sym
->st_info
)) == STT_GNU_IFUNC
)
9369 if (!SYMBOL_REFERENCES_LOCAL (info
, h
))
9373 val
= h
->root
.u
.def
.value
;
9375 val
= sym
->st_value
;
9376 val
+= rel
->r_addend
;
9377 val
+= sym_sec
->output_section
->vma
+ sym_sec
->output_offset
;
9379 /* Fudge factor to allow for the fact that the preliminary layout
9380 isn't exact. Reduce limits by this factor. */
9381 #define LIMIT_ADJUST(LIMIT) ((LIMIT) - (LIMIT) / 16)
9388 case R_PPC64_GOT16_HA
:
9389 if (val
- got
+ LIMIT_ADJUST (0x80008000ULL
)
9390 >= LIMIT_ADJUST (0x100000000ULL
))
9393 if (!bfd_get_section_contents (ibfd
, sec
, buf
,
9394 rel
->r_offset
& ~3, 4))
9396 insn
= bfd_get_32 (ibfd
, buf
);
9397 if (((insn
& ((0x3fu
<< 26) | 0x1f << 16))
9398 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9402 case R_PPC64_GOT16_LO_DS
:
9403 if (val
- got
+ LIMIT_ADJUST (0x80008000ULL
)
9404 >= LIMIT_ADJUST (0x100000000ULL
))
9406 if (!bfd_get_section_contents (ibfd
, sec
, buf
,
9407 rel
->r_offset
& ~3, 4))
9409 insn
= bfd_get_32 (ibfd
, buf
);
9410 if ((insn
& (0x3fu
<< 26 | 0x3)) != 58u << 26 /* ld */)
9414 case R_PPC64_GOT_PCREL34
:
9416 pc
+= sec
->output_section
->vma
+ sec
->output_offset
;
9417 if (val
- pc
+ LIMIT_ADJUST (1ULL << 33)
9418 >= LIMIT_ADJUST (1ULL << 34))
9420 if (!bfd_get_section_contents (ibfd
, sec
, buf
,
9421 rel
->r_offset
& ~3, 8))
9423 insn
= bfd_get_32 (ibfd
, buf
);
9424 if ((insn
& (-1u << 18)) != ((1u << 26) | (1u << 20)))
9426 insn
= bfd_get_32 (ibfd
, buf
+ 4);
9427 if ((insn
& (0x3fu
<< 26)) != 57u << 26)
9437 struct got_entry
**local_got_ents
= elf_local_got_ents (ibfd
);
9438 ent
= local_got_ents
[r_symndx
];
9440 for (; ent
!= NULL
; ent
= ent
->next
)
9441 if (ent
->addend
== rel
->r_addend
9442 && ent
->owner
== ibfd
9443 && ent
->tls_type
== 0)
9445 BFD_ASSERT (ent
&& ent
->got
.refcount
> 0);
9446 ent
->got
.refcount
-= 1;
9449 if (elf_section_data (sec
)->relocs
!= relstart
)
9453 if (local_syms
!= NULL
9454 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
9456 if (!info
->keep_memory
)
9459 symtab_hdr
->contents
= (unsigned char *) local_syms
;
9466 /* Return true iff input section I references the TOC using
9467 instructions limited to +/-32k offsets. */
9470 ppc64_elf_has_small_toc_reloc (asection
*i
)
9472 return (is_ppc64_elf (i
->owner
)
9473 && ppc64_elf_tdata (i
->owner
)->has_small_toc_reloc
);
9476 /* Allocate space for one GOT entry. */
9479 allocate_got (struct elf_link_hash_entry
*h
,
9480 struct bfd_link_info
*info
,
9481 struct got_entry
*gent
)
9483 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
9484 struct ppc_link_hash_entry
*eh
= ppc_elf_hash_entry (h
);
9485 int entsize
= (gent
->tls_type
& eh
->tls_mask
& (TLS_GD
| TLS_LD
)
9487 int rentsize
= (gent
->tls_type
& eh
->tls_mask
& TLS_GD
9488 ? 2 : 1) * sizeof (Elf64_External_Rela
);
9489 asection
*got
= ppc64_elf_tdata (gent
->owner
)->got
;
9491 gent
->got
.offset
= got
->size
;
9492 got
->size
+= entsize
;
9494 if (h
->type
== STT_GNU_IFUNC
)
9496 htab
->elf
.irelplt
->size
+= rentsize
;
9497 htab
->got_reli_size
+= rentsize
;
9499 else if (((bfd_link_pic (info
)
9500 && !(gent
->tls_type
!= 0
9501 && bfd_link_executable (info
)
9502 && SYMBOL_REFERENCES_LOCAL (info
, h
)))
9503 || (htab
->elf
.dynamic_sections_created
9505 && !SYMBOL_REFERENCES_LOCAL (info
, h
)))
9506 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
9508 asection
*relgot
= ppc64_elf_tdata (gent
->owner
)->relgot
;
9509 relgot
->size
+= rentsize
;
9513 /* This function merges got entries in the same toc group. */
9516 merge_got_entries (struct got_entry
**pent
)
9518 struct got_entry
*ent
, *ent2
;
9520 for (ent
= *pent
; ent
!= NULL
; ent
= ent
->next
)
9521 if (!ent
->is_indirect
)
9522 for (ent2
= ent
->next
; ent2
!= NULL
; ent2
= ent2
->next
)
9523 if (!ent2
->is_indirect
9524 && ent2
->addend
== ent
->addend
9525 && ent2
->tls_type
== ent
->tls_type
9526 && elf_gp (ent2
->owner
) == elf_gp (ent
->owner
))
9528 ent2
->is_indirect
= TRUE
;
9529 ent2
->got
.ent
= ent
;
9533 /* If H is undefined, make it dynamic if that makes sense. */
9536 ensure_undef_dynamic (struct bfd_link_info
*info
,
9537 struct elf_link_hash_entry
*h
)
9539 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
9541 if (htab
->dynamic_sections_created
9542 && ((info
->dynamic_undefined_weak
!= 0
9543 && h
->root
.type
== bfd_link_hash_undefweak
)
9544 || h
->root
.type
== bfd_link_hash_undefined
)
9547 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
9548 return bfd_elf_link_record_dynamic_symbol (info
, h
);
9552 /* Allocate space in .plt, .got and associated reloc sections for
9556 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
9558 struct bfd_link_info
*info
;
9559 struct ppc_link_hash_table
*htab
;
9561 struct ppc_link_hash_entry
*eh
;
9562 struct got_entry
**pgent
, *gent
;
9564 if (h
->root
.type
== bfd_link_hash_indirect
)
9567 info
= (struct bfd_link_info
*) inf
;
9568 htab
= ppc_hash_table (info
);
9572 eh
= ppc_elf_hash_entry (h
);
9573 /* Run through the TLS GD got entries first if we're changing them
9575 if ((eh
->tls_mask
& (TLS_TLS
| TLS_GDIE
)) == (TLS_TLS
| TLS_GDIE
))
9576 for (gent
= h
->got
.glist
; gent
!= NULL
; gent
= gent
->next
)
9577 if (gent
->got
.refcount
> 0
9578 && (gent
->tls_type
& TLS_GD
) != 0)
9580 /* This was a GD entry that has been converted to TPREL. If
9581 there happens to be a TPREL entry we can use that one. */
9582 struct got_entry
*ent
;
9583 for (ent
= h
->got
.glist
; ent
!= NULL
; ent
= ent
->next
)
9584 if (ent
->got
.refcount
> 0
9585 && (ent
->tls_type
& TLS_TPREL
) != 0
9586 && ent
->addend
== gent
->addend
9587 && ent
->owner
== gent
->owner
)
9589 gent
->got
.refcount
= 0;
9593 /* If not, then we'll be using our own TPREL entry. */
9594 if (gent
->got
.refcount
!= 0)
9595 gent
->tls_type
= TLS_TLS
| TLS_TPREL
;
9598 /* Remove any list entry that won't generate a word in the GOT before
9599 we call merge_got_entries. Otherwise we risk merging to empty
9601 pgent
= &h
->got
.glist
;
9602 while ((gent
= *pgent
) != NULL
)
9603 if (gent
->got
.refcount
> 0)
9605 if ((gent
->tls_type
& TLS_LD
) != 0
9606 && SYMBOL_REFERENCES_LOCAL (info
, h
))
9608 ppc64_tlsld_got (gent
->owner
)->got
.refcount
+= 1;
9609 *pgent
= gent
->next
;
9612 pgent
= &gent
->next
;
9615 *pgent
= gent
->next
;
9617 if (!htab
->do_multi_toc
)
9618 merge_got_entries (&h
->got
.glist
);
9620 for (gent
= h
->got
.glist
; gent
!= NULL
; gent
= gent
->next
)
9621 if (!gent
->is_indirect
)
9623 /* Ensure we catch all the cases where this symbol should
9625 if (!ensure_undef_dynamic (info
, h
))
9628 if (!is_ppc64_elf (gent
->owner
))
9631 allocate_got (h
, info
, gent
);
9634 /* If no dynamic sections we can't have dynamic relocs, except for
9635 IFUNCs which are handled even in static executables. */
9636 if (!htab
->elf
.dynamic_sections_created
9637 && h
->type
!= STT_GNU_IFUNC
)
9638 eh
->dyn_relocs
= NULL
;
9640 /* Discard relocs on undefined symbols that must be local. */
9641 else if (h
->root
.type
== bfd_link_hash_undefined
9642 && ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
9643 eh
->dyn_relocs
= NULL
;
9645 /* Also discard relocs on undefined weak syms with non-default
9646 visibility, or when dynamic_undefined_weak says so. */
9647 else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
9648 eh
->dyn_relocs
= NULL
;
9650 if (eh
->dyn_relocs
!= NULL
)
9652 struct elf_dyn_relocs
*p
, **pp
;
9654 /* In the shared -Bsymbolic case, discard space allocated for
9655 dynamic pc-relative relocs against symbols which turn out to
9656 be defined in regular objects. For the normal shared case,
9657 discard space for relocs that have become local due to symbol
9658 visibility changes. */
9659 if (bfd_link_pic (info
))
9661 /* Relocs that use pc_count are those that appear on a call
9662 insn, or certain REL relocs (see must_be_dyn_reloc) that
9663 can be generated via assembly. We want calls to
9664 protected symbols to resolve directly to the function
9665 rather than going via the plt. If people want function
9666 pointer comparisons to work as expected then they should
9667 avoid writing weird assembly. */
9668 if (SYMBOL_CALLS_LOCAL (info
, h
))
9670 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
9672 p
->count
-= p
->pc_count
;
9681 if (eh
->dyn_relocs
!= NULL
)
9683 /* Ensure we catch all the cases where this symbol
9684 should be made dynamic. */
9685 if (!ensure_undef_dynamic (info
, h
))
9690 /* For a fixed position executable, discard space for
9691 relocs against symbols which are not dynamic. */
9692 else if (h
->type
!= STT_GNU_IFUNC
)
9694 if (h
->dynamic_adjusted
9696 && !ELF_COMMON_DEF_P (h
))
9698 /* Ensure we catch all the cases where this symbol
9699 should be made dynamic. */
9700 if (!ensure_undef_dynamic (info
, h
))
9703 /* But if that didn't work out, discard dynamic relocs. */
9704 if (h
->dynindx
== -1)
9705 eh
->dyn_relocs
= NULL
;
9708 eh
->dyn_relocs
= NULL
;
9711 /* Finally, allocate space. */
9712 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
9714 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
9715 if (eh
->elf
.type
== STT_GNU_IFUNC
)
9716 sreloc
= htab
->elf
.irelplt
;
9717 sreloc
->size
+= p
->count
* sizeof (Elf64_External_Rela
);
9721 /* We might need a PLT entry when the symbol
9724 c) has plt16 relocs and has been processed by adjust_dynamic_symbol, or
9725 d) has plt16 relocs and we are linking statically. */
9726 if ((htab
->elf
.dynamic_sections_created
&& h
->dynindx
!= -1)
9727 || h
->type
== STT_GNU_IFUNC
9728 || (h
->needs_plt
&& h
->dynamic_adjusted
)
9731 && !htab
->elf
.dynamic_sections_created
9732 && !htab
->can_convert_all_inline_plt
9733 && (ppc_elf_hash_entry (h
)->tls_mask
9734 & (TLS_TLS
| PLT_KEEP
)) == PLT_KEEP
))
9736 struct plt_entry
*pent
;
9737 bfd_boolean doneone
= FALSE
;
9738 for (pent
= h
->plt
.plist
; pent
!= NULL
; pent
= pent
->next
)
9739 if (pent
->plt
.refcount
> 0)
9741 if (!htab
->elf
.dynamic_sections_created
9742 || h
->dynindx
== -1)
9744 if (h
->type
== STT_GNU_IFUNC
)
9747 pent
->plt
.offset
= s
->size
;
9748 s
->size
+= PLT_ENTRY_SIZE (htab
);
9749 s
= htab
->elf
.irelplt
;
9754 pent
->plt
.offset
= s
->size
;
9755 s
->size
+= LOCAL_PLT_ENTRY_SIZE (htab
);
9756 s
= bfd_link_pic (info
) ? htab
->relpltlocal
: NULL
;
9761 /* If this is the first .plt entry, make room for the special
9765 s
->size
+= PLT_INITIAL_ENTRY_SIZE (htab
);
9767 pent
->plt
.offset
= s
->size
;
9769 /* Make room for this entry. */
9770 s
->size
+= PLT_ENTRY_SIZE (htab
);
9772 /* Make room for the .glink code. */
9775 s
->size
+= GLINK_PLTRESOLVE_SIZE (htab
);
9778 /* We need bigger stubs past index 32767. */
9779 if (s
->size
>= GLINK_PLTRESOLVE_SIZE (htab
) + 32768*2*4)
9786 /* We also need to make an entry in the .rela.plt section. */
9787 s
= htab
->elf
.srelplt
;
9790 s
->size
+= sizeof (Elf64_External_Rela
);
9794 pent
->plt
.offset
= (bfd_vma
) -1;
9797 h
->plt
.plist
= NULL
;
9803 h
->plt
.plist
= NULL
;
9810 #define PPC_LO(v) ((v) & 0xffff)
9811 #define PPC_HI(v) (((v) >> 16) & 0xffff)
9812 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
9814 ((((v) & 0x3ffff0000ULL) << 16) | (v & 0xffff))
9815 #define HA34(v) ((v + (1ULL << 33)) >> 34)
9817 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9818 to set up space for global entry stubs. These are put in glink,
9819 after the branch table. */
9822 size_global_entry_stubs (struct elf_link_hash_entry
*h
, void *inf
)
9824 struct bfd_link_info
*info
;
9825 struct ppc_link_hash_table
*htab
;
9826 struct plt_entry
*pent
;
9829 if (h
->root
.type
== bfd_link_hash_indirect
)
9832 if (!h
->pointer_equality_needed
)
9839 htab
= ppc_hash_table (info
);
9843 s
= htab
->global_entry
;
9844 plt
= htab
->elf
.splt
;
9845 for (pent
= h
->plt
.plist
; pent
!= NULL
; pent
= pent
->next
)
9846 if (pent
->plt
.offset
!= (bfd_vma
) -1
9847 && pent
->addend
== 0)
9849 /* For ELFv2, if this symbol is not defined in a regular file
9850 and we are not generating a shared library or pie, then we
9851 need to define the symbol in the executable on a call stub.
9852 This is to avoid text relocations. */
9853 bfd_vma off
, stub_align
, stub_off
, stub_size
;
9854 unsigned int align_power
;
9858 if (htab
->params
->plt_stub_align
>= 0)
9859 align_power
= htab
->params
->plt_stub_align
;
9861 align_power
= -htab
->params
->plt_stub_align
;
9862 /* Setting section alignment is delayed until we know it is
9863 non-empty. Otherwise the .text output section will be
9864 aligned at least to plt_stub_align even when no global
9865 entry stubs are needed. */
9866 if (s
->alignment_power
< align_power
)
9867 s
->alignment_power
= align_power
;
9868 stub_align
= (bfd_vma
) 1 << align_power
;
9869 if (htab
->params
->plt_stub_align
>= 0
9870 || ((((stub_off
+ stub_size
- 1) & -stub_align
)
9871 - (stub_off
& -stub_align
))
9872 > ((stub_size
- 1) & -stub_align
)))
9873 stub_off
= (stub_off
+ stub_align
- 1) & -stub_align
;
9874 off
= pent
->plt
.offset
+ plt
->output_offset
+ plt
->output_section
->vma
;
9875 off
-= stub_off
+ s
->output_offset
+ s
->output_section
->vma
;
9876 /* Note that for --plt-stub-align negative we have a possible
9877 dependency between stub offset and size. Break that
9878 dependency by assuming the max stub size when calculating
9880 if (PPC_HA (off
) == 0)
9882 h
->root
.type
= bfd_link_hash_defined
;
9883 h
->root
.u
.def
.section
= s
;
9884 h
->root
.u
.def
.value
= stub_off
;
9885 s
->size
= stub_off
+ stub_size
;
9891 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9892 read-only sections. */
9895 maybe_set_textrel (struct elf_link_hash_entry
*h
, void *inf
)
9899 if (h
->root
.type
== bfd_link_hash_indirect
)
9902 sec
= readonly_dynrelocs (h
);
9905 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
9907 info
->flags
|= DF_TEXTREL
;
9908 info
->callbacks
->minfo (_("%pB: dynamic relocation against `%pT'"
9909 " in read-only section `%pA'\n"),
9910 sec
->owner
, h
->root
.root
.string
, sec
);
9912 /* Not an error, just cut short the traversal. */
9918 /* Set the sizes of the dynamic sections. */
9921 ppc64_elf_size_dynamic_sections (bfd
*output_bfd
,
9922 struct bfd_link_info
*info
)
9924 struct ppc_link_hash_table
*htab
;
9929 struct got_entry
*first_tlsld
;
9931 htab
= ppc_hash_table (info
);
9935 dynobj
= htab
->elf
.dynobj
;
9939 if (htab
->elf
.dynamic_sections_created
)
9941 /* Set the contents of the .interp section to the interpreter. */
9942 if (bfd_link_executable (info
) && !info
->nointerp
)
9944 s
= bfd_get_linker_section (dynobj
, ".interp");
9947 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
9948 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
9952 /* Set up .got offsets for local syms, and space for local dynamic
9954 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
9956 struct got_entry
**lgot_ents
;
9957 struct got_entry
**end_lgot_ents
;
9958 struct plt_entry
**local_plt
;
9959 struct plt_entry
**end_local_plt
;
9960 unsigned char *lgot_masks
;
9961 bfd_size_type locsymcount
;
9962 Elf_Internal_Shdr
*symtab_hdr
;
9964 if (!is_ppc64_elf (ibfd
))
9967 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
9969 struct ppc_dyn_relocs
*p
;
9971 for (p
= elf_section_data (s
)->local_dynrel
; p
!= NULL
; p
= p
->next
)
9973 if (!bfd_is_abs_section (p
->sec
)
9974 && bfd_is_abs_section (p
->sec
->output_section
))
9976 /* Input section has been discarded, either because
9977 it is a copy of a linkonce section or due to
9978 linker script /DISCARD/, so we'll be discarding
9981 else if (p
->count
!= 0)
9983 asection
*srel
= elf_section_data (p
->sec
)->sreloc
;
9985 srel
= htab
->elf
.irelplt
;
9986 srel
->size
+= p
->count
* sizeof (Elf64_External_Rela
);
9987 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
9988 info
->flags
|= DF_TEXTREL
;
9993 lgot_ents
= elf_local_got_ents (ibfd
);
9997 symtab_hdr
= &elf_symtab_hdr (ibfd
);
9998 locsymcount
= symtab_hdr
->sh_info
;
9999 end_lgot_ents
= lgot_ents
+ locsymcount
;
10000 local_plt
= (struct plt_entry
**) end_lgot_ents
;
10001 end_local_plt
= local_plt
+ locsymcount
;
10002 lgot_masks
= (unsigned char *) end_local_plt
;
10003 s
= ppc64_elf_tdata (ibfd
)->got
;
10004 for (; lgot_ents
< end_lgot_ents
; ++lgot_ents
, ++lgot_masks
)
10006 struct got_entry
**pent
, *ent
;
10009 while ((ent
= *pent
) != NULL
)
10010 if (ent
->got
.refcount
> 0)
10012 if ((ent
->tls_type
& *lgot_masks
& TLS_LD
) != 0)
10014 ppc64_tlsld_got (ibfd
)->got
.refcount
+= 1;
10019 unsigned int ent_size
= 8;
10020 unsigned int rel_size
= sizeof (Elf64_External_Rela
);
10022 ent
->got
.offset
= s
->size
;
10023 if ((ent
->tls_type
& *lgot_masks
& TLS_GD
) != 0)
10028 s
->size
+= ent_size
;
10029 if ((*lgot_masks
& (TLS_TLS
| PLT_IFUNC
)) == PLT_IFUNC
)
10031 htab
->elf
.irelplt
->size
+= rel_size
;
10032 htab
->got_reli_size
+= rel_size
;
10034 else if (bfd_link_pic (info
)
10035 && !(ent
->tls_type
!= 0
10036 && bfd_link_executable (info
)))
10038 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
10039 srel
->size
+= rel_size
;
10048 /* Allocate space for plt calls to local syms. */
10049 lgot_masks
= (unsigned char *) end_local_plt
;
10050 for (; local_plt
< end_local_plt
; ++local_plt
, ++lgot_masks
)
10052 struct plt_entry
*ent
;
10054 for (ent
= *local_plt
; ent
!= NULL
; ent
= ent
->next
)
10055 if (ent
->plt
.refcount
> 0)
10057 if ((*lgot_masks
& (TLS_TLS
| PLT_IFUNC
)) == PLT_IFUNC
)
10059 s
= htab
->elf
.iplt
;
10060 ent
->plt
.offset
= s
->size
;
10061 s
->size
+= PLT_ENTRY_SIZE (htab
);
10062 htab
->elf
.irelplt
->size
+= sizeof (Elf64_External_Rela
);
10064 else if (htab
->can_convert_all_inline_plt
10065 || (*lgot_masks
& (TLS_TLS
| PLT_KEEP
)) != PLT_KEEP
)
10066 ent
->plt
.offset
= (bfd_vma
) -1;
10069 s
= htab
->pltlocal
;
10070 ent
->plt
.offset
= s
->size
;
10071 s
->size
+= LOCAL_PLT_ENTRY_SIZE (htab
);
10072 if (bfd_link_pic (info
))
10073 htab
->relpltlocal
->size
+= sizeof (Elf64_External_Rela
);
10077 ent
->plt
.offset
= (bfd_vma
) -1;
10081 /* Allocate global sym .plt and .got entries, and space for global
10082 sym dynamic relocs. */
10083 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, info
);
10085 if (!htab
->opd_abi
&& !bfd_link_pic (info
))
10086 elf_link_hash_traverse (&htab
->elf
, size_global_entry_stubs
, info
);
10088 first_tlsld
= NULL
;
10089 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
10091 struct got_entry
*ent
;
10093 if (!is_ppc64_elf (ibfd
))
10096 ent
= ppc64_tlsld_got (ibfd
);
10097 if (ent
->got
.refcount
> 0)
10099 if (!htab
->do_multi_toc
&& first_tlsld
!= NULL
)
10101 ent
->is_indirect
= TRUE
;
10102 ent
->got
.ent
= first_tlsld
;
10106 if (first_tlsld
== NULL
)
10108 s
= ppc64_elf_tdata (ibfd
)->got
;
10109 ent
->got
.offset
= s
->size
;
10112 if (bfd_link_dll (info
))
10114 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
10115 srel
->size
+= sizeof (Elf64_External_Rela
);
10120 ent
->got
.offset
= (bfd_vma
) -1;
10123 /* We now have determined the sizes of the various dynamic sections.
10124 Allocate memory for them. */
10126 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
10128 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
10131 if (s
== htab
->brlt
|| s
== htab
->relbrlt
)
10132 /* These haven't been allocated yet; don't strip. */
10134 else if (s
== htab
->elf
.sgot
10135 || s
== htab
->elf
.splt
10136 || s
== htab
->elf
.iplt
10137 || s
== htab
->pltlocal
10138 || s
== htab
->glink
10139 || s
== htab
->global_entry
10140 || s
== htab
->elf
.sdynbss
10141 || s
== htab
->elf
.sdynrelro
)
10143 /* Strip this section if we don't need it; see the
10146 else if (s
== htab
->glink_eh_frame
)
10148 if (!bfd_is_abs_section (s
->output_section
))
10149 /* Not sized yet. */
10152 else if (CONST_STRNEQ (s
->name
, ".rela"))
10156 if (s
!= htab
->elf
.srelplt
)
10159 /* We use the reloc_count field as a counter if we need
10160 to copy relocs into the output file. */
10161 s
->reloc_count
= 0;
10166 /* It's not one of our sections, so don't allocate space. */
10172 /* If we don't need this section, strip it from the
10173 output file. This is mostly to handle .rela.bss and
10174 .rela.plt. We must create both sections in
10175 create_dynamic_sections, because they must be created
10176 before the linker maps input sections to output
10177 sections. The linker does that before
10178 adjust_dynamic_symbol is called, and it is that
10179 function which decides whether anything needs to go
10180 into these sections. */
10181 s
->flags
|= SEC_EXCLUDE
;
10185 if (bfd_is_abs_section (s
->output_section
))
10186 _bfd_error_handler (_("warning: discarding dynamic section %s"),
10189 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
10192 /* Allocate memory for the section contents. We use bfd_zalloc
10193 here in case unused entries are not reclaimed before the
10194 section's contents are written out. This should not happen,
10195 but this way if it does we get a R_PPC64_NONE reloc in .rela
10196 sections instead of garbage.
10197 We also rely on the section contents being zero when writing
10198 the GOT and .dynrelro. */
10199 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
10200 if (s
->contents
== NULL
)
10204 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
10206 if (!is_ppc64_elf (ibfd
))
10209 s
= ppc64_elf_tdata (ibfd
)->got
;
10210 if (s
!= NULL
&& s
!= htab
->elf
.sgot
)
10213 s
->flags
|= SEC_EXCLUDE
;
10216 s
->contents
= bfd_zalloc (ibfd
, s
->size
);
10217 if (s
->contents
== NULL
)
10221 s
= ppc64_elf_tdata (ibfd
)->relgot
;
10225 s
->flags
|= SEC_EXCLUDE
;
10228 s
->contents
= bfd_zalloc (ibfd
, s
->size
);
10229 if (s
->contents
== NULL
)
10232 s
->reloc_count
= 0;
10237 if (htab
->elf
.dynamic_sections_created
)
10239 bfd_boolean tls_opt
;
10241 /* Add some entries to the .dynamic section. We fill in the
10242 values later, in ppc64_elf_finish_dynamic_sections, but we
10243 must add the entries now so that we get the correct size for
10244 the .dynamic section. The DT_DEBUG entry is filled in by the
10245 dynamic linker and used by the debugger. */
10246 #define add_dynamic_entry(TAG, VAL) \
10247 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10249 if (bfd_link_executable (info
))
10251 if (!add_dynamic_entry (DT_DEBUG
, 0))
10255 if (htab
->elf
.splt
!= NULL
&& htab
->elf
.splt
->size
!= 0)
10257 if (!add_dynamic_entry (DT_PLTGOT
, 0)
10258 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
10259 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
10260 || !add_dynamic_entry (DT_JMPREL
, 0)
10261 || !add_dynamic_entry (DT_PPC64_GLINK
, 0))
10265 if (NO_OPD_RELOCS
&& abiversion (output_bfd
) <= 1)
10267 if (!add_dynamic_entry (DT_PPC64_OPD
, 0)
10268 || !add_dynamic_entry (DT_PPC64_OPDSZ
, 0))
10272 tls_opt
= (htab
->params
->tls_get_addr_opt
10273 && ((htab
->tls_get_addr_fd
!= NULL
10274 && htab
->tls_get_addr_fd
->elf
.plt
.plist
!= NULL
)
10275 || (htab
->tga_desc_fd
!= NULL
10276 && htab
->tga_desc_fd
->elf
.plt
.plist
!= NULL
)));
10277 if (tls_opt
|| !htab
->opd_abi
)
10279 if (!add_dynamic_entry (DT_PPC64_OPT
, tls_opt
? PPC64_OPT_TLS
: 0))
10285 if (!add_dynamic_entry (DT_RELA
, 0)
10286 || !add_dynamic_entry (DT_RELASZ
, 0)
10287 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf64_External_Rela
)))
10290 /* If any dynamic relocs apply to a read-only section,
10291 then we need a DT_TEXTREL entry. */
10292 if ((info
->flags
& DF_TEXTREL
) == 0)
10293 elf_link_hash_traverse (&htab
->elf
, maybe_set_textrel
, info
);
10295 if ((info
->flags
& DF_TEXTREL
) != 0)
10297 if (!add_dynamic_entry (DT_TEXTREL
, 0))
10302 #undef add_dynamic_entry
10307 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
10310 ppc64_elf_hash_symbol (struct elf_link_hash_entry
*h
)
10312 if (h
->plt
.plist
!= NULL
10314 && !h
->pointer_equality_needed
)
10317 return _bfd_elf_hash_symbol (h
);
10320 /* Determine the type of stub needed, if any, for a call. */
10322 static inline enum ppc_stub_type
10323 ppc_type_of_stub (asection
*input_sec
,
10324 const Elf_Internal_Rela
*rel
,
10325 struct ppc_link_hash_entry
**hash
,
10326 struct plt_entry
**plt_ent
,
10327 bfd_vma destination
,
10328 unsigned long local_off
)
10330 struct ppc_link_hash_entry
*h
= *hash
;
10332 bfd_vma branch_offset
;
10333 bfd_vma max_branch_offset
;
10334 enum elf_ppc64_reloc_type r_type
;
10338 struct plt_entry
*ent
;
10339 struct ppc_link_hash_entry
*fdh
= h
;
10341 && h
->oh
->is_func_descriptor
)
10343 fdh
= ppc_follow_link (h
->oh
);
10347 for (ent
= fdh
->elf
.plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
10348 if (ent
->addend
== rel
->r_addend
10349 && ent
->plt
.offset
!= (bfd_vma
) -1)
10352 return ppc_stub_plt_call
;
10355 /* Here, we know we don't have a plt entry. If we don't have a
10356 either a defined function descriptor or a defined entry symbol
10357 in a regular object file, then it is pointless trying to make
10358 any other type of stub. */
10359 if (!is_static_defined (&fdh
->elf
)
10360 && !is_static_defined (&h
->elf
))
10361 return ppc_stub_none
;
10363 else if (elf_local_got_ents (input_sec
->owner
) != NULL
)
10365 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (input_sec
->owner
);
10366 struct plt_entry
**local_plt
= (struct plt_entry
**)
10367 elf_local_got_ents (input_sec
->owner
) + symtab_hdr
->sh_info
;
10368 unsigned long r_symndx
= ELF64_R_SYM (rel
->r_info
);
10370 if (local_plt
[r_symndx
] != NULL
)
10372 struct plt_entry
*ent
;
10374 for (ent
= local_plt
[r_symndx
]; ent
!= NULL
; ent
= ent
->next
)
10375 if (ent
->addend
== rel
->r_addend
10376 && ent
->plt
.offset
!= (bfd_vma
) -1)
10379 return ppc_stub_plt_call
;
10384 /* Determine where the call point is. */
10385 location
= (input_sec
->output_offset
10386 + input_sec
->output_section
->vma
10389 branch_offset
= destination
- location
;
10390 r_type
= ELF64_R_TYPE (rel
->r_info
);
10392 /* Determine if a long branch stub is needed. */
10393 max_branch_offset
= 1 << 25;
10394 if (r_type
== R_PPC64_REL14
10395 || r_type
== R_PPC64_REL14_BRTAKEN
10396 || r_type
== R_PPC64_REL14_BRNTAKEN
)
10397 max_branch_offset
= 1 << 15;
10399 if (branch_offset
+ max_branch_offset
>= 2 * max_branch_offset
- local_off
)
10400 /* We need a stub. Figure out whether a long_branch or plt_branch
10401 is needed later. */
10402 return ppc_stub_long_branch
;
10404 return ppc_stub_none
;
10407 /* Gets the address of a label (1:) in r11 and builds an offset in r12,
10408 then adds it to r11 (LOAD false) or loads r12 from r11+r12 (LOAD true).
10413 . lis %r12,xxx-1b@highest
10414 . ori %r12,%r12,xxx-1b@higher
10415 . sldi %r12,%r12,32
10416 . oris %r12,%r12,xxx-1b@high
10417 . ori %r12,%r12,xxx-1b@l
10418 . add/ldx %r12,%r11,%r12 */
10421 build_offset (bfd
*abfd
, bfd_byte
*p
, bfd_vma off
, bfd_boolean load
)
10423 bfd_put_32 (abfd
, MFLR_R12
, p
);
10425 bfd_put_32 (abfd
, BCL_20_31
, p
);
10427 bfd_put_32 (abfd
, MFLR_R11
, p
);
10429 bfd_put_32 (abfd
, MTLR_R12
, p
);
10431 if (off
+ 0x8000 < 0x10000)
10434 bfd_put_32 (abfd
, LD_R12_0R11
+ PPC_LO (off
), p
);
10436 bfd_put_32 (abfd
, ADDI_R12_R11
+ PPC_LO (off
), p
);
10439 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10441 bfd_put_32 (abfd
, ADDIS_R12_R11
+ PPC_HA (off
), p
);
10444 bfd_put_32 (abfd
, LD_R12_0R12
+ PPC_LO (off
), p
);
10446 bfd_put_32 (abfd
, ADDI_R12_R12
+ PPC_LO (off
), p
);
10451 if (off
+ 0x800000000000ULL
< 0x1000000000000ULL
)
10453 bfd_put_32 (abfd
, LI_R12_0
+ ((off
>> 32) & 0xffff), p
);
10458 bfd_put_32 (abfd
, LIS_R12
+ ((off
>> 48) & 0xffff), p
);
10460 if (((off
>> 32) & 0xffff) != 0)
10462 bfd_put_32 (abfd
, ORI_R12_R12_0
+ ((off
>> 32) & 0xffff), p
);
10466 if (((off
>> 32) & 0xffffffffULL
) != 0)
10468 bfd_put_32 (abfd
, SLDI_R12_R12_32
, p
);
10471 if (PPC_HI (off
) != 0)
10473 bfd_put_32 (abfd
, ORIS_R12_R12_0
+ PPC_HI (off
), p
);
10476 if (PPC_LO (off
) != 0)
10478 bfd_put_32 (abfd
, ORI_R12_R12_0
+ PPC_LO (off
), p
);
10482 bfd_put_32 (abfd
, LDX_R12_R11_R12
, p
);
10484 bfd_put_32 (abfd
, ADD_R12_R11_R12
, p
);
10490 static unsigned int
10491 size_offset (bfd_vma off
)
10494 if (off
+ 0x8000 < 0x10000)
10496 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10500 if (off
+ 0x800000000000ULL
< 0x1000000000000ULL
)
10505 if (((off
>> 32) & 0xffff) != 0)
10508 if (((off
>> 32) & 0xffffffffULL
) != 0)
10510 if (PPC_HI (off
) != 0)
10512 if (PPC_LO (off
) != 0)
10519 static unsigned int
10520 num_relocs_for_offset (bfd_vma off
)
10522 unsigned int num_rel
;
10523 if (off
+ 0x8000 < 0x10000)
10525 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10530 if (off
+ 0x800000000000ULL
>= 0x1000000000000ULL
10531 && ((off
>> 32) & 0xffff) != 0)
10533 if (PPC_HI (off
) != 0)
10535 if (PPC_LO (off
) != 0)
10541 static Elf_Internal_Rela
*
10542 emit_relocs_for_offset (struct bfd_link_info
*info
, Elf_Internal_Rela
*r
,
10543 bfd_vma roff
, bfd_vma targ
, bfd_vma off
)
10545 bfd_vma relative_targ
= targ
- (roff
- 8);
10546 if (bfd_big_endian (info
->output_bfd
))
10548 r
->r_offset
= roff
;
10549 r
->r_addend
= relative_targ
+ roff
;
10550 if (off
+ 0x8000 < 0x10000)
10551 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16
);
10552 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10554 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HA
);
10557 r
->r_offset
= roff
;
10558 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_LO
);
10559 r
->r_addend
= relative_targ
+ roff
;
10563 if (off
+ 0x800000000000ULL
< 0x1000000000000ULL
)
10564 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHER
);
10567 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHEST
);
10568 if (((off
>> 32) & 0xffff) != 0)
10572 r
->r_offset
= roff
;
10573 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHER
);
10574 r
->r_addend
= relative_targ
+ roff
;
10577 if (((off
>> 32) & 0xffffffffULL
) != 0)
10579 if (PPC_HI (off
) != 0)
10583 r
->r_offset
= roff
;
10584 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGH
);
10585 r
->r_addend
= relative_targ
+ roff
;
10587 if (PPC_LO (off
) != 0)
10591 r
->r_offset
= roff
;
10592 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_LO
);
10593 r
->r_addend
= relative_targ
+ roff
;
10600 build_powerxx_offset (bfd
*abfd
, bfd_byte
*p
, bfd_vma off
, int odd
,
10604 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10609 bfd_put_32 (abfd
, NOP
, p
);
10615 insn
= PADDI_R12_PC
;
10617 bfd_put_32 (abfd
, insn
>> 32, p
);
10619 bfd_put_32 (abfd
, insn
, p
);
10621 /* The minimum value for paddi is -0x200000000. The minimum value
10622 for li is -0x8000, which when shifted by 34 and added gives a
10623 minimum value of -0x2000200000000. The maximum value is
10624 0x1ffffffff+0x7fff<<34 which is 0x2000200000000-1. */
10625 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10628 bfd_put_32 (abfd
, LI_R11_0
| (HA34 (off
) & 0xffff), p
);
10632 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10635 insn
= PADDI_R12_PC
| D34 (off
);
10636 bfd_put_32 (abfd
, insn
>> 32, p
);
10638 bfd_put_32 (abfd
, insn
, p
);
10642 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10646 bfd_put_32 (abfd
, LDX_R12_R11_R12
, p
);
10648 bfd_put_32 (abfd
, ADD_R12_R11_R12
, p
);
10653 bfd_put_32 (abfd
, LIS_R11
| ((HA34 (off
) >> 16) & 0x3fff), p
);
10655 bfd_put_32 (abfd
, ORI_R11_R11_0
| (HA34 (off
) & 0xffff), p
);
10659 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10662 insn
= PADDI_R12_PC
| D34 (off
);
10663 bfd_put_32 (abfd
, insn
>> 32, p
);
10665 bfd_put_32 (abfd
, insn
, p
);
10669 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10673 bfd_put_32 (abfd
, LDX_R12_R11_R12
, p
);
10675 bfd_put_32 (abfd
, ADD_R12_R11_R12
, p
);
10681 static unsigned int
10682 size_powerxx_offset (bfd_vma off
, int odd
)
10684 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10686 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10692 static unsigned int
10693 num_relocs_for_powerxx_offset (bfd_vma off
, int odd
)
10695 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10697 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10703 static Elf_Internal_Rela
*
10704 emit_relocs_for_powerxx_offset (struct bfd_link_info
*info
,
10705 Elf_Internal_Rela
*r
, bfd_vma roff
,
10706 bfd_vma targ
, bfd_vma off
, int odd
)
10708 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10710 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10712 int d_offset
= bfd_big_endian (info
->output_bfd
) ? 2 : 0;
10713 r
->r_offset
= roff
+ d_offset
;
10714 r
->r_addend
= targ
+ 8 - odd
- d_offset
;
10715 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHERA34
);
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_HIGHESTA34
);
10727 r
->r_offset
= roff
+ d_offset
;
10728 r
->r_addend
= targ
+ 4 + odd
- d_offset
;
10729 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHERA34
);
10733 r
->r_offset
= roff
;
10734 r
->r_addend
= targ
;
10735 r
->r_info
= ELF64_R_INFO (0, R_PPC64_PCREL34
);
10739 /* Emit .eh_frame opcode to advance pc by DELTA. */
10742 eh_advance (bfd
*abfd
, bfd_byte
*eh
, unsigned int delta
)
10746 *eh
++ = DW_CFA_advance_loc
+ delta
;
10747 else if (delta
< 256)
10749 *eh
++ = DW_CFA_advance_loc1
;
10752 else if (delta
< 65536)
10754 *eh
++ = DW_CFA_advance_loc2
;
10755 bfd_put_16 (abfd
, delta
, eh
);
10760 *eh
++ = DW_CFA_advance_loc4
;
10761 bfd_put_32 (abfd
, delta
, eh
);
10767 /* Size of required .eh_frame opcode to advance pc by DELTA. */
10769 static unsigned int
10770 eh_advance_size (unsigned int delta
)
10772 if (delta
< 64 * 4)
10773 /* DW_CFA_advance_loc+[1..63]. */
10775 if (delta
< 256 * 4)
10776 /* DW_CFA_advance_loc1, byte. */
10778 if (delta
< 65536 * 4)
10779 /* DW_CFA_advance_loc2, 2 bytes. */
10781 /* DW_CFA_advance_loc4, 4 bytes. */
10785 /* With power7 weakly ordered memory model, it is possible for ld.so
10786 to update a plt entry in one thread and have another thread see a
10787 stale zero toc entry. To avoid this we need some sort of acquire
10788 barrier in the call stub. One solution is to make the load of the
10789 toc word seem to appear to depend on the load of the function entry
10790 word. Another solution is to test for r2 being zero, and branch to
10791 the appropriate glink entry if so.
10793 . fake dep barrier compare
10794 . ld 12,xxx(2) ld 12,xxx(2)
10795 . mtctr 12 mtctr 12
10796 . xor 11,12,12 ld 2,xxx+8(2)
10797 . add 2,2,11 cmpldi 2,0
10798 . ld 2,xxx+8(2) bnectr+
10799 . bctr b <glink_entry>
10801 The solution involving the compare turns out to be faster, so
10802 that's what we use unless the branch won't reach. */
10804 #define ALWAYS_USE_FAKE_DEP 0
10805 #define ALWAYS_EMIT_R2SAVE 0
10807 static inline unsigned int
10808 plt_stub_size (struct ppc_link_hash_table
*htab
,
10809 struct ppc_stub_hash_entry
*stub_entry
,
10814 if (stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
)
10816 if (htab
->powerxx_stubs
)
10818 bfd_vma start
= (stub_entry
->stub_offset
10819 + stub_entry
->group
->stub_sec
->output_offset
10820 + stub_entry
->group
->stub_sec
->output_section
->vma
);
10821 if (stub_entry
->stub_type
> ppc_stub_plt_call_notoc
)
10823 size
= 8 + size_powerxx_offset (off
, start
& 4);
10826 size
= 8 + size_offset (off
- 8);
10827 if (stub_entry
->stub_type
> ppc_stub_plt_call_notoc
)
10833 if (ALWAYS_EMIT_R2SAVE
10834 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10836 if (PPC_HA (off
) != 0)
10841 if (htab
->params
->plt_static_chain
)
10843 if (htab
->params
->plt_thread_safe
10844 && htab
->elf
.dynamic_sections_created
10845 && stub_entry
->h
!= NULL
10846 && stub_entry
->h
->elf
.dynindx
!= -1)
10848 if (PPC_HA (off
+ 8 + 8 * htab
->params
->plt_static_chain
) != PPC_HA (off
))
10851 if (stub_entry
->h
!= NULL
10852 && is_tls_get_addr (&stub_entry
->h
->elf
, htab
)
10853 && htab
->params
->tls_get_addr_opt
)
10855 if (htab
->params
->no_tls_get_addr_regsave
)
10858 if (stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10864 if (stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10871 /* Depending on the sign of plt_stub_align:
10872 If positive, return the padding to align to a 2**plt_stub_align
10874 If negative, if this stub would cross fewer 2**plt_stub_align
10875 boundaries if we align, then return the padding needed to do so. */
10877 static inline unsigned int
10878 plt_stub_pad (struct ppc_link_hash_table
*htab
,
10879 struct ppc_stub_hash_entry
*stub_entry
,
10883 unsigned stub_size
;
10884 bfd_vma stub_off
= stub_entry
->group
->stub_sec
->size
;
10886 if (htab
->params
->plt_stub_align
>= 0)
10888 stub_align
= 1 << htab
->params
->plt_stub_align
;
10889 if ((stub_off
& (stub_align
- 1)) != 0)
10890 return stub_align
- (stub_off
& (stub_align
- 1));
10894 stub_align
= 1 << -htab
->params
->plt_stub_align
;
10895 stub_size
= plt_stub_size (htab
, stub_entry
, plt_off
);
10896 if (((stub_off
+ stub_size
- 1) & -stub_align
) - (stub_off
& -stub_align
)
10897 > ((stub_size
- 1) & -stub_align
))
10898 return stub_align
- (stub_off
& (stub_align
- 1));
10902 /* Build a .plt call stub. */
10904 static inline bfd_byte
*
10905 build_plt_stub (struct ppc_link_hash_table
*htab
,
10906 struct ppc_stub_hash_entry
*stub_entry
,
10907 bfd_byte
*p
, bfd_vma offset
, Elf_Internal_Rela
*r
)
10909 bfd
*obfd
= htab
->params
->stub_bfd
;
10910 bfd_boolean plt_load_toc
= htab
->opd_abi
;
10911 bfd_boolean plt_static_chain
= htab
->params
->plt_static_chain
;
10912 bfd_boolean plt_thread_safe
= (htab
->params
->plt_thread_safe
10913 && htab
->elf
.dynamic_sections_created
10914 && stub_entry
->h
!= NULL
10915 && stub_entry
->h
->elf
.dynindx
!= -1);
10916 bfd_boolean use_fake_dep
= plt_thread_safe
;
10917 bfd_vma cmp_branch_off
= 0;
10919 if (!ALWAYS_USE_FAKE_DEP
10922 && !(is_tls_get_addr (&stub_entry
->h
->elf
, htab
)
10923 && htab
->params
->tls_get_addr_opt
))
10925 bfd_vma pltoff
= stub_entry
->plt_ent
->plt
.offset
& ~1;
10926 bfd_vma pltindex
= ((pltoff
- PLT_INITIAL_ENTRY_SIZE (htab
))
10927 / PLT_ENTRY_SIZE (htab
));
10928 bfd_vma glinkoff
= GLINK_PLTRESOLVE_SIZE (htab
) + pltindex
* 8;
10931 if (pltindex
> 32768)
10932 glinkoff
+= (pltindex
- 32768) * 4;
10934 + htab
->glink
->output_offset
10935 + htab
->glink
->output_section
->vma
);
10936 from
= (p
- stub_entry
->group
->stub_sec
->contents
10937 + 4 * (ALWAYS_EMIT_R2SAVE
10938 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10939 + 4 * (PPC_HA (offset
) != 0)
10940 + 4 * (PPC_HA (offset
+ 8 + 8 * plt_static_chain
)
10941 != PPC_HA (offset
))
10942 + 4 * (plt_static_chain
!= 0)
10944 + stub_entry
->group
->stub_sec
->output_offset
10945 + stub_entry
->group
->stub_sec
->output_section
->vma
);
10946 cmp_branch_off
= to
- from
;
10947 use_fake_dep
= cmp_branch_off
+ (1 << 25) >= (1 << 26);
10950 if (PPC_HA (offset
) != 0)
10954 if (ALWAYS_EMIT_R2SAVE
10955 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10956 r
[0].r_offset
+= 4;
10957 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_HA
);
10958 r
[1].r_offset
= r
[0].r_offset
+ 4;
10959 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
10960 r
[1].r_addend
= r
[0].r_addend
;
10963 if (PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
10965 r
[2].r_offset
= r
[1].r_offset
+ 4;
10966 r
[2].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO
);
10967 r
[2].r_addend
= r
[0].r_addend
;
10971 r
[2].r_offset
= r
[1].r_offset
+ 8 + 8 * use_fake_dep
;
10972 r
[2].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
10973 r
[2].r_addend
= r
[0].r_addend
+ 8;
10974 if (plt_static_chain
)
10976 r
[3].r_offset
= r
[2].r_offset
+ 4;
10977 r
[3].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
10978 r
[3].r_addend
= r
[0].r_addend
+ 16;
10983 if (ALWAYS_EMIT_R2SAVE
10984 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10985 bfd_put_32 (obfd
, STD_R2_0R1
+ STK_TOC (htab
), p
), p
+= 4;
10988 bfd_put_32 (obfd
, ADDIS_R11_R2
| PPC_HA (offset
), p
), p
+= 4;
10989 bfd_put_32 (obfd
, LD_R12_0R11
| PPC_LO (offset
), p
), p
+= 4;
10993 bfd_put_32 (obfd
, ADDIS_R12_R2
| PPC_HA (offset
), p
), p
+= 4;
10994 bfd_put_32 (obfd
, LD_R12_0R12
| PPC_LO (offset
), p
), p
+= 4;
10997 && PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
10999 bfd_put_32 (obfd
, ADDI_R11_R11
| PPC_LO (offset
), p
), p
+= 4;
11002 bfd_put_32 (obfd
, MTCTR_R12
, p
), p
+= 4;
11007 bfd_put_32 (obfd
, XOR_R2_R12_R12
, p
), p
+= 4;
11008 bfd_put_32 (obfd
, ADD_R11_R11_R2
, p
), p
+= 4;
11010 bfd_put_32 (obfd
, LD_R2_0R11
| PPC_LO (offset
+ 8), p
), p
+= 4;
11011 if (plt_static_chain
)
11012 bfd_put_32 (obfd
, LD_R11_0R11
| PPC_LO (offset
+ 16), p
), p
+= 4;
11019 if (ALWAYS_EMIT_R2SAVE
11020 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
11021 r
[0].r_offset
+= 4;
11022 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
11025 if (PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
11027 r
[1].r_offset
= r
[0].r_offset
+ 4;
11028 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16
);
11029 r
[1].r_addend
= r
[0].r_addend
;
11033 r
[1].r_offset
= r
[0].r_offset
+ 8 + 8 * use_fake_dep
;
11034 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
11035 r
[1].r_addend
= r
[0].r_addend
+ 8 + 8 * plt_static_chain
;
11036 if (plt_static_chain
)
11038 r
[2].r_offset
= r
[1].r_offset
+ 4;
11039 r
[2].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
11040 r
[2].r_addend
= r
[0].r_addend
+ 8;
11045 if (ALWAYS_EMIT_R2SAVE
11046 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
11047 bfd_put_32 (obfd
, STD_R2_0R1
+ STK_TOC (htab
), p
), p
+= 4;
11048 bfd_put_32 (obfd
, LD_R12_0R2
| PPC_LO (offset
), p
), p
+= 4;
11050 && PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
11052 bfd_put_32 (obfd
, ADDI_R2_R2
| PPC_LO (offset
), p
), p
+= 4;
11055 bfd_put_32 (obfd
, MTCTR_R12
, p
), p
+= 4;
11060 bfd_put_32 (obfd
, XOR_R11_R12_R12
, p
), p
+= 4;
11061 bfd_put_32 (obfd
, ADD_R2_R2_R11
, p
), p
+= 4;
11063 if (plt_static_chain
)
11064 bfd_put_32 (obfd
, LD_R11_0R2
| PPC_LO (offset
+ 16), p
), p
+= 4;
11065 bfd_put_32 (obfd
, LD_R2_0R2
| PPC_LO (offset
+ 8), p
), p
+= 4;
11068 if (plt_load_toc
&& plt_thread_safe
&& !use_fake_dep
)
11070 bfd_put_32 (obfd
, CMPLDI_R2_0
, p
), p
+= 4;
11071 bfd_put_32 (obfd
, BNECTR_P4
, p
), p
+= 4;
11072 bfd_put_32 (obfd
, B_DOT
| (cmp_branch_off
& 0x3fffffc), p
), p
+= 4;
11075 bfd_put_32 (obfd
, BCTR
, p
), p
+= 4;
11079 /* Build a special .plt call stub for __tls_get_addr. */
11081 #define LD_R0_0R3 0xe8030000
11082 #define LD_R12_0R3 0xe9830000
11083 #define MR_R0_R3 0x7c601b78
11084 #define CMPDI_R0_0 0x2c200000
11085 #define ADD_R3_R12_R13 0x7c6c6a14
11086 #define BEQLR 0x4d820020
11087 #define MR_R3_R0 0x7c030378
11088 #define BCTRL 0x4e800421
11090 static inline bfd_byte
*
11091 build_tls_get_addr_stub (struct ppc_link_hash_table
*htab
,
11092 struct ppc_stub_hash_entry
*stub_entry
,
11093 bfd_byte
*p
, bfd_vma offset
, Elf_Internal_Rela
*r
)
11095 bfd
*obfd
= htab
->params
->stub_bfd
;
11099 bfd_put_32 (obfd
, LD_R0_0R3
+ 0, p
), p
+= 4;
11100 bfd_put_32 (obfd
, LD_R12_0R3
+ 8, p
), p
+= 4;
11101 bfd_put_32 (obfd
, CMPDI_R0_0
, p
), p
+= 4;
11102 bfd_put_32 (obfd
, MR_R0_R3
, p
), p
+= 4;
11103 bfd_put_32 (obfd
, ADD_R3_R12_R13
, p
), p
+= 4;
11104 bfd_put_32 (obfd
, BEQLR
, p
), p
+= 4;
11105 bfd_put_32 (obfd
, MR_R3_R0
, p
), p
+= 4;
11106 if (htab
->params
->no_tls_get_addr_regsave
)
11109 r
[0].r_offset
+= 7 * 4;
11110 if (stub_entry
->stub_type
!= ppc_stub_plt_call_r2save
)
11111 return build_plt_stub (htab
, stub_entry
, p
, offset
, r
);
11113 bfd_put_32 (obfd
, MFLR_R0
, p
);
11115 bfd_put_32 (obfd
, STD_R0_0R1
+ STK_LINKER (htab
), p
);
11119 r
[0].r_offset
+= 2 * 4;
11120 p
= build_plt_stub (htab
, stub_entry
, p
, offset
, r
);
11121 bfd_put_32 (obfd
, BCTRL
, p
- 4);
11123 bfd_put_32 (obfd
, LD_R2_0R1
+ STK_TOC (htab
), p
);
11125 bfd_put_32 (obfd
, LD_R0_0R1
+ STK_LINKER (htab
), p
);
11127 bfd_put_32 (obfd
, MTLR_R0
, p
);
11129 bfd_put_32 (obfd
, BLR
, p
);
11134 p
= tls_get_addr_prologue (obfd
, p
, htab
);
11137 r
[0].r_offset
+= 18 * 4;
11139 p
= build_plt_stub (htab
, stub_entry
, p
, offset
, r
);
11140 bfd_put_32 (obfd
, BCTRL
, p
- 4);
11142 if (stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
11144 bfd_put_32 (obfd
, LD_R2_0R1
+ STK_TOC (htab
), p
);
11148 p
= tls_get_addr_epilogue (obfd
, p
, htab
);
11151 if (htab
->glink_eh_frame
!= NULL
11152 && htab
->glink_eh_frame
->size
!= 0)
11154 bfd_byte
*base
, *eh
;
11156 base
= htab
->glink_eh_frame
->contents
+ stub_entry
->group
->eh_base
+ 17;
11157 eh
= base
+ stub_entry
->group
->eh_size
;
11158 if (htab
->params
->no_tls_get_addr_regsave
)
11160 unsigned int lr_used
, delta
;
11161 lr_used
= stub_entry
->stub_offset
+ (p
- 20 - loc
);
11162 delta
= lr_used
- stub_entry
->group
->lr_restore
;
11163 stub_entry
->group
->lr_restore
= lr_used
+ 16;
11164 eh
= eh_advance (htab
->elf
.dynobj
, eh
, delta
);
11165 *eh
++ = DW_CFA_offset_extended_sf
;
11167 *eh
++ = -(STK_LINKER (htab
) / 8) & 0x7f;
11168 *eh
++ = DW_CFA_advance_loc
+ 4;
11172 unsigned int cfa_updt
, delta
;
11173 /* After the bctrl, lr has been modified so we need to emit
11174 .eh_frame info saying the return address is on the stack. In
11175 fact we must put the EH info at or before the call rather
11176 than after it, because the EH info for a call needs to be
11177 specified by that point.
11178 See libgcc/unwind-dw2.c execute_cfa_program.
11179 Any stack pointer update must be described immediately after
11180 the instruction making the change, and since the stdu occurs
11181 after saving regs we put all the reg saves and the cfa
11183 cfa_updt
= stub_entry
->stub_offset
+ 18 * 4;
11184 delta
= cfa_updt
- stub_entry
->group
->lr_restore
;
11185 stub_entry
->group
->lr_restore
11186 = stub_entry
->stub_offset
+ (p
- loc
) - 4;
11187 eh
= eh_advance (htab
->elf
.dynobj
, eh
, delta
);
11188 *eh
++ = DW_CFA_def_cfa_offset
;
11196 *eh
++ = DW_CFA_offset_extended_sf
;
11198 *eh
++ = (-16 / 8) & 0x7f;
11199 for (i
= 4; i
< 12; i
++)
11201 *eh
++ = DW_CFA_offset
+ i
;
11202 *eh
++ = (htab
->opd_abi
? 13 : 12) - i
;
11204 *eh
++ = (DW_CFA_advance_loc
11205 + (stub_entry
->group
->lr_restore
- 8 - cfa_updt
) / 4);
11206 *eh
++ = DW_CFA_def_cfa_offset
;
11208 for (i
= 4; i
< 12; i
++)
11209 *eh
++ = DW_CFA_restore
+ i
;
11210 *eh
++ = DW_CFA_advance_loc
+ 2;
11212 *eh
++ = DW_CFA_restore_extended
;
11214 stub_entry
->group
->eh_size
= eh
- base
;
11219 static Elf_Internal_Rela
*
11220 get_relocs (asection
*sec
, int count
)
11222 Elf_Internal_Rela
*relocs
;
11223 struct bfd_elf_section_data
*elfsec_data
;
11225 elfsec_data
= elf_section_data (sec
);
11226 relocs
= elfsec_data
->relocs
;
11227 if (relocs
== NULL
)
11229 bfd_size_type relsize
;
11230 relsize
= sec
->reloc_count
* sizeof (*relocs
);
11231 relocs
= bfd_alloc (sec
->owner
, relsize
);
11232 if (relocs
== NULL
)
11234 elfsec_data
->relocs
= relocs
;
11235 elfsec_data
->rela
.hdr
= bfd_zalloc (sec
->owner
,
11236 sizeof (Elf_Internal_Shdr
));
11237 if (elfsec_data
->rela
.hdr
== NULL
)
11239 elfsec_data
->rela
.hdr
->sh_size
= (sec
->reloc_count
11240 * sizeof (Elf64_External_Rela
));
11241 elfsec_data
->rela
.hdr
->sh_entsize
= sizeof (Elf64_External_Rela
);
11242 sec
->reloc_count
= 0;
11244 relocs
+= sec
->reloc_count
;
11245 sec
->reloc_count
+= count
;
11249 /* Convert the relocs R[0] thru R[-NUM_REL+1], which are all no-symbol
11250 forms, to the equivalent relocs against the global symbol given by
11254 use_global_in_relocs (struct ppc_link_hash_table
*htab
,
11255 struct ppc_stub_hash_entry
*stub_entry
,
11256 Elf_Internal_Rela
*r
, unsigned int num_rel
)
11258 struct elf_link_hash_entry
**hashes
;
11259 unsigned long symndx
;
11260 struct ppc_link_hash_entry
*h
;
11263 /* Relocs are always against symbols in their own object file. Fake
11264 up global sym hashes for the stub bfd (which has no symbols). */
11265 hashes
= elf_sym_hashes (htab
->params
->stub_bfd
);
11266 if (hashes
== NULL
)
11268 bfd_size_type hsize
;
11270 /* When called the first time, stub_globals will contain the
11271 total number of symbols seen during stub sizing. After
11272 allocating, stub_globals is used as an index to fill the
11274 hsize
= (htab
->stub_globals
+ 1) * sizeof (*hashes
);
11275 hashes
= bfd_zalloc (htab
->params
->stub_bfd
, hsize
);
11276 if (hashes
== NULL
)
11278 elf_sym_hashes (htab
->params
->stub_bfd
) = hashes
;
11279 htab
->stub_globals
= 1;
11281 symndx
= htab
->stub_globals
++;
11283 hashes
[symndx
] = &h
->elf
;
11284 if (h
->oh
!= NULL
&& h
->oh
->is_func
)
11285 h
= ppc_follow_link (h
->oh
);
11286 BFD_ASSERT (h
->elf
.root
.type
== bfd_link_hash_defined
11287 || h
->elf
.root
.type
== bfd_link_hash_defweak
);
11288 symval
= defined_sym_val (&h
->elf
);
11289 while (num_rel
-- != 0)
11291 r
->r_info
= ELF64_R_INFO (symndx
, ELF64_R_TYPE (r
->r_info
));
11292 if (h
->elf
.root
.u
.def
.section
!= stub_entry
->target_section
)
11294 /* H is an opd symbol. The addend must be zero, and the
11295 branch reloc is the only one we can convert. */
11300 r
->r_addend
-= symval
;
11307 get_r2off (struct bfd_link_info
*info
,
11308 struct ppc_stub_hash_entry
*stub_entry
)
11310 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
11311 bfd_vma r2off
= htab
->sec_info
[stub_entry
->target_section
->id
].toc_off
;
11315 /* Support linking -R objects. Get the toc pointer from the
11318 if (!htab
->opd_abi
)
11320 asection
*opd
= stub_entry
->h
->elf
.root
.u
.def
.section
;
11321 bfd_vma opd_off
= stub_entry
->h
->elf
.root
.u
.def
.value
;
11323 if (strcmp (opd
->name
, ".opd") != 0
11324 || opd
->reloc_count
!= 0)
11326 info
->callbacks
->einfo
11327 (_("%P: cannot find opd entry toc for `%pT'\n"),
11328 stub_entry
->h
->elf
.root
.root
.string
);
11329 bfd_set_error (bfd_error_bad_value
);
11330 return (bfd_vma
) -1;
11332 if (!bfd_get_section_contents (opd
->owner
, opd
, buf
, opd_off
+ 8, 8))
11333 return (bfd_vma
) -1;
11334 r2off
= bfd_get_64 (opd
->owner
, buf
);
11335 r2off
-= elf_gp (info
->output_bfd
);
11337 r2off
-= htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
;
11342 ppc_build_one_stub (struct bfd_hash_entry
*gen_entry
, void *in_arg
)
11344 struct ppc_stub_hash_entry
*stub_entry
;
11345 struct ppc_branch_hash_entry
*br_entry
;
11346 struct bfd_link_info
*info
;
11347 struct ppc_link_hash_table
*htab
;
11349 bfd_byte
*p
, *relp
;
11351 Elf_Internal_Rela
*r
;
11356 /* Massage our args to the form they really have. */
11357 stub_entry
= (struct ppc_stub_hash_entry
*) gen_entry
;
11360 /* Fail if the target section could not be assigned to an output
11361 section. The user should fix his linker script. */
11362 if (stub_entry
->target_section
!= NULL
11363 && stub_entry
->target_section
->output_section
== NULL
11364 && info
->non_contiguous_regions
)
11365 info
->callbacks
->einfo (_("%F%P: Could not assign '%pA' to an output section. "
11366 "Retry without --enable-non-contiguous-regions.\n"),
11367 stub_entry
->target_section
);
11369 /* Same for the group. */
11370 if (stub_entry
->group
->stub_sec
!= NULL
11371 && stub_entry
->group
->stub_sec
->output_section
== NULL
11372 && info
->non_contiguous_regions
)
11373 info
->callbacks
->einfo (_("%F%P: Could not assign group %pA target %pA to an "
11374 "output section. Retry without "
11375 "--enable-non-contiguous-regions.\n"),
11376 stub_entry
->group
->stub_sec
,
11377 stub_entry
->target_section
);
11379 htab
= ppc_hash_table (info
);
11383 BFD_ASSERT (stub_entry
->stub_offset
>= stub_entry
->group
->stub_sec
->size
);
11384 loc
= stub_entry
->group
->stub_sec
->contents
+ stub_entry
->stub_offset
;
11386 htab
->stub_count
[stub_entry
->stub_type
- 1] += 1;
11387 switch (stub_entry
->stub_type
)
11389 case ppc_stub_long_branch
:
11390 case ppc_stub_long_branch_r2off
:
11391 /* Branches are relative. This is where we are going to. */
11392 targ
= (stub_entry
->target_value
11393 + stub_entry
->target_section
->output_offset
11394 + stub_entry
->target_section
->output_section
->vma
);
11395 targ
+= PPC64_LOCAL_ENTRY_OFFSET (stub_entry
->other
);
11397 /* And this is where we are coming from. */
11398 off
= (stub_entry
->stub_offset
11399 + stub_entry
->group
->stub_sec
->output_offset
11400 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11404 if (stub_entry
->stub_type
== ppc_stub_long_branch_r2off
)
11406 bfd_vma r2off
= get_r2off (info
, stub_entry
);
11408 if (r2off
== (bfd_vma
) -1)
11410 htab
->stub_error
= TRUE
;
11413 bfd_put_32 (htab
->params
->stub_bfd
, STD_R2_0R1
+ STK_TOC (htab
), p
);
11415 if (PPC_HA (r2off
) != 0)
11417 bfd_put_32 (htab
->params
->stub_bfd
,
11418 ADDIS_R2_R2
| PPC_HA (r2off
), p
);
11421 if (PPC_LO (r2off
) != 0)
11423 bfd_put_32 (htab
->params
->stub_bfd
,
11424 ADDI_R2_R2
| PPC_LO (r2off
), p
);
11429 bfd_put_32 (htab
->params
->stub_bfd
, B_DOT
| (off
& 0x3fffffc), p
);
11432 if (off
+ (1 << 25) >= (bfd_vma
) (1 << 26))
11435 (_("long branch stub `%s' offset overflow"),
11436 stub_entry
->root
.string
);
11437 htab
->stub_error
= TRUE
;
11441 if (info
->emitrelocations
)
11443 r
= get_relocs (stub_entry
->group
->stub_sec
, 1);
11446 r
->r_offset
= p
- 4 - stub_entry
->group
->stub_sec
->contents
;
11447 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL24
);
11448 r
->r_addend
= targ
;
11449 if (stub_entry
->h
!= NULL
11450 && !use_global_in_relocs (htab
, stub_entry
, r
, 1))
11455 case ppc_stub_plt_branch
:
11456 case ppc_stub_plt_branch_r2off
:
11457 br_entry
= ppc_branch_hash_lookup (&htab
->branch_hash_table
,
11458 stub_entry
->root
.string
+ 9,
11460 if (br_entry
== NULL
)
11462 _bfd_error_handler (_("can't find branch stub `%s'"),
11463 stub_entry
->root
.string
);
11464 htab
->stub_error
= TRUE
;
11468 targ
= (stub_entry
->target_value
11469 + stub_entry
->target_section
->output_offset
11470 + stub_entry
->target_section
->output_section
->vma
);
11471 if (stub_entry
->stub_type
!= ppc_stub_plt_branch_r2off
)
11472 targ
+= PPC64_LOCAL_ENTRY_OFFSET (stub_entry
->other
);
11474 bfd_put_64 (htab
->brlt
->owner
, targ
,
11475 htab
->brlt
->contents
+ br_entry
->offset
);
11477 if (br_entry
->iter
== htab
->stub_iteration
)
11479 br_entry
->iter
= 0;
11481 if (htab
->relbrlt
!= NULL
)
11483 /* Create a reloc for the branch lookup table entry. */
11484 Elf_Internal_Rela rela
;
11487 rela
.r_offset
= (br_entry
->offset
11488 + htab
->brlt
->output_offset
11489 + htab
->brlt
->output_section
->vma
);
11490 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
11491 rela
.r_addend
= targ
;
11493 rl
= htab
->relbrlt
->contents
;
11494 rl
+= (htab
->relbrlt
->reloc_count
++
11495 * sizeof (Elf64_External_Rela
));
11496 bfd_elf64_swap_reloca_out (htab
->relbrlt
->owner
, &rela
, rl
);
11498 else if (info
->emitrelocations
)
11500 r
= get_relocs (htab
->brlt
, 1);
11503 /* brlt, being SEC_LINKER_CREATED does not go through the
11504 normal reloc processing. Symbols and offsets are not
11505 translated from input file to output file form, so
11506 set up the offset per the output file. */
11507 r
->r_offset
= (br_entry
->offset
11508 + htab
->brlt
->output_offset
11509 + htab
->brlt
->output_section
->vma
);
11510 r
->r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
11511 r
->r_addend
= targ
;
11515 targ
= (br_entry
->offset
11516 + htab
->brlt
->output_offset
11517 + htab
->brlt
->output_section
->vma
);
11519 off
= (elf_gp (info
->output_bfd
)
11520 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
11523 if (off
+ 0x80008000 > 0xffffffff || (off
& 7) != 0)
11525 info
->callbacks
->einfo
11526 (_("%P: linkage table error against `%pT'\n"),
11527 stub_entry
->root
.string
);
11528 bfd_set_error (bfd_error_bad_value
);
11529 htab
->stub_error
= TRUE
;
11533 if (info
->emitrelocations
)
11535 r
= get_relocs (stub_entry
->group
->stub_sec
, 1 + (PPC_HA (off
) != 0));
11538 r
[0].r_offset
= loc
- stub_entry
->group
->stub_sec
->contents
;
11539 if (bfd_big_endian (info
->output_bfd
))
11540 r
[0].r_offset
+= 2;
11541 if (stub_entry
->stub_type
== ppc_stub_plt_branch_r2off
)
11542 r
[0].r_offset
+= 4;
11543 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
11544 r
[0].r_addend
= targ
;
11545 if (PPC_HA (off
) != 0)
11547 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_HA
);
11548 r
[1].r_offset
= r
[0].r_offset
+ 4;
11549 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
11550 r
[1].r_addend
= r
[0].r_addend
;
11555 if (stub_entry
->stub_type
!= ppc_stub_plt_branch_r2off
)
11557 if (PPC_HA (off
) != 0)
11559 bfd_put_32 (htab
->params
->stub_bfd
,
11560 ADDIS_R12_R2
| PPC_HA (off
), p
);
11562 bfd_put_32 (htab
->params
->stub_bfd
,
11563 LD_R12_0R12
| PPC_LO (off
), p
);
11566 bfd_put_32 (htab
->params
->stub_bfd
,
11567 LD_R12_0R2
| PPC_LO (off
), p
);
11571 bfd_vma r2off
= get_r2off (info
, stub_entry
);
11573 if (r2off
== (bfd_vma
) -1)
11575 htab
->stub_error
= TRUE
;
11579 bfd_put_32 (htab
->params
->stub_bfd
, STD_R2_0R1
+ STK_TOC (htab
), p
);
11581 if (PPC_HA (off
) != 0)
11583 bfd_put_32 (htab
->params
->stub_bfd
,
11584 ADDIS_R12_R2
| PPC_HA (off
), p
);
11586 bfd_put_32 (htab
->params
->stub_bfd
,
11587 LD_R12_0R12
| PPC_LO (off
), p
);
11590 bfd_put_32 (htab
->params
->stub_bfd
, LD_R12_0R2
| PPC_LO (off
), p
);
11592 if (PPC_HA (r2off
) != 0)
11595 bfd_put_32 (htab
->params
->stub_bfd
,
11596 ADDIS_R2_R2
| PPC_HA (r2off
), p
);
11598 if (PPC_LO (r2off
) != 0)
11601 bfd_put_32 (htab
->params
->stub_bfd
,
11602 ADDI_R2_R2
| PPC_LO (r2off
), p
);
11606 bfd_put_32 (htab
->params
->stub_bfd
, MTCTR_R12
, p
);
11608 bfd_put_32 (htab
->params
->stub_bfd
, BCTR
, p
);
11612 case ppc_stub_long_branch_notoc
:
11613 case ppc_stub_long_branch_both
:
11614 case ppc_stub_plt_branch_notoc
:
11615 case ppc_stub_plt_branch_both
:
11616 case ppc_stub_plt_call_notoc
:
11617 case ppc_stub_plt_call_both
:
11619 off
= (stub_entry
->stub_offset
11620 + stub_entry
->group
->stub_sec
->output_offset
11621 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11622 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
11623 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
11624 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
11627 bfd_put_32 (htab
->params
->stub_bfd
, STD_R2_0R1
+ STK_TOC (htab
), p
);
11630 if (stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
)
11632 targ
= stub_entry
->plt_ent
->plt
.offset
& ~1;
11633 if (targ
>= (bfd_vma
) -2)
11636 plt
= htab
->elf
.splt
;
11637 if (!htab
->elf
.dynamic_sections_created
11638 || stub_entry
->h
== NULL
11639 || stub_entry
->h
->elf
.dynindx
== -1)
11641 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
11642 plt
= htab
->elf
.iplt
;
11644 plt
= htab
->pltlocal
;
11646 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
11649 targ
= (stub_entry
->target_value
11650 + stub_entry
->target_section
->output_offset
11651 + stub_entry
->target_section
->output_section
->vma
);
11657 if (htab
->powerxx_stubs
)
11659 bfd_boolean load
= stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
;
11660 p
= build_powerxx_offset (htab
->params
->stub_bfd
, p
, off
, odd
, load
);
11664 /* The notoc stubs calculate their target (either a PLT entry or
11665 the global entry point of a function) relative to the PC
11666 returned by the "bcl" two instructions past the start of the
11667 sequence emitted by build_offset. The offset is therefore 8
11668 less than calculated from the start of the sequence. */
11670 p
= build_offset (htab
->params
->stub_bfd
, p
, off
,
11671 stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
);
11674 if (stub_entry
->stub_type
<= ppc_stub_long_branch_both
)
11678 from
= (stub_entry
->stub_offset
11679 + stub_entry
->group
->stub_sec
->output_offset
11680 + stub_entry
->group
->stub_sec
->output_section
->vma
11682 bfd_put_32 (htab
->params
->stub_bfd
,
11683 B_DOT
| ((targ
- from
) & 0x3fffffc), p
);
11687 bfd_put_32 (htab
->params
->stub_bfd
, MTCTR_R12
, p
);
11689 bfd_put_32 (htab
->params
->stub_bfd
, BCTR
, p
);
11693 if (info
->emitrelocations
)
11695 bfd_vma roff
= relp
- stub_entry
->group
->stub_sec
->contents
;
11696 if (htab
->powerxx_stubs
)
11697 num_rel
+= num_relocs_for_powerxx_offset (off
, odd
);
11700 num_rel
+= num_relocs_for_offset (off
);
11703 r
= get_relocs (stub_entry
->group
->stub_sec
, num_rel
);
11706 if (htab
->powerxx_stubs
)
11707 r
= emit_relocs_for_powerxx_offset (info
, r
, roff
, targ
, off
, odd
);
11709 r
= emit_relocs_for_offset (info
, r
, roff
, targ
, off
);
11710 if (stub_entry
->stub_type
== ppc_stub_long_branch_notoc
11711 || stub_entry
->stub_type
== ppc_stub_long_branch_both
)
11714 roff
= p
- 4 - stub_entry
->group
->stub_sec
->contents
;
11715 r
->r_offset
= roff
;
11716 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL24
);
11717 r
->r_addend
= targ
;
11718 if (stub_entry
->h
!= NULL
11719 && !use_global_in_relocs (htab
, stub_entry
, r
, num_rel
))
11724 if (!htab
->powerxx_stubs
11725 && htab
->glink_eh_frame
!= NULL
11726 && htab
->glink_eh_frame
->size
!= 0)
11728 bfd_byte
*base
, *eh
;
11729 unsigned int lr_used
, delta
;
11731 base
= (htab
->glink_eh_frame
->contents
11732 + stub_entry
->group
->eh_base
+ 17);
11733 eh
= base
+ stub_entry
->group
->eh_size
;
11734 lr_used
= stub_entry
->stub_offset
+ 8;
11735 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
11736 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
11737 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
11739 delta
= lr_used
- stub_entry
->group
->lr_restore
;
11740 stub_entry
->group
->lr_restore
= lr_used
+ 8;
11741 eh
= eh_advance (htab
->elf
.dynobj
, eh
, delta
);
11742 *eh
++ = DW_CFA_register
;
11745 *eh
++ = DW_CFA_advance_loc
+ 2;
11746 *eh
++ = DW_CFA_restore_extended
;
11748 stub_entry
->group
->eh_size
= eh
- base
;
11752 case ppc_stub_plt_call
:
11753 case ppc_stub_plt_call_r2save
:
11754 if (stub_entry
->h
!= NULL
11755 && stub_entry
->h
->is_func_descriptor
11756 && stub_entry
->h
->oh
!= NULL
)
11758 struct ppc_link_hash_entry
*fh
= ppc_follow_link (stub_entry
->h
->oh
);
11760 /* If the old-ABI "dot-symbol" is undefined make it weak so
11761 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL. */
11762 if (fh
->elf
.root
.type
== bfd_link_hash_undefined
11763 && (stub_entry
->h
->elf
.root
.type
== bfd_link_hash_defined
11764 || stub_entry
->h
->elf
.root
.type
== bfd_link_hash_defweak
))
11765 fh
->elf
.root
.type
= bfd_link_hash_undefweak
;
11768 /* Now build the stub. */
11769 targ
= stub_entry
->plt_ent
->plt
.offset
& ~1;
11770 if (targ
>= (bfd_vma
) -2)
11773 plt
= htab
->elf
.splt
;
11774 if (!htab
->elf
.dynamic_sections_created
11775 || stub_entry
->h
== NULL
11776 || stub_entry
->h
->elf
.dynindx
== -1)
11778 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
11779 plt
= htab
->elf
.iplt
;
11781 plt
= htab
->pltlocal
;
11783 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
11785 off
= (elf_gp (info
->output_bfd
)
11786 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
11789 if (off
+ 0x80008000 > 0xffffffff || (off
& 7) != 0)
11791 info
->callbacks
->einfo
11792 /* xgettext:c-format */
11793 (_("%P: linkage table error against `%pT'\n"),
11794 stub_entry
->h
!= NULL
11795 ? stub_entry
->h
->elf
.root
.root
.string
11797 bfd_set_error (bfd_error_bad_value
);
11798 htab
->stub_error
= TRUE
;
11803 if (info
->emitrelocations
)
11805 r
= get_relocs (stub_entry
->group
->stub_sec
,
11806 ((PPC_HA (off
) != 0)
11808 ? 2 + (htab
->params
->plt_static_chain
11809 && PPC_HA (off
+ 16) == PPC_HA (off
))
11813 r
[0].r_offset
= loc
- stub_entry
->group
->stub_sec
->contents
;
11814 if (bfd_big_endian (info
->output_bfd
))
11815 r
[0].r_offset
+= 2;
11816 r
[0].r_addend
= targ
;
11818 if (stub_entry
->h
!= NULL
11819 && is_tls_get_addr (&stub_entry
->h
->elf
, htab
)
11820 && htab
->params
->tls_get_addr_opt
)
11821 p
= build_tls_get_addr_stub (htab
, stub_entry
, loc
, off
, r
);
11823 p
= build_plt_stub (htab
, stub_entry
, loc
, off
, r
);
11826 case ppc_stub_save_res
:
11834 stub_entry
->group
->stub_sec
->size
= stub_entry
->stub_offset
+ (p
- loc
);
11836 if (htab
->params
->emit_stub_syms
)
11838 struct elf_link_hash_entry
*h
;
11841 const char *const stub_str
[] = { "long_branch",
11854 len1
= strlen (stub_str
[stub_entry
->stub_type
- 1]);
11855 len2
= strlen (stub_entry
->root
.string
);
11856 name
= bfd_malloc (len1
+ len2
+ 2);
11859 memcpy (name
, stub_entry
->root
.string
, 9);
11860 memcpy (name
+ 9, stub_str
[stub_entry
->stub_type
- 1], len1
);
11861 memcpy (name
+ len1
+ 9, stub_entry
->root
.string
+ 8, len2
- 8 + 1);
11862 h
= elf_link_hash_lookup (&htab
->elf
, name
, TRUE
, FALSE
, FALSE
);
11865 if (h
->root
.type
== bfd_link_hash_new
)
11867 h
->root
.type
= bfd_link_hash_defined
;
11868 h
->root
.u
.def
.section
= stub_entry
->group
->stub_sec
;
11869 h
->root
.u
.def
.value
= stub_entry
->stub_offset
;
11870 h
->ref_regular
= 1;
11871 h
->def_regular
= 1;
11872 h
->ref_regular_nonweak
= 1;
11873 h
->forced_local
= 1;
11875 h
->root
.linker_def
= 1;
11882 /* As above, but don't actually build the stub. Just bump offset so
11883 we know stub section sizes, and select plt_branch stubs where
11884 long_branch stubs won't do. */
11887 ppc_size_one_stub (struct bfd_hash_entry
*gen_entry
, void *in_arg
)
11889 struct ppc_stub_hash_entry
*stub_entry
;
11890 struct bfd_link_info
*info
;
11891 struct ppc_link_hash_table
*htab
;
11893 bfd_vma targ
, off
, r2off
;
11894 unsigned int size
, extra
, lr_used
, delta
, odd
;
11896 /* Massage our args to the form they really have. */
11897 stub_entry
= (struct ppc_stub_hash_entry
*) gen_entry
;
11900 htab
= ppc_hash_table (info
);
11904 /* Fail if the target section could not be assigned to an output
11905 section. The user should fix his linker script. */
11906 if (stub_entry
->target_section
!= NULL
11907 && stub_entry
->target_section
->output_section
== NULL
11908 && info
->non_contiguous_regions
)
11909 info
->callbacks
->einfo (_("%F%P: Could not assign %pA to an output section. "
11910 "Retry without --enable-non-contiguous-regions.\n"),
11911 stub_entry
->target_section
);
11913 /* Same for the group. */
11914 if (stub_entry
->group
->stub_sec
!= NULL
11915 && stub_entry
->group
->stub_sec
->output_section
== NULL
11916 && info
->non_contiguous_regions
)
11917 info
->callbacks
->einfo (_("%F%P: Could not assign group %pA target %pA to an "
11918 "output section. Retry without "
11919 "--enable-non-contiguous-regions.\n"),
11920 stub_entry
->group
->stub_sec
,
11921 stub_entry
->target_section
);
11923 /* Make a note of the offset within the stubs for this entry. */
11924 stub_entry
->stub_offset
= stub_entry
->group
->stub_sec
->size
;
11926 if (stub_entry
->h
!= NULL
11927 && stub_entry
->h
->save_res
11928 && stub_entry
->h
->elf
.root
.type
== bfd_link_hash_defined
11929 && stub_entry
->h
->elf
.root
.u
.def
.section
== htab
->sfpr
)
11931 /* Don't make stubs to out-of-line register save/restore
11932 functions. Instead, emit copies of the functions. */
11933 stub_entry
->group
->needs_save_res
= 1;
11934 stub_entry
->stub_type
= ppc_stub_save_res
;
11938 switch (stub_entry
->stub_type
)
11940 case ppc_stub_plt_branch
:
11941 case ppc_stub_plt_branch_r2off
:
11942 /* Reset the stub type from the plt branch variant in case we now
11943 can reach with a shorter stub. */
11944 stub_entry
->stub_type
+= ppc_stub_long_branch
- ppc_stub_plt_branch
;
11945 /* Fall through. */
11946 case ppc_stub_long_branch
:
11947 case ppc_stub_long_branch_r2off
:
11948 targ
= (stub_entry
->target_value
11949 + stub_entry
->target_section
->output_offset
11950 + stub_entry
->target_section
->output_section
->vma
);
11951 targ
+= PPC64_LOCAL_ENTRY_OFFSET (stub_entry
->other
);
11952 off
= (stub_entry
->stub_offset
11953 + stub_entry
->group
->stub_sec
->output_offset
11954 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11958 if (stub_entry
->stub_type
== ppc_stub_long_branch_r2off
)
11960 r2off
= get_r2off (info
, stub_entry
);
11961 if (r2off
== (bfd_vma
) -1)
11963 htab
->stub_error
= TRUE
;
11967 if (PPC_HA (r2off
) != 0)
11969 if (PPC_LO (r2off
) != 0)
11975 /* If the branch offset is too big, use a ppc_stub_plt_branch.
11976 Do the same for -R objects without function descriptors. */
11977 if ((stub_entry
->stub_type
== ppc_stub_long_branch_r2off
11979 && htab
->sec_info
[stub_entry
->target_section
->id
].toc_off
== 0)
11980 || off
+ (1 << 25) >= (bfd_vma
) (1 << 26))
11982 struct ppc_branch_hash_entry
*br_entry
;
11984 br_entry
= ppc_branch_hash_lookup (&htab
->branch_hash_table
,
11985 stub_entry
->root
.string
+ 9,
11987 if (br_entry
== NULL
)
11989 _bfd_error_handler (_("can't build branch stub `%s'"),
11990 stub_entry
->root
.string
);
11991 htab
->stub_error
= TRUE
;
11995 if (br_entry
->iter
!= htab
->stub_iteration
)
11997 br_entry
->iter
= htab
->stub_iteration
;
11998 br_entry
->offset
= htab
->brlt
->size
;
11999 htab
->brlt
->size
+= 8;
12001 if (htab
->relbrlt
!= NULL
)
12002 htab
->relbrlt
->size
+= sizeof (Elf64_External_Rela
);
12003 else if (info
->emitrelocations
)
12005 htab
->brlt
->reloc_count
+= 1;
12006 htab
->brlt
->flags
|= SEC_RELOC
;
12010 targ
= (br_entry
->offset
12011 + htab
->brlt
->output_offset
12012 + htab
->brlt
->output_section
->vma
);
12013 off
= (elf_gp (info
->output_bfd
)
12014 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
12017 if (info
->emitrelocations
)
12019 stub_entry
->group
->stub_sec
->reloc_count
12020 += 1 + (PPC_HA (off
) != 0);
12021 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
12024 stub_entry
->stub_type
+= ppc_stub_plt_branch
- ppc_stub_long_branch
;
12025 if (stub_entry
->stub_type
!= ppc_stub_plt_branch_r2off
)
12028 if (PPC_HA (off
) != 0)
12034 if (PPC_HA (off
) != 0)
12037 if (PPC_HA (r2off
) != 0)
12039 if (PPC_LO (r2off
) != 0)
12043 else if (info
->emitrelocations
)
12045 stub_entry
->group
->stub_sec
->reloc_count
+= 1;
12046 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
12050 case ppc_stub_plt_branch_notoc
:
12051 case ppc_stub_plt_branch_both
:
12052 stub_entry
->stub_type
+= ppc_stub_long_branch
- ppc_stub_plt_branch
;
12053 /* Fall through. */
12054 case ppc_stub_long_branch_notoc
:
12055 case ppc_stub_long_branch_both
:
12056 off
= (stub_entry
->stub_offset
12057 + stub_entry
->group
->stub_sec
->output_offset
12058 + stub_entry
->group
->stub_sec
->output_section
->vma
);
12060 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
)
12063 targ
= (stub_entry
->target_value
12064 + stub_entry
->target_section
->output_offset
12065 + stub_entry
->target_section
->output_section
->vma
);
12069 if (info
->emitrelocations
)
12071 unsigned int num_rel
;
12072 if (htab
->powerxx_stubs
)
12073 num_rel
= num_relocs_for_powerxx_offset (off
, odd
);
12075 num_rel
= num_relocs_for_offset (off
- 8);
12076 stub_entry
->group
->stub_sec
->reloc_count
+= num_rel
;
12077 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
12080 if (htab
->powerxx_stubs
)
12081 extra
= size_powerxx_offset (off
, odd
);
12083 extra
= size_offset (off
- 8);
12084 /* Include branch insn plus those in the offset sequence. */
12086 /* The branch insn is at the end, or "extra" bytes along. So
12087 its offset will be "extra" bytes less that that already
12091 if (!htab
->powerxx_stubs
)
12093 /* After the bcl, lr has been modified so we need to emit
12094 .eh_frame info saying the return address is in r12. */
12095 lr_used
= stub_entry
->stub_offset
+ 8;
12096 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
)
12098 /* The eh_frame info will consist of a DW_CFA_advance_loc or
12099 variant, DW_CFA_register, 65, 12, DW_CFA_advance_loc+2,
12100 DW_CFA_restore_extended 65. */
12101 delta
= lr_used
- stub_entry
->group
->lr_restore
;
12102 stub_entry
->group
->eh_size
+= eh_advance_size (delta
) + 6;
12103 stub_entry
->group
->lr_restore
= lr_used
+ 8;
12106 /* If the branch can't reach, use a plt_branch. */
12107 if (off
+ (1 << 25) >= (bfd_vma
) (1 << 26))
12109 stub_entry
->stub_type
+= (ppc_stub_plt_branch_notoc
12110 - ppc_stub_long_branch_notoc
);
12113 else if (info
->emitrelocations
)
12114 stub_entry
->group
->stub_sec
->reloc_count
+=1;
12117 case ppc_stub_plt_call_notoc
:
12118 case ppc_stub_plt_call_both
:
12119 off
= (stub_entry
->stub_offset
12120 + stub_entry
->group
->stub_sec
->output_offset
12121 + stub_entry
->group
->stub_sec
->output_section
->vma
);
12122 if (stub_entry
->stub_type
== ppc_stub_plt_call_both
)
12124 targ
= stub_entry
->plt_ent
->plt
.offset
& ~1;
12125 if (targ
>= (bfd_vma
) -2)
12128 plt
= htab
->elf
.splt
;
12129 if (!htab
->elf
.dynamic_sections_created
12130 || stub_entry
->h
== NULL
12131 || stub_entry
->h
->elf
.dynindx
== -1)
12133 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
12134 plt
= htab
->elf
.iplt
;
12136 plt
= htab
->pltlocal
;
12138 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
12142 if (htab
->params
->plt_stub_align
!= 0)
12144 unsigned pad
= plt_stub_pad (htab
, stub_entry
, off
);
12146 stub_entry
->group
->stub_sec
->size
+= pad
;
12147 stub_entry
->stub_offset
= stub_entry
->group
->stub_sec
->size
;
12151 if (info
->emitrelocations
)
12153 unsigned int num_rel
;
12154 if (htab
->powerxx_stubs
)
12155 num_rel
= num_relocs_for_powerxx_offset (off
, odd
);
12157 num_rel
= num_relocs_for_offset (off
- 8);
12158 stub_entry
->group
->stub_sec
->reloc_count
+= num_rel
;
12159 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
12162 size
= plt_stub_size (htab
, stub_entry
, off
);
12164 if (!htab
->powerxx_stubs
)
12166 /* After the bcl, lr has been modified so we need to emit
12167 .eh_frame info saying the return address is in r12. */
12168 lr_used
= stub_entry
->stub_offset
+ 8;
12169 if (stub_entry
->stub_type
== ppc_stub_plt_call_both
)
12171 /* The eh_frame info will consist of a DW_CFA_advance_loc or
12172 variant, DW_CFA_register, 65, 12, DW_CFA_advance_loc+2,
12173 DW_CFA_restore_extended 65. */
12174 delta
= lr_used
- stub_entry
->group
->lr_restore
;
12175 stub_entry
->group
->eh_size
+= eh_advance_size (delta
) + 6;
12176 stub_entry
->group
->lr_restore
= lr_used
+ 8;
12180 case ppc_stub_plt_call
:
12181 case ppc_stub_plt_call_r2save
:
12182 targ
= stub_entry
->plt_ent
->plt
.offset
& ~(bfd_vma
) 1;
12183 if (targ
>= (bfd_vma
) -2)
12185 plt
= htab
->elf
.splt
;
12186 if (!htab
->elf
.dynamic_sections_created
12187 || stub_entry
->h
== NULL
12188 || stub_entry
->h
->elf
.dynindx
== -1)
12190 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
12191 plt
= htab
->elf
.iplt
;
12193 plt
= htab
->pltlocal
;
12195 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
12197 off
= (elf_gp (info
->output_bfd
)
12198 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
12201 if (htab
->params
->plt_stub_align
!= 0)
12203 unsigned pad
= plt_stub_pad (htab
, stub_entry
, off
);
12205 stub_entry
->group
->stub_sec
->size
+= pad
;
12206 stub_entry
->stub_offset
= stub_entry
->group
->stub_sec
->size
;
12209 if (info
->emitrelocations
)
12211 stub_entry
->group
->stub_sec
->reloc_count
12212 += ((PPC_HA (off
) != 0)
12214 ? 2 + (htab
->params
->plt_static_chain
12215 && PPC_HA (off
+ 16) == PPC_HA (off
))
12217 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
12220 size
= plt_stub_size (htab
, stub_entry
, off
);
12222 if (stub_entry
->h
!= NULL
12223 && is_tls_get_addr (&stub_entry
->h
->elf
, htab
)
12224 && htab
->params
->tls_get_addr_opt
12225 && stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
12227 if (htab
->params
->no_tls_get_addr_regsave
)
12229 lr_used
= stub_entry
->stub_offset
+ size
- 20;
12230 /* The eh_frame info will consist of a DW_CFA_advance_loc
12231 or variant, DW_CFA_offset_externed_sf, 65, -stackoff,
12232 DW_CFA_advance_loc+4, DW_CFA_restore_extended, 65. */
12233 delta
= lr_used
- stub_entry
->group
->lr_restore
;
12234 stub_entry
->group
->eh_size
+= eh_advance_size (delta
) + 6;
12238 /* Adjustments to r1 need to be described. */
12239 unsigned int cfa_updt
= stub_entry
->stub_offset
+ 18 * 4;
12240 delta
= cfa_updt
- stub_entry
->group
->lr_restore
;
12241 stub_entry
->group
->eh_size
+= eh_advance_size (delta
);
12242 stub_entry
->group
->eh_size
+= htab
->opd_abi
? 36 : 35;
12244 stub_entry
->group
->lr_restore
= size
- 4;
12253 stub_entry
->group
->stub_sec
->size
+= size
;
12257 /* Set up various things so that we can make a list of input sections
12258 for each output section included in the link. Returns -1 on error,
12259 0 when no stubs will be needed, and 1 on success. */
12262 ppc64_elf_setup_section_lists (struct bfd_link_info
*info
)
12266 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12271 htab
->sec_info_arr_size
= _bfd_section_id
;
12272 amt
= sizeof (*htab
->sec_info
) * (htab
->sec_info_arr_size
);
12273 htab
->sec_info
= bfd_zmalloc (amt
);
12274 if (htab
->sec_info
== NULL
)
12277 /* Set toc_off for com, und, abs and ind sections. */
12278 for (id
= 0; id
< 3; id
++)
12279 htab
->sec_info
[id
].toc_off
= TOC_BASE_OFF
;
12284 /* Set up for first pass at multitoc partitioning. */
12287 ppc64_elf_start_multitoc_partition (struct bfd_link_info
*info
)
12289 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12291 htab
->toc_curr
= ppc64_elf_set_toc (info
, info
->output_bfd
);
12292 htab
->toc_bfd
= NULL
;
12293 htab
->toc_first_sec
= NULL
;
12296 /* The linker repeatedly calls this function for each TOC input section
12297 and linker generated GOT section. Group input bfds such that the toc
12298 within a group is less than 64k in size. */
12301 ppc64_elf_next_toc_section (struct bfd_link_info
*info
, asection
*isec
)
12303 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12304 bfd_vma addr
, off
, limit
;
12309 if (!htab
->second_toc_pass
)
12311 /* Keep track of the first .toc or .got section for this input bfd. */
12312 bfd_boolean new_bfd
= htab
->toc_bfd
!= isec
->owner
;
12316 htab
->toc_bfd
= isec
->owner
;
12317 htab
->toc_first_sec
= isec
;
12320 addr
= isec
->output_offset
+ isec
->output_section
->vma
;
12321 off
= addr
- htab
->toc_curr
;
12322 limit
= 0x80008000;
12323 if (ppc64_elf_tdata (isec
->owner
)->has_small_toc_reloc
)
12325 if (off
+ isec
->size
> limit
)
12327 addr
= (htab
->toc_first_sec
->output_offset
12328 + htab
->toc_first_sec
->output_section
->vma
);
12329 htab
->toc_curr
= addr
;
12330 htab
->toc_curr
&= -TOC_BASE_ALIGN
;
12333 /* toc_curr is the base address of this toc group. Set elf_gp
12334 for the input section to be the offset relative to the
12335 output toc base plus 0x8000. Making the input elf_gp an
12336 offset allows us to move the toc as a whole without
12337 recalculating input elf_gp. */
12338 off
= htab
->toc_curr
- elf_gp (info
->output_bfd
);
12339 off
+= TOC_BASE_OFF
;
12341 /* Die if someone uses a linker script that doesn't keep input
12342 file .toc and .got together. */
12344 && elf_gp (isec
->owner
) != 0
12345 && elf_gp (isec
->owner
) != off
)
12348 elf_gp (isec
->owner
) = off
;
12352 /* During the second pass toc_first_sec points to the start of
12353 a toc group, and toc_curr is used to track the old elf_gp.
12354 We use toc_bfd to ensure we only look at each bfd once. */
12355 if (htab
->toc_bfd
== isec
->owner
)
12357 htab
->toc_bfd
= isec
->owner
;
12359 if (htab
->toc_first_sec
== NULL
12360 || htab
->toc_curr
!= elf_gp (isec
->owner
))
12362 htab
->toc_curr
= elf_gp (isec
->owner
);
12363 htab
->toc_first_sec
= isec
;
12365 addr
= (htab
->toc_first_sec
->output_offset
12366 + htab
->toc_first_sec
->output_section
->vma
);
12367 off
= addr
- elf_gp (info
->output_bfd
) + TOC_BASE_OFF
;
12368 elf_gp (isec
->owner
) = off
;
12373 /* Called via elf_link_hash_traverse to merge GOT entries for global
12377 merge_global_got (struct elf_link_hash_entry
*h
, void *inf ATTRIBUTE_UNUSED
)
12379 if (h
->root
.type
== bfd_link_hash_indirect
)
12382 merge_got_entries (&h
->got
.glist
);
12387 /* Called via elf_link_hash_traverse to allocate GOT entries for global
12391 reallocate_got (struct elf_link_hash_entry
*h
, void *inf
)
12393 struct got_entry
*gent
;
12395 if (h
->root
.type
== bfd_link_hash_indirect
)
12398 for (gent
= h
->got
.glist
; gent
!= NULL
; gent
= gent
->next
)
12399 if (!gent
->is_indirect
)
12400 allocate_got (h
, (struct bfd_link_info
*) inf
, gent
);
12404 /* Called on the first multitoc pass after the last call to
12405 ppc64_elf_next_toc_section. This function removes duplicate GOT
12409 ppc64_elf_layout_multitoc (struct bfd_link_info
*info
)
12411 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12412 struct bfd
*ibfd
, *ibfd2
;
12413 bfd_boolean done_something
;
12415 htab
->multi_toc_needed
= htab
->toc_curr
!= elf_gp (info
->output_bfd
);
12417 if (!htab
->do_multi_toc
)
12420 /* Merge global sym got entries within a toc group. */
12421 elf_link_hash_traverse (&htab
->elf
, merge_global_got
, info
);
12423 /* And tlsld_got. */
12424 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12426 struct got_entry
*ent
, *ent2
;
12428 if (!is_ppc64_elf (ibfd
))
12431 ent
= ppc64_tlsld_got (ibfd
);
12432 if (!ent
->is_indirect
12433 && ent
->got
.offset
!= (bfd_vma
) -1)
12435 for (ibfd2
= ibfd
->link
.next
; ibfd2
!= NULL
; ibfd2
= ibfd2
->link
.next
)
12437 if (!is_ppc64_elf (ibfd2
))
12440 ent2
= ppc64_tlsld_got (ibfd2
);
12441 if (!ent2
->is_indirect
12442 && ent2
->got
.offset
!= (bfd_vma
) -1
12443 && elf_gp (ibfd2
) == elf_gp (ibfd
))
12445 ent2
->is_indirect
= TRUE
;
12446 ent2
->got
.ent
= ent
;
12452 /* Zap sizes of got sections. */
12453 htab
->elf
.irelplt
->rawsize
= htab
->elf
.irelplt
->size
;
12454 htab
->elf
.irelplt
->size
-= htab
->got_reli_size
;
12455 htab
->got_reli_size
= 0;
12457 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12459 asection
*got
, *relgot
;
12461 if (!is_ppc64_elf (ibfd
))
12464 got
= ppc64_elf_tdata (ibfd
)->got
;
12467 got
->rawsize
= got
->size
;
12469 relgot
= ppc64_elf_tdata (ibfd
)->relgot
;
12470 relgot
->rawsize
= relgot
->size
;
12475 /* Now reallocate the got, local syms first. We don't need to
12476 allocate section contents again since we never increase size. */
12477 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12479 struct got_entry
**lgot_ents
;
12480 struct got_entry
**end_lgot_ents
;
12481 struct plt_entry
**local_plt
;
12482 struct plt_entry
**end_local_plt
;
12483 unsigned char *lgot_masks
;
12484 bfd_size_type locsymcount
;
12485 Elf_Internal_Shdr
*symtab_hdr
;
12488 if (!is_ppc64_elf (ibfd
))
12491 lgot_ents
= elf_local_got_ents (ibfd
);
12495 symtab_hdr
= &elf_symtab_hdr (ibfd
);
12496 locsymcount
= symtab_hdr
->sh_info
;
12497 end_lgot_ents
= lgot_ents
+ locsymcount
;
12498 local_plt
= (struct plt_entry
**) end_lgot_ents
;
12499 end_local_plt
= local_plt
+ locsymcount
;
12500 lgot_masks
= (unsigned char *) end_local_plt
;
12501 s
= ppc64_elf_tdata (ibfd
)->got
;
12502 for (; lgot_ents
< end_lgot_ents
; ++lgot_ents
, ++lgot_masks
)
12504 struct got_entry
*ent
;
12506 for (ent
= *lgot_ents
; ent
!= NULL
; ent
= ent
->next
)
12508 unsigned int ent_size
= 8;
12509 unsigned int rel_size
= sizeof (Elf64_External_Rela
);
12511 ent
->got
.offset
= s
->size
;
12512 if ((ent
->tls_type
& *lgot_masks
& TLS_GD
) != 0)
12517 s
->size
+= ent_size
;
12518 if ((*lgot_masks
& (TLS_TLS
| PLT_IFUNC
)) == PLT_IFUNC
)
12520 htab
->elf
.irelplt
->size
+= rel_size
;
12521 htab
->got_reli_size
+= rel_size
;
12523 else if (bfd_link_pic (info
)
12524 && !(ent
->tls_type
!= 0
12525 && bfd_link_executable (info
)))
12527 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
12528 srel
->size
+= rel_size
;
12534 elf_link_hash_traverse (&htab
->elf
, reallocate_got
, info
);
12536 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12538 struct got_entry
*ent
;
12540 if (!is_ppc64_elf (ibfd
))
12543 ent
= ppc64_tlsld_got (ibfd
);
12544 if (!ent
->is_indirect
12545 && ent
->got
.offset
!= (bfd_vma
) -1)
12547 asection
*s
= ppc64_elf_tdata (ibfd
)->got
;
12548 ent
->got
.offset
= s
->size
;
12550 if (bfd_link_dll (info
))
12552 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
12553 srel
->size
+= sizeof (Elf64_External_Rela
);
12558 done_something
= htab
->elf
.irelplt
->rawsize
!= htab
->elf
.irelplt
->size
;
12559 if (!done_something
)
12560 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12564 if (!is_ppc64_elf (ibfd
))
12567 got
= ppc64_elf_tdata (ibfd
)->got
;
12570 done_something
= got
->rawsize
!= got
->size
;
12571 if (done_something
)
12576 if (done_something
)
12577 (*htab
->params
->layout_sections_again
) ();
12579 /* Set up for second pass over toc sections to recalculate elf_gp
12580 on input sections. */
12581 htab
->toc_bfd
= NULL
;
12582 htab
->toc_first_sec
= NULL
;
12583 htab
->second_toc_pass
= TRUE
;
12584 return done_something
;
12587 /* Called after second pass of multitoc partitioning. */
12590 ppc64_elf_finish_multitoc_partition (struct bfd_link_info
*info
)
12592 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12594 /* After the second pass, toc_curr tracks the TOC offset used
12595 for code sections below in ppc64_elf_next_input_section. */
12596 htab
->toc_curr
= TOC_BASE_OFF
;
12599 /* No toc references were found in ISEC. If the code in ISEC makes no
12600 calls, then there's no need to use toc adjusting stubs when branching
12601 into ISEC. Actually, indirect calls from ISEC are OK as they will
12602 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
12603 needed, and 2 if a cyclical call-graph was found but no other reason
12604 for a stub was detected. If called from the top level, a return of
12605 2 means the same as a return of 0. */
12608 toc_adjusting_stub_needed (struct bfd_link_info
*info
, asection
*isec
)
12612 /* Mark this section as checked. */
12613 isec
->call_check_done
= 1;
12615 /* We know none of our code bearing sections will need toc stubs. */
12616 if ((isec
->flags
& SEC_LINKER_CREATED
) != 0)
12619 if (isec
->size
== 0)
12622 if (isec
->output_section
== NULL
)
12626 if (isec
->reloc_count
!= 0)
12628 Elf_Internal_Rela
*relstart
, *rel
;
12629 Elf_Internal_Sym
*local_syms
;
12630 struct ppc_link_hash_table
*htab
;
12632 relstart
= _bfd_elf_link_read_relocs (isec
->owner
, isec
, NULL
, NULL
,
12633 info
->keep_memory
);
12634 if (relstart
== NULL
)
12637 /* Look for branches to outside of this section. */
12639 htab
= ppc_hash_table (info
);
12643 for (rel
= relstart
; rel
< relstart
+ isec
->reloc_count
; ++rel
)
12645 enum elf_ppc64_reloc_type r_type
;
12646 unsigned long r_symndx
;
12647 struct elf_link_hash_entry
*h
;
12648 struct ppc_link_hash_entry
*eh
;
12649 Elf_Internal_Sym
*sym
;
12651 struct _opd_sec_data
*opd
;
12655 r_type
= ELF64_R_TYPE (rel
->r_info
);
12656 if (r_type
!= R_PPC64_REL24
12657 && r_type
!= R_PPC64_REL24_NOTOC
12658 && r_type
!= R_PPC64_REL14
12659 && r_type
!= R_PPC64_REL14_BRTAKEN
12660 && r_type
!= R_PPC64_REL14_BRNTAKEN
12661 && r_type
!= R_PPC64_PLTCALL
12662 && r_type
!= R_PPC64_PLTCALL_NOTOC
)
12665 r_symndx
= ELF64_R_SYM (rel
->r_info
);
12666 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
, r_symndx
,
12673 /* Calls to dynamic lib functions go through a plt call stub
12675 eh
= ppc_elf_hash_entry (h
);
12677 && (eh
->elf
.plt
.plist
!= NULL
12679 && ppc_follow_link (eh
->oh
)->elf
.plt
.plist
!= NULL
)))
12685 if (sym_sec
== NULL
)
12686 /* Ignore other undefined symbols. */
12689 /* Assume branches to other sections not included in the
12690 link need stubs too, to cover -R and absolute syms. */
12691 if (sym_sec
->output_section
== NULL
)
12698 sym_value
= sym
->st_value
;
12701 if (h
->root
.type
!= bfd_link_hash_defined
12702 && h
->root
.type
!= bfd_link_hash_defweak
)
12704 sym_value
= h
->root
.u
.def
.value
;
12706 sym_value
+= rel
->r_addend
;
12708 /* If this branch reloc uses an opd sym, find the code section. */
12709 opd
= get_opd_info (sym_sec
);
12712 if (h
== NULL
&& opd
->adjust
!= NULL
)
12716 adjust
= opd
->adjust
[OPD_NDX (sym_value
)];
12718 /* Assume deleted functions won't ever be called. */
12720 sym_value
+= adjust
;
12723 dest
= opd_entry_value (sym_sec
, sym_value
,
12724 &sym_sec
, NULL
, FALSE
);
12725 if (dest
== (bfd_vma
) -1)
12730 + sym_sec
->output_offset
12731 + sym_sec
->output_section
->vma
);
12733 /* Ignore branch to self. */
12734 if (sym_sec
== isec
)
12737 /* If the called function uses the toc, we need a stub. */
12738 if (sym_sec
->has_toc_reloc
12739 || sym_sec
->makes_toc_func_call
)
12745 /* Assume any branch that needs a long branch stub might in fact
12746 need a plt_branch stub. A plt_branch stub uses r2. */
12747 else if (dest
- (isec
->output_offset
12748 + isec
->output_section
->vma
12749 + rel
->r_offset
) + (1 << 25)
12750 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
12758 /* If calling back to a section in the process of being
12759 tested, we can't say for sure that no toc adjusting stubs
12760 are needed, so don't return zero. */
12761 else if (sym_sec
->call_check_in_progress
)
12764 /* Branches to another section that itself doesn't have any TOC
12765 references are OK. Recursively call ourselves to check. */
12766 else if (!sym_sec
->call_check_done
)
12770 /* Mark current section as indeterminate, so that other
12771 sections that call back to current won't be marked as
12773 isec
->call_check_in_progress
= 1;
12774 recur
= toc_adjusting_stub_needed (info
, sym_sec
);
12775 isec
->call_check_in_progress
= 0;
12786 if (local_syms
!= NULL
12787 && (elf_symtab_hdr (isec
->owner
).contents
12788 != (unsigned char *) local_syms
))
12790 if (elf_section_data (isec
)->relocs
!= relstart
)
12795 && isec
->map_head
.s
!= NULL
12796 && (strcmp (isec
->output_section
->name
, ".init") == 0
12797 || strcmp (isec
->output_section
->name
, ".fini") == 0))
12799 if (isec
->map_head
.s
->has_toc_reloc
12800 || isec
->map_head
.s
->makes_toc_func_call
)
12802 else if (!isec
->map_head
.s
->call_check_done
)
12805 isec
->call_check_in_progress
= 1;
12806 recur
= toc_adjusting_stub_needed (info
, isec
->map_head
.s
);
12807 isec
->call_check_in_progress
= 0;
12814 isec
->makes_toc_func_call
= 1;
12819 /* The linker repeatedly calls this function for each input section,
12820 in the order that input sections are linked into output sections.
12821 Build lists of input sections to determine groupings between which
12822 we may insert linker stubs. */
12825 ppc64_elf_next_input_section (struct bfd_link_info
*info
, asection
*isec
)
12827 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12832 if ((isec
->output_section
->flags
& SEC_CODE
) != 0
12833 && isec
->output_section
->id
< htab
->sec_info_arr_size
)
12835 /* This happens to make the list in reverse order,
12836 which is what we want. */
12837 htab
->sec_info
[isec
->id
].u
.list
12838 = htab
->sec_info
[isec
->output_section
->id
].u
.list
;
12839 htab
->sec_info
[isec
->output_section
->id
].u
.list
= isec
;
12842 if (htab
->multi_toc_needed
)
12844 /* Analyse sections that aren't already flagged as needing a
12845 valid toc pointer. Exclude .fixup for the linux kernel.
12846 .fixup contains branches, but only back to the function that
12847 hit an exception. */
12848 if (!(isec
->has_toc_reloc
12849 || (isec
->flags
& SEC_CODE
) == 0
12850 || strcmp (isec
->name
, ".fixup") == 0
12851 || isec
->call_check_done
))
12853 if (toc_adjusting_stub_needed (info
, isec
) < 0)
12856 /* Make all sections use the TOC assigned for this object file.
12857 This will be wrong for pasted sections; We fix that in
12858 check_pasted_section(). */
12859 if (elf_gp (isec
->owner
) != 0)
12860 htab
->toc_curr
= elf_gp (isec
->owner
);
12863 htab
->sec_info
[isec
->id
].toc_off
= htab
->toc_curr
;
12867 /* Check that all .init and .fini sections use the same toc, if they
12868 have toc relocs. */
12871 check_pasted_section (struct bfd_link_info
*info
, const char *name
)
12873 asection
*o
= bfd_get_section_by_name (info
->output_bfd
, name
);
12877 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12878 bfd_vma toc_off
= 0;
12881 for (i
= o
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
12882 if (i
->has_toc_reloc
)
12885 toc_off
= htab
->sec_info
[i
->id
].toc_off
;
12886 else if (toc_off
!= htab
->sec_info
[i
->id
].toc_off
)
12891 for (i
= o
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
12892 if (i
->makes_toc_func_call
)
12894 toc_off
= htab
->sec_info
[i
->id
].toc_off
;
12898 /* Make sure the whole pasted function uses the same toc offset. */
12900 for (i
= o
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
12901 htab
->sec_info
[i
->id
].toc_off
= toc_off
;
12907 ppc64_elf_check_init_fini (struct bfd_link_info
*info
)
12909 return (check_pasted_section (info
, ".init")
12910 & check_pasted_section (info
, ".fini"));
12913 /* See whether we can group stub sections together. Grouping stub
12914 sections may result in fewer stubs. More importantly, we need to
12915 put all .init* and .fini* stubs at the beginning of the .init or
12916 .fini output sections respectively, because glibc splits the
12917 _init and _fini functions into multiple parts. Putting a stub in
12918 the middle of a function is not a good idea. */
12921 group_sections (struct bfd_link_info
*info
,
12922 bfd_size_type stub_group_size
,
12923 bfd_boolean stubs_always_before_branch
)
12925 struct ppc_link_hash_table
*htab
;
12927 bfd_boolean suppress_size_errors
;
12929 htab
= ppc_hash_table (info
);
12933 suppress_size_errors
= FALSE
;
12934 if (stub_group_size
== 1)
12936 /* Default values. */
12937 if (stubs_always_before_branch
)
12938 stub_group_size
= 0x1e00000;
12940 stub_group_size
= 0x1c00000;
12941 suppress_size_errors
= TRUE
;
12944 for (osec
= info
->output_bfd
->sections
; osec
!= NULL
; osec
= osec
->next
)
12948 if (osec
->id
>= htab
->sec_info_arr_size
)
12951 tail
= htab
->sec_info
[osec
->id
].u
.list
;
12952 while (tail
!= NULL
)
12956 bfd_size_type total
;
12957 bfd_boolean big_sec
;
12959 struct map_stub
*group
;
12960 bfd_size_type group_size
;
12963 total
= tail
->size
;
12964 group_size
= (ppc64_elf_section_data (tail
) != NULL
12965 && ppc64_elf_section_data (tail
)->has_14bit_branch
12966 ? stub_group_size
>> 10 : stub_group_size
);
12968 big_sec
= total
> group_size
;
12969 if (big_sec
&& !suppress_size_errors
)
12970 /* xgettext:c-format */
12971 _bfd_error_handler (_("%pB section %pA exceeds stub group size"),
12972 tail
->owner
, tail
);
12973 curr_toc
= htab
->sec_info
[tail
->id
].toc_off
;
12975 while ((prev
= htab
->sec_info
[curr
->id
].u
.list
) != NULL
12976 && ((total
+= curr
->output_offset
- prev
->output_offset
)
12977 < (ppc64_elf_section_data (prev
) != NULL
12978 && ppc64_elf_section_data (prev
)->has_14bit_branch
12979 ? (group_size
= stub_group_size
>> 10) : group_size
))
12980 && htab
->sec_info
[prev
->id
].toc_off
== curr_toc
)
12983 /* OK, the size from the start of CURR to the end is less
12984 than group_size and thus can be handled by one stub
12985 section. (or the tail section is itself larger than
12986 group_size, in which case we may be toast.) We should
12987 really be keeping track of the total size of stubs added
12988 here, as stubs contribute to the final output section
12989 size. That's a little tricky, and this way will only
12990 break if stubs added make the total size more than 2^25,
12991 ie. for the default stub_group_size, if stubs total more
12992 than 2097152 bytes, or nearly 75000 plt call stubs. */
12993 group
= bfd_alloc (curr
->owner
, sizeof (*group
));
12996 group
->link_sec
= curr
;
12997 group
->stub_sec
= NULL
;
12998 group
->needs_save_res
= 0;
12999 group
->lr_restore
= 0;
13000 group
->eh_size
= 0;
13001 group
->eh_base
= 0;
13002 group
->next
= htab
->group
;
13003 htab
->group
= group
;
13006 prev
= htab
->sec_info
[tail
->id
].u
.list
;
13007 /* Set up this stub group. */
13008 htab
->sec_info
[tail
->id
].u
.group
= group
;
13010 while (tail
!= curr
&& (tail
= prev
) != NULL
);
13012 /* But wait, there's more! Input sections up to group_size
13013 bytes before the stub section can be handled by it too.
13014 Don't do this if we have a really large section after the
13015 stubs, as adding more stubs increases the chance that
13016 branches may not reach into the stub section. */
13017 if (!stubs_always_before_branch
&& !big_sec
)
13020 while (prev
!= NULL
13021 && ((total
+= tail
->output_offset
- prev
->output_offset
)
13022 < (ppc64_elf_section_data (prev
) != NULL
13023 && ppc64_elf_section_data (prev
)->has_14bit_branch
13024 ? (group_size
= stub_group_size
>> 10)
13026 && htab
->sec_info
[prev
->id
].toc_off
== curr_toc
)
13029 prev
= htab
->sec_info
[tail
->id
].u
.list
;
13030 htab
->sec_info
[tail
->id
].u
.group
= group
;
13039 static const unsigned char glink_eh_frame_cie
[] =
13041 0, 0, 0, 16, /* length. */
13042 0, 0, 0, 0, /* id. */
13043 1, /* CIE version. */
13044 'z', 'R', 0, /* Augmentation string. */
13045 4, /* Code alignment. */
13046 0x78, /* Data alignment. */
13048 1, /* Augmentation size. */
13049 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding. */
13050 DW_CFA_def_cfa
, 1, 0 /* def_cfa: r1 offset 0. */
13053 /* Stripping output sections is normally done before dynamic section
13054 symbols have been allocated. This function is called later, and
13055 handles cases like htab->brlt which is mapped to its own output
13059 maybe_strip_output (struct bfd_link_info
*info
, asection
*isec
)
13061 if (isec
->size
== 0
13062 && isec
->output_section
->size
== 0
13063 && !(isec
->output_section
->flags
& SEC_KEEP
)
13064 && !bfd_section_removed_from_list (info
->output_bfd
,
13065 isec
->output_section
)
13066 && elf_section_data (isec
->output_section
)->dynindx
== 0)
13068 isec
->output_section
->flags
|= SEC_EXCLUDE
;
13069 bfd_section_list_remove (info
->output_bfd
, isec
->output_section
);
13070 info
->output_bfd
->section_count
--;
13074 /* Determine and set the size of the stub section for a final link.
13076 The basic idea here is to examine all the relocations looking for
13077 PC-relative calls to a target that is unreachable with a "bl"
13081 ppc64_elf_size_stubs (struct bfd_link_info
*info
)
13083 bfd_size_type stub_group_size
;
13084 bfd_boolean stubs_always_before_branch
;
13085 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
13090 if (htab
->params
->plt_thread_safe
== -1 && !bfd_link_executable (info
))
13091 htab
->params
->plt_thread_safe
= 1;
13092 if (!htab
->opd_abi
)
13093 htab
->params
->plt_thread_safe
= 0;
13094 else if (htab
->params
->plt_thread_safe
== -1)
13096 static const char *const thread_starter
[] =
13100 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
13102 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
13103 "mq_notify", "create_timer",
13108 "GOMP_parallel_start",
13109 "GOMP_parallel_loop_static",
13110 "GOMP_parallel_loop_static_start",
13111 "GOMP_parallel_loop_dynamic",
13112 "GOMP_parallel_loop_dynamic_start",
13113 "GOMP_parallel_loop_guided",
13114 "GOMP_parallel_loop_guided_start",
13115 "GOMP_parallel_loop_runtime",
13116 "GOMP_parallel_loop_runtime_start",
13117 "GOMP_parallel_sections",
13118 "GOMP_parallel_sections_start",
13124 for (i
= 0; i
< ARRAY_SIZE (thread_starter
); i
++)
13126 struct elf_link_hash_entry
*h
;
13127 h
= elf_link_hash_lookup (&htab
->elf
, thread_starter
[i
],
13128 FALSE
, FALSE
, TRUE
);
13129 htab
->params
->plt_thread_safe
= h
!= NULL
&& h
->ref_regular
;
13130 if (htab
->params
->plt_thread_safe
)
13134 stubs_always_before_branch
= htab
->params
->group_size
< 0;
13135 if (htab
->params
->group_size
< 0)
13136 stub_group_size
= -htab
->params
->group_size
;
13138 stub_group_size
= htab
->params
->group_size
;
13140 if (!group_sections (info
, stub_group_size
, stubs_always_before_branch
))
13143 htab
->tga_group
= NULL
;
13144 if (!htab
->params
->no_tls_get_addr_regsave
13145 && htab
->tga_desc_fd
!= NULL
13146 && (htab
->tga_desc_fd
->elf
.root
.type
== bfd_link_hash_undefined
13147 || htab
->tga_desc_fd
->elf
.root
.type
== bfd_link_hash_undefweak
)
13148 && htab
->tls_get_addr_fd
!= NULL
13149 && is_static_defined (&htab
->tls_get_addr_fd
->elf
))
13151 asection
*sym_sec
, *code_sec
, *stub_sec
;
13153 struct _opd_sec_data
*opd
;
13155 sym_sec
= htab
->tls_get_addr_fd
->elf
.root
.u
.def
.section
;
13156 sym_value
= defined_sym_val (&htab
->tls_get_addr_fd
->elf
);
13157 code_sec
= sym_sec
;
13158 opd
= get_opd_info (sym_sec
);
13160 opd_entry_value (sym_sec
, sym_value
, &code_sec
, NULL
, FALSE
);
13161 htab
->tga_group
= htab
->sec_info
[code_sec
->id
].u
.group
;
13162 stub_sec
= (*htab
->params
->add_stub_section
) (".tga_desc.stub",
13163 htab
->tga_group
->link_sec
);
13164 if (stub_sec
== NULL
)
13166 htab
->tga_group
->stub_sec
= stub_sec
;
13168 htab
->tga_desc_fd
->elf
.root
.type
= bfd_link_hash_defined
;
13169 htab
->tga_desc_fd
->elf
.root
.u
.def
.section
= stub_sec
;
13170 htab
->tga_desc_fd
->elf
.root
.u
.def
.value
= 0;
13171 htab
->tga_desc_fd
->elf
.type
= STT_FUNC
;
13172 htab
->tga_desc_fd
->elf
.def_regular
= 1;
13173 htab
->tga_desc_fd
->elf
.non_elf
= 0;
13174 _bfd_elf_link_hash_hide_symbol (info
, &htab
->tga_desc_fd
->elf
, TRUE
);
13177 #define STUB_SHRINK_ITER 20
13178 /* Loop until no stubs added. After iteration 20 of this loop we may
13179 exit on a stub section shrinking. This is to break out of a
13180 pathological case where adding stubs on one iteration decreases
13181 section gaps (perhaps due to alignment), which then requires
13182 fewer or smaller stubs on the next iteration. */
13187 unsigned int bfd_indx
;
13188 struct map_stub
*group
;
13190 htab
->stub_iteration
+= 1;
13192 for (input_bfd
= info
->input_bfds
, bfd_indx
= 0;
13194 input_bfd
= input_bfd
->link
.next
, bfd_indx
++)
13196 Elf_Internal_Shdr
*symtab_hdr
;
13198 Elf_Internal_Sym
*local_syms
= NULL
;
13200 if (!is_ppc64_elf (input_bfd
))
13203 /* We'll need the symbol table in a second. */
13204 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
13205 if (symtab_hdr
->sh_info
== 0)
13208 /* Walk over each section attached to the input bfd. */
13209 for (section
= input_bfd
->sections
;
13211 section
= section
->next
)
13213 Elf_Internal_Rela
*internal_relocs
, *irelaend
, *irela
;
13215 /* If there aren't any relocs, then there's nothing more
13217 if ((section
->flags
& SEC_RELOC
) == 0
13218 || (section
->flags
& SEC_ALLOC
) == 0
13219 || (section
->flags
& SEC_LOAD
) == 0
13220 || (section
->flags
& SEC_CODE
) == 0
13221 || section
->reloc_count
== 0)
13224 /* If this section is a link-once section that will be
13225 discarded, then don't create any stubs. */
13226 if (section
->output_section
== NULL
13227 || section
->output_section
->owner
!= info
->output_bfd
)
13230 /* Get the relocs. */
13232 = _bfd_elf_link_read_relocs (input_bfd
, section
, NULL
, NULL
,
13233 info
->keep_memory
);
13234 if (internal_relocs
== NULL
)
13235 goto error_ret_free_local
;
13237 /* Now examine each relocation. */
13238 irela
= internal_relocs
;
13239 irelaend
= irela
+ section
->reloc_count
;
13240 for (; irela
< irelaend
; irela
++)
13242 enum elf_ppc64_reloc_type r_type
;
13243 unsigned int r_indx
;
13244 enum ppc_stub_type stub_type
;
13245 struct ppc_stub_hash_entry
*stub_entry
;
13246 asection
*sym_sec
, *code_sec
;
13247 bfd_vma sym_value
, code_value
;
13248 bfd_vma destination
;
13249 unsigned long local_off
;
13250 bfd_boolean ok_dest
;
13251 struct ppc_link_hash_entry
*hash
;
13252 struct ppc_link_hash_entry
*fdh
;
13253 struct elf_link_hash_entry
*h
;
13254 Elf_Internal_Sym
*sym
;
13256 const asection
*id_sec
;
13257 struct _opd_sec_data
*opd
;
13258 struct plt_entry
*plt_ent
;
13260 r_type
= ELF64_R_TYPE (irela
->r_info
);
13261 r_indx
= ELF64_R_SYM (irela
->r_info
);
13263 if (r_type
>= R_PPC64_max
)
13265 bfd_set_error (bfd_error_bad_value
);
13266 goto error_ret_free_internal
;
13269 /* Only look for stubs on branch instructions. */
13270 if (r_type
!= R_PPC64_REL24
13271 && r_type
!= R_PPC64_REL24_NOTOC
13272 && r_type
!= R_PPC64_REL14
13273 && r_type
!= R_PPC64_REL14_BRTAKEN
13274 && r_type
!= R_PPC64_REL14_BRNTAKEN
)
13277 /* Now determine the call target, its name, value,
13279 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
13280 r_indx
, input_bfd
))
13281 goto error_ret_free_internal
;
13282 hash
= ppc_elf_hash_entry (h
);
13289 sym_value
= sym
->st_value
;
13290 if (sym_sec
!= NULL
13291 && sym_sec
->output_section
!= NULL
)
13294 else if (hash
->elf
.root
.type
== bfd_link_hash_defined
13295 || hash
->elf
.root
.type
== bfd_link_hash_defweak
)
13297 sym_value
= hash
->elf
.root
.u
.def
.value
;
13298 if (sym_sec
->output_section
!= NULL
)
13301 else if (hash
->elf
.root
.type
== bfd_link_hash_undefweak
13302 || hash
->elf
.root
.type
== bfd_link_hash_undefined
)
13304 /* Recognise an old ABI func code entry sym, and
13305 use the func descriptor sym instead if it is
13307 if (hash
->elf
.root
.root
.string
[0] == '.'
13308 && hash
->oh
!= NULL
)
13310 fdh
= ppc_follow_link (hash
->oh
);
13311 if (fdh
->elf
.root
.type
== bfd_link_hash_defined
13312 || fdh
->elf
.root
.type
== bfd_link_hash_defweak
)
13314 sym_sec
= fdh
->elf
.root
.u
.def
.section
;
13315 sym_value
= fdh
->elf
.root
.u
.def
.value
;
13316 if (sym_sec
->output_section
!= NULL
)
13325 bfd_set_error (bfd_error_bad_value
);
13326 goto error_ret_free_internal
;
13333 sym_value
+= irela
->r_addend
;
13334 destination
= (sym_value
13335 + sym_sec
->output_offset
13336 + sym_sec
->output_section
->vma
);
13337 local_off
= PPC64_LOCAL_ENTRY_OFFSET (hash
13342 code_sec
= sym_sec
;
13343 code_value
= sym_value
;
13344 opd
= get_opd_info (sym_sec
);
13349 if (hash
== NULL
&& opd
->adjust
!= NULL
)
13351 long adjust
= opd
->adjust
[OPD_NDX (sym_value
)];
13354 code_value
+= adjust
;
13355 sym_value
+= adjust
;
13357 dest
= opd_entry_value (sym_sec
, sym_value
,
13358 &code_sec
, &code_value
, FALSE
);
13359 if (dest
!= (bfd_vma
) -1)
13361 destination
= dest
;
13364 /* Fixup old ABI sym to point at code
13366 hash
->elf
.root
.type
= bfd_link_hash_defweak
;
13367 hash
->elf
.root
.u
.def
.section
= code_sec
;
13368 hash
->elf
.root
.u
.def
.value
= code_value
;
13373 /* Determine what (if any) linker stub is needed. */
13375 stub_type
= ppc_type_of_stub (section
, irela
, &hash
,
13376 &plt_ent
, destination
,
13379 if (r_type
== R_PPC64_REL24_NOTOC
)
13381 if (stub_type
== ppc_stub_plt_call
)
13382 stub_type
= ppc_stub_plt_call_notoc
;
13383 else if (stub_type
== ppc_stub_long_branch
13384 || (code_sec
!= NULL
13385 && code_sec
->output_section
!= NULL
13386 && (((hash
? hash
->elf
.other
: sym
->st_other
)
13387 & STO_PPC64_LOCAL_MASK
)
13388 > 1 << STO_PPC64_LOCAL_BIT
)))
13389 stub_type
= ppc_stub_long_branch_notoc
;
13391 else if (stub_type
!= ppc_stub_plt_call
)
13393 /* Check whether we need a TOC adjusting stub.
13394 Since the linker pastes together pieces from
13395 different object files when creating the
13396 _init and _fini functions, it may be that a
13397 call to what looks like a local sym is in
13398 fact a call needing a TOC adjustment. */
13399 if ((code_sec
!= NULL
13400 && code_sec
->output_section
!= NULL
13401 && (htab
->sec_info
[code_sec
->id
].toc_off
13402 != htab
->sec_info
[section
->id
].toc_off
)
13403 && (code_sec
->has_toc_reloc
13404 || code_sec
->makes_toc_func_call
))
13405 || (((hash
? hash
->elf
.other
: sym
->st_other
)
13406 & STO_PPC64_LOCAL_MASK
)
13407 == 1 << STO_PPC64_LOCAL_BIT
))
13408 stub_type
= ppc_stub_long_branch_r2off
;
13411 if (stub_type
== ppc_stub_none
)
13414 /* __tls_get_addr calls might be eliminated. */
13415 if (stub_type
!= ppc_stub_plt_call
13416 && stub_type
!= ppc_stub_plt_call_notoc
13418 && is_tls_get_addr (&hash
->elf
, htab
)
13419 && section
->has_tls_reloc
13420 && irela
!= internal_relocs
)
13422 /* Get tls info. */
13423 unsigned char *tls_mask
;
13425 if (!get_tls_mask (&tls_mask
, NULL
, NULL
, &local_syms
,
13426 irela
- 1, input_bfd
))
13427 goto error_ret_free_internal
;
13428 if ((*tls_mask
& TLS_TLS
) != 0
13429 && (*tls_mask
& (TLS_GD
| TLS_LD
)) == 0)
13433 if (stub_type
== ppc_stub_plt_call
)
13436 && htab
->params
->plt_localentry0
!= 0
13437 && is_elfv2_localentry0 (&hash
->elf
))
13438 htab
->has_plt_localentry0
= 1;
13439 else if (irela
+ 1 < irelaend
13440 && irela
[1].r_offset
== irela
->r_offset
+ 4
13441 && (ELF64_R_TYPE (irela
[1].r_info
)
13442 == R_PPC64_TOCSAVE
))
13444 if (!tocsave_find (htab
, INSERT
,
13445 &local_syms
, irela
+ 1, input_bfd
))
13446 goto error_ret_free_internal
;
13449 stub_type
= ppc_stub_plt_call_r2save
;
13452 /* Support for grouping stub sections. */
13453 id_sec
= htab
->sec_info
[section
->id
].u
.group
->link_sec
;
13455 /* Get the name of this stub. */
13456 stub_name
= ppc_stub_name (id_sec
, sym_sec
, hash
, irela
);
13458 goto error_ret_free_internal
;
13460 stub_entry
= ppc_stub_hash_lookup (&htab
->stub_hash_table
,
13461 stub_name
, FALSE
, FALSE
);
13462 if (stub_entry
!= NULL
)
13464 enum ppc_stub_type old_type
;
13465 /* A stub has already been created, but it may
13466 not be the required type. We shouldn't be
13467 transitioning from plt_call to long_branch
13468 stubs or vice versa, but we might be
13469 upgrading from plt_call to plt_call_r2save or
13470 from long_branch to long_branch_r2off. */
13472 old_type
= stub_entry
->stub_type
;
13478 case ppc_stub_save_res
:
13481 case ppc_stub_plt_call
:
13482 case ppc_stub_plt_call_r2save
:
13483 case ppc_stub_plt_call_notoc
:
13484 case ppc_stub_plt_call_both
:
13485 if (stub_type
== ppc_stub_plt_call
)
13487 else if (stub_type
== ppc_stub_plt_call_r2save
)
13489 if (old_type
== ppc_stub_plt_call_notoc
)
13490 stub_type
= ppc_stub_plt_call_both
;
13492 else if (stub_type
== ppc_stub_plt_call_notoc
)
13494 if (old_type
== ppc_stub_plt_call_r2save
)
13495 stub_type
= ppc_stub_plt_call_both
;
13501 case ppc_stub_plt_branch
:
13502 case ppc_stub_plt_branch_r2off
:
13503 case ppc_stub_plt_branch_notoc
:
13504 case ppc_stub_plt_branch_both
:
13505 old_type
+= (ppc_stub_long_branch
13506 - ppc_stub_plt_branch
);
13507 /* Fall through. */
13508 case ppc_stub_long_branch
:
13509 case ppc_stub_long_branch_r2off
:
13510 case ppc_stub_long_branch_notoc
:
13511 case ppc_stub_long_branch_both
:
13512 if (stub_type
== ppc_stub_long_branch
)
13514 else if (stub_type
== ppc_stub_long_branch_r2off
)
13516 if (old_type
== ppc_stub_long_branch_notoc
)
13517 stub_type
= ppc_stub_long_branch_both
;
13519 else if (stub_type
== ppc_stub_long_branch_notoc
)
13521 if (old_type
== ppc_stub_long_branch_r2off
)
13522 stub_type
= ppc_stub_long_branch_both
;
13528 if (old_type
< stub_type
)
13529 stub_entry
->stub_type
= stub_type
;
13533 stub_entry
= ppc_add_stub (stub_name
, section
, info
);
13534 if (stub_entry
== NULL
)
13537 error_ret_free_internal
:
13538 if (elf_section_data (section
)->relocs
== NULL
)
13539 free (internal_relocs
);
13540 error_ret_free_local
:
13541 if (local_syms
!= NULL
13542 && (symtab_hdr
->contents
13543 != (unsigned char *) local_syms
))
13548 stub_entry
->stub_type
= stub_type
;
13549 if (stub_type
>= ppc_stub_plt_call
13550 && stub_type
<= ppc_stub_plt_call_both
)
13552 stub_entry
->target_value
= sym_value
;
13553 stub_entry
->target_section
= sym_sec
;
13557 stub_entry
->target_value
= code_value
;
13558 stub_entry
->target_section
= code_sec
;
13560 stub_entry
->h
= hash
;
13561 stub_entry
->plt_ent
= plt_ent
;
13562 stub_entry
->symtype
13563 = hash
? hash
->elf
.type
: ELF_ST_TYPE (sym
->st_info
);
13564 stub_entry
->other
= hash
? hash
->elf
.other
: sym
->st_other
;
13567 && (hash
->elf
.root
.type
== bfd_link_hash_defined
13568 || hash
->elf
.root
.type
== bfd_link_hash_defweak
))
13569 htab
->stub_globals
+= 1;
13572 /* We're done with the internal relocs, free them. */
13573 if (elf_section_data (section
)->relocs
!= internal_relocs
)
13574 free (internal_relocs
);
13577 if (local_syms
!= NULL
13578 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
13580 if (!info
->keep_memory
)
13583 symtab_hdr
->contents
= (unsigned char *) local_syms
;
13587 /* We may have added some stubs. Find out the new size of the
13589 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13591 group
->lr_restore
= 0;
13592 group
->eh_size
= 0;
13593 if (group
->stub_sec
!= NULL
)
13595 asection
*stub_sec
= group
->stub_sec
;
13597 if (htab
->stub_iteration
<= STUB_SHRINK_ITER
13598 || stub_sec
->rawsize
< stub_sec
->size
)
13599 /* Past STUB_SHRINK_ITER, rawsize is the max size seen. */
13600 stub_sec
->rawsize
= stub_sec
->size
;
13601 stub_sec
->size
= 0;
13602 stub_sec
->reloc_count
= 0;
13603 stub_sec
->flags
&= ~SEC_RELOC
;
13606 if (htab
->tga_group
!= NULL
)
13608 /* See emit_tga_desc and emit_tga_desc_eh_frame. */
13609 htab
->tga_group
->eh_size
13610 = 1 + 2 + (htab
->opd_abi
!= 0) + 3 + 8 * 2 + 3 + 8 + 3;
13611 htab
->tga_group
->lr_restore
= 23 * 4;
13612 htab
->tga_group
->stub_sec
->size
= 24 * 4;
13615 if (htab
->stub_iteration
<= STUB_SHRINK_ITER
13616 || htab
->brlt
->rawsize
< htab
->brlt
->size
)
13617 htab
->brlt
->rawsize
= htab
->brlt
->size
;
13618 htab
->brlt
->size
= 0;
13619 htab
->brlt
->reloc_count
= 0;
13620 htab
->brlt
->flags
&= ~SEC_RELOC
;
13621 if (htab
->relbrlt
!= NULL
)
13622 htab
->relbrlt
->size
= 0;
13624 bfd_hash_traverse (&htab
->stub_hash_table
, ppc_size_one_stub
, info
);
13626 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13627 if (group
->needs_save_res
)
13628 group
->stub_sec
->size
+= htab
->sfpr
->size
;
13630 if (info
->emitrelocations
13631 && htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
13633 htab
->glink
->reloc_count
= 1;
13634 htab
->glink
->flags
|= SEC_RELOC
;
13637 if (htab
->glink_eh_frame
!= NULL
13638 && !bfd_is_abs_section (htab
->glink_eh_frame
->output_section
)
13639 && htab
->glink_eh_frame
->output_section
->size
> 8)
13641 size_t size
= 0, align
= 4;
13643 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13644 if (group
->eh_size
!= 0)
13645 size
+= (group
->eh_size
+ 17 + align
- 1) & -align
;
13646 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
13647 size
+= (24 + align
- 1) & -align
;
13649 size
+= (sizeof (glink_eh_frame_cie
) + align
- 1) & -align
;
13650 align
= 1ul << htab
->glink_eh_frame
->output_section
->alignment_power
;
13651 size
= (size
+ align
- 1) & -align
;
13652 htab
->glink_eh_frame
->rawsize
= htab
->glink_eh_frame
->size
;
13653 htab
->glink_eh_frame
->size
= size
;
13656 if (htab
->params
->plt_stub_align
!= 0)
13657 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13658 if (group
->stub_sec
!= NULL
)
13660 int align
= abs (htab
->params
->plt_stub_align
);
13661 group
->stub_sec
->size
13662 = (group
->stub_sec
->size
+ (1 << align
) - 1) & -(1 << align
);
13665 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13666 if (group
->stub_sec
!= NULL
13667 && group
->stub_sec
->rawsize
!= group
->stub_sec
->size
13668 && (htab
->stub_iteration
<= STUB_SHRINK_ITER
13669 || group
->stub_sec
->rawsize
< group
->stub_sec
->size
))
13673 && (htab
->brlt
->rawsize
== htab
->brlt
->size
13674 || (htab
->stub_iteration
> STUB_SHRINK_ITER
13675 && htab
->brlt
->rawsize
> htab
->brlt
->size
))
13676 && (htab
->glink_eh_frame
== NULL
13677 || htab
->glink_eh_frame
->rawsize
== htab
->glink_eh_frame
->size
)
13678 && (htab
->tga_group
== NULL
13679 || htab
->stub_iteration
> 1))
13682 /* Ask the linker to do its stuff. */
13683 (*htab
->params
->layout_sections_again
) ();
13686 if (htab
->glink_eh_frame
!= NULL
13687 && htab
->glink_eh_frame
->size
!= 0)
13690 bfd_byte
*p
, *last_fde
;
13691 size_t last_fde_len
, size
, align
, pad
;
13692 struct map_stub
*group
;
13694 /* It is necessary to at least have a rough outline of the
13695 linker generated CIEs and FDEs written before
13696 bfd_elf_discard_info is run, in order for these FDEs to be
13697 indexed in .eh_frame_hdr. */
13698 p
= bfd_zalloc (htab
->glink_eh_frame
->owner
, htab
->glink_eh_frame
->size
);
13701 htab
->glink_eh_frame
->contents
= p
;
13705 memcpy (p
, glink_eh_frame_cie
, sizeof (glink_eh_frame_cie
));
13706 /* CIE length (rewrite in case little-endian). */
13707 last_fde_len
= ((sizeof (glink_eh_frame_cie
) + align
- 1) & -align
) - 4;
13708 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
, p
);
13709 p
+= last_fde_len
+ 4;
13711 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13712 if (group
->eh_size
!= 0)
13714 group
->eh_base
= p
- htab
->glink_eh_frame
->contents
;
13716 last_fde_len
= ((group
->eh_size
+ 17 + align
- 1) & -align
) - 4;
13718 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
, p
);
13721 val
= p
- htab
->glink_eh_frame
->contents
;
13722 bfd_put_32 (htab
->elf
.dynobj
, val
, p
);
13724 /* Offset to stub section, written later. */
13726 /* stub section size. */
13727 bfd_put_32 (htab
->elf
.dynobj
, group
->stub_sec
->size
, p
);
13729 /* Augmentation. */
13731 /* Make sure we don't have all nops. This is enough for
13732 elf-eh-frame.c to detect the last non-nop opcode. */
13733 p
[group
->eh_size
- 1] = DW_CFA_advance_loc
+ 1;
13734 p
= last_fde
+ last_fde_len
+ 4;
13736 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
13739 last_fde_len
= ((24 + align
- 1) & -align
) - 4;
13741 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
, p
);
13744 val
= p
- htab
->glink_eh_frame
->contents
;
13745 bfd_put_32 (htab
->elf
.dynobj
, val
, p
);
13747 /* Offset to .glink, written later. */
13750 bfd_put_32 (htab
->elf
.dynobj
, htab
->glink
->size
- 8, p
);
13752 /* Augmentation. */
13755 *p
++ = DW_CFA_advance_loc
+ 1;
13756 *p
++ = DW_CFA_register
;
13758 *p
++ = htab
->opd_abi
? 12 : 0;
13759 *p
++ = DW_CFA_advance_loc
+ (htab
->opd_abi
? 5 : 7);
13760 *p
++ = DW_CFA_restore_extended
;
13762 p
+= ((24 + align
- 1) & -align
) - 24;
13764 /* Subsume any padding into the last FDE if user .eh_frame
13765 sections are aligned more than glink_eh_frame. Otherwise any
13766 zero padding will be seen as a terminator. */
13767 align
= 1ul << htab
->glink_eh_frame
->output_section
->alignment_power
;
13768 size
= p
- htab
->glink_eh_frame
->contents
;
13769 pad
= ((size
+ align
- 1) & -align
) - size
;
13770 htab
->glink_eh_frame
->size
= size
+ pad
;
13771 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
+ pad
, last_fde
);
13774 maybe_strip_output (info
, htab
->brlt
);
13775 if (htab
->glink_eh_frame
!= NULL
)
13776 maybe_strip_output (info
, htab
->glink_eh_frame
);
13781 /* Called after we have determined section placement. If sections
13782 move, we'll be called again. Provide a value for TOCstart. */
13785 ppc64_elf_set_toc (struct bfd_link_info
*info
, bfd
*obfd
)
13788 bfd_vma TOCstart
, adjust
;
13792 struct elf_link_hash_entry
*h
;
13793 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
13795 if (is_elf_hash_table (htab
)
13796 && htab
->hgot
!= NULL
)
13800 h
= elf_link_hash_lookup (htab
, ".TOC.", FALSE
, FALSE
, TRUE
);
13801 if (is_elf_hash_table (htab
))
13805 && h
->root
.type
== bfd_link_hash_defined
13806 && !h
->root
.linker_def
13807 && (!is_elf_hash_table (htab
)
13808 || h
->def_regular
))
13810 TOCstart
= defined_sym_val (h
) - TOC_BASE_OFF
;
13811 _bfd_set_gp_value (obfd
, TOCstart
);
13816 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
13817 order. The TOC starts where the first of these sections starts. */
13818 s
= bfd_get_section_by_name (obfd
, ".got");
13819 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13820 s
= bfd_get_section_by_name (obfd
, ".toc");
13821 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13822 s
= bfd_get_section_by_name (obfd
, ".tocbss");
13823 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13824 s
= bfd_get_section_by_name (obfd
, ".plt");
13825 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13827 /* This may happen for
13828 o references to TOC base (SYM@toc / TOC[tc0]) without a
13830 o bad linker script
13831 o --gc-sections and empty TOC sections
13833 FIXME: Warn user? */
13835 /* Look for a likely section. We probably won't even be
13837 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13838 if ((s
->flags
& (SEC_ALLOC
| SEC_SMALL_DATA
| SEC_READONLY
13840 == (SEC_ALLOC
| SEC_SMALL_DATA
))
13843 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13844 if ((s
->flags
& (SEC_ALLOC
| SEC_SMALL_DATA
| SEC_EXCLUDE
))
13845 == (SEC_ALLOC
| SEC_SMALL_DATA
))
13848 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13849 if ((s
->flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_EXCLUDE
))
13853 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13854 if ((s
->flags
& (SEC_ALLOC
| SEC_EXCLUDE
)) == SEC_ALLOC
)
13860 TOCstart
= s
->output_section
->vma
+ s
->output_offset
;
13862 /* Force alignment. */
13863 adjust
= TOCstart
& (TOC_BASE_ALIGN
- 1);
13864 TOCstart
-= adjust
;
13865 _bfd_set_gp_value (obfd
, TOCstart
);
13867 if (info
!= NULL
&& s
!= NULL
)
13869 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
13873 if (htab
->elf
.hgot
!= NULL
)
13875 htab
->elf
.hgot
->root
.u
.def
.value
= TOC_BASE_OFF
- adjust
;
13876 htab
->elf
.hgot
->root
.u
.def
.section
= s
;
13881 struct bfd_link_hash_entry
*bh
= NULL
;
13882 _bfd_generic_link_add_one_symbol (info
, obfd
, ".TOC.", BSF_GLOBAL
,
13883 s
, TOC_BASE_OFF
- adjust
,
13884 NULL
, FALSE
, FALSE
, &bh
);
13890 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
13891 write out any global entry stubs, and PLT relocations. */
13894 build_global_entry_stubs_and_plt (struct elf_link_hash_entry
*h
, void *inf
)
13896 struct bfd_link_info
*info
;
13897 struct ppc_link_hash_table
*htab
;
13898 struct plt_entry
*ent
;
13901 if (h
->root
.type
== bfd_link_hash_indirect
)
13905 htab
= ppc_hash_table (info
);
13909 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
13910 if (ent
->plt
.offset
!= (bfd_vma
) -1)
13912 /* This symbol has an entry in the procedure linkage
13913 table. Set it up. */
13914 Elf_Internal_Rela rela
;
13915 asection
*plt
, *relplt
;
13918 if (!htab
->elf
.dynamic_sections_created
13919 || h
->dynindx
== -1)
13921 if (!(h
->def_regular
13922 && (h
->root
.type
== bfd_link_hash_defined
13923 || h
->root
.type
== bfd_link_hash_defweak
)))
13925 if (h
->type
== STT_GNU_IFUNC
)
13927 plt
= htab
->elf
.iplt
;
13928 relplt
= htab
->elf
.irelplt
;
13929 htab
->local_ifunc_resolver
= 1;
13931 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_IREL
);
13933 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
13937 plt
= htab
->pltlocal
;
13938 if (bfd_link_pic (info
))
13940 relplt
= htab
->relpltlocal
;
13942 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_SLOT
);
13944 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
13949 rela
.r_addend
= defined_sym_val (h
) + ent
->addend
;
13951 if (relplt
== NULL
)
13953 loc
= plt
->contents
+ ent
->plt
.offset
;
13954 bfd_put_64 (info
->output_bfd
, rela
.r_addend
, loc
);
13957 bfd_vma toc
= elf_gp (info
->output_bfd
);
13958 toc
+= htab
->sec_info
[h
->root
.u
.def
.section
->id
].toc_off
;
13959 bfd_put_64 (info
->output_bfd
, toc
, loc
+ 8);
13964 rela
.r_offset
= (plt
->output_section
->vma
13965 + plt
->output_offset
13966 + ent
->plt
.offset
);
13967 loc
= relplt
->contents
+ (relplt
->reloc_count
++
13968 * sizeof (Elf64_External_Rela
));
13969 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rela
, loc
);
13974 rela
.r_offset
= (htab
->elf
.splt
->output_section
->vma
13975 + htab
->elf
.splt
->output_offset
13976 + ent
->plt
.offset
);
13977 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_PPC64_JMP_SLOT
);
13978 rela
.r_addend
= ent
->addend
;
13979 loc
= (htab
->elf
.srelplt
->contents
13980 + ((ent
->plt
.offset
- PLT_INITIAL_ENTRY_SIZE (htab
))
13981 / PLT_ENTRY_SIZE (htab
) * sizeof (Elf64_External_Rela
)));
13982 if (h
->type
== STT_GNU_IFUNC
&& is_static_defined (h
))
13983 htab
->maybe_local_ifunc_resolver
= 1;
13984 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rela
, loc
);
13988 if (!h
->pointer_equality_needed
)
13991 if (h
->def_regular
)
13994 s
= htab
->global_entry
;
13995 if (s
== NULL
|| s
->size
== 0)
13998 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
13999 if (ent
->plt
.offset
!= (bfd_vma
) -1
14000 && ent
->addend
== 0)
14006 p
= s
->contents
+ h
->root
.u
.def
.value
;
14007 plt
= htab
->elf
.splt
;
14008 if (!htab
->elf
.dynamic_sections_created
14009 || h
->dynindx
== -1)
14011 if (h
->type
== STT_GNU_IFUNC
)
14012 plt
= htab
->elf
.iplt
;
14014 plt
= htab
->pltlocal
;
14016 off
= ent
->plt
.offset
+ plt
->output_offset
+ plt
->output_section
->vma
;
14017 off
-= h
->root
.u
.def
.value
+ s
->output_offset
+ s
->output_section
->vma
;
14019 if (off
+ 0x80008000 > 0xffffffff || (off
& 3) != 0)
14021 info
->callbacks
->einfo
14022 (_("%P: linkage table error against `%pT'\n"),
14023 h
->root
.root
.string
);
14024 bfd_set_error (bfd_error_bad_value
);
14025 htab
->stub_error
= TRUE
;
14028 htab
->stub_count
[ppc_stub_global_entry
- 1] += 1;
14029 if (htab
->params
->emit_stub_syms
)
14031 size_t len
= strlen (h
->root
.root
.string
);
14032 char *name
= bfd_malloc (sizeof "12345678.global_entry." + len
);
14037 sprintf (name
, "%08x.global_entry.%s", s
->id
, h
->root
.root
.string
);
14038 h
= elf_link_hash_lookup (&htab
->elf
, name
, TRUE
, FALSE
, FALSE
);
14041 if (h
->root
.type
== bfd_link_hash_new
)
14043 h
->root
.type
= bfd_link_hash_defined
;
14044 h
->root
.u
.def
.section
= s
;
14045 h
->root
.u
.def
.value
= p
- s
->contents
;
14046 h
->ref_regular
= 1;
14047 h
->def_regular
= 1;
14048 h
->ref_regular_nonweak
= 1;
14049 h
->forced_local
= 1;
14051 h
->root
.linker_def
= 1;
14055 if (PPC_HA (off
) != 0)
14057 bfd_put_32 (s
->owner
, ADDIS_R12_R12
| PPC_HA (off
), p
);
14060 bfd_put_32 (s
->owner
, LD_R12_0R12
| PPC_LO (off
), p
);
14062 bfd_put_32 (s
->owner
, MTCTR_R12
, p
);
14064 bfd_put_32 (s
->owner
, BCTR
, p
);
14070 /* Write PLT relocs for locals. */
14073 write_plt_relocs_for_local_syms (struct bfd_link_info
*info
)
14075 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
14078 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
14080 struct got_entry
**lgot_ents
, **end_lgot_ents
;
14081 struct plt_entry
**local_plt
, **lplt
, **end_local_plt
;
14082 Elf_Internal_Shdr
*symtab_hdr
;
14083 bfd_size_type locsymcount
;
14084 Elf_Internal_Sym
*local_syms
= NULL
;
14085 struct plt_entry
*ent
;
14087 if (!is_ppc64_elf (ibfd
))
14090 lgot_ents
= elf_local_got_ents (ibfd
);
14094 symtab_hdr
= &elf_symtab_hdr (ibfd
);
14095 locsymcount
= symtab_hdr
->sh_info
;
14096 end_lgot_ents
= lgot_ents
+ locsymcount
;
14097 local_plt
= (struct plt_entry
**) end_lgot_ents
;
14098 end_local_plt
= local_plt
+ locsymcount
;
14099 for (lplt
= local_plt
; lplt
< end_local_plt
; ++lplt
)
14100 for (ent
= *lplt
; ent
!= NULL
; ent
= ent
->next
)
14101 if (ent
->plt
.offset
!= (bfd_vma
) -1)
14103 Elf_Internal_Sym
*sym
;
14105 asection
*plt
, *relplt
;
14109 if (!get_sym_h (NULL
, &sym
, &sym_sec
, NULL
, &local_syms
,
14110 lplt
- local_plt
, ibfd
))
14112 if (local_syms
!= NULL
14113 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
14118 val
= sym
->st_value
+ ent
->addend
;
14119 if (ELF_ST_TYPE (sym
->st_info
) != STT_GNU_IFUNC
)
14120 val
+= PPC64_LOCAL_ENTRY_OFFSET (sym
->st_other
);
14121 if (sym_sec
!= NULL
&& sym_sec
->output_section
!= NULL
)
14122 val
+= sym_sec
->output_offset
+ sym_sec
->output_section
->vma
;
14124 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
14126 htab
->local_ifunc_resolver
= 1;
14127 plt
= htab
->elf
.iplt
;
14128 relplt
= htab
->elf
.irelplt
;
14132 plt
= htab
->pltlocal
;
14133 relplt
= bfd_link_pic (info
) ? htab
->relpltlocal
: NULL
;
14136 if (relplt
== NULL
)
14138 loc
= plt
->contents
+ ent
->plt
.offset
;
14139 bfd_put_64 (info
->output_bfd
, val
, loc
);
14142 bfd_vma toc
= elf_gp (ibfd
);
14143 bfd_put_64 (info
->output_bfd
, toc
, loc
+ 8);
14148 Elf_Internal_Rela rela
;
14149 rela
.r_offset
= (ent
->plt
.offset
14150 + plt
->output_offset
14151 + plt
->output_section
->vma
);
14152 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
14155 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_IREL
);
14157 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
14162 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_SLOT
);
14164 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
14166 rela
.r_addend
= val
;
14167 loc
= relplt
->contents
+ (relplt
->reloc_count
++
14168 * sizeof (Elf64_External_Rela
));
14169 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rela
, loc
);
14173 if (local_syms
!= NULL
14174 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
14176 if (!info
->keep_memory
)
14179 symtab_hdr
->contents
= (unsigned char *) local_syms
;
14185 /* Emit the static wrapper function preserving registers around a
14186 __tls_get_addr_opt call. */
14189 emit_tga_desc (struct ppc_link_hash_table
*htab
)
14191 asection
*stub_sec
= htab
->tga_group
->stub_sec
;
14192 unsigned int cfa_updt
= 11 * 4;
14194 bfd_vma to
, from
, delta
;
14196 BFD_ASSERT (htab
->tga_desc_fd
->elf
.root
.type
== bfd_link_hash_defined
14197 && htab
->tga_desc_fd
->elf
.root
.u
.def
.section
== stub_sec
14198 && htab
->tga_desc_fd
->elf
.root
.u
.def
.value
== 0);
14199 to
= defined_sym_val (&htab
->tls_get_addr_fd
->elf
);
14200 from
= defined_sym_val (&htab
->tga_desc_fd
->elf
) + cfa_updt
;
14202 if (delta
+ (1 << 25) >= 1 << 26)
14204 _bfd_error_handler (_("__tls_get_addr call offset overflow"));
14205 htab
->stub_error
= TRUE
;
14209 p
= stub_sec
->contents
;
14210 p
= tls_get_addr_prologue (htab
->elf
.dynobj
, p
, htab
);
14211 bfd_put_32 (stub_sec
->owner
, B_DOT
| 1 | (delta
& 0x3fffffc), p
);
14213 p
= tls_get_addr_epilogue (htab
->elf
.dynobj
, p
, htab
);
14214 return stub_sec
->size
== (bfd_size_type
) (p
- stub_sec
->contents
);
14217 /* Emit eh_frame describing the static wrapper function. */
14220 emit_tga_desc_eh_frame (struct ppc_link_hash_table
*htab
, bfd_byte
*p
)
14222 unsigned int cfa_updt
= 11 * 4;
14225 *p
++ = DW_CFA_advance_loc
+ cfa_updt
/ 4;
14226 *p
++ = DW_CFA_def_cfa_offset
;
14234 *p
++ = DW_CFA_offset_extended_sf
;
14236 *p
++ = (-16 / 8) & 0x7f;
14237 for (i
= 4; i
< 12; i
++)
14239 *p
++ = DW_CFA_offset
+ i
;
14240 *p
++ = (htab
->opd_abi
? 13 : 12) - i
;
14242 *p
++ = DW_CFA_advance_loc
+ 10;
14243 *p
++ = DW_CFA_def_cfa_offset
;
14245 for (i
= 4; i
< 12; i
++)
14246 *p
++ = DW_CFA_restore
+ i
;
14247 *p
++ = DW_CFA_advance_loc
+ 2;
14248 *p
++ = DW_CFA_restore_extended
;
14253 /* Build all the stubs associated with the current output file.
14254 The stubs are kept in a hash table attached to the main linker
14255 hash table. This function is called via gldelf64ppc_finish. */
14258 ppc64_elf_build_stubs (struct bfd_link_info
*info
,
14261 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
14262 struct map_stub
*group
;
14263 asection
*stub_sec
;
14265 int stub_sec_count
= 0;
14270 /* Allocate memory to hold the linker stubs. */
14271 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14273 group
->eh_size
= 0;
14274 group
->lr_restore
= 0;
14275 if ((stub_sec
= group
->stub_sec
) != NULL
14276 && stub_sec
->size
!= 0)
14278 stub_sec
->contents
= bfd_zalloc (htab
->params
->stub_bfd
,
14280 if (stub_sec
->contents
== NULL
)
14282 stub_sec
->size
= 0;
14286 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
14291 /* Build the .glink plt call stub. */
14292 if (htab
->params
->emit_stub_syms
)
14294 struct elf_link_hash_entry
*h
;
14295 h
= elf_link_hash_lookup (&htab
->elf
, "__glink_PLTresolve",
14296 TRUE
, FALSE
, FALSE
);
14299 if (h
->root
.type
== bfd_link_hash_new
)
14301 h
->root
.type
= bfd_link_hash_defined
;
14302 h
->root
.u
.def
.section
= htab
->glink
;
14303 h
->root
.u
.def
.value
= 8;
14304 h
->ref_regular
= 1;
14305 h
->def_regular
= 1;
14306 h
->ref_regular_nonweak
= 1;
14307 h
->forced_local
= 1;
14309 h
->root
.linker_def
= 1;
14312 plt0
= (htab
->elf
.splt
->output_section
->vma
14313 + htab
->elf
.splt
->output_offset
14315 if (info
->emitrelocations
)
14317 Elf_Internal_Rela
*r
= get_relocs (htab
->glink
, 1);
14320 r
->r_offset
= (htab
->glink
->output_offset
14321 + htab
->glink
->output_section
->vma
);
14322 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL64
);
14323 r
->r_addend
= plt0
;
14325 p
= htab
->glink
->contents
;
14326 plt0
-= htab
->glink
->output_section
->vma
+ htab
->glink
->output_offset
;
14327 bfd_put_64 (htab
->glink
->owner
, plt0
, p
);
14331 bfd_put_32 (htab
->glink
->owner
, MFLR_R12
, p
);
14333 bfd_put_32 (htab
->glink
->owner
, BCL_20_31
, p
);
14335 bfd_put_32 (htab
->glink
->owner
, MFLR_R11
, p
);
14337 bfd_put_32 (htab
->glink
->owner
, LD_R2_0R11
| (-16 & 0xfffc), p
);
14339 bfd_put_32 (htab
->glink
->owner
, MTLR_R12
, p
);
14341 bfd_put_32 (htab
->glink
->owner
, ADD_R11_R2_R11
, p
);
14343 bfd_put_32 (htab
->glink
->owner
, LD_R12_0R11
, p
);
14345 bfd_put_32 (htab
->glink
->owner
, LD_R2_0R11
| 8, p
);
14347 bfd_put_32 (htab
->glink
->owner
, MTCTR_R12
, p
);
14349 bfd_put_32 (htab
->glink
->owner
, LD_R11_0R11
| 16, p
);
14354 bfd_put_32 (htab
->glink
->owner
, MFLR_R0
, p
);
14356 bfd_put_32 (htab
->glink
->owner
, BCL_20_31
, p
);
14358 bfd_put_32 (htab
->glink
->owner
, MFLR_R11
, p
);
14360 bfd_put_32 (htab
->glink
->owner
, STD_R2_0R1
+ 24, p
);
14362 bfd_put_32 (htab
->glink
->owner
, LD_R2_0R11
| (-16 & 0xfffc), p
);
14364 bfd_put_32 (htab
->glink
->owner
, MTLR_R0
, p
);
14366 bfd_put_32 (htab
->glink
->owner
, SUB_R12_R12_R11
, p
);
14368 bfd_put_32 (htab
->glink
->owner
, ADD_R11_R2_R11
, p
);
14370 bfd_put_32 (htab
->glink
->owner
, ADDI_R0_R12
| (-48 & 0xffff), p
);
14372 bfd_put_32 (htab
->glink
->owner
, LD_R12_0R11
, p
);
14374 bfd_put_32 (htab
->glink
->owner
, SRDI_R0_R0_2
, p
);
14376 bfd_put_32 (htab
->glink
->owner
, MTCTR_R12
, p
);
14378 bfd_put_32 (htab
->glink
->owner
, LD_R11_0R11
| 8, p
);
14381 bfd_put_32 (htab
->glink
->owner
, BCTR
, p
);
14383 BFD_ASSERT (p
== htab
->glink
->contents
+ GLINK_PLTRESOLVE_SIZE (htab
));
14385 /* Build the .glink lazy link call stubs. */
14387 while (p
< htab
->glink
->contents
+ htab
->glink
->size
)
14393 bfd_put_32 (htab
->glink
->owner
, LI_R0_0
| indx
, p
);
14398 bfd_put_32 (htab
->glink
->owner
, LIS_R0_0
| PPC_HI (indx
), p
);
14400 bfd_put_32 (htab
->glink
->owner
, ORI_R0_R0_0
| PPC_LO (indx
),
14405 bfd_put_32 (htab
->glink
->owner
,
14406 B_DOT
| ((htab
->glink
->contents
- p
+ 8) & 0x3fffffc), p
);
14412 if (htab
->tga_group
!= NULL
)
14414 htab
->tga_group
->lr_restore
= 23 * 4;
14415 htab
->tga_group
->stub_sec
->size
= 24 * 4;
14416 if (!emit_tga_desc (htab
))
14418 if (htab
->glink_eh_frame
!= NULL
14419 && htab
->glink_eh_frame
->size
!= 0)
14423 p
= htab
->glink_eh_frame
->contents
;
14424 p
+= (sizeof (glink_eh_frame_cie
) + align
- 1) & -align
;
14426 htab
->tga_group
->eh_size
= emit_tga_desc_eh_frame (htab
, p
) - p
;
14430 /* Build .glink global entry stubs, and PLT relocs for globals. */
14431 elf_link_hash_traverse (&htab
->elf
, build_global_entry_stubs_and_plt
, info
);
14433 if (!write_plt_relocs_for_local_syms (info
))
14436 if (htab
->brlt
!= NULL
&& htab
->brlt
->size
!= 0)
14438 htab
->brlt
->contents
= bfd_zalloc (htab
->brlt
->owner
,
14440 if (htab
->brlt
->contents
== NULL
)
14443 if (htab
->relbrlt
!= NULL
&& htab
->relbrlt
->size
!= 0)
14445 htab
->relbrlt
->contents
= bfd_zalloc (htab
->relbrlt
->owner
,
14446 htab
->relbrlt
->size
);
14447 if (htab
->relbrlt
->contents
== NULL
)
14451 /* Build the stubs as directed by the stub hash table. */
14452 bfd_hash_traverse (&htab
->stub_hash_table
, ppc_build_one_stub
, info
);
14454 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14455 if (group
->needs_save_res
)
14456 group
->stub_sec
->size
+= htab
->sfpr
->size
;
14458 if (htab
->relbrlt
!= NULL
)
14459 htab
->relbrlt
->reloc_count
= 0;
14461 if (htab
->params
->plt_stub_align
!= 0)
14462 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14463 if ((stub_sec
= group
->stub_sec
) != NULL
)
14465 int align
= abs (htab
->params
->plt_stub_align
);
14466 stub_sec
->size
= (stub_sec
->size
+ (1 << align
) - 1) & -(1 << align
);
14469 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14470 if (group
->needs_save_res
)
14472 stub_sec
= group
->stub_sec
;
14473 memcpy (stub_sec
->contents
+ stub_sec
->size
- htab
->sfpr
->size
,
14474 htab
->sfpr
->contents
, htab
->sfpr
->size
);
14475 if (htab
->params
->emit_stub_syms
)
14479 for (i
= 0; i
< ARRAY_SIZE (save_res_funcs
); i
++)
14480 if (!sfpr_define (info
, &save_res_funcs
[i
], stub_sec
))
14485 if (htab
->glink_eh_frame
!= NULL
14486 && htab
->glink_eh_frame
->size
!= 0)
14491 p
= htab
->glink_eh_frame
->contents
;
14492 p
+= (sizeof (glink_eh_frame_cie
) + align
- 1) & -align
;
14494 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14495 if (group
->eh_size
!= 0)
14497 /* Offset to stub section. */
14498 val
= (group
->stub_sec
->output_section
->vma
14499 + group
->stub_sec
->output_offset
);
14500 val
-= (htab
->glink_eh_frame
->output_section
->vma
14501 + htab
->glink_eh_frame
->output_offset
14502 + (p
+ 8 - htab
->glink_eh_frame
->contents
));
14503 if (val
+ 0x80000000 > 0xffffffff)
14506 (_("%s offset too large for .eh_frame sdata4 encoding"),
14507 group
->stub_sec
->name
);
14510 bfd_put_32 (htab
->elf
.dynobj
, val
, p
+ 8);
14511 p
+= (group
->eh_size
+ 17 + 3) & -4;
14513 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
14515 /* Offset to .glink. */
14516 val
= (htab
->glink
->output_section
->vma
14517 + htab
->glink
->output_offset
14519 val
-= (htab
->glink_eh_frame
->output_section
->vma
14520 + htab
->glink_eh_frame
->output_offset
14521 + (p
+ 8 - htab
->glink_eh_frame
->contents
));
14522 if (val
+ 0x80000000 > 0xffffffff)
14525 (_("%s offset too large for .eh_frame sdata4 encoding"),
14526 htab
->glink
->name
);
14529 bfd_put_32 (htab
->elf
.dynobj
, val
, p
+ 8);
14530 p
+= (24 + align
- 1) & -align
;
14534 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14535 if ((stub_sec
= group
->stub_sec
) != NULL
)
14537 stub_sec_count
+= 1;
14538 if (stub_sec
->rawsize
!= stub_sec
->size
14539 && (htab
->stub_iteration
<= STUB_SHRINK_ITER
14540 || stub_sec
->rawsize
< stub_sec
->size
))
14546 htab
->stub_error
= TRUE
;
14547 _bfd_error_handler (_("stubs don't match calculated size"));
14550 if (htab
->stub_error
)
14556 if (asprintf (&groupmsg
,
14557 ngettext ("linker stubs in %u group\n",
14558 "linker stubs in %u groups\n",
14560 stub_sec_count
) < 0)
14564 if (asprintf (stats
, _("%s"
14566 " branch toc adj %lu\n"
14567 " branch notoc %lu\n"
14568 " branch both %lu\n"
14569 " long branch %lu\n"
14570 " long toc adj %lu\n"
14571 " long notoc %lu\n"
14574 " plt call save %lu\n"
14575 " plt call notoc %lu\n"
14576 " plt call both %lu\n"
14577 " global entry %lu"),
14579 htab
->stub_count
[ppc_stub_long_branch
- 1],
14580 htab
->stub_count
[ppc_stub_long_branch_r2off
- 1],
14581 htab
->stub_count
[ppc_stub_long_branch_notoc
- 1],
14582 htab
->stub_count
[ppc_stub_long_branch_both
- 1],
14583 htab
->stub_count
[ppc_stub_plt_branch
- 1],
14584 htab
->stub_count
[ppc_stub_plt_branch_r2off
- 1],
14585 htab
->stub_count
[ppc_stub_plt_branch_notoc
- 1],
14586 htab
->stub_count
[ppc_stub_plt_branch_both
- 1],
14587 htab
->stub_count
[ppc_stub_plt_call
- 1],
14588 htab
->stub_count
[ppc_stub_plt_call_r2save
- 1],
14589 htab
->stub_count
[ppc_stub_plt_call_notoc
- 1],
14590 htab
->stub_count
[ppc_stub_plt_call_both
- 1],
14591 htab
->stub_count
[ppc_stub_global_entry
- 1]) < 0)
14599 /* What to do when ld finds relocations against symbols defined in
14600 discarded sections. */
14602 static unsigned int
14603 ppc64_elf_action_discarded (asection
*sec
)
14605 if (strcmp (".opd", sec
->name
) == 0)
14608 if (strcmp (".toc", sec
->name
) == 0)
14611 if (strcmp (".toc1", sec
->name
) == 0)
14614 return _bfd_elf_default_action_discarded (sec
);
14617 /* These are the dynamic relocations supported by glibc. */
14620 ppc64_glibc_dynamic_reloc (enum elf_ppc64_reloc_type r_type
)
14624 case R_PPC64_RELATIVE
:
14626 case R_PPC64_ADDR64
:
14627 case R_PPC64_GLOB_DAT
:
14628 case R_PPC64_IRELATIVE
:
14629 case R_PPC64_JMP_IREL
:
14630 case R_PPC64_JMP_SLOT
:
14631 case R_PPC64_DTPMOD64
:
14632 case R_PPC64_DTPREL64
:
14633 case R_PPC64_TPREL64
:
14634 case R_PPC64_TPREL16_LO_DS
:
14635 case R_PPC64_TPREL16_DS
:
14636 case R_PPC64_TPREL16
:
14637 case R_PPC64_TPREL16_LO
:
14638 case R_PPC64_TPREL16_HI
:
14639 case R_PPC64_TPREL16_HIGH
:
14640 case R_PPC64_TPREL16_HA
:
14641 case R_PPC64_TPREL16_HIGHA
:
14642 case R_PPC64_TPREL16_HIGHER
:
14643 case R_PPC64_TPREL16_HIGHEST
:
14644 case R_PPC64_TPREL16_HIGHERA
:
14645 case R_PPC64_TPREL16_HIGHESTA
:
14646 case R_PPC64_ADDR16_LO_DS
:
14647 case R_PPC64_ADDR16_LO
:
14648 case R_PPC64_ADDR16_HI
:
14649 case R_PPC64_ADDR16_HIGH
:
14650 case R_PPC64_ADDR16_HA
:
14651 case R_PPC64_ADDR16_HIGHA
:
14652 case R_PPC64_REL30
:
14654 case R_PPC64_UADDR64
:
14655 case R_PPC64_UADDR32
:
14656 case R_PPC64_ADDR32
:
14657 case R_PPC64_ADDR24
:
14658 case R_PPC64_ADDR16
:
14659 case R_PPC64_UADDR16
:
14660 case R_PPC64_ADDR16_DS
:
14661 case R_PPC64_ADDR16_HIGHER
:
14662 case R_PPC64_ADDR16_HIGHEST
:
14663 case R_PPC64_ADDR16_HIGHERA
:
14664 case R_PPC64_ADDR16_HIGHESTA
:
14665 case R_PPC64_ADDR14
:
14666 case R_PPC64_ADDR14_BRTAKEN
:
14667 case R_PPC64_ADDR14_BRNTAKEN
:
14668 case R_PPC64_REL32
:
14669 case R_PPC64_REL64
:
14677 /* The RELOCATE_SECTION function is called by the ELF backend linker
14678 to handle the relocations for a section.
14680 The relocs are always passed as Rela structures; if the section
14681 actually uses Rel structures, the r_addend field will always be
14684 This function is responsible for adjust the section contents as
14685 necessary, and (if using Rela relocs and generating a
14686 relocatable output file) adjusting the reloc addend as
14689 This function does not have to worry about setting the reloc
14690 address or the reloc symbol index.
14692 LOCAL_SYMS is a pointer to the swapped in local symbols.
14694 LOCAL_SECTIONS is an array giving the section in the input file
14695 corresponding to the st_shndx field of each local symbol.
14697 The global hash table entry for the global symbols can be found
14698 via elf_sym_hashes (input_bfd).
14700 When generating relocatable output, this function must handle
14701 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
14702 going to be the section symbol corresponding to the output
14703 section, which means that the addend must be adjusted
14707 ppc64_elf_relocate_section (bfd
*output_bfd
,
14708 struct bfd_link_info
*info
,
14710 asection
*input_section
,
14711 bfd_byte
*contents
,
14712 Elf_Internal_Rela
*relocs
,
14713 Elf_Internal_Sym
*local_syms
,
14714 asection
**local_sections
)
14716 struct ppc_link_hash_table
*htab
;
14717 Elf_Internal_Shdr
*symtab_hdr
;
14718 struct elf_link_hash_entry
**sym_hashes
;
14719 Elf_Internal_Rela
*rel
;
14720 Elf_Internal_Rela
*wrel
;
14721 Elf_Internal_Rela
*relend
;
14722 Elf_Internal_Rela outrel
;
14724 struct got_entry
**local_got_ents
;
14726 bfd_boolean ret
= TRUE
;
14727 bfd_boolean is_opd
;
14728 /* Assume 'at' branch hints. */
14729 bfd_boolean is_isa_v2
= TRUE
;
14730 bfd_boolean warned_dynamic
= FALSE
;
14731 bfd_vma d_offset
= (bfd_big_endian (input_bfd
) ? 2 : 0);
14733 /* Initialize howto table if needed. */
14734 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
14737 htab
= ppc_hash_table (info
);
14741 /* Don't relocate stub sections. */
14742 if (input_section
->owner
== htab
->params
->stub_bfd
)
14745 if (!is_ppc64_elf (input_bfd
))
14747 bfd_set_error (bfd_error_wrong_format
);
14751 local_got_ents
= elf_local_got_ents (input_bfd
);
14752 TOCstart
= elf_gp (output_bfd
);
14753 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
14754 sym_hashes
= elf_sym_hashes (input_bfd
);
14755 is_opd
= ppc64_elf_section_data (input_section
)->sec_type
== sec_opd
;
14757 rel
= wrel
= relocs
;
14758 relend
= relocs
+ input_section
->reloc_count
;
14759 for (; rel
< relend
; wrel
++, rel
++)
14761 enum elf_ppc64_reloc_type r_type
;
14763 bfd_reloc_status_type r
;
14764 Elf_Internal_Sym
*sym
;
14766 struct elf_link_hash_entry
*h_elf
;
14767 struct ppc_link_hash_entry
*h
;
14768 struct ppc_link_hash_entry
*fdh
;
14769 const char *sym_name
;
14770 unsigned long r_symndx
, toc_symndx
;
14771 bfd_vma toc_addend
;
14772 unsigned char tls_mask
, tls_gd
, tls_type
;
14773 unsigned char sym_type
;
14774 bfd_vma relocation
;
14775 bfd_boolean unresolved_reloc
, save_unresolved_reloc
;
14776 bfd_boolean warned
;
14777 enum { DEST_NORMAL
, DEST_OPD
, DEST_STUB
} reloc_dest
;
14780 struct ppc_stub_hash_entry
*stub_entry
;
14781 bfd_vma max_br_offset
;
14783 Elf_Internal_Rela orig_rel
;
14784 reloc_howto_type
*howto
;
14785 struct reloc_howto_struct alt_howto
;
14792 r_type
= ELF64_R_TYPE (rel
->r_info
);
14793 r_symndx
= ELF64_R_SYM (rel
->r_info
);
14795 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
14796 symbol of the previous ADDR64 reloc. The symbol gives us the
14797 proper TOC base to use. */
14798 if (rel
->r_info
== ELF64_R_INFO (0, R_PPC64_TOC
)
14800 && ELF64_R_TYPE (wrel
[-1].r_info
) == R_PPC64_ADDR64
14802 r_symndx
= ELF64_R_SYM (wrel
[-1].r_info
);
14808 unresolved_reloc
= FALSE
;
14811 if (r_symndx
< symtab_hdr
->sh_info
)
14813 /* It's a local symbol. */
14814 struct _opd_sec_data
*opd
;
14816 sym
= local_syms
+ r_symndx
;
14817 sec
= local_sections
[r_symndx
];
14818 sym_name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
, sec
);
14819 sym_type
= ELF64_ST_TYPE (sym
->st_info
);
14820 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
14821 opd
= get_opd_info (sec
);
14822 if (opd
!= NULL
&& opd
->adjust
!= NULL
)
14824 long adjust
= opd
->adjust
[OPD_NDX (sym
->st_value
14830 /* If this is a relocation against the opd section sym
14831 and we have edited .opd, adjust the reloc addend so
14832 that ld -r and ld --emit-relocs output is correct.
14833 If it is a reloc against some other .opd symbol,
14834 then the symbol value will be adjusted later. */
14835 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
14836 rel
->r_addend
+= adjust
;
14838 relocation
+= adjust
;
14844 bfd_boolean ignored
;
14846 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
14847 r_symndx
, symtab_hdr
, sym_hashes
,
14848 h_elf
, sec
, relocation
,
14849 unresolved_reloc
, warned
, ignored
);
14850 sym_name
= h_elf
->root
.root
.string
;
14851 sym_type
= h_elf
->type
;
14853 && sec
->owner
== output_bfd
14854 && strcmp (sec
->name
, ".opd") == 0)
14856 /* This is a symbol defined in a linker script. All
14857 such are defined in output sections, even those
14858 defined by simple assignment from a symbol defined in
14859 an input section. Transfer the symbol to an
14860 appropriate input .opd section, so that a branch to
14861 this symbol will be mapped to the location specified
14862 by the opd entry. */
14863 struct bfd_link_order
*lo
;
14864 for (lo
= sec
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
14865 if (lo
->type
== bfd_indirect_link_order
)
14867 asection
*isec
= lo
->u
.indirect
.section
;
14868 if (h_elf
->root
.u
.def
.value
>= isec
->output_offset
14869 && h_elf
->root
.u
.def
.value
< (isec
->output_offset
14872 h_elf
->root
.u
.def
.value
-= isec
->output_offset
;
14873 h_elf
->root
.u
.def
.section
= isec
;
14880 h
= ppc_elf_hash_entry (h_elf
);
14882 if (sec
!= NULL
&& discarded_section (sec
))
14884 _bfd_clear_contents (ppc64_elf_howto_table
[r_type
],
14885 input_bfd
, input_section
,
14886 contents
, rel
->r_offset
);
14887 wrel
->r_offset
= rel
->r_offset
;
14889 wrel
->r_addend
= 0;
14891 /* For ld -r, remove relocations in debug sections against
14892 symbols defined in discarded sections. Not done for
14893 non-debug to preserve relocs in .eh_frame which the
14894 eh_frame editing code expects to be present. */
14895 if (bfd_link_relocatable (info
)
14896 && (input_section
->flags
& SEC_DEBUGGING
))
14902 if (bfd_link_relocatable (info
))
14905 if (h
!= NULL
&& &h
->elf
== htab
->elf
.hgot
)
14907 relocation
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
14908 sec
= bfd_abs_section_ptr
;
14909 unresolved_reloc
= FALSE
;
14912 /* TLS optimizations. Replace instruction sequences and relocs
14913 based on information we collected in tls_optimize. We edit
14914 RELOCS so that --emit-relocs will output something sensible
14915 for the final instruction stream. */
14920 tls_mask
= h
->tls_mask
;
14921 else if (local_got_ents
!= NULL
)
14923 struct plt_entry
**local_plt
= (struct plt_entry
**)
14924 (local_got_ents
+ symtab_hdr
->sh_info
);
14925 unsigned char *lgot_masks
= (unsigned char *)
14926 (local_plt
+ symtab_hdr
->sh_info
);
14927 tls_mask
= lgot_masks
[r_symndx
];
14929 if (((tls_mask
& TLS_TLS
) == 0 || tls_mask
== (TLS_TLS
| TLS_MARK
))
14930 && (r_type
== R_PPC64_TLS
14931 || r_type
== R_PPC64_TLSGD
14932 || r_type
== R_PPC64_TLSLD
))
14934 /* Check for toc tls entries. */
14935 unsigned char *toc_tls
;
14937 if (!get_tls_mask (&toc_tls
, &toc_symndx
, &toc_addend
,
14938 &local_syms
, rel
, input_bfd
))
14942 tls_mask
= *toc_tls
;
14945 /* Check that tls relocs are used with tls syms, and non-tls
14946 relocs are used with non-tls syms. */
14947 if (r_symndx
!= STN_UNDEF
14948 && r_type
!= R_PPC64_NONE
14950 || h
->elf
.root
.type
== bfd_link_hash_defined
14951 || h
->elf
.root
.type
== bfd_link_hash_defweak
)
14952 && IS_PPC64_TLS_RELOC (r_type
) != (sym_type
== STT_TLS
))
14954 if ((tls_mask
& TLS_TLS
) != 0
14955 && (r_type
== R_PPC64_TLS
14956 || r_type
== R_PPC64_TLSGD
14957 || r_type
== R_PPC64_TLSLD
))
14958 /* R_PPC64_TLS is OK against a symbol in the TOC. */
14961 info
->callbacks
->einfo
14962 (!IS_PPC64_TLS_RELOC (r_type
)
14963 /* xgettext:c-format */
14964 ? _("%H: %s used with TLS symbol `%pT'\n")
14965 /* xgettext:c-format */
14966 : _("%H: %s used with non-TLS symbol `%pT'\n"),
14967 input_bfd
, input_section
, rel
->r_offset
,
14968 ppc64_elf_howto_table
[r_type
]->name
,
14972 /* Ensure reloc mapping code below stays sane. */
14973 if (R_PPC64_TOC16_LO_DS
!= R_PPC64_TOC16_DS
+ 1
14974 || R_PPC64_TOC16_LO
!= R_PPC64_TOC16
+ 1
14975 || (R_PPC64_GOT_TLSLD16
& 3) != (R_PPC64_GOT_TLSGD16
& 3)
14976 || (R_PPC64_GOT_TLSLD16_LO
& 3) != (R_PPC64_GOT_TLSGD16_LO
& 3)
14977 || (R_PPC64_GOT_TLSLD16_HI
& 3) != (R_PPC64_GOT_TLSGD16_HI
& 3)
14978 || (R_PPC64_GOT_TLSLD16_HA
& 3) != (R_PPC64_GOT_TLSGD16_HA
& 3)
14979 || (R_PPC64_GOT_TLSLD16
& 3) != (R_PPC64_GOT_TPREL16_DS
& 3)
14980 || (R_PPC64_GOT_TLSLD16_LO
& 3) != (R_PPC64_GOT_TPREL16_LO_DS
& 3)
14981 || (R_PPC64_GOT_TLSLD16_HI
& 3) != (R_PPC64_GOT_TPREL16_HI
& 3)
14982 || (R_PPC64_GOT_TLSLD16_HA
& 3) != (R_PPC64_GOT_TPREL16_HA
& 3))
14990 case R_PPC64_LO_DS_OPT
:
14991 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
- d_offset
);
14992 if ((insn
& (0x3fu
<< 26)) != 58u << 26)
14994 insn
+= (14u << 26) - (58u << 26);
14995 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
- d_offset
);
14996 r_type
= R_PPC64_TOC16_LO
;
14997 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15000 case R_PPC64_TOC16
:
15001 case R_PPC64_TOC16_LO
:
15002 case R_PPC64_TOC16_DS
:
15003 case R_PPC64_TOC16_LO_DS
:
15005 /* Check for toc tls entries. */
15006 unsigned char *toc_tls
;
15009 retval
= get_tls_mask (&toc_tls
, &toc_symndx
, &toc_addend
,
15010 &local_syms
, rel
, input_bfd
);
15016 tls_mask
= *toc_tls
;
15017 if (r_type
== R_PPC64_TOC16_DS
15018 || r_type
== R_PPC64_TOC16_LO_DS
)
15020 if ((tls_mask
& TLS_TLS
) != 0
15021 && (tls_mask
& (TLS_DTPREL
| TLS_TPREL
)) == 0)
15026 /* If we found a GD reloc pair, then we might be
15027 doing a GD->IE transition. */
15031 if ((tls_mask
& TLS_TLS
) != 0
15032 && (tls_mask
& TLS_GD
) == 0)
15035 else if (retval
== 3)
15037 if ((tls_mask
& TLS_TLS
) != 0
15038 && (tls_mask
& TLS_LD
) == 0)
15046 case R_PPC64_GOT_TPREL16_HI
:
15047 case R_PPC64_GOT_TPREL16_HA
:
15048 if ((tls_mask
& TLS_TLS
) != 0
15049 && (tls_mask
& TLS_TPREL
) == 0)
15051 rel
->r_offset
-= d_offset
;
15052 bfd_put_32 (input_bfd
, NOP
, contents
+ rel
->r_offset
);
15053 r_type
= R_PPC64_NONE
;
15054 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15058 case R_PPC64_GOT_TPREL16_DS
:
15059 case R_PPC64_GOT_TPREL16_LO_DS
:
15060 if ((tls_mask
& TLS_TLS
) != 0
15061 && (tls_mask
& TLS_TPREL
) == 0)
15064 insn
= bfd_get_32 (input_bfd
,
15065 contents
+ rel
->r_offset
- d_offset
);
15067 insn
|= 0x3c0d0000; /* addis 0,13,0 */
15068 bfd_put_32 (input_bfd
, insn
,
15069 contents
+ rel
->r_offset
- d_offset
);
15070 r_type
= R_PPC64_TPREL16_HA
;
15071 if (toc_symndx
!= 0)
15073 rel
->r_info
= ELF64_R_INFO (toc_symndx
, r_type
);
15074 rel
->r_addend
= toc_addend
;
15075 /* We changed the symbol. Start over in order to
15076 get h, sym, sec etc. right. */
15080 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15084 case R_PPC64_GOT_TPREL34
:
15085 if ((tls_mask
& TLS_TLS
) != 0
15086 && (tls_mask
& TLS_TPREL
) == 0)
15088 /* pld ra,sym@got@tprel@pcrel -> paddi ra,r13,sym@tprel */
15089 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15091 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15092 pinsn
+= ((2ULL << 56) + (-1ULL << 52)
15093 + (14ULL << 26) - (57ULL << 26) + (13ULL << 16));
15094 bfd_put_32 (input_bfd
, pinsn
>> 32,
15095 contents
+ rel
->r_offset
);
15096 bfd_put_32 (input_bfd
, pinsn
& 0xffffffff,
15097 contents
+ rel
->r_offset
+ 4);
15098 r_type
= R_PPC64_TPREL34
;
15099 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15104 if ((tls_mask
& TLS_TLS
) != 0
15105 && (tls_mask
& TLS_TPREL
) == 0)
15107 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
15108 insn
= _bfd_elf_ppc_at_tls_transform (insn
, 13);
15111 if ((rel
->r_offset
& 3) == 0)
15113 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
15114 /* Was PPC64_TLS which sits on insn boundary, now
15115 PPC64_TPREL16_LO which is at low-order half-word. */
15116 rel
->r_offset
+= d_offset
;
15117 r_type
= R_PPC64_TPREL16_LO
;
15118 if (toc_symndx
!= 0)
15120 rel
->r_info
= ELF64_R_INFO (toc_symndx
, r_type
);
15121 rel
->r_addend
= toc_addend
;
15122 /* We changed the symbol. Start over in order to
15123 get h, sym, sec etc. right. */
15127 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15129 else if ((rel
->r_offset
& 3) == 1)
15131 /* For pcrel IE to LE we already have the full
15132 offset and thus don't need an addi here. A nop
15134 if ((insn
& (0x3fu
<< 26)) == 14 << 26)
15136 /* Extract regs from addi rt,ra,si. */
15137 unsigned int rt
= (insn
>> 21) & 0x1f;
15138 unsigned int ra
= (insn
>> 16) & 0x1f;
15143 /* Build or ra,rs,rb with rb==rs, ie. mr ra,rs. */
15144 insn
= (rt
<< 16) | (ra
<< 21) | (ra
<< 11);
15145 insn
|= (31u << 26) | (444u << 1);
15148 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
- 1);
15153 case R_PPC64_GOT_TLSGD16_HI
:
15154 case R_PPC64_GOT_TLSGD16_HA
:
15156 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0)
15160 case R_PPC64_GOT_TLSLD16_HI
:
15161 case R_PPC64_GOT_TLSLD16_HA
:
15162 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0)
15165 if ((tls_mask
& tls_gd
) != 0)
15166 r_type
= (((r_type
- (R_PPC64_GOT_TLSGD16
& 3)) & 3)
15167 + R_PPC64_GOT_TPREL16_DS
);
15170 rel
->r_offset
-= d_offset
;
15171 bfd_put_32 (input_bfd
, NOP
, contents
+ rel
->r_offset
);
15172 r_type
= R_PPC64_NONE
;
15174 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15178 case R_PPC64_GOT_TLSGD16
:
15179 case R_PPC64_GOT_TLSGD16_LO
:
15181 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0)
15185 case R_PPC64_GOT_TLSLD16
:
15186 case R_PPC64_GOT_TLSLD16_LO
:
15187 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0)
15189 unsigned int insn1
, insn2
;
15192 offset
= (bfd_vma
) -1;
15193 /* If not using the newer R_PPC64_TLSGD/LD to mark
15194 __tls_get_addr calls, we must trust that the call
15195 stays with its arg setup insns, ie. that the next
15196 reloc is the __tls_get_addr call associated with
15197 the current reloc. Edit both insns. */
15198 if (input_section
->nomark_tls_get_addr
15199 && rel
+ 1 < relend
15200 && branch_reloc_hash_match (input_bfd
, rel
+ 1,
15201 htab
->tls_get_addr_fd
,
15203 htab
->tls_get_addr
,
15205 offset
= rel
[1].r_offset
;
15206 /* We read the low GOT_TLS (or TOC16) insn because we
15207 need to keep the destination reg. It may be
15208 something other than the usual r3, and moved to r3
15209 before the call by intervening code. */
15210 insn1
= bfd_get_32 (input_bfd
,
15211 contents
+ rel
->r_offset
- d_offset
);
15212 if ((tls_mask
& tls_gd
) != 0)
15215 insn1
&= (0x1f << 21) | (0x1f << 16);
15216 insn1
|= 58u << 26; /* ld */
15217 insn2
= 0x7c636a14; /* add 3,3,13 */
15218 if (offset
!= (bfd_vma
) -1)
15219 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
15220 if (r_type
== R_PPC64_TOC16
15221 || r_type
== R_PPC64_TOC16_LO
)
15222 r_type
+= R_PPC64_TOC16_DS
- R_PPC64_TOC16
;
15224 r_type
= (((r_type
- (R_PPC64_GOT_TLSGD16
& 1)) & 1)
15225 + R_PPC64_GOT_TPREL16_DS
);
15226 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15231 insn1
&= 0x1f << 21;
15232 insn1
|= 0x3c0d0000; /* addis r,13,0 */
15233 insn2
= 0x38630000; /* addi 3,3,0 */
15236 /* Was an LD reloc. */
15237 r_symndx
= STN_UNDEF
;
15238 rel
->r_addend
= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
15240 else if (toc_symndx
!= 0)
15242 r_symndx
= toc_symndx
;
15243 rel
->r_addend
= toc_addend
;
15245 r_type
= R_PPC64_TPREL16_HA
;
15246 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15247 if (offset
!= (bfd_vma
) -1)
15249 rel
[1].r_info
= ELF64_R_INFO (r_symndx
,
15250 R_PPC64_TPREL16_LO
);
15251 rel
[1].r_offset
= offset
+ d_offset
;
15252 rel
[1].r_addend
= rel
->r_addend
;
15255 bfd_put_32 (input_bfd
, insn1
,
15256 contents
+ rel
->r_offset
- d_offset
);
15257 if (offset
!= (bfd_vma
) -1)
15259 bfd_put_32 (input_bfd
, insn2
, contents
+ offset
);
15260 if (offset
+ 8 <= input_section
->size
)
15262 insn2
= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
15263 if (insn2
== LD_R2_0R1
+ STK_TOC (htab
))
15264 bfd_put_32 (input_bfd
, NOP
, contents
+ offset
+ 4);
15267 if ((tls_mask
& tls_gd
) == 0
15268 && (tls_gd
== 0 || toc_symndx
!= 0))
15270 /* We changed the symbol. Start over in order
15271 to get h, sym, sec etc. right. */
15277 case R_PPC64_GOT_TLSGD34
:
15278 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0)
15280 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15282 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15283 if ((tls_mask
& TLS_GDIE
) != 0)
15285 /* IE, pla -> pld */
15286 pinsn
+= (-2ULL << 56) + (57ULL << 26) - (14ULL << 26);
15287 r_type
= R_PPC64_GOT_TPREL34
;
15291 /* LE, pla pcrel -> paddi r13 */
15292 pinsn
+= (-1ULL << 52) + (13ULL << 16);
15293 r_type
= R_PPC64_TPREL34
;
15295 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15296 bfd_put_32 (input_bfd
, pinsn
>> 32,
15297 contents
+ rel
->r_offset
);
15298 bfd_put_32 (input_bfd
, pinsn
& 0xffffffff,
15299 contents
+ rel
->r_offset
+ 4);
15303 case R_PPC64_GOT_TLSLD34
:
15304 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0)
15306 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15308 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15309 pinsn
+= (-1ULL << 52) + (13ULL << 16);
15310 bfd_put_32 (input_bfd
, pinsn
>> 32,
15311 contents
+ rel
->r_offset
);
15312 bfd_put_32 (input_bfd
, pinsn
& 0xffffffff,
15313 contents
+ rel
->r_offset
+ 4);
15314 rel
->r_addend
= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
15315 r_symndx
= STN_UNDEF
;
15316 r_type
= R_PPC64_TPREL34
;
15317 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15322 case R_PPC64_TLSGD
:
15323 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0
15324 && rel
+ 1 < relend
)
15326 unsigned int insn2
;
15327 enum elf_ppc64_reloc_type r_type1
= ELF64_R_TYPE (rel
[1].r_info
);
15329 offset
= rel
->r_offset
;
15330 if (is_plt_seq_reloc (r_type1
))
15332 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
);
15333 if (r_type1
== R_PPC64_PLT_PCREL34
15334 || r_type1
== R_PPC64_PLT_PCREL34_NOTOC
)
15335 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
15336 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
15340 if (ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_PLTCALL
)
15341 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
15343 if ((tls_mask
& TLS_GDIE
) != 0)
15346 r_type
= R_PPC64_NONE
;
15347 insn2
= 0x7c636a14; /* add 3,3,13 */
15352 if (toc_symndx
!= 0)
15354 r_symndx
= toc_symndx
;
15355 rel
->r_addend
= toc_addend
;
15357 if (r_type1
== R_PPC64_REL24_NOTOC
15358 || r_type1
== R_PPC64_PLTCALL_NOTOC
)
15360 r_type
= R_PPC64_NONE
;
15365 rel
->r_offset
= offset
+ d_offset
;
15366 r_type
= R_PPC64_TPREL16_LO
;
15367 insn2
= 0x38630000; /* addi 3,3,0 */
15370 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15371 /* Zap the reloc on the _tls_get_addr call too. */
15372 BFD_ASSERT (offset
== rel
[1].r_offset
);
15373 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
15374 bfd_put_32 (input_bfd
, insn2
, contents
+ offset
);
15375 if ((tls_mask
& TLS_GDIE
) == 0
15377 && r_type
!= R_PPC64_NONE
)
15382 case R_PPC64_TLSLD
:
15383 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0
15384 && rel
+ 1 < relend
)
15386 unsigned int insn2
;
15387 enum elf_ppc64_reloc_type r_type1
= ELF64_R_TYPE (rel
[1].r_info
);
15389 offset
= rel
->r_offset
;
15390 if (is_plt_seq_reloc (r_type1
))
15392 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
);
15393 if (r_type1
== R_PPC64_PLT_PCREL34
15394 || r_type1
== R_PPC64_PLT_PCREL34_NOTOC
)
15395 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
15396 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
15400 if (ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_PLTCALL
)
15401 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
15403 if (r_type1
== R_PPC64_REL24_NOTOC
15404 || r_type1
== R_PPC64_PLTCALL_NOTOC
)
15406 r_type
= R_PPC64_NONE
;
15411 rel
->r_offset
= offset
+ d_offset
;
15412 r_symndx
= STN_UNDEF
;
15413 r_type
= R_PPC64_TPREL16_LO
;
15414 rel
->r_addend
= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
15415 insn2
= 0x38630000; /* addi 3,3,0 */
15417 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15418 /* Zap the reloc on the _tls_get_addr call too. */
15419 BFD_ASSERT (offset
== rel
[1].r_offset
);
15420 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
15421 bfd_put_32 (input_bfd
, insn2
, contents
+ offset
);
15422 if (r_type
!= R_PPC64_NONE
)
15427 case R_PPC64_DTPMOD64
:
15428 if (rel
+ 1 < relend
15429 && rel
[1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_DTPREL64
)
15430 && rel
[1].r_offset
== rel
->r_offset
+ 8)
15432 if ((tls_mask
& TLS_GD
) == 0)
15434 rel
[1].r_info
= ELF64_R_INFO (r_symndx
, R_PPC64_NONE
);
15435 if ((tls_mask
& TLS_GDIE
) != 0)
15436 r_type
= R_PPC64_TPREL64
;
15439 bfd_put_64 (output_bfd
, 1, contents
+ rel
->r_offset
);
15440 r_type
= R_PPC64_NONE
;
15442 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15447 if ((tls_mask
& TLS_LD
) == 0)
15449 bfd_put_64 (output_bfd
, 1, contents
+ rel
->r_offset
);
15450 r_type
= R_PPC64_NONE
;
15451 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15456 case R_PPC64_TPREL64
:
15457 if ((tls_mask
& TLS_TPREL
) == 0)
15459 r_type
= R_PPC64_NONE
;
15460 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15464 case R_PPC64_ENTRY
:
15465 relocation
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
15466 if (!bfd_link_pic (info
)
15467 && !info
->traditional_format
15468 && relocation
+ 0x80008000 <= 0xffffffff)
15470 unsigned int insn1
, insn2
;
15472 insn1
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15473 insn2
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15474 if ((insn1
& ~0xfffc) == LD_R2_0R12
15475 && insn2
== ADD_R2_R2_R12
)
15477 bfd_put_32 (input_bfd
,
15478 LIS_R2
+ PPC_HA (relocation
),
15479 contents
+ rel
->r_offset
);
15480 bfd_put_32 (input_bfd
,
15481 ADDI_R2_R2
+ PPC_LO (relocation
),
15482 contents
+ rel
->r_offset
+ 4);
15487 relocation
-= (rel
->r_offset
15488 + input_section
->output_offset
15489 + input_section
->output_section
->vma
);
15490 if (relocation
+ 0x80008000 <= 0xffffffff)
15492 unsigned int insn1
, insn2
;
15494 insn1
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15495 insn2
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15496 if ((insn1
& ~0xfffc) == LD_R2_0R12
15497 && insn2
== ADD_R2_R2_R12
)
15499 bfd_put_32 (input_bfd
,
15500 ADDIS_R2_R12
+ PPC_HA (relocation
),
15501 contents
+ rel
->r_offset
);
15502 bfd_put_32 (input_bfd
,
15503 ADDI_R2_R2
+ PPC_LO (relocation
),
15504 contents
+ rel
->r_offset
+ 4);
15510 case R_PPC64_REL16_HA
:
15511 /* If we are generating a non-PIC executable, edit
15512 . 0: addis 2,12,.TOC.-0b@ha
15513 . addi 2,2,.TOC.-0b@l
15514 used by ELFv2 global entry points to set up r2, to
15517 if .TOC. is in range. */
15518 if (!bfd_link_pic (info
)
15519 && !info
->traditional_format
15521 && rel
->r_addend
== d_offset
15522 && h
!= NULL
&& &h
->elf
== htab
->elf
.hgot
15523 && rel
+ 1 < relend
15524 && rel
[1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_REL16_LO
)
15525 && rel
[1].r_offset
== rel
->r_offset
+ 4
15526 && rel
[1].r_addend
== rel
->r_addend
+ 4
15527 && relocation
+ 0x80008000 <= 0xffffffff)
15529 unsigned int insn1
, insn2
;
15530 offset
= rel
->r_offset
- d_offset
;
15531 insn1
= bfd_get_32 (input_bfd
, contents
+ offset
);
15532 insn2
= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
15533 if ((insn1
& 0xffff0000) == ADDIS_R2_R12
15534 && (insn2
& 0xffff0000) == ADDI_R2_R2
)
15536 r_type
= R_PPC64_ADDR16_HA
;
15537 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15538 rel
->r_addend
-= d_offset
;
15539 rel
[1].r_info
= ELF64_R_INFO (r_symndx
, R_PPC64_ADDR16_LO
);
15540 rel
[1].r_addend
-= d_offset
+ 4;
15541 bfd_put_32 (input_bfd
, LIS_R2
, contents
+ offset
);
15547 /* Handle other relocations that tweak non-addend part of insn. */
15549 max_br_offset
= 1 << 25;
15550 addend
= rel
->r_addend
;
15551 reloc_dest
= DEST_NORMAL
;
15557 case R_PPC64_TOCSAVE
:
15558 if (relocation
+ addend
== (rel
->r_offset
15559 + input_section
->output_offset
15560 + input_section
->output_section
->vma
)
15561 && tocsave_find (htab
, NO_INSERT
,
15562 &local_syms
, rel
, input_bfd
))
15564 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15566 || insn
== CROR_151515
|| insn
== CROR_313131
)
15567 bfd_put_32 (input_bfd
,
15568 STD_R2_0R1
+ STK_TOC (htab
),
15569 contents
+ rel
->r_offset
);
15573 /* Branch taken prediction relocations. */
15574 case R_PPC64_ADDR14_BRTAKEN
:
15575 case R_PPC64_REL14_BRTAKEN
:
15576 insn
= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
15577 /* Fall through. */
15579 /* Branch not taken prediction relocations. */
15580 case R_PPC64_ADDR14_BRNTAKEN
:
15581 case R_PPC64_REL14_BRNTAKEN
:
15582 insn
|= bfd_get_32 (input_bfd
,
15583 contents
+ rel
->r_offset
) & ~(0x01 << 21);
15584 /* Fall through. */
15586 case R_PPC64_REL14
:
15587 max_br_offset
= 1 << 15;
15588 /* Fall through. */
15590 case R_PPC64_REL24
:
15591 case R_PPC64_REL24_NOTOC
:
15592 case R_PPC64_PLTCALL
:
15593 case R_PPC64_PLTCALL_NOTOC
:
15594 /* Calls to functions with a different TOC, such as calls to
15595 shared objects, need to alter the TOC pointer. This is
15596 done using a linkage stub. A REL24 branching to these
15597 linkage stubs needs to be followed by a nop, as the nop
15598 will be replaced with an instruction to restore the TOC
15603 && h
->oh
->is_func_descriptor
)
15604 fdh
= ppc_follow_link (h
->oh
);
15605 stub_entry
= ppc_get_stub_entry (input_section
, sec
, fdh
, &orig_rel
,
15607 if ((r_type
== R_PPC64_PLTCALL
15608 || r_type
== R_PPC64_PLTCALL_NOTOC
)
15609 && stub_entry
!= NULL
15610 && stub_entry
->stub_type
>= ppc_stub_plt_call
15611 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15614 if (stub_entry
!= NULL
15615 && ((stub_entry
->stub_type
>= ppc_stub_plt_call
15616 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15617 || stub_entry
->stub_type
== ppc_stub_plt_branch_r2off
15618 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
15619 || stub_entry
->stub_type
== ppc_stub_long_branch_r2off
15620 || stub_entry
->stub_type
== ppc_stub_long_branch_both
))
15622 bfd_boolean can_plt_call
= FALSE
;
15624 if (stub_entry
->stub_type
== ppc_stub_plt_call
15626 && htab
->params
->plt_localentry0
!= 0
15627 && is_elfv2_localentry0 (&h
->elf
))
15629 /* The function doesn't use or change r2. */
15630 can_plt_call
= TRUE
;
15632 else if (r_type
== R_PPC64_REL24_NOTOC
)
15634 /* NOTOC calls don't need to restore r2. */
15635 can_plt_call
= TRUE
;
15638 /* All of these stubs may modify r2, so there must be a
15639 branch and link followed by a nop. The nop is
15640 replaced by an insn to restore r2. */
15641 else if (rel
->r_offset
+ 8 <= input_section
->size
)
15645 br
= bfd_get_32 (input_bfd
,
15646 contents
+ rel
->r_offset
);
15651 nop
= bfd_get_32 (input_bfd
,
15652 contents
+ rel
->r_offset
+ 4);
15653 if (nop
== LD_R2_0R1
+ STK_TOC (htab
))
15654 can_plt_call
= TRUE
;
15655 else if (nop
== NOP
15656 || nop
== CROR_151515
15657 || nop
== CROR_313131
)
15660 && is_tls_get_addr (&h
->elf
, htab
)
15661 && htab
->params
->tls_get_addr_opt
)
15663 /* Special stub used, leave nop alone. */
15666 bfd_put_32 (input_bfd
,
15667 LD_R2_0R1
+ STK_TOC (htab
),
15668 contents
+ rel
->r_offset
+ 4);
15669 can_plt_call
= TRUE
;
15674 if (!can_plt_call
&& h
!= NULL
)
15676 const char *name
= h
->elf
.root
.root
.string
;
15681 if (strncmp (name
, "__libc_start_main", 17) == 0
15682 && (name
[17] == 0 || name
[17] == '@'))
15684 /* Allow crt1 branch to go via a toc adjusting
15685 stub. Other calls that never return could do
15686 the same, if we could detect such. */
15687 can_plt_call
= TRUE
;
15693 /* g++ as of 20130507 emits self-calls without a
15694 following nop. This is arguably wrong since we
15695 have conflicting information. On the one hand a
15696 global symbol and on the other a local call
15697 sequence, but don't error for this special case.
15698 It isn't possible to cheaply verify we have
15699 exactly such a call. Allow all calls to the same
15701 asection
*code_sec
= sec
;
15703 if (get_opd_info (sec
) != NULL
)
15705 bfd_vma off
= (relocation
+ addend
15706 - sec
->output_section
->vma
15707 - sec
->output_offset
);
15709 opd_entry_value (sec
, off
, &code_sec
, NULL
, FALSE
);
15711 if (code_sec
== input_section
)
15712 can_plt_call
= TRUE
;
15717 if (stub_entry
->stub_type
>= ppc_stub_plt_call
15718 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15719 info
->callbacks
->einfo
15720 /* xgettext:c-format */
15721 (_("%H: call to `%pT' lacks nop, can't restore toc; "
15722 "(plt call stub)\n"),
15723 input_bfd
, input_section
, rel
->r_offset
, sym_name
);
15725 info
->callbacks
->einfo
15726 /* xgettext:c-format */
15727 (_("%H: call to `%pT' lacks nop, can't restore toc; "
15728 "(toc save/adjust stub)\n"),
15729 input_bfd
, input_section
, rel
->r_offset
, sym_name
);
15731 bfd_set_error (bfd_error_bad_value
);
15736 && stub_entry
->stub_type
>= ppc_stub_plt_call
15737 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15738 unresolved_reloc
= FALSE
;
15741 if ((stub_entry
== NULL
15742 || stub_entry
->stub_type
== ppc_stub_long_branch
15743 || stub_entry
->stub_type
== ppc_stub_plt_branch
)
15744 && get_opd_info (sec
) != NULL
)
15746 /* The branch destination is the value of the opd entry. */
15747 bfd_vma off
= (relocation
+ addend
15748 - sec
->output_section
->vma
15749 - sec
->output_offset
);
15750 bfd_vma dest
= opd_entry_value (sec
, off
, NULL
, NULL
, FALSE
);
15751 if (dest
!= (bfd_vma
) -1)
15755 reloc_dest
= DEST_OPD
;
15759 /* If the branch is out of reach we ought to have a long
15761 from
= (rel
->r_offset
15762 + input_section
->output_offset
15763 + input_section
->output_section
->vma
);
15765 relocation
+= PPC64_LOCAL_ENTRY_OFFSET (fdh
15769 if (stub_entry
!= NULL
15770 && (stub_entry
->stub_type
== ppc_stub_long_branch
15771 || stub_entry
->stub_type
== ppc_stub_plt_branch
)
15772 && (r_type
== R_PPC64_ADDR14_BRTAKEN
15773 || r_type
== R_PPC64_ADDR14_BRNTAKEN
15774 || (relocation
+ addend
- from
+ max_br_offset
15775 < 2 * max_br_offset
)))
15776 /* Don't use the stub if this branch is in range. */
15779 if (stub_entry
!= NULL
15780 && (stub_entry
->stub_type
== ppc_stub_long_branch_notoc
15781 || stub_entry
->stub_type
== ppc_stub_long_branch_both
15782 || stub_entry
->stub_type
== ppc_stub_plt_branch_notoc
15783 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
)
15784 && (r_type
!= R_PPC64_REL24_NOTOC
15785 || ((fdh
? fdh
->elf
.other
: sym
->st_other
)
15786 & STO_PPC64_LOCAL_MASK
) <= 1 << STO_PPC64_LOCAL_BIT
)
15787 && (relocation
+ addend
- from
+ max_br_offset
15788 < 2 * max_br_offset
))
15791 if (stub_entry
!= NULL
15792 && (stub_entry
->stub_type
== ppc_stub_long_branch_r2off
15793 || stub_entry
->stub_type
== ppc_stub_long_branch_both
15794 || stub_entry
->stub_type
== ppc_stub_plt_branch_r2off
15795 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
)
15796 && r_type
== R_PPC64_REL24_NOTOC
15797 && (relocation
+ addend
- from
+ max_br_offset
15798 < 2 * max_br_offset
))
15801 if (stub_entry
!= NULL
)
15803 /* Munge up the value and addend so that we call the stub
15804 rather than the procedure directly. */
15805 asection
*stub_sec
= stub_entry
->group
->stub_sec
;
15807 if (stub_entry
->stub_type
== ppc_stub_save_res
)
15808 relocation
+= (stub_sec
->output_offset
15809 + stub_sec
->output_section
->vma
15810 + stub_sec
->size
- htab
->sfpr
->size
15811 - htab
->sfpr
->output_offset
15812 - htab
->sfpr
->output_section
->vma
);
15814 relocation
= (stub_entry
->stub_offset
15815 + stub_sec
->output_offset
15816 + stub_sec
->output_section
->vma
);
15818 reloc_dest
= DEST_STUB
;
15820 if (((stub_entry
->stub_type
== ppc_stub_plt_call
15821 && ALWAYS_EMIT_R2SAVE
)
15822 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
15823 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
15825 && is_tls_get_addr (&h
->elf
, htab
)
15826 && htab
->params
->tls_get_addr_opt
)
15827 && rel
+ 1 < relend
15828 && rel
[1].r_offset
== rel
->r_offset
+ 4
15829 && ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_TOCSAVE
)
15831 else if ((stub_entry
->stub_type
== ppc_stub_long_branch_both
15832 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
15833 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
15834 && r_type
== R_PPC64_REL24_NOTOC
)
15837 if (r_type
== R_PPC64_REL24_NOTOC
15838 && (stub_entry
->stub_type
== ppc_stub_plt_call_notoc
15839 || stub_entry
->stub_type
== ppc_stub_plt_call_both
))
15840 htab
->notoc_plt
= 1;
15847 /* Set 'a' bit. This is 0b00010 in BO field for branch
15848 on CR(BI) insns (BO == 001at or 011at), and 0b01000
15849 for branch on CTR insns (BO == 1a00t or 1a01t). */
15850 if ((insn
& (0x14 << 21)) == (0x04 << 21))
15851 insn
|= 0x02 << 21;
15852 else if ((insn
& (0x14 << 21)) == (0x10 << 21))
15853 insn
|= 0x08 << 21;
15859 /* Invert 'y' bit if not the default. */
15860 if ((bfd_signed_vma
) (relocation
+ addend
- from
) < 0)
15861 insn
^= 0x01 << 21;
15864 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
15867 /* NOP out calls to undefined weak functions.
15868 We can thus call a weak function without first
15869 checking whether the function is defined. */
15871 && h
->elf
.root
.type
== bfd_link_hash_undefweak
15872 && h
->elf
.dynindx
== -1
15873 && (r_type
== R_PPC64_REL24
15874 || r_type
== R_PPC64_REL24_NOTOC
)
15878 bfd_put_32 (input_bfd
, NOP
, contents
+ rel
->r_offset
);
15883 case R_PPC64_GOT16_DS
:
15884 if ((h
? h
->elf
.type
: ELF_ST_TYPE (sym
->st_info
)) == STT_GNU_IFUNC
)
15886 from
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
15887 if (relocation
+ addend
- from
+ 0x8000 < 0x10000
15888 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15890 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
15891 if ((insn
& (0x3fu
<< 26 | 0x3)) == 58u << 26 /* ld */)
15893 insn
+= (14u << 26) - (58u << 26);
15894 bfd_put_32 (input_bfd
, insn
, contents
+ (rel
->r_offset
& ~3));
15895 r_type
= R_PPC64_TOC16
;
15896 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15901 case R_PPC64_GOT16_LO_DS
:
15902 case R_PPC64_GOT16_HA
:
15903 if ((h
? h
->elf
.type
: ELF_ST_TYPE (sym
->st_info
)) == STT_GNU_IFUNC
)
15905 from
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
15906 if (relocation
+ addend
- from
+ 0x80008000ULL
< 0x100000000ULL
15907 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15909 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
15910 if ((insn
& (0x3fu
<< 26 | 0x3)) == 58u << 26 /* ld */)
15912 insn
+= (14u << 26) - (58u << 26);
15913 bfd_put_32 (input_bfd
, insn
, contents
+ (rel
->r_offset
& ~3));
15914 r_type
= R_PPC64_TOC16_LO
;
15915 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15917 else if ((insn
& (0x3fu
<< 26)) == 15u << 26 /* addis */)
15919 r_type
= R_PPC64_TOC16_HA
;
15920 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15925 case R_PPC64_GOT_PCREL34
:
15926 if ((h
? h
->elf
.type
: ELF_ST_TYPE (sym
->st_info
)) == STT_GNU_IFUNC
)
15928 from
= (rel
->r_offset
15929 + input_section
->output_section
->vma
15930 + input_section
->output_offset
);
15931 if (relocation
- from
+ (1ULL << 33) < 1ULL << 34
15932 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15934 offset
= rel
->r_offset
;
15935 pinsn
= bfd_get_32 (input_bfd
, contents
+ offset
);
15937 pinsn
|= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
15938 if ((pinsn
& ((-1ULL << 50) | (63ULL << 26)))
15939 == ((1ULL << 58) | (1ULL << 52) | (57ULL << 26) /* pld */))
15941 /* Replace with paddi. */
15942 pinsn
+= (2ULL << 56) + (14ULL << 26) - (57ULL << 26);
15943 r_type
= R_PPC64_PCREL34
;
15944 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15945 bfd_put_32 (input_bfd
, pinsn
>> 32, contents
+ offset
);
15946 bfd_put_32 (input_bfd
, pinsn
, contents
+ offset
+ 4);
15952 case R_PPC64_PCREL34
:
15953 if (SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15955 offset
= rel
->r_offset
;
15956 pinsn
= bfd_get_32 (input_bfd
, contents
+ offset
);
15958 pinsn
|= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
15959 if ((pinsn
& ((-1ULL << 50) | (63ULL << 26)))
15960 == ((1ULL << 58) | (2ULL << 56) | (1ULL << 52)
15961 | (14ULL << 26) /* paddi */))
15964 if (rel
+ 1 < relend
15965 && rel
[1].r_offset
== offset
15966 && rel
[1].r_info
== ELF64_R_INFO (0, R_PPC64_PCREL_OPT
))
15968 bfd_vma off2
= rel
[1].r_addend
;
15970 /* zero means next insn. */
15973 if (off2
+ 4 <= input_section
->size
)
15976 bfd_signed_vma addend_off
;
15977 pinsn2
= bfd_get_32 (input_bfd
, contents
+ off2
);
15979 if ((pinsn2
& (63ULL << 58)) == 1ULL << 58)
15981 if (off2
+ 8 > input_section
->size
)
15983 pinsn2
|= bfd_get_32 (input_bfd
,
15984 contents
+ off2
+ 4);
15986 if (xlate_pcrel_opt (&pinsn
, &pinsn2
, &addend_off
))
15988 addend
+= addend_off
;
15989 rel
->r_addend
= addend
;
15990 bfd_put_32 (input_bfd
, pinsn
>> 32,
15991 contents
+ offset
);
15992 bfd_put_32 (input_bfd
, pinsn
,
15993 contents
+ offset
+ 4);
15994 bfd_put_32 (input_bfd
, pinsn2
>> 32,
15996 if ((pinsn2
& (63ULL << 58)) == 1ULL << 58)
15997 bfd_put_32 (input_bfd
, pinsn2
,
15998 contents
+ off2
+ 4);
16008 save_unresolved_reloc
= unresolved_reloc
;
16012 /* xgettext:c-format */
16013 _bfd_error_handler (_("%pB: %s unsupported"),
16014 input_bfd
, ppc64_elf_howto_table
[r_type
]->name
);
16016 bfd_set_error (bfd_error_bad_value
);
16022 case R_PPC64_TLSGD
:
16023 case R_PPC64_TLSLD
:
16024 case R_PPC64_TOCSAVE
:
16025 case R_PPC64_GNU_VTINHERIT
:
16026 case R_PPC64_GNU_VTENTRY
:
16027 case R_PPC64_ENTRY
:
16028 case R_PPC64_PCREL_OPT
:
16031 /* GOT16 relocations. Like an ADDR16 using the symbol's
16032 address in the GOT as relocation value instead of the
16033 symbol's value itself. Also, create a GOT entry for the
16034 symbol and put the symbol value there. */
16035 case R_PPC64_GOT_TLSGD16
:
16036 case R_PPC64_GOT_TLSGD16_LO
:
16037 case R_PPC64_GOT_TLSGD16_HI
:
16038 case R_PPC64_GOT_TLSGD16_HA
:
16039 case R_PPC64_GOT_TLSGD34
:
16040 tls_type
= TLS_TLS
| TLS_GD
;
16043 case R_PPC64_GOT_TLSLD16
:
16044 case R_PPC64_GOT_TLSLD16_LO
:
16045 case R_PPC64_GOT_TLSLD16_HI
:
16046 case R_PPC64_GOT_TLSLD16_HA
:
16047 case R_PPC64_GOT_TLSLD34
:
16048 tls_type
= TLS_TLS
| TLS_LD
;
16051 case R_PPC64_GOT_TPREL16_DS
:
16052 case R_PPC64_GOT_TPREL16_LO_DS
:
16053 case R_PPC64_GOT_TPREL16_HI
:
16054 case R_PPC64_GOT_TPREL16_HA
:
16055 case R_PPC64_GOT_TPREL34
:
16056 tls_type
= TLS_TLS
| TLS_TPREL
;
16059 case R_PPC64_GOT_DTPREL16_DS
:
16060 case R_PPC64_GOT_DTPREL16_LO_DS
:
16061 case R_PPC64_GOT_DTPREL16_HI
:
16062 case R_PPC64_GOT_DTPREL16_HA
:
16063 case R_PPC64_GOT_DTPREL34
:
16064 tls_type
= TLS_TLS
| TLS_DTPREL
;
16067 case R_PPC64_GOT16
:
16068 case R_PPC64_GOT16_LO
:
16069 case R_PPC64_GOT16_HI
:
16070 case R_PPC64_GOT16_HA
:
16071 case R_PPC64_GOT16_DS
:
16072 case R_PPC64_GOT16_LO_DS
:
16073 case R_PPC64_GOT_PCREL34
:
16076 /* Relocation is to the entry for this symbol in the global
16081 unsigned long indx
= 0;
16082 struct got_entry
*ent
;
16084 if (tls_type
== (TLS_TLS
| TLS_LD
)
16085 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
16086 ent
= ppc64_tlsld_got (input_bfd
);
16091 if (!htab
->elf
.dynamic_sections_created
16092 || h
->elf
.dynindx
== -1
16093 || SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
)
16094 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, &h
->elf
))
16095 /* This is actually a static link, or it is a
16096 -Bsymbolic link and the symbol is defined
16097 locally, or the symbol was forced to be local
16098 because of a version file. */
16102 indx
= h
->elf
.dynindx
;
16103 unresolved_reloc
= FALSE
;
16105 ent
= h
->elf
.got
.glist
;
16109 if (local_got_ents
== NULL
)
16111 ent
= local_got_ents
[r_symndx
];
16114 for (; ent
!= NULL
; ent
= ent
->next
)
16115 if (ent
->addend
== orig_rel
.r_addend
16116 && ent
->owner
== input_bfd
16117 && ent
->tls_type
== tls_type
)
16123 if (ent
->is_indirect
)
16124 ent
= ent
->got
.ent
;
16125 offp
= &ent
->got
.offset
;
16126 got
= ppc64_elf_tdata (ent
->owner
)->got
;
16130 /* The offset must always be a multiple of 8. We use the
16131 least significant bit to record whether we have already
16132 processed this entry. */
16134 if ((off
& 1) != 0)
16138 /* Generate relocs for the dynamic linker, except in
16139 the case of TLSLD where we'll use one entry per
16147 ? h
->elf
.type
== STT_GNU_IFUNC
16148 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
);
16151 relgot
= htab
->elf
.irelplt
;
16153 htab
->local_ifunc_resolver
= 1;
16154 else if (is_static_defined (&h
->elf
))
16155 htab
->maybe_local_ifunc_resolver
= 1;
16158 || (bfd_link_pic (info
)
16160 || !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, &h
->elf
))
16162 && bfd_link_executable (info
)
16163 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))))
16164 relgot
= ppc64_elf_tdata (ent
->owner
)->relgot
;
16165 if (relgot
!= NULL
)
16167 outrel
.r_offset
= (got
->output_section
->vma
16168 + got
->output_offset
16170 outrel
.r_addend
= orig_rel
.r_addend
;
16171 if (tls_type
& (TLS_LD
| TLS_GD
))
16173 outrel
.r_addend
= 0;
16174 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_DTPMOD64
);
16175 if (tls_type
== (TLS_TLS
| TLS_GD
))
16177 loc
= relgot
->contents
;
16178 loc
+= (relgot
->reloc_count
++
16179 * sizeof (Elf64_External_Rela
));
16180 bfd_elf64_swap_reloca_out (output_bfd
,
16182 outrel
.r_offset
+= 8;
16183 outrel
.r_addend
= orig_rel
.r_addend
;
16185 = ELF64_R_INFO (indx
, R_PPC64_DTPREL64
);
16188 else if (tls_type
== (TLS_TLS
| TLS_DTPREL
))
16189 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_DTPREL64
);
16190 else if (tls_type
== (TLS_TLS
| TLS_TPREL
))
16191 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_TPREL64
);
16192 else if (indx
!= 0)
16193 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_GLOB_DAT
);
16197 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
16199 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
16201 /* Write the .got section contents for the sake
16203 loc
= got
->contents
+ off
;
16204 bfd_put_64 (output_bfd
, outrel
.r_addend
+ relocation
,
16208 if (indx
== 0 && tls_type
!= (TLS_TLS
| TLS_LD
))
16210 outrel
.r_addend
+= relocation
;
16211 if (tls_type
& (TLS_GD
| TLS_DTPREL
| TLS_TPREL
))
16213 if (htab
->elf
.tls_sec
== NULL
)
16214 outrel
.r_addend
= 0;
16216 outrel
.r_addend
-= htab
->elf
.tls_sec
->vma
;
16219 loc
= relgot
->contents
;
16220 loc
+= (relgot
->reloc_count
++
16221 * sizeof (Elf64_External_Rela
));
16222 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
16225 /* Init the .got section contents here if we're not
16226 emitting a reloc. */
16229 relocation
+= orig_rel
.r_addend
;
16232 if (htab
->elf
.tls_sec
== NULL
)
16236 if (tls_type
& TLS_LD
)
16239 relocation
-= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
16240 if (tls_type
& TLS_TPREL
)
16241 relocation
+= DTP_OFFSET
- TP_OFFSET
;
16244 if (tls_type
& (TLS_GD
| TLS_LD
))
16246 bfd_put_64 (output_bfd
, relocation
,
16247 got
->contents
+ off
+ 8);
16251 bfd_put_64 (output_bfd
, relocation
,
16252 got
->contents
+ off
);
16256 if (off
>= (bfd_vma
) -2)
16259 relocation
= got
->output_section
->vma
+ got
->output_offset
+ off
;
16261 if (!(r_type
== R_PPC64_GOT_PCREL34
16262 || r_type
== R_PPC64_GOT_TLSGD34
16263 || r_type
== R_PPC64_GOT_TLSLD34
16264 || r_type
== R_PPC64_GOT_TPREL34
16265 || r_type
== R_PPC64_GOT_DTPREL34
))
16266 addend
= -(TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
);
16270 case R_PPC64_PLT16_HA
:
16271 case R_PPC64_PLT16_HI
:
16272 case R_PPC64_PLT16_LO
:
16273 case R_PPC64_PLT16_LO_DS
:
16274 case R_PPC64_PLT_PCREL34
:
16275 case R_PPC64_PLT_PCREL34_NOTOC
:
16276 case R_PPC64_PLT32
:
16277 case R_PPC64_PLT64
:
16278 case R_PPC64_PLTSEQ
:
16279 case R_PPC64_PLTSEQ_NOTOC
:
16280 case R_PPC64_PLTCALL
:
16281 case R_PPC64_PLTCALL_NOTOC
:
16282 /* Relocation is to the entry for this symbol in the
16283 procedure linkage table. */
16284 unresolved_reloc
= TRUE
;
16286 struct plt_entry
**plt_list
= NULL
;
16288 plt_list
= &h
->elf
.plt
.plist
;
16289 else if (local_got_ents
!= NULL
)
16291 struct plt_entry
**local_plt
= (struct plt_entry
**)
16292 (local_got_ents
+ symtab_hdr
->sh_info
);
16293 plt_list
= local_plt
+ r_symndx
;
16297 struct plt_entry
*ent
;
16299 for (ent
= *plt_list
; ent
!= NULL
; ent
= ent
->next
)
16300 if (ent
->plt
.offset
!= (bfd_vma
) -1
16301 && ent
->addend
== orig_rel
.r_addend
)
16306 plt
= htab
->elf
.splt
;
16307 if (!htab
->elf
.dynamic_sections_created
16309 || h
->elf
.dynindx
== -1)
16312 ? h
->elf
.type
== STT_GNU_IFUNC
16313 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
16314 plt
= htab
->elf
.iplt
;
16316 plt
= htab
->pltlocal
;
16318 relocation
= (plt
->output_section
->vma
16319 + plt
->output_offset
16320 + ent
->plt
.offset
);
16321 if (r_type
== R_PPC64_PLT16_HA
16322 || r_type
== R_PPC64_PLT16_HI
16323 || r_type
== R_PPC64_PLT16_LO
16324 || r_type
== R_PPC64_PLT16_LO_DS
)
16326 got
= (elf_gp (output_bfd
)
16327 + htab
->sec_info
[input_section
->id
].toc_off
);
16331 unresolved_reloc
= FALSE
;
16339 /* Relocation value is TOC base. */
16340 relocation
= TOCstart
;
16341 if (r_symndx
== STN_UNDEF
)
16342 relocation
+= htab
->sec_info
[input_section
->id
].toc_off
;
16343 else if (unresolved_reloc
)
16345 else if (sec
!= NULL
&& sec
->id
< htab
->sec_info_arr_size
)
16346 relocation
+= htab
->sec_info
[sec
->id
].toc_off
;
16348 unresolved_reloc
= TRUE
;
16351 /* TOC16 relocs. We want the offset relative to the TOC base,
16352 which is the address of the start of the TOC plus 0x8000.
16353 The TOC consists of sections .got, .toc, .tocbss, and .plt,
16355 case R_PPC64_TOC16
:
16356 case R_PPC64_TOC16_LO
:
16357 case R_PPC64_TOC16_HI
:
16358 case R_PPC64_TOC16_DS
:
16359 case R_PPC64_TOC16_LO_DS
:
16360 case R_PPC64_TOC16_HA
:
16361 addend
-= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
16366 /* Relocate against the beginning of the section. */
16367 case R_PPC64_SECTOFF
:
16368 case R_PPC64_SECTOFF_LO
:
16369 case R_PPC64_SECTOFF_HI
:
16370 case R_PPC64_SECTOFF_DS
:
16371 case R_PPC64_SECTOFF_LO_DS
:
16372 case R_PPC64_SECTOFF_HA
:
16374 addend
-= sec
->output_section
->vma
;
16377 case R_PPC64_REL16
:
16378 case R_PPC64_REL16_LO
:
16379 case R_PPC64_REL16_HI
:
16380 case R_PPC64_REL16_HA
:
16381 case R_PPC64_REL16_HIGH
:
16382 case R_PPC64_REL16_HIGHA
:
16383 case R_PPC64_REL16_HIGHER
:
16384 case R_PPC64_REL16_HIGHERA
:
16385 case R_PPC64_REL16_HIGHEST
:
16386 case R_PPC64_REL16_HIGHESTA
:
16387 case R_PPC64_REL16_HIGHER34
:
16388 case R_PPC64_REL16_HIGHERA34
:
16389 case R_PPC64_REL16_HIGHEST34
:
16390 case R_PPC64_REL16_HIGHESTA34
:
16391 case R_PPC64_REL16DX_HA
:
16392 case R_PPC64_REL14
:
16393 case R_PPC64_REL14_BRNTAKEN
:
16394 case R_PPC64_REL14_BRTAKEN
:
16395 case R_PPC64_REL24
:
16396 case R_PPC64_REL24_NOTOC
:
16397 case R_PPC64_PCREL34
:
16398 case R_PPC64_PCREL28
:
16401 case R_PPC64_TPREL16
:
16402 case R_PPC64_TPREL16_LO
:
16403 case R_PPC64_TPREL16_HI
:
16404 case R_PPC64_TPREL16_HA
:
16405 case R_PPC64_TPREL16_DS
:
16406 case R_PPC64_TPREL16_LO_DS
:
16407 case R_PPC64_TPREL16_HIGH
:
16408 case R_PPC64_TPREL16_HIGHA
:
16409 case R_PPC64_TPREL16_HIGHER
:
16410 case R_PPC64_TPREL16_HIGHERA
:
16411 case R_PPC64_TPREL16_HIGHEST
:
16412 case R_PPC64_TPREL16_HIGHESTA
:
16413 case R_PPC64_TPREL34
:
16415 && h
->elf
.root
.type
== bfd_link_hash_undefweak
16416 && h
->elf
.dynindx
== -1)
16418 /* Make this relocation against an undefined weak symbol
16419 resolve to zero. This is really just a tweak, since
16420 code using weak externs ought to check that they are
16421 defined before using them. */
16422 bfd_byte
*p
= contents
+ rel
->r_offset
- d_offset
;
16424 insn
= bfd_get_32 (input_bfd
, p
);
16425 insn
= _bfd_elf_ppc_at_tprel_transform (insn
, 13);
16427 bfd_put_32 (input_bfd
, insn
, p
);
16430 if (htab
->elf
.tls_sec
!= NULL
)
16431 addend
-= htab
->elf
.tls_sec
->vma
+ TP_OFFSET
;
16432 /* The TPREL16 relocs shouldn't really be used in shared
16433 libs or with non-local symbols as that will result in
16434 DT_TEXTREL being set, but support them anyway. */
16437 case R_PPC64_DTPREL16
:
16438 case R_PPC64_DTPREL16_LO
:
16439 case R_PPC64_DTPREL16_HI
:
16440 case R_PPC64_DTPREL16_HA
:
16441 case R_PPC64_DTPREL16_DS
:
16442 case R_PPC64_DTPREL16_LO_DS
:
16443 case R_PPC64_DTPREL16_HIGH
:
16444 case R_PPC64_DTPREL16_HIGHA
:
16445 case R_PPC64_DTPREL16_HIGHER
:
16446 case R_PPC64_DTPREL16_HIGHERA
:
16447 case R_PPC64_DTPREL16_HIGHEST
:
16448 case R_PPC64_DTPREL16_HIGHESTA
:
16449 case R_PPC64_DTPREL34
:
16450 if (htab
->elf
.tls_sec
!= NULL
)
16451 addend
-= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
16454 case R_PPC64_ADDR64_LOCAL
:
16455 addend
+= PPC64_LOCAL_ENTRY_OFFSET (h
!= NULL
16460 case R_PPC64_DTPMOD64
:
16465 case R_PPC64_TPREL64
:
16466 if (htab
->elf
.tls_sec
!= NULL
)
16467 addend
-= htab
->elf
.tls_sec
->vma
+ TP_OFFSET
;
16470 case R_PPC64_DTPREL64
:
16471 if (htab
->elf
.tls_sec
!= NULL
)
16472 addend
-= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
16473 /* Fall through. */
16475 /* Relocations that may need to be propagated if this is a
16477 case R_PPC64_REL30
:
16478 case R_PPC64_REL32
:
16479 case R_PPC64_REL64
:
16480 case R_PPC64_ADDR14
:
16481 case R_PPC64_ADDR14_BRNTAKEN
:
16482 case R_PPC64_ADDR14_BRTAKEN
:
16483 case R_PPC64_ADDR16
:
16484 case R_PPC64_ADDR16_DS
:
16485 case R_PPC64_ADDR16_HA
:
16486 case R_PPC64_ADDR16_HI
:
16487 case R_PPC64_ADDR16_HIGH
:
16488 case R_PPC64_ADDR16_HIGHA
:
16489 case R_PPC64_ADDR16_HIGHER
:
16490 case R_PPC64_ADDR16_HIGHERA
:
16491 case R_PPC64_ADDR16_HIGHEST
:
16492 case R_PPC64_ADDR16_HIGHESTA
:
16493 case R_PPC64_ADDR16_LO
:
16494 case R_PPC64_ADDR16_LO_DS
:
16495 case R_PPC64_ADDR16_HIGHER34
:
16496 case R_PPC64_ADDR16_HIGHERA34
:
16497 case R_PPC64_ADDR16_HIGHEST34
:
16498 case R_PPC64_ADDR16_HIGHESTA34
:
16499 case R_PPC64_ADDR24
:
16500 case R_PPC64_ADDR32
:
16501 case R_PPC64_ADDR64
:
16502 case R_PPC64_UADDR16
:
16503 case R_PPC64_UADDR32
:
16504 case R_PPC64_UADDR64
:
16506 case R_PPC64_D34_LO
:
16507 case R_PPC64_D34_HI30
:
16508 case R_PPC64_D34_HA30
:
16511 if ((input_section
->flags
& SEC_ALLOC
) == 0)
16514 if (NO_OPD_RELOCS
&& is_opd
)
16517 if (bfd_link_pic (info
)
16519 || h
->dyn_relocs
!= NULL
)
16520 && ((h
!= NULL
&& pc_dynrelocs (h
))
16521 || must_be_dyn_reloc (info
, r_type
)))
16523 ? h
->dyn_relocs
!= NULL
16524 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
))
16526 bfd_boolean skip
, relocate
;
16531 /* When generating a dynamic object, these relocations
16532 are copied into the output file to be resolved at run
16538 out_off
= _bfd_elf_section_offset (output_bfd
, info
,
16539 input_section
, rel
->r_offset
);
16540 if (out_off
== (bfd_vma
) -1)
16542 else if (out_off
== (bfd_vma
) -2)
16543 skip
= TRUE
, relocate
= TRUE
;
16544 out_off
+= (input_section
->output_section
->vma
16545 + input_section
->output_offset
);
16546 outrel
.r_offset
= out_off
;
16547 outrel
.r_addend
= rel
->r_addend
;
16549 /* Optimize unaligned reloc use. */
16550 if ((r_type
== R_PPC64_ADDR64
&& (out_off
& 7) != 0)
16551 || (r_type
== R_PPC64_UADDR64
&& (out_off
& 7) == 0))
16552 r_type
^= R_PPC64_ADDR64
^ R_PPC64_UADDR64
;
16553 else if ((r_type
== R_PPC64_ADDR32
&& (out_off
& 3) != 0)
16554 || (r_type
== R_PPC64_UADDR32
&& (out_off
& 3) == 0))
16555 r_type
^= R_PPC64_ADDR32
^ R_PPC64_UADDR32
;
16556 else if ((r_type
== R_PPC64_ADDR16
&& (out_off
& 1) != 0)
16557 || (r_type
== R_PPC64_UADDR16
&& (out_off
& 1) == 0))
16558 r_type
^= R_PPC64_ADDR16
^ R_PPC64_UADDR16
;
16561 memset (&outrel
, 0, sizeof outrel
);
16562 else if (!SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
)
16564 && r_type
!= R_PPC64_TOC
)
16566 indx
= h
->elf
.dynindx
;
16567 BFD_ASSERT (indx
!= -1);
16568 outrel
.r_info
= ELF64_R_INFO (indx
, r_type
);
16572 /* This symbol is local, or marked to become local,
16573 or this is an opd section reloc which must point
16574 at a local function. */
16575 outrel
.r_addend
+= relocation
;
16576 if (r_type
== R_PPC64_ADDR64
|| r_type
== R_PPC64_TOC
)
16578 if (is_opd
&& h
!= NULL
)
16580 /* Lie about opd entries. This case occurs
16581 when building shared libraries and we
16582 reference a function in another shared
16583 lib. The same thing happens for a weak
16584 definition in an application that's
16585 overridden by a strong definition in a
16586 shared lib. (I believe this is a generic
16587 bug in binutils handling of weak syms.)
16588 In these cases we won't use the opd
16589 entry in this lib. */
16590 unresolved_reloc
= FALSE
;
16593 && r_type
== R_PPC64_ADDR64
16595 ? h
->elf
.type
== STT_GNU_IFUNC
16596 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
))
16597 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
16600 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
16602 /* We need to relocate .opd contents for ld.so.
16603 Prelink also wants simple and consistent rules
16604 for relocs. This make all RELATIVE relocs have
16605 *r_offset equal to r_addend. */
16612 ? h
->elf
.type
== STT_GNU_IFUNC
16613 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
16615 info
->callbacks
->einfo
16616 /* xgettext:c-format */
16617 (_("%H: %s for indirect "
16618 "function `%pT' unsupported\n"),
16619 input_bfd
, input_section
, rel
->r_offset
,
16620 ppc64_elf_howto_table
[r_type
]->name
,
16624 else if (r_symndx
== STN_UNDEF
|| bfd_is_abs_section (sec
))
16626 else if (sec
== NULL
|| sec
->owner
== NULL
)
16628 bfd_set_error (bfd_error_bad_value
);
16633 asection
*osec
= sec
->output_section
;
16635 if ((osec
->flags
& SEC_THREAD_LOCAL
) != 0)
16637 /* TLS symbol values are relative to the
16638 TLS segment. Dynamic relocations for
16639 local TLS symbols therefore can't be
16640 reduced to a relocation against their
16641 section symbol because it holds the
16642 address of the section, not a value
16643 relative to the TLS segment. We could
16644 change the .tdata dynamic section symbol
16645 to be zero value but STN_UNDEF works
16646 and is used elsewhere, eg. for TPREL64
16647 GOT relocs against local TLS symbols. */
16648 osec
= htab
->elf
.tls_sec
;
16653 indx
= elf_section_data (osec
)->dynindx
;
16656 if ((osec
->flags
& SEC_READONLY
) == 0
16657 && htab
->elf
.data_index_section
!= NULL
)
16658 osec
= htab
->elf
.data_index_section
;
16660 osec
= htab
->elf
.text_index_section
;
16661 indx
= elf_section_data (osec
)->dynindx
;
16663 BFD_ASSERT (indx
!= 0);
16666 /* We are turning this relocation into one
16667 against a section symbol, so subtract out
16668 the output section's address but not the
16669 offset of the input section in the output
16671 outrel
.r_addend
-= osec
->vma
;
16674 outrel
.r_info
= ELF64_R_INFO (indx
, r_type
);
16678 sreloc
= elf_section_data (input_section
)->sreloc
;
16680 ? h
->elf
.type
== STT_GNU_IFUNC
16681 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
16683 sreloc
= htab
->elf
.irelplt
;
16685 htab
->local_ifunc_resolver
= 1;
16686 else if (is_static_defined (&h
->elf
))
16687 htab
->maybe_local_ifunc_resolver
= 1;
16689 if (sreloc
== NULL
)
16692 if (sreloc
->reloc_count
* sizeof (Elf64_External_Rela
)
16695 loc
= sreloc
->contents
;
16696 loc
+= sreloc
->reloc_count
++ * sizeof (Elf64_External_Rela
);
16697 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
16699 if (!warned_dynamic
16700 && !ppc64_glibc_dynamic_reloc (ELF64_R_TYPE (outrel
.r_info
)))
16702 info
->callbacks
->einfo
16703 /* xgettext:c-format */
16704 (_("%X%P: %pB: %s against %pT "
16705 "is not supported by glibc as a dynamic relocation\n"),
16707 ppc64_elf_howto_table
[ELF64_R_TYPE (outrel
.r_info
)]->name
,
16709 warned_dynamic
= TRUE
;
16712 /* If this reloc is against an external symbol, it will
16713 be computed at runtime, so there's no need to do
16714 anything now. However, for the sake of prelink ensure
16715 that the section contents are a known value. */
16718 unresolved_reloc
= FALSE
;
16719 /* The value chosen here is quite arbitrary as ld.so
16720 ignores section contents except for the special
16721 case of .opd where the contents might be accessed
16722 before relocation. Choose zero, as that won't
16723 cause reloc overflow. */
16726 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
16727 to improve backward compatibility with older
16729 if (r_type
== R_PPC64_ADDR64
)
16730 addend
= outrel
.r_addend
;
16731 /* Adjust pc_relative relocs to have zero in *r_offset. */
16732 else if (ppc64_elf_howto_table
[r_type
]->pc_relative
)
16733 addend
= outrel
.r_offset
;
16739 case R_PPC64_GLOB_DAT
:
16740 case R_PPC64_JMP_SLOT
:
16741 case R_PPC64_JMP_IREL
:
16742 case R_PPC64_RELATIVE
:
16743 /* We shouldn't ever see these dynamic relocs in relocatable
16745 /* Fall through. */
16747 case R_PPC64_PLTGOT16
:
16748 case R_PPC64_PLTGOT16_DS
:
16749 case R_PPC64_PLTGOT16_HA
:
16750 case R_PPC64_PLTGOT16_HI
:
16751 case R_PPC64_PLTGOT16_LO
:
16752 case R_PPC64_PLTGOT16_LO_DS
:
16753 case R_PPC64_PLTREL32
:
16754 case R_PPC64_PLTREL64
:
16755 /* These ones haven't been implemented yet. */
16757 info
->callbacks
->einfo
16758 /* xgettext:c-format */
16759 (_("%P: %pB: %s is not supported for `%pT'\n"),
16761 ppc64_elf_howto_table
[r_type
]->name
, sym_name
);
16763 bfd_set_error (bfd_error_invalid_operation
);
16768 /* Multi-instruction sequences that access the TOC can be
16769 optimized, eg. addis ra,r2,0; addi rb,ra,x;
16770 to nop; addi rb,r2,x; */
16776 case R_PPC64_GOT_TLSLD16_HI
:
16777 case R_PPC64_GOT_TLSGD16_HI
:
16778 case R_PPC64_GOT_TPREL16_HI
:
16779 case R_PPC64_GOT_DTPREL16_HI
:
16780 case R_PPC64_GOT16_HI
:
16781 case R_PPC64_TOC16_HI
:
16782 /* These relocs would only be useful if building up an
16783 offset to later add to r2, perhaps in an indexed
16784 addressing mode instruction. Don't try to optimize.
16785 Unfortunately, the possibility of someone building up an
16786 offset like this or even with the HA relocs, means that
16787 we need to check the high insn when optimizing the low
16791 case R_PPC64_PLTCALL_NOTOC
:
16792 if (!unresolved_reloc
)
16793 htab
->notoc_plt
= 1;
16794 /* Fall through. */
16795 case R_PPC64_PLTCALL
:
16796 if (unresolved_reloc
)
16798 /* No plt entry. Make this into a direct call. */
16799 bfd_byte
*p
= contents
+ rel
->r_offset
;
16800 insn
= bfd_get_32 (input_bfd
, p
);
16802 bfd_put_32 (input_bfd
, B_DOT
| insn
, p
);
16803 if (r_type
== R_PPC64_PLTCALL
)
16804 bfd_put_32 (input_bfd
, NOP
, p
+ 4);
16805 unresolved_reloc
= save_unresolved_reloc
;
16806 r_type
= R_PPC64_REL24
;
16810 case R_PPC64_PLTSEQ_NOTOC
:
16811 case R_PPC64_PLTSEQ
:
16812 if (unresolved_reloc
)
16814 unresolved_reloc
= FALSE
;
16819 case R_PPC64_PLT_PCREL34_NOTOC
:
16820 if (!unresolved_reloc
)
16821 htab
->notoc_plt
= 1;
16822 /* Fall through. */
16823 case R_PPC64_PLT_PCREL34
:
16824 if (unresolved_reloc
)
16826 bfd_byte
*p
= contents
+ rel
->r_offset
;
16827 bfd_put_32 (input_bfd
, PNOP
>> 32, p
);
16828 bfd_put_32 (input_bfd
, PNOP
, p
+ 4);
16829 unresolved_reloc
= FALSE
;
16834 case R_PPC64_PLT16_HA
:
16835 if (unresolved_reloc
)
16837 unresolved_reloc
= FALSE
;
16840 /* Fall through. */
16841 case R_PPC64_GOT_TLSLD16_HA
:
16842 case R_PPC64_GOT_TLSGD16_HA
:
16843 case R_PPC64_GOT_TPREL16_HA
:
16844 case R_PPC64_GOT_DTPREL16_HA
:
16845 case R_PPC64_GOT16_HA
:
16846 case R_PPC64_TOC16_HA
:
16847 if (htab
->do_toc_opt
&& relocation
+ addend
+ 0x8000 < 0x10000
16848 && !ppc64_elf_tdata (input_bfd
)->unexpected_toc_insn
)
16852 p
= contents
+ (rel
->r_offset
& ~3);
16853 bfd_put_32 (input_bfd
, NOP
, p
);
16858 case R_PPC64_PLT16_LO
:
16859 case R_PPC64_PLT16_LO_DS
:
16860 if (unresolved_reloc
)
16862 unresolved_reloc
= FALSE
;
16865 /* Fall through. */
16866 case R_PPC64_GOT_TLSLD16_LO
:
16867 case R_PPC64_GOT_TLSGD16_LO
:
16868 case R_PPC64_GOT_TPREL16_LO_DS
:
16869 case R_PPC64_GOT_DTPREL16_LO_DS
:
16870 case R_PPC64_GOT16_LO
:
16871 case R_PPC64_GOT16_LO_DS
:
16872 case R_PPC64_TOC16_LO
:
16873 case R_PPC64_TOC16_LO_DS
:
16874 if (htab
->do_toc_opt
&& relocation
+ addend
+ 0x8000 < 0x10000
16875 && !ppc64_elf_tdata (input_bfd
)->unexpected_toc_insn
)
16877 bfd_byte
*p
= contents
+ (rel
->r_offset
& ~3);
16878 insn
= bfd_get_32 (input_bfd
, p
);
16879 if ((insn
& (0x3fu
<< 26)) == 12u << 26 /* addic */)
16881 /* Transform addic to addi when we change reg. */
16882 insn
&= ~((0x3fu
<< 26) | (0x1f << 16));
16883 insn
|= (14u << 26) | (2 << 16);
16887 insn
&= ~(0x1f << 16);
16890 bfd_put_32 (input_bfd
, insn
, p
);
16894 case R_PPC64_TPREL16_HA
:
16895 if (htab
->do_tls_opt
&& relocation
+ addend
+ 0x8000 < 0x10000)
16897 bfd_byte
*p
= contents
+ (rel
->r_offset
& ~3);
16898 insn
= bfd_get_32 (input_bfd
, p
);
16899 if ((insn
& ((0x3fu
<< 26) | 0x1f << 16))
16900 != ((15u << 26) | (13 << 16)) /* addis rt,13,imm */)
16901 /* xgettext:c-format */
16902 info
->callbacks
->minfo
16903 (_("%H: warning: %s unexpected insn %#x.\n"),
16904 input_bfd
, input_section
, rel
->r_offset
,
16905 ppc64_elf_howto_table
[r_type
]->name
, insn
);
16908 bfd_put_32 (input_bfd
, NOP
, p
);
16914 case R_PPC64_TPREL16_LO
:
16915 case R_PPC64_TPREL16_LO_DS
:
16916 if (htab
->do_tls_opt
&& relocation
+ addend
+ 0x8000 < 0x10000)
16918 bfd_byte
*p
= contents
+ (rel
->r_offset
& ~3);
16919 insn
= bfd_get_32 (input_bfd
, p
);
16920 insn
&= ~(0x1f << 16);
16922 bfd_put_32 (input_bfd
, insn
, p
);
16927 /* Do any further special processing. */
16933 case R_PPC64_REL16_HA
:
16934 case R_PPC64_REL16_HIGHA
:
16935 case R_PPC64_REL16_HIGHERA
:
16936 case R_PPC64_REL16_HIGHESTA
:
16937 case R_PPC64_REL16DX_HA
:
16938 case R_PPC64_ADDR16_HA
:
16939 case R_PPC64_ADDR16_HIGHA
:
16940 case R_PPC64_ADDR16_HIGHERA
:
16941 case R_PPC64_ADDR16_HIGHESTA
:
16942 case R_PPC64_TOC16_HA
:
16943 case R_PPC64_SECTOFF_HA
:
16944 case R_PPC64_TPREL16_HA
:
16945 case R_PPC64_TPREL16_HIGHA
:
16946 case R_PPC64_TPREL16_HIGHERA
:
16947 case R_PPC64_TPREL16_HIGHESTA
:
16948 case R_PPC64_DTPREL16_HA
:
16949 case R_PPC64_DTPREL16_HIGHA
:
16950 case R_PPC64_DTPREL16_HIGHERA
:
16951 case R_PPC64_DTPREL16_HIGHESTA
:
16952 /* It's just possible that this symbol is a weak symbol
16953 that's not actually defined anywhere. In that case,
16954 'sec' would be NULL, and we should leave the symbol
16955 alone (it will be set to zero elsewhere in the link). */
16958 /* Fall through. */
16960 case R_PPC64_GOT16_HA
:
16961 case R_PPC64_PLTGOT16_HA
:
16962 case R_PPC64_PLT16_HA
:
16963 case R_PPC64_GOT_TLSGD16_HA
:
16964 case R_PPC64_GOT_TLSLD16_HA
:
16965 case R_PPC64_GOT_TPREL16_HA
:
16966 case R_PPC64_GOT_DTPREL16_HA
:
16967 /* Add 0x10000 if sign bit in 0:15 is set.
16968 Bits 0:15 are not used. */
16972 case R_PPC64_D34_HA30
:
16973 case R_PPC64_ADDR16_HIGHERA34
:
16974 case R_PPC64_ADDR16_HIGHESTA34
:
16975 case R_PPC64_REL16_HIGHERA34
:
16976 case R_PPC64_REL16_HIGHESTA34
:
16978 addend
+= 1ULL << 33;
16981 case R_PPC64_ADDR16_DS
:
16982 case R_PPC64_ADDR16_LO_DS
:
16983 case R_PPC64_GOT16_DS
:
16984 case R_PPC64_GOT16_LO_DS
:
16985 case R_PPC64_PLT16_LO_DS
:
16986 case R_PPC64_SECTOFF_DS
:
16987 case R_PPC64_SECTOFF_LO_DS
:
16988 case R_PPC64_TOC16_DS
:
16989 case R_PPC64_TOC16_LO_DS
:
16990 case R_PPC64_PLTGOT16_DS
:
16991 case R_PPC64_PLTGOT16_LO_DS
:
16992 case R_PPC64_GOT_TPREL16_DS
:
16993 case R_PPC64_GOT_TPREL16_LO_DS
:
16994 case R_PPC64_GOT_DTPREL16_DS
:
16995 case R_PPC64_GOT_DTPREL16_LO_DS
:
16996 case R_PPC64_TPREL16_DS
:
16997 case R_PPC64_TPREL16_LO_DS
:
16998 case R_PPC64_DTPREL16_DS
:
16999 case R_PPC64_DTPREL16_LO_DS
:
17000 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
17002 /* If this reloc is against an lq, lxv, or stxv insn, then
17003 the value must be a multiple of 16. This is somewhat of
17004 a hack, but the "correct" way to do this by defining _DQ
17005 forms of all the _DS relocs bloats all reloc switches in
17006 this file. It doesn't make much sense to use these
17007 relocs in data, so testing the insn should be safe. */
17008 if ((insn
& (0x3fu
<< 26)) == (56u << 26)
17009 || ((insn
& (0x3fu
<< 26)) == (61u << 26) && (insn
& 3) == 1))
17011 relocation
+= addend
;
17012 addend
= insn
& (mask
^ 3);
17013 if ((relocation
& mask
) != 0)
17015 relocation
^= relocation
& mask
;
17016 info
->callbacks
->einfo
17017 /* xgettext:c-format */
17018 (_("%H: error: %s not a multiple of %u\n"),
17019 input_bfd
, input_section
, rel
->r_offset
,
17020 ppc64_elf_howto_table
[r_type
]->name
,
17022 bfd_set_error (bfd_error_bad_value
);
17029 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
17030 because such sections are not SEC_ALLOC and thus ld.so will
17031 not process them. */
17032 howto
= ppc64_elf_howto_table
[(int) r_type
];
17033 if (unresolved_reloc
17034 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
17035 && h
->elf
.def_dynamic
)
17036 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
17037 rel
->r_offset
) != (bfd_vma
) -1)
17039 info
->callbacks
->einfo
17040 /* xgettext:c-format */
17041 (_("%H: unresolvable %s against `%pT'\n"),
17042 input_bfd
, input_section
, rel
->r_offset
,
17044 h
->elf
.root
.root
.string
);
17048 /* 16-bit fields in insns mostly have signed values, but a
17049 few insns have 16-bit unsigned values. Really, we should
17050 have different reloc types. */
17051 if (howto
->complain_on_overflow
!= complain_overflow_dont
17052 && howto
->dst_mask
== 0xffff
17053 && (input_section
->flags
& SEC_CODE
) != 0)
17055 enum complain_overflow complain
= complain_overflow_signed
;
17057 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
17058 if ((insn
& (0x3fu
<< 26)) == 10u << 26 /* cmpli */)
17059 complain
= complain_overflow_bitfield
;
17060 else if (howto
->rightshift
== 0
17061 ? ((insn
& (0x3fu
<< 26)) == 28u << 26 /* andi */
17062 || (insn
& (0x3fu
<< 26)) == 24u << 26 /* ori */
17063 || (insn
& (0x3fu
<< 26)) == 26u << 26 /* xori */)
17064 : ((insn
& (0x3fu
<< 26)) == 29u << 26 /* andis */
17065 || (insn
& (0x3fu
<< 26)) == 25u << 26 /* oris */
17066 || (insn
& (0x3fu
<< 26)) == 27u << 26 /* xoris */))
17067 complain
= complain_overflow_unsigned
;
17068 if (howto
->complain_on_overflow
!= complain
)
17070 alt_howto
= *howto
;
17071 alt_howto
.complain_on_overflow
= complain
;
17072 howto
= &alt_howto
;
17078 /* Split field relocs aren't handled by _bfd_final_link_relocate. */
17080 case R_PPC64_D34_LO
:
17081 case R_PPC64_D34_HI30
:
17082 case R_PPC64_D34_HA30
:
17083 case R_PPC64_PCREL34
:
17084 case R_PPC64_GOT_PCREL34
:
17085 case R_PPC64_TPREL34
:
17086 case R_PPC64_DTPREL34
:
17087 case R_PPC64_GOT_TLSGD34
:
17088 case R_PPC64_GOT_TLSLD34
:
17089 case R_PPC64_GOT_TPREL34
:
17090 case R_PPC64_GOT_DTPREL34
:
17091 case R_PPC64_PLT_PCREL34
:
17092 case R_PPC64_PLT_PCREL34_NOTOC
:
17094 case R_PPC64_PCREL28
:
17095 if (rel
->r_offset
+ 8 > input_section
->size
)
17096 r
= bfd_reloc_outofrange
;
17099 relocation
+= addend
;
17100 if (howto
->pc_relative
)
17101 relocation
-= (rel
->r_offset
17102 + input_section
->output_offset
17103 + input_section
->output_section
->vma
);
17104 relocation
>>= howto
->rightshift
;
17106 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
17108 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
17110 pinsn
&= ~howto
->dst_mask
;
17111 pinsn
|= (((relocation
<< 16) | (relocation
& 0xffff))
17112 & howto
->dst_mask
);
17113 bfd_put_32 (input_bfd
, pinsn
>> 32, contents
+ rel
->r_offset
);
17114 bfd_put_32 (input_bfd
, pinsn
, contents
+ rel
->r_offset
+ 4);
17116 if (howto
->complain_on_overflow
== complain_overflow_signed
17117 && (relocation
+ (1ULL << (howto
->bitsize
- 1))
17118 >= 1ULL << howto
->bitsize
))
17119 r
= bfd_reloc_overflow
;
17123 case R_PPC64_REL16DX_HA
:
17124 if (rel
->r_offset
+ 4 > input_section
->size
)
17125 r
= bfd_reloc_outofrange
;
17128 relocation
+= addend
;
17129 relocation
-= (rel
->r_offset
17130 + input_section
->output_offset
17131 + input_section
->output_section
->vma
);
17132 relocation
= (bfd_signed_vma
) relocation
>> 16;
17133 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
17135 insn
|= (relocation
& 0xffc1) | ((relocation
& 0x3e) << 15);
17136 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
17138 if (relocation
+ 0x8000 > 0xffff)
17139 r
= bfd_reloc_overflow
;
17144 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
17145 contents
, rel
->r_offset
,
17146 relocation
, addend
);
17149 if (r
!= bfd_reloc_ok
)
17151 char *more_info
= NULL
;
17152 const char *reloc_name
= howto
->name
;
17154 if (reloc_dest
!= DEST_NORMAL
)
17156 more_info
= bfd_malloc (strlen (reloc_name
) + 8);
17157 if (more_info
!= NULL
)
17159 strcpy (more_info
, reloc_name
);
17160 strcat (more_info
, (reloc_dest
== DEST_OPD
17161 ? " (OPD)" : " (stub)"));
17162 reloc_name
= more_info
;
17166 if (r
== bfd_reloc_overflow
)
17168 /* On code like "if (foo) foo();" don't report overflow
17169 on a branch to zero when foo is undefined. */
17171 && (reloc_dest
== DEST_STUB
17173 && (h
->elf
.root
.type
== bfd_link_hash_undefweak
17174 || h
->elf
.root
.type
== bfd_link_hash_undefined
)
17175 && is_branch_reloc (r_type
))))
17176 info
->callbacks
->reloc_overflow (info
, &h
->elf
.root
,
17177 sym_name
, reloc_name
,
17179 input_bfd
, input_section
,
17184 info
->callbacks
->einfo
17185 /* xgettext:c-format */
17186 (_("%H: %s against `%pT': error %d\n"),
17187 input_bfd
, input_section
, rel
->r_offset
,
17188 reloc_name
, sym_name
, (int) r
);
17191 if (more_info
!= NULL
)
17201 Elf_Internal_Shdr
*rel_hdr
;
17202 size_t deleted
= rel
- wrel
;
17204 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
17205 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
17206 if (rel_hdr
->sh_size
== 0)
17208 /* It is too late to remove an empty reloc section. Leave
17210 ??? What is wrong with an empty section??? */
17211 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
17214 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
17215 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
17216 input_section
->reloc_count
-= deleted
;
17219 /* If we're emitting relocations, then shortly after this function
17220 returns, reloc offsets and addends for this section will be
17221 adjusted. Worse, reloc symbol indices will be for the output
17222 file rather than the input. Save a copy of the relocs for
17223 opd_entry_value. */
17224 if (is_opd
&& (info
->emitrelocations
|| bfd_link_relocatable (info
)))
17227 amt
= input_section
->reloc_count
* sizeof (Elf_Internal_Rela
);
17228 rel
= bfd_alloc (input_bfd
, amt
);
17229 BFD_ASSERT (ppc64_elf_tdata (input_bfd
)->opd
.relocs
== NULL
);
17230 ppc64_elf_tdata (input_bfd
)->opd
.relocs
= rel
;
17233 memcpy (rel
, relocs
, amt
);
17238 /* Adjust the value of any local symbols in opd sections. */
17241 ppc64_elf_output_symbol_hook (struct bfd_link_info
*info
,
17242 const char *name ATTRIBUTE_UNUSED
,
17243 Elf_Internal_Sym
*elfsym
,
17244 asection
*input_sec
,
17245 struct elf_link_hash_entry
*h
)
17247 struct _opd_sec_data
*opd
;
17254 opd
= get_opd_info (input_sec
);
17255 if (opd
== NULL
|| opd
->adjust
== NULL
)
17258 value
= elfsym
->st_value
- input_sec
->output_offset
;
17259 if (!bfd_link_relocatable (info
))
17260 value
-= input_sec
->output_section
->vma
;
17262 adjust
= opd
->adjust
[OPD_NDX (value
)];
17266 elfsym
->st_value
+= adjust
;
17270 /* Finish up dynamic symbol handling. We set the contents of various
17271 dynamic sections here. */
17274 ppc64_elf_finish_dynamic_symbol (bfd
*output_bfd
,
17275 struct bfd_link_info
*info
,
17276 struct elf_link_hash_entry
*h
,
17277 Elf_Internal_Sym
*sym
)
17279 struct ppc_link_hash_table
*htab
;
17280 struct plt_entry
*ent
;
17282 htab
= ppc_hash_table (info
);
17286 if (!htab
->opd_abi
&& !h
->def_regular
)
17287 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
17288 if (ent
->plt
.offset
!= (bfd_vma
) -1)
17290 /* Mark the symbol as undefined, rather than as
17291 defined in glink. Leave the value if there were
17292 any relocations where pointer equality matters
17293 (this is a clue for the dynamic linker, to make
17294 function pointer comparisons work between an
17295 application and shared library), otherwise set it
17297 sym
->st_shndx
= SHN_UNDEF
;
17298 if (!h
->pointer_equality_needed
)
17300 else if (!h
->ref_regular_nonweak
)
17302 /* This breaks function pointer comparisons, but
17303 that is better than breaking tests for a NULL
17304 function pointer. */
17311 && (h
->root
.type
== bfd_link_hash_defined
17312 || h
->root
.type
== bfd_link_hash_defweak
)
17313 && (h
->root
.u
.def
.section
== htab
->elf
.sdynbss
17314 || h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
))
17316 /* This symbol needs a copy reloc. Set it up. */
17317 Elf_Internal_Rela rela
;
17321 if (h
->dynindx
== -1)
17324 rela
.r_offset
= defined_sym_val (h
);
17325 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_PPC64_COPY
);
17327 if (h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
17328 srel
= htab
->elf
.sreldynrelro
;
17330 srel
= htab
->elf
.srelbss
;
17331 loc
= srel
->contents
;
17332 loc
+= srel
->reloc_count
++ * sizeof (Elf64_External_Rela
);
17333 bfd_elf64_swap_reloca_out (output_bfd
, &rela
, loc
);
17339 /* Used to decide how to sort relocs in an optimal manner for the
17340 dynamic linker, before writing them out. */
17342 static enum elf_reloc_type_class
17343 ppc64_elf_reloc_type_class (const struct bfd_link_info
*info
,
17344 const asection
*rel_sec
,
17345 const Elf_Internal_Rela
*rela
)
17347 enum elf_ppc64_reloc_type r_type
;
17348 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
17350 if (rel_sec
== htab
->elf
.irelplt
)
17351 return reloc_class_ifunc
;
17353 r_type
= ELF64_R_TYPE (rela
->r_info
);
17356 case R_PPC64_RELATIVE
:
17357 return reloc_class_relative
;
17358 case R_PPC64_JMP_SLOT
:
17359 return reloc_class_plt
;
17361 return reloc_class_copy
;
17363 return reloc_class_normal
;
17367 /* Finish up the dynamic sections. */
17370 ppc64_elf_finish_dynamic_sections (bfd
*output_bfd
,
17371 struct bfd_link_info
*info
)
17373 struct ppc_link_hash_table
*htab
;
17377 htab
= ppc_hash_table (info
);
17381 dynobj
= htab
->elf
.dynobj
;
17382 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
17384 if (htab
->elf
.dynamic_sections_created
)
17386 Elf64_External_Dyn
*dyncon
, *dynconend
;
17388 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
17391 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
17392 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
17393 for (; dyncon
< dynconend
; dyncon
++)
17395 Elf_Internal_Dyn dyn
;
17398 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
17405 case DT_PPC64_GLINK
:
17407 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
17408 /* We stupidly defined DT_PPC64_GLINK to be the start
17409 of glink rather than the first entry point, which is
17410 what ld.so needs, and now have a bigger stub to
17411 support automatic multiple TOCs. */
17412 dyn
.d_un
.d_ptr
+= GLINK_PLTRESOLVE_SIZE (htab
) - 8 * 4;
17416 s
= bfd_get_section_by_name (output_bfd
, ".opd");
17419 dyn
.d_un
.d_ptr
= s
->vma
;
17423 if ((htab
->do_multi_toc
&& htab
->multi_toc_needed
)
17424 || htab
->notoc_plt
)
17425 dyn
.d_un
.d_val
|= PPC64_OPT_MULTI_TOC
;
17426 if (htab
->has_plt_localentry0
)
17427 dyn
.d_un
.d_val
|= PPC64_OPT_LOCALENTRY
;
17430 case DT_PPC64_OPDSZ
:
17431 s
= bfd_get_section_by_name (output_bfd
, ".opd");
17434 dyn
.d_un
.d_val
= s
->size
;
17438 s
= htab
->elf
.splt
;
17439 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
17443 s
= htab
->elf
.srelplt
;
17444 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
17448 dyn
.d_un
.d_val
= htab
->elf
.srelplt
->size
;
17452 if (htab
->local_ifunc_resolver
)
17453 info
->callbacks
->einfo
17454 (_("%X%P: text relocations and GNU indirect "
17455 "functions will result in a segfault at runtime\n"));
17456 else if (htab
->maybe_local_ifunc_resolver
)
17457 info
->callbacks
->einfo
17458 (_("%P: warning: text relocations and GNU indirect "
17459 "functions may result in a segfault at runtime\n"));
17463 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
17467 if (htab
->elf
.sgot
!= NULL
&& htab
->elf
.sgot
->size
!= 0
17468 && htab
->elf
.sgot
->output_section
!= bfd_abs_section_ptr
)
17470 /* Fill in the first entry in the global offset table.
17471 We use it to hold the link-time TOCbase. */
17472 bfd_put_64 (output_bfd
,
17473 elf_gp (output_bfd
) + TOC_BASE_OFF
,
17474 htab
->elf
.sgot
->contents
);
17476 /* Set .got entry size. */
17477 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
17481 if (htab
->elf
.splt
!= NULL
&& htab
->elf
.splt
->size
!= 0
17482 && htab
->elf
.splt
->output_section
!= bfd_abs_section_ptr
)
17484 /* Set .plt entry size. */
17485 elf_section_data (htab
->elf
.splt
->output_section
)->this_hdr
.sh_entsize
17486 = PLT_ENTRY_SIZE (htab
);
17489 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
17490 brlt ourselves if emitrelocations. */
17491 if (htab
->brlt
!= NULL
17492 && htab
->brlt
->reloc_count
!= 0
17493 && !_bfd_elf_link_output_relocs (output_bfd
,
17495 elf_section_data (htab
->brlt
)->rela
.hdr
,
17496 elf_section_data (htab
->brlt
)->relocs
,
17500 if (htab
->glink
!= NULL
17501 && htab
->glink
->reloc_count
!= 0
17502 && !_bfd_elf_link_output_relocs (output_bfd
,
17504 elf_section_data (htab
->glink
)->rela
.hdr
,
17505 elf_section_data (htab
->glink
)->relocs
,
17510 if (htab
->glink_eh_frame
!= NULL
17511 && htab
->glink_eh_frame
->size
!= 0
17512 && htab
->glink_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
17513 && !_bfd_elf_write_section_eh_frame (output_bfd
, info
,
17514 htab
->glink_eh_frame
,
17515 htab
->glink_eh_frame
->contents
))
17518 /* We need to handle writing out multiple GOT sections ourselves,
17519 since we didn't add them to DYNOBJ. We know dynobj is the first
17521 while ((dynobj
= dynobj
->link
.next
) != NULL
)
17525 if (!is_ppc64_elf (dynobj
))
17528 s
= ppc64_elf_tdata (dynobj
)->got
;
17531 && s
->output_section
!= bfd_abs_section_ptr
17532 && !bfd_set_section_contents (output_bfd
, s
->output_section
,
17533 s
->contents
, s
->output_offset
,
17536 s
= ppc64_elf_tdata (dynobj
)->relgot
;
17539 && s
->output_section
!= bfd_abs_section_ptr
17540 && !bfd_set_section_contents (output_bfd
, s
->output_section
,
17541 s
->contents
, s
->output_offset
,
17549 #include "elf64-target.h"
17551 /* FreeBSD support */
17553 #undef TARGET_LITTLE_SYM
17554 #undef TARGET_LITTLE_NAME
17556 #undef TARGET_BIG_SYM
17557 #define TARGET_BIG_SYM powerpc_elf64_fbsd_vec
17558 #undef TARGET_BIG_NAME
17559 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
17562 #define ELF_OSABI ELFOSABI_FREEBSD
17565 #define elf64_bed elf64_powerpc_fbsd_bed
17567 #include "elf64-target.h"