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
->relbrlt
!= NULL
)
13776 maybe_strip_output (info
, htab
->relbrlt
);
13777 if (htab
->glink_eh_frame
!= NULL
)
13778 maybe_strip_output (info
, htab
->glink_eh_frame
);
13783 /* Called after we have determined section placement. If sections
13784 move, we'll be called again. Provide a value for TOCstart. */
13787 ppc64_elf_set_toc (struct bfd_link_info
*info
, bfd
*obfd
)
13790 bfd_vma TOCstart
, adjust
;
13794 struct elf_link_hash_entry
*h
;
13795 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
13797 if (is_elf_hash_table (htab
)
13798 && htab
->hgot
!= NULL
)
13802 h
= elf_link_hash_lookup (htab
, ".TOC.", FALSE
, FALSE
, TRUE
);
13803 if (is_elf_hash_table (htab
))
13807 && h
->root
.type
== bfd_link_hash_defined
13808 && !h
->root
.linker_def
13809 && (!is_elf_hash_table (htab
)
13810 || h
->def_regular
))
13812 TOCstart
= defined_sym_val (h
) - TOC_BASE_OFF
;
13813 _bfd_set_gp_value (obfd
, TOCstart
);
13818 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
13819 order. The TOC starts where the first of these sections starts. */
13820 s
= bfd_get_section_by_name (obfd
, ".got");
13821 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13822 s
= bfd_get_section_by_name (obfd
, ".toc");
13823 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13824 s
= bfd_get_section_by_name (obfd
, ".tocbss");
13825 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13826 s
= bfd_get_section_by_name (obfd
, ".plt");
13827 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13829 /* This may happen for
13830 o references to TOC base (SYM@toc / TOC[tc0]) without a
13832 o bad linker script
13833 o --gc-sections and empty TOC sections
13835 FIXME: Warn user? */
13837 /* Look for a likely section. We probably won't even be
13839 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13840 if ((s
->flags
& (SEC_ALLOC
| SEC_SMALL_DATA
| SEC_READONLY
13842 == (SEC_ALLOC
| SEC_SMALL_DATA
))
13845 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13846 if ((s
->flags
& (SEC_ALLOC
| SEC_SMALL_DATA
| SEC_EXCLUDE
))
13847 == (SEC_ALLOC
| SEC_SMALL_DATA
))
13850 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13851 if ((s
->flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_EXCLUDE
))
13855 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13856 if ((s
->flags
& (SEC_ALLOC
| SEC_EXCLUDE
)) == SEC_ALLOC
)
13862 TOCstart
= s
->output_section
->vma
+ s
->output_offset
;
13864 /* Force alignment. */
13865 adjust
= TOCstart
& (TOC_BASE_ALIGN
- 1);
13866 TOCstart
-= adjust
;
13867 _bfd_set_gp_value (obfd
, TOCstart
);
13869 if (info
!= NULL
&& s
!= NULL
)
13871 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
13875 if (htab
->elf
.hgot
!= NULL
)
13877 htab
->elf
.hgot
->root
.u
.def
.value
= TOC_BASE_OFF
- adjust
;
13878 htab
->elf
.hgot
->root
.u
.def
.section
= s
;
13883 struct bfd_link_hash_entry
*bh
= NULL
;
13884 _bfd_generic_link_add_one_symbol (info
, obfd
, ".TOC.", BSF_GLOBAL
,
13885 s
, TOC_BASE_OFF
- adjust
,
13886 NULL
, FALSE
, FALSE
, &bh
);
13892 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
13893 write out any global entry stubs, and PLT relocations. */
13896 build_global_entry_stubs_and_plt (struct elf_link_hash_entry
*h
, void *inf
)
13898 struct bfd_link_info
*info
;
13899 struct ppc_link_hash_table
*htab
;
13900 struct plt_entry
*ent
;
13903 if (h
->root
.type
== bfd_link_hash_indirect
)
13907 htab
= ppc_hash_table (info
);
13911 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
13912 if (ent
->plt
.offset
!= (bfd_vma
) -1)
13914 /* This symbol has an entry in the procedure linkage
13915 table. Set it up. */
13916 Elf_Internal_Rela rela
;
13917 asection
*plt
, *relplt
;
13920 if (!htab
->elf
.dynamic_sections_created
13921 || h
->dynindx
== -1)
13923 if (!(h
->def_regular
13924 && (h
->root
.type
== bfd_link_hash_defined
13925 || h
->root
.type
== bfd_link_hash_defweak
)))
13927 if (h
->type
== STT_GNU_IFUNC
)
13929 plt
= htab
->elf
.iplt
;
13930 relplt
= htab
->elf
.irelplt
;
13931 htab
->local_ifunc_resolver
= 1;
13933 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_IREL
);
13935 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
13939 plt
= htab
->pltlocal
;
13940 if (bfd_link_pic (info
))
13942 relplt
= htab
->relpltlocal
;
13944 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_SLOT
);
13946 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
13951 rela
.r_addend
= defined_sym_val (h
) + ent
->addend
;
13953 if (relplt
== NULL
)
13955 loc
= plt
->contents
+ ent
->plt
.offset
;
13956 bfd_put_64 (info
->output_bfd
, rela
.r_addend
, loc
);
13959 bfd_vma toc
= elf_gp (info
->output_bfd
);
13960 toc
+= htab
->sec_info
[h
->root
.u
.def
.section
->id
].toc_off
;
13961 bfd_put_64 (info
->output_bfd
, toc
, loc
+ 8);
13966 rela
.r_offset
= (plt
->output_section
->vma
13967 + plt
->output_offset
13968 + ent
->plt
.offset
);
13969 loc
= relplt
->contents
+ (relplt
->reloc_count
++
13970 * sizeof (Elf64_External_Rela
));
13971 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rela
, loc
);
13976 rela
.r_offset
= (htab
->elf
.splt
->output_section
->vma
13977 + htab
->elf
.splt
->output_offset
13978 + ent
->plt
.offset
);
13979 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_PPC64_JMP_SLOT
);
13980 rela
.r_addend
= ent
->addend
;
13981 loc
= (htab
->elf
.srelplt
->contents
13982 + ((ent
->plt
.offset
- PLT_INITIAL_ENTRY_SIZE (htab
))
13983 / PLT_ENTRY_SIZE (htab
) * sizeof (Elf64_External_Rela
)));
13984 if (h
->type
== STT_GNU_IFUNC
&& is_static_defined (h
))
13985 htab
->maybe_local_ifunc_resolver
= 1;
13986 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rela
, loc
);
13990 if (!h
->pointer_equality_needed
)
13993 if (h
->def_regular
)
13996 s
= htab
->global_entry
;
13997 if (s
== NULL
|| s
->size
== 0)
14000 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
14001 if (ent
->plt
.offset
!= (bfd_vma
) -1
14002 && ent
->addend
== 0)
14008 p
= s
->contents
+ h
->root
.u
.def
.value
;
14009 plt
= htab
->elf
.splt
;
14010 if (!htab
->elf
.dynamic_sections_created
14011 || h
->dynindx
== -1)
14013 if (h
->type
== STT_GNU_IFUNC
)
14014 plt
= htab
->elf
.iplt
;
14016 plt
= htab
->pltlocal
;
14018 off
= ent
->plt
.offset
+ plt
->output_offset
+ plt
->output_section
->vma
;
14019 off
-= h
->root
.u
.def
.value
+ s
->output_offset
+ s
->output_section
->vma
;
14021 if (off
+ 0x80008000 > 0xffffffff || (off
& 3) != 0)
14023 info
->callbacks
->einfo
14024 (_("%P: linkage table error against `%pT'\n"),
14025 h
->root
.root
.string
);
14026 bfd_set_error (bfd_error_bad_value
);
14027 htab
->stub_error
= TRUE
;
14030 htab
->stub_count
[ppc_stub_global_entry
- 1] += 1;
14031 if (htab
->params
->emit_stub_syms
)
14033 size_t len
= strlen (h
->root
.root
.string
);
14034 char *name
= bfd_malloc (sizeof "12345678.global_entry." + len
);
14039 sprintf (name
, "%08x.global_entry.%s", s
->id
, h
->root
.root
.string
);
14040 h
= elf_link_hash_lookup (&htab
->elf
, name
, TRUE
, FALSE
, FALSE
);
14043 if (h
->root
.type
== bfd_link_hash_new
)
14045 h
->root
.type
= bfd_link_hash_defined
;
14046 h
->root
.u
.def
.section
= s
;
14047 h
->root
.u
.def
.value
= p
- s
->contents
;
14048 h
->ref_regular
= 1;
14049 h
->def_regular
= 1;
14050 h
->ref_regular_nonweak
= 1;
14051 h
->forced_local
= 1;
14053 h
->root
.linker_def
= 1;
14057 if (PPC_HA (off
) != 0)
14059 bfd_put_32 (s
->owner
, ADDIS_R12_R12
| PPC_HA (off
), p
);
14062 bfd_put_32 (s
->owner
, LD_R12_0R12
| PPC_LO (off
), p
);
14064 bfd_put_32 (s
->owner
, MTCTR_R12
, p
);
14066 bfd_put_32 (s
->owner
, BCTR
, p
);
14072 /* Write PLT relocs for locals. */
14075 write_plt_relocs_for_local_syms (struct bfd_link_info
*info
)
14077 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
14080 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
14082 struct got_entry
**lgot_ents
, **end_lgot_ents
;
14083 struct plt_entry
**local_plt
, **lplt
, **end_local_plt
;
14084 Elf_Internal_Shdr
*symtab_hdr
;
14085 bfd_size_type locsymcount
;
14086 Elf_Internal_Sym
*local_syms
= NULL
;
14087 struct plt_entry
*ent
;
14089 if (!is_ppc64_elf (ibfd
))
14092 lgot_ents
= elf_local_got_ents (ibfd
);
14096 symtab_hdr
= &elf_symtab_hdr (ibfd
);
14097 locsymcount
= symtab_hdr
->sh_info
;
14098 end_lgot_ents
= lgot_ents
+ locsymcount
;
14099 local_plt
= (struct plt_entry
**) end_lgot_ents
;
14100 end_local_plt
= local_plt
+ locsymcount
;
14101 for (lplt
= local_plt
; lplt
< end_local_plt
; ++lplt
)
14102 for (ent
= *lplt
; ent
!= NULL
; ent
= ent
->next
)
14103 if (ent
->plt
.offset
!= (bfd_vma
) -1)
14105 Elf_Internal_Sym
*sym
;
14107 asection
*plt
, *relplt
;
14111 if (!get_sym_h (NULL
, &sym
, &sym_sec
, NULL
, &local_syms
,
14112 lplt
- local_plt
, ibfd
))
14114 if (local_syms
!= NULL
14115 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
14120 val
= sym
->st_value
+ ent
->addend
;
14121 if (ELF_ST_TYPE (sym
->st_info
) != STT_GNU_IFUNC
)
14122 val
+= PPC64_LOCAL_ENTRY_OFFSET (sym
->st_other
);
14123 if (sym_sec
!= NULL
&& sym_sec
->output_section
!= NULL
)
14124 val
+= sym_sec
->output_offset
+ sym_sec
->output_section
->vma
;
14126 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
14128 htab
->local_ifunc_resolver
= 1;
14129 plt
= htab
->elf
.iplt
;
14130 relplt
= htab
->elf
.irelplt
;
14134 plt
= htab
->pltlocal
;
14135 relplt
= bfd_link_pic (info
) ? htab
->relpltlocal
: NULL
;
14138 if (relplt
== NULL
)
14140 loc
= plt
->contents
+ ent
->plt
.offset
;
14141 bfd_put_64 (info
->output_bfd
, val
, loc
);
14144 bfd_vma toc
= elf_gp (ibfd
);
14145 bfd_put_64 (info
->output_bfd
, toc
, loc
+ 8);
14150 Elf_Internal_Rela rela
;
14151 rela
.r_offset
= (ent
->plt
.offset
14152 + plt
->output_offset
14153 + plt
->output_section
->vma
);
14154 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
14157 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_IREL
);
14159 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
14164 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_SLOT
);
14166 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
14168 rela
.r_addend
= val
;
14169 loc
= relplt
->contents
+ (relplt
->reloc_count
++
14170 * sizeof (Elf64_External_Rela
));
14171 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rela
, loc
);
14175 if (local_syms
!= NULL
14176 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
14178 if (!info
->keep_memory
)
14181 symtab_hdr
->contents
= (unsigned char *) local_syms
;
14187 /* Emit the static wrapper function preserving registers around a
14188 __tls_get_addr_opt call. */
14191 emit_tga_desc (struct ppc_link_hash_table
*htab
)
14193 asection
*stub_sec
= htab
->tga_group
->stub_sec
;
14194 unsigned int cfa_updt
= 11 * 4;
14196 bfd_vma to
, from
, delta
;
14198 BFD_ASSERT (htab
->tga_desc_fd
->elf
.root
.type
== bfd_link_hash_defined
14199 && htab
->tga_desc_fd
->elf
.root
.u
.def
.section
== stub_sec
14200 && htab
->tga_desc_fd
->elf
.root
.u
.def
.value
== 0);
14201 to
= defined_sym_val (&htab
->tls_get_addr_fd
->elf
);
14202 from
= defined_sym_val (&htab
->tga_desc_fd
->elf
) + cfa_updt
;
14204 if (delta
+ (1 << 25) >= 1 << 26)
14206 _bfd_error_handler (_("__tls_get_addr call offset overflow"));
14207 htab
->stub_error
= TRUE
;
14211 p
= stub_sec
->contents
;
14212 p
= tls_get_addr_prologue (htab
->elf
.dynobj
, p
, htab
);
14213 bfd_put_32 (stub_sec
->owner
, B_DOT
| 1 | (delta
& 0x3fffffc), p
);
14215 p
= tls_get_addr_epilogue (htab
->elf
.dynobj
, p
, htab
);
14216 return stub_sec
->size
== (bfd_size_type
) (p
- stub_sec
->contents
);
14219 /* Emit eh_frame describing the static wrapper function. */
14222 emit_tga_desc_eh_frame (struct ppc_link_hash_table
*htab
, bfd_byte
*p
)
14224 unsigned int cfa_updt
= 11 * 4;
14227 *p
++ = DW_CFA_advance_loc
+ cfa_updt
/ 4;
14228 *p
++ = DW_CFA_def_cfa_offset
;
14236 *p
++ = DW_CFA_offset_extended_sf
;
14238 *p
++ = (-16 / 8) & 0x7f;
14239 for (i
= 4; i
< 12; i
++)
14241 *p
++ = DW_CFA_offset
+ i
;
14242 *p
++ = (htab
->opd_abi
? 13 : 12) - i
;
14244 *p
++ = DW_CFA_advance_loc
+ 10;
14245 *p
++ = DW_CFA_def_cfa_offset
;
14247 for (i
= 4; i
< 12; i
++)
14248 *p
++ = DW_CFA_restore
+ i
;
14249 *p
++ = DW_CFA_advance_loc
+ 2;
14250 *p
++ = DW_CFA_restore_extended
;
14255 /* Build all the stubs associated with the current output file.
14256 The stubs are kept in a hash table attached to the main linker
14257 hash table. This function is called via gldelf64ppc_finish. */
14260 ppc64_elf_build_stubs (struct bfd_link_info
*info
,
14263 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
14264 struct map_stub
*group
;
14265 asection
*stub_sec
;
14267 int stub_sec_count
= 0;
14272 /* Allocate memory to hold the linker stubs. */
14273 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14275 group
->eh_size
= 0;
14276 group
->lr_restore
= 0;
14277 if ((stub_sec
= group
->stub_sec
) != NULL
14278 && stub_sec
->size
!= 0)
14280 stub_sec
->contents
= bfd_zalloc (htab
->params
->stub_bfd
,
14282 if (stub_sec
->contents
== NULL
)
14284 stub_sec
->size
= 0;
14288 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
14293 /* Build the .glink plt call stub. */
14294 if (htab
->params
->emit_stub_syms
)
14296 struct elf_link_hash_entry
*h
;
14297 h
= elf_link_hash_lookup (&htab
->elf
, "__glink_PLTresolve",
14298 TRUE
, FALSE
, FALSE
);
14301 if (h
->root
.type
== bfd_link_hash_new
)
14303 h
->root
.type
= bfd_link_hash_defined
;
14304 h
->root
.u
.def
.section
= htab
->glink
;
14305 h
->root
.u
.def
.value
= 8;
14306 h
->ref_regular
= 1;
14307 h
->def_regular
= 1;
14308 h
->ref_regular_nonweak
= 1;
14309 h
->forced_local
= 1;
14311 h
->root
.linker_def
= 1;
14314 plt0
= (htab
->elf
.splt
->output_section
->vma
14315 + htab
->elf
.splt
->output_offset
14317 if (info
->emitrelocations
)
14319 Elf_Internal_Rela
*r
= get_relocs (htab
->glink
, 1);
14322 r
->r_offset
= (htab
->glink
->output_offset
14323 + htab
->glink
->output_section
->vma
);
14324 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL64
);
14325 r
->r_addend
= plt0
;
14327 p
= htab
->glink
->contents
;
14328 plt0
-= htab
->glink
->output_section
->vma
+ htab
->glink
->output_offset
;
14329 bfd_put_64 (htab
->glink
->owner
, plt0
, p
);
14333 bfd_put_32 (htab
->glink
->owner
, MFLR_R12
, p
);
14335 bfd_put_32 (htab
->glink
->owner
, BCL_20_31
, p
);
14337 bfd_put_32 (htab
->glink
->owner
, MFLR_R11
, p
);
14339 bfd_put_32 (htab
->glink
->owner
, LD_R2_0R11
| (-16 & 0xfffc), p
);
14341 bfd_put_32 (htab
->glink
->owner
, MTLR_R12
, p
);
14343 bfd_put_32 (htab
->glink
->owner
, ADD_R11_R2_R11
, p
);
14345 bfd_put_32 (htab
->glink
->owner
, LD_R12_0R11
, p
);
14347 bfd_put_32 (htab
->glink
->owner
, LD_R2_0R11
| 8, p
);
14349 bfd_put_32 (htab
->glink
->owner
, MTCTR_R12
, p
);
14351 bfd_put_32 (htab
->glink
->owner
, LD_R11_0R11
| 16, p
);
14356 bfd_put_32 (htab
->glink
->owner
, MFLR_R0
, p
);
14358 bfd_put_32 (htab
->glink
->owner
, BCL_20_31
, p
);
14360 bfd_put_32 (htab
->glink
->owner
, MFLR_R11
, p
);
14362 bfd_put_32 (htab
->glink
->owner
, STD_R2_0R1
+ 24, p
);
14364 bfd_put_32 (htab
->glink
->owner
, LD_R2_0R11
| (-16 & 0xfffc), p
);
14366 bfd_put_32 (htab
->glink
->owner
, MTLR_R0
, p
);
14368 bfd_put_32 (htab
->glink
->owner
, SUB_R12_R12_R11
, p
);
14370 bfd_put_32 (htab
->glink
->owner
, ADD_R11_R2_R11
, p
);
14372 bfd_put_32 (htab
->glink
->owner
, ADDI_R0_R12
| (-48 & 0xffff), p
);
14374 bfd_put_32 (htab
->glink
->owner
, LD_R12_0R11
, p
);
14376 bfd_put_32 (htab
->glink
->owner
, SRDI_R0_R0_2
, p
);
14378 bfd_put_32 (htab
->glink
->owner
, MTCTR_R12
, p
);
14380 bfd_put_32 (htab
->glink
->owner
, LD_R11_0R11
| 8, p
);
14383 bfd_put_32 (htab
->glink
->owner
, BCTR
, p
);
14385 BFD_ASSERT (p
== htab
->glink
->contents
+ GLINK_PLTRESOLVE_SIZE (htab
));
14387 /* Build the .glink lazy link call stubs. */
14389 while (p
< htab
->glink
->contents
+ htab
->glink
->size
)
14395 bfd_put_32 (htab
->glink
->owner
, LI_R0_0
| indx
, p
);
14400 bfd_put_32 (htab
->glink
->owner
, LIS_R0_0
| PPC_HI (indx
), p
);
14402 bfd_put_32 (htab
->glink
->owner
, ORI_R0_R0_0
| PPC_LO (indx
),
14407 bfd_put_32 (htab
->glink
->owner
,
14408 B_DOT
| ((htab
->glink
->contents
- p
+ 8) & 0x3fffffc), p
);
14414 if (htab
->tga_group
!= NULL
)
14416 htab
->tga_group
->lr_restore
= 23 * 4;
14417 htab
->tga_group
->stub_sec
->size
= 24 * 4;
14418 if (!emit_tga_desc (htab
))
14420 if (htab
->glink_eh_frame
!= NULL
14421 && htab
->glink_eh_frame
->size
!= 0)
14425 p
= htab
->glink_eh_frame
->contents
;
14426 p
+= (sizeof (glink_eh_frame_cie
) + align
- 1) & -align
;
14428 htab
->tga_group
->eh_size
= emit_tga_desc_eh_frame (htab
, p
) - p
;
14432 /* Build .glink global entry stubs, and PLT relocs for globals. */
14433 elf_link_hash_traverse (&htab
->elf
, build_global_entry_stubs_and_plt
, info
);
14435 if (!write_plt_relocs_for_local_syms (info
))
14438 if (htab
->brlt
!= NULL
&& htab
->brlt
->size
!= 0)
14440 htab
->brlt
->contents
= bfd_zalloc (htab
->brlt
->owner
,
14442 if (htab
->brlt
->contents
== NULL
)
14445 if (htab
->relbrlt
!= NULL
&& htab
->relbrlt
->size
!= 0)
14447 htab
->relbrlt
->contents
= bfd_zalloc (htab
->relbrlt
->owner
,
14448 htab
->relbrlt
->size
);
14449 if (htab
->relbrlt
->contents
== NULL
)
14453 /* Build the stubs as directed by the stub hash table. */
14454 bfd_hash_traverse (&htab
->stub_hash_table
, ppc_build_one_stub
, info
);
14456 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14457 if (group
->needs_save_res
)
14458 group
->stub_sec
->size
+= htab
->sfpr
->size
;
14460 if (htab
->relbrlt
!= NULL
)
14461 htab
->relbrlt
->reloc_count
= 0;
14463 if (htab
->params
->plt_stub_align
!= 0)
14464 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14465 if ((stub_sec
= group
->stub_sec
) != NULL
)
14467 int align
= abs (htab
->params
->plt_stub_align
);
14468 stub_sec
->size
= (stub_sec
->size
+ (1 << align
) - 1) & -(1 << align
);
14471 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14472 if (group
->needs_save_res
)
14474 stub_sec
= group
->stub_sec
;
14475 memcpy (stub_sec
->contents
+ stub_sec
->size
- htab
->sfpr
->size
,
14476 htab
->sfpr
->contents
, htab
->sfpr
->size
);
14477 if (htab
->params
->emit_stub_syms
)
14481 for (i
= 0; i
< ARRAY_SIZE (save_res_funcs
); i
++)
14482 if (!sfpr_define (info
, &save_res_funcs
[i
], stub_sec
))
14487 if (htab
->glink_eh_frame
!= NULL
14488 && htab
->glink_eh_frame
->size
!= 0)
14493 p
= htab
->glink_eh_frame
->contents
;
14494 p
+= (sizeof (glink_eh_frame_cie
) + align
- 1) & -align
;
14496 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14497 if (group
->eh_size
!= 0)
14499 /* Offset to stub section. */
14500 val
= (group
->stub_sec
->output_section
->vma
14501 + group
->stub_sec
->output_offset
);
14502 val
-= (htab
->glink_eh_frame
->output_section
->vma
14503 + htab
->glink_eh_frame
->output_offset
14504 + (p
+ 8 - htab
->glink_eh_frame
->contents
));
14505 if (val
+ 0x80000000 > 0xffffffff)
14508 (_("%s offset too large for .eh_frame sdata4 encoding"),
14509 group
->stub_sec
->name
);
14512 bfd_put_32 (htab
->elf
.dynobj
, val
, p
+ 8);
14513 p
+= (group
->eh_size
+ 17 + 3) & -4;
14515 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
14517 /* Offset to .glink. */
14518 val
= (htab
->glink
->output_section
->vma
14519 + htab
->glink
->output_offset
14521 val
-= (htab
->glink_eh_frame
->output_section
->vma
14522 + htab
->glink_eh_frame
->output_offset
14523 + (p
+ 8 - htab
->glink_eh_frame
->contents
));
14524 if (val
+ 0x80000000 > 0xffffffff)
14527 (_("%s offset too large for .eh_frame sdata4 encoding"),
14528 htab
->glink
->name
);
14531 bfd_put_32 (htab
->elf
.dynobj
, val
, p
+ 8);
14532 p
+= (24 + align
- 1) & -align
;
14536 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14537 if ((stub_sec
= group
->stub_sec
) != NULL
)
14539 stub_sec_count
+= 1;
14540 if (stub_sec
->rawsize
!= stub_sec
->size
14541 && (htab
->stub_iteration
<= STUB_SHRINK_ITER
14542 || stub_sec
->rawsize
< stub_sec
->size
))
14548 htab
->stub_error
= TRUE
;
14549 _bfd_error_handler (_("stubs don't match calculated size"));
14552 if (htab
->stub_error
)
14558 if (asprintf (&groupmsg
,
14559 ngettext ("linker stubs in %u group\n",
14560 "linker stubs in %u groups\n",
14562 stub_sec_count
) < 0)
14566 if (asprintf (stats
, _("%s"
14568 " branch toc adj %lu\n"
14569 " branch notoc %lu\n"
14570 " branch both %lu\n"
14571 " long branch %lu\n"
14572 " long toc adj %lu\n"
14573 " long notoc %lu\n"
14576 " plt call save %lu\n"
14577 " plt call notoc %lu\n"
14578 " plt call both %lu\n"
14579 " global entry %lu"),
14581 htab
->stub_count
[ppc_stub_long_branch
- 1],
14582 htab
->stub_count
[ppc_stub_long_branch_r2off
- 1],
14583 htab
->stub_count
[ppc_stub_long_branch_notoc
- 1],
14584 htab
->stub_count
[ppc_stub_long_branch_both
- 1],
14585 htab
->stub_count
[ppc_stub_plt_branch
- 1],
14586 htab
->stub_count
[ppc_stub_plt_branch_r2off
- 1],
14587 htab
->stub_count
[ppc_stub_plt_branch_notoc
- 1],
14588 htab
->stub_count
[ppc_stub_plt_branch_both
- 1],
14589 htab
->stub_count
[ppc_stub_plt_call
- 1],
14590 htab
->stub_count
[ppc_stub_plt_call_r2save
- 1],
14591 htab
->stub_count
[ppc_stub_plt_call_notoc
- 1],
14592 htab
->stub_count
[ppc_stub_plt_call_both
- 1],
14593 htab
->stub_count
[ppc_stub_global_entry
- 1]) < 0)
14601 /* What to do when ld finds relocations against symbols defined in
14602 discarded sections. */
14604 static unsigned int
14605 ppc64_elf_action_discarded (asection
*sec
)
14607 if (strcmp (".opd", sec
->name
) == 0)
14610 if (strcmp (".toc", sec
->name
) == 0)
14613 if (strcmp (".toc1", sec
->name
) == 0)
14616 return _bfd_elf_default_action_discarded (sec
);
14619 /* These are the dynamic relocations supported by glibc. */
14622 ppc64_glibc_dynamic_reloc (enum elf_ppc64_reloc_type r_type
)
14626 case R_PPC64_RELATIVE
:
14628 case R_PPC64_ADDR64
:
14629 case R_PPC64_GLOB_DAT
:
14630 case R_PPC64_IRELATIVE
:
14631 case R_PPC64_JMP_IREL
:
14632 case R_PPC64_JMP_SLOT
:
14633 case R_PPC64_DTPMOD64
:
14634 case R_PPC64_DTPREL64
:
14635 case R_PPC64_TPREL64
:
14636 case R_PPC64_TPREL16_LO_DS
:
14637 case R_PPC64_TPREL16_DS
:
14638 case R_PPC64_TPREL16
:
14639 case R_PPC64_TPREL16_LO
:
14640 case R_PPC64_TPREL16_HI
:
14641 case R_PPC64_TPREL16_HIGH
:
14642 case R_PPC64_TPREL16_HA
:
14643 case R_PPC64_TPREL16_HIGHA
:
14644 case R_PPC64_TPREL16_HIGHER
:
14645 case R_PPC64_TPREL16_HIGHEST
:
14646 case R_PPC64_TPREL16_HIGHERA
:
14647 case R_PPC64_TPREL16_HIGHESTA
:
14648 case R_PPC64_ADDR16_LO_DS
:
14649 case R_PPC64_ADDR16_LO
:
14650 case R_PPC64_ADDR16_HI
:
14651 case R_PPC64_ADDR16_HIGH
:
14652 case R_PPC64_ADDR16_HA
:
14653 case R_PPC64_ADDR16_HIGHA
:
14654 case R_PPC64_REL30
:
14656 case R_PPC64_UADDR64
:
14657 case R_PPC64_UADDR32
:
14658 case R_PPC64_ADDR32
:
14659 case R_PPC64_ADDR24
:
14660 case R_PPC64_ADDR16
:
14661 case R_PPC64_UADDR16
:
14662 case R_PPC64_ADDR16_DS
:
14663 case R_PPC64_ADDR16_HIGHER
:
14664 case R_PPC64_ADDR16_HIGHEST
:
14665 case R_PPC64_ADDR16_HIGHERA
:
14666 case R_PPC64_ADDR16_HIGHESTA
:
14667 case R_PPC64_ADDR14
:
14668 case R_PPC64_ADDR14_BRTAKEN
:
14669 case R_PPC64_ADDR14_BRNTAKEN
:
14670 case R_PPC64_REL32
:
14671 case R_PPC64_REL64
:
14679 /* The RELOCATE_SECTION function is called by the ELF backend linker
14680 to handle the relocations for a section.
14682 The relocs are always passed as Rela structures; if the section
14683 actually uses Rel structures, the r_addend field will always be
14686 This function is responsible for adjust the section contents as
14687 necessary, and (if using Rela relocs and generating a
14688 relocatable output file) adjusting the reloc addend as
14691 This function does not have to worry about setting the reloc
14692 address or the reloc symbol index.
14694 LOCAL_SYMS is a pointer to the swapped in local symbols.
14696 LOCAL_SECTIONS is an array giving the section in the input file
14697 corresponding to the st_shndx field of each local symbol.
14699 The global hash table entry for the global symbols can be found
14700 via elf_sym_hashes (input_bfd).
14702 When generating relocatable output, this function must handle
14703 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
14704 going to be the section symbol corresponding to the output
14705 section, which means that the addend must be adjusted
14709 ppc64_elf_relocate_section (bfd
*output_bfd
,
14710 struct bfd_link_info
*info
,
14712 asection
*input_section
,
14713 bfd_byte
*contents
,
14714 Elf_Internal_Rela
*relocs
,
14715 Elf_Internal_Sym
*local_syms
,
14716 asection
**local_sections
)
14718 struct ppc_link_hash_table
*htab
;
14719 Elf_Internal_Shdr
*symtab_hdr
;
14720 struct elf_link_hash_entry
**sym_hashes
;
14721 Elf_Internal_Rela
*rel
;
14722 Elf_Internal_Rela
*wrel
;
14723 Elf_Internal_Rela
*relend
;
14724 Elf_Internal_Rela outrel
;
14726 struct got_entry
**local_got_ents
;
14728 bfd_boolean ret
= TRUE
;
14729 bfd_boolean is_opd
;
14730 /* Assume 'at' branch hints. */
14731 bfd_boolean is_isa_v2
= TRUE
;
14732 bfd_boolean warned_dynamic
= FALSE
;
14733 bfd_vma d_offset
= (bfd_big_endian (input_bfd
) ? 2 : 0);
14735 /* Initialize howto table if needed. */
14736 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
14739 htab
= ppc_hash_table (info
);
14743 /* Don't relocate stub sections. */
14744 if (input_section
->owner
== htab
->params
->stub_bfd
)
14747 if (!is_ppc64_elf (input_bfd
))
14749 bfd_set_error (bfd_error_wrong_format
);
14753 local_got_ents
= elf_local_got_ents (input_bfd
);
14754 TOCstart
= elf_gp (output_bfd
);
14755 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
14756 sym_hashes
= elf_sym_hashes (input_bfd
);
14757 is_opd
= ppc64_elf_section_data (input_section
)->sec_type
== sec_opd
;
14759 rel
= wrel
= relocs
;
14760 relend
= relocs
+ input_section
->reloc_count
;
14761 for (; rel
< relend
; wrel
++, rel
++)
14763 enum elf_ppc64_reloc_type r_type
;
14765 bfd_reloc_status_type r
;
14766 Elf_Internal_Sym
*sym
;
14768 struct elf_link_hash_entry
*h_elf
;
14769 struct ppc_link_hash_entry
*h
;
14770 struct ppc_link_hash_entry
*fdh
;
14771 const char *sym_name
;
14772 unsigned long r_symndx
, toc_symndx
;
14773 bfd_vma toc_addend
;
14774 unsigned char tls_mask
, tls_gd
, tls_type
;
14775 unsigned char sym_type
;
14776 bfd_vma relocation
;
14777 bfd_boolean unresolved_reloc
, save_unresolved_reloc
;
14778 bfd_boolean warned
;
14779 enum { DEST_NORMAL
, DEST_OPD
, DEST_STUB
} reloc_dest
;
14782 struct ppc_stub_hash_entry
*stub_entry
;
14783 bfd_vma max_br_offset
;
14785 Elf_Internal_Rela orig_rel
;
14786 reloc_howto_type
*howto
;
14787 struct reloc_howto_struct alt_howto
;
14794 r_type
= ELF64_R_TYPE (rel
->r_info
);
14795 r_symndx
= ELF64_R_SYM (rel
->r_info
);
14797 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
14798 symbol of the previous ADDR64 reloc. The symbol gives us the
14799 proper TOC base to use. */
14800 if (rel
->r_info
== ELF64_R_INFO (0, R_PPC64_TOC
)
14802 && ELF64_R_TYPE (wrel
[-1].r_info
) == R_PPC64_ADDR64
14804 r_symndx
= ELF64_R_SYM (wrel
[-1].r_info
);
14810 unresolved_reloc
= FALSE
;
14813 if (r_symndx
< symtab_hdr
->sh_info
)
14815 /* It's a local symbol. */
14816 struct _opd_sec_data
*opd
;
14818 sym
= local_syms
+ r_symndx
;
14819 sec
= local_sections
[r_symndx
];
14820 sym_name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
, sec
);
14821 sym_type
= ELF64_ST_TYPE (sym
->st_info
);
14822 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
14823 opd
= get_opd_info (sec
);
14824 if (opd
!= NULL
&& opd
->adjust
!= NULL
)
14826 long adjust
= opd
->adjust
[OPD_NDX (sym
->st_value
14832 /* If this is a relocation against the opd section sym
14833 and we have edited .opd, adjust the reloc addend so
14834 that ld -r and ld --emit-relocs output is correct.
14835 If it is a reloc against some other .opd symbol,
14836 then the symbol value will be adjusted later. */
14837 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
14838 rel
->r_addend
+= adjust
;
14840 relocation
+= adjust
;
14846 bfd_boolean ignored
;
14848 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
14849 r_symndx
, symtab_hdr
, sym_hashes
,
14850 h_elf
, sec
, relocation
,
14851 unresolved_reloc
, warned
, ignored
);
14852 sym_name
= h_elf
->root
.root
.string
;
14853 sym_type
= h_elf
->type
;
14855 && sec
->owner
== output_bfd
14856 && strcmp (sec
->name
, ".opd") == 0)
14858 /* This is a symbol defined in a linker script. All
14859 such are defined in output sections, even those
14860 defined by simple assignment from a symbol defined in
14861 an input section. Transfer the symbol to an
14862 appropriate input .opd section, so that a branch to
14863 this symbol will be mapped to the location specified
14864 by the opd entry. */
14865 struct bfd_link_order
*lo
;
14866 for (lo
= sec
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
14867 if (lo
->type
== bfd_indirect_link_order
)
14869 asection
*isec
= lo
->u
.indirect
.section
;
14870 if (h_elf
->root
.u
.def
.value
>= isec
->output_offset
14871 && h_elf
->root
.u
.def
.value
< (isec
->output_offset
14874 h_elf
->root
.u
.def
.value
-= isec
->output_offset
;
14875 h_elf
->root
.u
.def
.section
= isec
;
14882 h
= ppc_elf_hash_entry (h_elf
);
14884 if (sec
!= NULL
&& discarded_section (sec
))
14886 _bfd_clear_contents (ppc64_elf_howto_table
[r_type
],
14887 input_bfd
, input_section
,
14888 contents
, rel
->r_offset
);
14889 wrel
->r_offset
= rel
->r_offset
;
14891 wrel
->r_addend
= 0;
14893 /* For ld -r, remove relocations in debug sections against
14894 symbols defined in discarded sections. Not done for
14895 non-debug to preserve relocs in .eh_frame which the
14896 eh_frame editing code expects to be present. */
14897 if (bfd_link_relocatable (info
)
14898 && (input_section
->flags
& SEC_DEBUGGING
))
14904 if (bfd_link_relocatable (info
))
14907 if (h
!= NULL
&& &h
->elf
== htab
->elf
.hgot
)
14909 relocation
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
14910 sec
= bfd_abs_section_ptr
;
14911 unresolved_reloc
= FALSE
;
14914 /* TLS optimizations. Replace instruction sequences and relocs
14915 based on information we collected in tls_optimize. We edit
14916 RELOCS so that --emit-relocs will output something sensible
14917 for the final instruction stream. */
14922 tls_mask
= h
->tls_mask
;
14923 else if (local_got_ents
!= NULL
)
14925 struct plt_entry
**local_plt
= (struct plt_entry
**)
14926 (local_got_ents
+ symtab_hdr
->sh_info
);
14927 unsigned char *lgot_masks
= (unsigned char *)
14928 (local_plt
+ symtab_hdr
->sh_info
);
14929 tls_mask
= lgot_masks
[r_symndx
];
14931 if (((tls_mask
& TLS_TLS
) == 0 || tls_mask
== (TLS_TLS
| TLS_MARK
))
14932 && (r_type
== R_PPC64_TLS
14933 || r_type
== R_PPC64_TLSGD
14934 || r_type
== R_PPC64_TLSLD
))
14936 /* Check for toc tls entries. */
14937 unsigned char *toc_tls
;
14939 if (!get_tls_mask (&toc_tls
, &toc_symndx
, &toc_addend
,
14940 &local_syms
, rel
, input_bfd
))
14944 tls_mask
= *toc_tls
;
14947 /* Check that tls relocs are used with tls syms, and non-tls
14948 relocs are used with non-tls syms. */
14949 if (r_symndx
!= STN_UNDEF
14950 && r_type
!= R_PPC64_NONE
14952 || h
->elf
.root
.type
== bfd_link_hash_defined
14953 || h
->elf
.root
.type
== bfd_link_hash_defweak
)
14954 && IS_PPC64_TLS_RELOC (r_type
) != (sym_type
== STT_TLS
))
14956 if ((tls_mask
& TLS_TLS
) != 0
14957 && (r_type
== R_PPC64_TLS
14958 || r_type
== R_PPC64_TLSGD
14959 || r_type
== R_PPC64_TLSLD
))
14960 /* R_PPC64_TLS is OK against a symbol in the TOC. */
14963 info
->callbacks
->einfo
14964 (!IS_PPC64_TLS_RELOC (r_type
)
14965 /* xgettext:c-format */
14966 ? _("%H: %s used with TLS symbol `%pT'\n")
14967 /* xgettext:c-format */
14968 : _("%H: %s used with non-TLS symbol `%pT'\n"),
14969 input_bfd
, input_section
, rel
->r_offset
,
14970 ppc64_elf_howto_table
[r_type
]->name
,
14974 /* Ensure reloc mapping code below stays sane. */
14975 if (R_PPC64_TOC16_LO_DS
!= R_PPC64_TOC16_DS
+ 1
14976 || R_PPC64_TOC16_LO
!= R_PPC64_TOC16
+ 1
14977 || (R_PPC64_GOT_TLSLD16
& 3) != (R_PPC64_GOT_TLSGD16
& 3)
14978 || (R_PPC64_GOT_TLSLD16_LO
& 3) != (R_PPC64_GOT_TLSGD16_LO
& 3)
14979 || (R_PPC64_GOT_TLSLD16_HI
& 3) != (R_PPC64_GOT_TLSGD16_HI
& 3)
14980 || (R_PPC64_GOT_TLSLD16_HA
& 3) != (R_PPC64_GOT_TLSGD16_HA
& 3)
14981 || (R_PPC64_GOT_TLSLD16
& 3) != (R_PPC64_GOT_TPREL16_DS
& 3)
14982 || (R_PPC64_GOT_TLSLD16_LO
& 3) != (R_PPC64_GOT_TPREL16_LO_DS
& 3)
14983 || (R_PPC64_GOT_TLSLD16_HI
& 3) != (R_PPC64_GOT_TPREL16_HI
& 3)
14984 || (R_PPC64_GOT_TLSLD16_HA
& 3) != (R_PPC64_GOT_TPREL16_HA
& 3))
14992 case R_PPC64_LO_DS_OPT
:
14993 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
- d_offset
);
14994 if ((insn
& (0x3fu
<< 26)) != 58u << 26)
14996 insn
+= (14u << 26) - (58u << 26);
14997 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
- d_offset
);
14998 r_type
= R_PPC64_TOC16_LO
;
14999 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15002 case R_PPC64_TOC16
:
15003 case R_PPC64_TOC16_LO
:
15004 case R_PPC64_TOC16_DS
:
15005 case R_PPC64_TOC16_LO_DS
:
15007 /* Check for toc tls entries. */
15008 unsigned char *toc_tls
;
15011 retval
= get_tls_mask (&toc_tls
, &toc_symndx
, &toc_addend
,
15012 &local_syms
, rel
, input_bfd
);
15018 tls_mask
= *toc_tls
;
15019 if (r_type
== R_PPC64_TOC16_DS
15020 || r_type
== R_PPC64_TOC16_LO_DS
)
15022 if ((tls_mask
& TLS_TLS
) != 0
15023 && (tls_mask
& (TLS_DTPREL
| TLS_TPREL
)) == 0)
15028 /* If we found a GD reloc pair, then we might be
15029 doing a GD->IE transition. */
15033 if ((tls_mask
& TLS_TLS
) != 0
15034 && (tls_mask
& TLS_GD
) == 0)
15037 else if (retval
== 3)
15039 if ((tls_mask
& TLS_TLS
) != 0
15040 && (tls_mask
& TLS_LD
) == 0)
15048 case R_PPC64_GOT_TPREL16_HI
:
15049 case R_PPC64_GOT_TPREL16_HA
:
15050 if ((tls_mask
& TLS_TLS
) != 0
15051 && (tls_mask
& TLS_TPREL
) == 0)
15053 rel
->r_offset
-= d_offset
;
15054 bfd_put_32 (input_bfd
, NOP
, contents
+ rel
->r_offset
);
15055 r_type
= R_PPC64_NONE
;
15056 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15060 case R_PPC64_GOT_TPREL16_DS
:
15061 case R_PPC64_GOT_TPREL16_LO_DS
:
15062 if ((tls_mask
& TLS_TLS
) != 0
15063 && (tls_mask
& TLS_TPREL
) == 0)
15066 insn
= bfd_get_32 (input_bfd
,
15067 contents
+ rel
->r_offset
- d_offset
);
15069 insn
|= 0x3c0d0000; /* addis 0,13,0 */
15070 bfd_put_32 (input_bfd
, insn
,
15071 contents
+ rel
->r_offset
- d_offset
);
15072 r_type
= R_PPC64_TPREL16_HA
;
15073 if (toc_symndx
!= 0)
15075 rel
->r_info
= ELF64_R_INFO (toc_symndx
, r_type
);
15076 rel
->r_addend
= toc_addend
;
15077 /* We changed the symbol. Start over in order to
15078 get h, sym, sec etc. right. */
15082 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15086 case R_PPC64_GOT_TPREL34
:
15087 if ((tls_mask
& TLS_TLS
) != 0
15088 && (tls_mask
& TLS_TPREL
) == 0)
15090 /* pld ra,sym@got@tprel@pcrel -> paddi ra,r13,sym@tprel */
15091 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15093 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15094 pinsn
+= ((2ULL << 56) + (-1ULL << 52)
15095 + (14ULL << 26) - (57ULL << 26) + (13ULL << 16));
15096 bfd_put_32 (input_bfd
, pinsn
>> 32,
15097 contents
+ rel
->r_offset
);
15098 bfd_put_32 (input_bfd
, pinsn
& 0xffffffff,
15099 contents
+ rel
->r_offset
+ 4);
15100 r_type
= R_PPC64_TPREL34
;
15101 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15106 if ((tls_mask
& TLS_TLS
) != 0
15107 && (tls_mask
& TLS_TPREL
) == 0)
15109 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
15110 insn
= _bfd_elf_ppc_at_tls_transform (insn
, 13);
15113 if ((rel
->r_offset
& 3) == 0)
15115 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
15116 /* Was PPC64_TLS which sits on insn boundary, now
15117 PPC64_TPREL16_LO which is at low-order half-word. */
15118 rel
->r_offset
+= d_offset
;
15119 r_type
= R_PPC64_TPREL16_LO
;
15120 if (toc_symndx
!= 0)
15122 rel
->r_info
= ELF64_R_INFO (toc_symndx
, r_type
);
15123 rel
->r_addend
= toc_addend
;
15124 /* We changed the symbol. Start over in order to
15125 get h, sym, sec etc. right. */
15129 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15131 else if ((rel
->r_offset
& 3) == 1)
15133 /* For pcrel IE to LE we already have the full
15134 offset and thus don't need an addi here. A nop
15136 if ((insn
& (0x3fu
<< 26)) == 14 << 26)
15138 /* Extract regs from addi rt,ra,si. */
15139 unsigned int rt
= (insn
>> 21) & 0x1f;
15140 unsigned int ra
= (insn
>> 16) & 0x1f;
15145 /* Build or ra,rs,rb with rb==rs, ie. mr ra,rs. */
15146 insn
= (rt
<< 16) | (ra
<< 21) | (ra
<< 11);
15147 insn
|= (31u << 26) | (444u << 1);
15150 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
- 1);
15155 case R_PPC64_GOT_TLSGD16_HI
:
15156 case R_PPC64_GOT_TLSGD16_HA
:
15158 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0)
15162 case R_PPC64_GOT_TLSLD16_HI
:
15163 case R_PPC64_GOT_TLSLD16_HA
:
15164 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0)
15167 if ((tls_mask
& tls_gd
) != 0)
15168 r_type
= (((r_type
- (R_PPC64_GOT_TLSGD16
& 3)) & 3)
15169 + R_PPC64_GOT_TPREL16_DS
);
15172 rel
->r_offset
-= d_offset
;
15173 bfd_put_32 (input_bfd
, NOP
, contents
+ rel
->r_offset
);
15174 r_type
= R_PPC64_NONE
;
15176 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15180 case R_PPC64_GOT_TLSGD16
:
15181 case R_PPC64_GOT_TLSGD16_LO
:
15183 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0)
15187 case R_PPC64_GOT_TLSLD16
:
15188 case R_PPC64_GOT_TLSLD16_LO
:
15189 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0)
15191 unsigned int insn1
, insn2
;
15194 offset
= (bfd_vma
) -1;
15195 /* If not using the newer R_PPC64_TLSGD/LD to mark
15196 __tls_get_addr calls, we must trust that the call
15197 stays with its arg setup insns, ie. that the next
15198 reloc is the __tls_get_addr call associated with
15199 the current reloc. Edit both insns. */
15200 if (input_section
->nomark_tls_get_addr
15201 && rel
+ 1 < relend
15202 && branch_reloc_hash_match (input_bfd
, rel
+ 1,
15203 htab
->tls_get_addr_fd
,
15205 htab
->tls_get_addr
,
15207 offset
= rel
[1].r_offset
;
15208 /* We read the low GOT_TLS (or TOC16) insn because we
15209 need to keep the destination reg. It may be
15210 something other than the usual r3, and moved to r3
15211 before the call by intervening code. */
15212 insn1
= bfd_get_32 (input_bfd
,
15213 contents
+ rel
->r_offset
- d_offset
);
15214 if ((tls_mask
& tls_gd
) != 0)
15217 insn1
&= (0x1f << 21) | (0x1f << 16);
15218 insn1
|= 58u << 26; /* ld */
15219 insn2
= 0x7c636a14; /* add 3,3,13 */
15220 if (offset
!= (bfd_vma
) -1)
15221 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
15222 if (r_type
== R_PPC64_TOC16
15223 || r_type
== R_PPC64_TOC16_LO
)
15224 r_type
+= R_PPC64_TOC16_DS
- R_PPC64_TOC16
;
15226 r_type
= (((r_type
- (R_PPC64_GOT_TLSGD16
& 1)) & 1)
15227 + R_PPC64_GOT_TPREL16_DS
);
15228 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15233 insn1
&= 0x1f << 21;
15234 insn1
|= 0x3c0d0000; /* addis r,13,0 */
15235 insn2
= 0x38630000; /* addi 3,3,0 */
15238 /* Was an LD reloc. */
15239 r_symndx
= STN_UNDEF
;
15240 rel
->r_addend
= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
15242 else if (toc_symndx
!= 0)
15244 r_symndx
= toc_symndx
;
15245 rel
->r_addend
= toc_addend
;
15247 r_type
= R_PPC64_TPREL16_HA
;
15248 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15249 if (offset
!= (bfd_vma
) -1)
15251 rel
[1].r_info
= ELF64_R_INFO (r_symndx
,
15252 R_PPC64_TPREL16_LO
);
15253 rel
[1].r_offset
= offset
+ d_offset
;
15254 rel
[1].r_addend
= rel
->r_addend
;
15257 bfd_put_32 (input_bfd
, insn1
,
15258 contents
+ rel
->r_offset
- d_offset
);
15259 if (offset
!= (bfd_vma
) -1)
15261 bfd_put_32 (input_bfd
, insn2
, contents
+ offset
);
15262 if (offset
+ 8 <= input_section
->size
)
15264 insn2
= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
15265 if (insn2
== LD_R2_0R1
+ STK_TOC (htab
))
15266 bfd_put_32 (input_bfd
, NOP
, contents
+ offset
+ 4);
15269 if ((tls_mask
& tls_gd
) == 0
15270 && (tls_gd
== 0 || toc_symndx
!= 0))
15272 /* We changed the symbol. Start over in order
15273 to get h, sym, sec etc. right. */
15279 case R_PPC64_GOT_TLSGD34
:
15280 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0)
15282 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15284 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15285 if ((tls_mask
& TLS_GDIE
) != 0)
15287 /* IE, pla -> pld */
15288 pinsn
+= (-2ULL << 56) + (57ULL << 26) - (14ULL << 26);
15289 r_type
= R_PPC64_GOT_TPREL34
;
15293 /* LE, pla pcrel -> paddi r13 */
15294 pinsn
+= (-1ULL << 52) + (13ULL << 16);
15295 r_type
= R_PPC64_TPREL34
;
15297 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15298 bfd_put_32 (input_bfd
, pinsn
>> 32,
15299 contents
+ rel
->r_offset
);
15300 bfd_put_32 (input_bfd
, pinsn
& 0xffffffff,
15301 contents
+ rel
->r_offset
+ 4);
15305 case R_PPC64_GOT_TLSLD34
:
15306 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0)
15308 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15310 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15311 pinsn
+= (-1ULL << 52) + (13ULL << 16);
15312 bfd_put_32 (input_bfd
, pinsn
>> 32,
15313 contents
+ rel
->r_offset
);
15314 bfd_put_32 (input_bfd
, pinsn
& 0xffffffff,
15315 contents
+ rel
->r_offset
+ 4);
15316 rel
->r_addend
= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
15317 r_symndx
= STN_UNDEF
;
15318 r_type
= R_PPC64_TPREL34
;
15319 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15324 case R_PPC64_TLSGD
:
15325 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0
15326 && rel
+ 1 < relend
)
15328 unsigned int insn2
;
15329 enum elf_ppc64_reloc_type r_type1
= ELF64_R_TYPE (rel
[1].r_info
);
15331 offset
= rel
->r_offset
;
15332 if (is_plt_seq_reloc (r_type1
))
15334 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
);
15335 if (r_type1
== R_PPC64_PLT_PCREL34
15336 || r_type1
== R_PPC64_PLT_PCREL34_NOTOC
)
15337 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
15338 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
15342 if (ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_PLTCALL
)
15343 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
15345 if ((tls_mask
& TLS_GDIE
) != 0)
15348 r_type
= R_PPC64_NONE
;
15349 insn2
= 0x7c636a14; /* add 3,3,13 */
15354 if (toc_symndx
!= 0)
15356 r_symndx
= toc_symndx
;
15357 rel
->r_addend
= toc_addend
;
15359 if (r_type1
== R_PPC64_REL24_NOTOC
15360 || r_type1
== R_PPC64_PLTCALL_NOTOC
)
15362 r_type
= R_PPC64_NONE
;
15367 rel
->r_offset
= offset
+ d_offset
;
15368 r_type
= R_PPC64_TPREL16_LO
;
15369 insn2
= 0x38630000; /* addi 3,3,0 */
15372 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15373 /* Zap the reloc on the _tls_get_addr call too. */
15374 BFD_ASSERT (offset
== rel
[1].r_offset
);
15375 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
15376 bfd_put_32 (input_bfd
, insn2
, contents
+ offset
);
15377 if ((tls_mask
& TLS_GDIE
) == 0
15379 && r_type
!= R_PPC64_NONE
)
15384 case R_PPC64_TLSLD
:
15385 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0
15386 && rel
+ 1 < relend
)
15388 unsigned int insn2
;
15389 enum elf_ppc64_reloc_type r_type1
= ELF64_R_TYPE (rel
[1].r_info
);
15391 offset
= rel
->r_offset
;
15392 if (is_plt_seq_reloc (r_type1
))
15394 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
);
15395 if (r_type1
== R_PPC64_PLT_PCREL34
15396 || r_type1
== R_PPC64_PLT_PCREL34_NOTOC
)
15397 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
15398 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
15402 if (ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_PLTCALL
)
15403 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
15405 if (r_type1
== R_PPC64_REL24_NOTOC
15406 || r_type1
== R_PPC64_PLTCALL_NOTOC
)
15408 r_type
= R_PPC64_NONE
;
15413 rel
->r_offset
= offset
+ d_offset
;
15414 r_symndx
= STN_UNDEF
;
15415 r_type
= R_PPC64_TPREL16_LO
;
15416 rel
->r_addend
= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
15417 insn2
= 0x38630000; /* addi 3,3,0 */
15419 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15420 /* Zap the reloc on the _tls_get_addr call too. */
15421 BFD_ASSERT (offset
== rel
[1].r_offset
);
15422 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
15423 bfd_put_32 (input_bfd
, insn2
, contents
+ offset
);
15424 if (r_type
!= R_PPC64_NONE
)
15429 case R_PPC64_DTPMOD64
:
15430 if (rel
+ 1 < relend
15431 && rel
[1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_DTPREL64
)
15432 && rel
[1].r_offset
== rel
->r_offset
+ 8)
15434 if ((tls_mask
& TLS_GD
) == 0)
15436 rel
[1].r_info
= ELF64_R_INFO (r_symndx
, R_PPC64_NONE
);
15437 if ((tls_mask
& TLS_GDIE
) != 0)
15438 r_type
= R_PPC64_TPREL64
;
15441 bfd_put_64 (output_bfd
, 1, contents
+ rel
->r_offset
);
15442 r_type
= R_PPC64_NONE
;
15444 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15449 if ((tls_mask
& TLS_LD
) == 0)
15451 bfd_put_64 (output_bfd
, 1, contents
+ rel
->r_offset
);
15452 r_type
= R_PPC64_NONE
;
15453 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15458 case R_PPC64_TPREL64
:
15459 if ((tls_mask
& TLS_TPREL
) == 0)
15461 r_type
= R_PPC64_NONE
;
15462 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15466 case R_PPC64_ENTRY
:
15467 relocation
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
15468 if (!bfd_link_pic (info
)
15469 && !info
->traditional_format
15470 && relocation
+ 0x80008000 <= 0xffffffff)
15472 unsigned int insn1
, insn2
;
15474 insn1
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15475 insn2
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15476 if ((insn1
& ~0xfffc) == LD_R2_0R12
15477 && insn2
== ADD_R2_R2_R12
)
15479 bfd_put_32 (input_bfd
,
15480 LIS_R2
+ PPC_HA (relocation
),
15481 contents
+ rel
->r_offset
);
15482 bfd_put_32 (input_bfd
,
15483 ADDI_R2_R2
+ PPC_LO (relocation
),
15484 contents
+ rel
->r_offset
+ 4);
15489 relocation
-= (rel
->r_offset
15490 + input_section
->output_offset
15491 + input_section
->output_section
->vma
);
15492 if (relocation
+ 0x80008000 <= 0xffffffff)
15494 unsigned int insn1
, insn2
;
15496 insn1
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15497 insn2
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15498 if ((insn1
& ~0xfffc) == LD_R2_0R12
15499 && insn2
== ADD_R2_R2_R12
)
15501 bfd_put_32 (input_bfd
,
15502 ADDIS_R2_R12
+ PPC_HA (relocation
),
15503 contents
+ rel
->r_offset
);
15504 bfd_put_32 (input_bfd
,
15505 ADDI_R2_R2
+ PPC_LO (relocation
),
15506 contents
+ rel
->r_offset
+ 4);
15512 case R_PPC64_REL16_HA
:
15513 /* If we are generating a non-PIC executable, edit
15514 . 0: addis 2,12,.TOC.-0b@ha
15515 . addi 2,2,.TOC.-0b@l
15516 used by ELFv2 global entry points to set up r2, to
15519 if .TOC. is in range. */
15520 if (!bfd_link_pic (info
)
15521 && !info
->traditional_format
15523 && rel
->r_addend
== d_offset
15524 && h
!= NULL
&& &h
->elf
== htab
->elf
.hgot
15525 && rel
+ 1 < relend
15526 && rel
[1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_REL16_LO
)
15527 && rel
[1].r_offset
== rel
->r_offset
+ 4
15528 && rel
[1].r_addend
== rel
->r_addend
+ 4
15529 && relocation
+ 0x80008000 <= 0xffffffff)
15531 unsigned int insn1
, insn2
;
15532 offset
= rel
->r_offset
- d_offset
;
15533 insn1
= bfd_get_32 (input_bfd
, contents
+ offset
);
15534 insn2
= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
15535 if ((insn1
& 0xffff0000) == ADDIS_R2_R12
15536 && (insn2
& 0xffff0000) == ADDI_R2_R2
)
15538 r_type
= R_PPC64_ADDR16_HA
;
15539 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15540 rel
->r_addend
-= d_offset
;
15541 rel
[1].r_info
= ELF64_R_INFO (r_symndx
, R_PPC64_ADDR16_LO
);
15542 rel
[1].r_addend
-= d_offset
+ 4;
15543 bfd_put_32 (input_bfd
, LIS_R2
, contents
+ offset
);
15549 /* Handle other relocations that tweak non-addend part of insn. */
15551 max_br_offset
= 1 << 25;
15552 addend
= rel
->r_addend
;
15553 reloc_dest
= DEST_NORMAL
;
15559 case R_PPC64_TOCSAVE
:
15560 if (relocation
+ addend
== (rel
->r_offset
15561 + input_section
->output_offset
15562 + input_section
->output_section
->vma
)
15563 && tocsave_find (htab
, NO_INSERT
,
15564 &local_syms
, rel
, input_bfd
))
15566 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15568 || insn
== CROR_151515
|| insn
== CROR_313131
)
15569 bfd_put_32 (input_bfd
,
15570 STD_R2_0R1
+ STK_TOC (htab
),
15571 contents
+ rel
->r_offset
);
15575 /* Branch taken prediction relocations. */
15576 case R_PPC64_ADDR14_BRTAKEN
:
15577 case R_PPC64_REL14_BRTAKEN
:
15578 insn
= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
15579 /* Fall through. */
15581 /* Branch not taken prediction relocations. */
15582 case R_PPC64_ADDR14_BRNTAKEN
:
15583 case R_PPC64_REL14_BRNTAKEN
:
15584 insn
|= bfd_get_32 (input_bfd
,
15585 contents
+ rel
->r_offset
) & ~(0x01 << 21);
15586 /* Fall through. */
15588 case R_PPC64_REL14
:
15589 max_br_offset
= 1 << 15;
15590 /* Fall through. */
15592 case R_PPC64_REL24
:
15593 case R_PPC64_REL24_NOTOC
:
15594 case R_PPC64_PLTCALL
:
15595 case R_PPC64_PLTCALL_NOTOC
:
15596 /* Calls to functions with a different TOC, such as calls to
15597 shared objects, need to alter the TOC pointer. This is
15598 done using a linkage stub. A REL24 branching to these
15599 linkage stubs needs to be followed by a nop, as the nop
15600 will be replaced with an instruction to restore the TOC
15605 && h
->oh
->is_func_descriptor
)
15606 fdh
= ppc_follow_link (h
->oh
);
15607 stub_entry
= ppc_get_stub_entry (input_section
, sec
, fdh
, &orig_rel
,
15609 if ((r_type
== R_PPC64_PLTCALL
15610 || r_type
== R_PPC64_PLTCALL_NOTOC
)
15611 && stub_entry
!= NULL
15612 && stub_entry
->stub_type
>= ppc_stub_plt_call
15613 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15616 if (stub_entry
!= NULL
15617 && ((stub_entry
->stub_type
>= ppc_stub_plt_call
15618 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15619 || stub_entry
->stub_type
== ppc_stub_plt_branch_r2off
15620 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
15621 || stub_entry
->stub_type
== ppc_stub_long_branch_r2off
15622 || stub_entry
->stub_type
== ppc_stub_long_branch_both
))
15624 bfd_boolean can_plt_call
= FALSE
;
15626 if (stub_entry
->stub_type
== ppc_stub_plt_call
15628 && htab
->params
->plt_localentry0
!= 0
15629 && is_elfv2_localentry0 (&h
->elf
))
15631 /* The function doesn't use or change r2. */
15632 can_plt_call
= TRUE
;
15634 else if (r_type
== R_PPC64_REL24_NOTOC
)
15636 /* NOTOC calls don't need to restore r2. */
15637 can_plt_call
= TRUE
;
15640 /* All of these stubs may modify r2, so there must be a
15641 branch and link followed by a nop. The nop is
15642 replaced by an insn to restore r2. */
15643 else if (rel
->r_offset
+ 8 <= input_section
->size
)
15647 br
= bfd_get_32 (input_bfd
,
15648 contents
+ rel
->r_offset
);
15653 nop
= bfd_get_32 (input_bfd
,
15654 contents
+ rel
->r_offset
+ 4);
15655 if (nop
== LD_R2_0R1
+ STK_TOC (htab
))
15656 can_plt_call
= TRUE
;
15657 else if (nop
== NOP
15658 || nop
== CROR_151515
15659 || nop
== CROR_313131
)
15662 && is_tls_get_addr (&h
->elf
, htab
)
15663 && htab
->params
->tls_get_addr_opt
)
15665 /* Special stub used, leave nop alone. */
15668 bfd_put_32 (input_bfd
,
15669 LD_R2_0R1
+ STK_TOC (htab
),
15670 contents
+ rel
->r_offset
+ 4);
15671 can_plt_call
= TRUE
;
15676 if (!can_plt_call
&& h
!= NULL
)
15678 const char *name
= h
->elf
.root
.root
.string
;
15683 if (strncmp (name
, "__libc_start_main", 17) == 0
15684 && (name
[17] == 0 || name
[17] == '@'))
15686 /* Allow crt1 branch to go via a toc adjusting
15687 stub. Other calls that never return could do
15688 the same, if we could detect such. */
15689 can_plt_call
= TRUE
;
15695 /* g++ as of 20130507 emits self-calls without a
15696 following nop. This is arguably wrong since we
15697 have conflicting information. On the one hand a
15698 global symbol and on the other a local call
15699 sequence, but don't error for this special case.
15700 It isn't possible to cheaply verify we have
15701 exactly such a call. Allow all calls to the same
15703 asection
*code_sec
= sec
;
15705 if (get_opd_info (sec
) != NULL
)
15707 bfd_vma off
= (relocation
+ addend
15708 - sec
->output_section
->vma
15709 - sec
->output_offset
);
15711 opd_entry_value (sec
, off
, &code_sec
, NULL
, FALSE
);
15713 if (code_sec
== input_section
)
15714 can_plt_call
= TRUE
;
15719 if (stub_entry
->stub_type
>= ppc_stub_plt_call
15720 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15721 info
->callbacks
->einfo
15722 /* xgettext:c-format */
15723 (_("%H: call to `%pT' lacks nop, can't restore toc; "
15724 "(plt call stub)\n"),
15725 input_bfd
, input_section
, rel
->r_offset
, sym_name
);
15727 info
->callbacks
->einfo
15728 /* xgettext:c-format */
15729 (_("%H: call to `%pT' lacks nop, can't restore toc; "
15730 "(toc save/adjust stub)\n"),
15731 input_bfd
, input_section
, rel
->r_offset
, sym_name
);
15733 bfd_set_error (bfd_error_bad_value
);
15738 && stub_entry
->stub_type
>= ppc_stub_plt_call
15739 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15740 unresolved_reloc
= FALSE
;
15743 if ((stub_entry
== NULL
15744 || stub_entry
->stub_type
== ppc_stub_long_branch
15745 || stub_entry
->stub_type
== ppc_stub_plt_branch
)
15746 && get_opd_info (sec
) != NULL
)
15748 /* The branch destination is the value of the opd entry. */
15749 bfd_vma off
= (relocation
+ addend
15750 - sec
->output_section
->vma
15751 - sec
->output_offset
);
15752 bfd_vma dest
= opd_entry_value (sec
, off
, NULL
, NULL
, FALSE
);
15753 if (dest
!= (bfd_vma
) -1)
15757 reloc_dest
= DEST_OPD
;
15761 /* If the branch is out of reach we ought to have a long
15763 from
= (rel
->r_offset
15764 + input_section
->output_offset
15765 + input_section
->output_section
->vma
);
15767 relocation
+= PPC64_LOCAL_ENTRY_OFFSET (fdh
15771 if (stub_entry
!= NULL
15772 && (stub_entry
->stub_type
== ppc_stub_long_branch
15773 || stub_entry
->stub_type
== ppc_stub_plt_branch
)
15774 && (r_type
== R_PPC64_ADDR14_BRTAKEN
15775 || r_type
== R_PPC64_ADDR14_BRNTAKEN
15776 || (relocation
+ addend
- from
+ max_br_offset
15777 < 2 * max_br_offset
)))
15778 /* Don't use the stub if this branch is in range. */
15781 if (stub_entry
!= NULL
15782 && (stub_entry
->stub_type
== ppc_stub_long_branch_notoc
15783 || stub_entry
->stub_type
== ppc_stub_long_branch_both
15784 || stub_entry
->stub_type
== ppc_stub_plt_branch_notoc
15785 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
)
15786 && (r_type
!= R_PPC64_REL24_NOTOC
15787 || ((fdh
? fdh
->elf
.other
: sym
->st_other
)
15788 & STO_PPC64_LOCAL_MASK
) <= 1 << STO_PPC64_LOCAL_BIT
)
15789 && (relocation
+ addend
- from
+ max_br_offset
15790 < 2 * max_br_offset
))
15793 if (stub_entry
!= NULL
15794 && (stub_entry
->stub_type
== ppc_stub_long_branch_r2off
15795 || stub_entry
->stub_type
== ppc_stub_long_branch_both
15796 || stub_entry
->stub_type
== ppc_stub_plt_branch_r2off
15797 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
)
15798 && r_type
== R_PPC64_REL24_NOTOC
15799 && (relocation
+ addend
- from
+ max_br_offset
15800 < 2 * max_br_offset
))
15803 if (stub_entry
!= NULL
)
15805 /* Munge up the value and addend so that we call the stub
15806 rather than the procedure directly. */
15807 asection
*stub_sec
= stub_entry
->group
->stub_sec
;
15809 if (stub_entry
->stub_type
== ppc_stub_save_res
)
15810 relocation
+= (stub_sec
->output_offset
15811 + stub_sec
->output_section
->vma
15812 + stub_sec
->size
- htab
->sfpr
->size
15813 - htab
->sfpr
->output_offset
15814 - htab
->sfpr
->output_section
->vma
);
15816 relocation
= (stub_entry
->stub_offset
15817 + stub_sec
->output_offset
15818 + stub_sec
->output_section
->vma
);
15820 reloc_dest
= DEST_STUB
;
15822 if (((stub_entry
->stub_type
== ppc_stub_plt_call
15823 && ALWAYS_EMIT_R2SAVE
)
15824 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
15825 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
15827 && is_tls_get_addr (&h
->elf
, htab
)
15828 && htab
->params
->tls_get_addr_opt
)
15829 && rel
+ 1 < relend
15830 && rel
[1].r_offset
== rel
->r_offset
+ 4
15831 && ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_TOCSAVE
)
15833 else if ((stub_entry
->stub_type
== ppc_stub_long_branch_both
15834 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
15835 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
15836 && r_type
== R_PPC64_REL24_NOTOC
)
15839 if (r_type
== R_PPC64_REL24_NOTOC
15840 && (stub_entry
->stub_type
== ppc_stub_plt_call_notoc
15841 || stub_entry
->stub_type
== ppc_stub_plt_call_both
))
15842 htab
->notoc_plt
= 1;
15849 /* Set 'a' bit. This is 0b00010 in BO field for branch
15850 on CR(BI) insns (BO == 001at or 011at), and 0b01000
15851 for branch on CTR insns (BO == 1a00t or 1a01t). */
15852 if ((insn
& (0x14 << 21)) == (0x04 << 21))
15853 insn
|= 0x02 << 21;
15854 else if ((insn
& (0x14 << 21)) == (0x10 << 21))
15855 insn
|= 0x08 << 21;
15861 /* Invert 'y' bit if not the default. */
15862 if ((bfd_signed_vma
) (relocation
+ addend
- from
) < 0)
15863 insn
^= 0x01 << 21;
15866 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
15869 /* NOP out calls to undefined weak functions.
15870 We can thus call a weak function without first
15871 checking whether the function is defined. */
15873 && h
->elf
.root
.type
== bfd_link_hash_undefweak
15874 && h
->elf
.dynindx
== -1
15875 && (r_type
== R_PPC64_REL24
15876 || r_type
== R_PPC64_REL24_NOTOC
)
15880 bfd_put_32 (input_bfd
, NOP
, contents
+ rel
->r_offset
);
15885 case R_PPC64_GOT16_DS
:
15886 if ((h
? h
->elf
.type
: ELF_ST_TYPE (sym
->st_info
)) == STT_GNU_IFUNC
)
15888 from
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
15889 if (relocation
+ addend
- from
+ 0x8000 < 0x10000
15890 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15892 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
15893 if ((insn
& (0x3fu
<< 26 | 0x3)) == 58u << 26 /* ld */)
15895 insn
+= (14u << 26) - (58u << 26);
15896 bfd_put_32 (input_bfd
, insn
, contents
+ (rel
->r_offset
& ~3));
15897 r_type
= R_PPC64_TOC16
;
15898 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15903 case R_PPC64_GOT16_LO_DS
:
15904 case R_PPC64_GOT16_HA
:
15905 if ((h
? h
->elf
.type
: ELF_ST_TYPE (sym
->st_info
)) == STT_GNU_IFUNC
)
15907 from
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
15908 if (relocation
+ addend
- from
+ 0x80008000ULL
< 0x100000000ULL
15909 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15911 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
15912 if ((insn
& (0x3fu
<< 26 | 0x3)) == 58u << 26 /* ld */)
15914 insn
+= (14u << 26) - (58u << 26);
15915 bfd_put_32 (input_bfd
, insn
, contents
+ (rel
->r_offset
& ~3));
15916 r_type
= R_PPC64_TOC16_LO
;
15917 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15919 else if ((insn
& (0x3fu
<< 26)) == 15u << 26 /* addis */)
15921 r_type
= R_PPC64_TOC16_HA
;
15922 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15927 case R_PPC64_GOT_PCREL34
:
15928 if ((h
? h
->elf
.type
: ELF_ST_TYPE (sym
->st_info
)) == STT_GNU_IFUNC
)
15930 from
= (rel
->r_offset
15931 + input_section
->output_section
->vma
15932 + input_section
->output_offset
);
15933 if (relocation
- from
+ (1ULL << 33) < 1ULL << 34
15934 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15936 offset
= rel
->r_offset
;
15937 pinsn
= bfd_get_32 (input_bfd
, contents
+ offset
);
15939 pinsn
|= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
15940 if ((pinsn
& ((-1ULL << 50) | (63ULL << 26)))
15941 == ((1ULL << 58) | (1ULL << 52) | (57ULL << 26) /* pld */))
15943 /* Replace with paddi. */
15944 pinsn
+= (2ULL << 56) + (14ULL << 26) - (57ULL << 26);
15945 r_type
= R_PPC64_PCREL34
;
15946 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15947 bfd_put_32 (input_bfd
, pinsn
>> 32, contents
+ offset
);
15948 bfd_put_32 (input_bfd
, pinsn
, contents
+ offset
+ 4);
15954 case R_PPC64_PCREL34
:
15955 if (SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15957 offset
= rel
->r_offset
;
15958 pinsn
= bfd_get_32 (input_bfd
, contents
+ offset
);
15960 pinsn
|= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
15961 if ((pinsn
& ((-1ULL << 50) | (63ULL << 26)))
15962 == ((1ULL << 58) | (2ULL << 56) | (1ULL << 52)
15963 | (14ULL << 26) /* paddi */))
15966 if (rel
+ 1 < relend
15967 && rel
[1].r_offset
== offset
15968 && rel
[1].r_info
== ELF64_R_INFO (0, R_PPC64_PCREL_OPT
))
15970 bfd_vma off2
= rel
[1].r_addend
;
15972 /* zero means next insn. */
15975 if (off2
+ 4 <= input_section
->size
)
15978 bfd_signed_vma addend_off
;
15979 pinsn2
= bfd_get_32 (input_bfd
, contents
+ off2
);
15981 if ((pinsn2
& (63ULL << 58)) == 1ULL << 58)
15983 if (off2
+ 8 > input_section
->size
)
15985 pinsn2
|= bfd_get_32 (input_bfd
,
15986 contents
+ off2
+ 4);
15988 if (xlate_pcrel_opt (&pinsn
, &pinsn2
, &addend_off
))
15990 addend
+= addend_off
;
15991 rel
->r_addend
= addend
;
15992 bfd_put_32 (input_bfd
, pinsn
>> 32,
15993 contents
+ offset
);
15994 bfd_put_32 (input_bfd
, pinsn
,
15995 contents
+ offset
+ 4);
15996 bfd_put_32 (input_bfd
, pinsn2
>> 32,
15998 if ((pinsn2
& (63ULL << 58)) == 1ULL << 58)
15999 bfd_put_32 (input_bfd
, pinsn2
,
16000 contents
+ off2
+ 4);
16010 save_unresolved_reloc
= unresolved_reloc
;
16014 /* xgettext:c-format */
16015 _bfd_error_handler (_("%pB: %s unsupported"),
16016 input_bfd
, ppc64_elf_howto_table
[r_type
]->name
);
16018 bfd_set_error (bfd_error_bad_value
);
16024 case R_PPC64_TLSGD
:
16025 case R_PPC64_TLSLD
:
16026 case R_PPC64_TOCSAVE
:
16027 case R_PPC64_GNU_VTINHERIT
:
16028 case R_PPC64_GNU_VTENTRY
:
16029 case R_PPC64_ENTRY
:
16030 case R_PPC64_PCREL_OPT
:
16033 /* GOT16 relocations. Like an ADDR16 using the symbol's
16034 address in the GOT as relocation value instead of the
16035 symbol's value itself. Also, create a GOT entry for the
16036 symbol and put the symbol value there. */
16037 case R_PPC64_GOT_TLSGD16
:
16038 case R_PPC64_GOT_TLSGD16_LO
:
16039 case R_PPC64_GOT_TLSGD16_HI
:
16040 case R_PPC64_GOT_TLSGD16_HA
:
16041 case R_PPC64_GOT_TLSGD34
:
16042 tls_type
= TLS_TLS
| TLS_GD
;
16045 case R_PPC64_GOT_TLSLD16
:
16046 case R_PPC64_GOT_TLSLD16_LO
:
16047 case R_PPC64_GOT_TLSLD16_HI
:
16048 case R_PPC64_GOT_TLSLD16_HA
:
16049 case R_PPC64_GOT_TLSLD34
:
16050 tls_type
= TLS_TLS
| TLS_LD
;
16053 case R_PPC64_GOT_TPREL16_DS
:
16054 case R_PPC64_GOT_TPREL16_LO_DS
:
16055 case R_PPC64_GOT_TPREL16_HI
:
16056 case R_PPC64_GOT_TPREL16_HA
:
16057 case R_PPC64_GOT_TPREL34
:
16058 tls_type
= TLS_TLS
| TLS_TPREL
;
16061 case R_PPC64_GOT_DTPREL16_DS
:
16062 case R_PPC64_GOT_DTPREL16_LO_DS
:
16063 case R_PPC64_GOT_DTPREL16_HI
:
16064 case R_PPC64_GOT_DTPREL16_HA
:
16065 case R_PPC64_GOT_DTPREL34
:
16066 tls_type
= TLS_TLS
| TLS_DTPREL
;
16069 case R_PPC64_GOT16
:
16070 case R_PPC64_GOT16_LO
:
16071 case R_PPC64_GOT16_HI
:
16072 case R_PPC64_GOT16_HA
:
16073 case R_PPC64_GOT16_DS
:
16074 case R_PPC64_GOT16_LO_DS
:
16075 case R_PPC64_GOT_PCREL34
:
16078 /* Relocation is to the entry for this symbol in the global
16083 unsigned long indx
= 0;
16084 struct got_entry
*ent
;
16086 if (tls_type
== (TLS_TLS
| TLS_LD
)
16087 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
16088 ent
= ppc64_tlsld_got (input_bfd
);
16093 if (!htab
->elf
.dynamic_sections_created
16094 || h
->elf
.dynindx
== -1
16095 || SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
)
16096 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, &h
->elf
))
16097 /* This is actually a static link, or it is a
16098 -Bsymbolic link and the symbol is defined
16099 locally, or the symbol was forced to be local
16100 because of a version file. */
16104 indx
= h
->elf
.dynindx
;
16105 unresolved_reloc
= FALSE
;
16107 ent
= h
->elf
.got
.glist
;
16111 if (local_got_ents
== NULL
)
16113 ent
= local_got_ents
[r_symndx
];
16116 for (; ent
!= NULL
; ent
= ent
->next
)
16117 if (ent
->addend
== orig_rel
.r_addend
16118 && ent
->owner
== input_bfd
16119 && ent
->tls_type
== tls_type
)
16125 if (ent
->is_indirect
)
16126 ent
= ent
->got
.ent
;
16127 offp
= &ent
->got
.offset
;
16128 got
= ppc64_elf_tdata (ent
->owner
)->got
;
16132 /* The offset must always be a multiple of 8. We use the
16133 least significant bit to record whether we have already
16134 processed this entry. */
16136 if ((off
& 1) != 0)
16140 /* Generate relocs for the dynamic linker, except in
16141 the case of TLSLD where we'll use one entry per
16149 ? h
->elf
.type
== STT_GNU_IFUNC
16150 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
);
16153 relgot
= htab
->elf
.irelplt
;
16155 htab
->local_ifunc_resolver
= 1;
16156 else if (is_static_defined (&h
->elf
))
16157 htab
->maybe_local_ifunc_resolver
= 1;
16160 || (bfd_link_pic (info
)
16162 || !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, &h
->elf
))
16164 && bfd_link_executable (info
)
16165 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))))
16166 relgot
= ppc64_elf_tdata (ent
->owner
)->relgot
;
16167 if (relgot
!= NULL
)
16169 outrel
.r_offset
= (got
->output_section
->vma
16170 + got
->output_offset
16172 outrel
.r_addend
= orig_rel
.r_addend
;
16173 if (tls_type
& (TLS_LD
| TLS_GD
))
16175 outrel
.r_addend
= 0;
16176 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_DTPMOD64
);
16177 if (tls_type
== (TLS_TLS
| TLS_GD
))
16179 loc
= relgot
->contents
;
16180 loc
+= (relgot
->reloc_count
++
16181 * sizeof (Elf64_External_Rela
));
16182 bfd_elf64_swap_reloca_out (output_bfd
,
16184 outrel
.r_offset
+= 8;
16185 outrel
.r_addend
= orig_rel
.r_addend
;
16187 = ELF64_R_INFO (indx
, R_PPC64_DTPREL64
);
16190 else if (tls_type
== (TLS_TLS
| TLS_DTPREL
))
16191 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_DTPREL64
);
16192 else if (tls_type
== (TLS_TLS
| TLS_TPREL
))
16193 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_TPREL64
);
16194 else if (indx
!= 0)
16195 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_GLOB_DAT
);
16199 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
16201 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
16203 /* Write the .got section contents for the sake
16205 loc
= got
->contents
+ off
;
16206 bfd_put_64 (output_bfd
, outrel
.r_addend
+ relocation
,
16210 if (indx
== 0 && tls_type
!= (TLS_TLS
| TLS_LD
))
16212 outrel
.r_addend
+= relocation
;
16213 if (tls_type
& (TLS_GD
| TLS_DTPREL
| TLS_TPREL
))
16215 if (htab
->elf
.tls_sec
== NULL
)
16216 outrel
.r_addend
= 0;
16218 outrel
.r_addend
-= htab
->elf
.tls_sec
->vma
;
16221 loc
= relgot
->contents
;
16222 loc
+= (relgot
->reloc_count
++
16223 * sizeof (Elf64_External_Rela
));
16224 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
16227 /* Init the .got section contents here if we're not
16228 emitting a reloc. */
16231 relocation
+= orig_rel
.r_addend
;
16234 if (htab
->elf
.tls_sec
== NULL
)
16238 if (tls_type
& TLS_LD
)
16241 relocation
-= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
16242 if (tls_type
& TLS_TPREL
)
16243 relocation
+= DTP_OFFSET
- TP_OFFSET
;
16246 if (tls_type
& (TLS_GD
| TLS_LD
))
16248 bfd_put_64 (output_bfd
, relocation
,
16249 got
->contents
+ off
+ 8);
16253 bfd_put_64 (output_bfd
, relocation
,
16254 got
->contents
+ off
);
16258 if (off
>= (bfd_vma
) -2)
16261 relocation
= got
->output_section
->vma
+ got
->output_offset
+ off
;
16263 if (!(r_type
== R_PPC64_GOT_PCREL34
16264 || r_type
== R_PPC64_GOT_TLSGD34
16265 || r_type
== R_PPC64_GOT_TLSLD34
16266 || r_type
== R_PPC64_GOT_TPREL34
16267 || r_type
== R_PPC64_GOT_DTPREL34
))
16268 addend
= -(TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
);
16272 case R_PPC64_PLT16_HA
:
16273 case R_PPC64_PLT16_HI
:
16274 case R_PPC64_PLT16_LO
:
16275 case R_PPC64_PLT16_LO_DS
:
16276 case R_PPC64_PLT_PCREL34
:
16277 case R_PPC64_PLT_PCREL34_NOTOC
:
16278 case R_PPC64_PLT32
:
16279 case R_PPC64_PLT64
:
16280 case R_PPC64_PLTSEQ
:
16281 case R_PPC64_PLTSEQ_NOTOC
:
16282 case R_PPC64_PLTCALL
:
16283 case R_PPC64_PLTCALL_NOTOC
:
16284 /* Relocation is to the entry for this symbol in the
16285 procedure linkage table. */
16286 unresolved_reloc
= TRUE
;
16288 struct plt_entry
**plt_list
= NULL
;
16290 plt_list
= &h
->elf
.plt
.plist
;
16291 else if (local_got_ents
!= NULL
)
16293 struct plt_entry
**local_plt
= (struct plt_entry
**)
16294 (local_got_ents
+ symtab_hdr
->sh_info
);
16295 plt_list
= local_plt
+ r_symndx
;
16299 struct plt_entry
*ent
;
16301 for (ent
= *plt_list
; ent
!= NULL
; ent
= ent
->next
)
16302 if (ent
->plt
.offset
!= (bfd_vma
) -1
16303 && ent
->addend
== orig_rel
.r_addend
)
16308 plt
= htab
->elf
.splt
;
16309 if (!htab
->elf
.dynamic_sections_created
16311 || h
->elf
.dynindx
== -1)
16314 ? h
->elf
.type
== STT_GNU_IFUNC
16315 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
16316 plt
= htab
->elf
.iplt
;
16318 plt
= htab
->pltlocal
;
16320 relocation
= (plt
->output_section
->vma
16321 + plt
->output_offset
16322 + ent
->plt
.offset
);
16323 if (r_type
== R_PPC64_PLT16_HA
16324 || r_type
== R_PPC64_PLT16_HI
16325 || r_type
== R_PPC64_PLT16_LO
16326 || r_type
== R_PPC64_PLT16_LO_DS
)
16328 got
= (elf_gp (output_bfd
)
16329 + htab
->sec_info
[input_section
->id
].toc_off
);
16333 unresolved_reloc
= FALSE
;
16341 /* Relocation value is TOC base. */
16342 relocation
= TOCstart
;
16343 if (r_symndx
== STN_UNDEF
)
16344 relocation
+= htab
->sec_info
[input_section
->id
].toc_off
;
16345 else if (unresolved_reloc
)
16347 else if (sec
!= NULL
&& sec
->id
< htab
->sec_info_arr_size
)
16348 relocation
+= htab
->sec_info
[sec
->id
].toc_off
;
16350 unresolved_reloc
= TRUE
;
16353 /* TOC16 relocs. We want the offset relative to the TOC base,
16354 which is the address of the start of the TOC plus 0x8000.
16355 The TOC consists of sections .got, .toc, .tocbss, and .plt,
16357 case R_PPC64_TOC16
:
16358 case R_PPC64_TOC16_LO
:
16359 case R_PPC64_TOC16_HI
:
16360 case R_PPC64_TOC16_DS
:
16361 case R_PPC64_TOC16_LO_DS
:
16362 case R_PPC64_TOC16_HA
:
16363 addend
-= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
16368 /* Relocate against the beginning of the section. */
16369 case R_PPC64_SECTOFF
:
16370 case R_PPC64_SECTOFF_LO
:
16371 case R_PPC64_SECTOFF_HI
:
16372 case R_PPC64_SECTOFF_DS
:
16373 case R_PPC64_SECTOFF_LO_DS
:
16374 case R_PPC64_SECTOFF_HA
:
16376 addend
-= sec
->output_section
->vma
;
16379 case R_PPC64_REL16
:
16380 case R_PPC64_REL16_LO
:
16381 case R_PPC64_REL16_HI
:
16382 case R_PPC64_REL16_HA
:
16383 case R_PPC64_REL16_HIGH
:
16384 case R_PPC64_REL16_HIGHA
:
16385 case R_PPC64_REL16_HIGHER
:
16386 case R_PPC64_REL16_HIGHERA
:
16387 case R_PPC64_REL16_HIGHEST
:
16388 case R_PPC64_REL16_HIGHESTA
:
16389 case R_PPC64_REL16_HIGHER34
:
16390 case R_PPC64_REL16_HIGHERA34
:
16391 case R_PPC64_REL16_HIGHEST34
:
16392 case R_PPC64_REL16_HIGHESTA34
:
16393 case R_PPC64_REL16DX_HA
:
16394 case R_PPC64_REL14
:
16395 case R_PPC64_REL14_BRNTAKEN
:
16396 case R_PPC64_REL14_BRTAKEN
:
16397 case R_PPC64_REL24
:
16398 case R_PPC64_REL24_NOTOC
:
16399 case R_PPC64_PCREL34
:
16400 case R_PPC64_PCREL28
:
16403 case R_PPC64_TPREL16
:
16404 case R_PPC64_TPREL16_LO
:
16405 case R_PPC64_TPREL16_HI
:
16406 case R_PPC64_TPREL16_HA
:
16407 case R_PPC64_TPREL16_DS
:
16408 case R_PPC64_TPREL16_LO_DS
:
16409 case R_PPC64_TPREL16_HIGH
:
16410 case R_PPC64_TPREL16_HIGHA
:
16411 case R_PPC64_TPREL16_HIGHER
:
16412 case R_PPC64_TPREL16_HIGHERA
:
16413 case R_PPC64_TPREL16_HIGHEST
:
16414 case R_PPC64_TPREL16_HIGHESTA
:
16415 case R_PPC64_TPREL34
:
16417 && h
->elf
.root
.type
== bfd_link_hash_undefweak
16418 && h
->elf
.dynindx
== -1)
16420 /* Make this relocation against an undefined weak symbol
16421 resolve to zero. This is really just a tweak, since
16422 code using weak externs ought to check that they are
16423 defined before using them. */
16424 bfd_byte
*p
= contents
+ rel
->r_offset
- d_offset
;
16426 insn
= bfd_get_32 (input_bfd
, p
);
16427 insn
= _bfd_elf_ppc_at_tprel_transform (insn
, 13);
16429 bfd_put_32 (input_bfd
, insn
, p
);
16432 if (htab
->elf
.tls_sec
!= NULL
)
16433 addend
-= htab
->elf
.tls_sec
->vma
+ TP_OFFSET
;
16434 /* The TPREL16 relocs shouldn't really be used in shared
16435 libs or with non-local symbols as that will result in
16436 DT_TEXTREL being set, but support them anyway. */
16439 case R_PPC64_DTPREL16
:
16440 case R_PPC64_DTPREL16_LO
:
16441 case R_PPC64_DTPREL16_HI
:
16442 case R_PPC64_DTPREL16_HA
:
16443 case R_PPC64_DTPREL16_DS
:
16444 case R_PPC64_DTPREL16_LO_DS
:
16445 case R_PPC64_DTPREL16_HIGH
:
16446 case R_PPC64_DTPREL16_HIGHA
:
16447 case R_PPC64_DTPREL16_HIGHER
:
16448 case R_PPC64_DTPREL16_HIGHERA
:
16449 case R_PPC64_DTPREL16_HIGHEST
:
16450 case R_PPC64_DTPREL16_HIGHESTA
:
16451 case R_PPC64_DTPREL34
:
16452 if (htab
->elf
.tls_sec
!= NULL
)
16453 addend
-= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
16456 case R_PPC64_ADDR64_LOCAL
:
16457 addend
+= PPC64_LOCAL_ENTRY_OFFSET (h
!= NULL
16462 case R_PPC64_DTPMOD64
:
16467 case R_PPC64_TPREL64
:
16468 if (htab
->elf
.tls_sec
!= NULL
)
16469 addend
-= htab
->elf
.tls_sec
->vma
+ TP_OFFSET
;
16472 case R_PPC64_DTPREL64
:
16473 if (htab
->elf
.tls_sec
!= NULL
)
16474 addend
-= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
16475 /* Fall through. */
16477 /* Relocations that may need to be propagated if this is a
16479 case R_PPC64_REL30
:
16480 case R_PPC64_REL32
:
16481 case R_PPC64_REL64
:
16482 case R_PPC64_ADDR14
:
16483 case R_PPC64_ADDR14_BRNTAKEN
:
16484 case R_PPC64_ADDR14_BRTAKEN
:
16485 case R_PPC64_ADDR16
:
16486 case R_PPC64_ADDR16_DS
:
16487 case R_PPC64_ADDR16_HA
:
16488 case R_PPC64_ADDR16_HI
:
16489 case R_PPC64_ADDR16_HIGH
:
16490 case R_PPC64_ADDR16_HIGHA
:
16491 case R_PPC64_ADDR16_HIGHER
:
16492 case R_PPC64_ADDR16_HIGHERA
:
16493 case R_PPC64_ADDR16_HIGHEST
:
16494 case R_PPC64_ADDR16_HIGHESTA
:
16495 case R_PPC64_ADDR16_LO
:
16496 case R_PPC64_ADDR16_LO_DS
:
16497 case R_PPC64_ADDR16_HIGHER34
:
16498 case R_PPC64_ADDR16_HIGHERA34
:
16499 case R_PPC64_ADDR16_HIGHEST34
:
16500 case R_PPC64_ADDR16_HIGHESTA34
:
16501 case R_PPC64_ADDR24
:
16502 case R_PPC64_ADDR32
:
16503 case R_PPC64_ADDR64
:
16504 case R_PPC64_UADDR16
:
16505 case R_PPC64_UADDR32
:
16506 case R_PPC64_UADDR64
:
16508 case R_PPC64_D34_LO
:
16509 case R_PPC64_D34_HI30
:
16510 case R_PPC64_D34_HA30
:
16513 if ((input_section
->flags
& SEC_ALLOC
) == 0)
16516 if (NO_OPD_RELOCS
&& is_opd
)
16519 if (bfd_link_pic (info
)
16521 || h
->dyn_relocs
!= NULL
)
16522 && ((h
!= NULL
&& pc_dynrelocs (h
))
16523 || must_be_dyn_reloc (info
, r_type
)))
16525 ? h
->dyn_relocs
!= NULL
16526 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
))
16528 bfd_boolean skip
, relocate
;
16533 /* When generating a dynamic object, these relocations
16534 are copied into the output file to be resolved at run
16540 out_off
= _bfd_elf_section_offset (output_bfd
, info
,
16541 input_section
, rel
->r_offset
);
16542 if (out_off
== (bfd_vma
) -1)
16544 else if (out_off
== (bfd_vma
) -2)
16545 skip
= TRUE
, relocate
= TRUE
;
16546 out_off
+= (input_section
->output_section
->vma
16547 + input_section
->output_offset
);
16548 outrel
.r_offset
= out_off
;
16549 outrel
.r_addend
= rel
->r_addend
;
16551 /* Optimize unaligned reloc use. */
16552 if ((r_type
== R_PPC64_ADDR64
&& (out_off
& 7) != 0)
16553 || (r_type
== R_PPC64_UADDR64
&& (out_off
& 7) == 0))
16554 r_type
^= R_PPC64_ADDR64
^ R_PPC64_UADDR64
;
16555 else if ((r_type
== R_PPC64_ADDR32
&& (out_off
& 3) != 0)
16556 || (r_type
== R_PPC64_UADDR32
&& (out_off
& 3) == 0))
16557 r_type
^= R_PPC64_ADDR32
^ R_PPC64_UADDR32
;
16558 else if ((r_type
== R_PPC64_ADDR16
&& (out_off
& 1) != 0)
16559 || (r_type
== R_PPC64_UADDR16
&& (out_off
& 1) == 0))
16560 r_type
^= R_PPC64_ADDR16
^ R_PPC64_UADDR16
;
16563 memset (&outrel
, 0, sizeof outrel
);
16564 else if (!SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
)
16566 && r_type
!= R_PPC64_TOC
)
16568 indx
= h
->elf
.dynindx
;
16569 BFD_ASSERT (indx
!= -1);
16570 outrel
.r_info
= ELF64_R_INFO (indx
, r_type
);
16574 /* This symbol is local, or marked to become local,
16575 or this is an opd section reloc which must point
16576 at a local function. */
16577 outrel
.r_addend
+= relocation
;
16578 if (r_type
== R_PPC64_ADDR64
|| r_type
== R_PPC64_TOC
)
16580 if (is_opd
&& h
!= NULL
)
16582 /* Lie about opd entries. This case occurs
16583 when building shared libraries and we
16584 reference a function in another shared
16585 lib. The same thing happens for a weak
16586 definition in an application that's
16587 overridden by a strong definition in a
16588 shared lib. (I believe this is a generic
16589 bug in binutils handling of weak syms.)
16590 In these cases we won't use the opd
16591 entry in this lib. */
16592 unresolved_reloc
= FALSE
;
16595 && r_type
== R_PPC64_ADDR64
16597 ? h
->elf
.type
== STT_GNU_IFUNC
16598 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
))
16599 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
16602 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
16604 /* We need to relocate .opd contents for ld.so.
16605 Prelink also wants simple and consistent rules
16606 for relocs. This make all RELATIVE relocs have
16607 *r_offset equal to r_addend. */
16614 ? h
->elf
.type
== STT_GNU_IFUNC
16615 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
16617 info
->callbacks
->einfo
16618 /* xgettext:c-format */
16619 (_("%H: %s for indirect "
16620 "function `%pT' unsupported\n"),
16621 input_bfd
, input_section
, rel
->r_offset
,
16622 ppc64_elf_howto_table
[r_type
]->name
,
16626 else if (r_symndx
== STN_UNDEF
|| bfd_is_abs_section (sec
))
16628 else if (sec
== NULL
|| sec
->owner
== NULL
)
16630 bfd_set_error (bfd_error_bad_value
);
16635 asection
*osec
= sec
->output_section
;
16637 if ((osec
->flags
& SEC_THREAD_LOCAL
) != 0)
16639 /* TLS symbol values are relative to the
16640 TLS segment. Dynamic relocations for
16641 local TLS symbols therefore can't be
16642 reduced to a relocation against their
16643 section symbol because it holds the
16644 address of the section, not a value
16645 relative to the TLS segment. We could
16646 change the .tdata dynamic section symbol
16647 to be zero value but STN_UNDEF works
16648 and is used elsewhere, eg. for TPREL64
16649 GOT relocs against local TLS symbols. */
16650 osec
= htab
->elf
.tls_sec
;
16655 indx
= elf_section_data (osec
)->dynindx
;
16658 if ((osec
->flags
& SEC_READONLY
) == 0
16659 && htab
->elf
.data_index_section
!= NULL
)
16660 osec
= htab
->elf
.data_index_section
;
16662 osec
= htab
->elf
.text_index_section
;
16663 indx
= elf_section_data (osec
)->dynindx
;
16665 BFD_ASSERT (indx
!= 0);
16668 /* We are turning this relocation into one
16669 against a section symbol, so subtract out
16670 the output section's address but not the
16671 offset of the input section in the output
16673 outrel
.r_addend
-= osec
->vma
;
16676 outrel
.r_info
= ELF64_R_INFO (indx
, r_type
);
16680 sreloc
= elf_section_data (input_section
)->sreloc
;
16682 ? h
->elf
.type
== STT_GNU_IFUNC
16683 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
16685 sreloc
= htab
->elf
.irelplt
;
16687 htab
->local_ifunc_resolver
= 1;
16688 else if (is_static_defined (&h
->elf
))
16689 htab
->maybe_local_ifunc_resolver
= 1;
16691 if (sreloc
== NULL
)
16694 if (sreloc
->reloc_count
* sizeof (Elf64_External_Rela
)
16697 loc
= sreloc
->contents
;
16698 loc
+= sreloc
->reloc_count
++ * sizeof (Elf64_External_Rela
);
16699 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
16701 if (!warned_dynamic
16702 && !ppc64_glibc_dynamic_reloc (ELF64_R_TYPE (outrel
.r_info
)))
16704 info
->callbacks
->einfo
16705 /* xgettext:c-format */
16706 (_("%X%P: %pB: %s against %pT "
16707 "is not supported by glibc as a dynamic relocation\n"),
16709 ppc64_elf_howto_table
[ELF64_R_TYPE (outrel
.r_info
)]->name
,
16711 warned_dynamic
= TRUE
;
16714 /* If this reloc is against an external symbol, it will
16715 be computed at runtime, so there's no need to do
16716 anything now. However, for the sake of prelink ensure
16717 that the section contents are a known value. */
16720 unresolved_reloc
= FALSE
;
16721 /* The value chosen here is quite arbitrary as ld.so
16722 ignores section contents except for the special
16723 case of .opd where the contents might be accessed
16724 before relocation. Choose zero, as that won't
16725 cause reloc overflow. */
16728 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
16729 to improve backward compatibility with older
16731 if (r_type
== R_PPC64_ADDR64
)
16732 addend
= outrel
.r_addend
;
16733 /* Adjust pc_relative relocs to have zero in *r_offset. */
16734 else if (ppc64_elf_howto_table
[r_type
]->pc_relative
)
16735 addend
= outrel
.r_offset
;
16741 case R_PPC64_GLOB_DAT
:
16742 case R_PPC64_JMP_SLOT
:
16743 case R_PPC64_JMP_IREL
:
16744 case R_PPC64_RELATIVE
:
16745 /* We shouldn't ever see these dynamic relocs in relocatable
16747 /* Fall through. */
16749 case R_PPC64_PLTGOT16
:
16750 case R_PPC64_PLTGOT16_DS
:
16751 case R_PPC64_PLTGOT16_HA
:
16752 case R_PPC64_PLTGOT16_HI
:
16753 case R_PPC64_PLTGOT16_LO
:
16754 case R_PPC64_PLTGOT16_LO_DS
:
16755 case R_PPC64_PLTREL32
:
16756 case R_PPC64_PLTREL64
:
16757 /* These ones haven't been implemented yet. */
16759 info
->callbacks
->einfo
16760 /* xgettext:c-format */
16761 (_("%P: %pB: %s is not supported for `%pT'\n"),
16763 ppc64_elf_howto_table
[r_type
]->name
, sym_name
);
16765 bfd_set_error (bfd_error_invalid_operation
);
16770 /* Multi-instruction sequences that access the TOC can be
16771 optimized, eg. addis ra,r2,0; addi rb,ra,x;
16772 to nop; addi rb,r2,x; */
16778 case R_PPC64_GOT_TLSLD16_HI
:
16779 case R_PPC64_GOT_TLSGD16_HI
:
16780 case R_PPC64_GOT_TPREL16_HI
:
16781 case R_PPC64_GOT_DTPREL16_HI
:
16782 case R_PPC64_GOT16_HI
:
16783 case R_PPC64_TOC16_HI
:
16784 /* These relocs would only be useful if building up an
16785 offset to later add to r2, perhaps in an indexed
16786 addressing mode instruction. Don't try to optimize.
16787 Unfortunately, the possibility of someone building up an
16788 offset like this or even with the HA relocs, means that
16789 we need to check the high insn when optimizing the low
16793 case R_PPC64_PLTCALL_NOTOC
:
16794 if (!unresolved_reloc
)
16795 htab
->notoc_plt
= 1;
16796 /* Fall through. */
16797 case R_PPC64_PLTCALL
:
16798 if (unresolved_reloc
)
16800 /* No plt entry. Make this into a direct call. */
16801 bfd_byte
*p
= contents
+ rel
->r_offset
;
16802 insn
= bfd_get_32 (input_bfd
, p
);
16804 bfd_put_32 (input_bfd
, B_DOT
| insn
, p
);
16805 if (r_type
== R_PPC64_PLTCALL
)
16806 bfd_put_32 (input_bfd
, NOP
, p
+ 4);
16807 unresolved_reloc
= save_unresolved_reloc
;
16808 r_type
= R_PPC64_REL24
;
16812 case R_PPC64_PLTSEQ_NOTOC
:
16813 case R_PPC64_PLTSEQ
:
16814 if (unresolved_reloc
)
16816 unresolved_reloc
= FALSE
;
16821 case R_PPC64_PLT_PCREL34_NOTOC
:
16822 if (!unresolved_reloc
)
16823 htab
->notoc_plt
= 1;
16824 /* Fall through. */
16825 case R_PPC64_PLT_PCREL34
:
16826 if (unresolved_reloc
)
16828 bfd_byte
*p
= contents
+ rel
->r_offset
;
16829 bfd_put_32 (input_bfd
, PNOP
>> 32, p
);
16830 bfd_put_32 (input_bfd
, PNOP
, p
+ 4);
16831 unresolved_reloc
= FALSE
;
16836 case R_PPC64_PLT16_HA
:
16837 if (unresolved_reloc
)
16839 unresolved_reloc
= FALSE
;
16842 /* Fall through. */
16843 case R_PPC64_GOT_TLSLD16_HA
:
16844 case R_PPC64_GOT_TLSGD16_HA
:
16845 case R_PPC64_GOT_TPREL16_HA
:
16846 case R_PPC64_GOT_DTPREL16_HA
:
16847 case R_PPC64_GOT16_HA
:
16848 case R_PPC64_TOC16_HA
:
16849 if (htab
->do_toc_opt
&& relocation
+ addend
+ 0x8000 < 0x10000
16850 && !ppc64_elf_tdata (input_bfd
)->unexpected_toc_insn
)
16854 p
= contents
+ (rel
->r_offset
& ~3);
16855 bfd_put_32 (input_bfd
, NOP
, p
);
16860 case R_PPC64_PLT16_LO
:
16861 case R_PPC64_PLT16_LO_DS
:
16862 if (unresolved_reloc
)
16864 unresolved_reloc
= FALSE
;
16867 /* Fall through. */
16868 case R_PPC64_GOT_TLSLD16_LO
:
16869 case R_PPC64_GOT_TLSGD16_LO
:
16870 case R_PPC64_GOT_TPREL16_LO_DS
:
16871 case R_PPC64_GOT_DTPREL16_LO_DS
:
16872 case R_PPC64_GOT16_LO
:
16873 case R_PPC64_GOT16_LO_DS
:
16874 case R_PPC64_TOC16_LO
:
16875 case R_PPC64_TOC16_LO_DS
:
16876 if (htab
->do_toc_opt
&& relocation
+ addend
+ 0x8000 < 0x10000
16877 && !ppc64_elf_tdata (input_bfd
)->unexpected_toc_insn
)
16879 bfd_byte
*p
= contents
+ (rel
->r_offset
& ~3);
16880 insn
= bfd_get_32 (input_bfd
, p
);
16881 if ((insn
& (0x3fu
<< 26)) == 12u << 26 /* addic */)
16883 /* Transform addic to addi when we change reg. */
16884 insn
&= ~((0x3fu
<< 26) | (0x1f << 16));
16885 insn
|= (14u << 26) | (2 << 16);
16889 insn
&= ~(0x1f << 16);
16892 bfd_put_32 (input_bfd
, insn
, p
);
16896 case R_PPC64_TPREL16_HA
:
16897 if (htab
->do_tls_opt
&& relocation
+ addend
+ 0x8000 < 0x10000)
16899 bfd_byte
*p
= contents
+ (rel
->r_offset
& ~3);
16900 insn
= bfd_get_32 (input_bfd
, p
);
16901 if ((insn
& ((0x3fu
<< 26) | 0x1f << 16))
16902 != ((15u << 26) | (13 << 16)) /* addis rt,13,imm */)
16903 /* xgettext:c-format */
16904 info
->callbacks
->minfo
16905 (_("%H: warning: %s unexpected insn %#x.\n"),
16906 input_bfd
, input_section
, rel
->r_offset
,
16907 ppc64_elf_howto_table
[r_type
]->name
, insn
);
16910 bfd_put_32 (input_bfd
, NOP
, p
);
16916 case R_PPC64_TPREL16_LO
:
16917 case R_PPC64_TPREL16_LO_DS
:
16918 if (htab
->do_tls_opt
&& relocation
+ addend
+ 0x8000 < 0x10000)
16920 bfd_byte
*p
= contents
+ (rel
->r_offset
& ~3);
16921 insn
= bfd_get_32 (input_bfd
, p
);
16922 insn
&= ~(0x1f << 16);
16924 bfd_put_32 (input_bfd
, insn
, p
);
16929 /* Do any further special processing. */
16935 case R_PPC64_REL16_HA
:
16936 case R_PPC64_REL16_HIGHA
:
16937 case R_PPC64_REL16_HIGHERA
:
16938 case R_PPC64_REL16_HIGHESTA
:
16939 case R_PPC64_REL16DX_HA
:
16940 case R_PPC64_ADDR16_HA
:
16941 case R_PPC64_ADDR16_HIGHA
:
16942 case R_PPC64_ADDR16_HIGHERA
:
16943 case R_PPC64_ADDR16_HIGHESTA
:
16944 case R_PPC64_TOC16_HA
:
16945 case R_PPC64_SECTOFF_HA
:
16946 case R_PPC64_TPREL16_HA
:
16947 case R_PPC64_TPREL16_HIGHA
:
16948 case R_PPC64_TPREL16_HIGHERA
:
16949 case R_PPC64_TPREL16_HIGHESTA
:
16950 case R_PPC64_DTPREL16_HA
:
16951 case R_PPC64_DTPREL16_HIGHA
:
16952 case R_PPC64_DTPREL16_HIGHERA
:
16953 case R_PPC64_DTPREL16_HIGHESTA
:
16954 /* It's just possible that this symbol is a weak symbol
16955 that's not actually defined anywhere. In that case,
16956 'sec' would be NULL, and we should leave the symbol
16957 alone (it will be set to zero elsewhere in the link). */
16960 /* Fall through. */
16962 case R_PPC64_GOT16_HA
:
16963 case R_PPC64_PLTGOT16_HA
:
16964 case R_PPC64_PLT16_HA
:
16965 case R_PPC64_GOT_TLSGD16_HA
:
16966 case R_PPC64_GOT_TLSLD16_HA
:
16967 case R_PPC64_GOT_TPREL16_HA
:
16968 case R_PPC64_GOT_DTPREL16_HA
:
16969 /* Add 0x10000 if sign bit in 0:15 is set.
16970 Bits 0:15 are not used. */
16974 case R_PPC64_D34_HA30
:
16975 case R_PPC64_ADDR16_HIGHERA34
:
16976 case R_PPC64_ADDR16_HIGHESTA34
:
16977 case R_PPC64_REL16_HIGHERA34
:
16978 case R_PPC64_REL16_HIGHESTA34
:
16980 addend
+= 1ULL << 33;
16983 case R_PPC64_ADDR16_DS
:
16984 case R_PPC64_ADDR16_LO_DS
:
16985 case R_PPC64_GOT16_DS
:
16986 case R_PPC64_GOT16_LO_DS
:
16987 case R_PPC64_PLT16_LO_DS
:
16988 case R_PPC64_SECTOFF_DS
:
16989 case R_PPC64_SECTOFF_LO_DS
:
16990 case R_PPC64_TOC16_DS
:
16991 case R_PPC64_TOC16_LO_DS
:
16992 case R_PPC64_PLTGOT16_DS
:
16993 case R_PPC64_PLTGOT16_LO_DS
:
16994 case R_PPC64_GOT_TPREL16_DS
:
16995 case R_PPC64_GOT_TPREL16_LO_DS
:
16996 case R_PPC64_GOT_DTPREL16_DS
:
16997 case R_PPC64_GOT_DTPREL16_LO_DS
:
16998 case R_PPC64_TPREL16_DS
:
16999 case R_PPC64_TPREL16_LO_DS
:
17000 case R_PPC64_DTPREL16_DS
:
17001 case R_PPC64_DTPREL16_LO_DS
:
17002 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
17004 /* If this reloc is against an lq, lxv, or stxv insn, then
17005 the value must be a multiple of 16. This is somewhat of
17006 a hack, but the "correct" way to do this by defining _DQ
17007 forms of all the _DS relocs bloats all reloc switches in
17008 this file. It doesn't make much sense to use these
17009 relocs in data, so testing the insn should be safe. */
17010 if ((insn
& (0x3fu
<< 26)) == (56u << 26)
17011 || ((insn
& (0x3fu
<< 26)) == (61u << 26) && (insn
& 3) == 1))
17013 relocation
+= addend
;
17014 addend
= insn
& (mask
^ 3);
17015 if ((relocation
& mask
) != 0)
17017 relocation
^= relocation
& mask
;
17018 info
->callbacks
->einfo
17019 /* xgettext:c-format */
17020 (_("%H: error: %s not a multiple of %u\n"),
17021 input_bfd
, input_section
, rel
->r_offset
,
17022 ppc64_elf_howto_table
[r_type
]->name
,
17024 bfd_set_error (bfd_error_bad_value
);
17031 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
17032 because such sections are not SEC_ALLOC and thus ld.so will
17033 not process them. */
17034 howto
= ppc64_elf_howto_table
[(int) r_type
];
17035 if (unresolved_reloc
17036 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
17037 && h
->elf
.def_dynamic
)
17038 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
17039 rel
->r_offset
) != (bfd_vma
) -1)
17041 info
->callbacks
->einfo
17042 /* xgettext:c-format */
17043 (_("%H: unresolvable %s against `%pT'\n"),
17044 input_bfd
, input_section
, rel
->r_offset
,
17046 h
->elf
.root
.root
.string
);
17050 /* 16-bit fields in insns mostly have signed values, but a
17051 few insns have 16-bit unsigned values. Really, we should
17052 have different reloc types. */
17053 if (howto
->complain_on_overflow
!= complain_overflow_dont
17054 && howto
->dst_mask
== 0xffff
17055 && (input_section
->flags
& SEC_CODE
) != 0)
17057 enum complain_overflow complain
= complain_overflow_signed
;
17059 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
17060 if ((insn
& (0x3fu
<< 26)) == 10u << 26 /* cmpli */)
17061 complain
= complain_overflow_bitfield
;
17062 else if (howto
->rightshift
== 0
17063 ? ((insn
& (0x3fu
<< 26)) == 28u << 26 /* andi */
17064 || (insn
& (0x3fu
<< 26)) == 24u << 26 /* ori */
17065 || (insn
& (0x3fu
<< 26)) == 26u << 26 /* xori */)
17066 : ((insn
& (0x3fu
<< 26)) == 29u << 26 /* andis */
17067 || (insn
& (0x3fu
<< 26)) == 25u << 26 /* oris */
17068 || (insn
& (0x3fu
<< 26)) == 27u << 26 /* xoris */))
17069 complain
= complain_overflow_unsigned
;
17070 if (howto
->complain_on_overflow
!= complain
)
17072 alt_howto
= *howto
;
17073 alt_howto
.complain_on_overflow
= complain
;
17074 howto
= &alt_howto
;
17080 /* Split field relocs aren't handled by _bfd_final_link_relocate. */
17082 case R_PPC64_D34_LO
:
17083 case R_PPC64_D34_HI30
:
17084 case R_PPC64_D34_HA30
:
17085 case R_PPC64_PCREL34
:
17086 case R_PPC64_GOT_PCREL34
:
17087 case R_PPC64_TPREL34
:
17088 case R_PPC64_DTPREL34
:
17089 case R_PPC64_GOT_TLSGD34
:
17090 case R_PPC64_GOT_TLSLD34
:
17091 case R_PPC64_GOT_TPREL34
:
17092 case R_PPC64_GOT_DTPREL34
:
17093 case R_PPC64_PLT_PCREL34
:
17094 case R_PPC64_PLT_PCREL34_NOTOC
:
17096 case R_PPC64_PCREL28
:
17097 if (rel
->r_offset
+ 8 > input_section
->size
)
17098 r
= bfd_reloc_outofrange
;
17101 relocation
+= addend
;
17102 if (howto
->pc_relative
)
17103 relocation
-= (rel
->r_offset
17104 + input_section
->output_offset
17105 + input_section
->output_section
->vma
);
17106 relocation
>>= howto
->rightshift
;
17108 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
17110 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
17112 pinsn
&= ~howto
->dst_mask
;
17113 pinsn
|= (((relocation
<< 16) | (relocation
& 0xffff))
17114 & howto
->dst_mask
);
17115 bfd_put_32 (input_bfd
, pinsn
>> 32, contents
+ rel
->r_offset
);
17116 bfd_put_32 (input_bfd
, pinsn
, contents
+ rel
->r_offset
+ 4);
17118 if (howto
->complain_on_overflow
== complain_overflow_signed
17119 && (relocation
+ (1ULL << (howto
->bitsize
- 1))
17120 >= 1ULL << howto
->bitsize
))
17121 r
= bfd_reloc_overflow
;
17125 case R_PPC64_REL16DX_HA
:
17126 if (rel
->r_offset
+ 4 > input_section
->size
)
17127 r
= bfd_reloc_outofrange
;
17130 relocation
+= addend
;
17131 relocation
-= (rel
->r_offset
17132 + input_section
->output_offset
17133 + input_section
->output_section
->vma
);
17134 relocation
= (bfd_signed_vma
) relocation
>> 16;
17135 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
17137 insn
|= (relocation
& 0xffc1) | ((relocation
& 0x3e) << 15);
17138 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
17140 if (relocation
+ 0x8000 > 0xffff)
17141 r
= bfd_reloc_overflow
;
17146 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
17147 contents
, rel
->r_offset
,
17148 relocation
, addend
);
17151 if (r
!= bfd_reloc_ok
)
17153 char *more_info
= NULL
;
17154 const char *reloc_name
= howto
->name
;
17156 if (reloc_dest
!= DEST_NORMAL
)
17158 more_info
= bfd_malloc (strlen (reloc_name
) + 8);
17159 if (more_info
!= NULL
)
17161 strcpy (more_info
, reloc_name
);
17162 strcat (more_info
, (reloc_dest
== DEST_OPD
17163 ? " (OPD)" : " (stub)"));
17164 reloc_name
= more_info
;
17168 if (r
== bfd_reloc_overflow
)
17170 /* On code like "if (foo) foo();" don't report overflow
17171 on a branch to zero when foo is undefined. */
17173 && (reloc_dest
== DEST_STUB
17175 && (h
->elf
.root
.type
== bfd_link_hash_undefweak
17176 || h
->elf
.root
.type
== bfd_link_hash_undefined
)
17177 && is_branch_reloc (r_type
))))
17178 info
->callbacks
->reloc_overflow (info
, &h
->elf
.root
,
17179 sym_name
, reloc_name
,
17181 input_bfd
, input_section
,
17186 info
->callbacks
->einfo
17187 /* xgettext:c-format */
17188 (_("%H: %s against `%pT': error %d\n"),
17189 input_bfd
, input_section
, rel
->r_offset
,
17190 reloc_name
, sym_name
, (int) r
);
17193 if (more_info
!= NULL
)
17203 Elf_Internal_Shdr
*rel_hdr
;
17204 size_t deleted
= rel
- wrel
;
17206 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
17207 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
17208 if (rel_hdr
->sh_size
== 0)
17210 /* It is too late to remove an empty reloc section. Leave
17212 ??? What is wrong with an empty section??? */
17213 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
17216 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
17217 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
17218 input_section
->reloc_count
-= deleted
;
17221 /* If we're emitting relocations, then shortly after this function
17222 returns, reloc offsets and addends for this section will be
17223 adjusted. Worse, reloc symbol indices will be for the output
17224 file rather than the input. Save a copy of the relocs for
17225 opd_entry_value. */
17226 if (is_opd
&& (info
->emitrelocations
|| bfd_link_relocatable (info
)))
17229 amt
= input_section
->reloc_count
* sizeof (Elf_Internal_Rela
);
17230 rel
= bfd_alloc (input_bfd
, amt
);
17231 BFD_ASSERT (ppc64_elf_tdata (input_bfd
)->opd
.relocs
== NULL
);
17232 ppc64_elf_tdata (input_bfd
)->opd
.relocs
= rel
;
17235 memcpy (rel
, relocs
, amt
);
17240 /* Adjust the value of any local symbols in opd sections. */
17243 ppc64_elf_output_symbol_hook (struct bfd_link_info
*info
,
17244 const char *name ATTRIBUTE_UNUSED
,
17245 Elf_Internal_Sym
*elfsym
,
17246 asection
*input_sec
,
17247 struct elf_link_hash_entry
*h
)
17249 struct _opd_sec_data
*opd
;
17256 opd
= get_opd_info (input_sec
);
17257 if (opd
== NULL
|| opd
->adjust
== NULL
)
17260 value
= elfsym
->st_value
- input_sec
->output_offset
;
17261 if (!bfd_link_relocatable (info
))
17262 value
-= input_sec
->output_section
->vma
;
17264 adjust
= opd
->adjust
[OPD_NDX (value
)];
17268 elfsym
->st_value
+= adjust
;
17272 /* Finish up dynamic symbol handling. We set the contents of various
17273 dynamic sections here. */
17276 ppc64_elf_finish_dynamic_symbol (bfd
*output_bfd
,
17277 struct bfd_link_info
*info
,
17278 struct elf_link_hash_entry
*h
,
17279 Elf_Internal_Sym
*sym
)
17281 struct ppc_link_hash_table
*htab
;
17282 struct plt_entry
*ent
;
17284 htab
= ppc_hash_table (info
);
17288 if (!htab
->opd_abi
&& !h
->def_regular
)
17289 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
17290 if (ent
->plt
.offset
!= (bfd_vma
) -1)
17292 /* Mark the symbol as undefined, rather than as
17293 defined in glink. Leave the value if there were
17294 any relocations where pointer equality matters
17295 (this is a clue for the dynamic linker, to make
17296 function pointer comparisons work between an
17297 application and shared library), otherwise set it
17299 sym
->st_shndx
= SHN_UNDEF
;
17300 if (!h
->pointer_equality_needed
)
17302 else if (!h
->ref_regular_nonweak
)
17304 /* This breaks function pointer comparisons, but
17305 that is better than breaking tests for a NULL
17306 function pointer. */
17313 && (h
->root
.type
== bfd_link_hash_defined
17314 || h
->root
.type
== bfd_link_hash_defweak
)
17315 && (h
->root
.u
.def
.section
== htab
->elf
.sdynbss
17316 || h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
))
17318 /* This symbol needs a copy reloc. Set it up. */
17319 Elf_Internal_Rela rela
;
17323 if (h
->dynindx
== -1)
17326 rela
.r_offset
= defined_sym_val (h
);
17327 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_PPC64_COPY
);
17329 if (h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
17330 srel
= htab
->elf
.sreldynrelro
;
17332 srel
= htab
->elf
.srelbss
;
17333 loc
= srel
->contents
;
17334 loc
+= srel
->reloc_count
++ * sizeof (Elf64_External_Rela
);
17335 bfd_elf64_swap_reloca_out (output_bfd
, &rela
, loc
);
17341 /* Used to decide how to sort relocs in an optimal manner for the
17342 dynamic linker, before writing them out. */
17344 static enum elf_reloc_type_class
17345 ppc64_elf_reloc_type_class (const struct bfd_link_info
*info
,
17346 const asection
*rel_sec
,
17347 const Elf_Internal_Rela
*rela
)
17349 enum elf_ppc64_reloc_type r_type
;
17350 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
17352 if (rel_sec
== htab
->elf
.irelplt
)
17353 return reloc_class_ifunc
;
17355 r_type
= ELF64_R_TYPE (rela
->r_info
);
17358 case R_PPC64_RELATIVE
:
17359 return reloc_class_relative
;
17360 case R_PPC64_JMP_SLOT
:
17361 return reloc_class_plt
;
17363 return reloc_class_copy
;
17365 return reloc_class_normal
;
17369 /* Finish up the dynamic sections. */
17372 ppc64_elf_finish_dynamic_sections (bfd
*output_bfd
,
17373 struct bfd_link_info
*info
)
17375 struct ppc_link_hash_table
*htab
;
17379 htab
= ppc_hash_table (info
);
17383 dynobj
= htab
->elf
.dynobj
;
17384 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
17386 if (htab
->elf
.dynamic_sections_created
)
17388 Elf64_External_Dyn
*dyncon
, *dynconend
;
17390 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
17393 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
17394 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
17395 for (; dyncon
< dynconend
; dyncon
++)
17397 Elf_Internal_Dyn dyn
;
17400 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
17407 case DT_PPC64_GLINK
:
17409 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
17410 /* We stupidly defined DT_PPC64_GLINK to be the start
17411 of glink rather than the first entry point, which is
17412 what ld.so needs, and now have a bigger stub to
17413 support automatic multiple TOCs. */
17414 dyn
.d_un
.d_ptr
+= GLINK_PLTRESOLVE_SIZE (htab
) - 8 * 4;
17418 s
= bfd_get_section_by_name (output_bfd
, ".opd");
17421 dyn
.d_un
.d_ptr
= s
->vma
;
17425 if ((htab
->do_multi_toc
&& htab
->multi_toc_needed
)
17426 || htab
->notoc_plt
)
17427 dyn
.d_un
.d_val
|= PPC64_OPT_MULTI_TOC
;
17428 if (htab
->has_plt_localentry0
)
17429 dyn
.d_un
.d_val
|= PPC64_OPT_LOCALENTRY
;
17432 case DT_PPC64_OPDSZ
:
17433 s
= bfd_get_section_by_name (output_bfd
, ".opd");
17436 dyn
.d_un
.d_val
= s
->size
;
17440 s
= htab
->elf
.splt
;
17441 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
17445 s
= htab
->elf
.srelplt
;
17446 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
17450 dyn
.d_un
.d_val
= htab
->elf
.srelplt
->size
;
17454 if (htab
->local_ifunc_resolver
)
17455 info
->callbacks
->einfo
17456 (_("%X%P: text relocations and GNU indirect "
17457 "functions will result in a segfault at runtime\n"));
17458 else if (htab
->maybe_local_ifunc_resolver
)
17459 info
->callbacks
->einfo
17460 (_("%P: warning: text relocations and GNU indirect "
17461 "functions may result in a segfault at runtime\n"));
17465 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
17469 if (htab
->elf
.sgot
!= NULL
&& htab
->elf
.sgot
->size
!= 0
17470 && htab
->elf
.sgot
->output_section
!= bfd_abs_section_ptr
)
17472 /* Fill in the first entry in the global offset table.
17473 We use it to hold the link-time TOCbase. */
17474 bfd_put_64 (output_bfd
,
17475 elf_gp (output_bfd
) + TOC_BASE_OFF
,
17476 htab
->elf
.sgot
->contents
);
17478 /* Set .got entry size. */
17479 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
17483 if (htab
->elf
.splt
!= NULL
&& htab
->elf
.splt
->size
!= 0
17484 && htab
->elf
.splt
->output_section
!= bfd_abs_section_ptr
)
17486 /* Set .plt entry size. */
17487 elf_section_data (htab
->elf
.splt
->output_section
)->this_hdr
.sh_entsize
17488 = PLT_ENTRY_SIZE (htab
);
17491 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
17492 brlt ourselves if emitrelocations. */
17493 if (htab
->brlt
!= NULL
17494 && htab
->brlt
->reloc_count
!= 0
17495 && !_bfd_elf_link_output_relocs (output_bfd
,
17497 elf_section_data (htab
->brlt
)->rela
.hdr
,
17498 elf_section_data (htab
->brlt
)->relocs
,
17502 if (htab
->glink
!= NULL
17503 && htab
->glink
->reloc_count
!= 0
17504 && !_bfd_elf_link_output_relocs (output_bfd
,
17506 elf_section_data (htab
->glink
)->rela
.hdr
,
17507 elf_section_data (htab
->glink
)->relocs
,
17512 if (htab
->glink_eh_frame
!= NULL
17513 && htab
->glink_eh_frame
->size
!= 0
17514 && htab
->glink_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
17515 && !_bfd_elf_write_section_eh_frame (output_bfd
, info
,
17516 htab
->glink_eh_frame
,
17517 htab
->glink_eh_frame
->contents
))
17520 /* We need to handle writing out multiple GOT sections ourselves,
17521 since we didn't add them to DYNOBJ. We know dynobj is the first
17523 while ((dynobj
= dynobj
->link
.next
) != NULL
)
17527 if (!is_ppc64_elf (dynobj
))
17530 s
= ppc64_elf_tdata (dynobj
)->got
;
17533 && s
->output_section
!= bfd_abs_section_ptr
17534 && !bfd_set_section_contents (output_bfd
, s
->output_section
,
17535 s
->contents
, s
->output_offset
,
17538 s
= ppc64_elf_tdata (dynobj
)->relgot
;
17541 && s
->output_section
!= bfd_abs_section_ptr
17542 && !bfd_set_section_contents (output_bfd
, s
->output_section
,
17543 s
->contents
, s
->output_offset
,
17551 #include "elf64-target.h"
17553 /* FreeBSD support */
17555 #undef TARGET_LITTLE_SYM
17556 #undef TARGET_LITTLE_NAME
17558 #undef TARGET_BIG_SYM
17559 #define TARGET_BIG_SYM powerpc_elf64_fbsd_vec
17560 #undef TARGET_BIG_NAME
17561 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
17564 #define ELF_OSABI ELFOSABI_FREEBSD
17567 #define elf64_bed elf64_powerpc_fbsd_bed
17569 #include "elf64-target.h"